forth.cpp

Tixys source code, include G.711, G.726, IMA-ADPCM etc.

	XT_TO_IN, XT_CELL_PLUS, XT_FETCH, XT_0_EQUALS,			// >IN CELL+ @ 0=
	XT_0BRANCH(3), (CELL)XT_REFILL_TIB, XT_EXIT,			// IF REFILL-TIB EXIT THEN
	XT_FALSE, XT_EXIT										// FALSE
	};


/** Definition of non standard forth word.<PRE>
: DO-QUIT   ( -- )  ( R:  i*x -- )
    EMPTYR
    0 >IN CELL+ !   \ set SOURCE-ID to 0
    POSTPONE [
    BEGIN
        REFILL
    WHILE
        INTERPRET
        STATE @ 0= IF ."  OK" THEN
        CR
    REPEAT
;
</PRE> */
static const CELL XT_DO_QUIT[] =
	{
	XT_FALSE, XT_TO_IN, XT_CELL_PLUS,						// 0 >IN CELL+
	XT_STORE, XT_LEFT_BRACKET,								// ! POSTPONE [
	(CELL)XT_REFILL, XT_0BRANCH(18), (CELL)XT_INTERPRET,	// BEGIN REFILL WHILE INTERPRET
	XT_STATE, XT_FETCH, XT_0_EQUALS, XT_0BRANCH(8),			// STATE @ 0= IF
	XT_SPACE, LIT('O'), XT_EMIT,							// ."  OK"
	LIT('K'), XT_EMIT, (CELL)XT_CR, 						// THEN CR
	XT_BRANCH(-18), XT_EXIT									// REPEAT
	};


static const CHAR AbortText[] = {'A','B','O','R','T'};
static const CHAR ExceptionText[] = {'E','x','c','e','p','t','i','o','n'};

/** Definition of ANS forth word. <PRE>
: EXCEPTION.   ( n -- n )
    DUP -1 =
    IF ." ABORT" EXIT THEN         // Print 'ABORT', and end
    DUP -2 =
    IF EXCEPTION-STRING 2@ TYPE EXIT THEN  // Print exception message, and end
    DUP -13 =
    IF
        EXCEPTION-STRING 2@ TYPE   // Print word name
        SPACE [CHAR] ? EMIT EXIT   // followed by " ?", then end
    THEN
    ." Exception" DUP .            // Print "Exception n", then end
;
</PRE> */
const CELL XT_EXCEPTION_DOT[] =
	{
	XT_DUP, XT_TRUE, XT_EQUALS, XT_0BRANCH(7),				// DUP -1 = IF 
	LIT(AbortText), LIT(5), XT_TYPE, XT_EXIT,				// ." ABORT" EXIT THEN

	XT_DUP, LIT(-2), XT_EQUALS, XT_0BRANCH(5),				// DUP -2 = IF 
	XT_EXCEPTION_MESSAGE, XT_2_FETCH, XT_TYPE, XT_EXIT,		// EXCEPTION-STRING 2@ TYPE EXIT

	XT_DUP, LIT(-13), XT_EQUALS, XT_0BRANCH(9),				// DUP -13 = IF 
	XT_EXCEPTION_MESSAGE, XT_2_FETCH, XT_TYPE, XT_SPACE,	// EXCEPTION-STRING 2@ TYPE SPACE
	LIT('?'), XT_EMIT, XT_EXIT,								// [CHAR] ? EMIT EXIT THEN

	LIT(ExceptionText), LIT(10), XT_TYPE,					// ." Exception"
	XT_DUP, (CELL)XT_DOT, XT_EXIT							// DUP .
	};


/** Definition of ANS forth word. <PRE>
: QUIT   ( i*x n -- )
	BEGIN
		EMPTYR  ['] DO-QUIT CATCH
		EXCEPTION. CR
	AGAIN
;
</PRE> */
const CELL XT_QUIT[] =
	{
	XT_EMPTYR, LIT(XT_DO_QUIT), XT_CATCH,					// BEGIN EMPTYR ['] DO-QUIT CATCH 
	(CELL)XT_EXCEPTION_DOT, (CELL)XT_CR,					// EXCEPTION. CR
	XT_EMPTYS, XT_BRANCH(-8)								// EMPTYS AGAIN
	};


