@idlizer/core 2.0.15

package/build/lib/src/LanguageWriters/writers/CppLanguageWriter.js

@@ -0,0 +1,472 @@
+/*
+ * 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 { createReferenceType, forceAsNamedNode, IDLU32Type, IDLUint8ArrayType, IDLVoidType } from '../../idl';
+import { Language } from '../../Language';
+import { PrimitiveTypeList } from "../../peer-generation/PrimitiveType";
+import { AssignStatement, BlockStatement, FieldModifier, PrintHint, MethodModifier, NamedMethodSignature, StringExpression } from "../LanguageWriter";
+import { CDefinedExpression, CLikeExpressionStatement, CLikeLanguageWriter, CLikeLoopStatement, CLikeReturnStatement } from "./CLikeLanguageWriter";
+import { RuntimeType } from "../common";
+import { IndentedPrinter } from "../../IndentedPrinter";
+import { throwException } from "../../util";
+import { cppKeywords } from "../../languageSpecificKeywords";
+////////////////////////////////////////////////////////////////
+//                        EXPRESSIONS                         //
+////////////////////////////////////////////////////////////////
+export class CppCastExpression {
+    constructor(convertor, value, type, options) {
+        this.convertor = convertor;
+        this.value = value;
+        this.type = type;
+        this.options = options;
+    }
+    asString() {
+        var _a, _b, _c, _d;
+        if (forceAsNamedNode(this.type).name === "Tag") {
+            return `${this.value.asString()} == ${PrimitiveTypeList.UndefinedRuntime} ? ${PrimitiveTypeList.UndefinedTag} : ${PrimitiveTypeList.ObjectTag}`;
+        }
+        let resultName = '';
+        if ((_a = this.options) === null || _a === void 0 ? void 0 : _a.overrideTypeName) {
+            resultName = this.options.overrideTypeName;
+        }
+        else {
+            const pureName = this.mapTypeWithReceiver(this.type, (_b = this.options) === null || _b === void 0 ? void 0 : _b.receiver);
+            const qualifiedName = ((_c = this.options) === null || _c === void 0 ? void 0 : _c.toRef) ? `${pureName}&` : pureName;
+            resultName = qualifiedName;
+        }
+        return ((_d = this.options) === null || _d === void 0 ? void 0 : _d.unsafe)
+            ? `reinterpret_cast<${resultName}>(${this.value.asString()})`
+            : `static_cast<${resultName}>(${this.value.asString()})`;
+    }
+    mapTypeWithReceiver(type, receiver) {
+        // make deducing type from receiver
+        if (receiver !== undefined) {
+            return `std::decay<decltype(${receiver})>::type`;
+        }
+        return this.convertor.convert(type);
+    }
+}
+export class CppPointerPropertyAccessExpression {
+    constructor(expression, name) {
+        this.expression = expression;
+        this.name = name;
+    }
+    asString() {
+        return `${this.expression}->${this.name}`;
+    }
+}
+////////////////////////////////////////////////////////////////
+//                         STATEMENTS                         //
+////////////////////////////////////////////////////////////////
+export class CppAssignStatement extends AssignStatement {
+    constructor(variableName, type, expression, isDeclared = true, isConst = true, options) {
+        super(variableName, type, expression, isDeclared, isConst, options);
+        this.variableName = variableName;
+        this.type = type;
+        this.expression = expression;
+        this.isDeclared = isDeclared;
+        this.isConst = isConst;
+        this.options = options;
+    }
+    write(writer) {
+        var _a, _b;
+        if (this.isDeclared) {
+            const typeName = this.type ? writer.stringifyTypeWithReceiver(this.type, (_a = this.options) === null || _a === void 0 ? void 0 : _a.receiver) : "auto";
+            const typeSpec = ((_b = this.options) === null || _b === void 0 ? void 0 : _b.assignRef) ? `${typeName}&` : typeName;
+            const initValue = this.expression ? this.expression.asString() : "{}";
+            const constSpec = this.isConst ? "const " : "";
+            writer.print(`${constSpec}${typeSpec} ${this.variableName} = ${initValue};`);
+        }
+        else {
+            writer.print(`${this.variableName} = ${this.expression.asString()};`);
+        }
+    }
+}
+class CppArrayResizeStatement {
+    constructor(array, length, deserializer) {
+        this.array = array;
+        this.length = length;
+        this.deserializer = deserializer;
+    }
+    write(writer) {
+        writer.print(`${this.deserializer}.resizeArray<std::decay<decltype(${this.array})>::type,
+        std::decay<decltype(*${this.array}.array)>::type>(&${this.array}, ${this.length});`);
+    }
+}
+class CppMapResizeStatement {
+    constructor(mapTypeName, keyType, valueType, map, size, deserializer) {
+        this.mapTypeName = mapTypeName;
+        this.keyType = keyType;
+        this.valueType = valueType;
+        this.map = map;
+        this.size = size;
+        this.deserializer = deserializer;
+    }
+    write(writer) {
+        writer.print(`${this.deserializer}.resizeMap<${this.mapTypeName}, ${writer.getNodeName(this.keyType)}, ${writer.getNodeName(this.valueType)}>(&${this.map}, ${this.size});`);
+    }
+}
+class CppMapForEachStatement {
+    constructor(map, key, value, op) {
+        this.map = map;
+        this.key = key;
+        this.value = value;
+        this.op = op;
+    }
+    write(writer) {
+        writer.print(`for (int32_t i = 0; i < ${this.map}.size; i++) {`);
+        writer.pushIndent();
+        writer.print(`auto ${this.key} = ${this.map}.keys[i];`);
+        writer.print(`auto ${this.value} = ${this.map}.values[i];`);
+        this.op();
+        writer.popIndent();
+        writer.print(`}`);
+    }
+}
+// todo:
+class CppEnumEntityStatement {
+    constructor(_enum) {
+        this._enum = _enum;
+    }
+    write(writer) {
+        writer.print(`typedef enum ${this._enum.name} {`);
+        writer.pushIndent();
+        this._enum.elements.forEach((member, index) => { var _a; return writer.print(`${member.name} = ${(_a = member.initializer) !== null && _a !== void 0 ? _a : index},`); });
+        writer.popIndent();
+        writer.print(`} ${this._enum.name};`);
+    }
+}
+class CPPThrowErrorStatement {
+    constructor(message) {
+        this.message = message;
+    }
+    write(writer) {
+        writer.print(`throw "${this.message}";`);
+    }
+}
+////////////////////////////////////////////////////////////////
+//                           WRITER                           //
+////////////////////////////////////////////////////////////////
+export class CppLanguageWriter extends CLikeLanguageWriter {
+    constructor(printer, resolver, typeConvertor, primitivesTypes) {
+        super(printer, resolver, Language.CPP);
+        this.primitivesTypes = primitivesTypes;
+        this.typeConvertor = typeConvertor;
+    }
+    getNodeName(type) {
+        return this.typeConvertor.convert(type);
+    }
+    fork(options) {
+        var _a;
+        return new CppLanguageWriter(new IndentedPrinter(), (_a = options === null || options === void 0 ? void 0 : options.resolver) !== null && _a !== void 0 ? _a : this.resolver, this.typeConvertor, this.primitivesTypes);
+    }
+    writeClass(name, op, superClass, interfaces) {
+        const superClasses = (superClass ? [superClass] : []).concat(interfaces !== null && interfaces !== void 0 ? interfaces : []);
+        const extendsClause = superClasses.length > 0 ? ` : ${superClasses.map(c => `public ${c}`).join(", ")}` : '';
+        this.printer.print(`class ${name}${extendsClause} {`);
+        this.pushIndent();
+        op(this);
+        this.popIndent();
+        this.printer.print(`};`);
+    }
+    writeInterface(name, op, superInterfaces) {
+        throw new Error("Method not implemented.");
+    }
+    writeMethodCall(receiver, method, params, nullable = false) {
+        if (nullable) {
+            this.printer.print(`if (${receiver}) ${receiver}.${method}(${params.join(", ")});`);
+        }
+        else {
+            super.writeMethodCall(receiver, method, params, nullable);
+        }
+    }
+    writeFieldDeclaration(name, type, modifiers, optional, initExpr) {
+        let filter = function (modifier_name) {
+            return modifier_name !== FieldModifier.STATIC;
+        };
+        let prefix = this.makeFieldModifiersList(modifiers, filter);
+        this.printer.print(`${prefix}:`);
+        this.printer.pushIndent();
+        this.printer.print(`${forceAsNamedNode(type).name} ${name};`);
+        this.printer.popIndent();
+    }
+    writeConstructorImplementation(className, signature, op, superCall, modifiers) {
+        const superInvocation = superCall
+            ? ` : ${superCall.name}(${superCall.signature.args.map((_, i) => superCall === null || superCall === void 0 ? void 0 : superCall.signature.argName(i)).join(", ")})`
+            : "";
+        const argList = signature.args.map((it, index) => {
+            var _a;
+            const maybeDefault = ((_a = signature.defaults) === null || _a === void 0 ? void 0 : _a[index]) ? ` = ${signature.defaults[index]}` : "";
+            return `${this.stringifyMethodArgType(it, signature.argHint(index))} ${signature.argName(index)}${maybeDefault}`;
+        }).join(", ");
+        this.print("public:");
+        this.print(`${className}(${argList})${superInvocation} {`);
+        this.pushIndent();
+        op(this);
+        this.popIndent();
+        this.print(`}`);
+    }
+    writeProperty(propName, propType, mutable = true) {
+        throw new Error("writeProperty for c++ is not implemented yet.");
+    }
+    /**
+     * Writes multiline comments decorated with stars
+     */
+    writeMultilineCommentBlock(lines) {
+        this.print('/*');
+        lines.split("\n").forEach(it => this.print(' * ' + it));
+        this.print(' */');
+    }
+    /**
+     * Writes `#include "path"`
+     * @param path File path to be included
+     */
+    writeInclude(path) {
+        this.print(`#include "${path}"`);
+    }
+    /**
+     * Writes `#include <path>`
+     * @param path File path to be included
+     */
+    writeGlobalInclude(path) {
+        this.print(`#include <${path}>`);
+    }
+    makeRef(type, options) {
+        return createReferenceType(`${this.stringifyTypeWithReceiver(type, options === null || options === void 0 ? void 0 : options.receiver)}&`, undefined, type);
+    }
+    makeThis() {
+        return new StringExpression("*this");
+    }
+    makeNull() {
+        return new StringExpression("nullptr");
+    }
+    makeValueFromOption(value) {
+        return this.makeString(`${value}.value`);
+    }
+    makeThrowError(message) {
+        return new CPPThrowErrorStatement(message);
+    }
+    makeAssign(variableName, type, expr, isDeclared = true, isConst = true, options) {
+        return new CppAssignStatement(variableName, type, expr, isDeclared, isConst, options);
+    }
+    makeLambda(signature, body) {
+        throw new Error(`TBD`);
+    }
+    makeReturn(expr) {
+        return new CLikeReturnStatement(expr);
+    }
+    makeCheckOptional(optional, doStatement) {
+        throw new Error(`TBD`);
+    }
+    makeStatement(expr) {
+        return new CLikeExpressionStatement(expr);
+    }
+    makeArrayAccess(value, indexVar) {
+        return this.makeString(`${value}.array[${indexVar}]`);
+    }
+    makeTupleAccess(value, index) {
+        return this.makeString(`${value}.value${index}`);
+    }
+    makeUnionSelector(value, valueType) {
+        return this.makeAssign(valueType, undefined, this.makeString(`${value}.selector`), false);
+    }
+    makeUnionVariantCondition(_convertor, _valueName, valueType, type, convertorIndex) {
+        return this.makeString(`${valueType} == ${convertorIndex}`);
+    }
+    makeUnionVariantCast(value, type, convertor, index) {
+        return this.makeString(`${value}.value${index}`);
+    }
+    makeLoop(counter, limit, statement) {
+        return new CLikeLoopStatement(counter, limit, statement);
+    }
+    makeMapForEach(map, key, value, op) {
+        return new CppMapForEachStatement(map, key, value, op);
+    }
+    makeArrayInit(type) {
+        return this.makeString(`{}`);
+    }
+    makeClassInit(type, paramenters) {
+        return this.makeString(`${this.getNodeName(type)}(${paramenters.map(it => it.asString()).join(", ")})`);
+    }
+    makeMapInit(type) {
+        return this.makeString(`{}`);
+    }
+    makeArrayResize(array, arrayType, length, deserializer) {
+        return new CppArrayResizeStatement(array, length, deserializer);
+    }
+    makeMapResize(mapTypeName, keyType, valueType, map, size, deserializer) {
+        return new CppMapResizeStatement(mapTypeName, keyType, valueType, map, size, deserializer);
+    }
+    makeCast(expr, type, options) {
+        return new CppCastExpression(this.typeConvertor, expr, type, options);
+    }
+    makePointerPropertyAccessExpression(expression, name) {
+        return new CppPointerPropertyAccessExpression(expression, name);
+    }
+    writePrintLog(message) {
+        this.print(`printf("${message}\n")`);
+    }
+    makeDefinedCheck(value) {
+        return new CDefinedExpression(value);
+    }
+    makeSetUnionSelector(value, index) {
+        return this.makeAssign(`${value}.selector`, undefined, this.makeString(index), false);
+    }
+    makeSetOptionTag(value, tag) {
+        return this.makeAssign(`${value}.tag`, undefined, tag, false);
+    }
+    getObjectAccessor(convertor, value, args) {
+        return value;
+    }
+    makeUndefined() {
+        return this.makeString(`${this.primitivesTypes.Undefined.getText()}()`);
+    }
+    makeVoid() {
+        return this.makeString(`${this.primitivesTypes.Void.getText()}()`);
+    }
+    makeRuntimeType(rt) {
+        return this.makeString(`INTEROP_RUNTIME_${RuntimeType[rt]}`);
+    }
+    makeMapInsert(keyAccessor, key, valueAccessor, value) {
+        // TODO: maybe use std::move?
+        return new BlockStatement([
+            this.makeAssign(keyAccessor, undefined, this.makeString(key), false),
+            this.makeAssign(valueAccessor, undefined, this.makeString(value), false)
+        ], false);
+    }
+    getTagType() {
+        return createReferenceType('Tag');
+    }
+    getRuntimeType() {
+        return createReferenceType(`RuntimeType`);
+    }
+    makeTupleAssign(receiver, tupleFields) {
+        const statements = tupleFields.map((field, index) => {
+            //TODO: maybe use std::move?
+            return this.makeAssign(`${receiver}.value${index}`, undefined, this.makeString(field), false);
+        });
+        return new BlockStatement(statements, false);
+    }
+    get supportedModifiers() {
+        return [MethodModifier.INLINE, MethodModifier.STATIC];
+    }
+    get supportedFieldModifiers() {
+        return [];
+    }
+    enumFromOrdinal(value, type) {
+        return this.makeString(`static_cast<${this.typeConvertor.convert(type)}>(` + value.asString() + `)`);
+    }
+    ordinalFromEnum(value, _) {
+        return value;
+    }
+    makeUnsafeCast(convertor, param) {
+        return param;
+    }
+    makeUnsafeCast_(value, type, typeOptions) {
+        let typeName = this.getNodeName(type);
+        switch (typeOptions) {
+            case PrintHint.AsPointer:
+                typeName = `${typeName}*`;
+                break;
+            case PrintHint.AsConstPointer:
+                typeName = `const ${typeName}*`;
+                break;
+            case PrintHint.AsConstReference:
+                typeName = `const ${typeName}&`;
+                break;
+            default:
+                break;
+        }
+        return `(${typeName}) (${value.asString()})`;
+    }
+    makeEnumCast(value, _unsafe, convertor) {
+        if (convertor !== undefined) {
+            return `static_cast<${this.typeConvertor.convert(convertor.nativeType())}>(${value})`;
+        }
+        throwException("Need pass EnumConvertor");
+    }
+    escapeKeyword(name) {
+        return cppKeywords.has(name) ? name + "_" : name;
+    }
+    makeEnumEntity(enumEntity, isExport) {
+        return new CppEnumEntityStatement(enumEntity);
+    }
+    decayTypeName(typeName) {
+        if (typeName.endsWith('*') || typeName.endsWith('&')) {
+            typeName = typeName.substring(0, typeName.length - 1);
+        }
+        if (typeName.startsWith('const ')) {
+            typeName = typeName.substring(6);
+        }
+        return typeName;
+    }
+    stringifyMethodReturnType(type, hint) {
+        const name = this.getNodeName(type);
+        let postfix = '';
+        if (hint === PrintHint.AsPointer || hint === PrintHint.AsConstPointer) {
+            postfix = '*';
+        }
+        let constModifier = '';
+        if (hint === PrintHint.AsConstPointer) {
+            constModifier = 'const ';
+        }
+        return `${constModifier}${name}${postfix}`;
+    }
+    stringifyMethodArgType(type, hint) {
+        // we should decide pass by value or by reference here
+        const name = this.getNodeName(type);
+        let constModifier = '';
+        let postfix = '';
+        switch (hint) {
+            case undefined:
+            case PrintHint.AsValue:
+                break;
+            case PrintHint.AsPointer:
+                postfix = '*';
+                break;
+            case PrintHint.AsConstPointer:
+                constModifier = 'const ';
+                postfix = '*';
+                break;
+            case PrintHint.AsConstReference:
+                constModifier = 'const ';
+                postfix = '&';
+                break;
+            default:
+                throw new Error(`Unknown hint ${hint}`);
+        }
+        return `${constModifier}${name}${postfix}`;
+    }
+    stringifyTypeWithReceiver(type, receiver) {
+        // make deducing type from receiver
+        if (receiver !== undefined) {
+            return `std::decay<decltype(${receiver})>::type`;
+        }
+        return this.getNodeName(type);
+    }
+    makeSerializerConstructorSignature() {
+        return new NamedMethodSignature(IDLVoidType, [
+            IDLUint8ArrayType,
+            IDLU32Type,
+            createReferenceType("CallbackResourceHolder" /* ast */)
+        ], ["data", "dataLength", "resourceHolder"], [undefined, `0`, `nullptr`], [undefined, undefined, undefined, PrintHint.AsPointer]);
+    }
+    makeLengthSerializer(serializer, value) {
+        return undefined;
+    }
+    makeLengthDeserializer(deserializer) {
+        return undefined;
+    }
+}
+//# sourceMappingURL=CppLanguageWriter.js.map

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

