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

comparison trunk/src/dil/Parser.d @ 486:bd176bc73e43

Fixed a few things in the Parser. Refactored some code that used parseArguments() to using parseExpressionList(). Added calls to set() and tidied up the code of the Parser a bit. Fixed parsing DotIdentifier in parseAsmPrimaryExpression(). Added charLiteral member to class CharExpression. Added class InformationManager. Added member infoMan to class Scope.

author	Aziz K?ksal <aziz.koeksal@gmail.com>
date	Sat, 01 Dec 2007 18:22:56 +0100
parents	ea8c7459f1c4
children	cfb3805768b6

comparison

equal deleted inserted replaced

-:ea8c7459f1c4
+:bd176bc73e43
 /++
 DeclDefs:
 DeclDef
 DeclDefs
 +/
-Declarations parseDeclarationDefinitions()
+Declaration[] parseDeclarationDefinitions()
 {
-auto decls = new Declarations;
+Declaration[] decls;
 while (token.type != T.EOF)
 decls ~= parseDeclarationDefinition();
 return decls;
 }
 require(T.LParen);
 ident = requireId();
 if (token.type == T.Comma)
 {
-// Parse at least one argument.
+nT();
-nT();
+args = parseExpressionList();
-args ~= parseAssignExpression();
+}
-}
+require(T.RParen);
-if (token.type == T.Comma)
-args ~= parseArguments(T.RParen);
-else
-require(T.RParen);
 if (token.type == T.Semicolon)
 {
 nT();
 // TODO: call set()?
 error(MID.ExpectedBaseClasses, token.srcText);
 return bases;
 }
 nT(); // Skip protection attribute.
 LparseBasicType:
+auto begin = token;
 auto type = parseBasicType();
 //if (type.tid != TID.DotList)
 // TODO: issue error msg. base classes can only be one or more identifiers or template instances separated by dots.
-bases ~= new BaseClass(prot, type);
+bases ~= set(new BaseClass(prot, type), begin);
 if (token.type != T.Comma)
 break;
 nT();
 }
 return bases;
 Identifier !( TemplateArguments )
 +/
 DotListExpression parseDotListExpression()
 {
 assert(token.type == T.Identifier || token.type == T.Dot || token.type == T.Typeof);
+auto begin = token;
 Expression[] identList;
 if (token.type == T.Dot)
 {
-identList ~= new IdentifierExpression(token);
+identList ~= set(new IdentifierExpression(token), begin);
 nT();
 }
 else if (token.type == T.Typeof)
 {
 requireNext(T.LParen);
 auto type = new TypeofType(parseExpression());
 require(T.RParen);
-identList ~= new TypeofExpression(type);
+set(type, begin);
+identList ~= set(new TypeofExpression(type), begin);
 if (token.type != T.Dot)
 goto Lreturn;
 nT();
 }
 while (1)
 {
-auto begin2 = token;
+begin = token;
 auto ident = requireId();
 Expression e;
 if (token.type == T.Not && peekNext() == T.LParen) // Identifier !( TemplateArguments )
 {
 nT(); // Skip !.
-e = set(new TemplateInstanceExpression(ident, parseTemplateArguments()), begin2);
+e = set(new TemplateInstanceExpression(ident, parseTemplateArguments()), begin);
 }
 else // Identifier
-e = set(new IdentifierExpression(ident), begin2);
+e = set(new IdentifierExpression(ident), begin);
 identList ~= e;
 LnewExpressionLoop:
 if (token.type != T.Dot)
 nT();
 }
 else if (token.type == T.Typeof)
 {
 requireNext(T.LParen);
-identList ~= set(new TypeofType(parseExpression()), begin);
+auto type = new TypeofType(parseExpression());
 require(T.RParen);
+identList ~= set(type, begin);
 if (token.type != T.Dot)
 goto Lreturn;
 nT();
 }
 T.Byte,   T.Ubyte,   T.Short,  T.Ushort,
 T.Int,    T.Uint,    T.Long,   T.Ulong,
 T.Float,  T.Double,  T.Real,
 T.Ifloat, T.Idouble, T.Ireal,
 T.Cfloat, T.Cdouble, T.Creal, T.Void:+/
-case T.Traits:
+case T.Traits: // D2.0
 // Tokens that can start a UnaryExpression:
 case T.AndBinary,
 T.PlusPlus,
 T.MinusMinus,
 T.Mul,
 break;
 default:
 if (token.isSpecialToken)
 goto case_parseExpressionStatement;
-// Assert that this isn't a valid expression.
+if (token.type != T.Dollar)
-assert(
+// Assert that this isn't a valid expression.
-delegate bool(){
+assert(
-bool success;
+delegate bool(){
-auto expression = try_(&parseExpression, success);
+bool success;
-return success;
+auto expression = try_(&parseExpression, success);
-}() == false, "Any token that could start a valid expression must have been caught by a case statement in parseStatement()."
+return success;
-);
+}() == false, "Didn't expect valid expression."
+);
 // Report error: it's an illegal statement.
 error(MID.ExpectedButFound, "Statement", token.srcText);
 s = new IllegalStatement(token);
 nT();
 assert(s !is null);
 set(s, begin);
 return s;
 }