// Macros for constructing word headers
#define IMMEDIATE 0x8000
#define TOKEN 0x4000
#define LINK(n) CELLS(((n)+!!((n)&TOKEN))&~(IMMEDIATE|TOKEN))
#define FLAGS(f) ((((f)&IMMEDIATE)?WordHeader::Immediate:0)|(((f)&TOKEN)?WordHeader::Token:0)|WordHeader::Valid)

#define PREPEND_CHAR(x,c) ((((CELL)x)<<BITS_PER_CHAR)+((CELL)c))
#ifdef LITTLE_ENDIAN
#define C4(a,b,c,d) ((CELL)PREPEND_CHAR(PREPEND_CHAR(PREPEND_CHAR(d,c),b),a))
#define C8(a,b,c,d,e,f,g,h) ((C4(e,f,g,h)<<(BITS_PER_CHAR*4))+C4(a,b,c,d))
#endif
#ifdef BIG_ENDIAN
#define C4(a,b,c,d) ((CELL)PREPEND_CHAR(PREPEND_CHAR(PREPEND_CHAR(a,b),c),d))
#define C8(a,b,c,d,e,f,g,h) ((C4(a,b,c,d)<<(BITS_PER_CHAR*4))+C4(e,f,g,h))
#endif

#if CHARS_PER_CELL==8

#define H1(a,args)				LINK(2+(args)),C8(FLAGS(args)+1,a,0,0,0,0,0,0)
#define H2(a,b,args)			LINK(2+(args)),C8(FLAGS(args)+2,a,b,0,0,0,0,0)
#define H3(a,b,c,args)			LINK(2+(args)),C8(FLAGS(args)+3,a,b,c,0,0,0,0)
#define H4(a,b,c,d,args)		LINK(2+(args)),C8(FLAGS(args)+4,a,b,c,d,0,0,0)
#define H5(a,b,c,d,e,args)		LINK(2+(args)),C8(FLAGS(args)+5,a,b,c,d,e,0,0)
#define H6(a,b,c,d,e,f,args)	LINK(2+(args)),C8(FLAGS(args)+6,a,b,c,d,e,f,0)
#define H7(a,b,c,d,e,f,g,args)	LINK(2+(args)),C8(FLAGS(args)+7,a,b,c,d,e,f,g)
#define H8(a,b,c,d,e,f,g,h,args)				LINK(3+(args)),C8(FLAGS(args)+8,a,b,c,d,e,f,g),C8(h,0,0,0,0,0,0,0)
#define H9(a,b,c,d,e,f,g,h,i,args)				LINK(3+(args)),C8(FLAGS(args)+9,a,b,c,d,e,f,g),C8(h,i,0,0,0,0,0,0)
#define H10(a,b,c,d,e,f,g,h,i,j,args)			LINK(3+(args)),C8(FLAGS(args)+10,a,b,c,d,e,f,g),C8(h,i,j,0,0,0,0,0)
#define H11(a,b,c,d,e,f,g,h,i,j,k,args)			LINK(3+(args)),C8(FLAGS(args)+11,a,b,c,d,e,f,g),C8(h,i,j,k,0,0,0,0)
#define H12(a,b,c,d,e,f,g,h,i,j,k,l,args)		LINK(3+(args)),C8(FLAGS(args)+12,a,b,c,d,e,f,g),C8(h,i,j,k,l,0,0,0)
#define H13(a,b,c,d,e,f,g,h,i,j,k,l,m,args)		LINK(3+(args)),C8(FLAGS(args)+13,a,b,c,d,e,f,g),C8(h,i,j,k,l,m,0,0)
#define H14(a,b,c,d,e,f,g,h,i,j,k,l,m,n,args)	LINK(3+(args)),C8(FLAGS(args)+14,a,b,c,d,e,f,g),C8(h,i,j,k,l,m,n,0)
#define H15(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,args)	LINK(3+(args)),C8(FLAGS(args)+15,a,b,c,d,e,f,g),C8(h,i,j,k,l,m,n,o)
#define H16(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,args)		LINK(4+(args)),C8(FLAGS(args)+16,a,b,c,d,e,f,g),C8(h,i,j,k,l,m,n,o),C8(p,0,0,0,0,0,0,0)
#define H17(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,args)		LINK(4+(args)),C8(FLAGS(args)+17,a,b,c,d,e,f,g),C8(h,i,j,k,l,m,n,o),C8(p,q,0,0,0,0,0,0)
#define H18(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,args)	LINK(4+(args)),C8(FLAGS(args)+18,a,b,c,d,e,f,g),C8(h,i,j,k,l,m,n,o),C8(p,q,r,0,0,0,0,0)

