anchor.diff:               (error "Unexpected character: ~a~%" next-character))
            :finally (return-from nil (nreverse character-buffer)))))
   
  -(defun skip-string-literal )
  +(defun collect-string* (stream delimiter)
  +  (loop for current-character = (next stream)
  +     until (null (next stream))
  +     collect (collect-character-while stream #'(lambda (character)
  +                                                 (not (char= character delimiter))))))
   
  -(defun skip-character-while (predicate stream)
  -  (declare (ignore next-is-valid-predicate))
  -  (loop for next-character = (next stream) 
  -     do (cond ((funcall predicate next-character) (pop! stream))
  -              (t (return-from nil next-character)))))
  +(defun collect-string-while (stream predicate) ())
   
  -(defun skip-character (skip-character stream)
  +(defun skip-character (stream skip-character)
     (loop for next-character = (next stream) ;until (null next-character)
        do (if (char= next-character skip-character)
               (pop! stream)
               (return-from nil next-character))))
   
  -(defun skip-n-characters (n stream)
  +(defun skip-character* (stream skip-character) ())
  +
  +(defun skip-character-while (stream predicate)
  +  (loop for next-character = (next stream)
  +     do (cond ((funcall predicate next-character) (pop! stream))
  +              (t (return-from nil next-character)))))
  +
  +
  +(defun skip-n-characters (stream n)
     (loop for remainder upto (1- n)
        do (pop! stream)
        :finally (next stream)))
   
   ;;; PARSER GENERATOR
  -(defmacro deftoken (name &optional &key (from nil) (read nil) (cond #'characterp)
  -                                     (word nil) (char nil) (drop t) (bans nil)
  -                                     (mult nil) (deli nil) (after nil))
  -  (let ((token-function-body
  -         (cond (from `(cond-dispatch-collector stream ,from))
  -               (mult `(collect-token-repeatedly-with (resolve-to-string ,after) ,mult))
  -               (read (if bans
  -                         `(collect-character-while
  -                           stream #'(lambda (character)
  -                                      (or (not (member character ,bans))
  -                                          (error "Invalid character: ~a" (char-name character)))))
  -                          `(seqv-dispatch-collector stream ,read)))
  -               (cond `(collect-character-while stream ,cond))
  -               (word `(collect-string-literal stream ,word))
  -               (char (if drop
  -                         `(skip-character ,char)
  -                         `(collect-character stream ,char)))
  -               (t (format t "Unrecognized token description")))))
  -    `(defun ,name (stream)
  -       ,token-function-body)))
  +(defun sequentially-resolve-tokens (stream token-list)
  +  (mapcar #'(lambda (token) (funcall token stream)) token-list))
  +
  +(defun conditionally-resolve-tokens (stream token-list)
  +  (format t "Conditionally choose from ~a for ~a~%" token-list stream))
  +
  +(defun repeat-resolve-tokens (stream token-list)
  +  (format t "repeat-resolve-tokens ~a ~a." stream token-list))
  +
  +(defun resolve-banlist (directives)
  +  (format t "A list of characters is returned from ~a~%" directives))
   
   (defmacro defparser (name &rest tokens)
     (labels ((string-to-symbol (&rest arguments)
  
positive.code: 
  (defun collect-character (stream character)
    (let ((next-character (read-char stream nil)))
      (or (when (char= next-character character) 
            next-character)
          (error "Unexpected character: ~a~%" next-character))))
  
  (defun collect-character-while (stream predicate)
    (loop for current-character = (pop! stream)
  
negative.code: ;;; PARSING UTILITIES
  (defun next (stream) (peek-char nil stream nil nil))
  
  