opencrbasic 1.0.0__tar.gz → 1.1.0__tar.gz

{opencrbasic-1.0.0 → opencrbasic-1.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: opencrbasic
-Version: 1.0.0
+Version: 1.1.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
@@ -118,6 +118,22 @@ crbc [options] program [messagefile]
   --report FILE write a JSON report (reference verdict and diagnostics, check findings)
   --config FILE use this opencrbasic.toml (default: nearest ancestor of the program)
   --check CODE=SEVERITY   set a check severity (error|warning|info|off); repeatable
+  --expand FILE expand #Define/#Macro macros into FILE, then compile FILE instead
+```
+
+`#Define` and `#Macro` are an opencrbasic extension, not CRBasic: the reference compilers reject
+them. `--expand` writes plain CRBasic (definitions commented out, uses expanded inline) that
+`CR6Comp.exe` accepts and that is the file to send to the logger; write it next to the source so
+its `Include`s resolve. The language server expands them the same way, so the editor reports
+the expansion's diagnostics on the line of each use. Syntax and rules:
+[`macros.py`](src/opencrbasic/macros.py).
+
+```crbasic
+#Define LOGD(msg) DebugMsg = msg    ' release build: #Define LOGD(msg)
+#Macro LOGV(name, value)
+  DebugMsg = name & "=" & value
+  CallTable Debug
+#EndMacro
 ```
 
 Check configuration and the report schema: `docs/checker.md` "Check configuration and report file".

{opencrbasic-1.0.0 → opencrbasic-1.1.0}/README.md

@@ -101,6 +101,22 @@ crbc [options] program [messagefile]
   --report FILE write a JSON report (reference verdict and diagnostics, check findings)
   --config FILE use this opencrbasic.toml (default: nearest ancestor of the program)
   --check CODE=SEVERITY   set a check severity (error|warning|info|off); repeatable
+  --expand FILE expand #Define/#Macro macros into FILE, then compile FILE instead
+```
+
+`#Define` and `#Macro` are an opencrbasic extension, not CRBasic: the reference compilers reject
+them. `--expand` writes plain CRBasic (definitions commented out, uses expanded inline) that
+`CR6Comp.exe` accepts and that is the file to send to the logger; write it next to the source so
+its `Include`s resolve. The language server expands them the same way, so the editor reports
+the expansion's diagnostics on the line of each use. Syntax and rules:
+[`macros.py`](src/opencrbasic/macros.py).
+
+```crbasic
+#Define LOGD(msg) DebugMsg = msg    ' release build: #Define LOGD(msg)
+#Macro LOGV(name, value)
+  DebugMsg = name & "=" & value
+  CallTable Debug
+#EndMacro
 ```
 
 Check configuration and the report schema: `docs/checker.md` "Check configuration and report file".

{opencrbasic-1.0.0 → opencrbasic-1.1.0}/pyproject.toml

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

{opencrbasic-1.0.0 → opencrbasic-1.1.0}/src/opencrbasic/__init__.py

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

{opencrbasic-1.0.0 → opencrbasic-1.1.0}/src/opencrbasic/analysis.py

@@ -120,6 +120,7 @@ def analyze(request: AnalysisRequest) -> AnalysisResult:
         warn_unused=request.warn_unused,
         source=recorder,
         signature=request.signature,
+        macros=True,
     )
     includes = getattr(result.program_ast, "include_paths", None) or {}
     lowered = {name.lower(): path for name, path in includes.items()}

{opencrbasic-1.0.0 → opencrbasic-1.1.0}/src/opencrbasic/cli.py

