---------------------------------------------------------------
QL Brouhabouha Forth 1994-05-15
---------------------------------------------------------------

Distribution is welcome, but ONLY allowed with all original 
textfiles being at least part of what is distributed, and the 
executable file remains the original one. 

All rights reserved @ Ewald Pfau, 1991-1994. 

---------------------------------------------------------------
---------------------------------------------------------------

This is a supplement to file: Brouha.Txt

Contents:
-- Table of optimizing compiler actions 
-- Table of Forth words 

---------------------------------------------------------------
---------------------------------------------------------------

***************************************************************
       ** Table of optimizing compiler actions **
***************************************************************

---------------------------------------------------------------
1.a
	 exe-An 
       & exe-B 
     ==> exe-Cn 

---------------------------------------------------------------
1.b
     A[  exe-A1  exe-A2  exe-A3 ... ]
     B=  ............................. exe-B
     C[  exe-C1  exe-C2  exe-C3 ... ]

---------------------------------------------------------------
1.c
     A[  R>    SWAP ROT     2DROP ]    
     B=  .......................... DROP
     C[  RDROP NIP  ROTDROP 3DROP ]    
     
     A[  2R>       2R>/SWAP  R>/RDROP RDROP/R>  2R@      ] 
     B=  ................................................. DROP
     C[  RDROP/R>  R>/RDROP  2RDROP   2RDROP    2R@/DROP ] 

     A[  NIP     DROP     2R>       2R>/SWAP  2R@ ]
     B=  .......................................... NIP
     C[  NIPNIP  DROPNIP  R>/RDROP  RDROP/R>  R@  ]
     
     A[  ROT      OVER      2DUP       R>        0       2R>/SWAP  ]
     B=  ........................................................... SWAP
     C[  ROTSWAP  OVERSWAP  2DUP/SWAP  R>/SWAP   0/SWAP  2R>       ]
     
     A[  ROT	 SWAP	  DUP	 ]
     B=  ......................... ROT
     C[  ROTROT  SWAPROT  DUPROT ]
     
     A[  DROP	2DROP  2SWAP  R>	2R>	2R>/SWAP ]
     B=  ................................................. 2DROP
     C[  3DROP	4DROP  2NIP   R>/2DROP	2RDROP	2RDROP	 ]
     
     A[  2R>	   ]
     B=  ........... 2SWAP  
     C[  2R>/2SWAP ]  
     
     A[  2SWAP  2OVER ]
     B=  .............. 2OVER
     C[  2TUCK  4DUP  ]
     
     A[  2ROT  ]
     B=  ....... 2ROT
     C[  -2ROT ]

     A[  DUP     SWAP     >R        SWAP/>R ]
     B=  .................................... >R
     C[  DUP/>R  SWAP/>R  SWAP/2>R  2>R     ]
     
     A[  >R	]
     B=  ........ R@
     C[  DUP/>R ]
     
     A[  R>	   DROP    ]
     B=  ................... R>
     C[  2R>/SWAP  DROP/R> ]
     
     A[  2DUP      2SWAP     ]
     B=  ..................... 2>R
     C[  2DUP/2>R  2SWAP/2>R ]
 
     A[  DUP   ]
     B=  ....... @
     C[  DUP/@ ]
     
     A[  2DUP    ]   
     B=  ......... C!
     C[  2DUP/C! ]

     A[  SWAP    OVER    TUCK    DUPROT   2DUP   ]   
     B=  ......................................... !
     C[  SWAP/!  OVER/!  TUCK/!  DUPROT/! 2DUP/! ]
     
     A[  OVER    TUCK    2DUP    CELLS    @   ]
     B=  ..................................... +
     C[  OVER/+  TUCK/+  2DUP/+  CELLS/+  @/+ ]

     A[  OVER    TUCK    2DUP    2DUP/SWAP    CELLS    @   ]
     B=  ................................................... -
     C[  OVER/-  TUCK/-  2DUP/-  2DUP/SWAP/-  CELLS/-  @/- ]

     A[  2SWAP    ]
     B=  .......... D-
     C[  2SWAP/D- ]

     A[  0<   0>   =   <>  <    >   U<   U>  ] 
     B=  ..................................... 0=
     C[  0>=  0=<  <>  =   >=	=<  U>=  U=< ]

     A[  2DUP/=   2DUP/<>  2DUP/- 2DUP/<   2DUP/>   2DUP/U<   2DUP/U>  ]
     B=  ............................................................... 0=
     C[  2DUP/<>  2DUP/=   2DUP/= 2DUP/>=  2DUP/=<  2DUP/U>=  2DUP/U=< ]

     A[  D0=   D0<  D=  D<  DU<  ]
     B=  ......................... 0=
     C[  D0<>  D0>= D<> D>= DU>= ]

     A[  1        ]
     B=  .......... /STRING
     C[  1/STRING ]

     A[  0      BL    ]
     B=  .............. FILL
     C[  ERASE  BLANK ]

     A[  @       ]
     B=  ......... EXECUTE
     C[  PERFORM ]

     A[  DROP      1       0      -1      FALSE   TRUE   ]
     B=  ................................................. EXIT
     C[  DROP/EXIT 1&EXIT  0&EXIT -1&EXIT 0&EXIT -1&EXIT ]

