opencrbasic 1.1.1__tar.gz → 1.2.0__tar.gz

{opencrbasic-1.1.1 → opencrbasic-1.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: opencrbasic
-Version: 1.1.1
+Version: 1.2.0
 Summary: Open-source re-implementation of the Campbell Scientific CRBasic pre-compilers (CR6, CR1000X, CR300, CR350)
 Project-URL: Repository, https://github.com/UtrechtUniversity/open-crbasic
 Author: Utrecht University

{opencrbasic-1.1.1 → opencrbasic-1.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "opencrbasic"
-version = "1.1.1"
+version = "1.2.0"
 description = "Open-source re-implementation of the Campbell Scientific CRBasic pre-compilers (CR6, CR1000X, CR300, CR350)"
 readme = "README.md"
 license = "MIT"

{opencrbasic-1.1.1 → opencrbasic-1.2.0}/src/opencrbasic/__init__.py

@@ -1,3 +1,3 @@
 """Open-source CRBasic (CR6) pre-compiler."""
 
-__version__ = "1.1.1"
+__version__ = "1.2.0"

{opencrbasic-1.1.1 → opencrbasic-1.2.0}/src/opencrbasic/checker/__init__.py

@@ -111,6 +111,7 @@ from . import (
     storage,
     structs,
     structure,
+    terminals,
     var_types,
     warnings,
 )
@@ -265,6 +266,7 @@ def _check(program: S.Program, profile: Profile, diags: Diagnostics, result) ->
             del diags.items[program.hash_cut :]  # parser findings of later lines
     program = structure.open_program_at_slowsequence(program, profile)
     env = consteval.Env(profile, dict(program.consts))
+    expressions.set_arity_context(program, profile)
 
     _run_pass(structure.check_pass1, program, profile, diags, env)
     # Also pass 1 (unconditional -- oracle-confirmed, `docs/loggers.md`): a `Const`'s own value
@@ -411,6 +413,7 @@ def _check(program: S.Program, profile: Profile, diags: Diagnostics, result) ->
         # "stop entirely at the first placement error" behaviour.
         pass2_start = len(diags.items)
         _run_pass(instr_rules.check_spi_open_order, _with_inline(program), profile, leading)
+        _run_pass(terminals.check_i2c_open_order, _with_inline(program), profile, ranges, env)
         # Block-closer messages come before a same-line placement error (`EndIf illegally
         # occurs before BeginProg.` follows `END IF without IF...`).
         # CR300/CR350: collected aside in `leading` (printed first on their line, but they do not
@@ -743,6 +746,7 @@ def _check(program: S.Program, profile: Profile, diags: Diagnostics, result) ->
         # instructions placed outside `DataTable...EndTable`, and an orphan `EndTable`.
         table_stop = _run_pass_capture(instr_data.check_table_structure, _with_inline(program), profile, diags)
         _run_pass(instr_data.check_fieldnames, program, profile, diags, env)
+        _run_pass(instr_data.check_fieldclassify, program, profile, diags, env)
         apply_diags = Diagnostics()
         _run_pass(structure.check_apply_restart_sequence, program, profile, apply_diags)
         for extra in apply_diags.items:  # in source order among the tier-C findings

{opencrbasic-1.1.1 → opencrbasic-1.2.0}/src/opencrbasic/checker/cr3xx.py

@@ -7,6 +7,7 @@ evidence: `docs/loggers.md`.
 
 import collections
 import dataclasses
+import math
 import re
 from collections.abc import Set as AbstractSet
 from typing import TypedDict
@@ -14,7 +15,7 @@ from typing import TypedDict
 from .. import bindings, consteval, lexer
 from .. import syntax as S
 from ..diagnostics import Diagnostic, Diagnostics
-from . import expressions, instr_rules, structure, symbols
+from . import expressions, instr_rules, longconv, structure, symbols
 
 # `SerialOpen`'s own `ComPort` argument (position 0, the only position checked here) is the one
 # `Serial*` function on CR300/CR350 whose compile-time validator additionally requires a genuine
@@ -40,6 +41,8 @@ _SERIALOPEN = "SERIALOPEN"
 _SERIALOPEN_PORTS = {
     "cr6": frozenset(range(1, 19)) | frozenset(range(31, 100)),
     "cr1000x": frozenset(range(1, 15)) | frozenset(range(31, 100)),
+    "cr300": frozenset(range(1, 13)) | frozenset(range(32, 48)),
+    "cr350": frozenset(range(1, 18)) | frozenset(range(32, 48)),
 }
 _COMPORT_ARG_POSITION = 0
 # Every `Serial*` function whose first argument is a `ComPort` (`data/<logger>/functions.json`:
@@ -79,6 +82,33 @@ _COMMS_MODES = {
     "COMC3": frozenset({0, 1, 2, 3, 4, 6}),
     "COMC7": frozenset({0, 1, 2, 3, 4, 6}),
 }
+_CR350_MAX_COMMS_MODE = {1: 0, 2: 0, 3: 0, 4: 1, 7: 1, 8: 1, 9: 1, 10: 1}
+
+
+def _check_cr350_comms_mode(
+    stmt: S.Call, port: int, profile, consts: dict, diags: Diagnostics, invalid_format: bool, shifted: bool
+) -> None:
+    maximum = _CR350_MAX_COMMS_MODE.get(port)
+    if maximum is None or (len(stmt.args) < 5 if shifted else len(stmt.args) != 6):
+        return
+    mode_arg = stmt.args[4 if shifted else 5]
+    if longconv._float_typed(mode_arg, frozenset()):
+        return
+    env = consteval.Env(profile, consts)
+    try:
+        raw = consteval.value_of(mode_arg, env)
+    except consteval.NotConstant:
+        return
+    if not consteval.is_finite_number(raw) or (
+        isinstance(raw, float) and (not -(2**31) <= raw < 2**31 or raw != int(raw))
+    ):
+        return
+    fmt = longconv.long_value(stmt.args[2], env, profile) if not shifted else None
+    if not shifted and not invalid_format and (fmt is None or not -1 <= fmt <= 15):
+        return
+    value = longconv.long_value(mode_arg, env, profile)
+    if value is not None and (mode := value & 0xFF) > maximum:
+        diags.error(stmt.line, f"{mode} is an invalid CommsMode parameter.", stmt.file)
 
 
 def _commsmode_problem(
@@ -94,7 +124,7 @@ def _commsmode_problem(
             mode = consteval.value_of(stmt.args[index], env)
     except consteval.NotConstant, consteval.DivideByZero, TypeError, ValueError:
         return None
-    if isinstance(mode, bool) or not isinstance(mode, (int, float)) or mode != int(mode):
+    if isinstance(mode, bool) or not consteval.is_finite_number(mode) or mode != int(mode):
         return None
     for key, modes in _COMMS_MODES.items():
         record = profile.symbols.get(key)
@@ -132,6 +162,34 @@ def _format_needs_com1_4(stmt: S.Call, profile, consts: dict | None) -> bool:
     return 1 <= port <= 8 and 16 <= fmt < 2**31
 
 
+def _non_finite(arg: S.Expr | None, profile, consts: dict | None) -> str | None:
+    """`"divide"` for a division by zero, `"float"` for an infinite or NaN constant: neither is
+    a constant integer (oracle, all four loggers, 2026-11-14,
+    `tests/fixtures/r150_serialopen_non_finite.json`)."""
+    if arg is None:
+        return None
+    if isinstance(arg, S.Name) and arg.name.upper() == "INF" and "INF" not in (consts or {}):
+        return "float"
+    try:
+        value = consteval.value_of(arg, consteval.Env(profile, dict(consts or {})))
+    except consteval.DivideByZero:
+        return "divide"
+    except consteval.NotConstant, TypeError, ValueError, OverflowError, ZeroDivisionError:
+        return None
+    return "float" if isinstance(value, float) and not math.isfinite(value) else None
+
+
+def _invalid_cr3xx_serial_format(arg: S.Expr, env: consteval.Env) -> bool:
+    """The integer format field on CR300/CR350 rejects options starting at 16 (round 134)."""
+    if not isinstance(arg, S.Name) and consteval.is_float(arg, env):
+        return False
+    try:
+        value = consteval.value_of(arg, env)
+    except consteval.NotConstant, ValueError, OverflowError:
+        return False
+    return consteval.is_finite_number(value) and 16 <= value <= 2**31 and value == int(value)
+
+
 def _non_numeric(expr, profile, consts: dict | None, variable_names) -> bool:
     if expressions._variable_refs(expr, variable_names):
         return True
@@ -143,7 +201,7 @@ def _non_numeric(expr, profile, consts: dict | None, variable_names) -> bool:
     return isinstance(value, str) or expressions._not_constant_integer(expr)
 
 
-def _check_baud(stmt: S.Call, profile, diags: Diagnostics, consts: dict | None = None) -> None:
+def _check_baud(stmt: S.Call, profile, diags: Diagnostics, consts: dict | None = None, *, port11: bool = False) -> None:
     port = stmt.args[0] if stmt.args else None
     rs232 = isinstance(port, S.Name) and port.name.upper() == "COMRS232"
     # CR6/CR1000X check every valid port (oracle, 2026-10-25, round 35: ComUSB, ComC1, ComSDC7,
@@ -152,7 +210,7 @@ def _check_baud(stmt: S.Call, profile, diags: Diagnostics, consts: dict | None =
         isinstance(port, S.Name)
         and (port.name.upper() in profile.symbols or port.name.upper() in {str(c).upper() for c in consts or {}})
     )
-    if len(stmt.args) < 2 or not (rs232 or (not profile.single_pass and known_port)):
+    if len(stmt.args) < 2 or not (rs232 or port11 or (not profile.single_pass and known_port)):
         return
     arg = stmt.args[1]
     sign = 1
@@ -209,9 +267,11 @@ def check(program: S.Program, profile, diags: Diagnostics) -> None:
     alongside `expressions.check_consts`.
     """
     cr3 = profile.name in ("cr300", "cr350")
+    from .instr_data import _with_inline
+
     known = expressions._known_names(program, profile)
     variable_names = symbols.declared_variable_names(program)
-    for stmt in program.statements:
+    for stmt in _with_inline(program.statements) if cr3 else program.statements:
         if not isinstance(stmt, S.Call):
             continue
         name = stmt.name.upper()
@@ -231,6 +291,8 @@ def check(program: S.Program, profile, diags: Diagnostics) -> None:
             continue
         is_variable = bool(expressions._variable_refs(arg, variable_names))
         ports = _SERIALOPEN_PORTS.get(profile.name)
+        port = None
+        sep = "\n" if cr3 and stmt.at_eol else ""
         if ports and not (names or is_variable or isinstance(arg, S.String)):
             # a constant ComPort outside the port codes ends the statement (oracle, round 36/37,
             # docs/checker.md#serialopen-comport-codes-round-37)
@@ -238,17 +300,62 @@ def check(program: S.Program, profile, diags: Diagnostics) -> None:
                 port = consteval.value_of(arg, consteval.Env(profile, dict(program.consts or {})))
             except consteval.NotConstant, TypeError, ValueError, ZeroDivisionError:
                 port = None
+            if cr3 and isinstance(port, bool):
+                port = -int(port)
+            if cr3 and isinstance(port, (int, float)) and port in (-(2**31), 2**31):
+                port = max(-(2**31 - 1), min(2**31 - 1, int(port)))
+            elif (
+                consteval.is_finite_number(port)
+                and not isinstance(port, bool)
+                and (
+                    port != int(port)
+                    or not -(2**31) <= port < 2**31
+                    or (cr3 and expressions._not_constant_integer(arg))
+                )
+            ) or (cr3 and isinstance(port, str)):
+                diags.error(stmt.line, "ComPort 0 illegal.", stmt.file)
+                diags.error(stmt.line, f"Parameter must be a constant integer: {stmt.text}{sep}.", stmt.file)
+                continue
             if consteval.is_finite_number(port) and not isinstance(port, bool):
-                if port != int(port) or not -(2**31) <= port < 2**31:
-                    diags.error(stmt.line, "ComPort 0 illegal.", stmt.file)
-                    diags.error(stmt.line, f"Parameter must be a constant integer: {stmt.text}.", stmt.file)
-                    continue
                 if int(port) not in ports:
-                    diags.error(stmt.line, f"ComPort {int(port)} illegal.", stmt.file)
-                    diags.error(stmt.line, f"No Matching, or out of place ) in expression: {stmt.text}.", stmt.file)
+                    diags.items.append(
+                        Diagnostic("error", stmt.line, f"ComPort {int(port)} illegal.", stmt.file, trigger=cr3)
+                    )
+                    if profile.name != "cr350":
+                        diags.error(
+                            stmt.line, f"No Matching, or out of place ) in expression: {stmt.text}{sep}.", stmt.file
+                        )
                     continue
-        _check_baud(stmt, profile, diags, program.consts)
+        _check_baud(stmt, profile, diags, program.consts, port11=cr3 and port == 11)
         constant_port = not (names or is_variable or isinstance(arg, S.String))
+        format_arg = stmt.args[2] if len(stmt.args) > 2 else None
+        invalid_format = (
+            cr3
+            and constant_port
+            and consteval.is_finite_number(port)
+            and format_arg is not None
+            and not expressions._variable_refs(format_arg, variable_names)
+            and _invalid_cr3xx_serial_format(format_arg, consteval.Env(profile, dict(program.consts)))
+        )
+        if invalid_format:
+            diags.error(stmt.line, "Invalid format option.", stmt.file)
+        cr3_shifted = (
+            cr3
+            and constant_port
+            and format_arg is not None
+            and not invalid_format
+            and (
+                _non_numeric(format_arg, profile, program.consts, variable_names)
+                or not isinstance(format_arg, S.Name)
+                and longconv._float_typed(format_arg, frozenset())
+            )
+        )
+        if cr3_shifted:
+            if profile.name == "cr350" and consteval.is_finite_number(port):
+                _check_cr350_comms_mode(stmt, int(port), profile, program.consts, diags, False, True)
+            elif len(stmt.args) > 5:
+                diags.error(stmt.line, f"No Matching, or out of place ) in expression: {stmt.text}{sep}.", stmt.file)
+            continue
         # CR6/CR1000X: a String or variable `SerialOpenFormat` makes the 5th argument the CommsMode, with
         # no TXDelay range and at most 5 arguments (oracle, 2026-10-28, round 57,
         # docs/checker.md#serialopen-format-and-commsmode-round-57)
@@ -260,7 +367,7 @@ def check(program: S.Program, profile, diags: Diagnostics) -> None:
             and _non_numeric(stmt.args[2], profile, program.consts, variable_names)
         )
         # a bare undeclared TXDelay is lost in the same comma recovery (decompiled `FUN_00494aa0`,
-        # oracle round 58, docs/checker.md#serialopen-recovery-round-58)
+        # oracle round 58, docs/checker.md#serialopen-recovery-rounds-58-and-142)
         shifted = shifted or (not cr3 and constant_port and bare_unknown_delay(stmt, known))
         if (
             not cr3
@@ -296,16 +403,12 @@ def check(program: S.Program, profile, diags: Diagnostics) -> None:
                     stmt.line, f"{int(value)} usec delay before transmit is illegal, must be 0..14000000", stmt.file
                 )
         # a 6th argument that is no constant integer counts as mode 0, then is rejected (same probes)
-        bad_mode = (
-            not cr3
-            and constant_port
-            and not shifted
-            and len(stmt.args) > 5
-            and stmt.args[5] is not None
-            and (
-                expressions._not_constant_integer(stmt.args[5])
-                or bool(expressions._variable_refs(stmt.args[5], variable_names))
-            )
+        check_mode = not cr3 and constant_port and not shifted and len(stmt.args) > 5 and stmt.args[5] is not None
+        mode_kind = _non_finite(stmt.args[5], profile, program.consts) if check_mode else None
+        bad_mode = check_mode and (
+            expressions._not_constant_integer(stmt.args[5])
+            or bool(expressions._variable_refs(stmt.args[5], variable_names))
+            or mode_kind is not None
         )
         if (
             not cr3
@@ -321,19 +424,55 @@ def check(program: S.Program, profile, diags: Diagnostics) -> None:
             else:
                 diags.warning(stmt.line, problem[1], stmt.file)
         if bad_mode:
-            diags.error(stmt.line, f"Parameter must be a constant integer: {stmt.text}.", stmt.file)
+            verb = "Divide by zero in expression" if mode_kind == "divide" else "Parameter must be a constant integer"
+            diags.error(stmt.line, f"{verb}: {stmt.text}.", stmt.file)
             continue
         if shifted and len(stmt.args) > 5:
             diags.error(stmt.line, f"No Matching, or out of place ) in expression: {stmt.text}.", stmt.file)
             continue
         if (
-            not (cr3 or names or is_variable or isinstance(arg, S.String))
+            not (names or is_variable or isinstance(arg, S.String))
             and len(stmt.args) > 4
             and expressions._variable_refs(stmt.args[4], variable_names)
         ):
             # a variable `BufferSize` (oracle, CR6/CR1000X, 2026-10-24, round 34)
-            diags.error(stmt.line, f"Parameter must be a constant integer: {stmt.text}.", stmt.file)
+            diags.error(stmt.line, f"Parameter must be a constant integer: {stmt.text}{sep}.", stmt.file)
             continue
+        if constant_port and len(stmt.args) > 4 and (kind := _non_finite(stmt.args[4], profile, program.consts)):
+            # an infinite `BufferSize`, or one that divides by zero (CR300/CR350: one message for both)
+            verb = (
+                "Divide by zero in expression"
+                if kind == "divide" and not cr3
+                else "Parameter must be a constant integer"
+            )
+            diags.error(stmt.line, f"{verb}: {stmt.text}{sep}.", stmt.file)
+            continue
+        if profile.name == "cr300" and port == 11 and len(stmt.args) > 4:
+            buffer = stmt.args[4]
+            if not expressions._not_constant_integer(buffer):
+                try:
+                    size = consteval.value_of(buffer, consteval.Env(profile, dict(program.consts)))
+                except consteval.NotConstant:
+                    size = None
+                if consteval.is_finite_number(size) and 0 < size < 2**31:
+                    diags.items.append(Diagnostic("error", stmt.line, "Out of memory.", stmt.file, trigger=True))
+        if profile.name == "cr350" and consteval.is_finite_number(port):
+            _check_cr350_comms_mode(stmt, int(port), profile, program.consts, diags, invalid_format, False)
+        if profile.name == "cr300" and constant_port and len(stmt.args) == 6 and stmt.args[5] is not None:
+            mode_arg = stmt.args[5]
+            env = consteval.Env(profile, dict(program.consts))
+            try:
+                mode = consteval.value_of(mode_arg, env)
+            except consteval.NotConstant:
+                mode = None
+            if (
+                not consteval.is_finite_number(mode)
+                or mode != int(mode)
+                or not isinstance(mode_arg, S.Name)
+                and consteval.is_float(mode_arg, env)
+                or expressions._variable_refs(mode_arg, variable_names)
+            ):
+                diags.error(stmt.line, f"Parameter must be a constant integer: {stmt.text}{sep}.", stmt.file)
         if names or is_variable or isinstance(arg, S.String):
             # A string or variable ComPort, all four loggers, pass 1 (oracle, 2026-10-01:
             # `SerialOpen("fuzz",...)`). CR300/CR350 echo the line end (`docs/loggers.md`).
@@ -883,18 +1022,38 @@ def check_float_destinations(program: S.Program, profile, diags: Diagnostics) ->
     String variable, a literal, an expression) gives `Illegal destination variable type,
     expecting Float.` (oracle, CR300, 2026-10-01: `PanelTemp(L,60)`, `PanelTemp(Nope,60)`,
     `VoltSe(L,1,mV1000,...)`, `Battery(L)`)."""
+    from .instr_data import _destination_env, constant_destination
+
     if profile.name not in ("cr300", "cr350"):
         return
     types: dict[str, str] | None = None
     scoped: dict[int, dict[str, str]] = {}
     known = ds = None
+    constant_names = profile.symbols.keys() | expressions._EXTRA_PREDEFINED_SYMBOLS
+    function_names = set(profile.functions)
+    destination_env = _destination_env(consteval.Env(profile))
+    destination_variables = symbols.declared_variable_names(program)
     params: dict[str, str] = {}  # the enclosing routine's parameters hide a global (round 31)
+    scalar_params: set[str] = set()
     per_line = collections.Counter((st.line, st.file) for st in program.statements)
     for stmt in program.statements:
         if isinstance(stmt, S.SubDef):
             params = {p.name.upper(): (p.type or "FLOAT").upper() for p in stmt.params}
+            scalar_params = {
+                p.name.upper()
+                for p in stmt.params
+                if not p.dim_exprs and (p.dims == 0 or p.type is None) and (p.type or "").upper() != "STRING"
+            }
+            if stmt.keyword.upper() == "FUNCTION":
+                function_names.add(stmt.name.upper())
+        elif isinstance(stmt, S.ConstDecl):
+            name = stmt.name.upper()
+            constant_names.add(name)
+            if name in program.consts:
+                destination_env.consts[name] = program.consts[name]
         elif S.ends_routine(stmt):
             params = {}
+            scalar_params = set()
         if (
             not isinstance(stmt, S.Instruction)
             or not stmt.args
@@ -903,12 +1062,19 @@ def check_float_destinations(program: S.Program, profile, diags: Diagnostics) ->
         ):
             continue
         info = profile.instructions.get(stmt.keyword.upper())
-        literal = (
+        send_variables = stmt.keyword.upper() == "SENDVARIABLES"
+        named_destination = send_variables or stmt.keyword.upper() in {"MOVE", "ERASE", "READIO", "REALTIME"}
+        invalid_destination = (
             next(
                 (
                     i
                     for i, (code, a) in enumerate(zip(info["params"], stmt.args))
-                    if code in (27, 29) and a is not None and not isinstance(a, S.String) and not _expr_names(a)
+                    if code in (27, 29)
+                    and (
+                        constant_destination(a, destination_env, params.keys() | destination_variables)
+                        if named_destination
+                        else a is not None and not isinstance(a, S.String) and not _expr_names(a)
+                    )
                 ),
                 None,
             )
@@ -916,13 +1082,12 @@ def check_float_destinations(program: S.Program, profile, diags: Diagnostics) ->
             else None
         )
         if (
-            literal is not None
+            invalid_destination is not None
             and per_line[(stmt.line, stmt.file)] == 1
-            and not any((d.line, d.file) == (stmt.line, stmt.file) for d in diags.errors)
+            and (send_variables or not any((d.line, d.file) == (stmt.line, stmt.file) for d in diags.errors))
         ):
-            # `RealTime(5)`, `Erase(5)`, `Matrix(5,(1+2),0,R)` -> `Invalid Variable or Array:
-            # 5.`, then the argument list ends (oracle, CR300, 2026-10-01: `Move(5,1,X,1)` ->
-            # `Too many parameters:  1.`)
+            # The argument list ends after a rejected destination. The next token is
+            # reported as excess (oracle, CR300/CR350, rounds 31 and 133).
             at = next(
                 (i for i, d in enumerate(diags.items) if d.file == stmt.file and d.line > stmt.line), len(diags.items)
             )
@@ -930,15 +1095,23 @@ def check_float_destinations(program: S.Program, profile, diags: Diagnostics) ->
                 Diagnostic(
                     "error",
                     stmt.line,
-                    f"Invalid Variable or Array: {expressions._arg_text(stmt, literal).strip()}.",
+                    f"Invalid Variable or Array: {expressions._arg_text(stmt, invalid_destination).strip()}.",
                     stmt.file,
                 )
             ]
-            if len(stmt.args) > literal + 1 and stmt.args[literal + 1] is not None:
-                text = instr_rules._next_simple_token(
-                    expressions._arg_text(stmt, literal + 1)
-                ) or expressions._arg_text(stmt, literal + 1)
+            following = invalid_destination + 1
+            if len(stmt.args) > following and stmt.args[following] is not None:
+                raw = expressions._arg_text(stmt, following)
+                text = instr_rules._next_simple_token(raw) or raw
                 new.append(Diagnostic("error", stmt.line, f"Too many parameters:  {text}.", stmt.file))
+            if send_variables:
+                # The destination aborts before SendVariables reads its remaining arguments.
+                at -= sum(
+                    (d.line, d.file) == (stmt.line, stmt.file) and d.severity == "error" for d in diags.items[:at]
+                )
+                diags.items[:] = [
+                    d for d in diags.items if (d.line, d.file) != (stmt.line, stmt.file) or d.severity != "error"
+                ]
             diags.items[at:at] = new
             continue
         if not info or not info["params"] or info["params"][0] != _FLOAT_DEST:
@@ -948,14 +1121,33 @@ def check_float_destinations(program: S.Program, profile, diags: Diagnostics) ->
             ds = expressions.program_dims(program, profile, known)
         assert known is not None and ds is not None
         arg = stmt.args[0]
+        assert arg is not None
         if isinstance(arg, S.Name) and arg.name.upper() in profile.functions:
             continue  # a bare function name is `Expression expects (` instead (expressions.py)
         key = (stmt.line, stmt.file)
+        if isinstance(arg, S.Index) and arg.name.upper() in scalar_params and any(a is not None for a in arg.args):
+            raw = expressions._arg_text(stmt, 0).strip()
+            diags.items[:] = [
+                d
+                for d in diags.items
+                if (d.line, d.file) != key
+                or not d.message.startswith(("Dimensions not declared:", "Too many parameters:"))
+            ]
+            diags.items.append(
+                Diagnostic("error", stmt.line, f"Dimensions not declared: {raw}.", stmt.file, trigger=True)
+            )
+            if len(stmt.args) > 1 and stmt.args[1] is not None:
+                raw = expressions._arg_text(stmt, 1)
+                token = instr_rules._next_simple_token(raw) or raw
+                diags.error(stmt.line, f"Too many parameters:  {token}.", stmt.file)
+            continue
         undefined = [n for n in _expr_names(arg) if n.upper() not in known]
+        variables = {**types, **scoped.get(id(stmt), {}), **params}
+        call = isinstance(arg, S.Index) and arg.name.upper() not in variables and arg.name.upper() in function_names
         expression = False
         dims = False
         if undefined:
-            if isinstance(arg, (S.Binary, S.Unary)):
+            if isinstance(arg, (S.Binary, S.Unary)) or call:
                 # an arithmetic expression is no destination: after its names, `Dimensions not
                 # declared` or the destination-type error (oracle, CR300, 2026-10-03)
                 expression = True
@@ -963,11 +1155,21 @@ def check_float_destinations(program: S.Program, profile, diags: Diagnostics) ->
             elif not isinstance(arg, (S.Name, S.Index)):
                 continue
             keep = [profile.unresolved_symbol_message.format(name=n) for n in undefined]
-        elif _is_bad_destination(arg, {**types, **scoped.get(id(stmt), {}), **params}):
+        elif (
+            call
+            or _is_bad_destination(arg, variables)
+            or isinstance(arg, S.Name)
+            and arg.name.upper() not in variables
+            and arg.name.upper() in constant_names
+        ):
             keep = []
         else:
             continue
         own = [d for d in diags.items if (d.line, d.file) == key and d.severity == "error"]
+        if call and any(
+            d.message.startswith(("Incomplete expression:", "Invalid, or out of place expression:")) for d in own
+        ):
+            continue
         if not keep and any(d.message.startswith("Dimensions not declared") for d in own):
             continue  # (`Battery(L(2))` for a Long scalar: over-indexing is reported first)
         if keep and [d.message for d in own[: len(keep)]] != keep:
@@ -1236,12 +1438,18 @@ def _report_unregistered(
         if isinstance(st, S.SubDef) and id(st) in tainted_subs and st.keyword == "FUNCTION"
     }
     affected: set[tuple[int, str]] = set()
+    removed_params: set[str] = set()
     for st in program.statements[taint_at + 1 :]:
-        if id(st) in dropped or id(st) in rewritten or isinstance(st, S.SubDef):
+        if isinstance(st, S.SubDef):
+            removed_params = {p.name.upper() for p in st.params} if id(st) in tainted_subs else set()
+            continue
+        if isinstance(st, S.Instruction) and structure._ends_sub(st, st.keyword.upper()):
+            removed_params.clear()
+        if id(st) in dropped or id(st) in rewritten:
             continue
         names: set[str] = set()
         unused._walk_stmt(st, names)
-        if names & unregistered or (not isinstance(st, S.Call) and names & functions):
+        if names & unregistered or names & removed_params or (not isinstance(st, S.Call) and names & functions):
             affected.add((st.line, st.file))
     if not affected:
         return
@@ -2426,6 +2634,7 @@ _ARITY_PREFIXES = {
     "many": "No Matching, or out of place ) in expression: ",
     "few": "Expression expects , : ",
     "empty": "Invalid, or out of place expression: ",
+    "network_constint": "Parameter must be a constant integer: ",
 }
 
 
@@ -2459,7 +2668,7 @@ def _arity_walk(expr: S.Expr | None, known: set[str], profile, state: _ArityStat
             )
             args, stop = args[:at], True
             state.setdefault("kind", "many")
-        elif problem in ("few", "empty"):
+        elif problem in ("few", "empty", "network_constint"):
             state.setdefault("kind", problem)
         elif problem:
             state["bad"] = True
@@ -2512,7 +2721,13 @@ def order_names_around_arity(program: S.Program, profile, diags: Diagnostics) ->
         if state.get("bad") or kind is None:
             continue
         arity = [(i, d) for i, d in own if d.message.startswith(_ARITY_PREFIXES[kind])]
-        if not arity and isinstance(stmt, S.Assignment) and own and expressions._undefined_names(stmt.target, known):
+        if (
+            not arity
+            and kind != "network_constint"
+            and isinstance(stmt, S.Assignment)
+            and own
+            and expressions._undefined_names(stmt.target, known)
+        ):
             # an unresolved target hides the pass-1 arity check, but the parse still reaches it
             arity = [
                 (
@@ -2758,9 +2973,13 @@ def order_invalid_assignments(program: S.Program, profile, diags: Diagnostics) -
     expression:` line (oracle, 2026-10-10: `Sec = Nope`, `6 = estimated`), which pass 1 emitted first."""
     if profile.name not in ("cr300", "cr350"):
         return
-    for key in {(d.line, d.file) for d in diags.items if d.message.startswith("Invalid assignment in expression:")}:
+    conditions = {id(st) for st in program.statements if isinstance(st, S.If)}
+    markers = [
+        d for d in diags.items if d.stmt not in conditions and d.message.startswith("Invalid assignment in expression:")
+    ]
+    for key in {(d.line, d.file) for d in markers}:
         own = [d for d in diags.items if (d.line, d.file) == key]
-        marks = [d for d in own if d.message.startswith("Invalid assignment in expression:")]
+        marks = [d for d in markers if (d.line, d.file) == key]
         group = [d for d in own if d not in marks] + marks
         first = next(i for i, d in enumerate(diags.items) if (d.line, d.file) == key)
         rest = [d for d in diags.items if (d.line, d.file) != key]