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' | 'o' | 'p'
                    | 'q' | 'r' | 's' | 't' | 'u' | 'v' | 'w'
                    | 'x' | 'y' | 'z' ;

all_characters      ::= ;
digit               ::= '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' ;
hexadecimal_digit   ::= '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' |
                        '8' | '9' | 'A' | 'a' | 'B' | 'b' | 'C' | 'c' |
                        'D' | 'd' | 'E' | 'e' | 'F' | 'f';
octal_digit         ::= '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7';
binary_digit        ::= '0' | '1';

character           ::= letter | digit | '_' ;

identifier          ::= (letter | '_') { character };

float               ::= digit  { digit } '.' digit {digit};
dec_integer         ::= ['0D' | '0d'] digit {digit};
hex_integer         ::= ('0X'|'0x') hexadecimal_digit {hexadecimal_digit};
octal_integer       ::= ('0O'|'0o') octal_digit {octal_digit};
binary_integer      ::= ('0B'|'0b') binary_digit {binary_digit};
integer             ::= dec_integer | hex_integer | octal_integer | binary_integer;
number              ::= integer | float;

string              ::= ('\'' {all_characters} '\'' | '\"' {all_characters} '\"' | '\"\"\"' {all_characters} '\"\"\"');

assignop            ::= '=' | '+=' | '-=' | '*=' | '/=' | '|=' | '&=' | '^=' | '%=' | '**=' | '<<=' | '>>=' | '>>>=';
logicop             ::= '&&' | '||' | '^^' | 'and' | 'or' | 'xor';
compop              ::= '==' | '!=' | '<' | '<=' | '>' | '>=' | 'is' | '!is';
mathop              ::= '+' | '-' | '*' | '/' | '%' | '**';
bitop               ::= '&' | '|' | '^' | '<<' | '>>' | '>>>';


primtype            ::= 'void' | 'int' | 'int8' | 'int16' | 'int32' | 'int64' | 'uint' | 'uint8' | 'uint16' |
                        'uint32' | 'uint64' | 'float' | 'double' | 'bool';
datatype            ::= (identifier | primtype | 'auto');
scope               ::= ['::'] {identifier '::'} [identifier ['<' type {',' type} '>'] '::'];
type                ::= ['const'] scope datatype ['<' type {',' type} '>'] { ('[' ']') | ('@' ['const']) };
# ternary is defined further below due to a circular dependency: ternary->expr->exprterm->initlist->assign
assign              ::= ternary [ assignop assign ];
initlist            ::= '{' [assign | initlist] {',' [assign | initlist]} '}';
exprpreop           ::= '-' | '+' | '!' | '++' | '--' | '~' | '@';
arglist             ::= '(' [identifier ':'] assign {',' [identifier ':'] assign} ')';
funccall            ::= scope identifier arglist;
constructcall       ::= type arglist;
varaccess           ::= scope identifier;
cast                ::= 'cast' '<' type '>' '(' assign ')';
literal             ::= number | string | 'true' | 'false' | 'null';
typemod             ::= ['&' ['in' | 'out' | 'inout']];
# statblock is defined further below, as statements are higher level than expressions.
lambda              ::= 'function' '(' [[type typemod] identifier {',' [type typemod] identifier}] ')' statblock;

exprvalue           ::= 'void' | constructcall | funccall | varaccess | cast | literal | '(' assign ')' | lambda;
exprpostop          ::= ('.' (funccall | identifier)) | ('[' [ identifier ':'] assign {',' [ identifier ':' assign } ']' ) | arglist | '++' | '--';
exprterm            ::= ([type '='] initlist) | ({exprpreop} exprvalue {exprpostop});
expr                ::= exprterm {(mathop | compop | logicop | bitop) exprterm};
ternary             ::= expr ['?' assign ':' assign];

return              ::= 'return' [assign] ';';
exprstat            ::= assign ';';
continue            ::= 'continue' ';';
break               ::= 'break' ';';

# As these are all statements using other statements, they use the statement and statblock types defined further below.
if                  ::= 'if' '(' assign ')' statement ['else' statement];
for                 ::= 'for' '(' (var | exprstat) exprstat [assign {',' assign}] ')' statement;
while               ::= 'while' '(' assign ')' statement;
dowhile             ::= 'do' statement 'while' '(' assign ')' ';';
try                 ::= 'try' statblock 'catch' statblock;
case                ::= (('case' expr) | 'default') ':' {statement};
switch              ::= 'switch' '(' assign ')' '{' {case} '}';

statement           ::= (if | for | while | return | statblock | break | continue | dowhile | switch | exprstat | try );
var                 ::= ['private'|'protected'] type identifier [( '=' (initlist | expr)) | arglist] {',' identifier [( '=' (initlist | expr)) | arglist]} ';';
statblock           ::= '{' {var | statement} '}';

funcattr            ::= {'override' | 'final' | 'explicit' | 'property'};
paramlist           ::= '(' ['void' | (type typemod [identifier] ['=' expr] {',' type typemod [identifier] ['=' expr]})] ')';

virtprop            ::= ['private' | 'protected'] type ['&'] identifier '{' {('get' | 'set') ['const'] funcattr (statblock | ';')} '}';
func                ::= {'shared' | 'external'} ['private' | 'protected'] [((type ['&']) | '~')] identifier paramlist ['const'] funcattr (';' | statblock);
funcdef             ::= {'external' | 'shared'} 'funcdef' type ['&'] identifier paramlist ';'
class               ::= {'shared' | 'abstract' | 'final' | 'external' | 'mixin'} 'class' identifier
                        (';' | ([':' identifier {',' identifier}] '{' {virtprop | func | var | funcdef | class} '}'));
enum                ::= {'shared' | 'external'} 'enum' identifier [ ':' primtype ] (';' | ('{' identifier ['=' expr] {',' identifier ['=' expr]} '}'));
import              ::= 'import' type ['&'] identifier paramlist funcattr 'from' string ';';
typedef             ::= 'typedef' (primtype | identifier) identifier ';';

interfacemethod     ::= type ['&'] identifier paramlist ['const'] ';';
interface           ::= {'external' | 'shared'} 'interface' identifier (';' | ([':' identifier {',' identifier}] '{' {virtprop | interfacemethod} '}'));

namespace           ::= 'namespace' identifier '{' script '}';
script              ::= {import | enum | typedef | class | interface | funcdef | virtprop | var | func | namespace | ';'};