//! Binary package envelopes and IL program reconstruction.

//! Tables occur in this order: symbols, dependencies, exports, data, functions.

//! Block records carry labels, parameters, loop depth, predecessors, instructions.

use std::lang::il;

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

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

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

use std::lang::alloc;

use std::mem;

/// Write a counted sequence of typed SSA parameters.

fn writeParams 'buffer (out: &mut writer::Writer 'buffer, params: &[il::Param]) throws (binary::Error) {

    try writer::integer(out, params.len as u64, 4);

    for param in params {

        try writer::integer(out, param.value.n as u64, 4);

        try writer::typ(out, param.type);

    }

}

/// Write global data definitions and their initializer sequences.

fn writeData 'buffer (out: &mut writer::Writer 'buffer, items: &[il::Data]) throws (binary::Error) {

    try writer::integer(out, items.len as u64, 4);

    for item in items {

        try writer::symbol(out, item.name);

        try writer::integer(out, item.size as u64, 4);

        try writer::integer(out, item.alignment as u64, 4);

        try writer::integer(out, 1 if item.readOnly else 0, 1);

        try writer::integer(out, 1 if item.isZeroInit else 0, 1);

        try writer::integer(out, item.values.len as u64, 4);

        for value in item.values {

            try writer::dataValue(out, value);

        }

    }

}

/// Write package identity, symbol tables, exports, and the optional entry.

fn writeHeader 'buffer (

    out: &mut writer::Writer 'buffer,

    symbols: &[*[u8]],

    name: *[u8],

    dependencies: &[*[u8]],

    exports: &[binary::Export],

    entry: ?*[u8]

) throws (binary::Error) {

    try writer::integer(out, binary::MAGIC as u64, 4);

    try writer::integer(out, binary::VERSION as u64, 4);

    try writer::integer(out, symbols.len as u64, 4);

    for name in symbols {

        try writer::bytes(out, name);

    }

    try writer::symbol(out, name);

    try writer::integer(out, dependencies.len as u64, 4);

    for name in dependencies {

        try writer::symbol(out, name);

    }

    try writer::integer(out, exports.len as u64, 4);

    for item in exports {

        try writer::symbol(out, item.name);

        match item.kind {

            case binary::ExportKind::Function => try writer::integer(out, 0, 1),

            case binary::ExportKind::Data => try writer::integer(out, 1, 1),

        }

    }

    if let entry = entry {

        try writer::integer(out, 1, 1);

        try writer::symbol(out, entry);

    } else {

        try writer::integer(out, 0, 1);

    }

}

/// Write a package. Return the number of encoded bytes.

/// All package tables and IL storage must remain valid during encoding.

export unsafe fn encode(bytes: &mut [u8], package: &binary::Package) -> u32 throws (binary::Error) {

    let output: 'output = &mut bytes[..], symbols = &package.symbols[..] in {

        let mut out = writer::new(output, symbols);

        try writeHeader(&mut out, symbols, package.name, package.dependencies, package.exports, package.entry);

        try writeData(&mut out, &package.program.data[..]);

        try writeFunctions(&mut out, package.program.fns);

        return out.offset;

    }

}

/// Write a counted function-pointer table in wire order.

fn writeFunctions 'buffer (out: &mut writer::Writer 'buffer, functions: &[*unsafe il::Fn]) throws (binary::Error) {

    try writer::integer(out, functions.len as u64, 4);

    for i in 0..functions.len {

        unsafe {

            try writeFunction(out, functions[i]);

        }

    }

}

/// Write function metadata before its parameter and block tables.

fn writeFunction 'buffer (out: &mut writer::Writer 'buffer, func: &il::Fn) throws (binary::Error) {

    try writer::symbol(out, func.name);

    try writer::typ(out, func.returnType);

    try writer::integer(out, 1 if func.isExtern else 0, 1);

    unsafe {

        try writeParams(out, func.params);

        try writeBlocks(out, func.blocks);

    }

}

