xref: /illumos-gate/usr/src/common/ficl/primitives.c (revision 495ee6847d0d3e288f47ba026d98a830e51cbc06)

/*
 * w o r d s . c
 * Forth Inspired Command Language
 * ANS Forth CORE word-set written in C
 * Author: John Sadler (john_sadler@alum.mit.edu)
 * Created: 19 July 1997
 * $Id: primitives.c,v 1.4 2010/09/13 18:43:04 asau Exp $
 */
/*
 * Copyright (c) 1997-2001 John Sadler (john_sadler@alum.mit.edu)
 * All rights reserved.
 *
 * Get the latest Ficl release at http://ficl.sourceforge.net
 *
 * I am interested in hearing from anyone who uses Ficl. If you have
 * a problem, a success story, a defect, an enhancement request, or
 * if you would like to contribute to the Ficl release, please
 * contact me by email at the address above.
 *
 * L I C E N S E  and  D I S C L A I M E R
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

#include "ficl.h"
#include <limits.h>

/*
 * Control structure building words use these
 * strings' addresses as markers on the stack to
 * check for structure completion.
 */
static char doTag[]    = "do";
static char colonTag[] = "colon";
static char leaveTag[] = "leave";

static char destTag[]  = "target";
static char origTag[]  = "origin";

static char caseTag[]  = "case";
static char ofTag[]  = "of";
static char fallthroughTag[]  = "fallthrough";

/*
 * C O N T R O L   S T R U C T U R E   B U I L D E R S
 *
 * Push current dictionary location for later branch resolution.
 * The location may be either a branch target or a patch address...
 */
static void
markBranch(ficlDictionary *dictionary, ficlVm *vm, char *tag)
{
	ficlStackPushPointer(vm->dataStack, dictionary->here);
	ficlStackPushPointer(vm->dataStack, tag);
}

static void
markControlTag(ficlVm *vm, char *tag)
{
	ficlStackPushPointer(vm->dataStack, tag);
}

static void
matchControlTag(ficlVm *vm, char *wantTag)
{
	char *tag;

	FICL_STACK_CHECK(vm->dataStack, 1, 0);

	tag = (char *)ficlStackPopPointer(vm->dataStack);

	/*
	 * Changed the code below to compare the pointers first
	 * (by popular demand)
	 */
	if ((tag != wantTag) && strcmp(tag, wantTag)) {
		ficlVmThrowError(vm,
		    "Error -- unmatched control structure \"%s\"", wantTag);
	}
}

/*
 * Expect a branch target address on the param stack,
 * FICL_VM_STATE_COMPILE a literal offset from the current dictionary location
 * to the target address
 */
static void
resolveBackBranch(ficlDictionary *dictionary, ficlVm *vm, char *tag)
{
	ficlCell *patchAddr, c;

	matchControlTag(vm, tag);

	FICL_STACK_CHECK(vm->dataStack, 1, 0);

	patchAddr = (ficlCell *)ficlStackPopPointer(vm->dataStack);
	c.i = patchAddr - dictionary->here;

	ficlDictionaryAppendCell(dictionary, c);
}

/*
 * Expect a branch patch address on the param stack,
 * FICL_VM_STATE_COMPILE a literal offset from the patch location
 * to the current dictionary location
 */
static void
resolveForwardBranch(ficlDictionary *dictionary, ficlVm *vm, char *tag)
{
	ficlInteger offset;
	ficlCell *patchAddr;

	matchControlTag(vm, tag);

	FICL_STACK_CHECK(vm->dataStack, 1, 0);

	patchAddr = (ficlCell *)ficlStackPopPointer(vm->dataStack);
	offset = dictionary->here - patchAddr;
	(*patchAddr).i = offset;
}

/*
 * Match the tag to the top of the stack. If success,
 * sopy "here" address into the ficlCell whose address is next
 * on the stack. Used by do..leave..loop.
 */
static void
resolveAbsBranch(ficlDictionary *dictionary, ficlVm *vm, char *wantTag)
{
	ficlCell *patchAddr;
	char *tag;

	FICL_STACK_CHECK(vm->dataStack, 2, 0);

	tag = ficlStackPopPointer(vm->dataStack);

	/*
	 * Changed the comparison below to compare the pointers first
	 * (by popular demand)
	 */
	if ((tag != wantTag) && strcmp(tag, wantTag)) {
		ficlVmTextOut(vm, "Warning -- Unmatched control word: ");
		ficlVmTextOut(vm, wantTag);
		ficlVmTextOut(vm, "\n");
	}

	patchAddr = (ficlCell *)ficlStackPopPointer(vm->dataStack);
	(*patchAddr).p = dictionary->here;
}

/*
 * c o l o n   d e f i n i t i o n s
 * Code to begin compiling a colon definition
 * This function sets the state to FICL_VM_STATE_COMPILE, then creates a
 * new word whose name is the next word in the input stream
 * and whose code is colonParen.
 */
static void
ficlPrimitiveColon(ficlVm *vm)
{
	ficlDictionary *dictionary = ficlVmGetDictionary(vm);
	ficlString name = ficlVmGetWord(vm);

	vm->state = FICL_VM_STATE_COMPILE;
	markControlTag(vm, colonTag);
	ficlDictionaryAppendWord(dictionary, name,
	    (ficlPrimitive)ficlInstructionColonParen,
	    FICL_WORD_DEFAULT | FICL_WORD_SMUDGED);

#if FICL_WANT_LOCALS
	vm->callback.system->localsCount = 0;
#endif
}

static void
ficlPrimitiveSemicolonCoIm(ficlVm *vm)
{
	ficlDictionary *dictionary = ficlVmGetDictionary(vm);

	matchControlTag(vm, colonTag);

#if FICL_WANT_LOCALS
	if (vm->callback.system->localsCount > 0) {
		ficlDictionary *locals;
		locals = ficlSystemGetLocals(vm->callback.system);
		ficlDictionaryEmpty(locals, locals->forthWordlist->size);
		ficlDictionaryAppendUnsigned(dictionary,
		    ficlInstructionUnlinkParen);
	}
	vm->callback.system->localsCount = 0;
#endif

	ficlDictionaryAppendUnsigned(dictionary, ficlInstructionSemiParen);
	vm->state = FICL_VM_STATE_INTERPRET;
	ficlDictionaryUnsmudge(dictionary);
}

/*
 * e x i t
 * CORE
 * This function simply pops the previous instruction
 * pointer and returns to the "next" loop. Used for exiting from within
 * a definition. Note that exitParen is identical to semiParen - they
 * are in two different functions so that "see" can correctly identify
 * the end of a colon definition, even if it uses "exit".
 */
static void
ficlPrimitiveExitCoIm(ficlVm *vm)
{
	ficlDictionary *dictionary = ficlVmGetDictionary(vm);
	FICL_IGNORE(vm);

#if FICL_WANT_LOCALS
	if (vm->callback.system->localsCount > 0) {
		ficlDictionaryAppendUnsigned(dictionary,
		    ficlInstructionUnlinkParen);
	}
#endif
	ficlDictionaryAppendUnsigned(dictionary, ficlInstructionExitParen);
}

/*
 * c o n s t a n t
 * IMMEDIATE
 * Compiles a constant into the dictionary. Constants return their
 * value when invoked. Expects a value on top of the parm stack.
 */
static void
ficlPrimitiveConstant(ficlVm *vm)
{
	ficlDictionary *dictionary = ficlVmGetDictionary(vm);
	ficlString name = ficlVmGetWord(vm);

	FICL_STACK_CHECK(vm->dataStack, 1, 0);

	ficlDictionaryAppendConstantInstruction(dictionary, name,
	    ficlInstructionConstantParen, ficlStackPopInteger(vm->dataStack));
}

static void
ficlPrimitive2Constant(ficlVm *vm)
{
	ficlDictionary *dictionary = ficlVmGetDictionary(vm);
	ficlString name = ficlVmGetWord(vm);

	FICL_STACK_CHECK(vm->dataStack, 2, 0);

	ficlDictionaryAppend2ConstantInstruction(dictionary, name,
	    ficlInstruction2ConstantParen, ficlStackPop2Integer(vm->dataStack));
}

/*
 * d i s p l a y C e l l
 * Drop and print the contents of the ficlCell at the top of the param
 * stack
 */
static void
ficlPrimitiveDot(ficlVm *vm)
{
	ficlCell c;

	FICL_STACK_CHECK(vm->dataStack, 1, 0);

	c = ficlStackPop(vm->dataStack);
	ficlLtoa((c).i, vm->pad, vm->base);
	strcat(vm->pad, " ");
	ficlVmTextOut(vm, vm->pad);
}

static void
ficlPrimitiveUDot(ficlVm *vm)
{
	ficlUnsigned u;

	FICL_STACK_CHECK(vm->dataStack, 1, 0);

	u = ficlStackPopUnsigned(vm->dataStack);
	ficlUltoa(u, vm->pad, vm->base);
	strcat(vm->pad, " ");
	ficlVmTextOut(vm, vm->pad);
}

static void
ficlPrimitiveHexDot(ficlVm *vm)
{
	ficlUnsigned u;

	FICL_STACK_CHECK(vm->dataStack, 1, 0);

	u = ficlStackPopUnsigned(vm->dataStack);
	ficlUltoa(u, vm->pad, 16);
	strcat(vm->pad, " ");
	ficlVmTextOut(vm, vm->pad);
}

/*
 * s t r l e n
 * Ficl   ( c-string -- length )
 *
 * Returns the length of a C-style (zero-terminated) string.
 *
 * --lch
 */
static void
ficlPrimitiveStrlen(ficlVm *vm)
{
	char *address = (char *)ficlStackPopPointer(vm->dataStack);
	ficlStackPushInteger(vm->dataStack, strlen(address));
}

/*
 * s p r i n t f
 * Ficl	( i*x c-addr-fmt u-fmt c-addr-buffer u-buffer --
 *	c-addr-buffer u-written success-flag )
 * Similar to the C sprintf() function.  It formats into a buffer based on
 * a "format" string.  Each character in the format string is copied verbatim
 * to the output buffer, until SPRINTF encounters a percent sign ("%").
 * SPRINTF then skips the percent sign, and examines the next character
 * (the "format character").  Here are the valid format characters:
 *    s - read a C-ADDR U-LENGTH string from the stack and copy it to
 *        the buffer
 *    d - read a ficlCell from the stack, format it as a string (base-10,
 *        signed), and copy it to the buffer
 *    x - same as d, except in base-16
 *    u - same as d, but unsigned
 *    % - output a literal percent-sign to the buffer
 * SPRINTF returns the c-addr-buffer argument unchanged, the number of bytes
 * written, and a flag indicating whether or not it ran out of space while
 * writing to the output buffer (FICL_TRUE if it ran out of space).
 *
 * If SPRINTF runs out of space in the buffer to store the formatted string,
 * it still continues parsing, in an effort to preserve your stack (otherwise
 * it might leave uneaten arguments behind).
 *
 * --lch
 */
static void
ficlPrimitiveSprintf(ficlVm *vm)
{
	int bufferLength = ficlStackPopInteger(vm->dataStack);
	char *buffer = (char *)ficlStackPopPointer(vm->dataStack);
	char *bufferStart = buffer;

	int formatLength = ficlStackPopInteger(vm->dataStack);
	char *format = (char *)ficlStackPopPointer(vm->dataStack);
	char *formatStop = format + formatLength;

	int base = 10;
	int unsignedInteger = 0; /* false */

	int append = 1; /* true */

	while (format < formatStop) {
		char scratch[64];
		char *source;
		int actualLength;
		int desiredLength;
		int leadingZeroes;

		if (*format != '%') {
			source = format;
			actualLength = desiredLength = 1;
			leadingZeroes = 0;
		} else {
			format++;
			if (format == formatStop)
				break;

			leadingZeroes = (*format == '0');
			if (leadingZeroes) {
				format++;
				if (format == formatStop)
					break;
			}

			desiredLength = isdigit((unsigned char)*format);
			if (desiredLength) {
				desiredLength = strtoul(format, &format, 10);
				if (format == formatStop)
					break;
			} else if (*format == '*') {
				desiredLength =
				    ficlStackPopInteger(vm->dataStack);

				format++;
				if (format == formatStop)
					break;
			}

			switch (*format) {
			case 's':
			case 'S':
				actualLength =
				    ficlStackPopInteger(vm->dataStack);
				source = (char *)
				    ficlStackPopPointer(vm->dataStack);
				break;
			case 'x':
			case 'X':
				base = 16;
				/* FALLTHROUGH */
			case 'u':
			case 'U':
				unsignedInteger = 1; /* true */
				/* FALLTHROUGH */
			case 'd':
			case 'D': {
				int integer;
				integer = ficlStackPopInteger(vm->dataStack);
				if (unsignedInteger)
					ficlUltoa(integer, scratch, base);
				else
					ficlLtoa(integer, scratch, base);
				base = 10;
				unsignedInteger = 0; /* false */
				source = scratch;
				actualLength = strlen(scratch);
				break;
			}
			case '%':
				source = format;
				actualLength = 1;
				/* FALLTHROUGH */
			default:
				continue;
			}
		}

		if (append) {
			if (!desiredLength)
				desiredLength = actualLength;
			if (desiredLength > bufferLength) {
				append = 0; /* false */
				desiredLength = bufferLength;
			}
			while (desiredLength > actualLength) {
				*buffer++ = (char)((leadingZeroes) ? '0' : ' ');
				bufferLength--;
				desiredLength--;
			}
			memcpy(buffer, source, actualLength);
			buffer += actualLength;
			bufferLength -= actualLength;
		}

		format++;
	}

	ficlStackPushPointer(vm->dataStack, bufferStart);
	ficlStackPushInteger(vm->dataStack, buffer - bufferStart);
	ficlStackPushInteger(vm->dataStack, FICL_BOOL(!append));
}

/*
 * d u p   &   f r i e n d s
 */
static void
ficlPrimitiveDepth(ficlVm *vm)
{
	int i;

	FICL_STACK_CHECK(vm->dataStack, 0, 1);

	i = ficlStackDepth(vm->dataStack);
	ficlStackPushInteger(vm->dataStack, i);
}

/*
 * e m i t   &   f r i e n d s
 */
static void
ficlPrimitiveEmit(ficlVm *vm)
{
	char buffer[2];
	int i;

	FICL_STACK_CHECK(vm->dataStack, 1, 0);

	i = ficlStackPopInteger(vm->dataStack);
	buffer[0] = (char)i;
	buffer[1] = '\0';
	ficlVmTextOut(vm, buffer);
}

static void
ficlPrimitiveCR(ficlVm *vm)
{
	ficlVmTextOut(vm, "\n");
}

static void
ficlPrimitiveBackslash(ficlVm *vm)
{
	char *trace = ficlVmGetInBuf(vm);
	char *stop = ficlVmGetInBufEnd(vm);
	char c = *trace;

	while ((trace != stop) && (c != '\r') && (c != '\n')) {
		c = *++trace;
	}

	/*
	 * Cope with DOS or UNIX-style EOLs -
	 * Check for /r, /n, /r/n, or /n/r end-of-line sequences,
	 * and point trace to next char. If EOL is \0, we're done.
	 */
	if (trace != stop) {
		trace++;

		if ((trace != stop) && (c != *trace) &&
		    ((*trace == '\r') || (*trace == '\n')))
			trace++;
	}

	ficlVmUpdateTib(vm, trace);
}

/*
 * paren CORE
 * Compilation: Perform the execution semantics given below.
 * Execution: ( "ccc<paren>" -- )
 * Parse ccc delimited by ) (right parenthesis). ( is an immediate word.
 * The number of characters in ccc may be zero to the number of characters
 * in the parse area.
 */
