// -------------------------------------------------------------
// ilo.swift, (c) charles childers
// -------------------------------------------------------------
// compile with:
//
//   swiftc -O vm/ilo.swift -o ilo
// -------------------------------------------------------------

import Foundation


// -------------------------------------------------------------
// Configuration
// -------------------------------------------------------------

let imageSize: Int = 65536
let stackSize: Int = 33
let addressSize: Int = 257


// -------------------------------------------------------------
// Globals
// -------------------------------------------------------------

// +----------+------------------------------------------------+
// | Name     | Contains                                       |
// +==========+================================================+
// | input    | input buffer ("keyboard")                      |
// | ip       | instruction pointer                            |
// | memory   | random access memory                           |
// | data     | data stack                                     |
// | address  | address stack                                  |
// +----------+------------------------------------------------+

var input: String = ""
var ip: Int = 0
var memory = [Int32](repeating: 0, count: imageSize)
var data = Stack(stackSize)
var address = Stack(addressSize)


// -------------------------------------------------------------
// Support Functions
// -------------------------------------------------------------

func getInt32FromData(data: NSData, offset: Int) -> Int32 {
    let raw = NSRange(location: offset * 4, length: 4)
    var i = [Int32](repeating: 0, count: 1)
    data.getBytes(&i, range: raw)
    return Int32(i[0])
}


// -------------------------------------------------------------
// Instructions
// -------------------------------------------------------------

func inst_no() { }
func inst_li() { ip += 1; data.push(memory[ip]) }
func inst_du() { data.push(data.tos()) }
func inst_dr() { data.drop() }
func inst_sw() { data.swap() }
func inst_pu() { address.push(data.pop()) }
func inst_po() { data.push(address.pop()) }
func inst_ju() { ip = Int(data.pop() - 1) }
func inst_ca() { address.push(Int32(ip)); ip = Int(data.pop() - 1) }
func inst_cc() { let dest = data.pop(); if (data.pop() != 0) { address.push(Int32(ip)); ip = Int(dest - 1) } }
func inst_cj() { let dest = data.pop(); if (data.pop() != 0) { ip = Int(dest - 1) } }
func inst_re() { ip = Int(address.pop()) }
func inst_eq() { let tos = data.pop(), nos = data.pop(); data.push((nos == tos) ? -1 : 0) }
func inst_ne() { let tos = data.pop(), nos = data.pop(); data.push((nos != tos) ? -1 : 0) }
func inst_lt() { let tos = data.pop(), nos = data.pop(); data.push((nos < tos) ? -1 : 0) }
func inst_gt() { let tos = data.pop(), nos = data.pop(); data.push((nos > tos) ? -1 : 0) }
func inst_fe() { let target = Int(data.pop()); data.push(memory[target]) }
func inst_st() { let addr = data.pop(), value = data.pop(); memory[Int(addr)] = value }
func inst_ad() { let tos = data.pop(), nos = data.pop(); data.push(nos &+ tos) }
func inst_su() { let tos = data.pop(), nos = data.pop(); data.push(nos &- tos) }
func inst_mu() { let tos = data.pop(), nos = data.pop(); data.push(nos &* tos) }
func inst_di() { let a = data.pop(), b = data.pop(); data.push(b % a); data.push(b / a) }
func inst_an() { let tos = data.pop(), nos = data.pop(); data.push(tos & nos) }
func inst_or() { let tos = data.pop(), nos = data.pop(); data.push(nos | tos) }
func inst_xo() { let tos = data.pop(), nos = data.pop(); data.push(nos ^ tos) }
func inst_sl() { let tos = data.pop(), nos = data.pop(); data.push(nos << tos) }
func inst_sr() { let tos = data.pop(), nos = data.pop(); data.push(nos >> tos) }
func inst_cp() {
    var len = Int(data.pop())
    var dest = Int(data.pop())
    var src = Int(data.pop())
    while (len != 0) {
        if (memory[dest] != memory[src]) { data.push(0); return }
        len -= 1
        dest += 1
        src += 1
    }
    data.push(-1)
}
func inst_cy() {
    var len = Int(data.pop())
    var dest = Int(data.pop())
    var src = Int(data.pop())
    while (len != 0) {
        memory[dest] = memory[src]
        len -= 1
        dest += 1
        src += 1
    }
}
func inst_io() {
    let device = Int(data.pop())
    let devices: [(()->Void)] = [
        io_cput, io_cget, io_rb, io_wb,
        io_si, io_pc, io_of, io_sd]
    if device < 0 || device > 7 { return } 
    devices[device]()
}


// -------------------------------------------------------------
// I/O Operations
// -------------------------------------------------------------

// +----------+------------------------------------------------+
// | Function | Action                                         |
// +==========+================================================+
// | io_cput  | Display a character to standard output         |
// | io_cget  | Read character from standard input source      |
// | io_rb    | Read block from storage                        |
// | io_wb    | Write block to storage                         |
// | io_si    | Save image (not implemented)                   |
// | io_pc    | Reset ilo to default state, restarting         |
// | io_of    | Power off (exit) ilo                           |
// | is_sd    | Return stack depths                            |
// +----------+------------------------------------------------+