---------------------------------------------------------------
---------------------------------------------------------------
2.a
	 exe-A
       & exe-Bn  
     ==> exe-Cn 

---------------------------------------------------------------
2.b
      A=  exe-A
      B[  exe-B1  exe-B2  exe-B3 ... ]
      C[  exe-C1  exe-C2  exe-C3 ... ]

---------------------------------------------------------------
2.c
     A=  DROP
     B[  SWAP       DUP       0      ]
     C[  DROP/SWAP  DROP/DUP  DROP/0 ]

     A=  SWAP
     B[  <  >  U<  U>  -       OVER  MOVE      ]
     C[  >  <  U>  U<  SWAP/-  TUCK  SWAP/MOVE ]

     A=  2DUP
     B[  =        <>       -       <        >      ]
     C[  2DUP/=   2DUP/<>  2DUP/-  2DUP/<   2DUP/> ]  

     A=  2DUP
     B[  U<       U>       AND       OR       XOR      ]
     C[  2DUP/U<  2DUP/U>  2DUP/AND  2DUP/OR  2DUP/XOR ]

     A=  2DUP/SWAP
     B[  <       >        U<       U>       -            ]
     C[  2DUP/>  2DUP/<   2DUP/U>  2DUP/U<  2DUP/SWAP/-  ]

---------------------------------------------------------------
---------------------------------------------------------------

3.a		    XBRA[  IF  WHILE  UNTIL  ]

---------------------------------------------------------------
3.b 
			  rel-exe	      rel-exe 
		       &  XBRA		   &  0=      
		     ==>  rel/0BRA	   &  XBRA     
					 ==>  rel/?BRA

---------------------------------------------------------------
3.c

   rel-exe	      rel/0BRA		     rel/?BRA 
						       
    PAUSE	    PAUSE/0BRA		  PAUSE/?BRA
       0<	       0</0BRA		     0</?BRA   
       0>	       0>/0BRA		     0>/?BRA   
	=		=/0BRA		      =/?BRA   
       <>	       <>/0BRA		     <>/?BRA   
	<		</0BRA		      </?BRA   
	>		>/0BRA		      >/?BRA   
       U<	       U</0BRA		     U</?BRA   
       U>	       U>/0BRA		     U>/?BRA   
   WITHIN	   WITHIN/0BRA		 WITHIN/?BRA   
	-	       <>/0BRA		     <>/?BRA   
      AND	      AND/0BRA		    AND/?BRA   
       OR	       OR/0BRA		     OR/?BRA   
      XOR             XOR/0BRA              XOR/?BRA   
     ?DUP	     ?DUP/0BRA		   ?DUP/?BRA   
      DUP	      DUP/0BRA		    DUP/?BRA   
     SWAP	     SWAP/0BRA		   SWAP/?BRA   
    CASE?	    CASE?/0BRA			       
    2DUP/=         2DUP/=/0BRA           2DUP/=/?BRA  
    2DUP/<>       2DUP/<>/0BRA          2DUP/<>/?BRA
    2DUP/-        2DUP/<>/0BRA          2DUP/<>/?BRA
    2DUP/<         2DUP/</0BRA           2DUP/</?BRA   
    2DUP/>         2DUP/>/0BRA           2DUP/>/?BRA
    2DUP/>=        2DUP/</?BRA           2DUP/</0BRA
    2DUP/=<        2DUP/>/?BRA           2DUP/>/0BRA
    2DUP/U<       2DUP/U</0BRA          2DUP/U</?BRA  
    2DUP/U>       2DUP/U>/0BRA          2DUP/U>/?BRA
    2DUP/U>=      2DUP/U</?BRA          2DUP/U</0BRA  
    2DUP/U=<      2DUP/U>/?BRA          2DUP/U>/0BRA
    2DUP/AND     2DUP/AND/0BRA         2DUP/AND/?BRA 
    2DUP/OR       2DUP/OR/0BRA          2DUP/OR/?BRA
    2DUP/XOR     2DUP/XOR/0BRA         2DUP/XOR/?BRA                          
     D0=              D0=/0BRA              D0=/?BRA   
     D0<	      D0</0BRA		    D0</?BRA   
      D=	       D=/0BRA		     D=/?BRA   
      D<	       D</0BRA		     D</?BRA   
     DU<	      DU</0BRA		    DU</?BRA   

