/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright (c) 2000 by Sun Microsystems, Inc.
 * All rights reserved.
 */

#pragma ident	"%Z%%M%	%I%	%E% SMI"

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>

#include <fcode/private.h>
#include <fcode/log.h>

int fcode_impl_count = 0;

void (*crash_ptr)(fcode_env_t *env) = do_crash;

uchar_t
next_bytecode(fcode_env_t *env)
{
	uchar_t	byte;

	byte = *env->fcode_ptr;
	env->fcode_ptr += env->fcode_incr;
	return (byte);
}

ushort_t
get_next_token(fcode_env_t *env)
{
	ushort_t token = next_bytecode(env);
	if ((token) && (token < 0x10)) {
		token = (token << 8) | next_bytecode(env);
	}
	env->last_fcode = token;
	return (token);
}

ushort_t
get_short(fcode_env_t *env)
{
	ushort_t u;

	/*
	 * Logical or DOES NOT guarantee left to right evaluation...
	 */
	u = next_bytecode(env) << 8;
	return (u | next_bytecode(env));
}

uint_t
get_int(fcode_env_t *env)
{
	uint_t u;

	/*
	 * Logical or DOES NOT guarantee left to right evaluation...
	 */
	u = get_short(env) << 16;
	return (u | get_short(env));
}

void
expose_acf(fcode_env_t *env, char *name)
{
	if (name == NULL)
		name = "<unknown>";
	EXPOSE_ACF;
	debug_msg(DEBUG_CONTEXT, "CONTEXT:expose_acf: acf: %p/'%s' %p\n",
	    LINK_TO_ACF(env->lastlink), name, env->current);
}

void
do_code(fcode_env_t *env, int token, char *name, void (*fn)(fcode_env_t *))
{
	env->table[token].name = name;
	if (fn == NULL) {
		env->table[token].apf = NULL;
		env->table[token].name = name;
	} else {
		header(env, name, strlen(name), 0);
		env->table[token].apf = (acf_t)HERE;
		COMPILE_TOKEN(fn);
		expose_acf(env, name);
	}
}

void
define_word(fcode_env_t *env, int flag, char *name, void (*fn)(fcode_env_t *))
{
	header(env, name, strlen(name), flag);
	COMPILE_TOKEN(fn);
	expose_acf(env, name);
}

void
end0(fcode_env_t *env)
{
	env->interpretting = 0;
}

static void
end1(fcode_env_t *env)
{
	env->interpretting = 0;
}

void
blit(fcode_env_t *env)
{
	fstack_t d = (int)get_int(env);
	PUSH(DS, d);
	literal(env);
}

void (*bbranch_ptrs[3])(fcode_env_t *env) = {
	do_bbranch,
	do_bqbranch,
	do_bofbranch
};

void
branch_common(fcode_env_t *env, short direction, fstack_t which, int doswap)
{
	fstack_t *sp;
	token_t *branch_loc;

	ASSERT((which < 3) && (which >= 0));
	which = (fstack_t)&bbranch_ptrs[which];
	set_temporary_compile(env);
	COMPILE_TOKEN(which);
	if (direction >= 0) {
		bmark(env);
		if (doswap)
			swap(env);
		PUSH(DS, 0);
		compile_comma(env);
	} else {

		/*
		 * We look down the stack for a branch location
		 * that isn't pointing to zero (i.e. a forward branch label).
		 * We move the first one we find to the top of the stack,
		 * which is what gets compiled in with 'compile_comma'.
		 * Not finding a valid branch label is bad.
		 */
		for (sp = env->ds; sp >= env->ds0; sp--) {
			branch_loc = (token_t *)*sp;
			if (branch_loc && *branch_loc) {
				break;
			}
		}
		if (sp < env->ds0)
			log_message(MSG_ERROR, "branch_common: back: "
			    "no branch loc on stack\n");
		else {
			/* Move branch_loc to top of data stack */
			for (; sp < env->ds; sp++)
				*sp = sp[1];
			*sp = (fstack_t)branch_loc;
		}
		env->level--;
		compile_comma(env);
		temporary_execute(env);
	}
}

void
bbranch(fcode_env_t *env)
{
	short offset = (short)get_short(env);

	branch_common(env, offset, 0, 1);
}

void
bqbranch(fcode_env_t *env)
{
	short offset = (short)get_short(env);

	branch_common(env, offset, 1, 0);
}

