iXML Community Group Test Suite

21 Jun 2022 (28 Jun 2022)

Top-level catalog for tests in the iXML Community Group Test Suite.

Tests have been contributed from several sources, but the core of the test collection are the tests contributed by Steven Pemberton in December 2021.

Misc tests 3

21 Jun 2022

Grammars 41-60.

Tests compiled manually in 2018 and 2019, re-packaged and extended (supplying test cases where needed) in 2022.

Note that some tests have alternate results for processors operating in non-standard modes, in particular modes in which they tolerate multiple definitions and undefined nonterminals or in which they do not tolerate non-productive nonterminals or unreachable nonterminals.

For a description of the form in which alternate results are recorded, see tests/misc-grammar/test-catalog.xml.

sample.grammar.41

Created 08 Feb 2022 by cmsmcq

Sample grammar from Niklaus Wirth, Grundlagen und Techniken des Compilerbaus (Bonn: Addison-Wesley, 1996), pp. 36-37.

Grammar for Oberon-0, the subset of Oberon for which the book describes a compiler.

Rules for whitespace and comments added for usability; Wirth assumes a lexer to eat whitespace. This grammar experiments with a pattern in which nonterminals normally begin and end with non-whitespace characters, so in the XML any whitespace goes outside the tags, not inside. (A different style is shown in sample.grammar.41bis.)

