#!/usr/bin/awk -f

# Constants and VM setup
BEGIN {
    IMAGE_SIZE = 524288    # Amount of simulated RAM
    DATA_DEPTH = 8192      # Depth of data stack
    ADDRESS_DEPTH = 32768  # Depth of the stacks
    
    # Initialize stacks
    data_sp = 0
    addr_sp = 0
    
    # VM state
    ip = 0
    
    # Opcode definitions
    OP_NOP = 0
    OP_LIT = 1
    OP_DUP = 2
    OP_DROP = 3
    OP_SWAP = 4
    OP_PUSH = 5
    OP_POP = 6
    OP_JUMP = 7
    OP_CALL = 8
    OP_CCALL = 9
    OP_RETURN = 10
    OP_EQ = 11
    OP_NEQ = 12
    OP_LT = 13
    OP_GT = 14
    OP_FETCH = 15
    OP_STORE = 16
    OP_ADD = 17
    OP_SUB = 18
    OP_MUL = 19
    OP_DIVMOD = 20
    OP_AND = 21
    OP_OR = 22
    OP_XOR = 23
    OP_SHIFT = 24
    OP_ZERO_EXIT = 25
    OP_HALT = 26
    
    # Initialize VM
    prepare_vm()
    
    # Load and run test program
    load_test_program()
    execute(0)
    
    # Print results
    print "Stack contents after execution:"
    print_stack()
}

# Stack operations
function stack_push(stack_name, value) {
    if (stack_name == "data") {
        data_sp++
        data_stack[data_sp] = value
    } else if (stack_name == "addr") {
        addr_sp++
        addr_stack[addr_sp] = value
    }
}

function stack_pop(stack_name) {
    if (stack_name == "data") {
        if (data_sp > 0) {
            value = data_stack[data_sp]
            data_sp--
            return value
        }
    } else if (stack_name == "addr") {
        if (addr_sp > 0) {
            value = addr_stack[addr_sp]
            addr_sp--
            return value
        }
    }
    return 0
}

function stack_tos(stack_name) {
    if (stack_name == "data" && data_sp > 0) {
        return data_stack[data_sp]
    }
    return 0
}

function stack_nos(stack_name) {
    if (stack_name == "data" && data_sp > 1) {
        return data_stack[data_sp - 1]
    }
    return 0
}

# Bitwise operations
function bitwise_and(x, y,    i, result, a, b) {
    result = 0
    for (i = 0; i < 32; i++) {
        a = int(x / (2 ^ i)) % 2
        b = int(y / (2 ^ i)) % 2
        if (a == 1 && b == 1)
            result += 2 ^ i
    }
    return result
}

function bitwise_or(x, y,    i, result, a, b) {
    result = 0
    for (i = 0; i < 32; i++) {
        a = int(x / (2 ^ i)) % 2
        b = int(y / (2 ^ i)) % 2
        if (a == 1 || b == 1)
            result += 2 ^ i
    }
    return result
}

function bitwise_xor(x, y,    i, result, a, b) {
    result = 0
    for (i = 0; i < 32; i++) {
        a = int(x / (2 ^ i)) % 2
        b = int(y / (2 ^ i)) % 2
        if (a != b)
            result += 2 ^ i
    }
    return result
}

# Helper functions
function abs(x) {
    return x < 0 ? -x : x
}

function lshift(x, n) {
    return int(x * (2 ^ n))
}

function rshift(x, n) {
    return int(x / (2 ^ n))
}

# VM core functions
function process_opcode(opcode) {
    if (opcode == OP_NOP) {
        return
    }
    else if (opcode == OP_LIT) {
        ip++
        stack_push("data", image[ip])
    }
    else if (opcode == OP_DUP) {
        stack_push("data", stack_tos("data"))
    }
    else if (opcode == OP_DROP) {
        stack_pop("data")
    }
    else if (opcode == OP_SWAP) {
        temp = stack_pop("data")
        temp2 = stack_pop("data")
        stack_push("data", temp)
        stack_push("data", temp2)
    }
    else if (opcode == OP_ADD) {
        x = stack_pop("data")
        y = stack_pop("data")
        stack_push("data", x + y)
    }
    else if (opcode == OP_SUB) {
        x = stack_pop("data")
        y = stack_pop("data")
        stack_push("data", y - x)
    }
    else if (opcode == OP_MUL) {
        x = stack_pop("data")
        y = stack_pop("data")
        stack_push("data", x * y)
    }
    else if (opcode == OP_HALT) {
        ip = IMAGE_SIZE
    }
}

function check_stack() {
    if (data_sp < 0 || addr_sp < 0 || 
        data_sp > DATA_DEPTH || addr_sp > ADDRESS_DEPTH) {
        ip = 0
        data_sp = 0
        addr_sp = 0
    }
}

function process_packed_opcodes(packed) {
    ops[0] = bitwise_and(packed, 255)
    ops[1] = bitwise_and(rshift(packed, 8), 255)
    ops[2] = bitwise_and(rshift(packed, 16), 255)
    ops[3] = bitwise_and(rshift(packed, 24), 255)
    
    for (i = 0; i < 4; i++) {
        if (ops[i] != 0) {
            process_opcode(ops[i])
        }
    }
}

function execute(offset) {
    addr_sp = 1
    ip = offset
    
    while (ip < IMAGE_SIZE) {
        opcode = image[ip]
        process_packed_opcodes(opcode)
        
        if (addr_sp == 0)
            ip = IMAGE_SIZE
            
        ip++
    }
}

function prepare_vm() {
    ip = 0
    data_sp = 0
    addr_sp = 0
}

# Test program loader
function pack_opcodes(op1, op2, op3, op4) {
    return op1 + (op2 * 256) + (op3 * 65536) + (op4 * 16777216)
}

function load_test_program() {
    # Simple test program that adds 10 and 5
    image[0] = pack_opcodes(OP_LIT, 0, 0, 0)  # Push literal
    image[1] = 10                             # Value 10
    image[2] = pack_opcodes(OP_LIT, 0, 0, 0)  # Push literal
    image[3] = 5                              # Value 5
    image[4] = pack_opcodes(OP_ADD, 0, 0, 0)  # Add them
    image[5] = pack_opcodes(OP_HALT, 0, 0, 0) # Halt
}

# Debug helper
function print_stack() {
    for (i = 1; i <= data_sp; i++) {
        print "Item", i ":", data_stack[i]
    }
}