Path: utzoo!mnetor!uunet!husc6!purdue!i.cc.purdue.edu!j.cc.purdue.edu!ain From: ain@j.cc.purdue.edu (Patrick White) Newsgroups: comp.sources.amiga Subject: dasm (part 1 of 2) Message-ID: <6390@j.cc.purdue.edu> Date: 8 Feb 88 23:40:34 GMT Organization: PUCC Land, USA Lines: 2463 Keywords: dasm, cross assembler, part 1 of 2, untested. Approved: ain@j.cc.purdue.edu (Pat White) Program Name: dasm (part 1 of 2) Submitted By: dillon%cory.Berkeley.EDU@ucbvax.berkeley.edu (Matt Dillon) Summary: A cross assembler for 6502, 68705, 6803, and HD6303 (extension of 6803) Poster Boy: Pat White (ain@j.cc.purdue.edu) Untested. NOTES: I didn't bother to compile these. -- Pat White (co-moderator comp.sources/binaries.amiga) UUCP: j.cc.purdue.edu!ain BITNET: PATWHITE@PURCCVM PHONE: (317) 743-8421 U.S. Mail: 320 Brown St. apt. 406, West Lafayette, IN 47906 ======================================== # This is a shell archive. # Remove everything above and including the cut line. # Then run the rest of the file through sh. #----cut here-----cut here-----cut here-----cut here----# #!/bin/sh # shar: Shell Archiver # Run the following text with /bin/sh to create: # Makefile # asm.h # exp.c # ftohex.c # globals.c # main.c # mne6303.c # mne6502.c # This archive created: Mon Feb 8 13:15:22 1988 # By: Patrick White (PUCC Land, USA) echo shar: extracting Makefile '(883 characters)' cat << \SHAR_EOF > Makefile # DASM -small systems cross assembler # (c)Copyright 1988 Matthew Dillon, All Rights Reserved. # # Requires SUP32.LIB (Aztec C) and precompiled symbol table of */* (all # low level Amiga includes, none of the top level includes). remember # to compile symbol table with +L option. # # However, shouldn't be too hard to modify to work with # lattice or without suplib. CFLAGS= +L +Iwork:include/symbols.m OBJS= main.o ops.o globals.o exp.o symbols.o \ mne6303.o mne6502.o mne68705.o mne6811.o SRCS= main.c ops.c globals.c exp.c symbols.c \ mne6303.c mne6502.c mne68705.c mne6811.c all: dasm ftohex dasm: $(OBJS) ln +Q $(OBJS) -lsup32 -lc32 -O c:dasm ftohex: ftohex.o ln +Q ftohex.o -lsup32 -lc32 -O c:ftohex example: dasm example.asm -oram:example.out -lram:example.list -f2 ftohex 2 ram:example.out ram:example.hex obj: $(OBJS) SHAR_EOF if test 883 -ne "`wc -c Makefile`" then echo shar: error transmitting Makefile '(should have been 883 characters)' fi echo shar: extracting asm.h '(6327 characters)' cat << \SHAR_EOF > asm.h /* * ASM65.H * * Structures and definitions */ #include #ifdef IBMPC typedef char ubyte; typedef unsigned uword; typedef long ulong; #define bzero(s,n) setmem(s,n,0) #define bset(s,n,c) setmem(s,n,c) #define bmov(s,d,n) movmem(s,d,n) #else typedef unsigned char ubyte; typedef unsigned short uword; typedef unsigned long ulong; #endif #define MNE struct _MNE #define MACRO struct _MACRO #define INCFILE struct _INCFILE #define REPLOOP struct _REPLOOP #define IFSTACK struct _IFSTACK #define SEGMENT struct _SEGMENT #define SYMBOL struct _SYMBOL #define STRLIST struct _STRLIST #define DEFORGFILL 255 #define SHASHSIZE 4096 #define MHASHSIZE 1024 #define SHASHAND 0x0FFF #define MHASHAND 0x03FF #define ALLOCSIZE 16384 #define MAXMACLEVEL 32 #define TAB 9 #define OUTFORM1 0 #define OUTFORM2 1 #define OUTFORM3 2 #define AM_IMP 0 /* implied */ #define AM_IMM8 1 /* immediate 8 bits */ #define AM_IMM16 2 /* immediate 16 bits */ #define AM_BYTEADR 3 /* address 8 bits */ #define AM_BYTEADRX 4 /* address 16 bits */ #define AM_BYTEADRY 5 /* relative 8 bits */ #define AM_WORDADR 6 /* index x 0 bits */ #define AM_WORDADRX 7 /* index x 8 bits */ #define AM_WORDADRY 8 /* index x 16 bits */ #define AM_REL 9 /* bit inst. special */ #define AM_INDBYTEX 10 /* bit-bra inst. spec. */ #define AM_INDBYTEY 11 /* index y 0 bits */ #define AM_INDWORD 12 /* index y 8 bits */ #define AM_0X 13 /* index x 0 bits */ #define AM_0Y 14 /* index y 0 bits */ #define AM_BITMOD 15 /* ind addr 8 bits */ #define AM_BITBRAMOD 16 /* ind addr 16 bits */ #define NUMOC 17 #define AF_IMP (1 << 0 ) #define AF_IMM8 (1 << 1 ) #define AF_IMM16 (1 << 2 ) #define AF_BYTEADR (1 << 3 ) #define AF_BYTEADRX (1 << 4 ) #define AF_BYTEADRY (1 << 5 ) #define AF_WORDADR (1 << 6 ) #define AF_WORDADRX (1 << 7 ) #define AF_WORDADRY (1 << 8 ) #define AF_REL (1 << 9 ) #define AF_INDBYTEX (1 << 10) #define AF_INDBYTEY (1 << 11) #define AF_INDWORD (1 << 12) #define AF_0X (1 << 13) #define AF_0Y (1 << 14) #define AF_BITMOD (1 << 15) #define AF_BITBRAMOD (1 << 16) #define AM_SYMBOL (NUMOC+0) #define AM_EXPLIST (NUMOC+1) #define AM_BYTE AM_BYTEADR #define AM_WORD AM_WORDADR #define AM_LONG (NUMOC+2) #define AM_BSS (NUMOC+3) STRLIST { STRLIST *next; ubyte buf[4]; }; #define MF_IF 0x04 #define MF_MACRO 0x08 MNE { MNE *next; /* hash */ void (*vect)(); /* dispatch */ char *name; /* actual name */ ubyte flags; /* special flags */ ulong okmask; ubyte opcode[NUMOC]; /* hex codes */ }; MACRO { MACRO *next; void (*vect)(); ubyte *name; ubyte flags; STRLIST *strlist; }; #define INF_MACRO 0x01 INCFILE { INCFILE *next; /* previously pushed context */ ubyte *name; /* file name */ FILE *fi; /* file handle */ ulong lineno; /* line number in file */ ubyte flags; /* flags (macro) */ /* Only if Macro */ STRLIST *args; /* arguments to macro */ STRLIST *strlist; /* current string list */ ulong saveidx; /* save localindex */ }; #define RPF_UNKNOWN 0x01 /* value unknown */ REPLOOP { REPLOOP *next; /* previously pushed context */ ulong count; /* repeat count */ ulong seek; /* seek to top of repeat */ ulong lineno; /* line number of line before */ INCFILE *file; /* which include file are we in*/ ubyte flags; }; #define IFF_UNKNOWN 0x01 /* value unknown */ #define IFF_BASE 0x04 IFSTACK { IFSTACK *next; /* previous IF */ INCFILE *file; /* which include file are we in*/ ubyte flags; ubyte true; /* 1 if true, 0 if false */ ubyte acctrue;/* accumulatively true (not incl this one) */ }; #define SF_UNKNOWN 0x01 /* ORG unknown */ #define SF_REF 0x04 /* ORG referenced */ #define SF_BSS 0x10 /* uninitialized area (U flag) */ #define SF_RORG 0x20 /* relocatable origin active */ SEGMENT { SEGMENT *next; /* next segment in segment list */ ubyte *name; /* name of segment */ ubyte flags; /* for ORG */ ubyte rflags; /* for RORG */ ulong org; /* current org */ ulong rorg; /* current rorg */ ulong initorg; ulong initrorg; ubyte initflags; ubyte initrflags; }; #define SYM_UNKNOWN 0x01 /* value unknown */ #define SYM_REF 0x04 /* referenced */ #define SYM_STRING 0x08 /* result is a string */ #define SYM_SET 0x10 /* SET instruction used */ #define SYM_MACRO 0x20 /* symbol is a macro */ #define SYM_MASREF 0x40 /* master reference */ SYMBOL { SYMBOL *next; /* next symbol in hash list */ ubyte *name; /* symbol name or string if expr. */ ubyte *string; /* if symbol is actually a string */ ubyte flags; /* flags */ ubyte addrmode; /* addressing mode (expressions) */ ulong value; /* current value */ uword namelen; /* name length */ }; extern SYMBOL *SHash[]; extern MNE *MHash[]; extern INCFILE *Incfile; extern REPLOOP *Reploop; extern SEGMENT *Seglist; extern IFSTACK *Ifstack; extern SEGMENT *Csegment; /* current segment */ extern ubyte *Av[]; extern ubyte Avbuf[]; extern uword Adrbytes[]; extern uword Cvt[]; extern uword Opsize[]; extern uword Mnext; /* mnemonic extension */ extern uword Mlevel; extern void fseek(); extern long ftell(); extern ubyte *malloc(), *zmalloc(), *strcpy(), *permalloc(); extern ubyte *sftos(); extern SYMBOL *allocsymbol(); extern ubyte Xtrace; extern ubyte Xdebug; extern ubyte MsbOrder; extern ubyte Outputformat; extern ulong Redo, Redo_why, Redo_eval; extern ulong Localindex, Lastlocalindex; extern ubyte F_format; extern ubyte F_verbose; extern char *F_outfile; extern char *F_listfile; extern char *F_symfile; extern char *F_temppath; extern FILE *FI_listfile; extern FILE *FI_temp; extern ubyte Fisclear; extern ulong Plab, Pflags; extern char Inclevel; extern ulong Processor; extern SYMBOL *findsymbol(), *createsymbol(), *eval(); extern uword _fmode; SHAR_EOF if test 6327 -ne "`wc -c asm.h`" then echo shar: error transmitting asm.h '(should have been 6327 characters)' fi echo shar: extracting exp.c '(13142 characters)' cat << \SHAR_EOF > exp.c /* * EXP.C * * Handle expression evaluation and addressing mode decode. * * NOTE! If you use the string field in an expression you must clear * the SYM_MACRO and SYM_STRING bits in the flags before calling * freesymbollist()! */ #include "asm.h" extern void doop(), evaltop(), stackarg(); extern void op_mult(), op_div(), op_mod(), op_add(), op_sub(), op_shiftleft(), op_shiftright(), op_greater(), op_greatereq(), op_smaller(), op_smallereq(), op_eqeq(), op_noteq(), op_andand(), op_oror(), op_xor(), op_and(), op_or(), op_negate(), op_invert(), op_not(); extern void op_takelsb(), op_takemsb(), op_question(); extern ubyte *pushsymbol(), *pushstr(), *pushbin(), *pushoct(), *pushdec(), *pushhex(), *pushchar(); extern short alphanum(); /* * evaluate an expression. Figure out the addressing mode: * * implied * #val immediate * val zero page or absolute * val,x zero,x or absolute,x * val,y zero,y or absolute,y * (val) indirect * (val,x) zero indirect x * (val),y zero indirect y * * exp, exp,.. LIST of expressions * * an absolute may be returned as zero page * a relative may be returned as zero page or absolute * * unary: - ~ ! < > * binary: (^)(* / %)(+ -)(>> <<)(& |)(`)(&& ||)(== != < > <= >=) * * values: symbol, octal, decimal, $hex, %binary, 'c "str" * */ #define MAXOPS 32 #define MAXARGS 64 ubyte Argflags[MAXARGS]; long Argstack[MAXARGS]; ubyte *Argstring[MAXARGS]; short Oppri[MAXOPS]; void (*Opdis[MAXOPS])(); uword Argi, Opi, Lastwasop; uword Argibase, Opibase; SYMBOL * eval(str) register char *str; { register SYMBOL *base, *cur; uword oldargibase = Argibase; uword oldopibase = Opibase; uword scr; Argibase = Argi; Opibase = Opi; Lastwasop = 1; base = cur = allocsymbol(); while (*str) { if (Xdebug) printf("char '%c'\n", *str); switch(*str) { case ' ': case '\n': ++str; break; case '~': if (Lastwasop) doop(op_invert, 128); else asmerr(0,0); ++str; break; case '*': doop(op_mult, 20); ++str; break; case '/': doop(op_div, 20); ++str; break; case '%': if (Lastwasop) { str = (char *)pushbin(str+1); } else { doop(op_mod, 20); ++str; } break; case '?': /* 10 */ doop(op_question, 10); ++str; break; case '+': /* 19 */ doop(op_add, 19); ++str; break; case '-': /* 19: - (or - unary) */ if (Lastwasop) { doop(op_negate, 128); } else { doop(op_sub, 19); } ++str; break; case '>': /* 18: >> << 17: > >= <= < */ if (Lastwasop) { doop(op_takelsb, 128); ++str; break; } if (str[1] == '>') { doop(op_shiftright, 18); ++str; } else if (str[1] == '=') { doop(op_greatereq, 17); ++str; } else { doop(op_greater, 17); } ++str; break; case '<': if (Lastwasop) { doop(op_takemsb, 128); ++str; break; } if (str[1] == '<') { doop(op_shiftleft, 18); ++str; } else if (str[1] == '=') { doop(op_smallereq, 17); ++str; } else { doop(op_smaller, 17); } ++str; break; case '=': /* 16: == (= same as ==) */ if (str[1] == '=') ++str; doop(op_eqeq, 16); ++str; break; case '!': /* 16: != */ if (Lastwasop) { doop(op_not, 128); } else { doop(op_noteq, 16); ++str; } ++str; break; case '&': /* 15: & 12: && */ if (str[1] == '&') { doop(op_andand, 12); ++str; } else { doop(op_and, 15); } ++str; break; case '^': /* 14: ^ */ doop(op_xor, 14); ++str; break; case '|': /* 13: | 11: || */ if (str[1] == '|') { doop(op_oror, 11); ++str; } else { doop(op_or, 13); } ++str; break; case '[': /* eventually an argument */ if (Opi == MAXOPS) puts("too many ops"); else Oppri[Opi++] = 0; ++str; break; case ']': while(Opi != Opibase && Oppri[Opi-1]) evaltop(); if (Opi != Opibase) --Opi; ++str; if (Argi == Argibase) { puts("']' error, no arg on stack"); break; } if (*str == 'd') { /* STRING CONVERSION */ char buf[32]; ++str; if (Argflags[Argi-1] == 0) { sprintf(buf,"%ld",Argstack[Argi-1]); Argstring[Argi-1] = strcpy(malloc(strlen(buf)+1),buf); } } break; case '#': cur->addrmode = AM_IMM8; ++str; break; case '(': cur->addrmode = AM_INDWORD; ++str; break; case ')': if (cur->addrmode == AM_INDWORD && str[1] == ',' && (str[2]|0x20) == 'y') { cur->addrmode = AM_INDBYTEY; str += 2; } ++str; break; case ',': while(Opi != Opibase) evaltop(); Lastwasop = 1; scr = str[1]|0x20; /* to lower case */ if (cur->addrmode == AM_INDWORD && scr == 'x' && !alphanum(str[2])) { cur->addrmode = AM_INDBYTEX; ++str; } else if (scr == 'x' && !alphanum(str[2])) { cur->addrmode = AM_0X; ++str; } else if (scr == 'y' && !alphanum(str[2])) { cur->addrmode = AM_0Y; ++str; } else { register SYMBOL *new = allocsymbol(); cur->next = new; --Argi; if (Argi < Argibase) asmerr(0,0); if (Argi > Argibase) asmerr(0,0); cur->value = Argstack[Argi]; cur->flags = Argflags[Argi]; if (cur->string= (void *)Argstring[Argi]) { cur->flags |= SYM_STRING; if (Xdebug) printf("STRING: %s\n", cur->string); } cur = new; } ++str; break; case '$': str = (char *)pushhex(str+1); break; case '\'': str = (char *)pushchar(str+1); break; case '\"': str = (char *)pushstr(str+1); break; default: if (*str == '0') str = (char *)pushoct(str); else { if (*str > '0' && *str <= '9') str = (char *)pushdec(str); else str = (char *)pushsymbol(str); } break; } } while(Opi != Opibase) evaltop(); if (Argi != Argibase) { short add = 0; --Argi; cur->value = Argstack[Argi]; cur->flags = Argflags[Argi]; if (cur->string= (void *)Argstring[Argi]) { cur->flags |= SYM_STRING; if (Xdebug) printf("STRING: %s\n", cur->string); } if (base->addrmode == 0) base->addrmode = AM_BYTEADR; } if (Argi != Argibase || Opi != Opibase) asmerr(0,0); Argi = Argibase; Opi = Opibase; Argibase = oldargibase; Opibase = oldopibase; return(base); } short alphanum(c) { return ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9')); } void evaltop() { if (Xdebug) printf("evaltop @(A,O) %ld %ld\n", Argi, Opi); if (Opi <= Opibase) { asmerr(0,0); Opi = Opibase; return; } --Opi; if (Oppri[Opi] == 128) { if (Argi < Argibase + 1) { asmerr(0,0); Argi = Argibase; return; } --Argi; (*Opdis[Opi])(Argstack[Argi], Argflags[Argi]); } else { if (Argi < Argibase + 2) { asmerr(0,0); Argi = Argibase; return; } Argi -= 2; (*Opdis[Opi])(Argstack[Argi], Argstack[Argi+1], Argflags[Argi], Argflags[Argi+1]); } } void stackarg(val, flags) long val; short flags; { ubyte *str = NULL; if (Xdebug) printf("stackarg %ld (@%d)\n", val, Argi); Lastwasop = 0; if (flags & SYM_STRING) { register ubyte *ptr = str = (ubyte *)val; register ubyte *new; register uword len; val = len = 0; while (*ptr && *ptr != '\"') { val = (val << 8) | *ptr; ++ptr; ++len; } new = malloc(len + 1); bmov(str, new, len); new[len] = 0; flags &= ~SYM_STRING; str = new; } Argstack[Argi] = val; Argstring[Argi] = str; Argflags[Argi] = flags; if (++Argi == MAXARGS) { puts("stackarg: maxargs stacked"); Argi = Argibase; } while (Opi != Opibase && Oppri[Opi-1] == 128) evaltop(); } void doop(func, pri) void (*func)(); { if (Xdebug) puts("doop"); Lastwasop = 1; if (Opi == Opibase || pri == 128) { if (Xdebug) printf("doop @ %ld unary\n", Opi); Opdis[Opi] = func; Oppri[Opi] = pri; ++Opi; return; } while (Opi != Opibase && Oppri[Opi-1] && pri <= Oppri[Opi-1]) evaltop(); if (Xdebug) printf("doop @ %ld\n", Opi); Opdis[Opi] = func; Oppri[Opi] = pri; ++Opi; if (Opi == MAXOPS) { puts("doop: too many operators"); Opi = Opibase; } return; } void op_takelsb(v1, f1) long v1; { stackarg(v1 & 0xFFL, f1); } void op_takemsb(v1, f1) long v1; { stackarg((v1 >> 8) & 0xFF, f1); } void op_negate(v1, f1) long v1; { stackarg(-v1, f1); } void op_invert(v1, f1) long v1; { stackarg(~v1, f1); } void op_not(v1, f1) long v1; { stackarg(!v1, f1); } void op_mult(v1, v2, f1, f2) long v1, v2; { stackarg(v1 * v2, f1|f2); } void op_div(v1, v2, f1, f2) long v1, v2; { if (f1|f2) { stackarg(0L, f1|f2); return; } if (v2 == 0) { puts("division by zero"); stackarg(0L, 0); } else { stackarg(v1 / v2, 0); } } void op_mod(v1, v2, f1, f2) long v1, v2; { if (f1|f2) { stackarg(0L, f1|f2); return; } if (v2 == 0) stackarg(v1, 0); else stackarg(v1 % v2, 0); } void op_question(v1, v2, f1, f2) long v1, v2; { if (f1) stackarg(0L, f1); else stackarg((long)((v1) ? v2 : 0), ((v1) ? f2 : 0)); } void op_add(v1, v2, f1, f2) long v1, v2; { stackarg(v1 + v2, f1|f2); } void op_sub(v1, v2, f1, f2) long v1, v2; { stackarg(v1 - v2, f1|f2); } void op_shiftright(v1, v2, f1, f2) long v1, v2; { if (f1|f2) stackarg(0L, f1|f2); else stackarg((long)(v1 >> v2), 0); } void op_shiftleft(v1, v2, f1, f2) long v1, v2; { if (f1|f2) stackarg(0L, f1|f2); else stackarg((long)(v1 << v2), 0); } void op_greater(v1, v2, f1, f2) long v1, v2; { stackarg((long)(v1 > v2), f1|f2); } void op_greatereq(v1, v2, f1, f2) long v1, v2; { stackarg((long)(v1 >= v2), f1|f2); } void op_smaller(v1, v2, f1, f2) long v1, v2; { stackarg((long)(v1 < v2), f1|f2); } void op_smallereq(v1, v2, f1, f2) long v1, v2; { stackarg((long)(v1 <= v2), f1|f2); } void op_eqeq(v1, v2, f1, f2) long v1, v2; { stackarg((long)(v1 == v2), f1|f2); } void op_noteq(v1, v2, f1, f2) long v1, v2; { stackarg((long)(v1 != v2), f1|f2); } void op_andand(v1, v2, f1, f2) long v1, v2; { if ((!f1 && !v1) || (!f2 && !v2)) { stackarg(0L, 0); return; } stackarg(1L, f1|f2); } void op_oror(v1, v2, f1, f2) long v1, v2; { if ((!f1 && v1) || (!f2 && v2)) { stackarg(1L, 0); return; } stackarg(0L, f1|f2); } void op_xor(v1, v2, f1, f2) long v1, v2; { stackarg(v1^v2, f1|f2); } void op_and(v1, v2, f1, f2) long v1, v2; { stackarg(v1&v2, f1|f2); } void op_or(v1, v2, f1, f2) long v1, v2; { stackarg(v1|v2, f1|f2); } ubyte * pushchar(str) char *str; { if (*str) { stackarg((long)*str, 0); ++str; } else { stackarg((long)' ', 0); } return((ubyte *)str); } ubyte * pushhex(str) char *str; { register long val = 0; for (;; ++str) { if (*str >= '0' && *str <= '9') { val = (val << 4) + (*str - '0'); continue; } if ((*str >= 'a' && *str <= 'f') || (*str >= 'A' && *str <= 'F')) { val = (val << 4) + ((*str&0x1F) + 9); continue; } break; } stackarg(val, 0); return((ubyte *)str); } ubyte * pushoct(str) char *str; { register long val = 0; while (*str >= '0' && *str <= '7') { val = (val << 3) + (*str - '0'); ++str; } stackarg(val, 0); return((ubyte *)str); } ubyte * pushdec(str) char *str; { register long val = 0; while (*str >= '0' && *str <= '9') { val = (val * 10) + (*str - '0'); ++str; } stackarg(val, 0); return((ubyte *)str); } ubyte * pushbin(str) char *str; { register long val = 0; while (*str == '0' || *str == '1') { val = (val << 1) | (*str - '0'); ++str; } stackarg(val, 0); return((ubyte *)str); } ubyte * pushstr(str) char *str; { stackarg(str, SYM_STRING); while (*str && *str != '\"') ++str; if (*str == '\"') ++str; return((ubyte *)str); } ubyte * pushsymbol(str) ubyte *str; { register SYMBOL *sym; register ubyte *ptr; ubyte macro = 0; for (ptr = str; *ptr == '_' || *ptr == '.' || (*ptr >= 'a' && *ptr <= 'z') || (*ptr >= 'A' && *ptr <= 'Z') || (*ptr >= '0' && *ptr <= '9'); ++ptr ); if (ptr == str) { asmerr(9,0); printf("char = '%lc' %ld (-1: %ld)\n", *str, *str, *(str-1)); if (F_listfile) fprintf(FI_listfile, "char = '%lc' code %ld\n", *str, *str); return((ubyte *)str+1); } if (sym = findsymbol(str, ptr - str)) { if (sym->flags & SYM_UNKNOWN) ++Redo_eval; if (sym->flags & SYM_MACRO) { macro = 1; sym = eval(sym->string); } if (sym->flags & SYM_STRING) stackarg(sym->string, SYM_STRING); else stackarg(sym->value, sym->flags & SYM_UNKNOWN); sym->flags |= SYM_REF|SYM_MASREF; if (macro) freesymbollist(sym); } else { stackarg(0L, SYM_UNKNOWN); sym = createsymbol(str, ptr - str); sym->flags = SYM_REF|SYM_MASREF|SYM_UNKNOWN; ++Redo_eval; } return(ptr); } SHAR_EOF if test 13142 -ne "`wc -c exp.c`" then echo shar: error transmitting exp.c '(should have been 13142 characters)' fi echo shar: extracting ftohex.c '(2997 characters)' cat << \SHAR_EOF > ftohex.c /* * FTOHEX.C * * FTOHEX format infile [outfile] * * format: format used when assembling (asm705/asm65) * 1,2,3 -generate straight hex file * * compilable on an ibm-pc or amiga _fmode is for Lattice C on the IBM, * is IGNORED by Aztec C on the Amiga. Note that INT and CHAR are not * used as IBM's lattice C uses 16 bit ints and unsigned chars. */ #include #ifdef IBMPC typedef char ubyte; typedef unsigned uword; #else typedef unsigned char ubyte; typedef unsigned short uword; #endif #define PERLINE 16 extern long ftell(); extern void fseek(); extern uword getwlh(); extern void puth(); uword _fmode = 0; main(ac, av) ubyte *av[]; short ac; { short format; FILE *infile; FILE *outfile; _fmode = 0x8000; if (ac < 3) { puts("FTOHEX format infile [outfile]"); puts("format 1,2, or 3. 3=raw"); puts("(C)Copyright 1987 by Matthew Dillon, All Rights Reserved"); exit(1); } format = atoi(av[1]); if (format < 1 || format > 3) exiterr("specify infile format 1, 2, or 3"); infile = fopen(av[2], "r"); if (infile == NULL) exiterr("unable to open input file"); outfile = (av[3]) ? fopen(av[3], "w") : stdout; if (outfile == NULL) exiterr("unable to open output file"); convert(format, infile, outfile); fclose(infile); fclose(outfile); } exiterr(str) ubyte *str; { fputs(str, stderr); fputs("\n", stderr); exit(1); } /* * Formats: * * 1: origin (word:lsb,msb) + data * 2: origin (word:lsb,msb) + length (word:lsb,msb) + data (repeat) * 3: data * * Hex output: * * :lloooo00(ll bytes hex code)cc ll=# of bytes * oooo=origin * cc=invert of checksum all codes */ convert(format, in, out) short format; FILE *in; FILE *out; { uword org = 0; uword idx; long len; ubyte buf[256]; if (format < 3) org = getwlh(in); if (format == 2) { len = getwlh(in); } else { long begin = ftell(in); fseek(in, 0, 2); len = ftell(in) - begin; fseek(in, begin, 0); } for (;;) { while (len > 0) { register ubyte chk; register short i; idx = (len > PERLINE) ? PERLINE : len; fread(buf, idx, 1, in); putc(':', out); puth(idx, out); puth(org >> 8, out); puth(org & 0xFF, out); putc('0', out); putc('0', out); chk = idx + (org >> 8) + (org & 0xFF); for (i = 0; i < idx; ++i) { chk += buf[i]; puth(buf[i], out); } puth((ubyte)-chk, out); putc('\r', out); putc('\n', out); len -= idx; org += idx; } if (format == 2) { org = getwlh(in); if (feof(in)) break; len = getwlh(in); } else { break; } } fprintf(out, ":00000001FF\r\n"); } uword getwlh(in) FILE *in; { uword result; result = getc(in); result += getc(in) << 8; return(result); } void puth(c, out) ubyte c; FILE *out; { static ubyte dig[] = { "0123456789ABCDEF" }; putc(dig[c>>4], out); putc(dig[c&15], out); } SHAR_EOF if test 2997 -ne "`wc -c ftohex.c`" then echo shar: error transmitting ftohex.c '(should have been 2997 characters)' fi echo shar: extracting globals.c '(3208 characters)' cat << \SHAR_EOF > globals.c #include "asm.h" extern void v_list(), v_include(), v_seg(), v_dc(), v_ds(), v_org(), v_rorg(), v_rend(), v_align(), v_subroutine(), v_equ(), v_eqm(), v_set(), v_macro(), v_endm(), v_mexit(), v_ifconst(), v_ifnconst(), v_if(), v_else(), v_endif(), v_repeat(), v_repend(), v_err(), v_hex(), v_trace(); extern void v_end(), v_echo(), v_processor(); SYMBOL *SHash[SHASHSIZE]; /* symbol hash table */ MNE *MHash[MHASHSIZE]; /* mnemonic hash table */ INCFILE *Incfile; /* include file stack */ REPLOOP *Reploop; /* repeat loop stack */ SEGMENT *Seglist; /* segment list */ SEGMENT *Csegment; /* current segment */ IFSTACK *Ifstack; /* IF/ELSE/ENDIF stack */ ubyte *Av[256]; /* up to 256 arguments */ ubyte Avbuf[512]; ubyte MsbOrder = 1; uword Mnext; char Inclevel; uword Mlevel; ulong Localindex; /* to generate local variables */ ulong Lastlocalindex; ulong Processor; ubyte Xdebug, Xtrace; ubyte Outputformat; ulong Redo, Redo_why; ulong Redo_eval; /* infinite loop detection only */ ubyte F_format = 1; ubyte F_verbose; char *F_outfile = "a.out"; char *F_listfile; char *F_symfile; char *F_temppath = "ram:"; FILE *FI_listfile; FILE *FI_temp; ubyte Fisclear; ulong Plab, Pflags; uword Adrbytes[] = { 1, 2, 3, 2, 2, 2, 3, 3, 3, 2, 2, 2, 3, 1, 1, 2, 3 }; uword Cvt[] = { 0, 2, 0, 6, 7, 8, 9, 0, 0, 0, 0, 0, 0, 4, 5, 0, 0 }; uword Opsize[] = { 0, 1, 2, 1, 1, 1, 2, 2, 2, 2, 1, 1, 2, 0, 0, 1, 1 }; MNE Ops[] = { { NULL, v_list , "list", 0, 0 }, { NULL, v_include , "include", 0, 0 }, { NULL, v_seg , "seg", 0, 0 }, { NULL, v_hex , "hex", 0, 0 }, { NULL, v_err , "err", 0, 0 }, { NULL, v_dc , "dc", 0, 0 }, { NULL, v_ds , "ds", 0, 0 }, { NULL, v_dc , "dv", 0, 0 }, { NULL, v_end , "end", 0, 0 }, { NULL, v_trace , "trace", 0, 0 }, { NULL, v_org , "org", 0, 0 }, { NULL, v_rorg , "rorg", 0, 0 }, { NULL, v_rend , "rend", 0, 0 }, { NULL, v_align , "align", 0, 0 }, { NULL, v_subroutine, "subroutine", 0, 0 }, { NULL, v_equ , "equ", 0, 0 }, { NULL, v_eqm , "eqm", 0, 0 }, { NULL, v_set , "set", 0, 0 }, { NULL, v_macro , "mac", MF_IF, 0 }, { NULL, v_endm , "endm", 0, 0 }, { NULL, v_mexit , "mexit", 0, 0 }, { NULL, v_ifconst , "ifconst", MF_IF, 0 }, { NULL, v_ifnconst, "ifnconst", MF_IF, 0 }, { NULL, v_if , "if", MF_IF, 0 }, { NULL, v_else , "else", MF_IF, 0 }, { NULL, v_endif , "endif", MF_IF, 0 }, { NULL, v_endif , "eif", MF_IF, 0 }, { NULL, v_repeat , "repeat", 0, 0 }, { NULL, v_repend , "repend", 0, 0 }, { NULL, v_echo , "echo", 0, 0 }, { NULL, v_processor,"processor", 0, 0 }, NULL }; SHAR_EOF if test 3208 -ne "`wc -c globals.c`" then echo shar: error transmitting globals.c '(should have been 3208 characters)' fi echo shar: extracting main.c '(17019 characters)' cat << \SHAR_EOF > main.c /* * MAIN.C * * DASM sourcefile * * NOTE: must handle mnemonic extensions and expression decode/compare. */ #include "asm.h" #define MAXLINE 256 #define ISEGNAME "code" extern uword hash1(); extern MNE *findmne(); extern MNE Ops[]; extern void findext(), cleanup(); extern void clearsegs(), clearrefs(); extern SYMBOL *eval(); uword _fmode = 0; /* was trying to port to 16 bit IBM-PC lattice C */ /* but failed */ ubyte Disable_me; ubyte StopAtEnd = 0; ubyte *Extstr; main(ac, av) ubyte *av[]; { ubyte buf[MAXLINE]; uword pass, i; register ubyte *ptr; register MNE *mne; register ulong oldredo = -1; register ulong oldwhy = 0; register ulong oldeval = 0; addhashtable(Ops); pass = 1; if (ac < 2) { fail: puts("DASM V2.00, high level Macro Assembler"); puts("(C)Copyright 1988 by Matthew Dillon, All Rights Reserved"); puts("redistributable for non-profit only"); puts(""); puts("ASM65 sourcefile [options]"); puts(" -f# output format"); puts(" -oname output file"); puts(" -lname list file"); puts(" -sname symbol dump"); puts(" -v# verboseness"); puts(" -Dname=exp define label"); exit(1); } printf("DASM V2.00, (c)Copyright 1988 Matthew Dillon, All Rights Reserved\n"); for (i = 2; i < ac; ++i) { if (av[i][0] == '-') { register ubyte *str = av[i]+2; switch(av[i][1]) { case 'd': Xdebug = atoi(str); break; case 'D': while (*str && *str != '=') ++str; if (*str == '=') { *str = 0; ++str; } else { str = (ubyte *)"0"; } Av[0] = av[i]+2; v_set(str); break; case 'f': /* F_format */ F_format = atoi(str); if (F_format < 1 || F_format > 3) panic("Illegal format specification"); break; case 'o': /* F_outfile */ F_outfile = (char *)str; nofile: if (*str == 0) panic("need file name for specified option"); break; case 'l': /* F_listfile */ F_listfile = (char *)str; goto nofile; case 's': /* F_symfile */ F_symfile = (char *)str; goto nofile; case 'v': /* F_verbose */ F_verbose = atoi(str); break; case 't': /* F_temppath */ F_temppath = (char *)str; break; default: goto fail; } continue; } goto fail; } /* INITIAL SEGMENT */ { register SEGMENT *seg = (SEGMENT *)permalloc(sizeof(SEGMENT)); seg->name = strcpy(permalloc(sizeof(ISEGNAME)), ISEGNAME); seg->flags= seg->rflags = seg->initflags = seg->initrflags = SF_UNKNOWN; Csegment = Seglist = seg; } /* TOP LEVEL IF */ { register IFSTACK *ifs = (IFSTACK *)zmalloc(sizeof(IFSTACK)); ifs->file = -1; ifs->flags = IFF_BASE; ifs->acctrue = 1; ifs->true = 1; Ifstack = ifs; } nextpass: Localindex = Lastlocalindex = 0; _fmode = 0x8000; FI_temp = fopen(F_outfile, "w"); _fmode = 0; Fisclear = 1; if (FI_temp == NULL) { printf("unable to [re]open '%s'\n", F_outfile); exit(1); } if (F_listfile) { FI_listfile = fopen(F_listfile, "w"); if (FI_listfile == NULL) { printf("unable to [re]open '%s'\n", F_listfile); exit(1); } } pushinclude(av[1]); while (Incfile) { for (;;) { if (Incfile->flags & INF_MACRO) { if (Incfile->strlist == NULL) { Av[0] = (ubyte *)""; v_mexit(); continue; } strcpy(buf, Incfile->strlist->buf); Incfile->strlist = Incfile->strlist->next; } else { if (fgets(buf, MAXLINE, Incfile->fi) == NULL) break; } cleanup(buf); ++Incfile->lineno; parse(buf); if (Av[1][0]) { findext(Av[1]); if (mne = findmne(Av[1])) { if ((mne->flags & MF_IF) || (Ifstack->true && Ifstack->acctrue)) (*mne->vect)(Av[2], mne); } else { if (Ifstack->true && Ifstack->acctrue) { printf("unknown mnemonic: '%s'\n", Av[1]); asmerr(4,0); } } } else { if (Ifstack->true && Ifstack->acctrue) programlabel(); } if (F_listfile) outlistfile(); } while (Reploop && Reploop->file == Incfile) rmnode(&Reploop, sizeof(REPLOOP)); while (Ifstack->file == Incfile) rmnode(&Ifstack, sizeof(IFSTACK)); fclose(Incfile->fi); free(Incfile->name); --Inclevel; rmnode(&Incfile, sizeof(INCFILE)); if (Incfile) { /* if (F_verbose > 1) printf("back to: %s\n", Incfile->name); */ if (F_listfile) fprintf(FI_listfile, "------- FILE %s\n", Incfile->name); } } if (F_verbose >= 1) { SEGMENT *seg; char *bss; puts(""); printf("END OF PASS: %d\n", pass); puts("Segment--- init-pc init-rpc finl-pc finl-rpc"); for (seg = Seglist; seg; seg = seg->next) { bss = (seg->flags & SF_BSS) ? "[u]" : " "; printf("%10s %3s ", seg->name, bss); printf("%s %s ", sftos(seg->initorg, seg->initflags), sftos(seg->initrorg, seg->initrflags)); printf("%s %s\n", sftos(seg->org, seg->flags), sftos(seg->rorg, seg->rflags)); } printf("Reasons: %4ld,%4ld Reasoncode: %08lx\n", Redo, Redo_eval, Redo_why); } if (F_verbose >= 3) { SYMBOL *sym; short i; if (F_verbose == 3) puts("SYMBOLIST: (Unreferenced and unresolved symbols only)"); else puts("SYMBOLIST"); for (i = 0; i < SHASHSIZE; ++i) { for (sym = SHash[i]; sym; sym = sym->next) { if (F_verbose > 3 || (sym->flags & SYM_UNKNOWN) || !(sym->flags & SYM_MASREF)) printf("%10s %s\n", sym->name, sftos(sym->value, sym->flags)); } } puts("ENDSYMBOLIST"); } closegenerate(); fclose(FI_temp); if (FI_listfile) fclose(FI_listfile); if (Redo) { if (Redo == oldredo && Redo_why == oldwhy && Redo_eval == oldeval) { puts("Error: source is not resolvable."); if (F_verbose < 2) puts("re-run with verbose option 2 or higher to determine problem"); exit(1); } oldredo = Redo; oldwhy = Redo_why; oldeval = Redo_eval; Redo = 0; Redo_why = 0; Redo_eval = 0; ++pass; if (StopAtEnd) { printf("Unrecoverable error in pass, aborting assembly!\n"); } else if (pass > 10) { printf("More than 10 passes, something *must* be wrong!\n"); exit(1); } else { clearrefs(); clearsegs(); goto nextpass; } } if (F_symfile) { FILE *fi = fopen(F_symfile, "w"); if (fi) { register SYMBOL *sym; puts("dumping symbols..."); for (i = 0; i < SHASHSIZE; ++i) { for (sym = SHash[i]; sym; sym = sym->next) { fprintf(fi, "%-15s %s", sym->name, sftos(sym->value, sym->flags)); if (sym->flags & SYM_STRING) fprintf(fi, " \"%s\"", sym->string); putc('\n', fi); } } fclose(fi); } else { printf("unable to open symbol dump file '%s'\n", F_symfile); } } } static outlistfile() { extern ubyte Gen[]; extern short Glen; char c = (Pflags & SF_BSS) ? 'U' : ' '; ubyte *ptr = Extstr; char dot; int i; dot = ' '; if (ptr) dot = '.'; else ptr = (ubyte *)""; fprintf(FI_listfile, "%5ld %c%s ", Incfile->lineno, c, sftos(Plab, Pflags & 7)); for (i = 0; i < Glen && i < 4; ++i) fprintf(FI_listfile, "%02x ", Gen[i]); for (; i < 4; ++i) fwrite(" ", 3, 1, FI_listfile); fprintf(FI_listfile, "%-10s %5s%c%-3s %s\n", Av[0], Av[1], dot, ptr, Av[2]); Glen = 0; Extstr = NULL; } ubyte * sftos(val, flags) long val; short flags; { static char buf[64]; static char c; register char *ptr = (c) ? buf : buf + 32; c = 1 - c; sprintf(ptr, "%04lx", val); if (flags & SYM_UNKNOWN) strcpy(ptr, "????"); if (flags & SYM_STRING) strcpy(ptr, "str "); if (flags & SYM_MACRO) strcpy(ptr, "eqm "); strcpy(ptr+4, " "); if (flags & (SYM_MASREF|SYM_SET)) { ptr[4] = '('; ptr[7] = ')'; } if (flags & (SYM_MASREF)) ptr[5] = 'r'; if (flags & (SYM_SET)) ptr[6] = 's'; return((ubyte *)ptr); } void clearsegs() { register SEGMENT *seg; for (seg = Seglist; seg; seg = seg->next) { seg->flags = (seg->flags & SF_BSS) | SF_UNKNOWN; seg->rflags= seg->initflags = seg->initrflags = SF_UNKNOWN; } } void clearrefs() { register SYMBOL *sym; register short i; for (i = 0; i < SHASHSIZE; ++i) for (sym = SHash[i]; sym; sym = sym->next) sym->flags &= ~SYM_REF; } void cleanup(buf) register ubyte *buf; { register ubyte *str; register STRLIST *strlist; register short arg, add; for (str = buf; *str; ++str) { switch(*str) { case '\n': case ';': goto br2; case TAB: *str = ' '; break; case '\'': ++str; if (*str == TAB) *str = ' '; if (*str == '\n' || *str == 0) { str[0] = ' '; str[1] = 0; } if (str[0] == ' ') str[0] = 0x80; break; case '\"': ++str; while (*str && *str != '\"') { if (*str == ' ') *str = 0x80; ++str; } if (*str != '\"') { asmerr(0,0); --str; } break; case '{': if (Disable_me) break; if (Xdebug) printf("macro tail: '%s'\n", str); arg = atoi(str+1); for (add = 0; *str && *str != '}'; ++str) --add; if (*str != '}') { puts("end brace required"); --str; break; } --add; ++str; if (Xdebug) printf("add/str: %d '%s'\n", add, str); for (strlist = Incfile->args; arg && strlist;) { --arg; strlist = strlist->next; } if (strlist) { add += strlen(strlist->buf); if (Xdebug) printf("strlist: '%s' %d\n", strlist->buf, strlen(strlist->buf)); if (str + add + strlen(str) + 1 > buf + MAXLINE) { if (Xdebug) printf("str %8ld buf %8ld (add/strlen(str)): %d %ld\n", str, buf, add, strlen(str)); panic("failure1"); } bmov(str, str + add, strlen(str)+1); str += add; if (str - strlen(strlist->buf) < buf) panic("failure2"); bmov(strlist->buf, str - strlen(strlist->buf), strlen(strlist->buf)); str -= strlen(strlist->buf); if (str < buf || str >= buf + MAXLINE) panic("failure 3"); --str; /* for loop increments string */ } else { asmerr(7,0); goto br2; } break; } } br2: while(str != buf && *(str-1) == ' ') --str; *str = 0; } panic(str) char *str; { puts(str); exit(1); } /* * .dir direct x * .ext extended x * .r relative x * .x index, no offset x * .x8 index, byte offset x * .x16 index, word offset x * .bit bit set/clr * .bbr bit and branch * .imp implied (inherent) x * .b x * .w x * .l x * .u x */ void findext(str) register ubyte *str; { Mnext = -1; Extstr = NULL; while (*str && *str != '.') ++str; if (*str) { *str = 0; ++str; Extstr = str; switch(str[0]|0x20) { case '0': case 'i': Mnext = AM_IMP; switch(str[1]|0x20) { case 'x': Mnext = AM_0X; break; case 'y': Mnext = AM_0Y; break; case 'n': Mnext = AM_INDWORD; break; } return; case 'd': case 'b': case 'z': switch(str[1]|0x20) { case 'x': Mnext = AM_BYTEADRX; break; case 'y': Mnext = AM_BYTEADRY; break; case 'i': Mnext = AM_BITMOD; break; case 'b': Mnext = AM_BITBRAMOD; break; default: Mnext = AM_BYTEADR; break; } return; case 'e': case 'w': case 'a': switch(str[1]|0x20) { case 'x': Mnext = AM_WORDADRX; break; case 'y': Mnext = AM_WORDADRY; break; default: Mnext = AM_WORDADR; break; } return; case 'l': Mnext = AM_LONG; return; case 'r': Mnext = AM_REL; return; case 'u': Mnext = AM_BSS; return; } } } /* * bytes arg will eventually be used to implement a linked list of free * nodes. */ rmnode(base, bytes) ulong **base; { ulong *node; if (node = *base) { *base = (ulong *)*node; free(node); } } /* * Parse into three arguments: Av[0], Av[1], Av[2] */ parse(buf) register ubyte *buf; { register short i, j; i = j = 0; Av[0] = Avbuf; while (buf[i] && buf[i] != ' ') { if (buf[i] == 0x80) buf[i] = ' '; Avbuf[j++] = buf[i++]; } Avbuf[j++] = 0; while (buf[i] == ' ') ++i; Av[1] = Avbuf + j; while (buf[i] && buf[i] != ' ') { if (buf[i] == 0x80) buf[i] = ' '; Avbuf[j++] = buf[i++]; } Avbuf[j++] = 0; while (buf[i] == ' ') ++i; Av[2] = Avbuf + j; while (buf[i]) { if (buf[i] == ' ') { while(buf[i+1] == ' ') ++i; } if (buf[i] == 0x80) buf[i] = ' '; Avbuf[j++] = buf[i++]; } Avbuf[j] = 0; } MNE * findmne(str) register ubyte *str; { register uword i; register ubyte c; register MNE *mne; ubyte buf[128]; for (i = 0; c = str[i]; ++i) { if (c >= 'A' && c <= 'Z') c += 'a' - 'A'; buf[i] = c; } buf[i] = 0; for (mne = MHash[hash1(buf)]; mne; mne = mne->next) { if (strcmp(buf, mne->name) == 0) break; } return(mne); } v_macro(str) char *str; { extern void v_execmac(); extern void v_endm(); STRLIST *base; ubyte defined = 0; register STRLIST **slp, *sl; register MACRO *mac; register MNE *mne; register uword i; ubyte buf[MAXLINE]; ubyte skipit = !(Ifstack->true && Ifstack->acctrue); if (skipit) { defined = 1; } else { defined = (findmne(str) != NULL); if (F_listfile) outlistfile(); } if (!defined) { base = NULL; slp = &base; mac = (MACRO *)permalloc(sizeof(MACRO)); i = hash1(str); mac->next = (void *)MHash[i]; mac->vect = v_execmac; mac->name = strcpy(permalloc(strlen(str)+1), str); mac->flags = MF_MACRO; MHash[i] = (void *)mac; } while (fgets(buf, MAXLINE, Incfile->fi)) { ++Incfile->lineno; Disable_me = 1; cleanup(buf); Disable_me = 0; if (parse(buf) >= 2) { findext(Av[1]); mne = findmne(Av[1]); if (mne->vect == v_endm) { if (!defined) mac->strlist = base; return; } } if (!skipit && F_listfile) outlistfile(); if (!defined) { sl = (STRLIST *)permalloc(5+strlen(buf)); strcpy(sl->buf, buf); *slp = sl; slp = &sl->next; } } asmerr(8,1); } addhashtable(mne) MNE *mne; { register uword i, j; ubyte opcode[NUMOC]; for (; mne->vect; ++mne) { bmov(mne->opcode, opcode, NUMOC); for (i = j = 0; i < NUMOC; ++i) { mne->opcode[i] = 0; /* not really needed */ if (mne->okmask & (1 << i)) mne->opcode[i] = opcode[j++]; } i = hash1(mne->name); mne->next = MHash[i]; MHash[i] = mne; } } static uword hash1(str) register ubyte *str; { register uword result = 0; while (*str) result = (result << 2) ^ *str++; return(result & MHASHAND); } pushinclude(str) char *str; { register INCFILE *inf; register FILE *fi; if (fi = fopen(str, "r")) { if (F_verbose > 1) printf("%.*sInclude: %s\n", Inclevel*4, "", str); ++Inclevel; if (F_listfile) fprintf(FI_listfile, "------- FILE %s\n", str); inf = (INCFILE *)zmalloc(sizeof(INCFILE)); inf->next = Incfile; inf->name = strcpy(malloc(strlen(str)+1), str); inf->fi = fi; inf->lineno = 0; Incfile = inf; return(1); } printf("unable to open %s\n", str); } char Stopend[] = { 1,1,1,1,1,1,1,1,1,1,0,1,1,0,1,1,1,0,0,1,1 }; char *Errors[] = { "Syntax Error", "Expression table overflow", "Unbalanced Braces []", "Division by zero", "Unknown Mnemonic", "Illegal Addressing mode", "Illegal forced Addressing mode", /* nu */ "Not enough args passed to Macro", "Premature EOF", "Illegal character", "Branch out of range", "ERR pseudo-op encountered", "Origin Reverse-indexed", /* 12 */ "EQU: Value mismatch", "Address must be <$100", /* nu */ "Illegal bit specification", "Not enough args", /* 16 */ "Label Mismatch", /* 17 */ "Value Undefined", "Illegal Forced Address mode", /* 19 */ "Processor not supported", /* 20 */ NULL }; asmerr(err, abort) short err, abort; { ubyte *ptr; ubyte *str; INCFILE *incfile; if (Stopend[err]) StopAtEnd = 1; for (incfile = Incfile; incfile->flags & INF_MACRO; incfile=incfile->next); str = (ubyte *)Errors[err]; if (F_listfile) fprintf(FI_listfile, "*line %4ld %-10s %s\n", incfile->lineno, incfile->name, str); printf("line %4ld %-10s %s\n", incfile->lineno, incfile->name, str); if (abort) { puts("Aborting assembly"); if (F_listfile) fputs("Aborting assembly\n", FI_listfile); exit(1); } } ubyte * zmalloc(bytes) uword bytes; { ubyte *ptr = malloc(bytes); if (ptr) { bzero(ptr, bytes); return(ptr); } panic("unable to malloc"); } ubyte * permalloc(bytes) uword bytes; { static ubyte *buf; static int left; ubyte *ptr; bytes = (bytes + 1) & ~1; if (bytes > left) { if ((buf = malloc(ALLOCSIZE)) == NULL) panic("unable to malloc"); bzero(buf, ALLOCSIZE); left = ALLOCSIZE; if (bytes > left) panic("software error"); } ptr = buf; buf += bytes; left -= bytes; return(ptr); } SHAR_EOF if test 17019 -ne "`wc -c main.c`" then echo shar: error transmitting main.c '(should have been 17019 characters)' fi echo shar: extracting mne6303.c '(9140 characters)' cat << \SHAR_EOF > mne6303.c #include "asm.h" extern void v_mnemonic(); /* * IMP IMM8 IMM16 BYTE BYTEX BYTEY WORD WORDX WORDY REL (,x) (),y (WORD) * 0 1 2 3 4 5 6 7 8 9 10 11 12 * * 0,x 0,y BIT BITBRA * 13 14 15 16 */ MNE Mne6803[] = { { NULL, v_mnemonic, "aba", 0, AF_IMP, { 0x1B }}, { NULL, v_mnemonic, "abx", 0, AF_IMP, { 0x3A }}, { NULL, v_mnemonic, "adca", 0, AF_IMM8|AF_BYTEADR|AF_BYTEADRX|AF_WORDADR, { 0x89, 0x99, 0xA9, 0xB9 }}, { NULL, v_mnemonic, "adcb", 0, AF_IMM8|AF_BYTEADR|AF_BYTEADRX|AF_WORDADR, { 0xC9, 0xD9, 0xE9, 0xF9 }}, { NULL, v_mnemonic, "adda", 0, AF_IMM8|AF_BYTEADR|AF_BYTEADRX|AF_WORDADR, { 0x8B, 0x9B, 0xAB, 0xBB }}, { NULL, v_mnemonic, "addb", 0, AF_IMM8|AF_BYTEADR|AF_BYTEADRX|AF_WORDADR, { 0xCB, 0xDB, 0xEB, 0xFB }}, { NULL, v_mnemonic, "addd", 0, AF_IMM16|AF_BYTEADR|AF_BYTEADRX|AF_WORDADR, { 0xC3, 0xD3, 0xE3, 0xF3 }}, { NULL, v_mnemonic, "anda", 0, AF_IMM8|AF_BYTEADR|AF_BYTEADRX|AF_WORDADR, { 0x84, 0x94, 0xA4, 0xB4 }}, { NULL, v_mnemonic, "andb", 0, AF_IMM8|AF_BYTEADR|AF_BYTEADRX|AF_WORDADR, { 0xC4, 0xD4, 0xE4, 0xF4 }}, { NULL, v_mnemonic, "bita", 0, AF_IMM8|AF_BYTEADR|AF_BYTEADRX|AF_WORDADR, { 0x85, 0x95, 0xA5, 0xB5 }}, { NULL, v_mnemonic, "bitb", 0, AF_IMM8|AF_BYTEADR|AF_BYTEADRX|AF_WORDADR, { 0xC5, 0xD5, 0xE5, 0xF5 }}, { NULL, v_mnemonic, "bra", 0, AF_REL, { 0x20 }}, { NULL, v_mnemonic, "brn", 0, AF_REL, { 0x21 }}, { NULL, v_mnemonic, "bcc", 0, AF_REL, { 0x24 }}, { NULL, v_mnemonic, "bcs", 0, AF_REL, { 0x25 }}, { NULL, v_mnemonic, "beq", 0, AF_REL, { 0x27 }}, { NULL, v_mnemonic, "bge", 0, AF_REL, { 0x2C }}, { NULL, v_mnemonic, "bgt", 0, AF_REL, { 0x2E }}, { NULL, v_mnemonic, "bhi", 0, AF_REL, { 0x22 }}, { NULL, v_mnemonic, "ble", 0, AF_REL, { 0x2F }}, { NULL, v_mnemonic, "bls", 0, AF_REL, { 0x23 }}, { NULL, v_mnemonic, "blt", 0, AF_REL, { 0x2D }}, { NULL, v_mnemonic, "bmi", 0, AF_REL, { 0x2B }}, { NULL, v_mnemonic, "bne", 0, AF_REL, { 0x26 }}, { NULL, v_mnemonic, "bvc", 0, AF_REL, { 0x28 }}, { NULL, v_mnemonic, "bvs", 0, AF_REL, { 0x29 }}, { NULL, v_mnemonic, "bpl", 0, AF_REL, { 0x2A }}, { NULL, v_mnemonic, "bsr", 0, AF_REL, { 0x8D }}, { NULL, v_mnemonic, "clc", 0, AF_IMP, { 0x0C }}, { NULL, v_mnemonic, "cli", 0, AF_IMP, { 0x0E }}, { NULL, v_mnemonic, "clv", 0, AF_IMP, { 0x0A }}, { NULL, v_mnemonic, "sec", 0, AF_IMP, { 0x0D }}, { NULL, v_mnemonic, "sei", 0, AF_IMP, { 0x0F }}, { NULL, v_mnemonic, "sev", 0, AF_IMP, { 0x0B }}, { NULL, v_mnemonic, "tap", 0, AF_IMP, { 0x06 }}, { NULL, v_mnemonic, "tpa", 0, AF_IMP, { 0x07 }}, { NULL, v_mnemonic, "clr", 0, AF_BYTEADRX|AF_WORDADR, { 0x6F, 0x7F }}, { NULL, v_mnemonic, "clra", 0, AF_IMP, { 0x4F }}, { NULL, v_mnemonic, "clrb", 0, AF_IMP, { 0x5F }}, { NULL, v_mnemonic, "cmpa", 0, AF_IMM8|AF_BYTEADR|AF_BYTEADRX|AF_WORDADR, { 0x81, 0x91, 0xA1, 0xB1 }}, { NULL, v_mnemonic, "cmpb", 0, AF_IMM8|AF_BYTEADR|AF_BYTEADRX|AF_WORDADR, { 0xC1, 0xD1, 0xE1, 0xF1 }}, { NULL, v_mnemonic, "cba", 0, AF_IMP, { 0x11 }}, { NULL, v_mnemonic, "com", 0, AF_BYTEADRX|AF_WORDADR, { 0x63, 0x73 }}, { NULL, v_mnemonic, "coma", 0, AF_IMP, { 0x43 }}, { NULL, v_mnemonic, "comb", 0, AF_IMP, { 0x53 }}, { NULL, v_mnemonic, "neg", 0, AF_BYTEADRX|AF_WORDADR, { 0x60, 0x70 }}, { NULL, v_mnemonic, "nega", 0, AF_IMP, { 0x40 }}, { NULL, v_mnemonic, "negb", 0, AF_IMP, { 0x50 }}, { NULL, v_mnemonic, "daa", 0, AF_IMP, { 0x19 }}, { NULL, v_mnemonic, "dec", 0, AF_BYTEADRX|AF_WORDADR, { 0x6A, 0x7A }}, { NULL, v_mnemonic, "deca", 0, AF_IMP, { 0x4A }}, { NULL, v_mnemonic, "decb", 0, AF_IMP, { 0x5A }}, { NULL, v_mnemonic, "eora", 0, AF_IMM8|AF_BYTEADR|AF_BYTEADRX|AF_WORDADR, { 0x88, 0x98, 0xA8, 0xB8 }}, { NULL, v_mnemonic, "eorb", 0, AF_IMM8|AF_BYTEADR|AF_BYTEADRX|AF_WORDADR, { 0xC8, 0xD8, 0xE8, 0xF8 }}, { NULL, v_mnemonic, "inc", 0, AF_BYTEADRX|AF_WORDADR, { 0x6C, 0x7C }}, { NULL, v_mnemonic, "inca", 0, AF_IMP, { 0x4C }}, { NULL, v_mnemonic, "incb", 0, AF_IMP, { 0x5C }}, { NULL, v_mnemonic, "jmp", 0, AF_BYTEADRX|AF_WORDADR, { 0x6E, 0x7E }}, { NULL, v_mnemonic, "jsr", 0, AF_BYTEADR|AF_BYTEADRX|AF_WORDADR, { 0x9D, 0xAD, 0xBD }}, { NULL, v_mnemonic, "ldaa", 0, AF_IMM8|AF_BYTEADR|AF_BYTEADRX|AF_WORDADR, { 0x86, 0x96, 0xA6, 0xB6 }}, { NULL, v_mnemonic, "ldab", 0, AF_IMM8|AF_BYTEADR|AF_BYTEADRX|AF_WORDADR, { 0xC6, 0xD6, 0xE6, 0xF6 }}, { NULL, v_mnemonic, "ldd", 0, AF_IMM16|AF_BYTEADR|AF_BYTEADRX|AF_WORDADR, { 0xCC, 0xDC, 0xEC, 0xFC }}, { NULL, v_mnemonic, "mul", 0, AF_IMP, { 0x3D }}, { NULL, v_mnemonic, "nop", 0, AF_IMP, { 0x01 }}, { NULL, v_mnemonic, "oraa",0, AF_IMM8|AF_BYTEADR|AF_BYTEADRX|AF_WORDADR, { 0x8A, 0x9A, 0xAA, 0xBA }}, { NULL, v_mnemonic, "orab", 0, AF_IMM8|AF_BYTEADR|AF_BYTEADRX|AF_WORDADR, { 0xCA, 0xDA, 0xEA, 0xFA }}, { NULL, v_mnemonic, "psha", 0, AF_IMP, { 0x36 }}, { NULL, v_mnemonic, "pshb", 0, AF_IMP, { 0x37 }}, { NULL, v_mnemonic, "pshx", 0, AF_IMP, { 0x3C }}, { NULL, v_mnemonic, "pulx", 0, AF_IMP, { 0x38 }}, { NULL, v_mnemonic, "pula", 0, AF_IMP, { 0x32 }}, { NULL, v_mnemonic, "pulb", 0, AF_IMP, { 0x33 }}, { NULL, v_mnemonic, "rol", 0, AF_BYTEADRX|AF_WORDADR, { 0x69, 0x79 }}, { NULL, v_mnemonic, "rola", 0, AF_IMP, { 0x49 }}, { NULL, v_mnemonic, "rolb", 0, AF_IMP, { 0x59 }}, { NULL, v_mnemonic, "ror", 0, AF_BYTEADRX|AF_WORDADR, { 0x66, 0x76 }}, { NULL, v_mnemonic, "rora", 0, AF_IMP, { 0x46 }}, { NULL, v_mnemonic, "rorb", 0, AF_IMP, { 0x56 }}, { NULL, v_mnemonic, "rti", 0, AF_IMP, { 0x3B }}, { NULL, v_mnemonic, "rts", 0, AF_IMP, { 0x39 }}, { NULL, v_mnemonic, "swi", 0, AF_IMP, { 0x3F }}, { NULL, v_mnemonic, "wai", 0, AF_IMP, { 0x3E }}, { NULL, v_mnemonic, "asl", 0, AF_BYTEADRX|AF_WORDADR, { 0x68, 0x78 }}, { NULL, v_mnemonic, "asla", 0, AF_IMP, { 0x48 }}, { NULL, v_mnemonic, "aslb", 0, AF_IMP, { 0x58 }}, { NULL, v_mnemonic, "asld", 0, AF_IMP, { 0x05 }}, { NULL, v_mnemonic, "asr", 0, AF_BYTEADRX|AF_WORDADR, { 0x67, 0x77 }}, { NULL, v_mnemonic, "asra", 0, AF_IMP, { 0x47 }}, { NULL, v_mnemonic, "asrb", 0, AF_IMP, { 0x57 }}, { NULL, v_mnemonic, "cpx", 0, AF_IMM16|AF_BYTEADR|AF_BYTEADRX|AF_WORDADR, { 0x8C, 0x9C, 0xAC, 0xBC }}, { NULL, v_mnemonic, "dex", 0, AF_IMP, { 0x09 }}, { NULL, v_mnemonic, "des", 0, AF_IMP, { 0x34 }}, { NULL, v_mnemonic, "inx", 0, AF_IMP, { 0x08 }}, { NULL, v_mnemonic, "ins", 0, AF_IMP, { 0x31 }}, { NULL, v_mnemonic, "ldx", 0, AF_IMM16|AF_BYTEADR|AF_BYTEADRX|AF_WORDADR, { 0xCE, 0xDE, 0xEE, 0xFE }}, { NULL, v_mnemonic, "lds", 0, AF_IMM16|AF_BYTEADR|AF_BYTEADRX|AF_WORDADR, { 0x8E, 0x9E, 0xAE, 0xBE }}, { NULL, v_mnemonic, "lsr", 0, AF_BYTEADRX|AF_WORDADR, { 0x64, 0x74 }}, { NULL, v_mnemonic, "lsra", 0, AF_IMP, { 0x44 }}, { NULL, v_mnemonic, "lsrb", 0, AF_IMP, { 0x54 }}, { NULL, v_mnemonic, "lsrd", 0, AF_IMP, { 0x04 }}, { NULL, v_mnemonic, "staa", 0, AF_BYTEADR|AF_BYTEADRX|AF_WORDADR, { 0x97, 0xA7, 0xB7 }}, { NULL, v_mnemonic, "stab", 0, AF_BYTEADR|AF_BYTEADRX|AF_WORDADR, { 0xD7, 0xE7, 0xF7 }}, { NULL, v_mnemonic, "std", 0, AF_BYTEADR|AF_BYTEADRX|AF_WORDADR, { 0xDD, 0xED, 0xFD }}, { NULL, v_mnemonic, "sts", 0, AF_BYTEADR|AF_BYTEADRX|AF_WORDADR, { 0x9F, 0xAF, 0xBF }}, { NULL, v_mnemonic, "stx", 0, AF_BYTEADR|AF_BYTEADRX|AF_WORDADR, { 0xDF, 0xEF, 0xFF }}, { NULL, v_mnemonic, "suba", 0, AF_IMM8|AF_BYTEADR|AF_BYTEADRX|AF_WORDADR, { 0x80, 0x90, 0xA0, 0xB0 }}, { NULL, v_mnemonic, "subb", 0, AF_IMM8|AF_BYTEADR|AF_BYTEADRX|AF_WORDADR, { 0xC0, 0xD0, 0xE0, 0xF0 }}, { NULL, v_mnemonic, "subd", 0, AF_IMM16|AF_BYTEADR|AF_BYTEADRX|AF_WORDADR, { 0x83, 0x93, 0xA3, 0xB3 }}, { NULL, v_mnemonic, "sba", 0, AF_IMP, { 0x10 }}, { NULL, v_mnemonic, "sbca", 0, AF_IMM8|AF_BYTEADR|AF_BYTEADRX|AF_WORDADR, { 0x82, 0x92, 0xA2, 0xB2 }}, { NULL, v_mnemonic, "sbcb", 0, AF_IMM8|AF_BYTEADR|AF_BYTEADRX|AF_WORDADR, { 0xC2, 0xD2, 0xE2, 0xF2 }}, { NULL, v_mnemonic, "tab", 0, AF_IMP, { 0x16 }}, { NULL, v_mnemonic, "tba", 0, AF_IMP, { 0x17 }}, { NULL, v_mnemonic, "tst", 0, AF_BYTEADRX|AF_WORDADR, { 0x6D, 0x7D }}, { NULL, v_mnemonic, "tsta", 0, AF_IMP, { 0x4D }}, { NULL, v_mnemonic, "tstb", 0, AF_IMP, { 0x5D }}, { NULL, v_mnemonic, "tsx", 0, AF_IMP, { 0x30 }}, { NULL, v_mnemonic, "txs", 0, AF_IMP, { 0x35 }}, NULL }; MNE MneHD6303[] = { { NULL, v_mnemonic, "slp", 0, AF_IMP, { 0x1A }}, { NULL, v_mnemonic, "aim", 0, AF_BYTEADR|AF_BYTEADRX, { 0x71, 0x61 }}, { NULL, v_mnemonic, "oim", 0, AF_BYTEADR|AF_BYTEADRX, { 0x72, 0x62 }}, { NULL, v_mnemonic, "eim", 0, AF_BYTEADR|AF_BYTEADRX, { 0x75, 0x65 }}, { NULL, v_mnemonic, "tim", 0, AF_BYTEADR|AF_BYTEADRX, { 0x7B, 0x6B }}, { NULL, v_mnemonic, "xgdx", 0, AF_IMP, { 0x18 }}, NULL }; SHAR_EOF if test 9140 -ne "`wc -c mne6303.c`" then echo shar: error transmitting mne6303.c '(should have been 9140 characters)' fi echo shar: extracting mne6502.c '(4166 characters)' cat << \SHAR_EOF > mne6502.c #include "asm.h" extern void v_mnemonic(); #define ASTD AF_BYTEADR|AF_BYTEADRX|AF_WORDADR|AF_WORDADRX|\ AF_WORDADRY|AF_INDBYTEX|AF_INDBYTEY MNE Mne6502[] = { NULL, v_mnemonic, "adc", 0, AF_IMM8|ASTD, { 0x69, 0x65, 0x75, 0x6D, 0x7D, 0x79, 0x61, 0x71 }, NULL, v_mnemonic, "and", 0, AF_IMM8|ASTD, { 0x29, 0x25, 0x35, 0x2D, 0x3D, 0x39, 0x21, 0x31 }, NULL, v_mnemonic, "asl", 0, AF_IMP|AF_BYTEADR|AF_BYTEADRX|AF_WORDADR|AF_WORDADRX, { 0x0A, 0x06, 0x16, 0x0E, 0x1E }, NULL, v_mnemonic, "bcc", 0, AF_REL, { 0x90 }, NULL, v_mnemonic, "bcs", 0, AF_REL, { 0xB0 }, NULL, v_mnemonic, "beq", 0, AF_REL, { 0xF0 }, NULL, v_mnemonic, "bit", 0, AF_BYTEADR|AF_WORDADR, { 0x24, 0x2C }, NULL, v_mnemonic, "bmi", 0, AF_REL, { 0x30 }, NULL, v_mnemonic, "bne", 0, AF_REL, { 0xD0 }, NULL, v_mnemonic, "bpl", 0, AF_REL, { 0x10 }, NULL, v_mnemonic, "brk", 0, AF_IMP, { 0x00 }, NULL, v_mnemonic, "bvc", 0, AF_REL, { 0x50 }, NULL, v_mnemonic, "bvs", 0, AF_REL, { 0x70 }, NULL, v_mnemonic, "clc", 0, AF_IMP, { 0x18 }, NULL, v_mnemonic, "cld", 0, AF_IMP, { 0xD8 }, NULL, v_mnemonic, "cli", 0, AF_IMP, { 0x58 }, NULL, v_mnemonic, "clv", 0, AF_IMP, { 0xB8 }, NULL, v_mnemonic, "cmp", 0, AF_IMM8|ASTD, { 0xC9, 0xC5, 0xD5, 0xCD, 0xDD, 0xD9, 0xC1, 0xD1 }, NULL, v_mnemonic, "cpx", 0, AF_IMM8|AF_BYTEADR|AF_WORDADR, { 0xE0, 0xE4, 0xEC }, NULL, v_mnemonic, "cpy", 0, AF_IMM8|AF_BYTEADR|AF_WORDADR, { 0xC0, 0xC4, 0xCC }, NULL, v_mnemonic, "dec", 0, AF_BYTEADR|AF_BYTEADRX|AF_WORDADR|AF_WORDADRX, { 0xC6, 0xD6, 0xCE, 0xDE }, NULL, v_mnemonic, "dex", 0, AF_IMP, { 0xCA }, NULL, v_mnemonic, "dey", 0, AF_IMP, { 0x88 }, NULL, v_mnemonic, "eor", 0, AF_IMM8|ASTD, { 0x49, 0x45, 0x55, 0x4D, 0x5D, 0x59, 0x41,0x51 }, NULL, v_mnemonic, "inc", 0, AF_BYTEADR|AF_BYTEADRX|AF_WORDADR|AF_WORDADRX, { 0xE6, 0xF6, 0xEE, 0xFE }, NULL, v_mnemonic, "inx", 0, AF_IMP, { 0xE8 }, NULL, v_mnemonic, "iny", 0, AF_IMP, { 0xC8 }, NULL, v_mnemonic, "jmp", 0, AF_WORDADR|AF_INDWORD, { 0x4C, 0x6C }, NULL, v_mnemonic, "jsr", 0, AF_WORDADR, { 0x20 }, NULL, v_mnemonic, "lda", 0, AF_IMM8|ASTD, { 0xA9, 0xA5, 0xB5, 0xAD, 0xBD, 0xB9, 0xA1, 0xB1 }, NULL, v_mnemonic, "ldx", 0, AF_IMM8|AF_BYTEADR|AF_BYTEADRY|AF_WORDADR|AF_WORDADRY, { 0xA2, 0xA6, 0xB6, 0xAE, 0xBE }, NULL, v_mnemonic, "ldy", 0, AF_IMM8|AF_BYTEADR|AF_BYTEADRX|AF_WORDADR|AF_WORDADRX, { 0xA0, 0xA4, 0xB4, 0xAC, 0xBC }, NULL, v_mnemonic, "lsr", 0, AF_IMP|AF_BYTEADR|AF_BYTEADRX|AF_WORDADR|AF_WORDADRX, { 0x4A, 0x46, 0x56, 0x4E, 0x5E }, NULL, v_mnemonic, "nop", 0, AF_IMP, { 0xEA }, NULL, v_mnemonic, "ora", 0, AF_IMM8|ASTD, { 0x09, 0x05, 0x15, 0x0D, 0x1D, 0x19, 0x01, 0x11 }, NULL, v_mnemonic, "pha", 0, AF_IMP, { 0x48 }, NULL, v_mnemonic, "php", 0, AF_IMP, { 0x08 }, NULL, v_mnemonic, "pla", 0, AF_IMP, { 0x68 }, NULL, v_mnemonic, "plp", 0, AF_IMP, { 0x28 }, NULL, v_mnemonic, "rol", 0, AF_IMP|AF_BYTEADR|AF_BYTEADRX|AF_WORDADR|AF_WORDADRX, { 0x2A, 0x26, 0x36, 0x2E, 0x3E }, NULL, v_mnemonic, "ror", 0, AF_IMP|AF_BYTEADR|AF_BYTEADRX|AF_WORDADR|AF_WORDADRX, { 0x6A, 0x66, 0x76, 0x6E, 0x7E }, NULL, v_mnemonic, "rti", 0, AF_IMP, { 0x40 }, NULL, v_mnemonic, "rts", 0, AF_IMP, { 0x60 }, NULL, v_mnemonic, "sbc", 0, AF_IMM8|ASTD, { 0xE9, 0xE5, 0xF5, 0xED, 0xFD, 0xF9, 0xE1, 0xF1 }, NULL, v_mnemonic, "sec", 0, AF_IMP, { 0x38 }, NULL, v_mnemonic, "sed", 0, AF_IMP, { 0xF8 }, NULL, v_mnemonic, "sei", 0, AF_IMP, { 0x78 }, NULL, v_mnemonic, "sta", 0, ASTD, { 0x85, 0x95, 0x8D, 0x9D, 0x99, 0x81, 0x91 }, NULL, v_mnemonic, "stx", 0, AF_BYTEADR|AF_BYTEADRY|AF_WORDADR, { 0x86, 0x96, 0x8E }, NULL, v_mnemonic, "sty", 0, AF_BYTEADR|AF_BYTEADRX|AF_WORDADR, { 0x84, 0x94, 0x8C }, NULL, v_mnemonic, "tax", 0, AF_IMP, { 0xAA }, NULL, v_mnemonic, "tay", 0, AF_IMP, { 0xA8 }, NULL, v_mnemonic, "tsx", 0, AF_IMP, { 0xBA }, NULL, v_mnemonic, "txa", 0, AF_IMP, { 0x8A }, NULL, v_mnemonic, "txs", 0, AF_IMP, { 0x9A }, NULL, v_mnemonic, "tya", 0, AF_IMP, { 0x98 }, NULL }; SHAR_EOF if test 4166 -ne "`wc -c mne6502.c`" then echo shar: error transmitting mne6502.c '(should have been 4166 characters)' fi # End of shell archive exit 0