collapseos/tools/emul/Makefile

TARGETS = shell/shell zasm/zasm runbin/runbin
CFSPACK = ../cfspack/cfspack
KERNEL = ../../kernel
APPS = ../../apps
ZASMBIN = zasm/zasm
INCCFS = zasm/includes.cfs
SRCPATTERN = *.+(asm|h)

.PHONY: all
all: $(TARGETS)

shell/kernel.h: shell/shell_.asm $(ZASMBIN) $(INCCFS)
	$(ZASMBIN) $(INCCFS) < $< | ./bin2c.sh KERNEL | tee $@ > /dev/null

zasm/kernel.h: zasm/kernel.bin
	./bin2c.sh KERNEL < $< | tee $@ > /dev/null

zasm/user.h: zasm/zasm.bin
	./bin2c.sh USERSPACE < $< | tee $@ > /dev/null

$(INCCFS): $(CFSPACK)
	$(CFSPACK) $(KERNEL) "$(SRCPATTERN)" > $@
	$(CFSPACK) $(APPS) "$(SRCPATTERN)" >> $@
	$(CFSPACK) user.h >> $@

shell/shell: shell/shell.c libz80/libz80.o shell/kernel.h $(CFSPACK)
$(ZASMBIN): zasm/zasm.c libz80/libz80.o zasm/kernel.h zasm/user.h
runbin/runbin: runbin/runbin.c libz80/libz80.o
$(TARGETS):
	$(CC) $< libz80/libz80.o -o $@

libz80/libz80.o: libz80/z80.c
	make -C libz80/codegen opcodes
	$(CC) -Wall -ansi -g -c -o libz80/libz80.o libz80/z80.c

$(CFSPACK):
	make -C ../cfspack

.PHONY: updatebootstrap
updatebootstrap: $(ZASMBIN) $(INCCFS)
	$(ZASMBIN) $(INCCFS) < zasm/glue.asm > zasm/kernel.bin
	$(ZASMBIN) $(INCCFS) < $(APPS)/zasm/glue.asm > zasm/zasm.bin

# Sometimes, when developing zasm, stuff get messed up and it's hard to unmess
# because zasm's brake-up ends up in its bootstrap bins. Sure, we can revert
# from git, but if we're in the middle of some work, it's inconvenient. As long
# as we don't diverge from scas's syntax, it can come to the recue!
.PHONY: rescue
rescue:
	scas -o zasm/kernel.bin -I $(KERNEL) zasm/glue.asm
	scas -o zasm/zasm.bin -I $(APPS) -I $(KERNEL) $(APPS)/zasm/glue.asm

.PHONY: clean
clean:
	rm -f $(TARGETS) zasm/{kernel,user}.h shell/kernel.h zasm/includes.*
Add the concept of unit tests Will be much much easier to tests new core routines without having to re-create their context first. Also, extract parse.asm from core.asm 2019-05-17 23:33:20 +10:00			`TARGETS = shell/shell zasm/zasm runbin/runbin`
zasm emul: add tooling for includes fsdev On build, pack `parts/z80` into a CFS and embed it into the emulated zasm executable as an fsdev. This will allow for the upcoming include directive to have something to go to. For now, this is useless except for inflating the emulated zasm's size. 2019-05-17 02:07:57 +10:00			`CFSPACK = ../cfspack/cfspack`
Move /parts/z80 to /kernel Let go of that "meta os" thing. it's not as meta as I made it sound like. It's a kernel. 2019-05-20 01:19:41 +10:00			`KERNEL = ../../kernel`
zasm emul: get rid of the kernel/user distinction Made things complicated for nothing. 2019-05-19 23:14:40 +10:00			`APPS = ../../apps`
zasm now bootstraps itself without scas! 2019-05-20 05:03:34 +10:00			`ZASMBIN = zasm/zasm`
Parametrize zasm linux bin's include CFS file ... instead of embedding it in the binary itself. Additionally, add a "zasm.sh" wrapper to faciliate zasm calls on a linux machine. 2019-06-03 05:50:59 +10:00			`INCCFS = zasm/includes.cfs`
Simplyfy the creation of includes.cfs The next step is to generate them on-the-fly. 2019-06-03 06:47:17 +10:00			`SRCPATTERN = *.+(asm\|h)`
Move apps/zasm/emul to tools/emul 2019-05-10 04:09:40 +10:00
Add tools/emul 2019-05-10 02:58:41 +10:00			`.PHONY: all`
Move apps/zasm/emul to tools/emul 2019-05-10 04:09:40 +10:00			`all: $(TARGETS)`
Add tools/emul 2019-05-10 02:58:41 +10:00
Parametrize zasm linux bin's include CFS file ... instead of embedding it in the binary itself. Additionally, add a "zasm.sh" wrapper to faciliate zasm calls on a linux machine. 2019-06-03 05:50:59 +10:00			`shell/kernel.h: shell/shell_.asm $(ZASMBIN) $(INCCFS)`
			`$(ZASMBIN) $(INCCFS) < $< \| ./bin2c.sh KERNEL \| tee $@ > /dev/null`
