"$Header$"
/********************************************************************
 ****							         ****
 ****       Z  8 0    B A C K   E N D   T A B L E S              ****
 ****							         ****
 ********************************************************************/



/*
 *  INTEGER SIZE:    16 bits
 *  POINTER SIZE:    16 bits
 */


/* We store LB in the iy index-register, because this results in the
 * cheapest addressing schemes for instruction like lol and stl.
 * For a lol with an argument that is too low (< 0-128) or too high
 * (>= 127) there is an overhead, because the offset cannot be
 * expressed in 8 bits. In these cases we copy the LB to the hl-register,
 * compute the required address and use register indirect mode to do
 * the load. These cases occur rarely (about 11.5 % in C and 5.5 %
 * in Pascal.
 */

EM_WSIZE = 2
EM_PSIZE = 2
EM_BSIZE = 4


/**************************
 ** R E G I S T E R S    **
 **************************/



REGISTERS:
AA   = ("a",1)	REG1, AREG.
BB   = ("b",1)	REG1.
CC   = ("c",1)	REG1.
DD   = ("d",1)	REG1.
EE   = ("e",1)	REG1.
HH   = ("h",1)	REG1.
LL   = ("l",1)	REG1.


BC  = ("bc",2,BB,CC)	REG, GEN_REG, BC_REG, ANY_REG.
DE  = ("de",2,DD,EE)	REG, GEN_REG, DE_REG, ANY_REG.
HL  = ("hl",2,HH,LL)	GEN_REG, HL_REG, ANY_REG.

LB  = ("iy",2)		LOCALBASE.
IX  = ("ix",2)		INDEXREG, IX_REG, ANY_REG.



pseudo0 = ("",2,BC,DE).
pseudo1 = ("",2,HL,IX).
pseudo2 = ("",2,pseudo0,pseudo1).
pseudo3 = ("",2,pseudo2,AA) ALL_REG.


/*****************
 ** T O K E N S **
 *****************/


TOKENS:
IMMEDIATE1	= {INT off;}		1 "%[off]"
IMMEDIATE	= {INT off;}		2 "%[off]"
IREG1		= {REGISTER reg;}	1 "(%[reg])"
INDEXED		= {REGISTER reg;
		   INT off;  }	1 "(%[reg]+%[off])"
EXTENDED	= {STRING off;  }	2 "(%[off])"
LOCAL_ADDR	= {INT off;  }	2
EXTENDED_ADDR   = {STRING off; }	2 "%[off]"



/*************************************
 ** T O K E N E X P R E S S I O N S **
 *************************************/


TOKENEXPRESSIONS:
ANYTOK		= IMMEDIATE + EXTENDED   
ANY1		= REG1	+ IMMEDIATE1 + IREG1 + INDEXED
ANY_ADDR	= EXTENDED_ADDR + LOCAL_ADDR  
ANY		= ANYTOK + ANY_REG + ANY_ADDR
MEM_ALL		= ANY - ANY_REG
REG_SCR		= REG * SCRATCH

ANY_REG_SCR	= ANY_REG * SCRATCH
GEN_REG_SCR	= GEN_REG * SCRATCH
HL_REG_SCR	= HL_REG  * SCRATCH
BC_REG_SCR	= BC_REG  * SCRATCH
DE_REG_SCR	= DE_REG  * SCRATCH
IX_REG_SCR	= IX_REG  * SCRATCH





/*************
 ** C O D E **
 *************/


CODE:


/* G R O U P  I :   L O A D S  */


loc | | |	{IMMEDIATE,$1}	| |
ldc | | |	{IMMEDIATE,highw(1)} {IMMEDIATE,loww(1)} | |
lol sfit($1,8)	| |		allocate(REG)
				move({INDEXED,LB,$1} , %[a.2] )
				move({INDEXED,LB,$1+1} , %[a.1] ) | %[a] | |
lol | |				allocate(HL_REG,REG)
				"push iy"
				"pop %[b]"
				move({IMMEDIATE,$1} , %[a] )
				"add hl,%[b]"
				"ld %[b.2],(hl)"
				"inc hl"
				"ld %[b.1],(hl)"
				erase(HL)
				erase(%[a])	| %[b] | |
ldl $1<126 && $1>0-128 | |	allocate(REG,REG)
				move({INDEXED,LB,$1} , %[a.2])
				move({INDEXED,LB,$1+1},%[a.1])
				move({INDEXED,LB,$1+2},%[b.2])
				move({INDEXED,LB,$1+3},%[b.1]) | %[b] %[a] | |
ldl	| |
				remove(ALL)
				allocate(BC_REG,DE_REG,HL_REG={IMMEDIATE,$1})
				"push iy"
				"pop bc"
				"add hl,bc"
				"ld e,(hl)"	
				"inc hl"
				"ld d,(hl)"
				"inc hl"
				"ld c,(hl)"
				"inc hl"
				"ld b,(hl)"
							| BC  DE | |
loe | | | {EXTENDED,$1} | |
lde | | | {EXTENDED,$1+"+2"} {EXTENDED,$1} | |
lil sfit($1,8) | |		  allocate(HL_REG,REG)
				move({INDEXED,LB,$1} , %[a.2])
				move({INDEXED,LB,$1+1} , %[a.1])
				"ld %[b.2],(hl)"
				"inc hl"
				"ld %[b.1],(hl)"
				erase(HL)
				erase(%[a])	| %[b] | |
lil | | 			  allocate(HL_REG = {IMMEDIATE,$1} , REG)
				"push iy"
				"pop %[b]"
				"add hl,%[b]"
				"ld %[b.2],(hl)"
				"inc hl"
				"ld %[b.1],(hl)"
				"ld h,%[b.1]"
				"ld l,%[b.2]"
				"ld %[b.2],(hl)"
				"inc hl"
				"ld %[b.1],(hl)"
				erase(HL)
				erase(%[a])	| %[b] | |
lof | HL_REG_SCR |	  	allocate(REG = {IMMEDIATE,$1} )
				"add hl,%[a]"
				"ld %[a.2],(hl)"
				"inc hl"
				"ld %[a.1],(hl)"
				erase(HL)
				erase(%[a])	| %[a] | |
