arkanalyzer 1.0.20 → 1.0.21

package/lib/core/graph/BaseImplicitGraph.d.ts

@@ -1,78 +1,78 @@
-import { NodeID, GraphTraits } from './GraphTraits';
-export { NodeID };
-/**
- * BaseImplicitGraph is an abstract class that represents an implicit graph.
- * An implicit graph is a graph representation where node and edge information is implicitly stored using maps.
- * This class implements the GraphTraits<Node> interface and provides basic graph operations.
- */
-export declare abstract class BaseImplicitGraph<Node> implements GraphTraits<Node> {
-    /**
-     * idToNodeMap is an optional map that maps node IDs (NodeID) to node objects (Node).
-     * If not initialized, calling related methods will throw an error.
-     */
-    protected idToNodeMap?: Map<NodeID, Node>;
-    /**
-     * nodeToIdMap is a map that maps node objects (Node) to node IDs (NodeID).
-     * This map must be initialized in the subclass.
-     */
-    protected nodeToIdMap: Map<Node, NodeID>;
-    /**
-     * succMap is a map that stores the successors of each node.
-     * The key is a node ID (NodeID), and the value is an array of successor node IDs.
-     */
-    succMap: Map<NodeID, NodeID[]>;
-    /**
-     * predMap is a map that stores the predecessors of each node.
-     * The key is a node ID (NodeID), and the value is an array of predecessor node IDs.
-     */
-    predMap: Map<NodeID, NodeID[]>;
-    constructor();
-    /**
-     * Gets the number of nodes in the graph.
-     * @returns The number of nodes in the graph.
-     */
-    getNodeNum(): number;
-    /**
-     * Returns an iterator for all nodes in the graph.
-     * @returns An iterator for traversing all nodes in the graph.
-     */
-    nodesItor(): IterableIterator<Node>;
-    /**
-     * Gets the node object corresponding to a given node ID.
-     * @param id The node ID.
-     * @returns The corresponding node object.
-     * @throws Throws an error if idToNodeMap is not initialized or if the node is not found.
-     */
-    getNode(id: NodeID): Node;
-    /**
-     * Checks whether the graph contains a specific node ID.
-     * @param id The node ID.
-     * @returns Returns true if the node ID exists in the graph; otherwise, returns false.
-     * @throws Throws an error if idToNodeMap is not initialized.
-     */
-    hasNode(id: NodeID): boolean;
-    /**
-     * Gets the list of successor node IDs for a given node.
-     * @param id The node ID.
-     * @returns An array of successor node IDs. Returns an empty array if no successors are found.
-     */
-    succ(id: NodeID): NodeID[];
-    /**
-     * Gets the list of predecessor node IDs for a given node.
-     * @param id The node ID.
-     * @returns An array of predecessor node IDs. Returns an empty array if no predecessors are found.
-     */
-    pred(id: NodeID): NodeID[];
-    /**
-     * Gets the nodeToIdMap, which maps node objects to node IDs.
-     * @returns The nodeToIdMap.
-     */
-    getNodeToIdMap(): Map<Node, NodeID>;
-    /**
-     * Abstract method to get the name of the graph.
-     * Subclasses must implement this method.
-     * @returns The name of the graph.
-     */
-    abstract getGraphName(): string;
-}
+import { NodeID, GraphTraits } from './GraphTraits';
+export { NodeID };
+/**
+ * BaseImplicitGraph is an abstract class that represents an implicit graph.
+ * An implicit graph is a graph representation where node and edge information is implicitly stored using maps.
+ * This class implements the GraphTraits<Node> interface and provides basic graph operations.
+ */
+export declare abstract class BaseImplicitGraph<Node> implements GraphTraits<Node> {
+    /**
+     * idToNodeMap is an optional map that maps node IDs (NodeID) to node objects (Node).
+     * If not initialized, calling related methods will throw an error.
+     */
+    protected idToNodeMap?: Map<NodeID, Node>;
+    /**
+     * nodeToIdMap is a map that maps node objects (Node) to node IDs (NodeID).
+     * This map must be initialized in the subclass.
+     */
+    protected nodeToIdMap: Map<Node, NodeID>;
+    /**
+     * succMap is a map that stores the successors of each node.
+     * The key is a node ID (NodeID), and the value is an array of successor node IDs.
+     */
+    succMap: Map<NodeID, NodeID[]>;
+    /**
+     * predMap is a map that stores the predecessors of each node.
+     * The key is a node ID (NodeID), and the value is an array of predecessor node IDs.
+     */
+    predMap: Map<NodeID, NodeID[]>;
+    constructor();
+    /**
+     * Gets the number of nodes in the graph.
+     * @returns The number of nodes in the graph.
+     */
+    getNodeNum(): number;
+    /**
+     * Returns an iterator for all nodes in the graph.
+     * @returns An iterator for traversing all nodes in the graph.
+     */
+    nodesItor(): IterableIterator<Node>;
+    /**
+     * Gets the node object corresponding to a given node ID.
+     * @param id The node ID.
+     * @returns The corresponding node object.
+     * @throws Throws an error if idToNodeMap is not initialized or if the node is not found.
+     */
+    getNode(id: NodeID): Node;
+    /**
+     * Checks whether the graph contains a specific node ID.
+     * @param id The node ID.
+     * @returns Returns true if the node ID exists in the graph; otherwise, returns false.
+     * @throws Throws an error if idToNodeMap is not initialized.
+     */
+    hasNode(id: NodeID): boolean;
+    /**
+     * Gets the list of successor node IDs for a given node.
+     * @param id The node ID.
+     * @returns An array of successor node IDs. Returns an empty array if no successors are found.
+     */
+    succ(id: NodeID): NodeID[];
+    /**
+     * Gets the list of predecessor node IDs for a given node.
+     * @param id The node ID.
+     * @returns An array of predecessor node IDs. Returns an empty array if no predecessors are found.
+     */
+    pred(id: NodeID): NodeID[];
+    /**
+     * Gets the nodeToIdMap, which maps node objects to node IDs.
+     * @returns The nodeToIdMap.
+     */
+    getNodeToIdMap(): Map<Node, NodeID>;
+    /**
+     * Abstract method to get the name of the graph.
+     * Subclasses must implement this method.
+     * @returns The name of the graph.
+     */
+    abstract getGraphName(): string;
+}
 //# sourceMappingURL=BaseImplicitGraph.d.ts.map

