(* Dodo grammar *)

line_terminator ::= "\r\n" | "\n";
input_character ::= ~line_terminator sigma;
spacing ::= space*;
space ::= white_space | comment;
mls ::= multiline_space*;
multiline_space ::= space | line_terminator | end_of_line_comment;
white_space ::= [ \t\012]+ ;
comment ::= xml_comment;
xml_comment ::= "<!--" (~ "-->" sigma)* "-->";
end_of_line_comment ::= '#' (~ line_terminator sigma)* line_terminator;
separator ::= line_terminator | ';' | end_of_line_comment;

is_caps ::= [A-Z];

is_nocaps ::= [a-z];

is_alpha ::= [a-zA-Z];

is_alpha_num ::= [a-zA-Z0-9];

dodo_caps_letter ::= is_caps;
dodo_nocaps_letter ::= is_nocaps;

dodo_letter_or_digit ::= is_alpha_num | '_';

word_strict ::= cword_strict | nword_strict ;
cword_strict ::= dodo_caps_letter dodo_letter_or_digit* ;
nword_strict ::= dodo_nocaps_letter dodo_letter_or_digit* ;
word ::= '$'? word_strict "'"* | "$_" ;
cword ::= '$'? cword_strict "'"* | "$_" ;
nword ::= '$'? nword_strict "'"* | "$_" ;

xml_docspec ::= "<?xml" xmltag_attr* mls "?>";
xmltag ::= '<' name:word_strict xmltag_attr* mls '>';
xmltag_attr ::= mls <XMLattr> name:word_strict spacing '=' spacing string_literal </XMLattr> ;
xmltag_close ::= <XMLclose> "</" name:word_strict ( ~'>' sigma)* '>' </XMLclose> ;
xmltag_no_body ::= '<' name:word_strict xmltag_attr* mls "/>";
xmltag_wrap ::= '<' name:"wrap" xmltag_attr* mls '>';

(* keyword ::= keywords  &word;*)

keywords ::=
  "test"
| "loop"
| "def"
| "default"
| "dispatch"
| "else"
| "filter"
| "fold"
| "for"
| "fun"
| "if"
| "is"
| "map"
| "match"
| "new"
| "parent"
| "return"
| "resume"
| "seed"
| "self"
| "throw"
| "try"
| "yield"
| "AND"
| "NOT"
| "OR"
| "UNDO"
| "XOR"
;


symchars ::=
      "->"
    | "==>"
    | "+=" 
    | "-=" 
    | "*=" 
    | "%=" 
    | "++" 
    | "--" 
    | "&&" 
    | "||" 
    | "<=" 
    | ">=" 
    | "!=" (*::=*)
    | ";" 
    | ":" 
    | "," 
    | "." 
    | "{" 
    | "}" 
    | "(" 
    | ")" 
    | "[" 
    | "]" 
    | "]0"
    | "!" 
    | "~" 
    | "+" 
    | "-" 
    | "*" 
    | "|" 
    | "%" 
    | "<" 
    | ">" 
    | "=" 
    | "?"
;

assign_op ::=
     '='
    | "+=" 
    | "-=" 
    | "*=" 
    | "%=" 
;

operator ::=
      "++" 
    | "--" 
    | "&&" 
    | "||" 
    | "<=" 
    | ">=" 
    | "!=" 
    | "!" 
    | "~" 
    | "+" 
    | "-" 
    | "*" 
    | "/"
    | "%" 
    | "<" 
    | ">" 
    | "=" 
;

integer_literal ::= <Integer> numeral spacing </Integer>;

numeral ::= hex_numeral
      | octal_numeral
      | decimal_numeral
;

hex_numeral ::= code:hex_code value:hex_digit+;
hex_code ::= '0' [xX] ;
hex_digit ::= [0-9a-fA-F];
octal_numeral ::= code:'0' value:octal_digit+;
octal_digit ::= [0-7];
decimal_numeral ::= value:[0-9]+;

