@tsplc/compiler 0.2.9 → 0.2.11

package/dist/codesys.js

@@ -144,7 +144,56 @@ function direct(address) {
   return { kind: "direct", address };
 }
 // packages/compiler/backends/codesys/emit.ts
-import { defaultValue, instancedBlock as instancedBlock5, standardBlocks } from "@tsplc/compiler/ir";
+import { defaultValue, instancedBlock as instancedBlock5, standardBlocks as standardBlocks2 } from "@tsplc/compiler/ir";
+
+// packages/compiler/backends/codesys/global-names.ts
+import { standardBlocks } from "@tsplc/compiler/ir";
+
+// packages/compiler/backends/codesys/storage.ts
+import { basename } from "node:path";
+import { instancedBlock } from "@tsplc/compiler/ir";
+var moduleName = (variable) => basename(variable.span.file).replace(/\.[^.]+$/, "");
+function storageLayout(core) {
+  const types = new Map(core.types.map((type) => [type.id, type]));
+  const blocks = new Map(core.blocks.map((block) => [block.id, block]));
+  const retention = new Map;
+  const blockRetained = (id) => {
+    const cached = retention.get(id);
+    if (cached !== undefined)
+      return cached;
+    const block = blocks.get(id);
+    if (!block)
+      throw new Error("Missing verified block during retention planning.");
+    const retained = block.state.some((field) => {
+      const type = instancedBlock(field.type, types);
+      return field.retain || type !== undefined && blockRetained(type.block);
+    });
+    retention.set(id, retained);
+    return retained;
+  };
+  const retainedBlocks = new Set(core.blocks.filter((block) => blockRetained(block.id)).map((block) => block.id));
+  const retainedVariables = new Set([...core.variables, ...core.blocks.flatMap((block) => block.state)].filter((variable) => {
+    const type = instancedBlock(variable.type, types);
+    return variable.retain || type !== undefined && retainedBlocks.has(type.block);
+  }).map((variable) => variable.id));
+  const groups = new Map;
+  for (const variable of core.variables) {
+    if (variable.storage === "input" || variable.storage === "output")
+      continue;
+    const storage = variable.storage === "constant" ? "constants" : retainedVariables.has(variable.id) ? "retained" : "state";
+    const id = `${variable.span.file}:${storage}`;
+    let group = groups.get(id);
+    if (!group) {
+      group = { id, module: moduleName(variable), storage, variables: [] };
+      groups.set(id, group);
+    }
+    group.variables.push(variable);
+  }
+  return { retainedBlocks, retainedVariables, globalLists: [...groups.values()] };
+}
+
+// packages/compiler/backends/codesys/types.ts
+import { instancedBlock as instancedBlock2 } from "@tsplc/compiler/ir";
 
 // packages/compiler/backends/codesys/numeric.ts
 import {
@@ -424,60 +473,212 @@ END_IF;
   }
 }
 
