// BNF grammar for BCPL
// Tom Crick (tomcrick@users.sourceforge.net)
// http://gccbcpl.sourceforge.net
// 2004-07-26


// Identifiers, strings, numbers

<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
<octal digit>		::= 0|1|2|3|4|5|6|7
<hex digit>		::= 0|1|2|3|4|5|6|7|8|9|A|B|C|D|E|F
<digit>			::= 0|1|2|3|4|5|6|7|8|9
<string constant>	::= "<255 or fewer characters>"
<character constant>	::= '<one character>'
<octal number>		::= #<octal digit>[<octal digit>]
<hex number>		::= #X<hex digit>[<hex digit>]
<number>		::= <octal number> | <hex number> | <digit>[<digit>]
<identifier>		::= <letter>[<letter> | <digit> | .]


// Operators

<address op>		::= @ | !
<mult op>		::= * | / | REM
<add op>		::= + | -
<rel op>		::= = | ¬= | <= | >= | < | >
<shift op>		::= << | >>
<and op>		::= &
<or op>			::= |
<eqv op>		::= EQV | NEQV
<not op>		::= ¬


// Expressions

<element>		::= <character constant> | <string constant> | <number> | <identifier> | TRUE | FALSE
<primary E>		::= <primary E>(<expression list>) | <primary E>( ) | (<expression>) | <element>
<vector E>		::= <vector E> ! <primary E> | <primary E>
<address E>		::= <address op><address E> | <vector E>
<mult E>		::= <mult E><mult op><address E> | <address E>
<add E>			::= <add E><add op><mult E> | <add op><mult E> | <mult E>
<rel E>			::= <add E>[<rel op><add E>]
<shift E>		::= <shift E><shift op><add E> | <rel E>
<not E>			::= <not op><shift E> | <shift E>
<and E>			::= <not E>[<and op><not E>]
<or E>			::= <and E>[<or op><and E>]
<eqv E>			::= <or E>[<eqv op><or E>]
<conditional E>		::= <eqv E> -> <conditional E>,<conditional E> | <eqv E>
<expression>		::= <conditional E> | TABLE<constant expression>[,<constant expression>] | VALOF<command>


// Constant-expressions

<c element>		::= <character constant> | <number> | <identifier> | TRUE | FALSE | (<constant expressions>)
<c mult E>		::= <c mult E><mult op><c element> | <c element>
<c add E>		::= <c add E><add op><c mult E> | <add op><c mult E> | <c mult E>
<c shift E>		::= <c shift E><shift op><c add E> | <c add E>
<c and E>		::= <c and E><and op><c shift E> | <c shift E>
<constant expression>	::= <constant expression><or op><c and E> | <c and E>


// Lists of expressions and identifiers

<expression list>	::= <expression>[,<expression>]
<name list>		::= <name>[,<name>]


// Declarations

<manifest item>		::= <identifier>=<constant expression>
<manifest list>		::= <manifest item>[;<manifest item>]
<manifest declaration>	::= MANIFEST$(<manifest list>$)
<static declaration>	::= STATIC$(<manifest list>$)
<global item>		::= <identifier>:<constant expression>
<global list>		::= <global item>[;<global item>]
<global declaration>	::= GLOBAL$(<global list>$)
<simple definition>	::= <name list>=<expression list>
<vector definition>	::= <identifier>=VEC<constant expression>
<function definition>	::= <identifier>(<name list>)=<expression> | <identifier>( )=<expression>
<routine definition>	::= <identifier>(<name list>) BE<command> | <identifier> ( ) BE<command>
<definition>		::= <simple definition> | <vector definition> | <function definition> | <routine definition>
<simultaneous declaration>	::= LET <definition>[ AND <definition>]
<declaration>		::= <simultaneous declaration> | <manifest declaration> | <static declaration> | <global declaration>


// LHS expressions

<lhse>			::= <identifier> | <vector E> ! <primary E> | !<primary E>
<left hand side list>	::= <lhse>[,<lhse>]


// Unlabelled commands

<assignment>		::= <left hand side list>:=<expression list>
<simple command>	::= BREAK | LOOP | ENDCASE | RETURN | FINISH
<goto command>		::= GOTO <expression>
<routine command>	::= <primary E>(<expression list>) | <primary E> ( )
<resultis command>	::= RESULTIS <expression>
<switchon command>	::= SWITCHON <expression> INTO <command command>
<repeatable command>	::= <repeatable command> REPEAT | <repeatable command> REPEATUNTIL <expression> |
			    <repeatable command> REPEATWHILE <expression>
<until command>		::= UNTIL <expression> DO <command>
<while command>		::= WHILE <expression> DO <expression>
<for command>		::= FOR <identifier> = <expression> TO <expression> BY <constant expression> DO <command> |
			    FOR <identifier> = <expression> TO <expression> DO <command>
<repetitive command>	::= <repeated command> | <until command> | <while command> | <for command>
<test command>		::= TEST <expression> THEN <command> ELSE <command>
<if command>		::= IF <expression> THEN <command>
<unless command>	::= UNLESS <expression> THEN <command>
<unlabelled command>	::= <repeatable command> | <repetitive command> | <test command> | <if command>


// Labelled commands

<label prefix>		::= <identifier> :
<case prefix>		::= CASE <constant expression> :
<default prefix>	::= DEFAULT :
<prefix>		::= <label prefix> | <case prefix> | <default prefix>
<command>		::= <unlabelled command> | <prefix> <command> | <prefix>


// Blocks and compound statements

<command list>		::= <command>[;<command>]
<declaration part>	::= <declaration>[;<declaration>]
<block>			::= $( <declaration part> ; <command list> $)
<compound command>	::= $( <command list> $)
<program>		::= <declaration part>

// At the outmost level, a BCPL program is a sequence of declarations