... | REG_SCR |	  		allocate(HL_REG = {IMMEDIATE,$1} )
				"add hl,%[1]"
				"ld %[1.2],(hl)"
				"inc hl"
				"ld %[1.1],(hl)"
				erase(HL)
				erase(%[1])	| %[1] | |
ldf | HL_REG_SCR |	  	allocate(REG = {IMMEDIATE,$1} , REG)
				"add hl,%[a]"
				"ld %[a.2],(hl)"
				"inc hl"
				"ld %[a.1],(hl)"
				"inc hl"
				"ld %[b.2],(hl)"
				"inc hl"
				"ld %[b.1],(hl)"
				erase(HL)
				erase(%[a])		| %[b] %[a] | |
... | REG_SCR |		  	allocate(HL_REG = {IMMEDIATE,$1} , REG)
				"add hl,%[1]"
				"ld %[1.2],(hl)"
				"inc hl"
				"ld %[1.1],(hl)"
				"inc hl"
				"ld %[b.2],(hl)"
				"inc hl"
				"ld %[b.1],(hl)"
				erase(HL)
				erase(%[1])		| %[b] %[1] | |
lal | |				remove(ALL)
				allocate(HL_REG, REG = {IMMEDIATE,$1} )
				"push iy"
				"pop hl"
				"add hl,%[b]"
				erase(%[a]) 		 | %[a] | |
lae | | |			{EXTENDED_ADDR,$1}	| |
lxl $1 == 0 |  |		remove(ALL)
				"push iy"
							|  |  |
lxl |  |			remove(ALL)
				allocate(AREG = {IMMEDIATE1,$1} ,
					 HL_REG,BC_REG)
				"push iy"
				"pop %[c]"
				"1:"
				"ld hl,4"
				"add hl,%[c]"
				"ld %[c.2],(hl)"
				"inc hl"
				"ld %[c.1],(hl)"
				"dec a"
				"jr nz,1b"
				"push %[c]"
				erase(AA)		|  | |
lxa $1 == 0 | | | | lxl $1 adp 4 |
lxa $1 == 1 |  |		remove(ALL)
 				allocate(HL_REG,BC_REG)
 				"ld %[b],4"
 				"push iy"
 				"pop hl"
 				"add hl,%[b]"
 				"ld %[b.2],(hl)"
 				"inc hl"
 				"ld %[b.1],(hl)"
 				"ld hl,4"
 				"add hl,%[b]"		| HL | |
lxa $1 > 1 |  |			remove (ANY)
	 			allocate(AREG = {IMMEDIATE1,$1},
 					 HL_REG,BC_REG)
 				"push iy"
 				"pop %[c]"
 				"1:"
 				"ld hl,4"
 				"add hl,%[c]"
 				"ld %[c.2],(hl)"
 				"inc hl"
 				"ld %[c.1],(hl)"
 				"inc hl"
 				"dec a"
 				"jr nz,1b"
 				"ld hl,4"
 				"add hl,%[c]"
 				erase(AA)		| HL | |
dch		| | 		| 			| loi 2 |
loi $1 == 1 | HL_REG |		 allocate(REG = {IMMEDIATE,0} )
				"ld %[a.2],(hl)"
				erase(%[a])		| %[a] | |
...	| REG |			  allocate(REG,AREG)
				move({IREG1,%[1]} , AA)
				move(AA , %[a.2])
				move({IMMEDIATE1,0} , %[a.1])
				erase(AA)			| %[a] | |
loi $1 == 2 | HL_REG_SCR |	 remove(ALL) allocate(REG)
				"ld %[a.2],(hl)"
				"inc hl"
				"ld %[a.1],(hl)"
				erase(%[1])		| %[a] | |
loi $1 == 4 | HL_REG_SCR |	remove(ALL)
				allocate(AREG,REG)
				"ld %[b.2],(hl)"
				"inc hl"
				"ld %[b.1],(hl)"
				"inc hl"
				"ld a,(hl)"
				"inc hl"
				"ld h,(hl)"
				"ld l,a"
				erase(HL)		| HL %[b] | |
loi $1 <= 511 && $1 > 4 |  HL_REG_SCR |
				remove(ALL)
				allocate(AREG,REG)
				move({IMMEDIATE,$1-1} , %[b])
				"add hl,%[b]"
				move({IMMEDIATE1,$1/2} , AA)
				"1:"
				"ld %[b.1],(hl)"
				"dec hl"
				"ld %[b.2],(hl)"
				"dec hl"
				"push %[b]"
				"dec a"
				"jr nz,1b"
				erase(%[a])
				erase(%[b])		| | |
loi $1 > 511 | STACK |		 remove(ALL) allocate(ALL_REG)
				move({IMMEDIATE,$1}, HL)
				"push hl"
				"call .los"
				erase(HL)		| | |
los $1 == 2 | STACK |		 remove(ALL) allocate(ALL_REG)
				"call .los"		| | |
lpi	| | | {EXTENDED_ADDR,$1} | |



/* G R O U P  II :   S T O R E S    */



stl sfit($1,8) | REG + HL_REG |
				remove(ALL)
				move(%[1.2] , {INDEXED,LB,$1} )
				move(%[1.1] , {INDEXED,LB,$1+1} )
									| | |
stl 	| REG |
				remove(ALL)
				allocate(HL_REG = {IMMEDIATE,$1} , REG)
				"push iy"
				"pop %[b]"
				"add hl,%[b]"
				"ld (hl),%[1.2]"
				"inc hl"
				"ld (hl),%[1.1]"
				erase(%[a])		| | |
ste  |  ANY_REG |		remove(EXTENDED,%[off] == $1)
				remove(ALL)
				move(%[1] , {EXTENDED,$1} )	| | |
sil ($1 >= 0-128 && $1 < 127) | REG |
				remove(ALL)
				allocate(HL_REG)
				move({INDEXED,LB,$1} , %[a.2])
				move({INDEXED,LB,$1+1} , %[a.1])
				"ld (hl),%[1.2]"
				"inc hl"
				"ld (hl),%[1.1]"
				erase(%[a])			| | |
