2048: slight VT100 changes (arrow characters, clear screen) and added uz80as as Linux assembler

2048/2048.ASM

@@ -13,12 +13,15 @@
 ; Compile:
 ;
 ;   TASM -80 -b 2048.ASM 2048.COM
+;   -or-
+;   uz80as 2048.ASM 2048.COM
 ;
 ; Credits:
 ;
 ;   Based on 2048 created by Gabriele Cirulli.
 ;   Based on the console version for GNU/Linux by Maurits van der Schee
 ;   Ported to Z80 and CP/M by Marco Maccaferri <macca@maccasoft.com>
+;   Slight VT100 compatibility changes by acn128 <acn@acn.wtf>
 
 
 CTRL_A      .EQU    1
@@ -945,7 +948,8 @@ DIV16:
             LD      HL,0
             LD      B,16
 
-DL1         SLL  C              ; Undoc. 0CBH, 31H
+DL1         SCF
+            RL      C
             RLA
             ADC     HL,HL
             SBC     HL,DE
@@ -1041,7 +1045,7 @@ POINTS      .DW     0000H
             .DW     4096H
             .DW     8192H
 
-INIT:       .DB     12, 1BH, "[?25l", EOS
+INIT:       .DB     1BH, "[?25l", 1BH, "[2J", EOS
 TERM:       .DB     1BH, "[?25h"
 RESET:      .DB     1BH, "[0m", EOS
 
@@ -1061,16 +1065,16 @@ BTMBORDER   .DB     0DFH
             .DB     0DFH, 0DFH, 0DFH, 0DFH, 0DFH, 0DFH, 0DFH
             .DB     0DFH, EOS
 
-MSG1:       .DB     1BH, "[0m",
+MSG1:       .DB     1BH, "[0m"
-            .DB     "        ", 11H, ",", 1EH, ",", 10H, ",", 1FH, " or q        "
+            .DB     "        <,>,^,v or q        "
             .DB     EOS
 MSG2:       .DB     1BH, "[0m"
-            .DB     "        QUIT? (y/n)         ",
+            .DB     "        QUIT? (y/n)         "
             .DB     EOS
-MSG3:       .DB     1BH, "[0m",
+MSG3:       .DB     1BH, "[0m"
             .DB     "         GAME OVER!         "
             .DB     BEL, CR, LF, EOS
-MSG4:       .DB     1BH, "[0m",
+MSG4:       .DB     1BH, "[0m"
             .DB     "2048                     pts"
             .DB     EOS
 

2048/README.md

@@ -19,7 +19,15 @@ When two tiles with the same number touch, they merge into one.
 
 ## Compile:
 
-TASM -80 -b 2048.ASM 2048.COM
+If using TASM, the command is: ``TASM -80 -b 2048.ASM 2048.COM``
+
+The "Micro Z80 Assembler" was used to assemble ``2048.COM`` on Linux.
+It is provided in the directory ``uz80as``, just compile it using ``make``.
+
+The command for assembling 2048 is: ``uz80as 2048.ASM 2048.COM``.
+
+uz80as can be found here: https://github.com/jorgicor/uz80as
+The uz80as directory here is taken from the RomWBW source tree.
 
 ## License:
 

2048/uz80as/Makefile

@@ -0,0 +1,67 @@
+# ===========================================================================
+# uz80as, an assembler for the Zilog Z80 and several other microprocessors.
+# ===========================================================================
+
+CC = gcc
+CFLAGS = -g
+
+OBJECTS = ngetopt.o main.o options.o \
+	utils.o err.o incl.o sym.o \
+	expr.o exprint.o pp.o list.o \
+	prtable.o uz80as.o targets.o \
+	z80.o gbcpu.o \
+	dp2200.o i4004.o \
+	i8008.o i8048.o \
+	i8051.o i8080.o \
+	mos6502.o mc6800.o
+
+SOURCES = \
+	config.h \
+	ngetopt.c ngetopt.h \
+	main.c \
+	options.c options.h \
+	utils.c utils.h \
+	err.c err.h \
+	incl.c incl.h \
+	sym.c sym.h \
+	expr.c expr.h \
+	exprint.c exprint.h \
+	pp.c pp.h \
+	list.c list.h \
+	prtable.c prtable.h \
+	uz80as.c uz80as.h \
+	targets.c targets.h \
+	z80.c \
+	gbcpu.c \
+	dp2200.c \
+	i4004.c \
+	i8008.c \
+	i8048.c \
+	i8051.c \
+	i8080.c \
+	mos6502.c \
+	mc6800.c
+
+all: uz80as
+
+clobber: clean
+	-rm -f uz80as uz80as
+
+clean:
+	-rm -f $(OBJECTS)
+
+uz80as: $(OBJECTS)
+	$(CC) $(CFLAGS) -o uz80as $(OBJECTS) 
+
+TESTS=test*.asm
+
+test: uz80as
+	echo "running tests"
+	for i in $(TESTS) ; do \
+		echo "====== $$i ======" ; \
+		./uz80as $$i ; \
+		cat $$(basename $$i .asm).lst ; \
+	done
+
+.c.o:
+	$(CC) $(CFLAGS) -I. -c $< -o $@

2048/uz80as/config.h

@@ -0,0 +1,29 @@
+/* config.h.  Generated from config.h.in by configure.  */
+/* config.h.in.  Generated from configure.ac by autoheader.  */
+
+/* Years of copyright */
+#define COPYRIGHT_YEARS "2018"
+
+/* Name of package */
+#define PACKAGE "uz80as"
+
+/* Define to the address where bug reports for this package should be sent. */
+#define PACKAGE_BUGREPORT "jorge.giner@hotmail.com"
+
+/* Define to the full name of this package. */
+#define PACKAGE_NAME "uz80as"
+
+/* Define to the full name and version of this package. */
+#define PACKAGE_STRING "uz80as 1.10"
+
+/* Define to the one symbol short name of this package. */
+#define PACKAGE_TARNAME "uz80as"
+
+/* Define to the home page for this package. */
+#define PACKAGE_URL "https://jorgicor.niobe.org/uz80as"
+
+/* Define to the version of this package. */
+#define PACKAGE_VERSION "1.10"
+
+/* Version number of package */
+#define VERSION "1.10"

2048/uz80as/dp2200.c

@@ -0,0 +1,208 @@
+/* ===========================================================================
+ * uz80as, an assembler for the Zilog Z80 and several other microprocessors.
+ *
+ * Datapoint 2200.
+ * ===========================================================================
+ */
+
+/*
+ * Datapoint 2200 Version I, 2K to 8K mem (program counter 13 bits).
+ * Datapoint 2200 Version II, 2K to 16K mem (protram counter 14 bits).
+ */
+
+#include "pp.h"
+#include "err.h"
+#include "options.h"
+#include "uz80as.h"
+#include <stddef.h>
+
+/* pat:
+ *	a: expr
+ *	b: ADA,ADB,ADC,ADD,ADH,ADL,ADM,
+ *	   ACA,ACB,ACC,ACD,ACH,ACL,ACM,
+ *	   SUA,SUB,SUC,SUD,SUH,SUL,SUM,
+ *	   SBA,SBB,SBC,SBD,SBH,SBL,SBM,
+ *	   NDA,NDB,NDC,NDD,NDH,NDL,NDM,
+ *	   XRA,XRB,XRC,XRD,XRH,XRL,XRM,
+ *	   ORA,ORB,ORC,ORD,ORH,ORL,ORM,
+ *	   CPA,CPB,CPC,CPD,CPH,CPL,CPM
+ *	c: NOP,LAB,LAC,LAD,LAE,LAH,LAL,LAM,
+ *	   LBA,LBC,LBD,LBE,LBH,LBL,LBM,
+ *	   LCA,LCB,LCD,LCE,LCH,LCL,LCM,
+ *	   LDA,LDB,LDC,LDE,LDH,LDL,LDM,
+ *	   LEA,LEB,LEC,LED,LEH,LEL,LEM,
+ *	   LHA,LHB,LHC,LHD,LHE,LHL,LHM,
+ *	   LLA,LLB,LLC,LLD,LLE,LLH,LLM,
+ *	   LMA,LMB,LMC,LMD,LME,LMH,LML,HALT
+ *	d: ADR,STATUS,DATA,WRITE,COM1,COM2,COM3,COM4
+ *	   BEEP,CLICK,DECK1,DECK2,
+ *	   RBK,WBK,BSP,SF,SB,REWND,TSTOP 
+ *	e: RFC,RFS,RTC,RTS,RFZ,RFP,RTZ,RTP
+ *	f: JFC,JFZ,JFS,JFP,JTC,JTZ,JTS,JTP
+ *	g: AD,SU,ND,OR,AC,SB,XR,CP
+ *	h: LA,LB,LC,LD,LE,LH,LL
+ *	i: CFC,CFZ,CFS,CFP,CTC,CTZ,CTS,CTP
+ *
+ * gen:
+ * 	.: output lastbyte
+ * 	b: (op << 3) | lastbyte
+ * 	c: op | lastbyte
+ * 	d: lastbyte = op as 8 bit value
+ * 	e: output op as word (no '.' should follow)
+ * 	f: (op << 1) + lastbyte
+ * 	g: (op << 4) | lastbyte
+ */
+
+const struct matchtab s_matchtab_dp2200[] = {
+	{ "SLC", "02.", 3, 0 },
+	{ "SRC", "0A.", 3, 0 },
+	{ "RETURN", "07.", 3, 0 },
+	{ "INPUT", "41.", 3, 0 },
+	{ "b", "80c0.", 3, 0 },
+	{ "c", "C0c0.", 3, 0 },
+	{ "EX d", "51f0.", 3, 0 },
+	{ "e", "03b0.", 3, 0 },
+	{ "g a", "04b0.d1.", 3, 0, "e8" },
+	{ "h a", "06b0.d1.", 3, 0, "e8"},
+	{ "f a", "40b0.e1", 3, 0 },
+	{ "i a", "42b0.e1", 3, 0 },
+	{ "JMP a", "44.e0", 3, 0 },
+	{ "CALL a", "46.e0", 3, 0 },
+	/* version II */
+	{ "BETA", "10.", 2, 0 },
+	{ "DI", "20.", 2, 0 },
+	{ "POP", "30.", 2, 0 },
+	{ "ALPHA", "18.", 2, 0 },
+	{ "EI", "28.", 2, 0 },
+	{ "PUSH", "38.", 2, 0 },
+	{ NULL, NULL },
+};
+
+static const char *const bval[] = {
+"ADA", "ADB", "ADC", "ADD", "ADE", "ADH", "ADL", "ADM",
+"ACA", "ACB", "ACC", "ACD", "ACE", "ACH", "ACL", "ACM",
+"SUA", "SUB", "SUC", "SUD", "SUE", "SUH", "SUL", "SUM",
+"SBA", "SBB", "SBC", "SBD", "SBE", "SBH", "SBL", "SBM",
+"NDA", "NDB", "NDC", "NDD", "NDE", "NDH", "NDL", "NDM",
+"XRA", "XRB", "XRC", "XRD", "XRE", "XRH", "XRL", "XRM",
+"ORA", "ORB", "ORC", "ORD", "ORE", "ORH", "ORL", "ORM",
+"CPA", "CPB", "CPC", "CPD", "CPE", "CPH", "CPL", "CPM",
+NULL };
+
+static const char *const cval[] = {
+"NOP", "LAB", "LAC", "LAD", "LAE", "LAH", "LAL", "LAM",
+"LBA", "",    "LBC", "LBD", "LBE", "LBH", "LBL", "LBM",
+"LCA", "LCB", "",    "LCD", "LCE", "LCH", "LCL", "LCM",
+"LDA", "LDB", "LDC", "",    "LDE", "LDH", "LDL", "LDM",
+"LEA", "LEB", "LEC", "LED", "",    "LEH", "LEL", "LEM",
+"LHA", "LHB", "LHC", "LHD", "LHE", "",    "LHL", "LHM",
+"LLA", "LLB", "LLC", "LLD", "LLE", "LLH", "",    "LLM",
+"LMA", "LMB", "LMC", "LMD", "LME", "LMH", "LML", "HALT",
+NULL };
+
+static const char *const dval[] = {
+"ADR", "STATUS", "DATA", "WRITE", "COM1", "COM2",  "COM3",  "COM4",
+"",    "",       "",     "",      "BEEP", "CLICK", "DECK1", "DECK2", 
+"RBK", "WBK",    "",     "BSP",   "SF",   "SB",    "REWND", "TSTOP", 
+NULL };
+
+static const char *const eval[] = { "RFC", "RFZ", "RFS", "RFP",
+				    "RTC", "RTZ", "RTS", "RTP",
+				    NULL };
+
+static const char *const fval[] = { "JFC", "JFZ", "JFS", "JFP",
+				    "JTC", "JTZ", "JTS", "JTP",
+				    NULL };
+
+static const char *const gval[] = { "AD", "AC", "SU", "SB",
+				    "ND", "XR", "OR", "CP",
+				    NULL };
+
+static const char *const hval[] = { "LA", "LB", "LC", "LD",
+				    "LE", "LH", "LL",
+				    NULL };
+
+static const char *const ival[] = { "CFC", "CFZ", "CFS", "CFP",
+				    "CTC", "CTZ", "CTS", "CTP",
+				    NULL };
+
+static const char *const *const valtab[] = { 
+	bval, cval, dval, eval, fval,
+       	gval, hval, ival
+};
+
+static int match_dp2200(char c, const char *p, const char **q)
+{
+	int v;
+
+	if (c <= 'i') {
+		v = mreg(p, valtab[(int) (c - 'b')], q);
+	} else {
+		v = -1;
+	}
+
+	return v;
+}
+
+static int gen_dp2200(int *eb, char p, const int *vs, int i, int savepc)
+{
+	int b;
+       
+	b = *eb;
+	switch (p) {
+	case 'f': b += (vs[i] << 1); break;
+	case 'g': b |= (vs[i] << 4); break;
+	default:
+		  return -1;
+	}
+
+	*eb = b;
+	return 0;
+}
+
+static int s_pat_char = 'b';
+static int s_pat_index;
+
+static void pat_char_rewind_dp2200(int c)
+{
+	s_pat_char = c;
+	s_pat_index = 0;
+};
+
+static const char *pat_next_str_dp2200(void)
+{
+	const char *s;
+
+	if (s_pat_char >= 'b' && s_pat_char <= 'n') {
+		s = valtab[(int) (s_pat_char - 'b')][s_pat_index];
+		if (s != NULL) {
+			s_pat_index++;
+		}
+	} else {
+		s = NULL;
+	}
+
+	return s;
+};
+
+const struct target s_target_dp2200 = {
+	.id = "dp2200",
+	.descr = "Datapoint 2200 Version I",
+	.matcht = s_matchtab_dp2200,
+	.matchf = match_dp2200,
+	.genf = gen_dp2200,
+	.pat_char_rewind = pat_char_rewind_dp2200,
+	.pat_next_str = pat_next_str_dp2200,
+	.mask = 1
+};
+
+const struct target s_target_dp2200ii = {
+	.id = "dp2200ii",
+	.descr = "Datapoint 2200 Version II",
+	.matcht = s_matchtab_dp2200,
+	.matchf = match_dp2200,
+	.genf = gen_dp2200,
+	.pat_char_rewind = pat_char_rewind_dp2200,
+	.pat_next_str = pat_next_str_dp2200,
+	.mask = 2
+};

2048/uz80as/err.c

@@ -0,0 +1,196 @@
+/* ===========================================================================
+ * uz80as, an assembler for the Zilog Z80 and several other microprocessors.
+ *
+ * Error reporting.
+ * ===========================================================================
+ */
+
+#include "config.h"
+#include "err.h"
+#include "incl.h"
+
+#ifndef ASSERT_H
+#include <assert.h>
+#endif
+
+#ifndef CTYPE_H
+#include <ctype.h>
+#endif
+
+#ifndef STDARG_H
+#include <stdarg.h>
+#endif
+
+#ifndef STDIO_H
+#include <stdio.h>
+#endif
+
+#ifndef STDLIB_H
+#include <stdlib.h>
+#endif
+
+#ifndef STRING_H
+#include <string.h>
+#endif
+
+/* Max number of errors before halt. */
+#define MAXERR		64
+
+int s_nerrors;
+
+static void eprfl(void)
+{
+	fprintf(stderr, "%s:%d: ", curfile()->name, curfile()->linenum);
+}
+
+static void eprwarn(void)
+{
+	fputs(_("warning:"), stderr);
+	fputc(' ', stderr);
+}
+
+/* Print the characters in [p, q[ to stderr. */
+void echars(const char *p, const char *q)
+{
+	while (*p != '\0' && p != q) {
+		fputc(*p, stderr);
+		p++;
+	}
+}
+
+/*
+ * Print a space, an opening parenthesis, the characters in [p, q[,
+ * and a closing parenthesis to stderr.
+ */
+void epchars(const char *p, const char *q)
+{
+	fputs(" (", stderr);
+	echars(p, q);
+	fputs(")", stderr);
+}
+
+/*
+ * Increments the number of errors, and exit with failure if
+ * maximum number of errors allowed is reached.
+ */
+void newerr(void)
+{
+	s_nerrors++;
+	if (s_nerrors >= MAXERR) {
+		eprogname();
+		fprintf(stderr, _("exiting: too many errors"));
+		enl();
+		exit(EXIT_FAILURE);
+	}
+}
+
+static void evprint(int warn, const char *ecode, va_list args)
+{
+	if (nfiles() > 0)
+		eprfl();
+	else
+		eprogname();
+
+	if (warn)
+		eprwarn();
+
+	assert(ecode != NULL);
+	vfprintf(stderr, ecode, args);
+}
+
+/* Prints only the printable characters, the rst as space. */
+static void eprint_printable(const char *p)
+{
+	for (; *p != '\0'; p++) {
+		if (isprint(*p))
+			putc(*p, stderr);
+		else
+			putc(' ', stderr);
+	}
+}
+
+/* Prints the line and a marker pointing to the charcater q inside line. */
+void eprcol(const char *line, const char *q)
+{
+	putc(' ', stderr);
+	eprint_printable(line);
+	fputs("\n ", stderr);
+	while (line != q) {
+		putc(' ', stderr);
+		line++;
+	}
+	fputs("^\n", stderr);
+}
+
+/*
+ * Like fprintf but prints to stderr.
+ * If we are parsing any file (incl.c), print first the file and the line.
+ * If not, print first the program name.
+ */
+void eprint(const char *ecode, ...)
+{
+	va_list args;
+
+	va_start(args, ecode);
+	evprint(0, ecode, args);
+	va_end(args);
+}
+
+/* Same as eprint, but print "warning: " before ecode str.  */
+void wprint(const char *ecode, ...)
+{
+	va_list args;
+
+	va_start(args, ecode);
+	evprint(1, ecode, args);
+	va_end(args);
+}
+
+/* Print \n on stderr. */
+void enl(void)
+{
+	fputc('\n', stderr);
+}
+
+/* Print the program name on stderr. */
+void eprogname(void)
+{
+	fprintf(stderr, PACKAGE": ");
+}
+
+/* Call malloc, but if no memory, print that error and exit with failure. */
+void *emalloc(size_t n)
+{
+	void *p;
+
+	if ((p = malloc(n)) == NULL) {
+		eprint(_("malloc fail\n"));
+		exit(EXIT_FAILURE);
+	}
+	//	printf("emalloc: %d = %x\n", n, p);
+	return p;
+}
+
+/* Call realloc, but if no memory, print that error and exit with failure. */
+void *erealloc(void *p, size_t n)
+{
+	// void *q = p;
+	if ((p = realloc(p, n)) == NULL) {
+		eprint(_("realloc fail\n"));
+		exit(EXIT_FAILURE);
+	}
+	// printf("erealloc: %x %d = %x\n", q, n, p);
+	return p;
+}
+
+/* Call fopen, but if any error, print it and exit with failure. */
+FILE *efopen(const char *fname, const char *ops)
+{
+	FILE *fp;
+
+	if ((fp = fopen(fname, ops)) == NULL) {
+		eprint(_("cannot open file %s\n"), fname);
+		exit(EXIT_FAILURE);
+	}
+	return fp;
+}

2048/uz80as/err.h

@@ -0,0 +1,32 @@
+/* ===========================================================================
+ * uz80as, an assembler for the Zilog Z80 and several other microprocessors.
+ *
+ * Error reporting.
+ * ===========================================================================
+ */
+
+#ifndef ERR_H
+#define ERR_H
+
+#ifndef STDIO_H
+#define STDIO_H
+#include <stdio.h>
+#endif
+
+#define _(str)	(str)
+
+extern int s_nerrors;
+
+void newerr(void);
+void eprogname(void);
+void echars(const char *p, const char *q);
+void epchars(const char *p, const char *q);
+void eprint(const char *ecode, ...);
+void wprint(const char *ecode, ...);
+void eprcol(const char *line, const char *q);
+void enl(void);
+void *emalloc(size_t n);
+void *erealloc(void *p, size_t n);
+FILE *efopen(const char *fname, const char *ops);
+
+#endif

2048/uz80as/expr.c

@@ -0,0 +1,459 @@
+/* ===========================================================================
+ * uz80as, an assembler for the Zilog Z80 and several other microprocessors.
+ *
+ * Expression parsing.
+ * ===========================================================================
+ */
+
+#include "config.h"
+#include "expr.h"
+#include "utils.h"
+#include "err.h"
+#include "sym.h"
+
+#ifndef ASSERT_H
+#include <assert.h>
+#endif
+
+#ifndef CTYPE_H
+#include <ctype.h>
+#endif
+
+#ifndef LIMITS_H
+#include <limits.h>
+#endif
+
+#ifndef STDIO_H
+#include <stdio.h>
+#endif
+
+#ifndef STDLIB_H
+#include <stdlib.h>
+#endif
+
+/* Max nested expressions. */
+#define ESTKSZ		16
+#define ESTKSZ2		(ESTKSZ*2)
+
+/* Return -1 on syntax error.
+ * *p must be a digit already.
+ * *q points to one past the end of the number without suffix.
+ */
+static int takenum(const char *p, const char *q, int radix)
+{
+	int k, n;
+
+	n = 0;
+	while (p != q) {
+		k = hexval(*p);
+	       	p++;
+		if (k >= 0 && k < radix)
+			n = n * radix + k;
+		else
+			return -1;
+	}
+	return n;
+}
+
+/* Go to the end of a number (advance all digits or letters). */
+static const char *goendnum(const char *p)
+{
+	const char *q;
+
+	for (q = p; isalnum(*q); q++)
+		;
+	return q;
+}
+
+/*
+ * Returns NULL on error.
+ * '*p' must be a digit already.
+ */
+static const char *getnum(const char *p, int *v)
+{
+	int n;
+	char c;
+	const char *q;
+
+	assert(isdigit(*p));
+
+	n = 0;
+	q = goendnum(p) - 1;
+	if (isalpha(*q)) {
+		c = toupper(*q);
+		if (c == 'H') {
+			n = takenum(p, q, 16);
+		} else if (c == 'D') {
+			n = takenum(p, q, 10);
+		} else if (c == 'O') {
+			n = takenum(p, q, 8);
+		} else if (c == 'B') {
+			n = takenum(p, q, 2);
+		} else {
+			return NULL;
+		}
+	} else {
+		n = takenum(p, q + 1, 10);
+	}
+
+	if (n < 0)
+		return NULL;
+
+	*v = n;
+	return q + 1;
+}
+
+/* 
+ * Gets a number that was prefixed.
+ * Returns NULL on error.
+ */
+static const char *getpnum(const char *p, int radix, int *v)
+{
+	const char *q;
+	int n;
+
+	q = goendnum(p);
+	n = takenum(p, q, radix);
+	if (n < 0)
+		return NULL;
+	*v = n;
+	return q;
+}
+
+/* Left shift */
+static int shl(int r, int n)
+{
+	n &= int_precission();
+	return r << n;
+}
+
+
+/* Portable arithmetic right shift. */
+static int ashr(int r, int n)
+{
+	n &= int_precission();
+	if (r & INT_MIN) {
+		return ~(~r >> n);
+	} else {
+		return r >> n;
+	}
+}
+
+/* Parses expression pointed by 'p'.
+ * If success, returns pointer to the end of parsed expression, and
+ * 'v' contains the calculated value of the expression.
+ * Returns NULL if a syntactic error has occurred. 
+ * Operators are evaluated left to right.
+ * To allow precedence use parenthesis.
+ * 'linepc' is the program counter to consider when we find the $ current
+ * pointer location symbol ($).
+ * 'allowfr' stands for 'allow forward references'. We will issue an error
+ * if we find a label that is not defined.
+ * 'ecode' will be valid if NULL is returned. NULL can be passed as ecode.
+ * 'ep' is the pointer to the position where the error ocurred. NULL can be
+ * passed as ep.
+ */
+const char *expr(const char *p, int *v, int linepc, int allowfr,
+	enum expr_ecode *ecode, const char **ep)
+{
+	int si, usi, usl;
+	const char *q;
+	char last;
+	int stack[ESTKSZ2];
+	int uopstk[ESTKSZ];
+	int r, n;
+	struct sym *sym;
+	int err;
+	enum expr_ecode ec;
+
+	ec = EXPR_E_NO_EXPR;
+	err = 0;
+	usi = 0;
+	si = 0;
+	r = 0;
+	last = 'V';	/* first void */
+	usl = 0;
+loop:
+	p = skipws(p);
+	if (*p == '(') {
+		if (last == 'n') {
+			goto end;
+		} else {
+			if (si >= ESTKSZ2) {
+				eprint(_("expression too complex\n"));
+				exit(EXIT_FAILURE);
+			}
+			stack[si++] = last;
+			stack[si++] = r;
+			stack[si++] = usl;
+			usl = usi;
+			p++;
+			r = 0;
+			last = 'v';	/* void */
+		}
+	} else if (*p == ')') {
+		if (last != 'n') {
+			ec = EXPR_E_CPAR;
+			goto esyntax;
+		} else if (si == 0) {
+			goto end;
+		} else {
+			p++;
+			n = r;
+			usl = stack[--si];
+			r = stack[--si];
+			last = (char) stack[--si];	
+			goto oper;
+		}
+	} else if (*p == '+') {
+		p++;
+		if (last == 'n')
+			last = '+';
+	} else if (*p == '-') {
+		if (last == 'n') {
+			p++;
+			last = '-';
+		} else {
+			goto uoper;
+		}
+	} else if (*p == '~') {
+		goto uoper;
+	} else if (*p == '!') {
+		if (*(p + 1) == '=') {
+			if (last != 'n') {
+				ec = EXPR_E_OPER;
+				goto esyntax;
+			} else {
+				p += 2;
+				last = 'N';
+			}
+		} else {
+			goto uoper;
+		}
+	} else if (*p == '*') {
+		if (last == 'n') {
+			last = *p++;
+		} else {
+			p++;
+			n = linepc;
+			goto oper;
+		}
+	} else if (*p == '/' || *p == '&' || *p == '|'
+		|| *p == '^')
+       	{
+		if (last != 'n') {
+			ec = EXPR_E_OPER;
+			goto esyntax;
+		} else {
+			last = *p++;
+		}
+	} else if (*p == '>') {
+		if (last != 'n') {
+			ec = EXPR_E_OPER;
+			goto esyntax;
+		}
+		p++;
+	       	if (*p == '=') {
+			last = 'G';
+			p++;
+		} else if (*p == '>') {
+			last = 'R';
+			p++;
+		} else {
+			last = '>';
+		}
+	} else if (*p == '<') {
+		if (last != 'n') {
+			ec = EXPR_E_OPER;
+			goto esyntax;
+		}
+		p++;
+	       	if (*p == '=') {
+			last = 'S';
+			p++;
+		} else if (*p == '<') {
+			last = 'L';
+			p++;
+		} else {
+			last = '<';
+		}
+	} else if (*p == '=') {
+		if (last != 'n') {
+			ec = EXPR_E_OPER;
+			goto esyntax;
+		}
+		p++;
+		if (*p == '=')
+			p++;
+		last = '=';
+	} else if (*p == '\'') {
+		if (last == 'n')
+			goto end;		
+		p++;
+		n = *p++;
+		if (*p != '\'') {
+			ec = EXPR_E_CHAR;
+			goto esyntax;
+		}
+		p++;
+		goto oper;
+	} else if (*p == '$') {
+		if (last == 'n')
+			goto end;
+		p++;
+		if (hexval(*p) < 0) {
+			n = linepc;
+			goto oper;
+		}
+		q = getpnum(p, 16, &n);
+		if (q == NULL) {
+			p--;
+			ec = EXPR_E_HEX;
+			goto esyntax;
+		}
+		p = q;
+		goto oper;
+	} else if (*p == '@') {
+		if (last == 'n')
+			goto end;
+		p++;
+		q = getpnum(p, 8, &n);
+		if (q == NULL) {
+			p--;
+			ec = EXPR_E_OCTAL;
+			goto esyntax;
+		}
+		p = q;
+		goto oper;
+	} else if (*p == '%') {
+		if (last == 'n') {
+			last = *p;
+			p++;
+		} else {
+			p++;
+			q = getpnum(p, 2, &n);
+			if (q == NULL) {
+				ec = EXPR_E_BIN;
+				goto esyntax;
+			}
+			p = q;
+			goto oper;
+		}
+	} else if ((p[0] == '0') && (p[1] == 'x')) {
+		p+=2;
+		q = getpnum(p, 16, &n);
+		if (q == NULL) {
+			p--;
+			ec = EXPR_E_HEX;
+			goto esyntax;
+		}
+		p = q;
+		goto oper;
+	} else if (isdigit(*p)) {
+		if (last == 'n')
+			goto end;
+		q = getnum(p, &n);
+		if (q == NULL) {
+			ec = EXPR_E_DEC;
+			goto esyntax;
+		}
+		p = q;
+		goto oper;
+	} else if (isidc0(*p)) {
+		if (last == 'n')
+			goto end;
+		q = p;
+		while (isidc(*p))
+			p++;
+		sym = lookup(q, p, 0, 0);
+		if (sym == NULL) {
+			n = 0;
+			if (!allowfr) {
+				err = 1;
+				eprint(_("undefined label"));
+				epchars(q, p);
+				enl();
+				newerr();
+			}
+		} else {
+			n = sym->val;
+		}
+		goto oper;
+	} else if (last == 'V') {
+		goto esyntax;
+	} else if (last != 'n') {
+		ec = EXPR_E_SYNTAX;
+		goto esyntax;
+	} else {
+end:		if (v != NULL)
+			*v = r;
+		return p;
+	}
+	goto loop;
+uoper:
+	if (last == 'n')
+		goto end;
+	if (usi >= ESTKSZ) {
+		eprint(_("expression too complex\n"));
+		exit(EXIT_FAILURE);
+	}
+	uopstk[usi++] = *p++;
+	goto loop;
+oper:
+	while (usi > usl) {
+		usi--;
+		switch (uopstk[usi]) {
+		case '~': n = ~n; break;
+		case '-': n = -n; break;
+		case '!': n = !n; break;
+		}
+	}
+	switch (last) {
+	case 'V': r = n; break;
+	case 'v': r = n; break;
+	case '+': r += n; break;
+	case '-': r -= n; break;
+	case '*': r *= n; break;
+	case '&': r &= n; break;
+	case '|': r |= n; break;
+	case '^': r ^= n; break;
+	case '=': r = r == n; break;
+	case '<': r = r < n; break;
+	case '>': r = r > n ; break;
+	case 'G': r = r >= n; break;
+	case 'S': r = r <= n; break;
+	case 'N': r = r != n; break;
+	/* This would be logical right shift:
+	 * case 'R': r = (unsigned int) r >> n; break;
+	 */
+	case 'R': r = ashr(r, n); break;
+	case 'L': r = shl(r, n); break;
+	case '~': r = ~n; break;
+	case '%':
+		if (n != 0) {
+			r %= n;
+	       	} else if (!err && !allowfr) {
+			err = 1;
+			eprint(_("modulo by zero\n"));
+			exit(EXIT_FAILURE);
+		}
+		break;
+	case '/':
+	       	if (n != 0) {
+			r /= n;
+		} else if (!err && !allowfr) {
+			err = 1;
+			eprint(_("division by zero\n"));
+			exit(EXIT_FAILURE);
+		}
+		break;
+	}
+	last = 'n';
+	goto loop;
+esyntax:
+	if (ecode != NULL)
+		*ecode = ec;
+	if (ep != NULL)
+		*ep = p;
+	return NULL;
+}

