Example #1
0
        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));
        }
Example #2
0
        // 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));
                }
            }
        }
Example #3
0
        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;
     }
 }
Example #5
0
        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);
        }
Example #7
0
        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("");
            }
        }
Example #9
0
        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();
            }
        }
Example #10
0
		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)
		{
		}
Example #11
0
		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);
		}
Example #12
0
 /// <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);
 }
Example #13
0
        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"));
        }
Example #14
0
        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);
        }
Example #16
0
        //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
        }
Example #17
0
        private object VisitVarNode(VarNode node)
        {
            var varName = node.Value.ToString();

            if (!GlobalScope.ContainsKey(varName))
            {
                throw new VariableNameException(varName);
            }

            return(GlobalScope[varName]);
        }
Example #18
0
        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);
        }
Example #19
0
        public void EvalTest()
        {
            // Arrange
            string testVariable = "hhhhhhhhhhh1";
            double testValue    = 1384.34;

            // Act
            VarNode testVarNode = new VarNode(testVariable, testValue);

            // Assert
            Assert.AreEqual(testValue, testVarNode.Eval());
        }
Example #20
0
        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);
        }
Example #21
0
        /// <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);
        }
Example #22
0
        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);
        }
Example #23
0
        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);
        }
Example #24
0
        VarNode FindChildVarNode(VarNode node, string name)
        {
            foreach (VarNode childNode in node.Nodes)
            {
                if (childNode.Name == name)
                {
                    return(childNode);
                }
            }

            return(null);
        }
Example #25
0
        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);
        }
Example #26
0
        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"));
        }
Example #27
0
        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());
        }
Example #28
0
    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);
    }
Example #29
0
        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);
        }
Example #30
0
 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);
         }
     }
 }
Example #31
0
        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"));
        }
Example #32
0
        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);
        }
Example #33
0
		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);
		}
Example #34
0
		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;
		}
Example #35
0
		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]);
		}
Example #36
0
        /// <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;
        }