Compiler Explorer

Source code

/*
Copyright (c) 2021 Bad Diode

Permission to use, copy, modify, and distribute this software for any
purpose with or without fee is hereby granted, provided that the above
copyright notice and this permission notice appear in all copies.

THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
WITH REGARD TO THIS SOFTWARE.
*/

#ifndef UTILS_SHORTHAND_H
#define UTILS_SHORTHAND_H

#include <assert.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>

// Fixed size data types.
typedef uint8_t      u8;
typedef uint16_t     u16;
typedef uint32_t     u32;
typedef uint64_t     u64;
typedef int8_t       s8;
typedef int16_t      s16;
typedef int32_t      s32;
typedef int64_t      s64;
typedef volatile u8  vu8;
typedef volatile u16 vu16;
typedef volatile u32 vu32;
typedef volatile u64 vu64;
typedef volatile s8  vs8;
typedef volatile s16 vs16;
typedef volatile s32 vs32;
typedef volatile s64 vs64;

// Size variables.
#define KB(N) ((u64)(N)   * 1024)
#define MB(N) ((u64)KB(N) * 1024)
#define GB(N) ((u64)MB(N) * 1024)
#define TB(N) ((u64)GB(N) * 1024)

// General utility macros.
#define MIN(A, B) ((A) <= (B) ? (A) : (B))
#define MAX(A, B) ((A) >= (B) ? (A) : (B))
#define CLAMP(X, MIN, MAX) ((X) <= (MIN) ? (MIN) : (X) > (MAX) ? (MAX): (X))
#define LEN(ARR) (sizeof(ARR) / sizeof((ARR)[0]))

#endif // UTILS_SHORTHAND_H

// General UXN variables.
#define PAGE_PROGRAM 0x0100
#define RAM_PAGES 0x10
#define POLYPHONY 4

// Accessor macros.
#define PEEK(p)       ((p)[0])
#define PEEK2(p)      (((u16)(p)[0] << 8) | ((u16)(p)[1]))
#define POP(p)        ((p) -= 1, PEEK(p))
#define POP2(p)       ((p) -= 2, PEEK2(p))
#define POKE(p, val)  do { (p)[0] = (val); } while(0);
#define POKE2(p, val) do { (p)[1] = (val) & 0xFF; (p)[0] = (val) >> 8; } while(0);
#define PUSH(p, val)  do { POKE((p), (val));  (p) += 1; } while(0)
#define PUSH2(p, val) do { POKE2((p), (val)); (p) += 2; } while(0);

// ROM.
extern u8 uxn_rom[];
extern u8 uxn_rom_size[];

// RAM.
u8 uxn_ram[KB(64) + 1];

// Stacks.
u8 wst[256];
u8 rst[256];
u8 *w;
u8 *r;

// Devices.
typedef u16 (*DeiFunc)(u8 *dev, u8 port);
typedef void (*DeoFunc)(u8 *dev, u8 port);
u8 device_data[256];
DeoFunc deo_map[16];
DeiFunc dei_map[16];

#define DEV(dev) PEEK2(&device_data[dev])
#define DEI(idx) dei_map[idx >> 4](&device_data[idx & 0xF0], idx & 0xF)
#define DEO(idx) deo_map[idx >> 4](&device_data[idx & 0xF0], idx & 0xF)

