protected override void Initialize() { worklist = new Stack <InstructionNode>(); transformRules = new List <TransformRule>(); var symbolDictionary = new SymbolDictionary(); symbolDictionary.Add(Architecture); symbolDictionary.Add(IRInstructionList.List); foreach (var rule in Rules.List) { var matchTokens = Tokenizer.Parse(rule.Match, ParseType.Instructions); var criteriaTokens = Tokenizer.Parse(rule.Criteria, ParseType.Expression); var transformTokens = Tokenizer.Parse(rule.Transform, ParseType.Instructions); var matchNodes = NodeParser.Parse(matchTokens, symbolDictionary); var criteriaExpression = ExpressionParser.Parse(criteriaTokens); var transformNodes = NodeParser.Parse(transformTokens, symbolDictionary); var transformRule = new TransformRule(matchNodes, criteriaExpression, transformNodes); transformRules.Add(transformRule); } }
protected static IList<LexicalElement> ParseAndGetElements(string subject) { var parser = new NodeParser(); IList<LexicalElement> elements; parser.Parse(subject, null, out elements); return elements; }
public static void TestParsing(string representation, NodeParser parser = null, bool shouldFail = false) { SourceCode source = new SourceCode(representation); TokenWalker walker = new Compiler(source).Walker; NodeParser nodeParser = parser ?? Parsers.Node.Program; Node node = null; Console.WriteLine(source.WithLineNumbers()); //Console.WriteLine(nodeParser.ToStringRecursively(enableHighlighting: false)); ParseResultHistory resultHistory = null; bool failed; try { nodeParser.Parse(ref node, walker, out resultHistory); failed = false; if (shouldFail) { Assert.IsNull(node); } } catch (FailedParsingNodeException e) { failed = true; } Console.WriteLine(resultHistory.ParseHistory(source)); Assert.IsNotNull(node); Assert.IsTrue(walker.IsLast()); Assert.IsFalse(failed); }
public void Saves_To_Cache() { var mockVertexFactory = new Mock <IVertexFactory>(); var mockProfileFactory = new Mock <IProfileFactory>(); var mockHyperlinkParser = new Mock <IHyperLinkParser>(); var mockVertexCache = new Mock <IVertexCache>(); var mockPause = new Mock <IPause>(); mockVertexFactory.Setup(v => v.Create(It.IsAny <IProfile>(), It.IsAny <IEnumerable <IProfile> >())) .Returns(new Vertex("johndoe", Create_Profiles())); mockProfileFactory.Setup(p => p.Create(It.IsAny <Uri>())) .Returns(new Profile("johndoe", @"http://steamcommunity.com/id/johndoe/friends/")); mockHyperlinkParser.Setup(h => h.ParseUser(It.IsAny <IProfile>())) .Returns(new List <string> { @"http://steamcommunity.com/id/one/friends/", "http://steamcommunity.com/id/two/friends/" }); mockVertexCache.Setup(v => v.Retrieve(It.IsAny <string>())) .Returns((IVertex)null); var nodeParser = new NodeParser(mockHyperlinkParser.Object, mockVertexFactory.Object, mockProfileFactory.Object, mockVertexCache.Object, mockPause.Object); var vertex = Create_Vertex(); var friends = nodeParser.Parse(new Uri($"http://steamcommunity.com/id/{vertex.Id}")); mockVertexCache.Verify(v => v.Save(vertex)); }
protected static IList <LexicalElement> ParseAndGetElements(string subject) { var parser = new NodeParser(); IList <LexicalElement> elements; parser.Parse(subject, null, out elements); return(elements); }
public void SimpleCase() { var nodes = ExpressionsBuild( "A>B,C", "B>C,D", "D>", "C>" ); var result = NodeParser.Parse(nodes); Assert.AreEqual("D,C,B,A", result.Select(a => a.Id).Aggregate((a, b) => a + "," + b)); }
public void TestParsingMissingToken() { string source = "variable123"; TokenWalker Walker = TestTools.GetWalker(source); NodeParser Parser = Keep(SyntaxKeyword.Assignment).Name("Identifier"); Node expression = null; Assert.Throws <FailedParsingNodeException>(() => Parser.Parse(ref expression, Walker, out _)); Assert.IsNull(expression); }
public void TestParseSingleToken() { string source = "variable123"; TokenWalker Walker = TestTools.GetWalker(source); NodeParser Parser = Keep(SyntaxKeyword.Identifier).Name("Identifier"); Node expression = null; Parser.Parse(ref expression, Walker, out _); Assert.IsNotNull(expression); }
private void Reparse() { var bufferText = Buffer.CurrentSnapshot.GetText(); try { parser.Parse(bufferText, "Editor", out parsedRepresentation); ast = new Lazy <NodeTree>(() => new Builder(bufferText, parsedRepresentation).ast); } catch (FormatException) { parsedRepresentation = new List <LexicalElement>(); ast = new Lazy <NodeTree>(() => null); } }
static void Main(string[] args) { string path = @"htmlToRead.html"; string readText = File.ReadAllText(path); NodeParser nodeParser = new NodeParser(); INode nodeTree = new NodeBase(); nodeTree.Add(nodeParser.Parse(readText)); //NodeWriter.Write(nodeTree); Console.WriteLine(readText); }
public static void RunParser() { Console.WriteLine("Four Function Calculator (Ctrl-D to quit, Enter after each line, ';' to end expression)"); var input = ""; while (!string.IsNullOrEmpty(input = Console.ReadLine())) { Lexer lexer = new Lexer(input); NodeParser parser = new NodeParser(lexer); try { parser.Parse(); } catch { Console.WriteLine("Doh!!"); } } Console.WriteLine("Finished."); }
public void CycleDependency() { var nodes = ExpressionsBuild( "A>B,C", "B>C,D", "D>", "C>A" ); try { var result = NodeParser.Parse(nodes); } catch (CycleDependencyException e) { CollectionAssert.AreEquivalent(new List <string>() { "A", "B", "C" }, e.UnresolvedNodes); } }
public void ExceedExpression() { var nodes = ExpressionsBuild( "A>B,E", "B>C,D", "D>F", "C>" ); try { var result = NodeParser.Parse(nodes); } catch (ExceedDependencyException e) { CollectionAssert.AreEquivalent(new List <string>() { "E", "F" }, e.ExceedNodes); } }
public override bool Execute() { var parser = new NodeParser(); var validator = new GeneralSemanticValidator(); foreach (var file in Files) { var nodes = File.ReadAllText(file.ItemSpec); IList<LexicalElement> tokens; parser.Parse(nodes, file.ItemSpec, out tokens); foreach (var token in tokens.Where(token => token.Name.Contains("_"))) { LogError(new Warning(file.ItemSpec, token.StartCursor, token.EndCursor, "Syntax", token.Name)); } var ast = new Builder(nodes, tokens).ast; var warnings = validator.Validate(file.ItemSpec, ast); foreach (var warning in warnings) { LogWarning(warning); } } return Log.HasLoggedErrors && !ContinueOnError; }
public void simulate() { checkAllAvaliableNodes(); saveLoad.nodes.Clear(); foreach (GameObject node in nodesGO) { if (node.name.Contains("MoveNodeComp")) { print("Xpos is " + node.transform.Find("XposInputField").gameObject.GetComponent <InputField>().text); print("Ypos is " + node.transform.Find("YposInputField").gameObject.GetComponent <InputField>().text); Node myNode = node.GetComponent <NodeContainerGO>().myNode; myNode.xPos = node.transform.position.x; myNode.yPos = node.transform.position.y; myNode.moveX = float.Parse(node.transform.Find("XposInputField").gameObject.GetComponent <InputField>().text); myNode.moveY = float.Parse(node.transform.Find("YposInputField").gameObject.GetComponent <InputField>().text); saveLoad.nodes.Add(myNode); } if (node.name.Contains("onClickNodeComp")) { print("Button is " + node.transform.Find("EventtInputField").gameObject.GetComponent <InputField>().text); Node myNode = node.GetComponent <NodeContainerGO>().myNode; myNode.xPos = node.transform.position.x; myNode.yPos = node.transform.position.y; myNode.keyCode = node.transform.Find("EventtInputField").gameObject.GetComponent <InputField>().text; saveLoad.nodes.Add(myNode); } } parser.Parse(); }
public override bool Execute() { var parser = new NodeParser(); var validator = new GeneralSemanticValidator(); foreach (var file in Files) { var nodes = File.ReadAllText(file.ItemSpec); IList <LexicalElement> tokens; parser.Parse(nodes, file.ItemSpec, out tokens); foreach (var token in tokens.Where(token => token.Name.Contains("_"))) { LogError(new Warning(file.ItemSpec, token.StartCursor, token.EndCursor, "Syntax", token.Name)); } var ast = new Builder(nodes, tokens).ast; var warnings = validator.Validate(file.ItemSpec, ast); foreach (var warning in warnings) { LogWarning(warning); } } return(Log.HasLoggedErrors && !ContinueOnError); }
public void EmptyCase() { var result = NodeParser.Parse(new List <Node>()); CollectionAssert.IsEmpty(result); }
public static void RunTemplateParser() { var input = @" <div>{{ }}</div> "; Func<string,string,string> getFullName = (f,l) => { return l + f; }; var scope = new { FirstName = "", LastName = "", GetFullName =getFullName}; Lexer lexer = new Lexer(input); NodeParser parser = new NodeParser(lexer); try { parser.Parse(); } catch { Console.WriteLine("Doh!!"); } }