Source Code 1992 March/Source_Code_CD-ROM_Walnut_Creek_March_1992.iso/usenet/altsrcs/2/2231

Internet Message Format | 1990-12-28 | 54.6 KB

From: [e-mail] (Mark Zenier)
Newsgroups: alt.sources
Subject: Frankenstein Cross Assemblers, Hitachi 6301/3, Part 2 of 2
Message-ID: <[e-mail]>
Date: 7 Dec 90 00:18:26 GMT

---- Cut Here and feed the following to sh ----
#!/bin/sh
# This is part 02 of Frankasm/As6301
# ============= as6301.y ==============
if test -f 'as6301.y' -a X"$1" != X"-c"; then
    echo 'x - skipping as6301.y (File already exists)'
else
echo 'x - extracting as6301.y (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'as6301.y' &&
X%{
X
X/*
XHEADER:     ;
XTITLE:         Frankenstein Cross Assemblers;
XVERSION:     2.0;
XDESCRIPTION: "    Reconfigurable Cross-assembler producing Intel (TM)
X        Hex format object records.  ";
XKEYWORDS:     cross-assemblers, 1805, 2650, 6301, 6502, 6805, 6809,
X        6811, tms7000, 8048, 8051, 8096, z8, z80;
XSYSTEM:     UNIX, MS-Dos ;
XFILENAME:     as6301.y;
XWARNINGS:     "This software is in the public domain.
X        Any prior copyright claims are relinquished.
X
X        This software is distributed with no warranty whatever.
X        The author takes no responsibility for the consequences
X        of its use.
X
X        Yacc (or Bison) required to compile."  ;
XSEE-ALSO:     as6301.doc,frasmain.c;
XAUTHORS:     Mark Zenier;
XCOMPILERS:     Microport Sys V/AT, ATT Yacc, Turbo C V1.5, Bison (CUG disk 285)
X        (previous versions Xenix, Unisoft 68000 Version 7, Sun 3);
X*/
X/* 6301 instruction generation file */
X/* November 17, 1990 */
X
X/*
X    description    frame work parser description for framework cross
X            assemblers
X    history        February 2, 1988
X            September 11, 1990 - merge table definition
X            September 12, 1990 - short file names
X            September 14, 1990 - short variable names
X            September 17, 1990 - use yylex as external
X*/
X#include <stdio.h>
X#include "frasmdat.h"
X#include "fragcon.h"
X
X#define yylex lexintercept
X
X/*
X    file        fraselcrit.h
X    author        Mark Zenier
X    description    Selection criteria and token values for 6301
X            framework assembler
X    usage        framework cross assembler
X    history        September 19, 1987
X*/
X
X        /* 0000.0000.xxxx.xxxx */
X#define BITNUMB        0xff
X#define BIT0        0x01
X#define BIT1        0x02
X#define BIT2        0x04
X#define BIT3        0x08
X#define BIT4        0x10
X#define BIT5        0x20
X#define BIT6        0x40
X#define BIT7        0x80
X
X        /* 0000.00xx.0000.0000 */
X#define ACCREG        0x300
X#define REGA        0x100
X#define REGB        0x200
X
X        /* 0000.xx00.0000.0000 */
X#define ADDR        0xc00
X#define DIRECT        0x400
X#define EXTENDED    0x800
X
X#define ST_INH 0x1
X#define ST_ACC 0x2
X#define ST_INDREG 0x4
X#define ST_EXP 0x8
X#define ST_IMM 0x10
X#define ST_IND 0x20
X#define ST_AEXP 0x40
X#define ST_AIMM 0x80
X#define ST_AIND 0x100
X#define ST_BSET 0x200
X#define ST_BSETIND 0x400
X#define ST_MEMIMM 0x800
X#define ST_MEMIMMIND 0x1000
X
X    static char    genbdef[] = "[1=];";
X    static char    genwdef[] = "[1=]x";
X    char ignosyn[] = "[Xinvalid syntax for instruction";
X    char ignosel[] = "[Xinvalid operands";
X
X    long    labelloc;
X    static int satsub;
X    int    ifstkpt = 0;
X    int    fraifskip = FALSE;
X
X    struct symel * endsymbol = SYMNULL;
X
X%}
X%union {
X    int    intv;
X    long     longv;
X    char    *strng;
X    struct symel *symb;
X    struct {int indexv, ex; } inetre;
X}
X
X%token <intv> ACCUM
X%token <intv> INDEX
X%type <inetre> indexed
X%token <intv> KOC_BDEF
X%token <intv> KOC_ELSE
X%token <intv> KOC_END
X%token <intv> KOC_ENDI
X%token <intv> KOC_EQU
X%token <intv> KOC_IF
X%token <intv> KOC_INCLUDE
X%token <intv> KOC_ORG
X%token <intv> KOC_RESM
X%token <intv> KOC_SDEF
X%token <intv> KOC_SET
X%token <intv> KOC_WDEF
X%token <intv> KOC_CHSET
X%token <intv> KOC_CHDEF
X%token <intv> KOC_CHUSE
X%token <intv> KOC_opcode
X
X%token <longv> CONSTANT
X%token EOL
X%token KEOP_AND
X%token KEOP_DEFINED
X%token KEOP_EQ
X%token KEOP_GE
X%token KEOP_GT
X%token KEOP_HIGH
X%token KEOP_LE
X%token KEOP_LOW
X%token KEOP_LT
X%token KEOP_MOD
X%token KEOP_MUN
X%token KEOP_NE
X%token KEOP_NOT
X%token KEOP_OR
X%token KEOP_SHL
X%token KEOP_SHR
X%token KEOP_XOR
X%token KEOP_locctr
X%token <symb> LABEL
X%token <strng> STRING
X%token <symb> SYMBOL
X
X%token KTK_invalid
X
X%right    KEOP_HIGH KEOP_LOW
X%left    KEOP_OR KEOP_XOR
X%left    KEOP_AND
X%right    KEOP_NOT
X%nonassoc    KEOP_GT KEOP_GE KEOP_LE KEOP_LT KEOP_NE KEOP_EQ
X%left    '+' '-'
X%left    '*' '/' KEOP_MOD KEOP_SHL KEOP_SHR
X%right    KEOP_MUN
X
X
X%type <intv> expr exprlist stringlist
X
X%start file
X
X%%
X
Xfile    :    file allline
X    |    allline
X    ;
X
Xallline    :     line EOL
X            {
X                clrexpr();
X            }
X    |    EOL
X    |    error EOL
X            {
X                clrexpr();
X                yyerrok;
X            }
X    ;
X
Xline    :    LABEL KOC_END
X            {
X                endsymbol = $1;
X                nextreadact = Nra_end;
X            }
X    |          KOC_END
X            {
X                nextreadact = Nra_end;
X            }
X    |    KOC_INCLUDE STRING
X            {
X        if(nextfstk >= FILESTKDPTH)
X        {
X            fraerror("include file nesting limit exceeded");
X        }
X        else
X        {
X            infilestk[nextfstk].fnm = savestring($2,strlen($2));
X            if( (infilestk[nextfstk].fpt = fopen($2,"r"))
X                ==(FILE *)NULL )
X            {
X                fraerror("cannot open include file");
X            }
X            else
X            {
X                nextreadact = Nra_new;
X            }
X        }
X            }
X    |    LABEL KOC_EQU expr
X            {
X                if($1 -> seg == SSG_UNDEF)
X                {
X                    pevalexpr(0, $3);
X                    if(evalr[0].seg == SSG_ABS)
X                    {
X                        $1 -> seg = SSG_EQU;
X                        $1 -> value = evalr[0].value;
X                        prtequvalue("C: 0x%lx\n",
X                            evalr[0].value);
X                    }
X                    else
X                    {
X                        fraerror(
X                    "noncomputable expression for EQU");
X                    }
X                }
X                else
X                {
X                    fraerror(
X                "cannot change symbol value with EQU");
X                }
X            }
X    |    LABEL KOC_SET expr
X            {
X                if($1 -> seg == SSG_UNDEF
X                   || $1 -> seg == SSG_SET)
X                {
X                    pevalexpr(0, $3);
X                    if(evalr[0].seg == SSG_ABS)
X                    {
X                        $1 -> seg = SSG_SET;
X                        $1 -> value = evalr[0].value;
X                        prtequvalue("C: 0x%lx\n",
X                            evalr[0].value);
X                    }
X                    else
X                    {
X                        fraerror(
X                    "noncomputable expression for SET");
X                    }
X                }
X                else
X                {
X                    fraerror(
X                "cannot change symbol value with SET");
X                }
X            }
X    |    KOC_IF expr
X            {
X        if((++ifstkpt) < IFSTKDEPTH)
X        {
X            pevalexpr(0, $2);
X            if(evalr[0].seg == SSG_ABS)
X            {
X                if(evalr[0].value != 0)
X                {
X                    elseifstk[ifstkpt] = If_Skip;
X                    endifstk[ifstkpt] = If_Active;
X                }
X                else
X                {
X                    fraifskip = TRUE;
X                    elseifstk[ifstkpt] = If_Active;
X                    endifstk[ifstkpt] = If_Active;
X                }
X            }
X            else
X            {
X                fraifskip = TRUE;
X                elseifstk[ifstkpt] = If_Active;
X                endifstk[ifstkpt] = If_Active;
X            }
X        }
X        else
X        {
X            fraerror("IF stack overflow");
X        }
X            }
X
X    |    KOC_IF
X            {
X        if(fraifskip)
X        {
X            if((++ifstkpt) < IFSTKDEPTH)
X            {
X                    elseifstk[ifstkpt] = If_Skip;
X                    endifstk[ifstkpt] = If_Skip;
X            }
X            else
X            {
X                fraerror("IF stack overflow");
X            }
X        }
X        else
X        {
X            yyerror("syntax error");
X            YYERROR;
X        }
X                }
X
X    |    KOC_ELSE
X            {
X                switch(elseifstk[ifstkpt])
X                {
X                case If_Active:
X                    fraifskip = FALSE;
X                    break;
X
X                case If_Skip:
X                    fraifskip = TRUE;
X                    break;
X
X                case If_Err:
X                    fraerror("ELSE with no matching if");
X                    break;
X                }
X            }
X
X    |    KOC_ENDI
X            {
X                switch(endifstk[ifstkpt])
X                {
X                case If_Active:
X                    fraifskip = FALSE;
X                    ifstkpt--;
X                    break;
X
X                case If_Skip:
X                    fraifskip = TRUE;
X                    ifstkpt--;
X                    break;
X
X                case If_Err:
X                    fraerror("ENDI with no matching if");
X                    break;
X                }
X            }
X    |    LABEL KOC_ORG expr
X            {
X                pevalexpr(0, $3);
X                if(evalr[0].seg == SSG_ABS)
X                {
X                    locctr = labelloc = evalr[0].value;
X                    if($1 -> seg == SSG_UNDEF)
X                    {
X                        $1 -> seg = SSG_ABS;
X                        $1 -> value = labelloc;
X                    }
X                    else
X                        fraerror(
X                        "multiple definition of label");
X                    prtequvalue("C: 0x%lx\n",
X                        evalr[0].value);
X                }
X                else
X                {
X                    fraerror(
X                     "noncomputable expression for ORG");
X                }
X            }
X    |          KOC_ORG expr
X            {
X                pevalexpr(0, $2);
X                if(evalr[0].seg == SSG_ABS)
X                {
X                    locctr = labelloc = evalr[0].value;
X                    prtequvalue("C: 0x%lx\n",
X                        evalr[0].value);
X                }
X                else
X                {
X                    fraerror(
X                     "noncomputable expression for ORG");
X                }
X            }
X    |    LABEL KOC_CHSET
X            {
X                if($1 -> seg == SSG_UNDEF)
X                {
X                    $1 -> seg = SSG_EQU;
X                    if( ($1->value = chtcreate()) <= 0)
X                    {
X        fraerror( "cannot create character translation table");
X                    }
X                    prtequvalue("C: 0x%lx\n", $1 -> value);
X                }
X                else
X                {
X            fraerror( "multiple definition of label");
X                }
X            }
X    |        KOC_CHUSE
X            {
X                chtcpoint = (int *) NULL;
X                prtequvalue("C: 0x%lx\n", 0L);
X            }
X    |        KOC_CHUSE expr
X            {
X                pevalexpr(0, $2);
X                if( evalr[0].seg == SSG_ABS)
X                {
X                    if( evalr[0].value == 0)
X                    {
X                        chtcpoint = (int *)NULL;
X                        prtequvalue("C: 0x%lx\n", 0L);
X                    }
X                    else if(evalr[0].value < chtnxalph)
X                    {
X                chtcpoint = chtatab[evalr[0].value];
X                prtequvalue("C: 0x%lx\n", evalr[0].value);
X                    }
X                    else
X                    {
X            fraerror("nonexistent character translation table");
X                    }
X                }
X                else
X                {
X                    fraerror("noncomputable expression");
X                }
X            }
X    |        KOC_CHDEF STRING ',' exprlist
X            {
X        int findrv, numret, *charaddr;
X        char *sourcestr = $2, *before;
X
X        if(chtnpoint != (int *)NULL)
X        {
X            for(satsub = 0; satsub < $4; satsub++)
X            {
X                before = sourcestr;
X
X                pevalexpr(0, exprlist[satsub]);
X                findrv = chtcfind(chtnpoint, &sourcestr,
X                        &charaddr, &numret);
X                if(findrv == CF_END)
X                {
X            fraerror("more expressions than characters");
X                    break;
X                }
X
X                if(evalr[0].seg == SSG_ABS)
X                {
X                    switch(findrv)
X                    {
X                    case CF_UNDEF:
X                        {
X                if(evalr[0].value < 0 ||
X                    evalr[0].value > 255)
X                {
X            frawarn("character translation value truncated");
X                }
X                *charaddr = evalr[0].value & 0xff;
X                prtequvalue("C: 0x%lx\n", evalr[0].value);
X                        }
X                        break;
X
X                    case CF_INVALID:
X                    case CF_NUMBER:
X                fracherror("invalid character to define",
X                    before, sourcestr);
X                        break;
X
X                    case CF_CHAR:
X                fracherror("character already defined",
X                    before, sourcestr);
X                        break;
X                    }
X                }
X                else
X                {
X                    fraerror("noncomputable expression");
X                }
X            }
X
X            if( *sourcestr != '\0')
X            {
X                fraerror("more characters than expressions");
X            }
X        }
X        else
X        {
X            fraerror("no CHARSET statement active");
X        }
X
X            }
X    |    LABEL
X            {
X            if($1 -> seg == SSG_UNDEF)
X            {
X                $1 -> seg = SSG_ABS;
X                $1 -> value = labelloc;
X                prtequvalue("C: 0x%lx\n", labelloc);
X
X            }
X            else
X                fraerror(
X                "multiple definition of label");
X            }
X    |    labeledline
X    ;
X
Xlabeledline :    LABEL genline
X            {
X            if($1 -> seg == SSG_UNDEF)
X            {
X                $1 -> seg = SSG_ABS;
X                $1 -> value = labelloc;
X            }
X            else
X                fraerror(
X                "multiple definition of label");
X            labelloc = locctr;
X            }
X
X    |    genline
X            {
X                labelloc = locctr;
X            }
X    ;
X
Xgenline    :    KOC_BDEF    exprlist
X            {
X                genlocrec(currseg, labelloc);
X                for( satsub = 0; satsub < $2; satsub++)
X                {
X                    pevalexpr(1, exprlist[satsub]);
X                    locctr += geninstr(genbdef);
X                }
X            }
X    |    KOC_SDEF stringlist
X            {
X                genlocrec(currseg, labelloc);
X                for(satsub = 0; satsub < $2; satsub++)
X                {
X                    locctr += genstring(stringlist[satsub]);
X                }
X            }
X    |    KOC_WDEF exprlist
X            {
X                genlocrec(currseg, labelloc);
X                for( satsub = 0; satsub < $2; satsub++)
X                {
X                    pevalexpr(1, exprlist[satsub]);
X                    locctr += geninstr(genwdef);
X                }
X            }
X    |    KOC_RESM expr
X            {
X                pevalexpr(0, $2);
X                if(evalr[0].seg == SSG_ABS)
X                {
X                    locctr = labelloc + evalr[0].value;
X                    prtequvalue("C: 0x%lx\n", labelloc);
X                }
X                else
X                {
X                    fraerror(
X                 "noncomputable result for RMB expression");
X                }
X            }
X    ;
X
Xexprlist :    exprlist ',' expr
X            {
X                exprlist[nextexprs ++ ] = $3;
X                $$ = nextexprs;
X            }
X    |    expr
X            {
X                nextexprs = 0;
X                exprlist[nextexprs ++ ] = $1;
X                $$ = nextexprs;
X            }
X    ;
X
Xstringlist :    stringlist ',' STRING
X            {
X                stringlist[nextstrs ++ ] = $3;
X                $$ = nextstrs;
X            }
X    |    STRING
X            {
X                nextstrs = 0;
X                stringlist[nextstrs ++ ] = $1;
X                $$ = nextstrs;
X            }
X    ;
X
X
Xgenline : KOC_opcode
X            {
X        genlocrec(currseg, labelloc);
X        locctr += geninstr(findgen($1, ST_INH, 0));
X            }
X    ;
Xgenline : KOC_opcode  ACCUM
X            {
X        genlocrec(currseg, labelloc);
X        locctr += geninstr(findgen($1, ST_ACC, $2));
X            }
X    ;
Xgenline : KOC_opcode  INDEX
X            {
X        genlocrec(currseg, labelloc);
X        locctr += geninstr(findgen($1, ST_INDREG, 0));
X            }
X    ;
Xgenline : KOC_opcode  expr
X            {
X        pevalexpr(1, $2);
X        genlocrec(currseg, labelloc);
X        locctr += geninstr( findgen( $1, ST_EXP,
X                  ( (evalr[1].seg == SSG_ABS
X                && evalr[1].value >= 0
X                && evalr[1].value <= 255 )
X                ? DIRECT : EXTENDED ) )
X                );
X            }
X    ;
Xgenline : KOC_opcode  '#' expr
X            {
X        pevalexpr(1, $3);
X        genlocrec(currseg, labelloc);
X        locctr += geninstr( findgen($1, ST_IMM, 0));
X            }
X    ;
Xgenline : KOC_opcode  indexed
X            {
X        pevalexpr(1, $2.ex);
X        genlocrec(currseg, labelloc);
X        locctr += geninstr( findgen($1, ST_IND, 0));
X            }
X    ;
Xgenline : KOC_opcode  ACCUM expr
X            {
X        pevalexpr(1, $3);
X        genlocrec(currseg, labelloc);
X        locctr += geninstr(findgen( $1, ST_AEXP, $2
X                 + ( (evalr[1].seg == SSG_ABS
X                && evalr[1].value >= 0
X                && evalr[1].value <= 255 )
X                ? DIRECT : EXTENDED ) ) );
X            }
X    ;
Xgenline : KOC_opcode  ACCUM '#' expr
X            {
X        pevalexpr(1,$4);
X        genlocrec(currseg, labelloc);
X        locctr += geninstr( findgen($1, ST_AIMM, $2 ));
X            }
X    ;
Xgenline : KOC_opcode  ACCUM indexed
X            {
X        pevalexpr(1, $3.ex);
X        genlocrec(currseg, labelloc);
X        locctr += geninstr( findgen($1, ST_AIND, $2));
X            }
X    ;
Xgenline : KOC_opcode  expr ',' expr
X            {
X        pevalexpr(1,$2);
X        if(evalr[1].seg != SSG_ABS ||
X            evalr[1].value < 0 ||
X            evalr[1].value > 7)
X        {
X            evalr[1].value = 0;
X            fraerror("impossible bit number");
X        }
X        pevalexpr(2,$4);
X        genlocrec(currseg, labelloc);
X        locctr += geninstr( findgen( $1, ST_BSET, 1<<evalr[1].value));
X            }
X    ;
Xgenline : KOC_opcode  expr ',' indexed
X            {
X        pevalexpr(1,$2);
X        if(evalr[1].seg != SSG_ABS ||
X            evalr[1].value < 0 ||
X            evalr[1].value > 7)
X        {
X            evalr[1].value = 0;
X            fraerror("impossible bit number");
X        }
X        pevalexpr(2,$4.ex);
X        genlocrec(currseg, labelloc);
X        locctr += geninstr( findgen( $1, ST_BSETIND,
X                    1<<evalr[1].value));
X            }
X    ;
Xgenline : KOC_opcode  '#' expr ',' expr
X            {
X        pevalexpr(1, $3);
X        pevalexpr(2, $5);
X        genlocrec(currseg, labelloc);
X        locctr += geninstr( findgen( $1, ST_MEMIMM, 0));
X            }
X    ;
Xgenline : KOC_opcode  '#' expr ',' indexed
X            {
X        pevalexpr(1, $3);
X        pevalexpr(2, $5.ex);
X        genlocrec(currseg, labelloc);
X        locctr += geninstr( findgen( $1, ST_MEMIMMIND, 0));
X            }
X    ;
Xindexed    :    INDEX ',' expr
X            {
X                $$.ex = $3;
X                $$.indexv = $1;
X            }
X    |    expr ',' INDEX
X            {
X                $$.ex = $1;
X                $$.indexv = $3;
X            }
X    ;
X
Xexpr    :    '+' expr %prec KEOP_MUN
X            {
X                $$ = $2;
X            }
X    |    '-' expr %prec KEOP_MUN
X            {
X                $$ = exprnode(PCCASE_UN,$2,IFC_NEG,0,0L,
X                    SYMNULL);
X            }
X    |    KEOP_NOT expr
X            {
X                $$ = exprnode(PCCASE_UN,$2,IFC_NOT,0,0L,
X                    SYMNULL);
X            }
X    |    KEOP_HIGH expr
X            {
X                $$ = exprnode(PCCASE_UN,$2,IFC_HIGH,0,0L,
X                    SYMNULL);
X            }
X    |    KEOP_LOW expr
X            {
X                $$ = exprnode(PCCASE_UN,$2,IFC_LOW,0,0L,
X                    SYMNULL);
X            }
X    |    expr '*' expr
X            {
X                $$ = exprnode(PCCASE_BIN,$1,IFC_MUL,$3,0L,
X                    SYMNULL);
X            }
X    |    expr '/' expr
X            {
X                $$ = exprnode(PCCASE_BIN,$1,IFC_DIV,$3,0L,
X                    SYMNULL);
X            }
X    |    expr '+' expr
X            {
X                $$ = exprnode(PCCASE_BIN,$1,IFC_ADD,$3,0L,
X                    SYMNULL);
X            }
X    |    expr '-' expr
X            {
X                $$ = exprnode(PCCASE_BIN,$1,IFC_SUB,$3,0L,
X                    SYMNULL);
X            }
X    |    expr KEOP_MOD expr
X            {
X                $$ = exprnode(PCCASE_BIN,$1,IFC_MOD,$3,0L,
X                    SYMNULL);
X            }
X    |    expr KEOP_SHL expr
X            {
X                $$ = exprnode(PCCASE_BIN,$1,IFC_SHL,$3,0L,
X                    SYMNULL);
X            }
X    |    expr KEOP_SHR expr
X            {
X                $$ = exprnode(PCCASE_BIN,$1,IFC_SHR,$3,0L,
X                    SYMNULL);
X            }
X    |    expr KEOP_GT expr
X            {
X                $$ = exprnode(PCCASE_BIN,$1,IFC_GT,$3,0L,
X                    SYMNULL);
X            }
X    |    expr KEOP_GE expr
X            {
X                $$ = exprnode(PCCASE_BIN,$1,IFC_GE,$3,0L,
X                    SYMNULL);
X            }
X    |    expr KEOP_LT expr
X            {
X                $$ = exprnode(PCCASE_BIN,$1,IFC_LT,$3,0L,
X                    SYMNULL);
X            }
X    |    expr KEOP_LE expr
X            {
X                $$ = exprnode(PCCASE_BIN,$1,IFC_LE,$3,0L,
X                    SYMNULL);
X            }
X    |    expr KEOP_NE expr
X            {
X                $$ = exprnode(PCCASE_BIN,$1,IFC_NE,$3,0L,
X                    SYMNULL);
X            }
X    |    expr KEOP_EQ expr
X            {
X                $$ = exprnode(PCCASE_BIN,$1,IFC_EQ,$3,0L,
X                    SYMNULL);
X            }
X    |    expr KEOP_AND expr
X            {
X                $$ = exprnode(PCCASE_BIN,$1,IFC_AND,$3,0L,
X                    SYMNULL);
X            }
X    |    expr KEOP_OR expr
X            {
X                $$ = exprnode(PCCASE_BIN,$1,IFC_OR,$3,0L,
X                    SYMNULL);
X            }
X    |    expr KEOP_XOR expr
X            {
X                $$ = exprnode(PCCASE_BIN,$1,IFC_XOR,$3,0L,
X                    SYMNULL);
X            }
X    |    KEOP_DEFINED SYMBOL
X            {
X                $$ = exprnode(PCCASE_DEF,0,IGP_DEFINED,0,0L,$2);
X            }
X    |    SYMBOL
X            {
X                $$ = exprnode(PCCASE_SYMB,0,IFC_SYMB,0,0L,$1);
X            }
X    |    '*'
X            {
X                $$ = exprnode(PCCASE_PROGC,0,IFC_PROGCTR,0,
X                    labelloc, SYMNULL);
X            }
X    |    CONSTANT
X            {
X                $$ = exprnode(PCCASE_CONS,0,IGP_CONSTANT,0,$1,
X                    SYMNULL);
X            }
X    |    STRING
X            {
X                char *sourcestr = $1;
X                long accval = 0;
X
X                if(strlen($1) > 0)
X                {
X                    accval = chtran(&sourcestr);
X                    if(*sourcestr != '\0')
X                    {
X                        accval = (accval << 8) +
X                            chtran(&sourcestr);
X                    }
X
X                    if( *sourcestr != '\0')
X                    {
X    frawarn("string constant in expression more than 2 characters long");
X                    }
X                }
X                $$ = exprnode(PCCASE_CONS, 0, IGP_CONSTANT, 0,
X                    accval, SYMNULL);
X            }
X    |    '(' expr ')'
X            {
X                $$ = $2;
X            }
X    ;
X
X
X%%
X
Xlexintercept()
X/*
X    description    intercept the call to yylex (the lexical analyzer)
X            and filter out all unnecessary tokens when skipping
X            the input between a failed IF and its matching ENDI or
X            ELSE
X    globals     fraifskip    the enable flag
X*/
X{
X#undef yylex
X
X    int rv;
X
X    if(fraifskip)
X    {
X        for(;;)
X        {
X
X            switch(rv = yylex())
X
X            {
X            case 0:
X            case KOC_END:
X            case KOC_IF:
X            case KOC_ELSE:
X            case KOC_ENDI:
X            case EOL:
X                return rv;
X            default:
X                break;
X            }
X        }
X    }
X    else
X        return yylex();
X#define yylex lexintercept
X}
X
X
Xsetreserved()
X{
X
X    reservedsym("and", KEOP_AND, 0);
X    reservedsym("defined", KEOP_DEFINED,0);
X    reservedsym("eq", KEOP_EQ, 0);
X    reservedsym("ge", KEOP_GE, 0);
X    reservedsym("gt", KEOP_GT, 0);
X    reservedsym("high", KEOP_HIGH, 0);
X    reservedsym("le", KEOP_LE, 0);
X    reservedsym("low", KEOP_LOW, 0);
X    reservedsym("lt", KEOP_LT, 0);
X    reservedsym("mod", KEOP_MOD, 0);
X    reservedsym("ne", KEOP_NE, 0);
X    reservedsym("not", KEOP_NOT, 0);
X    reservedsym("or", KEOP_OR, 0);
X    reservedsym("shl", KEOP_SHL, 0);
X    reservedsym("shr", KEOP_SHR, 0);
X    reservedsym("xor", KEOP_XOR, 0);
X    reservedsym("AND", KEOP_AND, 0);
X    reservedsym("DEFINED", KEOP_DEFINED,0);
X    reservedsym("EQ", KEOP_EQ, 0);
X    reservedsym("GE", KEOP_GE, 0);
X    reservedsym("GT", KEOP_GT, 0);
X    reservedsym("HIGH", KEOP_HIGH, 0);
X    reservedsym("LE", KEOP_LE, 0);
X    reservedsym("LOW", KEOP_LOW, 0);
X    reservedsym("LT", KEOP_LT, 0);
X    reservedsym("MOD", KEOP_MOD, 0);
X    reservedsym("NE", KEOP_NE, 0);
X    reservedsym("NOT", KEOP_NOT, 0);
X    reservedsym("OR", KEOP_OR, 0);
X    reservedsym("SHL", KEOP_SHL, 0);
X    reservedsym("SHR", KEOP_SHR, 0);
X    reservedsym("XOR", KEOP_XOR, 0);
X
X
X    reservedsym("a", ACCUM, REGA);
X    reservedsym("b", ACCUM, REGB);
X    reservedsym("x", INDEX, 0);
X    reservedsym("A", ACCUM, REGA);
X    reservedsym("B", ACCUM, REGB);
X    reservedsym("X", INDEX, 0);
X}
X
Xcpumatch(str)
X    char * str;
X{
X    return TRUE;
X}
X
X/*
X    description    Opcode and Instruction generation tables
X    usage        Unix, framework crossassembler
X    history        September 25, 1987
X*/
X
X#define NUMOPCODE 171
X#define NUMSYNBLK 263
X#define NUMDIFFOP 419
X
Xint gnumopcode = NUMOPCODE;
X
Xint ophashlnk[NUMOPCODE];
X
Xstruct opsym optab[NUMOPCODE+1]
X    = {
X    {"invalid", KOC_opcode, 2, 0 },
X    {"ABA", KOC_opcode, 1, 2 },
X    {"ABX", KOC_opcode, 1, 3 },
X    {"ADC", KOC_opcode, 3, 4 },
X    {"ADCA", KOC_opcode, 3, 7 },
X    {"ADCB", KOC_opcode, 3, 10 },
X    {"ADD", KOC_opcode, 3, 13 },
X    {"ADDA", KOC_opcode, 3, 16 },
X    {"ADDB", KOC_opcode, 3, 19 },
X    {"ADDD", KOC_opcode, 3, 22 },
X    {"AIM", KOC_opcode, 2, 25 },
X    {"AND", KOC_opcode, 3, 27 },
X    {"ANDA", KOC_opcode, 3, 30 },
X    {"ANDB", KOC_opcode, 3, 33 },
X    {"ASL", KOC_opcode, 3, 36 },
X    {"ASLA", KOC_opcode, 1, 39 },
X    {"ASLB", KOC_opcode, 1, 40 },
X    {"ASLD", KOC_opcode, 1, 41 },
X    {"ASR", KOC_opcode, 3, 42 },
X    {"ASRA", KOC_opcode, 1, 45 },
X    {"ASRB", KOC_opcode, 1, 46 },
X    {"BCC", KOC_opcode, 1, 47 },
X    {"BCLR", KOC_opcode, 2, 48 },
X    {"BCS", KOC_opcode, 1, 50 },
X    {"BEQ", KOC_opcode, 1, 51 },
X    {"BGE", KOC_opcode, 1, 52 },
X    {"BGT", KOC_opcode, 1, 53 },
X    {"BHI", KOC_opcode, 1, 54 },
X    {"BHS", KOC_opcode, 1, 55 },
X    {"BIT", KOC_opcode, 3, 56 },
X    {"BITA", KOC_opcode, 3, 59 },
X    {"BITB", KOC_opcode, 3, 62 },
X    {"BLE", KOC_opcode, 1, 65 },
X    {"BLO", KOC_opcode, 1, 66 },
X    {"BLS", KOC_opcode, 1, 67 },
X    {"BLT", KOC_opcode, 1, 68 },
X    {"BMI", KOC_opcode, 1, 69 },
X    {"BNE", KOC_opcode, 1, 70 },
X    {"BPL", KOC_opcode, 1, 71 },
X    {"BRA", KOC_opcode, 1, 72 },
X    {"BRN", KOC_opcode, 1, 73 },
X    {"BSET", KOC_opcode, 2, 74 },
X    {"BSR", KOC_opcode, 1, 76 },
X    {"BTGL", KOC_opcode, 2, 77 },
X    {"BTST", KOC_opcode, 2, 79 },
X    {"BVC", KOC_opcode, 1, 81 },
X    {"BVS", KOC_opcode, 1, 82 },
X    {"BYTE", KOC_BDEF, 0, 0 },
X    {"CBA", KOC_opcode, 1, 83 },
X    {"CHARDEF", KOC_CHDEF, 0, 0 },
X    {"CHARSET", KOC_CHSET, 0, 0 },
X    {"CHARUSE", KOC_CHUSE, 0, 0 },
X    {"CHD", KOC_CHDEF, 0, 0 },
X    {"CLC", KOC_opcode, 1, 84 },
X    {"CLI", KOC_opcode, 1, 85 },
X    {"CLR", KOC_opcode, 3, 86 },
X    {"CLRA", KOC_opcode, 1, 89 },
X    {"CLRB", KOC_opcode, 1, 90 },
X    {"CLV", KOC_opcode, 1, 91 },
X    {"CMP", KOC_opcode, 3, 92 },
X    {"CMPA", KOC_opcode, 3, 95 },
X    {"CMPB", KOC_opcode, 3, 98 },
X    {"COM", KOC_opcode, 3, 101 },
X    {"COMA", KOC_opcode, 1, 104 },
X    {"COMB", KOC_opcode, 1, 105 },
X    {"CPX", KOC_opcode, 3, 106 },
X    {"DAA", KOC_opcode, 1, 109 },
X    {"DB", KOC_BDEF, 0, 0 },
X    {"DEC", KOC_opcode, 3, 110 },
X    {"DECA", KOC_opcode, 1, 113 },
X    {"DECB", KOC_opcode, 1, 114 },
X    {"DES", KOC_opcode, 1, 115 },
X    {"DEX", KOC_opcode, 1, 116 },
X    {"DW", KOC_WDEF, 0, 0 },
X    {"EIM", KOC_opcode, 2, 117 },
X    {"ELSE", KOC_ELSE, 0, 0 },
X    {"END", KOC_END, 0, 0 },
X    {"ENDI", KOC_ENDI, 0, 0 },
X    {"EOR", KOC_opcode, 3, 119 },
X    {"EORA", KOC_opcode, 3, 122 },
X    {"EORB", KOC_opcode, 3, 125 },
X    {"EQU", KOC_EQU, 0, 0 },
X    {"FCB", KOC_BDEF, 0, 0 },
X    {"FCC", KOC_SDEF, 0, 0 },
X    {"FDB", KOC_WDEF, 0, 0 },
X    {"IF", KOC_IF, 0, 0 },
X    {"INC", KOC_opcode, 3, 128 },
X    {"INCA", KOC_opcode, 1, 131 },
X    {"INCB", KOC_opcode, 1, 132 },
X    {"INCL", KOC_INCLUDE, 0, 0 },
X    {"INCLUDE", KOC_INCLUDE, 0, 0 },
X    {"INS", KOC_opcode, 1, 133 },
X    {"INX", KOC_opcode, 1, 134 },
X    {"JMP", KOC_opcode, 2, 135 },
X    {"JSR", KOC_opcode, 2, 137 },
X    {"LDA", KOC_opcode, 3, 139 },
X    {"LDAA", KOC_opcode, 3, 142 },
X    {"LDAB", KOC_opcode, 3, 145 },
X    {"LDD", KOC_opcode, 3, 148 },
X    {"LDS", KOC_opcode, 3, 151 },
X    {"LDX", KOC_opcode, 3, 154 },
X    {"LSL", KOC_opcode, 3, 157 },
X    {"LSLA", KOC_opcode, 1, 160 },
X    {"LSLB", KOC_opcode, 1, 161 },
X    {"LSLD", KOC_opcode, 1, 162 },
X    {"LSR", KOC_opcode, 3, 163 },
X    {"LSRA", KOC_opcode, 1, 166 },
X    {"LSRB", KOC_opcode, 1, 167 },
X    {"LSRD", KOC_opcode, 1, 168 },
X    {"MUL", KOC_opcode, 1, 169 },
X    {"NEG", KOC_opcode, 3, 170 },
X    {"NEGA", KOC_opcode, 1, 173 },
X    {"NEGB", KOC_opcode, 1, 174 },
X    {"NOP", KOC_opcode, 1, 175 },
X    {"OIM", KOC_opcode, 2, 176 },
X    {"ORA", KOC_opcode, 3, 178 },
X    {"ORAA", KOC_opcode, 3, 181 },
X    {"ORAB", KOC_opcode, 3, 184 },
X    {"ORG", KOC_ORG, 0, 0 },
X    {"PSH", KOC_opcode, 2, 187 },
X    {"PSHA", KOC_opcode, 1, 189 },
X    {"PSHB", KOC_opcode, 1, 190 },
X    {"PSHX", KOC_opcode, 1, 191 },
X    {"PUL", KOC_opcode, 2, 192 },
X    {"PULA", KOC_opcode, 1, 194 },
X    {"PULB", KOC_opcode, 1, 195 },
X    {"PULX", KOC_opcode, 1, 196 },
X    {"RESERVE", KOC_RESM, 0, 0 },
X    {"RMB", KOC_RESM, 0, 0 },
X    {"ROL", KOC_opcode, 3, 197 },
X    {"ROLA", KOC_opcode, 1, 200 },
X    {"ROLB", KOC_opcode, 1, 201 },
X    {"ROR", KOC_opcode, 3, 202 },
X    {"RORA", KOC_opcode, 1, 205 },
X    {"RORB", KOC_opcode, 1, 206 },
X    {"RTI", KOC_opcode, 1, 207 },
X    {"RTS", KOC_opcode, 1, 208 },
X    {"SBA", KOC_opcode, 1, 209 },
X    {"SBC", KOC_opcode, 3, 210 },
X    {"SBCA", KOC_opcode, 3, 213 },
X    {"SBCB", KOC_opcode, 3, 216 },
X    {"SEC", KOC_opcode, 1, 219 },
X    {"SEI", KOC_opcode, 1, 220 },
X    {"SET", KOC_SET, 0, 0 },
X    {"SEV", KOC_opcode, 1, 221 },
X    {"SLP", KOC_opcode, 1, 222 },
X    {"STA", KOC_opcode, 2, 223 },
X    {"STAA", KOC_opcode, 2, 225 },
X    {"STAB", KOC_opcode, 2, 227 },
X    {"STD", KOC_opcode, 2, 229 },
X    {"STRING", KOC_SDEF, 0, 0 },
X    {"STS", KOC_opcode, 2, 231 },
X    {"STX", KOC_opcode, 2, 233 },
X    {"SUB", KOC_opcode, 3, 235 },
X    {"SUBA", KOC_opcode, 3, 238 },
X    {"SUBB", KOC_opcode, 3, 241 },
X    {"SUBD", KOC_opcode, 3, 244 },
X    {"SWI", KOC_opcode, 1, 247 },
X    {"TAB", KOC_opcode, 1, 248 },
X    {"TAP", KOC_opcode, 1, 249 },
X    {"TBA", KOC_opcode, 1, 250 },
X    {"TIM", KOC_opcode, 2, 251 },
X    {"TPA", KOC_opcode, 1, 253 },
X    {"TST", KOC_opcode, 3, 254 },
X    {"TSTA", KOC_opcode, 1, 257 },
X    {"TSTB", KOC_opcode, 1, 258 },
X    {"TSX", KOC_opcode, 1, 259 },
X    {"TXS", KOC_opcode, 1, 260 },
X    {"WAI", KOC_opcode, 1, 261 },
X    {"WORD", KOC_WDEF, 0, 0 },
X    {"XGDX", KOC_opcode, 1, 262 },
X    { "", 0, 0, 0 }};
X
Xstruct opsynt ostab[NUMSYNBLK+1]
X    = {
X/* invalid 0 */ { 0, 1, 0 },
X/* invalid 1 */ { 0xffff, 1, 1 },
X/* ABA 2 */ { ST_INH, 1, 2 },
X/* ABX 3 */ { ST_INH, 1, 3 },
X/* ADC 4 */ { ST_AEXP, 4, 4 },
X/* ADC 5 */ { ST_AIMM, 2, 8 },
X/* ADC 6 */ { ST_AIND, 2, 10 },
X/* ADCA 7 */ { ST_EXP, 2, 12 },
X/* ADCA 8 */ { ST_IMM, 1, 14 },
X/* ADCA 9 */ { ST_IND, 1, 15 },
X/* ADCB 10 */ { ST_EXP, 2, 16 },
X/* ADCB 11 */ { ST_IMM, 1, 18 },
X/* ADCB 12 */ { ST_IND, 1, 19 },
X/* ADD 13 */ { ST_AEXP, 4, 20 },
X/* ADD 14 */ { ST_AIMM, 2, 24 },
X/* ADD 15 */ { ST_AIND, 2, 26 },
X/* ADDA 16 */ { ST_EXP, 2, 28 },
X/* ADDA 17 */ { ST_IMM, 1, 30 },
X/* ADDA 18 */ { ST_IND, 1, 31 },
X/* ADDB 19 */ { ST_EXP, 2, 32 },
X/* ADDB 20 */ { ST_IMM, 1, 34 },
X/* ADDB 21 */ { ST_IND, 1, 35 },
X/* ADDD 22 */ { ST_EXP, 2, 36 },
X/* ADDD 23 */ { ST_IMM, 1, 38 },
X/* ADDD 24 */ { ST_IND, 1, 39 },
X/* AIM 25 */ { ST_MEMIMM, 1, 40 },
X/* AIM 26 */ { ST_MEMIMMIND, 1, 41 },
X/* AND 27 */ { ST_AEXP, 4, 42 },
X/* AND 28 */ { ST_AIMM, 2, 46 },
X/* AND 29 */ { ST_AIND, 2, 48 },
X/* ANDA 30 */ { ST_EXP, 2, 50 },
X/* ANDA 31 */ { ST_IMM, 1, 52 },
X/* ANDA 32 */ { ST_IND, 1, 53 },
X/* ANDB 33 */ { ST_EXP, 2, 54 },
X/* ANDB 34 */ { ST_IMM, 1, 56 },
X/* ANDB 35 */ { ST_IND, 1, 57 },
X/* ASL 36 */ { ST_ACC, 2, 58 },
X/* ASL 37 */ { ST_EXP, 1, 60 },
X/* ASL 38 */ { ST_IND, 1, 61 },
X/* ASLA 39 */ { ST_INH, 1, 62 },
X/* ASLB 40 */ { ST_INH, 1, 63 },
X/* ASLD 41 */ { ST_INH, 1, 64 },
X/* ASR 42 */ { ST_ACC, 2, 65 },
X/* ASR 43 */ { ST_EXP, 1, 67 },
X/* ASR 44 */ { ST_IND, 1, 68 },
X/* ASRA 45 */ { ST_INH, 1, 69 },
X/* ASRB 46 */ { ST_INH, 1, 70 },
X/* BCC 47 */ { ST_EXP, 1, 71 },
X/* BCLR 48 */ { ST_BSET, 8, 72 },
X/* BCLR 49 */ { ST_BSETIND, 8, 80 },
X/* BCS 50 */ { ST_EXP, 1, 88 },
X/* BEQ 51 */ { ST_EXP, 1, 89 },
X/* BGE 52 */ { ST_EXP, 1, 90 },
X/* BGT 53 */ { ST_EXP, 1, 91 },
X/* BHI 54 */ { ST_EXP, 1, 92 },
X/* BHS 55 */ { ST_EXP, 1, 93 },
X/* BIT 56 */ { ST_AEXP, 4, 94 },
X/* BIT 57 */ { ST_AIMM, 2, 98 },
X/* BIT 58 */ { ST_AIND, 2, 100 },
X/* BITA 59 */ { ST_EXP, 2, 102 },
X/* BITA 60 */ { ST_IMM, 1, 104 },
X/* BITA 61 */ { ST_IND, 1, 105 },
X/* BITB 62 */ { ST_EXP, 2, 106 },
X/* BITB 63 */ { ST_IMM, 1, 108 },
X/* BITB 64 */ { ST_IND, 1, 109 },
X/* BLE 65 */ { ST_EXP, 1, 110 },
X/* BLO 66 */ { ST_EXP, 1, 111 },
X/* BLS 67 */ { ST_EXP, 1, 112 },
X/* BLT 68 */ { ST_EXP, 1, 113 },
X/* BMI 69 */ { ST_EXP, 1, 114 },
X/* BNE 70 */ { ST_EXP, 1, 115 },
X/* BPL 71 */ { ST_EXP, 1, 116 },
X/* BRA 72 */ { ST_EXP, 1, 117 },
X/* BRN 73 */ { ST_EXP, 1, 118 },
X/* BSET 74 */ { ST_BSET, 8, 119 },
X/* BSET 75 */ { ST_BSETIND, 8, 127 },
X/* BSR 76 */ { ST_EXP, 1, 135 },
X/* BTGL 77 */ { ST_BSET, 8, 136 },
X/* BTGL 78 */ { ST_BSETIND, 8, 144 },
X/* BTST 79 */ { ST_BSET, 8, 152 },
X/* BTST 80 */ { ST_BSETIND, 8, 160 },
X/* BVC 81 */ { ST_EXP, 1, 168 },
X/* BVS 82 */ { ST_EXP, 1, 169 },
X/* CBA 83 */ { ST_INH, 1, 170 },
X/* CLC 84 */ { ST_INH, 1, 171 },
X/* CLI 85 */ { ST_INH, 1, 172 },
X/* CLR 86 */ { ST_ACC, 2, 173 },
X/* CLR 87 */ { ST_EXP, 1, 175 },
X/* CLR 88 */ { ST_IND, 1, 176 },
X/* CLRA 89 */ { ST_INH, 1, 177 },
X/* CLRB 90 */ { ST_INH, 1, 178 },
X/* CLV 91 */ { ST_INH, 1, 179 },
X/* CMP 92 */ { ST_AEXP, 4, 180 },
X/* CMP 93 */ { ST_AIMM, 2, 184 },
X/* CMP 94 */ { ST_AIND, 2, 186 },
X/* CMPA 95 */ { ST_EXP, 2, 188 },
X/* CMPA 96 */ { ST_IMM, 1, 190 },
X/* CMPA 97 */ { ST_IND, 1, 191 },
X/* CMPB 98 */ { ST_EXP, 2, 192 },
X/* CMPB 99 */ { ST_IMM, 1, 194 },
X/* CMPB 100 */ { ST_IND, 1, 195 },
X/* COM 101 */ { ST_ACC, 2, 196 },
X/* COM 102 */ { ST_EXP, 1, 198 },
X/* COM 103 */ { ST_IND, 1, 199 },
X/* COMA 104 */ { ST_INH, 1, 200 },
X/* COMB 105 */ { ST_INH, 1, 201 },
X/* CPX 106 */ { ST_EXP, 2, 202 },
X/* CPX 107 */ { ST_IMM, 1, 204 },
X/* CPX 108 */ { ST_IND, 1, 205 },
X/* DAA 109 */ { ST_INH, 1, 206 },
X/* DEC 110 */ { ST_ACC, 2, 207 },
X/* DEC 111 */ { ST_EXP, 1, 209 },
X/* DEC 112 */ { ST_IND, 1, 210 },
X/* DECA 113 */ { ST_INH, 1, 211 },
X/* DECB 114 */ { ST_INH, 1, 212 },
X/* DES 115 */ { ST_INH, 1, 213 },
X/* DEX 116 */ { ST_INH, 1, 214 },
X/* EIM 117 */ { ST_MEMIMM, 1, 215 },
X/* EIM 118 */ { ST_MEMIMMIND, 1, 216 },
X/* EOR 119 */ { ST_AEXP, 4, 217 },
X/* EOR 120 */ { ST_AIMM, 2, 221 },
X/* EOR 121 */ { ST_AIND, 2, 223 },
X/* EORA 122 */ { ST_EXP, 2, 225 },
X/* EORA 123 */ { ST_IMM, 1, 227 },
X/* EORA 124 */ { ST_IND, 1, 228 },
X/* EORB 125 */ { ST_EXP, 2, 229 },
X/* EORB 126 */ { ST_IMM, 1, 231 },
X/* EORB 127 */ { ST_IND, 1, 232 },
X/* INC 128 */ { ST_ACC, 2, 233 },
X/* INC 129 */ { ST_EXP, 1, 235 },
X/* INC 130 */ { ST_IND, 1, 236 },
X/* INCA 131 */ { ST_INH, 1, 237 },
X/* INCB 132 */ { ST_INH, 1, 238 },
X/* INS 133 */ { ST_INH, 1, 239 },
X/* INX 134 */ { ST_INH, 1, 240 },
X/* JMP 135 */ { ST_EXP, 1, 241 },
X/* JMP 136 */ { ST_IND, 1, 242 },
X/* JSR 137 */ { ST_EXP, 2, 243 },
X/* JSR 138 */ { ST_IND, 1, 245 },
X/* LDA 139 */ { ST_AEXP, 4, 246 },
X/* LDA 140 */ { ST_AIMM, 2, 250 },
X/* LDA 141 */ { ST_AIND, 2, 252 },
X/* LDAA 142 */ { ST_EXP, 2, 254 },
X/* LDAA 143 */ { ST_IMM, 1, 256 },
X/* LDAA 144 */ { ST_IND, 1, 257 },
X/* LDAB 145 */ { ST_EXP, 2, 258 },
X/* LDAB 146 */ { ST_IMM, 1, 260 },
X/* LDAB 147 */ { ST_IND, 1, 261 },
X/* LDD 148 */ { ST_EXP, 2, 262 },
X/* LDD 149 */ { ST_IMM, 1, 264 },
X/* LDD 150 */ { ST_IND, 1, 265 },
X/* LDS 151 */ { ST_EXP, 2, 266 },
X/* LDS 152 */ { ST_IMM, 1, 268 },
X/* LDS 153 */ { ST_IND, 1, 269 },
X/* LDX 154 */ { ST_EXP, 2, 270 },
X/* LDX 155 */ { ST_IMM, 1, 272 },
X/* LDX 156 */ { ST_IND, 1, 273 },
X/* LSL 157 */ { ST_ACC, 2, 274 },
X/* LSL 158 */ { ST_EXP, 1, 276 },
X/* LSL 159 */ { ST_IND, 1, 277 },
X/* LSLA 160 */ { ST_INH, 1, 278 },
X/* LSLB 161 */ { ST_INH, 1, 279 },
X/* LSLD 162 */ { ST_INH, 1, 280 },
X/* LSR 163 */ { ST_ACC, 2, 281 },
X/* LSR 164 */ { ST_EXP, 1, 283 },
X/* LSR 165 */ { ST_IND, 1, 284 },
X/* LSRA 166 */ { ST_INH, 1, 285 },
X/* LSRB 167 */ { ST_INH, 1, 286 },
X/* LSRD 168 */ { ST_INH, 1, 287 },
X/* MUL 169 */ { ST_INH, 1, 288 },
X/* NEG 170 */ { ST_ACC, 2, 289 },
X/* NEG 171 */ { ST_EXP, 1, 291 },
X/* NEG 172 */ { ST_IND, 1, 292 },
X/* NEGA 173 */ { ST_INH, 1, 293 },
X/* NEGB 174 */ { ST_INH, 1, 294 },
X/* NOP 175 */ { ST_INH, 1, 295 },
X/* OIM 176 */ { ST_MEMIMM, 1, 296 },
X/* OIM 177 */ { ST_MEMIMMIND, 1, 297 },
X/* ORA 178 */ { ST_AEXP, 4, 298 },
X/* ORA 179 */ { ST_AIMM, 2, 302 },
X/* ORA 180 */ { ST_AIND, 2, 304 },
X/* ORAA 181 */ { ST_EXP, 2, 306 },
X/* ORAA 182 */ { ST_IMM, 1, 308 },
X/* ORAA 183 */ { ST_IND, 1, 309 },
X/* ORAB 184 */ { ST_EXP, 2, 310 },
X/* ORAB 185 */ { ST_IMM, 1, 312 },
X/* ORAB 186 */ { ST_IND, 1, 313 },
X/* PSH 187 */ { ST_ACC, 2, 314 },
X/* PSH 188 */ { ST_INDREG, 1, 316 },
X/* PSHA 189 */ { ST_INH, 1, 317 },
X/* PSHB 190 */ { ST_INH, 1, 318 },
X/* PSHX 191 */ { ST_INH, 1, 319 },
X/* PUL 192 */ { ST_ACC, 2, 320 },
X/* PUL 193 */ { ST_INDREG, 1, 322 },
X/* PULA 194 */ { ST_INH, 1, 323 },
X/* PULB 195 */ { ST_INH, 1, 324 },
X/* PULX 196 */ { ST_INH, 1, 325 },
X/* ROL 197 */ { ST_ACC, 2, 326 },
X/* ROL 198 */ { ST_EXP, 1, 328 },
X/* ROL 199 */ { ST_IND, 1, 329 },
X/* ROLA 200 */ { ST_INH, 1, 330 },
X/* ROLB 201 */ { ST_INH, 1, 331 },
X/* ROR 202 */ { ST_ACC, 2, 332 },
X/* ROR 203 */ { ST_EXP, 1, 334 },
X/* ROR 204 */ { ST_IND, 1, 335 },
X/* RORA 205 */ { ST_INH, 1, 336 },
X/* RORB 206 */ { ST_INH, 1, 337 },
X/* RTI 207 */ { ST_INH, 1, 338 },
X/* RTS 208 */ { ST_INH, 1, 339 },
X/* SBA 209 */ { ST_INH, 1, 340 },
X/* SBC 210 */ { ST_AEXP, 4, 341 },
X/* SBC 211 */ { ST_AIMM, 2, 345 },
X/* SBC 212 */ { ST_AIND, 2, 347 },
X/* SBCA 213 */ { ST_EXP, 2, 349 },
X/* SBCA 214 */ { ST_IMM, 1, 351 },
X/* SBCA 215 */ { ST_IND, 1, 352 },
X/* SBCB 216 */ { ST_EXP, 2, 353 },
X/* SBCB 217 */ { ST_IMM, 1, 355 },
X/* SBCB 218 */ { ST_IND, 1, 356 },
X/* SEC 219 */ { ST_INH, 1, 357 },
X/* SEI 220 */ { ST_INH, 1, 358 },
X/* SEV 221 */ { ST_INH, 1, 359 },
X/* SLP 222 */ { ST_INH, 1, 360 },
X/* STA 223 */ { ST_AEXP, 4, 361 },
X/* STA 224 */ { ST_AIND, 2, 365 },
X/* STAA 225 */ { ST_EXP, 2, 367 },
X/* STAA 226 */ { ST_IND, 1, 369 },
X/* STAB 227 */ { ST_EXP, 2, 370 },
X/* STAB 228 */ { ST_IND, 1, 372 },
X/* STD 229 */ { ST_EXP, 2, 373 },
X/* STD 230 */ { ST_IND, 1, 375 },
X/* STS 231 */ { ST_EXP, 2, 376 },
X/* STS 232 */ { ST_IND, 1, 378 },
X/* STX 233 */ { ST_EXP, 2, 379 },
X/* STX 234 */ { ST_IND, 1, 381 },
X/* SUB 235 */ { ST_AEXP, 4, 382 },
X/* SUB 236 */ { ST_AIMM, 2, 386 },
X/* SUB 237 */ { ST_AIND, 2, 388 },
X/* SUBA 238 */ { ST_EXP, 2, 390 },
X/* SUBA 239 */ { ST_IMM, 1, 392 },
X/* SUBA 240 */ { ST_IND, 1, 393 },
X/* SUBB 241 */ { ST_EXP, 2, 394 },
X/* SUBB 242 */ { ST_IMM, 1, 396 },
X/* SUBB 243 */ { ST_IND, 1, 397 },
X/* SUBD 244 */ { ST_EXP, 2, 398 },
X/* SUBD 245 */ { ST_IMM, 1, 400 },
X/* SUBD 246 */ { ST_IND, 1, 401 },
X/* SWI 247 */ { ST_INH, 1, 402 },
X/* TAB 248 */ { ST_INH, 1, 403 },
X/* TAP 249 */ { ST_INH, 1, 404 },
X/* TBA 250 */ { ST_INH, 1, 405 },
X/* TIM 251 */ { ST_MEMIMM, 1, 406 },
X/* TIM 252 */ { ST_MEMIMMIND, 1, 407 },
X/* TPA 253 */ { ST_INH, 1, 408 },
X/* TST 254 */ { ST_ACC, 2, 409 },
X/* TST 255 */ { ST_EXP, 1, 411 },
X/* TST 256 */ { ST_IND, 1, 412 },
X/* TSTA 257 */ { ST_INH, 1, 413 },
X/* TSTB 258 */ { ST_INH, 1, 414 },
X/* TSX 259 */ { ST_INH, 1, 415 },
X/* TXS 260 */ { ST_INH, 1, 416 },
X/* WAI 261 */ { ST_INH, 1, 417 },
X/* XGDX 262 */ { ST_INH, 1, 418 },
X    { 0, 0, 0 } };
X
Xstruct igel igtab[NUMDIFFOP+1]
X    = {
X/* invalid 0 */   { 0 , 0,
X        "[Xnullentry" },
X/* invalid 1 */   { 0 , 0,
X        "[Xinvalid opcode" },
X/* ABA 2 */   { 0 , 0,
X        "1b;" },
X/* ABX 3 */   { 0 , 0,
X        "3a;" },
X/* ADC 4 */   { ACCREG+ADDR , REGA+DIRECT,
X        "99;[1=];" },
X/* ADC 5 */   { ACCREG+ADDR , REGA+EXTENDED,
X        "b9;[1=]x" },
X/* ADC 6 */   { ACCREG+ADDR , REGB+DIRECT,
X        "d9;[1=];" },
X/* ADC 7 */   { ACCREG+ADDR , REGB+EXTENDED,
X        "f9;[1=]x" },
X/* ADC 8 */   { ACCREG , REGA,
X        "89;[1=];" },
X/* ADC 9 */   { ACCREG , REGB,
X        "c9;[1=];" },
X/* ADC 10 */   { ACCREG , REGA,
X        "a9;[1=];" },
X/* ADC 11 */   { ACCREG , REGB,
X        "e9;[1=];" },
X/* ADCA 12 */   { ADDR , DIRECT,
X        "99;[1=];" },
X/* ADCA 13 */   { ADDR , EXTENDED,
X        "b9;[1=]x" },
X/* ADCA 14 */   { 0 , 0,
X        "89;[1=];" },
X/* ADCA 15 */   { 0 , 0,
X        "a9;[1=];" },
X/* ADCB 16 */   { ADDR , DIRECT,
X        "d9;[1=];" },
X/* ADCB 17 */   { ADDR , EXTENDED,
X        "f9;[1=]x" },
X/* ADCB 18 */   { 0 , 0,
X        "c9;[1=];" },
X/* ADCB 19 */   { 0 , 0,
X        "e9;[1=];" },
X/* ADD 20 */   { ACCREG+ADDR , REGA+DIRECT,
X        "9b;[1=];" },
X/* ADD 21 */   { ACCREG+ADDR , REGA+EXTENDED,
X        "bb;[1=]x" },
X/* ADD 22 */   { ACCREG+ADDR , REGB+DIRECT,
X        "db;[1=];" },
X/* ADD 23 */   { ACCREG+ADDR , REGB+EXTENDED,
X        "fb;[1=]x" },
X/* ADD 24 */   { ACCREG , REGA,
X        "8b;[1=];" },
X/* ADD 25 */   { ACCREG , REGB,
X        "cb;[1=];" },
X/* ADD 26 */   { ACCREG , REGA,
X        "ab;[1=];" },
X/* ADD 27 */   { ACCREG , REGB,
X        "eb;[1=];" },
X/* ADDA 28 */   { ADDR , DIRECT,
X        "9b;[1=];" },
X/* ADDA 29 */   { ADDR , EXTENDED,
X        "bb;[1=]x" },
X/* ADDA 30 */   { 0 , 0,
X        "8b;[1=];" },
X/* ADDA 31 */   { 0 , 0,
X        "ab;[1=];" },
X/* ADDB 32 */   { ADDR , DIRECT,
X        "db;[1=];" },
X/* ADDB 33 */   { ADDR , EXTENDED,
X        "fb;[1=]x" },
X/* ADDB 34 */   { 0 , 0,
X        "cb;[1=];" },
X/* ADDB 35 */   { 0 , 0,
X        "eb;[1=];" },
X/* ADDD 36 */   { ADDR , DIRECT,
X        "d3;[1=];" },
X/* ADDD 37 */   { ADDR , EXTENDED,
X        "f3;[1=]x" },
X/* ADDD 38 */   { 0 , 0,
X        "c3;[1=]x" },
X/* ADDD 39 */   { 0 , 0,
X        "e3;[1=];" },
X/* AIM 40 */   { 0 , 0,
X        "71;[1=];[2=];" },
X/* AIM 41 */   { 0 , 0,
X        "61;[1=];[2=];" },
X/* AND 42 */   { ACCREG+ADDR , REGA+DIRECT,
X        "94;[1=];" },
X/* AND 43 */   { ACCREG+ADDR , REGA+EXTENDED,
X        "b4;[1=]x" },
X/* AND 44 */   { ACCREG+ADDR , REGB+DIRECT,
X        "d4;[1=];" },
X/* AND 45 */   { ACCREG+ADDR , REGB+EXTENDED,
X        "f4;[1=]x" },
X/* AND 46 */   { ACCREG , REGA,
X        "84;[1=];" },
X/* AND 47 */   { ACCREG , REGB,
X        "c4;[1=];" },
X/* AND 48 */   { ACCREG , REGA,
X        "a4;[1=];" },
X/* AND 49 */   { ACCREG , REGB,
X        "e4;[1=];" },
X/* ANDA 50 */   { ADDR , DIRECT,
X        "94;[1=];" },
X/* ANDA 51 */   { ADDR , EXTENDED,
X        "b4;[1=]x" },
X/* ANDA 52 */   { 0 , 0,
X        "84;[1=];" },
X/* ANDA 53 */   { 0 , 0,
X        "a4;[1=];" },
X/* ANDB 54 */   { ADDR , DIRECT,
X        "d4;[1=];" },
X/* ANDB 55 */   { ADDR , EXTENDED,
X        "f4;[1=]x" },
X/* ANDB 56 */   { 0 , 0,
X        "c4;[1=];" },
X/* ANDB 57 */   { 0 , 0,
X        "e4;[1=];" },
X/* ASL 58 */   { ACCREG , REGA,
X        "48;" },
X/* ASL 59 */   { ACCREG , REGB,
X        "58;" },
X/* ASL 60 */   { 0 , 0,
X        "78;[1=]x" },
X/* ASL 61 */   { 0 , 0,
X        "68;[1=];" },
X/* ASLA 62 */   { 0 , 0,
X        "48;" },
X/* ASLB 63 */   { 0 , 0,
X        "58;" },
X/* ASLD 64 */   { 0 , 0,
X        "05;" },
X/* ASR 65 */   { ACCREG , REGA,
X        "47;" },
X/* ASR 66 */   { ACCREG , REGB,
X        "57;" },
X/* ASR 67 */   { 0 , 0,
X        "77;[1=]x" },
X/* ASR 68 */   { 0 , 0,
X        "67;[1=];" },
X/* ASRA 69 */   { 0 , 0,
X        "47;" },
X/* ASRB 70 */   { 0 , 0,
X        "57;" },
X/* BCC 71 */   { 0 , 0,
X        "24;[1=].P.2+-r" },
X/* BCLR 72 */   { BITNUMB , BIT0,
X        "71;fe;[2=];" },
X/* BCLR 73 */   { BITNUMB , BIT1,
X        "71;fd;[2=];" },
X/* BCLR 74 */   { BITNUMB , BIT2,
X        "71;fb;[2=];" },
X/* BCLR 75 */   { BITNUMB , BIT3,
X        "71;f7;[2=];" },
X/* BCLR 76 */   { BITNUMB , BIT4,
X        "71;ef;[2=];" },
X/* BCLR 77 */   { BITNUMB , BIT5,
X        "71;df;[2=];" },
X/* BCLR 78 */   { BITNUMB , BIT6,
X        "71;bf;[2=];" },
X/* BCLR 79 */   { BITNUMB , BIT7,
X        "71;7f;[2=];" },
X/* BCLR 80 */   { BITNUMB , BIT0,
X        "61;fe;[2=];" },
X/* BCLR 81 */   { BITNUMB , BIT1,
X        "61;fd;[2=];" },
X/* BCLR 82 */   { BITNUMB , BIT2,
X        "61;fb;[2=];" },
X/* BCLR 83 */   { BITNUMB , BIT3,
X        "61;f7;[2=];" },
X/* BCLR 84 */   { BITNUMB , BIT4,
X        "61;ef;[2=];" },
X/* BCLR 85 */   { BITNUMB , BIT5,
X        "61;df;[2=];" },
X/* BCLR 86 */   { BITNUMB , BIT6,
X        "61;bf;[2=];" },
X/* BCLR 87 */   { BITNUMB , BIT7,
X        "61;7f;[2=];" },
X/* BCS 88 */   { 0 , 0,
X        "25;[1=].P.2+-r" },
X/* BEQ 89 */   { 0 , 0,
X        "27;[1=].P.2+-r" },
X/* BGE 90 */   { 0 , 0,
X        "2c;[1=].P.2+-r" },
X/* BGT 91 */   { 0 , 0,
X        "2e;[1=].P.2+-r" },
X/* BHI 92 */   { 0 , 0,
X        "22;[1=].P.2+-r" },
X/* BHS 93 */   { 0 , 0,
X        "24;[1=].P.2+-r" },
X/* BIT 94 */   { ACCREG+ADDR , REGA+DIRECT,
X        "95;[1=];" },
X/* BIT 95 */   { ACCREG+ADDR , REGA+EXTENDED,
X        "b5;[1=]x" },
X/* BIT 96 */   { ACCREG+ADDR , REGB+DIRECT,
X        "d5;[1=];" },
X/* BIT 97 */   { ACCREG+ADDR , REGB+EXTENDED,
X        "f5;[1=]x" },
X/* BIT 98 */   { ACCREG , REGA,
X        "85;[1=];" },
X/* BIT 99 */   { ACCREG , REGB,
X        "c5;[1=];" },
X/* BIT 100 */   { ACCREG , REGA,
X        "a5;[1=];" },
X/* BIT 101 */   { ACCREG , REGB,
X        "e5;[1=];" },
X/* BITA 102 */   { ADDR , DIRECT,
X        "95;[1=];" },
X/* BITA 103 */   { ADDR , EXTENDED,
X        "b5;[1=]x" },
X/* BITA 104 */   { 0 , 0,
X        "85;[1=];" },
X/* BITA 105 */   { 0 , 0,
X        "a5;[1=];" },
X/* BITB 106 */   { ADDR , DIRECT,
X        "d5;[1=];" },
X/* BITB 107 */   { ADDR , EXTENDED,
X        "f5;[1=]x" },
X/* BITB 108 */   { 0 , 0,
X        "c5;[1=];" },
X/* BITB 109 */   { 0 , 0,
X        "e5;[1=];" },
X/* BLE 110 */   { 0 , 0,
X        "2f;[1=].P.2+-r" },
X/* BLO 111 */   { 0 , 0,
X        "25;[1=].P.2+-r" },
X/* BLS 112 */   { 0 , 0,
X        "23;[1=].P.2+-r" },
X/* BLT 113 */   { 0 , 0,
X        "2d;[1=].P.2+-r" },
X/* BMI 114 */   { 0 , 0,
X        "2b;[1=].P.2+-r" },
X/* BNE 115 */   { 0 , 0,
X        "26;[1=].P.2+-r" },
X/* BPL 116 */   { 0 , 0,
X        "2a;[1=].P.2+-r" },
X/* BRA 117 */   { 0 , 0,
X        "20;[1=].P.2+-r" },
X/* BRN 118 */   { 0 , 0,
X        "21;[1=].P.2+-r" },
X/* BSET 119 */   { BITNUMB , BIT0,
X        "72;01;[2=];" },
X/* BSET 120 */   { BITNUMB , BIT1,
X        "72;02;[2=];" },
X/* BSET 121 */   { BITNUMB , BIT2,
X        "72;04;[2=];" },
X/* BSET 122 */   { BITNUMB , BIT3,
X        "72;08;[2=];" },
X/* BSET 123 */   { BITNUMB , BIT4,
X        "72;10;[2=];" },
X/* BSET 124 */   { BITNUMB , BIT5,
X        "72;20;[2=];" },
X/* BSET 125 */   { BITNUMB , BIT6,
X        "72;40;[2=];" },
X/* BSET 126 */   { BITNUMB , BIT7,
X        "72;80;[2=];" },
X/* BSET 127 */   { BITNUMB , BIT0,
X        "62;01;[2=];" },
X/* BSET 128 */   { BITNUMB , BIT1,
X        "62;02;[2=];" },
X/* BSET 129 */   { BITNUMB , BIT2,
X        "62;04;[2=];" },
X/* BSET 130 */   { BITNUMB , BIT3,
X        "62;08;[2=];" },
X/* BSET 131 */   { BITNUMB , BIT4,
X        "62;10;[2=];" },
X/* BSET 132 */   { BITNUMB , BIT5,
X        "62;20;[2=];" },
X/* BSET 133 */   { BITNUMB , BIT6,
X        "62;40;[2=];" },
X/* BSET 134 */   { BITNUMB , BIT7,
X        "62;80;[2=];" },
X/* BSR 135 */   { 0 , 0,
X        "8d;[1=].P.2+-r" },
X/* BTGL 136 */   { BITNUMB , BIT0,
X        "75;01;[2=];" },
X/* BTGL 137 */   { BITNUMB , BIT1,
X        "75;02;[2=];" },
X/* BTGL 138 */   { BITNUMB , BIT2,
X        "75;04;[2=];" },
X/* BTGL 139 */   { BITNUMB , BIT3,
X        "75;08;[2=];" },
X/* BTGL 140 */   { BITNUMB , BIT4,
X        "75;10;[2=];" },
X/* BTGL 141 */   { BITNUMB , BIT5,
X        "75;20;[2=];" },
X/* BTGL 142 */   { BITNUMB , BIT6,
X        "75;40;[2=];" },
X/* BTGL 143 */   { BITNUMB , BIT7,
X        "75;80;[2=];" },
X/* BTGL 144 */   { BITNUMB , BIT0,
X        "65;01;[2=];" },
X/* BTGL 145 */   { BITNUMB , BIT1,
X        "65;02;[2=];" },
X/* BTGL 146 */   { BITNUMB , BIT2,
X        "65;04;[2=];" },
X/* BTGL 147 */   { BITNUMB , BIT3,
X        "65;08;[2=];" },
X/* BTGL 148 */   { BITNUMB , BIT4,
X        "65;10;[2=];" },
X/* BTGL 149 */   { BITNUMB , BIT5,
X        "65;20;[2=];" },
X/* BTGL 150 */   { BITNUMB , BIT6,
X        "65;40;[2=];" },
X/* BTGL 151 */   { BITNUMB , BIT7,
X        "65;80;[2=];" },
X/* BTST 152 */   { BITNUMB , BIT0,
X        "7b;01;[2=];" },
X/* BTST 153 */   { BITNUMB , BIT1,
X        "7b;02;[2=];" },
X/* BTST 154 */   { BITNUMB , BIT2,
X        "7b;04;[2=];" },
X/* BTST 155 */   { BITNUMB , BIT3,
X        "7b;08;[2=];" },
X/* BTST 156 */   { BITNUMB , BIT4,
X        "7b;10;[2=];" },
X/* BTST 157 */   { BITNUMB , BIT5,
X        "7b;20;[2=];" },
X/* BTST 158 */   { BITNUMB , BIT6,
X        "7b;40;[2=];" },
X/* BTST 159 */   { BITNUMB , BIT7,
X        "7b;80;[2=];" },
X/* BTST 160 */   { BITNUMB , BIT0,
X        "6b;01;[2=];" },
X/* BTST 161 */   { BITNUMB , BIT1,
X        "6b;02;[2=];" },
X/* BTST 162 */   { BITNUMB , BIT2,
X        "6b;04;[2=];" },
X/* BTST 163 */   { BITNUMB , BIT3,
X        "6b;08;[2=];" },
X/* BTST 164 */   { BITNUMB , BIT4,
X        "6b;10;[2=];" },
X/* BTST 165 */   { BITNUMB , BIT5,
X        "6b;20;[2=];" },
X/* BTST 166 */   { BITNUMB , BIT6,
X        "6b;40;[2=];" },
X/* BTST 167 */   { BITNUMB , BIT7,
X        "6b;80;[2=];" },
X/* BVC 168 */   { 0 , 0,
X        "28;[1=].P.2+-r" },
X/* BVS 169 */   { 0 , 0,
X        "29;[1=].P.2+-r" },
X/* CBA 170 */   { 0 , 0,
X        "11;" },
X/* CLC 171 */   { 0 , 0,
X        "0c;" },
X/* CLI 172 */   { 0 , 0,
X        "0e;" },
X/* CLR 173 */   { ACCREG , REGA,
X        "4f;" },
X/* CLR 174 */   { ACCREG , REGB,
X        "5f;" },
X/* CLR 175 */   { 0 , 0,
X        "7f;[1=]x" },
X/* CLR 176 */   { 0 , 0,
X        "6f;[1=];" },
X/* CLRA 177 */   { 0 , 0,
X        "4f;" },
X/* CLRB 178 */   { 0 , 0,
X        "5f;" },
X/* CLV 179 */   { 0 , 0,
X        "0a;" },
X/* CMP 180 */   { ACCREG+ADDR , REGA+DIRECT,
X        "91;[1=];" },
X/* CMP 181 */   { ACCREG+ADDR , REGA+EXTENDED,
X        "b1;[1=]x" },
X/* CMP 182 */   { ACCREG+ADDR , REGB+DIRECT,
X        "d1;[1=];" },
X/* CMP 183 */   { ACCREG+ADDR , REGB+EXTENDED,
X        "f1;[1=]x" },
X/* CMP 184 */   { ACCREG , REGA,
X        "81;[1=];" },
X/* CMP 185 */   { ACCREG , REGB,
X        "c1;[1=];" },
X/* CMP 186 */   { ACCREG , REGA,
X        "a1;[1=];" },
X/* CMP 187 */   { ACCREG , REGB,
X        "e1;[1=];" },
X/* CMPA 188 */   { ADDR , DIRECT,
X        "91;[1=];" },
X/* CMPA 189 */   { ADDR , EXTENDED,
X        "b1;[1=]x" },
X/* CMPA 190 */   { 0 , 0,
X        "81;[1=];" },
X/* CMPA 191 */   { 0 , 0,
X        "a1;[1=];" },
X/* CMPB 192 */   { ADDR , DIRECT,
X        "d1;[1=];" },
X/* CMPB 193 */   { ADDR , EXTENDED,
X        "f1;[1=]x" },
X/* CMPB 194 */   { 0 , 0,
X        "c1;[1=];" },
X/* CMPB 195 */   { 0 , 0,
X        "e1;[1=];" },
X/* COM 196 */   { ACCREG , REGA,
X        "43;" },
X/* COM 197 */   { ACCREG , REGB,
X        "53;" },
X/* COM 198 */   { 0 , 0,
X        "73;[1=]x" },
X/* COM 199 */   { 0 , 0,
X        "63;[1=];" },
X/* COMA 200 */   { 0 , 0,
X        "43;" },
X/* COMB 201 */   { 0 , 0,
X        "53;" },
X/* CPX 202 */   { ADDR , DIRECT,
X        "9c;[1=];" },
X/* CPX 203 */   { ADDR , EXTENDED,
X        "bc;[1=]x" },
X/* CPX 204 */   { 0 , 0,
X        "8c;[1=]x" },
X/* CPX 205 */   { 0 , 0,
X        "ac;[1=];" },
X/* DAA 206 */   { 0 , 0,
X        "19;" },
X/* DEC 207 */   { ACCREG , REGA,
X        "4a;" },
X/* DEC 208 */   { ACCREG , REGB,
X        "5a;" },
X/* DEC 209 */   { 0 , 0,
X        "7a;[1=]x" },
X/* DEC 210 */   { 0 , 0,
X        "6a;[1=];" },
X/* DECA 211 */   { 0 , 0,
X        "4a;" },
X/* DECB 212 */   { 0 , 0,
X        "5a;" },
X/* DES 213 */   { 0 , 0,
X        "34;" },
X/* DEX 214 */   { 0 , 0,
X        "09;" },
X/* EIM 215 */   { 0 , 0,
X        "75;[1=];[2=];" },
X/* EIM 216 */   { 0 , 0,
X        "65;[1=];[2=];" },
X/* EOR 217 */   { ACCREG+ADDR , REGA+DIRECT,
X        "98;[1=];" },
X/* EOR 218 */   { ACCREG+ADDR , REGA+EXTENDED,
X        "b8;[1=]x" },
X/* EOR 219 */   { ACCREG+ADDR , REGB+DIRECT,
X        "d8;[1=];" },
X/* EOR 220 */   { ACCREG+ADDR , REGB+EXTENDED,
X        "f8;[1=]x" },
X/* EOR 221 */   { ACCREG , REGA,
X        "88;[1=];" },
X/* EOR 222 */   { ACCREG , REGB,
X        "c8;[1=];" },
X/* EOR 223 */   { ACCREG , REGA,
X        "a8;[1=];" },
X/* EOR 224 */   { ACCREG , REGB,
X        "e8;[1=];" },
X/* EORA 225 */   { ADDR , DIRECT,
X        "98;[1=];" },
X/* EORA 226 */   { ADDR , EXTENDED,
X        "b8;[1=]x" },
X/* EORA 227 */   { 0 , 0,
X        "88;[1=];" },
X/* EORA 228 */   { 0 , 0,
X        "a8;[1=];" },
X/* EORB 229 */   { ADDR , DIRECT,
X        "d8;[1=];" },
X/* EORB 230 */   { ADDR , EXTENDED,
X        "f8;[1=]x" },
X/* EORB 231 */   { 0 , 0,
X        "c8;[1=];" },
X/* EORB 232 */   { 0 , 0,
X        "e8;[1=];" },
X/* INC 233 */   { ACCREG , REGA,
X        "4c;" },
X/* INC 234 */   { ACCREG , REGB,
X        "5c;" },
X/* INC 235 */   { 0 , 0,
X        "7c;[1=]x" },
X/* INC 236 */   { 0 , 0,
X        "6c;[1=];" },
X/* INCA 237 */   { 0 , 0,
X        "4c;" },
X/* INCB 238 */   { 0 , 0,
X        "5c;" },
X/* INS 239 */   { 0 , 0,
X        "31;" },
X/* INX 240 */   { 0 , 0,
X        "08;" },
X/* JMP 241 */   { 0 , 0,
X        "7e;[1=]x" },
X/* JMP 242 */   { 0 , 0,
X        "6e;[1=];" },
X/* JSR 243 */   { ADDR , DIRECT,
X        "9d;[1=];" },
X/* JSR 244 */   { ADDR , EXTENDED,
X        "bd;[1=]x" },
X/* JSR 245 */   { 0 , 0,
X        "ad;[1=];" },
X/* LDA 246 */   { ACCREG+ADDR , REGA+DIRECT,
X        "96;[1=];" },
X/* LDA 247 */   { ACCREG+ADDR , REGA+EXTENDED,
X        "b6;[1=]x" },
X/* LDA 248 */   { ACCREG+ADDR , REGB+DIRECT,
X        "d6;[1=];" },
X/* LDA 249 */   { ACCREG+ADDR , REGB+EXTENDED,
X        "f6;[1=]x" },
X/* LDA 250 */   { ACCREG , REGA,
X        "86;[1=];" },
X/* LDA 251 */   { ACCREG , REGB,
X        "c6;[1=];" },
X/* LDA 252 */   { ACCREG , REGA,
X        "a6;[1=];" },
X/* LDA 253 */   { ACCREG , REGB,
X        "e6;[1=];" },
X/* LDAA 254 */   { ADDR , DIRECT,
X        "96;[1=];" },
X/* LDAA 255 */   { ADDR , EXTENDED,
X        "b6;[1=]x" },
X/* LDAA 256 */   { 0 , 0,
X        "86;[1=];" },
X/* LDAA 257 */   { 0 , 0,
X        "a6;[1=];" },
X/* LDAB 258 */   { ADDR , DIRECT,
X        "d6;[1=];" },
X/* LDAB 259 */   { ADDR , EXTENDED,
X        "f6;[1=]x" },
X/* LDAB 260 */   { 0 , 0,
X        "c6;[1=];" },
X/* LDAB 261 */   { 0 , 0,
X        "e6;[1=];" },
X/* LDD 262 */   { ADDR , DIRECT,
X        "dc;[1=];" },
X/* LDD 263 */   { ADDR , EXTENDED,
X        "fc;[1=]x" },
X/* LDD 264 */   { 0 , 0,
X        "cc;[1=]x" },
X/* LDD 265 */   { 0 , 0,
X        "ec;[1=];" },
X/* LDS 266 */   { ADDR , DIRECT,
X        "9e;[1=];" },
X/* LDS 267 */   { ADDR , EXTENDED,
X        "be;[1=]x" },
X/* LDS 268 */   { 0 , 0,
X        "8e;[1=]x" },
X/* LDS 269 */   { 0 , 0,
X        "ae;[1=];" },
X/* LDX 270 */   { ADDR , DIRECT,
X        "de;[1=];" },
X/* LDX 271 */   { ADDR , EXTENDED,
X        "fe;[1=]x" },
X/* LDX 272 */   { 0 , 0,
X        "ce;[1=]x" },
X/* LDX 273 */   { 0 , 0,
X        "ee;[1=];" },
X/* LSL 274 */   { ACCREG , REGA,
X        "48;" },
X/* LSL 275 */   { ACCREG , REGB,
X        "58;" },
X/* LSL 276 */   { 0 , 0,
X        "78;[1=]x" },
X/* LSL 277 */   { 0 , 0,
X        "68;[1=];" },
X/* LSLA 278 */   { 0 , 0,
X        "48;" },
X/* LSLB 279 */   { 0 , 0,
X        "58;" },
X/* LSLD 280 */   { 0 , 0,
X        "05;" },
X/* LSR 281 */   { ACCREG , REGA,
X        "44;" },
X/* LSR 282 */   { ACCREG , REGB,
X        "54;" },
X/* LSR 283 */   { 0 , 0,
X        "74;[1=]x" },
X/* LSR 284 */   { 0 , 0,
X        "64;[1=];" },
X/* LSRA 285 */   { 0 , 0,
X        "44;" },
X/* LSRB 286 */   { 0 , 0,
X        "54;" },
X/* LSRD 287 */   { 0 , 0,
X        "04;" },
X/* MUL 288 */   { 0 , 0,
X        "3d;" },
X/* NEG 289 */   { ACCREG , REGA,
X        "40;" },
X/* NEG 290 */   { ACCREG , REGB,
X        "50;" },
X/* NEG 291 */   { 0 , 0,
X        "70;[1=]x" },
X/* NEG 292 */   { 0 , 0,
X        "60;[1=];" },
X/* NEGA 293 */   { 0 , 0,
X        "40;" },
X/* NEGB 294 */   { 0 , 0,
X        "50;" },
X/* NOP 295 */   { 0 , 0,
X        "01;" },
X/* OIM 296 */   { 0 , 0,
X        "72;[1=];[2=];" },
X/* OIM 297 */   { 0 , 0,
X        "62;[1=];[2=];" },
X/* ORA 298 */   { ACCREG+ADDR , REGA+DIRECT,
X        "9a;[1=];" },
X/* ORA 299 */   { ACCREG+ADDR , REGA+EXTENDED,
X        "ba;[1=]x" },
X/* ORA 300 */   { ACCREG+ADDR , REGB+DIRECT,
X        "da;[1=];" },
X/* ORA 301 */   { ACCREG+ADDR , REGB+EXTENDED,
X        "fa;[1=]x" },
X/* ORA 302 */   { ACCREG , REGA,
X        "8a;[1=];" },
X/* ORA 303 */   { ACCREG , REGB,
X        "ca;[1=];" },
X/* ORA 304 */   { ACCREG , REGA,
X        "aa;[1=];" },
X/* ORA 305 */   { ACCREG , REGB,
X        "ea;[1=];" },
X/* ORAA 306 */   { ADDR , DIRECT,
X        "9a;[1=];" },
X/* ORAA 307 */   { ADDR , EXTENDED,
X        "ba;[1=]x" },
X/* ORAA 308 */   { 0 , 0,
X        "8a;[1=];" },
X/* ORAA 309 */   { 0 , 0,
X        "aa;[1=];" },
X/* ORAB 310 */   { ADDR , DIRECT,
X        "da;[1=];" },
X/* ORAB 311 */   { ADDR , EXTENDED,
X        "fa;[1=]x" },
X/* ORAB 312 */   { 0 , 0,
X        "ca;[1=];" },
X/* ORAB 313 */   { 0 , 0,
X        "ea;[1=];" },
X/* PSH 314 */   { ACCREG , REGA,
X        "36;" },
X/* PSH 315 */   { ACCREG , REGB,
X        "37;" },
X/* PSH 316 */   { 0 , 0,
X        "3c;" },
X/* PSHA 317 */   { 0 , 0,
X        "36;" },
X/* PSHB 318 */   { 0 , 0,
X        "37;" },
X/* PSHX 319 */   { 0 , 0,
X        "3c;" },
X/* PUL 320 */   { ACCREG , REGA,
X        "32;" },
X/* PUL 321 */   { ACCREG , REGB,
X        "33;" },
X/* PUL 322 */   { 0 , 0,
X        "38;" },
X/* PULA 323 */   { 0 , 0,
X        "32;" },
X/* PULB 324 */   { 0 , 0,
X        "33;" },
X/* PULX 325 */   { 0 , 0,
X        "38;" },
X/* ROL 326 */   { ACCREG , REGA,
X        "49;" },
X/* ROL 327 */   { ACCREG , REGB,
X        "59;" },
X/* ROL 328 */   { 0 , 0,
X        "79;[1=]x" },
X/* ROL 329 */   { 0 , 0,
X        "69;[1=];" },
X/* ROLA 330 */   { 0 , 0,
X        "49;" },
X/* ROLB 331 */   { 0 , 0,
X        "59;" },
X/* ROR 332 */   { ACCREG , REGA,
X        "46;" },
X/* ROR 333 */   { ACCREG , REGB,
X        "56;" },
X/* ROR 334 */   { 0 , 0,
X        "76;[1=]x" },
X/* ROR 335 */   { 0 , 0,
X        "66;[1=];" },
X/* RORA 336 */   { 0 , 0,
X        "46;" },
X/* RORB 337 */   { 0 , 0,
X        "56;" },
X/* RTI 338 */   { 0 , 0,
X        "3b;" },
X/* RTS 339 */   { 0 , 0,
X        "39;" },
X/* SBA 340 */   { 0 , 0,
X        "10;" },
X/* SBC 341 */   { ACCREG+ADDR , REGA+DIRECT,
X        "92;[1=];" },
X/* SBC 342 */   { ACCREG+ADDR , REGA+EXTENDED,
X        "b2;[1=]x" },
X/* SBC 343 */   { ACCREG+ADDR , REGB+DIRECT,
X        "d2;[1=];" },
X/* SBC 344 */   { ACCREG+ADDR , REGB+EXTENDED,
X        "f2;[1=]x" },
X/* SBC 345 */   { ACCREG , REGA,
X        "82;[1=];" },
X/* SBC 346 */   { ACCREG , REGB,
X        "c2;[1=];" },
X/* SBC 347 */   { ACCREG , REGA,
X        "a2;[1=];" },
X/* SBC 348 */   { ACCREG , REGB,
X        "e2;[1=];" },
X/* SBCA 349 */   { ADDR , DIRECT,
X        "92;[1=];" },
X/* SBCA 350 */   { ADDR , EXTENDED,
X        "b2;[1=]x" },
X/* SBCA 351 */   { 0 , 0,
X        "82;[1=];" },
X/* SBCA 352 */   { 0 , 0,
X        "a2;[1=];" },
X/* SBCB 353 */   { ADDR , DIRECT,
X        "d2;[1=];" },
X/* SBCB 354 */   { ADDR , EXTENDED,
X        "f2;[1=]x" },
X/* SBCB 355 */   { 0 , 0,
X        "c2;[1=];" },
X/* SBCB 356 */   { 0 , 0,
X        "e2;[1=];" },
X/* SEC 357 */   { 0 , 0,
X        "0d;" },
X/* SEI 358 */   { 0 , 0,
X        "0f;" },
X/* SEV 359 */   { 0 , 0,
X        "0b;" },
X/* SLP 360 */   { 0 , 0,
X        "1a;" },
X/* STA 361 */   { ACCREG+ADDR , REGA+DIRECT,
X        "97;[1=];" },
X/* STA 362 */   { ACCREG+ADDR , REGA+EXTENDED,
X        "b7;[1=]x" },
X/* STA 363 */   { ACCREG+ADDR , REGB+DIRECT,
X        "d7;[1=];" },
X/* STA 364 */   { ACCREG+ADDR , REGB+EXTENDED,
X        "f7;[1=]x" },
X/* STA 365 */   { ACCREG , REGA,
X        "a7;[1=];" },
X/* STA 366 */   { ACCREG , REGB,
X        "e7;[1=];" },
X/* STAA 367 */   { ADDR , DIRECT,
X        "97;[1=];" },
X/* STAA 368 */   { ADDR , EXTENDED,
X        "b7;[1=]x" },
X/* STAA 369 */   { 0 , 0,
X        "a7;[1=];" },
X/* STAB 370 */   { ADDR , DIRECT,
X        "d7;[1=];" },
X/* STAB 371 */   { ADDR , EXTENDED,
X        "f7;[1=]x" },
X/* STAB 372 */   { 0 , 0,
X        "e7;[1=];" },
X/* STD 373 */   { ADDR , DIRECT,
X        "dd;[1=];" },
X/* STD 374 */   { ADDR , EXTENDED,
X        "fd;[1=]x" },
X/* STD 375 */   { 0 , 0,
X        "ed;[1=];" },
X/* STS 376 */   { ADDR , DIRECT,
X        "9f;[1=];" },
X/* STS 377 */   { ADDR , EXTENDED,
X        "bf;[1=]x" },
X/* STS 378 */   { 0 , 0,
X        "af;[1=];" },
X/* STX 379 */   { ADDR , DIRECT,
X        "df;[1=];" },
X/* STX 380 */   { ADDR , EXTENDED,
X        "ff;[1=]x" },
X/* STX 381 */   { 0 , 0,
X        "ef;[1=];" },
X/* SUB 382 */   { ACCREG+ADDR , REGA+DIRECT,
X        "90;[1=];" },
X/* SUB 383 */   { ACCREG+ADDR , REGA+EXTENDED,
X        "b0;[1=]x" },
X/* SUB 384 */   { ACCREG+ADDR , REGB+DIRECT,
X        "d0;[1=];" },
X/* SUB 385 */   { ACCREG+ADDR , REGB+EXTENDED,
X        "f0;[1=]x" },
X/* SUB 386 */   { ACCREG , REGA,
X        "80;[1=];" },
X/* SUB 387 */   { ACCREG , REGB,
X        "c0;[1=];" },
X/* SUB 388 */   { ACCREG , REGA,
X        "a0;[1=];" },
X/* SUB 389 */   { ACCREG , REGB,
X        "e0;[1=];" },
X/* SUBA 390 */   { ADDR , DIRECT,
X        "90;[1=];" },
X/* SUBA 391 */   { ADDR , EXTENDED,
X        "b0;[1=]x" },
X/* SUBA 392 */   { 0 , 0,
X        "80;[1=];" },
X/* SUBA 393 */   { 0 , 0,
X        "a0;[1=];" },
X/* SUBB 394 */   { ADDR , DIRECT,
X        "d0;[1=];" },
X/* SUBB 395 */   { ADDR , EXTENDED,
X        "f0;[1=]x" },
X/* SUBB 396 */   { 0 , 0,
X        "c0;[1=];" },
X/* SUBB 397 */   { 0 , 0,
X        "e0;[1=];" },
X/* SUBD 398 */   { ADDR , DIRECT,
X        "93;[1=];" },
X/* SUBD 399 */   { ADDR , EXTENDED,
X        "b3;[1=]x" },
X/* SUBD 400 */   { 0 , 0,
X        "83;[1=]x" },
X/* SUBD 401 */   { 0 , 0,
X        "a3;[1=];" },
X/* SWI 402 */   { 0 , 0,
X        "3f;" },
X/* TAB 403 */   { 0 , 0,
X        "16;" },
X/* TAP 404 */   { 0 , 0,
X        "06;" },
X/* TBA 405 */   { 0 , 0,
X        "17;" },
X/* TIM 406 */   { 0 , 0,
X        "7b;[1=];[2=];" },
X/* TIM 407 */   { 0 , 0,
X        "6b;[1=];[2=];" },
X/* TPA 408 */   { 0 , 0,
X        "07;" },
X/* TST 409 */   { ACCREG , REGA,
X        "4d;" },
X/* TST 410 */   { ACCREG , REGB,
X        "5d;" },
X/* TST 411 */   { 0 , 0,
X        "7d;[1=]x" },
X/* TST 412 */   { 0 , 0,
X        "6d;[1=];" },
X/* TSTA 413 */   { 0 , 0,
X        "4d;" },
X/* TSTB 414 */   { 0 , 0,
X        "5d;" },
X/* TSX 415 */   { 0 , 0,
X        "30;" },
X/* TXS 416 */   { 0 , 0,
X        "35;" },
X/* WAI 417 */   { 0 , 0,
X        "3e;" },
X/* XGDX 418 */   { 0 , 0,
X        "18;" },
X    { 0,0,""} };
X/* end fraptabdef.c */
SHAR_EOF
true || echo 'restore of as6301.y failed'
fi
exit 0