/// Write a counted block table in function order.

fn writeBlocks 'buffer (out: &mut writer::Writer 'buffer, blocks: &[il::Block]) throws (binary::Error) {

    try writer::integer(out, blocks.len as u64, 4);

    for i in 0..blocks.len {

        let block = &blocks[i];

        unsafe {

            try writeBlock(out, block.label, block.params, block.loopDepth, block.preds, block.instrs);

        }

    }

}

/// Write block metadata and counted predecessor and instruction tables.

fn writeBlock 'buffer (

    out: &mut writer::Writer 'buffer,

    label: *[u8],

    params: &[il::Param],

    loopDepth: u32,

    preds: &[u32],

    instructions: &[il::Instr],

) throws (binary::Error) {

    try writer::bytes(out, label);

    try writeParams(out, params);

    try writer::integer(out, loopDepth as u64, 4);

    try writer::integer(out, preds.len as u64, 4);

    for pred in preds {

        try writer::integer(out, pred as u64, 4);

    }

    try writer::integer(out, instructions.len as u64, 4);

    for instr in instructions {

        unsafe {

            try writer::instr(out, instr);

        }

    }

}

/// Read typed SSA parameters with checked register indices.

unsafe fn readParams 'input (input: &mut reader::Reader 'input) -> *unsafe [il::Param] throws (binary::Error) {

    let n = try reader::count(input, 5);

    let params = try reader::storage(input, @sizeOf(il::Param), @alignOf(il::Param), n)

        as *mut [il::Param];

    let initialized = try fillParams(input, params);

    return (&initialized[..]) as *unsafe [il::Param];

}

/// Fill owned parameter storage from checked register indices and type tags.

fn fillParams 'input (input: &mut reader::Reader 'input, params: *mut [il::Param]) -> *[il::Param] throws (binary::Error) {

    for i in 0..params.len {

        let value = try reader::reg(input);

        let t = try reader::typ(input);

        set params[i] = il::Param { value, type: t };

    }

    return params;

}

/// Extend an initializer extent without exceeding its declared storage.

fn extendDataExtent(extent: u64, value: il::DataValue, size: u32) -> u64 throws (binary::Error) {

    let mut width: u32 = 0;

    match value.item {

        case il::DataItem::Val { typ, .. } => {

            set width = il::typeSize(typ);

        },

        case il::DataItem::Sym(_), il::DataItem::Fn(_) => {

            set width = 8;

        },

        case il::DataItem::Str(text) => {

            set width = text.len;

        },

        case il::DataItem::Undef => {

            set width = 1;

        },

    }

    let amount = width as u64 * value.count as u64;

    if extent > size as u64 or amount > size as u64 - extent {

        throw binary::Error::Invalid;

    }

    return extent + amount;

}

/// Read global data and check initializer extents against declared storage.

unsafe fn readData 'input (input: &mut reader::Reader 'input) -> *[il::Data] throws (binary::Error) {

    let n = try reader::count(input, 18);

    let items = try reader::storage(input, @sizeOf(il::Data), @alignOf(il::Data), n)

        as *mut [il::Data];

    return try fillData(input, items);

}

/// Fill owned data definitions with checked metadata and initializer extents.

fn fillData 'input (input: &mut reader::Reader 'input, items: *mut [il::Data]) -> *[il::Data] throws (binary::Error) {

    for i in 0..items.len {

        let name = try reader::symbol(input);

        let size = try reader::integer(input, 4) as u32;

        let alignment = try reader::integer(input, 4) as u32;

        if alignment == 0 or (alignment & (alignment - 1)) <> 0 {

            throw binary::Error::Invalid;

        }

        let readOnly = try reader::flag(input);

        let isZeroInit = try reader::flag(input);

        let count = try reader::count(input, 5);

        unsafe {

            let values = try reader::storage(input, @sizeOf(il::DataValue), @alignOf(il::DataValue), count)

                as *mut [il::DataValue];

            let initialized = try fillDataValues(input, values, size);

            set items[i] = il::Data { name, size, alignment, readOnly, isZeroInit, values: initialized };

        }

    }

    return items;

}