zasm emul: bring back kernel/user distinction It was a bad idea to remove it. Now that I'm introducing the concept of a per-app glue file, it becomes much easier to build emulated zasm as a userspace app. 2019-05-20 02:57:59 +10:00
zasm now bootstraps itself without scas! 2019-05-20 05:03:34 +10:00			`zasm/kernel.h: zasm/kernel.bin`
			`./bin2c.sh KERNEL < $< \| tee $@ > /dev/null`

			`zasm/user.h: zasm/zasm.bin`
			`./bin2c.sh USERSPACE < $< \| tee $@ > /dev/null`
Add tools/emul 2019-05-10 02:58:41 +10:00
Parametrize zasm linux bin's include CFS file ... instead of embedding it in the binary itself. Additionally, add a "zasm.sh" wrapper to faciliate zasm calls on a linux machine. 2019-06-03 05:50:59 +10:00			`$(INCCFS): $(CFSPACK)`
Simplyfy the creation of includes.cfs The next step is to generate them on-the-fly. 2019-06-03 06:47:17 +10:00			`$(CFSPACK) $(KERNEL) "$(SRCPATTERN)" > $@`
			`$(CFSPACK) $(APPS) "$(SRCPATTERN)" >> $@`
			`$(CFSPACK) user.h >> $@`
zasm emul: add tooling for includes fsdev On build, pack `parts/z80` into a CFS and embed it into the emulated zasm executable as an fsdev. This will allow for the upcoming include directive to have something to go to. For now, this is useless except for inflating the emulated zasm's size. 2019-05-17 02:07:57 +10:00
tools/emul: clean up the place a bit 2019-05-17 21:23:59 +10:00			`shell/shell: shell/shell.c libz80/libz80.o shell/kernel.h $(CFSPACK)`
Parametrize zasm linux bin's include CFS file ... instead of embedding it in the binary itself. Additionally, add a "zasm.sh" wrapper to faciliate zasm calls on a linux machine. 2019-06-03 05:50:59 +10:00			`$(ZASMBIN): zasm/zasm.c libz80/libz80.o zasm/kernel.h zasm/user.h`
Add the concept of unit tests Will be much much easier to tests new core routines without having to re-create their context first. Also, extract parse.asm from core.asm 2019-05-17 23:33:20 +10:00			`runbin/runbin: runbin/runbin.c libz80/libz80.o`
Move apps/zasm/emul to tools/emul 2019-05-10 04:09:40 +10:00			`$(TARGETS):`
zasm: add support for .fill directive 2019-05-20 22:20:00 +10:00			`$(CC) $< libz80/libz80.o -o $@`
Add tools/emul 2019-05-10 02:58:41 +10:00
			`libz80/libz80.o: libz80/z80.c`
			`make -C libz80/codegen opcodes`
zasm: add support for .fill directive 2019-05-20 22:20:00 +10:00			`$(CC) -Wall -ansi -g -c -o libz80/libz80.o libz80/z80.c`
Add tools/emul 2019-05-10 02:58:41 +10:00
zasm emul: add tooling for includes fsdev On build, pack `parts/z80` into a CFS and embed it into the emulated zasm executable as an fsdev. This will allow for the upcoming include directive to have something to go to. For now, this is useless except for inflating the emulated zasm's size. 2019-05-17 02:07:57 +10:00			`$(CFSPACK):`
tools/emul/shell: add filesystem support With the help of the newly-introduced cfspack tool, we can mount a filesystem in our emulated shell and play around. Read-only for now. Unpacking incoming. 2019-05-13 01:20:31 +10:00			`make -C ../cfspack`

zasm now bootstraps itself without scas! 2019-05-20 05:03:34 +10:00			`.PHONY: updatebootstrap`
Parametrize zasm linux bin's include CFS file ... instead of embedding it in the binary itself. Additionally, add a "zasm.sh" wrapper to faciliate zasm calls on a linux machine. 2019-06-03 05:50:59 +10:00			`updatebootstrap: $(ZASMBIN) $(INCCFS)`
			`$(ZASMBIN) $(INCCFS) < zasm/glue.asm > zasm/kernel.bin`
			`$(ZASMBIN) $(INCCFS) < $(APPS)/zasm/glue.asm > zasm/zasm.bin`
zasm now bootstraps itself without scas! 2019-05-20 05:03:34 +10:00
tools/emul: add "make rescue" command 2019-05-20 22:58:53 +10:00			`# Sometimes, when developing zasm, stuff get messed up and it's hard to unmess`
			`# because zasm's brake-up ends up in its bootstrap bins. Sure, we can revert`
			`# from git, but if we're in the middle of some work, it's inconvenient. As long`
			`# as we don't diverge from scas's syntax, it can come to the recue!`
			`.PHONY: rescue`
			`rescue:`
			`scas -o zasm/kernel.bin -I $(KERNEL) zasm/glue.asm`
Make userspace parse args the same way the shell does 2019-06-03 04:05:20 +10:00			`scas -o zasm/zasm.bin -I $(APPS) -I $(KERNEL) $(APPS)/zasm/glue.asm`
tools/emul: add "make rescue" command 2019-05-20 22:58:53 +10:00
Add tools/emul 2019-05-10 02:58:41 +10:00			`.PHONY: clean`
			`clean:`
zasm now bootstraps itself without scas! 2019-05-20 05:03:34 +10:00			`rm -f $(TARGETS) zasm/{kernel,user}.h shell/kernel.h zasm/includes.*`