//! Verify compiler-emitted binary RIL package boundaries.

use std::sys;

use std::sys::unix;

use std::mem;

use std::lang::alloc;

use std::lang::il;

use std::lang::il::binary;

use std::lang::il::binary::program;

/// Maximum fixture image size.

constant IMAGE_SIZE: u32 = 4096;

/// Arena capacity for both decoded fixture packages.

constant ARENA_SIZE: u32 = 32768;

/// Input image storage.

static IMAGE: [u8; IMAGE_SIZE] = [0; IMAGE_SIZE];

/// Decoded package storage.

static MEMORY: [u8; ARENA_SIZE] = [0; ARENA_SIZE];

/// Decode one compiler output file.

unsafe fn load(path: *[u8], arena: &mut alloc::Arena) -> binary::Package {

    let length = unix::readFile(path, &mut IMAGE[..]) else panic "load: cannot read fixture";

    return try! program::decode(&IMAGE[..length], arena, binary::Limits { registers: 8192, blocks: 4096 });

}

/// Check identity, ownership, linkage, and source exports for two packages.

@default unsafe fn main(env: *sys::Env) -> i32 {

    assert env.args.len == 3, "main: expected two package paths";

    let mut arena = alloc::new(&mut MEMORY[..]);

    let support = load(env.args[1], &mut arena);

    let app = load(env.args[2], &mut arena);

    assert mem::eq(support.name, "support"), "main: mem::eq(support.name, \"support\")";

    assert mem::eq(app.name, "app"), "main: mem::eq(app.name, \"app\")";

    assert support.dependencies.len == 0, "main: support.dependencies.len == 0";

    assert app.dependencies.len == 1, "main: app.dependencies.len == 1";

    assert mem::eq(app.dependencies[0], "support"), "main: mem::eq(app.dependencies[0], \"support\")";

    assert support.program.fns.len == 2, "main: support.program.fns.len == 2";

    assert support.program.data.len == 3, "main: support.program.data.len == 3";

    assert mem::eq(support.program.fns[0].name, "support::read"), "main: mem::eq(support.program.fns[0].name, \"support::read\")";

    assert mem::eq(support.program.data[0].name, "support::value"), "main: mem::eq(support.program.data[0].name, \"support::value\")";

    assert app.program.fns.len == 1, "main: app.program.fns.len == 1";

    assert app.program.data.len == 2, "main: app.program.data.len == 2";

    assert not mem::eq(support.program.data[1].name, app.program.data[0].name), "main: package-local literals";

    assert not mem::eq(support.program.data[2].name, app.program.data[1].name), "main: package-local arrays";

    assert mem::eq(app.program.fns[0].name, "app::main"), "main: mem::eq(app.program.fns[0].name, \"app::main\")";

    assert support.exports.len == 2, "main: support.exports.len == 2";

    let mut fenceFound = false;

    for block in support.program.fns[0].blocks {

        for instr in block.instrs {

            if let case il::Instr::MemoryFence = instr { set fenceFound = true; }

        }

    }

    assert fenceFound, "main: intrinsic instruction";

    assert app.exports.len == 1, "main: app.exports.len == 1";

    assert app.exports[0].kind == binary::ExportKind::Function, "main: app.exports[0].kind == binary::ExportKind::Function";

    let entry = app.entry else panic "main: missing package entry";

    assert mem::eq(entry, "app::main"), "main: mem::eq(entry, \"app::main\")";

    let mut callFound = false;

    let mut dataFound = false;

    for block in app.program.fns[0].blocks {

        for instr in block.instrs {

            match instr {

                case il::Instr::Call { func, .. } => {

                    if let case il::Val::FnAddr(name) = func {

                        if mem::eq(name, "support::read") { set callFound = true; }

                    }

                },

                case il::Instr::Copy { val, .. } => {

                    if let case il::Val::DataSym(name) = val {

                        if mem::eq(name, "support::value") { set dataFound = true; }

                    }

                },

                else => {},

            }

        }

    }

    assert callFound and dataFound, "main: callFound and dataFound";

    return 0;

}