@idlizer/core 2.0.15

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

@@ -0,0 +1,121 @@
+/*
+ * 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 { PrimitiveTypeList } from "../../peer-generation/PrimitiveType";
+import { ExpressionStatement, LanguageWriter, Method, ReturnStatement } from "../LanguageWriter";
+////////////////////////////////////////////////////////////////
+//                         STATEMENTS                         //
+////////////////////////////////////////////////////////////////
+export class CLikeReturnStatement extends ReturnStatement {
+    constructor(expression) {
+        super(expression);
+        this.expression = expression;
+    }
+    write(writer) {
+        writer.print(this.expression ? `return ${this.expression.asString()};` : "return;");
+    }
+}
+export class CDefinedExpression {
+    constructor(value) {
+        this.value = value;
+    }
+    asString() {
+        return `${this.value} != ${PrimitiveTypeList.UndefinedTag}`;
+    }
+}
+export class CLikeLoopStatement {
+    constructor(counter, limit, statement) {
+        this.counter = counter;
+        this.limit = limit;
+        this.statement = statement;
+    }
+    write(writer) {
+        writer.print(`for (int ${this.counter} = 0; ${this.counter} < ${this.limit}; ${this.counter}++) {`);
+        if (this.statement) {
+            writer.pushIndent();
+            this.statement.write(writer);
+            writer.popIndent();
+            writer.print("}");
+        }
+    }
+}
+export class CLikeExpressionStatement extends ExpressionStatement {
+    constructor(expression) {
+        super(expression);
+        this.expression = expression;
+    }
+    write(writer) {
+        const text = this.expression.asString();
+        if (text.length > 0) {
+            writer.print(`${this.expression.asString()};`);
+        }
+    }
+}
+class CLikeThrowErrorStatement {
+    constructor(message) {
+        this.message = message;
+    }
+    write(writer) {
+        writer.print(`throw new Error("${this.message}");`);
+    }
+}
+////////////////////////////////////////////////////////////////
+//                           WRITER                           //
+////////////////////////////////////////////////////////////////
+export class CLikeLanguageWriter extends LanguageWriter {
+    constructor(printer, resolver, language) {
+        super(printer, resolver, language);
+    }
+    writeFunctionDeclaration(name, signature) {
+        this.writeMethodDeclaration(name, signature);
+    }
+    writeFunctionImplementation(name, signature, op) {
+        this.writeMethodImplementation(new Method(name, signature), op);
+    }
+    makeThrowError(message) {
+        return new CLikeThrowErrorStatement(message);
+    }
+    makeEquals(args) {
+        return this.makeNaryOp("==", args);
+    }
+    writeMethodCall(receiver, method, params, nullable = false) {
+        this.printer.print(`${receiver}.${method}(${params.join(", ")});`);
+    }
+    writeMethodDeclaration(name, signature, modifiers) {
+        this.writeDeclaration(name, signature, modifiers, ";");
+    }
+    writeEnum(name, members, op) {
+        throw new Error("WriteEnum for C-family languages is not implemented");
+    }
+    writeMethodImplementation(method, op) {
+        this.writeDeclaration(method.name, method.signature, method.modifiers);
+        this.printer.print(`{`);
+        this.pushIndent();
+        op(this);
+        this.popIndent();
+        this.printer.print(`}`);
+    }
+    writeDeclaration(name, signature, modifiers, postfix) {
+        let prefix = modifiers === null || modifiers === void 0 ? void 0 : modifiers.filter(it => this.supportedModifiers.includes(it)).map(it => this.mapMethodModifier(it)).join(" ");
+        prefix = prefix ? prefix + " " : "";
+        this.print(`${prefix}${this.stringifyMethodReturnType(signature.returnType, signature.retHint())} ${name}(${signature.args.map((it, index) => `${this.stringifyMethodArgType(it, signature.argHint(index))} ${signature.argName(index)}`).join(", ")})${postfix !== null && postfix !== void 0 ? postfix : ""}`);
+    }
+    stringifyMethodReturnType(type, _) {
+        return this.getNodeName(type);
+    }
+    stringifyMethodArgType(type, _) {
+        return this.getNodeName(type);
+    }
+}
+//# sourceMappingURL=CLikeLanguageWriter.js.map

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

@@ -0,0 +1,116 @@
+import { IDLContainerType, IDLEnum, IDLNode, IDLType } from '../../idl';
+import { ArgConvertor, BaseArgConvertor } from "../ArgConvertors";
+import { PrimitiveTypeList } from "../../peer-generation/PrimitiveType";
+import { AssignStatement, FieldModifier, LanguageExpression, LanguageStatement, LanguageWriter, MakeAssignOptions, MakeCastOptions, MakeRefOptions, Method, PrintHint, MethodModifier, MethodSignature, NamedMethodSignature, ObjectArgs } from "../LanguageWriter";
+import { CLikeLanguageWriter } from "./CLikeLanguageWriter";
+import { IdlNameConvertor } from "../nameConvertor";
+import { RuntimeType } from "../common";
+import { IndentedPrinter } from "../../IndentedPrinter";
+import { ReferenceResolver } from "../../peer-generation/ReferenceResolver";
+export declare class CppCastExpression implements LanguageExpression {
+    convertor: IdlNameConvertor;
+    value: LanguageExpression;
+    type: IDLType;
+    private options?;
+    constructor(convertor: IdlNameConvertor, value: LanguageExpression, type: IDLType, options?: MakeCastOptions | undefined);
+    asString(): string;
+    private mapTypeWithReceiver;
+}
+export declare class CppPointerPropertyAccessExpression implements LanguageExpression {
+    expression: string;
+    name: string;
+    constructor(expression: string, name: string);
+    asString(): string;
+}
+export declare class CppAssignStatement extends AssignStatement {
+    variableName: string;
+    type: IDLType | undefined;
+    expression: LanguageExpression | undefined;
+    isDeclared: boolean;
+    isConst: boolean;
+    protected options?: MakeAssignOptions | undefined;
+    constructor(variableName: string, type: IDLType | undefined, expression: LanguageExpression | undefined, isDeclared?: boolean, isConst?: boolean, options?: MakeAssignOptions | undefined);
+    write(writer: CppLanguageWriter): void;
+}
+export declare class CppLanguageWriter extends CLikeLanguageWriter {
+    private primitivesTypes;
+    protected typeConvertor: IdlNameConvertor;
+    constructor(printer: IndentedPrinter, resolver: ReferenceResolver, typeConvertor: IdlNameConvertor, primitivesTypes: PrimitiveTypeList);
+    getNodeName(type: IDLNode): string;
+    fork(options?: {
+        resolver?: ReferenceResolver;
+    }): LanguageWriter;
+    writeClass(name: string, op: (writer: this) => void, superClass?: string, interfaces?: string[]): void;
+    writeInterface(name: string, op: (writer: this) => void, superInterfaces?: string[]): void;
+    writeMethodCall(receiver: string, method: string, params: string[], nullable?: boolean): void;
+    writeFieldDeclaration(name: string, type: IDLType, modifiers: FieldModifier[] | undefined, optional: boolean, initExpr?: LanguageExpression): void;
+    writeConstructorImplementation(className: string, signature: MethodSignature, op: (writer: this) => void, superCall?: Method, modifiers?: MethodModifier[]): void;
+    writeProperty(propName: string, propType: IDLType, mutable?: boolean): void;
+    /**
+     * Writes multiline comments decorated with stars
+     */
+    writeMultilineCommentBlock(lines: string): void;
+    /**
+     * Writes `#include "path"`
+     * @param path File path to be included
+     */
+    writeInclude(path: string): void;
+    /**
+     * Writes `#include <path>`
+     * @param path File path to be included
+     */
+    writeGlobalInclude(path: string): void;
+    makeRef(type: IDLType, options?: MakeRefOptions): IDLType;
+    makeThis(): LanguageExpression;
+    makeNull(): LanguageExpression;
+    makeValueFromOption(value: string): LanguageExpression;
+    makeThrowError(message: string): LanguageStatement;
+    makeAssign(variableName: string, type: IDLType | undefined, expr: LanguageExpression | undefined, isDeclared?: boolean, isConst?: boolean, options?: MakeAssignOptions): LanguageStatement;
+    makeLambda(signature: MethodSignature, body?: LanguageStatement[]): LanguageExpression;
+    makeReturn(expr: LanguageExpression): LanguageStatement;
+    makeCheckOptional(optional: LanguageExpression, doStatement: LanguageStatement): LanguageStatement;
+    makeStatement(expr: LanguageExpression): LanguageStatement;
+    makeArrayAccess(value: string, indexVar: string): LanguageExpression;
+    makeTupleAccess(value: string, index: number): LanguageExpression;
+    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;
+    makeLoop(counter: string, limit: string, statement?: LanguageStatement): LanguageStatement;
+    makeMapForEach(map: string, key: string, value: string, op: () => void): LanguageStatement;
+    makeArrayInit(type: IDLContainerType): LanguageExpression;
+    makeClassInit(type: IDLType, paramenters: LanguageExpression[]): LanguageExpression;
+    makeMapInit(type: IDLType): LanguageExpression;
+    makeArrayResize(array: string, arrayType: string, length: string, deserializer: string): LanguageStatement;
+    makeMapResize(mapTypeName: string, keyType: IDLType, valueType: IDLType, map: string, size: string, deserializer: string): LanguageStatement;
+    makeCast(expr: LanguageExpression, type: IDLType, options?: MakeCastOptions): LanguageExpression;
+    makePointerPropertyAccessExpression(expression: string, name: string): CppPointerPropertyAccessExpression;
+    writePrintLog(message: string): void;
+    makeDefinedCheck(value: string): LanguageExpression;
+    makeSetUnionSelector(value: string, index: string): LanguageStatement;
+    makeSetOptionTag(value: string, tag: LanguageExpression): LanguageStatement;
+    getObjectAccessor(convertor: BaseArgConvertor, value: string, args?: ObjectArgs): string;
+    makeUndefined(): LanguageExpression;
+    makeVoid(): LanguageExpression;
+    makeRuntimeType(rt: RuntimeType): LanguageExpression;
+    makeMapInsert(keyAccessor: string, key: string, valueAccessor: string, value: string): LanguageStatement;
+    getTagType(): IDLType;
+    getRuntimeType(): IDLType;
+    makeTupleAssign(receiver: string, tupleFields: string[]): LanguageStatement;
+    get supportedModifiers(): MethodModifier[];
+    get supportedFieldModifiers(): FieldModifier[];
+    enumFromOrdinal(value: LanguageExpression, type: IDLType): LanguageExpression;
+    ordinalFromEnum(value: LanguageExpression, _: IDLType): LanguageExpression;
+    makeUnsafeCast(convertor: ArgConvertor, param: string): string;
+    makeUnsafeCast_(value: LanguageExpression, type: IDLType, typeOptions?: PrintHint): string;
+    makeEnumCast(value: string, _unsafe: boolean, convertor: ArgConvertor | undefined): string;
+    escapeKeyword(name: string): string;
+    makeEnumEntity(enumEntity: IDLEnum, isExport: boolean): LanguageStatement;
+    private decayTypeName;
+    stringifyMethodReturnType(type: IDLType, hint?: PrintHint): string;
+    stringifyMethodArgType(type: IDLType, hint?: PrintHint): string;
+    stringifyTypeWithReceiver(type: IDLType, receiver?: string): string;
+    makeSerializerConstructorSignature(): NamedMethodSignature | undefined;
+    makeLengthSerializer(serializer: string, value: string): LanguageStatement | undefined;
+    makeLengthDeserializer(deserializer: string): LanguageStatement | undefined;
+}
+//# sourceMappingURL=CppLanguageWriter.d.ts.map