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
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,
+: \ IMMEDIATE
+ KEY
+ 10 = 0BRANCH [ -5 , ]
+; \ We can now comment!
+
+\ BASIC DEFINITIONS ----------------------------------------------------------------------
+
: / /MOD SWAP DROP ;
: MOD /MOD DROP ;
: */ -ROT * SWAP / ;
: 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 )
;