+use Cwd qw/abs_path/;

+our $tool_dir = abs_path(dirname($0));

+our $lcov_version = "LCOV version 1.12";

+ open(INPUT_HANDLE, "<", $input_filename)

+ open(OUTPUT_HANDLE, ">", $output_filename)

+# Copyright (c) International Business Machines Corp., 2002,2012

+use File::Basename;

+use File::Temp qw(tempfile);

+use Cwd qw/abs_path/;

+our $tool_dir = abs_path(dirname($0));

+our $lcov_version = "LCOV version 1.12";

+# Specify coverage rate default precision

+our $default_precision = 1;

+

+our $BR_VEC_MAX = vec(pack('b*', 1 x $BR_VEC_WIDTH), 0, $BR_VEC_WIDTH);

+# Error classes which users may specify to ignore during processing

+our $ERROR_SOURCE = 0;

+our %ERROR_ID = (

+ "source" => $ERROR_SOURCE,

+);

+

+sub get_prefix($@);

+sub apply_prefix($@);

+sub parse_ignore_errors(@);

+sub parse_dir_prefix(@);

+sub rate($$;$$$);

+our @opt_dir_prefix; # Array of prefixes to remove from all sub directories

+our @dir_prefix;

+our $func_coverage; # If set, generate function coverage statistics

+our $br_coverage; # If set, generate branch coverage statistics

+our @opt_ignore_errors; # Ignore certain error classes during processing

+our @ignore;

+our $opt_config_file; # User-specified configuration file location

+our %opt_rc;

+our $charset = "UTF-8"; # Default charset for HTML pages

+our $lcov_func_coverage = 1;

+our $lcov_branch_coverage = 0;

+our $rc_desc_html = 0; # lcovrc: genhtml_desc_html

+# Check command line for a configuration file name

+Getopt::Long::Configure("pass_through", "no_auto_abbrev");

+GetOptions("config-file=s" => \$opt_config_file,

+ "rc=s%" => \%opt_rc);

+Getopt::Long::Configure("default");

+ # Remove spaces around rc options

+ my %new_opt_rc;

+

+ while (my ($key, $value) = each(%opt_rc)) {

+ $key =~ s/^\s+|\s+$//g;

+ $value =~ s/^\s+|\s+$//g;

+

+ $new_opt_rc{$key} = $value;

+ }

+ %opt_rc = %new_opt_rc;

+if (defined($opt_config_file)) {

+ $config = read_config($opt_config_file);

+} elsif (defined($ENV{"HOME"}) && (-r $ENV{"HOME"}."/.lcovrc"))

+if ($config || %opt_rc)

+ # Copy configuration file and --rc values to variables

+ "genhtml_precision" => \$default_precision,

+ "genhtml_charset" => \$charset,

+ "genhtml_desc_html" => \$rc_desc_html,

+ "lcov_function_coverage" => \$lcov_func_coverage,

+ "lcov_branch_coverage" => \$lcov_branch_coverage,

+# Copy related values if not specified

+$func_coverage = $lcov_func_coverage if (!defined($func_coverage));

+$br_coverage = $lcov_branch_coverage if (!defined($br_coverage));

+ "prefix|p=s" => \@opt_dir_prefix,

+ "ignore-errors=s" => \@opt_ignore_errors,

+ "config-file=s" => \$opt_config_file,

+ "rc=s%" => \%opt_rc,

+ "precision=i" => \$default_precision,

+# Determine which errors the user wants us to ignore

+parse_ignore_errors(@opt_ignore_errors);

+

+# Split the list of prefixes if needed

+parse_dir_prefix(@opt_dir_prefix);

+

+if ($no_prefix && @dir_prefix)

+ @dir_prefix = undef;

+# Make sure precision is within valid range

+if ($default_precision < 1 || $default_precision > 4)

+{

+ die("ERROR: specified precision is out of range (1 to 4)\n");

+}

+

+

+ --config-file FILENAME Specify configuration file location

+ --rc SETTING=VALUE Override configuration file setting

+ --ignore-errors ERRORS Continue after ERRORS (source)

+ --precision NUM Set precision of coverage rate

+ return rate($hit, $found, "% ($hit of $found $name)");

+sub get_fn_list($)

+{

+ my ($info) = @_;

+ my %fns;

+ my @result;

+

+ foreach my $filename (keys(%{$info})) {

+ my $data = $info->{$filename};

+ my $funcdata = $data->{"func"};

+ my $sumfnccount = $data->{"sumfnc"};

+

+ if (defined($funcdata)) {

+ foreach my $func_name (keys(%{$funcdata})) {

+ $fns{$func_name} = 1;

+ }

+ }

+

+ if (defined($sumfnccount)) {

+ foreach my $func_name (keys(%{$sumfnccount})) {

+ $fns{$func_name} = 1;

+ }

+ }

+ }

+

+ @result = keys(%fns);

+

+ return \@result;

+}

+

+#

+# rename_functions(info, conv)

+#

+# Rename all function names in INFO according to CONV: OLD_NAME -> NEW_NAME.

+# In case two functions demangle to the same name, assume that they are

+# different object code implementations for the same source function.

+#

+

+sub rename_functions($$)

+{

+ my ($info, $conv) = @_;

+

+ foreach my $filename (keys(%{$info})) {

+ my $data = $info->{$filename};

+ my $funcdata;

+ my $testfncdata;

+ my $sumfnccount;

+ my %newfuncdata;

+ my %newsumfnccount;

+ my $f_found;

+ my $f_hit;

+

+ # funcdata: function name -> line number

+ $funcdata = $data->{"func"};

+ foreach my $fn (keys(%{$funcdata})) {

+ my $cn = $conv->{$fn};

+

+ # Abort if two functions on different lines map to the

+ # same demangled name.

+ if (defined($newfuncdata{$cn}) &&

+ $newfuncdata{$cn} != $funcdata->{$fn}) {

+ die("ERROR: Demangled function name $cn ".

+ "maps to different lines (".

+ $newfuncdata{$cn}." vs ".

+ $funcdata->{$fn}.") in $filename\n");

+ }

+ $newfuncdata{$cn} = $funcdata->{$fn};

+ }

+ $data->{"func"} = \%newfuncdata;

+

+ # testfncdata: test name -> testfnccount

+ # testfnccount: function name -> execution count

+ $testfncdata = $data->{"testfnc"};

+ foreach my $tn (keys(%{$testfncdata})) {

+ my $testfnccount = $testfncdata->{$tn};

+ my %newtestfnccount;

+

+ foreach my $fn (keys(%{$testfnccount})) {

+ my $cn = $conv->{$fn};

+

+ # Add counts for different functions that map

+ # to the same name.

+ $newtestfnccount{$cn} +=

+ $testfnccount->{$fn};

+ }

+ $testfncdata->{$tn} = \%newtestfnccount;

+ }

+

+ # sumfnccount: function name -> execution count

+ $sumfnccount = $data->{"sumfnc"};

+ foreach my $fn (keys(%{$sumfnccount})) {

+ my $cn = $conv->{$fn};

+

+ # Add counts for different functions that map

+ # to the same name.

+ $newsumfnccount{$cn} += $sumfnccount->{$fn};

+ }

+ $data->{"sumfnc"} = \%newsumfnccount;

+

+ # Update function found and hit counts since they may have

+ # changed

+ $f_found = 0;

+ $f_hit = 0;

+ foreach my $fn (keys(%newsumfnccount)) {

+ $f_found++;

+ $f_hit++ if ($newsumfnccount{$fn} > 0);

+ }

+ $data->{"f_found"} = $f_found;

+ $data->{"f_hit"} = $f_hit;

+ }

+}

+ elsif (! @dir_prefix)

+ my $prefix = get_prefix(1, keys(%info_data));

+ if ($prefix)

+ info("Found common filename prefix \"$prefix\"\n");

+ $dir_prefix[0] = $prefix;

+

+ my $msg = "Using user-specified filename prefix ";