@@ -11,7 +11,8 @@ accepted (matching the exe's own option set) but has no implemented effect: orac
 have none observable from the CLI either. Extra long options: --logger
 {cr6,cr1000x,cr300,cr350} (default: from the file extension, else cr6) and --no-message-file (do
 not write the message file), --strict (opencrbasic checks, `checks.py`, on stderr only), --report FILE
-(JSON report, `docs/checker.md` "Check configuration and report file"), --config FILE and
+(JSON report, `docs/checker.md` "Check configuration and report file"), --expand FILE (expand
+`#Define`/`#Macro` macros into FILE and compile FILE instead, `macros.py`), --config FILE and
 --check CODE=SEVERITY (check configuration; both only act together with --strict or --report).
 Output goes to stdout and to the message file (`<LOGGER>cmple.xxx` by default, e.g. CR6cmple.xxx;
 CRLF line endings);
@@ -47,6 +48,7 @@ class _Options(TypedDict):
     strict: bool
     report: str | None
     config: str | None
+    expand: str | None
     check: list[str]
 
 
@@ -68,6 +70,7 @@ def _parse(argv: list[str]) -> tuple[_Options, list[str]]:
         "strict": False,
         "report": None,
         "config": None,
+        "expand": None,
         "check": [],
     }
     positional: list[str] = []
@@ -75,10 +78,10 @@ def _parse(argv: list[str]) -> tuple[_Options, list[str]]:
     while i < len(argv):
         arg = argv[i]
         if arg.startswith("--"):
-            if arg in ("--logger", "--report", "--config", "--check"):
+            if arg in ("--logger", "--report", "--config", "--expand", "--check"):
                 value = argv[i + 1] if i + 1 < len(argv) else ""
                 i += 2
-            elif arg.split("=", 1)[0] in ("--logger", "--report", "--config", "--check"):
+            elif arg.split("=", 1)[0] in ("--logger", "--report", "--config", "--expand", "--check"):
                 arg, value = arg.split("=", 1)
                 i += 1
             else:
@@ -87,7 +90,7 @@ def _parse(argv: list[str]) -> tuple[_Options, list[str]]:
                 if arg == "--check":
                     opts["check"].append(value)
                 else:
-                    opts[cast(Literal["logger", "report", "config"], arg[2:])] = value  # noqa: F821 -- ruff reads the Literal strings as names
+                    opts[cast(Literal["logger", "report", "config", "expand"], arg[2:])] = value  # noqa: F821 -- ruff reads the Literal strings as names
                 continue
             if arg == "--no-message-file":
                 opts["message_file"] = False
@@ -254,6 +257,20 @@ def main(argv: list[str] | None = None) -> int:
             _write_report(opts["report"], checks.missing_program_report(program.name, profile.name, opts["strict"]))
         return 1
 
+    if opts["expand"]:
+        from . import macros
+
+        try:
+            expanded = macros.expand(program.read_bytes().decode("latin-1"))
+        except macros.MacroError as e:
+            lines = [f"{positional[0]} -- Compile Failed!", "", f"line {e.line}: {e}"]
+            print("\n".join(lines))
+            if opts["message_file"]:
+                _write_message_file(message_path, lines)
+            return 1
+        program = Path(opts["expand"])
+        program.write_bytes(expanded.encode("latin-1", "replace"))
+
     result = compile_file(program, profile, display_name=program.name, warn_unused=opts["u"], provenance=False)
     if opts["p"]:
         from . import preprocess

{opencrbasic-1.0.0 → opencrbasic-1.1.0}/src/opencrbasic/compiler.py

@@ -200,9 +200,12 @@ def compile_file(
     source: SourceProvider | None = None,
     signature: bool = True,
     provenance: bool = True,
+    macros: bool = False,
 ) -> CompileResult:
     """`provenance=False` (the CLI and the tools) skips the position data only the language server
     reads (`LogicalLine.pieces`, `Program.line_map`, `Stmt.origin`); the compile output is unchanged.
+    `macros=True` (the language server) expands the entry file's `#Define`/`#Macro` macros
+    (`macros.py`), which the reference rejects.
 
     Never lets an unexpected exception escape (`docs/checker.md` "Robustness"): the real
     compiler never crashes on a syntactically-loadable file, so an internal bug in this project
@@ -215,7 +218,7 @@ def compile_file(
     """
     profile = profile or profiles.for_file(path)
     name = display_name or path.name
-    result = _compile_once(path, profile, name, None, source, provenance)
+    result = _compile_once(path, profile, name, None, source, provenance, macros)
     if profile.single_pass:
         # CR300/CR350 stop pulling a `Public`/`Dim` initializer's next line once any error has been
         # reported ahead of the declaration (oracle, 2026-10-10, `docs/checker.md` "Round 8"): re-run
