lambda-graphs 0.1.4__py3-none-any.whl

lambda_graphs/__init__.py

@@ -0,0 +1,18 @@
+from tree_sitter import Language
+
+import tree_sitter_c
+import tree_sitter_cpp
+import tree_sitter_java
+
+
+def get_language_map():
+    """Return a mapping from language name to tree-sitter Language object.
+
+    Uses pre-compiled grammar libraries from pip packages instead of
+    cloning and building grammars at runtime.
+    """
+    return {
+        "c": Language(tree_sitter_c.language()),
+        "cpp": Language(tree_sitter_cpp.language()),
+        "java": Language(tree_sitter_java.language()),
+    }

lambda_graphs/__main__.py

@@ -0,0 +1,7 @@
+"""Support executing module as script"""
+
+from __future__ import annotations
+
+from .cli import app
+
+app()

lambda_graphs/cli.py

@@ -0,0 +1,183 @@
+"""CLI for lambda-graphs"""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+from typing import Optional
+
+import typer
+from loguru import logger
+
+from .codeviews.combined_graph.combined_driver import CombinedDriver
+from .utils.multi_file_merger import merge_files
+from . import get_language_map
+
+get_language_map()
+app = typer.Typer()
+
+
+@app.callback(invoke_without_command=True)
+def main(
+    lang: str = typer.Option(..., help="c, cpp, java"),
+    code: Optional[str] = typer.Option(
+        None,
+        help="""
+    int main() {
+        int x = 3;
+        x = x + 3;
+        int y = 4;
+        y += 1;
+        return 0;
+    }
+    """,
+    ),
+    code_file: Optional[Path] = typer.Option(None, help="./test_file.c"),
+    code_folder: Optional[Path] = typer.Option(
+        None, help="./project_folder/ - combines all source files"
+    ),
+    combined_name: Optional[str] = typer.Option(
+        None,
+        help="Custom name for combined file (without extension), e.g., 'myproject'",
+    ),
+    graphs: str = typer.Option("ast,dfg", help="ast, cfg, dfg"),
+    output: str = typer.Option("dot", help="all/json/dot (dot generates png as well)"),
+    blacklisted: str = typer.Option("", help="Nodes to be removed from the AST"),
+    collapsed: bool = typer.Option(
+        False, help="Collapses all occurrences of a variable into one node"
+    ),
+    last_def: bool = typer.Option(
+        False, help="Adds last definition information to the DFG"
+    ),
+    last_use: bool = typer.Option(False, help="Adds last use information to the DFG"),
+    throw_parse_error: bool = typer.Option(
+        False, help="Throws an error if the code cannot be parsed"
+    ),
+    debug: bool = typer.Option(False, help="Enables debug logs"),
+):
+    """
+    lambda-graphs
+
+    Generates, customizes and combines multiple source code representations (AST, CFG, DFG)
+
+
+    """
+    if debug:
+        level = "DEBUG"
+    else:
+        level = "WARNING"
+
+    config = {
+        "handlers": [{"sink": sys.stderr, "level": level}],
+    }
+    logger.configure(**config)
+
+    codeviews = {
+        "AST": {
+            "exists": False,
+            "collapsed": collapsed,
+            "minimized": bool(blacklisted),
+            "blacklisted": blacklisted.split(","),
+        },
+        "DFG": {
+            "exists": False,
+            "collapsed": collapsed,
+            "minimized": False,
+            "statements": True,
+            "last_def": last_def,
+            "last_use": last_use,
+        },
+        "CFG": {
+            "exists": False,
+        },
+    }
+
+    if "ast" in graphs.lower():
+        codeviews["AST"] = {
+            "exists": True,
+            "collapsed": collapsed,
+            "minimized": bool(blacklisted),
+            "blacklisted": blacklisted.split(","),
+        }
+    if "dfg" in graphs.lower():
+        codeviews["DFG"] = {
+            "exists": True,
+            "collapsed": collapsed,
+            "minimized": False,
+            "statements": True,
+            "last_def": last_def,
+            "last_use": last_use,
+        }
+    if "cfg" in graphs.lower():
+        codeviews["CFG"] = {
+            "exists": True,
+        }
+
+    try:
+        output_dir = Path("output")
+        output_dir.mkdir(exist_ok=True)
+
+        if code_folder:
+            logger.info(f"Combining source files from folder: {code_folder}")
+
+            temp_dir = Path("temp")
+            temp_dir.mkdir(exist_ok=True)
+
+            if combined_name:
+                output_base_name = combined_name
+            else:
+                output_base_name = code_folder.name
+
+            if lang == "c":
+                combined_source_file = str(temp_dir / f"{output_base_name}.c")
+            elif lang == "java":
+                combined_source_file = str(temp_dir / f"{output_base_name}.java")
+            else:
+                combined_source_file = str(temp_dir / f"{output_base_name}.cpp")
+
+            combined_file_path = merge_files(
+                str(code_folder), lang, combined_source_file
+            )
+            logger.info(f"Combined source written to: {combined_file_path}")
+
+            with open(combined_file_path, "r") as file_handle:
+                src_code = file_handle.read()
+
+            output_file_name = str(output_dir / f"{output_base_name}.json")
+            CombinedDriver(
+                src_language=lang,
+                src_code=src_code,
+                output_file=output_file_name,
+                graph_format=output,
+                codeviews=codeviews,
+            )
+        elif code_file:
+            file_handle = open(code_file, "r")
+            src_code = file_handle.read()
+            file_handle.close()
+            output_base_name = code_file.stem
+            output_file_name = str(output_dir / f"{output_base_name}.json")
+            CombinedDriver(
+                src_language=lang,
+                src_code=src_code,
+                output_file=output_file_name,
+                graph_format=output,
+                codeviews=codeviews,
+            )
+        else:
+            if not code:
+                raise Exception("No code provided")
+            output_file_name = str(output_dir / "output.json")
+            CombinedDriver(
+                src_language=lang,
+                src_code=code,
+                output_file=output_file_name,
+                graph_format=output,
+                codeviews=codeviews,
+            )
+    except Exception as e:
+        try:
+            logger.error(e.msg)
+        except AttributeError:
+            logger.error(e)
+        sys.exit(-1)

