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!!");
}
}