floating_point_literal ::=
  <Float>
      m:digit+ '.' (f:fraction_part)? (exponent_part)? (t:float_type_suffix)? spacing
    | '.' f:fraction_part (exponent_part)? (t:float_type_suffix)? spacing
    | m:digit+ exponent_part (t:float_type_suffix)? spacing
    | m:digit+ (exponent_part)? t:float_type_suffix spacing
  </Float>
;

fraction_part ::= digit+;
exponent_part ::= [eE]e:([+\-]? digit+);
float_type_suffix ::= [fF];

digit ::= [0-9];

boolean_literal ::= <True/> "true" | <False/> "false";

character_literal ::=
    <Char>
    "'" value:single_character "'" spacing
    | value:escape_sequence spacing
    </Char>
;

single_character ::= ~"'" input_character;

string_literal ::= <String> '"' value:string_character* '"' spacing </String>;

string_character ::= ~'"' ~'\\' sigma | escape_sequence;

escape_sequence ::= octal_escape | unicode_escape | '\\' [0bfnrtv\\"']; (* " *)

unicode_escape ::= '\\' 'u' [0-9a-fA-F][0-9a-fA-F][0-9a-fA-F][0-9a-fA-F];

octal_escape ::= '\\' [0-3]?[0-7]?[0-7];

null_literal ::= <Null/> "null";

spacy_literal ::= floating_point_literal | integer_literal | character_literal | string_literal ;

regexp ::= <Regexp> '/' ( '\\' sigma | ~'/' sigma ) '/' | regexp_list | regexp_vartype | spacy_literal </Regexp> ;
regexp_list ::= <List> '[' regexps? ']' </List> ;
regexps ::= regexp ( ',' mls regexp )* ;
regexp_vartype ::= <Var> regexp_var ( '/' regexp_type )? </Var> ;
regexp_qualifier ::= <Maybe/> '?' | <Any/> '*' | <More/> '+' ;

prefix ::=
      ( op:"map" | op:"fold" | op:"seed" | op:"filter" | op:"match" | op:"return" | op:"throw" | op:"yield" ) white_space
    | <Label> label </Label>
;
prefix_new ::= "new" white_space ;
prefix_for ::= "for" white_space ;
prefix_in ::= "in" multiline_space ;
prefix_is ::= "is" multiline_space ;
prefix_resume ::= "resume" white_space ;
prefix_test ::= "test" white_space ;
prefix_loop ::= "loop" white_space ;
prefix_undo ::= "UNDO" white_space ;

identifier ::= name:word;
compound_ident ::= ( compound_ident_path '.' ~multiline_space )* identifier;
compound_ident_path ::= <Path> identifier ( list_index | call_arguments )? </Path> ;

class_ident ::= name:cword;
compound_class_ident ::= ( compound_ident_path '.' ~multiline_space )* class_ident;

var_ident ::= name:nword;
compound_var_ident ::= ( compound_ident_path '.' ~multiline_space )* var_ident ;
compound_operator ::= ( compound_ident_path '.' ~multiline_space )+ name:operator ;

reference ::= <Reference/> '.' ~multiline_space compound_var_ident ;

signal_ident ::= <Service> name:nword </Service> '!' ( compound_ident_path '.' ~multiline_space )+ class_ident ;

label ::= <Label> "$$" name:nword_strict </Label> ;

