crocgrammar.txt

// 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