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

comparison trunk/src/dil/Parser.d @ 505:3bb94ba21490

Refactored a great amount of code. Changed many declaration types from Token* to Identifier*. Fix in parseStructInitializer(): append null to idents in else body. Fixed class Parameter and parseParameterList().

author	Aziz K?ksal <aziz.koeksal@gmail.com>
date	Wed, 12 Dec 2007 02:25:42 +0100
parents	9076c4cea2a4
children	996041463028

comparison

equal deleted inserted replaced

-:9076c4cea2a4
+:3bb94ba21490
 auto begin = token;
 ModuleFQN moduleFQN;
 do
 {
 nT();
-moduleFQN ~= requireIdentifier("expected module identifier, not '{}'");
+moduleFQN ~= requireIdentifier(MSG.ExpectedModuleIdentifier);
 } while (token.type == T.Dot)
 require(T.Semicolon);
 return set(new ModuleDeclaration(moduleFQN), begin);
 }
 nT();
 while (!token.isDeclDefStart &&
 token.type != T.RBrace &&
 token.type != T.EOF)
 auto text = Token.textSpan(begin, this.prevToken);
-error(begin, "illegal Declaration found: " ~ text);
+error(begin, MSG.IllegalDeclaration ~ text);
 }
 decl.setProtection(this.protection);
 decl.setStorageClass(this.storageClass);
 assert(!isNodeSet(decl));
 set(decl, begin);
 bool testAutoDeclaration = false,
 bool optionalParameterList = true)
 {
 auto begin = token;
 Type type;
-Token* ident;
+Identifier* ident;
 // Check for AutoDeclaration: StorageClasses Identifier =
 if (testAutoDeclaration &&
 token.type == T.Identifier &&
 peekNext() == T.Assign)
 {
-ident = token;
+ident = token.ident;
 nT();
 }
 else
 {
 type = parseType();
 //   something(*p);
 type = parseCFunctionPointerType(type, ident, optionalParameterList);
 }
 else
 {
-ident = requireId();
+ident = requireIdentifier(MSG.ExpectedFunctionName);
 // Type FunctionName ( ParameterList ) FunctionBody
 if (token.type == T.LParen)
 {
 // It's a function declaration
 TemplateParameters tparams;
 type = parseDeclaratorSuffix(type);
 }
 }
 // It's a variable declaration.
-Token*[] idents = [ident];
+Identifier*[] idents = [ident];
 Expression[] values;
 goto LenterLoop; // We've already parsed an identifier. Jump to if statement and check for initializer.
 while (token.type == T.Comma)
 {
 nT();
-idents ~= requireId();
+idents ~= requireIdentifier(MSG.ExpectedVariableName);
 LenterLoop:
 if (token.type == T.Assign)
 nT(), (values ~= parseInitializer());
 else
 values ~= null;
 // StructInitializer:
 //         { }
 //         { StructMemberInitializers }
 Expression parseStructInitializer()
 {
-Token*[] idents;
+Identifier*[] idents;
 Expression[] values;
 nT();
 while (token.type != T.RBrace)
 {
-if (token.type == T.Identifier)
+if (token.type == T.Identifier &&
+// Peek for colon to see if this is a member identifier.
+peekNext() == T.Colon)
 {
-// Peek for colon to see if this is a member identifier.
+idents ~= token.ident;
-if (peekNext() == T.Colon)
+nT(), nT(); // Skip Identifier :
-{
-idents ~= token;
-nT();
-nT();
-}
 }
+else
+idents ~= null;
 // NonVoidInitializer
 values ~= parseNonVoidInitializer();
 if (token.type != T.Comma)
 break;
 error(MID.OutContract);
 nT();
 if (token.type == T.LParen)
 {
 nT();
-func.outIdent = requireId();
+func.outIdent = requireIdentifier(MSG.ExpectedAnIdentifier);
 require(T.RParen);
 }
 func.outBody = parseStatements();
 continue;
 case T.Body:
 nT();
 goto case T.LBrace;
 default:
-error(MID.ExpectedButFound, "FunctionBody", token.srcText);
+error(token, MSG.ExpectedFunctionBody, token.srcText);
 }
 break; // Exit loop.
 }
 set(func, begin);
 func.finishConstruction();
 {
 if (prev_lt == LinkageType.None)
 prev_lt = lt;
 else
 // TODO: create new msg RedundantLinkageType.
-error(begin, "redundant linkage type: " ~ Token.textSpan(begin, this.prevToken));
+error(begin, MSG.RedundantLinkageType ~ Token.textSpan(begin, this.prevToken));
 }
 Declaration parseStorageAttribute()
 {
 StorageClass stc, stc_tmp;
 case T.Pragma:
 // Pragma:
 //     pragma ( Identifier )
 //     pragma ( Identifier , ExpressionList )
 nT();
-Token* ident;
+Identifier* ident;
 Expression[] args;
-Declaration decls;
 require(T.LParen);
-ident = requireId();
+ident = requireIdentifier(MSG.ExpectedPragmaIdentifier);
 if (token.type == T.Comma)
-{
+nT(), (args = parseExpressionList());
-nT();
-args = parseExpressionList();
-}
 require(T.RParen);
-if (token.type == T.Semicolon)
+decl = new PragmaDeclaration(ident, args, parseDeclarationsBlock());
-{
-nT();
-// TODO: call set()?
-decls = new EmptyDeclaration();
-}
-else
-decls = parseDeclarationsBlock();
-decl = new PragmaDeclaration(ident, args, decls);
 break;
 default:
 // Protection attributes
 Protection prot;
 switch (token.type)
 Identifier* moduleAlias;
 // AliasName = ModuleName
 if (peekNext() == T.Assign)
 {
-moduleAlias = requireIdentifier("expected alias module name, not '{}'");
+moduleAlias = requireIdentifier(MSG.ExpectedAliasModuleName);
 nT(); // Skip =
 }
 // Identifier(.Identifier)*
 while (1)
 {
-moduleFQN ~= requireIdentifier("expected module identifier, not '{}'");
+moduleFQN ~= requireIdentifier(MSG.ExpectedModuleIdentifier);
 if (token.type != T.Dot)
 break;
 nT();
 }
 nT();
 Identifier* bindAlias;
 // BindAlias = BindName
 if (peekNext() == T.Assign)
 {
-bindAlias = requireIdentifier("expected alias name, not '{}'");
+bindAlias = requireIdentifier(MSG.ExpectedAliasImportName);
 nT(); // Skip =
 }
 // Push identifiers.
-bindNames ~= requireIdentifier("expected an identifier, not '{}'");
+bindNames ~= requireIdentifier(MSG.ExpectedImportName);
 bindAliases ~= bindAlias;
 } while (token.type == T.Comma)
 }
 require(T.Semicolon);
 Declaration parseEnumDeclaration()
 {
 assert(token.type == T.Enum);
-Token* enumName;
+Identifier* enumName;
 Type baseType;
 EnumMember[] members;
 bool hasBody;
 nT(); // Skip enum keyword.
-if (token.type == T.Identifier)
+enumName = optionalIdentifier();
-{
-enumName = token;
-nT();
-}
 if (token.type == T.Colon)
 {
 nT();
 baseType = parseBasicType();
 hasBody = true;
 nT(); // Skip {
 while (token.type != T.RBrace)
 {
 auto begin = token;
-auto memberName = requireId();
+auto name = requireIdentifier(MSG.ExpectedEnumMember);
 Expression value;
 if (token.type == T.Assign)
-{
+nT(), (value = parseAssignExpression());
-nT();
-value = parseAssignExpression();
-}
 else
 value = null;
-members ~= set(new EnumMember(memberName, value), begin);
+members ~= set(new EnumMember(name, value), begin);
 if (token.type != T.Comma)
 break;
 nT(); // Skip ,
 }
 require(T.RBrace);
 }
 else
-error(MID.ExpectedButFound, "enum declaration", token.srcText);
+error(token, MSG.ExpectedEnumBody, token.srcText);
 return new EnumDeclaration(enumName, baseType, members, hasBody);
 }
 Declaration parseClassDeclaration()
 {
 assert(token.type == T.Class);
-Token* className;
+Identifier* className;
 TemplateParameters tparams;
 BaseClass[] bases;
 Declarations decls;
 nT(); // Skip class keyword.
-className = requireId();
+className = requireIdentifier(MSG.ExpectedClassName);
 if (token.type == T.LParen)
 tparams = parseTemplateParameterList();
 if (token.type == T.Colon)
 nT();
 }
 else if (token.type == T.LBrace)
 decls = parseDeclarationDefinitionsBody();
 else
-expected(T.LBrace); // TODO: better error msg
+error(token, MSG.ExpectedClassBody, token.srcText);
 return new ClassDeclaration(className, tparams, bases, decls);
 }
 BaseClass[] parseBaseClasses(bool colonLeadsOff = true)
 Declaration parseInterfaceDeclaration()
 {
 assert(token.type == T.Interface);
-Token* name;
+Identifier* name;
 TemplateParameters tparams;
 BaseClass[] bases;
 Declarations decls;
 nT(); // Skip interface keyword.
-name = requireId();
+name = requireIdentifier(MSG.ExpectedInterfaceName);
 if (token.type == T.LParen)
 tparams = parseTemplateParameterList();
 if (token.type == T.Colon)
 if (token.type == T.Semicolon)
 {
 if (bases.length != 0)
 error(MID.BaseClassInForwardDeclaration);
+nT();
+}
+else if (token.type == T.LBrace)
+decls = parseDeclarationDefinitionsBody();
+else
+error(token, MSG.ExpectedInterfaceBody, token.srcText);
+return new InterfaceDeclaration(name, tparams, bases, decls);
+}
+Declaration parseAggregateDeclaration()
+{
+assert(token.type == T.Struct || token.type == T.Union);
+TOK tok = token.type;
+Identifier* name;
+TemplateParameters tparams;
+Declarations decls;
+nT(); // Skip struct or union keyword.
+name = optionalIdentifier();
+if (name && token.type == T.LParen)
+tparams = parseTemplateParameterList();
+if (token.type == T.Semicolon)
+{
+//if (name.length == 0)
+// TODO: error: forward declarations must have a name.
 nT();
 }
 else if (token.type == T.LBrace)
 decls = parseDeclarationDefinitionsBody();
 else
 expected(T.LBrace); // TODO: better error msg
-return new InterfaceDeclaration(name, tparams, bases, decls);
-}
-Declaration parseAggregateDeclaration()
-{
-assert(token.type == T.Struct || token.type == T.Union);
-TOK tok = token.type;
-Token* name;
-TemplateParameters tparams;
-Declarations decls;
-nT(); // Skip struct or union keyword.
-// name is optional.
-if (token.type == T.Identifier)
-{
-name = token;
-nT();
-if (token.type == T.LParen)
-tparams = parseTemplateParameterList();
-}
-if (token.type == T.Semicolon)
-{
-//if (name.length == 0)
-// TODO: error: forward declarations must have a name.
-nT();
-}
-else if (token.type == T.LBrace)
-decls = parseDeclarationDefinitionsBody();
-else
-expected(T.LBrace); // TODO: better error msg
 if (tok == T.Struct)
 {
-auto d = new StructDeclaration(name, tparams, decls);
+auto sd = new StructDeclaration(name, tparams, decls);
-d.setAlignSize(this.alignSize);
+sd.setAlignSize(this.alignSize);
-return d;
+return sd;
 }
 else
 return new UnionDeclaration(name, tparams, decls);
 }
 Declaration parseTemplateDeclaration()
 {
 assert(token.type == T.Template);
 nT(); // Skip template keyword.
-auto templateName = requireId();
+auto templateName = requireIdentifier(MSG.ExpectedTemplateName);
 auto templateParams = parseTemplateParameterList();
 auto decls = parseDeclarationDefinitionsBody();
 return new TemplateDeclaration(templateName, templateParams, decls);
 }
 }
 while (1)
 {
 begin = token;
-auto ident = requireId();
+auto ident = requireIdentifier(MSG.ExpectedAnIdentifier);
 Expression e;
 if (token.type == T.Not && peekNext() == T.LParen) // Identifier !( TemplateArguments )
 {
 nT(); // Skip !.
-e = set(new TemplateInstanceExpression(ident, parseTemplateArguments()), begin);
+auto tparams = parseTemplateArguments();
+e = new TemplateInstanceExpression(ident, tparams);
 }
 else // Identifier
-e = set(new IdentifierExpression(ident), begin);
+e = new IdentifierExpression(ident);
-identList ~= e;
+identList ~= set(e, begin);
 LnewExpressionLoop:
 if (token.type != T.Dot)
 break;
 nT(); // Skip dot.
 }
 while (1)
 {
 begin = token;
-auto ident = requireId();
+auto ident = requireIdentifier(MSG.ExpectedAnIdentifier);
+Type t;
 // NB.: Currently Types can't be followed by "!=" so we don't need to peek for "(" when parsing TemplateInstances.
 if (token.type == T.Not/+ && peekNext() == T.LParen+/) // Identifier !( TemplateArguments )
 {
 nT(); // Skip !.
-identList ~= set(new TemplateInstanceType(ident, parseTemplateArguments()), begin);
+t = new TemplateInstanceType(ident, parseTemplateArguments());
 }
 else // Identifier
-identList ~= set(new IdentifierType(ident), begin);
+t = new IdentifierType(ident);
+identList ~= set(t, begin);
 if (token.type != T.Dot)
 break;
 nT();
 }
 mixin TemplateIdentifier !( TemplateArguments ) MixinIdentifier ;
 */
 Class parseMixin(Class)()
 {
 assert(token.type == T.Mixin);
-auto begin = token;
 nT(); // Skip mixin keyword.
 static if (is(Class == MixinDeclaration))
 {
 if (token.type == T.LParen)
 require(T.Semicolon);
 return new MixinDeclaration(e);
 }
 }
