private TypeDescriptor Visit(VarNode node, Context context) { var var = context.GetVar(node.VarName); if (var == null) { var type = context.GetType(node.VarName); if (type == null) { Log(string.Format("Переменная {0} не существует", node.VarName), node); return(TypeDescriptor.Undefined); } else { int index = node.ChildIndex; var packageNameNode = new PackageNameNode(node.VarName); node.Parent.ReplaceChildren(index, index, packageNameNode); return(new TypeDescriptor(false, type)); } } return(new TypeDescriptor(true, var.Type, true)); }
// evaluate the tree recursively private double EvalTree(Node n) { if (n == null) { //Console.WriteLine("No expression entered."); return(0); } else { if (n is ChildNode) // tree only has one const node { ChildNode n1 = (ChildNode)n; return(n1.getVal()); } else if (n is VarNode) // tree has one variable node { VarNode n2 = (VarNode)n; return(_dict[n2.getVal()]); // return value assigned by user in the dictionary } else // m_root is a opNode { // need to evaluate the tree double l; double r; OperatorNode op = (OperatorNode)n; l = EvalTree(op.Left); r = EvalTree(op.Right); return(op.Eval(l, r)); } } }
private VarNode Variable() { var node = new VarNode(_currentToken); Eat(TokenType.ID); return(node); }
/// <summary> /// This method will update a type definition for a variable in all scopes /// </summary> /// <param name="leftHand">The variable to update</param> /// <param name="rhs">The typecontext to assign it</param> /// <param name="scopeName">The name of the calling scope</param> /// <param name="goback">A bool value checking if the child scopes should be updated</param> public void UpdateTypedef(VarNode leftHand, TypeContext rhs, string scopeName, bool goback) { if (!goback) { if (this.Name == SymbolTableBuilder.GlobalSymbolTable.Name) { foreach (SymbolTableObject child in this.Children) { child.UpdateTypedef(leftHand, rhs, scopeName, goback); } } } else { if (this.IsInFunction()) { GetEnclosingFunction().UpdateFuncVar(leftHand, rhs, GetEnclosingFunction().Name); } } if (this.Symbols.Any(sym => sym.Name == leftHand.Id)) { this.Symbols.FindAll(sym => sym.Name == leftHand.Id).ForEach(node => { node.TokenType = rhs.Type; }); leftHand.SymbolType = rhs; leftHand.Type = rhs.Type; } }
private double evalNode(Node node) { OpNode op_node = node as OpNode; ValueNode val_node = node as ValueNode; VarNode var_node = node as VarNode; if (null != op_node) { switch (op_node.m_op) { case '+': return(evalNode(op_node.m_left) + evalNode(op_node.m_right)); case '-': return(evalNode(op_node.m_left) - evalNode(op_node.m_right)); case '*': return(evalNode(op_node.m_left) * evalNode(op_node.m_right)); case '/': return(evalNode(op_node.m_left) / evalNode(op_node.m_right)); case '^': return(Math.Pow(evalNode(op_node.m_left), evalNode(op_node.m_right))); } } if (null != val_node)//if node is a value node, return it's value { return(val_node.m_value); } if (null != var_node) //if node is a variable, look up key in dictionary and return corresponding value { return(m_dict[var_node.m_var]); //will crash if variable isn't defined, so don't allows eval function to be called unless all variables are define. SEE allVarsDefined() function } return(0);//I don't know the how this code could get here, but the compiler wants something here }
/// <summary> /// This methods visits a var node /// If the var is a numeric it's checked if it is a float or integer /// Then it's checked if it's a bool or string var /// The var is assigned to an ID /// </summary> /// <param name="varNode">The name of the token</param> /// <returns>It returns an ID for the var</returns> public override object Visit(VarNode varNode) { string varNodeId = ""; if (varNode.Declaration) { if (varNode.SymbolType.Type == TokenType.NUMERIC) { if (varNode.SymbolType.IsFloat) { varNodeId += "float "; } else { varNodeId += "int "; } } else if (varNode.SymbolType.Type == TokenType.BOOL) { varNodeId += "bool "; } else if (varNode.SymbolType.Type == TokenType.STRING) { varNodeId += "String "; } } varNodeId += varNode.Id; return(varNodeId); }
bool allVarsDefinedNode(Node node) { OpNode o = node as OpNode; if (o != null)//node is an OpNode { return(allVarsDefinedNode(o.m_left) && allVarsDefinedNode(o.m_right)); } ValueNode value = node as ValueNode; if (value != null)//node is a ValueNode { return(true); } VarNode var = node as VarNode; if (var != null) //node is a VarNode { if (m_dict.ContainsKey(var.m_var)) //if key exists { return(true); } else//if key is not in dictionary { return(false); } } return(false);//Don't know how code would get here }
/// <summary> /// This method checks what type the parameters of a function is /// </summary> /// <param name="functionsParam">Is a variable, either float, bool, int or string</param> /// <param name="function">Is the function the parameter is given to</param> /// <returns></returns> private string findFuncInputparam(VarNode functionsParam, FuncNode function) { VarNode param = function.FunctionParameters.Find(x => x.Id == functionsParam.Id); if (param.SymbolType.IsFloat) { return("float "); } else if (param.SymbolType.Type == TokenType.BOOL) { return("bool "); } else if (!param.SymbolType.IsFloat) { return("int "); } else if (param.SymbolType.Type == TokenType.STRING) { return("String "); } else { new InvalidCodeException($"The function{function.Name} input parameter {functionsParam.Id} at {functionsParam.Line}:{functionsParam.Offset} is not used."); return(""); } }
public void UpdateVars(IVarListViewItem[] srcs) { updateId++; //Get new updateID foreach (IVarListViewItem src in srcs) { VarNode dst = null; if ((dst = FindVarNode(this, src.Name)) != null) { Update(dst, src, updateId); } else { dst = new VarNode(src.Name, src.Value, src.Type); this.Nodes.Add(dst); Update(dst, src, updateId); } } //Remove all nodes that have not been added or modified List <VarNode> toRemove = new List <VarNode>(); foreach (VarNode node in Nodes) { Clean(toRemove, node, updateId); } foreach (VarNode node in toRemove) { node.Remove(); } }
public MathFunc(MathFuncNode root, VarNode variable = null, IEnumerable<ConstNode> parameters = null, bool calculateConstants = false, bool simplify = false) : this(new FuncNode("f", new List<MathFuncNode>() { variable }), root, variable, parameters, calculateConstants, simplify) { }
public MathFunc(string str, string v = null, bool simplify = true, bool precompile = false) { if (!Helper.Parser.Parse(str)) throw new Exception("Impossible to parse input string"); LeftNode = Helper.Parser.FirstStatement.LeftNode; RightNode = Helper.Parser.FirstStatement.RightNode; Root = RightNode; if (string.IsNullOrEmpty(v)) ConstToVars(); else { Variable = new VarNode(v); ConstToVar(Root); } FindParamsAndUnknownFuncs(Root); Root.Sort(); if (simplify) Root = Simplify(Root); if (precompile) Root = Precompile(null, Root); }
/// <summary> /// Visit Var node in DFS manner. /// </summary> /// <param name="node">Var node that will be visited.</param> public void Visit(VarNode node) { foreach (var item in node.Descendants) { item.Accept(this); } node.Accept(_visitor); }
public void RegisterInContext() { VarNode body = new VarNode("a", null, new ConstantNode(42)); ClassNode node = new ClassNode("Foo", body); IContext context = new Context(); node.RegisterInContext(context); Assert.AreSame(node, context.GetValue("Foo")); }
public void GetCommand() { VarNode varnode = new VarNode("a", null, new ConstantNode(42)); ObjectNode node = new ObjectNode("Foo", varnode); var result = node.GetCommand(); Assert.IsNotNull(result); Assert.IsInstanceOfType(result, typeof(ObjectCommand)); }
/// <summary> /// creates a variable-container node /// </summary> /// <param name="graph"></param> /// <param name="var"></param> /// <param name="isInput"></param> /// <param name="pos"></param> /// <returns></returns> public static VarNode CreateNode(NodeGraph graph, Variable var, bool isInput, Vector2 pos) { VarNode res = ScriptableObject.CreateInstance <VarNode>(); res.Initialize(); res.Construct(var, isInput); InitNode(res, graph, pos); return(res); }
//Calculates an Expression Tree given it's root node private double Evaluate(Node n) { if (n == null) { return(-1); } ConstNode constTest = n as ConstNode; if (constTest != null) { return(constTest.get_val()); } VarNode varTest = n as VarNode; if (varTest != null) { try { return(vDict[n.get_name()]); } catch (Exception c) { Console.WriteLine("Key Not Found, Undefined Behavior"); } } OpNode opTest = n as OpNode; if (opTest != null) { if (opTest.get_name() == "+") { return(Evaluate(opTest.Left) + Evaluate(opTest.Right)); } else if (opTest.get_name() == "-") { return(Evaluate(opTest.Left) - Evaluate(opTest.Right)); } else if (opTest.get_name() == "*") { return(Evaluate(opTest.Left) * Evaluate(opTest.Right)); } else if (opTest.get_name() == "/") { return(Evaluate(opTest.Left) / Evaluate(opTest.Right)); } } return(0.0); //default return value }
private object VisitVarNode(VarNode node) { var varName = node.Value.ToString(); if (!GlobalScope.ContainsKey(varName)) { throw new VariableNameException(varName); } return(GlobalScope[varName]); }
public void VarNodeEmptyConstructorTest() { // Arrange and Act VarNode testVarNode = new VarNode(); // Assert bool varNameEqual = testVarNode.Variable == "NoData"; bool varValueEqual = testVarNode.Value == 0; Assert.AreEqual(varNameEqual, varValueEqual); }
public void EvalTest() { // Arrange string testVariable = "hhhhhhhhhhh1"; double testValue = 1384.34; // Act VarNode testVarNode = new VarNode(testVariable, testValue); // Assert Assert.AreEqual(testValue, testVarNode.Eval()); }
public void CreateObjectNode() { VarNode varnode = new VarNode("a", null, new ConstantNode(42)); ObjectNode node = new ObjectNode("Foo", varnode); Assert.AreEqual("Foo", node.Name); Assert.IsNotNull(node.Body); Assert.AreSame(varnode, node.Body); Assert.AreEqual("Foo", node.TypeInfo.Name); node.CheckType(null); Assert.AreEqual("Foo", node.TypeInfo.Name); }
/// <summary> /// This method will update function parameters of an enclosing function /// </summary> /// <param name="node">The node to look for</param> /// <param name="rhs">The typecontext to assign the variable</param> /// <param name="scopeName">The name of the calling scope</param> public void UpdateFuncVar(VarNode node, TypeContext rhs, string scopeName) { SymbolTableObject symobj = SymbolTableBuilder.GlobalSymbolTable.Children.First(symtab => symtab.Name == scopeName); FuncNode func = SymbolTableObject.FunctionDefinitions.First(fn => this.Name.Contains(fn.Name.Id) && this.Name.Contains("_" + fn.Line)); if (func.FunctionParameters.Any(vn => vn.Id == node.Id)) { node.Declaration = false; } symobj.UpdateTypedef(node, rhs, scopeName, false); }
public void CreateClassNodeWithNameAndNullBody() { VarNode body = new VarNode("a", null, new ConstantNode(42)); ClassNode node = new ClassNode("Foo", body); Assert.AreEqual("Foo", node.Name); Assert.IsNotNull(node.Body); Assert.AreEqual("Foo", node.TypeInfo.Name); node.CheckType(null); Assert.AreEqual("Foo", node.TypeInfo.Name); }
public void CreateVarNode() { string name = "foo"; TypeInfo typeinfo = TypeInfo.Int; IExpressionNode expression = new ConstantNode(42); VarNode node = new VarNode(name, typeinfo, expression); Assert.AreEqual(name, node.Name); Assert.AreSame(TypeInfo.Int, node.TypeInfo); Assert.AreSame(expression, node.Expression); }
VarNode FindChildVarNode(VarNode node, string name) { foreach (VarNode childNode in node.Nodes) { if (childNode.Name == name) { return(childNode); } } return(null); }
private TypeInfo Visit(VarNode node, MethodBuilder builder, CodegenContext context) { context.LastVar = builder.MethodInfo.GetVar(node.VarName); if (context.LastVar == null) { context.LastVar = context.CurrentClass.GetField(node.VarName); } builder.LoadToStack(context.LastVar); return(context.LastVar.Type); }
public void RegisterInContext() { VarNode varnode = new VarNode("a", null, new ConstantNode(42)); ObjectNode node = new ObjectNode("Foo", varnode); Context context = new Context(); node.RegisterInContext(context); Assert.IsNotNull(context.GetValue("Foo")); Assert.IsNull(context.GetValue("a")); Assert.AreSame(node, context.GetValue("Foo")); }
static public void TestJSCreationFunction() { VarNode m_1 = new VarNode("link"); StrNode m_2 = new StrNode("to,text"); StrNode m_3 = new StrNode("[[_to|_text]]"); MacroNode m = new MacroNode("macro", new List <ASTNode>() { m_1, m_2, m_3 }); Console.WriteLine(m.ToTaggedJS()); }
public List <Node> GenerateUnit(List <string> lines, ref Vector2 point, ref Vector2 startPoint, string unitName = null) { var generatedNodes = new List <Node>(); int index = -1; while (index < lines.Count - 1) { var nodes = GenerateNode(lines, point, ref index, Root, false); if (nodes == null) { break; } if (nodes.All(x => x is FunctionNode)) { var func = nodes.Where(x => x is FunctionNode).Cast <FunctionNode>(); if (unitName != null) { foreach (var functionNode in func) { functionNode.UpdateUnitName(unitName); } } Functions.AddRange(func.ToDictionary(x => x.Name, x => x)); } else if (nodes.SingleOrDefault(x => x is VarNode) != null) { if (Vars == null) { Vars = nodes.First() as VarNode; Vars.transform.position = startPoint; startPoint.y += 300; } else { Vars.AddVars((nodes.First() as VarNode).Vars); } } else if (nodes.SingleOrDefault(x => x is ConstNode) != null) { nodes.SingleOrDefault().transform.position = startPoint; startPoint.y += 300; } else if (nodes.Any()) { generatedNodes.AddRange(nodes); point = new Vector2(point.x, nodes.Last().GetBottom().y) + new Vector2(0, -g_Margin); } } return(generatedNodes); }
public void CreateVarNodeWithoutTypeInfo() { string name = "foo"; TypeInfo typeinfo = TypeInfo.Int; IExpressionNode expression = new ConstantNode(42); VarNode node = new VarNode(name, null, expression); Assert.IsNull(node.TypeInfo); node.CheckType(null); Assert.AreSame(TypeInfo.Int, node.TypeInfo); }
void Clean(List <VarNode> toRemove, VarNode node, int updateId) { if (node.UpdateID != updateId) { toRemove.Add(node); } else { foreach (VarNode childNode in node.Nodes) { Clean(toRemove, childNode, updateId); } } }
public void RegisterInContext() { string name = "foo"; TypeInfo typeinfo = TypeInfo.Int; IExpressionNode expression = new ConstantNode(42); VarNode node = new VarNode(name, null, expression); Context context = new Context(); node.RegisterInContext(context); Assert.IsNotNull(context.GetValue("foo")); Assert.AreSame(node, context.GetValue("foo")); }
public void CheckType() { VarNode varn = new VarNode("foo", TypeInfo.Int, null); IContext context = new Context(); varn.RegisterInContext(context); NameNode target = new NameNode("foo"); ConstantNode expr = new ConstantNode(42); AssignmentNode node = new AssignmentNode(target, expr); node.CheckType(context); Assert.AreSame(TypeInfo.Int, target.TypeInfo); }
public MathFunc(MathFuncNode left, MathFuncNode right, VarNode variable = null, IEnumerable<ConstNode> parameters = null, bool simplify = true, bool calculateConstants = false) { LeftNode = left; RightNode = right; Root = RightNode; Variable = variable; if (Variable == null) ConstToVars(); if (parameters != null) Parameters = parameters.Except(parameters.Where(p => p.Name == Variable.Name)).ToDictionary(node => node.Name); FindParamsAndUnknownFuncs(Root); Root.Sort(); if (simplify) Root = Simplify(Root); if (calculateConstants) Root = Precompile(null, Root); }
public void ConstToVars() { if (LeftNode.Type == MathNodeType.Variable) Variable = (VarNode)LeftNode; if (LeftNode.Type == MathNodeType.Constant) Variable = new VarNode(LeftNode.Name); else if (LeftNode.Type == MathNodeType.Function) { Variable = null; if (LeftNode.Childs.Count > 1 && ((FuncNode)LeftNode).Childs[1] != null) { var secondNode = ((FuncNode)LeftNode).Childs[1]; if (secondNode.Type == MathNodeType.Constant) Variable = new VarNode(secondNode.Name); else if (secondNode.Type == MathNodeType.Variable) Variable = (VarNode)secondNode; } GetFirstParam(RightNode); if (Variable == null) Variable = new VarNode("x"); } ConstToVar(Root); if (Root.Name == Variable.Name) Root = Variable; }
protected void GetFirstParam(MathFuncNode node) { if (Variable == null) for (int i = 0; i < node.Childs.Count; i++) if (Variable == null) if (node.Childs[i].Type == MathNodeType.Constant) { Variable = new VarNode(node.Childs[i].Name); break; } else if (node.Childs[i].Type == MathNodeType.Variable) { Variable = (VarNode)node.Childs[i]; break; } else GetFirstParam(node.Childs[i]); }
/// <summary> /// var_stmt = "var" identifier ( "=" expr | ":" type ) /// </summary> private VarNode parseVarStmt() { if (!check(LexemType.Var)) return null; var node = new VarNode(); node.Name = ensure(LexemType.Identifier, ParserMessages.VarIdentifierExpected).Value; if (check(LexemType.Colon)) node.Type = ensure(parseType, ParserMessages.VarTypeExpected); else if(check(LexemType.Assign)) node.Value = ensure(parseExpr, ParserMessages.InitExpressionExpected); else error(ParserMessages.InitExpressionOrTypeExpected); return node; }