<program> ::= program <identifier> ;
<block> . <identifier> ::= <letter >
{<letter or digit>}
<letter or digit> ::= <letter> |
<digit>
<block> ::= <label declaration part> <constant
definition part> <type definition part> <variable declaration
part>
<procedure and function declaration part> <statement
part>
<label declaration part> ::= <empty> |
label <label> {, <label>} ;
<label> ::= <unsigned integer>
<constant definition part> ::= <empty> |
const <constant definition> { ; <constant definition>}
; <constant definition> ::= <identifier> =
<constant> <constant> ::= <unsigned
number> | <sign> <unsigned number> | <constant identifier>
| <sign> <constant identifier> |
<string>
<unsigned number> ::= <unsigned integer> |
<unsigned real>
<unsigned integer> ::= <digit>
{<digit>}
<unsigned real> ::= <unsigned integer> .
<unsigned integer> | <unsigned integer> . <unsigned integer> E
<scale factor>|
<unsigned integer> E <scale factor>
<scale factor> ::= <unsigned integer> | <sign>
<unsigned integer>
<sign> ::= + | -
<constant identifier> ::= <identifier>
<string> ::= '<character>
{<character>}'
<type definition part> ::= <empty> |
type <type definition> {;<type definition>};
<type definition> ::= <identifier> =
<type>
<type> ::= <simple type> | <structured type> |
<pointer type>
<simple type> ::= <scalar type> | <subrange
type> | <type identifier>
<scalar type> ::= (<identifier>
{,<identifier>})
<subrange type> ::= <constant> ..
<constant>
<type identifier> ::= <identifier>
<structured type> ::= <array type> | <record
type> | <set type> | <file type>
<array type> ::= array [<index
type>{,<index type>}] of <component type>
<index type> ::= <simple type>
<component type> ::= <type>
<record type> ::= record <field list>
end
<field list> ::= <fixed part> | <fixed part> ;
<variant part> | <variant part>
<fixed part> ::= <record section> {;<record
section>}
<record section> ::= <field identifier> {, <field
identifier>} : <type> | <empty>
<variant type> ::= case <tag field>
<type identifier> of <variant> { ;
<variant>}
<tag field> ::= <field identifier> : |
<empty>
<variant> ::= <case label list> : ( <field
list> ) | <empty>
<case label list> ::= <case label> {, <case
label>}
<case label> ::= <constant>
<set type> ::=set of <base
type>
<base type> ::= <simple type>
<file type> ::= file of <type>
<pointer type> ::= <type identifier>
<variable declaration part> ::= <empty> |
var <variable declaration> {; <variable declaration>}
;
<variable declaration> ::= <identifier>
{,<identifier>} : <type>
<procedure and function declaration part> ::=
{<procedure or function declaration > ;}
<procedure or function declaration > ::= <procedure
declaration > | <function declaration >
<procedure declaration> ::= <procedure heading>
<block>
<procedure heading> ::= procedure
<identifier> ; |
procedure <identifier> ( <formal
parameter section> {;<formal parameter section>} );
<formal parameter section> ::= <parameter group> |
var <parameter group> |
function <parameter group> |
procedure <identifier> { , <identifier>}
<parameter group> ::= <identifier> {,
<identifier>} : <type identifier>
<function declaration> ::= <function heading>
<block>
<function heading> ::= function
<identifier> : <result type> ; |
function <identifier> ( <formal parameter
section> {;<formal parameter section>} ) : <result type> ;
<result type> ::= <type identifier>
<statement part> ::= <compund statement>
<statement> ::= <unlabelled statement> |
<label> : <unlabelled statement>
<unlabelled statement> ::= <simple statement> |
<structured statement>
<simple statement> ::= <assignment statement> |
<procedure statement> | <go to statement> | <empty
statement>
<assignment statement> ::= <variable> :=
<expression> | <function identifier> := <expression>
<variable> ::= <entire variable> | <component
variable> | <referenced variable>
<entire variable> ::= <variable identifier>
<variable identifier> ::= <identifier>
<component variable> ::= <indexed variable> |
<field designator> | <file buffer>
<indexed variable> ::= <array variable>
[<expression> {, <expression>}]
<array variable> ::= <variable>
<field designator> ::= <record variable> . <field
identifier>
<record variable> ::= <variable>
<field identifier> ::= <identifier>
<file buffer> ::= <file variable>
<file variable> ::= <variable>
<referenced variable> ::= <pointer variable>
<pointer variable> ::= <variable>
<expression> ::= <simple expression> | <simple
expression> <relational operator> <simple expression>
<relational operator> ::= = | <> | < | <= |
>= | > | in
<simple expression> ::= <term> | <sign>
<term>| <simple expression> <adding operator>
<term>
<adding operator> ::= + | - | or
<term> ::= <factor> | <term> <multiplying
operator> <factor>
<multiplying operator> ::= * | / | div |
mod | and
<factor> ::= <variable> | <unsigned constant>
| ( <expression> ) | <function designator> | <set> |
not <factor>
<unsigned constant> ::= <unsigned number> |
<string> | < constant identifier> < nil>
<function designator> ::= <function identifier> |
<function identifier ( <actual parameter> {, <actual parameter>}
)
<function identifier> ::= <identifier>
<set> ::= [ <element list> ]
<element list> ::= <element> {, <element> } |
<empty>
<element> ::= <expression> | <expression> ..
<expression>
<procedure statement> ::= <procedure identifier> |
<procedure identifier> (<actual parameter> {, <actual
parameter> })
<procedure identifier> ::= <identifier>
<actual parameter> ::= <expression> |
<variable> | <procedure identifier> | <function
identifier>
<go to statement> ::= goto
<label>
<empty statement> ::= <empty>
<empty> ::=
<structured statement> ::= <compound statement> |
<conditional statement> | <repetitive statement> | <with
statement>
<compound statement> ::= begin
<statement> {; <statement> } end;
<conditional statement> ::= <if statement> |
<case statement>
<if statement> ::= if <expression>
then <statement> | if <expression>
then <statement> else <statement>
<case statement> ::= case <expression>
of <case list element> {; <case list element> }
end
<case list element> ::= <case label list> :
<statement> | <empty>
<case label list> ::= <case label> {, <case
label> }
<repetitive statement> ::= <while statement> |
<repeat statemant> | <for statement>
<while statement> ::= while
<expression> do <statement>
<repeat statement> ::= repeat
<statement> {; <statement>} until
<expression>
<for statement> ::= for <control
variable> := <for list> do <statement>
<control variable> ::= <identifier>
<for list> ::= <initial value> to
<final value> | <initial value> downto <final
value>
<initial value> ::= <expression>
<final value> ::= <expression>
<with statement> ::= with <record
variable list> do <statement>
<record variable list> ::= <record variable> {,
<record variable>}