sil ($1 < 0-128 || $1 >= 127) | REG |
				remove(ALL)
				allocate(HL_REG,REG)
				"push iy"
				"pop %[b]"
				move({IMMEDIATE,$1} , %[a])
				"add hl,%[b]"
				"ld %[b.2],(hl)"
				"inc hl"
				"ld %[b.1],(hl)"
				"ld h,%[b.1]"
				"ld l,%[b.2]"
				"ld (hl),%[1.2]"
				"inc hl"
				"ld (hl),%[1.1]"
				erase(%[a])			| | |
stf | HL_REG_SCR REG |		remove(ALL)
				allocate(REG = {IMMEDIATE,$1})
				"add hl,%[a]"
				"ld (hl),%[2.2]"
				"inc hl"
				"ld (hl),%[2.1]"
				erase(%[1])			| | |
sti $1 == 1 | HL_REG REG |	remove(ALL)
				"ld (hl),%[2.2]" 		| | |
sti $1 == 2 | HL_REG_SCR REG |	remove(ALL)
				"ld (hl),%[2.2]"
				"inc hl"
				"ld (hl),%[2.1]"
				erase(%[1])			| | |
sti $1 == 4 | HL_REG_SCR REG REG |
				remove(ALL)
				"ld (hl),%[2.2]"
				"inc hl"
				"ld (hl),%[2.1]"
				"inc hl"
				"ld (hl),%[3.2]"
				"inc hl"
				"ld (hl),%[3.1]"
				erase(HL)			| | |
sti $1 <= 511 && $1 > 4 | HL_REG_SCR |
				remove(ALL)
				allocate(AREG,REG)
				move({IMMEDIATE1,$1/2} , AA)
				"1:"
				"pop %[b]"
				"ld (hl),%[b.2]"
				"inc hl"
				"ld (hl),%[b.1]"
				"inc hl"
				"dec a"
				"jr nz,1b"
				erase(AA)
				erase(HL)			| | |
sti $1 > 511 | STACK |		remove(ALL) allocate(ALL_REG)
				move({IMMEDIATE,$1}, HL)
				"push hl"
				"call .sts"
				erase(HL)			| | |
sts $1 == 2 | STACK |		remove(ALL) allocate(ALL_REG)
				"call .sts"			| | |
sdl ($1 >= 0-128 && $1 < 125) | REG REG |
				remove(ALL)
				move(%[1.2] , {INDEXED,LB,$1})
				move(%[1.1] , {INDEXED,LB,$1+1})
				move(%[2.2] , {INDEXED,LB,$1+2})
				move(%[2.1] , {INDEXED,LB,$1+3})	| | |
sdl ($1 < 0-128 || $1 >= 125) | STACK |
				remove(ALL)
				allocate(HL_REG = {IMMEDIATE,$1} ,
					BC_REG,DE_REG,IX_REG,AREG )
				"call .sdl"
				erase(HL)			| | |
sde | ANY_REG ANY_REG |
				remove(ALL)
				move(%[1] , {EXTENDED,$1})
				move(%[2] , {EXTENDED,$1+"+2"})	| | |
sdf | | 			remove(ALL)
				allocate(ALL_REG)
				move({IMMEDIATE,$1},DE)
				"call .sdf"
								| | |



/* G R O U P  III & IV :   I N T E G E R   A R I T H M E T I C  */



adi $1 == 2 | HL_REG_SCR GEN_REG |
				"add hl,%[2]"
				erase(HL) |	HL		| |
...	    | GEN_REG HL_REG_SCR |
				"add hl,%[1]"
				erase(HL) |	HL		| |
adi $1 == 4 | HL_REG_SCR DE_REG_SCR STACK |	  allocate(BC_REG)
				"pop bc"
				"add hl,bc"
				"ex de,hl"
				"pop bc"
				"adc hl,bc"
				erase(DE)
				erase(HL)	| HL DE | |
sbi $1 == 2 | GEN_REG HL_REG_SCR |
				"or a"
				"sbc hl,%[1]"
				erase(HL)	|	HL	| |
sbi $1 == 4 | BC_REG_SCR DE_REG_SCR STACK |
				allocate(HL_REG)
				"or a"
				"pop hl"
				"sbc hl,bc"  /* least sign. */
				"ex (sp),hl"
				"sbc hl,de"
				"pop de"
				erase(DE)
				erase(HL)	| HL DE 	| |
mli $1 == 2 | DE_REG_SCR  BC_REG  STACK |
				allocate(HL_REG,IX_REG,AREG)
				"call .mli2"
				erase(DE)	| HL		| |
mli $1 == 4 | STACK |		  allocate(ALL_REG)
				"call .mli4"			| | |
dvi $1 == 2 | BC_REG_SCR  DE_REG_SCR  STACK |
				  allocate(HL_REG,IX_REG,AREG)
				"call .dvi2"
				"push de"
				erase(BC)
				erase(DE)	|		| |
dvi $1 == 4 | STACK |		  allocate(ALL_REG)
				"call .dvi4"	| | |
dvu $1 == 2 | BC_REG_SCR  DE_REG_SCR  STACK |
				allocate(HL_REG,IX_REG,AREG)
				"call .dvu2"
				erase(BC)
				erase(DE)	| DE		| |
dvu $1 == 4 | STACK |		  allocate(ALL_REG)
				"call .dvu4"			| | |
rmi $1 == 2 | BC_REG_SCR  DE_REG_SCR  STACK |
				allocate(HL_REG,IX_REG,AREG)
				"call .rmi2"
				erase(BC)
				erase(DE)	| DE		| |
rmi $1 == 4 | STACK |		  allocate(ALL_REG)
				"call .dvi4"
				"pop hl"
				"pop hl"
				erase(HL)
						| BC DE		|  |
rmu $1 == 2 | BC_REG_SCR  DE_REG_SCR  STACK |
				allocate(HL_REG,IX_REG,AREG)
				"call .dvu2"
				erase(BC)
				erase(DE)	| HL		| |
rmu $1 == 4 | STACK |		  allocate(ALL_REG)
				"call .dvu4"	| BC DE		| |
ngi $1 == 2 | REG |		  allocate(HL_REG = {IMMEDIATE,0})
				"or a"
				"sbc hl,%[1]"
				erase(HL)		| HL	| |