+ for my $i (0 .. $#dir_prefix)

+ {

+ $dir_prefix[$i] =~ s/\/+$//;

+ $msg .= ", " unless 0 == $i;

+ $msg .= "\"" . $dir_prefix[$i] . "\"";

+ }

+ info($msg . "\n");

+

+ # Handle files in root directory gracefully

+ $dir_name = "root" if ($dir_name eq "");

+

+ if (!$no_prefix && @dir_prefix)

+ # Match directory names beginning with one of @dir_prefix

+ $dir_name = apply_prefix($dir_name,@dir_prefix);

+ open($handle, "|-", "gzip -c >'$filename'")

+ open($handle, ">", $filename)

+ $title .= " - " if ($trunc_dir ne "");

+ # Match directory name beginning with one of @dir_prefix

+ $rel_dir = apply_prefix($rel_dir,@dir_prefix);

+ # Handle files in root directory gracefully

+ $rel_dir = "root" if ($rel_dir eq "");

+ $trunc_dir = "root" if ($trunc_dir eq "");

+

+ info("Processing file ".apply_prefix($_[2], @dir_prefix)."\n");

+# "f_found" -> $fn_found (number of instrumented functions found in file)

+# "f_hit" -> $fn_hit (number of executed functions in file)

+# "b_found" -> $br_found (number of instrumented branches found in file)

+# "b_hit" -> $br_hit (number of executed branches in file)

+ my $notified_about_relative_paths;

+ open(INFO_HANDLE, "-|", "gunzip -c '$_[0]'")

+ open(INFO_HANDLE, "<", $_[0])

+ $filename = File::Spec->rel2abs($1, Cwd::cwd());

+

+ if (!File::Spec->file_name_is_absolute($1) &&

+ !$notified_about_relative_paths)

+ {

+ info("Resolved relative source file ".

+ "path \"$1\" with CWD to ".

+ "\"$filename\".\n");

+ $notified_about_relative_paths = 1;

+ }

+ last if (!$func_coverage);

+

+ last if (!$func_coverage);

+ last if (!$br_coverage);

+ my $data1_ref = $_[0]; # Hash 1

+ my $data2_ref = $_[1]; # Hash 2

+ foreach $line (keys(%$data1_ref))

+ $data1_count = $data1_ref->{$line};

+ $data2_count = $data2_ref->{$line};

+ # Add lines unique to data2_ref

+ foreach $line (keys(%$data2_ref))

+ # Skip lines already in data1_ref

+ if (defined($data1_ref->{$line})) { next; }

+ # Copy count from data2_ref

+ $result{$line} = $data2_ref->{$line};

+# get_prefix(min_dir, filename_list)

+# sum of the lengths of all resulting shortened filenames while observing

+# that no filename has less than MIN_DIR parent directories.

+sub get_prefix($@)

+ my ($min_dir, @filename_list) = @_;

+ $current = $_;

+ $current .= "/";

+

+ if (exists($prefix{$current})) { last; }

+ # Remove all prefixes that would cause filenames to have less than

+ # the minimum number of parent directories

+ foreach my $filename (@filename_list) {

+ my $dir = dirname($filename);

+

+ for (my $i = 0; $i < $min_dir; $i++) {

+ delete($prefix{$dir."/"});

+ $dir = shorten_prefix($dir);

+ }

+ }

+

+ # Check if any prefix remains

+ return undef if (!%prefix);

+

+ $current =~ s/\/$//;

+

+ open(TEST_HANDLE, "<", $_[0])

+ if (!defined($test_name)) {

+ die("ERROR: Found test description without prior test name in $_[0]:$.\n");

+ }

+ my $hour;

+ my $min;

+ my $sec;

+ ($year, $month, $day, $hour, $min, $sec) =

+ (localtime())[5, 4, 3, 2, 1, 0];

+ return sprintf("%d-%02d-%02d %02d:%02d:%02d", $year+1900, $month+1,

+ $day, $hour, $min, $sec);

+ my $desc = $description{$test_name};

+

+ $desc = escape_html($desc) if (!$rc_desc_html);

+ write_test_table_entry(*HTML_HANDLE, $test_name, $desc);

+ open(PNG_HANDLE, ">", $_)

+ open(*HTACCESS_HANDLE, ">", ".htaccess")

+ open(CSS_HANDLE, ">", "gcov.css")

+ my ($base_dir, $found, $hit) = @_;

+ $alt = rate($hit, $found, "%");

+ $width = rate($hit, $found, undef, 0);

+ $remainder = 100 - $width;

+ $png_name = $rate_png[classify_rate($found, $hit, $med_limit,

+ $rate = rate($hit, $found);

+ my $esc_filename = escape_html($filename);

+ $file_code = "<a href=\"$page_link\">$esc_filename</a>";

+ $file_code = $esc_filename;

+ $rate = rate($hit, $found, "&nbsp;%");

+ my $rate = rate($hit, $found, "&nbsp;%");

+ <meta http-equiv="Content-Type" content="text/html; charset=$charset">

+ <meta http-equiv="Content-Type" content="text/html; charset=$charset">

+ my $esc_trunc_name = escape_html($trunc_name);

+ "$overview_title</a> - $esc_trunc_name";

+ my $esc_base_name = escape_html($base_name);

+ my $esc_dir_name = escape_html($dir_name);

+ "$esc_dir_name</a> - $esc_base_name";

+ "$esc_dir_name</a> - $esc_base_name";

+ if ($sort) {

+ $view .= " (source / <a href=\"$base_name.func-sort-c.$html_ext\">functions</a>)";

+ } else {

+ $view .= " (source / <a href=\"$base_name.func.$html_ext\">functions</a>)";

+ }

+ $rate = rate($lines_hit, $lines_found, " %");

+ $rate = rate($fn_hit, $fn_found, " %");

+ $rate = rate($br_hit, $br_found, " %");

+ $block = -1 if ($block == $BR_VEC_MAX);

+ $block = $BR_VEC_MAX if $block < 0;

+ $v_block = $BR_VEC_MAX if $v_block < 0;

+ my @file;

+ if (!open(SOURCE_HANDLE, "<", $source_filename)) {

+ my @lines;

+ my $last_line = 0;

+

+ if (!$ignore[$ERROR_SOURCE]) {

+ die("ERROR: cannot read $source_filename\n");

+ }

+

+ # Continue without source file

+ warn("WARNING: cannot read $source_filename!\n");

+

+ @lines = sort( { $a <=> $b } keys(%count_data));

+ if (@lines) {

+ $last_line = $lines[scalar(@lines) - 1];

+ }

+ return ( ":" ) if ($last_line < 1);

+

+ # Simulate gcov behavior

+ for ($line_number = 1; $line_number <= $last_line;

+ $line_number++) {

+ push(@file, "/* EOF */");

+ }

+ } else {

+ @file = <SOURCE_HANDLE>;

+ }

+ $line_number = 0;

+ foreach (@file) {

+ $line_number++;

+ return sort({

+ $sumfncdata->{$b} == $sumfncdata->{$a} ?

+ $a cmp $b : $sumfncdata->{$a} <=> $sumfncdata->{$b}

+ } keys(%{$sumfncdata}));

+}

+

+sub demangle_list($)

+{

+ my ($list) = @_;

+ my $tmpfile;

+ my $handle;

+ my %demangle;

+ my %versions;

+

+ # Write function names to file

+ ($handle, $tmpfile) = tempfile();

+ die("ERROR: could not create temporary file") if (!defined($tmpfile));

+ print($handle join("\n", @$list));

+ close($handle);

+

+ # Build translation hash from c++filt output

+ open($handle, "-|", "c++filt < $tmpfile") or

+ die("ERROR: could not run c++filt: $!\n");

+ foreach my $func (@$list) {

+ my $translated = <$handle>;

+ my $version;

+

+ last if (!defined($translated));

+ chomp($translated);

+

+ $version = ++$versions{$translated};

+ $translated .= ".$version" if ($version > 1);

+ $demangle{$func} = $translated;

+ }

+ close($handle);

+

+ if (scalar(keys(%demangle)) != scalar(@$list)) {

+ die("ERROR: c++filt output not as expected (".

+ scalar(keys(%demangle))." vs ".scalar(@$list).") lines\n");

+ }

+

+ unlink($tmpfile) or

+ warn("WARNING: could not remove temporary file $tmpfile: $!\n");

+

+ return \%demangle;

+ my $demangle;

+

+ # Get demangle translation hash

+ if ($demangle_cpp) {

+ $demangle = demangle_list([ sort(keys(%{$funcdata})) ]);

+ }

+

+ # Replace function name with demangled version if available

+ $name = $demangle->{$name} if (exists($demangle->{$name}));

+

+ # Escape special characters

+# apply_prefix(filename, PREFIXES)

+# If FILENAME begins with PREFIX from PREFIXES, remove PREFIX from FILENAME

+# and return resulting string, otherwise return FILENAME.

+sub apply_prefix($@)

+ my $filename = shift;

+ my @dir_prefix = @_;

+ if (@dir_prefix)

+ foreach my $prefix (@dir_prefix)

+ if ($prefix ne "" && $filename =~ /^\Q$prefix\E\/(.*)$/)

+ {

+ return substr($filename, length($prefix) + 1);

+ }

+ ($mode & 1) && open(OLD_STDOUT, ">>&", "STDOUT");

+ ($mode & 2) && open(OLD_STDERR, ">>&", "STDERR");

+ ($mode & 1) && open(STDOUT, ">", "/dev/null");

+ ($mode & 2) && open(STDERR, ">", "/dev/null");

+ ($mode & 1) && open(STDOUT, ">>&", "OLD_STDOUT");

+ ($mode & 2) && open(STDERR, ">>&", "OLD_STDERR");

+ if (!open(HANDLE, "<", $filename))

+# variable. If the global configuration hashes CONFIG or OPT_RC contain a value

+# for keyword KEY_STRING, VAR_REF will be assigned the value for that keyword.

+ if (defined($opt_rc{$_})) {

+ ${$ref->{$_}} = $opt_rc{$_};

+ } elsif (defined($config->{$_})) {

+ open(HANDLE, "<", $filename)

+ <meta http-equiv="Content-Type" content="text/html; charset=$charset">

+ open(HANDLE, "<", $filename)

+

+#

+# parse_ignore_errors(@ignore_errors)

+#

+# Parse user input about which errors to ignore.

+#

+

+sub parse_ignore_errors(@)

+{

+ my (@ignore_errors) = @_;

+ my @items;

+ my $item;

+

+ return if (!@ignore_errors);

+

+ foreach $item (@ignore_errors) {

+ $item =~ s/\s//g;

+ if ($item =~ /,/) {

+ # Split and add comma-separated parameters

+ push(@items, split(/,/, $item));

+ } else {

+ # Add single parameter

+ push(@items, $item);

+ }

+ }

+ foreach $item (@items) {

+ my $item_id = $ERROR_ID{lc($item)};

+

+ if (!defined($item_id)) {

+ die("ERROR: unknown argument for --ignore-errors: ".

+ "$item\n");

+ }

+ $ignore[$item_id] = 1;

+ }

+}

+

+#

+# parse_dir_prefix(@dir_prefix)

+#

+# Parse user input about the prefix list

+#

+

+sub parse_dir_prefix(@)

+{

+ my (@opt_dir_prefix) = @_;

+ my $item;

+

+ return if (!@opt_dir_prefix);

+

+ foreach $item (@opt_dir_prefix) {

+ if ($item =~ /,/) {

+ # Split and add comma-separated parameters

+ push(@dir_prefix, split(/,/, $item));

+ } else {

+ # Add single parameter

+ push(@dir_prefix, $item);

+ }

+ }

+}

+

+#

+# rate(hit, found[, suffix, precision, width])

+#

+# Return the coverage rate [0..100] for HIT and FOUND values. 0 is only

+# returned when HIT is 0. 100 is only returned when HIT equals FOUND.

+# PRECISION specifies the precision of the result. SUFFIX defines a

+# string that is appended to the result if FOUND is non-zero. Spaces

+# are added to the start of the resulting string until it is at least WIDTH

+# characters wide.

+#

+

+sub rate($$;$$$)

+{

+ my ($hit, $found, $suffix, $precision, $width) = @_;

+ my $rate;

+

+ # Assign defaults if necessary

+ $precision = $default_precision if (!defined($precision));

+ $suffix = "" if (!defined($suffix));

+ $width = 0 if (!defined($width));

+

+ return sprintf("%*s", $width, "-") if (!defined($found) || $found == 0);

+ $rate = sprintf("%.*f", $precision, $hit * 100 / $found);

+

+ # Adjust rates if necessary

+ if ($rate == 0 && $hit > 0) {

+ $rate = sprintf("%.*f", $precision, 1 / 10 ** $precision);

+ } elsif ($rate == 100 && $hit != $found) {

+ $rate = sprintf("%.*f", $precision, 100 - 1 / 10 ** $precision);

+ }

+

+ return sprintf("%*s", $width, $rate.$suffix);

+}

+# Copyright (c) International Business Machines Corp., 2002,2012

+ splitpath catpath/;

+use Cwd qw/abs_path/;

+if( $^O eq "msys" )

+{

+ require File::Spec::Win32;

+}

+our $tool_dir = abs_path(dirname($0));

+our $lcov_version = "LCOV version 1.12";

+our $GCOV_VERSION_4_7_0 = 0x40700;

+# Error classes which users may specify to ignore during processing

+our %ERROR_ID = (

+ "gcov" => $ERROR_GCOV,

+ "source" => $ERROR_SOURCE,

+ "graph" => $ERROR_GRAPH,

+);

+

+# Marker to exclude branch coverage but keep function and line coveage

+our $EXCL_BR_START = "LCOV_EXCL_BR_START";

+our $EXCL_BR_STOP = "LCOV_EXCL_BR_STOP";

+

+# Compatibility mode values

+our $COMPAT_VALUE_OFF = 0;

+our $COMPAT_VALUE_ON = 1;

+our $COMPAT_VALUE_AUTO = 2;

+

+# Compatibility mode value names

+our %COMPAT_NAME_TO_VALUE = (

+ "off" => $COMPAT_VALUE_OFF,

+ "on" => $COMPAT_VALUE_ON,

+ "auto" => $COMPAT_VALUE_AUTO,

+);

+

+# Compatiblity modes

+our $COMPAT_MODE_LIBTOOL = 1 << 0;

+our $COMPAT_MODE_HAMMER = 1 << 1;

+our $COMPAT_MODE_SPLIT_CRC = 1 << 2;

+

+# Compatibility mode names

+our %COMPAT_NAME_TO_MODE = (

+ "libtool" => $COMPAT_MODE_LIBTOOL,

+ "hammer" => $COMPAT_MODE_HAMMER,

+ "split_crc" => $COMPAT_MODE_SPLIT_CRC,

+ "android_4_4_0" => $COMPAT_MODE_SPLIT_CRC,

+);

+

+# Map modes to names

+our %COMPAT_MODE_TO_NAME = (

+ $COMPAT_MODE_LIBTOOL => "libtool",

+ $COMPAT_MODE_HAMMER => "hammer",

+ $COMPAT_MODE_SPLIT_CRC => "split_crc",

+);

+

+# Compatibility mode default values

+our %COMPAT_MODE_DEFAULTS = (

+ $COMPAT_MODE_LIBTOOL => $COMPAT_VALUE_ON,

+ $COMPAT_MODE_HAMMER => $COMPAT_VALUE_AUTO,

+ $COMPAT_MODE_SPLIT_CRC => $COMPAT_VALUE_AUTO,

+);

+

+# Compatibility mode auto-detection routines

+sub compat_hammer_autodetect();

+our %COMPAT_MODE_AUTO = (

+ $COMPAT_MODE_HAMMER => \&compat_hammer_autodetect,

+ $COMPAT_MODE_SPLIT_CRC => 1, # will be done later

+);

+our $BR_VEC_MAX = vec(pack('b*', 1 x $BR_VEC_WIDTH), 0, $BR_VEC_WIDTH);

+our $UNNAMED_BLOCK = -1;

+sub graph_read(*$;$$);

+sub uniq(@);

+sub read_bb($);

+sub read_bbg_lines_record(*$$$$$);

+sub read_bbg($);

+sub read_gcno_word(*;$$);

+sub read_gcno_value(*$;$$);

+sub read_gcno_lines_record(*$$$$$$);

+sub determine_gcno_split_crc($$$);

+sub read_gcno($);

+sub parse_ignore_errors(@);

+sub is_external($);

+sub compat_name($);

+sub parse_compat_modes($);

+sub is_compat($);

+sub is_compat_auto($);

+our $gcov_version_string;

+our $opt_compat_libtool;

+our $opt_no_compat_libtool;

+our $rc_adjust_src_path;# Regexp specifying parts to remove from source path

+our $adjust_src_pattern;

+our $adjust_src_replace;

+our $opt_external = 1;

+our $opt_no_external;

+our @internal_dirs;

+our $opt_config_file;

+our $opt_gcov_all_blocks = 1;

+our $opt_compat;

+our %opt_rc;

+our %compat_value;

+our $gcno_split_crc;

+our $func_coverage = 1;

+our $br_coverage = 0;

+our $rc_auto_base = 1;

+our $excl_line = "LCOV_EXCL_LINE";

+our $excl_br_line = "LCOV_EXCL_BR_LINE";

+# Set LC_ALL so that gcov output will be in a unified format

+$ENV{"LC_ALL"} = "C";

+# Check command line for a configuration file name

+Getopt::Long::Configure("pass_through", "no_auto_abbrev");

+GetOptions("config-file=s" => \$opt_config_file,

+ "rc=s%" => \%opt_rc);

+Getopt::Long::Configure("default");

+

+{

+ # Remove spaces around rc options

+ my %new_opt_rc;

+

+ while (my ($key, $value) = each(%opt_rc)) {

+ $key =~ s/^\s+|\s+$//g;

+ $value =~ s/^\s+|\s+$//g;

+

+ $new_opt_rc{$key} = $value;

+ }

+ %opt_rc = %new_opt_rc;

+}

+if (defined($opt_config_file)) {

+ $config = read_config($opt_config_file);

+} elsif (defined($ENV{"HOME"}) && (-r $ENV{"HOME"}."/.lcovrc"))

+if ($config || %opt_rc)

+ # Copy configuration file and --rc values to variables

+ "geninfo_compat_libtool" => \$opt_compat_libtool,

+ "geninfo_external" => \$opt_external,

+ "geninfo_gcov_all_blocks" => \$opt_gcov_all_blocks,

+ "geninfo_compat" => \$opt_compat,

+ "geninfo_adjust_src_path" => \$rc_adjust_src_path,

+ "geninfo_auto_base" => \$rc_auto_base,

+ "lcov_function_coverage" => \$func_coverage,

+ "lcov_branch_coverage" => \$br_coverage,

+ "lcov_excl_line" => \$excl_line,

+ "lcov_excl_br_line" => \$excl_br_line,

+ });

+

+ # Check regexp

+ if (defined($rc_adjust_src_path)) {

+ my ($pattern, $replace) = split(/\s*=>\s*/,

+ $rc_adjust_src_path);

+ local $SIG{__DIE__};

+ eval '$adjust_src_pattern = qr>'.$pattern.'>;';

+ if (!defined($adjust_src_pattern)) {

+ my $msg = $@;

+

+ chomp($msg);

+ $msg =~ s/at \(eval.*$//;

+ warn("WARNING: invalid pattern in ".

+ "geninfo_adjust_src_path: $msg\n");

+ } elsif (!defined($replace)) {

+ # If no replacement is specified, simply remove pattern

+ $adjust_src_replace = "";

+ } else {

+ $adjust_src_replace = $replace;

+ }

+ }

+ for my $regexp (($excl_line, $excl_br_line)) {

+ eval 'qr/'.$regexp.'/';

+ my $error = $@;

+ chomp($error);

+ $error =~ s/at \(eval.*$//;

+ die("ERROR: invalid exclude pattern: $error") if $error;

+ }

+ "compat-libtool" => \$opt_compat_libtool,

+ "no-compat-libtool" => \$opt_no_compat_libtool,

+ "external" => \$opt_external,

+ "no-external" => \$opt_no_external,

+ "compat=s" => \$opt_compat,

+ "config-file=s" => \$opt_config_file,

+ "rc=s%" => \%opt_rc,

+ if (defined($opt_no_compat_libtool))

+ $opt_compat_libtool = ($opt_no_compat_libtool ? 0 : 1);

+ $opt_no_compat_libtool = undef;

+ }

+

+ if (defined($opt_no_external)) {

+ $opt_external = 0;

+ $opt_no_external = undef;

+# Check gcov tool

+if (system_no_output(3, $gcov_tool, "--help") == -1)

+{

+ die("ERROR: need tool $gcov_tool!\n");

+}

+

+($gcov_version, $gcov_version_string) = get_gcov_version();

+

+# Determine gcov options

+$gcov_caps = get_gcov_capabilities();

+push(@gcov_options, "-b") if ($gcov_caps->{'branch-probabilities'} &&

+ ($br_coverage || $func_coverage));

+push(@gcov_options, "-c") if ($gcov_caps->{'branch-counts'} &&

+ $br_coverage);

+push(@gcov_options, "-a") if ($gcov_caps->{'all-blocks'} &&

+ $opt_gcov_all_blocks && $br_coverage);

+push(@gcov_options, "-p") if ($gcov_caps->{'preserve-paths'});

+

+# Determine compatibility modes

+parse_compat_modes($opt_compat);

+

+# Determine which errors the user wants us to ignore

+parse_ignore_errors(@ignore_errors);

+

+ if (is_compat($COMPAT_MODE_HAMMER))

+ open(DUMMY_HANDLE, ">", $output_filename)

+# Build list of directories to identify external files

+foreach my $entry(@data_directory, $base_directory) {

+ next if (!defined($entry));

+ push(@internal_dirs, solve_relative_path($cwd, $entry));

+}

+

+if ($initial && $br_coverage) {

+ --(no-)external Include (ignore) data for external files

+ --config-file FILENAME Specify configuration file location

+ --rc SETTING=VALUE Override configuration file setting

+ --compat MODE=on|off|auto Set compat MODE (libtool, hammer, split_crc)

+ @file_list = `find "$directory" $maxdepth $follow -name \\*$ext -type f -o -name \\*$ext -type l 2>/dev/null`;

+ if (!@file_list) {

+ warn("WARNING: no $ext files found in $directory - ".

+ "skipping!\n");

+ return;

+ }

+#

+# derive_data(contentdata, funcdata, bbdata)

+#

+# Calculate function coverage data by combining line coverage data and the

+# list of lines belonging to a function.

+#

+# contentdata: [ instr1, count1, source1, instr2, count2, source2, ... ]

+# instr<n>: Instrumentation flag for line n

+# count<n>: Execution count for line n

+# source<n>: Source code for line n

+#

+# funcdata: [ count1, func1, count2, func2, ... ]

+# count<n>: Execution count for function number n

+# func<n>: Function name for function number n

+#

+# bbdata: function_name -> [ line1, line2, ... ]

+# line<n>: Line number belonging to the corresponding function

+#

+

+ my $fninstr = 0;

+ my $linstr = $gcov_content[ ( $line - 1 ) * 3 + 0 ];

+ next if (!$linstr);

+ $fninstr = 1;

+ next if (!$fninstr);

+ $source_dir = $da_dir;

+ if (is_compat($COMPAT_MODE_LIBTOOL)) {

+ # Avoid files from .libs dirs

+ $source_dir =~ s/\.libs$//;

+ if (is_compat($COMPAT_MODE_HAMMER))

+ ($instr, $graph) = read_bbg($bb_filename);

+ ($instr, $graph) = read_bb($bb_filename);

+ ($instr, $graph) = read_gcno($bb_filename);

+ # Try to find base directory automatically if requested by user

+ if ($rc_auto_base) {

+ $base_dir = find_base_from_graph($base_dir, $instr, $graph);

+ }

+

+ ($instr, $graph) = adjust_graph_filenames($base_dir, $instr, $graph);

+

+ debug("chdir($base_dir)\n");

+ open(INFO_HANDLE, ">>", $output_filename)

+ open(INFO_HANDLE, ">", "$da_filename.info")

+ # Skip gcov file for gcc built-in code

+ next if ($gcov_file eq "<built-in>.gcov");

+

+ if (!defined($source)) {

+ # Derive source file name from gcov file name if

+ # header format could not be parsed

+ $source = $gcov_file;

+ $source =~ s/\.gcov$//;

+ }

+

+ $source = solve_relative_path($base_dir, $source);

+

+ if (defined($adjust_src_pattern)) {

+ # Apply transformation as specified by user

+ $source =~ s/$adjust_src_pattern/$adjust_src_replace/g;

+ if (! -r $source && $checksum)

+ @matches = match_filename($source, keys(%{$instr}));

+ # Skip external files if requested

+ if (!$opt_external) {

+ if (is_external($source_filename)) {

+ info(" ignoring data for external file ".

+ "$source_filename\n");

+ unlink($gcov_file);

+ next;

+ $block = $BR_VEC_MAX if ($block < 0);

+ my $volume;

+ my $directories;

+ my $filename;

+ my @dirs; # holds path elements

+ # Convert from Windows path to msys path

+ if( $^O eq "msys" )

+ {

+ # search for a windows drive letter at the beginning

+ ($volume, $directories, $filename) = File::Spec::Win32->splitpath( $dir );

+ if( $volume ne '' )

+ {

+ my $uppercase_volume;

+ # transform c/d\../e/f\g to Windows style c\d\..\e\f\g

+ $dir = File::Spec::Win32->canonpath( $dir );

+ # use Win32 module to retrieve path components

+ # $uppercase_volume is not used any further

+ ( $uppercase_volume, $directories, $filename ) = File::Spec::Win32->splitpath( $dir );

+ @dirs = File::Spec::Win32->splitdir( $directories );

+

+ # prepend volume, since in msys C: is always mounted to /c

+ $volume =~ s|^([a-zA-Z]+):|/\L$1\E|;

+ unshift( @dirs, $volume );

+

+ # transform to Unix style '/' path

+ $directories = File::Spec->catdir( @dirs );

+ $dir = File::Spec->catpath( '', $directories, $filename );

+ } else {

+ # eliminate '\' path separators

+ $dir = File::Spec->canonpath( $dir );

+ }

+ }

+

+ $result =~ s/\/\.$/\//g;

+

+ # Remove trailing /

+ $result =~ s/\/$//g;

+ open(SOURCE, "<", $filename)

+ if (!open(INPUT, "<", $_[0]))

+ $block = -1 if ($block == $BR_VEC_MAX);

+ $block = $BR_VEC_MAX if $block < 0;

+ my $exclude_br_flag = 0;

+ my $exclude_branch = 0;

+ if (!open(INPUT, "<", $filename)) {

+ next if (!$br_coverage);

+ next if ($exclude_branch);

+ next if (!$br_coverage);

+ next if ($exclude_branch);

+ if (/$excl_line/ || $exclude_flag) {

+ # Check for exclusion markers (branch exclude)

+ if (!$no_markers) {

+ if (/$EXCL_BR_STOP/) {

+ $exclude_br_flag = 0;

+ } elsif (/$EXCL_BR_START/) {

+ $exclude_br_flag = 1;

+ }

+ if (/$excl_br_line/ || $exclude_br_flag) {

+ $exclude_branch = 1;

+ } else {

+ $exclude_branch = 0;

+ }

+ }

+ next if (!$br_coverage);

+ next if ($exclude_branch);

+ next if (!$br_coverage);

+ next if ($exclude_branch);

+ elsif (/^function\s+(.+)\s+called\s+(\d+)\s+/)

+ next if (!$func_coverage);

+ if (/$excl_line/ || $exclude_flag) {

+ # Check for exclusion markers (branch exclude)

+ if (!$no_markers) {

+ if (/$EXCL_BR_STOP/) {

+ $exclude_br_flag = 0;

+ } elsif (/$EXCL_BR_START/) {

+ $exclude_br_flag = 1;

+ }

+ if (/$excl_br_line/ || $exclude_br_flag) {

+ $exclude_branch = 1;

+ } else {

+ $exclude_branch = 0;

+ }

+ }

+

+ if ($count =~ /^[#=]/) {

+ if ($exclude_flag || $exclude_br_flag) {

+ my $pipe_next_line;

+ open(GCOV_PIPE, "-|", "$gcov_tool --version")

+ # LLVM gcov keeps version information on the second line.

+ # For example, gcov --version yields:

+ # LLVM (http://llvm.org/):

+ # LLVM version 3.4svn

+

+ $pipe_next_line = <GCOV_PIPE>;

+ # In case version information is on first line.

+ # For example, with Xcode 7.0 gcov --version yields:

+ # Apple LLVM 7.0.0 (clang-700.0.65)

+

+ $version_string = $pipe_next_line if ($pipe_next_line && $version_string =~ /LLVM/);

+ # Remove version information in parenthesis to cope with the following:

+ # - gcov (GCC) 4.4.7 20120313 (Red Hat 4.4.7-3)

+ # - gcov (crosstool-NG 1.18.0) 4.7.2

+ $version_string =~ s/\([^\)]*\)//g;

+

+ if ($version_string =~ /LLVM/)

+ # Map LLVM versions to the version of GCC gcov which

+ # they emulate

+ if ($result >= 0x030400)

+ {

+ info("Found LLVM gcov version 3.4, which emulates gcov version 4.2\n");

+ $result = 0x040200;

+ }

+ else

+ {

+ warn("This version of LLVM's gcov is unknown. Assuming it emulates GCC gcov version 4.2.\n");

+ $result = 0x040200;

+ }

+ return ($result, $version_string);

+ ($mode & 1) && open(OLD_STDOUT, ">>&", "STDOUT");

+ ($mode & 2) && open(OLD_STDERR, ">>&", "STDERR");

+ ($mode & 1) && open(STDOUT, ">", "/dev/null");

+ ($mode & 2) && open(STDERR, ">", "/dev/null");

+ debug("system(".join(' ', @_).")\n");

+ ($mode & 1) && open(STDOUT, ">>&", "OLD_STDOUT");

+ ($mode & 2) && open(STDERR, ">>&", "OLD_STDERR");

+ if (!open(HANDLE, "<", $filename))

+# variable. If the global configuration hashes CONFIG or OPT_RC contain a value

+# for keyword KEY_STRING, VAR_REF will be assigned the value for that keyword.

+ if (defined($opt_rc{$_})) {

+ ${$ref->{$_}} = $opt_rc{$_};

+ } elsif (defined($config->{$_})) {

+ if (!open(HANDLE, "<", $filename)) {

+ if (/$excl_line/ || $flag) {

+ $instr->{$filename} = \@new_data;

+ $source_dir = $graph_dir;

+ if (is_compat($COMPAT_MODE_LIBTOOL)) {

+ # Avoid files from .libs dirs

+ $source_dir =~ s/\.libs$//;

+ # Ignore empty graph file (e.g. source file with no statement)

+ if (-z $graph_filename)

+ {

+ warn("WARNING: empty $graph_filename (skipped)\n");

+ return;

+ }

+

+ if (is_compat($COMPAT_MODE_HAMMER))

+ ($instr, $graph) = read_bbg($graph_filename);

+ ($instr, $graph) = read_bb($graph_filename);

+ ($instr, $graph) = read_gcno($graph_filename);

+ # Try to find base directory automatically if requested by user

+ if ($rc_auto_base) {

+ $base_dir = find_base_from_graph($base_dir, $instr, $graph);

+ }

+

+ ($instr, $graph) = adjust_graph_filenames($base_dir, $instr, $graph);

+

+ open(INFO_HANDLE, ">>", $output_filename)

+ open(INFO_HANDLE, ">", "$graph_filename.info")

+ # Skip external files if requested

+ if (!$opt_external) {

+ if (is_external($filename)) {

+ info(" ignoring data for external file ".

+ "$filename\n");

+ next;

+ }

+ }

+

+ if (defined($funcdata) && $func_coverage) {

+# graph_read(handle, bytes[, description, peek])

+# if the number of bytes could not be read. If PEEK is non-zero, reset

+# file position after read.

+sub graph_read(*$;$$)

+ my ($handle, $length, $desc, $peek) = @_;

+ my $pos;

+ if ($peek) {

+ $pos = tell($handle);

+ if ($pos == -1) {

+ warn("Could not get current file position: $!\n");

+ return undef;

+ }

+ }

+ my $op = $peek ? "peek" : "read";

+ print(STDERR "DEBUG: $op($length)=$result: ");

+ if ($peek) {

+ if (!seek($handle, $pos, 0)) {

+ warn("Could not set file position: $!\n");

+ return undef;

+ }

+ }

+# uniq(list)

+#

+# Return list without duplicate entries.

+#

+

+sub uniq(@)

+{

+ my (@list) = @_;

+ my @new_list;

+ my %known;

+

+ foreach my $item (@list) {

+ next if ($known{$item});

+ $known{$item} = 1;

+ push(@new_list, $item);

+ }

+

+ return @new_list;

+}

+

+#

+# parent_dir(dir)

+#

+# Return parent directory for DIR. DIR must not contain relative path

+# components.

+#

+

+sub parent_dir($)

+{

+ my ($dir) = @_;

+ my ($v, $d, $f) = splitpath($dir, 1);

+ my @dirs = splitdir($d);

+

+ pop(@dirs);

+

+ return catpath($v, catdir(@dirs), $f);

+}

+

+#

+# find_base_from_graph(base_dir, instr, graph)

+#

+# Try to determine the base directory of the graph file specified by INSTR

+# and GRAPH. The base directory is the base for all relative filenames in

+# the graph file. It is defined by the current working directory at time

+# of compiling the source file.

+#

+# This function implements a heuristic which relies on the following

+# assumptions:

+# - all files used for compilation are still present at their location

+# - the base directory is either BASE_DIR or one of its parent directories

+# - files by the same name are not present in multiple parent directories

+#

+

+sub find_base_from_graph($$$)

+{

+ my ($base_dir, $instr, $graph) = @_;

+ my $old_base;

+ my $best_miss;

+ my $best_base;

+ my %rel_files;

+

+ # Determine list of relative paths

+ foreach my $filename (keys(%{$instr}), keys(%{$graph})) {

+ next if (file_name_is_absolute($filename));

+

+ $rel_files{$filename} = 1;

+ }

+

+ # Early exit if there are no relative paths

+ return $base_dir if (!%rel_files);

+

+ do {

+ my $miss = 0;

+

+ foreach my $filename (keys(%rel_files)) {

+ if (!-e solve_relative_path($base_dir, $filename)) {

+ $miss++;

+ }

+ }

+

+ debug("base_dir=$base_dir miss=$miss\n");

+

+ # Exit if we find an exact match with no misses

+ return $base_dir if ($miss == 0);

+

+ # No exact match, aim for the one with the least source file

+ # misses

+ if (!defined($best_base) || $miss < $best_miss) {

+ $best_base = $base_dir;

+ $best_miss = $miss;

+ }

+

+ # Repeat until there's no more parent directory

+ $old_base = $base_dir;

+ $base_dir = parent_dir($base_dir);

+ } while ($old_base ne $base_dir);

+

+ return $best_base;

+}

+

+#

+# adjust_graph_filenames(base_dir, instr, graph)

+#

+# Make relative paths in INSTR and GRAPH absolute and apply

+# geninfo_adjust_src_path setting to graph file data.

+#

+

+sub adjust_graph_filenames($$$)

+{

+ my ($base_dir, $instr, $graph) = @_;

+

+ foreach my $filename (keys(%{$instr})) {

+ my $old_filename = $filename;

+

+ # Convert to absolute canonical form

+ $filename = solve_relative_path($base_dir, $filename);

+

+ # Apply adjustment

+ if (defined($adjust_src_pattern)) {

+ $filename =~ s/$adjust_src_pattern/$adjust_src_replace/g;

+ }

+

+ if ($filename ne $old_filename) {

+ $instr->{$filename} = delete($instr->{$old_filename});

+ }

+ }

+

+ foreach my $filename (keys(%{$graph})) {

+ my $old_filename = $filename;

+

+ # Make absolute

+ # Convert to absolute canonical form

+ $filename = solve_relative_path($base_dir, $filename);

+

+ # Apply adjustment

+ if (defined($adjust_src_pattern)) {

+ $filename =~ s/$adjust_src_pattern/$adjust_src_replace/g;

+ }

+

+ if ($filename ne $old_filename) {

+ $graph->{$filename} = delete($graph->{$old_filename});

+ }

+ }

+

+ return ($instr, $graph);

+}

+

+#

+ $per_file->{$function} = [ uniq(@$lines) ];

+

+# read_bb(filename)

+# See the gcov info pages of gcc 2.95 for a description of the .bb file format.

+sub read_bb($)

+ my ($bb_filename) = @_;

+ open(HANDLE, "<", $bb_filename) or goto open_error;

+# function)

+sub read_bbg_lines_record(*$$$$$)

+ my ($handle, $bbg_filename, $bb, $fileorder, $filename, $function) = @_;

+ $filename = $string;

+ if (!exists($bb->{$function}->{$filename})) {

+ $bb->{$function}->{$filename} = [];

+ }

+# read_bbg(filename)

+# See the gcov-io.h file in the SLES 9 gcc 3.3.3 source code for a description

+# of the .bbg format.

+sub read_bbg($)

+ my ($bbg_filename) = @_;

+ open(HANDLE, "<", $bbg_filename) or goto open_error;

+ $function);

+# read_gcno_word(handle[, description, peek])

+sub read_gcno_word(*;$$)

+ my ($handle, $desc, $peek) = @_;

+ return graph_read($handle, 4, $desc, $peek);

+# read_gcno_value(handle, big_endian[, description, peek])

+# according to the specified endianness. If PEEK is non-zero, reset file

+# position after read.

+sub read_gcno_value(*$;$$)

+ my ($handle, $big_endian, $desc, $peek) = @_;

+ my $pos;

+ $word = read_gcno_word($handle, $desc, $peek);

+# function, big_endian)

+sub read_gcno_lines_record(*$$$$$$)

+ $big_endian) = @_;

+ $filename = $string;

+ if (!exists($bb->{$function}->{$filename})) {

+ $bb->{$function}->{$filename} = [];

+ }

+# determine_gcno_split_crc(handle, big_endian, rec_length)

+#

+# Determine if HANDLE refers to a .gcno file with a split checksum function

+# record format. Return non-zero in case of split checksum format, zero

+# otherwise, undef in case of read error.

+#

+

+sub determine_gcno_split_crc($$$)

+{

+ my ($handle, $big_endian, $rec_length) = @_;

+ my $strlen;

+ my $overlong_string;

+

+ return 1 if ($gcov_version >= $GCOV_VERSION_4_7_0);

+ return 1 if (is_compat($COMPAT_MODE_SPLIT_CRC));

+

+ # Heuristic:

+ # Decide format based on contents of next word in record:

+ # - pre-gcc 4.7

+ # This is the function name length / 4 which should be

+ # less than the remaining record length

+ # - gcc 4.7

+ # This is a checksum, likely with high-order bits set,

+ # resulting in a large number

+ $strlen = read_gcno_value($handle, $big_endian, undef, 1);

+ return undef if (!defined($strlen));

+ $overlong_string = 1 if ($strlen * 4 >= $rec_length - 12);

+

+ if ($overlong_string) {

+ if (is_compat_auto($COMPAT_MODE_SPLIT_CRC)) {

+ info("Auto-detected compatibility mode for split ".

+ "checksum .gcno file format\n");

+

+ return 1;

+ } else {

+ # Sanity check

+ warn("Found overlong string in function record: ".

+ "try '--compat split_crc'\n");

+ }

+ }

+

+ return 0;

+}

+

+#

+# read_gcno_function_record(handle, graph, big_endian, rec_length)

+ my ($handle, $bb, $fileorder, $big_endian, $rec_length) = @_;

+ # Determine if this is a function record with split checksums

+ if (!defined($gcno_split_crc)) {

+ $gcno_split_crc = determine_gcno_split_crc($handle, $big_endian,

+ $rec_length);

+ return undef if (!defined($gcno_split_crc));

+ }

+ # Skip cfg checksum word in case of split checksums

+ graph_skip($handle, 4, "function cfg checksum") if ($gcno_split_crc);

+# read_gcno(filename)

+# See the gcov-io.h file in the gcc 3.3 source code for a description of

+# the .gcno format.

+sub read_gcno($)

+ my ($gcno_filename) = @_;

+ my $filelength;

+ open(HANDLE, "<", $gcno_filename) or goto open_error;

+ $filelength = (stat(HANDLE))[7];

+ # Catch garbage at the end of a gcno file

+ if ($next_pos > $filelength) {

+ debug("Overlong record: file_length=$filelength ".

+ "rec_length=$length\n");

+ warn("WARNING: $gcno_filename: Overlong record at end ".

+ "of file!\n");

+ last;

+ }

+ *HANDLE, $bb, $fileorder, $big_endian,

+ $length);

+ $filename, $function,

+ my %short_option_translations = (

+ 'a' => 'all-blocks',

+ 'b' => 'branch-probabilities',

+ 'c' => 'branch-counts',

+ 'f' => 'function-summaries',

+ 'h' => 'help',

+ 'l' => 'long-file-names',

+ 'n' => 'no-output',

+ 'o' => 'object-directory',

+ 'p' => 'preserve-paths',

+ 'u' => 'unconditional-branches',

+ 'v' => 'version',

+ );

+ my $capability;

+ if (/--(\S+)/) {

+ $capability = $1;

+ } else {

+ # If the line provides a short option, translate it.

+ next if (!/^\s*-(\S)\s/);

+ $capability = $short_option_translations{$1};

+ next if not defined($capability);

+ }

+ next if ($capability eq 'help');

+ next if ($capability eq 'version');

+ next if ($capability eq 'object-directory');

+ $capabilities{$capability} = 1;

+ debug("gcov has capability '$capability'\n");

+

+#

+# parse_ignore_errors(@ignore_errors)

+#

+# Parse user input about which errors to ignore.

+#

+

+sub parse_ignore_errors(@)

+{

+ my (@ignore_errors) = @_;

+ my @items;

+ my $item;

+

+ return if (!@ignore_errors);

+

+ foreach $item (@ignore_errors) {

+ $item =~ s/\s//g;

+ if ($item =~ /,/) {

+ # Split and add comma-separated parameters

+ push(@items, split(/,/, $item));

+ } else {

+ # Add single parameter

+ push(@items, $item);

+ }

+ }

+ foreach $item (@items) {

+ my $item_id = $ERROR_ID{lc($item)};

+

+ if (!defined($item_id)) {

+ die("ERROR: unknown argument for --ignore-errors: ".

+ "$item\n");

+ }

+ $ignore[$item_id] = 1;

+ }

+}

+

+#

+# is_external(filename)

+#

+# Determine if a file is located outside of the specified data directories.

+#

+

+sub is_external($)

+{

+ my ($filename) = @_;

+ my $dir;

+

+ foreach $dir (@internal_dirs) {

+ return 0 if ($filename =~ /^\Q$dir\/\E/);

+ }

+ return 1;

+}

+

+#

+# compat_name(mode)

+#

+# Return the name of compatibility mode MODE.

+#

+

+sub compat_name($)

+{

+ my ($mode) = @_;

+ my $name = $COMPAT_MODE_TO_NAME{$mode};

+

+ return $name if (defined($name));

+

+ return "<unknown>";

+}

+

+#

+# parse_compat_modes(opt)

+#

+# Determine compatibility mode settings.

+#

+

+sub parse_compat_modes($)

+{

+ my ($opt) = @_;

+ my @opt_list;

+ my %specified;

+

+ # Initialize with defaults

+ %compat_value = %COMPAT_MODE_DEFAULTS;

+

+ # Add old style specifications

+ if (defined($opt_compat_libtool)) {

+ $compat_value{$COMPAT_MODE_LIBTOOL} =

+ $opt_compat_libtool ? $COMPAT_VALUE_ON

+ : $COMPAT_VALUE_OFF;

+ }

+

+ # Parse settings

+ if (defined($opt)) {

+ @opt_list = split(/\s*,\s*/, $opt);

+ }

+ foreach my $directive (@opt_list) {

+ my ($mode, $value);

+

+ # Either

+ # mode=off|on|auto or

+ # mode (implies on)

+ if ($directive !~ /^(\w+)=(\w+)$/ &&

+ $directive !~ /^(\w+)$/) {

+ die("ERROR: Unknown compatibility mode specification: ".

+ "$directive!\n");

+ }

+ # Determine mode

+ $mode = $COMPAT_NAME_TO_MODE{lc($1)};

+ if (!defined($mode)) {

+ die("ERROR: Unknown compatibility mode '$1'!\n");

+ }

+ $specified{$mode} = 1;

+ # Determine value

+ if (defined($2)) {

+ $value = $COMPAT_NAME_TO_VALUE{lc($2)};

+ if (!defined($value)) {

+ die("ERROR: Unknown compatibility mode ".

+ "value '$2'!\n");

+ }

+ } else {

+ $value = $COMPAT_VALUE_ON;

+ }

+ $compat_value{$mode} = $value;

+ }

+ # Perform auto-detection

+ foreach my $mode (sort(keys(%compat_value))) {

+ my $value = $compat_value{$mode};

+ my $is_autodetect = "";

+ my $name = compat_name($mode);

+

+ if ($value == $COMPAT_VALUE_AUTO) {

+ my $autodetect = $COMPAT_MODE_AUTO{$mode};

+

+ if (!defined($autodetect)) {

+ die("ERROR: No auto-detection for ".

+ "mode '$name' available!\n");

+ }

+

+ if (ref($autodetect) eq "CODE") {

+ $value = &$autodetect();

+ $compat_value{$mode} = $value;

+ $is_autodetect = " (auto-detected)";

+ }

+ }

+

+ if ($specified{$mode}) {

+ if ($value == $COMPAT_VALUE_ON) {

+ info("Enabling compatibility mode ".

+ "'$name'$is_autodetect\n");

+ } elsif ($value == $COMPAT_VALUE_OFF) {

+ info("Disabling compatibility mode ".

+ "'$name'$is_autodetect\n");

+ } else {

+ info("Using delayed auto-detection for ".

+ "compatibility mode ".

+ "'$name'\n");

+ }

+ }

+ }

+}

+

+sub compat_hammer_autodetect()

+{

+ if ($gcov_version_string =~ /suse/i && $gcov_version == 0x30303 ||

+ $gcov_version_string =~ /mandrake/i && $gcov_version == 0x30302)

+ {

+ info("Auto-detected compatibility mode for GCC 3.3 (hammer)\n");

+ return $COMPAT_VALUE_ON;

+ }

+ return $COMPAT_VALUE_OFF;

+}

+

+#

+# is_compat(mode)

+#

+# Return non-zero if compatibility mode MODE is enabled.

+#

+

+sub is_compat($)

+{

+ my ($mode) = @_;

+

+ return 1 if ($compat_value{$mode} == $COMPAT_VALUE_ON);

+ return 0;

+}

+

+#

+# is_compat_auto(mode)

+#

+# Return non-zero if compatibility mode MODE is set to auto-detect.

+#

+

+sub is_compat_auto($)

+{

+ my ($mode) = @_;

+

+ return 1 if ($compat_value{$mode} == $COMPAT_VALUE_AUTO);

+ return 0;

+}

+# Note that the Perl module GD.pm is required for this script to work.

+use Cwd qw/abs_path/;

+our $tool_dir = abs_path(dirname($0));

+our $lcov_version = "LCOV version 1.12";

+ open(HANDLE, "<", $filename)

+ my $height; # Height as define by source size

+ # Handle empty source files

+ if (!@source) {

+ @source = ( "" );

+ }

+ $height = scalar(@source);

+ open (PNG_HANDLE, ">", $filename)

+# Copyright (c) International Business Machines Corp., 2002,2012

+our $tool_dir = abs_path(dirname($0));

+our $lcov_version = "LCOV version 1.12";

+our $BR_VEC_MAX = vec(pack('b*', 1 x $BR_VEC_WIDTH), 0, $BR_VEC_WIDTH);

+sub summary();

+sub rate($$;$$$);

+our @opt_ignore_errors;

+our $opt_external;

+our $opt_no_external;

+our $opt_config_file;

+our %opt_rc;

+our @opt_summary;

+our $opt_compat;

+our $func_coverage = 1;

+our $br_coverage = 0;

+# Check command line for a configuration file name

+Getopt::Long::Configure("pass_through", "no_auto_abbrev");

+GetOptions("config-file=s" => \$opt_config_file,

+ "rc=s%" => \%opt_rc);

+Getopt::Long::Configure("default");

+ # Remove spaces around rc options

+ my %new_opt_rc;

+

+ while (my ($key, $value) = each(%opt_rc)) {

+ $key =~ s/^\s+|\s+$//g;

+ $value =~ s/^\s+|\s+$//g;

+

+ $new_opt_rc{$key} = $value;

+ }

+ %opt_rc = %new_opt_rc;

+if (defined($opt_config_file)) {

+ $config = read_config($opt_config_file);

+} elsif (defined($ENV{"HOME"}) && (-r $ENV{"HOME"}."/.lcovrc"))

+if ($config || %opt_rc)

+ # Copy configuration file and --rc values to variables

+ "lcov_branch_coverage" => \$br_coverage,

+ "lcov_function_coverage"=> \$func_coverage,

+ "ignore-errors=s" => \@opt_ignore_errors,

+ "external" => \$opt_external,

+ "no-external" => \$opt_no_external,

+ "summary=s" => \@opt_summary,

+ "compat=s" => \$opt_compat,

+ "config-file=s" => \$opt_config_file,

+ "rc=s%" => \%opt_rc,

+

+ if (defined($opt_no_external)) {

+ $opt_external = 0;

+ $opt_no_external = undef;

+ }

+if (@ARGV && !($extract || $remove || $diff || @opt_summary))

+elsif (@opt_summary)

+{

+ ($ln_overall_found, $ln_overall_hit,

+ $fn_overall_found, $fn_overall_hit,

+ $br_overall_found, $br_overall_hit) = summary();

+}

+ --summary FILE Show summary coverage data for tracefiles

+ --(no-)external Include (ignore) data for external files

+ --config-file FILENAME Specify configuration file location

+ --rc SETTING=VALUE Override configuration file setting

+ --compat MODE=on|off|auto Set compat MODE (libtool, hammer, split_crc)

+ @opt_summary && $i++;

+ die("Need one of options -z, -c, -a, -e, -r, -l, ".

+ "--diff or --summary\n".

+ die("ERROR: only one of -z, -c, -a, -e, -r, -l, ".

+ "--diff or --summary allowed!\n".

+ @file_list = `find "$current_dir" $maxdepth $follow -name \\*\\.da -type f -o -name \\*\\.gcda -type f 2>/dev/null`;

+ open(HANDLE, ">", $reset_file) or

+ open(HANDLE, "<", $from) or die("ERROR: cannot read $from: $!\n");

+ open(HANDLE, ">", $to) or die("ERROR: cannot write $from: $!\n");

+ foreach (@opt_ignore_errors) {

+ @param = (@param, "--ignore-errors", $_);

+ }

+ if ($no_recursion) {

+ @param = (@param, "--no-recursion");

+ if (defined($opt_external) && $opt_external)

+ {

+ @param = (@param, "--external");

+ }

+ if (defined($opt_external) && !$opt_external)

+ {

+ @param = (@param, "--no-external");

+ }

+ if (defined($opt_compat)) {

+ @param = (@param, "--compat", $opt_compat);

+ }

+ if (%opt_rc) {

+ foreach my $key (keys(%opt_rc)) {

+ @param = (@param, "--rc", "$key=".$opt_rc{$key});

+ }

+ }

+ if (defined($opt_config_file)) {

+ @param = (@param, "--config-file", $opt_config_file);

+ }

+

+ open(HANDLE, "<", $filename) || return undef;

+ open(HANDLE, "-|", "tar xvfz '$file' 2>/dev/null")

+ $count = 0;

+ if ($count == 0) {

+ die("ERROR: no data file found in package $file\n");

+ }

+ info(" data directory .......: $dir\n");

+ open(HANDLE, ">", $filename) || return 0;

+ open(HANDLE, "-|", "tar tfz '$filename'") or return undef;

+ # Check for availability of tar tool first

+ system("tar --help > /dev/null")

+ and die("ERROR: tar command not available\n");

+

+ chdir($cwd);

+# link_data_cb(datadir, rel, graphdir)

+#

+# Create symbolic link in GRAPDIR/REL pointing to DATADIR/REL.

+#

+

+sub link_data_cb($$$)

+{

+ my ($datadir, $rel, $graphdir) = @_;

+ my $absfrom = catfile($datadir, $rel);

+ my $absto = catfile($graphdir, $rel);

+ my $base;

+ my $dir;

+

+ if (-e $absto) {

+ die("ERROR: could not create symlink at $absto: ".

+ "File already exists!\n");

+ }

+ if (-l $absto) {

+ # Broken link - possibly from an interrupted earlier run

+ unlink($absto);

+ }

+

+ # Check for graph file

+ $base = $absto;

+ $base =~ s/\.(gcda|da)$//;

+ if (! -e $base.".gcno" && ! -e $base.".bbg" && ! -e $base.".bb") {

+ die("ERROR: No graph file found for $absfrom in ".

+ dirname($base)."!\n");

+ }

+

+ symlink($absfrom, $absto) or

+ die("ERROR: could not create symlink at $absto: $!\n");

+}

+

+#

+# unlink_data_cb(datadir, rel, graphdir)

+#

+# Remove symbolic link from GRAPHDIR/REL to DATADIR/REL.

+#

+

+sub unlink_data_cb($$$)

+{

+ my ($datadir, $rel, $graphdir) = @_;

+ my $absfrom = catfile($datadir, $rel);

+ my $absto = catfile($graphdir, $rel);

+ my $target;

+

+ return if (!-l $absto);

+ $target = readlink($absto);

+ return if (!defined($target) || $target ne $absfrom);

+

+ unlink($absto) or

+ warn("WARNING: could not remove symlink $absto: $!\n");

+}

+

+#

+# link_data(datadir, graphdir, create)

+#

+# If CREATE is non-zero, create symbolic links in GRAPHDIR for data files

+# found in DATADIR. Otherwise remove link in GRAPHDIR.

+#

+

+sub link_data($$$)

+{

+ my ($datadir, $graphdir, $create) = @_;

+

+ $datadir = abs_path($datadir);

+ $graphdir = abs_path($graphdir);

+ if ($create) {

+ lcov_find($datadir, \&link_data_cb, $graphdir, '\.gcda$',

+ '\.da$');

+ } else {

+ lcov_find($datadir, \&unlink_data_cb, $graphdir, '\.gcda$',

+ '\.da$');

+ }

+}

+

+#

+# find_graph_cb(datadir, rel, count_ref)

+#

+# Count number of files found.

+#

+

+sub find_graph_cb($$$)

+{

+ my ($dir, $rel, $count_ref) = @_;

+

+ ($$count_ref)++;

+}

+

+#

+# find_graph(dir)

+#

+# Search DIR for a graph file. Return non-zero if one was found, zero otherwise.

+#

+

+sub find_graph($)

+{

+ my ($dir) = @_;

+ my $count = 0;

+

+ lcov_find($dir, \&find_graph_cb, \$count, '\.gcno$', '\.bb$', '\.bbg$');

+

+ return $count > 0 ? 1 : 0;

+}

+

+#

+ if (find_graph($dir)) {

+ # Package contains graph files - collect from there

+ lcov_geninfo($dir);

+ } else {

+ # No graph files found, link data files next to

+ # graph files

+ link_data($dir, $base_directory, 1);

+ lcov_geninfo($base_directory);

+ link_data($dir, $base_directory, 0);

+ }

+ $block = $BR_VEC_MAX if $block < 0;

+ $v_block = $BR_VEC_MAX if $v_block < 0;

+ $block = -1 if ($block == $BR_VEC_MAX);

+# "f_found" -> $fn_found (number of instrumented functions found in file)

+# "f_hit" -> $fn_hit (number of executed functions in file)

+# "b_found" -> $br_found (number of instrumented branches found in file)

+# "b_hit" -> $br_hit (number of executed branches in file)

+ open(INFO_HANDLE, "-|", "gunzip -c '$_[0]'")

+ open(INFO_HANDLE, "<", $_[0])

+ last if (!$func_coverage);

+

+ last if (!$func_coverage);

+

+ last if (!$br_coverage);

+ my $data1_ref = $_[0]; # Hash 1

+ my $data2_ref = $_[1]; # Hash 2

+ foreach $line (keys(%$data1_ref))

+ $data1_count = $data1_ref->{$line};

+ $data2_count = $data2_ref->{$line};

+ # Add lines unique to data2_ref

+ foreach $line (keys(%$data2_ref))

+ # Skip lines already in data1_ref

+ if (defined($data1_ref->{$line})) { next; }

+ # Copy count from data2_ref

+ $result{$line} = $data2_ref->{$line};

+ open(INFO_HANDLE, ">", $output_filename)

+ $block = $BR_VEC_MAX if ($block < 0);

+# Transform shell wildcard expression to equivalent Perl regular expression.

+ open(INFO_HANDLE, ">", $output_filename)

+ open(INFO_HANDLE, ">", $output_filename)

+sub shorten_rate($$$)

+ my ($hit, $found, $width) = @_;

+ my $result = rate($hit, $found, "%", 1, $width);

+ $result = rate($hit, $found, "%", 0, $width);

+ $rate = shorten_rate($hit, $found, $fwidth[$F_LN_RATE]);

+ $fnrate = shorten_rate($fn_hit, $fn_found, $fwidth[$F_FN_RATE]);

+ $brrate = shorten_rate($br_hit, $br_found, $fwidth[$F_BR_RATE]);

+ $rate = shorten_rate($total_hit, $total_found, $fwidth[$F_LN_RATE]);

+ $fnrate = shorten_rate($fn_total_hit, $fn_total_found,

+ $fwidth[$F_FN_RATE]);

+ $brrate = shorten_rate($br_total_hit, $br_total_found,

+ $fwidth[$F_BR_RATE]);

+ open(HANDLE, "-|", "gunzip -c '$diff_file'")

+ open(HANDLE, "<", $diff_file)

+ foreach $testname (keys(%{$testfncdata})) {

+ foreach $func (keys(%{$fnccount})) {

+ foreach $func (keys(%{$sumfnccount})) {

+ open(INFO_HANDLE, ">", $output_filename)

+#

+# summary()

+#

+

+sub summary()

+{

+ my $filename;

+ my $current;

+ my $total;

+ my $ln_total_found;

+ my $ln_total_hit;

+ my $fn_total_found;

+ my $fn_total_hit;

+ my $br_total_found;

+ my $br_total_hit;

+

+ # Read and combine trace files

+ foreach $filename (@opt_summary) {

+ $current = read_info_file($filename);

+ if (!defined($total)) {

+ $total = $current;

+ } else {

+ $total = combine_info_files($total, $current);

+ }

+ }

+ # Calculate coverage data

+ foreach $filename (keys(%{$total}))

+ {

+ my $entry = $total->{$filename};

+ my $ln_found;

+ my $ln_hit;

+ my $fn_found;

+ my $fn_hit;

+ my $br_found;

+ my $br_hit;

+

+ (undef, undef, undef, undef, undef, undef, undef, undef,

+ $ln_found, $ln_hit, $fn_found, $fn_hit, $br_found,

+ $br_hit) = get_info_entry($entry);

+

+ # Add to totals

+ $ln_total_found += $ln_found;

+ $ln_total_hit += $ln_hit;

+ $fn_total_found += $fn_found;

+ $fn_total_hit += $fn_hit;

+ $br_total_found += $br_found;

+ $br_total_hit += $br_hit;

+ }

+

+

+ return ($ln_total_found, $ln_total_hit, $fn_total_found, $fn_total_hit,

+ $br_total_found, $br_total_hit);

+}

+ ($mode & 1) && open(OLD_STDOUT, ">>&", "STDOUT");

+ ($mode & 2) && open(OLD_STDERR, ">>&", "STDERR");

+ ($mode & 1) && open(STDOUT, ">", "/dev/null");

+ ($mode & 2) && open(STDERR, ">", "/dev/null");

+ ($mode & 1) && open(STDOUT, ">>&", "OLD_STDOUT");

+ ($mode & 2) && open(STDERR, ">>&", "OLD_STDERR");

+ if (!open(HANDLE, "<", $filename))

+# variable. If the global configuration hashes CONFIG or OPT_RC contain a value

+# for keyword KEY_STRING, VAR_REF will be assigned the value for that keyword.

+ if (defined($opt_rc{$_})) {

+ ${$ref->{$_}} = $opt_rc{$_};

+ } elsif (defined($config->{$_})) {

+ # Ensure temp directory is not in use by current process

+ chdir("/");

+

+

+ return rate($hit, $found, "% ($hit of $found $name)");

+ info("Summary coverage rate:\n");

+

+

+#

+# rate(hit, found[, suffix, precision, width])

+#

+# Return the coverage rate [0..100] for HIT and FOUND values. 0 is only

+# returned when HIT is 0. 100 is only returned when HIT equals FOUND.

+# PRECISION specifies the precision of the result. SUFFIX defines a

+# string that is appended to the result if FOUND is non-zero. Spaces

+# are added to the start of the resulting string until it is at least WIDTH

+# characters wide.

+#

+

+sub rate($$;$$$)

+{

+ my ($hit, $found, $suffix, $precision, $width) = @_;

+ my $rate;

+

+ # Assign defaults if necessary

+ $precision = 1 if (!defined($precision));

+ $suffix = "" if (!defined($suffix));

+ $width = 0 if (!defined($width));

+

+ return sprintf("%*s", $width, "-") if (!defined($found) || $found == 0);

+ $rate = sprintf("%.*f", $precision, $hit * 100 / $found);

+

+ # Adjust rates if necessary

+ if ($rate == 0 && $hit > 0) {

+ $rate = sprintf("%.*f", $precision, 1 / 10 ** $precision);

+ } elsif ($rate == 100 && $hit != $found) {

+ $rate = sprintf("%.*f", $precision, 100 - 1 / 10 ** $precision);

+ }

+

+ return sprintf("%*s", $width, $rate.$suffix);

+}