Implemented \ comments as a word, implemented [CHAR]
authorTim Vaughan <tgvaughan@gmail.com>
Fri, 6 May 2016 07:08:15 +0000 (19:08 +1200)
committerTim Vaughan <tgvaughan@gmail.com>
Fri, 6 May 2016 07:08:15 +0000 (19:08 +1200)
src/forth.jl
src/lib.4th

index e571758..b1d782c 100644 (file)
@@ -626,24 +626,10 @@ WORD = defPrimWord("WORD", () -> begin
     eof_char = Char(EOF)
     c = eof_char
 
-    skip_to_end = false
     while true
-
         callPrim(mem[KEY])
         c = Char(popPS())
 
-        if c == '\\'
-            skip_to_end = true
-            continue
-        end
-
-        if skip_to_end
-            if c == '\n' || c == eof_char
-                skip_to_end = false
-            end
-            continue
-        end
-
         if c == ' ' || c == '\t'
             continue
         end
@@ -852,7 +838,7 @@ end, name="DOCOL")
 defConst("DODOES", DODOES)
 
 FROMDOES_PAREN = defWord("(DOES>)",
-    [DODOES, LAST, FETCH, TOCFA, STORE, EXIT])
+    [DODOES, LATEST, FETCH, TOCFA, STORE, EXIT])
 
 FROMDOES = defWord("DOES>",
     [BTICK, FROMDOES_PAREN, COMMA, BTICK, EXIT, COMMA,
index a43f6c1..955cadf 100644 (file)
@@ -1,3 +1,10 @@
+: \ IMMEDIATE
+        KEY
+        10 = 0BRANCH [ -5 , ]
+; \ We can now comment!
+
+\ BASIC DEFINITIONS  ----------------------------------------------------------------------
+
 : / /MOD SWAP DROP ;
 : MOD /MOD DROP ;
 : */ -ROT * SWAP / ;
@@ -8,7 +15,8 @@
 : FALSE 0 ;
 : NOT 0= ;
 
- \ Allow for slightly more portable code
+\ Translate a number of cells into memory units
+\ (in our case 1 cell = 1 memory unit)
 : CELLS ;
 
 \ Since the smallest unit of memory in our system is 64 bits and since strings
 
 : LITERAL IMMEDIATE ['] LIT , , ;
 
-: ':' [ CHAR : ] LITERAL ;
-: ';' [ CHAR ; ] LITERAL ;
-: '(' [ CHAR ( ] LITERAL ;
-: ')' [ CHAR ) ] LITERAL ;
-: '<' [ CHAR < ] LITERAL ;
-: '>' [ CHAR > ] LITERAL ;
-: '"' [ CHAR " ] LITERAL ;
-: 'A' [ CHAR A ] LITERAL ;
-: '0' [ CHAR 0 ] LITERAL ;
-: '-' [ CHAR - ] LITERAL ;
-: '.' [ CHAR . ] LITERAL ;
+: [CHAR] IMMEDIATE
+    CHAR
+    ['] LIT , ,
+;
 
 : CR '\n' emit ;
 : SPACE BL emit ;
         1               \ allowed nested parens by keeping track of depth
         BEGIN
                 KEY             \ read next character
-                DUP '(' = IF    \ open paren?
+                DUP [CHAR] ( = IF    \ open paren?
                         DROP            \ drop the open paren
                         1+              \ depth increases
                 ELSE
-                        ')' = IF        \ close paren?
+                        [CHAR] ) = IF        \ close paren?
                                 1-              \ depth decreases
                         THEN
                 THEN
 
         ( print the remainder )
         DUP 10 < IF
-                '0'             ( decimal digits 0..9 )
+                [CHAR] 0             ( decimal digits 0..9 )
         ELSE
                 10 -            ( hex and beyond digits A..Z )
-                'A'
+                [CHAR] A
         THEN
         +
         EMIT
         SWAP            ( u flag )
 
         IF                      ( was it negative? print the - character )
-                '-' EMIT
+                [CHAR] - EMIT
         THEN
 
         U.
 : . 0 .R SPACE ;
 
 : .S            ( -- )
-        '<' EMIT DEPTH U. '>' EMIT SPACE
+        [CHAR] < EMIT DEPTH U. [CHAR] > EMIT SPACE
         PSP0 @ 1+
         BEGIN
                 DUP PSP@ 2 - <=
                 KEY DROP
                 BEGIN
                         KEY             ( get next character of the string )
-                        DUP '"' <>
+                        DUP [CHAR] " <>
                 WHILE
                         C,              ( copy character )
                 REPEAT
                 KEY DROP
                 BEGIN
                         KEY
-                        DUP '"' <>
+                        DUP [CHAR] " <>
                 WHILE
                         OVER C!         ( save next character )
                         1+              ( increment address )
         KEY DROP
         BEGIN
                 KEY
-                DUP ')' = IF
+                DUP [CHAR] ) = IF
                         DROP    ( drop the double quote character )
                         EXIT    ( return from this function )
                 THEN
         DUP >CFA @ CASE
                 DOCOL OF
                         \ Colon definition
-                        ':' EMIT SPACE DUP ID. SPACE
+                        [CHAR] : EMIT SPACE DUP ID. SPACE
                         DUP ?IMMEDIATE IF ." IMMEDIATE " THEN CR
                 ENDOF
                 DOVAR OF
         ENDCASE
 
         ( begin the definition with : NAME [IMMEDIATE] )
-        ( ':' EMIT SPACE DUP ID. SPACE
+        ( [CHAR] : EMIT SPACE DUP ID. SPACE
         DUP ?IMMEDIATE IF ." IMMEDIATE " THEN CR 4 )
 
         4 SPACES
                         .                       ( and print it )
                 ENDOF
                 ['] LITSTRING OF          ( is it LITSTRING ? )
-                        [ CHAR S ] LITERAL EMIT '"' EMIT SPACE ( print S"<space> )
+                        [CHAR] S EMIT [CHAR] " EMIT SPACE ( print S"<space> )
                         1+ DUP @                ( get the length word )
                         SWAP 1+ SWAP            ( end start+1 length )
                         2DUP TELL               ( print the string )
-                        '"' EMIT SPACE          ( finish the string with a final quote )
+                        [CHAR] " EMIT SPACE          ( finish the string with a final quote )
                         +                       ( end start+1+len, aligned )
                         1-                     ( because we're about to add 4 below )
                 ENDOF
                 1+             ( end start+1 )
         REPEAT
 
-        ';' EMIT CR
+        [CHAR] ; EMIT CR
 
         2DROP           ( restore stack )
 ;