@tsplc/compiler 0.0.0-stage → 0.1.0

package/backends/codesys/index.ts

@@ -0,0 +1,12 @@
+export { type CodesysOptions, codesys, direct } from "./config.ts";
+export { emitCodesys, type SourceMapping } from "./emit.ts";
+export {
+  buildCodesys,
+  codesysBuildConfig,
+  type CodesysEngineeringBuild,
+  engineeringBuildSchema,
+} from "./engineering.ts";
+export { type CodesysPlan, planCodesys } from "./plan.ts";
+export { diagnoseCodesys } from "./vendor.ts";
+export { ioTargets } from "./io-paths.ts";
+export { publicationSelectors } from "./publication.ts";

package/backends/codesys/io-paths.ts

@@ -0,0 +1,103 @@
+import type { PlcType, Variable, VerifiedCoreModule } from "@tsplc/compiler/ir";
+import { type IoTarget, ioLayout } from "@tsplc/typegen/hardware";
+import { moduleName } from "./storage.ts";
+
+type StorageSegment =
+  { kind: "field"; record: string; name: string } | { kind: "index"; value: number };
+
+/** An `io` key that names a field of authored module storage, e.g. `PlantIO.Motor.Output.Run`. */
+export interface StorageBinding {
+  key: string;
+  root: Variable;
+  segments: readonly StorageSegment[];
+  type: PlcType;
+}
+
+const pathPattern = /^([\w$-]+)\.([A-Za-z_$][\w$]*)((?:\.[A-Za-z_$][\w$]*|\[-?\d+\])*)$/;
+
+export const isStoragePath = (key: string): boolean => key.includes(".") || key.includes("[");
+
+/** Resolve a storage path against verified types; the error explains the first unresolvable segment. */
+export function resolveStoragePath(
+  core: VerifiedCoreModule,
+  key: string,
+): StorageBinding | { error: string } {
+  const match = pathPattern.exec(key);
+  if (!match) return { error: `${key}: expected Module.variable followed by .field or [index].` };
+  const [, module, name, rest] = match;
+  const roots = core.variables.filter(
+    (item) => item.storage === "module" && item.name === name && moduleName(item) === module,
+  );
+  if (roots.length !== 1)
+    return {
+      error: roots.length
+        ? `${key}: ${module}.${name} is declared by more than one module named ${module}.`
+        : `${key}: no mutable module variable ${module}.${name}.`,
+    };
+  const root = roots[0]!;
+  const types = new Map(core.types.map((type) => [type.id, type]));
+  let type = types.get(root.type)!;
+  const segments: StorageSegment[] = [];
+  for (const [, field, index] of rest!.matchAll(/\.([A-Za-z_$][\w$]*)|\[(-?\d+)\]/g)) {
+    if (field !== undefined) {
+      const member = type.kind === "record" ? type.fields.find((f) => f.name === field) : undefined;
+      if (!member) return { error: `${key}: no field ${field}.` };
+      segments.push({ kind: "field", record: type.id, name: field });
+      type = types.get(member.type)!;
+    } else {
+      const value = Number(index);
+      if (type.kind !== "array") return { error: `${key}: ${index} indexes a non-array value.` };
+      if (value < type.lowerBound || value >= type.lowerBound + type.length)
+        return {
+          error: `${key}: index ${value} is outside ${type.lowerBound}..${type.lowerBound + type.length - 1}.`,
+        };
+      segments.push({ kind: "index", value });
+      type = types.get(type.element)!;
+    }
+  }
+  return { key, root, segments, type };
+}
+
+/** IEC spelling of a bindable type, as typegen spells channels; undefined for records, enums, strings. */
+export function iecSpelling(
+  type: PlcType,
+  types: ReadonlyMap<string, PlcType>,
+): string | undefined {
+  if (
+    type.kind === "bool" ||
+    type.kind === "integer" ||
+    type.kind === "bits" ||
+    type.kind === "float"
+  )
+    return type.id;
+  if (type.kind !== "array") return undefined;
+  const element = iecSpelling(types.get(type.element)!, types);
+  const upper = type.lowerBound + type.length - 1;
+  return element && !element.startsWith("ARRAY")
+    ? `ARRAY[${type.lowerBound}..${upper}] OF ${element}`
+    : undefined;
+}
+
+/** Every key an `io` mapping may use: logical IO names and paths into mutable module storage. */
+export function ioTargets(core: VerifiedCoreModule): IoTarget[] {
+  const types = new Map(core.types.map((type) => [type.id, type]));
+  const targets: IoTarget[] = [];
+  const add = (key: string, type: PlcType) => {
+    const layout = ioLayout(iecSpelling(type, types) ?? "");
+    if (layout) targets.push({ key, layout });
+  };
+  const visit = (key: string, type: PlcType): void => {
+    add(key, type);
+    if (type.kind === "record")
+      for (const field of type.fields) visit(`${key}.${field.name}`, types.get(field.type)!);
+    // Typegen writes keys as template literal types, so any index matches here.
+    if (type.kind === "array") visit(`${key}[` + "${number}" + "]", types.get(type.element)!);
+  };
+  for (const variable of core.variables) {
+    if (variable.storage === "input" || variable.storage === "output")
+      add(variable.name, types.get(variable.type)!);
+    else if (variable.storage === "module")
+      visit(`${moduleName(variable)}.${variable.name}`, types.get(variable.type)!);
+  }
+  return targets;
+}

