C# Parser.Consume方法代码示例

        public override Statement Parse(Parser parser, Lexer.Token current)
        {
            string name = null;

            if (parser.Peek().Type == "IDENTIFIER")
            {
                name = parser.Current.Lexeme;
                parser.Consume("IDENTIFIER");
            }

            parser.Consume("LEFTPAREN");
            var parameters = ParseParameterList(parser).ToArray();
            parser.Consume("RIGHTPAREN");

            var token = parser.Peek();

            if (token.Type == "LEFTBRACE")
            {
                var body = parser.ParseNext();
                return new FunctionDefinitionExpr(new IdentifierExpr(name), parameters, (Statement)body,
                    new IdentifierExpr("UNKNOWN"));
            }
            else if (token.Type == "RIGHTARROW")
            {
                parser.Consume("RIGHTARROW");
                var body = parser.ParseExpression(0);
                parser.Consume("SEMICOLON");
                return new LambdaDefinitionExpr(new IdentifierExpr(name), parameters, body,
                    new IdentifierExpr("UNKNOWN"));
            }

            throw new ParseException("Malformed function defintion");
        }

        private string ParseTypeSpecified(Parser parser)
        {
            parser.Consume("COLON");

            var type = parser.Current.Lexeme;

            parser.Consume("IDENTIFIER");

            return type;
        }

        public override Statement Parse(Parser parser, Lexer.Token current)
        {
            parser.Consume("LEFTPAREN");
            var condition = parser.ParseExpression(0);
            parser.Consume("RIGHTPAREN");

            var trueBlock = ParseStatement(parser);

            var falseBlock = parser.ConsumeOptional("ELSE") ? ParseStatement(parser) : null;

            return new IfStmt(condition, trueBlock, falseBlock);
        }

        public override Statement Parse(Parser parser, Lexer.Token current)
        {
            string name = parser.Current.Lexeme;
            parser.Consume("IDENTIFIER");

            parser.Consume("LEFTBRACE");

            var statements = parser.ParseNext();

            parser.Consume("RIGHTBRACE");

            return new ClassDefinitionStmt(new IdentifierExpr(name), statements);
        }

 /// <summary>
 /// <inheritDoc/>
 /// <p>The default implementation resynchronizes the parser by consuming tokens
 /// until we find one in the resynchronization set--loosely the set of tokens
 /// that can follow the current rule.</p>
 /// </summary>
 public virtual void Recover(Parser recognizer, RecognitionException e)
 {
     //		System.out.println("recover in "+recognizer.getRuleInvocationStack()+
     //						   " index="+recognizer.getInputStream().index()+
     //						   ", lastErrorIndex="+
     //						   lastErrorIndex+
     //						   ", states="+lastErrorStates);
     if (lastErrorIndex == ((ITokenStream)recognizer.InputStream).Index && lastErrorStates != null && lastErrorStates.Contains(recognizer.State))
     {
         // uh oh, another error at same token index and previously-visited
         // state in ATN; must be a case where LT(1) is in the recovery
         // token set so nothing got consumed. Consume a single token
         // at least to prevent an infinite loop; this is a failsafe.
         //			System.err.println("seen error condition before index="+
         //							   lastErrorIndex+", states="+lastErrorStates);
         //			System.err.println("FAILSAFE consumes "+recognizer.getTokenNames()[recognizer.getInputStream().LA(1)]);
         recognizer.Consume();
     }
     lastErrorIndex = ((ITokenStream)recognizer.InputStream).Index;
     if (lastErrorStates == null)
     {
         lastErrorStates = new IntervalSet();
     }
     lastErrorStates.Add(recognizer.State);
     IntervalSet followSet = GetErrorRecoverySet(recognizer);
     ConsumeUntil(recognizer, followSet);
 }

        public override Statement Parse(Parser parser, Lexer.Token current)
        {
            parser.Consume("LEFTPAREN");
            var condition = parser.ParseExpression(0);
            parser.Consume("RIGHTPAREN");

            var block = ParseStatement(parser);// parser.ParseNext();

            if (!(block is Statement))
                throw new ParseException("Invalid statement in block.");
            /*
            if (!(block is IBlockStatement))
                parser.Consume("SEMICOLON");
            */
            return new WhileStmt(condition, block as Statement);
        }

        public IExpression Parse(Parser parser, IExpression left, Token token)
        {
            var thenArm = parser.ParseExpression();
            parser.Consume(TokenType.Colon);
            var elseArm = parser.ParseExpression(Precedence.Conditional - 1);

            return new ConditionalExpression(left, thenArm, elseArm);
        }

        public Expression Parse(Parser parser, Expression lhs, Token current)
        {
            var thenExpression = parser.ParseNext();

            parser.Consume("COLON");

            var elseExpression = parser.ParseExpression(Precedence - 1);

            return new ConditionalExpr(lhs, thenExpression, elseExpression);
        }

        public Expression Parse(Parser parser, Expression lhs, Token current)
        {
            var functionName = ((IdentifierExpr) lhs);

            // we should already be on the leftparen token.
            var arguments = ParseArguments(parser).ToArray();

            parser.Consume("RIGHTPAREN");

            return new FunctionCallExpr(functionName, arguments);
        }

        public override Statement Parse(Parser parser, Lexer.Token current)
        {
            var name = parser.Current.Lexeme;

            parser.Consume("IDENTIFIER");

            string type = null;
            if (parser.Peek().Type == "COLON")
                type = ParseTypeSpecified(parser);

            Expression initialValue = null;
            if (parser.ConsumeOptional("ASSIGNMENT"))
                initialValue = parser.ParseExpression(0);
            else if(_constVariables)
                throw  new ParseException("Const variable declarations must have an initialiser.");

            parser.Consume("SEMICOLON");

            return new VarDefinitionStmt(new IdentifierExpr(name), new IdentifierExpr(type), _constVariables, initialValue);
        }

        private IEnumerable<Expression> ParseArguments(Parser parser)
        {
            if (parser.Peek().Type == "RIGHTPAREN")
                yield break;

            while (true)
            {
                yield return parser.ParseExpression(0);

                if (parser.Peek().Type == "RIGHTPAREN")
                    yield break;

                parser.Consume("COMMA");
            }
        }

        public override Expression Parse(Parser p, Expression left, Token t)
        {
            var exp = new CallExpr();
            exp.CallTargetExpr = left;
            exp.Position = left.Position;

            if (p.Match(TokenType.RParen))
                return exp;

            do
            {
                exp.ArgumentExprs.Add(p.ParseExpression());
            } while (p.Match(TokenType.Comma));
            p.Consume(TokenType.RParen);

            return exp;
        }

        public IExpression Parse(Parser parser, IExpression left, Token token)
        {
            // Parse the comma-separated arguments until we hit, ")".
            var args = new List<IExpression>();
    
            // There may be no arguments at all.
            if (!parser.Match(TokenType.RightParen))
            {
                do
                {
                    args.Add(parser.ParseExpression());
                } 
                while (parser.Match(TokenType.Comma));
                
                parser.Consume(TokenType.RightParen);
            }

            return new CallExpression(left, args);
        }

        private List<VarDefinitionStmt> ParseParameterList(Parser parser)
        {
            var parameters = new List<VarDefinitionStmt>();

            if (parser.Peek().Type == "RIGHTPAREN")
                return parameters;

            while (true)
            {
                var name = parser.ParseExpression(0);

                if(!(name is IdentifierExpr))
                    throw new ParseException("Expected parameter name");

                Expression type = null;
                if (parser.ConsumeOptional("COLON"))
                {
                    type = parser.ParseExpression(0);

                    if (!(type is IdentifierExpr))
                        throw new ParseException("Expected parameter type");

                }
                else
                {
                    type = new IdentifierExpr("dynamic");
                }

                parameters.Add(new VarDefinitionStmt((IdentifierExpr)name, (IdentifierExpr)type, false, null));

                if (parser.Peek().Type == "RIGHTPAREN")
                    break;

                parser.Consume("COMMA");
            }

            return parameters;
        }

 /// <summary>Consume tokens until one matches the given token set.</summary>
 protected internal virtual void ConsumeUntil(Parser recognizer, IntervalSet set)
 {
     //		System.err.println("consumeUntil("+set.toString(recognizer.getTokenNames())+")");
     int ttype = ((ITokenStream)recognizer.InputStream).La(1);
     while (ttype != TokenConstants.Eof && !set.Contains(ttype))
     {
         //System.out.println("consume during recover LA(1)="+getTokenNames()[input.LA(1)]);
         //			recognizer.getInputStream().consume();
         recognizer.Consume();
         ttype = ((ITokenStream)recognizer.InputStream).La(1);
     }
 }