2048/uz80as/expr.h

@@ -0,0 +1,26 @@
+/* ===========================================================================
+ * uz80as, an assembler for the Zilog Z80 and several other microprocessors.
+ *
+ * Expression parsing.
+ * ===========================================================================
+ */
+
+#ifndef EXPR_H
+#define EXPR_H
+
+enum expr_ecode {
+	EXPR_E_NO_EXPR,	/* There was no expression parsed. */
+	EXPR_E_SYNTAX,	/* Syntax error. */
+	EXPR_E_CPAR,
+	EXPR_E_OPER,
+	EXPR_E_CHAR,
+	EXPR_E_HEX,
+	EXPR_E_OCTAL,
+	EXPR_E_BIN,
+	EXPR_E_DEC,
+};
+
+const char *expr(const char *p, int *v, int linepc, int allowfr,
+		 enum expr_ecode *ecode, const char **ep);
+
+#endif

2048/uz80as/exprint.c

@@ -0,0 +1,32 @@
+/* ===========================================================================
+ * uz80as, an assembler for the Zilog Z80 and several other microprocessors.
+ *
+ * Expression error reporting.
+ * ===========================================================================
+ */
+
+#include "config.h"
+#include "exprint.h"
+#include "err.h"
+
+static const char *expr_get_error_str(enum expr_ecode ecode)
+{
+	switch (ecode) {
+	case EXPR_E_NO_EXPR: return _("expression expected\n");
+	case EXPR_E_SYNTAX: return _("syntax error in expression\n");
+	case EXPR_E_CPAR: return _("unexpected ')'\n");
+	case EXPR_E_OPER: return _("misplaced operator\n");
+	case EXPR_E_CHAR: return _("invalid character code\n");
+	case EXPR_E_HEX: return _("invalid hexadecimal constant\n");
+	case EXPR_E_OCTAL: return _("invalid octal constant\n");
+	case EXPR_E_BIN: return _("invalid binary constant\n");
+	case EXPR_E_DEC: return _("invalid decimal constant\n");
+	default: return "\n";
+	}
+}
+
+void exprint(enum expr_ecode ecode, const char *pline, const char *ep)
+{
+	eprint(expr_get_error_str(ecode));
+	eprcol(pline, ep);
+}

2048/uz80as/exprint.h

@@ -0,0 +1,17 @@
+/* ===========================================================================
+ * uz80as, an assembler for the Zilog Z80 and several other microprocessors.
+ *
+ * Expression error reporting.
+ * ===========================================================================
+ */
+
+#ifndef EXPRINT_H
+#define EXPRINT_H
+
+#ifndef EXPR_H
+#include "expr.h"
+#endif
+
+void exprint(enum expr_ecode ecode, const char *pline, const char *ep);
+
+#endif

2048/uz80as/gbcpu.c

@@ -0,0 +1,301 @@
+/* ===========================================================================
+ * uz80as, an assembler for the Zilog Z80 and several other microprocessors.
+ *
+ * Sharp LR35902 (Nintendo Gameboy CPU).
+ * ===========================================================================
+ */
+
+#include "pp.h"
+#include "err.h"
+#include "options.h"
+#include "uz80as.h"
+#include <stddef.h>
+
+#if 0
+Opcode  Z80             GMB
+ ---------------------------------------
+ 08      EX   AF,AF      LD   (nn),SP
+ 10      DJNZ PC+dd      STOP
+ 22      LD   (nn),HL    LDI  (HL),A
+ 2A      LD   HL,(nn)    LDI  A,(HL)
+ 32      LD   (nn),A     LDD  (HL),A
+ 3A      LD   A,(nn)     LDD  A,(HL)
+ D3      OUT  (n),A      -
+ D9      EXX             RETI
+ DB      IN   A,(n)      -
+ DD      <IX>            -
+ E0      RET  PO         LD   (FF00+n),A
+ E2      JP   PO,nn      LD   (FF00+C),A
+ E3      EX   (SP),HL    -
+ E4      CALL PO,nn      -
+ E8      RET  PE         ADD  SP,dd
+ EA      JP   PE,nn      LD   (nn),A
+ EB      EX   DE,HL      -
+ EC      CALL PE,nn      -
+ ED      <pref>          -
+ F0      RET  P          LD   A,(FF00+n)
+ F2      JP   P,nn       LD   A,(FF00+C)
+ F4      CALL P,nn       -
+ F8      RET  M          LD   HL,SP+dd
+ FA      JP   M,nn       LD   A,(nn)
+ FC      CALL M,nn       -
+ FD      <IY>            -
+ CB3X    SLL  r/(HL)     SWAP r/(HL) 
+#endif
+
+/* pat:
+ * 	a: expr
+ * 	b: B,C,D,E,H,L,A
+ * 	c: *
+ * 	d: BC,DE,HL,SP
+ * 	e: *
+ * 	f: BC,DE,HL,AF
+ * 	g: ADD,ADC,SUB,SBC,AND,XOR,OR,CP
+ * 	h: INC,DEC
+ * 	i: *
+ * 	j: *
+ * 	k: *
+ * 	l: BIT,RES,SET
+ * 	m: *
+ * 	n: NZ,Z,NC,C
+ * 	o: RLC,RRC,RL,RR,SLA,SRA,SWAP,SRL
+ *
+ * gen:
+ * 	.: output lastbyte
+ * 	b: (op << 3) | lastbyte
+ * 	c: op | lastbyte
+ * 	d: lastbyte = op as 8 bit value
+ * 	e: output op as word (no '.' should follow)
+ * 	f: (op << 4) | lastbyte
+ * 	g: (op << 6) | lastbyte
+ * 	h: if op >= FF00 output last byte and then op as 8 bit value;
+ * 	   else output (lastbyte | 0x0A) and output op as word
+ * 	   (no '.' should follow)
+ * 	i: relative jump to op
+ * 	j: possible value to RST
+ * 	k: possible value to IM
+ * 	l: *
+ * 	m: check arithmetic used with A register
+ * 	n: check arithmetic used without A register
+ */
+
+const struct matchtab s_matchtab_gbcpu[] = {
+	{ "LD b,b", "40b0c1.", 1, 0 },
+	{ "LD b,(HL)", "46b0.", 1, 0 },
+	{ "LD A,(C)", "F2.", 1, 0 }, // * LD A,(FF00+C)
+	{ "LD A,(BC)", "0A.", 1, 0 },
+	{ "LD A,(DE)", "1A.", 1, 0 },
+	{ "LD A,(HLI)", "2A.", 1, 0 }, // *
+	{ "LD A,(HLD)", "3A.", 1, 0 }, // *
+	{ "LD A,(a)", "F0h0", 1, 0 }, // * LD A,(nn) & LD A,(FF00+n)
+	{ "LD b,a", "06b0.d1.", 1, 0, "e8" },
+	{ "LD SP,HL", "F9.", 1, 0 },
+	{ "LDHL SP,a", "F8.d0.", 1, 0, "e8" }, // * LD HL,SP+n
+	{ "LD d,a", "01f0.e1", 1, 0 },
+	{ "LD (C),A", "E2.", 1, 0 }, // * LD (FF00+C),A
+	{ "LD (HL),b", "70c0.", 1, 0 },
+	{ "LD (HL),a", "36.d0.", 1, 0, "e8" },
+	{ "LD (HLI),A", "22.", 1, 0 }, // *
+	{ "LD (HLD),A", "32.", 1, 0 }, // *
+	{ "LD (BC),A", "02.", 1, 0 },
+	{ "LD (DE),A", "12.", 1, 0 },
+	{ "LD (a),A", "E0h0", 1, 0 }, // * LD (nn),A & LD (FF00+n),A
+	{ "LD (a),SP", "08.e0", 1, 0 }, // *
+	{ "LDH A,(a)", "F0.d0.", 1, 0, "e8" }, // * LD A,(FF00+n)
+	{ "LDH (a),A", "E0.d0.", 1, 0, "e8" }, // * LD (FF00+n),A
+	{ "PUSH f", "C5f0.", 1, 0 },
+	{ "POP f", "C1f0.", 1, 0 },
+	{ "ADD HL,d", "09f0.", 1, 0 },
+	{ "ADD SP,a", "E8.d0.", 1, 0, "e8" }, // * 
+	{ "g A,b", "m080b0c1.", 1, 0 },
+	{ "g A,(HL)", "m086b0.", 1, 0 },
+	{ "g A,a", "m0C6b0.d1.", 1, 0, "e8" },
+	{ "g b", "n080b0c1.", 1, 0 },
+	{ "g (HL)", "n086b0.", 1, 0 },
+	{ "g a", "n0C6b0.d1.", 1, 0, "e8" },
+	{ "h b", "04b1c0.", 1, 0 },
+	{ "h (HL)", "34c0.", 1, 0 },
+	{ "INC d", "03f0.", 1, 0 },
+	{ "DEC d", "0Bf0.", 1, 0 },
+	{ "DAA", "27.", 1, 0 },
+	{ "CPL", "2F.", 1, 0 },
+	{ "CCF", "3F.", 1, 0 },
+	{ "SCF", "37.", 1, 0 },
+	{ "NOP", "00.", 1, 0 },
+	{ "HALT", "76.", 1, 0 },
+	{ "DI", "F3.", 1, 0 },
+	{ "EI", "FB.", 1, 0 },
+	{ "RLCA", "07.", 1, 0 },
+	{ "RLA", "17.", 1, 0 },
+	{ "RRCA", "0F.", 1, 0 },
+	{ "RRA", "1F.", 1, 0 },
+	{ "o b", "CB.00b0c1.", 1, 0 },
+	{ "o (HL)", "CB.06b0.", 1, 0 },
+	{ "l a,b", "CB.00g0b1c2.", 1, 0, "b3" },
+	{ "l a,(HL)", "CB.06g0b1.", 1, 0, "b3" },
+	{ "JP (HL)", "E9.", 1, 0 },
+	{ "JP n,a", "C2b0.e1", 1, 0 }, // *
+	{ "JP a", "C3.e0", 1, 0 },
+	{ "JR n,a", "20b0.i1.", 1, 0, "r8" },
+	{ "JR a", "18.i0.", 1, 0, "r8" },
+	{ "STOP", "10.00.", 1, 0 }, // *
+	{ "CALL n,a", "C4b0.e1", 1, 0 }, // *
+	{ "CALL a", "CD.e0", 1, 0 },
+	{ "RETI", "D9.", 1, 0 }, // *
+	{ "RET n", "C0b0.", 1, 0 },
+	{ "RET", "C9.", 1, 0 },
+	{ "RST a", "C7j0.", 1, 0, "ss" },
+	{ NULL, NULL },
+};
+
+static const char *const bval[] = { "B", "C", "D", "E",
+				    "H", "L", "", "A", NULL };
+static const char *const dval[] = { "BC", "DE", "HL", "SP", NULL };
+static const char *const fval[] = { "BC", "DE", "HL", "AF", NULL };
+static const char *const gval[] = { "ADD", "ADC", "SUB", "SBC",
+				    "AND", "XOR", "OR", "CP", NULL };
+static const char *const hval[] = { "INC", "DEC", NULL };
+static const char *const lval[] = { "", "BIT", "RES", "SET", NULL };
+static const char *const nval[] = { "NZ", "Z", "NC", "C", NULL };
+static const char *const oval[] = { "RLC", "RRC", "RL", "RR",
+				    "SLA", "SRA", "SWAP", "SRL", NULL };
+static const char *const nullv[] = { NULL };
+
+static const char *const *const valtab[] = { 
+	bval, nullv, dval, nullv, fval,
+       	gval, hval, nullv, nullv, nullv,
+       	lval, nullv, nval, oval
+};
+
+static int match_gbcpu(char c, const char *p, const char **q)
+{
+	int v;
+
+	switch (c) {
+	case 'b':
+	case 'd':
+	case 'f':
+	case 'g':
+	case 'h':
+	case 'l':
+	case 'n':
+	case 'o':
+		v = mreg(p, valtab[(int) (c - 'b')], q);
+		break;
+	default:
+		v = -1;
+	}
+
+	return v;
+}
+
+static int gen_gbcpu(int *eb, char p, const int *vs, int i, int savepc)
+{
+	int w, b;
+       
+	b = *eb;
+	switch (p) {
+	case 'f': b |= (vs[i] << 4); break;
+	case 'g': b |= (vs[i] << 6); break;
+	case 'h': w = vs[i] & 0xffff;
+		  if (w >= 0xff00) {
+			genb(b, s_pline_ep);
+			b = 0;
+			genb(w & 0xff, s_pline_ep);
+		  } else {
+			b |= 0x0A; 
+			genb(b, s_pline_ep);
+			b = 0;
+			genb(w & 0xff, s_pline_ep);
+			genb(w >> 8, s_pline_ep);
+		  }
+		  break;
+	case 'i': b = (vs[i] - savepc - 2); break;
+	case 'j': if (s_pass > 0 && (vs[i] & ~56) != 0) {
+			  eprint(_("invalid RST argument (%d)\n"),
+				vs[i]);
+			  eprcol(s_pline, s_pline_ep);
+			  newerr();
+		  }
+		  b |= vs[i];
+		  break;
+	case 'k': if (s_pass > 0 && (vs[i] < 0 || vs[i] > 2)) {
+			  eprint(_("invalid IM argument (%d)\n"),
+				vs[i]);
+			  eprcol(s_pline, s_pline_ep);
+			  newerr();
+		  }
+		  b = 0x46;
+		  if (vs[i] == 1)
+			  b = 0x56;
+		  else if (vs[i] == 2)
+			  b = 0x5E;
+		  break;
+	case 'm': if (s_pass == 0 && !s_extended_op) {
+			  if (vs[i] != 0 && vs[i] != 1 && vs[i] != 3) {
+				eprint(_("unofficial syntax\n"));
+				eprcol(s_pline, s_pline_ep);
+				newerr();
+			  }
+		  }
+		  break;
+	case 'n': if (s_pass == 0 && !s_extended_op) {
+			  if (vs[i] == 0 || vs[i] == 1 || vs[i] == 3) {
+				eprint(_("unofficial syntax\n"));
+				eprcol(s_pline, s_pline_ep);
+				newerr();
+			  }
+		  }
+		  break;
+	default:
+		  return -1;
+	}
+
+	*eb = b;
+	return 0;
+}
+
+static int s_pat_char = 'b';
+static int s_pat_index;
+
+static void pat_char_rewind_gbcpu(int c)
+{
+	s_pat_char = c;
+	s_pat_index = 0;
+};
+
+static const char *pat_next_str_gbcpu(void)
+{
+	const char *s;
+
+	switch (s_pat_char) {
+	case 'b':
+	case 'd':
+	case 'f':
+	case 'g':
+	case 'h':
+	case 'l':
+	case 'n':
+	case 'o':
+		s = valtab[(int) (s_pat_char - 'b')][s_pat_index];
+		if (s != NULL) {
+			s_pat_index++;
+		}
+		break;
+	default:
+		s = NULL;
+	}
+
+	return s;
+};
+
+const struct target s_target_gbcpu = {
+	.id = "gbcpu",
+	.descr = "Sharp LR35902 (Nintendo Gameboy CPU)",
+	.matcht = s_matchtab_gbcpu,
+	.matchf = match_gbcpu,
+	.genf = gen_gbcpu,
+	.pat_char_rewind = pat_char_rewind_gbcpu,
+	.pat_next_str = pat_next_str_gbcpu,
+	.mask = 1
+};

2048/uz80as/i4004.c

@@ -0,0 +1,189 @@
+/* ===========================================================================
+ * uz80as, an assembler for the Zilog Z80 and several other microprocessors.
+ *
+ * Intel 4004.
+ * Intel 4040.
+ * ===========================================================================
+ */
+
+/* Intel 4004. Max. memory 4K (12 bit addresses).
+ * Intel 4040. Max. memory 8K (13 bit addresses).
+ */
+
+#include "pp.h"
+#include "err.h"
+#include "options.h"
+#include "uz80as.h"
+#include <stddef.h>
+
+/* pat:
+ *	a: expr
+ *	b: ADD,SUB,LD,XCH,BBL,LDM 
+ *	c: WRM,WMP,WRR,WPM,WR0,WR1,WR2,WR3
+ *	   SBM,RDM,RDR,ADM,RD0,RD1,RD2,RD3
+ * 	d: CLB,CLC,IAC,CMC,CMA,RAL,RAR,TCC,
+ * 	   DAC,TCS,STC,DAA,KBP,DCL,
+ *	e: HLT,BBS,LCR,OR4,OR5,AN6,AN7
+ *	   DB0,DB1,SB0,SB1,EIN,DIN,RPM
+ *	f: 0P,1P,2P,3P,4P,5P,6P,7P
+ *
+ * gen:
+ * 	.: output lastbyte
+ * 	b: (op << 3) | lastbyte
+ * 	c: op | lastbyte
+ * 	d: lastbyte = op as 8 bit value
+ * 	e: output op as word (no '.' should follow)
+ * 	f: op | lastbyte, op in [0-15]
+ * 	g: op | lastbyte, op in [0,2,4,6,8,10,12,14]
+ * 	h: output (op & 0xff0000 >> 8) | lastbyte;
+ * 	   then ouput op as 8 bit value
+ * 	i: (op << 4) | lastbyte
+ * 	j: (op << 1) | lastbyte
+ */
+
+static const struct matchtab s_matchtab_i4004[] = {
+	{ "NOP", "00.", 1, 0 },
+	{ "JCN a,a", "10f0.d1.", 1, 0, "b4e8" },
+	{ "FIM f,a", "20j0.d1.", 1, 0, "e8" },
+	{ "FIM a,a", "20g0.d1.", 1, 0, "ppe8" },
+	{ "SRC f", "21j0.", 1, 0 },
+	{ "SRC a", "21g0.", 1, 0, "pp" },
+	{ "FIN f", "30j0.", 1, 0 },
+	{ "FIN a", "30g0.", 1, 0, "pp" },
+	{ "JIN f", "31j0.", 1, 0 },
+	{ "JIN a", "31g0.", 1, 0, "pp" },
+	{ "JUN a", "40h0", 1, 0 },
+	{ "JMS a", "50h0", 1, 0 },
+	{ "INC a", "60f0.", 1, 0, "b4" },
+	{ "ISZ a,a", "70f0.d1.", 1, 0, "b4e8" },
+	{ "b a", "80i0f1.", 1, 0, "b4" },
+	{ "c", "E0c0.", 1, 0 },
+	{ "d", "F0c0.", 1, 0 },
+	{ "e", "00c0.", 2, 0 },
+	{ NULL, NULL },
+};
+
+static const char *const bval[] = {
+"ADD", "SUB", "LD", "XCH", "BBL", "LDM",
+NULL };
+
+static const char *const cval[] = {
+"WRM", "WMP", "WRR", "WPM", "WR0", "WR1", "WR2", "WR3",
+"SBM", "RDM", "RDR", "ADM", "RD0", "RD1", "RD2", "RD3",
+NULL };
+
+static const char *const dval[] = {
+"CLB", "CLC", "IAC", "CMC", "CMA", "RAL", "RAR", "TCC",
+"DAC", "TCS", "STC", "DAA", "KBP", "DCL",
+NULL };
+
+static const char *const eval[] = {
+"", "HLT", "BBS", "LCR", "OR4", "OR5", "AN6", "AN7",
+"DB0", "DB1", "SB0", "SB1", "EIN", "DIN", "RPM",
+NULL };
+
+static const char *const fval[] = {
+"0P", "1P", "2P", "3P", "4P", "5P", "6P", "7P",
+NULL };
+
+static const char *const *const valtab[] = { 
+	bval, cval, dval, eval, fval
+};
+
+static int match_i4004(char c, const char *p, const char **q)
+{
+	int v;
+
+	if (c <= 'f') {
+		v = mreg(p, valtab[(int) (c - 'b')], q);
+	} else {
+		v = -1;
+	}
+
+	return v;
+}
+
+static int gen_i4004(int *eb, char p, const int *vs, int i, int savepc)
+{
+	int b;
+       
+	b = *eb;
+	switch (p) {
+	case 'f': if (s_pass > 0 && (vs[i] < 0 || vs[i] > 15)) {
+			  eprint(_("argument (%d) must be in range [0-15]\n"),
+				vs[i]);
+			  eprcol(s_pline, s_pline_ep);
+			  newerr();
+		  }
+	          b |= vs[i];
+		  break;
+	case 'g': if (s_pass > 0 && (vs[i] < 0 || vs[i] > 14 || (vs[i] & 1))) {
+			  eprint(
+		  _("argument (%d) must be an even number in range [0-14]\n"),
+				vs[i]);
+			  eprcol(s_pline, s_pline_ep);
+			  newerr();
+		  }
+	          b |= vs[i];
+		  break;
+	case 'h': b |= ((vs[i] >> 8) & 0x0f);
+		  genb(b, s_pline_ep);
+		  genb(vs[i], s_pline_ep);
+		  break;
+	case 'i': b |= (vs[i] << 4); break;
+	case 'j': b |= (vs[i] << 1); break;
+	default:
+		  return -1;
+	}
+
+	*eb = b;
+	return 0;
+}
+
+static int s_pat_char = 'b';
+static int s_pat_index;
+
+static void pat_char_rewind_i4004(int c)
+{
+	s_pat_char = c;
+	s_pat_index = 0;
+};
+
+static const char *pat_next_str_i4004(void)
+{
+	const char *s;
+
+	if (s_pat_char >= 'b' && s_pat_char <= 'f') {
+		s = valtab[(int) (s_pat_char - 'b')][s_pat_index];
+		if (s != NULL) {
+			s_pat_index++;
+		}
+	} else {
+		s = NULL;
+	}
+
+	return s;
+};
+
+const struct target s_target_i4004 = {
+	.id = "i4004",
+	.descr = "Intel 4004",
+	.matcht = s_matchtab_i4004,
+	.matchf = match_i4004,
+	.genf = gen_i4004,
+	.pat_char_rewind = pat_char_rewind_i4004,
+	.pat_next_str = pat_next_str_i4004,
+	.mask = 1
+};
+
+const struct target s_target_i4040 = {
+	.id = "i4040",
+	.descr = "Intel 4040",
+	.matcht = s_matchtab_i4004,
+	.matchf = match_i4004,
+	.genf = gen_i4004,
+	.pat_char_rewind = pat_char_rewind_i4004,
+	.pat_next_str = pat_next_str_i4004,
+	.mask = 3
+};
+

