@typecad/cuttlefish 0.1.0-alpha.1

package/dist/ir/hal/hal-emitter.d.ts

@@ -0,0 +1,62 @@
+import ts from "typescript";
+import { ExpressionIR, HALOpIR } from "../../api/index.js";
+import { HALInstance } from "./hal-parser.js";
+/** Escape C++ keywords in resolved text, but only when the text looks like a
+ *  variable reference (not a literal like "false", "true", "42", or a string). */
+export declare function maybeEscapeResolvedText(text: string): string;
+/**
+ * Strip a leading `.c_str()` from the literal text that follows a template span
+ * when the resolved value is a C++ string literal (e.g. `"label"`).
+ *
+ * HAL authors write `${param}.c_str()` to convert a `String`/`std::string`
+ * variable to `const char*` for C APIs. That is correct when `param` is a
+ * variable (renders as `myVar` → `myVar.c_str()`). But when `param` is a string
+ * literal it renders as `"label"`, and `"label".c_str()` is invalid C++ — a
+ * string literal has no `.c_str()` member. This drops the conversion in that
+ * case so `"label".c_str()` becomes just `"label"`, while leaving the variable
+ * path untouched.
+ */
+export declare function stripCStrAfterStringLiteral(followingLiteralText: string, resolvedValue: string): string;
+/** Resolve an arbitrary expression to its text form, with this/param substitution. */
+export declare function resolveExpressionText(expr: ts.Expression, instance: HALInstance, paramNames: string[], callArgTexts: string[], paramDefaults?: Map<string, string>): string | null;
+/** Scan an expression AST for callback() calls, extract callback IR from callArgs,
+ *  register them, and patch callArgTexts with placeholder names. */
+export declare function extractAndRegisterCallbacks(expr: ts.Expression, paramNames: string[], callArgs: ExpressionIR[], callArgTexts: string[]): void;
+/** Process a HAL method body, resolving emit()/include()/semantic calls.
+ *  Returns { emitLines, halOps, returnValue, returnClassName } or null if unresolvable.
+ *
+ *  `emitLines` contains legacy raw C++ strings (from `emit()` calls).
+ *  `halOps` contains structured HALOpIR nodes (from semantic function calls like
+ *  `gpioWrite()`, `i2cBegin()`, etc.).
+ *
+ *  During migration both can coexist; consumers should prefer `halOps` when present. */
+export declare function processHALMethodBody(instance: HALInstance, methodName: string, callArgs: ExpressionIR[]): {
+    emitLines: string[];
+    halOps: HALOpIR[];
+    returnValue?: string;
+    returnClassName?: string;
+} | null;
+/** Check if a resolved C++ value string is a simple literal (for stub detection). */
+export declare function isLiteralReturnValue(val: string | undefined): boolean;
+/** Resolve the C++ object name from a HAL instance's constructor field values. */
+export declare function resolveCppObjectName(instance: HALInstance): string | null;
+/** Process a list of statements for emit/include/semantic calls/return. */
+export declare function processStatementList(stmts: readonly ts.Statement[], instance: HALInstance, paramNames: string[], callArgTexts: string[], emitLines: string[], halOps: HALOpIR[], callArgs: ExpressionIR[], paramDefaults: Map<string, string>, returnExpr?: {
+    value: string;
+}): void;
+/** Reset resolver state (called between builds). */
+export declare function resetHALResolver(): void;
+/** Resolve a hal-expr IR node to its C++ text using the active strategy. */
+export declare function setActiveStrategy(strategy: import("../../api/shared/index.js").PlatformStrategy | null): void;
+export declare function resolveHALExprToText(expr: Extract<import("../../api/shared/index.js").ExpressionIR, {
+    kind: "hal-expr";
+}>): string | null;
+export declare function registerFloatVariable(name: string): void;
+/** Build snprintf prelude lines from a string_concat expression.
+ *  Returns { lines, bufferName } or null if the expression can't be formatted. */
+export declare function buildSnprintfFromConcat(expr: Extract<ExpressionIR, {
+    kind: "string_concat";
+}>): {
+    lines: string[];
+    bufferName: string;
+} | null;