@idlizer/core 2.0.15

package/build/lib/src/LanguageWriters/common.d.ts

@@ -0,0 +1,17 @@
+export declare enum RuntimeType {
+    UNEXPECTED = -1,
+    NUMBER = 1,
+    STRING = 2,
+    OBJECT = 3,
+    BOOLEAN = 4,
+    UNDEFINED = 5,
+    BIGINT = 6,
+    FUNCTION = 7,
+    SYMBOL = 8,
+    MATERIALIZED = 9
+}
+export declare class NativeModuleType {
+    name: string;
+    constructor(name: string);
+}
+//# sourceMappingURL=common.d.ts.map

package/build/lib/src/LanguageWriters/common.js

@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2024 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.
+ */
+export var RuntimeType;
+(function (RuntimeType) {
+    RuntimeType[RuntimeType["UNEXPECTED"] = -1] = "UNEXPECTED";
+    RuntimeType[RuntimeType["NUMBER"] = 1] = "NUMBER";
+    RuntimeType[RuntimeType["STRING"] = 2] = "STRING";
+    RuntimeType[RuntimeType["OBJECT"] = 3] = "OBJECT";
+    RuntimeType[RuntimeType["BOOLEAN"] = 4] = "BOOLEAN";
+    RuntimeType[RuntimeType["UNDEFINED"] = 5] = "UNDEFINED";
+    RuntimeType[RuntimeType["BIGINT"] = 6] = "BIGINT";
+    RuntimeType[RuntimeType["FUNCTION"] = 7] = "FUNCTION";
+    RuntimeType[RuntimeType["SYMBOL"] = 8] = "SYMBOL";
+    RuntimeType[RuntimeType["MATERIALIZED"] = 9] = "MATERIALIZED";
+})(RuntimeType || (RuntimeType = {}));
+export class NativeModuleType {
+    constructor(name) {
+        this.name = name;
+    }
+}
+//# sourceMappingURL=common.js.map

package/build/lib/src/LanguageWriters/convertors/CppConvertors.d.ts

@@ -0,0 +1,8 @@
+import * as idl from '../../idl';
+import { IdlNameConvertor } from "../nameConvertor";
+import { InteropConvertor } from '../InteropConvertor';
+export declare class CppInteropConvertor extends InteropConvertor implements IdlNameConvertor {
+    private unwrap;
+    convert(node: idl.IDLNode): string;
+}
+//# sourceMappingURL=CppConvertors.d.ts.map

package/build/lib/src/LanguageWriters/convertors/CppConvertors.js

@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 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.
+ */
+import * as idl from '../../idl';
+import { generatorConfiguration } from "../../config";
+import { InteropConvertor } from '../InteropConvertor';
+export class CppInteropConvertor extends InteropConvertor {
+    unwrap(type, result) {
+        if (idl.isType(type) && idl.isOptionalType(type)) {
+            return `Opt_${result.text}`;
+        }
+        if (result.noPrefix) {
+            return result.text;
+        }
+        const conf = generatorConfiguration();
+        const typePrefix = conf.param("TypePrefix");
+        const libPrefix = idl.isPrimitiveType(type) ? "" : conf.param("LibraryPrefix");
+        return `${typePrefix}${libPrefix}${result.text}`;
+    }
+    convert(node) {
+        return this.unwrap(node, this.convertNode(node));
+    }
+}
+//# sourceMappingURL=CppConvertors.js.map

package/build/lib/src/LanguageWriters/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./nameConvertor";
+export * from "./InteropConvertor";
+//# sourceMappingURL=index.d.ts.map

package/build/lib/src/LanguageWriters/index.js

@@ -0,0 +1,3 @@
+export * from "./nameConvertor";
+export * from "./InteropConvertor";
+//# sourceMappingURL=index.js.map

package/build/lib/src/LanguageWriters/nameConvertor.d.ts

