Method build_mapping

language/tools/move-bytecode-viewer/src/bytecode_viewer.rs:51–98

(&mut self)

    }

    fn build_mapping(&mut self) {
        let regex = Regex::new(r"^(\d+):.*").unwrap();
        let fun_regex = Regex::new(r"^public\s+([a-zA-Z_]+)\(").unwrap();
        let mut current_fun = None;
        let mut current_fdef_idx = None;
        let mut line_map = HashMap::new();

        let function_def_for_name: HashMap<String, u16> = self
            .view
            .function_defs()
            .into_iter()
            .flatten()
            .enumerate()
            .map(|(index, fdef)| {
                (
                    self.view
                        .identifier_at(self.view.function_handle_at(fdef.function).name)
                        .to_string(),
                    index as u16,
                )
            })
            .collect();

        for (i, line) in self.lines.iter().enumerate() {
            let line = line.trim();
            if let Some(cap) = fun_regex.captures(line) {
                let fn_name = cap.get(1).unwrap().as_str();
                let function_definition_index = function_def_for_name[fn_name];
                current_fun = Some(fn_name);
                current_fdef_idx = Some(FunctionDefinitionIndex(function_definition_index));
            }

            if let Some(cap) = regex.captures(line) {
                current_fun.map(|fname| {
                    let d = cap.get(1).unwrap().as_str().parse::<u16>().unwrap();
                    line_map.insert(
                        i,
                        BytecodeInfo {
                            function_name: fname.to_string(),
                            function_index: current_fdef_idx.unwrap(),
                            code_offset: d,
                        },
                    )
                });
            }
        }
        self.line_map = line_map;
    }
}

impl LeftScreen for BytecodeViewer<'_> {