anchor.diff:  ;;; because the order that the tokens appear in this list is significant.
   (defparameter *operator-tokens* nil)
   
  -;;; These are keyword tokens ???
  -(defparameter *keyword-tokens* nil)
  +;;; These are keyword tokens ??? Necessary?
  +(defparameter *keyword-symbols* nil)
   
   ;; end of input
   (deftoken :eoi)
   
   ;; Compound assignment operators
  -(deftoken :times-equals   "*=" :operator)
  -(deftoken :divide-equals  "/=" :operator)
  -(deftoken :mod-equals     "%=" :operator)
  -(deftoken :plus-equals    "+=" :operator)
  -(deftoken :minus-equals   "-=" :operator)
  -(deftoken :lshift-equals  "<<=" :operator)
  -(deftoken :rshift-equals  ">>=" :operator)
  -(deftoken :urshift-equals ">>>=" :operator)
  -(deftoken :and-equals     "&=" :operator)
  -(deftoken :xor-equals     "^=" :operator)
  -(deftoken :or-equals      "|=" :operator)
  +(deftoken :times-equals   "*=" :operator-token)
  +(deftoken :divide-equals  "/=" :operator-token)
  +(deftoken :mod-equals     "%=" :operator-token)
  +(deftoken :plus-equals    "+=" :operator-token)
  +(deftoken :minus-equals   "-=" :operator-token)
  +(deftoken :lshift-equals  "<<=" :operator-token)
  +(deftoken :rshift-equals  ">>=" :operator-token)
  +(deftoken :urshift-equals ">>>=" :operator-token)
  +(deftoken :and-equals     "&=" :operator-token)
  +(deftoken :xor-equals     "^=" :operator-token)
  +(deftoken :or-equals      "|=" :operator-token)
   
   ;; Operators and punctuators
   (deftoken :newline      (format nil "~%"))
  -(deftoken :semicolon    ";" :operator)
  -(deftoken :comma        "," :operator)
  -(deftoken :hook         "?" :operator)
  -(deftoken :colon        ":" :operator)
  +(deftoken :semicolon    ";" :operator-token)
  +(deftoken :comma        "," :operator-token)
  +(deftoken :hook         "?" :operator-token)
  +(deftoken :colon        ":" :operator-token)
   (deftoken :conditional)
  -(deftoken :bar2         "||" :operator)
  -(deftoken :ampersand2   "&&" :operator)
  -(deftoken :bar          "|" :operator)
  -(deftoken :caret        "^" :operator)
  -(deftoken :ampersand    "&" :operator)
  -(deftoken :equals3      "===" :operator)
  -(deftoken :not-equals2  "!==" :operator)
  -(deftoken :equals2      "==" :operator)
  -(deftoken :equals       "=" :operator)
  -(deftoken :not-equals   "!=" :operator)
  -(deftoken :urshift      ">>>" :operator)
  -(deftoken :lshift       "<<" :operator)
  -(deftoken :rshift       ">>" :operator)
  -(deftoken :less-than    "<" :operator)
  -(deftoken :less-than-equals "<=" :operator)
  -(deftoken :greater-than ">" :operator)
  -(deftoken :greater-than-equals ">=" :operator)
  -
  -(deftoken :asterisk     "*" :operator)
  -(deftoken :slash        "/" :operator)
  -(deftoken :percent      "%" :operator)
  -(deftoken :bang         "!" :operator)
  -(deftoken :tilde        "~" :operator)
  -(deftoken :unary-plus)
  -(deftoken :unary-minus)
  -(deftoken :plus2        "++" :operator)
  -(deftoken :minus2       "--" :operator)
  -(deftoken :plus         "+" :operator)
  -(deftoken :minus        "-" :operator)
  -(deftoken :dot          "." :operator)
  -(deftoken :left-bracket "[" :operator)
  -(deftoken :right-bracket "]" :operator)
  -(deftoken :left-curly   "{" :operator)
  -(deftoken :right-curly  "}" :operator)
  -(deftoken :left-paren   "(" :operator)
  -(deftoken :right-paren  ")" :operator)
  +(deftoken :bar2         "||" :operator-token)
  +(deftoken :ampersand2   "&&" :operator-token)
  +(deftoken :bar          "|" :operator-token)
  +(deftoken :caret        "^" :operator-token)
  +(deftoken :ampersand    "&" :operator-token)
  +(deftoken :equals3      "===" :operator-token)
  +(deftoken :not-equals2  "!==" :operator-token)
  +(deftoken :equals2      "==" :operator-token)
  +(deftoken :equals       "=" :operator-token)
  +(deftoken :not-equals   "!=" :operator-token)
  +(deftoken :urshift      ">>>" :operator-token)
  +(deftoken :lshift       "<<" :operator-token)
  +(deftoken :rshift       ">>" :operator-token)
  +(deftoken :less-than    "<" :operator-token)
  +(deftoken :less-than-equals "<=" :operator-token)
  +(deftoken :greater-than ">" :operator-token)
  +(deftoken :greater-than-equals ">=" :operator-token)
  +
  +(deftoken :asterisk     "*" :operator-token)
  +(deftoken :slash        "/" :operator-token)
  +(deftoken :percent      "%" :operator-token)
  +(deftoken :bang         "!" :operator-token)
  +(deftoken :tilde        "~" :operator-token)
  +(deftoken :plus2        "++" :operator-token)
  +(deftoken :minus2       "--" :operator-token)
  +(deftoken :plus         "+" :operator-token)
  +(deftoken :minus        "-" :operator-token)
  +(deftoken :dot          "." :operator-token)
  +(deftoken :left-bracket "[" :operator-token)
  +(deftoken :right-bracket "]" :operator-token)
  +(deftoken :left-curly   "{" :operator-token)
  +(deftoken :right-curly  "}" :operator-token)
  +(deftoken :left-paren   "(" :operator-token)
  +(deftoken :right-paren  ")" :operator-token)
  +
  +;; These represent operations (addition, etc.) rather than just text tokens.
  +;; The lexer will never output them, so possibly the whole *symbols-to-tokens*
  +;; setup wants to be in js-source-model instead of here.
  +(deftoken :assign       "=" :operation)
  +(deftoken :unary-plus   "+" :operation)
  +(deftoken :unary-minus  "-" :operation)
  +(deftoken :pre-decr     "--" :operation)
  +(deftoken :pre-incr     "++" :operation)
  +(deftoken :post-decr    "--" :operation)
  +(deftoken :post-incr    "++" :operation)
  +(deftoken :logical-and  "&&" :operation)
  +(deftoken :logical-or   "||" :operation)
  +(deftoken :logical-not  "!" :operation)
  +(deftoken :bitwise-and  "&" :operation)
  +(deftoken :bitwise-or   "|" :operation)
  +(deftoken :bitwise-not  "~" :operation)
  +(deftoken :bitwise-xor  "^" :operation)
  +(deftoken :equals       "==" :operation)
  +(deftoken :strict-equals "===" :operation)
  +(deftoken :strict-not-equals "!==" :operation)
  +(deftoken :add          "+" :operation)
  +(deftoken :subtract     "-" :operation)
  +(deftoken :multiply     "*" :operation)
  +(deftoken :divide       "/" :operation)
  +(deftoken :modulo       "%" :operation)
  +
   
   ;; Keywords
   (deftoken :break        "break" :keyword)
  
positive.code: (deftoken :true         "true"   :keyword)
  (deftoken :try          "try"    :keyword)
  (deftoken :typeof       "typeof" :keyword)
  (deftoken :var          "var"    :keyword)
  (deftoken :void         "void"   :keyword) ;???
  (deftoken :while        "while"  :keyword)
  
negative.code: ;;;;; Token definitions
  (defmacro deftoken (symbol &optional key token-type)
    (cond
      ((eq token-type :operator-token)
       `(progn
         (setf (gethash ,key *tokens-to-symbols*) ,symbol)
         (setf (gethash ,symbol *symbols-to-tokens*) ,key)
         (push ,key *operator-tokens*)))
      ((eq token-type :operation)
       `(setf (gethash ,symbol *symbols-to-tokens*) ,key))
      ((eq token-type :keyword)
       `(progn
         (setf (gethash ,key *tokens-to-symbols*) ,symbol)
         (push ,symbol *keyword-symbols*)))
      (key
       `(setf (gethash ,key *tokens-to-symbols*) ,symbol))
      (t
  