/// Fill owned initializer storage within its declared byte extent.

fn fillDataValues 'input (input: &mut reader::Reader 'input, values: *mut [il::DataValue], size: u32)

    -> *[il::DataValue] throws (binary::Error)

{

    let mut extent: u64 = 0;

    for i in 0..values.len {

        unsafe {

            set values[i] = try reader::dataValue(input);

        }

        set extent = try extendDataExtent(extent, values[i], size);

    }

    return values;

}

/// Read functions with checked block and register indices.

unsafe fn readFunctions 'input (input: &mut reader::Reader 'input, limits: binary::Limits)

    -> *unsafe [*unsafe il::Fn] throws (binary::Error)

{

    let n = try reader::count(input, 14);

    let fns = try reader::storage(input, @sizeOf(*il::Fn), @alignOf(*il::Fn), n) as *mut [*unsafe il::Fn];

    set input.registers = limits.registers;

    for i in 0..n {

        let name = try reader::symbol(input);

        let returnType = try reader::typ(input);

        let isExtern = try reader::flag(input);

        let params = try readParams(input);

        let count = try reader::count(input, 20);

        if count > limits.blocks or (isExtern and count <> 0) {

            throw binary::Error::Invalid;

        }

        set input.blocks = count;

        let blocks = try reader::storage(input, @sizeOf(il::Block), @alignOf(il::Block), count)

            as *mut [il::Block];

        let mut isLeaf = true;

        for j in 0..count {

            let label = try reader::bytes(input);

            let blockParams = try readParams(input);

            let loopDepth = try reader::integer(input, 4) as u32;

            let predCount = try reader::count(input, 4);

            let predStorage = try reader::storage(input, @sizeOf(u32), @alignOf(u32), predCount) as *mut [u32];

            let preds = try fillPredecessors(input, predStorage);

            let instrCount = try reader::count(input, 1);

            let instrs = try reader::storage(input, @sizeOf(il::Instr), @alignOf(il::Instr), instrCount)

                as *mut [il::Instr];

            if try fillInstructions(input, &mut instrs[..]) {

                set isLeaf = false;

            }

            set blocks[j] = il::Block {

                label, params: blockParams, instrs: (&mut instrs[..]) as *unsafe mut [il::Instr], locs: &[], preds: (&preds[..]) as *unsafe [u32], loopDepth,

            };

        }

        let func = try reader::storage(input, @sizeOf(il::Fn), @alignOf(il::Fn), 1) as *mut [il::Fn];

        set func[0] = il::Fn { name, params, returnType, isExtern, isLeaf, blocks: (&blocks[..]) as *unsafe [il::Block] };

        set fns[i] = &func[0];

    }

    return (&fns[..]) as *unsafe [*unsafe il::Fn];

}

/// Fill owned predecessor storage with checked block indices.

fn fillPredecessors 'input (input: &mut reader::Reader 'input, preds: *mut [u32]) -> *[u32] throws (binary::Error) {

    for i in 0..preds.len {

        set preds[i] = try reader::target(input);

    }

    return preds;

}

/// Fill an instruction table and report whether it contains a call.

fn fillInstructions 'input (input: &mut reader::Reader 'input, instrs: &mut [il::Instr]) -> bool throws (binary::Error) {

    let mut hasCall = false;

    for i in 0..instrs.len {

        unsafe {

            set instrs[i] = try reader::instr(input);

        }

        if il::isCall(instrs[i]) {

            set hasCall = true;

        }

    }

    return hasCall;

}

/// Read the package tables. The input must contain exactly one package.

unsafe fn readPackage 'input (input: &mut reader::Reader 'input, limits: binary::Limits)

    -> binary::Package throws (binary::Error)

