test.ebnf

(* TODO -
 *
 * Remove pointers.
   * Add either optional types or nullable types.
 * Are sets required?
 * Make everything immutable unless specified?
 * Add unsafe?
 * Add module definitions? These are in the ProgInOberon.pdf
 * Add child modules.
 * Add generics.
 * Add lambdas.
 * Add first class/pure functions?
 *)

(* A source file can either be a main function/entry point to the program or a library unit/module.
 * Each unit can import modules and each should be passed to the compiler.
 * A main function may or may not require command line arguments, i.e. an embedded systems program probably won't, an
 * OS kernel would, a program run on the command line would.
 *)
compilation_unit    =   function_decl (* TODO - Should this be a special rule? *)
                    |   module
                    ;

(* Wondering whether it's worth modules having an interface?
 * e.g.
 * [import_list]
 * "interface" qualified_identifier "is"
 *     decl_sequence
 * "end" qualified_identifier ";"
 *
 * "module" qualified_identifier ["implements" qualified_identifier {"," qualified_identifier}] "is"
 *
 * This would allow for implementations specific to various configurations, but that could also be done with a
 * specification/body split, as Ada does?
 *
 * I'm wanting a traits system as well, which would allow traits to also fit in there somewhere, maybe with
 * another keyword?
 *)
module              =   [import_list]
                        "module" qualified_identifier "is"
                            decl_sequence
                        ["begin"
                            statements]
                        "end" qualified_identifier ";"
                    ;

(* Allows to redefine module names, i.e. import System.OS as OS; *)
import_list         =   "import" qualified_identifier ["as" identifier] { ","
                                 qualified_identifier ["as" identifier] } ";"
                    ;

(* TODO - This seems to enable the keywords without the decl's. *)
decl_sequence       =   {   "constant" { constant_decl ";" }
                        |   "type" { type_decl ";" }
                        |   "var" { var_decl ";" } }
                        {   function_decl ";"
                        |   forward_decl ";" }
                    ;

constant_decl       =   identifier_def ":=" constant_expr ;

type_decl           =   identifier_def "is" type ;

(* TODO - Add default initialisation. *)
var_decl            =   identifier_list ":" type ;

function_decl       =   "function" [receiver] identifier_def [formal_params] "is"
                            decl_sequence
                        ["begin"
                            statements]
                        "end" identifier ";"
                    ;

(* TODO - Surely it's possible to do without forward declarations, like Go? *)
forward_decl        =   "function" "^" [receiver] identifier_def [formal_params] ;

formal_params       =   "(" [formal_parameter {";" formal_parameter}] ")" [":" qualified_identifier] ;

formal_parameter    =   ["var"] identifier {"," identifier} ":" type ;

receiver            =   "(" ["var"] identifier ":" identifier ")" ;

(* TODO - Arrays
 *
 * Need bounds and index types.
 * Ranges.
 *)
type                =   qualified_identifier
                    |   "array" [constant_expr {"," constant_expr}] "of" type
                    |   "record" ["("qualified_identifier")"]
                            field_list {";" field_list}
                        "end"
                    |   "pointer" "to" type
                    |   "function" [formal_params]
                    ;

field_list          =   [identifier_list ":" type] ;

statements          =   statement ";" {statement ";"} ;

statement           =   assignment_stmt
                    |   function_call
                    |   if_statement
                    |   case_statement
                    |   while_loop
                    |   repeat_loop
                    |   for_loop
                    |   general_loop
                    |   with_statement
                    |   "exit"
                    |   "return" [expression]
                    ;

assignment_stmt     =   designator ":=" expression ;

function_call       =   designator ["(" [expr_list] ")"] ;

if_statement        =   "if" expression "then"
                            statements
                        {"elsif" expression "then"
                            statements}
                        ["else"
                            statements]
                        "end" ;

case_statement      =   "case" expression "of"
                            case {"|" case}
                        ["else"
                            statements]
                        "end" ;

case                =   [case_labels {"," case_labels} ":"
                            statements] ;

case_labels         =   constant_expr [".." constant_expr] ;

while_loop          =   "while" expression "loop"
                            statements
                        "end" ;

(* TODO - Repeat loops can be implemented with an exit statement with an expression *)
repeat_loop         =   "loop"
                            statements
                        "until" expression ;

(* TODO - Add ranges *)
for_loop            =   "for" identifier ":=" expression "to" expression ["by" constant_expr] "loop"
                            statements
                        "end" ;

general_loop        =   "loop"
                            statements
                        "end" ;

with_statement      =   "with" guard "do"
                            statements {"|" guard "do"
                                statements}
                        ["else"
                            statements]
                        "end"
                    ;

guard               =   qualified_identifier ":" qualified_identifier ;

constant_expr       =   expression ;

expression          =   simple_expr [relation simple_expr] ;

simple_expr         =   ["+" | "-"] term {add_op term} ;

term                =   factor {mul_op factor} ;

factor              =   designator ["(" [expr_list] ")"]
                    |   number
                    |   character
                    |   string
                    |   "null"
                    |   set
                    |   "(" expression ")"
                    |   "not" factor
                    ;

set                 =   "{" [element {"," element}] "}" ;

element             =   expression [".." expression] ;

relation            =   "=" | "!=" | "<" | "<=" | ">" | ">=" | "in" | "is" ;

add_op              =   "+" | "-" | "or" ;

mul_op              =   "*" | "/" | "div" | "mod" | "and" ;

designator          =   qualified_identifier {"." identifier | "[" expr_list "]" | " ^ " | "(" qualified_identifier ")"} ;

expr_list           =   expression {"," expression} ;

identifier_list     =   identifier_def {"," identifier_def} ;

qualified_identifier    =   [identifier "."] identifier ;

identifier_def      =   identifier [" * " | " - "] ;