grammar.ebnf

(*
    This is a basic grammar declaration for Amber written in EBNF.
    This syntax does not include features that are not fully stable yet.
*)

root = { statement_global } ;

(* Statement *)
statement_local =
    builtins_statement |
    expression |
    if_chain |
    if_statement |
    loop |
    loop_array |
    variable_init_const |
    variable_init_mut |
    variable_set ;
statement_global =
    function_def |
    import_all |
    import_ids |
    main |
    statement_local ;

(* Block *)
singleline_block = ':', statement_local ;
multiline_block = '{', { statement_local }, '}' ;
block = singleline_block | multiline_block ;

(* Expression *)
expression =
    binary_operation |
    boolean |
    builtins_expression |
    command |
    function_call |
    identifier |
    list |
    null |
    number |
    parentheses |
    range |
    range_inclusive |
    ternary |
    text |
    unary_operation ;

(* Keywords *)
KEYWORD_AND = 'and' ;
KEYWORD_AS = 'as' ;
KEYWORD_BREAK = 'break' ;
KEYWORD_CD = 'cd' ;
KEYWORD_CONST = 'const' ;
KEYWORD_CONTINUE = 'continue' ;
KEYWORD_ECHO = 'echo' ;
KEYWORD_ELSE = 'else' ;
KEYWORD_EXIT = 'exit' ;
KEYWORD_FAIL = 'fail' ;
KEYWORD_FAILED = 'failed' ;
KEYWORD_FOR = 'for' ;
KEYWORD_FROM = 'from' ;
KEYWORD_FUN = 'fun' ;
KEYWORD_IF = 'if' ;
KEYWORD_IMPORT = 'import' ;
KEYWORD_IN = 'in' ;
KEYWORD_IS = 'is' ;
KEYWORD_LEN = 'len' ;
KEYWORD_LET = 'let' ;
KEYWORD_LINES = 'lines' ;
KEYWORD_LOOP = 'loop' ;
KEYWORD_MAIN = 'main' ;
KEYWORD_MV = 'mv' ;
KEYWORD_NAMEOF = 'nameof' ;
KEYWORD_NOT = 'not' ;
KEYWORD_OR = 'or' ;
KEYWORD_PUB = 'pub' ;
KEYWORD_REF = 'ref' ;
KEYWORD_RETURN = 'return' ;
KEYWORD_SILENT = 'silent' ;
KEYWORD_STATUS = 'status' ;
KEYWORD_THEN = 'then' ;
KEYWORD_TRUST = 'trust' ;
KEYWORD_UNSAFE = 'unsafe' ;

(* Terminals *)
ANY_CHAR = ? any character ? ;
LETTER = 'A'..'Z' | 'a'..'z' ;
DIGIT = '0'..'9' ;
TYPE = 'Text' | 'Num' | 'Bool' | 'Null';
UNARY_OP = '-' | KEYWORD_NOT ;
BINARY_OP = '+' | '-' | '*' | '/' | '%' | KEYWORD_AND | KEYWORD_OR | '==' | '!=' | '<' | '<=' | '>' | '>=' ;
SILENT_MOD = KEYWORD_SILENT ;
TRUST_MOD = KEYWORD_TRUST ;
VISIBILITY = KEYWORD_PUB ;

(* Identifier *)
any_identifier = (LETTER | '_'), { LETTER | '_' | DIGIT } ;
internal_identifier = '__', { LETTER | '_' | DIGIT } ;
identifier = any_identifier - internal_identifier ;

(* `Num` literal *)
integer = DIGIT, { DIGIT } ;
real = integer, '.', integer ;
number = integer | real ;

(* `Text` literal *)
interpolation = '{', expression, '}' ;
text = '"', { ANY_CHAR | interpolation }, '"' ;

(* `Bool` literal *)
boolean = 'true' | 'false' ;

(* `Null` literal *)
null = 'null' ;

