arkanalyzer 1.0.85 → 1.0.87

package/lib/frontend/cppFrontend/base/Expr.js

@@ -0,0 +1,530 @@
+"use strict";
+/*
+ * Copyright (c) 2024-2025 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArkDesignatedInitExpr = exports.ArkAggregateExpr = exports.ArkAllocExpr = exports.ArkCxxNormalBinOpExpr = exports.ArkCxxFolderExpr = exports.ArkNoExpectExpr = exports.ArkTypeIdExpr = exports.ArkArrayTypeTraitExpr = exports.ArkCxxCastExpr = exports.ArkCxxUnaryExpr = exports.Operator = exports.ArkCxxInitArrayExpr = exports.ArkCxxNewArrayExpr = exports.ArkCxxDeleteArrayExpr = void 0;
+const Expr_1 = require("../../../core/base/Expr");
+const Type_1 = require("../../../core/base/Type");
+const Ref_1 = require("../../../core/base/Ref");
+const Type_2 = require("./Type");
+const TypeInference_1 = require("../../../core/common/TypeInference");
+const Const_1 = require("../../../core/common/Const");
+const ModelUtils_1 = require("../../../core/common/ModelUtils");
+const Local_1 = require("../../../core/base/Local");
+const ArkClass_1 = require("../../../core/model/ArkClass");
+/**
+ * delete[] expression in C++
+ *  1. c++: delete[] a / delete[] a.b / delete[] a->b
+ */
+class ArkCxxDeleteArrayExpr extends Expr_1.AbstractExpr {
+    constructor(field) {
+        super();
+        this.field = field;
+    }
+    getField() {
+        return this.field;
+    }
+    setField(newField) {
+        this.field = newField;
+    }
+    getType() {
+        return Type_1.BooleanType.getInstance();
+    }
+    getUses() {
+        const uses = [];
+        uses.push(this.field);
+        uses.push(...this.field.getUses());
+        return uses;
+    }
+    toString() {
+        return 'delete[] ' + this.field;
+    }
+}
+exports.ArkCxxDeleteArrayExpr = ArkCxxDeleteArrayExpr;
+// Expression when creating a new array
+class ArkCxxNewArrayExpr extends Expr_1.AbstractExpr {
+    constructor(baseType, size, fromLiteral = false, elementsNumber) {
+        super();
+        this.elementsNumber = 0; // The total number of elements contained in the array
+        this.baseType = baseType;
+        this.size = size;
+        this.fromLiteral = fromLiteral;
+        if (elementsNumber) {
+            this.elementsNumber = elementsNumber;
+        }
+    }
+    getElementsNumber() {
+        return this.elementsNumber;
+    }
+    setElementsNumber(elementsNumber) {
+        this.elementsNumber = elementsNumber;
+    }
+    getSize() {
+        return this.size;
+    }
+    setSize(newSize) {
+        this.size = newSize;
+    }
+    getType() {
+        return new Type_1.ArrayType(this.baseType, 1);
+    }
+    getBaseType() {
+        return this.baseType;
+    }
+    setBaseType(newType) {
+        this.baseType = newType;
+    }
+    isFromLiteral() {
+        return this.fromLiteral;
+    }
+    inferType(arkMethod) {
+        const type = TypeInference_1.TypeInference.inferUnclearedType(this.baseType, arkMethod.getDeclaringArkClass());
+        if (type) {
+            this.baseType = type;
+        }
+        return this;
+    }
+    getUses() {
+        let uses = [this.size];
+        uses.push(...this.size.getUses());
+        return uses;
+    }
+    toString() {
+        return 'newarray (' + this.baseType + ')';
+    }
+}
+exports.ArkCxxNewArrayExpr = ArkCxxNewArrayExpr;
+// Array 0 initialization expression
+class ArkCxxInitArrayExpr extends Expr_1.AbstractExpr {
+    constructor(op) {
+        super();
+        this.op = op;
+    }
+    getOp() {
+        return this.op;
+    }
+    setOp(newOp) {
+        this.op = newOp;
+    }
+    getUses() {
+        let uses = [];
+        uses.push(this.op);
+        uses.push(...this.op.getUses());
+        return uses;
+    }
+    getType() {
+        return this.op.getType();
+    }
+    toString() {
+        return 'initArrayWith(' + this.op + ')';
+    }
+    inferType(arkMethod) {
+        if (this.op instanceof Ref_1.AbstractRef || this.op instanceof Expr_1.AbstractExpr) {
+            this.op.inferType(arkMethod);
+        }
+        return this;
+    }
+}
+exports.ArkCxxInitArrayExpr = ArkCxxInitArrayExpr;
+var Operator;
+(function (Operator) {
+    Operator["sizeof"] = "sizeof";
+    Operator["alignof"] = "alignof";
+    Operator["Unknown"] = "Unknown";
+})(Operator = exports.Operator || (exports.Operator = {}));
+// expression with either a type or (unevaluated) expression operand.
+// Used for sizeof/alignof (C99 6.5.3.4) and vec_step (OpenCL 1.1 6.11.12).
+class ArkCxxUnaryExpr extends Expr_1.AbstractExpr {
+    constructor(operator, op) {
+        super();
+        this.operator = operator;
+        this.op = op;
+    }
+    getOp() {
+        return this.op;
+    }
+    setOp(newOp) {
+        this.op = newOp;
+    }
+    getOperator() {
+        return this.operator;
+    }
+    getUses() {
+        let uses = [];
+        if (!(this.op instanceof Type_1.Type)) {
+            uses.push(this.op);
+            uses.push(...this.op.getUses());
+        }
+        return uses;
+    }
+    getOpType() {
+        if (this.op instanceof Type_1.Type) {
+            return this.op;
+        }
+        return this.op.getType();
+    }
+    getType() {
+        return Type_2.CxxSizeTType.getInstance(Type_2.CxxTypeSigned.UNSIGNED, Type_2.CxxTypeBitWidth.UNKNOWN, Type_2.CxxStdTypeName.SIZE_T);
+    }
+    toString() {
+        return this.operator + '(' + this.op + ')';
+    }
+    inferType(arkMethod) {
+        if (this.op instanceof Ref_1.AbstractRef || this.op instanceof Expr_1.AbstractExpr) {
+            this.op.inferType(arkMethod);
+        }
+        return this;
+    }
+}
+exports.ArkCxxUnaryExpr = ArkCxxUnaryExpr;
+// Type conversion expression
+class ArkCxxCastExpr extends Expr_1.ArkCastExpr {
+    constructor(op, type, cxxCastType) {
+        super(op, type);
+        this.cxxCastType = cxxCastType;
+    }
+    getCxxCastType() {
+        return this.cxxCastType;
+    }
+    toString() {
+        return `<${this.cxxCastType}: ${this.getType()}>${this.getOp()}`;
+    }
+    inferType(arkMethod) {
+        let op = this.getOp();
+        if (op instanceof Ref_1.AbstractRef || op instanceof Expr_1.AbstractExpr) {
+            op.inferType(arkMethod);
+        }
+        return this;
+    }
+}
+exports.ArkCxxCastExpr = ArkCxxCastExpr;
+// __array_extent  expression,the inner of node is DeclRefExpr or several IntegerLiteral
+class ArkArrayTypeTraitExpr extends Expr_1.AbstractExpr {
+    constructor(dimensionSizes = [], op) {
+        super();
+        this.op = op || null;
+        this.dimensionSizes = dimensionSizes;
+    }
+    getOp() {
+        return this.op;
+    }
+    setOp(newOp) {
+        this.op = newOp;
+    }
+    getUses() {
+        let uses = [];
+        if (this.op) {
+            uses.push(this.op);
+            uses.push(...this.op.getUses());
+        }
+        return uses;
+    }
+    getDimensionOrder() {
+        return this.dimensionSizes;
+    }
+    setDimensionOrder(dimensionOrder) {
+        this.dimensionSizes = dimensionOrder;
+    }
+    getOpType() {
+        if (this.op) {
+            return this.op.getType();
+        }
+        return null;
+    }
+    getType() {
+        return Type_2.CxxSizeTType.getInstance(Type_2.CxxTypeSigned.UNSIGNED, Type_2.CxxTypeBitWidth.UNKNOWN, Type_2.CxxStdTypeName.SIZE_T);
+    }
+    toString() {
+        if (this.op) {
+            return 'ArrayTypeTrait(' + this.op + this.dimensionSizes + ')';
+        }
+        return 'ArrayTypeTrait(' + this.dimensionSizes + ')';
+    }
+    inferType(arkMethod) {
+        if (this.op instanceof Ref_1.AbstractRef || this.op instanceof Expr_1.AbstractExpr) {
+            this.op.inferType(arkMethod);
+        }
+        return this;
+    }
+}
+exports.ArkArrayTypeTraitExpr = ArkArrayTypeTraitExpr;
+// typeid expression
+class ArkTypeIdExpr extends Expr_1.AbstractExpr {
+    constructor(op) {
+        super();
+        this.op = op;
+    }
+    getOp() {
+        return this.op;
+    }
+    setOp(newOp) {
+        this.op = newOp;
+    }
+    getUses() {
+        let uses = [];
+        uses.push(this.op);
+        uses.push(...this.op.getUses());
+        return uses;
+    }
+    getType() {
+        return new Type_2.TypeInfo('type_info', this.op.getType());
+    }
+    toString() {
+        return 'typeid(' + this.op + ')';
+    }
+    inferType(arkMethod) {
+        if (this.op instanceof Ref_1.AbstractRef || this.op instanceof Expr_1.AbstractExpr) {
+            this.op.inferType(arkMethod);
+        }
+        return this;
+    }
+}
+exports.ArkTypeIdExpr = ArkTypeIdExpr;
+// noexcept expression
+class ArkNoExpectExpr extends Expr_1.AbstractExpr {
+    constructor(op) {
+        super();
+        this.op = op;
+    }
+    getOp() {
+        return this.op;
+    }
+    setOp(newOp) {
+        this.op = newOp;
+    }
+    getUses() {
+        let uses = [];
+        uses.push(this.op);
+        uses.push(...this.op.getUses());
+        return uses;
+    }
+    getOpType() {
+        return this.op.getType();
+    }
+    getType() {
+        return Type_1.BooleanType.getInstance();
+    }
+    toString() {
+        return 'noexcept(' + this.op + ')';
+    }
+    inferType(arkMethod) {
+        if (this.op instanceof Ref_1.AbstractRef || this.op instanceof Expr_1.AbstractExpr) {
+            this.op.inferType(arkMethod);
+        }
+        return this;
+    }
+}
+exports.ArkNoExpectExpr = ArkNoExpectExpr;
+// cxx folder expression
+class ArkCxxFolderExpr extends Expr_1.AbstractExpr {
+    constructor(arg, op) {
+        super();
+        this.arg = arg;
+        this.op = op;
+    }
+    getArg() {
+        return this.arg;
+    }
+    setArg(newArg) {
+        this.arg = newArg;
+    }
+    getUses() {
+        let uses = [];
+        uses.push(this.arg);
+        uses.push(...this.arg.getUses());
+        return uses;
+    }
+    getType() {
+        return this.arg.getType();
+    }
+    getOp() {
+        return this.op;
+    }
+    toString() {
+        return `CxxFolderExpr(` + this.arg + this.op + `...)`;
+    }
+    inferType(arkMethod) {
+        let arg = this.getArg();
+        if (arg instanceof Ref_1.AbstractRef || arg instanceof Expr_1.AbstractExpr) {
+            arg.inferType(arkMethod);
+        }
+        return this;
+    }
+}
+exports.ArkCxxFolderExpr = ArkCxxFolderExpr;
+class ArkCxxNormalBinOpExpr extends Expr_1.AbstractBinopExpr {
+    constructor(op1, op2, operator) {
+        super(op1, op2, operator);
+    }
+    getType() {
+        if (!this.type) {
+            this.setType();
+        }
+        return this.type;
+    }
+    setCxxType(type) {
+        this.type = type;
+    }
+}
+exports.ArkCxxNormalBinOpExpr = ArkCxxNormalBinOpExpr;
+// Declare class objects on the stack
+class ArkAllocExpr extends Expr_1.AbstractExpr {
+    constructor(classType) {
+        super();
+        this.classType = classType;
+    }
+    getClassType() {
+        return this.classType;
+    }
+    getUses() {
+        return [];
+    }
+    getType() {
+        return this.classType;
+    }
+    toString() {
+        return 'alloc ' + this.classType;
+    }
+    /**
+     *Inference type method
+     *@ param arkMethod - Ark method object, the context used for type inference
+     *@ returns the ArkNewExpr instance of the current object
+     */
+    inferType(arkMethod) {
+        var _a, _b;
+        const classSignature = this.classType.getClassSignature();
+        if (classSignature.getDeclaringFileSignature().getFileName() === Const_1.UNKNOWN_FILE_NAME) {
+            const className = classSignature.getClassName();
+            let type = (_a = ModelUtils_1.ModelUtils.findDeclaredLocal(new Local_1.Local(className), arkMethod, 1)) === null || _a === void 0 ? void 0 : _a.getType();
+            if (TypeInference_1.TypeInference.isUnclearType(type)) {
+                type = TypeInference_1.TypeInference.inferUnclearRefName(className, arkMethod.getDeclaringArkClass());
+            }
+            // If the type is an alias type, replace with the original type
+            if (type instanceof Type_1.AliasType) {
+                const originalType = TypeInference_1.TypeInference.replaceAliasType(type);
+                if (originalType instanceof Type_1.FunctionType) {
+                    type = originalType.getMethodSignature().getMethodSubSignature().getReturnType();
+                }
+                else {
+                    type = originalType;
+                }
+            }
+            if (type && type instanceof Type_1.ClassType) {
+                const instanceType = (_b = this.constructorSignature(type, arkMethod)) !== null && _b !== void 0 ? _b : type;
+                this.classType.setClassSignature(instanceType.getClassSignature());
+                TypeInference_1.TypeInference.inferRealGenericTypes(this.classType.getRealGenericTypes(), arkMethod.getDeclaringArkClass());
+            }
+        }
+        return this;
+    }
+    constructorSignature(type, arkMethod) {
+        var _a;
+        const classConstructor = arkMethod.getDeclaringArkFile().getScene().getClass(type.getClassSignature());
+        if ((classConstructor === null || classConstructor === void 0 ? void 0 : classConstructor.getCategory()) === ArkClass_1.ClassCategory.INTERFACE) {
+            const type = (_a = classConstructor.getMethodWithName('construct-signature')) === null || _a === void 0 ? void 0 : _a.getReturnType();
+            if (type) {
+                const returnType = TypeInference_1.TypeInference.replaceAliasType(type);
+                return returnType instanceof Type_1.ClassType ? returnType : undefined;
+            }
+        }
+        return undefined;
+    }
+}
+exports.ArkAllocExpr = ArkAllocExpr;
+/**
+ * Aggregate expression to represent such cases :
+ *     struct Point q = (struct Point){.x = 5, .y = 8, .name = 'c'};
+ *     int* arr = (int[5]){1, 2, 3, 4, 5};
+ *     the right value is {},its kind is CompoundLiteralExpr or InitListExpr
+ */
+class ArkAggregateExpr extends Expr_1.AbstractExpr {
+    constructor(elements, type) {
+        super();
+        this.elements = elements;
+        this.type = type;
+    }
+    getElements() {
+        return this.elements;
+    }
+    setType(type) {
+        this.type = type;
+    }
+    getUses() {
+        let uses = [];
+        for (const element of this.elements) {
+            uses.push(element);
+            uses.push(...element.getUses());
+        }
+        return uses;
+    }
+    getType() {
+        return this.type;
+    }
+    inferType(arkMethod) {
+        const trueType = TypeInference_1.TypeInference.inferUnclearedType(this.type, arkMethod.getDeclaringArkClass());
+        if (trueType) {
+            this.type = trueType;
+        }
+        return this;
+    }
+    toString() {
+        return `AggregateExpr(${this.elements})`;
+    }
+}
+exports.ArkAggregateExpr = ArkAggregateExpr;
+/**
+ * ArkDesignatedInitExpr is used to represent designated initializers in aggregate initialization expressions.
+ * It consists of an initializer value and a designator, which specifies the field or element to be initialized.
+ * For example:
+ *     struct Point q = (struct Point){.x = 5, .y = 8, .name = 'c'};
+ *     its kind is DesignatedInitExpr
+ */
+class ArkDesignatedInitExpr extends Expr_1.AbstractExpr {
+    constructor(init, designator) {
+        super();
+        this.init = init;
+        this.designator = designator;
+    }
+    getInit() {
+        return this.init;
+    }
+    getDesignator() {
+        return this.designator;
+    }
+    inferType(arkMethod) {
+        if (this.init instanceof Ref_1.AbstractRef || this.init instanceof Expr_1.AbstractExpr) {
+            this.init.inferType(arkMethod);
+        }
+        if (this.designator instanceof Ref_1.AbstractRef || this.designator instanceof Expr_1.AbstractExpr) {
+            this.designator.inferType(arkMethod);
+        }
+        return this;
+    }
+    getUses() {
+        let uses = [];
+        uses.push(this.init);
+        uses.push(this.designator);
+        uses.push(...this.init.getUses());
+        uses.push(...this.designator.getUses());
+        return uses;
+    }
+    getType() {
+        return this.init.getType();
+    }
+    toString() {
+        return this.init + ' = ' + this.designator;
+    }
+}
+exports.ArkDesignatedInitExpr = ArkDesignatedInitExpr;

