#include <stdio.h>
#include <stdint.h>
#include <string.h>
#include <stdbool.h>

static uint8_t code[] = {
    0x00,0x02,0x87,0xe8,0x00,0x12,0xf8,0xfb,
    0x00,0x22,0x49,0x37,0x00,0x32,0x1f,0x4e,
    0x07,0x32,0x80,0x89,0x01,0x32,0x66,0x4c,
    0x05,0xc3,0x05,0xf3,0x01,0x12,0x73,0xa9,
    0x07,0x22,0x9b,0xe5,0x03,0x83,0x06,0x12,
    0xb3,0xb6,0x05,0x02,0xa8,0x7b,0x05,0xf3,
    0x00,0x32,0x0a,0x00,0x03,0x93,0x03,0x22,
    0x69,0x76,0x04,0x01,0x0b,0x31,0x0f,0x00,
    0x10,0x00,0x05,0x12,0xb4,0x36,0x00,0xc3,
    0x07,0x02,0x07,0x35,0x03,0x83,0x05,0x12,
    0x0f,0x64,0x00,0x43,0x03,0xb3,0x08,0x02,
    0x02,0x00,0x05,0x23,0x01,0xb3,0x07,0xc3,
    0x05,0x02,0x5e,0xd6,0x07,0x83,0x06,0x73,
    0x02,0x32,0x80,0x14,0x03,0x12,0x7b,0x4b,
    0x06,0x12,0xa1,0x28,0x01,0x22,0x17,0x30,
    0x02,0xa3,0x00,0x12,0x6d,0xda,0x01,0x53,
    0x02,0x23,0x04,0x11,0x03,0x03,0x07,0x02,
    0x17,0x04,0x03,0xc3,0x03,0x12,0x4b,0xac,
    0x02,0x32,0xce,0x33,0x01,0x03,0x06,0x12,
    0x12,0x8e,
};

static const char *op_names[] = {
    "MOVE", "OR", "XOR", "AND", "NOT", "ADD", "SUB", "MUL", "SHL", "SHR",
    "INC", "DEC", "PUSH", "POP", "CMP", "JNZ", "JZ",
};

typedef struct instruction {
    size_t offset;
    unsigned int opcode;
    unsigned int mode;
    unsigned int rdest;
    unsigned int rsrc;
    uint16_t imm;
} instruction;


int main(void)
{
    static instruction instructions[16384];
    size_t num_instructions = 0;

    for (size_t i = 0; i < sizeof(code); i += 2) {
        unsigned int opt = code[i + 1];

        instruction insn = {
            .offset = i,
            .opcode = code[i],
            .mode = opt & 15,
            .rdest = (opt >> 4) & 3,
            .rsrc = (opt >> 6) & 3,
            .imm = 0xbaadU,
        };

        if (insn.opcode >= sizeof(op_names) / sizeof(op_names[0])) {
            fprintf(stderr, "Wrong opcode %u at %.8zx\n", insn.opcode, insn.offset);
            return 1;
        }

        if (insn.mode >= 4) {
            fprintf(stderr, "Wrong mode %u at %.8zx\n", insn.mode, insn.offset);
            return 1;
        }

        if (insn.mode == 0 || insn.mode == 2) {
            i += 2;
            insn.imm = code[i] | code[i + 1] << 8;
        }
        instructions[num_instructions++] = insn;
    }

    size_t ip = 0;
    uint16_t regs[4] = { 0 };
    uint16_t stack[256];
    size_t stackptr = 0;
    bool zf = false;

    while (ip < num_instructions) {
        instruction *insn = &instructions[ip];
        uint16_t *dest = NULL;
        uint16_t *src = NULL;
        uint16_t imm = insn->imm;

        printf("%.4zx: %s\t", ip, op_names[insn->opcode]);

        switch (insn->mode) {
            case 0: // IMM.
                dest = &imm;
                printf("%.4x\t", insn->imm);
                break;
            case 1: // REG.
                dest = &regs[insn->rdest];
                printf("r%u\t", insn->rdest);
                break;
            case 2: // REG, IMM.
                dest = &regs[insn->rdest];
                src = &imm;
                printf("r%u, %.4x", insn->rdest, insn->imm);
                break;
            case 3: // REG, REG.
                dest = &regs[insn->rdest];
                src = &regs[insn->rsrc];
                printf("r%u, r%u\t", insn->rdest, insn->rsrc);
                break;
        }

        printf(" ; ");
        ++ip;

        switch (insn->opcode) {
            case 0: // MOVE.
                *dest = *src;
                break;
            case 1: // OR.
                *dest = *dest || *src;
                break;
            case 2: // XOR.
                *dest = (*dest || *src) && !(*dest && *src);
                break;
            case 3: // AND.
                *dest = *dest && *src;
                break;
            case 4: // NOT.
                *dest = !*dest;
                break;
            case 5: // ADD.
                *dest += *src;
                break;
            case 6: // SUB.
                *dest -= *src;
                break;
            case 7: // MUL.
                *dest *= *src;
                break;
            case 8: // SHL.
                *dest <<= *src;
                break;
            case 9: // SHR.
                *dest >>= *src;
                break;
            case 10: // INC.
                *dest += 1;
                break;
            case 11: // DEC.
                *dest -= 1;
                break;
            case 12: // PUSH.
                if (stackptr >= sizeof(stack) / sizeof(stack[0])) {
                    fprintf(stderr, "Stack overflow\n");
                    return 2;
                }
                stack[stackptr++] = *dest;
                break;
            case 13: // POP
                if (stackptr == 0) {
                    fprintf(stderr, "Stack underflow\n");
                    return 2;
                }
                *dest = stack[--stackptr];
                break;
            case 14: // CMP.
                zf = (*dest - *src) == 0;
                break;
            case 15: // JNZ.
                if (!zf) {
                    ip = *dest;
                }
                break;
            case 16: // JZ.
                if (zf) {
                    ip = *dest;
                }
                break;
        }

        if (insn->opcode >= 1 && insn->opcode <= 11) {
            zf = *dest == 0;
        }

        printf(" r0 = %.4x, r1 = %.4x, r2 = %.4x, r3 = %.4x, zf = %u\n",
            regs[0], regs[1], regs[2], regs[3], zf);
    }
}