void
do_quote(fcode_env_t *env)
{
	int len;
	uchar_t *strptr;

	strptr = (uchar_t *)IP;
	len = *strptr;
	PUSH(DS, (fstack_t)strptr+1);
	PUSH(DS, len);
	strptr += TOKEN_ROUNDUP(len+2);
	IP = (token_t *)strptr;
}

void
bquote(fcode_env_t *env)
{
	char stringbuff[256];
	int len, count;
	char *strptr;

	count = len = next_bytecode(env);
	if (env->state) {
		COMPILE_TOKEN(&quote_ptr);
		strptr = (char *)HERE;
		*strptr++ = len;
		while (count--)
			*strptr++ = next_bytecode(env);
		*strptr++ = 0;
		set_here(env, (uchar_t *)strptr, "bquote");
		token_roundup(env, "bquote");
	} else {
		strptr = stringbuff;
		while (count--)
			*strptr++ = next_bytecode(env);
		*strptr = 0;
		push_string(env, stringbuff, len);
	}
}

char *
get_name(token_t *linkp)
{
	char *name, *p;
	flag_t *fptr = LINK_TO_FLAGS(linkp);
	int len;
	char *cptr;

	if (*fptr & FLAG_NONAME)
		return (NULL);

	cptr = (char *)fptr;
	len = cptr[-1];
	if (len <= 0 || len > 64 || cptr[-2] != '\0')
		return (NULL);

	name = cptr - (len+2);

	for (p = name; *p != '\0'; p++)
		if (!isprint(*p))
			return (NULL);

	if ((p - name) != len)
		return (NULL);

	return (name);
}

void
header(fcode_env_t *env, char *name, int len, flag_t flag)
{
	char *strptr;
	flag_t *fptr;
	acf_t dptr;
	extern void add_debug_acf(fcode_env_t *, acf_t);

	/* Now form the entry in the dictionary */
	token_roundup(env, "header");
	dptr = (acf_t)HERE;
	if (len) {
		int bytes = len+2+sizeof (flag_t);
		dptr = (acf_t)(TOKEN_ROUNDUP(HERE+bytes));
		fptr = LINK_TO_FLAGS(dptr);
		strptr = (char *)fptr - 1;
		*strptr-- = len;
		*strptr-- = 0;
		while (len)
			*strptr-- = name[--len];
	} else {
		dptr++;
		fptr = LINK_TO_FLAGS(dptr);
		flag |= FLAG_NONAME;
	}
	*fptr = flag;
	*dptr = *((acf_t)env->current);
	env->lastlink = dptr++;
	set_here(env, (uchar_t *)dptr, "header");

	if (name_is_debugged(env, name)) {
		log_message(MSG_INFO, "Turning debug on for %s\n", name);
		add_debug_acf(env, LINK_TO_ACF(env->lastlink));
	}
	debug_msg(DEBUG_HEADER, "Define: '%s' @ %p\n", name, HERE);
}

void
token_common(fcode_env_t *env, int headered, int visible)
{
	char namebuff[32];
	int len, count, token;
	char *strptr, c;

	strptr = namebuff;
	if (headered) {
		len = next_bytecode(env);
		for (count = 0; count < len; count++) {
			c = next_bytecode(env);
			if (count < sizeof (namebuff))
				*strptr++ = c;
		}
	}

	if (!visible)
		len = 0;
	*strptr = 0;
	token = get_short(env);
	env->last_token = token;

	debug_msg(DEBUG_NEW_TOKEN, "Define %s token: '%s' (%x)\n",
	    (visible ? "named" : "headerless"), namebuff, token);

	header(env, namebuff, len, 0);
	env->table[token].flags = 0;
	if (len) {
		env->table[token].name = MALLOC(len+1);
		strncpy(env->table[token].name, namebuff, len);
	} else {
		env->table[token].name = NULL;
	}
	env->last_token = token;
}

void
named_token(fcode_env_t *env)
{
	token_common(env, 1, env->fcode_debug);
}

void
external_token(fcode_env_t *env)
{
	token_common(env, 1, 1);
}

void
new_token(fcode_env_t *env)
{
	token_common(env, 0, 0);
}

void
offset16(fcode_env_t *env)
{
	env->offset_incr = 2;
}

void
minus_one(fcode_env_t *env)
{
	PUSH(DS, -1);
}

