anchor.diff:  
   
   
  +(defun lisp-version ()
  +  (let ((v (lisp-implementation-version)))
  +    (when (prefixp "Version " v)
  +      (setf v (subseq v (length "Version "))))
  +    (with-output-to-string (out)
  +      (with-input-from-string (inp v)
  +        (loop
  +          :with state = :normal
  +          :for ch = (read-char inp nil nil)
  +          :while ch
  +          :do (if (char= ch #\space)
  +                  (when (eq state :normal)
  +                    (setf state :space)
  +                    (write-char #\_ out))
  +                  (progn
  +                    (setf state :normal)
  +                    (case ch
  +                      ((#\( #\))) ; deleted characters
  +                      ((#\-) ; substituted characters
  +                       (write-char #\_ out))
  +                      (otherwise ; plain characters
  +                       (write-char ch out))))))))))
  +
  +;; (list (lisp-implementation-version) (lisp-version))
   
   (defun executable-name (base)
  -  (format nil "~(~A-~A-~{~A-~A-~A~}-~A~)"
  +  (format nil "~(~A-~A-~A-~{~A-~A-~A~}-~A~)"
             base
             (or (lisp-implementation-type-keyword) "unknown")
  +          (lisp-version)
             (distribution)
             (or (machine-type-keyword) "unknown")))
  -
   
   
   (defun executable-filename (base)
     (format nil "~A~A" (executable-name base)
             #+(or windows win32) ".exe"
             #-(or windows win32) ""))
  -
   
   
   (defun date ()
  
positive.code:     (format t "~V,,,'-<~>  ~V,,,'-<~>~%" system-width license-width)))
  
  
  (defun write-manifest-file (program-name system)
    "
  DO:     write a {program-name}-{distribution}.manifest file for the given SYSTEM.
  "
  
negative.code: (defparameter *system-licenses*
    '(("cl-ppcre"       . "BSD-2")
      ("split-sequence" . :unknown)
      ("terminfo"       . "MIT")
      ("closer-mop"     . "MIT")))
  
  (defun asdf-system-name (system)
    (slot-value system 'asdf::name))
  
  (defun asdf-system-license (system-name)
    (let ((system  (asdf:find-system system-name)))
      (or (cdr (assoc system-name *system-licenses* :test 'string-equal))
          (and (slot-boundp system 'asdf::licence)
               (slot-value system 'asdf::licence))
          :unknown)))
  
  (defun system-depends-on (system)
    (delete (string-downcase system)
  