;;; This file was generated by Zebu (Version 3.5.5)

(IN-PACKAGE "CONSTRAINT-GRAMMAR-PARSER")
(REQUIRE "zebu-package")
(USE-PACKAGE "ZEBU")

(DEFUN ATTRIBUTE94 (KEY DUMMY DUMMY1 VALUE DUMMY2)
  (DECLARE (IGNORE DUMMY2 DUMMY1 DUMMY))
  (BUILD-PARSED-KEY-VALUE-PAIR KEY VALUE))

(DEFUN ATTRIBUTES95 (ATTRIBUTE ATTRIBUTES) (APPEND ATTRIBUTE ATTRIBUTES))

(DEFUN CONTENT*96 (ELEMENT) (LIST ELEMENT))

(DEFUN CONTENT*97 (ELEMENT DATA) (LIST ELEMENT DATA))

(DEFUN CONTENT*98 (ELEMENT DATA CONTENT*) (LIST* ELEMENT DATA CONTENT*))

(DEFUN CONTENT99 (DATA) (LIST DATA))

(DEFUN CONTENT100 (ELEMENT) (LIST ELEMENT))

(DEFUN CONTENT101 (DATA CONTENT*) (CONS DATA CONTENT*))

(DEFUN CONTENT102 (ELEMENT CONTENT) (CONS ELEMENT CONTENT))

(DEFUN DTD103 (DTD-ELEMENT) (LIST DTD-ELEMENT))

(DEFUN DTD104 (DTD-ELEMENT DTD) (CONS DTD-ELEMENT DTD))

(DEFUN DOCTYPE-TAG105 (DUMMY DOCTYPE-DATA DUMMY1 DTD DUMMY2)
  (DECLARE (IGNORE DUMMY2 DUMMY1 DUMMY))
  (LIST :!ENTITY DOCTYPE-DATA DTD))

(DEFUN NOTATION-TAG106 (DUMMY DATA DUMMY1)
  (DECLARE (IGNORE DUMMY1 DUMMY DATA))
  (CONS :!ENTITY ATTRIBUTES))

(DEFUN ENTITY-TAG107 (DUMMY DATA DUMMY1)
  (DECLARE (IGNORE DUMMY1 DUMMY DATA))
  (CONS :!ENTITY ATTRIBUTES))

(DEFUN COMMENT-TAG108 (DUMMY COMMENT DUMMY1)
  (DECLARE (IGNORE DUMMY1 DUMMY))
  (CONS :!-- COMMENT))

(DEFUN Q-MILESTONE-TAG109 (DUMMY ELEMENT-NAME DUMMY1)
  (DECLARE (IGNORE DUMMY1 DUMMY))
  (INTERN (CONCAT "?" ELEMENT-NAME) :KEYWORD))

(DEFUN Q-MILESTONE-TAG110 (DUMMY ELEMENT-NAME ATTRIBUTES DUMMY1)
  (DECLARE (IGNORE DUMMY1 DUMMY))
  (CONS (INTERN (CONCAT "?" ELEMENT-NAME) :KEYWORD) ATTRIBUTES))

(DEFUN MILESTONE-TAG111 (DUMMY ELEMENT-NAME DUMMY1)
  (DECLARE (IGNORE DUMMY1 DUMMY))
  (INTERN ELEMENT-NAME :KEYWORD))

(DEFUN MILESTONE-TAG112 (DUMMY ELEMENT-NAME ATTRIBUTES DUMMY1)
  (DECLARE (IGNORE DUMMY1 DUMMY))
  (CONS (INTERN ELEMENT-NAME :KEYWORD) ATTRIBUTES))

(DEFUN OPEN-TAG113 (DUMMY ELEMENT-NAME DUMMY1)
  (DECLARE (IGNORE DUMMY1 DUMMY))
  (PROGN (PUT-TOKEN (CONCAT "<" ELEMENT-NAME ">"))
         (INTERN ELEMENT-NAME :KEYWORD)))

