projects/dil: trunk/src/dil/parser/Parser.d comparison

comparison trunk/src/dil/parser/Parser.d @ 774:846044180d22

Added method skip() to class Parser.

author	Aziz K?ksal <aziz.koeksal@gmail.com>
date	Mon, 18 Feb 2008 20:03:44 +0100
parents	5e3ef1b2011c
children	c1d5cfd7aa44

comparison

equal deleted inserted replaced

-:6dbbb403fc58
+:846044180d22
 bool consumed()(TOK k) // Templatized, so it's inlined.
 {
 return token.kind == k ? (nT(), true) : false;
 }
+/// Asserts that the current token is of kind expectedKind,
+/// and then moves to the next token.
+void skip()(TOK expectedKind)
+{
+assert(token.kind == expectedKind /+|| *(int*).init+/, token.srcText());
+nT();
+}
 /+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 |                        Declaration parsing methods                        |
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+/
 Declaration parseModuleDeclaration()
 {
-assert(token.kind == T.Module);
+skip(T.Module);
 auto begin = token;
 ModuleFQN moduleFQN;
 do
-{
-nT();
 moduleFQN ~= requireIdentifier(MSG.ExpectedModuleIdentifier);
-} while (token.kind == T.Dot)
+while (consumed(T.Dot))
 require(T.Semicolon);
 return set(new ModuleDeclaration(moduleFQN), begin);
 }
 /++
 bool testAutoDeclaration = false,
 bool optionalParameterList = true)
 {
 auto begin = token;
 Type type;
-Identifier* ident;
+Identifier* name;
 // Check for AutoDeclaration: StorageClasses Identifier =
 if (testAutoDeclaration &&
 token.kind == T.Identifier &&
 peekNext() == T.Assign)
 {
-ident = token.ident;
+name = token.ident;
-nT();
+skip(T.Identifier);
 }
 else
 {
 type = parseType(); // VariableType or ReturnType
 if (token.kind == T.LParen)
 //     // In the following case precedence is given to a CallExpression.
 //     something(*p); // 'something' may be a function/method or an object having opCall overloaded.
 //   }
 //   // A pointer to a function taking no parameters and returning 'something'.
 //   something(*p);
-type = parseCFunctionPointerType(type, ident, optionalParameterList);
+type = parseCFunctionPointerType(type, name, optionalParameterList);
 }
 else if (peekNext() == T.LParen)
 { // Type FunctionName ( ParameterList ) FunctionBody
-ident = requireIdentifier(MSG.ExpectedFunctionName);
+name = requireIdentifier(MSG.ExpectedFunctionName);
-ident || nT(); // Skip non-identifier token.
+name || nT(); // Skip non-identifier token.
 assert(token.kind == T.LParen);
 // It's a function declaration
 TemplateParameters tparams;
 if (tokenAfterParenIs(T.LParen))
 // ( TemplateParameterList ) ( ParameterList )
 default:
 }
 }
 // ReturnType FunctionName ( ParameterList )
 auto funcBody = parseFunctionBody();
-auto fd = new FunctionDeclaration(type, ident,/+ tparams,+/ params, funcBody);
+auto fd = new FunctionDeclaration(type, name,/+ tparams,+/ params, funcBody);
 fd.setStorageClass(stc);
 fd.setLinkageType(linkType);
 fd.setProtection(protection);
 if (tparams)
 {
-auto d = putInsideTemplateDeclaration(begin, ident, fd, tparams);
+auto d = putInsideTemplateDeclaration(begin, name, fd, tparams);
 d.setStorageClass(stc);
 d.setProtection(protection);
 return set(d, begin);
 }
 return set(fd, begin);
 }
 else
-{
+{ // Type VariableName DeclaratorSuffix
-// Type VariableName DeclaratorSuffix
+name = requireIdentifier(MSG.ExpectedVariableName);
-ident = requireIdentifier(MSG.ExpectedVariableName);
 type = parseDeclaratorSuffix(type);
 }
 }
-// It's a variable declaration.
+// It's a variables declaration.
-Identifier*[] idents = [ident];
+Identifier*[] names = [name]; // One identifier has been parsed already.
 Expression[] values;
-goto LenterLoop; // We've already parsed an identifier. Jump to if statement and check for initializer.
+goto LenterLoop; // Enter the loop and check for an initializer.
 while (consumed(T.Comma))
 {
-idents ~= requireIdentifier(MSG.ExpectedVariableName);
+names ~= requireIdentifier(MSG.ExpectedVariableName);
 LenterLoop:
 if (consumed(T.Assign))
 values ~= parseInitializer();
 else
 values ~= null;
 }
 require(T.Semicolon);
