Method apply_to_linear_object

rust/src/render_layer.rs:99–187

Apply this Render Layer to the lines produced by a LinearViewObject for rendering in Linear View.

(
        &self,
        object: &mut LinearViewObject,
        _prev_object: Option<&mut LinearViewObject>,
        _next_object: Option<&mut LinearViewObject>,
        lines: Vec<LinearDisassemblyLi

    /// Apply this Render Layer to the lines produced by a LinearViewObject for rendering in Linear View.
    fn apply_to_linear_object(
        &self,
        object: &mut LinearViewObject,
        _prev_object: Option<&mut LinearViewObject>,
        _next_object: Option<&mut LinearViewObject>,
        lines: Vec<LinearDisassemblyLine>,
    ) -> Vec<LinearDisassemblyLine> {
        let text_to_lines =
            |function: &Function, block: &BasicBlock<NativeBlock>, text: DisassemblyTextLine| {
                LinearDisassemblyLine {
                    ty: LinearDisassemblyLineType::CodeDisassemblyLineType,
                    function: Some(function.to_owned()),
                    basic_block: Some(block.to_owned()),
                    contents: text,
                }
            };

        // Hack: HLIL bodies don't have basic blocks.
        let obj_ident = object.identifier();
        if !lines.is_empty()
            && (obj_ident.name.starts_with("HLIL") || obj_ident.name.starts_with("Language"))
        {
            // Apply to HLIL body.
            let function = lines[0]
                .function
                .to_owned()
                .expect("HLIL body has no function");
            return self.apply_to_hlil_body(&function, lines);
        }

        // Collect the "line blocks".
        // Line blocks are contiguous lines with the same backing basic block (or lack thereof).
        // Line blocks also group by line type.
        let mut line_blocks: Vec<Vec<LinearDisassemblyLine>> = Vec::new();
        for line in lines {
            let Some(last_block) = line_blocks.last_mut() else {
                // No last block, create the first block.
                line_blocks.push(vec![line]);
                continue;
            };

            let Some(last_line) = last_block.last() else {
                // No last line, create the first line.
                last_block.push(line);
                continue;
            };

            // TODO: If we want to allow a block with multiple line types we need to specifically check
            // TODO: If the last line type was Code, if it is and the last line is not we make a new block.
            if last_line.basic_block == line.basic_block && last_line.ty == line.ty {
                // Same basic block and line type, this is a part of the same line block.
                last_block.push(line);
            } else {
                // Not the same line block, create a new block.
                line_blocks.push(vec![line]);
            }
        }