The BigraphER language

<parens(X)> ::= LPAR X RPAR

<brackets(X)> ::= LSBR X RSBR

<bracketed_exp> ::= LSBR <exp> RSBR

<braces(X)> ::= LCBR X RCBR

<comma_list(X)> ::= [X (COMMA X)*]

<comma_nonempty_list(X)> ::= X (COMMA X)*

<model> ::= <dec_list> <rs> EOF

<dec_list> ::= (<dec> SEMICOLON)+

<dec> ::= INT <dec_gen>
        | FLOAT <dec_gen>
        | STRING <dec_gen>
        | <dec_ctrl>
        | <dec_big>
        | <dec_react>

<dec_gen> ::= IDE EQUAL <exp>

<dec_ctrl> ::= ATOMIC <ctrl_exp>
             | <ctrl_exp>

<ctrl_exp> ::= CTRL CIDE EQUAL CINT
             | FUN CTRL CIDE <parens(<ide_list_nonempty>)> EQUAL CINT

<dec_big> ::= BIG IDE EQUAL <bexp>
            | FUN BIG IDE <parens(<ide_list_nonempty>)> EQUAL <bexp>

<dec_react> ::= REACT IDE EQUAL <bexp> <arrow> <bexp> [<eta_exp>] [<conds>]
              | FUN REACT IDE <parens(<ide_list_nonempty>)> EQUAL <bexp>
                <arrow> <bexp> [<eta_exp>] [<conds>]

<arrow> ::= ARR
          | LARR <exp> RARR

<conds> ::= IF <comma_nonempty_list(<cond>)>

<cond> ::= [BANG] <bexp> IN <place>

<place> ::= PARAM
          | CTX

<eta_exp> ::= AT <brackets(<int_list>)>

<int_list> ::= <comma_list(CINT)>

<end_pos> ::= END

<rs> ::= BEGIN <rs_type> [(<'param'> SEMICOLON)+] <'init'> SEMICOLON
         <'rules'> [ACTIONS EQUAL
         <brackets(<comma_nonempty_list(<action_def>)>)> SEMICOLON] [PREDS
         EQUAL <braces(<comma_nonempty_list(<pred_def>)>)> SEMICOLON]
         <end_pos>

<rs_type> ::= BRS
            | PBRS
            | SBRS
            | ABRS

<pred_def> ::= IDE [<bracketed_exp>]
             | IDE <parens(<exp_list>)> [<bracketed_exp>]

<action_def> ::= IDE [<brackets(<exp>)>] EQUAL
                 <braces(<comma_nonempty_list(<rule_with_loc>)>)>

<rule_with_loc> ::= IDE

<init> ::= INIT IDE
         | INIT IDE <parens(<exp_list>)>

<exp_list> ::= <comma_nonempty_list(<exp>)>

<exp> ::= <add_exp>

<add_exp> ::= <mul_exp>
            | <add_exp> PLUS <mul_exp>
            | <add_exp> MINUS <mul_exp>

<mul_exp> ::= <unary_exp>
            | <mul_exp> PROD <unary_exp>
            | <mul_exp> SLASH <unary_exp>

<unary_exp> ::= <pow_exp>
              | MINUS <unary_exp>

<pow_exp> ::= <atom_exp>
            | <atom_exp> CARET <unary_exp>

<atom_exp> ::= CINT
             | CFLOAT
             | CSTRING
             | IDE
             | ABS <parens(<exp>)>
             | <parens(<exp>)>

<ide_list_nonempty> ::= <comma_nonempty_list(IDE)>

<param> ::= INT <ide_list_nonempty> EQUAL <param_int_exp>
          | FLOAT <ide_list_nonempty> EQUAL <param_float_exp>
          | STRING <ide_list_nonempty> EQUAL <param_str_exp>

<param_int_exp> ::= <exp>
                  | <braces(<exp_list>)>
                  | LSBR <exp> COLON <exp> COLON <exp> RSBR

<param_float_exp> ::= <exp>
                    | <braces(<exp_list>)>
                    | LSBR <exp> COLON <exp> COLON <exp> RSBR

<param_str_exp> ::= <exp>
                  | <braces(<exp_list>)>

<priority_class> ::= <braces(<comma_nonempty_list(<rule_ide>)>)>
                   | <parens(<comma_nonempty_list(<rule_ide>)>)>