void
zero(fcode_env_t *env)
{
	PUSH(DS, 0);
}

void
one(fcode_env_t *env)
{
	PUSH(DS, 1);
}

void
two(fcode_env_t *env)
{
	PUSH(DS, 2);
}

void
three(fcode_env_t *env)
{
	PUSH(DS, 3);
}

void
version1(fcode_env_t *env)
{
	env->fcode_incr = 1;
}

static void
start0(fcode_env_t *env)
{
	env->fcode_incr = 1;
}

static void
start1(fcode_env_t *env)
{
	env->fcode_incr = 1;
}

void
start2(fcode_env_t *env)
{
	env->fcode_incr = 2;
}

static void
start4(fcode_env_t *env)
{
	env->fcode_incr = 4;
}

int
check_fcode_header(char *fname, uchar_t *header, int len)
{
	uint32_t length;
	static char func_name[] = "check_fcode_header";

	if (len <= 8) {
		log_message(MSG_ERROR, "%s: '%s' fcode size (%d) <= 8\n",
		    func_name, fname, len);
		return (0);
	}
	if (header[0] != 0xf1 && header[0] != 0xfd) {
		log_message(MSG_ERROR, "%s: '%s' header[0] is 0x%02x not"
		    " 0xf1/0xfd\n", func_name, fname, header[0]);
		return (0);
	}
	length = (header[4] << 24) | (header[5] << 16) | (header[6] << 8) |
	    header[7];
	if (length > len) {
		log_message(MSG_ERROR, "%s: '%s' length (%d) >"
		    " fcode size (%d)\n", func_name, fname, length, len);
		return (0);
	}
	if (length < len) {
		log_message(MSG_WARN, "%s: '%s' length (%d) <"
		    " fcode size (%d)\n", func_name, fname, length, len);
	}
	return (1);
}

void
byte_load(fcode_env_t *env)
{
	uchar_t	*fcode_buffer;
	uchar_t	*fcode_ptr;
	int	fcode_incr;
	int	offset_incr;
	int	fcode_xt;
	int	interpretting;
	int	depth;
	int	length;
	int	past_eob = 0;
	int db;

	/* save any existing interpret state */
	fcode_buffer = env->fcode_buffer;
	fcode_ptr = env->fcode_ptr;
	fcode_incr = env->fcode_incr;
	offset_incr  = env->offset_incr;
	interpretting = env->interpretting;
	depth = DEPTH-2;

	/* Now init them */
	CHECK_DEPTH(env, 2, "byte-load");
	fcode_xt = POP(DS);
	env->fcode_ptr = env->fcode_buffer = (uchar_t *)POP(DS);
	if (fcode_xt != 1) {
		log_message(MSG_WARN, "byte-load: ignoring xt\n");
	}

	length = (env->fcode_buffer[4] << 24) | (env->fcode_buffer[5] << 16) |
	    (env->fcode_buffer[6] << 8) | env->fcode_buffer[7];
	if (!check_fcode_header("byte-load", env->fcode_ptr, length))
		log_message(MSG_WARN, "byte-load: header NOT OK\n");

	env->fcode_incr = 1;
	env->offset_incr = 1;
	env->interpretting = 1;
	env->level = 0;

	db = get_interpreter_debug_level() &
	    (DEBUG_BYTELOAD_DS|DEBUG_BYTELOAD_RS|DEBUG_BYTELOAD_TOKENS);
	debug_msg(db, "byte_load: %p, %d\n", env->fcode_buffer, fcode_xt);
	debug_msg(db, "   header: %x, %x\n",
	    env->fcode_buffer[0], env->fcode_buffer[1]);
	debug_msg(db, "      crc: %x\n",
	    (env->fcode_buffer[2]<<8)|(env->fcode_buffer[3]));
	debug_msg(db, "   length: %x\n", length);
	env->fcode_ptr += 8;

	debug_msg(db, "Interpretting: %d\n", env->interpretting);

	while (env->interpretting) {
		int token;
		fcode_token *entry;
		acf_t apf;

		if (!past_eob && env->fcode_ptr >= env->fcode_buffer + length) {
			log_message(MSG_WARN, "byte-load: past EOB\n");
			past_eob = 1;
		}

		env->last_fcode_ptr = env->fcode_ptr;
		token = get_next_token(env);

		entry = &env->table[token];
		apf   = entry->apf;

		DEBUGF(BYTELOAD_DS, output_data_stack(env, MSG_FC_DEBUG));
		DEBUGF(BYTELOAD_RS, output_return_stack(env, 1, MSG_FC_DEBUG));
		DEBUGF(BYTELOAD_TOKENS, log_message(MSG_FC_DEBUG,
		    "%s: %04x %03x %s (%x)",
		    ((env->state && (entry->flags & IMMEDIATE) == 0)) ?
		    "Compile" : "Execute",
		    env->last_fcode_ptr - env->fcode_buffer, token,
		    entry->name ? entry->name : "???", entry->flags));
		if (db)
			log_message(MSG_FC_DEBUG, "\n");
		if (apf) {
			DEBUGF(TOKEN_USAGE, entry->usage++);
			PUSH(DS, (fstack_t)apf);
			if ((env->state) &&
				((entry->flags & IMMEDIATE) == 0)) {
				/* Compile in references */
				compile_comma(env);
			} else {
				execute(env);
			}
		}
	}
	if (DEPTH != depth) {
		log_message(MSG_ERROR, "FCODE has net stack change of %d\n",
		    DEPTH-depth);
	}
	/* restore old state */
	env->fcode_ptr		= fcode_ptr;
	env->fcode_buffer	= fcode_buffer;
	env->fcode_incr		= fcode_incr;
	env->offset_incr	= offset_incr;
	env->interpretting	= interpretting;
}