@@ -0,0 +1,28 @@
+import * as idl from '../idl';
+export interface IdlNameConvertor {
+    convert(node: idl.IDLNode): string;
+}
+export interface TypeConvertor<T> {
+    convertOptional(type: idl.IDLOptionalType): T;
+    convertUnion(type: idl.IDLUnionType): T;
+    convertContainer(type: idl.IDLContainerType): T;
+    convertImport(type: idl.IDLReferenceType, importClause: string): T;
+    convertTypeReference(type: idl.IDLReferenceType): T;
+    convertTypeParameter(type: idl.IDLTypeParameterType): T;
+    convertPrimitiveType(type: idl.IDLPrimitiveType): T;
+}
+export declare function convertType<T>(convertor: TypeConvertor<T>, type: idl.IDLType): T;
+export interface DeclarationConvertor<T> {
+    convertNamespace(node: idl.IDLNamespace): T;
+    convertInterface(node: idl.IDLInterface): T;
+    convertEnum(node: idl.IDLEnum): T;
+    convertTypedef(node: idl.IDLTypedef): T;
+    convertCallback(node: idl.IDLCallback): T;
+    convertMethod(node: idl.IDLMethod): T;
+    convertConstant(node: idl.IDLConstant): T;
+}
+export declare function convertDeclaration<T>(convertor: DeclarationConvertor<T>, decl: idl.IDLEntry): T;
+export interface NodeConvertor<T> extends TypeConvertor<T>, DeclarationConvertor<T> {
+}
+export declare function convertNode<T>(convertor: NodeConvertor<T>, node: idl.IDLNode): T;
+//# sourceMappingURL=nameConvertor.d.ts.map

package/build/lib/src/LanguageWriters/nameConvertor.js

@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) 2024 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.
+ */
+import * as idl from '../idl';
+export function convertType(convertor, type) {
+    if (idl.isOptionalType(type))
+        return convertor.convertOptional(type);
+    if (idl.isUnionType(type))
+        return convertor.convertUnion(type);
+    if (idl.isContainerType(type))
+        return convertor.convertContainer(type);
+    if (idl.isReferenceType(type)) {
+        const importAttr = idl.getExtAttribute(type, idl.IDLExtendedAttributes.Import);
+        return importAttr
+            ? convertor.convertImport(type, importAttr)
+            : convertor.convertTypeReference(type);
+    }
+    if (idl.isTypeParameterType(type))
+        return convertor.convertTypeParameter(type);
+    if (idl.isPrimitiveType(type))
+        return convertor.convertPrimitiveType(type);
+    throw new Error(`Unknown type ${idl.IDLKind[type.kind]}`);
+}
+export function convertDeclaration(convertor, decl) {
+    if (idl.isNamespace(decl))
+        return convertor.convertNamespace(decl);
+    if (idl.isInterface(decl))
+        return convertor.convertInterface(decl);
+    if (idl.isEnum(decl))
+        return convertor.convertEnum(decl);
+    if (idl.isEnumMember(decl))
+        return convertor.convertEnum(decl.parent);
+    if (idl.isTypedef(decl))
+        return convertor.convertTypedef(decl);
+    if (idl.isCallback(decl))
+        return convertor.convertCallback(decl);
+    if (idl.isMethod(decl))
+        return convertor.convertMethod(decl);
+    if (idl.isConstant(decl))
+        return convertor.convertConstant(decl);
+    throw new Error(`Unknown declaration type ${decl.kind ? idl.IDLKind[decl.kind] : "(undefined kind)"}`);
+}
+export function convertNode(convertor, node) {
+    if (idl.isEntry(node))
+        return convertDeclaration(convertor, node);
+    if (idl.isType(node))
+        return convertType(convertor, node);
+    throw new Error(`Unknown node type ${idl.IDLKind[node.kind]}`);
+}
+//# sourceMappingURL=nameConvertor.js.map

package/build/lib/src/LanguageWriters/writers/CJLanguageWriter.d.ts

