AnachronautandClaude Opus 5
ccf4b384e1
Five .asm files sat at the top of Programs/ beside six directories, with
nothing to say which a new file should join - and hello.asm, which is the
native assembler's first target and named in sixteen places, looked like a
stray.
Programs/
Examples/ what you read to learn: hello, printHello, inputTest,
replCalculator, and Fibonacci, primeSieve and gameOfLife
as sets of their own
Libraries/ included by name, no entry point of their own
Loader/ loader.asm, and the loadable program it reads
CosmOS/ the system, its applications and its assembler
testPrograms/ what 'make test' drives
Loader/ is the one worth explaining. loader.asm is not a demonstration: it
reads a program off a disk, puts the two pieces where the header asks, and
jumps to the entry. CosmOS grew out of it and does the same thing as one of
its commands. It is kept because backward compatibility with the simplest
version of the system is a standing goal, and it was sitting loose next to
the demos as though it were one.
Programs/loadable/ was a directory holding one file called hello.asm - a
third thing of that name, and the name said nothing about why it was there.
It is Loader/loadable.asm now, beside the loader that reads it.
Every reference moved with them: the makefile's program list, twelve
manifest lines, makedisks.sh, native.sh, and four paths across the README
and both manuals. Verified by deleting both build directories and running
the whole suite from nothing.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01E2JrLzFvuFX9fgi1LDRjrW
147 lines
5.8 KiB
Makefile
147 lines
5.8 KiB
Makefile
# SplitBit Programs Makefile
|
|
# Anachronaut
|
|
#
|
|
# Builds every SplitBit program into build/, and keeps track of which libraries
|
|
# each one includes so that editing a library reassembles whatever depends on it.
|
|
#
|
|
# make Assemble everything.
|
|
# make clean Throw away build/.
|
|
# make run-hello Assemble and run one program.
|
|
|
|
ASM ?= ../Assembler
|
|
EMU ?= ../SplitBit
|
|
BUILD ?= build
|
|
|
|
# Libraries are included by bare name, so the assembler is told where to find them.
|
|
# CosmOS owns the filesystem library and the service names, so it is a place to look too.
|
|
INCLUDES = -I Libraries -I CosmOS/Source
|
|
|
|
# The programs worth building. Every one lives in a directory that says what kind it is:
|
|
# Examples/ is what you read to learn, Loader/ is the standalone loader CosmOS grew out of,
|
|
# CosmOS/ is the system. Files in Libraries/ are left out because they have no entry point
|
|
# of their own, and the ones in testPrograms/ are covered by 'make test' in the parent
|
|
# directory.
|
|
PROGRAMS = \
|
|
CosmOS/Source/cosmos.asm \
|
|
Examples/hello.asm \
|
|
Examples/printHello.asm \
|
|
Examples/inputTest.asm \
|
|
Examples/replCalculator.asm \
|
|
Examples/Fibonacci/8bitFibonacci.asm \
|
|
Examples/Fibonacci/16bitFibonacci.asm \
|
|
Examples/Fibonacci/32bitFibonacci.asm \
|
|
Examples/primeSieve/8bitSieve.asm \
|
|
Examples/primeSieve/16bitSegmentedSieve.asm \
|
|
Examples/primeSieve/16bitSegmentedSieveModern.asm \
|
|
Examples/gameOfLife/16x16Life.asm \
|
|
Examples/gameOfLife/16x16LifeModern.asm \
|
|
Loader/loader.asm \
|
|
Loader/loadable.asm
|
|
|
|
BINARIES = $(PROGRAMS:%.asm=$(BUILD)/%.bin)
|
|
DEPENDENCIES = $(BINARIES:.bin=.d)
|
|
|
|
all: $(BINARIES)
|
|
|
|
# -M writes out which source files went into the binary, in the form of a make rule.
|
|
$(BUILD)/%.bin: %.asm
|
|
@mkdir -p $(@D)
|
|
$(ASM) $(INCLUDES) -M $(@:.bin=.d) -o $@ $<
|
|
|
|
# Assemble and run a single program, as in 'make run-hello'.
|
|
run-%: $(BUILD)/%.bin
|
|
$(EMU) $<
|
|
|
|
# ---- CosmOS ----
|
|
#
|
|
# make cosmos Assemble the system and everything it can load.
|
|
# make cosmos-disk ... and put the loadable programs on a disk image.
|
|
# make run-cosmos ... and boot the machine with that disk in the drive.
|
|
#
|
|
# Programs in Apps/ say where they live with #Base, so the assembler writes them out as
|
|
# loadable programs rather than as boot images. They are named .sbx to keep that
|
|
# difference visible: a .bin is something the machine boots, a .sbx is something a
|
|
# running system loads.
|
|
|
|
DISKTOOL ?= ../SplitDisk
|
|
COSMOS = $(BUILD)/CosmOS/Source/cosmos.bin
|
|
APPS = $(patsubst CosmOS/Apps/%.asm,$(BUILD)/CosmOS/Apps/%.sbx,$(wildcard CosmOS/Apps/*.asm))
|
|
COSMOS_DISK = $(BUILD)/cosmos.img
|
|
DEPENDENCIES += $(APPS:.sbx=.d)
|
|
|
|
$(BUILD)/CosmOS/Apps/%.sbx: CosmOS/Apps/%.asm
|
|
@mkdir -p $(@D)
|
|
$(ASM) $(INCLUDES) -M $(@:.sbx=.d) -o $@ $<
|
|
|
|
# The assembler that runs on the machine. It is not in Apps/ because it is not one file:
|
|
# it has a directory of its own, the way the C assembler does. Its own pieces are found
|
|
# beside it without being told, since an include is looked for next to the file that asked
|
|
# for it before anywhere else; only services.asm needs the include path.
|
|
NATIVE_ASM = $(BUILD)/CosmOS/Assembler/Asm.sbx
|
|
DEPENDENCIES += $(NATIVE_ASM:.sbx=.d)
|
|
|
|
$(NATIVE_ASM): CosmOS/Assembler/Asm.asm
|
|
@mkdir -p $(@D)
|
|
$(ASM) $(INCLUDES) -M $(@:.sbx=.d) -o $@ $<
|
|
|
|
cosmos: $(COSMOS) $(APPS) $(NATIVE_ASM)
|
|
|
|
# Made from scratch every time, so that what is on it is what is in Apps/ now and not
|
|
# also whatever used to be.
|
|
$(COSMOS_DISK): $(APPS) $(NATIVE_ASM) testPrograms/stringKeyword.asm \
|
|
CosmOS/Apps/hello.asm CosmOS/Apps/Say.asm CosmOS/Apps/Keys.asm \
|
|
CosmOS/Source/services.asm CosmOS/Source/console.asm \
|
|
$(wildcard CosmOS/Source/*.asm) $(wildcard CosmOS/Assembler/*.asm)
|
|
@mkdir -p $(@D)
|
|
rm -f $@
|
|
$(DISKTOOL) format $@ 4096 8
|
|
@for app in $(APPS); do $(DISKTOOL) put $@ $$app; done
|
|
$(DISKTOOL) put $@ $(NATIVE_ASM)
|
|
@# SOURCE goes on as well, because an assembler with nothing to assemble is a
|
|
@# demonstration of nothing.
|
|
@#
|
|
@# hello.asm and Say.asm are the APPLICATION versions, so each assembles to a .sbx
|
|
@# written straight over the one the host tool put there - which means the next
|
|
@# thing loaded is a program the machine built itself, in the same breath.
|
|
@#
|
|
@# Keys.asm is the one that brings a vector of its own, so assembling it exercises the
|
|
@# version two header and the Vector Segment: the loader installs its handler, the
|
|
@# console interrupts into it, and the shell takes the vector back at exit.
|
|
@#
|
|
@# strings.asm is the odd one out on purpose: it has no #Include and no #Base, so it
|
|
@# comes out as a boot image rather than a loadable program, and the difference
|
|
@# between the two is visible on one disk.
|
|
$(DISKTOOL) put $@ CosmOS/Apps/hello.asm
|
|
$(DISKTOOL) put $@ CosmOS/Apps/Say.asm
|
|
$(DISKTOOL) put $@ CosmOS/Apps/Keys.asm
|
|
$(DISKTOOL) put $@ CosmOS/Source/services.asm
|
|
$(DISKTOOL) put $@ CosmOS/Source/console.asm
|
|
$(DISKTOOL) put $@ testPrograms/stringKeyword.asm strings.asm
|
|
@# And the whole of CosmOS, and the whole of the assembler, so that the machine can
|
|
@# build the system it is running on and then build the thing that built it:
|
|
@#
|
|
@# > load Asm.sbx
|
|
@# > run cosmos.asm
|
|
@# > run Asm.asm
|
|
@#
|
|
@# Both come out byte for byte what the host tool makes from the same source.
|
|
@for f in CosmOS/Source/*.asm CosmOS/Assembler/*.asm; do \
|
|
$(DISKTOOL) put $@ $$f >/dev/null; done
|
|
|
|
# The system as well as the disk. Building only the image leaves whatever cosmos.bin was
|
|
# there before, or none at all, and then the disk is booted with a system that does not
|
|
# match the programs on it.
|
|
cosmos-disk: $(COSMOS) $(COSMOS_DISK)
|
|
|
|
run-cosmos: $(COSMOS) $(COSMOS_DISK)
|
|
$(EMU) --disk $(COSMOS_DISK) $(COSMOS)
|
|
|
|
clean:
|
|
rm -rf $(BUILD)
|
|
|
|
# Pull in the dependency rules written by -M above, so that touching a library
|
|
# reassembles every program that includes it.
|
|
-include $(DEPENDENCIES)
|
|
|
|
.PHONY: all clean cosmos cosmos-disk run-cosmos
|