@@ -0,0 +1,72 @@
+import { IndentedPrinter } from "../../IndentedPrinter";
+import { LambdaExpression, LanguageExpression, LanguageStatement, LanguageWriter, MakeCastOptions, MethodModifier, MethodSignature, ObjectArgs } from "../LanguageWriter";
+import { TSLanguageWriter } from "./TsLanguageWriter";
+import { IDLEnum, IDLType } from '../../idl';
+import { ArgConvertor } from "../ArgConvertors";
+import * as idl from '../../idl';
+import { IdlNameConvertor } from "../nameConvertor";
+import { ReferenceResolver } from "../../peer-generation/ReferenceResolver";
+export declare class EtsAssignStatement implements LanguageStatement {
+    variableName: string;
+    type: IDLType | undefined;
+    expression: LanguageExpression;
+    isDeclared: boolean;
+    protected isConst: boolean;
+    constructor(variableName: string, type: IDLType | undefined, expression: LanguageExpression, isDeclared?: boolean, isConst?: boolean);
+    write(writer: LanguageWriter): void;
+}
+export declare class ArkTSEnumEntityStatement implements LanguageStatement {
+    private readonly enumEntity;
+    private readonly isExport;
+    constructor(enumEntity: IDLEnum, isExport: boolean);
+    write(writer: LanguageWriter): void;
+}
+export declare class ETSLambdaExpression extends LambdaExpression {
+    private convertor;
+    constructor(writer: LanguageWriter, convertor: IdlNameConvertor, signature: MethodSignature, resolver: ReferenceResolver, body?: LanguageStatement[]);
+    protected get statementHasSemicolon(): boolean;
+    asString(): string;
+}
+export declare function generateTypeCheckerName(typeName: string): string;
+export declare function makeArrayTypeCheckCall(valueAccessor: string, typeName: string, writer: LanguageWriter): LanguageExpression;
+export declare class ETSLanguageWriter extends TSLanguageWriter {
+    private arrayConvertor;
+    constructor(printer: IndentedPrinter, resolver: ReferenceResolver, typeConvertor: IdlNameConvertor, arrayConvertor: IdlNameConvertor);
+    fork(options?: {
+        resolver?: ReferenceResolver;
+    }): LanguageWriter;
+    writeNativeMethodDeclaration(name: string, signature: MethodSignature): void;
+    makeAssign(variableName: string, type: IDLType | undefined, expr: LanguageExpression, isDeclared?: boolean, isConst?: boolean): LanguageStatement;
+    makeLambda(signature: MethodSignature, body?: LanguageStatement[]): LanguageExpression;
+    makeMapForEach(map: string, key: string, value: string, op: () => void): LanguageStatement;
+    makeMapSize(map: string): LanguageExpression;
+    get supportedModifiers(): MethodModifier[];
+    makeUnsafeCast(convertor: ArgConvertor, param: string): string;
+    runtimeType(param: ArgConvertor, valueType: string, value: string): void;
+    makeUnionVariantCast(value: string, type: string, convertor: ArgConvertor, index?: number): LanguageExpression;
+    enumFromOrdinal(value: LanguageExpression, enumEntry: idl.IDLType): LanguageExpression;
+    ordinalFromEnum(value: LanguageExpression, _: idl.IDLType): LanguageExpression;
+    makeDiscriminatorFromFields(convertor: {
+        targetType: (writer: LanguageWriter) => string;
+    }, value: string, accessors: string[], duplicates: Set<string>): LanguageExpression;
+    makeValueFromOption(value: string, destinationConvertor: ArgConvertor): LanguageExpression;
+    makeCallIsResource(value: string): LanguageExpression;
+    makeEnumEntity(enumEntity: IDLEnum, isExport: boolean): LanguageStatement;
+    getObjectAccessor(convertor: ArgConvertor, value: string, args?: ObjectArgs): string;
+    writeMethodCall(receiver: string, method: string, params: string[], nullable?: boolean): void;
+    writeProperty(propName: string, propType: IDLType): void;
+    makeEnumCast(value: string, _unsafe: boolean, convertor: ArgConvertor | undefined): string;
+    makeUnionVariantCondition(convertor: ArgConvertor, valueName: string, valueType: string, type: string, convertorIndex: number, runtimeTypeIndex: number): LanguageExpression;
+    makeCastCustomObject(customName: string, isGenericType: boolean): LanguageExpression;
+    makeHasOwnProperty(value: string, valueTypeName: string, property: string, propertyTypeName: string): LanguageExpression;
+    makeEquals(args: LanguageExpression[]): LanguageExpression;
+    makeDiscriminatorConvertor(convertor: ArgConvertor, value: string, index: number): LanguageExpression;
+    castToInt(value: string, bitness: 8 | 32): string;
+    castToBoolean(value: string): string;
+    instanceOf(convertor: ArgConvertor, value: string, duplicateMembers?: Set<string>): LanguageExpression;
+    typeInstanceOf(type: idl.IDLEntry, value: string, members?: string[]): LanguageExpression;
+    makeTypeCast(value: LanguageExpression, type: idl.IDLType, options?: MakeCastOptions): LanguageExpression;
+    makeCast(value: LanguageExpression, type: idl.IDLType, options?: MakeCastOptions): LanguageExpression;
+}
+export declare function makeEnumTypeCheckerCall(valueAccessor: string, enumName: string, writer: LanguageWriter): LanguageExpression;
+//# sourceMappingURL=ETSLanguageWriter.d.ts.map