projects/dang: parser/Parser.d comparison

comparison parser/Parser.d @ 152:893f23a9de93

Formatting change

author	Anders Halager <halager@gmail.com>
date	Mon, 21 Jul 2008 21:30:44 +0200
parents	aeeef0dea14e
children	0ea5d2f3e96b

comparison

equal deleted inserted replaced

-:aeeef0dea14e
+:893f23a9de93
 }
 return a;
 }
 enum : uint
 {
 Single,
 Scope,
 All
 }
 struct Att
 {
 Attribute a;
 uint nested;
 }
 /**
 Parse statements.
 This is the place to attack!
 */
 Stmt parseStatement()
 {
 Token t = peek;
 if (t.isReturn)
 {
 Token ret = next();
 Exp exp;
 if (peek.type != Tok.Seperator)
 exp = parseExpression();
 require(Tok.Seperator);
 return action.actOnReturnStmt(ret, exp);
+}
 /*
 if (cond)
 single statement | compound statement
 [else
 single statement | compound statement]
 */
-}
+else if (t.isIf)
-else if (t.isIf)
+{
-{
+Token _if = next();
-Token _if = next();
+require(Tok.OpenParentheses);
-require(Tok.OpenParentheses);
+Exp cond = parseExpression();
-Exp cond = parseExpression();
+require(Tok.CloseParentheses);
-require(Tok.CloseParentheses);
+Stmt thenB = parseSingleOrCompoundStatement();
-Stmt thenB = parseSingleOrCompoundStatement();
+// if there is no else part we use the if as token, to have
-// if there is no else part we use the if as token, to have
+// something than can be passed along
-// something than can be passed along
+Token _else = _if;
-Token _else = _if;
+Stmt elseB;
-Stmt elseB;
+if (peek.type == Tok.Else)
-if (peek.type == Tok.Else)
+{
-{
+_else = next();
-_else = next();
+elseB = parseSingleOrCompoundStatement();
-elseB = parseSingleOrCompoundStatement();
+}
-}
+return action.actOnIfStmt(_if, cond, thenB, _else, elseB);
-return action.actOnIfStmt(_if, cond, thenB, _else, elseB);
+}
 /*
 while (cond)
 single statement | compound statement
 */
-}
+else if (t.isWhile)
-else if (t.isWhile)
+{
-{
+Token _while = next();
-Token _while = next();
+require(Tok.OpenParentheses);
-require(Tok.OpenParentheses);
+Exp cond = parseExpression();
-Exp cond = parseExpression();
+require(Tok.CloseParentheses);
-require(Tok.CloseParentheses);
+Stmt bodyStmt = parseSingleOrCompoundStatement();
-Stmt bodyStmt = parseSingleOrCompoundStatement();
+return action.actOnWhileStmt(_while, cond, bodyStmt);
-return action.actOnWhileStmt(_while, cond, bodyStmt);
+}
-/*
+else if (t.isFor)
-One of four things:
+{
-A declaration of a function/variable `type id ...`
+Token _for = next();
-A direct assignment `id = exp;`
+require(Tok.OpenParentheses);
-An indirect assignment `id.id = exp`
+Stmt init;
-Some sort of free standing expression
+if ( isa(Tok.Seperator))
+require(Tok.Seperator);
-The assignments should be handled as binary expressions?
+else
-*/
+init = parseStatement();
-}
-else if (t.isFor)
+Exp cond;
-{
+if ( !isa(Tok.Seperator))
-Token _for = next();
+cond = parseExpression();
-require(Tok.OpenParentheses);
+require(Tok.Seperator);
-Stmt init;
-if ( isa(Tok.Seperator))
+Exp incre;
-require(Tok.Seperator);
+if ( !isa(Tok.CloseParentheses))
-else
+incre = parseExpression();
-init = parseStatement();
+require(Tok.CloseParentheses);
-Exp cond;
+Stmt bodyStmt = parseSingleOrCompoundStatement();
-if ( !isa(Tok.Seperator))
+return action.actOnForStmt(_for, init, cond, incre, bodyStmt);
-cond = parseExpression();
+}
-require(Tok.Seperator);
+else if (t.isBasicType || t.isIdentifier)
+{
-Exp incre;
+Token iden = peek;
-if ( !isa(Tok.CloseParentheses))
+Token n = peek(1);
-incre = parseExpression();
+// Must be an decl, if we start with a basic type, or two
-require(Tok.CloseParentheses);
+// identifiers in a row
+if ( n.type == Tok.Star || n.type == Tok.OpenBracket)
-Stmt bodyStmt = parseSingleOrCompoundStatement();
+{
-return action.actOnForStmt(_for, init, cond, incre, bodyStmt);
+int len = peekParseType;
-}
+if(peek(len).type == Tok.Identifier && len != 0)
-else if (t.isBasicType || t.isIdentifier)
+return action.actOnDeclStmt(parseVarDecl());
-{
-Token iden = peek;
+Exp exp = parseExpression();
-Token n = peek(1);
+require(Tok.Seperator);
-// Must be an decl, if we start with a basic type, or two
+return action.actOnExprStmt(exp);
-// identifiers in a row
+}
-if ( n.type == Tok.Star || n.type == Tok.OpenBracket)
-{
+if (n.isIdentifier())
-int len = peekParseType;
+return action.actOnDeclStmt(parseVarDecl());
-if(peek(len).type == Tok.Identifier && len != 0)
-return action.actOnDeclStmt(parseVarDecl());
+// Expression: a.b, a = b, a(b) etc.
+Exp exp = parseExpression();
-Exp exp = parseExpression();
+require(Tok.Seperator);
-require(Tok.Seperator);
+return action.actOnExprStmt(exp);
-return action.actOnExprStmt(exp);
+}
-}
+else if (t.isSwitch)
+{
-if (n.isIdentifier())
+next();
-return action.actOnDeclStmt(parseVarDecl());
+require(Tok.OpenParentheses);
+auto target = parseExpression();
-// Expression: a.b, a = b, a(b) etc.
+auto res = action.actOnStartOfSwitchStmt(t, target);
-Exp exp = parseExpression();
+require(Tok.CloseParentheses);
-require(Tok.Seperator);
+require(Tok.OpenBrace);
-return action.actOnExprStmt(exp);
+while (true)
-}
+{
-else if (t.isSwitch)
+Stmt[] statements;
-{
+if (isa(Tok.Default))
-next();
-require(Tok.OpenParentheses);
-auto target = parseExpression();
-auto res = action.actOnStartOfSwitchStmt(t, target);
-require(Tok.CloseParentheses);
-require(Tok.OpenBrace);
-while (true)
 {
-Stmt[] statements;
+Token _default = next();
-if (isa(Tok.Default))
-{
-Token _default = next();
-require(Tok.Colon);
-statements.length = 0;
-while (peek.type != Tok.Case
-&& peek.type != Tok.Default
-&& peek.type != Tok.CloseBrace)
-statements ~= parseStatement();
-action.actOnDefaultStmt(res, _default, statements);
-continue;
-}
-Token _case = peek;
-if (_case.type != Tok.Case)
-break;
-next();
-Exp[] literals;
-do
-{
-Exp e = parseExpression();
-literals ~= e;
-}
-while (skip(Tok.Comma));
 require(Tok.Colon);
+statements.length = 0;
 while (peek.type != Tok.Case
 && peek.type != Tok.Default
 && peek.type != Tok.CloseBrace)
 statements ~= parseStatement();
+action.actOnDefaultStmt(res, _default, statements);
-action.actOnCaseStmt(res, _case, literals, statements);
+continue;
-if (peek.type == Tok.CloseBrace)
-break;
 }
-require(Tok.CloseBrace);
-return res;
+Token _case = peek;
-}
+if (_case.type != Tok.Case)
-else
+break;
-{
+next();
-if (t.type == Tok.Star)
-{
+Exp[] literals;
-auto exp = parseExpression();
+do
-require(Tok.Seperator);
+{
-return action.actOnExprStmt(exp);
+Exp e = parseExpression();
-}
+literals ~= e;
-messages.report(UnexpectedBeginStmt, t.location).arg(t.getType);
+}
-return null;
+while (skip(Tok.Comma));
-}
+require(Tok.Colon);
-messages.report(UnexpectedTok, t.location);
-return null;
+while (peek.type != Tok.Case
-}
+&& peek.type != Tok.Default
+&& peek.type != Tok.CloseBrace)
-Decl parseVarDecl()
+statements ~= parseStatement();
-{
-// manually hardcoded to only support "type id [= exp];"
+action.actOnCaseStmt(res, _case, literals, statements);
-// as that is the only thing the codegen understands
-Id type = parseType;
+if (peek.type == Tok.CloseBrace)
-Id id = Id(next());
+break;
-Exp init;
+}
-if (skip(Tok.Assign))
+require(Tok.CloseBrace);
-init = parseExpression();
+return res;
-require(Tok.Seperator);
+}
-Attribute att;
+else if (t.type == Tok.Star)
-Decl d = action.actOnDeclarator(type, id, init, att);
+{
-return d;
+auto exp = parseExpression();
-}
+require(Tok.Seperator);
+return action.actOnExprStmt(exp);
-/**
+}
-Parses a function/method given the already parsed return type and name
+else
-*/
+{
-Decl parseFunc(ref Id type, ref Id name, Attribute att)
+messages.report(UnexpectedBeginStmt, t.location).arg(t.getType);
-{
+return null;
-Decl func = action.actOnStartOfFunctionDef(type, name, att);
+}
-parseFuncArgs(func);
+}
-if(peek.type == Tok.Seperator)
+Decl parseVarDecl()
 {
-next();
+// manually hardcoded to only support "type id [= exp];"
-return func;
+// as that is the only thing the codegen understands
-}
+Id type = parseType;
-Stmt stmt = parseCompoundStatement();
+Id id = Id(next());
+Exp init;
-return action.actOnEndOfFunction(func, stmt);
+if (skip(Tok.Assign))
-}
+init = parseExpression();
+require(Tok.Seperator);
-/**
+Attribute att;
-Parse the function arguments, assumes current token is (.
+Decl d = action.actOnDeclarator(type, id, init, att);
+return d;
-Both the intitial paren and the ending paren is consumed.
+}
-*/
-void parseFuncArgs(Decl func)
+/**
-{
+Parses a function/method given the already parsed return type and name
-require(Tok.OpenParentheses); // Remove the "(" token.
+*/
+Decl parseFunc(ref Id type, ref Id name, Attribute att)
-while(peek.type != Tok.CloseParentheses)
+{
-{
+Decl func = action.actOnStartOfFunctionDef(type, name, att);
-auto t = parseType();
+parseFuncArgs(func);
-Id i;
-if(peek.type == Tok.Identifier)
+if(peek.type == Tok.Seperator)
-i = parseIdentifier();
+{
-action.addFuncArg(func, t, i);
+next();
+return func;
-if(peek.type == Tok.Comma)
+}
-next();
+Stmt stmt = parseCompoundStatement();
-}
+return action.actOnEndOfFunction(func, stmt);
-require(Tok.CloseParentheses); // Remove the ")"
+}
-}
+/**
-/**
+Parse the function arguments, assumes current token is (.
-Parse either a block, or a single statement as allowed after if, while
-and for.
+Both the intitial paren and the ending paren is consumed.
 */
