2 Commits

Include renames

Author	SHA1	Message	Date
AnachronautandClaude Opus 5	fb335681d2	M4: SplitBit assembles SplitBit, and then assembles itself ... > load Asm.sbx > run cosmos.asm wrote cosmos.bin: program 7036, data 2448, labels 475 > run Asm.asm wrote Asm.sbx: program 7533, data 4099, labels 555 Both byte for byte identical to what the host assembler builds from the same source. The machine now builds the operating system it is running on, and builds the thing that built it. THE CHECK THAT MATTERS MOST IS THE THIRD ONE. A binary that matches could still have come from an assembler wrong in some way this particular source happens not to exercise. So Tests/native.sh boots the CosmOS that CosmOS built and has THAT assemble CosmOS again - and the second generation is identical to the first, down to the cycle count. It is a fixed point: the machinery has been through itself. After this the host is a convenience rather than a necessity. WHAT STOOD IN THE WAY was not the assembler. It loaded, faulted at 7,780 cycles, and the fault was in CosmOS: a loaded program is staged at 0x8000 before being blitted into place, so the whole FILE has to fit in the 32,768 bytes above it. The assembler's file was 33,983, and 22K of that was zeroed scratch buffers - because #Reserve emits what it reserves. None of that is initialised data. It is scratch, wanted only while the assembler runs, and while it runs everything above its own data is free. So the buffers are a MAP now rather than declarations - Assembler/scratch.asm writes down six addresses and the file carries none of it. 33,983 bytes became 11,648, and the assembler could load itself. The map has a file of its own because the reader and the label table both need addresses out of it while neither includes the other. The sizes are cut to the largest thing it is asked to build, and that turns out not to be the operating system: the assembler is 555 labels and 11,648 bytes of output against CosmOS's 475 and 9,564. The hardest thing this assembles is itself. Also: sizing it for CosmOS meant raising the label table, and raising the label table is what pushed the file over the staging limit. The two facts only met because the first one was tried. Speed, measured rather than guessed: CosmOS takes 80,168,646 cycles, which is eighty seconds of emulated time and under a second under --fast. Most of it is a straight walk of 475 label names, several thousand times. Sorting or bucketing that is easy and was deliberately not written before there was something to measure. make run-cosmos now puts every source file on the disk, so the whole thing can be done rather than read about. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01E2JrLzFvuFX9fgi1LDRjrW	2026-08-21 12:03:31 -04:00
AnachronautandClaude Opus 5	dcb331c151	SplitBit assembles SplitBit: M1, a single file with no includes ... Programs/CosmOS/Assembler/ is an assembler written in SplitBit assembly. It runs under CosmOS, reads source off a SplitBit disk, and writes a binary back to it with no host involved anywhere: > run Asm.sbx hello.asm wrote hello.bin: program 17, data 14, labels 2 THE ACCEPTANCE TEST IS THE BYTES. Tests/native.sh assembles Programs/hello.asm both ways and compares the two files byte for byte, then runs the one the machine built. "It ran" and "the sizes look right" both pass for a binary with a label one byte out, which is a program that jumps into the middle of an instruction - so the only honest test is the one SplitDisk and sbfs.asm already work under: two implementations of one written specification, each checking the other. The files are identical and the result prints Hello, World! in 70 cycles. hello.asm is the target because it is the oldest program in the repository. The first thing this machine ever ran is now the first thing it assembles for itself. TWO PASSES OVER STREAMED SOURCE. The C assembler reads every token of every file into one array; that cannot port, because cosmos.asm alone is 56,047 bytes against 64K of Data Memory. The native one streams through a 256 byte window, twice, and keeps only the label table between the passes. Two passes suffice because every length is known without resolving anything - an instruction's from its shape, a value's is one, a string's is its characters and a zero - so the first pass fixes every address and the second never needs a fixup list. A forward reference stops being a special case and becomes the reason there are two passes at all. The parts, each checked before anything was built on it: source.asm characters out of a file of any size, with a line number token.asm tokens out of characters, one character of lookahead classify.asm what a token is, in the C assembler's order, which IS the language: keyword, instruction, value, string, label labels.asm names packed in an arena, four bytes of index each numbers.asm sixteen bit arithmetic, since sbfs.asm's cannot be reached table.asm the instruction set, generated by the same script the monitor's copy is, and now BOTH are checked by docs.sh readTest.asm and tokenTest.asm check the reader and the tokenizer on their own, recorded as cosmosSource and cosmosTokens. A wrong classification does not produce a wrong byte somewhere obvious; it produces a right looking program of the wrong length, so it is worth catching where it happens. WHAT IT REFUSES: #Include, #Base, #Align, #Reserve and #Vectors are refused by name rather than ignored. Skipping a directive would produce a file that looked right and was the wrong length, which is the worst thing an assembler can do. Two traps worth recording, both already known to this project and both hit again: CALL restores A, B and DP0-DP2, so three routines returning an answer in A had it undone by their own return; and numStep works on DP0, so three sites that set DP1 left a pointer that never advanced. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01E2JrLzFvuFX9fgi1LDRjrW	2026-08-20 22:13:15 -04:00