//! Build a native image from the synchronization machine fixture.

use std::sys;

use std::io;

use std::sys::unix;

use std::lang::alloc;

use std::lang::strings;

use std::arch::rv64::asm;

use std::arch::rv64::image;

/// Assembly input storage.

static SOURCE: [u8; 65536] = [0; 65536];

/// Encoded text words.

static TEXT: [u32; 4096] = [0; 4096];

/// Assembly name and fixup storage.

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

/// Interned assembly identifiers.

unsafe static STRINGS: strings::Pool = strings::Pool { table: undefined, count: 0 };

/// Assemble startup and synchronization routines into one native code segment.

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

    assert env.args.len == 3;

    let length = unix::readFile(env.args[1], &mut SOURCE[..]) else panic "missing assembly";

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

    let data: *mut [u8] = &mut [];

    let program = try asm::assemble(asm::scanner::SourceKind::String, &SOURCE[..length],

        &mut TEXT[..], &mut data[..], &mut arena, &mut STRINGS, 0) catch err {

        match err {

            case asm::Error::Invalid { offset, message } => {

                io::printU32(offset); io::print(": "); io::printLn(message);

            },

            else => io::printLn("assembly output full"),

        }

        return 1;

    };

    assert program.externalFixups.len == 0;

    let size = program.text.len * 4;

    let header = try! image::header(image::Layout {

        entry: 0x80010000,

        code: image::Segment { address: 0x80010000, initialized: size, memory: size },

        roData: image::Segment { address: 0, initialized: 0, memory: 0 },

        rwData: image::Segment { address: 0x80020000, initialized: 0, memory: 4096 },

    });

    let fd = unix::openOpts(env.args[2], unix::OpenFlags(*unix::O_WRONLY | *unix::O_CREAT | *unix::O_TRUNC), 420);

    assert fd >= 0;

    let written = unix::writeAll(fd, &header[..]) and unix::writeAll(fd, @sliceOf(program.text.ptr as *u8, size));

    let closed = unix::close(fd) == 0;

    assert written and closed;

    return 0;

}