---------------------------------------------------------------
3.d 
			  rel-exe	      rel-exe 
		       &  XBRA		   &  0=      
		     ==>  rel/?BRA	   &  XBRA     
					 ==>  rel/0BRA

---------------------------------------------------------------
3.e

   rel-exe	      rel/?BRA		     rel/0BRA 

      0>=	       0</?BRA		     0</0BRA   
      0=<	       0>/?BRA		     0>/0BRA   
       >=		</?BRA		      </0BRA   
       =<		>/?BRA		      >/0BRA   
      U>=	       U</?BRA		     U</0BRA   
      U=<	       U>/?BRA		     U>/0BRA   
     D0<>	      D0=/?BRA		    D0=/0BRA   
     D0>=	      D0</?BRA		    D0</0BRA   
      D<>	       D=/?BRA		     D=/0BRA   
      D>=	       D</?BRA		     D</0BRA   
     DU>=	      DU</?BRA		    DU</0BRA   

---------------------------------------------------------------
---------------------------------------------------------------
4.a 
			  exe-An	 
		       &  exe-Bn
		     ==>  exe-Cn

---------------------------------------------------------------
4.b

     A[  exe-A1  exe-A2  exe-A3 ... ]
     B[  exe-B1  exe-B2  exe-B3 ... ]
     C[  exe-C1  exe-C2  exe-C3 ... ]

---------------------------------------------------------------
4.c

     BRA[ AHEAD  ELSE  AGAIN  REPEAT  LEAVE ]

---------------------------------------------------------------
4.d

     A[  PAUSE	    PAUSE	PAUSE	     0	  0    ] 
     B[  BRA	    LOOP	+LOOP	     DO   ?DO  ]
     C[  PAUSE/BRA  PAUSE/LOOP	PAUSE/+LOOP  0DO  ?0DO ]

---------------------------------------------------------------
---------------------------------------------------------------

***************************************************************
               ** Table of Forth words **
***************************************************************

---------------------------------------------------------------
---------------------------------------------------------------

\\ returnstack handling 

CORE:         
EXIT       ( -- R: i --) 
EXECUTE    ( cfa -- R: -- i) 
>R         ( n -- R: -- n) 
R>         ( -- n R: n --) 
R@         ( -- n R: n -- n) 

EXT:          
2>R        ( n1 n2 --  R: n1 n2) 
2R>        ( -- n1 n2  R: n1 n2) 
2R@        ( -- n1 n2  /R: n1 n2 -- n1 n2) 

----------------------------------------------------------------
\\ stack handling 