+// packages/compiler/backends/codesys/types.ts
+class CodesysTypes {
+  types;
+  objects = [];
+  names = new Map;
+  fields = new Map;
+  constructor(types, names, blockNames) {
+    this.types = types;
+    for (const type of types.values()) {
+      if (type.kind === "block") {
+        const name = blockNames.get(type.block);
+        if (!name)
+          throw new Error("Missing verified block name");
+        this.names.set(type.id, name);
+      }
+      if (["record", "array", "enum", "string"].includes(type.kind)) {
+        const label = type.id.split(":").at(-1);
+        if (type.kind === "record" || type.kind === "enum") {
+          const prefix = type.kind === "record" ? "ST" : "E";
+          this.names.set(type.id, names.allocateObject(prefix, label));
+        } else
+          this.names.set(type.id, names.allocate(`T_${label}`));
+      }
+      if (type.kind === "record" || type.kind === "enum") {
+        const names = new Names, fields = new Map;
+        for (const member of type.kind === "record" ? type.fields : type.members) {
+          fields.set(member.name, names.allocate(member.name, true));
+        }
+        this.fields.set(type.id, fields);
+      }
+    }
+    for (const type of types.values())
+      if (type.kind === "array" && instancedBlock2(type.id, types))
+        this.names.set(type.id, `ARRAY[${type.lowerBound}..${type.lowerBound + type.length - 1}] OF ${this.name(type.element)}`);
+    const emitted = new Set;
+    const emit = (type) => {
+      if (instancedBlock2(type.id, types) || !this.names.has(type.id) || emitted.has(type.id))
+        return;
+      if (type.kind === "array")
+        emit(this.type(type.element));
+      if (type.kind === "record") {
+        for (const field of type.fields)
+          emit(this.type(field.type));
+      }
+      emitted.add(type.id);
+      const name = this.name(type.id);
+      let declaration;
+      if (type.kind === "record") {
+        const fields = type.fields.map((field) => `    ${this.field(type.id, field.name)} : ${this.name(field.type)};`).join(`
+`);
+        declaration = `TYPE ${name} :
+STRUCT
+${fields}
+END_STRUCT
+END_TYPE
+`;
+      } else if (type.kind === "array") {
+        declaration = `TYPE ${name} : ARRAY[${type.lowerBound}..${type.lowerBound + type.length - 1}] OF ${this.name(type.element)};
+END_TYPE
+`;
+      } else if (type.kind === "string") {
+        declaration = `TYPE ${name} : ${type.encoding === "utf8" ? "STRING" : "WSTRING"}(${type.capacity});
+END_TYPE
+`;
+      } else if (type.kind === "enum") {
+        const members = type.members.map((member) => `    ${this.field(type.id, member.name)} := ${member.value}`).join(`,
+`);
+        declaration = `{attribute 'qualified_only'}
+{attribute 'strict'}
+TYPE ${name} : (
+${members}
+) DINT;
+END_TYPE
+`;
+      } else
+        throw new Error("Unsupported verified data type");
+      this.objects.push({ id: type.id, kind: "dataType", name, declaration });
+    };
+    for (const type of types.values())
+      emit(type);
+  }
+  type(id) {
+    const type = this.types.get(id);
+    if (!type)
+      throw new Error("Missing verified type");
+    return type;
+  }
+  name(id) {
+    return this.names.get(id) ?? id;
+  }
+  field(id, name) {
+    const field = this.fields.get(id)?.get(name);
+    if (!field)
+      throw new Error("Missing verified field");
+    return field;
+  }
+  declarationInitializer(value, id) {
+    const type = this.type(id);
+    if ((type.kind === "record" || type.kind === "array") && this.isZero(value))
+      return "";
+    return ` := ${this.literal(value, id)}`;
+  }
+  isZero(value) {
+    if (value.kind === "bool")
+      return !value.value;
+    if (value.kind === "integer")
+      return value.value === "0";
+    if (value.kind === "float")
+      return Object.is(value.value, 0);
+    if (value.kind === "string")
+      return value.value === "";
+    if (value.kind === "array")
+      return value.items.every((item) => this.isZero(item));
+    if (value.kind === "record")
+      return Object.values(value.fields).every((item) => this.isZero(item));
+    return false;
+  }
+  literal(value, id) {
+    const type = this.type(id);
+    if (type.kind === "enum" && value.kind === "integer") {
+      const member = type.members.find((member) => member.value === value.value);
+      if (!member)
+        throw new Error("Missing verified enum member");
+      return `${this.name(id)}.${this.field(id, member.name)}`;
+    }
+    if (type.kind === "string" && value.kind === "string") {
+      const wide = type.encoding === "utf16", quote = wide ? '"' : "'";
+      let text = "";
+      for (const char of value.value) {
+        const code = char.charCodeAt(0);
+        if (char === "$")
+          text += "$$";
+        else if (char === quote)
+          text += `$${char}`;
+        else if (code < 32 || code === 127)
+          text += `$${code.toString(16).toUpperCase().padStart(wide ? 4 : 2, "0")}`;
+        else
+          text += char;
+      }
+      return `${quote}${text}${quote}`;
+    }
+    if (type.kind === "array" && value.kind === "array") {
+      return `[${value.items.map((item) => this.literal(item, type.element)).join(", ")}]`;
+    }
+    if (type.kind === "record" && value.kind === "record") {
+      const fields = type.fields.map((field) => {
+        const initial = value.fields[field.name];
+        if (!initial)
+          throw new Error("Missing verified record initializer");
+        return `${this.field(id, field.name)} := ${this.literal(initial, field.type)}`;
+      });
+      return `(${fields.join(", ")})`;
+    }
+    if (type.kind === "duration" && value.kind === "duration") {
+      return `T#${BigInt(value.nanoseconds) / 1000000n}ms`;
+    }
+    if (type.kind === "calendar" && value.kind === "calendar") {
+      if (type.domain === "date")
+        return `D#${value.value}`;
+      if (type.domain === "timeOfDay")
+        return `TOD#${value.value}`;
+      return `DT#${value.value.replace("T", "-")}`;
+    }
+    return scalarLiteral(value, id);
+  }
+}
+
+// packages/compiler/backends/codesys/global-names.ts
+var planGlobalNames = (core, programNames = {}) => {
+  const names = new Names;
+  for (const name of Object.values(programNames))
+    names.reserve(name);
+  const typeMap = new Map(core.types.map((type) => [type.id, type]));
+  const blockNames = new Map(core.blocks.map((block) => [
+    block.id,
+    block.standard ? standardBlocks[block.standard].native : names.allocateObject("FB", block.name)
+  ]));
+  for (const name of blockNames.values())
+    names.reserve(name);
+  const targetTypes = new CodesysTypes(typeMap, names, blockNames);
+  const { globalLists, retainedVariables } = storageLayout(core);
+  const hasExports = (group) => group.variables.some((variable) => variable.exported && !variable.exposure);
+  const globals = globalLists.map((group) => {
+    const splitByStorage = globalLists.some((other) => other.module === group.module && other.storage !== group.storage && hasExports(other));
+    const name = hasExports(group) ? names.allocate(pascalCase(splitByStorage ? `${group.module}-${group.storage}` : group.module)) : names.allocateObject("GVL", `${group.module}_${group.storage}`);
+    const fields = new Names;
+    for (const name of blockNames.values())
+      fields.reserve(name);
+    return {
+      ...group,
+      name,
+      fields: new Map(group.variables.map((item) => [item.id, fields.allocate(item.name)]))
+    };
+  });
+  return { names, typeMap, blockNames, targetTypes, globals, retainedVariables };
+};
+
 // packages/compiler/backends/codesys/plan.ts
 import {
-  instancedBlock as instancedBlock3,
+  instancedBlock as instancedBlock4,
   isVerifiedCore
 } from "@tsplc/compiler/ir";
 import { ioLayout as ioLayout2 } from "@tsplc/typegen/hardware";
 
 // packages/compiler/backends/codesys/io-paths.ts
 import { ioLayout } from "@tsplc/typegen/hardware";
