Generate mnemonics from subrule / cat?

[fisherdog1]

I have a series of very similar mnemonics like this:

	ad {rd: gpreg}, {rs: gpreg}, {rt: gpreg} => 0x0`4 @ rd @ rs @ rt
	su {rd: gpreg}, {rs: gpreg}, {rt: gpreg} => 0x1`4 @ rd @ rs @ rt
	ic {rd: gpreg}, {rs: gpreg}, {rt: gpreg} => 0x2`4 @ rd @ rs @ rt
	dc {rd: gpreg}, {rs: gpreg}, {rt: gpreg} => 0x3`4 @ rd @ rs @ rt
	ls {rd: gpreg}, {rs: gpreg}, {rt: gpreg} => 0x4`4 @ rd @ rs @ rt
	rs {rd: gpreg}, {rs: gpreg}, {rt: gpreg} => 0x5`4 @ rd @ rs @ rt
	
	an {rd: gpreg}, {rs: gpreg}, {rt: gpreg} => 0x8`4 @ rd @ rs @ rt
	or {rd: gpreg}, {rs: gpreg}, {rt: gpreg} => 0x9`4 @ rd @ rs @ rt
	eo {rd: gpreg}, {rs: gpreg}, {rt: gpreg} => 0xA`4 @ rd @ rs @ rt
	
	ar {rd: gpreg}, {rs: gpreg}, {rt: gpreg} => 0xD`4 @ rd @ rs @ rt
	cp {rd: gpreg}, {rs: gpreg}, {rt: gpreg} => 0xE`4 @ rd @ rs @ rt

The mnemonic is of course a subset of possible 4 bit numbers. I can create a subrule associating these mnemonics to their numbers but I'm not sure there's a way to compress this code using it. The closest I've gotten is something like this for my conditional relative jumps:

	j {sbit: sreg_pos}, {sset: sreg_set}, {target} => 0xF`4 @ sset @ sbit @ pcrel8(target)

Which enables the following slightly unsatisfying formatting:

j	z,	c,	targetlabel

Is there a nicer way to do either of these things?

[hlorenzi]

Hmm, how about something like this?

#subruledef gpreg
{
	r1 => 0x1
	r2 => 0x2
	r3 => 0x3
}

#subruledef threeRegs
{
	{rd: gpreg}, {rs: gpreg}, {rt: gpreg} => rd @ rs @ rt
}

#ruledef
{	
	ad {args: threeRegs} => 0x0`4 @ args
	su {args: threeRegs} => 0x1`4 @ args
	ic {args: threeRegs} => 0x2`4 @ args
	dc {args: threeRegs} => 0x3`4 @ args
	ls {args: threeRegs} => 0x4`4 @ args
	rs {args: threeRegs} => 0x5`4 @ args
	
	an {args: threeRegs} => 0x8`4 @ args
	or {args: threeRegs} => 0x9`4 @ args
	eo {args: threeRegs} => 0xA`4 @ args
	
	ar {args: threeRegs} => 0xD`4 @ args
	cp {args: threeRegs} => 0xE`4 @ args
}

ad r1, r2, r3
su r2, r3, r1

I've extracted the common logic to the threeRegs subrule! Is this what you meant by compressing it?

About your jump instruction, the assembler should accept jz (without spaces) as valid!