Can now actually parse some basic code
This commit is contained in:
Hackerpilot
parent
79bfe7af4e
commit
6dc1e4c2ff
499
std/d/ast.d
499
std/d/ast.d
|
|
@ -23,217 +23,214 @@ import std.d.lexer;
|
|||
* 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(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(BaseClass baseClass) {}
|
||||
/** */ void visit(BaseClassList baseClassList) {}
|
||||
/** */ 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(NonVoidInitializer nonVoidInitializer) {}
|
||||
/** */ 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(Postblit postblit) {}
|
||||
/** */ 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(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(StructBodyItem structBodyItem) {}
|
||||
/** */ 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) { addExpression.accept(this); }
|
||||
/** */ void visit(AliasDeclaration aliasDeclaration) { aliasDeclaration.accept(this); }
|
||||
/** */ void visit(AliasInitializer aliasInitializer) { aliasInitializer.accept(this); }
|
||||
/** */ void visit(AliasThisDeclaration aliasThisDeclaration) { aliasThisDeclaration.accept(this); }
|
||||
/** */ void visit(AlignAttribute alignAttribute) { alignAttribute.accept(this); }
|
||||
/** */ void visit(AndAndExpression andAndExpression) { andAndExpression.accept(this); }
|
||||
/** */ void visit(AndExpression andExpression) { andExpression.accept(this); }
|
||||
/** */ void visit(ArgumentList argumentList) { argumentList.accept(this); }
|
||||
/** */ void visit(Arguments arguments) { arguments.accept(this); }
|
||||
/** */ void visit(ArrayInitializer arrayInitializer) { arrayInitializer.accept(this); }
|
||||
/** */ void visit(ArrayLiteral arrayLiteral) { arrayLiteral.accept(this); }
|
||||
/** */ void visit(ArrayMemberInitialization arrayMemberInitialization) { arrayMemberInitialization.accept(this); }
|
||||
/** */ void visit(AsmAddExp asmAddExp) { asmAddExp.accept(this); }
|
||||
/** */ void visit(AsmAndExp asmAndExp) { asmAndExp.accept(this); }
|
||||
/** */ void visit(AsmBrExp asmBrExp) { asmBrExp.accept(this); }
|
||||
/** */ void visit(AsmEqualExp asmEqualExp) { asmEqualExp.accept(this); }
|
||||
/** */ void visit(AsmExp asmExp) { asmExp.accept(this); }
|
||||
/** */ void visit(AsmInstruction asmInstruction) { asmInstruction.accept(this); }
|
||||
/** */ void visit(AsmLogAndExp asmLogAndExp) { asmLogAndExp.accept(this); }
|
||||
/** */ void visit(AsmLogOrExp asmLogOrExp) { asmLogOrExp.accept(this); }
|
||||
/** */ void visit(AsmMulExp asmMulExp) { asmMulExp.accept(this); }
|
||||
/** */ void visit(AsmOrExp asmOrExp) { asmOrExp.accept(this); }
|
||||
/** */ void visit(AsmPrimaryExp asmPrimaryExp) { asmPrimaryExp.accept(this); }
|
||||
/** */ void visit(AsmRelExp asmRelExp) { asmRelExp.accept(this); }
|
||||
/** */ void visit(AsmShiftExp asmShiftExp) { asmShiftExp.accept(this); }
|
||||
/** */ void visit(AsmStatement asmStatement) { asmStatement.accept(this); }
|
||||
/** */ void visit(AsmTypePrefix asmTypePrefix) { asmTypePrefix.accept(this); }
|
||||
/** */ void visit(AsmUnaExp asmUnaExp) { asmUnaExp.accept(this); }
|
||||
/** */ void visit(AsmXorExp asmXorExp) { asmXorExp.accept(this); }
|
||||
/** */ void visit(AssertExpression assertExpression) { assertExpression.accept(this); }
|
||||
/** */ void visit(AssertStatement assertStatement) { assertStatement.accept(this); }
|
||||
/** */ void visit(AssignExpression assignExpression) { assignExpression.accept(this); }
|
||||
/** */ void visit(AssignStatement assignStatement) { assignStatement.accept(this); }
|
||||
/** */ void visit(AssocArrayLiteral assocArrayLiteral) { assocArrayLiteral.accept(this); }
|
||||
/** */ void visit(AtAttribute atAttribute) { atAttribute.accept(this); }
|
||||
/** */ void visit(Attribute attribute) { attribute.accept(this); }
|
||||
/** */ void visit(AttributedDeclaration attributedDeclaration) { attributedDeclaration.accept(this); }
|
||||
/** */ void visit(AutoDeclaration autoDeclaration) { autoDeclaration.accept(this); }
|
||||
/** */ void visit(BlockStatement blockStatement) { blockStatement.accept(this); }
|
||||
/** */ void visit(BodyStatement bodyStatement) { bodyStatement.accept(this); }
|
||||
/** */ void visit(BreakStatement breakStatement) { breakStatement.accept(this); }
|
||||
/** */ void visit(BaseClass baseClass) { baseClass.accept(this); }
|
||||
/** */ void visit(BaseClassList baseClassList) { baseClassList.accept(this); }
|
||||
/** */ void visit(BasicType builtinType) { builtinType.accept(this); }
|
||||
/** */ void visit(CaseRangeStatement caseRangeStatement) { caseRangeStatement.accept(this); }
|
||||
/** */ void visit(CaseStatement caseStatement) { caseStatement.accept(this); }
|
||||
/** */ void visit(CastExpression castExpression) { castExpression.accept(this); }
|
||||
/** */ void visit(CastQualifier castQualifier) { castQualifier.accept(this); }
|
||||
/** */ void visit(Catch catch_) { catch_.accept(this); }
|
||||
/** */ void visit(Catches catches) { catches.accept(this); }
|
||||
/** */ void visit(ClassBody classBody) { classBody.accept(this); }
|
||||
/** */ void visit(ClassDeclaration classDeclaration) { classDeclaration.accept(this); }
|
||||
/** */ void visit(CmpExpression cmpExpression) { cmpExpression.accept(this); }
|
||||
/** */ void visit(CompileCondition compileCondition) { compileCondition.accept(this); }
|
||||
/** */ void visit(ConditionalDeclaration conditionalDeclaration) { conditionalDeclaration.accept(this); }
|
||||
/** */ void visit(ConditionalStatement conditionalStatement) { conditionalStatement.accept(this); }
|
||||
/** */ void visit(Constraint constraint) { constraint.accept(this); }
|
||||
/** */ void visit(Constructor constructor) { constructor.accept(this); }
|
||||
/** */ void visit(ContinueStatement continueStatement) { continueStatement.accept(this); }
|
||||
/** */ void visit(DebugCondition debugCondition) { debugCondition.accept(this); }
|
||||
/** */ void visit(DebugSpecification debugSpecification) { debugSpecification.accept(this); }
|
||||
/** */ void visit(Declaration declaration) { declaration.accept(this); }
|
||||
/** */ void visit(DeclarationsAndStatements declarationsAndStatements) { declarationsAndStatements.accept(this); }
|
||||
/** */ void visit(DeclarationOrInvariant declarationOrInvariant) { declarationOrInvariant.accept(this); }
|
||||
/** */ void visit(Declarator declarator) { declarator.accept(this); }
|
||||
/** */ void visit(DefaultStatement defaultStatement) { defaultStatement.accept(this); }
|
||||
/** */ void visit(DeleteExpression deleteExpression) { deleteExpression.accept(this); }
|
||||
/** */ void visit(DeleteStatement deleteStatement) { deleteStatement.accept(this); }
|
||||
/** */ void visit(Deprecated deprecated_) { deprecated_.accept(this); }
|
||||
/** */ void visit(Destructor destructor) { destructor.accept(this); }
|
||||
/** */ void visit(DoStatement doStatement) { doStatement.accept(this); }
|
||||
/** */ void visit(EnumBody enumBody) { enumBody.accept(this); }
|
||||
/** */ void visit(EnumDeclaration enumDeclaration) { enumDeclaration.accept(this); }
|
||||
/** */ void visit(EnumMember enumMember) { enumMember.accept(this); }
|
||||
/** */ void visit(EqualExpression equalExpression) { equalExpression.accept(this); }
|
||||
/** */ void visit(Expression expression) { expression.accept(this); }
|
||||
/** */ void visit(FinalSwitchStatement finalSwitchStatement) { finalSwitchStatement.accept(this); }
|
||||
/** */ void visit(Finally finally_) { finally_.accept(this); }
|
||||
/** */ void visit(ForStatement forStatement) { forStatement.accept(this); }
|
||||
/** */ void visit(ForeachRangeStatement foreachRangeStatement) { foreachRangeStatement.accept(this); }
|
||||
/** */ void visit(ForeachStatement foreachStatement) { foreachStatement.accept(this); }
|
||||
/** */ void visit(ForeachType foreachType) { foreachType.accept(this); }
|
||||
/** */ void visit(ForeachTypeList foreachTypeList) { foreachTypeList.accept(this); }
|
||||
/** */ void visit(FunctionAttribute functionAttribute) { functionAttribute.accept(this); }
|
||||
/** */ void visit(FunctionBody functionBody) { functionBody.accept(this); }
|
||||
/** */ void visit(FunctionCallExpression functionCallExpression) { functionCallExpression.accept(this); }
|
||||
/** */ void visit(FunctionCallStatement functionCallStatement) { functionCallStatement.accept(this); }
|
||||
/** */ void visit(FunctionDeclaration functionDeclaration) { functionDeclaration.accept(this); }
|
||||
/** */ void visit(FunctionLiteralExpression functionLiteralExpression) { functionLiteralExpression.accept(this); }
|
||||
/** */ void visit(GotoStatement gotoStatement) { gotoStatement.accept(this); }
|
||||
/** */ void visit(IdentifierChain identifierChain) { identifierChain.accept(this); }
|
||||
/** */ void visit(IdentifierList identifierList) { identifierList.accept(this); }
|
||||
/** */ void visit(IdentifierOrTemplateChain identifierOrTemplateChain) { identifierOrTemplateChain.accept(this); }
|
||||
/** */ void visit(IdentifierOrTemplateInstance identifierOrTemplateInstance) { identifierOrTemplateInstance.accept(this); }
|
||||
/** */ void visit(IdentityExpression identityExpression) { identityExpression.accept(this); }
|
||||
/** */ void visit(IfStatement ifStatement) { ifStatement.accept(this); }
|
||||
/** */ void visit(ImportBind importBind) { importBind.accept(this); }
|
||||
/** */ void visit(ImportBindings importBindings) { importBindings.accept(this); }
|
||||
/** */ void visit(ImportDeclaration importDeclaration) { importDeclaration.accept(this); }
|
||||
/** */ void visit(ImportExpression importExpression) { importExpression.accept(this); }
|
||||
/** */ void visit(ImportList importList) { importList.accept(this); }
|
||||
/** */ void visit(IndexExpression indexExpression) { indexExpression.accept(this); }
|
||||
/** */ void visit(InExpression inExpression) { inExpression.accept(this); }
|
||||
/** */ void visit(InStatement inStatement) { inStatement.accept(this); }
|
||||
/** */ void visit(Initialize initialize) { initialize.accept(this); }
|
||||
/** */ void visit(Initializer initializer) { initializer.accept(this); }
|
||||
/** */ void visit(InterfaceDeclaration interfaceDeclaration) { interfaceDeclaration.accept(this); }
|
||||
/** */ void visit(Invariant invariant_) { invariant_.accept(this); }
|
||||
/** */ void visit(IsExpression isExpression) { isExpression.accept(this); }
|
||||
/** */ void visit(KeyValuePair keyValuePair) { keyValuePair.accept(this); }
|
||||
/** */ void visit(KeyValuePairs keyValuePairs) { keyValuePairs.accept(this); }
|
||||
/** */ void visit(LabeledStatement labeledStatement) { labeledStatement.accept(this); }
|
||||
/** */ void visit(LambdaExpression lambdaExpression) { lambdaExpression.accept(this); }
|
||||
/** */ void visit(LastCatch lastCatch) { lastCatch.accept(this); }
|
||||
/** */ void visit(LinkageAttribute linkageAttribute) { linkageAttribute.accept(this); }
|
||||
/** */ void visit(MemberFunctionAttribute memberFunctionAttribute) { memberFunctionAttribute.accept(this); }
|
||||
/** */ void visit(MixinDeclaration mixinDeclaration) { mixinDeclaration.accept(this); }
|
||||
/** */ void visit(MixinExpression mixinExpression) { mixinExpression.accept(this); }
|
||||
/** */ void visit(MixinTemplateName mixinTemplateName) { mixinTemplateName.accept(this); }
|
||||
/** */ void visit(Module module_) { module_.accept(this); }
|
||||
/** */ void visit(ModuleDeclaration moduleDeclaration) { moduleDeclaration.accept(this); }
|
||||
/** */ void visit(MulExpression mulExpression) { mulExpression.accept(this); }
|
||||
/** */ void visit(NewAnonClassExpression newAnonClassExpression) { newAnonClassExpression.accept(this); }
|
||||
/** */ void visit(NewExpression newExpression) { newExpression.accept(this); }
|
||||
/** */ void visit(NonEmptyStatement nonEmptyStatement) { nonEmptyStatement.accept(this); }
|
||||
/** */ void visit(NonVoidInitializer nonVoidInitializer) { nonVoidInitializer.accept(this); }
|
||||
/** */ void visit(Operand operand) { operand.accept(this); }
|
||||
/** */ void visit(Operands operands) { operands.accept(this); }
|
||||
/** */ void visit(OrExpression orExpression) { orExpression.accept(this); }
|
||||
/** */ void visit(OrOrExpression orOrExpression) { orOrExpression.accept(this); }
|
||||
/** */ void visit(OutStatement outStatement) { outStatement.accept(this); }
|
||||
/** */ void visit(Parameter parameter) { parameter.accept(this); }
|
||||
/** */ void visit(ParameterAttribute parameterAttribute) { parameterAttribute.accept(this); }
|
||||
/** */ void visit(Parameters parameters) { parameters.accept(this); }
|
||||
/** */ void visit(Postblit postblit) { postblit.accept(this); }
|
||||
/** */ void visit(PostIncDecExpression postIncDecExpression) { postIncDecExpression.accept(this); }
|
||||
/** */ void visit(PowExpression powExpression) { powExpression.accept(this); }
|
||||
/** */ void visit(PragmaDeclaration pragmaDeclaration) { pragmaDeclaration.accept(this); }
|
||||
/** */ void visit(PragmaExpression pragmaExpression) { pragmaExpression.accept(this); }
|
||||
/** */ void visit(PreIncDecExpression preIncDecExpression) { preIncDecExpression.accept(this); }
|
||||
/** */ void visit(PrimaryExpression primaryExpression) { primaryExpression.accept(this); }
|
||||
/** */ void visit(Register register) { register.accept(this); }
|
||||
/** */ void visit(RelExpression relExpression) { relExpression.accept(this); }
|
||||
/** */ void visit(ReturnStatement returnStatement) { returnStatement.accept(this); }
|
||||
/** */ void visit(ScopeGuardStatement scopeGuardStatement) { scopeGuardStatement.accept(this); }
|
||||
/** */ void visit(SharedStaticConstructor sharedStaticConstructor) { sharedStaticConstructor.accept(this); }
|
||||
/** */ void visit(SharedStaticDestructor sharedStaticDestructor) { sharedStaticDestructor.accept(this); }
|
||||
/** */ void visit(ShiftExpression shiftExpression) { shiftExpression.accept(this); }
|
||||
/** */ void visit(SingleImport singleImport) { singleImport.accept(this); }
|
||||
/** */ void visit(SliceExpression sliceExpression) { sliceExpression.accept(this); }
|
||||
/** */ void visit(Statement statement) { statement.accept(this); }
|
||||
/** */ void visit(StatementNoCaseNoDefault statementNoCaseNoDefault) { statementNoCaseNoDefault.accept(this); }
|
||||
/** */ void visit(StaticAssertDeclaration staticAssertDeclaration) { staticAssertDeclaration.accept(this); }
|
||||
/** */ void visit(StaticAssertStatement staticAssertStatement) { staticAssertStatement.accept(this); }
|
||||
/** */ void visit(StaticConstructor staticConstructor) { staticConstructor.accept(this); }
|
||||
/** */ void visit(StaticDestructor staticDestructor) { staticDestructor.accept(this); }
|
||||
/** */ void visit(StaticIfCondition staticIfCondition) { staticIfCondition.accept(this); }
|
||||
/** */ void visit(StorageClass storageClass) { storageClass.accept(this); }
|
||||
/** */ void visit(StructBody structBody) { structBody.accept(this); }
|
||||
/** */ void visit(StructBodyItem structBodyItem) { structBodyItem.accept(this); }
|
||||
/** */ void visit(StructDeclaration structDeclaration) { structDeclaration.accept(this); }
|
||||
/** */ void visit(StructInitializer structInitializer) { structInitializer.accept(this); }
|
||||
/** */ void visit(StructMemberInitializer structMemberInitializer) { structMemberInitializer.accept(this); }
|
||||
/** */ void visit(StructMemberInitializers structMemberInitializers) { structMemberInitializers.accept(this); }
|
||||
/** */ void visit(SwitchBody switchBody) { switchBody.accept(this); }
|
||||
/** */ void visit(SwitchStatement switchStatement) { switchStatement.accept(this); }
|
||||
/** */ void visit(Symbol symbol) { symbol.accept(this); }
|
||||
/** */ void visit(SynchronizedStatement synchronizedStatement) { synchronizedStatement.accept(this); }
|
||||
/** */ void visit(TemplateAliasParameter templateAliasParameter) { templateAliasParameter.accept(this); }
|
||||
/** */ void visit(TemplateArgument templateArgument) { templateArgument.accept(this); }
|
||||
/** */ void visit(TemplateArgumentList templateArgumentList) { templateArgumentList.accept(this); }
|
||||
/** */ void visit(TemplateArguments templateArguments) { templateArguments.accept(this); }
|
||||
/** */ void visit(TemplateDeclaration templateDeclaration) { templateDeclaration.accept(this); }
|
||||
/** */ void visit(TemplateInstance templateInstance) { templateInstance.accept(this); }
|
||||
/** */ void visit(TemplateMixinStatement templateMixinStatement) { templateMixinStatement.accept(this); }
|
||||
/** */ void visit(TemplateParameter templateParameter) { templateParameter.accept(this); }
|
||||
/** */ void visit(TemplateParameterList templateParameterList) { templateParameterList.accept(this); }
|
||||
/** */ void visit(TemplateParameters templateParameters) { templateParameters.accept(this); }
|
||||
/** */ void visit(TemplateSingleArgument templateSingleArgument) { templateSingleArgument.accept(this); }
|
||||
/** */ void visit(TemplateThisParameter templateThisParameter) { templateThisParameter.accept(this); }
|
||||
/** */ void visit(TemplateTupleParameter templateTupleParameter) { templateTupleParameter.accept(this); }
|
||||
/** */ void visit(TemplateTypeParameter templateTypeParameter) { templateTypeParameter.accept(this); }
|
||||
/** */ void visit(TemplateValueParameter templateValueParameter) { templateValueParameter.accept(this); }
|
||||
/** */ void visit(TemplateValueParameterDefault templateValueParameterDefault) { templateValueParameterDefault.accept(this); }
|
||||
/** */ void visit(TernaryExpression ternaryExpression) { ternaryExpression.accept(this); }
|
||||
/** */ void visit(ThrowStatement throwStatement) { throwStatement.accept(this); }
|
||||
/** */ void visit(TraitsArgument traitsArgument) { traitsArgument.accept(this); }
|
||||
/** */ void visit(TraitsExpression traitsExpression) { traitsExpression.accept(this); }
|
||||
/** */ void visit(TryStatement tryStatement) { tryStatement.accept(this); }
|
||||
/** */ void visit(Type type) { type.accept(this); }
|
||||
/** */ void visit(Type2 type2) { type2.accept(this); }
|
||||
/** */ void visit(TypeConstructor typeConstructor) { typeConstructor.accept(this); }
|
||||
/** */ void visit(TypeConstructors typeConstructors) { typeConstructors.accept(this); }
|
||||
/** */ void visit(TypeSpecialization typeSpecialization) { typeSpecialization.accept(this); }
|
||||
/** */ void visit(TypeSuffix typeSuffix) { typeSuffix.accept(this); }
|
||||
/** */ void visit(TypeidExpression typeidExpression) { typeidExpression.accept(this); }
|
||||
/** */ void visit(TypeofExpression typeofExpression) { typeofExpression.accept(this); }
|
||||
/** */ void visit(UnaryExpression unaryExpression) { unaryExpression.accept(this); }
|
||||
/** */ void visit(UnionDeclaration unionDeclaration) { unionDeclaration.accept(this); }
|
||||
/** */ void visit(Unittest unittest_) { unittest_.accept(this); }
|
||||
/** */ void visit(VariableDeclaration variableDeclaration) { variableDeclaration.accept(this); }
|
||||
/** */ void visit(VersionCondition versionCondition) { versionCondition.accept(this); }
|
||||
/** */ void visit(VersionSpecification versionSpecification) { versionSpecification.accept(this); }
|
||||
/** */ void visit(WhileStatement whileStatement) { whileStatement.accept(this); }
|
||||
/** */ void visit(WithStatement withStatement) { withStatement.accept(this); }
|
||||
/** */ void visit(XorExpression xorExpression) { xorExpression.accept(this); }
|
||||
}
|
||||
|
||||
interface ASTNode
|
||||
|
|
@ -241,7 +238,6 @@ interface ASTNode
|
|||
/** */ void accept(ASTVisitor visitor);
|
||||
}
|
||||
|
||||
immutable string OVERRIDE_DEFAULT_ACCEPT = q{override void accept(ASTVisitor visitor) { visitor.visit(this); }};
|
||||
immutable string DEFAULT_ACCEPT = q{void accept(ASTVisitor visitor) { visitor.visit(this); }};
|
||||
|
||||
|
||||
|
|
@ -262,10 +258,10 @@ public:
|
|||
}
|
||||
|
||||
///
|
||||
class AliasDeclaration : Declaration
|
||||
class AliasDeclaration : ASTNode
|
||||
{
|
||||
public:
|
||||
mixin(OVERRIDE_DEFAULT_ACCEPT);
|
||||
mixin(DEFAULT_ACCEPT);
|
||||
/** */Type type;
|
||||
/** */Declarator declarator;
|
||||
/** */AliasInitializer[] initializations;
|
||||
|
|
@ -281,10 +277,10 @@ public:
|
|||
}
|
||||
|
||||
///
|
||||
class AliasThisDeclaration : Declaration
|
||||
class AliasThisDeclaration : ASTNode
|
||||
{
|
||||
public:
|
||||
mixin(OVERRIDE_DEFAULT_ACCEPT);
|
||||
mixin(DEFAULT_ACCEPT);
|
||||
/** */Token identifier;
|
||||
}
|
||||
|
||||
|
|
@ -826,7 +822,34 @@ public:
|
|||
class Declaration : ASTNode
|
||||
{
|
||||
public:
|
||||
mixin(DEFAULT_ACCEPT);
|
||||
|
||||
override void accept(ASTVisitor visitor)
|
||||
{
|
||||
if (attributedDeclaration !is null) visitor.visit(attributedDeclaration);
|
||||
if (importDeclaration !is null) visitor.visit(importDeclaration);
|
||||
if (functionDeclaration !is null) visitor.visit(functionDeclaration);
|
||||
if (variableDeclaration !is null) visitor.visit(variableDeclaration);
|
||||
if (aliasThisDeclaration !is null) visitor.visit(aliasThisDeclaration);
|
||||
if (structDeclaration !is null) visitor.visit(structDeclaration);
|
||||
if (classDeclaration !is null) visitor.visit(classDeclaration);
|
||||
if (interfaceDeclaration !is null) visitor.visit(interfaceDeclaration);
|
||||
if (unionDeclaration !is null) visitor.visit(unionDeclaration);
|
||||
if (enumDeclaration !is null) visitor.visit(enumDeclaration);
|
||||
if (aliasDeclaration !is null) visitor.visit(aliasDeclaration);
|
||||
if (mixinDeclaration !is null) visitor.visit(mixinDeclaration);
|
||||
if (unittest_ !is null) visitor.visit(unittest_);
|
||||
if (staticAssertDeclaration !is null) visitor.visit(staticAssertDeclaration);
|
||||
if (templateDeclaration !is null) visitor.visit(templateDeclaration);
|
||||
if (constructor !is null) visitor.visit(constructor);
|
||||
if (destructor !is null) visitor.visit(destructor);
|
||||
if (staticConstructor !is null) visitor.visit(staticConstructor);
|
||||
if (staticDestructor !is null) visitor.visit(staticDestructor);
|
||||
if (sharedStaticDestructor !is null) visitor.visit(sharedStaticDestructor);
|
||||
if (sharedStaticConstructor !is null) visitor.visit(sharedStaticConstructor);
|
||||
if (conditionalDeclaration !is null) visitor.visit(conditionalDeclaration);
|
||||
if (pragmaDeclaration !is null) visitor.visit(pragmaDeclaration);
|
||||
}
|
||||
|
||||
/** */ AttributedDeclaration attributedDeclaration;
|
||||
/** */ ImportDeclaration importDeclaration;
|
||||
/** */ FunctionDeclaration functionDeclaration;
|
||||
|
|
@ -873,19 +896,9 @@ class Declarator : ASTNode
|
|||
public:
|
||||
mixin(DEFAULT_ACCEPT);
|
||||
/** */ Token identifier;
|
||||
/** */ DeclaratorSuffix declaratorSuffix;
|
||||
/** */ Initializer initializer;
|
||||
}
|
||||
|
||||
///
|
||||
class DeclaratorSuffix : ASTNode
|
||||
{
|
||||
public:
|
||||
mixin(DEFAULT_ACCEPT);
|
||||
/** */ Type type;
|
||||
/** */ AssignExpression assignExpression;
|
||||
}
|
||||
|
||||
///
|
||||
class DefaultStatement : ASTNode
|
||||
{
|
||||
|
|
@ -1086,16 +1099,17 @@ public:
|
|||
}
|
||||
|
||||
///
|
||||
class FunctionDeclaration : Declaration
|
||||
class FunctionDeclaration : ASTNode
|
||||
{
|
||||
public:
|
||||
mixin(OVERRIDE_DEFAULT_ACCEPT);
|
||||
mixin(DEFAULT_ACCEPT);
|
||||
/** */ Type returnType;
|
||||
/** */ Token name;
|
||||
/** */ TemplateParameters templateParameters;
|
||||
/** */ Parameters parameters;
|
||||
/** */ Constraint constraint;
|
||||
/** */ FunctionBody functionBody;
|
||||
/** */ MemberFunctionAttribute[] memberFunctionAttributes;
|
||||
}
|
||||
|
||||
///
|
||||
|
|
@ -1191,10 +1205,10 @@ public:
|
|||
}
|
||||
|
||||
///
|
||||
class ImportDeclaration : Declaration
|
||||
class ImportDeclaration : ASTNode
|
||||
{
|
||||
public:
|
||||
mixin(OVERRIDE_DEFAULT_ACCEPT);
|
||||
mixin(DEFAULT_ACCEPT);
|
||||
/** */ SingleImport[] singleImports;
|
||||
/** */ ImportBindings importBindings;
|
||||
}
|
||||
|
|
@ -1384,7 +1398,13 @@ public:
|
|||
class Module : ASTNode
|
||||
{
|
||||
public:
|
||||
mixin(DEFAULT_ACCEPT);
|
||||
override void accept(ASTVisitor visitor)
|
||||
{
|
||||
if (moduleDeclaration !is null)
|
||||
visitor.visit(moduleDeclaration);
|
||||
foreach(d; declarations)
|
||||
visitor.visit(d);
|
||||
}
|
||||
/** */ ModuleDeclaration moduleDeclaration;
|
||||
/** */ Declaration[] declarations;
|
||||
}
|
||||
|
|
@ -2071,6 +2091,7 @@ class Type : ASTNode
|
|||
public:
|
||||
mixin(DEFAULT_ACCEPT);
|
||||
/** */ TypeConstructors typeConstructors;
|
||||
/** */ TypeSuffix[] typeSuffixes;
|
||||
/** */ Type2 type2;
|
||||
}
|
||||
|
||||
|
|
@ -2079,17 +2100,7 @@ class Type2 : ASTNode
|
|||
{
|
||||
public:
|
||||
mixin(DEFAULT_ACCEPT);
|
||||
/** */ Type2 type2;
|
||||
/** */ Type3 type3;
|
||||
/** */ TypeSuffix typeSuffix;
|
||||
}
|
||||
|
||||
///
|
||||
class Type3 : ASTNode
|
||||
{
|
||||
public:
|
||||
mixin(DEFAULT_ACCEPT);
|
||||
/** */ BasicType builtinType;
|
||||
/** */ BasicType basicType;
|
||||
/** */ Symbol symbol;
|
||||
/** */ TypeofExpression typeofExpression;
|
||||
/** */ IdentifierOrTemplateChain identifierOrTemplateChain;
|
||||
|
|
@ -2194,10 +2205,10 @@ public:
|
|||
}
|
||||
|
||||
///
|
||||
class VariableDeclaration : Declaration
|
||||
class VariableDeclaration : ASTNode
|
||||
{
|
||||
public:
|
||||
mixin(OVERRIDE_DEFAULT_ACCEPT);
|
||||
mixin(DEFAULT_ACCEPT);
|
||||
/** */ Type type;
|
||||
/** */ Declarator[] declarators;
|
||||
/** */ StorageClass storageClass;
|
||||
|
|
|
|||
|
|
@ -2505,7 +2505,7 @@ bool isRangeEoF(R)(ref R range)
|
|||
}
|
||||
|
||||
// Lookup table for token values
|
||||
immutable(string[TokenType.max + 1]) tokenValues = [
|
||||
package immutable(string[TokenType.max + 1]) tokenValues = [
|
||||
"=",
|
||||
"@",
|
||||
"&",
|
||||
|
|
|
|||
336
std/d/parser.d
336
std/d/parser.d
|
|
@ -70,16 +70,17 @@ import std.array;
|
|||
version (unittest) import std.stdio;
|
||||
|
||||
version = development;
|
||||
version(development) import std.stdio;
|
||||
|
||||
/**
|
||||
* Params:
|
||||
* tokens = the tokens parsed by std.d.lexer
|
||||
* Returns: the parsed module
|
||||
*/
|
||||
Module parseModule(R)(R tokens) if (is (ElementType!R == Token))
|
||||
Module parseModule(const(Token)[] tokens)
|
||||
{
|
||||
auto parser = new Parser();
|
||||
parser.tokens = tokens.array();
|
||||
parser.tokens = tokens;
|
||||
return parser.parseModule();
|
||||
}
|
||||
|
||||
|
|
@ -720,7 +721,7 @@ struct Parser
|
|||
* | $(LITERAL 'const')
|
||||
* | $(LITERAL 'auto')
|
||||
* | $(LITERAL 'scope')
|
||||
* | $(LITERAL 'gshared')
|
||||
* | $(LITERAL '___gshared')
|
||||
* | $(LITERAL 'shared')
|
||||
* | $(LITERAL 'immutable')
|
||||
* | $(LITERAL 'inout')
|
||||
|
|
@ -829,8 +830,9 @@ struct Parser
|
|||
{
|
||||
auto node = new BlockStatement();
|
||||
expect(TokenType.lBrace);
|
||||
if (!currentIs(TokenType.rBrace))
|
||||
node.declarationsAndStatements = parseDeclarationsAndStatements();
|
||||
skipBraceContent();
|
||||
//if (!currentIs(TokenType.rBrace))
|
||||
// node.declarationsAndStatements = parseDeclarationsAndStatements();
|
||||
expect(TokenType.rBrace);
|
||||
return node;
|
||||
}
|
||||
|
|
@ -1506,6 +1508,7 @@ class ClassFour(A, B) if (someTest()) : Super {}};
|
|||
*/
|
||||
Declaration parseDeclaration()
|
||||
{
|
||||
import std.stdio;
|
||||
auto node = new Declaration;
|
||||
switch (current().type)
|
||||
{
|
||||
|
|
@ -1540,17 +1543,22 @@ class ClassFour(A, B) if (someTest()) : Super {}};
|
|||
node.pragmaDeclaration = parsePragmaDeclaration();
|
||||
break;
|
||||
case TokenType.shared_:
|
||||
// TODO:
|
||||
// sharedStaticConstructor shared static this
|
||||
// sharedStaticDestructor shared static ~ this
|
||||
// attributedDeclaration shared anything else
|
||||
if (startsWith(TokenType.shared_, TokenType.static_, TokenType.this_))
|
||||
node.sharedStaticConstructor = parseSharedStaticConstructor();
|
||||
else if (startsWith(TokenType.shared_, TokenType.static_, TokenType.tilde))
|
||||
node.sharedStaticDestructor = parseSharedStaticDestructor();
|
||||
else
|
||||
node.attributedDeclaration = parseAttributedDeclaration();
|
||||
break;
|
||||
case TokenType.static_:
|
||||
// TODO:
|
||||
// staticConstructor static this
|
||||
// staticDestructor static ~
|
||||
// attributedDeclaration static anything else
|
||||
// conditionalDeclaration static if
|
||||
if (startsWith(TokenType.static_, TokenType.this_))
|
||||
node.staticConstructor = parseStaticConstructor();
|
||||
else if (startsWith(TokenType.static_, TokenType.tilde))
|
||||
node.staticDestructor = parseStaticDestructor();
|
||||
else if (startsWith(TokenType.static_, TokenType.if_))
|
||||
node.conditionalDeclaration = parseConditionalDeclaration();
|
||||
else
|
||||
node.attributedDeclaration = parseAttributedDeclaration();
|
||||
break;
|
||||
case TokenType.struct_:
|
||||
node.structDeclaration = parseStructDeclaration();
|
||||
|
|
@ -1564,17 +1572,53 @@ class ClassFour(A, B) if (someTest()) : Super {}};
|
|||
case TokenType.unittest_:
|
||||
node.unittest_ = parseUnittest();
|
||||
break;
|
||||
case TokenType.bool_: .. case TokenType.wchar_:
|
||||
case TokenType.identifier:
|
||||
// TODO:
|
||||
// variableDeclaration
|
||||
// functionDeclaration
|
||||
Type type = parseType();
|
||||
if (!currentIs(TokenType.identifier))
|
||||
{
|
||||
error("Identifier expected");
|
||||
return null;
|
||||
}
|
||||
if (peekIs(TokenType.lParen))
|
||||
node.functionDeclaration = parseFunctionDeclaration(type);
|
||||
else
|
||||
node.variableDeclaration = parseVariableDeclaration(type);
|
||||
break;
|
||||
case TokenType.version_:
|
||||
case TokenType.debug_:
|
||||
node.conditionalDeclaration = parseConditionalDeclaration();
|
||||
break;
|
||||
case TokenType.at:
|
||||
case TokenType.extern_:
|
||||
case TokenType.align_:
|
||||
//case TokenType.pragma_:
|
||||
case TokenType.deprecated_:
|
||||
case TokenType.private_:
|
||||
case TokenType.package_:
|
||||
case TokenType.protected_:
|
||||
case TokenType.public_:
|
||||
case TokenType.export_:
|
||||
//case TokenType.extern_:
|
||||
case TokenType.final_:
|
||||
case TokenType.synchronized_:
|
||||
case TokenType.override_:
|
||||
case TokenType.abstract_:
|
||||
case TokenType.const_:
|
||||
case TokenType.auto_:
|
||||
case TokenType.scope_:
|
||||
case TokenType.gshared:
|
||||
//case TokenType.shared_:
|
||||
case TokenType.immutable_:
|
||||
case TokenType.inout_:
|
||||
//case TokenType.static_:
|
||||
case TokenType.pure_:
|
||||
case TokenType.nothrow_:
|
||||
node.attributedDeclaration = parseAttributedDeclaration();
|
||||
break;
|
||||
default:
|
||||
error("Declaration expected");
|
||||
advance();
|
||||
return null;
|
||||
}
|
||||
return node;
|
||||
|
|
@ -1616,15 +1660,20 @@ class ClassFour(A, B) if (someTest()) : Super {}};
|
|||
* Parses a Declarator
|
||||
*
|
||||
* $(GRAMMAR $(RULEDEF declarator):
|
||||
* $(LITERAL Identifier) $(RULE declaratorSuffix)? ($(LITERAL '=') $(RULE initializer))?
|
||||
* $(LITERAL Identifier) ($(LITERAL '=') $(RULE initializer))?
|
||||
* ;)
|
||||
*/
|
||||
Declarator parseDeclarator()
|
||||
{
|
||||
auto node = new Declarator;
|
||||
node.identifier = *expect(TokenType.identifier);
|
||||
if (currentIs(TokenType.lBracket))
|
||||
node.declaratorSuffix = parseDeclaratorSuffix();
|
||||
auto id = expect(TokenType.identifier);
|
||||
if (id is null) return null;
|
||||
node.identifier = *id;
|
||||
if (currentIsOneOf(TokenType.lBracket, TokenType.star))
|
||||
{
|
||||
error("C-style variable declarations are not supported.");
|
||||
return null;
|
||||
}
|
||||
if (currentIs(TokenType.assign))
|
||||
{
|
||||
advance();
|
||||
|
|
@ -1633,20 +1682,6 @@ class ClassFour(A, B) if (someTest()) : Super {}};
|
|||
return node;
|
||||
}
|
||||
|
||||
/**
|
||||
* Parses a DeclaratorSuffix
|
||||
*
|
||||
* $(GRAMMAR $(RULEDEF declaratorSuffix):
|
||||
* $(LITERAL '[') ($(RULE type) | $(RULE assignExpression))? $(LITERAL ']')
|
||||
* ;)
|
||||
*/
|
||||
DeclaratorSuffix parseDeclaratorSuffix()
|
||||
{
|
||||
auto node = new DeclaratorSuffix;
|
||||
// TODO
|
||||
return node;
|
||||
}
|
||||
|
||||
/**
|
||||
* Parses a DefaultStatement
|
||||
*
|
||||
|
|
@ -1730,6 +1765,17 @@ class ClassFour(A, B) if (someTest()) : Super {}};
|
|||
return node;
|
||||
}
|
||||
|
||||
unittest
|
||||
{
|
||||
auto sourceCode = q{~this(){}}c;
|
||||
Parser p = getParserForUnittest(sourceCode, "parseDestructor");
|
||||
Destructor d = p.parseDestructor();
|
||||
assert (d !is null);
|
||||
assert (d.functionBody !is null);
|
||||
assert (p.errorCount == 0);
|
||||
stderr.writeln("Unittest for parseDestructor() passed.");
|
||||
}
|
||||
|
||||
/**
|
||||
* Parses a DoStatement
|
||||
*
|
||||
|
|
@ -2080,10 +2126,56 @@ body {} // six
|
|||
* | $(RULE memberFunctionAttribute)* ($(RULE type) | $(LITERAL 'auto') $(LITERAL 'ref')? | $(LITERAL 'ref') $(LITERAL 'auto')?) $(LITERAL Identifier) $(RULE parameters) $(RULE memberFunctionAttribute)* ($(RULE functionBody) | $(LITERAL ';'))
|
||||
* ;)
|
||||
*/
|
||||
FunctionDeclaration parseFunctionDeclaration()
|
||||
FunctionDeclaration parseFunctionDeclaration(Type type = null)
|
||||
{
|
||||
auto node = new FunctionDeclaration;
|
||||
// TODO
|
||||
|
||||
while(moreTokens() && currentIsMemberFunctionAttribute())
|
||||
node.memberFunctionAttributes ~= parseMemberFunctionAttribute();
|
||||
|
||||
switch (current.type)
|
||||
{
|
||||
case TokenType.auto_:
|
||||
break;
|
||||
case TokenType.ref_:
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
node.returnType = type is null ? parseType() : type;
|
||||
|
||||
auto ident = expect(TokenType.identifier);
|
||||
if (ident is null) return null;
|
||||
|
||||
node.name = *ident;
|
||||
|
||||
if (!currentIs(TokenType.lParen))
|
||||
{
|
||||
error(`"(" expected`);
|
||||
return null;
|
||||
}
|
||||
|
||||
bool isTemplate = peekPastParens().type == TokenType.lParen;
|
||||
|
||||
if (isTemplate)
|
||||
node.templateParameters = parseTemplateParameters();
|
||||
|
||||
node.parameters = parseParameters();
|
||||
|
||||
while(moreTokens() && currentIsMemberFunctionAttribute())
|
||||
node.memberFunctionAttributes ~= parseMemberFunctionAttribute();
|
||||
|
||||
if (isTemplate && currentIs(TokenType.if_))
|
||||
node.constraint = parseConstraint();
|
||||
|
||||
if (isTemplate)
|
||||
node.functionBody = parseFunctionBody();
|
||||
else if (currentIs(TokenType.semicolon))
|
||||
advance();
|
||||
else
|
||||
node.functionBody = parseFunctionBody();
|
||||
|
||||
return node;
|
||||
}
|
||||
|
||||
|
|
@ -2736,9 +2828,9 @@ interface "Four"
|
|||
Module parseModule()
|
||||
{
|
||||
Module m = new Module;
|
||||
while (index < tokens.length)
|
||||
while (moreTokens())
|
||||
{
|
||||
switch (tokens[index].type)
|
||||
switch (current().type)
|
||||
{
|
||||
case TokenType.module_:
|
||||
if (m.moduleDeclaration is null)
|
||||
|
|
@ -2747,7 +2839,9 @@ interface "Four"
|
|||
error("Only one module declaration is allowed per module");
|
||||
break;
|
||||
default:
|
||||
m.declarations ~= parseDeclaration();
|
||||
auto declaration = parseDeclaration();
|
||||
if (declaration !is null)
|
||||
m.declarations ~= declaration;
|
||||
}
|
||||
}
|
||||
return m;
|
||||
|
|
@ -3001,7 +3095,9 @@ interface "Four"
|
|||
Parameters parseParameters()
|
||||
{
|
||||
auto node = new Parameters;
|
||||
// TODO
|
||||
expect(TokenType.lParen);
|
||||
version(development) skipParenContent();
|
||||
expect(TokenType.rParen);
|
||||
return node;
|
||||
}
|
||||
|
||||
|
|
@ -3958,13 +4054,38 @@ interface "Four"
|
|||
* Parses a Type
|
||||
*
|
||||
* $(GRAMMAR $(RULEDEF type):
|
||||
* $(RULE typeConstructors)? $(RULE type2)
|
||||
* $(RULE typeConstructors)? $(RULE type2) $(RULE typeSuffix)*
|
||||
* ;)
|
||||
*/
|
||||
Type parseType()
|
||||
{
|
||||
auto node = new Type;
|
||||
// TODO
|
||||
switch(current.type)
|
||||
{
|
||||
case TokenType.const_:
|
||||
case TokenType.immutable_:
|
||||
case TokenType.inout_:
|
||||
case TokenType.shared_:
|
||||
node.typeConstructors = parseTypeConstructors();
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
node.type2 = parseType2();
|
||||
loop: while (true)
|
||||
{
|
||||
switch (current.type)
|
||||
{
|
||||
case TokenType.star:
|
||||
case TokenType.lBracket:
|
||||
case TokenType.delegate_:
|
||||
case TokenType.function_:
|
||||
node.typeSuffixes ~= parseTypeSuffix();
|
||||
break;
|
||||
default:
|
||||
break loop;
|
||||
}
|
||||
}
|
||||
return node;
|
||||
}
|
||||
|
||||
|
|
@ -3972,31 +4093,45 @@ interface "Four"
|
|||
* Parses a Type2
|
||||
*
|
||||
* $(GRAMMAR $(RULEDEF type2):
|
||||
* $(RULE type3) $(RULE typeSuffix)?
|
||||
* | $(RULE type2) $(RULE typeSuffix)
|
||||
* ;)
|
||||
*/
|
||||
Type2 parseType2()
|
||||
{
|
||||
auto node = new Type2;
|
||||
// TODO
|
||||
return node;
|
||||
}
|
||||
|
||||
/**
|
||||
* Parses a Type3
|
||||
*
|
||||
* $(GRAMMAR $(RULEDEF type3):
|
||||
* $(RULE builtinType)
|
||||
* | $(RULE symbol)
|
||||
* | $(RULE typeofExpression) ($(LITERAL '.') $(RULE identifierOrTemplateChain))?
|
||||
* | $(RULE typeConstructor) $(LITERAL '$(LPAREN)') $(RULE type) $(LITERAL '$(RPAREN)')
|
||||
* ;)
|
||||
*/
|
||||
Type3 parseType3()
|
||||
Type2 parseType2()
|
||||
{
|
||||
auto node = new Type3;
|
||||
// TODO
|
||||
auto node = new Type2;
|
||||
switch (current.type)
|
||||
{
|
||||
case TokenType.identifier:
|
||||
case TokenType.dot:
|
||||
node.symbol = parseSymbol();
|
||||
break;
|
||||
case TokenType.bool_: .. case TokenType.wchar_:
|
||||
node.basicType = parseBasicType();
|
||||
break;
|
||||
case TokenType.typeof_:
|
||||
node.typeofExpression = parseTypeofExpression();
|
||||
if (currentIs(TokenType.dot))
|
||||
{
|
||||
advance();
|
||||
node.identifierOrTemplateChain = parseIdentifierOrTemplateChain();
|
||||
}
|
||||
break;
|
||||
case TokenType.const_:
|
||||
case TokenType.immutable_:
|
||||
case TokenType.inout_:
|
||||
case TokenType.shared_:
|
||||
node.typeConstructor = parseTypeConstructor();
|
||||
expect(TokenType.lParen);
|
||||
node.type = parseType();
|
||||
expect(TokenType.rParen);
|
||||
break;
|
||||
default:
|
||||
error("Basic type, type constructor, symbol, or typeof expected");
|
||||
break;
|
||||
}
|
||||
return node;
|
||||
}
|
||||
|
||||
|
|
@ -4086,7 +4221,8 @@ interface "Four"
|
|||
case TokenType.function_:
|
||||
advance();
|
||||
node.parameters = parseParameters();
|
||||
// TODO: memberFunctionAttribute
|
||||
while (currentIsMemberFunctionAttribute())
|
||||
node.memberFunctionAttributes ~= parseMemberFunctionAttribute();
|
||||
return node;
|
||||
default:
|
||||
error(`"*", "[", "delegate", or "function" expected.`);
|
||||
|
|
@ -4249,10 +4385,29 @@ interface "Four"
|
|||
* | $(RULE autoDeclaration)
|
||||
* ;)
|
||||
*/
|
||||
VariableDeclaration parseVariableDeclaration()
|
||||
VariableDeclaration parseVariableDeclaration(Type type = null)
|
||||
{
|
||||
auto node = new VariableDeclaration;
|
||||
// TODO
|
||||
|
||||
if (currentIs(TokenType.auto_))
|
||||
{
|
||||
node.autoDeclaration = parseAutoDeclaration();
|
||||
return node;
|
||||
}
|
||||
|
||||
node.type = type is null ? parseType() : type;
|
||||
|
||||
while(true)
|
||||
{
|
||||
auto declarator = parseDeclarator();
|
||||
if (declarator is null) return null;
|
||||
node.declarators ~= declarator;
|
||||
if (moreTokens() && currentIs(TokenType.comma))
|
||||
advance();
|
||||
else
|
||||
break;
|
||||
}
|
||||
expect(TokenType.semicolon);
|
||||
return node;
|
||||
}
|
||||
|
||||
|
|
@ -4355,18 +4510,42 @@ interface "Four"
|
|||
return node;
|
||||
}
|
||||
|
||||
void error(string message)
|
||||
private bool currentIsMemberFunctionAttribute() const
|
||||
{
|
||||
++errorCount;
|
||||
import std.stdio;
|
||||
stderr.writefln("%s(%d:%d): %s", fileName, tokens[index].line,
|
||||
tokens[index].column, message);
|
||||
while (index < tokens.length)
|
||||
switch (current.type)
|
||||
{
|
||||
if (tokens[index].type == TokenType.semicolon)
|
||||
case TokenType.const_:
|
||||
case TokenType.immutable_:
|
||||
case TokenType.inout_:
|
||||
case TokenType.shared_:
|
||||
case TokenType.at:
|
||||
case TokenType.pure_:
|
||||
case TokenType.nothrow_:
|
||||
return true;
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
void error(lazy string message)
|
||||
{
|
||||
import std.stdio;
|
||||
++errorCount;
|
||||
if (errorFunction is null)
|
||||
stderr.writefln("%s(%d:%d): %s", fileName, tokens[index].line,
|
||||
tokens[index].column, message);
|
||||
else
|
||||
errorFunction(fileName, tokens[index].line, tokens[index].column,
|
||||
message);
|
||||
while (moreTokens())
|
||||
{
|
||||
if (currentIsOneOf(TokenType.semicolon, TokenType.rBrace))
|
||||
{
|
||||
advance();
|
||||
break;
|
||||
}
|
||||
else
|
||||
index++;
|
||||
advance();
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -4472,8 +4651,8 @@ interface "Four"
|
|||
return &tokens[index++];
|
||||
else
|
||||
{
|
||||
error("Expected " ~ to!string(type) ~ " instead of "
|
||||
~ to!string(tokens[index].type));
|
||||
error("Expected " ~ tokenValues[type] ~ " instead of "
|
||||
~ tokens[index].value);
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
|
@ -4481,7 +4660,7 @@ interface "Four"
|
|||
/**
|
||||
* Returns: the _current token
|
||||
*/
|
||||
Token current() const
|
||||
Token current() const @property
|
||||
{
|
||||
return tokens[index];
|
||||
}
|
||||
|
|
@ -4525,15 +4704,19 @@ interface "Four"
|
|||
*/
|
||||
bool moreTokens() const
|
||||
{
|
||||
return index < tokens.length;
|
||||
return index + 1 < tokens.length;
|
||||
}
|
||||
|
||||
version (unittest) static void doNothingErrorFunction(string fileName,
|
||||
int line, int column, string message) {}
|
||||
|
||||
version (unittest) static Parser getParserForUnittest(string sourceCode,
|
||||
string testName)
|
||||
{
|
||||
LexerConfig config;
|
||||
auto r = byToken(cast(const(ubyte)[]) sourceCode, config);
|
||||
Parser p;
|
||||
p.errorFunction = &doNothingErrorFunction;
|
||||
p.fileName = testName ~ ".d";
|
||||
p.tokens = r.array();
|
||||
return p;
|
||||
|
|
@ -4543,4 +4726,5 @@ interface "Four"
|
|||
const(Token)[] tokens;
|
||||
size_t index;
|
||||
string fileName;
|
||||
void function(string, int, int, string) errorFunction;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -0,0 +1,50 @@
|
|||
import std.d.lexer;
|
||||
import std.d.ast;
|
||||
import std.d.parser;
|
||||
import std.stdio;
|
||||
import std.file;
|
||||
import std.array;
|
||||
|
||||
class TestVisitor : ASTVisitor
|
||||
{
|
||||
override void visit(ClassDeclaration classDeclaration)
|
||||
{
|
||||
writeln("class ", classDeclaration.name.value, " on line ", classDeclaration.name.line);
|
||||
}
|
||||
|
||||
override void visit(ModuleDeclaration md)
|
||||
{
|
||||
writeln("module declaration found");
|
||||
}
|
||||
|
||||
override void visit(FunctionDeclaration funDec)
|
||||
{
|
||||
writeln("function ", funDec.name.value, " on line ", funDec.name.line);
|
||||
}
|
||||
|
||||
override void visit(VariableDeclaration varDec)
|
||||
{
|
||||
writeln("variable ", varDec.declarators[0].identifier.value,
|
||||
" on line ", varDec.declarators[0].identifier.line);
|
||||
}
|
||||
|
||||
override void visit(ImportDeclaration impDec)
|
||||
{
|
||||
writeln("import declaration found");
|
||||
}
|
||||
|
||||
alias ASTVisitor.visit visit;
|
||||
}
|
||||
|
||||
void main(string[] args)
|
||||
{
|
||||
auto de = dirEntry(args[1]);
|
||||
ubyte[] sourceBuffer = new ubyte[de.size];
|
||||
auto f = File(args[1]);
|
||||
ubyte[] rawSource = f.rawRead(sourceBuffer);
|
||||
LexerConfig config;
|
||||
auto tokens = byToken(rawSource, config).array();
|
||||
Module m = parseModule(tokens);
|
||||
ASTVisitor visitor = new TestVisitor;
|
||||
visitor.visit(m);
|
||||
}
|
||||
Loading…
Reference in New Issue