@@ -233,7 +236,7 @@ def compile_file(
             if bad is None or (limit is not None and bad >= limit):
                 break
             limit = bad
-            result = _compile_once(path, profile, name, limit, source, provenance)
+            result = _compile_once(path, profile, name, limit, source, provenance, macros)
     if result.program_ast is None:
         return result
     return _finish(result, path, warn_unused, source, signature)
@@ -246,12 +249,13 @@ def _compile_once(
     pull_limit: tuple[int, ...] | None,
     source: SourceProvider | None = None,
     provenance: bool = True,
+    macros: bool = False,
 ):
     from . import checker, parser
 
     try:
         program, diags = parser.parse_file(
-            path, profile=profile, pull_limit=pull_limit, source=source, provenance=provenance
+            path, profile=profile, pull_limit=pull_limit, source=source, provenance=provenance, macros=macros
         )
     except Exception as exc:
         diags = Diagnostics()

opencrbasic-1.1.0/src/opencrbasic/macros.py

@@ -0,0 +1,161 @@
+"""`crbc --expand FILE`: opencrbasic's own macro step, not a reference-compiler feature.
+
+The reference compilers reject `#Define` (`Unknown instruction`), so a program that uses macros is
+expanded first into plain CRBasic, which any compiler (`crbc`, `CR6Comp.exe`) accepts and which is
+the file to send to the logger. Macros expand inline, so they cost no call depth (the logger runs at
+most four nested `Sub`/`Function` calls).
+
+    #Define DEBUG 1                         object-like, one line
+    #Define LOGD(msg) DebugMsg = msg        function-like, one line (an empty body is allowed)
+    #Macro LOGV(name, value)                function-like, several lines
+      DebugMsg = name & "=" & value
+      CallTable Debug
+    #EndMacro
+
+- Names and parameters are case-insensitive, like CRBasic. A function-like name not followed by
+  `(` is left alone; a macro is defined from its line on and cannot be redefined.
+- Nothing inside a `"..."` string or a `'` comment is expanded. A one-line body loses its
+  trailing comment.
+- A macro body is expanded again after substitution, without expanding itself (no recursion).
+- Every other line, `#If` and the other reference directives included, is kept as written apart
+  from the expansion of macro names; the definition lines become comments so line numbers before
+  the first multi-line expansion stay the same. The lines of a multi-line expansion take the
+  indentation of the line that uses it.
+- A macro call must close on its own line. Macros in `Include` files are not read or expanded.
+- The language server expands macros the same way while analysing (`source.py`, the entry file
+  only), so a program with macros gets the diagnostics of its expansion, each on the line of the
+  macro use. `crbc` without `--expand` compiles like the reference and rejects `#Define`.
+"""
+
+import re
+import textwrap
+
+_DEFINE_RE = re.compile(r"^\s*#\s*(Define|Macro)\s+([A-Za-z_]\w*)(?:\(([^)]*)\))?(.*)$", re.IGNORECASE)
+_END_RE = re.compile(r"^\s*#\s*EndMacro\b", re.IGNORECASE)
+# strings and comments are copied whole; a number or `&H`/`&B` literal is never a name
+_TOKEN_RE = re.compile(r'"[^"\n]*"?|\'[^\n]*|\d\w*|&[HhBb]\w*|[A-Za-z_]\w*|.', re.DOTALL)
+
+
+class MacroError(Exception):
+    def __init__(self, line: int, message: str):
+        super().__init__(message)
+        self.line = line
+
+
+class _Macro:
+    __slots__ = ("params", "body")
+
+    def __init__(self, params: list[str] | None, body: str):
+        self.params = params  # None: object-like
+        self.body = body
+
+
+def _strip_comment(text: str) -> str:
+    return "".join(t for t in _TOKEN_RE.findall(text) if not t.startswith("'"))
+
+
+def _call_args(text: str, i: int, line: int, name: str) -> tuple[list[str], int]:
+    """The arguments of the call whose `(` is at `text[i]`, and the index after its `)`."""
+    args, current, depth = [], [], 0
+    for m in _TOKEN_RE.finditer(text, i + 1):
+        tok = m.group()
+        if tok == "\n":
+            break
+        if tok == ")" and depth == 0:
+            args.append("".join(current).strip())
+            return ([] if args == [""] else args), m.end()
+        if tok == "," and depth == 0:
+            args.append("".join(current).strip())
+            current = []
+            continue
+        depth += {"(": 1, ")": -1}.get(tok, 0)
+        current.append(tok)
+    raise MacroError(line, f"Macro {name}: missing ).")
+
+
+def _expand(text: str, macros: dict[str, _Macro], line: int, disabled: frozenset[str] = frozenset()) -> str:
+    out: list[str] = []
+    i = 0
+    while m := _TOKEN_RE.match(text, i):
+        tok, i = m.group(), m.end()
+        key = tok.upper()
+        macro = macros.get(key)
+        if macro is None or key in disabled:
+            out.append(tok)
+            continue
+        body = macro.body
+        if macro.params is not None:
+            j = i
+            while j < len(text) and text[j] in " \t":
+                j += 1
+            if j >= len(text) or text[j] != "(":
+                out.append(tok)
+                continue
+            args, i = _call_args(text, j, line, tok)
+            if len(args) != len(macro.params):
+                raise MacroError(line, f"Macro {tok} takes {len(macro.params)} argument(s), got {len(args)}.")
+            values = dict(zip(macro.params, args, strict=True))
+            body = "".join(values.get(t.upper(), t) for t in _TOKEN_RE.findall(body))
+        body = _expand(body, macros, line, disabled | {key})
+        head = text[text.rfind("\n", 0, m.start()) + 1 : m.start()]
+        indent = head[: len(head) - len(head.lstrip(" \t"))]
+        out.append(body.replace("\n", "\n" + indent))
+    return "".join(out)
+
+
+class Macros:
+    """The macros of one file, fed its lines in order (`expand` here, the loader for the editor)."""
+
+    def __init__(self):
+        self.table: dict[str, _Macro] = {}
+        self._open: tuple[str, list[str] | None, int, list[str]] | None = None  # a #Macro being read
+
+    def feed(self, text: str, line: int) -> str | None:
+        """`text` with macros expanded, or None when it is part of a definition."""
+        if self._open is not None:
+            if _END_RE.match(text):
+                name, params, start, body = self._open
+                self._open = None
+                self._define(name, params, textwrap.dedent("\n".join(body)).strip("\n"), start)
+            else:
+                self._open[3].append(text)
+            return None
+        d = _DEFINE_RE.match(text)
+        if d is None:
+            return _expand(text, self.table, line)
+        kind, name, rest = d.group(1).upper(), d.group(2), d.group(4)
+        params = None if d.group(3) is None else [p.strip().upper() for p in d.group(3).split(",")]
+        if params == [""]:
+            params = []
+        if params is not None and (
+            not all(re.fullmatch(r"[A-Za-z_]\w*", p) for p in params) or len(set(params)) < len(params)
+        ):
+            raise MacroError(line, f"Macro {name}: invalid parameter list.")
+        if kind == "MACRO":
+            if params is None or _strip_comment(rest).strip():
+                raise MacroError(line, f"#Macro {name} needs a (parameter list) and its body on the following lines.")
+            self._open = (name, params, line, [])
+        else:
+            self._define(name, params, _strip_comment(rest).strip(), line)
+        return None
+
+    def finish(self) -> None:
+        if self._open is not None:
+            raise MacroError(self._open[2], f"#Macro {self._open[0]} without #EndMacro.")
+
+    def _define(self, name: str, params: list[str] | None, body: str, line: int) -> None:
+        if name.upper() in self.table:
+            raise MacroError(line, f"Macro {name} is already defined.")
+        self.table[name.upper()] = _Macro(params, body)
+
+
+def expand(text: str) -> str:
+    """`text` with its `#Define`/`#Macro` definitions commented out and their uses expanded."""
+    newline = "\r\n" if "\r\n" in text else "\n"
+    macros = Macros()
+    out = []
+    for n, raw in enumerate(text.splitlines(), 1):
+        expanded = macros.feed(raw, n)
+        out.append("'" + raw if expanded is None else expanded.replace("\n", newline))
+    macros.finish()
+    return newline.join(out) + (newline if text.endswith(("\n", "\r")) else "")

{opencrbasic-1.0.0 → opencrbasic-1.1.0}/src/opencrbasic/parser.py

@@ -3174,6 +3174,7 @@ def parse_file(
     pull_limit: tuple[int, ...] | None = None,
     source: SourceProvider | None = None,
     provenance: bool = True,
+    macros: bool = False,
 ) -> tuple[S.Program, Diagnostics]:
     """`provenance=False` skips the pieces/line-map/origin data only the language server reads (the CLI
     path); everything the checker sees is unchanged. `profile` is normally left to the file's own extension (`profiles.for_file`, the historical
@@ -3191,6 +3192,7 @@ def parse_file(
         _CR3XX_INCLUDE_EXTS.get((profile or _profile_for(path.name)).name),
         source,
         provenance,
+        macros,
     )
     pull_log = diags.pull_log
     parser = _Parser(profile or _profile_for(path.name), diags, provenance)

{opencrbasic-1.0.0 → opencrbasic-1.1.0}/src/opencrbasic/source.py

@@ -29,6 +29,7 @@ from pathlib import Path
 from typing import NamedTuple
 
 from .diagnostics import Diagnostics
+from .macros import MacroError, Macros
 from .sources import DiskSource, SourceProvider
 
 _INCLUDE_RE = re.compile(r'^\s*Include\s*\(?\s*"([^"]*)"\s*\)?\s*$', re.IGNORECASE)
@@ -302,7 +303,9 @@ class _Loader:
         cr3xx_exts: tuple[str, ...] | None = None,
         source: SourceProvider | None = None,
         provenance: bool = True,
+        macros: bool = False,
     ):
+        self.macros = Macros() if macros else None  # the entry file's macros (`macros.py`)
         self.provenance = provenance  # False: skip `LogicalLine.pieces` (only the language server reads them)
         self.source = source or DiskSource()
         self.includes: dict[str, Path] = {}  # include display name -> the path it resolved to
@@ -416,6 +419,22 @@ class _Loader:
             if text.strip() == "":
                 i += 1
                 continue
+            if self.macros is not None and occ == 0:
+                try:
+                    expanded = self.macros.feed(text, start_line)
+                except MacroError as e:
+                    self.diags.error(e.line, str(e), filename)
+                    expanded = None
+                if expanded != text:
+                    # an expansion is reported, and spans, where the macro is used; no `pieces`
+                    for part in (expanded or "").split("\n"):
+                        if part.strip():
+                            phys = (start_line, i + 1)
+                            out.append(
+                                LogicalLine(part, last_line - shift, filename, section, phys=phys, occurrence=occ)
+                            )
+                    i += 1
+                    continue
             pulls, bad = 0, None
             orig = text
             orig_pieces = pieces
@@ -570,13 +589,19 @@ def load_program(
     cr3xx_exts: tuple[str, ...] | None = None,
     source: SourceProvider | None = None,
     provenance: bool = True,
+    macros: bool = False,
 ) -> tuple[list[LogicalLine], Diagnostics]:
     """Load `path` and every file it `Include`s/`IncludeSection`s, as one logical-line stream."""
     path = Path(path)
     diags = Diagnostics()
-    loader = _Loader(path.parent, diags, own_ext, pull_init, cr3xx_exts, source, provenance)
+    loader = _Loader(path.parent, diags, own_ext, pull_init, cr3xx_exts, source, provenance, macros)
     loader.pull_limit = pull_limit
     lines = loader.load_file(path, section=None, in_include=False)
+    try:
+        if loader.macros is not None:
+            loader.macros.finish()
+    except MacroError as e:
+        diags.error(e.line, str(e), path.name)
     diags.pull_log = loader.pull_log
     diags.pull_site = loader.site
     diags.include_paths = loader.includes