void
btick(fcode_env_t *env)
{
	int token = get_next_token(env);

	PUSH(DS, (fstack_t)env->table[token].apf);
	tick_literal(env);
}

static void
show_fcode_def(fcode_env_t *env, char *type)
{
	int i = env->last_token;

	if (get_interpreter_debug_level() & DEBUG_DUMP_TOKENS) {
		if (env->table[i].name)
			log_message(MSG_INFO, "%s: %s %03x %p\n", type,
			    env->table[i].name, i, env->table[i].apf);
		else
			log_message(MSG_INFO, "%s: <noname> %03x %p\n", type, i,
			    env->table[i].apf);
	}
}

void
bcolon(fcode_env_t *env)
{
	if (env->state == 0) {
		env->table[env->last_token].apf = (acf_t)HERE;
		env->table[env->last_token].flags = 0;
		show_fcode_def(env, "bcolon");
	}
	env->state |= 1;
	COMPILE_TOKEN(&do_colon);
}

void
bcreate(fcode_env_t *env)
{
	env->table[env->last_token].apf = (acf_t)HERE;
	show_fcode_def(env, "bcreate");
	COMPILE_TOKEN(&do_create);
	expose_acf(env, "<bcreate>");
}

void
get_token_name(fcode_env_t *env, int token, char **name, int *len)
{
	*name = env->table[token].name;
	if (*name) {
		*len = strlen(*name);
	} else
		*len = 0;
}

void
bvalue(fcode_env_t *env)
{
	env->table[env->last_token].apf = (acf_t)HERE;
	show_fcode_def(env, "bvalue");
	make_common_access(env, 0, 0, 1,
	    env->instance_mode, &noop, &noop, &set_value_actions);
}

void
bvariable(fcode_env_t *env)
{
	env->table[env->last_token].apf = (acf_t)HERE;
	show_fcode_def(env, "bvariable");
	PUSH(DS, 0);
	make_common_access(env, 0, 0, 1,
	    env->instance_mode, &instance_variable, &do_create, NULL);
}

void
bconstant(fcode_env_t *env)
{
	env->table[env->last_token].apf = (acf_t)HERE;
	show_fcode_def(env, "bconstant");
	make_common_access(env, 0, 0, 1,
	    env->instance_mode, &do_constant, &do_constant, NULL);
}

void
bdefer(fcode_env_t *env)
{
	env->table[env->last_token].apf = (acf_t)HERE;
	show_fcode_def(env, "bdefer");

	PUSH(DS, (fstack_t)&crash_ptr);
	make_common_access(env, 0, 0, 1, env->instance_mode,
	    &noop, &noop, &set_defer_actions);
}

void
bbuffer_colon(fcode_env_t *env)
{
	env->table[env->last_token].apf = (acf_t)HERE;
	show_fcode_def(env, "buffer:");
	PUSH(DS, 0);
	make_common_access(env, 0, 0, 2, env->instance_mode,
	    &noop, &noop, &set_buffer_actions);
}

