anchor.diff:                     ((eq token :geometry)
                       (cons (geometry)
                             (body-first-item)))
  -                   ((eq type :identifer) ; beginning of block statement
  +                   ((eq type :identifier) ; beginning of block statement
                       (cons (body-statement (list token))
                             (body-first-item)))
                      (t (error "Unknown statement type: ~A" type)))))
  
positive.code:   name
    statements)
  
  (defparameter +curly-scanners+
    (map 'list (lambda (thing)
                 (destructuring-bind (regex &rest rest) thing
                   (cons (ppcre:create-scanner (format nil "^(~A)" regex)) rest)))
         (list (list "{" #\{)
               (list "}" #\})
               (list "\\(" #\()
               (list "\\)" #\))
               (list "\\[" #\[)
               (list "\\]" #\])
               (list "," #\,)
               (list ";" #\;)
               (list "\\\"[^\\\"]*\\\"" :string
                     (lambda (string start end)
                       (subseq string (1+ start) (1- end))))
               (list "[a-zA-Z][a-zA-Z0-9_]*" :identifer
                     (let ((hash (alist-hash-table '(("frame" . :frame)
                                                     ("geometry" . :geometry)
                                                     ("class" . :class))
                                                   :test #'equal)))
                       (lambda (string start end)
                         (let ((token (subseq string start end)))
                           (gethash token hash token)))))
               (list "-?(([0-9]+\\.[0-9]*)|(\\.[0-9]+))" :float
                     (lambda (string start end)
                       (parse-float (subseq string start end))))
               (list "-?[0-9]+" :integer
                     (lambda (string start end)
                       (parse-integer string :start start :end end))))))
  
  (defparameter +curly-comment-regex+
    (let ((whitespace "\\s")
          (line-comment "#|//).*(\\n|$")
          (block-comment "/\\*[^(/\\*)]*\\*/"))
      (ppcre:create-scanner (format nil "^((~A)|(~A)|(~A))*"
                                    whitespace
                                    line-comment
                                    block-comment))))
  
  (defun curly-next-token (string start)
    "Returns (VALUES TOKEN-VALUE TOKEN-TYPE STRING-START STRING-END)"
    (multiple-value-bind (comment-start comment-end)
        (ppcre:scan +curly-comment-regex+ string :start start)
      (assert (= start comment-start))
      (let ((start comment-end))
        (loop for (scanner type value-function) in +curly-scanners+
           do (multiple-value-bind (start end)
                  (ppcre:scan scanner string :start start)
                (when start
                  (return (values type
                                  (if value-function
                                      (funcall value-function string start end)
                                      type)
                                  start
                                  end))))))))
  
  
  (defun curly-parse-string (string)
    (let ((start 0))
      (labels ((next ()
                 (multiple-value-bind (type token t-start end)
                     (curly-next-token string start)
                   (declare (ignore t-start))
                   ;; (when type
                   ;;   (format t "~&token: ~A `~A'" token (subseq string t-start end)))
                   (setq start end)
                   (values type token)))
               (start ()
                 ;(print 'start)
                 (multiple-value-bind (type token) (next)
  
negative.code:                (body-first-item ))
               (frame ()
                 (multiple-value-bind (type token) (next)
                   (assert (eq :identifier type))
                   (make-curly-block :type :frame
                                     :name token
                                     :statements (body))))
  