# HG changeset patch # User Anders Halager # Date 1216668644 -7200 # Node ID 893f23a9de93013c58b577b0481c002129edccd5 # Parent aeeef0dea14e80926332acd270e94381053f0a49 Formatting change diff -r aeeef0dea14e -r 893f23a9de93 parser/Parser.d --- a/parser/Parser.d Mon Jul 21 21:18:18 2008 +0200 +++ b/parser/Parser.d Mon Jul 21 21:30:44 2008 +0200 @@ -499,617 +499,605 @@ return a; } -enum : uint - { - Single, - Scope, - All - } - - struct Att - { - Attribute a; - uint nested; - } + enum : uint + { + Single, + Scope, + All + } - /** - Parse statements. - - This is the place to attack! - */ - Stmt parseStatement() - { - Token t = peek; + struct Att + { + Attribute a; + uint nested; + } - if (t.isReturn) - { - Token ret = next(); - Exp exp; - if (peek.type != Tok.Seperator) - exp = parseExpression(); - require(Tok.Seperator); - return action.actOnReturnStmt(ret, exp); + /** + Parse statements. + + This is the place to attack! + */ + Stmt parseStatement() + { + Token t = peek; - /* - if (cond) - single statement | compound statement - [else - single statement | compound statement] - */ - } - else if (t.isIf) - { - Token _if = next(); - - require(Tok.OpenParentheses); - Exp cond = parseExpression(); - require(Tok.CloseParentheses); - - Stmt thenB = parseSingleOrCompoundStatement(); + 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) + { + Token _if = next(); - // if there is no else part we use the if as token, to have - // something than can be passed along - Token _else = _if; - Stmt elseB; - if (peek.type == Tok.Else) - { - _else = next(); - elseB = parseSingleOrCompoundStatement(); - } + require(Tok.OpenParentheses); + Exp cond = parseExpression(); + require(Tok.CloseParentheses); - return action.actOnIfStmt(_if, cond, thenB, _else, elseB); + Stmt thenB = parseSingleOrCompoundStatement(); - /* - while (cond) - single statement | compound statement - */ - } - else if (t.isWhile) - { - Token _while = next(); - require(Tok.OpenParentheses); - Exp cond = parseExpression(); - require(Tok.CloseParentheses); - Stmt bodyStmt = parseSingleOrCompoundStatement(); - return action.actOnWhileStmt(_while, cond, bodyStmt); + // if there is no else part we use the if as token, to have + // something than can be passed along + Token _else = _if; + Stmt elseB; + if (peek.type == Tok.Else) + { + _else = next(); + elseB = parseSingleOrCompoundStatement(); + } - /* - One of four things: - A declaration of a function/variable `type id ...` - A direct assignment `id = exp;` - An indirect assignment `id.id = exp` - Some sort of free standing expression + return action.actOnIfStmt(_if, cond, thenB, _else, elseB); - The assignments should be handled as binary expressions? - */ - } - else if (t.isFor) - { - Token _for = next(); - require(Tok.OpenParentheses); - Stmt init; - if ( isa(Tok.Seperator)) - require(Tok.Seperator); - else - init = parseStatement(); - - Exp cond; - if ( !isa(Tok.Seperator)) - cond = parseExpression(); - require(Tok.Seperator); + } + /* + while (cond) + single statement | compound statement + */ + else if (t.isWhile) + { + Token _while = next(); + require(Tok.OpenParentheses); + Exp cond = parseExpression(); + require(Tok.CloseParentheses); + Stmt bodyStmt = parseSingleOrCompoundStatement(); + return action.actOnWhileStmt(_while, cond, bodyStmt); - Exp incre; - if ( !isa(Tok.CloseParentheses)) - incre = parseExpression(); - require(Tok.CloseParentheses); + } + else if (t.isFor) + { + Token _for = next(); + require(Tok.OpenParentheses); + Stmt init; + if ( isa(Tok.Seperator)) + require(Tok.Seperator); + else + init = parseStatement(); - Stmt bodyStmt = parseSingleOrCompoundStatement(); - return action.actOnForStmt(_for, init, cond, incre, bodyStmt); - } - else if (t.isBasicType || t.isIdentifier) - { - Token iden = peek; - Token n = peek(1); - // Must be an decl, if we start with a basic type, or two - // identifiers in a row - if ( n.type == Tok.Star || n.type == Tok.OpenBracket) - { - int len = peekParseType; - if(peek(len).type == Tok.Identifier && len != 0) - return action.actOnDeclStmt(parseVarDecl()); + Exp cond; + if ( !isa(Tok.Seperator)) + cond = parseExpression(); + require(Tok.Seperator); - Exp exp = parseExpression(); - require(Tok.Seperator); - return action.actOnExprStmt(exp); - } + Exp incre; + if ( !isa(Tok.CloseParentheses)) + incre = parseExpression(); + require(Tok.CloseParentheses); - if (n.isIdentifier()) - return action.actOnDeclStmt(parseVarDecl()); + Stmt bodyStmt = parseSingleOrCompoundStatement(); + return action.actOnForStmt(_for, init, cond, incre, bodyStmt); + } + else if (t.isBasicType || t.isIdentifier) + { + Token iden = peek; + Token n = peek(1); + // Must be an decl, if we start with a basic type, or two + // identifiers in a row + if ( n.type == Tok.Star || n.type == Tok.OpenBracket) + { + int len = peekParseType; + if(peek(len).type == Tok.Identifier && len != 0) + return action.actOnDeclStmt(parseVarDecl()); - // Expression: a.b, a = b, a(b) etc. - Exp exp = parseExpression(); - require(Tok.Seperator); - return action.actOnExprStmt(exp); + Exp exp = parseExpression(); + require(Tok.Seperator); + return action.actOnExprStmt(exp); } - else if (t.isSwitch) + + if (n.isIdentifier()) + return action.actOnDeclStmt(parseVarDecl()); + + // Expression: a.b, a = b, a(b) etc. + Exp exp = parseExpression(); + require(Tok.Seperator); + return action.actOnExprStmt(exp); + } + else if (t.isSwitch) + { + next(); + require(Tok.OpenParentheses); + auto target = parseExpression(); + auto res = action.actOnStartOfSwitchStmt(t, target); + require(Tok.CloseParentheses); + require(Tok.OpenBrace); + while (true) { - next(); - require(Tok.OpenParentheses); - auto target = parseExpression(); - auto res = action.actOnStartOfSwitchStmt(t, target); - require(Tok.CloseParentheses); - require(Tok.OpenBrace); - while (true) + Stmt[] statements; + if (isa(Tok.Default)) { - Stmt[] statements; - 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)); + 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.actOnCaseStmt(res, _case, literals, statements); - - if (peek.type == Tok.CloseBrace) - break; + action.actOnDefaultStmt(res, _default, statements); + continue; } - require(Tok.CloseBrace); - return res; - } - else - { - if (t.type == Tok.Star) - { - auto exp = parseExpression(); - require(Tok.Seperator); - return action.actOnExprStmt(exp); - } - messages.report(UnexpectedBeginStmt, t.location).arg(t.getType); - return null; - } - messages.report(UnexpectedTok, t.location); - return null; - } + + 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); + + while (peek.type != Tok.Case + && peek.type != Tok.Default + && peek.type != Tok.CloseBrace) + statements ~= parseStatement(); + + action.actOnCaseStmt(res, _case, literals, statements); - Decl parseVarDecl() - { - // manually hardcoded to only support "type id [= exp];" - // as that is the only thing the codegen understands - Id type = parseType; - Id id = Id(next()); - Exp init; - if (skip(Tok.Assign)) - init = parseExpression(); - require(Tok.Seperator); - Attribute att; - Decl d = action.actOnDeclarator(type, id, init, att); - return d; - } + if (peek.type == Tok.CloseBrace) + break; + } + require(Tok.CloseBrace); + return res; + } + else if (t.type == Tok.Star) + { + auto exp = parseExpression(); + require(Tok.Seperator); + return action.actOnExprStmt(exp); + } + else + { + messages.report(UnexpectedBeginStmt, t.location).arg(t.getType); + return null; + } + } - /** - Parses a function/method given the already parsed return type and name - */ - Decl parseFunc(ref Id type, ref Id name, Attribute att) - { - Decl func = action.actOnStartOfFunctionDef(type, name, att); - parseFuncArgs(func); + Decl parseVarDecl() + { + // manually hardcoded to only support "type id [= exp];" + // as that is the only thing the codegen understands + Id type = parseType; + Id id = Id(next()); + Exp init; + if (skip(Tok.Assign)) + init = parseExpression(); + require(Tok.Seperator); + Attribute att; + Decl d = action.actOnDeclarator(type, id, init, att); + return d; + } - if(peek.type == Tok.Seperator) - { - next(); - return func; - } - Stmt stmt = parseCompoundStatement(); + /** + Parses a function/method given the already parsed return type and name + */ + Decl parseFunc(ref Id type, ref Id name, Attribute att) + { + Decl func = action.actOnStartOfFunctionDef(type, name, att); + parseFuncArgs(func); - return action.actOnEndOfFunction(func, stmt); - } - - /** - Parse the function arguments, assumes current token is (. + if(peek.type == Tok.Seperator) + { + next(); + return func; + } + Stmt stmt = parseCompoundStatement(); - Both the intitial paren and the ending paren is consumed. - */ - void parseFuncArgs(Decl func) - { - require(Tok.OpenParentheses); // Remove the "(" token. + return action.actOnEndOfFunction(func, stmt); + } + + /** + Parse the function arguments, assumes current token is (. - while(peek.type != Tok.CloseParentheses) - { - auto t = parseType(); - Id i; - if(peek.type == Tok.Identifier) - i = parseIdentifier(); - action.addFuncArg(func, t, i); + Both the intitial paren and the ending paren is consumed. + */ + void parseFuncArgs(Decl func) + { + require(Tok.OpenParentheses); // Remove the "(" token. - if(peek.type == Tok.Comma) - next(); - } + while(peek.type != Tok.CloseParentheses) + { + auto t = parseType(); + Id i; + if(peek.type == Tok.Identifier) + i = parseIdentifier(); + action.addFuncArg(func, t, i); - require(Tok.CloseParentheses); // Remove the ")" - } + if(peek.type == Tok.Comma) + next(); + } - /** - Parse either a block, or a single statement as allowed after if, while - and for. - */ - Stmt parseSingleOrCompoundStatement() - { - if (peek.type == Tok.OpenBrace) - return parseCompoundStatement(); - return parseStatement(); - } + require(Tok.CloseParentheses); // Remove the ")" + } - /** - Parses a function-body or similar, expects an opening brace to be the - current token. + /** + Parse either a block, or a single statement as allowed after if, while + and for. + */ + Stmt parseSingleOrCompoundStatement() + { + if (peek.type == Tok.OpenBrace) + return parseCompoundStatement(); + return parseStatement(); + } + + /** + Parses a function-body or similar, expects an opening brace to be the + current token. - Will consume both the starting { and ending } - */ - Stmt parseCompoundStatement() - { - Token lbrace = require(Tok.OpenBrace); - SmallArray!(Stmt, 32) stmts; // Try to use the stack only - while ( !isa(Tok.CloseBrace) && !isa(Tok.EOF) ) - stmts ~= parseStatement(); - Token rbrace = require(Tok.CloseBrace); - return action.actOnCompoundStmt(lbrace, rbrace, stmts.unsafe()); - } + Will consume both the starting { and ending } + */ + Stmt parseCompoundStatement() + { + Token lbrace = require(Tok.OpenBrace); + SmallArray!(Stmt, 32) stmts; // Try to use the stack only + while ( !isa(Tok.CloseBrace) && !isa(Tok.EOF) ) + stmts ~= parseStatement(); + Token rbrace = require(Tok.CloseBrace); + return action.actOnCompoundStmt(lbrace, rbrace, stmts.unsafe()); + } - Id parseIdentifier() - { - Token tok = next(); + Id parseIdentifier() + { + Token tok = next(); - if (tok.type is Tok.Identifier) - return Id(tok); + if (tok.type is Tok.Identifier) + return Id(tok); - messages.report(UnexpectedTokSingle, tok.location) - .arg(tok.getType) - .arg(Tok.Identifier); - } + 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; + 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; - } + while (!skip(Tok.Seperator)) + next(); + return mod; + } - /** - Parse a type - this includes pointer and array(at some point) types. - */ - Id parseType() - { - Token type = next(); + /** + Parse a type - this includes pointer and array(at some point) types. + */ + Id parseType() + { + Token type = next(); - Id currentType; + Id currentType; - if ( !(type.isBasicType || type.type == Tok.Identifier) ) - messages.report(InvalidType, type.location); + if ( !(type.isBasicType || type.type == Tok.Identifier) ) + messages.report(InvalidType, type.location); - currentType = Id(type); - type = peek; + 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); + 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; - } + } + type = peek; + } - return currentType; - } + return currentType; + } - int peekParseType() - { - int i; - Token type = peek(i); + int peekParseType() + { + int i; + Token type = peek(i); - Id currentType; + Id currentType; - if ( !(type.isBasicType || type.type == Tok.Identifier) ) - return 0; + if ( !(type.isBasicType || type.type == Tok.Identifier) ) + return 0; - currentType = Id(type); - type = peek(++i); + 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; + 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); - } + } + type = peek(i); + } - return 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; - } - } + // -- 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(); - } + 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; - } + 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(); - } + 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); + 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); + 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; - } + 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); + 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); - } + require(Tok.CloseParentheses); + auto exp = P(); + return action.actOnCastExpr(_cast, Id(n), exp); + } - struct UnOp - { - Tok tokenType; - int prec; - } + 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; - } + 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; - } + 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}, + 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 + // =, += 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.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.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.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.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; - } + {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(); - } + 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 skip(Tok t) + { + if (peek().type != t) + return false; + next(); + return true; + } - bool isa(Tok t) - { - return peek.type == t; - } + bool isa(Tok t) + { + return peek.type == t; + } - Token next() - { - return lexer.next; - } + Token next() + { + return lexer.next; + } - Token peek(int i = 0) - { - return lexer.peek(i); - } + Token peek(int i = 0) + { + return lexer.peek(i); + } - Lexer lexer; - SourceManager sm; + Lexer lexer; + SourceManager sm; }