ngi $1 == 4 | DE_REG_SCR BC_REG_SCR |
				 allocate(HL_REG,AREG)
				"xor a"
				"ld h,a"
				"ld l,a"
				"sbc hl,de"
				"ex de,hl"
				"ld h,a"
				"ld l,a"
				"sbc hl,bc"
				erase(DE)	| HL DE | |
sli $1 == 2 | REG_SCR  HL_REG_SCR |
				"inc %[1.1]" /* see if count >> 15 */
				"dec %[1.1]"
				"jr z,1f"
				"ld %[1.2],15"
				"1:"
				"dec %[1.2]"
				"jp m,2f"
				"add hl,hl"
				"jr 1b"
				"2:"
				erase(%[1])
				erase(HL)	| HL | |
sli $1 == 4 | REG_SCR IX_REG_SCR HL_REG_SCR |
				"inc %[1.1]"
				"dec %[1.1]"
				"jr z,1f"
				"ld %[1.2],31"
				"1:"
				"dec %[1.2]"
				"jp m,2f"
				"add ix,ix"
				"adc hl,hl"
				"jr 1b"
				"2:"
				erase(%[1])
				erase(HL)
				erase(IX)	| HL IX | |
sri $1 == 2 | GEN_REG_SCR  GEN_REG_SCR |
				"inc %[1.1]"
				"dec %[1.1]"
				"jr z,1f"
				"ld %[1.2],15"
				"1:"
				"dec %[1.2]"
				"jp m,2f"
				"sra %[2.1]"
				"rr %[2.2]"
				"jr 1b"
				"2:"
				erase(%[1])
				erase(%[2])	| %[2] | |
sri $1 == 4 | GEN_REG_SCR  GEN_REG_SCR  GEN_REG_SCR |
				"inc %[1.1]"
				"dec %[1.1]"
				"jr z,1f"
				"ld %[1.2],31"
				"1:"
				"dec %[1.2]"
				"jp m,2f"
				"sra %[3.1]"
				"rr %[3.2]"
				"rr %[2.1]"
				"rr %[2.2]"
				"jr 1b"
				"2:"
				erase(%[1])
				erase(%[2])
				erase(%[3])	| %[3] %[2] | |
mlu | | | | mli $1 |
sru $1 == 2 | GEN_REG_SCR  GEN_REG_SCR |
				"inc %[1.1]"
				"dec %[1.1]"
				"jr z,1f"
				"ld %[1.2],15"
				"1:"
				"dec %[1.2]"
				"jp m,2f"
				"srl %[2.1]"
				"rr %[2.2]"
				"jr 1b"
				"2:"
				erase(%[1])
				erase(%[2])	| %[2] | |
sru $1 == 4 | GEN_REG_SCR  GEN_REG_SCR  GEN_REG_SCR |
				"inc %[1.1]"
				"dec %[1.1]"
				"jr z,1f"
				"ld %[1.2],31"
				"1:"
				"dec %[1.2]"
				"jp m,2f"
				"srl %[3.1]"
				"rr %[3.2]"
				"rr %[2.1]"
				"rr %[2.2]"
				"jr 1b"
				"2:"
				erase(%[1])
				erase(%[2])
				erase(%[3])	| %[3] %[2] | |
adu | | | | adi $1 |
sbu | | | | sbi $1 |
slu | | | | sli $1 |



/* G R O U P  V : F L O A T I N G  P O I N T */
  

adf | |
				"call .unimpld"	| | |
sbf | |
				"call .unimpld"	| | |
mlf | |
				"call .unimpld"	| | |
dvf | |
				"call .unimpld"	| | |
ngf | |
				"call .unimpld"	| | |
fif | |
				"call .unimpld"	| | |
fef | |
				"call .unimpld"	| | |



/* G R O U P  VI :   P O I N T E R   A R I T H M E T I C   */



adp $1 == 0 | | | | |
adp $1 == 1 | ANY_REG_SCR |	"inc %[1]"
				erase(%[1])	|	%[1]	| |
adp $1 == 2 | ANY_REG_SCR |	"inc %[1]"
				"inc %[1]"
				erase(%[1]) |	%[1]	| |
adp $1 == 0-1 | ANY_REG_SCR |	"dec %[1]"
				erase(%[1]) |	%[1]	| |
adp $1 == 0-2 | ANY_REG_SCR |	"dec %[1]"
				"dec %[1]"
				erase(%[1])  |		%[1]	| |
adp $1 < 0-2 || $1 > 2 | HL_REG_SCR |
				allocate(REG = {IMMEDIATE,$1} )
				"add hl,%[a]"
				erase(HL) |	HL	| |
... |		        REG |
				allocate(HL_REG = {IMMEDIATE,$1} )
				"add hl,%[1]"
				erase(HL) |	HL	| |
...	| LOCAL_ADDR | remove(ALL) | {LOCAL_ADDR, %[1.off]+$1}	| |
ads $1 == 2 | HL_REG_SCR REG |	 remove(ALL) "add hl,%[2]"
				erase(HL) |	HL	| |
...	    | REG HL_REG_SCR |	 "add hl,%[1]"
				erase(HL) |	HL	| |
sbs $1 == 2 | REG HL_REG_SCR |	 "or a"
				"sbc hl,%[1]"
				erase(HL) |	HL	| |



/* G R O U P  VII :  I N C R E M E N T   /   D E C R E M E N T   */



inc | ANY_REG_SCR |		 "inc %[1]"
				erase(%[1]) |		%[1] | |

/* There is no efficient way on the Z80 to increment or decrement
 * a local or external. We first fetch the variable into a register,
 * increment/decrement it and then store it.
 */

inl | | | | lol $1 inc stl $1 |
ine | | | | loe $1 inc ste $1 |
dec | ANY_REG_SCR | 		 "dec %[1]"
				erase(%[1]) |	%[1]	| |
del | | | | lol $1 dec stl $1 |
dee | | | | loe $1 dec ste $1 |
zrl ($1 >= 0-128 && $1 < 127) | |
				remove(ALL)
				allocate(AREG)
				"xor a"
				move(AA , {INDEXED,LB,$1})
				move(AA , {INDEXED,LB,$1+1})		| | |
zrl ($1 < 0-128 || $1 >= 127) | |
				remove(ALL)
				allocate(HL_REG = {IMMEDIATE,$1} , REG, AREG)
				"push iy"
				"pop %[b]"
				"add hl,%[b]"
				"xor a"
				"ld (hl),a"
				"inc hl"
				"ld (hl),a"
				erase(HL)				| | |
