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 2 of 2) Message-ID: <6391@j.cc.purdue.edu> Date: 8 Feb 88 23:42:09 GMT Organization: PUCC Land, USA Lines: 1997 Keywords: dasm, cross assembler, untested, part 2 of 2. Approved: ain@j.cc.purdue.edu (Pat White) Program Name: dasm (part 2 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 test compile this. -- 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: # mne6811.c # mne68705.c # ops.c # suite6303.asm # suite6502.asm # suite68705.asm # symbols.c # This archive created: Mon Feb 8 13:17:15 1988 # By: Patrick White (PUCC Land, USA) echo shar: extracting mne6811.c '(52 characters)' cat << \SHAR_EOF > mne6811.c #include "asm.h" MNE Mne68HC11[] = { NULL }; SHAR_EOF if test 52 -ne "`wc -c mne6811.c`" then echo shar: error transmitting mne6811.c '(should have been 52 characters)' fi echo shar: extracting mne68705.c '(5699 characters)' cat << \SHAR_EOF > mne68705.c #include "asm.h" #define AFSTD AF_BYTEADR|AF_BYTEADRX|AF_WORDADR|AF_WORDADRX|AF_0X extern void v_mnemonic(); MNE Mne68705[] = { NULL, v_mnemonic, "adc", 0, AF_IMM8|AFSTD, { 0xA9, 0xB9, 0xE9, 0xC9, 0xD9, 0xF9 }, NULL, v_mnemonic, "add", 0, AF_IMM8|AFSTD, { 0xAB, 0xBB, 0xEB, 0xCB, 0xDB, 0xFB }, NULL, v_mnemonic, "and", 0, AF_IMM8|AFSTD, { 0xA4, 0xB4, 0xE4, 0xC4, 0xD4, 0xF4 }, NULL, v_mnemonic, "asl", 0, AF_IMP|AF_BYTEADR|AF_BYTEADRX|AF_0X, { 0x48, 0x38, 0x68, 0x78 }, NULL, v_mnemonic, "asla", 0,AF_IMP, { 0x48 }, NULL, v_mnemonic, "aslx", 0,AF_IMP, { 0x58 }, NULL, v_mnemonic, "asr", 0, AF_IMP|AF_BYTEADR|AF_BYTEADRX|AF_0X, { 0x47, 0x37, 0x67, 0x77 }, NULL, v_mnemonic, "asra", 0,AF_IMP, { 0x47 }, NULL, v_mnemonic, "asrx", 0,AF_IMP, { 0x57 }, NULL, v_mnemonic, "bcc", 0, AF_REL, { 0x24 }, NULL, v_mnemonic, "bclr", 0,AF_BITMOD, { 0x11 }, NULL, v_mnemonic, "bcs", 0, AF_REL, { 0x25 }, NULL, v_mnemonic, "beq", 0, AF_REL, { 0x27 }, NULL, v_mnemonic, "bhcc", 0,AF_REL, { 0x28 }, NULL, v_mnemonic, "bhcs", 0,AF_REL, { 0x29 }, NULL, v_mnemonic, "bhi", 0, AF_REL, { 0x22 }, NULL, v_mnemonic, "bhs", 0, AF_REL, { 0x24 }, NULL, v_mnemonic, "bih", 0, AF_REL, { 0x2F }, NULL, v_mnemonic, "bil", 0, AF_REL, { 0x2E }, NULL, v_mnemonic, "bit", 0, AF_IMM8|AFSTD, { 0xA5, 0xB5, 0xE5, 0xC5, 0xD5, 0xF5 }, NULL, v_mnemonic, "blo", 0, AF_REL, { 0x25 }, NULL, v_mnemonic, "bls", 0, AF_REL, { 0x23 }, NULL, v_mnemonic, "bmc", 0, AF_REL, { 0x2C }, NULL, v_mnemonic, "bmi", 0, AF_REL, { 0x2B }, NULL, v_mnemonic, "bms", 0, AF_REL, { 0x2D }, NULL, v_mnemonic, "bne", 0, AF_REL, { 0x26 }, NULL, v_mnemonic, "bpl", 0, AF_REL, { 0x2A }, NULL, v_mnemonic, "bra", 0, AF_REL, { 0x20 }, NULL, v_mnemonic, "brn", 0, AF_REL, { 0x21 }, NULL, v_mnemonic, "brclr", 0, AF_BITBRAMOD, { 0x01 }, NULL, v_mnemonic, "brset", 0, AF_BITBRAMOD, { 0x00 }, NULL, v_mnemonic, "bset", 0,AF_BITMOD, { 0x10 }, NULL, v_mnemonic, "bsr", 0, AF_REL, { 0xAD }, NULL, v_mnemonic, "clc", 0, AF_IMP, { 0x98 }, NULL, v_mnemonic, "cli", 0, AF_IMP, { 0x9A }, NULL, v_mnemonic, "clr", 0, AF_IMP|AF_BYTEADR|AF_BYTEADRX|AF_0X, { 0x4F, 0x3F, 0x6F, 0x7F }, NULL, v_mnemonic, "clra", 0,AF_IMP, { 0x4F }, NULL, v_mnemonic, "clrx", 0,AF_IMP, { 0x5F }, NULL, v_mnemonic, "cmp", 0, AF_IMM8|AFSTD, { 0xA1, 0xB1, 0xE1, 0xC1, 0xD1, 0xF1 }, NULL, v_mnemonic, "com", 0, AF_IMP|AF_BYTEADR|AF_BYTEADRX|AF_0X, { 0x43, 0x33, 0x63, 0x73 }, NULL, v_mnemonic, "coma", 0,AF_IMP, { 0x43 }, NULL, v_mnemonic, "comx", 0,AF_IMP, { 0x53 }, NULL, v_mnemonic, "cpx", 0, AF_IMM8|AFSTD, { 0xA3, 0xB3, 0xE3, 0xC3, 0xD3, 0xF3 }, NULL, v_mnemonic, "dec", 0, AF_IMP|AF_BYTEADR|AF_BYTEADRX|AF_0X, { 0x4A, 0x3A, 0x6A, 0x7A }, NULL, v_mnemonic, "deca", 0,AF_IMP, { 0x4A }, NULL, v_mnemonic, "decx", 0,AF_IMP, { 0x5A }, NULL, v_mnemonic, "dex", 0, AF_IMP, { 0x5A }, NULL, v_mnemonic, "eor", 0, AF_IMM8|AFSTD, { 0xA8, 0xB8, 0xE8, 0xC8, 0xD8, 0xF8 }, NULL, v_mnemonic, "inc", 0, AF_IMP|AF_BYTEADR|AF_BYTEADRX|AF_0X, { 0x4C, 0x3C, 0x6C, 0x7C }, NULL, v_mnemonic, "inca", 0,AF_IMP, { 0x4C }, NULL, v_mnemonic, "incx", 0,AF_IMP, { 0x5C }, NULL, v_mnemonic, "inx", 0, AF_IMP, { 0x5C }, NULL, v_mnemonic, "jmp", 0, AFSTD, { 0xBC, 0xEC, 0xCC, 0xDC, 0xFC }, NULL, v_mnemonic, "jsr", 0, AFSTD, { 0xBD, 0xED, 0xCD, 0xDD, 0xFD }, NULL, v_mnemonic, "lda", 0, AF_IMM8|AFSTD, { 0xA6, 0xB6, 0xE6, 0xC6, 0xD6, 0xF6 }, NULL, v_mnemonic, "ldx", 0, AF_IMM8|AFSTD, { 0xAE, 0xBE, 0xEE, 0xCE, 0xDE, 0xFE }, NULL, v_mnemonic, "lsl", 0, AF_IMP|AF_BYTEADR|AF_BYTEADRX|AF_0X, { 0x48, 0x38, 0x68, 0x78 }, NULL, v_mnemonic, "lsla", 0,AF_IMP, { 0x48 }, NULL, v_mnemonic, "lslx", 0,AF_IMP, { 0x58 }, NULL, v_mnemonic, "lsr", 0, AF_IMP|AF_BYTEADR|AF_BYTEADRX|AF_0X, { 0x44, 0x34, 0x64, 0x74 }, NULL, v_mnemonic, "lsra", 0,AF_IMP, { 0x44 }, NULL, v_mnemonic, "lsrx", 0,AF_IMP, { 0x54 }, NULL, v_mnemonic, "neg", 0, AF_IMP|AF_BYTEADR|AF_BYTEADRX|AF_0X, { 0x40, 0x30, 0x60, 0x70 }, NULL, v_mnemonic, "nega", 0,AF_IMP, { 0x40 }, NULL, v_mnemonic, "negx", 0,AF_IMP, { 0x50 }, NULL, v_mnemonic, "nop", 0, AF_IMP, { 0x9D }, NULL, v_mnemonic, "ora", 0, AF_IMM8|AFSTD, { 0xAA, 0xBA, 0xEA, 0xCA, 0xDA, 0xFA }, NULL, v_mnemonic, "rol", 0, AF_IMP|AF_BYTEADR|AF_BYTEADRX|AF_0X, { 0x49, 0x39, 0x69, 0x79 }, NULL, v_mnemonic, "rola", 0,AF_IMP, { 0x49 }, NULL, v_mnemonic, "rolx", 0,AF_IMP, { 0x59 }, NULL, v_mnemonic, "ror", 0, AF_IMP|AF_BYTEADR|AF_BYTEADRX|AF_0X, { 0x46, 0x36, 0x66, 0x76 }, NULL, v_mnemonic, "rora", 0,AF_IMP, { 0x46 }, NULL, v_mnemonic, "rorx", 0,AF_IMP, { 0x56 }, NULL, v_mnemonic, "rsp", 0, AF_IMP, { 0x9C }, NULL, v_mnemonic, "rti", 0, AF_IMP, { 0x80 }, NULL, v_mnemonic, "rts", 0, AF_IMP, { 0x81 }, NULL, v_mnemonic, "sbc", 0, AF_IMM8|AFSTD, { 0xA2, 0xB2, 0xE2, 0xC2, 0xD2, 0xF2 }, NULL, v_mnemonic, "sec", 0, AF_IMP, { 0x99 }, NULL, v_mnemonic, "sei", 0, AF_IMP, { 0x9B }, NULL, v_mnemonic, "sta", 0, AFSTD, { 0xB7, 0xE7, 0xC7, 0xD7, 0xF7 }, NULL, v_mnemonic, "stx", 0, AFSTD, { 0xBF, 0xEF, 0xCF, 0xDF, 0xFF }, NULL, v_mnemonic, "sub", 0, AF_IMM8|AFSTD, { 0xA0, 0xB0, 0xE0, 0xC0, 0xD0, 0xF0 }, NULL, v_mnemonic, "swi", 0, AF_IMP, { 0x83 }, NULL, v_mnemonic, "tax", 0, AF_IMP, { 0x97 }, NULL, v_mnemonic, "tst", 0, AF_IMP|AF_BYTEADR|AF_BYTEADRX|AF_0X, { 0x4D, 0x3D, 0x6D, 0x7D }, NULL, v_mnemonic, "tsta", 0,AF_IMP, { 0x4D }, NULL, v_mnemonic, "tstx", 0,AF_IMP, { 0x5D }, NULL, v_mnemonic, "txa", 0, AF_IMP, { 0x9F }, NULL }; SHAR_EOF if test 5699 -ne "`wc -c mne68705.c`" then echo shar: error transmitting mne68705.c '(should have been 5699 characters)' fi echo shar: extracting ops.c '(18260 characters)' cat << \SHAR_EOF > ops.c /* * OPS.C * * Handle mnemonics and pseudo ops * */ #include "asm.h" ubyte Gen[256]; ubyte OrgFill = DEFORGFILL; short Glen; extern void generate(); extern void genfill(); extern void pushif(); /* * An opcode modifies the SEGMENT flags in the following ways: */ void v_processor(str) register char *str; { extern MNE Mne6502[]; extern MNE Mne6803[]; extern MNE MneHD6303[]; extern MNE Mne68705[]; extern MNE Mne68HC11[]; register short none = 1; static int called; if (called) return; called = 1; if (strcmp(str,"6502") == 0) { addhashtable(Mne6502); MsbOrder = 0; /* lsb,msb */ Processor = 6502; } if (strcmp(str,"6803") == 0) { addhashtable(Mne6803); MsbOrder = 1; /* msb,lsb */ Processor = 6803; } if (strcmp(str,"HD6303") == 0 || strcmp(str, "hd6303") == 0) { addhashtable(Mne6803); addhashtable(MneHD6303); MsbOrder = 1; /* msb,lsb */ Processor = 6303; } if (strcmp(str,"68705") == 0) { addhashtable(Mne68705); MsbOrder = 1; /* msb,lsb */ Processor = 68705; } if (strcmp(str,"68HC11") == 0 || strcmp(str, "68hc11") == 0) { addhashtable(Mne68HC11); MsbOrder = 1; /* msb,lsb */ Processor = 6811; } if (!Processor) asmerr(20,1); } #define badcode(mne,adrmode) (!(mne->okmask & (1 << adrmode))) void v_mnemonic(str,mne) register MNE *mne; ubyte *str; { register uword addrmode; register SYMBOL *sym; SYMBOL *symbase; short opsize; Csegment->flags |= SF_REF; programlabel(); symbase = eval(str); if (Xtrace) printf("PC: %04lx MNE: %s addrmode: %d ", Csegment->org, mne->name, symbase->addrmode); for (sym = symbase; sym; sym = sym->next) { if (sym->flags & SYM_UNKNOWN) { ++Redo; Redo_why |= 1 << 0; } } sym = symbase; if (sym->addrmode == AM_IMM8 || sym->addrmode == AM_BYTEADR) { if (sym->next) { sym->addrmode = AM_BITMOD; if (sym->next->next) sym->addrmode = AM_BITBRAMOD; } } addrmode = sym->addrmode; if ((sym->flags & SYM_UNKNOWN) || sym->value >= 0x100) opsize = 2; else opsize = (sym->value) ? 1 : 0; while (badcode(mne,addrmode) && Cvt[addrmode]) addrmode = Cvt[addrmode]; if (Xtrace) printf("mnemask: %08lx adrmode: %ld Cvt[am]: %ld\n", mne->okmask, addrmode, Cvt[addrmode]); if (badcode(mne,addrmode)) { asmerr(5,0); freesymbollist(symbase); return; } if (Mnext >= 0 && Mnext < NUMOC) { /* Force */ addrmode = Mnext; if (badcode(mne,addrmode)) { asmerr(19,0); freesymbollist(symbase); return; } } if (Xtrace) printf("final addrmode = %d\n", addrmode); while (opsize > Opsize[addrmode]) { if (Cvt[addrmode] == 0 || badcode(mne,Cvt[addrmode])) { if (sym->flags & SYM_UNKNOWN) break; asmerr(14,0); break; } addrmode = Cvt[addrmode]; } Glen = Adrbytes[addrmode]; Gen[0] = mne->opcode[addrmode]; Gen[1] = sym->value; if (Opsize[addrmode] > 1) { if (MsbOrder) { Gen[1] = sym->value >> 8; Gen[2] = sym->value; } else { Gen[2] = sym->value >> 8; } } switch(addrmode) { case AM_BITMOD: sym = symbase->next; if (!(sym->flags & SYM_UNKNOWN) && sym->value >= 0x100) asmerr(14,0); Gen[1] = sym->value; if (!(symbase->flags & SYM_UNKNOWN)) { if (symbase->value > 7) asmerr(15,0); else Gen[0] += symbase->value << 1; } break; case AM_BITBRAMOD: if (!(symbase->flags & SYM_UNKNOWN)) { if (symbase->value > 7) asmerr(15,0); else Gen[0] += symbase->value << 1; } sym = symbase->next; if (!(sym->flags & SYM_UNKNOWN) && sym->value >= 0x100) asmerr(14,0); Gen[1] = sym->value; sym = sym->next; case AM_REL: if (!(sym->flags & SYM_UNKNOWN)) { long pc; ubyte pcf; long dest; pc = (Csegment->flags & SF_RORG) ? Csegment->rorg : Csegment->org; pcf= (Csegment->flags & SF_RORG) ? Csegment->rflags : Csegment->flags; if ((pcf & 3) == 0) { dest = sym->value - pc - Adrbytes[addrmode]; if (dest >= 128 || dest < -128) asmerr(10,0); } Gen[(addrmode == AM_REL) ? 1 : 2] = dest & 0xFF; } break; } generate(); freesymbollist(symbase); } v_trace(str) char *str; { if (str[1] == 'n') Xtrace = 1; else Xtrace = 0; } v_list(str) { programlabel(); } v_include(str) char *str; { char *buf; programlabel(); if (*str == '\"') { buf = (char *)malloc(strlen(str)); strcpy(buf, str+1); for (str = buf; *str && *str != '\"'; ++str); *str = 0; pushinclude(buf); free(buf); } else { pushinclude(str); } } v_seg(str) char *str; { register SEGMENT *seg; for (seg = Seglist; seg; seg = seg->next) { if (strcmp(str, seg->name) == 0) { Csegment = seg; programlabel(); return; } } Csegment = seg = (SEGMENT *)zmalloc(sizeof(SEGMENT)); seg->next = Seglist; seg->name = strcpy(malloc(strlen(str)+1), str); seg->flags= seg->rflags = seg->initflags = seg->initrflags = SF_UNKNOWN; Seglist = seg; if (Mnext == AM_BSS) seg->flags |= SF_BSS; programlabel(); } v_hex(str) register char *str; { register int i; register int result; programlabel(); Glen = 0; for (i = 0; str[i]; ++i) { if (str[i] == ' ') continue; result = (gethexdig(str[i]) << 4) + gethexdig(str[i+1]); if (str[++i] == 0) break; Gen[Glen++] = result; } generate(); } gethexdig(c) { if (c >= '0' && c <= '9') return(c - '0'); if (c >= 'a' && c <= 'f') return(c - 'a' + 10); if (c >= 'A' && c <= 'F') return(c - 'A' + 10); asmerr(0,0); puts("(Must be a valid hex digit)"); if (F_listfile) fputs("(Must be a valid hex digit)\n", FI_listfile); return(0); } v_err() { programlabel(); asmerr(11, 1); exit(1); } v_dc(str,mne) char *str; MNE *mne; { register SYMBOL *sym; register SYMBOL *tmp; register ulong value; char *macstr; char vmode = 0; Glen = 0; programlabel(); if (mne->name[1] == 'v') { register short i; vmode = 1; for (i = 0; str[i] && str[i] != ' '; ++i); tmp = findsymbol(str, i); str += i; if (tmp == NULL) { puts("EQM label not found"); return; } if (tmp->flags & SYM_MACRO) { macstr = (void *)tmp->string; } else { puts("must specify EQM label for DV"); return; } } sym = eval(str); for (; sym; sym = sym->next) { value = sym->value; if (sym->flags & SYM_UNKNOWN) { ++Redo; Redo_why |= (1 << 2); } if (sym->flags & SYM_STRING) { register ubyte *ptr = (void *)sym->string; while (value = *ptr) { if (vmode) { setspecial(value, 0); tmp = eval(macstr); value = tmp->value; if (tmp->flags & SYM_UNKNOWN) { ++Redo; Redo_why |= (1 << 3); } freesymbollist(tmp); } switch(Mnext) { default: case AM_BYTE: Gen[Glen++] = value & 0xFF; break; case AM_WORD: if (MsbOrder) { Gen[Glen++] = (value >> 8) & 0xFF; Gen[Glen++] = value & 0xFF; } else { Gen[Glen++] = value & 0xFF; Gen[Glen++] = (value >> 8) & 0xFF; } break; case AM_LONG: if (MsbOrder) { Gen[Glen++] = (value >> 24)& 0xFF; Gen[Glen++] = (value >> 16)& 0xFF; Gen[Glen++] = (value >> 8) & 0xFF; Gen[Glen++] = value & 0xFF; } else { Gen[Glen++] = value & 0xFF; Gen[Glen++] = (value >> 8) & 0xFF; Gen[Glen++] = (value >> 16)& 0xFF; Gen[Glen++] = (value >> 24)& 0xFF; } break; } ++ptr; } } else { if (vmode) { setspecial(value, sym->flags); tmp = eval(macstr); value = tmp->value; if (tmp->flags & SYM_UNKNOWN) { ++Redo; Redo_why |= 1 << 4; } freesymbollist(tmp); } switch(Mnext) { default: case AM_BYTE: Gen[Glen++] = value & 0xFF; break; case AM_WORD: if (MsbOrder) { Gen[Glen++] = (value >> 8) & 0xFF; Gen[Glen++] = value & 0xFF; } else { Gen[Glen++] = value & 0xFF; Gen[Glen++] = (value >> 8) & 0xFF; } break; case AM_LONG: if (MsbOrder) { Gen[Glen++] = (value >> 24)& 0xFF; Gen[Glen++] = (value >> 16)& 0xFF; Gen[Glen++] = (value >> 8) & 0xFF; Gen[Glen++] = value & 0xFF; } else { Gen[Glen++] = value & 0xFF; Gen[Glen++] = (value >> 8) & 0xFF; Gen[Glen++] = (value >> 16)& 0xFF; Gen[Glen++] = (value >> 24)& 0xFF; } break; } } } generate(); freesymbollist(sym); } v_ds(str) char *str; { register SYMBOL *sym; int mult = 1; long filler = 0; if (Mnext == AM_WORD) mult = 2; if (Mnext == AM_LONG) mult = 4; programlabel(); if (sym = eval(str)) { if (sym->next) filler = sym->next->value; if (sym->flags & SYM_UNKNOWN) { ++Redo; Redo_why |= 1 << 5; } else { if (sym->next && sym->next->flags & SYM_UNKNOWN) { ++Redo; Redo_why |= 1 << 5; } genfill(filler, sym->value * mult); } freesymbollist(sym); } } v_org(str) char *str; { register SYMBOL *sym = eval(str); Csegment->org = sym->value; if (sym->flags & SYM_UNKNOWN) Csegment->flags |= SYM_UNKNOWN; else Csegment->flags &= ~SYM_UNKNOWN; if (Csegment->initflags & SYM_UNKNOWN) { Csegment->initorg = sym->value; Csegment->initflags = sym->flags; } if (sym->next) { OrgFill = sym->next->value; if (sym->next->flags & SYM_UNKNOWN) asmerr(18,1); } programlabel(); freesymbollist(sym); } v_rorg(str) char *str; { register SYMBOL *sym = eval(str); Csegment->flags |= SF_RORG; if (sym->addrmode != AM_IMP) { Csegment->rorg = sym->value; if (sym->flags & SYM_UNKNOWN) Csegment->rflags |= SYM_UNKNOWN; else Csegment->rflags &= ~SYM_UNKNOWN; if (Csegment->initrflags & SYM_UNKNOWN) { Csegment->initrorg = sym->value; Csegment->initrflags = sym->flags; } } programlabel(); freesymbollist(sym); } v_rend() { programlabel(); Csegment->flags &= ~SF_RORG; } v_align(str) char *str; { SYMBOL *sym = eval(str); ubyte fill = 0; ubyte rorg = Csegment->flags & SF_RORG; if (rorg) Csegment->rflags |= SF_REF; else Csegment->flags |= SF_REF; if (sym->next) { if (sym->next->flags & SYM_UNKNOWN) { ++Redo; Redo_why |= 1 << 6; } else { fill = sym->value; } } if (rorg) { if ((Csegment->rflags | sym->flags) & SYM_UNKNOWN) { ++Redo; Redo_why |= 1 << 7; } else { register long n = sym->value - (Csegment->rorg % sym->value); if (n != sym->value) genfill(fill, n); } } else { if ((Csegment->flags | sym->flags) & SYM_UNKNOWN) { ++Redo; Redo_why |= 1 << 8; } else { register long n = sym->value - (Csegment->org % sym->value); if (n != sym->value) genfill(fill, n); } } freesymbollist(sym); programlabel(); } v_subroutine() { ++Lastlocalindex; Localindex = Lastlocalindex; programlabel(); } v_equ(str) char *str; { SYMBOL *sym = eval(str); SYMBOL *lab; lab = findsymbol(Av[0], strlen(Av[0])); if (!lab) lab = createsymbol(Av[0], strlen(Av[0])); if (!(lab->flags & SYM_UNKNOWN)) { if (sym->flags & SYM_UNKNOWN) { ++Redo; Redo_why |= 1 << 9; } else { if (lab->value != sym->value) { asmerr(13,0); printf("old value: $%04lx new value: $%04lx\n", lab->value, sym->value); ++Redo; Redo_why |= 1 << 10; } } } lab->value = sym->value; lab->flags = sym->flags & (SYM_UNKNOWN|SYM_STRING); lab->string = sym->string; sym->flags &= ~(SYM_STRING|SYM_MACRO); freesymbollist(sym); } v_eqm(str) char *str; { register SYMBOL *lab; register int len = strlen(Av[0]); if (lab = findsymbol(Av[0], len)) { if (lab->flags & SYM_STRING) free(lab->string); } else { lab = createsymbol(Av[0], len); } lab->value = 0; lab->flags = SYM_STRING | SYM_SET | SYM_MACRO; lab->string = strcpy(malloc(strlen(str)+1), str); } v_echo(str) char *str; { SYMBOL *sym = eval(str); SYMBOL *s; char buf[256]; for (s = sym; s; s = s->next) { if (!(s->flags & SYM_UNKNOWN)) { if (s->flags & (SYM_MACRO|SYM_STRING)) sprintf(buf,"%s", s->string); else sprintf(buf,"$%lx", s->value); if (FI_listfile) fprintf(FI_listfile, " %s", buf); printf(" %s", buf); } } puts(""); if (FI_listfile) putc('\n', FI_listfile); } v_set(str) char *str; { SYMBOL *sym = eval(str); SYMBOL *lab; lab = findsymbol(Av[0], strlen(Av[0])); if (!lab) lab = createsymbol(Av[0], strlen(Av[0])); lab->value = sym->value; lab->flags = sym->flags & (SYM_UNKNOWN|SYM_STRING); lab->string = sym->string; sym->flags &= ~(SYM_STRING|SYM_MACRO); freesymbollist(sym); } v_execmac(str,mac) char *str; MACRO *mac; { register INCFILE *inc; STRLIST *base; register STRLIST **psl, *sl; register char *s1, *s2; programlabel(); if (Mlevel == MAXMACLEVEL) { puts("infinite macro recursion"); return(0); } ++Mlevel; base = (STRLIST *)malloc(strlen(str)+5); base->next = NULL; strcpy(base->buf, str); psl = &base->next; while (*str && *str != '\n') { s1 = str; while (*str && *str != '\n' && *str != ',') ++str; sl = (STRLIST *)malloc(5+(str-s1)); sl->next = NULL; *psl = sl; psl = &sl->next; bmov(s1, sl->buf, (str-s1)); sl->buf[str-s1] = 0; if (*str == ',') ++str; while (*str == ' ') ++str; } inc = (INCFILE *)zmalloc(sizeof(INCFILE)); inc->next = Incfile; inc->name = mac->name; inc->fi = Incfile->fi; /* garbage */ inc->lineno = 0; inc->flags = INF_MACRO; inc->saveidx = Localindex; inc->strlist = mac->strlist; inc->args = base; Incfile = inc; ++Lastlocalindex; Localindex = Lastlocalindex; } void v_end() { puts("END not implemented yet"); } void v_endm() { register INCFILE *inc = Incfile; register STRLIST *args, *an; programlabel(); if (inc->flags & INF_MACRO) { --Mlevel; for (args = inc->args; args; args = an) { an = args->next; free(args); } Localindex = inc->saveidx; Incfile = inc->next; free(inc); return; } puts("not within a macro"); } v_mexit() { v_endm(); } v_ifconst(str) char *str; { SYMBOL *sym; programlabel(); sym = eval(str); pushif(sym->flags == 0); freesymbollist(sym); } v_ifnconst(str) char *str; { SYMBOL *sym; programlabel(); sym = eval(str); pushif(sym->flags != 0); freesymbollist(sym); } void v_if(str) char *str; { SYMBOL *sym; if (!Ifstack->true || !Ifstack->acctrue) { pushif(0); return; } programlabel(); sym = eval(str); if (sym->flags) { ++Redo; Redo_why |= 1 << 11; pushif(0); Ifstack->acctrue = 0; } else { pushif((short)!!sym->value); } freesymbollist(sym); } v_else() { if (Ifstack->acctrue && !(Ifstack->flags & IFF_BASE)) { programlabel(); Ifstack->true = !Ifstack->true; } } v_endif() { IFSTACK *ifs = Ifstack; if (!(ifs->flags & IFF_BASE)) { if (ifs->acctrue) programlabel(); if (ifs->file != Incfile) { puts("too many endif's"); } else { Ifstack = ifs->next; free(ifs); } } } v_repeat(str) char *str; { register REPLOOP *rp; register SYMBOL *sym; programlabel(); sym = eval(str); rp = (REPLOOP *)zmalloc(sizeof(REPLOOP)); rp->next = Reploop; rp->file = Incfile; rp->seek = ftell(Incfile->fi); rp->lineno = Incfile->lineno; rp->count = sym->value; if (rp->flags = sym->flags) { ++Redo; Redo_why |= 1 << 12; } Reploop = rp; freesymbollist(sym); } void v_repend() { if (Reploop) { if (Reploop->file == Incfile) { if (Reploop->flags == 0 && --Reploop->count) { fseek(Incfile->fi,Reploop->seek,0); Incfile->lineno = Reploop->lineno; } else { rmnode(&Reploop, sizeof(REPLOOP)); programlabel(); } return; } } puts("no repeat"); } static long Seglen; static long Seekback; void generate() { long seekpos; static ulong org; if (!Redo) { if (!(Csegment->flags & SF_BSS)) { if (Fisclear) { Fisclear = 0; if (Csegment->flags & SF_UNKNOWN) { ++Redo; Redo_why |= 1 << 1; return; } org = Csegment->org; if (F_format < 3) { putc((short)(org & 0xFF), FI_temp); putc((short)((org >> 8) & 0xFF), FI_temp); if (F_format == 2) { Seekback = ftell(FI_temp); Seglen = 0; putc(0, FI_temp); putc(0, FI_temp); } } } switch(F_format) { default: case 3: case 1: if (Csegment->org < org) { printf("segment: %s %s vs current org: %04lx\n", Csegment->name, sftos(Csegment->org, Csegment->flags), org); asmerr(12, 1); exit(1); } while (Csegment->org != org) { putc(OrgFill, FI_temp); ++org; } fwrite(Gen, Glen, 1, FI_temp); break; case 2: if (org != Csegment->org) { org = Csegment->org; seekpos = ftell(FI_temp); fseek(FI_temp, Seekback, 0); putc((short)(Seglen & 0xFF), FI_temp); putc((short)((Seglen >> 8) & 0xFF), FI_temp); fseek(FI_temp, seekpos, 0); putc((short)(org & 0xFF), FI_temp); putc((short)((org >> 8) & 0xFF), FI_temp); Seekback = ftell(FI_temp); Seglen = 0; putc(0, FI_temp); putc(0, FI_temp); } fwrite(Gen, Glen, 1, FI_temp); Seglen += Glen; } org += Glen; } } Csegment->org += Glen; if (Csegment->flags & SF_RORG) Csegment->rorg += Glen; } void closegenerate() { if (!Redo) { if (F_format == 2) { fseek(FI_temp, Seekback, 0); putc((short)(Seglen & 0xFF), FI_temp); putc((short)((Seglen >> 8) & 0xFF), FI_temp); fseek(FI_temp, 0L, 2); } } } void genfill(fill, bytes) long bytes; { bset(Gen, sizeof(Gen), fill); while (bytes > sizeof(Gen)) { Glen = sizeof(Gen); bytes -= sizeof(Gen); generate(); } Glen = bytes; generate(); } void pushif(bool) { register IFSTACK *ifs = (IFSTACK *)zmalloc(sizeof(IFSTACK)); ifs->next = Ifstack; ifs->file = Incfile; ifs->flags = 0; ifs->true = bool; ifs->acctrue = Ifstack->acctrue && Ifstack->true; Ifstack = ifs; } SHAR_EOF if test 18260 -ne "`wc -c ops.c`" then echo shar: error transmitting ops.c '(should have been 18260 characters)' fi echo shar: extracting suite6303.asm '(4346 characters)' cat << \SHAR_EOF > suite6303.asm processor hd6303 org 0 adda #10 ; 8B 0A adda 10 ; 9B 0A adda 10,x ; AB 0A adda 1000 ; BB 03 E8 addb #10 ; CB 0A addb 10 ; DB 0A addb 10,x ; EB 0A addb 1000 ; FB 03 E8 addd #1000 ; C3 03 E8 addd 10 ; D3 0A addd 10,x ; E3 0A addd 1000 ; F3 03 E8 aba ; 1B adca #10 ; 89 0A adca 10 ; 99 0A adca 10,x ; A9 0A adca 1000 ; B9 03 E8 adcb #10 ; C9 adcb 10 ; D9 adcb 10,x ; E9 adcb 1000 ; F9 03 E8 anda #10 ; 84 0A anda 10 ; 94 0A anda 10,x ; A4 0A anda 1000 ; B4 03 E8 andb #10 ; C4 0A andb 10 ; D4 0A andb 10,x ; E4 0A andb 1000 ; F4 03 E8 bita #10 ; 85 0A bita 10 ; 95 0A bita 10,x ; A5 0A bita 1000 ; B5 03 E8 bitb #10 ; C5 0A bitb 10 ; D5 0A bitb 10,x ; E5 0A bitb 1000 ; F5 03 E8 clr 10,x ; 6F 0A clr 1000 ; 7F 03 E8 clra ; 4F clrb ; 5F cmpa #10 ; 81 0A cmpa 10 ; 91 0A cmpa 10,x ; A1 0A cmpa 1000 ; B1 03 E8 cmpb #10 ; C1 0A cmpb 10 ; D1 0A cmpb 10,x ; E1 0A cmpb 1000 ; F1 03 E8 cba ; 11 com 10,x ; 63 0A com 1000 ; 73 03 E8 coma ; 43 comb ; 53 neg 10,x ; 60 0A neg 1000 ; 70 03 E8 nega ; 40 negb ; 50 daa ; 19 dec 10,x ; 6A 0A dec 1000 ; 7A 03 E8 deca ; 4A decb ; 5A eora #10 ; 88 0A eora 10 ; 98 0A eora 10,x ; A8 0A eora 1000 ; B8 03 E8 eorb #10 ; C8 0A eorb 10 ; D8 0A eorb 10,x ; E8 0A eorb 1000 ; F8 03 E8 inc 10,x ; 6C 0A inc 1000 ; 7C 03 E8 inca ; 4C incb ; 5C ldaa #10 ; 86 0A ldaa 10 ; 96 0A ldaa 10,x ; A6 0A ldaa 1000 ; B6 03 E8 ldab #10 ; C6 0A ldab 10 ; D6 0A ldab 10,x ; E6 0A ldab 1000 ; F6 03 E8 ldd #1000 ; CC 03 E8 ldd 10 ; DC 0A ldd 10,x ; EC 0A ldd 1000 ; FC 03 E8 mul ; 3D oraa #10 ; 8A 0A oraa 10 ; 9A 0A oraa 10,x ; AA 0A oraa 1000 ; BA 03 E8 orab #10 ; CA 0A orab 10 ; DA 0A orab 10,x ; EA 0A orab 1000 ; FA 03 E8 psha ; 36 pshb ; 37 pula ; 32 pulb ; 33 rol 10,x ; 69 0A rol 1000 ; 79 03 E8 rola ; 49 rolb ; 59 ror 10,x ; 66 0A ror 1000 ; 76 03 E8 rora ; 46 rorb ; 56 asl 10,x ; 68 0A asl 1000 ; 78 03 E8 asla ; 48 aslb ; 58 asld ; 05 asr 10,x ; 67 0A asr 1000 ; 77 03 E8 asra ; 47 asrb ; 57 lsr 10,x ; 64 0A lsr 1000 ; 74 03 E8 lsra ; 44 lsrb ; 54 lsrd ; 04 staa 10 ; 97 0A staa 10,x ; A7 0A staa 1000 ; B7 03 E8 stab 10 ; D7 0A stab 10,x ; E7 0A stab 1000 ; F7 03 E8 std 10 ; DD 0A std 10,x ; ED 0A std 1000 ; FD 03 E8 suba #10 ; 80 0A suba 10 ; 90 0A suba 10,x ; A0 0A suba 1000 ; B0 03 E8 subb #10 ; C0 0A subb 10 ; D0 0A subb 10,x ; E0 0A subb 1000 ; F0 03 E8 subd #1000 ; 83 03 E8 subd 10 ; 93 0A subd 10,x ; A3 0A subd 1000 ; B3 03 E8 sba ; 10 sbca #10 ; 82 0A sbca 10 ; 92 0A sbca 10,x ; A2 0A sbca 1000 ; B2 03 E8 sbcb #10 ; C2 0A sbcb 10 ; D2 0A sbcb 10,x ; E2 0A sbcb 1000 ; F2 03 E8 tab ; 16 tba ; 17 tst 10,x ; 6D 0A tst 1000 ; 7D 03 E8 tsta ; 4D tstb ; 5D aim 10 ; 71 0A aim 10,x ; 61 0A oim 10 ; 72 0A oim 10,x ; 62 0A eim 10 ; 75 0A eim 10,x ; 65 0A tim 10 ; 7B 0A tim 10,x ; 6B 0A cpx #1000 ; 8C 03 E8 cpx 10 ; 9C 0A cpx 10,x ; AC 0A cpx 1000 ; BC 03 E8 dex ; 09 des ; 34 inx ; 08 ins ; 31 ldx #1000 ; CE 03 E8 ldx 10 ; DE 0A ldx 10,x ; EE 0A ldx 1000 ; FE 03 E8 lds #1000 ; 8E 03 E8 lds 10 ; 9E 0A lds 10,x ; AE 0A lds 1000 ; BE 03 E8 stx 10 ; DF 0A stx 10,x ; EF 0A stx 1000 ; FF 03 E8 sts 10 ; 9F 0A sts 10,x ; AF 0A sts 1000 ; BF 03 E8 txs ; 35 tsx ; 30 abx ; 3A pshx ; 3C pulx ; 38 xgdx ; 18 bra . ; 20 FE brn . ; 21 FE bcc . ; 24 FE bcs . ; 25 FE beq . ; 27 FE bge . ; 2C FE bgt . ; 2E FE bhi . ; 22 FE ble . ; 2F FE bls . ; 23 FE blt . ; 2D FE bmi . ; 2B FE bne . ; 26 FE bvc . ; 28 FE bvs . ; 29 FE bpl . ; 2A FE bsr . ; 8D FE jmp 10,x ; 6E 0A jmp 1000 ; 7E 03 E8 jsr 10 ; 9D 0A jsr 10,x ; AD 0A jsr 1000 ; BD 03 E8 nop ; 01 rti ; 3B rts ; 39 swi ; 3F wai ; 3E slp ; 1A clc ; 0C cli ; 0E clv ; 0A sec ; 0D sei ; 0F sev ; 0B tap ; 06 tpa ; 07 SHAR_EOF if test 4346 -ne "`wc -c suite6303.asm`" then echo shar: error transmitting suite6303.asm '(should have been 4346 characters)' fi echo shar: extracting suite6502.asm '(1645 characters)' cat << \SHAR_EOF > suite6502.asm ; TEST ADDRESSING MODES processor 6502 org 0 adc #1 adc 1 adc 1,x adc 1,y ;absolute adc 1000 adc 1000,x adc 1000,y adc (1,x) adc (1),y and #1 and 1 and 1,x and 1,y ;absolute and 1000 and 1000,x and 1000,y and (1,x) and (1),y asl asl 1 asl 1,x asl 1000 asl 1000,x bcc . bcs . beq . bit 1 bit 1000 bmi . bne . bpl . brk bvc . bvs . clc cld cli clv cmp #1 cmp 1 cmp 1,x cmp 1,y ;absolute cmp 1000 cmp 1000,x cmp 1000,y cmp (1,x) cmp (1),y cpx #1 cpx 1 cpx 1000 cpy #1 cpy 1 cpy 1000 dec 1 dec 1,x dec 1000 dec 1000,x dex dey eor #1 eor 1 eor 1,x eor 1,y ;absolute eor 1000 eor 1000,x eor 1000,y eor (1,x) eor (1),y inc 1 inc 1,x inc 1000 inc 1000,x inx iny jmp 1 ;absolute jmp 1000 jmp (1) ;absolute jmp (1000) jsr 1 ;absolute jsr 1000 lda #1 lda 1 lda 1,x lda 1,y ;absolute lda 1000 lda 1000,x lda 1000,y lda (1,x) lda (1),y ldx #1 ldx 1 ldx 1,y ldx 1000 ldx 1000,y ldy #1 ldy 1 ldy 1,x ldy 1000 ldy 1000,x lsr lsr 1 lsr 1,x lsr 1000 lsr 1000,x nop ora #1 ora 1 ora 1,x ora 1,y ;absolute ora 1000 ora 1000,x ora 1000,y ora (1,x) ora (1),y pha php pla plp rol rol 1 rol 1,x rol 1000 rol 1000,x ror ror 1 ror 1,x ror 1000 ror 1000,x rti rts sbc #1 sbc 1 sbc 1,x sbc 1,y ;absolute sbc 1000 sbc 1000,x sbc 1000,y sbc (1,x) sbc (1),y sec sed sei sta 1 sta 1,x sta 1,y ;absolute sta 1000 sta 1000,x sta 1000,y sta (1,x) sta (1),y stx 1 stx 1,y stx 1000 sty 1 sty 1,x sty 1000 tax tay tsx txa txs tya SHAR_EOF if test 1645 -ne "`wc -c suite6502.asm`" then echo shar: error transmitting suite6502.asm '(should have been 1645 characters)' fi echo shar: extracting suite68705.asm '(1628 characters)' cat << \SHAR_EOF > suite68705.asm processor 68705 org 0 adc #10 adc 10 adc 1000 adc ,x adc 1,x adc 1000,x add #10 add 10 add 1000 add ,x add 1,x add 1000,x and #10 and 10 and 1000 and ,x and 1,x and 1000,x asla aslx asl 10 asl ,x asl 10,x asra asrx asr 10 asr ,x asr 10,x bcc . bclr 1,23 bcs . beq . bhcc . bhcs . bhi . bhs . bih . bil . bit #10 bit 10 bit 1000 bit ,x bit 1,x bit 1000,x blo . bls . bmc . bmi . bms . bne . bpl . bra . brn . brclr 1,10,. brset 1,10,. bset 1,10 bsr . clc cli clra clrx clr 10 clr ,x clr 10,x cmp #10 cmp 10 cmp 1000 cmp ,x cmp 1,x cmp 1000,x coma comx com 10 com ,x com 10,x cpx #10 cpx 10 cpx 1000 cpx ,x cpx 10,x cpx 1000,x deca decx dec 10 dec ,x dec 10,x eor #10 eor 10 eor 1000 eor ,x eor 10,x eor 1000,x inca incx inc 10 inc ,x inc 10,x jmp 10 jmp 1000 jmp ,x jmp 10,x jmp 1000,x jsr 10 jsr 1000 jsr ,x jsr 10,x jsr 1000,x lda #10 lda 10 lda 1000 lda ,x lda 10,x lda 1000,x ldx #10 ldx 10 ldx 1000 ldx ,x ldx 10,x ldx 1000,x lsla lslx lsl 10 lsl ,x lsl 10,x lsra lsrx lsr 10 lsr ,x lsr 10,x nega negx neg 10 neg ,x neg 10,x nop ora #10 ora 10 ora 1000 ora ,x ora 10,x ora 1000,x rola rolx rol 10 rol ,x rol 10,x rora rorx ror 10 ror ,x ror 10,x rsp rti rts sbc #10 sbc 10 sbc 1000 sbc ,x sbc 10,x sbc 1000,x sec sei sta 10 sta 1000 sta ,x sta 10,x sta 1000,x stx 10 stx 1000 stx ,x stx 10,x stx 1000,x sub #10 sub 10 sub 1000 sub ,x sub 10,x sub 1000,x swi tax tsta tstx tst 10 tst ,x tst 10,x txa SHAR_EOF if test 1628 -ne "`wc -c suite68705.asm`" then echo shar: error transmitting suite68705.asm '(should have been 1628 characters)' fi echo shar: extracting symbols.c '(3632 characters)' cat << \SHAR_EOF > symbols.c /* * SYMBOLS.C * * SHash[SHASHSIZE] */ #include "asm.h" extern uword hash1(); static SYMBOL org; static SYMBOL special; void setspecial(value, flags) { special.value = value; special.flags = flags; } SYMBOL * findsymbol(str, len) ubyte *str; short len; { register uword h1; register SYMBOL *sym; ubyte buf[64]; static SYMBOL org; short n; if (str[0] == '.') { if (len == 1) { if (Csegment->flags & SF_RORG) { org.flags = Csegment->rflags & SYM_UNKNOWN; org.value = Csegment->rorg; } else { org.flags = Csegment->flags & SYM_UNKNOWN; org.value = Csegment->org; } return(&org); } if (len == 2 && str[1] == '.') return(&special); sprintf(buf, "%ld", Localindex); n = strlen(buf); bmov(str, buf+n, len); len += n; str = buf; } h1 = hash1(str, len); for (sym = SHash[h1]; sym; sym = sym->next) { if (sym->namelen == len && bcmp(sym->name, str, len)) break; } return(sym); } SYMBOL * createsymbol(str, len) ubyte *str; short len; { register SYMBOL *sym; register uword h1; ubyte buf[64]; if (str[0] == '.') { short n; sprintf(buf, "%ld", Localindex); n = strlen(buf); bmov(str, buf+n, len); len += n; str = buf; } sym = (SYMBOL *)allocsymbol(); sym->name = permalloc(len+1); bmov(str, sym->name, len); /* permalloc zero's the array for us */ sym->namelen = len; h1 = hash1(str, len); sym->next = SHash[h1]; sym->flags= SYM_UNKNOWN; SHash[h1] = sym; return(sym); } static uword hash1(str, len) register ubyte *str; register short len; { register uword result = 0; while (len--) result = (result << 2) ^ *str++; return(result & SHASHAND); } /* * Label Support Routines */ void programlabel() { register uword len; register SYMBOL *sym; register SEGMENT *cseg = Csegment; register ubyte *str; ubyte rorg = cseg->flags & SF_RORG; ubyte cflags = (rorg) ? cseg->rflags : cseg->flags; ulong pc = (rorg) ? cseg->rorg : cseg->org; Plab = cseg->org; Pflags = cseg->flags; str = Av[0]; if (*str == 0) return; len = strlen(str); if (str[len-1] == ':') --len; /* * Redo: unknown and referenced * referenced and origin not known * known and phase error (origin known) */ if (sym = findsymbol(str, len)) { if ((sym->flags & (SYM_UNKNOWN|SYM_REF)) == (SYM_UNKNOWN|SYM_REF)) { ++Redo; Redo_why |= 1 << 13; if (Xdebug) printf("redo 13: '%s' %04lx %04lx\n", sym->name, sym->flags, cflags); } else if ((cflags & SYM_UNKNOWN) && (sym->flags & SYM_REF)) { ++Redo; Redo_why |= 1 << 13; } else if (!(cflags & SYM_UNKNOWN) && !(sym->flags & SYM_UNKNOWN)) { if (pc != sym->value) { printf("mismatch %10s %s pc: %s\n", sym->name, sftos(sym->value, sym->flags), sftos(pc, cflags & 7)); asmerr(17,0); ++Redo; Redo_why |= 1 << 14; } } } else { sym = createsymbol(str, len); } sym->value = pc; sym->flags = (sym->flags & ~SYM_UNKNOWN) | (cflags & SYM_UNKNOWN); } SYMBOL *SymAlloc; SYMBOL * allocsymbol() { SYMBOL *sym; if (SymAlloc) { sym = SymAlloc; SymAlloc = SymAlloc->next; bzero(sym, sizeof(SYMBOL)); } else { sym = (SYMBOL *)permalloc(sizeof(SYMBOL)); } return(sym); } void freesymbol(sym) SYMBOL *sym; { sym->next = SymAlloc; SymAlloc = sym; } void freesymbollist(sym) SYMBOL *sym; { register SYMBOL *next; while (sym) { next = sym->next; sym->next = SymAlloc; if (sym->flags & SYM_STRING) free(sym->string); SymAlloc = sym; sym = next; } } SHAR_EOF if test 3632 -ne "`wc -c symbols.c`" then echo shar: error transmitting symbols.c '(should have been 3632 characters)' fi # End of shell archive exit 0