lambda_graphs/codeviews/AST/AST.py

@@ -0,0 +1,120 @@
+import networkx as nx
+
+
+class ASTGraph:
+    def __init__(self, src_language, src_code, properties, root_node, parser):
+        self.src_language = src_language
+        self.src_code = src_code
+        self.properties = properties
+        self.root_node = root_node
+        self.parser = parser
+        self.index = self.parser.index
+        self.all_tokens = self.parser.all_tokens
+        self.label = self.parser.label
+        self.method_map = self.parser.method_map
+        self.method_calls = self.parser.method_calls
+        self.start_line = self.parser.start_line
+        self.graph = self.to_networkx()
+
+    def get_AST_nodes(self, root_node, AST, AST_index):
+
+        if root_node.is_named:
+            if root_node.type in ["string_content", "escape_sequence"]:
+                return None
+
+            current_node_id = AST_index[
+                (root_node.start_point, root_node.end_point, root_node.type)
+            ]
+            if current_node_id in self.all_tokens:
+
+                label = self.label[current_node_id]
+            else:
+                label = root_node.type
+            AST.add_node(
+                current_node_id,
+                node_type=root_node.type,
+                label=label,
+                shape="box",
+                style="rounded, filled",
+                fillcolor="#BFE6D3",
+                color="white",
+            )
+            for child in root_node.children:
+                if child.is_named:
+                    child_id = self.get_AST_nodes(child, AST, AST_index)
+                    if child_id != None:
+                        AST.add_edge(current_node_id, child_id)
+            return current_node_id
+
+    def merge_nodes(self, G, nodes, new_node):
+        """
+        Merges the selected `nodes` of the graph G into one `new_node`,
+        meaning that all the edges that pointed to or from one of these
+        `nodes` will point to or from the `new_node`.
+        """
+
+        nodes.remove(new_node)
+
+        incoming_edges = G.in_edges(nodes, data=True)
+        outgoing_edges = G.out_edges(nodes, data=True)
+        for i in incoming_edges:
+            G.add_edge(i[0], new_node, **i[2])
+        for i in outgoing_edges:
+            G.add_edge(new_node, i[1], **i[2])
+
+        for n in nodes:
+            G.remove_node(n)
+
+    def collapse(self, G):
+        name_to_index_map = {}
+        node_attributes = {}
+
+        for variable in self.all_tokens:
+            if variable not in self.method_map:
+                name_to_index_map[self.label[variable]] = set()
+
+        for node, properties in G.nodes(data=True):
+            name = properties["label"]
+            if name in name_to_index_map.keys():
+                name_to_index_map[name].add(node)
+
+        for name, indexes in name_to_index_map.items():
+            node_list = list(indexes)
+            chosen_node = min(node_list)
+            node_attributes[chosen_node] = G.nodes(data=True)[chosen_node]
+            self.merge_nodes(G, node_list, chosen_node)
+        nx.set_node_attributes(G, node_attributes)
+
+    def minimize(self, root_node, blacklisted_nodes):
+        if root_node.type in self.properties.get("blacklisted", []):
+            blacklisted_nodes.append(
+                self.index[(root_node.start_point, root_node.end_point, root_node.type)]
+            )
+
+        for child in root_node.children:
+            self.minimize(child, blacklisted_nodes)
+
+        return blacklisted_nodes
+
+    def remove_blacklisted_nodes(self, G):
+        blacklisted_nodes = self.minimize(self.root_node, [])
+
+        for node in blacklisted_nodes:
+            for predecessor in G.predecessors(node):
+                for successor in G.successors(node):
+                    G.add_edge(predecessor, successor)
+
+            G.remove_node(node)
+
+    def to_networkx(self):
+        G = nx.MultiDiGraph()
+        self.get_AST_nodes(self.root_node, G, self.index)
+        if self.properties.get("collapsed", False) == True:
+            self.collapse(G)
+        if self.properties.get("minimized", False) == True:
+            self.remove_blacklisted_nodes(G)
+
+        nx.set_edge_attributes(G, "AST_edge", "edge_type")
+        nx.set_edge_attributes(G, "indigo", "color")
+        nx.set_edge_attributes(G, "vee", "shape")
+        return G