static void
ficlPrimitiveParenthesis(ficlVm *vm)
{
	ficlVmParseStringEx(vm, ')', 0);
}

/*
 * F E T C H   &   S T O R E
 */

/*
 * i f C o I m
 * IMMEDIATE
 * Compiles code for a conditional branch into the dictionary
 * and pushes the branch patch address on the stack for later
 * patching by ELSE or THEN/ENDIF.
 */
static void
ficlPrimitiveIfCoIm(ficlVm *vm)
{
	ficlDictionary *dictionary = ficlVmGetDictionary(vm);

	ficlDictionaryAppendUnsigned(dictionary,
	    ficlInstructionBranch0ParenWithCheck);
	markBranch(dictionary, vm, origTag);
	ficlDictionaryAppendUnsigned(dictionary, 1);
}

/*
 * e l s e C o I m
 *
 * IMMEDIATE -- compiles an "else"...
 * 1) FICL_VM_STATE_COMPILE a branch and a patch address;
 *    the address gets patched
 *    by "endif" to point past the "else" code.
 * 2) Pop the the "if" patch address
 * 3) Patch the "if" branch to point to the current FICL_VM_STATE_COMPILE
 *    address.
 * 4) Push the "else" patch address. ("endif" patches this to jump past
 *    the "else" code.
 */
static void
ficlPrimitiveElseCoIm(ficlVm *vm)
{
	ficlCell *patchAddr;
	ficlInteger offset;
	ficlDictionary *dictionary = ficlVmGetDictionary(vm);

	/* (1) FICL_VM_STATE_COMPILE branch runtime */
	ficlDictionaryAppendUnsigned(dictionary,
	    ficlInstructionBranchParenWithCheck);

	matchControlTag(vm, origTag);
						/* (2) pop "if" patch addr */
	patchAddr = (ficlCell *)ficlStackPopPointer(vm->dataStack);
	markBranch(dictionary, vm, origTag);	/* (4) push "else" patch addr */

			/* (1) FICL_VM_STATE_COMPILE patch placeholder */
	ficlDictionaryAppendUnsigned(dictionary, 1);
	offset = dictionary->here - patchAddr;
	(*patchAddr).i = offset;		/* (3) Patch "if" */
}

/*
 * e n d i f C o I m
 */
static void
ficlPrimitiveEndifCoIm(ficlVm *vm)
{
	ficlDictionary *dictionary = ficlVmGetDictionary(vm);
	resolveForwardBranch(dictionary, vm, origTag);
}

/*
 * c a s e C o I m
 * IMMEDIATE FICL_VM_STATE_COMPILE-ONLY
 *
 *
 * At FICL_VM_STATE_COMPILE-time, a CASE-SYS (see DPANS94 6.2.0873) looks
 * like this:
 *			i*addr i caseTag
 * and an OF-SYS (see DPANS94 6.2.1950) looks like this:
 *			i*addr i caseTag addr ofTag
 * The integer under caseTag is the count of fixup addresses that branch
 * to ENDCASE.
 */
static void
ficlPrimitiveCaseCoIm(ficlVm *vm)
{
	FICL_STACK_CHECK(vm->dataStack, 0, 2);

	ficlStackPushUnsigned(vm->dataStack, 0);
	markControlTag(vm, caseTag);
}

/*
 * e n d c a s eC o I m
 * IMMEDIATE FICL_VM_STATE_COMPILE-ONLY
 */
static void
ficlPrimitiveEndcaseCoIm(ficlVm *vm)
{
	ficlUnsigned fixupCount;
	ficlDictionary *dictionary;
	ficlCell *patchAddr;
	ficlInteger offset;

	/*
	 * if the last OF ended with FALLTHROUGH,
	 * just add the FALLTHROUGH fixup to the
	 * ENDOF fixups
	 */
	if (ficlStackGetTop(vm->dataStack).p == fallthroughTag) {
		matchControlTag(vm, fallthroughTag);
		patchAddr = ficlStackPopPointer(vm->dataStack);
		matchControlTag(vm, caseTag);
		fixupCount = ficlStackPopUnsigned(vm->dataStack);
		ficlStackPushPointer(vm->dataStack, patchAddr);
		ficlStackPushUnsigned(vm->dataStack, fixupCount + 1);
		markControlTag(vm, caseTag);
	}

	matchControlTag(vm, caseTag);

	FICL_STACK_CHECK(vm->dataStack, 1, 0);

	fixupCount = ficlStackPopUnsigned(vm->dataStack);
	FICL_STACK_CHECK(vm->dataStack, fixupCount, 0);

	dictionary = ficlVmGetDictionary(vm);

	ficlDictionaryAppendUnsigned(dictionary, ficlInstructionDrop);

	while (fixupCount--) {
		patchAddr = (ficlCell *)ficlStackPopPointer(vm->dataStack);
		offset = dictionary->here - patchAddr;
		(*patchAddr).i = offset;
	}
}

/*
 * o f C o I m
 * IMMEDIATE FICL_VM_STATE_COMPILE-ONLY
 */
static void
ficlPrimitiveOfCoIm(ficlVm *vm)
{
	ficlDictionary *dictionary = ficlVmGetDictionary(vm);
	ficlCell *fallthroughFixup = NULL;

	FICL_STACK_CHECK(vm->dataStack, 1, 3);

	if (ficlStackGetTop(vm->dataStack).p == fallthroughTag) {
		matchControlTag(vm, fallthroughTag);
		fallthroughFixup = ficlStackPopPointer(vm->dataStack);
	}

	matchControlTag(vm, caseTag);

	markControlTag(vm, caseTag);

	ficlDictionaryAppendUnsigned(dictionary, ficlInstructionOfParen);
	markBranch(dictionary, vm, ofTag);
	ficlDictionaryAppendUnsigned(dictionary, 2);

	if (fallthroughFixup != NULL) {
		ficlInteger offset = dictionary->here - fallthroughFixup;
		(*fallthroughFixup).i = offset;
	}
}

/*
 * e n d o f C o I m
 * IMMEDIATE FICL_VM_STATE_COMPILE-ONLY
 */
static void
ficlPrimitiveEndofCoIm(ficlVm *vm)
{
	ficlCell *patchAddr;
	ficlUnsigned fixupCount;
	ficlInteger offset;
	ficlDictionary *dictionary = ficlVmGetDictionary(vm);

	FICL_STACK_CHECK(vm->dataStack, 4, 3);

	/* ensure we're in an OF, */
	matchControlTag(vm, ofTag);

	/* grab the address of the branch location after the OF */
	patchAddr = (ficlCell *)ficlStackPopPointer(vm->dataStack);
	/* ensure we're also in a "case" */
	matchControlTag(vm, caseTag);
	/* grab the current number of ENDOF fixups */
	fixupCount = ficlStackPopUnsigned(vm->dataStack);

	/* FICL_VM_STATE_COMPILE branch runtime */
	ficlDictionaryAppendUnsigned(dictionary,
	    ficlInstructionBranchParenWithCheck);

	/*
	 * push a new ENDOF fixup, the updated count of ENDOF fixups,
	 * and the caseTag
	 */
	ficlStackPushPointer(vm->dataStack, dictionary->here);
	ficlStackPushUnsigned(vm->dataStack, fixupCount + 1);
	markControlTag(vm, caseTag);

	/* reserve space for the ENDOF fixup */
	ficlDictionaryAppendUnsigned(dictionary, 2);

	/* and patch the original OF */
	offset = dictionary->here - patchAddr;
	(*patchAddr).i = offset;
}

/*
 * f a l l t h r o u g h C o I m
 * IMMEDIATE FICL_VM_STATE_COMPILE-ONLY
 */
static void
ficlPrimitiveFallthroughCoIm(ficlVm *vm)
{
	ficlCell *patchAddr;
	ficlInteger offset;
	ficlDictionary *dictionary = ficlVmGetDictionary(vm);

	FICL_STACK_CHECK(vm->dataStack, 4, 3);

	/* ensure we're in an OF, */
	matchControlTag(vm, ofTag);
	/* grab the address of the branch location after the OF */
	patchAddr = (ficlCell *)ficlStackPopPointer(vm->dataStack);
	/* ensure we're also in a "case" */
	matchControlTag(vm, caseTag);

	/* okay, here we go.  put the case tag back. */
	markControlTag(vm, caseTag);

	/* FICL_VM_STATE_COMPILE branch runtime */
	ficlDictionaryAppendUnsigned(dictionary,
	    ficlInstructionBranchParenWithCheck);

	/* push a new FALLTHROUGH fixup and the fallthroughTag */
	ficlStackPushPointer(vm->dataStack, dictionary->here);
	markControlTag(vm, fallthroughTag);

	/* reserve space for the FALLTHROUGH fixup */
	ficlDictionaryAppendUnsigned(dictionary, 2);

	/* and patch the original OF */
	offset = dictionary->here - patchAddr;
	(*patchAddr).i = offset;
}

/*
 * h a s h
 * hash ( c-addr u -- code)
 * calculates hashcode of specified string and leaves it on the stack
 */
static void
ficlPrimitiveHash(ficlVm *vm)
{
	ficlString s;

	FICL_STRING_SET_LENGTH(s, ficlStackPopUnsigned(vm->dataStack));
	FICL_STRING_SET_POINTER(s, ficlStackPopPointer(vm->dataStack));
	ficlStackPushUnsigned(vm->dataStack, ficlHashCode(s));
}

/*
 * i n t e r p r e t
 * This is the "user interface" of a Forth. It does the following:
 *   while there are words in the VM's Text Input Buffer
 *     Copy next word into the pad (ficlVmGetWord)
 *     Attempt to find the word in the dictionary (ficlDictionaryLookup)
 *     If successful, execute the word.
 *     Otherwise, attempt to convert the word to a number (isNumber)
 *     If successful, push the number onto the parameter stack.
 *     Otherwise, print an error message and exit loop...
 *   End Loop
 *
 * From the standard, section 3.4
 * Text interpretation (see 6.1.1360 EVALUATE and 6.1.2050 QUIT) shall
 * repeat the following steps until either the parse area is empty or an
 * ambiguous condition exists:
 * a) Skip leading spaces and parse a name (see 3.4.1);
 */
static void
ficlPrimitiveInterpret(ficlVm *vm)
{
	ficlString s;
	int i;
	ficlSystem *system;

	FICL_VM_ASSERT(vm, vm);

	system = vm->callback.system;
	s = ficlVmGetWord0(vm);

	/*
	 * Get next word...if out of text, we're done.
	 */
	if (s.length == 0) {
		ficlVmThrow(vm, FICL_VM_STATUS_OUT_OF_TEXT);
	}

	/*
	 * Run the parse chain against the incoming token until somebody
	 * eats it. Otherwise emit an error message and give up.
	 */
	for (i = 0; i < FICL_MAX_PARSE_STEPS; i++) {
		ficlWord *word = system->parseList[i];

		if (word == NULL)
			break;

		if (word->code == ficlPrimitiveParseStepParen) {
			ficlParseStep pStep;
			pStep = (ficlParseStep)(word->param->fn);
			if ((*pStep)(vm, s))
				return;
		} else {
			ficlStackPushPointer(vm->dataStack,
			    FICL_STRING_GET_POINTER(s));
			ficlStackPushUnsigned(vm->dataStack,
			    FICL_STRING_GET_LENGTH(s));
			ficlVmExecuteXT(vm, word);
			if (ficlStackPopInteger(vm->dataStack))
				return;
		}
	}

	ficlVmThrowError(vm, "%.*s not found", FICL_STRING_GET_LENGTH(s),
	    FICL_STRING_GET_POINTER(s));
	/* back to inner interpreter */
}

/*
 * Surrogate precompiled parse step for ficlParseWord
 * (this step is hard coded in FICL_VM_STATE_INTERPRET)
 */
static void
ficlPrimitiveLookup(ficlVm *vm)
{
	ficlString name;
	FICL_STRING_SET_LENGTH(name, ficlStackPopUnsigned(vm->dataStack));
	FICL_STRING_SET_POINTER(name, ficlStackPopPointer(vm->dataStack));
	ficlStackPushInteger(vm->dataStack, ficlVmParseWord(vm, name));
}

/*
 * p a r e n P a r s e S t e p
 * (parse-step)  ( c-addr u -- flag )
 * runtime for a precompiled parse step - pop a counted string off the
 * stack, run the parse step against it, and push the result flag (FICL_TRUE
 * if success, FICL_FALSE otherwise).
 */
void
ficlPrimitiveParseStepParen(ficlVm *vm)
{
	ficlString s;
	ficlWord *word = vm->runningWord;
	ficlParseStep pStep = (ficlParseStep)(word->param->fn);

	FICL_STRING_SET_LENGTH(s, ficlStackPopInteger(vm->dataStack));
	FICL_STRING_SET_POINTER(s, ficlStackPopPointer(vm->dataStack));

	ficlStackPushInteger(vm->dataStack, (*pStep)(vm, s));
}

static void
ficlPrimitiveAddParseStep(ficlVm *vm)
{
	ficlWord *pStep;
	ficlDictionary *dictionary = ficlVmGetDictionary(vm);

	FICL_STACK_CHECK(vm->dataStack, 1, 0);

	pStep = (ficlWord *)(ficlStackPop(vm->dataStack).p);
	if ((pStep != NULL) && ficlDictionaryIsAWord(dictionary, pStep))
		ficlSystemAddParseStep(vm->callback.system, pStep);
}

/*
 * l i t e r a l I m
 *
 * IMMEDIATE code for "literal". This function gets a value from the stack
 * and compiles it into the dictionary preceded by the code for "(literal)".
 * IMMEDIATE
 */
void
ficlPrimitiveLiteralIm(ficlVm *vm)
{
	ficlDictionary *dictionary = ficlVmGetDictionary(vm);
	ficlInteger value;

	value = ficlStackPopInteger(vm->dataStack);

	switch (value) {
	case 1:
	case 2:
	case 3:
	case 4:
	case 5:
	case 6:
	case 7:
	case 8:
	case 9:
	case 10:
	case 11:
	case 12:
	case 13:
	case 14:
	case 15:
	case 16:
		ficlDictionaryAppendUnsigned(dictionary, value);
		break;

	case 0:
	case -1:
	case -2:
	case -3:
	case -4:
	case -5:
	case -6:
	case -7:
	case -8:
	case -9:
	case -10:
	case -11:
	case -12:
	case -13:
	case -14:
	case -15:
	case -16:
		ficlDictionaryAppendUnsigned(dictionary,
		    ficlInstruction0 - value);
	break;

	default:
		ficlDictionaryAppendUnsigned(dictionary,
		    ficlInstructionLiteralParen);
		ficlDictionaryAppendUnsigned(dictionary, value);
	break;
	}
}

static void
ficlPrimitive2LiteralIm(ficlVm *vm)
{
	ficlDictionary *dictionary = ficlVmGetDictionary(vm);

	ficlDictionaryAppendUnsigned(dictionary, ficlInstruction2LiteralParen);
	ficlDictionaryAppendCell(dictionary, ficlStackPop(vm->dataStack));
	ficlDictionaryAppendCell(dictionary, ficlStackPop(vm->dataStack));
}

