private void CreateAcceptAction(ParserState initialState, NonTerminal augmentedRoot)
 {
     var root = augmentedRoot.Productions[0].RValues[0];
     var shiftAction = initialState.Actions[root] as ShiftParserAction;
     var shiftOverRootState = shiftAction.NewState;
     shiftOverRootState.Actions[_grammar.Eof] = new AcceptParserAction();
 }

 public CParser(ParserState parserState, CLexer lexer)
 {
     this.ParserState = parserState;
     this.lexer = new LookAheadLexer(
         new CDirectiveLexer(parserState, lexer));
     this.grammar = new CGrammar();
 }

        public void BuildIfStatement()
        {
            var grammer = new AndyStructuralGrammar();
            var p = new ParserState("if");

            Assert.That(grammer.if_keyword.Match(p), Is.True);

            p = new ParserState("if()");
            var rule = grammer.if_keyword + grammer.Delimiter("(") + grammer.Delimiter(")");
            Assert.That(rule.Match(p), Is.True);

            p = new ParserState("if (a == b)");
            Assert.That(grammer.if_condition.Match(p), Is.True);

            p = new ParserState("if(a == 10){a=20;}");
            var if_block = grammer.if_condition + grammer.block;
            Assert.That(if_block.Match(p), Is.True);

            p = new ParserState("if(a == 10){a=20;}");
            if_block = grammer.if_condition + new RecursiveRule(() => grammer.block);
            Assert.That(if_block.Match(p), Is.True);

            p = new ParserState("if(a == 10){a=20;}");
            Assert.That(grammer.control_statement.Match(p), Is.True);
        }

 public List<Node> Parse(string input)
 {
     var state = new ParserState() { input = input, pos = 0 };
     if (!Match(state))
         throw new Exception(String.Format("Rule {0} failed to match", Name));
     return state.nodes;
 }

 public ActionRecord(ParserActionType actionType, ParserState newState, NonTerminal nonTerminal, int popCount)
 {
   ActionType = actionType;
   NewState = newState;
   NonTerminal = nonTerminal;
   PopCount = popCount;
 }

        public bool Execute(ParserState state)
        {
            var builder = new StringBuilder();

            for (var i = 0; i < base.Children.Count; i++)
            {
                var action = base.Children[i];
                var subState = state.Clone();
                subState.CurrentItem = string.Empty;
                if (!action.Execute(subState))
                {
                    logger.LogDebug($"{state.Tracker} Http sub {i} action failed.");
                    return false;
                }
                else
                {
                    builder.Append(state.CurrentItem);
                }
            }

            var value = builder.ToString();
            logger.LogDebug($"{state.Tracker} Http setting {name} to {value}.");
            state.HTTPHeaders[name] = value;
            return true;
        }

        public ParseResult Parse(Lexer lexer, ParserState initialState)
        {
            var context = new ParserContext(this, Automaton.Grammar, lexer);
            context.CurrentState = initialState;
            context.ParserStack.Push(new ParserNode(context, new GrammarDefinition("init"))
            {
                State = initialState
            });

            ReadNextToken(context);
            context.CurrentNode = new ParserNode(context, Automaton.Grammar.ToElement(lexer.Current.GetTokenCode()), lexer.Current);

            while (lexer.Current != null && context.Root == null && context.CurrentState != null)
            {
                // If no input and no default action (e.g. a grammar reduction),
                // that means we have to read the next token.
                if (context.CurrentNode == null && context.CurrentState.DefaultAction == null)
                    ReadNextToken(context);

                var action = GetNextAction(context);
                action.Execute(context);
            }

            lexer.SpecialBag.InsertNodesIntoAstNode(context.Root.Result);

            return ParseResult.FromContext(context);
        }

 public GrammarReductionConflict(ParserState state, TokenGrammarElement lookahead, ParserAction action1, ParserAction action2)
 {
     State = state;
     Lookahead = lookahead;
     Action1 = action1;
     Action2 = action2;
 }

        private bool IncludeBinary(List<string> tokens, ParserState state)
        {
            if (tokens.Count == 1)
                throw new Exception(string.Format("No file specified for .incbin pragma", tokens[1]));

            tokens[1] = tokens[1].Replace("\"", string.Empty);

            byte[] data = GetBytesFromFile(state.WorkingDirectory + @"\" + tokens[1]);
            if (data == null)
                throw new Exception($"Error loading file '{tokens[1]}'");

            int begin = 0, length = data.Length;
            if (tokens.Count >= 3)
                if (!Int32.TryParse(tokens[2], out begin))
                    throw new Exception("Third paramter for incbin must be numeric");

            if (tokens.Count == 3)
            {
                length = length - begin;
            }

            if (tokens.Count == 4)
                if (!Int32.TryParse(tokens[3], out length))
                    throw new Exception("Fourth paramter for incbin must be numeric");

            if ((begin >= length) || (begin + length > data.Length))
                throw new Exception("Out of bounds for incbin");

            for (int i = 0; i < length; i++)
                state.Code.Add(data[i + begin]);
            return true;
        }

    public ShiftParserAction(BnfTerm term, ParserState newState) {
      if (newState == null)
        throw new Exception("ParserShiftAction: newState may not be null. term: " + term.ToString());

      Term = term; 
      NewState = newState;
    }

 /// <summary>
 /// Indicates if the current parser state matches the rule.
 /// </summary>
 /// <param name="state">The state.</param>
 /// <returns></returns>
 public override bool Match(ParserState state)
 {
     while (this.FirstSon.Match(state))
     {
     }
     return true;
 }

 public PrecedenceBasedParserAction(BnfTerm shiftTerm, ParserState newShiftState, Production reduceProduction)
 {
     _reduceAction = new ReduceParserAction(reduceProduction);
     var reduceEntry = new ConditionalEntry(CheckMustReduce, _reduceAction, "(Precedence comparison)");
     ConditionalEntries.Add(reduceEntry);
     DefaultAction = _shiftAction = new ShiftParserAction(shiftTerm, newShiftState);
 }

  public XmlConverter(TextReader rdr, XmlWriter writer, IPlatform platform)
  {
      this.rdr = rdr;
      this.writer = writer;
      this.platform = platform;
      this.parserState = new ParserState();
 }

 protected override bool InternalMatch(ParserState state)
 {
     var old = state.Clone();
     bool result = Child.Match(state);
     state.Assign(old);
     return result;
 }

        public static ParserState Parse(string source, IAbstractSyntaxTreePrinter printer = null, Rule rule = null)
        {
            if (rule == null)
                rule = _grammar.file;

            var state = new ParserState(source);
            try
            {
                if (rule.Match(state))
                {
                    if (state.AtEndOfInput())
                    {
                        if (printer != null)
                            printer.Print(state.GetRoot());

                        return state;
                    }

                    throw new ParsingException(state, rule, message: "Failed to read end of input");
                }

                throw new ParsingException(state, rule, message: "Failed to parse source");
            }
            catch (ParsingException e)
            {
                return state.Exception(e);
            }
        }

        public CppFileParser(IAstPrinter printer, string file)
        {
            Rule parse_rule = grammar.file;

            string text = File.ReadAllText(file);
            printer.Clear();
            ParserState state = new ParserState(text);

            try
            {
                if (!parse_rule.Match(state))
                {
                    message = "Failed to parse file " + file;
                }
                else
                {
                    if (state.AtEndOfInput())
                    {
                        message = "Successfully parsed file";
                    }
                    else
                    {
                        message = "Failed to read end of input";
                    }
                }
                    
            }
            catch (ParsingException e)
            {
                state.ForceCompletion();
                message = e.Message;
            }

            printer.PrintNode(state.GetRoot(), 0);
        }

        private static IParseResult ParseDocEscapedChar(ParserState state)
        {
            state.Advance();
              if (char.IsLetterOrDigit(state.Current))
            return FailedParse.Get;

              return new SuccessfulParse(state.Current.ToString());
        }

 /// <summary>
 /// Indicates if the current parser state matches the rule.
 /// </summary>
 /// <param name="state">The state.</param>
 /// <returns></returns>
 public override bool Match(ParserState state)
 {
     if (this.Sons.Count == 0)
     {
         this.Sons.Add(ruleFunction());
     }
     return this.FirstSon.Match(state);
 }

 /// <summary>
 /// Indicates if the current parser state matches the rule.
 /// </summary>
 /// <param name="state">The state.</param>
 /// <returns></returns>
 public override bool Match(ParserState state)
 {
     if (!state.CurrentInput.StartsWith(this.value))
     {
         return false;
     }
     state.CurrentPosition = state.CurrentPosition + this.value.Length;
     return true;
 }

        private int ParseLabel(string line, ParserState state)
        {
            int colonPos = line.IndexOf(':');
            string labelName = line.Substring(0, colonPos);

            if (!state.Scopes.AddLabel(labelName.Trim().ToLowerInvariant(), state.Code.Count))
                throw new Exception($"Error adding label '{labelName}'");
            return colonPos + 1;
        }