//! Execute runtime-loaded native code after releasing its compiler workspace.

use std::mem;

use kernel::abi;

use kernel::backing;

use kernel::capability;

use kernel::pages;

use kernel::registry;

use kernel::loader;

use kernel::loadinput;

use kernel::domains;

use kernel::slots;

/// Capability storage for the loading domain.

unsafe static TABLE: capability::Table = undefined;

/// View a validated source Page as mapped bytes.

fn memory(address: u64) -> *mut u8;

/// Call a published entry with one instance's package-state table.

fn invoke(address: u64, table: u64) -> i64;

/// Load the hosted comparison package and execute its retained native instructions.

export unsafe fn run() {

    let pending = try! slots::reserve(&mut domains::STORE.slots[..]);

    let owner = try! slots::commit(&mut domains::STORE.slots[..], pending);

    capability::initialize(&mut TABLE, owner);

    try! backing::registerDomain(&mut pages::STORE.backings, owner);

    let authority = try! capability::install(&mut TABLE, capability::Entry {

        kind: abi::Kind::Domain, object: owner, rights: abi::Rights(abi::CREATE | abi::ALLOCATE),

    });

    let source = try! pages::allocate(&mut pages::STORE, &mut TABLE, authority, 1);

    let cap = try! capability::lookup(&TABLE, source, abi::Kind::Page, abi::Rights(abi::READ));

    let page = try! pages::get(&pages::STORE, cap.object);

    let bytes = @sliceOf(memory(page.base), 4096);

    let length = try! mem::copy(&mut bytes[..], &loadinput::INPUT[..]);

    let handle = try! loader::load(&mut loader::STATE, &mut pages::STORE, &mut registry::STORE, &mut TABLE,

        loader::Request { authority, source, offset: 0, length: length as u64 });

    assert not loader::STATE.busy;

    let object = try! registry::image(&registry::STORE, &TABLE, handle, abi::Rights(abi::EXECUTE));

    let package = try! registry::get(&registry::STORE, object);

    let entry = package.entry else panic "loaded entry";

    for i in 0..length {

        set bytes[i] = 0;

    }

    assert package.relocations.len > 0;

    let firstHandle = try! domains::create(&mut domains::STORE, &mut pages::STORE.backings, &registry::STORE, &mut TABLE, authority, handle);

    let secondHandle = try! domains::create(&mut domains::STORE, &mut pages::STORE.backings, &registry::STORE, &mut TABLE, authority, handle);

    let firstEntry = try! capability::get(&TABLE, firstHandle);

    let secondEntry = try! capability::get(&TABLE, secondHandle);

    let first = try! domains::get(&domains::STORE, firstEntry.object);

    let second = try! domains::get(&domains::STORE, secondEntry.object);

    assert first.state == domains::Lifecycle::Pending and second.state == domains::Lifecycle::Pending;

    assert domains::STORE.contexts[first.initial.index].frame.pc == entry;

    assert domains::STORE.contexts[second.initial.index].frame.pc == entry;

    assert first.memory.ring.mask == 255 and second.memory.ring.mask == 255;

    assert invoke(entry, first.graph.table.ptr as u64) == 43;

    assert invoke(entry, first.graph.table.ptr as u64) == 85;

    assert invoke(entry, second.graph.table.ptr as u64) == 43;

}