anchor.diff:          (symbol nil)
           (symbol-name nil)
           (next-char nil)
  -        ;; simple-version means that the symbol is the xml tag name, e.g. <foo
  -        ;; otherwise it's a <"foo" or a <(foo), the latter is evaluated and
  -        ;; the result is used as the tag name.
  +        ;; simple-version means that the xml tag name is a symbol, e.g. <foo
  +        ;; otherwise it's a <"foo" or a <(foo). unless it's a symbol it is
  +        ;; evaluated and the result is used as the tag name.
           (simple-version t))
       (unwind-protect
            (unread-char char s)                    ; read the entire token
  
positive.code:                               (collect (cons (string-downcase (string (first attribute)))
                                               (second attribute)))))))
                (if body
                    (progn
                      (emit-open-tag tag-name emittable-attributes)
                      (if protect
                          (let ((body-code)
                                (close-code))
                            (let ((%yaclml-code% '()))
                              (emit-body body)
                              (setf body-code %yaclml-code%))
                            (let ((%yaclml-code% '()))
                              (emit-close-tag tag-name)
                              (setf close-code %yaclml-code%))
                            (emit-code `(unwind-protect
                                         (progn ,@(mapcar #'writer (fold-strings (nreverse body-code))))
                                         ,@(mapcar #'writer (fold-strings (nreverse close-code))))))
                          (progn
                            (emit-body body)
                            (emit-close-tag tag-name))))
                    (emit-empty-tag tag-name emittable-attributes))))
            `(progn
              ,@(mapcar #'writer (fold-strings (nreverse %yaclml-code%)))
              nil))))))
  
  (defun with-xml-syntax ()
  
negative.code:           ;;(format t "Bailing out with ~S~%" symbol) ; TODO debug code
            (return-from xml-reader-open symbol)))
      ;;(format t "We've got a hit, simple-version? ~S~%" simple-version) ; TODO debug code
      (let ((*readtable* (copy-readtable)))
        (set-syntax-from-char *xml-reader-close-char* #\) *readtable*)
        (labels ((writer (form)
                   (if (stringp form)
                       `(write-string ,form *yaclml-stream*)
                       form))
                 (emitter (form)
                   (mapcar #'writer (fold-strings (nreverse form)))))
          (let* ((list (let ((result (read-delimited-list #\> s t)))
                         ;;(format t "The delimited list is ~S~%" result) ; TODO debug code
                         result))
                 (head (if simple-version
                           (subseq symbol-name 1) ; drop the "<" from the symbol-name
                           (car list)))
                 (tag-name (if (or (stringp head) (consp head))
                               head
                               (string-downcase (princ-to-string head))))
                 (%yaclml-code% nil)
  