//! Scheduled runtime compilation and an independent window witness.

export mod abi;

export mod sys;

/// Startup fields used by the scheduled fixture.

record Request: Copy {

    /// Readable binary package capability.

    source: u64,

    /// Complete binary package byte count.

    length: u64,

    /// Shared progress counters.

    progress: *unsafe mut u64,

}

/// Values supplied at domain activation.

record Env: Copy {

    /// Input handle, byte count, and shared progress address.

    argsPointer: *Request,

    /// Actor index selected by the parent.

    argsSize: u64,

    /// Event capability installed at creation.

    eventsHandle: u64,

    /// Shared event queue address.

    eventsPointer: u64,

}

/// Compile a package twice or record progress during another domain's load.

@default unsafe fn main(env: *Env) {

    let args = env.argsPointer;

    let progress = @sliceOf(args.progress, 4);

    let actor = env.argsSize as u32;

    if actor == 2 {

        assert progress[1] == 1;

        let mut busy = false;

        try sys::imageLoad(abi::Handle(0), abi::Handle(args.source), 0, args.length) catch error {

            assert error == abi::Error::Busy; set busy = true;

        };

        assert busy;

        set progress[2] = 1;

        return;

    }

    set progress[actor] = 1;

    let image = try sys::imageLoad(abi::Handle(0), abi::Handle(args.source), 0, args.length) catch error {

        set progress[actor] = 100 + error as u64; return;

    };

    let info = try! sys::queryImage(image);

    let repeated = try sys::imageLoad(abi::Handle(0), abi::Handle(args.source), 0, args.length) catch error {

        set progress[actor] = 200 + error as u64; return;

    };

    assert (try! sys::queryImage(repeated)).id == info.id;

    set progress[3] = info.id;

    set progress[actor] = 2;

}