anchor.diff:  
   (defclass parse-tree ()
     ((start-mark :initform nil :initarg :start-mark :reader start-mark)
  -   (size :initform nil :initarg :size)))
  -
  -(defgeneric start-offset (parse-tree))
  +   (size :initform nil :initarg :size))
  +  (:documentation "The base class for all parse trees."))
  +
  +(defgeneric start-offset (parse-tree)
  +  (:documentation "The offset in the buffer of the first
  +character of a parse tree."))
   
   (defmethod start-offset ((tree parse-tree))
     (let ((mark (start-mark tree)))
  
positive.code: 
  
  (defmacro grammar (&body body)
    (let ((rule (gensym "RULE"))
  	(rules (gensym "RULES"))
  	(result (gensym "RESULT")))
  
negative.code: ;;; lexer
  
  (defclass lexer ()
    ((buffer :initarg :buffer
             :reader buffer
             :documentation "The buffer associated with the
  lexer."))
    (:documentation "The base class for all lexers."))
  
  (defgeneric nb-lexemes (lexer)
    (:documentation "Return the number of lexemes in the lexer."))
  
  (defgeneric lexeme (lexer pos)
    (:documentation "Given a lexer and a position, return the
  lexeme in that position in the lexer."))
  
  (defgeneric insert-lexeme (lexer pos lexeme)
    (:documentation "Insert a lexeme at the position in the lexer.
  All lexemes following POS are moved to one position higher."))
  
  (defgeneric delete-invalid-lexemes (lexer from to)
    (:documentation "Invalidate all lexemes that could have changed
  as a result of modifications to the buffer"))
  
  (defgeneric inter-lexeme-object-p (lexer object)
    (:documentation "This generic function is called by the
  incremental lexer to determine whether a buffer object is an
  inter-lexeme object, typically whitespace. Client code must
  supply a method for this generic function."))
  
  (defgeneric skip-inter-lexeme-objects (lexer scan)
    (:documentation "This generic function is called by the
  incremental lexer to skip inter-lexeme buffer objects.  The
  default method for this generic function increments the scan mark
  until the object after the mark is not an inter-lexeme object, or
  until the end of the buffer has been reached."))
  
  (defgeneric update-lex (lexer start-pos end)
    (:documentation "This function is called by client code as part
  of the buffer-update protocol to inform the lexer that it needs
  to analyze the contents of the buffer at least up to the `end'
  mark of the buffer.  `start-pos' is the position in the lexeme
  sequence at which new lexemes should be inserted."))
  
  (defgeneric next-lexeme (lexer scan)
    (:documentation "This generic function is called by the
  incremental lexer to get a new lexeme from the buffer.  Client
  code must supply a method for this function that specializes on
  the lexer class.  It is guaranteed that scan is not at the end of
  the buffer, and that the first object after scan is not an
  inter-lexeme object.  Thus, a lexeme should always be returned by
  this function."))
  
  (defclass incremental-lexer (lexer)
    ((lexemes :initform (make-instance 'standard-flexichain) :reader lexemes))
    (:documentation "A subclass of lexer which maintains the buffer
  in the form of a sequence of lexemes that is updated
  incrementally."))
  
  (defmethod nb-lexemes ((lexer incremental-lexer))
    (nb-elements (lexemes lexer)))
  