(*

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 ;