Received: by j.cc.purdue.edu (5.54/1.14)
    id AA23823; Mon, 8 Feb 88 18:53:07 EST
Date: Mon, 8 Feb 88 18:53:07 EST
From: ain@j.cc.purdue.edu (Patrick White)
Message-Id: <8802082353.AA23823@j.cc.purdue.edu>
To: fys-ma@fintuvm.BITNET
Subject: posting to: news/comp/binaries/amiga/volume4
 
Article 147 of comp.sources.amiga:
Path: j.cc.purdue.edu!ain
From: ain@j.cc.purdue.edu (Patrick White)
Newsgroups: comp.sources.amiga
Subject: dasm  (part 1 of 2)
Keywords: dasm, cross assembler, part 1 of 2, untested.
Message-ID: <6390@j.cc.purdue.edu>
Date: 8 Feb 88 23:40:34 GMT
Organization: PUCC Land, USA
Lines: 2463
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 <stdio.h>
 
#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 <stdio.h>
 
#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