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 GrammarReductionConflict(ParserState state, TokenGrammarElement lookahead, ParserAction action1, ParserAction action2) { State = state; Lookahead = lookahead; Action1 = action1; Action2 = action2; }
public CParser(ParserState parserState, CLexer lexer) { this.ParserState = parserState; this.lexer = new LookAheadLexer( new CDirectiveLexer(parserState, lexer)); this.grammar = new CGrammar(); }
public XmlConverter(TextReader rdr, XmlWriter writer, IPlatform platform) { this.rdr = rdr; this.writer = writer; this.platform = platform; this.parserState = new ParserState(); }
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 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); }
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 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 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); } }
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; }
public ActionRecord(ParserActionType actionType, ParserState newState, NonTerminal nonTerminal, int popCount) { ActionType = actionType; NewState = newState; NonTerminal = nonTerminal; PopCount = popCount; }
/// <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); }
protected override bool InternalMatch(ParserState state) { var old = state.Clone(); bool result = Child.Match(state); state.Assign(old); return result; }
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; }
private static IParseResult ParseDocEscapedChar(ParserState state) { state.Advance(); if (char.IsLetterOrDigit(state.Current)) return FailedParse.Get; return new SuccessfulParse(state.Current.ToString()); }
private void Reset() { _stack.Reset(); _currentState = Data.InitialState; _currentLine = 0; _tokenCount = 0; _context.Errors.Clear(); }
/// <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); }
private void InitBlock() { nodeTree = new ParserState(); directives = null; jj_la1 = new int[53]; jj_2_rtns = new Calls[12]; jj_expentries = new ArrayList(); jj_lasttokens = new int[100]; }
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; }
/// <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; }
public static bool TryParseComponents(string uri, UriKind kind, out UriElements elements, out string error) { uri = uri.Trim(); ParserState state = new ParserState(uri, kind); elements = state.elements; error = null; if (uri.Length == 0 && (kind == UriKind.Relative || kind == UriKind.RelativeOrAbsolute)) { state.elements.isAbsoluteUri = false; return true; } if (uri.Length <= 1 && kind == UriKind.Absolute) { error = "Absolute URI is too short"; return false; } bool ok = ParseFilePath(state) && ParseScheme(state); var scheme = state.elements.scheme; UriParser parser = null; if (!StringUtilities.IsNullOrEmpty(scheme)) { parser = UriParser.GetParser(scheme); if (parser != null && !(parser is DefaultUriParser)) return true; } ok = ok && ParseAuthority(state) && ParsePath(state) && ParseQuery(state) && ParseFragment(state); if (StringUtilities.IsNullOrEmpty(state.elements.host) && (scheme == Uri.UriSchemeHttp || scheme == Uri.UriSchemeGopher || scheme == Uri.UriSchemeNntp || scheme == Uri.UriSchemeHttps || scheme == Uri.UriSchemeFtp)) state.error = "Invalid URI: The Authority/Host could not be parsed."; if (!StringUtilities.IsNullOrEmpty(state.elements.host) && Uri.CheckHostName(state.elements.host) == UriHostNameType.Unknown) state.error = "Invalid URI: The hostname could not be parsed."; if (!StringUtilities.IsNullOrEmpty(state.error)) { elements = null; error = state.error; return false; } return true; }
public bool Execute(ParserState state) { logger.LogDebug($"{state.Tracker} ExtractOne has {base.Children.Count} child actions."); foreach(var item in base.Children) { if(item.Execute(state)) return true; } return true; }
public bool Execute(ParserState state) { foreach (var action in base.Children) { if (!action.Execute(state)) return false; } return true; }
public void ParseMemoryAddress(string value, bool expected) { var grammer = new AsmBaseGrammar(); var p = new ParserState(value); Assert.That(grammer.memoryAddress.Match(p), Is.EqualTo(expected)); ParseNode node = p.GetRoot(); Console.WriteLine(node.Value); }
public Assembler(string source) : this() { var parser = new ParserState(source); bool match = _grammar.program.Match(parser); if (match == false) throw new Exception("Cannot parse source file"); _root = parser.GetRoot(); }
/// <summary> /// Initializes a new instance of the <see cref="Token"/> class. /// </summary> /// <param name="name">The name.</param> /// <param name="state">The state.</param> /// <exception cref="System.ArgumentNullException">Name of node cannot be null</exception> public Token(string name, ParserState state) { if (name == null) { throw new ArgumentNullException("Name of node cannot be null"); } this.Name = name; this.Input = state.Input; this.Begin = state.CurrentPosition; this.Tokens = new List<Token>(); }
public void ParseLine(string value, bool expected) { var grammer = new AsmStructuralGrammar(); var p = new ParserState(value); Assert.That(grammer.line.Match(p), Is.EqualTo(expected)); var printer = new CppStructuralOutputAsXml(); printer.Print(p.GetRoot()); Console.WriteLine(printer.AsXml()); }
public void ParseOpCode(string value, bool expected) { var grammer = new AsmBaseGrammar(); var printer = new CppStructuralOutputAsXml(); var p = new ParserState(value); Assert.That(grammer.opcode.Match(p), Is.EqualTo(expected)); ParseNode node = p.GetRoot(); Console.WriteLine(node.Value); }
public ParserEventArgs(ParserState state) { _state = state; }
/// <summary> /// Parse the productions: /// implicit_document ::= block_node DOCUMENT-END* /// * /// explicit_document ::= DIRECTIVE* DOCUMENT-START block_node? DOCUMENT-END* /// ************************* /// </summary> private ParsingEvent ParseDocumentStart(bool isImplicit) { if (currentToken is VersionDirective) { // EB22 throw new SyntaxErrorException("While parsing a document start node, could not find document end marker before version directive."); } // Parse extra document end indicators. var current = GetCurrentToken(); if (!isImplicit) { while (current is DocumentEnd) { Skip(); current = GetCurrentToken(); } } if (current == null) { throw new SyntaxErrorException("Reached the end of the stream while parsing a document start."); } if (current is Scalar && (state == ParserState.ImplicitDocumentStart || state == ParserState.DocumentStart)) { isImplicit = true; } // Parse an isImplicit document. if (isImplicit && !(current is VersionDirective || current is TagDirective || current is DocumentStart || current is StreamEnd || current is DocumentEnd) || current is BlockMappingStart) { var directives = new TagDirectiveCollection(); ProcessDirectives(directives); states.Push(ParserState.DocumentEnd); state = ParserState.BlockNode; return(new Events.DocumentStart(null, directives, true, current.Start, current.End)); } // Parse an explicit document. else if (!(current is StreamEnd || current is DocumentEnd)) { var start = current.Start; var directives = new TagDirectiveCollection(); var versionDirective = ProcessDirectives(directives); current = GetCurrentToken() ?? throw new SemanticErrorException("Reached the end of the stream while parsing a document start"); if (!(current is DocumentStart)) { throw new SemanticErrorException(current.Start, current.End, "Did not find expected <document start>."); } states.Push(ParserState.DocumentEnd); state = ParserState.DocumentContent; var end = current.End; Skip(); return(new Events.DocumentStart(versionDirective, directives, false, start, end)); } // Parse the stream end. else { if (current is DocumentEnd) { Skip(); } state = ParserState.StreamEnd; current = GetCurrentToken() ?? throw new SemanticErrorException("Reached the end of the stream while parsing a document start"); var evt = new Events.StreamEnd(current.Start, current.End); // Do not call skip here because that would throw an exception if (scanner.MoveNextWithoutConsuming()) { throw new InvalidOperationException("The scanner should contain no more tokens."); } return(evt); } }
public bool Parse() { if (isOK) { return(true); } bool finish = false; while (!finish) { switch (state) { case ParserState.PacketSize: if (buffer.Length < packetSizeLength) { finish = true; } else { buffer.Read(memoryStream.GetBuffer(), 0, packetSizeLength); switch (packetSizeLength) { case Packet.PacketSizeLength4: packetSize = BitConverter.ToInt32(memoryStream.GetBuffer(), 0); if (packetSize > ushort.MaxValue * 16 || packetSize < Packet.MinPacketSize) { throw new Exception($"recv packet size error, 可能是外网探测端口: {packetSize}"); } break; case Packet.PacketSizeLength2: packetSize = BitConverter.ToUInt16(memoryStream.GetBuffer(), 0); if (packetSize > ushort.MaxValue || packetSize < Packet.MinPacketSize) { throw new Exception($"recv packet size error:, 可能是外网探测端口: {packetSize}"); } break; default: throw new Exception("packet size byte count must be 2 or 4!"); } state = ParserState.PacketBody; } break; case ParserState.PacketBody: if (buffer.Length < packetSize) { finish = true; } else { memoryStream.Seek(0, SeekOrigin.Begin); memoryStream.SetLength(packetSize); byte[] bytes = memoryStream.GetBuffer(); buffer.Read(bytes, 0, packetSize); isOK = true; state = ParserState.PacketSize; finish = true; } break; } } return(isOK); }