2048/uz80as/i8008.c

@@ -0,0 +1,220 @@
+/* ===========================================================================
+ * uz80as, an assembler for the Zilog Z80 and several other microprocessors.
+ *
+ * Intel 8008.
+ * ===========================================================================
+ */
+
+/* Max. memory 16K (14 bits addresses). */
+
+#include "pp.h"
+#include "err.h"
+#include "options.h"
+#include "uz80as.h"
+#include <stddef.h>
+
+/* pat:
+ *	a: expr
+ *	b: ADA,ADB,ADC,ADD,ADH,ADL,ADM,
+ *	   ACA,ACB,ACC,ACD,ACH,ACL,ACM,
+ *	   SUA,SUB,SUC,SUD,SUH,SUL,SUM,
+ *	   SBA,SBB,SBC,SBD,SBH,SBL,SBM,
+ *	   NDA,NDB,NDC,NDD,NDH,NDL,NDM,
+ *	   XRA,XRB,XRC,XRD,XRH,XRL,XRM,
+ *	   ORA,ORB,ORC,ORD,ORH,ORL,ORM,
+ *	   CPA,CPB,CPC,CPD,CPH,CPL,CPM
+ *	c: NOP,LAB,LAC,LAD,LAE,LAH,LAL,LAM,
+ *	   LBA,LBB,LBC,LBD,LBE,LBH,LBL,LBM,
+ *	   LCA,LCB,LCC,LCD,LCE,LCH,LCL,LCM,
+ *	   LDA,LDB,LDC,LDD,LDE,LDH,LDL,LDM,
+ *	   LEA,LEB,LEC,LED,LEE,LEH,LEL,LEM,
+ *	   LHA,LHB,LHC,LHD,LHE,LHH,LHL,LHM,
+ *	   LLA,LLB,LLC,LLD,LLE,LLH,LLL,LLM,
+ *	   LMA,LMB,LMC,LMD,LME,LMH,LML,HLT
+ *	d: JFC,CFC,JMP,CAL,JFZ,CFZ,
+ *	   JFS,CFS,JFP,CFP,
+ *	   JTC,CTC,JTZ,CTZ,
+ *	   JTS,CTS,JTP,CTP
+ *	e: INB,INC,IND,INE,INH,INL
+ *	f: DCB,DCC,DCD,DCE,DCH,DCL
+ *	g: ADI,ACI,SUI,SBI,NDI,XRI,ORI,CPI
+ *	h: LAI,LBI,LCI,LDI,LEI,LHI,LLI,LMI
+ *	i: RFC,RFS,RTC,RTS,RFZ,RFP,RTZ,RTP
+ *	j: RLC,RRC,RAL,RAR
+ *
+ * gen:
+ * 	.: output lastbyte
+ * 	b: (op << 3) | lastbyte
+ * 	c: op | lastbyte
+ * 	d: lastbyte = op as 8 bit value
+ * 	e: output op as word (no '.' should follow)
+ * 	f: (op << 1) | lastbyte, op in [0-7]
+ * 	g: (op << 1) | lastbyte, op in [8-31]
+ * 	h: (op << 4) | lastbyte
+ * 	i: (op << 1) | lastbyte
+ * 	j: (op << 3) | lastbyte, op in [0-7]
+ */
+
+static const struct matchtab s_matchtab_i8008[] = {
+	{ "RET", "07.", 1, 0 },
+	{ "j", "02b0.", 1, 0 },
+	{ "i", "03b0.", 1, 0 },
+	{ "h a", "06b0.d1.", 1, 0, "e8" },
+	{ "g a", "04b0.d1.", 1, 0, "e8" },
+	{ "e", "00b0.", 1, 0 },
+	{ "f", "01b0.", 1, 0 },
+	{ "RST a", "05j0.", 1, 0, "b3" },
+	{ "d a", "40i0.e1", 1, 0 },
+	{ "INP a", "41f0.", 1, 0, "b3" },
+	{ "OUT a", "41g0.", 1, 0, "kk" },
+	{ "b", "80c0.", 1, 0 },
+	{ "c", "C0c0.", 1, 0 },
+	{ NULL, NULL },
+};
+
+static const char *const bval[] = {
+"ADA", "ADB", "ADC", "ADD", "ADE", "ADH", "ADL", "ADM",
+"ACA", "ACB", "ACC", "ACD", "ACE", "ACH", "ACL", "ACM",
+"SUA", "SUB", "SUC", "SUD", "SUE", "SUH", "SUL", "SUM",
+"SBA", "SBB", "SBC", "SBD", "SBE", "SBH", "SBL", "SBM",
+"NDA", "NDB", "NDC", "NDD", "NDE", "NDH", "NDL", "NDM",
+"XRA", "XRB", "XRC", "XRD", "XRE", "XRH", "XRL", "XRM",
+"ORA", "ORB", "ORC", "ORD", "ORE", "ORH", "ORL", "ORM",
+"CPA", "CPB", "CPC", "CPD", "CPE", "CPH", "CPL", "CPM",
+NULL };
+
+static const char *const cval[] = {
+"NOP", "LAB", "LAC", "LAD", "LAE", "LAH", "LAL", "LAM",
+"LBA", "LBB", "LBC", "LBD", "LBE", "LBH", "LBL", "LBM",
+"LCA", "LCB", "LCC", "LCD", "LCE", "LCH", "LCL", "LCM",
+"LDA", "LDB", "LDC", "LDD", "LDE", "LDH", "LDL", "LDM",
+"LEA", "LEB", "LEC", "LED", "LEE", "LEH", "LEL", "LEM",
+"LHA", "LHB", "LHC", "LHD", "LHE", "LHH", "LHL", "LHM",
+"LLA", "LLB", "LLC", "LLD", "LLE", "LLH", "LLL", "LLM",
+"LMA", "LMB", "LMC", "LMD", "LME", "LMH", "LML", "HLT",
+NULL };
+
+static const char *const dval[] = {
+"JFC", "CFC", "JMP", "CAL", "JFZ", "CFZ", "", "",
+"JFS", "CFS", "",    "",    "JFP", "CFP", "", "",
+"JTC", "CTC", "",    "",    "JTZ", "CTZ", "", "",
+"JTS", "CTS", "",    "",    "JTP", "CTP",
+NULL };
+
+static const char *const eval[] = { "",    "INB", "INC", "IND",
+				    "INE", "INH", "INL",
+				    NULL };
+
+static const char *const fval[] = { "",    "DCB", "DCC", "DCD",
+				    "DCE", "DCH", "DCL",
+				    NULL };
+
+static const char *const gval[] = { "ADI", "ACI", "SUI", "SBI",
+				    "NDI", "XRI", "ORI", "CPI",
+				    NULL };
+
+static const char *const hval[] = { "LAI", "LBI", "LCI", "LDI",
+				    "LEI", "LHI", "LLI", "LMI",
+				    NULL };
+
+static const char *const ival[] = { "RFC", "RFZ", "RFS", "RFP",
+				    "RTC", "RTZ", "RTS", "RTP",
+				    NULL };
+
+static const char *const jval[] = { "RLC", "RRC", "RAL", "RAR",
+				    NULL };
+
+static const char *const *const valtab[] = { 
+	bval, cval, dval, eval, fval,
+       	gval, hval, ival, jval
+};
+
+static int match_i8008(char c, const char *p, const char **q)
+{
+	int v;
+
+	if (c <= 'j') {
+		v = mreg(p, valtab[(int) (c - 'b')], q);
+	} else {
+		v = -1;
+	}
+
+	return v;
+}
+
+static int gen_i8008(int *eb, char p, const int *vs, int i, int savepc)
+{
+	int b;
+       
+	b = *eb;
+	switch (p) {
+	case 'f': if (s_pass > 0 && (vs[i] < 0 || vs[i] > 7)) {
+			  eprint(_("argument (%d) must be in range [0-7]\n"),
+				vs[i]);
+			  eprcol(s_pline, s_pline_ep);
+			  newerr();
+		  }
+	          b |= (vs[i] << 1);
+		  break;
+	case 'g': if (s_pass > 0 && (vs[i] < 8 || vs[i] > 31)) {
+			  eprint(_("argument (%d) must be in range [8-31]\n"),
+				vs[i]);
+			  eprcol(s_pline, s_pline_ep);
+			  newerr();
+		  }
+	          b |= (vs[i] << 1);
+		  break;
+	case 'h': b |= (vs[i] << 4); break;
+	case 'i': b |= (vs[i] << 1); break;
+	case 'j': if (s_pass > 0 && (vs[i] < 0 || vs[i] > 7)) {
+			  eprint(_("argument (%d) must be in range [0-7]\n"),
+				vs[i]);
+			  eprcol(s_pline, s_pline_ep);
+			  newerr();
+		  }
+	          b |= (vs[i] << 3);
+		  break;
+	default:
+		  return -1;
+	}
+
+	*eb = b;
+	return 0;
+}
+
+static int s_pat_char = 'b';
+static int s_pat_index;
+
+static void pat_char_rewind_i8008(int c)
+{
+	s_pat_char = c;
+	s_pat_index = 0;
+};
+
+static const char *pat_next_str_i8008(void)
+{
+	const char *s;
+
+	if (s_pat_char >= 'b' && s_pat_char <= 'j') {
+		s = valtab[(int) (s_pat_char - 'b')][s_pat_index];
+		if (s != NULL) {
+			s_pat_index++;
+		}
+	} else {
+		s = NULL;
+	}
+
+	return s;
+};
+
+const struct target s_target_i8008 = {
+	.id = "i8008",
+	.descr = "Intel 8008",
+	.matcht = s_matchtab_i8008,
+	.matchf = match_i8008,
+	.genf = gen_i8008,
+	.pat_char_rewind = pat_char_rewind_i8008,
+	.pat_next_str = pat_next_str_i8008,
+	.mask = 1
+};
+

2048/uz80as/i8048.c

@@ -0,0 +1,276 @@
+/* ===========================================================================
+ * uz80as, an assembler for the Zilog Z80 and several other microprocessors.
+ *
+ * Intel 8021.
+ * Intel 8022.
+ * Intel 8041.
+ * Intel 8048.
+ * ===========================================================================
+ */
+
+#include "pp.h"
+#include "err.h"
+#include "options.h"
+#include "uz80as.h"
+#include <stddef.h>
+
+/* pat:
+ *	a: expr
+ *	b: R0,R1,R2,R3,R4,R5,R6,R7
+ *	c: R0,R1
+ *	d: P1,P2
+ *	e: P4,P5,P6,P7
+ *	f: JB0,JB1,JB2,JB3,JB4,JB5,JB6,JB7
+ *
+ * gen:
+ * 	.: output lastbyte
+ * 	b: (op << 3) | lastbyte
+ * 	c: op | lastbyte
+ * 	d: lastbyte = op as 8 bit value
+ * 	e: output op as word (no '.' should follow)
+ * 	f: output lastbyte | ((op & 0x700) >> 3)
+ * 	   output op as 8 bit value
+ * 	   (no '.' should follow)
+ * 	g: (op << 5) | lastbyte
+ */
+
+static const struct matchtab s_matchtab_i8048[] = {
+	{ "NOP", "00.", 1, 0 },
+	{ "ADD A,b", "68c0.", 1, 0 },
+	{ "ADD A,@c", "60c0.", 1, 0 },
+	{ "ADD A,#a", "03.d0.", 1, 0, "e8" },
+	{ "ADDC A,b", "78c0.", 1, 0 },
+	{ "ADDC A,@c", "70c0.", 1, 0 },
+	{ "ADDC A,#a", "13.d0.", 1, 0, "e8" },
+	{ "ANL A,b", "58c0.", 1, 0 },
+	{ "ANL A,@c", "50c0.", 1, 0 },
+	{ "ANL A,#a", "53.d0.", 1, 0, "e8" },
+	{ "ANL BUS,#a", "98.d0.", 32, 0, "e8" },
+	{ "ANL d,#a", "98c0.d1.", 4, 0, "e8" },
+	{ "ANLD e,A", "9Cc0.", 1, 0 },
+	{ "CALL a", "14f0", 1, 0 },
+	{ "CLR A", "27.", 1, 0 },
+	{ "CLR C", "97.", 1, 0 },
+	{ "CLR F1", "A5.", 4, 0 },
+	{ "CLR F0", "85.", 4, 0 },
+	{ "CPL A", "37.", 1, 0 },
+	{ "CPL C", "A7.", 1, 0 },
+	{ "CPL F0", "95.", 4, 0 },
+	{ "CPL F1", "B5.", 4, 0 },
+	{ "DA A", "57.", 1, 0 },
+	{ "DEC A", "07.", 1, 0 },
+	{ "DEC b", "C8c0.", 4, 0 },
+	{ "DIS I", "15.", 2, 0 },
+	{ "DIS TCNTI", "35.", 2, 0 },
+	{ "DJNZ b,a", "E8c0.d1.", 1, 0, "e8" },
+	{ "EN DMA", "E5.", 64, 0 },
+	{ "EN FLAGS", "F5.", 64, 0 },
+	{ "EN I", "05.", 2, 0 },
+	{ "EN TCNTI", "25.", 2, 0 },
+	{ "ENT0 CLK", "75.", 32, 0 },
+	{ "IN A,DBB", "22.", 64, 0 },
+	{ "IN A,P0", "08.", 8, 0 },
+	{ "IN A,d", "08c0.", 1, 0 },
+	{ "INC A", "17.", 1, 0 },
+	{ "INC b", "18c0.", 1, 0 },
+	{ "INC @c", "10c0.", 1, 0 },
+	{ "INS A,BUS", "08.", 32, 0 },
+	{ "f a", "12g0.d1.", 4, 0, "e8" },
+	{ "JC a", "F6.d0.", 1, 0, "e8" },
+	{ "JF0 a", "B6.d0.", 4, 0, "e8" },
+	{ "JF1 a", "76.d0.", 4, 0, "e8" },
+	{ "JMP a", "04f0", 1, 0, "e11" },
+	{ "JMPP @A", "B3.", 1, 0 },
+	{ "JNC a", "E6.d0.", 1, 0, "e8" },
+	{ "JNI a", "86.d0.", 32, 0, "e8" },
+	{ "JNIBF a", "D6.d0.", 64, 0, "e8" },
+	{ "JNT0 a", "26.d0.", 2, 0, "e8" },
+	{ "JNT1 a", "46.d0.", 1, 0, "e8" },
+	{ "JNZ a", "96.d0.", 1, 0, "e8" },
+	{ "JOBF a", "86.d0.", 64, 0, "e8" },
+	{ "JTF a", "16.d0.", 1, 0, "e8" },
+	{ "JT0 a", "36.d0.", 2, 0, "e8" },
+	{ "JT1 a", "56.d0.", 1, 0, "e8" },
+	{ "JZ a", "C6.d0.", 1, 0, "e8" },
+	{ "MOV A,#a", "23.d0.", 1, 0, "e8" },
+	{ "MOV A,PSW", "C7.", 4, 0 },
+	{ "MOV A,b", "F8c0.", 1, 0 },
+	{ "MOV A,@c", "F0c0.", 1, 0 },
+	{ "MOV A,T", "42.", 1, 0 },
+	{ "MOV PSW,A", "D7.", 4, 0 },
+	{ "MOV b,A", "A8c0.", 1, 0 },
+	{ "MOV b,#a", "B8c0.d1.", 1, 0, "e8" },
+	{ "MOV @c,A", "A0c0.", 1, 0 },
+	{ "MOV @c,#a", "B0c0.d1.", 1, 0, "e8" },
+	{ "MOV STS,A", "90.", 64, 0 },
+	{ "MOV T,A", "62.", 1, 0 },
+	{ "MOVD A,e", "0Cc0.", 1, 0 },
+	{ "MOVD e,A", "3Cc0.", 1, 0 },
+	{ "MOVP A,@A", "A3.", 1, 0 },
+	{ "MOVP3 A,@A", "E3.", 4, 0 },
+	{ "MOVX A,@c", "80c0.", 32, 0 },
+	{ "MOVX @c,A", "90c0.", 32, 0 },
+	{ "NOP", "00.", 1, 0 },
+	{ "ORL A,b", "48c0.", 1, 0 },
+	{ "ORL A,@c", "40c0.", 1, 0 },
+	{ "ORL A,#a", "43.d0.", 1, 0, "e8" },
+	{ "ORL BUS,#a", "88.d0.", 32, 0, "e8" },
+	{ "ORL d,#a", "88c0.d1.", 4, 0, "e8" },
+	{ "ORLD e,A", "8Cc0.", 1, 0 },
+	{ "OUT DBB,A", "02.", 64, 0 },
+	{ "OUTL BUS,A", "02.", 32, 0 },
+	{ "OUTL P0,A", "90.", 8, 0 },
+	{ "OUTL d,A", "38c0.", 1, 0 },
+	{ "RAD", "80.", 16, 0 },
+	{ "RET", "83.", 1, 0 },
+	{ "RETR", "93.", 4, 0 },
+	{ "RETI", "93.", 16, 0 },
+	{ "RL A", "E7.", 1, 0 },
+	{ "RLC A", "F7.", 1, 0 },
+	{ "RR A", "77.", 1, 0 },
+	{ "RRC A", "67.", 1, 0 },
+	{ "SEL AN0", "85.", 16, 0 },
+	{ "SEL AN1", "95.", 16, 0 },
+	{ "SEL MB0", "E5.", 32, 0 },
+	{ "SEL MB1", "F5.", 32, 0 },
+	{ "SEL RB0", "C5.", 4, 0 },
+	{ "SEL RB1", "D5.", 4, 0 },
+	{ "STOP TCNT", "65.", 1, 0 },
+	{ "STRT CNT", "45.", 1, 0 },
+	{ "STRT T", "55.", 1, 0 },
+	{ "SWAP A", "47.", 1, 0 },
+	{ "XCH A,b", "28c0.", 1, 0 },
+	{ "XCH A,@c", "20c0.", 1, 0 },
+	{ "XCHD A,@c", "30c0.", 1, 0 },
+	{ "XRL A,b", "D8c0.", 1, 0 },
+	{ "XRL A,@c", "D0c0.", 1, 0 },
+	{ "XRL A,#a", "D3.d0.", 1, 0, "e8" },
+	{ NULL, NULL },
+};
+
+static const char *const bval[] = {
+"R0", "R1", "R2", "R3", "R4", "R5", "R6", "R7",
+NULL };
+
+static const char *const cval[] = {
+"R0", "R1",
+NULL };
+
+static const char *const dval[] = {
+"", "P1", "P2",
+NULL };
+
+static const char *const eval[] = {
+"P4", "P5", "P6", "P7",
+NULL };
+
+static const char *const fval[] = {
+"JB0", "JB1", "JB2", "JB3", "JB4", "JB5", "JB6", "JB7",
+NULL };
+
+static const char *const *const valtab[] = { 
+	bval, cval, dval, eval, fval
+};
+
+static int match_i8048(char c, const char *p, const char **q)
+{
+	int v;
+
+	if (c <= 'f') {
+		v = mreg(p, valtab[(int) (c - 'b')], q);
+	} else {
+		v = -1;
+	}
+
+	return v;
+}
+
+static int gen_i8048(int *eb, char p, const int *vs, int i, int savepc)
+{
+	int b;
+       
+	b = *eb;
+	switch (p) {
+	case 'f': b |= ((vs[i] & 0x700) >> 3);
+		  genb(b, s_pline_ep);
+		  genb(vs[i], s_pline_ep);
+		  break;
+	case 'g': b |= (vs[i] << 5);
+		  break;
+	default:
+		  return -1;
+	}
+
+	*eb = b;
+	return 0;
+}
+
+static int s_pat_char = 'b';
+static int s_pat_index;
+
+static void pat_char_rewind_i8048(int c)
+{
+	s_pat_char = c;
+	s_pat_index = 0;
+};
+
+static const char *pat_next_str_i8048(void)
+{
+	const char *s;
+
+	if (s_pat_char >= 'b' && s_pat_char <= 'f') {
+		s = valtab[(int) (s_pat_char - 'b')][s_pat_index];
+		if (s != NULL) {
+			s_pat_index++;
+		}
+	} else {
+		s = NULL;
+	}
+
+	return s;
+};
+
+const struct target s_target_i8041 = {
+	.id = "i8041",
+	.descr = "Intel 8041",
+	.matcht = s_matchtab_i8048,
+	.matchf = match_i8048,
+	.genf = gen_i8048,
+	.pat_char_rewind = pat_char_rewind_i8048,
+	.pat_next_str = pat_next_str_i8048,
+	.mask = 71
+};
+
+const struct target s_target_i8048 = {
+	.id = "i8048",
+	.descr = "Intel 8048",
+	.matcht = s_matchtab_i8048,
+	.matchf = match_i8048,
+	.genf = gen_i8048,
+	.pat_char_rewind = pat_char_rewind_i8048,
+	.pat_next_str = pat_next_str_i8048,
+	.mask = 39
+};
+
+const struct target s_target_i8021 = {
+	.id = "i8021",
+	.descr = "Intel 8021",
+	.matcht = s_matchtab_i8048,
+	.matchf = match_i8048,
+	.genf = gen_i8048,
+	.pat_char_rewind = pat_char_rewind_i8048,
+	.pat_next_str = pat_next_str_i8048,
+	.mask = 9
+};
+
+const struct target s_target_i8022 = {
+	.id = "i8022",
+	.descr = "Intel 8022",
+	.matcht = s_matchtab_i8048,
+	.matchf = match_i8048,
+	.genf = gen_i8048,
+	.pat_char_rewind = pat_char_rewind_i8048,
+	.pat_next_str = pat_next_str_i8048,
+	.mask = 27
+};
+

2048/uz80as/i8051.c