CORE:         
DROP       ( n --) 
DUP        ( n -- n n) 
SWAP       ( n1 n2 -- n2 n1) 
OVER       ( n1 n2 -- n1 n2 n1) 
ROT        ( n1 n2 n3 -- n2 n3 n1) 
?DUP       ( 0 -- 0  // n -- n n) 
2DROP      ( n1 n2 --) 
2DUP       ( n1 n2 -- n1 n2 n1 n2) 
2SWAP      ( n1 n2 n3 n4 -- n3 n4 n1 n2) 
2OVER      ( n1 n2 n3 n4 -- n1 n2 n3 n4 n1 n2) 
DEPTH      ( ix -- ix n) 

EXT:          
NIP        ( n1 n2 -- n2) 
TUCK       ( n1 n2 -- n2 n1 n2) 
PICK       ( nx .. np .. n0 p -- nx .. np .. n0 np) 
ROLL       ( nx .. np .. n0 p -- nx .. np-1 .. n0 np) 

DOUBLE EXT:   
2ROT       ( n1 n2 n3 n4 n5 n6 -- n3 n4 n5 n6 n1 n2) 

----------------------------------------------------------------
\\ arithmetic calculation 

CORE:         
=          ( n1 n2 -- f) 
U<         ( n1 n2 -- f) 
<          ( n1 n2 -- f) 
>          ( n1 n2 -- f) 
0=         ( n -- f) 
0<         ( n -- f) 
AND        ( n1 n2 -- n3) 
OR         ( n1 n2 -- n3) 
XOR        ( n1 n2 -- n3) 
INVERT     ( n1 -- n2) 
LSHIFT     ( n1 n2 -- n3) 
RSHIFT     ( n1 n2 -- n3) 
+          ( n1 n2 -- n3) 
-          ( n1 n2 -- n3) 
NEGATE     ( n -- n) 
ABS        ( n1 -- n2) 
MIN        ( n1 n2 -- n3) 
MAX        ( n1 n2 -- n3) 

EXT:          
<>         ( n1 n2 -- f) 
U>         ( n1 n2 -- f) 
0<>        ( n -- f) 
0>         ( n -- f) 
WITHIN     ( n1 n2 n3 -- f) 

DOUBLE:       
D=         ( d1 d2 -- f) 
D+         ( d1 d2 -- d3) 
DNEGATE    ( d1 -- d2) 
DABS       ( d1 -- d2) 
D<         ( d1 d2 -- f) 
D0=        ( d1 -- f) 
D0<        ( d1 -- f) 
DMIN       ( d1 d2 -- d3) 
DMAX       ( d1 d2 -- d3) 
M+         ( d1 n -- d2) 
D-         ( d1 d2 -- d3) 

EXT:          
DU<        ( d1 d2 -- f) 

----------------------------------------------------------------
\\ arithmetic constants 

CORE:         
ALIGNED    ( a -- a) 
1+         ( n -- n+1) 
1-         ( n -- n-1) 
2*         ( n -- n*2) 
2/         ( n -- n/2) 
CELL+      ( a -- a+) 
CELLS      ( n -- n+) 
CHAR+      ( a -- a+) 
CHARS      ( n -- n+) 
S>D        ( n -- d) 
>BODY      ( cfa -- a2) 

EXT:          
TRUE       ( -- -1) 
FALSE      ( -- 0) 

DOUBLE:       
D>S        ( d -- n) 
D2*        ( d1 -- d2) 
D2/        ( d1 -- d2) 

STRING:       
/STRING    ( a1 u1 n1 -- a1+ u1-) 

----------------------------------------------------------------
\\ memory access 

CORE:         
C@         ( a -- b) 
C!         ( b a --) 
@          ( a -- n) 
!          ( n a --) 
2@         ( a -- d) 
2!         ( d a --) 
+!         ( n a -) 
MOVE       ( a1 a2 n --) 
FILL       ( a n b --) 
COUNT      ( a$ -- a+1 n) 

EXT:          
ERASE      ( a n --) 

STRING:       
CMOVE      ( a1 a2 n --) 
CMOVE>     ( a1 a2 n --) 
BLANK      ( a n --) 
-TRAILING  ( a1 n1 -- a1 n2) 
COMPARE    ( a1 n1 a2 n2 --  -1/0/1) 
SEARCH     ( a1 n1 a2 n2 -- a3 n3 f)

----------------------------------------------------------------
\\ enhanced arithmetics 

CORE:         
UM/MOD     ( d n1 -- u2/rem u3/div) 
FM/MOD     ( d n1 -- n2 n3) 
SM/REM     ( d n1 -- n2 n3) 
UM*        ( u1 u2 -- ud) 
M*         ( n1 n2 -- d)

\ missing
/MOD       ( n1 n2 -- n3 n4) 
/          ( n1 n2 -- n3) 
MOD        ( n1 n2 -- n3) 
*          ( n1 n2 -- n3) 
*/MOD      ( n1 n2 n3 -- n4 n5) 
*/         ( n1 n2 n3 -- n4)

DOUBLE:       
M*/        ( d1 n1 n2 -- d2)

----------------------------------------------------------------
\\ system values 

CORE:         
BL         ( -- 32) 
>IN        ( -- a) 
SOURCE     ( -- a n)
STATE      ( -- a) 
BASE       ( -- a)

SEARCH:       
FORTH-WORDLIST   ( -- wid)

BLOCK:        
BLK        ( -- a)

BLOCK EXT:    
SCR        ( -- a)

FILE:         
BLOCK-FID  ( -- a) 
SOURCE-ID  ( -- n)

----------------------------------------------------------------
\\ value access 

CORE:         
HERE       ( -- a) 
ALLOT      ( n --) 
ALIGN      ( --) 
C,         ( b --) 
,          ( n --)

EXT:          
PAD        ( -- a) 
COMPILE,   ( cfa --) 
UNUSED     ( -- u)
ENVIRONMENT?     ( -- 0)

----------------------------------------------------------------
\\ number conversion 

CORE:         
DECIMAL    ( --)
>NUMBER    ( d a n -- d a+ n-)
<#         ( --) 
HOLD       ( b --) 
SIGN       ( n --) 
#          ( d1 -- d2) 
#S         ( d1 -- d2) 
#>         ( d -- a n)

EXT:          
HEX        ( --)

----------------------------------------------------------------
\\ output 

CORE: 
TYPE       ( a n --) 
EMIT       ( b --) 
SPACE      ( --) 
SPACES     ( n --) 
CR         ( --)
.          ( n --) 
U.         ( n --)

EXT:          
.(         ( --) 
.R         ( n1 n2 --) 
U.R        ( n1 n2 --)

DOUBLE:       
D.         ( d --) 
D.R        ( d n --)

FACILITY EXT: 
EMIT?      ( -- f) 
PAGE       ( --) 
AT-XY      ( n1 n2 --)

----------------------------------------------------------------
\\ search order 

CORE:         
FIND             ( $a -- a 0 , cfa -2/-1/1/2)

SEARCH:       
SEARCH-WORDLIST  ( a n wid -- 0 , cfa -2/-1/1/2) 
GET-ORDER        ( -- widn..wid1 n) 
SET-ORDER        ( widn..wid1 n --) 
GET-CURRENT      ( -- wid) 
SET-CURRENT      ( wid --) 
DEFINITIONS      ( --)

EXT:          
ALSO             ( --)
PREVIOUS         ( --)
FORTH            ( --)
ONLY             ( --)

TOOLS EXT:    
ASSEMBLER  ( --)
EDITOR     ( --)

----------------------------------------------------------------
\\ input & parsing 

CORE:         
FILE:         
KEY        ( -- b) 
ACCEPT     ( a n1 -- n2)
WORD       ( b -- a$) 
CHAR       ( -- b) 
'          ( -- cfa)
(          ( --) 
S"         ( -- a n)
\                ( --) 
PARSE            ( b -- a n) 
RESTORE-INPUT    ( nx ... n1 x -- f) 
SAVE-INPUT       ( -- nx ... n1 x) 
REFILL           ( -- f) 

FACILITY EXT: 
KEY?       ( -- f) 
EKEY?      ( -- f) 
EKEY       ( -- b)

TOOLS EXT:    
[THEN]     ( n --) 
[ELSE]     ( n -- n) 
[IF]       ( f -- n)

----------------------------------------------------------------
\\ error handling 

ERROR:        
CATCH      ( cfa  --  0 / #-throw) 
THROW      ( # --)

----------------------------------------------------------------
\\ file handling 

BLOCK:        
BUFFER           ( n -- a) 
BLOCK            ( n -- a) 
UPDATE           ( --) 
SAVE-BUFFERS     ( --) 
FLUSH            ( --)

BLOCK EXT:    
EMPTY-BUFFERS    ( --) 
LIST             ( n --)

----------------------------------------------------------------
\\ file handling 

FILE:         
R/W              ( -- n)
R/O              ( -- n)
FILE-POSITION    ( hdl -- d err#) 
REPOSITION-FILE  ( d hdl -- err#) 
FILE-SIZE        ( hdl -- d err#) 
RESIZE-FILE      ( d hdl -- err#)
CLOSE-FILE       ( hdl -- err#) 
OPEN-FILE        ( a n1 n2 -- hdl err#) 
CREATE-FILE      ( a n1 n2 -- hdl err#) 
DELETE-FILE      ( a n - err#)
READ-FILE        ( a n1 hdl -- n2 err#) 
WRITE-FILE       ( a n hdl -- err#)
READ-LINE        ( a n hdl -- n f err#)
WRITE-LINE       ( a n hdl -- err#)

EXT:          
FLUSH-FILE       ( hdl -- err#) 
RENAME-FILE      ( a1 n1 a2 n2 -- err#) 
FILE-STATUS      ( a1 n1 -- n2 err#)

----------------------------------------------------------------
\\ loop engine 

CORE:         
QUIT       ( --  /R: ix -- iy) 
ABORT      ( ix -- iy /R: ix -- iy)
EVALUATE   ( a n --) 

BLOCK EXT:    
THRU       ( u1 u2 --) 
LOAD       ( n --)

FILE:         
INCLUDE-FILE     ( hdl  --) 
INCLUDED         ( a n --)

----------------------------------------------------------------
\\ code compiler 

CORE:         
]          ( --) 
[          ( --) 
:          ( -- /R: -- i  /C: --  /"name") 
DOES>      ( /Runtime:      -- a  /R: i -- )
           ( /Generation:   --    /R: i -- ) 
           / /Compile:      --    /R:  -- i)
;          ( -- /R: i --  /C: --) 
RECURSE    ( --) 
IMMEDIATE  ( --)
LITERAL    ( -- n  /C: n --) 
[CHAR]     ( -- n  /C: -- /"name") 
[']        ( -- n  /C: -- /"name") 
POSTPONE   ( --  /C: --  /"name")
S"         ( /Interpret: -- a n) 
           ( /Runtime:   -- a n)
           ( /Compile:   -- /"string")
."         ( --  /C: -- /"string") 
ABORT"     ( --  /C: -- /"string")

EXT:          
:NONAME    ( -- /R: -- i  /C: -- cfa) 
C"         ( -- $a  /C: -- /"string")

DOUBLE:       
2LITERAL   ( -- d  /C: d --)

TOOLS EXT:    
CODE       ( -- n  /"name") 

LOCAL:        
(LOCAL)    ( /C: a n/0 --)
LOCAL|     ( /C: -- /"name name ... |")
TO         ( n --  /C: -- /"name")

----------------------------------------------------------------
\\ flow of control 

CORE:         
IF         ( f --  /C: -- a) 
THEN       ( --  /C: a --) 
ELSE       ( --  /C: a1 -- a2) 
BEGIN      ( --  /C: -- a) 
UNTIL      ( f --  /C: a --)
WHILE      ( f --  /C: a1 -- a2 a1) 
REPEAT     ( --  /C: a1 a2 --)
DO         ( n2 n1 -- /R: ix/nodo -- iy/do  /C: -- a) 
LOOP       ( --  /R: iy/do -- [iy/do]|[ix/nodo]  /C: a --) 
+LOOP      ( n --  /R: iy/do -- [iy/do]|[ix/nodo]  /C: a --)
I          ( -- n  /R: iy/do -- iy/do) 
UNLOOP     ( --  /R: iy/do -- ix/nodo) 
LEAVE      ( --  /R: iy/do -- ix/nodo)

EXT:          
AGAIN      ( -- /C: a --) 
?DO        ( n2 n1 -- /R: ix/nodo -- [ix/nodo]|[iy/do]  /C: -- a)
J          ( -- n /R: ix/dodo -- ix/dodo) 

TOOLS EXT:    
AHEAD      ( --  /C: -- a)
CS-PICK    ( ax..a1 x -- ax..a1 ax)
CS-ROLL    ( ax ax-1..a1 x -- ax-1..a1 ax)

----------------------------------------------------------------
\\ data compiler 

CORE:         
CREATE     ( --  /"name" /Run: -- a) 
CONSTANT   ( n -- /"name"  /Run: -- n) 
VARIABLE   ( -- /"name"  /Run: -- a)

EXT:          
VALUE      ( n --  /"name"  /Run: -- n) 
TO         ( n -- /"name"  /C: -- /"name") 
MARKER     ( -- /"name")

DOUBLE:       
2CONSTANT   ( d --  /"name"  /Run: -- d) 
2VARIABLE   ( --  /"name"  /Run: -- a)

SEARCH:       
WORDLIST   ( -- wid)

----------------------------------------------------------------
\\ tools 

TOOLS EXT:    
DUMP       ( a n --) 
?          ( a --) 
.S         ( --) 
WORDS      ( -- /"char") 
SEE        ( -- /"name") 
BYE        ( --)

SEARCH EXT:   
ORDER      ( --)

FACILITY EXT: 
MS         ( n --) 
TIME&DATE  ( -- n1 n2 n3 n4 n5 n6)

MEMORY:       
ALLOCATE    ( n -- a err#)
FREE        ( a -- err#)
RESIZE      ( a n -- a err#)

