diff --git a/std/d/ast.d b/std/d/ast.d
index 0dfd1e8..ec63238 100755
--- a/std/d/ast.d
+++ b/std/d/ast.d
@@ -20,221 +20,227 @@ import std.d.lexer;
/**
* Implements the $(LINK2 http://en.wikipedia.org/wiki/Visitor_pattern, Visitor Pattern)
- * for the various AST classes
+ * for the various AST ///
+classes
*/
-abstract class ASTVisitor
+abstract ///
+class ASTVisitor
{
- /** */ void visit(AddExpression addExpression) {}
- /** */ void visit(AliasDeclaration aliasDeclaration) {}
- /** */ void visit(AliasInitializer aliasInitializer) {}
- /** */ void visit(AliasThisDeclaration aliasThisDeclaration) {}
- /** */ void visit(AlignAttribute alignAttribute) {}
- /** */ void visit(AndAndExpression andAndExpression) {}
- /** */ void visit(AndExpression andExpression) {}
- /** */ void visit(ArgumentList argumentList) {}
- /** */ void visit(Arguments arguments) {}
- /** */ void visit(ArrayInitializer arrayInitializer) {}
- /** */ void visit(ArrayLiteral arrayLiteral) {}
- /** */ void visit(ArrayMemberInitialization arrayMemberInitialization) {}
- /** */ void visit(ArrayMemberInitializations arrayMemberInitializations) {}
- /** */ void visit(AsmAddExp asmAddExp) {}
- /** */ void visit(AsmAndExp asmAndExp) {}
- /** */ void visit(AsmBrExp asmBrExp) {}
- /** */ void visit(AsmEqualExp asmEqualExp) {}
- /** */ void visit(AsmExp asmExp) {}
- /** */ void visit(AsmInstruction asmInstruction) {}
- /** */ void visit(AsmLogAndExp asmLogAndExp) {}
- /** */ void visit(AsmLogOrExp asmLogOrExp) {}
- /** */ void visit(AsmMulExp asmMulExp) {}
- /** */ void visit(AsmOrExp asmOrExp) {}
- /** */ void visit(AsmPrimaryExp asmPrimaryExp) {}
- /** */ void visit(AsmRelExp asmRelExp) {}
- /** */ void visit(AsmShiftExp asmShiftExp) {}
- /** */ void visit(AsmStatement asmStatement) {}
- /** */ void visit(AsmTypePrefix asmTypePrefix) {}
- /** */ void visit(AsmUnaExp asmUnaExp) {}
- /** */ void visit(AsmXorExp asmXorExp) {}
- /** */ void visit(AssertExpression assertExpression) {}
- /** */ void visit(AssertStatement assertStatement) {}
- /** */ void visit(AssignExpression assignExpression) {}
- /** */ void visit(AssignStatement assignStatement) {}
- /** */ void visit(AssocArrayLiteral assocArrayLiteral) {}
- /** */ void visit(AtAttribute atAttribute) {}
- /** */ void visit(Attribute attribute) {}
- /** */ void visit(AttributedDeclaration attributedDeclaration) {}
- /** */ void visit(AutoDeclaration autoDeclaration) {}
- /** */ void visit(BlockStatement blockStatement) {}
- /** */ void visit(BodyStatement bodyStatement) {}
- /** */ void visit(BreakStatement breakStatement) {}
- /** */ void visit(BasicType builtinType) {}
- /** */ void visit(CaseRangeStatement caseRangeStatement) {}
- /** */ void visit(CaseStatement caseStatement) {}
- /** */ void visit(CastExpression castExpression) {}
- /** */ void visit(CastQualifier castQualifier) {}
- /** */ void visit(Catch catch_) {}
- /** */ void visit(Catches catches) {}
- /** */ void visit(ClassBody classBody) {}
- /** */ void visit(ClassDeclaration classDeclaration) {}
- /** */ void visit(CmpExpression cmpExpression) {}
- /** */ void visit(CompileCondition compileCondition) {}
- /** */ void visit(ConditionalDeclaration conditionalDeclaration) {}
- /** */ void visit(ConditionalStatement conditionalStatement) {}
- /** */ void visit(Constraint constraint) {}
- /** */ void visit(Constructor constructor) {}
- /** */ void visit(ContinueStatement continueStatement) {}
- /** */ void visit(DebugCondition debugCondition) {}
- /** */ void visit(DebugSpecification debugSpecification) {}
- /** */ void visit(Declaration declaration) {}
- /** */ void visit(DeclarationsAndStatements declarationsAndStatements) {}
- /** */ void visit(DeclarationOrInvariant declarationOrInvariant) {}
- /** */ void visit(Declarator declarator) {}
- /** */ void visit(DeclaratorSuffix declaratorSuffix) {}
- /** */ void visit(DefaultStatement defaultStatement) {}
- /** */ void visit(DeleteExpression deleteExpression) {}
- /** */ void visit(DeleteStatement deleteStatement) {}
- /** */ void visit(Deprecated deprecated_) {}
- /** */ void visit(Destructor destructor) {}
- /** */ void visit(DoStatement doStatement) {}
- /** */ void visit(EnumBody enumBody) {}
- /** */ void visit(EnumDeclaration enumDeclaration) {}
- /** */ void visit(EnumMember enumMember) {}
- /** */ void visit(EqualExpression equalExpression) {}
- /** */ void visit(Expression expression) {}
- /** */ void visit(FinalSwitchStatement finalSwitchStatement) {}
- /** */ void visit(Finally finally_) {}
- /** */ void visit(ForStatement forStatement) {}
- /** */ void visit(ForeachRangeStatement foreachRangeStatement) {}
- /** */ void visit(ForeachStatement foreachStatement) {}
- /** */ void visit(ForeachType foreachType) {}
- /** */ void visit(ForeachTypeList foreachTypeList) {}
- /** */ void visit(FunctionAttribute functionAttribute) {}
- /** */ void visit(FunctionBody functionBody) {}
- /** */ void visit(FunctionCallExpression functionCallExpression) {}
- /** */ void visit(FunctionCallStatement functionCallStatement) {}
- /** */ void visit(FunctionDeclaration functionDeclaration) {}
- /** */ void visit(FunctionLiteralExpression functionLiteralExpression) {}
- /** */ void visit(GotoStatement gotoStatement) {}
- /** */ void visit(IdentifierChain identifierChain) {}
- /** */ void visit(IdentifierList identifierList) {}
- /** */ void visit(IdentifierOrTemplateChain identifierOrTemplateChain) {}
- /** */ void visit(IdentifierOrTemplateInstance identifierOrTemplateInstance) {}
- /** */ void visit(IdentityExpression identityExpression) {}
- /** */ void visit(IfStatement ifStatement) {}
- /** */ void visit(ImportBind importBind) {}
- /** */ void visit(ImportBindings importBindings) {}
- /** */ void visit(ImportDeclaration importDeclaration) {}
- /** */ void visit(ImportExpression importExpression) {}
- /** */ void visit(ImportList importList) {}
- /** */ void visit(InExpression inExpression) {}
- /** */ void visit(InStatement inStatement) {}
- /** */ void visit(Initialize initialize) {}
- /** */ void visit(Initializer initializer) {}
- /** */ void visit(InterfaceDeclaration interfaceDeclaration) {}
- /** */ void visit(Invariant invariant_) {}
- /** */ void visit(IsExpression isExpression) {}
- /** */ void visit(KeyValuePair keyValuePair) {}
- /** */ void visit(KeyValuePairs keyValuePairs) {}
- /** */ void visit(LabeledStatement labeledStatement) {}
- /** */ void visit(LambdaExpression lambdaExpression) {}
- /** */ void visit(LastCatch lastCatch) {}
- /** */ void visit(LinkageAttribute linkageAttribute) {}
- /** */ void visit(MemberFunctionAttribute memberFunctionAttribute) {}
- /** */ void visit(MixinDeclaration mixinDeclaration) {}
- /** */ void visit(MixinExpression mixinExpression) {}
- /** */ void visit(MixinTemplateName mixinTemplateName) {}
- /** */ void visit(Module module_) {}
- /** */ void visit(ModuleDeclaration moduleDeclaration) {}
- /** */ void visit(MulExpression mulExpression) {}
- /** */ void visit(NewAnonClassExpression newAnonClassExpression) {}
- /** */ void visit(NewExpression newExpression) {}
- /** */ void visit(NonEmptyStatement nonEmptyStatement) {}
- /** */ void visit(NonEmptyStatementNoCaseNoDefault nonEmptyStatementNoCaseNoDefault) {}
- /** */ void visit(NonVoidInitializer nonVoidInitializer) {}
- /** */ void visit(Opcode opcode) {}
- /** */ void visit(Operand operand) {}
- /** */ void visit(Operands operands) {}
- /** */ void visit(OrExpression orExpression) {}
- /** */ void visit(OrOrExpression orOrExpression) {}
- /** */ void visit(OutStatement outStatement) {}
- /** */ void visit(Parameter parameter) {}
- /** */ void visit(ParameterAttribute parameterAttribute) {}
- /** */ void visit(Parameters parameters) {}
- /** */ void visit(PostIncDecExpression postIncDecExpression) {}
- /** */ void visit(PowExpression powExpression) {}
- /** */ void visit(PragmaDeclaration pragmaDeclaration) {}
- /** */ void visit(PragmaExpression pragmaExpression) {}
- /** */ void visit(PreIncDecExpression preIncDecExpression) {}
- /** */ void visit(PrimaryExpression primaryExpression) {}
- /** */ void visit(ProtectionAttribute protectionAttribute) {}
- /** */ void visit(Register register) {}
- /** */ void visit(RelExpression relExpression) {}
- /** */ void visit(ReturnStatement returnStatement) {}
- /** */ void visit(ScopeGuardStatement scopeGuardStatement) {}
- /** */ void visit(SharedStaticConstructor sharedStaticConstructor) {}
- /** */ void visit(SharedStaticDestructor sharedStaticDestructor) {}
- /** */ void visit(ShiftExpression shiftExpression) {}
- /** */ void visit(SingleImport singleImport) {}
- /** */ void visit(Statement statement) {}
- /** */ void visit(StatementNoCaseNoDefault statementNoCaseNoDefault) {}
- /** */ void visit(StaticAssertDeclaration staticAssertDeclaration) {}
- /** */ void visit(StaticAssertStatement staticAssertStatement) {}
- /** */ void visit(StaticConstructor staticConstructor) {}
- /** */ void visit(StaticDestructor staticDestructor) {}
- /** */ void visit(StaticIfCondition staticIfCondition) {}
- /** */ void visit(StorageClass storageClass) {}
- /** */ void visit(StructBody structBody) {}
- /** */ void visit(StructDeclaration structDeclaration) {}
- /** */ void visit(StructInitializer structInitializer) {}
- /** */ void visit(StructMemberInitializer structMemberInitializer) {}
- /** */ void visit(StructMemberInitializers structMemberInitializers) {}
- /** */ void visit(SwitchBody switchBody) {}
- /** */ void visit(SwitchStatement switchStatement) {}
- /** */ void visit(Symbol symbol) {}
- /** */ void visit(SynchronizedStatement synchronizedStatement) {}
- /** */ void visit(TemplateAliasParameter templateAliasParameter) {}
- /** */ void visit(TemplateArgument templateArgument) {}
- /** */ void visit(TemplateArgumentList templateArgumentList) {}
- /** */ void visit(TemplateArguments templateArguments) {}
- /** */ void visit(TemplateDeclaration templateDeclaration) {}
- /** */ void visit(TemplateInstance templateInstance) {}
- /** */ void visit(TemplateMixinStatement templateMixinStatement) {}
- /** */ void visit(TemplateParameter templateParameter) {}
- /** */ void visit(TemplateParameterList templateParameterList) {}
- /** */ void visit(TemplateParameters templateParameters) {}
- /** */ void visit(TemplateSingleArgument templateSingleArgument) {}
- /** */ void visit(TemplateThisParameter templateThisParameter) {}
- /** */ void visit(TemplateTupleParameter templateTupleParameter) {}
- /** */ void visit(TemplateTypeParameter templateTypeParameter) {}
- /** */ void visit(TemplateValueParameter templateValueParameter) {}
- /** */ void visit(TemplateValueParameterDefault templateValueParameterDefault) {}
- /** */ void visit(TernaryExpression ternaryExpression) {}
- /** */ void visit(ThrowStatement throwStatement) {}
- /** */ void visit(TraitsArgument traitsArgument) {}
- /** */ void visit(TraitsExpression traitsExpression) {}
- /** */ void visit(TryStatement tryStatement) {}
- /** */ void visit(Type type) {}
- /** */ void visit(Type2 type2) {}
- /** */ void visit(Type3 type3) {}
- /** */ void visit(TypeConstructor typeConstructor) {}
- /** */ void visit(TypeConstructors typeConstructors) {}
- /** */ void visit(TypeSpecialization typeSpecialization) {}
- /** */ void visit(TypeSuffix typeSuffix) {}
- /** */ void visit(TypeidExpression typeidExpression) {}
- /** */ void visit(TypeofExpression typeofExpression) {}
- /** */ void visit(UnaryExpression unaryExpression) {}
- /** */ void visit(UnionDeclaration unionDeclaration) {}
- /** */ void visit(Unittest unittest_) {}
- /** */ void visit(VariableDeclaration variableDeclaration) {}
- /** */ void visit(VersionCondition versionCondition) {}
- /** */ void visit(VersionSpecification versionSpecification) {}
- /** */ void visit(WhileStatement whileStatement) {}
- /** */ void visit(WithStatement withStatement) {}
- /** */ void visit(XorExpression xorExpression) {}
+ /** */void visit(AddExpression addExpression) {}
+ /** */void visit(AliasDeclaration aliasDeclaration) {}
+ /** */void visit(AliasInitializer aliasInitializer) {}
+ /** */void visit(AliasThisDeclaration aliasThisDeclaration) {}
+ /** */void visit(AlignAttribute alignAttribute) {}
+ /** */void visit(AndAndExpression andAndExpression) {}
+ /** */void visit(AndExpression andExpression) {}
+ /** */void visit(ArgumentList argumentList) {}
+ /** */void visit(Arguments arguments) {}
+ /** */void visit(ArrayInitializer arrayInitializer) {}
+ /** */void visit(ArrayLiteral arrayLiteral) {}
+ /** */void visit(ArrayMemberInitialization arrayMemberInitialization) {}
+ /** */void visit(ArrayMemberInitializations arrayMemberInitializations) {}
+ /** */void visit(AsmAddExp asmAddExp) {}
+ /** */void visit(AsmAndExp asmAndExp) {}
+ /** */void visit(AsmBrExp asmBrExp) {}
+ /** */void visit(AsmEqualExp asmEqualExp) {}
+ /** */void visit(AsmExp asmExp) {}
+ /** */void visit(AsmInstruction asmInstruction) {}
+ /** */void visit(AsmLogAndExp asmLogAndExp) {}
+ /** */void visit(AsmLogOrExp asmLogOrExp) {}
+ /** */void visit(AsmMulExp asmMulExp) {}
+ /** */void visit(AsmOrExp asmOrExp) {}
+ /** */void visit(AsmPrimaryExp asmPrimaryExp) {}
+ /** */void visit(AsmRelExp asmRelExp) {}
+ /** */void visit(AsmShiftExp asmShiftExp) {}
+ /** */void visit(AsmStatement asmStatement) {}
+ /** */void visit(AsmTypePrefix asmTypePrefix) {}
+ /** */void visit(AsmUnaExp asmUnaExp) {}
+ /** */void visit(AsmXorExp asmXorExp) {}
+ /** */void visit(AssertExpression assertExpression) {}
+ /** */void visit(AssertStatement assertStatement) {}
+ /** */void visit(AssignExpression assignExpression) {}
+ /** */void visit(AssignStatement assignStatement) {}
+ /** */void visit(AssocArrayLiteral assocArrayLiteral) {}
+ /** */void visit(AtAttribute atAttribute) {}
+ /** */void visit(Attribute attribute) {}
+ /** */void visit(AttributedDeclaration attributedDeclaration) {}
+ /** */void visit(AutoDeclaration autoDeclaration) {}
+ /** */void visit(BlockStatement blockStatement) {}
+ /** */void visit(BodyStatement bodyStatement) {}
+ /** */void visit(BreakStatement breakStatement) {}
+ /** */void visit(BasicType builtinType) {}
+ /** */void visit(CaseRangeStatement caseRangeStatement) {}
+ /** */void visit(CaseStatement caseStatement) {}
+ /** */void visit(CastExpression castExpression) {}
+ /** */void visit(CastQualifier castQualifier) {}
+ /** */void visit(Catch catch_) {}
+ /** */void visit(Catches catches) {}
+ /** */void visit(ClassBody ///
+classBody) {}
+ /** */void visit(ClassDeclaration ///
+classDeclaration) {}
+ /** */void visit(CmpExpression cmpExpression) {}
+ /** */void visit(CompileCondition compileCondition) {}
+ /** */void visit(ConditionalDeclaration conditionalDeclaration) {}
+ /** */void visit(ConditionalStatement conditionalStatement) {}
+ /** */void visit(Constraint constraint) {}
+ /** */void visit(Constructor constructor) {}
+ /** */void visit(ContinueStatement continueStatement) {}
+ /** */void visit(DebugCondition debugCondition) {}
+ /** */void visit(DebugSpecification debugSpecification) {}
+ /** */void visit(Declaration declaration) {}
+ /** */void visit(DeclarationsAndStatements declarationsAndStatements) {}
+ /** */void visit(DeclarationOrInvariant declarationOrInvariant) {}
+ /** */void visit(Declarator declarator) {}
+ /** */void visit(DeclaratorSuffix declaratorSuffix) {}
+ /** */void visit(DefaultStatement defaultStatement) {}
+ /** */void visit(DeleteExpression deleteExpression) {}
+ /** */void visit(DeleteStatement deleteStatement) {}
+ /** */void visit(Deprecated deprecated_) {}
+ /** */void visit(Destructor destructor) {}
+ /** */void visit(DoStatement doStatement) {}
+ /** */void visit(EnumBody enumBody) {}
+ /** */void visit(EnumDeclaration enumDeclaration) {}
+ /** */void visit(EnumMember enumMember) {}
+ /** */void visit(EqualExpression equalExpression) {}
+ /** */void visit(Expression expression) {}
+ /** */void visit(FinalSwitchStatement finalSwitchStatement) {}
+ /** */void visit(Finally finally_) {}
+ /** */void visit(ForStatement forStatement) {}
+ /** */void visit(ForeachRangeStatement foreachRangeStatement) {}
+ /** */void visit(ForeachStatement foreachStatement) {}
+ /** */void visit(ForeachType foreachType) {}
+ /** */void visit(ForeachTypeList foreachTypeList) {}
+ /** */void visit(FunctionAttribute functionAttribute) {}
+ /** */void visit(FunctionBody functionBody) {}
+ /** */void visit(FunctionCallExpression functionCallExpression) {}
+ /** */void visit(FunctionCallStatement functionCallStatement) {}
+ /** */void visit(FunctionDeclaration functionDeclaration) {}
+ /** */void visit(FunctionLiteralExpression functionLiteralExpression) {}
+ /** */void visit(GotoStatement gotoStatement) {}
+ /** */void visit(IdentifierChain identifierChain) {}
+ /** */void visit(IdentifierList identifierList) {}
+ /** */void visit(IdentifierOrTemplateChain identifierOrTemplateChain) {}
+ /** */void visit(IdentifierOrTemplateInstance identifierOrTemplateInstance) {}
+ /** */void visit(IdentityExpression identityExpression) {}
+ /** */void visit(IfStatement ifStatement) {}
+ /** */void visit(ImportBind importBind) {}
+ /** */void visit(ImportBindings importBindings) {}
+ /** */void visit(ImportDeclaration importDeclaration) {}
+ /** */void visit(ImportExpression importExpression) {}
+ /** */void visit(ImportList importList) {}
+ /** */void visit(IndexExpression indexExpression) {}
+ /** */void visit(InExpression inExpression) {}
+ /** */void visit(InStatement inStatement) {}
+ /** */void visit(Initialize initialize) {}
+ /** */void visit(Initializer initializer) {}
+ /** */void visit(InterfaceDeclaration interfaceDeclaration) {}
+ /** */void visit(Invariant invariant_) {}
+ /** */void visit(IsExpression isExpression) {}
+ /** */void visit(KeyValuePair keyValuePair) {}
+ /** */void visit(KeyValuePairs keyValuePairs) {}
+ /** */void visit(LabeledStatement labeledStatement) {}
+ /** */void visit(LambdaExpression lambdaExpression) {}
+ /** */void visit(LastCatch lastCatch) {}
+ /** */void visit(LinkageAttribute linkageAttribute) {}
+ /** */void visit(MemberFunctionAttribute memberFunctionAttribute) {}
+ /** */void visit(MixinDeclaration mixinDeclaration) {}
+ /** */void visit(MixinExpression mixinExpression) {}
+ /** */void visit(MixinTemplateName mixinTemplateName) {}
+ /** */void visit(Module module_) {}
+ /** */void visit(ModuleDeclaration moduleDeclaration) {}
+ /** */void visit(MulExpression mulExpression) {}
+ /** */void visit(NewAnonClassExpression newAnonClassExpression) {}
+ /** */void visit(NewExpression newExpression) {}
+ /** */void visit(NonEmptyStatement nonEmptyStatement) {}
+ /** */void visit(NonEmptyStatementNoCaseNoDefault nonEmptyStatementNoCaseNoDefault) {}
+ /** */void visit(NonVoidInitializer nonVoidInitializer) {}
+ /** */void visit(Opcode opcode) {}
+ /** */void visit(Operand operand) {}
+ /** */void visit(Operands operands) {}
+ /** */void visit(OrExpression orExpression) {}
+ /** */void visit(OrOrExpression orOrExpression) {}
+ /** */void visit(OutStatement outStatement) {}
+ /** */void visit(Parameter parameter) {}
+ /** */void visit(ParameterAttribute parameterAttribute) {}
+ /** */void visit(Parameters parameters) {}
+ /** */void visit(PostIncDecExpression postIncDecExpression) {}
+ /** */void visit(PowExpression powExpression) {}
+ /** */void visit(PragmaDeclaration pragmaDeclaration) {}
+ /** */void visit(PragmaExpression pragmaExpression) {}
+ /** */void visit(PreIncDecExpression preIncDecExpression) {}
+ /** */void visit(PrimaryExpression primaryExpression) {}
+ /** */void visit(ProtectionAttribute protectionAttribute) {}
+ /** */void visit(Register register) {}
+ /** */void visit(RelExpression relExpression) {}
+ /** */void visit(ReturnStatement returnStatement) {}
+ /** */void visit(ScopeGuardStatement scopeGuardStatement) {}
+ /** */void visit(SharedStaticConstructor sharedStaticConstructor) {}
+ /** */void visit(SharedStaticDestructor sharedStaticDestructor) {}
+ /** */void visit(ShiftExpression shiftExpression) {}
+ /** */void visit(SingleImport singleImport) {}
+ /** */void visit(SliceExpression sliceExpression) {}
+ /** */void visit(Statement statement) {}
+ /** */void visit(StatementNoCaseNoDefault statementNoCaseNoDefault) {}
+ /** */void visit(StaticAssertDeclaration staticAssertDeclaration) {}
+ /** */void visit(StaticAssertStatement staticAssertStatement) {}
+ /** */void visit(StaticConstructor staticConstructor) {}
+ /** */void visit(StaticDestructor staticDestructor) {}
+ /** */void visit(StaticIfCondition staticIfCondition) {}
+ /** */void visit(StorageClass storageClass) {}
+ /** */void visit(StructBody structBody) {}
+ /** */void visit(StructDeclaration structDeclaration) {}
+ /** */void visit(StructInitializer structInitializer) {}
+ /** */void visit(StructMemberInitializer structMemberInitializer) {}
+ /** */void visit(StructMemberInitializers structMemberInitializers) {}
+ /** */void visit(SwitchBody switchBody) {}
+ /** */void visit(SwitchStatement switchStatement) {}
+ /** */void visit(Symbol symbol) {}
+ /** */void visit(SynchronizedStatement synchronizedStatement) {}
+ /** */void visit(TemplateAliasParameter templateAliasParameter) {}
+ /** */void visit(TemplateArgument templateArgument) {}
+ /** */void visit(TemplateArgumentList templateArgumentList) {}
+ /** */void visit(TemplateArguments templateArguments) {}
+ /** */void visit(TemplateDeclaration templateDeclaration) {}
+ /** */void visit(TemplateInstance templateInstance) {}
+ /** */void visit(TemplateMixinStatement templateMixinStatement) {}
+ /** */void visit(TemplateParameter templateParameter) {}
+ /** */void visit(TemplateParameterList templateParameterList) {}
+ /** */void visit(TemplateParameters templateParameters) {}
+ /** */void visit(TemplateSingleArgument templateSingleArgument) {}
+ /** */void visit(TemplateThisParameter templateThisParameter) {}
+ /** */void visit(TemplateTupleParameter templateTupleParameter) {}
+ /** */void visit(TemplateTypeParameter templateTypeParameter) {}
+ /** */void visit(TemplateValueParameter templateValueParameter) {}
+ /** */void visit(TemplateValueParameterDefault templateValueParameterDefault) {}
+ /** */void visit(TernaryExpression ternaryExpression) {}
+ /** */void visit(ThrowStatement throwStatement) {}
+ /** */void visit(TraitsArgument traitsArgument) {}
+ /** */void visit(TraitsExpression traitsExpression) {}
+ /** */void visit(TryStatement tryStatement) {}
+ /** */void visit(Type type) {}
+ /** */void visit(Type2 type2) {}
+ /** */void visit(Type3 type3) {}
+ /** */void visit(TypeConstructor typeConstructor) {}
+ /** */void visit(TypeConstructors typeConstructors) {}
+ /** */void visit(TypeSpecialization typeSpecialization) {}
+ /** */void visit(TypeSuffix typeSuffix) {}
+ /** */void visit(TypeidExpression typeidExpression) {}
+ /** */void visit(TypeofExpression typeofExpression) {}
+ /** */void visit(UnaryExpression unaryExpression) {}
+ /** */void visit(UnionDeclaration unionDeclaration) {}
+ /** */void visit(Unittest unittest_) {}
+ /** */void visit(VariableDeclaration variableDeclaration) {}
+ /** */void visit(VersionCondition versionCondition) {}
+ /** */void visit(VersionSpecification versionSpecification) {}
+ /** */void visit(WhileStatement whileStatement) {}
+ /** */void visit(WithStatement withStatement) {}
+ /** */void visit(XorExpression xorExpression) {}
}
interface ASTNode
{
- void accept(ASTVisitor visitor);
+ /** */ void accept(ASTVisitor visitor);
}
immutable string OVERRIDE_DEFAULT_ACCEPT = q{override void accept(ASTVisitor visitor) { visitor.visit(this); }};
@@ -242,548 +248,614 @@ immutable string DEFAULT_ACCEPT = q{void accept(ASTVisitor visitor) { visitor.vi
immutable string SHIFT_SHIFT_BODY = q{
- Token operator;
- ShiftExpression left;
- ShiftExpression right;
+ /** */ Token operator;
+ /** */ ShiftExpression left;
+ /** */ ShiftExpression right;
};
+///
class AddExpression : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- TokenType operator;
- AddExpression left;
- MulExpression right;
+ /** */TokenType operator;
+ /** */AddExpression left;
+ /** */MulExpression right;
}
+///
class AliasDeclaration : Declaration
{
public:
mixin(OVERRIDE_DEFAULT_ACCEPT);
- Type type;
- Declarator declarator;
- AliasInitializer[] initializations;
+ /** */Type type;
+ /** */Declarator declarator;
+ /** */AliasInitializer[] initializations;
}
+///
class AliasInitializer : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- Token identifier;
- Type type;
+ /** */Token identifier;
+ /** */Type type;
}
+///
class AliasThisDeclaration : Declaration
{
public:
mixin(OVERRIDE_DEFAULT_ACCEPT);
- Token identifier;
+ /** */Token identifier;
}
+///
class AlignAttribute : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- Token intLiteral;
+ /** */Token intLiteral;
}
+///
class AndAndExpression : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- AndAndExpression left;
- OrExpression right;
+ /** */AndAndExpression left;
+ /** */OrExpression right;
}
+///
class AndExpression : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- AndExpression andExpression;
- ShiftExpression shiftExpression;
+ /** */AndExpression andExpression;
+ /** */ShiftExpression shiftExpression;
}
+///
class ArgumentList : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- AssignExpression[] arguments;
+ /** */AssignExpression[] arguments;
}
+///
class Arguments : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- ArgumentList argumentList;
+ /** */ArgumentList argumentList;
}
+///
class ArrayInitializer : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- ArrayMemberInitializations arrayMemberInitializations;
+ /** */ArrayMemberInitializations arrayMemberInitializations;
}
+///
class ArrayLiteral : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- ArgumentList argumentList;
+ /** */ArgumentList argumentList;
}
+///
class ArrayMemberInitialization : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- AssignExpression assignExpression;
- NonVoidInitializer nonVoidInitializer;
+ /** */AssignExpression assignExpression;
+ /** */NonVoidInitializer nonVoidInitializer;
}
+///
class ArrayMemberInitializations : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- ArrayMemberInitialization[] arrayMemberInitializations;
+ /** */ArrayMemberInitialization[] arrayMemberInitializations;
}
+///
class AsmAddExp : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- Token operator;
- AsmMulExp left;
- AsmMulExp right;
+ /** */Token operator;
+ /** */AsmMulExp left;
+ /** */AsmMulExp right;
}
+///
class AsmAndExp : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- AsmEqualExp left;
- AsmEqualExp right;
+ /** */AsmEqualExp left;
+ /** */AsmEqualExp right;
}
+///
class AsmBrExp : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- AsmBrExp asmBrExp;
- AsmEqualExp asmEqualExp;
- AsmUnaExp asmUnaExp;
+ /** */AsmBrExp asmBrExp;
+ /** */AsmEqualExp asmEqualExp;
+ /** */AsmUnaExp asmUnaExp;
}
+///
class AsmEqualExp : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- AsmRelExp left;
- AsmRelExp right;
- Token operator;
+ /** */AsmRelExp left;
+ /** */AsmRelExp right;
+ /** */Token operator;
}
+///
class AsmExp : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- AsmLogOrExp left;
- AsmExp middle;
- AsmExp right;
+ /** */AsmLogOrExp left;
+ /** */AsmExp middle;
+ /** */AsmExp right;
}
+///
class AsmInstruction : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- Token identifierOrInteger;
- bool hasAlign;
- AsmExp asmExp;
- Opcode opcode;
- Operands operands;
+ /** */Token identifierOrInteger;
+ /** */bool hasAlign;
+ /** */AsmExp asmExp;
+ /** */Opcode opcode;
+ /** */Operands operands;
}
+///
class AsmLogAndExp : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- AsmOrExp left;
- AsmOrExp right;
+ /** */AsmOrExp left;
+ /** */AsmOrExp right;
}
+///
class AsmLogOrExp : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- AsmLogAndExp left;
- AsmLogAndExp right;
+ /** */AsmLogAndExp left;
+ /** */AsmLogAndExp right;
}
+///
class AsmMulExp : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- AsmBrExp left;
- AsmBrExp right;
- Token operator;
+ /** */AsmBrExp left;
+ /** */AsmBrExp right;
+ /** */Token operator;
}
+///
class AsmOrExp : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- AsmXorExp left;
- AsmXorExp right;
+ /** */AsmXorExp left;
+ /** */AsmXorExp right;
}
+///
class AsmPrimaryExp : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- IdentifierChain identifierChain;
- Register register;
- Token token;
+ /** */IdentifierChain identifierChain;
+ /** */Register register;
+ /** */Token token;
}
+///
class AsmRelExp : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- AsmShiftExp left;
- AsmShiftExp right;
- Token operator;
+ /** */AsmShiftExp left;
+ /** */AsmShiftExp right;
+ /** */Token operator;
}
+///
class AsmShiftExp : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- AsmAddExp left;
- AsmAddExp right;
- Token operator;
+ /** */AsmAddExp left;
+ /** */AsmAddExp right;
+ /** */Token operator;
}
+///
class AsmStatement : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- AsmInstruction[] asmInstructions;
+ /** */AsmInstruction[] asmInstructions;
}
+///
class AsmTypePrefix : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- Token left;
- Token right;
+ /** */Token left;
+ /** */Token right;
}
+///
class AsmUnaExp : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- AsmTypePrefix asmTypePrefix;
- AsmExp asmExp;
- Token prefix;
- AsmPrimaryExp asmPrimaryExp;
- AsmUnaExp asmUnaExp;
+ /** */AsmTypePrefix asmTypePrefix;
+ /** */AsmExp asmExp;
+ /** */Token prefix;
+ /** */AsmPrimaryExp asmPrimaryExp;
+ /** */AsmUnaExp asmUnaExp;
}
+///
class AsmXorExp : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- AsmAndExp left;
- AsmAndExp right;
+ /** */AsmAndExp left;
+ /** */AsmAndExp right;
}
+///
class AssertExpression : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- AssignExpression assertion;
- AssignExpression message;
+ /** */AssignExpression assertion;
+ /** */AssignExpression message;
}
+///
class AssertStatement : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- AssertExpression assertExpression;
+ /** */AssertExpression assertExpression;
}
+///
class AssignExpression : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- TernaryExpression ternaryExpression;
- AssignExpression assignExpression;
- Token operator;
+ /** */TernaryExpression ternaryExpression;
+ /** */AssignExpression assignExpression;
+ /** */Token operator;
}
+///
class AssignStatement : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- PreIncDecExpression preIncDecExpression;
- PostIncDecExpression postIncDecExpression;
- UnaryExpression[] unaryExpressions;
- AssignExpression[] assignExpressions;
- Token[] assignOperators;
+ /** */PreIncDecExpression preIncDecExpression;
+ /** */PostIncDecExpression postIncDecExpression;
+ /** */UnaryExpression[] unaryExpressions;
+ /** */AssignExpression[] assignExpressions;
+ /** */Token[] assignOperators;
}
+///
class AssocArrayLiteral : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- KeyValuePairs keyValuePairs;
+ /** */KeyValuePairs keyValuePairs;
}
+///
class AtAttribute : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- FunctionCallExpression functionCallExpression;
- ArgumentList argumentList;
- Token identifier;
+ /** */FunctionCallExpression functionCallExpression;
+ /** */ArgumentList argumentList;
+ /** */Token identifier;
}
+///
class AttributedDeclaration : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- Declaration[] declarations;
+ /** */Attribute attribute;
+ /** */Declaration[] declarations;
}
+///
class Attribute : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- LinkageAttribute linkageAttribute;
- AlignAttribute alignAttribute;
- PragmaExpression pragmaExpression;
- Deprecated deprecated_;
- ProtectionAttribute protectionAttribute;
- AtAttribute atAttribute;
- Token attribute;
+ /** */LinkageAttribute linkageAttribute;
+ /** */AlignAttribute alignAttribute;
+ /** */PragmaExpression pragmaExpression;
+ /** */Deprecated deprecated_;
+ /** */ProtectionAttribute protectionAttribute;
+ /** */AtAttribute atAttribute;
+ /** */Token attribute;
}
+///
class AutoDeclaration : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- StorageClass storageClass;
- Token[] identifiers;
- Initializer[] initializers;
+ /** */StorageClass storageClass;
+ /** */Token[] identifiers;
+ /** */Initializer[] initializers;
}
+///
class BlockStatement : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- DeclarationsAndStatements declarationsAndStatements;
+ /** */DeclarationsAndStatements declarationsAndStatements;
}
+///
class BodyStatement : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- BlockStatement blockStatement;
+ /** */BlockStatement blockStatement;
}
+///
class BreakStatement : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- Token identifier;
- bool hasIdentifier;
+ /** */Token identifier;
+ /** */bool hasIdentifier;
}
+///
class BasicType : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- TokenType type;
+ /** */TokenType type;
}
+///
class CaseRangeStatement : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- AssignExpression low;
- AssignExpression high;
- DeclarationsAndStatements declarationsAndStatements;
+ /** */AssignExpression low;
+ /** */AssignExpression high;
+ /** */DeclarationsAndStatements declarationsAndStatements;
}
+///
class CaseStatement: ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- ArgumentList argumentList;
- DeclarationsAndStatements declarationsAndStatements;
+ /** */ArgumentList argumentList;
+ /** */DeclarationsAndStatements declarationsAndStatements;
}
+///
class CastExpression: ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- Type type;
- CastQualifier castQualifier;
+ /** */Type type;
+ /** */CastQualifier castQualifier;
+ /** */UnaryExpression unaryExpression;
}
+///
class CastQualifier: ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- TokenType first;
- TokenType second;
- bool hasSecond;
+ /** */TokenType first;
+ /** */TokenType second;
+ /** */bool hasSecond;
}
+///
class Catches: ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- Catch[] catches;
- LastCatch lastCatch;
+ /** */Catch[] catches;
+ /** */LastCatch lastCatch;
}
+///
class Catch: ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- Type type;
- Token identifier;
- NonEmptyStatementNoCaseNoDefault nonEmptyStatementNoCaseNoDefault;
+ /** */Type type;
+ /** */Token identifier;
+ /** */NonEmptyStatementNoCaseNoDefault nonEmptyStatementNoCaseNoDefault;
}
+///
class ClassBody: ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- DeclarationOrInvariant[] declarationOrInvariants;
+ /** */DeclarationOrInvariant[] declarationOrInvariants;
}
+///
class ClassDeclaration: ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- Token name;
- TemplateParameters templateParameters;
- Constraint constraint;
- IdentifierList superClasses;
- ClassBody classBody;
+ /** */Token name;
+ /** */TemplateParameters templateParameters;
+ /** */Constraint constraint;
+ /** */IdentifierList superClasses;
+ /** */ClassBody classBody;
}
+///
class CmpExpression : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- ShiftExpression shiftExpression;
- EqualExpression equalExpression;
- IdentityExpression identityExpression;
- RelExpression relExpression;
- InExpression inExpression;
+ /** */ShiftExpression shiftExpression;
+ /** */EqualExpression equalExpression;
+ /** */IdentityExpression identityExpression;
+ /** */RelExpression relExpression;
+ /** */InExpression inExpression;
}
+///
class CompileCondition : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- VersionCondition versionCondition;
- DebugCondition debugCondition;
- StaticIfCondition staticIfCondition;
+ /** */VersionCondition versionCondition;
+ /** */DebugCondition debugCondition;
+ /** */StaticIfCondition staticIfCondition;
}
+///
class ConditionalDeclaration : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- CompileCondition compileCondition;
- Declaration[] trueDeclarations;
- Declaration[] falseDeclarations;
+ /** */CompileCondition compileCondition;
+ /** */Declaration[] trueDeclarations;
+ /** */Declaration[] falseDeclarations;
}
+///
class ConditionalStatement : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- CompileCondition compileCondition;
- NonEmptyStatementNoCaseNoDefault trueStatement;
- NonEmptyStatementNoCaseNoDefault falseStatement;
+ /** */CompileCondition compileCondition;
+ /** */NonEmptyStatementNoCaseNoDefault trueStatement;
+ /** */NonEmptyStatementNoCaseNoDefault falseStatement;
}
+///
class Constraint : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- Expression expression;
+ /** */Expression expression;
}
+///
class Constructor : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- Parameters parameters;
- FunctionBody functionBody;
+ /** */Parameters parameters;
+ /** */FunctionBody functionBody;
}
+///
class ContinueStatement : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- bool hasIdentifier;
- Token identifier;
+ /** */ bool hasIdentifier;
+ /** */ Token identifier;
}
+///
class DebugCondition : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- Token identifierOrInteger;
- bool hasIdentifierOrInteger;
+ /** */ Token identifierOrInteger;
+ /** */ bool hasIdentifierOrInteger;
}
+///
class DebugSpecification : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- Token identifierOrInteger;
+ /** */ Token identifierOrInteger;
}
+///
class Declaration : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- AttributedDeclaration attributedDeclaration;
- ImportDeclaration importDeclaration;
- FunctionDeclaration functionDeclaration;
- VariableDeclaration variableDeclaration;
- AliasThisDeclaration aliasThisDeclaration;
- StructDeclaration structDeclaration;
- ClassDeclaration classDeclaration;
- InterfaceDeclaration interfaceDeclaration;
- UnionDeclaration unionDeclaration;
- EnumDeclaration enumDeclaration;
- AliasDeclaration aliasDeclaration;
- MixinDeclaration mixinDeclaration;
- Unittest unittest_;
- StaticAssertDeclaration staticAssertDeclaration;
- TemplateDeclaration templateDeclaration;
- Constructor constructor;
- Destructor destructor;
- StaticConstructor staticConstructor;
- StaticDestructor staticDestructor;
- SharedStaticDestructor sharedStaticDestructor;
- SharedStaticConstructor sharedStaticConstructor;
- ConditionalDeclaration conditionalDeclaration;
- PragmaDeclaration pragmaDeclaration;
+ /** */ AttributedDeclaration attributedDeclaration;
+ /** */ ImportDeclaration importDeclaration;
+ /** */ FunctionDeclaration functionDeclaration;
+ /** */ VariableDeclaration variableDeclaration;
+ /** */ AliasThisDeclaration aliasThisDeclaration;
+ /** */ StructDeclaration structDeclaration;
+ /** */ ClassDeclaration ///
+classDeclaration;
+ /** */ InterfaceDeclaration interfaceDeclaration;
+ /** */ UnionDeclaration unionDeclaration;
+ /** */ EnumDeclaration enumDeclaration;
+ /** */ AliasDeclaration aliasDeclaration;
+ /** */ MixinDeclaration mixinDeclaration;
+ /** */ Unittest unittest_;
+ /** */ StaticAssertDeclaration staticAssertDeclaration;
+ /** */ TemplateDeclaration templateDeclaration;
+ /** */ Constructor constructor;
+ /** */ Destructor destructor;
+ /** */ StaticConstructor staticConstructor;
+ /** */ StaticDestructor staticDestructor;
+ /** */ SharedStaticDestructor sharedStaticDestructor;
+ /** */ SharedStaticConstructor sharedStaticConstructor;
+ /** */ ConditionalDeclaration conditionalDeclaration;
+ /** */ PragmaDeclaration pragmaDeclaration;
}
+///
class DeclarationsAndStatements : ASTNode
{
mixin(DEFAULT_ACCEPT);
- ASTNode[] declarationsAndStatements;
+ /** */ ASTNode[] declarationsAndStatements;
}
+///
class DeclarationOrInvariant : ASTNode
{
mixin(DEFAULT_ACCEPT);
@@ -791,91 +863,103 @@ class DeclarationOrInvariant : ASTNode
Invariant invariant_;
}
+///
class Declarator : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- Token identifier;
- DeclaratorSuffix declaratorSuffix;
- Initializer initializer;
+ /** */ Token identifier;
+ /** */ DeclaratorSuffix declaratorSuffix;
+ /** */ Initializer initializer;
}
+///
class DeclaratorSuffix : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- Type type;
- AssignExpression assignExpression;
+ /** */ Type type;
+ /** */ AssignExpression assignExpression;
}
+///
class DefaultStatement : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- DeclarationsAndStatements declarationsAndStatements;
+ /** */ DeclarationsAndStatements declarationsAndStatements;
}
+///
class DeleteExpression : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- UnaryExpression unaryExpression;
+ /** */ UnaryExpression unaryExpression;
}
+///
class DeleteStatement : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- DeleteExpression deleteExpression;
+ /** */ DeleteExpression deleteExpression;
}
+///
class Deprecated : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- AssignExpression assignExpression;
+ /** */ AssignExpression assignExpression;
}
+///
class Destructor : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- FunctionBody functionBody;
+ /** */ FunctionBody functionBody;
}
+///
class DoStatement : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- BlockStatement blockStatement;
- Expression expression;
+ /** */ BlockStatement blockStatement;
+ /** */ Expression expression;
}
+///
class EnumBody : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- EnumMember[] enumMembers;
+ /** */ EnumMember[] enumMembers;
}
+///
class EnumDeclaration : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- Token identifier;
- Type type;
- EnumBody enumBody;
+ /** */ Token identifier;
+ /** */ Type type;
+ /** */ EnumBody enumBody;
}
+///
class EnumMember : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- Token identifier;
- Type type;
- AssignExpression assignExpression;
+ /** */ Token identifier;
+ /** */ Type type;
+ /** */ AssignExpression assignExpression;
}
+///
class EqualExpression : ASTNode
{
public:
@@ -883,169 +967,189 @@ public:
mixin(SHIFT_SHIFT_BODY);
}
+///
class Expression : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- AssignExpression[] assignExpressions;
+ /** */ AssignExpression[] assignExpressions;
}
+///
class FinalSwitchStatement : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- SwitchStatement switchStatement;
+ /** */ SwitchStatement switchStatement;
}
+///
class Finally : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- NonEmptyStatementNoCaseNoDefault nonEmptyStatementNoCaseNoDefault;
+ /** */ NonEmptyStatementNoCaseNoDefault nonEmptyStatementNoCaseNoDefault;
}
+///
class ForStatement : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- Declaration initializationDeclaration;
- Statement initializationStatement;
- Expression test;
- Expression increment;
- NonEmptyStatementNoCaseNoDefault nonEmptyStatementNoCaseNoDefault;
+ /** */ Declaration initializationDeclaration;
+ /** */ Statement initializationStatement;
+ /** */ Expression test;
+ /** */ Expression increment;
+ /** */ NonEmptyStatementNoCaseNoDefault nonEmptyStatementNoCaseNoDefault;
}
+///
class ForeachRangeStatement : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- ForeachType foreachType;
- Expression lower;
- Expression higher;
- NonEmptyStatementNoCaseNoDefault nonEmptyStatementNoCaseNoDefault;
+ /** */ ForeachType foreachType;
+ /** */ Expression lower;
+ /** */ Expression higher;
+ /** */ NonEmptyStatementNoCaseNoDefault nonEmptyStatementNoCaseNoDefault;
}
+///
class ForeachStatement : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- Token foreachType;
- ForeachTypeList foreachTypeList;
- Expression expression;
- NonEmptyStatementNoCaseNoDefault nonEmptyStatementNoCaseNoDefault;
+ /** */ Token foreachType;
+ /** */ ForeachTypeList foreachTypeList;
+ /** */ Expression expression;
+ /** */ NonEmptyStatementNoCaseNoDefault nonEmptyStatementNoCaseNoDefault;
}
+///
class ForeachType : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- bool isRef;
- Type type;
- Token identifier;
+ /** */ bool isRef;
+ /** */ Type type;
+ /** */ Token identifier;
}
+///
class ForeachTypeList : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- ForeachType[] foreachTypes;
+ /** */ ForeachType[] foreachTypes;
}
+///
class FunctionAttribute : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- Token pureOrNothrow;
- AtAttribute atAttribute;
+ /** */ Token pureOrNothrow;
+ /** */ AtAttribute atAttribute;
}
+///
class FunctionBody : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- BlockStatement blockStatement;
- BodyStatement bodyStatement;
- OutStatement outStatement;
- InStatement inStatement;
+ /** */ BlockStatement blockStatement;
+ /** */ BodyStatement bodyStatement;
+ /** */ OutStatement outStatement;
+ /** */ InStatement inStatement;
}
+///
class FunctionCallExpression : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- UnaryExpression unaryExpression;
- TemplateArguments templateArguments;
- Arguments arguments;
+ /** */ UnaryExpression unaryExpression;
+ /** */ TemplateArguments templateArguments;
+ /** */ Arguments arguments;
}
+///
class FunctionCallStatement : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- FunctionCallExpression functionCallExpression;
+ /** */ FunctionCallExpression functionCallExpression;
}
+///
class FunctionDeclaration : Declaration
{
public:
mixin(OVERRIDE_DEFAULT_ACCEPT);
- Type returnType;
- Token name;
- TemplateParameters templateParameters;
- Parameters parameters;
- Constraint constraint;
- FunctionBody functionBody;
+ /** */ Type returnType;
+ /** */ Token name;
+ /** */ TemplateParameters templateParameters;
+ /** */ Parameters parameters;
+ /** */ Constraint constraint;
+ /** */ FunctionBody functionBody;
}
+///
class FunctionLiteralExpression : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- Token functionOrDelegate;
- Type type;
- Parameters parameters;
- FunctionAttribute[] functionAttributes;
- FunctionBody functionBody;
+ /** */ Token functionOrDelegate;
+ /** */ Type type;
+ /** */ Parameters parameters;
+ /** */ FunctionAttribute[] functionAttributes;
+ /** */ FunctionBody functionBody;
}
+///
class GotoStatement : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- Expression expression;
- Token identifier;
- bool isDefault;
+ /** */ Expression expression;
+ /** */ Token identifier;
+ /** */ bool isDefault;
}
+///
class IdentifierChain : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- Token[] identifiers;
+ /** */ Token[] identifiers;
}
+///
class IdentifierList : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- Token[] identifiers;
+ /** */ Token[] identifiers;
}
+///
class IdentifierOrTemplateChain : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- IdentifierOrTemplateInstance[] identifiers;
+ /** */ IdentifierOrTemplateInstance[] identifiers;
}
+///
class IdentifierOrTemplateInstance : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- Token identifier;
- TemplateInstance templateInstance;
+ /** */ Token identifier;
+ /** */ TemplateInstance templateInstance;
}
+///
class IdentityExpression : ASTNode
{
public:
@@ -1053,55 +1157,71 @@ public:
mixin(SHIFT_SHIFT_BODY);
}
+///
class IfStatement : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- Expression expression;
- NonEmptyStatementNoCaseNoDefault thenStatement;
- NonEmptyStatementNoCaseNoDefault elseStatement;
+ /** */ Expression expression;
+ /** */ NonEmptyStatementNoCaseNoDefault thenStatement;
+ /** */ NonEmptyStatementNoCaseNoDefault elseStatement;
}
+///
class ImportBind : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- Token left;
- Token right;
+ /** */ Token left;
+ /** */ Token right;
}
+///
class ImportBindings : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- SingleImport bind;
- ImportBind[] ImportBinds;
+ /** */ SingleImport bind;
+ /** */ ImportBind[] ImportBinds;
}
+///
class ImportDeclaration : Declaration
{
public:
mixin(OVERRIDE_DEFAULT_ACCEPT);
- bool isStatic;
- ImportList importList;
+ /** */ bool isStatic;
+ /** */ ImportList importList;
}
+///
class ImportExpression : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- AssignExpression assignExpression;
+ /** */ AssignExpression assignExpression;
}
+///
class ImportList : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- SingleImport singleImport;
- ImportList next;
- ImportBindings bindings;
+ /** */ SingleImport singleImport;
+ /** */ ImportList next;
+ /** */ ImportBindings bindings;
}
+///
+class IndexExpression : ASTNode
+{
+public:
+ mixin(DEFAULT_ACCEPT);
+ /** */ UnaryExpression unaryExpression;
+ /** */ ArgumentList argumentList;
+}
+
+///
class InExpression : ASTNode
{
public:
@@ -1109,353 +1229,393 @@ public:
mixin(SHIFT_SHIFT_BODY);
}
+///
class InStatement : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- BlockStatement blockStatement;
+ /** */ BlockStatement blockStatement;
}
+///
class Initialize : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- NonEmptyStatementNoCaseNoDefault nonEmptyStatementNoCaseNoDefault;
+ /** */ NonEmptyStatementNoCaseNoDefault nonEmptyStatementNoCaseNoDefault;
}
+///
class Initializer : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- NonVoidInitializer nonVoidInitializer;
+ /** */ NonVoidInitializer nonVoidInitializer;
}
+///
class InterfaceDeclaration : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- Token identifier;
- TemplateParameters templateParameters;
- Constraint constraint;
- IdentifierList identifierList;
- StructBody structBody;
+ /** */ Token identifier;
+ /** */ TemplateParameters templateParameters;
+ /** */ Constraint constraint;
+ /** */ IdentifierList identifierList;
+ /** */ StructBody structBody;
}
+///
class Invariant : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- BlockStatement blockStatement;
+ /** */ BlockStatement blockStatement;
}
+///
class IsExpression : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- Type type;
- AssignExpression assignExpression;
- Token identifier;
- TypeSpecialization typeSpecialization;
- TemplateParameterList templateParameterList;
- Token equalsOrColon;
+ /** */ Type type;
+ /** */ AssignExpression assignExpression;
+ /** */ Token identifier;
+ /** */ TypeSpecialization typeSpecialization;
+ /** */ TemplateParameterList templateParameterList;
+ /** */ Token equalsOrColon;
}
+///
class KeyValuePair : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- KeyValuePair[] keyValuePairs;
+ /** */ KeyValuePair[] keyValuePairs;
}
+///
class KeyValuePairs : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- AssignExpression key;
- AssignExpression value;
+ /** */ AssignExpression key;
+ /** */ AssignExpression value;
}
+///
class LabeledStatement : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
Token identifier;
- Statement statement;
+ /** */ Statement statement;
}
+///
class LambdaExpression : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- Token identifier;
- Parameters paramaters;
- FunctionAttribute[] functionAttributes;
- AssignExpression assignExpression;
+ /** */ Token identifier;
+ /** */ Parameters paramaters;
+ /** */ FunctionAttribute[] functionAttributes;
+ /** */ AssignExpression assignExpression;
}
+///
class LastCatch : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- NonEmptyStatementNoCaseNoDefault nonEmptyStatementNoCaseNoDefault;
+ /** */ NonEmptyStatementNoCaseNoDefault nonEmptyStatementNoCaseNoDefault;
}
+///
class LinkageAttribute : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- Token identifier;
- bool hasPlusPlus;
+ /** */ Token identifier;
+ /** */ bool hasPlusPlus;
}
+///
class MemberFunctionAttribute : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- Token token;
- FunctionAttribute functionAttribute;
+ /** */ Token token;
+ /** */ FunctionAttribute functionAttribute;
}
+///
class MixinDeclaration : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- MixinExpression mixinExpression;
+ /** */ MixinExpression mixinExpression;
}
+///
class MixinExpression : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- AssignExpression assignExpression;
+ /** */ AssignExpression assignExpression;
}
+///
class MixinTemplateName : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- bool hasDot;
- IdentifierOrTemplateChain identifierOrTemplateChain;
- TypeofExpression typeofExpression;
+ /** */ bool hasDot;
+ /** */ IdentifierOrTemplateChain identifierOrTemplateChain;
+ /** */ TypeofExpression typeofExpression;
}
+///
class Module : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- ModuleDeclaration moduleDeclaration;
- Declaration[] declarations;
+ /** */ ModuleDeclaration moduleDeclaration;
+ /** */ Declaration[] declarations;
}
+///
class ModuleDeclaration : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- IdentifierChain moduleName;
+ /** */ IdentifierChain moduleName;
}
+///
class MulExpression : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- Token operator;
- UnaryExpression left;
- UnaryExpression right;
+ /** */ Token operator;
+ /** */ UnaryExpression left;
+ /** */ UnaryExpression right;
}
+///
class NewAnonClassExpression : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- Arguments allocatorArguments;
- Arguments constructorArguments;
- IdentifierList identifierList;
- ClassBody classBody;
+ /** */ Arguments allocatorArguments;
+ /** */ Arguments constructorArguments;
+ /** */ IdentifierList identifierList;
+ /** */ ClassBody ///
+classBody;
}
+///
class NewExpression : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- Type type;
- NewAnonClassExpression newAnonClassExpression;
- Arguments arguments;
- AssignExpression assignExpression;
+ /** */ Type type;
+ /** */ NewAnonClassExpression newAnonClassExpression;
+ /** */ Arguments arguments;
+ /** */ AssignExpression assignExpression;
}
+///
class NonEmptyStatement : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- NonEmptyStatementNoCaseNoDefault nonEmptyStatementNoCaseNoDefault;
- CaseStatement caseStatement;
- CaseRangeStatement caseRangeStatement;
- DefaultStatement defaultStatement;
+ /** */ NonEmptyStatementNoCaseNoDefault nonEmptyStatementNoCaseNoDefault;
+ /** */ CaseStatement caseStatement;
+ /** */ CaseRangeStatement caseRangeStatement;
+ /** */ DefaultStatement defaultStatement;
}
+///
class NonEmptyStatementNoCaseNoDefault : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- LabeledStatement labeledStatement;
- BlockStatement blockStatement;
- AssignStatement assignStatement;
- IfStatement ifStatement;
- WhileStatement whileStatement;
- DoStatement doStatement;
- ForStatement forStatement;
- ForeachStatement foreachStatement;
- SwitchStatement switchStatement;
- FinalSwitchStatement finalSwitchStatement;
- ContinueStatement continueStatement;
- BreakStatement breakStatement;
- ReturnStatement returnStatement;
- GotoStatement gotoStatement;
- WithStatement withStatement;
- SynchronizedStatement synchronizedStatement;
- TryStatement tryStatement;
- ThrowStatement throwStatement;
- ScopeGuardStatement scopeGuardStatement;
- AsmStatement asmStatement;
- ForeachRangeStatement foreachRangeStatement;
- ConditionalStatement conditionalStatement;
- StaticAssertStatement staticAssertStatement;
- AssertStatement assertStatement;
- TemplateMixinStatement templateMixinStatement;
- VersionSpecification versionSpecification;
- DebugSpecification debugSpecification;
- FunctionCallStatement functionCallStatement;
- DeleteStatement deleteStatement;
+ /** */ LabeledStatement labeledStatement;
+ /** */ BlockStatement blockStatement;
+ /** */ AssignStatement assignStatement;
+ /** */ IfStatement ifStatement;
+ /** */ WhileStatement whileStatement;
+ /** */ DoStatement doStatement;
+ /** */ ForStatement forStatement;
+ /** */ ForeachStatement foreachStatement;
+ /** */ SwitchStatement switchStatement;
+ /** */ FinalSwitchStatement finalSwitchStatement;
+ /** */ ContinueStatement continueStatement;
+ /** */ BreakStatement breakStatement;
+ /** */ ReturnStatement returnStatement;
+ /** */ GotoStatement gotoStatement;
+ /** */ WithStatement withStatement;
+ /** */ SynchronizedStatement synchronizedStatement;
+ /** */ TryStatement tryStatement;
+ /** */ ThrowStatement throwStatement;
+ /** */ ScopeGuardStatement scopeGuardStatement;
+ /** */ AsmStatement asmStatement;
+ /** */ ForeachRangeStatement foreachRangeStatement;
+ /** */ ConditionalStatement conditionalStatement;
+ /** */ StaticAssertStatement staticAssertStatement;
+ /** */ AssertStatement assertStatement;
+ /** */ TemplateMixinStatement templateMixinStatement;
+ /** */ VersionSpecification versionSpecification;
+ /** */ DebugSpecification debugSpecification;
+ /** */ FunctionCallStatement functionCallStatement;
+ /** */ DeleteStatement deleteStatement;
}
+///
class NonVoidInitializer : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- AssignExpression assignExpression;
- ArrayInitializer arrayInitializer;
- StructInitializer structInitializer;
+ /** */ AssignExpression assignExpression;
+ /** */ ArrayInitializer arrayInitializer;
+ /** */ StructInitializer structInitializer;
}
+///
class Opcode : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- Token identifier;
+ /** */ Token identifier;
}
+///
class Operand : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- AsmExp asmExp;
+ /** */ AsmExp asmExp;
}
+///
class Operands : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- Operand[] operands;
+ /** */ Operand[] operands;
}
+///
class OrExpression : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- XorExpression xorExpression;
- OrExpression orExpression;
+ /** */ XorExpression xorExpression;
+ /** */ OrExpression orExpression;
}
+///
class OrOrExpression : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- OrOrExpression orOrExpression;
- AndAndExpression andAndExpression;
+ /** */ OrOrExpression orOrExpression;
+ /** */ AndAndExpression andAndExpression;
}
+///
class OutStatement : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- Token parameter;
- BlockStatement blockStatement;
+ /** */ Token parameter;
+ /** */ BlockStatement blockStatement;
}
+///
class Parameter : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- ParameterAttribute[] paramaterAttributes;
- Type type;
- Token name;
- bool vararg;
+ /** */ ParameterAttribute[] paramaterAttributes;
+ /** */ Type type;
+ /** */ Token name;
+ /** */ bool vararg;
}
+///
class ParameterAttribute: ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- Token attribute;
- TypeConstructor typeConstructor;
+ /** */ Token attribute;
+ /** */ TypeConstructor typeConstructor;
}
+///
class Parameters : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- Parameter[] paramaters;
- bool hasVarargs;
+ /** */ Parameter[] paramaters;
+ /** */ bool hasVarargs;
}
+///
class PostIncDecExpression : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- Token operator;
- UnaryExpression unaryExpression;
+ /** */ Token operator;
+ /** */ UnaryExpression unaryExpression;
}
+///
class PowExpression : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- UnaryExpression unaryExpression;
- PowExpression powExpression;
+ /** */ UnaryExpression unaryExpression;
+ /** */ PowExpression powExpression;
}
+///
class PragmaDeclaration : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- PragmaExpression pragmaExpression;
+ /** */ PragmaExpression pragmaExpression;
}
+///
class PragmaExpression : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- Token identifier;
- ArgumentList argumentList;
+ /** */ Token identifier;
+ /** */ ArgumentList argumentList;
}
+///
class PreIncDecExpression : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- Token operator;
- UnaryExpression unaryExpression;
+ /** */ Token operator;
+ /** */ UnaryExpression unaryExpression;
}
+///
class PrimaryExpression : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- Token primary;
- bool hasDot;
+ /** */ Token primary;
+ /** */ bool hasDot;
IdentifierOrTemplateInstance identifierOrTemplateInstance;
Type type;
TypeofExpression typeofExpression;
@@ -1471,22 +1631,25 @@ public:
ImportExpression importExpression;
}
+///
class ProtectionAttribute : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- Token attribute;
+ /** */ Token attribute;
}
+///
class Register : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- Token identifier;
- Token integerLiteral;
- bool hasIntegerLiteral;
+ /** */ Token identifier;
+ /** */ Token integerLiteral;
+ /** */ bool hasIntegerLiteral;
}
+///
class RelExpression : ASTNode
{
public:
@@ -1494,520 +1657,591 @@ public:
mixin(SHIFT_SHIFT_BODY);
}
+///
class ReturnStatement : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- Expression expression;
+ /** */ Expression expression;
}
+///
class ScopeGuardStatement : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- Token identifier;
- NonEmptyStatementNoCaseNoDefault nonEmptyStatementNoCaseNoDefault;
+ /** */ Token identifier;
+ /** */ NonEmptyStatementNoCaseNoDefault nonEmptyStatementNoCaseNoDefault;
}
+///
class SharedStaticConstructor : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- FunctionBody functionBody;
+ /** */ FunctionBody functionBody;
}
+///
class SharedStaticDestructor : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- FunctionBody functionBody;
+ /** */ FunctionBody functionBody;
}
+///
class ShiftExpression : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- AddExpression addExpression;
- ShiftExpression shiftExpression;
- Token operator;
+ /** */ AddExpression addExpression;
+ /** */ ShiftExpression shiftExpression;
+ /** */ Token operator;
}
+///
class SingleImport : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- Token rename;
- IdentifierChain import_;
+ /** */ Token rename;
+ /** */ IdentifierChain import_;
}
+///
+class SliceExpression : ASTNode
+{
+public:
+ mixin(DEFAULT_ACCEPT);
+ /** */ AssignExpression lower;
+ /** */ AssignExpression upper;
+}
+
+///
class Statement : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- NonEmptyStatement nonEmptyStatement;
+ /** */ NonEmptyStatement nonEmptyStatement;
}
+///
class StatementNoCaseNoDefault : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- NonEmptyStatementNoCaseNoDefault nonEmptyStatementNoCaseNoDefault;
+ /** */ NonEmptyStatementNoCaseNoDefault nonEmptyStatementNoCaseNoDefault;
}
+///
class StaticAssertDeclaration : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- StaticAssertStatement staticAssertStatement;
+ /** */ StaticAssertStatement staticAssertStatement;
}
+///
class StaticAssertStatement : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- AssertStatement assertStatement;
+ /** */ AssertStatement assertStatement;
}
+///
class StaticConstructor : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- FunctionBody functionBody;
+ /** */ FunctionBody functionBody;
}
+///
class StaticDestructor : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- FunctionBody functionBody;
+ /** */ FunctionBody functionBody;
}
+///
class StaticIfCondition : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- AssignExpression assignExpression;
+ /** */ AssignExpression assignExpression;
}
+///
class StorageClass : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- AtAttribute atAttribute;
- TypeConstructor typeConstructor;
- Token storageClass;
+ /** */ AtAttribute atAttribute;
+ /** */ TypeConstructor typeConstructor;
+ /** */ Token storageClass;
}
+///
class StructBody : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- Declaration[] declarations;
+ /** */ Declaration[] declarations;
}
+///
class StructDeclaration : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- Token identifier;
- TemplateParameters templateParameters;
- Constraint constraint;
- StructBody structBody;
+ /** */ Token identifier;
+ /** */ TemplateParameters templateParameters;
+ /** */ Constraint constraint;
+ /** */ StructBody structBody;
}
+///
class StructInitializer : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- StructMemberInitializers structMemberInitializers;
+ /** */ StructMemberInitializers structMemberInitializers;
}
+///
class StructMemberInitializer : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- Token identifier;
- bool hasIdentifier;
- NonVoidInitializer nonVoidInitializer;
+ /** */ Token identifier;
+ /** */ bool hasIdentifier;
+ /** */ NonVoidInitializer nonVoidInitializer;
}
+///
class StructMemberInitializers : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- StructMemberInitializer[] structMemberInitializers;
+ /** */ StructMemberInitializer[] structMemberInitializers;
}
+///
class SwitchBody : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- Statement[] statements;
+ /** */ Statement[] statements;
}
+///
class SwitchStatement : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- Expression expression;
- SwitchBody switchBody;
+ /** */ Expression expression;
+ /** */ SwitchBody switchBody;
}
+///
class Symbol : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- IdentifierOrTemplateChain identifierOrTemplateChain;
- bool hasDot;
+ /** */ IdentifierOrTemplateChain identifierOrTemplateChain;
+ /** */ bool hasDot;
}
+///
class SynchronizedStatement : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- Expression expression;
- NonEmptyStatementNoCaseNoDefault nonEmptyStatementNoCaseNoDefault;
+ /** */ Expression expression;
+ /** */ NonEmptyStatementNoCaseNoDefault nonEmptyStatementNoCaseNoDefault;
}
+///
class TemplateAliasParameter : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- Type type;
- Token identifier;
- Type colonType;
- Expression colonExpression;
- Type assignType;
- Expression assignExpression;
+ /** */ Type type;
+ /** */ Token identifier;
+ /** */ Type colonType;
+ /** */ Expression colonExpression;
+ /** */ Type assignType;
+ /** */ Expression assignExpression;
}
+///
class TemplateArgument : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- Type type;
- AssignExpression assignExpression;
- Symbol symbol;
+ /** */ Type type;
+ /** */ AssignExpression assignExpression;
+ /** */ Symbol symbol;
}
+///
class TemplateArgumentList : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- TemplateArgument[] templateArguments;
+ /** */ TemplateArgument[] templateArguments;
}
+///
class TemplateArguments : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- TemplateArgumentList templateArgumentList;
- TemplateSingleArgument templateSingleArgument;
+ /** */ TemplateArgumentList templateArgumentList;
+ /** */ TemplateSingleArgument templateSingleArgument;
}
+///
class TemplateDeclaration : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- Token identifier;
- TemplateParameters templateParameters;
- Constraint constraint;
- Declaration[] declarations;
+ /** */ Token identifier;
+ /** */ TemplateParameters templateParameters;
+ /** */ Constraint constraint;
+ /** */ Declaration[] declarations;
}
+///
class TemplateInstance : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- Token identifier;
- TemplateArguments templateArguments;
+ /** */ Token identifier;
+ /** */ TemplateArguments templateArguments;
}
+///
class TemplateMixinStatement : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- Token identifier;
- TemplateArguments templateArguments;
- MixinTemplateName mixinTemplateName;
+ /** */ Token identifier;
+ /** */ TemplateArguments templateArguments;
+ /** */ MixinTemplateName mixinTemplateName;
}
+///
class TemplateParameter : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- TemplateTypeParameter templateTypeParameter;
- TemplateValueParameter templateValueParameter;
- TemplateAliasParameter templateAliasParameter;
- TemplateTupleParameter templateTupleParameter;
- TemplateThisParameter templateThisParameter;
+ /** */ TemplateTypeParameter templateTypeParameter;
+ /** */ TemplateValueParameter templateValueParameter;
+ /** */ TemplateAliasParameter templateAliasParameter;
+ /** */ TemplateTupleParameter templateTupleParameter;
+ /** */ TemplateThisParameter templateThisParameter;
}
+///
class TemplateParameterList : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- TemplateParameter[] templateParameters;
+ /** */ TemplateParameter[] templateParameters;
}
+///
class TemplateParameters : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- TemplateParameterList templateParameterList;
+ /** */ TemplateParameterList templateParameterList;
}
+///
class TemplateSingleArgument : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- Token token;
- BasicType builtinType;
+ /** */ Token token;
+ /** */ BasicType builtinType;
}
+///
class TemplateThisParameter : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- TemplateTypeParameter templateTypeParameter;
+ /** */ TemplateTypeParameter templateTypeParameter;
}
+///
class TemplateTupleParameter : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- Token identifier;
+ /** */ Token identifier;
}
+///
class TemplateTypeParameter : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- Token identifier;
- Type colonType;
- Type assignType;
+ /** */ Token identifier;
+ /** */ Type colonType;
+ /** */ Type assignType;
}
+///
class TemplateValueParameter : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- Type type;
- Token identifier;
- Expression expression;
- TemplateValueParameterDefault templateValueParameterDefault;
+ /** */ Type type;
+ /** */ Token identifier;
+ /** */ Expression expression;
+ /** */ TemplateValueParameterDefault templateValueParameterDefault;
}
+///
class TemplateValueParameterDefault : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- AssignExpression assignExpression;
- Token token;
+ /** */ AssignExpression assignExpression;
+ /** */ Token token;
}
+///
class TernaryExpression : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- OrOrExpression orOrExpression;
- Expression expression;
- TernaryExpression ternaryExpression;
+ /** */ OrOrExpression orOrExpression;
+ /** */ Expression expression;
+ /** */ TernaryExpression ternaryExpression;
}
+///
class ThrowStatement : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- Expression expression;
+ /** */ Expression expression;
}
+///
class TraitsArgument : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- AssignExpression assignExpression;
- Type type;
+ /** */ AssignExpression assignExpression;
+ /** */ Type type;
}
+///
class TraitsExpression : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- Token identifier;
- TraitsArgument[] traitsArguments;
+ /** */ Token identifier;
+ /** */ TraitsArgument[] traitsArguments;
}
+///
class TryStatement : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- NonEmptyStatementNoCaseNoDefault nonEmptyStatementNoCaseNoDefault;
- Catches catches;
- Finally finally_;
+ /** */ NonEmptyStatementNoCaseNoDefault nonEmptyStatementNoCaseNoDefault;
+ /** */ Catches catches;
+ /** */ Finally finally_;
}
+///
class Type : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- TypeConstructors typeConstructors;
- Type2 type2;
+ /** */ TypeConstructors typeConstructors;
+ /** */ Type2 type2;
}
+///
class Type2 : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- Type2 type2;
- Type3 type3;
- TypeSuffix typeSuffix;
+ /** */ Type2 type2;
+ /** */ Type3 type3;
+ /** */ TypeSuffix typeSuffix;
}
+///
class Type3 : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- BasicType builtinType;
- Symbol symbol;
- TypeofExpression typeofExpression;
- IdentifierOrTemplateChain identifierOrTemplateChain;
- TypeConstructor typeConstructor;
- Type type;
+ /** */ BasicType builtinType;
+ /** */ Symbol symbol;
+ /** */ TypeofExpression typeofExpression;
+ /** */ IdentifierOrTemplateChain identifierOrTemplateChain;
+ /** */ TypeConstructor typeConstructor;
+ /** */ Type type;
}
+///
class TypeConstructor : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- Token typeConstructor;
+ /** */ Token typeConstructor;
}
+///
class TypeConstructors : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- TypeConstructor[] typeConstructors;
+ /** */ TypeConstructor[] typeConstructors;
}
+///
class TypeSpecialization : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- Token token;
- Type type;
+ /** */ Token token;
+ /** */ Type type;
}
+///
class TypeSuffix : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- Token delegateOrFunction;
- bool star;
- Type type;
- AssignExpression assignExpression;
- MemberFunctionAttribute[] memberFunctionAttributes;
+ /** */ Token delegateOrFunction;
+ /** */ bool star;
+ /** */ Type type;
+ /** */ AssignExpression assignExpression;
+ /** */ MemberFunctionAttribute[] memberFunctionAttributes;
}
+///
class TypeidExpression : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- Type type;
- Expression expression;
+ /** */ Type type;
+ /** */ Expression expression;
}
+///
class TypeofExpression : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- Expression expression;
- Token return_;
+ /** */ Expression expression;
+ /** */ Token return_;
}
+///
class UnaryExpression : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- PrimaryExpression primaryExpression;
- UnaryExpression unaryExpression;
- Token prefix;
- PreIncDecExpression preIncDecExpression;
- PostIncDecExpression postIncDecExpression;
- NewExpression newExpression;
- DeleteExpression deleteExpression;
- CastExpression castExpression;
- FunctionCallExpression functionCallExpression;
- ArgumentList argumentList;
- AssignExpression low;
- AssignExpression high;
- IdentifierOrTemplateInstance identifierOrTemplateInstance;
- AssertExpression assertExpression;
+ /** */ PrimaryExpression primaryExpression;
+ /** */ UnaryExpression unaryExpression;
+ /** */ Token prefix;
+ /** */ PreIncDecExpression preIncDecExpression;
+ /** */ PostIncDecExpression postIncDecExpression;
+ /** */ NewExpression newExpression;
+ /** */ DeleteExpression deleteExpression;
+ /** */ CastExpression castExpression;
+ /** */ FunctionCallExpression functionCallExpression;
+ /** */ ArgumentList argumentList;
+ /** */ AssignExpression low;
+ /** */ AssignExpression high;
+ /** */ IdentifierOrTemplateInstance identifierOrTemplateInstance;
+ /** */ AssertExpression assertExpression;
}
+///
class UnionDeclaration : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- Token identifier;
- TemplateParameters templateParameters;
- Constraint constraint;
- StructBody structBody;
+ /** */ Token identifier;
+ /** */ TemplateParameters templateParameters;
+ /** */ Constraint constraint;
+ /** */ StructBody structBody;
}
+///
class Unittest : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- BlockStatement blockStatement;
+ /** */ BlockStatement blockStatement;
}
+///
class VariableDeclaration : Declaration
{
public:
mixin(OVERRIDE_DEFAULT_ACCEPT);
- Type type;
- Declarator[] declarators;
- StorageClass storageClass;
- AutoDeclaration autoDeclaration;
+ /** */ Type type;
+ /** */ Declarator[] declarators;
+ /** */ StorageClass storageClass;
+ /** */ AutoDeclaration autoDeclaration;
}
+///
class VersionCondition : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- Token token;
+ /** */ Token token;
}
+///
class VersionSpecification : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- Token token;
+ /** */ Token token;
}
+///
class WhileStatement : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- Expression expression;
- StatementNoCaseNoDefault statementNoCaseNoDefault;
+ /** */ Expression expression;
+ /** */ StatementNoCaseNoDefault statementNoCaseNoDefault;
}
+///
class WithStatement : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- Expression expression;
- Symbol symbol;
- TemplateInstance templateInstance;
+ /** */ Expression expression;
+ /** */ Symbol symbol;
+ /** */ TemplateInstance templateInstance;
}
+///
class XorExpression : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
- XorExpression left;
- AndExpression right;
+ /** */ XorExpression left;
+ /** */ AndExpression right;
}
diff --git a/std/d/lexer.d b/std/d/lexer.d
index 3c6ddad..9c2d210 100755
--- a/std/d/lexer.d
+++ b/std/d/lexer.d
@@ -13,7 +13,7 @@
* LexerConfig config;
* config.iterStyle = IterationStyle.everything;
* config.tokenStyle = TokenStyle.source;
- * config.versionNumber = 2061;
+ * config.versionNumber = 2064;
* config.vendorString = "Lexer Example";
* ---
* Once you have configured the _lexer, call byToken$(LPAREN)$(RPAREN) on your
@@ -200,7 +200,7 @@ enum IterationStyle
includeWhitespace = 0b0010,
/// Include $(LINK2 http://dlang.org/lex.html#specialtokens, special tokens)
includeSpecialTokens = 0b0100,
- /// Do not stop iteration on reaching the ___EOF__ token
+ /// Do not stop iteration on reaching the $(D_KEYWORD ___EOF__) token
ignoreEOF = 0b1000,
/// Include _everything
everything = includeComments | includeWhitespace | ignoreEOF
@@ -215,8 +215,8 @@ enum TokenStyle : uint
/**
* Escape sequences will be replaced with their equivalent characters,
* enclosing quote characters will not be included. Special tokens such as
- * __VENDOR__ will be replaced with their equivalent strings. Useful for
- * creating a compiler or interpreter.
+ * $(D_KEYWORD ___VENDOR__) will be replaced with their equivalent strings.
+ * Useful for creating a compiler or interpreter.
*/
default_ = 0b0000,
@@ -236,8 +236,8 @@ enum TokenStyle : uint
includeQuotes = 0b0010,
/**
- * Do not replace the value field of the special tokens such as ___DATE__
- * with their string equivalents.
+ * Do not replace the value field of the special tokens such as
+ * $(D_KEYWORD ___DATE__) with their string equivalents.
*/
doNotReplaceSpecial = 0b0100,
@@ -265,12 +265,12 @@ struct LexerConfig
TokenStyle tokenStyle = tokenStyle.default_;
/**
- * Replacement for the ___VERSION__ token. Defaults to 100.
+ * Replacement for the $(D_KEYWORD ___VERSION__) token. Defaults to 100.
*/
uint versionNumber = 100;
/**
- * Replacement for the ___VENDOR__ token. Defaults to $(D_STRING "std.d.lexer")
+ * Replacement for the $(D_KEYWORD ___VENDOR__) token. Defaults to $(D_STRING "std.d.lexer")
*/
string vendorString = "std.d.lexer";
@@ -597,7 +597,7 @@ L_advance:
return;
}
- if (config.iterStyle & TokenStyle.doNotReplaceSpecial)
+ if (config.tokenStyle & TokenStyle.doNotReplaceSpecial)
return;
expandSpecialToken();
}
@@ -2680,9 +2680,10 @@ immutable(string[TokenType.max + 1]) tokenValues = [
"__VERSION__",
"__FILE__",
"__LINE__",
- "__MODULE__",
- "__FUNCTION__",
- "__PRETTY_FUNCTION",
+ "__MODULE__",
+ "__FUNCTION__",
+ "__PRETTY_FUNCTION__",
+ null,
null,
null,
null,
@@ -2704,7 +2705,6 @@ immutable(string[TokenType.max + 1]) tokenValues = [
null,
null,
null,
- null,
];
pure string getTokenValue(const TokenType type)
@@ -2867,6 +2867,7 @@ pure TokenType lookupTokenType(R)(R input)
case '_': if (input[1..$].equal("_DATE__")) return TokenType.specialDate;
else if (input[1..$].equal("_FILE__")) return TokenType.specialFile;
else if (input[1..$].equal("_LINE__")) return TokenType.specialLine;
+ else if (input[1..$].equal("_vector")) return TokenType.vector;
else if (input[1..$].equal("_TIME__")) return TokenType.specialTime;
else if (input[1..$].equal("_traits")) return TokenType.traits; else break;
case 'a': if (input[1..$].equal("bstract")) return TokenType.abstract_; else break;
@@ -2896,8 +2897,8 @@ pure TokenType lookupTokenType(R)(R input)
{
case 'd': if (input[1..$].equal("eprecated")) return TokenType.deprecated_; else break;
case '_':
- if (input[1..$].equal("_VENDOR__")) return TokenType.specialVendor;
- else if (input[1..$].equal("_MODULE__")) return TokenType.specialModule; else break;
+ if (input[1..$].equal("_VENDOR__")) return TokenType.specialVendor;
+ else if (input[1..$].equal("_MODULE__")) return TokenType.specialModule; else break;
default: break;
}
break;
@@ -2906,13 +2907,14 @@ pure TokenType lookupTokenType(R)(R input)
return TokenType.specialVersion;
break;
case 12:
- switch (input[0])
- {
+ switch (input[0])
+ {
case 's': if (input[1..$].equal("ynchronized")) return TokenType.synchronized_; else break;
- case '_': if (input[1..$].equal("_FUNCTION__")) return TokenType.specialFunction; else break;
+ case '_': if (input[1..$].equal("_FUNCTION__")) return TokenType.specialFunction;
+ else if (input[1..$].equal("_parameters")) return TokenType.parameters; else break;
default: break;
- }
- break;
+ }
+ break;
case 13:
if (input[1..$].equal("_TIMESTAMP__"))
return TokenType.specialTimestamp;
@@ -2921,7 +2923,7 @@ pure TokenType lookupTokenType(R)(R input)
if (input[1..$].equal("oreach_reverse"))
return TokenType.foreach_reverse_;
break;
- case 19:
+ case 19:
if (input[1..$].equal("_PRETTY_FUNCTION__"))
return TokenType.specialPrettyFunction;
break;
@@ -3306,7 +3308,8 @@ unittest
~ " interface invariant is lazy macro mixin module new nothrow null"
~ " out override pure ref return struct super switch template this"
~ " throw true try typedef typeid typeof union unittest version volatile"
- ~ " while with __traits __parameters __vector");
+ ~ " while with __traits __parameters __vector __VENDOR__ __MODULE__"
+ ~ " __VERSION__ __TIMESTAMP__ __PRETTY_FUNCTION__");
auto expected = ["bool", "byte", "cdouble",
"cent", "cfloat", "char", "creal",
"dchar", "double", "float", "function",
@@ -3329,10 +3332,13 @@ unittest
"super", "switch", "template", "this", "throw",
"true", "try", "typedef", "typeid", "typeof",
"union", "unittest", "version", "volatile",
- "while", "with", "__traits", "__parameters", "__vector"];
+ "while", "with", "__traits", "__parameters", "__vector",
+ "__VENDOR__", "__MODULE__", "__VERSION__", "__TIMESTAMP__",
+ "__PRETTY_FUNCTION__"];
LexerConfig config;
+ config.tokenStyle = TokenStyle.doNotReplaceSpecial;
auto tokens = byToken(source, config);
- //writeln(tokens.map!"a.value"().array());
+// writeln(tokens.map!"a.value"().array());
assert (equal(map!"a.value"(tokens), expected));
}
@@ -3387,7 +3393,7 @@ unittest
assert (tokens.front.line == 1);
assert (tokens.moveFront() == TokenType.int_);
assert (tokens.front.line == 4);
- assert (isType(tokens.front));
+ assert (isBasicType(tokens.front));
assert (tokens.front.value == "double");
tokens.popFront();
assert (tokens.front.value == "abcde (a + b) == 0", tokens.front.value);
diff --git a/std/d/parser.d b/std/d/parser.d
index 5f9d3c5..9574c65 100755
--- a/std/d/parser.d
+++ b/std/d/parser.d
@@ -13,7 +13,10 @@
* Authors: Brian Schott
* Source: $(PHOBOSSRC std/d/_parser.d)
* MACROS:
- * GRAMMAR = $0
+ * GRAMMAR = $0
+ * RULEDEF = $0
+ * RULE = $0
+ * LITERAL = $0
*/
module std.d.parser;
@@ -22,6 +25,7 @@ import std.d.lexer;
import std.d.ast;
import std.conv;
import std.algorithm;
+import std.array;
version(unittest) import std.stdio;
/**
@@ -31,9 +35,9 @@ version(unittest) import std.stdio;
*/
Module parseModule(R)(R tokens) if (is (ElementType!R == Token))
{
- auto parser = new Parser();
- parser.tokens = tokens.array();
- return parser.parseModule();
+ auto parser = new Parser();
+ parser.tokens = tokens.array();
+ return parser.parseModule();
}
/**
@@ -41,601 +45,630 @@ Module parseModule(R)(R tokens) if (is (ElementType!R == Token))
*/
struct Parser
{
- /**
- * Parses an AddExpression.
- * $(GRAMMAR addExpression: mulExpression
- * | addExpression ('+' | '-' | '~') mulExpression
- * ;)
- */
- AddExpression parseAddExpression()
- {
- auto node = new AddExpression;
- node.right = parseMulExpression();
- while (currentIsOneOf(TokenType.plus, TokenType.minus, TokenType.tilde))
- {
- node.operator = advance().type;
- auto newNode = new AddExpression;
- newNode.left = node;
- newNode.right = parseMulExpression();
- node = newNode;
- }
- return node;
- }
-
- /**
- * Parses an AliasDeclaration
- * $(GRAMMAR aliasDeclaration: 'alias' (aliasInitializer (',' aliasInitializer)* | type declarator) ';'
- * ;)
- */
- AliasDeclaration parseAliasDeclaration()
- {
- auto node = new AliasDeclaration;
- expect(TokenType.alias_);
-
- // TODO
-
- expect(TokenType.semicolon);
- return node;
- }
-
- /**
- * Parses an AliasInitializer
- * $(GRAMMAR aliasInitializer: Identifier '=' type
- * ;)
- */
- AliasInitializer parseAliasInitializer()
- {
- auto node = new AliasInitializer;
- node.identifier = *expect(TokenType.identifier);
- expect(TokenType.assign);
- node.type = parseType();
- return node;
- }
-
- /**
- * Parses an AliasThisDeclaration
- * $(GRAMMAR aliasThisDeclaration: 'alias' Identifier 'this' ';'
- * ;)
- */
- AliasThisDeclaration parseAliasThisDeclaration()
- {
- auto node = new AliasThisDeclaration;
- expect(TokenType.alias_);
- node.identifier = *expect(TokenType.identifier);
- expect(TokenType.this_);
- expect(TokenType.semicolon);
- return node;
- }
-
- /**
- * Parses an AlignAttribute.
- * $(GRAMMAR alignAttribute: 'align' ('(' IntegerLiteral ')')?
- * ;)
- */
- AlignAttribute parseAlignAttribute()
- {
- auto node = new AlignAttribute;
- expect(TokenType.align_);
- if (currentIs(TokenType.lParen))
- {
- expect(TokenType.lParen);
- node.intLiteral = *expect(TokenType.intLiteral);
- expect(TokenType.rParen);
- }
- return node;
- }
-
- /**
- * Parses an AndAndExpression
- * $(GRAMMAR andAndExpression: orExpression
- * | andAndExpression '&&' orExpression
- * ;)
- */
- AndAndExpression parseAndAndExpression()
- {
- auto node = new AndAndExpression;
- node.right = parseOrExpression();
- while (currentIs(TokenType.logicAnd))
- {
- advance();
- auto node2 = new AndAndExpression;
- node2.left = node;
- node2.right = parseOrExpression();
- node = node2;
- }
- return node;
- }
-
- /**
- * Parses an AndExpression
- *
- * $(GRAMMAR )
- */
- AndExpression parseAndExpression()
- {
- auto node = new AndExpression;
- // TODO
- return node;
- }
-
- /**
- * Parses an ArgumentList
- *
- * $(GRAMMAR )
- */
- ArgumentList parseArgumentList()
- {
- auto node = new ArgumentList;
- // TODO
- return node;
- }
-
- /**
- * Parses an Arguments
- *
- * $(GRAMMAR )
- */
- Arguments parseArguments()
- {
- auto node = new Arguments;
- expect(TokenType.lParen);
- node.argumentList = parseArgumentList();
- expect(TokenType.rParen);
- return node;
- }
-
- /**
- * Parses an ArrayInitializer
- *
- * $(GRAMMAR )
- */
- ArrayInitializer parseArrayInitializer()
- {
- auto node = new ArrayInitializer;
- // TODO
- return node;
- }
-
- /**
- * Parses an ArrayLiteral
- *
- * $(GRAMMAR arrayLiteral: '[' argumentList ']'
+ /**
+ * Parses an AddExpression.
+ *
+ * $(GRAMMAR $(RULEDEF addExpression):
+ * $(RULE mulExpression)
+ * | $(RULE addExpression) $(LPAREN)$(LITERAL '+') | $(LITERAL'-') | $(LITERAL'~')$(RPAREN) $(RULE mulExpression)
* ;)
- */
- ArrayLiteral parseArrayLiteral()
- {
- auto node = new ArrayLiteral;
- expect(TokenType.lBracket);
- node.argumentList = parseArgumentList();
- expect(TokenType.rBracket);
- return node;
- }
+ */
+ AddExpression parseAddExpression()
+ {
+ auto node = new AddExpression;
+ node.right = parseMulExpression();
+ while (currentIsOneOf(TokenType.plus, TokenType.minus, TokenType.tilde))
+ {
+ node.operator = advance().type;
+ auto newNode = new AddExpression;
+ newNode.left = node;
+ newNode.right = parseMulExpression();
+ node = newNode;
+ }
+ return node;
+ }
- /**
- * Parses an ArrayMemberInitialization
- *
- * $(GRAMMAR )
- */
- ArrayMemberInitialization parseArrayMemberInitialization()
- {
- auto node = new ArrayMemberInitialization;
- // TODO
- return node;
- }
-
- /**
- * Parses an ArrayMemberInitializations
- *
- * $(GRAMMAR )
- */
- ArrayMemberInitializations parseArrayMemberInitializations()
- {
- auto node = new ArrayMemberInitializations;
- // TODO
- return node;
- }
-
- /**
- * Parses an AsmAddExp
- *
- * $(GRAMMAR )
- */
- AsmAddExp parseAsmAddExp()
- {
- auto node = new AsmAddExp;
- // TODO
- return node;
- }
-
- /**
- * Parses an AsmAndExp
- *
- * $(GRAMMAR )
- */
- AsmAndExp parseAsmAndExp()
- {
- auto node = new AsmAndExp;
- // TODO
- return node;
- }
-
- /**
- * Parses an AsmBrExp
- *
- * $(GRAMMAR )
- */
- AsmBrExp parseAsmBrExp()
- {
- auto node = new AsmBrExp;
- // TODO
- return node;
- }
-
- /**
- * Parses an AsmEqualExp
- *
- * $(GRAMMAR )
- */
- AsmEqualExp parseAsmEqualExp()
- {
- auto node = new AsmEqualExp;
- // TODO
- return node;
- }
-
- /**
- * Parses an AsmExp
- *
- * $(GRAMMAR )
- */
- AsmExp parseAsmExp()
- {
- auto node = new AsmExp;
-
- return node;
- }
-
- /**
- * Parses an AsmInstruction
- *
- * $(GRAMMAR )
- */
- AsmInstruction parseAsmInstruction()
- {
- auto node = new AsmInstruction;
-
- return node;
- }
-
- /**
- * Parses an AsmLogAndExp
- *
- * $(GRAMMAR )
- */
- AsmLogAndExp parseAsmLogAndExp()
- {
- auto node = new AsmLogAndExp;
-
- return node;
- }
-
- /**
- * Parses an AsmLogOrExp
- *
- * $(GRAMMAR )
- */
- AsmLogOrExp parseAsmLogOrExp()
- {
- auto node = new AsmLogOrExp;
-
- return node;
- }
-
- /**
- * Parses an AsmMulExp
- *
- * $(GRAMMAR )
- */
- AsmMulExp parseAsmMulExp()
- {
- auto node = new AsmMulExp;
-
- return node;
- }
-
- /**
- * Parses an AsmOrExp
- *
- * $(GRAMMAR )
- */
- AsmOrExp parseAsmOrExp()
- {
- auto node = new AsmOrExp;
-
- return node;
- }
-
- /**
- * Parses an AsmPrimaryExp
- *
- * $(GRAMMAR )
- */
- AsmPrimaryExp parseAsmPrimaryExp()
- {
- auto node = new AsmPrimaryExp;
-
- return node;
- }
-
- /**
- * Parses an AsmRelExp
- *
- * $(GRAMMAR )
- */
- AsmRelExp parseAsmRelExp()
- {
- auto node = new AsmRelExp;
-
- return node;
- }
-
- /**
- * Parses an AsmShiftExp
- *
- * $(GRAMMAR )
- */
- AsmShiftExp parseAsmShiftExp()
- {
- auto node = new AsmShiftExp;
-
- return node;
- }
-
- /**
- * Parses an AsmStatement
- *
- * $(GRAMMAR )
- */
- AsmStatement parseAsmStatement()
- {
- auto node = new AsmStatement;
-
- return node;
- }
-
- /**
- * Parses an AsmTypePrefix
- *
- * $(GRAMMAR )
- */
- AsmTypePrefix parseAsmTypePrefix()
- {
- auto node = new AsmTypePrefix;
-
- return node;
- }
-
- /**
- * Parses an AsmUnaExp
- *
- * $(GRAMMAR )
- */
- AsmUnaExp parseAsmUnaExp()
- {
- auto node = new AsmUnaExp;
-
- return node;
- }
-
- /**
- * Parses an AsmXorExp
- *
- * $(GRAMMAR )
- */
- AsmXorExp parseAsmXorExp()
- {
- auto node = new AsmXorExp;
-
- return node;
- }
-
- /**
- * Parses an AssertExpression
- *
- * $(GRAMMAR )
- */
- AssertExpression parseAssertExpression()
- {
- auto node = new AssertExpression;
-
- return node;
- }
-
- /**
- * Parses an AssertStatement
- *
- * $(GRAMMAR )
- */
- AssertStatement parseAssertStatement()
- {
- auto node = new AssertStatement;
-
- return node;
- }
-
- /**
- * Parses an AssignExpression
- *
- * $(GRAMMAR )
- */
- AssignExpression parseAssignExpression()
- {
- auto node = new AssignExpression;
-
- return node;
- }
-
- /**
- * Parses an AssignStatement
- *
- * $(GRAMMAR )
- */
- AssignStatement parseAssignStatement()
- {
- auto node = new AssignStatement;
-
- return node;
- }
-
- /**
- * Parses an AssocArrayLiteral
- *
- * $(GRAMMAR assocArrayLiteral: '[' keyValuePairs ']'
+ /**
+ * Parses an AliasDeclaration.
+ *
+ * $(GRAMMAR $(RULEDEF aliasDeclaration):
+ * $(LITERAL 'alias') $(LPAREN)$(RULE aliasInitializer) $(LPAREN)$(LITERAL ',') $(RULE aliasInitializer)$(RPAREN)* | $(RULE type) $(RULE declarator)$(RPAREN) $(LITERAL ';')
* ;)
- */
- AssocArrayLiteral parseAssocArrayLiteral()
- {
- auto node = new AssocArrayLiteral;
+ */
+ AliasDeclaration parseAliasDeclaration()
+ {
+ auto node = new AliasDeclaration;
+ expect(TokenType.alias_);
+
+ // TODO
+
+ expect(TokenType.semicolon);
+ return node;
+ }
+
+ /**
+ * Parses an AliasInitializer
+ * $(GRAMMAR $(RULEDEF aliasInitializer):
+ * $(LITERAL Identifier) $(LITERAL '=') $(RULE type)
+ * ;)
+ */
+ AliasInitializer parseAliasInitializer()
+ {
+ auto node = new AliasInitializer;
+ node.identifier = *expect(TokenType.identifier);
+ expect(TokenType.assign);
+ node.type = parseType();
+ return node;
+ }
+
+ /**
+ * Parses an AliasThisDeclaration
+ * $(GRAMMAR $(RULEDEF aliasThisDeclaration): $(LITERAL 'alias') $(LITERAL Identifier) $(LITERAL 'this') $(LITERAL ';')
+ * ;)
+ */
+ AliasThisDeclaration parseAliasThisDeclaration()
+ {
+ auto node = new AliasThisDeclaration;
+ expect(TokenType.alias_);
+ node.identifier = *expect(TokenType.identifier);
+ expect(TokenType.this_);
+ expect(TokenType.semicolon);
+ return node;
+ }
+
+ /**
+ * Parses an AlignAttribute.
+ * $(GRAMMAR $(RULEDEF alignAttribute): $(LITERAL 'align') ($(LITERAL '$(LPAREN)') $(LITERAL IntegerLiteral) $(LITERAL '$(RPAREN)'))?
+ * ;)
+ */
+ AlignAttribute parseAlignAttribute()
+ {
+ auto node = new AlignAttribute;
+ expect(TokenType.align_);
+ if (currentIs(TokenType.lParen))
+ {
+ expect(TokenType.lParen);
+ node.intLiteral = *expect(TokenType.intLiteral);
+ expect(TokenType.rParen);
+ }
+ return node;
+ }
+
+ /**
+ * Parses an AndAndExpression
+ * $(GRAMMAR $(RULEDEF andAndExpression):
+ * $(RULE orExpression)
+ * | $(RULE andAndExpression) $(LITERAL '&&') $(RULE orExpression)
+ * ;)
+ */
+ AndAndExpression parseAndAndExpression()
+ {
+ auto node = new AndAndExpression;
+ node.right = parseOrExpression();
+ while (currentIs(TokenType.logicAnd))
+ {
+ advance();
+ auto node2 = new AndAndExpression;
+ node2.left = node;
+ node2.right = parseOrExpression();
+ node = node2;
+ }
+ return node;
+ }
+
+ /**
+ * Parses an AndExpression
+ *
+ * $(GRAMMAR )
+ */
+ AndExpression parseAndExpression()
+ {
+ auto node = new AndExpression;
+ // TODO
+ return node;
+ }
+
+ /**
+ * Parses an ArgumentList
+ *
+ * $(GRAMMAR )
+ */
+ ArgumentList parseArgumentList()
+ {
+ auto node = new ArgumentList;
+ // TODO
+ return node;
+ }
+
+ /**
+ * Parses Arguments
+ *
+ * $(GRAMMAR $(RULEDEF arguments):
+ * $(LITERAL '$(LPAREN)') $(RULE argumentList)? $(LITERAL '$(RPAREN)')
+ * ;)
+ */
+ Arguments parseArguments()
+ {
+ auto node = new Arguments;
+ expect(TokenType.lParen);
+ node.argumentList = parseArgumentList();
+ expect(TokenType.rParen);
+ return node;
+ }
+
+ /**
+ * Parses an ArrayInitializer
+ *
+ * $(GRAMMAR )
+ */
+ ArrayInitializer parseArrayInitializer()
+ {
+ auto node = new ArrayInitializer;
+ // TODO
+ return node;
+ }
+
+ /**
+ * Parses an ArrayLiteral
+ *
+ * $(GRAMMAR $(RULEDEF arrayLiteral):
+ * $(LITERAL '[') $(RULE argumentList) $(LITERAL ']')
+ * ;)
+ */
+ ArrayLiteral parseArrayLiteral()
+ {
+ auto node = new ArrayLiteral;
+ expect(TokenType.lBracket);
+ node.argumentList = parseArgumentList();
+ expect(TokenType.rBracket);
+ return node;
+ }
+
+ /**
+ * Parses an ArrayMemberInitialization
+ *
+ * $(GRAMMAR )
+ */
+ ArrayMemberInitialization parseArrayMemberInitialization()
+ {
+ auto node = new ArrayMemberInitialization;
+ // TODO
+ return node;
+ }
+
+ /**
+ * Parses an ArrayMemberInitializations
+ *
+ * $(GRAMMAR )
+ */
+ ArrayMemberInitializations parseArrayMemberInitializations()
+ {
+ auto node = new ArrayMemberInitializations;
+ // TODO
+ return node;
+ }
+
+ /**
+ * Parses an AsmAddExp
+ *
+ * $(GRAMMAR )
+ */
+ AsmAddExp parseAsmAddExp()
+ {
+ auto node = new AsmAddExp;
+ // TODO
+ return node;
+ }
+
+ /**
+ * Parses an AsmAndExp
+ *
+ * $(GRAMMAR )
+ */
+ AsmAndExp parseAsmAndExp()
+ {
+ auto node = new AsmAndExp;
+ // TODO
+ return node;
+ }
+
+ /**
+ * Parses an AsmBrExp
+ *
+ * $(GRAMMAR )
+ */
+ AsmBrExp parseAsmBrExp()
+ {
+ auto node = new AsmBrExp;
+ // TODO
+ return node;
+ }
+
+ /**
+ * Parses an AsmEqualExp
+ *
+ * $(GRAMMAR )
+ */
+ AsmEqualExp parseAsmEqualExp()
+ {
+ auto node = new AsmEqualExp;
+ // TODO
+ return node;
+ }
+
+ /**
+ * Parses an AsmExp
+ *
+ * $(GRAMMAR )
+ */
+ AsmExp parseAsmExp()
+ {
+ auto node = new AsmExp;
+
+ return node;
+ }
+
+ /**
+ * Parses an AsmInstruction
+ *
+ * $(GRAMMAR )
+ */
+ AsmInstruction parseAsmInstruction()
+ {
+ auto node = new AsmInstruction;
+
+ return node;
+ }
+
+ /**
+ * Parses an AsmLogAndExp
+ *
+ * $(GRAMMAR )
+ */
+ AsmLogAndExp parseAsmLogAndExp()
+ {
+ auto node = new AsmLogAndExp;
+
+ return node;
+ }
+
+ /**
+ * Parses an AsmLogOrExp
+ *
+ * $(GRAMMAR )
+ */
+ AsmLogOrExp parseAsmLogOrExp()
+ {
+ auto node = new AsmLogOrExp;
+
+ return node;
+ }
+
+ /**
+ * Parses an AsmMulExp
+ *
+ * $(GRAMMAR )
+ */
+ AsmMulExp parseAsmMulExp()
+ {
+ auto node = new AsmMulExp;
+
+ return node;
+ }
+
+ /**
+ * Parses an AsmOrExp
+ *
+ * $(GRAMMAR )
+ */
+ AsmOrExp parseAsmOrExp()
+ {
+ auto node = new AsmOrExp;
+
+ return node;
+ }
+
+ /**
+ * Parses an AsmPrimaryExp
+ *
+ * $(GRAMMAR )
+ */
+ AsmPrimaryExp parseAsmPrimaryExp()
+ {
+ auto node = new AsmPrimaryExp;
+
+ return node;
+ }
+
+ /**
+ * Parses an AsmRelExp
+ *
+ * $(GRAMMAR )
+ */
+ AsmRelExp parseAsmRelExp()
+ {
+ auto node = new AsmRelExp;
+
+ return node;
+ }
+
+ /**
+ * Parses an AsmShiftExp
+ *
+ * $(GRAMMAR )
+ */
+ AsmShiftExp parseAsmShiftExp()
+ {
+ auto node = new AsmShiftExp;
+
+ return node;
+ }
+
+ /**
+ * Parses an AsmStatement
+ *
+ * $(GRAMMAR )
+ */
+ AsmStatement parseAsmStatement()
+ {
+ auto node = new AsmStatement;
+
+ return node;
+ }
+
+ /**
+ * Parses an AsmTypePrefix
+ *
+ * $(GRAMMAR )
+ */
+ AsmTypePrefix parseAsmTypePrefix()
+ {
+ auto node = new AsmTypePrefix;
+
+ return node;
+ }
+
+ /**
+ * Parses an AsmUnaExp
+ *
+ * $(GRAMMAR )
+ */
+ AsmUnaExp parseAsmUnaExp()
+ {
+ auto node = new AsmUnaExp;
+
+ return node;
+ }
+
+ /**
+ * Parses an AsmXorExp
+ *
+ * $(GRAMMAR )
+ */
+ AsmXorExp parseAsmXorExp()
+ {
+ auto node = new AsmXorExp;
+
+ return node;
+ }
+
+ /**
+ * Parses an AssertExpression
+ *
+ * $(GRAMMAR )
+ */
+ AssertExpression parseAssertExpression()
+ {
+ auto node = new AssertExpression;
+
+ return node;
+ }
+
+ /**
+ * Parses an AssertStatement
+ *
+ * $(GRAMMAR )
+ */
+ AssertStatement parseAssertStatement()
+ {
+ auto node = new AssertStatement;
+
+ return node;
+ }
+
+ /**
+ * Parses an AssignExpression
+ *
+ * $(GRAMMAR )
+ */
+ AssignExpression parseAssignExpression()
+ {
+ auto node = new AssignExpression;
+
+ return node;
+ }
+
+ /**
+ * Parses an AssignStatement
+ *
+ * $(GRAMMAR )
+ */
+ AssignStatement parseAssignStatement()
+ {
+ auto node = new AssignStatement;
+
+ return node;
+ }
+
+ /**
+ * Parses an AssocArrayLiteral
+ *
+ * $(GRAMMAR $(RULEDEF assocArrayLiteral):
+ * $(LITERAL '[') $(RULE keyValuePairs) $(LITERAL ']')
+ * ;)
+ */
+ AssocArrayLiteral parseAssocArrayLiteral()
+ {
+ auto node = new AssocArrayLiteral;
expect(TokenType.lBracket);
node.keyValuePairs = parseKeyValuePairs();
expect(TokenType.rBracket);
- return node;
- }
+ return node;
+ }
- /**
- * Parses an AtAttribute
- *
- * $(GRAMMAR )
- */
- AtAttribute parseAtAttribute()
- {
- auto node = new AtAttribute;
+ /**
+ * Parses an AtAttribute
+ *
+ * $(GRAMMAR )
+ */
+ AtAttribute parseAtAttribute()
+ {
+ auto node = new AtAttribute;
- return node;
- }
+ return node;
+ }
- /**
- * Parses an Attribute
- *
- * $(GRAMMAR )
- */
- Attribute parseAttribute()
- {
- auto node = new Attribute;
+ /**
+ * Parses an Attribute
+ *
+ * $(GRAMMAR )
+ */
+ Attribute parseAttribute()
+ {
+ auto node = new Attribute;
- return node;
- }
+ return node;
+ }
- /**
- * Parses an AttributedDeclaration
- *
- * $(GRAMMAR )
- */
- AttributedDeclaration parseAttributedDeclaration()
- {
- auto node = new AttributedDeclaration;
-
- return node;
- }
-
- /**
- * Parses an AutoDeclaration
- *
- * $(GRAMMAR )
- */
- AutoDeclaration parseAutoDeclaration()
- {
- auto node = new AutoDeclaration;
-
- return node;
- }
-
- /**
- * Parses a BlockStatement
- *
- * $(GRAMMAR blockStatement: '{' declarationsAndStatements? '}'
+ /**
+ * Parses an AttributedDeclaration
+ *
+ * $(GRAMMAR $(RULEDEF attributedDeclaration):
+ * $(RULE attribute) ($(LITERAL ':') | $(RULE declaration) | $(LITERAL '{') $(RULE declaration)* $(LITERAL '}'))
* ;)
- */
- BlockStatement parseBlockStatement()
- {
- auto node = new BlockStatement();
- expect(TokenType.lBrace);
- if (!currentIs(TokenType.rBrace))
- node.declarationsAndStatements = parseDeclarationsAndStatements();
- expect(TokenType.rBrace);
- return node;
- }
+ */
+ AttributedDeclaration parseAttributedDeclaration()
+ {
+ auto node = new AttributedDeclaration;
+ node.attribute = parseAttribute();
+ switch (current().type)
+ {
+ case TokenType.colon:
+ break;
+ case TokenType.lBrace:
+ while (moreTokens() && !currentIs(TokenType.rBrace))
+ node.declarations ~= parseDeclaration();
+ expect(TokenType.rBrace);
+ break;
+ default:
+ node.declarations ~= parseDeclaration();
+ break;
+ }
+ return node;
+ }
- /**
- * Parses a BodyStatement
- *
- * $(GRAMMAR bodyStatement: 'body' blockStatement
+ /**
+ * Parses an AutoDeclaration
+ *
+ * $(GRAMMAR )
+ */
+ AutoDeclaration parseAutoDeclaration()
+ {
+ auto node = new AutoDeclaration;
+
+ return node;
+ }
+
+ /**
+ * Parses a BlockStatement
+ *
+ * $(GRAMMAR $(RULEDEF blockStatement):
+ * $(LITERAL '{') $(RULE declarationsAndStatements)? $(LITERAL '}')
* ;)
- */
- BodyStatement parseBodyStatement()
- {
- auto node = new BodyStatement;
+ */
+ BlockStatement parseBlockStatement()
+ {
+ auto node = new BlockStatement();
+ expect(TokenType.lBrace);
+ if (!currentIs(TokenType.rBrace))
+ node.declarationsAndStatements = parseDeclarationsAndStatements();
+ expect(TokenType.rBrace);
+ return node;
+ }
+
+ /**
+ * Parses a BodyStatement
+ *
+ * $(GRAMMAR $(RULEDEF bodyStatement):
+ * $(LITERAL 'body') $(RULE blockStatement)
+ * ;)
+ */
+ BodyStatement parseBodyStatement()
+ {
+ auto node = new BodyStatement;
expect(TokenType.body_);
node.blockStatement = parseBlockStatement();
- return node;
- }
+ return node;
+ }
- /**
- * Parses a BreakStatement
- *
- * $(GRAMMAR breakStatement: 'break' Identifier? ';'
+ /**
+ * Parses a BreakStatement
+ *
+ * $(GRAMMAR $(RULEDEF breakStatement):
+ * $(LITERAL 'break') $(LITERAL Identifier)? $(LITERAL ';')
* ;)
- */
- BreakStatement parseBreakStatement()
- {
- expect(TokenType.break_);
- auto node = new BreakStatement;
- switch (current().type)
- {
- case TokenType.identifier:
- node.identifier = advance();
- expect(TokenType.semicolon);
- break;
- case TokenType.semicolon:
- advance();
- break;
- default:
- error("Identifier or semicolon expected following \"break\"");
- return null;
- }
- return node;
- }
+ */
+ BreakStatement parseBreakStatement()
+ {
+ expect(TokenType.break_);
+ auto node = new BreakStatement;
+ switch (current().type)
+ {
+ case TokenType.identifier:
+ node.identifier = advance();
+ expect(TokenType.semicolon);
+ break;
+ case TokenType.semicolon:
+ advance();
+ break;
+ default:
+ error("Identifier or semicolon expected following \"break\"");
+ return null;
+ }
+ return node;
+ }
- /**
- * Parses an BuiltinType
- *
- * $(GRAMMAR builtinType: 'bool'
- * | 'byte'
- * | 'ubyte'
- * | 'short'
- * | 'ushort'
- * | 'int'
- * | 'uint'
- * | 'long'
- * | 'ulong'
- * | 'char'
- * | 'wchar'
- * | 'dchar'
- * | 'float'
- * | 'double'
- * | 'real'
- * | 'ifloat'
- * | 'idouble'
- * | 'ireal'
- * | 'cfloat'
- * | 'cdouble'
- * | 'creal'
- * | 'void'
+ /**
+ * Parses an BuiltinType
+ *
+ * $(GRAMMAR $(RULEDEF builtinType):
+ * $(LITERAL 'bool')
+ * | $(LITERAL 'byte')
+ * | $(LITERAL 'ubyte')
+ * | $(LITERAL 'short')
+ * | $(LITERAL 'ushort')
+ * | $(LITERAL 'int')
+ * | $(LITERAL 'uint')
+ * | $(LITERAL 'long')
+ * | $(LITERAL 'ulong')
+ * | $(LITERAL 'char')
+ * | $(LITERAL 'wchar')
+ * | $(LITERAL 'dchar')
+ * | $(LITERAL 'float')
+ * | $(LITERAL 'double')
+ * | $(LITERAL 'real')
+ * | $(LITERAL 'ifloat')
+ * | $(LITERAL 'idouble')
+ * | $(LITERAL 'ireal')
+ * | $(LITERAL 'cfloat')
+ * | $(LITERAL 'cdouble')
+ * | $(LITERAL 'creal')
+ * | $(LITERAL 'void')
* ;)
- */
- BasicType parseBasicType()
- {
- auto node = new BasicType;
+ */
+ BasicType parseBasicType()
+ {
+ auto node = new BasicType;
if (isBasicType(current().type))
node.type = advance().type;
else
@@ -643,18 +676,19 @@ struct Parser
error("Basic type expected");
return null;
}
- return node;
- }
+ return node;
+ }
- /**
- * Parses a CaseRangeStatement
- *
- * $(GRAMMAR caseRangeStatement: 'case' assignExpression ':' '...' 'case' assignExpression ':' declarationsAndStatements
+ /**
+ * Parses a CaseRangeStatement
+ *
+ * $(GRAMMAR $(RULEDEF caseRangeStatement):
+ * $(LITERAL 'case') $(RULE assignExpression) $(LITERAL ':') $(LITERAL '...') $(LITERAL 'case') $(RULE assignExpression) $(LITERAL ':') $(RULE declarationsAndStatements)
* ;)
- */
- CaseRangeStatement parseCaseRangeStatement()
- {
- auto node = new CaseRangeStatement;
+ */
+ CaseRangeStatement parseCaseRangeStatement()
+ {
+ auto node = new CaseRangeStatement;
expect(TokenType.case_);
node.low = parseAssignExpression();
expect(TokenType.colon);
@@ -663,53 +697,81 @@ struct Parser
node.high = parseAssignExpression();
expect(TokenType.colon);
node.declarationsAndStatements = parseDeclarationsAndStatements();
- return node;
- }
+ return node;
+ }
- /**
- * Parses an CaseStatement
- *
- * $(GRAMMAR caseStatement: 'case' argumentList ':' declarationsAndStatements
+ /**
+ * Parses an CaseStatement
+ *
+ * $(GRAMMAR $(RULEDEF caseStatement):
+ * $(LITERAL 'case') $(RULE argumentList) $(LITERAL ':') $(RULE declarationsAndStatements)
* ;)
- */
- CaseStatement parseCaseStatement()
- {
- auto node = new CaseStatement;
+ */
+ CaseStatement parseCaseStatement()
+ {
+ auto node = new CaseStatement;
expect(TokenType.case_);
node.argumentList = parseArgumentList();
expect(TokenType.colon);
node.declarationsAndStatements = parseDeclarationsAndStatements();
- return node;
- }
+ return node;
+ }
- /**
- * Parses an CastExpression
- *
- * $(GRAMMAR )
- */
- CastExpression parseCastExpression()
- {
- auto node = new CastExpression;
+ /**
+ * Parses a CastExpression
+ *
+ * $(GRAMMAR $(RULEDEF castExpression):
+ * $(LITERAL 'cast') $(LITERAL '$(LPAREN)') ($(RULE type) | $(RULE castQualifier))? $(LITERAL '$(RPAREN)') $(RULE unaryExpression)
+ * ;)
+ */
+ CastExpression parseCastExpression()
+ {
+ auto node = new CastExpression;
+ expect(TokenType.cast_);
+ expect(TokenType.lParen);
+ if (isCastQualifier())
+ node.castQualifier = parseCastQualifier();
+ else
+ node.type = parseType();
+ expect(TokenType.rParen);
+ node.unaryExpression = parseUnaryExpression();
+ return node;
+ }
- return node;
- }
+ private bool isCastQualifier() const
+ {
+ switch (current().type)
+ {
+ case TokenType.const_:
+ return peekIsOneOf(TokenType.shared_, TokenType.rParen);
+ case TokenType.immutable_:
+ return peekIs(TokenType.rParen);
+ case TokenType.inout_:
+ return peekIsOneOf(TokenType.shared_, TokenType.rParen);
+ case TokenType.shared_:
+ return peekIsOneOf(TokenType.const_, TokenType.inout_, TokenType.rParen);
+ default:
+ return false;
+ }
+ }
- /**
- * Parses a CastQualifier
- *
- * $(GRAMMAR castQualifier: 'const'
- * | 'const' 'shared'
- * | 'immutable'
- * | 'inout'
- * | 'inout' 'shared'
- * | 'shared'
- * | 'shared' 'const'
- * | 'shared' 'inout'
+ /**
+ * Parses a CastQualifier
+ *
+ * $(GRAMMAR $(RULEDEF castQualifier):
+ * $(LITERAL 'const')
+ * | $(LITERAL 'const') $(LITERAL 'shared')
+ * | $(LITERAL 'immutable')
+ * | $(LITERAL 'inout')
+ * | $(LITERAL 'inout') $(LITERAL 'shared')
+ * | $(LITERAL 'shared')
+ * | $(LITERAL 'shared') $(LITERAL 'const')
+ * | $(LITERAL 'shared') $(LITERAL 'inout')
* ;)
- */
- CastQualifier parseCastQualifier()
- {
- auto node = new CastQualifier;
+ */
+ CastQualifier parseCastQualifier()
+ {
+ auto node = new CastQualifier;
switch (current().type)
{
case TokenType.inout_:
@@ -730,18 +792,19 @@ struct Parser
error("const, immutable, inout, or shared expected");
return null;
}
- return node;
- }
+ return node;
+ }
- /**
- * Parses a Catch
- *
- * $(GRAMMAR catch_: 'catch' '(' type Identifier? ')' nonEmptyStatementNoCaseNoDefault
- * ;)
- */
- Catch parseCatch()
- {
- auto node = new Catch;
+ /**
+ * Parses a Catch
+ *
+ * $(GRAMMAR $(RULEDEF catch):
+ * $(LITERAL 'catch') $(LITERAL '$(LPAREN)') $(RULE type) $(LITERAL Identifier)? $(LITERAL '$(RPAREN)') $(RULE nonEmptyStatementNoCaseNoDefault)
+ * ;)
+ */
+ Catch parseCatch()
+ {
+ auto node = new Catch;
expect(TokenType.catch_);
expect(TokenType.lParen);
node.type = parseType();
@@ -749,46 +812,48 @@ struct Parser
node.identifier = advance();
expect(TokenType.rParen);
node.nonEmptyStatementNoCaseNoDefault = parseNonEmptyStatementNoCaseNoDefault();
- return node;
- }
+ return node;
+ }
- /**
- * Parses a Catches
- *
- * $(GRAMMAR )
- */
- Catches parseCatches()
- {
- auto node = new Catches;
+ /**
+ * Parses a Catches
+ *
+ * $(GRAMMAR )
+ */
+ Catches parseCatches()
+ {
+ auto node = new Catches;
- return node;
- }
+ return node;
+ }
- /**
- * Parses an ClassBody
- *
- * $(GRAMMAR classBody: '{' declarationOrInvariant* '}'
+ /**
+ * Parses an ClassBody
+ *
+ * $(GRAMMAR $(RULEDEF classBody):
+ * $(LITERAL '{') $(RULE declarationOrInvariant)* $(LITERAL '}')
* ;)
- */
- ClassBody parseClassBody()
- {
- auto node = new ClassBody;
+ */
+ ClassBody parseClassBody()
+ {
+ auto node = new ClassBody;
expect(TokenType.lBrace);
while (!currentIs(TokenType.rBrace))
node.declarationOrInvariants ~= parseDeclarationOrInvariant();
expect(TokenType.rBrace);
- return node;
- }
+ return node;
+ }
- /**
- * Parses an ClassDeclaration
- *
- * $(GRAMMAR classDeclaration: 'class' Identifier (templateParameters constraint?)? (':' identifierList )? classBody
+ /**
+ * Parses an ClassDeclaration
+ *
+ * $(GRAMMAR $(RULEDEF classDeclaration):
+ * $(LITERAL 'class') $(LITERAL Identifier) ($(RULE templateParameters) $(RULE constraint)?)? ($(LITERAL ':') $(RULE identifierList))? $(RULE classBody)
* ;)
- */
- ClassDeclaration parseClassDeclaration()
- {
- auto node = new ClassDeclaration;
+ */
+ ClassDeclaration parseClassDeclaration()
+ {
+ auto node = new ClassDeclaration;
expect(TokenType.class_);
node.name = *expect(TokenType.identifier);
if (currentIs(TokenType.lParen))
@@ -800,32 +865,33 @@ struct Parser
if (currentIs(TokenType.colon))
node.superClasses = parseIdentifierList();
node.classBody = parseClassBody();
- return node;
- }
+ return node;
+ }
- /**
- * Parses an CmpExpression
- *
- * $(GRAMMAR )
- */
- CmpExpression parseCmpExpression()
- {
- auto node = new CmpExpression;
+ /**
+ * Parses an CmpExpression
+ *
+ * $(GRAMMAR )
+ */
+ CmpExpression parseCmpExpression()
+ {
+ auto node = new CmpExpression;
- return node;
- }
+ return node;
+ }
- /**
- * Parses a CompileCondition
- *
- * $(GRAMMAR compileCondition: versionCondition
- * | debugCondition
- * | staticIfCondition
+ /**
+ * Parses a CompileCondition
+ *
+ * $(GRAMMAR $(RULEDEF compileCondition):
+ * $(RULE versionCondition)
+ * | $(RULE debugCondition)
+ * | $(RULE staticIfCondition)
* ;)
- */
- CompileCondition parseCompileCondition()
- {
- auto node = new CompileCondition;
+ */
+ CompileCondition parseCompileCondition()
+ {
+ auto node = new CompileCondition;
switch (current().type)
{
case TokenType.version_:
@@ -841,99 +907,103 @@ struct Parser
error(`"version", "debug", or "static" expected`);
return null;
}
- return node;
- }
+ return node;
+ }
- /**
- * Parses an ConditionalDeclaration
- *
- * $(GRAMMAR )
- */
- ConditionalDeclaration parseConditionalDeclaration()
- {
- auto node = new ConditionalDeclaration;
+ /**
+ * Parses an ConditionalDeclaration
+ *
+ * $(GRAMMAR )
+ */
+ ConditionalDeclaration parseConditionalDeclaration()
+ {
+ auto node = new ConditionalDeclaration;
- return node;
- }
+ return node;
+ }
- /**
- * Parses an ConditionalStatement
- *
- * $(GRAMMAR )
- */
- ConditionalStatement parseConditionalStatement()
- {
- auto node = new ConditionalStatement;
+ /**
+ * Parses an ConditionalStatement
+ *
+ * $(GRAMMAR )
+ */
+ ConditionalStatement parseConditionalStatement()
+ {
+ auto node = new ConditionalStatement;
- return node;
- }
+ return node;
+ }
- /**
- * Parses an Constraint
- *
- * $(GRAMMAR constraint: 'if' '(' expression ')'
+ /**
+ * Parses an Constraint
+ *
+ * $(GRAMMAR $(RULEDEF constraint):
+ * $(LITERAL 'if') $(LITERAL '$(LPAREN)') $(RULE expression) $(LITERAL '$(RPAREN)')
* ;)
- */
- Constraint parseConstraint()
- {
- auto node = new Constraint;
+ */
+ Constraint parseConstraint()
+ {
+ auto node = new Constraint;
expect(TokenType.if_);
expect(TokenType.lParen);
node.expression = parseExpression();
expect(TokenType.rParen);
- return node;
- }
+ return node;
+ }
- /**
- * Parses a Constructor
- *
- * $(GRAMMAR constructor: 'this' parameters functionBody
+ /**
+ * Parses a Constructor
+ *
+ * $(GRAMMAR $(RULEDEF constructor):
+ * $(LITERAL 'this') $(RULE parameters) $(RULE functionBody)
* ;)
- */
- Constructor parseConstructor()
- {
- auto node = new Constructor;
+ */
+ Constructor parseConstructor()
+ {
+ auto node = new Constructor;
expect(TokenType.this_);
node.parameters = parseParameters();
node.functionBody = parseFunctionBody();
- return node;
- }
+ return node;
+ }
- /**
- * Parses an ContinueStatement
- *
- * $(GRAMMAR continueStatement: 'continue' Identifier? ';'
- * ;)
- */
- ContinueStatement parseContinueStatement()
- {
- expect(TokenType.continue_);
- auto node = new ContinueStatement;
- switch (current().type)
- {
- case TokenType.identifier:
- node.identifier = advance();
- expect(TokenType.semicolon);
- break;
- case TokenType.semicolon:
- advance();
- break;
- default:
- error(`Identifier or semicolon expected following "continue"`);
- return null;
- }
- return node;
- }
-
- /**
- * Parses an DebugCondition
- *
- * $(GRAMMAR debugCondition: 'debug' ('(' (IntegerLiteral | Identifier) ')')?
+ /**
+ * Parses an ContinueStatement
+ *
+ * $(GRAMMAR $(RULEDEF continueStatement):
+ * $(LITERAL 'continue') $(LITERAL Identifier)? $(LITERAL ';')
* ;)
- */
- DebugCondition parseDebugCondition()
- {
- auto node = new DebugCondition;
+ */
+ ContinueStatement parseContinueStatement()
+ {
+ expect(TokenType.continue_);
+ auto node = new ContinueStatement;
+ switch (current().type)
+ {
+ case TokenType.identifier:
+ node.identifier = advance();
+ expect(TokenType.semicolon);
+ break;
+ case TokenType.semicolon:
+ advance();
+ break;
+ default:
+ error(`Identifier or semicolon expected following "continue"`);
+ return null;
+ }
+ return node;
+ }
+
+ /**
+ * Parses a DebugCondition
+ *
+ * $(GRAMMAR $(RULEDEF debugCondition):
+ * $(LITERAL 'debug') ($(LITERAL '$(LPAREN)') ($(LITERAL IntegerLiteral) | $(LITERAL Identifier)) $(LITERAL '$(RPAREN)'))?
+ * ;)
+ */
+ DebugCondition parseDebugCondition()
+ {
+ auto node = new DebugCondition;
expect(TokenType.debug_);
if (currentIs(TokenType.lParen))
{
@@ -950,18 +1020,19 @@ struct Parser
}
else
node.hasIdentifierOrInteger = false;
- return node;
- }
+ return node;
+ }
- /**
- * Parses a DebugSpecification
- *
- * $(GRAMMAR debugSpecification: 'debug' '=' (Identifier | IntegerLiteral) ';'
+ /**
+ * Parses a DebugSpecification
+ *
+ * $(GRAMMAR $(RULEDEF debugSpecification):
+ * $(LITERAL 'debug') $(LITERAL '=') ($(LITERAL Identifier) | $(LITERAL IntegerLiteral)) $(LITERAL ';')
* ;)
- */
- DebugSpecification parseDebugSpecification()
- {
- auto node = new DebugSpecification;
+ */
+ DebugSpecification parseDebugSpecification()
+ {
+ auto node = new DebugSpecification;
expect(TokenType.debug_);
expect(TokenType.assign);
if (currentIsOneOf(TokenType.identifier, TokenType.intLiteral))
@@ -972,40 +1043,41 @@ struct Parser
return null;
}
expect(TokenType.semicolon);
- return node;
- }
+ return node;
+ }
- /**
- * Parses a Declaration
- *
- * $(GRAMMAR declaration: aliasDeclaration
- * | aliasThisDeclaration
- * | attributedDeclaration
- * | classDeclaration
- * | conditionalDeclaration
- * | constructor
- * | destructor
- * | enumDeclaration
- * | functionDeclaration
- * | importDeclaration
- * | interfaceDeclaration
- * | mixinDeclaration
- * | pragmaDeclaration
- * | sharedStaticConstructor
- * | sharedStaticDestructor
- * | staticAssertDeclaration
- * | staticConstructor
- * | staticDestructor
- * | structDeclaration
- * | templateDeclaration
- * | unionDeclaration
- * | unittest
- * | variableDeclaration
+ /**
+ * Parses a Declaration
+ *
+ * $(GRAMMAR $(RULEDEF declaration):
+ * $(RULE aliasDeclaration)
+ * | $(RULE aliasThisDeclaration)
+ * | $(RULE attributedDeclaration)
+ * | $(RULE classDeclaration)
+ * | $(RULE conditionalDeclaration)
+ * | $(RULE constructor)
+ * | $(RULE destructor)
+ * | $(RULE enumDeclaration)
+ * | $(RULE functionDeclaration)
+ * | $(RULE importDeclaration)
+ * | $(RULE interfaceDeclaration)
+ * | $(RULE mixinDeclaration)
+ * | $(RULE pragmaDeclaration)
+ * | $(RULE sharedStaticConstructor)
+ * | $(RULE sharedStaticDestructor)
+ * | $(RULE staticAssertDeclaration)
+ * | $(RULE staticConstructor)
+ * | $(RULE staticDestructor)
+ * | $(RULE structDeclaration)
+ * | $(RULE templateDeclaration)
+ * | $(RULE unionDeclaration)
+ * | $(RULE unittest)
+ * | $(RULE variableDeclaration)
* ;)
- */
- Declaration parseDeclaration()
- {
- auto node = new Declaration;
+ */
+ Declaration parseDeclaration()
+ {
+ auto node = new Declaration;
switch (current().type)
{
case TokenType.alias_:
@@ -1076,28 +1148,29 @@ struct Parser
error("Declaration expected");
return null;
}
- return node;
- }
-
- /**
- * Parses an DeclarationsAndStatements
- *
- * $(GRAMMAR )
- */
- DeclarationsAndStatements parseDeclarationsAndStatements()
- {
- auto node = new DeclarationsAndStatements;
-
- return node;
- }
+ return node;
+ }
/**
- * Parses a DeclarationOrInvariant
- *
- * $(GRAMMAR declarationOrInvariant : declaration
- * | invariant
+ * Parses an DeclarationsAndStatements
+ *
+ * $(GRAMMAR )
+ */
+ DeclarationsAndStatements parseDeclarationsAndStatements()
+ {
+ auto node = new DeclarationsAndStatements;
+
+ return node;
+ }
+
+ /**
+ * Parses a DeclarationOrInvariant
+ *
+ * $(GRAMMAR $(RULEDEF declarationOrInvariant):
+ * $(RULE declaration)
+ * | $(RULE invariant)
* ;)
- */
+ */
DeclarationOrInvariant parseDeclarationOrInvariant()
{
auto node = new DeclarationOrInvariant;
@@ -1105,18 +1178,19 @@ struct Parser
node.invariant_ = parseInvariant();
else
node.declaration = parseDeclaration();
- return node;
+ return node;
}
- /**
- * Parses a Declarator
- *
- * $(GRAMMAR declarator: Identifier declaratorSuffix? ('=' initializer)?
+ /**
+ * Parses a Declarator
+ *
+ * $(GRAMMAR $(RULEDEF declarator):
+ * $(LITERAL Identifier) $(RULE declaratorSuffix)? ($(LITERAL '=') $(RULE initializer))?
* ;)
- */
- Declarator parseDeclarator()
- {
- auto node = new Declarator;
+ */
+ Declarator parseDeclarator()
+ {
+ auto node = new Declarator;
node.identifier = *expect(TokenType.identifier);
if (currentIs(TokenType.lBracket))
node.declaratorSuffix = parseDeclaratorSuffix();
@@ -1125,66 +1199,67 @@ struct Parser
advance();
node.initializer = parseInitializer();
}
- return node;
- }
+ return node;
+ }
- /**
- * Parses an DeclaratorSuffix
- *
- * $(GRAMMAR )
- */
- DeclaratorSuffix parseDeclaratorSuffix()
- {
- auto node = new DeclaratorSuffix;
+ /**
+ * Parses an DeclaratorSuffix
+ *
+ * $(GRAMMAR )
+ */
+ DeclaratorSuffix parseDeclaratorSuffix()
+ {
+ auto node = new DeclaratorSuffix;
- return node;
- }
+ return node;
+ }
- /**
- * Parses an DefaultStatement
- *
- * $(GRAMMAR )
- */
- DefaultStatement parseDefaultStatement()
- {
- auto node = new DefaultStatement;
+ /**
+ * Parses an DefaultStatement
+ *
+ * $(GRAMMAR )
+ */
+ DefaultStatement parseDefaultStatement()
+ {
+ auto node = new DefaultStatement;
- return node;
- }
+ return node;
+ }
- /**
- * Parses an DeleteExpression
- *
- * $(GRAMMAR )
- */
- DeleteExpression parseDeleteExpression()
- {
- auto node = new DeleteExpression;
+ /**
+ * Parses an DeleteExpression
+ *
+ * $(GRAMMAR )
+ */
+ DeleteExpression parseDeleteExpression()
+ {
+ auto node = new DeleteExpression;
- return node;
- }
+ return node;
+ }
- /**
- * Parses an DeleteStatement
- *
- * $(GRAMMAR )
- */
- DeleteStatement parseDeleteStatement()
- {
- auto node = new DeleteStatement;
+ /**
+ * Parses an DeleteStatement
+ *
+ * $(GRAMMAR )
+ */
+ DeleteStatement parseDeleteStatement()
+ {
+ auto node = new DeleteStatement;
- return node;
- }
+ return node;
+ }
- /**
- * Parses a Deprecated attribute
- *
- * $(GRAMMAR deprecated: 'deprecated' ('(' assignExpression ')')?
+ /**
+ * Parses a Deprecated attribute
+ *
+ * $(GRAMMAR $(RULEDEF deprecated):
+ * $(LITERAL 'deprecated') ($(LITERAL '$(LPAREN)') $(RULE assignExpression) $(LITERAL '$(RPAREN)'))?
* ;)
- */
- Deprecated parseDeprecated()
- {
- auto node = new Deprecated;
+ */
+ Deprecated parseDeprecated()
+ {
+ auto node = new Deprecated;
expect(TokenType.deprecated_);
if (currentIs(TokenType.lParen))
{
@@ -1192,274 +1267,319 @@ struct Parser
node.assignExpression = parseAssignExpression();
expect(TokenType.rParen);
}
- return node;
- }
+ return node;
+ }
- /**
- * Parses a Destructor
- *
- * $(GRAMMAR destructor: '~' 'this' '(' ')' functionBody
+ /**
+ * Parses a Destructor
+ *
+ * $(GRAMMAR $(RULEDEF destructor):
+ * $(LITERAL '~') $(LITERAL 'this') $(LITERAL '$(LPAREN)') $(LITERAL '$(RPAREN)') $(RULE functionBody)
* ;)
- */
- Destructor parseDestructor()
- {
- auto node = new Destructor;
+ */
+ Destructor parseDestructor()
+ {
+ auto node = new Destructor;
expect(TokenType.tilde);
expect(TokenType.this_);
expect(TokenType.lParen);
expect(TokenType.rParen);
node.functionBody = parseFunctionBody();
- return node;
- }
+ return node;
+ }
- /**
- * Parses an DoStatement
- *
- * $(GRAMMAR )
- */
- DoStatement parseDoStatement()
- {
- auto node = new DoStatement;
-
- return node;
- }
-
- /**
- * Parses an EnumBody
- *
- * $(GRAMMAR )
- */
- EnumBody parseEnumBody()
- {
- auto node = new EnumBody;
-
- return node;
- }
-
- /**
- * Parses an EnumDeclaration
- *
- * $(GRAMMAR )
- */
- EnumDeclaration parseEnumDeclaration()
- {
- auto node = new EnumDeclaration;
-
- return node;
- }
-
- /**
- * Parses an EnumMember
- *
- * $(GRAMMAR )
- */
- EnumMember parseEnumMember()
- {
- auto node = new EnumMember;
-
- return node;
- }
-
- /**
- * Parses an EqualExpression
- *
- * $(GRAMMAR )
- */
- EqualExpression parseEqualExpression()
- {
- auto node = new EqualExpression;
-
- return node;
- }
-
- /**
- * Parses an Expression
- *
- * $(GRAMMAR )
- */
- Expression parseExpression()
- {
- auto node = new Expression;
-
- return node;
- }
-
- /**
- * Parses an FinalSwitchStatement
- *
- * $(GRAMMAR )
- */
- FinalSwitchStatement parseFinalSwitchStatement()
- {
- auto node = new FinalSwitchStatement;
-
- return node;
- }
-
- /**
- * Parses an Finally
- *
- * $(GRAMMAR )
- */
- Finally parseFinally()
- {
- auto node = new Finally;
-
- return node;
- }
-
- /**
- * Parses an ForStatement
- *
- * $(GRAMMAR )
- */
- ForStatement parseForStatement()
- {
- auto node = new ForStatement;
-
- return node;
- }
-
- /**
- * Parses an ForeachRangeStatement
- *
- * $(GRAMMAR )
- */
- ForeachRangeStatement parseForeachRangeStatement()
- {
- auto node = new ForeachRangeStatement;
-
- return node;
- }
-
- /**
- * Parses an ForeachStatement
- *
- * $(GRAMMAR )
- */
- ForeachStatement parseForeachStatement()
- {
- auto node = new ForeachStatement;
-
- return node;
- }
-
- /**
- * Parses an ForeachType
- *
- * $(GRAMMAR )
- */
- ForeachType parseForeachType()
- {
- auto node = new ForeachType;
-
- return node;
- }
-
- /**
- * Parses an ForeachTypeList
- *
- * $(GRAMMAR )
- */
- ForeachTypeList parseForeachTypeList()
- {
- auto node = new ForeachTypeList;
-
- return node;
- }
-
- /**
- * Parses an FunctionAttribute
- *
- * $(GRAMMAR )
- */
- FunctionAttribute parseFunctionAttribute()
- {
- auto node = new FunctionAttribute;
-
- return node;
- }
-
- /**
- * Parses an FunctionBody
- *
- * $(GRAMMAR )
- */
- FunctionBody parseFunctionBody()
- {
- auto node = new FunctionBody;
-
- return node;
- }
-
- /**
- * Parses an FunctionCallExpression
- *
- * $(GRAMMAR )
- */
- FunctionCallExpression parseFunctionCallExpression()
- {
- auto node = new FunctionCallExpression;
-
- return node;
- }
-
- /**
- * Parses an FunctionCallStatement
- *
- * $(GRAMMAR )
- */
- FunctionCallStatement parseFunctionCallStatement()
- {
- auto node = new FunctionCallStatement;
-
- return node;
- }
-
- /**
- * Parses an FunctionDeclaration
- *
- * $(GRAMMAR )
- */
- FunctionDeclaration parseFunctionDeclaration()
- {
- auto node = new FunctionDeclaration;
-
- return node;
- }
-
- /**
- * Parses an FunctionLiteralExpression
- *
- * $(GRAMMAR )
- */
- FunctionLiteralExpression parseFunctionLiteralExpression()
- {
- auto node = new FunctionLiteralExpression;
-
- return node;
- }
-
- /**
- * Parses an GotoStatement
- *
- * $(GRAMMAR )
- */
- GotoStatement parseGotoStatement()
- {
- auto node = new GotoStatement;
- return node;
- }
-
- /**
- * Parses an IdentifierChain
- *
- * $(GRAMMAR identifierChain: Identifier ('.' Identifier)*
+ /**
+ * Parses a DoStatement
+ *
+ * $(GRAMMAR $(RULEDEF doStatement):
+ * $(LITERAL 'do') $(RULE blockStatement) $(LITERAL 'while') $(LITERAL '$(LPAREN)') $(RULE expression) $(LITERAL '$(RPAREN)') $(LITERAL ';')
* ;)
- */
- IdentifierChain parseIdentifierChain()
- {
- auto node = new IdentifierChain;
+ */
+ DoStatement parseDoStatement()
+ {
+ auto node = new DoStatement;
+ expect(TokenType.do_);
+ node.blockStatement = parseBlockStatement();
+ expect(TokenType.while_);
+ expect(TokenType.lParen);
+ node.expression = parseExpression();
+ expect(TokenType.rParen);
+ expect(TokenType.semicolon);
+ return node;
+ }
+
+ /**
+ * Parses an EnumBody
+ *
+ * $(GRAMMAR $(RULEDEF enumBody):
+ * $(LITERAL ';')
+ * | $(LITERAL '{') $(RULE enumMember) ($(LITERAL ',') $(RULE enumMember)?)* $(LITERAL '}')
+ * ;)
+ */
+ EnumBody parseEnumBody()
+ {
+ auto node = new EnumBody;
+ if (!currentIs(TokenType.semicolon))
+ {
+ expect (TokenType.lBrace);
+ while (moreTokens())
+ {
+ if (!currentIs(TokenType.comma))
+ node.enumMembers ~= parseEnumMember();
+ if (currentIs(TokenType.comma))
+ continue;
+ else if (currentIs(TokenType.rBrace))
+ break;
+ else
+ {
+ error(`",", "}" or enum member expected`);
+ goto ret;
+ }
+ }
+ expect (TokenType.rBrace);
+ }
+ ret:
+ return node;
+ }
+
+ /**
+ * Parses an EnumDeclaration
+ *
+ * $(GRAMMAR $(RULEDEF enumDeclaration):
+ * $(LITERAL 'enum') $(LITERAL Identifier)? ($(LITERAL ':') $(RULE type))? $(RULE enumBody)
+ * ;)
+ */
+ EnumDeclaration parseEnumDeclaration()
+ {
+ auto node = new EnumDeclaration;
+ expect(TokenType.enum_);
+ if (currentIs(TokenType.identifier))
+ node.identifier = advance();
+ if (currentIs(TokenType.colon))
+ {
+ advance();
+ node.type = parseType();
+ }
+ node.enumBody = parseEnumBody();
+ return node;
+ }
+
+ /**
+ * Parses an EnumMember
+ *
+ * $(GRAMMAR $(RULEDEF enumMember):
+ * $(LITERAL Identifier)
+ * | ($(LITERAL Identifier) | $(RULE type)) $(LITERAL '=') $(RULE assignExpression)
+ * ;)
+ */
+ EnumMember parseEnumMember()
+ {
+ auto node = new EnumMember;
+ // TODO
+ return node;
+ }
+
+ /**
+ * Parses an EqualExpression
+ *
+ * $(GRAMMAR )
+ */
+ EqualExpression parseEqualExpression()
+ {
+ auto node = new EqualExpression;
+
+ return node;
+ }
+
+ /**
+ * Parses an Expression
+ *
+ * $(GRAMMAR )
+ */
+ Expression parseExpression()
+ {
+ auto node = new Expression;
+
+ return node;
+ }
+
+ /**
+ * Parses an FinalSwitchStatement
+ *
+ * $(GRAMMAR )
+ */
+ FinalSwitchStatement parseFinalSwitchStatement()
+ {
+ auto node = new FinalSwitchStatement;
+
+ return node;
+ }
+
+ /**
+ * Parses an Finally
+ *
+ * $(GRAMMAR )
+ */
+ Finally parseFinally()
+ {
+ auto node = new Finally;
+
+ return node;
+ }
+
+ /**
+ * Parses an ForStatement
+ *
+ * $(GRAMMAR )
+ */
+ ForStatement parseForStatement()
+ {
+ auto node = new ForStatement;
+
+ return node;
+ }
+
+ /**
+ * Parses an ForeachRangeStatement
+ *
+ * $(GRAMMAR )
+ */
+ ForeachRangeStatement parseForeachRangeStatement()
+ {
+ auto node = new ForeachRangeStatement;
+
+ return node;
+ }
+
+ /**
+ * Parses an ForeachStatement
+ *
+ * $(GRAMMAR )
+ */
+ ForeachStatement parseForeachStatement()
+ {
+ auto node = new ForeachStatement;
+
+ return node;
+ }
+
+ /**
+ * Parses an ForeachType
+ *
+ * $(GRAMMAR )
+ */
+ ForeachType parseForeachType()
+ {
+ auto node = new ForeachType;
+
+ return node;
+ }
+
+ /**
+ * Parses an ForeachTypeList
+ *
+ * $(GRAMMAR )
+ */
+ ForeachTypeList parseForeachTypeList()
+ {
+ auto node = new ForeachTypeList;
+
+ return node;
+ }
+
+ /**
+ * Parses an FunctionAttribute
+ *
+ * $(GRAMMAR )
+ */
+ FunctionAttribute parseFunctionAttribute()
+ {
+ auto node = new FunctionAttribute;
+
+ return node;
+ }
+
+ /**
+ * Parses an FunctionBody
+ *
+ * $(GRAMMAR )
+ */
+ FunctionBody parseFunctionBody()
+ {
+ auto node = new FunctionBody;
+
+ return node;
+ }
+
+ /**
+ * Parses an FunctionCallExpression
+ *
+ * $(GRAMMAR )
+ */
+ FunctionCallExpression parseFunctionCallExpression()
+ {
+ auto node = new FunctionCallExpression;
+
+ return node;
+ }
+
+ /**
+ * Parses an FunctionCallStatement
+ *
+ * $(GRAMMAR )
+ */
+ FunctionCallStatement parseFunctionCallStatement()
+ {
+ auto node = new FunctionCallStatement;
+
+ return node;
+ }
+
+ /**
+ * Parses an FunctionDeclaration
+ *
+ * $(GRAMMAR )
+ */
+ FunctionDeclaration parseFunctionDeclaration()
+ {
+ auto node = new FunctionDeclaration;
+
+ return node;
+ }
+
+ /**
+ * Parses an FunctionLiteralExpression
+ *
+ * $(GRAMMAR )
+ */
+ FunctionLiteralExpression parseFunctionLiteralExpression()
+ {
+ auto node = new FunctionLiteralExpression;
+
+ return node;
+ }
+
+ /**
+ * Parses an GotoStatement
+ *
+ * $(GRAMMAR )
+ */
+ GotoStatement parseGotoStatement()
+ {
+ auto node = new GotoStatement;
+ return node;
+ }
+
+ /**
+ * Parses an IdentifierChain
+ *
+ * $(GRAMMAR $(RULEDEF identifierChain):
+ * $(LITERAL Identifier) ($(LITERAL '.') $(LITERAL Identifier))*
+ * ;)
+ */
+ IdentifierChain parseIdentifierChain()
+ {
+ auto node = new IdentifierChain;
while (true)
{
node.identifiers ~= *expect(TokenType.identifier);
@@ -1471,18 +1591,31 @@ struct Parser
else
break;
}
- return node;
- }
+ return node;
+ }
- /**
- * Parses an IdentifierList
- *
- * $(GRAMMAR identifierList: Identifier (',' Identifier)*
+ unittest
+ {
+ auto input = cast(ubyte[]) "abcde.frocegu.creou.faowe"c;
+ LexerConfig config;
+ auto tokens = byToken(input, config);
+ Parser p;
+ p.fileName = "test";
+ p.tokens = tokens.array();
+ auto chain = p.parseIdentifierChain();
+ assert (chain.identifiers == ["abcde", "frocegu", "creou", "faowe"]);
+ }
+
+ /**
+ * Parses an IdentifierList
+ *
+ * $(GRAMMAR $(RULEDEF identifierList):
+ * $(LITERAL Identifier) ($(LITERAL ',') $(LITERAL Identifier))*
* ;)
- */
- IdentifierList parseIdentifierList()
- {
- auto node = new IdentifierList;
+ */
+ IdentifierList parseIdentifierList()
+ {
+ auto node = new IdentifierList;
while (true)
{
node.identifiers ~= *expect(TokenType.identifier);
@@ -1494,271 +1627,286 @@ struct Parser
else
break;
}
- return node;
- }
+ return node;
+ }
- /**
- * Parses an IdentifierOrTemplateChain
- *
- * $(GRAMMAR )
- */
- IdentifierOrTemplateChain parseIdentifierOrTemplateChain()
- {
- auto node = new IdentifierOrTemplateChain;
+ /**
+ * Parses an IdentifierOrTemplateChain
+ *
+ * $(GRAMMAR )
+ */
+ IdentifierOrTemplateChain parseIdentifierOrTemplateChain()
+ {
+ auto node = new IdentifierOrTemplateChain;
- return node;
- }
+ return node;
+ }
- /**
- * Parses an IdentifierOrTemplateInstance
- *
- * $(GRAMMAR )
- */
- IdentifierOrTemplateInstance parseIdentifierOrTemplateInstance()
- {
- auto node = new IdentifierOrTemplateInstance;
+ /**
+ * Parses an IdentifierOrTemplateInstance
+ *
+ * $(GRAMMAR )
+ */
+ IdentifierOrTemplateInstance parseIdentifierOrTemplateInstance()
+ {
+ auto node = new IdentifierOrTemplateInstance;
- return node;
- }
+ return node;
+ }
- /**
- * Parses an IdentityExpression
- *
- * $(GRAMMAR )
- */
- IdentityExpression parseIdentityExpression()
- {
- auto node = new IdentityExpression;
+ /**
+ * Parses an IdentityExpression
+ *
+ * $(GRAMMAR )
+ */
+ IdentityExpression parseIdentityExpression()
+ {
+ auto node = new IdentityExpression;
- return node;
- }
+ return node;
+ }
- /**
- * Parses an IfStatement
- *
- * $(GRAMMAR )
- */
- IfStatement parseIfStatement()
- {
- auto node = new IfStatement;
+ /**
+ * Parses an IfStatement
+ *
+ * $(GRAMMAR )
+ */
+ IfStatement parseIfStatement()
+ {
+ auto node = new IfStatement;
- return node;
- }
+ return node;
+ }
- /**
- * Parses an ImportBind
- *
- * $(GRAMMAR )
- */
- ImportBind parseImportBind()
- {
- auto node = new ImportBind;
+ /**
+ * Parses an ImportBind
+ *
+ * $(GRAMMAR )
+ */
+ ImportBind parseImportBind()
+ {
+ auto node = new ImportBind;
- return node;
- }
+ return node;
+ }
- /**
- * Parses an ImportBindings
- *
- * $(GRAMMAR )
- */
- ImportBindings parseImportBindings()
- {
- auto node = new ImportBindings;
+ /**
+ * Parses an ImportBindings
+ *
+ * $(GRAMMAR )
+ */
+ ImportBindings parseImportBindings()
+ {
+ auto node = new ImportBindings;
- return node;
- }
+ return node;
+ }
- /**
- * Parses an ImportDeclaration
- *
- * $(GRAMMAR )
- */
- ImportDeclaration parseImportDeclaration()()
- {
- auto node = new ImportDeclaration;
+ /**
+ * Parses an ImportDeclaration
+ *
+ * $(GRAMMAR )
+ */
+ ImportDeclaration parseImportDeclaration()()
+ {
+ auto node = new ImportDeclaration;
- return node;
- }
+ return node;
+ }
- /**
- * Parses an ImportExpression
- *
- * $(GRAMMAR )
- */
- ImportExpression parseImportExpression()
- {
- auto node = new ImportExpression;
+ /**
+ * Parses an ImportExpression
+ *
+ * $(GRAMMAR )
+ */
+ ImportExpression parseImportExpression()
+ {
+ auto node = new ImportExpression;
- return node;
- }
+ return node;
+ }
- /**
- * Parses an ImportList
- *
- * $(GRAMMAR )
- */
- ImportList parseImportList()
- {
- auto node = new ImportList;
+ /**
+ * Parses an ImportList
+ *
+ * $(GRAMMAR )
+ */
+ ImportList parseImportList()
+ {
+ auto node = new ImportList;
- return node;
- }
+ return node;
+ }
- /**
- * Parses an InExpression
- *
- * $(GRAMMAR )
- */
- InExpression parseInExpression()
- {
- auto node = new InExpression;
+ /**
+ * Parses an IndexExpression
+ *
+ * $(GRAMMAR $(RULEDEF indexExpression):
+ * $(RULE unaryExpression) $(LITERAL '[') $(RULE argumentList) $(LITERAL ']')
+ * ;)
+ */
+ IndexExpression parseImportList()
+ {
+ auto node = new IndexExpression;
- return node;
- }
+ return node;
+ }
- /**
- * Parses an InStatement
- *
- * $(GRAMMAR )
- */
- InStatement parseInStatement()
- {
- auto node = new InStatement;
+ /**
+ * Parses an InExpression
+ *
+ * $(GRAMMAR )
+ */
+ InExpression parseInExpression()
+ {
+ auto node = new InExpression;
- return node;
- }
+ return node;
+ }
- /**
- * Parses an Initialize
- *
- * $(GRAMMAR )
- */
- Initialize parseInitialize()
- {
- auto node = new Initialize;
+ /**
+ * Parses an InStatement
+ *
+ * $(GRAMMAR )
+ */
+ InStatement parseInStatement()
+ {
+ auto node = new InStatement;
- return node;
- }
+ return node;
+ }
- /**
- * Parses an Initializer
- *
- * $(GRAMMAR )
- */
- Initializer parseInitializer()
- {
- auto node = new Initializer;
+ /**
+ * Parses an Initialize
+ *
+ * $(GRAMMAR )
+ */
+ Initialize parseInitialize()
+ {
+ auto node = new Initialize;
- return node;
- }
+ return node;
+ }
- /**
- * Parses an InterfaceDeclaration
- *
- * $(GRAMMAR )
- */
- InterfaceDeclaration parseInterfaceDeclaration()
- {
- auto node = new InterfaceDeclaration;
- return node;
- }
+ /**
+ * Parses an Initializer
+ *
+ * $(GRAMMAR )
+ */
+ Initializer parseInitializer()
+ {
+ auto node = new Initializer;
- /**
- * Parses an Invariant
- *
- * $(GRAMMAR )
- */
- Invariant parseInvariant()
- {
- auto node = new Invariant;
+ return node;
+ }
- return node;
- }
+ /**
+ * Parses an InterfaceDeclaration
+ *
+ * $(GRAMMAR )
+ */
+ InterfaceDeclaration parseInterfaceDeclaration()
+ {
+ auto node = new InterfaceDeclaration;
+ return node;
+ }
- /**
- * Parses an IsExpression
- *
- * $(GRAMMAR )
- */
- IsExpression parseIsExpression()
- {
- auto node = new IsExpression;
+ /**
+ * Parses an Invariant
+ *
+ * $(GRAMMAR )
+ */
+ Invariant parseInvariant()
+ {
+ auto node = new Invariant;
- return node;
- }
+ return node;
+ }
- /**
- * Parses an KeyValuePair
- *
- * $(GRAMMAR )
- */
- KeyValuePair parseKeyValuePair()
- {
- auto node = new KeyValuePair;
+ /**
+ * Parses an IsExpression
+ *
+ * $(GRAMMAR )
+ */
+ IsExpression parseIsExpression()
+ {
+ auto node = new IsExpression;
- return node;
- }
+ return node;
+ }
- /**
- * Parses an KeyValuePairs
- *
- * $(GRAMMAR )
- */
- KeyValuePairs parseKeyValuePairs()
- {
- auto node = new KeyValuePairs;
+ /**
+ * Parses an KeyValuePair
+ *
+ * $(GRAMMAR )
+ */
+ KeyValuePair parseKeyValuePair()
+ {
+ auto node = new KeyValuePair;
- return node;
- }
+ return node;
+ }
- /**
- * Parses an LabeledStatement
- *
- * $(GRAMMAR )
- */
- LabeledStatement parseLabeledStatement()
- {
- auto node = new LabeledStatement;
- node.identifier = *expect(TokenType.identifier);
- expect(TokenType.colon);
- node.statement = parseStatement();
- return node;
- }
+ /**
+ * Parses an KeyValuePairs
+ *
+ * $(GRAMMAR )
+ */
+ KeyValuePairs parseKeyValuePairs()
+ {
+ auto node = new KeyValuePairs;
- /**
- * Parses an LambdaExpression
- *
- * $(GRAMMAR )
- */
- LambdaExpression parseLambdaExpression()
- {
- auto node = new LambdaExpression;
+ return node;
+ }
- return node;
- }
+ /**
+ * Parses an LabeledStatement
+ *
+ * $(GRAMMAR )
+ */
+ LabeledStatement parseLabeledStatement()
+ {
+ auto node = new LabeledStatement;
+ node.identifier = *expect(TokenType.identifier);
+ expect(TokenType.colon);
+ node.statement = parseStatement();
+ return node;
+ }
- /**
- * Parses an LastCatch
- *
- * $(GRAMMAR )
- */
- LastCatch parseLastCatch()
- {
- auto node = new LastCatch;
+ /**
+ * Parses an LambdaExpression
+ *
+ * $(GRAMMAR )
+ */
+ LambdaExpression parseLambdaExpression()
+ {
+ auto node = new LambdaExpression;
- return node;
- }
+ return node;
+ }
- /**
- * Parses an LinkageAttribute
- *
- * $(GRAMMAR linkageAttribute: 'extern' '(' Identifier '++'? ')'
+ /**
+ * Parses an LastCatch
+ *
+ * $(GRAMMAR )
+ */
+ LastCatch parseLastCatch()
+ {
+ auto node = new LastCatch;
+
+ return node;
+ }
+
+ /**
+ * Parses an LinkageAttribute
+ *
+ * $(GRAMMAR $(RULEDEF linkageAttribute):
+ * $(LITERAL 'extern') $(LITERAL '$(LPAREN)') $(LITERAL Identifier) $(LITERAL '++')? $(LITERAL '$(RPAREN)')
* ;)
- */
- LinkageAttribute parseLinkageAttribute()
- {
- auto node = new LinkageAttribute;
+ */
+ LinkageAttribute parseLinkageAttribute()
+ {
+ auto node = new LinkageAttribute;
expect(TokenType.extern_);
expect(TokenType.lParen);
node.identifier = *expect(TokenType.identifier);
@@ -1768,1178 +1916,1205 @@ struct Parser
node.hasPlusPlus = true;
}
expect(TokenType.rParen);
- return node;
- }
+ return node;
+ }
- /**
- * Parses an MemberFunctionAttribute
- *
- * $(GRAMMAR )
- */
- MemberFunctionAttribute parseMemberFunctionAttribute()
- {
- auto node = new MemberFunctionAttribute;
+ /**
+ * Parses an MemberFunctionAttribute
+ *
+ * $(GRAMMAR )
+ */
+ MemberFunctionAttribute parseMemberFunctionAttribute()
+ {
+ auto node = new MemberFunctionAttribute;
- return node;
- }
+ return node;
+ }
- /**
- * Parses an MixinDeclaration
- *
- * $(GRAMMAR mixinDeclaration: mixinExpression ';'
+ /**
+ * Parses an MixinDeclaration
+ *
+ * $(GRAMMAR $(RULEDEF mixinDeclaration):
+ * $(RULE mixinExpression) $(LITERAL ';')
* ;)
- */
- MixinDeclaration parseMixinDeclaration()
- {
- auto node = new MixinDeclaration;
+ */
+ MixinDeclaration parseMixinDeclaration()
+ {
+ auto node = new MixinDeclaration;
node.mixinExpression = parseMixinExpression();
expect(TokenType.semicolon);
- return node;
- }
+ return node;
+ }
- /**
- * Parses an MixinExpression
- *
- * $(GRAMMAR )
- */
- MixinExpression parseMixinExpression()
- {
- auto node = new MixinExpression;
+ /**
+ * Parses an MixinExpression
+ *
+ * $(GRAMMAR )
+ */
+ MixinExpression parseMixinExpression()
+ {
+ auto node = new MixinExpression;
- return node;
- }
+ return node;
+ }
- /**
- * Parses an MixinTemplateName
- *
- * $(GRAMMAR )
- */
- MixinTemplateName parseMixinTemplateName()
- {
- auto node = new MixinTemplateName;
+ /**
+ * Parses an MixinTemplateName
+ *
+ * $(GRAMMAR )
+ */
+ MixinTemplateName parseMixinTemplateName()
+ {
+ auto node = new MixinTemplateName;
- return node;
- }
+ return node;
+ }
- /**
- * Parses a Module
- *
- * $(GRAMMAR module: moduleDeclaration? declaration*
- * ;)
- */
- Module parseModule()
- {
- Module m = new Module;
- while (index < tokens.length)
- {
- switch (tokens[index].type)
- {
- case TokenType.module_:
- if (m.moduleDeclaration is null)
- m.moduleDeclaration = parseModuleDeclaration();
- else
- error("Only one module declaration is allowed per module");
- break;
- default:
- m.declarations ~= parseDeclaration();
- }
- }
- return m;
- }
-
- /**
- * Parses a ModuleDeclaration
- *
- * $(GRAMMAR moduleDeclaration: 'module' identifierChain ';'
- * ;)
- */
- ModuleDeclaration parseModuleDeclaration()
- {
- auto node = new ModuleDeclaration;
- expect(TokenType.module_);
- node.moduleName = parseIdentifierChain();
- expect(TokenType.semicolon);
- return node;
- }
-
- /**
- * Parses a MulExpression
- * $(GRAMMAR mulExpression: unaryExpression
- * | mulExpression ('*' | '/' | '%') unaryExpression
- * ;)
- */
- MulExpression parseMulExpression()
- {
- auto node = new MulExpression;
- auto left = parseUnaryExpression();
- if (tokens[index] == TokenType.star || tokens[index] == TokenType.div)
- {
- node.operator = tokens[index++];
- node.right = parseUnaryExpression();
- }
- return node;
- }
-
- /**
- * Parses an NewAnonClassExpression
- *
- * $(GRAMMAR )
- */
- NewAnonClassExpression parseNewAnonClassExpression()
- {
- auto node = new NewAnonClassExpression;
-
- return node;
- }
-
- /**
- * Parses an NewExpression
- *
- * $(GRAMMAR )
- */
- NewExpression parseNewExpression()
- {
- auto node = new NewExpression;
-
- return node;
- }
-
- /**
- * Parses an NonEmptyStatement
- *
- * $(GRAMMAR )
- */
- NonEmptyStatement parseNonEmptyStatement()
- {
- auto node = new NonEmptyStatement;
- return node;
- }
-
- /**
- * Parses an NonEmptyStatementNoCaseNoDefault
- *
- * $(GRAMMAR )
- */
- NonEmptyStatementNoCaseNoDefault parseNonEmptyStatementNoCaseNoDefault()
- {
- auto node = new NonEmptyStatementNoCaseNoDefault;
-
- return node;
- }
-
- /**
- * Parses an NonVoidInitializer
- *
- * $(GRAMMAR )
- */
- NonVoidInitializer parseNonVoidInitializer()
- {
- auto node = new NonVoidInitializer;
-
- return node;
- }
-
- /**
- * Parses an Opcode
- *
- * $(GRAMMAR )
- */
- Opcode parseOpcode()
- {
- auto node = new Opcode;
-
- return node;
- }
-
- /**
- * Parses an Operand
- *
- * $(GRAMMAR )
- */
- Operand parseOperand()
- {
- auto node = new Operand;
-
- return node;
- }
-
- /**
- * Parses an Operands
- *
- * $(GRAMMAR )
- */
- Operands parseOperands()
- {
- auto node = new Operands;
-
- return node;
- }
-
- /**
- * Parses an OrExpression
- *
- * $(GRAMMAR )
- */
- OrExpression parseOrExpression()
- {
- auto node = new OrExpression;
-
- return node;
- }
-
- /**
- * Parses an OrOrExpression
- *
- * $(GRAMMAR )
- */
- OrOrExpression parseOrOrExpression()
- {
- auto node = new OrOrExpression;
-
- return node;
- }
-
- /**
- * Parses an OutStatement
- *
- * $(GRAMMAR )
- */
- OutStatement parseOutStatement()
- {
- auto node = new OutStatement;
-
- return node;
- }
-
- /**
- * Parses an Parameter
- *
- * $(GRAMMAR )
- */
- Parameter parseParameter()
- {
- auto node = new Parameter;
-
- return node;
- }
-
- /**
- * Parses an ParameterAttribute
- *
- * $(GRAMMAR )
- */
- ParameterAttribute parseParameterAttribute()
- {
- auto node = new ParameterAttribute;
-
- return node;
- }
-
- /**
- * Parses an Parameters
- *
- * $(GRAMMAR )
- */
- Parameters parseParameters()
- {
- auto node = new Parameters;
-
- return node;
- }
-
- /**
- * Parses an PostIncDecExpression
- *
- * $(GRAMMAR )
- */
- PostIncDecExpression parsePostIncDecExpression()
- {
- auto node = new PostIncDecExpression;
-
- return node;
- }
-
- /**
- * Parses an PowExpression
- *
- * $(GRAMMAR )
- */
- PowExpression parsePowExpression()
- {
- auto node = new PowExpression;
-
- return node;
- }
-
- /**
- * Parses an PragmaDeclaration
- *
- * $(GRAMMAR )
- */
- PragmaDeclaration parsePragmaDeclaration()
- {
- auto node = new PragmaDeclaration;
-
- return node;
- }
-
- /**
- * Parses an PragmaExpression
- *
- * $(GRAMMAR )
- */
- PragmaExpression parsePragmaExpression()
- {
- auto node = new PragmaExpression;
-
- return node;
- }
-
- /**
- * Parses an PreIncDecExpression
- *
- * $(GRAMMAR )
- */
- PreIncDecExpression parsePreIncDecExpression()
- {
- auto node = new PreIncDecExpression;
-
- return node;
- }
-
- /**
- * Parses an PrimaryExpression
- *
- * $(GRAMMAR )
- */
- PrimaryExpression parsePrimaryExpression()
- {
- auto node = new PrimaryExpression;
-
- return node;
- }
-
- /**
- * Parses an ProtectionAttribute
- *
- * $(GRAMMAR )
- */
- ProtectionAttribute parseProtectionAttribute()
- {
- auto node = new ProtectionAttribute;
-
- return node;
- }
-
- /**
- * Parses an Register
- *
- * $(GRAMMAR )
- */
- Register parseRegister()
- {
- auto node = new Register;
-
- return node;
- }
-
- /**
- * Parses an RelExpression
- *
- * $(GRAMMAR )
- */
- RelExpression parseRelExpression()
- {
- auto node = new RelExpression;
-
- return node;
- }
-
- /**
- * Parses an ReturnStatement
- *
- * $(GRAMMAR )
- */
- ReturnStatement parseReturnStatement()
- {
- auto node = new ReturnStatement;
- expect(TokenType.return_);
- if (tokens[index] != TokenType.semicolon)
- node.expression = parseExpression();
- expect(TokenType.semicolon);
- return node;
- }
-
- /**
- * Parses an ScopeGuardStatement
- *
- * $(GRAMMAR )
- */
- ScopeGuardStatement parseScopeGuardStatement()
- {
- auto node = new ScopeGuardStatement;
-
- return node;
- }
-
- /**
- * Parses an SharedStaticConstructor
- *
- * $(GRAMMAR )
- */
- SharedStaticConstructor parseSharedStaticConstructor()
- {
- auto node = new SharedStaticConstructor;
-
- return node;
- }
-
- /**
- * Parses an SharedStaticDestructor
- *
- * $(GRAMMAR )
- */
- SharedStaticDestructor parseSharedStaticDestructor()
- {
- auto node = new SharedStaticDestructor;
-
- return node;
- }
-
- /**
- * Parses an ShiftExpression
- *
- * $(GRAMMAR )
- */
- ShiftExpression parseShiftExpression()
- {
- auto node = new ShiftExpression;
-
- return node;
- }
-
- /**
- * Parses an SingleImport
- *
- * $(GRAMMAR )
- */
- SingleImport parseSingleImport()
- {
- auto node = new SingleImport;
-
- return node;
- }
-
- /**
- * Parses a Statement
- *
- * $(GRAMMAR statement: ';'
- * | nonEmptyStatement
+ /**
+ * Parses a Module
+ *
+ * $(GRAMMAR $(RULEDEF module):
+ * $(RULE moduleDeclaration)? $(RULE declaration)*
* ;)
- */
- Statement parseStatement()
- {
- auto node = new Statement;
- if (currentIs(TokenType.semicolon))
+ */
+ Module parseModule()
+ {
+ Module m = new Module;
+ while (index < tokens.length)
+ {
+ switch (tokens[index].type)
+ {
+ case TokenType.module_:
+ if (m.moduleDeclaration is null)
+ m.moduleDeclaration = parseModuleDeclaration();
+ else
+ error("Only one module declaration is allowed per module");
+ break;
+ default:
+ m.declarations ~= parseDeclaration();
+ }
+ }
+ return m;
+ }
+
+ /**
+ * Parses a ModuleDeclaration
+ *
+ * $(GRAMMAR $(RULEDEF moduleDeclaration):
+ * $(LITERAL 'module') $(RULE identifierChain) $(LITERAL ';')
+ * ;)
+ */
+ ModuleDeclaration parseModuleDeclaration()
+ {
+ auto node = new ModuleDeclaration;
+ expect(TokenType.module_);
+ node.moduleName = parseIdentifierChain();
+ expect(TokenType.semicolon);
+ return node;
+ }
+
+ /**
+ * Parses a MulExpression
+ * $(GRAMMAR $(RULEDEF mulExpression):
+ * $(RULE unaryExpression)
+ * | $(RULE mulExpression) ($(LITERAL '*') | $(LITERAL '/') | $(LITERAL '%')) $(RULE unaryExpression)
+ * ;)
+ */
+ MulExpression parseMulExpression()
+ {
+ auto node = new MulExpression;
+ auto left = parseUnaryExpression();
+ if (tokens[index] == TokenType.star || tokens[index] == TokenType.div)
+ {
+ node.operator = tokens[index++];
+ node.right = parseUnaryExpression();
+ }
+ return node;
+ }
+
+ /**
+ * Parses an NewAnonClassExpression
+ *
+ * $(GRAMMAR )
+ */
+ NewAnonClassExpression parseNewAnonClassExpression()
+ {
+ auto node = new NewAnonClassExpression;
+
+ return node;
+ }
+
+ /**
+ * Parses an NewExpression
+ *
+ * $(GRAMMAR )
+ */
+ NewExpression parseNewExpression()
+ {
+ auto node = new NewExpression;
+
+ return node;
+ }
+
+ /**
+ * Parses an NonEmptyStatement
+ *
+ * $(GRAMMAR )
+ */
+ NonEmptyStatement parseNonEmptyStatement()
+ {
+ auto node = new NonEmptyStatement;
+ return node;
+ }
+
+ /**
+ * Parses an NonEmptyStatementNoCaseNoDefault
+ *
+ * $(GRAMMAR )
+ */
+ NonEmptyStatementNoCaseNoDefault parseNonEmptyStatementNoCaseNoDefault()
+ {
+ auto node = new NonEmptyStatementNoCaseNoDefault;
+
+ return node;
+ }
+
+ /**
+ * Parses an NonVoidInitializer
+ *
+ * $(GRAMMAR )
+ */
+ NonVoidInitializer parseNonVoidInitializer()
+ {
+ auto node = new NonVoidInitializer;
+
+ return node;
+ }
+
+ /**
+ * Parses an Opcode
+ *
+ * $(GRAMMAR )
+ */
+ Opcode parseOpcode()
+ {
+ auto node = new Opcode;
+
+ return node;
+ }
+
+ /**
+ * Parses an Operand
+ *
+ * $(GRAMMAR )
+ */
+ Operand parseOperand()
+ {
+ auto node = new Operand;
+
+ return node;
+ }
+
+ /**
+ * Parses an Operands
+ *
+ * $(GRAMMAR )
+ */
+ Operands parseOperands()
+ {
+ auto node = new Operands;
+
+ return node;
+ }
+
+ /**
+ * Parses an OrExpression
+ *
+ * $(GRAMMAR )
+ */
+ OrExpression parseOrExpression()
+ {
+ auto node = new OrExpression;
+
+ return node;
+ }
+
+ /**
+ * Parses an OrOrExpression
+ *
+ * $(GRAMMAR )
+ */
+ OrOrExpression parseOrOrExpression()
+ {
+ auto node = new OrOrExpression;
+
+ return node;
+ }
+
+ /**
+ * Parses an OutStatement
+ *
+ * $(GRAMMAR )
+ */
+ OutStatement parseOutStatement()
+ {
+ auto node = new OutStatement;
+
+ return node;
+ }
+
+ /**
+ * Parses an Parameter
+ *
+ * $(GRAMMAR )
+ */
+ Parameter parseParameter()
+ {
+ auto node = new Parameter;
+
+ return node;
+ }
+
+ /**
+ * Parses an ParameterAttribute
+ *
+ * $(GRAMMAR )
+ */
+ ParameterAttribute parseParameterAttribute()
+ {
+ auto node = new ParameterAttribute;
+
+ return node;
+ }
+
+ /**
+ * Parses an Parameters
+ *
+ * $(GRAMMAR )
+ */
+ Parameters parseParameters()
+ {
+ auto node = new Parameters;
+
+ return node;
+ }
+
+ /**
+ * Parses an PostIncDecExpression
+ *
+ * $(GRAMMAR )
+ */
+ PostIncDecExpression parsePostIncDecExpression()
+ {
+ auto node = new PostIncDecExpression;
+
+ return node;
+ }
+
+ /**
+ * Parses an PowExpression
+ *
+ * $(GRAMMAR )
+ */
+ PowExpression parsePowExpression()
+ {
+ auto node = new PowExpression;
+
+ return node;
+ }
+
+ /**
+ * Parses an PragmaDeclaration
+ *
+ * $(GRAMMAR )
+ */
+ PragmaDeclaration parsePragmaDeclaration()
+ {
+ auto node = new PragmaDeclaration;
+
+ return node;
+ }
+
+ /**
+ * Parses an PragmaExpression
+ *
+ * $(GRAMMAR )
+ */
+ PragmaExpression parsePragmaExpression()
+ {
+ auto node = new PragmaExpression;
+
+ return node;
+ }
+
+ /**
+ * Parses an PreIncDecExpression
+ *
+ * $(GRAMMAR )
+ */
+ PreIncDecExpression parsePreIncDecExpression()
+ {
+ auto node = new PreIncDecExpression;
+
+ return node;
+ }
+
+ /**
+ * Parses an PrimaryExpression
+ *
+ * $(GRAMMAR )
+ */
+ PrimaryExpression parsePrimaryExpression()
+ {
+ auto node = new PrimaryExpression;
+
+ return node;
+ }
+
+ /**
+ * Parses an ProtectionAttribute
+ *
+ * $(GRAMMAR )
+ */
+ ProtectionAttribute parseProtectionAttribute()
+ {
+ auto node = new ProtectionAttribute;
+
+ return node;
+ }
+
+ /**
+ * Parses an Register
+ *
+ * $(GRAMMAR )
+ */
+ Register parseRegister()
+ {
+ auto node = new Register;
+
+ return node;
+ }
+
+ /**
+ * Parses an RelExpression
+ *
+ * $(GRAMMAR )
+ */
+ RelExpression parseRelExpression()
+ {
+ auto node = new RelExpression;
+
+ return node;
+ }
+
+ /**
+ * Parses an ReturnStatement
+ *
+ * $(GRAMMAR )
+ */
+ ReturnStatement parseReturnStatement()
+ {
+ auto node = new ReturnStatement;
+ expect(TokenType.return_);
+ if (tokens[index] != TokenType.semicolon)
+ node.expression = parseExpression();
+ expect(TokenType.semicolon);
+ return node;
+ }
+
+ /**
+ * Parses an ScopeGuardStatement
+ *
+ * $(GRAMMAR )
+ */
+ ScopeGuardStatement parseScopeGuardStatement()
+ {
+ auto node = new ScopeGuardStatement;
+
+ return node;
+ }
+
+ /**
+ * Parses an SharedStaticConstructor
+ *
+ * $(GRAMMAR )
+ */
+ SharedStaticConstructor parseSharedStaticConstructor()
+ {
+ auto node = new SharedStaticConstructor;
+
+ return node;
+ }
+
+ /**
+ * Parses an SharedStaticDestructor
+ *
+ * $(GRAMMAR )
+ */
+ SharedStaticDestructor parseSharedStaticDestructor()
+ {
+ auto node = new SharedStaticDestructor;
+
+ return node;
+ }
+
+ /**
+ * Parses an ShiftExpression
+ *
+ * $(GRAMMAR )
+ */
+ ShiftExpression parseShiftExpression()
+ {
+ auto node = new ShiftExpression;
+
+ return node;
+ }
+
+ /**
+ * Parses an SingleImport
+ *
+ * $(GRAMMAR )
+ */
+ SingleImport parseSingleImport()
+ {
+ auto node = new SingleImport;
+
+ return node;
+ }
+
+ /**
+ * Parses a Statement
+ *
+ * $(GRAMMAR $(RULEDEF statement):
+ * $(LITERAL ';')
+ * | $(RULE nonEmptyStatement)
+ * ;)
+ */
+ Statement parseStatement()
+ {
+ auto node = new Statement;
+ if (currentIs(TokenType.semicolon))
advance();
else
- node.nonEmptyStatement = parseNonEmptyStatement();
- return node;
- }
-
- /**
- * Parses an StatementNoCaseNoDefault
- *
- * $(GRAMMAR )
- */
- StatementNoCaseNoDefault parseStatementNoCaseNoDefault()
- {
- auto node = new StatementNoCaseNoDefault;
- if (tokens[index] != TokenType.semicolon)
- node.nonEmptyStatementNoCaseNoDefault = parseNonEmptyStatementNoCaseNoDefault();
- else
- expect(TokenType.semicolon);
- return node;
- }
-
- /**
- * Parses an StaticAssertDeclaration
- *
- * $(GRAMMAR )
- */
- StaticAssertDeclaration parseStaticAssertDeclaration()
- {
- auto node = new StaticAssertDeclaration;
- node.staticAssertStatement = parseStaticAssertStatement();
- return node;
- }
-
- /**
- * Parses an StaticAssertStatement
- *
- * $(GRAMMAR )
- */
- StaticAssertStatement parseStaticAssertStatement()
- {
- auto node = new StaticAssertStatement;
- expect(TokenType.static_);
- node.assertStatement = parseAssertStatement();
- return node;
- }
-
- /**
- * Parses an StaticConstructor
- *
- * $(GRAMMAR )
- */
- StaticConstructor parseStaticConstructor()
- {
- auto node = new StaticConstructor;
- expect(TokenType.static_);
- expect(TokenType.this_);
- expect(TokenType.lParen);
- expect(TokenType.rParen);
- node.functionBody = parseFunctionBody();
- return node;
- }
-
- /**
- * Parses an StaticDestructor
- *
- * $(GRAMMAR )
- */
- StaticDestructor parseStaticDestructor()
- {
- auto node = new StaticDestructor;
- expect(TokenType.static_);
- expect(TokenType.tilde);
- expect(TokenType.this_);
- expect(TokenType.lParen);
- expect(TokenType.rParen);
- node.functionBody = parseFunctionBody();
- return node;
- }
-
- /**
- * Parses an StaticIfCondition
- *
- * $(GRAMMAR )
- */
- StaticIfCondition parseStaticIfCondition()
- {
- auto node = new StaticIfCondition;
- expect(TokenType.static_);
- expect(TokenType.if_);
- expect(TokenType.lParen);
- node.assignExpression = parseAssignExpression();
- expect(TokenType.rParen);
- return node;
- }
-
- /**
- * Parses an StorageClass
- *
- * $(GRAMMAR )
- */
- StorageClass parseStorageClass()
- {
- auto node = new StorageClass;
-
- return node;
- }
-
- /**
- * Parses an StructBody
- *
- * $(GRAMMAR )
- */
- StructBody parseStructBody()
- {
- auto node = new StructBody;
- expect(TokenType.lBrace);
- while (tokens[index] != TokenType.rBrace && moreTokens())
- node.declarations ~= parseDeclaration();
- expect(TokenType.rBrace);
- return node;
- }
-
- /**
- * Parses an StructDeclaration
- *
- * $(GRAMMAR structDeclaration: 'struct' Identifier (templateParameters constraint? structBody | (structBody | ';'))
- * ;)
- */
- StructDeclaration parseStructDeclaration()
- {
- auto node = new StructDeclaration;
- expect(TokenType.struct_);
- node.identifier = *expect(TokenType.identifier);
- if (currentIs(TokenType.lParen))
- {
- node.templateParameters = parseTemplateParameters();
- if (tokens[index] == TokenType.if_)
- node.constraint = parseConstraint();
- node.structBody = parseStructBody();
- }
- else if (currentIs(TokenType.lBrace))
- {
- node.structBody = parseStructBody();
- }
- else if (currentIs(TokenType.semicolon))
- advance();
- else
- {
- error("Template Parameters, Struct Body, or Semicolon expected");
- return null;
- }
- return node;
- }
-
- /**
- * Parses an StructInitializer
- *
- * $(GRAMMAR )
- */
- StructInitializer parseStructInitializer()
- {
- auto node = new StructInitializer;
- expect(TokenType.lBrace);
- node.structMemberInitializers = parseStructMemberInitializers();
- expect(TokenType.rBrace);
- return node;
- }
-
- /**
- * Parses an StructMemberInitializer
- *
- * $(GRAMMAR )
- */
- StructMemberInitializer parseStructMemberInitializer()
- {
- auto node = new StructMemberInitializer;
- if (startsWith(TokenType.identifier, TokenType.colon))
- {
- node.identifier = tokens[index++];
- index++;
- }
- node.nonVoidInitializer = parseNonVoidInitializer();
- return node;
- }
-
- /**
- * Parses an StructMemberInitializers
- *
- * $(GRAMMAR )
- */
- StructMemberInitializers parseStructMemberInitializers()
- {
- auto node = new StructMemberInitializers;
-
- return node;
- }
-
- /**
- * Parses an SwitchBody
- *
- * $(GRAMMAR )
- */
- SwitchBody parseSwitchBody()
- {
- auto node = new SwitchBody;
- expect(TokenType.lBrace);
- while (moreTokens() && tokens[index] != TokenType.rBrace)
- node.statements ~= parseStatement();
- expect(TokenType.rBrace);
- return node;
- }
-
- /**
- * Parses an SwitchStatement
- *
- * $(GRAMMAR )
- */
- SwitchStatement parseSwitchStatement()
- {
- auto node = new SwitchStatement;
- expect(TokenType.switch_);
- expect(TokenType.lParen);
- node.expression = parseExpression();
- expect(TokenType.rParen);
- node.switchBody = parseSwitchBody();
- return node;
- }
-
- /**
- * Parses an Symbol
- *
- * $(GRAMMAR )
- */
- Symbol parseSymbol()
- {
- auto node = new Symbol;
- if (tokens[index] == TokenType.dot)
- {
- node.hasDot = true;
- ++index;
- }
- node.identifierOrTemplateChain = parseIdentifierOrTemplateChain();
- return node;
- }
-
- /**
- * Parses an SynchronizedStatement
- *
- * $(GRAMMAR )
- */
- SynchronizedStatement parseSynchronizedStatement()
- {
- auto node = new SynchronizedStatement;
- expect(TokenType.synchronized_);
- if (tokens[index] == TokenType.lParen)
- {
- expect(TokenType.lParen);
- node.expression = parseExpression();
- expect(TokenType.rParen);
- }
- node.nonEmptyStatementNoCaseNoDefault = parseNonEmptyStatementNoCaseNoDefault();
- return node;
- }
-
- /**
- * Parses an TemplateAliasParameter
- *
- * $(GRAMMAR )
- */
- TemplateAliasParameter parseTemplateAliasParameter()
- {
- auto node = new TemplateAliasParameter;
-
- return node;
- }
-
- /**
- * Parses an TemplateArgument
- *
- * $(GRAMMAR )
- */
- TemplateArgument parseTemplateArgument()
- {
- auto node = new TemplateArgument;
-
- return node;
- }
-
- /**
- * Parses an TemplateArgumentList
- *
- * $(GRAMMAR )
- */
- TemplateArgumentList parseTemplateArgumentList()
- {
- auto node = new TemplateArgumentList;
-
- return node;
- }
-
- /**
- * Parses an TemplateArguments
- *
- * $(GRAMMAR )
- */
- TemplateArguments parseTemplateArguments()
- {
- auto node = new TemplateArguments;
-
- return node;
- }
-
- /**
- * Parses an TemplateDeclaration
- *
- * $(GRAMMAR )
- */
- TemplateDeclaration parseTemplateDeclaration()
- {
- auto node = new TemplateDeclaration;
-
- return node;
- }
-
- /**
- * Parses an TemplateInstance
- *
- * $(GRAMMAR )
- */
- TemplateInstance parseTemplateInstance()
- {
- auto node = new TemplateInstance;
-
- return node;
- }
-
- /**
- * Parses an TemplateMixinStatement
- *
- * $(GRAMMAR )
- */
- TemplateMixinStatement parseTemplateMixinStatement()
- {
- auto node = new TemplateMixinStatement;
-
- return node;
- }
-
- /**
- * Parses an TemplateParameter
- *
- * $(GRAMMAR )
- */
- TemplateParameter parseTemplateParameter()
- {
- auto node = new TemplateParameter;
-
- return node;
- }
-
- /**
- * Parses an TemplateParameterList
- *
- * $(GRAMMAR )
- */
- TemplateParameterList parseTemplateParameterList()
- {
- auto node = new TemplateParameterList;
-
- return node;
- }
-
- /**
- * Parses an TemplateParameters
- *
- * $(GRAMMAR )
- */
- TemplateParameters parseTemplateParameters()
- {
- auto node = new TemplateParameters;
-
- return node;
- }
-
- /**
- * Parses an TemplateSingleArgument
- *
- * $(GRAMMAR )
- */
- TemplateSingleArgument parseTemplateSingleArgument()
- {
- auto node = new TemplateSingleArgument;
-
- return node;
- }
-
- /**
- * Parses an TemplateThisParameter
- *
- * $(GRAMMAR )
- */
- TemplateThisParameter parseTemplateThisParameter()
- {
- auto node = new TemplateThisParameter;
-
- return node;
- }
-
- /**
- * Parses an TemplateTupleParameter
- *
- * $(GRAMMAR )
- */
- TemplateTupleParameter parseTemplateTupleParameter()
- {
- auto node = new TemplateTupleParameter;
-
- return node;
- }
-
- /**
- * Parses an TemplateTypeParameter
- *
- * $(GRAMMAR )
- */
- TemplateTypeParameter parseTemplateTypeParameter()
- {
- auto node = new TemplateTypeParameter;
-
- return node;
- }
-
- /**
- * Parses an TemplateValueParameter
- *
- * $(GRAMMAR )
- */
- TemplateValueParameter parseTemplateValueParameter()
- {
- auto node = new TemplateValueParameter;
-
- return node;
- }
-
- /**
- * Parses an TemplateValueParameterDefault
- *
- * $(GRAMMAR )
- */
- TemplateValueParameterDefault parseTemplateValueParameterDefault()
- {
- auto node = new TemplateValueParameterDefault;
-
- return node;
- }
-
- /**
- * Parses an TernaryExpression
- *
- * $(GRAMMAR )
- */
- TernaryExpression parseTernaryExpression()
- {
- auto node = new TernaryExpression;
- node.orOrExpression = parseOrOrExpression();
- if (tokens[index] == TokenType.ternary)
- {
- ++index;
- node.expression = parseExpression();
- expect(TokenType.colon);
- node.ternaryExpression = parseTernaryExpression();
- }
- return node;
- }
-
- /**
- * Parses an ThrowStatement
- *
- * $(GRAMMAR )
- */
- ThrowStatement parseThrowStatement()
- {
- auto node = new ThrowStatement;
- expect(TokenType.throw_);
- node.expression = parseExpression();
- expect(TokenType.semicolon);
- return node;
- }
-
- /**
- * Parses an TraitsArgument
- *
- * $(GRAMMAR )
- */
- TraitsArgument parseTraitsArgument()
- {
- auto node = new TraitsArgument;
-
- return node;
- }
-
- /**
- * Parses an TraitsExpression
- *
- * $(GRAMMAR )
- */
- TraitsExpression parseTraitsExpression()
- {
- auto node = new TraitsExpression;
-
- return node;
- }
-
- /**
- * Parses an TryStatement
- *
- * $(GRAMMAR )
- */
- TryStatement parseTryStatement()
- {
- auto node = new TryStatement;
-
- return node;
- }
-
- /**
- * Parses an Type
- *
- * $(GRAMMAR )
- */
- Type parseType()
- {
- auto node = new Type;
-
- return node;
- }
-
- /**
- * Parses an Type2
- *
- * $(GRAMMAR )
- */
- Type2 parseType2()
- {
- auto node = new Type2;
-
- return node;
- }
-
- /**
- * Parses an Type3
- *
- * $(GRAMMAR )
- */
- Type3 parseType3()
- {
- auto node = new Type3;
-
- return node;
- }
-
- /**
- * Parses an TypeConstructor
- *
- * $(GRAMMAR )
- */
- TypeConstructor parseTypeConstructor()
- {
- auto node = new TypeConstructor;
-
- return node;
- }
-
- /**
- * Parses an TypeConstructors
- *
- * $(GRAMMAR )
- */
- TypeConstructors parseTypeConstructors()
- {
- auto node = new TypeConstructors;
-
- return node;
- }
-
- /**
- * Parses an TypeSpecialization
- *
- * $(GRAMMAR )
- */
- TypeSpecialization parseTypeSpecialization()
- {
- auto node = new TypeSpecialization;
-
- return node;
- }
-
- /**
- * Parses an TypeSuffix
- *
- * $(GRAMMAR )
- */
- TypeSuffix parseTypeSuffix()
- {
- auto node = new TypeSuffix;
-
- return node;
- }
-
- /**
- * Parses an TypeidExpression
- *
- * $(GRAMMAR )
- */
- TypeidExpression parseTypeidExpression()
- {
- auto node = new TypeidExpression;
-
- return node;
- }
-
- /**
- * Parses an TypeofExpression
- *
- * $(GRAMMAR )
- */
- TypeofExpression parseTypeofExpression()
- {
- auto node = new TypeofExpression;
- expect(TokenType.typeof_);
- expect(TokenType.lParen);
- if (tokens[index] == TokenType.return_)
- node.return_ = tokens[index];
- else
- node.expression = parseExpression();
- expect(TokenType.rParen);
- return node;
- }
-
- /**
- * Parses an UnaryExpression
- *
- * $(GRAMMAR )
- */
- UnaryExpression parseUnaryExpression()
- {
- auto node = new UnaryExpression;
-
- return node;
- }
-
- /**
- * Parses an UnionDeclaration
- *
- * $(GRAMMAR )
- */
- UnionDeclaration parseUnionDeclaration()
- {
- auto node = new UnionDeclaration;
-
- return node;
- }
-
- /**
- * Parses an Unittest
- *
- * $(GRAMMAR )
- */
- Unittest parseUnittest()
- {
- auto node = new Unittest;
- expect(TokenType.unittest_);
- node.blockStatement = parseBlockStatement();
- return node;
- }
-
- /**
- * Parses a VariableDeclaration
- *
- * $(GRAMMAR )
- */
- VariableDeclaration parseVariableDeclaration()
- {
- auto node = new VariableDeclaration;
-
- return node;
- }
-
- /**
- * Parses a VersionCondition
- *
- * $(GRAMMAR versionCondition: 'version' '(' (IntegerLiteral | Identifier | 'unittest' | 'assert') ')'
+ node.nonEmptyStatement = parseNonEmptyStatement();
+ return node;
+ }
+
+ /**
+ * Parses an StatementNoCaseNoDefault
+ *
+ * $(GRAMMAR )
+ */
+ StatementNoCaseNoDefault parseStatementNoCaseNoDefault()
+ {
+ auto node = new StatementNoCaseNoDefault;
+ if (tokens[index] != TokenType.semicolon)
+ node.nonEmptyStatementNoCaseNoDefault = parseNonEmptyStatementNoCaseNoDefault();
+ else
+ expect(TokenType.semicolon);
+ return node;
+ }
+
+ /**
+ * Parses an StaticAssertDeclaration
+ *
+ * $(GRAMMAR )
+ */
+ StaticAssertDeclaration parseStaticAssertDeclaration()
+ {
+ auto node = new StaticAssertDeclaration;
+ node.staticAssertStatement = parseStaticAssertStatement();
+ return node;
+ }
+
+ /**
+ * Parses an StaticAssertStatement
+ *
+ * $(GRAMMAR )
+ */
+ StaticAssertStatement parseStaticAssertStatement()
+ {
+ auto node = new StaticAssertStatement;
+ expect(TokenType.static_);
+ node.assertStatement = parseAssertStatement();
+ return node;
+ }
+
+ /**
+ * Parses an StaticConstructor
+ *
+ * $(GRAMMAR )
+ */
+ StaticConstructor parseStaticConstructor()
+ {
+ auto node = new StaticConstructor;
+ expect(TokenType.static_);
+ expect(TokenType.this_);
+ expect(TokenType.lParen);
+ expect(TokenType.rParen);
+ node.functionBody = parseFunctionBody();
+ return node;
+ }
+
+ /**
+ * Parses an StaticDestructor
+ *
+ * $(GRAMMAR )
+ */
+ StaticDestructor parseStaticDestructor()
+ {
+ auto node = new StaticDestructor;
+ expect(TokenType.static_);
+ expect(TokenType.tilde);
+ expect(TokenType.this_);
+ expect(TokenType.lParen);
+ expect(TokenType.rParen);
+ node.functionBody = parseFunctionBody();
+ return node;
+ }
+
+ /**
+ * Parses an StaticIfCondition
+ *
+ * $(GRAMMAR )
+ */
+ StaticIfCondition parseStaticIfCondition()
+ {
+ auto node = new StaticIfCondition;
+ expect(TokenType.static_);
+ expect(TokenType.if_);
+ expect(TokenType.lParen);
+ node.assignExpression = parseAssignExpression();
+ expect(TokenType.rParen);
+ return node;
+ }
+
+ /**
+ * Parses an StorageClass
+ *
+ * $(GRAMMAR )
+ */
+ StorageClass parseStorageClass()
+ {
+ auto node = new StorageClass;
+
+ return node;
+ }
+
+ /**
+ * Parses an StructBody
+ *
+ * $(GRAMMAR )
+ */
+ StructBody parseStructBody()
+ {
+ auto node = new StructBody;
+ expect(TokenType.lBrace);
+ while (tokens[index] != TokenType.rBrace && moreTokens())
+ node.declarations ~= parseDeclaration();
+ expect(TokenType.rBrace);
+ return node;
+ }
+
+ /**
+ * Parses a StructDeclaration
+ *
+ * $(GRAMMAR $(RULEDEF structDeclaration):
+ * $(LITERAL 'struct') $(LITERAL Identifier) ($(RULE templateParameters) $(RULE constraint)? $(RULE structBody) | ($(RULE structBody) | $(LITERAL ';')))
* ;)
- */
- VersionCondition parseVersionCondition()
- {
- auto node = new VersionCondition;
- expect(TokenType.version_);
- expect(TokenType.lParen);
+ */
+ StructDeclaration parseStructDeclaration()
+ {
+ auto node = new StructDeclaration;
+ expect(TokenType.struct_);
+ node.identifier = *expect(TokenType.identifier);
+ if (currentIs(TokenType.lParen))
+ {
+ node.templateParameters = parseTemplateParameters();
+ if (tokens[index] == TokenType.if_)
+ node.constraint = parseConstraint();
+ node.structBody = parseStructBody();
+ }
+ else if (currentIs(TokenType.lBrace))
+ {
+ node.structBody = parseStructBody();
+ }
+ else if (currentIs(TokenType.semicolon))
+ advance();
+ else
+ {
+ error("Template Parameters, Struct Body, or Semicolon expected");
+ return null;
+ }
+ return node;
+ }
+
+ /**
+ * Parses an StructInitializer
+ *
+ * $(GRAMMAR )
+ */
+ StructInitializer parseStructInitializer()
+ {
+ auto node = new StructInitializer;
+ expect(TokenType.lBrace);
+ node.structMemberInitializers = parseStructMemberInitializers();
+ expect(TokenType.rBrace);
+ return node;
+ }
+
+ /**
+ * Parses an StructMemberInitializer
+ *
+ * $(GRAMMAR )
+ */
+ StructMemberInitializer parseStructMemberInitializer()
+ {
+ auto node = new StructMemberInitializer;
+ if (startsWith(TokenType.identifier, TokenType.colon))
+ {
+ node.identifier = tokens[index++];
+ index++;
+ }
+ node.nonVoidInitializer = parseNonVoidInitializer();
+ return node;
+ }
+
+ /**
+ * Parses an StructMemberInitializers
+ *
+ * $(GRAMMAR )
+ */
+ StructMemberInitializers parseStructMemberInitializers()
+ {
+ auto node = new StructMemberInitializers;
+
+ return node;
+ }
+
+ /**
+ * Parses an SwitchBody
+ *
+ * $(GRAMMAR )
+ */
+ SwitchBody parseSwitchBody()
+ {
+ auto node = new SwitchBody;
+ expect(TokenType.lBrace);
+ while (moreTokens() && tokens[index] != TokenType.rBrace)
+ node.statements ~= parseStatement();
+ expect(TokenType.rBrace);
+ return node;
+ }
+
+ /**
+ * Parses an SwitchStatement
+ *
+ * $(GRAMMAR )
+ */
+ SwitchStatement parseSwitchStatement()
+ {
+ auto node = new SwitchStatement;
+ expect(TokenType.switch_);
+ expect(TokenType.lParen);
+ node.expression = parseExpression();
+ expect(TokenType.rParen);
+ node.switchBody = parseSwitchBody();
+ return node;
+ }
+
+ /**
+ * Parses an Symbol
+ *
+ * $(GRAMMAR )
+ */
+ Symbol parseSymbol()
+ {
+ auto node = new Symbol;
+ if (tokens[index] == TokenType.dot)
+ {
+ node.hasDot = true;
+ ++index;
+ }
+ node.identifierOrTemplateChain = parseIdentifierOrTemplateChain();
+ return node;
+ }
+
+ /**
+ * Parses an SynchronizedStatement
+ *
+ * $(GRAMMAR )
+ */
+ SynchronizedStatement parseSynchronizedStatement()
+ {
+ auto node = new SynchronizedStatement;
+ expect(TokenType.synchronized_);
+ if (tokens[index] == TokenType.lParen)
+ {
+ expect(TokenType.lParen);
+ node.expression = parseExpression();
+ expect(TokenType.rParen);
+ }
+ node.nonEmptyStatementNoCaseNoDefault = parseNonEmptyStatementNoCaseNoDefault();
+ return node;
+ }
+
+ /**
+ * Parses an TemplateAliasParameter
+ *
+ * $(GRAMMAR )
+ */
+ TemplateAliasParameter parseTemplateAliasParameter()
+ {
+ auto node = new TemplateAliasParameter;
+
+ return node;
+ }
+
+ /**
+ * Parses an TemplateArgument
+ *
+ * $(GRAMMAR )
+ */
+ TemplateArgument parseTemplateArgument()
+ {
+ auto node = new TemplateArgument;
+
+ return node;
+ }
+
+ /**
+ * Parses an TemplateArgumentList
+ *
+ * $(GRAMMAR )
+ */
+ TemplateArgumentList parseTemplateArgumentList()
+ {
+ auto node = new TemplateArgumentList;
+
+ return node;
+ }
+
+ /**
+ * Parses an TemplateArguments
+ *
+ * $(GRAMMAR )
+ */
+ TemplateArguments parseTemplateArguments()
+ {
+ auto node = new TemplateArguments;
+
+ return node;
+ }
+
+ /**
+ * Parses an TemplateDeclaration
+ *
+ * $(GRAMMAR )
+ */
+ TemplateDeclaration parseTemplateDeclaration()
+ {
+ auto node = new TemplateDeclaration;
+
+ return node;
+ }
+
+ /**
+ * Parses an TemplateInstance
+ *
+ * $(GRAMMAR )
+ */
+ TemplateInstance parseTemplateInstance()
+ {
+ auto node = new TemplateInstance;
+
+ return node;
+ }
+
+ /**
+ * Parses an TemplateMixinStatement
+ *
+ * $(GRAMMAR )
+ */
+ TemplateMixinStatement parseTemplateMixinStatement()
+ {
+ auto node = new TemplateMixinStatement;
+
+ return node;
+ }
+
+ /**
+ * Parses an TemplateParameter
+ *
+ * $(GRAMMAR )
+ */
+ TemplateParameter parseTemplateParameter()
+ {
+ auto node = new TemplateParameter;
+
+ return node;
+ }
+
+ /**
+ * Parses an TemplateParameterList
+ *
+ * $(GRAMMAR )
+ */
+ TemplateParameterList parseTemplateParameterList()
+ {
+ auto node = new TemplateParameterList;
+
+ return node;
+ }
+
+ /**
+ * Parses an TemplateParameters
+ *
+ * $(GRAMMAR )
+ */
+ TemplateParameters parseTemplateParameters()
+ {
+ auto node = new TemplateParameters;
+
+ return node;
+ }
+
+ /**
+ * Parses an TemplateSingleArgument
+ *
+ * $(GRAMMAR )
+ */
+ TemplateSingleArgument parseTemplateSingleArgument()
+ {
+ auto node = new TemplateSingleArgument;
+
+ return node;
+ }
+
+ /**
+ * Parses an TemplateThisParameter
+ *
+ * $(GRAMMAR )
+ */
+ TemplateThisParameter parseTemplateThisParameter()
+ {
+ auto node = new TemplateThisParameter;
+
+ return node;
+ }
+
+ /**
+ * Parses an TemplateTupleParameter
+ *
+ * $(GRAMMAR )
+ */
+ TemplateTupleParameter parseTemplateTupleParameter()
+ {
+ auto node = new TemplateTupleParameter;
+
+ return node;
+ }
+
+ /**
+ * Parses an TemplateTypeParameter
+ *
+ * $(GRAMMAR )
+ */
+ TemplateTypeParameter parseTemplateTypeParameter()
+ {
+ auto node = new TemplateTypeParameter;
+
+ return node;
+ }
+
+ /**
+ * Parses an TemplateValueParameter
+ *
+ * $(GRAMMAR )
+ */
+ TemplateValueParameter parseTemplateValueParameter()
+ {
+ auto node = new TemplateValueParameter;
+
+ return node;
+ }
+
+ /**
+ * Parses an TemplateValueParameterDefault
+ *
+ * $(GRAMMAR )
+ */
+ TemplateValueParameterDefault parseTemplateValueParameterDefault()
+ {
+ auto node = new TemplateValueParameterDefault;
+
+ return node;
+ }
+
+ /**
+ * Parses an TernaryExpression
+ *
+ * $(GRAMMAR )
+ */
+ TernaryExpression parseTernaryExpression()
+ {
+ auto node = new TernaryExpression;
+ node.orOrExpression = parseOrOrExpression();
+ if (tokens[index] == TokenType.ternary)
+ {
+ ++index;
+ node.expression = parseExpression();
+ expect(TokenType.colon);
+ node.ternaryExpression = parseTernaryExpression();
+ }
+ return node;
+ }
+
+ /**
+ * Parses an ThrowStatement
+ *
+ * $(GRAMMAR )
+ */
+ ThrowStatement parseThrowStatement()
+ {
+ auto node = new ThrowStatement;
+ expect(TokenType.throw_);
+ node.expression = parseExpression();
+ expect(TokenType.semicolon);
+ return node;
+ }
+
+ /**
+ * Parses an TraitsArgument
+ *
+ * $(GRAMMAR )
+ */
+ TraitsArgument parseTraitsArgument()
+ {
+ auto node = new TraitsArgument;
+
+ return node;
+ }
+
+ /**
+ * Parses an TraitsExpression
+ *
+ * $(GRAMMAR )
+ */
+ TraitsExpression parseTraitsExpression()
+ {
+ auto node = new TraitsExpression;
+
+ return node;
+ }
+
+ /**
+ * Parses an TryStatement
+ *
+ * $(GRAMMAR )
+ */
+ TryStatement parseTryStatement()
+ {
+ auto node = new TryStatement;
+
+ return node;
+ }
+
+ /**
+ * Parses an Type
+ *
+ * $(GRAMMAR )
+ */
+ Type parseType()
+ {
+ auto node = new Type;
+
+ return node;
+ }
+
+ /**
+ * Parses an Type2
+ *
+ * $(GRAMMAR )
+ */
+ Type2 parseType2()
+ {
+ auto node = new Type2;
+
+ return node;
+ }
+
+ /**
+ * Parses an Type3
+ *
+ * $(GRAMMAR )
+ */
+ Type3 parseType3()
+ {
+ auto node = new Type3;
+
+ return node;
+ }
+
+ /**
+ * Parses an TypeConstructor
+ *
+ * $(GRAMMAR )
+ */
+ TypeConstructor parseTypeConstructor()
+ {
+ auto node = new TypeConstructor;
+
+ return node;
+ }
+
+ /**
+ * Parses an TypeConstructors
+ *
+ * $(GRAMMAR )
+ */
+ TypeConstructors parseTypeConstructors()
+ {
+ auto node = new TypeConstructors;
+
+ return node;
+ }
+
+ /**
+ * Parses an TypeSpecialization
+ *
+ * $(GRAMMAR )
+ */
+ TypeSpecialization parseTypeSpecialization()
+ {
+ auto node = new TypeSpecialization;
+
+ return node;
+ }
+
+ /**
+ * Parses an TypeSuffix
+ *
+ * $(GRAMMAR )
+ */
+ TypeSuffix parseTypeSuffix()
+ {
+ auto node = new TypeSuffix;
+
+ return node;
+ }
+
+ /**
+ * Parses an TypeidExpression
+ *
+ * $(GRAMMAR )
+ */
+ TypeidExpression parseTypeidExpression()
+ {
+ auto node = new TypeidExpression;
+
+ return node;
+ }
+
+ /**
+ * Parses an TypeofExpression
+ *
+ * $(GRAMMAR )
+ */
+ TypeofExpression parseTypeofExpression()
+ {
+ auto node = new TypeofExpression;
+ expect(TokenType.typeof_);
+ expect(TokenType.lParen);
+ if (tokens[index] == TokenType.return_)
+ node.return_ = tokens[index];
+ else
+ node.expression = parseExpression();
+ expect(TokenType.rParen);
+ return node;
+ }
+
+ /**
+ * Parses a UnaryExpression
+ *
+ * $(GRAMMAR $(RULEDEF unaryExpression):
+ * $(RULE primaryExpression)
+ * | $(LITERAL '&') $(RULE unaryExpression)
+ * | $(LITERAL '!') $(RULE unaryExpression)
+ * | $(LITERAL '*') $(RULE unaryExpression)
+ * | $(LITERAL '+') $(RULE unaryExpression)
+ * | $(LITERAL '-') $(RULE unaryExpression)
+ * | $(LITERAL '~') $(RULE unaryExpression)
+ * | $(RULE newExpression)
+ * | $(RULE deleteExpression)
+ * | $(RULE castExpression)
+ * | $(RULE functionCallExpression)
+ * | $(RULE preIncDecExpression)
+ * | $(RULE postIncDecExpression)
+ * | $(RULE sliceExpression)
+ * | $(RULE indexExpression)
+ * | $(RULE unaryExpression) $(LITERAL '.') $(RULE identifierOrTemplateInstance)
+ * | $(RULE assertExpression)
+ * ;)
+ */
+ UnaryExpression parseUnaryExpression()
+ {
+ auto node = new UnaryExpression;
+
+ return node;
+ }
+
+ /**
+ * Parses an UnionDeclaration
+ *
+ * $(GRAMMAR )
+ */
+ UnionDeclaration parseUnionDeclaration()
+ {
+ auto node = new UnionDeclaration;
+
+ return node;
+ }
+
+ /**
+ * Parses a Unittest
+ *
+ * $(GRAMMAR $(RULEDEF unittest):
+ * $(LITERAL 'unittest') $(RULE blockStatement)
+ * ;)
+ */
+ Unittest parseUnittest()
+ {
+ auto node = new Unittest;
+ expect(TokenType.unittest_);
+ node.blockStatement = parseBlockStatement();
+ return node;
+ }
+
+ /**
+ * Parses a VariableDeclaration
+ *
+ * $(GRAMMAR )
+ */
+ VariableDeclaration parseVariableDeclaration()
+ {
+ auto node = new VariableDeclaration;
+
+ return node;
+ }
+
+ /**
+ * Parses a VersionCondition
+ *
+ * $(GRAMMAR $(RULEDEF versionCondition):
+ * $(LITERAL 'version') $(LITERAL '$(LPAREN)') ($(LITERAL IntegerLiteral) | $(LITERAL Identifier) | $(LITERAL 'unittest') | $(LITERAL 'assert')) $(LITERAL '$(RPAREN)')
+ * ;)
+ */
+ VersionCondition parseVersionCondition()
+ {
+ auto node = new VersionCondition;
+ expect(TokenType.version_);
+ expect(TokenType.lParen);
if (currentIsOneOf(TokenType.intLiteral, TokenType.identifier,
TokenType.unittest_, TokenType.assert_))
{
@@ -2950,197 +3125,212 @@ struct Parser
error(`Expected an integer literal, an identifier, "assert", or "unittest"`);
return null;
}
- expect(TokenType.rParen);
- return node;
- }
+ expect(TokenType.rParen);
+ return node;
+ }
- /**
- * Parses a VersionSpecification
- *
- * $(GRAMMAR versionSpecification: 'version' '=' (Identifier | IntegerLiteral) ';'
+ /**
+ * Parses a VersionSpecification
+ *
+ * $(GRAMMAR $(RULEDEF versionSpecification):
+ * $(LITERAL 'version') $(LITERAL '=') ($(LITERAL Identifier) | $(LITERAL IntegerLiteral)) $(LITERAL ';')
* ;)
- */
- VersionSpecification parseVersionSpecification()
- {
- auto node = new VersionSpecification;
- expect(TokenType.version_);
- expect(TokenType.assign);
+ */
+ VersionSpecification parseVersionSpecification()
+ {
+ auto node = new VersionSpecification;
+ expect(TokenType.version_);
+ expect(TokenType.assign);
if (!currentIsOneOf(TokenType.identifier, TokenType.intLiteral))
{
error("Identifier or integer literal expected");
return null;
}
- node.token = advance();
- expect(TokenType.semicolon);
- return node;
- }
+ node.token = advance();
+ expect(TokenType.semicolon);
+ return node;
+ }
- /**
- * Parses an WhileStatement
- *
- * $(GRAMMAR whileStatement: 'while' '(' expression ')' statementNoCaseNoDefault
+ /**
+ * Parses a WhileStatement
+ *
+ * $(GRAMMAR $(RULEDEF whileStatement):
+ * $(LITERAL 'while') $(LITERAL '$(LPAREN)') $(RULE expression) $(LITERAL '$(RPAREN)') $(RULE statementNoCaseNoDefault)
* ;)
- */
- WhileStatement parseWhileStatement()
- {
- auto node = new WhileStatement;
+ */
+ WhileStatement parseWhileStatement()
+ {
+ auto node = new WhileStatement;
expect(TokenType.while_);
expect(TokenType.lParen);
node.expression = parseExpression();
expect(TokenType.rParen);
node.statementNoCaseNoDefault = parseStatementNoCaseNoDefault();
- return node;
- }
+ return node;
+ }
- /**
- * Parses an WithStatement
- *
- * $(GRAMMAR )
- */
- WithStatement parseWithStatement()
- {
- auto node = new WithStatement;
- expect(TokenType.with_);
- expect(TokenType.lParen);
- // magic here
- expect(TokenType.rParen);
- parseNonEmptyStatementNoCaseNoDefault();
- return node;
- }
+ /**
+ * Parses a WithStatement
+ *
+ * $(GRAMMAR $(RULEDEF withStatement):
+ * $(LITERAL 'with') $(LITERAL '$(LPAREN)') ($(RULE expression) | $(RULE symbol) | $(RULE templateInstance)) $(LITERAL '$(RPAREN)') $(RULE nonEmptyStatementNoCaseNoDefault)
+ * ;)
+ */
+ WithStatement parseWithStatement()
+ {
+ auto node = new WithStatement;
+ expect(TokenType.with_);
+ expect(TokenType.lParen);
+ // TODO: magic here
+ expect(TokenType.rParen);
+ parseNonEmptyStatementNoCaseNoDefault();
+ return node;
+ }
- /**
- * Parses an XorExpression
- *
- * $(GRAMMAR )
- */
- XorExpression parseXorExpression()
- {
- auto node = new XorExpression;
+ /**
+ * Parses an XorExpression
+ *
+ * $(GRAMMAR )
+ */
+ XorExpression parseXorExpression()
+ {
+ auto node = new XorExpression;
// TODO
- return node;
- }
+ return node;
+ }
- void error(string message)
- {
+ void error(string message)
+ {
++errorCount;
- import std.stdio;
- stderr.writefln("%s(%d:%d): %s", fileName, tokens[index].line,
- tokens[index].column, message);
- while (index < tokens.length)
- {
- if (tokens[++index].type == TokenType.semicolon)
- break;
- }
- }
+ import std.stdio;
+ stderr.writefln("%s(%d:%d): %s", fileName, tokens[index].line,
+ tokens[index].column, message);
+ while (index < tokens.length)
+ {
+ if (tokens[++index].type == TokenType.semicolon)
+ break;
+ }
+ }
- Token* peekPast(alias O, alias C)()
- in
- {
- assert (tokens[index].type == O);
- }
- body
- {
- int depth = 1;
- auto i = index;
- ++i;
- while (index < tokens.length)
- {
- if (tokens[i] == O)
- ++depth;
- else if (tokens[i] == C)
- {
- --depth;
- ++i;
- if (depth <= 0)
- break;
- }
- ++i;
- }
- return depth == 0 ? &tokens[i] : null;
- }
+ const(Token)* peekPast(alias O, alias C)()
+ in
+ {
+ assert (tokens[index].type == O);
+ }
+ body
+ {
+ int depth = 1;
+ auto i = index;
+ ++i;
+ while (index < tokens.length)
+ {
+ if (tokens[i] == O)
+ ++depth;
+ else if (tokens[i] == C)
+ {
+ --depth;
+ ++i;
+ if (depth <= 0)
+ break;
+ }
+ ++i;
+ }
+ return depth == 0 ? &tokens[i] : null;
+ }
- Token* peekPastParens()
- {
- return peekPast!(TokenType.lParen, TokenType.rParen)();
- }
+ const(Token)* peekPastParens()
+ {
+ return peekPast!(TokenType.lParen, TokenType.rParen)();
+ }
- Token* peekPastBrackets()
- {
- return peekPast!(TokenType.lBracket, TokenType.rBracket)();
- }
+ const(Token)* peekPastBrackets()
+ {
+ return peekPast!(TokenType.lBracket, TokenType.rBracket)();
+ }
- Token* peekPastBraces()
- {
- return peekPast!(TokenType.lBrace, TokenType.rBrace)();
- }
+ const(Token)* peekPastBraces()
+ {
+ return peekPast!(TokenType.lBrace, TokenType.rBrace)();
+ }
- /**
- * Returns a token of the specified type if it was the next token, otherwise
- * calls the error function and returns null.
- */
- Token* expect(TokenType type)
- {
- if (tokens[index].type == type)
- return &tokens[index++];
- else
- {
- error("Expected " ~ to!string(type));
- return null;
- }
- }
+ bool peekIs(TokenType t) const
+ {
+ return index + 1 < tokens.length && tokens[index + 1].type == t;
+ }
- /**
- * Returns: the current token
- */
- Token current()
- {
- return tokens[index];
- }
+ bool peekIsOneOf(TokenType[] types...) const
+ {
+ if (index + 1 >= tokens.length) return false;
+ return canFind(types, tokens[index + 1].type);
+ }
- /**
- * Advances to the next token and returns the current token
- */
- Token advance()
- {
- return tokens[index++];
- }
+ /**
+ * Returns a token of the specified type if it was the next token, otherwise
+ * calls the error function and returns null.
+ */
+ const(Token)* expect(TokenType type)
+ {
+ if (tokens[index].type == type)
+ return &tokens[index++];
+ else
+ {
+ error("Expected " ~ to!string(type));
+ return null;
+ }
+ }
- /**
- * Returns: true if the current token has the given type
- */
- bool currentIs(TokenType type)
- {
- return tokens[index] == type;
- }
+ /**
+ * Returns: the current token
+ */
+ Token current() const
+ {
+ return tokens[index];
+ }
- /**
- * Returns: true if the current token is one of the given types
- */
- bool currentIsOneOf(TokenType[] types...)
- {
- return canFind(types, current().type);
- }
+ /**
+ * Advances to the next token and returns the current token
+ */
+ Token advance()
+ {
+ return tokens[index++];
+ }
- bool startsWith(TokenType[] types...)
- {
- for (size_t i = 0; i != types.length; ++i)
- {
- if (tokens[index + i].type != types[i])
- return false;
- }
- return true;
- }
+ /**
+ * Returns: true if the current token has the given type
+ */
+ bool currentIs(TokenType type) const
+ {
+ return index < tokens.length && tokens[index] == type;
+ }
- /**
- * Returns: true if there are more tokens
- */
- bool moreTokens()
- {
- return index < tokens.length;
- }
+ /**
+ * Returns: true if the current token is one of the given types
+ */
+ bool currentIsOneOf(TokenType[] types...) const
+ {
+ return canFind(types, current().type);
+ }
+
+ bool startsWith(TokenType[] types...) const
+ {
+ for (size_t i = 0; i != types.length; ++i)
+ {
+ if (tokens[index + i].type != types[i])
+ return false;
+ }
+ return true;
+ }
+
+ /**
+ * Returns: true if there are more tokens
+ */
+ bool moreTokens() const
+ {
+ return index < tokens.length;
+ }
uint errorCount;
- Token[] tokens;
- size_t index;
- string fileName;
+ const(Token)[] tokens;
+ size_t index;
+ string fileName;
}