home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Source Code 1992 March
/
Source_Code_CD-ROM_Walnut_Creek_March_1992.iso
/
usenet
/
altsrcs
/
2
/
2223
< prev
next >
Wrap
Internet Message Format
|
1990-12-28
|
52KB
From: markz@ssc.UUCP (Mark Zenier)
Newsgroups: alt.sources
Subject: Frankstein Cross Assemblers, Motorola 6809, Part 2 of 2
Message-ID: <616@ssc.UUCP>
Date: 6 Dec 90 07:24:27 GMT
---- Cut Here and feed the following to sh ----
#!/bin/sh
# This is part 02 of Frankasm/As6809
# ============= as6809.y ==============
if test -f 'as6809.y' -a X"$1" != X"-c"; then
echo 'x - skipping as6809.y (File already exists)'
else
echo 'x - extracting as6809.y (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'as6809.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: as6809.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: as6809.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/* 6809 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 /* select criteria for ST_EXP 0000.0000.0000.00xx */
X#define ADDR 0x3
X#define DIRECT 0x1
X#define EXTENDED 0x2
X#define ST_INH 0x1
X#define ST_IMM 0x2
X#define ST_EXP 0x4
X#define ST_IND 0x8
X#define ST_PCR 0x10
X#define ST_IPCR 0x20
X#define ST_IEXPR 0x40
X#define ST_SPSH 0x1
X#define ST_UPSH 0x1
X#define ST_TFR 0x1
X
X static char genbdef[] = "[1=];";
X static char genwdef[] = "[1=]x"; /* x for normal, y for byte rev */
X char ignosyn[] = "[Xinvalid syntax for instruction";
X char ignosel[] = "[Xinvalid operands";
X#define IDM000 0
X#define IDM100 1
X#define IDM101 2
X#define IDM102 3
X#define IDM103 4
X#define IDM104 5
X#define IDM105 6
X#define IDM106 7
X#define IDM108 8
X#define IDM109 9
X#define IDM10B 10
X#define IDM111 11
X#define IDM113 12
X#define IDM114 13
X#define IDM115 14
X#define IDM116 15
X#define IDM118 16
X#define IDM119 17
X#define IDM11B 18
X char *(indexgen [] [4]) = {
X/*IDM000;*/ { "[1=].5R.00|;", "[1=].5R.20|;", "[1=].5R.40|;", "[1=].5R.60|;"},
X/*IDM100;*/ { "80;", "a0;", "c0;", "e0;" },
X/*IDM101;*/ { "81;", "a1;", "c1;", "e1;" },
X/*IDM102;*/ { "82;", "a2;", "c2;", "e2;" },
X/*IDM103;*/ { "83;", "a3;", "c3;", "e3;" },
X/*IDM104;*/ { "84;", "a4;", "c4;", "e4;" },
X/*IDM105;*/ { "85;", "a5;", "c5;", "e5;" },
X/*IDM106;*/ { "86;", "a6;", "c6;", "e6;" },
X/*IDM108;*/ { "88;[1=]r", "a8;[1=]r", "c8;[1=]r", "e8;[1=]r" },
X/*IDM109;*/ { "89;[1=]x", "a9;[1=]x", "c9;[1=]x", "e9;[1=]x" },
X/*IDM10B;*/ { "8B;", "aB;", "cB;", "eB;" },
X/*IDM111;*/ { "91;", "B1;", "D1;", "F1;" },
X/*IDM113;*/ { "93;", "B3;", "D3;", "F3;" },
X/*IDM114;*/ { "94;", "B4;", "D4;", "F4;" },
X/*IDM115;*/ { "95;", "B5;", "D5;", "F5;" },
X/*IDM116;*/ { "96;", "B6;", "D6;", "F6;" },
X/*IDM118;*/ { "98;[1=]r", "b8;[1=]r", "d8;[1=]r", "f8;[1=]r" },
X/*IDM119;*/ { "99;[1=]x", "b9;[1=]x", "d9;[1=]x", "f9;[1=]x" },
X/*IDM11B;*/ { "9B;", "BB;", "DB;", "FB;" }
X };
X
X#define PCRNEG8M -126
X#define PCRPLUS8M 129
X#define PCR8STR "8c;[1=].Q.1+-r"
X#define IPCR8STR "9c;[1=].Q.1+-r"
X#define PCR16STR "8d;[1=].Q.2+-.ffff&x"
X#define IPCR16STR "9d;[1=].Q.2+-.ffff&x"
X#define IEXPSTR "9f;[1=]x"
X#define TFRD 0
X#define TFRX 1
X#define TFRY 2
X#define TFRU 3
X#define TFRS 4
X#define TFRPC 5
X#define TFRA 0x8
X#define TFRB 0x9
X#define TFRCC 0xa
X#define TFRDP 0xb
X#define TFR8BIT 0x8
X#define REGBUSTK 0x100
X#define REGBSSTK 0x200
X#define PPOSTCC 0x01
X#define PPOSTA 0x02
X#define PPOSTB 0x04
X#define PPOSTDP 0x08
X#define PPOSTX 0x10
X#define PPOSTY 0x20
X#define PPOSTS (0x40|REGBSSTK)
X#define PPOSTU (0x40|REGBUSTK)
X#define PPOSTPC 0x80
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}
X
X%token <intv> ACCUM
X%token <intv> INDEX
X%token <intv> SPECREG
X%token PCRELATIVE
X%type <intv> regbits register
X%type <strng> 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%token <intv> KOC_sstkop
X%token <intv> KOC_ustkop
X%token <intv> KOC_tfrop
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 '#' expr
X {
X pevalexpr(1, $3);
X genlocrec(currseg, labelloc);
X locctr += geninstr( findgen($1, ST_IMM, 0));
X }
X ;
Xgenline : KOC_opcode expr
X {
X genlocrec(currseg, labelloc);
X pevalexpr(1, $2);
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 indexed
X {
X genlocrec(currseg, labelloc);
X locctr += geninstr(findgen($1, ST_IND, 0));
X locctr += geninstr($2);
X }
X ;
Xgenline : KOC_opcode expr ',' PCRELATIVE
X {
X genlocrec(currseg, labelloc);
X pevalexpr(1, $2);
X locctr += geninstr(findgen($1, ST_IND, 0));
X if(evalr[1].seg == SSG_ABS
X && (evalr[1].value - locctr) >= PCRNEG8M
X && (evalr[1].value - locctr) <= PCRPLUS8M)
X {
X locctr += geninstr(PCR8STR);
X }
X else
X {
X locctr += geninstr(PCR16STR);
X }
X }
X ;
Xgenline : KOC_opcode '[' expr ',' PCRELATIVE ']'
X {
X genlocrec(currseg, labelloc);
X pevalexpr(1, $3);
X locctr += geninstr(findgen($1, ST_IND, 0));
X if(evalr[1].seg == SSG_ABS
X && (evalr[1].value - locctr) >= PCRNEG8M
X && (evalr[1].value - locctr) <= PCRPLUS8M)
X {
X locctr += geninstr(IPCR8STR);
X }
X else
X {
X locctr += geninstr(IPCR16STR);
X }
X }
X ;
Xgenline : KOC_opcode '[' expr ']'
X {
X genlocrec(currseg, labelloc);
X pevalexpr(1, $3);
X locctr += geninstr(findgen($1, ST_IND, 0));
X locctr += geninstr(IEXPSTR);
X }
X ;
Xgenline : KOC_sstkop regbits
X {
X genlocrec(currseg, labelloc);
X if($2 & REGBSSTK)
X {
X fraerror("push/pop of system stack register");
X evalr[1].value = 0;
X }
X else
X {
X evalr[1].value = $2 & 0xff;
X }
X locctr += geninstr(findgen($1, ST_SPSH, 0));
X }
X ;
Xgenline : KOC_ustkop regbits
X {
X genlocrec(currseg, labelloc);
X if($2 & REGBUSTK)
X {
X fraerror("push/pop of user stack register");
X evalr[1].value = 0;
X }
X else
X {
X evalr[1].value = $2 & 0xff;
X }
X locctr += geninstr(findgen($1, ST_SPSH, 0));
X }
X ;
Xgenline : KOC_tfrop register ',' register
X {
X genlocrec(currseg, labelloc);
X if(($2 & TFR8BIT) == ($4 & TFR8BIT))
X {
X evalr[1].value = $2;
X evalr[2].value = $4;
X }
X else
X {
X evalr[1].value = 0;
X evalr[2].value = 0;
X fraerror("operands are different sizes");
X }
X locctr += geninstr(findgen($1, ST_TFR, 0));
X }
X ;
Xindexed : expr ',' INDEX
X {
X pevalexpr(1, $1);
X if(evalr[1].seg == SSG_ABS
X && evalr[1].value >= -128
X && evalr[1].value <= 127 )
X {
X if(evalr[1].value >= -16
X && evalr[1].value <= 15)
X {
X if(evalr[1].value == 0)
X $$ = indexgen [IDM104] [$3 - TFRX];
X else
X $$ = indexgen [IDM000] [$3 - TFRX];
X }
X else
X {
X $$ = indexgen [IDM108] [$3 - TFRX];
X }
X }
X else
X {
X $$ = indexgen [IDM109] [$3 - TFRX];
X }
X }
X
X | ACCUM ',' INDEX
X {
X switch($1)
X {
X case TFRA:
X $$ = indexgen [IDM106] [$3 - TFRX];
X break;
X case TFRB:
X $$ = indexgen [IDM105] [$3 - TFRX];
X break;
X case TFRD:
X $$ = indexgen [IDM10B] [$3 - TFRX];
X break;
X }
X }
X
X | ',' INDEX
X {
X $$ = indexgen [IDM104] [$2 - TFRX];
X }
X
X | ',' INDEX '+'
X {
X $$ = indexgen [IDM100] [$2 - TFRX];
X }
X
X | ',' INDEX '+' '+'
X {
X $$ = indexgen [IDM101] [$2 - TFRX];
X }
X
X | ',' '-' INDEX
X {
X $$ = indexgen [IDM102] [$3 - TFRX];
X }
X
X | ',' '-' '-' INDEX
X {
X $$ = indexgen [IDM103] [$4 - TFRX];
X }
X
X | '[' expr ',' INDEX ']'
X {
X pevalexpr(1, $2);
X if(evalr[1].seg == SSG_ABS
X && evalr[1].value >= -128
X && evalr[1].value <= 127 )
X {
X if(evalr[1].value == 0)
X $$ = indexgen [IDM114] [$4 - TFRX];
X else
X $$ = indexgen [IDM118] [$4 - TFRX];
X }
X else
X {
X $$ = indexgen [IDM119] [$4 - TFRX];
X }
X }
X
X | '[' ACCUM ',' INDEX ']'
X {
X switch($2)
X {
X case TFRA:
X $$ = indexgen [IDM116] [$4 - TFRX];
X break;
X case TFRB:
X $$ = indexgen [IDM115] [$4 - TFRX];
X break;
X case TFRD:
X $$ = indexgen [IDM11B] [$4 - TFRX];
X break;
X }
X }
X
X | '[' ',' INDEX ']'
X {
X $$ = indexgen [IDM114] [$3 - TFRX];
X }
X
X | '[' ',' INDEX '+' '+' ']'
X {
X $$ = indexgen [IDM111] [$3 - TFRX];
X }
X
X | '[' ',' '-' '-' INDEX ']'
X {
X $$ = indexgen [IDM113] [$5 - TFRX];
X }
X ;
X
Xregbits : regbits ',' register
X {
X switch($3)
X {
X case TFRD:
X $$ = $1 | (PPOSTA | PPOSTB);
X break;
X case TFRX:
X $$ = $1 | PPOSTX;
X break;
X case TFRY:
X $$ = $1 | PPOSTY;
X break;
X case TFRU:
X $$ = $1 | PPOSTU;
X break;
X case TFRS:
X $$ = $1 | PPOSTS;
X break;
X case TFRPC:
X $$ = $1 | PPOSTPC;
X break;
X case TFRA:
X $$ = $1 | PPOSTA;
X break;
X case TFRB:
X $$ = $1 | PPOSTB;
X break;
X case TFRCC:
X $$ = $1 | PPOSTCC;
X break;
X case TFRDP:
X $$ = $1 | PPOSTDP;
X break;
X }
X }
X | register
X {
X switch($1)
X {
X case TFRD:
X $$ = (PPOSTA | PPOSTB);
X break;
X case TFRX:
X $$ = PPOSTX;
X break;
X case TFRY:
X $$ = PPOSTY;
X break;
X case TFRU:
X $$ = PPOSTU;
X break;
X case TFRS:
X $$ = PPOSTS;
X break;
X case TFRPC:
X $$ = PPOSTPC;
X break;
X case TFRA:
X $$ = PPOSTA;
X break;
X case TFRB:
X $$ = PPOSTB;
X break;
X case TFRCC:
X $$ = PPOSTCC;
X break;
X case TFRDP:
X $$ = PPOSTDP;
X break;
X }
X }
X ;
X
Xregister : ACCUM
X | INDEX
X | SPECREG
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%%
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
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 /* machine specific token definitions */
X reservedsym("a", ACCUM, TFRA);
X reservedsym("b", ACCUM, TFRB);
X reservedsym("cc", SPECREG, TFRCC);
X reservedsym("dp", SPECREG, TFRDP);
X reservedsym("d", ACCUM, TFRD);
X reservedsym("x", INDEX, TFRX);
X reservedsym("y", INDEX, TFRY);
X reservedsym("u", INDEX, TFRU);
X reservedsym("s", INDEX, TFRS);
X reservedsym("pc", SPECREG, TFRPC);
X reservedsym("pcr", PCRELATIVE, 0);
X reservedsym("A", ACCUM, TFRA);
X reservedsym("B", ACCUM, TFRB);
X reservedsym("CC", SPECREG, TFRCC);
X reservedsym("DP", SPECREG, TFRDP);
X reservedsym("D", ACCUM, TFRD);
X reservedsym("X", INDEX, TFRX);
X reservedsym("Y", INDEX, TFRY);
X reservedsym("U", INDEX, TFRU);
X reservedsym("S", INDEX, TFRS);
X reservedsym("PC", SPECREG, TFRPC);
X reservedsym("PCR", PCRELATIVE, 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 163
X#define NUMSYNBLK 226
X#define NUMDIFFOP 279
X
Xint gnumopcode = NUMOPCODE;
X
Xint ophashlnk[NUMOPCODE];
X
Xstruct opsym optab[NUMOPCODE+1]
X = {
X {"invalid", KOC_opcode, 2, 0 },
X {"ABX", KOC_opcode, 1, 2 },
X {"ADCA", KOC_opcode, 3, 3 },
X {"ADCB", KOC_opcode, 3, 6 },
X {"ADDA", KOC_opcode, 3, 9 },
X {"ADDB", KOC_opcode, 3, 12 },
X {"ADDD", KOC_opcode, 3, 15 },
X {"ANDA", KOC_opcode, 3, 18 },
X {"ANDB", KOC_opcode, 3, 21 },
X {"ANDCC", KOC_opcode, 1, 24 },
X {"ASL", KOC_opcode, 2, 25 },
X {"ASLA", KOC_opcode, 1, 27 },
X {"ASLB", KOC_opcode, 1, 28 },
X {"ASR", KOC_opcode, 2, 29 },
X {"ASRA", KOC_opcode, 1, 31 },
X {"ASRB", KOC_opcode, 1, 32 },
X {"BCC", KOC_opcode, 1, 33 },
X {"BCS", KOC_opcode, 1, 34 },
X {"BEQ", KOC_opcode, 1, 35 },
X {"BGE", KOC_opcode, 1, 36 },
X {"BGT", KOC_opcode, 1, 37 },
X {"BHI", KOC_opcode, 1, 38 },
X {"BHS", KOC_opcode, 1, 39 },
X {"BITA", KOC_opcode, 3, 40 },
X {"BITB", KOC_opcode, 3, 43 },
X {"BLE", KOC_opcode, 1, 46 },
X {"BLO", KOC_opcode, 1, 47 },
X {"BLS", KOC_opcode, 1, 48 },
X {"BLT", KOC_opcode, 1, 49 },
X {"BMI", KOC_opcode, 1, 50 },
X {"BNE", KOC_opcode, 1, 51 },
X {"BPL", KOC_opcode, 1, 52 },
X {"BRA", KOC_opcode, 1, 53 },
X {"BRN", KOC_opcode, 1, 54 },
X {"BSR", KOC_opcode, 1, 55 },
X {"BVC", KOC_opcode, 1, 56 },
X {"BVS", KOC_opcode, 1, 57 },
X {"BYTE", KOC_BDEF, 0, 0 },
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 {"CLR", KOC_opcode, 2, 58 },
X {"CLRA", KOC_opcode, 1, 60 },
X {"CLRB", KOC_opcode, 1, 61 },
X {"CMPA", KOC_opcode, 3, 62 },
X {"CMPB", KOC_opcode, 3, 65 },
X {"CMPD", KOC_opcode, 3, 68 },
X {"CMPS", KOC_opcode, 3, 71 },
X {"CMPU", KOC_opcode, 3, 74 },
X {"CMPX", KOC_opcode, 3, 77 },
X {"CMPY", KOC_opcode, 3, 80 },
X {"COM", KOC_opcode, 2, 83 },
X {"COMA", KOC_opcode, 1, 85 },
X {"COMB", KOC_opcode, 1, 86 },
X {"CWAI", KOC_opcode, 1, 87 },
X {"DAA", KOC_opcode, 1, 88 },
X {"DB", KOC_BDEF, 0, 0 },
X {"DEC", KOC_opcode, 2, 89 },
X {"DECA", KOC_opcode, 1, 91 },
X {"DECB", KOC_opcode, 1, 92 },
X {"DW", KOC_WDEF, 0, 0 },
X {"ELSE", KOC_ELSE, 0, 0 },
X {"END", KOC_END, 0, 0 },
X {"ENDI", KOC_ENDI, 0, 0 },
X {"EORA", KOC_opcode, 3, 93 },
X {"EORB", KOC_opcode, 3, 96 },
X {"EQU", KOC_EQU, 0, 0 },
X {"EXG", KOC_tfrop, 1, 99 },
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, 2, 100 },
X {"INCA", KOC_opcode, 1, 102 },
X {"INCB", KOC_opcode, 1, 103 },
X {"INCL", KOC_INCLUDE, 0, 0 },
X {"INCLUDE", KOC_INCLUDE, 0, 0 },
X {"JMP", KOC_opcode, 2, 104 },
X {"JSR", KOC_opcode, 2, 106 },
X {"LBCC", KOC_opcode, 1, 108 },
X {"LBCS", KOC_opcode, 1, 109 },
X {"LBEQ", KOC_opcode, 1, 110 },
X {"LBGE", KOC_opcode, 1, 111 },
X {"LBGT", KOC_opcode, 1, 112 },
X {"LBHI", KOC_opcode, 1, 113 },
X {"LBHS", KOC_opcode, 1, 114 },
X {"LBLE", KOC_opcode, 1, 115 },
X {"LBLO", KOC_opcode, 1, 116 },
X {"LBLS", KOC_opcode, 1, 117 },
X {"LBLT", KOC_opcode, 1, 118 },
X {"LBMI", KOC_opcode, 1, 119 },
X {"LBNE", KOC_opcode, 1, 120 },
X {"LBPL", KOC_opcode, 1, 121 },
X {"LBRA", KOC_opcode, 1, 122 },
X {"LBRN", KOC_opcode, 1, 123 },
X {"LBSR", KOC_opcode, 1, 124 },
X {"LBVC", KOC_opcode, 1, 125 },
X {"LBVS", KOC_opcode, 1, 126 },
X {"LDA", KOC_opcode, 3, 127 },
X {"LDB", KOC_opcode, 3, 130 },
X {"LDD", KOC_opcode, 3, 133 },
X {"LDS", KOC_opcode, 3, 136 },
X {"LDU", KOC_opcode, 3, 139 },
X {"LDX", KOC_opcode, 3, 142 },
X {"LDY", KOC_opcode, 3, 145 },
X {"LEAS", KOC_opcode, 1, 148 },
X {"LEAU", KOC_opcode, 1, 149 },
X {"LEAX", KOC_opcode, 1, 150 },
X {"LEAY", KOC_opcode, 1, 151 },
X {"LSL", KOC_opcode, 2, 152 },
X {"LSLA", KOC_opcode, 1, 154 },
X {"LSLB", KOC_opcode, 1, 155 },
X {"LSR", KOC_opcode, 2, 156 },
X {"LSRA", KOC_opcode, 1, 158 },
X {"LSRB", KOC_opcode, 1, 159 },
X {"MUL", KOC_opcode, 1, 160 },
X {"NEG", KOC_opcode, 2, 161 },
X {"NEGA", KOC_opcode, 1, 163 },
X {"NEGB", KOC_opcode, 1, 164 },
X {"NOP", KOC_opcode, 1, 165 },
X {"ORA", KOC_opcode, 3, 166 },
X {"ORB", KOC_opcode, 3, 169 },
X {"ORCC", KOC_opcode, 1, 172 },
X {"ORG", KOC_ORG, 0, 0 },
X {"PSHS", KOC_sstkop, 1, 173 },
X {"PSHU", KOC_ustkop, 1, 174 },
X {"PULS", KOC_sstkop, 1, 175 },
X {"PULU", KOC_ustkop, 1, 176 },
X {"RESERVE", KOC_RESM, 0, 0 },
X {"RMB", KOC_RESM, 0, 0 },
X {"ROL", KOC_opcode, 2, 177 },
X {"ROLA", KOC_opcode, 1, 179 },
X {"ROLB", KOC_opcode, 1, 180 },
X {"ROR", KOC_opcode, 2, 181 },
X {"RORA", KOC_opcode, 1, 183 },
X {"RORB", KOC_opcode, 1, 184 },
X {"RTI", KOC_opcode, 1, 185 },
X {"RTS", KOC_opcode, 1, 186 },
X {"SBCA", KOC_opcode, 3, 187 },
X {"SBCB", KOC_opcode, 3, 190 },
X {"SET", KOC_SET, 0, 0 },
X {"SEX", KOC_opcode, 1, 193 },
X {"STA", KOC_opcode, 2, 194 },
X {"STB", KOC_opcode, 2, 196 },
X {"STD", KOC_opcode, 2, 198 },
X {"STRING", KOC_SDEF, 0, 0 },
X {"STS", KOC_opcode, 2, 200 },
X {"STU", KOC_opcode, 2, 202 },
X {"STX", KOC_opcode, 2, 204 },
X {"STY", KOC_opcode, 2, 206 },
X {"SUBA", KOC_opcode, 3, 208 },
X {"SUBB", KOC_opcode, 3, 211 },
X {"SUBD", KOC_opcode, 3, 214 },
X {"SWI2", KOC_opcode, 1, 217 },
X {"SWI3", KOC_opcode, 1, 218 },
X {"SWI", KOC_opcode, 1, 219 },
X {"SYNC", KOC_opcode, 1, 220 },
X {"TFR", KOC_tfrop, 1, 221 },
X {"TST", KOC_opcode, 2, 222 },
X {"TSTA", KOC_opcode, 1, 224 },
X {"TSTB", KOC_opcode, 1, 225 },
X {"WORD", KOC_WDEF, 0, 0 },
X { "", 0, 0, 0 }};
X
Xstruct opsynt ostab[NUMSYNBLK+1]
X = {
X/* invalid 0 */ { 0, 1, 0 },
X/* invalid 1 */ { 0xffff, 1, 1 },
X/* ABX 2 */ { ST_INH, 1, 2 },
X/* ADCA 3 */ { ST_EXP, 2, 3 },
X/* ADCA 4 */ { ST_IMM, 1, 5 },
X/* ADCA 5 */ { ST_IND, 1, 6 },
X/* ADCB 6 */ { ST_EXP, 2, 7 },
X/* ADCB 7 */ { ST_IMM, 1, 9 },
X/* ADCB 8 */ { ST_IND, 1, 10 },
X/* ADDA 9 */ { ST_EXP, 2, 11 },
X/* ADDA 10 */ { ST_IMM, 1, 13 },
X/* ADDA 11 */ { ST_IND, 1, 14 },
X/* ADDB 12 */ { ST_EXP, 2, 15 },
X/* ADDB 13 */ { ST_IMM, 1, 17 },
X/* ADDB 14 */ { ST_IND, 1, 18 },
X/* ADDD 15 */ { ST_EXP, 2, 19 },
X/* ADDD 16 */ { ST_IMM, 1, 21 },
X/* ADDD 17 */ { ST_IND, 1, 22 },
X/* ANDA 18 */ { ST_EXP, 2, 23 },
X/* ANDA 19 */ { ST_IMM, 1, 25 },
X/* ANDA 20 */ { ST_IND, 1, 26 },
X/* ANDB 21 */ { ST_EXP, 2, 27 },
X/* ANDB 22 */ { ST_IMM, 1, 29 },
X/* ANDB 23 */ { ST_IND, 1, 30 },
X/* ANDCC 24 */ { ST_IMM, 1, 31 },
X/* ASL 25 */ { ST_EXP, 2, 32 },
X/* ASL 26 */ { ST_IND, 1, 34 },
X/* ASLA 27 */ { ST_INH, 1, 35 },
X/* ASLB 28 */ { ST_INH, 1, 36 },
X/* ASR 29 */ { ST_EXP, 2, 37 },
X/* ASR 30 */ { ST_IND, 1, 39 },
X/* ASRA 31 */ { ST_INH, 1, 40 },
X/* ASRB 32 */ { ST_INH, 1, 41 },
X/* BCC 33 */ { ST_EXP, 1, 42 },
X/* BCS 34 */ { ST_EXP, 1, 43 },
X/* BEQ 35 */ { ST_EXP, 1, 44 },
X/* BGE 36 */ { ST_EXP, 1, 45 },
X/* BGT 37 */ { ST_EXP, 1, 46 },
X/* BHI 38 */ { ST_EXP, 1, 47 },
X/* BHS 39 */ { ST_EXP, 1, 48 },
X/* BITA 40 */ { ST_EXP, 2, 49 },
X/* BITA 41 */ { ST_IMM, 1, 51 },
X/* BITA 42 */ { ST_IND, 1, 52 },
X/* BITB 43 */ { ST_EXP, 2, 53 },
X/* BITB 44 */ { ST_IMM, 1, 55 },
X/* BITB 45 */ { ST_IND, 1, 56 },
X/* BLE 46 */ { ST_EXP, 1, 57 },
X/* BLO 47 */ { ST_EXP, 1, 58 },
X/* BLS 48 */ { ST_EXP, 1, 59 },
X/* BLT 49 */ { ST_EXP, 1, 60 },
X/* BMI 50 */ { ST_EXP, 1, 61 },
X/* BNE 51 */ { ST_EXP, 1, 62 },
X/* BPL 52 */ { ST_EXP, 1, 63 },
X/* BRA 53 */ { ST_EXP, 1, 64 },
X/* BRN 54 */ { ST_EXP, 1, 65 },
X/* BSR 55 */ { ST_EXP, 1, 66 },
X/* BVC 56 */ { ST_EXP, 1, 67 },
X/* BVS 57 */ { ST_EXP, 1, 68 },
X/* CLR 58 */ { ST_EXP, 2, 69 },
X/* CLR 59 */ { ST_IND, 1, 71 },
X/* CLRA 60 */ { ST_INH, 1, 72 },
X/* CLRB 61 */ { ST_INH, 1, 73 },
X/* CMPA 62 */ { ST_EXP, 2, 74 },
X/* CMPA 63 */ { ST_IMM, 1, 76 },
X/* CMPA 64 */ { ST_IND, 1, 77 },
X/* CMPB 65 */ { ST_EXP, 2, 78 },
X/* CMPB 66 */ { ST_IMM, 1, 80 },
X/* CMPB 67 */ { ST_IND, 1, 81 },
X/* CMPD 68 */ { ST_EXP, 2, 82 },
X/* CMPD 69 */ { ST_IMM, 1, 84 },
X/* CMPD 70 */ { ST_IND, 1, 85 },
X/* CMPS 71 */ { ST_EXP, 2, 86 },
X/* CMPS 72 */ { ST_IMM, 1, 88 },
X/* CMPS 73 */ { ST_IND, 1, 89 },
X/* CMPU 74 */ { ST_EXP, 2, 90 },
X/* CMPU 75 */ { ST_IMM, 1, 92 },
X/* CMPU 76 */ { ST_IND, 1, 93 },
X/* CMPX 77 */ { ST_EXP, 2, 94 },
X/* CMPX 78 */ { ST_IMM, 1, 96 },
X/* CMPX 79 */ { ST_IND, 1, 97 },
X/* CMPY 80 */ { ST_EXP, 2, 98 },
X/* CMPY 81 */ { ST_IMM, 1, 100 },
X/* CMPY 82 */ { ST_IND, 1, 101 },
X/* COM 83 */ { ST_EXP, 2, 102 },
X/* COM 84 */ { ST_IND, 1, 104 },
X/* COMA 85 */ { ST_INH, 1, 105 },
X/* COMB 86 */ { ST_INH, 1, 106 },
X/* CWAI 87 */ { ST_IMM, 1, 107 },
X/* DAA 88 */ { ST_INH, 1, 108 },
X/* DEC 89 */ { ST_EXP, 2, 109 },
X/* DEC 90 */ { ST_IND, 1, 111 },
X/* DECA 91 */ { ST_INH, 1, 112 },
X/* DECB 92 */ { ST_INH, 1, 113 },
X/* EORA 93 */ { ST_EXP, 2, 114 },
X/* EORA 94 */ { ST_IMM, 1, 116 },
X/* EORA 95 */ { ST_IND, 1, 117 },
X/* EORB 96 */ { ST_EXP, 2, 118 },
X/* EORB 97 */ { ST_IMM, 1, 120 },
X/* EORB 98 */ { ST_IND, 1, 121 },
X/* EXG 99 */ { ST_TFR, 1, 122 },
X/* INC 100 */ { ST_EXP, 2, 123 },
X/* INC 101 */ { ST_IND, 1, 125 },
X/* INCA 102 */ { ST_INH, 1, 126 },
X/* INCB 103 */ { ST_INH, 1, 127 },
X/* JMP 104 */ { ST_EXP, 2, 128 },
X/* JMP 105 */ { ST_IND, 1, 130 },
X/* JSR 106 */ { ST_EXP, 2, 131 },
X/* JSR 107 */ { ST_IND, 1, 133 },
X/* LBCC 108 */ { ST_EXP, 1, 134 },
X/* LBCS 109 */ { ST_EXP, 1, 135 },
X/* LBEQ 110 */ { ST_EXP, 1, 136 },
X/* LBGE 111 */ { ST_EXP, 1, 137 },
X/* LBGT 112 */ { ST_EXP, 1, 138 },
X/* LBHI 113 */ { ST_EXP, 1, 139 },
X/* LBHS 114 */ { ST_EXP, 1, 140 },
X/* LBLE 115 */ { ST_EXP, 1, 141 },
X/* LBLO 116 */ { ST_EXP, 1, 142 },
X/* LBLS 117 */ { ST_EXP, 1, 143 },
X/* LBLT 118 */ { ST_EXP, 1, 144 },
X/* LBMI 119 */ { ST_EXP, 1, 145 },
X/* LBNE 120 */ { ST_EXP, 1, 146 },
X/* LBPL 121 */ { ST_EXP, 1, 147 },
X/* LBRA 122 */ { ST_EXP, 1, 148 },
X/* LBRN 123 */ { ST_EXP, 1, 149 },
X/* LBSR 124 */ { ST_EXP, 1, 150 },
X/* LBVC 125 */ { ST_EXP, 1, 151 },
X/* LBVS 126 */ { ST_EXP, 1, 152 },
X/* LDA 127 */ { ST_EXP, 2, 153 },
X/* LDA 128 */ { ST_IMM, 1, 155 },
X/* LDA 129 */ { ST_IND, 1, 156 },
X/* LDB 130 */ { ST_EXP, 2, 157 },
X/* LDB 131 */ { ST_IMM, 1, 159 },
X/* LDB 132 */ { ST_IND, 1, 160 },
X/* LDD 133 */ { ST_EXP, 2, 161 },
X/* LDD 134 */ { ST_IMM, 1, 163 },
X/* LDD 135 */ { ST_IND, 1, 164 },
X/* LDS 136 */ { ST_EXP, 2, 165 },
X/* LDS 137 */ { ST_IMM, 1, 167 },
X/* LDS 138 */ { ST_IND, 1, 168 },
X/* LDU 139 */ { ST_EXP, 2, 169 },
X/* LDU 140 */ { ST_IMM, 1, 171 },
X/* LDU 141 */ { ST_IND, 1, 172 },
X/* LDX 142 */ { ST_EXP, 2, 173 },
X/* LDX 143 */ { ST_IMM, 1, 175 },
X/* LDX 144 */ { ST_IND, 1, 176 },
X/* LDY 145 */ { ST_EXP, 2, 177 },
X/* LDY 146 */ { ST_IMM, 1, 179 },
X/* LDY 147 */ { ST_IND, 1, 180 },
X/* LEAS 148 */ { ST_IND, 1, 181 },
X/* LEAU 149 */ { ST_IND, 1, 182 },
X/* LEAX 150 */ { ST_IND, 1, 183 },
X/* LEAY 151 */ { ST_IND, 1, 184 },
X/* LSL 152 */ { ST_EXP, 2, 185 },
X/* LSL 153 */ { ST_IND, 1, 187 },
X/* LSLA 154 */ { ST_INH, 1, 188 },
X/* LSLB 155 */ { ST_INH, 1, 189 },
X/* LSR 156 */ { ST_EXP, 2, 190 },
X/* LSR 157 */ { ST_IND, 1, 192 },
X/* LSRA 158 */ { ST_INH, 1, 193 },
X/* LSRB 159 */ { ST_INH, 1, 194 },
X/* MUL 160 */ { ST_INH, 1, 195 },
X/* NEG 161 */ { ST_EXP, 2, 196 },
X/* NEG 162 */ { ST_IND, 1, 198 },
X/* NEGA 163 */ { ST_INH, 1, 199 },
X/* NEGB 164 */ { ST_INH, 1, 200 },
X/* NOP 165 */ { ST_INH, 1, 201 },
X/* ORA 166 */ { ST_EXP, 2, 202 },
X/* ORA 167 */ { ST_IMM, 1, 204 },
X/* ORA 168 */ { ST_IND, 1, 205 },
X/* ORB 169 */ { ST_EXP, 2, 206 },
X/* ORB 170 */ { ST_IMM, 1, 208 },
X/* ORB 171 */ { ST_IND, 1, 209 },
X/* ORCC 172 */ { ST_IMM, 1, 210 },
X/* PSHS 173 */ { ST_SPSH, 1, 211 },
X/* PSHU 174 */ { ST_UPSH, 1, 212 },
X/* PULS 175 */ { ST_SPSH, 1, 213 },
X/* PULU 176 */ { ST_UPSH, 1, 214 },
X/* ROL 177 */ { ST_EXP, 2, 215 },
X/* ROL 178 */ { ST_IND, 1, 217 },
X/* ROLA 179 */ { ST_INH, 1, 218 },
X/* ROLB 180 */ { ST_INH, 1, 219 },
X/* ROR 181 */ { ST_EXP, 2, 220 },
X/* ROR 182 */ { ST_IND, 1, 222 },
X/* RORA 183 */ { ST_INH, 1, 223 },
X/* RORB 184 */ { ST_INH, 1, 224 },
X/* RTI 185 */ { ST_INH, 1, 225 },
X/* RTS 186 */ { ST_INH, 1, 226 },
X/* SBCA 187 */ { ST_EXP, 2, 227 },
X/* SBCA 188 */ { ST_IMM, 1, 229 },
X/* SBCA 189 */ { ST_IND, 1, 230 },
X/* SBCB 190 */ { ST_EXP, 2, 231 },
X/* SBCB 191 */ { ST_IMM, 1, 233 },
X/* SBCB 192 */ { ST_IND, 1, 234 },
X/* SEX 193 */ { ST_INH, 1, 235 },
X/* STA 194 */ { ST_EXP, 2, 236 },
X/* STA 195 */ { ST_IND, 1, 238 },
X/* STB 196 */ { ST_EXP, 2, 239 },
X/* STB 197 */ { ST_IND, 1, 241 },
X/* STD 198 */ { ST_EXP, 2, 242 },
X/* STD 199 */ { ST_IND, 1, 244 },
X/* STS 200 */ { ST_EXP, 2, 245 },
X/* STS 201 */ { ST_IND, 1, 247 },
X/* STU 202 */ { ST_EXP, 2, 248 },
X/* STU 203 */ { ST_IND, 1, 250 },
X/* STX 204 */ { ST_EXP, 2, 251 },
X/* STX 205 */ { ST_IND, 1, 253 },
X/* STY 206 */ { ST_EXP, 2, 254 },
X/* STY 207 */ { ST_IND, 1, 256 },
X/* SUBA 208 */ { ST_EXP, 2, 257 },
X/* SUBA 209 */ { ST_IMM, 1, 259 },
X/* SUBA 210 */ { ST_IND, 1, 260 },
X/* SUBB 211 */ { ST_EXP, 2, 261 },
X/* SUBB 212 */ { ST_IMM, 1, 263 },
X/* SUBB 213 */ { ST_IND, 1, 264 },
X/* SUBD 214 */ { ST_EXP, 2, 265 },
X/* SUBD 215 */ { ST_IMM, 1, 267 },
X/* SUBD 216 */ { ST_IND, 1, 268 },
X/* SWI2 217 */ { ST_INH, 1, 269 },
X/* SWI3 218 */ { ST_INH, 1, 270 },
X/* SWI 219 */ { ST_INH, 1, 271 },
X/* SYNC 220 */ { ST_INH, 1, 272 },
X/* TFR 221 */ { ST_TFR, 1, 273 },
X/* TST 222 */ { ST_EXP, 2, 274 },
X/* TST 223 */ { ST_IND, 1, 276 },
X/* TSTA 224 */ { ST_INH, 1, 277 },
X/* TSTB 225 */ { ST_INH, 1, 278 },
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/* ABX 2 */ { 0 , 0,
X "3a;" },
X/* ADCA 3 */ { ADDR , DIRECT,
X "99;[1=];" },
X/* ADCA 4 */ { ADDR , EXTENDED,
X "b9;[1=]x" },
X/* ADCA 5 */ { 0 , 0,
X "89;[1=];" },
X/* ADCA 6 */ { 0 , 0,
X "a9;" },
X/* ADCB 7 */ { ADDR , DIRECT,
X "d9;[1=];" },
X/* ADCB 8 */ { ADDR , EXTENDED,
X "f9;[1=]x" },
X/* ADCB 9 */ { 0 , 0,
X "c9;[1=];" },
X/* ADCB 10 */ { 0 , 0,
X "e9;" },
X/* ADDA 11 */ { ADDR , DIRECT,
X "9b;[1=];" },
X/* ADDA 12 */ { ADDR , EXTENDED,
X "bb;[1=]x" },
X/* ADDA 13 */ { 0 , 0,
X "8b;[1=];" },
X/* ADDA 14 */ { 0 , 0,
X "ab;" },
X/* ADDB 15 */ { ADDR , DIRECT,
X "db;[1=];" },
X/* ADDB 16 */ { ADDR , EXTENDED,
X "fb;[1=]x" },
X/* ADDB 17 */ { 0 , 0,
X "cb;[1=];" },
X/* ADDB 18 */ { 0 , 0,
X "eb;" },
X/* ADDD 19 */ { ADDR , DIRECT,
X "d3;[1=];" },
X/* ADDD 20 */ { ADDR , EXTENDED,
X "f3;[1=]x" },
X/* ADDD 21 */ { 0 , 0,
X "c3;[1=]x" },
X/* ADDD 22 */ { 0 , 0,
X "e3;" },
X/* ANDA 23 */ { ADDR , DIRECT,
X "94;[1=];" },
X/* ANDA 24 */ { ADDR , EXTENDED,
X "b4;[1=]x" },
X/* ANDA 25 */ { 0 , 0,
X "84;[1=];" },
X/* ANDA 26 */ { 0 , 0,
X "a4;" },
X/* ANDB 27 */ { ADDR , DIRECT,
X "d4;[1=];" },
X/* ANDB 28 */ { ADDR , EXTENDED,
X "f4;[1=]x" },
X/* ANDB 29 */ { 0 , 0,
X "c4;[1=];" },
X/* ANDB 30 */ { 0 , 0,
X "e4;" },
X/* ANDCC 31 */ { 0 , 0,
X "1c;[1=];" },
X/* ASL 32 */ { ADDR , DIRECT,
X "08;[1=];" },
X/* ASL 33 */ { ADDR , EXTENDED,
X "78;[1=]x" },
X/* ASL 34 */ { 0 , 0,
X "68;" },
X/* ASLA 35 */ { 0 , 0,
X "48;" },
X/* ASLB 36 */ { 0 , 0,
X "58;" },
X/* ASR 37 */ { ADDR , DIRECT,
X "07;[1=];" },
X/* ASR 38 */ { ADDR , EXTENDED,
X "77;[1=]x" },
X/* ASR 39 */ { 0 , 0,
X "67;" },
X/* ASRA 40 */ { 0 , 0,
X "47;" },
X/* ASRB 41 */ { 0 , 0,
X "57;" },
X/* BCC 42 */ { 0 , 0,
X "24;[1=].Q.1+-r" },
X/* BCS 43 */ { 0 , 0,
X "25;[1=].Q.1+-r" },
X/* BEQ 44 */ { 0 , 0,
X "27;[1=].Q.1+-r" },
X/* BGE 45 */ { 0 , 0,
X "2c;[1=].Q.1+-r" },
X/* BGT 46 */ { 0 , 0,
X "2e;[1=].Q.1+-r" },
X/* BHI 47 */ { 0 , 0,
X "22;[1=].Q.1+-r" },
X/* BHS 48 */ { 0 , 0,
X "24;[1=].Q.1+-r" },
X/* BITA 49 */ { ADDR , DIRECT,
X "95;[1=];" },
X/* BITA 50 */ { ADDR , EXTENDED,
X "b5;[1=]x" },
X/* BITA 51 */ { 0 , 0,
X "85;[1=];" },
X/* BITA 52 */ { 0 , 0,
X "a5;" },
X/* BITB 53 */ { ADDR , DIRECT,
X "d5;[1=];" },
X/* BITB 54 */ { ADDR , EXTENDED,
X "f5;[1=]x" },
X/* BITB 55 */ { 0 , 0,
X "c5;[1=];" },
X/* BITB 56 */ { 0 , 0,
X "e5;" },
X/* BLE 57 */ { 0 , 0,
X "2f;[1=].Q.1+-r" },
X/* BLO 58 */ { 0 , 0,
X "25;[1=].Q.1+-r" },
X/* BLS 59 */ { 0 , 0,
X "23;[1=].Q.1+-r" },
X/* BLT 60 */ { 0 , 0,
X "2d;[1=].Q.1+-r" },
X/* BMI 61 */ { 0 , 0,
X "2b;[1=].Q.1+-r" },
X/* BNE 62 */ { 0 , 0,
X "26;[1=].Q.1+-r" },
X/* BPL 63 */ { 0 , 0,
X "2a;[1=].Q.1+-r" },
X/* BRA 64 */ { 0 , 0,
X "20;[1=].Q.1+-r" },
X/* BRN 65 */ { 0 , 0,
X "21;[1=].Q.1+-r" },
X/* BSR 66 */ { 0 , 0,
X "8d;[1=].Q.1+-r" },
X/* BVC 67 */ { 0 , 0,
X "28;[1=].Q.1+-r" },
X/* BVS 68 */ { 0 , 0,
X "29;[1=].Q.1+-r" },
X/* CLR 69 */ { ADDR , DIRECT,
X "0f;[1=];" },
X/* CLR 70 */ { ADDR , EXTENDED,
X "7f;[1=]x" },
X/* CLR 71 */ { 0 , 0,
X "6f;" },
X/* CLRA 72 */ { 0 , 0,
X "4f;" },
X/* CLRB 73 */ { 0 , 0,
X "5f;" },
X/* CMPA 74 */ { ADDR , DIRECT,
X "91;[1=];" },
X/* CMPA 75 */ { ADDR , EXTENDED,
X "b1;[1=]x" },
X/* CMPA 76 */ { 0 , 0,
X "81;[1=];" },
X/* CMPA 77 */ { 0 , 0,
X "a1;" },
X/* CMPB 78 */ { ADDR , DIRECT,
X "d1;[1=];" },
X/* CMPB 79 */ { ADDR , EXTENDED,
X "f1;[1=]x" },
X/* CMPB 80 */ { 0 , 0,
X "c1;[1=];" },
X/* CMPB 81 */ { 0 , 0,
X "e1;" },
X/* CMPD 82 */ { ADDR , DIRECT,
X "10;93;[1=];" },
X/* CMPD 83 */ { ADDR , EXTENDED,
X "10;b3;[1=]x" },
X/* CMPD 84 */ { 0 , 0,
X "10;83;[1=]x" },
X/* CMPD 85 */ { 0 , 0,
X "10;a3;" },
X/* CMPS 86 */ { ADDR , DIRECT,
X "11;9c;[1=];" },
X/* CMPS 87 */ { ADDR , EXTENDED,
X "11;bc;[1=]x" },
X/* CMPS 88 */ { 0 , 0,
X "11;8c;[1=]x" },
X/* CMPS 89 */ { 0 , 0,
X "11;ac;" },
X/* CMPU 90 */ { ADDR , DIRECT,
X "11;93;[1=];" },
X/* CMPU 91 */ { ADDR , EXTENDED,
X "11;b3;[1=]x" },
X/* CMPU 92 */ { 0 , 0,
X "11;83;[1=]x" },
X/* CMPU 93 */ { 0 , 0,
X "11;a3;" },
X/* CMPX 94 */ { ADDR , DIRECT,
X "9c;[1=];" },
X/* CMPX 95 */ { ADDR , EXTENDED,
X "bc;[1=]x" },
X/* CMPX 96 */ { 0 , 0,
X "8c;[1=]x" },
X/* CMPX 97 */ { 0 , 0,
X "ac;" },
X/* CMPY 98 */ { ADDR , DIRECT,
X "10;9c;[1=];" },
X/* CMPY 99 */ { ADDR , EXTENDED,
X "10;bc;[1=]x" },
X/* CMPY 100 */ { 0 , 0,
X "10;8c;[1=]x" },
X/* CMPY 101 */ { 0 , 0,
X "10;ac;" },
X/* COM 102 */ { ADDR , DIRECT,
X "03;[1=];" },
X/* COM 103 */ { ADDR , EXTENDED,
X "73;[1=]x" },
X/* COM 104 */ { 0 , 0,
X "63;" },
X/* COMA 105 */ { 0 , 0,
X "43;" },
X/* COMB 106 */ { 0 , 0,
X "53;" },
X/* CWAI 107 */ { 0 , 0,
X "3c;[1=];" },
X/* DAA 108 */ { 0 , 0,
X "19;" },
X/* DEC 109 */ { ADDR , DIRECT,
X "0a;[1=];" },
X/* DEC 110 */ { ADDR , EXTENDED,
X "7a;[1=]x" },
X/* DEC 111 */ { 0 , 0,
X "6a;" },
X/* DECA 112 */ { 0 , 0,
X "4a;" },
X/* DECB 113 */ { 0 , 0,
X "5a;" },
X/* EORA 114 */ { ADDR , DIRECT,
X "98;[1=];" },
X/* EORA 115 */ { ADDR , EXTENDED,
X "b8;[1=]x" },
X/* EORA 116 */ { 0 , 0,
X "88;[1=];" },
X/* EORA 117 */ { 0 , 0,
X "a8;" },
X/* EORB 118 */ { ADDR , DIRECT,
X "d8;[1=];" },
X/* EORB 119 */ { ADDR , EXTENDED,
X "f8;[1=]x" },
X/* EORB 120 */ { 0 , 0,
X "c8;[1=];" },
X/* EORB 121 */ { 0 , 0,
X "e8;" },
X/* EXG 122 */ { 0 , 0,
X "1e;[1#2#];" },
X/* INC 123 */ { ADDR , DIRECT,
X "0c;[1=];" },
X/* INC 124 */ { ADDR , EXTENDED,
X "7c;[1=]x" },
X/* INC 125 */ { 0 , 0,
X "6c;" },
X/* INCA 126 */ { 0 , 0,
X "4c;" },
X/* INCB 127 */ { 0 , 0,
X "5c;" },
X/* JMP 128 */ { ADDR , DIRECT,
X "0e;[1=];" },
X/* JMP 129 */ { ADDR , EXTENDED,
X "7e;[1=]x" },
X/* JMP 130 */ { 0 , 0,
X "6e;" },
X/* JSR 131 */ { ADDR , DIRECT,
X "9d;[1=];" },
X/* JSR 132 */ { ADDR , EXTENDED,
X "bd;[1=]x" },
X/* JSR 133 */ { 0 , 0,
X "ad;" },
X/* LBCC 134 */ { 0 , 0,
X "10;24;[1=].Q.2+-.ffff&x" },
X/* LBCS 135 */ { 0 , 0,
X "10;25;[1=].Q.2+-.ffff&x" },
X/* LBEQ 136 */ { 0 , 0,
X "10;27;[1=].Q.2+-.ffff&x" },
X/* LBGE 137 */ { 0 , 0,
X "10;2c;[1=].Q.2+-.ffff&x" },
X/* LBGT 138 */ { 0 , 0,
X "10;2e;[1=].Q.2+-.ffff&x" },
X/* LBHI 139 */ { 0 , 0,
X "10;22;[1=].Q.2+-.ffff&x" },
X/* LBHS 140 */ { 0 , 0,
X "10;24;[1=].Q.2+-.ffff&x" },
X/* LBLE 141 */ { 0 , 0,
X "10;2f;[1=].Q.2+-.ffff&x" },
X/* LBLO 142 */ { 0 , 0,
X "10;25;[1=].Q.2+-.ffff&x" },
X/* LBLS 143 */ { 0 , 0,
X "10;23;[1=].Q.2+-.ffff&x" },
X/* LBLT 144 */ { 0 , 0,
X "10;2d;[1=].Q.2+-.ffff&x" },
X/* LBMI 145 */ { 0 , 0,
X "10;2b;[1=].Q.2+-.ffff&x" },
X/* LBNE 146 */ { 0 , 0,
X "10;26;[1=].Q.2+-.ffff&x" },
X/* LBPL 147 */ { 0 , 0,
X "10;2a;[1=].Q.2+-.ffff&x" },
X/* LBRA 148 */ { 0 , 0,
X "16;[1=].Q.2+-.ffff&x" },
X/* LBRN 149 */ { 0 , 0,
X "10;21;[1=].Q.2+-.ffff&x" },
X/* LBSR 150 */ { 0 , 0,
X "17;[1=].Q.2+-.ffff&x" },
X/* LBVC 151 */ { 0 , 0,
X "10;28;[1=].Q.2+-.ffff&x" },
X/* LBVS 152 */ { 0 , 0,
X "10;29;[1=].Q.2+-.ffff&x" },
X/* LDA 153 */ { ADDR , DIRECT,
X "96;[1=];" },
X/* LDA 154 */ { ADDR , EXTENDED,
X "b6;[1=]x" },
X/* LDA 155 */ { 0 , 0,
X "86;[1=];" },
X/* LDA 156 */ { 0 , 0,
X "a6;" },
X/* LDB 157 */ { ADDR , DIRECT,
X "d6;[1=];" },
X/* LDB 158 */ { ADDR , EXTENDED,
X "f6;[1=]x" },
X/* LDB 159 */ { 0 , 0,
X "c6;[1=];" },
X/* LDB 160 */ { 0 , 0,
X "e6;" },
X/* LDD 161 */ { ADDR , DIRECT,
X "dc;[1=];" },
X/* LDD 162 */ { ADDR , EXTENDED,
X "fc;[1=]x" },
X/* LDD 163 */ { 0 , 0,
X "cc;[1=]x" },
X/* LDD 164 */ { 0 , 0,
X "ec;" },
X/* LDS 165 */ { ADDR , DIRECT,
X "10;de;[1=];" },
X/* LDS 166 */ { ADDR , EXTENDED,
X "10;fe;[1=]x" },
X/* LDS 167 */ { 0 , 0,
X "10;ce;[1=]x" },
X/* LDS 168 */ { 0 , 0,
X "10;ee;" },
X/* LDU 169 */ { ADDR , DIRECT,
X "de;[1=];" },
X/* LDU 170 */ { ADDR , EXTENDED,
X "fe;[1=]x" },
X/* LDU 171 */ { 0 , 0,
X "ce;[1=]x" },
X/* LDU 172 */ { 0 , 0,
X "ee;" },
X/* LDX 173 */ { ADDR , DIRECT,
X "9e;[1=];" },
X/* LDX 174 */ { ADDR , EXTENDED,
X "be;[1=]x" },
X/* LDX 175 */ { 0 , 0,
X "8e;[1=]x" },
X/* LDX 176 */ { 0 , 0,
X "ae;" },
X/* LDY 177 */ { ADDR , DIRECT,
X "10;9e;[1=];" },
X/* LDY 178 */ { ADDR , EXTENDED,
X "10;be;[1=]x" },
X/* LDY 179 */ { 0 , 0,
X "10;8e;[1=]x" },
X/* LDY 180 */ { 0 , 0,
X "10;ae;" },
X/* LEAS 181 */ { 0 , 0,
X "32;" },
X/* LEAU 182 */ { 0 , 0,
X "33;" },
X/* LEAX 183 */ { 0 , 0,
X "30;" },
X/* LEAY 184 */ { 0 , 0,
X "31;" },
X/* LSL 185 */ { ADDR , DIRECT,
X "08;[1=];" },
X/* LSL 186 */ { ADDR , EXTENDED,
X "78;[1=]x" },
X/* LSL 187 */ { 0 , 0,
X "68;" },
X/* LSLA 188 */ { 0 , 0,
X "48;" },
X/* LSLB 189 */ { 0 , 0,
X "58;" },
X/* LSR 190 */ { ADDR , DIRECT,
X "04;[1=];" },
X/* LSR 191 */ { ADDR , EXTENDED,
X "74;[1=]x" },
X/* LSR 192 */ { 0 , 0,
X "64;" },
X/* LSRA 193 */ { 0 , 0,
X "44;" },
X/* LSRB 194 */ { 0 , 0,
X "54;" },
X/* MUL 195 */ { 0 , 0,
X "3d;" },
X/* NEG 196 */ { ADDR , DIRECT,
X "00;[1=];" },
X/* NEG 197 */ { ADDR , EXTENDED,
X "70;[1=]x" },
X/* NEG 198 */ { 0 , 0,
X "60;" },
X/* NEGA 199 */ { 0 , 0,
X "40;" },
X/* NEGB 200 */ { 0 , 0,
X "50;" },
X/* NOP 201 */ { 0 , 0,
X "12;" },
X/* ORA 202 */ { ADDR , DIRECT,
X "9a;[1=];" },
X/* ORA 203 */ { ADDR , EXTENDED,
X "ba;[1=]x" },
X/* ORA 204 */ { 0 , 0,
X "8a;[1=];" },
X/* ORA 205 */ { 0 , 0,
X "aa;" },
X/* ORB 206 */ { ADDR , DIRECT,
X "da;[1=];" },
X/* ORB 207 */ { ADDR , EXTENDED,
X "fa;[1=]x" },
X/* ORB 208 */ { 0 , 0,
X "ca;[1=];" },
X/* ORB 209 */ { 0 , 0,
X "ea;" },
X/* ORCC 210 */ { 0 , 0,
X "1a;[1=];" },
X/* PSHS 211 */ { 0 , 0,
X "34;[1#];" },
X/* PSHU 212 */ { 0 , 0,
X "36;[1#];" },
X/* PULS 213 */ { 0 , 0,
X "35;[1#];" },
X/* PULU 214 */ { 0 , 0,
X "37;[1#];" },
X/* ROL 215 */ { ADDR , DIRECT,
X "09;[1=];" },
X/* ROL 216 */ { ADDR , EXTENDED,
X "79;[1=]x" },
X/* ROL 217 */ { 0 , 0,
X "69;" },
X/* ROLA 218 */ { 0 , 0,
X "49;" },
X/* ROLB 219 */ { 0 , 0,
X "59;" },
X/* ROR 220 */ { ADDR , DIRECT,
X "06;[1=];" },
X/* ROR 221 */ { ADDR , EXTENDED,
X "76;[1=]x" },
X/* ROR 222 */ { 0 , 0,
X "66;" },
X/* RORA 223 */ { 0 , 0,
X "46;" },
X/* RORB 224 */ { 0 , 0,
X "56;" },
X/* RTI 225 */ { 0 , 0,
X "3b;" },
X/* RTS 226 */ { 0 , 0,
X "39;" },
X/* SBCA 227 */ { ADDR , DIRECT,
X "92;[1=];" },
X/* SBCA 228 */ { ADDR , EXTENDED,
X "b2;[1=]x" },
X/* SBCA 229 */ { 0 , 0,
X "82;[1=];" },
X/* SBCA 230 */ { 0 , 0,
X "a2;" },
X/* SBCB 231 */ { ADDR , DIRECT,
X "d2;[1=];" },
X/* SBCB 232 */ { ADDR , EXTENDED,
X "f2;[1=]x" },
X/* SBCB 233 */ { 0 , 0,
X "c2;[1=];" },
X/* SBCB 234 */ { 0 , 0,
X "e2;" },
X/* SEX 235 */ { 0 , 0,
X "1d;" },
X/* STA 236 */ { ADDR , DIRECT,
X "97;[1=];" },
X/* STA 237 */ { ADDR , EXTENDED,
X "b7;[1=]x" },
X/* STA 238 */ { 0 , 0,
X "a7;" },
X/* STB 239 */ { ADDR , DIRECT,
X "d7;[1=];" },
X/* STB 240 */ { ADDR , EXTENDED,
X "f7;[1=]x" },
X/* STB 241 */ { 0 , 0,
X "e7;" },
X/* STD 242 */ { ADDR , DIRECT,
X "dd;[1=];" },
X/* STD 243 */ { ADDR , EXTENDED,
X "fd;[1=]x" },
X/* STD 244 */ { 0 , 0,
X "ed;" },
X/* STS 245 */ { ADDR , DIRECT,
X "10;df;[1=];" },
X/* STS 246 */ { ADDR , EXTENDED,
X "10;ff;[1=]x" },
X/* STS 247 */ { 0 , 0,
X "10;ef;" },
X/* STU 248 */ { ADDR , DIRECT,
X "df;[1=];" },
X/* STU 249 */ { ADDR , EXTENDED,
X "ff;[1=]x" },
X/* STU 250 */ { 0 , 0,
X "ef;" },
X/* STX 251 */ { ADDR , DIRECT,
X "9f;[1=];" },
X/* STX 252 */ { ADDR , EXTENDED,
X "bf;[1=]x" },
X/* STX 253 */ { 0 , 0,
X "af;" },
X/* STY 254 */ { ADDR , DIRECT,
X "10;9f;[1=];" },
X/* STY 255 */ { ADDR , EXTENDED,
X "10;bf;[1=]x" },
X/* STY 256 */ { 0 , 0,
X "10;af;" },
X/* SUBA 257 */ { ADDR , DIRECT,
X "90;[1=];" },
X/* SUBA 258 */ { ADDR , EXTENDED,
X "b0;[1=]x" },
X/* SUBA 259 */ { 0 , 0,
X "80;[1=];" },
X/* SUBA 260 */ { 0 , 0,
X "a0;" },
X/* SUBB 261 */ { ADDR , DIRECT,
X "d0;[1=];" },
X/* SUBB 262 */ { ADDR , EXTENDED,
X "f0;[1=]x" },
X/* SUBB 263 */ { 0 , 0,
X "c0;[1=];" },
X/* SUBB 264 */ { 0 , 0,
X "e0;" },
X/* SUBD 265 */ { ADDR , DIRECT,
X "93;[1=];" },
X/* SUBD 266 */ { ADDR , EXTENDED,
X "b3;[1=]x" },
X/* SUBD 267 */ { 0 , 0,
X "83;[1=]x" },
X/* SUBD 268 */ { 0 , 0,
X "a3;" },
X/* SWI2 269 */ { 0 , 0,
X "10;3f;" },
X/* SWI3 270 */ { 0 , 0,
X "11;3f;" },
X/* SWI 271 */ { 0 , 0,
X "3f;" },
X/* SYNC 272 */ { 0 , 0,
X "13;" },
X/* TFR 273 */ { 0 , 0,
X "1f;[1#2#];" },
X/* TST 274 */ { ADDR , DIRECT,
X "0d;[1=];" },
X/* TST 275 */ { ADDR , EXTENDED,
X "7d;[1=]x" },
X/* TST 276 */ { 0 , 0,
X "6d;" },
X/* TSTA 277 */ { 0 , 0,
X "4d;" },
X/* TSTB 278 */ { 0 , 0,
X "5d;" },
X { 0,0,""} };
X/* end fraptabdef.c */
SHAR_EOF
true || echo 'restore of as6809.y failed'
fi
exit 0