package/lib/frontend/cppFrontend/base/Ref.d.ts

@@ -0,0 +1,25 @@
+import { ArkInstanceFieldRef, ClosureFieldRef } from '../../../core/base/Ref';
+import { Local } from '../../../core/base/Local';
+import { FieldSignature } from '../../../core/model/ArkSignature';
+import { Type } from '../../../core/base/Type';
+/**
+ * C++ member access implementation, designed as a derived class because it needs to distinguish between p.f
+ * and p->f without intrusive modification to the original arkIR
+ */
+export declare class ArkCxxInstanceFieldRef extends ArkInstanceFieldRef {
+    private isArrow;
+    constructor(base: Local, isArrow: boolean, fieldSignature: FieldSignature);
+    isArrowAccess(): boolean;
+    toString(): string;
+    getType(): Type;
+}
+export declare enum CxxClosureCaptureType {
+    BY_VALUE = 0,
+    BY_REF = 1
+}
+export declare class CxxClosureFieldRef extends ClosureFieldRef {
+    private captureType;
+    constructor(base: Local, fieldName: string, type: Type, captureType: CxxClosureCaptureType);
+    getCaptureType(): CxxClosureCaptureType;
+}
+//# sourceMappingURL=Ref.d.ts.map

package/lib/frontend/cppFrontend/base/Ref.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Ref.d.ts","sourceRoot":"","sources":["../../../../src/frontend/cppFrontend/base/Ref.ts"],"names":[],"mappings":"AAeA,OAAO,EAAE,mBAAmB,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAC9E,OAAO,EAAE,KAAK,EAAE,MAAM,0BAA0B,CAAC;AACjD,OAAO,EAAE,cAAc,EAAE,MAAM,kCAAkC,CAAC;AAClE,OAAO,EAAE,IAAI,EAAE,MAAM,yBAAyB,CAAC;AAE/C;;;GAGG;AACH,qBAAa,sBAAuB,SAAQ,mBAAmB;IAC3D,OAAO,CAAC,OAAO,CAAU;gBAEb,IAAI,EAAE,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,cAAc,EAAE,cAAc;IAKlE,aAAa,IAAI,OAAO;IAIxB,QAAQ,IAAI,MAAM;IAIlB,OAAO,IAAI,IAAI;CAGzB;AAED,oBAAY,qBAAqB;IAC7B,QAAQ,IAAI;IACZ,MAAM,IAAI;CACb;AAED,qBAAa,kBAAmB,SAAQ,eAAe;IACnD,OAAO,CAAC,WAAW,CAAwB;gBAE/B,IAAI,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,WAAW,EAAE,qBAAqB;IAKnF,cAAc,IAAI,qBAAqB;CAGjD"}

