Frankenstein Cross Assemblers, TI TMS7000 flavor, Part 1 of 1
Mark Zenier
markz at ssc.UUCP
Thu Dec 6 18:26:41 AEST 1990
---- Cut Here and feed the following to sh ----
#!/bin/sh
# This is Frankasm/As7000, a shell archive (shar 3.43)
# made 12/04/1990 08:46 UTC by markz at ssc.uucp
# Source directory /usr/mark/frank.shar
#
# existing files will NOT be overwritten unless -c is specified
# This format requires very little intelligence at unshar time.
# "if test", "echo", "true", and "sed" may be needed.
#
# This shar contains:
# length mode name
# ------ ---------- ------------------------------------------
# 952 -r--r----- as7000.1
# 6878 -r--r----- as7000.doc
# 3991 -r--r----- as7000.tst
# 7347 -r--r----- as7000.tut
# 36162 -r--r--r-- as7000.y
#
# ============= as7000.1 ==============
if test -f 'as7000.1' -a X"$1" != X"-c"; then
echo 'x - skipping as7000.1 (File already exists)'
else
echo 'x - extracting as7000.1 (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'as7000.1' &&
X.TH AS7000 1L
X.SH NAME
Xas7000 \- cross assembler for microcomputers
X.SH SYNOPSIS
Xas7000 [-p cpu] [-l listfile] [-o hexfile] [-d] [-s symbolfile] input
X.SH DESCRIPTION
XThe as7000 command assembles the input file into a
Xtext output file representing the program memory for a microcomputer.
X
XOptions
X.IP "-p cpu"
XIgnored by this program.
X.IP "-l listfile"
XOutput a file formated with the memory address, data, and source input lines.
X.IP "-o hexfile"
XOutput the memory data image in a form accepted by most prom programmers.
X.IP "-h hexfile"
XSame as \-o.
X.IP \-d
XSave the intermediate data file (see FILE) and abort the execution at the
Xend of processing.
X.IP "-s symbolfile"
XPrint the symbol table values and names, one per line in the specified file.
X.SH FILES
X/usr/tmp/frtXXXXXX
X.SH SEE ALSO
XFrankenstein Cross Assemblers Users Manual (file base.doc)
XAppendix for as7000 Frankenstein Assembler (file as7000.doc)
X.SH NOTES
XThere is only one input file.
SHAR_EOF
true || echo 'restore of as7000.1 failed'
fi
# ============= as7000.doc ==============
if test -f 'as7000.doc' -a X"$1" != X"-c"; then
echo 'x - skipping as7000.doc (File already exists)'
else
echo 'x - extracting as7000.doc (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'as7000.doc' &&
X.HM A 1 1 1 1 1 1
X.H 1 "Appendix for as7000 Frankenstein Assembler"
X.H 2 "Pseudo Operations"
X.H 3 "Standard Pseudo Operation Mnemonics"
X.VL 40 5 1
X.LI "End"
XEND
X.LI "File Inclusion"
XINCL
XINCLUDE
X.LI "If"
XIF
X.LI "Else"
XELSE
X.LI "End If"
XENDI
X.LI "Equate"
XEQU
X.LI "Set"
XSET
X.LI "Org"
XORG
X.LI "Reserve Memory"
XRESERVE
XRMB
X.LI "Define Byte Data"
XBYTE
XDB
XFCB
X.LI "Define Word Data"
XDW
XFDB
XWORD
X.LI "Define String Data"
XFCC
XSTRING
X.LI "Define Character Set Translation"
XCHARSET
X.LI "Define Character Value"
XCHARDEF
XCHD
X.LI "Use Character Translation"
XCHARUSE
X.LE
X.H 2 "Instructions"
X.H 3 "Differences with the TI defined Syntax"
X.DS
X.TS
X;
Xl l.
XTI syntax as7000 syntax
X.sp
Xop % immediate , register op # immediate , register
Xop % immed , register, jump dest op # immed , register , jump dest
Xop @ label op label
Xop @ label ( B ) op expr ( B )
Xop *register op [ register ]
Xmovd % immed ( B ) , register movd # immed (B), register
X.sp
XConstants
X.sp
X?0101010 %01010101
X>89ab $89ab
X'''' "'"
X.sp
XComments
X.sp
Xafter the last operand everything following a semicolon
X.sp
XSymbols
X.sp
XR0-R255 equ with value between 0 and $ff
XR0-R255 0 to 255, Not Recommended !
XP0-P255 equ with value between $100 and $1ff
XP0-P255 256 to 511, Not Recommended !
X.sp
X.TE
X.DE
X.H 3 "Instruction List"
X.TS H
X;
Xl l l.
XOpcode Syntax Selection Criteria
X.sp
X.TH
X.sp
XADC '#' expr ',' expr
XADC '#' expr ',' expr DSTA
XADC '#' expr ',' expr DSTB
XADC expr ',' expr
XADC expr ',' expr DSTA
XADC expr ',' expr DSTB
XADC expr ',' expr SRCB DSTA
X.sp
XADD '#' expr ',' expr
XADD '#' expr ',' expr DSTA
XADD '#' expr ',' expr DSTB
XADD expr ',' expr
XADD expr ',' expr DSTA
XADD expr ',' expr DSTB
XADD expr ',' expr SRCB DSTA
X.sp
XAND '#' expr ',' expr
XAND '#' expr ',' expr DSTA
XAND '#' expr ',' expr DSTB
XAND expr ',' expr
XAND expr ',' expr DSTA
XAND expr ',' expr DSTB
XAND expr ',' expr SRCB DSTA
X.sp
XANDP '#' expr ',' expr
XANDP expr ',' expr SRCA
XANDP expr ',' expr SRCB
X.sp
XBR '[' expr ']'
XBR expr '(' REG ')' SRCB
XBR expr
X.sp
XBTJO '#' expr ',' expr ',' expr
XBTJO '#' expr ',' expr ',' expr DSTA
XBTJO '#' expr ',' expr ',' expr DSTB
XBTJO expr ',' expr ',' expr
XBTJO expr ',' expr ',' expr DSTA
XBTJO expr ',' expr ',' expr DSTB
XBTJO expr ',' expr ',' expr SRCB DSTA
X.sp
XBTJOP '#' expr ',' expr ',' expr
XBTJOP expr ',' expr ',' expr SRCA
XBTJOP expr ',' expr ',' expr SRCB
X.sp
XBTJZ '#' expr ',' expr ',' expr
XBTJZ '#' expr ',' expr ',' expr DSTA
XBTJZ '#' expr ',' expr ',' expr DSTB
XBTJZ expr ',' expr ',' expr
XBTJZ expr ',' expr ',' expr DSTA
XBTJZ expr ',' expr ',' expr DSTB
XBTJZ expr ',' expr ',' expr SRCB DSTA
X.sp
XBTJZP '#' expr ',' expr ',' expr
XBTJZP expr ',' expr ',' expr SRCA
XBTJZP expr ',' expr ',' expr SRCB
X.sp
XCALL '[' expr ']'
XCALL expr '(' REG ')' SRCB
XCALL expr
X.sp
XCLR expr
XCLR expr DSTA
XCLR expr DSTB
X.sp
XCLRC
X.sp
XCMP '#' expr ',' expr
XCMP '#' expr ',' expr DSTA
XCMP '#' expr ',' expr DSTB
XCMP expr ',' expr
XCMP expr ',' expr DSTA
XCMP expr ',' expr DSTB
XCMP expr ',' expr SRCB DSTA
X.sp
XCMPA '[' expr ']'
XCMPA expr '(' REG ')' SRCB
XCMPA expr
X.sp
XDAC '#' expr ',' expr
XDAC '#' expr ',' expr DSTA
XDAC '#' expr ',' expr DSTB
XDAC expr ',' expr
XDAC expr ',' expr DSTA
XDAC expr ',' expr DSTB
XDAC expr ',' expr SRCB DSTA
X.sp
XDEC expr
XDEC expr DSTA
XDEC expr DSTB
X.sp
XDECD expr
XDECD expr DSTA
XDECD expr DSTB
X.sp
XDINT
X.sp
XDJNZ expr ',' expr
XDJNZ expr ',' expr DSTA
XDJNZ expr ',' expr DSTB
X.sp
XDSB '#' expr ',' expr
XDSB '#' expr ',' expr DSTA
XDSB '#' expr ',' expr DSTB
XDSB expr ',' expr
XDSB expr ',' expr DSTA
XDSB expr ',' expr DSTB
XDSB expr ',' expr SRCB DSTA
X.sp
XEINT
X.sp
XIDLE
X.sp
XINC expr
XINC expr DSTA
XINC expr DSTB
X.sp
XINV expr
XINV expr DSTA
XINV expr DSTB
X.sp
XJC expr
X.sp
XJEQ expr
X.sp
XJGE expr
X.sp
XJGT expr
X.sp
XJHS expr
X.sp
XJL expr
X.sp
XJLT expr
X.sp
XJMP expr
X.sp
XJN expr
X.sp
XJNC expr
X.sp
XJNE expr
X.sp
XJNZ expr
X.sp
XJP expr
X.sp
XJPZ expr
X.sp
XJZ expr
X.sp
XLDA '[' expr ']'
XLDA expr '(' REG ')' SRCB
XLDA expr
X.sp
XLDSP
X.sp
XMOV '#' expr ',' expr
XMOV '#' expr ',' expr DSTA
XMOV '#' expr ',' expr DSTB
XMOV expr ',' expr
XMOV expr ',' expr DSTA
XMOV expr ',' expr DSTB
XMOV expr ',' expr SRCA
XMOV expr ',' expr SRCA DSTB
XMOV expr ',' expr SRCB
XMOV expr ',' expr SRCB DSTA
X.sp
XMOVD '#' expr '(' REG ')' ',' expr
XMOVD '#' expr ',' expr
XMOVD expr ',' expr
X.sp
XMOVP '#' expr ',' expr
XMOVP expr ',' expr DSTA
XMOVP expr ',' expr DSTB
XMOVP expr ',' expr SRCA
XMOVP expr ',' expr SRCB
X.sp
XMPY '#' expr ',' expr
XMPY '#' expr ',' expr DSTA
XMPY '#' expr ',' expr DSTB
XMPY expr ',' expr
XMPY expr ',' expr DSTA
XMPY expr ',' expr DSTB
XMPY expr ',' expr SRCB DSTA
X.sp
XNOP
X.sp
XOR '#' expr ',' expr
XOR '#' expr ',' expr DSTA
XOR '#' expr ',' expr DSTB
XOR expr ',' expr
XOR expr ',' expr DSTA
XOR expr ',' expr DSTB
XOR expr ',' expr SRCB DSTA
X.sp
XORP '#' expr ',' expr
XORP expr ',' expr SRCA
XORP expr ',' expr SRCB
X.sp
XPOP STATUS
XPOP expr
XPOP expr DSTA
XPOP expr DSTB
X.sp
XPUSH STATUS
XPUSH expr
XPUSH expr DSTA
XPUSH expr DSTB
X.sp
XRETI
X.sp
XRETS
X.sp
XRL expr
XRL expr DSTA
XRL expr DSTB
X.sp
XRLC expr
XRLC expr DSTA
XRLC expr DSTB
X.sp
XRR expr
XRR expr DSTA
XRR expr DSTB
X.sp
XRRC expr
XRRC expr DSTA
XRRC expr DSTB
X.sp
XSBB '#' expr ',' expr
XSBB '#' expr ',' expr DSTA
XSBB '#' expr ',' expr DSTB
XSBB expr ',' expr
XSBB expr ',' expr DSTA
XSBB expr ',' expr DSTB
XSBB expr ',' expr SRCB DSTA
X.sp
XSETC
X.sp
XSTA '[' expr ']'
XSTA expr '(' REG ')' SRCB
XSTA expr
X.sp
XSTSP
X.sp
XSUB '#' expr ',' expr
XSUB '#' expr ',' expr DSTA
XSUB '#' expr ',' expr DSTB
XSUB expr ',' expr
XSUB expr ',' expr DSTA
XSUB expr ',' expr DSTB
XSUB expr ',' expr SRCB DSTA
X.sp
XSWAP expr
XSWAP expr DSTA
XSWAP expr DSTB
X.sp
XTRAP expr
X.sp
XTSTA
X.sp
XTSTB
X.sp
XXCHB expr
XXCHB expr DSTA
XXCHB expr DSTB
X.sp
XXOR '#' expr ',' expr
XXOR '#' expr ',' expr DSTA
XXOR '#' expr ',' expr DSTB
XXOR expr ',' expr
XXOR expr ',' expr DSTA
XXOR expr ',' expr DSTB
XXOR expr ',' expr SRCB DSTA
X.sp
XXORP '#' expr ',' expr
XXORP expr ',' expr SRCA
XXORP expr ',' expr SRCB
X.TE
X.H 3 "Selection Criteria Keywords"
X.VL 25 5
X.LI DSTA
XThe instruction will use a short form if the A register is used as the
Xdestination register.
X.LI DSTB
XThe instruction will use a short form if the B register is used as the
Xdestination register.
X.LI SRCA
XThe instruction will use a short form if the A register is used as the
Xsource register.
X.LI SRCB
XThe instruction will use a short form if the B register is used as the
Xsource register.
X.LE
X.H 3 "Apostrophes"
XThe apostrophes in the syntax field are a notation used for the
Xparser generator and are not put in the assembler source statement.
X.H 2 "Notes"
X.H 3 "Reserved Symbols"
X.H 4 "Machine Dependent Reserved Symbols"
XA
XB
XST
Xa
Xb
Xst
X.H 4 "Standard Reserved Symbols"
XAND
XDEFINED
XEQ
XGE
XGT
XHIGH
XLE
XLOW
XLT
XMOD
XNE
XNOT
XOR
XSHL
XSHR
XXOR
Xand
Xdefined
Xeq
Xge
Xgt
Xhigh
Xle
Xlow
Xlt
Xmod
Xne
Xnot
Xor
Xshl
Xshr
Xxor
X.TC 1 1 7
SHAR_EOF
true || echo 'restore of as7000.doc failed'
fi
# ============= as7000.tst ==============
if test -f 'as7000.tst' -a X"$1" != X"-c"; then
echo 'x - skipping as7000.tst (File already exists)'
else
echo 'x - extracting as7000.tst (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'as7000.tst' &&
Ximm equ $55
Xlabel equ $3456
Xport equ $102
Xrd equ $78
Xrs equ $34
X adc b,a
X adc rs,a
X adc rs,b
X adc rs,rd
X adc #imm,a
X adc #imm,b
X adc #imm,rd
X add b,a
X add rs,a
X add rs,b
X add rs,rd
X add #imm,a
X add #imm,b
X add #imm,rd
X and b,a
X and rs,a
X and rs,b
X and rs,rd
X and #imm,a
X and #imm,b
X and #imm,rd
X andp a,port
X andp b,port
X andp #imm,port
X br label
X br label(b)
X br [rs]
X btjo b,a,jmpdst
X btjo rs,a,jmpdst
X btjo rs,b,jmpdst
X btjo rs,rd,jmpdst
X btjo #imm,a,jmpdst
X btjo #imm,b,jmpdst
X btjo #imm,rd,jmpdst
X btjop a,port,jmpdst
X btjop b,port,jmpdst
X btjop #imm,port,jmpdst
X btjz b,a,jmpdst
X btjz rs,a,jmpdst
X btjz rs,b,jmpdst
X btjz rs,rd,jmpdst
X btjz #imm,a,jmpdst
X btjz #imm,b,jmpdst
X btjz #imm,rd,jmpdst
X btjzp a,port,jmpdst
X btjzp b,port,jmpdst
X btjzp #imm,port,jmpdst
X call label
X call label(b)
X call [rs]
X clr a
X clr b
X clr rd
X clrc
X cmp b,a
X cmp rs,a
X cmp rs,b
X cmp rs,rd
X cmp #imm,a
X cmp #imm,b
X cmp #imm,rd
X cmpa label
X cmpa label(b)
X cmpa [rs]
X dac b,a
X dac rs,a
X dac rs,b
Xjmpdst dac rs,rd
X dac #imm,a
X dac #imm,b
X dac #imm,rd
X dec a
X dec b
X dec rd
X decd a
X decd b
X decd rd
X dint
X djnz a,jmpdst
X djnz b,jmpdst
X djnz rd,jmpdst
X dsb b,a
X dsb rs,a
X dsb rs,b
X dsb rs,rd
X dsb #imm,a
X dsb #imm,b
X dsb #imm,rd
X eint
X idle
X inc a
X inc b
X inc rd
X inv a
X inv b
X inv rd
X jc jmpdst
X jeq jmpdst
X jge jmpdst
X jgt jmpdst
X jhs jmpdst
X jl jmpdst
X jlt jmpdst
X jmp jmpdst
X jn jmpdst
X jnc jmpdst
X jne jmpdst
X jnz jmpdst
X jp jmpdst
X jpz jmpdst
X jz jmpdst
X lda label
X lda label(b)
X lda [rs]
X ldsp
X mov a,b
X mov a,rd
X mov b,a
X mov b,rd
X mov rs,a
X mov rs,b
X mov rs,rd
X mov #imm,a
X mov #imm,b
X mov #imm,rd
X movd rs,rd
X movd #imm(b),rd
X movd #imm,rd
X movp a,port
X movp b,port
X movp port,a
X movp port,b
X movp #imm,port
X mpy b,a
X mpy rs,a
X mpy rs,b
X mpy rs,rd
X mpy #imm,a
X mpy #imm,b
X mpy #imm,rd
X nop
X or b,a
X or rs,a
X or rs,b
X or rs,rd
X or #imm,a
X or #imm,b
X or #imm,rd
X orp a,port
X orp b,port
X orp #imm,port
X pop a
X pop b
X pop rd
X pop st
X push a
X push b
X push rd
X push st
X reti
X rets
X rl a
X rl b
X rl rd
X rlc a
X rlc b
X rlc rd
X rr a
X rr b
X rr rd
X rrc a
X rrc b
X rrc rd
X sbb b,a
X sbb rs,a
X sbb rs,b
X sbb rs,rd
X sbb #imm,a
X sbb #imm,b
X sbb #imm,rd
X setc
X sta label
X sta label(b)
X sta [rs]
X stsp
X sub b,a
X sub rs,a
X sub rs,b
X sub rs,rd
X sub #imm,a
X sub #imm,b
X sub #imm,rd
X swap a
X swap b
X swap rd
X trap 00
X trap 01
X trap 02
X trap 03
X trap 04
X trap 05
X trap 06
X trap 07
X trap 08
X trap 09
X trap 10
X trap 11
X trap 12
X trap 13
X trap 14
X trap 15
X trap 16
X trap 17
X trap 18
X trap 19
X trap 20
X trap 21
X trap 22
X trap 23
X tsta
X tstb
X xchb a
X xchb b
X xchb rd
X xor b,a
X xor rs,a
X xor rs,b
X xor rs,rd
X xor #imm,a
X xor #imm,b
X xor #imm,rd
X xorp a,port
X xorp b,port
X xorp #imm,port
SHAR_EOF
true || echo 'restore of as7000.tst failed'
fi
# ============= as7000.tut ==============
if test -f 'as7000.tut' -a X"$1" != X"-c"; then
echo 'x - skipping as7000.tut (File already exists)'
else
echo 'x - extracting as7000.tut (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'as7000.tut' &&
X00000055 imm 00003456 label 00000102 port
X00000078 rd 00000034 rs 000000a5 jmpdst
X 0x55 imm equ $55
X 0x3456 label equ $3456
X 0x102 port equ $102
X 0x78 rd equ $78
X 0x34 rs equ $34
X0000 69 adc b,a
X0001 19 34 adc rs,a
X0003 39 34 adc rs,b
X0005 49 34 78 adc rs,rd
X0008 29 55 adc #imm,a
X000a 59 55 adc #imm,b
X000c 79 55 78 adc #imm,rd
X000f 68 add b,a
X0010 18 34 add rs,a
X0012 38 34 add rs,b
X0014 48 34 78 add rs,rd
X0017 28 55 add #imm,a
X0019 58 55 add #imm,b
X001b 78 55 78 add #imm,rd
X001e 63 and b,a
X001f 13 34 and rs,a
X0021 33 34 and rs,b
X0023 43 34 78 and rs,rd
X0026 23 55 and #imm,a
X0028 53 55 and #imm,b
X002a 73 55 78 and #imm,rd
X002d 83 02 andp a,port
X002f 93 02 andp b,port
X0031 a3 55 02 andp #imm,port
X0034 8c 34 56 br label
X0037 ac 34 56 br label(b)
X003a 9c 34 br [rs]
X003c 66 67 btjo b,a,jmpdst
X003e 16 34 64 btjo rs,a,jmpdst
X0041 36 34 61 btjo rs,b,jmpdst
X0044 46 34 78 5d btjo rs,rd,jmpdst
X0048 26 55 5a btjo #imm,a,jmpdst
X004b 56 55 57 btjo #imm,b,jmpdst
X004e 76 55 78 53 btjo #imm,rd,jmpdst
X0052 86 02 50 btjop a,port,jmpdst
X0055 96 02 4d btjop b,port,jmpdst
X0058 a6 55 02 49 btjop #imm,port,jmpdst
X005c 67 47 btjz b,a,jmpdst
X005e 17 34 44 btjz rs,a,jmpdst
X0061 37 34 41 btjz rs,b,jmpdst
X0064 47 34 78 3d btjz rs,rd,jmpdst
X0068 27 55 3a btjz #imm,a,jmpdst
X006b 57 55 37 btjz #imm,b,jmpdst
X006e 77 55 78 33 btjz #imm,rd,jmpdst
X0072 87 02 30 btjzp a,port,jmpdst
X0075 97 02 2d btjzp b,port,jmpdst
X0078 a7 55 02 29 btjzp #imm,port,jmpdst
X007c 8e 34 56 call label
X007f ae 34 56 call label(b)
X0082 9e 34 call [rs]
X0084 b5 clr a
X0085 c5 clr b
X0086 d5 78 clr rd
X0088 b0 clrc
X0089 6d cmp b,a
X008a 1d 34 cmp rs,a
X008c 3d 34 cmp rs,b
X008e 4d 34 78 cmp rs,rd
X0091 2d 55 cmp #imm,a
X0093 5d 55 cmp #imm,b
X0095 7d 55 78 cmp #imm,rd
X0098 8d 34 56 cmpa label
X009b ad 34 56 cmpa label(b)
X009e 9d 34 cmpa [rs]
X00a0 6e dac b,a
X00a1 1e 34 dac rs,a
X00a3 3e 34 dac rs,b
X00a5 4e 34 78 jmpdst dac rs,rd
X00a8 2e 55 dac #imm,a
X00aa 5e 55 dac #imm,b
X00ac 7e 55 78 dac #imm,rd
X00af b2 dec a
X00b0 c2 dec b
X00b1 d2 78 dec rd
X00b3 bb decd a
X00b4 cb decd b
X00b5 db 78 decd rd
X00b7 06 dint
X00b8 ba eb djnz a,jmpdst
X00ba ca e9 djnz b,jmpdst
X00bc da 78 e6 djnz rd,jmpdst
X00bf 6f dsb b,a
X00c0 1f 34 dsb rs,a
X00c2 3f 34 dsb rs,b
X00c4 4f 34 78 dsb rs,rd
X00c7 2f 55 dsb #imm,a
X00c9 5f 55 dsb #imm,b
X00cb 7f 55 78 dsb #imm,rd
X00ce 05 eint
X00cf 01 idle
X00d0 b3 inc a
X00d1 c3 inc b
X00d2 d3 78 inc rd
X00d4 b4 inv a
X00d5 c4 inv b
X00d6 d4 78 inv rd
X00d8 e3 cb jc jmpdst
X00da e2 c9 jeq jmpdst
X00dc e5 c7 jge jmpdst
X00de e4 c5 jgt jmpdst
X00e0 e3 c3 jhs jmpdst
X00e2 e7 c1 jl jmpdst
X00e4 e1 bf jlt jmpdst
X00e6 e0 bd jmp jmpdst
X00e8 e1 bb jn jmpdst
X00ea e7 b9 jnc jmpdst
X00ec e6 b7 jne jmpdst
X00ee e6 b5 jnz jmpdst
X00f0 e4 b3 jp jmpdst
X00f2 e5 b1 jpz jmpdst
X00f4 e2 af jz jmpdst
X00f6 8a 34 56 lda label
X00f9 aa 34 56 lda label(b)
X00fc 9a 34 lda [rs]
X00fe 0d ldsp
X00ff c0 mov a,b
X0100 d0 78 mov a,rd
X0102 62 mov b,a
X0103 d1 78 mov b,rd
X0105 12 34 mov rs,a
X0107 32 34 mov rs,b
X0109 42 34 78 mov rs,rd
X010c 22 55 mov #imm,a
X010e 52 55 mov #imm,b
X0110 72 55 78 mov #imm,rd
X0113 98 34 78 movd rs,rd
X0116 a8 00 55 78 movd #imm(b),rd
X011a 88 00 55 78 movd #imm,rd
X011e 82 02 movp a,port
X0120 92 02 movp b,port
X0122 80 02 movp port,a
X0124 91 02 movp port,b
X0126 a2 55 02 movp #imm,port
X0129 6c mpy b,a
X012a 1c 34 mpy rs,a
X012c 3c 34 mpy rs,b
X012e 4c 34 78 mpy rs,rd
X0131 2c 55 mpy #imm,a
X0133 5c 55 mpy #imm,b
X0135 7c 55 78 mpy #imm,rd
X0138 00 nop
X0139 64 or b,a
X013a 14 34 or rs,a
X013c 34 34 or rs,b
X013e 44 34 78 or rs,rd
X0141 24 55 or #imm,a
X0143 54 55 or #imm,b
X0145 74 55 78 or #imm,rd
X0148 84 02 orp a,port
X014a 94 02 orp b,port
X014c a4 55 02 orp #imm,port
X014f b9 pop a
X0150 c9 pop b
X0151 d9 78 pop rd
X0153 08 pop st
X0154 b8 push a
X0155 c8 push b
X0156 d8 78 push rd
X0158 0e push st
X0159 0b reti
X015a 0a rets
X015b be rl a
X015c ce rl b
X015d de 78 rl rd
X015f bf rlc a
X0160 cf rlc b
X0161 df 78 rlc rd
X0163 bc rr a
X0164 cc rr b
X0165 dc 78 rr rd
X0167 bd rrc a
X0168 cd rrc b
X0169 dd 78 rrc rd
X016b 6b sbb b,a
X016c 1b 34 sbb rs,a
X016e 3b 34 sbb rs,b
X0170 4b 34 78 sbb rs,rd
X0173 2b 55 sbb #imm,a
X0175 5b 55 sbb #imm,b
X0177 7b 55 78 sbb #imm,rd
X017a 07 setc
X017b 8b 34 56 sta label
X017e ab 34 56 sta label(b)
X0181 9b 34 sta [rs]
X0183 09 stsp
X0184 6a sub b,a
X0185 1a 34 sub rs,a
X0187 3a 34 sub rs,b
X0189 4a 34 78 sub rs,rd
X018c 2a 55 sub #imm,a
X018e 5a 55 sub #imm,b
X0190 7a 55 78 sub #imm,rd
X0193 b7 swap a
X0194 c7 swap b
X0195 d7 78 swap rd
X0197 ff trap 00
X0198 fe trap 01
X0199 fd trap 02
X019a fc trap 03
X019b fb trap 04
X019c fa trap 05
X019d f9 trap 06
X019e f8 trap 07
X019f f7 trap 08
X01a0 f6 trap 09
X01a1 f5 trap 10
X01a2 f4 trap 11
X01a3 f3 trap 12
X01a4 f2 trap 13
X01a5 f1 trap 14
X01a6 f0 trap 15
X01a7 ef trap 16
X01a8 ee trap 17
X01a9 ed trap 18
X01aa ec trap 19
X01ab eb trap 20
X01ac ea trap 21
X01ad e9 trap 22
X01ae e8 trap 23
X01af b0 tsta
X01b0 c1 tstb
X01b1 b6 xchb a
X01b2 c6 xchb b
X01b3 d6 78 xchb rd
X01b5 65 xor b,a
X01b6 15 34 xor rs,a
X01b8 35 34 xor rs,b
X01ba 45 34 78 xor rs,rd
X01bd 25 55 xor #imm,a
X01bf 55 55 xor #imm,b
X01c1 75 55 78 xor #imm,rd
X01c4 85 02 xorp a,port
X01c6 95 02 xorp b,port
X01c8 a5 55 02 xorp #imm,port
X ERROR SUMMARY - ERRORS DETECTED 0
X - WARNINGS 0
SHAR_EOF
true || echo 'restore of as7000.tut failed'
fi
# ============= as7000.y ==============
if test -f 'as7000.y' -a X"$1" != X"-c"; then
echo 'x - skipping as7000.y (File already exists)'
else
echo 'x - extracting as7000.y (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'as7000.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: as7000.y;
XWARNINGS: "The language defined in this file does
X not follow the standard Texas Instruments syntax.
X
X 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: as7000.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/* TMS7000 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.00xx */
X#define DSTMASK 0x3
X#define DSTA 0x1
X#define DSTB 0x2
X /* 0000.0000.0000.xx00 */
X#define SRCMASK 0xc
X#define SRCA 0x4
X#define SRCB 0x8
X#define ST_INH 0x1
X#define ST_EXPR 0x2
X#define ST_EXPR2 0x4
X#define ST_EXPR3 0x8
X#define ST_IEXPR2 0x10
X#define ST_IEXPR3 0x20
X#define ST_INDEX 0x40
X#define ST_IMMIND 0x80
X#define ST_RINDIR 0x100
X#define ST_STATUS 0x200
X
X static int operselbits;
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/illegal instruction for cpu";
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 STATUS
X%token <intv> REG
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 expr
X {
X genlocrec(currseg, labelloc);
X pevalexpr(1,$2);
X operselbits = 0;
X if(evalr[1].seg == SSG_ABS)
X {
X if(evalr[1].value == 0)
X {
X operselbits |= DSTA;
X }
X else if(evalr[1].value == 1)
X {
X operselbits |= DSTB;
X }
X }
X locctr += geninstr(findgen($1, ST_EXPR, operselbits));
X }
X ;
Xgenline : KOC_opcode expr ',' expr
X {
X genlocrec(currseg, labelloc);
X pevalexpr(1,$2);
X pevalexpr(2,$4);
X operselbits = 0;
X if(evalr[1].seg == SSG_ABS)
X {
X if(evalr[1].value == 0)
X {
X operselbits |= SRCA;
X }
X else if(evalr[1].value == 1)
X {
X operselbits |= SRCB;
X }
X }
X if(evalr[2].seg == SSG_ABS)
X {
X if(evalr[2].value == 0)
X {
X operselbits |= DSTA;
X }
X else if(evalr[2].value == 1)
X {
X operselbits |= DSTB;
X }
X }
X locctr += geninstr(findgen($1, ST_EXPR2, operselbits));
X }
X ;
Xgenline : KOC_opcode expr ',' expr ',' expr
X {
X genlocrec(currseg, labelloc);
X pevalexpr(1,$2);
X pevalexpr(2,$4);
X pevalexpr(3,$6);
X operselbits = 0;
X if(evalr[1].seg == SSG_ABS)
X {
X if(evalr[1].value == 0)
X {
X operselbits |= SRCA;
X }
X else if(evalr[1].value == 1)
X {
X operselbits |= SRCB;
X }
X }
X if(evalr[2].seg == SSG_ABS)
X {
X if(evalr[2].value == 0)
X {
X operselbits |= DSTA;
X }
X else if(evalr[2].value == 1)
X {
X operselbits |= DSTB;
X }
X }
X locctr += geninstr(findgen($1, ST_EXPR3, operselbits));
X }
X ;
Xgenline : KOC_opcode '#' expr ',' expr
X {
X genlocrec(currseg, labelloc);
X pevalexpr(1,$3);
X pevalexpr(2,$5);
X operselbits = 0;
X if(evalr[2].seg == SSG_ABS)
X {
X if(evalr[2].value == 0)
X {
X operselbits |= DSTA;
X }
X else if(evalr[2].value == 1)
X {
X operselbits |= DSTB;
X }
X }
X locctr += geninstr(findgen($1, ST_IEXPR2, operselbits));
X }
X ;
Xgenline : KOC_opcode '#' expr ',' expr ',' expr
X {
X genlocrec(currseg, labelloc);
X pevalexpr(1,$3);
X pevalexpr(2,$5);
X pevalexpr(3,$7);
X operselbits = 0;
X if(evalr[2].seg == SSG_ABS)
X {
X if(evalr[2].value == 0)
X {
X operselbits |= DSTA;
X }
X else if(evalr[2].value == 1)
X {
X operselbits |= DSTB;
X }
X }
X locctr += geninstr(findgen($1, ST_IEXPR3, operselbits));
X }
X ;
Xgenline : KOC_opcode expr '(' REG ')'
X {
X genlocrec(currseg, labelloc);
X pevalexpr(1,$2);
X operselbits = 0;
X if($4 == 0)
X {
X operselbits |= SRCA;
X }
X else if($4 == 1)
X {
X operselbits |= SRCB;
X }
X locctr += geninstr(findgen($1, ST_INDEX, operselbits));
X }
X ;
Xgenline : KOC_opcode '#' expr '(' REG ')' ',' expr
X {
X genlocrec(currseg, labelloc);
X pevalexpr(1,$3);
X pevalexpr(2,$8);
X operselbits = 0;
X if($5 == 0)
X {
X operselbits |= SRCA;
X }
X else if($5 == 1)
X {
X operselbits |= SRCB;
X }
X locctr += geninstr(findgen($1, ST_IMMIND, operselbits));
X }
X ;
Xgenline : KOC_opcode '[' expr ']'
X {
X genlocrec(currseg, labelloc);
X pevalexpr(1,$3);
X locctr += geninstr(findgen($1, ST_RINDIR, 0));
X }
X ;
Xgenline : KOC_opcode STATUS
X {
X genlocrec(currseg, labelloc);
X locctr += geninstr(findgen($1, ST_STATUS, 0));
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
Xexpr : REG
X {
X $$ = exprnode(PCCASE_CONS,0,IGP_CONSTANT,0,(long)$1,SYMNULL);
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("st", STATUS, 0);
X reservedsym("a", REG, 0);
X reservedsym("b", REG, 1);
X reservedsym("ST", STATUS, 0);
X reservedsym("A", REG, 0);
X reservedsym("B", REG, 1);
X
X}
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 92
X#define NUMSYNBLK 104
X#define NUMDIFFOP 213
X
Xint gnumopcode = NUMOPCODE;
X
Xint ophashlnk[NUMOPCODE];
X
Xstruct opsym optab[NUMOPCODE+1]
X = {
X {"invalid", KOC_opcode, 2, 0 },
X {"ADC", KOC_opcode, 2, 2 },
X {"ADD", KOC_opcode, 2, 4 },
X {"AND", KOC_opcode, 2, 6 },
X {"ANDP", KOC_opcode, 2, 8 },
X {"BR", KOC_opcode, 3, 10 },
X {"BTJO", KOC_opcode, 2, 13 },
X {"BTJOP", KOC_opcode, 2, 15 },
X {"BTJZ", KOC_opcode, 2, 17 },
X {"BTJZP", KOC_opcode, 2, 19 },
X {"BYTE", KOC_BDEF, 0, 0 },
X {"CALL", KOC_opcode, 3, 21 },
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, 24 },
X {"CLRC", KOC_opcode, 1, 25 },
X {"CMP", KOC_opcode, 2, 26 },
X {"CMPA", KOC_opcode, 3, 28 },
X {"DAC", KOC_opcode, 2, 31 },
X {"DB", KOC_BDEF, 0, 0 },
X {"DEC", KOC_opcode, 1, 33 },
X {"DECD", KOC_opcode, 1, 34 },
X {"DINT", KOC_opcode, 1, 35 },
X {"DJNZ", KOC_opcode, 1, 36 },
X {"DSB", KOC_opcode, 2, 37 },
X {"DW", KOC_WDEF, 0, 0 },
X {"EINT", KOC_opcode, 1, 39 },
X {"ELSE", KOC_ELSE, 0, 0 },
X {"END", KOC_END, 0, 0 },
X {"ENDI", KOC_ENDI, 0, 0 },
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 {"IDLE", KOC_opcode, 1, 40 },
X {"IF", KOC_IF, 0, 0 },
X {"INC", KOC_opcode, 1, 41 },
X {"INCL", KOC_INCLUDE, 0, 0 },
X {"INCLUDE", KOC_INCLUDE, 0, 0 },
X {"INV", KOC_opcode, 1, 42 },
X {"JC", KOC_opcode, 1, 43 },
X {"JEQ", KOC_opcode, 1, 44 },
X {"JGE", KOC_opcode, 1, 45 },
X {"JGT", KOC_opcode, 1, 46 },
X {"JHS", KOC_opcode, 1, 47 },
X {"JL", KOC_opcode, 1, 48 },
X {"JLT", KOC_opcode, 1, 49 },
X {"JMP", KOC_opcode, 1, 50 },
X {"JN", KOC_opcode, 1, 51 },
X {"JNC", KOC_opcode, 1, 52 },
X {"JNE", KOC_opcode, 1, 53 },
X {"JNZ", KOC_opcode, 1, 54 },
X {"JP", KOC_opcode, 1, 55 },
X {"JPZ", KOC_opcode, 1, 56 },
X {"JZ", KOC_opcode, 1, 57 },
X {"LDA", KOC_opcode, 3, 58 },
X {"LDSP", KOC_opcode, 1, 61 },
X {"MOV", KOC_opcode, 2, 62 },
X {"MOVD", KOC_opcode, 3, 64 },
X {"MOVP", KOC_opcode, 2, 67 },
X {"MPY", KOC_opcode, 2, 69 },
X {"NOP", KOC_opcode, 1, 71 },
X {"OR", KOC_opcode, 2, 72 },
X {"ORG", KOC_ORG, 0, 0 },
X {"ORP", KOC_opcode, 2, 74 },
X {"POP", KOC_opcode, 2, 76 },
X {"PUSH", KOC_opcode, 2, 78 },
X {"RESERVE", KOC_RESM, 0, 0 },
X {"RETI", KOC_opcode, 1, 80 },
X {"RETS", KOC_opcode, 1, 81 },
X {"RL", KOC_opcode, 1, 82 },
X {"RLC", KOC_opcode, 1, 83 },
X {"RMB", KOC_RESM, 0, 0 },
X {"RR", KOC_opcode, 1, 84 },
X {"RRC", KOC_opcode, 1, 85 },
X {"SBB", KOC_opcode, 2, 86 },
X {"SET", KOC_SET, 0, 0 },
X {"SETC", KOC_opcode, 1, 88 },
X {"STA", KOC_opcode, 3, 89 },
X {"STRING", KOC_SDEF, 0, 0 },
X {"STSP", KOC_opcode, 1, 92 },
X {"SUB", KOC_opcode, 2, 93 },
X {"SWAP", KOC_opcode, 1, 95 },
X {"TRAP", KOC_opcode, 1, 96 },
X {"TSTA", KOC_opcode, 1, 97 },
X {"TSTB", KOC_opcode, 1, 98 },
X {"WORD", KOC_WDEF, 0, 0 },
X {"XCHB", KOC_opcode, 1, 99 },
X {"XOR", KOC_opcode, 2, 100 },
X {"XORP", KOC_opcode, 2, 102 },
X { "", 0, 0, 0 }};
X
Xstruct opsynt ostab[NUMSYNBLK+1]
X = {
X/* invalid 0 */ { 0, 1, 0 },
X/* invalid 1 */ { 0xffff, 1, 1 },
X/* ADC 2 */ { ST_EXPR2, 4, 2 },
X/* ADC 3 */ { ST_IEXPR2, 3, 6 },
X/* ADD 4 */ { ST_EXPR2, 4, 9 },
X/* ADD 5 */ { ST_IEXPR2, 3, 13 },
X/* AND 6 */ { ST_EXPR2, 4, 16 },
X/* AND 7 */ { ST_IEXPR2, 3, 20 },
X/* ANDP 8 */ { ST_EXPR2, 2, 23 },
X/* ANDP 9 */ { ST_IEXPR2, 1, 25 },
X/* BR 10 */ { ST_EXPR, 1, 26 },
X/* BR 11 */ { ST_INDEX, 1, 27 },
X/* BR 12 */ { ST_RINDIR, 1, 28 },
X/* BTJO 13 */ { ST_EXPR3, 4, 29 },
X/* BTJO 14 */ { ST_IEXPR3, 3, 33 },
X/* BTJOP 15 */ { ST_EXPR3, 2, 36 },
X/* BTJOP 16 */ { ST_IEXPR3, 1, 38 },
X/* BTJZ 17 */ { ST_EXPR3, 4, 39 },
X/* BTJZ 18 */ { ST_IEXPR3, 3, 43 },
X/* BTJZP 19 */ { ST_EXPR3, 2, 46 },
X/* BTJZP 20 */ { ST_IEXPR3, 1, 48 },
X/* CALL 21 */ { ST_EXPR, 1, 49 },
X/* CALL 22 */ { ST_INDEX, 1, 50 },
X/* CALL 23 */ { ST_RINDIR, 1, 51 },
X/* CLR 24 */ { ST_EXPR, 3, 52 },
X/* CLRC 25 */ { ST_INH, 1, 55 },
X/* CMP 26 */ { ST_EXPR2, 4, 56 },
X/* CMP 27 */ { ST_IEXPR2, 3, 60 },
X/* CMPA 28 */ { ST_EXPR, 1, 63 },
X/* CMPA 29 */ { ST_INDEX, 1, 64 },
X/* CMPA 30 */ { ST_RINDIR, 1, 65 },
X/* DAC 31 */ { ST_EXPR2, 4, 66 },
X/* DAC 32 */ { ST_IEXPR2, 3, 70 },
X/* DEC 33 */ { ST_EXPR, 3, 73 },
X/* DECD 34 */ { ST_EXPR, 3, 76 },
X/* DINT 35 */ { ST_INH, 1, 79 },
X/* DJNZ 36 */ { ST_EXPR2, 3, 80 },
X/* DSB 37 */ { ST_EXPR2, 4, 83 },
X/* DSB 38 */ { ST_IEXPR2, 3, 87 },
X/* EINT 39 */ { ST_INH, 1, 90 },
X/* IDLE 40 */ { ST_INH, 1, 91 },
X/* INC 41 */ { ST_EXPR, 3, 92 },
X/* INV 42 */ { ST_EXPR, 3, 95 },
X/* JC 43 */ { ST_EXPR, 1, 98 },
X/* JEQ 44 */ { ST_EXPR, 1, 99 },
X/* JGE 45 */ { ST_EXPR, 1, 100 },
X/* JGT 46 */ { ST_EXPR, 1, 101 },
X/* JHS 47 */ { ST_EXPR, 1, 102 },
X/* JL 48 */ { ST_EXPR, 1, 103 },
X/* JLT 49 */ { ST_EXPR, 1, 104 },
X/* JMP 50 */ { ST_EXPR, 1, 105 },
X/* JN 51 */ { ST_EXPR, 1, 106 },
X/* JNC 52 */ { ST_EXPR, 1, 107 },
X/* JNE 53 */ { ST_EXPR, 1, 108 },
X/* JNZ 54 */ { ST_EXPR, 1, 109 },
X/* JP 55 */ { ST_EXPR, 1, 110 },
X/* JPZ 56 */ { ST_EXPR, 1, 111 },
X/* JZ 57 */ { ST_EXPR, 1, 112 },
X/* LDA 58 */ { ST_EXPR, 1, 113 },
X/* LDA 59 */ { ST_INDEX, 1, 114 },
X/* LDA 60 */ { ST_RINDIR, 1, 115 },
X/* LDSP 61 */ { ST_INH, 1, 116 },
X/* MOV 62 */ { ST_EXPR2, 7, 117 },
X/* MOV 63 */ { ST_IEXPR2, 3, 124 },
X/* MOVD 64 */ { ST_EXPR2, 1, 127 },
X/* MOVD 65 */ { ST_IEXPR2, 1, 128 },
X/* MOVD 66 */ { ST_IMMIND, 1, 129 },
X/* MOVP 67 */ { ST_EXPR2, 4, 130 },
X/* MOVP 68 */ { ST_IEXPR2, 1, 134 },
X/* MPY 69 */ { ST_EXPR2, 4, 135 },
X/* MPY 70 */ { ST_IEXPR2, 3, 139 },
X/* NOP 71 */ { ST_INH, 1, 142 },
X/* OR 72 */ { ST_EXPR2, 4, 143 },
X/* OR 73 */ { ST_IEXPR2, 3, 147 },
X/* ORP 74 */ { ST_EXPR2, 2, 150 },
X/* ORP 75 */ { ST_IEXPR2, 1, 152 },
X/* POP 76 */ { ST_EXPR, 3, 153 },
X/* POP 77 */ { ST_STATUS, 1, 156 },
X/* PUSH 78 */ { ST_EXPR, 3, 157 },
X/* PUSH 79 */ { ST_STATUS, 1, 160 },
X/* RETI 80 */ { ST_INH, 1, 161 },
X/* RETS 81 */ { ST_INH, 1, 162 },
X/* RL 82 */ { ST_EXPR, 3, 163 },
X/* RLC 83 */ { ST_EXPR, 3, 166 },
X/* RR 84 */ { ST_EXPR, 3, 169 },
X/* RRC 85 */ { ST_EXPR, 3, 172 },
X/* SBB 86 */ { ST_EXPR2, 4, 175 },
X/* SBB 87 */ { ST_IEXPR2, 3, 179 },
X/* SETC 88 */ { ST_INH, 1, 182 },
X/* STA 89 */ { ST_EXPR, 1, 183 },
X/* STA 90 */ { ST_INDEX, 1, 184 },
X/* STA 91 */ { ST_RINDIR, 1, 185 },
X/* STSP 92 */ { ST_INH, 1, 186 },
X/* SUB 93 */ { ST_EXPR2, 4, 187 },
X/* SUB 94 */ { ST_IEXPR2, 3, 191 },
X/* SWAP 95 */ { ST_EXPR, 3, 194 },
X/* TRAP 96 */ { ST_EXPR, 1, 197 },
X/* TSTA 97 */ { ST_INH, 1, 198 },
X/* TSTB 98 */ { ST_INH, 1, 199 },
X/* XCHB 99 */ { ST_EXPR, 3, 200 },
X/* XOR 100 */ { ST_EXPR2, 4, 203 },
X/* XOR 101 */ { ST_IEXPR2, 3, 207 },
X/* XORP 102 */ { ST_EXPR2, 2, 210 },
X/* XORP 103 */ { ST_IEXPR2, 1, 212 },
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/* ADC 2 */ { SRCMASK|DSTMASK , SRCB|DSTA,
X "69;" },
X/* ADC 3 */ { DSTMASK , DSTA,
X "19;[1=].8I;" },
X/* ADC 4 */ { DSTMASK , DSTB,
X "39;[1=].8I;" },
X/* ADC 5 */ { 0 , 0,
X "49;[1=].8I;[2=].8I;" },
X/* ADC 6 */ { DSTMASK , DSTA,
X "29;[1=];" },
X/* ADC 7 */ { DSTMASK , DSTB,
X "59;[1=];" },
X/* ADC 8 */ { 0 , 0,
X "79;[1=];[2=].8I;" },
X/* ADD 9 */ { SRCMASK|DSTMASK , SRCB|DSTA,
X "68;" },
X/* ADD 10 */ { DSTMASK , DSTA,
X "18;[1=].8I;" },
X/* ADD 11 */ { DSTMASK , DSTB,
X "38;[1=].8I;" },
X/* ADD 12 */ { 0 , 0,
X "48;[1=].8I;[2=].8I;" },
X/* ADD 13 */ { DSTMASK , DSTA,
X "28;[1=];" },
X/* ADD 14 */ { DSTMASK , DSTB,
X "58;[1=];" },
X/* ADD 15 */ { 0 , 0,
X "78;[1=];[2=].8I;" },
X/* AND 16 */ { SRCMASK|DSTMASK , SRCB|DSTA,
X "63;" },
X/* AND 17 */ { DSTMASK , DSTA,
X "13;[1=].8I;" },
X/* AND 18 */ { DSTMASK , DSTB,
X "33;[1=].8I;" },
X/* AND 19 */ { 0 , 0,
X "43;[1=].8I;[2=].8I;" },
X/* AND 20 */ { DSTMASK , DSTA,
X "23;[1=];" },
X/* AND 21 */ { DSTMASK , DSTB,
X "53;[1=];" },
X/* AND 22 */ { 0 , 0,
X "73;[1=];[2=].8I;" },
X/* ANDP 23 */ { SRCMASK , SRCA,
X "83;[2=].100-.8I;" },
X/* ANDP 24 */ { SRCMASK , SRCB,
X "93;[2=].100-.8I;" },
X/* ANDP 25 */ { 0 , 0,
X "a3;[1=];[2=].100-.8I;" },
X/* BR 26 */ { 0 , 0,
X "8c;[1=]x" },
X/* BR 27 */ { SRCMASK , SRCB,
X "ac;[1=]x" },
X/* BR 28 */ { 0 , 0,
X "9c;[1=].8I;" },
X/* BTJO 29 */ { SRCMASK|DSTMASK , SRCB|DSTA,
X "66;[3=].Q.1+-r" },
X/* BTJO 30 */ { DSTMASK , DSTA,
X "16;[1=].8I;[3=].Q.1+-r" },
X/* BTJO 31 */ { DSTMASK , DSTB,
X "36;[1=].8I;[3=].Q.1+-r" },
X/* BTJO 32 */ { 0 , 0,
X "46;[1=].8I;[2=].8I;[3=].Q.1+-r" },
X/* BTJO 33 */ { DSTMASK , DSTA,
X "26;[1=];[3=].Q.1+-r" },
X/* BTJO 34 */ { DSTMASK , DSTB,
X "56;[1=];[3=].Q.1+-r" },
X/* BTJO 35 */ { 0 , 0,
X "76;[1=];[2=].8I;[3=].Q.1+-r" },
X/* BTJOP 36 */ { SRCMASK , SRCA,
X "86;[2=].100-.8I;[3=].Q.1+-r" },
X/* BTJOP 37 */ { SRCMASK , SRCB,
X "96;[2=].100-.8I;[3=].Q.1+-r" },
X/* BTJOP 38 */ { 0 , 0,
X "a6;[1=];[2=].100-.8I;[3=].Q.1+-r" },
X/* BTJZ 39 */ { SRCMASK|DSTMASK , SRCB|DSTA,
X "67;[3=].Q.1+-r" },
X/* BTJZ 40 */ { DSTMASK , DSTA,
X "17;[1=].8I;[3=].Q.1+-r" },
X/* BTJZ 41 */ { DSTMASK , DSTB,
X "37;[1=].8I;[3=].Q.1+-r" },
X/* BTJZ 42 */ { 0 , 0,
X "47;[1=].8I;[2=].8I;[3=].Q.1+-r" },
X/* BTJZ 43 */ { DSTMASK , DSTA,
X "27;[1=];[3=].Q.1+-r" },
X/* BTJZ 44 */ { DSTMASK , DSTB,
X "57;[1=];[3=].Q.1+-r" },
X/* BTJZ 45 */ { 0 , 0,
X "77;[1=];[2=].8I;[3=].Q.1+-r" },
X/* BTJZP 46 */ { SRCMASK , SRCA,
X "87;[2=].100-.8I;[3=].Q.1+-r" },
X/* BTJZP 47 */ { SRCMASK , SRCB,
X "97;[2=].100-.8I;[3=].Q.1+-r" },
X/* BTJZP 48 */ { 0 , 0,
X "a7;[1=];[2=].100-.8I;[3=].Q.1+-r" },
X/* CALL 49 */ { 0 , 0,
X "8e;[1=]x" },
X/* CALL 50 */ { SRCMASK , SRCB,
X "ae;[1=]x" },
X/* CALL 51 */ { 0 , 0,
X "9e;[1=].8I;" },
X/* CLR 52 */ { DSTMASK , DSTA,
X "b5;" },
X/* CLR 53 */ { DSTMASK , DSTB,
X "c5;" },
X/* CLR 54 */ { 0 , 0,
X "d5;[1=].8I;" },
X/* CLRC 55 */ { 0 , 0,
X "b0;" },
X/* CMP 56 */ { SRCMASK|DSTMASK , SRCB|DSTA,
X "6d;" },
X/* CMP 57 */ { DSTMASK , DSTA,
X "1d;[1=].8I;" },
X/* CMP 58 */ { DSTMASK , DSTB,
X "3d;[1=].8I;" },
X/* CMP 59 */ { 0 , 0,
X "4d;[1=].8I;[2=].8I;" },
X/* CMP 60 */ { DSTMASK , DSTA,
X "2d;[1=];" },
X/* CMP 61 */ { DSTMASK , DSTB,
X "5d;[1=];" },
X/* CMP 62 */ { 0 , 0,
X "7d;[1=];[2=].8I;" },
X/* CMPA 63 */ { 0 , 0,
X "8d;[1=]x" },
X/* CMPA 64 */ { SRCMASK , SRCB,
X "ad;[1=]x" },
X/* CMPA 65 */ { 0 , 0,
X "9d;[1=].8I;" },
X/* DAC 66 */ { SRCMASK|DSTMASK , SRCB|DSTA,
X "6e;" },
X/* DAC 67 */ { DSTMASK , DSTA,
X "1e;[1=].8I;" },
X/* DAC 68 */ { DSTMASK , DSTB,
X "3e;[1=].8I;" },
X/* DAC 69 */ { 0 , 0,
X "4e;[1=].8I;[2=].8I;" },
X/* DAC 70 */ { DSTMASK , DSTA,
X "2e;[1=];" },
X/* DAC 71 */ { DSTMASK , DSTB,
X "5e;[1=];" },
X/* DAC 72 */ { 0 , 0,
X "7e;[1=];[2=].8I;" },
X/* DEC 73 */ { DSTMASK , DSTA,
X "b2;" },
X/* DEC 74 */ { DSTMASK , DSTB,
X "c2;" },
X/* DEC 75 */ { 0 , 0,
X "d2;[1=].8I;" },
X/* DECD 76 */ { DSTMASK , DSTA,
X "bb;" },
X/* DECD 77 */ { DSTMASK , DSTB,
X "cb;" },
X/* DECD 78 */ { 0 , 0,
X "db;[1=].8I;" },
X/* DINT 79 */ { 0 , 0,
X "06;" },
X/* DJNZ 80 */ { SRCMASK , SRCA,
X "ba;[2=].Q.1+-r" },
X/* DJNZ 81 */ { SRCMASK , SRCB,
X "ca;[2=].Q.1+-r" },
X/* DJNZ 82 */ { 0 , 0,
X "da;[1=].8I;[2=].Q.1+-r" },
X/* DSB 83 */ { SRCMASK|DSTMASK , SRCB|DSTA,
X "6f;" },
X/* DSB 84 */ { DSTMASK , DSTA,
X "1f;[1=].8I;" },
X/* DSB 85 */ { DSTMASK , DSTB,
X "3f;[1=].8I;" },
X/* DSB 86 */ { 0 , 0,
X "4f;[1=].8I;[2=].8I;" },
X/* DSB 87 */ { DSTMASK , DSTA,
X "2f;[1=];" },
X/* DSB 88 */ { DSTMASK , DSTB,
X "5f;[1=];" },
X/* DSB 89 */ { 0 , 0,
X "7f;[1=];[2=].8I;" },
X/* EINT 90 */ { 0 , 0,
X "05;" },
X/* IDLE 91 */ { 0 , 0,
X "01;" },
X/* INC 92 */ { DSTMASK , DSTA,
X "b3;" },
X/* INC 93 */ { DSTMASK , DSTB,
X "c3;" },
X/* INC 94 */ { 0 , 0,
X "d3;[1=].8I;" },
X/* INV 95 */ { DSTMASK , DSTA,
X "b4;" },
X/* INV 96 */ { DSTMASK , DSTB,
X "c4;" },
X/* INV 97 */ { 0 , 0,
X "d4;[1=].8I;" },
X/* JC 98 */ { 0 , 0,
X "e3;[1=].Q.1+-r" },
X/* JEQ 99 */ { 0 , 0,
X "e2;[1=].Q.1+-r" },
X/* JGE 100 */ { 0 , 0,
X "e5;[1=].Q.1+-r" },
X/* JGT 101 */ { 0 , 0,
X "e4;[1=].Q.1+-r" },
X/* JHS 102 */ { 0 , 0,
X "e3;[1=].Q.1+-r" },
X/* JL 103 */ { 0 , 0,
X "e7;[1=].Q.1+-r" },
X/* JLT 104 */ { 0 , 0,
X "e1;[1=].Q.1+-r" },
X/* JMP 105 */ { 0 , 0,
X "e0;[1=].Q.1+-r" },
X/* JN 106 */ { 0 , 0,
X "e1;[1=].Q.1+-r" },
X/* JNC 107 */ { 0 , 0,
X "e7;[1=].Q.1+-r" },
X/* JNE 108 */ { 0 , 0,
X "e6;[1=].Q.1+-r" },
X/* JNZ 109 */ { 0 , 0,
X "e6;[1=].Q.1+-r" },
X/* JP 110 */ { 0 , 0,
X "e4;[1=].Q.1+-r" },
X/* JPZ 111 */ { 0 , 0,
X "e5;[1=].Q.1+-r" },
X/* JZ 112 */ { 0 , 0,
X "e2;[1=].Q.1+-r" },
X/* LDA 113 */ { 0 , 0,
X "8a;[1=]x" },
X/* LDA 114 */ { SRCMASK , SRCB,
X "aa;[1=]x" },
X/* LDA 115 */ { 0 , 0,
X "9a;[1=].8I;" },
X/* LDSP 116 */ { 0 , 0,
X "0d;" },
X/* MOV 117 */ { SRCMASK|DSTMASK , SRCA|DSTB,
X "c0;" },
X/* MOV 118 */ { SRCMASK|DSTMASK , SRCB|DSTA,
X "62;" },
X/* MOV 119 */ { DSTMASK , DSTA,
X "12;[1=].8I;" },
X/* MOV 120 */ { SRCMASK , SRCA,
X "d0;[2=].8I;" },
X/* MOV 121 */ { SRCMASK , SRCB,
X "d1;[2=].8I;" },
X/* MOV 122 */ { DSTMASK , DSTB,
X "32;[1=].8I;" },
X/* MOV 123 */ { 0 , 0,
X "42;[1=].8I;[2=].8I;" },
X/* MOV 124 */ { DSTMASK , DSTA,
X "22;[1=];" },
X/* MOV 125 */ { DSTMASK , DSTB,
X "52;[1=];" },
X/* MOV 126 */ { 0 , 0,
X "72;[1=];[2=].8I;" },
X/* MOVD 127 */ { 0 , 0,
X "98;[1=].8I;[2=].8I;" },
X/* MOVD 128 */ { 0 , 0,
X "88;[1=]x[2=].8I;" },
X/* MOVD 129 */ { SRCMASK , SRCB,
X "a8;[1=]x[2=].8I;" },
X/* MOVP 130 */ { SRCMASK , SRCA,
X "82;[2=].100-.8I;" },
X/* MOVP 131 */ { SRCMASK , SRCB,
X "92;[2=].100-.8I;" },
X/* MOVP 132 */ { DSTMASK , DSTA,
X "80;[1=].100-.8I;" },
X/* MOVP 133 */ { DSTMASK , DSTB,
X "91;[1=].100-.8I;" },
X/* MOVP 134 */ { 0 , 0,
X "a2;[1=];[2=].100-.8I;" },
X/* MPY 135 */ { SRCMASK|DSTMASK , SRCB|DSTA,
X "6c;" },
X/* MPY 136 */ { DSTMASK , DSTA,
X "1c;[1=].8I;" },
X/* MPY 137 */ { DSTMASK , DSTB,
X "3c;[1=].8I;" },
X/* MPY 138 */ { 0 , 0,
X "4c;[1=].8I;[2=].8I;" },
X/* MPY 139 */ { DSTMASK , DSTA,
X "2c;[1=];" },
X/* MPY 140 */ { DSTMASK , DSTB,
X "5c;[1=];" },
X/* MPY 141 */ { 0 , 0,
X "7c;[1=];[2=].8I;" },
X/* NOP 142 */ { 0 , 0,
X "00;" },
X/* OR 143 */ { SRCMASK|DSTMASK , SRCB|DSTA,
X "64;" },
X/* OR 144 */ { DSTMASK , DSTA,
X "14;[1=].8I;" },
X/* OR 145 */ { DSTMASK , DSTB,
X "34;[1=].8I;" },
X/* OR 146 */ { 0 , 0,
X "44;[1=].8I;[2=].8I;" },
X/* OR 147 */ { DSTMASK , DSTA,
X "24;[1=];" },
X/* OR 148 */ { DSTMASK , DSTB,
X "54;[1=];" },
X/* OR 149 */ { 0 , 0,
X "74;[1=];[2=].8I;" },
X/* ORP 150 */ { SRCMASK , SRCA,
X "84;[2=].100-.8I;" },
X/* ORP 151 */ { SRCMASK , SRCB,
X "94;[2=].100-.8I;" },
X/* ORP 152 */ { 0 , 0,
X "a4;[1=];[2=].100-.8I;" },
X/* POP 153 */ { DSTMASK , DSTA,
X "b9;" },
X/* POP 154 */ { DSTMASK , DSTB,
X "c9;" },
X/* POP 155 */ { 0 , 0,
X "d9;[1=].8I;" },
X/* POP 156 */ { 0 , 0,
X "08;" },
X/* PUSH 157 */ { DSTMASK , DSTA,
X "b8;" },
X/* PUSH 158 */ { DSTMASK , DSTB,
X "c8;" },
X/* PUSH 159 */ { 0 , 0,
X "d8;[1=].8I;" },
X/* PUSH 160 */ { 0 , 0,
X "0e;" },
X/* RETI 161 */ { 0 , 0,
X "0b;" },
X/* RETS 162 */ { 0 , 0,
X "0a;" },
X/* RL 163 */ { DSTMASK , DSTA,
X "be;" },
X/* RL 164 */ { DSTMASK , DSTB,
X "ce;" },
X/* RL 165 */ { 0 , 0,
X "de;[1=].8I;" },
X/* RLC 166 */ { DSTMASK , DSTA,
X "bf;" },
X/* RLC 167 */ { DSTMASK , DSTB,
X "cf;" },
X/* RLC 168 */ { 0 , 0,
X "df;[1=].8I;" },
X/* RR 169 */ { DSTMASK , DSTA,
X "bc;" },
X/* RR 170 */ { DSTMASK , DSTB,
X "cc;" },
X/* RR 171 */ { 0 , 0,
X "dc;[1=].8I;" },
X/* RRC 172 */ { DSTMASK , DSTA,
X "bd;" },
X/* RRC 173 */ { DSTMASK , DSTB,
X "cd;" },
X/* RRC 174 */ { 0 , 0,
X "dd;[1=].8I;" },
X/* SBB 175 */ { SRCMASK|DSTMASK , SRCB|DSTA,
X "6b;" },
X/* SBB 176 */ { DSTMASK , DSTA,
X "1b;[1=].8I;" },
X/* SBB 177 */ { DSTMASK , DSTB,
X "3b;[1=].8I;" },
X/* SBB 178 */ { 0 , 0,
X "4b;[1=].8I;[2=].8I;" },
X/* SBB 179 */ { DSTMASK , DSTA,
X "2b;[1=];" },
X/* SBB 180 */ { DSTMASK , DSTB,
X "5b;[1=];" },
X/* SBB 181 */ { 0 , 0,
X "7b;[1=];[2=].8I;" },
X/* SETC 182 */ { 0 , 0,
X "07;" },
X/* STA 183 */ { 0 , 0,
X "8b;[1=]x" },
X/* STA 184 */ { SRCMASK , SRCB,
X "ab;[1=]x" },
X/* STA 185 */ { 0 , 0,
X "9b;[1=].8I;" },
X/* STSP 186 */ { 0 , 0,
X "09;" },
X/* SUB 187 */ { SRCMASK|DSTMASK , SRCB|DSTA,
X "6a;" },
X/* SUB 188 */ { DSTMASK , DSTA,
X "1a;[1=].8I;" },
X/* SUB 189 */ { DSTMASK , DSTB,
X "3a;[1=].8I;" },
X/* SUB 190 */ { 0 , 0,
X "4a;[1=].8I;[2=].8I;" },
X/* SUB 191 */ { DSTMASK , DSTA,
X "2a;[1=];" },
X/* SUB 192 */ { DSTMASK , DSTB,
X "5a;[1=];" },
X/* SUB 193 */ { 0 , 0,
X "7a;[1=];[2=].8I;" },
X/* SWAP 194 */ { DSTMASK , DSTA,
X "b7;" },
X/* SWAP 195 */ { DSTMASK , DSTB,
X "c7;" },
X/* SWAP 196 */ { 0 , 0,
X "d7;[1=].8I;" },
X/* TRAP 197 */ { 0 , 0,
X "ff.[1=].5I-~.e8<T!;" },
X/* TSTA 198 */ { 0 , 0,
X "b0;" },
X/* TSTB 199 */ { 0 , 0,
X "c1;" },
X/* XCHB 200 */ { DSTMASK , DSTA,
X "b6;" },
X/* XCHB 201 */ { DSTMASK , DSTB,
X "c6;" },
X/* XCHB 202 */ { 0 , 0,
X "d6;[1=].8I;" },
X/* XOR 203 */ { SRCMASK|DSTMASK , SRCB|DSTA,
X "65;" },
X/* XOR 204 */ { DSTMASK , DSTA,
X "15;[1=].8I;" },
X/* XOR 205 */ { DSTMASK , DSTB,
X "35;[1=].8I;" },
X/* XOR 206 */ { 0 , 0,
X "45;[1=].8I;[2=].8I;" },
X/* XOR 207 */ { DSTMASK , DSTA,
X "25;[1=];" },
X/* XOR 208 */ { DSTMASK , DSTB,
X "55;[1=];" },
X/* XOR 209 */ { 0 , 0,
X "75;[1=];[2=].8I;" },
X/* XORP 210 */ { SRCMASK , SRCA,
X "85;[2=].100-.8I;" },
X/* XORP 211 */ { SRCMASK , SRCB,
X "95;[2=].100-.8I;" },
X/* XORP 212 */ { 0 , 0,
X "a5;[1=];[2=].100-.8I;" },
X { 0,0,""} };
X/* end fraptabdef.c */
SHAR_EOF
true || echo 'restore of as7000.y failed'
fi
exit 0
More information about the Alt.sources
mailing list