# cool language called sea:

<id-start> ::= ...
<id-cont> ::= ...
<digit> ::= ...
<digits> ::= ...
<letter> ::= ...
<letter_> ::= <letter> | '_'
<digitletter_> ::= <digit> | <letter> | '_'
<ident> ::= <id-start>
        | <ident> <id-cont>

<program> ::= <declaration>*

<declaration> ::= <fn-decl> | <global-decl>

<fn-proto> ::= fn <ident> '(' <parameter-list> ,? ')' (-> <type-name>)?
<fn-decl> ::= <fn-proto> <block>

<parameter-list> ::= <parameter>
                 | <parameter-list> , <parameter>
<parameter> ::= <ident> : <type-name>

<block> ::= <statement>*
        | <block> <expr>

<statement> ::= <return-statement>
            | <expr-statement>
            | <assignment-statement>
            | <var-decl> ';'
<return-statement> ::= return <expr>? ';'
<expr-statement> ::= <expr> ';'
<assignment-statement> ::= <expr> <assignment-op> <expr> ';'
<assignment-op> ::= |= | &= | ^= | /= | *= | %= | <<= | >>= | += | -= | =

<expr> ::= <assignment-expr>

<assignment-expr> ::= <or-expr>
                  | <or-expr> <assignment-op> <assignment-expr>
<or-expr> ::= <and-expr>
           | <or-expr> || <and-expr>
<and-expr> ::= <bitor-expr>
           | <and-expr> && <bitor-expr>
<bitor-expr> ::= <bitxor-expr>
           | <bitor-expr> '|' <bitxor-expr>
<bitxor-expr> ::= <bitand-expr>
           | <bitxor-expr> ^ <bitand-expr>
<bitand-expr> ::= <equality-expr>
           | <bitand-expr> & <equality-expr>
<equality-expr> ::= <relational-expr>
           | <equality-expr> (!= | ==) <relational-expr>
<relational-expr> ::= <shift-expr>
           | <relational-expr> (< | > | <= | >=) <shift-expr>
<shift-expr> ::= <add-expr>
           | <shift-expr> (<< | >>) <add-expr>
<add-expr> ::= <mul-expr>
           | <add-expr> (+ | -) <mul-expr>
<mul-expr> ::= <prefix-expr>
           | <mul-expr> (* | / | %) <prefix-expr>

<prefix-expr> ::= <prefix-op> <as-expr>
<prefix-op> ::= ! - & *

<as-expr> ::= <postfix-expr> as <type-name>

<postfix-expr> ::= <primary-expr>
               | <postfix-expr> '(' (<argument-list>,?)? ')'

<argument-list> ::= <argument>
                 | <parameter-list> , <argument>
<argument> ::= <expr>
           | <ident>: <expr>

<primary-expr> ::= <constant>
               | <literal>
               | <ident>
               | '(' <expr> ')'
               | <block>

<var-decl> ::= (let | var) <ident> (':' <type-name>)? ( = <expr> )?
<global-decl> ::= <var-decl> ';'

<type-name> ::= <ident>
            | <primitive-type>
            | <pointer>
<pointer> ::= '*' 'const'? <type-name>
<primitive-type> ::= bool
                 | <integral-type>
                 | <floating-type>
                 | void

<integral-type> ::= ('u' | 'i') <digits>+
<floating-type> ::= 'f'('32' | '64')

<constant> ::= <integral-constant>
           | <floating-constant>
<integral-constant> ::= <dec-digits><integral-type>?
                    | '0x' <hex-digits> <integral-type>?
                    | '0b' <bin-digits> <integral-type>?
                    | '0o' <oct-digits> <integral-type>?

<floating-constant> ::= <dec-digits> <floating-type>?
                    | '.' <dec-digits> <exp-part>? <floating-type>?
                    | <dec-digits> '.' <dec-digits>? <exp-part>? <floating-type>?

<exp-part> ::=  ('e' | 'E') ('-' | '+')? <dec-digits>