anchor.diff:  DO:         Same as more, but force no pagination.
   "
     (apply (function more) :page nil paths))
  -  
  +
   
   (defvar *directory-stack* nil)
   
  
positive.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
  
negative.code:   *working-directory*)
  
  
  
  (defun parent-directory (dirpath)
    (make-pathname :directory (let ((dir (pathname-directory dirpath)))
                                (cons (car dir) (butlast (cdr dir))))
  