private static void BuildBlockToBlockStatement(Node node, Node nodeI, AST statementList) { if (node.children.Count > 1) { statementList.AddNode(node); } else { string content = string.Empty; Block block = nodeI as Block; Validity.Assert(block != null); Assignment a1 = null; Node n1 = statementList.GetNode(node.Guid); if (n1 is Assignment) { a1 = n1 as Assignment; // // Comment Jun: // This condition basically checks if the single line codeblock is either a full expression or a single ident // For now, in order to check for single ident, we check if the LHS if empty // This needs refinement bool isSingleIdent = string.IsNullOrEmpty((((Block)node).LHS)); if (isSingleIdent) { // This single line codeblock is a single identifier a1.right.Name = block.LHS != "" ? block.LHS : block.Name.Replace(";", "").Trim(); content = a1.ToScript(); } else { // This single line codeblock is a full expression content = ((Block)node).Name; } // Comment Jun: Create a new block that represents the new contents Block block2 = new Block(content, node.Guid); int index = statementList.nodeList.IndexOf(a1); statementList.RemoveNode(a1); statementList.nodeList.Insert(index, block2); statementList.nodeMap.Add(block2.Guid, block2); // Comment Jun: Reflect the new changes to the original block (node as Block).SetData(block2.LHS, content); } } }
private static void BuildBlockToFuncStatement(Node node, Node nodeFunc, AST statementList) { Validity.Assert(node is Block); if (node.children.Count > 1) { statementList.AddNode(node); } else { Assignment funcCall = (Assignment)statementList.GetNode(nodeFunc.Guid); Block block = node as Block; string lhs = string.Empty; string content = string.Empty; bool isSingleIdent = string.IsNullOrEmpty(block.LHS); if (isSingleIdent) { lhs = block.TrimName(); // Create the cnontents of the new block. // The rhs of the block is the rhs of the function call statement content = lhs + '=' + funcCall.left.Name; } else { lhs = block.LHS; content = block.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 // Comment Tron: Insert the new node into the index where the removed node was originally Block block2 = new Block(content, node.Guid); statementList.nodeList.Insert(index, block2); statementList.nodeMap.Add(block2.Guid, block2); // Comment Jun: Reflect the new changes to the original block (node as Block).SetData(block2.LHS, content); } }
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); } }
/// <summary> /// Create BinaryExpressionNode /// </summary> /// <param name="node"></param> /// <param name="outnode"></param> private void EmitBlockNode(Block node, out AssociativeNode outnode) { Validity.Assert(node != null); // TODO: Confirm that these children are returned in the order that they // appear in the code Dictionary<int, Node> childNodes = node.GetChildrenWithIndices(); // Parse program statement in node.Name string code = node.Name + ";"; ProtoCore.AST.AssociativeAST.CodeBlockNode codeBlockNode = (ProtoCore.AST.AssociativeAST.CodeBlockNode)ProtoCore.Utils.ParserUtils.Parse(code); Validity.Assert(codeBlockNode != null); List<ProtoCore.AST.AssociativeAST.AssociativeNode> astList = codeBlockNode.Body; Validity.Assert(astList.Count == 1); if (astList[0] is ProtoCore.AST.AssociativeAST.IdentifierNode) { ProtoCore.AST.AssociativeAST.BinaryExpressionNode ben = new ProtoCore.AST.AssociativeAST.BinaryExpressionNode(); ben.LeftNode = astList[0]; ben.Optr = ProtoCore.DSASM.Operator.assign; ProtoCore.AST.AssociativeAST.AssociativeNode statement = null; foreach (KeyValuePair<int, Node> kvp in childNodes) DFSTraverse(kvp.Value, out statement); ben.RightNode = statement; astList[0] = ben; } //I don't know what I am doing if (astList[0] is BinaryExpressionNode) { BinaryExpressionNode tempBen = astList[0] as BinaryExpressionNode; if (tempBen.LeftNode is IdentifierNode) { IdentifierNode identitiferNode = tempBen.LeftNode as IdentifierNode; if (identitiferNode.ArrayDimensions != null) { ArrayIndexerNode arrIndex = new ArrayIndexerNode(); arrIndex.ArrayDimensions = identitiferNode.ArrayDimensions; arrIndex.Array = identitiferNode; tempBen.LeftNode = arrIndex; } } if (tempBen.RightNode is IdentifierNode) { IdentifierNode identitiferNode = tempBen.RightNode as IdentifierNode; if (identitiferNode.ArrayDimensions != null) { ArrayIndexerNode arrIndex = new ArrayIndexerNode(); arrIndex.ArrayDimensions = identitiferNode.ArrayDimensions; arrIndex.Array = identitiferNode; tempBen.RightNode = arrIndex; } } astList[0] = tempBen; } //it should be correct, if not, debug? ProtoCore.AST.AssociativeAST.BinaryExpressionNode bNode = astList[0] as ProtoCore.AST.AssociativeAST.BinaryExpressionNode; Validity.Assert(bNode != null); bNode.Guid = node.Guid; //bNode.SplitFromUID = node.splitFomUint; // Child nodes are arguments to expression in bNode.RightNode. // Match child nodes with IdentifierNode's in bNode.RightNode - pratapa foreach (Node n in childNodes.Values) { AssociativeNode argNode = null; DFSTraverse(n, out argNode); // DFS traverse the bNode.RightNode and check for IdentifierNode's // and if their names match with the names of argNode, then replace // the IdentifierNode in bNode.RightNode with argNode BinaryExpressionNode ben = argNode as BinaryExpressionNode; Validity.Assert(ben != null); //ProtoCore.CodeGenDS codeGen = new ProtoCore.CodeGenDS(ben); AstCodeBlockTraverse sourceGen = new AstCodeBlockTraverse(ben); ProtoCore.AST.AssociativeAST.AssociativeNode right = bNode.RightNode; sourceGen.DFSTraverse(ref right); bNode.RightNode = right; } //(AstRootNode as CodeBlockNode).Body.Add(expressionNode); Validity.Assert(gc != null); gc.HandleNewNode(bNode); outnode = bNode; }
/* proc RewriteCodeBlock(Node codeblock) // Create new codeblocks for every line of code in the current codeblock CodeBlock[] newBlockList = new CodeBlock[node.lines.length] for n = 0 to node.lines.length newBlockList[n].code = node.lines[n] newBlockList[n].uid = generateUID(codeblock.uid) end // At this point, determine which parents of the current codeblock node need to be connected to each splitted node // Iterate through each parent of the current code block foreach parentNode in codeblock.parents // Iterate through each child of the parent for n = 0 to parentNode.children.length // Check if the child is this codeblock if parentNode.children[n] is equal to codeblock // index ‘n’ is the current output slot of the codeblock newBlockList[n].parent.push(parentNode) // Rewire the parent’s child to this new codeblock parentNode.children[n] = newBlockList[n] end n++; end end end */ /*private List<Block> RewriteCodeBlock(Block codeblock) { Validity.Assert(codeblock != null); if (codeblock.Name == null || codeblock.Name.Length <= 0) { return null; } // Comment Jun: Im just trying to find the number of times ';' occurs // Make this more efficient by turning this into a function in a utils class string dummy = codeblock.Name.Replace(";", ""); if ((codeblock.Name.Length - dummy.Length) <= 1) { // Single line codeblocks need not be split return null; } string[] token = new string[1]; token[0] = ProtoCore.DSASM.Constants.termline; StringSplitOptions opt = new StringSplitOptions(); string[] contents = codeblock.Name.Split(token, opt); int length = contents.Length; // The map of the new uid and its associated connecting slot Dictionary<int, uint> slotIndexToUIDMap = new Dictionary<int, uint>(); // Create new codeblocks for every line of code in the current codeblock CodeBlock[] newBlockList = new CodeBlock[node.lines.length] List<Block> newBlockList = new List<Block>(); for (int n = 0; n < length; n++) { // TODO Jun: Check with IDE why the semicolon is inconsitent string code = contents[n]; if (code.Length > 0 && code[0] != ';') { uint newGuid = GraphUtilities.GenerateUID(); List<AssignmentStatement> assignmentData = new List<AssignmentStatement>(); if (codeblock.assignmentData.Count > 0) { // This assignemnt data list must contain only 1 element // This element is associated witht he current line in the codeblock assignmentData.Add(codeblock.assignmentData[n]); } Block newBlock = new Block(code, newGuid, assignmentData); newBlock.splitFomUint = codeblock.Guid; newBlockList.Add(newBlock); slotIndexToUIDMap.Add(n, newGuid); } } // At this point, determine which parents of the current codeblock node need to be connected to each splitted node // Iterate through each parent of the current code block List<Node> parents = codeblock.GetParents(); foreach (Node parentNode in parents) { // Iterate through each child of the parent for (int childIndex = 0; childIndex < parentNode.children.Count; childIndex++) { Node child = null; bool foundIndex = parentNode.children.TryGetValue(childIndex, out child); if (foundIndex) { // Check if the child is this codeblock if (child.Guid == codeblock.Guid) { int fromIndex = parentNode.childConnections[childIndex].from; // Set the new codeblock's parent newBlockList[fromIndex].AddParent(parentNode); // Rewire the parent’s child to this new codeblock parentNode.RemoveChild(childIndex); parentNode.AddChild(newBlockList[fromIndex], childIndex, fromIndex); } } } } if (codeBlockUIDMap.ContainsKey(codeblock.Guid)) { codeBlockUIDMap[codeblock.Guid] = slotIndexToUIDMap; } else { codeBlockUIDMap.Add(codeblock.Guid, slotIndexToUIDMap); } return newBlockList; }*/ private List<Block> RewriteCodeBlock(Block codeblock) { Validity.Assert(codeblock != null); if (codeblock.Name == null || codeblock.Name.Length <= 0 ) { return null; } // Comment Aparajit: This check is erroneous and should be removed // It's there since in some Nunit tests, comment strings are being passed in here string dummy = codeblock.Name.Replace(";", ""); if ((codeblock.Name.Length - dummy.Length) <= 1) { return null; } //if (!codeblock.Name.EndsWith(";")) // codeblock.Name += ";"; List<ProtoCore.AST.Node> nodes = GraphUtilities.ParseCodeBlock(codeblock.Name); if (nodes.Count <= 1) { // Single line codeblocks need not be split return null; } int length = nodes.Count; // The map of the new uid and its associated connecting slot Dictionary<int, uint> slotIndexToUIDMap = new Dictionary<int, uint>(); // Create new codeblocks for every line of code in the current codeblock CodeBlock[] newBlockList = new CodeBlock[node.lines.length] List<Block> newBlockList = new List<Block>(); for (int n = 0; n < length; n++) { ProtoCore.AST.Node node = nodes[n]; Validity.Assert(node is ProtoCore.AST.AssociativeAST.BinaryExpressionNode); string code = ProtoCore.Utils.ParserUtils.ExtractStatementFromCode(codeblock.Name, node); if (code.Length > 0) { uint newGuid = GraphUtilities.GenerateUID(); List<AssignmentStatement> assignmentData = new List<AssignmentStatement>(); if (codeblock.assignmentData.Count > 0) { // This assignemnt data list must contain only 1 element // This element is associated witht he current line in the codeblock assignmentData.Add(codeblock.assignmentData[n]); } Block newBlock = new Block(code, newGuid, assignmentData); newBlock.splitFomUint = codeblock.Guid; newBlockList.Add(newBlock); slotIndexToUIDMap.Add(n, newGuid); } } // At this point, determine which parents of the current codeblock node need to be connected to each splitted node // Iterate through each parent of the current code block List<Node> parents = codeblock.GetParents(); foreach (Node parentNode in parents) { // Iterate through each child of the parent for (int childIndex = 0; childIndex < parentNode.children.Count; childIndex++) { Node child = null; bool foundIndex = parentNode.children.TryGetValue(childIndex, out child); if (foundIndex) { // Check if the child is this codeblock if (child.Guid == codeblock.Guid) { int fromIndex = parentNode.childConnections[childIndex].from; // Set the new codeblock's parent newBlockList[fromIndex].AddParent(parentNode); // Rewire the parent’s child to this new codeblock parentNode.RemoveChild(childIndex); parentNode.AddChild(newBlockList[fromIndex], childIndex, fromIndex); } } } } if (codeBlockUIDMap.ContainsKey(codeblock.Guid)) { codeBlockUIDMap[codeblock.Guid] = slotIndexToUIDMap; } else { codeBlockUIDMap.Add(codeblock.Guid, slotIndexToUIDMap); } return newBlockList; }