@@ -0,0 +1,244 @@
+/* ===========================================================================
+ * uz80as, an assembler for the Zilog Z80 and several other microprocessors.
+ *
+ * Intel 8051.
+ * ===========================================================================
+ */
+
+#include "pp.h"
+#include "err.h"
+#include "options.h"
+#include "uz80as.h"
+#include <stddef.h>
+
+/* pat:
+ *	a: expr
+ *	b: R0,R1,R2,R3,R4,R5,R6,R7
+ *	c: R0,R1
+ * 	d: ADD,ADDC,ORL,ANL,XRL,SUBB,XCH,MOV
+ *
+ * gen:
+ * 	.: output lastbyte
+ * 	b: (op << 3) | lastbyte
+ * 	c: op | lastbyte
+ * 	d: lastbyte = op as 8 bit value
+ * 	e: output op as word (no '.' should follow)
+ * 	f: output lastbyte | ((op & 0x700) >> 3)
+ * 	   output op as 8 bit value
+ * 	   (no '.' should follow)
+ * 	g: relative jump -2
+ * 	h: relative jump -3
+ * 	i: ouput op as big endian word
+ * 	j: b + (op << 4)
+ */
+
+static const struct matchtab s_matchtab_i8051[] = {
+	{ "ACALL a", "11f0", 1, 0, "e11" },
+	{ "d A,b", "08j0c1.", 1, 0 },
+	{ "d A,@c", "06j0c1.", 1, 0 },
+	{ "ADD A,#a", "24.d0.", 1, 0, "e8" },
+	{ "ADDC A,#a", "34.d0.", 1, 0, "e8" },
+	{ "ORL A,#a", "44.d0.", 1, 0, "e8" },
+	{ "ANL A,#a", "54.d0.", 1, 0, "e8" },
+	{ "XRL A,#a", "64.d0.", 1, 0, "e8" },
+	{ "SUBB A,#a", "94.d0.", 1, 0, "e8" },
+	{ "MOV A,#a", "74.d0.", 1, 0, "e8" },
+	{ "d A,a", "05j0.d1.", 1, 0, "e8" },
+	// { "ADD A,b", "28c0.", 1, 0 },
+	// { "ADD A,@c", "26c0.", 1, 0 },
+	// { "ADD A,a", "25.d0.", 1, 0, "e8" },
+	// { "ADDC A,b", "38c0.", 1, 0 },
+	// { "ADDC A,@c", "36c0.", 1, 0 },
+	// { "ADDC A,a", "35.d0.", 1, 0, "e8" },
+	{ "AJMP a", "01f0", 1, 0, "e11" },
+	// { "ANL A,b", "58c0.", 1, 0 },
+	// { "ANL A,@c", "56c0.", 1, 0 },
+	// { "ANL A,a", "55.d0.", 1, 0, "e8" },
+	{ "ANL C,/a", "B0.d0.", 1, 0, "e8" },
+	{ "ANL C,a", "82.d0.", 1, 0, "e8" },
+	{ "ANL a,A", "52.d0.", 1, 0 },
+	{ "ANL a,#a", "53.d0.d1.", 1, 0, "e8e8" },
+	{ "CJNE A,#a,a", "B4.d0.h1.", 1, 0, "e8r8" },
+	{ "CJNE b,#a,a", "B8c0.d1.h2.", 1, 0, "e8r8" },
+	{ "CJNE @c,#a,a", "B6c0.d1.h2.", 1, 0, "e8r8" },
+	{ "CJNE A,a,a", "B5.d0.h1.", 1, 0, "e8r8" },
+	{ "CLR A", "E4.", 1, 0 },
+	{ "CLR C", "C3.", 1, 0 },
+	{ "CLR a", "C2.d0.", 1, 0, "e8" },
+	{ "CPL A", "F4.", 1, 0 },
+	{ "CPL C", "B3.", 1, 0 },
+	{ "CPL a", "B2.d0.", 1, 0, "e8" },
+	{ "DA A", "D4.", 1, 0 },
+	{ "DEC A", "14.", 1, 0 },
+	{ "DEC b", "18c0.", 1, 0 },
+	{ "DEC @c", "16c0.", 1, 0 },
+	{ "DEC a", "15.d0.", 1, 0, "e8" },
+	{ "DIV AB", "84.", 1, 0 },
+	{ "DJNZ b,a", "D8c0.g1.", 1, 0, "r8" },
+	{ "DJNZ a,a", "D5.d0.h1.", 1, 0, "e8r8" },
+	{ "INC DPTR", "A3.", 1, 0 },
+	{ "INC A", "04.", 1, 0 },
+	{ "INC b", "08c0.", 1, 0 },
+	{ "INC @c", "06c0.", 1, 0 },
+	{ "INC a", "05.d0.", 1, 0, "e8" },
+	{ "JB a,a", "20.d0.h1.", 1, 0, "e8r8" },
+	{ "JBC a,a", "10.d0.h1.", 1, 0, "e8r8" },
+	{ "JC a", "40.g0.", 1, 0, "r8" },
+	{ "JMP @A+DPTR", "73.", 1, 0 },
+	{ "JNB a,a", "30.d0.h1.", 1, 0, "e8r8" },
+	{ "JNC a", "50.g0.", 1, 0, "r8" },
+	{ "JNZ a", "70.g0.", 1, 0, "r8" },
+	{ "JZ a", "60.g0.", 1, 0, "r8" },
+	{ "LCALL a", "12.i0", 1, 0 }, 
+	{ "LJMP a", "02.i0", 1, 0 },
+	// { "MOV A,b", "E8c0.", 1, 0 },
+	// { "MOV A,@c", "E6c0.", 1, 0 },
+	// { "MOV A,a", "E5.d0.", 1, 0, "e8" }, // MOV A,ACC not valid?
+	{ "MOV b,A", "F8c0.", 1, 0 },
+	{ "MOV b,#a", "78c0.d1.", 1, 0, "e8" },
+	{ "MOV b,a", "A8c0.d1.", 1, 0, "e8" },
+	{ "MOV @c,A", "F6c0.", 1, 0 },
+	{ "MOV @c,#a", "76c0.d1.", 1, 0, "e8" },
+	{ "MOV @c,a", "A6c0.d1.", 1, 0, "e8" },
+	{ "MOV C,a", "A2.d0.", 1, 0, "e8" },
+	{ "MOV DPTR,#a", "90.i0", 1, 0, "e8" },
+	{ "MOV a,A", "F5.d0.", 1, 0, "e8" },
+	{ "MOV a,C", "92.d0.", 1, 0, "e8" },
+	{ "MOV a,b", "88c1.d0.", 1, 0, "e8" },
+	{ "MOV a,@c", "86c1.d0.", 1, 0, "e8" },
+	{ "MOV a,#a", "75.d0.d1.", 1, 0, "e8e8" },
+	{ "MOV a,a", "85.d1.d0.", 1, 0, "e8e8" },
+	{ "MOVC A,@A+DPTR", "93.", 1, 0 },
+	{ "MOVC A,@A+PC", "83.", 1, 0 },
+	{ "MOVX A,@c", "E2c0.", 1, 0 },
+	{ "MOVX A,@DPTR", "E0.", 1, 0 },
+	{ "MOVX @c,A", "F2c0.", 1, 0 },
+	{ "MOVX @DPTR,A", "F0.", 1, 0 },
+	{ "MUL AB", "A4.", 1, 0 },
+	{ "NOP", "00.", 1, 0 },
+	// { "ORL A,b", "48c0.", 1, 0 },
+	// { "ORL A,@c", "46c0.", 1, 0 },
+	// { "ORL A,a", "45.d0.", 1, 0, "e8" },
+	{ "ORL C,/a", "A0.d0.", 1, 0, "e8" },
+	{ "ORL C,a", "72.d0.", 1, 0, "e8" },
+	{ "ORL a,A", "42.d0.", 1, 0, "e8" },
+	{ "ORL a,#a", "43.d0.d1.", 1, 0, "e8e8" },
+	{ "POP a", "D0.d0.", 1, 0, "e8" },
+	{ "PUSH a", "C0.d0.", 1, 0, "e8" },
+	{ "RET", "22.", 1, 0 },
+	{ "RETI", "32.", 1, 0 },
+	{ "RL A", "23.", 1, 0 },
+	{ "RLC A", "33.", 1, 0 },
+	{ "RR A", "03.", 1, 0 },
+	{ "RRC A", "13.", 1, 0 },
+	{ "SETB C", "D3.", 1, 0 },
+	{ "SETB a", "D2.d0.", 1, 0, "e8" },
+	{ "SJMP a", "80.g0.", 1, 0, "r8" },
+	// { "SUBB A,b", "98c0.", 1, 0 },
+	// { "SUBB A,@c", "96c0.", 1, 0 },
+	// { "SUBB A,a", "95.d0.", 1, 0, "e8" },
+	{ "SWAP A", "C4.", 1, 0 },
+	// { "XCH A,b", "C8c0.", 1, 0 },
+	// { "XCH A,@c", "C6c0.", 1, 0 },
+	// { "XCH A,a", "C5.d0.", 1, 0, "e8" },
+	{ "XCHD A,@c", "D6c0.", 1, 0 },
+	// { "XRL A,b", "68c0.", 1, 0 },
+	// { "XRL A,@c", "66c0.", 1, 0 },
+	// { "XRL A,a", "65.d0.", 1, 0, "e8" },
+	{ "XRL a,A", "62.d0.", 1, 0, "e8" },
+	{ "XRL a,#a", "63.d0.d1.", 1, 0, "e8e8" },
+	{ NULL, NULL },
+};
+
+static const char *const bval[] = {
+"R0", "R1", "R2", "R3", "R4", "R5", "R6", "R7",
+NULL };
+
+static const char *const cval[] = {
+"R0", "R1",
+NULL };
+
+static const char *const dval[] = {
+"", "", "ADD", "ADDC", "ORL", "ANL", "XRL", "",
+"", "SUBB", "", "", "XCH", "", "MOV",
+NULL };
+
+static const char *const *const valtab[] = { 
+	bval, cval, dval
+};
+
+static int match_i8051(char c, const char *p, const char **q)
+{
+	int v;
+
+	if (c <= 'd') {
+		v = mreg(p, valtab[(int) (c - 'b')], q);
+	} else {
+		v = -1;
+	}
+
+	return v;
+}
+
+static int gen_i8051(int *eb, char p, const int *vs, int i, int savepc)
+{
+	int b;
+       
+	b = *eb;
+	switch (p) {
+	case 'f': b |= ((vs[i] & 0x700) >> 3);
+		  genb(b, s_pline_ep);
+		  genb(vs[i], s_pline_ep);
+		  break;
+	case 'g': b = (vs[i] - savepc - 2); break;
+		  break;
+	case 'h': b = (vs[i] - savepc - 3); break;
+		  break;
+	case 'i': genb(vs[i] >> 8, s_pline_ep);
+		  genb(vs[i], s_pline_ep);
+		  break;
+	case 'j': b += (vs[i] << 4); break;
+	default:
+		  return -1;
+	}
+
+	*eb = b;
+	return 0;
+}
+
+static int s_pat_char = 'b';
+static int s_pat_index;
+
+static void pat_char_rewind_i8051(int c)
+{
+	s_pat_char = c;
+	s_pat_index = 0;
+};
+
+static const char *pat_next_str_i8051(void)
+{
+	const char *s;
+
+	if (s_pat_char >= 'b' && s_pat_char <= 'd') {
+		s = valtab[(int) (s_pat_char - 'b')][s_pat_index];
+		if (s != NULL) {
+			s_pat_index++;
+		}
+	} else {
+		s = NULL;
+	}
+
+	return s;
+};
+
+const struct target s_target_i8051 = {
+	.id = "i8051",
+	.descr = "Intel 8051",
+	.matcht = s_matchtab_i8051,
+	.matchf = match_i8051,
+	.genf = gen_i8051,
+	.pat_char_rewind = pat_char_rewind_i8051,
+	.pat_next_str = pat_next_str_i8051,
+	.mask = 1
+};
+

2048/uz80as/i8080.c

@@ -0,0 +1,214 @@
+/* ===========================================================================
+ * uz80as, an assembler for the Zilog Z80 and several other microprocessors.
+ *
+ * Intel 8080.
+ * ===========================================================================
+ */
+
+#include "pp.h"
+#include "err.h"
+#include "options.h"
+#include "uz80as.h"
+#include <stddef.h>
+
+/* pat:
+ *	a: expr
+ *	b: B,C,D,E,H,L,M,A
+ *	c: B,D,H,SP
+ *	d: B,D
+ *	e: B,D,H,PSW
+ *	f: JNZ,JZ,JNC,JC,JPO,JPE,JP,JM
+ *	g: CNZ,CZ,CNC,CC,CPO,CPE,CP,CM
+ *	h: RNZ,RZ,RNC,RC,RPO,RPE,RP,RM
+ *	i: B,C,D,E,H,L,A
+ *	j: ADD,ADC,SUB,SBB,ANA,XRA,ORA,CMP
+ *	k: RLC,RRC,RAL,RAR
+ *	l: ADI,ACI,SUI,SBI,ANI,XRI,ORI,CPI
+ *	m: SHLD,LHLD,STA,LDA
+ *	n: DI,EI
+ *	o: OUT,IN
+ *	p: STC,CMC
+ *	q: POP,PUSH
+ *	r: STAX,LDAX
+ *
+ * gen:
+ * 	.: output lastbyte
+ * 	b: (op << 3) | lastbyte
+ * 	c: op | lastbyte
+ * 	d: lastbyte = op as 8 bit value
+ * 	e: output op as word (no '.' should follow)
+ * 	f: (op << 4) | lastbyte
+ * 	g: possible value to RST
+ * 	h: (op << 2) | lastbyte
+ */
+
+static const struct matchtab s_matchtab_i8080[] = {
+	{ "MOV M,i", "70c0.", 3, 0 },
+	{ "MOV i,M", "46b0.", 3, 0 },
+	{ "MOV i,i", "40b0c1.", 3, 0 },
+	{ "MVI b,a", "06b0.d1.", 3, 0, "e8" },
+	{ "LXI c,a", "01f0.e1", 3, 0 },
+	{ "m a", "22b0.e1", 3, 0 },
+	{ "r d", "02b0f1.", 3, 0 },
+	{ "XCHG", "EB.", 3, 0 },
+	{ "j b", "80b0c1.", 3, 0 },
+	{ "l a", "C6b0.d1.", 3, 0, "e8" },
+	{ "INR b", "04b0.", 3, 0 },
+	{ "DCR b", "05b0.", 3, 0 },
+	{ "INX c", "03f0.", 3, 0 },
+	{ "DCX c", "0Bf0.", 3, 0 },
+	{ "DAD c", "09f0.", 3, 0 },
+	{ "DAA", "27.", 3, 0 },
+	{ "k", "07b0.", 3, 0 },
+	{ "CMA", "2F.", 3, 0 },
+	{ "p", "37b0.", 3, 0 },
+	{ "JMP a", "C3.e0", 3, 0 },
+	{ "f a", "C2b0.e1", 3, 0 },
+	{ "CALL a", "CD.e0", 3, 0 },
+	{ "g a", "C4b0.e1", 3, 0 },
+	{ "RET", "C9.", 3, 0 },
+	{ "h", "C0b0.", 3, 0 },
+	{ "RST a", "C7g0.", 3, 0, "b3" },
+	{ "PCHL", "E9.", 3, 0 },
+	{ "q e", "C1h0f1.", 3, 0 },
+	{ "XTHL", "E3.", 3, 0 },
+	{ "SPHL", "F9.", 3, 0 },
+	{ "o a", "D3b0.d1.", 3, 0, "e8" },
+	{ "n", "F3b0.", 3, 0 },
+	{ "HLT", "76.", 3, 0 },
+	{ "NOP", "00.", 3, 0 },
+	/* 8085 added instructions */
+	{ "RIM", "20.", 2, 0 },
+	{ "SIM", "30.", 2, 0 },
+	{ "ARHL", "10.", 2, 2 },
+	{ "DSUB", "08.", 2, 2 },
+	{ "RDEL", "18.", 2, 2 },
+	{ "LDHI a", "28.d0.", 2, 2, "e8" },
+	{ "LDSI a", "38.d0.", 2, 2, "e8" },
+	{ "RSTV", "CB.", 2, 2 },
+	{ "SHLX", "D9.", 2, 2 },
+	{ "LHLX", "ED.", 2, 2 },
+	{ "JNK a", "DD.e0", 2, 2 },
+	{ "JNX5 a", "DD.e0", 2, 2 },
+	{ "JNUI a", "DD.e0", 2, 2 },
+	{ "JK a", "FD.e0", 2, 2 },
+	{ "JX5 a", "FD.e0", 2, 2 },
+	{ "JUI a", "FD.e0", 2, 2 },
+	{ NULL, NULL },
+};
+
+static const char *const bval[] = { "B", "C", "D", "E",
+				    "H", "L", "M", "A", NULL };
+static const char *const cval[] = { "B", "D", "H", "SP", NULL };
+static const char *const dval[] = { "B", "D", NULL };
+static const char *const eval[] = { "B", "D", "H", "PSW", NULL };
+static const char *const fval[] = { "JNZ", "JZ", "JNC", "JC",
+				    "JPO", "JPE", "JP", "JM", NULL };
+static const char *const gval[] = { "CNZ", "CZ", "CNC", "CC",
+				    "CPO", "CPE", "CP", "CM", NULL };
+static const char *const hval[] = { "RNZ", "RZ", "RNC", "RC",
+				    "RPO", "RPE", "RP", "RM", NULL };
+static const char *const ival[] = { "B", "C", "D", "E",
+				    "H", "L", "", "A", NULL };
+static const char *const jval[] = { "ADD", "ADC", "SUB", "SBB",
+				    "ANA", "XRA", "ORA", "CMP", NULL };
+static const char *const kval[] = { "RLC", "RRC", "RAL", "RAR", NULL };
+static const char *const lval[] = { "ADI", "ACI", "SUI", "SBI",
+				    "ANI", "XRI", "ORI", "CPI", NULL };
+static const char *const mval[] = { "SHLD", "LHLD", "STA", "LDA", NULL };
+static const char *const nval[] = { "DI", "EI", NULL };
+static const char *const oval[] = { "OUT", "IN", NULL };
+static const char *const pval[] = { "STC", "CMC", NULL };
+static const char *const qval[] = { "POP", "PUSH", NULL };
+static const char *const rval[] = { "STAX", "LDAX", NULL };
+
+static const char *const *const valtab[] = { 
+	bval, cval, dval, eval, fval,
+       	gval, hval, ival, jval, kval,
+	lval, mval, nval, oval, pval,
+	qval, rval
+};
+
+static int match_i8080(char c, const char *p, const char **q)
+{
+	int v;
+
+	if (c <= 'r') {
+		v = mreg(p, valtab[(int) (c - 'b')], q);
+	} else {
+		v = -1;
+	}
+
+	return v;
+}
+
+static int gen_i8080(int *eb, char p, const int *vs, int i, int savepc)
+{
+	int b;
+       
+	b = *eb;
+	switch (p) {
+	case 'f': b |= (vs[i] << 4); break;
+	case 'g': if (s_pass > 0 && (vs[i] & ~7) != 0) {
+			  eprint(_("invalid RST argument (%d)\n"),
+				vs[i]);
+			  eprcol(s_pline, s_pline_ep);
+			  newerr();
+		  }
+		  b |= (vs[i] << 3);
+		  break;
+	case 'h': b |= (vs[i] << 2); break;
+	default:
+		  return -1;
+	}
+
+	*eb = b;
+	return 0;
+}
+
+static int s_pat_char = 'b';
+static int s_pat_index;
+
+static void pat_char_rewind_i8080(int c)
+{
+	s_pat_char = c;
+	s_pat_index = 0;
+};
+
+static const char *pat_next_str_i8080(void)
+{
+	const char *s;
+
+	if (s_pat_char >= 'b' && s_pat_char <= 'r') {
+		s = valtab[(int) (s_pat_char - 'b')][s_pat_index];
+		if (s != NULL) {
+			s_pat_index++;
+		}
+	} else {
+		s = NULL;
+	}
+
+	return s;
+};
+
+const struct target s_target_i8080 = {
+	.id = "i8080",
+	.descr = "Intel 8080",
+	.matcht = s_matchtab_i8080,
+	.matchf = match_i8080,
+	.genf = gen_i8080,
+	.pat_char_rewind = pat_char_rewind_i8080,
+	.pat_next_str = pat_next_str_i8080,
+	.mask = 1
+};
+
+const struct target s_target_i8085 = {
+	.id = "i8085",
+	.descr = "Intel 8085",
+	.matcht = s_matchtab_i8080,
+	.matchf = match_i8080,
+	.genf = gen_i8080,
+	.pat_char_rewind = pat_char_rewind_i8080,
+	.pat_next_str = pat_next_str_i8080,
+	.mask = 2
+};

2048/uz80as/incl.c

@@ -0,0 +1,81 @@
+/* ===========================================================================
+ * uz80as, an assembler for the Zilog Z80 and several other microprocessors.
+ *
+ * Include file stack.
+ * ===========================================================================
+ */
+
+#include "config.h"
+#include "incl.h"
+#include "utils.h"
+#include "err.h"
+
+#ifndef ASSERT_H
+#include <assert.h>
+#endif
+
+#ifndef STDIO_H
+#include <stdio.h>
+#endif
+
+#ifndef STDLIB_H
+#include <stdlib.h>
+#endif
+
+/* Max number of nested included files. */
+#define NFILES		128
+
+/* Number of nested files. */
+static int s_nfiles;
+
+/* Current file. */
+static struct incfile *s_curfile;
+
+/* Get the current file. Never returns NULL. */
+struct incfile *curfile(void)
+{
+	assert(s_curfile != NULL);
+	return s_curfile;
+}
+
+/* The number of nested files. 0 means no file loaded. */
+int nfiles(void)
+{
+	return s_nfiles;
+}
+
+/* Leave the current included file. */
+void popfile(void)
+{
+	struct incfile *ifile;
+
+	assert(s_curfile != NULL);
+	fclose(s_curfile->fin);
+	ifile = s_curfile;
+	s_curfile = ifile->prev;
+	free(ifile);
+	s_nfiles--;
+}
+
+/* Include a file whose name is [p, q[. */
+void pushfile(const char *p, const char *q)
+{
+	struct incfile *ifile;
+
+	if (s_nfiles == NFILES) {
+		eprint(_("maximum number of nested includes exceeded (%d)\n"),
+			NFILES);
+		exit(EXIT_FAILURE);
+	}
+
+	// printf("pushfile: %s\n", p);
+	ifile = emalloc((sizeof *ifile) + (q - p) + 1);
+	ifile->name = (char *) ((unsigned char *) ifile + sizeof *ifile);
+	copychars(ifile->name, p, q);
+
+	ifile->fin = efopen(ifile->name, "r");
+	ifile->linenum = 0;
+	ifile->prev = s_curfile;
+	s_curfile = ifile;
+	s_nfiles++;
+}

2048/uz80as/incl.h

@@ -0,0 +1,28 @@
+/* ===========================================================================
+ * uz80as, an assembler for the Zilog Z80 and several other microprocessors.
+ *
+ * Include file stack.
+ * ===========================================================================
+ */
+
+#ifndef INCL_H
+#define INCL_H
+
+#ifndef STDIO_H
+#define STDIO_H
+#include <stdio.h>
+#endif
+
+struct incfile {
+	struct incfile *prev;
+	FILE *fin;
+	int linenum;
+	char *name;
+};
+
+void pushfile(const char *p, const char *q);
+void popfile(void);
+struct incfile *curfile(void);
+int nfiles(void);
+
+#endif

2048/uz80as/list.c

@@ -0,0 +1,164 @@
+/* ===========================================================================
+ * uz80as, an assembler for the Zilog Z80 and several other microprocessors.
+ *
+ * Assembly listing generation.
+ * ===========================================================================
+ */
+
+#include "config.h"
+#include "list.h"
+#include "err.h"
+
+#ifndef STDIO_H
+#include <stdio.h>
+#endif
+
+#ifndef STLIB_H
+#include <stdlib.h>
+#endif
+
+#ifndef STRING_H
+#include <string.h>
+#endif
+
+static FILE *s_list_file;
+
+/* N characters in current line. */
+static int s_nchars;
+
+/* Generated data bytes in this line. */
+static int s_nbytes;
+
+/* Line text. */
+static const char *s_line;
+
+/* Line number. */
+static int s_linenum;
+
+/* Program counter. */
+static int s_pc;
+
+/* Number of current nested files. */
+static int s_nfiles;
+
+/* If listing line number, etc are generated or just the line. */
+int s_codes = 1;
+
+/* If listing is enabled or not. */
+int s_list_on = 1;
+
+/* If we are skipping lines. */
+static int s_skip_on = 0;
+
+void list_open(const char *fname)
+{
+	s_list_file = fopen(fname, "w");
+	if (s_list_file == NULL) {
+		eprint(_("cannot open file %s\n"), fname);
+	}
+}
+
+void list_close(void)
+{
+	if (s_list_file != NULL)
+		fclose(s_list_file);
+}
+
+static void prhead(void)
+{
+	int i, j, n;
+
+	s_nchars = fprintf(s_list_file, "%-.4d", s_linenum);
+
+	n = 7 - s_nchars;
+	if (n <= 0)
+		n = 1;
+	j = 0;
+	if (s_nfiles > 0)
+		j = s_nfiles - 1;
+	if (j > n)
+		j = n;
+	for (i = 0; i < j; i++)
+		fputc('+', s_list_file);
+	j = n - j;
+	while (j--)
+		fputc(' ', s_list_file);
+	s_nchars += n;
+
+	s_nchars += fprintf(s_list_file, "%.4X", s_pc);
+	if (s_skip_on)
+		fputc('~', s_list_file);
+	else
+		fputc(' ', s_list_file);
+	s_nchars += 1;
+}
+
+static void prline(void)
+{
+	if (s_line == NULL) {
+		fputs("\n", s_list_file);
+	} else {
+		if (s_codes) {
+			while (s_nchars < 24) {
+				s_nchars++;
+				fputc(' ', s_list_file);
+			}
+		}
+		fprintf(s_list_file, "%s\n", s_line);
+		s_line = NULL;
+	}
+	s_nchars = 0;
+	s_nbytes = 0;
+}
+
+void list_startln(const char *line, int linenum, int pc, int nested_files)
+{
+	if (s_list_file == NULL)
+		return;
+	s_linenum = linenum;
+	s_pc = pc;
+	s_line = line;
+	s_nchars = 0;
+	s_nbytes = 0;
+	s_nfiles = nested_files;
+}
+
+void list_setpc(int pc)
+{
+	s_pc = pc;
+}
+
+void list_skip(int on)
+{
+	s_skip_on = on;
+}
+
+void list_eject(void)
+{
+	if (s_list_file == NULL || !s_list_on)
+		return;
+}
+
+void list_genb(int b)
+{
+	if (s_list_file == NULL || !s_codes || !s_list_on)
+		return;
+	if (s_nchars == 0)
+		prhead();
+	if (s_nbytes >= 4) {
+		prline();
+		prhead();
+	}
+	s_nchars += fprintf(s_list_file, "%2.2X ", (b & 0xff));
+	s_nbytes++;
+	s_pc++;
+}
+
+void list_endln(void)
+{
+	if (s_list_file == NULL || !s_list_on)
+		return;
+	if (s_codes && s_nchars == 0)
+		prhead();
+	prline();
+}

2048/uz80as/list.h

@@ -0,0 +1,23 @@
+/* ===========================================================================
+ * uz80as, an assembler for the Zilog Z80 and several other microprocessors.
+ *
+ * Assembly listing generation.
+ * ===========================================================================
+ */
+
+#ifndef LIST_H
+#define LIST_H
+
+extern int s_codes;
+extern int s_list_on;
+
+void list_open(const char *fname);
+void list_close(void);
+void list_startln(const char *line, int linenum, int pc, int nested_files);
+void list_setpc(int pc);
+void list_skip(int on);
+void list_eject(void);
+void list_genb(int b);
+void list_endln(void);
+
+#endif

2048/uz80as/main.c

