anchor.diff:  
   (defmethod sys.gray:stream-read-sequence ((stream fat32-file-stream) sequence &optional (start 0) end)
     (assert (member (direction stream) '(:input :io)))
  -  (error "Feature not implemented"))
  +  (error "Feature not implemented: ~a" 'sys.gray:stream-read-sequence))
   
   (defmethod sys.gray:stream-write-char ((stream fat32-file-character-stream) char)
  -  (error "Feature not implemented"))
  +  (error "Feature not implemented: ~a" 'sys.gray:stream-write-char))
   
   (defmethod sys.gray:stream-read-sequence ((stream fat32-file-character-stream) sequence &optional (start 0) end)
     (assert (member (direction stream) '(:input :io)))
  -  (error "Feature not implemented"))
  +  (error "Feature not implemented: ~a" 'sys.gray:stream-read-sequence))
   
   (defmethod sys.gray:stream-read-char ((stream fat32-file-character-stream))
     (assert (member (direction stream) '(:input :io)))
  
positive.code: (defmethod host-default-device ((host fat32-host))
    nil)
  
  (defmethod parse-namestring-using-host ((host fat32-host) namestring junk-allowed)
    (assert (not junk-allowed) (junk-allowed) "Junk-allowed not implemented yet")
    (let ((start 0)
          (end (length namestring))
          (directory '())
          (name "")
          (type ""))
  
      (loop for i from start to (1- end)
         for char = (aref namestring i)
         :do (when (char= char #\>)
               (unless (< i 1)
                 (progn (push (subseq namestring (1+ start) i) directory)
                        (setf start i)))))
  
      (loop for i from start to (1- end)
         for char = (aref namestring i)
         :initially (setf name (subseq namestring (1+ start) end))
         :do (cond ((char= char #\.)
                    (progn (setf name (subseq namestring (1+ start) i)
                                 type (subseq namestring (1+ i) end))
                           (return)))))
  
      (make-pathname :host host
                     :directory directory
                     :name name
                     :type type
                     :version :newest)))
  
  (defmethod unparse-pathname (pathname (host fat32-host))
    (let ((dir (pathname-directory pathname))
          (name (pathname-name pathname))
          (type (pathname-type pathname)))
      (values dir
              (if (string= "" type)
                  name
                  (format nil "~a.~a" name type)))))
  
  (defclass fat32-file-stream (sys.gray:fundamental-binary-input-stream
                               sys.gray:fundamental-binary-output-stream
  
negative.code:         instance))
  
  ;; Read some file
  (with-open-file (file #P"FAT32:>dir1>log-1") ; put your file path
    (loop for line = (read-line file nil nil)
       while line do (print line)))
  |#
  