emul: embed blkfs in forth binary

This will allow us to read from blkfs in tests.
Move /emul/forth/* to /emul
2020-04-24 18:01:55 -04:00 · 2020-04-24 17:53:58 -04:00 · 2020-04-24 14:10:40 -04:00 · 2020-04-24 12:10:07 -04:00 · 2020-04-24 10:59:59 -04:00 · 2020-04-24 10:59:28 -04:00
33 changed files with 101 additions and 416 deletions
--- a/blk/061
+++ b/blk/061
@ -1,6 +1,6 @@
-(cont.)
 ." xxx" --     *I* Compiles string literal xxx followed by a
               call to (print).
+C<?     -- f   Returns whether there's a char waiting in buf.
 C<      -- c   Read one char from buffered input.
 DUMP    n a -- Prints n bytes at addr a in a hexdump format.
               Prints in chunks of 8 bytes. Doesn't do partial
--- a/blk/081
+++ b/blk/081
@ -2,10 +2,10 @@
 RAMSTART  INITIAL_SP    +53       readln's variables
 +02       CURRENT       +55       adev's variables
 +04       HERE          +57       blk's variables
-+06       FUTURE USES   +59       z80a's variables
-+08       FLAGS         +5b       FUTURE USES
+06       C<?*          +59       z80a's variables
+08       C<* override  +5b       FUTURE USES
 +0a       PARSEPTR      +70       DRIVERS
-+0c       CINPTR        +80       RAMEND
+0c       C<*           +80       RAMEND
 +0e       WORDBUF
 +2e       BOOT C< PTR
 +4e       INTJUMP
--- a/blk/082
+++ b/blk/082
@ -1,4 +1,4 @@
-(cont.) INITIAL_SP holds the initial Stack Pointer value so
+INITIAL_SP holds the initial Stack Pointer value so
 that we know where to reset it on ABORT

 CURRENT points to the last dict entry.
@ -7,10 +7,10 @@ HERE points to current write offset.

 IP is the Interpreter Pointer

-FLAGS holds global flags. Only used for prompt output control
-for now.
-
 PARSEPTR holds routine address called on (parse)

-CINPTR holds routine address called on C<
+C<* holds routine address called on C<. If the C<* override
+at 0x08 is nonzero, this routine is called instead.
+
+
                                                        (cont.)
--- a/blk/083
+++ b/blk/083
@ -1,4 +1,7 @@
-(cont.) WORDBUF is the buffer used by WORD
+C<?* is a pointer to a word being called by C<?. If 0 or 1,
+will return that value as-is.
+
+WORDBUF is the buffer used by WORD

 BOOT C< PTR is used when Forth boots from in-memory
 source. See "Initialization sequence" below.
@ -9,8 +12,5 @@ jump to this address. If you use one of those slots for an
 interrupt, write a jump to the appropriate offset in that RAM
 location.

-CURRENTPTR points to current CURRENT. The Forth CURRENT word
-doesn't return RAM+2 directly, but rather the value at this
-address. Most of the time, it points to RAM+2, but sometimes,
-when maintaining alternative dicts (during cross compilation
-for example), it can point elsewhere.                   (cont.)
+
+                                                        (cont.)
--- a/blk/084
+++ b/blk/084
@ -1,4 +1,10 @@
-(cont.) FUTURE USES section is unused for now.          
+CURRENTPTR points to current CURRENT. The Forth CURRENT word
+doesn't return RAM+2 directly, but rather the value at this
+address. Most of the time, it points to RAM+2, but sometimes,
+when maintaining alternative dicts (during cross compilation
+for example), it can point elsewhere.
+
+FUTURE USES section is unused for now.          

 DRIVERS section is reserved for recipe-specific
 drivers. Here is a list of known usages:
@ -8,9 +14,3 @@ drivers. Here is a list of known usages:



-
-
-
-
-
-
--- a/blk/393
+++ b/blk/393
@ -1,5 +1,4 @@
 : RAM+ [ RAMSTART LITN ] + ;
-: FLAGS 0x08 RAM+ ;
 : (parse*) 0x0a RAM+ ;
 : HERE 0x04 RAM+ ;
 : CURRENT* 0x51 RAM+ ;
@ -9,7 +8,8 @@
 : (find) CURRENT @ SWAP _find ;

 : QUIT
-    0 FLAGS ! (resRS)
+    (resRS)
+    0 0x08 RAM+ !  ( 08 == C<* override )
    LIT< INTERPRET (find) DROP EXECUTE
 ;
 394 407 LOADR
--- a/blk/398
+++ b/blk/398
@ -2,7 +2,12 @@
  for an abort message )
 : (parse) (parsed) NOT IF ABORT THEN ;

-: C< 0x0c RAM+ @ EXECUTE ( 0c == CINPTR ) ;
+: C<? 0x06 RAM+ @ DUP 2 > IF EXECUTE THEN ( 06 == C<?* ) ;
+: C<
+    0x08 RAM+ @  ( 08 == C<* override )
+    DUP NOT IF DROP 0x0c RAM+ @ THEN  ( 0c == C<* )
+    EXECUTE
+;

 : , HERE @ ! HERE @ 2+ HERE ! ;

--- a/blk/403
+++ b/blk/403
@ -2,13 +2,8 @@
    BEGIN
    WORD
    (find)
-    IF
-        1 FLAGS !
-        EXECUTE
-        0 FLAGS !
-    ELSE
-        (parse*) @ EXECUTE
-    THEN
+    NOT IF (parse*) @ THEN EXECUTE
+    C<? NOT IF LIT< (ok) (find) IF EXECUTE THEN THEN
    AGAIN
 ;

--- a/blk/405
+++ b/blk/405
@ -3,8 +3,11 @@
    LIT< (parse) (find) DROP (parse*) !
    ( 2e == SYSTEM SCRATCHPAD )
    CURRENT @ 0x2e RAM+ !
-    ( 0c == CINPTR )
+    0 0x08 RAM+ !  ( 08 == C<* override )
+    ( 0c == C<* )
    LIT< (boot<) (find) DROP 0x0c RAM+ !
+    ( boot< always has a char waiting. 06 == C<?* )
+    1 0x06 RAM+ !
    LIT< INIT (find)
    IF EXECUTE
    ELSE DROP INTERPRET THEN
--- a/emul/.gitignore
+++ b/emul/.gitignore
@ -1,7 +1,8 @@
-/forth/stage1
-/forth/stage1dbg
-/forth/stage2
-/forth/forth
-/*/*-bin.h
-/*/*.bin
+/stage1
+/stage1dbg
+/stage2
+/forth
+/*-bin.h
+/core.bin
+/forth?.bin
 /blkfs
--- a/emul/Makefile
+++ b/emul/Makefile
@ -1,7 +1,7 @@
-TARGETS = forth/forth forth/stage2
+TARGETS = forth stage2
 # Those Forth source files are in a particular order
 FORTHSRCS = core.fs cmp.fs print.fs parse.fs readln.fs fmt.fs blk.fs
-FORTHSRC_PATHS = ${FORTHSRCS:%=../forth/%} forth/run.fs
+FORTHSRC_PATHS = ${FORTHSRCS:%=../forth/%} run.fs
 OBJS = emul.o libz80/libz80.o
 SLATEST = ../tools/slatest
 STRIPFC = ../tools/stripfc
@ -23,43 +23,43 @@ $(BLKUNPACK): $(BLKPACK)

 # z80c.bin is not in the prerequisites because it's a bootstrap
 # binary that should be updated manually through make updatebootstrap.
-forth/forth0.bin: $(SLATEST)
-	cp forth/z80c.bin $@
+forth0.bin: $(SLATEST)
+	cp z80c.bin $@
 	$(SLATEST) $@
-	cat forth/pre.fs forth/emul.fs >> $@
+	cat pre.fs emul.fs >> $@

-forth/forth0-bin.h: forth/forth0.bin $(BIN2C)
-	$(BIN2C) KERNEL < forth/forth0.bin | tee $@ > /dev/null
+forth0-bin.h: forth0.bin $(BIN2C)
+	$(BIN2C) KERNEL < forth0.bin | tee $@ > /dev/null

-forth/stage1: forth/stage.c $(OBJS) forth/forth0-bin.h 
-	$(CC) forth/stage.c $(OBJS) -o $@
+stage1: stage.c $(OBJS) forth0-bin.h 
+	$(CC) stage.c $(OBJS) -o $@

-forth/stage1dbg: forth/stage.c $(OBJS) forth/forth0-bin.h 
-	$(CC) -DDEBUG forth/stage.c $(OBJS) -o $@
+stage1dbg: stage.c $(OBJS) forth0-bin.h 
+	$(CC) -DDEBUG stage.c $(OBJS) -o $@

 # We don't really need to use stripfc, but we do it anyway to test that we
 # don't mistakenly break our code with that tool. It's easier to debug here.
-forth/core.bin: $(FORTHSRC_PATHS) forth/stage1
-	cat $(FORTHSRC_PATHS) ./forth/stop.fs | $(STRIPFC) | ./forth/stage1 > $@
+core.bin: $(FORTHSRC_PATHS) stage1
+	cat $(FORTHSRC_PATHS) stop.fs | $(STRIPFC) | ./stage1 > $@

-forth/forth1.bin: forth/core.bin $(SLATEST)
-	cat forth/z80c.bin forth/core.bin > $@
+forth1.bin: core.bin $(SLATEST)
+	cat z80c.bin core.bin > $@
 	$(SLATEST) $@

-forth/forth1-bin.h: forth/forth1.bin $(BIN2C)
-	$(BIN2C) KERNEL < forth/forth1.bin > $@
+forth1-bin.h: forth1.bin $(BIN2C)
+	$(BIN2C) KERNEL < forth1.bin > $@

-forth/stage2: forth/stage.c $(OBJS) forth/forth1-bin.h forth/blkfs-bin.h
-	$(CC) -DSTAGE2 forth/stage.c $(OBJS) -o $@
+stage2: stage.c $(OBJS) forth1-bin.h blkfs-bin.h
+	$(CC) -DSTAGE2 stage.c $(OBJS) -o $@

 blkfs: $(BLKPACK)
 	$(BLKPACK) ../blk > $@

-forth/blkfs-bin.h: blkfs $(BIN2C)
+blkfs-bin.h: blkfs $(BIN2C)
 	$(BIN2C) BLKFS < blkfs > $@

-forth/forth: forth/forth.c $(OBJS) forth/forth1-bin.h blkfs
-	$(CC) forth/forth.c $(OBJS) -o $@
+forth: forth.c $(OBJS) forth1-bin.h blkfs-bin.h
+	$(CC) forth.c $(OBJS) -o $@

 libz80/libz80.o: libz80/z80.c
 	$(MAKE) -C libz80/codegen opcodes
@ -70,8 +70,8 @@ emul.o: emul.c


 .PHONY: updatebootstrap
-updatebootstrap: forth/stage2
-	cat ./forth/xcomp.fs | ./forth/stage2 > ./forth/z80c.bin
+updatebootstrap: stage2
+	cat xcomp.fs | ./stage2 > z80c.bin

 .PHONY: pack
 pack:
@ -83,5 +83,5 @@ unpack:

 .PHONY: clean
 clean:
-	rm -f $(TARGETS) emul.o forth/*-bin.h forth/forth?.bin blkfs
+	rm -f $(TARGETS) emul.o *-bin.h forth?.bin blkfs
 	$(MAKE) -C ../tools clean
--- a/emul/forth/emul.fs
+++ b/emul/forth/emul.fs
--- a/emul/forth/forth.c
+++ b/emul/forth/forth.c
@ -2,8 +2,9 @@
 #include <stdio.h>
 #include <unistd.h>
 #include <termios.h>
-#include "../emul.h"
+#include "emul.h"
 #include "forth1-bin.h"
+#include "blkfs-bin.h"

 // in sync with glue.asm
 #define RAMSTART 0x900
@ -102,6 +103,12 @@ int main(int argc, char *argv[])
        return 1;
    }
    blkfp = fopen("blkfs", "r+");
+    if (blkfp) {
+        fprintf(stderr, "Using blkfs file\n");
+    } else {
+        blkfp = fmemopen((char*)BLKFS, sizeof(BLKFS), "r");
+        fprintf(stderr, "Using in-memory read-only blkfs\n");
+    }
    Machine *m = emul_init();
    m->ramstart = RAMSTART;
    m->iord[STDIO_PORT] = iord_stdio;
--- a/emul/forth/pre.fs
+++ b/emul/forth/pre.fs
--- a/emul/forth/run.fs
+++ b/emul/forth/run.fs
@ -19,5 +19,6 @@
    ['] EFS! BLK!* !
    RDLN$
    LIT< _sys [entry]
+    ." Collapse OS" CRLF
    INTERPRET
 ;
--- a/emul/forth/stage.c
+++ b/emul/forth/stage.c
@ -1,7 +1,7 @@
 #include <stdint.h>
 #include <stdio.h>
 #include <unistd.h>
-#include "../emul.h"
+#include "emul.h"
 #ifdef STAGE2
 #include "forth1-bin.h"
 #include "blkfs-bin.h"
--- a/emul/forth/stop.fs
+++ b/emul/forth/stop.fs
--- a/emul/forth/xcomp.fs
+++ b/emul/forth/xcomp.fs
--- a/emul/forth/z80c.bin
+++ b/emul/forth/z80c.bin
--- a/forth/blk.fs
+++ b/forth/blk.fs
@ -61,28 +61,28 @@
 ;

 : LOAD
-    ( save BLK>, CINPTR and boot< ptr to RSP )
+    ( save BLK>, C<* override and boot< ptr to RSP )
    BLK> @ >R
-    0x0c RAM+ @ >R
+    0x08 RAM+ @ >R
    0x2e RAM+ @ >R
    BLK@
    ( Point to beginning of BLK )
    BLK( 0x2e RAM+ !
-    ( 0c == CINPTR )
-    ['] _ 0x0c RAM+ !
+    ( 08 == C<* override )
+    ['] _ 0x08 RAM+ !
    INTERPRET
    R> 0x2e RAM+ !
-    ( Before we restore CINPTR, are we restoring it to "_"?
+    ( Before we restore C<* are we restoring it to "_"?
      if yes, it means we're in a nested LOAD which means we
      should also load back the saved BLK>. Otherwise, we can
      ignore the BLK> from RSP. )
-    I 0x0c RAM+ @ = IF
+    I 0x08 RAM+ @ = IF
        ( nested load )
-        R> DROP ( CINPTR )
+        R> DROP ( C<* )
        R> BLK@
    ELSE
        ( not nested )
-        R> 0x0c RAM+ !
+        R> 0x08 RAM+ !
        R> DROP ( BLK> )
    THEN
 ;
--- a/forth/core.fs
+++ b/forth/core.fs
@ -3,7 +3,7 @@
    CURRENT @ 1-
    DUP C@ 128 OR SWAP C!
 ;
-: [ INTERPRET 1 FLAGS ! ; IMMEDIATE
+: [ INTERPRET ; IMMEDIATE
 : ] R> DROP ;
 : LITS 34 , SCPY ;
 : LIT< WORD LITS ; IMMEDIATE
--- a/forth/print.fs
+++ b/forth/print.fs
@ -26,10 +26,12 @@
 : ABORT" [COMPILE] ." COMPILE ABORT ; IMMEDIATE

 : (uflw) ABORT" stack underflow" ;
-: (wnf) ABORT" word not found" ;

 : BS 8 EMIT ;
 : LF 10 EMIT ;
 : CR 13 EMIT ;
 : CRLF CR LF ;
 : SPC 32 EMIT ;
+
+: (wnf) (print) SPC ABORT" word not found" ;
+: (ok) SPC ." ok" CRLF ;
--- a/forth/readln.fs
+++ b/forth/readln.fs
@ -54,17 +54,16 @@

 ( Read one line in input buffer and make IN> point to it )
 : (rdln)
-    ( Should we prompt? if we're executing a word, FLAGS bit
-      0, then we shouldn't. )
-    FLAGS @ 0x1 AND NOT IF '>' EMIT SPC THEN
    (infl)
    BEGIN (rdlnc) NOT UNTIL
    LF IN( IN> !
 ;

+: RDLN<? IN> @ C@ ;
+
 ( And finally, implement a replacement for the (c<) routine )
-: (rdln<)
-    IN> @ C@                    ( c )
+: RDLN<
+    RDLN<?                      ( c )
    ( not EOL? good, inc and return )
    DUP IF 1 IN> +! EXIT THEN   ( c )
    ( EOL ? readline. we still return typed char though )
@ -79,6 +78,7 @@
      the last typed 0x0a and one for the following NULL. )
    INBUFSZ 4 + ALLOT
    (infl)
-    ['] (rdln<) 0x0c RAM+ !
+    ['] RDLN<? 0x06 RAM+ !
+    ['] RDLN< 0x0c RAM+ !
 ;

--- a/recipes/rc2014/Makefile
+++ b/recipes/rc2014/Makefile
@ -1,7 +1,7 @@
 TARGET = stage1.bin
 BASEDIR = ../..
 FDIR = $(BASEDIR)/forth
-EDIR = $(BASEDIR)/emul/forth
+EDIR = $(BASEDIR)/emul
 STAGE2 = $(EDIR)/stage2
 EMUL = $(BASEDIR)/emul/hw/rc2014/classic

@ -36,4 +36,3 @@ $(EMUL):
 .PHONY: emul
 emul: $(EMUL) $(TARGET)
 	$(EMUL) $(TARGET)
-	
--- a/recipes/rc2014/run.fs
+++ b/recipes/rc2014/run.fs
@ -1,9 +1,7 @@
 : (c<) KEY DUP EMIT ;
-: INIT
+: _
    ACIA$
    ." Collapse OS" CRLF
    ( 0c == CINPTR )
    ['] (c<) 0x0c RAM+ !
-;
-INIT
-
+; _
--- a/recipes/rc2014/zasm/.gitignore
+++ b/recipes/rc2014/zasm/.gitignore
@ -1,2 +0,0 @@
-/cfsin/zasm
-/cfsin/user.h
--- a/recipes/rc2014/zasm/Makefile
+++ b/recipes/rc2014/zasm/Makefile
@ -1,30 +0,0 @@
-SHELLAPPS = zasm sdct memt at28w
-APPTARGETS = ${SHELLAPPS:%=cfsin/%} 
-CFSTARGETS = $(APPTARGETS) cfsin/user.h
-BASEDIR = ../../..
-ZASM = $(BASEDIR)/emul/zasm/zasm
-KERNEL = $(BASEDIR)/kernel
-APPS = $(BASEDIR)/apps
-CFSPACK = $(BASEDIR)/tools/cfspack/cfspack
-
-.PHONY: all
-all: os.bin sdcard.cfs
-
-os.bin: glue.asm
-	$(ZASM) $(KERNEL) $(APPS) < glue.asm > $@
-
-$(CFSPACK):
-	make -C $(BASEDIR)/tools/cfspack
-
-sdcard.cfs: $(CFSTARGETS) $(CFSPACK)
-	$(CFSPACK) cfsin > $@
-
-$(APPTARGETS): $(ZASMBIN)
-	$(ZASM) $(KERNEL) $(APPS) user.h < $(APPS)/${@:cfsin/%=%}/glue.asm > $@
-
-cfsin/user.h: user.h
-	cp user.h $@
-
-.PHONY: clean
-clean:
-	rm -f $(CFSTARGETS) sdcard.cfs os.bin
--- a/recipes/rc2014/zasm/README.md
+++ b/recipes/rc2014/zasm/README.md
@ -1,109 +0,0 @@
-# Assembling binaries
-
-For a system to be able to self-reproduce, it needs to assemble source z80
-assembly to binary.
-
-## Goals
-
-Have a RC2014 assemble a Collapse OS kernel with its source living on a CFS on
-a SD card.
-
-## Gathering parts
-
-* Same parts as the [SD card recipe](../sdcard).
-
-## The zasm binary
-
-To achieve our goal in this recipe, we'll need a zasm binary on the SD card.
-This zasm binary needs to be compiled with the right jump offsets for the kernel
-we build in this recipe. These offsets are in `user.h` and are closely in sync
-with the configuration in `glue.asm`.
-
-`user.h` is then included in `apps/zasm/glue.asm`.
-
-The makefile in this recipe takes care of compiling zasm with the proper
-`user.h` file and place it in `cfsin/zasm`
-
-## The userland source
-
-The code we're going to compile is `cfsin/hello.asm`. As you can see, we also
-include `user.h` in this source code or else `ld hl, sAwesome` would load the
-wrong offset.
-
-Because of this, the Makefile takes care of copying `user.h` in our filesystem.
-
-## Preparing the card and kernel
-
-After running `make`, you'll end up with `sdcard.cfs` which you can load the
-same way you did in the SD card recipe.
-
-You will also have `os.bin`, which you can flash on your EEPROM the same way
-you already did before.
-
-## Running it
-
-Compiling and running `hello.asm` is done very much like in
-[the shell emulator](../../../doc/zasm.md):
-
-    Collapse OS
-    > sdci
-    > fson
-    > fopen 0 hello.asm
-    > fnew 1 dest
-    > fopen 1 dest
-    > zasm 1 2
-    > dest
-    Assembled from a RC2014
-    >
-
-That RC2014 is starting to feel powerful now, right?
-
-## Test your hardware
-
-Now that you have a fully functional filesystem that can load programs and run
-them easily, you'll see that this recipe's CFS include a couple of programs
-besides `zasm`. Among them, there's `sdct` that stress tests reading and
-writing on the SD card and `memt` that stress tests RAM. You might be
-interested in running them. Look at their description in `apps/`. All you need
-to to do run them is to type their name.
-
-## Assembling the kernel
-
-Now let's go for something a little more fun! Jiu-jitsu? No, you're not going to
-learn jiu-jitsu! You're going to assemble the kernel from within your RC2014!
-
-The makefile doesn't prepare a CFS blob for this, let's learn to build that blob
-yourself. First of all, we'll need to have what we already had in `sdcard.cfs`
-because it has `zasm` and `user.h`. But we're going to add the contents of
-the `/kernel/` directory to it.
-
-    $ cp ../../../kernel/*.{h,asm} cfsin
-
-You'll also need your glue file:
-
-    $ cp glue.asm cfsin
-
-You're now ready to re-make your CFS:
-
-    $ rm sdcard.cfs && make
-
-Now you can write this into your card and boot Collapse OS:
-
-    Collapse OS
-    > sdci
-    > fson
-    > fopn 0 glue.asm
-    > fnew 10 dest
-    > fopen 1 dest
-    > zasm 1 2          # This takes a while. About 7 minutes.
-    > sdcf              # success! sdcf flushes SD card buffers to the card.
-
-Now let's go verify that we assembled the right thing. Pop out the card and
-plug it in your "modern" computer. Pipe the device directly through `cfsunpack`
-to unpack the FS into a directory (it will stop reading when it stops seeing
-CFS blocks):
-
-    $ sudo cat /dev/sdX | ../../../tools/cfspack/cfsunpack cfsout
-    $ cmp cfsout/dest ../os.bin
-
-They're the same! Your RC2014 assembled a full Collapse OS kernel all by itself!
--- a/recipes/rc2014/zasm/cfsin/hello.asm
+++ b/recipes/rc2014/zasm/cfsin/hello.asm
@ -1,10 +0,0 @@
-.inc "user.h"
-
-	ld	hl, sAwesome
-	call	printstr
-	xor	a		; success
-	ret
-
-sAwesome:
-	.db	"Assembled from a RC2014", 0x0d, 0x0a, 0
-
--- a/recipes/rc2014/zasm/glue.asm
+++ b/recipes/rc2014/zasm/glue.asm
@ -1,151 +0,0 @@
-; classic RC2014 setup (8K ROM + 32K RAM) and a stock Serial I/O module
-; The RAM module is selected on A15, so it has the range 0x8000-0xffff
-.equ	RAMSTART	0x8000
-; Kernel RAMEND last check: 0x9933
-; We allocate at least 0x100 bytes for the stack, which is why we have this
-; threshold.
-.equ	RAMEND		0x9b00
-.equ	USER_CODE	RAMEND  ; in sync with user.h
-.equ	ACIA_CTL	0x80	; Control and status. RS off.
-.equ	ACIA_IO		0x81	; Transmit. RS on.
-
-	jp	init	; 3 bytes
-
-; *** Jump Table ***
-	jp	strncmp
-	jp	upcase
-	jp	findchar
-	jp	blkSel
-	jp	blkSet
-	jp	fsFindFN
-	jp	fsOpen
-	jp	fsGetB
-	jp	printstr
-	jp	printcrlf
-	jp	_blkGetB
-	jp	_blkPutB
-	jp	_blkSeek
-	jp	_blkTell
-	jp	sdcGetB
-	jp	sdcPutB
-	jp	blkGetB
-
-; interrupt hook
-.fill	0x38-$
-jp	aciaInt
-
-; *** cont. ***
-
-	jp	stdioPutC
-
-.inc "err.h"
-.inc "ascii.h"
-.inc "blkdev.h"
-.inc "fs.h"
-.inc "core.asm"
-.inc "str.asm"
-.equ	ACIA_RAMSTART		RAMSTART
-.inc "acia.asm"
-.equ	BLOCKDEV_RAMSTART	ACIA_RAMEND
-.equ	BLOCKDEV_COUNT		4
-.inc "blockdev.asm"
-; List of devices
-.dw	sdcGetB, sdcPutB
-.dw	blk1GetB, blk1PutB
-.dw	blk2GetB, blk2PutB
-.dw	mmapGetB, mmapPutB
-
-
-.equ	MMAP_START	0xe000
-.inc "mmap.asm"
-
-.equ	STDIO_RAMSTART	BLOCKDEV_RAMEND
-.equ	STDIO_GETC	aciaGetC
-.equ	STDIO_PUTC	aciaPutC
-.inc "stdio.asm"
-
-.equ	FS_RAMSTART	STDIO_RAMEND
-.equ	FS_HANDLE_COUNT	2
-.inc "fs.asm"
-
-; *** BASIC ***
-
-; RAM space used in different routines for short term processing.
-.equ	SCRATCHPAD_SIZE	STDIO_BUFSIZE
-.equ	SCRATCHPAD	FS_RAMEND
-.inc "lib/util.asm"
-.inc "lib/ari.asm"
-.inc "lib/parse.asm"
-.inc "lib/fmt.asm"
-.equ	EXPR_PARSE	parseLiteralOrVar
-.inc "lib/expr.asm"
-.inc "basic/util.asm"
-.inc "basic/parse.asm"
-.inc "basic/tok.asm"
-.equ	VAR_RAMSTART	SCRATCHPAD+SCRATCHPAD_SIZE
-.inc "basic/var.asm"
-.equ	BUF_RAMSTART	VAR_RAMEND
-.inc "basic/buf.asm"
-.inc "basic/blk.asm"
-.inc "basic/sdc.asm"
-.equ	BFS_RAMSTART	BUF_RAMEND
-.inc "basic/fs.asm"
-.equ	BAS_RAMSTART	BFS_RAMEND
-.inc "basic/main.asm"
-
-.equ	SDC_RAMSTART	BAS_RAMEND
-.equ	SDC_PORT_CSHIGH	6
-.equ	SDC_PORT_CSLOW	5
-.equ	SDC_PORT_SPI	4
-.inc "sdc.asm"
-
-.out	SDC_RAMEND
-
-init:
-	di
-	ld	sp, RAMEND
-	im	1
-	call	aciaInit
-	call	fsInit
-	call	basInit
-	ld	hl, basFindCmdExtra
-	ld	(BAS_FINDHOOK), hl
-
-	xor	a
-	ld	de, BLOCKDEV_SEL
-	call	blkSel
-
-	ei
-	jp	basStart
-
-basFindCmdExtra:
-	ld	hl, basFSCmds
-	call	basFindCmd
-	ret	z
-	ld	hl, basBLKCmds
-	call	basFindCmd
-	ret	z
-	ld	hl, basSDCCmds
-	call	basFindCmd
-	ret	z
-	jp	basPgmHook
-
-; *** blkdev 1: file handle 0 ***
-
-blk1GetB:
-	ld	ix, FS_HANDLES
-	jp	fsGetB
-
-blk1PutB:
-	ld	ix, FS_HANDLES
-	jp	fsPutB
-
-; *** blkdev 2: file handle 1 ***
-
-blk2GetB:
-	ld	ix, FS_HANDLES+FS_HANDLE_SIZE
-	jp	fsGetB
-
-blk2PutB:
-	ld	ix, FS_HANDLES+FS_HANDLE_SIZE
-	jp	fsPutB
--- a/recipes/rc2014/zasm/user.h
+++ b/recipes/rc2014/zasm/user.h
@ -1,23 +0,0 @@
-.org    0x9b00
-
-; *** JUMP TABLE ***
-.equ    strncmp        0x03
-.equ    upcase         @+3
-.equ    findchar       @+3
-.equ    blkSel         @+3
-.equ    blkSet         @+3
-.equ    fsFindFN       @+3
-.equ    fsOpen         @+3
-.equ    fsGetB         @+3
-.equ    printstr       @+3
-.equ    printcrlf      @+3
-.equ    _blkGetB       @+3
-.equ    _blkPutB       @+3
-.equ    _blkSeek       @+3
-.equ    _blkTell       @+3
-.equ    sdcGetB        @+3
-.equ    sdcPutB        @+3
-.equ    blkGetB        @+3
-
-; *** cont. ***
-.equ    stdioPutC      0x3b
--- a/tests/Makefile
+++ b/tests/Makefile
@ -2,5 +2,5 @@ EMULDIR = ../emul

 .PHONY: run
 run:
-	$(MAKE) -C $(EMULDIR) forth/forth
+	$(MAKE) -C $(EMULDIR) all
 	cd forth && ./runtests.sh
--- a/tests/forth/runtests.sh
+++ b/tests/forth/runtests.sh
@ -1,8 +1,7 @@
 #!/bin/sh -e

 BASE=../..
-EXEC="${BASE}/emul/forth/forth"
-FDIR="${BASE}/forth"
+EXEC="${BASE}/emul/forth"
 TMP=$(mktemp)

 chk() {
Author	SHA1	Message	Date
Virgil Dupras	b5c370a936	emul: embed blkfs in forth binary This will allow us to read from blkfs in tests.	2020-04-24 18:01:55 -04:00
Virgil Dupras	1bd191e86a	Move /emul/forth/* to /emul Less noisy this way	2020-04-24 17:53:58 -04:00
Virgil Dupras	816563e2e3	Stop LOADing on ABORT This is done by adding a "C<* override" layer that is reset to 0 on ABORT. The problem was that when ABORT happened during a LOAD, we had a resetted RSP and started from a clean INTERPRET, but LOAD didn't have the opportunity to restore C<, which caused it to continue interpreting from the faulty BLK. With a C< override, we don't need to restore C<*, we just need to clear the override.	2020-04-24 14:10:40 -04:00
Virgil Dupras	af39b37dd1	Replace the "> " prompt with the more traditional "ok" one This is more than cosmetic, it's also highly usable. The presence or absence of the "ok" message allows us to know whether the command aborted. Previously, the "> " prompt appeared when the system expected a prompt in the INTERPRET context, whether the previous command aborted or not. Also, this allows us to get rid of that ugly FLAGS global variable.	2020-04-24 12:10:07 -04:00
Virgil Dupras	a699c93509	Print word that wasn't found on "word not found" error	2020-04-24 10:59:59 -04:00
Virgil Dupras	f19a5e1f71	Remove recipes/rc2014/zasm That becomes irrelevant in Forth	2020-04-24 10:59:28 -04:00