public static PipelineNode GetPipeline(Parser theParser) { PipelineNode pipeline = null; if (theParser != null) { object objLeft = theParser.GetReductionSyntaxNode(0); object objRight = theParser.GetReductionSyntaxNode(2); if (objLeft is PipelineNode) { pipeline = (PipelineNode)objLeft; pipeline.AddItem(objRight as ASTNode); } else if (objRight is PipelineNode) { pipeline = (PipelineNode)objRight; pipeline.Insert(0, objLeft as ASTNode); } } if (pipeline == null) { pipeline = new PipelineNode(theParser); if (theParser != null) { pipeline.AddItemFromParser(theParser, 0); pipeline.AddItemFromParser(theParser, 2); } } return pipeline; }
public static ParamsListNode GetParamsList(Parser theParser) { ParamsListNode paramsList = null; if (theParser != null) { object objLeft = theParser.GetReductionSyntaxNode(0); object objRight = theParser.GetReductionSyntaxNode(1); if (objLeft is ParamsListNode) { paramsList = (ParamsListNode)objLeft; paramsList.AddParam(objRight); } else if (objRight is ParamsListNode) { paramsList = (ParamsListNode)objRight; paramsList.Insert(0, objLeft); } } if (paramsList == null) { paramsList = new ParamsListNode(theParser); if (theParser != null) { paramsList.AddParamFromParser(theParser, 0); paramsList.AddParamFromParser(theParser, 1); } } return paramsList; }
public static ParamsListNode GetParamsListFromRight(Parser theParser) { object objRight = theParser.GetReductionSyntaxNode(1); ParamsListNode paramsList = null; if (objRight is ParamsListNode) { paramsList = (ParamsListNode)objRight; } else { paramsList = new ParamsListNode(theParser); paramsList.AddParamFromParser(theParser, 1); } return paramsList; }
/// <summary> /// Runs a custom "C++ Header" grammar on a preprocessed and transformed file to produce /// a tree of source elements in memory. /// </summary> /// <param name="file">The preprocessed source file.</param> public NonTerminal Parse(string file) { using (var stream = new StreamReader(file)) { var parser = new Parser(stream, grammar); parser.TrimReductions = true; while (true) { var result = parser.Parse(); switch (result) { case ParseMessage.InternalError: throw new InvalidOperationException("Internal error in parser"); case ParseMessage.LexicalError: throw new InvalidOperationException(string.Format("Lexical error: (line:{0}) {1}", parser.TokenLineNumber, parser.TokenText)); case ParseMessage.SyntaxError: throw new InvalidOperationException(string.Format("Syntax error: (line:{0}) {1}\n -- Expected: {2}", parser.LineNumber, parser.LineText, string.Join<Symbol>(", ", parser.GetExpectedTokens()))); case ParseMessage.TokenRead: var terminal = new Terminal(parser.TokenSymbol, parser.TokenText); parser.TokenSyntaxNode = terminal; break; case ParseMessage.Reduction: var nonTerminal = new NonTerminal(parser.ReductionRule); parser.TokenSyntaxNode = nonTerminal; for (int i = 0; i < parser.ReductionCount; i++) nonTerminal.Add(parser.GetReductionSyntaxNode(i)); break; case ParseMessage.Accept: return parser.TokenSyntaxNode as NonTerminal; } } } }
public bool Parse(TextReader sourceReader) { Debug.Assert(sourceReader != null); m_parser = ParserFactory.CreateParser(sourceReader); m_parser.TrimReductions = true; while (true) { switch (m_parser.Parse()) { case ParseMessage.LexicalError: ErrorString = string.Format("Lexical Error. Line {0}. Token {1} was not expected.", m_parser.LineNumber, m_parser.TokenText); return false; case ParseMessage.SyntaxError: StringBuilder text = new StringBuilder(); foreach (Symbol tokenSymbol in m_parser.GetExpectedTokens()) text.AppendFormat(" {0}", tokenSymbol); ErrorString = string.Format("Syntax Error. Line {0}. Expecting: {1}.", m_parser.LineNumber, text); return false; case ParseMessage.Reduction: NonTerminalNode nonTerminal = SyntaxRuleFactory.CreateNode(m_parser.ReductionRule); m_parser.TokenSyntaxNode = nonTerminal; for (int i = 0; i < m_parser.ReductionCount; i++) nonTerminal.AppendChildNode(m_parser.GetReductionSyntaxNode(i) as SyntaxNode); // post parsing syntax check (used to do things like segregate the difference between HAVING and WHERE // expressions in terms of the validtity of aggregate expressions) nonTerminal.CheckSyntax(); break; case ParseMessage.TokenRead: m_parser.TokenSyntaxNode = new TerminalNode(m_parser); break; case ParseMessage.Accept: SyntaxTree = m_parser.TokenSyntaxNode as NonTerminalNode; ErrorString = null; return true; case ParseMessage.InternalError: ErrorString = "Internal Error. Something is horribly wrong."; return false; case ParseMessage.NotLoadedError: ErrorString = "Grammar Table is not loaded."; return false; case ParseMessage.CommentError: ErrorString = "Comment Error. Unexpected end of input."; return false; case ParseMessage.CommentBlockRead: case ParseMessage.CommentLineRead: // don't do anything break; } } }
private ComplexSyntaxNode ParseImpl(TextReader xpidlTextReader) { var goldParser = new GoldParser.Parser(xpidlTextReader, m_Grammar) { TrimReductions = true, IgnoreNestedComments = true }; goldParser.AddCommentSymbols( new Regex(@"^\/\*$", RegexOptions.Singleline), // /* new Regex(@"^\*\/$", RegexOptions.Singleline)); // */ goldParser.AddCommentSymbols( new Regex(@"^\%\{\s*C\+\+$", RegexOptions.Singleline), // %{ C++ new Regex(@"^\%\}(\s*C\+\+)?$", RegexOptions.Singleline)); // %} C++ var rootSyntaxNode = new ComplexSyntaxNode(null); while (true) { ParseMessage parseMessage = goldParser.Parse(); switch (parseMessage) { case ParseMessage.Empty: break; // Comment or inline C header case ParseMessage.CommentLineRead: case ParseMessage.CommentBlockRead: var commentSyntaxNode = new CommentSyntaxNode(goldParser.CommentText); if (goldParser.TokenSyntaxNode == null) { rootSyntaxNode.AddChildNode(commentSyntaxNode); } else { ((SyntaxNode)goldParser.TokenSyntaxNode).AttachCommentNode(commentSyntaxNode); } break; // Read valid token case ParseMessage.TokenRead: var simpleSyntaxNode = new SimpleSyntaxNode(goldParser.TokenSymbol, goldParser.TokenText); goldParser.TokenSyntaxNode = simpleSyntaxNode; break; // Can create new xpidl-node case ParseMessage.Reduction: var complexSyntaxNode = new ComplexSyntaxNode(goldParser.ReductionRule); for (Int32 i = 0; i < goldParser.ReductionCount; ++i) { var syntaxNode = (SyntaxNode)goldParser.GetReductionSyntaxNode(i); complexSyntaxNode.AddChildNode(syntaxNode); if (i == (goldParser.ReductionCount - 1)) { complexSyntaxNode.ReattachCommentNodes(syntaxNode); } else { syntaxNode.DetachCommentNodes(complexSyntaxNode); } } goldParser.TokenSyntaxNode = complexSyntaxNode; break; // Parsing successfully completed case ParseMessage.Accept: var acceptedSyntaxNode = (SyntaxNode)goldParser.TokenSyntaxNode; Debug.Assert(acceptedSyntaxNode != null); rootSyntaxNode.AddChildNode(acceptedSyntaxNode); acceptedSyntaxNode.DetachCommentNodes(rootSyntaxNode); return rootSyntaxNode; // Grammar table is not loaded case ParseMessage.NotLoadedError: throw new XpidlParserException("Grammar not loaded"); // Unexpected end of input case ParseMessage.CommentError: throw new XpidlParserException("Comment error"); // Invalid token case ParseMessage.LexicalError: throw new XpidlParserSyntaxException("Can not recognize token", goldParser.TokenText, goldParser.LineNumber, goldParser.LinePosition); // Unexpected token case ParseMessage.SyntaxError: throw new XpidlParserSyntaxException("Unexpected token", goldParser.TokenText, goldParser.LineNumber, goldParser.LinePosition); // Fatal internal error case ParseMessage.InternalError: throw new XpidlParserException("Internal parser error"); } } }