[itsgrimetime]

Generate C readers for the known 32-bit big-endian layout and dispatch HSD_ArchiveGetPublicAs(type, archive, name) through a generated type table. Rust compiles annotations into field readers and branching code; native C supplies the host layout.

Readers recurse directly with ordinary archive-owned allocations and identity/reference caches for cycles and shared arrays. Remove the private arena, task/copy queues and runtime annotation/operator tables. Keep binding scopes in local arrays or constants, and tracing/readback/verifiers in test support. Fix first-field alias moves that could copy an enclosing record into undersized pointer storage, with independent fixtures for both traversal orders.

Keep existing HSD_Archive declarations and allocations. A TARGET_PC field owns native reader state; the remaining src changes provide typed dispatch and normal/preload cleanup. Remove DAT_NATIVE_READERS; MELEE_DAT_READERS only controls building the adapter locally.

Untyped/script data stays serialized; specialized lbArchiveRelocate consumers still need native integration. Caller pointers cannot follow moves from subsequently loaded roots. #3653 remains separate until this lands.

Validation: 58 Rust tests and Clippy; six native tests including parity/readback across 7,050 archives; ASan/UBSan HSD dispatch and typed access for 27 fighters. Reader-enabled game call sites compile, and the GALE01 MWCC rebuild matches its expected hash. 605/605 samples match. Formatting and EditorConfig pass. All eight CI build/check jobs pass on 724d002. Generated outputs are uncommitted.

[ribbanya]

Maybe I'm missing something but why does it need any of this stuff still? The task is to read an archive (meaning understand the header) then using some kind of type dispatch expand it to its in-memory form and return it. So GetPublicAs specifies the type and then the only job of the C code here is to read a symbol back as that type.

So I don't see why, for example, a growable vector or a private arena would be necessary.

[ribbanya]

The intended concept is very simple: Rust generates "dumb" C code that simply reads a 32-bit BE archive and translates it at runtime to the same struct laid out appropriately for the running platform. So each generated set of C files only understands one architecture and polymorphism is abstracted through simple tables and callbacks (a dispatched reader). It doesn't perform any complex reasoning, it just takes the type and symbol name requested from the HSD_ArchiveGetPublicAs and translates it.

Again, maybe I am missing something that makes this unviable but I can't think of anything. There should be enough information in the dwarf for the Rust code to generate this kind of C code.

[ribbanya]

So basically what we need is HSD_ArchiveGetPublicAs to be some kind of switch statement or indexed callback table based on the type argument. Then for each type, a generated translation unit is responsible for only reading that type from the serialized form to memory. Then the dispatcher returns the expanded type.

[ribbanya]

We can create a new #if branch definition for HSD_ArchiveGetPublicAs to facilitate this, under TARGET_PC maybe.

[ribbanya]

This is much better, thank you. Will need some tweaking for a while but it's a good foundation.

[ribbanya]

As I said, needs more iteration, but this looks good for now. Thanks!