APPENDIX D: LANGUAGE SYNTAX DESCRIPTION
<letter> ::= A | B | C | D | E | F | G | H | I | J |
K | L | M | N | O | P | Q | R | S | T |
U | V | W | X | Y | Z | a | b | c | d |
e | f | g | h | i | j | k | l | m | n |
n | o | p | q | r | s | t | u | v | w |
x | y | z | @
<digit> ::= 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 |
A | B | C | D | E | F {only allowed in HEX numbers}
<special symbol> ::= {reserved words are listed in section 16.2}
+ | - | * | / | = | <> | < | > |
<= | >= | ( | ) | [ | ] | { | } |
:= | . | , | ; | : | ' | ^ |
{the following are additional or substitutions:}
(. | .) | ~ | \ | ? | ! | | | $ | & | #
(. is a synonym for [
.) is a synonym for ]
~, \, and ? are synonyms (see Section 8.1.1)
!, and | are synonyms (see Section 8.1.2)
& (see Section 8.1.3)
<identifier> ::= <letter> {<letter or digit or underscore>}
<letter or digit or underscore> ::= <letter> | <digit> | _
<digit sequence> ::= <digit> {<digit>}
<unsigned integer> ::= $ <digit sequence> |
<digit sequence>
<unsigned real> ::= <unsigned integer> . <digit sequence> |
<unsigned integer> . <digit sequence>
E <scale factor> |
<unsigned integer> E <scale factor>
<unsigned number> ::= <unsigned integer> | <unsigned real>
<scale factor> ::= <unsigned integer> | <sign><unsigned integer>
<sign> ::= + | -
<string> ::= ' <character> {<character>}' | ''
<constant identifier> ::= <identifier>
<constant> ::= <unsigned number> |
<sign><unsigned number> |
<constant identifier> |
<sign><constant identifier> |
<string>
<constant definition> ::= <identifier> = <constant>
<type> ::= <simple type> |
<structured type> |
<pointer type>
<type definition> ::= <identifier> = <type>
<simple type> ::= <scalar type> |
<subrange type> |
<type identifier>
<type identifier> ::= <identifier>
<scalar type> ::= ( <identifier> { , <identifier>} )
<subrange type> ::= <constant> .. <constant>
<structured type> ::= <unpacked structured type> |
PACKED <unpacked structured type>
<unpacked structured type> ::= <array type> |
<record type> |
<set type> |
<file type>
<array type> ::= <normal array> |
<string array>
<string array> ::= STRING <max length>
<max length> ::= [ <intconst> ] |
<empty>
<intconst> ::= <unsigned integer> |
<int const id>
<int const id> ::= <identifier>
<normal array> ::= 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 part> ::= CASE <tag field> <type identifier> OF
<variant> {;<variant>}
<variant> ::= <case label list> : (<field list>) |
<empty>
<case label list> ::= <case label> {,<case label>}
<case label> ::= <constant>
<tag field> ::= <identifier> : |
<empty>
<set type> ::= SET OF <base type>
<base type> ::= <simple type>
<file type> ::= file {of <type>}
<variable> ::= <var> |
<external var> |
<absolute var>
<external var> ::= EXTERNAL <var>
<absolute var> ::= ABSOLUTE [ <constant> ] <var>
<var> ::= <entire variable> |
<component variable> |
<referenced variable>
Declaration of variables of type STRING:
<identifier>{,<identifier>} : STRING {[<constant>]}
<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>
<unsigned constant> ::= <unsigned number> |
<string> |
NIL |
<constant identifier>
<factor> ::= <variable> |
<unsigned constant> |
<function designator> |
<expression> |
<logical not operator> <factor>
<set> ::= [ <element list> ]
<element list> ::= <element> {,<element>} |
<empty>
<element> ::= <expression> |
<expression> .. <expression>
<term> ::= <factor> <multiplying operator> <factor>
<simple expression> ::= <term> |
<simple expression> <adding operator> <term> |
<adding operator> <term>
<expression> ::= <simple expression> |
<simple expression> <relational operator>
<simple expression>
<logical not operator> ::= NOT | ~ | \ | ?
~ (synonyms \ and ?) is a NOT operator for non-booleans.
<multiplying operator> ::= * | / | DIV | MOD | AND | &
& is an AND operator on non-booleans.
<adding operator> ::= + | - | OR | | | !
! (synonym |) is an OR operator on non-booleans.
<relational operators> ::= = | <> | < | <= | > | >= | IN
<function designator> ::= <function identifier> |
<function identifier> ( <parm> {,<parm>} )
<function identifier> ::= <identifier>
<statement> ::= <label> : <unlabelled statement> |
<unlabelled statement>
<unlabelled statement> ::= <simple statement> |
<structured statement>
<label> ::= <unsigned integer>
<simple statement>::= <assignment statement> |
<procedure statement> |
<goto statement> |
<empty statement>
<empty statement> ::= <empty>
<assignment statement> ::= <variable> := <expression> |
<function identifier> := <expression>
<procedure statement> ::= <procedure identifier>( <parm> {,<parm>}) |
<procedure identifier>
<procedure identifier>::= <identifier>
<parm> ::= <procedure identifier> |
<function identifier> |
<expression> |
<variable>
<goto statement> ::= goto <label>
<structured statement> ::= <repetitive statment> |
<conditional statement> |
<compound statement> |
<with statement>
<compound statement> ::= BEGIN <statement> {;<statement>} END
<conditional statement> ::= <case statement> |
<if statement>
<if statement> ::= IF <expression> THEN <statement> ELSE <statement> |
IF <expression> THEN <statement>
<case statement> ::= CASE <expression> OF
<case list> {,<case list>}
{ELSE <statement>}
END
<case list> ::= <label list> : <statement> |
<empty>
<label list> ::= <case label> {,<case label>}
<repetitive statement> ::= <repeat statement> |
<while statement> |
<for statement>
<while statement> ::= WHILE <expression> DO <statement>
<repeat statement> ::= REPEAT <statement> {,<statement>}
UNTIL <expression>
<for statement> ::= FOR <ctrlvar> := <for list> DO <statement>
<for list> ::= <expression> DOWNTO <expression> |
<expression> TO <expression>
<ctrlvar> ::= <variable>
<with statement> ::= WITH <record variable list> DO <statment>
<record variable list> ::= <record variable> {,<record variable>}
<procedure declaration> ::= EXTERNAL <procedure heading> |
<procedure heading> <block>
<block> ::= <label declaration part>
<constant definition part>
<type definition part>
<variable declaration part>
<procfunc declaration part>
<statement part>
<procedure heading> ::= PROCEDURE <identifier> <parmlist> |
PROCEDURE <identifier> |
PROCEDURE INTERRUPT [ <constant> ] ;
<parmlist> ::= ( <fparm> {,<fparm>} )
<fparm> ::= <procedure heading> |
<function heading> |
VAR <parm group> |
<parm group>
<parm group> ::= <identifier> {,<identifier>} :
<type identifier> |
<identifier> {,<identifier>} :
<conformant array>
<conformant array> ::= ARRAY [ <indxtyp> {;<indxtyp>} ] OF
<conarray2>
<conarray2> ::= <type identifier> |
<conformant array>
<indxtyp> ::= <identifier> .. <identifier> :
<ordtypid>
<ordtypid> ::= <scalar type identifier> |
<subrange type identifier>
<label declaration part> ::= <empty> |
LABEL <label> {,<label>} ;
<constant definition part> ::= <empty> |
CONST
<constant definition>
{;<constant definition>} ;
<type definition part> ::= <empty> |
TYPE
<type definition>
{;<type definition>} ;
<variable declaration part> ::= <empty> |
VAR
<variable declaration>
{;<variable declaration>} ;
<procfunc declaration part> ::= {<proc or func> ; }
<proc or func> ::= <procedure declaration> |
<function declaration>
<statement part> ::= <compound statement>
<function decl> ::= EXTERNAL <function heading> |
<function heading> <block>
<functon heading> ::= FUNCTION <identifier><parmlist>:<result type> |
FUNCTION <identifier> : <result type> ;
<result type> ::= <type identifier>
<readcall> ::= <read or readln> {( {<filevar> ,} {<varlist>} )}
<read or readln> ::= READ | READLN
<filevar> ::= <variable>
<varlist> ::= <variable> {,<variable>}
<writecall> ::= <write or writeln>{( {<filevar> ,} {exprlist} )}
<write or writeln> ::= WRITE | WRITELN
<exprlist> ::= <wexpr> {,<wexpr>}
<wexpr> ::= <expression> {:<width expr> {:<dec expr>}}
<width expr> ::= <expression>
<dec expr> ::= <expression>
<program> ::= <program heading> <block> . |
<module heading>
<label declaration part>
<constant definition part>
<type definition part>
<variable declaration part>
<procfunc declaration part>
MODEND .
<program heading> ::= PROGRAM <identifier> {( <prog parms> )} ;
<module heading> ::= MODULE <identifier> ;
<prog parms> ::= <identifier> {,<identifier>}