/*
 * D o  /  L o o p
 * do -- IMMEDIATE FICL_VM_STATE_COMPILE ONLY
 *    Compiles code to initialize a loop: FICL_VM_STATE_COMPILE (do),
 *    allot space to hold the "leave" address, push a branch
 *    target address for the loop.
 * (do) -- runtime for "do"
 *    pops index and limit from the p stack and moves them
 *    to the r stack, then skips to the loop body.
 * loop -- IMMEDIATE FICL_VM_STATE_COMPILE ONLY
 * +loop
 *    Compiles code for the test part of a loop:
 *    FICL_VM_STATE_COMPILE (loop), resolve forward branch from "do", and
 *    copy "here" address to the "leave" address allotted by "do"
 * i,j,k -- FICL_VM_STATE_COMPILE ONLY
 *    Runtime: Push loop indices on param stack (i is innermost loop...)
 *    Note: each loop has three values on the return stack:
 *    ( R: leave limit index )
 *    "leave" is the absolute address of the next ficlCell after the loop
 *    limit and index are the loop control variables.
 * leave -- FICL_VM_STATE_COMPILE ONLY
 *    Runtime: pop the loop control variables, then pop the
 *    "leave" address and jump (absolute) there.
 */
static void
ficlPrimitiveDoCoIm(ficlVm *vm)
{
	ficlDictionary *dictionary = ficlVmGetDictionary(vm);

	ficlDictionaryAppendUnsigned(dictionary, ficlInstructionDoParen);
	/*
	 * Allot space for a pointer to the end
	 * of the loop - "leave" uses this...
	 */
	markBranch(dictionary, vm, leaveTag);
	ficlDictionaryAppendUnsigned(dictionary, 0);
	/*
	 * Mark location of head of loop...
	 */
	markBranch(dictionary, vm, doTag);
}

static void
ficlPrimitiveQDoCoIm(ficlVm *vm)
{
	ficlDictionary *dictionary = ficlVmGetDictionary(vm);

	ficlDictionaryAppendUnsigned(dictionary, ficlInstructionQDoParen);
	/*
	 * Allot space for a pointer to the end
	 * of the loop - "leave" uses this...
	 */
	markBranch(dictionary, vm, leaveTag);
	ficlDictionaryAppendUnsigned(dictionary, 0);
	/*
	 * Mark location of head of loop...
	 */
	markBranch(dictionary, vm, doTag);
}


static void
ficlPrimitiveLoopCoIm(ficlVm *vm)
{
	ficlDictionary *dictionary = ficlVmGetDictionary(vm);

	ficlDictionaryAppendUnsigned(dictionary, ficlInstructionLoopParen);
	resolveBackBranch(dictionary, vm, doTag);
	resolveAbsBranch(dictionary, vm, leaveTag);
}

static void
ficlPrimitivePlusLoopCoIm(ficlVm *vm)
{
	ficlDictionary *dictionary = ficlVmGetDictionary(vm);

	ficlDictionaryAppendUnsigned(dictionary, ficlInstructionPlusLoopParen);
	resolveBackBranch(dictionary, vm, doTag);
	resolveAbsBranch(dictionary, vm, leaveTag);
}

/*
 * v a r i a b l e
 */
static void
ficlPrimitiveVariable(ficlVm *vm)
{
	ficlDictionary *dictionary = ficlVmGetDictionary(vm);
	ficlString name = ficlVmGetWord(vm);

	ficlDictionaryAppendWord(dictionary, name,
	    (ficlPrimitive)ficlInstructionVariableParen, FICL_WORD_DEFAULT);
	ficlVmDictionaryAllotCells(vm, dictionary, 1);
}

static void
ficlPrimitive2Variable(ficlVm *vm)
{
	ficlDictionary *dictionary = ficlVmGetDictionary(vm);
	ficlString name = ficlVmGetWord(vm);

	ficlDictionaryAppendWord(dictionary, name,
	    (ficlPrimitive)ficlInstructionVariableParen, FICL_WORD_DEFAULT);
	ficlVmDictionaryAllotCells(vm, dictionary, 2);
}

/*
 * b a s e   &   f r i e n d s
 */
static void
ficlPrimitiveBase(ficlVm *vm)
{
	ficlCell *pBase, c;

	FICL_STACK_CHECK(vm->dataStack, 0, 1);

	pBase = (ficlCell *)(&vm->base);
	c.p = pBase;
	ficlStackPush(vm->dataStack, c);
}

static void
ficlPrimitiveDecimal(ficlVm *vm)
{
	vm->base = 10;
}


static void
ficlPrimitiveHex(ficlVm *vm)
{
	vm->base = 16;
}

/*
 * a l l o t   &   f r i e n d s
 */
static void
ficlPrimitiveAllot(ficlVm *vm)
{
	ficlDictionary *dictionary;
	ficlInteger i;

	FICL_STACK_CHECK(vm->dataStack, 1, 0);

	dictionary = ficlVmGetDictionary(vm);
	i = ficlStackPopInteger(vm->dataStack);

	FICL_VM_DICTIONARY_CHECK(vm, dictionary, i);

	ficlVmDictionaryAllot(vm, dictionary, i);
}

static void
ficlPrimitiveHere(ficlVm *vm)
{
	ficlDictionary *dictionary;

	FICL_STACK_CHECK(vm->dataStack, 0, 1);

	dictionary = ficlVmGetDictionary(vm);
	ficlStackPushPointer(vm->dataStack, dictionary->here);
}

/*
 * t i c k
 * tick         CORE ( "<spaces>name" -- xt )
 * Skip leading space delimiters. Parse name delimited by a space. Find
 * name and return xt, the execution token for name. An ambiguous condition
 * exists if name is not found.
 */
void
ficlPrimitiveTick(ficlVm *vm)
{
	ficlWord *word = NULL;
	ficlString name = ficlVmGetWord(vm);

	FICL_STACK_CHECK(vm->dataStack, 0, 1);

	word = ficlDictionaryLookup(ficlVmGetDictionary(vm), name);
	if (!word)
		ficlVmThrowError(vm, "%.*s not found",
		    FICL_STRING_GET_LENGTH(name),
		    FICL_STRING_GET_POINTER(name));
	ficlStackPushPointer(vm->dataStack, word);
}

static void
ficlPrimitiveBracketTickCoIm(ficlVm *vm)
{
	ficlPrimitiveTick(vm);
	ficlPrimitiveLiteralIm(vm);
}

/*
 * p o s t p o n e
 * Lookup the next word in the input stream and FICL_VM_STATE_COMPILE code to
 * insert it into definitions created by the resulting word
 * (defers compilation, even of immediate words)
 */
static void
ficlPrimitivePostponeCoIm(ficlVm *vm)
{
	ficlDictionary *dictionary  = ficlVmGetDictionary(vm);
	ficlWord *word;
	ficlWord *pComma = ficlSystemLookup(vm->callback.system, ",");
	ficlCell c;

	FICL_VM_ASSERT(vm, pComma);

	ficlPrimitiveTick(vm);
	word = ficlStackGetTop(vm->dataStack).p;
	if (ficlWordIsImmediate(word)) {
		ficlDictionaryAppendCell(dictionary,
		    ficlStackPop(vm->dataStack));
	} else {
		ficlPrimitiveLiteralIm(vm);
		c.p = pComma;
		ficlDictionaryAppendCell(dictionary, c);
	}
}

/*
 * e x e c u t e
 * Pop an execution token (pointer to a word) off the stack and
 * run it
 */
static void
ficlPrimitiveExecute(ficlVm *vm)
{
	ficlWord *word;

	FICL_STACK_CHECK(vm->dataStack, 1, 0);

	word = ficlStackPopPointer(vm->dataStack);
	ficlVmExecuteWord(vm, word);
}

/*
 * i m m e d i a t e
 * Make the most recently compiled word IMMEDIATE -- it executes even
 * in FICL_VM_STATE_COMPILE state (most often used for control compiling words
 * such as IF, THEN, etc)
 */
static void
ficlPrimitiveImmediate(ficlVm *vm)
{
	FICL_IGNORE(vm);
	ficlDictionarySetImmediate(ficlVmGetDictionary(vm));
}

static void
ficlPrimitiveCompileOnly(ficlVm *vm)
{
	FICL_IGNORE(vm);
	ficlDictionarySetFlags(ficlVmGetDictionary(vm), FICL_WORD_COMPILE_ONLY);
}

static void
ficlPrimitiveSetObjectFlag(ficlVm *vm)
{
	FICL_IGNORE(vm);
	ficlDictionarySetFlags(ficlVmGetDictionary(vm), FICL_WORD_OBJECT);
}

static void
ficlPrimitiveIsObject(ficlVm *vm)
{
	ficlInteger flag;
	ficlWord *word = (ficlWord *)ficlStackPopPointer(vm->dataStack);

	flag = ((word != NULL) && (word->flags & FICL_WORD_OBJECT))?
	    FICL_TRUE : FICL_FALSE;

	ficlStackPushInteger(vm->dataStack, flag);
}

static void
ficlPrimitiveCountedStringQuoteIm(ficlVm *vm)
{
	ficlDictionary *dictionary = ficlVmGetDictionary(vm);

	if (vm->state == FICL_VM_STATE_INTERPRET) {
		ficlCountedString *counted = (ficlCountedString *)
		    dictionary->here;

		ficlVmGetString(vm, counted, '\"');
		ficlStackPushPointer(vm->dataStack, counted);

		/*
		 * move HERE past string so it doesn't get overwritten.  --lch
		 */
		ficlVmDictionaryAllot(vm, dictionary,
		    counted->length + sizeof (ficlUnsigned8));
	} else {	/* FICL_VM_STATE_COMPILE state */
		ficlDictionaryAppendUnsigned(dictionary,
		    ficlInstructionCStringLiteralParen);
		dictionary->here =
		    FICL_POINTER_TO_CELL(ficlVmGetString(vm,
		    (ficlCountedString *)dictionary->here, '\"'));
		ficlDictionaryAlign(dictionary);
	}
}

/*
 * d o t Q u o t e
 * IMMEDIATE word that compiles a string literal for later display
 * FICL_VM_STATE_COMPILE fiStringLiteralParen, then copy the bytes of the
 * string from the
 * TIB to the dictionary. Backpatch the count byte and align the dictionary.
 */
static void
ficlPrimitiveDotQuoteCoIm(ficlVm *vm)
{
	ficlDictionary *dictionary = ficlVmGetDictionary(vm);
	ficlWord *pType = ficlSystemLookup(vm->callback.system, "type");
	ficlCell c;

	FICL_VM_ASSERT(vm, pType);

	ficlDictionaryAppendUnsigned(dictionary,
	    ficlInstructionStringLiteralParen);
	dictionary->here =
	    FICL_POINTER_TO_CELL(ficlVmGetString(vm,
	    (ficlCountedString *)dictionary->here, '\"'));
	ficlDictionaryAlign(dictionary);
	c.p = pType;
	ficlDictionaryAppendCell(dictionary, c);
}

static void
ficlPrimitiveDotParen(ficlVm *vm)
{
	char *from = ficlVmGetInBuf(vm);
	char *stop = ficlVmGetInBufEnd(vm);
	char *to = vm->pad;
	char c;

	/*
	 * Note: the standard does not want leading spaces skipped.
	 */
	for (c = *from; (from != stop) && (c != ')'); c = *++from)
		*to++ = c;

	*to = '\0';
	if ((from != stop) && (c == ')'))
		from++;

	ficlVmTextOut(vm, vm->pad);
	ficlVmUpdateTib(vm, from);
}

/*
 * s l i t e r a l
 * STRING
 * Interpretation: Interpretation semantics for this word are undefined.
 * Compilation: ( c-addr1 u -- )
 * Append the run-time semantics given below to the current definition.
 * Run-time:       ( -- c-addr2 u )
 * Return c-addr2 u describing a string consisting of the characters
 * specified by c-addr1 u during compilation. A program shall not alter
 * the returned string.
 */
static void ficlPrimitiveSLiteralCoIm(ficlVm *vm)
{
	ficlDictionary *dictionary;
	char *from;
	char *to;
	ficlUnsigned length;

	FICL_STACK_CHECK(vm->dataStack, 2, 0);

	dictionary = ficlVmGetDictionary(vm);
	length  = ficlStackPopUnsigned(vm->dataStack);
	from = ficlStackPopPointer(vm->dataStack);

	ficlDictionaryAppendUnsigned(dictionary,
	    ficlInstructionStringLiteralParen);
	to = (char *)dictionary->here;
	*to++ = (char)length;

	for (; length > 0; --length) {
		*to++ = *from++;
	}

	*to++ = 0;
	dictionary->here = FICL_POINTER_TO_CELL(ficlAlignPointer(to));
}

/*
 * s t a t e
 * Return the address of the VM's state member (must be sized the
 * same as a ficlCell for this reason)
 */
static void ficlPrimitiveState(ficlVm *vm)
{
	FICL_STACK_CHECK(vm->dataStack, 0, 1);
	ficlStackPushPointer(vm->dataStack, &vm->state);
}

/*
 * c r e a t e . . . d o e s >
 * Make a new word in the dictionary with the run-time effect of
 * a variable (push my address), but with extra space allotted
 * for use by does> .
 */
static void
ficlPrimitiveCreate(ficlVm *vm)
{
	ficlDictionary *dictionary = ficlVmGetDictionary(vm);
	ficlString name = ficlVmGetWord(vm);

	ficlDictionaryAppendWord(dictionary, name,
	    (ficlPrimitive)ficlInstructionCreateParen, FICL_WORD_DEFAULT);
	ficlVmDictionaryAllotCells(vm, dictionary, 1);
}

static void
ficlPrimitiveDoesCoIm(ficlVm *vm)
{
	ficlDictionary *dictionary = ficlVmGetDictionary(vm);
#if FICL_WANT_LOCALS
	if (vm->callback.system->localsCount > 0) {
		ficlDictionary *locals =
		    ficlSystemGetLocals(vm->callback.system);
		ficlDictionaryEmpty(locals, locals->forthWordlist->size);
		ficlDictionaryAppendUnsigned(dictionary,
		    ficlInstructionUnlinkParen);
	}

	vm->callback.system->localsCount = 0;
#endif
	FICL_IGNORE(vm);

	ficlDictionaryAppendUnsigned(dictionary, ficlInstructionDoesParen);
}

/*
 * t o   b o d y
 * to-body	CORE ( xt -- a-addr )
 * a-addr is the data-field address corresponding to xt. An ambiguous
 * condition exists if xt is not for a word defined via CREATE.
 */
static void
ficlPrimitiveToBody(ficlVm *vm)
{
	ficlWord *word;
	FICL_STACK_CHECK(vm->dataStack, 1, 1);

	word = ficlStackPopPointer(vm->dataStack);
	ficlStackPushPointer(vm->dataStack, word->param + 1);
}

/*
 * from-body	Ficl ( a-addr -- xt )
 * Reverse effect of >body
 */
static void
ficlPrimitiveFromBody(ficlVm *vm)
{
	char *ptr;
	FICL_STACK_CHECK(vm->dataStack, 1, 1);

	ptr = (char *)ficlStackPopPointer(vm->dataStack) - sizeof (ficlWord);
	ficlStackPushPointer(vm->dataStack, ptr);
}

/*
 * >name	Ficl ( xt -- c-addr u )
 * Push the address and length of a word's name given its address
 * xt.
 */
static void
ficlPrimitiveToName(ficlVm *vm)
{
	ficlWord *word;

	FICL_STACK_CHECK(vm->dataStack, 1, 2);

	word = ficlStackPopPointer(vm->dataStack);
	ficlStackPushPointer(vm->dataStack, word->name);
	ficlStackPushUnsigned(vm->dataStack, word->length);
}