package/lib/core/graph/BaseImplicitGraph.js

@@ -1,78 +1,78 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BaseImplicitGraph = void 0;
-/**
- * BaseImplicitGraph is an abstract class that represents an implicit graph.
- * An implicit graph is a graph representation where node and edge information is implicitly stored using maps.
- * This class implements the GraphTraits<Node> interface and provides basic graph operations.
- */
-class BaseImplicitGraph {
-    constructor() { }
-    /**
-     * Gets the number of nodes in the graph.
-     * @returns The number of nodes in the graph.
-     */
-    getNodeNum() {
-        return this.nodeToIdMap.size;
-    }
-    /**
-     * Returns an iterator for all nodes in the graph.
-     * @returns An iterator for traversing all nodes in the graph.
-     */
-    nodesItor() {
-        return this.nodeToIdMap.keys();
-    }
-    /**
-     * Gets the node object corresponding to a given node ID.
-     * @param id The node ID.
-     * @returns The corresponding node object.
-     * @throws Throws an error if idToNodeMap is not initialized or if the node is not found.
-     */
-    getNode(id) {
-        if (!this.idToNodeMap) {
-            throw new Error(`initialize this.idToNodeMap first`);
-        }
-        if (!this.idToNodeMap.has(id)) {
-            throw new Error(`Can find Node # ${id}`);
-        }
-        return this.idToNodeMap.get(id);
-    }
-    /**
-     * Checks whether the graph contains a specific node ID.
-     * @param id The node ID.
-     * @returns Returns true if the node ID exists in the graph; otherwise, returns false.
-     * @throws Throws an error if idToNodeMap is not initialized.
-     */
-    hasNode(id) {
-        if (!this.idToNodeMap) {
-            throw new Error(`initialize this.idToNodeMap first`);
-        }
-        return this.idToNodeMap.has(id);
-    }
-    /**
-     * Gets the list of successor node IDs for a given node.
-     * @param id The node ID.
-     * @returns An array of successor node IDs. Returns an empty array if no successors are found.
-     */
-    succ(id) {
-        var _a;
-        return (_a = this.succMap.get(id)) !== null && _a !== void 0 ? _a : [];
-    }
-    /**
-     * Gets the list of predecessor node IDs for a given node.
-     * @param id The node ID.
-     * @returns An array of predecessor node IDs. Returns an empty array if no predecessors are found.
-     */
-    pred(id) {
-        var _a;
-        return (_a = this.predMap.get(id)) !== null && _a !== void 0 ? _a : [];
-    }
-    /**
-     * Gets the nodeToIdMap, which maps node objects to node IDs.
-     * @returns The nodeToIdMap.
-     */
-    getNodeToIdMap() {
-        return this.nodeToIdMap;
-    }
-}
-exports.BaseImplicitGraph = BaseImplicitGraph;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseImplicitGraph = void 0;
+/**
+ * BaseImplicitGraph is an abstract class that represents an implicit graph.
+ * An implicit graph is a graph representation where node and edge information is implicitly stored using maps.
+ * This class implements the GraphTraits<Node> interface and provides basic graph operations.
+ */
+class BaseImplicitGraph {
+    constructor() { }
+    /**
+     * Gets the number of nodes in the graph.
+     * @returns The number of nodes in the graph.
+     */
+    getNodeNum() {
+        return this.nodeToIdMap.size;
+    }
+    /**
+     * Returns an iterator for all nodes in the graph.
+     * @returns An iterator for traversing all nodes in the graph.
+     */
+    nodesItor() {
+        return this.nodeToIdMap.keys();
+    }
+    /**
+     * Gets the node object corresponding to a given node ID.
+     * @param id The node ID.
+     * @returns The corresponding node object.
+     * @throws Throws an error if idToNodeMap is not initialized or if the node is not found.
+     */
+    getNode(id) {
+        if (!this.idToNodeMap) {
+            throw new Error(`initialize this.idToNodeMap first`);
+        }
+        if (!this.idToNodeMap.has(id)) {
+            throw new Error(`Can find Node # ${id}`);
+        }
+        return this.idToNodeMap.get(id);
+    }
+    /**
+     * Checks whether the graph contains a specific node ID.
+     * @param id The node ID.
+     * @returns Returns true if the node ID exists in the graph; otherwise, returns false.
+     * @throws Throws an error if idToNodeMap is not initialized.
+     */
+    hasNode(id) {
+        if (!this.idToNodeMap) {
+            throw new Error(`initialize this.idToNodeMap first`);
+        }
+        return this.idToNodeMap.has(id);
+    }
+    /**
+     * Gets the list of successor node IDs for a given node.
+     * @param id The node ID.
+     * @returns An array of successor node IDs. Returns an empty array if no successors are found.
+     */
+    succ(id) {
+        var _a;
+        return (_a = this.succMap.get(id)) !== null && _a !== void 0 ? _a : [];
+    }
+    /**
+     * Gets the list of predecessor node IDs for a given node.
+     * @param id The node ID.
+     * @returns An array of predecessor node IDs. Returns an empty array if no predecessors are found.
+     */
+    pred(id) {
+        var _a;
+        return (_a = this.predMap.get(id)) !== null && _a !== void 0 ? _a : [];
+    }
+    /**
+     * Gets the nodeToIdMap, which maps node objects to node IDs.
+     * @returns The nodeToIdMap.
+     */
+    getNodeToIdMap() {
+        return this.nodeToIdMap;
+    }
+}
+exports.BaseImplicitGraph = BaseImplicitGraph;

