anchor.diff:                                      (symbol (string-downcase item))
                                       (otherwise item))) (cons name args)))))
         (error "Please assign a shell function to ~S" '*shell*)))
  -  
  +
   (defmacro defcommand (name &optional docstring)
     "Define a macro named NAME taking any number of arguments, and
   calling the external program of same name thru the shell."
  
positive.code:                      (otherwise (format nil "~A" (car args))))))
        (if (and (< 0 (length current))
                 (char= (character "-") (char current 0)))
             (push current options)
             (push current arguments)))))
  
  
  (defun relativize (path default)
  
negative.code:             to load files.
  "
    (loop
      (let* ((subdirs     (sort (subdirectories-names (working-directory))
                                (function string<)))
             (files       (sort (files (working-directory) :type "lisp")
                                (lambda (a b) (string< (car a) (car b)))))
             (item-count  (+ (length subdirs) (length files)))
             (count-width (if (= 0 item-count) 1 (ceiling (log item-count 10)))))
        (format t "~&")
        (format t "--- current directory ----------------------------~%")
        (format t "~V,A  ~A~%" count-width "" (working-directory))
        (format t "--- parent directory ----------------------------~%")
        (format t "~V,D) ~A~%"
                count-width 0 (parent-directory (working-directory)))
        (when subdirs
          (format t "--- subdirectories -------------------------------~%")
          (print-list t subdirs 1 :index-width count-width))
        (when files
          (format t "--- files ----------------------------------------~%")
          (print-list t (mapcar (function car) files)
                      (1+ (length subdirs)) :index-width count-width))
        (format t "--------------------------------------------------~%")
        (let ((answer
                (block :answer
                  (loop
                    (format t "~&Change directory number, ~
                              load file number, or -1 to quit: ")
                    (finish-output)
                    (let ((answer (read t nil nil)))
                      (typecase answer
                        (integer (if (<= -1 answer item-count)
                                     (return-from :answer answer)
                                     (format t "~&Input out of range.~%")))
                        (otherwise (format t "~&Bad input type.~%"))))))))
          (cond
            ((= -1 answer) (return))
            ((= 0 answer)
             (change-working-directory (parent-directory (working-directory))))
            ((<= answer (length subdirs))
             (change-working-directory 
              (child-directory (working-directory) (elt subdirs (1- answer)))))
            (t (load (cdr (elt files (- answer (length subdirs) 1)))
                     :verbose t)))))))
  
  
  (defun resolve (path &key (directory nil))
    (setf path (typecase path
  