# 2025-02-03
# 2025-02-13
# https://smlweb.cpsc.ucalgary.ca/start.html
# https://smlweb.cpsc.ucalgary.ca/example-grammars/

# pan grammar

# dotlr



########################################
# module ###############################
########################################

<_> =| <whitespace>* ;

<whitespace> =| ' \t\n' ;

# TODO `#!/usr/bin/...`
<program> =| <_> <declaration>* ;

<declaration> =
| <pub>? "var" <whitespace> <_> <mut>? <hash>? <identifier> <compile_type>? '=' <_> <expr> ';' <_>
# TODO compile_var mutability..
# TODO "ref", "err", "out"
;
<pub> =| "pub" <whitespace> <_> ;
<mut> =| "mut" <whitespace> <_> ;
<hash> =| "#" <_> ;

<compile_expr> =
| <literal>
| "#" <_> <atom>
;

<compile_type> =
| ":" <_> <type>
| ":" <_> "#" <_> <atom>
;

<assignment> =| <left_hand_side> '=' <_> <expr> ';' <_> ;

# TODO should the semicolon be in the statement rule ?
<statement> =
| <declaration>
| <assignment>
| <expr> ";" <_>
| <defer_identifier> <defer_param>? <block> ";" <_>
| <loop_control_identifier> <label>? <expr>? ";" <_>
;
<defer_param> =| "|" <_> <identifier> "|" <_> ;

# keyword "defer" and "errdefer"
<defer_identifier> =| <identifier> ;

# keyword "break" and "continue"
<loop_control_identifier> =| <identifier> ;



########################################
# types ################################
########################################

<type> =
| <simple_type>
| "*" <_> <expr>
| "[" <_> <expr> "]" <_> <expr>
| "[" <_> "]" <_> <expr>
| "?" <_> <expr>
| <errorset> '!' <_> <expr>
# TODO record
# TODO class
# TODO enum
# TODO union
# TODO variant
;

<simple_type> =
| "void" <_>
| "bool" <_>
| "u" <digit>+ <_> # "u1", "u8", "u16", "u32", "u64"
| "s" <digit>+ <_> # "s1", "s8", "s16", "s32", "s64"
| "usize" <_>
| "isize" <_>
| "f32" <_>
| "f64" <_>
;



########################################
# functions ############################
########################################

<function> =| <fn_lambda> <parameter_list>? <block> ;

<fn_lambda> =
| "fn" <_> <compile_type>  # fn, stand-alone types
| "."  <_>                 # lambda, type signature inferred
# TODO '.' prefix is large gramatic allocation
;

# TODO generalize argument lists

# <parameter_list> =| '|' ( <parameter> ',' )* ( <parameter> ','? )? '|' ;
<parameter_list> =| "|" <_> <parameter_list_inner>? "|" <_> ;
<parameter_list_inner> =
| <parameter> "," <_> <parameter_list_inner>
| <parameter> <comma_space>
| 
;

<parameter_one> =| "|" <_> <parameter> "|" <_> ; # TODO consider replace parameter_list

<parameter> =| <ref>? <hash_space>? <identifier> <comp_type>? ;
<ref> =| "ref" <whitespace> <_> ;

<hash_space> =| "#" <_> ;



########################################
# control flow #########################
########################################

<block> =| "{" <_> <statement>* <expr>? "}" <_> ;

<if> =| "if" <_> "(" <_> <expr> ")" <_> <parameter_one>? <block> <elif>* <else>? ;
<elif> =| "elif" <_> <block> ;
<else> =| "else" <_> <parameter_one>? <block> ;

<for> =| "for" <_> "(" <for_list> ")" <_> <parameter_list>? <block> <for_else>? ;
<for_else> =| "else" <_> <block> ;

# <for_list> =| ( for_arg ',' )* for_arg ','? ;
<for_list> =| <for_list_inner> <for_arg> <comma_space>? ;
<for_list_inner> =
| <for_arg> <comma_space> <for_list_inner>
| <for_arg> <comma_space>?
;

<for_arg> =
| <expr>
| <range>
;

<range> =| <expr> ".." <_> <expr> ; # TODO optional exprs ?