outfixing spacing do
  appending spacing do

    regexp_var ::= name:compound_var_ident ( '(' ( regexp_bindings | regexps )? ')' )? regexp_qualifier? ;
    regexp_binding ::= <Binding> identifier regexp </Binding> ;
    regexp_bindings ::= regexp_binding ( ',' regexp_binding )* ;
    regexp_type ::= <Type> name:compound_ident ( '(' regexp_bindings? ')' )? </Type> ;
  
    type_spec ::= <TypeSpec> type_fun | type_yield | type_dispatch | compound_ident ( type_suffix )* | "def" | '?' </TypeSpec> ;

    type_suffix ::= type_map_suffix | type_list_suffix;

    type_map_suffix ::= '[' prefix_for <MapKey> type_spec </MapKey> mls ']';

    type_list_suffix ::= <ListType> '[' ( mls type_list_sizes mls )? ']' </ListType>;
    type_list_sizes ::= type_list_size ( ',' mls type_list_size )* ;
    type_list_size ::= <Size> integer_literal </Size> ;
    
    type_fun ::= name:"fun" <FunType> '(' mls type_list? mls "->" mls type_continuations mls ')' </FunType> ;
    
    type_yield ::= name:"yield" <Param> '(' mls type_list? mls ')' </Param> ;
    
    type_dispatch ::= name:"dispatch" <Target> compound_ident </Target> ;

    type_continuations ::= type_continuation ( ',' mls type_continuation )* ;
    type_continuation ::= <ContType> type_spec | '(' mls type_list? mls ')' </ContType> ;
    type_list ::= type_spec ( ',' mls type_spec )* ;
    
    type_name ::= <Type> compound_ident </Type>;
    class_name ::= <Type> compound_class_ident </Type>;
    ident_name ::= <Ident> compound_ident </Ident>;
    var_name ::= compound_var_ident | compound_operator | reference ;
    simple_class_name ::= <Type> class_ident </Type>;
    simple_var_name ::= <Ident> var_ident </Ident>;

    literal ::=
          boolean_literal
        | null_literal
        | spacy_literal (* ~[a-zA-Z0-9_']   '*)
        | list_literal
        | map_literal
    ;

    list_literal ::= <List> '[' mls expression_list? mls ']' </List> ;
    map_literal ::= <Map> '[' mls proto_bindings? mls ']' </Map> ;


    proto_based ::= <New> prefix_new type_name ( mls proto_attributes )? class_qualifiers? class_body? </New> ;
    proto_attribute ::= <Binding> compound_ident expression </Binding> ;
    proto_attributes ::= '(' mls proto_bindings mls ')' ;
    proto_bindings ::= proto_attribute ( ',' mls proto_attribute )* ;

    class_qualifiers ::= <Qual> prefix_is mls class_name ( ',' mls class_name )* </Qual> ;
    class_body ::= <Body> mls '{' mls declarations mls '}' | ':' mls declarations mls '.' </Body> ;
    class_decl ::=
        <Parent> var_name </Parent> class_name
        ( (* prototype-based *) var_init | class_qualifiers? class_body )?
    ; 

    declaration ::=
        <Decl> 
            class_decl
            | conversion_decl
            | constructor_spec | constructor_decl
            | type_spec ( fun_specification | fun_declaration | var_declarations )
        </Decl>
    ;
    declaration_xml ::=
        <XMLbody>
            xmltag_no_body mls
            | xmltag_wrap mls ( test_match mls )* xmltag_close mls
            | xmltag mls declarations mls xmltag_close mls
        </XMLbody>
    ;
    declarations ::= declaration_xml* declaration? ( separator mls declaration_xml* declaration? )* ;
    
    var_declaration ::= <Var> compound_var_ident var_init? </Var> ;
    var_init ::= '=' mls <Init> expression </Init> ;
    var_declarations ::= var_declaration ( ',' var_declaration )* ;
    fun_declaration ::=
        <Fun> 
            compound_var_ident 
            parameters 
            ( var_init | fun_body )? 
        </Fun>
    ;
    fun_specification ::= <FunSpec> compound_var_ident '(' mls param_specs mls ')' </FunSpec> ;
    constructor_decl ::=
        <Constructor>
            class_ident
            parameters
            fun_body?
        </Constructor>
    ;
    constructor_spec ::= <ConstrSpec> class_ident '(' mls param_specs mls ')' </ConstrSpec> ;
    conversion_decl ::= <Conversion> "->" '(' mls type_list ')' ( var_init | fun_body )? </Conversion> ;
    
    fun_body ::= <Body> ':' mls instructions mls '.' | mls '{' mls instructions mls '}' </Body> ;
    instruction ::= undo_instr ( <Finally> mls "==>" instruction </Finally> )? ;
    undo_instr ::= <Undo> prefix_undo single_instr </Undo> | single_instr ;
    single_instr ::=
        test_instr 
        | loop_instr 
        | <Try> "try" fun_body </Try>
        | <Transaction> "transaction" fun_body </Transaction>
        | <Resume> prefix_resume label expression? </Resume> 
        | declaration
        | assign_instr 
        | expressions 
        | label
    ;
    instruction_xml ::=
        <XMLbody>
            xmltag_no_body mls
            | xmltag mls instructions mls xmltag_close mls
        </XMLbody>
    ;
    instructions ::= instruction_xml* instruction? ( separator mls instruction_xml* instruction? )* ;
    
    assign_instr ::= <Assign> <Ident> reference </Ident> op:assign_op expression </Assign> ;
    
    loop_instr ::= <Loop> "loop" fun_body | prefix_loop loop_header fun_body </Loop>;
    loop_header ::=
        <While> "while" mls expression </While> 
        | <Until> "until" mls expression </Until> 
        | <Foreach> "foreach" mls foreach_in | "foreach" mls '(' mls foreach_ins mls ')' </Foreach>
        | <For> "for" '(' mls ( for_init separator | ';' ) mls ( for_cond ';'? | ( for_cond separator | ';' ) mls for_step ) mls ')' </For>
    ;
    
    test_instr ::= <Test> "test" test_body | prefix_test expression fun_body | prefix_test match_header match_body </Test> ;
    
    test_body ::= ':' mls ( test_select mls )* '.' | mls '{' mls ( test_select mls )* '}' ;
    test_select ::=  <Case> expression_list fun_body </Case> ;
    
    match_header ::= <MatchVal> expression | '(' mls expression_list mls ')' </MatchVal> ;
    match_body ::= ':' mls ( test_match mls )* '.' | mls '{' mls ( test_match mls )* '}' ;
    test_match ::= <Case> regexp ( ',' mls regexp )* fun_body </Case> ; 
    
    for_cond ::= unfold_cond ;
    for_init ::= <Init> expressions </Init> ;
    for_step ::= <Step> expressions </Step> ;
    
    foreach_in ::= simple_var_name prefix_in mls expression ;
    foreach_ins ::= foreach_in ( ',' mls foreach_in )* ;

    param_specs ::= param_spec ( ',' param_spec )* ;
    param_spec ::= <Param> type_spec regexp_qualifier? </Param> ;
    parameters ::= <Param> '(' mls param_list? mls ')' </Param> ;
    param_list ::=
        <Decl> type_spec var_declarations </Decl>
        ( separator mls <Decl> type_spec var_declarations </Decl> )*
    ; 
    
    continuations ::= mls "->" continuation_body ( mls '|' continuation_body )* ;
    
    continuation_body ::= 
        <Cont> ( <Param> label? idents_continuation </Param> mls expressions )? </Cont> 
    ;
    
    idents_continuation ::= simple_var_name separator | '(' mls bindings? mls ')' ;
    bindings ::= binding ( ',' mls binding )* ;
    binding ::= simple_var_name | literal ;
    
    expression ::= <Expr> exp_comp continuations </Expr> | exp_comp ;
    exp_comp ::= 
        <Apply> prefix exp_comp </Apply> 
        | <Resume> prefix_resume label </Resume> 
        | exp_base
    ;
    exp_base ::= proto_based | <Expr> exp_atom exp_bool+ | exp_atom exp_compar exp_bool* </Expr> | exp_atom ;
        
    exp_bool ::=
        <Logic>
          op:"&&" mls exp_atom exp_compar?
        | op:"||" mls exp_atom exp_compar?
        </Logic>
        | exp_term
    ;
    
    (* support for chained comparisons eg. a = b = c or a < b <= c *)
    exp_compar_eq ::= op:'=' mls ( <Both> exp_compar_with exp_compar_eq </Both> | exp_compar_with ) ;
    exp_compar_lt ::=
        op:'<'  mls ( <Both> exp_compar_with exp_compar_lt </Both> | exp_compar_with )
        | op:"<=" mls ( <Both> exp_compar_with exp_compar_lt </Both> | exp_compar_with ) 
    ;
    exp_compar_gt ::=
        op:'>'  mls ( <Both> exp_compar_with exp_compar_gt </Both> | exp_compar_with )
        | op:">=" mls ( <Both> exp_compar_with exp_compar_gt </Both> | exp_compar_with )
    ;
    
    exp_compar ::= 
        <Compar>
            exp_compar_eq
            | exp_compar_lt
            | exp_compar_gt
            | op:"!=" mls exp_compar_with
            | op:'~' mls regexp
        </Compar>
    ;
    
    exp_compar_with ::= <Expr> exp_atom exp_term+ </Expr> | exp_atom;
    
    exp_term ::=
        <Arith>
          op:'+' mls exp_atom exp_factor*
        | op:'-' mls exp_atom exp_factor*
        </Arith>
        | exp_factor
    ;
        
    exp_factor ::=
        <Arith>
          op:'*' mls exp_atom
        | op:'/' mls exp_atom
        </Arith>
    ;
        
    exp_atom ::=
          literal 
        | if_else
        | lambda
        | unfold
        | exp_unary 
        | label exp_atom
        | exp_var_atom 
    ;
    
    exp_unary ::=
        <Arith>
          op:"++" exp_var_atom
        | op:"--" exp_var_atom
        | op:'-' exp_var_atom
        </Arith>
        |
        <Logic>
          op:"!" exp_var_atom
        </Logic>
    ;
    
    exp_var_atom ::=
          '(' mls expressions mls ')'
        | <Signal> signal_ident call_arguments </Signal>
        | <Constr> class_name call_arguments </Constr>
        | <Var> var_name ( list_index | call_arguments )? </Var>
    ;
    
    list_index ::= <Index> '[' mls ( <From/> integer_literal '+' | expression_list ) mls ']' </Index> ; 
    call_arguments ::= <Arguments> '(' mls expression_list? mls ')' </Arguments> ;
    
    expressions ::= <Expr> expression ( ',' mls <Cont> <Param/> expressions </Cont> ) </Expr> | expression ;
    expression_list ::= expression ( ',' mls expression )* ;
    
    if_else ::=
        <If>
        "if" mls '(' mls <Cond> expression </Cond> mls ')' mls
        <Then> expressions </Then> mls
        "else" mls <Else> expressions </Else>
        </If> 
    ;
    
    lambda ::=
        <Lambda>
        "fun" ':' mls lambda_param separator mls expressions mls '.'
        | "fun" mls '{' mls lambda_param separator mls expressions mls '}'
        </Lambda>
    ;
    
    lambda_param ::= <Param> param_list? mls "->" mls lambda_cont ( ',' mls lambda_cont )* </Param> ;
    lambda_cont ::= <Decl> simple_var_name type_continuation ( <Init> '=' simple_var_name </Init> )? </Decl> ;
    
    unfold ::=
        <Unfold>
        "unfold" ':' mls unfold_parts mls '.'
        | "unfold" mls '{' mls unfold_parts mls '}'
        </Unfold>
    ;
    unfold_parts ::= ( unfold_inits separator | ';' ) mls ( unfold_cond separator | ';' ) mls unfold_steps? ;
    
    unfold_inits ::= unfold_init ( ',' mls unfold_init )* ;
    unfold_init ::= <Init> var_ident '=' mls expression </Init> ;
    unfold_cond ::= <Cond> expressions </Cond> ;
    unfold_steps ::= unfold_step ( ',' mls unfold_step )* ;
    unfold_step ::= <Step> expressions ( prefix_in mls <Value> expression </Value> )? </Step> ;

  done;
done;

start ::= ( <XMLdoc> xml_docspec </XMLdoc> )? mls declarations mls EOF ;