+auto begin = token;
 Expression[] templateIdent;
-Token* mixinIdent;
+Identifier* mixinIdent;
 // This code is similar to parseDotListType().
 if (token.type == T.Dot)
 {
 nT();
 }
 while (1)
 {
 begin = token;
-auto ident = requireId();
+auto ident = requireIdentifier(MSG.ExpectedAnIdentifier);
 Expression e;
 if (token.type == T.Not) // Identifier !( TemplateArguments )
 {
 // No need to peek for T.LParen. This must be a template instance.
 nT();
-e = set(new TemplateInstanceExpression(ident, parseTemplateArguments()), begin);
+auto tparams = parseTemplateArguments();
+e = new TemplateInstanceExpression(ident, tparams);
 }
 else // Identifier
-e = set(new IdentifierExpression(ident), begin);
+e = new IdentifierExpression(ident);
-templateIdent ~= e;
+templateIdent ~= set(e, begin);
 if (token.type != T.Dot)
 break;
 nT();
 }
-if (token.type == T.Identifier)
+mixinIdent = optionalIdentifier();
-{
-mixinIdent = token;
-nT();
-}
 require(T.Semicolon);
 return new Class(templateIdent, mixinIdent);
 }
 s = parseAttributeStatement();
 return s;
 case T.Identifier:
 if (peekNext() == T.Colon)
 {
-auto ident = token;
+auto ident = token.ident;
-nT(); // Skip Identifier
+nT(), nT(); // Skip Identifier :
-nT(); // Skip :
 s = new LabeledStatement(ident, parseNoScopeOrEmptyStatement());
 break;
 }
 goto case T.Dot;
 case T.Dot, T.Typeof:
 nT();
 while (!token.isStatementStart &&
 token.type != T.RBrace &&
 token.type != T.EOF)
 auto text = Token.textSpan(begin, this.prevToken);