@@ -0,0 +1,303 @@
+/* ===========================================================================
+ * uz80as, an assembler for the Zilog Z80 and several other microprocessors.
+ *
+ * main(), handling of command line options.
+ * ===========================================================================
+ */
+
+#include "config.h"
+#include "ngetopt.h"
+#include "options.h"
+#include "utils.h"
+#include "err.h"
+#include "uz80as.h"
+#include "prtable.h"
+#include "targets.h"
+
+#ifndef STDIO_H
+#include <stdio.h>
+#endif
+
+#ifndef STDLIB_H
+#include <stdlib.h>
+#endif
+
+#ifndef STRING_H
+#include <string.h>
+#endif
+
+#ifndef CTYPE_H
+#include <ctype.h>
+#endif
+
+void print_copyright(FILE *f)
+{
+	static const char *copyright =
+"Copyright (C) " COPYRIGHT_YEARS " Jorge Giner Cordero.\n";
+
+	fputs(copyright, f);
+}
+
+static void print_license(FILE *f)
+{
+	static const char *license[] = {
+"Permission is hereby granted, free of charge, to any person obtaining",
+"a copy of this software and associated documentation files (the",
+"\"Software\"), to deal in the Software without restriction, including",
+"without limitation the rights to use, copy, modify, merge, publish,",
+"distribute, sublicense, and/or sell copies of the Software, and to",
+"permit persons to whom the Software is furnished to do so, subject to",
+"the following conditions:",
+"",
+"The above copyright notice and this permission notice shall be included",
+"in all copies or substantial portions of the Software.",
+"",
+"THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND,",
+"EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF",
+"MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.",
+"IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY",
+"CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,",
+"TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE",
+"SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE."
+       	};
+
+	int i;
+
+	for (i = 0; i < NELEMS(license); i++) {
+		fprintf(f, "%s\n", license[i]);
+	}
+}
+
+static void print_version(FILE *f)
+{
+	const struct target *p;
+
+	fputs(PACKAGE_STRING, f);
+	fputs("\n", f);
+	fputs("Targets:", f);
+	for (p = first_target(); p != NULL; p = next_target()) {
+		fprintf(f, " %s", p->id);
+	}
+	fputs("\n", f);
+}
+
+static void print_help(const char *argv0)
+{
+	static const char *help =
+"Usage: %s [OPTION]... ASM_FILE [OBJ_FILE [LST_FILE]]\n"
+"\n"
+"Assemble ASM_FILE into OBJ_FILE and generate the listing LST_FILE.\n"
+"If not specified, OBJ_FILE is ASM_FILE with the extension changed to .obj.\n"
+"If not specified, LST_FILE is ASM_FILE with the extension changed to .lst.\n"
+"\n"
+"Options:\n"
+"  -h, --help           Display this help and exit.\n"
+"  -V, --verbose        be chatty.\n"
+"  -v, --version        Output version information and exit.\n"
+"  -l, --license        Display the license text and exit.\n"
+"  -d, --define=MACRO   Define a macro.\n"
+"  -f, --fill=n         Fill memory with value n.\n"
+"  -q, --quiet          Do not generate the listing file.\n"
+"  -x, --extended       Enable extended instruction syntax.\n"
+"  -u, --undocumented   Enable undocumented instructions.\n"
+"  -t, --target=NAME    Select the target micro. z80 is the default.\n" 
+"  -e, --list-targets   List the targets supported.\n" 
+"\n"
+"Examples:\n"
+"  " PACKAGE " p.asm                     Assemble p.asm into p.obj\n"
+"  " PACKAGE " p.asm p.bin               Assemble p.asm into p.bin\n"
+"  " PACKAGE " -d\"MUL(a,b) (a*b)\" p.asm  Define the macro MUL and assemble p.asm\n"
+"\n"
+"Report bugs to: <" PACKAGE_BUGREPORT ">.\n"
+"Home page: <" PACKAGE_URL ">.\n";
+
+	printf(help, argv0);
+}
+
+/*
+ * Get the filename part of fname (that is, for ../../fname.abc, get
+ * fname.abc).
+ * Then substitute the extension .abd by .ext or append .ext.
+ */
+static char *mkfname(const char *fname, const char *ext)
+{
+	size_t alen, elen;
+	const char *p, *q;
+	char *s;
+
+	alen = strlen(fname);
+	elen = strlen(ext);
+
+	/* Find start of filename in path string */
+	p = fname + alen;
+	while (p > fname && *p != '/' && *p != '\\')
+		p--;
+
+	if (*p == '/' || *p == '\\')
+		p++;
+	
+	/* Find the extension */
+	q = fname + alen;
+	while (q > p && *q != '.')
+		q--;
+
+	if (*q != '.')
+		q = fname + alen;
+
+	s = emalloc((q - p) + 1 + elen + 1);
+	if (q > p)
+		memmove(s, p, (q - p));
+	s[q - p] = '\0';
+	strcat(s, ".");
+	strcat(s, ext);
+	return s;
+}
+
+static void parse_fill_byte(const char *optarg)
+{
+	int hi, lo;
+
+	if (strlen(optarg) != 2)
+		goto error;
+
+	if ((hi = hexval(optarg[0])) < 0)
+		goto error;
+	if ((lo = hexval(optarg[1])) < 0)
+		goto error;
+
+	s_mem_fillval = hi * 16 + lo;
+	return;
+
+error:	eprogname();
+	fprintf(stderr, _("invalid command line fill value (%s)\n"), optarg);
+	eprogname();
+	fprintf(stderr, " ");
+	fprintf(stderr, _("Please, use two hexadecimal digits.\n"));
+	exit(EXIT_FAILURE);
+}
+
+static void parse_target_id(const char *optarg)
+{
+	const struct target *p;
+
+	p = find_target(optarg);
+	if (p == NULL) {
+		eprogname();
+		fprintf(stderr, _("invalid target '%s'\n"), optarg);
+		exit(EXIT_FAILURE);
+	} else {
+		s_target_id = p->id;
+	}
+}
+
+static void list_targets(FILE *f)
+{	
+	const struct target *p;
+
+	for (p = first_target(); p != NULL; p = next_target()) {
+		fprintf(f, "%-14s%s\n", p->id, p->descr);
+	}
+}
+
+int main(int argc, char *argv[])
+{
+	int c;
+	struct ngetopt ngo;
+
+	static struct ngetopt_opt ops[] = {
+		{ "define", 1, 'd' },
+		{ "extended", 0, 'x' },
+		{ "list-targets", 0, 'e' },
+		{ "fill", 1, 'f' },
+		{ "help", 0, 'h' },
+		{ "license", 0, 'l' },
+		{ "quiet", 0, 'q' },
+		{ "target", 1, 't' },
+		{ "undocumented", 0, 'u' },
+		{ "version", 0, 'v' },
+		{ "print-table", 1, 0 },
+		{ "print-delta", 1, 0 },
+		{ "verbose", 0, 'V' },
+		{ NULL, 0, 0 },
+	};
+
+	ngetopt_init(&ngo, argc, argv, ops);
+	do {
+		c = ngetopt_next(&ngo);
+		switch (c) {
+		case 'V':
+			verbose++;
+			break;
+		case 'v':
+			print_version(stdout);
+			exit(EXIT_SUCCESS);
+		case 'h':
+			print_help(argv[0]);
+			exit(EXIT_SUCCESS);
+		case 'l':
+			print_copyright(stdout);
+			fputs("\n", stdout);
+			print_license(stdout);
+			exit(EXIT_SUCCESS);
+		case 't':
+			parse_target_id(ngo.optarg);
+			break;
+		case 'e':
+			list_targets(stdout);
+			exit(EXIT_SUCCESS);
+			break;
+		case 'd':
+			predefine(ngo.optarg);
+			break;
+		case 'f':
+			parse_fill_byte(ngo.optarg);
+			break;
+		case 'q':
+			s_listing = 0;
+			break;
+		case 'x':
+			s_extended_op = 1;
+			break;
+		case 'u':
+			s_undocumented_op = 1;
+			break;
+		case '?':
+			eprint(_("unrecognized option %s\n"),
+				ngo.optarg);
+			exit(EXIT_FAILURE);
+		case ':':
+			eprint(_("%s needs an argument\n"),
+				ngo.optarg);
+			exit(EXIT_FAILURE);
+		case ';':
+			eprint(_("%s does not allow for arguments\n"),
+				ngo.optarg);
+			exit(EXIT_FAILURE);
+		case 0:
+			if (strcmp(ngo.optstr, "print-table") == 0) {
+				print_table(stdout, ngo.optarg);
+				exit(EXIT_SUCCESS);
+			}
+		}
+	} while (c != -1);
+
+	if (argc == ngo.optind) {
+		eprint(_("wrong number of arguments\n"));
+		exit(EXIT_FAILURE);
+	}
+
+	s_asmfname = argv[ngo.optind];
+
+	if (argc - ngo.optind > 1)
+		s_objfname = argv[ngo.optind + 1];
+	else
+		s_objfname = mkfname(s_asmfname, "obj");
+
+	if (argc - ngo.optind > 2)
+		s_lstfname = argv[ngo.optind + 2];
+	else
+		s_lstfname = mkfname(s_asmfname, "lst");
+
+	uz80as();
+	return 0;
+}

2048/uz80as/mc6800.c

@@ -0,0 +1,338 @@
+/* ===========================================================================
+ * uz80as, an assembler for the Zilog Z80 and several other microprocessors.
+ *
+ * Motorola 6800, 6801.
+ * ===========================================================================
+ */
+
+#include "pp.h"
+#include "err.h"
+#include "options.h"
+#include "uz80as.h"
+#include <stddef.h>
+
+/* pat:
+ *	a: expr
+ * 	b: NEGA,COMA,LSRA,RORA,ASRA,
+ *	   ROLA,DECA,INCA,TSTA,CLRA
+ * 	c: NEGB,COMB,LSRB,RORB,ASRB,
+ *	   ROLB,DECB,INCB,TSTB,CLRB
+ * 	d: NEG,COM,LSR,ROR,ASR,
+ *	   ROL,DEC,INC,TST,JMP,CLR
+ *	e: SUBA,CMPA,SBCA,ANDA,BITA,LDAA,
+ * 	   EORA,ADCA,ORAA,ADDA
+ *	f: SUBB,CMPB,SBCB,ANDB,BITB,LDAB,
+ * 	   EORB,ADCB,ORAB,ADDB
+ * 	g: INX,DEX,CLV,SEV,CLC,SEC,CLI,SEI
+ *      h: BRA,BHI,BLS,BCC,BCS,BNE,BEQ,
+ *	   BVC,BVS,BPL,BMI,BGE,BLT,BGT,BLE
+ *	i: TSX,INS,PULA,PULB,DES,TXS,PSHA,
+ *	   PSHB,RTS,RTI,WAI,SWI
+ *
+ * gen:
+ * 	.: output lastbyte
+ * 	b: (op << 3) | lastbyte
+ * 	c: op | lastbyte
+ * 	d: lastbyte = op as 8 bit value
+ * 	e: output op as word (no '.' should follow)
+ * 	f: ouput op as big endian word (no '.' should follow)
+ * 	g: if op<=$ff output lastbyte and output op as byte
+ * 	   else output (lastbyte | 0x20) and output op as big endian word
+ * 	   (no '.' should follow)
+ * 	h: relative - 2
+ * 	i: relative - 4
+ * 	i: relative - 5
+ */
+
+static const struct matchtab s_matchtab_mc6800[] = {
+	{ "NOP", "01.", 1, 0 },
+	{ "TAP", "06.", 1, 0 },
+	{ "TPA", "07.", 1, 0 },
+	{ "g", "08c0.", 1, 0 },
+	{ "SBA", "10.", 1, 0 },
+	{ "CBA", "11.", 1, 0 },
+	{ "TAB", "16.", 1, 0 },
+	{ "TBA", "17.", 1, 0 },
+	{ "DAA", "19.", 1, 0 },
+	{ "ABA", "1B.", 1, 0 },
+	{ "i", "30c0.", 1, 0 }, 
+	{ "h a", "20c0.h1.", 1, 0, "r8" },
+	{ "b", "40c0.", 1, 0 },
+	{ "c", "50c0.", 1, 0 },
+	{ "d a,X", "60c0.d1.", 1, 0, "e8" },
+	{ "d a,Y", "18.60c0.d1.", 8, 0, "e8" },
+	{ "d a", "70c0.f1", 1, 0, "e16" },
+	{ "e #a", "80c0.d1.", 1, 0, "e8" },
+	{ "f #a", "C0c0.d1.", 1, 0, "e8" },
+	{ "e >a", "B0c0.f1", 1, 0, "e16" },
+	{ "f >a", "F0c0.f1", 1, 0, "e16" },
+	{ "e a,X", "A0c0.d1.", 1, 0, "e8" },
+	{ "f a,X", "E0c0.d1.", 1, 0, "e8" },
+	{ "e a,Y", "18.A0c0.d1.", 8, 0, "e8" },
+	{ "f a,Y", "18.E0c0.d1.", 8, 0, "e8" },
+	{ "e a", "90c0g1", 1, 0 },
+	{ "f a", "D0c0g1", 1, 0 },
+	{ "STAA >a", "B7.f0", 1, 0, "e16" },
+	{ "STAA a,X", "A7.d0.", 1, 0, "e8" },
+	{ "STAA a,Y", "18.A7.d0.", 8, 0, "e8" },
+	{ "STAA a", "97g0", 1, 0 },
+	{ "STAB >a", "F7.f0", 1, 0, "e16" },
+	{ "STAB a,X", "E7.d0.", 1, 0, "e8" },
+	{ "STAB a,Y", "18.E7.d0.", 8, 0, "e8" },
+	{ "STAB a", "D7g0", 1, 0 },
+	{ "CPX #a", "8C.f0", 1, 0, "e16" },
+	{ "CPX >a", "BC.f0", 1, 0, "e16" },
+	{ "CPX a,X", "AC.d0.", 1, 0, "e8" },
+	{ "CPX a,Y", "CD.AC.d0.", 8, 0, "e8" },
+	{ "CPX a", "9Cg0", 1, 0 },
+	{ "LDS #a", "8E.f0", 1, 0, "e16" },
+	{ "LDS >a", "BE.f0", 1, 0, "e16" },
+	{ "LDS a,X", "AE.d0.", 1, 0, "e8" },
+	{ "LDS a,Y", "18.AE.d0.", 8, 0, "e8" },
+	{ "LDS a", "9Eg0", 1, 0 },
+	{ "STS >a", "BF.f0", 1, 0, "e16" },
+	{ "STS a,X", "AF.d0.", 1, 0, "e8" },
+	{ "STS a,Y", "18.AF.d0.", 8, 0, "e8" },
+	{ "STS a", "9Fg0", 1, 0 },
+	{ "LDX #a", "CE.f0", 1, 0, "e16" },
+	{ "LDX >a", "FE.f0", 1, 0, "e16" },
+	{ "LDX a,X", "EE.d0.", 1, 0, "e8" },
+	{ "LDX a,Y", "CD.EE.d0.", 8, 0, "e8" },
+	{ "LDX a", "DEg0", 1, 0 },
+	{ "STX >a", "FF.f0", 1, 0, "e16" },
+	{ "STX a,X", "EF.d0.", 1, 0, "e8" },
+	{ "STX a,Y", "CD.EF.d0.", 8, 0, "e8" },
+	{ "STX a", "DFg0", 1, 0 },
+	{ "BSR a", "8D.h0.", 1, 0, "r8" },
+	{ "JSR >a", "BD.f0", 4, 0, "e16" },
+	{ "JSR a,X", "AD.d0.", 1, 0, "e8" },
+	{ "JSR a,Y", "18.AD.d0.", 8, 0, "e8" },
+	{ "JSR a", "BD.f0", 2, 0, "e16" },
+	{ "JSR a", "9Dg0", 4, 0 },
+	{ "ABX", "3A.", 4, 0 },
+	{ "ADDD #a", "C3.f0", 4, 0, "e16" },
+	{ "ADDD >a", "F3.f0", 4, 0, "e16" },
+	{ "ADDD a,X", "E3.d0.", 4, 0, "e8" },
+	{ "ADDD a,Y", "18.E3.d0.", 8, 0, "e8" },
+	{ "ADDD a", "D3g0", 4, 0 },
+	{ "ASLD", "05.", 4, 0 },
+	{ "LSLD", "05.", 4, 0 },
+	{ "BHS a", "24.h0.", 4, 0, "r8" },
+	{ "BLO a", "25.h0.", 4, 0, "r8" },
+	{ "BRN a", "21.h0.", 4, 0, "r8" },
+	{ "LDD #a", "CC.f0", 4, 0, "e16" },
+	{ "LDD >a", "FC.f0", 4, 0, "e16" },
+	{ "LDD a,X", "EC.d0.", 4, 0, "e8" },
+	{ "LDD a,Y", "18.EC.d0.", 8, 0, "e8" },
+	{ "LDD a", "DCg0", 4, 0 },
+	{ "LSL a,X", "68.d0.", 4, 0, "e8" },
+	{ "LSL a,Y", "18.68.d0.", 8, 0, "e8" },
+	{ "LSL a", "78.f0", 4, 0, "e16" },
+	{ "LSRD", "04.", 4, 0 },
+	{ "MUL", "3D.", 4, 0 },
+	{ "PSHX", "3C.", 4, 0 },
+	{ "PSHY", "18.3C.", 8, 0 },
+	{ "PULX", "38.", 4, 0 },
+	{ "PULY", "18.38.", 8, 0 },
+	{ "STD >a", "FD.f0", 4, 0, "e16" },
+	{ "STD a,X", "ED.d0.", 4, 0, "e8" },
+	{ "STD a,Y", "18.ED.d0.", 8, 0, "e8" },
+	{ "STD a", "DDg0", 4, 0 },
+	{ "SUBD #a", "83.f0", 4, 0, "e16" },
+	{ "SUBD >a", "B3.f0", 4, 0, "e16" },
+	{ "SUBD a,X", "A3.d0.", 4, 0, "e8" },
+	{ "SUBD a,Y", "18.A3.d0.", 8, 0, "e8" },
+	{ "SUBD a", "93g0", 4, 0 },
+	{ "TEST", "00.", 8, 0 },
+	{ "IDIV", "02.", 8, 0 },
+	{ "FDIV", "03.", 8, 0 },
+	{ "BRSET a,X,a,a", "1E.d0.d1.i2.", 8, 0, "e8e8r8" },
+	{ "BRSET a,Y,a,a", "18.1E.d0.d1.j2.", 8, 0, "e8e8r8" },
+	{ "BRSET a,a,a", "12.d0.d1.i2.", 8, 0, "e8e8r8" },
+	{ "BRCLR a,X,a,a", "1F.d0.d1.i2.", 8, 0, "e8e8r8" },
+	{ "BRCLR a,Y,a,a", "18.1F.d0.d1.j2.", 8, 0, "e8e8r8" },
+	{ "BRCLR a,a,a", "13.d0.d1.i2.", 8, 0, "e8e8r8" },
+	{ "BSET a,X,a", "1C.d0.d1.", 8, 0, "e8e8" }, 
+	{ "BSET a,Y,a", "18.1C.d0.d1.", 8, 0, "e8e8" }, 
+	{ "BSET a,a", "14.d0.d1.", 8, 0, "e8e8" },
+	{ "BCLR a,X,a", "1D.d0.d1.", 8, 0, "e8e8" }, 
+	{ "BCLR a,Y,a", "18.1D.d0.d1.", 8, 0, "e8e8" }, 
+	{ "BCLR a,a", "15.d0.d1.", 8, 0, "e8e8" },
+	{ "LSLA", "48.", 8, 0 },
+	{ "LSLB", "58.", 8, 0 },
+	{ "XGDX", "8F.", 8, 0 },
+	{ "STOP", "CF.", 8, 0 },
+	{ "ABY", "18.3A.", 8, 0 },
+	{ "CPY #a", "18.8C.f0", 8, 0, "e16" },
+	{ "CPY >a", "18.BC.f0", 8, 0, "e16" },
+	{ "CPY a,X", "1A.AC.d0.", 8, 0, "e8" },
+	{ "CPY a,Y", "18.AC.d0.", 8, 0, "e8" },
+	{ "CPY a", "18.9Cg0", 8, 0 },
+	{ "DEY", "18.09.", 8, 0 },
+	{ "INY", "18.08.", 8, 0 },
+	{ "LDY #a", "18.CE.f0", 8, 0, "e16" },
+	{ "LDY >a", "18.FE.f0", 8, 0, "e16" },
+	{ "LDY a,X", "1A.EE.d0.", 8, 0, "e8" },
+	{ "LDY a,Y", "18.EE.d0.", 8, 0, "e8" },
+	{ "LDY a", "18.DEg0", 8, 0 },
+	{ "STY >a", "18.FF.f0", 8, 0, "e16" },
+	{ "STY a,X", "1A.EF.d0.", 8, 0, "e8" },
+	{ "STY a,Y", "18.EF.d0.", 8, 0, "e8" },
+	{ "STY a", "18.DFg0", 8, 0 },
+	{ "TSY", "18.30.", 8, 0 },
+	{ "TYS", "18.35.", 8, 0 },
+	{ "XGDY", "18.8F.", 8, 0 },
+	{ "CPD #a", "1A.83.f0", 8, 0, "e16" },
+	{ "CPD >a", "1A.B3.f0", 8, 0, "e16" },
+	{ "CPD a,X", "1A.A3.d0.", 8, 0, "e8" },
+	{ "CPD a,Y", "CD.A3.d0.", 8, 0, "e8" },
+	{ "CPD a", "1A.93g0", 8, 0 },
+	{ NULL, NULL },
+};
+
+static const char *const bval[] = {
+"NEGA", "", "", "COMA", "LSRA", "", "RORA", "ASRA",
+"ASLA", "ROLA", "DECA", "", "INCA", "TSTA", "", "CLRA",
+NULL };
+
+static const char *const cval[] = {
+"NEGB", "", "", "COMB", "LSRB", "", "RORB", "ASRB",
+"ASLB", "ROLB", "DECB", "", "INCB", "TSTB", "", "CLRB",
+NULL };
+
+static const char *const dval[] = {
+"NEG", "", "", "COM", "LSR", "", "ROR", "ASR",
+"ASL", "ROL", "DEC", "", "INC", "TST", "JMP", "CLR",
+NULL };
+
+static const char *const eval[] = {
+"SUBA", "CMPA", "SBCA", "", "ANDA", "BITA", "LDAA", "",
+"EORA", "ADCA", "ORAA", "ADDA",
+NULL };
+
+static const char *const fval[] = {
+"SUBB", "CMPB", "SBCB", "", "ANDB", "BITB", "LDAB", "",
+"EORB", "ADCB", "ORAB", "ADDB",
+NULL };
+
+static const char *const gval[] = {
+"INX", "DEX", "CLV", "SEV", "CLC", "SEC", "CLI", "SEI",
+NULL };
+
+static const char *const hval[] = {
+"BRA", "", "BHI", "BLS", "BCC", "BCS", "BNE", "BEQ",
+"BVC", "BVS", "BPL", "BMI", "BGE", "BLT", "BGT", "BLE",
+NULL };
+
+static const char *const ival[] = {
+"TSX", "INS", "PULA", "PULB", "DES", "TXS", "PSHA",
+"PSHB", "", "RTS", "", "RTI", "", "", "WAI", "SWI",
+NULL };
+
+static const char *const *const valtab[] = { 
+	bval, cval, dval, eval, fval,
+       	gval, hval, ival
+};
+
+static int match_mc6800(char c, const char *p, const char **q)
+{
+	int v;
+
+	if (c <= 'i') {
+		v = mreg(p, valtab[(int) (c - 'b')], q);
+	} else {
+		v = -1;
+	}
+
+	return v;
+}
+
+static int gen_mc6800(int *eb, char p, const int *vs, int i, int savepc)
+{
+	int b;
+       
+	b = *eb;
+	switch (p) {
+	case 'f': genb(vs[i] >> 8, s_pline_ep);
+		  genb(vs[i], s_pline_ep);
+		  break;
+	case 'g': if (vs[i] <= 255) {
+			  genb(b, s_pline_ep);
+			  genb(vs[i], s_pline_ep);
+		  } else {
+			  genb(b | 0x20, s_pline_ep);
+			  genb(vs[i] >> 8, s_pline_ep);
+			  genb(vs[i], s_pline_ep);
+		  }
+		  break;
+	case 'h': b = (vs[i] - savepc - 2);
+		  break;
+	case 'i': b = (vs[i] - savepc - 4);
+		  break;
+	case 'j': b = (vs[i] - savepc - 5);
+		  break;
+	default:
+		  return -1;
+	}
+
+	*eb = b;
+	return 0;
+}
+
+static int s_pat_char = 'b';
+static int s_pat_index;
+
+static void pat_char_rewind_mc6800(int c)
+{
+	s_pat_char = c;
+	s_pat_index = 0;
+};
+
+static const char *pat_next_str_mc6800(void)
+{
+	const char *s;
+
+	if (s_pat_char >= 'b' && s_pat_char <= 'i') {
+		s = valtab[(int) (s_pat_char - 'b')][s_pat_index];
+		if (s != NULL) {
+			s_pat_index++;
+		}
+	} else {
+		s = NULL;
+	}
+
+	return s;
+};
+
+const struct target s_target_mc6800 = {
+	.id = "mc6800",
+	.descr = "Motorola 6800",
+	.matcht = s_matchtab_mc6800,
+	.matchf = match_mc6800,
+	.genf = gen_mc6800,
+	.pat_char_rewind = pat_char_rewind_mc6800,
+	.pat_next_str = pat_next_str_mc6800,
+	.mask = 3
+};
+
+const struct target s_target_mc6801 = {
+	.id = "mc6801",
+	.descr = "Motorola 6801",
+	.matcht = s_matchtab_mc6800,
+	.matchf = match_mc6800,
+	.genf = gen_mc6800,
+	.pat_char_rewind = pat_char_rewind_mc6800,
+	.pat_next_str = pat_next_str_mc6800,
+	.mask = 5
+};
+
+const struct target s_target_m68hc11 = {
+	.id = "m68hc11",
+	.descr = "Motorola 68HC11",
+	.matcht = s_matchtab_mc6800,
+	.matchf = match_mc6800,
+	.genf = gen_mc6800,
+	.pat_char_rewind = pat_char_rewind_mc6800,
+	.pat_next_str = pat_next_str_mc6800,
+	.mask = 13
+};

2048/uz80as/mos6502.c

