public void TestConflictGrammarWithHintsOnRules() { var grammar = new ConflictGrammarWithHintsInRules(); var parser = new Parser(grammar); Assert.True(parser.Language.Errors.Count == 0); // Field sample var sample = FieldSample; var tree = parser.Parse(sample); Assert.NotNull(tree); Assert.False(tree.HasErrors()); Assert.NotNull(tree.Root); var term = tree.Root.Term as NonTerminal; Assert.NotNull(term); Assert.Equal("definition", term.Name); Assert.Equal(1, tree.Root.ChildNodes.Count); var modNode = tree.Root.ChildNodes[0].ChildNodes[0]; Assert.Equal("fieldModifier", modNode.Term.Name); //Property sample = PropertySample; tree = parser.Parse(sample); Assert.NotNull(tree); Assert.False(tree.HasErrors()); Assert.NotNull(tree.Root); term = tree.Root.Term as NonTerminal; Assert.NotNull(term); Assert.Equal("definition", term.Name); Assert.Equal(1, tree.Root.ChildNodes.Count); modNode = tree.Root.ChildNodes[0].ChildNodes[0]; Assert.Equal("propModifier", modNode.Term.Name); }
public Ast.Block ParseString(string Chunk) { ParseTree parseTree = parser.Parse(Chunk); ParseTreeNode root = parseTree.Root; if (root == null) { Irony.LogMessage msg = parseTree.ParserMessages[0]; throw new LuaException("", msg.Location.Line, msg.Location.Column, msg.Message); } return(ParseBlock(root)); }
public void TestErrorRecovery() { var grammar = new ErrorRecoveryGrammar(); var parser = new Parser(grammar); TestHelper.CheckGrammarErrors(parser); //correct sample var parseTree = parser.Parse("x = y; y = z + m; m = n;"); Assert.IsFalse(parseTree.HasErrors(), "Unexpected parse errors in correct source sample."); parseTree = parser.Parse("x = y; m = = d ; y = z + m; x = z z; m = n;"); Assert.AreEqual(2, parseTree.ParserMessages.Count, "Invalid # of errors."); }
public override object Read(string path) { var obj = new TurbulencePropertiesData(); string text = Load(path); var grammar = new OpenFoamGrammar(); var parser = new Parser(grammar); var tree = parser.Parse(text); _fileHandler = null; foreach (ParseTreeNode rootEntryNode in tree.Root.FindDictEntries(null)) { if (rootEntryNode.GetEntryIdentifier() == "simulationType") { obj.SimulationType = rootEntryNode.GetBasicValEnum<TurbulenceModel>(); if (obj.SimulationType == TurbulenceModel.RASModel) { _fileHandler = new RASPropertiesHandler(); obj.RasProperties = (RASPropertiesData) _fileHandler.Read(path); } else if (obj.SimulationType == TurbulenceModel.LESModel) { _fileHandler = new LESPropertiesHandler(); obj.LesProperties = (LESPropertiesData) _fileHandler.Read(path); } break; } } return obj; }
/// <summary> /// retorna null si ocurrio un error al leer el archivo. /// </summary> /// <param name="path"></param> /// <returns></returns> private StaticEntity CreateStaticEntity(string path) { var src = File.ReadAllText(path); var grammar = new PyUsacGrammar(); var langData = new LanguageData(grammar); var parser = new Irony.Parsing.Parser(langData);//Para evitar conflicto con el namespace Parser var parseTree = parser.Parse(src); bool hasErrors = false; foreach (var error in parseTree.ParserMessages) { if (error.Level == Irony.ErrorLevel.Error) { hasErrors = true; } ErrorFactory.CreateParsingError(error, path); } if (hasErrors) { return(null); } var astBuilder = new PyAstBuilder(new AstContext(langData), path); astBuilder.BuildAst(parseTree); var programNode = (ProgramNode)parseTree.Root.AstNode; var entity = new StaticEntity(programNode); entity.InitVisitor(true); return(entity); }
public override object Read(string path) { var obj = new RASPropertiesData(); string text = Load(path); var grammar = new OpenFoamGrammar(); var parser = new Parser(grammar); var tree = parser.Parse(text); foreach (ParseTreeNode rootEntryNode in tree.Root.FindDictEntries(null)) { switch (rootEntryNode.GetEntryIdentifier()) { case "RASModel": obj.RasModelName = rootEntryNode.GetBasicValString(); break; case "turbulence": obj.Turbulence = rootEntryNode.GetBasicValEnum<OnOffValue>(); break; case "printCoeffs": obj.PrintCoeffs = rootEntryNode.GetBasicValEnum<OnOffValue>(); break; } } return obj; }
private void button1_Click(object sender, EventArgs e) { string programText = textBox1.Text; CameraControlGrammar grammar = new CameraControlGrammar(); Parser parser = new Parser(grammar); ParseTree program = parser.Parse(programText); //var ttt=program.ToXml(); var cameraSizeNode = program.Root.ChildNodes[0]; var widthNode = cameraSizeNode.ChildNodes[0]; int width = (int)widthNode.Token.Value; var heightNode = cameraSizeNode.ChildNodes[1]; int height = (int)heightNode.Token.Value; // loop through the movement commands foreach (ParseTreeNode commandNode in program.Root.ChildNodes[2].ChildNodes) { // get the number of pixels to move Token pixelsToken = commandNode.ChildNodes[0].Token; int pixelsToMove = (int)pixelsToken.Value; // get the direction Token directionToken =commandNode.ChildNodes[1].Token; string directionText = directionToken.Text.ToLower(); } int u = 0; }
public bool TryParse(string sourceText, out MarkupExtension graph) { graph = null; try { ParseTree tree = _parser.Parse(sourceText); #if DEBUG // Save result tree for debugging purposes LastParseTree = tree; LastException = null; #endif if (tree.Status == ParseTreeStatus.Parsed) { graph = MarkupExtension.Create(tree.Root); return(true); } } #if DEBUG catch (Exception ex) { LastParseTree = null; LastException = ex; } #else catch { // ignored } #endif return(false); }
/// <summary> /// Insert the string from the include file inside the include directive tag /// </summary> /// <remarks></remarks> private void ExpandIncludeFiles(ParseTreeNode rootNode, T4Grammar grammar, Parser parser) { var includes = from n in rootNode.ChildNodes let segmentChild = n.ChildNodes.First() where segmentChild.Term == grammar.Directive let dir = segmentChild let dirName = grammar.GetDirectiveName(dir) where T4Grammar.IsEqualText(Convert.ToString(dirName), "include") select dir; var includeFiles = from incDir in includes let filepath = grammar.GetDirectiveAttributes(incDir)["File"] select new { DirectiveNode = incDir, File = GetIncludeFile(Convert.ToString(filepath)) }; foreach (var incFile in includeFiles) { //do not expand the same files, in case there's a multiple nested references to the same include files if (_expandedFiles.Contains(incFile.File.FullName)) continue; var text = File.ReadAllText(Convert.ToString(incFile.File.FullName)); var content = grammar.GetContentNode(parser.Parse(text)); incFile.DirectiveNode.Tag = new TranslationTag { ExpandedParseTreeNode = content }; //remember expanded file _expandedFiles.Add(incFile.File.FullName); //recursively process content from include file ExpandIncludeFiles(content, grammar, parser); } }
public override object Read(string path) { var rawData = new FvSolutionData(); string txt; using (var reader = new StreamReader(path)) { txt = reader.ReadToEnd(); } var grammar = new OpenFoamGrammar(); var parser = new Parser(grammar); var tree = parser.Parse(txt); foreach (ParseTreeNode rootEntryNode in tree.Root.FindDictEntries(null)) { var identifier = rootEntryNode.GetEntryIdentifier(); switch (identifier) { case "options": ParseOptions(rootEntryNode.ChildNodes[2], rawData); break; case "solvers": ParseSolvers(rootEntryNode.ChildNodes[2], rawData); break; } } return rawData; }
private static void LoadBnfFile(string fileName, Builder mainBuilder) { Console.WriteLine("Parse BNF file: {0}", fileName); var bnf = File.ReadAllText(fileName); var metaParser = new MetaParser(); var meta = metaParser.Parse(bnf); var oprimizedBnf = Optimize(bnf); var parser = new Parser(new BnfGrammar(meta.Mode)); var tree = parser.Parse(oprimizedBnf, fileName); if (tree.Status == ParseTreeStatus.Error) { throw new Exception((tree.ParserMessages.Count > 0) ? string.Format("{0}, in {3} file at line {1}, column {2}", tree.ParserMessages[0].Message, tree.ParserMessages[0].Location.Line, tree.ParserMessages[0].Location.Column, fileName) : string.Format(@"Unknow error in BNF file {0}", fileName)); } var builder = new Builder(tree, mainBuilder); builder.BuildExpressions(); foreach (var @using in meta.Usings) LoadBnfFile(@using, mainBuilder); }
public void ShouldNotParseWithoutCases() { // Arrange var grammar = new CicodeGrammar(); var parser = new Parser(grammar); var sourceCode = @" FUNCTION A() SELECT CASE a END SELECT END "; // Act var parseTree = parser.Parse(sourceCode); // Assert Assert.IsNotNull(parseTree); Assert.IsTrue(parseTree.HasErrors()); // A parser error is expected at the end of line 4 because the expected list of cases which is missing Assert.AreEqual<int>(1, parseTree.ParserMessages .Where(m => m.Location.Line == 4) .Where(m => m.ParserState.ExpectedTerminals.First().Name == "CASE") .Count()); }
public override object Read(string path) { var rawData = new DecomposeParDictData(); string txt; using (var reader = new StreamReader(path)) { txt = reader.ReadToEnd(); } var grammar = new OpenFoamGrammar(); var parser = new Parser(grammar); var tree = parser.Parse(txt); foreach (ParseTreeNode rootEntryNode in tree.Root.FindDictEntries(null)) { var identifier = rootEntryNode.GetEntryIdentifier(); switch (identifier) { case "numberOfSubdomains": rawData.numberOfSubdomains = rootEntryNode.GetBasicValInt(); break; } } return rawData; }
public void ShouldNotParseCaseElseWhenNotAtTheEnd() { // Arrange var grammar = new CicodeGrammar(); var parser = new Parser(grammar); var sourceCode = @" FUNCTION A() SELECT CASE a CASE 1 A(); CASE ELSE A(); CASE 1 A(); END SELECT END "; // Act var parseTree = parser.Parse(sourceCode); // Assert Assert.IsNotNull(parseTree); Assert.IsTrue(parseTree.HasErrors()); // A parser error is expected at line 7 because of the CASE ELSE clause which is not at then end of the case list Assert.AreEqual<int>(1, parseTree.ParserMessages.Where(m => m.Location.Line == 7).Count()); }
private SourceUnitTree Parse(SourceUnit sourceUnit, bool allowSingle, out bool isExpression) { isExpression = false; IronyParser parser = new IronyParser(allowSingle ? singleStatement : fullGrammar); parser.Context.Mode = ParseMode.CommandLine; scopes = new Stack<LexicalScopeBuilder>(); EnterTopLevelScope(); try { var parsedScript = parser.Parse(sourceUnit.GetCode()); if (parsedScript.HasErrors()) { sourceUnit.CodeProperties = ScriptCodeParseResult.Invalid; return null; } if (sourceUnit.Kind == SourceCodeKind.InteractiveCode && parser.Context.Status == ParserStatus.AcceptedPartial) { sourceUnit.CodeProperties = ScriptCodeParseResult.IncompleteStatement; return null; } sourceUnit.CodeProperties = ScriptCodeParseResult.Complete; return BuildSourceTree(parsedScript.Root, sourceUnit, allowSingle, out isExpression); } catch (Exception e) { throw; } finally { LeaveScope(); } }
public override object Read(string path) { var obj = new FvSolutionData(); string txt = Load(path); var grammar = new OpenFoamGrammar(); var parser = new Parser(grammar); var tree = parser.Parse(txt); foreach (ParseTreeNode rootEntryNode in tree.Root.FindDictEntries(null)) { var identifier = rootEntryNode.GetEntryIdentifier(); switch (identifier) { case "solvers": obj.Solvers = GetSolvers(rootEntryNode.GetDictContent()); break; case "PISO": case "SIMPLE": case "PIMPLE": obj.Solution = GetSolution(identifier, rootEntryNode.GetDictContent()); break; } } return obj; }
public override object Read(string path) { var obj = new AirfoilPropertiesInstance(); string text = Load(path); var grammar = new OpenFoamGrammar(); var parser = new Parser(grammar); var tree = parser.Parse(text); obj.row = new List<Vertice>(); foreach (ParseTreeNode rootEntryNode in tree.Root.FindDictEntries(null)) { var id = rootEntryNode.GetEntryIdentifier(); if (id == "airfoilData") { var dict = rootEntryNode.GetDictContent().ChildNodes[1]; foreach (ParseTreeNode t in dict.ChildNodes) { var array_head = t.ChildNodes[0].ChildNodes[1].ChildNodes; var v = new Vertice { X = Convert.ToDecimal(array_head[0].ChildNodes[0].Token.Value), Y = Convert.ToDecimal(array_head[1].ChildNodes[0].Token.Value), Z = Convert.ToDecimal(array_head[2].ChildNodes[0].Token.Value) }; obj.row.Add( v ); } } } obj.airfoilName = FileName; return obj; }
public override object Read(string path) { var obj = new DecomposeParDictData(); string txt = Load(path); var grammar = new OpenFoamGrammar(); var parser = new Parser(grammar); var tree = parser.Parse(txt); foreach (ParseTreeNode rootEntryNode in tree.Root.FindDictEntries(null)) { var identifier = rootEntryNode.GetEntryIdentifier(); switch (identifier) { case "numberOfSubdomains": obj.numberOfSubdomains = rootEntryNode.GetBasicValInt(); break; case "method": obj.method = rootEntryNode.GetBasicValEnum<DecompositionMethod>(); break; case "hierarchicalCoeffs": obj.hCoefs = GetHierarchicalCoeffs(rootEntryNode.GetDictContent()); break; } } return obj; }
public void HandleFile(string file) { if (!System.IO.File.Exists(file)) return; try { FileStream fileStream = System.IO.File.Open(file, FileMode.Open, FileAccess.Read, FileShare.ReadWrite); using (StreamReader reader = new StreamReader(fileStream)) { var parser = new Parser(LuaGrammar.Instance); var tree = parser.Parse(reader.ReadToEnd()); var root = tree.Root; if (root != null) { File = new LuaFile(file, tree.Tokens); RefreshTree(root); FileManager.Instance.AddFile(File); } else { System.Diagnostics.Debug.Print("***********error***********" + file); } } } catch(Exception e) { BabePackage.Setting.LogError("open file failed:" + e.GetType().FullName); } }
public ParseTree ParseString(string code) { var tree = _parser.Parse(code); Assert.IsNotNull(tree); return(tree); }
public override object Read(string path) { var obj = new AirfoilPropertiesData(); string text; using (var reader = new StreamReader(path)) { text = reader.ReadToEnd(); } var grammar = new OpenFoamGrammar(); var parser = new Parser(grammar); var tree = parser.Parse(text); obj.airfoilData = new List<Vertice>(); foreach (ParseTreeNode rootEntryNode in tree.Root.FindDictEntries(null)) { var id = rootEntryNode.GetEntryIdentifier(); if (id == "airfoilData") { var dict = rootEntryNode.GetDictContent().ChildNodes[1]; for (int i = 0; i < dict.ChildNodes.Count; i++) { var array_head = dict.ChildNodes[i].ChildNodes[0].ChildNodes[1].ChildNodes; var v = new Vertice(); v.X = Convert.ToDecimal(array_head[0].ChildNodes[0].Token.Value); v.Y = Convert.ToDecimal(array_head[1].ChildNodes[0].Token.Value); v.Z = Convert.ToDecimal(array_head[2].ChildNodes[0].Token.Value); obj.airfoilData.Add( v ); } } } return obj; }
/// <summary> /// Build a parse tree from trip idl /// </summary> /// <param name="tripIdl">trip idl text</param> /// <returns>a parse tree</returns> public static ParseTree ParseTripIdl(string tripIdl) { Grammar g = new IdlGrammar(); var parser = new Parser(g); var parseTree = parser.Parse(tripIdl); return parseTree; }
public void TestCase() { GLSLGrammar lang = new GLSLGrammar (); var compiler = new Irony.Parsing.Parser(lang); var tree = compiler.Parse ("void main(void) { float v = vec3(1,1,1); }"); //CheckNodes (tree.Root, 0); }
public void StructTest01() { GLSLGrammar lang = new GLSLGrammar (); var compiler = new Irony.Parsing.Parser(lang); var tree = compiler.Parse ("struct Camera { float x;}"); //CheckNodes (tree.Root, 0); }
public override object Read(string path) { string txt; using (var reader = new StreamReader(path)) { txt = reader.ReadToEnd(); } var grammar = new OpenFoamGrammar(); var parser = new Parser(grammar); var tree = parser.Parse(txt); var d = new Vertice(); foreach (ParseTreeNode rootEntryNode in tree.Root.FindDictEntries(null)) { var identifier = rootEntryNode.GetEntryIdentifier(); switch (identifier) { case "value": d.X = rootEntryNode.GetDictArrayBody().GetArrayOfDecimal()[0]; d.Y = rootEntryNode.GetDictArrayBody().GetArrayOfDecimal()[1]; d.Z = rootEntryNode.GetDictArrayBody().GetArrayOfDecimal()[2]; break; } } return d; }
public override object Read(string path) { var obj = new RefineMeshDictData(); string txt; using (var reader = new StreamReader(path)) { txt = reader.ReadToEnd(); } var grammar = new OpenFoamGrammar(); var parser = new Parser(grammar); var tree = parser.Parse(txt); foreach (ParseTreeNode rootEntryNode in tree.Root.FindDictEntries(null)) { var identifier = rootEntryNode.GetEntryIdentifier(); string patch; switch ( identifier ) { case "set": obj.setvalue = rootEntryNode.GetBasicValString(); break; case "coordinateSystem": obj.coordsys = rootEntryNode.GetBasicValEnum<CoordinateSystem>(); break; case "globalCoeffs": { var dict = rootEntryNode.GetDictContent(); obj.globalCoeffs = GetCoeffs(ref dict, out patch); } break; case "patchLocalCoeffs": { var dict = rootEntryNode.GetDictContent(); obj.patchLocalCoeffs = GetCoeffs(ref dict, out patch); obj.patch = patch; } break; case "directions": { obj.direction = new List<DirectionType>(); var s = rootEntryNode.ChildNodes[2].ChildNodes[1].GetArrayOfString(); foreach (string t in s) { obj.direction.Add(t.ToEnum<DirectionType>()); } } break; case "useHexTopology": obj.useHexTopology = rootEntryNode.GetBasicValBool(); break; case "geometricCut": obj.geometricCut = rootEntryNode.GetBasicValBool(); break; case "writeMesh": obj.writeMesh = rootEntryNode.GetBasicValBool(); break; } } return obj; }
static int Main(string[] args) { try { bool mode2 = (((args.Length >= 3) ? args[2] : "") == "mode2"); Console.WriteLine("Create grammar"); var grammar = new XbnfGrammar(mode2 ? XbnfGrammar.Mode.HttpCompatible : XbnfGrammar.Mode.Strict); Console.WriteLine("Create parser"); var parser = new Parser(grammar); Console.WriteLine("Read XBNF from {0}", args[0]); var xbnf = File.ReadAllText(args[0]); Console.WriteLine("Optimize"); var oprimized = Optimize(xbnf); Console.WriteLine("Parse"); var tree = parser.Parse(oprimized, "<source>"); Console.WriteLine("Convert to C#"); var csharp = grammar.RunSample(tree); Console.WriteLine("Write C# to {0}", args[1]); File.WriteAllText(args[1], AddHeaderFooter(csharp)); } catch (Exception ex) { Console.Write(ex.ToString()); return -1; } return 0; }
public void TestCase() { GLSLGrammar lang = new GLSLGrammar(); var compiler = new Irony.Parsing.Parser(lang); var tree = compiler.Parse("void main(void) { float v = vec3(1,1,1); }"); //CheckNodes (tree.Root, 0); }
public static bool TestAst(string src) { var grammar = new PyUsacGrammar(); var langData = new LanguageData(grammar); var parser = new Irony.Parsing.Parser(langData);//Para evitar conflicto con el namespace Parser var parseTree = parser.Parse(src); var root = parseTree.Root; if (parseTree.HasErrors()) { ErrorHelper.ErrorFactory.CreateParsingErrors(parseTree, "_null"); return(false); } else { var dotCode = GetDot(root); var astBuilder = new AstBuilder(new AstContext(langData)); astBuilder.BuildAst(parseTree); var astRoot = (AstNode)root.AstNode; Debug.WriteLine(""); Debug.WriteLine("--------------------------------------------------"); Debug.WriteLine(""); GetDot(astRoot); return(true); } }
public static bool TestSyntax(string src) { var grammar = new PyUsacGrammar(); var langData = new LanguageData(grammar); var parser = new Irony.Parsing.Parser(langData);//Para evitar conflicto con el namespace Parser var parseTree = parser.Parse(src); var root = parseTree.Root; if (parseTree.HasErrors()) { ErrorHelper.ErrorFactory.CreateParsingErrors(parseTree, "_null"); return(false); } else { GetDot(root); Debug.WriteLine(""); Debug.WriteLine("--------------------------------------------------"); Debug.WriteLine(""); return(true); } }
public void StructTest01() { GLSLGrammar lang = new GLSLGrammar(); var compiler = new Irony.Parsing.Parser(lang); var tree = compiler.Parse("struct Camera { float x;}"); //CheckNodes (tree.Root, 0); }
public override object Read(string path) { var rawData = new VelocityData(); string txt; using (var reader = new StreamReader(path)) { txt = reader.ReadToEnd(); } var grammar = new OpenFoamGrammar(); var parser = new Parser(grammar); var tree = parser.Parse(txt); foreach (ParseTreeNode rootEntryNode in tree.Root.FindDictEntries(null)) { var identifier = rootEntryNode.GetEntryIdentifier(); switch (identifier) { //case "turbineArrayOn": // rawData.TurbineArrayOn = rootEntryNode.GetBasicValBool(); // break; } } return rawData; }
public bool AssemblyBlock(eBLOCK200_BLOCKTYPES blockType, int blockNr, eBLOCK200_OB_VERSIONS blockVer, bool forceExpandedFormat, bool bNoWizardInfo, bool bUseChineseOpcode, string source, out byte[] dest) { dest = null; var server = new CoMsSig200Lib.Sig200ServerClass(); Sig200SignatureList InsList = null; server.CreateInstructionSignatures(null); server.SetMnemonic(eSIG200_MNEMONICS.eSIG200_MNEMONIC_SIMATIC); server.GetInstructionSignatureList(ref InsList); var grammar = new STLCompiler.STLGrammar(); LanguageData language = new LanguageData(grammar); Parser parser = new Parser(language); ParseTree parseTree = parser.Parse(source); ParseTreeNode root = parseTree.Root; var project = new STLCompiler.S7Project(root.AstNode as Block, server); var builder = new CoMsBlock200Lib.Block200Class() as IBlock200Fix; int pnOBSize, pnOBSizeNoWiz, pnDBArea3Size; builder.CalcBlockSizes(project, server, (int)eBLOCK200_OB_VERSIONS.eBLOCK200_OB_VERSION_2ND_GEN_5, 2, /* Must 2, from reverse */ out pnOBSize, out pnOBSizeNoWiz, out pnDBArea3Size); IntPtr ppbyDestBlock = Marshal.AllocCoTaskMem(pnOBSize); IntPtr ppbyEdgeData = IntPtr.Zero; int nDestBytes = pnOBSize, nEdges = 0; try { builder.AssembleBlock(project, server, (int)eBLOCK200_BLOCKTYPES.eBLOCK200_BLOCKTYPE_OB, 1, (int)eBLOCK200_OB_VERSIONS.eBLOCK200_OB_VERSION_2ND_GEN_5, 0, 1, 1, out ppbyDestBlock, out nDestBytes, out ppbyEdgeData, out nEdges); dest = new byte[nDestBytes]; Marshal.Copy(ppbyDestBlock, dest, 0, nDestBytes); } catch(COMException e) { Console.Write(e.Message); return false; } return true; }
public ParseTreeNode getRoot(string sourceCode, Grammar fabricGrammar) { LanguageData fabric = new LanguageData(fabricGrammar); Parser parser = new Parser(fabric); ParseTree parseTree = parser.Parse(sourceCode); ParseTreeNode root = parseTree.Root; return root; }
public static ParseTree GenerateParseTree(string statement) { Grammar grammar = new ID3SQLGrammar(); LanguageData languageData = new LanguageData(grammar); Parser parser = new Parser(languageData); ParseTree parseTree = parser.Parse(statement); return parseTree; }
private void button1_Click(object sender, EventArgs e) { Grammar grammar = new ExpressionGrammar(); Parser parser = new Parser(grammar); ParseTree parseTree = parser.Parse(richTextBox1.Text); if (parseTree.Status.ToString() != "Error") listBox1.Items.Add(parseTree.SourceText); }
public override object Read(string path) { var rawData = new AblPropertiesData(); string txt; using (var reader = new StreamReader(path)) { txt = reader.ReadToEnd(); } var grammar = new OpenFoamGrammar(); var parser = new Parser(grammar); var tree = parser.Parse(txt); foreach (ParseTreeNode rootEntryNode in tree.Root.FindDictEntries(null)) { var identifier = rootEntryNode.GetEntryIdentifier(); switch (identifier) { case "turbineArrayOn": rawData.turbineArrayOn = rootEntryNode.GetBasicValBool(); break; case "driveWindOn": rawData.driveWindOn = rootEntryNode.GetBasicValBool(); break; case "UWindSpeed": rawData.UWindSpeedDim = rootEntryNode.GetDimVal(); break; case "UWindDir": rawData.UWindDir = rootEntryNode.GetBasicValDecimal(); break; case "hWind": rawData.HWindDim = rootEntryNode.GetDimVal(); break; case "alpha": rawData.alpha = rootEntryNode.GetBasicValDecimal(); break; case "lowerBoundaryName": rawData.lowerBoundaryName = rootEntryNode.GetBasicValString(); break; case "upperBoundaryName": rawData.upperBoundaryName = rootEntryNode.GetBasicValString(); break; case "statisticsOn": rawData.statisticsOn = rootEntryNode.GetBasicValBool(); break; case "statisticsFrequency": rawData.statisticsFrequency = rootEntryNode.GetBasicValDecimal(); break; case "meanAvgStartTime": rawData.meanAvgStartTime = rootEntryNode.GetBasicValDecimal(); break; case "corrAvgStartTime": rawData.corrAvgStartTime = rootEntryNode.GetBasicValDecimal(); break; } } return rawData; }
private void ParseSourceCode() { LanguageData language = new LanguageData(grammar); Parser gridWorldParser = new Parser(language); ParseTree parseTree = gridWorldParser.Parse(immediateRepresentation.ZestSourceCode); immediateRepresentation.HasErrors = parseTree.HasErrors(); immediateRepresentation.ParseTreeRoot = parseTree.Root; immediateRepresentation.ErrorList = parseTree.ParserMessages; }
public ParseTreeNode getRoot(string sourceCode, Grammar grammar) { LanguageData language = new LanguageData(grammar); Irony.Parsing.Parser parser = new Irony.Parsing.Parser(language); ParseTree parseTree = parser.Parse(sourceCode); ParseTreeNode root = parseTree.Root; if (root == null) { throw new Exception(parseTree.ParserMessages[0].ToString()); } return(root); }
public static bool InterpretFromFileName(string filePath) { string src; try { src = File.ReadAllText(filePath); } catch (Exception) { //Reprotar error de preprocesador return(false); } var grammar = new PyUsacGrammar(); var langData = new LanguageData(grammar); var parser = new Irony.Parsing.Parser(langData);//Para evitar conflicto con el namespace Parser var parseTree = parser.Parse(src); var root = parseTree.Root; bool hasErrors = false; foreach (var error in parseTree.ParserMessages) { if (error.Level == Irony.ErrorLevel.Error) { hasErrors = true; } ErrorHelper.ErrorFactory.CreateParsingError(error, filePath); } if (hasErrors) { return(false); } //var dotCode = GetDot(root);//Descomentar en debug mode! :) var astBuilder = new PyAstBuilder(new AstContext(langData), filePath); astBuilder.BuildAst(parseTree); var programNode = (ProgramNode)parseTree.Root.AstNode; //GetDot(programNode);//Descomentar en debug mode! :) var entity = new StaticEntity(programNode); entity.InitVisitor(true); entity.InvokeMain(); TypeConstants.ClearTypeHashtable(); return(true); }
bool ParseJava (string javaSourceText) { var parser = new Irony.Parsing.Parser (grammar); var result = parser.Parse (javaSourceText); foreach (var m in result.ParserMessages) Console.WriteLine ($"{m.Level} {m.Location} {m.Message}"); if (result.HasErrors ()) return false; var parsedPackage = (JavaPackage)result.Root.AstNode; FlattenNestedTypes (parsedPackage); var pkg = api.Packages.FirstOrDefault (p => p.Name == parsedPackage.Name); if (pkg == null) { api.Packages.Add (parsedPackage); pkg = parsedPackage; } else foreach (var t in parsedPackage.Types) pkg.Types.Add (t); pkg.Types = pkg.Types.OrderBy (t => t.Name).ToList (); return true; }
public Hub ParseString(string text) { var grammar = new HubGrammar(); var language = new LanguageData(grammar); var parser = new Irony.Parsing.Parser(language); var tree = parser.Parse(text); var hub = new Hub { Id = tree.Root.ChildNodes.Single(x => x.Term.Name == "Name").ChildNodes[0].Token.ValueString, Name = tree.Root.ChildNodes.Single(x => x.Term.Name == "Name").ChildNodes[1].Token.ValueString, HubType = tree.Root.ChildNodes.Single(x => x.Term.Name == "HubType").ChildNodes[0].Token.ValueString, Lines = new List <string>(tree.Root.ChildNodes.Where(x => x.Term.Name == "Line").Select(x => x.ChildNodes[0].Token.ValueString)), Lores = new List <string>(tree.Root.ChildNodes.Where(x => x.Term.Name == "Lore").Select(x => x.ChildNodes[0].Token.ValueString)), }; return(hub); }
// Build the Irony parse tree, then do a depth-first search through it, building an expression tree. public override void Parse(Root root, string text) { if (text.Trim() == "") { return; } ParseTree parseTree = parser.Parse(text); foreach (var parseError in parseTree.ParserMessages) { root.CompilerErrors.Add(new ParserCompilerError("", parseError.Location.Line, parseError.Location.Column, parseError.Message)); } if (root.CompilerErrors.Count > 0) { return; } ConsumeParseTree(root, root, parseTree.Root); }
public void GetDeclarations(LuaBlockNode block, LuaModel model) { // require("sample.lua") if (Target != null && (Target.AsString == "require" || Target.AsString == "NPL.load") && Arguments.ChildNodes.Count == 1 && Arguments.ChildNodes[0] is LuaLiteralNode && ((LuaLiteralNode)Arguments.ChildNodes[0]).Type == LuaType.String) { string fileName = ((LuaLiteralNode)Arguments.ChildNodes[0]).Value; fileName = fileName.Substring(1, fileName.Length - 2); try { string filePath = Path.Combine(Path.GetDirectoryName(model.FilePath), fileName); // project mode if (model.Entry != null && model.Entry.Analyzer != null && model.Entry.Analyzer.ContainsFile(filePath)) { AnalysisEntry requiredEntry = model.Entry.Analyzer.GetAnalysisEntry(filePath); if (requiredEntry.Model != null) { block.Requires.AddRange(requiredEntry.Model.GetGlobalDeclarations()); model.AddIncludedFile(filePath, requiredEntry.Model); } } // singleton mode else { string source = File.ReadAllText(filePath); Irony.Parsing.Parser parser = new Irony.Parsing.Parser(LuaGrammar.Instance); ParseTree tree = parser.Parse(source); LuaModel requiredModel = new LuaModel(tree, filePath); block.Requires.AddRange(requiredModel.GetGlobalDeclarations()); model.AddIncludedFile(filePath, requiredModel); } } catch (Exception e) { } } }
static void Main(string[] args) { LanguageData LangData = new LanguageData(new UIGrammar()); Irony.Parsing.Parser Pars = new Irony.Parsing.Parser(LangData); StringBuilder SBuilder = new StringBuilder(); foreach (string Statement in File.ReadLines("C:\\Program Files\\Maxis\\The Sims Online\\TSOClient\\gamedata\\uiscripts\\personselection.uis")) { SBuilder.Append(Statement + "\r\n"); } Debug.WriteLine("Attempting to parse: " + SBuilder.ToString()); ParseTree Tree = Pars.Parse(SBuilder.ToString()); //DisplayTree((AstNode)Tree.Root.AstNode, 0); WalkTree(Tree.Root); Console.ReadLine(); }
public DeclaredObjectContainer Parse(string programFile) { string program = System.IO.File.ReadAllText(programFile); var grammar = new BDVHDLGrammar(); var parser = new Irony.Parsing.Parser(grammar); var ast = parser.Parse(program); if (ast.Status != ParseTreeStatus.Parsed) { throw new ParserException(programFile, ast.Status, ast.ParserMessages); } (new TreeConverter()).Convert(ast, grammar); var evaluator = new NodeEvaluator(); evaluator.EvaluateGeneral(ast.Root); return(evaluator.declaredObjects); }
public ParseTree Parse(string source, string fileName) { return(internalParser.Parse(source, fileName)); }
public void StructTest02() { GLSLGrammar lang = new GLSLGrammar(); var compiler = new Irony.Parsing.Parser(lang); var tree = compiler.Parse("struct Camera { float x; int num; }; "); }
public void StructTest04() { GLSLGrammar lang = new GLSLGrammar(); var compiler = new Irony.Parsing.Parser(lang); var tree = compiler.Parse("struct Camera { float x; int num; vec3 output; vec2 data[10]; vec4 grid[3][4]; bool samples[]; };"); }
public ParseTree Parse(string instructions) { return(Parser.Parse(instructions)); }