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

Lots of DDoc changes, some parser work

This commit is contained in:
Hackerpilot 2013-06-01 17:51:45 +00:00
parent 4ad043085a
commit 0e58854fa9
3 changed files with 3869 additions and 3439 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1672
std/d/ast.d
View File

File diff suppressed because it is too large Load Diff

38
std/d/lexer.d
View File

@ -13,7 +13,7 @@
* LexerConfig config;
* config.iterStyle = IterationStyle.everything;
* config.tokenStyle = TokenStyle.source;
* config.versionNumber = 2061;
* config.versionNumber = 2064;
* config.vendorString = "Lexer Example";
* ---
* Once you have configured the _lexer, call byToken$(LPAREN)$(RPAREN) on your
@ -200,7 +200,7 @@ enum IterationStyle
includeWhitespace = 0b0010,
/// Include $(LINK2 http://dlang.org/lex.html#specialtokens, special tokens)
includeSpecialTokens = 0b0100,
/// Do not stop iteration on reaching the ___EOF__ token
/// Do not stop iteration on reaching the $(D_KEYWORD ___EOF__) token
ignoreEOF = 0b1000,
/// Include _everything
everything = includeComments | includeWhitespace | ignoreEOF
@ -215,8 +215,8 @@ enum TokenStyle : uint
/**
* Escape sequences will be replaced with their equivalent characters,
* enclosing quote characters will not be included. Special tokens such as
* __VENDOR__ will be replaced with their equivalent strings. Useful for
* creating a compiler or interpreter.
* $(D_KEYWORD ___VENDOR__) will be replaced with their equivalent strings.
* Useful for creating a compiler or interpreter.
*/
default_ = 0b0000,
@ -236,8 +236,8 @@ enum TokenStyle : uint
includeQuotes = 0b0010,
/**
* Do not replace the value field of the special tokens such as ___DATE__
* with their string equivalents.
* Do not replace the value field of the special tokens such as
* $(D_KEYWORD ___DATE__) with their string equivalents.
*/
doNotReplaceSpecial = 0b0100,
@ -265,12 +265,12 @@ struct LexerConfig
TokenStyle tokenStyle = tokenStyle.default_;
/**
* Replacement for the ___VERSION__ token. Defaults to 100.
* Replacement for the $(D_KEYWORD ___VERSION__) token. Defaults to 100.
*/
uint versionNumber = 100;
/**
* Replacement for the ___VENDOR__ token. Defaults to $(D_STRING "std.d.lexer")
* Replacement for the $(D_KEYWORD ___VENDOR__) token. Defaults to $(D_STRING "std.d.lexer")
*/
string vendorString = "std.d.lexer";
@ -597,7 +597,7 @@ L_advance:
return;
}
if (config.iterStyle & TokenStyle.doNotReplaceSpecial)
if (config.tokenStyle & TokenStyle.doNotReplaceSpecial)
return;
expandSpecialToken();
}
@ -2682,7 +2682,8 @@ immutable(string[TokenType.max + 1]) tokenValues = [
"__LINE__",
"__MODULE__",
"__FUNCTION__",
"__PRETTY_FUNCTION",
"__PRETTY_FUNCTION__",
null,
null,
null,
null,
@ -2704,7 +2705,6 @@ immutable(string[TokenType.max + 1]) tokenValues = [
null,
null,
null,
null,
];
pure string getTokenValue(const TokenType type)
@ -2867,6 +2867,7 @@ pure TokenType lookupTokenType(R)(R input)
case '_': if (input[1..$].equal("_DATE__")) return TokenType.specialDate;
else if (input[1..$].equal("_FILE__")) return TokenType.specialFile;
else if (input[1..$].equal("_LINE__")) return TokenType.specialLine;
else if (input[1..$].equal("_vector")) return TokenType.vector;
else if (input[1..$].equal("_TIME__")) return TokenType.specialTime;
else if (input[1..$].equal("_traits")) return TokenType.traits; else break;
case 'a': if (input[1..$].equal("bstract")) return TokenType.abstract_; else break;
@ -2909,7 +2910,8 @@ pure TokenType lookupTokenType(R)(R input)
switch (input[0])
{
case 's': if (input[1..$].equal("ynchronized")) return TokenType.synchronized_; else break;
case '_': if (input[1..$].equal("_FUNCTION__")) return TokenType.specialFunction; else break;
case '_': if (input[1..$].equal("_FUNCTION__")) return TokenType.specialFunction;
else if (input[1..$].equal("_parameters")) return TokenType.parameters; else break;
default: break;
}
break;
@ -3306,7 +3308,8 @@ unittest
~ " interface invariant is lazy macro mixin module new nothrow null"
~ " out override pure ref return struct super switch template this"
~ " throw true try typedef typeid typeof union unittest version volatile"
~ " while with __traits __parameters __vector");
~ " while with __traits __parameters __vector __VENDOR__ __MODULE__"
~ " __VERSION__ __TIMESTAMP__ __PRETTY_FUNCTION__");
auto expected = ["bool", "byte", "cdouble",
"cent", "cfloat", "char", "creal",
"dchar", "double", "float", "function",
@ -3329,10 +3332,13 @@ unittest
"super", "switch", "template", "this", "throw",
"true", "try", "typedef", "typeid", "typeof",
"union", "unittest", "version", "volatile",
"while", "with", "__traits", "__parameters", "__vector"];
"while", "with", "__traits", "__parameters", "__vector",
"__VENDOR__", "__MODULE__", "__VERSION__", "__TIMESTAMP__",
"__PRETTY_FUNCTION__"];
LexerConfig config;
config.tokenStyle = TokenStyle.doNotReplaceSpecial;
auto tokens = byToken(source, config);
//writeln(tokens.map!"a.value"().array());
// writeln(tokens.map!"a.value"().array());
assert (equal(map!"a.value"(tokens), expected));
}
@ -3387,7 +3393,7 @@ unittest
assert (tokens.front.line == 1);
assert (tokens.moveFront() == TokenType.int_);
assert (tokens.front.line == 4);
assert (isType(tokens.front));
assert (isBasicType(tokens.front));
assert (tokens.front.value == "double");
tokens.popFront();
assert (tokens.front.value == "abcde (a + b) == 0", tokens.front.value);