(DEFUN OPEN-TAG114 (DUMMY ELEMENT-NAME ATTRIBUTES DUMMY1)
  (DECLARE (IGNORE DUMMY1 DUMMY))
  (CONS (INTERN ELEMENT-NAME :KEYWORD) ATTRIBUTES))

(DEFUN CLOSE-TAG115 (DUMMY ELEMENT-NAME DUMMY1)
  (DECLARE (IGNORE DUMMY1 DUMMY))
  (LIST (CONCAT "</" ELEMENT-NAME ">")))

(DEFUN ELEMENT116 (OPEN-TAG CONTENT CLOSE-TAG)
  (DECLARE (IGNORE CLOSE-TAG))
  (CONS OPEN-TAG CONTENT))

(DEFUN ELEMENT117 (Q-MILESTONE-TAG) (LIST Q-MILESTONE-TAG))

(DEFUN ELEMENT118 (ENTITY-TAG) (LIST ENTITY-TAG))

(DEFUN ELEMENT119 (DOCTYPE-TAG) (LIST DOCTYPE-TAG))

(DEFUN ELEMENT120 (COMMENT-TAG) (LIST COMMENT-TAG))

(DEFUN DOCUMENT121 (ELEMENT) (PRINT ELEMENT))


(EVAL-WHEN (COMPILE)
  (UNLESS (MEMBER "zebu-regex" *MODULES* :TEST #'EQUAL)
    (WARN "Load the Zebu Compiler!")))
(DECLAIM (SPECIAL ZEBU::*REGEX-GROUPS* ZEBU::*REGEX-GROUPINGS*))
(DEFUN WHITESPACE
    (STRING &OPTIONAL (ZEBU::START 0) (ZEBU::END (LENGTH STRING)))
  (WHEN (PROGN (SETF ZEBU::*REGEX-GROUPINGS* 1)
               (BLOCK ZEBU::FINAL-RETURN
                 (BLOCK ZEBU::COMPARE
                   (LET ((ZEBU::INDEX ZEBU::START) (LENGTH ZEBU::END))
                     (SETF (SVREF ZEBU::*REGEX-GROUPS* 0)
                           (LIST ZEBU::INDEX NIL))
                     (LET ((ZEBU::OINDEX ZEBU::INDEX))
                       (BLOCK ZEBU::COMPARE
                         (DO ()
                             (NIL)
                           (LET ((ZEBU::RANGE
                                  #*0000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000))
                             (IF (>= ZEBU::INDEX LENGTH)
                                 (RETURN-FROM ZEBU::COMPARE NIL))
                             (IF (= 1
                                    (SBIT ZEBU::RANGE
                                          (CHAR-CODE
                                           (CHAR STRING ZEBU::INDEX))))
                                 (INCF ZEBU::INDEX)
                               (RETURN-FROM ZEBU::COMPARE NIL)))))
                       (DO ((ZEBU::START ZEBU::INDEX (1- ZEBU::START)))
                           ((< ZEBU::START ZEBU::OINDEX) NIL)
                         (LET ((ZEBU::INDEX ZEBU::START))
                           (BLOCK ZEBU::COMPARE
                             (LET ((ZEBU::RANGE
                                    #*0000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000))
                               (IF (>= ZEBU::INDEX LENGTH)
                                   (RETURN-FROM ZEBU::COMPARE NIL))
                               (IF (= 1
                                      (SBIT
                                       ZEBU::RANGE
                                       (CHAR-CODE (CHAR STRING ZEBU::INDEX))))
                                   (INCF ZEBU::INDEX)
                                 (RETURN-FROM ZEBU::COMPARE NIL)))
                             (SETF (CADR (SVREF ZEBU::*REGEX-GROUPS* 0))
                                   ZEBU::INDEX)
                             (RETURN-FROM ZEBU::FINAL-RETURN T)))))))))
    (SECOND (SVREF ZEBU::*REGEX-GROUPS* 0))))

(DEFUN DATA (STRING &OPTIONAL (ZEBU::START 0) (ZEBU::END (LENGTH STRING)))
  (WHEN (PROGN (SETF ZEBU::*REGEX-GROUPINGS* 1)
               (BLOCK ZEBU::FINAL-RETURN
                 (BLOCK ZEBU::COMPARE
                   (LET ((ZEBU::INDEX ZEBU::START) (LENGTH ZEBU::END))
                     (SETF (SVREF ZEBU::*REGEX-GROUPS* 0)
                           (LIST ZEBU::INDEX NIL))
                     (LET ((ZEBU::OINDEX ZEBU::INDEX))
                       (BLOCK ZEBU::COMPARE
                         (DO ()
                             (NIL)
                           (LET ((ZEBU::RANGE
                                  #*1111111111111111111111111111111111111111111111111111111111110111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111))
                             (IF (>= ZEBU::INDEX LENGTH)
                                 (RETURN-FROM ZEBU::COMPARE NIL))
                             (IF (= 1
                                    (SBIT ZEBU::RANGE
                                          (CHAR-CODE
                                           (CHAR STRING ZEBU::INDEX))))
                                 (INCF ZEBU::INDEX)
                               (RETURN-FROM ZEBU::COMPARE NIL)))))
                       (DO ((ZEBU::START ZEBU::INDEX (1- ZEBU::START)))
                           ((< ZEBU::START ZEBU::OINDEX) NIL)
                         (LET ((ZEBU::INDEX ZEBU::START))
                           (BLOCK ZEBU::COMPARE
                             (LET ((ZEBU::RANGE
                                    #*1111111111111111111111111111111111111111111111111111111111110111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111))
                               (IF (>= ZEBU::INDEX LENGTH)
                                   (RETURN-FROM ZEBU::COMPARE NIL))
                               (IF (= 1
                                      (SBIT
                                       ZEBU::RANGE
                                       (CHAR-CODE (CHAR STRING ZEBU::INDEX))))
                                   (INCF ZEBU::INDEX)
                                 (RETURN-FROM ZEBU::COMPARE NIL)))
                             (SETF (CADR (SVREF ZEBU::*REGEX-GROUPS* 0))
                                   ZEBU::INDEX)
                             (RETURN-FROM ZEBU::FINAL-RETURN T)))))))))
    (SECOND (SVREF ZEBU::*REGEX-GROUPS* 0))))

(DEFUN COMMENT-DATA
    (STRING &OPTIONAL (ZEBU::START 0) (ZEBU::END (LENGTH STRING)))
  (WHEN (PROGN (SETF ZEBU::*REGEX-GROUPINGS* 1)
               (BLOCK ZEBU::FINAL-RETURN
                 (BLOCK ZEBU::COMPARE
                   (LET ((ZEBU::INDEX ZEBU::START) (LENGTH ZEBU::END))
                     (SETF (SVREF ZEBU::*REGEX-GROUPS* 0)
                           (LIST ZEBU::INDEX NIL))
                     (IF (AND (< ZEBU::INDEX LENGTH)
                              (EQL (CHAR STRING ZEBU::INDEX) #\())
                         (INCF ZEBU::INDEX)
                       (RETURN-FROM ZEBU::COMPARE NIL))
                     (LET ((ZEBU::RANGE
                            #*1111111111111111111111111111111111111111111110111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111))
                       (IF (>= ZEBU::INDEX LENGTH)
                           (RETURN-FROM ZEBU::COMPARE NIL))
                       (IF (= 1
                              (SBIT ZEBU::RANGE
                                    (CHAR-CODE (CHAR STRING ZEBU::INDEX))))
                           (INCF ZEBU::INDEX)
                         (RETURN-FROM ZEBU::COMPARE NIL)))
                     (LET ((ZEBU::NEW-INDEX (+ ZEBU::INDEX 2)))
                       (IF (< LENGTH ZEBU::NEW-INDEX)
                           (RETURN-FROM ZEBU::COMPARE NIL))
                       (IF (STRING= STRING "|-"
                             :START1 ZEBU::INDEX
                             :END1 ZEBU::NEW-INDEX)
                           (INCF ZEBU::INDEX 2)
                         (RETURN-FROM ZEBU::COMPARE NIL)))
                     (LET ((ZEBU::RANGE
                            #*1111111111111111111111111111111111111111111110111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111))
                       (IF (>= ZEBU::INDEX LENGTH)
                           (RETURN-FROM ZEBU::COMPARE NIL))
                       (IF (= 1
                              (SBIT ZEBU::RANGE
                                    (CHAR-CODE (CHAR STRING ZEBU::INDEX))))
                           (INCF ZEBU::INDEX)
                         (RETURN-FROM ZEBU::COMPARE NIL)))
                     (LET ((ZEBU::OINDEX ZEBU::INDEX))
                       (BLOCK ZEBU::COMPARE
                         (DO ()
                             (NIL)
                           (IF (AND (< ZEBU::INDEX LENGTH)
                                    (EQL (CHAR STRING ZEBU::INDEX) #\)))
                               (INCF ZEBU::INDEX)
                             (RETURN-FROM ZEBU::COMPARE NIL))))
                       (DO ((ZEBU::START ZEBU::INDEX (1- ZEBU::START)))
                           ((< ZEBU::START ZEBU::OINDEX) NIL)
                         (LET ((ZEBU::INDEX ZEBU::START))
                           (BLOCK ZEBU::COMPARE
                             (SETF (CADR (SVREF ZEBU::*REGEX-GROUPS* 0))
                                   ZEBU::INDEX)
                             (RETURN-FROM ZEBU::FINAL-RETURN T)))))))))
    (SECOND (SVREF ZEBU::*REGEX-GROUPS* 0))))

(DEFUN DOCTYPE-DATA
    (STRING &OPTIONAL (ZEBU::START 0) (ZEBU::END (LENGTH STRING)))
  (WHEN (PROGN (SETF ZEBU::*REGEX-GROUPINGS* 1)
               (BLOCK ZEBU::FINAL-RETURN
                 (BLOCK ZEBU::COMPARE
                   (LET ((ZEBU::INDEX ZEBU::START) (LENGTH ZEBU::END))
                     (SETF (SVREF ZEBU::*REGEX-GROUPS* 0)
                           (LIST ZEBU::INDEX NIL))
                     (LET ((ZEBU::OINDEX ZEBU::INDEX))
                       (BLOCK ZEBU::COMPARE
                         (DO ()
                             (NIL)
                           (LET ((ZEBU::RANGE
                                  #*0000000000000000000000000000000000000000000000101111111111000000011111111111111111111111111111110111111111111111111111111110000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000))
                             (IF (>= ZEBU::INDEX LENGTH)
                                 (RETURN-FROM ZEBU::COMPARE NIL))
                             (IF (= 1
                                    (SBIT ZEBU::RANGE
                                          (CHAR-CODE
                                           (CHAR STRING ZEBU::INDEX))))
                                 (INCF ZEBU::INDEX)
                               (RETURN-FROM ZEBU::COMPARE NIL)))))
                       (DO ((ZEBU::START ZEBU::INDEX (1- ZEBU::START)))
                           ((< ZEBU::START ZEBU::OINDEX) NIL)
                         (LET ((ZEBU::INDEX ZEBU::START))
                           (BLOCK ZEBU::COMPARE
                             (LET ((ZEBU::RANGE
                                    #*0000000000000000000000000000000000000000000000101111111111000000011111111111111111111111111111110111111111111111111111111110000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000))
                               (IF (>= ZEBU::INDEX LENGTH)
                                   (RETURN-FROM ZEBU::COMPARE NIL))
                               (IF (= 1
                                      (SBIT
                                       ZEBU::RANGE
                                       (CHAR-CODE (CHAR STRING ZEBU::INDEX))))
                                   (INCF ZEBU::INDEX)
                                 (RETURN-FROM ZEBU::COMPARE NIL)))
                             (SETF (CADR (SVREF ZEBU::*REGEX-GROUPS* 0))
                                   ZEBU::INDEX)
                             (RETURN-FROM ZEBU::FINAL-RETURN T)))))))))
    (SECOND (SVREF ZEBU::*REGEX-GROUPS* 0))))

(DEFUN ELT-DATA (STRING &OPTIONAL (ZEBU::START 0) (ZEBU::END (LENGTH STRING)))
  (WHEN (PROGN (SETF ZEBU::*REGEX-GROUPINGS* 1)
               (BLOCK ZEBU::FINAL-RETURN
                 (BLOCK ZEBU::COMPARE
                   (LET ((ZEBU::INDEX ZEBU::START) (LENGTH ZEBU::END))
                     (SETF (SVREF ZEBU::*REGEX-GROUPS* 0)
                           (LIST ZEBU::INDEX NIL))
                     (LET ((ZEBU::OINDEX ZEBU::INDEX))
                       (BLOCK ZEBU::COMPARE
                         (DO ()
                             (NIL)
                           (LET ((ZEBU::RANGE
                                  #*0000000000000000000000000000000000000000000001000000000000000000011111111111111111111111111000010111111111111111111111111110000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000))
                             (IF (>= ZEBU::INDEX LENGTH)
                                 (RETURN-FROM ZEBU::COMPARE NIL))
                             (IF (= 1
                                    (SBIT ZEBU::RANGE
                                          (CHAR-CODE
                                           (CHAR STRING ZEBU::INDEX))))
                                 (INCF ZEBU::INDEX)
                               (RETURN-FROM ZEBU::COMPARE NIL)))))
                       (DO ((ZEBU::START ZEBU::INDEX (1- ZEBU::START)))
                           ((< ZEBU::START ZEBU::OINDEX) NIL)
                         (LET ((ZEBU::INDEX ZEBU::START))
                           (BLOCK ZEBU::COMPARE
                             (LET ((ZEBU::RANGE
                                    #*0000000000000000000000000000000000000000000001000000000000000000011111111111111111111111111000010111111111111111111111111110000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000))
                               (IF (>= ZEBU::INDEX LENGTH)
                                   (RETURN-FROM ZEBU::COMPARE NIL))
                               (IF (= 1
                                      (SBIT
                                       ZEBU::RANGE
                                       (CHAR-CODE (CHAR STRING ZEBU::INDEX))))
                                   (INCF ZEBU::INDEX)
                                 (RETURN-FROM ZEBU::COMPARE NIL)))
                             (SETF (CADR (SVREF ZEBU::*REGEX-GROUPS* 0))
                                   ZEBU::INDEX)
                             (RETURN-FROM ZEBU::FINAL-RETURN T)))))))))
    (SECOND (SVREF ZEBU::*REGEX-GROUPS* 0))))

(DEFUN KEY-DATA (STRING &OPTIONAL (ZEBU::START 0) (ZEBU::END (LENGTH STRING)))
  (WHEN (PROGN (SETF ZEBU::*REGEX-GROUPINGS* 1)
               (BLOCK ZEBU::FINAL-RETURN
                 (BLOCK ZEBU::COMPARE
                   (LET ((ZEBU::INDEX ZEBU::START) (LENGTH ZEBU::END))
                     (SETF (SVREF ZEBU::*REGEX-GROUPS* 0)
                           (LIST ZEBU::INDEX NIL))
                     (LET ((ZEBU::OINDEX ZEBU::INDEX))
                       (BLOCK ZEBU::COMPARE
                         (DO ()
                             (NIL)
                           (LET ((ZEBU::RANGE
                                  #*0000000000000000000000000000000000000000000001000000000000000000011111111111111111111111111000000111111111111111111111111110000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000))
                             (IF (>= ZEBU::INDEX LENGTH)
                                 (RETURN-FROM ZEBU::COMPARE NIL))
                             (IF (= 1
                                    (SBIT ZEBU::RANGE
                                          (CHAR-CODE
                                           (CHAR STRING ZEBU::INDEX))))
                                 (INCF ZEBU::INDEX)
                               (RETURN-FROM ZEBU::COMPARE NIL)))))
                       (DO ((ZEBU::START ZEBU::INDEX (1- ZEBU::START)))
                           ((< ZEBU::START ZEBU::OINDEX) NIL)
                         (LET ((ZEBU::INDEX ZEBU::START))
                           (BLOCK ZEBU::COMPARE
                             (LET ((ZEBU::RANGE
                                    #*0000000000000000000000000000000000000000000001000000000000000000011111111111111111111111111000000111111111111111111111111110000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000))
                               (IF (>= ZEBU::INDEX LENGTH)
                                   (RETURN-FROM ZEBU::COMPARE NIL))
                               (IF (= 1
                                      (SBIT
                                       ZEBU::RANGE
                                       (CHAR-CODE (CHAR STRING ZEBU::INDEX))))
                                   (INCF ZEBU::INDEX)
                                 (RETURN-FROM ZEBU::COMPARE NIL)))
                             (SETF (CADR (SVREF ZEBU::*REGEX-GROUPS* 0))
                                   ZEBU::INDEX)
                             (RETURN-FROM ZEBU::FINAL-RETURN T)))))))))
    (SECOND (SVREF ZEBU::*REGEX-GROUPS* 0))))

(DEFUN ATT-DATA (STRING &OPTIONAL (ZEBU::START 0) (ZEBU::END (LENGTH STRING)))
  (WHEN (PROGN (SETF ZEBU::*REGEX-GROUPINGS* 1)
               (BLOCK ZEBU::FINAL-RETURN
                 (BLOCK ZEBU::COMPARE
                   (LET ((ZEBU::INDEX ZEBU::START) (LENGTH ZEBU::END))
                     (SETF (SVREF ZEBU::*REGEX-GROUPS* 0)
                           (LIST ZEBU::INDEX NIL))
                     (LET ((ZEBU::OINDEX ZEBU::INDEX))
                       (BLOCK ZEBU::COMPARE
                         (DO ()
                             (NIL)
                           (LET ((ZEBU::RANGE
                                  #*1111111111111111111111111111111111011111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111))
                             (IF (>= ZEBU::INDEX LENGTH)
                                 (RETURN-FROM ZEBU::COMPARE NIL))
                             (IF (= 1
                                    (SBIT ZEBU::RANGE
                                          (CHAR-CODE
                                           (CHAR STRING ZEBU::INDEX))))
                                 (INCF ZEBU::INDEX)
                               (RETURN-FROM ZEBU::COMPARE NIL)))))
                       (DO ((ZEBU::START ZEBU::INDEX (1- ZEBU::START)))
                           ((< ZEBU::START ZEBU::OINDEX) NIL)
                         (LET ((ZEBU::INDEX ZEBU::START))
                           (BLOCK ZEBU::COMPARE
                             (LET ((ZEBU::RANGE
                                    #*1111111111111111111111111111111111011111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111))
                               (IF (>= ZEBU::INDEX LENGTH)
                                   (RETURN-FROM ZEBU::COMPARE NIL))
                               (IF (= 1
                                      (SBIT
                                       ZEBU::RANGE
                                       (CHAR-CODE (CHAR STRING ZEBU::INDEX))))
                                   (INCF ZEBU::INDEX)
                                 (RETURN-FROM ZEBU::COMPARE NIL)))
                             (SETF (CADR (SVREF ZEBU::*REGEX-GROUPS* 0))
                                   ZEBU::INDEX)
                             (RETURN-FROM ZEBU::FINAL-RETURN T)))))))))
    (SECOND (SVREF ZEBU::*REGEX-GROUPS* 0))))