anchor.diff:    (unless (end-of-string-p lexer)
       (cond ((accept lexer #\+)
              (alexandria:when-let ((number (match-number lexer)))
  -             (list :offset number)))
  +             `(lem-vi-mode.ex-command:offset-line ,number)))
             ((accept lexer #\-)
              (alexandria:when-let ((number (match-number lexer)))
  -             (list :offset (- number)))))))
  +             `(lem-vi-mode.ex-command:offset-line ,(- number)))))))
   
   (defun parse-ex-range-element (lexer)
     (let ((list (loop
  
positive.code: (defpackage :lem-vi-mode.ex-parser
    (:use :cl)
    (:export :parse-ex-range))
  (in-package :lem-vi-mode.ex-parser)
  
  (defstruct lexer
    position
    string)
  
  (defun lookahead (lexer)
    (char (lexer-string lexer) (lexer-position lexer)))
  
negative.code: (defun match-pattern (lexer)
    (unless (end-of-string-p lexer)
      (alexandria:when-let ((result (match-pattern-1 lexer #\/)))
        (return-from match-pattern `(lem-vi-mode.ex-command:search-forward ,result)))
      (alexandria:when-let ((result (match-pattern-1 lexer #\?)))
        (return-from match-pattern `(lem-vi-mode.ex-command:search-backward ,result)))))
  
  (defun parse-ex-line (lexer)
    (skip-whitespace lexer)
    (unless (end-of-string-p lexer)
      (let ((result))
        (cond ((setf result (match-number lexer))
               `(lem-vi-mode.ex-command:goto-line ,result))
              ((setf result (case (lookahead lexer)
                              (#\. '(lem-vi-mode.ex-command:current-line))
                              (#\$ '(lem-vi-mode.ex-command:last-line))
                              (#\% '(lem-vi-mode.ex-command:all-lines))))
               (lexer-forward lexer)
               result)
              ((accept lexer #\')
               (prog1 `(lem-vi-mode.ex-command:marker ,(lookahead lexer))
                 (lexer-forward lexer)))
              ((match-pattern lexer))))))
  
  