/// <summary> /// Represents simple binary expressions which involve literal on left and identifier on the right /// </summary> /// <param name="i1"></param> /// <param name="o"></param> /// <param name="i2"></param> internal BinExprNode(LiteralNode i1, Operator o, IdentNode i2) : base(i1.Name + o.Name + i2.Name, o.Guid) { op = o; left = i1; right = i2; }
private static int BuildFuncToIdentStatement(Node node, Node nodeI, Dictionary <int, Node> nodeDic, AST statementList, int j) { Assignment a1 = (Assignment)statementList.GetNode(node.Guid); IdentNode identNode = nodeI as IdentNode; Validity.Assert(null != identNode); List <int> keys = GetKeysFromValue(nodeDic, nodeI); FunctionCall f = ((FunctionCall)a1.right); if (keys.Count > 1) { do { f.parameters[keys[j]] = identNode; j++; } while (j < keys.Count); } else { f.parameters[keys[j]] = identNode; } j = 0; return(j); }
private void EmitIdentifierNode(IdentNode node, out AssociativeNode outnode) { Validity.Assert(node != null); Dictionary <int, Node> nodes = node.GetChildrenWithIndices(); Validity.Assert(nodes.Count <= 1); // Create BinaryExpressionNode with the lhs as the IdentifierNode and the rhs as the temp Node emitted from the child // Return the IdentifierNode BinaryExpressionNode expressionNode = new BinaryExpressionNode(); if (nodes.Count > 0) { AssociativeNode tmpNode = null; DFSTraverse(nodes[0], out tmpNode); expressionNode.RightNode = tmpNode; } else { // Create IdentifierNode and assign it to null expressionNode.RightNode = new NullNode(); } IdentifierNode leftNode = new IdentifierNode(node.Name); expressionNode.LeftNode = leftNode; expressionNode.Optr = ProtoCore.DSASM.Operator.assign; expressionNode.Guid = node.Guid; Validity.Assert(gc != null); gc.HandleNewNode(expressionNode); //(AstRootNode as CodeBlockNode).Body.Add(expressionNode); outnode = expressionNode; }
/// <summary> /// Represents binary expressions which involve identifier on the left and compound expression on the right /// </summary> /// <param name="e1"></param> /// <param name="op"></param> /// <param name="e2"></param> public BinExprNode(IdentNode e1, Operator op, Expr e2) : base(op.Name, op.Guid) { left = e1; this.op = op; right = e2; }
/// <summary> /// Represents simple binary expressions which involve identifier on left and literal on the right /// </summary> /// <param name="i1"></param> /// <param name="o"></param> /// <param name="i2"></param> internal BinExprNode(IdentNode i1, Operator o, LiteralNode i2) : base(i1.Name + o.Name + i2.Name, o.Guid) { op = o; left = i1; right = i2; }
private static void BuildBlockToIdentStatement(Node node, Node nodeIdent, AST statementList) { Validity.Assert(node is Block); if (node.children.Count > 1) { statementList.AddNode(node); } else { IdentNode identNode = nodeIdent as IdentNode; Validity.Assert(null != identNode); Block block = node as Block; string lhs = string.Empty; string content = string.Empty; bool isSingleIdent = string.IsNullOrEmpty(block.LHS); if (isSingleIdent) { lhs = block.TrimName(); } else { lhs = block.LHS; } // Create the cnontents of the new block. content = lhs + '=' + identNode.Name; // Comment Jun: Remove the current codeblock first // Codeblock removal is guid dependent Node nodeToRemove = statementList.GetNode(node.Guid); int index = statementList.nodeList.IndexOf(nodeToRemove); statementList.RemoveNode(nodeToRemove); // Comment Jun: Create a new block using the current guid // This new codeblock represents the new contents Block block2 = new Block(content, node.Guid); statementList.nodeList.Insert(index, block2); statementList.nodeMap.Add(block2.Guid, block2); statementList.AddNode(block2); // Comment Jun: Reflect the new changes to the original block (node as Block).SetData(block2.LHS, content); } }
private void EmitIdentifierNode(IdentNode node, out AssociativeNode outnode) { Validity.Assert(node != null); Dictionary<int, Node> nodes = node.GetChildrenWithIndices(); Validity.Assert(nodes.Count <= 1); // Create BinaryExpressionNode with the lhs as the IdentifierNode and the rhs as the temp Node emitted from the child // Return the IdentifierNode BinaryExpressionNode expressionNode = new BinaryExpressionNode(); if (nodes.Count > 0) { AssociativeNode tmpNode = null; DFSTraverse(nodes[0], out tmpNode); expressionNode.RightNode = tmpNode; } else { // Create IdentifierNode and assign it to null expressionNode.RightNode = new NullNode(); } IdentifierNode leftNode = new IdentifierNode(node.Name); expressionNode.LeftNode = leftNode; expressionNode.Optr = ProtoCore.DSASM.Operator.assign; expressionNode.Guid = node.Guid; Validity.Assert(gc != null); gc.HandleNewNode(expressionNode); //(AstRootNode as CodeBlockNode).Body.Add(expressionNode); outnode = expressionNode; }
internal Assignment(IdentNode identNodeL, IdentNode identNodeR) : base("=", identNodeL.Guid) { // TODO: Complete member initialization left = identNodeL; right = identNodeR; }
internal Assignment(IdentNode identNodeL, IdentNode identNodeR) : base("=", identNodeL.Guid) { // TODO: Complete member initialization left = identNodeL; right = identNodeR; }
/// <summary> /// Represents binary expressions which involve identifier on the left and compound expression on the right /// </summary> /// <param name="e1"></param> /// <param name="op"></param> /// <param name="e2"></param> public BinExprNode(IdentNode e1, Operator op, Expr e2) : base(op.Name, op.Guid) { left = e1; this.op = op; right = e2; }
public bool CreateIdentifierNode(uint guid, string identifier) { if (guid < 0) throw new ArgumentException("Invalid argument value!", "guid"); if (String.IsNullOrEmpty(identifier)) throw new ArgumentException("Invalid argument value!", "identifier"); IdentNode id = new IdentNode(identifier, guid); graph.AddNode(id); return true; // If failed, return 'false'. }