@@ -0,0 +1,385 @@
+/* ===========================================================================
+ * uz80as, an assembler for the Zilog Z80 and several other microprocessors.
+ *
+ * MOS Technology 6502.
+ * Rockwell R6501.
+ * California Micro Devices G65SC02.
+ * Rockwell R65C02.
+ * Rockwell R65C29.
+ * Western Design Center W65C02S.
+ * ===========================================================================
+ */
+
+/* mos6502, the original
+ *
+ *     g65sc02 California Micro Devices, adds to mos6502:
+ *         - zp ADC,AND,CMP,EOR,LDA,ORA,SBC,STA
+ *         - DEC A, INC A
+ *         - JMP (abs,X)
+ *         - BRA
+ *         - PHX,PHY,PLX,PLY
+ *         - STZ
+ *         - TRB
+ *         - TSB
+ *         - More addressing modes for BIT, etc
+ *
+ *     r6501 Rockwell, adds to mos6502:
+ *         - BBR, BBS
+ *         - RMB, SMB
+ *
+ *     r65c02 Rockwell, adds the instructions of the g65sc02 and r6501
+ * 	
+ *     r65c29 Rockwell, adds to r65c02:
+ *        - MUL
+ *
+ *     w65c02s Western Design Center, adds to r65c02:
+ *        - STP,WAI
+ */
+
+#include "pp.h"
+#include "err.h"
+#include "options.h"
+#include "uz80as.h"
+#include <stddef.h>
+
+/* pat:
+ *	a: expr
+ *	b: ORA,AND,EOR,ADC,STA,LDA,CMP,SBC
+ *	c: ORA,AND,EOR,ADC,LDA,CMP,SBC
+ *	d: PHP,CLC,PLP,SEC,PHA,CLI,PLA,SEI,
+ *	   DEY,TYA,TAY,CLV,INY,CLD,INX,SED
+ *	e: ASL,ROL,LSR,ROR
+ *	f: DEC, INC
+ *	g: BPL,BMI,BVC,BVS,BCC,BCS,BNE,BEQ
+ *	h: TXA,TXS,TAX,TSX,DEX,NOP
+ *	i: CPY,CPX
+ *	j: TSB,TRB
+ *	k: BBR0,BBR1,BBR2,BBR3,BBR4,BBR5,BBR6,BBR6,
+ *	   BBS0,BBS1,BBS2,BBS3,BBS4,BBS5,BBS6,BBS7
+ *	l: RMB0,RMB1,RMB2,RMB3,RMB4,RMB5,EMB6,RMB7,
+ *	   SMB0,SMB1,SMB2,SMB3,SMB4,SMB5,SMB6,SMB7
+ *	m: PHY,PLY
+ *	n: PHX,PLX
+ *	o: INC, DEC
+ *
+ * gen:
+ * 	.: output lastbyte
+ * 	b: (op << 3) | lastbyte
+ * 	c: op | lastbyte
+ * 	d: lastbyte = op as 8 bit value
+ * 	e: output op as word (no '.' should follow)
+ * 	f: (op << 5) | lastbyte
+ * 	g: if op <= $FF output last byte and then op as 8 bit value;
+ * 	   else output (lastbyte | 0x08) and output op as word
+ * 	   (no '.' should follow)
+ * 	h: (op << 4) | lastbyte
+ * 	i: relative jump to op (-2)
+ * 	j: if op <= $FF output $64 and op as 8 bit
+ * 	   else output $9C and op as word
+ * 	   (no '.' should follow)
+ * 	k: if op <= $FF ouput $74 and op as 8 bit
+ * 	   else output $9E and op as word
+ * 	   (no '.' should follow)
+ * 	l: relative jump to op (-3)
+ */
+
+static const struct matchtab s_matchtab_mos6502[] = {
+	{ "BRK", "00.", 1, 0 },
+	{ "JSR a", "20.e0", 1, 0 },
+	{ "RTI", "40.", 1, 0 },
+	{ "RTS", "60.", 1, 0 },
+	{ "h", "8Ah0.", 1, 0 },
+	{ "d", "08h0.", 1, 0 },
+	{ "c #a", "09f0.d1.", 1, 0, "e8" },
+	{ "b (a,X)", "01f0.d1.", 1, 0, "e8" },
+	{ "b (a),Y", "11f0.d1.", 1, 0, "e8" },
+	{ "b (a)", "12f0.d1.", 2, 0, "e8" },
+	{ "b a", "05f0g1", 1, 0 },
+	{ "b a,X", "15f0g1", 1, 0 },
+	{ "b a,Y", "19f0.e1", 1, 0 },
+	{ "e A", "0Af0.", 1, 0 },
+	{ "e a", "06f0g1", 1, 0 },
+	{ "e a,X", "16f0g1", 1, 0 },
+	{ "STX a", "86g0", 1, 0 },
+	{ "STX a,Y", "96.d0.", 1, 0, "e8" },
+	{ "LDX #a", "A2.d0.", 1, 0, "e8" },
+	{ "LDX a", "A6g0", 1, 0 },
+	{ "LDX a,Y", "B6g0", 1, 0 },
+	{ "o A", "1Af0.", 2, 0 },
+	{ "f a", "C6f0g1", 1, 0 },
+	{ "f a,X", "D6f0g1", 1, 0 },
+	{ "g a", "10f0.i1.", 1, 0, "r8" },
+	{ "BIT #a", "89.d0.", 2, 0, "e8" },
+	{ "BIT a", "24g0", 1, 0 },
+	{ "BIT a,X", "34g0", 2, 0 },
+	{ "JMP (a)", "6C.e0", 1, 0 },
+	{ "JMP (a,X)", "7C.e0", 2, 0 },
+	{ "JMP a", "4C.e0", 1, 0 },
+	{ "STY a", "84g0", 1, 0 },
+	{ "STY a,X", "94.d0.", 1, 0, "e8" },
+	{ "LDY #a", "A0.d0.", 1, 0, "e8" },
+	{ "LDY a", "A4g0", 1, 0 },
+	{ "LDY a,X", "B4g0", 1, 0 },
+	{ "i #a", "C0f0.d1.", 1, 0, "e8" },
+	{ "i a", "C4f0g1", 1, 0 },
+	{ "j a", "04h0g1", 2, 0 },
+	{ "k a,a", "0Fh0.d1.l2.", 4, 0, "e8r8" },
+	{ "l a", "07h0.d1.", 4, 0, "e8" },
+	{ "m", "5Af0.", 2, 0 },
+	{ "n", "DAf0.", 2, 0 },
+	{ "BRA a", "80.i0.", 2, 0, "r8" },
+	{ "STZ a,X", "k1", 2, 0 },
+	{ "STZ a", "j1", 2, 0 },
+	{ "MUL", "02.", 8, 0 },
+	{ "WAI", "CB.", 16, 0 },
+	{ "STP", "DB.", 16, 0 },
+	{ NULL, NULL },
+};
+
+static const char *const bval[] = {
+	"ORA", "AND", "EOR", "ADC",
+	"STA", "LDA", "CMP", "SBC",
+       	NULL
+};
+
+static const char *const cval[] = {
+	"ORA", "AND", "EOR", "ADC",
+	"", "LDA", "CMP", "SBC", NULL
+};
+
+static const char *const dval[] = {
+       	"PHP", "CLC", "PLP", "SEC",
+	"PHA", "CLI", "PLA", "SEI",
+	"DEY", "TYA", "TAY", "CLV",
+	"INY", "CLD", "INX", "SED",
+	NULL
+};
+
+
+static const char *const eval[] = {
+	"ASL", "ROL", "LSR", "ROR",
+	NULL
+};
+
+static const char *const fval[] = {
+	"DEC", "INC",
+	NULL
+};
+
+static const char *const gval[] = {
+	"BPL", "BMI", "BVC", "BVS",
+	"BCC", "BCS", "BNE", "BEQ",
+	NULL
+};
+
+static const char *const hval[] = {
+	"TXA", "TXS", "TAX", "TSX",
+	"DEX", "", "NOP",
+	NULL
+};
+
+static const char *const ival[] = {
+	"CPY", "CPX",
+	NULL
+};
+
+static const char *const jval[] = {
+	"TSB", "TRB",
+	NULL
+};
+
+static const char *const kval[] = {
+	"BBR0", "BBR1", "BBR2", "BBR3",
+       	"BBR4", "BBR5", "BBR6", "BBR7",
+	"BBS0", "BBS1", "BBS2", "BBS3",
+       	"BBS4", "BBS5", "BBS6", "BBS7",
+	NULL
+};
+
+static const char *const lval[] = {
+	"RMB0", "RMB1", "RMB2", "RMB3",
+       	"RMB4", "RMB5", "RMB6", "RMB7",
+	"SMB0", "SMB1", "SMB2", "SMB3",
+       	"SMB4", "SMB5", "SMB6", "SMB7",
+	NULL
+};
+
+static const char *const mval[] = {
+	"PHY", "PLY",
+	NULL
+};
+
+static const char *const nval[] = {
+	"PHX", "PLX",
+	NULL
+};
+
+static const char *const oval[] = {
+	"INC", "DEC",
+	NULL
+};
+
+static const char *const *const valtab[] = { 
+	bval, cval, dval, eval, fval,
+	gval, hval, ival, jval, kval,
+	lval, mval, nval, oval
+};
+
+static int match_mos6502(char c, const char *p, const char **q)
+{
+	int v;
+
+	if (c <= 'o') {
+		v = mreg(p, valtab[(int) (c - 'b')], q);
+	} else {
+		v = -1;
+	}
+
+	return v;
+}
+
+static int gen_mos6502(int *eb, char p, const int *vs, int i, int savepc)
+{
+	int b, w;
+       
+	b = *eb;
+	switch (p) {
+	case 'f': b |= (vs[i] << 5); break;
+	case 'g': w = vs[i] & 0xffff;
+		  if (w <= 0xff) {
+			genb(b, s_pline_ep);
+			b = 0;
+			genb(w, s_pline_ep);
+		  } else {
+			b |= 0x08; 
+			genb(b, s_pline_ep);
+			b = 0;
+			genb(w, s_pline_ep);
+			genb(w >> 8, s_pline_ep);
+		  }
+		  break;
+	case 'h': b |= (vs[i] << 4); break;
+	case 'i': b = (vs[i] - savepc - 2); break;
+	case 'j': w = vs[i] & 0xffff;
+		  if (w <= 0xff) {
+			genb(0x64, s_pline_ep);
+			b = 0;
+			genb(w, s_pline_ep);
+		  } else {
+			genb(0x9C, s_pline_ep);
+			b = 0;
+			genb(w, s_pline_ep);
+			genb(w >> 8, s_pline_ep);
+		  }
+		  break;
+	case 'k': w = vs[i] & 0xffff;
+		  if (w <= 0xff) {
+			genb(0x74, s_pline_ep);
+			b = 0;
+			genb(w, s_pline_ep);
+		  } else {
+			genb(0x9E, s_pline_ep);
+			b = 0;
+			genb(w, s_pline_ep);
+			genb(w >> 8, s_pline_ep);
+		  }
+		  break;
+	case 'l': b = (vs[i] - savepc - 3); break;
+	default:
+		  return -1;
+	}
+
+	*eb = b;
+	return 0;
+}
+
+static int s_pat_char = 'b';
+static int s_pat_index;
+
+static void pat_char_rewind_mos6502(int c)
+{
+	s_pat_char = c;
+	s_pat_index = 0;
+};
+
+static const char *pat_next_str_mos6502(void)
+{
+	const char *s;
+
+	if (s_pat_char >= 'b' && s_pat_char <= 'o') {
+		s = valtab[(int) (s_pat_char - 'b')][s_pat_index];
+		if (s != NULL) {
+			s_pat_index++;
+		}
+	} else {
+		s = NULL;
+	}
+
+	return s;
+};
+
+const struct target s_target_mos6502 = {
+	.id = "mos6502",
+	.descr = "MOS Technology 6502",
+	.matcht = s_matchtab_mos6502,
+	.matchf = match_mos6502,
+	.genf = gen_mos6502,
+	.pat_char_rewind = pat_char_rewind_mos6502,
+	.pat_next_str = pat_next_str_mos6502,
+	.mask = 1
+};
+
+const struct target s_target_r6501 = {
+	.id = "r6501",
+	.descr = "Rockwell R6501",
+	.matcht = s_matchtab_mos6502,
+	.matchf = match_mos6502,
+	.genf = gen_mos6502,
+	.pat_char_rewind = pat_char_rewind_mos6502,
+	.pat_next_str = pat_next_str_mos6502,
+	.mask = 5
+};
+
+const struct target s_target_g65sc02 = {
+	.id = "g65sc02",
+	.descr = "California Micro Devices G65SC02",
+	.matcht = s_matchtab_mos6502,
+	.matchf = match_mos6502,
+	.genf = gen_mos6502,
+	.pat_char_rewind = pat_char_rewind_mos6502,
+	.pat_next_str = pat_next_str_mos6502,
+	.mask = 3
+};
+
+const struct target s_target_r65c02 = {
+	.id = "r65c02",
+	.descr = "Rockwell R65C02",
+	.matcht = s_matchtab_mos6502,
+	.matchf = match_mos6502,
+	.genf = gen_mos6502,
+	.pat_char_rewind = pat_char_rewind_mos6502,
+	.pat_next_str = pat_next_str_mos6502,
+	.mask = 7
+};
+
+const struct target s_target_r65c29 = {
+	.id = "r65c29",
+	.descr = "Rockwell R65C29, R65C00/21",
+	.matcht = s_matchtab_mos6502,
+	.matchf = match_mos6502,
+	.genf = gen_mos6502,
+	.pat_char_rewind = pat_char_rewind_mos6502,
+	.pat_next_str = pat_next_str_mos6502,
+	.mask = 15
+};
+
+const struct target s_target_w65c02s = {
+	.id = "w65c02s",
+	.descr = "Western Design Center W65C02S",
+	.matcht = s_matchtab_mos6502,
+	.matchf = match_mos6502,
+	.genf = gen_mos6502,
+	.pat_char_rewind = pat_char_rewind_mos6502,
+	.pat_next_str = pat_next_str_mos6502,
+	.mask = 027
+};

2048/uz80as/ngetopt.c

@@ -0,0 +1,237 @@
+/* ===========================================================================
+ * uz80as, an assembler for the Zilog Z80 and several other microprocessors.
+ *
+ * Handling of command line options, similar to getopt.
+ * ===========================================================================
+ */
+
+/*
+ * Changes:
+ *
+ * - Jul 22 2018: long options without short option character recognized.
+ *
+ */
+
+#include "ngetopt.h"
+
+#ifndef STRING_H
+#include <string.h>
+#endif
+
+static int find_short_opt(int val, struct ngetopt_opt *ops)
+{
+	int i;
+
+	i = 0;
+	while (ops[i].name != NULL) {
+		if (ops[i].val > 0 && ops[i].val == val)
+			return i;
+		i++;
+	}
+
+	return -1;
+}
+
+static int find_long_opt(char *str, struct ngetopt_opt *ops)
+{
+	int i;
+	const char *p, *q;
+
+	i = 0;
+	while (ops[i].name != NULL) {
+		p = ops[i].name;
+		q = str;
+		while (*p != '\0' && *p == *q) {
+			p++;
+			q++;
+		}
+		if (*p == '\0' && (*q == '\0' || *q == '=')) {
+			return i;
+		}
+		i++;
+	}
+
+	return -1;
+}
+
+void ngetopt_init(struct ngetopt *p, int argc, char *const *argv,
+	struct ngetopt_opt *ops)
+{
+	p->argc = argc;
+	p->argv = argv;
+	p->ops = ops;
+	p->optind = 1;
+	p->subind = 0;
+	strcpy(p->str, "-X");
+}
+
+static int get_short_opt(struct ngetopt *p)
+{
+	int i;
+	char *opt;
+
+	opt = p->argv[p->optind];
+	i = find_short_opt(opt[p->subind], p->ops);
+	if (i < 0) {
+		/* unrecognized option */
+		p->str[1] = (char) opt[p->subind];
+		p->optarg = p->str;
+		p->subind++;
+		return '?';
+	}
+
+	if (!p->ops[i].has_arg) {
+		/* it's ok */
+		p->subind++;
+		return p->ops[i].val;
+	}
+
+	/* needs an argument */
+	if (opt[p->subind + 1] != '\0') {
+		/* the argument is the suffix */
+		p->optarg = &opt[p->subind + 1];
+		p->subind = 0;
+		p->optind++;
+		return p->ops[i].val;
+	}
+
+	/* the argument is the next token */
+	p->optind++;
+	p->subind = 0;
+	if (p->optind < p->argc) {
+		p->optarg = p->argv[p->optind];
+		p->optind++;
+		return p->ops[i].val;
+	}
+
+	/* ups, argument missing */
+	p->str[1] = (char) p->ops[i].val;
+	p->optarg = p->str;
+	return ':';
+}
+
+static int get_opt(struct ngetopt *p)
+{
+	int i;
+	char *opt, *optnext;
+
+	/* all arguments consumed */
+	if (p->optind >= p->argc)
+		return -1;
+
+	opt = p->argv[p->optind];
+	if (opt[0] != '-') {
+		/* non option */
+		return -1;
+	}
+
+	/* - */
+	if (opt[1] == '\0') {
+		/* stdin */
+		return -1;
+	}
+
+	if (opt[1] != '-') {
+		/* -xxxxx */
+		p->subind = 1;
+		return get_short_opt(p);
+	}
+	
+	/* -- */
+	if (opt[2] == '\0') {
+		/* found "--" */
+		p->optind++;
+		return -1;
+	}
+
+	/* long option */
+	i = find_long_opt(&opt[2], p->ops);
+	if (i < 0) {
+		/* not found */
+		p->optind++;
+		p->optarg = opt;
+		while (*opt != '\0' && *opt != '=') {
+			opt++;
+		}
+		*opt = '\0';
+		return '?';
+	}
+
+	/* found, go to end of option */
+	optnext = opt + 2 + strlen(p->ops[i].name);
+
+	if (*optnext == '\0' && !p->ops[i].has_arg) {
+		/* doesn't need arguments */
+		p->optind++;
+		p->optstr = opt + 2;
+		return p->ops[i].val;
+	}
+
+	if (*optnext == '=' && !p->ops[i].has_arg) {
+		/* does not need arguments but argument supplied */
+		*optnext = '\0';
+		p->optarg = opt;
+		return ';';
+	}
+
+	/* the argument is the next token */
+	if (*optnext == '\0') {
+		p->optind++;
+		if (p->optind < p->argc) {
+			p->optstr = opt + 2;
+			p->optarg = p->argv[p->optind];
+			p->optind++;
+			return p->ops[i].val;
+		}
+
+		/* ups, argument missing */
+		p->optarg = opt;
+		p->optind++;
+		return ':';
+	}
+
+	/* *optnext == '=' */
+	*optnext = '\0';
+	p->optstr = opt + 2;
+	p->optarg = optnext + 1;
+	p->optind++;
+	return p->ops[i].val;
+}
+
+/*
+ * If ok:
+ *
+ * 	- For a long option with a zero value single character option, 0 is
+ * 	returned, optstr is the string of the long option (without '-' or '--')
+ * 	and optarg is the option argument or NULL.
+ *
+ * 	- For anything else the single option character is returned and optarg
+ * 	is the option argument or NULL.
+ *
+ * If the option is not recognized, '?' is returned, and optarg is the
+ * literal string of the option not recognized (already with '-' or '--'
+ * prefixed).
+ *
+ * If the option is recognized but the argument is missing, ':' is
+ * returned and optarg is the option as supplied (with '-' or '--' prefixed).
+ *
+ * If the option is recognized and it is a long option followed by '=', but the
+ * option does not take arguments, ';' is returned and optarg is the option
+ * (with '-' or '--' prefixed).
+ *
+ * -1 is returned if no more options.
+ */
+int ngetopt_next(struct ngetopt *p)
+{
+	if (p->subind == 0)
+		return get_opt(p);
+
+	/* p->subind > 0 */
+	if (p->argv[p->optind][p->subind] != '\0')
+		return get_short_opt(p);
+
+	/* no more options in this list of short options */
+	p->subind = 0;
+	p->optind++;
+	return get_opt(p);
+}

2048/uz80as/ngetopt.h

@@ -0,0 +1,40 @@
+/* ===========================================================================
+ * uz80as, an assembler for the Zilog Z80 and several other microprocessors.
+ *
+ * Handling of command line options, similar to getopt.
+ * ===========================================================================
+ */
+
+#ifndef NGETOPT_H
+#define NGETOPT_H
+
+/*
+ * Changelog:
+ *
+ * - Jul 21 2018: long options without short option character recognized.
+ *
+ */
+
+struct ngetopt_opt {
+	const char *name;
+	int has_arg;
+	int val;
+};
+
+struct ngetopt {
+	char *optstr;
+	char *optarg;
+	/* private */
+	int optind;
+	int argc;
+	char *const *argv;
+	struct ngetopt_opt *ops;
+	int subind;
+	char str[3];
+};
+
+void ngetopt_init(struct ngetopt *p, int argc, char *const *argv,
+	struct ngetopt_opt *ops);
+int ngetopt_next(struct ngetopt *p);
+
+#endif

2048/uz80as/options.c

@@ -0,0 +1,33 @@
+/* ===========================================================================
+ * uz80as, an assembler for the Zilog Z80 and several other microprocessors.
+ *
+ * Global options, normally coming from the command line.
+ * ===========================================================================
+ */
+
+#include "config.h"
+#include "options.h"
+#include "err.h"
+
+const char *s_asmfname;	/* Name of source file. */
+const char *s_objfname;	/* Name of generated binary file. */
+const char *s_lstfname;	/* Name of listing file. */
+const char *s_target_id = "z80"; /* ID of target */
+int s_listing = 1;	/* If we generate the listing file or not. */
+int s_extended_op = 0;	/* Allow extended instruction syntax. */
+int s_undocumented_op = 0;  /* Allow undocumented instructions. */
+int s_mem_fillval = 0;	/* Default value to fill the 64K memory. */
+
+/* Command line macro definitions. */
+struct predef *s_predefs;
+
+/* Predefine a macro in the command line that must persist between passes. */
+void predefine(const char *text)
+{
+	struct predef *pdef;
+
+	pdef = emalloc(sizeof(*pdef));
+	pdef->name = text;
+	pdef->next = s_predefs;
+	s_predefs = pdef;
+}

2048/uz80as/options.h

@@ -0,0 +1,29 @@
+/* ===========================================================================
+ * uz80as, an assembler for the Zilog Z80 and several other microprocessors.
+ *
+ * Global options, normally coming from the command line.
+ * ===========================================================================
+ */
+
+#ifndef OPTIONS_H
+#define OPTIONS_H
+
+/* Predefined macro at the command line. */
+struct predef {
+	struct predef *next;
+	const char *name;
+};
+
+extern const char *s_asmfname;
+extern const char *s_objfname;
+extern const char *s_lstfname;
+extern const char *s_target_id;
+extern int s_listing;
+extern int s_extended_op;
+extern int s_undocumented_op;
+extern int s_mem_fillval;
+extern struct predef *s_predefs;
+
+void predefine(const char *name);
+
+#endif

2048/uz80as/pp.c