void
uxn_eval(u16 pc_pos) {
    if (!pc_pos || device_data[0xf]) {
        return;
    }
    u8 *pc = &uxn_ram[pc_pos];
    while (true) {
        switch (*pc++) {
            case 0x00: /* BRK    */ { return; } break;
            case 0x20: /* JCI    */ { u8 cond = POP(w); s16 off = PEEK2(pc); pc += 2; if (cond) { pc += off;  } } break;
            case 0x40: /* JMI    */ { s16 off = PEEK2(pc); pc += off + 2; } break;
            case 0x60: /* JSI    */ { u16 pc_off = pc - uxn_ram + 2; s16 off = PEEK2(pc); PUSH2(r, pc_off); pc += off + 2;  } break;
            case 0x80: /* LIT    */ { u8 val = PEEK(pc); pc += 1; PUSH(w, val); } break;
            case 0xa0: /* LIT2   */ { u16 val = PEEK2(pc); pc += 2; PUSH2(w, val); } break;
            case 0xc0: /* LITr   */ { u8 val = PEEK(pc); pc += 1; PUSH(r, val); } break;
            case 0xe0: /* LIT2r  */ { u16 val = PEEK2(pc); pc += 2; PUSH2(r, val); } break;
            case 0x01: /* INC    */ { u8 val = PEEK(w - 1) + 1; POKE(w - 1, val); } break;
            case 0x21: /* INC2   */ { u16 val = PEEK2(w - 2) + 1; POKE2(w - 2, val); } break;
            case 0x02: /* POP    */ { w--; } break;
            case 0x22: /* POP2   */ { w -= 2; } break;
            case 0x03: /* NIP    */ { u8 a = POP(w); w--; PUSH(w, a); } break;
            case 0x23: /* NIP2   */ { u16 a = POP2(w); w -= 2; PUSH2(w, a); } break;
            case 0x04: /* SWP    */ { u8 b = POP(w); u8 a = POP(w); PUSH(w, b); PUSH(w, a); } break;
            case 0x24: /* SWP2   */ { u16 b = POP2(w); u16 a = POP2(w); PUSH2(w, b); PUSH2(w, a); } break;
            case 0x05: /* ROT    */ { u8 c = POP(w); u8 b = POP(w); u8 a = POP(w); PUSH(w, b); PUSH(w, c); PUSH(w, a); } break;
            case 0x25: /* ROT2   */ { u16 c = POP2(w); u16 b = POP2(w); u16 a = POP2(w); PUSH2(w, b); PUSH2(w, c); PUSH2(w, a); } break;
            case 0x06: /* DUP    */ { u8 a = PEEK(w - 1); PUSH(w, a); } break;
            case 0x26: /* DUP2   */ { u16 a = PEEK2(w - 2); PUSH2(w, a); } break;
            case 0x07: /* OVR    */ { u8 b = POP(w); u8 a = POP(w); PUSH(w, a); PUSH(w, b); PUSH(w, a); } break;
            case 0x27: /* OVR2   */ { u16 b = POP2(w); u16 a = POP2(w); PUSH2(w, a); PUSH2(w, b); PUSH2(w, a); } break;
            case 0x08: /* EQU    */ { u8 b = POP(w); u8 a = POP(w); if (a == b) { PUSH(w, 1); } else { PUSH(w, 0); } } break;
            case 0x28: /* EQU2   */ { u16 b = POP2(w); u16 a = POP2(w); if (a == b) { PUSH(w, 1); } else { PUSH(w, 0); } } break;
            case 0x09: /* NEQ    */ { u8 b = POP(w); u8 a = POP(w); if (a != b) { PUSH(w, 1); } else { PUSH(w, 0); } } break;
            case 0x29: /* NEQ2   */ { u16 b = POP2(w); u16 a = POP2(w); if (a != b) { PUSH(w, 1); } else { PUSH(w, 0); } } break;
            case 0x0a: /* GTH    */ { u8 b = POP(w); u8 a = POP(w); if (a >  b) { PUSH(w, 1); } else { PUSH(w, 0); } } break;
            case 0x2a: /* GTH2   */ { u16 b = POP2(w); u16 a = POP2(w); if (a >  b) { PUSH(w, 1); } else { PUSH(w, 0); } } break;
            case 0x0b: /* LTH    */ { u8 b = POP(w); u8 a = POP(w); if (a <  b) { PUSH(w, 1); } else { PUSH(w, 0); } } break;
            case 0x2b: /* LTH2   */ { u16 b = POP2(w); u16 a = POP2(w); if (a <  b) { PUSH(w, 1); } else { PUSH(w, 0); } } break;
            case 0x0c: /* JMP    */ { s8 off = POP(w); pc += off; } break;
            case 0x2c: /* JMP2   */ { u16 off = POP2(w); pc = uxn_ram + off; } break;
            case 0x0d: /* JCN    */ { s8 off = POP(w); u8 cond = POP(w); if (cond) { pc += off; } } break;
            case 0x2d: /* JCN2   */ { u16 off = POP2(w); u8 cond = POP(w); if (cond) { pc = uxn_ram + off; } } break;
            case 0x0e: /* JSR    */ { u16 pc_off = pc - uxn_ram; s8 off = POP(w); pc += off; PUSH2(r, pc_off); } break;
            case 0x2e: /* JSR2   */ { u16 pc_off = pc - uxn_ram; u16 off = POP2(w); pc = uxn_ram + off; PUSH2(r, pc_off); } break;
            case 0x0f: /* STH    */ { u8 a = POP(w); PUSH(r, a); } break;
            case 0x2f: /* STH2   */ { u16 a = POP2(w); PUSH2(r, a); } break;
            case 0x10: /* LDZ    */ { u8 off = POP(w); u8 val = PEEK(uxn_ram + off); PUSH(w, val); } break;
            case 0x30: /* LDZ2   */ { u8 off = POP(w); u16 val = PEEK2(uxn_ram + off); PUSH2(w, val); } break;
            case 0x11: /* STZ    */ { u8 off = POP(w); u8 val = POP(w); POKE(uxn_ram + off, val); } break;
            case 0x31: /* STZ2   */ { u8 off = POP(w); u16 val = POP2(w); POKE2(uxn_ram + off, val); } break;
            case 0x12: /* LDR    */ { s8 off = POP(w); u8 val = PEEK(pc + off); PUSH(w, val); } break;
            case 0x32: /* LDR2   */ { s8 off = POP(w); u16 val = PEEK2(pc + off); PUSH2(w, val); } break;
            case 0x13: /* STR    */ { s8 off = POP(w); u8 val = POP(w); POKE(pc + off, val); } break;
            case 0x33: /* STR2   */ { s8 off = POP(w); u16 val = POP2(w); POKE2(pc + off, val); } break;
            case 0x14: /* LDA    */ { u16 off = POP2(w); u8 val = PEEK(uxn_ram + off); PUSH(w, val); } break;
            case 0x34: /* LDA2   */ { u16 off = POP2(w); u16 val = PEEK2(uxn_ram + off); PUSH2(w, val); } break;
            case 0x15: /* STA    */ { u16 off = POP2(w); u8 val = POP(w); POKE(uxn_ram + off, val); } break;
            case 0x35: /* STA2   */ { u16 off = POP2(w); u16 val = POP2(w); POKE2(uxn_ram + off, val); } break;
            case 0x16: /* DEI    */ { u8 dev = POP(w); u8 val = DEI(dev); PUSH(w, val); } break;
            case 0x36: /* DEI2   */ { u8 dev = POP(w); u16 val = DEI(dev); PUSH2(w, val); } break;
            case 0x17: /* DEO    */ { u8 dev = POP(w); u8 val = POP(w); POKE(device_data + dev, val); DEO(dev); } break;
            case 0x37: /* DEO2   */ { u8 dev = POP(w); u16 val = POP2(w); POKE2(device_data + dev, val); DEO(dev); } break;
            case 0x18: /* ADD    */ { u8 b = POP(w); u8 a = POP(w); PUSH(w, a + b); } break;
            case 0x38: /* ADD2   */ { u16 b = POP2(w); u16 a = POP2(w); PUSH2(w, a + b); } break;
            case 0x19: /* SUB    */ { u8 b = POP(w); u8 a = POP(w); PUSH(w, a - b); } break;
            case 0x39: /* SUB2   */ { u16 b = POP2(w); u16 a = POP2(w); PUSH2(w, a - b); } break;
            case 0x1a: /* MUL    */ { u8 b = POP(w); u8 a = POP(w); PUSH(w, a * b); } break;
            case 0x3a: /* MUL2   */ { u16 b = POP2(w); u16 a = POP2(w); PUSH2(w, a * b); } break;
            case 0x1b: /* DIV    */ { u8 b = POP(w); u8 a = POP(w); PUSH(w, a / b); } break;
            case 0x3b: /* DIV2   */ { u16 b = POP2(w); u16 a = POP2(w); PUSH2(w, a / b); } break;
            case 0x1c: /* AND    */ { u8 b = POP(w); u8 a = POP(w); PUSH(w, a & b); } break;
            case 0x3c: /* AND2   */ { u16 b = POP2(w); u16 a = POP2(w); PUSH2(w, a & b); } break;
            case 0x1d: /* ORA    */ { u8 b = POP(w); u8 a = POP(w); PUSH(w, a | b); } break;
            case 0x3d: /* ORA2   */ { u16 b = POP2(w); u16 a = POP2(w); PUSH2(w, a | b); } break;
            case 0x1e: /* EOR    */ { u8 b = POP(w); u8 a = POP(w); PUSH(w, a ^ b); } break;
            case 0x3e: /* EOR2   */ { u16 b = POP2(w); u16 a = POP2(w); PUSH2(w, a ^ b); } break;
            case 0x1f: /* SFT    */ { u8 shift = POP(w); u8 val = POP(w); u8 shift_left = shift >> 4; u8 shift_right = shift & 0xF; val >>= shift_right; val <<= shift_left; PUSH(w, val); } break;
            case 0x3f: /* SFT2   */ { u8 shift = POP(w); u16 val = POP2(w); u8 shift_left = shift >> 4; u8 shift_right = shift & 0xF; val >>= shift_right; val <<= shift_left; PUSH2(w, val); } break;
            case 0x81: /* INCk   */ { u8 a = PEEK(w - 1) + 1; PUSH(w, a); } break;
            case 0xa1: /* INC2k  */ { u16 a = PEEK2(w - 2) + 1; PUSH2(w, a); } break;
            case 0x82: /* POPk   */ { return; } break;
            case 0xa2: /* POP2k  */ { return; } break;
            case 0x83: /* NIPk   */ { u8 a = PEEK(w - 1); PUSH(w, a); } break;
            case 0xa3: /* NIP2k  */ { u16 a = PEEK2(w - 2); PUSH2(w, a); } break;
            case 0x84: /* SWPk   */ { u8 b = PEEK(w - 1); u8 a = PEEK(w - 2); PUSH(w, b); PUSH(w, a); } break;
            case 0xa4: /* SWP2k  */ { u16 b = PEEK2(w - 2); u16 a = PEEK2(w - 4); PUSH2(w, b); PUSH2(w, a); } break;
            case 0x85: /* ROTk   */ { u8 c = PEEK(w - 1); u8 b = PEEK(w - 2); u8 a = PEEK(w - 3); PUSH(w, b); PUSH(w, c); PUSH(w, a); } break;
            case 0xa5: /* ROT2k  */ { u16 c = PEEK2(w - 2); u16 b = PEEK2(w - 4); u16 a = PEEK2(w - 6); PUSH2(w, b); PUSH2(w, c); PUSH2(w, a); } break;
            case 0x86: /* DUPk   */ { u8 a = PEEK(w - 1); PUSH(w, a); PUSH(w, a); } break;
            case 0xa6: /* DUP2k  */ { u16 a = PEEK2(w - 2); PUSH2(w, a); PUSH2(w, a); } break;
            case 0x87: /* OVRk   */ { u8 b = PEEK(w - 1); u8 a = PEEK(w - 2); PUSH(w, a); PUSH(w, b); PUSH(w, a); } break;
            case 0xa7: /* OVR2k  */ { u16 b = PEEK2(w - 2); u16 a = PEEK2(w - 4); PUSH2(w, a); PUSH2(w, b); PUSH2(w, a); } break;
            case 0x88: /* EQUk   */ { u8 b = PEEK(w - 1); u8 a = PEEK(w - 2); if (a == b) { PUSH(w, 1); } else { PUSH(w, 0); } } break;
            case 0xa8: /* EQU2k  */ { u16 b = PEEK2(w - 2); u16 a = PEEK2(w - 4); if (a == b) { PUSH(w, 1); } else { PUSH(w, 0); } } break;
            case 0x89: /* NEQk   */ { u8 b = PEEK(w - 1); u8 a = PEEK(w - 2); if (a != b) { PUSH(w, 1); } else { PUSH(w, 0); } } break;
            case 0xa9: /* NEQ2k  */ { u16 b = PEEK2(w - 2); u16 a = PEEK2(w - 4); if (a != b) { PUSH(w, 1); } else { PUSH(w, 0); } } break;
            case 0x8a: /* GTHk   */ { u8 b = PEEK(w - 1); u8 a = PEEK(w - 2); if (a >  b) { PUSH(w, 1); } else { PUSH(w, 0); } } break;
            case 0xaa: /* GTH2k  */ { u16 b = PEEK2(w - 2); u16 a = PEEK2(w - 4); if (a >  b) { PUSH(w, 1); } else { PUSH(w, 0); } } break;
            case 0x8b: /* LTHk   */ { u8 b = PEEK(w - 1); u8 a = PEEK(w - 2); if (a <  b) { PUSH(w, 1); } else { PUSH(w, 0); } } break;
            case 0xab: /* LTH2k  */ { u16 b = PEEK2(w - 2); u16 a = PEEK2(w - 4); if (a <  b) { PUSH(w, 1); } else { PUSH(w, 0); } } break;
            case 0x8c: /* JMPk   */ { s8 off = PEEK(w - 1); pc += off; } break;
            case 0xac: /* JMP2k  */ { u16 off = PEEK2(w - 2); pc = uxn_ram + off; } break;
            case 0x8d: /* JCNk   */ { s8 off = PEEK(w - 1); u8 cond = PEEK(w - 2); if (cond) { pc += off; } } break;
            case 0xad: /* JCN2k  */ { u16 off = PEEK2(w - 2); u8 cond = PEEK(w - 2); if (cond) { pc = uxn_ram + off; } } break;
            case 0x8e: /* JSRk   */ { u16 pc_off = pc - uxn_ram; s8 off = PEEK(w - 1); pc += off; PUSH2(r, pc_off); } break;
            case 0xae: /* JSR2k  */ { u16 pc_off = pc - uxn_ram; u16 off = PEEK2(w - 2); pc = uxn_ram + off; PUSH2(r, pc_off); } break;
            case 0x8f: /* STHk   */ { u8 val = PEEK(w - 1); PUSH(r, val); } break;
            case 0xaf: /* STH2k  */ { u16 val = PEEK2(w - 2); PUSH2(r, val); } break;
            case 0x90: /* LDZk   */ { u8 off = PEEK(w - 1); u8 val = PEEK(uxn_ram + off); PUSH(w, val); } break;
            case 0xb0: /* LDZ2k  */ { u8 off = PEEK(w - 1); u16 val = PEEK2(uxn_ram + off); PUSH2(w, val); } break;
            case 0x91: /* STZk   */ { u8 off = PEEK(w - 1); u8 val = PEEK(w - 2); POKE(uxn_ram + off, val); } break;
            case 0xb1: /* STZ2k  */ { u8 off = PEEK(w - 1); u16 val = PEEK2(w - 4); POKE2(uxn_ram + off, val); } break;
            case 0x92: /* LDRk   */ { s8 off = PEEK(w - 1); u8 val = PEEK(pc + off); PUSH(w, val); } break;
            case 0xb2: /* LDR2k  */ { s8 off = PEEK(w - 1); u16 val = PEEK2(pc + off); PUSH2(w, val); } break;
            case 0x93: /* STRk   */ { s8 off = PEEK(w - 1); u8 val = PEEK(w - 2); POKE(pc + off, val); } break;
            case 0xb3: /* STR2k  */ { s8 off = PEEK(w - 1); u16 val = PEEK2(w - 4); POKE2(pc + off, val); } break;
            case 0x94: /* LDAk   */ { u16 off = PEEK2(w - 2); u8 val = PEEK(uxn_ram + off); PUSH(w, val); } break;
            case 0xb4: /* LDA2k  */ { u16 off = PEEK2(w - 2); u16 val = PEEK2(uxn_ram + off); PUSH2(w, val); } break;
            case 0x95: /* STAk   */ { u16 off = PEEK2(w - 2); u8 val = PEEK(w - 2); POKE(uxn_ram + off, val); } break;
            case 0xb5: /* STA2k  */ { u16 off = PEEK2(w - 2); u16 val = PEEK2(w - 4); POKE2(uxn_ram + off, val); } break;
            case 0x96: /* DEIk   */ { u8 dev = PEEK(w - 1); u8 val =  DEI(dev); PUSH(w, val); } break;
            case 0xb6: /* DEI2k  */ { u8 dev = PEEK(w - 1); u16 val = DEI(dev); PUSH2(w, val); } break;
            case 0x97: /* DEOk   */ { u8 dev = PEEK(w - 1); u8 val = PEEK(w - 2); POKE(device_data + dev, val); DEO(dev); } break;
            case 0xb7: /* DEO2k  */ { u8 dev = PEEK(w - 1); u16 val = PEEK2(w - 3); POKE2(device_data + dev, val); DEO(dev); } break;
            case 0x98: /* ADDk   */ { u8 b = PEEK(w - 1); u8 a = PEEK(w - 2); PUSH(w, a + b); } break;
            case 0xb8: /* ADD2k  */ { u16 b = PEEK2(w - 2); u16 a = PEEK2(w - 4); PUSH2(w, a + b); } break;
            case 0x99: /* SUBk   */ { u8 b = PEEK(w - 1); u8 a = PEEK(w - 2); PUSH(w, a - b); } break;
            case 0xb9: /* SUB2k  */ { u16 b = PEEK2(w - 2); u16 a = PEEK2(w - 4); PUSH2(w, a - b); } break;
            case 0x9a: /* MULk   */ { u8 b = PEEK(w - 1); u8 a = PEEK(w - 2); PUSH(w, a * b); } break;
            case 0xba: /* MUL2k  */ { u16 b = PEEK2(w - 2); u16 a = PEEK2(w - 4); PUSH2(w, a * b); } break;
            case 0x9b: /* DIVk   */ { u8 b = PEEK(w - 1); u8 a = PEEK(w - 2); PUSH(w, a / b); } break;
            case 0xbb: /* DIV2k  */ { u16 b = PEEK2(w - 2); u16 a = PEEK2(w - 4); PUSH2(w, a / b); } break;
            case 0x9c: /* ANDk   */ { u8 b = PEEK(w - 1); u8 a = PEEK(w - 2); PUSH(w, a & b); } break;
            case 0xbc: /* AND2k  */ { u16 b = PEEK2(w - 2); u16 a = PEEK2(w - 4); PUSH2(w, a & b); } break;
            case 0x9d: /* ORAk   */ { u8 b = PEEK(w - 1); u8 a = PEEK(w - 2); PUSH(w, a | b); } break;
            case 0xbd: /* ORA2k  */ { u16 b = PEEK2(w - 2); u16 a = PEEK2(w - 4); PUSH2(w, a | b); } break;
            case 0x9e: /* EORk   */ { u8 b = PEEK(w - 1); u8 a = PEEK(w - 2); PUSH(w, a ^ b); } break;
            case 0xbe: /* EOR2k  */ { u16 b = PEEK2(w - 2); u16 a = PEEK2(w - 4); PUSH2(w, a ^ b); } break;
            case 0x9f: /* SFTk   */ { u8 shift = PEEK(w - 1); u8 val = PEEK(w - 2); u8 shift_left = shift >> 4; u8 shift_right = shift & 0xF; val >>= shift_right; val <<= shift_left; PUSH(w, val); } break;
            case 0xbf: /* SFT2k  */ { u8 shift = PEEK(w - 1); u16 val = PEEK2(w - 4); u8 shift_left = shift >> 4; u8 shift_right = shift & 0xF; val >>= shift_right; val <<= shift_left; PUSH2(w, val); } break;
            case 0x41: /* INCr   */ { u8 val = PEEK(r - 1) + 1; POKE(r - 1, val); } break;
            case 0x61: /* INC2r  */ { u16 val = PEEK2(r - 2) + 1; POKE2(r - 2, val); } break;
            case 0x42: /* POPr   */ { r--; } break;
            case 0x62: /* POP2r  */ { r -= 2; } break;
            case 0x43: /* NIPr   */ { u8 a = POP(r); r--; PUSH(r, a); } break;
            case 0x63: /* NIP2r  */ { u16 a = POP2(r); r -= 2; PUSH2(r, a); } break;
            case 0x44: /* SWPr   */ { u8 b = POP(r); u8 a = POP(r); PUSH(r, b); PUSH(r, a); } break;
            case 0x64: /* SWP2r  */ { u16 b = POP2(r); u16 a = POP2(r); PUSH2(r, b); PUSH2(r, a); } break;
            case 0x45: /* ROTr   */ { u8 c = POP(r); u8 b = POP(r); u8 a = POP(r); PUSH(r, b); PUSH(r, c); PUSH(r, a); } break;
            case 0x65: /* ROT2r  */ { u16 c = POP2(r); u16 b = POP2(r); u16 a = POP2(r); PUSH2(r, b); PUSH2(r, c); PUSH2(r, a); } break;
            case 0x46: /* DUPr   */ { u8 a = PEEK(r - 1); PUSH(r, a); } break;
            case 0x66: /* DUP2r  */ { u16 a = PEEK2(r - 2); PUSH2(r, a); } break;
            case 0x47: /* OVRr   */ { u8 b = POP(r); u8 a = POP(r); PUSH(r, a); PUSH(r, b); PUSH(r, a); } break;
            case 0x67: /* OVR2r  */ { u16 b = POP2(r); u16 a = POP2(r); PUSH2(r, a); PUSH2(r, b); PUSH2(r, a); } break;
            case 0x48: /* EQUr   */ { u8 b = POP(r); u8 a = POP(r); if (a == b) { PUSH(r, 1); } else { PUSH(r, 0); } } break;
            case 0x68: /* EQU2r  */ { u16 b = POP2(r); u16 a = POP2(r); if (a == b) { PUSH(r, 1); } else { PUSH(r, 0); } } break;
            case 0x49: /* NEQr   */ { u8 b = POP(r); u8 a = POP(r); if (a != b) { PUSH(r, 1); } else { PUSH(r, 0); } } break;
            case 0x69: /* NEQ2r  */ { u16 b = POP2(r); u16 a = POP2(r); if (a != b) { PUSH(r, 1); } else { PUSH(r, 0); } } break;
            case 0x4a: /* GTHr   */ { u8 b = POP(r); u8 a = POP(r); if (a >  b) { PUSH(r, 1); } else { PUSH(r, 0); } } break;
            case 0x6a: /* GTH2r  */ { u16 b = POP2(r); u16 a = POP2(r); if (a >  b) { PUSH(r, 1); } else { PUSH(r, 0); } } break;
            case 0x4b: /* LTHr   */ { u8 b = POP(r); u8 a = POP(r); if (a <  b) { PUSH(r, 1); } else { PUSH(r, 0); } } break;
            case 0x6b: /* LTH2r  */ { u16 b = POP2(r); u16 a = POP2(r); if (a <  b) { PUSH(r, 1); } else { PUSH(r, 0); } } break;
            case 0x4c: /* JMPr   */ { s8 off = POP(r); pc += off; } break;
            case 0x6c: /* JMP2r  */ { u16 off = POP2(r); pc = uxn_ram + off; } break;
            case 0x4d: /* JCNr   */ { s8 off = POP(r); u8 cond = POP(r); if (cond) { pc += off; } } break;
            case 0x6d: /* JCN2r  */ { u16 off = POP2(r); u8 cond = POP(r); if (cond) { pc = uxn_ram + off; } } break;
            case 0x4e: /* JSRr   */ { u16 pc_off = pc - uxn_ram; s8 off = POP(r); pc += off; PUSH2(r, pc_off); } break;
            case 0x6e: /* JSR2r  */ { u16 pc_off = pc - uxn_ram; u16 off = POP2(r); pc = uxn_ram + off; PUSH2(r, pc_off); } break;
            case 0x4f: /* STHr   */ { u8 a = POP(r); PUSH(w, a); } break;
            case 0x6f: /* STH2r  */ { u16 a = POP2(r); PUSH2(w, a); } break;
            case 0x50: /* LDZr   */ { u8 off = POP(r); u8 val = PEEK(uxn_ram + off); PUSH(r, val); } break;
            case 0x70: /* LDZ2r  */ { u8 off = POP(r); u16 val = PEEK2(uxn_ram + off); PUSH2(r, val); } break;
            case 0x51: /* STZr   */ { u8 off = POP(r); u8 val = POP(r); POKE(uxn_ram + off, val); } break;
            case 0x71: /* STZ2r  */ { u8 off = POP(r); u16 val = POP2(r); POKE2(uxn_ram + off, val); } break;
            case 0x52: /* LDRr   */ { s8 off = POP(r); u8 val = PEEK(pc + off); PUSH(r, val); } break;
            case 0x72: /* LDR2r  */ { s8 off = POP(r); u16 val = PEEK2(pc + off); PUSH2(r, val); } break;
            case 0x53: /* STRr   */ { s8 off = POP(r); u8 val = POP(r); POKE(pc + off, val); } break;
            case 0x73: /* STR2r  */ { s8 off = POP(r); u16 val = POP2(r); POKE2(pc + off, val); } break;
            case 0x54: /* LDAr   */ { u16 off = POP2(r); u8 val = PEEK(uxn_ram + off); PUSH(r, val); } break;
            case 0x74: /* LDA2r  */ { u16 off = POP2(r); u16 val = PEEK2(uxn_ram + off); PUSH2(r, val); } break;
            case 0x55: /* STAr   */ { u16 off = POP2(r); u8 val = POP(r); POKE(uxn_ram + off, val); } break;
            case 0x75: /* STA2r  */ { u16 off = POP2(r); u16 val = POP2(r); POKE2(uxn_ram + off, val); } break;
            case 0x56: /* DEIr   */ { u8 dev = POP(r); u8 val = DEI(dev); PUSH(r, val); } break;
            case 0x76: /* DEI2r  */ { u8 dev = POP(r); u16 val = DEI(dev); PUSH2(r, val); } break;
            case 0x57: /* DEOr   */ { u8 dev = POP(r); u8 val = POP(r); POKE(device_data + dev, val); DEO(dev); } break;
            case 0x77: /* DEO2r  */ { u8 dev = POP2(r); u16 val = POP2(r); POKE2(device_data + dev, val); DEO(dev); } break;
            case 0x58: /* ADDr   */ { u8 b = POP(r); u8 a = POP(r); PUSH(r, a + b); } break;
            case 0x78: /* ADD2r  */ { u16 b = POP2(r); u16 a = POP2(r); PUSH2(r, a + b); } break;
            case 0x59: /* SUBr   */ { u8 b = POP(r); u8 a = POP(r); PUSH(r, a - b); } break;
            case 0x79: /* SUB2r  */ { u16 b = POP2(r); u16 a = POP2(r); PUSH2(r, a - b); } break;
            case 0x5a: /* MULr   */ { u8 b = POP(r); u8 a = POP(r); PUSH(r, a * b); } break;
            case 0x7a: /* MUL2r  */ { u16 b = POP2(r); u16 a = POP2(r); PUSH2(r, a * b); } break;
            case 0x5b: /* DIVr   */ { u8 b = POP(r); u8 a = POP(r); PUSH(r, a / b); } break;
            case 0x7b: /* DIV2r  */ { u16 b = POP2(r); u16 a = POP2(r); PUSH2(r, a / b); } break;
            case 0x5c: /* ANDr   */ { u8 b = POP(r); u8 a = POP(r); PUSH(r, a & b); } break;
            case 0x7c: /* AND2r  */ { u16 b = POP2(r); u16 a = POP2(r); PUSH2(r, a & b); } break;
            case 0x5d: /* ORAr   */ { u8 b = POP(r); u8 a = POP(r); PUSH(r, a | b); } break;
            case 0x7d: /* ORA2r  */ { u16 b = POP2(r); u16 a = POP2(r); PUSH2(r, a | b); } break;
            case 0x5e: /* EORr   */ { u8 b = POP(r); u8 a = POP(r); PUSH(r, a ^ b); } break;
            case 0x7e: /* EOR2r  */ { u16 b = POP2(r); u16 a = POP2(r); PUSH2(r, a ^ b); } break;
            case 0x5f: /* SFTr   */ { u8 shift = POP(r); u8 val = POP(r); u8 shift_left = shift >> 4; u8 shift_right = shift & 0xF; val >>= shift_right; val <<= shift_left; PUSH(r, val); } break;
            case 0x7f: /* SFT2r  */ { u8 shift = POP(r); u16 val = POP2(r); u8 shift_left = shift >> 4; u8 shift_right = shift & 0xF; val >>= shift_right; val <<= shift_left; PUSH2(r, val); } break;
            case 0xc1: /* INCkr  */ { u8 a = PEEK(r - 1) + 1; PUSH(r, a); } break;
            case 0xe1: /* INC2kr */ { u16 a = PEEK2(r - 2) + 1; PUSH2(r, a); } break;
            case 0xc2: /* POPkr  */ { return; } break;
            case 0xe2: /* POP2kr */ { return; } break;
            case 0xc3: /* NIPkr  */ { u8 a = PEEK(r - 1); PUSH(r, a); } break;
            case 0xe3: /* NIP2kr */ { u16 a = PEEK2(r - 2); PUSH2(r, a); } break;
            case 0xc4: /* SWPkr  */ { u8 b = PEEK(r - 1); u8 a = PEEK(r - 2); PUSH(r, b); PUSH(r, a); } break;
            case 0xe4: /* SWP2kr */ { u16 b = PEEK2(r - 2); u16 a = PEEK2(r - 4); PUSH2(r, b); PUSH2(r, a); } break;
            case 0xc5: /* ROTkr  */ { u8 c = PEEK(r - 1); u8 b = PEEK(r - 2); u8 a = PEEK(r - 3); PUSH(r, b); PUSH(r, c); PUSH(r, a); } break;
            case 0xe5: /* ROT2kr */ { u16 c = PEEK2(r - 2); u16 b = PEEK2(r - 4); u16 a = PEEK2(r - 6); PUSH2(r, b); PUSH2(r, c); PUSH2(r, a); } break;
            case 0xc6: /* DUPkr  */ { u8 a = PEEK(r - 1); PUSH(r, a); PUSH(r, a); } break;
            case 0xe6: /* DUP2kr */ { u16 a = PEEK2(r - 2); PUSH2(r, a); PUSH2(r, a); } break;
            case 0xc7: /* OVRkr  */ { u8 b = PEEK(r - 1); u8 a = PEEK(r - 2); PUSH(r, a); PUSH(r, b); PUSH(r, a); } break;
            case 0xe7: /* OVR2kr */ { u16 b = PEEK2(r - 2); u16 a = PEEK2(r - 4); PUSH2(r, a); PUSH2(r, b); PUSH2(r, a); } break;
            case 0xc8: /* EQUkr  */ { u8 b = PEEK(r - 1); u8 a = PEEK(r - 2); if (a == b) { PUSH(r, 1); } else { PUSH(r, 0); } } break;
            case 0xe8: /* EQU2kr */ { u16 b = PEEK2(r - 2); u16 a = PEEK2(r - 4); if (a == b) { PUSH(r, 1); } else { PUSH(r, 0); } } break;
            case 0xc9: /* NEQkr  */ { u8 b = PEEK(r - 1); u8 a = PEEK(r - 2); if (a != b) { PUSH(r, 1); } else { PUSH(r, 0); } } break;
            case 0xe9: /* NEQ2kr */ { u16 b = PEEK2(r - 2); u16 a = PEEK2(r - 4); if (a != b) { PUSH(r, 1); } else { PUSH(r, 0); } } break;
            case 0xca: /* GTHkr  */ { u8 b = PEEK(r - 1); u8 a = PEEK(r - 2); if (a >  b) { PUSH(r, 1); } else { PUSH(r, 0); } } break;
            case 0xea: /* GTH2kr */ { u16 b = PEEK2(r - 2); u16 a = PEEK2(r - 4); if (a >  b) { PUSH(r, 1); } else { PUSH(r, 0); } } break;
            case 0xcb: /* LTHkr  */ { u8 b = PEEK(r - 1); u8 a = PEEK(r - 2); if (a <  b) { PUSH(r, 1); } else { PUSH(r, 0); } } break;
            case 0xeb: /* LTH2kr */ { u16 b = PEEK2(r - 2); u16 a = PEEK2(r - 4); if (a <  b) { PUSH(r, 1); } else { PUSH(r, 0); } } break;
            case 0xcc: /* JMPkr  */ { s8 off = PEEK(r - 1); pc += off; } break;
            case 0xec: /* JMP2kr */ { u16 off = PEEK2(r - 2); pc = uxn_ram + off; } break;
            case 0xcd: /* JCNkr  */ { s8 off = PEEK(r - 1); u8 cond = PEEK(r - 2); if (cond) { pc += off; } } break;
            case 0xed: /* JCN2kr */ { u16 off = PEEK2(r - 2); u8 cond = PEEK(r - 2); if (cond) { pc = uxn_ram + off; } } break;
            case 0xce: /* JSRkr  */ { u16 pc_off = pc - uxn_ram; s8 off = PEEK(r - 1); pc += off; PUSH2(r, pc_off); } break;
            case 0xee: /* JSR2kr */ { u16 pc_off = pc - uxn_ram; u16 off = PEEK2(r - 2); pc = uxn_ram + off; PUSH2(r, pc_off); } break;
            case 0xcf: /* STHkr  */ { u8 val = PEEK(r - 1); PUSH(w, val); } break;
            case 0xef: /* STH2kr */ { u16 val = PEEK2(r - 2); PUSH2(w, val); } break;
            case 0xd0: /* LDZkr  */ { u8 off = PEEK(r - 1); u8 val = PEEK(uxn_ram + off); PUSH(r, val); } break;
            case 0xf0: /* LDZ2kr */ { u8 off = PEEK(r - 1); u16 val = PEEK2(uxn_ram + off); PUSH2(r, val); } break;
            case 0xd1: /* STZkr  */ { u8 off = PEEK(r - 1); u8 val = PEEK(r - 2); POKE(uxn_ram + off, val); } break;
            case 0xf1: /* STZ2kr */ { u8 off = PEEK(r - 1); u16 val = PEEK2(r - 4); POKE2(uxn_ram + off, val); } break;
            case 0xd2: /* LDRkr  */ { s8 off = PEEK(r - 1); u8 val = PEEK(pc + off); PUSH(r, val); } break;
            case 0xf2: /* LDR2kr */ { s8 off = PEEK(r - 1); u16 val = PEEK2(pc + off); PUSH2(r, val); } break;
            case 0xd3: /* STRkr  */ { s8 off = PEEK(r - 1); u8 val = PEEK(r - 2); POKE(pc + off, val); } break;
            case 0xf3: /* STR2kr */ { s8 off = PEEK(r - 1); u16 val = PEEK2(r - 4); POKE2(pc + off, val); } break;
            case 0xd4: /* LDAkr  */ { u16 off = PEEK2(r - 2); u8 val = PEEK(uxn_ram + off); PUSH(r, val); } break;
            case 0xf4: /* LDA2kr */ { u16 off = PEEK2(r - 2); u16 val = PEEK2(uxn_ram + off); PUSH2(r, val); } break;
            case 0xd5: /* STAkr  */ { u16 off = PEEK2(r - 2); u8 val = PEEK(r - 2); POKE(uxn_ram + off, val); } break;
            case 0xf5: /* STA2kr */ { u16 off = PEEK2(r - 2); u16 val = PEEK2(r - 4); POKE2(uxn_ram + off, val); } break;
            case 0xd6: /* DEIkr  */ { u8 dev = PEEK(r - 1); u8 val = DEI(dev); PUSH(r, val); } break;
            case 0xf6: /* DEI2kr */ { u8 dev = PEEK(r - 1); u16 val = DEI(dev); PUSH2(r, val); } break;
            case 0xd7: /* DEOkr  */ { u8 dev = PEEK(r - 1); u8 val = PEEK(r - 2); POKE(device_data + dev, val); DEO(dev); } break;
            case 0xf7: /* DEO2kr */ { u8 dev = PEEK(r - 1); u16 val = PEEK2(r - 3); POKE2(device_data + dev, val); DEO(dev); } break;
            case 0xd8: /* ADDkr  */ { u8 b = PEEK(r - 1); u8 a = PEEK(r - 2); PUSH(r, a + b); } break;
            case 0xf8: /* ADD2kr */ { u16 b = PEEK2(r - 2); u16 a = PEEK2(r - 4); PUSH2(r, a + b); } break;
            case 0xd9: /* SUBkr  */ { u8 b = PEEK(r - 1); u8 a = PEEK(r - 2); PUSH(r, a - b); } break;
            case 0xf9: /* SUB2kr */ { u16 b = PEEK2(r - 2); u16 a = PEEK2(r - 4); PUSH2(r, a - b); } break;
            case 0xda: /* MULkr  */ { u8 b = PEEK(r - 1); u8 a = PEEK(r - 2); PUSH(r, a * b); } break;
            case 0xfa: /* MUL2kr */ { u16 b = PEEK2(r - 2); u16 a = PEEK2(r - 4); PUSH2(r, a * b); } break;
            case 0xdb: /* DIVkr  */ { u8 b = PEEK(r - 1); u8 a = PEEK(r - 2); PUSH(r, a / b); } break;
            case 0xfb: /* DIV2kr */ { u16 b = PEEK2(r - 2); u16 a = PEEK2(r - 4); PUSH2(r, a / b); } break;
            case 0xdc: /* ANDkr  */ { u8 b = PEEK(r - 1); u8 a = PEEK(r - 2); PUSH(r, a & b); } break;
            case 0xfc: /* AND2kr */ { u16 b = PEEK2(r - 2); u16 a = PEEK2(r - 4); PUSH2(r, a & b); } break;
            case 0xdd: /* ORAkr  */ { u8 b = PEEK(r - 1); u8 a = PEEK(r - 2); PUSH(r, a | b); } break;
            case 0xfd: /* ORA2kr */ { u16 b = PEEK2(r - 2); u16 a = PEEK2(r - 4); PUSH2(r, a | b); } break;
            case 0xde: /* EORkr  */ { u8 b = PEEK(r - 1); u8 a = PEEK(r - 2); PUSH(r, a ^ b); } break;
            case 0xfe: /* EOR2kr */ { u16 b = PEEK2(r - 2); u16 a = PEEK2(r - 4); PUSH2(r, a ^ b); } break;
            case 0xdf: /* SFTkr  */ { u8 shift = PEEK(r - 1); u8 val = PEEK(r - 2); u8 shift_left = shift >> 4; u8 shift_right = shift & 0xF; val >>= shift_right; val <<= shift_left; PUSH(r, val); } break;
            case 0xff: /* SFT2kr */ { u8 shift = PEEK(r - 1); u16 val = PEEK2(r - 4); u8 shift_left = shift >> 4; u8 shift_right = shift & 0xF; val >>= shift_right; val <<= shift_left; PUSH2(r, val); } break;
        }
    }
}