-error(begin, "illegal Statement found: " ~ text);
+error(begin, MSG.IllegalStatement ~ text);
 }
 assert(s !is null);
 set(s, begin);
 return s;
 }
 require(T.RBrace);
 s = set(ss, begin);
 }
 else if (token.type == T.Semicolon)
 {
-error(MID.ExpectedButFound, "non-empty statement", ";");
+error(token, MSG.ExpectedNonEmptyStatement);
 nT();
 s = set(new EmptyStatement(), begin);
 }
 else
 s = parseStatement();
 Expression condition;
 Statement ifBody, elseBody;
 require(T.LParen);
-Token* ident;
+Identifier* ident;
 auto begin = token; // For start of AutoDeclaration or normal Declaration.
 // auto Identifier = Expression
 if (token.type == T.Auto)
 {
 nT();
-ident = requireId();
+ident = requireIdentifier(MSG.ExpectedVariableName);
 require(T.Assign);
 auto init = parseExpression();
 auto v = new VariableDeclaration(null, [ident], [init]);
-set(v, ident);
+set(v, begin.nextNWS);
 auto d = new StorageClassDeclaration(StorageClass.Auto, T.Auto, v);
 set(d, begin);
 variable = new DeclarationStatement(d);
 set(variable, begin);
 }
 require(T.LParen);
 while (1)
 {
 auto paramBegin = token;
-Token* stcTok;
+StorageClass stc;
 Type type;
-Token* ident;
+Identifier* ident;
 switch (token.type)
 {
 case T.Ref, T.Inout:
-stcTok = token;
+stc = StorageClass.Ref;
 nT();
 // fall through
 case T.Identifier:
 auto next = peekNext();
 if (next == T.Comma || next == T.Semicolon || next == T.RParen)
 {
-ident = token;
+ident = requireIdentifier(MSG.ExpectedVariableName);
 nT();
 break;
 }
 // fall through
 default:
 type = parseDeclarator(ident);
 }
-params ~= set(new Parameter(stcTok, type, ident, null), paramBegin);
+params ~= set(new Parameter(stc, type, ident, null), paramBegin);
 if (token.type != T.Comma)
 break;
 nT();
 }
 Statement parseContinueStatement()
 {
 assert(token.type == T.Continue);
 nT();
-Token* ident;
+auto ident = optionalIdentifier();
-if (token.type == T.Identifier)
-{
-ident = token;
-nT();
-}
 require(T.Semicolon);
 return new ContinueStatement(ident);
 }
 Statement parseBreakStatement()
 {
 assert(token.type == T.Break);
 nT();
-Token* ident;
+auto ident = optionalIdentifier();
-if (token.type == T.Identifier)
-{
-ident = token;
-nT();
-}
-require(T.Semicolon);
 return new BreakStatement(ident);
 }
 Statement parseReturnStatement()
 {
 Statement parseGotoStatement()
 {
 assert(token.type == T.Goto);
 nT();
-Token* ident;
+Identifier* ident;
 Expression caseExpr;
 switch (token.type)
 {
 case T.Case:
 nT();
 break;
 case T.Default:
 nT();
 break;
 default:
-ident = requireId();
+ident = requireIdentifier(MSG.ExpectedAnIdentifier);
 }
 require(T.Semicolon);
 return new GotoStatement(ident, caseExpr);
 }
 Parameter param;
 if (token.type == T.LParen)
 {
 nT();
 auto begin = token;
-Token* ident;
+Identifier* ident;
 auto type = parseDeclarator(ident, true);
-param = new Parameter(null, type, ident, null);
+param = new Parameter(StorageClass.None, type, ident, null);
 set(param, begin);
 require(T.RParen);
 }
 catchBodies ~= new CatchBody(param, parseNoScopeStatement());
 if (param is null)
 {
 assert(token.type == T.Scope);
 nT();
 assert(token.type == T.LParen);
 nT();
+auto condition = requireIdentifier(MSG.ExpectedScopeIdentifier);
-Token* condition = requireId();
 if (condition)
-switch (condition.ident.identID)
+switch (condition.identID)
 {
 case ID.exit, ID.success, ID.failure:
 break;
 default:
 // TODO: create MID.InvalidScopeIdentifier
-error(condition, "'exit', 'success', 'failure' are valid scope identifiers, but not '{}';", condition.srcText);
+error(this.prevToken, MSG.InvalidScopeIdentifier, this.prevToken.srcText);
 }
 require(T.RParen);
 Statement scopeBody;
 if (token.type == T.LBrace)
 scopeBody = parseScopeStatement();
 Statement parsePragmaStatement()
 {
 assert(token.type == T.Pragma);
 nT();
-Token* ident;
+Identifier* ident;
 Expression[] args;
 Statement pragmaBody;
 require(T.LParen);
-ident = requireId();
+ident = requireIdentifier(MSG.ExpectedPragmaIdentifier);
 if (token.type == T.Comma)
 {
 nT();
 args = parseExpressionList();
 Statement parseAsmInstruction()
 {
 auto begin = token;
 Statement s;
-typeof(token) ident;
+Identifier* ident;
 switch (token.type)
 {
 // Keywords that are valid opcodes.
 case T.In, T.Int, T.Out:
-ident = token;
+ident = token.ident;
 nT();
 goto LOpcode;
 case T.Identifier:
-ident = token;
+ident = token.ident;
 nT(); // Skip Identifier
 if (token.type == T.Colon)
 {
 // Identifier : AsmInstruction
 nT(); // Skip :
 }
 require(T.Semicolon);
 s = new AsmInstruction(ident, es);
 break;
 case T.Align:
-nT();
+// align Integer;
-auto number = token;
+nT();
-switch (token.type)
+int number = -1;
-{
+if (token.type == T.Int32)
-case T.Int32, T.Int64, T.Uint32, T.Uint64:
+(number = token.int_), nT();
-number = token; nT(); break;
+else
-default:
+error(token, MSG.ExpectedIntegerAfterAlign, token.srcText);
-if (token.type != T.Semicolon)
-nT();
-number = null;
-// TODO: report error: number expected after asm align statement.
-error(token, "expected an integer after align, not '{}'", token.srcText);
-}
 require(T.Semicolon);
 s = new AsmAlignStatement(number);
 break;
 case T.Semicolon:
 s = new EmptyStatement();
 nT();
 while (!token.isAsmInstructionStart &&
 token.type != T.RBrace &&
 token.type != T.EOF)
 auto text = Token.textSpan(begin, this.prevToken);
-error(begin, "illegal AsmInstruction found: " ~ text);
+error(begin, MSG.IllegalAsmInstructino ~ text);
 }
 set(s, begin);
 return s;
 }
 // DotIdentifier
 Expression[] identList;
 while (1)
 {
 auto begin2 = token;
-auto ident = requireId();
+auto ident = requireIdentifier(MSG.ExpectedAnIdentifier);
 e = new IdentifierExpression(ident);
 set(e, begin2);
 identList ~= e;
 if (token.type != T.Dot)
 break;
 }
 bool success;
 auto type = try_(&parseType_, success);
 if (success)
 {
-auto ident = requireId();
+auto ident = requireIdentifier(MSG.ExpectedIdAfterTypeDot);
 e = new TypeDotIdExpression(type, ident);
 break;
 }
 goto default;
 default:
 break;
 case T.Is:
 requireNext(T.LParen);
 Type type, specType;
-Token* ident; // optional Identifier
+Identifier* ident; // optional Identifier
 Token* opTok, specTok;
 type = parseDeclarator(ident, true);
 switch (token.type)
 T.Cfloat, T.Cdouble, T.Creal, T.Void:
 auto type = new IntegralType(token.type);
 nT();
 set(type, begin);
 require(T.Dot);
-auto ident = requireId();
+auto ident = requireIdentifier(MSG.ExpectedIdAfterTypeDot);
 e = new TypeDotIdExpression(type, ident);
 break;
 version(D2)
 {
 case T.Traits:
 nT();
 require(T.LParen);
-auto id = requireId();
+auto id = requireIdentifier(MSG.ExpectedAnIdentifier);
 TemplateArguments args;
 if (token.type == T.Comma)
 args = parseTemplateArguments2();
 else
 require(T.RParen);
 }
 set(t, begin);
 return t;
 }
-Type parseCFunctionPointerType(Type type, ref Token* ident, bool optionalParamList)
+Type parseCFunctionPointerType(Type type, ref Identifier* ident, bool optionalParamList)
 {
 assert(token.type == T.LParen);
 assert(type !is null);
 auto begin = token;
 nT(); // Skip (
 type = parseCFunctionPointerType(type, ident, true);
 }
 else if (token.type == T.Identifier)
 {
 // The identifier of the function pointer and the declaration.
-ident = token;
+ident = token.ident;
 nT();
 type = parseDeclaratorSuffix(type);
 }
 require(T.RParen);
 type = set(new CFuncPointerType(type, params), begin);
 return type;
 }
-Type parseDeclarator(ref Token* ident, bool identOptional = false)
+Type parseDeclarator(ref Identifier* ident, bool identOptional = false)
 {
 auto t = parseType();
 if (token.type == T.LParen)
 {
 t = parseCFunctionPointerType(t, ident, true);
 }
 else if (token.type == T.Identifier)
 {
-ident = token;
+ident = token.ident;
 nT();
 t = parseDeclaratorSuffix(t);
 }
 if (ident is null && !identOptional)
-expected(T.Identifier);
+error(token, MSG.ExpectedDeclaratorIdentifier, token.srcText);
 return t;
 }
 /++
 {
 nT();
 return set(params, begin);
 }
+Loop:
 while (1)
 {
 auto paramBegin = token;
-Token* stcTok;
 StorageClass stc, tmp;
+Type type;
+Identifier* ident;
+Expression defValue;
+void pushParameter()
+{
+params ~= set(new Parameter(stc, type, ident, defValue), paramBegin);
+}
 if (token.type == T.Ellipses)
 {
 nT();
-params ~= set(new Parameter(null, null, null, null), paramBegin);
+stc = StorageClass.Variadic;
-break; // Exit loop.
+pushParameter(); // type, ident and defValue will be null.
+break Loop;
 }
 Lstc_loop:
 switch (token.type)
 {
 version(D2)
 {
 case T.Invariant: // D2.0
 if (peekNext() == T.LParen)
 goto default;
 tmp = StorageClass.Invariant;
 goto Lcommon;
 tmp = StorageClass.Scope;
 goto Lcommon;
 case T.Static: // D2.0
 tmp = StorageClass.Static;
 goto Lcommon;
+}
 case T.In:
 tmp = StorageClass.In;
 goto Lcommon;
 case T.Out:
 tmp = StorageClass.Out;
 goto Lcommon;
 case T.Lazy:
 tmp = StorageClass.Lazy;
 goto Lcommon;
 Lcommon:
+// Check for redundancy.
 if (stc & tmp)
 error(MID.RedundantStorageClass, token.srcText);
 else
 stc |= tmp;
 nT();
+version(D2)
 goto Lstc_loop;
-}
+else
-else // else body of version(D2)
+goto default; // In D1.0 only one stc per parameter is allowed.
-{
-case T.In, T.Out, T.Inout, T.Ref, T.Lazy:
-stcTok = token;
-nT();
-goto default;
-}
 default:
-version(D2)
+type = parseDeclarator(ident, true);
-{
-if (stc != StorageClass.None)
-stcTok = begin;
-}
-Token* ident;
-auto type = parseDeclarator(ident, true);
-Expression assignExpr;
 if (token.type == T.Assign)
+nT(), (defValue = parseAssignExpression());
+if (token.type == T.Ellipses)
 {
 nT();
-assignExpr = parseAssignExpression();
+stc |= StorageClass.Variadic;
+pushParameter();
+break Loop;
 }
-if (token.type == T.Ellipses)
+pushParameter();
-{
-auto p = set(new Parameter(stcTok, type, ident, assignExpr), paramBegin);
-p.stc |= StorageClass.Variadic;
-params ~= p;
-nT();
-break; // Exit loop.
-}
-params ~= set(new Parameter(stcTok, type, ident, assignExpr), paramBegin);
 if (token.type != T.Comma)
-break; // Exit loop.
+break Loop;
 nT();
-continue;
+}
-}
-break; // Exit loop.
 }
 require(T.RParen);
 return set(params, begin);
 }
 TemplateArguments parseTemplateArguments()
 {
 TemplateArguments targs;
 require(T.LParen);
 if (token.type != T.RParen)
 targs = parseTemplateArguments_();
 require(T.RParen);
 return targs;
 }
 version(D2)
 nT();
 TemplateArguments targs;
 if (token.type != T.RParen)
 targs = parseTemplateArguments_();
 else
