A slight variation on the standard Pascal grammar with some changes
for ease of parsing.  Note that the nonterminals are presented in
alpabetical order for ease of reference.  A second section (at the
end of the document) lists the nonterminals that were dropped from
the grammar.  I've included them for posterity.

Syntax of this grammar:
* Things surrounded by angle braces are nonterminals.
* Things in all caps are tokens.
* Sequences surrounded by braces can be repeated 0 or more times.

One major change to Pascal: Zeroary function calls still require the
parentheses.

--------------------------------------------------------------------------------

<actual_parameters> ::= <expression> { COMMA <expression> }

<addop> ::= PLUS
<addop> ::= MINUS
<addop> ::= OR

<array_indices> ::= <simple_type> { COMMA <simple_type> } 

<array_type> ::= ARRAY OPEN_BRACKET <array_indices> CLOSE_BRACKET 
                 OF <type>

<assignment_statement> ::= <variable> BECOMES <expression>

<block> ::= <label_declarations>
            <constant_definitions>
            <type_definitions>
            <variable_declarations>
            <procfunc_declarations>
            <compound_statement>

<case_label_list> ::= <constant> { COMMA <constant> }

<case_list_element> ::= <case_label_list> COLON <statement>
<case_list_element> ::= epsilon

<case_statement> ::= CASE <expression> OF 
                     <case_list_element> { SEMICOLON <case_list_element> }
                     END

<compound_statement> ::= BEGIN <statement> { SEMICOLON <statement> } END

<constant> ::= <optional_sign> <unsigned_number>
<constant> ::= STRING

<constant_definition> ::= ID EQUALS <constant>

<constant_definitions> ::= epsilon
<constant_definitions> ::= CONST <constant_definition>
                           SEMICOLON
                           { <constant_definition> SEMICOLON }

<direction> ::= TO
<direction> ::= DOWNTO

<element> ::= <expression>
<element> ::= <expression> DOTDOT <expression>

<elements> ::= epsilon
<elements> ::= <element> { COMMA <element> }

<empty_statement> ::= epsilon

<expression> ::= <simple_expression> 
<expression> ::= <simple_expression> <relop> <simple_expression>

<factor> ::= <variable>
<factor> ::= <unsigned_constant>
<factor> ::= OPEN_PAREN <expression> CLOSE_PAREN
<factor> ::= <set>
<factor> ::= <function_call>
<factor> ::= NOT <factor>

<field_designator> ::= <variable> DOT ID

<field_list> ::= <fixed_part>
<field_list> ::= <fixed_part> SEMICOLON <variant_part>
<field_list> ::= <variant_part>

<file_buffer> ::= <variable> POINTER

<file_type> ::= FILE OF <type>

<fixed_part> ::= <record_section> { SEMICOLON <record_section> }

<formal_parameter_section> ::= <parameter_group>
<formal_parameter_section> ::= VAR <parameter_group>
<formal_parameter_section> ::= FUNCTION <parameter_group>
<formal_parameter_section> ::= PROCEDURE ID { COMMA ID }

<for_statement> ::= FOR <identifier> BECOMES 
                    <expression> <direction> <expression> 
                    DO <statement>

<function_call> ::= <identifier> OPEN CLOSE
<function_call> ::= <identifier> OPEN <actual_parameters> CLOSE

<function_declaration> ::= <function_heading> <block>

<function_heading> ::= FUNCTION ID COLON ID SEMICOLON
<function_heading> ::= FUNCTION ID 
                       OPEN_PAREN 
                       <formal_parameter_section> 
                       { SEMICOLON <formal_parameter_section> } 
                       CLOSE_PAREN COLON <type_identifier> SEMICOLON

<go_to_statement> ::= GOTO <label>

<if_statement> ::= IF <expression> THEN <statement>
<if_statement> ::= IF <expression> THEN <statement> ELSE <statement>

<indexed_variable> ::= <variable> OPEN_BRACE 
                       <expression> { COMMA <expression> }
                       CLOSE_BRACE

<label_declarations> ::= epsilon
<label_declarations> ::= LABEL <UINT> { COMMA <UINT> } SEMICOLON

<mulop> ::= TIMES
<mulop> ::= DIVIDE
<mulop> ::= DIV
<mulop> ::= MOD
<mulop> ::= AND

<optional_label> ::= epsilon
<optional_label> ::= UINT COLON

<optional_sign> ::= epsilon
<optional_sign> ::= PLUS
<optional_sign> ::= MINUS

<optional_tag> ::= epsilon
<optional_tag> ::= ID COLON

<packed_type> ::= PACKED <structured_type>

<parameter_group> ::= ID { COMMA ID } COLON ID

<pointer_type> ::= POINTER <type_identifier>

<procedure_declaration> ::= <procedure_heading> <block>

<procedure_heading> ::= PROCEDURE ID SEMICOLON
<procedure_heading> ::= PROCEDURE ID 
                        OPEN_PAREN 
                        <formal_parameter_section> 
                        { SEMICOLON <formal_parameter_section> } 
                        CLOSE_PAREN
                        SEMICOLON