void
do_field(fcode_env_t *env)
{
	fstack_t *d;

	d = (fstack_t *)WA;
	TOS += *d;
}

void
bfield(fcode_env_t *env)
{
	env->table[env->last_token].apf = (acf_t)HERE;
	show_fcode_def(env, "bfield");
	COMPILE_TOKEN(&do_field);
	over(env);
	compile_comma(env);
	add(env);
	expose_acf(env, "<bfield>");
}

void
bto(fcode_env_t *env)
{
	btick(env);

	if (env->state) {
		COMPILE_TOKEN(&to_ptr);
	} else {
		do_set_action(env);
	}
}

void
get_token(fcode_env_t *env)
{
	fstack_t tok;
	fstack_t immediate = 0;

	CHECK_DEPTH(env, 1, "get-token");
	tok = POP(DS);
	tok &= MAX_FCODE;
	PUSH(DS, (fstack_t)env->table[tok].apf);
	if (env->table[tok].flags & IMMEDIATE) 	immediate = 1;
	PUSH(DS, immediate);
}

void
set_token(fcode_env_t *env)
{
	fstack_t tok;
	fstack_t immediate;
	acf_t acf;

	CHECK_DEPTH(env, 3, "set-token");
	tok = POP(DS);
	tok &= MAX_FCODE;
	immediate = POP(DS);
	acf = (acf_t)POP(DS);
	if (immediate)
		env->table[tok].flags |= IMMEDIATE;
	else
		env->table[tok].flags &= ~IMMEDIATE;
	env->table[tok].apf = acf;
	immediate = env->last_token;
	env->last_token = tok;
	show_fcode_def(env, "set_token");
	env->last_token = immediate;
}

void
bof(fcode_env_t *env)
{
	short offset = get_short(env);
	branch_common(env, offset, 2, 0);
}

void
bcase(fcode_env_t *env)
{
	env->level++;
	set_temporary_compile(env);
	PUSH(DS, 0);
}

void
bendcase(fcode_env_t *env)
{
	COMPILE_TOKEN(env->table[0x46].apf);	/* Hack for now... */
	while (TOS) {
		bresolve(env);
	}
	(void) POP(DS);
	env->level--;
	temporary_execute(env);
}

void
bendof(fcode_env_t *env)
{
	short offset = get_short(env);
	branch_common(env, offset, 0, 1);
	bresolve(env);
}

void
fcode_revision(fcode_env_t *env)
{
	/* We are Version 3.0 */
	PUSH(DS, 0x30000);
}

void
alloc_mem(fcode_env_t *env)
{
	CHECK_DEPTH(env, 1, "alloc-mem");
	TOS = (fstack_t)MALLOC((size_t)TOS);
	if (!TOS) {
		throw_from_fclib(env, 1, "alloc-mem failed");
	}
}

void
free_mem(fcode_env_t *env)
{
	void *p;

	CHECK_DEPTH(env, 2, "free-mem");
	(void) POP(DS);
	p = (void *) POP(DS);
	FREE(p);
}

void
parse_two_int(fcode_env_t *env)
{
	uint_t lo, hi;
	char *str;
	int len;

	CHECK_DEPTH(env, 2, "parse-2int");
	lo = 0;
	hi = 0;
	str = pop_a_string(env, &len);
	if (len) {
		if (sscanf(str, "%x,%x", &hi, &lo) != 2) {
			throw_from_fclib(env, 1, "parse_2int");
		}
	}
	PUSH(DS, lo);
	PUSH(DS, hi);
}

void
left_parse_string(fcode_env_t *env)
{
	char sep, *cptr, *lstr, *rstr;
	int len, llen, rlen;

	CHECK_DEPTH(env, 3, "left-parse-string");
	sep = (char)POP(DS);
	if (TOS == 0) {
		two_dup(env);
		return;
	}
	lstr = pop_a_string(env, &llen);
	len = 0;
	cptr = NULL;
	while (len < llen) {
		if (lstr[len] == sep) {
			cptr = lstr+len;
			break;
		}
		len++;
	}
	if (cptr != NULL) {
		rstr = cptr+1;
		rlen = lstr + llen - rstr;
		llen = len;
	} else {
		rlen = 0;
		rstr = lstr;
	}
	PUSH(DS, (fstack_t)rstr);
	PUSH(DS, rlen);
	PUSH(DS, (fstack_t)lstr);
	PUSH(DS, llen);
}

