let caseStorage = try storage(input, @sizeOf(il::SwitchCase), @alignOf(il::SwitchCase), n)

            let vcases = try fillCases(input, caseStorage);

/// Fill owned switch cases with signed values and checked block targets.

fn fillCases 'input (input: &mut Reader 'input, cases: *mut [il::SwitchCase]) -> *mut [il::SwitchCase] throws (binary::Error) {

    for i in 0..cases.len {

        let value = try integer(input, 8) as i64;

        let block = try target(input);

        unsafe {

            let args = try values(input);

            set cases[i] = il::SwitchCase { value, target: block, args };

        }

    }

    return cases;

}

/// Switch decoding stops at an invalid target or argument in either case.

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

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

    let mut encoded: [u8; 48] = [0; 48];

    set encoded[0] = binary::INSTR_SWITCH;

    set encoded[1] = 4;

    set encoded[10] = 2;

    set encoded[26] = 1;

    set encoded[30] = 4;

    set encoded[43] = 1;

    set encoded[47] = 4;

    for offset in [22, 39, 30, 47] {

        let original = encoded[offset];

        set encoded[offset] = 255;

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

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

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

            set input.blocks = 1;

            let mut failed = false;

            try reader::instr(&mut input) catch err {

                assert err == binary::Error::Invalid;

                set failed = true;

            };

            assert failed;

            assert input.offset == offset + (4 if offset == 22 or offset == 39 else 1);

        }

        set encoded[offset] = original;

    }

}