forks
/
D-Scanner
mirror of https://github.com/dlang-community/D-Scanner.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Getting closer

This commit is contained in:
Hackerpilot 2013-07-07 22:20:41 -07:00
parent 3acdffdc6b
commit 3f0994c4d2
2 changed files with 140 additions and 157 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

30
std/d/ast.d
View File

@ -72,7 +72,6 @@ abstract class ASTVisitor
/** */ void visit(CastQualifier castQualifier) { castQualifier.accept(this); } /** */ void visit(CastQualifier castQualifier) { castQualifier.accept(this); }
/** */ void visit(Catch catch_) { catch_.accept(this); } /** */ void visit(Catch catch_) { catch_.accept(this); }
/** */ void visit(Catches catches) { catches.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(ClassDeclaration classDeclaration) { classDeclaration.accept(this); }
/** */ void visit(CmpExpression cmpExpression) { cmpExpression.accept(this); } /** */ void visit(CmpExpression cmpExpression) { cmpExpression.accept(this); }
/** */ void visit(CompileCondition compileCondition) { compileCondition.accept(this); } /** */ void visit(CompileCondition compileCondition) { compileCondition.accept(this); }
@ -180,7 +179,6 @@ abstract class ASTVisitor
/** */ void visit(StaticIfCondition staticIfCondition) { staticIfCondition.accept(this); } /** */ void visit(StaticIfCondition staticIfCondition) { staticIfCondition.accept(this); }
/** */ void visit(StorageClass storageClass) { storageClass.accept(this); } /** */ void visit(StorageClass storageClass) { storageClass.accept(this); }
/** */ void visit(StructBody structBody) { structBody.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(StructDeclaration structDeclaration) { structDeclaration.accept(this); }
/** */ void visit(StructInitializer structInitializer) { structInitializer.accept(this); } /** */ void visit(StructInitializer structInitializer) { structInitializer.accept(this); }
/** */ void visit(StructMemberInitializer structMemberInitializer) { structMemberInitializer.accept(this); } /** */ void visit(StructMemberInitializer structMemberInitializer) { structMemberInitializer.accept(this); }
@ -675,14 +673,6 @@ public:
/** */ StatementNoCaseNoDefault statementNoCaseNoDefault; /** */ StatementNoCaseNoDefault statementNoCaseNoDefault;
} }
///
class ClassBody: ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
/** */ DeclarationOrInvariant[] declarationOrInvariants;
}
/// ///
class ClassDeclaration: ASTNode class ClassDeclaration: ASTNode
{ {
@ -692,7 +682,7 @@ public:
/** */ TemplateParameters templateParameters; /** */ TemplateParameters templateParameters;
/** */ Constraint constraint; /** */ Constraint constraint;
/** */ BaseClassList baseClassList; /** */ BaseClassList baseClassList;
/** */ ClassBody classBody; /** */ StructBody structBody;
} }
/// ///
@ -842,6 +832,8 @@ public:
/** */ ConditionalDeclaration conditionalDeclaration; /** */ ConditionalDeclaration conditionalDeclaration;
/** */ PragmaDeclaration pragmaDeclaration; /** */ PragmaDeclaration pragmaDeclaration;
/** */ VersionSpecification versionSpecification; /** */ VersionSpecification versionSpecification;
/** */ Invariant invariant_;
/** */ Postblit postblit;
/** */ Declaration[] declarations; /** */ Declaration[] declarations;
} }
@ -1426,7 +1418,7 @@ public:
/** */ Arguments allocatorArguments; /** */ Arguments allocatorArguments;
/** */ Arguments constructorArguments; /** */ Arguments constructorArguments;
/** */ BaseClassList baseClassList; /** */ BaseClassList baseClassList;
/** */ ClassBody classBody; /** */ StructBody structBody;
} }
/// ///
@ -1771,16 +1763,7 @@ class StructBody : ASTNode
{ {
public: public:
mixin(DEFAULT_ACCEPT); mixin(DEFAULT_ACCEPT);
/** */ StructBodyItem[] structBodyItems; /** */ Declaration[] declarations;
}
class StructBodyItem : ASTNode
{
public:
mixin(DEFAULT_ACCEPT);
/** */ Declaration declaration;
/** */ Invariant invariant_;
/** */ Postblit postblit;
} }
/// ///
@ -2086,7 +2069,8 @@ public:
/** */ bool star; /** */ bool star;
/** */ bool array; /** */ bool array;
/** */ Type type; /** */ Type type;
/** */ AssignExpression assignExpression; /** */ AssignExpression low;
/** */ AssignExpression high;
/** */ Parameters parameters; /** */ Parameters parameters;
/** */ MemberFunctionAttribute[] memberFunctionAttributes; /** */ MemberFunctionAttribute[] memberFunctionAttributes;
} }

267
std/d/parser.d
View File

