From 2d044bfe809be2fb02ae5aa8540cd57f7af407a1 Mon Sep 17 00:00:00 2001
From: Jason Self <j@jxself.org>
Date: Sat, 25 Nov 2017 21:34:10 -0800
Subject: [PATCH 1/1] Importing a56 version 1.3 from
 http://www.zdomain.com/a56.html. Copyright of examples is not clear so I
 removed them.

---
 Makefile   |  116 +++
 README-1.1 |  143 ++++
 README-1.2 |  169 +++++
 README-1.3 |  145 ++++
 a56.h      |   94 +++
 a56.key    |  193 +++++
 a56.y      | 2114 ++++++++++++++++++++++++++++++++++++++++++++++++++++
 frac2int.c |  118 +++
 getopt.c   |  129 ++++
 keybld.c   |  231 ++++++
 lex.c      |  477 ++++++++++++
 main.c     |  467 ++++++++++++
 subs.c     |  165 ++++
 tok.awk    |    4 +
 toktab.c   |  131 ++++
 toomf.c    |   60 ++
 torom.c    |   70 ++
 17 files changed, 4826 insertions(+)
 create mode 100644 Makefile
 create mode 100644 README-1.1
 create mode 100644 README-1.2
 create mode 100644 README-1.3
 create mode 100644 a56.h
 create mode 100644 a56.key
 create mode 100644 a56.y
 create mode 100644 frac2int.c
 create mode 100644 getopt.c
 create mode 100644 keybld.c
 create mode 100644 lex.c
 create mode 100644 main.c
 create mode 100644 subs.c
 create mode 100644 tok.awk
 create mode 100644 toktab.c
 create mode 100644 toomf.c
 create mode 100644 torom.c

