compilation module=
program module | definition module | implementation module ;
program module=
"MODULE", module identifier, [ interrupt protection ], ";",
import lists,
module block, module identifier, "." ;
module identifier= identifier ;
definition module=
"DEFINITION", "MODULE", module identifier, ";",
import lists,
definitions,
"END", module identifier, "." ;
implementation module=
"IMPLEMENTATION", "MODULE", module identifier, [ interrupt protection ], ";",
import lists,
module block, module identifier, "." ;
import lists= { import list } ;
import list= simple import | unqualified import ;
simple import= "IMPORT", identifier list, ";" ;
unqualified import= "FROM", module identifier, "IMPORT", identifier list, ";" ;
export list= unqualified export | qualified export ;
unqualified export= "EXPORT", identifier list, ";" ;
qualified export= "EXPORT", "QUALIFIED", identifier list, ";" ;
interrupt protection= "[", protection expression, "]" ;
protection expression= constant expression ;
qualified identifier= { qualifying identifier, "." }, identifier ;
qualifying identifier= module identifier ;
definitions= { definition } ;
definition=
"CONST", { constant declaration, ";" } |
"TYPE", { type definition, ";" } |
"VAR", { variable declaration, ";" } |
procedure heading, ";" ;
type definition= type declaration | opaque type definition ;
opaque type definition= identifier ;
procedure heading= proper procedure heading | function procedure heading ;
proper procedure heading=
"PROCEDURE", procedure identifier, [ formal parameters ] ;
formal parameters= "(", [ formal parameter list ], ")" ;
formal parameter list= formal parameter, { ";", formal parameter } ;
function procedure heading=
"PROCEDURE", procedure identifier, formal parameters, ":", function result type ;
function result type= type identifier ;
formal parameter=
value parameter specification | variable parameter specification ;
value parameter specification= identifier list, ":", formal type ;
variable parameter specification= "VAR", identifier list, ":", formal type ;
declarations= { declaration } ;
declaration=
"CONST", { constant declaration, ";" } |
"TYPE", { type declaration, ";" } |
"VAR", { variable declaration, ";" } |
procedure declaration, ";" |
local module declaration, ";" ;
constant declaration= identifier, "=", constant expression ;
type declaration= identifier, "=", type denoter ;
variable declaration= variable identifier list, ":", type denoter ;
variable identifier list=
identifier, [ machine address ], { ",", identifier, [ machine address ] } ;
machine address= "[", value of address type, "]" ;
value of address type= constant expression ;
procedure declaration=
proper procedure declaration | function procedure declaration ;
proper procedure declaration=
proper procedure heading, ";",
( proper procedure block, procedure identifier | "FORWARD" ) ;
procedure identifier= identifier ;
function procedure declaration=
function procedure heading, ";",
( function procedure block, procedure identifier | "FORWARD" ) ;
local module declaration=
"MODULE", module identifier, [ interrupt protection ], ";",
import lists, [ export list ],
module block, module identifier ;
type denoter= type identifier | new type ;
ordinal type denoter= ordinal type identifier | new ordinal type ;
type identifier= qualified identifier ;
ordinal type identifier= type identifier ;
new type=
new ordinal type | set type |
packedset type | pointer type |
procedure type | array type |
record type ;
new ordinal type= enumeration type | subrange type ;
enumeration type= "(", identifier list, ")" ;
identifier list= identifier, { ",", identifier } ;
subrange type=
[0 pt] [ range type ], "[", constant expression, "..", constant expression, "]" ;
range type= ordinal type identifier ;
set type= "SET", "OF", base type ;
base type= ordinal type denoter ;
packedset type= "PACKEDSET", "OF", base type ;
pointer type= "POINTER", "TO", bound type ;
bound type= type denoter ;
procedure type= proper procedure type | function procedure type ;
proper procedure type=
"PROCEDURE", [ "(", [ formal parameter type list ], ")" ] ;
function procedure type=
"PROCEDURE", "(", [ formal parameter type list ], ")", ":", function result type ;
formal parameter type list=
formal parameter type, { ",", formal parameter type } ;
formal parameter type=
variable formal type | value formal type ;
variable formal type= "VAR", formal type ;
value formal type= formal type ;
formal type= type identifier | open array formal type ;
open array formal type= "ARRAY", "OF", open array component type ;
open array component type= formal type ;
array type= "ARRAY", index type, { ",", index type }, "OF", component type ;
index type= ordinal type denoter ;
component type= type denoter ;
record type= "RECORD", field list, "END" ;
field list= fields, { ";", fields } ;
fields= [ fixed fields | variant fields ] ;
fixed fields= identifier list, ":", field type ;
field type= type denoter ;
variant fields= "CASE", tag field, "OF", variant list, "END" ;
tag field= [ tag identifier ], ":", tag type ;
tag identifier= identifier ;
tag type= ordinal type identifier ;
variant list= variant, { "|", variant }, [ variant else part ] ;
variant else part= "ELSE", field list ;
variant= [ variant label list, ":", field list ] ;
variant label list= variant label, { ",", variant label } ;
variant label= constant expression, [ "..", constant expression ] ;
proper procedure block= declarations, [ procedure body ], "END" ;
procedure body= "BEGIN", block body ;
function procedure block= declarations, function body, "END" ;
function body= "BEGIN", block body ;
module block= declarations, [ module body ], "END" ;
module body= initialization body, [ finalization body ] ;
initialization body= "BEGIN", block body ;
finalization body= "FINALLY", block body ;
block body= normal part, [ "EXCEPT", exceptional part ] ;
normal part= statement sequence ;
exceptional part= statement sequence ;
statement=
empty statement | assignment statement | procedure call |
return statement | retry statement | with statement |
if statement | case statement | while statement |
repeat statement | loop statement | exit statement |
for statement ;
statement sequence= statement, { ";", statement } ;
empty statement= ;
assignment statement= variable designator, ":=", expression ;
procedure call= procedure designator, [ actual parameters ] ;
procedure designator= value designator ;
return statement= simple return statement | function return statement ;
simple return statement= "RETURN" ;
function return statement= "RETURN", expression ;
retry statement= "RETRY" ;
with statement= "WITH", record designator, "DO", statement sequence, "END" ;
record designator= variable designator | value designator ;
if statement= guarded statements, [ if else part ], "END" ;
guarded statements=
"IF", boolean expression, "THEN", statement sequence,
{ "ELSIF", boolean expression, "THEN", statement sequence } ;
if else part= "ELSE", statement sequence ;
boolean expression= expression ;
case statement= "CASE", case selector, "OF", case list, "END" ;
case selector= ordinal expression ;
case list= case alternative, { "|", case alternative }, [ case else part ] ;
case else part= "ELSE", statement sequence ;
case alternative= [ case label list, ":", statement sequence ] ;
case label list= case label, { ",", case label } ;
case label= constant expression, [ "..", constant expression ] ;
while statement=
"WHILE", boolean expression, "DO", statement sequence, "END" ;
repeat statement=
"REPEAT", statement sequence, "UNTIL", boolean expression ;
loop statement= "LOOP", statement sequence, "END" ;
exit statement= "EXIT" ;
for statement=
"FOR", control variable identifier, ":=", initial value,
"TO", final value, [ "BY", step size ], "DO",
statement sequence, "END" ;
control variable identifier= identifier ;
initial value= ordinal expression ;
final value= ordinal expression ;
step size= constant expression ;
variable designator=
entire designator | indexed designator |
selected designator | dereferenced designator ;
entire designator= qualified identifier ;
indexed designator=
array variable designator, "[", index expression, { ",", index expression }, "]" ;
array variable designator= variable designator ;
index expression= ordinal expression ;
selected designator= record variable designator, ".", field identifier ;
record variable designator= variable designator ;
field identifier= identifier ;
dereferenced designator= pointer variable designator, " " ;
pointer variable designator= variable designator ;
expression= simple expression, [ relational operator, simple expression ] ;
simple expression= [ sign ], term, { term operator, term } ;
term= factor, { factor operator, factor } ;
factor=
"(", expression, ")" |
logical negation operator, factor |
value designator | function call |
value constructor | constant literal ;
ordinal expression= expression ;
relational operator=
equals operator | inequality operator |
less than operator | greater than operator |
less than or equal operator | subset operator |
greater than or equal operator | superset operator |
set membership operator ;
term operator=
plus operator | set union operator |
minus operator | set difference operator |
logical disjunction operator | string catenate symbol ;
factor operator=
multiplication operator | set intersection operator |
division operator | symmetric set difference operator |
rem operator | div operator |
mod operator | logical conjunction operator ;
value designator=
entire value | indexed value |
selected value | dereferenced value ;
entire value= qualified identifier ;
indexed value= array value, "[", index expression, { ",", index expression }, "]" ;
array value= value designator ;
selected value= record value, ".", field identifier ;
record value= value designator ;
dereferenced value= pointer value, dereferencing operator ;
pointer value= value designator ;
function call= function designator, actual parameters ;
function designator= value designator ;
value constructor= array constructor | record constructor | set constructor ;
array constructor= array type identifier, array constructed value ;
array type identifier= type identifier ;
array constructed value=
"{", repeated structure component, { ",", repeated structure component }, "}" ;
repeated structure component=
structure component, [ "BY", repetition factor ] ;
repetition factor= constant expression ;
structure component=
expression | array constructed value |
record constructed value | set constructed value ;
record constructor= record type identifier, record constructed value ;
record type identifier= type identifier ;
record constructed value=
"{", [ structure component, { ",", structure component } ], "}" ;
set constructor= set type identifier, set constructed value ;
set type identifier= type identifier ;
set constructed value= "{", [ member, { ",", member } ], "}" ;
member= interval | singleton ;
interval= ordinal expression, "..", ordinal expression ;
singleton= ordinal expression ;
constant literal= whole number literal | real literal | string literal ;
constant expression= expression ;
actual parameters= "(", [ actual parameter list ], ")" ;
actual parameter list= actual parameter, { ",", actual parameter } ;
actual parameter= variable designator | expression | type parameter ;
type parameter= type identifier ;