zrf | |
				"call .unimpld" | | |
zre  |  |			remove(EXTENDED,%[off] == $1)
				remove(ALL)
				allocate(ANY_REG = {IMMEDIATE,0} )
				move(%[a] , {EXTENDED,$1})	| | |
zer $1 == 2 | | |  {IMMEDIATE,0} | |
zer $1 == 4 | | |  {IMMEDIATE,0} {IMMEDIATE,0} | |
zer $1 > 4 && $1 < 256 | STACK |

				allocate(BC_REG , GEN_REG)
				"ld b,$1"
				"ld %[b],0"
				"1:"
				"push %[b]"
				"djnz 1b"
								| | |



/* G R O U P  VIII :   C O N V E R T   */



cii | STACK |			remove(ALL) allocate(ALL_REG)
				"call .cii"			| | |
cuu | STACK |			remove(ALL) allocate(ALL_REG)
				"call .cuu"			| | |
cui | | | | cuu |
ciu | | | | cuu |
cfi | |
				"call .unimpld"	| | |
cif | |
				"call .unimpld"	| | |
cuf | |
				"call .unimpld"	| | |
cff | |
				"call .unimpld"	| | |
cfu | |
				"call .unimpld"	| | |
cmf | |
				"call .unimpld"	| | |



/* G R O U P  IX :   L O G I C A L   */



and $1 == 2 | GEN_REG GEN_REG_SCR |
				allocate(AREG)
				"ld a,%[1.2]"
				"and %[2.2]"
				"ld %[2.2],a"
				"ld a,%[1.1]"
				"and %[2.1]"
				"ld %[2.1],a"
				erase(%[2])	   |		%[2]	| |
and defined($1) && $1 > 2 | STACK |
				allocate(DE_REG = {IMMEDIATE,$1},
					BC_REG,HL_REG,IX_REG,AREG)
				"call .and"
				erase(DE)			| | |
and ! defined($1) | DE_REG_SCR  STACK |
				allocate(BC_REG,HL_REG,IX_REG,AREG)
				"call .and"
				erase(DE)			| | |
ior $1 == 2 | GEN_REG GEN_REG_SCR |
				allocate(AREG)
				"ld a,%[1.2]"
				"or %[2.2]"
				"ld %[2.2],a"
				"ld a,%[1.1]"
				"or %[2.1]"
				"ld %[2.1],a"
				erase(%[2])	   |		%[2]	| |
ior defined($1) && $1 > 2 | STACK |
				allocate(DE_REG = {IMMEDIATE,$1},
					BC_REG,HL_REG,IX_REG,AREG)
				"call .ior"
				erase(DE)			| | |
ior ! defined($1) | DE_REG_SCR  STACK |
				allocate(BC_REG,HL_REG,IX_REG,AREG)
				"call .ior"
				erase(DE)			| | |
xor $1 == 2 | GEN_REG GEN_REG_SCR |
				allocate(AREG)
				"ld a,%[1.2]"
				"xor %[2.2]"
				"ld %[2.2],a"
				"ld a,%[1.1]"
				"xor %[2.1]"
				"ld %[2.1],a"
				erase(%[2])	   |		%[2]	| |
xor defined($1) && $1 > 2 | STACK |
				allocate(DE_REG = {IMMEDIATE,$1},
					BC_REG,HL_REG,IX_REG,AREG)
				"call .xor"
				erase(DE)			| | |
xor ! defined($1) | DE_REG_SCR  STACK |
				allocate(BC_REG,HL_REG,IX_REG,AREG)
				"call .xor"
				erase(DE)			| | |
com $1 == 2 | GEN_REG_SCR |	 allocate(AREG)
				"ld a,%[1.2]"
				"cpl"
				"ld %[1.2],a"
				"ld a,%[1.1]"
				"cpl"
				"ld %[1.1],a"
				erase(%[1]) |		%[1]	| |
com defined($1) && $1 > 2  | STACK |
				allocate(AREG,
					 HL_REG = {IMMEDIATE,$1} )
				"add hl,sp"
				"1:"
				"dec hl"
				"ld a,(hl)"
				"cpl"
				"ld (hl),a"
				"xor a"
				"sbc hl,sp"
				"jr z,2f"
				"add hl,sp"
				"jr 1b"
				"2:"
				erase(HL)	| | |
com ! defined($1) | HL_REG_SCR STACK |
				allocate(AREG)
				"add hl,sp"
				"1:"
				"dec hl"
				"ld a,(hl)"
				"cpl"
				"ld (hl),a"
				"xor a"
				"sbc hl,sp"
				"jr z,2f"
				"add hl,sp"
				"jr 1b"
				"2:"
				erase(HL)	| | |
rol $1 == 2 | REG_SCR HL_REG_SCR |
				allocate(AREG)
				"ld a,%[1.2]"
				"and 15"
				"jr z,2f"
				"ld %[1],0"
				"1:"
				"add hl,hl"
				"adc hl,%[1]"
				"dec a"
				"jr nz,1b"
				"2:"
				erase(%[1])
				erase(%[2])	|	HL		| |
rol $1 == 4 | REG  IX_REG_SCR  HL_REG_SCR |
				allocate(AREG)
				"ld a,%[1.2]"
				"and 31"
				"jr z,3f"
				"1:"
				"add ix,ix"
				"adc hl,hl"
				"jr nc,2f"
				"inc ix"
				"2:"
				"dec a"
				"jr nz,1b"
				"3:"
				erase(HL)
				erase(IX)	| HL IX  | |
ror $1 == 2 | GEN_REG_SCR  GEN_REG_SCR |
				allocate(AREG)
				"ld a,%[1.2]"
				"and 15"
				"jr z,0f"
				"1:"
				"srl %[2.1]"
				"rr %[2.2]"
				"jr nc,2f"
				"set 7,%[2.1]"
				"2:"
				"dec a"
				"jr nz,1b"
				"0:"
				erase(%[1])
				erase(%[2])	| %[2] | |
