semantifold 0.2.0 → 0.3.0

package/build/src/backends/c.js

@@ -0,0 +1,308 @@
+// @ts-check
+import { unsupportedCapability } from "../diagnostic.js";
+import { finalizeMapping, toSourceMapV3 } from "../mapping.js";
+import { statementSignature, planNativeModule } from "./ordered-expressions.js";
+import { cRuntimeHeader } from "./c-runtime.js";
+import { maximumCSourceLength, validateCMemory } from "./c-validation.js";
+import { validateNativeGraph } from "./native-validation.js";
+import { emitScalarType } from "./scalars.js";
+import { validateBackendModule } from "./shared.js";
+import { SourceWriter } from "./writer.js";
+/** @typedef {import("../semantic/types.js").SemanticModule} SemanticModule */
+/** @typedef {import("../semantic/types.js").SemanticNode} SemanticNode */
+/** @typedef {import("../semantic/types.js").Statement} Statement */
+/** @typedef {import("../semantic/types.js").Block} Block */
+/** @typedef {import("./ordered-expressions.js").PlannedValue} PlannedValue */
+/** @typedef {import("./ordered-expressions.js").PlannedStep} PlannedStep */
+/** @typedef {{id: string, steps: PlannedStep[], value: PlannedValue}} StatementPlan */
+const binaryTokens = new Map([
+    ["IntegerAdd", "semantifold_integer_add"], ["IntegerSubtract", "semantifold_integer_subtract"],
+    ["IntegerMultiply", "semantifold_integer_multiply"], ["StringConcat", "semantifold_string_concat"],
+    ["StringEqual", "semantifold_string_equal"], ["StringNotEqual", "semantifold_string_not_equal"],
+    ["IntegerEqual", "=="], ["IntegerNotEqual", "!="], ["BooleanEqual", "=="], ["BooleanNotEqual", "!="],
+    ["IntegerLessThan", "<"], ["IntegerLessThanOrEqual", "<="],
+    ["IntegerGreaterThan", ">"], ["IntegerGreaterThanOrEqual", ">="]
+]);
+/**
+ * Produces a fully validated, deterministic C17 translation unit and owned support header.
+ * @param {{filename?: string, mapDirective?: unknown, module: SemanticModule, sourceMapFilename?: unknown, sources?: {filename: string, content: string, language?: import("../semantic/types.js").SemanticLanguage}[]}} input - Backend request.
+ * @returns {{artifacts: import("../semantic/types.js").GeneratedSetArtifact[], target: string}} Complete candidate.
+ */
+export function generateCProgram({ filename, mapDirective, module, sourceMapFilename, sources }) {
+    validateNativeGraph(module);
+    validateBackendModule(module, "c");
+    validateCMemory(module);
+    if (filename !== undefined && filename != "program.c")
+        unsupportedCapability("c", "artifact filename other than program.c", module.location);
+    if (mapDirective !== undefined || sourceMapFilename !== undefined)
+        unsupportedCapability("c", "source-map filename or directive option", module.location);
+    const plans = planNativeModule(module);
+    new CEmitter(undefined, plans, module.location).program(module);
+    const writer = new SourceWriter({ filename: "program.c", language: "c", module, sources });
+    const emitter = new CEmitter(writer, plans, module.location);
+    emitter.program(module);
+    const mapping = finalizeMapping(writer.finish());
+    const root = mapping.nodes.find(({ path }) => path == "");
+    if (!root)
+        throw new Error("Validated C module omitted its root provenance.");
+    const relatedOrigins = root.origin.kind == "source"
+        ? [{ location: root.origin.location, nodeId: root.id, role: "module", sourceId: root.origin.sourceId }]
+        : (root.origin.kind == "derived" ? root.origin.origins : root.origin.relatedOrigins).map((origin) => ({ ...origin, nodeId: origin.nodeId ?? root.id, role: origin.role ?? "module" }));
+    return { target: "c", artifacts: [{
+                content: mapping.generated.content, contentKind: "text", mediaType: "text/x-c", ownership: "generated", path: "program.c",
+                provenance: { kind: "text", mapping, sourceMap: toSourceMapV3(mapping) }, role: "entry"
+            }, {
+                content: cRuntimeHeader, contentKind: "text", mediaType: "text/x-c", ownership: "generated", path: "semantifold_runtime.h",
+                provenance: { kind: "synthetic", reason: "Canonical C17 scalar helpers and module-lifetime immutable UTF-8 arena.", relatedOrigins }, role: "support"
+            }] };
+}
+/** Writes only target syntax from validated semantic occurrences and private plans. */
+class CEmitter {
+    /**
+     * Binds the writer and complete plan.
+     * @param {SourceWriter | undefined} writer - Provenance writer; omitted for exact size preflight.
+     * @param {Map<string, StatementPlan>} plans - Validated occurrence plans.
+     * @param {import("../semantic/types.js").SourceLocation} location - Root diagnostic location.
+     */
+    constructor(writer, plans, location) {
+        this.writer = writer;
+        this.plans = plans;
+        this.location = location;
+        this.length = 0;
+    }
+    /**
+     * Writes generated scaffold with a related semantic origin.
+     * @param {string} text - C syntax.
+     * @param {SemanticNode} node - Related node.
+     * @param {string} path - Occurrence path.
+     * @returns {void}
+     */
+    synthetic(text, node, path) {
+        this.checkSize(text, node);
+        this.writer?.synthetic(text, "C17 ordered-expression and lifetime scaffold", [node], [path]);
+    }
+    /**
+     * Writes an original semantic token or anchor.
+     * @param {string} text - Target token.
+     * @param {SemanticNode} node - Original node.
+     * @param {string} path - Occurrence path.
+     * @param {string} [role] - Parser token role.
+     * @returns {void}
+     */
+    mapped(text, node, path, role) {
+        this.checkSize(text, node);
+        this.writer?.mapped(text, { mappingKind: role ? "exact" : "anchor", node, path, ...(role ? { role } : {}) });
+    }
+    /**
+     * Bounds private emission before any artifact can escape the parser's proven input profile.
+     * @param {string} text - Next exact output chunk.
+     * @param {SemanticNode} node - Related semantic occurrence.
+     * @returns {void}
+     */
+    checkSize(text, node) {
+        this.length += text.length;
+        if (this.length > maximumCSourceLength)
+            unsupportedCapability("c", "generated program exceeds the frozen C parser's 32767 UTF-16 input limit", "location" in node ? node.location : this.location);
+    }
+    /**
+     * Emits canonical prototypes, definitions, and the cleanup-owning main.
+     * @param {SemanticModule} module - Semantic module.
+     * @returns {void}
+     */
+    program(module) {
+        this.synthetic('/* semantifold:program:c:v1 */\n#include "semantifold_runtime.h"\n\n', module, "");
+        module.functions.forEach((declaration, index) => {
+            const parameters = declaration.parameters.map((parameter) => `${emitScalarType("c", parameter.type)} ${parameter.name}`).join(", ");
+            this.synthetic(`static ${emitScalarType("c", declaration.returnType)} ${declaration.name}(${parameters});\n`, declaration, `/functions/${index}`);
+        });
+        module.functions.forEach((declaration, index) => {
+            const path = `/functions/${index}`;
+            this.synthetic("\nstatic ", declaration, path);
+            this.mapped(emitScalarType("c", declaration.returnType), declaration.returnType, `${path}/returnType`, "type");
+            this.synthetic(" ", declaration, path);
+            this.mapped(declaration.name, declaration, path, "name");
+            this.synthetic("(", declaration, path);
+            declaration.parameters.forEach((parameter, parameterIndex) => {
+                const parameterPath = `${path}/parameters/${parameterIndex}`;
+                if (parameterIndex)
+                    this.synthetic(", ", parameter, parameterPath);
+                this.mapped(emitScalarType("c", parameter.type), parameter.type, `${parameterPath}/type`, "type");
+                this.synthetic(" ", parameter, parameterPath);
+                this.mapped(parameter.name, parameter, parameterPath, "name");
+            });
+            this.synthetic(") {\n", declaration, path);
+            declaration.parameters.forEach((parameter, parameterIndex) => this.synthetic(`    (void)${parameter.name};\n`, parameter, `${path}/parameters/${parameterIndex}`));
+            this.block(declaration.body, `${path}/body`, "    ");
+            this.synthetic("}\n", declaration, path);
+        });
+        this.synthetic("\nint main(void) {\n", module.entryPoint, "/entryPoint");
+        module.functions.forEach((declaration, index) => this.synthetic(`    (void)${declaration.name};\n`, declaration, `/functions/${index}`));
+        this.block(module.entryPoint.body, "/entryPoint/body", "    ");
+        this.synthetic("    semantifold_cleanup();\n    return 0;\n}\n", module.entryPoint, "/entryPoint");
+    }
+    /**
+     * Emits statements in semantic source order.
+     * @param {Block} block - Semantic block.
+     * @param {string} path - Occurrence path.
+     * @param {string} indent - Current indentation.
+     * @returns {void}
+     */
+    block(block, path, indent) {
+        block.statements.forEach((statement, index) => this.statement(statement, `${path}/statements/${index}`, indent));
+    }
+    /**
+     * Emits one paired region with a pure final consumer.
+     * @param {Statement} statement - Original statement.
+     * @param {string} path - Occurrence path.
+     * @param {string} indent - Current indentation.
+     * @returns {void}
+     */
+    statement(statement, path, indent) {
+        const plan = this.plans.get(path);
+        if (!plan)
+            throw new Error("Missing validated C statement plan.");
+        const marker = `semantifold:ordered-expression:c:v1`;
+        const signature = statementSignature(statement);
+        this.synthetic(`${indent}/* ${marker} begin ${plan.id} ${signature} */\n`, statement, path);
+        this.steps(plan.steps, indent);
+        this.synthetic(indent, statement, path);
+        if (statement.kind == "LocalDeclaration") {
+            if (!statement.mutable)
+                this.synthetic("const ", statement, path);
+            this.mapped(emitScalarType("c", statement.type), statement.type, `${path}/type`, "type");
+            this.synthetic(" ", statement, path);
+            this.mapped(statement.name, statement, path, "name");
+            this.synthetic(" ", statement, path);
+            this.mapped("=", statement, path, "operator");
+            this.synthetic(" ", statement, path);
+        }
+        else if (statement.kind == "AssignmentStatement") {
+            this.mapped(statement.target.name, statement.target, `${path}/target`, "name");
+            this.synthetic(" ", statement, path);
+            this.mapped("=", statement, path, "operator");
+            this.synthetic(" ", statement, path);
+        }
+        else if (statement.kind == "ReturnStatement")
+            this.mapped("return ", statement, path);
+        else if (statement.kind == "PrintStatement")
+            this.mapped(`semantifold_print_${plan.value.type}(`, statement, path);
+        else
+            this.mapped("if (", statement, path);
+        this.value(plan.value);
+        if (statement.kind == "IfStatement") {
+            this.synthetic(") {\n", statement, path);
+            this.block(statement.consequent, `${path}/consequent`, `${indent}    `);
+            this.synthetic(`${indent}}`, statement, path);
+            if (statement.alternate) {
+                this.mapped(" else ", statement, path);
+                this.synthetic("{\n", statement, path);
+                this.block(statement.alternate, `${path}/alternate`, `${indent}    `);
+                this.synthetic(`${indent}}`, statement, path);
+            }
+            this.synthetic("\n", statement, path);
+        }
+        else {
+            this.synthetic(`${statement.kind == "PrintStatement" ? ")" : ""};\n`, statement, path);
+            if (statement.kind == "LocalDeclaration")
+                this.synthetic(`${indent}(void)${statement.name};\n`, statement, path);
+        }
+        this.synthetic(`${indent}/* ${marker} end ${plan.id} ${signature} */\n`, statement, path);
+    }
+    /**
+     * Emits each eager step or conditional RHS at its planned location.
+     * @param {PlannedStep[]} steps - Ordered private steps.
+     * @param {string} indent - Current indentation.
+     * @returns {void}
+     */
+    steps(steps, indent) {
+        for (const step of steps) {
+            const { result, operands, rightSteps } = step;
+            const { expression, path, name } = result;
+            const type = emitScalarType("c", { kind: "TypeReference", name: result.type });
+            this.synthetic(`${indent}${type} ${name} = `, expression, path);
+            if (rightSteps) {
+                this.value(operands[0]);
+                this.synthetic(`;\n${indent}if (`, expression, path);
+                if (expression.kind != "BinaryExpression")
+                    throw new Error("Invalid conditional C plan.");
+                this.synthetic(`${expression.operation == "BooleanOr" ? "!" : ""}${name}) {\n`, expression, path);
+                this.steps(rightSteps, `${indent}    `);
+                this.synthetic(`${indent}    ${name} = (${name} `, expression, path);
+                this.mapped(expression.operation == "BooleanOr" ? "||" : "&&", expression, path, "operator");
+                this.synthetic(" ", expression, path);
+                this.value(operands[1]);
+                this.synthetic(`);\n${indent}}\n`, expression, path);
+            }
+            else {
+                this.operation(step);
+                this.synthetic(";\n", expression, path);
+            }
+        }
+    }
+    /**
+     * Emits one nontrivial operation with pure operands.
+     * @param {PlannedStep} step - Eager step.
+     * @returns {void}
+     */
+    operation({ result: { expression, path }, operands }) {
+        if (expression.kind == "CallExpression") {
+            this.mapped(expression.callee, expression, path, "callee");
+            this.synthetic("(", expression, path);
+            operands.forEach((operand, index) => {
+                if (index)
+                    this.synthetic(", ", expression, path);
+                this.value(operand);
+            });
+            this.synthetic(")", expression, path);
+        }
+        else if (expression.kind == "UnaryExpression") {
+            this.mapped(expression.operation == "IntegerNegate" ? "semantifold_integer_negate" : "!", expression, path, "operator");
+            this.synthetic("(", expression, path);
+            this.value(operands[0]);
+            this.synthetic(")", expression, path);
+        }
+        else if (expression.kind == "BinaryExpression") {
+            const token = binaryTokens.get(expression.operation);
+            if (!token)
+                throw new Error("Unsupported operation passed C planning.");
+            const helper = token.startsWith("semantifold_");
+            if (helper)
+                this.mapped(token, expression, path, "operator");
+            this.synthetic("(", expression, path);
+            this.value(operands[0]);
+            if (helper)
+                this.synthetic(", ", expression, path);
+            else {
+                this.synthetic(" ", expression, path);
+                this.mapped(token, expression, path, "operator");
+                this.synthetic(" ", expression, path);
+            }
+            this.value(operands[1]);
+            this.synthetic(")", expression, path);
+        }
+        else
+            throw new Error("Pure expression was scheduled as a C operation.");
+    }
+    /**
+     * Emits a pure operand with original token provenance or a synthetic temporary use.
+     * @param {PlannedValue} value - Planned pure operand.
+     * @returns {void}
+     */
+    value({ expression, path, name }) {
+        if (name)
+            return this.synthetic(name, expression, path);
+        if (expression.kind == "IdentifierExpression")
+            return this.mapped(expression.name, expression, path, "name");
+        if (expression.kind == "BooleanLiteral")
+            return this.mapped(String(expression.value), expression, path, "literal");
+        if (expression.kind == "IntegerLiteral")
+            return this.mapped(`INT64_C(${expression.value})`, expression, path, "literal");
+        if (expression.kind == "StringLiteral") {
+            const bytes = new TextEncoder().encode(expression.value);
+            const literal = Array.from(bytes, (byte) => `\\${byte.toString(8).padStart(3, "0")}`).join("");
+            return this.mapped(`SEMANTIFOLD_STRING("${literal}")`, expression, path, "literal");
+        }
+        throw new Error("Unsequenced expression passed C planning.");
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"c.js","sourceRoot":"","sources":["../../../src/backends/c.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {unsupportedCapability} from \"../diagnostic.js\"\nimport {finalizeMapping, toSourceMapV3} from \"../mapping.js\"\nimport {statementSignature, planNativeModule} from \"./ordered-expressions.js\"\nimport {cRuntimeHeader} from \"./c-runtime.js\"\nimport {maximumCSourceLength, validateCMemory} from \"./c-validation.js\"\nimport {validateNativeGraph} from \"./native-validation.js\"\nimport {emitScalarType} from \"./scalars.js\"\nimport {validateBackendModule} from \"./shared.js\"\nimport {SourceWriter} from \"./writer.js\"\n\n/** @typedef {import(\"../semantic/types.js\").SemanticModule} SemanticModule */\n/** @typedef {import(\"../semantic/types.js\").SemanticNode} SemanticNode */\n/** @typedef {import(\"../semantic/types.js\").Statement} Statement */\n/** @typedef {import(\"../semantic/types.js\").Block} Block */\n/** @typedef {import(\"./ordered-expressions.js\").PlannedValue} PlannedValue */\n/** @typedef {import(\"./ordered-expressions.js\").PlannedStep} PlannedStep */\n/** @typedef {{id: string, steps: PlannedStep[], value: PlannedValue}} StatementPlan */\n\nconst binaryTokens = new Map([\n  [\"IntegerAdd\", \"semantifold_integer_add\"], [\"IntegerSubtract\", \"semantifold_integer_subtract\"],\n  [\"IntegerMultiply\", \"semantifold_integer_multiply\"], [\"StringConcat\", \"semantifold_string_concat\"],\n  [\"StringEqual\", \"semantifold_string_equal\"], [\"StringNotEqual\", \"semantifold_string_not_equal\"],\n  [\"IntegerEqual\", \"==\"], [\"IntegerNotEqual\", \"!=\"], [\"BooleanEqual\", \"==\"], [\"BooleanNotEqual\", \"!=\"],\n  [\"IntegerLessThan\", \"<\"], [\"IntegerLessThanOrEqual\", \"<=\"],\n  [\"IntegerGreaterThan\", \">\"], [\"IntegerGreaterThanOrEqual\", \">=\"]\n])\n\n/**\n * Produces a fully validated, deterministic C17 translation unit and owned support header.\n * @param {{filename?: string, mapDirective?: unknown, module: SemanticModule, sourceMapFilename?: unknown, sources?: {filename: string, content: string, language?: import(\"../semantic/types.js\").SemanticLanguage}[]}} input - Backend request.\n * @returns {{artifacts: import(\"../semantic/types.js\").GeneratedSetArtifact[], target: string}} Complete candidate.\n */\nexport function generateCProgram({filename, mapDirective, module, sourceMapFilename, sources}) {\n  validateNativeGraph(module)\n  validateBackendModule(module, \"c\")\n  validateCMemory(module)\n  if (filename !== undefined && filename != \"program.c\") unsupportedCapability(\"c\", \"artifact filename other than program.c\", module.location)\n  if (mapDirective !== undefined || sourceMapFilename !== undefined) unsupportedCapability(\"c\", \"source-map filename or directive option\", module.location)\n  const plans = planNativeModule(module)\n\n  new CEmitter(undefined, plans, module.location).program(module)\n  const writer = new SourceWriter({filename: \"program.c\", language: \"c\", module, sources})\n  const emitter = new CEmitter(writer, plans, module.location)\n\n  emitter.program(module)\n  const mapping = finalizeMapping(writer.finish())\n  const root = mapping.nodes.find(({path}) => path == \"\")\n\n  if (!root) throw new Error(\"Validated C module omitted its root provenance.\")\n  const relatedOrigins = root.origin.kind == \"source\"\n    ? [{location: root.origin.location, nodeId: root.id, role: \"module\", sourceId: root.origin.sourceId}]\n    : (root.origin.kind == \"derived\" ? root.origin.origins : root.origin.relatedOrigins).map((origin) =>\n      ({...origin, nodeId: origin.nodeId ?? root.id, role: origin.role ?? \"module\"}))\n\n  return {target: \"c\", artifacts: [{\n    content: mapping.generated.content, contentKind: \"text\", mediaType: \"text/x-c\", ownership: \"generated\", path: \"program.c\",\n    provenance: {kind: \"text\", mapping, sourceMap: toSourceMapV3(mapping)}, role: \"entry\"\n  }, {\n    content: cRuntimeHeader, contentKind: \"text\", mediaType: \"text/x-c\", ownership: \"generated\", path: \"semantifold_runtime.h\",\n    provenance: {kind: \"synthetic\", reason: \"Canonical C17 scalar helpers and module-lifetime immutable UTF-8 arena.\", relatedOrigins}, role: \"support\"\n  }]}\n}\n\n/** Writes only target syntax from validated semantic occurrences and private plans. */\nclass CEmitter {\n  /**\n   * Binds the writer and complete plan.\n   * @param {SourceWriter | undefined} writer - Provenance writer; omitted for exact size preflight.\n   * @param {Map<string, StatementPlan>} plans - Validated occurrence plans.\n   * @param {import(\"../semantic/types.js\").SourceLocation} location - Root diagnostic location.\n   */\n  constructor(writer, plans, location) {\n    this.writer = writer\n    this.plans = plans\n    this.location = location\n    this.length = 0\n  }\n\n  /**\n   * Writes generated scaffold with a related semantic origin.\n   * @param {string} text - C syntax.\n   * @param {SemanticNode} node - Related node.\n   * @param {string} path - Occurrence path.\n   * @returns {void}\n   */\n  synthetic(text, node, path) {\n    this.checkSize(text, node)\n    this.writer?.synthetic(text, \"C17 ordered-expression and lifetime scaffold\", [node], [path])\n  }\n\n  /**\n   * Writes an original semantic token or anchor.\n   * @param {string} text - Target token.\n   * @param {SemanticNode} node - Original node.\n   * @param {string} path - Occurrence path.\n   * @param {string} [role] - Parser token role.\n   * @returns {void}\n   */\n  mapped(text, node, path, role) {\n    this.checkSize(text, node)\n    this.writer?.mapped(text, {mappingKind: role ? \"exact\" : \"anchor\", node, path, ...(role ? {role} : {})})\n  }\n\n  /**\n   * Bounds private emission before any artifact can escape the parser's proven input profile.\n   * @param {string} text - Next exact output chunk.\n   * @param {SemanticNode} node - Related semantic occurrence.\n   * @returns {void}\n   */\n  checkSize(text, node) {\n    this.length += text.length\n    if (this.length > maximumCSourceLength) unsupportedCapability(\"c\", \"generated program exceeds the frozen C parser's 32767 UTF-16 input limit\",\n      \"location\" in node ? node.location : this.location)\n  }\n\n  /**\n   * Emits canonical prototypes, definitions, and the cleanup-owning main.\n   * @param {SemanticModule} module - Semantic module.\n   * @returns {void}\n   */\n  program(module) {\n    this.synthetic('/* semantifold:program:c:v1 */\\n#include \"semantifold_runtime.h\"\\n\\n', module, \"\")\n    module.functions.forEach((declaration, index) => {\n      const parameters = declaration.parameters.map((parameter) => `${emitScalarType(\"c\", parameter.type)} ${parameter.name}`).join(\", \")\n\n      this.synthetic(`static ${emitScalarType(\"c\", declaration.returnType)} ${declaration.name}(${parameters});\\n`, declaration, `/functions/${index}`)\n    })\n    module.functions.forEach((declaration, index) => {\n      const path = `/functions/${index}`\n\n      this.synthetic(\"\\nstatic \", declaration, path)\n      this.mapped(emitScalarType(\"c\", declaration.returnType), declaration.returnType, `${path}/returnType`, \"type\")\n      this.synthetic(\" \", declaration, path)\n      this.mapped(declaration.name, declaration, path, \"name\")\n      this.synthetic(\"(\", declaration, path)\n      declaration.parameters.forEach((parameter, parameterIndex) => {\n        const parameterPath = `${path}/parameters/${parameterIndex}`\n\n        if (parameterIndex) this.synthetic(\", \", parameter, parameterPath)\n        this.mapped(emitScalarType(\"c\", parameter.type), parameter.type, `${parameterPath}/type`, \"type\")\n        this.synthetic(\" \", parameter, parameterPath)\n        this.mapped(parameter.name, parameter, parameterPath, \"name\")\n      })\n      this.synthetic(\") {\\n\", declaration, path)\n      declaration.parameters.forEach((parameter, parameterIndex) => this.synthetic(`    (void)${parameter.name};\\n`, parameter, `${path}/parameters/${parameterIndex}`))\n      this.block(declaration.body, `${path}/body`, \"    \")\n      this.synthetic(\"}\\n\", declaration, path)\n    })\n    this.synthetic(\"\\nint main(void) {\\n\", module.entryPoint, \"/entryPoint\")\n    module.functions.forEach((declaration, index) => this.synthetic(`    (void)${declaration.name};\\n`, declaration, `/functions/${index}`))\n    this.block(module.entryPoint.body, \"/entryPoint/body\", \"    \")\n    this.synthetic(\"    semantifold_cleanup();\\n    return 0;\\n}\\n\", module.entryPoint, \"/entryPoint\")\n  }\n\n  /**\n   * Emits statements in semantic source order.\n   * @param {Block} block - Semantic block.\n   * @param {string} path - Occurrence path.\n   * @param {string} indent - Current indentation.\n   * @returns {void}\n   */\n  block(block, path, indent) {\n    block.statements.forEach((statement, index) => this.statement(statement, `${path}/statements/${index}`, indent))\n  }\n\n  /**\n   * Emits one paired region with a pure final consumer.\n   * @param {Statement} statement - Original statement.\n   * @param {string} path - Occurrence path.\n   * @param {string} indent - Current indentation.\n   * @returns {void}\n   */\n  statement(statement, path, indent) {\n    const plan = this.plans.get(path)\n\n    if (!plan) throw new Error(\"Missing validated C statement plan.\")\n    const marker = `semantifold:ordered-expression:c:v1`\n    const signature = statementSignature(statement)\n\n    this.synthetic(`${indent}/* ${marker} begin ${plan.id} ${signature} */\\n`, statement, path)\n    this.steps(plan.steps, indent)\n    this.synthetic(indent, statement, path)\n    if (statement.kind == \"LocalDeclaration\") {\n      if (!statement.mutable) this.synthetic(\"const \", statement, path)\n      this.mapped(emitScalarType(\"c\", statement.type), statement.type, `${path}/type`, \"type\")\n      this.synthetic(\" \", statement, path)\n      this.mapped(statement.name, statement, path, \"name\")\n      this.synthetic(\" \", statement, path)\n      this.mapped(\"=\", statement, path, \"operator\")\n      this.synthetic(\" \", statement, path)\n    } else if (statement.kind == \"AssignmentStatement\") {\n      this.mapped(statement.target.name, statement.target, `${path}/target`, \"name\")\n      this.synthetic(\" \", statement, path)\n      this.mapped(\"=\", statement, path, \"operator\")\n      this.synthetic(\" \", statement, path)\n    } else if (statement.kind == \"ReturnStatement\") this.mapped(\"return \", statement, path)\n    else if (statement.kind == \"PrintStatement\") this.mapped(`semantifold_print_${plan.value.type}(`, statement, path)\n    else this.mapped(\"if (\", statement, path)\n    this.value(plan.value)\n    if (statement.kind == \"IfStatement\") {\n      this.synthetic(\") {\\n\", statement, path)\n      this.block(statement.consequent, `${path}/consequent`, `${indent}    `)\n      this.synthetic(`${indent}}`, statement, path)\n      if (statement.alternate) {\n        this.mapped(\" else \", statement, path)\n        this.synthetic(\"{\\n\", statement, path)\n        this.block(statement.alternate, `${path}/alternate`, `${indent}    `)\n        this.synthetic(`${indent}}`, statement, path)\n      }\n      this.synthetic(\"\\n\", statement, path)\n    } else {\n      this.synthetic(`${statement.kind == \"PrintStatement\" ? \")\" : \"\"};\\n`, statement, path)\n      if (statement.kind == \"LocalDeclaration\") this.synthetic(`${indent}(void)${statement.name};\\n`, statement, path)\n    }\n    this.synthetic(`${indent}/* ${marker} end ${plan.id} ${signature} */\\n`, statement, path)\n  }\n\n  /**\n   * Emits each eager step or conditional RHS at its planned location.\n   * @param {PlannedStep[]} steps - Ordered private steps.\n   * @param {string} indent - Current indentation.\n   * @returns {void}\n   */\n  steps(steps, indent) {\n    for (const step of steps) {\n      const {result, operands, rightSteps} = step\n      const {expression, path, name} = result\n      const type = emitScalarType(\"c\", {kind: \"TypeReference\", name: result.type})\n\n      this.synthetic(`${indent}${type} ${name} = `, expression, path)\n      if (rightSteps) {\n        this.value(operands[0])\n        this.synthetic(`;\\n${indent}if (`, expression, path)\n        if (expression.kind != \"BinaryExpression\") throw new Error(\"Invalid conditional C plan.\")\n        this.synthetic(`${expression.operation == \"BooleanOr\" ? \"!\" : \"\"}${name}) {\\n`, expression, path)\n        this.steps(rightSteps, `${indent}    `)\n        this.synthetic(`${indent}    ${name} = (${name} `, expression, path)\n        this.mapped(expression.operation == \"BooleanOr\" ? \"||\" : \"&&\", expression, path, \"operator\")\n        this.synthetic(\" \", expression, path)\n        this.value(operands[1])\n        this.synthetic(`);\\n${indent}}\\n`, expression, path)\n      } else {\n        this.operation(step)\n        this.synthetic(\";\\n\", expression, path)\n      }\n    }\n  }\n\n  /**\n   * Emits one nontrivial operation with pure operands.\n   * @param {PlannedStep} step - Eager step.\n   * @returns {void}\n   */\n  operation({result: {expression, path}, operands}) {\n    if (expression.kind == \"CallExpression\") {\n      this.mapped(expression.callee, expression, path, \"callee\")\n      this.synthetic(\"(\", expression, path)\n      operands.forEach((operand, index) => {\n        if (index) this.synthetic(\", \", expression, path)\n        this.value(operand)\n      })\n      this.synthetic(\")\", expression, path)\n    } else if (expression.kind == \"UnaryExpression\") {\n      this.mapped(expression.operation == \"IntegerNegate\" ? \"semantifold_integer_negate\" : \"!\", expression, path, \"operator\")\n      this.synthetic(\"(\", expression, path)\n      this.value(operands[0])\n      this.synthetic(\")\", expression, path)\n    } else if (expression.kind == \"BinaryExpression\") {\n      const token = binaryTokens.get(expression.operation)\n\n      if (!token) throw new Error(\"Unsupported operation passed C planning.\")\n      const helper = token.startsWith(\"semantifold_\")\n\n      if (helper) this.mapped(token, expression, path, \"operator\")\n      this.synthetic(\"(\", expression, path)\n      this.value(operands[0])\n      if (helper) this.synthetic(\", \", expression, path)\n      else {\n        this.synthetic(\" \", expression, path)\n        this.mapped(token, expression, path, \"operator\")\n        this.synthetic(\" \", expression, path)\n      }\n      this.value(operands[1])\n      this.synthetic(\")\", expression, path)\n    } else throw new Error(\"Pure expression was scheduled as a C operation.\")\n  }\n\n  /**\n   * Emits a pure operand with original token provenance or a synthetic temporary use.\n   * @param {PlannedValue} value - Planned pure operand.\n   * @returns {void}\n   */\n  value({expression, path, name}) {\n    if (name) return this.synthetic(name, expression, path)\n    if (expression.kind == \"IdentifierExpression\") return this.mapped(expression.name, expression, path, \"name\")\n    if (expression.kind == \"BooleanLiteral\") return this.mapped(String(expression.value), expression, path, \"literal\")\n    if (expression.kind == \"IntegerLiteral\") return this.mapped(`INT64_C(${expression.value})`, expression, path, \"literal\")\n    if (expression.kind == \"StringLiteral\") {\n      const bytes = new TextEncoder().encode(expression.value)\n      const literal = Array.from(bytes, (byte) => `\\\\${byte.toString(8).padStart(3, \"0\")}`).join(\"\")\n\n      return this.mapped(`SEMANTIFOLD_STRING(\"${literal}\")`, expression, path, \"literal\")\n    }\n    throw new Error(\"Unsequenced expression passed C planning.\")\n  }\n}\n"]}

package/build/src/backends/cpp-runtime.d.ts

@@ -0,0 +1,3 @@
+/** Exact C++20 native support; owned scalar values never expose implementation lifetimes. */
+export declare const cppRuntime = "#include <cstdint>\n#include <cstdio>\n#include <cstdlib>\n#include <string>\n#include <limits>\n#include <climits>\n\nstatic_assert(CHAR_BIT == 8 && sizeof(std::int64_t) == 8, \"Semantifold requires eight-bit bytes and int64\");\nstatic_assert(sizeof(std::size_t) == 8 && sizeof(std::ptrdiff_t) == 8, \"Semantifold requires the qualified 64-bit ABI\");\nstatic_assert(_GLIBCXX_USE_CXX11_ABI == 1, \"Semantifold requires libstdc++ C++11 string ABI\");\n\n[[noreturn]] inline void semantifold_fatal(const char *message, std::size_t length) {\n    (void)std::fwrite(message, 1, length, stderr);\n    std::exit(70);\n}\n\ninline std::int64_t semantifold_integer_add(std::int64_t left, std::int64_t right) {\n    std::int64_t result;\n    if (__builtin_add_overflow(left, right, &result)) {\n        semantifold_fatal(\"semantifold: integer overflow\\n\", sizeof(\"semantifold: integer overflow\\n\") - 1);\n    }\n    return result;\n}\n\ninline std::int64_t semantifold_integer_subtract(std::int64_t left, std::int64_t right) {\n    std::int64_t result;\n    if (__builtin_sub_overflow(left, right, &result)) {\n        semantifold_fatal(\"semantifold: integer overflow\\n\", sizeof(\"semantifold: integer overflow\\n\") - 1);\n    }\n    return result;\n}\n\ninline std::int64_t semantifold_integer_multiply(std::int64_t left, std::int64_t right) {\n    std::int64_t result;\n    if (__builtin_mul_overflow(left, right, &result)) {\n        semantifold_fatal(\"semantifold: integer overflow\\n\", sizeof(\"semantifold: integer overflow\\n\") - 1);\n    }\n    return result;\n}\n\ninline std::int64_t semantifold_integer_negate(std::int64_t value) {\n    return semantifold_integer_subtract(std::int64_t(0), value);\n}\n\ninline std::string semantifold_string_concat(std::string left, std::string right) {\n    if (right.size() > left.max_size() - left.size()) {\n        semantifold_fatal(\"semantifold: string size\\n\", sizeof(\"semantifold: string size\\n\") - 1);\n    }\n    return left + right;\n}\n\ninline bool semantifold_string_equal(std::string left, std::string right) {\n    return left == right;\n}\n\ninline bool semantifold_string_not_equal(std::string left, std::string right) {\n    return left != right;\n}\n\ninline void semantifold_write(const char *data, std::size_t length) {\n    if (length != 0 && std::fwrite(data, 1, length, stdout) != length) {\n        semantifold_fatal(\"semantifold: output failure\\n\", sizeof(\"semantifold: output failure\\n\") - 1);\n    }\n}\n\ninline void semantifold_newline() {\n    semantifold_write(\"\\n\", 1);\n    if (std::fflush(stdout) != 0) semantifold_fatal(\"semantifold: output failure\\n\", sizeof(\"semantifold: output failure\\n\") - 1);\n}\n\ninline void semantifold_print_string(std::string value) {\n    semantifold_write(value.data(), value.size());\n    semantifold_newline();\n}\n\ninline void semantifold_print_boolean(bool value) {\n    if (value) semantifold_write(\"true\", 4);\n    else semantifold_write(\"false\", 5);\n    semantifold_newline();\n}\n\ninline void semantifold_print_integer(std::int64_t value) {\n    char digits[20];\n    std::size_t position = sizeof(digits);\n    std::uint64_t magnitude = static_cast<std::uint64_t>(value);\n    if (value < 0) magnitude = std::uint64_t(0) - magnitude;\n    do {\n        digits[--position] = static_cast<char>(std::uint64_t(48) + magnitude % std::uint64_t(10));\n        magnitude /= std::uint64_t(10);\n    } while (magnitude != 0);\n    if (value < 0) digits[--position] = '-';\n    semantifold_write(digits + position, sizeof(digits) - position);\n    semantifold_newline();\n}\n/* semantifold:runtime:cpp:v1 end */\n";
+//# sourceMappingURL=cpp-runtime.d.ts.map

package/build/src/backends/cpp-runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cpp-runtime.d.ts","sourceRoot":"","sources":["../../../src/backends/cpp-runtime.js"],"names":[],"mappings":"AAEA,6FAA6F;AAC7F,eAAO,MAAM,UAAU,8kHA+FtB,CAAA"}

package/build/src/backends/cpp-runtime.js

@@ -0,0 +1,99 @@
+// @ts-check
+/** Exact C++20 native support; owned scalar values never expose implementation lifetimes. */
+export const cppRuntime = `#include <cstdint>
+#include <cstdio>
+#include <cstdlib>
+#include <string>
+#include <limits>
+#include <climits>
+
+static_assert(CHAR_BIT == 8 && sizeof(std::int64_t) == 8, "Semantifold requires eight-bit bytes and int64");
+static_assert(sizeof(std::size_t) == 8 && sizeof(std::ptrdiff_t) == 8, "Semantifold requires the qualified 64-bit ABI");
+static_assert(_GLIBCXX_USE_CXX11_ABI == 1, "Semantifold requires libstdc++ C++11 string ABI");
+
+[[noreturn]] inline void semantifold_fatal(const char *message, std::size_t length) {
+    (void)std::fwrite(message, 1, length, stderr);
+    std::exit(70);
+}
+
+inline std::int64_t semantifold_integer_add(std::int64_t left, std::int64_t right) {
+    std::int64_t result;
+    if (__builtin_add_overflow(left, right, &result)) {
+        semantifold_fatal("semantifold: integer overflow\\n", sizeof("semantifold: integer overflow\\n") - 1);
+    }
+    return result;
+}
+
+inline std::int64_t semantifold_integer_subtract(std::int64_t left, std::int64_t right) {
+    std::int64_t result;
+    if (__builtin_sub_overflow(left, right, &result)) {
+        semantifold_fatal("semantifold: integer overflow\\n", sizeof("semantifold: integer overflow\\n") - 1);
+    }
+    return result;
+}
+
+inline std::int64_t semantifold_integer_multiply(std::int64_t left, std::int64_t right) {
+    std::int64_t result;
+    if (__builtin_mul_overflow(left, right, &result)) {
+        semantifold_fatal("semantifold: integer overflow\\n", sizeof("semantifold: integer overflow\\n") - 1);
+    }
+    return result;
+}
+
+inline std::int64_t semantifold_integer_negate(std::int64_t value) {
+    return semantifold_integer_subtract(std::int64_t(0), value);
+}
+
+inline std::string semantifold_string_concat(std::string left, std::string right) {
+    if (right.size() > left.max_size() - left.size()) {
+        semantifold_fatal("semantifold: string size\\n", sizeof("semantifold: string size\\n") - 1);
+    }
+    return left + right;
+}
+
+inline bool semantifold_string_equal(std::string left, std::string right) {
+    return left == right;
+}
+
+inline bool semantifold_string_not_equal(std::string left, std::string right) {
+    return left != right;
+}
+
+inline void semantifold_write(const char *data, std::size_t length) {
+    if (length != 0 && std::fwrite(data, 1, length, stdout) != length) {
+        semantifold_fatal("semantifold: output failure\\n", sizeof("semantifold: output failure\\n") - 1);
+    }
+}
+
+inline void semantifold_newline() {
+    semantifold_write("\\n", 1);
+    if (std::fflush(stdout) != 0) semantifold_fatal("semantifold: output failure\\n", sizeof("semantifold: output failure\\n") - 1);
+}
+
+inline void semantifold_print_string(std::string value) {
+    semantifold_write(value.data(), value.size());
+    semantifold_newline();
+}
+
+inline void semantifold_print_boolean(bool value) {
+    if (value) semantifold_write("true", 4);
+    else semantifold_write("false", 5);
+    semantifold_newline();
+}
+
+inline void semantifold_print_integer(std::int64_t value) {
+    char digits[20];
+    std::size_t position = sizeof(digits);
+    std::uint64_t magnitude = static_cast<std::uint64_t>(value);
+    if (value < 0) magnitude = std::uint64_t(0) - magnitude;
+    do {
+        digits[--position] = static_cast<char>(std::uint64_t(48) + magnitude % std::uint64_t(10));
+        magnitude /= std::uint64_t(10);
+    } while (magnitude != 0);
+    if (value < 0) digits[--position] = '-';
+    semantifold_write(digits + position, sizeof(digits) - position);
+    semantifold_newline();
+}
+/* semantifold:runtime:cpp:v1 end */
+`;
+//# sourceMappingURL=data:application/json;base64,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

package/build/src/backends/cpp-validation.d.ts

@@ -0,0 +1,9 @@
+/** Qualified frozen parser input bound, including the inline support. */
+export declare const maximumCppSourceLength = 32767;
+/**
+ * Rejects known unrepresentable values before target emission.
+ * @param {import("../semantic/types.js").SemanticModule} module - Fully validated semantic module.
+ * @returns {void}
+ */
+export declare function validateCppValues(module: import("../semantic/types.js").SemanticModule): void;
+//# sourceMappingURL=cpp-validation.d.ts.map

package/build/src/backends/cpp-validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cpp-validation.d.ts","sourceRoot":"","sources":["../../../src/backends/cpp-validation.js"],"names":[],"mappings":"AAIA,yEAAyE;AACzE,eAAO,MAAM,sBAAsB,QAAQ,CAAA;AAsD3C;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAH7B,OAAO,sBAAsB,EAAE,cAGF,GAF3B,IAAI,CAOhB"}

package/build/src/backends/cpp-validation.js

@@ -0,0 +1,74 @@
+// @ts-check
+import { unsupportedCapability } from "../diagnostic.js";
+/** Qualified frozen parser input bound, including the inline support. */
+export const maximumCppSourceLength = 32767;
+/** Propagates proven UTF-8 value sizes without evaluating or rewriting semantic expressions. */
+class CppValueValidator {
+    /**
+     * Checks every expression, including skipped-runtime candidates before generation.
+     * @param {import("../semantic/types.js").Expression} expression - Validated expression.
+     * @param {Map<string, bigint | undefined>} sizes - Visible value byte sizes.
+     * @returns {bigint | undefined} Statically known string size.
+     */
+    size(expression, sizes) {
+        if (expression.kind == "StringLiteral")
+            return BigInt(Buffer.byteLength(expression.value, "utf8"));
+        if (expression.kind == "IdentifierExpression")
+            return sizes.get(expression.name);
+        if (expression.kind == "CallExpression") {
+            for (const argument of expression.arguments)
+                this.size(argument, sizes);
+        }
+        else if (expression.kind == "UnaryExpression")
+            this.size(expression.operand, sizes);
+        else if (expression.kind == "BinaryExpression") {
+            const left = this.size(expression.left, sizes);
+            const right = this.size(expression.right, sizes);
+            if (expression.operation == "StringConcat") {
+                if ((left ?? 0n) + (right ?? 0n) > 9223372036854775807n) {
+                    unsupportedCapability("cpp", "known owned string size exceeds the qualified 64-bit object limit", expression.location);
+                }
+                if (left !== undefined && right !== undefined)
+                    return left + right;
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Follows value copies and merges only identical proven branch results.
+     * @param {import("../semantic/types.js").Block} block - Lexical block.
+     * @param {Map<string, bigint | undefined>} inherited - Visible byte sizes.
+     * @returns {Map<string, bigint | undefined>} Outgoing proven sizes.
+     */
+    block(block, inherited) {
+        const sizes = new Map(inherited);
+        for (const statement of block.statements) {
+            if (statement.kind == "LocalDeclaration")
+                sizes.set(statement.name, this.size(statement.initializer, sizes));
+            else if (statement.kind == "AssignmentStatement")
+                sizes.set(statement.target.name, this.size(statement.expression, sizes));
+            else if (statement.kind == "IfStatement") {
+                this.size(statement.condition, sizes);
+                const left = this.block(statement.consequent, sizes);
+                const right = statement.alternate ? this.block(statement.alternate, sizes) : sizes;
+                for (const name of sizes.keys())
+                    sizes.set(name, left.get(name) === right.get(name) ? left.get(name) : undefined);
+            }
+            else
+                this.size(statement.expression, sizes);
+        }
+        return sizes;
+    }
+}
+/**
+ * Rejects known unrepresentable values before target emission.
+ * @param {import("../semantic/types.js").SemanticModule} module - Fully validated semantic module.
+ * @returns {void}
+ */
+export function validateCppValues(module) {
+    const validator = new CppValueValidator();
+    for (const declaration of module.functions)
+        validator.block(declaration.body, new Map());
+    validator.block(module.entryPoint.body, new Map());
+}
+//# sourceMappingURL=data:application/json;base64,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