#elif CHARS_PER_CELL==4

#define H1(a,args)		LINK(2+(args)),C4(FLAGS(args)+1,a,0,0)
#define H2(a,b,args)	LINK(2+(args)),C4(FLAGS(args)+2,a,b,0)
#define H3(a,b,c,args)	LINK(2+(args)),C4(FLAGS(args)+3,a,b,c)
#define H4(a,b,c,d,args)		LINK(3+(args)),C4(FLAGS(args)+4,a,b,c),C4(d,0,0,0)
#define H5(a,b,c,d,e,args)		LINK(3+(args)),C4(FLAGS(args)+5,a,b,c),C4(d,e,0,0)
#define H6(a,b,c,d,e,f,args)	LINK(3+(args)),C4(FLAGS(args)+6,a,b,c),C4(d,e,f,0)
#define H7(a,b,c,d,e,f,g,args)	LINK(3+(args)),C4(FLAGS(args)+7,a,b,c),C4(d,e,f,g)
#define H8(a,b,c,d,e,f,g,h,args)		LINK(4+(args)),C4(FLAGS(args)+8,a,b,c),C4(d,e,f,g),C4(h,0,0,0)
#define H9(a,b,c,d,e,f,g,h,i,args)		LINK(4+(args)),C4(FLAGS(args)+9,a,b,c),C4(d,e,f,g),C4(h,i,0,0)
#define H10(a,b,c,d,e,f,g,h,i,j,args)	LINK(4+(args)),C4(FLAGS(args)+10,a,b,c),C4(d,e,f,g),C4(h,i,j,0)
#define H11(a,b,c,d,e,f,g,h,i,j,k,args)	LINK(4+(args)),C4(FLAGS(args)+11,a,b,c),C4(d,e,f,g),C4(h,i,j,k)
#define H12(a,b,c,d,e,f,g,h,i,j,k,l,args)		LINK(5+(args)),C4(FLAGS(args)+12,a,b,c),C4(d,e,f,g),C4(h,i,j,k),C4(l,0,0,0)
#define H13(a,b,c,d,e,f,g,h,i,j,k,l,m,args)		LINK(5+(args)),C4(FLAGS(args)+13,a,b,c),C4(d,e,f,g),C4(h,i,j,k),C4(l,m,0,0)
#define H14(a,b,c,d,e,f,g,h,i,j,k,l,m,n,args)	LINK(5+(args)),C4(FLAGS(args)+14,a,b,c),C4(d,e,f,g),C4(h,i,j,k),C4(l,m,n,0)
#define H15(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,args)	LINK(5+(args)),C4(FLAGS(args)+15,a,b,c),C4(d,e,f,g),C4(h,i,j,k),C4(l,m,n,o)
#define H16(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,args)		LINK(6+(args)),C4(FLAGS(args)+16,a,b,c),C4(d,e,f,g),C4(h,i,j,k),C4(l,m,n,o),C4(p,0,0,0)
#define H17(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,args)		LINK(6+(args)),C4(FLAGS(args)+17,a,b,c),C4(d,e,f,g),C4(h,i,j,k),C4(l,m,n,o),C4(p,q,0,0)
#define H18(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,args)	LINK(6+(args)),C4(FLAGS(args)+18,a,b,c),C4(d,e,f,g),C4(h,i,j,k),C4(l,m,n,o),C4(p,q,r,0)