@ -2,6 +2,11 @@
/** /**
* <script type="text/javascript">inhibitQuickIndex = 1</script> * <script type="text/javascript">inhibitQuickIndex = 1</script>
* <style type="text/css">
* .grammar_ruledef { font-weight: bold; }
* .grammar_rule { font-weight: bold; }
* .grammar_literal { color: crimson; }
* </style>
* This module contains a _parser for D source code. * This module contains a _parser for D source code.
* *
* Grammar: * Grammar:
@ -54,10 +59,10 @@
* Authors: Brian Schott * Authors: Brian Schott
* Source: $(PHOBOSSRC std/d/_parser.d) * Source: $(PHOBOSSRC std/d/_parser.d)
* MACROS: * MACROS:
* GRAMMAR = $(D_CODE $0) * GRAMMAR = <pre class="grammar">$0</pre>
* RULEDEF = $(DDOC_ANCHOR $0) $(B $0) * RULEDEF = <a name="$0"><span class="grammar_ruledef">$0</span></a>
* RULE = $(LINK2 #$0, $(B $0)) * RULE = <a href="#$0"><span class="grammar_rule">$0</span></a>
* LITERAL = $(D_STRING $0) * LITERAL = <span class="grammar_literal">$0</span>
*/ */
module std.d.parser; module std.d.parser;
@ -67,12 +72,10 @@ import std.d.ast;
import std.conv; import std.conv;
import std.algorithm; import std.algorithm;
import std.array; import std.array;
version (unittest) import std.stdio;
version = development;
version = verbose;
version(development) import std.stdio;
import std.stdio; import std.stdio;
import std.string : format;
version = verbose;
/** /**
* Params: * Params:
@ -85,8 +88,8 @@ Module parseModule(const(Token)[] tokens, string fileName)
parser.fileName = fileName; parser.fileName = fileName;
parser.tokens = tokens; parser.tokens = tokens;
auto mod = parser.parseModule(); auto mod = parser.parseModule();
version (development) writeln("Parsing finished with ", parser.errorCount, writefln("Parsing finished with %d errors and %d warnings.",
" errors and ", parser.warningCount, " warnings."); parser.errorCount, parser.warningCount);
return mod; return mod;
} }
@ -442,11 +445,11 @@ alias core.sys.posix.stdio.fileno fileno;
* *
* $(GRAMMAR $(RULEDEF asmInstruction): * $(GRAMMAR $(RULEDEF asmInstruction):
* $(LITERAL Identifier) * $(LITERAL Identifier)
* | $(LITERAL 'align') I$(RULE ntegerLiteral) * | $(LITERAL 'align') $(RULE IntegerLiteral)
* | $(LITERAL 'align') $(LITERAL Identifier) * | $(LITERAL 'align') $(LITERAL Identifier)
* | $(LITERAL Identifier) $(LITERAL ':') $(RULE asmInstruction) * | $(LITERAL Identifier) $(LITERAL ':') $(RULE asmInstruction)
* | $(LITERAL Identifier) $(RULE asmExp) * | $(LITERAL Identifier) $(RULE asmExp)
* | $(RULE opcode) $(RULE operands) * | $(LITERAL Identifier) $(RULE operands)
* ;) * ;)
*/ */
AsmInstruction parseAsmInstruction() AsmInstruction parseAsmInstruction()
@ -843,7 +846,6 @@ alias core.sys.posix.stdio.fileno fileno;
mixin(traceEnterAndExit!(__FUNCTION__)); mixin(traceEnterAndExit!(__FUNCTION__));
auto node = new BlockStatement(); auto node = new BlockStatement();
if (expect(TokenType.lBrace) is null) return null; if (expect(TokenType.lBrace) is null) return null;
version (development) skipBraceContent();
if (!currentIs(TokenType.rBrace)) if (!currentIs(TokenType.rBrace))
node.declarationsAndStatements = parseDeclarationsAndStatements(); node.declarationsAndStatements = parseDeclarationsAndStatements();
if (expect(TokenType.rBrace) is null) return null; if (expect(TokenType.rBrace) is null) return null;
@ -1166,7 +1168,7 @@ incorrect;
* Parses a Catch * Parses a Catch
* *
* $(GRAMMAR $(RULEDEF catch): * $(GRAMMAR $(RULEDEF catch):
* $(LITERAL 'catch') $(LITERAL '$(LPAREN)') $(RULE type) $(LITERAL Identifier)? $(LITERAL '$(RPAREN)') $(RULE nonEmptyStatementNoCaseNoDefault) * $(LITERAL 'catch') $(LITERAL '$(LPAREN)') $(RULE type) $(LITERAL Identifier)? $(LITERAL '$(RPAREN)') $(RULE statementNoCaseNoDefault)
* ;) * ;)
*/ */
Catch parseCatch() Catch parseCatch()
@ -1197,14 +1199,11 @@ incorrect;
auto node = new Catches; auto node = new Catches;
while (true) while (true)
{ {
expect(TokenType.catch_); if (!currentIs(TokenType.catch_))
if (currentIs(TokenType.lParen)) break;
if (peekIs(TokenType.lParen))
{ {
node.catches ~= parseCatch(); node.catches ~= parseCatch();
if (currentIs(TokenType.catch_))
continue;
else
break;
} }
else else
{ {
@ -1215,33 +1214,11 @@ incorrect;
return node; return node;
} }
/**
* Parses a ClassBody
*
* $(GRAMMAR $(RULEDEF classBody):
* $(LITERAL '{') $(RULE declarationOrInvariant)* $(LITERAL '}')
* ;)
*/
ClassBody parseClassBody()
{
mixin(traceEnterAndExit!(__FUNCTION__));
auto node = new ClassBody;
if (expect(TokenType.lBrace) is null) return null;
while (moreTokens() && !currentIs(TokenType.rBrace))
{
auto doi = parseDeclarationOrInvariant();
if (doi !is null)
node.declarationOrInvariants ~= doi;
}
if (expect(TokenType.rBrace) is null) return null;
return node;
}
/** /**
* Parses a ClassDeclaration * Parses a ClassDeclaration
* *
* $(GRAMMAR $(RULEDEF classDeclaration): * $(GRAMMAR $(RULEDEF classDeclaration):
* $(LITERAL 'class') $(LITERAL Identifier) ($(RULE templateParameters) $(RULE constraint)?)? ($(LITERAL ':') $(RULE baseClassList))? $(RULE classBody) * $(LITERAL 'class') $(LITERAL Identifier) ($(RULE templateParameters) $(RULE constraint)?)? ($(LITERAL ':') $(RULE baseClassList))? $(RULE structBody)
* ;) * ;)
*/ */
ClassDeclaration parseClassDeclaration() ClassDeclaration parseClassDeclaration()
@ -1265,7 +1242,7 @@ incorrect;
advance(); advance();
node.baseClassList = parseBaseClassList(); node.baseClassList = parseBaseClassList();
} }
node.classBody = parseClassBody(); node.structBody = parseStructBody();
return node; return node;
} }
@ -1430,7 +1407,7 @@ class ClassFour(A, B) if (someTest()) : Super {}}c;
} }
/** /**
* Parses an ConditionalStatement * Parses a ConditionalStatement
* *
* $(GRAMMAR $(RULEDEF conditionalStatement): * $(GRAMMAR $(RULEDEF conditionalStatement):
* $(RULE compileCondition) $(RULE statementNoCaseNoDefault) ($(LITERAL 'else') $(RULE statementNoCaseNoDefault))? * $(RULE compileCondition) $(RULE statementNoCaseNoDefault) ($(LITERAL 'else') $(RULE statementNoCaseNoDefault))?
@ -1616,6 +1593,7 @@ class ClassFour(A, B) if (someTest()) : Super {}}c;
* | $(RULE unittest) * | $(RULE unittest)
* | $(RULE variableDeclaration) * | $(RULE variableDeclaration)
* | $(RULE attributeDeclaration) * | $(RULE attributeDeclaration)
* | $(RULE invariant)
* | $(LITERAL '{') $(RULE declaration)+ $(LITERAL '}') * | $(LITERAL '{') $(RULE declaration)+ $(LITERAL '}')
* ;) * ;)
*/ */
@ -1655,7 +1633,7 @@ class ClassFour(A, B) if (someTest()) : Super {}}c;
if (declaration !is null) if (declaration !is null)
node.declarations ~= declaration; node.declarations ~= declaration;
} }
expect(TokenType.rBrace); if (expect(TokenType.rBrace) is null) return null;
break; break;
case alias_: case alias_:
if (startsWith(alias_, identifier, this_)) if (startsWith(alias_, identifier, this_))
@ -1667,7 +1645,10 @@ class ClassFour(A, B) if (someTest()) : Super {}}c;
node.classDeclaration = parseClassDeclaration(); node.classDeclaration = parseClassDeclaration();
break; break;
case this_: case this_:
node.constructor = parseConstructor(); if (startsWith(this_, lParen, this_))
node.postblit = parsePostblit();
else
node.constructor = parseConstructor();
break; break;
case tilde: case tilde:
node.destructor = parseDestructor(); node.destructor = parseDestructor();
@ -1719,6 +1700,9 @@ class ClassFour(A, B) if (someTest()) : Super {}}c;
case union_: case union_:
node.unionDeclaration = parseUnionDeclaration(); node.unionDeclaration = parseUnionDeclaration();
break; break;
case invariant_:
node.invariant_ = parseInvariant();
break;
case unittest_: case unittest_:
node.unittest_ = parseUnittest(); node.unittest_ = parseUnittest();
break; break;
@ -1767,6 +1751,7 @@ class ClassFour(A, B) if (someTest()) : Super {}}c;
break; break;
case debug_: case debug_:
node.conditionalDeclaration = parseConditionalDeclaration(); node.conditionalDeclaration = parseConditionalDeclaration();
if (node.conditionalDeclaration is null) return null;
break; break;
default: default:
error("Declaration expected"); error("Declaration expected");
@ -1782,10 +1767,6 @@ class ClassFour(A, B) if (someTest()) : Super {}}c;
* $(GRAMMAR $(RULEDEF declarationsAndStatements): * $(GRAMMAR $(RULEDEF declarationsAndStatements):
* $(RULE declarationOrStatement)+ * $(RULE declarationOrStatement)+
* ; * ;
*$(RULEDEF declarationOrStatement):
* $(RULE declaration)
* | $(RULE statementNoCaseNoDefault)
* ;)
*/ */
DeclarationsAndStatements parseDeclarationsAndStatements() DeclarationsAndStatements parseDeclarationsAndStatements()
{ {
@ -1794,7 +1775,7 @@ class ClassFour(A, B) if (someTest()) : Super {}}c;
while (!currentIsOneOf(TokenType.rBrace) && moreTokens()) while (!currentIsOneOf(TokenType.rBrace) && moreTokens())
{ {
auto dos = parseDeclarationOrStatement(); auto dos = parseDeclarationOrStatement();
if (dos.statement !is null || dos.declaration !is null) if (dos !is null)
node.declarationsAndStatements ~= dos; node.declarationsAndStatements ~= dos;
else else
return null; return null;
@ -1802,25 +1783,6 @@ class ClassFour(A, B) if (someTest()) : Super {}}c;
return node; return node;
} }
/**
* Parses a DeclarationOrInvariant
*
* $(GRAMMAR $(RULEDEF declarationOrInvariant):
* $(RULE declaration)
* | $(RULE invariant)
* ;)
*/
DeclarationOrInvariant parseDeclarationOrInvariant()
{
mixin(traceEnterAndExit!(__FUNCTION__));
auto node = new DeclarationOrInvariant;
if (currentIs(TokenType.invariant_))
node.invariant_ = parseInvariant();
else
node.declaration = parseDeclaration();
return node;
}
/** /**
* Parses a DeclarationOrStatement * Parses a DeclarationOrStatement
* *
@ -1836,9 +1798,21 @@ class ClassFour(A, B) if (someTest()) : Super {}}c;
// "Any ambiguities in the grammar between Statements and // "Any ambiguities in the grammar between Statements and
// Declarations are resolved by the declarations taking precedence." // Declarations are resolved by the declarations taking precedence."
if (isDeclaration()) if (isDeclaration())
{
trace("+++ parsing declaration");
node.declaration = parseDeclaration(); node.declaration = parseDeclaration();
}
else else
{
trace("+++ parsing statement");
node.statement = parseStatementNoCaseNoDefault(); node.statement = parseStatementNoCaseNoDefault();
}
if (node.statement is null && node.declaration is null)
{
error("Could not parse declaration or statement");
return null;
}
return node; return node;
} }
@ -1960,7 +1934,7 @@ class ClassFour(A, B) if (someTest()) : Super {}}c;
* Parses a DoStatement * Parses a DoStatement
* *
* $(GRAMMAR $(RULEDEF doStatement): * $(GRAMMAR $(RULEDEF doStatement):
* $(LITERAL 'do') $(RULE nonEmptyStatementNoCaseNoDefault) $(LITERAL 'while') $(LITERAL '$(LPAREN)') $(RULE expression) $(LITERAL '$(RPAREN)') $(LITERAL ';') * $(LITERAL 'do') $(RULE statementNoCaseNoDefault) $(LITERAL 'while') $(LITERAL '$(LPAREN)') $(RULE expression) $(LITERAL '$(RPAREN)') $(LITERAL ';')
* ;) * ;)
*/ */
DoStatement parseDoStatement() DoStatement parseDoStatement()
@ -2184,14 +2158,14 @@ class ClassFour(A, B) if (someTest()) : Super {}}c;
* Parses a ForeachStatement * Parses a ForeachStatement
* *
* $(GRAMMAR $(RULEDEF foreachStatement): * $(GRAMMAR $(RULEDEF foreachStatement):
* ($(LITERAL 'foreach') | $(LITERAL 'foreach_reverse')) $(LITERAL '$(LPAREN)') $(RULE foreachTypeList) $(LITERAL ';') $(RULE expression) $(LITERAL '$(RPAREN)') $(RULE nonEmptyStatementNoCaseNoDefault) * ($(LITERAL 'foreach') | $(LITERAL 'foreach_reverse')) $(LITERAL '$(LPAREN)') $(RULE foreachTypeList) $(LITERAL ';') $(RULE expression) $(LITERAL '$(RPAREN)') $(RULE statementNoCaseNoDefault)
* | ($(LITERAL 'foreach') | $(LITERAL 'foreach_reverse')) $(LITERAL '$(LPAREN)') $(RULE foreachType) $(LITERAL ';') $(RULE expression) $(LITERAL '..') $(RULE expression) $(LITERAL '$(RPAREN)') $(RULE nonEmptyStatementNoCaseNoDefault) * | ($(LITERAL 'foreach') | $(LITERAL 'foreach_reverse')) $(LITERAL '$(LPAREN)') $(RULE foreachType) $(LITERAL ';') $(RULE expression) $(LITERAL '..') $(RULE expression) $(LITERAL '$(RPAREN)') $(RULE statementNoCaseNoDefault)
* ;) * ;)
*/ */
ForeachStatement parseForeachStatement() ForeachStatement parseForeachStatement()
{ {
mixin(traceEnterAndExit!(__FUNCTION__));
auto node = new ForeachStatement; auto node = new ForeachStatement;
if (currentIsOneOf(TokenType.foreach_, TokenType.foreach_reverse_)) if (currentIsOneOf(TokenType.foreach_, TokenType.foreach_reverse_))
node.foreachType = advance().type; node.foreachType = advance().type;
else else
@ -2202,7 +2176,7 @@ class ClassFour(A, B) if (someTest()) : Super {}}c;
if (expect(TokenType.lParen) is null) return null; if (expect(TokenType.lParen) is null) return null;
auto feType = parseForeachTypeList(); auto feType = parseForeachTypeList();
bool canBeRange = feType.items.length == 1; bool canBeRange = feType.items.length == 1;
expect(TokenType.semicolon); if (expect(TokenType.semicolon) is null) return null;
node.low = parseExpression(); node.low = parseExpression();
if (node.low is null) return null; if (node.low is null) return null;
if (currentIs(TokenType.slice)) if (currentIs(TokenType.slice))
@ -2231,10 +2205,12 @@ class ClassFour(A, B) if (someTest()) : Super {}}c;
*/ */
ForeachType parseForeachType() ForeachType parseForeachType()
{ {
mixin(traceEnterAndExit!(__FUNCTION__));
auto node = new ForeachType; auto node = new ForeachType;
if (currentIsOneOf(TokenType.ref_, TokenType.const_, TokenType.immutable_, if (currentIsOneOf(TokenType.ref_, TokenType.const_, TokenType.immutable_,
TokenType.shared_, TokenType.inout_)) TokenType.shared_, TokenType.inout_))
{ {
trace("+++ Type constructor");
if ((node.typeConstructors = parseTypeConstructors()) is null) if ((node.typeConstructors = parseTypeConstructors()) is null)
return null; return null;
} }
@ -2259,6 +2235,7 @@ class ClassFour(A, B) if (someTest()) : Super {}}c;
*/ */
ForeachTypeList parseForeachTypeList() ForeachTypeList parseForeachTypeList()
{ {
mixin(traceEnterAndExit!(__FUNCTION__));
return parseCommaSeparatedRule!(ForeachTypeList, ForeachType)(); return parseCommaSeparatedRule!(ForeachTypeList, ForeachType)();
} }
@ -3177,7 +3154,7 @@ invariant() foo();
* Parses a LastCatch * Parses a LastCatch
* *
* $(GRAMMAR $(RULEDEF lastCatch): * $(GRAMMAR $(RULEDEF lastCatch):
* $(LITERAL 'catch') $(RULE nonEmptyStatementNoCaseNoDefault) * $(LITERAL 'catch') $(RULE statementNoCaseNoDefault)
* ;) * ;)
*/ */
LastCatch parseLastCatch() LastCatch parseLastCatch()
@ -3254,7 +3231,7 @@ invariant() foo();
* *
* $(GRAMMAR $(RULEDEF mixinDeclaration): * $(GRAMMAR $(RULEDEF mixinDeclaration):
* $(RULE mixinExpression) $(LITERAL ';') * $(RULE mixinExpression) $(LITERAL ';')
* | $(RULE templateMixinStatement) $(LITERAL ';') * | $(RULE templateMixinExpression) $(LITERAL ';')
* ;) * ;)
*/ */
MixinDeclaration parseMixinDeclaration() MixinDeclaration parseMixinDeclaration()
@ -3291,7 +3268,7 @@ invariant() foo();
* Parses a MixinTemplateDeclaration * Parses a MixinTemplateDeclaration
* *
* $(GRAMMAR $(RULEDEF mixinTemplateDeclaration): * $(GRAMMAR $(RULEDEF mixinTemplateDeclaration):
* $(LITERAL 'mixin') $RULE templateDeclaration * $(LITERAL 'mixin') $(RULE templateDeclaration)
* ;) * ;)
*/ */
MixinTemplateDeclaration parseMixinTemplateDeclaration() MixinTemplateDeclaration parseMixinTemplateDeclaration()
@ -3379,7 +3356,7 @@ invariant() foo();
* Parses a NewAnonClassExpression * Parses a NewAnonClassExpression
* *
* $(GRAMMAR $(RULEDEF newAnonClassExpression): * $(GRAMMAR $(RULEDEF newAnonClassExpression):
* $(LITERAL 'new') $(RULE arguments)? $(LITERAL 'class') $(RULE arguments)? $(RULE baseClassList)? $(RULE classBody) * $(LITERAL 'new') $(RULE arguments)? $(LITERAL 'class') $(RULE arguments)? $(RULE baseClassList)? $(RULE structBody)
* ;) * ;)
*/ */
NewAnonClassExpression parseNewAnonClassExpression() NewAnonClassExpression parseNewAnonClassExpression()
@ -3391,7 +3368,7 @@ invariant() foo();
expect(TokenType.class_); expect(TokenType.class_);
if (!currentIs(TokenType.lBrace)) if (!currentIs(TokenType.lBrace))
node.baseClassList = parseBaseClassList(); node.baseClassList = parseBaseClassList();
node.classBody = parseClassBody(); node.structBody = parseStructBody();
return node; return node;
} }
@ -3447,7 +3424,6 @@ invariant() foo();
* | $(RULE throwStatement) * | $(RULE throwStatement)
* | $(RULE scopeGuardStatement) * | $(RULE scopeGuardStatement)
* | $(RULE asmStatement) * | $(RULE asmStatement)
* | $(RULE foreachRangeStatement)
* | $(RULE conditionalStatement) * | $(RULE conditionalStatement)
* | $(RULE staticAssertStatement) * | $(RULE staticAssertStatement)
* | $(RULE versionSpecification) * | $(RULE versionSpecification)
@ -3642,7 +3618,7 @@ invariant() foo();
* Parses a Parameter * Parses a Parameter
* *
* $(GRAMMAR $(RULEDEF parameter): * $(GRAMMAR $(RULEDEF parameter):
* $(RULE parameterAttribute)* $(RULE type) ($(LITERAL Identifier)? $(LITERAL '...') | ($(LITERAL Identifier) ($(LITERAL '=') $(RULE assignExpression))?))? * $(RULE parameterAttribute)* $(RULE type) ($(LITERAL Identifier)? $(LITERAL '...') | ($(LITERAL Identifier)? ($(LITERAL '=') $(RULE assignExpression))?))?
* ;) * ;)
*/ */
Parameter parseParameter() Parameter parseParameter()
@ -3678,6 +3654,11 @@ invariant() foo();
node.vararg = true; node.vararg = true;
advance(); advance();
} }
else if (currentIs(TokenType.assign))
{
advance();
node.default_ = parseAssignExpression();
}
return node; return node;
} }
@ -3697,6 +3678,7 @@ invariant() foo();
*/ */
TokenType parseParameterAttribute(bool validate = false) TokenType parseParameterAttribute(bool validate = false)
{ {
mixin(traceEnterAndExit!(__FUNCTION__));
with (TokenType) switch (current.type) with (TokenType) switch (current.type)
{ {
case immutable_: case immutable_:
@ -3797,7 +3779,7 @@ q{(int a, ...)
/** /**
* Parses a Postblit * Parses a Postblit
* *
* $(GRAMMAR $(RULEDEF parameters): * $(GRAMMAR $(RULEDEF postblit):
* $(LITERAL 'this') $(LITERAL '$(LPAREN)') $(LITERAL 'this') $(LITERAL '$(RPAREN)') ($(RULE functionBody) | $(LITERAL ';')) * $(LITERAL 'this') $(LITERAL '$(LPAREN)') $(LITERAL 'this') $(LITERAL '$(RPAREN)') ($(RULE functionBody) | $(LITERAL ';'))
* ;) * ;)
*/ */
@ -3911,7 +3893,7 @@ q{(int a, ...)
* $(GRAMMAR $(RULEDEF primaryExpression): * $(GRAMMAR $(RULEDEF primaryExpression):
* $(RULE identifierOrTemplateInstance) * $(RULE identifierOrTemplateInstance)
* | $(LITERAL '.') $(RULE identifierOrTemplateInstance) * | $(LITERAL '.') $(RULE identifierOrTemplateInstance)
* | $(RULE basicType) $(LITERAL '.') $(LITERAL Identifier) * | $(RULE builtinType) $(LITERAL '.') $(LITERAL Identifier)
* | $(RULE typeofExpression) * | $(RULE typeofExpression)
* | $(RULE typeidExpression) * | $(RULE typeidExpression)
* | $(RULE vector) * | $(RULE vector)
@ -3996,6 +3978,8 @@ q{(int a, ...)
auto p = peekPastParens(); auto p = peekPastParens();
if (p !is null && p.type == TokenType.goesTo) if (p !is null && p.type == TokenType.goesTo)
node.lambdaExpression = parseLambdaExpression(); node.lambdaExpression = parseLambdaExpression();
else if (p !is null && p.type == TokenType.lBrace)
node.functionLiteralExpression = parseFunctionLiteralExpression();
else else
{ {
advance(); advance();
@ -4320,7 +4304,7 @@ q{(int a, ...)
/** /**
* Parses a StaticDestructor * Parses a StaticDestructor
* *
* $(GRAMMAR $(RULEDEF staticConstructor): * $(GRAMMAR $(RULEDEF staticDestructor):
* $(LITERAL 'static') $(LITERAL '~') $(LITERAL 'this') $(LITERAL '$(LPAREN)') $(LITERAL '$(RPAREN)') $(RULE functionBody) * $(LITERAL 'static') $(LITERAL '~') $(LITERAL 'this') $(LITERAL '$(LPAREN)') $(LITERAL '$(RPAREN)') $(RULE functionBody)
* ;) * ;)
*/ */
@ -4420,7 +4404,7 @@ q{(int a, ...)
* Parses a StructBody * Parses a StructBody
* *
* $(GRAMMAR $(RULEDEF structBody): * $(GRAMMAR $(RULEDEF structBody):
* $(LITERAL '{') $(RULE structBodyItem)* $(LITERAL '}') * $(LITERAL '{') $(RULE declaration)* $(LITERAL '}')
* ;) * ;)
*/ */
StructBody parseStructBody() StructBody parseStructBody()
@ -4429,33 +4413,11 @@ q{(int a, ...)
auto node = new StructBody; auto node = new StructBody;
expect(TokenType.lBrace); expect(TokenType.lBrace);
while (!currentIs(TokenType.rBrace) && moreTokens()) while (!currentIs(TokenType.rBrace) && moreTokens())
node.structBodyItems ~= parseStructBodyItem(); node.declarations ~= parseDeclaration();
expect(TokenType.rBrace); expect(TokenType.rBrace);
return node; return node;
} }
/**
* Parses a StructBodyItem
*
* $(GRAMMAR $(RULEDEF structBodyItem):
* $(RULE declaration)
* | $(RULE postBlit)
* | $(RULE invariant)
* ;)
*/
StructBodyItem parseStructBodyItem()
{
mixin(traceEnterAndExit!(__FUNCTION__));
auto node = new StructBodyItem;
if (currentIs(TokenType.invariant_))
node.invariant_ = parseInvariant();
else if (startsWith(TokenType.this_, TokenType.lParen, TokenType.this_))
node.postblit = parsePostblit();
else
node.declaration = parseDeclaration();
return node;
}
/** /**
* Parses a StructDeclaration * Parses a StructDeclaration
* *
@ -4620,7 +4582,7 @@ q{(int a, ...)
* Parses a SynchronizedStatement * Parses a SynchronizedStatement
* *
* $(GRAMMAR $(RULEDEF synchronizedStatement): * $(GRAMMAR $(RULEDEF synchronizedStatement):
* $(LITERAL 'synchronized') ($(LITERAL '$(LPAREN)') $(RULE expression) $(LITERAL '$(RPAREN)'))? $(RULE nonEmptyStatementNoCaseNoDefault) * $(LITERAL 'synchronized') ($(LITERAL '$(LPAREN)') $(RULE expression) $(LITERAL '$(RPAREN)'))? $(RULE statementNoCaseNoDefault)
* ;) * ;)
*/ */
SynchronizedStatement parseSynchronizedStatement() SynchronizedStatement parseSynchronizedStatement()
@ -4695,7 +4657,7 @@ q{(int a, ...)
mixin(traceEnterAndExit!(__FUNCTION__)); mixin(traceEnterAndExit!(__FUNCTION__));
auto node = new TemplateArgument; auto node = new TemplateArgument;
if (isBasicType(current.type) || !isExpression()) if (isBasicType(current.type) || isAttribute() || !isExpression())
{ {
if ((node.type = parseType()) is null) return null; if ((node.type = parseType()) is null) return null;
} }
@ -4734,7 +4696,8 @@ q{(int a, ...)
if (currentIs(TokenType.lParen)) if (currentIs(TokenType.lParen))
{ {
advance(); advance();
node.templateArgumentList = parseTemplateArgumentList(); if (!currentIs(TokenType.rParen))
node.templateArgumentList = parseTemplateArgumentList();
expect(TokenType.rParen); expect(TokenType.rParen);
} }
else else
@ -4746,7 +4709,7 @@ q{(int a, ...)
* Parses a TemplateDeclaration * Parses a TemplateDeclaration
* *
* $(GRAMMAR $(RULEDEF templateDeclaration): * $(GRAMMAR $(RULEDEF templateDeclaration):
* $(LITERAL 'template') $(LITERAL Identifier) $(RULE templateParameters) $(RULE constraint)? $(LITERAL '{') $(RULE declaration)+ $(LITERAL '}') * $(LITERAL 'template') $(LITERAL Identifier) $(RULE templateParameters) $(RULE constraint)? $(LITERAL '{') $(RULE declaration)* $(LITERAL '}')
* ;) * ;)
*/ */
TemplateDeclaration parseTemplateDeclaration() TemplateDeclaration parseTemplateDeclaration()
@ -4760,11 +4723,14 @@ q{(int a, ...)
node.templateParameters = parseTemplateParameters(); node.templateParameters = parseTemplateParameters();
if (currentIs(TokenType.if_)) if (currentIs(TokenType.if_))
node.constraint = parseConstraint(); node.constraint = parseConstraint();
expect(TokenType.lBrace); if (expect(TokenType.lBrace) is null) return null;
do while (moreTokens() && !currentIs(TokenType.rBrace))
node.declarations ~= parseDeclaration(); {
while (!currentIs(TokenType.rBrace) && moreTokens()); auto decl = parseDeclaration();
expect(TokenType.rBrace); if (decl !is null)
node.declarations ~= decl;
}
expect(TokenType.rBrace);
return node; return node;
} }
@ -4980,7 +4946,7 @@ q{(int a, ...)
advance(); advance();
node.colonType = parseType(); node.colonType = parseType();
} }
else if (currentIs(TokenType.assign)) if (currentIs(TokenType.assign))
{ {
advance(); advance();
node.assignType = parseType(); node.assignType = parseType();
@ -5112,7 +5078,7 @@ q{(int a, ...)
* Parses a TryStatement * Parses a TryStatement
* *
* $(GRAMMAR $(RULEDEF tryStatement): * $(GRAMMAR $(RULEDEF tryStatement):
* $(LITERAL 'try') $(RULE nonEmptyStatementNoCaseNoDefault) ($(RULE catches) | $(RULE catches) $(RULE finally) | $(RULE finally)) * $(LITERAL 'try') $(RULE statementNoCaseNoDefault) ($(RULE catches) | $(RULE catches) $(RULE finally) | $(RULE finally))
* ;) * ;)
*/ */
TryStatement parseTryStatement() TryStatement parseTryStatement()
@ -5245,6 +5211,7 @@ q{(int a, ...)
case inout_: case inout_:
case shared_: case shared_:
case scope_: case scope_:
case ref_:
return advance().type; return advance().type;
default: default:
if (validate) if (validate)
@ -5335,7 +5302,9 @@ q{(int a, ...)
* *
* $(GRAMMAR $(RULEDEF typeSuffix): * $(GRAMMAR $(RULEDEF typeSuffix):
* $(LITERAL '*') * $(LITERAL '*')
* | $(LITERAL '[') ($(RULE type) | $(RULE assignExpression))? $(LITERAL ']') * | $(LITERAL '[') $(RULE type)? $(LITERAL ']')
* | $(LITERAL '[') $(RULE assignExpression) $(LITERAL ']')
* | $(LITERAL '[') $(RULE assignExpression) $(LITERAL '..') $(RULE assignExpression) $(LITERAL ']')
* | ($(LITERAL 'delegate') | $(LITERAL 'function')) $(RULE parameters) $(RULE memberFunctionAttribute)* * | ($(LITERAL 'delegate') | $(LITERAL 'function')) $(RULE parameters) $(RULE memberFunctionAttribute)*
* ;) * ;)
*/ */
@ -5359,11 +5328,20 @@ q{(int a, ...)
if (type is null) if (type is null)
{ {
goToBookmark(bookmark); goToBookmark(bookmark);
node.assignExpression = parseAssignExpression(); node.low = parseAssignExpression();
if (node.assignExpression is null) return null; if (node.low is null) return null;
if (currentIs(slice))
{
advance();
node.high = parseAssignExpression();
if (node.high is null) return null;
}
} }
else else
{
goToBookmark(bookmark);
node.type = type; node.type = type;
}
end: end:
if (expect(TokenType.rBracket) is null) return null; if (expect(TokenType.rBracket) is null) return null;
return node; return node;
@ -5724,7 +5702,7 @@ q{doStuff(5)}c;
* Parses a WithStatement * Parses a WithStatement
* *
* $(GRAMMAR $(RULEDEF withStatement): * $(GRAMMAR $(RULEDEF withStatement):
* $(LITERAL 'with') $(LITERAL '$(LPAREN)') $(RULE expression) $(LITERAL '$(RPAREN)') $(RULE nonEmptyStatementNoCaseNoDefault) * $(LITERAL 'with') $(LITERAL '$(LPAREN)') $(RULE expression) $(LITERAL '$(RPAREN)') $(RULE statementNoCaseNoDefault)
* ;) * ;)
*/ */
WithStatement parseWithStatement() WithStatement parseWithStatement()
@ -5790,8 +5768,20 @@ private:
bool isDeclaration() bool isDeclaration()
{ {
mixin(traceEnterAndExit!(__FUNCTION__));
with (TokenType) switch (current.type) with (TokenType) switch (current.type)
{ {
case debug_:
case version_:
return peekIs(TokenType.assign);
case static_:
if (startsWith(static_, if_))
return false;
break;
case scope_:
if (peekIs(TokenType.lParen))
return false;
goto case;
mixin(BASIC_TYPE_CASE_RANGE); mixin(BASIC_TYPE_CASE_RANGE);
case const_: case const_:
case immutable_: case immutable_:
@ -5837,16 +5827,17 @@ private:
case goto_: case goto_:
case try_: case try_:
case throw_: case throw_:
case scope_:
case asm_: case asm_:
case foreach_reverse_: case foreach_reverse_:
case lBrace:
return false; return false;
default: default:
trace("+++ no clue");
break; break;
} }
// h4x
auto b = setBookmark(); auto b = setBookmark();
scope(exit) goToBookmark(b); scope(exit) goToBookmark(b);
return parseDeclaration() !is null; return parseDeclaration() !is null;
} }
@ -5879,6 +5870,7 @@ private:
case const_: case const_:
case immutable_: case immutable_:
case inout_: case inout_:
case scope_:
return !peekIs(TokenType.lParen); return !peekIs(TokenType.lParen);
case static_: case static_:
return !peekIsOneOf(assert_, this_, if_, tilde); return !peekIsOneOf(assert_, this_, if_, tilde);
@ -5910,7 +5902,6 @@ private:
case override_: case override_:
case abstract_: case abstract_:
case auto_: case auto_:
case scope_:
case gshared: case gshared:
case pure_: case pure_:
case nothrow_: case nothrow_:
@ -6002,6 +5993,7 @@ private:
{ {
++errorCount; ++errorCount;
auto column = index < tokens.length ? tokens[index].column : 0; auto column = index < tokens.length ? tokens[index].column : 0;
column++;
auto line = index < tokens.length ? tokens[index].line : 0; auto line = index < tokens.length ? tokens[index].line : 0;
if (messageFunction is null) if (messageFunction is null)
writefln("!! %s(%d:%d): %s", fileName, line, column, message); writefln("!! %s(%d:%d): %s", fileName, line, column, message);
@ -6010,7 +6002,8 @@ private:
} }
while (moreTokens()) while (moreTokens())
{ {
if (currentIsOneOf(TokenType.semicolon, TokenType.rBrace)) if (currentIsOneOf(TokenType.semicolon, TokenType.rBrace,
TokenType.rParen, TokenType.rBracket))
{ {
advance(); advance();
break; break;
@ -6167,11 +6160,15 @@ private:
*/ */
bool currentIsOneOf(TokenType[] types...) const bool currentIsOneOf(TokenType[] types...) const
{ {
if (index >= tokens.length)
return false;
return canFind(types, current.type); return canFind(types, current.type);
} }
bool startsWith(TokenType[] types...) const bool startsWith(TokenType[] types...) const
{ {
if (index >= tokens.length)
return false;
for (size_t i = 0; i != types.length; ++i) for (size_t i = 0; i != types.length; ++i)
{ {
if (tokens[index + i].type != types[i]) if (tokens[index + i].type != types[i])
@ -6185,13 +6182,15 @@ private:
*/ */
bool moreTokens() const bool moreTokens() const
{ {
return index + 1 < tokens.length; return index < tokens.length;
} }
size_t setBookmark() size_t setBookmark()
{ {
++suppressMessages; mixin(traceEnterAndExit!(__FUNCTION__));
return index; suppressMessages++;
auto i = index;
return i;
} }
void goToBookmark(size_t i) void goToBookmark(size_t i)
@ -6228,7 +6227,7 @@ private:
if (suppressMessages > 0) if (suppressMessages > 0)
return; return;
if (index < tokens.length) if (index < tokens.length)
writeln(message, "(", current.line, ":", current.column, ")"); writeln(message, "(", current.line, ":", current.column + 1, ")");
else else
writeln(message, "(EOF:0)"); writeln(message, "(EOF:0)");
} }