README.md

@@ -41,12 +41,11 @@ path to giving Collapse OS a try.
            from this folder.
 * `recipes`: collection of recipes that assemble parts together on a specific
              machine.
-* `blk`: Collapse OS filesystem's content. See `000` for intro.
 * `doc`: User guide for when you've successfully installed Collapse OS.
 * `tools`: Tools for working with Collapse OS from "modern" environments. For
            example, tools for facilitating data upload to a Collapse OS machine
            through a serial port.
-* `emul`: Emulated applications.
+* `emul`: Emulated applications, such as zasm and the shell.
 * `tests`: Automated test suite for the whole project.
 
 ## Status

blk/000

@@ -1,15 +0,0 @@
-Collapse OS file system
-
-This is a Forth-style filesystems which is very simple. It is a
-list of 1024 bytes block, organised in 16 lines of 64 columns
-each. You refer to blocks by numbers. You show them with LIST.
-You interpret them with LOAD.
-
-Conventions: When you see "(cont.)" at the bottom right of a
-block, it means that the next block continues the same kind of
-contents. This of course only work for informational text.
-
-Block numbers are abbreviated with prefix "B". "BX" means
-"block X".
-
-The master index of this filesystem is at B1.

blk/001

@@ -1,2 +0,0 @@
-MASTER INDEX
-

drv/at28.fs

@@ -2,12 +2,12 @@
   operation while doing the right thing. Checks data integrity
   and ABORT on mismatch.
 )
-( n a -- )
+( a n -- )
 : AT28!
-    2DUP C!
-    ( as long as writing operation is running, IO/6 will toggle at each
-      read attempt. We know that write is finished when we read the same
-      value twice. )
+    2DUP C! SWAP
+	( as long as writing operation is running, IO/6 will toggle at each
+	  read attempt. We know that write is finished when we read the same
+	  value twice. )
     BEGIN ( n1 a )
         DUP C@      ( n1 a n2 )
         OVER C@     ( n1 a n2 n3 )

emul/.gitignore

@@ -1,6 +1,8 @@
 /forth/stage1
 /forth/stage1dbg
 /forth/stage2
+/forth/stage2dbg
 /forth/forth
+/runbin/runbin
 /*/*-bin.h
 /*/*.bin

emul/Makefile

@@ -1,4 +1,4 @@
-TARGETS = forth/forth
+TARGETS = runbin/runbin forth/forth
 BIN2C = ../tools/bin2c
 # Those Forth source files are in a particular order
 BOOTSRCS = ./forth/conf.fs \
@@ -58,6 +58,9 @@ forth/stage2: forth/stage.c $(OBJS) forth/forth1-bin.h
 forth/forth: forth/forth.c $(OBJS) forth/forth1-bin.h 
 	$(CC) forth/forth.c $(OBJS) -o $@
 
+runbin/runbin: runbin/runbin.c $(OBJS)
+	$(CC) runbin/runbin.c $(OBJS) -o $@
+
 libz80/libz80.o: libz80/z80.c
 	$(MAKE) -C libz80/codegen opcodes
 	$(CC) -Wall -ansi -g -c -o libz80/libz80.o libz80/z80.c

emul/README.md

@@ -49,6 +49,14 @@ the power of a full Forth intepreter, including an assembler, to assemble
 Normally, running this step should yield the exact same `boot.bin` and
 `z80c.bin` as before, unless of course you've changed the source.
 
+## runbin
+
+This is a very simple tool that reads binary z80 code from stdin, loads it in
+memory starting at address 0 and then run the code until it halts. The exit
+code of the program is the value of `A` when the program halts.
+
+This is used for unit tests.
+
 ## Problems?
 
 If the libz80-wrapped zasm executable works badly (hangs, spew garbage, etc.),

emul/runbin/runbin.c

