\ Parsing words from bytecode 

( G: allow 8-char operator and 255 chars from byte-code to evaluate )
CREATE TOKEN-BUFFER 264 CHARS ALLOT

( G: LLIT precedes numbers whether compiling or not. )
: LLIT ( S: "number" -- )
   TOKEN-BUFFER 0 TOKENS>STRING EVALUATE ; IMMEDIATE

CREATE ADDRESSES 256 CELLS ALLOT
VARIABLE LAST-ADDRESS -1 LAST-ADDRESS !

: NEW-ADDRESS ( S: -- )
   HERE LAST-ADDRESS NEW-ITEM CELLS ADDRESSES + ! ;

: GET-ADDRESS ( S: -- addr )
   INPUT-TOKEN CELLS ADDRESSES + @ ;

( G: like CHAR but use next token for the char )
: LCHAR ( S: "char" -- char )
   INPUT-TOKEN ;
( G: like [CHAR] but from token )
: L[CHAR] ( S: "char" -- )
   INPUT-TOKEN POSTPONE LITERAL ; IMMEDIATE

( G: like S" but text from tokens )
: LS" ( C: "text" -- ) ( E: -- c-addr len ) ( I: "text" -- c-addr len )
   TOKEN-BUFFER 0 [CHAR] S SC!
   [CHAR] " SC! BL SC! TOKENS>STRING
   [CHAR] " SC! EVALUATE ; IMMEDIATE

( G: like ABORT" but from tokens )
: LABORT" ( C: "text" -- ) ( E: f -- )
   S" ABORT" TOKEN-BUFFER SWAP CHARS MOVE TOKEN-BUFFER 5  [CHAR] " SC! BL SC!
   TOKENS>STRING [CHAR] " SC! EVALUATE ; IMMEDIATE

( G: like ." but text from tokens )
: L." ( C: "text" -- ) ( E: -- )
   TOKEN-BUFFER 0 [CHAR] . SC! [CHAR] " SC! BL SC! TOKENS>STRING
   [CHAR] " SC! EVALUATE ; IMMEDIATE
( G: like token .( )
: L.( ( S: "text" -- )
   TOKEN-BUFFER 0 [CHAR] . SC! [CHAR] ( SC! BL SC! TOKENS>STRING [CHAR] ) SC!
   EVALUATE ; IMMEDIATE

( G: : or ' a name )
CREATE NAME-BUFFER 34 CHARS ALLOT

\ ( G: L' gets the xt for the next token in the input stream. )
\ : L' ( S: -- xt )
\    INPUT-TOKEN TOKEN>XT @ ;

\ ( G: L['] gets the xt and compiles it as a literal. )
\ : L['] ( S: -- )
\    L' POSTPONE LITERAL ; IMMEDIATE

 ( 3 kinds of colon defining words.
( G: L:NONAME returns an xt, doesn't get a token.
( G: L: gets a token but no xt or name.
( G: LNAME: creates a new name and a new token both.)

( The 3 types get handled at ; when the xt's are available.
( So ;LEAD finds out from LEADCOMPILE which it was. )

VARIABLE TOKENCOMPILE

: ;L ( S: 0|xt colon-sys -- xt|nothing )
   POSTPONE ;
   TOKENCOMPILE @ IF
     TOKENCOMPILE @ -2 = IF
       DROP [CHAR] ' NAME-BUFFER C! NAME-BUFFER 34 EVALUATE
     THEN
     NEW-TOKEN
   THEN ;
IMMEDIATE

: L:NONAME ( S: -- xt colon-sys )
   0 TOKENCOMPILE ! :NONAME ;
( G: LEAD: gets an xt for a token. )
: L: ( S: -- xt colon-sys )
  -1 TOKENCOMPILE ! :NONAME ;
( G: L: creates a word that keeps its name.  It gets a token too. )
: LNAME:  ( S: "name" -- 0 colon-sys )
   0 NAME-BUFFER 34 BL FILL
   NAME-BUFFER 0 [CHAR] : SC! BL SC!
   -2 TOKENCOMPILE !
   TOKENS>STRING EVALUATE ;
\ would it be easier to make it deferred?  Then we could assign the token
\ immediately.  we'd have to put the xt in the deferred spot later instead of
\ finding the xt later and putting it in the token spot.

\ There's an issue about parsing commands that might get used both on bytecode
\ and on later text.  There could be a place for bytecode-created commands that
\ later parse text.  There's definitely a place for bytecode that parses bytecode.
\ How can we have it both ways?  If we use different tokens to do both then we
\ use up more tokens and also we get routines that do one or the other that can
\ get confused.  So we defer the commands that might go either way, and redirect
\ them according to the current source.

\ But immediate words aren't an issue unless they get postponed, and we can
\ handle those with POSTPONE (which isn't implemented yet).  We just don't have
\ many words that it's a problem with, yet.

DEFER PCHAR
DEFER P:NONAME
DEFER P:

\ LNAME: has no corresponding text form and doesn't need to be switched.

( G: set up parsing words for tokens )
: TOPARSETOKENS ( S: -- )
   ['] LCHAR            [IS] PCHAR
\    ['] L'               [IS] P'
   ['] L:               [IS] P:
   ['] L:NONAME         [IS] P:NONAME ;

( G: set up parsing words for text )
: TOPARSETEXT ( S: -- )
   ['] CHAR             [IS] PCHAR
\    ['] '                [IS] P'
\    ['] [']              [IS] P[']
   ['] :                [IS] P:
   ['] :NONAME          [IS] P:NONAME ;
Kwiki Logo