Remove unused DELW

There was a weird empty block in the middle of the program.

blk/003

@@ -2,15 +2,15 @@ Collapse OS usage guide
 
 This document is not meant to be an introduction to Forth, but
 to instruct the user about the peculiarities of this Forth
-implemenation. Be sure to refer to dictionary for a word
+implementation. The recommended introductory book is Starting
-reference.
+Forth by Leo Brodie. This is the reference that was used to
+build this implementation and many of the conventions described
+in this book are followed in Collapse OS. Be sure to refer to
+the dictionary (B30) for a word reference.
 
 Contents
 
- 4 DOES>                        6 Compilation vs meta-comp.
+ 4 Number literals              6 Compilation vs meta-comp.
- 8 I/O                         14 Addressed devices         
+ 8 Interpreter I/O             11 Signed-ness
-18 Signed-ness
+14 Addressed devices           17 DOES>
-
-
-
 

blk/004

@@ -1,16 +1,11 @@
-DOES>
+Number literals
 
-Used inside a colon definition that itself uses CREATE, DOES>
+Traditional Forth often use HEX/DEC switches to go from decimal
-transforms that newly created word into a "does cell", that is,
+to hexadecimal parsing. Collapse OS parses literals in a way
-a regular cell ( when called, puts the cell's addr on PS), but
+that is closer to C.
-right after that, it executes words that appear after the
-DOES>.
-
-"does cells" always allocate 4 bytes (2 for the cell, 2 for the
-DOES> link) and there is no need for ALLOT in colon definition.
-
-At compile time, colon definition stops processing words when
-reaching the DOES>.
-
-Example: ": CONSTANT CREATE HERE @ ! DOES> @ ;"
 
+Straight numbers are decimals, numbers starting with "0x"
+are hexadecimals (example "0x12ef"), "0b" prefixes indicate
+binary (example "0b1010"), char literals are single characters
+surrounded by ' (example 'X'). Char literals can't be used for
+whitespaces.

blk/008

@@ -1,16 +1,16 @@
-I/O
+Interpreter I/O
 
-A little word about inputs. There are two kind of inputs:
+The INTERPRET loop, the heart of Collapse OS, feeds itself
-direct and buffered.  As a general rule, we read line in a
+from the C< word, which yields a character every time it is
-buffer, then feed words in it to the interpreter. That's what
+called. If no character is available to interpret, it blocks.
-"WORD" does. If it's at the End Of Line, it blocks and wait
-until another line is entered.
 
-KEY input, however, is direct. Regardless of the input buffer's
+During normal operations, C< is simply a buffered layer over
-state, KEY will return the next typed key.
+KEY, which has the same behavior (but unbuffered). Before
+yielding any character, the C< routine fetches a whole line
+from KEY, puts it in a buffer, then yields the buffered line,
+one character at once.
 
-PARSING AND BOOTSTRAP: Parsing number literal is a very "core"
+Both C< and KEY can be overridden by setting an alternate
-activity of Forth, and therefore generally seen as having to be
+routine at the proper RAM offset (see B80). For example, C<
-implemented in native code.  However, Collapse OS' Forth
+overrides are used during LOAD so that input comes from
-supports many kinds of literals: decimal, hex, char, binary.
+disk blocks instead of keyboard.                        (cont.)
-This incurs a significant complexity penalty.           (cont.)

blk/009

@@ -1,16 +1,6 @@
-(cont.) What if we could implement those parsing routines in
+KEY overrides can be used to, for example, temporarily give
-Forth? "But it's a core routine!" you say. Yes, but here's the
+prompt control to a RS-232 device instead of the keyboard.
-deal: at its native core, only decimal parsing is supported. It
-lives in the "(parsed)" word. The interpreter's main loop is
-initially set to simply call that word.
-
-However, in core.fs, "(parsex)", "(parsec)" and "(parseb)" are
-implemented, in Forth, then "(parse)", which goes through them
-all is defined. Then, "(parsef)", which is the variable in
-which the interpreter's word pointer is set, is updated to that
-new "(parse)" word.
-
-This way, we have a full-featured (and extensible) parsing with
-a tiny native core.
-
 
+Interpreter output is unbuffered and only has EMIT. This
+word can also be overriden, mostly as a companion to the
+raison d'etre of your KEY override.

blk/017

@@ -0,0 +1,16 @@
+DOES>
+
+Used inside a colon definition that itself uses CREATE, DOES>
+transforms that newly created word into a "does cell", that is,
+a regular cell ( when called, puts the cell's addr on PS), but
+right after that, it executes words that appear after the
+DOES>.
+
+"does cells" always allocate 4 bytes (2 for the cell, 2 for the
+DOES> link) and there is no need for ALLOT in colon definition.
+
+At compile time, colon definition stops processing words when
+reaching the DOES>.
+
+Example: ": CONSTANT CREATE HERE @ ! DOES> @ ;"
+

blk/031

@@ -7,10 +7,10 @@ modified. "I:" prefix means "IMMEDIATE", that is, that this
 stack transformation is made at compile time.
 
 Word references (wordref): When we say we have a "word
-reference", it's a pointer to a words *code link*. For example,
+reference", it's a pointer to a word's *code link*. For
-the label "PLUS:" in this unit is a word reference. Why not
+example, the address that "' DUP" is a wordref, that is, a
-refer to the beginning of the word struct? Because we actually
+reference to the code link of the word DUP.
-seldom refer to the name and prev link, except during
+
-compilation, so defining "word reference" this way makes the
+PF: Parameter field. The area following the code link of a
-code easier to understand.
+word. For example, "' H@ 1+" points to the PF of the word H@.
                                                         (cont.)

blk/032

@@ -1,4 +1,3 @@
-(cont.)
 Atom: A word of the type compiledWord contains, in its PF, a
 list of what we call "atoms". Those atoms are most of the time
 word references, but they can also be references to NUMBER and

blk/037

@@ -10,7 +10,7 @@ Entry management
 ,        n --     Write n in HERE and advance it.
 ALLOT    n --     Move HERE by n bytes
 C,       b --     Write byte b in HERE and advance it.
-DELW     a --     Delete wordref at a. If it shadows another
-                  definition, that definition is unshadowed.
 EMPTY  --         Rewind HERE and CURRENT where they were at
-                  system initialization.                (cont.)
+                  system initialization.            
+
+                                                        (cont.)

blk/040

@@ -8,7 +8,7 @@ CREATE x    --     Create cell named x. Doesn't allocate a PF.
 COMPILE x   --     Meta compiles. See B6.
 CONSTANT x  n --   Creates cell x that when called pushes its
                    value.
-DOES>       --     See B4.
+DOES>       --     See B17.
 IMMED?      a -- f Checks whether wordref at a is immediate.
 IMMEDIATE   --     Flag the latest defined word as immediate.
 LITA        n --   Write address n as a literal.

blk/122

@@ -1 +1 @@
-123 132 LOADR
+123 131 LOADR

blk/129

@@ -0,0 +1,16 @@
+( Note that the last word is always skipped because it's not
+possible to reliably detect its end. If you need that last
+word, define a dummy word before calling RLDICT.
+
+We first start by copying the affected area to H@+4. This is
+where the relinking will take place.
+
+Then we iterate the new dict from the top, keeping track of
+wr, the current wordref and we, wr's end offset.
+
+Initially, we get our wr and we, withH@ and CURRENT, which we
+offset by u+4. +4 before, remember, we're using 4 bytes
+as variable space.
+
+At each iteration, we becomes wr-header and wr is fetched from
+PREV field. )

blk/130

@@ -1,16 +1,16 @@
-( Note that the last word is always skipped because it's not
+: RLDICT ( target offset -- )
-possible to reliably detect its end. If you need that last
+    H@ 2+ ! H@ ! ( H@+2 == offset, H@ == target )
-word, define a dummy word before calling RLDICT.
+    H@ @ WORD( DUP H@ -^        ( src u )
-
+    DUP ROT SWAP H@ 4 +         ( u src u dst )
-We first start by copying the affected area to H@+4. This is
+    SWAP MOVE                   ( u )
-where the relinking will take place.
+    4 + DUP CURRENT @ WORD( +   ( u we )
-
+    DUP .X CRLF
-Then we iterate the new dict from the top, keeping track of
+    SWAP CURRENT @ PREV + DUP .X CRLF ( we wr )
-wr, the current wordref and we, wr's end offset.
+    BEGIN                       ( we wr )
-
+        DUP ROT                 ( wr wr we )
-Initially, we get our wr and we, withH@ and CURRENT, which we
+        H@ @ H@ 2+ @            ( wr wr we ol o )
-offset by u+4. +4 before, remember, we're using 4 bytes
+        2SWAP RLWORD            ( wr )
-as variable space.
+        DUP PREV SWAP           ( wr oldwr )
-
+        WORD( SWAP              ( we wr )
-At each iteration, we becomes wr-header and wr is fetched from
+        DUP 4 - H@ <= ( are we finished? )
-PREV field. )
+    UNTIL H@ 4 + .X CRLF ;

blk/131

@@ -1,16 +1,9 @@
-: RLDICT ( target offset -- )
+( Relink a regular Forth full interpreter. )
-    H@ 2+ ! H@ ! ( H@+2 == offset, H@ == target )
+: RLCORE
-    H@ @ WORD( DUP H@ -^        ( src u )
+    LIT< H@ (find) DROP         ( target )
-    DUP ROT SWAP H@ 4 +         ( u src u dst )
+    DUP 3 - @                   ( t prevoff )
-    SWAP MOVE                   ( u )
+    ( subtract H@ name length )
-    4 + DUP CURRENT @ WORD( +   ( u we )
+    2-                          ( t o )
-    DUP .X CRLF
+    RLDICT
-    SWAP CURRENT @ PREV + DUP .X CRLF ( we wr )
+;
-    BEGIN                       ( we wr )
+
-        DUP ROT                 ( wr wr we )
-        H@ @ H@ 2+ @            ( wr wr we ol o )
-        2SWAP RLWORD            ( wr )
-        DUP PREV SWAP           ( wr oldwr )
-        WORD( SWAP              ( we wr )
-        DUP 4 - H@ <= ( are we finished? )
-    UNTIL H@ 4 + .X CRLF ;

blk/132

@@ -1,9 +0,0 @@
-( Relink a regular Forth full interpreter. )
-: RLCORE
-    LIT< H@ (find) DROP         ( target )
-    DUP 3 - @                   ( t prevoff )
-    ( subtract H@ name length )
-    2-                          ( t o )
-    RLDICT
-;
-

blk/434

@@ -6,5 +6,4 @@
     LOOP
     2DROP
 ;
-: DELW 1- 0 SWAP C! ;
 : PREV 3 - DUP @ - ;