func io_cput() {
    let v = UnicodeScalar(Int(data.pop())) ?? UnicodeScalar(32)
    print(Character(v!), terminator: "")
}
func io_cget() {
    if (input.count > 0) {
        let c = input.first!
        guard let v = c.asciiValue else { return }
        data.push(Int32(v))
        input = String(input.dropFirst())
    } else {
        data.push(32)
    }
}
func io_rb() {
    let buffer = data.pop(), block = data.pop()
    load_block(Int(block), to: Int(buffer))
}
func io_wb() {
    let buffer = data.pop(), block = data.pop()
    write_block(Int(block), to: Int(buffer))
}
func io_si() { }
func io_pc() {
    load_image()
    data.empty()
    address.empty()
    ip = -1
}
func io_of() { ip = 65536; exit(0) }
func io_sd() {
    data.push(Int32(data.depth()))
    data.push(Int32(address.depth()))
}


// -------------------------------------------------------------
// Block I/O
// -------------------------------------------------------------

func blocks() -> URL {
    return URL(fileURLWithPath: "./ilo.blocks")
}

func load_block(_ block: Int, to: Int) {
    let storage = blocks()
    let fd = try! FileHandle(forReadingFrom: storage)
    fd.seek(toFileOffset: UInt64(block * 4096))
    let data = fd.readData(ofLength: 4096) as NSData
    for i in 0 ... 1023 {
        memory[to + i] = getInt32FromData(data: data, offset: i)
    }
    fd.closeFile()
}

func write_block(_ block: Int, to: Int) {
    let storage = blocks()
    let fd = try! FileHandle(forUpdating: storage)
    fd.seek(toFileOffset: UInt64(block * 4096))
    for i in 0 ... 1023 {
        let word = Data(bytes: &memory[to + i], count: 4)
        fd.write(word)
    }
    fd.closeFile()
}


// -------------------------------------------------------------
// Instruction Processing
// -------------------------------------------------------------

func process_instruction(opcode: Int32) {
    let instructions: [(()->Void)] = [
        inst_no, inst_li, inst_du, inst_dr, inst_sw,
        inst_pu, inst_po, inst_ju, inst_ca, inst_cc,
        inst_cj, inst_re, inst_eq, inst_ne, inst_lt,
        inst_gt, inst_fe, inst_st, inst_ad, inst_su,
        inst_mu, inst_di, inst_an, inst_or, inst_xo,
        inst_sl, inst_sr, inst_cp, inst_cy, inst_io]
    // skip `no` and invalid opcodes
    if opcode < 1 || opcode > 29 { return } 
    instructions[Int(opcode)]()
}

func process() {
    while input.count > 0 {
        for inst in memory[ip].bytes {
            process_instruction(opcode: Int32(inst))
        }
        ip += 1
    }
}


// -------------------------------------------------------------
// Initialization
// -------------------------------------------------------------

func load_image() {
    let fileURL = URL(fileURLWithPath: "./ilo.rom")
    let data = NSData(contentsOf: fileURL)!
    var i: Int = 0
    while (i < 65536) {
        memory[i] = getInt32FromData(data: data, offset: i)
        i += 1
    }
}

func bootstrap() {
    if memory[0] == 0 {
        load_image()
        ip = 0
        data.empty()
        address.empty()
    }
    input = " "
    process()
}


// -------------------------------------------------------------
// Stacks
// -------------------------------------------------------------

class Stack {
    private var limit: Int
    private var data: [Int32]
    private var sp: Int = 0
    init(_ size: Int) {
        data = [Int32](repeating: 0, count: size)
        limit = size
    }
    public func tos() -> Int32 { return data[sp] }
    public func nos() -> Int32 { return data[sp - 1] }
    public func push(_ n: Int32) { sp += 1; data[sp] = n }
    public func pop() -> Int32 { sp -= 1; return data[sp + 1] }
    public func drop() { sp -= 1 }
    public func swap() { let a = data[sp]; let b = data[sp - 1]; data[sp] = b; data[sp - 1] = a }
    public func depth() -> Int { return sp }
    public func item(_ n: Int) -> Int32 { return data[n] }
    public func empty() { sp = 0 }
}


// -------------------------------------------------------------
// Extensions to Existing Classes
// -------------------------------------------------------------

extension FixedWidthInteger where Self: SignedInteger {
    var bytes: [Int8] {
        var _endian = littleEndian
        let bytePtr = withUnsafePointer(to: &_endian) {
            $0.withMemoryRebound(to: Int8.self, capacity: MemoryLayout<Self>.size) {
                UnsafeBufferPointer(start: $0, count: MemoryLayout<Self>.size)
            }
        }
        return [Int8](bytePtr)
    }
}


// -------------------------------------------------------------
// Top-level System
// -------------------------------------------------------------

func main() {
    bootstrap()
    while ip < 65535 {
        input = readLine() ?? ""
        input = " \(input) \n"
        process()
    }
}

main()