@@ -0,0 +1,745 @@
+/* ===========================================================================
+ * uz80as, an assembler for the Zilog Z80 and several other microprocessors.
+ *
+ * Preprocessor.
+ * ===========================================================================
+ */
+
+#include "config.h"
+#include "pp.h"
+#include "utils.h"
+#include "err.h"
+#include "incl.h"
+#include "expr.h"
+#include "exprint.h"
+
+#ifndef CTYPE_H
+#include <ctype.h>
+#endif
+
+#ifndef STDIO_H
+#include <stdio.h>
+#endif
+
+#ifndef STDLIB_H
+#include <stdlib.h>
+#endif
+
+#ifndef STRING_H
+#include <string.h>
+#endif
+
+/* Max number of macros. */
+#define NMACROS		1000
+
+/* Closest prime to NMACROS / 4. */
+#define MACTABSZ	241
+
+/* Max number of macro arguments. */
+#define	NPARAMS		20
+
+#define DEFINESTR	"DEFINE"
+#define DEFCONTSTR	"DEFCONT"
+#define INCLUDESTR	"INCLUDE"
+#define IFSTR		"IF"
+#define IFDEFSTR	"IFDEF"
+#define IFNDEFSTR	"IFNDEF"
+#define ENDIFSTR	"ENDIF"
+#define ELSESTR		"ELSE"
+
+/*
+ * Macro.
+ *
+ * For example, the macro:
+ *
+ * #define SUM(a,b)	(a+b)
+ *
+ * is:
+ *
+ * name = SUM
+ * pars = a\0b\0
+ * ppars[0] points to &pars[0], that is to "a"
+ * ppars[1] points to &pars[2], that is to "b"
+ * npars = 2
+ * text is "(a+b)"
+ */
+struct macro {
+	struct macro *next;	/* Next in hash chain. */
+	char *name;		/* Identifier. */
+	char *pars;		/* String with params separated by '\0'. */
+	char *text;		/* Text to expand. */
+	char *ppars[NPARAMS];	/* Pointers to the beginning of each param. */
+	int npars;		/* Valid number of params in ppars. */
+};
+
+/* Hash table of preprocessor symbols. */
+static struct macro *s_mactab[MACTABSZ];
+
+/* Preprocessing line buffers. */
+static char s_ppbuf[2][LINESZ];
+
+/* If we are discarding lines; if not 0, level of if. */
+int s_skipon;
+
+/* Number of nested #if or #ifdef or #ifndef. */
+static int s_nifs;
+
+/* Last defined macro. */
+static struct macro *s_lastmac;
+
+/* Number of macros in table. */
+static int s_nmacs;
+
+/* The preprocessed line, points to one of s_ppbuf. */
+char *s_pline;
+
+/* Current program counter. */
+int s_pc;
+
+/* Current pass. */
+int s_pass;
+
+
+/* Only valid while in the call to pp_line(). */
+static const char *s_line; 	/* original line */
+static const char *s_line_ep;	/* pointer inside s_line for error reporting */
+
+/*
+ * Copy [p, q[ to [dp, dq[.
+ */
+static char *copypp(char *dp, char *dq, const char *p, const char *q)
+{
+	while (dp < dq && p < q)
+		*dp++ = *p++;
+	return dp;
+}
+
+/*
+ * Find the 'argnum' argument in 'args' and return a pointer to it.
+ *
+ * 'args' is a list of arguments "([id [,id]*).
+ * 'argnum' is the argument number to find.
+ *
+ * Return not found.
+ */
+static const char *findarg(const char *args, int argnum)
+{
+	if (*args == '(') {
+		do {
+			args++;
+			if (argnum == 0)
+				return args;
+			argnum--;
+			while (*args != '\0' && *args != ','
+				&& *args != ')')
+			{
+				args++;
+			}
+		} while (*args == ',');
+	}
+	return NULL;
+}
+
+/*
+ * Find the 'argnum' argument in 'args' and copy it to [dp, dq[.
+ *
+ * 'args' points to a list of arguments "([id [,id]*).
+ * 'argnum' is the argument number to copy.
+ *
+ * Return the new 'dp' after copying.
+ */
+static char *copyarg(char *dp, char *dq, const char *args, int argnum)
+{
+	const char *p;
+
+	p = findarg(args, argnum);
+	if (p == NULL)
+		return dp;
+
+	while (dp < dq && *p != '\0' && *p != ',' && *p != ')')
+		*dp++ = *p++;
+	return dp;
+}
+
+/*
+ * Sees if [idp, idq[ is a parameter of the macro 'pps'.
+ * If it is, return the number of parameter.
+ * Else return -1.
+ */
+static int findparam(const char *idp, const char *idq, struct macro *pps)
+{
+	int i;
+	const char *p, *r;
+
+	for (i = 0; i < pps->npars; i++) {
+		p = pps->ppars[i];
+		r = idp;
+		while (*p != '\0' && r < idq && *p == *r) {
+			p++;
+			r++;
+		}
+		if (*p == '\0' && r == idq)
+			return i;
+	}
+	return -1;
+}
+
+/*
+ * Lookup the string in [p, q[ in 's_mactab'.
+ * Return the symbol or NULL if it is not in the table.
+ */
+static struct macro *pplookup(const char *p, const char *q)
+{
+	int h;
+	struct macro *nod;
+
+	h = hash(p, q, MACTABSZ);
+	for (nod = s_mactab[h]; nod != NULL; nod = nod->next)
+		if (scmp(p, q, nod->name) == 0)
+			return nod;
+	
+	return nod;
+}
+
+/*
+ * Expand macro in [dp, dq[.
+ *
+ * 'pps' is the macro to expand.
+ * 'args' points to the start of the arguments to substitute, if any.
+ *
+ * Return new dp.
+ */
+static char *expandid(char *dp, char *dq, struct macro *pps, const char *args)
+{
+	const char *p, *q;
+	int validid, argnum;
+
+	validid = 1;
+	p = pps->text;
+	while (*p != '\0' && dp < dq) {
+		if (isidc0(*p)) {
+			for (q = p; isidc(*q); q++)
+				;
+			if (validid) {
+				argnum = findparam(p, q, pps);
+				if (argnum >= 0)
+					dp = copyarg(dp, dq, args, argnum);
+				else
+					dp = copypp(dp, dq, p, q);
+			} else {
+				dp = copypp(dp, dq, p, q);
+			}
+			p = q;
+			validid = 1;
+		} else {
+			validid = !isidc(*p);
+			*dp++ = *p++;
+		}
+	}
+	return dp;
+}
+
+/* 
+ * If 'p' points the the start of an argument list, that is, '(',
+ * point to one character past the first ')' after 'p'.
+ * Else return 'p'.
+ */
+static const char *skipargs(const char *p)
+{
+	if (*p == '(') {
+		while (*p != '\0' && *p != ')')
+			p++;
+		if (*p == ')')
+			p++;
+	}
+	return p;
+}
+
+/*
+ * Expand macros found in 'p' (null terminated) into [dp, dq[.
+ * dq must be writable to put a final '\0'.
+ */
+static int expand_line(char *dp, char *dq, const char *p)
+{
+	char *op;
+	int expanded, validid;
+	const char *s;
+	struct macro *nod;
+
+	validid = 1;
+	expanded = 0;
+	while (dp < dq && *p != '\0' && *p != ';') {
+		if (*p == '\'' && *(p + 1) != '\0' && *(p + 2) == '\'') {
+			/* characters */
+			dp = copypp(dp, dq, p, p + 3);
+			p += 3;
+			validid = 1;
+		} else if (*p == '\"') {
+			/* strings */
+			s = p;
+			p++;
+			/* skip over the string literal */
+			while (*p != '\0' && *p != '\"') {
+				if (p[0] == '\\' && p[1] == '\"')
+					p++;
+				p++;
+			}
+			if (*p == '\"')
+				p++;
+			dp = copypp(dp, dq, s, p);
+			validid = 1;
+		} else if (isidc0(*p)) {
+			s = p;
+			while (isidc(*p))
+				p++;
+			if (validid) {
+				nod = pplookup(s, p);
+				if (nod != NULL) {
+					op = dp;
+					dp = expandid(dp, dq, nod, p);
+					expanded = dp != op;
+					p = skipargs(p);
+				} else {
+					dp = copypp(dp, dq, s, p);
+				}
+			} else {
+				dp = copypp(dp, dq, s, p);
+			}
+			validid = 1;
+		} else {
+			validid = *p != '.' && !isalnum(*p);
+			*dp++ = *p++;
+		}
+	}
+	*dp = '\0';
+	return expanded;
+}
+
+/*
+ * Expand macros found in 'p' (null terminated).
+ * Return a pointer to an internal preprocessed line (null terminated).
+ */
+static char *expand_line0(const char *p)
+{
+	int iter, expanded;
+	char *np, *nq, *op;
+
+	iter = 0;
+	np = &s_ppbuf[iter & 1][0];
+	nq = &s_ppbuf[iter & 1][LINESZ - 1];
+	expanded = expand_line(np, nq, p);
+	/* TODO: recursive macro expansion limit */
+	while (expanded && iter < 5) {
+		op = np;
+		iter++;
+		np = &s_ppbuf[iter & 1][0];
+		nq = &s_ppbuf[iter & 1][LINESZ - 1];
+		expanded = expand_line(np, nq, op);
+	}
+	return np;
+}
+
+/*
+ * Check if 'p' starts with the preprocessor directive 'ucq', that must be in
+ * upper case.
+ * 'p' can have any case.
+ * After the preprocessor directive must be a space or '\0'.
+ * Return 1 if all the above is true. 0 otherwise.
+ */
+static int isppid(const char *p, const char *ucq)
+{
+	while (*p != '\0' && *ucq != '\0' && toupper(*p) == *ucq) {
+		p++;
+		ucq++;
+	}
+	return (*ucq == '\0') && (*p == '\0' || isspace(*p));
+}
+
+/*
+ * Define a macro.
+ *
+ * [idp, idq[ is the macro id.
+ * [ap, aq[ is the macro argument list. If ap == aq there are no arguments.
+ * [tp, tq[ is the macro text.
+ */ 
+static void define(const char *idp, const char *idq,
+		   const char *tp, const char *tq,
+		   const char *ap, const char *aq)
+{
+	int h;
+	char *p;
+	struct macro *nod;
+
+	h = hash(idp, idq, MACTABSZ);
+	for (nod = s_mactab[h]; nod != NULL; nod = nod->next) {
+		if (scmp(idp, idq, nod->name) == 0) {
+			/* Already defined. */
+			return;
+		}
+	}
+
+	s_nmacs++;
+	if (s_nmacs >= NMACROS) {
+		eprint(_("maximum number of macros exceeded (%d)\n"), NMACROS);
+		exit(EXIT_FAILURE);
+	}
+
+	nod = emalloc((sizeof *nod) + (idq - idp) + (aq - ap) + 2);
+	nod->text = emalloc(tq - tp + 1);
+	nod->name = (char *) ((unsigned char *) nod + (sizeof *nod));
+	nod->pars = nod->name + (idq - idp + 1);
+
+	copychars(nod->name, idp, idq);
+	copychars(nod->text, tp, tq);
+	copychars(nod->pars, ap, aq);
+
+	// printf("DEF %s(%s) %s\n", nod->name, nod->pars, nod->text);
+
+	/* We don't check whether the arguments are different. */
+
+	/*
+	 * Make ppars point to each argument and null terminate each one.
+	 * Count the number of arguments.
+	 */
+	nod->npars = 0;
+	p = nod->pars;
+	while (*p != '\0') {
+		nod->ppars[nod->npars++] = p;
+		while (*p != '\0' && *p != ',')
+			p++;
+		if (*p == ',')
+			*p++ = '\0';
+	}
+
+	nod->next = s_mactab[h];
+	s_mactab[h] = nod;
+	s_lastmac = nod;
+}
+
+/* Add the text [p, q[ to the last macro text.  */
+static void defcont(const char *p, const char *q)
+{
+	char *nt;
+	size_t len;
+
+	len = strlen(s_lastmac->text);
+	nt = erealloc(s_lastmac->text, (q - p) + len + 1);
+	copychars(nt + len, p, q);
+	s_lastmac->text = nt;
+}
+
+/* 
+ * If 'p' points to a valid identifier start, go to the end of the identifier.
+ * Else return 'p'.
+ */
+static const char *getid(const char *p)
+{
+	if (isidc0(*p)) {
+		while (isidc(*p))
+			p++;
+	}
+	return p;
+}
+
+/* Issues error in a macro definition. */
+static void macdeferr(int cmdline, const char *estr, const char *ep)
+{
+	if (cmdline) {
+		eprint(_("error in command line macro definition\n"));
+	}
+	eprint(estr);
+	eprcol(s_line, ep);
+	if (cmdline) {
+		exit(EXIT_FAILURE);
+	} else {
+		newerr();
+	}
+}
+
+/* Parse macro definition. */
+static void pmacdef(const char *p, int cmdline)
+{
+	const char *q, *ap, *aq, *idp, *idq;
+
+	idp = p;
+	idq = getid(idp);
+	if (idq == idp) {
+		macdeferr(cmdline, _("identifier excepted\n"), p);
+		return;
+	}
+	p = idq;
+	ap = aq = p;
+	if (*p == '(') {
+		p++;
+		ap = p;
+		while (isidc0(*p)) {
+			p = getid(p);
+			if (*p != ',')
+				break;
+			p++;
+		}
+		if (*p != ')') {
+			macdeferr(cmdline, _("')' expected\n"), p);
+			return;
+		}
+		aq = p;
+		p++;
+	}
+	if (*p != '\0' && !isspace(*p)) {
+		macdeferr(cmdline, _("space expected\n"), p);
+		return;
+	}
+	p = skipws(p);
+	/* go to the end */
+	for (q = p; *q != '\0'; q++)
+		;
+	/* go to the first non white from the end */
+	while (q > p && isspace(*(q - 1)))
+		q--;
+	define(idp, idq, p, q, ap, aq);
+}
+
+/* Parse #define. */
+static void pdefine(const char *p)
+{
+	p = skipws(p + sizeof(DEFINESTR) - 1);
+	pmacdef(p, 0);
+}
+
+/* Parse #defcont. */
+static void pdefcont(const char *p)
+{
+	const char *q;
+
+	p = skipws(p + sizeof(DEFCONTSTR) - 1);
+
+	/* go to the end */
+	for (q = p; *q != '\0'; q++)
+		;
+
+	/* go to the first non white from the end */
+	while (q > p && isspace(*(q - 1)))
+		q--;
+
+	if (p == q) {
+		/* nothing to add */
+		return;
+	}
+
+	if (s_lastmac == NULL) {
+		eprint(_("#DEFCONT without a previous #DEFINE\n"));
+		eprcol(s_line, s_line_ep);
+		newerr();
+		return;
+	}
+
+	defcont(p, q);
+}
+
+/* Parse #include. */
+static void pinclude(const char *p)
+{
+	const char *q;
+
+	p = skipws(p + sizeof(INCLUDESTR) - 1);
+	if (*p != '\"') {
+		eprint(_("#INCLUDE expects a filename between quotes\n"));
+		eprcol(s_line, p);
+		newerr();
+		return;
+	}
+	q = ++p;
+	while (*q != '\0' && *q != '\"')
+		q++;
+	if (*q != '\"') {
+		wprint(_("no terminating quote\n"));
+		eprcol(s_line, q);
+	}
+	pushfile(p, q);
+}
+
+/*
+ * Parse #ifdef or #ifndef.
+ * 'idsz' is the length of the string 'ifdef' or 'ifndef', plus '\0'.
+ * 'ifdef' must be 1 if we are #ifdef, 0 if #ifndef.
+ */
+static void pifdef(const char *p, size_t idsz, int ifdef)
+{
+	const char *q;
+	struct macro *nod;
+
+	s_nifs++;
+	if (s_skipon)
+		return;
+
+	p = skipws(p + idsz - 1);
+	if (!isidc0(*p)) {
+		s_skipon = s_nifs;
+		eprint(_("identifier expected\n"));
+		eprcol(s_line, p);
+		newerr();
+		return;
+	}
+	q = p;
+	while (isidc(*q))
+		q++;
+	nod = pplookup(p, q);
+	if (ifdef == (nod != NULL))
+		s_skipon = 0;
+	else
+		s_skipon = s_nifs;
+}
+
+/* Parse #else. */
+static void pelse(const char *p)
+{
+	if (s_nifs == 0) {
+		eprint(_("unbalanced #ELSE\n"));
+		eprcol(s_line, s_line_ep);
+		newerr();
+		return;
+	}
+
+	if (s_skipon && s_nifs == s_skipon)
+		s_skipon = 0;
+	else if (!s_skipon)
+		s_skipon = s_nifs;
+}
+
+/* Parse #endif. */
+static void pendif(const char *p)
+{
+	if (s_nifs == 0) {
+		eprint(_("unbalanced #ENDIF\n"));
+		eprcol(s_line, s_line_ep);
+		newerr();
+		return;
+	}
+
+	if (s_skipon && s_nifs == s_skipon)
+		s_skipon = 0;
+	s_nifs--;
+}
+
+/*
+ * Parse #if.
+ */
+static void pif(const char *p)
+{
+	int v;
+	enum expr_ecode ex_ec;
+	const char *ep;
+
+	s_nifs++;
+	if (s_skipon)
+		return;
+
+	p = skipws(p + sizeof(IFSTR) - 1);
+	if (!expr(p, &v, s_pc, 1, &ex_ec, &ep)) {
+		s_skipon = 1;
+		exprint(ex_ec, s_line, ep);
+		newerr();
+		return;
+	}
+
+	if (v == 0)
+		s_skipon = s_nifs;
+	else
+		s_skipon = 0;
+}
+
+/*
+ * Parse a preprocessor line.
+ * 'p' points to the next character after the '#'.
+ */
+static int 
+parse_line(const char *p)
+{
+	if (isppid(p, IFDEFSTR)) {
+		pifdef(p, sizeof IFDEFSTR, 1);
+	} else if (isppid(p, IFNDEFSTR)) {
+		pifdef(p, sizeof IFNDEFSTR, 0);
+	} else if (isppid(p, IFSTR)) {
+		pif(p);
+	} else if (isppid(p, ELSESTR)) {
+		pelse(p);
+	} else if (isppid(p, ENDIFSTR)) {
+		pendif(p);
+	} else if (s_skipon) {
+		;
+	} else if (isppid(p, INCLUDESTR)) {
+		pinclude(p);
+	} else if (isppid(p, DEFINESTR)) {
+		pdefine(p);
+	} else if (isppid(p, DEFCONTSTR)) {
+		pdefcont(p);
+	} else {
+		return 0;
+/*
+		eprint(_("unknown preprocessor directive\n"));
+		eprcol(s_line, s_line_ep);
+		newerr();
+*/
+	}
+	return 1;
+}
+
+/*
+ * Preprocess 'line' in 's_pline'.
+ * In this module, while we are preprocessing:
+ * 	s_line is the original line.
+ * 	s_line_ep is a pointer inside line that we keep for error reporting.
+ */
+void pp_line(const char *line)
+{
+	const char *p;
+
+	s_line = line;
+	s_line_ep = line;
+
+	p = skipws(line);
+	if ((*p == '#') || (*p == '.')) {
+		s_line_ep = p;
+		if (parse_line(p + 1)) {
+			s_ppbuf[0][0] = '\0';
+			s_pline = &s_ppbuf[0][0];
+			return;
+		}
+	}
+	if (s_skipon) {
+		s_ppbuf[0][0] = '\0';
+		s_pline = &s_ppbuf[0][0];
+		return;
+	}
+	s_pline = expand_line0(line);
+}
+
+/* Reset the module for other passes. */
+void pp_reset(void)
+{
+	int i;
+	struct macro *nod, *cur;
+
+	s_nmacs = 0;
+	s_nifs = 0;
+	s_skipon = 0;
+	s_lastmac = NULL;
+	for (i = 0; i < MACTABSZ; i++) {
+		nod = s_mactab[i];
+		while (nod != NULL) {
+			cur = nod;
+			nod = nod->next;
+			free(cur->text);
+			free(cur);
+		}
+	}
+	memset(s_mactab, 0, MACTABSZ * sizeof(s_mactab[0]));
+}
+
+void pp_define(const char *mactext)
+{
+	s_line = mactext;
+	s_line_ep = mactext;
+	pmacdef(mactext, 1);
+	s_lastmac = NULL;
+}

2048/uz80as/pp.h

@@ -0,0 +1,23 @@
+/* ===========================================================================
+ * uz80as, an assembler for the Zilog Z80 and several other microprocessors.
+ *
+ * Preprocessor.
+ * ===========================================================================
+ */
+
+#ifndef PP_H
+#define PP_H
+
+/* Max line length after macro expansion + '\0'. */
+#define LINESZ		512
+
+extern char *s_pline;
+extern int s_pc;
+extern int s_pass;
+extern int s_skipon;
+
+void pp_line(const char *line);
+void pp_reset(void);
+void pp_define(const char *name);
+
+#endif

2048/uz80as/prtable.c

@@ -0,0 +1,343 @@
+#include "prtable.h"
+#include "err.h"
+#include "targets.h"
+#include "uz80as.h"
+
+#ifndef STDLIB_H
+#include <stdlib.h>
+#endif
+
+#ifndef CTYPE_H
+#include <ctype.h>
+#endif
+
+#ifndef STRING_H
+#include <string.h>
+#endif
+
+enum { STRSZ = 32 };
+
+struct itext {
+	struct itext *next;
+	int undoc;
+	char str[STRSZ];
+};
+
+struct ilist {
+	struct itext *head;
+	int nelems;
+};
+
+struct itable {
+	struct itext **table;
+	int nelems;
+};
+
+static char s_buf[STRSZ];
+
+static void nomem(const char *str)
+{
+	eprogname();
+	fprintf(stderr, _("not enough memory (%s)\n"), str);
+	exit(EXIT_FAILURE);
+}
+
+static int compare(const void *pa, const void *pb)
+{
+	const struct itext * const *ia;
+	const struct itext * const *ib;
+
+	ia = (const struct itext * const *) pa;
+	ib = (const struct itext * const *) pb;
+	return strcmp((*ia)->str, (*ib)->str);
+}
+
+/* 
+ * Returns a new allocated itable of pointers that point to each element in the
+ * list ilist, alphabetically sorted.
+ */
+static struct itable *sort_list(struct ilist *ilist)
+{
+	int n;
+	struct itable *itable;
+	struct itext *p;
+
+	if ((itable = calloc(1, sizeof(*itable))) == NULL) {
+		return NULL;
+	}
+	itable->nelems = 0;
+
+	if (ilist->nelems == 0) {
+		return itable;
+	}
+
+	itable->table = malloc(ilist->nelems * sizeof(*itable->table));
+	if (itable->table == NULL) {
+		free(itable);
+		return NULL;
+	}
+
+	for (n = 0, p = ilist->head;
+	     p != NULL && n < ilist->nelems;
+	     p = p->next, n++)
+       	{
+		itable->table[n] = p;
+	}
+	itable->nelems = n;
+
+	qsort(itable->table, itable->nelems, sizeof(*itable->table), compare);
+	return itable;
+}
+
+static void print_itable(struct itable *itable, FILE *f)
+{
+	int i, col;
+	struct itext *p;
+
+	if (itable == NULL) {
+		return;
+	}
+
+	fputs("@multitable @columnfractions .25 .25 .25 .25\n", f);
+	col = 0;
+	for (i = 0; i < itable->nelems; i++) {
+		p = itable->table[i];
+		if (col == 0) {
+			fputs("@item ", f);
+		} else {
+			fputs("@tab ", f);
+		}
+		if (p->undoc) {
+			fputs("* ", f);
+		}
+		fprintf(f, "%s\n", p->str);
+		col++;
+		if (col >= 4) {
+			col = 0;
+		}
+	}
+	fputs("@end multitable\n", f);
+}
+
+#if 0
+static void print_ilist(struct ilist *ilist, FILE *f)
+{
+	int col;
+	struct itext *p;
+
+	if (ilist == NULL) {
+		return;
+	}
+
+	fputs("@multitable @columnfractions .25 .25 .25 .25\n", f);
+	col = 0;
+	for (p = ilist->head; p != NULL; p = p->next) {
+		if (col == 0) {
+			fputs("@item ", f);
+		} else {
+			fputs("@tab ", f);
+		}
+		if (p->undoc) {
+			fputs("* ", f);
+		}
+		fprintf(f, "%s\n", p->str);
+		col++;
+		if (col >= 4) {
+			col = 0;
+		}
+	}
+	fputs("@end multitable\n", f);
+}
+#endif
+
+static void bufset(int i, char c)
+{
+	if (i >= STRSZ) {
+		eprogname();
+		fputs(_("prtable: please, increase s_buf size\n"), stderr);
+		exit(EXIT_FAILURE);
+	} else {
+		s_buf[i] = c;
+	}
+}
+
+static void gen_inst2(struct ilist *ilist, char *instr, int undoc)
+{
+	struct itext *p;
+
+	if ((p = malloc(sizeof(*p))) == NULL) {
+		nomem("gen_inst2");
+	}
+
+	snprintf(p->str, STRSZ, "%s", instr);
+	p->undoc = undoc;
+	p->next = ilist->head;
+	ilist->head = p;
+	ilist->nelems++;
+}
+
+static void gen_inst(struct ilist *ilist, const struct target *t,
+		     unsigned char undoc, const char *p, size_t bufi,
+		     const char *pr)
+{
+	size_t bufk;
+	const char *s;
+
+	while (*p) {
+		if (!islower(*p)) {
+			if (*p == '@') {
+				bufset(bufi++, '@');
+			}
+			bufset(bufi++, *p);
+			p++;
+		} else if (*p == 'a') {
+			if (pr == NULL) {
+				bufset(bufi++, 'e');
+			} else if (pr[0] && pr[1]) {
+				if (pr[0] == pr[1]) {
+					bufset(bufi++, pr[0]);
+					pr += 2;
+				} else if (isdigit(pr[1])) {
+					bufset(bufi++, *pr);
+					pr++;
+					while (isdigit(*pr)) {
+						bufset(bufi++, *pr);
+						pr++;
+					}
+				} else {
+					bufset(bufi++, pr[0]);
+					bufset(bufi++, pr[1]);
+					pr += 2;
+				}
+			} else {
+				bufset(bufi++, 'e');
+			}
+			p++;
+		} else {
+			break;
+		}
+	}
+
+	if (*p == '\0') {
+		bufset(bufi, '\0');
+		gen_inst2(ilist, s_buf, t->mask & undoc);
+	} else {
+		t->pat_char_rewind(*p);
+		while ((s = t->pat_next_str()) != NULL) {
+			if (s[0] != '\0') {
+				bufset(bufi, '\0');
+				bufk = bufi;
+				while (*s != '\0') {
+					bufset(bufk++, *s);
+					s++;
+				}
+				bufset(bufk, '\0');
+				gen_inst(ilist, t, undoc, p + 1, bufk, pr);
+			}
+		}
+	}
+}
+
+/* Generate a list of instructions. */
+static struct ilist *gen_list(const struct target *t, unsigned char mask2,
+                              int delta)
+{
+	int i, pr;
+	const struct matchtab *mt;
+	struct ilist *ilist;
+
+	if ((ilist = calloc(1, sizeof(*ilist))) == NULL) {
+		return NULL;
+	}
+
+	i = 0;
+	mt = t->matcht;
+	while (mt[i].pat != NULL) {
+		pr = 0;
+		if (t->mask == 1 && (mt[i].mask & 1)) {
+			pr = 1;
+		} else if (delta) {
+			if ((mt[i].mask & t->mask) &&
+				!(mt[i].mask & mask2))
+			{
+				pr = 1;
+			}
+		} else if (t->mask & mt[i].mask) {
+			pr = 1;
+		}
+		if (pr) { 
+			gen_inst(ilist, t, mt[i].undoc, mt[i].pat,
+				 0, mt[i].pr);
+		}
+		i++;
+	}
+
+	return ilist;
+}
+
+/* 
+ * Prints the instruction set of a target or if target_id is "target2,target1"
+ * prints the instructions in target2 not in target1.
+ */
+void print_table(FILE *f, const char *target_id)
+{
+	struct ilist *ilist;
+	struct itable *itable;
+	const struct target *t, *t2;
+	char target1[STRSZ];
+	const char *target2;
+	unsigned char mask2;
+	int delta;
+
+	/* check if we have "target" or "target,target" as arguments */
+	if ((target2 = strchr(target_id, ',')) != NULL) {
+		delta = 1;
+		snprintf(target1, sizeof(target1), "%s", target_id);
+		target1[target2 - target_id] = '\0';
+		target2++;
+	} else {
+		delta = 0;
+		snprintf(target1, sizeof(target1), "%s", target_id);
+		target2 = NULL;
+	}
+
+	t = find_target(target1);
+	if (t == NULL) {
+		eprogname();
+		fprintf(stderr, _("invalid target '%s'\n"), target1);
+		exit(EXIT_FAILURE);
+	}
+
+	if (target2) {
+		t2 = find_target(target2);
+		if (t2 == NULL) {
+			eprogname();
+			fprintf(stderr, _("invalid target '%s'\n"), target2);
+			exit(EXIT_FAILURE);
+		}
+		if (t->matcht != t2->matcht) {
+			eprogname();
+			fprintf(stderr, _("unrelated targets %s,%s\n"),
+				target1, target2);
+			exit(EXIT_FAILURE);
+		}
+		mask2 = t2->mask;
+	} else {
+		mask2 = 1;
+	}
+
+	if ((ilist = gen_list(t, mask2, delta)) == NULL) {
+		nomem("gen_list");
+	}
+
+	if ((itable = sort_list(ilist)) == NULL) {
+		nomem("sort_list");
+	}
+
+	print_itable(itable, f);
+
+	/* We don't free ilist nor itable for now, since this is called
+	 * from main and then the program terminated.
+	 */
+}
+

2048/uz80as/prtable.h

@@ -0,0 +1,11 @@
+#ifndef PRTABLE_H
+#define PRTABLE_H
+
+#ifndef STDIO_H
+#define STDIO_H
+#include <stdio.h>
+#endif
+
+void print_table(FILE *f, const char *target_id);
+
+#endif

2048/uz80as/sym.c

@@ -0,0 +1,103 @@
+/* ===========================================================================
+ * uz80as, an assembler for the Zilog Z80 and several other microprocessors.
+ *
+ * Symbol table for labels.
+ * ===========================================================================
+ */
+
+#include "config.h"
+#include "sym.h"
+#include "utils.h"
+#include "err.h"
+
+#ifndef STDIO_H
+#include <stdio.h>
+#endif
+
+#ifndef STDLIB_H
+#include <stdlib.h>
+#endif
+
+/*
+ * Maximum number of symbols (labels) allowed.
+ * Must not be more than 64K.
+ */
+#define NSYMS		15000
+
+/* Closest prime to NSYMS / 4. */
+#define SYMTABSZ	3739
+
+/*
+ * Nodes for the s_symtab hash table.
+ * The symbol at index 0 is never used.
+ */
+static struct sym s_symlist[NSYMS];
+
+/*
+ * Hash table of indexes into s_symlist.
+ * 0 means that the bucket is empty.
+ */
+static unsigned short s_symtab[SYMTABSZ];
+
+/* Next free symbol in s_symlist. Note: 0 not used. */
+static int s_nsyms = 1;
+
+/*
+ * Lookups the string in [p, q[ in s_symtab.
+ * If !insert, returns the symbol or NULL if it is not in the table.
+ * If insert, inserts the symbol in the table if it is not there, and
+ * sets its .val to 'pc'.
+ */
+struct sym *lookup(const char *p, const char *q, int insert, int pc)
+{
+	int h, k;
+	struct sym *nod;
+
+	if (q - p > SYMLEN - 1) {
+		/* Label too long, don't add. */
+		eprint(_("label too long"));
+		epchars(p, q);
+		enl();
+		newerr();
+		/*
+		 * This would truncate:
+		 * q = p + (SYMLEN - 1);
+		 */
+		return NULL;
+	}
+
+	h = hash(p, q, SYMTABSZ);
+	for (k = s_symtab[h]; k != 0; k = s_symlist[k].next) {
+		if (scmp(p, q, s_symlist[k].name) == 0) {
+			if (insert) {
+				if (!s_symlist[k].isequ) {
+					wprint("duplicate label (%s)\n",
+						s_symlist[k].name);
+				}
+			}
+			return &s_symlist[k];
+		}
+	}
+
+	if (insert) {
+		if (s_nsyms == NSYMS) {
+			eprint(_("maximum number of labels exceeded (%d)\n"),
+				NSYMS);
+			exit(EXIT_FAILURE);
+		}
+
+		nod = &s_symlist[s_nsyms];
+		nod->next = s_symtab[h];
+		s_symtab[h] = (unsigned short) s_nsyms;
+		s_nsyms++;
+
+		k = 0;
+		while (p != q && k < SYMLEN - 1)
+			nod->name[k++] = *p++;
+		nod->name[k] = '\0';
+		nod->val = pc;
+		return nod;
+	}
+
+	return NULL;
+}

2048/uz80as/sym.h

@@ -0,0 +1,23 @@
+/* ===========================================================================
+ * uz80as, an assembler for the Zilog Z80 and several other microprocessors.
+ *
+ * Symbol table for labels.
+ * ===========================================================================
+ */
+
+#ifndef SYM_H
+#define SYM_H
+
+/* Max symbol length + '\0'. */
+#define SYMLEN		32
+
+struct sym {
+	char name[SYMLEN];		/* null terminated string */
+	int val;			/* value of symbol */
+	unsigned short next;		/* index into symlist; 0 is no next */
+	unsigned char isequ;		/* if val comes from EQU */
+};
+
+struct sym *lookup(const char *p, const char *q, int insert, int pc);
+
+#endif

2048/uz80as/targets.c