-/+
+/++
 ScopeStatement:
 NoScopeStatement
 +/
 Statement parseScopeStatement()
 {
 return new ScopeStatement(parseNoScopeStatement());
 }
-/+
+/++
 NoScopeStatement:
 NonEmptyStatement
 BlockStatement
 BlockStatement:
 { }
 { StatementList }
 +/
 Statement parseNoScopeStatement()
 {
+auto begin = token;
 Statement s;
 if (token.type == T.LBrace)
 {
 nT();
 auto ss = new Statements();
 while (token.type != T.RBrace && token.type != T.EOF)
 ss ~= parseStatement();
 require(T.RBrace);
-s = ss;
+s = set(ss, begin);
 }
 else if (token.type == T.Semicolon)
 {
 error(MID.ExpectedButFound, "non-empty statement", ";");
-s = new EmptyStatement();
+nT();
-nT();
+s = set(new EmptyStatement(), begin);
 }
 else
 s = parseStatement();
 return s;
 }
-/+
+/++
 NoScopeOrEmptyStatement:
 ;
 NoScopeStatement
 +/
 Statement parseNoScopeOrEmptyStatement()
 {
 if (token.type == T.Semicolon)
 {
-nT();
+auto begin = token;
-return new EmptyStatement();
+nT();
+return set(new EmptyStatement(), begin);
 }
 else
 return parseNoScopeStatement();
 }
 Linkage.Category link_cat;
 void addStorageClass()
 {
 if (stc & tmp)
-{
 error(MID.RedundantStorageClass, token.srcText);
-}
 else
 stc |= tmp;
 }
 Statement parse()
 require(T.RParen);
 auto switchBody = parseScopeStatement();
 return new SwitchStatement(condition, switchBody);
 }
-Statement parseCaseDefaultBody()
+/++
+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 Statements();
 while (token.type != T.Case &&
 token.type != T.Default &&
 token.type != T.RBrace &&
 token.type != T.EOF)
 s ~= parseStatement();
-return new ScopeStatement(s);
+return set(new ScopeStatement(s), begin);
 }
 Statement parseCaseStatement()
 {
 assert(token.type == T.Case);
 nT();
 values ~= parseAssignExpression();
 } while (token.type == T.Comma)
 require(T.Colon);
-auto caseBody = parseCaseDefaultBody();
+auto caseBody = parseCaseOrDefaultBody();
 return new CaseStatement(values, caseBody);
 }
 Statement parseDefaultStatement()
 {
 assert(token.type == T.Default);
 nT();
 require(T.Colon);
-return new DefaultStatement(parseCaseDefaultBody());
+auto defaultBody = parseCaseOrDefaultBody();
+return new DefaultStatement(defaultBody);
 }
 Statement parseContinueStatement()
 {
 assert(token.type == T.Continue);
 nT();
 Parameter param;
 if (token.type == T.LParen)
 {
 nT();
+auto begin = token;
 Token* ident;
 auto type = parseDeclarator(ident, true);
 param = new Parameter(null, type, ident, null);
+set(param, begin);
 require(T.RParen);
 }
 catchBodies ~= new CatchBody(param, parseNoScopeStatement());
 if (param is null)
 break; // This is a LastCatch
 }
 if (token.type == T.Finally)
 {
+auto begin = token;
 nT();
 finBody = new FinallyBody(parseNoScopeStatement());
+set(finBody, begin);
 }
 if (catchBodies.length == 0 && finBody is null)
 {
 // TODO: issue error msg.
 require(T.LParen);
 ident = requireId();
 if (token.type == T.Comma)
 {
-// Parse at least one argument.
+nT();
-nT();
+args = parseExpressionList();
-args ~= parseAssignExpression();
+}
-}
+require(T.RParen);
-if (token.type == T.Comma)
-args ~= parseArguments(T.RParen);
-else
-require(T.RParen);
 pragmaBody = parseNoScopeOrEmptyStatement();
 return new PragmaStatement(ident, args, pragmaBody);
 }
 e = new AsmRegisterExpression(token);
 nT();
 break;
 default:
 // DotIdentifier
