anchor.diff:               :format-control ":ELEMENT-TYPE is not permitted."
                :class :bad-argument))
       (setf (aref *file-table* fid)
  -          (apply 'open path
  +          (apply 'open (parse-path path)
                    :element-type '(unsigned-byte 8)
                    keys))
       (format *client* "~D~%" fid)))
  
positive.code:                       (destructuring-bind ,lambda-list (rest ,args)
                          ,@body)))))
  
  (defcommand :open (path &rest keys &key &allow-other-keys)
    (let ((fid (loop
                  for i from 0
                  for entry across *file-table*
                  do (when (eql entry nil)
                       (return i)))))
      (format t "Keys ~S~%" keys)
      (unless fid
        (error 'error-with-class
               :format-control "Too many open files."
  
negative.code:   (format *client* "~S~%"
            (list* :ok
                   (mapcar (lambda (path)
                             (unparse-namestring
                              (namestring path)))
                           (directory (parse-path path))))))
  
  (defcommand :probe (path)
    (if (probe-file (parse-path path))
        (format *client* ":ok~%")
        (format *client* "(:not-found \"File not found\")~%")))
  
  (defcommand :create (path)
    (if (open (parse-path path) :direction :probe :if-exists nil :if-does-not-exist :create)
        (format *client* ":ok~%")
        (format *client* "(:error \"???\")~%")))
  
  #-mezzano
  (defcommand :backup (path)
    (when (open (parse-path path) :direction :probe)
      (cl-fad:copy-file (parse-path path) (format nil "~A~~" (parse-path path))
                        :overwrite t))
    (format *client* ":ok~%"))
  
  (defcommand :restore (path)
    (let ((backup (format nil "~A~~" (parse-path path))))
      (when (open backup :direction :probe)
        (rename-file backup (parse-path path)))
      (format *client* ":ok~%")))
  
  (defcommand :create-directory (path)
    (multiple-value-bind (_ created)
        (ensure-directories-exist (parse-path path))
      (declare (ignore _))
      (if created
          (format *client* ":ok~%")
          (format *client* ":exists~%"))))
  
  (defcommand :rename-file (source dest)
    (rename-file (parse-path source) (parse-path dest))
    (format *client* ":ok~%"))
  
  (defcommand :file-write-date (path)
    (format *client* "~D~%" (file-write-date (parse-path path))))
  
  (defcommand :delete (path)
    (if (or (pathname-name (parse-path path)) (pathname-type (parse-path path)))
        (delete-file (parse-path path))
        #+sbcl (sb-posix:rmdir (parse-path path))
        #-sbcl (error "delete of directories not implemented"))
    (format *client* ":ok~%"))
  
  