d0p1/ack
1
0
Fork 0
Code Issues Pull requests Packages Projects Releases Wiki Activity
ack/mach/6500/cg/table
bal 58c679c94c Patterns for floating point instruction and for LFR 8 and RET 8 added. 
Each such instruction now results in a call to a library routine.
At present, all these routines generate an Illegal EM Instruction trap,
but anyone wishing to implement floating point for the 6502 can
do so without changing the back end table.
1984-11-06 12:47:26 +00:00

2294 lines
33 KiB
Plaintext
Raw Blame History

#define em_bsize 2 /* must be equal to EM_BSIZE */
#define ND !defined($1)
#define D defined($1)
#define BASE 240
#define MIN (0-BASE)
#define MAX (254-em_bsize-BASE)
#define IN(x) (x>=MIN && x<=MAX)
#define IND(x) (x>=MIN && x<=(MAX-2))
/*****************************************************\
**** ****
**** 6 5 0 0 B A C K E N D T A B L E ****
**** ****
\*****************************************************/
/*
* INTEGER SIZE: 16 bits
* POINTER SIZE: 16 bits
* NO FLOATS
*/
EM_WSIZE = 2
EM_PSIZE = 2
EM_BSIZE = 2
/*********************\
* R E G I S T E R S *
\*********************/
REGISTERS:
AA = ("a",1), REG.
XX = ("x",1), REG.
AX = ("<dummy>",2,AA,XX), R16.
/* AX is a registerpair, A contains the highbyte of a word and
* X contains the lowbyte
*/
/***************\
* T O K E N S *
\***************/
TOKENS:
IMMEDIATE = {INT off;} 1 "#%[off]" /* a fake token the
* cgg needs one
*/
/***********************************\
* T O K E N E X P R E S S I O N S *
\***********************************/
TOKENEXPRESSIONS:
AAA = IMMEDIATE /* a fake tokenexpression
* the cgg needs one
*/
/***********\
* C O D E *
\***********/
CODE:
/* GROUP 1 - LOAD */
loc ($1%256)==($1/256) | |
allocate(R16)
"lda #[$1].l"
"tax"
| %[a] | |
loc | |
allocate(R16)
"lda #[$1].h"
"ldx #[$1].l"
| %[a] | |
ldc highw(1)==loww(1) && (loww(1)%256)==(loww(1)/256) | |
allocate(R16)
"lda #[%(loww(1)%)].l"
"tax"
"jsr Push"
| %[a] | |
ldc | |
allocate(R16)
"lda #[%(highw(1)%)].h"
"ldx #[%(highw(1)%)].l"
"jsr Push"
"lda #[%(loww(1)%)].h"
"ldx #[%(loww(1)%)].l"
| %[a] | |
lol IN($1) | |
allocate(R16)
"ldy #BASE+$1"
"lda (LBl),y"
"tax"
"iny"
"lda (LBl),y"
| %[a] | |
lol | |
allocate(R16)
"lda #[$1].h"
"ldx #[$1].l"
"jsr Lol"
| %[a] | |
loe | |
allocate(R16)
"lda $1+1"
"ldx $1"
| %[a] | |
lil IN($1) | |
allocate(R16)
"ldy #BASE+$1"
"lda (LBl),y"
"tax"
"iny"
"lda (LBl),y"
"jsr Loi"
| %[a] | |
lil | |
allocate(R16)
"lda #[$1].h"
"ldx #[$1].l"
"jsr Lol"
"jsr Loi"
| %[a] | |
lof $1==0 | R16 |
"jsr Loi"
| %[1] | |
lof | |
allocate(R16)
"lda #[$1].h"
"ldx #[$1].l"
"jsr Adi2"
"jsr Loi"
| %[a] | |
lal | |
allocate(R16)
"clc"
"lda #[$1].l"
"adc LB"
"tax"
"lda #[$1].h"
"adc LB+1"
| %[a] | |
lae | |
allocate(R16)
"lda #[$1].h"
"ldx #[$1].l"
| %[a] | |
lxl $1==0 | |
allocate(R16)
"lda LB+1"
"ldx LB"
| %[a] | |
lxl $1<=255 | | /* n restricted to a max of 255 */
allocate(R16)
"ldx #[$1].l"
"jsr Lxl"
| %[a] | |
lxa $1==0 | |
allocate(R16)
"jsr Lxa1"
| %[a] | |
lxa $1<=255 | | /* n restricted to a max of 255 */
allocate(R16)
"ldx #[$1].l"
"jsr Lxa2"
| %[a] | |
loi $1==1 | R16 |
"jsr Loi1"
| %[1] | |
loi $1==2 | R16 |
"jsr Loi"
| %[1] | |
loi $1==4 | R16 |
"jsr Ldi"
| | |
loi D | R16 |
"ldy #[$1].h"
"sty NBYTES+1"
"ldy #[$1].l"
"jsr Loil"
| | |
los $1==2 | R16 |
"jsr Los"
| | |
ldl IND($1) | |
allocate(R16)
"ldy #BASE+$1+3"
"lda (LBl),y"
"pha"
"dey"
"lda (LBl),y"
"tax"
"pla"
"jsr Push"
"dey"
"lda (LBl),y"
"pha"
"dey"
"lda (LBl),y"
"tax"
"pla"
| %[a] | |
ldl | |
allocate(R16)
"lda #[$1].h"
"ldx #[$1].l"
"jsr Locaddr"
"jsr Ldo"
| | |
lde | |
allocate(R16)
"lda $1+3"
"ldx $1+2"
"jsr Push"
"lda $1+1"
"ldx $1"
| %[a] | |
ldf $1==0 | R16 |
"jsr Ldi"
| | |
ldf | |
allocate(R16)
"lda #[$1].h"
"ldx #[$1].l"
"jsr Adi2"
"jsr Ldi"
| | |
lpi | |
allocate(R16)
"lda #[$1].h"
"ldx #[$1].l"
| %[a] | |
/* GROUP 2 - STORE */
stl IN($1) | R16 |
"ldy #BASE+1+$1"
"sta (LBl),y"
"txa"
"dey"
"sta (LBl),y"
| | |
stl | |
allocate(R16)
"lda #[$1].h"
"ldx #[$1].l"
"jsr Stl"
| | |
ste | R16 |
"sta $1+1"
"stx $1"
| | |
sil IN($1) | |
allocate(R16)
"ldy #BASE+$1"
"lda (LBl),y"
"tax"
"iny"
"lda (LBl),y"
"jsr Sti"
| | |
sil | |
allocate(R16)
"lda #[$1].h"
"ldx #[$1].l"
"jsr Lol"
"jsr Sti"
| | |
stf $1==0 | R16 |
"jsr Sti"
| | |
stf | |
allocate(R16)
"lda #[$1].h"
"ldx #[$1].l"
"jsr Adi2"
"jsr Sti"
| | |
sti $1==1 | R16 |
"jsr Sti1"
| | |
sti $1==2 | R16 |
"jsr Sti"
| | |
sti $1==4 | R16 |
"jsr Sdi"
| | |
sti D | R16 |
"ldy #[$1].h"
"sty NBYTES+1"
"ldy #[$1].l"
"jsr Stil"
| | |
sts $1==2 | R16 |
"jsr Sts"
| | |
sdl IND($1) | R16 |
"ldy #BASE+$1"
"pha"
"txa"
"sta (LBl),y"
"iny"
"pla"
"sta (LBl),y"
"jsr Pop"
"iny"
"pha"
"txa"
"sta (LBl),y"
"iny"
"pla"
"sta (LBl),y"
| | |
sdl | |
allocate(R16)
"lda #[$1].h"
"ldx #[$1].l"
"jsr Locaddr"
"jsr Sdo"
| | |
sde | R16 |
"sta $1+1"
"stx $1"
"jsr Pop"
"sta $1+3"
"stx $1+2"
| | |
sdf $1==0 | R16 |
"jsr Sdi"
| | |
sdf | |
allocate(R16)
"lda #[$1].h"
"ldx #[$1].l"
"jsr Adi2"
"jsr Sdi"
| | |
/* GROUP 3 - INTEGER ARITHMETIC */
loc lol adi (IN($2) && $3==2) | |
allocate(R16)
"ldy #BASE+$2"
"clc"
"lda #[$1].l"
"adc (LBl),y"
"tax"
"iny"
"lda #[$1].h"
"adc (LBl),y"
| %[a] | |
lol loc adi | | | | loc $2 lol $1 adi $3 |
lol lol adi (IN($1) && IN($2) && $3==2) | |
allocate(R16)
"ldy #BASE+$1+1"
"lda (LBl),y"
"pha"
"dey"
"lda (LBl),y"
"ldy #BASE+$2"
"clc"
"adc (LBl),y"
"tax"
"iny"
"pla"
"adc (LBl),y"
| %[a] | |
lol loe adi (IN($1) && $3==2) | |
allocate(R16)
"ldy #BASE+$1"
"clc"
"lda (LBl),y"
"adc $2"
"tax"
"iny"
"lda (LBl),y"
"adc $2+1"
| %[a] | |
loe lol adi | | | | lol $2 loe $1 adi $3 |
loe loe adi $3==2 | |
allocate(R16)
"clc"
"lda $1"
"adc $2"
"tax"
"lda $1+1"
"adc $2+1"
| %[a] | |
loc loe adi $3==2 | |
allocate(R16)
"clc"
"lda #[$1].l"
"adc $2"
"tax"
"lda #[$1].h"
"adc $2+1"
| %[a] | |
loe loc adi | | | | loc $2 loe $1 adi $3 |
ldl adi IND($1) && $2==2 | |
allocate(R16)
"ldy #BASE+$1"
"clc"
"lda (LBl),y"
"iny"
"iny"
"adc (LBl),y"
"tax"
"dey"
"lda (LBl),y"
"iny"
"iny"
"adc (LBl),y"
| %[a] | |
lde adi $2==2 | |
allocate(R16)
"clc"
"lda $1"
"adc $1+2"
"tax"
"lda $1+1"
"adc $1+3"
| %[a] | |
loc adi $2==2 | R16 |
"pha"
"txa"
"clc"
"adc #[$1].l"
"tax"
"pla"
"adc #[$1].h"
| %[1] | |
lol adi IN($1) && $2==2 | R16 |
"pha"
"ldy #BASE+$1"
"clc"
"txa"
"adc (LBl),y"
"tax"
"iny"
"pla"
"adc (LBl),y"
| %[1] | |
loe adi $2==2 | R16 |
"pha"
"clc"
"txa"
"adc $1"
"tax"
"pla"
"adc $1+1"
| %[1] | |
lol lol adi IN($1) && !IN($2) && $3==2
| | | | lol $2 lol $1 adi $3 |
adi $1==2 | R16 |
"jsr Adi2"
| %[1] | |
adi $1==4 | |
allocate(R16)
"jsr Adi4"
| | |
adi ND | R16 |
"jsr Test2"
"jsr Adi2"
| %[1] | |
loc lol sbi (IN($2) && $3==2) | |
allocate(R16)
"ldy #BASE+$1"
"sec"
"lda #[$1].l"
"sbc (LBl),y"
"tax"
"iny"
"lda #[$1].h"
"sbc (LBl),y"
| %[a] | |
lol loc sbi | | | | lol $1 loc 0-$2 adi $3 |
lol lol sbi (IN($1) && IN($2) && $3==2) | |
allocate(R16)
"ldy #BASE+$1+1"
"lda (LBl),y"
"pha"
"dey"
"lda (LBl),y"
"ldy #BASE+$2"
"sec"
"sbc (LBl),y"
"tax"
"iny"
"pla"
"sbc (LBl),y"
| %[a] | |
lol loe sbi (IN($1) && $3==2) | |
allocate(R16)
"ldy #BASE+$1"
"sec"
"lda (LBl),y"
"sbc $2"
"tax"
"iny"
"lda (LBl),y"
"sbc $2+1"
| %[a] | |
loe lol sbi (IN($2) && $3==2) | |
allocate(R16)
"ldy #BASE+$1"
"sec"
"lda $2"
"sbc (LBl),y"
"tax"
"iny"
"lda $2+1"
"sbc (LBl),y"
| %[a] | |
loe loe sbi $3==2 | |
allocate(R16)
"sec"
"lda $1"
"sbc $2"
"tax"
"lda $1+1"
"sbc $2+1"
| %[a] | |
loc loe sbi $3==2 | |
allocate(R16)
"sec"
"lda #[$1].l"
"sbc $2"
"tax"
"lda #[$1].h"
"sbc $2+1"
| %[a] | |
loe loc sbi | | | | loe $1 loc 0-$2 adi $3 |
ldl sbi IND($1) && $2==2 | |
allocate(R16)
"ldy #BASE+$1+2"
"sec"
"lda (LBl),y"
"dey"
"dey"
"sbc (LBl),y"
"tax"
"ldy #BASE+$1+3"
"lda (LBl),y"
"dey"
"dey"
"sbc (LBl),y"
| %[a] | |
lde sbi $2==2 | |
allocate(R16)
"sec"
"lda $1+2"
"sbc $1"
"tax"
"lda $1+3"
"sbc $1"
| %[a] | |
loc sbi $2==2 | R16 |
"pha"
"txa"
"sec"
"sbc #[$1].l"
"tax"
"pla"
"sbc #[$1].h"
| %[1] | |
lol sbi IN($1) && $2==2 | R16 |
"pha"
"ldy #BASE+$1"
"sec"
"txa"
"sbc (LBl),y"
"tax"
"iny"
"pla"
"sbc #[$1].h"
| %[1] | |
loe sbi $2==2 | R16 |
"pha"
"sec"
"txa"
"sbc $1"
"tax"
"pla"
"sbc $1+1"
| %[1] | |
sbi $1==2 | R16 |
"jsr Sbi2"
| %[1] | |
sbi $1==4 | |
allocate(R16)
"jsr Sbi4"
| | |
sbi ND | R16 |
"jsr Test2"
"jsr Sbi2"
| %[1] | |
loc lol mli (IN($2) && $3==2) | |
allocate(R16)
"lda #[$1].l"
"sta ARTH"
"lda #[$1].h"
"sta ARTH+1"
"ldy #BASE+$2"
"lda (LBl),y"
"sta ARTH+2"
"iny"
"lda (LBl),y"
"sta ARTH+3"
"jsr Mlinp"
| %[a] | |
lol loc mli | | | | loc $2 lol $1 mli $3 |
lol lol mli (IN($1) && IN($2) && $3==2) | |
allocate(R16)
"ldy #BASE+$1"
"lda (LBl),y"
"sta ARTH"
"iny"
"lda (LBl),y"
"sta ARTH+1"
"ldy #BASE+$2"
"lda (LBl),y"
"sta ARTH+2"
"iny"
"lda (LBl),y"
"sta ARTH+3"
"jsr Mlinp"
| %[a] | |
lol loe mli (IN($1) && $3==2) | |
allocate(R16)
"ldy #BASE+$1"
"lda (LBl),y"
"sta ARTH"
"iny"
"lda (LBl),y"
"sta ARTH+1"
"lda $2"
"sta ARTH+2"
"lda $2+1"
"sta ARTH+3"
"jsr Mlinp"
| %[a] | |
loe lol mli (IN($2) && $3==2) | | | | lol $2 loe $1 mli $3 |
loe loe mli $3==2 | |
allocate(R16)
"lda $1"
"sta ARTH"
"lda $1+1"
"sta ARTH+1"
"lda $2"
"sta ARTH+2"
"lda $2+1"
"sta ARTH+3"
"jsr Mlinp"
| %[a] | |
loc loe mli $3==2 | |
allocate(R16)
"lda #[$1].l"
"sta ARTH"
"lda #[$1].h"
"sta ARTH+1"
"lda $2"
"sta ARTH+2"
"lda $2+1"
"sta ARTH+3"
"jsr Mlinp"
| %[a] | |
loe loc mli | | | | loc $2 loe $1 mli $3 |
ldl mli IND($1) && $2==2 | |
allocate(R16)
"ldy #BASE+$1"
"lda (LBl),y"
"sta ARTH"
"iny"
"lda (LBl),y"
"sta ARTH+1"
"iny"
"lda (LBl),y"
"sta ARTH+2"
"iny"
"lda (LBl),y"
"sta ARTH+3"
"jsr Mlinp"
| %[a] | |
lde mli $2==2 | |
allocate(R16)
"lda $1"
"sta ARTH"
"lda $1+1"
"sta ARTH+1"
"lda $1+2"
"sta ARTH+2"
"lda $1+3"
"sta ARTH+3"
"jsr Mlinp"
| %[a] | |
loc mli $2==2 | R16 |
"stx ARTH"
"sta ARTH+1"
"lda #[$1].l"
"sta ARTH+2"
"lda #[$1].h"
"sta ARTH+3"
"jsr Mlinp"
| %[1] | |
lol mli IN($1) && $2==2 | R16 |
"stx ARTH"
"sta ARTH+1"
"ldy #BASE+$1"
"lda (LBl),y"
"sta ARTH+2"
"iny"
"lda (LBl),y"
"sta ARTH+3"
"jsr Mlinp"
| %[1] | |
loe mli $2==2 | R16 |
"stx ARTH"
"sta ARTH+1"
"lda $1"
"sta ARTH+2"
"lda $1+1"
"sta ARTH+3"
"jsr Mlinp"
| %[1] | |
lol lol mli IN($1) && !IN($2) && $3==2
| | | | lol $2 lol $1 mli $3 |
mli $1==2 | R16 |
"jsr Mli2"
| %[1] | |
mli $1==4 | |
allocate(R16)
"jsr Mli4"
| | |
mli ND | R16 |
"jsr Test2"
"jsr Mli2"
| %[1] | |
loc lol dvi (IN($2) && $3==2) | |
allocate(R16)
"ldy #BASE+$2"
"lda (LBl),y"
"sta ARTH"
"iny"
"lda (LBl),y"
"sta ARTH+1"
"lda #[$1].l"
"sta ARTH+2"
"lda #[$1].h"
"sta ARTH+3"
"ldy #1"
"sty UNSIGN"
"jsr Div"
| %[a] | |
lol loc dvi (IN($1) && $3==2) | |
allocate(R16)
"lda #[$2].l"
"sta ARTH"
"lda #[$2].h"
"sta ARTH+1"
"ldy #BASE+$1"
"lda (LBl),y"
"sta ARTH+2"
"iny"
"lda (LBl),y"
"sta ARTH+3"
"ldy #1"
"sty UNSIGN"
"jsr Div"
| %[a] | |
lol lol dvi (IN($1) && IN($2) && $3==2) | |
allocate(R16)
"ldy #BASE+$2"
"lda (LBl),y"
"sta ARTH"
"iny"
"lda (LBl),y"
"sta ARTH+1"
"ldy #BASE+$1"
"lda (LBl),y"
"sta ARTH+2"
"iny"
"lda (LBl),y"
"sta ARTH+3"
"ldy #1"
"sty UNSIGN"
"jsr Div"
| %[a] | |
lol loe dvi (IN($1) && $3==2) | |
allocate(R16)
"ldy #BASE+$1"
"lda (LBl),y"
"sta ARTH+2"
"iny"
"lda (LBl),y"
"sta ARTH+3"
"lda $2"
"sta ARTH"
"lda $2+1"
"sta ARTH+1"
"ldy #1"
"sty UNSIGN"
"jsr Div"
| %[a] | |
loe lol dvi (IN($2) && $3==2) | |
allocate(R16)
"ldy #BASE+$2"
"lda (LBl),y"
"sta ARTH"
"iny"
"lda (LBl),y"
"sta ARTH+1"
"lda $2"
"sta ARTH+2"
"lda $2+1"
"sta ARTH+3"
"ldy #1"
"sty UNSIGN"
"jsr Div"
| %[a] | |
loe loe dvi $3==2 | |
allocate(R16)
"lda $2"
"sta ARTH"
"lda $2+1"
"sta ARTH+1"
"lda $1"
"sta ARTH+2"
"lda $1+1"
"sta ARTH+3"
"ldy #1"
"sty UNSIGN"
"jsr Div"
| %[a] | |
loc loe dvi $3==2 | |
allocate(R16)
"lda #[$1].l"
"sta ARTH+2"
"lda #[$1].h"
"sta ARTH+3"
"lda $2"
"sta ARTH"
"lda $2+1"
"sta ARTH+1"
"ldy #1"
"sty UNSIGN"
"jsr Div"
| %[a] | |
loe loc dvi $3==2 | |
allocate(R16)
"lda #[$2].l"
"sta ARTH"
"lda #[$2].h"
"sta ARTH+1"
"lda $1"
"sta ARTH+2"
"lda $1+1"
"sta ARTH+3"
"ldy #1"
"sty UNSIGN"
"jsr Div"
| %[a] | |
ldl dvi IND($1) && $2==2 | |
allocate(R16)
"ldy #BASE+$1"
"lda (LBl),y"
"sta ARTH"
"iny"
"lda (LBl),y"
"sta ARTH+1"
"iny"
"lda (LBl),y"
"sta ARTH+2"
"iny"
"lda (LBl),y"
"sta ARTH+3"
"ldy #1"
"sty UNSIGN"
"jsr Div"
| %[a] | |
lde dvi $2==2 | |
allocate(R16)
"lda $1"
"sta ARTH"
"lda $1+1"
"sta ARTH+1"
"lda $1+2"
"sta ARTH+2"
"lda $1+3"
"sta ARTH+3"
"ldy #1"
"sty UNSIGN"
"jsr Div"
| %[a] | |
loc dvi $2==2 | R16 |
"stx ARTH+2"
"sta ARTH+3"
"lda #[$1].l"
"sta ARTH"
"lda #[$1].h"
"sta ARTH+1"
"ldy #1"
"sty UNSIGN"
"jsr Div"
| %[1] | |
lol dvi IN($1) && $2==2 | R16 |
"stx ARTH+2"
"sta ARTH+3"
"ldy #BASE+$1"
"lda (LBl),y"
"sta ARTH"
"iny"
"lda (LBl),y"
"sta ARTH+1"
"ldy #1"
"sty UNSIGN"
"jsr Div"
| %[1] | |
loe dvi $2==2 | R16 |
"stx ARTH+2"
"sta ARTH+3"
"lda $1"
"sta ARTH"
"lda $1+1"
"sta ARTH+1"
"ldy #1"
"sty UNSIGN"
"jsr Div"
| %[1] | |
dvi $1==2 | R16 |
"jsr Dvi2"
| %[1] | |
dvi $1==4 | |
allocate(R16)
"jsr Dvi4"
| | |
dvi ND | R16 |
"jsr Test2"
"jsr Dvi2"
| %[1] | |
rmi $1==2 | R16 |
"jsr Rmi2"
| %[1] | |
rmi $1==4 | |
allocate(R16)
"jsr Rmi4"
| | |
rmi ND | R16 |
"jsr Test2"
"jsr Rmi2"
| %[1] | |
ngi $1==2 | R16 |
"jsr Ngi2"
| %[1] | |
ngi $1==4 | |
allocate(R16)
"lda SP+1"
"ldx SP+2"
"jsr Ngi4"
| | |
ngi ND | R16 |
"jsr Test2"
"jsr Ngi2"
| %[1] | |
sli $1==2 | R16 |
"jsr Sli2"
| %[1] | |
sli $1==4 | R16 |
"jsr Sli4"
| | |
sli ND | R16 |
"jsr Test2"
"jsr Sli2"
| %[1] | |
sri $1==2 | R16 |
"jsr Sri2"
| %[1] | |
sri $1==4 | R16 |
"jsr Sri4"
| | |
sri ND | R16 |
"jsr Test2"
"jsr Sri2"
| %[1] | |
/* GROUP 4 - UNSIGNED ARITHMETIC */
loc lol adu | | | | loc $1 lol $2 adi $3 |
lol loc adu | | | | lol $1 loc $2 adi $3 |
lol lol adu | | | | lol $1 lol $2 adi $3 |
lol loe adu | | | | lol $1 loe $2 adi $3 |
loe lol adu | | | | loe $1 lol $2 adi $3 |
loe loe adu | | | | loe $1 loe $2 adi $3 |
loc loe adu | | | | loc $1 loe $2 adi $3 |
loe loc adu | | | | loe $1 loc $2 adi $3 |
ldl adu | | | | ldl $1 adi $2 |
lde adu | | | | lde $1 adi $2 |
loc adu | | | | loc $1 adi $2 |
lol adu | | | | lol $1 adi $2 |
loe adu | | | | loe $1 adi $2 |
adu | | | | adi $1 |
loc lol sbu | | | | loc $1 lol $2 sbi $3 |
lol loc sbu | | | | lol $1 loc $2 sbi $3 |
lol lol sbu | | | | lol $1 lol $2 sbi $3 |
lol loe sbu | | | | lol $1 loe $2 sbi $3 |
loe lol sbu | | | | loe $1 lol $2 sbi $3 |
loe loe sbu | | | | loe $1 loe $2 sbi $3 |
loc loe sbu | | | | loc $1 loe $2 sbi $3 |
loe loc sbu | | | | loe $1 loc $2 sbi $3 |
ldl sbu | | | | ldl $1 sbi $2 |
lde sbu | | | | lde $1 sbi $2 |
loc sbu | | | | loc $1 sbi $2 |
lol sbu | | | | lol $1 sbi $2 |
loe sbu | | | | loe $1 sbi $2 |
sbu | | | | sbi $1 |
loc lol mlu (IN($2) && $3==2) | |
allocate(R16)
"lda #[$1].l"
"sta ARTH"
"lda #[$1].h"
"sta ARTH+1"
"ldy #BASE+$2"
"lda (LBl),y"
"sta ARTH+2"
"iny"
"lda (LBl),y"
"sta ARTH+3"
"ldy #0"
"sty UNSIGN"
"jsr Mul"
| %[a] | |
lol loc mlu | | | | loc $2 lol $1 mlu $3 |
lol lol mlu (IN($1) && IN($2) && $3==2) | |
allocate(R16)
"ldy #BASE+$1"
"lda (LBl),y"
"sta ARTH"
"iny"
"lda (LBl),y"
"sta ARTH+1"
"ldy #BASE+$2"
"lda (LBl),y"
"sta ARTH+2"
"iny"
"lda (LBl),y"
"sta ARTH+3"
"ldy #0"
"sty UNSIGN"
"jsr Mul"
| %[a] | |
lol loe mlu (IN($1) && $3==2) | |
allocate(R16)
"ldy #BASE+$1"
"lda (LBl),y"
"sta ARTH"
"iny"
"lda (LBl),y"
"sta ARTH+1"
"lda $2"
"sta ARTH+2"
"lda $2+1"
"sta ARTH+3"
"ldy #0"
"sty UNSIGN"
"jsr Mul"
| %[a] | |
loe lol mlu (IN($2) && $3==2) | | | | lol $2 loe $1 mlu $3 |
loe loe mlu $3==2 | |
allocate(R16)
"lda $1"
"sta ARTH"
"lda $1+1"
"sta ARTH+1"
"lda $2"
"sta ARTH+2"
"lda $2+1"
"sta ARTH+3"
"ldy #0"
"sty UNSIGN"
"jsr Mul"
| %[a] | |
loc loe mlu $3==2 | |
allocate(R16)
"lda #[$1].l"
"sta ARTH"
"lda #[$1].h"
"sta ARTH+1"
"lda $2"
"sta ARTH+2"
"lda $2+1"
"sta ARTH+3"
"ldy #0"
"sty UNSIGN"
"jsr Mul"
| %[a] | |
loe loc mlu | | | | loc $2 loe $1 mlu $3 |
ldl mlu IND($1) && $2==2 | |
allocate(R16)
"ldy #BASE+$1"
"lda (LBl),y"
"sta ARTH"
"iny"
"lda (LBl),y"
"sta ARTH+1"
"iny"
"lda (LBl),y"
"sta ARTH+2"
"iny"
"lda (LBl),y"
"sta ARTH+3"
"ldy #0"
"sty UNSIGN"
"jsr Mul"
| %[a] | |
lde mlu $2==2 | |
allocate(R16)
"lda $1"
"sta ARTH"
"lda $1+1"
"sta ARTH+1"
"lda $1+2"
"sta ARTH+2"
"lda $1+3"
"sta ARTH+3"
"ldy #0"
"sty UNSIGN"
"jsr Mul"
| %[a] | |
loc mlu $2==2 | R16 |
"stx ARTH"
"sta ARTH+1"
"lda #[$1].l"
"sta ARTH+2"
"lda #[$1].h"
"sta ARTH+3"
"ldy #0"
"sty UNSIGN"
"jsr Mul"
| %[1] | |
lol mlu IN($1) && $2==2 | R16 |
"stx ARTH"
"sta ARTH+1"
"ldy #BASE+$1"
"lda (LBl),y"
"sta ARTH+2"
"iny"
"lda (LBl),y"
"sta ARTH+3"
"ldy #0"
"sty UNSIGN"
"jsr Mul"
| %[1] | |
loe mlu $2==2 | R16 |
"stx ARTH"
"sta ARTH+1"
"lda $1"
"sta ARTH+2"
"lda $1+1"
"sta ARTH+3"
"ldy #0"
"sty UNSIGN"
"jsr Mul"
| %[1] | |
lol lol mlu IN($1) && !IN($2) && $3==2
| | | | lol $2 lol $1 mlu $3 |
mlu $1==2 | R16 |
"jsr Mlu2"
| %[1] | |
mlu $1==4 | |
allocate(R16)
"jsr Mlu4"
| | |
mlu ND | R16 |
"jsr Test2"
"jsr Mlu2"
| %[1] | |
loc lol dvu (IN($2) && $3==2) | |
allocate(R16)
"ldy #BASE+$2"
"lda (LBl),y"
"sta ARTH"
"iny"
"lda (LBl),y"
"sta ARTH+1"
"lda #[$1].l"
"sta ARTH+2"
"lda #[$1].h"
"sta ARTH+3"
"ldy #0"
"sty UNSIGN"
"jsr Duv"
| %[a] | |
lol loc dvu (IN($1) && $3==2) | |
allocate(R16)
"lda #[$2].l"
"sta ARTH"
"lda #[$2].h"
"sta ARTH+1"
"ldy #BASE+$1"
"lda (LBl),y"
"sta ARTH+2"
"iny"
"lda (LBl),y"
"sta ARTH+3"
"ldy #0"
"sty UNSIGN"
"jsr Duv"
| %[a] | |
lol lol dvu (IN($1) && IN($2) && $3==2) | |
allocate(R16)
"ldy #BASE+$2"
"lda (LBl),y"
"sta ARTH"
"iny"
"lda (LBl),y"
"sta ARTH+1"
"ldy #BASE+$1"
"lda (LBl),y"
"sta ARTH+2"
"iny"
"lda (LBl),y"
"sta ARTH+3"
"ldy #0"
"sty UNSIGN"
"jsr Duv"
| %[a] | |
lol loe dvu (IN($1) && $3==2) | |
allocate(R16)
"ldy #BASE+$1"
"lda (LBl),y"
"sta ARTH+2"
"iny"
"lda (LBl),y"
"sta ARTH+3"
"lda $2"
"sta ARTH"
"lda $2+1"
"sta ARTH+1"
"ldy #0"
"sty UNSIGN"
"jsr Duv"
| %[a] | |
loe lol dvu (IN($2) && $3==2) | |
allocate(R16)
"ldy #BASE+$2"
"lda (LBl),y"
"sta ARTH"
"iny"
"lda (LBl),y"
"sta ARTH+1"
"lda $2"
"sta ARTH+2"
"lda $2+1"
"sta ARTH+3"
"ldy #0"
"sty UNSIGN"
"jsr Duv"
| %[a] | |
loe loe dvu $3==2 | |
allocate(R16)
"lda $2"
"sta ARTH"
"lda $2+1"
"sta ARTH+1"
"lda $1"
"sta ARTH+2"
"lda $1+1"
"sta ARTH+3"
"ldy #0"
"sty UNSIGN"
"jsr Duv"
| %[a] | |
loc loe dvu $3==2 | |
allocate(R16)
"lda #[$1].l"
"sta ARTH+2"
"lda #[$1].h"
"sta ARTH+3"
"lda $2"
"sta ARTH"
"lda $2+1"
"sta ARTH+1"
"ldy #0"
"sty UNSIGN"
"jsr Duv"
| %[a] | |
loe loc dvu $3==2 | |
allocate(R16)
"lda #[$2].l"
"sta ARTH"
"lda #[$2].h"
"sta ARTH+1"
"lda $1"
"sta ARTH+2"
"lda $1+1"
"sta ARTH+3"
"ldy #0"
"sty UNSIGN"
"jsr Duv"
| %[a] | |
ldl dvu IND($1) && $2==2 | |
allocate(R16)
"ldy #BASE+$1"
"lda (LBl),y"
"sta ARTH"
"iny"
"lda (LBl),y"
"sta ARTH+1"
"iny"
"lda (LBl),y"
"sta ARTH+2"
"iny"
"lda (LBl),y"
"sta ARTH+3"
"ldy #0"
"sty UNSIGN"
"jsr Duv"
| %[a] | |
lde dvu $2==2 | |
allocate(R16)
"lda $1"
"sta ARTH"
"lda $1+1"
"sta ARTH+1"
"lda $1+2"
"sta ARTH+2"
"lda $1+3"
"sta ARTH+3"
"ldy #0"
"sty UNSIGN"
"jsr Duv"
| %[a] | |
loc dvu $2==2 | R16 |
"stx ARTH+2"
"sta ARTH+3"
"lda #[$1].l"
"sta ARTH"
"lda #[$1].h"
"sta ARTH+1"
"ldy #0"
"sty UNSIGN"
"jsr Duv"
| %[1] | |
lol dvu IN($1) && $2==2 | R16 |
"stx ARTH+2"
"sta ARTH+3"
"ldy #BASE+$1"
"lda (LBl),y"
"sta ARTH"
"iny"
"lda (LBl),y"
"sta ARTH+1"
"ldy #0"
"sty UNSIGN"
"jsr Duv"
| %[1] | |
loe dvu $2==2 | R16 |
"stx ARTH+2"
"sta ARTH+3"
"lda $1"
"sta ARTH"
"lda $1+1"
"sta ARTH+1"
"ldy #0"
"sty UNSIGN"
"jsr Duv"
| %[1] | |
dvu $1==2 | R16 |
"jsr Dvu2"
| %[1] | |
dvu $1==4 | |
allocate(R16)
"jsr Dvu4"
| | |
dvu ND | R16 |
"jsr Test2"
"jsr Dvu2"
| %[1] | |
rmu $1==2 | R16 |
"jsr Rmu2"
| %[1] | |
rmu $1==4 | |
allocate(R16)
"jsr Rmu4"
| | |
slu | | | | sli $1 |
sru $1==2 | R16 |
"jsr Sru2"
| %[1] | |
sru $1==4 | R16 |
"jsr Sru4"
| | |
sru ND | R16 |
"jsr Test2"
"jsr Sru2"
| %[1] | |
/* GROUP 6 - POINTER ARITHMETIC */
adp $1==0 | | | | |
adp | | | | loc $1 adi 2 |
ads $1==2 | R16 |
"jsr Adi2"
| %[1] | |
ads ND | R16 |
"jsr Test2"
"jsr Adi2"
| %[1] | |
sbs $1==2 | R16 |
"jsr Sbi2"
| %[1] | |
sbs ND | R16 |
"jsr Test2"
"jsr Sbi2"
| %[1] | |
/* GROUP 7 INCREMENT/DECREMENT/ZERO */
inc | R16 |
"inx"
"bne 1f"
"clc"
"adc #1\n1:"
| %[1] | |
inl IN($1) | |
allocate(R16)
"ldy #BASE+$1"
"clc"
"lda (LBl),y"
"adc #1"
"sta (LBl),y"
"bcc 1f"
"iny"
"lda (LBl),y"
"adc #0"
"sta (LBl),y\n1:"
| | |
inl D | |
allocate(R16)
"lda #[$1].h"
"ldx #[$1].l"
"jsr Lol"
"inx"
"bne 1f"
"clc"
"adc #1"
"1: jsr Stii"
| | |
ine | |
"inc $1"
"bne 1f"
"inc $1+1\n1:"
| | |
dec | R16 |
"cpx #0"
"bne 1f"
"sec"
"sbc #1"
"1: dex"
| %[1] | |
del IN($1) | |
allocate(R16)
"ldy #BASE+$1"
"sec"
"lda (LBl),y"
"sbc #1"
"sta (LBl),y"
"bcs 1f"
"iny"
"lda (LBl),y"
"sbc #0"
"sta (LBl),y\n1:"
| | |
del | |
allocate(R16)
"lda #[$1].h"
"ldx #[$1].l"
"jsr Lol"
"cpx #0"
"bne 1f"
"sec"
"sbc #1"
"1: dex"
"jsr Stii"
| | |
dee | |
"ldy $1"
"bne 1f"
"dec $1+1"
"1: dey"
"sty $1"
| | |
zrl IN($1) | |
allocate(R16)
"ldy #BASE+$1"
"lda #0"
"sta (LBl),y"
"iny"
"sta (LBl),y"
| | |
zrl | |
allocate(R16)
"lda #[$1].h"
"ldx #[$1].l"
"jsr Zrl"
| | |
zre | |
"ldy #0"
"sty $1"
"sty $1+1"
| | |
zer $1==2 | |
allocate(R16)
"lda #0"
"tax"
| %[a] | |
zer $1==4 | |
allocate(R16)
"lda #0"
"tax"
"jsr Push"
| %[a] | |
zer $1>0 && $1<=256 | |
allocate(R16)
"ldy #$1-1"
"jsr Zer"
| | |
/* GROUP 8 - CONVERT (stack: source, source size, dest. size (top)) */
loc loc cii $1==1 && $2==2 | R16 |
"txa"
"bpl 1f"
"lda #0FFh"
"bne 2f"
"1: lda #0\n2:"
| %[1] | |
cii | R16 |
"jsr Cii"
| | |
cui | | | | cii |
ciu | | | | cii |
cuu | | | | asp 4 |
/* GROUP 9 - LOGICAL */
and $1==2 | R16 |
"sta ARTH+1"
"stx ARTH"
"jsr Pop"
"and ARTH+1"
"pha"
"txa"
"and ARTH"
"tax"
"pla"
| %[1] | |
and $1<=254 | |
allocate(R16)
"ldy #[$1].l"
"jsr And"
| | |
and ND | R16 |
"jsr TestFFh"
"jsr Pop"
"iny"
"jsr And"
| | |
ior $1==2 | R16 |
"sta ARTH+1"
"stx ARTH"
"jsr Pop"
"ora ARTH+1"
"pha"
"txa"
"ora ARTH"
"tax"
"pla"
| %[1] | |
ior $1<=254 | |
allocate(R16)
"ldy #[$1].l"
"jsr Ior"
| | |
ior ND | R16 |
"jsr TestFFh"
"jsr Pop"
"iny"
"jsr Ior"
| | |
xor $1==2 | R16 |
"sta ARTH+1"
"stx ARTH"
"jsr Pop"
"eor ARTH+1"
"pha"
"txa"
"eor ARTH"
"tax"
"pla"
| %[1] | |
xor $1<=254 | |
allocate(R16)
"ldy #[$1].l"
"jsr Xor"
| | |
xor ND | R16 |
"jsr TestFFh"
"jsr Pop"
"iny"
"jsr Xor"
| | |
com $1==2 | R16 |
"eor #0FFh"
"pha"
"txa"
"eor #0FFh"
"tax"
"pla"
| %[1] | |
com $1<=254 | |
allocate(R16)
"ldy #[$1].l"
"jsr Com"
| | |
com ND | R16 |
"jsr TestFFh"
"jsr Pop"
"iny"
"jsr Com"
| | |
rol $1==2 | R16 |
"jsr Rol"
| %[1] | |
rol $1==4 | R16 |
"jsr Rol4"
| | |
rol ND | R16 |
"jsr Test2"
"jsr Rolw"
| %[1] | |
ror $1==2 | R16 |
"jsr Ror"
| %[1] | |
ror $1==4 | R16 |
"jsr Ror4"
| | |
ror ND | R16 |
"jsr Test2"
"jsr Rorw"
| %[1] | |
/* GROUP 10 - SETS */
loc inn $1<0 && $2==2 | R16 |
"lda #0"
"tax"
| %[1] | |
loc inn $2==2 && $1==0 | R16 |
"txa"
"and #1"
"tax"
"lda #0"
| %[1] | |
loc inn $2==2 && $1>0 && $1<16 | R16 |
"ldy #$1"
"stx ARTH"
"1: lsr a"
"ror ARTH"
"dey"
"bne 1b"
"lda ARTH"
"and #1"
"tax"
"lda #0"
| %[1] | |
loc inn zeq $1>0 && $1<16 && $2==2 | R16 |
"ldy #$1+1"
"stx ARTH"
"1: lsr a"
"ror ARTH"
"dey"
"bne 1b"
"bcc $1"
| | |
loc inn zne $1>0 && $1<16 && $2==2 | R16 |
"ldy #$1+1"
"stx ARTH"
"1: lsr a"
"ror ARTH"
"dey"
"bne 1b"
"bcs $1"
| | |
inn $1==2 | R16 |
"txa"
"tay"
"jsr Pop"
"stx ARTH"
"1: lsr a"
"ror ARTH"
"dey"
"bne 1b"
"lda ARTH"
"and #1"
"tax"
"lda #0"
| %[1] | |
inn zeq $1==2 | R16 |
"txa"
"tay"
"jsr Pop"
"stx ARTH"
"1: lsr a"
"ror ARTH"
"dey"
"bpl 1b"
"lda ARTH"
"bcc $2"
| %[1] | |
inn zne $1==2 | R16 |
"txa"
"tay"
"jsr Pop"
"stx ARTH"
"1: lsr a"
"ror ARTH"
"dey"
"bpl 1b"
"bcs $2"
| %[1] | |
inn $1<=256 | R16 |
"ldy #$1-1"
"jsr Inn"
| %[1] | |
inn ND | R16 |
"jsr TestFFh"
"jsr Pop"
"jsr Inn"
| %[1] | |
loc set $2==2 && $1>=0 && $1<16 | |
allocate(R16)
"ldy #$1"
"lda #0"
"sta ARTH"
"sec"
"1: rol ARTH"
"rol a"
"dey"
"bpl 1b"
"ldx ARTH"
| %[a] | |
set $1==2 | R16 |
"txa"
"tay"
"lda #0"
"sta ARTH"
"sec"
"1: rol ARTH"
"rol a"
"bpl 1b"
"ldx ARTH"
| %[1] | |
set $1<=256 | R16 |
"ldy #$1-1"
"jsr Set"
| | |
set ND | R16 |
"jsr TestFFh"
"jsr Pop"
"jsr Set"
| | |
/* GROUP 11 - ARRAY */
lae lar defined(rom(1,3)) | | | | lae $1 aar $2 loi rom(1,3) |
lar $1==2 | R16 |
"jsr Lar"
| | |
lar ND | R16 |
"jsr Test2"
"jsr Lar"
| | |
lae sar defined(rom(1,3)) | | | | lae $1 aar $2 sti rom(1,3) |
sar $1==2 | R16 |
"jsr Sar"
| | |
sar ND | R16 |
"jsr Test2"
"jsr Sar"
| | |
lae aar $2==2 && rom(1,3)==1 && rom(1,1)==0 | | | | adi 2 |
lae aar $2==2 && rom(1,3)==1 && rom(1,1)!=0 | |
| | adi 2 adp 0-rom(1,1) |
lae aar $2==2 && rom(1,3)==2 && rom(1,1)==0 | R16 |
"pha"
"txa"
"asl a"
"tax"
"pla"
"rol a"
| %[1] | adi 2 |
lae aar $2==2 && rom(1,3)==2 && rom(1,1)!=0 | R16 |
"pha"
"txa"
"asl a"
"tax"
"pla"
"rol a"
| %[1] | adi 2 adp (0-rom(1,1))*2 |
lae aar $2==2 && rom(1,3)>2 && rom(1,1)==0 | |
| | loc rom(1,3) mli 2 adi 2 |
lae aar $2==2 && rom(1,3)>2 && rom(1,1)!=0 | |
| | loc rom(1,3) mli 2 adi 2 adp (0-rom(1,1))*rom(1,3) |
aar $1==2 | R16 |
"jsr Aar"
| %[1] | |
aar ND | R16 |
"jsr Test2"
"jsr Aar"
| %[1] | |
/* GROUP 12 - COMPARE */
cmi $1==2 | R16 |
"jsr Cmi"
| %[1] | |
cmi $1==4 | |
allocate(R16)
"jsr Cmi4"
| %[a] | |
cmi ND | R16 |
"jsr Test2"
"jsr Cmi"
| %[1] | |
cmu $1==2 | R16 |
"jsr Cmu2"
| %[1] | |
cmu $1==4 | |
allocate(R16)
"jsr Cmu4"
| %[a] | |
cmu ND | R16 |
"jsr Test2"
"jsr Cmu"
| | |
cmp | |
| | cmu 2 |
cms $1==2 | |
allocate(R16)
"ldy #2"
"jsr Cms"
| %[a] | |
cms $1==4 | |
allocate(R16)
"ldy #4"
"jsr Cms"
| %[a] | |
cms ND | R16 |
"jsr TestFFh"
"iny"
"jsr Cms"
| %[1] | |
tlt | R16 |
"jsr Tlt"
| %[1] | |
tle | R16 |
"jsr Tle"
| %[1] | |
teq | R16 |
"jsr Teq"
| %[1] | |
tne | R16 |
"jsr Tne"
| %[1] | |
tge | R16 |
"jsr Tge"
| %[1] | |
tgt | R16 |
"jsr Tgt"
| %[1] | |
/* GROUP 13 - BRANCH */
bra | |
remove(ALL)
"jmp $1"
| | |
blt | R16 |
"jsr Sbi2"
"bmi $1"
| | |
ble | R16 |
"jsr Sbi2"
"bmi $1"
"bne 1f"
"txa"
"beq $1\n1:"
| | |
beq | R16 |
"sta BRANCH+1"
"stx BRANCH"
"jsr Pop"
"cmp BRANCH+1"
"bne 1f"
"cpx BRANCH"
"beq $1\n1:"
| | |
bne | R16 |
"sta BRANCH+1"
"stx BRANCH"
"jsr Pop"
"cmp BRANCH+1"
"bne $1"
"cpx BRANCH"
"bne $1"
| | |
bge | R16 |
"jsr Sbi2"
"bpl $1"
| | |
bgt | R16 |
"jsr Sbi2"
"bmi 1f"
"bne $1"
"txa"
"bne $1\n1:"
| | |
cmi zlt $1==2 | | | | blt $2 |
cmp zlt | | | | blt $2 |
zlt | R16 |
"tay"
"bmi $1"
| | |
cmi zle $1==2 | | | | ble $2 |
cmp zle | | | | ble $2 |
zle | R16 |
"tay"
"bmi $1"
"bne 1f"
"txa"
"beq $1\n1:"
| | |
cmi zeq $1==2 | | | | beq $2 |
cmp zeq | | | | beq $2 |
cms zeq $1==2 | | | | beq $2 |
zeq | R16 |
"tay"
"bne 1f"
"txa"
"beq $1\n1:"
| | |
cmi zne $1==2 | | | | bne $2 |
cmp zne | | | | bne $2 |
cms zne $1==2 | | | | bne $2 |
zne | R16 |
"tay"
"bne $1"
"txa"
"bne $1"
| | |
cmi zge $1==2 | | | | bge $2 |
cmp zge | | | | bge $2 |
zge | R16 |
"tay"
"bpl $1"
| | |
cmi zgt $1==2 | | | | bgt $2 |
cmp zgt | | | | bgt $2 |
zgt | R16 |
"tay"
"bmi 1f"
"bne $1"
"txa"
"bne $1\n1:"
| | |
/* GROUP 14 - PROCEDURE CALL */
cai | R16 |
"stx ADDR"
"sta ADDR+1"
"jsr Indir"
| | |
cal | |
remove(ALL)
"jsr $1"
| | |
lfr $1==2 | |
allocate(R16)
"lda #0"
"ldx #RETURN"
"jsr Loi"
| %[a] | |
lfr $1==4 | |
allocate(R16)
"lda #0"
"ldx #RETURN"
"jsr Ldi"
| | |
lfr ret $1==$2 | | | | ret 0 |
asp lfr ret $2==$3 | | | | ret 0 |
ret $1==0 || $1==2 || $1==4 | |
allocate(R16)
"ldy #$1"
"jmp Ret"
| | |
/* GROUP 15 - MISCELLANOUS */
asp | |
allocate(R16)
"lda #[$1].h"
"ldx #[$1].l"
"jsr Asp"
| | |
ass $1==2 | R16 |
"jsr Asp"
| | |
ass ND | R16 |
"jsr Test2"
"jsr Pop"
"jsr Asp"
| | |
blm $1==0 | | | | asp 4 |
blm D | R16 |
"ldy #[[$1].h+1]"
"sty NBYTES+1"
"ldy #[$1].l"
"jsr Blm"
| | |
bls $1==2 | R16 |
"sta NBYTES+1"
"inc NBYTES+1"
"txa"
"tay"
"jsr Pop"
"jsr Blm"
| | |
bls ND | R16 |
"jsr Test2"
"sta NBYTES+1"
"inc NBYTES+1"
"txa"
"tay"
"jsr Pop"
"jsr Blm"
| | |
csa | R16 |
"jmp Csa"
| | |
csb | R16 |
"jmp Csb"
| | |
dch | | | | loi 2 |
dup $1==2 | R16 |
"jsr Push"
| %[1] | |
dup $1<=256 | |
allocate(R16)
"ldy #[$1].l"
"jsr Dup"
| | |
dus $1==2 | R16 |
"jsr TestFFh"
"iny"
"jsr Dup"
| | |
exg $1==2 | R16 |
"jsr Exg2"
| %[1] | |
exg $1<=255 | |
allocate(R16)
"ldy #$1"
"jsr Exg"
| | |
fil | |
"ldy #[$1].l"
"sty hol0+4"
"ldy #[$1].h"
"sty hol0+5"
| | |
gto | |
allocate(R16)
"lda #[$1].h"
"ldx #[$1].l"
"jmp Gto"
| | |
lim | |
allocate(R16)
"ldx IGNMASK"
"lda IGNMASK+1"
| %[a] | |
lin | |
"ldy #[$1].l"
"sty hol0"
"ldy #[$1].h"
"sty hol0+1"
| | |
lni | |
"inc hol0"
"bne 1f"
"inc hol0+1\n1:"
| | |
lor $1==0 | |
allocate(R16)
"ldx LB"
"lda LB+1"
| %[a] | |
lor $1==1 | |
allocate(R16)
"ldx SP+2"
"lda SP+1"
| %[a] | |
lor $1==2 | |
allocate(R16)
"ldx HP"
"lda HP+1"
| %[a] | |
lpb | | | | adp 2 |
mon | R16 |
"jsr Mon"
| %[1] | |
nop | |
allocate(R16)
"jsr Printstack"
| | |
rck | R16 | | | |
rtt | |
remove(ALL)
"jmp Rtt"
| | |
sig | R16 |
"pha"
"txa"
"pha"
"ldx ERRPROC"
"lda ERRPROC+1"
"jsr Push"
"pla"
"sta ERRPROC"
"pla"
"sta ERRPROC+1"
| | |
sim | R16 |
"stx IGNMASK"
"sta IGNMASK+1"
| | |
str $1==0 | R16 |
"stx LB"
"sta LB+1"
"tay"
"sec"
"txa"
"sbc #BASE"
"sta LBl"
"tya"
"sbc #0"
"sta LBl+1"
| | |
str $1==1 | R16 |
"stx SP+2"
"sta SP+1"
| | |
str $1==2 | R16 |
"stx HP"
"sta HP+1"
| | |
trp | R16 |
"jsr Trap"
| | |
lol lal sti $1==$2 && $3==1 | | | | | /* throw away funny C-proc-prolog */
| STACK |
allocate(R16)
"jsr Pop"
| %[a] | |
/* FLOATING POINT
* Every EM floating point instruction is translated
* into a library call. At present, these library
* routines generate an 'Illegal EM instruction' trap.
*/
adf $1==4 | STACK |
"jsr Adf4"
| | |
adf $1==8 | STACK |
"jsr Adf8" | | |
sbf $1==4 | STACK |
"jsr Sbf4"
| | |
sbf $1==8 | STACK |
"jsr Sbf8" | | |
mlf $1==4 | STACK |
"jsr Mlf4"
| | |
mlf $1==8 | STACK |
"jsr Mlf8" | | |
dvf $1==4 | STACK |
"jsr Dvf4"
| | |
dvf $1==8 | STACK |
"jsr Dvf8" | | |
ngf $1==4 | STACK |
"jsr Ngf4"
| | |
ngf $1==8 | STACK |
"jsr Ngf8" | | |
zrf $1==4 | STACK |
"jsr Zrf4"
| | |
zrf $1==8 | STACK |
"jsr Zrf8" | | |
cmf $1==4 | STACK |
"jsr Cmf4"
| | |
cmf $1==8 | STACK |
"jsr Cmf8" | | |
fef $1==4 | STACK |
"jsr Fef4"
| | |
fef $1==8 | STACK |
"jsr Fef8" | | |
fif $1==4 | STACK |
"jsr Fif4"
| | |
fif $1==8 | STACK |
"jsr Fif8" | | |
cfi | STACK |
"jsr Cfi" | | |
cif | STACK |
"jsr Cif" | | |
cuf | STACK |
"jsr Cuf" | | |
cff | STACK |
"jsr Cff" | | |
cfu | STACK |
"jsr Cfu" | | |
lfr $1==8 | STACK |
"jsr Lfr8" | | |
ret $1==8 | STACK |
"jmp Ret8" | | |
/*************\
* M O V E S *
\*************/
MOVES: (AAA,AAA,"nop")
STACKS: (R16, , "jsr Push")
Reference in a new issue View git blame Copy permalink