diff --git a/Makefile b/Makefile
new file mode 100644
index 0000000..fc5b25d
--- /dev/null
+++ b/Makefile
@@ -0,0 +1,116 @@
+#######################################################
+#
+#  a56 - a DSP56001 assembler
+#
+#  Written by Quinn C. Jensen
+#  July 1990
+#
+#######################################################
+
+# environment definitions
+# uncomment the ones you like
+
+# generic unix
+CC = cc
+HOSTCC = cc
+YACC = yacc
+CCDEFS = -DLDEBUG
+MV = mv
+YTABC = y.tab.c
+YTABH = y.tab.h
+POSTPROCESS = echo
+
+# gcc & bison
+#CC = gcc
+#HOSTCC = gcc
+#YACC = bison -y
+#CCDEFS =
+#MV = mv
+#YTABC = y.tab.c
+#YTABH = y.tab.h
+#POSTPROCESS = echo
+
+# Delorie's DOS gcc (from ftp://omnigate.clarkson.edu/pub/msdos/djgpp)
+#CC = gcc
+#HOSTCC = gcc
+#YACC = bison -y
+#CCDEFS =
+#MV = ren
+#YTABC = y_tab.c
+#YTABH = y_tab.h
+#POSTPROCESS = coff2exe
+
+# gcc cross-compile to go32 environment
+#CC = i386-go32-gcc
+#HOSTCC = cc
+#YACC = yacc
+#CCDEFS =
+#MV = mv
+#YTABC = y.tab.c
+#YTABH = y.tab.h
+#POSTPROCESS = echo
+
+#######################################################
+
+# -O or -g
+#DEBUG = -O -Olimit 3000
+DEBUG = -O
+
+SRCS = main.c a56.y lex.c subs.c getopt.c kparse.key
+OBJS = main.o gram.o lex.o toktab.o subs.o getopt.o kparse.o
+
+DEFINES = $(CCDEFS)
+#DEFINES = -DYYDEBUG -DLDEBUG $(CCDEFS)
+
+CFLAGS = $(DEBUG) $(DEFINES)
+
+all:	keybld a56 toomf
+
+a56:	$(OBJS)
+	$(CC) $(CFLAGS) -o a56 $(OBJS) -lm
+	@$(POSTPROCESS) a56
+
+keybld:	keybld.o ksubs.o
+	$(HOSTCC) $(CFLAGS) -o keybld keybld.o ksubs.o
+	@$(POSTPROCESS) keybld
+
+keybld.o:	keybld.c
+	$(HOSTCC) $(CFLAGS) -c keybld.c
+
+ksubs.o:	subs.c
+	$(HOSTCC) $(CFLAGS) -c subs.c
+	$(MV) subs.o ksubs.o
+
+lex.o:	lex.c gram.h
+
+kparse.c:	a56.key keybld
+	keybld < a56.key > kparse.c
+
+gram.c gram.h:	a56.y
+	@echo "[expect 2 shift/reduce conflicts here]"
+	$(YACC) -d a56.y
+	$(MV) $(YTABC) gram.c
+	$(MV) $(YTABH) gram.h
+
+toktab.c:	gram.h
+	awk -f tok.awk < gram.h > toktab.c
+
+y.output:	a56.y
+	$(YACC) -v a56.y
+
+toomf:	toomf.o
+	$(CC) -o toomf $(CFLAGS) toomf.o
+	@$(POSTPROCESS) toomf
+
+torom:	torom.o subs.o
+	$(CC) -o torom $(CFLAGS) torom.o subs.o
+
+tape:	toktab.c
+	csh -c 'tar cvbf 1 - `cat files` | gzip > a56.tar.gz'
+
+main.o gram.o lex.o:	a56.h
+
+clean:	; rm -f a56 toomf y.output *.o *.out tmp *.bak a56.tar.gz keybld
+
+spotless:	clean
+	rm -f gram.c lexyy.c gram.h toktab.c kparse.c
diff --git a/README-1.1 b/README-1.1
new file mode 100644
index 0000000..daf3194
--- /dev/null
+++ b/README-1.1
@@ -0,0 +1,143 @@
+
+  a56 - a DSP56001 assembler - version 1.1
+
+/*
+ * Copyright (C) 1990-1992 Quinn C. Jensen
+ *
+ * Permission to use, copy, modify, distribute, and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  The author makes no representations
+ * about the suitability of this software for any purpose.  It is
+ * provided "as is" without express or implied warranty.
+ *
+ */
+
+V1.1 CHANGES
+
+Many thanks to Tom Cunningham at Motorola who noted several bugs, fixing
+most of them.  Thanks also to Stephen Edwards at CalTech for his fixes as well.
+Both he and Tom fixed up the XY parallel move code;  I believe all the
+fixes are integrated.
+
+Summary of changes since v1.0:
+
+	- Jcc, JScc, Tcc recognizes "CC" synonym for "HS" (Tom)
+	- LUA syntax fixed (Tom, Stephen)
+	- DIV syntax fixed (Tom)
+	- XY move fixed (Tom, Stephen)
+	- a56 now detects phase errors (changes in symbol values
+	  between pass 1 and 2)
+	- several causes of phase errors fixed
+	- immediate value handling improved for both integer and
+	  fixed-point values
+	- symbols have type (INT or FLOAT)
+	- cpp droppings are properly handled
+	- ALIGN pseudo-op added
+
+Known bugs/deficiencies:
+
+	- MOVE to a control reg generates bogus code (always use MOVEC,
+	  MOVEM, and MOVEP)
+
+The example code has been cleaned up a bit and I've included my
+56K board's envelope code - tdsg.basic.a56.  This code is specific to
+my implimentation.
+
+A note on the reverb code - I have since found since posting version 1.0
+that the reverb code has a great-big almost-DC bumb in its impulse
+response.  I found this after doing some simulations.  I suspected something
+was wrong because I had to scale the output of the comb filters by .046
+or something before going into the two all-pass stages.  Overall I think it
+works better without the 1.7 ms all-pass.  There's another reverb example 
+on Dr. Bubb that fits Moorer's 1979 model better.  I've included this in 
+the examples but I have not yet assembled or tried it.
+
+OVERVIEW
+
+This program was written as a vehicle to learn the intricacies
+of the DSP56001 instruction set, and to provide a tool for Unix-based
+DSP code development (for those of us without a NeXT machine.)
+
+The intent was to provide compatibility with Motorola assembler's syntax.
+But since the author did not have Motorola's assembler or its documentation,
+it is no doubt far from compatible.  Only a few pseudo-ops are implemented--
+probably only partially.
+
+Macros are not supported, except through the use of an external macro
+preprocessor, such as /lib/cpp.  To facilitate cpp macro expansion, multiple
+assembler statements on a single input line are delimited with an '@', e.g.:
+
+	#define JCHEQ(c,label)	move #c,x0 @cmp x0,a @jeq label
+
+	#define JCHNE(c,label)	move #c,x0 @cmp x0,a @jne label
+
+
+SUPPORTED PSEUDO-OPS
+
+The following is a list of the pseudo-ops that are recognized:
+
+	<symbol> = <expression>				;assign a symbol
+	
+	ALIGN <number>					;set location pointer
+							;to next integral
+							;multiple of <number>
+
+	ORG <space:> <expression>			;new location pointer
+	ORG <space:> <expression>, <space:> <expression>
+
+	DC <dc_list>					;declare constants
+
+	PAGE <number>, <number>, <number>, <number>	;ignored
+
+	INCLUDE <file>					;file inclusion
+
+	END						;end
+
+In addition, a "PSECT" pseudo-op was implemented.  It allows program sections
+to be defined and bopped in and out of, each with its own location counter and
+space.  The Motorola assembler probably does not have this pseudo-op, but no
+doubt supports the concept in some way.
+
+	PSECT <name> <space:><begin_addr>:<end_addr>	;define
+
+	PSECT <name>					;switch to psect <name>
+
+
+FUTURE DIRECTION
+
+The assembler probably generates bogus code here and there, and no doubt
+does not handle all of the syntax.  I welcome all comments, fixes and 
+enhancements.
+
+TO MAKE AND USE
+
+Type "make".  gram.c and lex.yy.c are provided for those without yacc
+(or bison) and/or lex.
+
+The resulting program, a56, is used as follows:
+
+	a56 [-b] [-l] [-o output-file] file [...]
+
+An assembler listing is sent to the standard-output and an ascii-formatted
+object file (a56.out) is produced.  The "-b" option adds binary to the listing.
+"-l" causes included files to be listed.  "-o" directs the output to the
+specified file rather than the default, a56.out.
+
+A separate program, toomf, converts a56.out into "OMF" format suitable for 
+downloading to the 56001 via the sloader.a56 program.
+
+	toomf < a56.out > file.omf
+
+AUTHOR
+
+11/28/91
+v1.1 8/6/92
+
+Quinn C. Jensen
+1374 N 40 E
+Orem, UT  84057
+
+home: jensenq@zdomain.com (preferred address for a56 correspondence)
+work: jensenq@novell.com
diff --git a/README-1.2 b/README-1.2
new file mode 100644
index 0000000..682e499
--- /dev/null
+++ b/README-1.2
@@ -0,0 +1,169 @@
+
+  a56 - a DSP56001 assembler - version 1.2
+
+/*
+ * Copyright (C) 1990-1994 Quinn C. Jensen
+ *
+ * Permission to use, copy, modify, distribute, and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  The author makes no representations
+ * about the suitability of this software for any purpose.  It is
+ * provided "as is" without express or implied warranty.
+ *
+ */
+
+V1.2 CHANGES
+
+Contributors to V1.2 -
+
+    Andreas Gustafsson <gson@joker.cs.hut.fi>
+      - Added DS and DSM directives
+      - Generalization of the use of "*" allowing current program counter
+        to be used in any expression (including "org l:*" which is useful
+        for changing spaces without changing the PC)
+      - Noted a bug with MOVEP to a non-symbolic I/O address.  I believe
+        this is now fixed.
+      - Noted that mispelled argumentless operators will be treated as
+        labels.  For example, N0P (N-zero-P) will be treated as a label.
+        Unfortunately, my own use of a56 (i.e. using cpp as the macro
+        pre-processor) complicates this.  However, the grammar might
+        have been simpler if the lexical analyzer was able to distinguish
+        between label declarations and references instead of leaving that
+        up to the YACC parser.
+
+    Tim Channon <tchannon@black.demon.co.uk> and Peter Breuer
+      <ptb@comlab.ox.ac.uk>
+      - Missing ";" in grammar!
+
+    Rober Ganter <ganter@ifi.unibas.ch>
+      - Fixed bad comment on line 10 of a56.y
+
+    Me <jensenq@zdomain.com>
+      - Listing now includes psect usage summary
+      - Better checking of movec arguments
+      - Added int(value) function to convert floating point constant expression
+        to integer (by truncation)
+      - Correctly convert a floating -1.0 to 0x800000
+      - Wrote a new lexical analyzer and lexical parser generator
+      - Many other minor enhancements and fixes.
+      - Ported to DOS using DJ Delories' GCC port.  (Tools available at
+        ftp://omnigate.clarkson.edu/pub/msdos/djgpp)
+
+Known bugs/deficiencies:
+
+        - MOVE to a control reg generates bogus code (always use MOVEC,
+          MOVEM, and MOVEP)
+
+The example code this time around includes a full six-comb stereo reverb
+(based on Moorer).  This one sounds a lot better than the four-comb algorithm.
+Each comb uses a one-pole low-pass filter in the loop.  It lacks the
+early-reflection FIR (although Motorola's rvb2.asm has it) but has
+true stereo decorrelation by using a twin allpass stage.  My old reverb
+just used inversion to simulate stereo (the whole reverb effect would
+disappear if you mixed the outputs).  I've included only actual reverb
+code itself.  It lacks the hardware-implementation-specific shell.
+
+
+---------------------------------------------------------------------------
+
+OVERVIEW
+
+This program was written as a vehicle to learn the intricacies
+of the DSP56001 instruction set, and to provide a tool for Unix-based
+DSP code development (for those of us without a NeXT machine.)
+
+The intent was to provide compatibility with Motorola assembler's syntax.
+But since the author did not have Motorola's assembler or its documentation,
+it is no doubt far from compatible.  Only a few pseudo-ops are implemented--
+probably only partially.
+
+Macros are not supported, except through the use of an external macro
+preprocessor, such as /lib/cpp.  To facilitate cpp macro expansion, multiple
+assembler statements on a single input line are delimited with an '@', e.g.:
+
+        #define JCHEQ(c,label)	move #c,x0 @cmp x0,a @jeq label
+
+        #define JCHNE(c,label)	move #c,x0 @cmp x0,a @jne label
+
+
+SUPPORTED PSEUDO-OPS
+
+The following is a list of the pseudo-ops that are recognized:
+
+        <symbol> = <expression>                         ;assign a symbol
+        <label> EQU <expression>                        ;ditto
+
+        ALIGN <number>                                  ;set location pointer
+                                                        ;to next integral
+                                                        ;multiple of <number>
+
+        ORG <space:> <expression>                       ;new location pointer
+        ORG <space:> <expression>, <space:> <expression>
+
+        DC <dc_list>                                    ;declare constants
+
+        DS <number>                                     ;reserve <number>
+                                                        ;words of space
+
+        <label> DSM <number>                            ;reserve space for
+                                                        ;properly aligned
+                                                        ;modulo-addressed
+                                                        ;buffer of size
+                                                        ;<number>, assigning
+                                                        ;the aligned starting
+                                                        ;address to <label>
+
+        PAGE <number>, <number>, <number>, <number>     ;ignored
+
+        INCLUDE <file>                                  ;file inclusion
+
+        END                                             ;end
+
+In addition, a "PSECT" pseudo-op was implemented.  It allows program sections
+to be defined and bopped in and out of, each with its own location counter and
+space.  The Motorola assembler probably does not have this pseudo-op, but no
+doubt supports the concept in some way.
+
+        PSECT <name> <space:><begin_addr>:<end_addr>    ;define
+
+        PSECT <name>                                    ;switch to psect <name>
+
+
+FUTURE DIRECTION
+
+The assembler probably generates bogus code here and there, and no doubt
+does not handle all of the syntax.  I welcome all comments, fixes and 
+enhancements.
+
+TO MAKE AND USE
+
+Type "make".
+
+The resulting program, a56, is used as follows:
+
+        a56 [-b] [-l] [-o output-file] file [...]
+
+An assembler listing is sent to the standard-output and an ascii-formatted
+object file (a56.out) is produced.  The "-b" option adds binary to the listing.
+"-l" causes included files to be listed.  "-o" directs the output to the
+specified file rather than the default, a56.out.
+
+A separate program, toomf, converts a56.out into "OMF" format suitable for 
+downloading to the 56001 via the sloader.a56 program.
+
+        toomf < a56.out > file.omf
+
+AUTHOR
+
+11/28/91
+v1.1 8/6/92
+v1.2 5/2/94
+
+Quinn C. Jensen
+1374 N 40 E
+Orem, UT  84057
+
+home: jensenq@zdomain.com (preferred address for a56 correspondence)
+work: jensenq@novell.com
diff --git a/README-1.3 b/README-1.3
new file mode 100644
index 0000000..6492dae
--- /dev/null
+++ b/README-1.3
@@ -0,0 +1,145 @@
+
+  a56 - a DSP5600X assembler - version 1.3
+
+/*
+ * Copyright (C) 1990-1998 Quinn C. Jensen
+ *
+ * Permission to use, copy, modify, distribute, and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  The author makes no representations
+ * about the suitability of this software for any purpose.  It is
+ * provided "as is" without express or implied warranty.
+ *
+ */
+
+V1.3 CHANGES
+
+    - Added intrinsic transcendental functions for constant literal
+      expressions (pi, sin, cos, tan atan, asin, acos, exp, ln, log,
+      pow)
+
+    - Added warnings for control register load/use hazards
+
+    - More sophisticated constant expression evaluation including
+      implicit float/integer conversion.  Results of expressions
+      are typed and so formatted in the listing and symbol table.
+
+    - Various fixes including stray pointers, etc. (Thanks to 
+      Dirk Farin farindk@trick.informatik.uni-stuttgart.de)
+
+Known bugs/deficiencies:
+
+    - MOVE to a control reg generates bogus code (always use MOVEC,
+      MOVEM, and MOVEP)
+
+Wish list
+
+    - Add support for new instructions and modes
+
+
+---------------------------------------------------------------------------
+
+OVERVIEW
+
+This program was written as a vehicle to learn the intricacies
+of the DSP56001 instruction set, and to provide a tool for Unix-based
+DSP code development (for those of us without a NeXT machine.)
+
+The intent was to provide compatibility with Motorola assembler's syntax.
+But since the author did not have Motorola's assembler or its documentation,
+it is no doubt far from compatible.  Only a few pseudo-ops are implemented--
+probably only partially.
+
+Macros are not supported, except through the use of an external macro
+preprocessor, such as /lib/cpp.  To facilitate cpp macro expansion, multiple
+assembler statements on a single input line are delimited with an '@', e.g.:
+
+        #define JCHEQ(c,label)	move #c,x0 @cmp x0,a @jeq label
+
+        #define JCHNE(c,label)	move #c,x0 @cmp x0,a @jne label
+
+
+SUPPORTED PSEUDO-OPS
+
+The following is a list of the pseudo-ops that are recognized:
+
+        <symbol> = <expression>                         ;assign a symbol
+        <label> EQU <expression>                        ;ditto
+
+        ALIGN <number>                                  ;set location pointer
+                                                        ;to next integral
+                                                        ;multiple of <number>
+
+        ORG <space:> <expression>                       ;new location pointer
+        ORG <space:> <expression>, <space:> <expression>
+
+        DC <dc_list>                                    ;declare constants
+
+        DS <number>                                     ;reserve <number>
+                                                        ;words of space
+
+        <label> DSM <number>                            ;reserve space for
+                                                        ;properly aligned
+                                                        ;modulo-addressed
+                                                        ;buffer of size
+                                                        ;<number>, assigning
+                                                        ;the aligned starting
+                                                        ;address to <label>
+
+        PAGE <number>, <number>, <number>, <number>     ;ignored
+
+        INCLUDE <file>                                  ;file inclusion
+
+        END                                             ;end
+
+In addition, a "PSECT" pseudo-op was implemented.  It allows program sections
+to be defined and bopped in and out of, each with its own location counter and
+space.  The Motorola assembler probably does not have this pseudo-op, but no
+doubt supports the concept in some way.
+
+        PSECT <name> <space:><begin_addr>:<end_addr>    ;define
+
+        PSECT <name>                                    ;switch to psect <name>
+
+
+FUTURE DIRECTION
+
+The assembler probably generates bogus code here and there, and no doubt
+does not handle all of the syntax.  I welcome all comments, fixes and 
+enhancements.
+
+TO MAKE AND USE
+
+Type "make".
+
+The resulting program, a56, is used as follows:
+
+        a56 [-b] [-l] [-o output-file] file [...]
+
+An assembler listing is sent to the standard-output and an ascii-formatted
+object file (a56.out) is produced.  The "-b" option adds binary to the listing.
+"-l" causes included files to be listed.  "-o" directs the output to the
+specified file rather than the default, a56.out.
+
+A separate program, toomf, converts a56.out into "OMF" format suitable for 
+downloading to the 56001 via the sloader.a56 program.
+
+        toomf < a56.out > file.omf
+
+AUTHOR
+
+11/28/91
+v1.1 8/6/92
+v1.2 5/2/94
+v1.3 3/18/98
+
+Quinn C. Jensen
+1374 N 40 E
+Orem, UT  84057
+
+http://www.zdomain.com/~jensenq/
+
+home: jensenq@zdomain.com (preferred address for a56 correspondence)
+work: jensenq@novell.com
diff --git a/a56.h b/a56.h
new file mode 100644
index 0000000..474688b
--- /dev/null
+++ b/a56.h
@@ -0,0 +1,94 @@
+/*******************************************************
+ *
+ *  a56 - a DSP56001 assembler
+ *
+ *  Written by Quinn C. Jensen
+ *  July 1990
+ *
+ *******************************************************\
+
+/*
+ * Copyright (C) 1990-1994 Quinn C. Jensen
+ *
+ * Permission to use, copy, modify, distribute, and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  The author makes no representations
+ * about the suitability of this software for any purpose.  It is
+ * provided "as is" without express or implied warranty.
+ *
+ */
+
+/*
+ *  a56.h - general definitions
+ *
+ */
+
+#include <stdio.h>
+
+#ifndef TRUE
+#define TRUE 1
+#define FALSE 0
+#define NOT !
+typedef int BOOL;
+#endif
+
+struct sym {
+	char *name;
+	struct n {
+		short type;
+#define UNDEF -1
+#define INT 0
+#define FLT 1
+		short seg;
+#define NONE 0
+#define PROG 1
+#define XDATA 2
+#define YDATA 3
+#define LDATA 4
+#define ANY 5
+		union val {
+			int i;
+			double f;
+		} val;
+	} n;
+	struct sym *next;
+} *find_sym();
+
+extern int pass;
+
+#define NEW(object) ((object *)alloc(sizeof(object)))
+
+#define MAX_NEST 20		/* maximum include file nesting */
+
+struct inc {
+	char *file;
+	FILE *fp;
+	int line;
+};
+extern struct inc inc[];
+extern int inc_p;
+#define curfile inc[inc_p].file
+#define curline inc[inc_p].line
+
+extern int ldebug;
+
+struct psect {
+	char *name;
+	int seg;
+	unsigned int pc, bottom, top;
+	struct psect *next;
+} *find_psect(), *new_psect();
+
+FILE *open_read(), *open_write(), *open_append();
+
+	/* save string s somewhere */
+#define strsave(s) ((s) != NULL ? \
+		(char *)strcpy((char *)malloc(strlen(s)+1),(s)) : NULL)
+
+	/* after a call to fgets(), remove the newline character */
+#define rmcr(s) {if (s[strlen(s)-1] == '\n') s[strlen(s)-1] = '\0';};
+
+#define ASSERT(expr, str) \
+		if(expr) fprintf(stderr, "ASSERT: %s: line %d: %s\n", __FILE__, __LINE__, str);
diff --git a/a56.key b/a56.key
new file mode 100644
index 0000000..ae7c52b
--- /dev/null
+++ b/a56.key
@@ -0,0 +1,193 @@
+.code	#include "a56.h"
+.code	#include "gram.h"
+X:		{return XMEM;}
+Y:		{return YMEM;}
+L:		{return LMEM;}
+P:		{return PMEM;}
+A10		{return A10;}
+A		{return AAAA;}
+B10		{return B10;}
+B		{return BBBB;}
+AB		{return AABB;}
+BA		{return BBAA;}
+X		{return XXXX;}
+Y		{return YYYY;}
+SR		{return SR;}
+MR		{return MR;}
+CCR		{return CCR;}
+OMR		{return OMR;}
+SP		{return SP;}
+SSH		{return SSH;}
+SSL		{return SSL;}
+LA		{return LA;}
+LC		{return LC;}
+A0		{yylval.ival = 0; return AREG;}
+A1		{yylval.ival = 1; return AREG;}
+A2		{yylval.ival = 2; return AREG;}
+B0		{yylval.ival = 0; return BREG;}
+B1		{yylval.ival = 1; return BREG;}
+B2		{yylval.ival = 2; return BREG;}
+M0		{yylval.ival = 0; return MREG;}
+M1		{yylval.ival = 1; return MREG;}
+M2		{yylval.ival = 2; return MREG;}
+M3		{yylval.ival = 3; return MREG;}
+M4		{yylval.ival = 4; return MREG;}
+M5		{yylval.ival = 5; return MREG;}
+M6		{yylval.ival = 6; return MREG;}
+M7		{yylval.ival = 7; return MREG;}
+N0		{yylval.ival = 0; return NREG;}
+N1		{yylval.ival = 1; return NREG;}
+N2		{yylval.ival = 2; return NREG;}
+N3		{yylval.ival = 3; return NREG;}
+N4		{yylval.ival = 4; return NREG;}
+N5		{yylval.ival = 5; return NREG;}
+N6		{yylval.ival = 6; return NREG;}
+N7		{yylval.ival = 7; return NREG;}
+R0		{yylval.ival = 0; return RREG;}
+R1		{yylval.ival = 1; return RREG;}
+R2		{yylval.ival = 2; return RREG;}
+R3		{yylval.ival = 3; return RREG;}
+R4		{yylval.ival = 4; return RREG;}
+R5		{yylval.ival = 5; return RREG;}
+R6		{yylval.ival = 6; return RREG;}
+R7		{yylval.ival = 7; return RREG;}
+X0		{yylval.ival = 0; return XREG;}
+X1		{yylval.ival = 1; return XREG;}
+Y0		{yylval.ival = 0; return YREG;}
+Y1		{yylval.ival = 1; return YREG;}
+ABS		{return OP_ABS;}
+ADC		{return OP_ADC;}
+ADD		{return OP_ADD;}
+ADDL	{return OP_ADDL;}
+ADDR	{return OP_ADDR;}
+ASL		{return OP_ASL;}
+ASR		{return OP_ASR;}
+CLR		{return OP_CLR;}
+CMP		{return OP_CMP;}
+CMPM	{return OP_CMPM;}
+DIV		{return OP_DIV;}
+MAC		{return OP_MAC;}
+MACR	{return OP_MACR;}
+MPY		{return OP_MPY;}
+MPYR	{return OP_MPYR;}
+NEG		{return OP_NEG;}
+NORM	{return OP_NORM;}
+RND		{return OP_RND;}
+SBC		{return OP_SBC;}
+SUB		{return OP_SUB;}
+SUBL	{return OP_SUBL;}
+SUBR	{return OP_SUBR;}
+TCC		{yylval.cond = 0x0; return OP_TCC;}
+THS		{yylval.cond = 0x0; return OP_TCC;}
+TGE		{yylval.cond = 0x1; return OP_TCC;}
+TNE		{yylval.cond = 0x2; return OP_TCC;}
+TPL		{yylval.cond = 0x3; return OP_TCC;}
+TNN		{yylval.cond = 0x4; return OP_TCC;}
+TEC		{yylval.cond = 0x5; return OP_TCC;}
+TLC		{yylval.cond = 0x6; return OP_TCC;}
+TGT		{yylval.cond = 0x7; return OP_TCC;}
+TCS		{yylval.cond = 0x8; return OP_TCC;}
+TLO		{yylval.cond = 0x8; return OP_TCC;}
+TLT		{yylval.cond = 0x9; return OP_TCC;}
+TEQ		{yylval.cond = 0xA; return OP_TCC;}
+TMI		{yylval.cond = 0xB; return OP_TCC;}
+TNR		{yylval.cond = 0xC; return OP_TCC;}
+TES		{yylval.cond = 0xD; return OP_TCC;}
+TLS		{yylval.cond = 0xE; return OP_TCC;}
+TLE		{yylval.cond = 0xF; return OP_TCC;}
+TFR		{return OP_TFR;}
+TST		{return OP_TST;}
+AND		{return OP_AND;}
+ANDI	{return OP_ANDI;}
+EOR		{return OP_EOR;}
+LSL		{return OP_LSL;}
+LSR		{return OP_LSR;}
+NOT		{return OP_NOT;}
+OR		{return OP_OR;}
+ORI		{return OP_ORI;}
+ROL		{return OP_ROL;}
+ROR		{return OP_ROR;}
+BCLR	{return OP_BCLR;}
+BSET	{return OP_BSET;}
+BCHG	{return OP_BCHG;}
+BTST	{return OP_BTST;}
+DO		{return OP_DO;}
+ENDDO	{return OP_ENDDO;}
+LUA		{return OP_LUA;}
+MOVE	{return OP_MOVE;}
+MOVEC	{return OP_MOVEC;}
+MOVEM	{return OP_MOVEM;}
+MOVEP	{return OP_MOVEP;}
+INCLUDE	{return OP_INCLUDE;}
+ILLEGAL	{return OP_ILLEGAL;}
+JCC		{yylval.cond = 0x0; return OP_JCC;}
+JHS		{yylval.cond = 0x0; return OP_JCC;}
+JGE		{yylval.cond = 0x1; return OP_JCC;}
+JNE		{yylval.cond = 0x2; return OP_JCC;}
+JPL		{yylval.cond = 0x3; return OP_JCC;}
+JNN		{yylval.cond = 0x4; return OP_JCC;}
+JEC		{yylval.cond = 0x5; return OP_JCC;}
+JLC		{yylval.cond = 0x6; return OP_JCC;}
+JGT		{yylval.cond = 0x7; return OP_JCC;}
+JCS		{yylval.cond = 0x8; return OP_JCC;}
+JLO		{yylval.cond = 0x8; return OP_JCC;}
+JLT		{yylval.cond = 0x9; return OP_JCC;}
+JEQ		{yylval.cond = 0xA; return OP_JCC;}
+JMI		{yylval.cond = 0xB; return OP_JCC;}
+JNR		{yylval.cond = 0xC; return OP_JCC;}
+JES		{yylval.cond = 0xD; return OP_JCC;}
+JLS		{yylval.cond = 0xE; return OP_JCC;}
+JLE		{yylval.cond = 0xF; return OP_JCC;}
+JMP		{return OP_JMP;}
+JCLR	{return OP_JCLR;}
+JSET	{return OP_JSET;}
+JSCC	{yylval.cond = 0x0; return OP_JSCC;}
+JSHS	{yylval.cond = 0x0; return OP_JSCC;}
+JSGE	{yylval.cond = 0x1; return OP_JSCC;}
+JSNE	{yylval.cond = 0x2; return OP_JSCC;}
+JSPL	{yylval.cond = 0x3; return OP_JSCC;}
+JSNN	{yylval.cond = 0x4; return OP_JSCC;}
+JSEC	{yylval.cond = 0x5; return OP_JSCC;}
+JSLC	{yylval.cond = 0x6; return OP_JSCC;}
+JSGT	{yylval.cond = 0x7; return OP_JSCC;}
+JSCS	{yylval.cond = 0x8; return OP_JSCC;}
+JSLO	{yylval.cond = 0x8; return OP_JSCC;}
+JSLT	{yylval.cond = 0x9; return OP_JSCC;}
+JSEQ	{yylval.cond = 0xA; return OP_JSCC;}
+JSMI	{yylval.cond = 0xB; return OP_JSCC;}
+JSNR	{yylval.cond = 0xC; return OP_JSCC;}
+JSES	{yylval.cond = 0xD; return OP_JSCC;}
+JSLS	{yylval.cond = 0xE; return OP_JSCC;}
+JSLE	{yylval.cond = 0xF; return OP_JSCC;}
+JSR		{return OP_JSR;}
+JSCLR	{return OP_JSCLR;}
+JSSET	{return OP_JSSET;}
+NOP		{return OP_NOP;}
+REP		{return OP_REP;}
+RESET	{return OP_RESET;}
+RTI		{return OP_RTI;}
+RTS		{return OP_RTS;}
+STOP	{return OP_STOP;}
+SWI		{return OP_SWI;}
+WAIT	{return OP_WAIT;}
+EQU		{return OP_EQU;}
+ORG		{return OP_ORG;}
+DC		{return OP_DC;}
+DS		{return OP_DS;}
+DSM		{return OP_DSM;}
+INT		{return OP_INT;}
+END		{return OP_END;}
+PAGE	{return OP_PAGE;}
+PSECT	{return OP_PSECT;}
+ALIGN	{return OP_ALIGN;}
+PI		{return OP_PI;}
+SIN		{return OP_SIN;}
+COS		{return OP_COS;}
+TAN		{return OP_TAN;}
+ATAN	{return OP_ATAN;}
+ASIN	{return OP_ASIN;}
+ACOS	{return OP_ACOS;}
+EXP		{return OP_EXP;}
+LN		{return OP_LN;}
+LOG		{return OP_LOG;}
+POW		{return OP_POW;}
diff --git a/a56.y b/a56.y
new file mode 100644
index 0000000..9c3399b
--- /dev/null
+++ b/a56.y
@@ -0,0 +1,2114 @@
+%{
+/*******************************************************
+ *
+ *  a56 - a DSP56001 assembler
+ *
+ *  Written by Quinn C. Jensen
+ *  July 1990
+ *
+ *******************************************************/
+
+/*
+ * Copyright (C) 1990-1994 Quinn C. Jensen
+ *
+ * Permission to use, copy, modify, distribute, and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  The author makes no representations
+ * about the suitability of this software for any purpose.  It is
+ * provided "as is" without express or implied warranty.
+ *
+ */
+
+/*
+ *  a56.y - The YACC grammar for the assembler.
+ *
+ *  Note:  This module requires a "BIG" version of YACC.  I had to
+ *  recompile YACC in the largest mode available.
+ *
+ *  Other notes:
+ *
+ *  MOVEC, MOVEM and MOVEP must be used explicitly--MOVE can't yet figure
+ *  out which form to use.
+ *
+ */
+
+#include "a56.h"
+#include <math.h>
+
+unsigned int w0, w1;			/* workspace for the actual generated code */
+BOOL uses_w1;					/* says whether w1 is alive */
+unsigned int pc;				/* current program counter */
+int seg;						/* current segment P: X: Y: or L: */
+int expr_seg;					/* segment of current expression */
+
+int just_rep = 0;				/* keeps track of REP instruction */
+int hot_rreg = -1;				/* rreg loaded by prev inst. or -1 */
+int hot_nreg = -1;				/* nreg loaded by prev inst. or -1 */
+int hot_mreg = -1;				/* mreg loaded by prev inst. or -1 */
+int prev_hot_rreg = -1;			/* rreg loaded by prev inst. or -1 */
+int prev_hot_nreg = -1;			/* nreg loaded by prev inst. or -1 */
+int prev_hot_mreg = -1;			/* mreg loaded by prev inst. or -1 */
+
+int substatement = 0;			/* in a substatement */
+BOOL long_symbolic_expr = FALSE; /* a parser flag */
+char *new_include = NULL;		/* file to be included */
+
+/* listing stuff */
+
+char segs[] = "uPXYL*";
+extern BOOL list_on_next;		/* listing to turn on or off */
+BOOL list_on;					/* listing on at the moment */
+extern char *cur_line;			/* points to line being lex'd */
+char list_buf[1024 + 80];		/* listing buffer */
+char list_buf2[1024 + 80];		/* listing buffer for two-line code */
+BOOL uses_buf2 = FALSE;			/* list_buf2 is alive */
+BOOL list_print_line = FALSE;	/* whether or not to print line in listing */
+char *spaces(), *luntab();
+
+struct n binary_op();
+struct n unary_op();
+struct n sym_ref();
+
+#define R_R6				0x0001
+#define R_R5				0x0002
+#define R_R4				0x0004
+#define R_DATA_ALU_ACCUM	0x0008
+#define R_CTL_REG			0x0010
+#define R_FUNKY_CTL_REG		0x0020
+#define R_SDX				0x0040
+#define R_SDY				0x0080
+#define R_LSD				0x0100
+#define R_AB				0x0200
+#define R_XREG				0x0400
+#define R_YREG				0x0800
+/* registers to which short immediate move is an unsigned int */
+#define R_UINT				0x1000
+/* registers to which short immediate move is an signed frac */
+#define R_SFRAC				0x2000
+%}
+
+%union {
+	int ival;			/* integer value */
+	struct n n;			/* just like in struct sym */
+	double dval;		/* floating point value */
+	char *sval;			/* string */
+	int cval;			/* character */
+	char cond;			/* condition */
+	struct regs {
+		int r6, r5, r4, data_alu_accum, ctl_reg, funky_ctl_reg;
+		int sdx, sdy, lsd, ab, xreg, yreg;
+		int flags;
+	} regs;
+	struct ea {
+		int mode;
+		int ext;
+		int pp;
+	} ea;
+}
+
+%token <n> CHEX CDEC FRAC 
+%token <ival> AREG BREG MREG NREG RREG XREG YREG
+%token <ival> OP OPA OPP
+%token <cond> OP_JCC OP_JSCC OP_TCC
+%token <sval> SYM
+%token <sval> STRING
+%token <cval> CHAR
+%token XMEM
+%token YMEM
+%token LMEM
+%token PMEM
+%token AAAA
+%token A10
+%token BBBB
+%token B10
+%token AABB
+%token BBAA
+%token XXXX
+%token YYYY
+%token SR
+%token MR
+%token CCR
+%token OMR
+%token SP
+%token SSH
+%token SSL
+%token LA
+%token LC
+%token EOL
+%token EOS
+%token LEXBAD
+
+%token OP_ABS
+%token OP_ADC
+%token OP_ADD
+%token OP_ADDL
+%token OP_ADDR
+%token OP_ASL
+%token OP_ASR
+%token OP_CLR
+%token OP_CMP
+%token OP_CMPM
+%token OP_DIV
+%token OP_MAC
+%token OP_MACR
+%token OP_MPY
+%token OP_MPYR
+%token OP_NEG
+%token OP_NORM
+%token OP_RND
+%token OP_SBC
+%token OP_SUB
+%token OP_SUBL
+%token OP_SUBR
+%token OP_TFR
+%token OP_TST
+%token OP_AND
+%token OP_ANDI
+%token OP_EOR
+%token OP_LSL
+%token OP_LSR
+%token OP_NOT
+%token OP_OR
+%token OP_ORI
+%token OP_ROL
+%token OP_ROR
+%token OP_BCLR
+%token OP_BSET
+%token OP_BCHG
+%token OP_BTST
+%token OP_DO
+%token OP_ENDDO
+%token OP_LUA
+%token OP_MOVE
+%token OP_MOVEC
+%token OP_MOVEM
+%token OP_MOVEP
+%token OP_ILLEGAL
+%token OP_INCLUDE
+%token OP_JMP
+%token OP_JCLR
+%token OP_JSET
+%token OP_JSR
+%token OP_JSCLR
+%token OP_JSSET
+%token OP_NOP
+%token OP_REP
+%token OP_RESET
+%token OP_RTI
+%token OP_RTS
+%token OP_STOP
+%token OP_SWI
+%token OP_WAIT
+%token OP_EQU
+%token OP_ORG
+%token OP_DC
+%token OP_DS
+%token OP_DSM
+%token OP_END
+%token OP_PAGE
+%token OP_PSECT
+%token OP_ALIGN
+%token OP_INT
+%token SHL
+%token SHR
+%token OP_PI
+%token OP_SIN
+%token OP_COS
+%token OP_TAN
+%token OP_ATAN
+%token OP_ASIN
+%token OP_ACOS
+%token OP_EXP
+%token OP_LN
+%token OP_LOG
+%token OP_POW
+
+%type <n> num num_or_sym 
+%type <n> num_or_sym_expr
+%type <n> expr
+%type <n> ix
+%type <n> ix_long
+
+%type <ival> abs_addr abs_short_addr io_short_addr 
+%type <ival> a_b x_or_y ea b5_10111_max
+%type <ival> p6_ean_a6 ea_no_ext p6_ea_a6 ea_a6 ea_a12
+%type <ival> ea_short
+%type <ival> prog_ctl_reg
+%type <ival> op8_1 op8_2 op8_3 op8_4 op8_5 op8_6 op8_7 op8_8
+%type <ival> mpy_arg mpy_srcs plus_minus
+%type <ival> sd3
+%type <ival> funky_ctl_reg tcc_sd space
+%type <sval> opt_label
+
+%type <regs> regs
+%type <ea> movep_ea_pp
+
+%left '|'
+%left '^'
+%left SHL SHR
+%left '&'
+%left '+' '-'
+%left '*' '/' '%'
+%right '~'
+
+%start input
+
+%%
+
+/*%%%********************* top syntax ***********************/
+
+input	:	/* empty */
+	|	input statement
+	;
+
+statement
+	:	good_stuff EOL
+			{
+			if(pass == 2 && list_on && list_print_line) {
+				printf(ldebug ? "\n(%s|%s)\n" : "%s%s\n",
+					list_buf, substatement == 0 ? luntab(cur_line) : "");
+				if(uses_buf2)
+					printf(ldebug ? "\n(%s|)\n" : "%s\n",
+						list_buf2);
+				list_buf[0] = list_buf2[0] = '\0';
+			}
+			curline++;
+			uses_buf2 = FALSE;
+			list_print_line = TRUE;
+			list_on = list_on_next;
+			substatement = 0;
+			if(NOT check_psect(seg, pc) && pass == 2)
+				yyerror("%04X: psect violation", pc);
+			}
+	|	good_stuff EOS
+			{
+			if(pass == 2 && list_on && list_print_line) {
+				printf(ldebug ? "\n(%s" : "%s", list_buf);
+				if(substatement == 0)
+					printf(ldebug ? "|%s)\n" : "%s\n", luntab(cur_line));
+				else
+					printf(ldebug ? ")\n" : "\n");
+				if(uses_buf2)
+					printf(ldebug ? "\n(%s|)\n" : "%s\n",
+						list_buf2);
+				list_buf[0] = list_buf2[0] = '\0';
+			}
+			substatement++;
+			uses_buf2 = FALSE;
+			list_print_line = TRUE;
+			list_on = list_on_next;
+			if(NOT check_psect(seg, pc) && pass == 2)
+				yyerror("%04X: psect violation", pc);
+			}
+	|	error EOL
+			{curline++; substatement = 0;}
+	;
+
+good_stuff
+	:	/* empty */
+			{sprintf(list_buf, "%s", spaces(0));}
+	|	cpp_droppings
+			{list_print_line = FALSE;}
+	|	assembler_ops
+			{long_symbolic_expr = FALSE;}
+	|	label_field operation_field
+			{char *printcode();
+			if(pass == 2) {
+				gencode(seg, pc, w0);
+				sprintf(list_buf, "%c:%04X %s ", segs[seg], pc, printcode(w0));
+				pc++;
+				if(uses_w1) {
+					gencode(seg, pc, w1);
+					sprintf(list_buf2, "%c:%04X %s", segs[seg], pc,
+	       					printcode(w1 & 0xFFFFFF));
+					uses_buf2++;
+					pc++;
+				}
+			} else {
+				pc++;
+				if(uses_w1)
+					pc++;
+			}
+			w0 = w1 = 0; uses_w1 = FALSE; 
+			long_symbolic_expr = FALSE;}
+	|	SYM 
+			{sym_def($1, INT, seg, pc);
+			free($1);
+			if(pass == 2 && list_on) {
+				sprintf(list_buf, "%c:%04X%s", segs[seg], pc, spaces(14-8));
+			long_symbolic_expr = FALSE;
+			}}
+	;
+
+cpp_droppings
+	:	'#' num STRING
+			{if(strlen($3) > 0)
+				curfile = $3;
+			else
+				curfile = "<stdin>";
+			curline = $2.val.i - 1;}
+	;
+
+assembler_ops
+	:	SYM OP_EQU expr
+			{sym_def($1, $3.type, ANY, $3.val.i, $3.val.f);
+			free($1);
+			if(pass == 2 && list_on) {
+				if($3.type == INT)
+					sprintf(list_buf, "%06X%s",
+						$3.val.i & 0xFFFFFF,
+						spaces(14-8));
+				else
+					sprintf(list_buf, "%10g%s", $3.val.f,
+						spaces(14-4));
+			}}
+	|	OP_ALIGN expr
+			{int ival = n2int($2);
+			if($2.type == UNDEF) {
+				yyerror("illegal forward reference");
+			} else if (ival <= 1) {
+				yyerror("%d: illegal alignment", ival);
+			} else {
+				if(pc % ival != 0)
+					pc += ival - pc % ival;
+			}
+			if(pass == 2 && list_on)
+				sprintf(list_buf, "%c:%04X%s", segs[seg], pc, 
+					spaces(14-8));
+			}
+	|	OP_PSECT SYM
+			{struct psect *pp = find_psect($2);
+			if(NOT pp) {
+				if(pass == 2)
+					yyerror("%s: undefined psect", $2);
+			} else {
+				seg = pp->seg;
+				pc = pp->pc;
+				set_psect(pp);
+				if(pass == 2 && list_on)
+					sprintf(list_buf, "%c:%04X%s", segs[seg], pc,
+						spaces(14-8));
+			}
+			free($2);}
+	|	OP_PSECT SYM space expr ':' expr
+			{new_psect($2, $3, n2int($4), n2int($6));
+			if(pass == 2 && list_on)
+				sprintf(list_buf, "%c:%04X %04X%s", 
+					segs[$3], n2int($4), n2int($6), spaces(14-8+4+1));
+			}
+	|	OP_ORG space expr
+			{pc = n2int($3);
+			seg = $2;
+			if(pass == 2 && list_on)
+				sprintf(list_buf, "%c:%04X%s", segs[seg], pc, 
+					spaces(14-8));
+			}
+	|	OP_ORG space expr ',' space expr
+			{pc = n2int($3);
+			seg = $2;
+			if(pass == 2 && list_on)
+				sprintf(list_buf, "%c:%04X%s", segs[seg], pc, 
+					spaces(14-8));
+			}
+	|	label_field OP_DC dc_list
+	|	label_field OP_DS expr
+			{pc += n2int($3);
+			if(pass == 2 && list_on)
+				sprintf(list_buf, "%c:%04X%s", segs[seg], pc, 
+					spaces(14-8));
+			}
+	|	opt_label OP_DSM expr
+			{int size = n2int($3);
+			if(size)
+			{    int align = 1;
+			     while(align < size)
+				 align <<= 1;
+			     pc += (align - (pc % align));
+			}
+			if($1)
+			{   sym_def($1, INT, seg, pc);
+ 			    free($1);
+			}
+			pc += size;
+			}
+	|	OP_PAGE num ',' num ',' num ',' num
+			{if(pass == 2 && list_on) {
+				sprintf(list_buf, "%s", spaces(0));
+			}}
+	|	OP_INCLUDE STRING
+			{if(pass == 2 && list_on) {
+				printf(ldebug ? "\n(%s|%s)\n" : "%s%s\n",
+					spaces(0), luntab(cur_line));
+				list_print_line = FALSE;
+			}
+			include($2); /* free($2); */
+			}
+	|	OP_END
+			{if(pass == 2 && list_on) {
+				sprintf(list_buf, "%s", spaces(0));
+			}}
+	;
+
+dc_list
+	:	dc_list ',' dc_stuff
+	|	dc_stuff
+	;
+
+dc_stuff
+	:	STRING
+			{int len = strlen($1), i; char *cp; w0 = 0;
+			if(len % 3 == 2)
+				len++;	/* force empty word */
+			for(i = 0, cp = $1; i < len; i++, cp++) {
+				w0 |= (*cp & 0xFF) << (2 - (i % 3)) * 8;
+				if(i % 3 == 2 || i == len - 1) {
+					if(pass == 2) {
+						if(list_on) sprintf(list_buf, "%c:%04X %06X%s",
+							segs[seg], pc, w0, 
+							spaces(14-6+5));
+						gencode(seg, pc, w0);
+					}
+					pc++; w0 = 0;
+				}
+			}
+			free($1);}
+ 	|	expr
+			{int frac = n2frac($1);
+			if(pass == 2) {
+				if(list_on) {
+					sprintf(list_buf, "%c:%04X %06X%s", segs[seg], pc, 
+						frac & 0xFFFFFF, spaces(14-6+5));
+				}
+				gencode(seg, pc, frac);
+			}
+			pc++;}
+
+space
+	:	PMEM
+			{$$ = PROG;}
+	|	XMEM
+			{$$ = XDATA;}
+	|	YMEM
+			{$$ = YDATA;}
+	|	LMEM
+			{$$ = LDATA;}
+	;       
+
+label_field
+	:	SYM
+			{sym_def($1, INT, seg, pc);
+			free($1);}
+	|	/* empty */
+	;
+
+opt_label
+	:	SYM		{$$ = $1;}
+	|	/* empty */	{$$ = NULL;}
+	;
+
+operation_field
+	:	operation
+			{prev_hot_rreg = hot_rreg;
+			prev_hot_nreg = hot_nreg;
+			prev_hot_mreg = hot_mreg;
+			hot_rreg = hot_nreg = hot_mreg = -1;
+			if(just_rep) 
+				just_rep--;}
+	;
+
+operation
+	:	no_parallel
+	|	parallel_ok
+			{w0 |= 0x200000;}
+	|	parallel_ok parallel_move
+	;
+
+/*%%%************* instructions that allow parallel moves ****************/
+
+parallel_ok
+	:
+		OP_MPY mpy_arg
+			{w0 |= 0x80 | $2 << 2;}
+	|	OP_MPYR mpy_arg
+			{w0 |= 0x81 | $2 << 2;}
+	|	OP_MAC mpy_arg
+			{w0 |= 0x82 | $2 << 2;}
+	|	OP_MACR mpy_arg
+			{w0 |= 0x83 | $2 << 2;}
+
+	|       OP_SUB op8_1
+			{w0 |= 0x04 | $2 << 3;}
+	|	OP_ADD op8_1
+			{w0 |= 0x00 | $2 << 3;}
+	|	OP_MOVE
+			{w0 |= 0x00;}
+
+	|	OP_TFR op8_2
+			{w0 |= 0x01 | $2 << 3;}
+	|	OP_CMP op8_2
+			{w0 |= 0x05 | $2 << 3;}
+	|	OP_CMPM op8_2
+			{w0 |= 0x07 | $2 << 3;}
+
+	|	OP_RND op8_3
+			{w0 |= 0x11 | $2 << 3;}
+	|	OP_ADDL op8_3
+			{w0 |= 0x12 | $2 << 3;}
+	|	OP_CLR op8_3
+			{w0 |= 0x13 | $2 << 3;}
+	|	OP_SUBL op8_3
+			{w0 |= 0x16 | $2 << 3;}
+	|	OP_NOT op8_3
+			{w0 |= 0x17 | $2 << 3;}
+
+	|	OP_ADDR op8_4
+			{w0 |= 0x02 | $2 << 3;}
+	|	OP_TST op8_4
+			{w0 |= 0x03 | $2 << 3;}
+	|	OP_SUBR op8_4
+			{w0 |= 0x06 | $2 << 3;}
+
+	|       OP_AND op8_5
+			{w0 |= 0x46 | $2 << 3;}
+	|	OP_OR op8_5
+			{w0 |= 0x42 | $2 << 3;}
+	|       OP_EOR op8_5
+			{w0 |= 0x43 | $2 << 3;}
+
+	|       OP_ASR op8_6
+			{w0 |= 0x22 | $2 << 3;}
+	|       OP_LSR op8_6
+			{w0 |= 0x23 | $2 << 3;}
+	|       OP_ABS op8_6
+			{w0 |= 0x26 | $2 << 3;}
+	|       OP_ROR op8_6
+			{w0 |= 0x27 | $2 << 3;}
+
+	|       OP_ASL op8_7
+			{w0 |= 0x32 | $2 << 3;}
+	|       OP_LSL op8_7
+			{w0 |= 0x33 | $2 << 3;}
+	|       OP_NEG op8_7
+			{w0 |= 0x36 | $2 << 3;}
+	|       OP_ROL op8_7
+			{w0 |= 0x37 | $2 << 3;}
+
+	|       OP_ADC op8_8
+			{w0 |= 0x21 | $2 << 3;}
+	|       OP_SBC op8_8
+			{w0 |= 0x25 | $2 << 3;}
+	;
+
+mpy_arg	:	plus_minus mpy_srcs ',' a_b
+			{$$ = $1 | $4 << 1 | $2 << 2;}
+	;
+
+plus_minus
+	:	'+'    
+			{$$ = 0;}
+	|	'-'    
+			{$$ = 1;}
+	|	
+			{$$ = 0;}
+	;
+
+mpy_srcs
+	:       XREG ',' XREG
+			{switch ($1 << 4 | $3) {
+				case 0x00: $$ = 0x0; break;
+				case 0x01: 
+				case 0x10: $$ = 0x2; break;
+				case 0x11: 
+					yyerror("illegal source operands"); 
+					break;
+			}}      			
+	|	YREG ',' YREG
+			{switch ($1 << 4 | $3) {
+				case 0x00: $$ = 0x1; break;
+				case 0x01: 
+				case 0x10: $$ = 0x3; break;
+				case 0x11: 
+					yyerror("illegal source operands"); 
+					break;
+			}}      			
+	|	XREG ',' YREG
+			{switch ($1 << 4 | $3) {
+				case 0x00: $$ = 0x5; break;
+				case 0x01: $$ = 0x4; break;
+				case 0x10: $$ = 0x6; break;
+				case 0x11: $$ = 0x7; break;
+			}}      			
+	|	YREG ',' XREG
+			{switch ($1 << 4 | $3) {
+				case 0x00: $$ = 0x5; break;
+				case 0x01: $$ = 0x6; break;
+				case 0x10: $$ = 0x4; break;
+				case 0x11: $$ = 0x7; break;
+			}}      			
+	;
+
+op8_1	:	BBBB ',' AAAA
+			{$$ = 0x2;}
+	|	AAAA ',' BBBB
+			{$$ = 0x3;}
+	|	XXXX ',' a_b
+			{$$ = 0x4 | $3;}
+	|	YYYY ',' a_b
+			{$$ = 0x6 | $3;}
+	|	XREG ',' a_b
+			{$$ = 0x8 | $1 << 2 | $3;}
+	|	YREG ',' a_b
+			{$$ = 0xA | $1 << 2 | $3;}
+	;
+
+op8_2	:	BBBB ',' AAAA
+			{$$ = 0x0;}
+	|	AAAA ',' BBBB
+			{$$ = 0x1;}
+	|	XREG ',' a_b
+			{$$ = 0x8 | $1 << 2 | $3;}
+	|	YREG ',' a_b
+			{$$ = 0xA | $1 << 2 | $3;}
+	;
+
+op8_3	:	AAAA
+			{$$ = 0x0;}
+	|	BBBB
+			{$$ = 0x1;}
+	|	BBBB ',' AAAA
+			{$$ = 0x0;}
+	|	AAAA ',' BBBB
+			{$$ = 0x1;}
+	;
+
+op8_4	:	op8_3
+			{$$ = $1;}
+	;
+
+op8_5	:	XREG ',' a_b
+			{$$ = 0x0 | $1 << 2 | $3;}
+	|	YREG ',' a_b
+			{$$ = 0x2 | $1 << 2 | $3;}
+	;
+
+op8_6	:	a_b
+			{$$ = $1;}
+	;
+
+op8_7	:	a_b
+			{$$ = $1;}
+	;
+
+op8_8	:	XXXX ',' a_b
+			{$$ = 0x0 | $3;}
+	|	YYYY ',' a_b
+			{$$ = 0x2 | $3;}
+	;
+
+a_b	:	AAAA
+			{$$ = 0;}
+	|	BBBB
+			{$$ = 1;}
+	;
+
+no_parallel
+	:	control_inst
+			{if(just_rep == 1)
+				yyerror("instruction not allowed after REP");}
+	|	bit_inst
+	|	move_inst
+	|	arith_inst
+	;
+
+/*%%%************** non-parallel arithmetic and logical ********************/
+
+arith_inst
+	:	OP_NORM RREG ',' a_b
+			{w0 |= 0x01D815 | $2 << 8 | $4 << 3;}
+	|	OP_DIV sd3
+			{w0 |= 0x018040 | $2 << 3;}
+	|	or_op ix ',' funky_ctl_reg
+			{w0 |= 0x0000F8 | (n2int($2) & 0xFF) << 8 | $4;}
+	|	and_op ix ',' funky_ctl_reg
+			{w0 |= 0x0000B8 | (n2int($2) & 0xFF) << 8 | $4;}
+	;
+
+or_op	:	OP_OR
+	|	OP_ORI
+	;
+
+and_op	:	OP_AND
+	|	OP_ANDI
+	;
+
+/*%%%******************************* control instructions **********************/
+
+control_inst
+	:	OP_JSCC ea_a12
+			{if($2) {
+				w0 |= 0x0BC0A0 | $1 << 0;
+			} else {
+				w0 |= 0x0F0000 | $1 << 12;
+			}}
+	|	OP_JCC ea_a12
+			{if($2) {
+				w0 |= 0x0AC0A0 | $1 << 0;
+			} else {
+				w0 |= 0x0E0000 | $1 << 12;
+			}}
+	|	OP_JSR ea_a12
+			{if($2) {
+				w0 |= 0x0BC080;
+			} else {
+				w0 |= 0x0D0000;
+			}}
+	|	OP_JMP ea_a12
+			{if($2) {
+				w0 |= 0x0AC080;
+			} else {
+				w0 |= 0x0C0000;
+			}}
+
+	|	OP_JSSET control_args
+			{w0 |= 0x0B0020;}
+	|	OP_JSCLR control_args
+			{w0 |= 0x0B0000;}
+	|	OP_JSET control_args
+			{w0 |= 0x0A0020;}
+	|	OP_JCLR control_args
+			{w0 |= 0x0A0000;}
+
+	|	OP_REP rep_args
+			{just_rep = 2;}
+	|	OP_DO do_args
+			{uses_w1++;}
+	|	OP_ENDDO
+			{w0 |= 0x00008C;}
+	|	OP_STOP
+			{w0 |= 0x000087;}
+	|	OP_WAIT
+			{w0 |= 0x000086;}
+	|	OP_RESET
+			{w0 |= 0x000084;}
+	|	OP_RTS
+			{w0 |= 0x00000C;}
+	|	OP_SWI
+			{w0 |= 0x000006;}
+	|	OP_ILLEGAL
+			{w0 |= 0x000005;}
+	|	OP_RTI
+			{w0 |= 0x000004;}
+	|	OP_NOP
+			{w0 |= 0x000000;
+			just_rep = 0;}
+	;
+
+do_args
+	:	ix ',' abs_addr
+			{int ival = n2int($1);
+			w0 |= 0x060080 | (ival & 0xFF) << 8 | (ival & 0xF00)>> 8;
+			if(ival > 0xFFF && pass == 2) {
+				yywarning("warning: immediate operand truncated");
+			}
+			w1 |= $3-1;}
+	|	regs ',' abs_addr
+			{w0 |= 0x06C000 | $1.r6 << 8;
+			hot_rreg = hot_nreg = hot_mreg = -1;
+			w1 |= $3-1;}
+	|	x_or_y ea_no_ext ',' abs_addr
+			{w0 |= 0x064000 | $2 << 8 | $1 << 6;
+			w1 |= $4-1;}
+	|	x_or_y abs_short_addr ',' abs_addr	/* allow forced */
+			{w0 |= 0x060000 | ($2 & 0x3F) << 8 | $1 << 6;
+			/*
+			 * $$$ oops, can't check expr_seg because both abs_short_addr and
+			 * abs_addr touch it
+			 */
+			if($2 > 0x003F && pass == 2)
+				yywarning("warning: address operand truncated");
+			w1 |= $4-1;}
+	|	x_or_y abs_addr ',' abs_addr
+			{w0 |= 0x060000 | ($2 & 0x3F) << 8 | $1 << 6;
+			/*
+			 * $$$ oops, can't check expr_seg because both abs_short_addr and
+			 * abs_addr touch it
+			 */
+			if($2 > 0x003F && pass == 2)
+				yywarning("warning: address operand truncated");
+			w1 |= $4-1;}
+	;       		
+
+rep_args
+	:	ix
+			{int ival = n2int($1);
+			w0 |= 0x0600A0 | (ival & 0xFF) << 8 | (ival & 0xF00)>> 8;
+			if(ival > 0xFFF && pass == 2) {
+				yywarning("warning: immediate operand truncated");
+			}}
+	|	regs
+			{w0 |= 0x06C020 | $1.r6 << 8;
+			hot_rreg = hot_nreg = hot_mreg = -1;}
+	|	x_or_y ea_no_ext
+			{w0 |= 0x064020 | $1 << 6 | $2 << 8;}
+	|	x_or_y abs_addr
+			{w0 |= 0x060020 | $1 << 6 | ($2 & 0x3F) << 8;
+			if(expr_seg != ANY && ($1 == 0 && expr_seg != XDATA ||
+				$1 == 1 && expr_seg != YDATA))
+				yywarning("warning: space mismatch");
+			if($2 > 0x003F && pass == 2)
+				yywarning("warning: address operand truncated");
+			}
+	|	x_or_y abs_short_addr	/* forced */
+			{w0 |= 0x060020 | $1 << 6 | ($2 & 0x3F) << 8;
+			if(expr_seg != ANY && ($1 == 0 && expr_seg != XDATA ||
+				$1 == 1 && expr_seg != YDATA))
+				yywarning("warning: space mismatch");
+			if($2 > 0x003F && pass == 2)
+				yywarning("warning: address operand truncated");
+			}
+	;
+
+control_args
+	:	b5_10111_max ',' x_or_y p6_ean_a6 ',' abs_addr
+			{w0 |= $1 << 0 | $3 << 6;
+			uses_w1++;
+			w1 = $6;}
+	|	b5_10111_max ',' regs ',' abs_addr
+			{w0 |= 0x00C000 | $1 << 0 | $3.r6 << 8;
+			hot_rreg = hot_nreg = hot_mreg = -1;
+			uses_w1++;
+			w1 = $5;}
+	;
+
+p6_ean_a6
+	:	abs_addr	/* in pass 2 can always discern size. */
+				/* Sometimes in pass one, too.  But since */
+				/* address extension is always used for the */
+				/* branch target, pass 1 can assume the */
+				/* symbol value will fit; warning in pass 2 */
+				/* if it doesn't */
+			{if($1 != -1) {	/* symbol defined */
+				w0 |= ($1 & 0x3F) << 8;
+				if($1 >= 0xFFC0) {
+					w0 |= 0x008080;
+				} else {
+					w0 |= 0x000080;
+					if($1 > 0x003F && pass == 2)
+						yywarning("warning: address operand truncated");
+				}
+			}}
+	|	abs_short_addr
+			{if($1 != -1) {
+				if($1 > 0x3F && pass == 2)
+					yywarning("warning: address operand truncated");
+				w0 |= 0x000080 | ($1 & 0x3F) << 8;
+			}}
+	|	io_short_addr
+			{if($1 != -1) {
+				if($1 < 0xFFC0 && pass == 2)
+					yywarning("warning: address operand truncated");
+				w0 |= 0x008080 | ($1 & 0x3F) << 8;
+			}}
+	|	ea_no_ext
+			{w0 |= 0x004080 | $1 << 8;}
+	;
+
+/*%%%**************************** bit instructions ***************************/
+
+bit_inst
+	:	OP_BTST bit_args
+			{w0 |= 0x0B0020;}
+	|	OP_BCHG bit_args
+			{w0 |= 0x0B0000;}
+	|	OP_BSET bit_args
+			{w0 |= 0x0A0020;}
+	|	OP_BCLR bit_args
+			{w0 |= 0x0A0000;}
+	;       		
+
+bit_args
+	:	b5_10111_max ',' x_or_y p6_ea_a6
+			{w0 |= $1 << 0 | $3 << 6;
+			}
+	|	b5_10111_max ',' regs
+			{w0 |= 0x00C040 | $1 << 0 | $3.r6 << 8;}
+	;       	
+
+p6_ea_a6
+	:	io_short_addr	/* must be forced to tell from abs_addr */
+			{if($1 != -1) {
+				w0 |= ($1 & 0x3F) << 8 | 0x008000;
+				if($1 < 0xFFC0 && pass == 2)
+					yywarning("warning: address operand truncated");
+			}}
+	|	abs_short_addr	/* must be forced to tell from abs_addr */
+			{if($1 != -1) {
+				w0 |= ($1 & 0x3F) << 8 | 0x000000;
+				if($1 > 0x003F && pass == 2)
+					yywarning("warning: address operand truncated");
+			}}
+	|	ea	/* can use abs_addr */
+			{w0 |= 0x004000;}
+	;
+
+/*%%%************************** move instructions **********************/
+
+move_inst
+	:	OP_MOVEP movep_args
+	|	OP_MOVEM movem_args
+	|	OP_MOVEC movec_args
+	|	OP_LUA ea_short ',' regs
+			{w0 |= 0x044010 | $2 << 8 | $4.r4;}
+	|	OP_TCC tcc_args
+			{w0 |= $1 << 12;}
+	;       	
+
+tcc_args
+	:	tcc_sd
+			{w0 |= 0x020000 | $1 << 3;}
+	|	tcc_sd RREG ',' RREG
+			{w0 |= 0x030000 | $1 << 3 | $2 << 8 | $4;}
+	;
+
+tcc_sd
+	:	regs /* a_b */ ',' regs /* a_b */
+			{hot_rreg = hot_nreg = hot_mreg = -1;
+			if($1.flags & R_AB && $3.flags & R_AB) {
+				if($1.ab == $3.ab) 
+					yyerror("source and dest must be different");
+				$$ = $3.ab;
+			} else if($1.flags & R_XREG && $3.flags & R_AB) {
+				$$ = 0x8 | $1.xreg << 2 | $3.ab;
+			} else if($1.flags & R_YREG && $3.flags & R_AB) {
+				$$ = 0xA | $1.yreg << 2 | $3.ab;
+			} else 
+				yyerror("illegal TCC operands");
+			}
+	;
+
+sd3	:	regs /* XREG */ ',' regs /* a_b */
+			{hot_rreg = hot_nreg = hot_mreg = -1;
+			if($1.flags & R_XREG && $3.flags & R_AB) {
+				$$ = $1.xreg << 2 | $3.ab;
+			} else if($1.flags & R_YREG && $3.flags & R_AB) {
+				$$ = $1.yreg << 2 | 2 | $3.ab;
+			}}
+	;
+
+movec_args
+	:	x_or_y ea ',' regs /* ctl_reg */
+			{if(NOT ($4.flags & R_CTL_REG))
+				yyerror("bad MOVEC target register");
+			if(expr_seg != ANY && ($1 == 0 && expr_seg != XDATA ||
+				$1 == 1 && expr_seg != YDATA))
+				yywarning("warning: space mismatch");
+			if($1 == 0) {
+				w0 |= 0x05C020 | $4.ctl_reg;
+			} else {
+				w0 |= 0x05C060 | $4.ctl_reg;
+			}}
+	|	regs /* ctl_reg */ ',' x_or_y ea
+			{hot_rreg = hot_nreg = hot_mreg = -1;
+			if(NOT ($1.flags & R_CTL_REG))
+				yyerror("bad MOVEC source register");
+			if($3 == 0) {
+				w0 |= 0x054020 | $1.ctl_reg;
+			} else {
+				w0 |= 0x054060 | $1.ctl_reg;
+			}}
+	|	ix ',' regs /* ctl_reg */
+			{int ival = n2int($1);
+			if(NOT ($3.flags & R_CTL_REG))
+				yyerror("bad MOVEC target register");
+			if(ival < 256 && NOT long_symbolic_expr) {
+				w0 |= 0x0500A0 | (ival & 0xFF) << 8 | $3.ctl_reg; 
+			} else {
+				w0 |= 0x05C020 | 0x003400 | $3.ctl_reg;
+				uses_w1++; w1 = ival & 0xFFFF;
+			}}
+	|	x_or_y abs_short_addr ',' regs /* ctl_reg */
+			{if($1 == 0) {
+				w0 |= 0x058020 | ($2 & 0x3F) << 8 | $4.ctl_reg;
+			} else {
+				w0 |= 0x058060 | ($2 & 0x3F) << 8 | $4.ctl_reg;
+			}
+			if(NOT ($4.flags & R_CTL_REG))
+				yyerror("bad MOVEC target register");
+			if($2 > 0x003F && pass == 2)
+				yywarning("warning: address operand truncated");
+			}
+	|	regs /* ctl_reg */ ',' x_or_y abs_short_addr
+			{hot_rreg = hot_nreg = hot_mreg = -1;
+			if($3 == 0) {
+				w0 |= 0x050020 | ($4 & 0x3F) << 8 | $1.ctl_reg;
+			} else {
+				w0 |= 0x050060 | ($4 & 0x3F) << 8 | $1.ctl_reg;
+			}
+			if(NOT ($1.flags & R_CTL_REG))
+				yyerror("bad MOVEC source register");
+			if($4 > 0x003F && pass == 2)
+				yywarning("warning: address operand truncated");
+			}
+	|	regs /* ctl_reg */ ',' regs
+			{if($1.flags & R_CTL_REG) {
+				w0 |= 0x0440A0 | $3.r6 << 8 | $1.ctl_reg;
+			} else if($3.flags & R_CTL_REG) {
+				w0 |= 0x04C0A0 | $1.r6 << 8 | $3.ctl_reg;
+			} else if($1.flags & $3.flags & R_CTL_REG) {
+				/* bogus? $$$ */
+	       			w0 |= 0x04C0A0 | ($1.ctl_reg | 0x20) << 8 | 
+				$3.ctl_reg;
+			} else {
+				yyerror("MOVEC must reference a control reg");
+			}}
+	;
+
+movep_args
+	:	x_or_y movep_ea_pp ',' x_or_y movep_ea_pp
+			{w0 |= 0x084080;
+			switch($2.pp << 1 | $5.pp) {
+				case 0:	case 3:
+					yyerror("illegal MOVEP; can't move EA to EA or IO to IO");
+					break;
+				case 1:	/* ea, pp */
+					w0 |= $4 << 16 | 1 << 15 | $1 << 6 |
+						($5.ext & 0x3F);
+					if($2.mode == 0x003000) {
+						w0 |= 0x003000;
+						uses_w1++;
+						w1 = $2.ext;
+					} else {
+						w0 |= $2.mode;
+					}
+					break;
+				case 2:	/* pp, ea */
+					w0 |= $1 << 16 | 0 << 15 | $4 << 6 |
+						($2.ext & 0x3F);
+					if($5.mode == 0x003000) {
+						w0 |= 0x003000;
+						uses_w1++;
+						w1 = $5.ext;
+					} else {
+						w0 |= $5.mode;
+					}
+					break;
+			}}
+	|	ix ',' x_or_y num_or_sym
+			{w0 |= 0x084080;
+			w0 |= $3 << 16 | 1 << 15 | 0x34 << 8 | 
+				(n2int($4) & 0x3F);
+			uses_w1++;
+			w1 = n2int($1);}
+	|	PMEM ea ',' x_or_y num_or_sym
+			{w0 |= 0x084040;
+			w0 |= $4 << 16 | 1 << 15 | (n2int($5) & 0x3F);}
+	|	x_or_y movep_ea_pp ',' PMEM ea
+			{w0 |= 0x084040;
+			if($2.mode != 0x003000 && $2.mode != 0)
+				yyerror("illegal MOVEP");
+			w0 |= $1 << 16 | 0 << 15 | ($2.ext & 0x3F);}
+	|	regs ',' x_or_y num_or_sym
+			{hot_rreg = hot_nreg = hot_mreg = -1;
+			w0 |= 0x084000;
+			w0 |= $3 << 16 | 1 << 15 | $1.r6 << 8 | 
+				(n2int($4) & 0x3F);}
+	|	x_or_y movep_ea_pp ',' regs
+			{hot_rreg = hot_nreg = hot_mreg = -1;
+			w0 |= 0x084000;
+			if(!$2.pp)
+				yyerror("illegal MOVEP");
+			w0 |= $1 << 16 | 0 << 15 | $4.r6 << 8 | ($2.ext & 0x3F);}
+	;
+
+movep_ea_pp
+	:	abs_addr
+			{if($1 != UNDEF && $1 >= 0xFFC0) {
+				/* defined symbol or constant, in i/o range */
+				$$.pp = 1;
+				$$.mode = 0;
+			} else {
+				/* either out of i/o range or symbol not */
+				/* yet defined:  assume ea extension */
+				$$.pp = 0;
+				$$.mode = 0x003000;
+			}
+			$$.ext = $1;}
+	|	io_short_addr	/* forced i/o short */
+			{$$.pp = 1;
+			$$.mode = 0;
+			if($1 < 0xFFC0 && pass == 2)
+				yywarning("warning: address operand truncated");
+			$$.ext = $1;}
+	|	ea_no_ext
+			{$$.pp = 0;
+			$$.mode = $1 << 8;
+			$$.ext = $1;}
+	;
+
+movem_args
+	:	regs ',' PMEM ea_a6
+			{w0 |= 0x070000 | 0 << 15 | $1.r6;}
+	|	PMEM ea_a6 ',' regs
+			{hot_rreg = hot_nreg = hot_mreg = -1;
+			w0 |= 0x070000 | 1 << 15 | $4.r6;}
+	;
+
+/*%%%**************** memory reference fields ************************/
+
+b5_10111_max
+	:	ix
+			{int ival = n2int($1);
+			$$ = ival; if(ival > 0x17) 
+				yyerror("%d: illegal bit number", ival);}
+	;
+
+x_or_y
+	:	XMEM
+			{$$ = 0;}
+	|	YMEM
+			{$$ = 1;}
+	;
+
+/*%%%**************** effective address fields ************************/
+
+ea_a6
+	:	ea
+			{w0 |= 0x004080;}
+	|	abs_short_addr
+			{w0 |= ($1 & 0x3F) << 8;
+			if($1 > 0x003F && pass == 2)
+				yywarning("warning: address operand truncated");
+			}
+	;
+
+ea_a12
+	:	ea
+			{$$ = 1;}
+	|	abs_short_addr
+			{w0 |= $1 & 0xFFF; $$ = 0;
+			if($1 > 0x0FFF && pass == 2)
+				yywarning("warning: address operand truncated");
+			}
+	;
+
+ea	:	abs_addr
+			{w0 |= 0x003000;
+			uses_w1++;
+			w1 |= $1;
+			$$ = 0x003000;}
+	|	ea_no_ext
+			{w0 |= $1 << 8;
+			$$ = $1 << 8;
+			expr_seg = ANY;}
+	;
+
+ea_no_ext
+	:	ea_short
+			{$$ = $1;}
+	|	'(' RREG ')'
+			{if($2 == prev_hot_rreg) yywarning("warning: r%d just loaded", $2);
+			$$ = 4 << 3 | $2;}
+	|	'(' RREG '+' NREG ')'
+			{if($2 == prev_hot_rreg) yywarning("warning: r%d just loaded", $2);
+			if($4 == prev_hot_nreg) yywarning("warning: n%d just loaded", $4);
+			if($2 == prev_hot_mreg) yywarning("warning: m%d just loaded", $2);
+			$$ = 5 << 3 | $2;
+			if($2 != $4) yyerror("Rn and Nn must be same number");}
+	|	'-' '(' RREG ')'
+			{if($3 == prev_hot_rreg) yywarning("warning: r%d just loaded", $3);
+			if($3 == prev_hot_mreg) yywarning("warning: m%d just loaded", $3);
+			$$ = 7 << 3 | $3;}
+	;
+
+ea_short
+	:	'(' RREG ')' '-' NREG
+			{if($2 == prev_hot_rreg) yywarning("warning: r%d just loaded", $2);
+			if($5 == prev_hot_nreg) yywarning("warning: n%d just loaded", $5);
+			if($2 == prev_hot_mreg) yywarning("warning: m%d just loaded", $2);
+			$$ = 0 << 3 | $2;
+			expr_seg = ANY;
+			if($2 != $5) yyerror("Rn and Nn must be same number");}
+	|	'(' RREG ')' '+' NREG
+			{if($2 == prev_hot_rreg) yywarning("warning: r%d just loaded", $2);
+			if($5 == prev_hot_nreg) yywarning("warning: n%d just loaded", $5);
+			if($2 == prev_hot_mreg) yywarning("warning: m%d just loaded", $2);
+			$$ = 1 << 3 | $2;
+			expr_seg = ANY;
+			if($2 != $5) yyerror("Rn and Nn must be same number");}
+	|	'(' RREG ')' '-'
+			{if($2 == prev_hot_rreg) yywarning("warning: r%d just loaded", $2);
+			if($2 == prev_hot_mreg) yywarning("warning: m%d just loaded", $2);
+			expr_seg = ANY;
+			$$ = 2 << 3 | $2;}
+	|	'(' RREG ')' '+'
+			{if($2 == prev_hot_rreg) yywarning("warning: r%d just loaded", $2);
+			if($2 == prev_hot_mreg) yywarning("warning: m%d just loaded", $2);
+			expr_seg = ANY;
+			$$ = 3 << 3 | $2;}
+	;
+
+/*%%%******************* register fields ******************************/
+
+regs
+	:	XREG
+			{$$.r6 = $$.r5 = 0x04 | $1;
+			$$.sdx = $1;
+			$$.xreg = $1;
+			$$.flags = R_R6|R_R5|R_XREG|R_SDX|R_SFRAC;}
+	|	YREG
+			{$$.r6 = $$.r5 = 0x06 | $1;
+			$$.sdy = $1;
+			$$.yreg = $1;
+			$$.flags = R_R6|R_R5|R_SDY|R_YREG|R_SFRAC;}
+	|	AREG
+			{switch($1) {
+				case 0: 
+					$$.r6 = $$.r5 = 0x08 | 0; 
+					break;
+				case 1: 
+					$$.r6 = $$.r5 = 0x08 | 4; 
+					break;
+				case 2: 
+					$$.r6 = $$.r5 = 0x08 | 2; 
+					break;
+			}
+			$$.flags = R_R6|R_R5|R_UINT;}
+	|	BREG
+			{switch($1) {
+				case 0: 
+					$$.r6 = $$.r5 = 0x08 | 1; break;
+				case 1: 
+					$$.r6 = $$.r5 = 0x08 | 5; break;
+				case 2: 
+					$$.r6 = $$.r5 = 0x08 | 3; break;
+			}
+			$$.flags = R_R6|R_R5|R_UINT;}
+	|	AAAA
+			{$$.r6 = $$.r5 = 0x0E;
+			$$.sdx = $$.sdy = 0x2;
+			$$.ab = 0;
+			$$.lsd = 4;
+			$$.flags = R_R6|R_R5|R_SDX|R_SDY|R_AB|R_LSD|R_SFRAC;}
+	|	BBBB
+			{$$.r6 = $$.r5 = 0x0F;
+			$$.sdx = $$.sdy = 0x3;
+			$$.ab = 1;
+			$$.lsd = 5;
+			$$.flags = R_R6|R_R5|R_SDX|R_SDY|R_AB|R_LSD|R_SFRAC;}
+	|	RREG
+			{$$.r6 = $$.r5 = 0x10 | $1;
+			$$.r4 = 0x00 | $1;
+			$$.flags = R_R6|R_R5|R_R4|R_UINT;
+			hot_rreg = $1;}
+	|	NREG
+			{$$.r6 = $$.r5 = 0x18 | $1;
+			$$.r4 = 0x08 | $1;
+			$$.flags = R_R6|R_R5|R_R4|R_UINT;
+			hot_nreg = $1;}
+	|	MREG
+			{$$.r6 = 0x20 | $1;
+			$$.r5 = -1;
+			$$.ctl_reg = $1;
+			$$.flags = R_R6|R_R5|R_CTL_REG|R_UINT;
+			hot_mreg = $1;}
+	|	prog_ctl_reg
+			{$$.r6 = 0x38 | $1;
+			$$.r5 = -1;
+			$$.ctl_reg = 0x18 | $1;
+			$$.flags = R_R6|R_R5|R_CTL_REG|R_UINT;}
+	|	A10
+			{$$.lsd  = 0;
+			$$.flags = R_LSD;}
+	|	B10
+			{$$.lsd = 1;
+			$$.flags = R_LSD;}
+	|	XXXX
+			{$$.lsd = 2;
+			$$.flags = R_LSD;}
+	|	YYYY
+			{$$.lsd = 3;
+			$$.flags = R_LSD;}
+	|	AABB
+			{$$.lsd = 6;
+			$$.flags = R_LSD;}
+	|	BBAA
+			{$$.lsd = 7;
+			$$.flags = R_LSD;}
+	;
+
+prog_ctl_reg
+	:	SR
+			{$$ = 1;}
+	|	OMR
+			{$$ = 2;}
+	|	SP
+			{$$ = 3;}
+	|	SSH
+			{$$ = 4;}
+	|	SSL
+			{$$ = 5;}
+	|	LA
+			{$$ = 6;}
+	|	LC
+			{$$ = 7;}
+	;
+
+funky_ctl_reg
+	:	MR
+			{$$ = 0;}
+	|	CCR
+			{$$ = 1;}
+	|	OMR
+			{$$ = 2;}
+	;
+
+/*%%%************************* parallel moves *************/
+
+parallel_move
+	:	i_move
+	|	u_move
+	|	x_or_y_move
+	|	xr_move
+	|	ry_move
+	|	r_move
+	|	xy_move
+	|	l_move
+	;
+
+i_move  :	ix ',' regs
+			{int ival = n2int($1);
+			int frac = n2frac($1);
+			int value;
+			BOOL shortform = FALSE;
+			if($3.flags & R_CTL_REG) {
+				yyerror("please use MOVEC for control register moves");
+				break;
+			}
+			if(($3.flags & R_SFRAC) && $1.type == FLT) {
+				if((frac & 0xFFFF) == 0 && 
+					NOT long_symbolic_expr) {
+					value = frac >> 16;
+					shortform++;
+				} else {
+					value = frac;
+				}
+			} else {
+				if(ival <= 0xFF && ival >= -0xFF && NOT long_symbolic_expr) {
+					value = ival;
+					shortform++;
+				} else {
+					value = ival;
+				}
+			}
+
+			if(shortform) {
+				w0 |= 0x200000 | (value & 0xFF) << 8 |
+					$3.r5 << 16;
+			} else {
+				w0 |= 0x400000 | 0x00F400 |
+					($3.r5 >> 3 & 3) << 20 | 
+					($3.r5 & 7) << 16;
+				uses_w1++; w1 = value;
+			}}
+	;
+
+r_move	:	regs ',' regs
+			{
+				if($3.flags & R_CTL_REG) {
+					yyerror("please use MOVEC for control register moves");
+					break;
+				}
+				if($1.flags & R_R5 & $3.flags) 
+					w0 |= 0x200000 | $3.r5 << 8 | $1.r5 << 13;
+				else
+					yyerror("illegal R move");
+			}	
+	;
+
+u_move	:	ea_short
+			{w0 |= 0x204000 | $1 << 8;}
+	;
+
+x_or_y_move
+	:	x_or_y ea ',' regs
+			{w0 |= 0x40C000 | $1 << 19;
+			if(expr_seg != ANY && ($1 == 0 && expr_seg != XDATA ||
+				$1 == 1 && expr_seg != YDATA))
+				yywarning("warning: space mismatch");
+			if($4.flags & R_CTL_REG) {
+				yyerror("please use MOVEC for control register moves");
+				break;
+			}
+			w0 |= ($4.r5 >> 3 & 3) << 20 | ($4.r5 & 7) << 16;}
+	|	x_or_y abs_short_addr ',' regs
+			{w0 |= 0x408000 | $1 << 19 | ($2 & 0x3F) << 8;
+			if(expr_seg != ANY && ($1 == 0 && expr_seg != XDATA ||
+				$1 == 1 && expr_seg != YDATA))
+				yywarning("warning: space mismatch");
+			if($4.flags & R_CTL_REG) {
+				yyerror("please use MOVEC for control register moves");
+				break;
+			}
+			if($2 > 0x003F && pass == 2)
+				yywarning("warning: address operand truncated");
+			w0 |= ($4.r5>> 3 & 3) << 20 | ($4.r5 & 7) << 16;}
+	|	regs ',' x_or_y ea
+			{hot_rreg = hot_nreg = hot_mreg = -1;
+			w0 |= 0x404000 | $3 << 19;
+			if(expr_seg != ANY && ($3 == 0 && expr_seg != XDATA ||
+				$3 == 1 && expr_seg != YDATA))
+				yywarning("warning: space mismatch");
+			if($1.flags & R_CTL_REG) {
+				yyerror("please use MOVEC for control register moves");
+				break;
+			}
+			w0 |= ($1.r5 >> 3 & 3) << 20 | ($1.r5 & 7) << 16;}
+	|	regs ',' x_or_y abs_short_addr
+			{hot_rreg = hot_nreg = hot_mreg = -1;
+			w0 |= 0x400000 | $3 << 19 | ($4 & 0x3F) << 8;
+			if($1.flags & R_CTL_REG) {
+				yyerror("please use MOVEC for control register moves");
+				break;
+			}
+			if(expr_seg != ANY && ($3 == 0 && expr_seg != XDATA ||
+				$3 == 1 && expr_seg != YDATA))
+				yywarning("warning: space mismatch");
+			if($4 > 0x003F && pass == 2)
+				yywarning("warning: address operand truncated");
+			w0 |= ($1.r5 >> 3 & 3) << 20 | ($1.r5 & 7) << 16;}
+	|	ix_long ',' regs
+			{w0 |= 0x400000 | 0x00F400 | ($3.r5 >> 3 & 3) << 20 |
+			    ($3.r5 & 7) << 16;
+			if($3.flags & R_CTL_REG) {
+				yyerror("please use MOVEC for control register moves");
+				break;
+			}
+			uses_w1++; w1 = n2frac($1);
+			}
+	;
+
+xr_move
+	:	x_or_y /* XMEM */ ea ',' regs	regs /* a_b */ ',' YREG
+			{hot_rreg = hot_nreg = hot_mreg = -1;
+			if(expr_seg != ANY && ($1 == 0 && expr_seg != XDATA ||
+				$1 == 1 && expr_seg != YDATA))
+				yywarning("warning: space mismatch");
+			if($1 == 0 && $5.flags & R_AB) {
+				w0 |= 0x108000 | $4.sdx << 18 | $5.ab << 17 |
+					$7 << 16;
+			} else {
+				yyerror("illegal X:R move");
+			}}
+	| 	ix ',' regs		regs /* a_b */ ',' YREG
+			{hot_rreg = hot_nreg = hot_mreg = -1;
+			if($4.flags & R_AB) {
+				w0 |= 0x10B400 | $3.sdx << 18 | $4.ab << 17 |
+					$6 << 16;
+				uses_w1++;
+				w1 |= n2frac($1) & 0xFFFFFF;
+			} else {
+				yyerror("illegal X:R move");
+			}}
+	|	regs ',' x_or_y /* XMEM */ ea	regs /* a_b */ ',' regs/*YREG*/
+			{hot_rreg = hot_nreg = hot_mreg = -1;
+			if(expr_seg != ANY && ($3 == 0 && expr_seg != XDATA ||
+				$3 == 1 && expr_seg != YDATA))
+				yywarning("warning: space mismatch");
+			if($1.flags & R_SDX && $3 == 0 && $5.flags & R_AB &&
+				$7.flags & R_YREG) {
+				w0 |= 0x100000 | $1.sdx << 18 | $5.ab << 17 |
+					$7.yreg << 16;
+			} else if($1.flags & R_AB && $3 == 0 && 
+				$5.flags & R_XREG && $7.flags & R_AB) {
+				if($5.xreg != 0) yyerror("must use X0");
+				if($1.ab == 0 && $7.ab == 0)
+					w0 |= 0x080000;
+				else if($1.ab == 1 && $7.ab == 1)
+					w0 |= 0x090000;
+				else
+					yyerror("illegal X:R move");
+			} else {
+				yyerror("illegal X:R move");
+			}}
+	;
+
+ry_move	:	regs /* a_b */ ',' regs /* XREG	*/      YMEM ea ',' regs
+			{hot_rreg = hot_nreg = hot_mreg = -1;
+			if($3.flags & R_XREG && $7.flags & (R_YREG|R_AB)) {
+				w0 |= 0x10C000 | $1.ab << 19 | $3.xreg << 18 |
+					$7.sdy << 16;
+			} else {
+				yyerror("illegal R:Y move");
+			}}
+	|	regs /* a_b */ ',' regs /* XREG	*/	ix ',' regs
+			{hot_rreg = hot_nreg = hot_mreg = -1;
+			if($3.flags & R_XREG && $6.flags & (R_YREG|R_AB)) {
+				w0 |= 0x10F400 | $1.ab << 19 | $3.xreg << 18 |
+					$6.sdy << 16;
+				uses_w1++;
+				w1 |= n2frac($4) & 0xFFFFFF;
+			} else {
+				yyerror("illegal R:Y move");
+			}}
+	|	regs /* a_b */ ',' regs /* XREG	*/	regs ',' YMEM ea
+			{hot_rreg = hot_nreg = hot_mreg = -1;
+			if($1.flags & R_AB && $3.flags & R_XREG) {
+				w0 |= 0x104000 | $1.ab << 19 | $3.xreg << 18 |
+				$4.sdy << 16;
+			} else if ($1.flags & R_YREG && $3.flags & R_AB &&
+				$4.flags & R_AB) {
+				if($1.yreg != 0) yyerror("must use Y0");
+				if($3.ab == 0 && $4.ab == 0)
+					w0 |= 0x088000;
+				else if($3.ab == 1 && $4.ab == 1)
+					w0 |= 0x098000;
+				else
+					yyerror("illegal R:Y move");
+			} else {
+				yyerror("illegal R:Y move");
+			}}
+	;
+
+l_move
+	:	LMEM ea ',' regs /* lsd */
+			{if($4.flags & R_CTL_REG) {
+				yyerror("please use MOVEC for control register moves");
+				break;
+			}
+			w0 |= 0x40C000 | ($4.lsd & 3) << 16 | ($4.lsd >> 2) << 19;}
+	|	regs /* lsd */ ',' LMEM ea
+			{hot_rreg = hot_nreg = hot_mreg = -1;
+			if($1.flags & R_CTL_REG) {
+				yyerror("please use MOVEC for control register moves");
+				break;
+			}
+			w0 |= 0x404000 | ($1.lsd & 3) << 16 | ($1.lsd >> 2) << 19;}
+	|	LMEM abs_short_addr ',' regs /* lsd */
+			{w0 |= 0x408000 | ($4.lsd & 3) << 16 | ($4.lsd >> 2) << 19;
+			if($4.flags & R_CTL_REG) {
+				yyerror("please use MOVEC for control register moves");
+				break;
+			}
+			if($2 > 0x003F && pass == 2)
+				yywarning("warning: address operand truncated");
+			w0 |= ($2 & 0x3F) << 8;}
+	|	regs /* lsd */ ',' LMEM abs_short_addr
+			{hot_rreg = hot_nreg = hot_mreg = -1;
+			w0 |= 0x400000 | ($1.lsd & 3) << 16 | ($1.lsd >> 2) << 19;
+			if($1.flags & R_CTL_REG) {
+				yyerror("please use MOVEC for control register moves");
+				break;
+			}
+			if($4 > 0x003F && pass == 2)
+				yywarning("warning: address operand truncated");
+			w0 |= ($4 & 0x3F) << 8;}
+	;
+
+xy_move
+	:	x_or_y /*XMEM*/ ea /*ea_strange*/ ',' regs	YMEM ea /*ea_strange*/ ',' regs
+			{int eax = $2, eay = $6,
+			     regx = ($4.flags & R_AB) ? $4.ab | 2 : $4.xreg,
+			     regy = ($8.flags & R_AB) ? $8.ab | 2 : $8.yreg;
+			hot_rreg = hot_nreg = hot_mreg = -1;
+			if((eax & 0x400) == (eay & 0x400))
+				yyerror("registers must be in opposite halves");
+			if(!($4.flags & (R_AB | R_XREG)))
+				yyerror("invalid X move register");
+			if(!($8.flags & (R_AB | R_YREG)))
+				yyerror("invalid Y move register");
+			if($4.flags & R_AB &&
+			   $8.flags & R_AB &&
+			   $4.ab == $8.ab)
+				yyerror("duplicate destination register");
+			w0 = w0 & 0xFF | 0xC08000;	/* both write */
+			w0 |= eax & 0x1f00 | (eay & 0x300) << 5 | (eay & 0x1800) << 9 | regx << 18 | regy << 16;}
+	|	x_or_y /*XMEM*/ ea /*ea_strange*/ ',' regs	regs ',' YMEM ea /*ea_strange*/
+			{int eax = $2, eay = $8,
+			     regx = ($4.flags & R_AB) ? $4.ab | 2 : $4.xreg,
+			     regy = ($5.flags & R_AB) ? $5.ab | 2 : $5.yreg;
+			hot_rreg = hot_nreg = hot_mreg = -1;
+			if((eax & 0x400) == (eay & 0x400))
+				yyerror("registers must be in opposite halves");
+			if(!($4.flags & (R_AB | R_XREG)))
+				yyerror("invalid X move register");
+			if(!($5.flags & (R_AB | R_YREG)))
+				yyerror("invalid Y move register");
+			w0 = w0 & 0xFF | 0x808000;	/* X:write, Y:read */
+			w0 |= eax & 0x1f00 | (eay & 0x300) << 5 | (eay & 0x1800) << 9 | regx << 18 | regy << 16;}
+	|	regs ',' x_or_y /*XMEM*/ ea /*ea_strange*/	YMEM ea /*ea_strange*/ ',' regs
+			{int eax = $4, eay = $6,
+			     regx = ($1.flags & R_AB) ? $1.ab | 2 : $1.xreg,
+			     regy = ($8.flags & R_AB) ? $8.ab | 2 : $8.yreg;
+			hot_rreg = hot_nreg = hot_mreg = -1;
+			if((eax & 0x400) == (eay & 0x400))
+				yyerror("registers must be in opposite halves");
+			if(!($1.flags & (R_AB | R_XREG)))
+				yyerror("invalid X move register");
+			if(!($8.flags & (R_AB | R_YREG)))
+				yyerror("invalid Y move register");
+	      		w0 = w0 & 0xFF | 0xC00000;	/* X:read, Y:write */
+			w0 |= eax & 0x1f00 | (eay & 0x300) << 5 | (eay & 0x1800) << 9 | regx << 18 | regy << 16;}
+	|	regs ',' x_or_y /*XMEM*/ ea /*ea_strange*/	regs ',' YMEM ea /*ea_strange*/
+			{int eax = $4, eay = $8,
+			     regx = ($1.flags & R_AB) ? $1.ab | 2 : $1.xreg,
+			     regy = ($5.flags & R_AB) ? $5.ab | 2 : $5.yreg;
+			hot_rreg = hot_nreg = hot_mreg = -1;
+			if((eax & 0x400) == (eay & 0x400))
+				yyerror("registers must be in opposite halves");
+			if(!($1.flags & (R_AB | R_XREG)))
+				yyerror("invalid X move register");
+			if(!($5.flags & (R_AB | R_YREG)))
+				yyerror("invalid Y move register");
+	      		w0 = w0 & 0xFF | 0x800000;	/* both read */
+			w0 |= eax & 0x1f00 | (eay & 0x300) << 5 | (eay & 0x1800) << 9 | regx << 18 | regy << 16;}
+	;
+
+/*%%%******* absolute address and immediate data fields ************/
+
+num	:	CHEX
+			{$$ = $1;}
+	|	CDEC
+			{$$ = $1;}
+	|	FRAC
+			{$$ = $1;}
+	;
+
+ix	:	'#' expr
+			{$$ = $2; expr_seg = ANY;}
+	|	'#' '<' expr
+			{$$.val.i = n2int($3) & 0xFF;
+			$$.type = INT;
+			expr_seg = ANY;
+			long_symbolic_expr = FALSE;}
+	;
+
+ix_long	:	'#' '>' expr
+			{$$ = $3; expr_seg = ANY;}
+	;
+
+abs_addr
+	:	expr
+			{$$ = n2int($1);
+			expr_seg = $1.seg;}
+	;
+
+abs_short_addr
+	:	'<' expr
+			{$$ = n2int($2);
+			expr_seg = $2.seg;}
+	;
+
+io_short_addr
+	:	SHL expr
+			{$$ = n2int($2);
+			expr_seg = $2.seg;} 
+	;
+
+num_or_sym
+	:	num
+			{$$ = $1;}
+	|	SYM
+			{$$ = sym_ref($1); free($1);}
+	|	io_short_addr
+			{$$.type = INT; $$.val.i = $1; $$.seg = expr_seg;}
+	;
+
+num_or_sym_expr
+	:	num
+			{$$ = $1; expr_seg = $1.seg;}
+	|	SYM
+			{$$ = sym_ref($1);
+			free($1);
+			long_symbolic_expr++;
+			expr_seg = $$.seg;
+			}
+	|	CHAR
+			{$$.type = INT; $$.val.i = $1 & 0xFFFFFF; expr_seg = $$.seg = ANY;}
+	|	'*'
+			{$$.type = INT; $$.val.i = pc; expr_seg = $$.seg = ANY;}
+	|	OP_PI
+			{$$.type = FLT; $$.val.f = acos(-1.0); expr_seg = $$.seg = ANY;}
+	;
+
+expr
+	:	OP_INT '(' expr ')'
+			{$$.type = INT; 
+			if($3.type == INT)
+				$$.val.i = $3.val.i;
+			else
+				$$.val.i = $3.val.f;
+			$$.seg = $3.seg;
+			}
+	|	expr '|' expr
+			{$$ = binary_op($1, '|', $3);}
+	|	expr '^' expr
+			{$$ = binary_op($1, '^', $3);}
+	|	expr '&' expr
+			{$$ = binary_op($1, '&', $3);}
+	|	expr SHR expr
+			{$$ = binary_op($1, SHR, $3);}
+	|	expr SHL expr
+			{$$ = binary_op($1, SHL, $3);}
+	|	expr '-' expr
+			{$$ = binary_op($1, '-', $3);}
+	|	expr '+' expr
+			{$$ = binary_op($1, '+', $3);}
+	|	expr '%' expr
+			{$$ = binary_op($1, '%', $3);}
+	|	expr '/' expr
+			{$$ = binary_op($1, '/', $3);}
+	|	expr '*' expr
+			{$$ = binary_op($1, '*', $3);}
+	|	'-' expr %prec '~'
+			{$$ = unary_op('-', $2);}
+	|	'~' expr
+			{$$ = unary_op('~', $2);}
+	|	OP_SIN '(' expr ')'
+			{$$ = unary_op('s', $3);}
+	|	OP_COS '(' expr ')'
+			{$$ = unary_op('c', $3);}
+	|	OP_TAN '(' expr ')'
+			{$$ = unary_op('t', $3);}
+	|	OP_ASIN '(' expr ')'
+			{$$ = unary_op('S', $3);}
+	|	OP_ACOS '(' expr ')'
+			{$$ = unary_op('C', $3);}
+	|	OP_ATAN '(' expr ')'
+			{$$ = unary_op('T', $3);}
+	|	OP_EXP '(' expr ')'
+			{$$ = unary_op('e', $3);}
+	|	OP_LN '(' expr ')'
+			{$$ = unary_op('l', $3);}
+	|	OP_LOG '(' expr ')'
+			{$$ = unary_op('L', $3);}
+	|	OP_ABS '(' expr ')'
+			{$$ = unary_op('a', $3);}
+	|	OP_POW '(' expr ',' expr ')'
+			{$$ = binary_op($3, 'p', $5);}
+	|	'(' expr ')'
+			{$$ = $2;}
+	|	num_or_sym_expr
+			{$$ = $1;}
+	;
+
+/*%%%****************** end ******************************/
+
+%%
+
+#include <stdio.h>
+#include <setjmp.h>
+#include <sys/signal.h>
+
+int yydebug;
+
+struct n binary_op(a1, op, a2)
+struct n a1, a2;
+int op;
+{
+	struct n result;
+	int iarg1, iarg2;
+	double farg1, farg2;
+
+	if(a1.type == UNDEF || a2.type == UNDEF) {
+		result.type = UNDEF;
+		return result;
+	}
+
+	iarg1 = a1.type == INT ? a1.val.i : a1.val.f;
+	iarg2 = a2.type == INT ? a2.val.i : a2.val.f;
+
+	farg1 = a1.type == INT ? a1.val.i : a1.val.f;
+	farg2 = a2.type == INT ? a2.val.i : a2.val.f;
+
+	/* figure out target segment */
+
+	if(a1.seg == a2.seg)
+		result.seg = a1.seg;
+	else if(a1.seg == ANY)
+		result.seg = a2.seg;
+	else if(a2.seg == ANY)
+		result.seg = a1.seg;
+	else
+		result.seg = NONE;
+
+	/* promote to float automatically */
+
+	if(a1.type != a2.type) {
+		if(a1.type == INT) {
+			a1.val.f = a1.val.i;		/* truncate */
+			a1.type = FLT;
+		} else {
+			a2.val.f = a2.val.i;		/* truncate */
+		}
+	}
+	result.type = a1.type;
+
+	/* do the op */
+
+	switch(op) {
+	case '+':
+		if(result.type == INT) result.val.i = a1.val.i + a2.val.i;
+		else result.val.f = a1.val.f + a2.val.f;
+		break;
+	case '-':
+		if(result.type == INT) result.val.i = a1.val.i - a2.val.i;
+		else result.val.f = a1.val.f - a2.val.f;
+		break;
+	case '*':
+		if(result.type == INT) result.val.i = a1.val.i * a2.val.i;
+		else result.val.f = a1.val.f * a2.val.f;
+		break;
+	case '/':
+		if(result.type == INT) result.val.i = a1.val.i / a2.val.i;
+		else result.val.f = a1.val.f / a2.val.f;
+		break;
+	case '%':
+		result.val.i = iarg1 % iarg2;
+		result.type = INT;
+		break;
+	case SHL:
+		result.val.i = iarg1 << iarg2;
+		result.type = INT;
+		break;
+	case SHR:
+		result.val.i = iarg1 >> iarg2;
+		result.type = INT;
+		break;
+	case '|':
+		result.val.i = iarg1 | iarg2;
+		result.type = INT;
+		break;
+	case '&':
+		result.val.i = iarg1 & iarg2;
+		result.type = INT;
+		break;
+	case '^':
+		result.val.i = iarg1 ^ iarg2;
+		result.type = INT;
+		break;
+	case 'p':
+		result.val.f = pow(farg1, farg2);
+		result.type = FLT;
+	}
+
+	return result;
+}
+
+jmp_buf unary_env;
+
+void
+sigfpu()
+{
+	longjmp(unary_env, 1);
+}
+
+char *unary_name(op)
+{
+	switch(op) {
+	case 's':	return "sin";
+	case 'c':	return "cos";
+	case 't':	return "tan";
+	case 'S':	return "asin";
+	case 'C':	return "acos";
+	case 'T':	return "atan";
+	case 'e':	return "exp";
+   	case 'l':	return "ln";
+	case 'L':	return "log";
+	case 'a':	return "abs";
+	}
+}
+
+struct n unary_op(op, a1)
+int op;
+struct n a1;
+{
+	struct n result;
+	void (*orig)();
+	double farg;
+
+	if(a1.type == UNDEF) {
+		result.type = UNDEF;
+		return result;
+	}
+
+	result.seg = a1.seg;
+
+	/* do the op */
+
+	orig = signal(SIGFPE, sigfpu);
+	if(setjmp(unary_env)) {
+		yyerror("floating point exception in function %s", unary_name(op));
+		result.val.i = result.val.f = 0;
+	} else {
+		farg = a1.type == INT ? (double)a1.val.i : a1.val.f;
+		switch(op) {
+		case '-':
+			result.type = a1.type;
+			if(a1.type == INT) result.val.i = -a1.val.i;
+			else result.val.f = -a1.val.f;
+			break;
+		case '~':
+			result.type = a1.type;
+			if(a1.type == INT) result.val.i = ~a1.val.i;
+			else result.val.f = ~(int)a1.val.f;
+			break;
+		case 'a':
+			result.type = a1.type;
+			if(a1.type == INT) result.val.i = a1.val.i < 0 ? -a1.val.i : a1.val.i;
+			else result.val.f = result.val.f = a1.val.f < 0 ? -a1.val.f : a1.val.f;
+			break;
+		case 's':
+			result.type = FLT;
+			result.val.f = sin(farg);
+			break;
+		case 'c':
+			result.type = FLT;
+			result.val.f = cos(farg);
+			break;
+		case 't':
+			result.type = FLT;
+			result.val.f = tan(farg);
+			break;
+		case 'S':
+			result.type = FLT;
+			result.val.f = asin(farg);
+			break;
+		case 'C':
+			result.type = FLT;
+			result.val.f = acos(farg);
+			break;
+		case 'T':
+			result.type = FLT;
+			result.val.f = atan(farg);
+			break;
+		case 'e':
+			result.type = FLT;
+			result.val.f = exp(farg);
+			break;
+	   	case 'l':
+			result.type = FLT;
+			result.val.f = log(farg);
+			break;
+		case 'L':
+			result.type = FLT;
+			result.val.f = log10(farg);
+			break;
+		}
+	}
+	signal(SIGFPE, orig);
+
+	return result;
+}
+
+n2int(n)
+struct n n;
+{
+	if(n.type == UNDEF)
+		return UNDEF;
+	else if(n.type == INT)
+		return n.val.i;
+	else
+		return n.val.f;
+}
+
+n2frac(n)
+struct n n;
+{
+	double adval = n.val.f >= 0.0 ? n.val.f : -n.val.f;
+
+	if(n.type == UNDEF)
+		return UNDEF;
+	else if(n.type == INT)
+		return n.val.i;
+	else if(n.val.f == -1.0)
+		return 0x800000;
+
+	adval -= (double)(int)adval;
+	adval *= (double)0x800000;
+	adval += 0.5;
+
+	if(n.val.f >= 0.0)
+		return adval;
+	else
+		return -adval;
+}
+
+extern struct {int n; char *name;} tok_tab[];
+extern int n_tok;
+
+char *tok_print(tok)
+int tok;
+{
+	int i;
+	static char buf[32];
+
+	if(tok == '1') {
+		i = 1;
+	}
+
+	if(tok < 256) {
+		sprintf(buf, tok < ' ' ? "\\z%02X" : "%c", tok & 0xFF);
+		return buf;
+	} else {
+		for(i = 0; i < n_tok; i++) {
+			if(tok == tok_tab[i].n)
+				return tok_tab[i].name;
+		}
+	}
+	return "*bogus*";
+}
+
+yyerror(s, a0, a1, a2, a3)
+char *s, *a0, *a1, *a2, *a3;
+{
+	extern int error;
+	char buf[1024];
+
+	error++;
+	sprintf(buf, s, a0, a1, a2, a3);
+
+	if(pass == 2) {
+		fprintf(stderr, "%s: line %d: %s (tok=%s)\n", curfile, curline,
+			buf, tok_print(yychar));
+		fprintf(stderr, "%s\n", cur_line);
+		printf("%s: line %d: %s (tok=%s)\n", curfile, curline,
+			buf, tok_print(yychar));
+	}
+}
+
+yywarning(s, a0, a1, a2, a3)
+char *s, *a0, *a1, *a2, *a3;
+{
+	extern int warning;
+	char buf[1024];
+
+	warning++;
+	sprintf(buf, s, a0, a1, a2, a3);
+
+	if(pass == 2) {
+		fprintf(stderr, "%s: line %d: %s (tok=%s)\n", curfile, curline,
+			buf, tok_print(yychar));
+		fprintf(stderr, "%s\n", cur_line);
+		printf("%s: line %d: %s (tok=%s)\n", curfile, curline,
+			buf, tok_print(yychar));
+	}
+}
+
+char *luntab(s)
+char *s;
+{
+	static char buf[1024];
+	int p;
+
+	strcpy(buf, s);
+
+	untab(buf);
+	p = strlen(buf);
+
+	if(buf[p - 1] == '\n')
+		buf[p - 1] = '\0';
+
+	return buf;
+}
diff --git a/frac2int.c b/frac2int.c
new file mode 100644
index 0000000..8f01796
--- /dev/null
+++ b/frac2int.c
@@ -0,0 +1,118 @@
+#if 0
++----------------------------------------------------------------------+
+|   Question: My filter design package gives me decimal fractional     |
+|             numbers  as output  for my  FIR filter coefficients.     |
+|             How  do I convert  these decimal fractions  into the     |
+|             DSP56200's format?                                       |
++----------------------------------------------------------------------+
+
+      Answer:
+           It's fairly easy to convert decimal fractions into  the
+      data  format required by the DSP56200.  The DSP56200 coeffi-
+      cients are represented as  24-bit  signed,  fractional,  2's
+      complement numbers as shown in Table 1.
+
+         TABLE 1 - Representations for FIR Filter Coefficients
+         -----------------------------------------------------
+
+          Decimal                                  Hexadecimal
+          Fraction       24-Bit Binary Value       Coefficient
+          --------       -------------------       ----------
+
+            0.75     0.1100000 00000000 00000000    60 00 00
+            0.5      0.1000000 00000000 00000000    40 00 00
+            0.25     0.0100000 00000000 00000000    20 00 00
+            0.125    0.0010000 00000000 00000000    10 00 00
+           -0.125    1.1110000 00000000 00000000    F0 00 00
+           -0.75     1.0100000 00000000 00000000    A0 00 00
+
+      Each  24-bit  coefficient  is  separated  into  three  bytes
+      corresponding  to the high, middle, and low bytes.  The high
+      byte is written to the DSP56200 at  address  0A  (hex),  the
+      middle byte to address 0B (hex), and the low byte to address
+      0C (hex).
+
+      Conversion Procedure:
+
+         Step 1:  Multiply the decimal fraction by 8388608.0 (decimal).
+                  Note that 8388608 = 2 raised to the 23rd power.
+         Step 2:  Truncate or round the result into an integer.
+         Step 3:  Logically AND this integer with 00FFFFFF (hex).
+         Step 4:  Write the result to an output file as a hex integer.
+
+      It is easy to write a program to perform this conversion  on
+      a  set  of  coefficients.  If done by computer program, make
+      sure that all integer  variables  are  represented  with  at
+      least  24-bits.   An  example  of  a  short  "C"  program is
+      included at the end of this answer.
+
+      Things to watch for:
+
+         (1) Avoid letting a coefficient value be exactly 800000
+             (-1.0 in a fractional system).  If this coefficient
+             is multiplied by a data sample with value -1.0, the
+             result is -1.0 instead of +1.0 as expected. This is
+             because +1.0 cannot be represented in a signed, 2's
+             complement, fractional system.
+
+         (2) The filter coefficients must  be carefully selected
+             to prevent overflow.   If there is a possibility of
+             overflow with a set of filter coefficients, then all
+             coefficients must be scaled by a constant value. The
+             DSP56200's 24-bit coefficients  allow plenty of room
+             for scaling.   If 12-bit input data samples are used
+             in a system,  the potential  for overflow is greatly
+             reduced if the samples are right justified and sign-
+             extended four bits before they are sent to the 
+             DSP56200.
+
+"C" Program:
+#endif
+           /****************************************\
+           **  DECIMAL FRACTION TO HEX CONVERSION  **
+           \****************************************/
+
+/******************************************************************\
+*  This program converts one decimal, fractional number to a hex   *
+*  number which can be written to the DSP56200's Coefficient RAM   *
+*  Access registers.  It prompts the user for a decimal fraction   *
+*  and returns the corresponding hex number.                       *
+*                                                                  *
+*   Examples of Program Results (useful for checking programs)     *
+*        Inputs                    Outputs                         *
+*        ------                    -------                         *
+*         0.750                =>  600000                          *
+*         0.500                =>  400000                          *
+*         0.250                =>  200000                          *
+*         0.125                =>  100000                          *
+*        -0.125                =>  f00000                          *
+*        -0.750                =>  a00000                          *
+*         0.00784313678741455  =>  010101                          *
+*        -0.00784313678741455  =>  fefeff                          *
+*                                                                  *
+*   Note: The program assumes that the variable type "long" is an  *
+*         integer which is at least 24-bits wide.                  *
+*                                                                  *
+*   Also: The DSP56200 cannot  use any coefficient value with a    *
+*         magnitude of 1.0 or larger.  All coefficients must be    *
+*         signed, fractional quantities.                           *
+\******************************************************************/
+
+main()
+{
+           double fractnum;              /* double precision floating pt */
+           long   hexval;                /* long integer */
+
+    for(;;) {
+        /* Read 1 Decimal Floating Point Number from the Keyboard */
+           printf("Enter the decimal fraction: ");
+           scanf("%lf", &fractnum);
+
+        /* Convert to a Hex Integer which can be used by the DSP56200 */
+           hexval =  (long) (8388608.0 * fractnum);
+           hexval =  0x00ffffffL & hexval;
+
+        /* Write the Hex number out to the Terminal */
+           printf("DSP56200 Coefficient = %06lx\n", hexval);
+    }
+}
diff --git a/getopt.c b/getopt.c
new file mode 100644
index 0000000..6d74b39
--- /dev/null
+++ b/getopt.c
@@ -0,0 +1,129 @@
+/*
+	I got this off net.sources from Henry Spencer.
+	It is a public domain getopt(3) like in System V.
+	I have made the following modifications:
+
+	index(s,c) was added because too many people could
+	not compile getopt without it.
+
+	A test main program was added, ifdeffed by GETOPT.
+	This main program is a public domain implementation
+	of the getopt(1) program like in System V.  The getopt
+	program can be used to standardize shell option handling.
+		e.g.  cc -DGETOPT getopt.c -o getopt
+*/
+#include <stdio.h>
+
+#ifndef lint
+static	char	sccsfid[] = "@(#) getopt.c 5.0 (UTZoo) 1985";
+#endif
+
+#define	ARGCH    (int)':'
+#define BADCH	 (int)'?'
+#define EMSG	 ""
+#define	ENDARGS  "--"
+
+/* this is included because index is not on some UNIX systems */
+static
+char *
+index (s, c)
+register	char	*s;
+register	int 	c;
+	{
+	while (*s)
+		if (c == *s) return (s);
+		else s++;
+	return (NULL);
+	}
+
+/*
+ * get option letter from argument vector
+ */
+int	opterr = 1,		/* useless, never set or used */
+	optind = 1,		/* index into parent argv vector */
+	optopt;			/* character checked for validity */
+char	*optarg;		/* argument associated with option */
+
+#define tell(s)	fputs(*nargv,stderr);fputs(s,stderr); \
+		fputc(optopt,stderr);fputc('\n',stderr);return(BADCH);
+
+
+getopt(nargc,nargv,ostr)
+int	nargc;
+char	**nargv,
+	*ostr;
+{
+	static char	*place = EMSG;	/* option letter processing */
+	register char	*oli;		/* option letter list index */
+	char	*index();
+
+	if(!*place) {			/* update scanning pointer */
+		if(optind >= nargc || *(place = nargv[optind]) != '-' || !*++place) return(EOF);
+		if (*place == '-') {	/* found "--" */
+			++optind;
+			return(EOF);
+		}
+	}				/* option letter okay? */
+	if ((optopt = (int)*place++) == ARGCH || !(oli = index(ostr,optopt))) {
+		if(!*place) ++optind;
+		tell(": illegal option -- ");
+	}
+	if (*++oli != ARGCH) {		/* don't need argument */
+		optarg = NULL;
+		if (!*place) ++optind;
+	}
+	else {				/* need an argument */
+		if (*place) optarg = place;	/* no white space */
+		else if (nargc <= ++optind) {	/* no arg */
+			place = EMSG;
+			tell(": option requires an argument -- ");
+		}
+	 	else optarg = nargv[optind];	/* white space */
+		place = EMSG;
+		++optind;
+	}
+	return(optopt);			/* dump back option letter */
+}
+
+
+#ifdef GETOPT
+
+#ifndef lint
+static	char	sccspid[] = "@(#) getopt.c 5.1 (WangInst) 6/15/85";
+#endif
+
+main (argc, argv) char **argv;
+	{
+	char	*optstring = argv[1];
+	char	*argv0 = argv[0];
+	extern	int 	optind;
+	extern	char	*optarg;
+	int 	opterr = 0;
+	int 	C;
+	char	*opi;
+	if (argc == 1)
+		{
+		fprintf (stderr, "Usage: %s optstring args\n", argv0);
+		exit (1);
+		}
+	argv++;
+	argc--;
+	argv[0] = argv0;
+	while ((C = getopt (argc, argv, optstring)) != EOF)
+		{
+		if (C == BADCH) opterr++;
+		printf ("-%c ", C);
+		opi = index (optstring, C);
+		if (opi && opi[1] == ARGCH)
+			if (optarg)
+				printf ("\"%s\" ", optarg);
+			else opterr++;
+		}
+	printf ("%s", ENDARGS);
+	while (optind < argc)
+		printf (" \"%s\"", argv[optind++]);
+	putchar ('\n');
+	exit (opterr);
+	}
+
+#endif
diff --git a/keybld.c b/keybld.c
new file mode 100644
index 0000000..f3d6ce6
--- /dev/null
+++ b/keybld.c
@@ -0,0 +1,231 @@
+/*
+ * Copyright (C) 1990-1994 Quinn C. Jensen
+ *
+ * Permission to use, copy, modify, distribute, and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  The author makes no representations
+ * about the suitability of this software for any purpose.  It is
+ * provided "as is" without express or implied warranty.
+ *
+ */
+static char *Copyright = "Copyright (C) 1990-1994 Quinn C. Jensen";
+
+/*
+ * keybld - builds a finite-state parser for the given keyword list
+ *
+ */
+
+#include <stdio.h>
+#include "a56.h"
+
+char buf[1024];
+
+main()
+{
+	int line = 0;
+
+	while(gets(buf)) {
+		char *bp = buf;
+		line++;
+		while(*bp != '\t' && *bp != ' ') bp++;
+		*bp++ = '\0';
+		while(*bp == '\t' || *bp == ' ') bp++;
+		if(strcmp(buf, ".code") == 0) {
+			printf("%s\n", bp);
+		} else if(add_tok(buf, bp) == -1) {
+			fprintf(stderr, "input line %d: ambiguous\n", line);
+		}
+	}
+
+	dump_machine();
+	return 0;
+}
+
+#define MAX_CHAR 'z'
+
+#define TRANSITIONS (MAX_CHAR + 1)
+
+struct state {
+	int number;
+	char *seen;
+	struct trans {
+		char action;
+		void *arg;
+	} trans[TRANSITIONS];
+	struct state *next;
+} empty_state, *stop = NULL, *scur = NULL, *new_state();
+int n_states = 0;
+
+/* actions */
+#define NOMATCH 0	/* argument is nothing */
+#define GOTO 1		/* argument is target state */
+#define TERMINAL 2	/* argument is which user action to perform */
+
+struct user_action {
+	char *action;
+	struct user_action *next;
+} *utop = NULL, *ucur = NULL;
+int n_user_actions = 0;
+
+add_tok(tok, actions)
+char *tok, *actions;
+{
+	struct state *scur;
+	struct user_action *unew = (struct user_action *)alloc(sizeof *unew);
+	unew->action = strsave(actions);
+	unew->next = NULL;
+	if(ucur)
+		ucur->next = unew;
+	ucur = unew;
+	if(utop == NULL)
+		utop = unew;
+
+	if(stop == NULL)
+		new_state(NULL);
+
+	if(follow(*tok, tok + 1, stop) == -1)
+		return -1;
+
+	n_user_actions++;
+	return 0;
+}
+
+follow(c, tp, sp)
+char c;
+char *tp;
+struct state *sp;
+{
+	struct trans *arcp, *arcup;
+	
+	if(c >= 'a' && c <= 'z') {
+		c -= 'a' - 'A';
+	}
+	arcp = sp->trans + c;
+
+	if(c >= 'A' && c <= 'Z') {
+		arcup = sp->trans + c + 'a' - 'A';
+	} else {
+		arcup = arcp;
+	}
+
+	if(c == '\0') {
+		if(arcp->action == TERMINAL) {
+			return -1;
+		} else {
+			arcp->action = arcup->action = TERMINAL;
+			arcp->arg = arcup->arg = (void *)n_user_actions;
+			return 0;
+		}
+	} else {
+		if(arcp->action == GOTO) {
+			return follow(*tp, tp + 1, arcp->arg);
+		} else {
+			struct state *new = new_state(tp);
+			arcp->action = arcup->action = GOTO;
+			arcp->arg = arcup->arg = (void *)new;
+			return follow(*tp, tp + 1, new);
+		}
+	}
+}
+
+struct state *new_state(tp)
+char *tp;
+{
+	struct state *snew = (struct state *)alloc(sizeof *snew);
+	char tmp[1024];
+
+	*snew = empty_state;
+
+	snew->number = n_states++;
+
+	snew->next = NULL;
+
+	if(scur)
+		scur->next = snew;
+	scur = snew;
+
+	if(stop == NULL)
+		stop = snew;
+
+	if(tp) {
+		strncpy(tmp, buf, tp - buf);
+		tmp[tp - buf] = '\0';
+	} else
+		strcpy(tmp, "<nothing>");
+
+	snew->seen = strsave(tmp);
+
+	return snew;
+}
+
+dump_machine()
+{
+	struct state *sp;
+	struct user_action *up;
+	int n, a;
+
+	printf("/* state machine generated by keybld */\n");
+	printf("/* states=%d actions=%d */\n", n_states, n_user_actions);
+	printf("/* %d bytes required for transition table storage */\n",
+		sizeof(short) * TRANSITIONS * n_states);
+
+	printf("short transitions[%d][%d] = {\n", n_states, TRANSITIONS);
+	for(n = 0, sp = stop; sp; sp = sp->next, n++) {
+		printf("	/* state %d: \"%s\" */\n", n, sp->seen);
+		printf("	{");
+		for(a = 0; a < TRANSITIONS; a++) {
+			struct trans *tp = sp->trans + a;
+			switch(tp->action) {
+			case GOTO:
+				printf("%d", ((struct state *)tp->arg)->number);
+				break;
+			case TERMINAL:
+				printf("%d", -(int)tp->arg - 1);
+				break;
+			case NOMATCH:
+				printf("0");
+				break;
+			}
+			printf(",%s", a % 20 == 19 ? "\n\t\t" : "");
+		};
+		printf("},\n");
+	}
+
+	printf("};\n");
+
+	printf("\
+\n\
+kparse(kp)\n\
+char *kp;\n\
+{\n\
+	int state = 0;\n\
+\n\
+	for(;;) {\n\
+		short transition = transitions[state][*kp];\n");
+
+printf("\
+		if(transition == 0) {\n\
+			return 0;\n\
+		} else if(transition > 0) {\n\
+			kp++;\n\
+			state = transition;\n\
+		} else {\n\
+			switch(-transition) {\n");
+
+	for(n = 1, up = utop; up; up = up->next, n++) {
+		printf("\
+			case %d:\n\
+				%s;\n\
+				break;\n", n, up->action);
+	}
+
+	printf("\
+			}\n\
+			return transition;\n\
+		}\n\
+	}\n\
+}\n");
+
+}
diff --git a/lex.c b/lex.c
new file mode 100644
index 0000000..5195793
--- /dev/null
+++ b/lex.c
@@ -0,0 +1,477 @@
+/*******************************************************
+ *
+ *  a56 - a DSP56001 assembler
+ *
+ *  Written by Quinn C. Jensen
+ *  July 1990
+ *
+ *******************************************************\
+
+/*
+ *  lex.c - lexical analyzer envelope.  lexyy.c, included below,
+ *  is the LEX-generated code.
+ *
+ */
+
+#include "a56.h"
+#include "gram.h"
+
+int ldebug = 0;
+#ifdef LDEBUG
+#define RET(val) \
+	{\
+		if(ldebug) {\
+			printf("[%s]", tok_print(val));\
+			fflush(stdout);\
+		}\
+		return val;\
+	}
+#else
+#define RET(val) {return val;}
+#endif
+
+extern YYSTYPE yyval;
+
+double atof();
+
+/**************** yylex - returns next token *****************************/
+
+#define MAX_TOK 1024
+char tok[MAX_TOK];
+
+yylex()
+{
+	int ltok = next_tok();
+	int itok;
+
+	switch(ltok) {
+	case EOF:
+		if(yywrap() == 1)
+			return 0;
+		else
+			return yylex();
+		break;
+	case SYM:
+		if(itok = is_keyword(tok)) {
+			RET(itok);
+		} else {
+			yylval.sval = strsave(tok);
+			RET(SYM);
+		}
+		break;
+	case CHEX:
+		yylval.n.type = INT;
+		yylval.n.seg = ANY;
+		yylval.n.val.i = strtol(tok, 0, 16);
+		RET(CHEX);
+		break;
+	case CDEC:
+		yylval.n.type= INT;
+		yylval.n.seg = ANY;
+		yylval.n.val.i = atoi(tok);
+		RET(CDEC);
+		break;
+	case FRAC:
+		yylval.n.type = FLT;
+		yylval.n.seg = ANY;
+		yylval.n.val.f = atof(tok);
+		RET(FRAC);
+	case CHAR:
+		yylval.cval = *tok;
+		RET(CHAR);
+	case STRING:
+		yylval.sval = (char *)fixstring(tok);
+		yylval.sval = strsave(yylval.sval);
+		RET(STRING);
+	default:
+		RET(ltok);
+	}
+}
+
+is_keyword(tok)
+char *tok;
+{
+	int kval = kparse(tok);
+	if(kval > 0)
+		return kval;
+
+	return 0;
+}
+
+struct ascii_tab {
+	char *str;
+	int flags;
+} ascii_tab[];
+#define IS_NONE		0x0000
+#define IS_NUM		0x0001
+#define IS_ALPHA	0x0002
+#define IS_HEX		0x0004
+#define IS_WHITE	0x0008
+
+extern FILE *yyin;
+
+int next_tok()
+{
+	char *tp = tok;
+	enum {S_TOP, S_HEXNUM, S_NUM, S_ALNUM, S_CHAR, S_ESC_CHAR, S_COMMENT,
+		S_SQ_STRING, S_DQ_STRING, S_SHL, S_SHR} state = S_TOP;
+	static int unget = 0;
+	BOOL dot_seen = FALSE;
+
+	for(;;) {
+		int c = unget ? unget : lgetc(yyin);
+		int flags;
+		unget = 0;
+		flags = ascii_tab[c & 0x7F].flags;
+		if(tp > tok + MAX_TOK - 2) return LEXBAD;
+		switch(state) {
+		case S_TOP:
+			if(c == EOF) {
+				return EOF;
+			} else if(flags & IS_WHITE) {
+				/* ignore */ ;
+			} else if(flags & IS_ALPHA) {
+				*tp++ = c;
+				state = S_ALNUM;
+			} else if((flags & IS_NUM) || c == '.') {
+				unget = c;
+				state = S_NUM;
+			} else {
+				switch(c) {
+				case '$': state = S_HEXNUM; break;
+				case '"': state = S_DQ_STRING; break;
+				case '\'': state = S_CHAR; break;
+				case '>': state = S_SHR; break;
+				case '<': state = S_SHL; break;
+				case ';': state = S_COMMENT; break;
+				case '\n': return EOL;
+				case '@': return EOS;
+				default: return c;
+				}
+			}
+			break;
+		case S_COMMENT:
+			if(c == EOF) {
+				unget = EOF;
+				*tp = '\0';
+				return EOL;
+			} else if(c == '\n') {
+				return EOL;
+			}
+			break;
+		case S_SHR:
+			if(c == EOF) {
+				unget = EOF;
+				*tp = '\0';
+				return '>';
+			} else if(c == '>') {
+				return SHR;
+			} else {
+				unget = c;
+				return '>';
+			}
+			break;
+		case S_SHL:
+			if(c == EOF) {
+				unget = EOF;
+				*tp = '\0';
+				return '<';
+			} else if(c == '<') {
+				return SHL;
+			} else {
+				unget = c;
+				return '<';
+			}
+			break;
+		case S_HEXNUM:
+			if(c == EOF) {
+				unget = EOF;
+				*tp = '\0';
+				return CHEX;
+			} else if(flags & IS_HEX) {
+				*tp++ = c;
+				break;
+			} else {
+				unget = c;
+				*tp = '\0';
+				return CHEX;
+			}
+			break;
+		case S_ALNUM:
+			if(c == EOF) {
+				unget = EOF;
+				*tp = '\0';
+				return SYM;
+			} else if(c == ':') {
+				*tp++ = c;
+				*tp = '\0';
+				return SYM;
+				break;
+			} else if(flags & (IS_ALPHA|IS_NUM)) {
+				*tp++ = c;
+				break;
+			} else {
+				unget = c;
+				*tp = '\0';
+				return SYM;
+			}
+			break;
+		case S_NUM:
+			if(c == EOF) {
+				unget = EOF;
+				*tp = '\0';
+				return dot_seen ? FRAC : CDEC;
+			} else if((flags & IS_NUM) || (c == '.' && NOT dot_seen)) {
+				*tp++ = c;
+				if(c == '.') dot_seen = TRUE;
+				break;
+			} else {
+				unget = c;
+				*tp = '\0';
+				return dot_seen ? FRAC : CDEC;
+			}
+			break;
+		case S_CHAR:
+			if(c == EOF) {
+				unget = EOF;
+				*tp = '\0';
+				return CHAR;
+			} else if(c == '\\') {
+				state = S_ESC_CHAR;
+			} else if(c == '\'') {
+				*tp = '\0';
+				return CHAR;
+			} else {
+				*tp++ = c;
+				if(tp > tok + 1)
+					state = S_SQ_STRING;
+			}
+			break;
+		case S_ESC_CHAR:
+			if(c == EOF) {
+				unget = EOF;
+				*tp = '\0';
+				return CHAR;
+			}
+			switch(c) {
+			case 'b': *tp = '\b'; break;
+			case 'f': *tp = '\f'; break;
+			case 'n': *tp = '\n'; break;
+			case 'r': *tp = '\r'; break;
+			case 't': *tp = '\t'; break;
+			case '\\': *tp = '\\'; break;
+			case '\'':
+				*tp = '\0';
+				return CHAR;
+				break;
+			default:
+				*tp++ = c;
+				state = S_SQ_STRING;
+				break;
+			}
+			break;
+		case S_SQ_STRING:
+			if(c == EOF) {
+				unget = EOF;
+				*tp = '\0';
+				return STRING;
+			} else if(c == '\'') {
+				*tp = '\0';
+				return STRING;
+			} else {
+				*tp++ = c;
+			}
+			break;
+		case S_DQ_STRING:
+			if(c == EOF) {
+				unget = EOF;
+				*tp = '\0';
+				return STRING;
+			} else if(c == '"') {
+				*tp = '\0';
+				return STRING;
+			} else {
+				*tp++ = c;
+			}
+			break;
+		} /* switch(state) */
+	} /* for(;;) */
+}
+
+struct ascii_tab ascii_tab[] = {
+	{"\\z00",	IS_NONE					/* 0x00 */},
+	{"\\z01",	IS_NONE					/* 0x01 */},
+	{"\\z02",	IS_NONE					/* 0x02 */},
+	{"\\z03",	IS_NONE					/* 0x03 */},
+	{"\\z04",	IS_NONE					/* 0x04 */},
+	{"\\z05",	IS_NONE					/* 0x05 */},
+	{"\\z06",	IS_NONE					/* 0x06 */},
+	{"\\z07",	IS_NONE					/* 0x07 */},
+	{"\\b",		IS_NONE					/* 0x08 */},
+	{"\\t",		IS_NONE|IS_WHITE		/* 0x09 */},
+	{"\\n",		IS_NONE					/* 0x0A */},
+	{"\\z0B",	IS_NONE					/* 0x0B */},
+	{"\\z0C",	IS_NONE					/* 0x0C */},
+	{"\\r",		IS_NONE					/* 0x0D */},
+	{"\\z0E",	IS_NONE					/* 0x0E */},
+	{"\\z0F",	IS_NONE					/* 0x0F */},
+	{"\\z10",	IS_NONE					/* 0x10 */},
+	{"\\z11",	IS_NONE					/* 0x11 */},
+	{"\\z12",	IS_NONE					/* 0x12 */},
+	{"\\z13",	IS_NONE					/* 0x13 */},
+	{"\\z14",	IS_NONE					/* 0x14 */},
+	{"\\z15",	IS_NONE					/* 0x15 */},
+	{"\\z16",	IS_NONE					/* 0x16 */},
+	{"\\z17",	IS_NONE					/* 0x17 */},
+	{"\\z18",	IS_NONE					/* 0x18 */},
+	{"\\z19",	IS_NONE					/* 0x19 */},
+	{"\\z1A",	IS_NONE					/* 0x1A */},
+	{"\\z1B",	IS_NONE					/* 0x1B */},
+	{"\\z1C",	IS_NONE					/* 0x1C */},
+	{"\\z1D",	IS_NONE					/* 0x1D */},
+	{"\\z1E",	IS_NONE					/* 0x1E */},
+	{"\\z1F",	IS_NONE					/* 0x1F */},
+	{" ",		IS_NONE|IS_WHITE		/* 0x20 */},
+	{"!",		IS_NONE					/* 0x21 */},
+	{"\"",		IS_NONE					/* 0x22 */},
+	{"#",		IS_NONE					/* 0x23 */},
+	{"$",		IS_NONE					/* 0x24 */},
+	{"%",		IS_NONE					/* 0x25 */},
+	{"&",		IS_NONE					/* 0x26 */},
+	{"'",		IS_NONE					/* 0x27 */},
+	{"(",		IS_NONE					/* 0x28 */},
+	{")",		IS_NONE					/* 0x29 */},
+	{"*",		IS_NONE					/* 0x2A */},
+	{"+",		IS_NONE					/* 0x2B */},
+	{",",		IS_NONE					/* 0x2C */},
+	{"-",		IS_NONE					/* 0x2D */},
+	{".",		IS_NONE					/* 0x2E */},
+	{"/",		IS_NONE					/* 0x2F */},
+	{"0",		IS_NONE|IS_NUM|IS_HEX	/* 0x30 */},
+	{"1",		IS_NONE|IS_NUM|IS_HEX	/* 0x31 */},
+	{"2",		IS_NONE|IS_NUM|IS_HEX	/* 0x32 */},
+	{"3",		IS_NONE|IS_NUM|IS_HEX	/* 0x33 */},
+	{"4",		IS_NONE|IS_NUM|IS_HEX	/* 0x34 */},
+	{"5",		IS_NONE|IS_NUM|IS_HEX	/* 0x35 */},
+	{"6",		IS_NONE|IS_NUM|IS_HEX	/* 0x36 */},
+	{"7",		IS_NONE|IS_NUM|IS_HEX	/* 0x37 */},
+	{"8",		IS_NONE|IS_NUM|IS_HEX	/* 0x38 */},
+	{"9",		IS_NONE|IS_NUM|IS_HEX	/* 0x39 */},
+	{":",		IS_NONE					/* 0x3A */},
+	{";",		IS_NONE					/* 0x3B */},
+	{"<",		IS_NONE					/* 0x3C */},
+	{"=",		IS_NONE					/* 0x3D */},
+	{">",		IS_NONE					/* 0x3E */},
+	{"?",		IS_NONE					/* 0x3F */},
+	{"@",		IS_NONE					/* 0x40 */},
+	{"A",		IS_NONE|IS_ALPHA|IS_HEX	/* 0x41 */},
+	{"B",		IS_NONE|IS_ALPHA|IS_HEX	/* 0x42 */},
+	{"C",		IS_NONE|IS_ALPHA|IS_HEX	/* 0x43 */},
+	{"D",		IS_NONE|IS_ALPHA|IS_HEX	/* 0x44 */},
+	{"E",		IS_NONE|IS_ALPHA|IS_HEX	/* 0x45 */},
+	{"F",		IS_NONE|IS_ALPHA|IS_HEX	/* 0x46 */},
+	{"G",		IS_NONE|IS_ALPHA		/* 0x47 */},
+	{"H",		IS_NONE|IS_ALPHA		/* 0x48 */},
+	{"I",		IS_NONE|IS_ALPHA		/* 0x49 */},
+	{"J",		IS_NONE|IS_ALPHA		/* 0x4A */},
+	{"K",		IS_NONE|IS_ALPHA		/* 0x4B */},
+	{"L",		IS_NONE|IS_ALPHA		/* 0x4C */},
+	{"M",		IS_NONE|IS_ALPHA		/* 0x4D */},
+	{"N",		IS_NONE|IS_ALPHA		/* 0x4E */},
+	{"O",		IS_NONE|IS_ALPHA		/* 0x4F */},
+	{"P",		IS_NONE|IS_ALPHA		/* 0x50 */},
+	{"Q",		IS_NONE|IS_ALPHA		/* 0x51 */},
+	{"R",		IS_NONE|IS_ALPHA		/* 0x52 */},
+	{"S",		IS_NONE|IS_ALPHA		/* 0x53 */},
+	{"T",		IS_NONE|IS_ALPHA		/* 0x54 */},
+	{"U",		IS_NONE|IS_ALPHA		/* 0x55 */},
+	{"V",		IS_NONE|IS_ALPHA		/* 0x56 */},
+	{"W",		IS_NONE|IS_ALPHA		/* 0x57 */},
+	{"X",		IS_NONE|IS_ALPHA		/* 0x58 */},
+	{"Y",		IS_NONE|IS_ALPHA		/* 0x59 */},
+	{"Z",		IS_NONE|IS_ALPHA		/* 0x5A */},
+	{"[",		IS_NONE					/* 0x5B */},
+	{"\\",		IS_NONE					/* 0x5C */},
+	{"]",		IS_NONE					/* 0x5D */},
+	{"^",		IS_NONE					/* 0x5E */},
+	{"_",		IS_NONE|IS_ALPHA		/* 0x5F */},
+	{"`",		IS_NONE					/* 0x60 */},
+	{"a",		IS_NONE|IS_ALPHA|IS_HEX	/* 0x61 */},
+	{"b",		IS_NONE|IS_ALPHA|IS_HEX	/* 0x62 */},
+	{"c",		IS_NONE|IS_ALPHA|IS_HEX	/* 0x63 */},
+	{"d",		IS_NONE|IS_ALPHA|IS_HEX	/* 0x64 */},
+	{"e",		IS_NONE|IS_ALPHA|IS_HEX	/* 0x65 */},
+	{"f",		IS_NONE|IS_ALPHA|IS_HEX	/* 0x66 */},
+	{"g",		IS_NONE|IS_ALPHA		/* 0x67 */},
+	{"h",		IS_NONE|IS_ALPHA		/* 0x68 */},
+	{"i",		IS_NONE|IS_ALPHA		/* 0x69 */},
+	{"j",		IS_NONE|IS_ALPHA		/* 0x6A */},
+	{"k",		IS_NONE|IS_ALPHA		/* 0x6B */},
+	{"l",		IS_NONE|IS_ALPHA		/* 0x6C */},
+	{"m",		IS_NONE|IS_ALPHA		/* 0x6D */},
+	{"n",		IS_NONE|IS_ALPHA		/* 0x6E */},
+	{"o",		IS_NONE|IS_ALPHA		/* 0x6F */},
+	{"p",		IS_NONE|IS_ALPHA		/* 0x70 */},
+	{"q",		IS_NONE|IS_ALPHA		/* 0x71 */},
+	{"r",		IS_NONE|IS_ALPHA		/* 0x72 */},
+	{"s",		IS_NONE|IS_ALPHA		/* 0x73 */},
+	{"t",		IS_NONE|IS_ALPHA		/* 0x74 */},
+	{"u",		IS_NONE|IS_ALPHA		/* 0x75 */},
+	{"v",		IS_NONE|IS_ALPHA		/* 0x76 */},
+	{"w",		IS_NONE|IS_ALPHA		/* 0x77 */},
+	{"x",		IS_NONE|IS_ALPHA		/* 0x78 */},
+	{"y",		IS_NONE|IS_ALPHA		/* 0x79 */},
+	{"z",		IS_NONE|IS_ALPHA		/* 0x7A */},
+	{"{",		IS_NONE					/* 0x7B */},
+	{"|",		IS_NONE					/* 0x7C */},
+	{"}",		IS_NONE					/* 0x7D */},
+	{"~",		IS_NONE					/* 0x7E */},
+	{"\\z7F",	IS_NONE					/* 0x7F */},
+};
+
+
+/**************** lgetc - returns next character *************************/
+
+#define INLINE 1024
+
+char line_buf[INLINE];
+char *cur_line = line_buf;		/* points to current line buffer */
+char *clp = NULL;				/* where we're at in cur_line */
+
+lgetc(fp)
+FILE *fp;
+{
+	int c;
+
+	if(clp == NULL) {
+		if(fgets(cur_line, INLINE, fp) == NULL) {
+			c = EOF;
+		} else {
+			clp = cur_line;
+			c = *clp++;
+		}
+	} else {
+		c = *clp++;
+	}
+
+	switch(c) {
+	case EOF:
+		/* at EOF: all done */
+		if(ldebug)
+			printf("<eof>\n");
+		return EOF;
+		break;
+	case '\0':
+		c = '\n';
+	case '\n':
+		clp = NULL;
+		break;
+	default:
+		break;
+	}
+
+	if(ldebug)
+		printf(c < ' ' ? "<\\z%02X>%s" : "<%c>", c, c == '\n' ? "\n" : "");
+
+	return c;
+}
diff --git a/main.c b/main.c
new file mode 100644
index 0000000..e85f8a1
--- /dev/null
+++ b/main.c
@@ -0,0 +1,467 @@
+/*******************************************************
+ *
+ *  a56 - a DSP56001 assembler
+ *
+ *  Written by Quinn C. Jensen
+ *  July 1990
+ *
+ *******************************************************\
+
+/*
+ * Copyright (C) 1990-1994 Quinn C. Jensen
+ *
+ * Permission to use, copy, modify, distribute, and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  The author makes no representations
+ * about the suitability of this software for any purpose.  It is
+ * provided "as is" without express or implied warranty.
+ *
+ */
+static char *Copyright = "Copyright (C) 1990-1994 Quinn C. Jensen";
+
+/*
+ *  main.c - The "main" code for the assembler.
+ *
+ */
+
+#include "a56.h"
+
+#define MAX 1024
+
+int pass;
+int error, warning;
+extern unsigned long pc;
+extern int seg;
+BOOL binary_listing = FALSE;
+BOOL list_includes = FALSE;
+FILE *obj = NULL;
+extern BOOL list_on;
+BOOL list_on_next = TRUE;
+char *alloc();
+
+main(argc,argv)
+int argc;
+char *argv[];
+{
+	int i;
+	extern char *optarg;
+	extern int optind;
+	int c;
+	char *output_file = "a56.out";
+	char *input_file;
+	char *usage = "usage: a56  [-b]  [-l]  [-d]  [-o output-file]  input-file\n";
+
+	while((c = getopt(argc, argv, "bldo:")) != EOF) switch (c) {
+		case 'b':
+			binary_listing++;
+			break;
+		case 'l':
+			list_includes++;
+			break;
+		case 'd':
+			ldebug++;
+			break;
+		case 'o':
+			output_file = optarg;
+			break;
+		case '?':
+		default:
+			fatal(usage);
+	}
+	input_file = argv[optind++];
+	if(input_file == NULL) fatal(usage);
+	obj = open_write(output_file);
+
+	pc = 0;
+	seg = 0;
+	pass = 1;
+	reset_psects();
+	include(input_file);
+
+	pc = 0;
+	seg = 0;
+	pass = 2;
+	reset_psects();
+	include(input_file);
+
+	psect_summary();
+	dump_symtab();
+	fclose(obj);
+	printf("errors=%d\n", error);
+	printf("warnings=%d\n", warning);
+	return error ? 1 : 0;
+}
+
+struct inc inc[MAX_NEST];
+int inc_p = 0;
+FILE *yyin;
+
+include(file)
+char *file;
+{
+	FILE *fp = open_read(file);
+
+	inc_p++;
+	if(inc_p >= MAX_NEST)
+		fatal("%s: include nesting too deep\n", file);
+
+	inc[inc_p].file = file;
+	inc[inc_p].fp = fp;
+	inc[inc_p].line = 1;
+
+	list_on_next = TRUE;
+	if(inc_p > 1 && NOT list_includes)
+		list_on_next = FALSE;
+
+	yyin = inc[inc_p].fp;
+	if(inc_p == 1)
+#ifdef FLEX
+	{
+		static int started = 0;
+		if(started)
+			yyrestart(yyin);
+		else
+			started = 1;
+		yyparse();
+	}
+#else
+		yyparse();
+#endif
+}
+
+yywrap()
+{
+	fclose(inc[inc_p].fp);
+	inc_p--;
+	list_on = list_on_next = TRUE;
+	if(inc_p > 1)
+		list_on = list_on_next = FALSE;
+	if(inc_p) {
+		yyin = inc[inc_p].fp;
+		return 0;
+	} else {
+		return 1;
+	}
+}
+
+struct n
+sym_ref(sym)		/* return symbol value or UNDEF if not defined yet */
+char *sym;
+{
+	struct sym *sp, *find_sym();
+	struct n result;
+
+	result.type = UNDEF;
+
+	sp = find_sym(sym);
+	if(NOT sp) {
+		if(pass == 2) {
+			yyerror("%s: undefined symbol", sym);
+		}		   
+		return result;
+	}
+
+	return sp->n;
+}
+
+#define HASHSIZE 128
+
+#define HASH(sym) (((sym)[0] ^ sym[1]) % HASHSIZE)
+
+struct sym *symtab[HASHSIZE];
+
+sym_def(sym, type, seg, i, f)
+char *sym;
+int type;
+int seg;
+int i;
+double f;
+{
+	struct sym *sp, **stop, *find_sym();
+
+	if(pass == 1) {
+		if(find_sym(sym)) {
+			pass = 2;				/* what a kludge */
+			yyerror("%s: multiply defined symbol", sym);
+			pass = 1;
+			return;
+		}
+		stop = &symtab[HASH(sym)];
+		sp = NEW(struct sym);
+		sp->next = *stop;
+		*stop = sp;
+		sp->name = strsave(sym);
+		sp->n.type = type;
+		sp->n.seg = seg;
+		if(type == INT)
+			sp->n.val.i = i & 0xFFFFFF;
+		else
+			sp->n.val.f = f;
+	} else {
+		sp = find_sym(sym);
+		if(NOT sp)
+			fatal("internal error 304\n");
+		if(sp->n.type != type ||
+			type == INT && sp->n.val.i != (i & 0xFFFFFF) ||
+			type == FLT && sp->n.val.f != f)
+			yyerror("%s: assembler phase error", sym);
+	}		
+}
+
+struct sym *find_sym(sym)
+char *sym;
+{
+	struct sym *sp, **stop;
+
+	stop = &symtab[HASH(sym)];
+	for(sp = *stop; sp; sp = sp->next)
+		if(strcmp(sp->name, sym) == 0)
+			return sp;
+		
+	return NULL;
+}
+
+extern char segs[];
+dump_symtab()
+{
+	struct sym *sp, **stop;
+	int i;
+
+	printf("\n\
+Symbol Table\n\
+-------------------------------------\n");
+/*
+SSSSSSSSSSSSSSSS S XXXXXX
+SSSSSSSSSSSSSSSS S DDDDDDDDD.DDDDDDDDDD
+*/
+
+	for(i = 0, stop = symtab; i < HASHSIZE; i++, stop++) {
+		for(sp = *stop; sp; sp = sp->next) {
+			if(sp->n.type == INT) {
+				printf("%16s %c %06X\n", sp->name, segs[sp->n.seg], sp->n.val.i);
+				fprintf(obj, "I %06X %s\n", sp->n.val.i, sp->name);
+			} else {
+				printf("%16s %c %.10f\n", sp->name, segs[sp->n.seg], sp->n.val.f);
+				fprintf(obj, "F %.10f %s\n", sp->n.val.f, sp->name);
+			}
+		}
+	}   
+}
+
+char *printcode(word)
+int word;
+{
+	static char list[MAX], *lp;
+	int i;
+
+	word &= 0xFFFFFF;
+
+	if(binary_listing) {
+		sprintf(list, "%06X<", word);
+		for(i = 0, lp = &list[7]; i < 24; i++, lp++) {
+			*lp = word & 1 << 23 - i ? '1' : '0';
+			if(i && i % 4 == 3)
+				*++lp = i % 8 == 7 ? ' ' : ',';
+		}
+		lp[-1] = '>';
+		lp[0] = '\0';
+	} else {
+		sprintf(list, "%06X", word);
+	}
+	return list;
+}
+
+char *spacespace[2] = {
+/*P:XXXX_XXXXXX_*/
+ "              ",
+/*P:XXXX_XXXXXX(XXXX_XXXX_XXXX_XXXX_XXXX_XXXX)_*/
+ "                                             "};
+char *spaces(n)
+int n;
+{
+	return spacespace[binary_listing ? 1 : 0] + n;
+}
+
+extern char segs[];
+
+gencode(seg, pc, word)
+int seg, pc, word;
+{
+	fprintf(obj, "%c %04X %06X\n", segs[seg], pc, word & 0xFFFFFF);
+}
+
+char fixbuf[1024];
+
+char *fixstring(s)
+char *s;
+{
+	char *bp = fixbuf;
+	int ival;
+
+	while(*s) {
+		switch (*s) {
+			case '\'':
+			case '\"':
+				s++;
+				break;
+			case '\\':
+				switch (*++s) {
+					case 'b': *bp++ = '\b'; break;
+					case 'r': *bp++ = '\r'; break;
+					case 'f': *bp++ = '\f'; break;
+					case 'n': *bp++ = '\n'; break;
+					case 't': *bp++ = '\t'; break;
+					case '\\': *bp++ = '\\'; break;
+					case '0':
+						ival = 0;
+						while(*s >= '0' && *s <= '9') {
+							ival <<= 3;
+							ival += *s++ - '0';
+						}
+						*bp++ = ival;
+						break;
+				}
+				break;
+			default:
+				*bp++ = *s++;
+				break;
+		}
+	}
+	*bp = '\0';
+	return fixbuf;
+}
+
+#define ONE 0x4000000
+
+makefrac(s)
+char *s;
+{
+	int frac = 0, div = 1;
+	int scale = 1;
+
+	while(*s) {
+		switch(*s) {
+			case '-':
+				scale = -1;
+				break;
+			case '.':
+				div = 10;
+				break;
+			default:
+				frac += (*s - '0') * scale * ONE / div;
+				div *= 10;
+				break;
+		}
+		s++;
+	}
+
+	return frac + scale * 4 >> 3 & 0xFFFFFF;
+}
+
+/***************** psect stuff ************************/
+
+struct psect *ptop = NULL, *cur_psect = NULL;
+
+reset_psects()
+{
+	struct psect *pp;
+
+	for(pp = ptop; pp; pp = pp->next) {
+		pp->pc = pp->bottom;
+	}
+
+	set_psect(NULL);
+}
+
+psect_summary()
+{
+	printf("\nSummary of psect usage\n\n");
+
+	printf("\
+                 section seg base last top      used       avail    total\n\
+-------------------------------------------------------------------------\n");
+/*
+SSSSSSSSSSSSSSSSSSSSSSSS  X  FFFF FFFF FFFF 99999 100%  99999 100%  99999
+*/
+
+	summarize(ptop);	/* do it recursively to place back in order */
+	printf("\n");
+}
+
+summarize(pp)
+struct psect *pp;
+{
+	int used, avail, of;
+
+	if(pp == NULL)
+		return;
+
+	used = pp->pc - pp->bottom;
+	avail = pp->top - pp->pc;
+	of = pp->top - pp->bottom;
+
+	summarize(pp->next);
+
+	printf("%24.24s  %c  %04X %04X %04X %5d %3d%%  %5d %3d%%  %5d\n",
+		pp->name, segs[pp->seg], pp->bottom, pp->pc, pp->top,
+		used, of ? used * 100 / of : 0, avail, of ? avail * 100 / of : 0,
+		of);
+}
+
+struct psect *find_psect(name)
+char *name;
+{
+	struct psect *pp;
+
+	for(pp = ptop; pp; pp = pp->next)
+		if(strcmp(pp->name, name) == 0)
+			return pp;
+
+	return NULL;
+}
+
+set_psect(pp)
+struct psect *pp;
+{
+	cur_psect = pp;
+}
+
+check_psect(seg, pc)
+int seg;
+unsigned int pc;
+{
+	if(cur_psect) {
+		if(seg == cur_psect->seg && pc >= cur_psect->bottom && 
+			pc <= cur_psect->top) {
+			cur_psect->pc = pc;
+			return TRUE;
+		} else {
+			return FALSE;
+		}
+	} else {
+		return TRUE;
+	}
+}
+
+struct psect *new_psect(name, seg, bottom, top)
+char *name;
+int seg;
+unsigned int bottom, top;
+{
+	struct psect *pp = find_psect(name);
+
+	if(NOT pp) {
+		pp = (struct psect *)alloc(sizeof *pp);
+		pp->next = ptop;
+		ptop = pp;
+		pp->name = strsave(name);
+		pp->seg = seg;
+		pp->pc = bottom;
+	}
+	pp->bottom = bottom;
+	pp->top = top;
+
+	return pp;
+}
diff --git a/subs.c b/subs.c
new file mode 100644
index 0000000..a9e0b5e
--- /dev/null
+++ b/subs.c
@@ -0,0 +1,165 @@
+/*******************************************************
+ *
+ *  a56 - a DSP56001 assembler
+ *
+ *  Written by Quinn C. Jensen
+ *  July 1990
+ *
+ *******************************************************\
+
+/*
+ * Copyright (C) 1990-1994 Quinn C. Jensen
+ *
+ * Permission to use, copy, modify, distribute, and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  The author makes no representations
+ * about the suitability of this software for any purpose.  It is
+ * provided "as is" without express or implied warranty.
+ *
+ */
+static char *Copyright = "Copyright (C) 1990-1994 Quinn C. Jensen";
+
+/*
+ *  subs.c - Some subroutines for the assembler.
+ *
+ */
+
+#include "a56.h"
+
+#define MAX 1024
+
+char *alloc();
+
+FILE *open_read(file)
+char *file;
+{
+	FILE *fp;
+
+	if(strcmp(file, "-") == 0)
+		fp = stdin;
+	else if ((fp = fopen(file, "r")) == NULL) {
+		perror(file);
+		exit(1);
+	}	
+	return fp;
+}
+
+FILE *open_write(file)
+char *file;
+{
+	FILE *fp;
+	if ((fp = fopen(file, "w")) == NULL) {
+		perror(file);
+		exit(1);
+	}	
+	return fp;
+}
+
+FILE *open_append(file)
+char *file;
+{
+	FILE *fp;
+	if ((fp = fopen(file, "a")) == NULL) {
+		perror(file);
+		exit(1);
+	}	
+	return fp;
+}
+
+fatal(c, a1, a2, a3, a4, a5, a6, a7, a8)
+char *c, *a1, *a2, *a3, *a4, *a5, *a6, *a7, *a8;
+{
+	fprintf(stderr, c, a1, a2, a3, a4, a5, a6, a7, a8);
+	exit(1);
+}
+
+#define TABS 8
+#define MAX_BUF 256
+
+char tabbuf[MAX_BUF], *untabn();
+char *untab(s)	/* expand tabs in s */
+register char *s;
+{
+	return untabn(s, TABS);
+}
+
+char *untabn(s, stops)	/* expand tabs in s */
+register char *s;
+register int stops;
+{
+	char *o = s;
+
+	/* copy input string into buffer to scan while input string is modified */
+
+	register char *b = tabbuf;
+	
+	strncpy(b, s, MAX_BUF);
+
+	/* iterate until the copy of the input string is depleted */
+
+	while(*b) {
+		if(*b == '\t') {
+			do
+				*s = ' ';
+			while ((++s - o) % stops);
+		} else {
+			*s = *b; s++;
+		}
+		b++;
+	}
+
+	/* null terminate the resultant string */
+
+	*s = '\0';
+
+	return o;
+}
+
+char *alloc(size)
+int size;
+{
+	char *p = (char *)malloc(size);
+	if(NOT p)
+		fatal("alloc:  insufficient virtual memory to allocate %d bytes\n", 
+			size);
+	return p;
+}
+
+#define ascii2n(c)  \
+	((c) >= 'a' ? (c) - 'a' + 10 : ((c) >= 'A' ? (c) - 'A' + 10 : (c) - '0'))
+
+#define valid(c) ((c) >= '0' && (c) <= '9' || \
+	(c) >= 'A' && (c) <= 'Z' || \
+	(c) >= 'a' && (c) <= 'z')
+
+strtol(s, p, base)
+register char *s, **p;
+register int base;
+{
+	register long result = 0;
+	register int sign = 0;
+
+	while(*s == ' ' || *s == '\t')
+		s++;
+
+	if(*s == '-') {
+		s++;
+		sign++;
+	}
+
+	while(valid(*s)) {
+		register int dig = ascii2n(*s);
+		if(dig >= base)
+			break;
+		result *= base;
+		result += dig;
+ 		s++;
+	}
+
+	if(p)
+		*p = s;
+
+	return sign ? -result : result;
+}
diff --git a/tok.awk b/tok.awk
new file mode 100644
index 0000000..44e02aa
--- /dev/null
+++ b/tok.awk
@@ -0,0 +1,4 @@
+BEGIN		{printf("struct {int n; char *name;} tok_tab[] = {\n");}
+/#define/	{printf("    {%d, \"%s\"},\n", $3, $2);}
+/# define/	{printf("    {%d, \"%s\"},\n", $4, $3);}
+END		{printf("};\n#define N_TOK (sizeof tok_tab / sizeof tok_tab[0])\nint n_tok = N_TOK;\n");}
diff --git a/toktab.c b/toktab.c
new file mode 100644
index 0000000..e70ea14
--- /dev/null
+++ b/toktab.c
@@ -0,0 +1,131 @@
+struct {int n; char *name;} tok_tab[] = {
+    {257, "CHEX"},
+    {258, "CDEC"},
+    {259, "FRAC"},
+    {260, "AREG"},
+    {261, "BREG"},
+    {262, "MREG"},
+    {263, "NREG"},
+    {264, "RREG"},
+    {265, "XREG"},
+    {266, "YREG"},
+    {267, "OP"},
+    {268, "OPA"},
+    {269, "OPP"},
+    {270, "OP_JCC"},
+    {271, "OP_JSCC"},
+    {272, "OP_TCC"},
+    {273, "SYM"},
+    {274, "STRING"},
+    {275, "CHAR"},
+    {276, "XMEM"},
+    {277, "YMEM"},
+    {278, "LMEM"},
+    {279, "PMEM"},
+    {280, "AAAA"},
+    {281, "A10"},
+    {282, "BBBB"},
+    {283, "B10"},
+    {284, "AABB"},
+    {285, "BBAA"},
+    {286, "XXXX"},
+    {287, "YYYY"},
+    {288, "SR"},
+    {289, "MR"},
+    {290, "CCR"},
+    {291, "OMR"},
+    {292, "SP"},
+    {293, "SSH"},
+    {294, "SSL"},
+    {295, "LA"},
+    {296, "LC"},
+    {297, "EOL"},
+    {298, "EOS"},
+    {299, "LEXBAD"},
+    {300, "OP_ABS"},
+    {301, "OP_ADC"},
+    {302, "OP_ADD"},
+    {303, "OP_ADDL"},
+    {304, "OP_ADDR"},
+    {305, "OP_ASL"},
+    {306, "OP_ASR"},
+    {307, "OP_CLR"},
+    {308, "OP_CMP"},
+    {309, "OP_CMPM"},
+    {310, "OP_DIV"},
+    {311, "OP_MAC"},
+    {312, "OP_MACR"},
+    {313, "OP_MPY"},
+    {314, "OP_MPYR"},
+    {315, "OP_NEG"},
+    {316, "OP_NORM"},
+    {317, "OP_RND"},
+    {318, "OP_SBC"},
+    {319, "OP_SUB"},
+    {320, "OP_SUBL"},
+    {321, "OP_SUBR"},
+    {322, "OP_TFR"},
+    {323, "OP_TST"},
+    {324, "OP_AND"},
+    {325, "OP_ANDI"},
+    {326, "OP_EOR"},
+    {327, "OP_LSL"},
+    {328, "OP_LSR"},
+    {329, "OP_NOT"},
+    {330, "OP_OR"},
+    {331, "OP_ORI"},
+    {332, "OP_ROL"},
+    {333, "OP_ROR"},
+    {334, "OP_BCLR"},
+    {335, "OP_BSET"},
+    {336, "OP_BCHG"},
+    {337, "OP_BTST"},
+    {338, "OP_DO"},
+    {339, "OP_ENDDO"},
+    {340, "OP_LUA"},
+    {341, "OP_MOVE"},
+    {342, "OP_MOVEC"},
+    {343, "OP_MOVEM"},
+    {344, "OP_MOVEP"},
+    {345, "OP_ILLEGAL"},
+    {346, "OP_INCLUDE"},
+    {347, "OP_JMP"},
+    {348, "OP_JCLR"},
+    {349, "OP_JSET"},
+    {350, "OP_JSR"},
+    {351, "OP_JSCLR"},
+    {352, "OP_JSSET"},
+    {353, "OP_NOP"},
+    {354, "OP_REP"},
+    {355, "OP_RESET"},
+    {356, "OP_RTI"},
+    {357, "OP_RTS"},
+    {358, "OP_STOP"},
+    {359, "OP_SWI"},
+    {360, "OP_WAIT"},
+    {361, "OP_EQU"},
+    {362, "OP_ORG"},
+    {363, "OP_DC"},
+    {364, "OP_DS"},
+    {365, "OP_DSM"},
+    {366, "OP_END"},
+    {367, "OP_PAGE"},
+    {368, "OP_PSECT"},
+    {369, "OP_ALIGN"},
+    {370, "OP_INT"},
+    {371, "SHL"},
+    {372, "SHR"},
+    {373, "OP_PI"},
+    {374, "OP_SIN"},
+    {375, "OP_COS"},
+    {376, "OP_TAN"},
+    {377, "OP_ATAN"},
+    {378, "OP_ASIN"},
+    {379, "OP_ACOS"},
+    {380, "OP_EXP"},
+    {381, "OP_LN"},
+    {382, "OP_LOG"},
+    {383, "OP_POW"},
+};
+#define N_TOK (sizeof tok_tab / sizeof tok_tab[0])
+int n_tok = N_TOK;
diff --git a/toomf.c b/toomf.c
new file mode 100644
index 0000000..2504b80
--- /dev/null
+++ b/toomf.c
@@ -0,0 +1,60 @@
+/*******************************************************
+ *
+ *  a56 - a DSP56001 assembler
+ *
+ *  Written by Quinn C. Jensen
+ *  July 1990
+ *
+ *******************************************************\
+
+/*
+ * Copyright (C) 1990-1994 Quinn C. Jensen
+ *
+ * Permission to use, copy, modify, distribute, and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  The author makes no representations
+ * about the suitability of this software for any purpose.  It is
+ * provided "as is" without express or implied warranty.
+ *
+ */
+static char *Copyright = "Copyright (C) 1990-1994 Quinn C. Jensen";
+
+/*
+ *  This small program converts the a56.out file from the assembler
+ *  into a file suitable for loading into 56001 memory via the
+ *  SLOADER.ASM serial loader program provided on the Motorola
+ *  Dr. Bubb BBS.
+ *
+ */
+
+#define MAX 256
+
+main(argc,argv)
+int argc;
+char *argv[];
+{
+	char buf[MAX];
+	int curaddr = 0;
+	int line = 0;
+	int curseg = '\0';
+	int startaddr = -1;
+
+	while(gets(buf)) {
+		char seg;
+		int addr, data;
+		line++;
+		if(sscanf(buf, "%c%x%x", &seg, &addr, &data) == 3) {
+			if(seg == 'I' || seg == 'F') break;
+			if(seg != curseg || curaddr != addr) {
+				printf("\n_DATA %c %04X\n", curseg = seg, curaddr = addr);
+			}   
+			if(startaddr == -1 && seg == 'P')
+				startaddr = addr;
+			printf("%06X ", data & 0xFFFFFF);
+			curaddr++;
+		}
+	}
+	printf("\n_END %04X\n", startaddr);
+}
diff --git a/torom.c b/torom.c
new file mode 100644
index 0000000..afb79c2
--- /dev/null
+++ b/torom.c
@@ -0,0 +1,70 @@
+/*******************************************************
+ *
+ *  a56 - a DSP56001 assembler
+ *
+ *  Written by Quinn C. Jensen
+ *  July 1990
+ *
+ *******************************************************\
+
+/*
+ * Copyright (C) 1990-1994 Quinn C. Jensen
+ *
+ * Permission to use, copy, modify, distribute, and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  The author makes no representations
+ * about the suitability of this software for any purpose.  It is
+ * provided "as is" without express or implied warranty.
+ *
+ */
+static char *Copyright = "Copyright (C) 1990-1994 Quinn C. Jensen";
+
+/*
+ *  This program converts the a56.out assembler output file into
+ *  raw binary, suitable for conversion to S-records for an EPROM burner.
+ *
+ */
+
+
+#define MAX 256
+
+main(argc,argv)
+int argc;
+char *argv[];
+{
+	char buf[MAX];
+	int curaddr = 0;
+	int line = 0;
+
+	while(gets(buf)) {
+		char seg;
+		int addr, data;
+		line++;
+		if(sscanf(buf, "%c%x%x", &seg, &addr, &data) == 3) {
+			if(seg == 'I') {
+				break;
+			} else {
+				if(addr < curaddr) {
+					fatal("%s: input line %d: can't go back\n", argv[0], line);
+				} else if(addr != curaddr) {
+					while(curaddr < addr) {
+						putword(0);
+						curaddr++;
+					}
+				}
+				putword(data);
+				curaddr++;
+			}
+		}
+	}
+}
+
+putword(data)
+int data;
+{
+	putchar(data >>  0 & 0xFF);
+	putchar(data >>  8 & 0xFF);
+	putchar(data >> 16 & 0xFF);
+}
-- 
2.31.1