{

    let magic = try reader::integer(input, 4) as u32;

    let version = try reader::integer(input, 4) as u32;

    if magic <> binary::MAGIC or version <> binary::VERSION {

        throw binary::Error::Invalid;

    }

    let symbolCount = try reader::count(input, 4);

    let symbolStorage = try reader::storage(input, @sizeOf(*[u8]), @alignOf(*[u8]), symbolCount)

        as *mut [*[u8]];

    let symbols = try fillSymbols(input, symbolStorage);

    let source: 'tables = &input.bytes[..], names = &symbols[..] where 'input: 'tables in {

        let mut cursor = reader::new(source, input.arena, names);

        set cursor.offset = input.offset;

        let name = try reader::symbol(&mut cursor);

        let depCount = try reader::count(&mut cursor, 4);

        let dependencyStorage = try reader::storage(&mut cursor, @sizeOf(*[u8]), @alignOf(*[u8]), depCount)

            as *mut [*[u8]];

        let dependencies = try fillDependencies(&mut cursor, dependencyStorage);

        let exportCount = try reader::count(&mut cursor, 5);

        let exportStorage = try reader::storage(&mut cursor, @sizeOf(binary::Export), @alignOf(binary::Export), exportCount)

            as *mut [binary::Export];

        let exports = try fillExports(&mut cursor, exportStorage);

        let mut entry: ?*[u8] = nil;

        if try reader::flag(&mut cursor) {

            set entry = try reader::symbol(&mut cursor);

        }

        let data = try readData(&mut cursor);

        let fns = try readFunctions(&mut cursor, limits);

        if cursor.offset <> cursor.bytes.len {

            throw binary::Error::Invalid;

        }

        set input.offset = cursor.offset;

        return binary::Package { symbols: (&symbols[..]) as *unsafe [*[u8]], name, dependencies: (&dependencies[..]) as *unsafe [*[u8]], exports: (&exports[..]) as *unsafe [binary::Export], entry, program: il::Program { data, fns } };

    }

}

/// Fill owned symbol storage with distinct nonempty names.

fn fillSymbols 'input (input: &mut reader::Reader 'input, symbols: *mut [*[u8]]) -> *[*[u8]] throws (binary::Error) {

    for i in 0..symbols.len {

        unsafe {

            set symbols[i] = try reader::bytes(input);

        }

        let name = symbols[i];

        if name.len == 0 {

            throw binary::Error::Invalid;

        }

        for j in 0..i {

            if mem::eq(name, symbols[j]) {

                throw binary::Error::Invalid;

            }

        }

    }

    return symbols;

}

/// Fill owned dependency storage from checked symbol indices.

fn fillDependencies 'input (input: &mut reader::Reader 'input, dependencies: *mut [*[u8]]) -> *[*[u8]] throws (binary::Error) {

    for i in 0..dependencies.len {

        set dependencies[i] = try reader::symbol(input);

    }

    return dependencies;

}

/// Fill owned exports from checked symbol indices and kind flags.

fn fillExports 'input (input: &mut reader::Reader 'input, exports: *mut [binary::Export]) -> *[binary::Export] throws (binary::Error) {

    for i in 0..exports.len {

        let symbol = try reader::symbol(input);

        let kind = binary::ExportKind::Data if try reader::flag(input) else binary::ExportKind::Function;

        set exports[i] = binary::Export { name: symbol, kind };

    }

    return exports;

}

/// Decode one package. Restore the arena offset on every failure.

/// The caller must retain the decoded allocations until the last package use.

export unsafe fn decode(bytes: &[u8], arena: &mut alloc::Arena, limits: binary::Limits)

    -> binary::Package throws (binary::Error)

{

    let saved = alloc::save(arena);

    let namesTable: [*[u8]; 0] = [];

    let source: 'input = &bytes[..], names = &namesTable[..] in {

        let mut input = reader::new(source, &mut *arena, names);

        return try readPackage(&mut input, limits) catch err {

            alloc::restore(arena, saved);

            throw err;

        };

    }

}