(* `List` literal *)
empty_list = '[', TYPE, ']' ;
full_list = '[', [ expression, { ',', expression } ], ']' ;
list = empty_list | full_list ;

(* Command expression *)
(* The ordering of command modifiers doesn't matter *)
command_modifier = SILENT_MOD, [ TRUST_MOD ] ;
command_modifier_block = command_modifier, multiline_block ;
command_base = '$', { ANY_CHAR | interpolation }, '$' ;
command = [ SILENT_MOD ], command_base, [ failure_handler ] ;
command_trust = [ SILENT_MOD ], TRUST_MOD, command_base ;

(* Operations *)
binary_operation = expression, BINARY_OP, expression ;
unary_operation = UNARY_OP, expression ;

(* Parentheses *)
parentheses = '(', expression, ')' ;

(* Failure handler *)
failure_propagation = '?';
failure_block = KEYWORD_FAILED, block ;
failure_handler = failure_propagation | failure_block ;

(* Variable *)
variable_index = '[', expression, ']' ;
variable_init_mut = KEYWORD_LET, identifier, '=', expression ;
variable_init_const = KEYWORD_CONST, identifier, '=', expression ;
variable_get = identifier, variable_index? ;
variable_set = identifier, variable_index?, '=', expression ;

(* Function *)
function_call = identifier, '(', [ expression, { ',', expression } ], ')' ;
function_call_failed = [ SILENT_MOD ], function_call, failure_handler ;
function_call_trust = [ SILENT_MOD ], TRUST_MOD, function_call ;
function_def = [ VISIBILITY ], KEYWORD_FUN, identifier, '(', [ identifier, { ',', identifier } ], ')', block ;
function_def_typed = [ VISIBILITY ], KEYWORD_FUN, identifier, '(',
    [ identifier, ':', TYPE, { ',', identifier, ':', TYPE } ], ')', ':', TYPE, block ;

(* Loop *)
loop = KEYWORD_LOOP, block ;
loop_array = KEYWORD_FOR | KEYWORD_LOOP, identifier, KEYWORD_IN, expression, block ;
loop_array_iterator = KEYWORD_FOR | KEYWORD_LOOP, identifier, ',', identifier, KEYWORD_IN, expression, block ;

(* Ranges *)
range = expression, '..', expression ;
range_inclusive = expression, '..=', expression ;

(* Conditional *)
if_statement = KEYWORD_IF, expression, block, [ KEYWORD_ELSE, block ] ;
if_chain = KEYWORD_IF, '{', { expression, block }, [ KEYWORD_ELSE, block ],  '}' ;
ternary = expression, KEYWORD_THEN, expression, KEYWORD_ELSE, expression ;

(* Main *)
main = KEYWORD_MAIN, [ '(', identifier, ')' ], block ;

(* Imports *)
import_path = '"', { ANY_CHAR }, '"' ;
import_all = [ VISIBILITY ], KEYWORD_IMPORT, '*', KEYWORD_FROM, import_path ;
import_ids = [ VISIBILITY ], KEYWORD_IMPORT, '{', { identifier, [ KEYWORD_AS, identifier ], [ ',' ] }, '}', KEYWORD_FROM, import_path ;

(* Comment *)
comment = '//', { ANY_CHAR }, '\n' ;

(* Built-ins *)
builtins_statement =
    builtin_cd |
    builtin_echo |
    builtin_exit |
    builtin_mv ;
builtin_cd = KEYWORD_CD, expression ;
builtin_echo = KEYWORD_ECHO, expression ;
builtin_exit = KEYWORD_EXIT, expression ;
builtin_mv = KEYWORD_MV, expression ;

builtins_expression =
    builtin_len |
    builtin_lines |
    builtin_nameof ;
builtin_len = KEYWORD_LEN, expression ;
builtin_lines = KEYWORD_LINES, expression ;
builtin_nameof = KEYWORD_NAMEOF, expression ;