ror $1 == 4 | GEN_REG_SCR  GEN_REG_SCR  GEN_REG_SCR |
				allocate(AREG)
				"ld a,%[1.2]"
				"and 31"
				"jr z,0f"
				"1:"
				"srl %[3.1]"
				"rr %[3.2]"
				"rr %[2.1]"
				"rr %[2.2]"
				"jr nc,2f"
				"set 7,%[3.1]"
				"2:"
				"dec a"
				"jr nz,1b"
				"0:"
				erase(%[1])
				erase(%[2])
				erase(%[3])	| %[3] %[2]  | |



/* G R O U P  X :  S E T S    */


inn defined($1) | STACK |	 allocate(HL_REG = {IMMEDIATE,$1},
					 BC_REG,DE_REG,IX_REG,AREG)
				"call .inn"
				erase(HL)			| | |
inn !defined($1) | HL_REG_SCR  STACK |
				allocate(BC_REG,DE_REG,IX_REG,AREG)
				"call .inn"
				erase(HL)			| | |
set defined($1) | STACK |	 allocate(HL_REG = {IMMEDIATE,$1},
					 BC_REG,DE_REG,IX_REG,AREG)
				"call .set"
				erase(HL)			| | |
set !defined($1) | HL_REG_SCR  STACK |
				allocate(BC_REG,DE_REG,IX_REG,AREG)
				"call .set"
				erase(HL)			| | |



/* G R O U P XI :  A R R A Y S */


lae aar $2 == 2 && rom(1,3) == 2 | STACK |
				allocate(ALL_REG)
				move({EXTENDED_ADDR,$1},BC)
				"push bc"
				"call .aar2"			| | |
lae aar $2 == 2 && rom(1,3) != 2 | STACK |
				allocate(ALL_REG)
				move({EXTENDED_ADDR,$1},BC)
				"push bc"
				"call .aar"			| | |
aar $1==2	| |
				remove(ALL)
				allocate(ALL_REG)
				"call .aar"
								| | |
aar !defined($1) | |		remove(ALL)
				allocate(ALL_REG)
				"call .aaru"			| | |
lae lar $2 == 2 && rom(1,3) == 2 | STACK |
				remove(ALL) allocate(ALL_REG)
				move({EXTENDED_ADDR,$1},BC)
				"push bc"
				"call .lar2"			| | |
lae lar $2 == 2 && rom(1,3) != 2 | STACK |
				remove(ALL) allocate(ALL_REG)
				move({EXTENDED_ADDR,$1},BC)
				"push bc"
				"call .lar"			| | |
lar $1==2 | |			remove(ALL)
				allocate(ALL_REG)
				"call .lar"			| | |
lar !defined($1) | |		remove(ALL)
				allocate(ALL_REG)
				"call .laru"			| | |
lae sar $2 == 2 && rom(1,3) == 2 | STACK |
				remove(ALL) allocate(ALL_REG)
				move({EXTENDED_ADDR, $1},BC)
				"push bc"
				"call .sar2"			| | |
lae sar $2 == 2 && rom(1,3) != 2 | STACK |
				remove(ALL) allocate(ALL_REG)
				move({EXTENDED_ADDR, $1},BC)
				"push bc"
				"call .sar"			| | |
sar $1==2 | |			remove(ALL)
				allocate(ALL_REG)
				"call .sar"			| | |
sar !defined($1) | |		remove(ALL)
				allocate(ALL_REG)
				"call .saru"			| | |


/* G R O U P  XII :  C O M P A R E  */



cmi $1 == 2 | REG_SCR HL_REG_SCR |
				remove(ALL) allocate(AREG)
				"ld a,h"
				"xor %[1.1]"
				"jp m,1f"
				"sbc hl,%[1]"
				"jr 2f"
				"1:"
				"xor %[1.1]"
				"jp m,2f"
				"set 0,l"
				"2:"
				erase(%[1])
				erase(%[2])	|	HL		| |
cmi $1 == 4 | STACK |		remove(ALL) allocate(AREG = {IMMEDIATE1,1},
					BC_REG,DE_REG,HL_REG,IX_REG)
				"call .cmu4"
				erase(AA)	| DE	| |
cmu $1 == 2 | REG_SCR  HL_REG_SCR |
				remove(ALL) allocate(AREG)
				"ld a,h"
				"xor %[1.1]" /* resets carry bit */
				"jp m,1f"
				"sbc hl,%[1]"
				"jr 2f"
				"1:"
				"xor %[1.1]"
				"cpl"
				"set 0,l"
				"2:"
				erase(%[1])
				erase(%[2])	| HL | |
cmu $1 == 4 | STACK |		remove(ALL) allocate(AREG = {IMMEDIATE1,0},
					BC_REG,DE_REG,HL_REG,IX_REG)
				"call .cmu4"
				erase(AA)	| DE	| |
cmp | | | | cmu 2 |
cms $1 == 2 | GEN_REG  GEN_REG_SCR |
				remove(ALL) allocate(AREG)
				"ld a,%[1.1]"
				"xor %[2.1]"
				"ld %[2.1],a"
				"ld a,%[1.2]"
				"xor %[2.2]"
				"ld %[2.2],a"	| %[2] | |
/***
cmu defined($1) | STACK |	 allocate(HL_REG = {IMMEDIATE,$1},
					BC_REG,DE_REG,IX_REG,AREG)
				"call .cmu"
				erase(HL)		| | |
cmu ! defined($1) | HL_REG_SCR  STACK |
				 allocate(BC_REG,DE_REG,IX_REG,AREG)
				"call .cmu"
				erase(HL)		| | |
*/
cms defined($1) | STACK |	 remove(ALL) allocate(HL_REG = {IMMEDIATE,$1},
					BC_REG,DE_REG,IX_REG,AREG)
				"call .cms"
				erase(HL)		| | |
cms ! defined($1) | HL_REG_SCR  STACK |
				 allocate(BC_REG,DE_REG,IX_REG,AREG)
				"call .cms"
				erase(HL)		| | |




tlt | GEN_REG |			remove(ALL)
				allocate(GEN_REG = {IMMEDIATE,0})
				"bit 7,%[1.1]"
				"jr z,1f"
				"inc %[a.2]"
				"1:"
				erase(%[a])	|	%[a]		| |
