anchor.diff:      (symbols-that-should-be-documented
        packages :excluded-packages excluded-packages
        :excluded-symbols excluded-symbols) 
  -    (symbols-documented-by-documents multi-doc))
  +    (symbols-documented-by-documents multi-doc default-package))
      #'string-lessp))
    
   #+ignore
  
positive.code: 			 *package*))
  	  (os *output-stream*))
        (format os "~&<div id='symbols-not-documented' class='markdown-report'>~%")
        (format os "~&<h1>Symbols that are not documented</h1>~%")
        (cond (packages
  	     (format os "~&<div>~%")
  	     (format os "~&<h2>From packages:</h2>~%")
  	     (format os "~&~{~&<span>~a</span>~^ ~}"
  		     (mapcar #'package-name packages))
  	     (format os "~&</div>~%")
  	     (format os "~&<h2>Symbols</h2>~%")
  	     (loop for s in (symbols-not-documented-by-multi-document
  			     documents
  			     packages
  			     :excluded-symbols excluded)
  		do (format os "~&<span>~s</span>~%" s))
  	     (when excluded
  	       (format os "~&<div class='excluded-symbols'>~%")
  	       (format os "~&<h2>Ignoring ~d symbols</h2>~%"
  		       (length excluded))
  	       (unless donot-display-excluded-symbols
  		 (format 
  		  os "~&~{<span class='excluded-symbol'>~s</span>~^~%~}~%"
  		  excluded))
  	       (format os "~&</div>~%")))
  	    (t
  	     (format os "~&<p>There are no packages specified by the 
  propoerty :documentation-packages~%")))
        (format os "~&</div>~%"))))
  
  (defextension (markdown-warnings-report
  	       :arguments ())
    (when (eq phase :render)
      (let ((os *output-stream*)
  	  (documents (document-property :documentation-documents))
  	  (warnings? nil))
        (format os "~&<div id='markdown-warnings' class='markdown-report'>~%")
        (format os "~&<h1>Markdown Warnings</h1>~%")
  
        (loop for document in (ensure-list documents) do
  	   (when (warnings document)
  	     (setf warnings? t)
  	     (format os "~&<div>~%")
  	     (let ((source (source document)))
  	       (format os "~&<h2>~a</h2>~%"
  		       (typecase source
  			 (pathname source)
  			 (string 
  			  (format nil "~a~@[...~]"
  				  (subseq source 0 (min 50 (length source)))
  				  (> (length source) 50)))
  			 (t (format nil "Something of type ~s"
  				    (type-of source))))))
  	     (format os "~&<ul>~%")
  	     (loop for warning in (warnings document) do
  		  (format os "~&<li>~a</li>~%" warning))
  	     (format os "~&</ul>~%")
  	     (format os "~&</div>~%")))
  
negative.code: 	    symbols-documented-by-documents
  	    symbols-not-documented-by-multi-document 
  	    )))
  
  (defmethod documents ((document document)) (list document))
  
  (defmethod documents ((document multi-document)) (children document))
  
  (defun build-documentation-report (source target document packages
  				   &key (format :html) excluded-symbols
  				   docs-package search-locations)
    (cl-markdown:markdown  
     source
     :format format
     :stream target
     :additional-extensions '(unmentioned-symbols-report
  			    unused-exported-symbols-report
  			    markdown-warnings-report
  			    documented-symbols-report)
     :properties `((:documentation-document
  		  . ,document)
  		 (:documentation-documents
  		  . ,(documents document))
  		 (:documentation-packages 
  		  . ,(ensure-list packages))
  		 (:documentation-excluded-symbols 
  		  . ,excluded-symbols)
  		 ,@(when docs-package
  			 `((:docs-package . ,(find-package docs-package))))
  		 (:search-locations 
  		  . ,(append 
  		      (list
  		       (system-relative-pathname 'cl-markdown "resources/"))
  		      (ensure-list search-locations)))
  		 (:style-sheet . "markdown-report-styles.css"))))
  
  (defun symbols-defined-by-packages (packages &key excluded-symbols)
    (sort 
     (remove-duplicates
      (loop for package in (ensure-list packages) append
  	 (let ((package (find-package package)))
  	   (loop for s being the symbols
  	      of package when 
  	      (and (eql package (symbol-package s))
  		   (or (fboundp s)
  		       (boundp s)
  		       (find-class s nil)
  		       (get s 'prolog:functor)
  		       (eq (system:variable-information s) :special)
  		       (member s excluded-symbols)
  		       #+allegro
  		       (symbol-is-type-specifier-p s)
  		       ;; Could check deftypes if necessary.
  		       ))
  	      collect s))))
     'string< :key 'symbol-name))
  
  (defun symbols-exported-with-no-definition (packages &key excluded-symbols)
   (sort 
  