Permalink
Switch branches/tags
Nothing to show
Find file Copy path
Fetching contributors…
Cannot retrieve contributors at this time
537 lines (422 sloc) 10.1 KB
// Lexical
WhiteSpace:
Space+
Space:
' '
\t
\v
\u000C
EndOfLine
Comment
LinePragma
EndOfLine:
\r
\n
\r\n
EOF
EOF:
<physical end of file>
\0
Comment:
// Character* EndOfLine
NestedComment
NestedComment:
/* (Character | NestedComment)* */
LinePragma:
//#line (' ' | \t)+ Decimal ((' ' | \t)+ " Character* ")? EndOfLine
Token:
Identifier
Keyword
StringLiteral
IntLiteral
FloatLiteral
Symbol
EOF
Symbol:
+ | += | ++ | - | -= | -- | ~ | ~= | * | *= | / | /= | % | %=
< | <= | <=> | << | <<= | > | >= | >> | >>= | >>> | >>>=
& | &= | && | '|' | |= | || | ^ | ^= | = | == | ? | ?=
. | '..' | '...' | ! | != | '(' | ')' | [ | ] | { | } | : | ,
; | # | \ | -> | @
Identifier:
IdentifierStart IdentifierChar*
IdentifierStart:
_
a .. z
A .. Z
IdentifierChar:
IdentifierStart
DecimalDigit
!
Keyword:
and | as | assert | break | case | catch | class | continue | default | do | else
false | finally | for | foreach | function | global | if | import | in | is | local
module | namespace | not | null | or | override | return | scope | switch
this | throw | true | try | vararg | while | with | yield
StringLiteral:
RegularString
VerbatimString
RegularString:
" (Character | EscapeSequence | EndOfLine)* "
' (Character | EscapeSequence | EndOfLine)* '
EscapeSequence:
\'
\"
\\
\n
\r
\t
\x HexDigit HexDigit
\u HexDigit HexDigit HexDigit HexDigit
\U HexDigit HexDigit HexDigit HexDigit HexDigit HexDigit HexDigit HexDigit
\ DecimalDigit (DecimalDigit DecimalDigit?)?
VerbatimString:
@" (Character | EndOfLine)* "
@' (Character | EndOfLine)* '
[={n}[ (Character | EndOfLine)* ]={n}]
IntLiteral:
Decimal
Binary
Hexadecimal
Decimal:
DecimalDigit (DecimalDigit | _)*
DecimalDigit:
0 .. 9
Binary:
0 (b | B) (BinaryDigit | _)+
BinaryDigit:
0 .. 1
Hexadecimal:
0 (x | X) (HexDigit | _)+
HexDigit:
0 .. 9
a .. f
A .. F
FloatLiteral:
Integer Decimal? Exponent?
Integer:
DecimalDigit (DecimalDigit | _)*
Decimal:
. (DecimalDigit | _)+
Exponent:
(e | E) (+ | -)? (DecimalDigit | _)+
// -----------------------------------------------------------------------------------------------------------------
// -----------------------------------------------------------------------------------------------------------------
// -----------------------------------------------------------------------------------------------------------------
// Syntax
List(elem):
elem (, elem)*
DottedName:
Identifier (. Identifier)*
Module:
ModuleDeclaration Statement* EOF
ModuleDeclaration:
Decorators? module DottedName StatementTerminator
StatementTerminator:
;
// The following are not consumed
EndOfLine
}
')'
]
Statement:
AssertStatement
ImportStatement
BlockStatement
ExpressionStatement
DeclarationStatement
IfStatement
WhileStatement
DoWhileStatement
ForStatement
ForeachStatement
SwitchStatement
ContinueStatement
BreakStatement
ReturnStatement
TryCatchStatement
ThrowStatement
ScopeActionStatement
Assignment
AssertStatement:
assert '(' Expression (, Expression)? ')' StatementTerminator
ImportStatement:
import DottedName (as Identifier)? SelectiveImports? StatementTerminator
SelectiveImports:
: List(SelectiveImport)
SelectiveImport:
Identifier (as Identifier)?
BlockStatement:
{ Statement* }
ExpressionStatement:
Expression StatementTerminator
DeclarationStatement:
VariableDeclaration StatementTerminator
Decorators? OtherDeclaration
Decorators:
Decorator+
Decorator:
@ DottedName ArgumentsWith?
OtherDeclaration:
FunctionDeclaration
ClassDeclaration
NamespaceDeclaration
VariableDeclaration:
LocalVarDeclaration
GlobalVarDeclaration
LocalVarDeclaration:
local List(Identifier) (= ExpressionList)?
GlobalVarDeclaration:
global List(Identifier) (= ExpressionList)?
FunctionDeclaration:
(local | global)? SimpleFunctionDeclaration
SimpleFunctionDeclaration:
function Identifier FunctionBody
FunctionBody:
'(' Parameters? ')' ReturnTypes? (BlockStatement | = Expression)
Parameters:
(Parameter | ThisParam) (, Parameter)* (, VarargParam)?
VarargParam
VarargParam:
vararg
...
ThisParam:
this (as Identifier)? (: Type | Parameter)?
Parameter:
Identifier (: Type)? (= Expression)?
ReturnTypes:
: List(Type) (, ...)?
: ...
: void
Type:
BasicType
not null
any
@ DottedName
BasicType:
BasicType '|' BasicType
null
bool
int
float
string
table
array
memblock
function
class
instance DottedName?
DottedName
namespace
thread
nativeobj
weakref
funcdef
ClassDeclaration:
(local | global)? class Identifier (: List(Expression))? { ClassMember* }
ClassMember:
Decorators? override? SimpleFunctionDeclaration
Decorators? override? this FunctionBody
Decorators? override? Identifier (= Expression)? StatementTerminator
NamespaceDeclaration:
(local | global) namespace Identifier (: Expression)? { NamespaceMember* }
NamespaceMember:
Decorators? SimpleFunctionDeclaration
Decorators? Identifier (= Expression)? StatementTerminator
IfStatement:
if '(' (local Identifier =)? Expression ')' Statement (else Statement)?
WhileStatement:
while Identifier? '(' (local Identifier =)? Expression ')' Statement
DoWhileStatement:
do Statement while Identifier? '(' Expression ')'
ForStatement:
for Identifier? '(' ForInitializer? ; Expression? ; ForIncrement? ')' Statement
for Identifier? '(' Identifier ; Expression '..' List(Expression) ')' Statement
ForInitializer:
ForInitializer , ForInitializer
Expression
LocalVarDeclaration
Assignment
ForIncrement:
ForIncrement , ForIncrement
Expression
Assignment
ForeachStatement:
foreach Identifier? '(' List(Identifier) ; Expression (, Expression (, Expression)?)? ')' Statement
SwitchStatement:
switch Identifier? '(' Expression ')' { List(CaseStatement) DefaultStatement? }
CaseStatement:
case List(Expression) : Statement*
DefaultStatement:
default : Statement*
ContinueStatement:
continue Identifier? StatementTerminator
BreakStatement:
break Identifier? StatementTerminator
ReturnStatement:
return List(Expression)? StatementTerminator
TryCatchStatement:
try Statement CatchClauses
try Statement finally Statement
try Statement CatchClauses finally Statement
CatchClauses:
CatchallClause
CatchClause+ CatchallClause?
CatchClause:
catch '(' Identifier : DottedName ('|' DottedName)* ')' Statement
CatchallClause:
catch '(' Identifier ')' Statement
ThrowStatement:
throw Expression StatementTerminator
ScopeActionStatement:
scope '(' (exit | success | failure) ')' Statement
Assignment:
List(AssignmentLHS) = List(Expression)
AssignmentLHS += Expression
AssignmentLHS -= Expression
AssignmentLHS ~= Expression
AssignmentLHS *= Expression
AssignmentLHS /= Expression
AssignmentLHS %= Expression
AssignmentLHS <<= Expression
AssignmentLHS >>= Expression
AssignmentLHS >>>= Expression
AssignmentLHS |= Expression
AssignmentLHS ^= Expression
AssignmentLHS &= Expression
AssignmentLHS ?= Expression
++ PrimaryExpression
-- PrimaryExpression
PrimaryExpression ++
PrimaryExpression --
AssignmentLHS:
Identifier
// Note - for these, the PostfixExpression must start with Identifier, 'this', ':', or '#'.
PostfixExpression [ ]
PostfixExpression [ Expression? '..' Expression? ]
DotExpression
// In addition to the above, this PostfixExpression may start with 'vararg'
PostfixExpression [ Expression ]
Expression:
ConditionalExpression
ConditionalExpression:
LogicalConjExpression
LogicalConjExpression '?' Expression : ConditionalExpression
LogicalConjExpression:
OrExpression
OrOrExpression
AndAndExpression
OrOrExpression:
OrOrExpression || OrExpression
OrOrExpression or OrExpression
AndAndExpression:
AndAndExpression && OrExpression
AndAndExpression and OrExpression
OrExpression:
XorExpression
OrExpression '|' XorExpression
XorExpression:
AndExpression
XorExpression ^ AndExpression
AndExpression:
CompareExpression
AndExpression & CompareExpression
CompareExpression:
ShiftExpression
EqualExpression
RelExpression
EqualExpression:
ShiftExpression == ShiftExpression
ShiftExpression != ShiftExpression
ShiftExpression is ShiftExpression
ShiftExpression is not ShiftExpression
RelExpression:
ShiftExpression < ShiftExpression
ShiftExpression <= ShiftExpression
ShiftExpression > ShiftExpression
ShiftExpression >= ShiftExpression
ShiftExpression <=> ShiftExpression
ShiftExpression in ShiftExpression
ShiftExpression not in ShiftExpression
ShiftExpression:
AddExpression
ShiftExpression << AddExpression
ShiftExpression >> AddExpression
ShiftExpression >>> AddExpression
AddExpression:
AsExpression
AddExpression + AsExpression
AddExpression - AsExpression
AddExpression ~ AsExpression
AsExpression:
MulExpression
AsExpression as AsType
AsType:
bool
int
float
string
MulExpression:
UnaryExpression
MulExpression * UnaryExpression
MulExpression / UnaryExpression
MulExpression % UnaryExpression
UnaryExpression:
PostfixExpression
- UnaryExpression
! UnaryExpression
not UnaryExpression
~ UnaryExpression
# UnaryExpression
PostfixExpression:
PrimaryExpression
CallExpression
PostfixExpression [ ]
PostfixExpression [ Expression ]
PostfixExpression [ Expression? '..' Expression? ]
PostfixExpression . super
DotExpression
DotExpression:
PostfixExpression . (Identifier | '(' Expression ')')
CallExpression:
PostfixExpression ArgumentsWith
DotExpression ArgumentsWith
ArgumentsWith:
'(' Arguments? ')'
'(' with Expression (, List(Expression))? ')'
Arguments:
List(Expression)
PrimaryExpression:
Identifier
this
null
true
false
vararg
IntLiteral
FloatLiteral
StringLiteral
: (Identifier | super | '(' Expression ')')
function Identifier? FunctionBody
\ Parameters ((-> Expression) | BlockStatement)
'(' Expression ')'
TableCtorExp
ArrayLiteral
yield '(' Arguments? ')'
ArrayLiteral:
[ (Expression ,?)* ]
[ Expression ForComprehension ]
TableCtorExp:
{ (TableField ,?)* }
{ PlainTableField ForComprehension }
TableField:
Identifier = Expression
PlainTableField
SimpleFunctionDeclaration
PlainTableField:
[ Expression ] = Expression
ForComprehension:
foreach List(Identifier) ; Expression (, Expression (, Expression)?)? IfComprehension? ForComprehension?
for Identifier (: | ;) Expression '..' Expression (, Expression)? IfComprehension? ForComprehension?
IfComprehension:
if Expression