fgen from NetBSD

4 files changed, 2220 insertions, 0 deletions

diff --git a/usr.bin/fgen/Makefile b/usr.bin/fgen/Makefile
new file mode 100644
index 00000000000..9bc76aacb16
--- /dev/null
+++ b/usr.bin/fgen/Makefile
@@ -0,0 +1,9 @@
+#	$OpenBSD: Makefile,v 1.1 2001/08/17 21:31:02 jason Exp $
+#	$NetBSD: Makefile,v 1.4 2000/07/03 02:51:16 matt Exp $
+
+CPPFLAGS+= -I${.CURDIR}
+PROG=	fgen
+SRCS=	fgen.l
+MAN=	fgen.1
+
+.include <bsd.prog.mk>
diff --git a/usr.bin/fgen/fgen.1 b/usr.bin/fgen/fgen.1
new file mode 100644
index 00000000000..3c8d8a44a9d
--- /dev/null
+++ b/usr.bin/fgen/fgen.1
@@ -0,0 +1,75 @@
+.\"	$OpenBSD: fgen.1,v 1.1 2001/08/17 21:31:02 jason Exp $
+.\"	$NetBSD: fgen.1,v 1.6 2001/06/13 10:46:05 wiz Exp $
+.\"
+.\" Copyright (c) 1998 Eduardo Horvath, All Rights Reserved.
+.\"
+.\" 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.
+.\" 3. All advertising materials mentioning features or use of this software
+.\"    must display the following acknowledgement:
+.\"      This product includes software developed by Eduardo Horvath.
+.\" 4. The name of the author may not be used to endorse or promote products
+.\"    derived from this software without specific prior written permission
+.\"
+.\" THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 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.
+.\"
+.\" The following requests are required for all man pages.
+.Dd October 31, 1998
+.Dt FGEN 1
+.Os
+.Sh NAME
+.Nm fgen
+.Nd IEEE 1275 Open Firmware FCode Tokenizer
+.Sh SYNOPSIS
+.Nm
+.Op Fl d Ar level
+.Op Fl o Ar outfile
+.Ar infile
+.Sh DESCRIPTION
+Reads Forth source and generates tokenized FCode object file.
+.\" This next request is for sections 1, 6, 7 & 8 only
+.\" .Sh ENVIRONMENT
+.\" .Sh FILES
+.\" .Sh EXAMPLES
+.\" This next request is for sections 1, 6, 7 & 8 only
+.\"     (command return values (to shell) and fprintf/stderr type diagnostics)
+.\" .Sh DIAGNOSTICS
+.\" .Sh ERRORS
+.\" .Sh SEE ALSO
+.\" Cross-references should be ordered by section (low to high), then in
+.\"     alphabetical order.
+.\" .Sh STANDARDS
+.\" .Sh HISTORY
+.Sh AUTHORS
+Written by Eduardo E. Horvath <eeh@one-o.com>
+.Sh BUGS
+String escape sequences are not recognized so things such as 
+.Pp
+.Li \&" foo \&"\&(01 02\&) \&"n \&"
+.Pp
+will result in the string
+.Pp
+.Dq  foo \&"\&(01 02\&) \&"n .
+.Pp
+Hexadecimal numbers with dots in them such as 
+.Li 100.0000 
+are not parsed.
+.Pp
+Permissions on the output file are often incorrect.
+.Pp
+Output to the standard output device can cause problems.
diff --git a/usr.bin/fgen/fgen.h b/usr.bin/fgen/fgen.h
new file mode 100644
index 00000000000..45ee349b4a7
--- /dev/null
+++ b/usr.bin/fgen/fgen.h
@@ -0,0 +1,136 @@
+/*	$OpenBSD: fgen.h,v 1.1 2001/08/17 21:31:02 jason Exp $	*/
+/*	$NetBSD: fgen.h,v 1.4 2001/06/13 10:46:05 wiz Exp $	*/
+/*
+ * fgen.h -- stuff for the fcode tokenizer.
+ *
+ * Copyright (c) 1998 Eduardo Horvath.
+ * All rights reserved.
+ *
+ * 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.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *      This product includes software developed by Eduardo Horvath.
+ * 4. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 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.
+ */
+
+/* Type of a Cell */
+typedef long Cell;
+
+/* Token from the scanner. */
+struct tok {
+	int type;
+	char *text;
+};
+
+#define TOKEN struct tok
+#define YY_DECL TOKEN* yylex __P((void))
+
+#define FCODE	0xF00DBABE
+#define MACRO	0xFEEDBABE
+
+/* Defined fcode and string. */
+struct fcode {
+	char *name;
+	long num;
+	int type;
+	struct fcode *l;
+	struct fcode *r;
+};
+
+/* macro instruction as separate words */
+struct macro {
+	char *name;
+	char *equiv;
+	int type;
+	struct macro *l;
+	struct macro *r;
+};
+
+/*
+ * FCode header -- assumes big-endian machine, 
+ *	otherwise the bits need twiddling.
+ */
+struct fcode_header {
+	char	header;
+	char	format;
+	short	checksum;
+	int	length;
+};
+
+/* Tokenizer tokens */
+enum toktypes { 
+	TOK_OCTAL = 8,
+	TOK_DECIMAL = 10,
+	TOK_HEX = 16,
+
+	TOK_NUMBER, 
+	TOK_STRING_LIT, 
+	TOK_C_LIT,
+	TOK_PSTRING, 
+	TOK_TOKENIZE,
+	TOK_COMMENT, 
+	TOK_ENDCOMMENT,
+	TOK_COLON, 
+	TOK_SEMICOLON, 
+	TOK_TOSTRING,
+	
+	/* These are special */
+	TOK_AGAIN,
+	TOK_ALIAS,
+	TOK_GETTOKEN,
+	TOK_ASCII,
+	TOK_BEGIN,
+	TOK_BUFFER,
+	TOK_CASE,
+	TOK_CONSTANT,
+	TOK_CONTROL,
+	TOK_CREATE,
+	TOK_DEFER,
+	TOK_DO,
+	TOK_ELSE,
+	TOK_ENDCASE,
+	TOK_ENDOF,
+	TOK_EXTERNAL,
+	TOK_FIELD,
+	TOK_HEADERLESS,
+	TOK_HEADERS,
+	TOK_IF,
+	TOK_LEAVE,
+	TOK_LOOP,
+	TOK_OF,
+	TOK_REPEAT,
+	TOK_THEN,
+	TOK_TO,
+	TOK_UNTIL,
+	TOK_VALUE,
+	TOK_VARIABLE,
+	TOK_WHILE,
+	TOK_OFFSET16,
+
+	/* Tokenizer directives */
+	TOK_BEGTOK,
+	TOK_EMIT_BYTE,
+	TOK_ENDTOK,
+	TOK_FLOAD,
+
+	TOK_OTHER
+};
diff --git a/usr.bin/fgen/fgen.l b/usr.bin/fgen/fgen.l
new file mode 100644
index 00000000000..a2057cf930d
--- /dev/null
+++ b/usr.bin/fgen/fgen.l
@@ -0,0 +1,2000 @@
+%{
+/*	$OpenBSD: fgen.l,v 1.1 2001/08/17 21:31:02 jason Exp $	*/
+/*	$NetBSD: fgen.l,v 1.12 2001/06/13 10:46:05 wiz Exp $	*/
+/* FLEX input for FORTH input file scanner */
+/*  
+ * Copyright (c) 1998 Eduardo Horvath.
+ * All rights reserved.
+ *
+ * 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.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *      This product includes software developed by Eduardo Horvath.
+ * 4. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 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.
+ */
+/*
+	Specifications are as follows:
+
+	The function "yylex()" always returns a pointer to a structure:
+
+	    struct tok {
+		int type;
+		char *text;
+	    }
+	    #define TOKEN struct tok
+*/
+%}
+
+%option yylineno
+
+decimal	[0-9]
+hex	[0-9A-Fa-f]
+octal	[0-7]
+white	[ \t\n\r\f]
+tail	{white}
+
+%{
+#include <sys/types.h>
+
+#include <assert.h>
+#include <err.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+
+#include "fgen.h"
+TOKEN token;
+
+/*
+ * Global variables that control the parse state.
+ */
+
+struct fcode *dictionary = NULL;
+struct macro *aliases = NULL;
+int outf = 1; /* stdout */
+int state = 0;
+int nextfcode = 0x800; 
+int base = TOK_HEX;
+long outpos;
+char *outbuf = NULL;
+char *outfile, *infile;
+#define BUFCLICK	(1024*1024)
+size_t outbufsiz = 0;
+char *myname = NULL;
+int offsetsize = 8;
+int defining = 0;
+int tokenizer = 0;
+
+#define PSTKSIZ		1024
+Cell parse_stack[PSTKSIZ];
+int parse_stack_ptr = 0;
+
+void	token_err __P((int, char *, char *, char *, ...))
+	__attribute__((__format__(__printf__, 4, 5)));
+YY_DECL;
+
+int debug = 0;
+#define ASSERT if (debug) assert
+#define STATE(y, x)	do { if (debug) printf( "%ld State %s: token `%s'\n", outpos, x, y); } while (0)
+
+#define YY_NO_UNPUT
+%}
+
+%%
+
+0			{ token.type = TOK_OTHER; token.text = yytext;
+				return &token; }
+
+1			{ token.type = TOK_OTHER; token.text = yytext;
+				return &token; }
+
+2			{ token.type = TOK_OTHER; token.text = yytext;
+				return &token; }
+
+3			{ token.type = TOK_OTHER; token.text = yytext;
+				return &token; }
+
+-1		{ token.type = TOK_OTHER; token.text = yytext;
+				return &token; }
+
+{white}*		/* whitespace -- keep looping */ ;
+
+\\[^\n]*\n		/* end of line comment -- keep looping */ { STATE(yytext, "EOL comment"); }
+
+-?{hex}+		{ token.type = TOK_NUMBER; token.text = yytext;
+					return &token; }
+
+\'.\'		{ token.type = TOK_C_LIT; token.text = yytext; return &token; }
+
+\"{white}*(\\\"|[^"])*\"	{ token.type = TOK_STRING_LIT; token.text = yytext; 
+				return &token; } /* String started by `"' or `."' */
+
+\.\({white}*(\\\"|[^)])*\)	{ token.type = TOK_PSTRING; token.text = yytext; 
+				return &token; } /* String of type `.(.....)' */
+
+\.\"{white}*(\\\"|[^"])*\"	{ token.type = TOK_PSTRING; token.text = yytext; 
+				return &token; }
+
+"("		{ token.type = TOK_COMMENT; token.text = yytext;
+				return &token; }
+
+")"		{ token.type = TOK_ENDCOMMENT; token.text = yytext;
+				return &token; }
+
+":"		{ token.type = TOK_COLON; token.text = yytext;
+				return &token; }
+
+";"		{ token.type = TOK_SEMICOLON; token.text = yytext;
+				return &token; }
+
+\'		{ token.type = TOK_TOKENIZE; token.text = yytext;
+				return &token; }
+
+[aA][gG][aA][iI][nN]	{ token.type = TOK_AGAIN; token.text = yytext;
+				return &token; }
+
+[aA][lL][iI][aA][sS]	{ token.type = TOK_ALIAS; token.text = yytext;
+				return &token; }
+
+\[\'\]			{ token.type = TOK_GETTOKEN; token.text = yytext;
+				return &token; }
+
+[aA][sS][cC][iI][iI]	{ token.type = TOK_ASCII; token.text = yytext;
+				return &token; }
+
+[bB][eE][gG][iI][nN]	{ token.type = TOK_BEGIN; token.text = yytext;
+				return &token; }
+
+[bB][uU][fF][fF][eE][rR]:	{ token.type = TOK_BUFFER; token.text = yytext;
+				return &token; }
+
+[cC][aA][sS][eE]	{ token.type = TOK_CASE; token.text = yytext;
+				return &token; }
+
+[cC][oO][nN][sS][tT][aA][nN][tT]	{ token.type = TOK_CONSTANT; token.text = yytext;
+				return &token; }
+
+[cC][oO][nN][tT][rR][oO][lL]	{ token.type = TOK_CONTROL; token.text = yytext;
+				return &token; }
+
+[cC][rR][eE][aA][tT][eE]	{ token.type = TOK_CREATE; token.text = yytext;
+				return &token; }
+
+[dD]#		{ token.type = TOK_DECIMAL; token.text = yytext;
+				return &token; }
+
+[dD][eE][cC][iI][mM][aA][lL]	{ token.type = TOK_DECIMAL; token.text = yytext;
+				return &token; }
+
+[dD][eE][fF][eE][rR]	{ token.type = TOK_DEFER; token.text = yytext;
+				return &token; }
+
+\??[dD][oO]	{ token.type = TOK_DO; token.text = yytext;
+				return &token; }
+
+[eE][lL][sS][eE]	{ token.type = TOK_ELSE; token.text = yytext;
+				return &token; }
+
+[eE][nN][dD][cC][aA][sS][eE]	{ token.type = TOK_ENDCASE; token.text = yytext;
+				return &token; }
+
+[eE][nN][dD][oO][fF]	{ token.type = TOK_ENDOF; token.text = yytext;
+				return &token; }
+
+[eE][xX][tT][eE][rR][nN][aA][lL]	{ token.type = TOK_EXTERNAL; token.text = yytext;
+				return &token; }
+
+[fF][iI][eE][lL][dD]	{ token.type = TOK_FIELD; token.text = yytext;
+				return &token; }
+
+[hH]#		{ token.type = TOK_HEX; token.text = yytext;
+				return &token; }
+
+[hH][eE][aA][dD][eE][rR][lL][eE][sS][sS]	{ token.type = TOK_HEADERLESS; token.text = yytext;
+				return &token; }
+
+[hH][eE][aA][dD][eE][rR][sS]	{ token.type = TOK_HEADERS; token.text = yytext;
+				return &token; }
+
+[hH][eE][xX]	{ token.type = TOK_HEX; token.text = yytext;
+				return &token; }
+
+[iI][fF]		{ token.type = TOK_IF; token.text = yytext;
+				return &token; }
+
+\??[lL][eE][aA][vV][eE]	{ token.type = TOK_LEAVE; token.text = yytext;
+				return &token; }
+
+\+?[lL][oO][oO][pP]	{ token.type = TOK_LOOP; token.text = yytext;
+				return &token; }
+
+[oO]#		{ token.type = TOK_OCTAL; token.text = yytext;
+				return &token; }
+
+[oO][cC][tT][aA][lL]	{ token.type = TOK_OCTAL; token.text = yytext;
+				return &token; }
+
+[oO][fF]		{ token.type = TOK_OF; token.text = yytext;
+				return &token; }
+
+[rR][eE][pP][eE][aA][tT]	{ token.type = TOK_REPEAT; token.text = yytext;
+				return &token; }
+
+[tT][hH][eE][nN]	{ token.type = TOK_THEN; token.text = yytext;
+				return &token; }
+
+[tT][oO]		{ token.type = TOK_TO; token.text = yytext;
+				return &token; }
+
+[uU][nN][tT][iI][lL]	{ token.type = TOK_UNTIL; token.text = yytext;
+				return &token; }
+
+[vV][aA][lL][uU][eE]	{ token.type = TOK_VALUE; token.text = yytext;
+				return &token; }
+
+[vV][aA][rR][iI][aA][bB][lL][eE]	{ token.type = TOK_VARIABLE; token.text = yytext;
+				return &token; }
+
+[wW][hH][iI][lL][eE]	{ token.type = TOK_WHILE; token.text = yytext;
+				return &token; }
+
+offset16		{ token.type = TOK_OFFSET16; token.text = yytext;
+				return &token; }
+
+tokenizer\[	{ token.type = TOK_BEGTOK; token.text = yytext;
+				return &token; }
+
+emit-byte		{ token.type = TOK_EMIT_BYTE; token.text = yytext;
+				return &token; }
+
+\]tokenizer	{ token.type = TOK_ENDTOK; token.text = yytext;
+				return &token; }
+
+fload		{ token.type = TOK_FLOAD; token.text = yytext;
+				return &token; }
+
+
+[^ \n\t\r\f]+	{ token.type = TOK_OTHER; token.text = yytext;
+				return &token; }
+
+<<EOF>>			{ return NULL; }
+%%
+
+/* Function definitions */
+void push __P((Cell));
+Cell pop __P((void));
+int depth __P((void));
+int fadd __P((struct fcode *, struct fcode *));
+struct fcode *flookup __P((struct fcode *, char *));
+int aadd __P((struct macro *, struct macro *));
+struct macro *alookup __P((struct macro *, char *));
+void initdic __P((void));
+void usage __P((char *));
+void tokenize __P((YY_BUFFER_STATE));
+int emit __P((char *));
+int spit __P((long));
+void sspit __P((char *));
+int apply_macros __P((YY_BUFFER_STATE, char *));
+int main __P((int argc, char *argv[]));
+
+/*
+ * Standard FCode names and numbers.  Includes standard
+ * tokenizer aliases.
+ */
+struct fcode fcodes[] = {
+		{ "end0",			0x0000 },
+		{ "b(lit)",			0x0010 },
+		{ "b(')",			0x0011 },
+		{ "b(\")",			0x0012 },
+		{ "bbranch",			0x0013 },
+		{ "b?branch",			0x0014 },
+		{ "b(loop)",			0x0015 },
+		{ "b(+loop)",			0x0016 },
+		{ "b(do)",			0x0017 },
+		{ "b(?do)",			0x0018 },
+		{ "i",				0x0019 },
+		{ "j",				0x001a },
+		{ "b(leave)",			0x001b },
+		{ "b(of)",			0x001c },
+		{ "execute",			0x001d },
+		{ "+",				0x001e },
+		{ "-",				0x001f },
+		{ "*",				0x0020 },
+		{ "/",				0x0021 },
+		{ "mod",			0x0022 },
+		{ "and",			0x0023 },
+		{ "or",				0x0024 },
+		{ "xor",			0x0025 },
+		{ "invert",			0x0026 },
+		{ "lshift",			0x0027 },
+		{ "rshift",			0x0028 },
+		{ ">>a",			0x0029 },
+		{ "/mod",			0x002a },
+		{ "u/mod",			0x002b },
+		{ "negate",			0x002c },
+		{ "abs",			0x002d },
+		{ "min",			0x002e },
+		{ "max",			0x002f },
+		{ ">r",				0x0030 },
+		{ "r>",				0x0031 },
+		{ "r@",				0x0032 },
+		{ "exit",			0x0033 },
+		{ "0=",				0x0034 },
+		{ "0<>",			0x0035 },
+		{ "0<",				0x0036 },
+		{ "0<=",			0x0037 },
+		{ "0>",				0x0038 },
+		{ "0>=",			0x0039 },
+		{ "<",				0x003a },
+		{ ">",				0x003b },
+		{ "=",				0x003c },
+		{ "<>",				0x003d },
+		{ "u>",				0x003e },
+		{ "u<=",			0x003f },
+		{ "u<",				0x0040 },
+		{ "u>=",			0x0041 },
+		{ ">=",				0x0042 },
+		{ "<=",				0x0043 },
+		{ "between",			0x0044 },
+		{ "within",			0x0045 },
+		{ "drop",			0x0046 },
+		{ "dup",			0x0047 },
+		{ "over",			0x0048 },
+		{ "swap",			0x0049 },
+		{ "rot",			0x004a },
+		{ "-rot",			0x004b },
+		{ "tuck",			0x004c },
+		{ "nip",			0x004d },
+		{ "pick",			0x004e },
+		{ "roll",			0x004f },
+		{ "?dup",			0x0050 },
+		{ "depth",			0x0051 },
+		{ "2drop",			0x0052 },
+		{ "2dup",			0x0053 },
+		{ "2over",			0x0054 },
+		{ "2swap",			0x0055 },
+		{ "2rot",			0x0056 },
+		{ "2/",				0x0057 },
+		{ "u2/",			0x0058 },
+		{ "2*",				0x0059 },
+		{ "/c",				0x005a },
+		{ "/w",				0x005b },
+		{ "/l",				0x005c },
+		{ "/n",				0x005d },
+		{ "ca+",			0x005e },
+		{ "wa+",			0x005f },
+		{ "la+",			0x0060 },
+		{ "na+",			0x0061 },
+		{ "char+",			0x0062 },
+		{ "wa1+",			0x0063 },
+		{ "la1+",			0x0064 },
+		{ "cell+",			0x0065 },
+		{ "chars",			0x0066 },
+		{ "/w*",			0x0067 },
+		{ "/l*",			0x0068 },
+		{ "cells",			0x0069 },
+		{ "on",				0x006a },
+		{ "off",			0x006b },
+		{ "+!",				0x006c },
+		{ "@",				0x006d },
+		{ "l@",				0x006e },
+		{ "w@",				0x006f },
+		{ "<w@",			0x0070 },
+		{ "c@",				0x0071 },
+		{ "!",				0x0072 },
+		{ "l!",				0x0073 },
+		{ "w!",				0x0074 },
+		{ "c!",				0x0075 },
+		{ "2@",				0x0076 },
+		{ "2!",				0x0077 },
+		{ "move",			0x0078 },
+		{ "fill",			0x0079 },
+		{ "comp",			0x007a },
+		{ "noop",			0x007b },
+		{ "lwsplit",			0x007c },
+		{ "wjoin",			0x007d },
+		{ "lbsplit",			0x007e },
+		{ "bljoin",			0x007f },
+		{ "wbflip",			0x0080 },
+		{ "upc",			0x0081 },
+		{ "lcc",			0x0082 },
+		{ "pack",			0x0083 },
+		{ "count",			0x0084 },
+		{ "body>",			0x0085 },
+		{ ">body",			0x0086 },
+		{ "fcode-revision",		0x0087 },
+		{ "span",			0x0088 },
+		{ "unloop",			0x0089 },
+		{ "expect",			0x008a },
+		{ "alloc-mem",			0x008b },
+		{ "free-mem",			0x008c },
+		{ "key?",			0x008d },
+		{ "key",			0x008e },
+		{ "emit",			0x008f },
+		{ "type",			0x0090 },
+		{ "(cr",			0x0091 },
+		{ "cr",				0x0092 },
+		{ "#out",			0x0093 },
+		{ "#line",			0x0094 },
+		{ "hold",			0x0095 },
+		{ "<#",				0x0096 },
+		{ "u#>",			0x0097 },
+		{ "sign",			0x0098 },
+		{ "u#",				0x0099 },
+		{ "u#s",			0x009a },
+		{ "u.",				0x009b },
+		{ "u.r",			0x009c },
+		{ ".",				0x009d },
+		{ ".r",				0x009e },
+		{ ".s",				0x009f },
+		{ "base",			0x00a0 },
+		{ "convert",			0x00a1 },
+		{ "$number",			0x00a2 },
+		{ "digit",			0x00a3 },
+		{ "-1",				0x00a4 },
+		{ "true",			0x00a4 },
+		{ "0",				0x00a5 },
+		{ "1",				0x00a6 },
+		{ "2",				0x00a7 },
+		{ "3",				0x00a8 },
+		{ "bl",				0x00a9 },
+		{ "bs",				0x00aa },
+		{ "bell",			0x00ab },
+		{ "bounds",			0x00ac },
+		{ "here",			0x00ad },
+		{ "aligned",			0x00ae },
+		{ "wbsplit",			0x00af },
+		{ "bwjoin",			0x00b0 },
+		{ "b(<mark)",			0x00b1 },
+		{ "b(>resolve)",		0x00b2 },
+		{ "set-token-table",		0x00b3 },
+		{ "set-table",			0x00b4 },
+		{ "new-token",			0x00b5 },
+		{ "named-token",		0x00b6 },
+		{ "b(:)",			0x00b7 },
+		{ "b(value)",			0x00b8 },
+		{ "b(variable)",		0x00b9 },
+		{ "b(constant)",		0x00ba },
+		{ "b(create)",			0x00bb },
+		{ "b(defer)",			0x00bc },
+		{ "b(buffer:)",			0x00bd },
+		{ "b(field)",			0x00be },
+		{ "b(code)",			0x00bf },
+		{ "instance",			0x00c0 },
+		{ "b(;)",			0x00c2 },
+		{ "b(to)",			0x00c3 },
+		{ "b(case)",			0x00c4 },
+		{ "b(endcase)",			0x00c5 },
+		{ "b(endof)",			0x00c6 },
+		{ "#",				0x00c7 },
+		{ "#s",				0x00c8 },
+		{ "#>",				0x00c9 },
+		{ "external-token",		0x00ca },
+		{ "$find",			0x00cb },
+		{ "offset16",			0x00cc },
+		{ "evaluate",			0x00cd },
+		{ "c,",				0x00d0 },
+		{ "w,",				0x00d1 },
+		{ "l,",				0x00d2 },
+		{ "'",				0x00d3 },
+		{ "um*",			0x00d4 },
+		{ "um/mod",			0x00d5 },
+		{ "d+",				0x00d8 },
+		{ "d-",				0x00d9 },
+		{ "get-token",			0x00da },
+		{ "set-token",			0x00db },
+		{ "state",			0x00dc },
+		{ "compile,",			0x00dd },
+		{ "behavior",			0x00de },
+		{ "start0",			0x00f0 },
+		{ "start1",			0x00f1 },
+		{ "start2",			0x00f2 },
+		{ "start4",			0x00f3 },
+		{ "ferror",			0x00fc },
+		{ "version1",			0x00fd },
+		{ "4-byte-id",			0x00fe },
+		{ "end1",			0x00ff },
+		{ "dma-alloc",			0x0101 },
+		{ "my-address",			0x0102 },
+		{ "my-space",			0x0103 },
+		{ "memmap",			0x0104 },
+		{ "free-virtual",		0x0105 },
+		{ ">physical",			0x0106 },
+		{ "my-params",			0x010f },
+		{ "property",			0x0110 },
+		{ "encode-int",			0x0111 },
+		{ "encode+",			0x0112 },
+		{ "encode-phys",		0x0113 },
+		{ "encode-string",		0x0114 },
+		{ "encode-bytes",		0x0115 },
+		{ "reg",			0x0116 },
+		{ "intr",			0x0117 },
+		{ "driver",			0x0118 },
+		{ "model",			0x0119 },
+		{ "device-type",		0x011a },
+		{ "parse-2int",			0x011b },
+		{ "is-install",			0x011c },
+		{ "is-remove",			0x011d },
+		{ "is-selftest",		0x011e },
+		{ "new-device",			0x011f },
+		{ "diagnostic-mode?",		0x0120 },
+		{ "display-status",		0x0121 },
+		{ "memory-test-suite",		0x0122 },
+		{ "group-code",			0x0123 },
+		{ "mask",			0x0124 },
+		{ "get-msecs",			0x0125 },
+		{ "ms",				0x0126 },
+		{ "find-device",		0x0127 },
+		{ "decode-phys",		0x0128 },
+		{ "map-low",			0x0130 },
+		{ "sbus-intr>cpu",		0x0131 },
+		{ "#lines",			0x0150 },
+		{ "#columns",			0x0151 },
+		{ "line#",			0x0152 },
+		{ "column#",			0x0153 },
+		{ "inverse?",			0x0154 },
+		{ "inverse-screen?",		0x0155 },
+		{ "frame-buffer-busy?",		0x0156 },
+		{ "draw-character",		0x0157 },
+		{ "reset-screen",		0x0158 },
+		{ "toggle-cursor",		0x0159 },
+		{ "erase-screen",		0x015a },
+		{ "blink-screen",		0x015b },
+		{ "invert-screen",		0x015c },
+		{ "insert-characters",		0x015d },
+		{ "delete-characters",		0x015e },
+		{ "insert-lines",		0x015f },
+		{ "delete-lines",		0x0160 },
+		{ "draw-logo",			0x0161 },
+		{ "frame-buffer-addr",		0x0162 },
+		{ "screen-height",		0x0163 },
+		{ "screen-width",		0x0164 },
+		{ "window-top",			0x0165 },
+		{ "window-left",		0x0166 },
+		{ "default-font",		0x016a },
+		{ "set-font",			0x016b },
+		{ "char-height",		0x016c },
+		{ "char-width",			0x016d },
+		{ ">font",			0x016e },
+		{ "fontbytes",			0x016f },
+		{ "fb8-draw-character",		0x0180 },
+		{ "fb8-reset-screen",		0x0181 },
+		{ "fb8-toggle-cursor",		0x0182 },
+		{ "fb8-erase-screen",		0x0183 },
+		{ "fb8-blink-screen",		0x0184 },
+		{ "fb8-invert-screen",		0x0185 },
+		{ "fb8-insert-characters",	0x0186 },
+		{ "fb8-delete-characters",	0x0187 },
+		{ "fb8-inisert-lines",		0x0188 },
+		{ "fb8-delete-lines",		0x0189 },
+		{ "fb8-draw-logo",		0x018a },
+		{ "fb8-install",		0x018b },
+		{ "return-buffer",		0x01a0 },
+		{ "xmit-packet",		0x01a1 },
+		{ "poll-packet",		0x01a2 },
+		{ "mac-address",		0x01a4 },
+		{ "device-name",		0x0201 },
+		{ "my-args",			0x0202 },
+		{ "my-self",			0x0203 },
+		{ "find-package",		0x0204 },
+		{ "open-package",		0x0205 },
+		{ "close-package",		0x0206 },
+		{ "find-method",		0x0207 },
+		{ "call-package",		0x0208 },
+		{ "$call-parent",		0x0209 },
+		{ "my-parent",			0x020a },
+		{ "ihandle>phandle",		0x020b },
+		{ "my-unit",			0x020d },
+		{ "$call-method",		0x020e },
+		{ "$open-package",		0x020f },
+		{ "processor-type",		0x0210 },
+		{ "firmware-version",		0x0211 },
+		{ "fcode-version",		0x0212 },
+		{ "alarm",			0x0213 },
+		{ "(is-user-word)",		0x0214 },
+		{ "suspend-fcode",		0x0215 },
+		{ "abort",			0x0216 },
+		{ "catch",			0x0217 },
+		{ "throw",			0x0218 },
+		{ "user-abort",			0x0219 },
+		{ "get-my-property",		0x021a },
+		{ "decode-int",			0x021b },
+		{ "decode-string",		0x021c },
+		{ "get-inherited-property",	0x021d },
+		{ "delete-property",		0x021e },
+		{ "get-package-property",	0x021f },
+		{ "cpeek",			0x0220 },
+		{ "wpeek",			0x0221 },
+		{ "lpeek",			0x0222 },
+		{ "cpoke",			0x0223 },
+		{ "wpoke",			0x0224 },
+		{ "lpoke",			0x0225 },
+		{ "lwflip",			0x0226 },
+		{ "lbflip",			0x0227 },
+		{ "lbflips",			0x0228 },
+		{ "adr-mask",			0x0229 },
+		{ "rb@",			0x0230 },
+		{ "rb!",			0x0231 },
+		{ "rw@",			0x0232 },
+		{ "rw!",			0x0233 },
+		{ "rl@",			0x0234 },
+		{ "rl!",			0x0235 },
+		{ "wbflips",			0x0236 },
+		{ "lwflips",			0x0237 },
+		{ "probe",			0x0238 },
+		{ "probe-virtual",		0x0239 },
+		{ "child",			0x023b },
+		{ "peer",			0x023c },
+		{ "next-property",		0x023d },
+		{ "byte-load",			0x023e },
+		{ "set-args",			0x023f },
+		{ "left-parse-string",		0x0240 },
+			/* 64-bit FCode extensions */
+		{ "bxjoin",			0x0241 },
+		{ "<l@",			0x0242 },
+		{ "lxjoin",			0x0243 },
+		{ "rx@",			0x022e },
+		{ "rx!",			0x022f },
+		{ "wxjoin",			0x0244 },
+		{ "x,",				0x0245 },
+		{ "x@",				0x0246 },
+		{ "x!",				0x0247 },
+		{ "/x",				0x0248 },
+		{ "/x*",			0x0249 },
+		{ "xa+",			0x024a },
+		{ "xa1+",			0x024b },
+		{ "xbflip",			0x024c },
+		{ "xbflips",			0x024d },
+		{ "xbsplit",			0x024e },
+		{ "xlflip",			0x024f },
+		{ "xlflips",			0x0250 },
+		{ "xlsplit",			0x0251 },
+		{ "xwflip",			0x0252 },
+		{ "xwflips",			0x0253 },
+		{ "xwsplit",			0x0254 },
+		{ NULL, NULL }
+};
+
+/*
+ * Default macros -- can be overridden by colon definitions.
+ */
+struct macro macros[] = {
+	{ "eval",	"evaluate" }, /* Build a more balanced tree */
+	{ "(.)",	"dup abs <# u#s swap sign u#>" },
+	{ "<<",		"lshift" },
+	{ ">>",		"rshift" },
+	{ "?",		"@ ." },
+	{ "1+",		"1 +" },
+	{ "1-",		"1 -" },
+	{ "2+",		"2 +" },
+	{ "2-",		"2 -" },
+	{ "abort\"",	"-2 throw" },
+	{ "accept",	"span @ -rot expect span @ swap span !" },
+	{ "allot",	"0 max 0 ?do 0 c, loop" },
+	{ "blank",	"bl fill" },
+	{ "/c*",	"chars" },
+	{ "ca1+",	"char+" },
+	{ "carret",	"b(lit) 00 00 00 0x0d" },
+	{ ".d"		"base @ swap 0x0a base ! . base !" },
+	{ "decode-bytes", ">r over r@ + swap r@ - rot r>" },
+	{ "3drop",	"drop 2drop" },
+	{ "3dup",	"2 pick 2 pick 2 pick" },
+	{ "erase",	"0 fill" },
+	{ "false",	"0" },
+	{ ".h"		"base @ swap 0x10 base ! . base !" },
+	{ "linefeed",	"b(lit) 00 00 00 0x0a" },
+	{ "/n*",	"cells" },
+	{ "na1+",	"cell+", },
+	{ "not",	"invert", },
+	{ "s.",		"(.) type space" },
+	{ "space",	"bl emit" },
+	{ "spaces",	"0 max 0 ?do space loop" },
+	{ "struct",	"0" },
+	{ "true",	"-1" },
+	{ "(u,)",	"<# u#s u#>" },
+	{ NULL, NULL }
+};
+
+/*
+ * Parser stack control functions.
+ */
+
+void
+push(val)
+Cell val;
+{
+	parse_stack[parse_stack_ptr++] = val;
+	if (parse_stack_ptr >= PSTKSIZ) {
+		(void)printf( "Parse stack overflow\n");
+		exit(1);
+	}
+}
+
+Cell
+pop()
+{
+	ASSERT(parse_stack_ptr);
+	return parse_stack[--parse_stack_ptr];
+}
+
+int
+depth()
+{
+	return (parse_stack_ptr);
+}
+
+/*
+ * Insert fcode into dictionary.
+ */
+int
+fadd(dict, new)
+struct fcode *dict, *new;
+{
+	int res = strcmp(dict->name, new->name);
+
+#ifdef DEBUG
+	new->type = FCODE;
+	ASSERT(dict->type == FCODE);
+#endif
+	/* Don't allow duplicate entries. */
+	if (!res) return (0);
+	if (res < 0) {
+		if (dict->l)
+			return fadd(dict->l, new);
+		else {
+#ifdef DEBUG
+			if (debug > 1)
+				(void)printf( "fadd: new FCode `%s' is %lx\n", 
+					      new->name, new->num);
+#endif
+			new->l = new->r = NULL;
+			dict->l = new;
+		}
+	} else {
+		if (dict->r)
+			return fadd(dict->r, new);
+		else {
+#ifdef DEBUG
+			if (debug > 1)
+				(void)printf( "fadd: new FCode `%s' is %lx\n", 
+					      new->name, new->num);
+#endif
+			new->l = new->r = NULL;
+			dict->r = new;
+		}
+	}
+	return (1);
+}
+
+/*
+ * Look for a code in the dictionary.
+ */
+struct fcode *
+flookup(dict, str)
+struct fcode *dict;
+char *str;
+{
+	int res;
+	if (!dict) return (dict);
+
+	res = strcmp(dict->name, str);
+#ifdef DEBUG
+	ASSERT(dict->type == FCODE);
+	if (debug > 2)
+		(void)printf( "flookup: `%s' and `%s' %s match\n", 
+			      str, dict->name, res?"don't":"do");
+#endif
+	if (!res) return (dict);
+	if (res < 0)
+		return (flookup(dict->l, str));
+	else 
+		return (flookup(dict->r, str));
+
+}
+
+/*
+ * Insert alias into macros.
+ */
+int
+aadd(dict, new)
+	struct macro *dict, *new;
+{
+	int res = strcmp(dict->name, new->name);
+
+#ifdef DEBUG
+	new->type = MACRO;
+	ASSERT(dict->type == MACRO);
+#endif
+	/* Don't allow duplicate entries. */
+	if (!res) return (0);
+	if (res < 0) {
+		if (dict->l)
+			return aadd(dict->l, new);
+		else {
+			new->l = new->r = NULL;
+			dict->l = new;
+#ifdef DEBUG
+			if (debug > 1)
+				(void)printf( "aadd: new alias `%s' to `%s'\n", 
+					      new->name, new->equiv);
+#endif
+		}
+	} else {
+		if (dict->r)
+			return aadd(dict->r, new);
+		else {
+			new->l = new->r = NULL;
+			dict->r = new;
+#ifdef DEBUG
+			if (debug > 1)
+				(void)printf( "aadd: new alias `%s' to `%s'\n", 
+					      new->name, new->equiv);
+#endif
+		}
+	}
+	return (1);
+}
+
+/*
+ * Look for a macro in the aliases.
+ */
+struct macro *
+alookup(dict, str)
+struct macro *dict;
+char *str;
+{
+	int res;
+	if (!dict) return (dict);
+
+#ifdef DEBUG
+	ASSERT(dict->type == MACRO);
+#endif
+	res = strcmp(dict->name, str);
+	if (!res) return (dict);
+	if (res < 0)
+		return (alookup(dict->l, str));
+	else 
+		return (alookup(dict->r, str));
+
+}
+
+/*
+ * Bootstrap the dictionary and then install
+ * all the standard FCodes.
+ */
+void
+initdic()
+{
+	struct fcode *code = fcodes;
+	struct macro *alias = macros;
+
+	ASSERT(dictionary == NULL);
+	code->l = code->r = NULL;
+	dictionary = code;
+#ifdef DEBUG
+	code->type = FCODE;
+#endif
+
+	while ((++code)->name) {
+		if(!fadd(dictionary, code)) {
+			printf("init: duplicate dictionary entry %s\n", 
+			       code->name);
+			abort();
+		}
+	}
+
+	ASSERT(aliases == NULL);
+	aliases = alias;
+	alias->l = alias->r = NULL;
+#ifdef DEBUG
+	alias->type = MACRO;
+#endif
+	while ((++alias)->name) {
+		if(!aadd(aliases, alias)) {
+			printf("init: duplicate macro entry %s\n", 
+			       alias->name);
+			abort();
+		}
+	}
+
+}
+
+int
+apply_macros(input, str) 
+	YY_BUFFER_STATE input;
+	char *str;
+{
+	struct macro *xform = alookup(aliases, str);
+	
+	if (xform) {
+		YY_BUFFER_STATE newbuf;
+
+		newbuf = yy_scan_string(xform->equiv);
+		yy_switch_to_buffer(newbuf);
+		tokenize(newbuf);
+		yy_switch_to_buffer(input);
+		yy_delete_buffer(newbuf);
+	}
+	return (xform != NULL);
+}
+
+void
+usage(me)
+	char *me;
+{
+	(void)fprintf(stderr, "%s: [-o <outfile>] <infile>\n", me);
+	exit(1);
+}
+
+int
+main(argc, argv)
+	int argc;
+	char *argv[];
+{
+	int bflag, ch;
+	FILE *inf;
+	struct fcode_header *fheader;
+	YY_BUFFER_STATE inbuf;
+	char *hdrtype = "version1";
+	int i;
+
+	outf = 1; /* stdout */
+	myname = argv[0];
+
+	bflag = 0;
+	while ((ch = getopt(argc, argv, "d:o:")) != -1)
+		switch(ch) {
+		case 'd':
+			debug = atol(optarg);
+			break;
+		case 'o':
+			outfile = optarg;
+			break;
+		case '?':
+		default:
+			warnx("Illegal argument: %c\n", ch);
+			usage(myname);
+		}
+	argc -= optind;
+	argv += optind;
+	
+	if (argc != 1)
+		usage(myname);
+	
+	infile = argv[0];
+
+	/*
+	 * Initialization stuff.
+	 */
+	initdic();
+	outbufsiz = BUFCLICK;
+	outbuf = malloc(outbufsiz);
+	fheader = (struct fcode_header *)outbuf;
+	outpos = 0;
+	emit(hdrtype);
+	outpos = sizeof(*fheader);
+
+	/* 
+	 * Do it.
+	 */
+	if ((inf = fopen(infile, "r")) == NULL)
+		(void)err(1, "can not open %s for reading", infile);
+
+	inbuf = yy_create_buffer( inf, YY_BUF_SIZE );
+	yy_switch_to_buffer(inbuf);
+	tokenize(inbuf);
+	yy_delete_buffer(inbuf);
+	fclose(inf);
+	emit("end0");
+
+	/* Now calculate length and checksum and stick them in the header */
+	fheader->format = 0x08;
+	fheader->length = htonl(outpos);
+	fheader->checksum = 0;
+	for (i = sizeof(*fheader); i<outpos; i++)
+		fheader->checksum += outbuf[i];
+	fheader->checksum = htons(fheader->checksum);
+
+	if ((outf = open(outfile, O_WRONLY|O_CREAT|O_TRUNC, 0666)) == NULL)
+		err(1, "can out open %s for writing", outfile);
+
+	if (write(outf, outbuf, outpos) != outpos) {
+		close(outf);
+		unlink(outfile);
+		err(1, "write error");
+	}
+	close(outf);
+	return (0);
+};
+
+/*
+ * Tokenize one file.  This is a separate function so it can
+ * be called recursively to parse mutiple levels of include files.
+ */
+
+void
+tokenize(input) 
+	YY_BUFFER_STATE input;
+{
+	FILE *inf;
+	YY_BUFFER_STATE inbuf;
+	TOKEN *token;
+	char *last_token = "";
+	struct fcode *fcode;
+	int pos, off;
+
+	while ((token = yylex()) != NULL) {
+		switch (token->type) {
+		case TOK_NUMBER:
+			STATE(token->text, "TOK_NUMBER");
+		{ 
+			char *end;
+			Cell value;
+			
+			if (tokenizer) {
+				push(strtol(token->text, &end, 16));
+				break;
+			}
+			value = strtol(token->text, &end, base);
+			if (*end != 0)
+				token_err(yylineno, infile, yytext,
+				    "illegal number conversion");
+
+			/* 
+			 * If this is a 64-bit value we need to store two literals
+			 * and issue a `lxjoin' to combine them.  But that's a future
+			 * project.
+			 */
+			emit("b(lit)");
+			spit(value>>24);
+			spit((value>>16)&0x0ff);
+			spit((value>>8)&0x0ff);
+			spit(value&0x0ff);
+		}
+		break;
+		case TOK_C_LIT:
+			STATE(token->text, "TOK_C_LIT");
+			emit("b(lit)");
+			spit(0);
+			spit(0);
+			spit(0);
+			spit(token->text[1]);
+		break;
+		case TOK_STRING_LIT: 
+			STATE(token->text, "TOK_STRING_LIT:");
+		{
+			int len;
+			char *p = token->text;
+			
+			++p;			/* Skip the quote */
+			len = strlen(++p);	/* Skip the 1st space */
+
+#define ERR_TOOLONG	\
+	token_err(yylineno, infile, yytext, "string length %d too long", len)
+
+			if (len > 255)
+				ERR_TOOLONG;
+
+			if (p[len-1] == ')' ||
+			    p[len-1] == '"') {
+				p[len-1] = 0;
+			}
+			emit("b(\")");
+			sspit(p);
+		}
+		break;
+		case TOK_PSTRING: 
+			STATE(token->text, "TOK_PSTRING:");
+		{
+			int len;
+			char *p = token->text;
+
+			if (*p++ == '.') p++; /* Skip over delimiter */
+			p++; /* Skip over space/tab */
+
+			len = strlen(p);
+			if (len > 255)
+				ERR_TOOLONG;
+
+			if (p[len-1] == ')' ||
+			    p[len-1] == '"') {
+				p[len-1] = 0;
+			}
+			emit("b(\")");
+			sspit(p);
+			emit("type");
+		}
+		break;
+		case TOK_TOKENIZE:
+			STATE(token->text, "TOK_TOKENIZE");
+			/* The next pass should tokenize the FCODE number */
+			emit("b(')");
+			break;
+		case TOK_COMMENT: 
+			STATE(token->text, "TOK_COMMENT:");
+			while (((token = yylex()) != NULL) && token->type != TOK_ENDCOMMENT)
+				;
+			break;
+		case TOK_ENDCOMMENT:
+			STATE(token->text, "TOK_ENDCOMMENT");
+			token_err(yylineno, infile, NULL,
+			    "ENDCOMMENT encountered outside comment");
+			break;
+		case TOK_COLON: 
+			STATE(token->text, "TOK_COLON:");
+
+			token = yylex();
+			if (token == NULL)
+				token_err(yylineno, infile, yytext,
+				    "EOF in colon definition");
+			
+			/* Add new code to dictionary */
+			fcode = malloc(sizeof(*fcode));
+			fcode->num = nextfcode++;
+			fcode->name = strdup(token->text);
+			if (!fadd(dictionary, fcode))
+				token_err(yylineno, infile, NULL,
+				    "Duplicate definition: `%s'\n", fcode->name);
+#ifdef DEBUG
+			if (debug)
+				(void)printf("Adding %s to dictionary\n", token->text);		
+#endif
+			if (state == 0)
+				emit("new-token");
+			else {
+				if (state == TOK_EXTERNAL)
+					emit("external-token");
+				else
+				/* Here we have a choice of new-token or named-token */
+					emit("named-token");
+				sspit(token->text);
+			}
+			spit(fcode->num);
+			emit("b(:)");
+			last_token = fcode->name;
+			defining = 1;
+ 			break;
+		case TOK_SEMICOLON: 
+			STATE(token->text, "TOK_SEMICOLON:");
+			emit("b(;)");
+			defining = 0;
+			if (depth()) {
+				token_err(yylineno, infile, NULL,
+				    "Warning: stack depth %d at end of %s\n",
+				    depth(), last_token);
+			}
+			last_token = "";
+			break;
+
+			/* These are special */
+		case TOK_AGAIN:
+			STATE(token->text, "TOK_AGAIN");
+			emit("bbranch");
+			pos = pop();
+			pos -= outpos;
+			if (offsetsize == 16) {
+				spit((pos>>8)&0xff);
+			}
+			spit(pos&0xff);
+			break;
+		case TOK_ALIAS:
+			STATE(token->text, "TOK_ALIAS");
+		{
+			struct macro *alias;
+
+			token = yylex();
+			if (token == NULL) {
+				(void)printf( "EOF in alias definition\n");
+				return;
+			}
+			if (token->type != TOK_OTHER) {
+				(void)printf( "ENDCOMMENT aliasing weird token type %d\n",
+					      token->type);
+			}
+			alias = malloc(sizeof(*alias));
+			alias->name = strdup(token->text);
+			token = yylex();
+			if (token == NULL) {
+				(void)printf( "EOF in alias definition\n");
+				return;
+			}			
+			alias->equiv = strdup(token->text);
+			if (!aadd(aliases, alias)) {
+				(void)printf( "ERROR: Duplicate alias %s\n",
+					      alias->name);
+				exit(1);
+			}
+		}
+		break;
+		case TOK_GETTOKEN:
+			STATE(token->text, "TOK_GETTOKEN");
+			/* This is caused by ['] */
+			emit("b(')");
+			token = yylex();
+			if (token == NULL) {
+				(void)printf( "EOF in [']\n");
+				return;
+			}
+			if ((fcode = flookup(dictionary, token->text)) == NULL) {
+				(void)printf( "[']: %s not found\n", token->text);
+				exit(1);
+			}
+			spit(fcode->num);
+			break;
+		case TOK_ASCII:
+			STATE(token->text, "TOK_ASCII");
+			token = yylex();
+			if (token == NULL) {
+				(void)printf( "EOF after \"ascii\"\n");
+				exit(1);
+			}
+			emit("b(lit)");
+			spit(0);
+			spit(0);
+			spit(0);
+			spit(token->text[0]);
+			break;
+		case TOK_BEGIN:
+			STATE(token->text, "TOK_BEGIN");
+			emit("b(<mark)");
+			push(outpos);
+			break;
+		case TOK_BUFFER:
+			STATE(token->text, "TOK_BUFFER");
+
+			token = yylex();
+			if (token == NULL) {
+				(void)printf( "EOF in colon definition\n");
+				return;
+			}
+			
+			/* Add new code to dictionary */
+			fcode = malloc(sizeof(*fcode));
+			fcode->num = nextfcode++;
+			fcode->name = strdup(token->text);
+			fadd(dictionary, fcode);
+			
+			if (state == 0)
+				emit("new-token");
+			else {
+				if (state == TOK_EXTERNAL)
+					emit("external-token");
+				else
+				/* Here we have a choice of new-token or named-token */
+					emit("named-token");
+				sspit(token->text);
+			}
+			spit(fcode->num);
+			emit("b(buffer:)");
+			break;
+		case TOK_CASE:
+			STATE(token->text, "TOK_CASE");
+			emit("b(case)");
+			push(0);
+			break;
+		case TOK_CONSTANT:
+			STATE(token->text, "TOK_CONSTANT");
+
+			token = yylex();
+			if (token == NULL) {
+				(void)printf( "EOF in constant definition\n");
+				return;
+			}
+			
+			/* Add new code to dictionary */
+			fcode = malloc(sizeof(*fcode));
+			fcode->num = nextfcode++;
+			fcode->name = strdup(token->text);
+			fadd(dictionary, fcode);
+			
+			if (state == 0)
+				emit("new-token");
+			else {
+				if (state == TOK_EXTERNAL)
+					emit("external-token");
+				else
+				/* Here we have a choice of new-token or named-token */
+					emit("named-token");
+				sspit(token->text);
+			}
+			spit(fcode->num);
+			emit("b(constant)");
+			break;
+		case TOK_CONTROL:
+			STATE(token->text, "TOK_CONTROL");
+			token = yylex();
+			if (token == NULL) {
+				(void)printf( "EOF after \"ascii\"\n");
+				exit(1);
+			}
+			emit("b(lit)");
+			spit(0);
+			spit(0);
+			spit(0);
+			spit(token->text[0]&0x1f);
+			break;
+		case TOK_CREATE:
+			STATE(token->text, "TOK_CREATE");
+			/* Don't know what this does or if it's right */
+			token = yylex();
+			if (token == NULL) {
+				(void)printf( "EOF in create definition\n");
+				return;
+			}
+			
+			/* Add new code to dictionary */
+			fcode = malloc(sizeof(*fcode));
+			fcode->num = nextfcode++;
+			fcode->name = strdup(token->text);
+			fadd(dictionary, fcode);
+			
+			if (state == 0)
+				emit("new-token");
+			else {
+				if (state == TOK_EXTERNAL)
+					emit("external-token");
+				else
+				/* Here we have a choice of new-token or named-token */
+					emit("named-token");
+				sspit(token->text);
+			}
+			spit(fcode->num);
+			emit("b(create)");
+			break;
+		case TOK_DECIMAL:
+			STATE(token->text, "TOK_DECIMAL");
+			if (token->text[1] != '#') {
+				if (defining) {
+					spit(10);
+					emit("base");
+					emit("!");
+				} else
+					base = TOK_DECIMAL;
+			} else {
+				char *end;
+				Cell value;
+
+				token = yylex();
+				if (token == NULL) {
+					(void)printf( "EOF after d#\n");
+					return;
+				}
+				if (token->type == TOK_OTHER) {
+					if (strcmp("-1", token->text) == 0) {
+						emit(token->text);
+						break;
+					}
+				}
+				value = strtol(token->text, &end, 10);
+				if (*end != 0)
+					token_err(yylineno, infile, NULL,
+					    "Illegal number conversion: %s", token->text);
+
+				/* 
+				 * If this is a 64-bit value we need to store two literals
+				 * and issue a `lxjoin' to combine them.  But that's a future
+				 * project.
+				 */
+				emit("b(lit)");
+				spit(value>>24);
+				spit((value>>16)&0x0ff);
+				spit((value>>8)&0x0ff);
+				spit(value&0x0ff);
+			}
+			break;
+		case TOK_DEFER:
+			STATE(token->text, "TOK_DEFER");
+			/* Don't know what this does or if it's right */
+			token = yylex();
+			if (token == NULL) {
+				(void)printf( "EOF in colon definition\n");
+				return;
+			}
+			
+			/* Add new code to dictionary */
+			fcode = malloc(sizeof(*fcode));
+			fcode->num = nextfcode++;
+			fcode->name = strdup(token->text);
+			fadd(dictionary, fcode);
+			
+			if (state == 0)
+				emit("new-token");
+			else {
+				if (state == TOK_EXTERNAL)
+					emit("external-token");
+				else
+				/* Here we have a choice of new-token or named-token */
+					emit("named-token");
+				sspit(token->text);
+			}
+			spit(fcode->num);
+			emit("b(defer)");
+			break;
+		case TOK_DO:
+			STATE(token->text, "TOK_DO");
+			/*
+			 * From the 1275 spec.  B is branch location, T is branch target.
+			 *
+			 *	b(do)  offset1 ... b(loop)  offset2 ...
+			 *	b(do)  offset1 ... b(+loop) offset2 ...
+			 *	b(?do) offset1 ... b(loop)  offset2 ...
+			 *	b(?do) offset1 ... b(+loop) offset2 ...
+			 *            ^                            ^
+			 *           B1       ^            ^       T1
+			 *                    T2           B2
+			 *
+			 * How we do this is we generate the b(do) or b(?do), spit out a
+			 * zero offset while remembering b1 and t2.  Then we call tokenize()
+			 * to generate the body.  When tokenize() finds a b(loop) or b(+loop),
+			 * it generates the FCode and returns, with outpos at b2.  We then
+			 * calculate the offsets, put them in the right slots and finishup.
+			 */
+			
+			if (token->text[0] == '?')
+				emit("b(?do)");
+			else
+				emit("b(do)");
+			push(outpos);
+			if (offsetsize == 16) {
+				spit(0);
+			}
+			spit(0);	/* Place holder for later */
+			push(outpos);
+			break;
+		case TOK_ELSE:
+			STATE(token->text, "TOK_ELSE");
+			/* Get where we need to patch */
+			off = pop();
+			emit("bbranch");
+			/* Save where we are now. */
+			push(outpos);
+			if (offsetsize == 16) {
+				spit(0);	/* Place holder for later */
+			}
+			spit(0);	/* Place holder for later */
+			emit("b(>resolve)");
+			/* Rewind and patch the if branch */
+			pos = outpos;
+			outpos = off;
+			off = pos - off;
+			if (offsetsize == 16) {
+				spit(0);	/* Place holder for later */
+			}
+			spit(0);	/* Place holder for later */
+			/* revert to the end */
+			outpos = pos;
+			break;
+		case TOK_ENDCASE: 
+			STATE(token->text, "TOK_ENDCASE:");
+			pos = outpos; /* Remember where we need to branch to */
+
+			/* Thread our way backwards and install proper offsets */
+			off = pop();
+			while (off) {
+				int tmp;
+
+				/* Move to this offset */
+				outpos = off;
+				/* Load next offset to process */
+				tmp = outbuf[outpos];
+
+				/* process this offset */
+				off = pos - outpos;
+				if (offsetsize == 16) {
+					spit((off>>8)&0xff);
+				}
+				spit(off&0xff);
+				off = tmp;
+			}
+			outpos = pos;
+			emit("b(endcase)");
+			break;
+		case TOK_ENDOF:
+			STATE(token->text, "TOK_ENDOF");
+			off = pop();
+			emit("b(endof)");
+			/* 
+			 * Save back pointer in the offset field so we can traverse
+			 * the linked list and patch it in the endcase.
+			 */
+			pos = pop();	/* get position of prev link. */
+			push(outpos);	/* save position of this link. */
+			spit(pos);	/* save potision of prev link. */
+			if (offsetsize == 16) {
+				spit(0);
+			}
+			pos = outpos;
+			/* Now point the offset from b(of) here. */
+			outpos = off;
+			off = outpos - off;
+			if (offsetsize == 16) {
+				spit((off>>8)&0xff);
+			}
+			spit(off&0xff);
+			/* Restore position */
+			outpos = pos;
+			break;
+		case TOK_EXTERNAL:
+			STATE(token->text, "TOK_EXTERNAL");
+			state = TOK_EXTERNAL;
+			break;
+		case TOK_FIELD:
+			STATE(token->text, "TOK_FIELD");
+	
+			token = yylex();
+			if (token == NULL) {
+				(void)printf( "EOF in field definition\n");
+				return;
+			}
+			
+			/* Add new code to dictionary */
+			fcode = malloc(sizeof(*fcode));
+			fcode->num = nextfcode++;
+			fcode->name = strdup(token->text);
+			fadd(dictionary, fcode);
+			
+			if (state == 0)
+				emit("new-token");
+			else {
+				if (state == TOK_EXTERNAL)
+					emit("external-token");
+				else
+				/* Here we have a choice of new-token or named-token */
+					emit("named-token");
+				sspit(token->text);
+			}
+			spit(fcode->num);
+			emit("b(field)");
+			break;
+		
+		case TOK_HEX:
+			STATE(token->text, "TOK_HEX");
+			if (token->text[1] != '#') {
+				if (defining) {
+					spit(16);
+					emit("base");
+					emit("!");
+				} else
+					base = TOK_HEX;
+			} else {
+				char *end;
+				Cell value;
+
+				token = yylex();
+				if (token == NULL) {
+					(void)printf( "EOF after h#\n");
+					return;
+				}
+				value = strtol(token->text, &end, 16);
+				if (*end != 0) {
+					(void)printf("Illegal number conversion:%s:%d: %s\n",
+					    infile, yylineno, yytext);
+					exit(1);
+				}
+				/* 
+				 * If this is a 64-bit value we need to store two literals
+				 * and issue a `lxjoin' to combine them.  But that's a future
+				 * project.
+				 */
+				emit("b(lit)");
+				spit(value>>24);
+				spit((value>>16)&0x0ff);
+				spit((value>>8)&0x0ff);
+				spit(value&0x0ff);
+			}
+			break;
+		case TOK_HEADERLESS:
+			STATE(token->text, "TOK_HEADERLESS");
+			state = 0;
+			break;
+		case TOK_HEADERS:
+			STATE(token->text, "TOK_HEADERS");
+			state = TOK_HEADERS;
+			break;
+		case TOK_OFFSET16:
+			STATE(token->text, "TOK_OFFSET16");
+			offsetsize = 16;
+			emit("offset16");
+			break;
+		case TOK_IF:
+			STATE(token->text, "TOK_IF");
+			/*
+			 * Similar to do but simpler since we only deal w/one branch.
+			 */
+			emit("b?branch");
+			push(outpos);
+			if (offsetsize == 16) {
+				spit(0);	/* Place holder for later */
+			}
+			spit(0);	/* Place holder for later */
+			break;
+		case TOK_LEAVE:
+			STATE(token->text, "TOK_LEAVE");
+			emit("b(leave)");
+			break;
+		case TOK_LOOP:
+			STATE(token->text, "TOK_LOOP");
+
+			if (token->text[0] == '+')
+				emit("b(+loop)");
+			else
+				emit("b(loop)");
+			/* First do backwards branch of loop */
+			pos = pop();
+			off = pos - outpos;
+			if (offsetsize == 16) {
+				spit((off>>8)&0xff);
+			}
+			spit(off&0xff);
+			/* Now do forward branch of do */
+			pos = outpos;
+			outpos = pop();
+			off = pos - outpos;
+			if (offsetsize == 16) {
+				spit((off>>8)&0xff);
+			}
+			spit(off&0xff);
+			/* Restore output position */
+			outpos = pos;
+			break;
+		case TOK_OCTAL:
+			STATE(token->text, "TOK_OCTAL");
+			if (token->text[1] != '#') {
+				if (defining) {
+					spit(16);
+					emit("base");
+					emit("!");
+				} else
+					base = TOK_OCTAL;
+			} else {
+				char *end;
+				Cell value;
+
+				token = yylex();
+				if (token == NULL) {
+					(void)printf( "EOF after o#\n");
+					return;
+				}
+				value = strtol(token->text, &end, 8);
+				if (*end != 0) {
+					(void)printf("Illegal number conversion:%s:%d: %s\n",
+					    infile, yylineno, yytext);
+					exit(1);
+				}
+				/* 
+				 * If this is a 64-bit value we need to store two literals
+				 * and issue a `lxjoin' to combine them.  But that's a future
+				 * project.
+				 */
+				emit("b(lit)");
+				spit(value>>24);
+				spit((value>>16)&0x0ff);
+				spit((value>>8)&0x0ff);
+				spit(value&0x0ff);
+			}
+			break;
+		case TOK_OF:
+			STATE(token->text, "TOK_OF");
+			/*
+			 * Let's hope I get the semantics right.
+			 *
+			 * The `of' behaves almost the same as an
+			 * `if'.  The difference is that `endof'
+			 * takes a branch offset to the associated
+			 * `endcase'.  Here we will generate a temporary
+			 * offset of the `of' associated with the `endof'.
+			 * Then in `endcase' we should be pointing just
+			 * after the offset of the last `endof' so we 
+			 * calculate the offset and thread our way backwards
+			 * searching for the previous `b(case)' or `b(endof)'.
+			 */
+			emit("b(of)");
+			push(outpos);
+			if (offsetsize == 16) {
+				spit(0);
+			}
+			spit(0);	/* Place holder for later */
+			break;
+		case TOK_REPEAT:
+			STATE(token->text, "TOK_REPEAT");
+			emit("bbranch");
+			pos = pop();
+			off = pop();
+			/* First the offset for the branch back to the begin */
+			off -= outpos;
+			if (offsetsize == 16) {
+				spit((off>>8)&0xff);
+			}
+			spit(off&0xff);
+			emit("b(>resolve)");
+			/* Now point the offset of the while here. */
+			off = outpos;
+			outpos = pos;
+			pos = off - pos;
+			if (offsetsize == 16) {
+				spit((pos>>8)&0xff);
+			}
+			spit(pos&0xff);
+			/* Return to the end of the output */
+			outpos = off;
+			break;
+		case TOK_THEN:
+			STATE(token->text, "TOK_THEN");
+			emit("b(>resolve)");
+			pos = outpos;
+			outpos = pop();
+			off = pos - outpos;
+			if (offsetsize == 16) {
+				spit((off>>8)&0xff);
+			}
+			spit(off&0xff);
+			outpos = pos;
+			break;
+		case TOK_TO:
+			STATE(token->text, "TOK_TO");
+			/* The next pass should tokenize the FCODE number */
+			emit("b(to)");
+			break;
+		case TOK_UNTIL:
+			STATE(token->text, "TOK_UNTIL");
+		{
+			int pos;
+
+			emit("b?branch");
+			pos = pop();
+			pos -= outpos;
+			if (offsetsize == 16) {
+				spit((pos>>8)&0xff);
+			}
+			spit(pos&0xff);
+		}
+		break;			
+		case TOK_VALUE:
+			STATE(token->text, "TOK_VALUE");
+
+			token = yylex();
+			if (token == NULL) {
+				(void)printf( "EOF in value definition\n");
+				return;
+			}
+			
+			/* Add new code to dictionary */
+			fcode = malloc(sizeof(*fcode));
+			fcode->num = nextfcode++;
+			fcode->name = strdup(token->text);
+			fadd(dictionary, fcode);
+			
+			if (state == 0)
+				emit("new-token");
+			else {
+				if (state == TOK_EXTERNAL)
+					emit("external-token");
+				else
+				/* Here we have a choice of new-token or named-token */
+					emit("named-token");
+				sspit(token->text);
+			}
+			spit(fcode->num);
+			emit("b(value)");
+			break;
+		case TOK_VARIABLE:
+			STATE(token->text, "TOK_VARIABLE");
+
+			token = yylex();
+			if (token == NULL) {
+				(void)printf( "EOF in variable definition\n");
+				return;
+			}
+			
+			/* Add new code to dictionary */
+			fcode = malloc(sizeof(*fcode));
+			fcode->num = nextfcode++;
+			fcode->name = strdup(token->text);
+			fadd(dictionary, fcode);
+			
+			if (state == 0)
+				emit("new-token");
+			else {
+				if (state == TOK_EXTERNAL)
+					emit("external-token");
+				else
+				/* Here we have a choice of new-token or named-token */
+					emit("named-token");
+				sspit(token->text);
+			}
+			spit(fcode->num);
+			emit("b(variable)");
+			break;
+		case TOK_WHILE:
+			STATE(token->text, "TOK_WHILE");
+			emit("b?branch");
+			push(outpos);
+			if (offsetsize == 16) {
+				spit(0);
+			}
+			spit(0);
+			break;
+
+			/* Tokenizer directives */
+		case TOK_BEGTOK:
+			STATE(token->text, "TOK_BEGTOK");
+			tokenizer = 1;
+			break;
+		case TOK_EMIT_BYTE:
+			STATE(token->text, "TOK_EMIT_BYTE");
+			spit(pop());
+			break;
+		case TOK_ENDTOK:
+			STATE(token->text, "TOK_ENDTOK");
+			tokenizer = 0;
+			break;
+		case TOK_FLOAD:
+			STATE(token->text, "TOK_FLOAD");
+			/* Parse a different file for a while */
+			token = yylex();
+			if ((inf = fopen(token->text, "r")) == NULL) {
+				(void)printf("%s: Could not open %s: %s\n",
+					      myname, token->text, strerror(errno));
+				break;
+			}
+			inbuf = yy_create_buffer(inf, YY_BUF_SIZE);
+			yy_switch_to_buffer(inbuf);
+			{
+				char *oldinfile = infile;
+
+				infile = token->text;
+				tokenize(inbuf);
+				infile = oldinfile;
+			}
+			yy_switch_to_buffer(input);
+			yy_delete_buffer(inbuf);
+			fclose(inf);
+			break;
+		case TOK_OTHER:
+			STATE(token->text, "TOK_OTHER");
+			if (apply_macros(input, token->text))
+				break;
+			if (emit(token->text)) {
+#if 0
+				/*
+				 * Call an external command 
+				 *
+				 * XXXXX assumes it will always find the command
+				 */
+				sspit(token->text);
+				emit("$find");
+				emit("drop");
+				emit("execute");
+#else
+				(void)printf( "%s: undefined token `%s'\n",
+					      myname, token->text);
+				fflush(stderr);
+				exit(1);
+#endif
+			}
+			break;
+		default:
+		}
+	}
+	return;
+}
+
+/*
+ * print a tokenizer error message
+ */
+void
+token_err(int lineno, char *infile, char *text, char *fmt, ...)
+{
+	va_list ap;
+
+	va_start(ap, fmt);
+	if (infile)
+		(void)fprintf(stderr, "%s:%d: ", infile, lineno);
+	if (fmt)
+		(void)vfprintf(stderr, fmt, ap);
+	fputc('\n', stderr);
+	if (text)
+		fprintf(stderr, "\t%s", text);
+	va_end(ap);
+	exit(1);
+}
+
+/*
+ * Lookup fcode string in dictionary and spit it out.
+ *
+ * Fcode must be in dictionary.  No alias conversion done.
+ */
+int
+emit(str)
+	char *str;
+{
+	struct fcode *code;
+	if ((code = flookup( dictionary, str)))
+		spit(code->num);
+#ifdef DEBUG
+	if (debug > 1) {
+		if (code)
+			(void)printf( "emitting `%s'\n", code->name);
+		else
+			(void)printf( "emit: not found `%s'\n", str);
+	}
+#endif
+	return (code == NULL);
+}
+
+/*
+ * Spit out an integral value as a series of FCodes.
+ *
+ * It will spit out one zero byte or as many bytes as are
+ * non-zero.
+ */
+int
+spit(n)
+	long n;
+{
+	int count = 1;
+
+	if (n >> 8)
+		count += spit(n >> 8);
+	if (outpos >= outbufsiz) {
+		while (outpos >= outbufsiz) outbufsiz += BUFCLICK;
+		if (!(outbuf = realloc(outbuf, outbufsiz))) {
+			(void)printf( "realloc of %ld bytes failed -- out of memory\n",
+				      (long)outbufsiz);
+			exit(1);
+		}
+	}
+	outbuf[outpos++] = n;
+	return (count);
+}
+
+/*
+ * Spit out an FCode string.
+ */
+void
+sspit(s)
+	char *s;
+{
+	int len = strlen(s);
+
+	if (len > 255) {
+		(void)printf( "string length %d too long\n", len);
+		return;
+	}
+#ifdef DEBUG
+	if (debug > 1)
+		(void)printf( "sspit: len %d str `%s'\n", len, s);
+#endif
+	spit(len);
+	while (*s)
+		spit(*s++);
+}
+
+int 
+yywrap()
+{
+	/* Always generate EOF */
+	return (1);
+}