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>}