lambda-graphs 0.1.4__py3-none-any.whl

lambda_graphs/codeviews/CST/CST_driver.py

@@ -0,0 +1,70 @@
+import os
+
+import networkx as nx
+from ...tree_parser.parser_driver import ParserDriver
+
+
+class CSTGraph:
+    def __init__(self, src_language, src_code, root_node):
+        self.src_language = src_language
+        self.src_code = src_code
+        self.root_node = root_node
+        self.index = {}
+        self.create_CST_id(self.root_node, self.index, [0])
+        self.graph = self.to_networkx()
+        grandparent_folder = os.path.abspath(
+            os.path.dirname(os.path.dirname(os.path.dirname(__file__)))
+        )
+
+    def postorder_traversal(self, node):
+        if node.children:
+            for child in node.children:
+                self.postorder_traversal(child)
+
+    def create_CST_id(self, root_node, CST_index, CST_id):
+        current_node_id = CST_id[0]
+        CST_id[0] += 1
+        CST_index[(root_node.start_point, root_node.end_point, root_node.type)] = (
+            current_node_id
+        )
+        for child in root_node.children:
+
+            child_id = self.create_CST_id(child, CST_index, CST_id)
+        return current_node_id
+
+    def get_CST_nodes(self, root_node, CST, CST_index):
+        current_node_id = CST_index[
+            (root_node.start_point, root_node.end_point, root_node.type)
+        ]
+        label = str(root_node.start_point[0]) + "_" + root_node.type
+        CST.add_node(
+            current_node_id,
+            label=label,
+            shape="box",
+            style="rounded, filled",
+            fillcolor="#BFE6D3",
+            color="white",
+        )
+        for child in root_node.children:
+
+            child_id = self.get_CST_nodes(child, CST, CST_index)
+            if child_id != None:
+                CST.add_edge(current_node_id, child_id)
+        return current_node_id
+
+    def to_networkx(self):
+        G = nx.MultiDiGraph()
+        self.get_CST_nodes(self.root_node, G, self.index)
+        nx.set_edge_attributes(G, "CST_edge", "edge_type")
+        nx.set_edge_attributes(G, "blue", "color")
+        nx.set_edge_attributes(G, "vee", "shape")
+        return G
+
+
+class CSTDriver:
+    def __init__(self, src_language="c", src_code=""):
+        self.src_language = src_language
+        self.src_code = src_code
+        self.parser = ParserDriver(src_language, src_code).parser
+        self.root_node, self.tree = self.parser.parse()
+        self.graph = CSTGraph(self.src_language, self.src_code, self.root_node)

lambda_graphs/codeviews/DFG/DFG_driver.py

@@ -0,0 +1,42 @@
+import networkx as nx
+from ...tree_parser.parser_driver import ParserDriver
+from ...utils import postprocessor
+from ..SDFG.SDFG import DfgRda
+
+
+class DFGDriver:
+    def __init__(
+        self,
+        src_language="c",
+        src_code="",
+        output_file="DFG_output.json",
+        properties={},
+    ):
+        self.src_language = src_language
+
+        self.parser = ParserDriver(src_language, src_code).parser
+        self.root_node = self.parser.root_node
+        self.src_code = self.parser.src_code
+        self.properties = properties.get("DFG", {})
+
+        self.graph = nx.MultiDiGraph()
+        self.rda_table = None
+        self.rda_result = None
+
+        if self.properties.get("statements", False):
+            result = DfgRda(
+                src_language=src_language,
+                src_code=src_code,
+                properties=properties,
+            )
+            self.rda_table = result.rda_table
+            self.rda_result = result.rda_result
+            self.graph = result.graph
+        if output_file:
+            self.json = postprocessor.write_networkx_to_json(self.graph, output_file)
+            postprocessor.write_to_dot(
+                self.graph,
+                output_file.split(".")[0] + ".dot",
+                output_png=True,
+                src_language=self.src_language,
+            )

lambda_graphs/codeviews/SDFG/SDFG.py