466
std/d/parser.d
View File

@ -13,7 +13,10 @@
* Authors: Brian Schott
* Source: $(PHOBOSSRC std/d/_parser.d)
* MACROS:
* GRAMMAR = <pre>$0</pre>
* GRAMMAR = <pre style="font-weight: bold">$0</pre>
* RULEDEF = <a name="$0"><span>$0</span></a>
* RULE = <a href="#$0"><span style="font-weight: bold">$0</span></a>
* LITERAL = <span style="font-style:italic; color: green; font-weight: normal;">$0</span>
*/
module std.d.parser;
@ -22,6 +25,7 @@ import std.d.lexer;
import std.d.ast;
import std.conv;
import std.algorithm;
import std.array;
version(unittest) import std.stdio;
/**
@ -43,8 +47,10 @@ struct Parser
{
/**
* Parses an AddExpression.
* $(GRAMMAR addExpression: mulExpression
* | addExpression ('+' | '-' | '~') mulExpression
*
* $(GRAMMAR $(RULEDEF addExpression):
* $(RULE mulExpression)
* | $(RULE addExpression) $(LPAREN)$(LITERAL '+') | $(LITERAL'-') | $(LITERAL'~')$(RPAREN) $(RULE mulExpression)
* ;)
*/
AddExpression parseAddExpression()
@ -63,8 +69,10 @@ struct Parser
}
/**
* Parses an AliasDeclaration
* $(GRAMMAR aliasDeclaration: 'alias' (aliasInitializer (',' aliasInitializer)* | type declarator) ';'
* Parses an AliasDeclaration.
*
* $(GRAMMAR $(RULEDEF aliasDeclaration):
* $(LITERAL 'alias') $(LPAREN)$(RULE aliasInitializer) $(LPAREN)$(LITERAL ',') $(RULE aliasInitializer)$(RPAREN)* | $(RULE type) $(RULE declarator)$(RPAREN) $(LITERAL ';')
* ;)
*/
AliasDeclaration parseAliasDeclaration()
@ -80,7 +88,8 @@ struct Parser
/**
* Parses an AliasInitializer
* $(GRAMMAR aliasInitializer: Identifier '=' type
* $(GRAMMAR $(RULEDEF aliasInitializer):
* $(LITERAL Identifier) $(LITERAL '=') $(RULE type)
* ;)
*/
AliasInitializer parseAliasInitializer()
@ -94,7 +103,7 @@ struct Parser
/**
* Parses an AliasThisDeclaration
* $(GRAMMAR aliasThisDeclaration: 'alias' Identifier 'this' ';'
* $(GRAMMAR $(RULEDEF aliasThisDeclaration): $(LITERAL 'alias') $(LITERAL Identifier) $(LITERAL 'this') $(LITERAL ';')
* ;)
*/
AliasThisDeclaration parseAliasThisDeclaration()
@ -109,7 +118,7 @@ struct Parser
/**
* Parses an AlignAttribute.
* $(GRAMMAR alignAttribute: 'align' ('(' IntegerLiteral ')')?
* $(GRAMMAR $(RULEDEF alignAttribute): $(LITERAL 'align') ($(LITERAL '$(LPAREN)') $(LITERAL IntegerLiteral) $(LITERAL '$(RPAREN)'))?
* ;)
*/
AlignAttribute parseAlignAttribute()
@ -127,8 +136,9 @@ struct Parser
/**
* Parses an AndAndExpression
* $(GRAMMAR andAndExpression: orExpression
* | andAndExpression '&&' orExpression
* $(GRAMMAR $(RULEDEF andAndExpression):
* $(RULE orExpression)
* | $(RULE andAndExpression) $(LITERAL '&&') $(RULE orExpression)
* ;)
*/
AndAndExpression parseAndAndExpression()
@ -171,9 +181,11 @@ struct Parser
}
/**
* Parses an Arguments
* Parses Arguments
*
* $(GRAMMAR )
* $(GRAMMAR $(RULEDEF arguments):
* $(LITERAL '$(LPAREN)') $(RULE argumentList)? $(LITERAL '$(RPAREN)')
* ;)
*/
Arguments parseArguments()
{
@ -199,7 +211,8 @@ struct Parser
/**
* Parses an ArrayLiteral
*
* $(GRAMMAR arrayLiteral: '[' argumentList ']'
* $(GRAMMAR $(RULEDEF arrayLiteral):
* $(LITERAL '[') $(RULE argumentList) $(LITERAL ']')
* ;)
*/
ArrayLiteral parseArrayLiteral()
@ -490,7 +503,8 @@ struct Parser
/**
* Parses an AssocArrayLiteral
*
* $(GRAMMAR assocArrayLiteral: '[' keyValuePairs ']'
* $(GRAMMAR $(RULEDEF assocArrayLiteral):
* $(LITERAL '[') $(RULE keyValuePairs) $(LITERAL ']')
* ;)
*/
AssocArrayLiteral parseAssocArrayLiteral()
@ -529,12 +543,27 @@ struct Parser
/**
* Parses an AttributedDeclaration
*
* $(GRAMMAR )
* $(GRAMMAR $(RULEDEF attributedDeclaration):
* $(RULE attribute) ($(LITERAL ':') | $(RULE declaration) | $(LITERAL '{') $(RULE declaration)* $(LITERAL '}'))
* ;)
*/
AttributedDeclaration parseAttributedDeclaration()
{
auto node = new AttributedDeclaration;
node.attribute = parseAttribute();
switch (current().type)
{
case TokenType.colon:
break;
case TokenType.lBrace:
while (moreTokens() && !currentIs(TokenType.rBrace))
node.declarations ~= parseDeclaration();
expect(TokenType.rBrace);
break;
default:
node.declarations ~= parseDeclaration();
break;
}
return node;
}
@ -553,7 +582,8 @@ struct Parser
/**
* Parses a BlockStatement
*
* $(GRAMMAR blockStatement: '{' declarationsAndStatements? '}'
* $(GRAMMAR $(RULEDEF blockStatement):
* $(LITERAL '{') $(RULE declarationsAndStatements)? $(LITERAL '}')
* ;)
*/
BlockStatement parseBlockStatement()
@ -569,7 +599,8 @@ struct Parser
/**
* Parses a BodyStatement
*
* $(GRAMMAR bodyStatement: 'body' blockStatement
* $(GRAMMAR $(RULEDEF bodyStatement):
* $(LITERAL 'body') $(RULE blockStatement)
* ;)
*/
BodyStatement parseBodyStatement()
@ -583,7 +614,8 @@ struct Parser
/**
* Parses a BreakStatement
*
* $(GRAMMAR breakStatement: 'break' Identifier? ';'
* $(GRAMMAR $(RULEDEF breakStatement):
* $(LITERAL 'break') $(LITERAL Identifier)? $(LITERAL ';')
* ;)
*/
BreakStatement parseBreakStatement()
@ -609,28 +641,29 @@ struct Parser
/**
* Parses an BuiltinType
*
* $(GRAMMAR builtinType: 'bool'
* | 'byte'
* | 'ubyte'
* | 'short'
* | 'ushort'
* | 'int'
* | 'uint'
* | 'long'
* | 'ulong'
* | 'char'
* | 'wchar'
* | 'dchar'
* | 'float'
* | 'double'
* | 'real'
* | 'ifloat'
* | 'idouble'
* | 'ireal'
* | 'cfloat'
* | 'cdouble'
* | 'creal'
* | 'void'
* $(GRAMMAR $(RULEDEF builtinType):
* $(LITERAL 'bool')
* | $(LITERAL 'byte')
* | $(LITERAL 'ubyte')
* | $(LITERAL 'short')
* | $(LITERAL 'ushort')
* | $(LITERAL 'int')
* | $(LITERAL 'uint')
* | $(LITERAL 'long')
* | $(LITERAL 'ulong')
* | $(LITERAL 'char')
* | $(LITERAL 'wchar')
* | $(LITERAL 'dchar')
* | $(LITERAL 'float')
* | $(LITERAL 'double')
* | $(LITERAL 'real')
* | $(LITERAL 'ifloat')
* | $(LITERAL 'idouble')
* | $(LITERAL 'ireal')
* | $(LITERAL 'cfloat')
* | $(LITERAL 'cdouble')
* | $(LITERAL 'creal')
* | $(LITERAL 'void')
* ;)
*/
BasicType parseBasicType()
@ -649,7 +682,8 @@ struct Parser
/**
* Parses a CaseRangeStatement
*
* $(GRAMMAR caseRangeStatement: 'case' assignExpression ':' '...' 'case' assignExpression ':' declarationsAndStatements
* $(GRAMMAR $(RULEDEF caseRangeStatement):
* $(LITERAL 'case') $(RULE assignExpression) $(LITERAL ':') $(LITERAL '...') $(LITERAL 'case') $(RULE assignExpression) $(LITERAL ':') $(RULE declarationsAndStatements)
* ;)
*/
CaseRangeStatement parseCaseRangeStatement()
@ -669,7 +703,8 @@ struct Parser
/**
* Parses an CaseStatement
*
* $(GRAMMAR caseStatement: 'case' argumentList ':' declarationsAndStatements
* $(GRAMMAR $(RULEDEF caseStatement):
* $(LITERAL 'case') $(RULE argumentList) $(LITERAL ':') $(RULE declarationsAndStatements)
* ;)
*/
CaseStatement parseCaseStatement()
@ -683,28 +718,55 @@ struct Parser
}
/**
* Parses an CastExpression
* Parses a CastExpression
*
* $(GRAMMAR )
* $(GRAMMAR $(RULEDEF castExpression):
* $(LITERAL 'cast') $(LITERAL '$(LPAREN)') ($(RULE type) | $(RULE castQualifier))? $(LITERAL '$(RPAREN)') $(RULE unaryExpression)
* ;)
*/
CastExpression parseCastExpression()
{
auto node = new CastExpression;
expect(TokenType.cast_);
expect(TokenType.lParen);
if (isCastQualifier())
node.castQualifier = parseCastQualifier();
else
node.type = parseType();
expect(TokenType.rParen);
node.unaryExpression = parseUnaryExpression();
return node;
}
private bool isCastQualifier() const
{
switch (current().type)
{
case TokenType.const_:
return peekIsOneOf(TokenType.shared_, TokenType.rParen);
case TokenType.immutable_:
return peekIs(TokenType.rParen);
case TokenType.inout_:
return peekIsOneOf(TokenType.shared_, TokenType.rParen);
case TokenType.shared_:
return peekIsOneOf(TokenType.const_, TokenType.inout_, TokenType.rParen);
default:
return false;
}
}
/**
* Parses a CastQualifier
*
* $(GRAMMAR castQualifier: 'const'
* | 'const' 'shared'
* | 'immutable'
* | 'inout'
* | 'inout' 'shared'
* | 'shared'
* | 'shared' 'const'
* | 'shared' 'inout'
* $(GRAMMAR $(RULEDEF castQualifier):
* $(LITERAL 'const')
* | $(LITERAL 'const') $(LITERAL 'shared')
* | $(LITERAL 'immutable')
* | $(LITERAL 'inout')
* | $(LITERAL 'inout') $(LITERAL 'shared')
* | $(LITERAL 'shared')
* | $(LITERAL 'shared') $(LITERAL 'const')
* | $(LITERAL 'shared') $(LITERAL 'inout')
* ;)
*/
CastQualifier parseCastQualifier()
@ -736,7 +798,8 @@ struct Parser
/**
* Parses a Catch
*
* $(GRAMMAR catch_: 'catch' '(' type Identifier? ')' nonEmptyStatementNoCaseNoDefault
* $(GRAMMAR $(RULEDEF catch):
* $(LITERAL 'catch') $(LITERAL '$(LPAREN)') $(RULE type) $(LITERAL Identifier)? $(LITERAL '$(RPAREN)') $(RULE nonEmptyStatementNoCaseNoDefault)
* ;)
*/
Catch parseCatch()
@ -767,7 +830,8 @@ struct Parser
/**
* Parses an ClassBody
*
* $(GRAMMAR classBody: '{' declarationOrInvariant* '}'
* $(GRAMMAR $(RULEDEF classBody):
* $(LITERAL '{') $(RULE declarationOrInvariant)* $(LITERAL '}')
* ;)
*/
ClassBody parseClassBody()
@ -783,7 +847,8 @@ struct Parser
/**
* Parses an ClassDeclaration
*
* $(GRAMMAR classDeclaration: 'class' Identifier (templateParameters constraint?)? (':' identifierList )? classBody
* $(GRAMMAR $(RULEDEF classDeclaration):
* $(LITERAL 'class') $(LITERAL Identifier) ($(RULE templateParameters) $(RULE constraint)?)? ($(LITERAL ':') $(RULE identifierList))? $(RULE classBody)
* ;)
*/
ClassDeclaration parseClassDeclaration()
@ -818,9 +883,10 @@ struct Parser
/**
* Parses a CompileCondition
*
* $(GRAMMAR compileCondition: versionCondition
* | debugCondition
* | staticIfCondition
* $(GRAMMAR $(RULEDEF compileCondition):
* $(RULE versionCondition)
* | $(RULE debugCondition)
* | $(RULE staticIfCondition)
* ;)
*/
CompileCondition parseCompileCondition()
@ -871,7 +937,8 @@ struct Parser
/**
* Parses an Constraint
*
* $(GRAMMAR constraint: 'if' '(' expression ')'
* $(GRAMMAR $(RULEDEF constraint):
* $(LITERAL 'if') $(LITERAL '$(LPAREN)') $(RULE expression) $(LITERAL '$(RPAREN)')
* ;)
*/
Constraint parseConstraint()
@ -887,7 +954,8 @@ struct Parser
/**
* Parses a Constructor
*
* $(GRAMMAR constructor: 'this' parameters functionBody
* $(GRAMMAR $(RULEDEF constructor):
* $(LITERAL 'this') $(RULE parameters) $(RULE functionBody)
* ;)
*/
Constructor parseConstructor()
@ -902,7 +970,8 @@ struct Parser
/**
* Parses an ContinueStatement
*
* $(GRAMMAR continueStatement: 'continue' Identifier? ';'
* $(GRAMMAR $(RULEDEF continueStatement):
* $(LITERAL 'continue') $(LITERAL Identifier)? $(LITERAL ';')
* ;)
*/
ContinueStatement parseContinueStatement()
@ -926,9 +995,10 @@ struct Parser
}
/**
* Parses an DebugCondition
* Parses a DebugCondition
*
* $(GRAMMAR debugCondition: 'debug' ('(' (IntegerLiteral | Identifier) ')')?
* $(GRAMMAR $(RULEDEF debugCondition):
* $(LITERAL 'debug') ($(LITERAL '$(LPAREN)') ($(LITERAL IntegerLiteral) | $(LITERAL Identifier)) $(LITERAL '$(RPAREN)'))?
* ;)
*/
DebugCondition parseDebugCondition()
@ -956,7 +1026,8 @@ struct Parser
/**
* Parses a DebugSpecification
*
* $(GRAMMAR debugSpecification: 'debug' '=' (Identifier | IntegerLiteral) ';'
* $(GRAMMAR $(RULEDEF debugSpecification):
* $(LITERAL 'debug') $(LITERAL '=') ($(LITERAL Identifier) | $(LITERAL IntegerLiteral)) $(LITERAL ';')
* ;)
*/
DebugSpecification parseDebugSpecification()
@ -978,29 +1049,30 @@ struct Parser
/**
* Parses a Declaration
*
* $(GRAMMAR declaration: aliasDeclaration
* | aliasThisDeclaration
* | attributedDeclaration
* | classDeclaration
* | conditionalDeclaration
* | constructor
* | destructor
* | enumDeclaration
* | functionDeclaration
* | importDeclaration
* | interfaceDeclaration
* | mixinDeclaration
* | pragmaDeclaration
* | sharedStaticConstructor
* | sharedStaticDestructor
* | staticAssertDeclaration
* | staticConstructor
* | staticDestructor
* | structDeclaration
* | templateDeclaration
* | unionDeclaration
* | unittest
* | variableDeclaration
* $(GRAMMAR $(RULEDEF declaration):
* $(RULE aliasDeclaration)
* | $(RULE aliasThisDeclaration)
* | $(RULE attributedDeclaration)
* | $(RULE classDeclaration)
* | $(RULE conditionalDeclaration)
* | $(RULE constructor)
* | $(RULE destructor)
* | $(RULE enumDeclaration)
* | $(RULE functionDeclaration)
* | $(RULE importDeclaration)
* | $(RULE interfaceDeclaration)
* | $(RULE mixinDeclaration)
* | $(RULE pragmaDeclaration)
* | $(RULE sharedStaticConstructor)
* | $(RULE sharedStaticDestructor)
* | $(RULE staticAssertDeclaration)
* | $(RULE staticConstructor)
* | $(RULE staticDestructor)
* | $(RULE structDeclaration)
* | $(RULE templateDeclaration)
* | $(RULE unionDeclaration)
* | $(RULE unittest)
* | $(RULE variableDeclaration)
* ;)
*/
Declaration parseDeclaration()
@ -1094,8 +1166,9 @@ struct Parser
/**
* Parses a DeclarationOrInvariant
*
* $(GRAMMAR declarationOrInvariant : declaration
* | invariant
* $(GRAMMAR $(RULEDEF declarationOrInvariant):
* $(RULE declaration)
* | $(RULE invariant)
* ;)
*/
DeclarationOrInvariant parseDeclarationOrInvariant()
@ -1111,7 +1184,8 @@ struct Parser
/**
* Parses a Declarator
*
* $(GRAMMAR declarator: Identifier declaratorSuffix? ('=' initializer)?
* $(GRAMMAR $(RULEDEF declarator):
* $(LITERAL Identifier) $(RULE declaratorSuffix)? ($(LITERAL '=') $(RULE initializer))?
* ;)
*/
Declarator parseDeclarator()
@ -1179,7 +1253,8 @@ struct Parser
/**
* Parses a Deprecated attribute
*
* $(GRAMMAR deprecated: 'deprecated' ('(' assignExpression ')')?
* $(GRAMMAR $(RULEDEF deprecated):
* $(LITERAL 'deprecated') ($(LITERAL '$(LPAREN)') $(RULE assignExpression) $(LITERAL '$(RPAREN)'))?
* ;)
*/
Deprecated parseDeprecated()
@ -1198,7 +1273,8 @@ struct Parser
/**
* Parses a Destructor
*
* $(GRAMMAR destructor: '~' 'this' '(' ')' functionBody
* $(GRAMMAR $(RULEDEF destructor):
* $(LITERAL '~') $(LITERAL 'this') $(LITERAL '$(LPAREN)') $(LITERAL '$(RPAREN)') $(RULE functionBody)
* ;)
*/
Destructor parseDestructor()
@ -1213,50 +1289,93 @@ struct Parser
}
/**
* Parses an DoStatement
* Parses a DoStatement
*
* $(GRAMMAR )
* $(GRAMMAR $(RULEDEF doStatement):
* $(LITERAL 'do') $(RULE blockStatement) $(LITERAL 'while') $(LITERAL '$(LPAREN)') $(RULE expression) $(LITERAL '$(RPAREN)') $(LITERAL ';')
* ;)
*/
DoStatement parseDoStatement()
{
auto node = new DoStatement;
expect(TokenType.do_);
node.blockStatement = parseBlockStatement();
expect(TokenType.while_);
expect(TokenType.lParen);
node.expression = parseExpression();
expect(TokenType.rParen);
expect(TokenType.semicolon);
return node;
}
/**
* Parses an EnumBody
*
* $(GRAMMAR )
* $(GRAMMAR $(RULEDEF enumBody):
* $(LITERAL ';')
* | $(LITERAL '{') $(RULE enumMember) ($(LITERAL ',') $(RULE enumMember)?)* $(LITERAL '}')
* ;)
*/
EnumBody parseEnumBody()
{
auto node = new EnumBody;
if (!currentIs(TokenType.semicolon))
{
expect (TokenType.lBrace);
while (moreTokens())
{
if (!currentIs(TokenType.comma))
node.enumMembers ~= parseEnumMember();
if (currentIs(TokenType.comma))
continue;
else if (currentIs(TokenType.rBrace))
break;
else
{
error(`",", "}" or enum member expected`);
goto ret;
}
}
expect (TokenType.rBrace);
}
ret:
return node;
}
/**
* Parses an EnumDeclaration
*
* $(GRAMMAR )
* $(GRAMMAR $(RULEDEF enumDeclaration):
* $(LITERAL 'enum') $(LITERAL Identifier)? ($(LITERAL ':') $(RULE type))? $(RULE enumBody)
* ;)
*/
EnumDeclaration parseEnumDeclaration()
{
auto node = new EnumDeclaration;
expect(TokenType.enum_);
if (currentIs(TokenType.identifier))
node.identifier = advance();
if (currentIs(TokenType.colon))
{
advance();
node.type = parseType();
}
node.enumBody = parseEnumBody();
return node;
}
/**
* Parses an EnumMember
*
* $(GRAMMAR )
* $(GRAMMAR $(RULEDEF enumMember):
* $(LITERAL Identifier)
* | ($(LITERAL Identifier) | $(RULE type)) $(LITERAL '=') $(RULE assignExpression)
* ;)
*/
EnumMember parseEnumMember()
{
auto node = new EnumMember;
// TODO
return node;
}
@ -1454,7 +1573,8 @@ struct Parser
/**
* Parses an IdentifierChain
*
* $(GRAMMAR identifierChain: Identifier ('.' Identifier)*
* $(GRAMMAR $(RULEDEF identifierChain):
* $(LITERAL Identifier) ($(LITERAL '.') $(LITERAL Identifier))*
* ;)
*/
IdentifierChain parseIdentifierChain()
@ -1474,10 +1594,23 @@ struct Parser
return node;
}
unittest
{
auto input = cast(ubyte[]) "abcde.frocegu.creou.faowe"c;
LexerConfig config;
auto tokens = byToken(input, config);
Parser p;
p.fileName = "test";
p.tokens = tokens.array();
auto chain = p.parseIdentifierChain();
assert (chain.identifiers == ["abcde", "frocegu", "creou", "faowe"]);
}
/**
* Parses an IdentifierList
*
* $(GRAMMAR identifierList: Identifier (',' Identifier)*
* $(GRAMMAR $(RULEDEF identifierList):
* $(LITERAL Identifier) ($(LITERAL ',') $(LITERAL Identifier))*
* ;)
*/
IdentifierList parseIdentifierList()
@ -1605,6 +1738,20 @@ struct Parser
return node;
}
/**
* Parses an IndexExpression
*
* $(GRAMMAR $(RULEDEF indexExpression):
* $(RULE unaryExpression) $(LITERAL '[') $(RULE argumentList) $(LITERAL ']')
* ;)
*/
IndexExpression parseImportList()
{
auto node = new IndexExpression;
return node;
}
/**
* Parses an InExpression
*
@ -1753,7 +1900,8 @@ struct Parser
/**
* Parses an LinkageAttribute
*
* $(GRAMMAR linkageAttribute: 'extern' '(' Identifier '++'? ')'
* $(GRAMMAR $(RULEDEF linkageAttribute):
* $(LITERAL 'extern') $(LITERAL '$(LPAREN)') $(LITERAL Identifier) $(LITERAL '++')? $(LITERAL '$(RPAREN)')
* ;)
*/
LinkageAttribute parseLinkageAttribute()
@ -1786,7 +1934,8 @@ struct Parser
/**
* Parses an MixinDeclaration
*
* $(GRAMMAR mixinDeclaration: mixinExpression ';'
* $(GRAMMAR $(RULEDEF mixinDeclaration):
* $(RULE mixinExpression) $(LITERAL ';')
* ;)
*/
MixinDeclaration parseMixinDeclaration()
@ -1824,7 +1973,8 @@ struct Parser
/**
* Parses a Module
*
* $(GRAMMAR module: moduleDeclaration? declaration*
* $(GRAMMAR $(RULEDEF module):
* $(RULE moduleDeclaration)? $(RULE declaration)*
* ;)
*/
Module parseModule()
@ -1850,7 +2000,8 @@ struct Parser
/**
* Parses a ModuleDeclaration
*
* $(GRAMMAR moduleDeclaration: 'module' identifierChain ';'
* $(GRAMMAR $(RULEDEF moduleDeclaration):
* $(LITERAL 'module') $(RULE identifierChain) $(LITERAL ';')
* ;)
*/
ModuleDeclaration parseModuleDeclaration()
@ -1864,8 +2015,9 @@ struct Parser
/**
* Parses a MulExpression
* $(GRAMMAR mulExpression: unaryExpression
* | mulExpression ('*' | '/' | '%') unaryExpression
* $(GRAMMAR $(RULEDEF mulExpression):
* $(RULE unaryExpression)
* | $(RULE mulExpression) ($(LITERAL '*') | $(LITERAL '/') | $(LITERAL '%')) $(RULE unaryExpression)
* ;)
*/
MulExpression parseMulExpression()
@ -2233,8 +2385,9 @@ struct Parser
/**
* Parses a Statement
*
* $(GRAMMAR statement: ';'
* | nonEmptyStatement
* $(GRAMMAR $(RULEDEF statement):
* $(LITERAL ';')
* | $(RULE nonEmptyStatement)
* ;)
*/
Statement parseStatement()
@ -2364,9 +2517,10 @@ struct Parser
}
/**
* Parses an StructDeclaration
* Parses a StructDeclaration
*
* $(GRAMMAR structDeclaration: 'struct' Identifier (templateParameters constraint? structBody | (structBody | ';'))
* $(GRAMMAR $(RULEDEF structDeclaration):
* $(LITERAL 'struct') $(LITERAL Identifier) ($(RULE templateParameters) $(RULE constraint)? $(RULE structBody) | ($(RULE structBody) | $(LITERAL ';')))
* ;)
*/
StructDeclaration parseStructDeclaration()
@ -2881,9 +3035,27 @@ struct Parser
}
/**
* Parses an UnaryExpression
* Parses a UnaryExpression
*
* $(GRAMMAR )
* $(GRAMMAR $(RULEDEF unaryExpression):
* $(RULE primaryExpression)
* | $(LITERAL '&') $(RULE unaryExpression)
* | $(LITERAL '!') $(RULE unaryExpression)
* | $(LITERAL '*') $(RULE unaryExpression)
* | $(LITERAL '+') $(RULE unaryExpression)
* | $(LITERAL '-') $(RULE unaryExpression)
* | $(LITERAL '~') $(RULE unaryExpression)
* | $(RULE newExpression)
* | $(RULE deleteExpression)
* | $(RULE castExpression)
* | $(RULE functionCallExpression)
* | $(RULE preIncDecExpression)
* | $(RULE postIncDecExpression)
* | $(RULE sliceExpression)
* | $(RULE indexExpression)
* | $(RULE unaryExpression) $(LITERAL '.') $(RULE identifierOrTemplateInstance)
* | $(RULE assertExpression)
* ;)
*/
UnaryExpression parseUnaryExpression()
{
@ -2905,9 +3077,11 @@ struct Parser
}
/**
* Parses an Unittest
* Parses a Unittest
*
* $(GRAMMAR )
* $(GRAMMAR $(RULEDEF unittest):
* $(LITERAL 'unittest') $(RULE blockStatement)
* ;)
*/
Unittest parseUnittest()
{
@ -2932,7 +3106,8 @@ struct Parser
/**
* Parses a VersionCondition
*
* $(GRAMMAR versionCondition: 'version' '(' (IntegerLiteral | Identifier | 'unittest' | 'assert') ')'
* $(GRAMMAR $(RULEDEF versionCondition):
* $(LITERAL 'version') $(LITERAL '$(LPAREN)') ($(LITERAL IntegerLiteral) | $(LITERAL Identifier) | $(LITERAL 'unittest') | $(LITERAL 'assert')) $(LITERAL '$(RPAREN)')
* ;)
*/
VersionCondition parseVersionCondition()
@ -2957,7 +3132,8 @@ struct Parser
/**
* Parses a VersionSpecification
*
* $(GRAMMAR versionSpecification: 'version' '=' (Identifier | IntegerLiteral) ';'
* $(GRAMMAR $(RULEDEF versionSpecification):
* $(LITERAL 'version') $(LITERAL '=') ($(LITERAL Identifier) | $(LITERAL IntegerLiteral)) $(LITERAL ';')
* ;)
*/
VersionSpecification parseVersionSpecification()
@ -2976,9 +3152,10 @@ struct Parser
}
/**
* Parses an WhileStatement
* Parses a WhileStatement
*
* $(GRAMMAR whileStatement: 'while' '(' expression ')' statementNoCaseNoDefault
* $(GRAMMAR $(RULEDEF whileStatement):
* $(LITERAL 'while') $(LITERAL '$(LPAREN)') $(RULE expression) $(LITERAL '$(RPAREN)') $(RULE statementNoCaseNoDefault)
* ;)
*/
WhileStatement parseWhileStatement()
@ -2993,16 +3170,18 @@ struct Parser
}
/**
* Parses an WithStatement
* Parses a WithStatement
*
* $(GRAMMAR )
* $(GRAMMAR $(RULEDEF withStatement):
* $(LITERAL 'with') $(LITERAL '$(LPAREN)') ($(RULE expression) | $(RULE symbol) | $(RULE templateInstance)) $(LITERAL '$(RPAREN)') $(RULE nonEmptyStatementNoCaseNoDefault)
* ;)
*/
WithStatement parseWithStatement()
{
auto node = new WithStatement;
expect(TokenType.with_);
expect(TokenType.lParen);
// magic here
// TODO: magic here
expect(TokenType.rParen);
parseNonEmptyStatementNoCaseNoDefault();
return node;
@ -3033,7 +3212,7 @@ struct Parser
}
}
Token* peekPast(alias O, alias C)()
const(Token)* peekPast(alias O, alias C)()
in
{
assert (tokens[index].type == O);
@ -3059,26 +3238,37 @@ struct Parser
return depth == 0 ? &tokens[i] : null;
}
Token* peekPastParens()
const(Token)* peekPastParens()
{
return peekPast!(TokenType.lParen, TokenType.rParen)();
}
Token* peekPastBrackets()
const(Token)* peekPastBrackets()
{
return peekPast!(TokenType.lBracket, TokenType.rBracket)();
}
Token* peekPastBraces()
const(Token)* peekPastBraces()
{
return peekPast!(TokenType.lBrace, TokenType.rBrace)();
}
bool peekIs(TokenType t) const
{
return index + 1 < tokens.length && tokens[index + 1].type == t;
}
bool peekIsOneOf(TokenType[] types...) const
{
if (index + 1 >= tokens.length) return false;
return canFind(types, tokens[index + 1].type);
}
/**
* Returns a token of the specified type if it was the next token, otherwise
* calls the error function and returns null.
*/
Token* expect(TokenType type)
const(Token)* expect(TokenType type)
{
if (tokens[index].type == type)
return &tokens[index++];
@ -3092,7 +3282,7 @@ struct Parser
/**
* Returns: the current token
*/
Token current()
Token current() const
{
return tokens[index];
}
@ -3108,20 +3298,20 @@ struct Parser
/**
* Returns: true if the current token has the given type
*/
bool currentIs(TokenType type)
bool currentIs(TokenType type) const
{
return tokens[index] == type;
return index < tokens.length && tokens[index] == type;
}
/**
* Returns: true if the current token is one of the given types
*/
bool currentIsOneOf(TokenType[] types...)
bool currentIsOneOf(TokenType[] types...) const
{
return canFind(types, current().type);
}
bool startsWith(TokenType[] types...)
bool startsWith(TokenType[] types...) const
{
for (size_t i = 0; i != types.length; ++i)
{
@ -3134,13 +3324,13 @@ struct Parser
/**
* Returns: true if there are more tokens
*/
bool moreTokens()
bool moreTokens() const
{
return index < tokens.length;
}
uint errorCount;
Token[] tokens;
const(Token)[] tokens;
size_t index;
string fileName;
}