@@ -0,0 +1,33 @@
+#include <stdint.h>
+#include <stdio.h>
+#include "../emul.h"
+
+/* runbin loads binary from stdin directly in memory address 0 then runs it
+ * until it halts. The return code is the value of the register A at halt time.
+ */
+
+static void iowr_stderr(uint8_t val)
+{
+    fputc(val, stderr);
+}
+
+int main()
+{
+    Machine *m = emul_init();
+    m->iowr[0] = iowr_stderr;
+    // read stdin in mem
+    int i = 0;
+    int c = getchar();
+    while (c != EOF) {
+        m->mem[i] = c & 0xff;
+        i++;
+        c = getchar();
+    }
+    if (!i) {
+        fprintf(stderr, "No input, aborting\n");
+        return 1;
+    }
+    emul_loop();
+    return m->cpu.R1.br.A;
+}
+

forth/boot.fs

@@ -159,7 +159,7 @@ PC ORG @ 4 + ! ( find )
   adjust. Because the compare loop pre-decrements, instead
   of DECing HL twice, we DEC it once. )
     HL DECss,
-BEGIN, ( inner )
+L3 BSET ( inner )
     ( DE is a wordref, first step, do our len correspond? )
     HL PUSHqq,          ( --> lvl 1 )
     DE PUSHqq,          ( --> lvl 2 )
@@ -172,15 +172,15 @@ BEGIN, ( inner )
     DE DECss, ( Skip prev field. One less because we )
     DE DECss, ( pre-decrement )
     B C LDrr, ( loop C times )
-BEGIN, ( loop )
+L5 BSET ( loop )
     ( pre-decrement for easier Z matching )
     DE DECss,
     HL DECss,
     LDA(DE),
     (HL) CPr,
-    JRNZ, L3 FWR ( loopend )
-    DJNZ, AGAIN, ( loop )
-L4 FSET L3 FSET ( loopend )
+    JRNZ, L6 FWR ( loopend )
+    DJNZ, L5 BWR ( loop )
+L4 FSET L6 FSET ( loopend )
 ( At this point, Z is set if we have a match. In all cases,
   we want to pop HL and DE )
     DE POPqq,           ( <-- lvl 2 )
@@ -201,14 +201,14 @@ L4 FSET L3 FSET ( loopend )
     ( HL is prev field's addr. Is offset zero? )
     A D LDrr,
     E ORr,
-    IFZ, ( noprev )
-        ( get absolute addr from offset )
-        ( carry cleared from "or e" )
-        DE SBCHLss,
-        EXDEHL,             ( result in DE )
-    THEN, ( noprev )
+    JRZ, L6 FWR ( noprev )
+    ( get absolute addr from offset )
+    ( carry cleared from "or e" )
+    DE SBCHLss,
+    EXDEHL,             ( result in DE )
+L6 FSET ( noprev )
     HL POPqq,           ( <-- lvl 1 )
-    JRNZ, AGAIN, ( inner, try to match again )
+    JRNZ, L3 BWR ( inner, try to match again )
     ( Z set? end of dict, unset Z )
 L1 FSET ( fail )
     A XORr,
@@ -260,7 +260,8 @@ PC ORG @ 0x1e + ! ( chkPS )
     HL DECss,
     HL DECss,
     HL DECss,
-    SP SUBHLss,
+    A ORr,           ( clear carry )
+    SP SBCHLss,
     HL POPqq,
     CNC RETcc,      ( INITIAL_SP >= SP? good )
     JR, L1 BWR ( abortUnderflow )
@@ -268,7 +269,8 @@ PC ORG @ 0x1e + ! ( chkPS )
 L3 BSET ( chkRS )
     IX PUSHqq, HL POPqq,
     DE RS_ADDR LDddnn,
-    DE SUBHLss,
+    A ORr,           ( clear carry )
+    DE SBCHLss,
     CNC RETcc,      ( IX >= RS_ADDR? good )
     JR, L1 BWR ( abortUnderflow )
 

forth/z80a.fs

@@ -16,16 +16,18 @@
 
   To avoid using dict memory in compilation targets, we
   pre-declare label variables here, which means we have a
-  limited number of it. For now, 4 ought to be enough. )
+  limited number of it. For now, 6 ought to be enough. )
 : L1 2 Z80AMEM+ ;
 : L2 4 Z80AMEM+ ;
 : L3 6 Z80AMEM+ ;
 : L4 8 Z80AMEM+ ;