package/lib/frontend/cppFrontend/base/Ref.js

@@ -0,0 +1,53 @@
+"use strict";
+/*
+ * Copyright (c) 2024-2025 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CxxClosureFieldRef = exports.CxxClosureCaptureType = exports.ArkCxxInstanceFieldRef = void 0;
+const Ref_1 = require("../../../core/base/Ref");
+/**
+ * C++ member access implementation, designed as a derived class because it needs to distinguish between p.f
+ * and p->f without intrusive modification to the original arkIR
+ */
+class ArkCxxInstanceFieldRef extends Ref_1.ArkInstanceFieldRef {
+    constructor(base, isArrow, fieldSignature) {
+        super(base, fieldSignature);
+        this.isArrow = isArrow;
+    }
+    isArrowAccess() {
+        return this.isArrow;
+    }
+    toString() {
+        return this.getBase().toString() + (this.isArrow ? '->' : '.') + '<' + this.getFieldSignature() + '>';
+    }
+    getType() {
+        return this.getFieldSignature().getType();
+    }
+}
+exports.ArkCxxInstanceFieldRef = ArkCxxInstanceFieldRef;
+var CxxClosureCaptureType;
+(function (CxxClosureCaptureType) {
+    CxxClosureCaptureType[CxxClosureCaptureType["BY_VALUE"] = 0] = "BY_VALUE";
+    CxxClosureCaptureType[CxxClosureCaptureType["BY_REF"] = 1] = "BY_REF";
+})(CxxClosureCaptureType = exports.CxxClosureCaptureType || (exports.CxxClosureCaptureType = {}));
+class CxxClosureFieldRef extends Ref_1.ClosureFieldRef {
+    constructor(base, fieldName, type, captureType) {
+        super(base, fieldName, type);
+        this.captureType = captureType;
+    }
+    getCaptureType() {
+        return this.captureType;
+    }
+}
+exports.CxxClosureFieldRef = CxxClosureFieldRef;

