Function parse_lcov_data

src/feedback/clang_coverage.rs:629–689

parse line coverage of library from lcov data

(lcov: &str, coverage: &mut CodeCoverage)

    /// parse line coverage of library from lcov data
    pub fn parse_lcov_data(lcov: &str, coverage: &mut CodeCoverage) -> Result<()> {
        let mut de = crate::program::serde::Deserializer::from_input(lcov);
        // fn: line of function begion, function name;
        while de.is_next_token("SF:") {
            let mut fns: Vec<(usize, &str)> = Vec::new();
            de.eat_token("SF:")?;
            let _sf = de.consume_token_until("\n")?;
            // parse function lines
            while de.is_next_token("FN:") {
                de.eat_token("FN:")?;
                let line: usize = de.parse_number()?;
                de.eat_token(",")?;
                let f_name = de.consume_token_until("\n")?;
                fns.push((line, f_name));
            }
            fns.sort_by(|a, b| a.0.cmp(&b.0));

            let mut line_counts: Vec<(usize, usize)> = Vec::new();
            de.eat_token_until("FNH:")?;
            de.eat_token_until("DA:")?;
            while de.is_next_token("DA:") {
                de.eat_token("DA:")?;
                let line: usize = de.parse_number()?;
                de.eat_token(",")?;
                let count: usize = de.parse_number()?;
                line_counts.push((line, count));
            }

            let mut i = 0;
            let mut j = 0;
            while i < fns.len() && j < line_counts.len() {
                let (cur_begin, f_name) = fns[i];
                let (line, count) = line_counts[j];
                if line < cur_begin {
                    j += 1;
                    continue;
                }
                // if cur fn is the last one
                if i == fns.len() - 1 {
                    let func_cov = coverage.get_function_cov_mut(f_name).unwrap();
                    func_cov.lines.push([line, count]);
                    j += 1;
                } else {
                    let (next_begin, _) = fns[i + 1];
                    // if line still in the range of f_name
                    if line < next_begin {
                        let func_cov = coverage
                            .get_function_cov_mut(f_name)
                            .unwrap_or_else(|| panic!("cannot obtain coverage of :{f_name}"));
                        func_cov.lines.push([line, count]);
                        j += 1;
                    // else get the next fn
                    } else {
                        i += 1;
                    }
                }
            }
            de.consume_token_until("end_of_record")?;