-error(MID.ExpectedButFound, "Type/Expression", ")");
+error(token, MSG.ExpectedTypeOrExpression);
 require(T.RParen);
 return targs;
 }
 } // version(D2)
 nT();
 TemplateParameters tparams;
 if (token.type != T.RParen)
 tparams = parseTemplateParameterList_();
 else
-error(MID.ExpectedButFound, "Type/Expression", ")");
+error(token, MSG.ExpectedTemplateParameters);
 return tparams;
 }
 } // version(D2)
 TemplateParameters parseTemplateParameterList_()
 while (1)
 {
 auto paramBegin = token;
 TemplateParameter tp;
-Token* ident;
+Identifier* ident;
 Type specType, defType;
 void parseSpecAndOrDefaultType()
 {
 // : SpecializationType
 {
 case T.Alias:
 // TemplateAliasParameter:
 //         alias Identifier
 nT(); // Skip alias keyword.
-ident = requireId();
+ident = requireIdentifier(MSG.ExpectedAliasTemplateParam);
 parseSpecAndOrDefaultType();
 tp = new TemplateAliasParameter(ident, specType, defType);
 break;
 case T.Identifier:
-ident = token;
+ident = token.ident;
 switch (peekNext())
 {
 case T.Ellipses:
 // TemplateTupleParameter:
 //         Identifier ...
 {
 case T.This:
 // TemplateThisParameter
 //         this TemplateTypeParameter
 nT(); // Skip 'this' keyword.
-ident = requireId();
+ident = requireIdentifier(MSG.ExpectedNameForThisTempParam);
 parseSpecAndOrDefaultType();
 tp = new TemplateThisParameter(ident, specType, defType);
 break;
 }
 default:
 {
 nT();
 require(tok);
 }
+Identifier* optionalIdentifier()
+{
+Identifier* id;
+if (token.type == T.Identifier)
+(id = token.ident), nT();
+return id;
+}
 Identifier* requireIdentifier()
 {
 Identifier* id;
 if (token.type == T.Identifier)
 (id = token.ident), nT();
 else
 error(MID.ExpectedButFound, "Identifier", token.srcText);
 return null;
 }
+Token* requireIdToken(char[] errorMsg)
+{
+Token* idtok;
+if (token.type == T.Identifier)
+(idtok = token), nT();
+else
+error(token, errorMsg, token.srcText);
+return idtok;
+}
 /// Reports an error that has no message ID yet.
 void error(Token* token, char[] formatMsg, ...)
 {
 error_(token, MID.min, formatMsg, _arguments, _argptr);
 }
 }
 auto location = token.getLocation();
 auto msg = Format(_arguments, _argptr, formatMsg);
 errors ~= new Information(InfoType.Parser, mid, location, msg);
 }
+/// Collection of error messages with no MID yet.
+private struct MSG
+{
+static:
+auto ExpectedIdAfterTypeDot = "expected identifier after '(Type).', not '{}'";
+auto ExpectedModuleIdentifier = "expected module identifier, not '{}'";
+auto IllegalDeclaration = "illegal Declaration found: {}";
+auto ExpectedFunctionName = "expected function name, not '{}'";
+auto ExpectedVariableName = "expected variable name, not '{}'";
+auto ExpectedFunctionBody = "expected function body, not '{}'";
+auto RedundantLinkageType = "redundant linkage type: ";
+auto ExpectedPragmaIdentifier = "expected pragma identifier, not '{}'";
+auto ExpectedAliasModuleName = "expected alias module name, not '{}'";
+auto ExpectedAliasImportName = "expected alias name, not '{}'";
+auto ExpectedImportName = "expected an identifier, not '{}'";
+auto ExpectedEnumMember = "expected enum member, not '{}'";
+auto ExpectedEnumBody = "expected enum body, not '{}'";
+auto ExpectedClassName = "expected class name, not '{}'";
+auto ExpectedClassBody = "expected class body, not '{}'";
+auto ExpectedInterfaceName = "expected interface name, not '{}'";
+auto ExpectedInterfaceBody = "expected interface body, not '{}'";
+auto ExpectedTemplateName = "expected template name, not '{}'";
+auto ExpectedAnIdentifier = "expected an identifier, not '{}'";
+auto IllegalStatement = "illegal Statement found: ";
+auto ExpectedNonEmptyStatement = "didn't expect ';', use { } instead";
+auto ExpectedScopeIdentifier = "expected 'exit', 'success' or 'failure', not '{}'";
+auto InvalidScopeIdentifier = "'exit', 'success', 'failure' are valid scope identifiers, but not '{}';";
+auto ExpectedIntegerAfterAlign = "expected an integer after align, not '{}'";
+auto IllegalAsmInstructino = "illegal AsmInstruction found: ";
+auto ExpectedDeclaratorIdentifier = "expected declarator identifier, not '{}'";
+auto ExpectedTemplateParameters = "expected one or more template parameters not ')'";
+auto ExpectedTypeOrExpression = "expected a type or and expression not ')'";
+auto ExpectedAliasTemplateParam = "expected name for alias template parameter, not '{}'";
+auto ExpectedNameForThisTempParam = "expected name for 'this' template parameter, not '{}'";
+}
 }

Mercurial > projects > dil

comparison trunk/src/dil/Parser.d @ 505:3bb94ba21490