/*

Lua 5.1

Based on eBNF grammar for Lua[1]

[1] http://www.lua.org/manual/5.1/

Author:

Tetsuro Matsumura (https://github.com/tetsurom/)

*/

File = Chunk

Chunk = { __ $(Block) __ #Source }

SPACE = [\t\v\f ]

// Space including line terminator

__ = ( SPACE / LINE_TERMINATOR_SEQUENCE / COMMENT )*

// Space without line terminator

_ = ( SPACE / MULTI_LINE_COMMENT_SINGLE_LINE )*

LINE_TERMINATOR = [\n\r\u2028\u2029]

LINE_TERMINATOR_SEQUENCE = '\n'

/ '\r\n'

/ '\r'

COMMENT = MULTI_LINE_COMMENT

/ SINGLE_LINE_COMMENT

MULTI_LINE_COMMENT = '--' BRACKET_STRING_COMMENT

MULTI_LINE_COMMENT_SINGLE_LINE = '--' <on !MultiLineBracketString BRACKET_STRING_COMMENT>

SINGLE_LINE_COMMENT = '--' ( !LINE_TERMINATOR . )*

Identifier = !KEYWORD { [a-zA-Z_] W* #Name }

W = [a-zA-Z0-9_]

//Automatic Semicolon Insertion

EOS = __ ';'

/ _ SINGLE_LINE_COMMENT? LINE_TERMINATOR_SEQUENCE

/ _ &( "end" / "elseif" / "else" / "until" )

/ __ EOF

EOF = !.

HEX = [A-Fa-f0-9]

DIGIT = [0-9]

//Operator

//==========

"." = '.' !"."

".." = '..' !"."

"<" = '<' ![=]

">" = '>' ![=]

"=" = '=' ![=]

//KeyWords

//==========

"and" = 'and' !W

"break" = 'break' !W

"do" = 'do' !W

"else" = 'else' !W

"elseif" = 'elseif' !W

"end" = 'end' !W

"false" = 'false' !W

"for" = 'for' !W

"function" = 'function' !W

"if" = 'if' !W

"in" = 'in' !W

"local" = 'local' !W

"nil" = 'nil' !W

"not" = 'not' !W

"or" = 'or' !W

"repeat" = 'repeat' !W

"return" = 'return' !W

"then" = 'then' !W

"true" = 'true' !W

"until" = 'until' !W

"while" = 'while' !W

KEYWORD = "and"

/ "break"

/ "do"

/ "else"

/ "elseif"

/ "end"

/ "false"

/ "for"

/ "function"

/ "if"

/ "in"

/ "local"

/ "nil"

/ "not"

/ "or"

/ "repeat"

/ "return"

/ "then"

/ "true"

/ "until"

/ "while"

//Expression

//==========

/*

exp ::= prefixexp

exp ::= nil | false | true

exp ::= Number

exp ::= String

exp ::= function

exp ::= tableconstructor

exp ::= `...´

exp ::= exp binop exp

exp ::= unop exp

prefixexp ::= var | functioncall | `(´ exp `)´

Operator precedences

(LOW)

or

and

< > <= >= ~= ==

..

+ -

* / %

not # - (unary)

^

(HIGH)

*/

PrimaryExpression = Identifier

/ Literal

/ TableConstructor

/ '(' __ Expression __ ')'

TableConstructor = { "{" __ ( addFieldList __ )? "}" #Table }

addFieldList = $(Field) ( __ [,;] __ $(Field) )* ( __ [,;] )?

Field = { "[" __ $(Expression) __ "]" __ "=" __ $(Expression) #TableSetterApply }

/ { $(Identifier) __ "=" __ $(Expression) #TableProperty }

/ VariadicParameter

/ Expression

ReceiverExpression = PrimaryExpression

/ FunctionExpression

MemberExpression = ReceiverExpression {$ __ addMemberOperator }*

addMemberOperator = '[' __ $(Expression) __ ']' #Index

/ '.' __ $(Identifier) #Field

CallExpression = MemberExpression {$ addCallOrMemberOperator }*

CallStatement = MemberExpression {$ addCallOperator }+ EOS

addCallOperator = __ ":" __ $(Identifier) _ $(Arguments) #Method

/ _ $(Arguments) #Apply

/ _ $(TableArgument) #Apply

/ _ $(StringArgument) #Apply

addCallOrMemberOperator = addCallOperator

/ __ addMemberOperator

Arguments = '(' __ UnpackExpressionList __ ')'

TableArgument = { $(TableConstructor) #List }

StringArgument = { $(StringLiteral) #List }

LeftHandSideExpression = CallExpression

PowerExpression = { $left(LeftHandSideExpression) __ "^" #Power __ $right(PowerExpression) }

/ LeftHandSideExpression

UnaryExpression = PowerExpression

/ { addUnaryOperator _ $expr(UnaryExpression) }

addUnaryOperator = "+" #Plus

/ "-" #Minus

/ "#" #Count

/ "not" #LogicalNot

MultiplicativeExpression = UnaryExpression {$left __ ("*" #Mul / "/" #Div / "%" #Mod) __ $right(UnaryExpression) }*

AdditiveExpression = MultiplicativeExpression {$left __ ("+" #Add / "-" #Sub) __ $right(MultiplicativeExpression) }*

ConcatExpression = { $left(AdditiveExpression) __ ".." #Concat __ $right(ConcatExpression) }

/ AdditiveExpression

EqualityExpression = ConcatExpression {$left __ addEqualityOperator __ $right(ConcatExpression) }*

addEqualityOperator = "<=" #LessThanEquals

/ ">=" #GreaterThanEquals

/ "<" #LessThan

/ ">" #GreaterThan

/ "==" #Equals

/ "~=" #NotEquals

LogicalANDExpression = EqualityExpression {$left __ "and" __ $right(EqualityExpression) #LogicalAnd }*

LogicalORExpression = LogicalANDExpression {$left __ "or" __ $right(LogicalANDExpression) #LogicalOr }*

Expression = FunctionExpression

/ LogicalORExpression

ExpressionListItem = VariadicParameter

/ Expression

VariadicParameter = { "..." #VariadicParameter }

ExpressionList = { ( $(ExpressionListItem) ( __ ',' __ $(ExpressionListItem) )* )? #List }

UnpackExpressionList = { ( $(ExpressionListItem) ( __ ',' __ $(ExpressionListItem) )* )? #UnpackList }

IdentifierList = { ( $(Identifier) ( __ ',' __ $(Identifier) )* )? #List }

LeftHandSideExpressionList = { ( $(LeftHandSideExpression) ( __ ',' __ $(LeftHandSideExpression) )* )? #List }

//Statement

//==========

Statement = BlockStatement

/ VariableStatement

/ AssignmentStatement

/ IfStatement

/ RepeatStatement

/ WhileStatement

/ ForStatement

/ ForEachStatement

/ CallStatement

LastOnlyStatement = ReturnStatement

/ BreakStatement

BlockStatement = "do" __ Block __ "end" EOS?

VariableStatement = { "local" __ $(IdentifierList) ( __ "=" __ $(ExpressionList) )? EOS #MultiVarDecl }

AssignmentStatement = { $var(LeftHandSideExpressionList) __ "=" __ $expr(ExpressionList) EOS #MultiAssign }

IfStatement = { "if" __ $cond(Expression) __ "then" __ $then(Block) __ ( elseClause / elsifClause )? __ "end" EOS? #If }

elsifClause = $({ "elseif" __ $cond(Expression) __ "then" __ $then(Block) ( elseClause / elsifClause )? #If })

elseClause = "else" __ $else(Block)

RepeatStatement = { "repeat" __ $body(Statement) __ "until" __ $cond(Expression) EOS #DoWhile }

WhileStatement = { "while" __ $expr(Expression) __ $body(BlockStatement) #While }

ForStatement = { "for" __ $(Identifier) __ "=" __ $(Expression) __ "," __ $(Expression) __ ( "," __ $(Expression) __ )? $(BlockStatement) #ForInRange }

ForEachStatement = { "for" __ $(IdentifierList) __ "in" __ $(ExpressionList) __ $(BlockStatement) #Foreach }

BreakStatement = { "break" EOS #Break }

ReturnStatement = { "return" ( _ $expr(ExpressionList) )? EOS #Return }

//Program

//==========

FunctionExpression = { "function" __ addFuncBody "end" EOS? #FuncDecl }

FunctionDeclaration = { "function" __ addMethodName __ $(FunctionDeclarationBody) __ "end" EOS? #Method }

/ { "function" __ $left(FuncName) __ $right(FunctionDeclarationBody) __ "end" EOS? #Assign }

addLocalFunction = $(LocalFunctionVarDeclPart) $(LocalFunctionBody) __ "end" EOS?

LocalFunctionVarDeclPart = { "local" __ "function" __ $(LocalFunctionName) #VarDecl }

LocalFunctionName = { &$(Identifier) #List }

LocalFunctionBody = { $(Identifier) __ $(FunctionDeclarationBody) #Assign }

FuncName = Identifier {$ __ "." __ $(Identifier) #Field }*

addMethodName = $(FuncName) __ ":" __ $(Identifier)

FunctionDeclarationBody = { addFuncBody #FuncDecl }

addFuncBody = $param(ParameterList) __ $body(Block)

ParameterList = { '(' __ addParameterList? __ ')' #List }

addParameterList = $(VariadicParameter)

/ $(Identifier) ( __ ',' __ $(Identifier) )* ( __ ',' __ $(VariadicParameter) )?

Block = { ( __ addSourceElement )* ( __ $(LastOnlyStatement) )? #Block }

addSourceElement = $(FunctionDeclaration)

/ addLocalFunction

/ $(Statement)

//Literal

//==========

Literal = NilLiteral

/ BooleanLiteral

/ NumericLiteral

/ StringLiteral

NilLiteral = { "nil" #Null }

BooleanLiteral = { "true" #True }

/ { "false" #False }

NumericLiteral = HexIntegerLiteral

/ FloatingPointLiteral

/ DecimalIntergerLiteral

DecimalIntergerLiteral = { DECIMAL_INTEGER #Integer }

HexIntegerLiteral = { '0' [xX] HEX* #HexInteger }

FloatingPointLiteral = { DECIMAL_INTEGER? '.' DIGIT+ EXPONENT_PART? #Double }

/ { DECIMAL_INTEGER EXPONENT_PART #Double }

DECIMAL_INTEGER = [1-9] DIGIT*

/ "0"

EXPONENT_PART = [eE] SIGN? DECIMAL_INTEGER

SIGN = '+'

/ '-'

StringLiteral = ["] { ( !["] QUOTED_STRING_CHAR )* #String } ["]

/ ['] { ( !['] QUOTED_STRING_CHAR )* #String } [']

/ '[[' LINE_TERMINATOR_SEQUENCE? { BS_CHAR_NOBLOCK* #String } ']]'

/ <block ( '[' <def BracketStringEquals [=]+> '[' LINE_TERMINATOR_SEQUENCE? { BS_CHAR* #String } BS_TERMINATOR )>

BRACKET_STRING_COMMENT = '[[' LINE_TERMINATOR_SEQUENCE? BS_COMMENT_CHAR_NOBLOCK* ']]'

/ <block ( '[' <def BracketStringEquals [=]+> '[' LINE_TERMINATOR_SEQUENCE? BS_COMMENT_CHAR* BS_TERMINATOR )>

QUOTED_STRING_CHAR = !( '\\' / LINE_TERMINATOR ) .

/ '\\' ESCAPE_SEQUENCE

BS_CHAR_NOBLOCK = !']]' (LINE_TERMINATOR_SEQUENCE / .)

BS_CHAR = !BS_TERMINATOR (LINE_TERMINATOR_SEQUENCE / .)

BS_COMMENT_CHAR_NOBLOCK = !']]' (!LINE_TERMINATOR_SEQUENCE . / <if MultiLineBracketString> LINE_TERMINATOR_SEQUENCE)

BS_COMMENT_CHAR = !BS_TERMINATOR (!LINE_TERMINATOR_SEQUENCE . / <if MultiLineBracketString> LINE_TERMINATOR_SEQUENCE)

BS_TERMINATOR = ']' <isa BracketStringEquals> ']'

ESCAPE_SEQUENCE = '\\'

/ ["'abfnrtv]

/ CODE_ESCAPE_SEQUENCE

/ LINE_TERMINATOR_SEQUENCE

CODE_ESCAPE_SEQUENCE = DIGIT DIGIT DIGIT

/ DIGIT DIGIT

/ DIGIT

example TableConstructor '''

{ [f(1)] = g; "x", "y"; x = 1, f(x), [30] = 23; 45 }

'''

example TableConstructor '''

{[1+2]=2, a = 3, ...}

'''

example A '''

a.b.c.d

'''

example A '''

a.b[0]

'''

example A '''

a.b[0][0]

'''

example VariableStatement&Statement ~15c0620 '''

local a,b,c = 1,2,3;

'''

example AssignmentStatement&Statement '''

A x, y = y, x;

'''

example AssignmentStatement&Statement '''

A a.b = 1;

'''

example IfStatement&Statement ~cb23ebe '''

if n < 10 then return n end

'''

example IfStatement&Statement '''

if n < 10 then return n else return 0 end

'''

example IfStatement&Statement '''

if n < 10 then return n elseif n == 0 then return 0 else return -1 end

'''

example ForStatement&Statement '''

for var = e1, e2, e3 do break end

'''

example ForEachStatement&Statement '''

for k,v in list do end

'''

example FunctionExpression '''

function (a, b) end

'''

example FunctionExpression '''

function (a, b, ...) end

'''

example FunctionExpression '''

function () return 1,2,3 end

'''

example FunctionDeclaration '''

function f(a, b) end

'''

example FunctionDeclaration '''

function g:m(a, b, ...) end

'''

example FunctionDeclaration '''

function r() return 1,2,3 end

'''

example BooleanLiteral&Literal ~1e4f2d3 '''

true

'''

example DecimalIntergerLiteral&Expression ~6db38 '''

123

'''

example HexIntegerLiteral&Expression ~e2d592 '''

0xa12

'''

example FloatingPointLiteral&Expression ~34726e '''

12.456

'''

example FloatingPointLiteral&Expression ~182b0b '''

12.456e-78

'''

example FloatingPointLiteral&Expression '''

0.12

'''

example FloatingPointLiteral&Expression ~0f800a4 '''

.12

'''

example FloatingPointLiteral&Expression ~1143ad '''

.12e3

'''

example FloatingPointLiteral&Expression ~85018a '''

5e3

'''

example StringLiteral ~ca45b4 '''

'\97lo\10\04923"'

'''

example StringLiteral ~1055b4 '''

[[foobar123]]

'''

example StringLiteral ~12f1ea '''

[==[foo[bar]123]==]

'''

// formatted by $ nez format