node-red-contrib-me-vplc 1.0.0

package/project/backend/st_compiler.py

@@ -0,0 +1,1415 @@
+import copy
+import math
+import re
+import time
+import zipfile
+from datetime import datetime
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple
+
+
+class STCompileError(Exception):
+    pass
+
+
+class STArray:
+    def __init__(self, lower: int, upper: int, factory):
+        self.lower = int(lower)
+        self.upper = int(upper)
+        self._values = [factory() for _ in range(self.upper - self.lower + 1)]
+
+    def __getitem__(self, index: int) -> Any:
+        idx = int(index) - self.lower
+        if idx < 0 or idx >= len(self._values):
+            raise IndexError(f"ARRAY Index {index} ausserhalb {self.lower}..{self.upper}")
+        return self._values[idx]
+
+    def __setitem__(self, index: int, value: Any) -> None:
+        idx = int(index) - self.lower
+        if idx < 0 or idx >= len(self._values):
+            raise IndexError(f"ARRAY Index {index} ausserhalb {self.lower}..{self.upper}")
+        self._values[idx] = value
+
+    def to_list(self) -> List[Any]:
+        return [to_plain(v) for v in self._values]
+
+
+class STStruct:
+    def __init__(self, **values):
+        object.__setattr__(self, "_values", dict(values))
+
+    def __getattr__(self, name: str) -> Any:
+        values = object.__getattribute__(self, "_values")
+        key = find_key(values, name)
+        if key is None:
+            raise AttributeError(name)
+        return values[key]
+
+    def __setattr__(self, name: str, value: Any) -> None:
+        values = object.__getattribute__(self, "_values")
+        key = find_key(values, name) or name
+        values[key] = value
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {k: to_plain(v) for k, v in self._values.items()}
+
+
+def find_key(mapping: Dict[str, Any], name: str) -> Optional[str]:
+    if name in mapping:
+        return name
+    wanted = name.upper()
+    for key in mapping.keys():
+        if key.upper() == wanted:
+            return key
+    return None
+
+
+def to_plain(value: Any) -> Any:
+    if isinstance(value, STArray):
+        return value.to_list()
+    if isinstance(value, STStruct):
+        return value.to_dict()
+    if isinstance(value, FunctionBlockInstance):
+        return value.export_public()
+    if hasattr(value, "__dict__"):
+        return {k: to_plain(v) for k, v in value.__dict__.items() if not k.startswith("_")}
+    return value
+
+
+def clone_value(value: Any) -> Any:
+    if isinstance(value, FunctionBlockInstance):
+        return value.clone()
+    return copy.deepcopy(value)
+
+
+class TON:
+    def __init__(self) -> None:
+        self.IN = False
+        self.PT = 0
+        self.Q = False
+        self.ET = 0
+        self._start: Optional[float] = None
+
+    def __call__(self, IN: Optional[bool] = None, PT: Optional[int] = None, **kwargs) -> "TON":
+        if IN is not None:
+            self.IN = bool(IN)
+        if PT is not None:
+            self.PT = int(PT)
+        now = time.perf_counter()
+        if self.IN:
+            if self._start is None:
+                self._start = now
+            self.ET = int((now - self._start) * 1000.0)
+            self.Q = self.ET >= int(self.PT)
+        else:
+            self._start = None
+            self.ET = 0
+            self.Q = False
+        return self
+
+
+class TOF:
+    def __init__(self) -> None:
+        self.IN = False
+        self.PT = 0
+        self.Q = False
+        self.ET = 0
+        self._fall: Optional[float] = None
+        self._prev = False
+
+    def __call__(self, IN: Optional[bool] = None, PT: Optional[int] = None, **kwargs) -> "TOF":
+        if IN is not None:
+            self.IN = bool(IN)
+        if PT is not None:
+            self.PT = int(PT)
+        now = time.perf_counter()
+        if self.IN:
+            self.Q = True
+            self.ET = 0
+            self._fall = None
+        else:
+            if self._prev and self._fall is None:
+                self._fall = now
+            if self._fall is None:
+                self.Q = False
+                self.ET = 0
+            else:
+                self.ET = int((now - self._fall) * 1000.0)
+                self.Q = self.ET < int(self.PT)
+        self._prev = self.IN
+        return self
+
+
+class TP:
+    def __init__(self) -> None:
+        self.IN = False
+        self.PT = 0
+        self.Q = False
+        self.ET = 0
+        self._start: Optional[float] = None
+        self._prev = False
+
+    def __call__(self, IN: Optional[bool] = None, PT: Optional[int] = None, **kwargs) -> "TP":
+        if IN is not None:
+            self.IN = bool(IN)
+        if PT is not None:
+            self.PT = int(PT)
+        now = time.perf_counter()
+        rising = self.IN and not self._prev
+        if rising and not self.Q:
+            self._start = now
+            self.Q = True
+        if self.Q and self._start is not None:
+            self.ET = int((now - self._start) * 1000.0)
+            if self.ET >= int(self.PT):
+                self.Q = False
+                self.ET = int(self.PT)
+                self._start = None
+        else:
+            self.ET = 0
+        self._prev = self.IN
+        return self
+
+
+class R_TRIG:
+    def __init__(self) -> None:
+        self.CLK = False
+        self.Q = False
+        self.M = False
+
+    def __call__(self, CLK: Optional[bool] = None, **kwargs) -> "R_TRIG":
+        if CLK is not None:
+            self.CLK = bool(CLK)
+        self.Q = bool(self.CLK and not self.M)
+        self.M = bool(self.CLK)
+        return self
+
+
+class F_TRIG:
+    def __init__(self) -> None:
+        self.CLK = False
+        self.Q = False
+        self.M = False
+
+    def __call__(self, CLK: Optional[bool] = None, **kwargs) -> "F_TRIG":
+        if CLK is not None:
+            self.CLK = bool(CLK)
+        self.Q = bool((not self.CLK) and self.M)
+        self.M = bool(self.CLK)
+        return self
+
+
+class RS:
+    def __init__(self) -> None:
+        self.S = False
+        self.R1 = False
+        self.Q1 = False
+
+    def __call__(self, S: Optional[bool] = None, R1: Optional[bool] = None, **kwargs) -> "RS":
+        if S is not None:
+            self.S = bool(S)
+        if R1 is not None:
+            self.R1 = bool(R1)
+        self.Q1 = bool((self.Q1 or self.S) and not self.R1)
+        return self
+
+
+class SR:
+    def __init__(self) -> None:
+        self.S1 = False
+        self.R = False
+        self.Q1 = False
+
+    def __call__(self, S1: Optional[bool] = None, R: Optional[bool] = None, **kwargs) -> "SR":
+        if S1 is not None:
+            self.S1 = bool(S1)
+        if R is not None:
+            self.R = bool(R)
+        self.Q1 = bool(self.S1 or (self.Q1 and not self.R))
+        return self
+
+
+class CTU:
+    def __init__(self) -> None:
+        self.CU = False
+        self.RESET = False
+        self.PV = 0
+        self.Q = False
+        self.CV = 0
+        self._prev_cu = False
+
+    def __call__(self, CU: Optional[bool] = None, RESET: Optional[bool] = None, PV: Optional[int] = None, **kwargs) -> "CTU":
+        if CU is not None:
+            self.CU = bool(CU)
+        if RESET is not None:
+            self.RESET = bool(RESET)
+        if PV is not None:
+            self.PV = int(PV)
+        if self.RESET:
+            self.CV = 0
+        elif self.CU and not self._prev_cu:
+            self.CV += 1
+        self.Q = self.CV >= self.PV
+        self._prev_cu = self.CU
+        return self
+
+
+BUILTIN_FB = {
+    "TON": TON,
+    "TOF": TOF,
+    "TP": TP,
+    "R_TRIG": R_TRIG,
+    "F_TRIG": F_TRIG,
+    "RS": RS,
+    "SR": SR,
+    "CTU": CTU,
+}
+
+
+@dataclass
+class VarDecl:
+    name: str
+    type_name: str
+    default_text: Optional[str] = None
+    section: str = "VAR"
+    address: Optional[str] = None
+
+
+@dataclass
+class POU:
+    kind: str
+    name: str
+    return_type: Optional[str]
+    declarations: List[VarDecl] = field(default_factory=list)
+    statements: List[str] = field(default_factory=list)
+
+
+class FunctionBlockInstance:
+    def __init__(self, pou: POU, compiler: "STCompiler") -> None:
+        self._pou = pou
+        self._compiler = compiler
+        self._vars = compiler.instantiate_declarations(pou.declarations, include_inputs=True)
+        self._temp_decls = [d for d in pou.declarations if d.section == "VAR_TEMP"]
+        self._runtime: Optional[STRuntime] = None
+        if pou.kind == "FUNCTION":
+            self._vars[pou.name] = compiler.default_for_type(pou.return_type or "BOOL")
+
+    def clone(self) -> "FunctionBlockInstance":
+        other = FunctionBlockInstance.__new__(FunctionBlockInstance)
+        other._pou = self._pou
+        other._compiler = self._compiler
+        other._vars = clone_value(self._vars)
+        other._temp_decls = list(self._temp_decls)
+        other._runtime = None
+        return other
+
+    def __getattr__(self, name: str) -> Any:
+        key = find_key(self._vars, name)
+        if key is None:
+            raise AttributeError(name)
+        return self._vars[key]
+
+    def __setattr__(self, name: str, value: Any) -> None:
+        if name.startswith("_"):
+            object.__setattr__(self, name, value)
+        else:
+            key = find_key(self._vars, name) or name
+            self._vars[key] = value
+            # Wichtig für verschachtelte FBs: Wird ein FB-Eingang per
+            # Instanz.Attribut := Wert gesetzt, muss auch die bereits erzeugte
+            # Runtime-Umgebung der Instanz aktualisiert werden. Sonst arbeitet
+            # der FB im nächsten Aufruf mit alten Eingängen. Das war die Ursache,
+            # warum z. B. LDC.Enabled, LDSC.PushButtonOn und EFuseControl.INx
+            # im Example nicht korrekt wirksam wurden.
+            runtime = getattr(self, "_runtime", None)
+            env = getattr(runtime, "env", None)
+            if isinstance(env, dict):
+                env[key] = value
+                env[key.upper()] = value
+
+    def _reset_temp_vars(self) -> None:
+        # IEC 61131-3: VAR_TEMP ist pro Bausteinaufruf temporär und darf nicht
+        # zyklusübergreifend speichern. STAT/VAR und VAR_OUTPUT behalten ihren Zustand.
+        for decl in self._temp_decls:
+            self._vars[decl.name] = self._compiler.make_default_value(decl.type_name, decl.default_text)
+
+    def __call__(self, **params) -> Any:
+        if self._runtime is None:
+            self._runtime = STRuntime(self._compiler, self._vars)
+        self._reset_temp_vars()
+        self._runtime.refresh_env()
+        for key, value in params.items():
+            real_key = find_key(self._vars, key) or key
+            self._vars[real_key] = value
+            self._runtime.env[real_key] = value
+            self._runtime.env[real_key.upper()] = value
+        self._runtime.execute_block(self._pou.statements)
+        if self._pou.kind == "FUNCTION":
+            key = find_key(self._vars, self._pou.name) or self._pou.name
+            return self._vars.get(key)
+        return self
+
+    def export_public(self) -> Dict[str, Any]:
+        return {k: to_plain(v) for k, v in self._vars.items() if not k.startswith("_")}
+
+
+class STRuntime:
+    def __init__(self, compiler: "STCompiler", variables: Dict[str, Any]) -> None:
+        self.compiler = compiler
+        self.variables = variables
+        # Performance: environment once per runtime instead of once per expression.
+        # Scalar assignments keep this env synchronized in set_target().
+        self.env = self.make_env()
+
+    def refresh_env(self) -> None:
+        # Runtime-Umgebungen werden aus Performancegründen wiederverwendet.
+        # Vor jedem äußeren Bausteinaufruf müssen globale Werte und lokale
+        # Variablen wieder in die eval-Umgebung gespiegelt werden, sonst sehen
+        # verschachtelte FBs veraltete HMI-/GLOBAL-Werte.
+        for key, value in self.compiler.global_values.items():
+            self.env[key] = value
+            self.env[key.upper()] = value
+        for key, value in self.variables.items():
+            self.env[key] = value
+            self.env[key.upper()] = value
+
+    def execute_block(self, lines: List[str]) -> None:
+        i = 0
+        while i < len(lines):
+            line = lines[i].strip()
+            if not line:
+                i += 1
+                continue
+            upper = line.upper()
+            if upper.startswith("IF ") and "END_IF" in upper:
+                inline_match = re.match(r"IF\s+(.+?)\s+THEN\s+(.*?)\s*END_IF\s*$", line, flags=re.IGNORECASE | re.DOTALL)
+                if not inline_match:
+                    raise STCompileError(f"Inline-IF Syntax nicht erkannt: {line}")
+                if bool(self.eval_expr(inline_match.group(1).strip())):
+                    self.execute_block(self.compiler.split_statements(inline_match.group(2).strip()))
+                i += 1
+                continue
+            if upper.startswith("IF "):
+                branches, end_idx = self.collect_if(lines, i)
+                executed = False
+                for condition, block in branches:
+                    if condition is None or bool(self.eval_expr(condition)):
+                        self.execute_block(block)
+                        executed = True
+                        break
+                i = end_idx + 1
+                continue
+            if upper.startswith("FOR "):
+                var_name, start_expr, end_expr, step_expr, block, end_idx = self.collect_for(lines, i)
+                start_val = int(self.eval_expr(start_expr))
+                end_val = int(self.eval_expr(end_expr))
+                step_val = int(self.eval_expr(step_expr)) if step_expr else 1
+                if step_val == 0:
+                    raise STCompileError("FOR STEP darf nicht 0 sein.")
+                cmp = (lambda a, b: a <= b) if step_val > 0 else (lambda a, b: a >= b)
+                value = start_val
+                while cmp(value, end_val):
+                    self.set_target(var_name, value)
+                    self.execute_block(block)
+                    value += step_val
+                i = end_idx + 1
+                continue
+            if upper.startswith("WHILE "):
+                condition, block, end_idx = self.collect_while(lines, i)
+                guard = 0
+                while bool(self.eval_expr(condition)):
+                    self.execute_block(block)
+                    guard += 1
+                    if guard > 100000:
+                        raise STCompileError("WHILE Schutzlimit erreicht.")
+                i = end_idx + 1
+                continue
+            if upper.startswith("CASE "):
+                selector, branches, end_idx = self.collect_case(lines, i)
+                selector_value = self.eval_expr(selector)
+                selected_block = None
+                else_block = None
+                for labels, block in branches:
+                    if labels is None:
+                        else_block = block
+                        continue
+                    for label in labels:
+                        if self.eval_expr(label) == selector_value:
+                            selected_block = block
+                            break
+                    if selected_block is not None:
+                        break
+                if selected_block is None:
+                    selected_block = else_block
+                if selected_block is not None:
+                    self.execute_block(selected_block)
+                i = end_idx + 1
+                continue
+            if upper in {"ELSE", "END_IF", "END_FOR", "END_WHILE", "END_CASE"} or upper.startswith("ELSIF "):
+                return
+            self.execute_statement(line)
+            i += 1
+
+    def collect_if(self, lines: List[str], start: int) -> Tuple[List[Tuple[Optional[str], List[str]]], int]:
+        first = lines[start].strip()
+        condition = first[2:].strip()
+        if condition.upper().endswith("THEN"):
+            condition = condition[:-4].strip()
+        branches: List[Tuple[Optional[str], List[str]]] = [(condition, [])]
+        active = branches[-1][1]
+        depth = 0
+        for idx in range(start + 1, len(lines)):
+            line = lines[idx].strip()
+            upper = line.upper()
+            if upper.startswith("IF "):
+                depth += 1
+                active.append(line)
+                continue
+            if upper in {"END_IF", "END_IF;"}:
+                if depth == 0:
+                    return branches, idx
+                depth -= 1
+                active.append(line)
+                continue
+            if depth == 0 and upper.startswith("ELSIF "):
+                cond = line[5:].strip()
+                if cond.upper().endswith("THEN"):
+                    cond = cond[:-4].strip()
+                branches.append((cond, []))
+                active = branches[-1][1]
+                continue
+            if depth == 0 and upper in {"ELSE", "ELSE;"}:
+                branches.append((None, []))
+                active = branches[-1][1]
+                continue
+            active.append(line)
+        raise STCompileError("IF ohne END_IF gefunden.")
+
+    def collect_for(self, lines: List[str], start: int):
+        first = lines[start].strip().rstrip(";")
+        match = re.match(r"FOR\s+(.+?)\s*:=\s*(.+?)\s+TO\s+(.+?)(?:\s+BY\s+(.+?))?\s+DO\s*$", first, re.IGNORECASE)
+        if not match:
+            raise STCompileError(f"FOR Syntax nicht erkannt: {first}")
+        var_name, start_expr, end_expr, step_expr = match.group(1), match.group(2), match.group(3), match.group(4)
+        block: List[str] = []
+        depth = 0
+        for idx in range(start + 1, len(lines)):
+            line = lines[idx].strip()
+            upper = line.upper()
+            if upper.startswith("FOR "):
+                depth += 1
+                block.append(line)
+                continue
+            if upper in {"END_FOR", "END_FOR;"}:
+                if depth == 0:
+                    return var_name.strip(), start_expr.strip(), end_expr.strip(), (step_expr or "1").strip(), block, idx
+                depth -= 1
+                block.append(line)
+                continue
+            block.append(line)
+        raise STCompileError("FOR ohne END_FOR gefunden.")
+
+    def collect_while(self, lines: List[str], start: int):
+        first = lines[start].strip().rstrip(";")
+        match = re.match(r"WHILE\s+(.+?)\s+DO\s*$", first, re.IGNORECASE)
+        if not match:
+            raise STCompileError(f"WHILE Syntax nicht erkannt: {first}")
+        block: List[str] = []
+        depth = 0
+        for idx in range(start + 1, len(lines)):
+            line = lines[idx].strip()
+            upper = line.upper()
+            if upper.startswith("WHILE "):
+                depth += 1
+                block.append(line)
+                continue
+            if upper in {"END_WHILE", "END_WHILE;"}:
+                if depth == 0:
+                    return match.group(1).strip(), block, idx
+                depth -= 1
+                block.append(line)
+                continue
+            block.append(line)
+        raise STCompileError("WHILE ohne END_WHILE gefunden.")
+
+    def collect_case(self, lines: List[str], start: int):
+        first = lines[start].strip().rstrip(";")
+        match = re.match(r"CASE\s+(.+?)\s+OF\s*$", first, re.IGNORECASE)
+        if not match:
+            raise STCompileError(f"CASE Syntax nicht erkannt: {first}")
+        selector = match.group(1).strip()
+        branches: List[Tuple[Optional[List[str]], List[str]]] = []
+        active: Optional[List[str]] = None
+        depth_case = 0
+        depth_if = 0
+        depth_for = 0
+        depth_while = 0
+
+        def inside_nested_block() -> bool:
+            return depth_case > 0 or depth_if > 0 or depth_for > 0 or depth_while > 0
+
+        for idx in range(start + 1, len(lines)):
+            line = lines[idx].strip()
+            upper = line.upper().rstrip(";")
+
+            # CASE muss IF/ELSE/END_IF innerhalb eines CASE-Zweigs unverändert als normalen Code behalten.
+            # Vorher wurde jedes ELSE auf CASE-Ebene als CASE-ELSE interpretiert. Dadurch wurden IF-Blöcke
+            # innerhalb der CASE-Zweige zerschnitten und die Runtime stoppte mit "IF ohne END_IF gefunden".
+            if upper.startswith("IF "):
+                if active is not None:
+                    active.append(line)
+                depth_if += 1
+                # Einzeilige IFs mit END_IF direkt in derselben Zeile erhöhen die Tiefe nicht dauerhaft.
+                if "END_IF" in upper:
+                    depth_if = max(0, depth_if - 1)
+                continue
+            if upper.startswith("ELSIF "):
+                if active is not None:
+                    active.append(line)
+                continue
+            if upper == "ELSE" and depth_if > 0:
+                if active is not None:
+                    active.append(line)
+                continue
+            if upper == "END_IF":
+                if active is not None:
+                    active.append(line)
+                depth_if = max(0, depth_if - 1)
+                continue
+
+            if upper.startswith("FOR "):
+                if active is not None:
+                    active.append(line)
+                depth_for += 1
+                continue
+            if upper == "END_FOR":
+                if active is not None:
+                    active.append(line)
+                depth_for = max(0, depth_for - 1)
+                continue
+
+            if upper.startswith("WHILE "):
+                if active is not None:
+                    active.append(line)
+                depth_while += 1
+                continue
+            if upper == "END_WHILE":
+                if active is not None:
+                    active.append(line)
+                depth_while = max(0, depth_while - 1)
+                continue
+
+            if upper.startswith("CASE "):
+                if active is not None:
+                    active.append(line)
+                depth_case += 1
+                continue
+            if upper == "END_CASE":
+                if depth_case == 0 and not inside_nested_block():
+                    return selector, branches, idx
+                if active is not None:
+                    active.append(line)
+                depth_case = max(0, depth_case - 1)
+                continue
+
+            if not inside_nested_block() and upper == "ELSE":
+                branches.append((None, []))
+                active = branches[-1][1]
+                continue
+            if not inside_nested_block() and upper.startswith("ELSE "):
+                # IEC-ST erlaubt auch kompakte CASE-ELSE-Zweige wie:
+                #   ELSE CURRENT := 0; req := IN1;
+                # Diese Zeile ist kein normaler IF-ELSE, sondern der Default-Zweig des CASE.
+                branches.append((None, []))
+                active = branches[-1][1]
+                rest = line[4:].strip()
+                if rest:
+                    active.append(rest)
+                continue
+            # CASE label can be either on its own line:
+            #   0:
+            # or on the same line as the first statement:
+            #   0: req := IN1
+            #   BCC_OFF: nextState := BCC_ON
+            # Wichtig: Eine normale ST-Zuweisung wie "WAIT1 := wait" darf NICHT
+            # als CASE-Label "WAIT1" mit Rest "= wait" interpretiert werden.
+            # Deshalb akzeptieren wir nur Doppelpunkte, die nicht Teil von ":=" sind.
+            label_match = re.match(r"^(.+?)(?<!:):(?!\=)\s*(.*)$", line)
+            if not inside_nested_block() and label_match:
+                labels = [part.strip() for part in split_top_level(label_match.group(1), ",") if part.strip()]
+                branches.append((labels, []))
+                active = branches[-1][1]
+                rest = (label_match.group(2) or "").strip()
+                if rest:
+                    active.append(rest)
+                continue
+            if active is not None:
+                active.append(line)
+        raise STCompileError("CASE ohne END_CASE gefunden.")
+
+    def execute_statement(self, line: str) -> None:
+        line = line.strip().rstrip(";")
+        if not line:
+            return
+        call_match = re.match(r"^([A-Za-z_]\w*(?:\.[A-Za-z_]\w*)?)\s*\((.*)\)$", line, re.DOTALL)
+        if call_match and ":=" not in call_match.group(1):
+            target = call_match.group(1).strip()
+            arg_text = call_match.group(2)
+            positional_raw, inputs, outputs = self.parse_call_arguments_raw(arg_text)
+
+            pou_key = self.compiler.find_pou_key(target)
+            if pou_key and self.compiler.pous[pou_key].kind == "FUNCTION":
+                positional_values = [self.eval_expr(item) for item in positional_raw]
+                result = self.compiler.call_function_instance(target, positional_values, inputs)
+            else:
+                fb = self.eval_expr(target)
+                if not callable(fb):
+                    raise STCompileError(f"{target} ist nicht aufrufbar.")
+
+                positional_output_bindings: Dict[str, str] = {}
+                if positional_raw:
+                    input_names: List[str] = []
+                    output_names: List[str] = []
+                    if isinstance(fb, FunctionBlockInstance):
+                        input_names = [d.name for d in fb._pou.declarations if d.section.startswith("VAR_INPUT") or d.section == "VAR_IN_OUT"]
+                        output_names = [d.name for d in fb._pou.declarations if d.section.startswith("VAR_OUTPUT")]
+                    elif hasattr(fb, "__dict__"):
+                        input_names = [name for name in fb.__dict__.keys() if not name.startswith("_")]
+
+                    for name, expr in zip(input_names, positional_raw):
+                        inputs[name] = self.eval_expr(expr)
+
+                    # Einige im Example verwendete Aufrufe nutzen den letzten
+                    # positionalen Parameter als Zielvariable für den ersten
+                    # Ausgang, z. B.:
+                    #   HyX(A, B, H, CMP_Type#GT, ResultVar);
+                    # Das entspricht praktisch Q => ResultVar und muss nach dem
+                    # FB-Aufruf zurückgeschrieben werden.
+                    extra_positionals = positional_raw[len(input_names):]
+                    for out_name, dest in zip(output_names, extra_positionals):
+                        positional_output_bindings[out_name] = dest
+
+                result = fb(**inputs)
+                outputs.update(positional_output_bindings)
+
+            source = result if result is not None else self.eval_expr(target)
+            for out_name, dest in outputs.items():
+                try:
+                    value = getattr(source, out_name)
+                except Exception:
+                    value = getattr(self.eval_expr(target), out_name)
+                self.set_target(dest, value)
+            return
+        if ":=" in line:
+            left, right = line.split(":=", 1)
+            self.set_target(left.strip(), self.eval_expr(right.strip()))
+            return
+        value = self.eval_expr(line)
+        if callable(value):
+            value()
+
+    def parse_call_arguments_raw(self, text: str) -> Tuple[List[str], Dict[str, Any], Dict[str, str]]:
+        positional: List[str] = []
+        inputs: Dict[str, Any] = {}
+        outputs: Dict[str, str] = {}
+        for part in split_top_level(text, ","):
+            item = part.strip()
+            if not item:
+                continue
+            if "=>" in item:
+                key, dest = item.split("=>", 1)
+                outputs[key.strip()] = dest.strip()
+            elif ":=" in item:
+                key, expr = item.split(":=", 1)
+                inputs[key.strip()] = self.eval_expr(expr.strip())
+            else:
+                positional.append(item)
+        return positional, inputs, outputs
+
+    def parse_call_arguments(self, text: str) -> Tuple[List[Any], Dict[str, Any], Dict[str, str]]:
+        positional: List[Any] = []
+        inputs: Dict[str, Any] = {}
+        outputs: Dict[str, str] = {}
+        for part in split_top_level(text, ","):
+            if not part.strip():
+                continue
+            if "=>" in part:
+                key, dest = part.split("=>", 1)
+                outputs[key.strip()] = dest.strip()
+            elif ":=" in part:
+                key, expr = part.split(":=", 1)
+                inputs[key.strip()] = self.eval_expr(expr.strip())
+            else:
+                positional.append(self.eval_expr(part.strip()))
+        return positional, inputs, outputs
+
+    def parse_call_params(self, text: str) -> Dict[str, Any]:
+        _, inputs, _ = self.parse_call_arguments(text)
+        return inputs
+
+    def eval_expr(self, expr: str) -> Any:
+        text = expr.strip().rstrip(";")
+        if not text:
+            return None
+        try:
+            code = self.compiler.compile_expr(text)
+            return eval(code, {"__builtins__": {}}, self.env)
+        except Exception as exc:
+            raise STCompileError(f"Ausdruck nicht auswertbar: '{expr}' -> {exc}") from exc
+
+    def make_env(self) -> Dict[str, Any]:
+        env: Dict[str, Any] = {
+            "ABS": abs,
+            "MIN": min,
+            "MAX": max,
+            "LIMIT": lambda mn, v, mx: max(mn, min(v, mx)),
+            "SEL": lambda g, in0, in1: in1 if g else in0,
+            "MUX": lambda k, *args: args[int(k)],
+            "INT": int,
+            "DINT": int,
+            "REAL": float,
+            "LREAL": float,
+            "BOOL": bool,
+            "INT_TO_REAL": float,
+            "REAL_TO_INT": lambda x: int(round(x)),
+            "DINT_TO_REAL": float,
+            "REAL_TO_DINT": lambda x: int(round(x)),
+            "BYTE_TO_INT": int,
+            "WORD_TO_INT": int,
+            "BIT": lambda value, bit: (int(value) >> int(bit)) & 1,
+            "SIN": math.sin,
+            "COS": math.cos,
+            "TAN": math.tan,
+            "SQRT": math.sqrt,
+        }
+        for key, value in self.compiler.constants.items():
+            env[key] = value
+            env[key.upper()] = value
+        for key, value in self.compiler.global_values.items():
+            env[key] = value
+            env[key.upper()] = value
+        for key, value in self.variables.items():
+            env[key] = value
+            env[key.upper()] = value
+        for name, pou in self.compiler.pous.items():
+            if pou.kind == "FUNCTION":
+                env[name] = self.compiler.make_function_callable(pou)
+                env[name.upper()] = env[name]
+        return env
+
+    def set_target(self, target: str, value: Any) -> None:
+        target = target.strip()
+        # Simple variable
+        if re.fullmatch(r"[A-Za-z_]\w*", target):
+            key = find_key(self.variables, target)
+            if key is not None:
+                self.variables[key] = value
+                self.env[key] = value
+                self.env[key.upper()] = value
+            else:
+                gkey = find_key(self.compiler.global_values, target)
+                if gkey is not None:
+                    self.compiler.global_values[gkey] = value
+                    self.env[gkey] = value
+                    self.env[gkey.upper()] = value
+                else:
+                    self.variables[target] = value
+                    self.env[target] = value
+                    self.env[target.upper()] = value
+            return
+        # Indexed target: ARR[i]
+        m = re.match(r"^(.+)\[([^\]]+)\]$", target)
+        if m:
+            arr = self.eval_expr(m.group(1).strip())
+            idx = self.eval_expr(m.group(2).strip())
+            arr[idx] = value
+            return
+        # Attribute target: Inst.Out or Struct.Field
+        if "." in target:
+            obj_expr, attr = target.rsplit(".", 1)
+            obj = self.eval_expr(obj_expr.strip())
+            attr_name = attr.strip()
+            setattr(obj, attr_name, value)
+            # Zusätzliche Absicherung für Objekte mit vorbereiteter Runtime.
+            # FunctionBlockInstance.__setattr__ synchronisiert bereits, aber
+            # STStruct/native Objekte können ebenfalls eine _runtime besitzen.
+            runtime = getattr(obj, "_runtime", None)
+            env = getattr(runtime, "env", None)
+            vars_dict = getattr(obj, "_vars", None)
+            if isinstance(env, dict):
+                key = find_key(vars_dict, attr_name) if isinstance(vars_dict, dict) else attr_name
+                key = key or attr_name
+                env[key] = value
+                env[key.upper()] = value
+            return
+        raise STCompileError(f"Zuweisungsziel nicht unterstuetzt: {target}")
+
+
+class STProgram:
+    def __init__(self, compiler: "STCompiler", main: POU, source_files: List[str]) -> None:
+        self.compiler = compiler
+        self.main = main
+        self.name = main.name
+        self.source_files = source_files
+        self.variables = compiler.global_values
+        self.variables.update(compiler.instantiate_declarations(main.declarations, include_inputs=True))
+        self.statements = main.statements
+        self.last_error: Optional[str] = None
+        self._runtime = STRuntime(self.compiler, self.variables)
+
+    def execute(self, inputs: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        if inputs:
+            for key, value in inputs.items():
+                real_key = find_key(self.variables, key) or key
+                self.variables[real_key] = value
+                self._runtime.env[real_key] = value
+                self._runtime.env[real_key.upper()] = value
+        try:
+            self._runtime.refresh_env()
+            self._runtime.execute_block(self.statements)
+            self.last_error = None
+        except Exception as exc:
+            self.last_error = str(exc)
+            raise
+        return {k: to_plain(v) for k, v in self.variables.items()}
+
+
+class STCompiler:
+    SIMPLE_TYPES = {"BOOL", "BYTE", "WORD", "DWORD", "INT", "DINT", "SINT", "UINT", "UDINT", "REAL", "LREAL", "TIME", "STRING"}
+
+    def __init__(self) -> None:
+        self.pous: Dict[str, POU] = {}
+        self.struct_types: Dict[str, List[VarDecl]] = {}
+        self.alias_types: Dict[str, str] = {}
+        self.constants: Dict[str, Any] = {}
+        self.global_declarations: List[VarDecl] = []
+        self.global_values: Dict[str, Any] = {}
+        self._expr_cache: Dict[str, Any] = {}
+        self.compile_log: List[Dict[str, Any]] = []
+
+    def log(self, level: str, message: str, **details: Any) -> None:
+        entry: Dict[str, Any] = {
+            "time": datetime.now().strftime("%H:%M:%S.%f")[:-3],
+            "level": level.upper(),
+            "message": message,
+        }
+        if details:
+            entry["details"] = {key: to_plain(value) for key, value in details.items()}
+        self.compile_log.append(entry)
+
+    def info(self, message: str, **details: Any) -> None:
+        self.log("INFO", message, **details)
+
+    def warn(self, message: str, **details: Any) -> None:
+        self.log("WARN", message, **details)
+
+    def error(self, message: str, **details: Any) -> None:
+        self.log("ERROR", message, **details)
+
+    @staticmethod
+    def compile_path(path: Path) -> STProgram:
+        files: List[Tuple[str, str]] = []
+        if path.suffix.lower() == ".zip":
+            with zipfile.ZipFile(path, "r") as archive:
+                for name in archive.namelist():
+                    if name.lower().endswith(".st") and not name.endswith("/"):
+                        raw = archive.read(name)
+                        files.append((name, raw.decode("utf-8", errors="replace")))
+        elif path.suffix.lower() == ".st":
+            files.append((path.name, path.read_text(encoding="utf-8", errors="replace")))
+        else:
+            files.append((path.name, path.read_text(encoding="utf-8", errors="replace")))
+        if not files:
+            raise STCompileError("Keine ST-Dateien im Projekt gefunden.")
+        return STCompiler.compile_sources(files)
+
+    @staticmethod
+    def compile_sources(files: List[Tuple[str, str]]) -> STProgram:
+        compiler = STCompiler()
+        source_files = [name for name, _ in files]
+        compiler.info("Compiler gestartet", source_files=len(files), files=source_files)
+        try:
+            for name, content in files:
+                compiler.info("Quelldatei geladen", file=name, chars=len(content), lines=len(content.splitlines()))
+
+            full_source = "\n".join(content for _, content in files)
+            compiler.info("Quellen zusammengeführt", chars=len(full_source), lines=len(full_source.splitlines()))
+
+            clean_source = compiler.remove_comments(full_source)
+            compiler.info("Kommentare entfernt", chars=len(clean_source), lines=len(clean_source.splitlines()))
+
+            compiler.parse_types(clean_source)
+            compiler.info(
+                "Datentypen ausgewertet",
+                structs=len(compiler.struct_types),
+                aliases=len(compiler.alias_types),
+                constants=len(compiler.constants),
+                struct_names=sorted(compiler.struct_types.keys()),
+                alias_names=sorted(compiler.alias_types.keys()),
+            )
+
+            compiler.extract_global_declarations(clean_source)
+            compiler.info("Globale Deklarationen ausgewertet", variables=len(compiler.global_declarations))
+
+            compiler.parse_pous(clean_source)
+            compiler.info("POUs ausgewertet", count=len(compiler.pous), names=[f"{p.kind} {p.name}" for p in compiler.pous.values()])
+
+            compiler.global_values = compiler.instantiate_declarations(compiler.global_declarations, include_inputs=True)
+            compiler.info("Globale Variablen instanziiert", variables=len(compiler.global_values))
+
+            if not compiler.pous:
+                decls, code = compiler.extract_vars_and_code(clean_source)
+                statements = compiler.split_statements(code)
+                main = POU(kind="PROGRAM", name="Main", return_type=None, declarations=decls, statements=statements)
+                compiler.pous[main.name] = main
+                compiler.warn("Kein PROGRAM/FB/FUNCTION gefunden, Fallback PROGRAM Main erzeugt", variables=len(decls), statements=len(statements))
+
+            program = compiler.find_main_program()
+            compiler.info("Main PROGRAM ausgewählt", program=program.name)
+
+            for pou in compiler.pous.values():
+                compiler.info(
+                    "POU vorbereitet",
+                    kind=pou.kind,
+                    name=pou.name,
+                    return_type=pou.return_type or "-",
+                    variables=len(pou.declarations),
+                    statements=len(pou.statements),
+                    variable_names=[decl.name for decl in pou.declarations],
+                )
+
+            result = STProgram(compiler, program, source_files)
+            compiler.info(
+                "Compiler abgeschlossen",
+                program=program.name,
+                runtime_variables=len(result.variables),
+                statements=len(program.statements),
+                optimized_runtime=True,
+            )
+            return result
+        except Exception as exc:
+            compiler.error("Compiler abgebrochen", error=str(exc), error_type=type(exc).__name__)
+            if isinstance(exc, STCompileError):
+                setattr(exc, "compile_log", compiler.compile_log)
+                raise
+            wrapped = STCompileError(str(exc))
+            setattr(wrapped, "compile_log", compiler.compile_log)
+            raise wrapped from exc
+
+    def compile_expr(self, expr: str):
+        cached = self._expr_cache.get(expr)
+        if cached is not None:
+            return cached
+        text = self.replace_literals(expr)
+        text = re.sub(r"\b([A-Za-z_]\w*)#([A-Za-z_]\w*)\b", lambda m: str(self.constants.get(f"{m.group(1)}#{m.group(2)}", self.constants.get(m.group(2), 0))), text)
+        text = re.sub(r"\b([A-Za-z_]\w*)\.(\d+)\b", r"BIT(\1, \2)", text)
+        text = re.sub(r"\bTRUE\b", "True", text, flags=re.IGNORECASE)
+        text = re.sub(r"\bFALSE\b", "False", text, flags=re.IGNORECASE)
+        text = re.sub(r"\bAND\b", " and ", text, flags=re.IGNORECASE)
+        text = re.sub(r"\bOR\b", " or ", text, flags=re.IGNORECASE)
+        text = re.sub(r"\bXOR\b", " != ", text, flags=re.IGNORECASE)
+        text = re.sub(r"\bNOT\b", " not ", text, flags=re.IGNORECASE)
+        text = re.sub(r"\bMOD\b", " % ", text, flags=re.IGNORECASE)
+        text = text.replace("<>", "!=")
+        text = re.sub(r"(?<![:<>!])=(?!=)", "==", text).strip()
+        try:
+            code = compile(text, "<st-expression>", "eval")
+        except SyntaxError as exc:
+            raise STCompileError(f"Ausdruck nicht kompilierbar: '{expr}' -> {exc}") from exc
+        self._expr_cache[expr] = code
+        return code
+
+    def find_main_program(self) -> POU:
+        programs = [p for p in self.pous.values() if p.kind == "PROGRAM"]
+        if not programs:
+            raise STCompileError("Kein PROGRAM gefunden. Bitte ein PROGRAM ... END_PROGRAM anlegen.")
+        for p in programs:
+            if p.name.upper() in {"PLC_PRG", "MAIN", "PRG"}:
+                return p
+        return programs[0]
+
+    def parse_types(self, source: str) -> None:
+        for match in re.finditer(r"\bTYPE\b(.*?)\bEND_TYPE\b", source, flags=re.IGNORECASE | re.DOTALL):
+            block = match.group(1)
+            # STRUCT datatypes
+            for sm in re.finditer(r"(\w+)\s*:\s*STRUCT(.*?)END_STRUCT\s*;?", block, flags=re.IGNORECASE | re.DOTALL):
+                name = sm.group(1)
+                decls = self.parse_var_lines(sm.group(2), "STRUCT")
+                self.struct_types[name] = decls
+            # ENUM / alias datatypes, e.g. TYPE X : INT ( A := 0, B := 1 ); END_TYPE or TYPE E : (A,B); END_TYPE
+            for em in re.finditer(r"(\w+)\s*:\s*(?:(\w+)\s*)?\((.*?)\)\s*;?", block, flags=re.IGNORECASE | re.DOTALL):
+                type_name = em.group(1)
+                base_type = em.group(2) or "INT"
+                enum_body = em.group(3)
+                self.alias_types[type_name] = base_type
+                value = 0
+                for raw_item in split_top_level(enum_body, ","):
+                    item = raw_item.strip()
+                    if not item:
+                        continue
+                    if ":=" in item:
+                        const_name, const_expr = item.split(":=", 1)
+                        const_name = const_name.strip()
+                        value = int(self.literal(const_expr.strip()))
+                    else:
+                        const_name = item.strip()
+                    if const_name:
+                        self.constants[const_name] = value
+                        self.constants[f"{type_name}#{const_name}"] = value
+                    value += 1
+            # Simple alias, e.g. TYPE X : INT; END_TYPE
+            for am in re.finditer(r"(\w+)\s*:\s*(\w+)\s*;", block, flags=re.IGNORECASE):
+                name, base = am.group(1), am.group(2)
+                if name not in self.struct_types:
+                    self.alias_types[name] = base
+
+    def extract_global_declarations(self, source: str) -> None:
+        self.global_declarations = []
+        var_pattern = re.compile(r"\b(VAR_GLOBAL(?:\s+CONSTANT)?)\b(.*?)\bEND_VAR\b", flags=re.IGNORECASE | re.DOTALL)
+        for block in var_pattern.finditer(source):
+            section = block.group(1).upper().replace(" ", "_")
+            self.global_declarations.extend(self.parse_var_lines(block.group(2), section))
+
+    def parse_pous(self, source: str) -> None:
+        pattern = re.compile(
+            r"\b(FUNCTION_BLOCK|FUNCTION|PROGRAM)\s+(\w+)(?:\s*:\s*(\w+))?(.*?)(?:\bEND_FUNCTION_BLOCK\b|\bEND_FUNCTION\b|\bEND_PROGRAM\b)",
+            flags=re.IGNORECASE | re.DOTALL,
+        )
+        for match in pattern.finditer(source):
+            kind = match.group(1).upper()
+            name = match.group(2)
+            return_type = match.group(3)
+            body = match.group(4)
+            decls, code = self.extract_vars_and_code(body)
+            pou = POU(kind=kind, name=name, return_type=return_type, declarations=decls, statements=self.split_statements(code))
+            self.pous[name] = pou
+
+    def remove_comments(self, source: str) -> str:
+        source = re.sub(r"\(\*.*?\*\)", "", source, flags=re.DOTALL)
+        source = re.sub(r"//.*", "", source)
+        return source
+
+    def extract_vars_and_code(self, body: str) -> Tuple[List[VarDecl], str]:
+        declarations: List[VarDecl] = []
+        code = body
+        var_pattern = re.compile(r"\b(VAR(?:_INPUT|_OUTPUT|_IN_OUT|_GLOBAL|_TEMP|_EXTERNAL)?(?:\s+CONSTANT)?)\b(.*?)\bEND_VAR\b", flags=re.IGNORECASE | re.DOTALL)
+        blocks = list(var_pattern.finditer(body))
+        for block in blocks:
+            section = block.group(1).upper().replace(" ", "_")
+            declarations.extend(self.parse_var_lines(block.group(2), section))
+        for block in reversed(blocks):
+            code = code[:block.start()] + "\n" + code[block.end():]
+        return declarations, code
+
+    def parse_var_lines(self, block: str, section: str) -> List[VarDecl]:
+        block = re.sub(r"\{[^{}]*\}", "", block)
+        decls: List[VarDecl] = []
+        for raw in split_top_level(block, ";"):
+            line = raw.strip()
+            if not line or ":" not in line:
+                continue
+            names_part, type_part = line.split(":", 1)
+            default_text = None
+            if ":=" in type_part:
+                type_name, default_text = type_part.split(":=", 1)
+            else:
+                type_name = type_part
+            type_name = type_name.strip()
+            for raw_name in names_part.split(","):
+                raw_name = raw_name.strip()
+                if not raw_name:
+                    continue
+                address = None
+                at_match = re.match(r"(?:(\w+)\s+)?AT\s+([^\s]+)$", raw_name, flags=re.IGNORECASE)
+                if at_match:
+                    name = at_match.group(1) or at_match.group(2).replace("%", "_").replace(".", "_")
+                    address = at_match.group(2)
+                else:
+                    name = raw_name
+                    if " AT " in raw_name.upper():
+                        parts = re.split(r"\s+AT\s+", raw_name, flags=re.IGNORECASE)
+                        name = parts[0].strip()
+                        address = parts[1].strip()
+                decls.append(VarDecl(name=name, type_name=type_name, default_text=(default_text or None), section=section, address=address))
+        return decls
+
+    def instantiate_declarations(self, declarations: List[VarDecl], include_inputs: bool = True) -> Dict[str, Any]:
+        variables: Dict[str, Any] = {}
+        for decl in declarations:
+            if not include_inputs and decl.section == "VAR_INPUT":
+                continue
+            if decl.section == "VAR_EXTERNAL":
+                continue
+            variables[decl.name] = self.make_default_value(decl.type_name, decl.default_text)
+        return variables
+
+    def make_default_value(self, type_name: str, default_text: Optional[str] = None) -> Any:
+        type_clean = type_name.strip()
+        type_clean = self.alias_types.get(type_clean, type_clean)
+        array_match = re.match(r"ARRAY\s*\[\s*(-?\d+)\s*\.\.\s*(-?\d+)\s*\]\s+OF\s+(.+)$", type_clean, flags=re.IGNORECASE)
+        if array_match:
+            lower, upper, inner_type = int(array_match.group(1)), int(array_match.group(2)), array_match.group(3).strip()
+            defaults = []
+            if default_text:
+                defaults = [self.literal(part.strip()) for part in split_top_level(default_text, ",") if part.strip()]
+
+            def factory(counter={"i": 0}):
+                idx = counter["i"]
+                counter["i"] += 1
+                if idx < len(defaults):
+                    return clone_value(defaults[idx])
+                return self.make_default_value(inner_type, None)
+
+            return STArray(lower, upper, factory)
+        upper_type = type_clean.upper()
+        if default_text is not None:
+            return self.literal(default_text)
+        if upper_type in BUILTIN_FB:
+            return BUILTIN_FB[upper_type]()
+        pou_key = self.find_pou_key(type_clean)
+        if pou_key and self.pous[pou_key].kind in {"FUNCTION_BLOCK", "FUNCTION"}:
+            return FunctionBlockInstance(self.pous[pou_key], self)
+        struct_key = self.find_struct_key(type_clean)
+        if struct_key:
+            values = self.instantiate_declarations(self.struct_types[struct_key])
+            return STStruct(**values)
+        return self.default_for_type(type_clean)
+
+    def default_for_type(self, type_name: str) -> Any:
+        type_name = self.alias_types.get((type_name or "").strip(), type_name)
+        upper_type = (type_name or "").strip().upper()
+        if upper_type == "BOOL":
+            return False
+        if upper_type in {"REAL", "LREAL"}:
+            return 0.0
+        if upper_type in {"STRING"}:
+            return ""
+        if upper_type in {"TIME", "TIME_OF_DAY", "DATE"}:
+            return 0
+        if upper_type in {"BYTE", "WORD", "DWORD", "INT", "DINT", "SINT", "UINT", "UDINT", "LINT", "ULINT"}:
+            return 0
+        return 0
+
+    def find_pou_key(self, name: str) -> Optional[str]:
+        return find_key(self.pous, name)
+
+    def find_struct_key(self, name: str) -> Optional[str]:
+        return find_key(self.struct_types, name)
+
+    def literal(self, text: str) -> Any:
+        value = text.strip().rstrip(";")
+        upper = value.upper().replace(" ", "")
+        if upper == "TRUE":
+            return True
+        if upper == "FALSE":
+            return False
+        if value in self.constants:
+            return self.constants[value]
+        if upper in {k.upper(): v for k, v in self.constants.items()}:
+            for k, v in self.constants.items():
+                if k.upper() == upper:
+                    return v
+        if upper.startswith("T#") or upper.startswith("TIME#"):
+            return parse_time_literal(upper)
+        if upper.startswith("16#"):
+            return int(upper[3:].replace("_", ""), 16)
+        if re.match(r"^(B|W|DW|L)?#16#", upper):
+            return int(upper.split("#16#", 1)[1].replace("_", ""), 16)
+        if upper.startswith("2#"):
+            return int(upper[2:].replace("_", ""), 2)
+        try:
+            normalized = value.replace("_", "")
+            if "." in normalized or "E" in normalized.upper():
+                return float(normalized)
+            return int(normalized)
+        except ValueError:
+            if (value.startswith("'") and value.endswith("'")) or (value.startswith('"') and value.endswith('"')):
+                return value[1:-1]
+            return value
+
+    def replace_literals(self, text: str) -> str:
+        def repl_time(match):
+            return str(parse_time_literal(match.group(0).upper().replace(" ", "")))
+
+        text = re.sub(r"\b(?:T|TIME)#(?:\d+D)?(?:\d+H)?(?:\d+M(?!S))?(?:\d+S)?(?:\d+MS)?\b", repl_time, text, flags=re.IGNORECASE)
+        text = re.sub(r"\b(?:B|W|DW|L)?#16#([0-9A-Fa-f_]+)\b", lambda m: str(int(m.group(1).replace("_", ""), 16)), text)
+        text = re.sub(r"\b16#([0-9A-Fa-f_]+)\b", lambda m: str(int(m.group(1).replace("_", ""), 16)), text)
+        text = re.sub(r"\b2#([01_]+)\b", lambda m: str(int(m.group(1).replace("_", ""), 2)), text)
+        return text
+
+    def make_function_callable(self, pou: POU):
+        def call_function(*args, **kwargs):
+            inst = FunctionBlockInstance(pou, self)
+            input_decls = [d for d in pou.declarations if d.section.startswith("VAR_INPUT")]
+            for decl, value in zip(input_decls, args):
+                setattr(inst, decl.name, value)
+            result = inst(**kwargs)
+            if pou.return_type:
+                key = find_key(inst._vars, pou.name) or pou.name
+                return inst._vars.get(key)
+            return result
+        return call_function
+
+    def call_function_instance(self, name: str, args: List[Any], kwargs: Dict[str, Any]) -> Any:
+        key = self.find_pou_key(name)
+        if not key or self.pous[key].kind != "FUNCTION":
+            raise STCompileError(f"Funktion {name} nicht gefunden.")
+        pou = self.pous[key]
+        inst = FunctionBlockInstance(pou, self)
+        input_decls = [d for d in pou.declarations if d.section.startswith("VAR_INPUT")]
+        for decl, value in zip(input_decls, args):
+            setattr(inst, decl.name, value)
+        for k, v in kwargs.items():
+            setattr(inst, k, v)
+        inst()
+        if pou.return_type:
+            rkey = find_key(inst._vars, pou.name) or pou.name
+            return inst._vars.get(rkey)
+        return inst
+
+    def split_statements(self, code: str) -> List[str]:
+        normalized = code.replace("\r\n", "\n").replace("\r", "\n")
+        lines: List[str] = []
+        buffer = ""
+        paren_depth = 0
+        pending_ctrl = ""
+        pending_until: Optional[str] = None
+
+        def flush_buffer() -> None:
+            nonlocal buffer, paren_depth
+            if buffer.strip():
+                lines.append(buffer.strip().rstrip(";"))
+            buffer = ""
+            paren_depth = 0
+
+        for raw_line in normalized.split("\n"):
+            line = raw_line.strip()
+            if not line:
+                continue
+            upper = line.upper().rstrip(";")
+
+            if pending_ctrl:
+                pending_ctrl = (pending_ctrl + " " + line).strip()
+                if pending_until and re.search(r"\b" + re.escape(pending_until) + r"\b", pending_ctrl, flags=re.IGNORECASE):
+                    if pending_until in {"THEN", "DO", "OF"}:
+                        # keep keyword but remove everything after it onto following normal text only if needed
+                        pass
+                    lines.append(pending_ctrl.rstrip(";"))
+                    pending_ctrl = ""
+                    pending_until = None
+                continue
+
+            # CASE labels are separate statements: Label: or A, B:
+            if re.match(r"^[A-Za-z_]\w*(?:#[A-Za-z_]\w*)?(?:\s*,\s*[A-Za-z_]\w*(?:#[A-Za-z_]\w*)?)*:$", line):
+                flush_buffer()
+                lines.append(line.rstrip(";"))
+                continue
+
+            if upper in {"ELSE", "END_IF", "END_FOR", "END_WHILE", "END_CASE"}:
+                flush_buffer()
+                lines.append(upper)
+                continue
+
+            if upper.startswith("IF ") or upper.startswith("ELSIF "):
+                flush_buffer()
+                if re.search(r"\bTHEN\b", line, flags=re.IGNORECASE):
+                    lines.append(line.rstrip(";"))
+                else:
+                    pending_ctrl = line
+                    pending_until = "THEN"
+                continue
+
+            if upper.startswith("FOR ") or upper.startswith("WHILE "):
+                flush_buffer()
+                if re.search(r"\bDO\b", line, flags=re.IGNORECASE):
+                    lines.append(line.rstrip(";"))
+                else:
+                    pending_ctrl = line
+                    pending_until = "DO"
+                continue
+
+            if upper.startswith("CASE "):
+                flush_buffer()
+                if re.search(r"\bOF\b", line, flags=re.IGNORECASE):
+                    lines.append(line.rstrip(";"))
+                else:
+                    pending_ctrl = line
+                    pending_until = "OF"
+                continue
+
+            for ch in line:
+                if ch == "(":
+                    paren_depth += 1
+                elif ch == ")":
+                    paren_depth = max(0, paren_depth - 1)
+            buffer = (buffer + " " + line).strip()
+            if paren_depth == 0 and ";" in buffer:
+                parts = split_top_level(buffer, ";")
+                for part in parts[:-1]:
+                    if part.strip():
+                        lines.append(part.strip())
+                buffer = parts[-1].strip()
+        if pending_ctrl:
+            lines.append(pending_ctrl.strip().rstrip(";"))
+        flush_buffer()
+        return lines
+
+
+def split_top_level(text: str, sep: str) -> List[str]:
+    parts: List[str] = []
+    current: List[str] = []
+    depth_round = 0
+    depth_square = 0
+    in_string: Optional[str] = None
+    i = 0
+    while i < len(text):
+        ch = text[i]
+        if in_string:
+            current.append(ch)
+            if ch == in_string:
+                in_string = None
+            i += 1
+            continue
+        if ch in {'"', "'"}:
+            in_string = ch
+            current.append(ch)
+            i += 1
+            continue
+        if ch == "(":
+            depth_round += 1
+        elif ch == ")":
+            depth_round = max(0, depth_round - 1)
+        elif ch == "[":
+            depth_square += 1
+        elif ch == "]":
+            depth_square = max(0, depth_square - 1)
+        if ch == sep and depth_round == 0 and depth_square == 0:
+            parts.append("".join(current))
+            current = []
+        else:
+            current.append(ch)
+        i += 1
+    parts.append("".join(current))
+    return parts
+
+
+def parse_time_literal(upper: str) -> int:
+    text = upper.replace("TIME#", "T#").replace(" ", "")
+    if not text.startswith("T#"):
+        return 0
+    body = text[2:]
+    total = 0
+    for number, unit in re.findall(r"(\d+)(D|H|MS|M|S)", body):
+        n = int(number)
+        if unit == "D":
+            total += n * 24 * 60 * 60 * 1000
+        elif unit == "H":
+            total += n * 60 * 60 * 1000
+        elif unit == "M":
+            total += n * 60 * 1000
+        elif unit == "S":
+            total += n * 1000
+        elif unit == "MS":
+            total += n
+    return total