Beispiel #1
0
        /// <summary>
        /// Transforms Node to the Final ProtoAST form
        /// </summary>
        /// <returns></returns>
        public List<AssociativeNode> ToGraphIR(AST graph, GraphCompiler graphCompiler)
        {
            GraphNodeToASTGenerator astGen = new GraphNodeToASTGenerator(graph, graphCompiler);
            astGen.AddNodesToAST();
            List<ProtoCore.AST.AssociativeAST.AssociativeNode> irGraph = astGen.SplitAST();

            return irGraph;
        }
Beispiel #2
0
 static List<Node> DFS(Node node, AST statementList)
 {
     List<Node> sotedNodes = new List<Node>();
     Dictionary<Node, int> nodeStateMap = new Dictionary<Node, int>();
     if (IsNotVisited(node, nodeStateMap))
     {
         DFSVisit(node, nodeStateMap, sotedNodes, statementList);
     }
     return sotedNodes;
 }
        public void BuildGraphFromNodes(List<SnapshotNode> snapshotNodeList)
        {
            // Instantiate SynchronizeData and GraphCompiler
            SynchronizeData syncData = new SynchronizeData();
            syncData.AddedNodes = snapshotNodeList;

            GraphCompiler gc = GraphToDSCompiler.GraphCompiler.CreateInstance();
            GraphBuilder gb = new GraphBuilder(syncData, gc);

            gb.AddNodesToAST();
            gb.MakeConnectionsForAddedNodes();

            graph = gb.Graph;
        }
Beispiel #4
0
 static List<Node> DFS(AST graph)
 {
     List<Node> nodes = graph.GetNodes();
     List<Node> sotedNodes = new List<Node>();
     Dictionary<Node, int> nodeStateMap = new Dictionary<Node, int>();
     IEnumerable iter = nodes;
     foreach (Node node in iter)
     {
         if (IsNotVisited(node, nodeStateMap))
         {
             DFSVisit(node, nodeStateMap, sotedNodes);
         }
     }
     return sotedNodes;
 }
Beispiel #5
0
        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);
                }
            }
        }
Beispiel #6
0
        private static int BuildIdentToCodeBlockIdentStatement(Node node, Node nodeI, List<Node> nodes, AST statementList, int j)
        {
            Block block = nodeI as Block;
            Validity.Assert(block != null);

            // Comment Jun: Check if the codeblock is a single ident
            string lhs = block.LHS;
            if (string.IsNullOrEmpty(lhs))
            {
                lhs = block.TrimName();
            }

            Assignment a = new Assignment((IdentNode)node, new IdentNode(lhs, block.Guid));
            if (statementList.nodeMap.ContainsKey(a.Guid))
            {
                int index = statementList.nodeList.IndexOf(statementList.GetNode(a.Guid));
                statementList.RemoveNode(statementList.GetNode(a.Guid));

                statementList.nodeList.Insert(index, a);
                statementList.nodeMap.Add(a.Guid, a);
            }
            else
            {
                statementList.AddNode(a);
            }
                
            return ++j;
        }
Beispiel #7
0
 public static List<Node> sort(Node node, AST statementList)
 {
     return DFS(node, statementList);
 }