-Stmt parseSingleOrCompoundStatement()
+void parseFuncArgs(Decl func)
 {
-if (peek.type == Tok.OpenBrace)
+require(Tok.OpenParentheses); // Remove the "(" token.
-return parseCompoundStatement();
-return parseStatement();
+while(peek.type != Tok.CloseParentheses)
-}
+{
+auto t = parseType();
-/**
+Id i;
-Parses a function-body or similar, expects an opening brace to be the
+if(peek.type == Tok.Identifier)
-current token.
+i = parseIdentifier();
+action.addFuncArg(func, t, i);
-Will consume both the starting { and ending }
-*/
+if(peek.type == Tok.Comma)
-Stmt parseCompoundStatement()
+next();
-{
+}
-Token lbrace = require(Tok.OpenBrace);
-SmallArray!(Stmt, 32) stmts; // Try to use the stack only
+require(Tok.CloseParentheses); // Remove the ")"
-while ( !isa(Tok.CloseBrace) && !isa(Tok.EOF) )
+}
-stmts ~= parseStatement();
-Token rbrace = require(Tok.CloseBrace);
+/**
-return action.actOnCompoundStmt(lbrace, rbrace, stmts.unsafe());
+Parse either a block, or a single statement as allowed after if, while
-}
+and for.
+*/
-Id parseIdentifier()
+Stmt parseSingleOrCompoundStatement()
 {
-Token tok = next();
+if (peek.type == Tok.OpenBrace)
+return parseCompoundStatement();
-if (tok.type is Tok.Identifier)
+return parseStatement();
-return Id(tok);
+}
-messages.report(UnexpectedTokSingle, tok.location)
+/**
-.arg(tok.getType)
+Parses a function-body or similar, expects an opening brace to be the
-.arg(Tok.Identifier);
+current token.
-}
+Will consume both the starting { and ending }
-ModuleName parseModuleName()
+*/
-{
+Stmt parseCompoundStatement()
-auto id = parseIdentifier();
+{
-ModuleName mod;
+Token lbrace = require(Tok.OpenBrace);
-while (skip(Tok.Dot))
+SmallArray!(Stmt, 32) stmts; // Try to use the stack only
-{
+while ( !isa(Tok.CloseBrace) && !isa(Tok.EOF) )
-mod.packages ~= id;
+stmts ~= parseStatement();
-if (peek.type != Tok.Identifier) {
+Token rbrace = require(Tok.CloseBrace);
-messages.report(ExpectedIdAfterPackage, peek.location);
+return action.actOnCompoundStmt(lbrace, rbrace, stmts.unsafe());
-goto Lerror;
+}
-}
-id = parseIdentifier();
+Id parseIdentifier()
-}
+{
-mod.id = id;
+Token tok = next();
-return mod;
+if (tok.type is Tok.Identifier)
+return Id(tok);
+messages.report(UnexpectedTokSingle, tok.location)
+.arg(tok.getType)
+.arg(Tok.Identifier);
+}
+ModuleName parseModuleName()
+{
+auto id = parseIdentifier();
+ModuleName mod;
+while (skip(Tok.Dot))
+{
+mod.packages ~= id;
+if (peek.type != Tok.Identifier) {
+messages.report(ExpectedIdAfterPackage, peek.location);
+goto Lerror;
+}
+id = parseIdentifier();
+}
+mod.id = id;
+return mod;
 Lerror:
 while (!skip(Tok.Seperator))
 next();
 return mod;
 }
 /**
 Parse a type - this includes pointer and array(at some point) types.
 */
 Id parseType()
 {
 Token type = next();
 Id currentType;
 if ( !(type.isBasicType || type.type == Tok.Identifier) )
 messages.report(InvalidType, type.location);
 currentType = Id(type);
 type = peek;
 while(type.type == Tok.Star || type.type == Tok.OpenBracket)
 {
 if(type.type == Tok.Star)
 {
 currentType = PointerId(currentType);
 next();
 }
 else
 {
 next();
 if(peek.type == Tok.Integer)
 currentType = StaticArrayId(
 currentType,
 action.actOnNumericConstant(
 require(Tok.Integer)));
 require(Tok.CloseBracket);
 }
 type = peek;
 }
 return currentType;
 }
 int peekParseType()
 {
 int i;
 Token type = peek(i);
 Id currentType;
 if ( !(type.isBasicType || type.type == Tok.Identifier) )
 return 0;
 currentType = Id(type);
 type = peek(++i);
 while(type.type == Tok.Star || type.type == Tok.OpenBracket)
 {
 if(type.type == Tok.Star)
 {
 i++;
 }
 else
 {
 if(peek(i++).type != Tok.OpenBracket)
 return 0;
 if(peek(i).type == Tok.Integer)
 {
 i++;
 if(peek(i++).type != Tok.CloseBracket)
 return 0;
 }
 else
 if(peek(i++).type != Tok.CloseBracket)
 return 0;
 }
 type = peek(i);
 }
 return i;
 }
 private:
 // -- Expression parsing -- //
 Exp parsePostfixExp(Exp target)
 {
 switch(peek.type)
 {
 case Tok.Dot:
 switch(peek(1).type)
 {
 case Tok.Identifier:
 Token op = next();
 Id member = Id(next());
 Exp exp = action.actOnMemberReference(target, op.location, member);
 return parsePostfixExp(exp);
 default:
 Token t = peek(1);
 messages.report(ExpectedIdAfterDot, t.location);
 }
 case Tok.OpenBracket:
 Token open = next();
 Exp index = parseExpression();
 Token close = require(Tok.CloseBracket);
 return action.actOnIndexEpr(target, open, index, close);
 default:
 return target;
 }
 }
 Exp parseExpression(int p = 0)
 {
 auto exp = P();
 Token n = peek();
 BinOp* op = null;
 while ((op = binary(n.type)) != null && op.prec >= p)
 {
 next();
 int q = op.leftAssoc? 1 + op.prec : op.prec;
 auto exp2 = parseExpression(q);
 exp = action.actOnBinaryOp(n.location, op.operator, exp, exp2);
 n = peek();
 }
 return exp;
 }
 Exp P()
 {
 Token n = next();
 if (auto op = unary(n.type))
 return action.actOnUnaryOp(n, parseExpression(op.prec));
 else if (n.type == Tok.OpenParentheses)
 {
 auto e = parseExpression(0);
 require(Tok.CloseParentheses);
 return e;
 }
 else if (n.type == Tok.Identifier)
 {
 Exp value = action.actOnIdentifierExp(Id(n));
 Exp iden = parsePostfixExp(value);
 switch(peek.type)
 {
 case Tok.OpenParentheses:
 Token lp = next();
 SmallArray!(Exp, 8) args;
 while(peek.type != Tok.CloseParentheses)
 {
 if(peek.type == Tok.Comma)
 next();
 args ~= parseExpression();
 }
 Token rp = next();
 return action.actOnCallExpr(iden, lp, args.unsafe(), rp);
 default:
 return iden;
 }
 }
 else if (n.type == Tok.Cast)
 return parseCast(n);
 else if (n.type == Tok.Integer)
 return action.actOnNumericConstant(n);
 else if (n.type == Tok.String)
 return action.actOnStringExp(n);
 messages.report(ExpectedExp, n.location)
 .fatal(ExitLevel.Parser);
 return null;
 }
 Exp parseCast(ref Token _cast)
 {
 require(Tok.OpenParentheses);
 auto n = next();
 if(!n.isBasicType && !n.isIdentifier)
 messages.report(ExpectedCastType, n.location);
 require(Tok.CloseParentheses);
 auto exp = P();
 return action.actOnCastExpr(_cast, Id(n), exp);
 }
 struct UnOp
 {
 Tok tokenType;
 int prec;
 }
 static const UnOp[] _unary =
 [
 {Tok.Minus, 4},
 {Tok.Star, 4}
 ];
 UnOp* unary(Tok t)
 {
 foreach (ref op; _unary)
 if (op.tokenType == t)
 return &op;
 return null;
 }
 struct BinOp
 {
 Tok tokenType;
 int prec;
 bool leftAssoc;
 Operator operator;
 }
 static const BinOp[] _binary =
 [
 {Tok.Assign,        1, false, Operator.Assign},
 {Tok.PlusAssign,    1, false, Operator.AddAssign},
 {Tok.MinusAssign,   1, false, Operator.SubAssign},
 {Tok.StarAssign,    1, false, Operator.MulAssign},
 {Tok.SlashAssign,   1, false, Operator.DivAssign},
 {Tok.PercentAssign, 1, false, Operator.ModAssign},
 // =, += etc. 1
 // (need special-case for the ternary operator at this level)
 // ||, 2
 // &&, 3
 // |, 4
 // &, 5
 // ^, 6
 // ==, !=, is, !is, 7
 // <, <= etc, 7
 // in, 7
 // <<, >>, >>>, 8
 // +, -, ~, 9
 // *, /, %, 10
 // unary operators here
 {Tok.Eq,        2, true, Operator.Eq},
 {Tok.Ne,        2, true, Operator.Ne},
 {Tok.Lt,        2, true, Operator.Lt},
 {Tok.Le,        2, true, Operator.Le},
 {Tok.Gt,        2, true, Operator.Gt},
 {Tok.Ge,        2, true, Operator.Ge},
 {Tok.Plus,      3, true, Operator.Add},
 {Tok.Minus,     3, true, Operator.Sub},
 {Tok.Star,      5, true, Operator.Mul},
 {Tok.Slash,     5, true, Operator.Div},
 {Tok.Percent,   5, true, Operator.Mod},
 {Tok.LeftShift,             8, true, Operator.LeftShift},
 {Tok.RightShift,            8, true, Operator.RightShift},
 {Tok.UnsignedRightShift,    8, true, Operator.UnsignedRightShift}
 ];
 BinOp* binary(Tok t)
 {
 foreach (ref op; _binary)
 if (op.tokenType == t)
 return &op;
 return null;
 }
 private:
 Token require(Tok t)
 {
 if (peek().type != t)
 messages.report(UnexpectedTokSingle, peek.location)
 .arg(peek.getType)
 .arg(t);
 return next();
 }
 bool skip(Tok t)
 {
 if (peek().type != t)
 return false;
 next();
 return true;
 }
 bool isa(Tok t)
 {
 return peek.type == t;
 }
 Token next()
 {
 return lexer.next;
 }
 Token peek(int i = 0)
 {
 return lexer.peek(i);
 }
 Lexer lexer;
 SourceManager sm;
 }

Mercurial > projects > dang

comparison parser/Parser.d @ 152:893f23a9de93