grammar

EBNF notation. Click any rule to navigate.

notation

| alternative
[ ] optional
{ } repetition

program structure

#

program

{ import } { declaration } EOF
#

import

"import" STRING "as" IDENTIFIER ";"
referenced by: program

declarations

#

declaration

classDecl | funDecl | varDecl | constDecl | statement
referenced by: program, block
#

varDecl

[ "export" ] "var" IDENTIFIER [ "=" expression ] ";"
referenced by: declaration, forStmt
#

constDecl

[ "export" ] "const" IDENTIFIER "=" expression ";"
referenced by: declaration, forStmt
#

funDecl

[ "export" ] "fun" function
referenced by: declaration
#

classDecl

[ "export" ] "class" IDENTIFIER [ "<" IDENTIFIER ] "{" { function } "}"
referenced by: declaration
#

function

IDENTIFIER "(" [ parameters ] ")" block
referenced by: funDecl, classDecl
#

parameters

IDENTIFIER { "," IDENTIFIER }
referenced by: function, functionExpr

statements

#

block

"{" { declaration } "}"
referenced by: function, functionExpr, statement
#

exprStmt

expression ";"
referenced by: statement, forStmt
#

printStmt

"print" expression ";"
referenced by: statement
#

returnStmt

"return" [ expression ] ";"
referenced by: statement
#

ifStmt

"if" "(" expression ")" statement [ "else" statement ]
referenced by: statement
#

whileStmt

"while" "(" expression ")" statement
referenced by: statement
#

forStmt

"for" "(" ( varDecl | constDecl | exprStmt | ";" ) [ expression ] ";" [ expression ] ")" statement
referenced by: statement
#

breakStmt

"break" ";"
referenced by: statement
#

continueStmt

"continue" ";"
referenced by: statement

expressions

#

assignment

( call "." IDENTIFIER | call "[" expression "]" | IDENTIFIER ) "=" assignment | logic_or
referenced by: expression
#

logic_or

logic_and { "or" logic_and }
referenced by: assignment
#

logic_and

equality { "and" equality }
referenced by: logic_or
#

equality

comparison { ( "!=" | "==" ) comparison }
referenced by: logic_and
#

comparison

term { ( ">" | ">=" | "<" | "<=" ) term }
referenced by: equality
#

term

factor { ( "-" | "+" ) factor }
referenced by: comparison
#

factor

unary { ( "/" | "*" ) unary }
referenced by: term
#

unary

( "!" | "-" ) unary | call
referenced by: factor
#

call

primary { "(" [ arguments ] ")" | "." IDENTIFIER | "[" expression "]" }
referenced by: unary, assignment
#

primary

"true" | "false" | "nil" | "this" | NUMBER | STRING | IDENTIFIER | "(" expression ")" | "super" "." IDENTIFIER | arrayLiteral | hashLiteral | functionExpr
referenced by: call
#

arguments

expression { "," expression }
referenced by: call

literals

#

arrayLiteral

"[" [ expression { "," expression } ] "]"
referenced by: primary
#

hashLiteral

"{" [ hashEntry { "," hashEntry } ] "}"
referenced by: primary
#

hashEntry

expression ":" expression
referenced by: hashLiteral
#

functionExpr

"fun" "(" [ parameters ] ")" block
referenced by: primary

IDENTIFIER, NUMBER, STRING, EOF are lexical tokens.