firstclass 0.0.3__tar.gz → 0.2.0__tar.gz

{firstclass-0.0.3 → firstclass-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: firstclass
-Version: 0.0.3
+Version: 0.2.0
 Summary: dataclass with bytes, ctypes, C struct, JSON and XML serialization
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
@@ -45,6 +45,7 @@ Packet.sizeof()                    # 36
 | `bool_t` | `bool` | 1 |
 | `char_t` | `char` | 1 |
 | `char_array[N]` | `char x[N]` | N (UTF-8, NUL-padded) |
+| `wchar_t` / `wchar_array[N]` | `uint16_t x[N]` | 2 (2*N), UTF-16, NUL-padded |
 | `bytes_t[N]` | `uint8_t x[N]` | N |
 | `array_t[T, N]` | `T x[N]` | N * size(T) |
 | `enum_t[Color, uint8_t]` | `uint8_t x` (+ `enum Color {..}` in header) | storage size |
@@ -84,6 +85,7 @@ address only means something inside the same process. Sizes follow the platform
 | `obj.to_xml(indent=None)` / `Cls.from_xml(s)` | `<Packet><kind>1</kind>...</Packet>`, arrays as `<item>` |
 | `obj.to_ctypes()` / `Cls.from_ctypes(c)` / `Cls.ctypes_type()` | `ctypes.Structure` with matching layout |
 | `Cls.c_header()` | C source for the struct(s), nested ones first |
+| `Cls.rust_source()` | Rust `#[repr(C)]` source for the struct(s) and enums |
 
 ## Import C/C++ headers
 
@@ -112,6 +114,60 @@ bitfields, inheritance, virtual members, unknown types (`#include`d headers are
 Plain C enums are 32-bit like C unless `: type` is given. C field names that are Python keywords
 (`class`, `from`, ...) get a trailing underscore (`class_`).
 
+## Validation
+
+A value that cannot be encoded never becomes an instance. Fields are checked when the object is
+created and on every attribute assignment, so the mistake surfaces where it was made, not later in
+`to_bytes()`:
+
+```python
+Header(kind=300, tag="x")    # ValueError: Header.kind: 300 out of range for uint8_t [0, 255]
+Header(kind=1, tag="ab")     # ValueError: Header.tag: 'ab' is 2 bytes, char_array[1] holds 1
+h.name = "far too long"      # ValueError, and h.name keeps its old value
+```
+
+Wrong type -> `TypeError`, wrong value or size -> `ValueError`. Sequences and bytes-likes are
+normalised (`(1, 2)` becomes `[1, 2]`, `bytearray` becomes `bytes`) and copied. The one gap is
+mutating a container in place (`obj.nums[0] = 300`), which is not an assignment to the field;
+`to_bytes()` still refuses it. Applies to hand-written classes and to classes made by
+`from_header` / `from_rust`.
+
+## Comparison
+
+Like a dataclass, `==` / `!=` compare field by field. Unlike a plain dataclass, ordering is on by
+default: `<`, `<=`, `>`, `>=` compare fields in declaration order, like tuples, so you can `sorted()`,
+`min()` and `max()` instances. Comparing with another class raises `TypeError` (`==` is just `False`).
+Switch it off with `@firstclass(order=False)`; `eq=False` turns off both.
+
+## Rust
+
+```python
+from firstclass import from_rust
+
+t = from_rust("src/protocol.rs")            # or from_rust(text="...")
+t.Header, t.Status, t.constants, t.skipped  # same result object as from_header
+print(t.Header.rust_source())               # and back: any firstclass class -> Rust definitions
+```
+
+`from_rust` reads simple `#[repr(C)]` structs (C layout with padding) and `#[repr(C, packed)]`
+structs (no padding), plus C-like enums with `#[repr(u8)]`, `#[repr(i32)]` or `#[repr(C)]` and
+plain discriminants (constant expressions, `as` casts, `const`s allowed). Types: `u8`..`u64`,
+`i8`..`i64`, `usize`, `isize`, `f32`, `f64`, `bool`, `c_int` and the other `c_*` names, `[T; N]`
+(`N` may be a `const` expression), nested structs, type aliases, tuple structs, raw pointers,
+references, `Box`, `Option<&T>` and `fn` pointers (stored as addresses). `[u8; N]` becomes
+`bytes_t[N]`, `[c_char; N]` becomes `char_array[N]`, `wchar_t` the 2-byte UTF-16 types. Modules are
+flattened and `#[cfg(test)]` items are ignored.
+
+Skipped with a reason in `.skipped`: structs without `#[repr(C)]` (Rust may reorder their fields;
+pass `assume_repr_c=True` to read them anyway), `repr(transparent)`, `repr(align(N))`,
+`packed(N)` for N > 1, generics, unions, `char`, `u128`, `String`/`Vec`/slices/tuples, enums with
+data. Options: `byteorder`, `align`, `assume_repr_c`, `long_size`.
+
+`Cls.rust_source()` writes `#[repr(C)]` / `#[repr(C, packed)]` structs, `#[repr(u8)]` enums,
+`[u8; N]` for strings and bytes, `[u16; N]` for wide strings, `*mut c_void` for pointers and
+`r#` for keyword names. Rust has no bitfields, so each group of bitfields becomes one integer
+field with the member names in a comment.
+
 ## Layout options
 
 ```python
@@ -144,3 +200,7 @@ bitfields, `#pragma pack` structs) and uses the generated classes.
 ```
 python -m unittest discover -s tests
 ```
+
+The suite (about 450 tests, 40 s) includes random-class fuzzing of every conversion path, parser
+fuzzing, byte-for-byte checks against real packets, and layout checks against the system C compiler
+and `rustc` (skipped when they are not installed). CI runs it on Ubuntu for Python 3.10 to 3.14.

{firstclass-0.0.3 → firstclass-0.2.0}/README.md

@@ -38,6 +38,7 @@ Packet.sizeof()                    # 36
 | `bool_t` | `bool` | 1 |
 | `char_t` | `char` | 1 |
 | `char_array[N]` | `char x[N]` | N (UTF-8, NUL-padded) |
+| `wchar_t` / `wchar_array[N]` | `uint16_t x[N]` | 2 (2*N), UTF-16, NUL-padded |
 | `bytes_t[N]` | `uint8_t x[N]` | N |
 | `array_t[T, N]` | `T x[N]` | N * size(T) |
 | `enum_t[Color, uint8_t]` | `uint8_t x` (+ `enum Color {..}` in header) | storage size |
@@ -77,6 +78,7 @@ address only means something inside the same process. Sizes follow the platform
 | `obj.to_xml(indent=None)` / `Cls.from_xml(s)` | `<Packet><kind>1</kind>...</Packet>`, arrays as `<item>` |
 | `obj.to_ctypes()` / `Cls.from_ctypes(c)` / `Cls.ctypes_type()` | `ctypes.Structure` with matching layout |
 | `Cls.c_header()` | C source for the struct(s), nested ones first |
+| `Cls.rust_source()` | Rust `#[repr(C)]` source for the struct(s) and enums |
 
 ## Import C/C++ headers
 
@@ -105,6 +107,60 @@ bitfields, inheritance, virtual members, unknown types (`#include`d headers are
 Plain C enums are 32-bit like C unless `: type` is given. C field names that are Python keywords
 (`class`, `from`, ...) get a trailing underscore (`class_`).
 
+## Validation
+
+A value that cannot be encoded never becomes an instance. Fields are checked when the object is
+created and on every attribute assignment, so the mistake surfaces where it was made, not later in
+`to_bytes()`:
+
+```python
+Header(kind=300, tag="x")    # ValueError: Header.kind: 300 out of range for uint8_t [0, 255]
+Header(kind=1, tag="ab")     # ValueError: Header.tag: 'ab' is 2 bytes, char_array[1] holds 1
+h.name = "far too long"      # ValueError, and h.name keeps its old value
+```
+
+Wrong type -> `TypeError`, wrong value or size -> `ValueError`. Sequences and bytes-likes are
+normalised (`(1, 2)` becomes `[1, 2]`, `bytearray` becomes `bytes`) and copied. The one gap is
+mutating a container in place (`obj.nums[0] = 300`), which is not an assignment to the field;
+`to_bytes()` still refuses it. Applies to hand-written classes and to classes made by
+`from_header` / `from_rust`.
+
+## Comparison
+
+Like a dataclass, `==` / `!=` compare field by field. Unlike a plain dataclass, ordering is on by
+default: `<`, `<=`, `>`, `>=` compare fields in declaration order, like tuples, so you can `sorted()`,
+`min()` and `max()` instances. Comparing with another class raises `TypeError` (`==` is just `False`).
+Switch it off with `@firstclass(order=False)`; `eq=False` turns off both.
+
+## Rust
+
+```python
+from firstclass import from_rust
+
+t = from_rust("src/protocol.rs")            # or from_rust(text="...")
+t.Header, t.Status, t.constants, t.skipped  # same result object as from_header
+print(t.Header.rust_source())               # and back: any firstclass class -> Rust definitions
+```
+
+`from_rust` reads simple `#[repr(C)]` structs (C layout with padding) and `#[repr(C, packed)]`
+structs (no padding), plus C-like enums with `#[repr(u8)]`, `#[repr(i32)]` or `#[repr(C)]` and
+plain discriminants (constant expressions, `as` casts, `const`s allowed). Types: `u8`..`u64`,
+`i8`..`i64`, `usize`, `isize`, `f32`, `f64`, `bool`, `c_int` and the other `c_*` names, `[T; N]`
+(`N` may be a `const` expression), nested structs, type aliases, tuple structs, raw pointers,
+references, `Box`, `Option<&T>` and `fn` pointers (stored as addresses). `[u8; N]` becomes
+`bytes_t[N]`, `[c_char; N]` becomes `char_array[N]`, `wchar_t` the 2-byte UTF-16 types. Modules are
+flattened and `#[cfg(test)]` items are ignored.
+
+Skipped with a reason in `.skipped`: structs without `#[repr(C)]` (Rust may reorder their fields;
+pass `assume_repr_c=True` to read them anyway), `repr(transparent)`, `repr(align(N))`,
+`packed(N)` for N > 1, generics, unions, `char`, `u128`, `String`/`Vec`/slices/tuples, enums with
+data. Options: `byteorder`, `align`, `assume_repr_c`, `long_size`.
+
+`Cls.rust_source()` writes `#[repr(C)]` / `#[repr(C, packed)]` structs, `#[repr(u8)]` enums,
+`[u8; N]` for strings and bytes, `[u16; N]` for wide strings, `*mut c_void` for pointers and
+`r#` for keyword names. Rust has no bitfields, so each group of bitfields becomes one integer
+field with the member names in a comment.
+
 ## Layout options
 
 ```python
@@ -137,3 +193,7 @@ bitfields, `#pragma pack` structs) and uses the generated classes.
 ```
 python -m unittest discover -s tests
 ```
+
+The suite (about 450 tests, 40 s) includes random-class fuzzing of every conversion path, parser
+fuzzing, byte-for-byte checks against real packets, and layout checks against the system C compiler
+and `rustc` (skipped when they are not installed). CI runs it on Ubuntu for Python 3.10 to 3.14.

{firstclass-0.0.3 → firstclass-0.2.0}/firstclass/__init__.py

@@ -1,5 +1,6 @@
 from ._core import firstclass
 from ._header import from_header
+from ._rust import from_rust
 from ._specs import (
     array_t,
     bitfield,
@@ -18,14 +19,17 @@ from ._specs import (
     uint16_t,
     uint32_t,
     uint64_t,
+    wchar_array,
+    wchar_t,
 )
 
 __all__ = [
-    "firstclass", "from_header",
+    "firstclass", "from_header", "from_rust",
     "uint8_t", "uint16_t", "uint32_t", "uint64_t",
     "int8_t", "int16_t", "int32_t", "int64_t",
     "float32_t", "float64_t", "bool_t", "char_t",
-    "char_array", "bytes_t", "array_t", "bitfield", "enum_t",
+    "char_array", "wchar_t", "wchar_array", "bytes_t", "array_t", "bitfield", "enum_t",
 ]
 
 firstclass.from_header = from_header  # also reachable as the decorator's attribute
+firstclass.from_rust = from_rust

{firstclass-0.0.3 → firstclass-0.2.0}/firstclass/_core.py

@@ -8,11 +8,12 @@ import sys
 import typing
 import xml.etree.ElementTree as ET
 
+from ._rustgen import rust_source
 from ._specs import ArrayOf, BitField, EnumSpec, Nested, Spec, resolve_spec
 
 _METHODS = (
     "to_bytes", "from_bytes", "unpack_from", "to_dict", "from_dict", "to_json", "from_json",
-    "to_xml", "from_xml", "to_ctypes", "from_ctypes", "ctypes_type", "c_header", "sizeof",
+    "to_xml", "from_xml", "to_ctypes", "from_ctypes", "ctypes_type", "c_header", "rust_source", "sizeof",
 )
 
 
@@ -31,6 +32,7 @@ class Schema:
         self._fields: list[tuple[dataclasses.Field, Spec]] | None = None
         self._layout = None
         self._ctype = None
+        self._spec_map = None
 
     # -- structure -----------------------------------------------------------
 
@@ -61,7 +63,7 @@ class Schema:
             for i, (_, spec) in enumerate(self.fields):
                 if isinstance(spec, BitField):
                     st, unit = spec.storage, spec.storage.size() * 8
-                    if group is None or group[0].name != st.name or group[1] + spec.bits > unit:
+                    if group is None or group[0].size() != st.size() or group[1] + spec.bits > unit:
                         a = st.align() if self.aligned else 1
                         off = _round_up(off, a)
                         widest = max(widest, a)
@@ -99,6 +101,31 @@ class Schema:
     def _by_name(self):
         return {f.name: f for f, _ in self.fields}  # small; fields are cached
 
+    @property
+    def spec_map(self):
+        if self._spec_map is None:
+            self._spec_map = {f.name: (f, spec) for f, spec in self.fields}
+        return self._spec_map
+
+    def validate_instance(self, obj):
+        """Check (and normalise) every field of a freshly built instance."""
+        for f, spec in self.fields:
+            if hasattr(obj, f.name):
+                try:
+                    value = spec.check(getattr(obj, f.name))
+                except (TypeError, ValueError) as e:
+                    raise self._ctx(f, e) from e
+                object.__setattr__(obj, f.name, value)
+
+    def checked_setattr(self, obj, name, value):
+        entry = self.spec_map.get(name)
+        if entry is not None:
+            try:
+                value = entry[1].check(value)
+            except (TypeError, ValueError) as e:
+                raise self._ctx(entry[0], e) from e
+        object.__setattr__(obj, name, value)
+
     def _ctx(self, f, exc):
         kind = TypeError if isinstance(exc, TypeError) else ValueError  # e.g. UnicodeDecodeError -> ValueError
         return kind(f"{self.cls.__name__}.{f.name}: {exc}")
@@ -231,7 +258,7 @@ class Schema:
         c = self.ctypes_type()()
         for f, spec in self.fields:
             try:
-                setattr(c, f.name, spec.to_c(getattr(obj, f.name)))
+                setattr(c, f.name, spec.to_c(getattr(obj, f.name), self.bo))
             except (TypeError, ValueError) as e:
                 raise self._ctx(f, e) from e
         return c
@@ -279,6 +306,11 @@ class Schema:
 def firstclass(cls=None, /, *, byteorder: str = "little", align: bool = False, **dataclass_kwargs):
     """Like `@dataclass` (same keyword args), plus binary/JSON/XML/ctypes/C codecs.
 
+    Unlike a plain dataclass, `order=True` is the default (compare field by field, like tuples);
+    pass `order=False` to turn it off. Values are validated when an instance is created and on
+    every attribute assignment: a field that cannot be encoded (out of range, too long, wrong type)
+    raises `ValueError` / `TypeError` immediately, never later in `to_bytes()`.
+
     byteorder: 'little' (default) or 'big'.
     align: False (default) = packed layout, no padding; True = natural C alignment padding.
     """
@@ -286,12 +318,30 @@ def firstclass(cls=None, /, *, byteorder: str = "little", align: bool = False, *
     def wrap(cls):
         if not isinstance(cls, type):
             raise TypeError(f"@firstclass needs a class, got {type(cls).__name__}")
-        dc = dataclasses.dataclass(cls, **dataclass_kwargs)
+        kwargs = dict(dataclass_kwargs)
+        kwargs.setdefault("order", kwargs.get("eq", True))  # ==, <, <=, >, >= by field order
+        holder = []
+        frozen = bool(kwargs.get("frozen"))
+        if frozen:  # frozen __init__ bypasses __setattr__, so validate once the instance is built
+            user_post = getattr(cls, "__post_init__", None)
+            if getattr(user_post, "_firstclass", False):
+                user_post = None  # inherited from a firstclass parent: already covered
+
+            def __post_init__(self, *args):
+                holder[0].validate_instance(self)
+                if user_post is not None:
+                    user_post(self, *args)
+            __post_init__._firstclass = True
+            cls.__post_init__ = __post_init__
+        dc = dataclasses.dataclass(cls, **kwargs)
         clash = [f.name for f in dataclasses.fields(dc) if f.name in _METHODS or f.name == "__firstclass__"]
         if clash:
             raise TypeError(f"{dc.__name__}: field names clash with firstclass methods: {clash}")
         s = Schema(dc, byteorder, align)
         dc.__firstclass__ = s
+        holder.append(s)
+        if not frozen:  # every assignment (including those in __init__) is checked
+            dc.__setattr__ = lambda self, name, value: s.checked_setattr(self, name, value)
         dc.to_bytes = lambda self: s.pack(self)
         dc.from_bytes = staticmethod(s.from_bytes)
         dc.unpack_from = staticmethod(s.unpack_from)
@@ -305,6 +355,7 @@ def firstclass(cls=None, /, *, byteorder: str = "little", align: bool = False, *
         dc.from_ctypes = staticmethod(s.from_ctypes)
         dc.ctypes_type = staticmethod(s.ctypes_type)
         dc.c_header = staticmethod(s.c_header)
+        dc.rust_source = staticmethod(lambda: rust_source(s))
         dc.sizeof = staticmethod(s.size)
         return dc
 

{firstclass-0.0.3 → firstclass-0.2.0}/firstclass/_header.py

@@ -73,7 +73,10 @@ def _int_value(text: str) -> int:
 
 def _match(toks: list[Tok], i: int) -> int:
     """Index of the bracket closing toks[i] ('(' '[' '{'), or the last index if unbalanced."""
-    open_, close = {"(": ("(", ")"), "[": ("[", "]"), "{": ("{", "}")}[toks[i].text]
+    pair = {"(": ("(", ")"), "[": ("[", "]"), "{": ("{", "}")}.get(toks[i].text)
+    if pair is None:  # not an opening bracket: nothing to match
+        return i
+    open_, close = pair
     depth = 0
     for j in range(i, len(toks)):
         if toks[j].kind == "op":
@@ -99,7 +102,10 @@ class _Expr:
     def value(self) -> int:
         if not self.t:
             raise _ExprError("empty expression")
-        v = self.ternary()
+        try:
+            v = self.ternary()
+        except RecursionError:
+            raise _ExprError("expression nested too deeply") from None
         if self.i != len(self.t):
             raise _ExprError(f"unexpected token {self.t[self.i].text!r}")
         return v
@@ -286,6 +292,7 @@ class _Ctx:
         self.typedefs: dict[str, TypedefDecl] = {}
         self.constants: dict[str, int] = {}
         self.pack = None
+        self.parse_error = None
         self.long_size = long_size
         self._anon = 0
 
@@ -570,7 +577,7 @@ class _Parser:
                 continue
             break
         self.i = self.statement_end(self.i)
-        if words and words[0] in ("struct", "enum", "union") and len(words) == 2 and words[1].startswith("_anon"):
+        if words and words[0] in ("struct", "enum", "union") and len(words) == 2 and (words[1] or "").startswith("_anon"):
             plain = next((d for d in decls if d[0] and not d[1] and not d[2]), None)
             if plain:
                 self.ctx.rename(words[1], plain[0])
@@ -752,7 +759,7 @@ class _Parser:
     def parse_field_stmt(self, decl):
         words = self.parse_specifiers()
         inline_anon = bool(words) and words[0] in ("struct", "union", "enum") and len(words) == 2 \
-            and words[1].startswith("_anon")
+            and (words[1] or "").startswith("_anon")
         if not words:
             decl.reason = decl.reason or "unsupported member declaration"
             return
@@ -891,6 +898,8 @@ class _Builder:
             sc = _named_scalar(w)
             if sc:
                 return sc, False, []
+            if w in ("wchar_t", "char16_t"):  # always the 2-byte UTF-16 unit
+                return ("wchar",), False, []
         if words[0] in ("struct", "union", "enum") and len(words) == 2:
             if words[0] == "union":
                 raise _Skip("union unsupported")
@@ -982,6 +991,8 @@ class _Builder:
             return S.bool_t
         if kind == "char":
             return S.char_t
+        if kind == "wchar":
+            return S.wchar_t
         if kind == "struct":
             return self.struct(base[1])
         if kind == "enum":
@@ -1007,6 +1018,8 @@ class _Builder:
         last = dims.pop()
         if not ptr and base == ("char",):
             elem = S.char_array[last]
+        elif not ptr and base == ("wchar",):
+            elem = S.wchar_array[last]
         elif not ptr and base == ("int", 8, False):
             elem = S.bytes_t[last]
         else:
@@ -1016,37 +1029,13 @@ class _Builder:
         return elem
 
 
-def from_header(path=None, *, text=None, byteorder: str = "little", align: bool | None = None,
-                defines: dict | None = None, long_size: int | None = None) -> HeaderTypes:
-    """Parse a C/C++ header (`path`, or source `text=`) into firstclass classes.
-
-    structs/classes become `@firstclass` dataclasses, enums/enum classes become `IntEnum`s.
-    Layout follows the C rules: natural alignment padding, unless the struct is
-    `#pragma pack(1)` / `__attribute__((packed))`. Override with `align=True/False`.
-    `defines` presets macros; `long_size` is the size of C `long` (default: this machine's).
-    Things that cannot be represented are listed in the result's `.skipped`.
-    """
-    if (path is None) == (text is None):
-        raise TypeError("pass exactly one of path or text=")
-    if path is not None:
-        text = Path(os.fspath(path)).read_text(encoding="utf-8", errors="replace")
-    if byteorder not in ("little", "big"):
-        raise ValueError(f"byteorder must be 'little' or 'big', got {byteorder!r}")
-    long_size = long_size or ctypes.sizeof(ctypes.c_long)
-    ctx = _Ctx(long_size)
-    pre = _Preprocessor(defines)
-    toks = _fold_attributes(pre.run(text, ctx))
-    _Parser(toks, ctx).parse_all()
-    for name, body in pre.macros.items():  # integer #defines are constants too
-        if name not in ctx.constants:
-            try:
-                ctx.constants[name] = ctx.eval(pre.expand(body, (name,)))
-            except (_ExprError, ValueError, KeyError):
-                pass
-
+def _assemble(ctx, byteorder, align) -> HeaderTypes:
+    """Build classes for everything the parser collected."""
     builder = _Builder(ctx, byteorder, align)
     result = HeaderTypes()
     result.constants = dict(ctx.constants)
+    if ctx.parse_error:
+        result.skipped["<input>"] = ctx.parse_error
     for name in list(ctx.structs):
         if name.startswith("_anon"):
             continue
@@ -1076,3 +1065,37 @@ def from_header(path=None, *, text=None, byteorder: str = "little", align: bool
         elif base[1] in result.skipped:
             result.skipped[name] = result.skipped[base[1]]
     return result
+
+
+def from_header(path=None, *, text=None, byteorder: str = "little", align: bool | None = None,
+                defines: dict | None = None, long_size: int | None = None) -> HeaderTypes:
+    """Parse a C/C++ header (`path`, or source `text=`) into firstclass classes.
+
+    structs/classes become `@firstclass` dataclasses, enums/enum classes become `IntEnum`s.
+    Layout follows the C rules: natural alignment padding, unless the struct is
+    `#pragma pack(1)` / `__attribute__((packed))`. Override with `align=True/False`.
+    `defines` presets macros; `long_size` is the size of C `long` (default: this machine's).
+    Things that cannot be represented are listed in the result's `.skipped`.
+    """
+    if (path is None) == (text is None):
+        raise TypeError("pass exactly one of path or text=")
+    if path is not None:
+        text = Path(os.fspath(path)).read_text(encoding="utf-8", errors="replace")
+    if byteorder not in ("little", "big"):
+        raise ValueError(f"byteorder must be 'little' or 'big', got {byteorder!r}")
+    long_size = long_size or ctypes.sizeof(ctypes.c_long)
+    ctx = _Ctx(long_size)
+    pre = _Preprocessor(defines)
+    toks = _fold_attributes(pre.run(text, ctx))
+    try:
+        _Parser(toks, ctx).parse_all()
+    except RecursionError:  # absurdly nested input: keep what was parsed before it
+        ctx.parse_error = "input nested too deeply to parse completely"
+    for name, body in pre.macros.items():  # integer #defines are constants too
+        if name not in ctx.constants:
+            try:
+                ctx.constants[name] = ctx.eval(pre.expand(body, (name,)))
+            except (_ExprError, ValueError, KeyError):
+                pass
+
+    return _assemble(ctx, byteorder, align)