| Definitions of macros corresponding to ctlrom opcodes for MAYBE II

uSP     = 0xFF
uRC     = 0xFE

_DEBUG  = 0xFD
_RESERV = 0xFC

T3      = 0xFB
T2      = T3-1
T1      = T2-1
T0      = T1-1

SBASE = T0-1                         | Base of microstack (builds down).

.macro WORD(x) x%256 x/256           | Low-byte followed by high-byte.
.macro LONG(x) WORD(x) WORD(x >> 16) | Low-word followed by high-word.

| Opcode 0 not used for now (reserved for an I/O hack opcode later).

.macro call(s)                  0x01 (.+4)%256 (.+3)/256 WORD(s)
.macro rtn()                    0x02
.macro push(x)                  0x03 x
.macro pop(x)                   0x04 x
.macro move(x,y)                0x05 x y
.macro cmove(cx,y)              0x06 cx y
.macro swt(x)                   0x07 x
.macro pdisp(x,p00,p01,p10,p11) 0x08 x WORD(p00) WORD(p01) WORD(p10) WORD(p11)
.macro pwrup()                  0x09
.macro add(x,y,z)               0x0A x y z
.macro cadd(cx,y,z)             0x0B cx y z
.macro jmp(adr)                 0x0C WORD(adr)
.macro imove(x,y)               0x0D x y
.macro movei(x,y)               0x0E x y

| Copy n-byte SRAM values:

.macro move2(x,y) move(x,y)     move(x+1,y+1)
.macro move4(x,y) move2(x,y)    move2(x+2,y+2)

.macro cmove2(cx,y) cmove((cx)%256,y) cmove((cx)/256,y+1)
.macro cmove4(cx,y) cmove2(cx,y)      cmove2(cx >> 16,y+2)

.macro l(adrlo,adrhi,x)         0x0F adrlo adrhi x
.macro s(x,adrlo,adrhi)         0x10 x adrlo adrhi
.macro refr()                   0x11

.macro jmi(x)                   0x12 WORD(x)
.macro jetra(x)                 0x13 WORD(x)
.macro jready(x)                0x14 WORD(x)
.macro jp1(x)                   0x15 WORD(x)
.macro jodd(x)                  0x16 WORD(x)
.macro jnc(x)                   0x17 WORD(x)
.macro jp0(x)                   0x18 WORD(x)
.macro je(x)                    0x19 WORD(x)

| Opcodes 0x1A and 0x1B are not used.

.macro sub(x,y,z)               0x1C x y z
.macro cmp(x,y)                 0x1D x y

| Following macros demonstrate an alternative to composing countless
| nanoinstrctions. All could have been written as explicit nanocodes,
| but at the cost of 1 opcode each and much effort in pounding out
| the nanobits. Note, however, that each of these ewpands into
| 2 nanoinstruction calls. You have to pay for your laziness.

.macro ccmp(cx,y)     cmove(cx,T0) cmp(T0,y)     | Constant compare.
.macro cor(cx,y,z)    cmove(cx,T0) or(T0,y,z)    | Constant OR (inclusive).
.macro cxor(cx,y,z)   cmove(cx,T0) xor(T0,y,z)   | Constant XOR.
.macro csub(x,cy,z)   cmove(cy,T0) sub(x,T0,z)   | Constant subtract.
.macro csubcy(x,cy,z) cmove(cy,T0) subcy(x,T0,z) | Constact sub w/borrou.

.macro jpl(a)                   0x1E WORD(a)
.macro jnextra(a)               0x1F WORD(a)    | Extra condition bit.
.macro jnready(a)               0x20 WORD(a)
.macro jnp1(a)                  0x21 WORD(a)
.macro jeven(a)                 0x22 WORD(a)
.macro jc(a)                    0x23 WORD(a)
.macro jnp0(a)                  0x24 WORD(a)
.macro jne(a)                   0x25 WORD(a)
.macro urom(l,h,dst)            0x26 l h dst
.macro and(x,y,z)               0x27 x y z
.macro or(x,y,z)                0x28 x y z
.macro xor(x,y,z)               0x29 x y z
.macro not(x,y)                 0x2A x y
.macro neg(x,y)                 0x2B x y

| 16-bit operations. Operands use 2 consecutive SRAM locations.

.macro add2(x,y,z)              0x2C x y z x+1 y+1 z+1
.macro cadd2(cx,y,z)            0x2D cx%256 y z cx/256 y+1 z+1
.macro sub2(x,y,z)              0x2E x y z x+1 y+1 z+1
.macro cmp2(x,y)                0x2F x y x+1 y+1

.macro ccmp2(cx,y) cmove2(cx,T0) cmp2(T0,y)

.macro count(x)                 0x30 x
.macro cond(x)                  0x31 x

| Opcodes 0x32 A 033 are negcy  subcy(x,y,z) below (for no good reason).

| Opcodes 0x34 - 0x39 implement the I/O functions
|.macro iowrite(x)              0x34 
|.macro ioread(x)               0x35 x
.macro iowrite(x)               writeio(x, 0)
.macro ioread(x)                readio(0, x)
.macro cwriteio(cx, r)          cmove(cx,T0) writeio(T0, r)
.macro readio(r, x)             0x34 r x
.macro ireadio(x, y)            0x35 x y
.macro writeio(x, r)            0x36 r x | NOTE ARG REVERSAL [see ctlrom]
.macro writeioi(x, y)           0x37 y x | NOTE ARG REVERSAL [see ctlrom]

| Opcodes 037 - 0x7F not used (for no good reason).

.macro dispatch(x,adr)          0x80 x adr/256 adr%256
.macro addcy(x,y,z)             0x81 x y z
.macro negcy(x, y)              0x32 x y
.macro subcy(x,y,z)             0x33 x y z
.macro caddcy(cx,y,z)           0x82 cx y z
.macro cand(cx,y,z)             0x83 cx y z

| Opcodes 0x84 - 0x88 not used (for no good reason).

.macro rotr7(x,y)               0x89 x y        | Right rotations.
.macro rotr6(x,y)               0x8A x y
.macro rotr5(x,y)               0x8B x y
.macro rotr4(x,y)               0x8C x y
.macro rotr3(x,y)               0x8D x y
.macro rotr2(x,y)               0x8E x y
.macro rotr1(x,y)               0x8F x y

.macro rotl7(x,y)               0x8F x y        | Left rotations.
.macro rotl6(x,y)               0x8E x y
.macro rotl5(x,y)               0x8D x y
.macro rotl4(x,y)               0x8C x y
.macro rotl3(x,y)               0x8B x y
.macro rotl2(x,y)               0x8A x y
.macro rotl1(x,y)               0x89 x y

.macro bpt() 0xFF               | Breakpoint.