-auto begin2 = token;
 Expression[] identList;
-goto LenterLoop;
+while (1)
-while (token.type == T.Dot)
 {
-nT();
+auto begin2 = token;
-begin2 = token;
 auto ident = requireId();
-LenterLoop:
+e = new IdentifierExpression(ident);
-e = new IdentifierExpression(token);
-nT();
 set(e, begin2);
 identList ~= e;
+if (token.type != T.Dot)
+break;
+nT(); // Skip dot.
 }
 e = new DotListExpression(identList);
 }
 break;
 default:
 return e;
 }
 Expression parseOrOrExpression()
 {
-auto begin = token;
 alias parseAndAndExpression parseNext;
+auto begin = token;
 auto e = parseNext();
 while (token.type == T.OrLogical)
 {
 auto tok = token;
 nT();
 return e;
 }
 Expression parseAndAndExpression()
 {
-auto begin = token;
 alias parseOrExpression parseNext;
+auto begin = token;
 auto e = parseNext();
 while (token.type == T.AndLogical)
 {
 auto tok = token;
 nT();
 return e;
 }
 Expression parseOrExpression()
 {
-auto begin = token;
 alias parseXorExpression parseNext;
+auto begin = token;
 auto e = parseNext();
 while (token.type == T.OrBinary)
 {
 auto tok = token;
 nT();
 return e;
 }
 Expression parseXorExpression()
 {
-auto begin = token;
 alias parseAndExpression parseNext;
+auto begin = token;
 auto e = parseNext();
 while (token.type == T.Xor)
 {
 auto tok = token;
 nT();
 return e;
 }
 Expression parseAndExpression()
 {
-auto begin = token;
 alias parseCmpExpression parseNext;
+auto begin = token;
 auto e = parseNext();
 while (token.type == T.AndBinary)
 {
 auto tok = token;
 nT();
 return e;
 }
 Expression parseCmpExpression()
 {
+alias parseShiftExpression parseNext;
 auto begin = token;
 auto e = parseShiftExpression();
 auto operator = token;
 switch (operator.type)
 {
 case T.Equal, T.NotEqual:
 nT();
-e = new EqualExpression(e, parseShiftExpression(), operator);
+e = new EqualExpression(e, parseNext(), operator);
 break;
 case T.Not:
 if (peekNext() != T.Is)
 break;
 nT();
 // fall through
 case T.Is:
 nT();
-e = new IdentityExpression(e, parseShiftExpression(), operator);
+e = new IdentityExpression(e, parseNext(), operator);
 break;
 case T.LessEqual, T.Less, T.GreaterEqual, T.Greater,
 T.Unordered, T.UorE, T.UorG, T.UorGorE,
 T.UorL, T.UorLorE, T.LorEorG, T.LorG:
 nT();
-e = new RelExpression(e, parseShiftExpression(), operator);
+e = new RelExpression(e, parseNext(), operator);
 break;
 case T.In:
 nT();
-e = new InExpression(e, parseShiftExpression(), operator);
+e = new InExpression(e, parseNext(), operator);
 break;
 default:
 return e;
 }
 set(e, begin);
 return e;
 }
 Expression parseShiftExpression()
 {
-auto begin = token;
+alias parseAddExpression parseNext;
-auto e = parseAddExpression();
+auto begin = token;
+auto e = parseNext();
 while (1)
 {
 auto operator = token;
 switch (operator.type)
 {
-case T.LShift:  nT(); e = new LShiftExpression(e, parseAddExpression(), operator); break;
+case T.LShift:  nT(); e = new LShiftExpression(e, parseNext(), operator); break;
-case T.RShift:  nT(); e = new RShiftExpression(e, parseAddExpression(), operator); break;
+case T.RShift:  nT(); e = new RShiftExpression(e, parseNext(), operator); break;
-case T.URShift: nT(); e = new URShiftExpression(e, parseAddExpression(), operator); break;
+case T.URShift: nT(); e = new URShiftExpression(e, parseNext(), operator); break;
 default:
 return e;
 }
 set(e, begin);
 }
 assert(0);
 }
 Expression parseAddExpression()
 {
-auto begin = token;
+alias parseMulExpression parseNext;
-auto e = parseMulExpression();
+auto begin = token;
+auto e = parseNext();
 while (1)
 {
 auto operator = token;
 switch (operator.type)
 {
-case T.Plus:  nT(); e = new PlusExpression(e, parseMulExpression(), operator); break;
+case T.Plus:  nT(); e = new PlusExpression(e, parseNext(), operator); break;
-case T.Minus: nT(); e = new MinusExpression(e, parseMulExpression(), operator); break;
+case T.Minus: nT(); e = new MinusExpression(e, parseNext(), operator); break;
-case T.Tilde: nT(); e = new CatExpression(e, parseMulExpression(), operator); break;
+case T.Tilde: nT(); e = new CatExpression(e, parseNext(), operator); break;
 default:
 return e;
 }
 set(e, begin);
 }
 break;
 case T.MinusMinus:
 e = new PostDecrExpression(e);
 break;
 case T.LParen:
-e = new CallExpression(e, parseArguments(T.RParen));
+e = new CallExpression(e, parseArguments());
 goto Lset;
 case T.LBracket:
 // parse Slice- and IndexExpression
 nT();
 if (token.type == T.RBracket)
 nT();
 e = new SliceExpression(e, es[0], parseAssignExpression());
 require(T.RBracket);
 goto Lset;
 }
-else if (token.type == T.Comma)
+if (token.type == T.Comma)
 {
-es ~= parseArguments(T.RBracket);
+nT();
+es ~= parseExpressionList();
 }
-else
+require(T.RBracket);
-require(T.RBracket);
 e = new IndexExpression(e, es);
 goto Lset;
 default:
 return e;
 T.Imaginary32, T.Imaginary64, T.Imaginary80:
 e = new RealExpression(token.type, token.real_);
 nT();
 break;
 case T.CharLiteral, T.WCharLiteral, T.DCharLiteral:
-nT();
+e = new CharExpression(token);
-e = new CharExpression();
+nT();
 break;
 case T.String:
 Token*[] stringLiterals;
 do
 {
 if (token.type != T.RBracket)
 {
 e = parseAssignExpression();
 if (token.type == T.Colon)
 goto LparseAssocArray;
-else if (token.type == T.Comma)
+if (token.type == T.Comma)
-values = [e] ~ parseArguments(T.RBracket);
+{
-else
+nT();
-require(T.RBracket);
+values = [e] ~ parseExpressionList();
+}
+require(T.RBracket);
 }
 else
 nT();
 e = new ArrayLiteralExpression(values);
 Expression[] newArguments;
 Expression[] ctorArguments;
 if (token.type == T.LParen)
-newArguments = parseArguments(T.RParen);
+newArguments = parseArguments();
 // NewAnonClassExpression:
 //         new (ArgumentList)opt class (ArgumentList)opt SuperClassopt InterfaceClassesopt ClassBody
 if (token.type == T.Class)
 {
 nT();
 if (token.type == T.LParen)
-ctorArguments = parseArguments(T.RParen);
+ctorArguments = parseArguments();
 BaseClass[] bases = token.type != T.LBrace ? parseBaseClasses(false) : null ;
 auto decls = parseDeclarationDefinitionsBlock();
 return set(new NewAnonClassExpression(/*e, */newArguments, bases, ctorArguments, decls), begin);
 //         NewArguments Type ( ArgumentList )
 //         NewArguments Type
 auto type = parseType();
 if (token.type == T.LParen)
-ctorArguments = parseArguments(T.RParen);
+ctorArguments = parseArguments();
 return set(new NewExpression(/*e, */newArguments, type, ctorArguments), begin);
 }
 Type parseType()
 expected(T.Identifier);
 return t;
 }
-Expression[] parseArguments(TOK terminator)
+/++
-{
+Parse a list of AssignExpressions.
-assert(token.type == T.LParen || token.type == T.LBracket || token.type == T.Comma);
+ExpressionList:
-assert(terminator == T.RParen || terminator == T.RBracket);
+AssignExpression
+AssignExpression , ExpressionList
++/
+Expression[] parseExpressionList()
+{
+Expression[] expressions;
+while (1)
+{
+expressions ~= parseAssignExpression();
+if (token.type != T.Comma)
+break;
+nT();
+}
+return expressions;
+}
+/++
+Arguments:
+( )
+( ExpressionList )
++/
+Expression[] parseArguments()
+{
+assert(token.type == T.LParen);
+nT();
 Expression[] args;
+if (token.type != TOK.RParen)
-nT();
+args = parseExpressionList();
-if (token.type == terminator)
+require(TOK.RParen);
-{
-nT();
-return null;
-}
-goto LenterLoop;
-do
-{
-nT();
-LenterLoop:
-args ~= parseAssignExpression();
-} while (token.type == T.Comma)
-require(terminator);
 return args;
 }
 Parameters parseParameterList()
 out(params)

Mercurial > projects > dil

comparison trunk/src/dil/Parser.d @ 486:bd176bc73e43