static void
ficlPrimitiveLastWord(ficlVm *vm)
{
	ficlDictionary *dictionary = ficlVmGetDictionary(vm);
	ficlWord *wp = dictionary->smudge;
	ficlCell c;

	FICL_VM_ASSERT(vm, wp);

	c.p = wp;
	ficlVmPush(vm, c);
}

/*
 * l b r a c k e t   e t c
 */
static void
ficlPrimitiveLeftBracketCoIm(ficlVm *vm)
{
	vm->state = FICL_VM_STATE_INTERPRET;
}

static void
ficlPrimitiveRightBracket(ficlVm *vm)
{
	vm->state = FICL_VM_STATE_COMPILE;
}

/*
 * p i c t u r e d   n u m e r i c   w o r d s
 *
 * less-number-sign CORE ( -- )
 * Initialize the pictured numeric output conversion process.
 * (clear the pad)
 */
static void
ficlPrimitiveLessNumberSign(ficlVm *vm)
{
	ficlCountedString *counted = FICL_POINTER_TO_COUNTED_STRING(vm->pad);
	counted->length = 0;
}

/*
 * number-sign		CORE ( ud1 -- ud2 )
 * Divide ud1 by the number in BASE giving the quotient ud2 and the remainder
 * n. (n is the least-significant digit of ud1.) Convert n to external form
 * and add the resulting character to the beginning of the pictured numeric
 * output  string. An ambiguous condition exists if # executes outside of a
 * <# #> delimited number conversion.
 */
static void
ficlPrimitiveNumberSign(ficlVm *vm)
{
	ficlCountedString *counted;
	ficl2Unsigned u;
	ficl2UnsignedQR uqr;

	FICL_STACK_CHECK(vm->dataStack, 2, 2);

	counted = FICL_POINTER_TO_COUNTED_STRING(vm->pad);
	u = ficlStackPop2Unsigned(vm->dataStack);
	uqr = ficl2UnsignedDivide(u, (ficlUnsigned16)(vm->base));
	counted->text[counted->length++] = ficlDigitToCharacter(uqr.remainder);
	ficlStackPush2Unsigned(vm->dataStack, uqr.quotient);
}

/*
 * number-sign-greater CORE ( xd -- c-addr u )
 * Drop xd. Make the pictured numeric output string available as a character
 * string. c-addr and u specify the resulting character string. A program
 * may replace characters within the string.
 */
static void
ficlPrimitiveNumberSignGreater(ficlVm *vm)
{
	ficlCountedString *counted;

	FICL_STACK_CHECK(vm->dataStack, 2, 2);

	counted = FICL_POINTER_TO_COUNTED_STRING(vm->pad);
	counted->text[counted->length] = 0;
	ficlStringReverse(counted->text);
	ficlStackDrop(vm->dataStack, 2);
	ficlStackPushPointer(vm->dataStack, counted->text);
	ficlStackPushUnsigned(vm->dataStack, counted->length);
}

/*
 * number-sign-s	CORE ( ud1 -- ud2 )
 * Convert one digit of ud1 according to the rule for #. Continue conversion
 * until the quotient is zero. ud2 is zero. An ambiguous condition exists if
 * #S executes outside of a <# #> delimited number conversion.
 * TO DO: presently does not use ud1 hi ficlCell - use it!
 */
static void
ficlPrimitiveNumberSignS(ficlVm *vm)
{
	ficlCountedString *counted;
	ficl2Unsigned u;
	ficl2UnsignedQR uqr;

	FICL_STACK_CHECK(vm->dataStack, 2, 2);

	counted = FICL_POINTER_TO_COUNTED_STRING(vm->pad);
	u = ficlStackPop2Unsigned(vm->dataStack);

	do {
		uqr = ficl2UnsignedDivide(u, (ficlUnsigned16)(vm->base));
		counted->text[counted->length++] =
		    ficlDigitToCharacter(uqr.remainder);
		u = uqr.quotient;
	} while (FICL_2UNSIGNED_NOT_ZERO(u));

	ficlStackPush2Unsigned(vm->dataStack, u);
}

/*
 * HOLD		CORE ( char -- )
 * Add char to the beginning of the pictured numeric output string.
 * An ambiguous condition exists if HOLD executes outside of a <# #>
 * delimited number conversion.
 */
static void
ficlPrimitiveHold(ficlVm *vm)
{
	ficlCountedString *counted;
	int i;

	FICL_STACK_CHECK(vm->dataStack, 1, 0);

	counted = FICL_POINTER_TO_COUNTED_STRING(vm->pad);
	i = ficlStackPopInteger(vm->dataStack);
	counted->text[counted->length++] = (char)i;
}

/*
 * SIGN		CORE ( n -- )
 * If n is negative, add a minus sign to the beginning of the pictured
 * numeric output string. An ambiguous condition exists if SIGN
 * executes outside of a <# #> delimited number conversion.
 */
static void
ficlPrimitiveSign(ficlVm *vm)
{
	ficlCountedString *counted;
	int i;

	FICL_STACK_CHECK(vm->dataStack, 1, 0);

	counted = FICL_POINTER_TO_COUNTED_STRING(vm->pad);
	i = ficlStackPopInteger(vm->dataStack);
	if (i < 0)
		counted->text[counted->length++] = '-';
}

/*
 * t o   N u m b e r
 * to-number CORE ( ud1 c-addr1 u1 -- ud2 c-addr2 u2 )
 * ud2 is the unsigned result of converting the characters within the
 * string specified by c-addr1 u1 into digits, using the number in BASE,
 * and adding each into ud1 after multiplying ud1 by the number in BASE.
 * Conversion continues left-to-right until a character that is not
 * convertible, including any + or -, is encountered or the string is
 * entirely converted. c-addr2 is the location of the first unconverted
 * character or the first character past the end of the string if the string
 * was entirely converted. u2 is the number of unconverted characters in the
 * string. An ambiguous condition exists if ud2 overflows during the
 * conversion.
 */
static void
ficlPrimitiveToNumber(ficlVm *vm)
{
	ficlUnsigned length;
	char *trace;
	ficl2Unsigned accumulator;
	ficlUnsigned base = vm->base;
	ficlUnsigned c;
	ficlUnsigned digit;

	FICL_STACK_CHECK(vm->dataStack, 4, 4);

	length = ficlStackPopUnsigned(vm->dataStack);
	trace = (char *)ficlStackPopPointer(vm->dataStack);
	accumulator = ficlStackPop2Unsigned(vm->dataStack);

	for (c = *trace; length > 0; c = *++trace, length--) {
		if (c < '0')
			break;

		digit = c - '0';

		if (digit > 9)
			digit = tolower(c) - 'a' + 10;
		/*
		 * Note: following test also catches chars between 9 and a
		 * because 'digit' is unsigned!
		 */
		if (digit >= base)
			break;

		accumulator = ficl2UnsignedMultiplyAccumulate(accumulator,
		    base, digit);
	}

	ficlStackPush2Unsigned(vm->dataStack, accumulator);
	ficlStackPushPointer(vm->dataStack, trace);
	ficlStackPushUnsigned(vm->dataStack, length);
}

/*
 * q u i t   &   a b o r t
 * quit CORE	( -- )  ( R:  i*x -- )
 * Empty the return stack, store zero in SOURCE-ID if it is present, make
 * the user input device the input source, and enter interpretation state.
 * Do not display a message. Repeat the following:
 *
 *   Accept a line from the input source into the input buffer, set >IN to
 *   zero, and FICL_VM_STATE_INTERPRET.
 *   Display the implementation-defined system prompt if in
 *   interpretation state, all processing has been completed, and no
 *   ambiguous condition exists.
 */
static void
ficlPrimitiveQuit(ficlVm *vm)
{
	ficlVmThrow(vm, FICL_VM_STATUS_QUIT);
}

static void
ficlPrimitiveAbort(ficlVm *vm)
{
	ficlVmThrow(vm, FICL_VM_STATUS_ABORT);
}

/*
 * a c c e p t
 * accept	CORE ( c-addr +n1 -- +n2 )
 * Receive a string of at most +n1 characters. An ambiguous condition
 * exists if +n1 is zero or greater than 32,767. Display graphic characters
 * as they are received. A program that depends on the presence or absence
 * of non-graphic characters in the string has an environmental dependency.
 * The editing functions, if any, that the system performs in order to
 * construct the string are implementation-defined.
 *
 * (Although the standard text doesn't say so, I assume that the intent
 * of 'accept' is to store the string at the address specified on
 * the stack.)
 *
 * NOTE: getchar() is used there as its present both in loader and
 *	userland; however, the more correct solution would be to set
 *	terminal to raw mode for userland.
 */
static void
ficlPrimitiveAccept(ficlVm *vm)
{
	ficlUnsigned size;
	char *address;
	int c;
	ficlUnsigned length = 0;

	FICL_STACK_CHECK(vm->dataStack, 2, 1);

	size = ficlStackPopInteger(vm->dataStack);
	address = ficlStackPopPointer(vm->dataStack);

	while (size != length) {
		c = getchar();
		if (c == '\n' || c == '\r')
			break;
		address[length++] = c;
	}
	ficlStackPushInteger(vm->dataStack, length);
}

/*
 * a l i g n
 * 6.1.0705 ALIGN	CORE ( -- )
 * If the data-space pointer is not aligned, reserve enough space to
 * align it.
 */
static void
ficlPrimitiveAlign(ficlVm *vm)
{
	ficlDictionary *dictionary = ficlVmGetDictionary(vm);
	FICL_IGNORE(vm);
	ficlDictionaryAlign(dictionary);
}

/*
 * a l i g n e d
 */
static void
ficlPrimitiveAligned(ficlVm *vm)
{
	void *addr;

	FICL_STACK_CHECK(vm->dataStack, 1, 1);

	addr = ficlStackPopPointer(vm->dataStack);
	ficlStackPushPointer(vm->dataStack, ficlAlignPointer(addr));
}

/*
 * b e g i n   &   f r i e n d s
 * Indefinite loop control structures
 * A.6.1.0760 BEGIN
 * Typical use:
 *	: X ... BEGIN ... test UNTIL ;
 * or
 *	: X ... BEGIN ... test WHILE ... REPEAT ;
 */
static void
ficlPrimitiveBeginCoIm(ficlVm *vm)
{
	ficlDictionary *dictionary = ficlVmGetDictionary(vm);
	markBranch(dictionary, vm, destTag);
}

static void
ficlPrimitiveUntilCoIm(ficlVm *vm)
{
	ficlDictionary *dictionary = ficlVmGetDictionary(vm);

	ficlDictionaryAppendUnsigned(dictionary,
	    ficlInstructionBranch0ParenWithCheck);
	resolveBackBranch(dictionary, vm, destTag);
}

static void
ficlPrimitiveWhileCoIm(ficlVm *vm)
{
	ficlDictionary *dictionary = ficlVmGetDictionary(vm);

	FICL_STACK_CHECK(vm->dataStack, 2, 5);

	ficlDictionaryAppendUnsigned(dictionary,
	    ficlInstructionBranch0ParenWithCheck);
	markBranch(dictionary, vm, origTag);

	/* equivalent to 2swap */
	ficlStackRoll(vm->dataStack, 3);
	ficlStackRoll(vm->dataStack, 3);

	ficlDictionaryAppendUnsigned(dictionary, 1);
}

static void
ficlPrimitiveRepeatCoIm(ficlVm *vm)
{
	ficlDictionary *dictionary = ficlVmGetDictionary(vm);

	ficlDictionaryAppendUnsigned(dictionary,
	    ficlInstructionBranchParenWithCheck);
	/* expect "begin" branch marker */
	resolveBackBranch(dictionary, vm, destTag);
	/* expect "while" branch marker */
	resolveForwardBranch(dictionary, vm, origTag);
}

static void
ficlPrimitiveAgainCoIm(ficlVm *vm)
{
	ficlDictionary *dictionary = ficlVmGetDictionary(vm);

	ficlDictionaryAppendUnsigned(dictionary,
	    ficlInstructionBranchParenWithCheck);
	/* expect "begin" branch marker */
	resolveBackBranch(dictionary, vm, destTag);
}

/*
 * c h a r   &   f r i e n d s
 * 6.1.0895 CHAR	CORE ( "<spaces>name" -- char )
 * Skip leading space delimiters. Parse name delimited by a space.
 * Put the value of its first character onto the stack.
 *
 * bracket-char		CORE
 * Interpretation: Interpretation semantics for this word are undefined.
 * Compilation: ( "<spaces>name" -- )
 * Skip leading space delimiters. Parse name delimited by a space.
 * Append the run-time semantics given below to the current definition.
 * Run-time: ( -- char )
 * Place char, the value of the first character of name, on the stack.
 */
static void
ficlPrimitiveChar(ficlVm *vm)
{
	ficlString s;

	FICL_STACK_CHECK(vm->dataStack, 0, 1);

	s = ficlVmGetWord(vm);
	ficlStackPushUnsigned(vm->dataStack, (ficlUnsigned)(s.text[0]));
}

static void
ficlPrimitiveCharCoIm(ficlVm *vm)
{
	ficlPrimitiveChar(vm);
	ficlPrimitiveLiteralIm(vm);
}

/*
 * c h a r P l u s
 * char-plus	CORE ( c-addr1 -- c-addr2 )
 * Add the size in address units of a character to c-addr1, giving c-addr2.
 */
static void
ficlPrimitiveCharPlus(ficlVm *vm)
{
	char *p;

	FICL_STACK_CHECK(vm->dataStack, 1, 1);

	p = ficlStackPopPointer(vm->dataStack);
	ficlStackPushPointer(vm->dataStack, p + 1);
}

/*
 * c h a r s
 * chars	CORE ( n1 -- n2 )
 * n2 is the size in address units of n1 characters.
 * For most processors, this function can be a no-op. To guarantee
 * portability, we'll multiply by sizeof (char).
 */
#if defined(_M_IX86)
#pragma warning(disable: 4127)
#endif
static void
ficlPrimitiveChars(ficlVm *vm)
{
	if (sizeof (char) > 1) {
		ficlInteger i;

		FICL_STACK_CHECK(vm->dataStack, 1, 1);

		i = ficlStackPopInteger(vm->dataStack);
		ficlStackPushInteger(vm->dataStack, i * sizeof (char));
	}
	/* otherwise no-op! */
}
#if defined(_M_IX86)
#pragma warning(default: 4127)
#endif

/*
 * c o u n t
 * COUNT	CORE ( c-addr1 -- c-addr2 u )
 * Return the character string specification for the counted string stored
 * at c-addr1. c-addr2 is the address of the first character after c-addr1.
 * u is the contents of the character at c-addr1, which is the length in
 * characters of the string at c-addr2.
 */
static void
ficlPrimitiveCount(ficlVm *vm)
{
	ficlCountedString *counted;

	FICL_STACK_CHECK(vm->dataStack, 1, 2);

	counted = ficlStackPopPointer(vm->dataStack);
	ficlStackPushPointer(vm->dataStack, counted->text);
	ficlStackPushUnsigned(vm->dataStack, counted->length);
}

/*
 * e n v i r o n m e n t ?
 * environment-query CORE ( c-addr u -- FICL_FALSE | i*x FICL_TRUE )
 * c-addr is the address of a character string and u is the string's
 * character count. u may have a value in the range from zero to an
 * implementation-defined maximum which shall not be less than 31. The
 * character string should contain a keyword from 3.2.6 Environmental
 * queries or the optional word sets to be checked for correspondence
 * with an attribute of the present environment. If the system treats the
 * attribute as unknown, the returned flag is FICL_FALSE; otherwise, the flag
 * is FICL_TRUE and the i*x returned is of the type specified in the table for
 * the attribute queried.
 */