@@ -0,0 +1,135 @@
+import os.path
+import time
+
+import networkx as nx
+from loguru import logger
+
+from lambda_graphs.codeviews.CFG.CFG_driver import CFGDriver
+from lambda_graphs.codeviews.SDFG.SDFG_c import dfg_c
+from lambda_graphs.codeviews.SDFG.SDFG_cpp import dfg_cpp
+from lambda_graphs.codeviews.SDFG.SDFG_java import dfg_java
+from lambda_graphs.utils import postprocessor, DFG_utils
+
+debug = False
+
+
+class DfgRda:
+    def __init__(
+        self,
+        src_language="c",
+        src_code="",
+        output_file=None,
+        graph_format="dot",
+        properties=None,
+    ):
+        if not properties:
+            properties = {
+                "CFG": {},
+                "DFG": {
+                    "last_use": True,
+                    "last_def": True,
+                    "alex_algo": True,
+                },
+            }
+        self.src_language = src_language
+        self.src_code = src_code
+        self.properties = properties
+        self.graph = nx.MultiDiGraph()
+        start = time.time()
+        self.CFG_Results = CFGDriver(
+            self.src_language, self.src_code, "", self.properties["CFG"]
+        )
+        end = time.time()
+        self.CFG = self.CFG_Results.graph
+        self.rda_table = None
+        self.rda_result = None
+        start_dfg = time.time()
+        self.graph, self.debug_graph, self.rda_table, self.rda_result = self.rda(
+            self.properties["DFG"]
+        )
+        end_dfg = time.time()
+        if debug:
+            logger.warning(
+                "CFG time: "
+                + str(end - start)
+                + " DFG time: "
+                + str(end_dfg - start_dfg)
+            )
+        if output_file:
+            if graph_format == "all" or graph_format == "json":
+                self.json = postprocessor.write_networkx_to_json(
+                    self.graph, output_file
+                )
+            if graph_format == "all" or graph_format == "dot":
+                postprocessor.write_to_dot(
+                    self.graph,
+                    output_file.rsplit(".", 1)[0] + ".dot",
+                    output_png=True,
+                    src_language=self.src_language,
+                )
+            if graph_format == "all" or graph_format == "dot":
+                postprocessor.write_to_dot(
+                    self.debug_graph,
+                    output_file.rsplit(".", 1)[0] + "_debug.dot",
+                    output_png=True,
+                    src_language=self.src_language,
+                )
+            self.json = postprocessor.write_networkx_to_json(self.graph, output_file)
+
+    def get_graph(self):
+        return self.graph
+
+    def index_to_code(self):
+        tokens_index = DFG_utils.tree_to_token_index(self.CFG_Results.root_node)
+        code = self.src_code.split("\n")
+        code_tokens = [DFG_utils.index_to_code_token(x, code) for x in tokens_index]
+        index_to_code = {}
+
+        for ind, code in zip(tokens_index, code_tokens):
+            if ind in self.CFG_Results.parser.index:
+                idx = self.CFG_Results.parser.index[ind]
+            else:
+                idx = -1
+            index_to_code[ind] = (idx, code)
+
+        return index_to_code
+
+    def rda(self, properties):
+        lang_map = {
+            "c": dfg_c,
+            "cpp": dfg_cpp,
+            "java": dfg_java,
+        }
+        driver = lang_map[self.src_language]
+        return driver(properties, self.CFG_Results)
+
+
+if __name__ == "__main__":
+    for extension in ("c", "cpp"):
+        file = f"data/test_manual.{extension}"
+        if not os.path.isfile(file):
+            continue
+        with open(file, "r") as f:
+            sample_file = f.read()
+
+        output_file = f"data/{extension}_test.json"
+        src_code = sample_file
+        result = DfgRda(
+            src_language=extension,
+            src_code=src_code,
+            output_file=None,
+        )
+        graph = result.graph
+        postprocessor.write_to_dot(
+            graph,
+            output_file.rsplit(".", 1)[0] + ".dot",
+            output_png=True,
+            src_language=extension,
+        )
+        debug_graph = result.debug_graph
+        postprocessor.write_to_dot(
+            debug_graph,
+            output_file.rsplit(".", 1)[0] + "_debug.dot",
+            output_png=True,
+            src_language=extension,
+        )