# TODO update_expr, after parameter, before block
## normal `while( it.next() ) |val| { ... }`
## zig    `while( i < 10 ) :( i += 1 ) { ... }`
## pan `while( i < 10 ) { defer { i += 1; }; ... }`
<while> =| "while" <_> "(" <_> <expr> ")" <_> <parameter_one>? <block> <for_else>? ;

# TODO
<switch> =|
	"switch" <_> "(" <_> <expr> ")" <_>
	<switch_case>*
	<else_one>?
;
<else_one> =| "else" <_> <parameter_one>? <block> ;

# TODO should case arguments be required comptime, like types ?
<switch_case> =| "case" <_> "(" <_> <arg_list>? ")" <_> <parameter_one>? <block> ;

# <arg_list> =| ( <expr> ',' )* <expr> ','? ;
<arg_list> =| <arg_list> <expr> <comma_space>? ;
<arg_list> =
| <expr> <comma_space> <arg_list>
| <expr> <comma_space>?
|
;



########################################
# expr #################################
########################################

<expr> =
| <binary>
# atom # thru the binary_exprs
;

# equality, comparison, addition, multiplication, unary
<binary> =| <comparison> ;

# <bool_combo> =| <comparison> ( <bool_operator> <comparison> )* ;
<bool_combo> =| <comparison> <bool_comp>* ;
<bool_comp> =| <bool_operator> <comparison> ;

<bool_operator> =
| "and" <_>
| "or" <_>
;

# <comparison> =| <addition> ( <comparison_operator> <addition> )* ;
<comparison> =| <addition> <addition_comp>* ;
<addition_comp> =| <comparison_operator> <addition> ;
<comparison_operator> =
| "=="  <_>
| "<>"  <_>
| "<"   <_>
| "<="  <_>
| ">"   <_>
| ">="  <_>
;
<addition> =
# <multiplication> ( <addition_operator> <multiplication> )*
| <multiplication> <multiplication_comp>*
; # sum
<multiplication_comp> =| <addition_operator> <multiplication> ;
<addition_operator> =| '+-' <_> ;
<multiplication> =| <atom> ; # product
<multiplication_operator> =| '*/%' <_> ;

<bitwise> = # TODO
# <expr> ( ( '`''|''`' | '`''&''`'  | '<''<' | '>''>' ) <expr> )*
| <expr> <bitwise_operation>*
# TODO maybe `$&` and `$|`
# TODO sign extend shift right..
# TODO rotate left, rotate right..
;
<bitwise_operation> =| <bitwise_operator> <expr> ;
<bitwise_operator> =
| "`|`" <_>
| "`&`" <_>
| "<<" <_>
| ">>" <_>
;

<atom> =
| <left_hand_side>
| <atom> "." <_> "!" <_> # `atom iferr |e| { return e; }`
| <atom> "." <_> "?" <_> # TODO trap or error or panic ? fallible function,
# `if( atom ) |a| { a } else { return error.nil; }` # fallible function
# `if( atom ) |a| { a } else { trap; }` # XXX hidden trap, like assert..
| <atom> "." <_> "&" <_>
| <atom> "." <_> "~" <_>
| <atom> "." <_> "+" <_>
| <atom> "." <_> "-" <_>
| <literal>
| <struct_val> # TODO
| <type>
| <call>
| <slice>
| <block>
| <expr> "ifnil" <_> <parameter_one>? <block>
| <expr> "iferr" <_> <parameter_one>? <block>
| <expr> "catch" <_> <parameter_one>? <switch_block> # TODO
| <if>
| <for>
| <while>
| <switch> # TODO
;

<struct_val> =
| "." <_> "(" <_> <struct_val_fields>? ")" <_>
| <expr>  "(" <_> <struct_val_fields>? ")" <_>
;