Beispiel #8
0
        /**/
        public List<uint> ConnectionToUID(List<Connection> input)
        {
            List<uint> result = new List<uint>();
            foreach (Connection inputConnection in input)
            {
                result.Add(inputConnection.OtherNode);
            }
            return result;
        }

        /*Tron: Use for node to code function
         *For each connected component of the graph, generate a respective string of code
         */
        public List<SnapshotNode> ToCode(AST graph, GraphCompiler originalGC, List<SnapshotNode> inputs)
        {
            List<SnapshotNode> result = new List<SnapshotNode>();

            List<Node> li = TopSort.sort(graph);
            tguid = 20000;
            List<string> listIslands = new List<string>();
            List<Node> islandNodes = new List<Node>();
            int countIslands = 0;
            statementList = new AST();
            ModifiedStmtGuidList.Clear();
            List<string> importIslands = new List<string>();
            IEnumerable iter = li;
            List<Node> islandNodeList = new List<Node>();
            //List<List<Node>> listing = new List<List<Node>>();
            List<Node> listing = new List<Node>();
            foreach (Node node in iter)
            {
                if (node != null)
                {
                    if (node is ImportNode)
                    {
                        importIslands.Add(node.ToScript() + ProtoCore.DSASM.Constants.termline);
                    }
                    else if (node.IsIsland)
                    {
                        countIslands++;
                        if (node is ArrayNode)
                        {
                            BuildArrayNodeStatement(node, statementList);
                            if (!islandNodes.Contains(node))
                                islandNodes.Add(node);
                            string island = statementList.GetNode(node.Guid).ToScript() + ProtoCore.DSASM.Constants.termline;
                            if (!listIslands.Contains(island))
                                listIslands.Add(island);
                        }
                        else if (node is LiteralNode)
                        {
                            BuildLiteralNodeStatement(node, statementList);
                            string island = statementList.GetNode(node.Guid).ToScript() + ProtoCore.DSASM.Constants.termline;
                            if (!listIslands.Contains(island))
                                listIslands.Add(island);
                        }
                        else if (node is Func)
                        {
                            BuildFunctionCallStatement(node, statementList);
                            string island = statementList.GetNode(node.Guid).ToScript() + ProtoCore.DSASM.Constants.termline;
                            if (!listIslands.Contains(island))
                                listIslands.Add(island);
                        }
                        else if (node is Operator)
                        {
                            BuildOperatorStatement(node, statementList);
                            string island = statementList.GetNode(node.Guid).ToScript() + ProtoCore.DSASM.Constants.termline;
                            if (!listIslands.Contains(island))
                                listIslands.Add(island);
                        }
                        else if (node is Block)
                        {
                            BuildBlockStatement(node, statementList);
                            islandNodes.Add(node);
                            //string island = statementList.GetNode(node.Guid).ToScript() + ProtoCore.DSASM.Constants.termline;
                            //if (!listIslands.Contains(island))
                              //  listIslands.Add(island);
                        }
                        else if (node is IdentNode)
                        {
                            // comment Jun:
                            // An island identifier node is handled by emitting a null as its rhs
                            statementList.AddNode(node);
                            string contents = statementList.GetNode(node.Guid).ToScript() + "=" + ProtoCore.DSASM.Literal.Null + ProtoCore.DSASM.Constants.termline;
                            listIslands.Add(contents);
                        }
                        else
                        {
                            statementList.AddNode(node);
                            string island = node.ToScript() + ProtoCore.DSASM.Constants.termline;
                            if (!listIslands.Contains(island))
                                listIslands.Add(island);
                        }
                        islandNodeList.Add(node);
                        listing = listing.ToList().Union<Node>(BuildStatement(node, statementList)).ToList();
                        HandleNewNode(node);
                    }
                    else if (node.IsLeaf)
                    {
                        if (node is ArrayNode)
                        {
                            BuildArrayNodeStatement(node, statementList);
                        }
                        else if (node is LiteralNode)
                        {
                            BuildLiteralNodeStatement(node, statementList);
                        }
                        else if (node is Func)
                        {
                            BuildFunctionCallStatement(node, statementList);
                        }
                        else if (node is Operator)
                        {
                            BuildOperatorStatement(node, statementList);
                        }
                        else if (node is Block)
                        {
                            BuildBlockStatement(node, statementList);
                        }
                        else if (node is IdentNode)
                        {
                            statementList.AddNode(node);
                            string contents = statementList.GetNode(node.Guid).ToScript() + "=" + ProtoCore.DSASM.Literal.Null + ProtoCore.DSASM.Constants.termline;
                            listIslands.Add(contents);
                        }
                        HandleNewNode(node);
                    }
                    else if (node.IsRoot && !node.IsIsland)
                    {
                        if (node is Operator)
                        {
                            BuildOperatorStatement(node, statementList);
                        }
                        else if (node is Func)
                        {
                            BuildFunctionCallStatement(node, statementList);
                        }
                        else if (node is Block)
                        {
                            BuildBlockStatement(node, statementList);
                        }
                        //liststat = BuildStatement(node, statementList);
                        //finalScript=finalScript.Union(BuildStatement(node, statementList)).ToList();
                        
                        //comment out for NodeToCode function
                        //listing.Add(BuildStatement(node, statementList));
                        listing = BuildStatement(node, statementList);
                        HandleNewNode(node);
                    }
                    else if (node is Operator)
                    {
                        BuildOperatorStatement(node, statementList);
                        HandleNewNode(node);
                    }
                    else if (node is Func)
                    {
                        BuildFunctionCallStatement(node, statementList);
                        HandleNewNode(node);
                    }
                    else if (node is ArrayNode)
                    {
                        BuildArrayNodeStatement(node, statementList);
                        HandleNewNode(node);
                    }
                    else if (node is LiteralNode)
                    {
                        BuildLiteralNodeStatement(node, statementList);
                        HandleNewNode(node);
                    }
                    else if (node is Block)
                    {
                        BuildBlockStatement(node, statementList);
                        listing = BuildStatement(node, statementList);
                        HandleNewNode(node);
                    }
                }
            }
            StringBuilder builder = new StringBuilder();
            foreach (string island in importIslands)// Loop through all strings
            {
                builder.Append(island);             // Append string to StringBuilder
            }
            foreach (string island in listIslands)  // Loop through all strings
            {
                builder.Append(island);             // Append string to StringBuilder
            }

            /*N2C*/
            #region get connected components of the graph
            List<Node> nodeToCodeInputList = new List<Node>();
            List<List<Node>> listingAlternate = new List<List<Node>>();
            List<List<Node>> listingAlt2 = new List<List<Node>>();
            if (nodeToCodeUIDs.Count != 0)
            {
                foreach (uint nodeID in nodeToCodeUIDs)
                {
                    if (graph.GetNode(nodeID) != null)
                    {
                        nodeToCodeInputList.Add(graph.GetNode(nodeID));
                    }
                    else
                    {
                        if (this.codeBlockUIDMap[nodeID] != null)
                        {
                            foreach (KeyValuePair<int, uint> pair in this.codeBlockUIDMap[nodeID])
                            {
                                nodeToCodeInputList.Add(graph.GetNode(pair.Value));
                            }
                        }
                    }
                }
                //listingAlternate = GetConnectedComponents(nodeToCodeInputList, graph);
                listingAlt2 = GetConnectedComponents_02(nodeToCodeInputList, graph);
            }
            #endregion

            //foreach (List<Node> n1 in listing)
            //{
            //    foreach (Node n2 in n1)
            //        if (!finalScript.Contains(n2))
            //            finalScript.Add(n2);
            //        else
            //        {
            //            finalScript.Remove(n2);
            //            finalScript.Add(n2);
            //        }
            //}
            listing = SortCodeBlocks(listing);
            List<List<Node>> finalList = new List<List<Node>>();
            foreach (List<Node> l1 in listingAlt2)
            {
                List<Node> temp = new List<Node>();
                foreach (Node n1 in l1)
                    foreach (Node listingNode in listing)
                        if (listingNode.Guid == n1.Guid)
                            temp.Add(listingNode);
                if (temp.Count != 0)
                    finalList.Add(temp);
            }            
            islandNodeList = islandNodeList.Union(islandNodes).ToList();
            //islandNodeList = SortCodeBlocks(islandNodeList);
            //if (islandNodeList.Count != 0)
            //    finalList.Add(islandNodeList);

            #region generate code and snapshot node
            uint id = 0;
            foreach (List<Node> nodeList in finalList)
            {
                string output = "";
                List<Node> tempList = SortCodeBlocks(nodeList);
                //tempList.Reverse();
                foreach (Node node in tempList)
                {
                    if (nodeToCodeUIDs.Contains(node.Guid))
                    {
                        if (node.ToCode() != null)
                            output += node.ToCode().Replace(";", "") + ProtoCore.DSASM.Constants.termline;
                    }
                    else
                    {
                        foreach (KeyValuePair<uint, Dictionary<int, uint>> pair in this.codeBlockUIDMap)
                        {
                            if (pair.Value.ContainsValue(node.Guid))
                            {
                                output += node.ToCode().Replace(";", "") + ProtoCore.DSASM.Constants.termline; //ensure only one semicolon at the end of a statement, by request from UI
                            }
                        }
                    }    
                }
                output = output.TrimEnd('\n');
                SnapshotNode ssn = new SnapshotNode();
                ssn.Id = id++;
                ssn.Content = output;
                ssn.Type = SnapshotNodeType.CodeBlock;
                ssn.InputList = new List<Connection>();

                foreach (SnapshotNode inputNode in inputs)
                {
                    foreach (Node subTreeNode in nodeList)
                    {
                        if (inputNode.Id == subTreeNode.Guid)
                        {
                            foreach (Connection c1 in inputNode.InputList)
                            {
                                if (!IsInternalConnection(c1, this))                //the connection is not internal, return it back to UI
                                {
                                    Connection newInputConnection = new Connection();
                                    newInputConnection.OtherNode = c1.OtherNode;
                                    newInputConnection.OtherIndex = c1.OtherIndex;
                                    newInputConnection.IsImplicit = c1.IsImplicit;
                                    string[] tokens = graph.GetNode(c1.OtherNode).Name.Split('=');
                                    newInputConnection.LocalName = tokens[0];
                                    ssn.InputList.Add(newInputConnection);
                                }
                            }
                        }
                        else if (codeBlockUIDMap.ContainsKey(inputNode.Id))         //inputNode was split
                        {
                            if (codeBlockUIDMap[inputNode.Id].ContainsValue(subTreeNode.Guid))
                            {
                                foreach (Connection c1 in inputNode.InputList)
                                {
                                    if (!IsInternalConnection(c1, this))
                                    {
                                        int indexSlot = 0;
                                        foreach (KeyValuePair<int, uint> pair in codeBlockUIDMap[inputNode.Id])
                                        {
                                            if (pair.Value == subTreeNode.Guid)
                                                indexSlot = pair.Key;
                                        }
                                        if (c1.OtherIndex == indexSlot)
                                        {
                                            Connection newInputConnection = new Connection();
                                            newInputConnection.OtherNode = c1.OtherNode;
                                            newInputConnection.OtherIndex = c1.OtherIndex;
                                            foreach (KeyValuePair<uint, Dictionary<int, uint>> pair in originalGC.codeBlockUIDMap)
                                            {
                                                if (pair.Value.ContainsValue(c1.OtherNode))                     //this means if the other node was split, return the original Id that was sent to us by the UI
                                                {
                                                    newInputConnection.OtherNode = pair.Key;
                                                    newInputConnection.OtherIndex = pair.Value.First(x => x.Value == c1.OtherNode).Key;
                                                }
                                            }
                                            newInputConnection.IsImplicit = c1.IsImplicit;
                                            string[] tokens = graph.GetNode(c1.OtherNode).Name.Split('=');
                                            newInputConnection.LocalName = tokens[0];
                                            ssn.InputList.Add(newInputConnection);
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
                ssn.OutputList = new List<Connection>();
                foreach (SnapshotNode inputNode in inputs)
                {
                    foreach (Node subTreeNode in nodeList)
                    {
                        //if (subTreeNode.Name.Split('=')[0] == outputCnt.LocalName)
                        if (inputNode.Id == subTreeNode.Guid)
                        {
                            foreach (Connection c1 in inputNode.OutputList)
                            {
                                if (!IsInternalConnection(c1, this))
                                {
                                    Connection newOutputConnection = new Connection();
                                    newOutputConnection.OtherNode = c1.OtherNode;
                                    newOutputConnection.OtherIndex = c1.OtherIndex;
                                    newOutputConnection.IsImplicit = c1.IsImplicit;
                                    newOutputConnection.LocalName = c1.LocalName;
                                    ssn.OutputList.Add(newOutputConnection);
                                }
                            }
                        }

                        else if (codeBlockUIDMap.ContainsKey(inputNode.Id))         //inputNode was split
                        {
                            if (codeBlockUIDMap[inputNode.Id].ContainsValue(subTreeNode.Guid))
                            {
                                foreach (Connection c1 in inputNode.OutputList)
                                {
                                    if (!IsInternalConnection(c1, this))
                                    {
                                        int indexSlot = 0;
                                        foreach (KeyValuePair<int, uint> pair in codeBlockUIDMap[inputNode.Id])
                                        {
                                            if (pair.Value == subTreeNode.Guid)
                                            {
                                                indexSlot = pair.Key;
                                                break;
                                            }
                                        }
                                        if (c1.LocalIndex == indexSlot)
                                        {
                                            Connection newOutputConnection = new Connection();
                                            newOutputConnection.OtherNode = c1.OtherNode;
                                            newOutputConnection.OtherIndex = c1.OtherIndex;
                                            foreach (KeyValuePair<uint, Dictionary<int, uint>> pair in originalGC.codeBlockUIDMap)
                                            {
                                                if (pair.Value.ContainsValue(c1.OtherNode))                     //this means if the other node was split, return the original Id that was sent to us by the UI
                                                {
                                                    newOutputConnection.OtherNode = pair.Key;
                                                    newOutputConnection.OtherIndex = pair.Value.First(x => x.Value == c1.OtherNode).Key;
                                                }
                                            }
                                            newOutputConnection.IsImplicit = c1.IsImplicit;
                                            newOutputConnection.LocalName = c1.LocalName;
                                            ssn.OutputList.Add(newOutputConnection);
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
                result.Add(ssn);
            }
            #endregion

            #region remove _temp_xxx name
            //Dictionary<string, string> tempReplaceValue = new Dictionary<string, string>();
            //for (int i = 0; i < result.Count; i++)
            //{
            //    SnapshotNode ssn = result[i];
            //    string[] statements = ssn.Content.Split(';');
            //    for (int j = 0; j < statements.Length; j++)
            //    {
            //        string statement = statements[j];
            //        string lhsTempName = statement.Split('=')[0].Replace("\n", "").Trim();
            //        foreach (Node astNode in graph.nodeList)
            //        {
            //            if (astNode.Name.Split('=')[0].Trim() == lhsTempName && lhsTempName.StartsWith("_temp_"))
            //            {
            //                //this means in the ast there is some statement _temp_abc = something
            //                //which means the _temp_xxx is generated, not typed in by users
            //                tempReplaceValue.Add(lhsTempName, statement.Split('=')[1].Replace("\n", "").Trim());
            //            }
            //        }
            //    }
            //}
            //for (int i = 0; i < result.Count; i++)
            //{
            //    SnapshotNode ssn = result[i];
            //    foreach (KeyValuePair<string, string> pair in tempReplaceValue)
            //    {
            //        ssn.Content.Replace(pair.Key, pair.Value);
            //    }
            //}
            #endregion

            #region replace _temp_ name with more elegant name
            //int tempId = 0;
            //for (int i = 0; i < result.Count; i++)
            //{
            //    SnapshotNode ssn = result[i];
            //    string[] statements = ssn.Content.Split(';');
            //    for (int j = 0; j < statements.Length; j++)
            //    {
            //        string statement = statements[j];
            //        string lhsTempName = statement.Split('=')[0].Replace("\n", "").Trim();
            //        foreach (Node astNode in graph.nodeList)
            //        {
            //            if (astNode.Name.Split('=')[0].Trim() == lhsTempName && lhsTempName.StartsWith("_temp_"))
            //            {
            //                string newTempName = "temp_" + tempId++;
            //                for (int k = 0; k < result.Count; k++)
            //                {
            //                    result[k].Content = result[k].Content.Replace(lhsTempName, newTempName);
            //                }
            //            }
            //        }
            //        if (statement.Split('=').Length > 1)
            //        {
            //            string rhsTempName = statement.Split('=')[1].Replace("\n", "").Trim();
            //            foreach (Node astNode in graph.nodeList)
            //            {
            //                if (astNode.Name.Split('=')[0].Trim() == rhsTempName && rhsTempName.StartsWith("_temp_"))
            //                {
            //                    string newTempName = "temp_" + tempId++;
            //                    for (int k = 0; k < result.Count; k++)
            //                    {
            //                        result[k].Content = result[k].Content.Replace(rhsTempName, newTempName);
            //                    }
            //                }
            //            }
            //        }
            //    }
            //}
            #endregion

            #region return to original input connections
            for (int i = 0; i < result.Count; i++)
            {
                SnapshotNode ssn = result[i];
                for (int j = 0; j < ssn.InputList.Count; j++)
                {
                    Connection inputConnection = ssn.InputList[j];
                    foreach (KeyValuePair<uint, Dictionary<int, uint>> kvp in originalGC.codeBlockUIDMap)
                    {
                        foreach (KeyValuePair<int, uint> kvp2 in kvp.Value)
                        {
                            if (kvp2.Value == inputConnection.OtherNode)
                            {
                                Connection oldInputConnection = new Connection();
                                oldInputConnection.OtherNode = kvp.Key;
                                oldInputConnection.OtherIndex = inputConnection.OtherIndex;
                                oldInputConnection.IsImplicit = inputConnection.IsImplicit;
                                oldInputConnection.LocalName = inputConnection.LocalName;
                                oldInputConnection.LocalIndex = inputConnection.LocalIndex;
                                ssn.InputList.Remove(inputConnection);
                                ssn.InputList.Insert(j, oldInputConnection);
                            }
                        }
                    }
                }

                for (int j = 0; j < ssn.OutputList.Count; j++)
                {
                    Connection outputConnection = ssn.OutputList[j];
                    foreach (KeyValuePair<uint, Dictionary<int, uint>> kvp in originalGC.codeBlockUIDMap)
                    {
                        foreach (KeyValuePair<int, uint> kvp2 in kvp.Value)
                        {
                            if (kvp2.Value == outputConnection.OtherNode)
                            {
                                Connection oldInputConnection = new Connection();
                                oldInputConnection.OtherNode = kvp.Key;
                                oldInputConnection.OtherIndex = outputConnection.OtherIndex;
                                oldInputConnection.IsImplicit = outputConnection.IsImplicit;
                                oldInputConnection.LocalName = outputConnection.LocalName;
                                oldInputConnection.LocalIndex = outputConnection.LocalIndex;
                                ssn.OutputList.Remove(outputConnection);
                                ssn.OutputList.Insert(j, oldInputConnection);
                            }
                        }
                    }
                }
            }
            #endregion
            /*Chirag's
            foreach (var value in finalScript)
            {
                if (nodeToCodeUIDs.Contains((value as Node).Guid))
                    if (value.ToCode() != null)
                        liststat += value.ToCode() + ProtoCore.DSASM.Constants.termline;
            }
            liststat = builder.ToString() + liststat;
            //liststat += builder.ToString();
            //GraphUtilities.runningUID = GraphToDSCompiler.Constants.UIDStart;
            //result.AddRange(liststat.Split(';'));
            */
            UpdateAddedNodesInModifiedNameList();

            return result;
        }
Beispiel #9
0
 private static int BuildOperatorToOperatorStatement(Node node, Node nodeI, Dictionary<int, Node> nodeDic, AST statementList, int j)
 {
     Assignment a1 = (Assignment)statementList.GetNode(node.Guid);
     Assignment a2 = (Assignment)statementList.GetNode(nodeI.Guid);
     List<int> keys = GetKeysFromValue(nodeDic, nodeI);
     if (keys.Count > 1)
     {
         if (keys[j] == 0)
         {
             ((BinExprNode)a1.right).left = a2.left; if (keys.Count == 2) ++j;
         }
         else
         {
             ((BinExprNode)a1.right).right = a2.left; if (keys.Count == 2) ++j;
         }
     }
     else
     {
         if (keys[0] == 0)
         {
             ((BinExprNode)a1.right).left = a2.left; if (keys.Count == 2) ++j;
         }
         else
         {
             ((BinExprNode)a1.right).right = a2.left; if (keys.Count == 2) ++j;
         }
     }
     return j;
 }
Beispiel #10
0
        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);
        }
Beispiel #11
0
        private static int BuildFuncToBlockStatement(Node node, Node nodeI, Dictionary <int, Node> nodeDic, AST statementList, int j)
        {
            Assignment   a1    = (Assignment)statementList.GetNode(node.Guid);
            Block        block = nodeI as Block;
            List <int>   keys  = GetKeysFromValue(nodeDic, nodeI);
            FunctionCall f     = ((FunctionCall)a1.right);

            if (keys.Count > 1)
            {
                do
                {
                    f.parameters[keys[j]] = new IdentNode(block.LHS, block.Guid);
                    j++;
                } while (j < keys.Count);
            }
            else
            {
                f.parameters[keys[j]] = new IdentNode(block.LHS, block.Guid);
            }
            j = 0;
            return(j);
        }
Beispiel #12
0
        private static int BuildIdentToCodeBlockIdentStatement(Node node, Node nodeI, List <Node> nodes, AST statementList, int j)
        {
            Block block = nodeI as Block;

            Validity.Assert(block != null);

            // Comment Jun: Check if the codeblock is a single ident
            string lhs = block.LHS;

            if (string.IsNullOrEmpty(lhs))
            {
                lhs = block.TrimName();
            }

            Assignment a = new Assignment((IdentNode)node, new IdentNode(lhs, block.Guid));

            if (statementList.nodeMap.ContainsKey(a.Guid))
            {
                int index = statementList.nodeList.IndexOf(statementList.GetNode(a.Guid));
                statementList.RemoveNode(statementList.GetNode(a.Guid));

                statementList.nodeList.Insert(index, a);
                statementList.nodeMap.Add(a.Guid, a);
            }
            else
            {
                statementList.AddNode(a);
            }

            return(++j);
        }
Beispiel #13
0
 public static List <Node> sort(Node node, AST statementList)
 {
     return(DFS(node, statementList));
 }
Beispiel #14
0
 public static List <Node> sort(AST graph)
 {
     return(DFS(graph));
 }
Beispiel #15
0
        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;
        }
Beispiel #16
0
        private static void BuildIdentToIdentStatement(Node node, Node nodeI, AST statementList)
        {
            Assignment a = new Assignment((IdentNode)node, (IdentNode)nodeI);
            if (statementList.nodeMap.ContainsKey(node.Guid))
            {
                Node nodeToRemove = statementList.GetNode(a.Guid);
                int index = statementList.nodeList.IndexOf(nodeToRemove);
                statementList.RemoveNode(nodeToRemove);

                statementList.nodeList.Insert(index, a);
                statementList.nodeMap.Add(a.Guid, a);
            }
            else
                statementList.AddNode(a);
        }
Beispiel #17
0
        private static int BuildOperatorToOperatorStatement(Node node, Node nodeI, Dictionary <int, Node> nodeDic, AST statementList, int j)
        {
            Assignment a1   = (Assignment)statementList.GetNode(node.Guid);
            Assignment a2   = (Assignment)statementList.GetNode(nodeI.Guid);
            List <int> keys = GetKeysFromValue(nodeDic, nodeI);

            if (keys.Count > 1)
            {
                if (keys[j] == 0)
                {
                    ((BinExprNode)a1.right).left = a2.left; if (keys.Count == 2)
                    {
                        ++j;
                    }
                }
                else
                {
                    ((BinExprNode)a1.right).right = a2.left; if (keys.Count == 2)
                    {
                        ++j;
                    }
                }
            }
            else
            {
                if (keys[0] == 0)
                {
                    ((BinExprNode)a1.right).left = a2.left; if (keys.Count == 2)
                    {
                        ++j;
                    }
                }
                else
                {
                    ((BinExprNode)a1.right).right = a2.left; if (keys.Count == 2)
                    {
                        ++j;
                    }
                }
            }
            return(j);
        }
Beispiel #18
0
        //
        // TODO Jun: Re-evaluate the topsort implementation
        //
        static void DFSVisit(Node node, Dictionary<Node, int> nodeStateMap, List<Node> list, AST statementList)
        {
            nodeStateMap.Add(node, VISITING);
            List<Node> nodes = node.GetChildren();
            Dictionary<int, Node> nodeDic = node.GetChildrenWithIndices();
            IEnumerable iter = nodes;
            int j = 0;
            foreach (Node nodeI in iter)
            {
                if (node is IdentNode && nodeI is LiteralNode)
                {
                    BuildIdentToLiteralStatement(node, nodeI, statementList);
                }
                else if (node is IdentNode && nodeI is IdentNode)
                {
                    BuildIdentToIdentStatement(node, nodeI, statementList);
                }
                else if (node is IdentNode && nodeI is Block)
                {
                    Block blocknode = (Block)nodeI;
                    if (GraphBuilder.AnalyzeString(blocknode.Name) == SnapshotNodeType.Literal)
                    {
                        LiteralNode literal = new LiteralNode(blocknode.content, nodeI.Guid);
                        BuildIdentToLiteralStatement(node, literal, statementList);
                    }
                    else
                    {
                        j = BuildIdentToCodeBlockIdentStatement(node, nodeI, nodes, statementList, j);
                    }
                }
                else if (node is Operator && nodeI is Block)
                {
                    j = BuildOperatorToBlockStatement(node, nodeI, nodeDic, statementList, j);
                }
                else if (node is Func && nodeI is Block)
                {
                    j = BuildFuncToBlockStatement(node, nodeI, nodeDic, statementList, j);
                }
                else if (node is Func && nodeI is IdentNode)
                {
                    j = BuildFuncToIdentStatement(node, nodeI, nodeDic, statementList, j);
                }
                else if (node is IdentNode && nodeI is Operator)
                {
                    BuildIdentToOperatorStatement(node, statementList, nodeI);
                }
                else if (node is Operator && nodeI is Operator)
                {
                    j = BuildOperatorToOperatorStatement(node, nodeI, nodeDic, statementList, j);
                }
                else if (node is IdentNode && nodeI is Func)
                {
                    BuildIdentToFuncStatement(node, nodeI, statementList);
                }
                else if (node is Func && nodeI is Func)
                {
                    j = BuildFuncToFuncStatement(node, nodeI, nodeDic, statementList, j);
                }
                else if (node is Operator && nodeI is Func)
                {
                    j = BuildOperatorToOperatorStatement(node, nodeI, nodeDic, statementList, j);
                }
                else if (node is Func && nodeI is Operator)
                {
                    j = BuildFuncToFuncStatement(node, nodeI, nodeDic, statementList, j);
                }
                else if ((node is Operator && nodeI is ArrayNode) || (node is Operator && nodeI is LiteralNode))
                { 
                    j = BuildOperatorToOperatorStatement(node, nodeI, nodeDic, statementList, j);
                }
                else if ((node is Func && nodeI is ArrayNode) || (node is Func && nodeI is LiteralNode))
                {
                    j = BuildFuncToFuncStatement(node, nodeI, nodeDic, statementList, j);
                }
                else if ((node is Block && nodeI is Block))
                {
                    BuildBlockToBlockStatement(node, nodeI, statementList);
                }
                else if ((node is Block && nodeI is Func))
                {
                    BuildBlockToFuncStatement(node, nodeI, statementList);
                }
                else if ((node is Block && nodeI is Operator))
                {
                    BuildBlockToFuncStatement(node, nodeI, statementList);
                }
                else if ((node is Block && nodeI is IdentNode))
                {
                    BuildBlockToIdentStatement(node, nodeI, statementList);
                }
                /*Block to Operator*/
                else if (node is Block && nodeI is Operator)
                {
                    //BuildBlockToOperatorStatement(node, nodeI, statementList);
                }
                //else if ((node is Block && nodeI is Func))
                //{
                //    BuildBlockToBlockStatement(node, nodeI, statementList);
                //}
                else
                {
                    if (node is Operator)
                    {
                        if (nodes.IndexOf(nodeI, j) == 0)
                        {
                            Assignment a = (Assignment)statementList.GetNode(node.Guid);
                            ((BinExprNode)a.right).left = nodeI;
                            ++j;
                        }
                        else
                        {
                            Assignment a = (Assignment)statementList.GetNode(node.Guid);
                            ((BinExprNode)a.right).right = nodeI;
                        }
                    }
                    else if (node is Func)
                    {
                        Assignment a = (Assignment)statementList.GetNode(node.Guid);
                        FunctionCall f = ((FunctionCall)a.right);
                        f.parameters[nodes.IndexOf(nodeI, j)] = nodeI;
                        j = 0;
                    }
                }

                if (IsNotVisited(nodeI, nodeStateMap))
                {
                    DFSVisit(nodeI, nodeStateMap, list, statementList);
                }
            }
            nodeStateMap[node] = VISITED;
            list.Add(node);
        }
Beispiel #19
0
        private static int BuildFuncToFuncStatement(Node node, Node nodeI, Dictionary <int, Node> nodeDic, AST statementList, int j)
        {
            Assignment   a1   = (Assignment)statementList.GetNode(node.Guid);
            Assignment   a2   = (Assignment)statementList.GetNode(nodeI.Guid);
            List <int>   keys = GetKeysFromValue(nodeDic, nodeI);
            FunctionCall f    = ((FunctionCall)a1.right);

            if (keys.Count > 1)
            {
                do
                {
                    f.parameters[keys[j]] = a2.left; j++;
                } while (j < keys.Count);
            }
            else
            {
                f.parameters[keys[j]] = a2.left;
            }
            j = 0;
            return(j);
        }
Beispiel #20
0
        List<Node> BuildStatement(Node node, AST statementList)
        {
            //statementList.RemoveNode(node);
            List<Node> l = TopSort.sort(node, statementList);
            //if (node is Block)
            //{
            //    
            //    statementList.AddNode(node);
            //}
            List<uint> guid = new List<uint>();
            IEnumerable iter = l;
            string liststat = "";
            foreach (Node nodus in iter)
            {
                if (nodus != null)
                {
                    guid.Add(nodus.Guid);
                }
            }

            List<Node> nodes = new List<Node>(statementList.GetNodes());
            foreach (var value in nodes)
            {
                liststat += value.ToScript() + ProtoCore.DSASM.Constants.termline;
            }

            return nodes;
        }
Beispiel #21
0
        //
        // TODO Jun: Re-evaluate the topsort implementation
        //
        static void DFSVisit(Node node, Dictionary <Node, int> nodeStateMap, List <Node> list, AST statementList)
        {
            nodeStateMap.Add(node, VISITING);
            List <Node>            nodes   = node.GetChildren();
            Dictionary <int, Node> nodeDic = node.GetChildrenWithIndices();
            IEnumerable            iter    = nodes;
            int j = 0;

            foreach (Node nodeI in iter)
            {
                if (node is IdentNode && nodeI is LiteralNode)
                {
                    BuildIdentToLiteralStatement(node, nodeI, statementList);
                }
                else if (node is IdentNode && nodeI is IdentNode)
                {
                    BuildIdentToIdentStatement(node, nodeI, statementList);
                }
                else if (node is IdentNode && nodeI is Block)
                {
                    Block blocknode = (Block)nodeI;
                    if (GraphBuilder.AnalyzeString(blocknode.Name) == SnapshotNodeType.Literal)
                    {
                        LiteralNode literal = new LiteralNode(blocknode.content, nodeI.Guid);
                        BuildIdentToLiteralStatement(node, literal, statementList);
                    }
                    else
                    {
                        j = BuildIdentToCodeBlockIdentStatement(node, nodeI, nodes, statementList, j);
                    }
                }
                else if (node is Operator && nodeI is Block)
                {
                    j = BuildOperatorToBlockStatement(node, nodeI, nodeDic, statementList, j);
                }
                else if (node is Func && nodeI is Block)
                {
                    j = BuildFuncToBlockStatement(node, nodeI, nodeDic, statementList, j);
                }
                else if (node is Func && nodeI is IdentNode)
                {
                    j = BuildFuncToIdentStatement(node, nodeI, nodeDic, statementList, j);
                }
                else if (node is IdentNode && nodeI is Operator)
                {
                    BuildIdentToOperatorStatement(node, statementList, nodeI);
                }
                else if (node is Operator && nodeI is Operator)
                {
                    j = BuildOperatorToOperatorStatement(node, nodeI, nodeDic, statementList, j);
                }
                else if (node is IdentNode && nodeI is Func)
                {
                    BuildIdentToFuncStatement(node, nodeI, statementList);
                }
                else if (node is Func && nodeI is Func)
                {
                    j = BuildFuncToFuncStatement(node, nodeI, nodeDic, statementList, j);
                }
                else if (node is Operator && nodeI is Func)
                {
                    j = BuildOperatorToOperatorStatement(node, nodeI, nodeDic, statementList, j);
                }
                else if (node is Func && nodeI is Operator)
                {
                    j = BuildFuncToFuncStatement(node, nodeI, nodeDic, statementList, j);
                }
                else if ((node is Operator && nodeI is ArrayNode) || (node is Operator && nodeI is LiteralNode))
                {
                    j = BuildOperatorToOperatorStatement(node, nodeI, nodeDic, statementList, j);
                }
                else if ((node is Func && nodeI is ArrayNode) || (node is Func && nodeI is LiteralNode))
                {
                    j = BuildFuncToFuncStatement(node, nodeI, nodeDic, statementList, j);
                }
                else if ((node is Block && nodeI is Block))
                {
                    BuildBlockToBlockStatement(node, nodeI, statementList);
                }
                else if ((node is Block && nodeI is Func))
                {
                    BuildBlockToFuncStatement(node, nodeI, statementList);
                }
                else if ((node is Block && nodeI is Operator))
                {
                    BuildBlockToFuncStatement(node, nodeI, statementList);
                }
                else if ((node is Block && nodeI is IdentNode))
                {
                    BuildBlockToIdentStatement(node, nodeI, statementList);
                }
                /*Block to Operator*/
                else if (node is Block && nodeI is Operator)
                {
                    //BuildBlockToOperatorStatement(node, nodeI, statementList);
                }
                //else if ((node is Block && nodeI is Func))
                //{
                //    BuildBlockToBlockStatement(node, nodeI, statementList);
                //}
                else
                {
                    if (node is Operator)
                    {
                        if (nodes.IndexOf(nodeI, j) == 0)
                        {
                            Assignment a = (Assignment)statementList.GetNode(node.Guid);
                            ((BinExprNode)a.right).left = nodeI;
                            ++j;
                        }
                        else
                        {
                            Assignment a = (Assignment)statementList.GetNode(node.Guid);
                            ((BinExprNode)a.right).right = nodeI;
                        }
                    }
                    else if (node is Func)
                    {
                        Assignment   a = (Assignment)statementList.GetNode(node.Guid);
                        FunctionCall f = ((FunctionCall)a.right);
                        f.parameters[nodes.IndexOf(nodeI, j)] = nodeI;
                        j = 0;
                    }
                }

                if (IsNotVisited(nodeI, nodeStateMap))
                {
                    DFSVisit(nodeI, nodeStateMap, list, statementList);
                }
            }
            nodeStateMap[node] = VISITED;
            list.Add(node);
        }
 public GraphNodeToASTGenerator(AST graph, GraphCompiler gc)
 {
     this.graph = graph;
     this.gc = gc;
 }
Beispiel #23
0
 private string BuildScriptFromIR(AST graph)
 {
     return "";
 }
Beispiel #24
0
 public static List<Node> sort(AST graph)
 {
     return DFS(graph);
 }
Beispiel #25
0
        /*
        proc Rewrite(graph)
            foreach node in graph
	            if node is CodeBlock 
		            RewriteCodeBlock(node)
	            end
            end
        end
         */

        private void RewriteCodeBlock(AST graph)
        {
            List<int> nodesToRemove = new List<int>();
            List<uint> guidListOfNodesToRemove = new List<uint>();

            List<Node> rewrittenNodeList = new List<Node>();
            Dictionary<uint, Node> rewrittenUIDMap = new Dictionary<uint, Node>();

            foreach (Node node in graph.nodeList)
            {
                if (node != null)
                {
                    if (node is Block)
                    {
                        List<Block> listBlocks = RewriteCodeBlock(node as Block);
                        if (listBlocks != null && listBlocks.Count > 1)
                        {
                            // Add the new range of split blocks
                            //rewrittenNodeList.AddRange(listBlocks);

                            // Add the uids of every split block
                            foreach (Block toAdd in listBlocks)
                            {
                                if (rewrittenUIDMap.ContainsKey(toAdd.Guid))
                                {
                                    rewrittenNodeList.RemoveAll((x) => x.Guid == toAdd.Guid);
                                    rewrittenNodeList.Add(toAdd);
                                    rewrittenUIDMap[toAdd.Guid] = toAdd;
                                }
                                else
                                {
                                    rewrittenNodeList.Add(toAdd);
                                    rewrittenUIDMap.Add(toAdd.Guid, toAdd);
                                }
                            }
                        }
                        else
                        {
                            if (((Block)node).splitFomUint ==0)
                            ((Block)node).splitFomUint = node.Guid;
                            if (!rewrittenNodeList.Contains(node))
                            rewrittenNodeList.Add(node);
                            if (rewrittenUIDMap.ContainsKey(node.Guid)) 
                                rewrittenUIDMap[node.Guid] = node;
                            else
                            rewrittenUIDMap.Add(node.Guid, node);
                        }
                    }
                    else
                    {
                        if (!rewrittenNodeList.Contains(node))
                        rewrittenNodeList.Add(node);
                        if (rewrittenUIDMap.ContainsKey(node.Guid)) 
                            rewrittenUIDMap[node.Guid] = node;
                        else
                            rewrittenUIDMap.Add(node.Guid, node);
                    }
                }
            }

            graph.nodeList = new List<Node>(rewrittenNodeList);
            graph.nodeMap = new Dictionary<uint, Node>(rewrittenUIDMap);
        }
Beispiel #26
0
        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);
            }
        }
Beispiel #27
0
        private string BuildScriptFromGraph(AST graph)
        {
            string liststat = "";
            //RewriteCodeBlock(graph);
            List<Node> li = TopSort.sort(graph);
            //li = SortCodeBlocks(li);
            tguid = 20000;
            //IEnumerable iter = li;
            List<string> listIslands = new List<string>();
            List<Node> islandNodes = new List<Node>();
            int countIslands = 0;
            statementList = new AST();
            ModifiedStmtGuidList.Clear();
            List<string> importIslands = new List<string>();
            IEnumerable iter = li;
            List<Node> finalScript = new List<Node>();
            List<List<Node>> listing = new List<List<Node>>();
            foreach (Node node in iter)
            {
                if (node != null)
                {
                    if (node is ImportNode)
                    {
                        importIslands.Add(node.ToScript() + ProtoCore.DSASM.Constants.termline);
                    }
                    else if (node.IsIsland)
                    {
                        countIslands++;
                        if (node is ArrayNode)
                        {
                            BuildArrayNodeStatement(node, statementList);
                            if (!islandNodes.Contains(node))
                                islandNodes.Add(node);
                            string island = statementList.GetNode(node.Guid).ToScript() + ProtoCore.DSASM.Constants.termline;
                            if (!listIslands.Contains(island))
                                listIslands.Add(island);
                        }
                        else if (node is LiteralNode)
                        {
                            BuildLiteralNodeStatement(node, statementList);
                            string island = statementList.GetNode(node.Guid).ToScript() + ProtoCore.DSASM.Constants.termline;
                            if (!listIslands.Contains(island))
                                listIslands.Add(island);
                        }
                        else if (node is Func)
                        {
                            BuildFunctionCallStatement(node, statementList);
                            string island = statementList.GetNode(node.Guid).ToScript() + ProtoCore.DSASM.Constants.termline;
                            if (!listIslands.Contains(island))
                                listIslands.Add(island);
                        }
                        else if (node is Operator)
                        {
                            BuildOperatorStatement(node, statementList);
                            string island = statementList.GetNode(node.Guid).ToScript() + ProtoCore.DSASM.Constants.termline;
                            if (!listIslands.Contains(island))
                                listIslands.Add(island);
                        }
                        else if (node is Block)
                        {
                            BuildBlockStatement(node, statementList);
                            if (!islandNodes.Contains(node))
                            islandNodes.Add(node);
                            /*string island = statementList.GetNode(node.Guid).ToScript() + ProtoCore.DSASM.Constants.termline;
                            if (!listIslands.Contains(island))
                                listIslands.Add(island);*/
                        }
                        else if (node is IdentNode)
                        {
                            // comment Jun:
                            // An island identifier node is handled by emitting a null as its rhs
                            statementList.AddNode(node);
                            string contents = statementList.GetNode(node.Guid).ToScript() + "=" + ProtoCore.DSASM.Literal.Null + ProtoCore.DSASM.Constants.termline;
                            listIslands.Add(contents);
                        }
                        else
                        {
                            statementList.AddNode(node);
                            string island = node.ToScript() + ProtoCore.DSASM.Constants.termline;
                            if (!listIslands.Contains(island))
                                listIslands.Add(island);
                        }
                        HandleNewNode(node);
                    }
                    else if (node.IsLeaf)
                    {
                        if (node is ArrayNode)
                        {
                            BuildArrayNodeStatement(node, statementList);
                        }
                        else if (node is LiteralNode)
                        {
                            BuildLiteralNodeStatement(node, statementList);
                        }
                        else if (node is Func)
                        {
                            BuildFunctionCallStatement(node, statementList);
                        }
                        else if (node is Operator)
                        {
                            BuildOperatorStatement(node, statementList);
                        }
                        else if (node is Block)
                        {
                            BuildBlockStatement(node, statementList);
                        }
                        else if (node is IdentNode)
                        {
                            statementList.AddNode(node);
                            string contents = statementList.GetNode(node.Guid).ToScript() + "=" + ProtoCore.DSASM.Literal.Null + ProtoCore.DSASM.Constants.termline;
                            listIslands.Add(contents);
                        }
                        HandleNewNode(node);
                    }
                    else if (node.IsRoot && !node.IsIsland)
                    {
                        if (node is Operator)
                        {
                            BuildOperatorStatement(node, statementList);
                        }
                        else if (node is Func)
                        {
                            BuildFunctionCallStatement(node, statementList);
                        }
                        else if (node is Block)
                        {
                            BuildBlockStatement(node, statementList);
                        }
                        else if (node is IdentNode)
                        {
                            BuildIdentStatement(node, statementList);
                        }
                        //liststat = BuildStatement(node, statementList);
                        //finalScript=finalScript.Union(BuildStatement(node, statementList)).ToList();
                        
                        //comment out for new node to code
                        listing.Add(BuildStatement(node, statementList));
                        HandleNewNode(node);
                    }
                    else if (node is Operator)
                    {
                        BuildOperatorStatement(node, statementList);
                        HandleNewNode(node);
                    }
                    else if (node is Func)
                    {
                        BuildFunctionCallStatement(node, statementList);
                        HandleNewNode(node);
                    }
                    else if (node is ArrayNode)
                    {
                        BuildArrayNodeStatement(node, statementList);
                        HandleNewNode(node);
                    }
                    else if (node is LiteralNode)
                    {
                        BuildLiteralNodeStatement(node, statementList);
                        HandleNewNode(node);
                    }
                    else if (node is Block)
                    {
                        BuildBlockStatement(node, statementList);
                        HandleNewNode(node);
                    }
                    else if (node is IdentNode)
                    {
                        BuildIdentStatement(node, statementList);
                        HandleNewNode(node);
                    }
                    else
                    {
                        HandleNewNode(node);
                    }
                }
            }
            StringBuilder builder = new StringBuilder();
            foreach (string island in importIslands) // Loop through all strings
            {
                builder.Append(island); // Append string to StringBuilder
            }

            // nullify deleted variables or variables that undefined in this
            // run. 
            HashSet<string> nullifyVariables = new HashSet<string>(RemovedNodeNameList);
            nullifyVariables.UnionWith(this.UndefinedNameList);

            foreach (string variable in nullifyVariables)
            {
                if (!String.IsNullOrEmpty(variable))
                {
                    builder.Append(variable + " = null;\n");
                }
            }

            //for_taking_care_of_nulls
            const string tempNullAssign = Constants.kwTempNull + "=" + ProtoCore.DSDefinitions.Keyword.Null + ";\n";
            builder.Append(tempNullAssign);
            foreach (string island in listIslands) // Loop through all strings
            {
                builder.Append(island); // Append string to StringBuilder
            }

            foreach (List<Node> n1 in listing)
            {
                foreach (Node n2 in n1)
                {
                    if (!nodesToGuid(finalScript).Contains(n2.Guid))
                    {
                        finalScript.Add(n2);
                    }
                    else
                    {
                        finalScript.RemoveAll(x=>x.Guid == n2.Guid);
                        finalScript.Add(n2);
                    }
                }
            }

            finalScript = finalScript.Union(islandNodes).ToList();
            finalScript = SortCodeBlocks(finalScript);

            foreach (var value in finalScript)
            {
                liststat += value.ToScript() + ProtoCore.DSASM.Constants.termline;
            }
            liststat = builder.ToString() + liststat;
            //GraphUtilities.runningUID = GraphToDSCompiler.Constants.UIDStart;


            UpdateAddedNodesInModifiedNameList();

            return liststat;
        }
Beispiel #28
0
        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);
            }
        }
Beispiel #29
0
 private void BuildIdentStatement(Node node, AST statementList)
 {
     IdentNode identNode = node as IdentNode;
     Assignment a = new Assignment(identNode, identNode);
     statementList.AddNode(a);
 }
Beispiel #30
0
 private static int BuildFuncToBlockStatement(Node node, Node nodeI, Dictionary<int, Node> nodeDic, AST statementList, int j)
 {
     Assignment a1 = (Assignment)statementList.GetNode(node.Guid);
     Block block = nodeI as Block;
     List<int> keys = GetKeysFromValue(nodeDic, nodeI);
     FunctionCall f = ((FunctionCall)a1.right);
     if (keys.Count > 1)
     {
         do
         {
             f.parameters[keys[j]] = new IdentNode(block.LHS, block.Guid); 
             j++;
         } while (j < keys.Count);
     }
     else
     {
         f.parameters[keys[j]] = new IdentNode(block.LHS, block.Guid);
     }
     j = 0;
     return j;
 }
Beispiel #31
0
        private void BuildBlockStatement(Node node, AST statementList)
        {
            if (node.children.Count > 1 || node.IsLeaf || node.IsIsland)
            {
                statementList.AddNode(node);
            }
            else
            {
                Block n = node as Block;
                Node a;

                // TODO Jun: why is this check needed?

                // This checks if the current node is a full expression
                // If a codeblock contains LHS then it is a full expression
                if (!string.IsNullOrEmpty(n.LHS))
                {
                    // This is a full expression
                    // such as: [a = 2;]
                    a = new Assignment(new IdentNode(n.LHS, node.Guid), new IdentNode(n.LHS, node.Guid));
                }
                else
                {   
                    // This is a single identifier
                    // such as: [a;]
                    string s = n.Name;
                    s = s.TrimEnd(';');
                    a = new Assignment(new IdentNode(s, node.Guid), new IdentNode(s, node.Guid));
                }
                statementList.AddNode(a);
            }
        }
Beispiel #32
0
 private void BuildLiteralNodeStatement(Node node, AST statementList)
 {
     LiteralNode n = (LiteralNode)node;
     tguid = GetTempGUID(n.Guid);
     string name = GraphToDSCompiler.kw.tempPrefix + tguid;
     n.tempName = name;
     Node a = new Assignment(new IdentNode(name, tguid), n);
     statementList.AddNode(a);
 }
Beispiel #33
0
        private void BuildArrayNodeStatement(Node node, AST statementList)
        {
            Expr e = (Expr)node;
            tguid = GetTempGUID(e.Guid);

            Assignment a = new Assignment(new IdentNode(GraphToDSCompiler.kw.tempPrefix + tguid, tguid), e);
            statementList.AddNode(a);
        }
Beispiel #34
0
        private static void BuildIdentToOperatorStatement(Node node, AST statementList, Node nodeI)
        {
            Assignment a2 = (Assignment)statementList.GetNode(nodeI.Guid);
            Assignment a = new Assignment((IdentNode)node, (IdentNode)a2.left);
            if (statementList.nodeMap.ContainsKey(a.Guid))
            {
                Node nodeToRemove = statementList.GetNode(a.Guid);
                int index = statementList.nodeList.IndexOf(nodeToRemove);
                statementList.RemoveNode(nodeToRemove);

                statementList.nodeList.Insert(index, a);
                statementList.nodeMap.Add(a.Guid, a);
            }
            else
                statementList.AddNode(a);
        }
Beispiel #35
0
 private void BuildFunctionCallStatement(Node node, AST statementList)
 {
     Func n = (Func)node;
     tguid = GetTempGUID(n.Guid);
     FunctionCall f = new FunctionCall(n);
     Assignment a = new Assignment(new IdentNode(n.tempName, tguid), f);
     statementList.AddNode(a);
 }
Beispiel #36
0
 private static int BuildFuncToFuncStatement(Node node, Node nodeI, Dictionary<int, Node> nodeDic, AST statementList, int j)
 {
     Assignment a1 = (Assignment)statementList.GetNode(node.Guid);
     Assignment a2 = (Assignment)statementList.GetNode(nodeI.Guid);
     List<int> keys = GetKeysFromValue(nodeDic, nodeI);
     FunctionCall f = ((FunctionCall)a1.right);
     if (keys.Count > 1)
         do
         {
             f.parameters[keys[j]] = a2.left; j++;
         } while (j < keys.Count);
     else f.parameters[keys[j]] = a2.left;
     j = 0;
     return j;
 }
Beispiel #37
0
        private void BuildOperatorStatement(Node node, AST statementList)
        {
            Operator n = (Operator)node;
            Expr e1 = null;
            Expr e2 = null;

            tguid = GetTempGUID(n.Guid);

            BinExprNode b = new BinExprNode(e1, n, e2);

            Assignment a = new Assignment(new IdentNode(n.tempName, tguid), b);


            statementList.AddNode(a);
        }
Beispiel #38
0
 public string BuildScript(AST graph)
 {
     string statements = "";
     if (usePatternRewrite)
     {/*
         // Transform the graph into the graph IR
         GraphTransform graphTransform = new GraphTransform(graph);
         graph = graphTransform.ToFinalGraph();
         statements = BuildScriptFromIR(graph);*/
     }
     else
     {
         statements = BuildScriptFromGraph(graph);
     }
     return statements;
 }
Beispiel #39
0
 public GraphNodeToASTGenerator(AST graph, GraphCompiler gc)
 {
     this.graph = graph;
     this.gc    = gc;
 }