static void
ficlPrimitiveEnvironmentQ(ficlVm *vm)
{
	ficlDictionary *environment;
	ficlWord *word;
	ficlString name;

	FICL_STACK_CHECK(vm->dataStack, 2, 1);

	environment = vm->callback.system->environment;
	name.length = ficlStackPopUnsigned(vm->dataStack);
	name.text = ficlStackPopPointer(vm->dataStack);

	word = ficlDictionaryLookup(environment, name);

	if (word != NULL) {
		ficlVmExecuteWord(vm, word);
		ficlStackPushInteger(vm->dataStack, FICL_TRUE);
	} else {
		ficlStackPushInteger(vm->dataStack, FICL_FALSE);
	}
}

/*
 * e v a l u a t e
 * EVALUATE CORE ( i*x c-addr u -- j*x )
 * Save the current input source specification. Store minus-one (-1) in
 * SOURCE-ID if it is present. Make the string described by c-addr and u
 * both the input source and input buffer, set >IN to zero, and
 * FICL_VM_STATE_INTERPRET.
 * When the parse area is empty, restore the prior input source
 * specification. Other stack effects are due to the words EVALUATEd.
 */
static void
ficlPrimitiveEvaluate(ficlVm *vm)
{
	ficlCell id;
	int result;
	ficlString string;

	FICL_STACK_CHECK(vm->dataStack, 2, 0);

	FICL_STRING_SET_LENGTH(string, ficlStackPopUnsigned(vm->dataStack));
	FICL_STRING_SET_POINTER(string, ficlStackPopPointer(vm->dataStack));

	id = vm->sourceId;
	vm->sourceId.i = -1;
	result = ficlVmExecuteString(vm, string);
	vm->sourceId = id;
	if (result != FICL_VM_STATUS_OUT_OF_TEXT)
		ficlVmThrow(vm, result);
}

/*
 * s t r i n g   q u o t e
 * Interpreting: get string delimited by a quote from the input stream,
 * copy to a scratch area, and put its count and address on the stack.
 * Compiling: FICL_VM_STATE_COMPILE code to push the address and count
 * of a string literal, FICL_VM_STATE_COMPILE the string from the input
 * stream, and align the dictionary pointer.
 */
static void
ficlPrimitiveStringQuoteIm(ficlVm *vm)
{
	ficlDictionary *dictionary = ficlVmGetDictionary(vm);

	if (vm->state == FICL_VM_STATE_INTERPRET) {
		ficlCountedString *counted;
		counted = (ficlCountedString *)dictionary->here;
		ficlVmGetString(vm, counted, '\"');
		ficlStackPushPointer(vm->dataStack, counted->text);
		ficlStackPushUnsigned(vm->dataStack, counted->length);
	} else {	/* FICL_VM_STATE_COMPILE state */
		ficlDictionaryAppendUnsigned(dictionary,
		    ficlInstructionStringLiteralParen);
		dictionary->here = FICL_POINTER_TO_CELL(
		    ficlVmGetString(vm, (ficlCountedString *)dictionary->here,
		    '\"'));
		ficlDictionaryAlign(dictionary);
	}
}

/*
 * t y p e
 * Pop count and char address from stack and print the designated string.
 */
static void
ficlPrimitiveType(ficlVm *vm)
{
	ficlUnsigned length;
	char *s;

	FICL_STACK_CHECK(vm->dataStack, 2, 0);

	length = ficlStackPopUnsigned(vm->dataStack);
	s = ficlStackPopPointer(vm->dataStack);

	if ((s == NULL) || (length == 0))
		return;

	/*
	 * Since we don't have an output primitive for a counted string
	 * (oops), make sure the string is null terminated. If not, copy
	 * and terminate it.
	 */
	if (s[length] != 0) {
		char *here = (char *)ficlVmGetDictionary(vm)->here;
		if (s != here)
			strncpy(here, s, length);

		here[length] = '\0';
		s = here;
	}

	ficlVmTextOut(vm, s);
}

/*
 * w o r d
 * word CORE ( char "<chars>ccc<char>" -- c-addr )
 * Skip leading delimiters. Parse characters ccc delimited by char. An
 * ambiguous condition exists if the length of the parsed string is greater
 * than the implementation-defined length of a counted string.
 *
 * c-addr is the address of a transient region containing the parsed word
 * as a counted string. If the parse area was empty or contained no
 * characters other than the delimiter, the resulting string has a zero
 * length. A space, not included in the length, follows the string. A
 * program may replace characters within the string.
 * NOTE! Ficl also NULL-terminates the dest string.
 */
static void
ficlPrimitiveWord(ficlVm *vm)
{
	ficlCountedString *counted;
	char delim;
	ficlString name;

	FICL_STACK_CHECK(vm->dataStack, 1, 1);

	counted = (ficlCountedString *)vm->pad;
	delim = (char)ficlStackPopInteger(vm->dataStack);
	name = ficlVmParseStringEx(vm, delim, 1);

	if (FICL_STRING_GET_LENGTH(name) > FICL_PAD_SIZE - 1)
		FICL_STRING_SET_LENGTH(name, FICL_PAD_SIZE - 1);

	counted->length = (ficlUnsigned8)FICL_STRING_GET_LENGTH(name);
	strncpy(counted->text, FICL_STRING_GET_POINTER(name),
	    FICL_STRING_GET_LENGTH(name));

	/*
	 * store an extra space at the end of the primitive...
	 * why? dunno yet.  Guy Carver did it.
	 */
	counted->text[counted->length] = ' ';
	counted->text[counted->length + 1] = 0;

	ficlStackPushPointer(vm->dataStack, counted);
}

/*
 * p a r s e - w o r d
 * Ficl   PARSE-WORD  ( <spaces>name -- c-addr u )
 * Skip leading spaces and parse name delimited by a space. c-addr is the
 * address within the input buffer and u is the length of the selected
 * string. If the parse area is empty, the resulting string has a zero length.
 */
static void ficlPrimitiveParseNoCopy(ficlVm *vm)
{
	ficlString s;

	FICL_STACK_CHECK(vm->dataStack, 0, 2);

	s = ficlVmGetWord0(vm);
	ficlStackPushPointer(vm->dataStack, FICL_STRING_GET_POINTER(s));
	ficlStackPushUnsigned(vm->dataStack, FICL_STRING_GET_LENGTH(s));
}

/*
 * p a r s e
 * CORE EXT  ( char "ccc<char>" -- c-addr u )
 * Parse ccc delimited by the delimiter char.
 * c-addr is the address (within the input buffer) and u is the length of
 * the parsed string. If the parse area was empty, the resulting string has
 * a zero length.
 * NOTE! PARSE differs from WORD: it does not skip leading delimiters.
 */
static void
ficlPrimitiveParse(ficlVm *vm)
{
	ficlString s;
	char delim;

	FICL_STACK_CHECK(vm->dataStack, 1, 2);

	delim = (char)ficlStackPopInteger(vm->dataStack);

	s = ficlVmParseStringEx(vm, delim, 0);
	ficlStackPushPointer(vm->dataStack, FICL_STRING_GET_POINTER(s));
	ficlStackPushUnsigned(vm->dataStack, FICL_STRING_GET_LENGTH(s));
}

/*
 * f i n d
 * FIND CORE ( c-addr -- c-addr 0  |  xt 1  |  xt -1 )
 * Find the definition named in the counted string at c-addr. If the
 * definition is not found, return c-addr and zero. If the definition is
 * found, return its execution token xt. If the definition is immediate,
 * also return one (1), otherwise also return minus-one (-1). For a given
 * string, the values returned by FIND while compiling may differ from
 * those returned while not compiling.
 */
static void
do_find(ficlVm *vm, ficlString name, void *returnForFailure)
{
	ficlWord *word;

	word = ficlDictionaryLookup(ficlVmGetDictionary(vm), name);
	if (word) {
		ficlStackPushPointer(vm->dataStack, word);
		ficlStackPushInteger(vm->dataStack,
		    (ficlWordIsImmediate(word) ? 1 : -1));
	} else {
		ficlStackPushPointer(vm->dataStack, returnForFailure);
		ficlStackPushUnsigned(vm->dataStack, 0);
	}
}

/*
 * f i n d
 * FIND CORE ( c-addr -- c-addr 0  |  xt 1  |  xt -1 )
 * Find the definition named in the counted string at c-addr. If the
 * definition is not found, return c-addr and zero. If the definition is
 * found, return its execution token xt. If the definition is immediate,
 * also return one (1), otherwise also return minus-one (-1). For a given
 * string, the values returned by FIND while compiling may differ from
 * those returned while not compiling.
 */
static void
ficlPrimitiveCFind(ficlVm *vm)
{
	ficlCountedString *counted;
	ficlString name;

	FICL_STACK_CHECK(vm->dataStack, 1, 2);

	counted = ficlStackPopPointer(vm->dataStack);
	FICL_STRING_SET_FROM_COUNTED_STRING(name, *counted);
	do_find(vm, name, counted);
}

/*
 * s f i n d
 * Ficl   ( c-addr u -- 0 0  |  xt 1  |  xt -1 )
 * Like FIND, but takes "c-addr u" for the string.
 */
static void
ficlPrimitiveSFind(ficlVm *vm)
{
	ficlString name;

	FICL_STACK_CHECK(vm->dataStack, 2, 2);

	name.length = ficlStackPopInteger(vm->dataStack);
	name.text = ficlStackPopPointer(vm->dataStack);

	do_find(vm, name, NULL);
}

/*
 * r e c u r s e
 */
static void
ficlPrimitiveRecurseCoIm(ficlVm *vm)
{
	ficlDictionary *dictionary = ficlVmGetDictionary(vm);
	ficlCell c;

	FICL_IGNORE(vm);
	c.p = dictionary->smudge;
	ficlDictionaryAppendCell(dictionary, c);
}

/*
 * s o u r c e
 * CORE ( -- c-addr u )
 * c-addr is the address of, and u is the number of characters in, the
 * input buffer.
 */
static void
ficlPrimitiveSource(ficlVm *vm)
{
	FICL_STACK_CHECK(vm->dataStack, 0, 2);

	ficlStackPushPointer(vm->dataStack, vm->tib.text);
	ficlStackPushInteger(vm->dataStack, ficlVmGetInBufLen(vm));
}

/*
 * v e r s i o n
 * non-standard...
 */
static void
ficlPrimitiveVersion(ficlVm *vm)
{
	ficlVmTextOut(vm, "Ficl version " FICL_VERSION "\n");
}

/*
 * t o I n
 * to-in CORE
 */
static void
ficlPrimitiveToIn(ficlVm *vm)
{
	FICL_STACK_CHECK(vm->dataStack, 0, 1);

	ficlStackPushPointer(vm->dataStack, &vm->tib.index);
}

/*
 * c o l o n N o N a m e
 * CORE EXT ( C:  -- colon-sys )  ( S:  -- xt )
 * Create an unnamed colon definition and push its address.
 * Change state to FICL_VM_STATE_COMPILE.
 */
static void
ficlPrimitiveColonNoName(ficlVm *vm)
{
	ficlDictionary *dictionary = ficlVmGetDictionary(vm);
	ficlWord *word;
	ficlString name;

	FICL_STRING_SET_LENGTH(name, 0);
	FICL_STRING_SET_POINTER(name, NULL);

	vm->state = FICL_VM_STATE_COMPILE;
	word = ficlDictionaryAppendWord(dictionary, name,
	    (ficlPrimitive)ficlInstructionColonParen,
	    FICL_WORD_DEFAULT | FICL_WORD_SMUDGED);

	ficlStackPushPointer(vm->dataStack, word);
	markControlTag(vm, colonTag);
}

/*
 * u s e r   V a r i a b l e
 * user  ( u -- )  "<spaces>name"
 * Get a name from the input stream and create a user variable
 * with the name and the index supplied. The run-time effect
 * of a user variable is to push the address of the indexed ficlCell
 * in the running vm's user array.
 *
 * User variables are vm local cells. Each vm has an array of
 * FICL_USER_CELLS of them when FICL_WANT_USER is nonzero.
 * Ficl's user facility is implemented with two primitives,
 * "user" and "(user)", a variable ("nUser") (in softcore.c) that
 * holds the index of the next free user ficlCell, and a redefinition
 * (also in softcore) of "user" that defines a user word and increments
 * nUser.
 */
#if FICL_WANT_USER
static void
ficlPrimitiveUser(ficlVm *vm)
{
	ficlDictionary *dictionary = ficlVmGetDictionary(vm);
	ficlString name = ficlVmGetWord(vm);
	ficlCell c;

	c = ficlStackPop(vm->dataStack);
	if (c.i >= FICL_USER_CELLS) {
		ficlVmThrowError(vm, "Error - out of user space");
	}

	ficlDictionaryAppendWord(dictionary, name,
	    (ficlPrimitive)ficlInstructionUserParen, FICL_WORD_DEFAULT);
	ficlDictionaryAppendCell(dictionary, c);
}
#endif

#if FICL_WANT_LOCALS
/*
 * Each local is recorded in a private locals dictionary as a
 * word that does doLocalIm at runtime. DoLocalIm compiles code
 * into the client definition to fetch the value of the
 * corresponding local variable from the return stack.
 * The private dictionary gets initialized at the end of each block
 * that uses locals (in ; and does> for example).
 */
void
ficlLocalParenIm(ficlVm *vm, int isDouble, int isFloat)
{
	ficlDictionary *dictionary = ficlVmGetDictionary(vm);
	ficlInteger nLocal = vm->runningWord->param[0].i;

#if !FICL_WANT_FLOAT
	FICL_VM_ASSERT(vm, !isFloat);
	/* get rid of unused parameter warning */
	isFloat = 0;
#endif /* FICL_WANT_FLOAT */

	if (vm->state == FICL_VM_STATE_INTERPRET) {
		ficlStack *stack;
#if FICL_WANT_FLOAT
		if (isFloat)
			stack = vm->floatStack;
		else
#endif /* FICL_WANT_FLOAT */
			stack = vm->dataStack;

		ficlStackPush(stack, vm->returnStack->frame[nLocal]);
		if (isDouble)
			ficlStackPush(stack, vm->returnStack->frame[nLocal+1]);
	} else {
		ficlInstruction instruction;
		ficlInteger appendLocalOffset;
#if FICL_WANT_FLOAT
		if (isFloat) {
			instruction =
			    (isDouble) ? ficlInstructionGetF2LocalParen :
			    ficlInstructionGetFLocalParen;
			appendLocalOffset = FICL_TRUE;
		} else
#endif /* FICL_WANT_FLOAT */
		if (nLocal == 0) {
			instruction = (isDouble) ? ficlInstructionGet2Local0 :
			    ficlInstructionGetLocal0;
			appendLocalOffset = FICL_FALSE;
		} else if ((nLocal == 1) && !isDouble) {
			instruction = ficlInstructionGetLocal1;
			appendLocalOffset = FICL_FALSE;
		} else {
			instruction =
			    (isDouble) ? ficlInstructionGet2LocalParen :
			    ficlInstructionGetLocalParen;
			appendLocalOffset = FICL_TRUE;
		}

		ficlDictionaryAppendUnsigned(dictionary, instruction);
		if (appendLocalOffset)
			ficlDictionaryAppendUnsigned(dictionary, nLocal);
	}
}

static void
ficlPrimitiveDoLocalIm(ficlVm *vm)
{
	ficlLocalParenIm(vm, 0, 0);
}

static void
ficlPrimitiveDo2LocalIm(ficlVm *vm)
{
	ficlLocalParenIm(vm, 1, 0);
}

