anchor.diff:                                (1+ (start scanner))
                                 (1- (current scanner))))))
   
  -    (loop until (or (char= (peek scanner) #\")
  -                    (is-at-end scanner))
  -          do (advance scanner))
  -
  -    ;; If String's not terminated
  -    (if (is-at-end scanner)
  -        ;; Report it
  -        (cerror "Continue scanning"
  -                'unterminated-string-error
  -                :line (line scanner)
  -                :place (start scanner))
  -        ;; Consume the closing "
  -        (advance scanner))
  -    (add-string scanner)))
  +    ;; Only process the string if it starts as a string
  +    (when (char= (current-character scanner) #\")
  +      (loop until (or (char= (peek scanner) #\")
  +                      (is-at-end scanner))
  +            do (advance scanner))
  +
  +      ;; If String's not terminated
  +      (if (is-at-end scanner)
  +          ;; Report it
  +          (cerror "Continue scanning"
  +                  'unterminated-string-error
  +                  :line (line scanner)
  +                  :place (start scanner))
  +          ;; Otherwise consume the closing "
  +          (advance scanner))
  +      (add-string scanner))))
   
   (-> is-digit (character) boolean)
   (defun is-digit (char)
  
positive.code: ;; Defining Token
  ;; ;;;;;;;;;;;;;;
  
  (defparameter +1char-token-associations+
    '((#\( :left-paren)
      (#\) :right-paren)
      (#\{ :left-brace)
      (#\} :right-brace)
      (#\, :comma)
      (#\. :dot)
      (#\- :minus)
      (#\+ :plus)
      (#\* :star)
      (#\/ :slash)
      (#\; :semicolon)))
  
  (defparameter +keywords+
    #.(let ((keywords-alist
              '(("and" . :and)
                ("class" . :class)
                ("else" . :else)
                ("false" . :false)
                ("for" . :for)
                ("fun" . :fun)
                ("if" . :if)
                ("nil" . :nil)
                ("or" . :or)
                ("print" . :print)
                ("return" . :return)
                ("super" . :super)
                ("this" . :this)
                ("true" . :true)
                ("var" . :var)
                ("while" . :while))))
        (alexandria:alist-hash-table keywords-alist
                                     :test #'equal
                                     :size (length keywords-alist))))
  
  (deftype token-type ()
    `(member
      ;; Single-character tokens
      :left-paren :right-paren
      :left-brace :right-brace
      :comma :dot :minus :plus :star :slash :semicolon
  
      ;; One or two character tokens
                  :bang :bang-equal
                  :equal :equal-equal
                  :greater :greater-equal
                  :less :less-equal
  
                  ;; Literals
                  :identifier :string :number
  
                  ;; Keywords.
      :and :class :else :false :fun :for :if :nil :or
                  :print :return :super :this :true :var :while
  
      :eof))
  
  (defclass Token ()
  
negative.code: (-> match (scanner character) boolean)
  (defun match (scanner expected)
    "Consume the next character and return T if it is expected character, return NIL otherwise."
    (unless (char/= (peek scanner) expected)
      (move-forward scanner)
      t))
  
  (-> peek (scanner) character)
  (defun peek (scanner)
    "Return the next character in the source or End-of-text token if we're at the end."
    (if (is-at-end scanner)
        #\Etx
        (aref (source scanner) (current scanner))))
  
  (-> peek-next (scanner) character)
  (defun peek-next (scanner)
    "Return the character after the next character in the source or ETX if there's none.'"
    (if (>= (1+ (current scanner))
            (length (source scanner)))
        #\Etx
        (aref (source scanner)
              (1+ (current scanner)))))
  
  (-> current-character (scanner) character)
  (defun current-character (scanner)
    "Return the current character of the source - the one that is processed right now, or STX if processing hasn't started yet."
    (if (zerop (current scanner))
        #\Stx
        (aref (source scanner) (1- (current scanner)))))
  
  (defun is-at-newline (scanner)
    "Return T if scanner is at newline(next character will be \n)."
    (char= (peek scanner) #\Linefeed))
  
  (-> scan-token (scanner) (or boolean token))
  (defun scan-token (scanner)
    "Add next token from the scanner's source."
    ;; FIXME: Make cerror return something else than NIL.
    (advance scanner)
    (or (process-1char-token scanner)
        (process-1-or-2-char-token scanner)
        (process-comment-or-slash scanner)
        (process-whitespace scanner)
        (process-string scanner)
        (process-number-literal scanner)
        (process-identifier scanner)
        (cerror "Continue scanning."
                'unexpected-character-error
                :character currently-processed-character
                :line (line scanner)
                :place (start scanner))))
  
  (-> scan-tokens (string) vector)
  (defun scan-tokens (input)
  