update

Author: chengpeng-wang

README.md

@@ -42,6 +42,7 @@ Note that you should collect **both the data dependencies and control dependenci
    ```
 
 4. Ensure you have the Tree-sitter library and language bindings installed:
+
    ```sh
    cd lib
    python build.py

src/memory/IR/IR.py

@@ -4,19 +4,7 @@
 
 class IR(ABC):
     """Abstract base class for intermediate representations used in code analysis.
-
-    This class provides an interface for loading and saving intermediate representations for abstraction
     """
 
     def __init__(self, code_in_files: Dict[str, str]) -> None:
-        self.code_in_files = code_in_files
-
-    @abstractmethod
-    def load(self) -> None:
-        """Load and parse the intermediate representation."""
-        pass
-
-    @abstractmethod
-    def save(self) -> None:
-        """Save the intermediate representation"""
-        pass
+        self.code_in_files = code_in_files

src/memory/IR/U6IR.py

@@ -70,21 +70,14 @@ class U6IR(IR):
         - Various locks for concurrent access protection
     """
 
-    def __init__(self, code_in_files: Dict[str, str], persist_dir: str) -> None:
+    def __init__(self, code_in_files: Dict[str, str]) -> None:
         """Initialize U6IR with source code and optional persistence directory.
 
         Args:
             code_in_files: Dictionary mapping file paths to their source code content
-            persist_dir: Optional directory path for persisting IR data to disk
         """
         super().__init__(code_in_files)
 
-        # Persist directory and file path
-        self.persist_dir = persist_dir
-        if not Path(persist_dir).exists():
-            os.makedirs(persist_dir)
-        self.persist_json_path = os.path.join(persist_dir, "u6ir.json")
-
         # ====================================================================
         # RAW PARSING DATA
         # Data structures populated during initial AST parsing phase
@@ -472,75 +465,4 @@ def find_nodes_by_type(self, root_node: Node, node_type: str, k=0) -> List[Node]
             nodes.append(root_node)
         for child_node in root_node.children:
             nodes.extend(self.find_nodes_by_type(child_node, node_type, k + 1))
-        return nodes
-
-    # ====================================================================
-    # PERSISTENCE FUNCTIONS
-    # Load and save IR data
-    # ====================================================================
-
-    # @Hanxi: This function is to be implemented.
-    def load(self) -> None:
-        """Load previously persisted U6IR data from disk.
-
-        If persist_dir was specified during initialization, attempts to load
-        all analysis data from the persistence directory. This enables
-        resuming analysis from a previous state without re-parsing.
-
-        Note:
-            Currently not implemented - serves as placeholder for future
-            persistence functionality.
-        """
-        pass
-
-    # @Hanxi: This function is to be carefully designed.
-    def save(self) -> None:
-        """Save current U6IR data to disk for persistence.
-
-        Serializes all analysis data structures to JSON format and saves to
-        the persistence directory specified during initialization.
-
-        The following data is persisted:
-        - Raw function metadata (functionRawDataDic)
-        - Function name mappings (functionNameToId)
-        - Function file locations (functionToFile)
-        - Global variables/macros (glb_var_map)
-        - Function analysis results (function_env)
-        - API analysis results (api_env)
-        - Call graph relationships
-
-        Attention: AST nodes are not serializable, so we only persist the function name and location.
-        """
-
-        # Build dictionary of data to persist
-        persist_data = {
-            "functionRawDataDic": {
-                str(k): (None, v[1], v[2], v[3])
-                for k, v in self.functionRawDataDic.items()
-            },
-            "functionNameToId": {k: list(v) for k, v in self.functionNameToId.items()},
-            "functionToFile": {str(k): v for k, v in self.functionToFile.items()},
-            "glb_var_map": self.glb_var_map,
-            "function_env": {str(k): v.to_dict() for k, v in self.function_env.items()},
-            "api_env": {str(k): v.to_dict() for k, v in self.api_env.items()},
-            "function_caller_callee_map": {
-                str(k): {str(site_id): list(callees) for site_id, callees in v.items()}
-                for k, v in self.function_caller_callee_map.items()
-            },
-            "function_callee_caller_map": {
-                str(k): [(site_id, caller_id) for site_id, caller_id in v]
-                for k, v in self.function_callee_caller_map.items()
-            },
-            "function_caller_api_callee_map": {
-                str(k): {str(site_id): list(apis) for site_id, apis in v.items()}
-                for k, v in self.function_caller_api_callee_map.items()
-            },
-            "api_callee_function_caller_map": {
-                str(k): [(site_id, caller_id) for site_id, caller_id in v]
-                for k, v in self.api_callee_function_caller_map.items()
-            },
-        }
-
-        # Write to JSON file
-        with open(self.persist_json_path, "w") as f:
-            json.dump(persist_data, f, indent=2)
+        return nodes

src/reposlice.py

@@ -55,14 +55,10 @@ def __init__(
         suffixs = ["cpp", "cc", "hpp", "c", "h"]
         self.traverse_files(self.project_path, suffixs)
 
-        self.result_dir = f"{BASE_PATH}/IRDB/{self.language}/U6IR/{self.project_name}"
-        os.makedirs(self.result_dir, exist_ok=True)
-
         # Build the U6IR of the project
         self.ts_analyzer = Cpp_TSAnalyzer(
             self.code_in_files,
             self.language,
-            self.result_dir,
             self.max_symbolic_workers,
         )
 

src/tstool/analyzer/Cpp_TS_analyzer.py

@@ -19,11 +19,10 @@ def __init__(
         self,
         code_in_files: Dict[str, str],
         language_name: str,
-        persist_dir: str,
         max_symbolic_workers_num=10,
     ) -> None:
         super().__init__(
-            code_in_files, language_name, persist_dir, max_symbolic_workers_num
+            code_in_files, language_name,  max_symbolic_workers_num
         )
 
     def _extract_function_raw_info(

src/tstool/analyzer/TS_analyzer.py

@@ -30,7 +30,6 @@ def __init__(
         self,
         code_in_files: Dict[str, str],
         language_name: str,
-        persist_dir: str,
         max_symbolic_workers_num=10,
     ) -> None:
         """
@@ -39,17 +38,14 @@ def __init__(
         Args:
             code_in_files: Dict mapping file paths to source contents
             language_name: Programming language name
-            persist_dir: Directory to persist the analysis results
             max_symbolic_workers_num: Max parallel workers for analysis
         """
         self.code_in_files = code_in_files
-        self.persist_dir = persist_dir
         cwd = Path(__file__).resolve().parent.absolute()
         TSPATH = cwd / "../../../lib/build/"
         language_path = TSPATH / "my-languages.so"
         self.max_symbolic_workers_num = max_symbolic_workers_num
-
-        self.u6ir = U6IR(code_in_files, persist_dir)
+        self.u6ir = U6IR(code_in_files)
 
         # Initialize tree-sitter parser
         self.parser = Parser()
@@ -79,14 +75,6 @@ def run(self) -> U6IR:
         self._analyze_call_graph()
         return self.u6ir
 
-    def incremental_run(
-        self, old_u6ir: U6IR, code_in_changed_files: Dict[str, str]
-    ) -> U6IR:
-        """
-        Run the analyzer incrementally.
-        """
-        return self.u6ir
-
     ##################################################
     #   Wrapper functions for project AST parsing    #
     # (Only used by the TSAnalyzer class/subclasses) #