anchor.diff:    ("\\)" (return (values '|)| '|)|)))
     ("\\[" (return (values '|[| '|[|)))
     ("\\]" (return (values '|]| '|]|)))
  -  "--(.*)--" ;; inline comment FIXME: doesn't work with multiple inline comments on a single line
  +  ("\\|" (return (values 'pipe 'pipe)))
  +  "--(.*?)--" ;; inline comment
     "--(.*)\\\n"  ;; single line comments
     ("0x([0-9a-fA-F]+)" (return (values 'constant (parse-integer (or $1 "") :radix 16))))
     ("[-]?[0-9]+" (return (values 'constant (parse-integer $@))))
     ("\\\"([0-9a-fA-F]+)\\\"" (return (values 'constant (parse-integer (or $1 "") :radix 16))))
  -  ("[\\w-]+" (return (values 'name (alexandria:symbolicate (substitute #\- #\_ (string-upcase $@))))))
  +  ("[\\w-]+" (return (values 'name (alexandria:symbolicate (lisp-name $@))))) ;;substitute #\- #\_ (string-upcase $@))))))
     )
   
   (defun test-lexer (string)
  
positive.code:   (integer-expr
     (integer (lambda (a) (declare (ignore a)) `(:integer)))
     (integer |(| constant |..| constant |)| 
  	    (lambda (a b c d e f) (declare (ignore a b d f)) `(:integer ,c ,e)))
     (integer |(| constant |)| (lambda (a b c d) (declare (ignore a b d)) `(:integer ,c)))
     (integer |{| named-number-list |}| (lambda (a b c d) (declare (ignore a b d)) `(:integer ,c))))
  
    (bit-string-range 
     (constant |..| constant (lambda (a b c) (declare (ignore b)) `(:range ,a ,c)))
     (constant |..| max (lambda (a b c) (declare (ignore b c)) `(:range ,a nil))))
  
    (bit-string-option
     (size |(| bit-string-range |)| (lambda (a b c d) (declare (ignore a b d)) c)))
  
negative.code:   (:export #:parse-definition))
  
  (in-package #:asinine.parser)
  
  (defun lisp-name (string)
    (with-output-to-string (s)
      (do ((i 0 (1+ i))
           (state :normal))
          ((= i (length string)))
        (let ((c (char string i)))
          ;; if the previous character was a downcased character and this one is an upcased character then 
          ;; output a - 
          (cond
            ((and (eq state :downcase) (upper-case-p c))
             (princ #\- s)
             (setf state :upcase))
            ((lower-case-p c)
             (setf state :downcase))
            (t (setf state :normal)))
          (princ (char-upcase c) s)))))
  
  (cl-lex:define-string-lexer asn1-lexer 
    ("SEQUENCE" (return (values 'sequence 'sequence)))
  