tle | GEN_REG |			remove(ALL)
				allocate(AREG, GEN_REG = {IMMEDIATE,1})
				"xor a"
				"add a,%[1.1]"
				"jp m,2f"
				"jr nz,1f"
				"xor a"
				"add a,%[1.2]"
				"jr z,2f"
				"1:"
				"dec %[b.2]"
				"2:"
				erase(%[b])	|	%[b]		| |
teq | GEN_REG |			remove(ALL)
				allocate(AREG,GEN_REG = {IMMEDIATE,0})
				"ld a,%[1.1]"
				"or a"
				"jp m,1f"
				"xor %[1.2]"
				"jr nz,1f"
				"inc %[b.2]"
				"1:"
				erase(%[b])	|	%[b]		| |
tne | GEN_REG |			remove(ALL)
				allocate(AREG, GEN_REG = {IMMEDIATE,0})
				"ld a,%[1.1]"
				"or %[1.2]"
				"jr z,1f"
				"inc %[b.2]"
				"1:"
				erase(%[b])	|	%[b]		| |
tge | GEN_REG |			remove(ALL)
				allocate(GEN_REG = {IMMEDIATE,0})
				"bit 7,%[1.1]"
				"jr nz,1f"
				"inc %[a.2]"
				"1:"
				erase(%[a])	|	%[a]		| |
tgt | GEN_REG |			remove(ALL)
				allocate(AREG, GEN_REG = {IMMEDIATE,0})
				"xor a"
				"add a,%[1.1]"
				"jp m,2f"
				"jr nz,1f"
				"xor a"
				"add a,%[1.2]"
				"jr z,2f"
				"1:"
				"inc %[b.2]"
				"2:"
				erase(%[b])	|	%[b]		| |



/* G R O U P  XIII :   B R A N C H   */



bra	| | 			remove(ALL)
				"jp $1"			| | |
blt | GEN_REG  GEN_REG |	 remove(ALL)	allocate(AREG)
				"ld a,%[2.2]"
				"sub %[1.2]"
				"ld a,%[2.1]"
				"sbc a,%[1.1]"
				"jp m,$1"			| | |
ble | GEN_REG GEN_REG |	    	remove(ALL)	allocate(AREG)
				"ld a,%[2.2]"
				"sub %[1.2]"
				"ld a,%[2.1]"
				"sbc a,%[1.1]"
				"jp m,$1"
				"jr nz,1f"
				"ld a,%[2.2]"
				"cp %[1.2]"
				"jr z,$1"
				"1:"				| | |
beq | GEN_REG  GEN_REG |	 remove(ALL)	allocate(AREG)
				"ld a,%[2.2]"
				"sub %[1.2]"
				"jr nz,1f"
				"ld a,%[2.1]"
				"sbc a,%[1.1]"
				"jr z,$1"
				"1:"				| | |
bne | GEN_REG  GEN_REG |	 remove(ALL)	allocate(AREG)
				"ld a,%[2.2]"
				"sub %[1.2]"
				"jr nz,$1"
				"ld a,%[2.1]"
				"sbc a,%[1.1]"
				"jr nz,$1"			
				erase(AA)			| | |

bge | GEN_REG  GEN_REG |	remove(ALL)	allocate(AREG)
				"ld a,%[2.2]"
				"sub %[1.2]"
				"ld a,%[2.1]"
				"sbc a,%[1.1]"
				"jp p,$1"			| | |
bgt | GEN_REG  GEN_REG_SCR |	 remove(ALL)	allocate(AREG)
				"ld a,%[2.2]"
				"sub %[1.2]"
				"ld %[2.2],a"
				"ld a,%[2.1]"
				"sbc a,%[1.1]"
				"jp m,1f"
				"jr nz,$1"
				"xor a"
				"cp %[2.2]"
				"jr nz,$1"
				"1:"
				erase(%[2])				| | |
zlt | GEN_REG |  		remove(ALL)   "bit 7,%[1.1]"
				"jr nz,$1"			| | |
zle | GEN_REG | remove(ALL) 	allocate(AREG)
				"xor a"
				"add a,%[1.1]"
				"jp m,$1"
				"jr nz,1f"
				"xor a"
				"add a,%[1.2]"
				"jr z,$1"
				"1:"				| | |
zeq | GEN_REG | 		remove(ALL) 	allocate(AREG)
				"ld a,%[1.1]"
				"or %[1.2]"
				"jr z,$1"			| | |
zne | GEN_REG | 		remove(ALL) 	allocate(AREG)
				"ld a,%[1.1]"
				"or %[1.2]"
				"jr nz,$1"			| | |
zge | GEN_REG | 		remove(ALL) 	"bit 7,%[1.1]"
				"jr z,$1"			| | |
zgt | GEN_REG | 		remove(ALL) 	allocate(AREG)
				"xor a"
				"add a,%[1.1]"
				"jp m,1f"
				"jr nz,$1"
				"xor a"
				"add a,%[1.2]"
				"jr nz,$1"
				"1:"				| | |



/* G R O U P  XIV :   P R O C E D U R E   C A L L S   */



cai | HL_REG |			remove(ALL)
				allocate( GEN_REG )
				"ld %[a],1f"
				"push %[a]"
				"jp (hl)"
				"1:"
									| | |
cal | |				remove(ALL)
				allocate(ALL_REG)
				"call $1"
									| | |
lfr $1 == 2 |  |		remove(ALL)
				"push de"
						|  |  |
lfr $1 == 4 | STACK |		"push de"
				"push bc"			| | |
lfr 	| |			remove(ALL)
				move({IMMEDIATE,$1},DE)
				"call .lfr"
								| | |
ret $1 == 0 | STACK |
				remove(ALL)	
				allocate(HL_REG,LOCALBASE)
				"push iy"
				"pop hl"
				"ld sp,hl"
				"pop iy"
				"ret"				| | |
ret $1 == 2 | STACK |		remove(ALL)
				allocate(HL_REG,DE_REG,LOCALBASE)
				"pop de"
				"push iy"
				"pop hl"
				"ld sp,hl"
				"pop iy"
				"ret"				| | |
ret $1 == 4 | STACK |
				remove(ALL)
				allocate(BC_REG, DE_REG, HL_REG, LOCALBASE)
				"pop bc"
				"pop de"
				"push iy"
				"pop hl"
				"ld sp,hl"
				"pop iy"
				"ret"				| | |