# .( .k1 = v1, .k2 = "v2" ) // shorthand
# .( val1, val2, ) // tuple
# List ( .allocator = c_allocator ) // explicit
<struct_val_fields> =
# ( '.' <_> <identifier> '=' <_> <expr> ',' )* '.' <_> <identifier> '=' <_> <expr> ','? <_>
| <record_field>
# ( <expr> ',' <_> )* <expr> ','? <_>
| <tuple_field>
;
# ( '.' <_> <identifier> '=' <_> <expr> ',' )* '.' <_> <identifier> '=' <_> <expr> ','? <_>
<record_field> =
| "." <_> <identifier> "=" <_> <expr> "," <_> <record_field>
| "." <_> <identifier> "=" <_> <expr> <comma_space>?
# TODO consider empty struct literals, zero fields..
;
<tuple_field> =
| <expr> "," <_> <tuple_field>
| <expr> <comma_space>?
# TODO consider empty tuples
;
<comma_space> =| "," <_> ;

<call> =| <expr> "(" <_> <argument_list> ")" <_> ;

<index> =| <expr> "[" <_> <expr> "]" <_> ;

<slice> =| <expr> "[" <_> <expr>? ".." <_> <expr>? "]" <_> ;

# <argument_list> =| ( <expr> ',' )* ( <expr> ','? )? ;
<argument_list> =
| <expr> "," <_> <argument_list>
| <expr> <comma_space>?
| 
;



########################################
# identifier and literals ##############
########################################

<identifier> =| <letter> <alphanumeric>* ;

<letter> =
# "a".."z"
| 'abcdefghijklmnopqrstuvwxyz'
# "A".."Z"
| 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
# "_"
| '_'
;
<alphanumeric> =
| <letter>
# "0".."9"
| '0123456789'
;

<literal> =
| "undefined"
| "nil"
| <boolean>
| <number>
| <string>
| <function>
;

<boolean> =
| "true"
| "false"
;

<number> =
| <integer>
| <float>
;

<integer> =
| '+-'? <digit>+
| '+-'? "0x" <hex>+
| '+-'? "0b" <bin>+
# character literal
# TODO escape backslash
|         "0'" <dot> "'"
;

<dot> =
| 'abcdefghijklmnopqrstuvwxyz'
| 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
| '0123456789'
| '`~!@#$%^&*()-_=+'
| '[{]}\\|'
| ';:\'"'
| ',<.>/?'
;

<sign> =| '+-' ;

# <digit> =| "0".."9" ;
<digit>  =| '0123456789'  ;
<digit_> =| '0123456789_' ;
<hex> =
| '0123456789_'
| 'abcdefABCDEF'
;
<bin> =| '01_' ; # "0".."1"

<float> =
# <sign>? <digit> <digit_>* '.'  <digit_>+ ( 'p' <sign>?  <digit_>+ )?
# <sign>? '0''x'     <hex>+ '.'     <hex>+ ( 'p' <sign>?     <hex>+ )?
# <sign>? '0''b'     <bin>+ '.'     <bin>+ ( 'p' <sign>?     <bin>+ )?
| '+-'? <digit> <digit_>* "."  <digit_>+ <float_dec_suffix>?
| '+-'? "0x"       <hex>+ "."     <hex>+ <float_hex_suffix>?
| '+-'? "0b"       <bin>+ "."     <bin>+ <float_bin_suffix>?
;
<float_dec_suffix> =| "p" '+-'?  <digit_>+ ;
<float_hex_suffix> =| "p" '+-'?     <hex>+ ;
<float_bin_suffix> =| "p" '+-'?     <bin>+ ;

<string> =
| '"' <not_quote_not_newline>* '"'
| '/' '"' <not_newline>* '\n'
;

# <not_quote_not_newline> = TODO ;

# <not_newline> = TODO ;

<left_hand_side> = # resident, assignable
| <identifier>
| <atom> "." <_> <identifier>
| <atom> "." <_> <digit>+
| <atom> "." <_> "*" <_>
| <atom> "[" <_> <expr> "]" <_>
| <atom> "[" <_> <expr> ".." <_> <expr> "]" <_>
;



########################################
# remaining issues #####################
########################################

# expr + + 7 # bad, invalid
# expr + +7 # good, definitive
# expr ++ 7 # odd, definitive, but wrong
# expr ++7 # valid, but difficult; ( expr + signed_integer ) or ( expr ++ expr )