<rules> ::= RULES EQUAL <brackets(<comma_list(<priority_class>)>)> SEMICOLON

<rule_ide> ::= IDE
             | IDE <parens(<exp_list>)>

<bexp> ::= <bpar_exp>

<bpar_exp> ::= <bcomp_exp> (PLUS <bcomp_exp>)*
             | <bpar_exp> PIPE <bcomp_exp> (PLUS <bcomp_exp>)*
             | <bpar_exp> DPIPE <bcomp_exp> (PLUS <bcomp_exp>)*

<bprefix_exp> ::= <wire_exp> <parens(<bexp>)>
                | <wire_exp> <ion_exp>
                | <wire_exp> <ion_exp> DOT <simple_bexp>
                | <wire_exp> IDE
                | <wire_exp> IDE <parens(<exp_list>)>
                | SHARE <simple_bexp> BY <simple_bexp> IN <simple_bexp>
                | <simple_bexp>

<simple_bexp> ::= <parens(<bexp>)>
                | <parens(<bexp>)> <parens(<bexp>)>
                | <id_exp>
                | MERGE <o_delim_int_2>
                | SPLIT <o_delim_int_2>
                | SLASH IDE
                | IDE SLASH <braces(<ide_list_nonempty>)>
                | <braces(IDE)>
                | CINT
                | LPAR <brackets(<comma_list(<braces(<int_list>)>)>)> COMMA
                  CINT RPAR
                | IDE
                | IDE <parens(<exp_list>)>
                | <ion_exp>
                | <ion_exp> DOT <simple_bexp>
                | PAR <parens(<exp> COMMA <bexp>)>
                | PPAR <parens(<exp> COMMA <bexp>)>

<id_exp> ::= ID <o_delim_int_1>
           | ID <braces(<ide_list_nonempty>)>
           | ID <parens(CINT COMMA <braces(<ide_list_nonempty>)>)>

<o_delim_int_1> ::= [<parens(CINT)>]

<o_delim_int_2> ::= [<parens(CINT)>]

<ion_exp> ::= CIDE [<braces(<ide_list_nonempty>)>]
            | CIDE <parens(<ctrl_param_exp_list>)>
              [<braces(<ide_list_nonempty>)>]

<ctrl_param_exp_list> ::= <comma_nonempty_list(<ctrl_param_exp_top>)>

<ctrl_param_exp_top> ::= <exp>
                       | <brackets(IDE)>
                       | LSBR IDE COLON <constraint_exp> RSBR
                       | <brackets(<constraint_exp>)>
                       | <brackets(<brackets(<ctrl_param_exp>)>)>

<ctrl_param_exp> ::= <ctrl_param_add>

<ctrl_param_add> ::= <ctrl_param_mul>
                   | <ctrl_param_add> PLUS <ctrl_param_mul>
                   | <ctrl_param_add> MINUS <ctrl_param_mul>

<ctrl_param_mul> ::= <ctrl_param_unary>
                   | <ctrl_param_mul> PROD <ctrl_param_unary>
                   | <ctrl_param_mul> SLASH <ctrl_param_unary>

<ctrl_param_unary> ::= <ctrl_param_atom>
                     | MINUS <ctrl_param_unary>

<ctrl_param_atom> ::= HOLE
                    | CINT
                    | CFLOAT
                    | CSTRING
                    | IDE
                    | ABS <parens(<ctrl_param_exp>)>
                    | <parens(<ctrl_param_exp>)>

<constraint_exp> ::= <constraint_and> (DPIPE <constraint_and>)*

<constraint_atom> ::= <comparison>
                    | BANG <parens(<constraint_exp>)>
                    | <parens(<constraint_exp>)>

<comparison> ::= <ctrl_param_exp> EQUAL <ctrl_param_exp>
               | <ctrl_param_exp> NEQUAL <ctrl_param_exp>
               | <ctrl_param_exp> LT <ctrl_param_exp>
               | <ctrl_param_exp> LTE <ctrl_param_exp>
               | <ctrl_param_exp> GT <ctrl_param_exp>
               | <ctrl_param_exp> GTE <ctrl_param_exp>

<wire_exp> ::= <closure>+
             | IDE SLASH <braces(<ide_list_nonempty>)>
             | SLASH <braces(<ide_list_nonempty>)>

<closure> ::= SLASH IDE