//! 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.

unsafe fn writeParams(out: &mut writer::Writer, 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 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 mut out = writer::new(bytes, package.symbols);

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

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

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

    for name in package.symbols {

        try writer::bytes(&mut out, name);

    }

    try writer::symbol(&mut out, package.name);

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

    for name in package.dependencies {

        try writer::symbol(&mut out, name);

    }

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

    for item in package.exports {

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

        match item.kind {

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

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

        }

    }

    if let entry = package.entry {

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

        try writer::symbol(&mut out, entry);

    } else {

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

    }

    try writer::integer(&mut out, package.program.data.len as u64, 4);

    for item in package.program.data {

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

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

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

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

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

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

        for value in item.values {

            try writer::dataValue(&mut out, value);

        }

    }

    try writer::integer(&mut out, package.program.fns.len as u64, 4);

    for func in package.program.fns {

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

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

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

        try writeParams(&mut out, func.params);

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

        for block in func.blocks {

            try writer::bytes(&mut out, block.label);

            try writeParams(&mut out, block.params);

            try writer::integer(&mut out, block.loopDepth as u64, 4);

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

            for pred in block.preds {

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

            }

            try writer::integer(&mut out, block.instrs.len as u64, 4);

            for instr in block.instrs {

                try writer::instr(&mut out, instr);

            }

        }

    }

    return out.offset;

}

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

unsafe fn readParams(input: &mut reader::Reader) -> *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];

    for i in 0..n {

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

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

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

    }

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

}

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

unsafe fn readData(input: &mut reader::Reader) -> *[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];

    for i in 0..n {

        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);

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

            as *mut [il::DataValue];

        let mut extent: u64 = 0;

        for j in 0..count {

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

            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; },

            }

            set extent += width as u64 * value.count as u64;

            if extent > size as u64 {

                throw binary::Error::Invalid;

            }

            set values[j] = value;

        }

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

    }

    return items;

}

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

unsafe fn readFunctions(input: &mut reader::Reader, 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 preds = try reader::storage(input, @sizeOf(u32), @alignOf(u32), predCount) as *mut [u32];

            for k in 0..predCount {

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

            }

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

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

                as *mut [il::Instr];

            for k in 0..instrCount {

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

                if il::isCall(instr) {

                    set isLeaf = false;

                }

                set instrs[k] = instr;

            }

            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];

}

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

unsafe fn readPackage(input: &mut reader::Reader, 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 symbols = try reader::storage(input, @sizeOf(*[u8]), @alignOf(*[u8]), symbolCount)

        as *mut [*[u8]];

    for i in 0..symbolCount {

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

        if name.len == 0 {

            throw binary::Error::Invalid;

        }

        for j in 0..i {

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

                throw binary::Error::Invalid;

            }

        }

        set symbols[i] = name;

    }

    set input.symbols = (&symbols[..]) as *unsafe [*[u8]];

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

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

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

        as *mut [*[u8]];

    for i in 0..depCount {

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

    }

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

    let exports = try reader::storage(input, @sizeOf(binary::Export), @alignOf(binary::Export), exportCount)

        as *mut [binary::Export];

    for i in 0..exportCount {

        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 };

    }

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

    if try reader::flag(input) {

        set entry = try reader::symbol(input);

    }

    let data = try readData(input);

    let fns = try readFunctions(input, limits);

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

        throw binary::Error::Invalid;

    }

    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 } };

}

/// 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 mut input = reader::new(bytes, arena, &[]);

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

        alloc::restore(arena, saved);

        throw err;

    };

}