summaryrefslogtreecommitdiff
path: root/usr.bin/fgen
diff options
context:
space:
mode:
Diffstat (limited to 'usr.bin/fgen')
-rw-r--r--usr.bin/fgen/Makefile9
-rw-r--r--usr.bin/fgen/fgen.175
-rw-r--r--usr.bin/fgen/fgen.h136
-rw-r--r--usr.bin/fgen/fgen.l2000
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);
+}
generated by cgit v1.2.3 (git 2.25.1) at 2024-12-01 10:55:37 +0000