package/lib/frontend/cppFrontend/base/Trap.d.ts

@@ -0,0 +1,8 @@
+import { BasicBlock } from '../../../core/graph/BasicBlock';
+import { Trap } from '../../../core/base/Trap';
+export declare class CxxTrap extends Trap {
+    private readonly cxxCatchBlocks;
+    constructor(tryBlocks: BasicBlock[], catchBlocks: BasicBlock[][]);
+    getCxxCatchBlocks(): BasicBlock[][];
+}
+//# sourceMappingURL=Trap.d.ts.map

package/lib/frontend/cppFrontend/base/Trap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Trap.d.ts","sourceRoot":"","sources":["../../../../src/frontend/cppFrontend/base/Trap.ts"],"names":[],"mappings":"AAeA,OAAO,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAC;AAC5D,OAAO,EAAE,IAAI,EAAE,MAAM,yBAAyB,CAAC;AAE/C,qBAAa,OAAQ,SAAQ,IAAI;IAG7B,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAiB;gBAEpC,SAAS,EAAE,UAAU,EAAE,EAAE,WAAW,EAAE,UAAU,EAAE,EAAE;IAMzD,iBAAiB,IAAI,UAAU,EAAE,EAAE;CAG7C"}

package/lib/frontend/cppFrontend/base/Trap.js

@@ -0,0 +1,28 @@
+"use strict";
+/*
+ * Copyright (c) 2024-2025 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CxxTrap = void 0;
+const Trap_1 = require("../../../core/base/Trap");
+class CxxTrap extends Trap_1.Trap {
+    constructor(tryBlocks, catchBlocks) {
+        super(tryBlocks, []);
+        this.cxxCatchBlocks = catchBlocks;
+    }
+    getCxxCatchBlocks() {
+        return this.cxxCatchBlocks;
+    }
+}
+exports.CxxTrap = CxxTrap;