+: L5 10 Z80AMEM+ ;
+: L6 12 Z80AMEM+ ;
 
 : Z80A$
     ( 59 == z80a's memory )
     H@ 0x59 RAM+ !
-    10 ALLOT
+    14 ALLOT
 ;
 
 ( Splits word into msb/lsb, lsb being on TOS )
@@ -41,6 +43,42 @@
 : A, C, ;
 : A,, SPLITB A, A, ;
 
+( There are 2 label types: backward and forward. For each
+  type, there are two actions: set and write. Setting a label
+  is declaring where it is. It has to be performed at the
+  label's destination. Writing a label is writing its offset
+  difference to the binary result. It has to be done right
+  after a relative jump operation. Yes, labels are only for
+  relative jumps.
+
+  For backward labels, set happens before write. For forward
+  labels, write happen before set. The write operation writes
+  a dummy placeholder, and then the set operation writes the
+  offset at that placeholder's address.
+
+  Variable actions are expected to be called with labels in
+  front of them. Example, "L2 FSET"
+
+  About that "1 -": z80 relative jumps record "e-2", that is,
+  the offset that *counts the 2 bytes of the jump itself*.
+  Because we set the label *after* the jump OP1 itself, that's
+  1 byte that is taken care of. We still need to adjust by
+  another byte before writing the offset.
+)
+
+: BSET PC SWAP ! ;
+: BWR @ PC - 1 - A, ;
+( same as BSET, but we need to write a placeholder )
+: FWR BSET 0 A, ;
+: FSET
+    @ DUP PC        ( l l pc )
+    -^ 1 -          ( l off )
+    ( warning: l is a PC offset, not a mem addr! )
+    SWAP ORG @ +    ( off addr )
+    C!
+;
+
+
 ( "r" register constants )
 7 CONSTANT A
 0 CONSTANT B
@@ -337,52 +375,3 @@
 ( Routines )
 ( 29 == chkPS )
 : chkPS, 29 CALLnn, ;
-
-( Flow
-
-  There are 2 label types: backward and forward. For each
-  type, there are two actions: set and write. Setting a label
-  is declaring where it is. It has to be performed at the
-  label's destination. Writing a label is writing its offset
-  difference to the binary result. It has to be done right
-  after a relative jump operation. Yes, labels are only for
-  relative jumps.
-
-  For backward labels, set happens before write. For forward
-  labels, write happen before set. The write operation writes
-  a dummy placeholder, and then the set operation writes the
-  offset at that placeholder's address.
-
-  Variable actions are expected to be called with labels in
-  front of them. Example, "L2 FSET"
-
-  About that "1 -": z80 relative jumps record "e-2", that is,
-  the offset that *counts the 2 bytes of the jump itself*.
-  Because we set the label *after* the jump OP1 itself, that's
-  1 byte that is taken care of. We still need to adjust by
-  another byte before writing the offset.
-)
-
-( Place BEGIN, where you want to jump back and AGAIN after
-  a relative jump operator. Just like BSET and BWR. )
-: BEGIN, PC ;
-: AGAIN, PC - 1 - A, ;
-
-: BSET PC SWAP ! ;
-: BWR @ AGAIN, ;
-( same as BSET, but we need to write a placeholder )
-: FJR, PC 0 A, ;
-: IFZ, JRZ, FJR, ;
-: IFNZ, JRNZ, FJR, ;
-: IFC, JRC, FJR, ;
-: IFNC, JRNC, FJR, ;
-: THEN,
-    DUP PC          ( l l pc )
-    -^ 1 -          ( l off )
-    ( warning: l is a PC offset, not a mem addr! )
-    SWAP ORG @ +    ( off addr )
-    C!
-;
-: FWR BSET 0 A, ;
-: FSET @ THEN, ;
-

forth/z80c.fs

@@ -149,10 +149,10 @@ CODE NOT
     A L LDrr,
     H ORr,
     HL 0 LDddnn,
-    IFNZ, ( skip )
-        ( false, make 1 )
-        HL INCss,
-    THEN, ( skip )
+    JRNZ, L1 FWR ( skip )
+    ( false, make 1 )
+    HL INCss,
+L1 FSET ( skip )
     HL PUSHqq,
 ;CODE
 
@@ -168,7 +168,8 @@ CODE -
     DE POPqq,
     HL POPqq,
     chkPS,
-    DE SUBHLss,
+    A ORr,
+    DE SBCHLss,
     HL PUSHqq,
 ;CODE
 
@@ -203,17 +204,17 @@ CODE /MOD
     A B LDrr,
     B 16 LDrn,
     HL 0 LDddnn,
-    BEGIN, ( loop )
-        SCF,
-        C RLr,
-        RLA,
-        HL ADCHLss,
-        DE SBCHLss,
-        IFNC, ( skip )
-            DE ADDHLss,
-            C DECr,
-        THEN, ( skip )
-    DJNZ, AGAIN, ( loop )
+L1 BSET ( loop )
+    SCF,
+    C RLr,
+    RLA,
+    HL ADCHLss,
+    DE SBCHLss,
+    JRNC, L2 FWR ( skip )
+    DE ADDHLss,
+    C DECr,
+L2 FSET ( skip )
+    DJNZ, L1 BWR ( loop )
     B A LDrr,
     HL PUSHqq,
     BC PUSHqq,
@@ -315,16 +316,16 @@ CODE SCMP
     DE  POPqq,
     HL  POPqq,
     chkPS,
-    BEGIN, ( loop )
-        LDA(DE),
-        (HL) CPr,
-        JRNZ, L1 FWR ( not equal? break early to "end".
-                       NZ is set. )
-        A ORr,   ( if our char is null, stop )
-        HL INCss,
-        DE INCss,
-    JRNZ, AGAIN, ( loop )
-L1 FSET ( end )
+L1 BSET ( loop )
+    LDA(DE),
+    (HL) CPr,
+    JRNZ, L2 FWR ( not equal? break early to "end".
+                   NZ is set. )
+    A ORr,   ( if our char is null, stop )
+    HL INCss,
+    DE INCss,
+    JRNZ, L1 BWR ( loop )
+L2 FSET ( end )
     ( 40 == flagsToBC )
     40 CALLnn,
     BC PUSHqq,
@@ -334,7 +335,8 @@ CODE CMP
     HL  POPqq,
     DE  POPqq,
     chkPS,
-    DE SUBHLss,
+    A ORr,      ( clear carry )
+    DE SBCHLss,
     ( 40 == flagsToBC )
     40 CALLnn,
     BC PUSHqq,
@@ -347,13 +349,13 @@ CODE _find
     chkPS,
     ( 3 == find )
     3 CALLnn,
-    IFZ, ( found )
-        ( not found )
-        HL PUSHqq,
-        DE 0 LDddnn,
-        DE PUSHqq,
-        JPNEXT,
-    THEN, ( found )
+    JRZ, L1 FWR ( found )
+    ( not found )
+    HL PUSHqq,
+    DE 0 LDddnn,
+    DE PUSHqq,
+    JPNEXT,
+L1 FSET ( found )
     DE PUSHqq,
     DE 1 LDddnn,
     DE PUSHqq,

recipes/rc2014/eeprom/README.md

@@ -7,8 +7,7 @@ itself.
 
 ## Gathering parts
 
-* A RC2014 Classic
-* `stage3.bin` from the base recipe
+* A RC2014 Classic that could install the base recipe
 * An extra AT28C64B
 * 1x 40106 inverter gates
 * Proto board, RC2014 header pins, wires, IC sockets, etc.
@@ -33,33 +32,52 @@ in write protection mode, but I preferred building my own module.
 
 I don't think you need a schematic. It's really simple.
 
-## Using the at28 driver
+## Building the kernel
 
-The AT28 driver is at `drv/at28.fs` and is a pure forth source file so it's
-rather easy to set up from the base Stage 3 binary:
+For this recipe to work, we need a block device for the `at28w` program to read
+from. The easiest way to go around would be to use a SD card, but maybe you
+haven't built a SPI relay yet and it's quite a challenge to do so.
 
-    cat ../stage3.bin ../pre.fs ../../../drv/at28.fs ../run.fs > os.bin
-    ../../../emul/hw/rc2014/classic os.bin
+Therefore, for this recipe, we'll have `at28w` read from a memory map and we'll
+upload contents to write to memory through our serial link.
+
+`at28w` is designed to be ran as a "user application", but in this case, because
+we run from a kernel without a filesystem and that `pgm` can't run without it,
+we'll integrate `at28w` directly in our kernel and expose it as an extra shell
+command (renaming it to `a28w` to fit the 4 chars limit).
+
+For all this to work, you'll need [glue code that looks like this](glue.asm).
+Running `make` in this directory will produce a `os.bin` with that glue code
+that you can install in the same way you did with the basic RC2014 recipe.
+
+If your range is different than `0x2000-0x3fff`, you'll have to modify
+`AT28W_MEMSTART` before you build.
 
 ## Writing contents to the AT28
 
-The driver provides `AT28!` which can be plugged in adev's `A!*`.
+The memory map is configured to start at `0xd000`. The first step is to upload
+contents at that address as documented in ["Load code in RAM and run it"][load].
 
-It's not in the Stage 3 binary, but because it's a small piece of Forth code,
-let's just run its definition code:
+You have to know the size of the contents you've loaded because you'll pass it
+as at argument to `a28w`. You can run:
 
-    cat ../../../drv/at28.fs | ./stripfc | ./exec <tty device>
+    Collapse OS
+    > bsel 0
+    > seek 00 0000
+    > a28w <size-of-contents>
 
-Then, upload your binary to some place in memory, for example `a000`. To do so,
-run this from your modern computer:
+It takes a little while to write. About 1 second per 0x100 bytes (soon, I'll
+implement page writing which should make it much faster).
 
-    ./upload <tty device> a000 <filename>
+If the program doesn't report an error, you're all good! The program takes care
+of verifying each byte, so everything should be in place. You can verify
+yourself by `peek`-ing around the `0x2000-0x3fff` range.
 
-Then, activate `AT28!` with `' AT28! A!* !` and then run
-`0xa000 0x2000 <size-of-bin> AMOVE`. `AT28!` checks every myte for integrity,
-so it there's no error, you should be fine. Your content is now on the EEPROM!
+Note that to write a single byte to the AT28 eeprom, you don't need a special
+program. You can, while you're in the `0x2000-0x3fff` range, run `poke 1` and
+send an arbitrary char. It will work. The problem is with writing multiple
+bytes: you have to wait until the eeprom is finished writing before writing to
+a new address, something a regular `poke` doesn't do but `at28w` does.
+
+[load]: ../../../doc/load-run-code.md
 
-Why not upload content directly to `0x2000` after having activated `AT28!`?
-Technically, you could. It was my first idea too. However, at the time of this
-writing, I always get weird mismatch errors about halfway through. Maybe that
-the ACIA interrupt does something wrong...

tools/.gitignore

@@ -8,4 +8,3 @@
 /stripfc
 /bin2c
 /exec
-/blkpack

tools/Makefile

@@ -8,10 +8,9 @@ SLATEST_TGT = slatest
 STRIPFC_TGT = stripfc
 BIN2C_TGT = bin2c
 EXEC_TGT = exec
-BLKPACK_TGT = blkpack
 TARGETS = $(MEMDUMP_TGT) $(BLKDUMP_TGT) $(UPLOAD_TGT) $(FONTCOMPILE_TGT) \
 	$(TTYSAFE_TGT) $(PINGPONG_TGT) $(SLATEST_TGT) $(STRIPFC_TGT) \
-	$(BIN2C_TGT) $(EXEC_TGT) $(BLKPACK_TGT)
+	$(BIN2C_TGT) $(EXEC_TGT)
 OBJS = common.o
 
 all: $(TARGETS)
@@ -30,7 +29,6 @@ $(SLATEST_TGT): $(SLATEST_TGT).c
 $(STRIPFC_TGT): $(STRIPFC_TGT).c
 $(BIN2C_TGT): $(BIN2C_TGT).c
 $(EXEC_TGT): $(EXEC_TGT).c
-$(BLKPACK_TGT): $(BLKPACK_TGT).c
 $(TARGETS): $(OBJS)
 	$(CC) $(CFLAGS) $@.c $(OBJS) -o $@
 

tools/blkpack.c

@@ -1,64 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <dirent.h>
-#include <string.h>
-#include <sys/stat.h>
-
-void usage()
-{
-    fprintf(stderr, "Usage: blkpack dirname\n");
-}
-
-int main(int argc, char *argv[])
-{
-    DIR *dp;
-    struct dirent *ep;
-    char *buf = NULL;
-    int blkcnt = 0;
-    if (argc != 2) {
-        usage();
-        return 1;
-    }
-    dp = opendir(argv[1]);
-    if (dp == NULL) {
-        fprintf(stderr, "Couldn't open directory.\n");
-        return 1;
-    }
-    while ((ep = readdir(dp))) {
-        if ((strcmp(ep->d_name, ".") == 0) || strcmp(ep->d_name, "..") == 0) {
-            continue;
-        }
-        if (ep->d_type != DT_REG) {
-            continue;
-        }
-        int blkid = atoi(ep->d_name);
-        if (blkid >= blkcnt) {
-            int newcnt = blkid+1;
-            buf = realloc(buf, newcnt*1024);
-            bzero(buf+(blkcnt*1024), (newcnt-blkcnt)*1024);
-            blkcnt = newcnt;
-        }
-        char fullpath[0x200];
-        strcpy(fullpath, argv[1]);
-        strcat(fullpath, "/");
-        strcat(fullpath, ep->d_name);
-        FILE *fp = fopen(fullpath, "r");
-        char *line = NULL;
-        size_t n = 0;
-        for (int i=0; i<16; i++) {
-            ssize_t cnt = getline(&line, &n, fp);
-            if (cnt < 0) break;
-            if (cnt > 65) {
-                fprintf(stderr, "Line %d too long in blk %s\n", i+1, ep->d_name);
-            }
-            strncpy(buf+(blkid*1024)+(i*64), line, cnt-1);
-        }
-        free(line);
-    }
-    fwrite(buf, 1024, blkcnt, stdout);
-    free(buf);
-    closedir(dp);
-    return 0;
-}
-

tools/common.c

@@ -8,9 +8,7 @@
 void mread(int fd, char *s, int count)
 {
     while (count) {
-        while (read(fd, s, 1) == 0) {
-            usleep(1000);
-        }
+        while (read(fd, s, 1) == 0);
         s++;
         count--;
     }

tools/upload.c

@@ -65,7 +65,6 @@ int main(int argc, char **argv)
             // we don't exit now because we need to "consume" our whole program.
             returncode = 1;
         }
-        usleep(1000); // let it breathe
     }
     mread(fd, s, 2); // "> " prompt
     sendcmdp(fd, "FORGET _");