Skip to content

Instantly share code, notes, and snippets.

@FatalCatharsis

FatalCatharsis/DlangBNF Secret

Created February 17, 2017 03:13
Show Gist options
  • Star 0 You must be signed in to star a gist
  • Fork 0 You must be signed in to fork a gist
  • Save FatalCatharsis/fb3e9c7c3c3f2534fdab64e3baa47db6 to your computer and use it in GitHub Desktop.
Save FatalCatharsis/fb3e9c7c3c3f2534fdab64e3baa47db6 to your computer and use it in GitHub Desktop.
Download ZIP
Raw
DlangBNF
{
parserClass="com.dlangplugin.parser.DlangParser"
extends="com.intellij.extapi.psi.ASTWrapperPsiElement"
psiClassPrefix="Dlang"
psiImplClassSuffix="Impl"
psiPackage="com.dlangplugin.psi"
psiImplPackage="com.dlangplugin.psi.impl"
elementTypeHolderClass="com.dlangplugin.psi.DlangTypes"
elementTypeClass="com.dlangplugin.psi.DlangElementType"
tokenTypeClass="com.dlangplugin.psi.DlangTokenType"
psiImplUtilClass="com.dlangplugin.psi.impl.DlangPsiImplUtil"
}
Module ::=
(ModuleDeclaration DeclDefs) |
(DeclDefs)
Type ::= TypeCtors? BasicType BasicType2?
TypeCtors ::= TypeCtor*
TypeCtor ::=
CONST |
IMMUTABLE |
INOUT |
SHARED
BasicType ::=
BasicTypeX |
(DOT_OP IdentifierList) |
IdentifierList |
(Typeof DOT_OP IdentifierList) |
Typeof |
(TypeCtor EXPR_START Type EXPR_END) |
TypeVector
BasicTypeX ::=
BOOL |
BYTE |
UBYTE |
SHORT |
USHORT |
INT |
UINT |
LONG |
ULONG |
CHAR |
WCHAR |
DCHAR |
FLOAT |
DOUBLE |
REAL |
IFLOAT |
IDOUBLE |
IREAL |
CFLOAT |
CDOUBLE |
CREAL |
CVOID
BasicType2 ::= (BasicType2X BasicType2?)
BasicType2X ::=
MUL_OP |
BasicType2XArray |
(DELEGATE Parameters MemberFunctionAttributes?) |
(FUNCTION Parameters FunctionAttributes?)
BasicType2XArray ::=
(LEFT_BRACKET AssignExpression (DOTDOT_OP AssignExpression)? RIGHT_BRACKET) |
(LEFT_BRACKET Type? RIGHT_BRACKET)
IdentifierList ::=
(IDENTIFIER LEFT_BRACKET AssignExpression RIGHT_BRACKET DOT_OP IdentifierList) |
(IDENTIFIER (DOT_OP IdentifierList)?) |
(TemplateInstance (DOT_OP IdentifierList)?)
Typeof ::= (TYPEOF_KEYWORD EXPR_START (Expression | RETURN) EXPR_END)
TypeVector ::= (VECTOR EXPR_START Type EXPR_END)
// --------------------------
// BEGIN EXPRESSIONS
// --------------------------
Expression ::= CommaExpression
CommaExpression ::= (AssignExpression (PARAM_SEP CommaExpression)?) {extends=Expression}
AssignExpression ::=
(ConditionalExpression ASSIGN_OP AssignExpression) |
(ConditionalExpression PLUS_ASSIGN_OP AssignExpression) |
(ConditionalExpression MINUS_ASSIGN_OP AssignExpression) |
(ConditionalExpression MUL_ASSIGN_OP AssignExpression) |
(ConditionalExpression DIV_ASSIGN_OP AssignExpression) |
(ConditionalExpression MOD_ASSIGN_OP AssignExpression) |
(ConditionalExpression BIT_AND_ASSIGN_OP AssignExpression) |
(ConditionalExpression BIT_OR_ASSIGN_OP AssignExpression) |
(ConditionalExpression BIT_XOR_ASSIGN_OP AssignExpression) |
(ConditionalExpression CONCAT_ASSIGN_OP AssignExpression) |
(ConditionalExpression SHIFT_LEFT_ASSIGN_OP AssignExpression) |
(ConditionalExpression SHIFT_RIGHT_ASSIGN_OP AssignExpression) |
(ConditionalExpression UNSIGNED_SHIFT_RIGHT_ASSIGN_OP AssignExpression) |
(ConditionalExpression POW_ASSIGN_OP AssignExpression) |
ConditionalExpression
{extends=Expression}
ConditionalExpression ::=
(OrOrExpression QUESTION_OP Expression COLON_OP ConditionalExpression) |
OrOrExpression
{extends=Expression}
OrOrExpression ::= (AndAndExpression OrOrExpressionPrime) {extends=Expression}
OrOrExpressionPrime ::= (OR_OP AndAndExpression OrOrExpressionPrime)?
AndAndExpression ::=
(OrExpression AndAndExpressionPrime) |
(CmpExpression AndAndExpressionPrime) {extends=Expression}
AndAndExpressionPrime ::=
((AND_OP OrExpression AndAndExpressionPrime) |
(AND_OP CmpExpression AndAndExpressionPrime))?
OrExpression ::= (XorExpression OrExpressionPrime) {extends=Expression}
OrExpressionPrime ::= (BIT_OR_OP XorExpression OrExpressionPrime)?
XorExpression ::= (AndExpression XorExpressionPrime) {extends=Expression}
XorExpressionPrime ::= (BIT_XOR_OP AndExpression XorExpressionPrime)?
AndExpression ::= (ShiftExpression AndExpressionPrime) {extends=Expression}
AndExpressionPrime ::= (BIT_OR_OP ShiftExpression AndExpressionPrime)?
CmpExpression ::=
ShiftExpression |
EqualExpression |
IdentityExpression |
RelExpression |
InExpression
{extends=Expression}
EqualExpression ::=
(ShiftExpression EQUALS_OP ShiftExpression) |
(ShiftExpression NOT_EQUALS_OP ShiftExpression)
{extends=Expression}
IdentityExpression ::=
(ShiftExpression IS ShiftExpression) |
(ShiftExpression NOT_IS ShiftExpression)
{extends=Expression}
RelExpression ::=
(ShiftExpression LESS_THAN_OP ShiftExpression) |
(ShiftExpression LESS_THAN_EQUALS_OP ShiftExpression) |
(ShiftExpression GREATER_THAN_OP ShiftExpression) |
(ShiftExpression GREATER_THAN_EQUALS_OP ShiftExpression) |
(ShiftExpression UNORDERED_OP ShiftExpression) |
(ShiftExpression UNORDERED_OR_EQUAL_OP ShiftExpression) |
(ShiftExpression LESS_OR_GREATER_OP ShiftExpression) |
(ShiftExpression LESS_EQUAL_OR_GREATER_OP ShiftExpression) |
(ShiftExpression UNORDERED_LESS_OR_EQUAL_OP ShiftExpression) |
(ShiftExpression UNORDERED_OR_LESS_OP ShiftExpression) |
(ShiftExpression UNORDERED_GREATER_OR_EQUAL_OP ShiftExpression) |
(ShiftExpression UNORDERED_OR_GREATER_OP ShiftExpression)
{extends=Expression}
InExpression ::=
(ShiftExpression IN ShiftExpression) |
(ShiftExpression NOT_IN ShiftExpression)
{extends=Expression}
ShiftExpression ::= (AddExpression ShiftExpressionPrime)
{extends=Expression}
ShiftExpressionPrime ::=
((SHIFT_LEFT_OP AddExpression ShiftExpressionPrime) |
(SHIFT_RIGHT_OP AddExpression ShiftExpressionPrime) |
(UNSIGNED_SHIFT_RIGHT_OP AddExpression ShiftExpressionPrime))?
AddExpression ::=
MulExpression |
CatExpression
{extends=Expression}
AddExpressionPrime ::=
((PLUS_OP MulExpression AddExpressionPrime) |
(MINUS_OP MulExpression AddExpressionPrime))?
{extends=Expression}
CatExpression ::= (CONCAT_OP MulExpression AddExpressionPrime) {extends=Expression}
MulExpression ::= (UnaryExpression MulExpressionPrime AddExpressionPrime) {extends=Expression}
MulExpressionPrime ::=
((MUL_OP UnaryExpression MulExpressionPrime) |
(DIV_OP UnaryExpression MulExpressionPrime) |
(MOD_OP UnaryExpression MulExpressionPrime))?
UnaryExpression ::=
(BIT_AND_OP UnaryExpression) |
(INCREMENT_OP UnaryExpression) |
(DECREMENT_OP UnaryExpression) |
(MUL_OP UnaryExpression) |
(MINUS_OP UnaryExpression) |
(PLUS_OP UnaryExpression) |
(NOT_OP UnaryExpression) |
ComplementExpression |
(EXPR_START Type EXPR_END DOT_OP IDENTIFIER) |
(EXPR_START Type EXPR_END DOT_OP TemplateInstance) |
DeleteExpression |
CastExpression |
PowExpression
{extends=Expression}
ComplementExpression ::= (CONCAT_OP UnaryExpression) {extends=Expression}
NewExpression ::=
(NEW AllocatorArguments? Type) |
NewExpressionWithArgs
{extends=Expression}
NewExpressionWithArgs ::=
(NEW AllocatorArguments? Type LEFT_BRACKET AssignExpression RIGHT_BRACKET) |
(NEW AllocatorArguments? Type EXPR_START ArgumentList? EXPR_END) |
NewAnonClassExpression
{extends=Expression}
AllocatorArguments ::= (EXPR_START ArgumentList? EXPR_END) {extends=Expression}
ArgumentList ::=
(AssignExpression PARAM_SEP ArgumentList) |
(AssignExpression PARAM_SEP) |
AssignExpression
{extends=Expression}
NewAnonClassExpression ::= (NEW AllocatorArguments? CLASS ClassArguments? SuperClass? Interfaces? AggregateBody) {extends=Expression}
ClassArguments ::= (EXPR_START ArgumentList? EXPR_END)
DeleteExpression ::= (DELETE UnaryExpression) {extends=Expression}
CastExpression ::=
(CAST EXPR_START Type EXPR_END UnaryExpression) |
(CAST EXPR_START TypeCtors? EXPR_END UnaryExpression) {extends=Expression}
PowExpression ::=
(PostfixExpression POW_OP UnaryExpression) |
PostfixExpression
{extends=Expression}
PostfixExpression ::=
(PrimaryExpression PostfixExpressionPrime) |
(TypeCtors? BasicType EXPR_START ArgumentList? EXPR_END PostfixExpressionPrime)
{extends=Expression}
PostfixExpressionPrime ::=
((DOT_OP IDENTIFIER PostfixExpressionPrime) |
(DOT_OP TemplateInstance PostfixExpressionPrime) |
(DOT_OP NewExpression PostfixExpressionPrime) |
(INCREMENT_OP PostfixExpressionPrime) |
(DECREMENT_OP PostfixExpressionPrime) |
(EXPR_START ArgumentList? EXPR_END PostfixExpressionPrime) |
IndexExpression |
SliceExpression)?
IndexExpression ::= (LEFT_BRACKET ArgumentList RIGHT_BRACKET PostfixExpressionPrime) {extends=Expression}
SliceExpression ::=
(LEFT_BRACKET RIGHT_BRACKET PostfixExpressionPrime) |
(LEFT_BRACKET Slice PARAM_SEP? RIGHT_BRACKET PostfixExpressionPrime)
{extends=Expression}
Slice ::=
AssignExpression |
(AssignExpression PARAM_SEP Slice) |
(AssignExpression DOTDOT_OP AssignExpression PARAM_SEP Slice) |
(AssignExpression DOTDOT_OP AssignExpression)
{extends=Expression}
PrimaryExpression ::=
IDENTIFIER |
(DOT_OP IDENTIFIER) |
TemplateInstance |
(DOT_OP TemplateInstance) |
THIS |
SUPER |
NULL |
TRUE |
FALSE |
DOLLAR_OP |
INTEGER_LITERAL |
FLOAT_LITERAL |
CHARACTER_LITERAL |
StringLiterals |
ArrayLiteral |
AssocArrayLiteral |
FunctionLiteral |
AssertExpression |
MixinExpression |
ImportExpression |
NewExpressionWithArgs |
(BasicTypeX DOT_OP IDENTIFIER) |
Typeof |
TypeidExpression |
IsExpression |
(EXPR_START Expression EXPR_END) |
TraitsExpression |
SpecialKeyword
{extends=Expression}
StringLiterals ::=
(STRING_LITERAL StringLiteralsPrime) |
(TokenString StringLiteralsPrime)
StringLiteralsPrime ::=
((STRING_LITERAL StringLiteralsPrime) |
(TokenString StringLiteralsPrime))?
Token ::=
IDENTIFIER |
STRING_LITERAL |
TokenString |
CHARACTER_LITERAL |
INTEGER_LITERAL |
FLOAT_LITERAL |
Keyword |
DIV_OP | DIV_ASSIGN_OP | DOT_OP | DOTDOT_OP |
ELLIPSIS_OP | BIT_AND_OP | BIT_AND_ASSIGN_OP | AND_OP | BIT_OR_OP | BIT_OR_ASSIGN_OP |
OR_OP | MINUS_OP | MINUS_ASSIGN_OP | DECREMENT_OP |
PLUS_OP | PLUS_ASSIGN_OP | INCREMENT_OP | LESS_THAN_OP |
LESS_THAN_EQUALS_OP | SHIFT_LEFT_OP | SHIFT_LEFT_ASSIGN_OP | LESS_OR_GREATER_OP |
LESS_EQUAL_OR_GREATER_OP | GREATER_THAN_OP | GREATER_THAN_EQUALS_OP | SHIFT_RIGHT_ASSIGN_OP |
UNSIGNED_SHIFT_RIGHT_ASSIGN_OP | SHIFT_RIGHT_OP | UNSIGNED_SHIFT_RIGHT_OP | NOT_OP|
NOT_EQUALS_OP | UNORDERED_OR_EQUAL_OP | UNORDERED_OP | UNORDERED_GREATER_OR_EQUAL_OP |
UNORDERED_OR_GREATER_OP | UNORDERED_LESS_OR_EQUAL_OP | UNORDERED_OR_LESS_OP | EXPR_START |
EXPR_END | LEFT_BRACKET | RIGHT_BRACKET | CURLY_BRACE_LEFT |
QUESTION_OP | PARAM_SEP | SEMICOLON_OP |
COLON_OP | DOLLAR_OP | ASSIGN_OP | EQUALS_OP |
MUL_OP | MUL_ASSIGN_OP | MOD_OP | MOD_ASSIGN_OP |
BIT_XOR_OP | BIT_XOR_ASSIGN_OP | POW_OP | POW_ASSIGN_OP |
CONCAT_OP | CONCAT_ASSIGN_OP | AT_OP | ARROW_OP | "#"
Keyword ::=
ABSTRACT |
ALIAS |
ALIGN |
ASM |
ASSERT |
AUTO |
BODY |
BOOL |
BREAK |
BYTE |
CASE |
CAST |
CATCH_KEYWORD |
CDOUBLE |
CENT |
CFLOAT |
CHAR |
CLASS |
CONST |
CONTINUE |
CREAL |
DCHAR |
DEBUG |
DEFAULT |
DELEGATE |
DELETE |
DEPRECATED |
DO |
DOUBLE |
ELSE |
ENUM |
EXPORT |
EXTERN |
FALSE |
FINAL |
FINALLY |
FLOAT |
FOR |
FOREACH_KEYWORD |
FOREACH_REVERSE |
FUNCTION |
GOTO |
IDOUBLE |
IF |
IFLOAT |
IMMUTABLE |
IMPORT_KEYWORD |
IN |
INOUT |
INT |
INTERFACE_KEYWORD |
INVARIANT_KEYWORD |
IREAL |
IS |
LAZY |
LONG |
MACRO |
MIXIN |
MODULE |
NEW |
NOTHROW |
NULL |
OUT |
OVERRIDE |
PACKAGE |
PRAGMA_KEYWORD |
PRIVATE |
PROTECTED |
PUBLIC |
PURE |
REAL |
REF |
RETURN |
SCOPE |
SHARED |
SHORT |
STATIC |
STRUCT |
SUPER |
SWITCH |
SYNCHRONIZED |
TEMPLATE |
THIS |
THROW |
TRUE |
TRY |
TYPEDEF |
TYPEID |
TYPEOF_KEYWORD |
UBYTE |
UCENT |
UINT |
ULONG |
UNION |
UNITTEST |
USHORT |
VERSION |
VOID |
VOLATILE |
WCHAR |
WHILE |
WITH |
SPEC_FILE |
SPEC_FILE_FULL_PATH |
SPEC_MODULE |
SPEC_LINE |
SPEC_FUNCTION |
SPEC_PRETTY_FUNCTION |
GSHARED |
UNDERSCORE_TRAITS |
VECTOR |
UNDERSCORE_PARAMS
TokenString ::= (TOKEN_STRING_OP Token CURLY_BRACE_RIGHT)
ArrayLiteral ::= (LEFT_BRACKET ArgumentList RIGHT_BRACKET)
AssocArrayLiteral ::= (LEFT_BRACKET KeyValuePairs RIGHT_BRACKET)
KeyValuePairs ::=
(KeyValuePair PARAM_SEP KeyValuePairs) |
KeyValuePair
KeyValuePair ::= (KeyExpression COLON_OP ValueExpression)
KeyExpression ::= AssignExpression
ValueExpression ::= AssignExpression
FunctionLiteral ::=
(FUNCTION Type? ParameterAttributes WHITESPACE? FunctionLiteralBody) |
(DELEGATE Type? ParameterMemberAttributes WHITESPACE? FunctionLiteralBody) |
(ParameterMemberAttributes FunctionLiteralBody) |
Lambda
ParameterAttributes ::= Parameters FunctionAttributes?
ParameterMemberAttributes ::= Parameters MemberFunctionAttributes?
FunctionLiteralBody ::=
BlockStatement |
(FunctionContracts? BodyStatement)
Lambda ::=
(FUNCTION Type? ParameterAttributes ARROW_OP AssignExpression) |
(DELEGATE Type? ParameterMemberAttributes ARROW_OP AssignExpression) |
(ParameterMemberAttributes ARROW_OP AssignExpression) |
(IDENTIFIER ARROW_OP AssignExpression)
AssertExpression ::=
(ASSERT EXPR_START AssignExpression PARAM_SEP AssignExpression PARAM_SEP?) |
(ASSERT EXPR_START AssignExpression PARAM_SEP?)
MixinExpression ::= (MIXIN EXPR_START AssignExpression EXPR_END)
ImportExpression ::= (IMPORT_KEYWORD EXPR_START AssignExpression EXPR_END)
TypeidExpression ::=
(TYPEID EXPR_START Type EXPR_END) |
(TYPEID EXPR_START Expression EXPR_END)
IsExpression ::=
(IS EXPR_START Type EXPR_END) |
(IS EXPR_START Type IDENTIFIER EXPR_END) |
(IS EXPR_START Type COLON_OP TypeSpecialization EXPR_END) |
(IS EXPR_START Type EQUALS_OP TypeSpecialization EXPR_END) |
(IS EXPR_START Type COLON_OP TypeSpecialization PARAM_SEP TemplateParameterList EXPR_END) |
(IS EXPR_START Type EQUALS_OP TypeSpecialization PARAM_SEP TemplateParameterList EXPR_END) |
(IS EXPR_START Type IDENTIFIER COLON_OP TypeSpecialization EXPR_END) |
(IS EXPR_START Type IDENTIFIER EQUALS_OP TypeSpecialization EXPR_END) |
(IS EXPR_START Type IDENTIFIER COLON_OP TypeSpecialization PARAM_SEP TemplateParameterList EXPR_END) |
(IS EXPR_START Type IDENTIFIER EQUALS_OP TypeSpecialization PARAM_SEP TemplateParameterList EXPR_END)
TypeSpecialization ::=
Type |
STRUCT |
UNION |
CLASS |
INTERFACE_KEYWORD |
ENUM |
FUNCTION |
DELEGATE |
SUPER |
CONST |
IMMUTABLE |
INOUT |
SHARED |
RETURN |
UNDERSCORE_PARAMS
TraitsExpression ::= (UNDERSCORE_TRAITS EXPR_START TraitsKeyword PARAM_SEP TraitsArguments EXPR_END)
TraitsKeyword ::=
"isAbstractClass" |
"isArithmetic" |
"isAssociativeArray" |
"isFinalClass" |
"isPod" |
"isNested" |
"isFloating" |
"isIntegral" |
"isScalar" |
"isStaticArray" |
"isUnsigned" |
"isVirtualFunction" |
"isVirtualMethod" |
"isAbstractFunction" |
"isFinalFunction" |
"isStaticFunction" |
"isOverrideFunction" |
"isRef" |
"isOut" |
"isLazy" |
"hasMember" |
"identifier" |
"getAliasThis" |
"getAttributes" |
"getFunctionAttributes" |
"getMember" |
"getOverloads" |
"getPointerBitmap" |
"getProtection" |
"getVirtualMethods" |
"getUnitTests" |
"parent" |
"classInstanceSize" |
"getVitrualIndex" |
"allMembers" |
"derivedMembers" |
"isSame" |
"compiles"
TraitsArguments ::=
(TraitsArgument PARAM_SEP TraitsArguments) |
TraitsArgument
TraitsArgument ::=
AssignExpression |
Type
SpecialKeyword ::=
SPEC_FILE |
SPEC_FILE_FULL_PATH |
SPEC_MODULE |
SPEC_LINE |
SPEC_FUNCTION |
SPEC_PRETTY_FUNCTION
//---------------------------------------------
// BEGIN STATEMENTS
//---------------------------------------------
private Statement ::=
SEMICOLON_OP |
NonEmptyStatement |
ScopeBlockStatement
private StatementRecover ::=
!(SEMICOLON_OP)
private NoScopeNonEmptyStatement ::=
NonEmptyStatement |
BlockStatement
private NoScopeStatement ::=
SEMICOLON_OP |
NonEmptyStatement |
BlockStatement
private NonEmptyOrScopeBlockStatement ::=
NonEmptyStatement |
ScopeBlockStatement
private NonEmptyStatement ::=
NonEmptyStatementNoCaseNoDefault |
CaseStatement |
CaseRangeStatement |
DefaultStatement
private NonEmptyStatementNoCaseNoDefault ::=
LabeledStatement |
ExpressionStatement |
DeclarationStatement |
IfStatement |
WhileStatement |
DoStatement |
ForStatement |
ForeachStatement |
SwitchStatement |
FinalSwitchStatement |
ContinueStatement |
BreakStatement |
ReturnStatement |
GotoStatement |
WithStatement |
SynchronizedStatement |
TryStatement |
ScopeGuardStatement |
ThrowStatement |
AsmStatement |
PragmaStatement |
MixinStatement |
ForeachRangeStatement |
ConditionalStatement |
StaticAssert |
TemplateMixin |
ImportDeclaration
private ScopeStatement ::=
NonEmptyStatement |
BlockStatement
private ScopeBlockStatement ::= BlockStatement
LabeledStatement ::=
(IDENTIFIER COLON_OP NoScopeStatement) |
(IDENTIFIER COLON_OP Statement) |
(IDENTIFIER COLON_OP)
private BlockStatement ::=
(CURLY_BRACE_LEFT CURLY_BRACE_RIGHT) |
(CURLY_BRACE_LEFT StatementList CURLY_BRACE_RIGHT)
private StatementList ::= Statement+
ExpressionStatement ::= (Expression SEMICOLON_OP)
private DeclarationStatement ::= (StorageClasses? Declaration)
IfStatement ::=
(IF EXPR_START IfCondition EXPR_END ThenStatement ELSE ElseStatement) |
(IF EXPR_START IfCondition EXPR_END ThenStatement)
IfCondition ::=
Expression |
(AUTO IDENTIFIER ASSIGN_OP Expression) |
(TypeCtors IDENTIFIER ASSIGN_OP Expression) |
(TypeCtors? BasicType Declarator ASSIGN_OP Expression)
ThenStatement ::= ScopeStatement
ElseStatement ::= ScopeStatement
WhileStatement ::= (WHILE EXPR_START Expression EXPR_END ScopeStatement)
DoStatement ::= (DO ScopeStatement WHILE EXPR_START Expression EXPR_END SEMICOLON_OP)
ForStatement ::= (FOR EXPR_START Initialize Test? SEMICOLON_OP Increment? EXPR_END ScopeStatement)
Initialize ::=
SEMICOLON_OP |
NoScopeNonEmptyStatement
Test ::= Expression
Increment ::= Expression
ForeachStatement ::= (Foreach EXPR_START ForeachTypeList SEMICOLON_OP ForeachAggregate EXPR_END NoScopeNonEmptyStatement)
Foreach ::=
FOREACH_KEYWORD |
FOREACH_REVERSE
ForeachTypeList ::=
(ForeachType PARAM_SEP ForeachTypeList) |
ForeachType
ForeachType ::=
(ForeachTypeAttributes? BasicType Declarator) |
(ForeachTypeAttributes? IDENTIFIER)
ForeachTypeAttributes ::=
ForeachTypeAttribute ForeachTypeAttributes? |
ForeachTypeAttribute
ForeachTypeAttribute ::=
REF |
TypeCtor
ForeachAggregate ::= Expression
ForeachRangeStatement ::= (Foreach EXPR_START ForeachType SEMICOLON_OP LwrExpression DOTDOT_OP UprExpression EXPR_END ScopeStatement)
LwrExpression ::= Expression
UprExpression ::= Expression
SwitchStatement ::= (SWITCH EXPR_START Expression EXPR_END ScopeStatement)
CaseStatement ::= (CASE ArgumentList COLON_OP ScopeStatementList)
CaseRangeStatement ::= (CASE FirstExp COLON_OP DOTDOT_OP CASE LastExp COLON_OP ScopeStatementList)
FirstExp ::= AssignExpression
LastExp ::= AssignExpression
DefaultStatement ::= (DEFAULT COLON_OP ScopeStatementList)
ScopeStatementList ::= StatementListNoCaseNoDefault
StatementListNoCaseNoDefault ::=
(StatementNoCaseNoDefault StatementListNoCaseNoDefault) |
StatementNoCaseNoDefault
StatementNoCaseNoDefault ::=
SEMICOLON_OP |
NonEmptyStatementNoCaseNoDefault |
ScopeBlockStatement
FinalSwitchStatement ::= (FINAL SWITCH EXPR_START Expression EXPR_END ScopeStatement)
ContinueStatement ::= (CONTINUE IDENTIFIER? SEMICOLON_OP)
BreakStatement ::= (BREAK IDENTIFIER? SEMICOLON_OP)
ReturnStatement ::= (RETURN Expression? SEMICOLON_OP)
GotoStatement ::=
(GOTO IDENTIFIER SEMICOLON_OP) |
(GOTO DEFAULT SEMICOLON_OP) |
(GOTO CASE SEMICOLON_OP) |
(GOTO CASE Expression SEMICOLON_OP)
WithStatement ::=
(WITH EXPR_START Expression EXPR_END ScopeStatement) |
(WITH EXPR_START Symbol EXPR_END ScopeStatement) |
(WITH EXPR_START TemplateInstance EXPR_END ScopeStatement)
SynchronizedStatement ::=
(SYNCHRONIZED ScopeStatement) |
(SYNCHRONIZED EXPR_START Expression EXPR_END ScopeStatement)
TryStatement ::=
(TRY ScopeStatement Catches FinallyStatement) |
(TRY ScopeStatement Catches) |
(TRY ScopeStatement FinallyStatement)
Catches ::=
(Catch Catches) |
Catch
Catch ::= (CATCH_KEYWORD EXPR_START CatchParameter EXPR_END NoScopeNonEmptyStatement)
CatchParameter ::= (BasicType IDENTIFIER)
FinallyStatement ::= (FINALLY NoScopeNonEmptyStatement)
ThrowStatement ::= (THROW Expression SEMICOLON_OP)
ScopeGuardStatement ::=
(SCOPE EXPR_START "exit" EXPR_END NonEmptyOrScopeBlockStatement) |
(SCOPE EXPR_START "success" EXPR_END NonEmptyOrScopeBlockStatement) |
(SCOPE EXPR_START "failure" EXPR_END NonEmptyOrScopeBlockStatement)
AsmStatement ::= (ASM FunctionAttributes? CURLY_BRACE_LEFT AsmInstructionList? CURLY_BRACE_RIGHT)
AsmInstructionList ::=
(AsmInstruction SEMICOLON_OP AsmInstructionList) |
(AsmInstruction SEMICOLON_OP)
PragmaStatement ::= (Pragma NoScopeStatement)
MixinStatement ::= (MIXIN EXPR_START AssignExpression EXPR_END SEMICOLON_OP)
//--------------------------------------------------------
// IASM
//--------------------------------------------------------
AsmInstruction ::=
(IDENTIFIER COLON_OP AsmInstruction) |
(ALIGN INTEGER_EXPRESSION) |
"EVEN" |
"NAKED" |
"db" Operands |
"ds" Operands |
"di" Operands |
"dl" Operands |
"df" Operands |
"dd" Operands |
"de" Operands |
"db" STRING_LITERAL |
"db" TokenString |
"ds" STRING_LITERAL |
"ds" TokenString |
"di" STRING_LITERAL |
"di" TokenString |
"dl" STRING_LITERAL |
"dl" TokenString |
"dw" STRING_LITERAL |
"dw" TokenString |
"dq" STRING_LITERAL |
"dq" TokenString |
Opcode Operands |
Opcode
// TODO
Opcode ::= "EAX"
Operands ::=
(Operand PARAM_SEP Operands) |
Operand
INTEGER_EXPRESSION ::=
INTEGER_LITERAL |
IDENTIFIER
Register ::=
"AL" | "AH" | "AX" | "EAX" |
"BL" | "BH" | "BX" | "EBX" |
"CL" | "CH" | "CX" | "ECX" |
"DL" | "DH" | "DX" | "EDX" |
"BP" | "EBP" |
"SP" | "ESP" |
"DI" | "EDI" |
"SI" | "ESI" |
"ES" | "CS" | "SS" | "DS" | "GS" | "FS" |
"CR0" | "CR2" | "CR3" | "CR4" |
"DR0" | "DR1" | "DR2" | "DR3" | "DR6" | "DR7" |
"TR3" | "TR4" | "TR5" | "TR6" | "TR7" |
"ST" |
"ST(0)" | "ST(1)" | "ST(2)" | "ST(3)" | "ST(4)" | "ST(5)" | "ST(6)" | "ST(7)" |
"MM0" | "MM1" | "MM2" | "MM3" | "MM4" | "MM5" | "MM6" | "MM7" |
"XMM0" | "XMM1" | "XMM2" | "XMM3" | "XMM4" | "XMM5" | "XMM6" | "XMM7"
Register64 ::=
"RAX" | "RBX" | "RCX" | "RDX" |
"BPL" | "RBP" |
"SPL" | "RSP" |
"DIL" | "RDI" |
"SIL" | "RSI" |
"R8B" | "R8W" | "R8D" | "R8" |
"R9B" | "R9W" | "R9D" | "R9" |
"R10B" | "R10W" | "R10D" | "R10" |
"R11B" | "R11W" | "R11D" | "R11" |
"R12B" | "R12W" | "R12D" | "R12" |
"R13B" | "R13W" | "R13D" | "R13" |
"R14B" | "R14W" | "R14D" | "R14" |
"R15B" | "R15W" | "R15D" | "R15" |
"XMM8" | "XMM9" | "XMM10" | "XMM11" | "XMM12" | "XMM13" | "XMM14" | "XMM15" |
"YMM0" | "YMM1" | "YMM2" | "YMM3" | "YMM4" | "YMM5" | "YMM6" | "YMM7" |
"YMM8" | "YMM9" | "YMM10" | "YMM11" | "YMM12" | "YMM13" | "YMM14" | "YMM15"
Operand ::= AsmExp
AsmExp ::=
(AsmLogOrExp QUESTION_OP AsmExp COLON_OP AsmExp) |
AsmLogOrExp
AsmLogOrExp ::= (AsmLogAndExp AsmLogOrExpPrime)
AsmLogOrExpPrime ::= (OR_OP AsmLogAndExp AsmLogOrExpPrime)?
AsmLogAndExp ::= (AsmOrExp AsmLogAndExpPrime)
AsmLogAndExpPrime ::= (AND_OP AsmOrExp AsmLogAndExpPrime)?
AsmOrExp ::= (AsmXorExp AsmOrExpPrime)
AsmOrExpPrime ::= (BIT_OR_OP AsmXorExp AsmOrExpPrime)?
AsmXorExp ::= (AsmAndExp AsmXorExpPrime)
AsmXorExpPrime ::= (BIT_XOR_OP AsmAndExp AsmXorExpPrime)?
AsmAndExp ::= (AsmEqualExp AsmAndExpPrime)
AsmAndExpPrime ::= (BIT_AND_OP AsmEqualExp AsmAndExpPrime)?
AsmEqualExp ::= (AsmRelExp AsmEqualExpPrime)
AsmEqualExpPrime ::=
((EQUALS_OP AsmRelExp AsmEqualExpPrime) |
(NOT_EQUALS_OP AsmRelExp AsmEqualExpPrime))?
AsmRelExp ::= (AsmShiftExp AsmRelExpPrime)
AsmRelExpPrime ::=
((LESS_THAN_OP AsmShiftExp AsmRelExpPrime) |
(LESS_THAN_EQUALS_OP AsmShiftExp AsmRelExpPrime) |
(GREATER_THAN_OP AsmShiftExp AsmRelExpPrime) |
(GREATER_THAN_EQUALS_OP AsmShiftExp AsmRelExpPrime))?
AsmShiftExp ::= (AsmAddExp AsmShiftExpPrime)
AsmShiftExpPrime ::=
((SHIFT_LEFT_OP AsmAddExp AsmShiftExpPrime) |
(SHIFT_RIGHT_OP AsmAddExp AsmShiftExpPrime) |
(UNSIGNED_SHIFT_RIGHT_OP AsmAddExp AsmShiftExpPrime))?
AsmAddExp ::= (AsmMulExp AsmAddExpPrime)
AsmAddExpPrime ::=
((PLUS_OP AsmMulExp AsmAddExpPrime) |
(MINUS_OP AsmMulExp AsmAddExpPrime))?
AsmMulExp ::= (AsmBrExp AsmMulExpPrime)
AsmMulExpPrime ::=
((MUL_OP AsmBrExp AsmMulExpPrime) |
(DIV_OP AsmBrExp AsmMulExpPrime) |
(MOD_OP AsmBrExp AsmMulExpPrime))?
AsmBrExp ::= (AsmUnaExp AsmBrExpPrime)
AsmBrExpPrime ::= (LEFT_BRACKET AsmExp RIGHT_BRACKET AsmBrExpPrime)?
AsmUnaExp ::=
(AsmTypePrefix AsmExp) |
("offsetof" AsmExp) |
("seg" AsmExp) |
(PLUS_OP AsmUnaExp) |
(MINUS_OP AsmUnaExp) |
(NOT_OP AsmUnaExp) |
(CONCAT_OP AsmUnaExp) |
AsmPrimaryExp
AsmPrimaryExp ::=
INTEGER_LITERAL |
FLOAT_LITERAL |
"__LOCAL_SIZE" |
DOLLAR_OP |
(Register COLON_OP AsmExp) |
Register |
(Register64 COLON_OP AsmExp) |
Register64 |
DotIdentifier |
THIS
DotIdentifier ::=
(IDENTIFIER DOT_OP DotIdentifier) |
IDENTIFIER
AsmTypePrefix ::=
("near" ptr) |
("far" ptr) |
(BYTE ptr) |
(SHORT ptr) |
(INT ptr) |
("word" ptr) |
("dword" ptr) |
("qword" ptr) |
(FLOAT ptr) |
(DOUBLE ptr) |
(REAL ptr)
private Declaration ::=
AggregateDeclaration |
EnumDeclaration |
ImportDeclaration |
FuncDeclaration |
VarDeclarations |
AliasDeclaration
AliasDeclaration ::=
(ALIAS StorageClasses? BasicType Declarator SEMICOLON_OP) |
(ALIAS StorageClasses? BasicType FuncDeclaration SEMICOLON_OP) |
(ALIAS AliasDeclarationX SEMICOLON_OP)
AliasDeclarationX ::= (AliasDeclarationY AliasDeclarationXPrime)
AliasDeclarationXPrime ::= (PARAM_SEP AliasDeclarationY AliasDeclarationXPrime)?
AliasDeclarationY ::=
(IDENTIFIER TemplateParameters? ASSIGN_OP StorageClasses? Type) |
(IDENTIFIER TemplateParameters? ASSIGN_OP FunctionLiteral)
AutoDeclaration ::= (StorageClasses AutoDeclarationX SEMICOLON_OP)
AutoDeclarationX ::= (AutoDeclarationY AutoDeclarationXPrime)
AutoDeclarationXPrime ::= (PARAM_SEP AutoDeclarationY AutoDeclarationXPrime)?
AutoDeclarationY ::= (IDENTIFIER TemplateParameters? ASSIGN_OP Initializer)
VarDeclarations ::=
(StorageClasses? BasicType Declarators SEMICOLON_OP) |
AutoDeclaration
Declarators ::=
(DeclaratorInitializer PARAM_SEP DeclaratorIdentifierList) |
DeclaratorInitializer
DeclaratorInitializer ::=
(VarDeclarator TemplateParameters? ASSIGN_OP Initializer) |
VarDeclarator |
(AltDeclarator ASSIGN_OP Initializer) |
AltDeclarator
DeclaratorIdentifierList ::=
(DeclaratorIdentifier PARAM_SEP DeclaratorIdentifierList) |
DeclaratorIdentifier
DeclaratorIdentifier ::=
VarDeclaratorIdentifier |
AltDeclaratorIdentifier
VarDeclaratorIdentifier ::=
(IDENTIFIER TemplateParameters? ASSIGN_OP Initializer) |
IDENTIFIER
AltDeclaratorIdentifier ::=
(BasicType2 IDENTIFIER AltDeclaratorSuffixes? ASSIGN_OP Initializer) |
(BasicType2 IDENTIFIER AltDeclaratorSuffixes?) |
(BasicType2? IDENTIFIER AltDeclaratorSuffixes ASSIGN_OP Initializer) |
(BasicType2? IDENTIFIER AltDeclaratorSuffixes)
Declarator ::=
VarDeclarator |
AltDeclarator
VarDeclarator ::= (BasicType2? IDENTIFIER)
AltDeclarator ::=
(BasicType2? IDENTIFIER AltDeclaratorSuffixes) |
(BasicType2? EXPR_START AltDeclaratorX EXPR_END AltFuncDeclaratorSuffix) |
(BasicType2? EXPR_START AltDeclaratorX EXPR_END AltDeclaratorSuffixes) |
(BasicType2? EXPR_START AltDeclaratorX EXPR_END)
AltDeclaratorX ::=
(BasicType2? IDENTIFIER AltFuncDeclaratorSuffix) |
(BasicType2? IDENTIFIER) |
AltDeclarator
AltDeclaratorSuffixes ::=
(AltDeclaratorSuffix AltDeclaratorSuffixes) |
AltDeclaratorSuffix
AltDeclaratorSuffix ::=
(LEFT_BRACKET RIGHT_BRACKET) |
(LEFT_BRACKET AssignExpression RIGHT_BRACKET) |
(LEFT_BRACKET Type RIGHT_BRACKET)
AltFuncDeclaratorSuffix ::= (Parameters MemberFunctionAttributes?)
StorageClasses ::=
(StorageClass StorageClasses) |
StorageClass
StorageClass ::=
LinkageAttribute |
AlignAttribute |
DEPRECATED |
ENUM |
STATIC |
EXTERN |
ABSTRACT |
FINAL |
OVERRIDE |
SYNCHRONIZED |
AUTO |
SCOPE |
CONST |
IMMUTABLE |
INOUT |
SHARED |
GSHARED |
Property |
NOTHROW |
PURE |
REF
Initializer ::=
VoidInitializer |
NonVoidInitializer
VoidInitializer ::= VOID
NonVoidInitializer ::=
ExpInitializer |
ArrayInitializer |
StructInitializer
ExpInitializer ::= AssignExpression
ArrayInitializer ::= (LEFT_BRACKET ArrayMemberInitializations? RIGHT_BRACKET)
ArrayMemberInitializations ::=
(ArrayMemberInitialization PARAM_SEP ArrayMemberInitializations) |
(ArrayMemberInitialization PARAM_SEP) |
ArrayMemberInitialization
ArrayMemberInitialization ::=
NonVoidInitializer |
AssignExpression COLON_OP NonVoidInitializer
StructInitializer ::= (CURLY_BRACE_LEFT StructMemberInitializers? CURLY_BRACE_RIGHT)
StructMemberInitializers ::=
(StructMemberInitializer PARAM_SEP StructMemberInitializers) |
(StructMemberInitializer PARAM_SEP) |
StructMemberInitializer
StructMemberInitializer ::=
NonVoidInitializer |
(IDENTIFIER COLON_OP NonVoidInitializer)
//--------------------------------------------------------
// Functions
//--------------------------------------------------------
FuncDeclaration ::=
(StorageClasses? BasicType FuncDeclarator FunctionBody) |
AutoFuncDeclaration
AutoFuncDeclaration ::= (StorageClasses IDENTIFIER FuncDeclaratorSuffix FunctionBody)
FuncDeclarator ::= (BasicType2? IDENTIFIER FuncDeclaratorSuffix)
FuncDeclaratorSuffix ::=
(Parameters MemberFunctionAttributes?) |
(TemplateParameters Parameters MemberFunctionAttributes? Constraint?)
Parameters ::= (EXPR_START ParameterList? EXPR_END)
ParameterList ::=
(Parameter PARAM_SEP ParameterList) |
Parameter |
ELLIPSIS_OP
Parameter ::=
(InOut? BasicType Declarator ELLIPSIS_OP) |
(InOut? BasicType Declarator ASSIGN_OP AssignExpression) |
(InOut? BasicType Declarator) |
(InOut? Type) |
(InOut? Type ELLIPSIS_OP)
InOut ::= (InOutX InOutPrime)
InOutPrime ::= (InOutX InOutPrime)?
InOutX ::=
AUTO |
TypeCtor |
FINAL |
IN |
LAZY |
OUT |
REF |
RETURN REF |
SCOPE
FunctionAttributes ::=
(FunctionAttribute FunctionAttributes) |
FunctionAttribute
FunctionAttribute ::=
NOTHROW |
PURE |
Property
MemberFunctionAttributes ::=
(MemberFunctionAttribute MemberFunctionAttributes) |
MemberFunctionAttribute
MemberFunctionAttribute ::=
CONST |
IMMUTABLE |
INOUT |
RETURN |
SHARED |
FunctionAttribute
FunctionBody ::=
BlockStatement |
(FunctionContracts? BodyStatement) |
FunctionContracts
FunctionContracts ::=
(InStatement OutStatment?) |
(OutStatment InStatement?)
InStatement ::= (IN BlockStatement)
OutStatment ::=
(OUT BlockStatement) |
(OUT EXPR_START IDENTIFIER EXPR_END BlockStatement)
BodyStatement ::= (BODY BlockStatement)
Constructor ::=
(THIS Parameters MemberFunctionAttributes? SEMICOLON_OP) |
(THIS Parameters MemberFunctionAttributes? FunctionBody) |
ConstructorTemplate
ConstructorTemplate ::=
(THIS TemplateParameters Parameters MemberFunctionAttributes? Constraint? SEMICOLON_OP) |
(THIS TemplateParameters Parameters MemberFunctionAttributes? Constraint? FunctionBody)
Destructor ::=
(CONCAT_OP THIS EXPR_START EXPR_END MemberFunctionAttributes? SEMICOLON_OP) |
(CONCAT_OP THIS EXPR_START EXPR_END MemberFunctionAttributes? FunctionBody)
Postblit ::=
(THIS EXPR_START THIS EXPR_END MemberFunctionAttributes? SEMICOLON_OP) |
(THIS EXPR_START THIS EXPR_END MemberFunctionAttributes? FunctionBody)
Allocator ::=
(NEW Parameters SEMICOLON_OP) |
(NEW Parameters FunctionBody)
Deallocator ::=
(DELETE Parameters SEMICOLON_OP) |
(DELETE Parameters FunctionBody)
Invariant ::=
(INVARIANT_KEYWORD EXPR_START EXPR_END BlockStatement) |
(INVARIANT_KEYWORD BlockStatement)
UnitTest ::= (UNITTEST BlockStatement)
StaticConstructor ::=
(STATIC THIS EXPR_START EXPR_END MemberFunctionAttributes? SEMICOLON_OP) |
(STATIC THIS EXPR_START EXPR_END MemberFunctionAttributes? FunctionBody)
StaticDestructor ::=
(STATIC CONCAT_OP THIS EXPR_START EXPR_END MemberFunctionAttributes? SEMICOLON_OP) |
(STATIC CONCAT_OP THIS EXPR_START EXPR_END MemberFunctionAttributes? FunctionBody)
SharedStaticConstructor ::=
(SHARED STATIC THIS EXPR_START EXPR_END MemberFunctionAttributes? SEMICOLON_OP) |
(SHARED STATIC THIS EXPR_START EXPR_END MemberFunctionAttributes? FunctionBody)
SharedStaticDestructor ::=
(SHARED STATIC CONCAT_OP THIS EXPR_START EXPR_END MemberFunctionAttributes? SEMICOLON_OP) |
(SHARED STATIC CONCAT_OP THIS EXPR_START EXPR_END MemberFunctionAttributes? FunctionBody)
//-----------------------------------------------
// Aggregate
//-----------------------------------------------
AggregateDeclaration ::=
ClassDeclaration |
InterfaceDeclaration |
StructDeclaration |
UnionDeclaration
ClassDeclaration ::=
(CLASS IDENTIFIER SEMICOLON_OP) |
(CLASS IDENTIFIER BaseClassList? AggregateBody) |
ClassTemplateDeclaration
ClassTemplateDeclaration ::=
(CLASS IDENTIFIER TemplateParameters Constraint? BaseClassList? AggregateBody) |
(CLASS IDENTIFIER TemplateParameters BaseClassList Constraint AggregateBody)
InterfaceDeclaration ::=
(INTERFACE_KEYWORD IDENTIFIER SEMICOLON_OP) |
(INTERFACE_KEYWORD IDENTIFIER BaseInterfaceList? AggregateBody) |
InterfaceTemplateDeclaration
InterfaceTemplateDeclaration ::=
(INTERFACE_KEYWORD IDENTIFIER TemplateParameters Constraint? BaseInterfaceList? AggregateBody) |
(INTERFACE_KEYWORD IDENTIFIER TemplateParameters BaseInterfaceList Constraint AggregateBody)
StructDeclaration ::=
(STRUCT IDENTIFIER SEMICOLON_OP) |
(STRUCT IDENTIFIER AggregateBody) |
StructTemplateDeclaration |
AnonStructDeclaration
StructTemplateDeclaration ::= (STRUCT IDENTIFIER TemplateParameters Constraint? AggregateBody)
AnonStructDeclaration ::= (STRUCT AggregateBody)
UnionDeclaration ::=
(UNION IDENTIFIER SEMICOLON_OP) |
(UNION IDENTIFIER AggregateBody) |
UnionTemplateDeclaration |
AnonUnionDeclaration
UnionTemplateDeclaration ::= (UNION IDENTIFIER TemplateParameters Constraint? AggregateBody)
AnonUnionDeclaration ::= (UNION AggregateBody)
AggregateBody ::= (CURLY_BRACE_LEFT DeclDefs? CURLY_BRACE_RIGHT)
BaseClassList ::=
(COLON_OP SuperClass PARAM_SEP Interfaces) |
(COLON_OP SuperClass) |
(COLON_OP Interfaces)
BaseInterfaceList ::= (COLON_OP Interfaces)
SuperClass ::= BasicType
Interfaces ::=
(Interface PARAM_SEP Interfaces) |
Interface
Interface ::= BasicType
AliasThis ::= (ALIAS IDENTIFIER THIS SEMICOLON_OP)
//-------------------------------------------------------------
// Enum
//-------------------------------------------------------------
EnumDeclaration ::=
(ENUM IDENTIFIER EnumBody) |
(ENUM IDENTIFIER COLON_OP EnumBaseType EnumBody)
AnonymousEnumDeclaration
EnumBaseType ::= Type
EnumBody ::=
(CURLY_BRACE_LEFT EnumMembers CURLY_BRACE_RIGHT) |
SEMICOLON_OP
EnumMembers ::=
(EnumMember PARAM_SEP EnumMembers) |
(EnumMember PARAM_SEP) |
EnumMember
EnumMember ::=
(IDENTIFIER ASSIGN_OP AssignExpression) |
IDENTIFIER
AnonymousEnumDeclaration ::=
(ENUM COLON_OP EnumBaseType CURLY_BRACE_LEFT EnumMembers CURLY_BRACE_RIGHT) |
(ENUM CURLY_BRACE_LEFT EnumMembers CURLY_BRACE_RIGHT) |
(ENUM CURLY_BRACE_LEFT AnonymousEnumMembers CURLY_BRACE_RIGHT)
AnonymousEnumMembers ::=
(AnonymousEnumMember PARAM_SEP AnonymousEnumMembers) |
(AnonymousEnumMember PARAM_SEP) |
AnonymousEnumMember
AnonymousEnumMember ::=
EnumMember |
(Type IDENTIFIER ASSIGN_OP AssignExpression)
//---------------------------------------------------------------
// Template
//---------------------------------------------------------------
TemplateDeclaration ::= (TEMPLATE IDENTIFIER TemplateParameters Constraint? CURLY_BRACE_LEFT DeclDefs? CURLY_BRACE_RIGHT)
TemplateParameters ::= (EXPR_START TemplateParameterList? EXPR_END)
TemplateParameterList ::=
(TemplateParameter PARAM_SEP TemplateParameterList) |
(TemplateParameter PARAM_SEP) |
TemplateParameter
TemplateParameter ::=
TemplateTypeParameter |
TemplateValueParameter |
TemplateAliasParameter |
TemplateTupleParameter |
TemplateThisParameter
Constraint ::= (IF EXPR_START Expression EXPR_END)
TemplateInstance ::= (IDENTIFIER TemplateArguments)
TemplateArguments ::=
(NOT_OP EXPR_START TemplateArgumentList? EXPR_END) |
(NOT_OP TemplateSingleArgument)
TemplateArgumentList ::=
(TemplateArgument PARAM_SEP TemplateArgumentList) |
(TemplateArgument PARAM_SEP) |
TemplateArgument
TemplateArgument ::=
Type |
AssignExpression |
Symbol
Symbol ::=
SymbolTail |
(DOT_OP SymbolTail)
SymbolTail ::=
(IDENTIFIER DOT_OP SymbolTail) |
IDENTIFIER |
(TemplateInstance DOT_OP SymbolTail) |
TemplateInstance
TemplateSingleArgument ::=
IDENTIFIER |
BasicTypeX |
CHARACTER_LITERAL |
STRING_LITERAL |
TokenString |
INTEGER_LITERAL |
FLOAT_LITERAL |
TRUE |
FALSE |
NULL |
THIS |
SpecialKeyword
TemplateTypeParameter ::=
(IDENTIFIER TemplateTypeParameterSpecialization TemplateTypeParameterDefault) |
(IDENTIFIER TemplateTypeParameterSpecialization) |
(IDENTIFIER TemplateTypeParameterDefault) |
IDENTIFIER
TemplateTypeParameterSpecialization ::= (COLON_OP Type)
TemplateTypeParameterDefault ::= (ASSIGN_OP Type)
TemplateThisParameter ::= (THIS TemplateTypeParameter)
TemplateValueParameter ::=
(BasicType Declarator TemplateValueParameterSpecialization TemplateValueParameterDefault) |
(BasicType Declarator TemplateValueParameterSpecialization) |
(BasicType Declarator TemplateValueParameterDefault) |
(BasicType Declarator)
TemplateValueParameterSpecialization ::= (COLON_OP ConditionalExpression)
TemplateValueParameterDefault ::=
(ASSIGN_OP AssignExpression) |
(ASSIGN_OP SpecialKeyword)
TemplateAliasParameter ::=
(ALIAS IDENTIFIER TemplateAliasParameterSpecialization? TemplateAliasParameterDefault?) |
(ALIAS BasicType Declarator TemplateAliasParameterSpecialization? TemplateAliasParameterDefault?)
TemplateAliasParameterSpecialization ::=
(COLON_OP Type) |
(COLON_OP ConditionalExpression)
TemplateAliasParameterDefault ::=
(ASSIGN_OP Type) |
(ASSIGN_OP ConditionalExpression)
TemplateTupleParameter ::= (IDENTIFIER ELLIPSIS_OP)
TemplateMixinDeclaration ::= (MIXIN TEMPLATE IDENTIFIER TemplateParameters Constraint? CURLY_BRACE_LEFT DeclDefs? CURLY_BRACE_RIGHT)
TemplateMixin ::= (MIXIN MixinTemplateName TemplateArguments? IDENTIFIER? SEMICOLON_OP)
MixinTemplateName ::=
(DOT_OP QualifiedIdentifierList) |
QualifiedIdentifierList |
(Typeof DOT_OP QualifiedIdentifierList)
QualifiedIdentifierList ::=
(IDENTIFIER DOT_OP QualifiedIdentifierList) |
(TemplateInstance DOT_OP QualifiedIdentifierList) |
IDENTIFIER
AttributeSpecifier ::=
(Attribute COLON_OP) |
(Attribute DeclarationBlock)
Attribute ::=
LinkageAttribute |
AlignAttribute |
DeprecatedAttribute |
ProtectionAttribute |
Pragma |
STATIC |
EXTERN |
ABSTRACT |
FINAL |
OVERRIDE |
SYNCHRONIZED |
AUTO |
SCOPE |
CONST |
IMMUTABLE |
INOUT |
SHARED |
GSHARED |
Property |
NOTHROW |
PURE |
REF
DeclarationBlock ::=
DeclDef |
(CURLY_BRACE_LEFT DeclDefs? CURLY_BRACE_RIGHT)
LinkageAttribute ::=
(EXTERN EXPR_START LinkageType EXPR_END) |
(EXTERN EXPR_START "C++" PARAM_SEP IdentifierList) |
(EXTERN EXPR_START "C++" PARAM_SEP CppAggregateType)
LinkageType ::=
"C" |
"C++" |
"D" |
"Windows" |
"Pascal" |
"System" |
"Objective-C"
CppAggregateType ::= (CLASS STRUCT)
AlignAttribute ::=
(ALIGN EXPR_START AssignExpression EXPR_END) |
ALIGN
DeprecatedAttribute ::=
(DEPRECATED EXPR_START AssignExpression EXPR_END) |
DEPRECATED
ProtectionAttribute ::=
PRIVATE |
(PACKAGE EXPR_START IdentifierList EXPR_END) |
PACKAGE |
PROTECTED |
PUBLIC |
EXPORT
Property ::=
(AT_OP PropertyIdentifier) |
UserDefinedAttribute
PropertyIdentifier ::=
"property" |
"safe" |
"trusted" |
"system" |
"disable" |
"nogc"
UserDefinedAttribute ::=
(AT_OP EXPR_START ArgumentList EXPR_END) |
(AT_OP IDENTIFIER EXPR_START ArgumentList? EXPR_END) |
(AT_OP IDENTIFIER) |
(AT_OP TemplateInstance EXPR_START ArgumentList? EXPR_END) |
(AT_OP TemplateInstance)
Pragma ::=
(PRAGMA_KEYWORD EXPR_START IDENTIFIER EXPR_END) |
(PRAGMA_KEYWORD EXPR_START IDENTIFIER PARAM_SEP ArgumentList EXPR_END)
//-----------------------------------------------------------------
// Conditional
//-----------------------------------------------------------------
ConditionalDeclaration ::=
(Condition DeclarationBlock ELSE DeclarationBlock) |
(Condition DeclarationBlock ELSE COLON_OP DeclDefs?) |
(Condition DeclarationBlock) |
(Condition COLON_OP DeclDefs?)
ConditionalStatement ::=
(Condition NoScopeNonEmptyStatement ELSE NoScopeNonEmptyStatement) |
(Condition NoScopeNonEmptyStatement)
Condition ::=
VersionCondition |
DebugCondition |
StaticIfCondition
VersionCondition ::=
(VERSION EXPR_START INTEGER_LITERAL EXPR_END) |
(VERSION EXPR_START IDENTIFIER EXPR_END) |
(VERSION EXPR_START UNITTEST EXPR_END) |
(VERSION EXPR_START ASSERT EXPR_END)
DebugCondition ::=
(DEBUG EXPR_START INTEGER_LITERAL EXPR_END) |
(DEBUG EXPR_START IDENTIFIER EXPR_END) |
DEBUG
StaticIfCondition ::= (STATIC IF EXPR_START AssignExpression EXPR_END)
VersionSpecification ::=
(VERSION ASSIGN_OP IDENTIFIER SEMICOLON_OP) |
(VERSION ASSIGN_OP INTEGER_LITERAL SEMICOLON_OP)
DebugSpecificaiton ::=
(DEBUG ASSIGN_OP IDENTIFIER SEMICOLON_OP) |
(DEBUG ASSIGN_OP INTEGER_LITERAL SEMICOLON_OP)
StaticAssert ::=
(STATIC ASSERT EXPR_START AssignExpression PARAM_SEP? EXPR_END SEMICOLON_OP) |
(STATIC ASSERT EXPR_START AssignExpression PARAM_SEP AssignExpression PARAM_SEP? EXPR_END SEMICOLON_OP)
//---------------------------------------------------------------------
// Module
//---------------------------------------------------------------------
private DeclDefs ::=
(DeclDef DeclDefs) |
DeclDef
private DeclDef ::=
AttributeSpecifier |
Declaration |
Constructor |
Destructor |
Postblit |
Allocator |
Deallocator |
Invariant |
UnitTest |
AliasThis |
StaticConstructor |
StaticDestructor |
SharedStaticConstructor |
SharedStaticDestructor |
ConditionalDeclaration |
DebugSpecificaiton |
VersionSpecification |
StaticAssert |
TemplateDeclaration |
TemplateMixinDeclaration |
TemplateMixin |
MixinDeclaration |
SEMICOLON_OP
ModuleDeclaration ::= (MODULE ModuleFullyQualifiedName SEMICOLON_OP)
ModuleFullyQualifiedName ::= ModuleName (DOT_OP ModuleName)*
ModuleName ::= IDENTIFIER
ImportDeclaration ::=
(IMPORT_KEYWORD ImportList SEMICOLON_OP) |
(STATIC IMPORT_KEYWORD ImportList)
ImportList ::=
(Import PARAM_SEP ImportList) |
(ImportBindings) |
Import
Import ::=
(ModuleAliasIdentifier ASSIGN_OP ModuleFullyQualifiedName) |
ModuleFullyQualifiedName
ImportBindings ::= (Import COLON_OP ImportBindList)
ImportBindList ::=
(ImportBind PARAM_SEP ImportBindList) |
ImportBind
ImportBind ::=
(IDENTIFIER ASSIGN_OP IDENTIFIER) |
IDENTIFIER
ModuleAliasIdentifier ::= IDENTIFIER
MixinDeclaration ::= (MIXIN EXPR_START AssignExpression EXPR_END SEMICOLON_OP)
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment