anchor.diff:          (raw-stream all-chars consumed-chars last-char-status
                       first-consumed-character-position)
         stream
  -    (let ((char (if hang-p
  -                    (read-char raw-stream nil :eof)
  -                    (read-char-no-hang raw-stream nil :eof))))
  +    (let* ((consume-p (lexer-context-consume-p stream))
  +           (needs-position-record
  +            (and
  +             (not (slot-boundp stream 'first-consumed-character-position))
  +             consume-p))
  +           (position-record
  +            (when needs-position-record
  +              (make-position-record-from-positional-stream raw-stream)))
  +           (char (if hang-p
  +                     (read-char raw-stream nil :eof)
  +                     (read-char-no-hang raw-stream nil :eof))))
  +      (when needs-position-record
  +        (if (eq char :eof)
  +            (setf first-consumed-character-position nil)
  +            (setf first-consumed-character-position position-record)))
         (cond
           ((and (not hang-p)
                 (not char)))
           ((eq char :eof)
            (setf last-char-status nil))
  -        ((lexer-context-consume-p stream)
  +        (consume-p
            (vector-push-extend char all-chars)
            (vector-push-extend char consumed-chars)
  -         (unless (slot-boundp stream 'first-consumed-character-position)
  -           (setf first-consumed-character-position (make-position-record-from-positional-stream raw-stream)))
            (setf last-char-status 'consumed))
           (t
            (vector-push-extend char all-chars)
  
positive.code:     (let ((final-value (if (equal 1 (length new-parts))
                             (aref new-parts 0)
                             (make-instance 'compound-word :parts new-parts :value nil))))
        (make-instance 'assignment-word :name name :value-word final-value :value raw))))
  
  (define-data name (simple-word)
    ()
  
negative.code: (define-reserved-word bang "!")
  (define-reserved-word in "in")
  
  (defun make-reserved (string &rest initargs)
    (apply 'make-instance (fset:lookup *reserved-words* string) initargs))
  
  (defun reserved-p (word)
    (fset:lookup *reserved-words* word))
  