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