/*
 * (is-user-word)  ( name-str name-len xt -- )
 */
void
is_user_word(fcode_env_t *env)
{
	fstack_t xt;
	char *name;
	int len;

	CHECK_DEPTH(env, 3, "(is-user-word)");
	xt = POP(DS);
	name = pop_a_string(env, &len);
	header(env, name, len, 0);
	COMPILE_TOKEN(&do_alias);
	COMPILE_TOKEN(xt);
	expose_acf(env, name);
}

void
f_error(fcode_env_t *env)
{
#if 0
	env->interpretting = 0;
	log_message(MSG_ERROR, "Uniplemented FCODE token encountered %x\n",
	    env->last_fcode);
#else
	forth_abort(env, "Unimplemented FCODE token: 0x%x\n", env->last_fcode);
#endif
}

static void
fcode_buffer_addr(fcode_env_t *env)
{
	PUSH(DS, (fstack_t)(env->fcode_buffer));
}

#pragma init(_init)

static void
_init(void)
{
	fcode_env_t *env = initial_env;

	ASSERT(env);
	NOTICE;

	P1275(0x000, DEFINER,	"end0",			end0);
	P1275(0x010, DEFINER,	"b(lit)",		blit);
	P1275(0x011, DEFINER,	"b(')",			btick);
	P1275(0x012, DEFINER,	"b(\")",		bquote);
	P1275(0x013, DEFINER,	"bbranch",		bbranch);
	P1275(0x014, DEFINER,	"b?branch",		bqbranch);
	P1275(0x015, DEFINER,	"b(loop)",		bloop);
	P1275(0x016, DEFINER,	"b(+loop)",		bplusloop);
	P1275(0x017, DEFINER,	"b(do)",		bdo);
	P1275(0x018, DEFINER,	"b(?do)",		bqdo);
	P1275(0x01b, DEFINER,	"b(leave)",		bleave);
	P1275(0x01c, DEFINER,	"b(of)",		bof);

	P1275(0x087, 0,		"fcode-revision",	fcode_revision);

	P1275(0x08b, 0,		"alloc-mem",		alloc_mem);
	P1275(0x08c, 0,		"free-mem",		free_mem);

	P1275(0x0a4, 0,		"-1",			minus_one);
	P1275(0x0a5, 0,		"0",			zero);
	P1275(0x0a6, 0,		"1",			one);
	P1275(0x0a7, 0,		"2",			two);
	P1275(0x0a8, 0,		"3",			three);

	P1275(0x0ae, 0,		"aligned",		aligned);
	P1275(0x0b1, DEFINER,	"b(<mark)",		bmark);
	P1275(0x0b2, DEFINER,	"b(>resolve)",		bresolve);
	FCODE(0x0b3, 0,		"set-token-table",	fc_historical);
	FCODE(0x0b4, 0,		"set-table",		fc_historical);
	P1275(0x0b5, 0,		"new-token",		new_token);
	P1275(0x0b6, 0,		"named-token",		named_token);
	P1275(0x0b7, DEFINER,	"b(:)",			bcolon);
	P1275(0x0b8, DEFINER,	"b(value)",		bvalue);
	P1275(0x0b9, DEFINER,	"b(variable)",		bvariable);
	P1275(0x0ba, DEFINER,	"b(constant)",		bconstant);
	P1275(0x0bb, DEFINER,	"b(create)",		bcreate);
	P1275(0x0bc, DEFINER,	"b(defer)",		bdefer);
	P1275(0x0bd, 0,		"b(buffer:)",		bbuffer_colon);
	P1275(0x0be, 0,		"b(field)",		bfield);
	FCODE(0x0bf, 0,		"b(code)",		fc_historical);
	P1275(0x0c0, IMMEDIATE,	"instance",		instance);

	P1275(0x0c2, DEFINER,	"b(;)",			semi);
	P1275(0x0c3, DEFINER,	"b(to)",		bto);
	P1275(0x0c4, DEFINER,	"b(case)",		bcase);
	P1275(0x0c5, DEFINER,	"b(endcase)",		bendcase);
	P1275(0x0c6, DEFINER,	"b(endof)",		bendof);

	P1275(0x0ca, 0,		"external-token",	external_token);
	P1275(0x0cc, 0,		"offset16",		offset16);
	P1275(0x0cd, 0,		"evaluate",		evaluate);

	P1275(0x0da, 0,		"get-token",		get_token);
	P1275(0x0db, 0,		"set-token",		set_token);

	P1275(0x0f0, 0,		"start0",		start0);
	P1275(0x0f1, 0,		"start1",		start1);
	P1275(0x0f2, 0,		"start2",		start2);
	P1275(0x0f3, 0,		"start4",		start4);

	P1275(0x0fd, 0,		"version1",		version1);
	FCODE(0x0fe, 0,		"4-byte-id",		fc_historical);

	P1275(0x0ff, 0,		"end1",			end1);

	/* Call it "old-dma-alloc" so no one gets confused */
	FCODE(0x101, 0,		"old-dma-alloc",	fc_historical);

	FCODE(0x104, 0,		"memmap",		fc_historical);
	FCODE(0x105, 0,		"free-virtual",		fc_unimplemented);

	FCODE(0x106, 0,		">physical",		fc_historical);

	FCODE(0x10f, 0,		"my-params",		fc_historical);

	P1275(0x11b, 0,		"parse-2int",		parse_two_int);

	FCODE(0x122, 0,		"memory-test-suite",	fc_unimplemented);
	FCODE(0x123, 0,		"group-code",		fc_historical);
	FCODE(0x124, 0,		"mask",			fc_unimplemented);

	FCODE(0x130, 0,		"map-low",		fc_unimplemented);
	FCODE(0x131, 0,		"sbus-intr>cpu",	fc_unimplemented);

	FCODE(0x170, 0,		"fb1-draw-character",	fc_historical);
	FCODE(0x171, 0,		"fb1-reset-screen",	fc_historical);
	FCODE(0x172, 0,		"fb1-toggle-cursor",	fc_historical);
	FCODE(0x173, 0,		"fb1-erase-screen",	fc_historical);
	FCODE(0x174, 0,		"fb1-blink-screen",	fc_historical);
	FCODE(0x175, 0,		"fb1-invert-screen",	fc_historical);
	FCODE(0x176, 0,		"fb1-insert-characters",	fc_historical);
	FCODE(0x177, 0,		"fb1-delete-characters",	fc_historical);
	FCODE(0x178, 0,		"fb1-insert-lines",	fc_historical);
	FCODE(0x179, 0,		"fb1-delete-lines",	fc_historical);
	FCODE(0x17a, 0,		"fb1-draw-logo",	fc_historical);
	FCODE(0x17b, 0,		"fb1-install",		fc_historical);
	FCODE(0x17c, 0,		"fb1-slide-up",		fc_historical);

	FCODE(0x190, 0,		"VME-bus Support",	fc_obsolete);
	FCODE(0x191, 0,		"VME-bus Support",	fc_obsolete);
	FCODE(0x192, 0,		"VME-bus Support",	fc_obsolete);
	FCODE(0x193, 0,		"VME-bus Support",	fc_obsolete);
	FCODE(0x194, 0,		"VME-bus Support",	fc_obsolete);
	FCODE(0x195, 0,		"VME-bus Support",	fc_obsolete);
	FCODE(0x196, 0,		"VME-bus Support",	fc_obsolete);

	FCODE(0x1a0, 0,		"return-buffer",	fc_historical);
	FCODE(0x1a1, 0,		"xmit-packet",		fc_historical);
	FCODE(0x1a2, 0,		"poll-packet",		fc_historical);

	FCODE(0x210, 0,		"processor-type",	fc_historical);
	FCODE(0x211, 0,		"firmware-version",	fc_historical);
	FCODE(0x212, 0,		"fcode-version",	fc_historical);

	FCODE(0x214, 0,		"(is-user-word)",	is_user_word);
	FCODE(0x215, 0,		"suspend-fcode",	fc_unimplemented);

	FCODE(0x229, 0,		"adr-mask",		fc_historical);

	FCODE(0x238, 0,		"probe",		fc_historical);
	FCODE(0x239, 0,		"probe-virtual",	fc_historical);

	P1275(0x23e, 0,		"byte-load",		byte_load);

	P1275(0x240, 0,		"left-parse-string",	left_parse_string);
	FORTH(0,		"fcode-buffer",		fcode_buffer_addr);
}