#if FICL_WANT_FLOAT
static void
ficlPrimitiveDoFLocalIm(ficlVm *vm)
{
	ficlLocalParenIm(vm, 0, 1);
}

static void
ficlPrimitiveDoF2LocalIm(ficlVm *vm)
{
	ficlLocalParenIm(vm, 1, 1);
}
#endif /* FICL_WANT_FLOAT */

/*
 * l o c a l P a r e n
 * paren-local-paren LOCAL
 * Interpretation: Interpretation semantics for this word are undefined.
 * Execution: ( c-addr u -- )
 * When executed during compilation, (LOCAL) passes a message to the
 * system that has one of two meanings. If u is non-zero,
 * the message identifies a new local whose definition name is given by
 * the string of characters identified by c-addr u. If u is zero,
 * the message is last local and c-addr has no significance.
 *
 * The result of executing (LOCAL) during compilation of a definition is
 * to create a set of named local identifiers, each of which is
 * a definition name, that only have execution semantics within the scope
 * of that definition's source.
 *
 * local Execution: ( -- x )
 *
 * Push the local's value, x, onto the stack. The local's value is
 * initialized as described in 13.3.3 Processing locals and may be
 * changed by preceding the local's name with TO. An ambiguous condition
 * exists when local is executed while in interpretation state.
 */
void
ficlLocalParen(ficlVm *vm, int isDouble, int isFloat)
{
	ficlDictionary *dictionary;
	ficlString name;

	FICL_STACK_CHECK(vm->dataStack, 2, 0);

	dictionary = ficlVmGetDictionary(vm);
	FICL_STRING_SET_LENGTH(name, ficlStackPopUnsigned(vm->dataStack));
	FICL_STRING_SET_POINTER(name,
	    (char *)ficlStackPopPointer(vm->dataStack));

	if (FICL_STRING_GET_LENGTH(name) > 0) {
		/*
		 * add a local to the **locals** dictionary and
		 * update localsCount
		 */
		ficlPrimitive code;
		ficlInstruction instruction;
		ficlDictionary *locals;

		locals = ficlSystemGetLocals(vm->callback.system);
		if (vm->callback.system->localsCount >= FICL_MAX_LOCALS) {
			ficlVmThrowError(vm, "Error: out of local space");
		}

#if !FICL_WANT_FLOAT
		FICL_VM_ASSERT(vm, !isFloat);
		/* get rid of unused parameter warning */
		isFloat = 0;
#else /* FICL_WANT_FLOAT */
		if (isFloat) {
			if (isDouble) {
				code = ficlPrimitiveDoF2LocalIm;
				instruction = ficlInstructionToF2LocalParen;
			} else {
				code = ficlPrimitiveDoFLocalIm;
				instruction = ficlInstructionToFLocalParen;
			}
		} else
#endif /* FICL_WANT_FLOAT */
		if (isDouble) {
			code = ficlPrimitiveDo2LocalIm;
			instruction = ficlInstructionTo2LocalParen;
		} else {
			code = ficlPrimitiveDoLocalIm;
			instruction = ficlInstructionToLocalParen;
		}

		ficlDictionaryAppendWord(locals, name, code,
		    FICL_WORD_COMPILE_ONLY_IMMEDIATE);
		ficlDictionaryAppendUnsigned(locals,
		    vm->callback.system->localsCount);

		if (vm->callback.system->localsCount == 0) {
			/*
			 * FICL_VM_STATE_COMPILE code to create a local
			 * stack frame
			 */
			ficlDictionaryAppendUnsigned(dictionary,
			    ficlInstructionLinkParen);

			/* save location in dictionary for #locals */
			vm->callback.system->localsFixup = dictionary->here;
			ficlDictionaryAppendUnsigned(dictionary,
			    vm->callback.system->localsCount);
		}

		ficlDictionaryAppendUnsigned(dictionary, instruction);
		ficlDictionaryAppendUnsigned(dictionary,
		    vm->callback.system->localsCount);

		vm->callback.system->localsCount += (isDouble) ? 2 : 1;
	} else if (vm->callback.system->localsCount > 0) {
		/* write localsCount to (link) param area in dictionary */
		*(ficlInteger *)(vm->callback.system->localsFixup) =
		    vm->callback.system->localsCount;
	}
}

static void
ficlPrimitiveLocalParen(ficlVm *vm)
{
	ficlLocalParen(vm, 0, 0);
}

static void
ficlPrimitive2LocalParen(ficlVm *vm)
{
	ficlLocalParen(vm, 1, 0);
}
#endif /* FICL_WANT_LOCALS */

/*
 * t o V a l u e
 * CORE EXT
 * Interpretation: ( x "<spaces>name" -- )
 * Skip leading spaces and parse name delimited by a space. Store x in
 * name. An ambiguous condition exists if name was not defined by VALUE.
 * NOTE: In Ficl, VALUE is an alias of CONSTANT
 */
static void
ficlPrimitiveToValue(ficlVm *vm)
{
	ficlString name = ficlVmGetWord(vm);
	ficlDictionary *dictionary = ficlVmGetDictionary(vm);
	ficlWord *word;
	ficlInstruction instruction = 0;
	ficlStack *stack;
	ficlInteger isDouble;
#if FICL_WANT_LOCALS
	ficlInteger nLocal;
	ficlInteger appendLocalOffset;
	ficlInteger isFloat;
#endif /* FICL_WANT_LOCALS */

#if FICL_WANT_LOCALS
	if ((vm->callback.system->localsCount > 0) &&
	    (vm->state == FICL_VM_STATE_COMPILE)) {
		ficlDictionary *locals;

		locals = ficlSystemGetLocals(vm->callback.system);
		word = ficlDictionaryLookup(locals, name);
		if (!word)
			goto TO_GLOBAL;

		if (word->code == ficlPrimitiveDoLocalIm) {
			instruction = ficlInstructionToLocalParen;
			isDouble = isFloat = FICL_FALSE;
		} else if (word->code == ficlPrimitiveDo2LocalIm) {
			instruction = ficlInstructionTo2LocalParen;
			isDouble = FICL_TRUE;
			isFloat = FICL_FALSE;
		}
#if FICL_WANT_FLOAT
		else if (word->code == ficlPrimitiveDoFLocalIm) {
			instruction = ficlInstructionToFLocalParen;
			isDouble = FICL_FALSE;
			isFloat = FICL_TRUE;
		} else if (word->code == ficlPrimitiveDoF2LocalIm) {
			instruction = ficlInstructionToF2LocalParen;
			isDouble = isFloat = FICL_TRUE;
		}
#endif /* FICL_WANT_FLOAT */
		else {
			ficlVmThrowError(vm,
			    "to %.*s : local is of unknown type",
			    FICL_STRING_GET_LENGTH(name),
			    FICL_STRING_GET_POINTER(name));
			return;
		}

		nLocal = word->param[0].i;
		appendLocalOffset = FICL_TRUE;

#if FICL_WANT_FLOAT
		if (!isFloat) {
#endif /* FICL_WANT_FLOAT */
			if (nLocal == 0) {
				instruction =
				    (isDouble) ? ficlInstructionTo2Local0 :
				    ficlInstructionToLocal0;
				appendLocalOffset = FICL_FALSE;
			} else if ((nLocal == 1) && !isDouble) {
				instruction = ficlInstructionToLocal1;
				appendLocalOffset = FICL_FALSE;
			}
#if FICL_WANT_FLOAT
		}
#endif /* FICL_WANT_FLOAT */

		ficlDictionaryAppendUnsigned(dictionary, instruction);
		if (appendLocalOffset)
			ficlDictionaryAppendUnsigned(dictionary, nLocal);
		return;
	}
#endif

#if FICL_WANT_LOCALS
TO_GLOBAL:
#endif /* FICL_WANT_LOCALS */
	word = ficlDictionaryLookup(dictionary, name);
	if (!word)
		ficlVmThrowError(vm, "%.*s not found",
		    FICL_STRING_GET_LENGTH(name),
		    FICL_STRING_GET_POINTER(name));

	switch ((ficlInstruction)word->code) {
	case ficlInstructionConstantParen:
		instruction = ficlInstructionStore;
		stack = vm->dataStack;
		isDouble = FICL_FALSE;
	break;
	case ficlInstruction2ConstantParen:
		instruction = ficlInstruction2Store;
		stack = vm->dataStack;
		isDouble = FICL_TRUE;
	break;
#if FICL_WANT_FLOAT
	case ficlInstructionFConstantParen:
		instruction = ficlInstructionFStore;
		stack = vm->floatStack;
		isDouble = FICL_FALSE;
	break;
	case ficlInstructionF2ConstantParen:
		instruction = ficlInstructionF2Store;
		stack = vm->floatStack;
		isDouble = FICL_TRUE;
	break;
#endif /* FICL_WANT_FLOAT */
	default:
		ficlVmThrowError(vm,
		    "to %.*s : value/constant is of unknown type",
		    FICL_STRING_GET_LENGTH(name),
		    FICL_STRING_GET_POINTER(name));
	return;
	}

	if (vm->state == FICL_VM_STATE_INTERPRET) {
		word->param[0] = ficlStackPop(stack);
		if (isDouble)
			word->param[1] = ficlStackPop(stack);
	} else {
		/* FICL_VM_STATE_COMPILE code to store to word's param */
		ficlStackPushPointer(vm->dataStack, &word->param[0]);
		ficlPrimitiveLiteralIm(vm);
		ficlDictionaryAppendUnsigned(dictionary, instruction);
	}
}

/*
 * f m S l a s h M o d
 * f-m-slash-mod CORE ( d1 n1 -- n2 n3 )
 * Divide d1 by n1, giving the floored quotient n3 and the remainder n2.
 * Input and output stack arguments are signed. An ambiguous condition
 * exists if n1 is zero or if the quotient lies outside the range of a
 * single-ficlCell signed integer.
 */
static void
ficlPrimitiveFMSlashMod(ficlVm *vm)
{
	ficl2Integer d1;
	ficlInteger n1;
	ficl2IntegerQR qr;

	FICL_STACK_CHECK(vm->dataStack, 3, 2);

	n1 = ficlStackPopInteger(vm->dataStack);
	d1 = ficlStackPop2Integer(vm->dataStack);
	qr = ficl2IntegerDivideFloored(d1, n1);
	ficlStackPushInteger(vm->dataStack, qr.remainder);
	ficlStackPushInteger(vm->dataStack,
	    FICL_2UNSIGNED_GET_LOW(qr.quotient));
}

/*
 * s m S l a s h R e m
 * s-m-slash-remainder CORE ( d1 n1 -- n2 n3 )
 * Divide d1 by n1, giving the symmetric quotient n3 and the remainder n2.
 * Input and output stack arguments are signed. An ambiguous condition
 * exists if n1 is zero or if the quotient lies outside the range of a
 * single-ficlCell signed integer.
 */
static void
ficlPrimitiveSMSlashRem(ficlVm *vm)
{
	ficl2Integer d1;
	ficlInteger n1;
	ficl2IntegerQR qr;

	FICL_STACK_CHECK(vm->dataStack, 3, 2);

	n1 = ficlStackPopInteger(vm->dataStack);
	d1 = ficlStackPop2Integer(vm->dataStack);
	qr = ficl2IntegerDivideSymmetric(d1, n1);
	ficlStackPushInteger(vm->dataStack, qr.remainder);
	ficlStackPushInteger(vm->dataStack,
	    FICL_2UNSIGNED_GET_LOW(qr.quotient));
}

static void
ficlPrimitiveMod(ficlVm *vm)
{
	ficl2Integer d1;
	ficlInteger n1;
	ficlInteger i;
	ficl2IntegerQR qr;
	FICL_STACK_CHECK(vm->dataStack, 2, 1);

	n1 = ficlStackPopInteger(vm->dataStack);
	i = ficlStackPopInteger(vm->dataStack);
	FICL_INTEGER_TO_2INTEGER(i, d1);
	qr = ficl2IntegerDivideSymmetric(d1, n1);
	ficlStackPushInteger(vm->dataStack, qr.remainder);
}

/*
 * u m S l a s h M o d
 * u-m-slash-mod CORE ( ud u1 -- u2 u3 )
 * Divide ud by u1, giving the quotient u3 and the remainder u2.
 * All values and arithmetic are unsigned. An ambiguous condition
 * exists if u1 is zero or if the quotient lies outside the range of a
 * single-ficlCell unsigned integer.
 */
static void
ficlPrimitiveUMSlashMod(ficlVm *vm)
{
	ficl2Unsigned ud;
	ficlUnsigned u1;
	ficl2UnsignedQR uqr;

	u1    = ficlStackPopUnsigned(vm->dataStack);
	ud    = ficlStackPop2Unsigned(vm->dataStack);
	uqr   = ficl2UnsignedDivide(ud, u1);
	ficlStackPushUnsigned(vm->dataStack, uqr.remainder);
	ficlStackPushUnsigned(vm->dataStack,
	    FICL_2UNSIGNED_GET_LOW(uqr.quotient));
}

/*
 * m S t a r
 * m-star CORE ( n1 n2 -- d )
 * d is the signed product of n1 times n2.
 */
static void
ficlPrimitiveMStar(ficlVm *vm)
{
	ficlInteger n2;
	ficlInteger n1;
	ficl2Integer d;
	FICL_STACK_CHECK(vm->dataStack, 2, 2);

	n2 = ficlStackPopInteger(vm->dataStack);
	n1 = ficlStackPopInteger(vm->dataStack);

	d = ficl2IntegerMultiply(n1, n2);
	ficlStackPush2Integer(vm->dataStack, d);
}

static void
ficlPrimitiveUMStar(ficlVm *vm)
{
	ficlUnsigned u2;
	ficlUnsigned u1;
	ficl2Unsigned ud;
	FICL_STACK_CHECK(vm->dataStack, 2, 2);

	u2 = ficlStackPopUnsigned(vm->dataStack);
	u1 = ficlStackPopUnsigned(vm->dataStack);

	ud = ficl2UnsignedMultiply(u1, u2);
	ficlStackPush2Unsigned(vm->dataStack, ud);
}

/*
 * 2 r o t
 * DOUBLE   ( d1 d2 d3 -- d2 d3 d1 )
 */
static void
ficlPrimitive2Rot(ficlVm *vm)
{
	ficl2Integer d1, d2, d3;
	FICL_STACK_CHECK(vm->dataStack, 6, 6);

	d3 = ficlStackPop2Integer(vm->dataStack);
	d2 = ficlStackPop2Integer(vm->dataStack);
	d1 = ficlStackPop2Integer(vm->dataStack);
	ficlStackPush2Integer(vm->dataStack, d2);
	ficlStackPush2Integer(vm->dataStack, d3);
	ficlStackPush2Integer(vm->dataStack, d1);
}

/*
 * p a d
 * CORE EXT  ( -- c-addr )
 * c-addr is the address of a transient region that can be used to hold
 * data for intermediate processing.
 */
static void
ficlPrimitivePad(ficlVm *vm)
{
	ficlStackPushPointer(vm->dataStack, vm->pad);
}

/*
 * s o u r c e - i d
 * CORE EXT, FILE   ( -- 0 | -1 | fileid )
 *    Identifies the input source as follows:
 *
 * SOURCE-ID       Input source
 * ---------       ------------
 * fileid          Text file fileid
 * -1              String (via EVALUATE)
 * 0               User input device
 */
static void
ficlPrimitiveSourceID(ficlVm *vm)
{
	ficlStackPushInteger(vm->dataStack, vm->sourceId.i);
}

