#
# BNF for Shannon:
#   repeat 0 or more times: {...}
#   optional: [...]
#   group: (...)
#   OR: |
#   literal: "..." or '...'
#   any word: reference to another syntactic element
#   glue: ## (otherwise elements are separated by whitespace or can be 
#       distinguished by the parser)
#   <SEP> is one or more new lines and/or semicolons
#   Comments are like in C++ /* */ and //
#


# ---------- Statements

program ::= { statement } <EOF>

statement ::= definition | var-def | sub-block | builtin | assignment | fifo-push |
     if-block | case-block | while-block | for-block | 'break' | 'continue' |
     return | delete | insert

block ::= single-block | multi-block

single-block ::= ':' [ <SEP> ] statement

multi-block ::= [ <SEP> ] '{' [ <SEP> ] { statement } '}' 

definition ::= 'def' [ type-expr ] ident { type-derivator } '=' const-expr <SEP>

var-def ::= 'var' [ type-expr ] ident { type-derivator } '=' expr <SEP>

sub-block ::= 'begin' block

builtin ::= assertion | dump | exit

assertion ::= 'assert' expr <SEP>

dump ::= 'dump' expr { ',' expr } <SEP>

exit ::= 'exit' expr <SEP>

assignment ::= designator [ assignment-opr expr ] <SEP>

assignment-opr = '=' | '+=' | '-=' | '*= ' | '/=' | '%=' | '|='

fifo-push ::= expr '<<' expr { '<<' expr } <SEP>

if-block ::= 'if' expr block { 'elif' expr block } [ 'else' block ]

case-block ::= 'case' expr '{' case-label { case-label } [ 'default' block ] '}'

case-label ::= case-range { ',' case-range } block

case-range ::= expr [ '..' expr ]

while-block ::= 'while' expr block

for-block ::= 'for' ident [ ',' ident ] '=' expr [ '..' expr ] block

return ::= 'return' [ expr ] <SEP>

delete ::= 'del' designator <SEP>

insert ::= 'ins' designator '=' expr <SEP>


# ---------- Const Expression

const-expr ::= subrange-type | enum-type | expr

subrange-type ::= expr '..' expr

enum-type ::= '(' ident { ',' ident } ')'  -- this is not correct

type-expr ::= const-expr


# ---------- Expression

expr ::= and-level { ( 'or | 'xor' ) and-level }

and-level ::= not-level { ( 'and' | 'shl' | 'shr' ) not-level }

not-level ::= [ 'not' ] relation

relation ::= arithm-expr [ 'in' in-expr |
    ( '==' | '!=' | '<' | '<=' | '>' | '>=' ) arithm-expr ]

in-expr ::= arithm-expr [ '..' arithm-expr ]

arithm-expr ::= term { ( '+' | '-' ) term }

term ::= cat-expr { ( '*' | '/' | '%' ) cat-expr }

cat-expr ::= factor { '|' factor }

factor ::= [ '-' ] designator [ '?' ] [ ( 'as' | 'is' ) type-expr ]

designator ::= [ '@' ] atom { '.' ident | '[' index-expr ']' |
    '(' [ actual-args ] ')' }

atom ::= ident | number | string-literal | vec-ctor | dict-ctor |
    fifo-ctor | range-ctor | if-func | typeof | type-spec | 'this' | '(' expr ')'

vec-ctor ::= '[' [ expr { ',' expr } ] ']'

dict-ctor ::= '{' [ dict-elem { ',' dict-elem } ] '}'

dict-elem ::= expr [ '=' expr ]

fifo-ctor ::= '<' [ expr { ',' expr } ] '>'

range-ctor ::= '[' expr '..' expr ']'

if-func ::= 'if' '(' expr ',' expr ',' expr ')'

typeof ::= 'typeof' designator

type-spec ::= ident { '*' type-derivator { type-derivator } }

type-derivator ::= container-derivator | prototype-derivator |
    state-derivator | '[..]' | '<>'

container-derivator ::= '[' [ const-expr ] ']'

prototype-derivator ::= formal-args

state-derivator ::= formal-args multi-block

formal-args ::= '(' formal-arg { ',' formal-arg } ')'

formal-arg ::= type-expr [ ident ] [ '=' const-expr ]

index-expr ::= expr [ '..' [ expr ] ]

actual-args ::= expr { ',' [ expr ] }


# ---------- Basic elements

ident ::= ( letter | "_" ) ## { letter | digit | "_" }

number ::= decimal | hexadecimal

decimal ::= digit ## { digit }

hexadecimal ::= "0x" ## hexdigit ## { hexdigit }

string-literal ::= "'" ## { string-element } ## "'"

string-element ::= printable-char | string-escape

string-escape ::= "\\" | "\t" | "\r" | "\n" | "\'"
        | ( "\x" ## hexdigit ## hexdigit )