@idlizer/core 2.0.15

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

@@ -0,0 +1,578 @@
+/*
+ * 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";
+import { IndentedPrinter } from "../../IndentedPrinter";
+import { CJKeywords } from "../../languageSpecificKeywords";
+import { RuntimeType } from "../common";
+import { AssignStatement, ExpressionStatement, FieldModifier, LambdaExpression, LanguageWriter, MethodModifier, MethodSignature, ReturnStatement, StringExpression } from "../LanguageWriter";
+import { Language } from "../../Language";
+import { isDefined } from "../../util";
+////////////////////////////////////////////////////////////////
+//                        EXPRESSIONS                         //
+////////////////////////////////////////////////////////////////
+class CJLambdaExpression extends LambdaExpression {
+    constructor(writer, signature, resolver, body) {
+        super(writer, signature, resolver, body);
+        this.writer = writer;
+    }
+    get statementHasSemicolon() {
+        return false;
+    }
+    asString() {
+        const params = this.signature.args.map((it, i) => `${this.signature.argName(i)}: ${this.writer.getNodeName(it)}`);
+        return `{${params.join(", ")} => ${this.bodyAsString()} }`;
+    }
+}
+export class CJCheckDefinedExpression {
+    constructor(value) {
+        this.value = value;
+    }
+    asString() {
+        return `${this.value}.isSome()`;
+    }
+}
+export class CJCastExpression {
+    constructor(value, type, unsafe = false) {
+        this.value = value;
+        this.type = type;
+        this.unsafe = unsafe;
+    }
+    asString() {
+        return `match (${this.value.asString()} as ${this.type}) { case Some(x) => x; case None => throw Exception("Cast is not succeeded")}`;
+    }
+}
+export class CJUnionCastExpression {
+    constructor(value, type, unsafe = false) {
+        this.value = value;
+        this.type = type;
+        this.unsafe = unsafe;
+    }
+    asString() {
+        return `${this.type}(${this.value.asString})`;
+    }
+}
+export class CJMatchExpression {
+    constructor(matchValue, matchCases, caseBlocks) {
+        this.matchValue = matchValue;
+        this.matchCases = matchCases;
+        this.caseBlocks = caseBlocks;
+    }
+    asString() {
+        let output = [];
+        output.push(`match (${this.matchValue.asString()}) {`);
+        for (let index in this.matchCases) {
+            output.push(`case ${this.matchCases[index].asString()} => ${this.caseBlocks[index].asString()} `);
+        }
+        output.push(`case _ => throw Exception(\"Unmatched pattern ${this.matchValue.asString()}\")`);
+        output.push(`}`);
+        return output.join('\n');
+    }
+}
+export class CJTernaryExpression {
+    constructor(condition, trueExpression, falseExpression) {
+        this.condition = condition;
+        this.trueExpression = trueExpression;
+        this.falseExpression = falseExpression;
+    }
+    asString() {
+        return `if (${this.condition.asString()}) { ${this.trueExpression.asString()} } else { ${this.falseExpression.asString()} }`;
+    }
+}
+export class CJNewObjectExpression {
+    constructor(objectName, params) {
+        this.objectName = objectName;
+        this.params = params;
+    }
+    asString() {
+        return `${this.objectName}(${this.params.map(it => it.asString()).join(", ")})`;
+    }
+}
+////////////////////////////////////////////////////////////////
+//                         STATEMENTS                         //
+////////////////////////////////////////////////////////////////
+export class CJAssignStatement extends AssignStatement {
+    constructor(variableName, type, expression, isDeclared = true, isConst = true) {
+        super(variableName, type, expression, isDeclared, isConst);
+        this.variableName = variableName;
+        this.type = type;
+        this.expression = expression;
+        this.isDeclared = isDeclared;
+        this.isConst = isConst;
+    }
+    write(writer) {
+        var _a;
+        if (this.isDeclared) {
+            const typeSpec = ((_a = this.options) === null || _a === void 0 ? void 0 : _a.overrideTypeName)
+                ? `: ${this.options.overrideTypeName}`
+                : this.type ? `: ${writer.getNodeName(this.type)}` : "";
+            const constSpec = this.isConst ? "let" : "var";
+            const initValue = this.expression ? `= ${this.expression.asString()}` : "";
+            writer.print(`${constSpec} ${this.variableName}${typeSpec} ${initValue}`);
+        }
+        else {
+            writer.print(`${this.variableName} = ${this.expression.asString()}`);
+        }
+    }
+}
+class CJLoopStatement {
+    constructor(counter, limit, statement) {
+        this.counter = counter;
+        this.limit = limit;
+        this.statement = statement;
+    }
+    write(writer) {
+        writer.print(`for (${this.counter} in 0..${this.limit}) {`);
+        if (this.statement) {
+            writer.pushIndent();
+            this.statement.write(writer);
+            writer.popIndent();
+            writer.print("}");
+        }
+    }
+}
+class CJMapForEachStatement {
+    constructor(map, key, value, op) {
+        this.map = map;
+        this.key = key;
+        this.value = value;
+        this.op = op;
+    }
+    write(writer) {
+        writer.print(`for ((key, value) in ${this.map}) {`);
+        writer.pushIndent();
+        this.op();
+        writer.popIndent();
+        writer.print(`}`);
+    }
+}
+export class CJEnumWithGetter {
+    constructor(enumEntity, isExport) {
+        this.enumEntity = enumEntity;
+        this.isExport = isExport;
+    }
+    write(writer) {
+        const initializers = this.enumEntity.elements.map(it => {
+            return { name: it.name, id: it.initializer };
+        });
+        const isStringEnum = initializers.every(it => typeof it.id == 'string');
+        let memberValue = 0;
+        const members = [];
+        for (const initializer of initializers) {
+            if (typeof initializer.id == 'string') {
+                members.push({ name: initializer.name, stringId: initializer.id, numberId: memberValue });
+            }
+            else if (typeof initializer.id == 'number') {
+                memberValue = initializer.id;
+                members.push({ name: initializer.name, stringId: undefined, numberId: memberValue });
+            }
+            else {
+                members.push({ name: initializer.name, stringId: undefined, numberId: memberValue });
+            }
+            memberValue += 1;
+        }
+        let enumName = this.enumEntity.name;
+        writer.writeClass(enumName, () => {
+            const enumType = idl.createReferenceType(enumName, undefined, this.enumEntity);
+            members.forEach(it => {
+                writer.writeFieldDeclaration(it.name, enumType, [FieldModifier.PUBLIC, FieldModifier.STATIC, FieldModifier.FINAL], false, writer.makeString(`${enumName}(${it.numberId})`));
+            });
+            const value = 'value';
+            const intType = idl.IDLI32Type;
+            writer.writeFieldDeclaration(value, intType, [FieldModifier.PUBLIC, FieldModifier.FINAL], false);
+            const signature = new MethodSignature(idl.IDLVoidType, [intType]);
+            writer.writeConstructorImplementation(enumName, signature, () => {
+                writer.writeStatement(writer.makeAssign(value, undefined, writer.makeString(signature.argName(0)), false));
+            });
+        });
+    }
+}
+export class CJEnumEntityStatement {
+    constructor(enumEntity, isExport) {
+        this.enumEntity = enumEntity;
+        this.isExport = isExport;
+    }
+    write(writer) {
+        writer.print(this.enumEntity.comment);
+        writer.print(`${this.isExport ? "public " : ""}enum ${this.enumEntity.name} {`);
+        writer.pushIndent();
+        this.enumEntity.elements.forEach((member, index) => {
+            writer.print(member.comment);
+            const varticalBar = index < this.enumEntity.elements.length - 1 ? '|' : '';
+            const initValue = member.initializer ? ` = ${member.initializer}` : ``;
+            writer.print(`${member.name}${initValue}${varticalBar}`);
+        });
+        writer.popIndent();
+        writer.print(`}`);
+    }
+}
+class CJThrowErrorStatement {
+    constructor(message) {
+        this.message = message;
+    }
+    write(writer) {
+        writer.print(`throw Exception("${this.message}")`);
+    }
+}
+class CJCheckOptionalStatement {
+    constructor(undefinedValue, optionalExpression, doStatement) {
+        this.undefinedValue = undefinedValue;
+        this.optionalExpression = optionalExpression;
+        this.doStatement = doStatement;
+    }
+    write(writer) {
+        writer.print(`if (let Some(${this.optionalExpression.asString()}) <- ${this.optionalExpression.asString()}) {`);
+        writer.pushIndent();
+        this.doStatement.write(writer);
+        writer.popIndent();
+        writer.print('}');
+    }
+}
+class CJArrayResizeStatement {
+    constructor(array, arrayType, length, deserializer) {
+        this.array = array;
+        this.arrayType = arrayType;
+        this.length = length;
+        this.deserializer = deserializer;
+    }
+    write(writer) {
+        writer.print(`${this.array} = ${this.arrayType}(Int64(${this.length}))`);
+    }
+}
+////////////////////////////////////////////////////////////////
+//                           WRITER                           //
+////////////////////////////////////////////////////////////////
+export class CJLanguageWriter extends LanguageWriter {
+    constructor(printer, resolver, typeConvertor, typeForeignConvertor, language = Language.CJ) {
+        super(printer, resolver, language);
+        this.typeConvertor = typeConvertor;
+        this.typeForeignConvertor = typeForeignConvertor;
+    }
+    fork(options) {
+        var _a;
+        return new CJLanguageWriter(new IndentedPrinter(), (_a = options === null || options === void 0 ? void 0 : options.resolver) !== null && _a !== void 0 ? _a : this.resolver, this.typeConvertor, this.typeForeignConvertor);
+    }
+    getNodeName(type) {
+        return this.typeConvertor.convert(type);
+    }
+    writeClass(name, op, superClass, interfaces, generics) {
+        let extendsClause = superClass ? `${superClass}` : undefined;
+        let implementsClause = interfaces ? `${interfaces.join(' & ')}` : undefined;
+        let inheritancePart = [extendsClause, implementsClause]
+            .filter(isDefined)
+            .join(' & ');
+        inheritancePart = inheritancePart.length != 0 ? ' <: '.concat(inheritancePart) : '';
+        this.printer.print(`public open class ${name}${inheritancePart} {`);
+        this.pushIndent();
+        op(this);
+        this.popIndent();
+        this.printer.print(`}`);
+    }
+    writeEnum(name, members, op) {
+        this.printer.print(`public enum ${name}{`);
+        this.pushIndent();
+        for (const member of members) {
+            this.print('|'.concat(member.name));
+        }
+        op(this);
+        this.popIndent();
+        this.printer.print(`}`);
+    }
+    writeInterface(name, op, superInterfaces) {
+        let extendsClause = superInterfaces ? ` <: ${superInterfaces.join(" & ")}` : '';
+        this.printer.print(`public interface ${name}${extendsClause} {`);
+        this.pushIndent();
+        op(this);
+        this.popIndent();
+        this.printer.print(`}`);
+    }
+    writeFunctionDeclaration(name, signature) {
+        this.printer.print(this.generateFunctionDeclaration(name, signature));
+    }
+    writeFunctionImplementation(name, signature, op) {
+        this.printer.print(`${this.generateFunctionDeclaration(name, signature)} {`);
+        this.printer.pushIndent();
+        op(this);
+        this.printer.popIndent();
+        this.printer.print('}');
+    }
+    generateFunctionDeclaration(name, signature) {
+        const args = signature.args.map((it, index) => `${signature.argName(index)}: ${this.getNodeName(it)}`);
+        return `public func ${name}(${args.join(", ")})`;
+    }
+    writeMethodCall(receiver, method, params, nullable = false) {
+        params = params.map(argName => this.escapeKeyword(argName));
+        if (nullable) {
+            if (receiver == 'this') {
+                this.printer.print('let thisObj = this');
+                super.writeMethodCall('thisObj', method, params, false);
+                return;
+            }
+            this.printer.print(`if (let Some(${receiver}) <- ${receiver}) { ${receiver}.${method}(${params.join(", ")}) }`);
+        }
+        else {
+            super.writeMethodCall(receiver, method, params, nullable);
+        }
+    }
+    writeFieldDeclaration(name, type, modifiers, optional, initExpr) {
+        const init = initExpr != undefined ? ` = ${initExpr.asString()}` : ``;
+        name = this.escapeKeyword(name);
+        let prefix = this.makeFieldModifiersList(modifiers);
+        this.printer.print(`${prefix ? prefix.concat(" ") : ""}var ${name}: ${this.getNodeName(type)}${init}`);
+    }
+    writeMethodDeclaration(name, signature, modifiers) {
+        this.writeDeclaration(name, signature, modifiers);
+    }
+    writeConstructorImplementation(className, signature, op, superCall, modifiers) {
+        this.printer.print(`${modifiers ? modifiers.map((it) => MethodModifier[it].toLowerCase()).join(' ') + ' ' : ''}${className}(${signature.args.map((it, index) => `${signature.argName(index)}: ${this.getNodeName(it)}`).join(", ")}) {`);
+        this.pushIndent();
+        if (superCall) {
+            this.print(`super(${superCall.signature.args.map((_, i) => superCall === null || superCall === void 0 ? void 0 : superCall.signature.argName(i)).join(", ")})`);
+        }
+        op(this);
+        this.popIndent();
+        this.printer.print(`}`);
+    }
+    writeProperty(propName, propType, mutable, getterLambda, setterLambda) {
+        let shortName = propName.concat("_container");
+        if (!getterLambda) {
+            this.print(`private var ${shortName}: ${this.getNodeName(propType)}`);
+        }
+        this.print(`${mutable ? "mut " : ""}prop ${propName}: ${this.getNodeName(propType)} {`);
+        this.pushIndent();
+        this.print(`get() {`);
+        this.pushIndent();
+        if (getterLambda) {
+            getterLambda(this);
+        }
+        else {
+            this.print(`return ${shortName}`);
+        }
+        this.popIndent();
+        this.print(`}`);
+        if (mutable) {
+            this.print(`set(x) { ${shortName} = x }`);
+            this.pushIndent();
+            if (setterLambda)
+                setterLambda(this);
+            this.popIndent();
+        }
+        this.popIndent();
+        this.print(`}`);
+    }
+    writeMethodImplementation(method, op) {
+        this.writeDeclaration(method.name, method.signature, method.modifiers, " {");
+        this.pushIndent();
+        op(this);
+        this.popIndent();
+        this.printer.print(`}`);
+    }
+    writeCJForeign(op) {
+        this.print(`foreign {`);
+        this.pushIndent();
+        op(this);
+        this.popIndent();
+        this.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}func ${name}(${signature.args.map((it, index) => `${signature.argName(index)}: ${this.getNodeName(it)}`).join(", ")}): ${this.getNodeName(signature.returnType)}${postfix !== null && postfix !== void 0 ? postfix : ""}`);
+    }
+    writeNativeFunctionCall(printer, name, signature) {
+        printer.print(`return unsafe { ${name}(${signature.args.map((it, index) => `${signature.argName(index)}`).join(", ")}) }`);
+    }
+    writeNativeMethodDeclaration(name, signature) {
+        let signture = `${signature.args.map((it, index) => `${this.escapeKeyword(signature.argName(index))}: ${this.typeForeignConvertor.convert(it)}`).join(", ")}`;
+        this.print(`func ${name}(${signture}): ${this.typeForeignConvertor.convert(signature.returnType)}`);
+    }
+    makeEnumCast(enumName, _unsafe, _convertor) {
+        return `${enumName}.value`;
+    }
+    makeAssign(variableName, type, expr, isDeclared = true, isConst = true) {
+        return new CJAssignStatement(variableName, type, expr, isDeclared, isConst);
+    }
+    makeClassInit(type, parameters) {
+        throw new Error(`makeClassInit`);
+    }
+    makeArrayInit(type, size) {
+        return this.makeString(`ArrayList<${this.getNodeName(type.elementType[0])}>(${size !== null && size !== void 0 ? size : ''})`);
+    }
+    makeMapInit(type) {
+        throw new Error(`TBD`);
+    }
+    makeArrayLength(array, length) {
+        return this.makeString(`${array}.size`);
+    }
+    makeArrayResize(array, arrayType, length, deserializer) {
+        return new CJArrayResizeStatement(array, arrayType, length, deserializer);
+    }
+    makeArrayAccess(value, indexVar) {
+        return this.makeString(`${value}[Int64(${indexVar})]`);
+    }
+    makeRuntimeTypeCondition(typeVarName, equals, type, varName) {
+        if (varName) {
+            varName = this.escapeKeyword(varName);
+            return this.makeString(`let Some(${varName}) <- ${varName}`);
+        }
+        else {
+            const op = equals ? "==" : "!=";
+            return this.makeNaryOp(op, [this.makeRuntimeType(type), this.makeString(`Int32(${typeVarName})`)]);
+        }
+    }
+    makeLambda(signature, body) {
+        return new CJLambdaExpression(this, signature, this.resolver, body);
+    }
+    makeThrowError(message) {
+        return new CJThrowErrorStatement(message);
+    }
+    makeTernary(condition, trueExpression, falseExpression) {
+        return new CJTernaryExpression(condition, trueExpression, falseExpression);
+    }
+    makeReturn(expr) {
+        return new ReturnStatement(expr);
+    }
+    makeCheckOptional(optional, doStatement) {
+        return new CJCheckOptionalStatement("undefined", optional, doStatement);
+    }
+    makeStatement(expr) {
+        return new ExpressionStatement(expr);
+    }
+    makeLoop(counter, limit, statement) {
+        return new CJLoopStatement(counter, limit, statement);
+    }
+    makeMapForEach(map, key, value, op) {
+        return new CJMapForEachStatement(map, key, value, op);
+    }
+    makeDefinedCheck(value) {
+        return new CJCheckDefinedExpression(value);
+    }
+    makeNewObject(objectName, params = []) {
+        return new CJNewObjectExpression(objectName, params);
+    }
+    writePrintLog(message) {
+        this.print(`println("${message}")`);
+    }
+    makeCast(value, type, options) {
+        var _a;
+        return new CJCastExpression(value, this.getNodeName(type), (_a = options === null || options === void 0 ? void 0 : options.unsafe) !== null && _a !== void 0 ? _a : false);
+    }
+    typeInstanceOf(type, value, members) {
+        if (idl.isInterface(type)) {
+            return this.makeString(`${value} is ${this.getNodeName(type)}`);
+        }
+        throw new Error(`typeInstanceOf fails: not class or interface: ${this.getNodeName(type)}`);
+    }
+    getObjectAccessor(convertor, value, args) {
+        return `${value}`;
+    }
+    makeUndefined() {
+        return this.makeString("Option.None");
+    }
+    makeUnwrapOptional(expression) {
+        return new CJMatchExpression(expression, [this.makeString('Some(serializer)')], [this.makeString('serializer')]);
+    }
+    makeValueFromOption(value, destinationConvertor) {
+        return this.makeString(`${value}`);
+    }
+    makeRuntimeType(rt) {
+        return this.makeString(`RuntimeType.${RuntimeType[rt]}.ordinal`);
+    }
+    makeRuntimeTypeGetterCall(value) {
+        let methodCall = this.makeMethodCall("Ark_Object", "getRuntimeType", [this.makeString(value)]);
+        return this.makeString(methodCall.asString() + '.ordinal');
+    }
+    makeMapInsert(keyAccessor, key, valueAccessor, value) {
+        return this.makeStatement(this.makeMethodCall(keyAccessor, "set", [this.makeString(key), this.makeString(value)]));
+    }
+    makeNull(value) {
+        return new StringExpression(`None<${value}>`);
+    }
+    getTagType() {
+        return idl.createReferenceType("Tags");
+    }
+    getRuntimeType() {
+        return idl.IDLNumberType;
+    }
+    makeTupleAssign(receiver, fields) {
+        return this.makeAssign(receiver, undefined, this.makeString(`[${fields.map(it => `${it}!`).join(",")}]`), false);
+    }
+    get supportedModifiers() {
+        return [MethodModifier.PUBLIC, MethodModifier.PRIVATE, MethodModifier.STATIC];
+    }
+    get supportedFieldModifiers() {
+        return [FieldModifier.PUBLIC, FieldModifier.PRIVATE, FieldModifier.PROTECTED, FieldModifier.READONLY, FieldModifier.STATIC];
+    }
+    makeUnionSelector(value, valueType) {
+        return this.makeAssign(valueType, undefined, this.makeMethodCall(value, "getSelector", []), false);
+    }
+    makeUnionVariantCondition(_convertor, _valueName, valueType, type, convertorIndex) {
+        return this.makeString(`${valueType} == ${convertorIndex}`);
+    }
+    makeUnionVariantCast(value, type, convertor, index) {
+        return this.makeMethodCall(value, `getValue${index}`, []);
+    }
+    makeTupleAccess(value, index) {
+        return this.makeString(`${value}.value${index}`);
+    }
+    enumFromOrdinal(value, enumEntry) {
+        return this.makeString(`${this.getNodeName(enumEntry)}(${value.asString()})`);
+    }
+    ordinalFromEnum(value, _) {
+        return this.makeString(`Int32(${value.asString()}.value)`);
+    }
+    makeEnumEntity(enumEntity, isExport) {
+        return new CJEnumWithGetter(enumEntity, isExport);
+    }
+    makeEquals(args) {
+        return this.makeString(`refEq(${args.map(arg => `${arg.asString()}`).join(`, `)})`);
+    }
+    runtimeType(param, valueType, value) {
+        this.writeStatement(this.makeAssign(valueType, undefined, this.makeRuntimeTypeGetterCall(value), false));
+    }
+    escapeKeyword(word) {
+        return CJKeywords.has(word) ? word + "_" : word;
+    }
+    castToInt(value, bitness) {
+        return `Int${bitness}(${value})`;
+    }
+    castToBoolean(value) {
+        return `if (${value}) { Int32(1) } else { Int32(0) }`;
+    }
+    makeLengthSerializer(serializer, value) {
+        return this.makeBlock([
+            this.makeStatement(this.makeMethodCall(serializer, "writeInt8", [this.makeRuntimeType(RuntimeType.STRING)])),
+            this.makeStatement(this.makeMethodCall(serializer, "writeString", [this.makeString(`${value}.getValue1()`)]))
+        ], false);
+    }
+    makeLengthDeserializer(deserializer) {
+        const valueType = "valueType";
+        return this.makeBlock([
+            this.makeAssign(valueType, undefined, this.makeMethodCall(deserializer, "readInt8", []), true),
+            this.makeMultiBranchCondition([{
+                    expr: this.makeRuntimeTypeCondition(valueType, true, RuntimeType.NUMBER, ''),
+                    stmt: this.makeReturn(this.makeString(`Ark_Length(${deserializer}.readFloat32())`))
+                },
+                {
+                    expr: this.makeRuntimeTypeCondition(valueType, true, RuntimeType.STRING, ''),
+                    stmt: this.makeReturn(this.makeString(`Ark_Length(${deserializer}.readString())`))
+                },
+                {
+                    expr: this.makeRuntimeTypeCondition(valueType, true, RuntimeType.OBJECT, ''),
+                    stmt: this.makeReturn(this.makeString(`Ark_Length(Resource(${deserializer}.readString(), "", 0.0, Option.None, Option.None))`))
+                }], this.makeReturn(this.makeUndefined())),
+        ], false);
+    }
+}
+//# sourceMappingURL=CJLanguageWriter.js.map

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

@@ -0,0 +1,46 @@
+import { Language } from "../../Language";
+import { IndentedPrinter } from "../../IndentedPrinter";
+import * as idl from "../../idl";
+import { ExpressionStatement, LanguageExpression, LanguageStatement, LanguageWriter, Method, PrintHint, MethodModifier, MethodSignature, ReturnStatement } from "../LanguageWriter";
+import { ReferenceResolver } from "../../peer-generation/ReferenceResolver";
+export declare class CLikeReturnStatement extends ReturnStatement {
+    expression: LanguageExpression;
+    constructor(expression: LanguageExpression);
+    write(writer: LanguageWriter): void;
+}
+export declare class CDefinedExpression implements LanguageExpression {
+    private value;
+    constructor(value: string);
+    asString(): string;
+}
+export declare class CLikeLoopStatement implements LanguageStatement {
+    private counter;
+    private limit;
+    private statement;
+    constructor(counter: string, limit: string, statement: LanguageStatement | undefined);
+    write(writer: LanguageWriter): void;
+}
+export declare class CLikeExpressionStatement extends ExpressionStatement {
+    expression: LanguageExpression;
+    constructor(expression: LanguageExpression);
+    write(writer: LanguageWriter): void;
+}
+export declare abstract class CLikeLanguageWriter extends LanguageWriter {
+    protected constructor(printer: IndentedPrinter, resolver: ReferenceResolver, language: Language);
+    writeFunctionDeclaration(name: string, signature: MethodSignature): void;
+    writeFunctionImplementation(name: string, signature: MethodSignature, op: (writer: this) => void): void;
+    makeThrowError(message: string): LanguageStatement;
+    makeEquals(args: LanguageExpression[]): LanguageExpression;
+    writeMethodCall(receiver: string, method: string, params: string[], nullable?: boolean): void;
+    writeMethodDeclaration(name: string, signature: MethodSignature, modifiers?: MethodModifier[]): void;
+    writeEnum(name: string, members: {
+        name: string;
+        stringId: string | undefined;
+        numberId: number;
+    }[], op: (writer: LanguageWriter) => void): void;
+    writeMethodImplementation(method: Method, op: (writer: this) => void): void;
+    private writeDeclaration;
+    protected stringifyMethodReturnType(type: idl.IDLType, _?: PrintHint): string;
+    protected stringifyMethodArgType(type: idl.IDLType, _?: PrintHint): string;
+}
+//# sourceMappingURL=CLikeLanguageWriter.d.ts.map