#else

#error CHARS_PER_CELL value not supported

#endif

/**
Initial contents for FORTH dictionary
*/
static const CELL ForthDictionary[] =
	{
	H1('!',TOKEN), XT_STORE,
	H1('#',TOKEN), XT_NUMBER_SIGN,
	H2('#','>',TOKEN), XT_NUMBER_SIGN_GREATER,
	H2('#','S',TOKEN), (CELL)XT_NUMBER_SIGN_S,
	H1('\'',TOKEN), (CELL)XT_TICK,
	H1('(',IMMEDIATE|5), LIT(')'),							// : (   ( "ccc<paren>" -- )
		XT_PARSE, XT_2DROP, XT_EXIT,						//   [CHAR] ) PARSE 2DROP ; IMMEDIATE
	H1('*',TOKEN), XT_STAR,
	H2('*','/',3),											// : * /   ( n1 n2 n3 -- n4 )
		(CELL)XT_STAR_SLASH_MOD, XT_NIP, XT_EXIT,			//   */MOD NIP ;
	H5('*','/','M','O','D',TOKEN), (CELL)XT_STAR_SLASH_MOD,
	H1('+',TOKEN), XT_PLUS,
	H2('+','!',TOKEN), XT_PLUS_STORE,
	H5('+','L','O','O','P',IMMEDIATE|5),					// : +LOOP   ( C: do-sys -- )
		LIT(XT_PAREN_PLUS_LOOP),							//   ['] (+loop)
		(CELL)XT_BACKWARD_BRANCH_COMMA, (CELL)XT_THEN,		//   <BRANCH, POSTPONE THEN
		XT_EXIT,											//   ; IMMEDIATE
	H1(',',TOKEN), XT_COMMA,
	H1('-',TOKEN), XT_MINUS,
	H1('.',TOKEN), (CELL)XT_DOT,
	H2('.','"',IMMEDIATE|5),								// : ."   ( "ccc<quote>" -- )
		(CELL)XT_S_QUOTE, LIT(XT_TYPE), XT_COMMA, XT_EXIT,	//   POSTPONE S" POSTPONE TYPE ; IMMEDIATE
	H1('/',3),												// : /   ( n1 n2 -- n3 )
		(CELL)XT_SLASH_MOD, XT_NIP, XT_EXIT,				//   /MOD NIP ;
	H4('/','M','O','D',TOKEN), (CELL)XT_SLASH_MOD,
	H2('0','<',TOKEN), XT_0_LESS,
	H2('0','=',TOKEN), XT_0_EQUALS,
	H2('1','+',TOKEN), XT_1_PLUS,
	H2('1','-',TOKEN), XT_1_MINUS,
	H2('2','!',TOKEN), XT_2_STORE,
	H2('2','*',TOKEN), XT_2_STAR,
	H2('2','/',TOKEN), XT_2_SLASH,
	H2('2','@',TOKEN), XT_2_FETCH,
	H5('2','D','R','O','P',TOKEN), XT_2DROP,
	H4('2','D','U','P',TOKEN), XT_2DUP,
	H5('2','O','V','E','R',TOKEN), XT_2OVER,
	H5('2','S','W','A','P',TOKEN), XT_2SWAP,
	H1(':',7),												// : :   ( C: "<spaces>name" -- colon-sys )
		XT_PARSE_WORD, (CELL)XT_CREATE_WORD,				//   PARSE-WORD CREATE-WORD
		XT_FALSE, LIT(ColonMagic), XT_RIGHT_BRACKET,		//   0 COLON-MAGIC ]
		XT_EXIT,
	H1(';',IMMEDIATE|14),									// : ;   ( C: colon-sys -- )
		XT_LEFT_BRACKET,									//   [
		LIT(ColonMagic), (CELL)XT_NEST_CHECK,				//   COLON-MAGIC NEST-CHECK
		LIT(XT_EXIT), XT_COMMA, XT_DUP, XT_0_EQUALS, 		//   ['] EXIT , DUP 0=
		XT_0BRANCH(2), XT_DROP, (CELL)XT_VALIDATE, XT_EXIT,	//   IF DROP VALIDATE THEN ; IMMEDIATE
	H1('<',TOKEN), XT_LESS_THAN,
	H2('<','#',TOKEN), XT_LESS_NUMBER_SIGN,
	H1('=',TOKEN), XT_EQUALS,
	H1('>',TOKEN), XT_GREATER_THAN,
	H5('>','B','O','D','Y',TOKEN), XT_CELL_PLUS,
	H3('>','I','N',TOKEN), XT_TO_IN,
	H7('>','N','U','M','B','E','R',TOKEN), XT_TO_NUMBER,
	H2('>','R',TOKEN), XT_TO_R,
	H4('?','D','U','P',TOKEN), XT_QUESTION_DUP,
	H1('@',TOKEN), XT_FETCH,
	H5('A','B','O','R','T',2), XT_TRUE, XT_THROW,			// : ABORT -1 THROW ;
	H6('A','B','O','R','T','"',IMMEDIATE|10),				// : ABORT"   ( "ccc<quote>" -- )
		(CELL)XT_IF, (CELL)XT_S_QUOTE,						//   POSTPONE IF POSTPONE S"
		LIT(-2), (CELL)XT_LITERAL,							//   -2 POSTPONE LITERAL
		LIT(XT_THROW_QUOTE), XT_COMMA,						//   POSTPONE THROW-QUOTE
		(CELL)XT_THEN, XT_EXIT,								//   POSTPONE THEN ; IMMEDIATE
	H3('A','B','S',TOKEN), XT_ABS,
	H6('A','C','C','E','P','T',TOKEN), XT_ACCEPT,
	H5('A','L','I','G','N',TOKEN), XT_ALIGN,
	H7('A','L','I','G','N','E','D',TOKEN), XT_ALIGNED,
	H5('A','L','L','O','T',TOKEN), XT_ALLOT,
	H3('A','N','D',TOKEN), XT_AND,
	H4('B','A','S','E',TOKEN), XT_BASE,
	H5('B','E','G','I','N',IMMEDIATE|TOKEN), (CELL)XT_BEGIN,
	H2('B','L',2),											// 32 CONSTANT BL
		XT_PAREN_CONSTANT, 32,
	H2('C','!',TOKEN), XT_C_STORE,
	H2('C',',',TOKEN), XT_C_COMMA,
	H2('C','@',TOKEN), XT_C_FETCH,
	H5('C','E','L','L','+',TOKEN), XT_CELL_PLUS,
	H5('C','E','L','L','S',TOKEN), XT_CELLS,
	H4('C','H','A','R',TOKEN), (CELL)XT_CHAR,
	H5('C','H','A','R','+',TOKEN), XT_CHAR_PLUS,
	H5('C','H','A','R','S',TOKEN), XT_CHARS,
	H8('C','O','N','S','T','A','N','T',8),					// : CONSTANT   ( x "<spaces>name" -- )
		XT_PARSE_WORD, (CELL)XT_CREATE_WORD,				//   PARSE-WORD CREATE-WORD
		LIT(XT_PAREN_CONSTANT), XT_COMMA, XT_COMMA,			//   POSTPONE (constant) ,
		(CELL)XT_VALIDATE, XT_EXIT,							//   VALIDATE ;
	H5('C','O','U','N','T',TOKEN), XT_COUNT,
	H2('C','R',TOKEN), (CELL)XT_CR,
	H6('C','R','E','A','T','E',TOKEN), (CELL)XT_CREATE,
	H7('D','E','C','I','M','A','L',5),						// : DECIMAL   ( -- )
		LIT(10), XT_BASE, XT_STORE, XT_EXIT,				//   10 BASE ! ;
	H5('D','E','P','T','H',TOKEN), XT_DEPTH,
	H2('D','O',IMMEDIATE|5),								// : DO   ( C: -- do-sys )
		LIT(XT_PAREN_DO), (CELL)XT_FORWARD_BRANCH_COMMA,	//   ['] (do) >BRANCH,
		(CELL)XT_BEGIN, XT_EXIT,							//   POSTPONE BEGIN ; IMMEDIATE
	H5('D','O','E','S','>',IMMEDIATE|7),					// : DOES>   ( C: colon-sys1 -- colon-sys2 )
		LIT(XT_PAREN_DOES), XT_COMMA,						//   POSTPONE (does) 
		LIT(XT_R_FROM), XT_COMMA, XT_EXIT,					//   POSTPONE R> ;
	H4('D','R','O','P',TOKEN), XT_DROP,
	H3('D','U','P',TOKEN), XT_DUP,
	H4('E','L','S','E',IMMEDIATE|4),						// : ELSE   ( C: orig1 -- orig2 )
		(CELL)XT_AHEAD, XT_2SWAP, (CELL)XT_THEN, XT_EXIT,	//   POSTPONE AHEAD 2SWAP POSTPONE THEN ; IMMEDIATE
	H4('E','M','I','T',TOKEN), XT_EMIT,
	H12('E','N','V','I','R','O','N','M','E','N','T','?',13),// : ENVIRONMENT?   ( c-addr u -- false | i*x true )
		XT_FORTH_WORDLIST, XT_CELL_PLUS, XT_FETCH,			//   ENVIRONMENT-WORDLIST
		XT_PAREN_SEARCH_WORDLIST, XT_NIP, 					//   (search-wordlist) NIP
		XT_0BRANCH(4), XT_EXECUTE, XT_TRUE, XT_EXIT,		//   IF EXECUTE TRUE EXIT THEN
		XT_DROP, XT_FALSE, XT_EXIT,							//   DROP FALSE ;
	H8('E','V','A','L','U','A','T','E',TOKEN), (CELL)XT_EVALUATE,
	H7('E','X','E','C','U','T','E',TOKEN), XT_EXECUTE,
	H4('E','X','I','T',TOKEN), XT_EXIT,
	H4('F','I','L','L',TOKEN), XT_FILL,
	H4('F','I','N','D',17),									// : FIND   ( c-addr -- c-addr 0  |  xt 1  |  xt -1 )
		XT_COUNT, (CELL)XT_PAREN_FIND, XT_0BRANCH(8),		//   COUNT (find) IF 
		XT_0BRANCH(4), LIT(1), XT_EXIT, XT_TRUE, XT_EXIT,	//   IF 1 EXIT THEN -1 EXIT 
		XT_DROP, LIT(CHARS(1)), XT_MINUS, XT_FALSE, XT_EXIT,//   THEN DROP 1 CHARS - 0 THEN ;
	H6('F','M','/','M','O','D',TOKEN), (CELL)XT_FM_SLASH_MOD,
	H4('H','E','R','E',TOKEN), XT_HERE,
	H4('H','O','L','D',TOKEN), XT_HOLD,
	H1('I',TOKEN), XT_I,
	H2('I','F',IMMEDIATE|TOKEN), (CELL)XT_IF,
	H9('I','M','M','E','D','I','A','T','E',4),				// : IMMEDIATE   ( -- )
		LIT(WordHeader::Immediate), (CELL)(XT_VALIDATE+2),	//   1 SET-WORD-FLAG ;
		XT_EXIT,
	H6('I','N','V','E','R','T',TOKEN), XT_INVERT,
	H1('J',TOKEN), XT_J,
	H3('K','E','Y',TOKEN), XT_KEY,
	H5('L','E','A','V','E',TOKEN), XT_LEAVE,
	H7('L','I','T','E','R','A','L',IMMEDIATE|TOKEN), (CELL)XT_LITERAL,
	H4('L','O','O','P',IMMEDIATE|5),						// : LOOP   ( C: do-sys -- )
		LIT(XT_PAREN_LOOP), (CELL)XT_BACKWARD_BRANCH_COMMA,	//   ['] (loop) <BRANCH,
		(CELL)XT_THEN, XT_EXIT,								//   POSTPONE THEN ; IMMEDIATE
	H6('L','S','H','I','F','T',TOKEN), XT_LSHIFT,
	H2('M','*',TOKEN), (CELL)XT_M_STAR,
	H3('M','A','X',TOKEN), XT_MAX,
	H3('M','I','N',TOKEN), XT_MIN,
	H3('M','O','D',3),										// : MOD   ( n1 n2 -- n3 )
		(CELL)XT_SLASH_MOD, XT_DROP, XT_EXIT,				//   /MOD DROP ;
	H4('M','O','V','E',TOKEN), XT_MOVE,
	H6('N','E','G','A','T','E',TOKEN), XT_NEGATE,
	H2('O','R',TOKEN), XT_OR,
	H4('O','V','E','R',TOKEN), XT_OVER,
	H8('P','O','S','T','P','O','N','E',IMMEDIATE|10),		// : POSTPONE   ( "<spaces>name" -- )
		(CELL)XT_PAREN_TICK,								//   (')
		XT_0BRANCH(3), XT_COMMA, XT_EXIT,					//   IF , EXIT THEN
		(CELL)XT_LITERAL, LIT(XT_COMMA), XT_COMMA, XT_EXIT,	//   POSTPONE LITERAL POSTPONE , ; IMMEDIATE
	H4('Q','U','I','T',TOKEN), (CELL)XT_QUIT,
	H2('R','>',TOKEN), XT_R_FROM,
	H2('R','@',TOKEN), XT_R_FETCH,
	H7('R','E','C','U','R','S','E',IMMEDIATE|5),			// : RECURSE   ( -- )
		XT_LATEST, XT_FETCH, XT_TO_CFA, XT_COMMA, XT_EXIT,	//   LATEST @ >CFA , ;
	H6('R','E','P','E','A','T',IMMEDIATE|3),				// : REPEAT   ( C: orig dest -- )
		(CELL)XT_AGAIN, (CELL)XT_THEN, XT_EXIT,				//   POSTPONE AGAIN POSTPONE THEN ; IMMEDIATE
	H3('R','O','T',TOKEN), XT_ROT,
	H6('R','S','H','I','F','T',TOKEN), XT_RSHIFT,
	H2('S','"',IMMEDIATE|TOKEN), (CELL)XT_S_QUOTE,
	H3('S','>','D',TOKEN), XT_S_TO_D,
	H4('S','I','G','N',TOKEN), XT_SIGN,
	H6('S','M','/','R','E','M',TOKEN), (CELL)XT_SM_SLASH_REM,
	H6('S','O','U','R','C','E',3),							// : SOURCE   ( -- c-addr u )
		XT_PAREN_SOURCE, XT_2_FETCH, XT_EXIT,				//   (source) 2@ ;
	H5('S','P','A','C','E',TOKEN), XT_SPACE,
	H6('S','P','A','C','E','S',10),							// : SPACES   ( n -- )
		XT_DUP, XT_0_GREATER, XT_0BRANCH(5),				//   BEGIN DUP 0> WHILE 
		XT_SPACE, XT_1_MINUS, XT_BRANCH(-7), XT_DROP,		//   SPACE 1- REPEAT DROP
		XT_EXIT,											//   ;
	H5('S','T','A','T','E',TOKEN), XT_STATE,
	H4('S','W','A','P',TOKEN), XT_SWAP,
	H4('T','H','E','N',IMMEDIATE|TOKEN), (CELL)XT_THEN,
	H4('T','Y','P','E',TOKEN), XT_TYPE,
	H2('U','.',3),											// : U.   ( u -- )
		XT_FALSE, (CELL)XT_D_DOT, XT_EXIT,					//   0 D. ;
	H2('U','<',TOKEN), XT_U_LESS_THAN,
	H3('U','M','*',TOKEN), XT_UM_STAR,
	H6('U','M','/','M','O','D',TOKEN), (CELL)XT_UM_SLASH_MOD,
	H6('U','N','L','O','O','P',TOKEN), XT_UNLOOP,
	H5('U','N','T','I','L',IMMEDIATE|4),					// : UNTIL   ( C: dest -- )
		LIT(XT_PAREN_0BRANCH),								//   ['] (0branch) 
		(CELL)XT_BACKWARD_BRANCH_COMMA,	XT_EXIT,			//   <BRANCH, ; IMMEDIATE
	H8('V','A','R','I','A','B','L','E',4),					// : VARIABLE   ( "<spaces>name" -- )
		(CELL)XT_CREATE, XT_FALSE, XT_COMMA, XT_EXIT,		//   CREATE 0 , ;
	H5('W','H','I','L','E',IMMEDIATE|3),					// : WHILE   ( C: dest -- orig dest )
		(CELL)XT_IF, XT_2SWAP, XT_EXIT,						//   POSTPONE IF 2SWAP ; IMMEDIATE
	H4('W','O','R','D',14),									// : WORD   ( char "<chars>ccc<char>" -- c-addr )
		XT_INVERT, XT_PARSE, LIT(SlashCountedString),		//   INVERT PARSE /COUNTED-STRING 
		XT_MIN, XT_DUP, XT_HERE, XT_C_STORE, XT_HERE,		//   MIN DUP HERE C! HERE 
		XT_CHAR_PLUS, XT_SWAP, XT_CMOVE, XT_HERE, XT_EXIT,	//   CHAR+ SWAP CMOVE HERE ;
	H3('X','O','R',TOKEN), XT_XOR,
	H1('[',IMMEDIATE|TOKEN), XT_LEFT_BRACKET,
	H3('[','\'',']',IMMEDIATE|3),							// : [']   ( "<spaces>name" -- )
		(CELL)XT_TICK, (CELL)XT_LITERAL, XT_EXIT,			//   ' POSTPONE LITERAL ; IMMEDIATE
	H6('[','C','H','A','R',']',IMMEDIATE|3),				// : [CHAR]   ( "<spaces>name" -- )
		(CELL)XT_CHAR, (CELL)XT_LITERAL, XT_EXIT,			//   CHAR POSTPONE LITERAL ; IMMEDIATE
	H1(']',TOKEN), XT_RIGHT_BRACKET,

	//
	// CORE EXT
	//

	H3('0','<','>',TOKEN), XT_0_NOT_EQUALS,
	H2('0','>',TOKEN), XT_0_GREATER,
	H3('2','>','R',TOKEN), XT_2_TO_R,
	H3('2','R','>',TOKEN), XT_2_R_FROM,
	H3('2','R','@',TOKEN), XT_2_R_FETCH,
	H7(':','N','O','N','A','M','E',8),						// : :NONAME   ( C:  -- colon-sys )  ( S:  -- xt )
		XT_FALSE, XT_FALSE, (CELL)XT_CREATE_WORD,			//   0 0 CREATE-WORD 
		XT_HERE, LIT(ColonMagic), XT_RIGHT_BRACKET,		//   HERE COLON-MAGIC ] ;
		XT_EXIT,
	H2('<','>',TOKEN), XT_NOT_EQUALS,
	H3('?','D','O',IMMEDIATE|5),							// : ?DO   ( C: -- do-sys )
		LIT(XT_PAREN_QUESTION_DO),							//   ['] (?do)
		(CELL)XT_FORWARD_BRANCH_COMMA, (CELL)XT_BEGIN,		//   >BRANCH, POSTPONE BEGIN
		XT_EXIT,											// ; IMMEDIATE
	H5('A','G','A','I','N',IMMEDIATE|TOKEN), (CELL)XT_AGAIN,