package/backends/codesys/names.ts

@@ -0,0 +1,76 @@
+// CODESYS declaration, statement, operator and elementary-type keywords.
+// https://content.helpme-codesys.com/en/CODESYS%20Development%20System/_cds_keywords.html
+const keywords = new Set(
+  `
+ACTION END_ACTION PROGRAM END_PROGRAM FUNCTION END_FUNCTION FUNCTION_BLOCK END_FUNCTION_BLOCK
+INTERFACE END_INTERFACE METHOD END_METHOD PROPERTY END_PROPERTY
+TYPE END_TYPE STRUCT END_STRUCT UNION END_UNION ARRAY POINTER REFERENCE
+VAR END_VAR VAR_INPUT VAR_OUTPUT VAR_IN_OUT VAR_TEMP VAR_GLOBAL VAR_EXTERNAL
+VAR_ACCESS VAR_CONFIG VAR_STAT VAR_INST VAR_GENERIC
+CONSTANT RETAIN NON_RETAIN PERSISTENT AT READ_ONLY READ_WRITE PARAMS
+CONFIGURATION END_CONFIGURATION RESOURCE END_RESOURCE TASK WITH SINGLE INTERVAL PRIORITY
+PRIVATE PUBLIC PROTECTED INTERNAL ABSTRACT FINAL OVERRIDE EXTENDS IMPLEMENTS THIS SUPER
+IF THEN ELSIF ELSE END_IF CASE OF END_CASE FOR TO BY DO END_FOR
+WHILE END_WHILE REPEAT UNTIL END_REPEAT RETURN EXIT CONTINUE JMP
+TRUE FALSE BOOL BYTE WORD DWORD LWORD SINT USINT INT UINT DINT UDINT LINT ULINT
+REAL LREAL TIME LTIME DATE LDATE DATE_AND_TIME LDATE_AND_TIME TIME_OF_DAY LTIME_OF_DAY
+DT LDT TOD LTOD STRING WSTRING CHAR WCHAR
+ANY ANY_BIT ANY_DATE ANY_DERIVED ANY_ELEMENTARY ANY_INT ANY_MAGNITUDE ANY_NUM
+ANY_REAL ANY_STRING ANY_UNSIGNED
+AND AND_THEN OR OR_ELSE XOR NOT MOD ADD SUB MUL DIV MOVE SEL MIN MAX LIMIT
+ABS ACOS ASIN ATAN COS SIN TAN EXP EXPT LN LOG SQRT TRUNC SHL SHR ROL ROR
+ADR SIZEOF CONCAT DELETE FIND INSERT LEFT LEN MID REPLACE RIGHT
+`
+    .trim()
+    .split(/\s+/),
+);
+const types =
+  "(?:BOOL|BYTE|WORD|DWORD|LWORD|SINT|USINT|INT|UINT|DINT|UDINT|LINT|ULINT|REAL|LREAL|TIME|LTIME|DATE|LDATE|DATE_AND_TIME|LDATE_AND_TIME|TIME_OF_DAY|LTIME_OF_DAY|DT|LDT|TOD|LTOD|STRING|WSTRING|CHAR|WCHAR)";
+const conversion = new RegExp(`^(?:${types}_TO_${types}|TO_${types}|TRUNC_${types})$`);
+export function isIecIdentifier(name: string): boolean {
+  const upper = name.toUpperCase();
+  return (
+    /^[A-Za-z][A-Za-z0-9_]*$/.test(name) &&
+    !name.includes("__") &&
+    !keywords.has(upper) &&
+    !conversion.test(upper)
+  );
+}
+
+const identifierBody = (label: string): string =>
+  label
+    .replace(/[^A-Za-z0-9_]/g, "_")
+    .replace(/_+/g, "_")
+    .replace(/^_+|_+$/g, "") || "name";
+
+/** Capitals inside a word are kept, so `PlantIO` stays as written while `plant-io` is `PlantIo`. */
+export const pascalCase = (label: string): string =>
+  label
+    .split(/[^A-Za-z0-9]+/)
+    .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+    .join("");
+
+export class Names {
+  private readonly used = new Set<string>();
+  allocateObject(prefix: "FB" | "F" | "PRG" | "ST" | "E" | "GVL", label: string): string {
+    const source = prefix === "F" ? label.replace(/^PRG_/, "") : label;
+    const kind = prefix === "F" && source.startsWith("FUN_") ? "FUN" : prefix;
+    const body = source.startsWith(`${kind}_`) ? source.slice(kind.length + 1) : source;
+    return this.allocate(`${kind}_${identifierBody(body)}`);
+  }
+
+  reserve(name: string): void {
+    this.used.add(name.toUpperCase());
+    // Qualified native types must keep their library prefix resolvable in the
+    // declaration scope, not merely reserve the complete dotted spelling.
+    const prefix = name.split(".")[0];
+    if (prefix) this.used.add(prefix.toUpperCase());
+  }
+  allocate(label: string, preserve = true): string {
+    const base = preserve && isIecIdentifier(label) ? label : `plc_${identifierBody(label)}`;
+    let name = base;
+    for (let suffix = 2; this.used.has(name.toUpperCase()); suffix++) name = `${base}_${suffix}`;
+    this.reserve(name);
+    return name;
+  }
+}

