Add full compiler toolchain, libc, examples and reference docs

First substantive commit: the entire Sprinter C compiler tree on top of
the bare README+gitignore initial commit.

What's in here:
  bin/sprinter-cc        — driver script invoking SDCC + linker + mkexe
  libc/                  — Sprinter-specific libc layer over ESTEX/BIOS
                           (conio, gfx, io, mem, stdio + headers)
  runtime/               — crt0 variants (default/small/banked/minimal)
                           + heap + bank trampolines
  toolchain/             — mkexe (SprintEXE packer, C + tests)
  examples/              — 30 demo programs (gfx, file I/O, env, time, …)
  lib/Makefile           — builds the libc archive (sprinter.lib)
  docs/                  — converted Sprinter manuals + asm reference samples
  third_party/           — solid-c reference compiler dump + sdcc setup script
  release_docs/          — packaging / release notes

gitignore overhaul:
  • Drop dangerous blanket patterns: *.asm (would hide docs/samples/*.asm)
    and *.exe (case-insensitive match was hiding third_party/solid-c/*.EXE
    on macOS APFS).  Replaced with examples/*/*.{asm,exe,…} and lib/*.lib.
  • Restore tracking of toolchain/mkexe/tests/{one,big}.bin — those are
    INPUT fixtures, not build outputs.
  • Collapse the duplicated SDCC/C/Sdcc sections into one section per
    concern (build outputs / vendored / OS-junk).
  • Add .sprinter-cc-*/, build/ (catches lib/build/ too), .claude/.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

libc/mem/bank_io.c

@@ -0,0 +1,51 @@
+/*
+ * bank_io — HOME-resident helpers to read/write a "far" page that lives
+ * in some physical RAM page outside the currently-mapped W3 bank.
+ *
+ *   - We always run from HOME (window 1, always mapped), so we are free
+ *     to swap W3 (port 0xE2) between the caller's bank and the data
+ *     page, then restore it before returning.
+ *   - The caller must not rely on W3 contents during the call — the swap
+ *     is transparent to instruction-fetch (we execute from W1), and only
+ *     this function touches W3.
+ *   - DI/EI is NOT applied around the swap; ISRs in HOME are unaffected,
+ *     and banked-call ISRs are not expected in our current design.
+ */
+
+#include <stdint.h>
+#include <string.h>
+#include <sprinter.h>
+#include <sprinter_mem.h>
+
+uint8_t bank_load_byte(uint8_t phys_page, uint16_t off_in_window)
+{
+    uint8_t saved = _io_page_w3;
+    sprinter_page_w3(phys_page);
+    uint8_t v = *((volatile uint8_t *)(0xC000u + off_in_window));
+    sprinter_page_w3(saved);
+    return v;
+}
+
+void bank_store_byte(uint8_t phys_page, uint16_t off_in_window, uint8_t v)
+{
+    uint8_t saved = _io_page_w3;
+    sprinter_page_w3(phys_page);
+    *((volatile uint8_t *)(0xC000u + off_in_window)) = v;
+    sprinter_page_w3(saved);
+}
+
+void bank_read(uint8_t phys_page, uint16_t off, void *dst, uint16_t n)
+{
+    uint8_t saved = _io_page_w3;
+    sprinter_page_w3(phys_page);
+    memcpy(dst, (const void *)(0xC000u + off), n);
+    sprinter_page_w3(saved);
+}
+
+void bank_write(uint8_t phys_page, uint16_t off, const void *src, uint16_t n)
+{
+    uint8_t saved = _io_page_w3;
+    sprinter_page_w3(phys_page);
+    memcpy((void *)(0xC000u + off), src, n);
+    sprinter_page_w3(saved);
+}

libc/mem/mem_alloc.c

@@ -0,0 +1,99 @@
+/*
+ * mem_alloc_pages / mem_free_block / mem_get_page / mem_info — ESTEX EMM
+ * wrappers for explicit 16 KB-page allocation.
+ *
+ *   ESTEX $3C INFOMEM    → HL=total pages, BC=free pages
+ *   ESTEX $3D GETMEM     B=npages       → A=block id,        CF=err
+ *   ESTEX $3E FREEMEM    A=block id     →                    CF=err
+ *   BIOS  $C4 EMM_GETPAGE A=blk, B=idx  → A=physical page    CF=err
+ *
+ * Pattern: every RST 10h / RST 8 is bracketed with push/pop IX because
+ * ESTEX/BIOS clobber it and the C caller uses it as a frame pointer.
+ */
+
+#include <stdint.h>
+#include <sprinter_mem.h>
+
+uint8_t mem_alloc_pages(uint8_t n) __naked
+{
+    (void)n;
+    __asm
+        ;; SDCC single-uint8 arg → A on entry.
+        push  ix
+        ld    b, a
+        ld    c, #0x3D
+        rst   #0x10
+        pop   ix
+        jr    c, _alloc_fail
+        ret
+    _alloc_fail:
+        call  __errno_set
+        xor   a, a                  ; 0 = failure
+        ret
+    __endasm;
+}
+
+void mem_free_block(uint8_t blk_id) __naked
+{
+    (void)blk_id;
+    __asm
+        ;; SDCC single-uint8 arg → A on entry.
+        push  ix
+        ld    c, #0x3E
+        rst   #0x10
+        pop   ix
+        ret
+    __endasm;
+}
+
+uint8_t mem_get_page(uint8_t blk_id, uint8_t idx) __naked
+{
+    (void)blk_id; (void)idx;
+    __asm
+        ;; 2-arg uint8/uint8: blk_id → A, idx → L.
+        push  ix
+        ld    b, l                  ; BIOS wants idx in B
+        ;; A still has blk_id
+        ld    c, #0xC4              ; BIOS EMM_GETPAGE
+        rst   #0x08
+        pop   ix
+        ;; A = physical page number.  Return as uint8 → A.
+        ret
+    __endasm;
+}
+
+void mem_info(uint16_t *total, uint16_t *free_pages) __naked
+{
+    (void)total; (void)free_pages;
+    __asm
+        ;; HL = total, DE = free_pages on entry.
+        ;; ESTEX INFOMEM clobbers everything; stash both pointers on stack.
+        push  ix
+        push  hl                    ; [SP+0..1] = total ptr
+        push  de                    ; [SP+2..3] = free_pages ptr  (wait wrong order)
+
+        ;; Actually after two pushes: SP+0 = free_pages_ptr, SP+2 = total_ptr.
+        ;; That's the layout we'll use below.
+
+        ld    c, #0x3C              ; ESTEX INFOMEM → HL=total, BC=free
+        rst   #0x10
+        ;; HL = total value, BC = free value.
+
+        pop   de                    ; DE = free_pages ptr
+        ld    a, c
+        ld    (de), a
+        inc   de
+        ld    a, b
+        ld    (de), a
+
+        pop   de                    ; DE = total ptr
+        ld    a, l
+        ld    (de), a
+        inc   de
+        ld    a, h
+        ld    (de), a
+
+        pop   ix
+        ret
+    __endasm;
+}