ret  		| |		remove(ALL)
				move({IMMEDIATE,$1},DE)
				"call .ret"
				erase(BC)			| | |



/* G R O U P  XV :   M I S C E L L A N E O U S   */



asp $1 == 0 | | | | |
asp $1 != 0 | STACK | 		remove(ALL) allocate(HL_REG)
				move({IMMEDIATE,$1} , HL)
				"add hl,sp"
				"ld sp,hl"
				erase(HL)				| | |
ass $1 == 2 | HL_REG_SCR  STACK |
				remove(ALL)
				"add hl,sp"
				"ld sp,hl"
				erase(HL)				| | |
blm $1 == 0 | | | | |
blm $1 > 0 |DE_REG_SCR  HL_REG_SCR |

				allocate(BC_REG = {IMMEDIATE,$1} )
				"ldir"
				erase(HL)
				erase(BC)
				erase(DE)				| | |
bls $1 == 2 | BC_REG_SCR  DE_REG_SCR  HL_REG_SCR |
				remove(MEM_ALL)
				"ldir"
				erase(HL)
				erase(BC)
				erase(DE)				| | |
csa $1 == 2 | STACK |		 allocate(ALL_REG)
				"jr .csa"				| | |
csb $1 == 2 | STACK |		 allocate(ALL_REG)
				"jr .csb"				| | |
dus $1 == 2 | BC_REG_SCR |	remove(MEM_ALL) allocate(HL_REG,DE_REG)
				move({IMMEDIATE,0} , HL)
				"add hl,sp"
				"ld d,h"
				"ld e,l"		/* destination */
				"sbc hl,bc"		/* source */
				"ld sp,hl"
				"ex de,hl"
				"ldir"
				erase(HL)
				erase(BC)			| | |
dup $1 == 2 | ANY | | %[1] %[1] | |
dup $1 == 4 | ANY ANY | | %[2] %[1] %[2] %[1] |  |
dup $1 == 6 | ANY ANY ANY | | %[3] %[2] %[1] %[3] %[2] %[1] | |
dup $1 > 6 | STACK |		allocate(HL_REG,BC_REG,DE_REG)
				move({IMMEDIATE,0} , HL)
				"add hl,sp"
				"ld d,h"
				"ld e,l"		/* destination */
				move ({IMMEDIATE,$1},BC) /* count */
				"sbc hl,bc"		/* source */
				"ld sp,hl"
				"ex de,hl"
				"ldir"
				erase(HL)
				erase(BC)			| | |
lor $1 == 0 | |			 "push iy"			 |  | |
fil	| |			allocate(HL_REG)
				move({EXTENDED_ADDR,$1},HL)
				"ld (hol0+4),hl"
				erase(HL)				| | |
lor $1 == 1 | STACK |		 allocate(HL_REG)
				move({IMMEDIATE,0} , HL)
				"add hl,sp"
				erase(HL)	|	HL		| |
lor $1 == 2 | STACK | | {EXTENDED,".reghp"} | |
exg $1 == 2 | ANY ANY |		| %[1] %[2] | |
exg 	| STACK |		remove(MEM_ALL)
				allocate(HL_REG)
				move({IMMEDIATE,$1},HL)
				"push hl"
				"call .exg"		| | |
gto		| |		remove(ALL)
				allocate(ALL_REG)
				move({EXTENDED_ADDR,$1},HL)
				"call .gto"
							| | |
lim		| | 		| {EXTENDED,"ignmask"} | |
lin        | |			  remove(ALL) allocate(HL_REG)
				move({IMMEDIATE,$1},HL)
				"ld (hol0),hl"
				erase(HL)				| | |
lni	| |			 allocate(HL_REG)
				"ld hl,hol0"
				"inc (hl)"
				erase(HL)		| | |
lpb		| | 		|			| adp 4 |
nop		| STACK |
#ifdef DEBUG
				allocate(ALL_REG)
				"call .nop"
#endif
							| | |
rck $1 == 2 | STACK |		 allocate(ALL_REG)
				"call .rck"
									| | |
rtt		| |		|			| ret 0|
sig		| HL_REG_SCR |			

				"ld (trapproc),hl"	
				"ld hl,trapproc"
							| HL | |
sim	| HL_REG | 		remove(MEM_ALL)
				 "pop hl"
				 "ld (ignmask),hl"		| | |
str $1 == 0 | |			"pop iy" | | |
str $1 == 1 | STACK |		 allocate(HL_REG)
				"pop hl"
				"ld sp,hl"			| | |
str $1 == 2 | STACK |		 allocate(ALL_REG)
				"call .strhp"
									| | |
trp| |				remove(ALL)
				allocate(ALL_REG)
				  "call .trp.z"		| | |
mon	| |			remove(MEM_ALL)
				"call .mon"		 | | |



/* C O E R C I O N S  */



/* from 4 bytes to 2 */
 

/* to a register */
| ANYTOK		 |	allocate(ANY_REG)
				move(%[1],%[a])	|	%[a]	| |

| STACK |			allocate(ANY_REG)
				"pop %[a]"	|	%[a]	| |
| LOCAL_ADDR	|		allocate(ANY_REG)
				move(LB,%[a])
				"add %[a],%[1]"
							|	%[a]  | |
| IMMEDIATE |			allocate(ANY_REG)
				move(%[1],%[a])
							| %[a] | |
				

/* between registers */

| GEN_REG |			allocate(GEN_REG)
				"ld %[a.1],%[1.1]"
				"ld %[a.2],%[1.2]"	|	%[a]	| |
| LOCALBASE |				allocate(ANY_REG)
				"push iy"
				"pop %[a]"	|	%[a]	| |


/***********
 ** MOVES **
 ***********/



MOVES:
(ANY,ANY,"ld %[2],%[1]")
(ANY1,ANY1,"ld %[2],%[1]")




/************
 *  STACKS  *
 ************/


STACKS:

(ANY_REG, ,	  "push %[1]" 	    )
(MEM_ALL, ANY_REG, move(%[1],%[a])
		  "push %[a]"       )
(MEM_ALL, ,	  "push hl"
		  move(%[1],HL)
		  "ex (sp),hl"      )