Path: utzoo!utgpu!cs.utexas.edu!uunet!pilchuck!ssc!markz
From: markz@ssc.UUCP (Mark Zenier)
Newsgroups: alt.sources
Subject: Frankenstein Cross Assemblers, Intel 8048 "Flavor", Part 2 of 2
Message-ID: <597@ssc.UUCP>
Date: 4 Dec 90 08:16:44 GMT
Organization: SSC, Inc., Seattle, WA
Lines: 1769
Archive-name: Frankasm/As804802
Submitted-by: markz@ssc.uucp

---- Cut Here and feed the following to sh ----
#!/bin/sh
# This is part 02 of Frankasm/As8048
# ============= as8048.y ==============
if test -f 'as8048.y' -a X"$1" != X"-c"; then
	echo 'x - skipping as8048.y (File already exists)'
else
echo 'x - extracting as8048.y (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'as8048.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: 	as8048.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: 	as8048.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/* 8048  et al  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/* 0000.0000.0000.xxxx  interrupt selections */
X#define	ISELMASK	0xf
X#define	ISELI		0x1
X#define	ISELTCNTI	0x2
X#define	ISELDMA		0x4
X#define	ISELFLAGS	0x8
X/* 0000.0000.0000.xxxx  accum-flag selections */
X#define	AFSELMASK	0xf
X#define	AFSELA		0x1
X#define	AFSELC		0x2
X#define	AFSELF0		0x4
X#define	AFSELF1		0x8
X/* 0000.0000.xxxx.0000  low port selections */
X#define	PSELMASK	0xf0
X#define	PSELBUS		0x10
X#define	PSELP1		0x20
X#define	PSELP2		0x40
X#define	PSELDBB		0x80
X/* 0000.00xx.xxxx.0000  misc register selections */
X#define	MSELMASK	0x3f0
X#define	MSELPSW		0x10
X#define	MSELT		0x20
X#define	MSELCNT		0x40
X#define	MSELTCNT	0x80
X#define	MSELCLK		0x100
X#define	MSELSTS		0x200
X/* 0000.xx00.0000.0000  ram size */
X#define	RAMSIZEMASK	0xc00
X#define	RAMSIZE64	0x400
X#define	RAMSIZE128	0x800
X#define	RAMSIZE256	0xc00
X/* xxx0.0000.0000.0000  instruction set variations */
X#define	INSTIDL		0x8000
X#define	INSTNOT41	0x4000
X#define	INST41		0x2000
X#define	CPU8048		INSTNOT41|RAMSIZE64
X#define	CPU8049		INSTNOT41|RAMSIZE128
X#define	CPU8050		INSTNOT41|RAMSIZE256
X#define	CPU80C48	INSTNOT41|INSTIDL|RAMSIZE64
X#define	CPU80C49	INSTNOT41|INSTIDL|RAMSIZE128
X#define	CPU80C50	INSTNOT41|INSTIDL|RAMSIZE256
X#define	CPU8041		INST41|RAMSIZE64
X#define	CPU8042		INST41|RAMSIZE128
X#define ST_AF 0x1
X#define ST_REG 0x2
X#define ST_EXPR 0x4
X#define ST_AR 0x8
X#define ST_AINDIRR 0x10
X#define ST_AIMMED 0x20
X#define ST_INDIRA 0x40
X#define ST_INDIRR 0x80
X#define ST_REGEXP 0x100
X#define ST_PA2 0x200
X#define ST_PA4 0x400
X#define ST_P2A 0x800
X#define ST_P4A 0x1000
X#define ST_P2IMMED 0x2000
X#define ST_INH 0x1
X#define ST_INT 0x2
X#define ST_RSELC 0x4
X#define ST_MSELC 0x8
X#define ST_MREG 0x10
X#define ST_MAR 0x1
X#define ST_MAINDIRA 0x2
X#define ST_MAINDIRR 0x4
X#define ST_MAIMMED 0x8
X#define ST_MAMR 0x10
X#define ST_MMRA 0x20
X#define ST_MRA 0x40
X#define ST_MRIMMED 0x80
X#define ST_MINDIRRA 0x100
X#define ST_MINDIRRIM 0x200
X	
X	static char	genbdef[] = "[1=];";
X	static char	genwdef[] = "[1=]y"; /* x for normal, y for byte rev */
X	char ignosyn[] = "[Xinvalid syntax for instruction";
X	char ignosel[] = "[Xinvalid operands/illegal instruction for cpu";
X	int	cpuselect = CPU80C50;
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> RSELC
X%token <intv> MSELC
X%token <intv> INT
X%token <intv> AF
X%token <intv> REG
X%token <intv> P02
X%token <intv> P47
X%token <intv> MREG
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_CPU
X%token <intv> KOC_REG
X%token <intv> KOC_opcode
X%token <intv> KOC_misc
X%token <intv> KOC_mov
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
Xline	:	KOC_CPU STRING
X			{
X		if( ! cpumatch($2))
X		{
X			fraerror("unknown cpu type, 80C50 assumed");
X			cpuselect = CPU80C50;
X		}
X			}
X	;
Xline :		LABEL KOC_REG 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					switch(cpuselect & RAMSIZEMASK)
X					{
X					case RAMSIZE64:
X						if(evalr[0].value < 0 ||
X						   evalr[0].value > 63)
X						{
X							fraerror(
X					"unimplemented register address");
X						}
X						break;
X
X					case RAMSIZE128:
X						if(evalr[0].value < 0 ||
X						   evalr[0].value > 127)
X						{
X							fraerror(
X					"unimplemented register address");
X						}
X						break;
X
X					case RAMSIZE256:
X						if(evalr[0].value < 0 ||
X						   evalr[0].value > 255)
X						{
X							fraerror(
X					"unimplemented register address");
X						}
X						break;
X
X					default:
X						break;
X					}
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 REGISTER SET");
X				}
X			}
X			else
X			{
X				fraerror(
X			"cannot change symbol value with REGISTER SET");
X			}
X		}
X	;
Xgenline : KOC_opcode  AF
X			{
X		genlocrec(currseg, labelloc);
X		locctr += geninstr(findgen($1, ST_AF,  $2|cpuselect));
X			}
X	;
Xgenline : KOC_opcode  REG
X			{
X		genlocrec(currseg, labelloc);
X		evalr[1].value = $2;
X		locctr += geninstr(findgen($1, ST_REG,  cpuselect));
X			}
X	;
Xgenline : KOC_opcode  expr
X			{
X		genlocrec(currseg, labelloc);
X		pevalexpr(1, $2);
X		locctr += geninstr(findgen($1, ST_EXPR,  cpuselect));
X			}
X	;
Xgenline : KOC_opcode  AF ',' REG
X			{
X		genlocrec(currseg, labelloc);
X		evalr[1].value = $4;
X		locctr += geninstr(findgen($1, ST_AR,  $2|cpuselect));
X			}
X	;
Xgenline : KOC_opcode  AF ',' '@' REG
X			{
X		genlocrec(currseg, labelloc);
X		if($5 > 1)
X		{
X			fraerror("invalid register for indirect mode");
X			evalr[1].value = 0;
X		}
X		else
X		{
X			evalr[1].value = $5;
X		}
X		locctr += geninstr(findgen($1, ST_AINDIRR,  $2|cpuselect));
X			}
X	;
Xgenline : KOC_opcode  AF ',' '#' expr
X			{
X		genlocrec(currseg, labelloc);
X		pevalexpr(1, $5);
X		locctr += geninstr(findgen($1, ST_AIMMED,  $2|cpuselect));
X			}
X	;
Xgenline : KOC_opcode  '@' AF
X			{
X		genlocrec(currseg, labelloc);
X		locctr += geninstr(findgen($1, ST_INDIRA,  $3|cpuselect));
X			}
X	;
Xgenline : KOC_opcode  '@' REG
X			{
X		genlocrec(currseg, labelloc);
X		if($3 > 1)
X		{
X			fraerror("invalid register for indirect mode");
X			evalr[1].value = 0;
X		}
X		else
X		{
X			evalr[1].value = $3;
X		}
X		locctr += geninstr(findgen($1, ST_INDIRR,  cpuselect));
X			}
X	;
Xgenline : KOC_opcode  REG ',' expr
X			{
X		genlocrec(currseg, labelloc);
X		evalr[1].value = $2;
X		pevalexpr(2, $4);
X		locctr += geninstr(findgen($1, ST_REGEXP,  cpuselect));
X			}
X	;
Xgenline : KOC_opcode  AF ',' P02
X			{
X		genlocrec(currseg, labelloc);
X		locctr += geninstr(findgen($1, ST_PA2,  $2 | $4|cpuselect));
X			}
X	;
Xgenline : KOC_opcode  AF ',' P47 
X			{
X		genlocrec(currseg, labelloc);
X		evalr[1].value = $4;
X		locctr += geninstr(findgen($1, ST_PA4,  $2|cpuselect));
X			}
X	;
Xgenline : KOC_opcode  P02 ',' AF
X			{
X		genlocrec(currseg, labelloc);
X		locctr += geninstr(findgen($1, ST_P2A,  $2 | $4|cpuselect));
X			}
X	;
Xgenline : KOC_opcode  P47 ',' AF
X			{
X		genlocrec(currseg, labelloc);
X		evalr[1].value = $2;
X		locctr += geninstr(findgen($1, ST_P4A,  $4|cpuselect));
X			}
X	;
Xgenline : KOC_opcode  P02 ',' '#' expr
X			{
X		genlocrec(currseg, labelloc);
X		pevalexpr(1, $5);
X		locctr += geninstr(findgen($1, ST_P2IMMED,  $2|cpuselect));
X			}
X	;
Xgenline : KOC_misc 
X			{
X		genlocrec(currseg, labelloc);
X		locctr += geninstr(findgen($1, ST_INH,  cpuselect));
X			}
X	;
Xgenline : KOC_misc  INT
X			{
X		genlocrec(currseg, labelloc);
X		locctr += geninstr(findgen($1, ST_INT,  $2|cpuselect));
X			}
X	;
Xgenline : KOC_misc  RSELC
X			{
X		genlocrec(currseg, labelloc);
X		evalr[1].value = $2 << 4;
X		locctr += geninstr(findgen($1, ST_RSELC,  cpuselect));
X			}
X	;
Xgenline : KOC_misc  MSELC
X			{
X		genlocrec(currseg, labelloc);
X		evalr[1].value = $2 << 4;
X		locctr += geninstr(findgen($1, ST_MSELC,  cpuselect));
X			}
X	;
Xgenline : KOC_misc  MREG
X			{
X		genlocrec(currseg, labelloc);
X		locctr += geninstr(findgen($1, ST_MREG,  $2|cpuselect));
X			}
X	;
Xgenline : KOC_mov  AF ',' REG
X			{
X		genlocrec(currseg, labelloc);
X		evalr[1].value = $4;
X		locctr += geninstr(findgen($1, ST_MAR,  $2|cpuselect));
X			}
X	;
Xgenline : KOC_mov  AF ',' '@' AF
X			{
X		genlocrec(currseg, labelloc);
X		locctr += geninstr(findgen($1, ST_MAINDIRA,  $2|$5|cpuselect));
X			}
X	;
Xgenline : KOC_mov  AF ',' '@' REG
X			{
X		genlocrec(currseg, labelloc);
X		if($5 > 1)
X		{
X			fraerror("invalid register for indirect mode");
X			evalr[1].value = 0;
X		}
X		else
X		{
X			evalr[1].value = $5;
X		}
X		locctr += geninstr(findgen($1, ST_MAINDIRR,  $2|cpuselect));
X			}
X	;
Xgenline : KOC_mov  AF ',' '#' expr
X			{
X		genlocrec(currseg, labelloc);
X		pevalexpr(1, $5);
X		locctr += geninstr(findgen($1, ST_MAIMMED,  $2|cpuselect));
X			}
X	;
Xgenline : KOC_mov  AF ',' MREG
X			{
X		genlocrec(currseg, labelloc);
X		locctr += geninstr(findgen($1, ST_MAMR,  $2 | $4|cpuselect));
X			}
X	;
Xgenline : KOC_mov  MREG ',' AF
X			{
X		genlocrec(currseg, labelloc);
X		locctr += geninstr(findgen($1, ST_MMRA,  $2 | $4|cpuselect));
X			}
X	;
Xgenline : KOC_mov  REG ',' AF
X			{
X		genlocrec(currseg, labelloc);
X		evalr[1].value = $2;
X		locctr += geninstr(findgen($1, ST_MRA,  $4|cpuselect));
X			}
X	;
Xgenline : KOC_mov  REG ',' '#' expr
X			{
X		genlocrec(currseg, labelloc);
X		evalr[1].value = $2;
X		pevalexpr(2, $5);
X		locctr += geninstr(findgen($1, ST_MRIMMED,  cpuselect));
X			}
X	;
Xgenline : KOC_mov  '@' REG ',' AF
X			{
X		genlocrec(currseg, labelloc);
X		if($3 > 1)
X		{
X			fraerror("invalid register for indirect mode");
X			evalr[1].value = 0;
X		}
X		else
X		{
X			evalr[1].value = $3;
X		}
X		locctr += geninstr(findgen($1, ST_MINDIRRA,  $5|cpuselect));
X			}
X	;
Xgenline : KOC_mov  '@' REG ',' '#' expr
X			{
X		genlocrec(currseg, labelloc);
X		if($3 > 1)
X		{
X			fraerror("invalid register for indirect mode");
X			evalr[1].value = 0;
X		}
X		else
X		{
X			evalr[1].value = $3;
X		}
X		pevalexpr(2, $6);
X		locctr += geninstr(findgen($1, ST_MINDIRRIM,  cpuselect));
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%%
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("RB0", RSELC, 0);
X	reservedsym("RB1", RSELC, 1);
X	reservedsym("MB0", MSELC, 2);
X	reservedsym("MB1", MSELC, 3);
X	reservedsym("I", INT, ISELI);
X	reservedsym("TCNTI", INT, ISELTCNTI);
X	reservedsym("A", AF, AFSELA);
X	reservedsym("C", AF, AFSELC);
X	reservedsym("F0", AF, AFSELF0);
X	reservedsym("F1", AF, AFSELF1);
X	reservedsym("R0", REG, 0);
X	reservedsym("R1", REG, 1);
X	reservedsym("R2", REG, 2);
X	reservedsym("R3", REG, 3);
X	reservedsym("R4", REG, 4);
X	reservedsym("R5", REG, 5);
X	reservedsym("R6", REG, 6);
X	reservedsym("R7", REG, 7);
X	reservedsym("BUS", P02, PSELBUS);
X	reservedsym("P1", P02, PSELP1);
X	reservedsym("P2", P02, PSELP2);
X	reservedsym("P4", P47, 0);
X	reservedsym("P5", P47, 1);
X	reservedsym("P6", P47, 2);
X	reservedsym("P7", P47, 3);
X	reservedsym("PSW", MREG, MSELPSW);
X	reservedsym("T", MREG, MSELT);
X	reservedsym("CNT", MREG, MSELCNT);
X	reservedsym("TCNT", MREG, MSELTCNT);
X	reservedsym("CLK", MREG, MSELCLK);
X	reservedsym("DMA", INT, ISELDMA);
X	reservedsym("FLAGS", INT, ISELFLAGS);
X	reservedsym("DBB", P02, PSELDBB);
X	reservedsym("STS", MREG, MSELSTS);
X	reservedsym("rb0", RSELC, 0);
X	reservedsym("rb1", RSELC, 1);
X	reservedsym("mb0", MSELC, 2);
X	reservedsym("mb1", MSELC, 3);
X	reservedsym("i", INT, ISELI);
X	reservedsym("tcnti", INT, ISELTCNTI);
X	reservedsym("a", AF, AFSELA);
X	reservedsym("c", AF, AFSELC);
X	reservedsym("f0", AF, AFSELF0);
X	reservedsym("f1", AF, AFSELF1);
X	reservedsym("r0", REG, 0);
X	reservedsym("r1", REG, 1);
X	reservedsym("r2", REG, 2);
X	reservedsym("r3", REG, 3);
X	reservedsym("r4", REG, 4);
X	reservedsym("r5", REG, 5);
X	reservedsym("r6", REG, 6);
X	reservedsym("r7", REG, 7);
X	reservedsym("bus", P02, PSELBUS);
X	reservedsym("p1", P02, PSELP1);
X	reservedsym("p2", P02, PSELP2);
X	reservedsym("p4", P47, 0);
X	reservedsym("p5", P47, 1);
X	reservedsym("p6", P47, 2);
X	reservedsym("p7", P47, 3);
X	reservedsym("psw", MREG, MSELPSW);
X	reservedsym("t", MREG, MSELT);
X	reservedsym("cnt", MREG, MSELCNT);
X	reservedsym("tcnt", MREG, MSELTCNT);
X	reservedsym("clk", MREG, MSELCLK);
X	reservedsym("dma", INT, ISELDMA);
X	reservedsym("flags", INT, ISELFLAGS);
X	reservedsym("dbb", P02, PSELDBB);
X	reservedsym("sts", MREG, MSELSTS);
X
X}
X
Xcpumatch(str)
X	char * str;
X{
X	int msub;
X
X	static struct
X	{
X		char * mtch;
X		int   cpuv;
X	} matchtab[] =
X	{
X		{"C48", CPU80C48},
X		{"c48", CPU80C48},
X		{"C35", CPU80C48},
X		{"c35", CPU80C48},
X		{"C49", CPU80C49},
X		{"c49", CPU80C49},
X		{"C39", CPU80C49},
X		{"c39", CPU80C49},
X		{"C50", CPU80C50},
X		{"c50", CPU80C50},
X		{"C40", CPU80C50},
X		{"c40", CPU80C50},
X		{"48", CPU8048},
X		{"35", CPU8048},
X		{"49", CPU8049},
X		{"39", CPU8049},
X		{"50", CPU8050},
X		{"40", CPU8050},
X		{"41", CPU8041},
X		{"42", CPU8042},
X		{ "" , 0 }
X	};
X
X	for(msub = 0; matchtab[msub].mtch[0] != '\0'; msub++)
X	{
X		if(strcontains(str, matchtab[msub].mtch))
X		{
X			cpuselect = matchtab[msub].cpuv;
X			return TRUE;
X		}
X	}
X
X	return FALSE;
X}
X
X
Xstrcontains(s1, sm)
X	char * s1, *sm;
X{
X	int l1 = strlen(s1), lm = strlen(sm);
X
X	for(; l1 >= lm; l1--, s1++)
X	{
X		if(strncmp(s1, sm, lm) == 0)
X		{
X			return TRUE;
X		}
X	}
X	return FALSE;
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 91
X#define NUMSYNBLK 94
X#define NUMDIFFOP 116
X
Xint gnumopcode = NUMOPCODE;
X
Xint ophashlnk[NUMOPCODE];
X
Xstruct opsym optab[NUMOPCODE+1]
X	= {
X	{"invalid", KOC_opcode, 2, 0 },
X	{"ADD", KOC_opcode, 3, 2 },
X	{"ADDC", KOC_opcode, 3, 5 },
X	{"ANL", KOC_opcode, 4, 8 },
X	{"ANLD", KOC_opcode, 1, 12 },
X	{"BYTE", KOC_BDEF, 0, 0 },
X	{"CALL", KOC_opcode, 1, 13 },
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, 1, 14 },
X	{"CPL", KOC_opcode, 1, 15 },
X	{"CPU", KOC_CPU, 0, 0 },
X	{"DA", KOC_opcode, 1, 16 },
X	{"DB", KOC_BDEF, 0, 0 },
X	{"DEC", KOC_opcode, 2, 17 },
X	{"DIS", KOC_misc, 1, 19 },
X	{"DJNZ", KOC_opcode, 1, 20 },
X	{"DW", KOC_WDEF, 0, 0 },
X	{"ELSE", KOC_ELSE, 0, 0 },
X	{"EN", KOC_misc, 1, 21 },
X	{"END", KOC_END, 0, 0 },
X	{"ENDI", KOC_ENDI, 0, 0 },
X	{"ENT0", KOC_misc, 1, 22 },
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	{"HALT", KOC_misc, 1, 23 },
X	{"IDL", KOC_misc, 1, 24 },
X	{"IF", KOC_IF, 0, 0 },
X	{"IN", KOC_opcode, 1, 25 },
X	{"INC", KOC_opcode, 3, 26 },
X	{"INCL", KOC_INCLUDE, 0, 0 },
X	{"INCLUDE", KOC_INCLUDE, 0, 0 },
X	{"INS", KOC_opcode, 1, 29 },
X	{"JB0", KOC_opcode, 1, 30 },
X	{"JB1", KOC_opcode, 1, 31 },
X	{"JB2", KOC_opcode, 1, 32 },
X	{"JB3", KOC_opcode, 1, 33 },
X	{"JB4", KOC_opcode, 1, 34 },
X	{"JB5", KOC_opcode, 1, 35 },
X	{"JB6", KOC_opcode, 1, 36 },
X	{"JB7", KOC_opcode, 1, 37 },
X	{"JC", KOC_opcode, 1, 38 },
X	{"JF0", KOC_opcode, 1, 39 },
X	{"JF1", KOC_opcode, 1, 40 },
X	{"JMP", KOC_opcode, 1, 41 },
X	{"JMPP", KOC_opcode, 1, 42 },
X	{"JNC", KOC_opcode, 1, 43 },
X	{"JNI", KOC_opcode, 1, 44 },
X	{"JNIBF", KOC_opcode, 1, 45 },
X	{"JNT0", KOC_opcode, 1, 46 },
X	{"JNT1", KOC_opcode, 1, 47 },
X	{"JNZ", KOC_opcode, 1, 48 },
X	{"JOBF", KOC_opcode, 1, 49 },
X	{"JT0", KOC_opcode, 1, 50 },
X	{"JT1", KOC_opcode, 1, 51 },
X	{"JTF", KOC_opcode, 1, 52 },
X	{"JZ", KOC_opcode, 1, 53 },
X	{"MOV", KOC_mov, 9, 54 },
X	{"MOVD", KOC_opcode, 2, 63 },
X	{"MOVP3", KOC_mov, 1, 65 },
X	{"MOVP", KOC_mov, 1, 66 },
X	{"MOVX", KOC_mov, 2, 67 },
X	{"NOP", KOC_misc, 1, 69 },
X	{"ORG", KOC_ORG, 0, 0 },
X	{"ORL", KOC_opcode, 4, 70 },
X	{"ORLD", KOC_opcode, 1, 74 },
X	{"OUT", KOC_opcode, 1, 75 },
X	{"OUTL", KOC_opcode, 1, 76 },
X	{"REGISTER", KOC_REG, 0, 0 },
X	{"RESERVE", KOC_RESM, 0, 0 },
X	{"RET", KOC_misc, 1, 77 },
X	{"RETR", KOC_misc, 1, 78 },
X	{"RL", KOC_opcode, 1, 79 },
X	{"RLC", KOC_opcode, 1, 80 },
X	{"RMB", KOC_RESM, 0, 0 },
X	{"RR", KOC_opcode, 1, 81 },
X	{"RRC", KOC_opcode, 1, 82 },
X	{"SEL", KOC_misc, 2, 83 },
X	{"SET", KOC_SET, 0, 0 },
X	{"STOP", KOC_misc, 1, 85 },
X	{"STRING", KOC_SDEF, 0, 0 },
X	{"STRT", KOC_misc, 1, 86 },
X	{"SWAP", KOC_opcode, 1, 87 },
X	{"WORD", KOC_WDEF, 0, 0 },
X	{"XCH", KOC_opcode, 2, 88 },
X	{"XCHD", KOC_opcode, 1, 90 },
X	{"XRL", KOC_opcode, 3, 91 },
X	{ "", 0, 0, 0 }};
X
Xstruct opsynt ostab[NUMSYNBLK+1]
X	= {
X/* invalid 0 */ { 0, 1, 0 },
X/* invalid 1 */ { 0xffff, 1, 1 },
X/* ADD 2 */ { ST_AIMMED, 1, 2 },
X/* ADD 3 */ { ST_AINDIRR, 1, 3 },
X/* ADD 4 */ { ST_AR, 1, 4 },
X/* ADDC 5 */ { ST_AIMMED, 1, 5 },
X/* ADDC 6 */ { ST_AINDIRR, 1, 6 },
X/* ADDC 7 */ { ST_AR, 1, 7 },
X/* ANL 8 */ { ST_AIMMED, 1, 8 },
X/* ANL 9 */ { ST_AINDIRR, 1, 9 },
X/* ANL 10 */ { ST_AR, 1, 10 },
X/* ANL 11 */ { ST_P2IMMED, 3, 11 },
X/* ANLD 12 */ { ST_P4A, 1, 14 },
X/* CALL 13 */ { ST_EXPR, 1, 15 },
X/* CLR 14 */ { ST_AF, 4, 16 },
X/* CPL 15 */ { ST_AF, 4, 20 },
X/* DA 16 */ { ST_AF, 1, 24 },
X/* DEC 17 */ { ST_AF, 1, 25 },
X/* DEC 18 */ { ST_REG, 1, 26 },
X/* DIS 19 */ { ST_INT, 2, 27 },
X/* DJNZ 20 */ { ST_REGEXP, 1, 29 },
X/* EN 21 */ { ST_INT, 4, 30 },
X/* ENT0 22 */ { ST_MREG, 1, 34 },
X/* HALT 23 */ { ST_INH, 1, 35 },
X/* IDL 24 */ { ST_INH, 1, 36 },
X/* IN 25 */ { ST_PA2, 3, 37 },
X/* INC 26 */ { ST_AF, 1, 40 },
X/* INC 27 */ { ST_INDIRR, 1, 41 },
X/* INC 28 */ { ST_REG, 1, 42 },
X/* INS 29 */ { ST_PA2, 1, 43 },
X/* JB0 30 */ { ST_EXPR, 1, 44 },
X/* JB1 31 */ { ST_EXPR, 1, 45 },
X/* JB2 32 */ { ST_EXPR, 1, 46 },
X/* JB3 33 */ { ST_EXPR, 1, 47 },
X/* JB4 34 */ { ST_EXPR, 1, 48 },
X/* JB5 35 */ { ST_EXPR, 1, 49 },
X/* JB6 36 */ { ST_EXPR, 1, 50 },
X/* JB7 37 */ { ST_EXPR, 1, 51 },
X/* JC 38 */ { ST_EXPR, 1, 52 },
X/* JF0 39 */ { ST_EXPR, 1, 53 },
X/* JF1 40 */ { ST_EXPR, 1, 54 },
X/* JMP 41 */ { ST_EXPR, 1, 55 },
X/* JMPP 42 */ { ST_INDIRA, 1, 56 },
X/* JNC 43 */ { ST_EXPR, 1, 57 },
X/* JNI 44 */ { ST_EXPR, 1, 58 },
X/* JNIBF 45 */ { ST_EXPR, 1, 59 },
X/* JNT0 46 */ { ST_EXPR, 1, 60 },
X/* JNT1 47 */ { ST_EXPR, 1, 61 },
X/* JNZ 48 */ { ST_EXPR, 1, 62 },
X/* JOBF 49 */ { ST_EXPR, 1, 63 },
X/* JT0 50 */ { ST_EXPR, 1, 64 },
X/* JT1 51 */ { ST_EXPR, 1, 65 },
X/* JTF 52 */ { ST_EXPR, 1, 66 },
X/* JZ 53 */ { ST_EXPR, 1, 67 },
X/* MOV 54 */ { ST_MAIMMED, 1, 68 },
X/* MOV 55 */ { ST_MAINDIRR, 1, 69 },
X/* MOV 56 */ { ST_MAMR, 2, 70 },
X/* MOV 57 */ { ST_MAR, 1, 72 },
X/* MOV 58 */ { ST_MINDIRRA, 1, 73 },
X/* MOV 59 */ { ST_MINDIRRIM, 1, 74 },
X/* MOV 60 */ { ST_MMRA, 3, 75 },
X/* MOV 61 */ { ST_MRA, 1, 78 },
X/* MOV 62 */ { ST_MRIMMED, 1, 79 },
X/* MOVD 63 */ { ST_P4A, 1, 80 },
X/* MOVD 64 */ { ST_PA4, 1, 81 },
X/* MOVP3 65 */ { ST_MAINDIRA, 1, 82 },
X/* MOVP 66 */ { ST_MAINDIRA, 1, 83 },
X/* MOVX 67 */ { ST_MAINDIRR, 1, 84 },
X/* MOVX 68 */ { ST_MINDIRRA, 1, 85 },
X/* NOP 69 */ { ST_INH, 1, 86 },
X/* ORL 70 */ { ST_AIMMED, 1, 87 },
X/* ORL 71 */ { ST_AINDIRR, 1, 88 },
X/* ORL 72 */ { ST_AR, 1, 89 },
X/* ORL 73 */ { ST_P2IMMED, 3, 90 },
X/* ORLD 74 */ { ST_P4A, 1, 93 },
X/* OUT 75 */ { ST_P2A, 1, 94 },
X/* OUTL 76 */ { ST_P2A, 3, 95 },
X/* RET 77 */ { ST_INH, 1, 98 },
X/* RETR 78 */ { ST_INH, 1, 99 },
X/* RL 79 */ { ST_AF, 1, 100 },
X/* RLC 80 */ { ST_AF, 1, 101 },
X/* RR 81 */ { ST_AF, 1, 102 },
X/* RRC 82 */ { ST_AF, 1, 103 },
X/* SEL 83 */ { ST_MSELC, 1, 104 },
X/* SEL 84 */ { ST_RSELC, 1, 105 },
X/* STOP 85 */ { ST_MREG, 1, 106 },
X/* STRT 86 */ { ST_MREG, 2, 107 },
X/* SWAP 87 */ { ST_AF, 1, 109 },
X/* XCH 88 */ { ST_AINDIRR, 1, 110 },
X/* XCH 89 */ { ST_AR, 1, 111 },
X/* XCHD 90 */ { ST_AINDIRR, 1, 112 },
X/* XRL 91 */ { ST_AIMMED, 1, 113 },
X/* XRL 92 */ { ST_AINDIRR, 1, 114 },
X/* XRL 93 */ { ST_AR, 1, 115 },
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/* ADD 2 */   { AFSELMASK , AFSELA, 
X		"03;[1=];" },
X/* ADD 3 */   { AFSELMASK , AFSELA, 
X		"60.[1#]|;" },
X/* ADD 4 */   { AFSELMASK , AFSELA, 
X		"68.[1#]|;" },
X/* ADDC 5 */   { AFSELMASK , AFSELA, 
X		"13;[1=];" },
X/* ADDC 6 */   { AFSELMASK , AFSELA, 
X		"70.[1#]|;" },
X/* ADDC 7 */   { AFSELMASK , AFSELA, 
X		"78.[1#]|;" },
X/* ANL 8 */   { AFSELMASK , AFSELA, 
X		"53;[1=];" },
X/* ANL 9 */   { AFSELMASK , AFSELA, 
X		"50.[1#]|;" },
X/* ANL 10 */   { AFSELMASK , AFSELA, 
X		"58.[1#]|;" },
X/* ANL 11 */   { INSTNOT41|PSELMASK , PSELBUS|INSTNOT41, 
X		"98;[1=];" },
X/* ANL 12 */   { PSELMASK , PSELP1, 
X		"99;[1=];" },
X/* ANL 13 */   { PSELMASK , PSELP2, 
X		"9a;[1=];" },
X/* ANLD 14 */   { AFSELMASK , AFSELA, 
X		"9c.[1#]|;" },
X/* CALL 15 */   { 0 , 0, 
X		"[1=].P.f800&-.bI~.3}.e0&.14|;!.ff&;" },
X/* CLR 16 */   { AFSELMASK , AFSELA, 
X		"27;" },
X/* CLR 17 */   { AFSELMASK , AFSELC, 
X		"97;" },
X/* CLR 18 */   { AFSELMASK , AFSELF0, 
X		"85;" },
X/* CLR 19 */   { AFSELMASK , AFSELF1, 
X		"a5;" },
X/* CPL 20 */   { AFSELMASK , AFSELA, 
X		"37;" },
X/* CPL 21 */   { AFSELMASK , AFSELC, 
X		"a7;" },
X/* CPL 22 */   { AFSELMASK , AFSELF0, 
X		"95;" },
X/* CPL 23 */   { AFSELMASK , AFSELF1, 
X		"b5;" },
X/* DA 24 */   { AFSELMASK , AFSELA, 
X		"57;" },
X/* DEC 25 */   { AFSELMASK , AFSELA, 
X		"07;" },
X/* DEC 26 */   { 0 , 0, 
X		"c8.[1#]|;" },
X/* DIS 27 */   { ISELMASK , ISELI, 
X		"15;" },
X/* DIS 28 */   { ISELMASK , ISELTCNTI, 
X		"35;" },
X/* DJNZ 29 */   { 0 , 0, 
X		"e8.[1#]|;[2=].Q.ff00&-.8I;" },
X/* EN 30 */   { ISELMASK , ISELI, 
X		"05;" },
X/* EN 31 */   { ISELMASK , ISELTCNTI, 
X		"25;" },
X/* EN 32 */   { INST41|ISELMASK , ISELDMA|INST41, 
X		"e5;" },
X/* EN 33 */   { INST41|ISELMASK , ISELFLAGS|INST41, 
X		"f5;" },
X/* ENT0 34 */   { INSTNOT41|MSELMASK , MSELCLK|INSTNOT41, 
X		"75;" },
X/* HALT 35 */   { INSTIDL , INSTIDL, 
X		"01;" },
X/* IDL 36 */   { INSTIDL , INSTIDL, 
X		"01;" },
X/* IN 37 */   { INST41|PSELMASK|AFSELMASK , PSELDBB|AFSELA|INST41, 
X		"22;" },
X/* IN 38 */   { PSELMASK|AFSELMASK , PSELP1|AFSELA, 
X		"09;" },
X/* IN 39 */   { PSELMASK|AFSELMASK , PSELP2|AFSELA, 
X		"0a;" },
X/* INC 40 */   { AFSELMASK , AFSELA, 
X		"17;" },
X/* INC 41 */   { 0 , 0, 
X		"10.[1#]|;" },
X/* INC 42 */   { 0 , 0, 
X		"18.[1#]|;" },
X/* INS 43 */   { INSTNOT41|PSELMASK|AFSELMASK , PSELBUS|AFSELA|INSTNOT41, 
X		"08;" },
X/* JB0 44 */   { 0 , 0, 
X		"12;[1=].Q.ff00&-.8I;" },
X/* JB1 45 */   { 0 , 0, 
X		"32;[1=].Q.ff00&-.8I;" },
X/* JB2 46 */   { 0 , 0, 
X		"52;[1=].Q.ff00&-.8I;" },
X/* JB3 47 */   { 0 , 0, 
X		"72;[1=].Q.ff00&-.8I;" },
X/* JB4 48 */   { 0 , 0, 
X		"92;[1=].Q.ff00&-.8I;" },
X/* JB5 49 */   { 0 , 0, 
X		"b2;[1=].Q.ff00&-.8I;" },
X/* JB6 50 */   { 0 , 0, 
X		"d2;[1=].Q.ff00&-.8I;" },
X/* JB7 51 */   { 0 , 0, 
X		"f2;[1=].Q.ff00&-.8I;" },
X/* JC 52 */   { 0 , 0, 
X		"f6;[1=].Q.ff00&-.8I;" },
X/* JF0 53 */   { 0 , 0, 
X		"b6;[1=].Q.ff00&-.8I;" },
X/* JF1 54 */   { 0 , 0, 
X		"76;[1=].Q.ff00&-.8I;" },
X/* JMP 55 */   { 0 , 0, 
X		"[1=].P.f800&-.bI~.3}.e0&.04|;!.ff&;" },
X/* JMPP 56 */   { AFSELMASK , AFSELA, 
X		"b3;" },
X/* JNC 57 */   { 0 , 0, 
X		"e6;[1=].Q.ff00&-.8I;" },
X/* JNI 58 */   { INSTNOT41 , INSTNOT41, 
X		"86;[1=].Q.ff00&-.8I;" },
X/* JNIBF 59 */   { INST41 , INST41, 
X		"d6;[1=].Q.ff00&-.8I;" },
X/* JNT0 60 */   { 0 , 0, 
X		"26;[1=].Q.ff00&-.8I;" },
X/* JNT1 61 */   { 0 , 0, 
X		"46;[1=].Q.ff00&-.8I;" },
X/* JNZ 62 */   { 0 , 0, 
X		"96;[1=].Q.ff00&-.8I;" },
X/* JOBF 63 */   { INST41 , INST41, 
X		"86;[1=].Q.ff00&-.8I;" },
X/* JT0 64 */   { 0 , 0, 
X		"36;[1=].Q.ff00&-.8I;" },
X/* JT1 65 */   { 0 , 0, 
X		"56;[1=].Q.ff00&-.8I;" },
X/* JTF 66 */   { 0 , 0, 
X		"16;[1=].Q.ff00&-.8I;" },
X/* JZ 67 */   { 0 , 0, 
X		"c6;[1=].Q.ff00&-.8I;" },
X/* MOV 68 */   { AFSELMASK , AFSELA, 
X		"23;[1=];" },
X/* MOV 69 */   { AFSELMASK , AFSELA, 
X		"f0.[1#]|;" },
X/* MOV 70 */   { AFSELMASK|MSELMASK , AFSELA|MSELPSW, 
X		"c7;" },
X/* MOV 71 */   { AFSELMASK|MSELMASK , AFSELA|MSELT, 
X		"42;" },
X/* MOV 72 */   { AFSELMASK , AFSELA, 
X		"f8.[1#]|;" },
X/* MOV 73 */   { AFSELMASK , AFSELA, 
X		"a0.[1#]|;" },
X/* MOV 74 */   { 0 , 0, 
X		"b0.[1#]|;[2=];" },
X/* MOV 75 */   { AFSELMASK|MSELMASK , AFSELA|MSELPSW, 
X		"d7;" },
X/* MOV 76 */   { INST41|AFSELMASK|MSELMASK , AFSELA|MSELSTS|INST41, 
X		"50;" },
X/* MOV 77 */   { AFSELMASK|MSELMASK , AFSELA|MSELT, 
X		"62;" },
X/* MOV 78 */   { AFSELMASK , AFSELA, 
X		"a8.[1#]|;" },
X/* MOV 79 */   { 0 , 0, 
X		"b8.[1#]|;[2=];" },
X/* MOVD 80 */   { AFSELMASK , AFSELA, 
X		"3c.[1#]|;" },
X/* MOVD 81 */   { AFSELMASK , AFSELA, 
X		"0c.[1#]|;" },
X/* MOVP3 82 */   { AFSELMASK , AFSELA, 
X		"e3;" },
X/* MOVP 83 */   { AFSELMASK , AFSELA, 
X		"a3;" },
X/* MOVX 84 */   { INSTNOT41|AFSELMASK , AFSELA|INSTNOT41, 
X		"80.[1#]|;" },
X/* MOVX 85 */   { INSTNOT41|AFSELMASK , AFSELA|INSTNOT41, 
X		"90.[1#]|;" },
X/* NOP 86 */   { 0 , 0, 
X		"00;" },
X/* ORL 87 */   { AFSELMASK , AFSELA, 
X		"43;[1=];" },
X/* ORL 88 */   { AFSELMASK , AFSELA, 
X		"40.[1#]|;" },
X/* ORL 89 */   { AFSELMASK , AFSELA, 
X		"48.[1#]|;" },
X/* ORL 90 */   { INSTNOT41|PSELMASK , PSELBUS|INSTNOT41, 
X		"88;[1=];" },
X/* ORL 91 */   { PSELMASK , PSELP1, 
X		"89;[1=];" },
X/* ORL 92 */   { PSELMASK , PSELP2, 
X		"8a;[1=];" },
X/* ORLD 93 */   { AFSELMASK , AFSELA, 
X		"8c.[1#]|;" },
X/* OUT 94 */   { INST41|AFSELMASK|PSELMASK , AFSELA|PSELDBB|INST41, 
X		"02;" },
X/* OUTL 95 */   { INSTNOT41|AFSELMASK|PSELMASK , AFSELA|PSELBUS|INSTNOT41, 
X		"02;" },
X/* OUTL 96 */   { AFSELMASK|PSELMASK , AFSELA|PSELP1, 
X		"39;" },
X/* OUTL 97 */   { AFSELMASK|PSELMASK , AFSELA|PSELP2, 
X		"3a;" },
X/* RET 98 */   { 0 , 0, 
X		"83;" },
X/* RETR 99 */   { 0 , 0, 
X		"93;" },
X/* RL 100 */   { AFSELMASK , AFSELA, 
X		"e7;" },
X/* RLC 101 */   { AFSELMASK , AFSELA, 
X		"f7;" },
X/* RR 102 */   { AFSELMASK , AFSELA, 
X		"77;" },
X/* RRC 103 */   { AFSELMASK , AFSELA, 
X		"67;" },
X/* SEL 104 */   { INSTNOT41 , INSTNOT41, 
X		"c5.[1#]|;" },
X/* SEL 105 */   { 0 , 0, 
X		"c5.[1#]|;" },
X/* STOP 106 */   { MSELMASK , MSELTCNT, 
X		"65;" },
X/* STRT 107 */   { MSELMASK , MSELCNT, 
X		"45;" },
X/* STRT 108 */   { MSELMASK , MSELT, 
X		"55;" },
X/* SWAP 109 */   { AFSELMASK , AFSELA, 
X		"47;" },
X/* XCH 110 */   { AFSELMASK , AFSELA, 
X		"20.[1#]|;" },
X/* XCH 111 */   { AFSELMASK , AFSELA, 
X		"28.[1#]|;" },
X/* XCHD 112 */   { AFSELMASK , AFSELA, 
X		"30.[1#]|;" },
X/* XRL 113 */   { AFSELMASK , AFSELA, 
X		"d3;[1=];" },
X/* XRL 114 */   { AFSELMASK , AFSELA, 
X		"d0.[1#]|;" },
X/* XRL 115 */   { AFSELMASK , AFSELA, 
X		"d8.[1#]|;" },
X	{ 0,0,""} };
X/* end fraptabdef.c */
SHAR_EOF
true || echo 'restore of as8048.y failed'
fi
exit 0


Brought to you by Super Global Mega Corp .com