package/lib/core/graph/BasicBlock.d.ts

@@ -1,105 +1,105 @@
-import { Stmt } from '../base/Stmt';
-import { ArkError } from '../common/ArkError';
-/**
- * @category core/graph
- * A `BasicBlock` is composed of:
- * - ID: a **number** that uniquely identify the basic block, initialized as -1.
- * - Statements: an **array** of statements in the basic block.
- * - Predecessors:  an **array** of basic blocks in front of the current basic block. More accurately, these basic
- *     blocks can reach the current block through edges.
- * - Successors: an **array** of basic blocks after the current basic block. More accurately, the current block can
- *     reach these basic blocks through edges.
- */
-export declare class BasicBlock {
-    private id;
-    private stmts;
-    private predecessorBlocks;
-    private successorBlocks;
-    private exceptionalSuccessorBlocks?;
-    constructor();
-    getId(): number;
-    setId(id: number): void;
-    /**
-     * Returns an array of the statements in a basic block.
-     * @returns An array of statements in a basic block.
-     */
-    getStmts(): Stmt[];
-    addStmt(stmt: Stmt): void;
-    /**
-     * Adds the given stmt at the beginning of the basic block.
-     * @param stmt
-     */
-    addHead(stmt: Stmt | Stmt[]): void;
-    /**
-     * Adds the given stmt at the end of the basic block.
-     * @param stmt
-     */
-    addTail(stmt: Stmt | Stmt[]): void;
-    /**
-     * Inserts toInsert in the basic block after point.
-     * @param toInsert
-     * @param point
-     * @returns The number of successfully inserted statements
-     */
-    insertAfter(toInsert: Stmt | Stmt[], point: Stmt): number;
-    /**
-     * Inserts toInsert in the basic block befor point.
-     * @param toInsert
-     * @param point
-     * @returns The number of successfully inserted statements
-     */
-    insertBefore(toInsert: Stmt | Stmt[], point: Stmt): number;
-    /**
-     * Removes the given stmt from this basic block.
-     * @param stmt
-     * @returns
-     */
-    remove(stmt: Stmt): void;
-    /**
-     * Removes the first stmt from this basic block.
-     */
-    removeHead(): void;
-    /**
-     * Removes the last stmt from this basic block.
-     */
-    removeTail(): void;
-    getHead(): Stmt | null;
-    getTail(): Stmt | null;
-    /**
-     * Returns successors of the current basic block, whose types are also basic blocks (i.e.{@link BasicBlock}).
-     * @returns Successors of the current basic block.
-     * @example
-     * 1. get block successors.
-
-    ```typescript
-    const body = arkMethod.getBody();
-    const blocks = [...body.getCfg().getBlocks()]
-    for (let i = 0; i < blocks.length; i++) {
-    const block = blocks[i]
-        ...
-        for (const next of block.getSuccessors()) {
-        ...
-        }
-    }
-    ```
-     */
-    getSuccessors(): BasicBlock[];
-    /**
-     * Returns predecessors of the current basic block, whose types are also basic blocks.
-     * @returns An array of basic blocks.
-     */
-    getPredecessors(): BasicBlock[];
-    addPredecessorBlock(block: BasicBlock): void;
-    setPredecessorBlock(idx: number, block: BasicBlock): boolean;
-    setSuccessorBlock(idx: number, block: BasicBlock): boolean;
-    addStmtToFirst(stmt: Stmt): void;
-    addSuccessorBlock(block: BasicBlock): void;
-    removePredecessorBlock(block: BasicBlock): boolean;
-    removeSuccessorBlock(block: BasicBlock): boolean;
-    toString(): string;
-    validate(): ArkError;
-    private insertPos;
-    getExceptionalSuccessorBlocks(): BasicBlock[] | undefined;
-    addExceptionalSuccessorBlock(block: BasicBlock): void;
-}
+import { Stmt } from '../base/Stmt';
+import { ArkError } from '../common/ArkError';
+/**
+ * @category core/graph
+ * A `BasicBlock` is composed of:
+ * - ID: a **number** that uniquely identify the basic block, initialized as -1.
+ * - Statements: an **array** of statements in the basic block.
+ * - Predecessors:  an **array** of basic blocks in front of the current basic block. More accurately, these basic
+ *     blocks can reach the current block through edges.
+ * - Successors: an **array** of basic blocks after the current basic block. More accurately, the current block can
+ *     reach these basic blocks through edges.
+ */
+export declare class BasicBlock {
+    private id;
+    private stmts;
+    private predecessorBlocks;
+    private successorBlocks;
+    private exceptionalSuccessorBlocks?;
+    constructor();
+    getId(): number;
+    setId(id: number): void;
+    /**
+     * Returns an array of the statements in a basic block.
+     * @returns An array of statements in a basic block.
+     */
+    getStmts(): Stmt[];
+    addStmt(stmt: Stmt): void;
+    /**
+     * Adds the given stmt at the beginning of the basic block.
+     * @param stmt
+     */
+    addHead(stmt: Stmt | Stmt[]): void;
+    /**
+     * Adds the given stmt at the end of the basic block.
+     * @param stmt
+     */
+    addTail(stmt: Stmt | Stmt[]): void;
+    /**
+     * Inserts toInsert in the basic block after point.
+     * @param toInsert
+     * @param point
+     * @returns The number of successfully inserted statements
+     */
+    insertAfter(toInsert: Stmt | Stmt[], point: Stmt): number;
+    /**
+     * Inserts toInsert in the basic block befor point.
+     * @param toInsert
+     * @param point
+     * @returns The number of successfully inserted statements
+     */
+    insertBefore(toInsert: Stmt | Stmt[], point: Stmt): number;
+    /**
+     * Removes the given stmt from this basic block.
+     * @param stmt
+     * @returns
+     */
+    remove(stmt: Stmt): void;
+    /**
+     * Removes the first stmt from this basic block.
+     */
+    removeHead(): void;
+    /**
+     * Removes the last stmt from this basic block.
+     */
+    removeTail(): void;
+    getHead(): Stmt | null;
+    getTail(): Stmt | null;
+    /**
+     * Returns successors of the current basic block, whose types are also basic blocks (i.e.{@link BasicBlock}).
+     * @returns Successors of the current basic block.
+     * @example
+     * 1. get block successors.
+
+    ```typescript
+    const body = arkMethod.getBody();
+    const blocks = [...body.getCfg().getBlocks()]
+    for (let i = 0; i < blocks.length; i++) {
+    const block = blocks[i]
+        ...
+        for (const next of block.getSuccessors()) {
+        ...
+        }
+    }
+    ```
+     */
+    getSuccessors(): BasicBlock[];
+    /**
+     * Returns predecessors of the current basic block, whose types are also basic blocks.
+     * @returns An array of basic blocks.
+     */
+    getPredecessors(): BasicBlock[];
+    addPredecessorBlock(block: BasicBlock): void;
+    setPredecessorBlock(idx: number, block: BasicBlock): boolean;
+    setSuccessorBlock(idx: number, block: BasicBlock): boolean;
+    addStmtToFirst(stmt: Stmt): void;
+    addSuccessorBlock(block: BasicBlock): void;
+    removePredecessorBlock(block: BasicBlock): boolean;
+    removeSuccessorBlock(block: BasicBlock): boolean;
+    toString(): string;
+    validate(): ArkError;
+    private insertPos;
+    getExceptionalSuccessorBlocks(): BasicBlock[] | undefined;
+    addExceptionalSuccessorBlock(block: BasicBlock): void;
+}
 //# sourceMappingURL=BasicBlock.d.ts.map