package/backends/codesys/numeric.ts

@@ -0,0 +1,356 @@
+import {
+  type Constant,
+  type CoreExpression,
+  type GeneratedObject,
+  integerRange,
+  floatMaximum,
+  integerType,
+  type PlcType,
+} from "@tsplc/compiler/ir";
+
+export function scalarLiteral(value: Constant, type: string): string {
+  if (value.kind === "bool") return value.value ? "TRUE" : "FALSE";
+  if (value.kind === "integer") return `${type}#${value.value}`;
+  if (value.kind === "float") {
+    // String(-0) loses the IEEE sign; keep it explicit in target float literals.
+    const text = Object.is(value.value, -0) ? "-0.0" : String(value.value).replace(/e/i, "E");
+    return `${type}#${text}`;
+  }
+  throw new Error("Expected verified scalar constant");
+}
+
+export class NumericLowering {
+  readonly objects: GeneratedObject[] = [];
+  private readonly helpers = new Map<string, string>();
+
+  constructor(
+    private readonly types: ReadonlyMap<string, PlcType>,
+    private readonly allocate: (label: string) => string,
+  ) {}
+
+  prepare(value: CoreExpression): void {
+    if (value.kind === "load") {
+      value.path?.forEach((segment) => {
+        if (segment.kind === "index") this.prepare(segment.value);
+      });
+    }
+    if (value.kind === "borrow") {
+      value.place.path.forEach((segment) => {
+        if (segment.kind === "index") this.prepare(segment.value);
+      });
+    }
+    if (value.kind === "binary") {
+      this.prepare(value.left);
+      this.prepare(value.right);
+      if (value.policy) this.arithmetic(value.type, value.operator, value.policy);
+    }
+    if (value.kind === "unary") this.prepare(value.operand);
+    if (value.kind === "convert") {
+      this.prepare(value.operand);
+      if (value.policy === "saturate") this.saturation(value.operand.type, value.type);
+    }
+  }
+
+  render(value: CoreExpression, operands: readonly string[]): string {
+    if (value.kind === "convert") {
+      return value.policy === "saturate"
+        ? `${this.saturation(value.operand.type, value.type)}(${operands[0]})`
+        : `TO_${value.type}(${operands[0]})`;
+    }
+    if (value.kind === "unary") {
+      // Avoid signed intermediate casts: TIME spans the complete UDINT range.
+      if (value.operator === "timeToMilliseconds") return `TIME_TO_UDINT(${operands[0]})`;
+      // Milliseconds since the runtime started; DINT wraps after 24.8 days, so subtract to compare.
+      if (value.operator === "clock") return "TO_DINT(TIME_TO_UDINT(TIME()))";
+      return value.operator === "not"
+        ? `(NOT ${operands[0]})`
+        : `TO_${value.type}(${value.operator === "negate" ? "-" : "NOT "}${operands[0]})`;
+    }
+    if (value.kind !== "binary") throw new Error("Expected numeric operation");
+    if (value.policy) {
+      return `${this.arithmetic(value.type, value.operator, value.policy)}(${operands.join(", ")})`;
+    }
+    if (value.operator === "shiftLeft" || value.operator === "shiftRight") {
+      const shift = value.operator === "shiftLeft" ? "SHL" : "SHR";
+      return `TO_${value.type}(${shift}(${operands.join(", ")}))`;
+    }
+    const tokens: Readonly<Record<string, string>> = {
+      add: "+",
+      subtract: "-",
+      multiply: "*",
+      divide: "/",
+      remainder: "MOD",
+      equal: "=",
+      notEqual: "<>",
+      less: "<",
+      lessEqual: "<=",
+      greater: ">",
+      greaterEqual: ">=",
+      bitAnd: "AND",
+      bitOr: "OR",
+      bitXor: "XOR",
+    };
+    const token = tokens[value.operator];
+    if (!token) throw new Error("Boolean short-circuit operation was not normalized");
+    const text =
+      value.operator === "remainder"
+        ? `(${operands[0]} - (${operands[0]} / ${operands[1]}) * ${operands[1]})`
+        : `(${operands[0]} ${token} ${operands[1]})`;
+    return value.type === "BOOL" ? text : `TO_${value.type}(${text})`;
+  }
+
+  private helper(
+    key: string,
+    type: string,
+    inputs: readonly [string, string][],
+    body: (name: string) => string,
+    locals = "",
+  ): string {
+    const existing = this.helpers.get(key);
+    if (existing) return existing;
+    const name = this.allocate(`numeric_${key}`);
+    this.helpers.set(key, name);
+    const parameters = inputs
+      .map(([input, inputType]) => `    ${input} : ${inputType};`)
+      .join("\n");
+    const variables = locals
+      ? `VAR
+${locals}
+END_VAR
+`
+      : "";
+    const declaration = `FUNCTION ${name} : ${type}
+VAR_INPUT
+${parameters}
+END_VAR
+${variables}`;
+    this.objects.push({
+      id: `numeric:${key}`,
+      kind: "function",
+      name,
+      declaration,
+      implementation: body(name),
+    });
+    return name;
+  }
+
+  private add64(): string {
+    // XOR forms the sum bits; each carry moves left until it exits the 64-bit word.
+    // This gives modulo 2^64 addition without relying on target integer overflow.
+    return this.helper(
+      "add64",
+      "LWORD",
+      [
+        ["a", "LWORD"],
+        ["b", "LWORD"],
+      ],
+      (name) => `x := a;
+y := b;
+FOR i := 1 TO 64 DO
+    carry := SHL(x AND y, 1);
+    x := x XOR y;
+    y := carry;
+END_FOR;
+${name} := x;
+`,
+      `    x, y, carry : LWORD;
+    i : UINT;`,
+    );
+  }
+
+  private wrap64(operator: string): string {
+    const add = this.add64();
+    if (operator === "add") return add;
+    if (operator === "subtract") {
+      // Two's complement negation and addition use the same modulo word operation.
+      return this.helper(
+        "subtract64",
+        "LWORD",
+        [
+          ["a", "LWORD"],
+          ["b", "LWORD"],
+        ],
+        (name) => `${name} := ${add}(a, ${add}(NOT b, LWORD#1));
+`,
+      );
+    }
+    if (operator !== "multiply") throw new Error("Unsupported verified wrapping operation");
+    // Shift-and-add retains exactly the low 64 product bits.
+    return this.helper(
+      "multiply64",
+      "LWORD",
+      [
+        ["a", "LWORD"],
+        ["b", "LWORD"],
+      ],
+      (name) => `x := a;
+y := b;
+result := LWORD#0;
+FOR i := 1 TO 64 DO
+    IF (y AND LWORD#1) <> LWORD#0 THEN
+        result := ${add}(result, x);
+    END_IF;
+    x := SHL(x, 1);
+    y := SHR(y, 1);
+END_FOR;
+${name} := result;
+`,
+      `    x, y, result : LWORD;
+    i : UINT;`,
+    );
+  }
+
+  private arithmetic(typeId: string, operator: string, policy: "wrap" | "saturate"): string {
+    const type = this.types.get(typeId);
+    if (type?.kind !== "integer") throw new Error("Expected verified integer arithmetic");
+    const token = operator === "add" ? "+" : operator === "subtract" ? "-" : "*";
+    const key = `${policy}_${operator}_${typeId}`;
+    if (policy === "wrap") {
+      if (type.bits === 64) {
+        const operation = this.wrap64(operator);
+        return this.helper(
+          key,
+          typeId,
+          [
+            ["a", typeId],
+            ["b", typeId],
+          ],
+          (
+            name,
+          ) => `${name} := LWORD_TO_${typeId}(${operation}(${typeId}_TO_LWORD(a), ${typeId}_TO_LWORD(b)));
+`,
+        );
+      }
+      const wide = !type.signed && operator !== "subtract" ? "ULINT" : "LINT";
+      return this.helper(
+        key,
+        typeId,
+        [
+          ["a", typeId],
+          ["b", typeId],
+        ],
+        (
+          name,
+        ) => `${name} := ${wide}_TO_${typeId}(${typeId}_TO_${wide}(a) ${token} ${typeId}_TO_${wide}(b));
+`,
+      );
+    }
+
+    const [minimum, maximum] = integerRange(type);
+    const min = `${typeId}#${minimum}`,
+      max = `${typeId}#${maximum}`,
+      zero = `${typeId}#0`;
+    return this.helper(
+      key,
+      typeId,
+      [
+        ["a", typeId],
+        ["b", typeId],
+      ],
+      (name) => {
+        const clamp = (
+          condition: string,
+          endpoint: string,
+          depth = "",
+        ) => `${depth}IF ${condition} THEN
+${depth}    ${name} := ${endpoint};
+${depth}    RETURN;
+${depth}END_IF;
+`;
+        let body: string;
+        if (!type.signed) {
+          // Unsigned subtraction has only underflow; the other operations have only overflow.
+          if (operator === "add") body = clamp(`a > ${max} - b`, max);
+          else if (operator === "subtract") body = clamp("a < b", zero);
+          else
+            body = `IF b <> ${zero} THEN
+${clamp(`a > ${max} / b`, max, "    ")}END_IF;
+`;
+        } else if (operator === "add") {
+          body = `IF b > ${zero} THEN
+${clamp(`a > ${max} - b`, max, "    ")}ELSIF b < ${zero} THEN
+${clamp(`a < ${min} - b`, min, "    ")}END_IF;
+`;
+        } else if (operator === "subtract") {
+          body = `IF b < ${zero} THEN
+${clamp(`a > ${max} + b`, max, "    ")}ELSIF b > ${zero} THEN
+${clamp(`a < ${min} + b`, min, "    ")}END_IF;
+`;
+        } else {
+          // Handle zero first, then divide the endpoint before multiplying. Each sign
+          // quadrant tests representability without forming an overflowing product.
+          body =
+            clamp(`a = ${zero}`, zero) +
+            clamp(`b = ${zero}`, zero) +
+            `IF a > ${zero} THEN
+    IF b > ${zero} THEN
+${clamp(`a > ${max} / b`, max, "        ")}    ELSE
+${clamp(`b < ${min} / a`, min, "        ")}    END_IF;
+ELSE
+    IF b > ${zero} THEN
+${clamp(`a < ${min} / b`, min, "        ")}    ELSE
+${clamp(`a < ${max} / b`, max, "        ")}    END_IF;
+END_IF;
+`;
+        }
+        return `${body}${name} := a ${token} b;
+`;
+      },
+    );
+  }
+
+  private saturation(sourceId: string, targetId: string): string {
+    const source = this.types.get(sourceId),
+      target = this.types.get(targetId);
+    if (source?.kind === "float" && target?.kind === "float") {
+      // Widening cannot exceed the destination's finite range. Identity
+      // conversions are removed by normalization; neither needs a helper.
+      if (source.bits <= target.bits) return `TO_${targetId}`;
+      const maximum = floatMaximum(target);
+      const literal = (value: number, type: string): string =>
+        scalarLiteral({ kind: "float", value }, type);
+      return this.helper(
+        `saturate_${sourceId}_${targetId}`,
+        targetId,
+        [["value", sourceId]],
+        (name) => `IF value < ${literal(-maximum, sourceId)} THEN
+    ${name} := ${literal(-maximum, targetId)};
+    RETURN;
+END_IF;
+IF value > ${literal(maximum, sourceId)} THEN
+    ${name} := ${literal(maximum, targetId)};
+    RETURN;
+END_IF;
+${name} := TO_${targetId}(value);
+`,
+      );
+    }
+    if (!source || !target || !integerType(source) || !integerType(target)) {
+      throw new Error("Expected verified integer saturation");
+    }
+    const [fromMin, fromMax] = integerRange(source),
+      [toMin, toMax] = integerRange(target);
+    return this.helper(
+      `saturate_${sourceId}_${targetId}`,
+      targetId,
+      [["value", sourceId]],
+      (name) => {
+        let body = "";
+        if (fromMin < toMin)
+          body += `IF value < ${sourceId}#${toMin} THEN
+    ${name} := ${targetId}#${toMin};
+    RETURN;
+END_IF;
+`;
+        if (fromMax > toMax)
+          body += `IF value > ${sourceId}#${toMax} THEN
+    ${name} := ${targetId}#${toMax};
+    RETURN;
+END_IF;
+`;
+        return `${body}${name} := TO_${targetId}(value);
+`;
+      },
+    );
+  }
+}