/// Collect function definitions and their bodies in pointer-table order.

fn collectFunctions 'tables (names: &mut Names 'tables, owner: *[u8], functions: &[*unsafe il::Fn]) throws (binary::Error) {

    for i in 0..functions.len {

        let func = functions[i];

        unsafe {

            try collectFunction(names, owner, func.name, func.blocks);

        }

    }

}

/// Collect a function definition before its block references.

fn collectFunction 'tables (names: &mut Names 'tables, owner: *[u8], name: *[u8], blocks: &[il::Block]) throws (binary::Error) {

    try definition(names, owner, name);

    for i in 0..blocks.len {

        let block = &blocks[i];

        unsafe {

            try collectInstructions(names, owner, block.instrs);

        }

    }

}

/// Collect instruction references in table order.

fn collectInstructions 'tables (names: &mut Names 'tables, owner: *[u8], instructions: &[il::Instr]) throws (binary::Error) {

    for i in 0..instructions.len {

        try instruction(names, owner, &instructions[i]);

    }

}

    try collectFunctions(names, owner, program.fns);

/// Function definitions precede their block references in table order.

@test unsafe fn functionCollectionOrder() throws (testing::TestError) {

    let external = il::Fn { name: "p::external", params: &[], returnType: il::Type::W64,

        isExtern: true, isLeaf: true, blocks: &[] };

    let mut first = [il::Instr::Copy { dst: il::Reg { n: 0 }, val: il::Val::DataSym("z::data") }];

    let mut second = [il::Instr::Ret { val: il::Val::FnAddr("a::fn") }];

    let blocks = [

        il::Block { label: "first", params: &[], instrs: &mut first[..], locs: &[], preds: &[], loopDepth: 0 },

        il::Block { label: "empty", params: &[], instrs: &mut [], locs: &[], preds: &[], loopDepth: 0 },

        il::Block { label: "second", params: &[], instrs: &mut second[..], locs: &[], preds: &[], loopDepth: 0 },

    ];

    let function = il::Fn { name: "p::main", params: &[], returnType: il::Type::W64,

        isExtern: false, isLeaf: true, blocks: &blocks[..] };

    let local = il::Program { data: &[], fns: &[&external, &function] };

    let expected: [*[u8]; 7] = ["p", "p::external", "p::main", "z::data", "z", "a::fn", "a"];

    for capacity in 0..expected.len + 1 {

        let mut symbols: [*[u8]; 8] = [""; 8];

        let mut dependencies: [*[u8]; 2] = [""; 2];

        let symbolTable: 'tables = &mut symbols[..capacity], dependencyTable = &mut dependencies[..] in {

            let mut names = collect::new(symbolTable, dependencyTable);

            let mut failed = false;

            try collect::package(&mut names, "p", local, &[], nil) catch err {

                assert err == binary::Error::Capacity;

                set failed = true;

            };

            assert failed == (capacity < expected.len);

            assert names.symbolCount <= capacity;

            if not failed {

                assert names.symbolCount == expected.len;

                for name, i in expected { try testing::expectBytesEq(names.symbols[i], name); }

                assert names.dependencyCount == 2;

                try testing::expectBytesEq(names.dependencies[0], "z");

                try testing::expectBytesEq(names.dependencies[1], "a");

            }

        }

        for i in capacity..symbols.len { assert symbols[i].len == 0; }

    }

}