@@ -0,0 +1,96 @@
+/* ===========================================================================
+ * uz80as, an assembler for the Zilog Z80 and several other microprocessors.
+ *
+ * Target list.
+ * ===========================================================================
+ */
+
+#include "targets.h"
+#include "uz80as.h"
+
+#ifndef STRING_H
+#include <string.h>
+#endif
+
+extern const struct target s_target_z80;
+extern const struct target s_target_hd64180;
+extern const struct target s_target_gbcpu;
+extern const struct target s_target_dp2200;
+extern const struct target s_target_dp2200ii;
+extern const struct target s_target_i4004;
+extern const struct target s_target_i4040;
+extern const struct target s_target_i8008;
+extern const struct target s_target_i8021;
+extern const struct target s_target_i8022;
+extern const struct target s_target_i8041;
+extern const struct target s_target_i8048;
+extern const struct target s_target_i8051;
+extern const struct target s_target_i8080;
+extern const struct target s_target_i8085;
+extern const struct target s_target_mos6502;
+extern const struct target s_target_r6501;
+extern const struct target s_target_g65sc02;
+extern const struct target s_target_r65c02;
+extern const struct target s_target_r65c29;
+extern const struct target s_target_w65c02s;
+extern const struct target s_target_mc6800;
+extern const struct target s_target_mc6801;
+extern const struct target s_target_m68hc11;
+
+static const struct target *s_targets[] = {
+	&s_target_z80,
+	&s_target_hd64180,
+	&s_target_gbcpu,
+	&s_target_dp2200,
+	&s_target_dp2200ii,
+	&s_target_i4004,
+	&s_target_i4040,
+	&s_target_i8008,
+	&s_target_i8021,
+	&s_target_i8022,
+	&s_target_i8041,
+	&s_target_i8048,
+	&s_target_i8051,
+	&s_target_i8080,
+	&s_target_i8085,
+	&s_target_mos6502,
+	&s_target_r6501,
+	&s_target_g65sc02,
+	&s_target_r65c02,
+	&s_target_r65c29,
+	&s_target_w65c02s,
+	&s_target_mc6800,
+	&s_target_mc6801,
+	&s_target_m68hc11,
+	NULL,
+};
+
+static int s_index;
+
+const struct target *find_target(const char *id)
+{
+	const struct target **p;
+
+	for (p = s_targets; *p != NULL; p++) {
+		if (strcmp(id, (*p)->id) == 0) {
+			return *p;
+		}
+	}
+
+	return NULL;
+}
+
+const struct target *first_target(void)
+{
+	s_index = 0;
+	return next_target();
+}
+
+const struct target *next_target(void)
+{
+	if (s_targets[s_index] != NULL) {
+		return s_targets[s_index++];
+	} else {
+		return NULL;
+	}
+}

2048/uz80as/targets.h

@@ -0,0 +1,18 @@
+/* ===========================================================================
+ * uz80as, an assembler for the Zilog Z80 and several other microprocessors.
+ *
+ * Target list.
+ * ===========================================================================
+ */
+
+#ifndef TARGETS_H
+#define TARGETS_H
+
+struct target;
+
+const struct target *find_target(const char *id);
+
+const struct target *first_target(void);
+const struct target *next_target(void);
+
+#endif

2048/uz80as/test.asm

@@ -0,0 +1,8 @@
+	.org 0x100
+beep: .text 	"\"\"\"" ; comment
+	.align 4
+	.text "foo"
+	.align 16
+	.text "bar"
+	.db	$45,0x67,'7'
+	.end

2048/uz80as/test1.asm

@@ -0,0 +1,3 @@
+	.org $100
+beep: .text 	"x" ; comment
+	.end

2048/uz80as/utils.c

@@ -0,0 +1,137 @@
+/* ===========================================================================
+ * uz80as, an assembler for the Zilog Z80 and several other microprocessors.
+ *
+ * Generic functions.
+ * ===========================================================================
+ */
+
+#include "config.h"
+#include "utils.h"
+
+#ifndef CTYPE_H
+#include <ctype.h>
+#endif
+
+#ifndef LIMITS_H
+#include <limits.h>
+#endif
+
+/*
+ * Copy [p, q[ to dst and null terminate dst.
+ */
+void copychars(char *dst, const char *p, const char *q)
+{
+//	int i = 0;
+//	printf("copychars %x->%x to %x \'", p, q, dst);
+	while (p != q) {
+//		printf("%c", *p);
+		*dst++ = *p++;
+//		i++;
+	}
+	*dst = '\0';
+//	printf("\' %d %x %d\n", *dst, dst, i);
+}
+
+/* Skip space. */
+const char *skipws(const char *p)
+{
+	while (isspace(*p))
+		p++;
+	return p;
+}
+
+/* Return 1 if *p is a valid start character for an identifier. */
+int isidc0(char c)
+{
+	return (c == '_') || isalpha(c);
+}
+
+/* 
+ * Return 1 if *p is a valid character for an identifier.
+ * Don't use for the first character.
+ */
+int isidc(char c)
+{
+	return (c == '_') || (c == '.') || isalnum(c);
+}
+
+/* Hash the string in [p, q[ to give a bucket in symtab. */
+int hash(const char *p, const char *q, unsigned int tabsz)
+{
+	unsigned int h;
+
+	h = 0;
+	while (p != q) {
+		h = 31 * h + (unsigned char) *p;
+		p++;
+	}
+
+	return h % tabsz;
+}
+
+/* 
+ * Compare the string in [p, q[ with the null-terminated string s.
+ * Return 0 if equal.
+ */
+int scmp(const char *p, const char *q, const char *s)
+{
+	while (p < q) {
+		if (*p == *s) {
+			p++;
+			s++;
+		} else if (*s == '\0') {
+			return 1;
+		} else if (*p < *s) {
+			return -1;
+		} else {
+			return 1;
+		}
+	}
+
+	if (*s == '\0')
+		return 0;
+	else
+		return -1;
+}
+/*
+ * Given a hexadecimal character (in upper case), returns its integer value.
+ * Returns -1 if c is not a hexadecimal character.
+ */
+int hexvalu(char c)
+{
+	if (c >= '0' && c <= '9')
+		return c - '0';
+	else if (c >= 'A' && c <= 'F')
+		return (c - 'A') + 10;
+	else
+		return -1;
+}
+
+/*
+ * Given a hexadecimal character, returns its integer value.
+ * Returns -1 if c is not a hexadecimal character.
+ */
+int hexval(char c)
+{
+	if (c >= 'a' && c <= 'f')
+		return (c - 'a') + 10;
+	else
+		return hexvalu(c);
+}
+
+int int_precission(void)
+{
+	static int bits = 0;
+	unsigned int i;
+
+	if (bits > 0)
+		return bits;
+
+	i = INT_MAX;
+	bits = 0;
+	while (i) {
+		bits++;
+		i >>= 1;
+	}
+	return bits;
+}

2048/uz80as/utils.h

@@ -0,0 +1,26 @@
+/* ===========================================================================
+ * uz80as, an assembler for the Zilog Z80 and several other microprocessors.
+ *
+ * Generic functions.
+ * ===========================================================================
+ */
+
+#ifndef UTILS_H
+#define UTILS_H
+
+#define NELEMS(a)	(sizeof(a)/sizeof(a[0]))
+
+#define XSTR(n) STR(n)
+#define STR(n) #n
+
+void copychars(char *dst, const char *p, const char *q);
+int hash(const char *p, const char *q, unsigned int tabsz);
+int isidc0(char c);
+int isidc(char c);
+int scmp(const char *p, const char *q, const char *s);
+const char *skipws(const char *p);
+int hexvalu(char c);
+int hexval(char c);
+int int_precission(void);
+
+#endif

2048/uz80as/uz80as.h

@@ -0,0 +1,63 @@
+/* ===========================================================================
+ * uz80as, an assembler for the Zilog Z80 and several other microprocessors.
+ *
+ * Assembler.
+ * ===========================================================================
+ */
+
+#ifndef UZ80AS_H
+#define UZ80AS_H
+
+int verbose;
+
+/* matchtab.flags */
+enum {
+	MATCH_F_UNDOC = 1,
+	MATCH_F_EXTEN = 2,
+};
+
+/* pat:
+ * 	a: expr
+ * 	b - z: used by target
+ *
+ * gen:
+ * 	.: output lastbyte
+ * 	b: (op << 3) | lastbyte
+ * 	c: op | lastbyte
+ * 	d: lastbyte = op as 8 bit value
+ * 	e: output op as word (no '.' should follow)
+ * 	f - z: used by target
+ *
+ * pr:
+ * 	8: e8
+ *	f: e16
+ *	r: relative jump
+ */
+
+struct matchtab {
+	const char *pat;
+	const char *gen;
+	unsigned char mask;
+	unsigned char undoc;
+	const char *pr;
+};
+
+struct target {
+	const char *id;
+	const char *descr;
+	const struct matchtab *matcht;
+	int (*matchf)(char c, const char *p, const char **q);
+	int (*genf)(int *eb, char p, const int *vs, int i, int savepc);
+	void (*pat_char_rewind)(int c);
+	const char * (*pat_next_str)(void);
+	unsigned char mask;
+};
+
+extern const char *s_pline_ep;
+
+void genb(int b, const char *ep);
+int mreg(const char *p, const char *const list[], const char **r);
+
+void uz80as(void);
+
+#endif

2048/uz80as/z80.c

@@ -0,0 +1,362 @@
+/* ===========================================================================
+ * uz80as, an assembler for the Zilog Z80 and several other microprocessors.
+ *
+ * Zilog Z80 CPU.
+ * ===========================================================================
+ */
+
+#include "pp.h"
+#include "err.h"
+#include "options.h"
+#include "uz80as.h"
+#include <stddef.h>
+
+/* pat:
+ * 	a: expr
+ * 	b: B,C,D,E,H,L,A
+ * 	c: IX,IY (must be followed by + or -)
+ * 	d: BC,DE,HL,SP
+ * 	e: IX,IY
+ * 	f: BC,DE,HL,AF
+ * 	g: ADD,ADC,SUB,SBC,AND,XOR,OR,CP
+ * 	h: INC,DEC
+ * 	i: BC,DE,IX,SP
+ * 	j: BC,DE,IY,SP
+ * 	k: RLC,RRC,RL,RR,SLA,SRA,SRL
+ * 	l: BIT,RES,SET
+ * 	m: NZ,Z,NC,C,PO,PE,P,M
+ * 	n: NZ,Z,NC,C
+ * 	o: *
+ *      p: B,C,D,E,IXH,IXL,A
+ *      q: B,C,D,E,IYH,IYL,A
+ *
+ * gen:
+ * 	.: output lastbyte
+ * 	b: (op << 3) | lastbyte
+ * 	c: op | lastbyte
+ * 	d: lastbyte = op as 8 bit value
+ * 	e: output op as word (no '.' should follow)
+ * 	f: (op << 4) | lastbyte
+ * 	g: (op << 6) | lastbyte
+ * 	h: *
+ * 	i: relative jump to op
+ * 	j: possible value to RST
+ * 	k: possible value to IM
+ * 	m: check arithmetic used with A register
+ * 	n: check arithmetic used without A register
+ */
+
+static const struct matchtab s_matchtab_z80[] = {
+	{ "LD b,b", "40b0c1.", 3, 0 },
+	{ "LD p,p", "DD.40b0c1.", 1, 1 },
+	{ "LD q,q", "FD.40b0c1.", 1, 1 },
+	{ "LD b,(HL)", "46b0.", 3, 0 },
+	{ "LD b,(e)", "d1.46b0.00.", 3, 0, "ii" },
+	{ "LD b,(ca)", "d1.46b0.d2.", 3, 0, "ii" },
+	{ "LD A,I", "ED.57.", 3, 0 },
+	{ "LD A,R", "ED.5F.", 3, 0 },
+	{ "LD A,(BC)", "0A.", 3, 0 },
+	{ "LD A,(DE)", "1A.", 3, 0 },
+	{ "LD A,(a)", "3A.e0", 3, 0 },
+	{ "LD b,a", "06b0.d1.", 3, 0, "e8" },
+	{ "LD p,a", "DD.06b0.d1.", 1, 1, "e8" },
+	{ "LD q,a", "FD.06b0.d1.", 1, 1, "e8" },
+	{ "LD I,A", "ED.47.", 3, 0 },
+	{ "LD R,A", "ED.4F.", 3, 0 },
+	{ "LD SP,HL", "F9.", 3, 0 },
+	{ "LD SP,e", "d0.F9.", 3, 0 },
+	{ "LD HL,(a)", "2A.e0", 3, 0 },
+	{ "LD d,(a)", "ED.4Bf0.e1", 3, 0 },
+	{ "LD d,a", "01f0.e1", 3, 0 },
+	{ "LD e,(a)", "d0.2A.e1", 3, 0 },
+	{ "LD e,a", "d0.21.e1", 3, 0 },
+	{ "LD (HL),b", "70c0.", 3, 0 },
+	{ "LD (HL),a", "36.d0.", 3, 0, "e8" },
+	{ "LD (BC),A", "02.", 3, 0 },
+	{ "LD (DE),A", "12.", 3, 0 },
+	{ "LD (e),b", "d0.70c1.00.", 3, 0, "ii" },
+	{ "LD (ca),b", "d0.70c2.d1.", 3, 0, "ii" },
+	{ "LD (e),a", "d0.36.00.d1.", 3, 0, "iie8" },
+	{ "LD (ca),a", "d0.36.d1.d2.", 3, 0, "iie8" },
+	{ "LD (a),A", "32.e0", 3, 0 },
+	{ "LD (a),HL", "22.e0", 3, 0 },
+	{ "LD (a),d", "ED.43f1.e0", 3, 0 },
+	{ "LD (a),e", "d1.22.e0", 3, 0 },
+	{ "PUSH f", "C5f0.", 3, 0 },
+	{ "PUSH e", "d0.E5.", 3, 0 },
+	{ "POP f", "C1f0.", 3, 0 },
+	{ "POP e", "d0.E1.", 3, 0 },
+	{ "EX DE,HL", "EB.", 3, 0 },
+	{ "EX AF,AF'", "08.", 3, 0 },
+	{ "EX (SP),HL", "E3.", 3, 0 },
+	{ "EX (SP),e", "d0.E3.", 3, 0 },
+	{ "EXX", "D9.", 3, 0 },
+	{ "LDI", "ED.A0.", 3, 0 },
+	{ "LDIR", "ED.B0.", 3, 0 },
+	{ "LDD", "ED.A8.", 3, 0 },
+	{ "LDDR", "ED.B8.", 3, 0 },
+	{ "CPI", "ED.A1.", 3, 0 },
+	{ "CPIR", "ED.B1.", 3, 0 },
+	{ "CPD", "ED.A9.", 3, 0 },
+	{ "CPDR", "ED.B9.", 3, 0 },
+	{ "ADD HL,d", "09f0.", 3, 0 },
+	{ "ADD IX,i", "DD.09f0.", 3, 0 },
+	{ "ADD IY,j", "FD.09f0.", 3, 0 },
+	{ "ADC HL,d", "ED.4Af0.", 3, 0 },
+	{ "SBC HL,d", "ED.42f0.", 3, 0 },
+	{ "g A,b", "m080b0c1.", 3, 0 },
+	{ "g A,p", "DD.m080b0c1.", 1, 1 },
+	{ "g A,q", "FD.m080b0c1.", 1, 1 },
+	{ "g A,(HL)", "m086b0.", 3, 0 },
+	{ "g A,(ca)", "m0d1.86b0.d2.", 3, 0, "ii" },
+	{ "g A,a", "m0C6b0.d1.", 3, 0, "e8" },
+	{ "g b", "n080b0c1.", 3, 0 },
+	{ "g p", "DD.n080b0c1.", 1, 1 },
+	{ "g q", "FD.n080b0c1.", 1, 1 },
+	{ "g (HL)", "n086b0.", 3, 0 },
+	{ "g (ca)", "n0d1.86b0.d2.", 3, 0, "ii" },
+	{ "g a", "n0C6b0.d1.", 3, 0, "e8" },
+	{ "h b", "04b1c0.", 3, 0 },
+	{ "h p", "DD.04b1c0.", 1, 1 },
+	{ "h q", "FD.04b1c0.", 1, 1 },
+	{ "h (HL)", "34c0.", 3, 0 },
+	{ "h (ca)", "d1.34c0.d2.", 3, 0, "ii" },
+	{ "h (e)", "d1.34c0.00.", 3, 0, "ii" },
+	{ "INC d", "03f0.", 3, 0 },
+	{ "INC e", "d0.23.", 3, 0 },
+	{ "DEC d", "0Bf0.", 3, 0 },
+	{ "DEC e", "d0.2B.", 3, 0 },
+	{ "DAA", "27.", 3, 0 },
+	{ "CPL", "2F.", 3, 0 },
+	{ "NEG", "ED.44.", 3, 0 },
+	{ "CCF", "3F.", 3, 0 },
+	{ "SCF", "37.", 3, 0 },
+	{ "NOP", "00.", 3, 0 },
+	{ "HALT", "76.", 3, 0 },
+	{ "DI", "F3.", 3, 0 },
+	{ "EI", "FB.", 3, 0 },
+	{ "IM a", "ED.k0.", 3, 0, "tt" },
+	{ "RLCA", "07.", 3, 0 },
+	{ "RLA", "17.", 3, 0 },
+	{ "RRCA", "0F.", 3, 0 },
+	{ "RRA", "1F.", 3, 0 },
+	{ "SLL b", "CB.30c0.", 1, 1 },
+	{ "SLL (HL)", "CB.36.", 1, 1 },
+	{ "SLL (ca)", "d0.CB.d1.36.", 1, 1, "ii" },
+	{ "SLL (ca),b", "d0.CB.d1.30c2.", 1, 1, "ii" },
+	{ "k b", "CB.00b0c1.", 3, 0 },
+	{ "k (HL)", "CB.06b0.", 3, 0 },
+	{ "k (ca)", "d1.CB.d2.06b0.", 3, 0, "ii" },
+	{ "k (ca),b", "d1.CB.d2.00b0c3.", 1, 1, "ii" },
+	{ "RLD", "ED.6F.", 3, 0 },
+	{ "RRD", "ED.67.", 3, 0 },
+	{ "l a,b", "CB.00g0b1c2.", 3, 0, "b3" },
+	{ "l a,(HL)", "CB.06g0b1.", 3, 0, "b3" },
+	{ "l a,(ca)", "d2.CB.d3.06g0b1.", 3, 0, "b3ii" },
+	{ "RES a,(ca),b", "d1.CB.d2.80b0c3.", 1, 1, "b3ii" },
+	{ "SET a,(ca),b", "d1.CB.d2.C0b0c3.", 1, 1, "b3ii" },
+	{ "JP (HL)", "E9.", 3, 0 },
+	{ "JP (e)", "d0.E9.", 3, 0 },
+	{ "JP m,a", "C2b0.e1", 3, 0 },
+	{ "JP a", "C3.e0", 3, 0 },
+	{ "JR n,a", "20b0.i1.", 3, 0, "r8" },
+	{ "JR a", "18.i0.", 3, 0, "r8" },
+	{ "DJNZ a", "10.i0.", 3, 0, "r8" },
+	{ "CALL m,a", "C4b0.e1", 3, 0 },
+	{ "CALL a", "CD.e0", 3, 0 },
+	{ "RETI", "ED.4D.", 3, 0 },
+	{ "RETN", "ED.45.", 3, 0 },
+	{ "RET m", "C0b0.", 3, 0 },
+	{ "RET", "C9.", 3, 0 },
+	{ "RST a", "C7j0.", 3, 0, "ss" },
+	{ "IN b,(C)", "ED.40b0.", 3, 0 },
+	{ "IN A,(a)", "DB.d0.", 3, 0, "e8" },
+	{ "IN F,(a)", "ED.70.", 3, 0 },
+	{ "IN (C)", "ED.70.", 1, 1 },
+	{ "INI", "ED.A2.", 3, 0 },
+	{ "INIR", "ED.B2.", 3, 0 },
+	{ "IND", "ED.AA.", 3, 0 },
+	{ "INDR", "ED.BA.", 3, 0 },
+	{ "OUT (C),0", "ED.71.", 1, 1 },
+	{ "OUT (C),b", "ED.41b0.", 3, 0 },
+	{ "OUT (a),A", "D3.d0.", 3, 0, "e8" },
+	{ "OUTI", "ED.A3.", 3, 0 },
+	{ "OTIR", "ED.B3.", 3, 0 },
+	{ "OUTD", "ED.AB.", 3, 0 },
+	{ "OTDR", "ED.BB.", 3, 0 },
+	/* hd64180 added instructions */
+	{ "IN0 b,(a)", "ED.00b0.d1.", 2, 0, "e8" }, 
+	{ "OUT0 (a),b", "ED.01b1.d0.", 2, 0, "e8" },
+	{ "OTDM", "ED.8B.", 2, 0 },
+	{ "OTDMR", "ED.9B.", 2, 0 },
+	{ "OTIM", "ED.83.", 2, 0 },
+	{ "OTIMR", "ED.93.", 2, 0 },
+	{ "MLT d", "ED.4Cf0.", 2, 0 },
+	{ "SLP", "ED.76.", 2, 0 },
+	{ "TST b", "ED.04b0.", 2, 0 },
+	{ "TST (HL)", "ED.34.", 2, 0 },
+	{ "TST a", "ED.64.d0.", 2, 0, "e8" },
+	{ "TSTIO a", "ED.74.d0.", 2, 0, "e8" },
+	{ NULL, NULL },
+};
+
+static const char *const bval[] = { "B", "C", "D", "E",
+				    "H", "L", "", "A", NULL };
+static const char *const cval[] = { "IX", "IY", NULL };
+static const char *const dval[] = { "BC", "DE", "HL", "SP", NULL };
+static const char *const fval[] = { "BC", "DE", "HL", "AF", NULL };
+static const char *const gval[] = { "ADD", "ADC", "SUB", "SBC",
+				    "AND", "XOR", "OR", "CP", NULL };
+static const char *const hval[] = { "INC", "DEC", NULL };
+static const char *const ival[] = { "BC", "DE", "IX", "SP", NULL };
+static const char *const jval[] = { "BC", "DE", "IY", "SP", NULL };
+static const char *const kval[] = { "RLC", "RRC", "RL", "RR",
+				    "SLA", "SRA", "", "SRL", NULL };
+static const char *const lval[] = { "", "BIT", "RES", "SET", NULL };
+static const char *const mval[] = { "NZ", "Z", "NC", "C",
+				    "PO", "PE", "P", "M", NULL };
+static const char *const nval[] = { "NZ", "Z", "NC", "C", NULL };
+static const char *const pval[] = { "B", "C", "D", "E",
+				    "IXH", "IXL", "", "A", NULL };
+static const char *const qval[] = { "B", "C", "D", "E",
+				    "IYH", "IYL", "", "A", NULL };
+static const char *const nullv[] = { NULL };
+
+static const char *const *const valtab[] = { 
+	bval, cval, dval, dval, fval,
+       	gval, hval, ival, jval, kval,
+       	lval, mval, nval, nullv, pval,
+       	qval
+};
+
+static int indval(const char *p, int disp, const char **q)
+{
+	int v;
+	const char *r;
+
+	v = mreg(p, cval, &r);
+	if (v >= 0) {
+		v = (v == 0) ? 0xDD : 0xFD;
+		while (*r == ' ') r++;
+		if (!disp || *r == '+' || *r == '-') {
+			*q = r;
+			return v;
+		}
+	}
+	return -1;
+}
+
+static int match_z80(char c, const char *p, const char **q)
+{
+	int v;
+
+	if (c == 'c' || c == 'e') {
+		v = indval(p, c == 'c', q);
+	} else if (c <= 'q') {
+		v = mreg(p, valtab[(int) (c - 'b')], q);
+	} else {
+		v = -1;
+	}
+
+	return v;
+}
+
+static int gen_z80(int *eb, char p, const int *vs, int i, int savepc)
+{
+	int b;
+       
+	b = *eb;
+	switch (p) {
+	case 'f': b |= (vs[i] << 4); break;
+	case 'g': b |= (vs[i] << 6); break;
+	case 'i': b = (vs[i] - savepc - 2); break;
+	case 'j': if (s_pass > 0 && (vs[i] & ~56) != 0) {
+			  eprint(_("invalid RST argument (%d)\n"),
+				vs[i]);
+			  eprcol(s_pline, s_pline_ep);
+			  newerr();
+		  }
+		  b |= vs[i];
+		  break;
+	case 'k': if (s_pass > 0 && (vs[i] < 0 || vs[i] > 2)) {
+			  eprint(_("invalid IM argument (%d)\n"),
+				vs[i]);
+			  eprcol(s_pline, s_pline_ep);
+			  newerr();
+		  }
+		  b = 0x46;
+		  if (vs[i] == 1)
+			  b = 0x56;
+		  else if (vs[i] == 2)
+			  b = 0x5E;
+		  break;
+	case 'm': if (s_pass == 0 && !s_extended_op) {
+			  if (vs[i] != 0 && vs[i] != 1 && vs[i] != 3) {
+				eprint(_("unofficial syntax\n"));
+				eprcol(s_pline, s_pline_ep);
+				newerr();
+			  }
+		  }
+		  break;
+	case 'n': if (s_pass == 0 && !s_extended_op) {
+			  if (vs[i] == 0 || vs[i] == 1 || vs[i] == 3) {
+				eprint(_("unofficial syntax\n"));
+				eprcol(s_pline, s_pline_ep);
+				newerr();
+			  }
+		  }
+		  break;
+	default:
+		  return -1;
+	}
+
+	*eb = b;
+	return 0;
+}
+
+static int s_pat_char = 'b';
+static int s_pat_index;
+
+static void pat_char_rewind_z80(int c)
+{
+	s_pat_char = c;
+	s_pat_index = 0;
+};
+
+static const char *pat_next_str_z80(void)
+{
+	const char *s;
+
+	if (s_pat_char >= 'b' && s_pat_char <= 'q') {
+		s = valtab[(int) (s_pat_char - 'b')][s_pat_index];
+		if (s != NULL) {
+			s_pat_index++;
+		}
+	} else {
+		s = NULL;
+	}
+
+	return s;
+};
+
+const struct target s_target_z80 = {
+	.id = "z80",
+	.descr = "Zilog Z80",
+	.matcht = s_matchtab_z80,
+	.matchf = match_z80,
+	.genf = gen_z80,
+	.pat_char_rewind = pat_char_rewind_z80,
+	.pat_next_str = pat_next_str_z80,
+	.mask = 1
+};
+
+const struct target s_target_hd64180 = {
+	.id = "hd64180",
+	.descr = "Hitachi HD64180",
+	.matcht = s_matchtab_z80,
+	.matchf = match_z80,
+	.genf = gen_z80,
+	.pat_char_rewind = pat_char_rewind_z80,
+	.pat_next_str = pat_next_str_z80,
+	.mask = 2
+};