/*
 * r e f i l l
 * CORE EXT   ( -- flag )
 * Attempt to fill the input buffer from the input source, returning
 * a FICL_TRUE flag if successful.
 * When the input source is the user input device, attempt to receive input
 * into the terminal input buffer. If successful, make the result the input
 * buffer, set >IN to zero, and return FICL_TRUE. Receipt of a line containing
 * no characters is considered successful. If there is no input available from
 * the current input source, return FICL_FALSE.
 * When the input source is a string from EVALUATE, return FICL_FALSE and
 * perform no other action.
 */
static void
ficlPrimitiveRefill(ficlVm *vm)
{
	ficlInteger ret = (vm->sourceId.i == -1) ? FICL_FALSE : FICL_TRUE;
	if (ret && (vm->restart == 0))
		ficlVmThrow(vm, FICL_VM_STATUS_RESTART);

	ficlStackPushInteger(vm->dataStack, ret);
}

/*
 * freebsd exception handling words
 * Catch, from ANS Forth standard. Installs a safety net, then EXECUTE
 * the word in ToS. If an exception happens, restore the state to what
 * it was before, and pushes the exception value on the stack. If not,
 * push zero.
 *
 * Notice that Catch implements an inner interpreter. This is ugly,
 * but given how Ficl works, it cannot be helped. The problem is that
 * colon definitions will be executed *after* the function returns,
 * while "code" definitions will be executed immediately. I considered
 * other solutions to this problem, but all of them shared the same
 * basic problem (with added disadvantages): if Ficl ever changes it's
 * inner thread modus operandi, one would have to fix this word.
 *
 * More comments can be found throughout catch's code.
 *
 * Daniel C. Sobral Jan 09/1999
 * sadler may 2000 -- revised to follow ficl.c:ficlExecXT.
 */
static void
ficlPrimitiveCatch(ficlVm *vm)
{
	int except;
	jmp_buf vmState;
	ficlVm vmCopy;
	ficlStack dataStackCopy;
	ficlStack returnStackCopy;
	ficlWord *word;

	FICL_VM_ASSERT(vm, vm);
	FICL_VM_ASSERT(vm, vm->callback.system->exitInnerWord);

	/*
	 * Get xt.
	 * We need this *before* we save the stack pointer, or
	 * we'll have to pop one element out of the stack after
	 * an exception. I prefer to get done with it up front. :-)
	 */

	FICL_STACK_CHECK(vm->dataStack, 1, 0);

	word = ficlStackPopPointer(vm->dataStack);

	/*
	 * Save vm's state -- a catch will not back out environmental
	 * changes.
	 *
	 * We are *not* saving dictionary state, since it is
	 * global instead of per vm, and we are not saving
	 * stack contents, since we are not required to (and,
	 * thus, it would be useless). We save vm, and vm
	 * "stacks" (a structure containing general information
	 * about it, including the current stack pointer).
	 */
	memcpy((void*)&vmCopy, (void*)vm, sizeof (ficlVm));
	memcpy((void*)&dataStackCopy, (void*)vm->dataStack, sizeof (ficlStack));
	memcpy((void*)&returnStackCopy, (void*)vm->returnStack,
	    sizeof (ficlStack));

	/*
	 * Give vm a jmp_buf
	 */
	vm->exceptionHandler = &vmState;

	/*
	 * Safety net
	 */
	except = setjmp(vmState);

	switch (except) {
	/*
	 * Setup condition - push poison pill so that the VM throws
	 * VM_INNEREXIT if the XT terminates normally, then execute
	 * the XT
	 */
	case 0:
		/* Open mouth, insert emetic */
		ficlVmPushIP(vm, &(vm->callback.system->exitInnerWord));
		ficlVmExecuteWord(vm, word);
		ficlVmInnerLoop(vm, 0);
	break;

	/*
	 * Normal exit from XT - lose the poison pill,
	 * restore old setjmp vector and push a zero.
	 */
	case FICL_VM_STATUS_INNER_EXIT:
		ficlVmPopIP(vm);	/* Gack - hurl poison pill */
					/* Restore just the setjmp vector */
		vm->exceptionHandler = vmCopy.exceptionHandler;
					/* Push 0 -- everything is ok */
		ficlStackPushInteger(vm->dataStack, 0);
	break;

	/*
	 * Some other exception got thrown - restore pre-existing VM state
	 * and push the exception code
	 */
	default:
		/* Restore vm's state */
		memcpy((void*)vm, (void*)&vmCopy, sizeof (ficlVm));
		memcpy((void*)vm->dataStack, (void*)&dataStackCopy,
		    sizeof (ficlStack));
		memcpy((void*)vm->returnStack, (void*)&returnStackCopy,
		    sizeof (ficlStack));

		ficlStackPushInteger(vm->dataStack, except); /* Push error */
	break;
	}
}

/*
 * t h r o w
 * EXCEPTION
 * Throw --  From ANS Forth standard.
 *
 * Throw takes the ToS and, if that's different from zero,
 * returns to the last executed catch context. Further throws will
 * unstack previously executed "catches", in LIFO mode.
 *
 * Daniel C. Sobral Jan 09/1999
 */
static void
ficlPrimitiveThrow(ficlVm *vm)
{
	int except;

	except = ficlStackPopInteger(vm->dataStack);

	if (except)
		ficlVmThrow(vm, except);
}

/*
 * a l l o c a t e
 * MEMORY
 */
static void
ficlPrimitiveAllocate(ficlVm *vm)
{
	size_t size;
	void *p;

	size = ficlStackPopInteger(vm->dataStack);
	p = ficlMalloc(size);
	ficlStackPushPointer(vm->dataStack, p);
	if (p != NULL)
		ficlStackPushInteger(vm->dataStack, 0);
	else
		ficlStackPushInteger(vm->dataStack, 1);
}

/*
 * f r e e
 * MEMORY
 */
static void
ficlPrimitiveFree(ficlVm *vm)
{
	void *p;

	p = ficlStackPopPointer(vm->dataStack);
	ficlFree(p);
	ficlStackPushInteger(vm->dataStack, 0);
}

/*
 * r e s i z e
 * MEMORY
 */
static void
ficlPrimitiveResize(ficlVm *vm)
{
	size_t size;
	void *new, *old;

	size = ficlStackPopInteger(vm->dataStack);
	old = ficlStackPopPointer(vm->dataStack);
	new = ficlRealloc(old, size);

	if (new) {
		ficlStackPushPointer(vm->dataStack, new);
		ficlStackPushInteger(vm->dataStack, 0);
	} else {
		ficlStackPushPointer(vm->dataStack, old);
		ficlStackPushInteger(vm->dataStack, 1);
	}
}

/*
 * e x i t - i n n e r
 * Signals execXT that an inner loop has completed
 */
static void
ficlPrimitiveExitInner(ficlVm *vm)
{
	ficlVmThrow(vm, FICL_VM_STATUS_INNER_EXIT);
}

#if 0
static void
ficlPrimitiveName(ficlVm *vm)
{
	FICL_IGNORE(vm);
}
#endif

/*
 * f i c l C o m p i l e C o r e
 * Builds the primitive wordset and the environment-query namespace.
 */