@@ -0,0 +1,147 @@
+import * as idl from "../../idl";
+import { IndentedPrinter } from "../../IndentedPrinter";
+import { ArgConvertor, BaseArgConvertor } from "../ArgConvertors";
+import { RuntimeType } from "../common";
+import { AssignStatement, FieldModifier, LambdaExpression, LanguageExpression, LanguageStatement, LanguageWriter, MakeCastOptions, Method, MethodModifier, MethodSignature, NamedMethodSignature, ObjectArgs } from "../LanguageWriter";
+import { IdlNameConvertor } from "../nameConvertor";
+import { Language } from "../../Language";
+import { ReferenceResolver } from "../../peer-generation/ReferenceResolver";
+export declare class CJCheckDefinedExpression implements LanguageExpression {
+    private value;
+    constructor(value: string);
+    asString(): string;
+}
+export declare class CJCastExpression implements LanguageExpression {
+    value: LanguageExpression;
+    type: string;
+    private unsafe;
+    constructor(value: LanguageExpression, type: string, unsafe?: boolean);
+    asString(): string;
+}
+export declare class CJUnionCastExpression implements LanguageExpression {
+    value: LanguageExpression;
+    type: string;
+    private unsafe;
+    constructor(value: LanguageExpression, type: string, unsafe?: boolean);
+    asString(): string;
+}
+export declare class CJMatchExpression implements LanguageExpression {
+    matchValue: LanguageExpression;
+    matchCases: LanguageExpression[];
+    caseBlocks: LanguageExpression[];
+    constructor(matchValue: LanguageExpression, matchCases: LanguageExpression[], caseBlocks: LanguageExpression[]);
+    asString(): string;
+}
+export declare class CJTernaryExpression implements LanguageExpression {
+    condition: LanguageExpression;
+    trueExpression: LanguageExpression;
+    falseExpression: LanguageExpression;
+    constructor(condition: LanguageExpression, trueExpression: LanguageExpression, falseExpression: LanguageExpression);
+    asString(): string;
+}
+export declare class CJNewObjectExpression implements LanguageExpression {
+    private objectName;
+    private params;
+    constructor(objectName: string, params: LanguageExpression[]);
+    asString(): string;
+}
+export declare class CJAssignStatement extends AssignStatement {
+    variableName: string;
+    type: idl.IDLType | undefined;
+    expression: LanguageExpression;
+    isDeclared: boolean;
+    isConst: boolean;
+    constructor(variableName: string, type: idl.IDLType | undefined, expression: LanguageExpression, isDeclared?: boolean, isConst?: boolean);
+    write(writer: LanguageWriter): void;
+}
+export declare class CJEnumWithGetter implements LanguageStatement {
+    private readonly enumEntity;
+    private readonly isExport;
+    constructor(enumEntity: idl.IDLEnum, isExport: boolean);
+    write(writer: LanguageWriter): void;
+}
+export declare class CJEnumEntityStatement implements LanguageStatement {
+    private readonly enumEntity;
+    private readonly isExport;
+    constructor(enumEntity: idl.IDLEnum, isExport: boolean);
+    write(writer: LanguageWriter): void;
+}
+export declare class CJLanguageWriter extends LanguageWriter {
+    protected typeConvertor: IdlNameConvertor;
+    protected typeForeignConvertor: IdlNameConvertor;
+    constructor(printer: IndentedPrinter, resolver: ReferenceResolver, typeConvertor: IdlNameConvertor, typeForeignConvertor: IdlNameConvertor, language?: Language);
+    fork(options?: {
+        resolver?: ReferenceResolver;
+    }): LanguageWriter;
+    getNodeName(type: idl.IDLNode): string;
+    writeClass(name: string, op: (writer: this) => void, superClass?: string, interfaces?: string[], generics?: string[]): void;
+    writeEnum(name: string, members: {
+        name: string;
+        stringId: string | undefined;
+        numberId: number;
+    }[], op: (writer: LanguageWriter) => void): void;
+    writeInterface(name: string, op: (writer: this) => void, superInterfaces?: string[]): void;
+    writeFunctionDeclaration(name: string, signature: MethodSignature): void;
+    writeFunctionImplementation(name: string, signature: MethodSignature, op: (writer: this) => void): void;
+    private generateFunctionDeclaration;
+    writeMethodCall(receiver: string, method: string, params: string[], nullable?: boolean): void;
+    writeFieldDeclaration(name: string, type: idl.IDLType, modifiers: FieldModifier[] | undefined, optional: boolean, initExpr?: LanguageExpression): void;
+    writeMethodDeclaration(name: string, signature: MethodSignature, modifiers?: MethodModifier[]): void;
+    writeConstructorImplementation(className: string, signature: MethodSignature, op: (writer: this) => void, superCall?: Method, modifiers?: MethodModifier[]): void;
+    writeProperty(propName: string, propType: idl.IDLType, mutable?: boolean, getterLambda?: (writer: this) => void, setterLambda?: (writer: this) => void): void;
+    writeMethodImplementation(method: Method, op: (writer: this) => void): void;
+    writeCJForeign(op: (writer: CJLanguageWriter) => void): void;
+    private writeDeclaration;
+    writeNativeFunctionCall(printer: LanguageWriter, name: string, signature: MethodSignature): void;
+    writeNativeMethodDeclaration(name: string, signature: NamedMethodSignature): void;
+    makeEnumCast(enumName: string, _unsafe: boolean, _convertor: ArgConvertor | undefined): string;
+    makeAssign(variableName: string, type: idl.IDLType | undefined, expr: LanguageExpression, isDeclared?: boolean, isConst?: boolean): LanguageStatement;
+    makeClassInit(type: idl.IDLType, parameters: LanguageExpression[]): LanguageExpression;
+    makeArrayInit(type: idl.IDLContainerType, size?: number): LanguageExpression;
+    makeMapInit(type: idl.IDLType): LanguageExpression;
+    makeArrayLength(array: string, length?: string): LanguageExpression;
+    makeArrayResize(array: string, arrayType: string, length: string, deserializer: string): LanguageStatement;
+    makeArrayAccess(value: string, indexVar: string): LanguageExpression;
+    makeRuntimeTypeCondition(typeVarName: string, equals: boolean, type: RuntimeType, varName: string): LanguageExpression;
+    makeLambda(signature: MethodSignature, body?: LanguageStatement[]): LanguageExpression;
+    makeThrowError(message: string): LanguageStatement;
+    makeTernary(condition: LanguageExpression, trueExpression: LanguageExpression, falseExpression: LanguageExpression): LanguageExpression;
+    makeReturn(expr: LanguageExpression): LanguageStatement;
+    makeCheckOptional(optional: LanguageExpression, doStatement: LanguageStatement): LanguageStatement;
+    makeStatement(expr: LanguageExpression): LanguageStatement;
+    makeLoop(counter: string, limit: string, statement?: LanguageStatement): LanguageStatement;
+    makeMapForEach(map: string, key: string, value: string, op: () => void): LanguageStatement;
+    makeDefinedCheck(value: string): LanguageExpression;
+    makeNewObject(objectName: string, params?: LanguageExpression[]): LanguageExpression;
+    writePrintLog(message: string): void;
+    makeCast(value: LanguageExpression, type: idl.IDLType, options?: MakeCastOptions): LanguageExpression;
+    typeInstanceOf(type: idl.IDLEntry, value: string, members?: string[]): LanguageExpression;
+    getObjectAccessor(convertor: BaseArgConvertor, value: string, args?: ObjectArgs): string;
+    makeUndefined(): LanguageExpression;
+    makeUnwrapOptional(expression: LambdaExpression): LanguageExpression;
+    makeValueFromOption(value: string, destinationConvertor: ArgConvertor): LanguageExpression;
+    makeRuntimeType(rt: RuntimeType): LanguageExpression;
+    makeRuntimeTypeGetterCall(value: string): LanguageExpression;
+    makeMapInsert(keyAccessor: string, key: string, valueAccessor: string, value: string): LanguageStatement;
+    makeNull(value?: string): LanguageExpression;
+    getTagType(): idl.IDLType;
+    getRuntimeType(): idl.IDLType;
+    makeTupleAssign(receiver: string, fields: string[]): LanguageStatement;
+    get supportedModifiers(): MethodModifier[];
+    get supportedFieldModifiers(): FieldModifier[];
+    makeUnionSelector(value: string, valueType: string): LanguageStatement;
+    makeUnionVariantCondition(_convertor: ArgConvertor, _valueName: string, valueType: string, type: string, convertorIndex?: number): LanguageExpression;
+    makeUnionVariantCast(value: string, type: string, convertor: ArgConvertor, index: number): LanguageExpression;
+    makeTupleAccess(value: string, index: number): LanguageExpression;
+    enumFromOrdinal(value: LanguageExpression, enumEntry: idl.IDLType): LanguageExpression;
+    ordinalFromEnum(value: LanguageExpression, _: idl.IDLType): LanguageExpression;
+    makeEnumEntity(enumEntity: idl.IDLEnum, isExport: boolean): LanguageStatement;
+    makeEquals(args: LanguageExpression[]): LanguageExpression;
+    runtimeType(param: ArgConvertor, valueType: string, value: string): void;
+    escapeKeyword(word: string): string;
+    castToInt(value: string, bitness: 8 | 32): string;
+    castToBoolean(value: string): string;
+    makeLengthSerializer(serializer: string, value: string): LanguageStatement | undefined;
+    makeLengthDeserializer(deserializer: string): LanguageStatement | undefined;
+}
+//# sourceMappingURL=CJLanguageWriter.d.ts.map