-
-// packages/compiler/backends/codesys/storage.ts
-import { basename } from "node:path";
-import { instancedBlock } from "@tsplc/compiler/ir";
-var moduleName = (variable) => basename(variable.span.file).replace(/\.[^.]+$/, "");
-function storageLayout(core) {
-  const types = new Map(core.types.map((type) => [type.id, type]));
-  const blocks = new Map(core.blocks.map((block) => [block.id, block]));
-  const retention = new Map;
-  const blockRetained = (id) => {
-    const cached = retention.get(id);
-    if (cached !== undefined)
-      return cached;
-    const block = blocks.get(id);
-    if (!block)
-      throw new Error("Missing verified block during retention planning.");
-    const retained = block.state.some((field) => {
-      const type = instancedBlock(field.type, types);
-      return field.retain || type !== undefined && blockRetained(type.block);
-    });
-    retention.set(id, retained);
-    return retained;
-  };
-  const retainedBlocks = new Set(core.blocks.filter((block) => blockRetained(block.id)).map((block) => block.id));
-  const retainedVariables = new Set([...core.variables, ...core.blocks.flatMap((block) => block.state)].filter((variable) => {
-    const type = instancedBlock(variable.type, types);
-    return variable.retain || type !== undefined && retainedBlocks.has(type.block);
-  }).map((variable) => variable.id));
-  const groups = new Map;
-  for (const variable of core.variables) {
-    if (variable.storage === "input" || variable.storage === "output")
-      continue;
-    const storage = variable.storage === "constant" ? "constants" : retainedVariables.has(variable.id) ? "retained" : "state";
-    const id = `${variable.span.file}:${storage}`;
-    let group = groups.get(id);
-    if (!group) {
-      group = { id, module: moduleName(variable), storage, variables: [] };
-      groups.set(id, group);
-    }
-    group.variables.push(variable);
-  }
-  return { retainedBlocks, retainedVariables, globalLists: [...groups.values()] };
-}
-
-// packages/compiler/backends/codesys/io-paths.ts
 var pathPattern = /^([\w$-]+)\.([A-Za-z_$][\w$]*)((?:\.[A-Za-z_$][\w$]*|\[-?\d+\])*)$/;
 var isStoragePath = (key) => key.includes(".") || key.includes("[");
 function resolveStoragePath(core, key) {
@@ -1006,7 +1207,54 @@ IF digits=0 THEN malformed:=TRUE;END_IF;IF negative THEN numberValue:=-numberVal
 };
 
 // packages/compiler/backends/codesys/task-access.ts