void
ficlSystemCompileCore(ficlSystem *system)
{
	ficlWord *interpret;
	ficlDictionary *dictionary = ficlSystemGetDictionary(system);
	ficlDictionary *environment = ficlSystemGetEnvironment(system);

	FICL_SYSTEM_ASSERT(system, dictionary);
	FICL_SYSTEM_ASSERT(system, environment);

#define	FICL_TOKEN(token, description)
#define	FICL_INSTRUCTION_TOKEN(token, description, flags)	\
	ficlDictionarySetInstruction(dictionary, description, token, flags);
#include "ficltokens.h"
#undef FICL_TOKEN
#undef FICL_INSTRUCTION_TOKEN

	/*
	 * The Core word set
	 * see softcore.c for definitions of: abs bl space spaces abort"
	 */
	ficlDictionarySetPrimitive(dictionary, "#", ficlPrimitiveNumberSign,
	    FICL_WORD_DEFAULT);
	ficlDictionarySetPrimitive(dictionary, "#>",
	    ficlPrimitiveNumberSignGreater, FICL_WORD_DEFAULT);
	ficlDictionarySetPrimitive(dictionary, "#s", ficlPrimitiveNumberSignS,
	    FICL_WORD_DEFAULT);
	ficlDictionarySetPrimitive(dictionary, "\'", ficlPrimitiveTick,
	    FICL_WORD_DEFAULT);
	ficlDictionarySetPrimitive(dictionary, "(", ficlPrimitiveParenthesis,
	    FICL_WORD_IMMEDIATE);
	ficlDictionarySetPrimitive(dictionary, "+loop",
	    ficlPrimitivePlusLoopCoIm, FICL_WORD_COMPILE_ONLY_IMMEDIATE);
	ficlDictionarySetPrimitive(dictionary, ".", ficlPrimitiveDot,
	    FICL_WORD_DEFAULT);
	ficlDictionarySetPrimitive(dictionary, ".\"",
	    ficlPrimitiveDotQuoteCoIm, FICL_WORD_COMPILE_ONLY_IMMEDIATE);
	ficlDictionarySetPrimitive(dictionary, ":", ficlPrimitiveColon,
	    FICL_WORD_DEFAULT);
	ficlDictionarySetPrimitive(dictionary, ";", ficlPrimitiveSemicolonCoIm,
	    FICL_WORD_COMPILE_ONLY_IMMEDIATE);
	ficlDictionarySetPrimitive(dictionary, "<#",
	    ficlPrimitiveLessNumberSign, FICL_WORD_DEFAULT);
	ficlDictionarySetPrimitive(dictionary, ">body", ficlPrimitiveToBody,
	    FICL_WORD_DEFAULT);
	ficlDictionarySetPrimitive(dictionary, ">in", ficlPrimitiveToIn,
	    FICL_WORD_DEFAULT);
	ficlDictionarySetPrimitive(dictionary, ">number", ficlPrimitiveToNumber,
	    FICL_WORD_DEFAULT);
	ficlDictionarySetPrimitive(dictionary, "abort", ficlPrimitiveAbort,
	    FICL_WORD_DEFAULT);
	ficlDictionarySetPrimitive(dictionary, "accept", ficlPrimitiveAccept,
	    FICL_WORD_DEFAULT);
	ficlDictionarySetPrimitive(dictionary, "align", ficlPrimitiveAlign,
	    FICL_WORD_DEFAULT);
	ficlDictionarySetPrimitive(dictionary, "aligned", ficlPrimitiveAligned,
	    FICL_WORD_DEFAULT);
	ficlDictionarySetPrimitive(dictionary, "allot", ficlPrimitiveAllot,
	    FICL_WORD_DEFAULT);
	ficlDictionarySetPrimitive(dictionary, "base", ficlPrimitiveBase,
	    FICL_WORD_DEFAULT);
	ficlDictionarySetPrimitive(dictionary, "begin", ficlPrimitiveBeginCoIm,
	    FICL_WORD_COMPILE_ONLY_IMMEDIATE);
	ficlDictionarySetPrimitive(dictionary, "case", ficlPrimitiveCaseCoIm,
	    FICL_WORD_COMPILE_ONLY_IMMEDIATE);
	ficlDictionarySetPrimitive(dictionary, "char", ficlPrimitiveChar,
	    FICL_WORD_DEFAULT);
	ficlDictionarySetPrimitive(dictionary, "char+", ficlPrimitiveCharPlus,
	    FICL_WORD_DEFAULT);
	ficlDictionarySetPrimitive(dictionary, "chars", ficlPrimitiveChars,
	    FICL_WORD_DEFAULT);
	ficlDictionarySetPrimitive(dictionary, "constant",
	    ficlPrimitiveConstant, FICL_WORD_DEFAULT);
	ficlDictionarySetPrimitive(dictionary, "count", ficlPrimitiveCount,
	    FICL_WORD_DEFAULT);
	ficlDictionarySetPrimitive(dictionary, "cr", ficlPrimitiveCR,
	    FICL_WORD_DEFAULT);
	ficlDictionarySetPrimitive(dictionary, "create", ficlPrimitiveCreate,
	    FICL_WORD_DEFAULT);
	ficlDictionarySetPrimitive(dictionary, "decimal", ficlPrimitiveDecimal,
	    FICL_WORD_DEFAULT);
	ficlDictionarySetPrimitive(dictionary, "depth", ficlPrimitiveDepth,
	    FICL_WORD_DEFAULT);
	ficlDictionarySetPrimitive(dictionary, "do", ficlPrimitiveDoCoIm,
	    FICL_WORD_COMPILE_ONLY_IMMEDIATE);
	ficlDictionarySetPrimitive(dictionary, "does>", ficlPrimitiveDoesCoIm,
	    FICL_WORD_COMPILE_ONLY_IMMEDIATE);
	ficlDictionarySetPrimitive(dictionary, "else", ficlPrimitiveElseCoIm,
	    FICL_WORD_COMPILE_ONLY_IMMEDIATE);
	ficlDictionarySetPrimitive(dictionary, "emit", ficlPrimitiveEmit,
	    FICL_WORD_DEFAULT);
	ficlDictionarySetPrimitive(dictionary, "endcase",
	    ficlPrimitiveEndcaseCoIm, FICL_WORD_COMPILE_ONLY_IMMEDIATE);
	ficlDictionarySetPrimitive(dictionary, "endof", ficlPrimitiveEndofCoIm,
	    FICL_WORD_COMPILE_ONLY_IMMEDIATE);
	ficlDictionarySetPrimitive(dictionary, "environment?",
	    ficlPrimitiveEnvironmentQ, FICL_WORD_DEFAULT);
	ficlDictionarySetPrimitive(dictionary, "evaluate",
	    ficlPrimitiveEvaluate, FICL_WORD_DEFAULT);
	ficlDictionarySetPrimitive(dictionary, "execute", ficlPrimitiveExecute,
	    FICL_WORD_DEFAULT);
	ficlDictionarySetPrimitive(dictionary, "exit", ficlPrimitiveExitCoIm,
	    FICL_WORD_COMPILE_ONLY_IMMEDIATE);
	ficlDictionarySetPrimitive(dictionary, "fallthrough",
	    ficlPrimitiveFallthroughCoIm, FICL_WORD_COMPILE_ONLY_IMMEDIATE);
	ficlDictionarySetPrimitive(dictionary, "find", ficlPrimitiveCFind,
	    FICL_WORD_DEFAULT);
	ficlDictionarySetPrimitive(dictionary, "fm/mod",
	    ficlPrimitiveFMSlashMod, FICL_WORD_DEFAULT);
	ficlDictionarySetPrimitive(dictionary, "here", ficlPrimitiveHere,
	    FICL_WORD_DEFAULT);
	ficlDictionarySetPrimitive(dictionary, "hold", ficlPrimitiveHold,
	    FICL_WORD_DEFAULT);
	ficlDictionarySetPrimitive(dictionary, "if", ficlPrimitiveIfCoIm,
	    FICL_WORD_COMPILE_ONLY_IMMEDIATE);
	ficlDictionarySetPrimitive(dictionary, "immediate",
	    ficlPrimitiveImmediate, FICL_WORD_DEFAULT);
	ficlDictionarySetPrimitive(dictionary, "literal",
	    ficlPrimitiveLiteralIm, FICL_WORD_IMMEDIATE);
	ficlDictionarySetPrimitive(dictionary, "loop", ficlPrimitiveLoopCoIm,
	    FICL_WORD_COMPILE_ONLY_IMMEDIATE);
	ficlDictionarySetPrimitive(dictionary, "m*", ficlPrimitiveMStar,
	    FICL_WORD_DEFAULT);
	ficlDictionarySetPrimitive(dictionary, "mod", ficlPrimitiveMod,
	    FICL_WORD_DEFAULT);
	ficlDictionarySetPrimitive(dictionary, "of", ficlPrimitiveOfCoIm,
	    FICL_WORD_COMPILE_ONLY_IMMEDIATE);
	ficlDictionarySetPrimitive(dictionary, "postpone",
	    ficlPrimitivePostponeCoIm, FICL_WORD_COMPILE_ONLY_IMMEDIATE);
	ficlDictionarySetPrimitive(dictionary, "quit", ficlPrimitiveQuit,
	    FICL_WORD_DEFAULT);
	ficlDictionarySetPrimitive(dictionary, "recurse",
	    ficlPrimitiveRecurseCoIm, FICL_WORD_COMPILE_ONLY_IMMEDIATE);
	ficlDictionarySetPrimitive(dictionary, "repeat",
	    ficlPrimitiveRepeatCoIm, FICL_WORD_COMPILE_ONLY_IMMEDIATE);
	ficlDictionarySetPrimitive(dictionary, "s\"",
	    ficlPrimitiveStringQuoteIm, FICL_WORD_IMMEDIATE);
	ficlDictionarySetPrimitive(dictionary, "sign", ficlPrimitiveSign,
	    FICL_WORD_DEFAULT);
	ficlDictionarySetPrimitive(dictionary, "sm/rem",
	    ficlPrimitiveSMSlashRem, FICL_WORD_DEFAULT);
	ficlDictionarySetPrimitive(dictionary, "source", ficlPrimitiveSource,
	    FICL_WORD_DEFAULT);
	ficlDictionarySetPrimitive(dictionary, "state", ficlPrimitiveState,
	    FICL_WORD_DEFAULT);
	ficlDictionarySetPrimitive(dictionary, "then", ficlPrimitiveEndifCoIm,
	    FICL_WORD_COMPILE_ONLY_IMMEDIATE);
	ficlDictionarySetPrimitive(dictionary, "type", ficlPrimitiveType,
	    FICL_WORD_DEFAULT);
	ficlDictionarySetPrimitive(dictionary, "u.", ficlPrimitiveUDot,
	    FICL_WORD_DEFAULT);
	ficlDictionarySetPrimitive(dictionary, "um*", ficlPrimitiveUMStar,
	    FICL_WORD_DEFAULT);
	ficlDictionarySetPrimitive(dictionary, "um/mod",
	    ficlPrimitiveUMSlashMod, FICL_WORD_DEFAULT);
	ficlDictionarySetPrimitive(dictionary, "until",
	    ficlPrimitiveUntilCoIm, FICL_WORD_COMPILE_ONLY_IMMEDIATE);
	ficlDictionarySetPrimitive(dictionary, "variable",
	    ficlPrimitiveVariable, FICL_WORD_DEFAULT);
	ficlDictionarySetPrimitive(dictionary, "while",
	    ficlPrimitiveWhileCoIm, FICL_WORD_COMPILE_ONLY_IMMEDIATE);
	ficlDictionarySetPrimitive(dictionary, "word", ficlPrimitiveWord,
	    FICL_WORD_DEFAULT);
	ficlDictionarySetPrimitive(dictionary, "[",
	    ficlPrimitiveLeftBracketCoIm, FICL_WORD_COMPILE_ONLY_IMMEDIATE);
	ficlDictionarySetPrimitive(dictionary, "[\']",
	    ficlPrimitiveBracketTickCoIm, FICL_WORD_COMPILE_ONLY_IMMEDIATE);
	ficlDictionarySetPrimitive(dictionary, "[char]", ficlPrimitiveCharCoIm,
	    FICL_WORD_COMPILE_ONLY_IMMEDIATE);
	ficlDictionarySetPrimitive(dictionary, "]", ficlPrimitiveRightBracket,
	    FICL_WORD_DEFAULT);
	/*
	 * The Core Extensions word set...
	 * see softcore.fr for other definitions
	 */
	/* "#tib" */
	ficlDictionarySetPrimitive(dictionary, ".(", ficlPrimitiveDotParen,
	    FICL_WORD_IMMEDIATE);
	/* ".r" is in softcore */
	ficlDictionarySetPrimitive(dictionary, ":noname",
	    ficlPrimitiveColonNoName, FICL_WORD_DEFAULT);
	ficlDictionarySetPrimitive(dictionary, "?do", ficlPrimitiveQDoCoIm,
	    FICL_WORD_COMPILE_ONLY_IMMEDIATE);
	ficlDictionarySetPrimitive(dictionary, "again", ficlPrimitiveAgainCoIm,
	    FICL_WORD_COMPILE_ONLY_IMMEDIATE);
	ficlDictionarySetPrimitive(dictionary, "c\"",
	    ficlPrimitiveCountedStringQuoteIm, FICL_WORD_IMMEDIATE);
	ficlDictionarySetPrimitive(dictionary, "hex", ficlPrimitiveHex,
	    FICL_WORD_DEFAULT);
	ficlDictionarySetPrimitive(dictionary, "pad", ficlPrimitivePad,
	    FICL_WORD_DEFAULT);
	ficlDictionarySetPrimitive(dictionary, "parse", ficlPrimitiveParse,
	    FICL_WORD_DEFAULT);

	/*
	 * query restore-input save-input tib u.r u> unused
	 * [FICL_VM_STATE_COMPILE]
	 */
	ficlDictionarySetPrimitive(dictionary, "refill", ficlPrimitiveRefill,
	    FICL_WORD_DEFAULT);
	ficlDictionarySetPrimitive(dictionary, "source-id",
	    ficlPrimitiveSourceID, FICL_WORD_DEFAULT);
	ficlDictionarySetPrimitive(dictionary, "to", ficlPrimitiveToValue,
	    FICL_WORD_IMMEDIATE);
	ficlDictionarySetPrimitive(dictionary, "value", ficlPrimitiveConstant,
	    FICL_WORD_DEFAULT);
	ficlDictionarySetPrimitive(dictionary, "\\", ficlPrimitiveBackslash,
	    FICL_WORD_IMMEDIATE);

	/*
	 * Environment query values for the Core word set
	 */
	ficlDictionarySetConstant(environment, "/counted-string",
	    FICL_COUNTED_STRING_MAX);
	ficlDictionarySetConstant(environment, "/hold", FICL_PAD_SIZE);
	ficlDictionarySetConstant(environment, "/pad", FICL_PAD_SIZE);
	ficlDictionarySetConstant(environment, "address-unit-bits", 8);
	ficlDictionarySetConstant(environment, "core", FICL_TRUE);
	ficlDictionarySetConstant(environment, "core-ext", FICL_FALSE);
	ficlDictionarySetConstant(environment, "floored", FICL_FALSE);
	ficlDictionarySetConstant(environment, "max-char", UCHAR_MAX);
	ficlDictionarySetConstant(environment, "max-n", LONG_MAX);
	ficlDictionarySetConstant(environment, "max-u", ULONG_MAX);

	{
		ficl2Integer id;
		ficlInteger low, high;

		low = ULONG_MAX;
		high = LONG_MAX;
		FICL_2INTEGER_SET(high, low, id);
		ficlDictionarySet2Constant(environment, "max-d", id);
		high = ULONG_MAX;
		FICL_2INTEGER_SET(high, low, id);
		ficlDictionarySet2Constant(environment, "max-ud", id);
	}

	ficlDictionarySetConstant(environment, "return-stack-cells",
	    FICL_DEFAULT_STACK_SIZE);
	ficlDictionarySetConstant(environment, "stack-cells",
	    FICL_DEFAULT_STACK_SIZE);

	/*
	 * The optional Double-Number word set (partial)
	 */
	ficlDictionarySetPrimitive(dictionary, "2constant",
	    ficlPrimitive2Constant, FICL_WORD_IMMEDIATE);
	ficlDictionarySetPrimitive(dictionary, "2literal",
	    ficlPrimitive2LiteralIm, FICL_WORD_IMMEDIATE);
	ficlDictionarySetPrimitive(dictionary, "2variable",
	    ficlPrimitive2Variable, FICL_WORD_IMMEDIATE);
	/*
	 * D+ D- D. D.R D0< D0= D2* D2/ in softcore
	 * D< D= D>S DABS DMAX DMIN DNEGATE in softcore
	 * m-star-slash is TODO
	 * M+ in softcore
	 */

	/*
	 * DOUBLE EXT
	 */
	ficlDictionarySetPrimitive(dictionary, "2rot",
	    ficlPrimitive2Rot, FICL_WORD_DEFAULT);
	ficlDictionarySetPrimitive(dictionary, "2value",
	    ficlPrimitive2Constant, FICL_WORD_IMMEDIATE);
	/* du< in softcore */
	/*
	 * The optional Exception and Exception Extensions word set
	 */
	ficlDictionarySetPrimitive(dictionary, "catch", ficlPrimitiveCatch,
	    FICL_WORD_DEFAULT);
	ficlDictionarySetPrimitive(dictionary, "throw", ficlPrimitiveThrow,
	    FICL_WORD_DEFAULT);

	ficlDictionarySetConstant(environment, "exception", FICL_TRUE);
	ficlDictionarySetConstant(environment, "exception-ext", FICL_TRUE);

	/*
	 * The optional Locals and Locals Extensions word set
	 * see softcore.c for implementation of locals|
	 */
#if FICL_WANT_LOCALS
	ficlDictionarySetPrimitive(dictionary, "doLocal",
	    ficlPrimitiveDoLocalIm, FICL_WORD_COMPILE_ONLY_IMMEDIATE);
	ficlDictionarySetPrimitive(dictionary, "(local)",
	    ficlPrimitiveLocalParen, FICL_WORD_COMPILE_ONLY);
	ficlDictionarySetPrimitive(dictionary, "(2local)",
	    ficlPrimitive2LocalParen, FICL_WORD_COMPILE_ONLY);

	ficlDictionarySetConstant(environment, "locals", FICL_TRUE);
	ficlDictionarySetConstant(environment, "locals-ext", FICL_TRUE);
	ficlDictionarySetConstant(environment, "#locals", FICL_MAX_LOCALS);
#endif

	/*
	 * The optional Memory-Allocation word set
	 */

	ficlDictionarySetPrimitive(dictionary, "allocate",
	    ficlPrimitiveAllocate, FICL_WORD_DEFAULT);
	ficlDictionarySetPrimitive(dictionary, "free", ficlPrimitiveFree,
	    FICL_WORD_DEFAULT);
	ficlDictionarySetPrimitive(dictionary, "resize", ficlPrimitiveResize,
	    FICL_WORD_DEFAULT);

	ficlDictionarySetConstant(environment, "memory-alloc", FICL_TRUE);

	/*
	 * The optional Search-Order word set
	 */
	ficlSystemCompileSearch(system);

	/*
	 * The optional Programming-Tools and Programming-Tools
	 * Extensions word set
	 */
	ficlSystemCompileTools(system);

	/*
	 * The optional File-Access and File-Access Extensions word set
	 */
#if FICL_WANT_FILE
	ficlSystemCompileFile(system);
#endif

	/*
	 * Ficl extras
	 */
	ficlDictionarySetPrimitive(dictionary, ".ver", ficlPrimitiveVersion,
	    FICL_WORD_DEFAULT);
	ficlDictionarySetPrimitive(dictionary, ">name", ficlPrimitiveToName,
	    FICL_WORD_DEFAULT);
	ficlDictionarySetPrimitive(dictionary, "add-parse-step",
	    ficlPrimitiveAddParseStep, FICL_WORD_DEFAULT);
	ficlDictionarySetPrimitive(dictionary, "body>", ficlPrimitiveFromBody,
	    FICL_WORD_DEFAULT);
	ficlDictionarySetPrimitive(dictionary, "compile-only",
	    ficlPrimitiveCompileOnly, FICL_WORD_DEFAULT);
	ficlDictionarySetPrimitive(dictionary, "endif", ficlPrimitiveEndifCoIm,
	    FICL_WORD_COMPILE_ONLY_IMMEDIATE);
	ficlDictionarySetPrimitive(dictionary, "last-word",
	    ficlPrimitiveLastWord, FICL_WORD_DEFAULT);
	ficlDictionarySetPrimitive(dictionary, "hash", ficlPrimitiveHash,
	    FICL_WORD_DEFAULT);
	ficlDictionarySetPrimitive(dictionary, "objectify",
	    ficlPrimitiveSetObjectFlag, FICL_WORD_DEFAULT);
	ficlDictionarySetPrimitive(dictionary, "?object",
	    ficlPrimitiveIsObject, FICL_WORD_DEFAULT);
	ficlDictionarySetPrimitive(dictionary, "parse-word",
	    ficlPrimitiveParseNoCopy, FICL_WORD_DEFAULT);
	ficlDictionarySetPrimitive(dictionary, "sfind", ficlPrimitiveSFind,
	    FICL_WORD_DEFAULT);
	ficlDictionarySetPrimitive(dictionary, "sliteral",
	    ficlPrimitiveSLiteralCoIm, FICL_WORD_COMPILE_ONLY_IMMEDIATE);
	ficlDictionarySetPrimitive(dictionary, "sprintf", ficlPrimitiveSprintf,
	    FICL_WORD_DEFAULT);
	ficlDictionarySetPrimitive(dictionary, "strlen", ficlPrimitiveStrlen,
	    FICL_WORD_DEFAULT);
	ficlDictionarySetPrimitive(dictionary, "x.", ficlPrimitiveHexDot,
	    FICL_WORD_DEFAULT);
#if FICL_WANT_USER
	ficlDictionarySetPrimitive(dictionary, "user", ficlPrimitiveUser,
	    FICL_WORD_DEFAULT);
#endif

	/*
	 * internal support words
	 */
	interpret = ficlDictionarySetPrimitive(dictionary, "interpret",
	    ficlPrimitiveInterpret, FICL_WORD_DEFAULT);
	ficlDictionarySetPrimitive(dictionary, "lookup", ficlPrimitiveLookup,
	    FICL_WORD_DEFAULT);
	ficlDictionarySetPrimitive(dictionary, "(parse-step)",
	    ficlPrimitiveParseStepParen, FICL_WORD_DEFAULT);
	system->exitInnerWord = ficlDictionarySetPrimitive(dictionary,
	    "exit-inner", ficlPrimitiveExitInner, FICL_WORD_DEFAULT);

	/*
	 * Set constants representing the internal instruction words
	 * If you want all of 'em, turn that "#if 0" to "#if 1".
	 * By default you only get the numbers (fi0, fiNeg1, etc).
	 */
#define	FICL_TOKEN(token, description)	\
	ficlDictionarySetConstant(dictionary, #token, token);
#if 0
#define	FICL_INSTRUCTION_TOKEN(token, description, flags)	\
	ficlDictionarySetConstant(dictionary, #token, token);
#else
#define	FICL_INSTRUCTION_TOKEN(token, description, flags)
#endif /* 0 */
#include "ficltokens.h"
#undef FICL_TOKEN
#undef FICL_INSTRUCTION_TOKEN

	/*
	 * Set up system's outer interpreter loop - maybe this should
	 * be in initSystem?
	 */
	system->interpreterLoop[0] = interpret;
	system->interpreterLoop[1] = (ficlWord *)ficlInstructionBranchParen;
	system->interpreterLoop[2] = (ficlWord *)(void *)(-2);

	FICL_SYSTEM_ASSERT(system,
	    ficlDictionaryCellsAvailable(dictionary) > 0);
}