-auto d = new VariablesDeclaration(type, idents, values);
+auto d = new VariablesDeclaration(type, names, values);
 d.setStorageClass(stc);
 d.setLinkageType(linkType);
 d.setProtection(protection);
 return set(d, begin);
 }
 {
 auto begin = token;
 auto next = peekNext();
 if (next == T.Comma || next == T.Semicolon)
 {
-nT();
+skip(T.Void);
 return set(new VoidInitExpression(), begin);
 }
 }
 return parseNonVoidInitializer();
 }
 //         [ ]
 //         [ ArrayMemberInitializations ]
 Expression[] keys;
 Expression[] values;
-nT();
+skip(T.LBracket);
 while (token.kind != T.RBracket)
 {
 auto e = parseNonVoidInitializer();
 if (consumed(T.Colon))
 {
 {
 keys ~= null;
 values ~= e;
 }
-if (token.kind != T.Comma)
+if (!consumed(T.Comma))
 break;
-nT();
 }
 require(T.RBracket);
 init = new ArrayInitExpression(keys, values);
 break;
 case T.LBrace:
 Expression parseStructInitializer()
 {
 Identifier*[] idents;
 Expression[] values;
-nT();
+skip(T.LBrace);
 while (token.kind != T.RBrace)
 {
 if (token.kind == T.Identifier &&
 // Peek for colon to see if this is a member identifier.
 peekNext() == T.Colon)
 {
 idents ~= token.ident;
-nT(), nT(); // Skip Identifier :
+skip(T.Identifier), skip(T.Colon);
 }
 else
 idents ~= null;
 // NonVoidInitializer
 values ~= parseNonVoidInitializer();
-if (token.kind != T.Comma)
+if (!consumed(T.Comma))
 break;
-nT();
 }
 require(T.RBrace);
 return new StructInitExpression(idents, values);
 }
 }
 LinkageType parseLinkageType()
 {
 LinkageType linkageType;
-if (token.kind != T.LParen)
+if (!consumed(T.LParen))
 return linkageType;
-nT(); // Skip (
+if (consumed(T.RParen))
-if (token.kind == T.RParen)
+{ // extern()
-{
-nT();
 error(MID.MissingLinkageType);
 return linkageType;
 }
 auto identTok = requireId();
 return parse();
 }
 uint parseAlignAttribute()
 {
-assert(token.kind == T.Align);
+skip(T.Align);
-nT(); // Skip align keyword.
 uint size = DEFAULT_ALIGN_SIZE; // Global default.
 if (consumed(T.LParen))
 {
 if (token.kind == T.Int32)
-(size = token.int_), nT();
+(size = token.int_), skip(T.Int32);
 else
 expected(T.Int32);
 require(T.RParen);
 }
 return size;
 return decl;
 }
 Declaration parseImportDeclaration()
 {
-assert(token.kind == T.Import || token.kind == T.Static);
 bool isStatic = consumed(T.Static);
-assert(token.kind == T.Import);
+skip(T.Import);
-nT(); // Skip import keyword.
 ModuleFQN[] moduleFQNs;
 Identifier*[] moduleAliases;
 Identifier*[] bindNames;
 Identifier*[] bindAliases;
 Identifier* moduleAlias;
 // AliasName = ModuleName
 if (peekNext() == T.Assign)
 {
 moduleAlias = requireIdentifier(MSG.ExpectedAliasModuleName);
-nT(); // Skip =
+skip(T.Assign);
 }
 // Identifier ("." Identifier)*
 do
 moduleFQN ~= requireIdentifier(MSG.ExpectedModuleIdentifier);
 while (consumed(T.Dot))
 // Push identifiers.
 moduleFQNs ~= moduleFQN;
 moduleAliases ~= moduleAlias;
 } while (consumed(T.Comma))
-if (token.kind == T.Colon)
+if (consumed(T.Colon))
-{
+{ // BindAlias "=" BindName ("," BindAlias "=" BindName)*;
-// BindAlias = BindName(, BindAlias = BindName)*;
+// BindName ("," BindName)*;
-// BindName(, BindName)*;
 do
 {
-nT();
 Identifier* bindAlias;
 // BindAlias = BindName
 if (peekNext() == T.Assign)
 {
 bindAlias = requireIdentifier(MSG.ExpectedAliasImportName);
-nT(); // Skip =
+skip(T.Assign);
 }
 // Push identifiers.
 bindNames ~= requireIdentifier(MSG.ExpectedImportName);
 bindAliases ~= bindAlias;
-} while (token.kind == T.Comma)
+} while (consumed(T.Comma))
 }
 require(T.Semicolon);
 return new ImportDeclaration(moduleFQNs, moduleAliases, bindNames, bindAliases, isStatic);
 }
 Declaration parseEnumDeclaration()
 {
-assert(token.kind == T.Enum);
+skip(T.Enum);
-nT(); // Skip enum keyword.
 Identifier* enumName;
 Type baseType;
 EnumMemberDeclaration[] members;
 bool hasBody;
 else
 value = null;
 members ~= set(new EnumMemberDeclaration(name, value), begin);
-if (token.kind != T.Comma)
+if (!consumed(T.Comma))
 break;
-nT(); // Skip ,
 }
 require(T.RBrace);
 }
 else
 error(token, MSG.ExpectedEnumBody, token.srcText);
 return new TemplateDeclaration(name, tparams, cd);
 }
 Declaration parseClassDeclaration()
 {
-assert(token.kind == T.Class);
+auto begin = token;
-auto begin = token;
+skip(T.Class);
-nT(); // Skip class keyword.
 Identifier* className;
 TemplateParameters tparams;
 BaseClassType[] bases;
 CompoundDeclaration decls;
 return d;
 }
 BaseClassType[] parseBaseClasses(bool colonLeadsOff = true)
 {
-if (colonLeadsOff)
+colonLeadsOff && skip(T.Colon);
-{
-assert(token.kind == T.Colon);
-nT(); // Skip colon
-}
 BaseClassType[] bases;
 do
 {
 Protection prot = Protection.Public;
 switch (token.kind)
 {
 return bases;
 }
 Declaration parseInterfaceDeclaration()
 {
-assert(token.kind == T.Interface);
+auto begin = token;
-auto begin = token;
+skip(T.Interface);
-nT(); // Skip interface keyword.
 Identifier* name;
 TemplateParameters tparams;
 BaseClassType[] bases;
 CompoundDeclaration decls;
 Declaration parseStructOrUnionDeclaration()
 {
 assert(token.kind == T.Struct || token.kind == T.Union);
 auto begin = token;
-nT(); // Skip struct or union keyword.
+skip(token.kind);
 Identifier* name;
 TemplateParameters tparams;
 CompoundDeclaration decls;
 return d;
 }
 Declaration parseConstructorDeclaration()
 {
-assert(token.kind == T.This);
+skip(T.This);
-nT(); // Skip 'this' keyword.
 auto parameters = parseParameterList();
 auto funcBody = parseFunctionBody();
 return new ConstructorDeclaration(parameters, funcBody);
 }
 Declaration parseDestructorDeclaration()
 {
-assert(token.kind == T.Tilde);
+skip(T.Tilde);
-nT(); // Skip ~
 require(T.This);
 require(T.LParen);
 require(T.RParen);
 auto funcBody = parseFunctionBody();
 return new DestructorDeclaration(funcBody);
 }
 Declaration parseStaticConstructorDeclaration()
 {
-assert(token.kind == T.Static);
+skip(T.Static);
-nT(); // Skip static keyword.
+skip(T.This);
-nT(); // Skip 'this' keyword.
 require(T.LParen);
 require(T.RParen);
 auto funcBody = parseFunctionBody();
 return new StaticConstructorDeclaration(funcBody);
 }
 Declaration parseStaticDestructorDeclaration()
 {
-assert(token.kind == T.Static);
+skip(T.Static);
-nT(); // Skip static keyword.
+skip(T.Tilde);
-nT(); // Skip ~
 require(T.This);
 require(T.LParen);
 require(T.RParen);
 auto funcBody = parseFunctionBody();
 return new StaticDestructorDeclaration(funcBody);
 }
 Declaration parseInvariantDeclaration()
 {
-assert(token.kind == T.Invariant);
+skip(T.Invariant);
-nT(); // Skip invariant keyword.
 // Optional () for getting ready porting to D 2.0
-if (token.kind == T.LParen)
+if (consumed(T.LParen))
-requireNext(T.RParen);
+require(T.RParen);
 auto funcBody = parseFunctionBody();
 return new InvariantDeclaration(funcBody);
 }
 Declaration parseUnittestDeclaration()
 {
-assert(token.kind == T.Unittest);
+skip(T.Unittest);
-nT(); // Skip unittest keyword.
 auto funcBody = parseFunctionBody();
 return new UnittestDeclaration(funcBody);
 }
 Token* parseIdentOrInt()
 return null;
 }
 Declaration parseDebugDeclaration()
 {
-assert(token.kind == T.Debug);
+skip(T.Debug);
-nT(); // Skip debug keyword.
 Token* spec;
 Token* cond;
 Declaration decls, elseDecls;
 return new DebugDeclaration(spec, cond, decls, elseDecls);
 }
 Declaration parseVersionDeclaration()
 {
-assert(token.kind == T.Version);
+skip(T.Version);
-nT(); // Skip version keyword.
 Token* spec;
 Token* cond;
 Declaration decls, elseDecls;
 return new VersionDeclaration(spec, cond, decls, elseDecls);
 }
 Declaration parseStaticIfDeclaration()
 {
-assert(token.kind == T.Static);
+skip(T.Static);
-nT(); // Skip static keyword.
+skip(T.If);
-nT(); // Skip if keyword.
 Expression condition;
 Declaration ifDecls, elseDecls;
 require(T.LParen);
 return new StaticIfDeclaration(condition, ifDecls, elseDecls);
 }
 Declaration parseStaticAssertDeclaration()
 {
-assert(token.kind == T.Static);
+skip(T.Static);
-nT(); // Skip static keyword.
+skip(T.Assert);
-nT(); // Skip assert keyword.
 Expression condition, message;
 require(T.LParen);
 condition = parseAssignExpression();
 if (consumed(T.Comma))
 message = parseAssignExpression();
 return new StaticAssertDeclaration(condition, message);
 }
 Declaration parseTemplateDeclaration()
 {
-assert(token.kind == T.Template);
+skip(T.Template);
-nT(); // Skip template keyword.
 auto templateName = requireIdentifier(MSG.ExpectedTemplateName);
 auto templateParams = parseTemplateParameterList();
 auto decls = parseDeclarationDefinitionsBody();
 return new TemplateDeclaration(templateName, templateParams, decls);
 }
 Declaration parseNewDeclaration()
 {
-assert(token.kind == T.New);
+skip(T.New);
-nT(); // Skip new keyword.
 auto parameters = parseParameterList();
 auto funcBody = parseFunctionBody();
 return new NewDeclaration(parameters, funcBody);
 }
 Declaration parseDeleteDeclaration()
 {
-assert(token.kind == T.Delete);
+skip(T.Delete);
-nT(); // Skip delete keyword.
 auto parameters = parseParameterList();
 auto funcBody = parseFunctionBody();
 return new DeleteDeclaration(parameters, funcBody);
 }
 Type parseTypeofType()
 {
-assert(token.kind == T.Typeof);
+auto begin = token;
-auto begin = token;
+skip(T.Typeof);
+require(T.LParen);
 Type type;
-requireNext(T.LParen);
 switch (token.kind)
 {
 version(D2)
 {
 case T.Return:
 mixin TemplateIdentifier !( TemplateArguments ) MixinIdentifier ;
 +/
 Class parseMixin(Class)()
 {
 static assert(is(Class == MixinDeclaration) || is(Class == MixinStatement));
-assert(token.kind == T.Mixin);
+skip(T.Mixin);
-nT(); // Skip mixin keyword.
 static if (is(Class == MixinDeclaration))
 {
 if (consumed(T.LParen))
 {
 return s;
 case T.Identifier:
 if (peekNext() == T.Colon)
 {
 auto ident = token.ident;
-nT(), nT(); // Skip Identifier :
+skip(T.Identifier); skip(T.Colon);
 s = new LabeledStatement(ident, parseNoScopeOrEmptyStatement());
 break;
 }
 goto case T.Dot;
 case T.Dot, T.Typeof:
 return new DeclarationStatement(parse());
 }
 Statement parseIfStatement()
 {
-assert(token.kind == T.If);
+skip(T.If);
-nT();
 Statement variable;
 Expression condition;
 Statement ifBody, elseBody;
 set(d, begin);
 variable = new DeclarationStatement(d);
 set(variable, begin);
 }
 else
-{
+{ // Declarator = Expression
-// Declarator = Expression
 Type parseDeclaratorAssign()
 {
 auto type = parseDeclarator(ident);
 require(T.Assign);
 return type;
 return new IfStatement(variable, condition, ifBody, elseBody);
 }
 Statement parseWhileStatement()
 {
-assert(token.kind == T.While);
+skip(T.While);
-nT();
 require(T.LParen);
 auto condition = parseExpression();
 require(T.RParen);
 return new WhileStatement(condition, parseScopeStatement());
 }
 Statement parseDoWhileStatement()
 {
-assert(token.kind == T.Do);
+skip(T.Do);
-nT();
 auto doBody = parseScopeStatement();
 require(T.While);
 require(T.LParen);
 auto condition = parseExpression();
 require(T.RParen);
 return new DoWhileStatement(condition, doBody);
 }
 Statement parseForStatement()
 {
-assert(token.kind == T.For);
+skip(T.For);
-nT();
-require(T.LParen);
 Statement init, forBody;
 Expression condition, increment;
-if (token.kind != T.Semicolon)
+require(T.LParen);
+if (!consumed(T.Semicolon))
 init = parseNoScopeStatement();
-else
-nT(); // Skip ;
 if (token.kind != T.Semicolon)
 condition = parseExpression();
 require(T.Semicolon);
 if (token.kind != T.RParen)
 increment = parseExpression();
 return new ForeachStatement(tok, params, e, forBody);
 }
 Statement parseSwitchStatement()
 {
-assert(token.kind == T.Switch);
+skip(T.Switch);
-nT();
 require(T.LParen);
 auto condition = parseExpression();
 require(T.RParen);
 auto switchBody = parseScopeStatement();
 return new SwitchStatement(condition, switchBody);
 }
-/++
+/// Helper function for parsing the body of a default or case statement.
-Helper function for parsing the body of
-a default or case statement.
-+/
 Statement parseCaseOrDefaultBody()
 {
 // This function is similar to parseNoScopeStatement()
 auto begin = token;
 auto s = new CompoundStatement();
 return set(new ScopeStatement(s), begin);
 }
 Statement parseCaseStatement()
 {
-assert(token.kind == T.Case);
+skip(T.Case);
-nT();
 auto values = parseExpressionList();
 require(T.Colon);
 auto caseBody = parseCaseOrDefaultBody();
 return new CaseStatement(values, caseBody);
 }
 Statement parseDefaultStatement()
 {
-assert(token.kind == T.Default);
+skip(T.Default);
-nT();
 require(T.Colon);
 auto defaultBody = parseCaseOrDefaultBody();
 return new DefaultStatement(defaultBody);
 }
 Statement parseContinueStatement()
 {
-assert(token.kind == T.Continue);
+skip(T.Continue);
-nT();
 auto ident = optionalIdentifier();
 require(T.Semicolon);
 return new ContinueStatement(ident);
 }
 Statement parseBreakStatement()
 {
-assert(token.kind == T.Break);
+skip(T.Break);
-nT();
 auto ident = optionalIdentifier();
 require(T.Semicolon);
 return new BreakStatement(ident);
 }
 Statement parseReturnStatement()
 {
-assert(token.kind == T.Return);
+skip(T.Return);
-nT();
 Expression expr;
 if (token.kind != T.Semicolon)
 expr = parseExpression();
 require(T.Semicolon);
 return new ReturnStatement(expr);
 }
 Statement parseGotoStatement()
 {
-assert(token.kind == T.Goto);
+skip(T.Goto);
-nT();
 Identifier* ident;
 Expression caseExpr;
 switch (token.kind)
 {
 case T.Case:
+ident = token.ident;
 nT();
 if (token.kind == T.Semicolon)
 break;
 caseExpr = parseExpression();
 break;
 case T.Default:
+ident = token.ident;
 nT();
 break;
 default:
 ident = requireIdentifier(MSG.ExpectedAnIdentifier);
 }
 return new GotoStatement(ident, caseExpr);
 }
 Statement parseWithStatement()
 {
-assert(token.kind == T.With);
+skip(T.With);
-nT();
 require(T.LParen);
 auto expr = parseExpression();
 require(T.RParen);
 return new WithStatement(expr, parseScopeStatement());
 }
 Statement parseSynchronizedStatement()
 {
-assert(token.kind == T.Synchronized);
+skip(T.Synchronized);
-nT();
 Expression expr;
 if (consumed(T.LParen))
 {
 expr = parseExpression();
 require(T.RParen);
 return new SynchronizedStatement(expr, parseScopeStatement());
 }
 Statement parseTryStatement()
 {
-assert(token.kind == T.Try);
+auto begin = token;
-auto begin = token;
+skip(T.Try);
-nT();
 auto tryBody = parseScopeStatement();
 CatchStatement[] catchBodies;
 FinallyStatement finBody;
 return new TryStatement(tryBody, catchBodies, finBody);
 }
 Statement parseThrowStatement()
 {
-assert(token.kind == T.Throw);
+skip(T.Throw);
-nT();
 auto expr = parseExpression();
 require(T.Semicolon);
 return new ThrowStatement(expr);
 }
 Statement parseScopeGuardStatement()
 {
-assert(token.kind == T.Scope);
+skip(T.Scope);
-nT();
+skip(T.LParen);
-assert(token.kind == T.LParen);
-nT();
 auto condition = requireIdentifier(MSG.ExpectedScopeIdentifier);
 if (condition)
 switch (condition.idKind)
 {
 case IDK.exit, IDK.success, IDK.failure:
 return new ScopeGuardStatement(condition, scopeBody);
 }
 Statement parseVolatileStatement()
 {
-assert(token.kind == T.Volatile);
+skip(T.Volatile);
-nT();
 Statement volatileBody;
 if (token.kind == T.Semicolon)
 nT();
 else if (token.kind == T.LBrace)
 volatileBody = parseScopeStatement();
 return new VolatileStatement(volatileBody);
 }
 Statement parsePragmaStatement()
 {
-assert(token.kind == T.Pragma);
+skip(T.Pragma);
-nT();
 Identifier* ident;
 Expression[] args;
 Statement pragmaBody;
 return new PragmaStatement(ident, args, pragmaBody);
 }
 Statement parseStaticIfStatement()
 {
-assert(token.kind == T.Static);
+skip(T.Static);
-nT();
+skip(T.If);
-assert(token.kind == T.If);
-nT();
 Expression condition;
 Statement ifBody, elseBody;
 require(T.LParen);
 condition = parseExpression();
 return new StaticIfStatement(condition, ifBody, elseBody);
 }
 Statement parseStaticAssertStatement()
 {
-assert(token.kind == T.Static);
+skip(T.Static);
-nT();
+skip(T.Assert);
-assert(token.kind == T.Assert);
-nT();
 Expression condition, message;
 require(T.LParen);
 condition = parseAssignExpression(); // Condition.
 if (consumed(T.Comma))
 message = parseAssignExpression(); // Error message.
 require(T.RParen);
 return new StaticAssertStatement(condition, message);
 }
 Statement parseDebugStatement()
 {
-assert(token.kind == T.Debug);
+skip(T.Debug);
-nT(); // Skip debug keyword.
 Token* cond;
 Statement debugBody, elseBody;
 // ( Condition )
 if (consumed(T.LParen))
 return new DebugStatement(cond, debugBody, elseBody);
 }
 Statement parseVersionStatement()
 {
-assert(token.kind == T.Version);
+skip(T.Version);
-nT(); // Skip version keyword.
 Token* cond;
 Statement versionBody, elseBody;
 // ( Condition )
 require(T.LParen);
 |                         Assembler parsing methods                         |
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+/
 Statement parseAsmBlockStatement()
 {
-assert(token.kind == T.Asm);
+skip(T.Asm);
-nT(); // Skip asm keyword.
 require(T.LBrace);
 auto ss = new CompoundStatement;
 while (token.kind != T.RBrace && token.kind != T.EOF)
 ss ~= parseAsmStatement();
 require(T.RBrace);
 ident = token.ident;
 nT();
 goto LOpcode;
 case T.Identifier:
 ident = token.ident;
-nT(); // Skip Identifier
+nT();
 if (consumed(T.Colon))
 { // Identifier : AsmStatement
 s = new LabeledStatement(ident, parseAsmStatement());
 break;
 }
 case T.Align:
 // align Integer;
 nT();
 int number = -1;
 if (token.kind == T.Int32)
-(number = token.int_), nT();
+(number = token.int_), skip(T.Int32);
 else
 error(token, MSG.ExpectedIntegerAfterAlign, token.srcText);
 require(T.Semicolon);
 s = new AsmAlignStatement(number);
 break;
 case IDK.near, IDK.far,/* "byte",  "short",  "int",*/
 IDK.word, IDK.dword, IDK.qword/*, "float", "double", "real"*/:
 LAsmTypePrefix:
 nT();
 if (token.kind == T.Identifier && token.ident is Ident.ptr)
-nT();
+skip(T.Identifier);
 else
 error(MID.ExpectedButFound, "ptr", token.srcText);
 e = new AsmTypeExpression(parseAsmExpression());
 break;
 case IDK.offset:
 // (1) - (7)
 int number = -1;
 if (consumed(T.LParen))
 {
 if (token.kind == T.Int32)
-(number = token.int_), nT();
+(number = token.int_), skip(T.Int32);
 else
 expected(T.Int32);
 require(T.RParen);
 }
 e = new AsmRegisterExpression(register, number);
 int number = -1;
 if (consumed(T.Colon))
 {
 // :0, :4, :8
 if (token.kind == T.Int32)
-(number = token.int_), nT();
+(number = token.int_), skip(T.Int32);
 if (number != 0 && number != 4 && number != 8)
 error(MID.ExpectedButFound, "0, 4 or 8", token.srcText);
 }
 e = new AsmRegisterExpression(register, number);
 break;
 break;
 case T.LParen:
 // ( Type ) . Identifier
 Type parseType_()
 {
-nT();
+skip(T.LParen);
 auto type = parseType();
 require(T.RParen);
 require(T.Dot);
 return type;
 }
 auto ident = requireIdentifier(MSG.ExpectedAnIdentifier);
 Expression e;
 // Peek for '(' to avoid matching: id !is id
 if (token.kind == T.Not && peekNext() == T.LParen)
 { // Identifier !( TemplateArguments )
-nT(); // Skip !.
+skip(T.Not);
 auto tparams = parseTemplateArguments();
 e = new TemplateInstanceExpression(ident, tparams);
 }
 else // Identifier
 e = new IdentifierExpression(ident);
 auto funcBody = parseFunctionBody();
 e = new FunctionLiteralExpression(null, parameters, funcBody);
 }
 else
 { // ( Expression )
-nT();
+skip(T.LParen);
 e = parseExpression();
 require(T.RParen);
 e = new ParenExpression(e);
 }
 break;
 version(D2)
 {
 case T.Traits:
-nT();
+requireNext(T.LParen);
-require(T.LParen);
 auto id = requireIdentifier(MSG.ExpectedAnIdentifier);
 TemplateArguments args;
 if (token.kind == T.Comma)
 args = parseTemplateArguments2();
 else
 }
 Expression parseNewExpression(/*Expression e*/)
 {
 auto begin = token;
-assert(token.kind == T.New);
+skip(T.New);
-nT(); // Skip new keyword.
 Expression[] newArguments;
 Expression[] ctorArguments;
 if (token.kind == T.LParen)
 return t;
 version(D2)
 {
 case T.Const:
 // const ( Type )
-nT();
+requireNext(T.LParen);
-require(T.LParen);
 t = parseType();
 require(T.RParen);
 t = new ConstType(t);
 break;
 case T.Invariant:
 // invariant ( Type )
-nT();
+requireNext(T.LParen);
-require(T.LParen);
 t = parseType();
 require(T.RParen);
 t = new InvariantType(t);
 break;
 } // version(D2)
 return set(t, begin);
 }
 Type parseBasicType2(Type t)
 {
-typeof(token) begin;
 while (1)
 {
-begin = token;
+auto begin = token;
 switch (token.kind)
 {
 case T.Mul:
 t = new PointerType(t);
 nT();
 assert(0);
 }
 bool tokenAfterParenIs(TOK tok)
 {
-// We count nested parentheses tokens because template types may appear inside parameter lists; e.g. (int x, Foo!(int) y).
+// We count nested parentheses tokens because template types
+// may appear inside parameter lists. E.g.: (int x, Foo!(int) y)
 assert(token.kind == T.LParen);
 Token* next = token;
 uint level = 1;
 Loop:
 while (1)
 if (token.kind != T.LBracket)
 return lhsType; // Break recursion; return Type on the left hand side of the Identifier.
 auto begin = token;
 Type t;
-nT();
+skip(T.LBracket);
 if (consumed(T.RBracket))
 t = new ArrayType(parseNext()); // [ ]
 else
 {
 bool success;
 return parseNext();
 }
 Type parseArrayType(Type t)
 {
-assert(token.kind == T.LBracket);
+auto begin = token;
-auto begin = token;
+skip(T.LBracket);
-nT();
 if (consumed(T.RBracket))
 t = new ArrayType(t);
 else
 {
 bool success;
 return t;
 }
 Type parseCFunctionPointerType(Type type, ref Identifier* ident, bool optionalParamList)
 {
-assert(token.kind == T.LParen);
 assert(type !is null);
 auto begin = token;
-nT(); // Skip (
+skip(T.LParen);
 type = parseBasicType2(type);
 if (token.kind == T.LParen)
-{
+{ // Can be nested.
-// Can be nested.
 type = parseCFunctionPointerType(type, ident, true);
 }
 else if (token.kind == T.Identifier)
-{
+{ // The identifier of the function pointer and the declaration.
-// The identifier of the function pointer and the declaration.
 ident = token.ident;
 nT();
 type = parseDeclaratorSuffix(type);
 }
 require(T.RParen);
 ( )
 ( ExpressionList )
 +/
 Expression[] parseArguments()
 {
-assert(token.kind == T.LParen);
+skip(T.LParen);
-nT();
 Expression[] args;
-if (token.kind != TOK.RParen)
+if (token.kind != T.RParen)
 args = parseExpressionList();
-require(TOK.RParen);
+require(T.RParen);
 return args;
 }
 Parameters parseParameterList()
 out(params)
 version(D2)
 {
 TemplateArguments parseTemplateArguments2()
 {
-assert(token.kind == T.Comma);
+skip(T.Comma);
-nT();
 TemplateArguments targs;
 if (token.kind != T.RParen)
 targs = parseTemplateArguments_();
 else
 error(token, MSG.ExpectedTypeOrExpression);
 Type parseType_()
 {
 auto type = parseType();
 if (token.kind == T.Comma || token.kind == T.RParen)
 return type;
-++errorCount; // Cause try_() to fail.
+errorCount++; // Cause try_() to fail.
 return null;
 }
 bool success;
 auto typeArgument = try_(&parseType_, success);
 if (success)
 version(D2)
 {
 TemplateParameters parseTemplateParameterList2()
 {
-assert(token.kind == T.Comma);
+skip(T.Comma);
-nT();
 auto begin = token;
 auto tparams = new TemplateParameters;
 if (token.kind != T.RParen)
 parseTemplateParameterList_(tparams);
 else
 switch (token.kind)
 {
 case T.Alias:
 // TemplateAliasParameter:
 //         alias Identifier
-nT(); // Skip alias keyword.
+skip(T.Alias);
 ident = requireIdentifier(MSG.ExpectedAliasTemplateParam);
 parseSpecAndOrDefaultType();
 tp = new TemplateAliasParameter(ident, specType, defType);
 break;
 case T.Identifier:
 switch (peekNext())
 {
 case T.Ellipses:
 // TemplateTupleParameter:
 //         Identifier ...
-nT(); // Skip Identifier.
+skip(T.Identifier); skip(T.Ellipses);
-nT(); // Skip Ellipses.
 if (token.kind == T.Comma)
 error(MID.TemplateTupleParameter);
 tp = new TemplateTupleParameter(ident);
 break;
 case T.Comma, T.RParen, T.Colon, T.Assign:
 // TemplateTypeParameter:
 //         Identifier
-nT(); // Skip Identifier.
+skip(T.Identifier);
 parseSpecAndOrDefaultType();
 tp = new TemplateTypeParameter(ident, specType, defType);
 break;
 default:
 // TemplateValueParameter:
 version(D2)
 {
 case T.This:
 // TemplateThisParameter
 //         this TemplateTypeParameter
-nT(); // Skip 'this' keyword.
+skip(T.This);
 ident = requireIdentifier(MSG.ExpectedNameForThisTempParam);
 parseSpecAndOrDefaultType();
 tp = new TemplateThisParameter(ident, specType, defType);
 break;
 }
 Identifier* optionalIdentifier()
 {
 Identifier* id;
 if (token.kind == T.Identifier)
-(id = token.ident), nT();
+(id = token.ident), skip(T.Identifier);
 return id;
 }
 Identifier* requireIdentifier()
 {
 Identifier* id;
 if (token.kind == T.Identifier)
-(id = token.ident), nT();
+(id = token.ident), skip(T.Identifier);
 else
 error(MID.ExpectedButFound, "Identifier", token.srcText);
 return id;
 }
-/++
+/// Params:
-Params:
+///   errorMsg = an error that has no message ID yet.
-errorMsg = an error that has no message ID yet.
-+/
 Identifier* requireIdentifier(char[] errorMsg)
 {
 Identifier* id;
 if (token.kind == T.Identifier)
-(id = token.ident), nT();
+(id = token.ident), skip(T.Identifier);
 else
 error(token, errorMsg, token.srcText);
 return id;
 }
 Identifier* requireIdentifier(MID mid)
 {
 Identifier* id;
 if (token.kind == T.Identifier)
-(id = token.ident), nT();
+(id = token.ident), skip(T.Identifier);
 else
 error(mid, token.srcText);
 return id;
 }
 Token* requireIdToken(char[] errorMsg)
 {
 Token* idtok;
 if (token.kind == T.Identifier)
-(idtok = token), nT();
+(idtok = token), skip(T.Identifier);
 else
 error(token, errorMsg, token.srcText);
 return idtok;
 }

Mercurial > projects > dil

comparison trunk/src/dil/parser/Parser.d @ 774:846044180d22