(For what it's worth: in some ways the raw parse tree produced by this grammar is nicer than the raw parse tree produced by grammar 41bis, but optional nonterminals and nonterminals which can produce the empty string cause ambiguity unless they are handled specially.)

Invisible XML Grammar

{ Sample grammar from Niklaus Wirth, Grundlagen und Techniken des
Compilerbaus (Bonn: Addison-Wesley, 1996), pp. 36-37.

Oberon-0.

Rules for ws added for convenience; Wirth assumes the lexer
eats whitespace. }

{ Revisions:
  2022-06-15 : CMSMcQ : tweaks to align output with grammar 41bis
  2022-06-14 : CMSMcQ : revise S handling (tight tags, where possible).
                        Hide most literals, use pre-terminal symbols.
  2018-08-10 : CMSMcQ : correct syntax errors found by DCG parser
  2018-08-09 : CMSMcQ : made first transcription; needs testing, since
      the translation from Wirth's EBNF is error-prone.
}

{ We move the rule for module to the front, since it is the
start symbol. }

            module = S?, -"MODULE", S, @ident, SEMI,
                     declarations,
                     (-"BEGIN", StatementSequence)?,
                     -"END", S, @ident_close, S?, -".", S?.
    
             ident = letter, (letter; digit)*.
       ident_close = ident.
           integer = digit, (digit)*.
          selector = (member; subscript)++(S?).
	    member = -".", S?, ident.
	 subscript = -"[", S?, expression, S?, -"]".
         {selector = (".", S?, ident; "[", S?, expression, S?, "]")++S.}
            number = integer.
            factor = ident, (S?, selector)?
	           ; number
		   ; -"(", S?, expression, S?, -")"
		   ; "~", S?, factor
		   .
              term = factor++(S?, (TIMES; DIV; MOD; AND), S?).
	      
  SimpleExpression =  (PLUS; MINUS)?, term++(S?, (PLUS; MINUS; OR), S?).

    { N.B. Simplexpression allows 1, -1, 1 + 1,
      -1 + 1, but not 1 + -1.
      I expect that's intentional.
      I've made it also forbid white space between sign and term.
    }    
 
        expression = SimpleExpression, (S?, -COMPARATOR, S?, SimpleExpression)?.
       -COMPARATOR = EQL; NEQ; LSS; LEQ; GTR; GEQ.
        assignment = ident, S?, (selector, S?)?, -":=", S?, expression.
  ActualParameters = -"(", S?, expression**(S?, -",", S?), S?, -")".
     ProcedureCall = ident, (S?, selector)?, (S?, ActualParameters)?.
       IfStatement = -"IF", S?, condition, S?, 
                     -"THEN", then-stmts,
                     (-"ELSIF", S?, condition, S?, 
		     -"THEN", then-stmts)*,
                     (-"ELSE", else-stmts)?,
		     -"END".
         condition = -expression.
        then-stmts = -StatementSequence.
        else-stmts = -StatementSequence.
    WhileStatement = -"WHILE", S?, condition, S?,
                     -"DO", do-statements,
		     -"END".
     do-statements = -StatementSequence.

         statement = S?, ((assignment
			 ; ProcedureCall
			 ; IfStatement
			 ; WhileStatement), S?)?.
 StatementSequence = statement++ -";".
 
 { Wirth's formulation is closer to the following, but that complicates whitespace
   handling. 

         statement = (assignment; ProcedureCall; IfStatement; WhileStatement)?.
 StatementSequence = statement++SEMI.
 }

         IdentList = ident++(-",", S?).
         ArrayType = -"ARRAY", S?, expression, S?, -"OF", S?, type.
         FieldList = (IdentList, COLON, type)?.
        RecordType = -"RECORD", S?, FieldList++SEMI, S?, -"END", S?.
              type = ident
	           ; ArrayType
		   ; RecordType
		   .
         FPSection = (-"VAR", S)?, IdentList, COLON, type.
  FormalParameters = -"(", S?, FPSection**SEMI, S?, -")".
  ProcedureHeading = -"PROCEDURE", S, ident, S?, FormalParameters?.
     ProcedureBody = declarations, 
                     (-"BEGIN", StatementSequence)?,
		     -"END", S, @ident.
ProcedureDeclaration
                   = ProcedureHeading, SEMI, ProcedureBody.
      declarations = (constants, S?)?, (types, S?)?, (variables, S?)?, (procedures, S?)?.
         constants = -"CONST", (S, (ident, EQUALS, expression, S?, -";")++S)?.
             types = -"TYPE", (S, (IdentList, EQUALS, type, S?, -";")++S)?.
         variables = -"VAR", (S, (IdentList, COLON, type, S?, -";")++S)?.
        procedures = (ProcedureDeclaration, S?, -";")++S.

{ S and comment added here to make the grammar usable without
  a scanner. N.B. Comments nest. }
                -S = (ws; comment)+.
               -ws = -[" "; #09; #0A; #0D].

           comment = -"(*", comment-body, -"*)".
      comment-body = comment-chars, ((comment++comment-chars), comment-chars?)?.
    -comment-chars = (cc1; cc2; cc3)+, star*, lpar* | star+, lpar* | lpar+.
              -cc1 = not-star-or-lpar.
              -cc2 = lpar+, not-star-or-lpar.
	      -cc3 = star+, lpar+, not-star-or-lpar
                   | star+, not-star-or-lrpar.
 -not-star-or-lpar = ~["*("].
-not-star-or-lrpar = ~["(*)"].
             -lpar = "(".
	     -star = "*".

            -digit = ['0'-'9'].
           -letter = ['a'-'z'; 'A'-'Z'].

             TIMES = -"*".
	       DIV = -"DIV".
	       MOD = -"MOD".
	       AND = -"AND".
	      PLUS = -"+".
	     MINUS = -"-".
	        OR = -"OR".
               EQL = -"=".
	       NEQ = -"#".
	       LSS = -"<".
	       LEQ = -"<=".
	       GTR = -">".
	       GEQ = -">=".

{ Separators }
             -SEMI = S?, -";", S?.
            -COLON = S?, -":", S?.
           -EQUALS = S?, -"=", S?.

Test case: Grammar test

Repository URI: …/tests/misc/misc-041-060-catalog.xml

Expected result

<ixml>
   <comment> Sample grammar from Niklaus Wirth, Grundlagen und Techniken des
Compilerbaus (Bonn: Addison-Wesley, 1996), pp. 36-37.

Oberon-0.

Rules for ws added for convenience; Wirth assumes the lexer
eats whitespace. </comment>
   <comment> Revisions:
  2022-06-15 : CMSMcQ : tweaks to align output with grammar 41bis
  2022-06-14 : CMSMcQ : revise S handling (tight tags, where possible).
                        Hide most literals, use pre-terminal symbols.
  2018-08-10 : CMSMcQ : correct syntax errors found by DCG parser
  2018-08-09 : CMSMcQ : made first transcription; needs testing, since
      the translation from Wirth's EBNF is error-prone.
</comment>
   <comment> We move the rule for module to the front, since it is the
start symbol. </comment>
   <rule name="module">
      <alt>
         <option>
            <nonterminal name="S"/>
         </option>
         <literal tmark="-" string="MODULE"/>
         <nonterminal name="S"/>
         <nonterminal mark="@" name="ident"/>
         <nonterminal name="SEMI"/>
         <nonterminal name="declarations"/>
         <option>
            <alts>
               <alt>
                  <literal tmark="-" string="BEGIN"/>
                  <nonterminal name="StatementSequence"/>
               </alt>
            </alts>
         </option>
         <literal tmark="-" string="END"/>
         <nonterminal name="S"/>
         <nonterminal mark="@" name="ident_close"/>
         <option>
            <nonterminal name="S"/>
         </option>
         <literal tmark="-" string="."/>
         <option>
            <nonterminal name="S"/>
         </option>
      </alt>
   </rule>
   <rule name="ident">
      <alt>
         <nonterminal name="letter"/>
         <repeat0>
            <alts>
               <alt>
                  <nonterminal name="letter"/>
               </alt>
               <alt>
                  <nonterminal name="digit"/>
               </alt>
            </alts>
         </repeat0>
      </alt>
   </rule>
   <rule name="ident_close">
      <alt>
         <nonterminal name="ident"/>
      </alt>
   </rule>
   <rule name="integer">
      <alt>
         <nonterminal name="digit"/>
         <repeat0>
            <alts>
               <alt>
                  <nonterminal name="digit"/>
               </alt>
            </alts>
         </repeat0>
      </alt>
   </rule>
   <rule name="selector">
      <alt>
         <repeat1>
            <alts>
               <alt>
                  <nonterminal name="member"/>
               </alt>
               <alt>
                  <nonterminal name="subscript"/>
               </alt>
            </alts>
            <sep>
               <alts>
                  <alt>
                     <option>
                        <nonterminal name="S"/>
                     </option>
                  </alt>
               </alts>
            </sep>
         </repeat1>
      </alt>
   </rule>
   <rule name="member">
      <alt>
         <literal tmark="-" string="."/>
         <option>
            <nonterminal name="S"/>
         </option>
         <nonterminal name="ident"/>
      </alt>
   </rule>
   <rule name="subscript">
      <alt>
         <literal tmark="-" string="["/>
         <option>
            <nonterminal name="S"/>
         </option>
         <nonterminal name="expression"/>
         <option>
            <nonterminal name="S"/>
         </option>
         <literal tmark="-" string="]"/>
      </alt>
   </rule>
   <comment>selector = (".", S?, ident; "[", S?, expression, S?, "]")++S.</comment>
   <rule name="number">
      <alt>
         <nonterminal name="integer"/>
      </alt>
   </rule>
   <rule name="factor">
      <alt>
         <nonterminal name="ident"/>
         <option>
            <alts>
               <alt>
                  <option>
                     <nonterminal name="S"/>
                  </option>
                  <nonterminal name="selector"/>
               </alt>
            </alts>
         </option>
      </alt>
      <alt>
         <nonterminal name="number"/>
      </alt>
      <alt>
         <literal tmark="-" string="("/>
         <option>
            <nonterminal name="S"/>
         </option>
         <nonterminal name="expression"/>
         <option>
            <nonterminal name="S"/>
         </option>
         <literal tmark="-" string=")"/>
      </alt>
      <alt>
         <literal string="~"/>
         <option>
            <nonterminal name="S"/>
         </option>
         <nonterminal name="factor"/>
      </alt>
   </rule>
   <rule name="term">
      <alt>
         <repeat1>
            <nonterminal name="factor"/>
            <sep>
               <alts>
                  <alt>
                     <option>
                        <nonterminal name="S"/>
                     </option>
                     <alts>
                        <alt>
                           <nonterminal name="TIMES"/>
                        </alt>
                        <alt>
                           <nonterminal name="DIV"/>
                        </alt>
                        <alt>
                           <nonterminal name="MOD"/>
                        </alt>
                        <alt>
                           <nonterminal name="AND"/>
                        </alt>
                     </alts>
                     <option>
                        <nonterminal name="S"/>
                     </option>
                  </alt>
               </alts>
            </sep>
         </repeat1>
      </alt>
   </rule>
   <rule name="SimpleExpression">
      <alt>
         <option>
            <alts>
               <alt>
                  <nonterminal name="PLUS"/>
               </alt>
               <alt>
                  <nonterminal name="MINUS"/>
               </alt>
            </alts>
         </option>
         <repeat1>
            <nonterminal name="term"/>
            <sep>
               <alts>
                  <alt>
                     <option>
                        <nonterminal name="S"/>
                     </option>
                     <alts>
                        <alt>
                           <nonterminal name="PLUS"/>
                        </alt>
                        <alt>
                           <nonterminal name="MINUS"/>
                        </alt>
                        <alt>
                           <nonterminal name="OR"/>
                        </alt>
                     </alts>
                     <option>
                        <nonterminal name="S"/>
                     </option>
                  </alt>
               </alts>
            </sep>
         </repeat1>
      </alt>
   </rule>
   <comment> N.B. Simplexpression allows 1, -1, 1 + 1,
      -1 + 1, but not 1 + -1.
      I expect that's intentional.
      I've made it also forbid white space between sign and term.
    </comment>
   <rule name="expression">
      <alt>
         <nonterminal name="SimpleExpression"/>
         <option>
            <alts>
               <alt>
                  <option>
                     <nonterminal name="S"/>
                  </option>
                  <nonterminal mark="-" name="COMPARATOR"/>
                  <option>
                     <nonterminal name="S"/>
                  </option>
                  <nonterminal name="SimpleExpression"/>
               </alt>
            </alts>
         </option>
      </alt>
   </rule>
   <rule mark="-" name="COMPARATOR">
      <alt>
         <nonterminal name="EQL"/>
      </alt>
      <alt>
         <nonterminal name="NEQ"/>
      </alt>
      <alt>
         <nonterminal name="LSS"/>
      </alt>
      <alt>
         <nonterminal name="LEQ"/>
      </alt>
      <alt>
         <nonterminal name="GTR"/>
      </alt>
      <alt>
         <nonterminal name="GEQ"/>
      </alt>
   </rule>
   <rule name="assignment">
      <alt>
         <nonterminal name="ident"/>
         <option>
            <nonterminal name="S"/>
         </option>
         <option>
            <alts>
               <alt>
                  <nonterminal name="selector"/>
                  <option>
                     <nonterminal name="S"/>
                  </option>
               </alt>
            </alts>
         </option>
         <literal tmark="-" string=":="/>
         <option>
            <nonterminal name="S"/>
         </option>
         <nonterminal name="expression"/>
      </alt>
   </rule>
   <rule name="ActualParameters">
      <alt>
         <literal tmark="-" string="("/>
         <option>
            <nonterminal name="S"/>
         </option>
         <repeat0>
            <nonterminal name="expression"/>
            <sep>
               <alts>
                  <alt>
                     <option>
                        <nonterminal name="S"/>
                     </option>
                     <literal tmark="-" string=","/>
                     <option>
                        <nonterminal name="S"/>
                     </option>
                  </alt>
               </alts>
            </sep>
         </repeat0>
         <option>
            <nonterminal name="S"/>
         </option>
         <literal tmark="-" string=")"/>
      </alt>
   </rule>
   <rule name="ProcedureCall">
      <alt>
         <nonterminal name="ident"/>
         <option>
            <alts>
               <alt>
                  <option>
                     <nonterminal name="S"/>
                  </option>
                  <nonterminal name="selector"/>
               </alt>
            </alts>
         </option>
         <option>
            <alts>
               <alt>
                  <option>
                     <nonterminal name="S"/>
                  </option>
                  <nonterminal name="ActualParameters"/>
               </alt>
            </alts>
         </option>
      </alt>
   </rule>
   <rule name="IfStatement">
      <alt>
         <literal tmark="-" string="IF"/>
         <option>
            <nonterminal name="S"/>
         </option>
         <nonterminal name="condition"/>
         <option>
            <nonterminal name="S"/>
         </option>
         <literal tmark="-" string="THEN"/>
         <nonterminal name="then-stmts"/>
         <repeat0>
            <alts>
               <alt>
                  <literal tmark="-" string="ELSIF"/>
                  <option>
                     <nonterminal name="S"/>
                  </option>
                  <nonterminal name="condition"/>
                  <option>
                     <nonterminal name="S"/>
                  </option>
                  <literal tmark="-" string="THEN"/>
                  <nonterminal name="then-stmts"/>
               </alt>
            </alts>
         </repeat0>
         <option>
            <alts>
               <alt>
                  <literal tmark="-" string="ELSE"/>
                  <nonterminal name="else-stmts"/>
               </alt>
            </alts>
         </option>
         <literal tmark="-" string="END"/>
      </alt>
   </rule>
   <rule name="condition">
      <alt>
         <nonterminal mark="-" name="expression"/>
      </alt>
   </rule>
   <rule name="then-stmts">
      <alt>
         <nonterminal mark="-" name="StatementSequence"/>
      </alt>
   </rule>
   <rule name="else-stmts">
      <alt>
         <nonterminal mark="-" name="StatementSequence"/>
      </alt>
   </rule>
   <rule name="WhileStatement">
      <alt>
         <literal tmark="-" string="WHILE"/>
         <option>
            <nonterminal name="S"/>
         </option>
         <nonterminal name="condition"/>
         <option>
            <nonterminal name="S"/>
         </option>
         <literal tmark="-" string="DO"/>
         <nonterminal name="do-statements"/>
         <literal tmark="-" string="END"/>
      </alt>
   </rule>
   <rule name="do-statements">
      <alt>
         <nonterminal mark="-" name="StatementSequence"/>
      </alt>
   </rule>
   <rule name="statement">
      <alt>
         <option>
            <nonterminal name="S"/>
         </option>
         <option>
            <alts>
               <alt>
                  <alts>
                     <alt>
                        <nonterminal name="assignment"/>
                     </alt>
                     <alt>
                        <nonterminal name="ProcedureCall"/>
                     </alt>
                     <alt>
                        <nonterminal name="IfStatement"/>
                     </alt>
                     <alt>
                        <nonterminal name="WhileStatement"/>
                     </alt>
                  </alts>
                  <option>
                     <nonterminal name="S"/>
                  </option>
               </alt>
            </alts>
         </option>
      </alt>
   </rule>
   <rule name="StatementSequence">
      <alt>
         <repeat1>
            <nonterminal name="statement"/>
            <sep>
               <literal tmark="-" string=";"/>
            </sep>
         </repeat1>
      </alt>
   </rule>
   <comment> Wirth's formulation is closer to the following, but that complicates whitespace
   handling. 

         statement = (assignment; ProcedureCall; IfStatement; WhileStatement)?.
 StatementSequence = statement++SEMI.
 </comment>
   <rule name="IdentList">
      <alt>
         <repeat1>
            <nonterminal name="ident"/>
            <sep>
               <alts>
                  <alt>
                     <literal tmark="-" string=","/>
                     <option>
                        <nonterminal name="S"/>
                     </option>
                  </alt>
               </alts>
            </sep>
         </repeat1>
      </alt>
   </rule>
   <rule name="ArrayType">
      <alt>
         <literal tmark="-" string="ARRAY"/>
         <option>
            <nonterminal name="S"/>
         </option>
         <nonterminal name="expression"/>
         <option>
            <nonterminal name="S"/>
         </option>
         <literal tmark="-" string="OF"/>
         <option>
            <nonterminal name="S"/>
         </option>
         <nonterminal name="type"/>
      </alt>
   </rule>
   <rule name="FieldList">
      <alt>
         <option>
            <alts>
               <alt>
                  <nonterminal name="IdentList"/>
                  <nonterminal name="COLON"/>
                  <nonterminal name="type"/>
               </alt>
            </alts>
         </option>
      </alt>
   </rule>
   <rule name="RecordType">
      <alt>
         <literal tmark="-" string="RECORD"/>
         <option>
            <nonterminal name="S"/>
         </option>
         <repeat1>
            <nonterminal name="FieldList"/>
            <sep>
               <nonterminal name="SEMI"/>
            </sep>
         </repeat1>
         <option>
            <nonterminal name="S"/>
         </option>
         <literal tmark="-" string="END"/>
         <option>
            <nonterminal name="S"/>
         </option>
      </alt>
   </rule>
   <rule name="type">
      <alt>
         <nonterminal name="ident"/>
      </alt>
      <alt>
         <nonterminal name="ArrayType"/>
      </alt>
      <alt>
         <nonterminal name="RecordType"/>
      </alt>
   </rule>
   <rule name="FPSection">
      <alt>
         <option>
            <alts>
               <alt>
                  <literal tmark="-" string="VAR"/>
                  <nonterminal name="S"/>
               </alt>
            </alts>
         </option>
         <nonterminal name="IdentList"/>
         <nonterminal name="COLON"/>
         <nonterminal name="type"/>
      </alt>
   </rule>
   <rule name="FormalParameters">
      <alt>
         <literal tmark="-" string="("/>
         <option>
            <nonterminal name="S"/>
         </option>
         <repeat0>
            <nonterminal name="FPSection"/>
            <sep>
               <nonterminal name="SEMI"/>
            </sep>
         </repeat0>
         <option>
            <nonterminal name="S"/>
         </option>
         <literal tmark="-" string=")"/>
      </alt>
   </rule>
   <rule name="ProcedureHeading">
      <alt>
         <literal tmark="-" string="PROCEDURE"/>
         <nonterminal name="S"/>
         <nonterminal name="ident"/>
         <option>
            <nonterminal name="S"/>
         </option>
         <option>
            <nonterminal name="FormalParameters"/>
         </option>
      </alt>
   </rule>
   <rule name="ProcedureBody">
      <alt>
         <nonterminal name="declarations"/>
         <option>
            <alts>
               <alt>
                  <literal tmark="-" string="BEGIN"/>
                  <nonterminal name="StatementSequence"/>
               </alt>
            </alts>
         </option>
         <literal tmark="-" string="END"/>
         <nonterminal name="S"/>
         <nonterminal mark="@" name="ident"/>
      </alt>
   </rule>
   <rule name="ProcedureDeclaration">
      <alt>
         <nonterminal name="ProcedureHeading"/>
         <nonterminal name="SEMI"/>
         <nonterminal name="ProcedureBody"/>
      </alt>
   </rule>
   <rule name="declarations">
      <alt>
         <option>
            <alts>
               <alt>
                  <nonterminal name="constants"/>
                  <option>
                     <nonterminal name="S"/>
                  </option>
               </alt>
            </alts>
         </option>
         <option>
            <alts>
               <alt>
                  <nonterminal name="types"/>
                  <option>
                     <nonterminal name="S"/>
                  </option>
               </alt>
            </alts>
         </option>
         <option>
            <alts>
               <alt>
                  <nonterminal name="variables"/>
                  <option>
                     <nonterminal name="S"/>
                  </option>
               </alt>
            </alts>
         </option>
         <option>
            <alts>
               <alt>
                  <nonterminal name="procedures"/>
                  <option>
                     <nonterminal name="S"/>
                  </option>
               </alt>
            </alts>
         </option>
      </alt>
   </rule>
   <rule name="constants">
      <alt>
         <literal tmark="-" string="CONST"/>
         <option>
            <alts>
               <alt>
                  <nonterminal name="S"/>
                  <repeat1>
                     <alts>
                        <alt>
                           <nonterminal name="ident"/>
                           <nonterminal name="EQUALS"/>
                           <nonterminal name="expression"/>
                           <option>
                              <nonterminal name="S"/>
                           </option>
                           <literal tmark="-" string=";"/>
                        </alt>
                     </alts>
                     <sep>
                        <nonterminal name="S"/>
                     </sep>
                  </repeat1>
               </alt>
            </alts>
         </option>
      </alt>
   </rule>
   <rule name="types">
      <alt>
         <literal tmark="-" string="TYPE"/>
         <option>
            <alts>
               <alt>
                  <nonterminal name="S"/>
                  <repeat1>
                     <alts>
                        <alt>
                           <nonterminal name="IdentList"/>
                           <nonterminal name="EQUALS"/>
                           <nonterminal name="type"/>
                           <option>
                              <nonterminal name="S"/>
                           </option>
                           <literal tmark="-" string=";"/>
                        </alt>
                     </alts>
                     <sep>
                        <nonterminal name="S"/>
                     </sep>
                  </repeat1>
               </alt>
            </alts>
         </option>
      </alt>
   </rule>
   <rule name="variables">
      <alt>
         <literal tmark="-" string="VAR"/>
         <option>
            <alts>
               <alt>
                  <nonterminal name="S"/>
                  <repeat1>
                     <alts>
                        <alt>
                           <nonterminal name="IdentList"/>
                           <nonterminal name="COLON"/>
                           <nonterminal name="type"/>
                           <option>
                              <nonterminal name="S"/>
                           </option>
                           <literal tmark="-" string=";"/>
                        </alt>
                     </alts>
                     <sep>
                        <nonterminal name="S"/>
                     </sep>
                  </repeat1>
               </alt>
            </alts>
         </option>
      </alt>
   </rule>
   <rule name="procedures">
      <alt>
         <repeat1>
            <alts>
               <alt>
                  <nonterminal name="ProcedureDeclaration"/>
                  <option>
                     <nonterminal name="S"/>
                  </option>
                  <literal tmark="-" string=";"/>
               </alt>
            </alts>
            <sep>
               <nonterminal name="S"/>
            </sep>
         </repeat1>
      </alt>
   </rule>
   <comment> S and comment added here to make the grammar usable without
  a scanner. N.B. Comments nest. </comment>
   <rule mark="-" name="S">
      <alt>
         <repeat1>
            <alts>
               <alt>
                  <nonterminal name="ws"/>
               </alt>
               <alt>
                  <nonterminal name="comment"/>
               </alt>
            </alts>
         </repeat1>
      </alt>
   </rule>
   <rule mark="-" name="ws">
      <alt>
         <inclusion tmark="-">
            <member string=" "/>
            <member hex="09"/>
            <member hex="0A"/>
            <member hex="0D"/>
         </inclusion>
      </alt>
   </rule>
   <rule name="comment">
      <alt>
         <literal tmark="-" string="(*"/>
         <nonterminal name="comment-body"/>
         <literal tmark="-" string="*)"/>
      </alt>
   </rule>
   <rule name="comment-body">
      <alt>
         <nonterminal name="comment-chars"/>
         <option>
            <alts>
               <alt>
                  <alts>
                     <alt>
                        <repeat1>
                           <nonterminal name="comment"/>
                           <sep>
                              <nonterminal name="comment-chars"/>
                           </sep>
                        </repeat1>
                     </alt>
                  </alts>
                  <option>
                     <nonterminal name="comment-chars"/>
                  </option>
               </alt>
            </alts>
         </option>
      </alt>
   </rule>
   <rule mark="-" name="comment-chars">
      <alt>
         <repeat1>
            <alts>
               <alt>
                  <nonterminal name="cc1"/>
               </alt>
               <alt>
                  <nonterminal name="cc2"/>
               </alt>
               <alt>
                  <nonterminal name="cc3"/>
               </alt>
            </alts>
         </repeat1>
         <repeat0>
            <nonterminal name="star"/>
         </repeat0>
         <repeat0>
            <nonterminal name="lpar"/>
         </repeat0>
      </alt>
      <alt>
         <repeat1>
            <nonterminal name="star"/>
         </repeat1>
         <repeat0>
            <nonterminal name="lpar"/>
         </repeat0>
      </alt>
      <alt>
         <repeat1>
            <nonterminal name="lpar"/>
         </repeat1>
      </alt>
   </rule>
   <rule mark="-" name="cc1">
      <alt>
         <nonterminal name="not-star-or-lpar"/>
      </alt>
   </rule>
   <rule mark="-" name="cc2">
      <alt>
         <repeat1>
            <nonterminal name="lpar"/>
         </repeat1>
         <nonterminal name="not-star-or-lpar"/>
      </alt>
   </rule>
   <rule mark="-" name="cc3">
      <alt>
         <repeat1>
            <nonterminal name="star"/>
         </repeat1>
         <repeat1>
            <nonterminal name="lpar"/>
         </repeat1>
         <nonterminal name="not-star-or-lpar"/>
      </alt>
      <alt>
         <repeat1>
            <nonterminal name="star"/>
         </repeat1>
         <nonterminal name="not-star-or-lrpar"/>
      </alt>
   </rule>
   <rule mark="-" name="not-star-or-lpar">
      <alt>
         <exclusion>
            <member string="*("/>
         </exclusion>
      </alt>
   </rule>
   <rule mark="-" name="not-star-or-lrpar">
      <alt>
         <exclusion>
            <member string="(*)"/>
         </exclusion>
      </alt>
   </rule>
   <rule mark="-" name="lpar">
      <alt>
         <literal string="("/>
      </alt>
   </rule>
   <rule mark="-" name="star">
      <alt>
         <literal string="*"/>
      </alt>
   </rule>
   <rule mark="-" name="digit">
      <alt>
         <inclusion>
            <member from="0" to="9"/>
         </inclusion>
      </alt>
   </rule>
   <rule mark="-" name="letter">
      <alt>
         <inclusion>
            <member from="a" to="z"/>
            <member from="A" to="Z"/>
         </inclusion>
      </alt>
   </rule>
   <rule name="TIMES">
      <alt>
         <literal tmark="-" string="*"/>
      </alt>
   </rule>
   <rule name="DIV">
      <alt>
         <literal tmark="-" string="DIV"/>
      </alt>
   </rule>
   <rule name="MOD">
      <alt>
         <literal tmark="-" string="MOD"/>
      </alt>
   </rule>
   <rule name="AND">
      <alt>
         <literal tmark="-" string="AND"/>
      </alt>
   </rule>
   <rule name="PLUS">
      <alt>
         <literal tmark="-" string="+"/>
      </alt>
   </rule>
   <rule name="MINUS">
      <alt>
         <literal tmark="-" string="-"/>
      </alt>
   </rule>
   <rule name="OR">
      <alt>
         <literal tmark="-" string="OR"/>
      </alt>
   </rule>
   <rule name="EQL">
      <alt>
         <literal tmark="-" string="="/>
      </alt>
   </rule>
   <rule name="NEQ">
      <alt>
         <literal tmark="-" string="#"/>
      </alt>
   </rule>
   <rule name="LSS">
      <alt>
         <literal tmark="-" string="&lt;"/>
      </alt>
   </rule>
   <rule name="LEQ">
      <alt>
         <literal tmark="-" string="&lt;="/>
      </alt>
   </rule>
   <rule name="GTR">
      <alt>
         <literal tmark="-" string="&gt;"/>
      </alt>
   </rule>
   <rule name="GEQ">
      <alt>
         <literal tmark="-" string="&gt;="/>
      </alt>
   </rule>
   <comment> Separators </comment>
   <rule mark="-" name="SEMI">
      <alt>
         <option>
            <nonterminal name="S"/>
         </option>
         <literal tmark="-" string=";"/>
         <option>
            <nonterminal name="S"/>
         </option>
      </alt>
   </rule>
   <rule mark="-" name="COLON">
      <alt>
         <option>
            <nonterminal name="S"/>
         </option>
         <literal tmark="-" string=":"/>
         <option>
            <nonterminal name="S"/>
         </option>
      </alt>
   </rule>
   <rule mark="-" name="EQUALS">
      <alt>
         <option>
            <nonterminal name="S"/>
         </option>
         <literal tmark="-" string="="/>
         <option>
            <nonterminal name="S"/>
         </option>
      </alt>
   </rule>
</ixml>