-import { instancedBlock as instancedBlock2 } from "@tsplc/compiler/ir";
+import { instancedBlock as instancedBlock3 } from "@tsplc/compiler/ir";
+function schedulePrograms(core, tasks, report) {
+  const background = new Map;
+  for (const program of core.programs) {
+    if (!program.background)
+      continue;
+    const { priority, intervalNanoseconds } = program.background;
+    const name = `TsplcBackground_${priority}_${BigInt(intervalNanoseconds) / 1000000n}`;
+    const existing = background.get(name);
+    if (existing) {
+      existing.programs.push(program.name);
+      continue;
+    }
+    background.set(name, {
+      name,
+      priority,
+      intervalNanoseconds,
+      programs: [program.name]
+    });
+  }
+  return appendContinuations(core, [...tasks, ...background.values()], report);
+}
+function taskStorageOwnership(core, report) {
+  const owners = new Map;
+  const globals = new Map(core.variables.map((item) => [item.id, item]));
+  const functions = new Map(core.functions.map((item) => [item.id, item]));
+  const blocks = new Map(core.blocks.map((block) => [block.id, block.runtime?.kind]));
+  const runtimes = new Map(core.types.flatMap((type) => type.kind === "block" ? [[type.id, blocks.get(type.block)]] : []));
+  return (task, program) => {
+    const fn = functions.get(program.entry);
+    if (!fn)
+      throw new Error("Verified core has a missing entry.");
+    const worker = program.background?.worker;
+    const host = worker && core.variables.find((item) => item.name === worker && item.span.file === fn.span.file && runtimes.get(item.type) === "backgroundHost");
+    for (const id of accessedStorage(fn, core, host ? host.id : undefined)) {
+      const item = globals.get(id);
+      if (!item || item.storage === "constant" || runtimes.get(item.type) === "mailbox")
+        continue;
+      const ownsWorker = worker === item.name && item.span.file === fn.span.file;
+      if (program.background && (!ownsWorker || host && item.id === host.id))
+        report(`Background task ${program.name} accesses scan-owned storage ${item.name}; pass value snapshots through the mailbox.`, item.span);
+      const owner = owners.get(id);
+      if (owner && owner !== task)
+        report(`Storage ${item.name} is shared across cyclic tasks ${owner} and ${task}.`, item.span);
+      owners.set(id, task);
+    }
+  };
+}
 function accessedStorage(fn, core, scheduledHost) {
   const scheduledCall = fn.body.find((item) => item.kind === "invoke" && item.instance === scheduledHost);
   const result = new Set, seen = new Set;
@@ -1095,7 +1343,7 @@ function accessedStorage(fn, core, scheduledHost) {
         const variable = variables.get(item.instance);
         if (!variable)
           throw new Error("Missing verified instance during task planning.");
-        const type = instancedBlock2(variable.type, types);
+        const type = instancedBlock3(variable.type, types);
         const block = type && blocks.get(type.block);
         if (block && !seen.has(block.id)) {
           seen.add(block.id);
@@ -1108,6 +1356,44 @@ function accessedStorage(fn, core, scheduledHost) {
   body(fn.body);
   return result;
 }
+function appendContinuations(core, tasks, report) {
+  const continuations = core.programs.flatMap((program) => program.continuation ? [{ name: program.name, scope: program.continuation }] : []);
+  if (!continuations.length)
+    return tasks;
+  const programs = new Map(core.programs.map((program) => [program.name, program]));
+  const functions = new Map(core.functions.map((routine) => [routine.id, routine]));
+  const placements = tasks.map((task) => {
+    const roots = new Set;
+    for (const name of task.programs) {
+      const program = programs.get(name);
+      if (!program || program.background)
+        continue;
+      const entry = functions.get(program.entry);
+      if (entry)
+        for (const id of accessedStorage(entry, core))
+          roots.add(id);
+    }
+    return { task, roots, additions: [] };
+  });
+  for (const { name, scope } of continuations) {
+    const root = core.variables.find((variable) => variable.name === scope.instance && variable.span.file === scope.file);
+    if (!root) {
+      report(`Missing continuation owner ${scope.instance}.`);
+      continue;
+    }
+    const owners = placements.filter(({ roots }) => roots.has(root.id));
+    const [owner] = owners;
+    if (!owner || owners.length !== 1) {
+      report(`Continuation owner ${scope.instance} must belong to exactly one caller task.`, root.span);
+      continue;
+    }
+    owner.additions.push(name);
+  }
+  return placements.map(({ task, additions }) => ({
+    ...task,
+    programs: task.programs.concat(additions)
+  }));
+}
 
 // packages/compiler/backends/codesys/publication.ts
 var globals = (core) => core.variables.filter((variable) => variable.storage === "module" && variable.exported);
@@ -1168,49 +1454,12 @@ function planCodesys(core, deployment, value) {
     return {
       diagnostics: parsed.error.issues.map((issue) => diagnostic(`${issue.path.join(".")}: ${issue.message}`))
     };
-  const backgroundTasks = new Map;
-  for (const program of core.programs) {
-    if (!program.background)
-      continue;
-    const { priority, intervalNanoseconds } = program.background;
-    const name = `TsplcBackground_${priority}_${BigInt(intervalNanoseconds) / 1000000n}`;
-    const existing = backgroundTasks.get(name);
-    backgroundTasks.set(name, {
-      name,
-      priority,
-      intervalNanoseconds,
-      programs: [...existing?.programs ?? [], program.name]
-    });
-  }
-  deployment = { tasks: [...deployment.tasks, ...backgroundTasks.values()] };
   const options = parsed.data;
   const diagnostics = [];
   const report = (message, span) => {
     diagnostics.push(diagnostic(message, span));
   };
-  const callerTasks = deployment.tasks;
-  for (const continuation of core.programs.filter((program) => program.continuation)) {
-    const scope = continuation.continuation;
-    const root = core.variables.find((variable) => variable.name === scope.instance && variable.span.file === scope.file);
-    if (!root) {
-      report(`Missing continuation owner ${scope.instance}.`);
-      continue;
-    }
-    const owners = callerTasks.filter((task) => task.programs.some((name) => {
-      const program = core.programs.find((program) => program.name === name);
-      if (!program || program.background)
-        return false;
-      const fn = core.functions.find((fn) => fn.id === program.entry);
-      return fn && accessedStorage(fn, core).has(root.id);
-    }));
-    if (owners.length !== 1) {
-      report(`Continuation owner ${scope.instance} must belong to exactly one caller task.`, root.span);
-      continue;
-    }
-    deployment = {
-      tasks: deployment.tasks.map((task) => task.name === owners[0].name ? { ...task, programs: [...task.programs, continuation.name] } : task)
-    };
-  }
+  deployment = { tasks: schedulePrograms(core, deployment.tasks, report) };
   const http = new Map;
   for (const block of core.blocks)
     if (block.runtime?.kind === "http" || block.runtime?.kind === "rpc") {
@@ -1367,10 +1616,7 @@ function validateTasks(core, deployment, report) {
   const programs = new Map(core.programs.map((program) => [program.name, program]));
   const assignment = new Map;
   const taskNames = new Set;
-  const stateOwners = new Map;
-  const globals = new Map(core.variables.map((item) => [item.id, item]));
-  const functions = new Map(core.functions.map((item) => [item.id, item]));
-  const blockRuntimes = new Map(core.types.flatMap((type) => type.kind === "block" ? [[type.id, core.blocks.find((block) => block.id === type.block)?.runtime?.kind]] : []));
+  const checkOwnership = taskStorageOwnership(core, report);
   for (const task of deployment.tasks) {
     if (!isIecIdentifier(task.name))
       report(`Invalid task name ${task.name}.`);
@@ -1397,24 +1643,7 @@ function validateTasks(core, deployment, report) {
       if (assignment.has(name))
         report(`Program ${name} must belong to exactly one task.`);
       assignment.set(name, task.name);
-      const fn = functions.get(program.entry);
-      if (!fn)
-        throw new Error("Verified core has a missing entry.");
-      const host = program.background && core.variables.find((item) => item.name === program.background?.worker && item.span.file === fn.span.file && blockRuntimes.get(item.type) === "backgroundHost");
-      for (const id of accessedStorage(fn, core, host ? host.id : undefined)) {
-        const item = globals.get(id);
-        if (!item || item.storage === "constant")
-          continue;
-        if (blockRuntimes.get(item.type) === "mailbox")
-          continue;
-        const ownsWorker = program.background?.worker === item.name && item.span.file === fn.span.file;
-        if (program.background && (!ownsWorker || item.id === host?.id))
-          report(`Background task ${program.name} accesses scan-owned storage ${item.name}; pass value snapshots through the mailbox.`, item.span);
-        const owner = stateOwners.get(id);
-        if (owner && owner !== task.name)
-          report(`Storage ${item.name} is shared across cyclic tasks ${owner} and ${task.name}.`, item.span);
-        stateOwners.set(id, task.name);
-      }
+      checkOwnership(task.name, program);
     }
   }
   for (const name of programs.keys())
@@ -1442,7 +1671,7 @@ function validateStorage(core, options, report) {
   const blockHasInOut = (id) => {
     const block = blocks.get(id);
     return block.inputs.some((input) => input.mode === "inOut") || block.state.some((field) => {
-      const type = instancedBlock3(field.type, types);
+      const type = instancedBlock4(field.type, types);
       return type !== undefined && blockHasInOut(type.block);
     });
   };
@@ -1451,7 +1680,7 @@ function validateStorage(core, options, report) {
     if (layout.retainedBlocks.has(block.id) && blockHasInOut(block.id))
       report("Retained function blocks cannot contain direct or nested InOut references.", block.span);
   for (const variable of core.variables) {
-    const type = instancedBlock3(variable.type, types);
+    const type = instancedBlock4(variable.type, types);
     if (variable.retain && type && blockHasInOut(type.block))
       report("Retained function blocks cannot contain direct or nested InOut references.", variable.span);
   }
@@ -1543,174 +1772,6 @@ function validateConstants(core, report) {
   });
 }
 
-// packages/compiler/backends/codesys/types.ts
-import { instancedBlock as instancedBlock4 } from "@tsplc/compiler/ir";
-class CodesysTypes {
-  types;
-  objects = [];
-  names = new Map;
-  fields = new Map;
-  constructor(types, names, blockNames) {
-    this.types = types;
-    for (const type of types.values()) {
-      if (type.kind === "block") {
-        const name = blockNames.get(type.block);
-        if (!name)
-          throw new Error("Missing verified block name");
-        this.names.set(type.id, name);
-      }
-      if (["record", "array", "enum", "string"].includes(type.kind)) {
-        const label = type.id.split(":").at(-1);
-        if (type.kind === "record" || type.kind === "enum") {
-          const prefix = type.kind === "record" ? "ST" : "E";
-          this.names.set(type.id, names.allocateObject(prefix, label));
-        } else
-          this.names.set(type.id, names.allocate(`T_${label}`));
-      }
-      if (type.kind === "record" || type.kind === "enum") {
-        const names = new Names, fields = new Map;
-        for (const member of type.kind === "record" ? type.fields : type.members) {
-          fields.set(member.name, names.allocate(member.name, true));
-        }
-        this.fields.set(type.id, fields);
-      }
-    }
-    for (const type of types.values())
-      if (type.kind === "array" && instancedBlock4(type.id, types))
-        this.names.set(type.id, `ARRAY[${type.lowerBound}..${type.lowerBound + type.length - 1}] OF ${this.name(type.element)}`);
-    const emitted = new Set;
-    const emit = (type) => {
-      if (instancedBlock4(type.id, types) || !this.names.has(type.id) || emitted.has(type.id))
-        return;
-      if (type.kind === "array")
-        emit(this.type(type.element));
-      if (type.kind === "record") {
-        for (const field of type.fields)
-          emit(this.type(field.type));
-      }
-      emitted.add(type.id);
-      const name = this.name(type.id);
-      let declaration;
-      if (type.kind === "record") {
-        const fields = type.fields.map((field) => `    ${this.field(type.id, field.name)} : ${this.name(field.type)};`).join(`
-`);
-        declaration = `TYPE ${name} :
-STRUCT
-${fields}
-END_STRUCT
-END_TYPE
-`;
-      } else if (type.kind === "array") {
-        declaration = `TYPE ${name} : ARRAY[${type.lowerBound}..${type.lowerBound + type.length - 1}] OF ${this.name(type.element)};
-END_TYPE
-`;
-      } else if (type.kind === "string") {
-        declaration = `TYPE ${name} : ${type.encoding === "utf8" ? "STRING" : "WSTRING"}(${type.capacity});
-END_TYPE
-`;
-      } else if (type.kind === "enum") {
-        const members = type.members.map((member) => `    ${this.field(type.id, member.name)} := ${member.value}`).join(`,
-`);
-        declaration = `{attribute 'qualified_only'}
-{attribute 'strict'}
-TYPE ${name} : (
-${members}
-) DINT;
-END_TYPE
-`;
-      } else
-        throw new Error("Unsupported verified data type");
-      this.objects.push({ id: type.id, kind: "dataType", name, declaration });
-    };
-    for (const type of types.values())
-      emit(type);
-  }
-  type(id) {
-    const type = this.types.get(id);
-    if (!type)
-      throw new Error("Missing verified type");
-    return type;
-  }
-  name(id) {
-    return this.names.get(id) ?? id;
-  }
-  field(id, name) {
-    const field = this.fields.get(id)?.get(name);
-    if (!field)
-      throw new Error("Missing verified field");
-    return field;
-  }
-  declarationInitializer(value, id) {
-    const type = this.type(id);
-    if ((type.kind === "record" || type.kind === "array") && this.isZero(value))
-      return "";
-    return ` := ${this.literal(value, id)}`;
-  }
-  isZero(value) {
-    if (value.kind === "bool")
-      return !value.value;
-    if (value.kind === "integer")
-      return value.value === "0";
-    if (value.kind === "float")
-      return Object.is(value.value, 0);
-    if (value.kind === "string")
-      return value.value === "";
-    if (value.kind === "array")
-      return value.items.every((item) => this.isZero(item));
-    if (value.kind === "record")
-      return Object.values(value.fields).every((item) => this.isZero(item));
-    return false;
-  }
-  literal(value, id) {
-    const type = this.type(id);
-    if (type.kind === "enum" && value.kind === "integer") {
-      const member = type.members.find((member) => member.value === value.value);
-      if (!member)
-        throw new Error("Missing verified enum member");
-      return `${this.name(id)}.${this.field(id, member.name)}`;
-    }
-    if (type.kind === "string" && value.kind === "string") {
-      const wide = type.encoding === "utf16", quote = wide ? '"' : "'";
-      let text = "";
-      for (const char of value.value) {
-        const code = char.charCodeAt(0);
-        if (char === "$")
-          text += "$$";
-        else if (char === quote)
-          text += `$${char}`;
-        else if (code < 32 || code === 127)
-          text += `$${code.toString(16).toUpperCase().padStart(wide ? 4 : 2, "0")}`;
-        else
-          text += char;
-      }
-      return `${quote}${text}${quote}`;
-    }
-    if (type.kind === "array" && value.kind === "array") {
-      return `[${value.items.map((item) => this.literal(item, type.element)).join(", ")}]`;
-    }
-    if (type.kind === "record" && value.kind === "record") {
-      const fields = type.fields.map((field) => {
-        const initial = value.fields[field.name];
-        if (!initial)
-          throw new Error("Missing verified record initializer");
-        return `${this.field(id, field.name)} := ${this.literal(initial, field.type)}`;
-      });
-      return `(${fields.join(", ")})`;
-    }
-    if (type.kind === "duration" && value.kind === "duration") {
-      return `T#${BigInt(value.nanoseconds) / 1000000n}ms`;
-    }
-    if (type.kind === "calendar" && value.kind === "calendar") {
-      if (type.domain === "date")
-        return `D#${value.value}`;
-      if (type.domain === "timeOfDay")
-        return `TOD#${value.value}`;
-      return `DT#${value.value.replace("T", "-")}`;
-    }
-    return scalarLiteral(value, id);
-  }
-}
-
 // packages/compiler/backends/codesys/emit.ts
 function required(value) {
   if (value === undefined)
@@ -1734,7 +1795,7 @@ function emitCodesys(plan) {
 
 class CodesysEmitter {
   plan;
-  names = new Names;
+  names;
   networkName;
   rpcChannels = [];
   references = new Map;
@@ -1753,7 +1814,8 @@ class CodesysEmitter {
   routineScopes = new Map;
   targetTypes;
   numeric;
-  layout;
+  globals;
+  retainedVariables;
   constructor(plan) {
     this.plan = plan;
     const { core, options } = plan;
@@ -1762,19 +1824,15 @@ class CodesysEmitter {
       if (!fn.owner && [...accessedStorage(fn, core)].some((id) => persistent.has(id)))
         this.programRoutines.add(fn.id);
     }
-    for (const name of Object.values(options.programNames ?? {}))
-      this.names.reserve(name);
-    this.typeMap = new Map(core.types.map((type) => [type.id, type]));
+    const { names, typeMap, blockNames, targetTypes, globals, retainedVariables } = planGlobalNames(core, options.programNames);
+    this.names = names;
+    this.typeMap = typeMap;
+    this.blockNames = blockNames;
+    this.targetTypes = targetTypes;
+    this.globals = globals;
+    this.retainedVariables = retainedVariables;
     this.blocks = new Map(core.blocks.map((block) => [block.id, block]));
-    this.blockNames = new Map(core.blocks.map((block) => [
-      block.id,
-      block.standard ? standardBlocks[block.standard].native : this.names.allocateObject("FB", block.name)
-    ]));
-    for (const name of this.blockNames.values())
-      this.names.reserve(name);
-    this.targetTypes = new CodesysTypes(this.typeMap, this.names, this.blockNames);
     this.numeric = new NumericLowering(this.typeMap, (label) => this.names.allocate(label));
-    this.layout = storageLayout(core);
     this.objects.push(...this.targetTypes.objects);
   }
   emit() {
@@ -1899,7 +1957,7 @@ export const serviceChannels=${JSON.stringify(this.rpcChannels, null, 2)} as con
     const program = core.programs.find((item) => item.id === object.id);
     if (program)
       source = program.entry.split(":")[0] ?? "";
-    const group = this.layout.globalLists.find((item) => item.id === object.id);
+    const group = this.globals.find((item) => item.id === object.id);
     if (group) {
       source = group.variables[0]?.id.split(":")[0] ?? "";
     }
@@ -1915,23 +1973,18 @@ export const serviceChannels=${JSON.stringify(this.rpcChannels, null, 2)} as con
   }
   emitGlobals() {
     const { options } = this.plan;
-    const { layout, names, references, mappings, targetTypes, typeMap, objects } = this;
-    const hasExports = (group) => group.variables.some((variable) => variable.exported && !variable.exposure);
-    for (const group of layout.globalLists) {
-      const splitByStorage = layout.globalLists.some((other) => other.module === group.module && other.storage !== group.storage && hasExports(other));
-      const name = hasExports(group) ? names.allocate(pascalCase(splitByStorage ? `${group.module}-${group.storage}` : group.module)) : names.allocateObject("GVL", `${group.module}_${group.storage}`);
+    const { globals, references, mappings, targetTypes, typeMap, objects } = this;
+    for (const group of globals) {
+      const { name, fields } = group;
       const published = new Set(this.plan.publication[options.buildTarget]);
       const publish = group.variables.some((variable) => published.has(variable.id));
-      const fields = new Names;
-      for (const name of this.blockNames.values())
-        fields.reserve(name);
       const lines = [
         ...publish ? ["{attribute 'linkalways'}"] : [],
         "{attribute 'qualified_only'}",
         group.storage === "constants" ? "VAR_GLOBAL CONSTANT" : group.storage === "retained" ? "VAR_GLOBAL RETAIN" : "VAR_GLOBAL"
       ];
       for (const item of group.variables) {
-        const field = fields.allocate(item.name);
+        const field = required(fields.get(item.id));
         references.set(item.id, `${name}.${field}`);
         if (published.has(item.id))
           lines.push(`    {attribute 'symbol' := '${item.exposure ? "read" : "readwrite"}'}`);
@@ -2076,7 +2129,7 @@ export const serviceChannels=${JSON.stringify(this.rpcChannels, null, 2)} as con
         fields.reserve(objectName);
       for (const method of core.functions.filter((fn) => fn.owner?.block === block.id))
         functionNames.set(method.id, fields.allocate(method.name));
-      const native = block.standard && standardBlocks[block.standard];
+      const native = block.standard && standardBlocks2[block.standard];
       for (const item of [...block.inputs, ...block.outputs, ...block.state])
         mapped.set(item.id, native ? required([...native.inputs, ...native.outputs].find(([name]) => name === item.name))[1] : fields.allocate(item.name, true));
       if (block.runtime?.kind === "mailbox")
@@ -2171,7 +2224,7 @@ END_VAR`
       blocks,
       blockFields,
       numeric,
-      layout
+      retainedVariables
     } = this;
     const block = "inputs" in fn ? fn : undefined;
     const method = "owner" in fn ? fn.owner : undefined;
@@ -2450,8 +2503,8 @@ END_VAR`
       if (block.runtime?.kind === "mailbox")
         declaration.push("VAR", `    ${required(this.mailboxLocks.get(block.id))} : __XWORD;`, "END_VAR");
       section("VAR_OUTPUT", block.outputs);
-      section("VAR", block.state.filter((item) => !layout.retainedVariables.has(item.id)));
-      section("VAR RETAIN", block.state.filter((item) => layout.retainedVariables.has(item.id)));
+      section("VAR", block.state.filter((item) => !retainedVariables.has(item.id)));
+      section("VAR RETAIN", block.state.filter((item) => retainedVariables.has(item.id)));
     }
     if (declarations.length) {
       declaration.push(block || program ? "VAR_TEMP" : "VAR");
@@ -2582,5 +2635,5 @@ export {
   publicationSelectors
 };
 
-//# debugId=ADC5FCAD73E0D40364756E2164756E21
+//# debugId=C98587762BFC22D464756E2164756E21
 //# sourceMappingURL=codesys.js.map