path: root/slof/engine.in

// ============================================================================
//  * Copyright (c) 2004, 2005 IBM Corporation
//  * All rights reserved. 
//  * This program and the accompanying materials 
//  * are made available under the terms of the BSD License 
//  * which accompanies this distribution, and is available at
//  * http://www.opensource.org/licenses/bsd-license.php
//  * 
//  * Contributors:
//  *     IBM Corporation - initial implementation
// ============================================================================


//
// Copyright 2002,2003,2004  Segher Boessenkool  <segher@kernel.crashing.org>
//

// This is the core engine of Paflof.  It is almost ANS Forth compatible.
// There are two possibilities why an aspect would not be:
//   a) Open Firmware requires different semantics;
//   b) bugs.
// Most of the "extended" semantics defined in the OF specification are
// not implemented; just the bare essentials.  For example, you can't
// use structural words (IF, THEN, BEGIN, etc.) or return-stack
// manipulation words (R> etc.) in the interpreter.


// The data stack pointer.
raw(HERE DOVAL _A(the_mem))

// Some common constant numbers; smaller and faster if they are defined
// as constants, than when inlined as a literal.
con(-1 -1)
con(0 0)
con(1 1)
con(2 2)
con(3 3)
con(4 4)
con(8 8)
con(H#10 0x10)
con(H#FF 0xff)
con(H#FFFF 0xffff)
con(D#10 0x0a)


// Manipulating different kinds of addresses.
con(/C 1)
con(/W 2)
con(/L 4)
con(/N CELLSIZE)
con(CELL CELLSIZE)
col(/C* /C *)
col(/W* /W *)
col(/L* /L *)
col(/N* /N *)
col(CA+ /C* +)
col(WA+ /W* +)
col(LA+ /L* +)
col(NA+ /N* +)
col(CA1+ /C +)
col(WA1+ /W +)
col(LA1+ /L +)
col(NA1+ /N +)
col(CHAR+ CA1+)
col(CELL+ NA1+)
col(CHAR- /C -)
col(CELL- /N -)
col(CHARS /C*)
col(CELLS /N*)
col(CHARS+ CA+)
col(CELLS+ NA+)


// Run-time words for TO and for string literals.
col(DOTO R> CELL+ DUP >R @ CELL+ !)
col(SLITERAL R> CELL+ DUP DUP C@ + LIT(-CELLSIZE) AND >R)


// Stack manipulation.
col(?DUP DUP 0BRANCH(1) DUP)
col(TUCK SWAP OVER)
col(2DUP OVER OVER)
col(3DUP 2 PICK 2 PICK 2 PICK)
col(2OVER 3 PICK 3 PICK)
col(2DROP DROP DROP)
col(3DROP DROP DROP DROP)
col(NIP SWAP DROP)
col(CLEAR 0 DEPTH!)
col(ROT >R SWAP R> SWAP)
col(-ROT SWAP >R SWAP R>)
col(2SWAP >R -ROT R> -ROT)
col(2ROT >R >R 2SWAP R> R> 2SWAP)
col(ROLL DUP ?DUP 0BRANCH(6) ROT >R 1 - BRANCH(-9) ?DUP 0BRANCH(6) R> -ROT 1 - BRANCH(-9))


// Arithmetic.
col(2* 1 LSHIFT)
col(U2/ 1 RSHIFT)
col(2/ 1 ASHIFT)
col(<< LSHIFT)
col(>> RSHIFT)
col(>>A ASHIFT)
col(INVERT -1 XOR)
col(NOT INVERT)


// Booleans.
con(TRUE -1)
con(FALSE 0)


// Comparisons.
col(> SWAP <)
col(U> SWAP U<)
col(<= > 0=)
col(<> = 0=)
col(>= < 0=)
col(0<= 0 <=)
col(0<> 0 <>)
col(0> 0 >)
col(0>= 0 >=)
col(U<= U> 0=)
col(U>= U< 0=)
col(WITHIN ROT DUP ROT >= 0BRANCH(3) 2DROP FALSE EXIT > 0BRANCH(2) FALSE EXIT TRUE)
col(BETWEEN 1 + WITHIN)


// Double-cell single-bit shifts.
col(D2* 2* OVER 0< - >R 2* R>)
col(UD2/ >R U2/ R@ LIT(8*CELLSIZE-1) LSHIFT OR R> U2/)
col(D2/ >R U2/ R@ LIT(8*CELLSIZE-1) LSHIFT OR R> 2/)


// More arithmetic.
col(NEGATE 0 SWAP -)
col(ABS DUP 0< 0BRANCH(1) NEGATE)
col(MAX 2DUP < 0BRANCH(1) SWAP DROP)
col(MIN 2DUP > 0BRANCH(1) SWAP DROP)
col(U* *)
col(1+ 1 +)
col(1- 1 -)
col(2+ 2 +)
col(2- 2 -)
col(EVEN 1+ -1 AND)
col(BOUNDS OVER + SWAP)


// Double-cell and mixed-size arithmetic.
col(S>D DUP 0<)
col(DNEGATE INVERT >R NEGATE DUP 0= R> SWAP -)
col(DABS DUP 0< 0BRANCH(1) DNEGATE)
col(M+ SWAP >R DUP >R + DUP R> U< R> SWAP -)
col(D+ >R M+ R> +)
col(D- DNEGATE D+)
col(*' >R DUP 0< >R D2* R> 0BRANCH(2) R@ M+ R>)
col(UM* 0 -ROT LIT(8*CELLSIZE) 0 DODO *' DOLOOP(-3) DROP)
col(M* 2DUP XOR >R >R ABS R> ABS UM* R> 0BRANCH(1) DNEGATE)
col(/' >R DUP 0< >R D2* R> OVER R@ U>= OR 0BRANCH(6) >R 1 OR R> R@ - R>)
col(UM/MOD LIT(8*CELLSIZE) 0 DODO /' DOLOOP(-3) DROP SWAP)
col(SM/REM OVER >R >R DABS R@ ABS UM/MOD R> 0< 0BRANCH(1) NEGATE R> 0< 0BRANCH(4) NEGATE SWAP NEGATE SWAP)
col(FM/MOD DUP >R 2DUP XOR 0< >R SM/REM OVER 0<> R> AND 0BRANCH(6) 1- SWAP R> + SWAP EXIT R> DROP)


// Division.
col(U/MOD 0 SWAP UM/MOD)
col(/MOD >R S>D R> FM/MOD)
col(/ /MOD NIP)
col(MOD /MOD DROP)
col(*/MOD >R M* R> FM/MOD)
col(*/ */MOD NIP)


// Splitting, joining, flipping the components of a number.
col(WBSPLIT DUP H#FF AND SWAP 8 RSHIFT)
col(LWSPLIT DUP H#FFFF AND SWAP H#10 RSHIFT)
col(LBSPLIT LWSPLIT >R WBSPLIT R> WBSPLIT)
col(BWJOIN 8 LSHIFT OR)
col(WLJOIN H#10 LSHIFT OR)
col(BLJOIN BWJOIN >R BWJOIN R> WLJOIN)
col(WBFLIP WBSPLIT SWAP BWJOIN)
col(LWFLIP LWSPLIT SWAP WLJOIN)
col(LBFLIP LBSPLIT SWAP 2SWAP SWAP BLJOIN)


// Aligning to cell size.
col(ALIGNED /N 1- + /N NEGATE AND)


// Counted loop stuff.
col(I R> R@ SWAP >R)
col(J R> R> R> R@ SWAP >R SWAP >R SWAP >R)
col(UNLOOP R> R> R> 2DROP >R)


// Memory accesses.
col(+! TUCK @ + SWAP !)
col(COMP 0 DO?DO(27) OVER I + C@ OVER I + C@ 2DUP < 0BRANCH(6) 2DROP UNLOOP 2DROP LIT(-1) EXIT > 0BRANCH(4) UNLOOP 2DROP 1 EXIT DOLOOP(-27) 2DROP 0)
col(OFF FALSE SWAP !)
col(ON TRUE SWAP !)
col(<W@ W@ DUP LIT(0x8000) >= 0BRANCH(3) LIT(0x10000) -)
col(2@ DUP @ SWAP CELL+ @)
col(2! DUP >R CELL+ ! R> !)
col(WBFLIPS BOUNDS DO?DO(8) I W@ WBFLIP I W! /W DO+LOOP(-8))
col(LWFLIPS BOUNDS DO?DO(8) I L@ LWFLIP I L! /L DO+LOOP(-8))
col(LBFLIPS BOUNDS DO?DO(8) I L@ LBFLIP I L! /L DO+LOOP(-8))
col(FILL -ROT BOUNDS DO?DO(5) DUP I C! DOLOOP(-5) DROP)
col(BLANK LIT(0x20) FILL)
col(ERASE LIT(0x00) FILL)


// Exception handling.
var(CATCHER 0)
var(ABORT"-STR 0)
col(CATCH DEPTH >R CATCHER @ >R RDEPTH CATCHER ! EXECUTE R> CATCHER ! R> DROP 0)
col(THROW ?DUP 0BRANCH(12) CATCHER @ RDEPTH! R> CATCHER ! R> SWAP >R DEPTH! DROP R>)
col(ABORT -1 THROW)


// Text input.
var(#TIB TIBSIZE)
val(IB 0)
var(#IB 0)
val(SOURCE-ID 0)
col(SOURCE IB #IB @)
var(>IN 0)
col(TERMINAL TIB DOTO IB #TIB @ #IB ! 0 DOTO SOURCE-ID)


// ASCII codes.
con(BL 0x20)
con(BELL 7)
con(BS 8)
con(CARRET 0x0d)
con(LINEFEED 0x0a)


// Text output.
dfr(EMIT)
col(TYPE BOUNDS DO?DO(5) I C@ EMIT DOLOOP(-5))
col(CR CARRET EMIT LINEFEED EMIT)
col(SPACE BL EMIT)
col(SPACES 0 DO?DO(3) SPACE DOLOOP(-3))


// Text manipulation.
col(COUNT DUP CHAR+ SWAP C@)
col(UPC DUP LIT('a') LIT('z') BETWEEN 0BRANCH(3) LIT(0x20) - )
col(LCC DUP LIT('A') LIT('Z') BETWEEN 0BRANCH(3) LIT(0x20) + )


// Text input.
dfr(KEY)
dfr(KEY?)
dfr(ACCEPT)
var(SPAN 0)
col(EXPECT ACCEPT SPAN !)
col(REFILL SOURCE-ID 0= 0BRANCH(7) SOURCE EXPECT 0 >IN ! TRUE EXIT SOURCE-ID -1 = 0BRANCH(2) FALSE EXIT LIT(0x6502) THROW)


// Number base.
var(BASE 16)
col(DECIMAL D#10 BASE !)
col(HEX H#10 BASE !)
col(OCTAL 8 BASE !)


// Pictured numeric output.
col(PAD HERE LIT(256) +)
col(TODIGIT DUP LIT(9) > 0BRANCH(3) LIT(0x27) + LIT(0x30) +)
col(MU/MOD DUP >R U/MOD R> SWAP >R UM/MOD R>)
col(<# PAD DUP !)
col(HOLD PAD DUP @ 1- TUCK SWAP ! C!)
col(SIGN 0< 0BRANCH(3) LIT('-') HOLD)
col(# BASE @ MU/MOD ROT TODIGIT HOLD)
col(#S # 2DUP OR 0BRANCH(2) BRANCH(-7))
col(#> 2DROP PAD DUP @ TUCK -)
col((.) <# DUP >R ABS 0 #S R> SIGN #>)
col(U# BASE @ U/MOD SWAP TODIGIT HOLD)
col(U#S U# DUP 0BRANCH(2) BRANCH(-6))
col(U#> DROP PAD DUP @ TUCK -)
col((U.) <# U#S U#>)
col(. (.) TYPE SPACE)
col(S. .)
col(U. (U.) TYPE SPACE)
col(.R SWAP (.) ROT 2DUP < 0BRANCH(5) OVER - SPACES BRANCH(1) DROP TYPE)
col(U.R SWAP (U.) ROT 2DUP < 0BRANCH(5) OVER - SPACES BRANCH(1) DROP TYPE)
col(.D BASE @ SWAP DECIMAL . BASE !)
col(.H BASE @ SWAP HEX . BASE !)
col(.S DEPTH 0 DO?DO(8) DEPTH I - 1- PICK . DOLOOP(-8))
col(? @ .)


// Numeric input.
col(DIGIT OVER UPC DUP LIT('A') LIT('Z') BETWEEN 0BRANCH(3) LIT(7) - LIT(0x30) - DUP ROT 0 SWAP WITHIN 0BRANCH(4) NIP TRUE BRANCH(2) DROP FALSE)
col(>NUMBER DUP 0= 0BRANCH(1) EXIT OVER C@ BASE @ DIGIT 0BRANCH(23) SWAP >R SWAP >R >R BASE @ U* SWAP BASE @ UM* ROT + R> 0 D+ R> CHAR+ R> 1- BRANCH(-35) DROP)
col($NUMBER DUP 0= 0BRANCH(4) DROP DROP TRUE EXIT >R DUP >R C@ LIT('-') = DUP 0BRANCH(15) R> CHAR+ R> 1- DUP 0= 0BRANCH(5) DROP DROP DROP TRUE EXIT >R >R 0 0 R> R> >NUMBER NIP 0= 0BRANCH(7) DROP SWAP 0BRANCH(1) NEGATE FALSE EXIT DROP DROP DROP TRUE)


// Data space allocation.
col(ALLOT HERE + DOTO HERE)
col(, HERE ! /N ALLOT)
col(C, HERE C! /C ALLOT)
col(W, HERE W! /W ALLOT)
col(L, HERE L! /L ALLOT)
col(ALIGN HERE /N 1- AND 0BRANCH(4) 0 C, BRANCH(-10))
col(PLACE 2DUP C! CHAR+ SWAP CHARS BOUNDS DO?DO(9) DUP C@ I C! CHAR+ 1 CHARS DO+LOOP(-9) DROP)
col(STRING, HERE OVER 1+ CHARS ALLOT PLACE)


// Every language needs a no-op.
col(NOOP)


// Now it gets ugly: search-order and word-lisst infrastructure.


// LASTWORD must be the last thing in our dictionary!
extern cell xt_LASTWORD[];

raw(FORTH-WORDLIST DODOES _A(xt_NOOP+3) _A(0) _A(xt_LASTWORD))
	// +4 for 32-bit, +3 for 64-bit

raw(CURRENT DOVAL _A(xt_FORTH_X2d_WORDLIST+5))
	// +7 for 32-bit, +5 for 64-bit

col(LAST CURRENT CELL+)

raw(SEARCH-ORDER DOVAR _A(xt_FORTH_X2d_WORDLIST+5) _A(0) _A(0) _A(0) _A(0) _A(0) _A(0) _A(0) _A(0) _A(0) _A(0) _A(0) _A(0) _A(0) _A(0) _A(0))
	// +7 for 32-bit, +5 for 64-bit
raw(CONTEXT DOVAL _A(xt_SEARCH_X2d_ORDER+4))
	// +6 for 32-bit, +4 for 64-bit


// Dictionary structure.
col(LINK>NAME CELL+)
col(NAME> CHAR+ DUP C@ 1+ CHARS+ ALIGNED)
col(LINK> LINK>NAME NAME>)
col(NAME>STRING CHAR+ COUNT)

// Creating word headers.
var(LATEST 0)
dfr((REVEAL))
col(HEADER ALIGN HERE LAST @ , LATEST ! 0 C, STRING, ALIGN)
col(REVEAL   LATEST @ LINK>NAME NAME>STRING (REVEAL) LATEST @ LAST !)

// Finding words.
col(STRING=CI >R SWAP DUP R> <> 0BRANCH(3) 3DROP FALSE EXIT CHARS BOUNDS DO?DO(18) DUP C@ UPC I C@ UPC <> 0BRANCH(4) DROP UNLOOP FALSE EXIT CHAR+ 1 CHARS DO+LOOP(-18) DROP TRUE)
// (find) ( str len head -- 0 | link )
dfr((FIND))
col(((FIND)) DUP 0BRANCH(15) >R 2DUP R@ LINK>NAME NAME>STRING STRING=CI 0BRANCH(3) 2DROP R> EXIT R> @ BRANCH(-18) 3DROP FALSE)
col((FIND-ORDER) CONTEXT DUP >R SEARCH-ORDER U>= 0BRANCH(18) 2DUP R@ @ CELL+ @ (FIND) ?DUP 0BRANCH(5) NIP NIP R> DROP EXIT R> CELL- BRANCH(-24) R> 3DROP 0)
col($FIND (FIND-ORDER) DUP 0BRANCH(6) LINK>NAME DUP NAME> SWAP C@ TRUE)

// Flags on words.
con('IMMEDIATE 1)
col(IMMEDIATE? 'IMMEDIATE AND 0<>)
col(IMMEDIATE LAST @ CELL+ DUP C@ 'IMMEDIATE OR SWAP C!)

// Utility -- list all words in compilation wordlist.
col(WORDS LAST @ ?DUP 0BRANCH(9) DUP CELL+ CHAR+ COUNT TYPE SPACE @ BRANCH(-12))

// Parsing.
col(FINDCHAR SWAP 0 DO?DO(24) OVER I + C@ OVER DUP BL = 0BRANCH(3) <= BRANCH(1) = 0BRANCH(6) I UNLOOP NIP NIP TRUE EXIT DOLOOP(-24) DROP DROP FALSE)
col(PARSE >R IB >IN @ + SPAN @ >IN @ - 2DUP R> FINDCHAR 0BRANCH(6) NIP DUP 1 + BRANCH(1) DUP >IN +!)
col(SKIPWS IB SPAN @ DUP >IN @ > 0BRANCH(14) OVER >IN @ + C@ BL <= 0BRANCH(5) 1 >IN +! BRANCH(-20) DROP DROP)
col(PARSE-WORD SKIPWS BL PARSE)
var(WHICHPOCKET 0)
col(POCKET LIT(POCKETSIZE) WHICHPOCKET @ * POCKETS + 1 WHICHPOCKET @ - WHICHPOCKET !)
col(WORD POCKET >R PARSE DUP R@ C! BOUNDS R> DUP 2SWAP DO?DO(7) CHAR+ I C@ OVER C! DOLOOP(-7) DROP)

// Some simple parsing words.
col(CHAR PARSE-WORD DROP C@)
imm(( LIT(')') PARSE 2DROP)
imm(\ LINEFEED PARSE 2DROP)

// The compiler infrastructure.
var(STATE 0)
imm([ STATE OFF)
col(] STATE ON)
col(COMPILE, ,)
col(: PARSE-WORD HEADER DOTICK DOCOL COMPILE, ])
col(:NONAME ALIGN HERE DOTICK DOCOL COMPILE, ])
imm(; DOTICK EXIT COMPILE, REVEAL [)

// Compiling strings.
imm(C" LIT('"') PARSE DOTICK SLITERAL COMPILE, DUP C, BOUNDS DO?DO(5) I C@ C, DOLOOP(-5) ALIGN)
imm(S" STATE @ 0BRANCH(5) C" DOTICK COUNT COMPILE, EXIT LIT('"') PARSE DUP >R POCKET DUP >R SWAP MOVE R> R>)
imm(." S" DOTICK TYPE COMPILE,)
imm(.( LIT(')') PARSE TYPE)

// Structure words.
col(RESOLVE-ORIG HERE OVER CELL+ - SWAP !)
imm(AHEAD DOTICK DOBRANCH COMPILE, HERE 0 COMPILE,)
imm(IF DOTICK DO0BRANCH COMPILE, HERE 0 COMPILE,)
imm(THEN RESOLVE-ORIG)
imm(ELSE DOTICK DOBRANCH COMPILE, HERE 0 COMPILE, SWAP RESOLVE-ORIG)
imm(CASE 0)
imm(ENDCASE DOTICK DROP COMPILE, ?DUP 0BRANCH(5) 1- SWAP THEN BRANCH(-8))
imm(OF 1+ >R DOTICK OVER COMPILE, DOTICK = COMPILE, IF DOTICK DROP COMPILE, R>)
imm(ENDOF >R ELSE R>)
col(RESOLVE-DEST HERE CELL+ - COMPILE,)
imm(BEGIN HERE)
imm(AGAIN DOTICK DOBRANCH COMPILE, RESOLVE-DEST)
imm(UNTIL DOTICK DO0BRANCH COMPILE, RESOLVE-DEST)
imm(WHILE IF SWAP)
imm(REPEAT AGAIN THEN)

// Counted loops.
var(LEAVES 0)
col(RESOLVE-LOOP LEAVES @ ?DUP 0BRANCH(10) DUP @ SWAP HERE OVER - SWAP ! BRANCH(-13) HERE - COMPILE, LEAVES !)
imm(DO LEAVES @ HERE DOTICK DODO COMPILE, 0 LEAVES !)
imm(?DO LEAVES @ DOTICK DODO?DO COMPILE, HERE HERE LEAVES ! 0 COMPILE,)
imm(LOOP DOTICK DODOLOOP COMPILE, RESOLVE-LOOP)
imm(+LOOP DOTICK DODO+LOOP COMPILE, RESOLVE-LOOP)
imm(LEAVE DOTICK DODOLEAVE COMPILE, LEAVES @ HERE LEAVES ! COMPILE,)
imm(?LEAVE DOTICK DODO?LEAVE COMPILE, LEAVES @ HERE LEAVES ! COMPILE,)

// Interpreter nesting.
col(SAVE-SOURCE R> IB >R #IB @ >R SOURCE-ID >R SPAN @ >R >IN @ >R >R)
col(RESTORE-SOURCE R> R> >IN ! R> SPAN ! R> DOTO SOURCE-ID R> #IB ! R> DOTO IB >R)

// System replies.
str(OK-STR "ok")
str(ABORTED-STR "Aborted")
str(EXCEPTION-STR "Exception #")
col(PRINT-STATUS SPACE DUP 0= 0BRANCH(4) DOTICK OK-STR BRANCH(7) DUP -1 = 0BRANCH(6) DOTICK ABORTED-STR COUNT TYPE BRANCH(10) DUP LIT(-2) = 0BRANCH(7) ABORT"-STR @ COUNT TYPE DROP BRANCH(5) DOTICK EXCEPTION-STR COUNT TYPE . CR)

// The compiler and interpreter.
col(COMPILE-WORD 2DUP $FIND 0BRANCH(10) IMMEDIATE? 0BRANCH(4) NIP NIP EXECUTE EXIT COMPILE, 2DROP EXIT 2DUP $NUMBER 0BRANCH(4) TYPE LIT(-99) THROW DOTICK DOLIT COMPILE, COMPILE, 2DROP)
col(INTERPRET-WORD 2DUP $FIND 0BRANCH(5) DROP NIP NIP EXECUTE EXIT 2DUP $NUMBER 0BRANCH(4) TYPE LIT(-99) THROW >R 2DROP R>)
col(INTERPRET 0 >IN ! PARSE-WORD DUP 0BRANCH(10) STATE @ 0BRANCH(3) COMPILE-WORD BRANCH(1) INTERPRET-WORD BRANCH(-14) 2DROP)

// Evaluate, the one word to rule them all.  It is evil, btw.
col(EVALUATE SAVE-SOURCE -1 DOTO SOURCE-ID DUP #IB ! SPAN ! DOTO IB INTERPRET RESTORE-SOURCE)
col(EVAL EVALUATE)

// Abort with a message.
col(DOABORT" SWAP 0BRANCH(5) ABORT"-STR ! LIT(-2) THROW DROP)
imm(ABORT" C" DOTICK DOABORT" COMPILE,)

// Tick.
str(UNDEFINED-STR "undefined word")
col(' PARSE-WORD $FIND 0= DOTICK UNDEFINED-STR DOABORT" DROP)

// The outer interpreter.
col(QUIT 0 RDEPTH! [ TERMINAL DEPTH . LIT('>') EMIT SPACE REFILL 0BRANCH(10) SPACE DOTICK INTERPRET CATCH DUP PRINT-STATUS 0BRANCH(-17) BRANCH(-23))

// Reading and writing to/from file; including files.
dfr(MAP-FILE)
dfr(UNMAP-FILE)
dfr(WRITE-FILE)
col(INCLUDED MAP-FILE 2DUP >R >R BOUNDS DO?DO(21) R> R@ SWAP >R R@ - R@ SWAP 2DUP LINEFEED FINDCHAR 0BRANCH(1) NIP DUP >R EVALUATE R> 1+ DO+LOOP(-21) R> R> UNMAP-FILE)
col(INCLUDE PARSE-WORD INCLUDED)

// CREATE ... DOES> ...
col($CREATE HEADER DOTICK DODOES COMPILE, DOTICK NOOP CELL+ COMPILE, REVEAL)
col(CREATE PARSE-WORD $CREATE)
col(DODOES> R> CELL+ LATEST @ LINK> CELL+ !)
imm(DOES> DOTICK DODOES> COMPILE,)

// Defining words.
col(CONSTANT PARSE-WORD HEADER DOTICK DOCON COMPILE, COMPILE, REVEAL)
col(VALUE PARSE-WORD HEADER DOTICK DOVAL COMPILE, COMPILE, REVEAL)
col(VARIABLE PARSE-WORD HEADER DOTICK DOVAR COMPILE, 0 COMPILE, REVEAL)
col(BUFFER: PARSE-WORD HEADER DOTICK DOBUFFER: COMPILE, ALLOT REVEAL)
col(DEFER PARSE-WORD HEADER DOTICK DODEFER COMPILE, DOTICK ABORT COMPILE, REVEAL)
col(ALIAS PARSE-WORD HEADER DOTICK DOALIAS COMPILE, ' COMPILE, REVEAL)
col(STRUCT 0)
col(FIELD PARSE-WORD HEADER DOTICK DOFIELD COMPILE, OVER , + REVEAL)

// Words with (mostly) non-standard compilation behaviour.
imm(LITERAL DOTICK DOLIT COMPILE, COMPILE,)
col(COMPILE R> CELL+ DUP @ COMPILE, >R)
imm([COMPILE] ' COMPILE,)
imm(POSTPONE PARSE-WORD $FIND 0= DOTICK UNDEFINED-STR DOABORT" IMMEDIATE? 0= 0BRANCH(6) DOTICK DOTICK COMPILE, COMPILE, DOTICK COMPILE, COMPILE,)
imm([CHAR] CHAR LITERAL)
imm(['] ' DOTICK DOTICK COMPILE, COMPILE,)

// FIND.
col(FIND DUP COUNT $FIND 0BRANCH(9) ROT DROP TRUE SWAP IMMEDIATE? 0BRANCH(1) NEGATE EXIT FALSE EXIT)

// Accessing data in CREATE'd words.
imm(TO ' STATE @ 0BRANCH(5) DOTICK DOTO COMPILE, COMPILE, EXIT CELL+ !)
col(BEHAVIOR CELL+ @)
col(>BODY 2 CELLS +)
col(BODY> 2 CELLS -)

// Making words recursive.
imm(RECURSIVE REVEAL)
imm(RECURSE LATEST @ LINK> COMPILE,)