Function decode_binary_program_to_instructions

core/src/program/decoder.rs:13–54

(
    program: BinaryProgram,
)

}

pub fn decode_binary_program_to_instructions(
    program: BinaryProgram,
) -> Result<Vec<BinaryInstruction>, String> {
    let mut prophets: HashMap<usize, OlaProphet> = HashMap::new();
    for prophet in program.prophets {
        prophets.insert(prophet.host, prophet);
    }

    let mut grouped_binary: Vec<Vec<String>> = vec![];
    let mut cached_first_instruction: Vec<String> = vec![];

    let mut lines = program.bytecode.lines();
    loop {
        if let Some(line) = lines.next() {
            if !cached_first_instruction.is_empty() {
                cached_first_instruction.push(line.to_string());
                grouped_binary.push(cached_first_instruction.clone());
                cached_first_instruction.clear();
            } else {
                let length = get_instruction_length(line.to_string())?;
                if length == 1 {
                    grouped_binary.push(vec![line.to_string()]);
                } else {
                    cached_first_instruction.push(line.to_string());
                }
            }
        } else {
            break;
        }
    }

    let mut instructions: Vec<BinaryInstruction> = vec![];
    let mut host: usize = 0;
    for binary_code in grouped_binary {
        let prophet = prophets.get(&host).cloned();
        let instruction = BinaryInstruction::decode(binary_code, prophet)?;
        let instruction_len = instruction.binary_length();
        instructions.push(instruction);
        host += instruction_len as usize;
    }
    Ok(instructions)
}

fn get_instruction_length(instruction: String) -> Result<u8, String> {
    let instruction_without_prefix = instruction.trim_start_matches("0x");