lambda_graphs/codeviews/AST/AST_driver.py

@@ -0,0 +1,37 @@
+from .AST import ASTGraph
+from ...tree_parser.parser_driver import ParserDriver
+from ...utils import postprocessor
+
+
+class ASTDriver:
+    def __init__(
+        self,
+        src_language="c",
+        src_code="",
+        output_file="AST_output.json",
+        properties={},
+    ):
+        self.src_language = src_language
+        self.src_code = src_code
+        self.properties = properties
+        self.parser = ParserDriver(src_language, src_code).parser
+        self.root_node = self.parser.root_node
+        self.AST = ASTGraph(
+            self.src_language,
+            self.src_code,
+            self.properties,
+            self.root_node,
+            self.parser,
+        )
+        self.graph = self.AST.graph
+        if output_file:
+            self.json = postprocessor.write_networkx_to_json(self.graph, output_file)
+            try:
+                postprocessor.write_to_dot(
+                    self.graph,
+                    output_file.split(".")[0] + ".dot",
+                    output_png=True,
+                    src_language=self.src_language,
+                )
+            except Exception:
+                pass

lambda_graphs/codeviews/CFG/CFG.py

@@ -0,0 +1,42 @@
+import networkx as nx
+
+
+class CFGGraph:
+    def __init__(self, src_language, src_code, properties, root_node, parser):
+        self.src_language = src_language
+        self.src_code = src_code
+        self.properties = properties
+        self.root_node = root_node
+        self.parser = parser
+        self.index = self.parser.index
+        self.all_tokens = self.parser.all_tokens
+
+    def to_networkx(self, CFG_node_list, CFG_edge_list):
+        G = nx.MultiDiGraph()
+        for node in CFG_node_list:
+            label = str(node[1] + 1) + "_ " + node[2]
+            G.add_node(node[0], label=label, type_label=node[3])
+        for edge in CFG_edge_list:
+            additional_data = None
+            if len(edge) == 4:
+                additional_data = edge[3]
+            if edge[2].startswith("constructor_call"):
+                normal_label = "constructor_call"
+            elif edge[2].startswith("method_call"):
+                normal_label = "method_call"
+            elif edge[2].startswith("virtual_call"):
+                normal_label = "virtual_call"
+            else:
+                normal_label = edge[2]
+            G.add_edge(
+                edge[0],
+                edge[1],
+                controlflow_type=edge[2],
+                edge_type="CFG_edge",
+                label=normal_label,
+                color="red",
+            )
+            if additional_data:
+                for key, value in additional_data.items():
+                    G.edges[edge[0], edge[1], 0][key] = value
+        return G