<procedure_call> ::= <identifier>
<procedure_call> ::= <identifier> OPEN_PAREN <actual_parameters> CLOSE_PAREN

<procfunc_declaration> ::= <procedure_declaration>
<procfunc_declaration> ::= <function_declaration>

<procfunc_declarations> ::= { <procfunc_declaration> SEMICOLON }

<program> ::= <program_heading> <block> DOT

<program_heading> ::= PROGRAM ID 
                      OPEN_PAREN ID { COMMA ID } CLOSE_PAREN SEMICOLON

<record_section> ::= epsilon
<record_section> ::= ID { COMMA ID } COLON <type>

<record_type> ::= RECORD <field_list> END

<record_variable_list> ::= <variable> { COMMA <variable> }

<referenced_variable> ::= <variable> POINTER

<relop> ::= EQUALS
<relop> ::= NOT_EQUALS
<relop> ::= LESS_THAN
<relop> ::= LESS_EQUAL
<relop> ::= GREATER_EQUAL
<relop> ::= GREATER_THAN
<relop> ::= IN

<repeat_statement> ::= REPEAT <statement> { SEMICOLON <statement> }
                       UNTIL <expression>

<scalar_type> ::= OPEN_PAREN ID { COMMA ID } CLOSE_PAREN

<set> ::= LBRACKET <elements> RBRACKET

<set_type> ::= SET OF <simple_type>

<simple_expression> ::= <optional_sign> <term>
<simple_expression> ::= <simple_expression> <addop> <term>

<simple_type> ::= <scalar_type>
<simple_type> ::= <subrange_type>
<simple_type> ::= ID

<statement> ::= <optional_label> <unlabelled_statement>

<structured_type> ::= <array_type>
<structured_type> ::= <record_type>
<structured_type> ::= <set_type>
<structured_type> ::= <file_type>

<subrange_type> ::= <constant> DOTDOT <constant>

<term> ::= <factor>
<term> ::= <term> <mulop> <factor>

<type> ::= <simple_type>
<type> ::= <structured_type>
<type> ::= <packed_type>
<type> ::= <pointer_type>

<type_definition> ::= <identifier> EQUALS <type>

<type_definitions> ::= epsilon
<type_definitions> ::= TYPE <type_definition> 
                       SEMICOLON 
                       { <type_definition> SEMICOLON }

<type_identifier> ::= ID

<unlabelled_statement> ::= <assignment_statement>
<unlabelled_statement> ::= <procedure_call>
<unlabelled_statement> ::= <go_to_statement>
<unlabelled_statement> ::= <empty_statement>
<unlabelled_statement> ::= <compound_statement>
<unlabelled_statement> ::= <if_statement>
<unlabelled_statement> ::= <case_statement>
<unlabelled_statement> ::= <while_statement>
<unlabelled_statement> ::= <repeat_statement>
<unlabelled_statement> ::= <for_statement>
<unlabelled_statement> ::= <with_statement>

<unsigned_number> ::= UINT
<unsigned_number> ::= UREAL
<unsigned_number> ::= ID

<unsigned_constant> ::= UINT
<unsigned_constant> ::= UREAL
<unsigned_constant> ::= STRING 
<unsigned_constant> ::= NIL

<variable> ::= <variable_name>
<variable> ::= <indexed_variable>
<variable> ::= <field_designator>
<variable> ::= <file_buffer>
<variable> ::= <referenced_variable>

<variable_declaration> ::= ID { COMMA ID } COLON <type>

<variable_declarations> ::= epsilon
<variable_declarations> ::= VAR <variable_declaration> SEMICOLON
                            { <variable_declaration> SEMICOLON }

<variable_name> ::= ID

<variant> ::= epsilon
<variant> ::= <constant> { COMMA <constant> } COLON 
              OPEN_PAREN <field_list> CLOSE_PAREN

<variant_part> ::= CASE <optional_tag> <type_identifier> OF <variant> 
                   { SEMICOLON <variant> }

<while_statement> ::= WHILE <expression> DO <statement>

<with_statement> ::= WITH <record_variable_list> DO <statement>

--------------------------------------------------------------------------------

/Unused nonterminals (usually factored out), included here for posterity/

<actual_parameter> ::= <expression>
<actual_parameter> ::= <variable>
<actual_parameter> ::= <procedure_identifier>
<actual_parameter> ::= <function_identifier>

<conditional_statement> ::= <if_statement>
<conditional_statement> ::= <case_statement>

<empty> ::=

<entire_variable> ::= <variable_idenntifier>

<field_identifier> ::= <identifier>

<file_variable> ::= <variable>

<final_value> ::= <expression>

<function_identifier> ::= <identifier>

<initial_value> ::= <expression>

<label> ::= UINT

<record_variable> ::= <variable>

<repetitive_statement> ::= <while_statement>
<repetitive_statement> ::= <repeat_statement>
<repetitive_statement> ::= <for_statement>

<result_type> ::= <type_identifier>

<statement_part> ::= <compound_statement>

<structured_statement> ::= <compound_statement>
<structured_statement> ::= <conditional_statement>
<structured_statement> ::= <repetitive_statement>
<structured_statement> ::= <with_statement>

<variable_identifier> ::= ID