diff options
Diffstat (limited to 'chromium/third_party/lcov-1.9/bin/genhtml')
-rwxr-xr-x | chromium/third_party/lcov-1.9/bin/genhtml | 5648 |
1 files changed, 5648 insertions, 0 deletions
diff --git a/chromium/third_party/lcov-1.9/bin/genhtml b/chromium/third_party/lcov-1.9/bin/genhtml new file mode 100755 index 00000000000..d74063a4fdb --- /dev/null +++ b/chromium/third_party/lcov-1.9/bin/genhtml @@ -0,0 +1,5648 @@ +#!/usr/bin/perl -w +# +# Copyright (c) International Business Machines Corp., 2002,2010 +# +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2 of the License, or (at +# your option) any later version. +# +# This program is distributed in the hope that it will be useful, but +# WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, write to the Free Software +# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +# +# +# genhtml +# +# This script generates HTML output from .info files as created by the +# geninfo script. Call it with --help and refer to the genhtml man page +# to get information on usage and available options. +# +# +# History: +# 2002-08-23 created by Peter Oberparleiter <Peter.Oberparleiter@de.ibm.com> +# IBM Lab Boeblingen +# based on code by Manoj Iyer <manjo@mail.utexas.edu> and +# Megan Bock <mbock@us.ibm.com> +# IBM Austin +# 2002-08-27 / Peter Oberparleiter: implemented frame view +# 2002-08-29 / Peter Oberparleiter: implemented test description filtering +# so that by default only descriptions for test cases which +# actually hit some source lines are kept +# 2002-09-05 / Peter Oberparleiter: implemented --no-sourceview +# 2002-09-05 / Mike Kobler: One of my source file paths includes a "+" in +# the directory name. I found that genhtml.pl died when it +# encountered it. I was able to fix the problem by modifying +# the string with the escape character before parsing it. +# 2002-10-26 / Peter Oberparleiter: implemented --num-spaces +# 2003-04-07 / Peter Oberparleiter: fixed bug which resulted in an error +# when trying to combine .info files containing data without +# a test name +# 2003-04-10 / Peter Oberparleiter: extended fix by Mike to also cover +# other special characters +# 2003-04-30 / Peter Oberparleiter: made info write to STDERR, not STDOUT +# 2003-07-10 / Peter Oberparleiter: added line checksum support +# 2004-08-09 / Peter Oberparleiter: added configuration file support +# 2005-03-04 / Cal Pierog: added legend to HTML output, fixed coloring of +# "good coverage" background +# 2006-03-18 / Marcus Boerger: added --custom-intro, --custom-outro and +# overwrite --no-prefix if --prefix is present +# 2006-03-20 / Peter Oberparleiter: changes to custom_* function (rename +# to html_prolog/_epilog, minor modifications to implementation), +# changed prefix/noprefix handling to be consistent with current +# logic +# 2006-03-20 / Peter Oberparleiter: added --html-extension option +# 2008-07-14 / Tom Zoerner: added --function-coverage command line option; +# added function table to source file page +# 2008-08-13 / Peter Oberparleiter: modified function coverage +# implementation (now enabled per default), +# introduced sorting option (enabled per default) +# + +use strict; +use File::Basename; +use Getopt::Long; +use Digest::MD5 qw(md5_base64); + + +# Global constants +our $title = "LCOV - code coverage report"; +our $lcov_version = 'LCOV version 1.9'; +our $lcov_url = "http://ltp.sourceforge.net/coverage/lcov.php"; +our $tool_name = basename($0); + +# Specify coverage rate limits (in %) for classifying file entries +# HI: $hi_limit <= rate <= 100 graph color: green +# MED: $med_limit <= rate < $hi_limit graph color: orange +# LO: 0 <= rate < $med_limit graph color: red + +# For line coverage/all coverage types if not specified +our $hi_limit = 90; +our $med_limit = 75; + +# For function coverage +our $fn_hi_limit; +our $fn_med_limit; + +# For branch coverage +our $br_hi_limit; +our $br_med_limit; + +# Width of overview image +our $overview_width = 80; + +# Resolution of overview navigation: this number specifies the maximum +# difference in lines between the position a user selected from the overview +# and the position the source code window is scrolled to. +our $nav_resolution = 4; + +# Clicking a line in the overview image should show the source code view at +# a position a bit further up so that the requested line is not the first +# line in the window. This number specifies that offset in lines. +our $nav_offset = 10; + +# Clicking on a function name should show the source code at a position a +# few lines before the first line of code of that function. This number +# specifies that offset in lines. +our $func_offset = 2; + +our $overview_title = "top level"; + +# Width for line coverage information in the source code view +our $line_field_width = 12; + +# Width for branch coverage information in the source code view +our $br_field_width = 16; + +# Internal Constants + +# Header types +our $HDR_DIR = 0; +our $HDR_FILE = 1; +our $HDR_SOURCE = 2; +our $HDR_TESTDESC = 3; +our $HDR_FUNC = 4; + +# Sort types +our $SORT_FILE = 0; +our $SORT_LINE = 1; +our $SORT_FUNC = 2; +our $SORT_BRANCH = 3; + +# Fileview heading types +our $HEAD_NO_DETAIL = 1; +our $HEAD_DETAIL_HIDDEN = 2; +our $HEAD_DETAIL_SHOWN = 3; + +# Offsets for storing branch coverage data in vectors +our $BR_BLOCK = 0; +our $BR_BRANCH = 1; +our $BR_TAKEN = 2; +our $BR_VEC_ENTRIES = 3; +our $BR_VEC_WIDTH = 32; + +# Additional offsets used when converting branch coverage data to HTML +our $BR_LEN = 3; +our $BR_OPEN = 4; +our $BR_CLOSE = 5; + +# Branch data combination types +our $BR_SUB = 0; +our $BR_ADD = 1; + +# Data related prototypes +sub print_usage(*); +sub gen_html(); +sub html_create($$); +sub process_dir($); +sub process_file($$$); +sub info(@); +sub read_info_file($); +sub get_info_entry($); +sub set_info_entry($$$$$$$$$;$$$$$$); +sub get_prefix(@); +sub shorten_prefix($); +sub get_dir_list(@); +sub get_relative_base_path($); +sub read_testfile($); +sub get_date_string(); +sub create_sub_dir($); +sub subtract_counts($$); +sub add_counts($$); +sub apply_baseline($$); +sub remove_unused_descriptions(); +sub get_found_and_hit($); +sub get_affecting_tests($$$); +sub combine_info_files($$); +sub merge_checksums($$$); +sub combine_info_entries($$$); +sub apply_prefix($$); +sub system_no_output($@); +sub read_config($); +sub apply_config($); +sub get_html_prolog($); +sub get_html_epilog($); +sub write_dir_page($$$$$$$$$$$$$$$$$); +sub classify_rate($$$$); +sub br_taken_add($$); +sub br_taken_sub($$); +sub br_ivec_len($); +sub br_ivec_get($$); +sub br_ivec_push($$$$); +sub combine_brcount($$$); +sub get_br_found_and_hit($); +sub warn_handler($); +sub die_handler($); + + +# HTML related prototypes +sub escape_html($); +sub get_bar_graph_code($$$); + +sub write_png_files(); +sub write_htaccess_file(); +sub write_css_file(); +sub write_description_file($$$$$$$); +sub write_function_table(*$$$$$$$$$$); + +sub write_html(*$); +sub write_html_prolog(*$$); +sub write_html_epilog(*$;$); + +sub write_header(*$$$$$$$$$$); +sub write_header_prolog(*$); +sub write_header_line(*@); +sub write_header_epilog(*$); + +sub write_file_table(*$$$$$$$); +sub write_file_table_prolog(*$@); +sub write_file_table_entry(*$$$@); +sub write_file_table_detail_entry(*$@); +sub write_file_table_epilog(*); + +sub write_test_table_prolog(*$); +sub write_test_table_entry(*$$); +sub write_test_table_epilog(*); + +sub write_source($$$$$$$); +sub write_source_prolog(*); +sub write_source_line(*$$$$$$); +sub write_source_epilog(*); + +sub write_frameset(*$$$); +sub write_overview_line(*$$$); +sub write_overview(*$$$$); + +# External prototype (defined in genpng) +sub gen_png($$$@); + + +# Global variables & initialization +our %info_data; # Hash containing all data from .info file +our $dir_prefix; # Prefix to remove from all sub directories +our %test_description; # Hash containing test descriptions if available +our $date = get_date_string(); + +our @info_filenames; # List of .info files to use as data source +our $test_title; # Title for output as written to each page header +our $output_directory; # Name of directory in which to store output +our $base_filename; # Optional name of file containing baseline data +our $desc_filename; # Name of file containing test descriptions +our $css_filename; # Optional name of external stylesheet file to use +our $quiet; # If set, suppress information messages +our $help; # Help option flag +our $version; # Version option flag +our $show_details; # If set, generate detailed directory view +our $no_prefix; # If set, do not remove filename prefix +our $func_coverage = 1; # If set, generate function coverage statistics +our $no_func_coverage; # Disable func_coverage +our $br_coverage = 1; # If set, generate branch coverage statistics +our $no_br_coverage; # Disable br_coverage +our $sort = 1; # If set, provide directory listings with sorted entries +our $no_sort; # Disable sort +our $frames; # If set, use frames for source code view +our $keep_descriptions; # If set, do not remove unused test case descriptions +our $no_sourceview; # If set, do not create a source code view for each file +our $highlight; # If set, highlight lines covered by converted data only +our $legend; # If set, include legend in output +our $tab_size = 8; # Number of spaces to use in place of tab +our $config; # Configuration file contents +our $html_prolog_file; # Custom HTML prolog file (up to and including <body>) +our $html_epilog_file; # Custom HTML epilog file (from </body> onwards) +our $html_prolog; # Actual HTML prolog +our $html_epilog; # Actual HTML epilog +our $html_ext = "html"; # Extension for generated HTML files +our $html_gzip = 0; # Compress with gzip +our $demangle_cpp = 0; # Demangle C++ function names +our @fileview_sortlist; +our @fileview_sortname = ("", "-sort-l", "-sort-f", "-sort-b"); +our @funcview_sortlist; +our @rate_name = ("Lo", "Med", "Hi"); +our @rate_png = ("ruby.png", "amber.png", "emerald.png"); + +our $cwd = `pwd`; # Current working directory +chomp($cwd); +our $tool_dir = dirname($0); # Directory where genhtml tool is installed + + +# +# Code entry point +# + +$SIG{__WARN__} = \&warn_handler; +$SIG{__DIE__} = \&die_handler; + +# Prettify version string +$lcov_version =~ s/\$\s*Revision\s*:?\s*(\S+)\s*\$/$1/; + +# Add current working directory if $tool_dir is not already an absolute path +if (! ($tool_dir =~ /^\/(.*)$/)) +{ + $tool_dir = "$cwd/$tool_dir"; +} + +# Read configuration file if available +if (defined($ENV{"HOME"}) && (-r $ENV{"HOME"}."/.lcovrc")) +{ + $config = read_config($ENV{"HOME"}."/.lcovrc"); +} +elsif (-r "/etc/lcovrc") +{ + $config = read_config("/etc/lcovrc"); +} + +if ($config) +{ + # Copy configuration file values to variables + apply_config({ + "genhtml_css_file" => \$css_filename, + "genhtml_hi_limit" => \$hi_limit, + "genhtml_med_limit" => \$med_limit, + "genhtml_line_field_width" => \$line_field_width, + "genhtml_overview_width" => \$overview_width, + "genhtml_nav_resolution" => \$nav_resolution, + "genhtml_nav_offset" => \$nav_offset, + "genhtml_keep_descriptions" => \$keep_descriptions, + "genhtml_no_prefix" => \$no_prefix, + "genhtml_no_source" => \$no_sourceview, + "genhtml_num_spaces" => \$tab_size, + "genhtml_highlight" => \$highlight, + "genhtml_legend" => \$legend, + "genhtml_html_prolog" => \$html_prolog_file, + "genhtml_html_epilog" => \$html_epilog_file, + "genhtml_html_extension" => \$html_ext, + "genhtml_html_gzip" => \$html_gzip, + "genhtml_function_hi_limit" => \$fn_hi_limit, + "genhtml_function_med_limit" => \$fn_med_limit, + "genhtml_function_coverage" => \$func_coverage, + "genhtml_branch_hi_limit" => \$br_hi_limit, + "genhtml_branch_med_limit" => \$br_med_limit, + "genhtml_branch_coverage" => \$br_coverage, + "genhtml_branch_field_width" => \$br_field_width, + "genhtml_sort" => \$sort, + }); +} + +# Copy limit values if not specified +$fn_hi_limit = $hi_limit if (!defined($fn_hi_limit)); +$fn_med_limit = $med_limit if (!defined($fn_med_limit)); +$br_hi_limit = $hi_limit if (!defined($br_hi_limit)); +$br_med_limit = $med_limit if (!defined($br_med_limit)); + +# Parse command line options +if (!GetOptions("output-directory|o=s" => \$output_directory, + "title|t=s" => \$test_title, + "description-file|d=s" => \$desc_filename, + "keep-descriptions|k" => \$keep_descriptions, + "css-file|c=s" => \$css_filename, + "baseline-file|b=s" => \$base_filename, + "prefix|p=s" => \$dir_prefix, + "num-spaces=i" => \$tab_size, + "no-prefix" => \$no_prefix, + "no-sourceview" => \$no_sourceview, + "show-details|s" => \$show_details, + "frames|f" => \$frames, + "highlight" => \$highlight, + "legend" => \$legend, + "quiet|q" => \$quiet, + "help|h|?" => \$help, + "version|v" => \$version, + "html-prolog=s" => \$html_prolog_file, + "html-epilog=s" => \$html_epilog_file, + "html-extension=s" => \$html_ext, + "html-gzip" => \$html_gzip, + "function-coverage" => \$func_coverage, + "no-function-coverage" => \$no_func_coverage, + "branch-coverage" => \$br_coverage, + "no-branch-coverage" => \$no_br_coverage, + "sort" => \$sort, + "no-sort" => \$no_sort, + "demangle-cpp" => \$demangle_cpp, + )) +{ + print(STDERR "Use $tool_name --help to get usage information\n"); + exit(1); +} else { + # Merge options + if ($no_func_coverage) { + $func_coverage = 0; + } + if ($no_br_coverage) { + $br_coverage = 0; + } + + # Merge sort options + if ($no_sort) { + $sort = 0; + } +} + +@info_filenames = @ARGV; + +# Check for help option +if ($help) +{ + print_usage(*STDOUT); + exit(0); +} + +# Check for version option +if ($version) +{ + print("$tool_name: $lcov_version\n"); + exit(0); +} + +# Check for info filename +if (!@info_filenames) +{ + die("No filename specified\n". + "Use $tool_name --help to get usage information\n"); +} + +# Generate a title if none is specified +if (!$test_title) +{ + if (scalar(@info_filenames) == 1) + { + # Only one filename specified, use it as title + $test_title = basename($info_filenames[0]); + } + else + { + # More than one filename specified, used default title + $test_title = "unnamed"; + } +} + +# Make sure css_filename is an absolute path (in case we're changing +# directories) +if ($css_filename) +{ + if (!($css_filename =~ /^\/(.*)$/)) + { + $css_filename = $cwd."/".$css_filename; + } +} + +# Make sure tab_size is within valid range +if ($tab_size < 1) +{ + print(STDERR "ERROR: invalid number of spaces specified: ". + "$tab_size!\n"); + exit(1); +} + +# Get HTML prolog and epilog +$html_prolog = get_html_prolog($html_prolog_file); +$html_epilog = get_html_epilog($html_epilog_file); + +# Issue a warning if --no-sourceview is enabled together with --frames +if ($no_sourceview && defined($frames)) +{ + warn("WARNING: option --frames disabled because --no-sourceview ". + "was specified!\n"); + $frames = undef; +} + +# Issue a warning if --no-prefix is enabled together with --prefix +if ($no_prefix && defined($dir_prefix)) +{ + warn("WARNING: option --prefix disabled because --no-prefix was ". + "specified!\n"); + $dir_prefix = undef; +} + +@fileview_sortlist = ($SORT_FILE); +@funcview_sortlist = ($SORT_FILE); + +if ($sort) { + push(@fileview_sortlist, $SORT_LINE); + push(@fileview_sortlist, $SORT_FUNC) if ($func_coverage); + push(@fileview_sortlist, $SORT_BRANCH) if ($br_coverage); + push(@funcview_sortlist, $SORT_LINE); +} + +if ($frames) +{ + # Include genpng code needed for overview image generation + do("$tool_dir/genpng"); +} + +# Ensure that the c++filt tool is available when using --demangle-cpp +if ($demangle_cpp) +{ + if (system_no_output(3, "c++filt", "--version")) { + die("ERROR: could not find c++filt tool needed for ". + "--demangle-cpp\n"); + } +} + +# Make sure output_directory exists, create it if necessary +if ($output_directory) +{ + stat($output_directory); + + if (! -e _) + { + create_sub_dir($output_directory); + } +} + +# Do something +gen_html(); + +exit(0); + + + +# +# print_usage(handle) +# +# Print usage information. +# + +sub print_usage(*) +{ + local *HANDLE = $_[0]; + + print(HANDLE <<END_OF_USAGE); +Usage: $tool_name [OPTIONS] INFOFILE(S) + +Create HTML output for coverage data found in INFOFILE. Note that INFOFILE +may also be a list of filenames. + +Misc: + -h, --help Print this help, then exit + -v, --version Print version number, then exit + -q, --quiet Do not print progress messages + +Operation: + -o, --output-directory OUTDIR Write HTML output to OUTDIR + -s, --show-details Generate detailed directory view + -d, --description-file DESCFILE Read test case descriptions from DESCFILE + -k, --keep-descriptions Do not remove unused test descriptions + -b, --baseline-file BASEFILE Use BASEFILE as baseline file + -p, --prefix PREFIX Remove PREFIX from all directory names + --no-prefix Do not remove prefix from directory names + --(no-)function-coverage Enable (disable) function coverage display + --(no-)branch-coverage Enable (disable) branch coverage display + +HTML output: + -f, --frames Use HTML frames for source code view + -t, --title TITLE Display TITLE in header of all pages + -c, --css-file CSSFILE Use external style sheet file CSSFILE + --no-source Do not create source code view + --num-spaces NUM Replace tabs with NUM spaces in source view + --highlight Highlight lines with converted-only data + --legend Include color legend in HTML output + --html-prolog FILE Use FILE as HTML prolog for generated pages + --html-epilog FILE Use FILE as HTML epilog for generated pages + --html-extension EXT Use EXT as filename extension for pages + --html-gzip Use gzip to compress HTML + --(no-)sort Enable (disable) sorted coverage views + --demangle-cpp Demangle C++ function names + +For more information see: $lcov_url +END_OF_USAGE + ; +} + + +# +# get_rate(found, hit) +# +# Return a relative value for the specified found&hit values +# which is used for sorting the corresponding entries in a +# file list. +# + +sub get_rate($$) +{ + my ($found, $hit) = @_; + + if ($found == 0) { + return 10000; + } + return int($hit * 1000 / $found) * 10 + 2 - (1 / $found); +} + + +# +# get_overall_line(found, hit, name_singular, name_plural) +# +# Return a string containing overall information for the specified +# found/hit data. +# + +sub get_overall_line($$$$) +{ + my ($found, $hit, $name_sn, $name_pl) = @_; + my $name; + + return "no data found" if (!defined($found) || $found == 0); + $name = ($found == 1) ? $name_sn : $name_pl; + return sprintf("%.1f%% (%d of %d %s)", $hit * 100 / $found, $hit, + $found, $name); +} + + +# +# print_overall_rate(ln_do, ln_found, ln_hit, fn_do, fn_found, fn_hit, br_do +# br_found, br_hit) +# +# Print overall coverage rates for the specified coverage types. +# + +sub print_overall_rate($$$$$$$$$) +{ + my ($ln_do, $ln_found, $ln_hit, $fn_do, $fn_found, $fn_hit, + $br_do, $br_found, $br_hit) = @_; + + info("Overall coverage rate:\n"); + info(" lines......: %s\n", + get_overall_line($ln_found, $ln_hit, "line", "lines")) + if ($ln_do); + info(" functions..: %s\n", + get_overall_line($fn_found, $fn_hit, "function", "functions")) + if ($fn_do); + info(" branches...: %s\n", + get_overall_line($br_found, $br_hit, "branch", "branches")) + if ($br_do); +} + + +# +# gen_html() +# +# Generate a set of HTML pages from contents of .info file INFO_FILENAME. +# Files will be written to the current directory. If provided, test case +# descriptions will be read from .tests file TEST_FILENAME and included +# in ouput. +# +# Die on error. +# + +sub gen_html() +{ + local *HTML_HANDLE; + my %overview; + my %base_data; + my $lines_found; + my $lines_hit; + my $fn_found; + my $fn_hit; + my $br_found; + my $br_hit; + my $overall_found = 0; + my $overall_hit = 0; + my $total_fn_found = 0; + my $total_fn_hit = 0; + my $total_br_found = 0; + my $total_br_hit = 0; + my $dir_name; + my $link_name; + my @dir_list; + my %new_info; + + # Read in all specified .info files + foreach (@info_filenames) + { + %new_info = %{read_info_file($_)}; + + # Combine %new_info with %info_data + %info_data = %{combine_info_files(\%info_data, \%new_info)}; + } + + info("Found %d entries.\n", scalar(keys(%info_data))); + + # Read and apply baseline data if specified + if ($base_filename) + { + # Read baseline file + info("Reading baseline file $base_filename\n"); + %base_data = %{read_info_file($base_filename)}; + info("Found %d entries.\n", scalar(keys(%base_data))); + + # Apply baseline + info("Subtracting baseline data.\n"); + %info_data = %{apply_baseline(\%info_data, \%base_data)}; + } + + @dir_list = get_dir_list(keys(%info_data)); + + if ($no_prefix) + { + # User requested that we leave filenames alone + info("User asked not to remove filename prefix\n"); + } + elsif (!defined($dir_prefix)) + { + # Get prefix common to most directories in list + $dir_prefix = get_prefix(@dir_list); + + if ($dir_prefix) + { + info("Found common filename prefix \"$dir_prefix\"\n"); + } + else + { + info("No common filename prefix found!\n"); + $no_prefix=1; + } + } + else + { + info("Using user-specified filename prefix \"". + "$dir_prefix\"\n"); + } + + # Read in test description file if specified + if ($desc_filename) + { + info("Reading test description file $desc_filename\n"); + %test_description = %{read_testfile($desc_filename)}; + + # Remove test descriptions which are not referenced + # from %info_data if user didn't tell us otherwise + if (!$keep_descriptions) + { + remove_unused_descriptions(); + } + } + + # Change to output directory if specified + if ($output_directory) + { + chdir($output_directory) + or die("ERROR: cannot change to directory ". + "$output_directory!\n"); + } + + info("Writing .css and .png files.\n"); + write_css_file(); + write_png_files(); + + if ($html_gzip) + { + info("Writing .htaccess file.\n"); + write_htaccess_file(); + } + + info("Generating output.\n"); + + # Process each subdirectory and collect overview information + foreach $dir_name (@dir_list) + { + ($lines_found, $lines_hit, $fn_found, $fn_hit, + $br_found, $br_hit) + = process_dir($dir_name); + + # Remove prefix if applicable + if (!$no_prefix && $dir_prefix) + { + # Match directory names beginning with $dir_prefix + $dir_name = apply_prefix($dir_name, $dir_prefix); + } + + # Generate name for directory overview HTML page + if ($dir_name =~ /^\/(.*)$/) + { + $link_name = substr($dir_name, 1)."/index.$html_ext"; + } + else + { + $link_name = $dir_name."/index.$html_ext"; + } + + $overview{$dir_name} = [$lines_found, $lines_hit, $fn_found, + $fn_hit, $br_found, $br_hit, $link_name, + get_rate($lines_found, $lines_hit), + get_rate($fn_found, $fn_hit), + get_rate($br_found, $br_hit)]; + $overall_found += $lines_found; + $overall_hit += $lines_hit; + $total_fn_found += $fn_found; + $total_fn_hit += $fn_hit; + $total_br_found += $br_found; + $total_br_hit += $br_hit; + } + + # Generate overview page + info("Writing directory view page.\n"); + + # Create sorted pages + foreach (@fileview_sortlist) { + write_dir_page($fileview_sortname[$_], ".", "", $test_title, + undef, $overall_found, $overall_hit, + $total_fn_found, $total_fn_hit, $total_br_found, + $total_br_hit, \%overview, {}, {}, {}, 0, $_); + } + + # Check if there are any test case descriptions to write out + if (%test_description) + { + info("Writing test case description file.\n"); + write_description_file( \%test_description, + $overall_found, $overall_hit, + $total_fn_found, $total_fn_hit, + $total_br_found, $total_br_hit); + } + + print_overall_rate(1, $overall_found, $overall_hit, + $func_coverage, $total_fn_found, $total_fn_hit, + $br_coverage, $total_br_found, $total_br_hit); + + chdir($cwd); +} + +# +# html_create(handle, filename) +# + +sub html_create($$) +{ + my $handle = $_[0]; + my $filename = $_[1]; + + if ($html_gzip) + { + open($handle, "|gzip -c >$filename") + or die("ERROR: cannot open $filename for writing ". + "(gzip)!\n"); + } + else + { + open($handle, ">$filename") + or die("ERROR: cannot open $filename for writing!\n"); + } +} + +sub write_dir_page($$$$$$$$$$$$$$$$$) +{ + my ($name, $rel_dir, $base_dir, $title, $trunc_dir, $overall_found, + $overall_hit, $total_fn_found, $total_fn_hit, $total_br_found, + $total_br_hit, $overview, $testhash, $testfnchash, $testbrhash, + $view_type, $sort_type) = @_; + + # Generate directory overview page including details + html_create(*HTML_HANDLE, "$rel_dir/index$name.$html_ext"); + if (!defined($trunc_dir)) { + $trunc_dir = ""; + } + write_html_prolog(*HTML_HANDLE, $base_dir, "LCOV - $title$trunc_dir"); + write_header(*HTML_HANDLE, $view_type, $trunc_dir, $rel_dir, + $overall_found, $overall_hit, $total_fn_found, + $total_fn_hit, $total_br_found, $total_br_hit, $sort_type); + write_file_table(*HTML_HANDLE, $base_dir, $overview, $testhash, + $testfnchash, $testbrhash, $view_type, $sort_type); + write_html_epilog(*HTML_HANDLE, $base_dir); + close(*HTML_HANDLE); +} + + +# +# process_dir(dir_name) +# + +sub process_dir($) +{ + my $abs_dir = $_[0]; + my $trunc_dir; + my $rel_dir = $abs_dir; + my $base_dir; + my $filename; + my %overview; + my $lines_found; + my $lines_hit; + my $fn_found; + my $fn_hit; + my $br_found; + my $br_hit; + my $overall_found=0; + my $overall_hit=0; + my $total_fn_found=0; + my $total_fn_hit=0; + my $total_br_found = 0; + my $total_br_hit = 0; + my $base_name; + my $extension; + my $testdata; + my %testhash; + my $testfncdata; + my %testfnchash; + my $testbrdata; + my %testbrhash; + my @sort_list; + local *HTML_HANDLE; + + # Remove prefix if applicable + if (!$no_prefix) + { + # Match directory name beginning with $dir_prefix + $rel_dir = apply_prefix($rel_dir, $dir_prefix); + } + + $trunc_dir = $rel_dir; + + # Remove leading / + if ($rel_dir =~ /^\/(.*)$/) + { + $rel_dir = substr($rel_dir, 1); + } + + $base_dir = get_relative_base_path($rel_dir); + + create_sub_dir($rel_dir); + + # Match filenames which specify files in this directory, not including + # sub-directories + foreach $filename (grep(/^\Q$abs_dir\E\/[^\/]*$/,keys(%info_data))) + { + my $page_link; + my $func_link; + + ($lines_found, $lines_hit, $fn_found, $fn_hit, $br_found, + $br_hit, $testdata, $testfncdata, $testbrdata) = + process_file($trunc_dir, $rel_dir, $filename); + + $base_name = basename($filename); + + if ($no_sourceview) { + $page_link = ""; + } elsif ($frames) { + # Link to frameset page + $page_link = "$base_name.gcov.frameset.$html_ext"; + } else { + # Link directory to source code view page + $page_link = "$base_name.gcov.$html_ext"; + } + $overview{$base_name} = [$lines_found, $lines_hit, $fn_found, + $fn_hit, $br_found, $br_hit, + $page_link, + get_rate($lines_found, $lines_hit), + get_rate($fn_found, $fn_hit), + get_rate($br_found, $br_hit)]; + + $testhash{$base_name} = $testdata; + $testfnchash{$base_name} = $testfncdata; + $testbrhash{$base_name} = $testbrdata; + + $overall_found += $lines_found; + $overall_hit += $lines_hit; + + $total_fn_found += $fn_found; + $total_fn_hit += $fn_hit; + + $total_br_found += $br_found; + $total_br_hit += $br_hit; + } + + # Create sorted pages + foreach (@fileview_sortlist) { + # Generate directory overview page (without details) + write_dir_page($fileview_sortname[$_], $rel_dir, $base_dir, + $test_title, $trunc_dir, $overall_found, + $overall_hit, $total_fn_found, $total_fn_hit, + $total_br_found, $total_br_hit, \%overview, {}, + {}, {}, 1, $_); + if (!$show_details) { + next; + } + # Generate directory overview page including details + write_dir_page("-detail".$fileview_sortname[$_], $rel_dir, + $base_dir, $test_title, $trunc_dir, + $overall_found, $overall_hit, $total_fn_found, + $total_fn_hit, $total_br_found, $total_br_hit, + \%overview, \%testhash, \%testfnchash, + \%testbrhash, 1, $_); + } + + # Calculate resulting line counts + return ($overall_found, $overall_hit, $total_fn_found, $total_fn_hit, + $total_br_found, $total_br_hit); +} + + +# +# get_converted_lines(testdata) +# +# Return hash of line numbers of those lines which were only covered in +# converted data sets. +# + +sub get_converted_lines($) +{ + my $testdata = $_[0]; + my $testcount; + my %converted; + my %nonconverted; + my $hash; + my $testcase; + my $line; + my %result; + + + # Get a hash containing line numbers with positive counts both for + # converted and original data sets + foreach $testcase (keys(%{$testdata})) + { + # Check to see if this is a converted data set + if ($testcase =~ /,diff$/) + { + $hash = \%converted; + } + else + { + $hash = \%nonconverted; + } + + $testcount = $testdata->{$testcase}; + # Add lines with a positive count to hash + foreach $line (keys%{$testcount}) + { + if ($testcount->{$line} > 0) + { + $hash->{$line} = 1; + } + } + } + + # Combine both hashes to resulting list + foreach $line (keys(%converted)) + { + if (!defined($nonconverted{$line})) + { + $result{$line} = 1; + } + } + + return \%result; +} + + +sub write_function_page($$$$$$$$$$$$$$$$$$) +{ + my ($base_dir, $rel_dir, $trunc_dir, $base_name, $title, + $lines_found, $lines_hit, $fn_found, $fn_hit, $br_found, $br_hit, + $sumcount, $funcdata, $sumfnccount, $testfncdata, $sumbrcount, + $testbrdata, $sort_type) = @_; + my $pagetitle; + my $filename; + + # Generate function table for this file + if ($sort_type == 0) { + $filename = "$rel_dir/$base_name.func.$html_ext"; + } else { + $filename = "$rel_dir/$base_name.func-sort-c.$html_ext"; + } + html_create(*HTML_HANDLE, $filename); + $pagetitle = "LCOV - $title - $trunc_dir/$base_name - functions"; + write_html_prolog(*HTML_HANDLE, $base_dir, $pagetitle); + write_header(*HTML_HANDLE, 4, "$trunc_dir/$base_name", + "$rel_dir/$base_name", $lines_found, $lines_hit, + $fn_found, $fn_hit, $br_found, $br_hit, $sort_type); + write_function_table(*HTML_HANDLE, "$base_name.gcov.$html_ext", + $sumcount, $funcdata, + $sumfnccount, $testfncdata, $sumbrcount, + $testbrdata, $base_name, + $base_dir, $sort_type); + write_html_epilog(*HTML_HANDLE, $base_dir, 1); + close(*HTML_HANDLE); +} + + +# +# process_file(trunc_dir, rel_dir, filename) +# + +sub process_file($$$) +{ + info("Processing file ".apply_prefix($_[2], $dir_prefix)."\n"); + + my $trunc_dir = $_[0]; + my $rel_dir = $_[1]; + my $filename = $_[2]; + my $base_name = basename($filename); + my $base_dir = get_relative_base_path($rel_dir); + my $testdata; + my $testcount; + my $sumcount; + my $funcdata; + my $checkdata; + my $testfncdata; + my $sumfnccount; + my $testbrdata; + my $sumbrcount; + my $lines_found; + my $lines_hit; + my $fn_found; + my $fn_hit; + my $br_found; + my $br_hit; + my $converted; + my @source; + my $pagetitle; + local *HTML_HANDLE; + + ($testdata, $sumcount, $funcdata, $checkdata, $testfncdata, + $sumfnccount, $testbrdata, $sumbrcount, $lines_found, $lines_hit, + $fn_found, $fn_hit, $br_found, $br_hit) + = get_info_entry($info_data{$filename}); + + # Return after this point in case user asked us not to generate + # source code view + if ($no_sourceview) + { + return ($lines_found, $lines_hit, $fn_found, $fn_hit, + $br_found, $br_hit, $testdata, $testfncdata, + $testbrdata); + } + + $converted = get_converted_lines($testdata); + # Generate source code view for this file + html_create(*HTML_HANDLE, "$rel_dir/$base_name.gcov.$html_ext"); + $pagetitle = "LCOV - $test_title - $trunc_dir/$base_name"; + write_html_prolog(*HTML_HANDLE, $base_dir, $pagetitle); + write_header(*HTML_HANDLE, 2, "$trunc_dir/$base_name", + "$rel_dir/$base_name", $lines_found, $lines_hit, + $fn_found, $fn_hit, $br_found, $br_hit, 0); + @source = write_source(*HTML_HANDLE, $filename, $sumcount, $checkdata, + $converted, $funcdata, $sumbrcount); + + write_html_epilog(*HTML_HANDLE, $base_dir, 1); + close(*HTML_HANDLE); + + if ($func_coverage) { + # Create function tables + foreach (@funcview_sortlist) { + write_function_page($base_dir, $rel_dir, $trunc_dir, + $base_name, $test_title, + $lines_found, $lines_hit, + $fn_found, $fn_hit, $br_found, + $br_hit, $sumcount, + $funcdata, $sumfnccount, + $testfncdata, $sumbrcount, + $testbrdata, $_); + } + } + + # Additional files are needed in case of frame output + if (!$frames) + { + return ($lines_found, $lines_hit, $fn_found, $fn_hit, + $br_found, $br_hit, $testdata, $testfncdata, + $testbrdata); + } + + # Create overview png file + gen_png("$rel_dir/$base_name.gcov.png", $overview_width, $tab_size, + @source); + + # Create frameset page + html_create(*HTML_HANDLE, + "$rel_dir/$base_name.gcov.frameset.$html_ext"); + write_frameset(*HTML_HANDLE, $base_dir, $base_name, $pagetitle); + close(*HTML_HANDLE); + + # Write overview frame + html_create(*HTML_HANDLE, + "$rel_dir/$base_name.gcov.overview.$html_ext"); + write_overview(*HTML_HANDLE, $base_dir, $base_name, $pagetitle, + scalar(@source)); + close(*HTML_HANDLE); + + return ($lines_found, $lines_hit, $fn_found, $fn_hit, $br_found, + $br_hit, $testdata, $testfncdata, $testbrdata); +} + + +# +# read_info_file(info_filename) +# +# Read in the contents of the .info file specified by INFO_FILENAME. Data will +# be returned as a reference to a hash containing the following mappings: +# +# %result: for each filename found in file -> \%data +# +# %data: "test" -> \%testdata +# "sum" -> \%sumcount +# "func" -> \%funcdata +# "found" -> $lines_found (number of instrumented lines found in file) +# "hit" -> $lines_hit (number of executed lines in file) +# "check" -> \%checkdata +# "testfnc" -> \%testfncdata +# "sumfnc" -> \%sumfnccount +# "testbr" -> \%testbrdata +# "sumbr" -> \%sumbrcount +# +# %testdata : name of test affecting this file -> \%testcount +# %testfncdata: name of test affecting this file -> \%testfnccount +# %testbrdata: name of test affecting this file -> \%testbrcount +# +# %testcount : line number -> execution count for a single test +# %testfnccount: function name -> execution count for a single test +# %testbrcount : line number -> branch coverage data for a single test +# %sumcount : line number -> execution count for all tests +# %sumfnccount : function name -> execution count for all tests +# %sumbrcount : line number -> branch coverage data for all tests +# %funcdata : function name -> line number +# %checkdata : line number -> checksum of source code line +# $brdata : vector of items: block, branch, taken +# +# Note that .info file sections referring to the same file and test name +# will automatically be combined by adding all execution counts. +# +# Note that if INFO_FILENAME ends with ".gz", it is assumed that the file +# is compressed using GZIP. If available, GUNZIP will be used to decompress +# this file. +# +# Die on error. +# + +sub read_info_file($) +{ + my $tracefile = $_[0]; # Name of tracefile + my %result; # Resulting hash: file -> data + my $data; # Data handle for current entry + my $testdata; # " " + my $testcount; # " " + my $sumcount; # " " + my $funcdata; # " " + my $checkdata; # " " + my $testfncdata; + my $testfnccount; + my $sumfnccount; + my $testbrdata; + my $testbrcount; + my $sumbrcount; + my $line; # Current line read from .info file + my $testname; # Current test name + my $filename; # Current filename + my $hitcount; # Count for lines hit + my $count; # Execution count of current line + my $negative; # If set, warn about negative counts + my $changed_testname; # If set, warn about changed testname + my $line_checksum; # Checksum of current line + my $br_found; + my $br_hit; + local *INFO_HANDLE; # Filehandle for .info file + + info("Reading data file $tracefile\n"); + + # Check if file exists and is readable + stat($_[0]); + if (!(-r _)) + { + die("ERROR: cannot read file $_[0]!\n"); + } + + # Check if this is really a plain file + if (!(-f _)) + { + die("ERROR: not a plain file: $_[0]!\n"); + } + + # Check for .gz extension + if ($_[0] =~ /\.gz$/) + { + # Check for availability of GZIP tool + system_no_output(1, "gunzip" ,"-h") + and die("ERROR: gunzip command not available!\n"); + + # Check integrity of compressed file + system_no_output(1, "gunzip", "-t", $_[0]) + and die("ERROR: integrity check failed for ". + "compressed file $_[0]!\n"); + + # Open compressed file + open(INFO_HANDLE, "gunzip -c $_[0]|") + or die("ERROR: cannot start gunzip to decompress ". + "file $_[0]!\n"); + } + else + { + # Open decompressed file + open(INFO_HANDLE, $_[0]) + or die("ERROR: cannot read file $_[0]!\n"); + } + + $testname = ""; + while (<INFO_HANDLE>) + { + chomp($_); + $line = $_; + + # Switch statement + foreach ($line) + { + /^TN:([^,]*)(,diff)?/ && do + { + # Test name information found + $testname = defined($1) ? $1 : ""; + if ($testname =~ s/\W/_/g) + { + $changed_testname = 1; + } + $testname .= $2 if (defined($2)); + last; + }; + + /^[SK]F:(.*)/ && do + { + # Filename information found + # Retrieve data for new entry + $filename = $1; + + $data = $result{$filename}; + ($testdata, $sumcount, $funcdata, $checkdata, + $testfncdata, $sumfnccount, $testbrdata, + $sumbrcount) = + get_info_entry($data); + + if (defined($testname)) + { + $testcount = $testdata->{$testname}; + $testfnccount = $testfncdata->{$testname}; + $testbrcount = $testbrdata->{$testname}; + } + else + { + $testcount = {}; + $testfnccount = {}; + $testbrcount = {}; + } + last; + }; + + /^DA:(\d+),(-?\d+)(,[^,\s]+)?/ && do + { + # Fix negative counts + $count = $2 < 0 ? 0 : $2; + if ($2 < 0) + { + $negative = 1; + } + # Execution count found, add to structure + # Add summary counts + $sumcount->{$1} += $count; + + # Add test-specific counts + if (defined($testname)) + { + $testcount->{$1} += $count; + } + + # Store line checksum if available + if (defined($3)) + { + $line_checksum = substr($3, 1); + + # Does it match a previous definition + if (defined($checkdata->{$1}) && + ($checkdata->{$1} ne + $line_checksum)) + { + die("ERROR: checksum mismatch ". + "at $filename:$1\n"); + } + + $checkdata->{$1} = $line_checksum; + } + last; + }; + + /^FN:(\d+),([^,]+)/ && do + { + # Function data found, add to structure + $funcdata->{$2} = $1; + + # Also initialize function call data + if (!defined($sumfnccount->{$2})) { + $sumfnccount->{$2} = 0; + } + if (defined($testname)) + { + if (!defined($testfnccount->{$2})) { + $testfnccount->{$2} = 0; + } + } + last; + }; + + /^FNDA:(\d+),([^,]+)/ && do + { + # Function call count found, add to structure + # Add summary counts + $sumfnccount->{$2} += $1; + + # Add test-specific counts + if (defined($testname)) + { + $testfnccount->{$2} += $1; + } + last; + }; + + /^BRDA:(\d+),(\d+),(\d+),(\d+|-)/ && do { + # Branch coverage data found + my ($line, $block, $branch, $taken) = + ($1, $2, $3, $4); + + $sumbrcount->{$line} = + br_ivec_push($sumbrcount->{$line}, + $block, $branch, $taken); + + # Add test-specific counts + if (defined($testname)) { + $testbrcount->{$line} = + br_ivec_push( + $testbrcount->{$line}, + $block, $branch, + $taken); + } + last; + }; + + /^end_of_record/ && do + { + # Found end of section marker + if ($filename) + { + # Store current section data + if (defined($testname)) + { + $testdata->{$testname} = + $testcount; + $testfncdata->{$testname} = + $testfnccount; + $testbrdata->{$testname} = + $testbrcount; + } + + set_info_entry($data, $testdata, + $sumcount, $funcdata, + $checkdata, $testfncdata, + $sumfnccount, + $testbrdata, + $sumbrcount); + $result{$filename} = $data; + last; + } + }; + + # default + last; + } + } + close(INFO_HANDLE); + + # Calculate lines_found and lines_hit for each file + foreach $filename (keys(%result)) + { + $data = $result{$filename}; + + ($testdata, $sumcount, undef, undef, $testfncdata, + $sumfnccount, $testbrdata, $sumbrcount) = + get_info_entry($data); + + # Filter out empty files + if (scalar(keys(%{$sumcount})) == 0) + { + delete($result{$filename}); + next; + } + # Filter out empty test cases + foreach $testname (keys(%{$testdata})) + { + if (!defined($testdata->{$testname}) || + scalar(keys(%{$testdata->{$testname}})) == 0) + { + delete($testdata->{$testname}); + delete($testfncdata->{$testname}); + } + } + + $data->{"found"} = scalar(keys(%{$sumcount})); + $hitcount = 0; + + foreach (keys(%{$sumcount})) + { + if ($sumcount->{$_} > 0) { $hitcount++; } + } + + $data->{"hit"} = $hitcount; + + # Get found/hit values for function call data + $data->{"f_found"} = scalar(keys(%{$sumfnccount})); + $hitcount = 0; + + foreach (keys(%{$sumfnccount})) { + if ($sumfnccount->{$_} > 0) { + $hitcount++; + } + } + $data->{"f_hit"} = $hitcount; + + # Get found/hit values for branch data + ($br_found, $br_hit) = get_br_found_and_hit($sumbrcount); + + $data->{"b_found"} = $br_found; + $data->{"b_hit"} = $br_hit; + } + + if (scalar(keys(%result)) == 0) + { + die("ERROR: no valid records found in tracefile $tracefile\n"); + } + if ($negative) + { + warn("WARNING: negative counts found in tracefile ". + "$tracefile\n"); + } + if ($changed_testname) + { + warn("WARNING: invalid characters removed from testname in ". + "tracefile $tracefile\n"); + } + + return(\%result); +} + + +# +# get_info_entry(hash_ref) +# +# Retrieve data from an entry of the structure generated by read_info_file(). +# Return a list of references to hashes: +# (test data hash ref, sum count hash ref, funcdata hash ref, checkdata hash +# ref, testfncdata hash ref, sumfnccount hash ref, lines found, lines hit, +# functions found, functions hit) +# + +sub get_info_entry($) +{ + my $testdata_ref = $_[0]->{"test"}; + my $sumcount_ref = $_[0]->{"sum"}; + my $funcdata_ref = $_[0]->{"func"}; + my $checkdata_ref = $_[0]->{"check"}; + my $testfncdata = $_[0]->{"testfnc"}; + my $sumfnccount = $_[0]->{"sumfnc"}; + my $testbrdata = $_[0]->{"testbr"}; + my $sumbrcount = $_[0]->{"sumbr"}; + my $lines_found = $_[0]->{"found"}; + my $lines_hit = $_[0]->{"hit"}; + my $fn_found = $_[0]->{"f_found"}; + my $fn_hit = $_[0]->{"f_hit"}; + my $br_found = $_[0]->{"b_found"}; + my $br_hit = $_[0]->{"b_hit"}; + + return ($testdata_ref, $sumcount_ref, $funcdata_ref, $checkdata_ref, + $testfncdata, $sumfnccount, $testbrdata, $sumbrcount, + $lines_found, $lines_hit, $fn_found, $fn_hit, + $br_found, $br_hit); +} + + +# +# set_info_entry(hash_ref, testdata_ref, sumcount_ref, funcdata_ref, +# checkdata_ref, testfncdata_ref, sumfcncount_ref, +# testbrdata_ref, sumbrcount_ref[,lines_found, +# lines_hit, f_found, f_hit, $b_found, $b_hit]) +# +# Update the hash referenced by HASH_REF with the provided data references. +# + +sub set_info_entry($$$$$$$$$;$$$$$$) +{ + my $data_ref = $_[0]; + + $data_ref->{"test"} = $_[1]; + $data_ref->{"sum"} = $_[2]; + $data_ref->{"func"} = $_[3]; + $data_ref->{"check"} = $_[4]; + $data_ref->{"testfnc"} = $_[5]; + $data_ref->{"sumfnc"} = $_[6]; + $data_ref->{"testbr"} = $_[7]; + $data_ref->{"sumbr"} = $_[8]; + + if (defined($_[9])) { $data_ref->{"found"} = $_[9]; } + if (defined($_[10])) { $data_ref->{"hit"} = $_[10]; } + if (defined($_[11])) { $data_ref->{"f_found"} = $_[11]; } + if (defined($_[12])) { $data_ref->{"f_hit"} = $_[12]; } + if (defined($_[13])) { $data_ref->{"b_found"} = $_[13]; } + if (defined($_[14])) { $data_ref->{"b_hit"} = $_[14]; } +} + + +# +# add_counts(data1_ref, data2_ref) +# +# DATA1_REF and DATA2_REF are references to hashes containing a mapping +# +# line number -> execution count +# +# Return a list (RESULT_REF, LINES_FOUND, LINES_HIT) where RESULT_REF +# is a reference to a hash containing the combined mapping in which +# execution counts are added. +# + +sub add_counts($$) +{ + my %data1 = %{$_[0]}; # Hash 1 + my %data2 = %{$_[1]}; # Hash 2 + my %result; # Resulting hash + my $line; # Current line iteration scalar + my $data1_count; # Count of line in hash1 + my $data2_count; # Count of line in hash2 + my $found = 0; # Total number of lines found + my $hit = 0; # Number of lines with a count > 0 + + foreach $line (keys(%data1)) + { + $data1_count = $data1{$line}; + $data2_count = $data2{$line}; + + # Add counts if present in both hashes + if (defined($data2_count)) { $data1_count += $data2_count; } + + # Store sum in %result + $result{$line} = $data1_count; + + $found++; + if ($data1_count > 0) { $hit++; } + } + + # Add lines unique to data2 + foreach $line (keys(%data2)) + { + # Skip lines already in data1 + if (defined($data1{$line})) { next; } + + # Copy count from data2 + $result{$line} = $data2{$line}; + + $found++; + if ($result{$line} > 0) { $hit++; } + } + + return (\%result, $found, $hit); +} + + +# +# merge_checksums(ref1, ref2, filename) +# +# REF1 and REF2 are references to hashes containing a mapping +# +# line number -> checksum +# +# Merge checksum lists defined in REF1 and REF2 and return reference to +# resulting hash. Die if a checksum for a line is defined in both hashes +# but does not match. +# + +sub merge_checksums($$$) +{ + my $ref1 = $_[0]; + my $ref2 = $_[1]; + my $filename = $_[2]; + my %result; + my $line; + + foreach $line (keys(%{$ref1})) + { + if (defined($ref2->{$line}) && + ($ref1->{$line} ne $ref2->{$line})) + { + die("ERROR: checksum mismatch at $filename:$line\n"); + } + $result{$line} = $ref1->{$line}; + } + + foreach $line (keys(%{$ref2})) + { + $result{$line} = $ref2->{$line}; + } + + return \%result; +} + + +# +# merge_func_data(funcdata1, funcdata2, filename) +# + +sub merge_func_data($$$) +{ + my ($funcdata1, $funcdata2, $filename) = @_; + my %result; + my $func; + + if (defined($funcdata1)) { + %result = %{$funcdata1}; + } + + foreach $func (keys(%{$funcdata2})) { + my $line1 = $result{$func}; + my $line2 = $funcdata2->{$func}; + + if (defined($line1) && ($line1 != $line2)) { + warn("WARNING: function data mismatch at ". + "$filename:$line2\n"); + next; + } + $result{$func} = $line2; + } + + return \%result; +} + + +# +# add_fnccount(fnccount1, fnccount2) +# +# Add function call count data. Return list (fnccount_added, f_found, f_hit) +# + +sub add_fnccount($$) +{ + my ($fnccount1, $fnccount2) = @_; + my %result; + my $fn_found; + my $fn_hit; + my $function; + + if (defined($fnccount1)) { + %result = %{$fnccount1}; + } + foreach $function (keys(%{$fnccount2})) { + $result{$function} += $fnccount2->{$function}; + } + $fn_found = scalar(keys(%result)); + $fn_hit = 0; + foreach $function (keys(%result)) { + if ($result{$function} > 0) { + $fn_hit++; + } + } + + return (\%result, $fn_found, $fn_hit); +} + +# +# add_testfncdata(testfncdata1, testfncdata2) +# +# Add function call count data for several tests. Return reference to +# added_testfncdata. +# + +sub add_testfncdata($$) +{ + my ($testfncdata1, $testfncdata2) = @_; + my %result; + my $testname; + + foreach $testname (keys(%{$testfncdata1})) { + if (defined($testfncdata2->{$testname})) { + my $fnccount; + + # Function call count data for this testname exists + # in both data sets: add + ($fnccount) = add_fnccount( + $testfncdata1->{$testname}, + $testfncdata2->{$testname}); + $result{$testname} = $fnccount; + next; + } + # Function call count data for this testname is unique to + # data set 1: copy + $result{$testname} = $testfncdata1->{$testname}; + } + + # Add count data for testnames unique to data set 2 + foreach $testname (keys(%{$testfncdata2})) { + if (!defined($result{$testname})) { + $result{$testname} = $testfncdata2->{$testname}; + } + } + return \%result; +} + + +# +# brcount_to_db(brcount) +# +# Convert brcount data to the following format: +# +# db: line number -> block hash +# block hash: block number -> branch hash +# branch hash: branch number -> taken value +# + +sub brcount_to_db($) +{ + my ($brcount) = @_; + my $line; + my $db; + + # Add branches from first count to database + foreach $line (keys(%{$brcount})) { + my $brdata = $brcount->{$line}; + my $i; + my $num = br_ivec_len($brdata); + + for ($i = 0; $i < $num; $i++) { + my ($block, $branch, $taken) = br_ivec_get($brdata, $i); + + $db->{$line}->{$block}->{$branch} = $taken; + } + } + + return $db; +} + + +# +# db_to_brcount(db) +# +# Convert branch coverage data back to brcount format. +# + +sub db_to_brcount($) +{ + my ($db) = @_; + my $line; + my $brcount = {}; + my $br_found = 0; + my $br_hit = 0; + + # Convert database back to brcount format + foreach $line (sort({$a <=> $b} keys(%{$db}))) { + my $ldata = $db->{$line}; + my $brdata; + my $block; + + foreach $block (sort({$a <=> $b} keys(%{$ldata}))) { + my $bdata = $ldata->{$block}; + my $branch; + + foreach $branch (sort({$a <=> $b} keys(%{$bdata}))) { + my $taken = $bdata->{$branch}; + + $br_found++; + $br_hit++ if ($taken ne "-" && $taken > 0); + $brdata = br_ivec_push($brdata, $block, + $branch, $taken); + } + } + $brcount->{$line} = $brdata; + } + + return ($brcount, $br_found, $br_hit); +} + + +# +# combine_brcount(brcount1, brcount2, type) +# +# If add is BR_ADD, add branch coverage data and return list (brcount_added, +# br_found, br_hit). If add is BR_SUB, subtract the taken values of brcount2 +# from brcount1 and return (brcount_sub, br_found, br_hit). +# + +sub combine_brcount($$$) +{ + my ($brcount1, $brcount2, $type) = @_; + my $line; + my $block; + my $branch; + my $taken; + my $db; + my $br_found = 0; + my $br_hit = 0; + my $result; + + # Convert branches from first count to database + $db = brcount_to_db($brcount1); + # Combine values from database and second count + foreach $line (keys(%{$brcount2})) { + my $brdata = $brcount2->{$line}; + my $num = br_ivec_len($brdata); + my $i; + + for ($i = 0; $i < $num; $i++) { + ($block, $branch, $taken) = br_ivec_get($brdata, $i); + my $new_taken = $db->{$line}->{$block}->{$branch}; + + if ($type == $BR_ADD) { + $new_taken = br_taken_add($new_taken, $taken); + } elsif ($type == $BR_SUB) { + $new_taken = br_taken_sub($new_taken, $taken); + } + $db->{$line}->{$block}->{$branch} = $new_taken + if (defined($new_taken)); + } + } + # Convert database back to brcount format + ($result, $br_found, $br_hit) = db_to_brcount($db); + + return ($result, $br_found, $br_hit); +} + + +# +# add_testbrdata(testbrdata1, testbrdata2) +# +# Add branch coverage data for several tests. Return reference to +# added_testbrdata. +# + +sub add_testbrdata($$) +{ + my ($testbrdata1, $testbrdata2) = @_; + my %result; + my $testname; + + foreach $testname (keys(%{$testbrdata1})) { + if (defined($testbrdata2->{$testname})) { + my $brcount; + + # Branch coverage data for this testname exists + # in both data sets: add + ($brcount) = combine_brcount($testbrdata1->{$testname}, + $testbrdata2->{$testname}, $BR_ADD); + $result{$testname} = $brcount; + next; + } + # Branch coverage data for this testname is unique to + # data set 1: copy + $result{$testname} = $testbrdata1->{$testname}; + } + + # Add count data for testnames unique to data set 2 + foreach $testname (keys(%{$testbrdata2})) { + if (!defined($result{$testname})) { + $result{$testname} = $testbrdata2->{$testname}; + } + } + return \%result; +} + + +# +# combine_info_entries(entry_ref1, entry_ref2, filename) +# +# Combine .info data entry hashes referenced by ENTRY_REF1 and ENTRY_REF2. +# Return reference to resulting hash. +# + +sub combine_info_entries($$$) +{ + my $entry1 = $_[0]; # Reference to hash containing first entry + my $testdata1; + my $sumcount1; + my $funcdata1; + my $checkdata1; + my $testfncdata1; + my $sumfnccount1; + my $testbrdata1; + my $sumbrcount1; + + my $entry2 = $_[1]; # Reference to hash containing second entry + my $testdata2; + my $sumcount2; + my $funcdata2; + my $checkdata2; + my $testfncdata2; + my $sumfnccount2; + my $testbrdata2; + my $sumbrcount2; + + my %result; # Hash containing combined entry + my %result_testdata; + my $result_sumcount = {}; + my $result_funcdata; + my $result_testfncdata; + my $result_sumfnccount; + my $result_testbrdata; + my $result_sumbrcount; + my $lines_found; + my $lines_hit; + my $fn_found; + my $fn_hit; + my $br_found; + my $br_hit; + + my $testname; + my $filename = $_[2]; + + # Retrieve data + ($testdata1, $sumcount1, $funcdata1, $checkdata1, $testfncdata1, + $sumfnccount1, $testbrdata1, $sumbrcount1) = get_info_entry($entry1); + ($testdata2, $sumcount2, $funcdata2, $checkdata2, $testfncdata2, + $sumfnccount2, $testbrdata2, $sumbrcount2) = get_info_entry($entry2); + + # Merge checksums + $checkdata1 = merge_checksums($checkdata1, $checkdata2, $filename); + + # Combine funcdata + $result_funcdata = merge_func_data($funcdata1, $funcdata2, $filename); + + # Combine function call count data + $result_testfncdata = add_testfncdata($testfncdata1, $testfncdata2); + ($result_sumfnccount, $fn_found, $fn_hit) = + add_fnccount($sumfnccount1, $sumfnccount2); + + # Combine branch coverage data + $result_testbrdata = add_testbrdata($testbrdata1, $testbrdata2); + ($result_sumbrcount, $br_found, $br_hit) = + combine_brcount($sumbrcount1, $sumbrcount2, $BR_ADD); + + # Combine testdata + foreach $testname (keys(%{$testdata1})) + { + if (defined($testdata2->{$testname})) + { + # testname is present in both entries, requires + # combination + ($result_testdata{$testname}) = + add_counts($testdata1->{$testname}, + $testdata2->{$testname}); + } + else + { + # testname only present in entry1, add to result + $result_testdata{$testname} = $testdata1->{$testname}; + } + + # update sum count hash + ($result_sumcount, $lines_found, $lines_hit) = + add_counts($result_sumcount, + $result_testdata{$testname}); + } + + foreach $testname (keys(%{$testdata2})) + { + # Skip testnames already covered by previous iteration + if (defined($testdata1->{$testname})) { next; } + + # testname only present in entry2, add to result hash + $result_testdata{$testname} = $testdata2->{$testname}; + + # update sum count hash + ($result_sumcount, $lines_found, $lines_hit) = + add_counts($result_sumcount, + $result_testdata{$testname}); + } + + # Calculate resulting sumcount + + # Store result + set_info_entry(\%result, \%result_testdata, $result_sumcount, + $result_funcdata, $checkdata1, $result_testfncdata, + $result_sumfnccount, $result_testbrdata, + $result_sumbrcount, $lines_found, $lines_hit, + $fn_found, $fn_hit, $br_found, $br_hit); + + return(\%result); +} + + +# +# combine_info_files(info_ref1, info_ref2) +# +# Combine .info data in hashes referenced by INFO_REF1 and INFO_REF2. Return +# reference to resulting hash. +# + +sub combine_info_files($$) +{ + my %hash1 = %{$_[0]}; + my %hash2 = %{$_[1]}; + my $filename; + + foreach $filename (keys(%hash2)) + { + if ($hash1{$filename}) + { + # Entry already exists in hash1, combine them + $hash1{$filename} = + combine_info_entries($hash1{$filename}, + $hash2{$filename}, + $filename); + } + else + { + # Entry is unique in both hashes, simply add to + # resulting hash + $hash1{$filename} = $hash2{$filename}; + } + } + + return(\%hash1); +} + + +# +# get_prefix(filename_list) +# +# Search FILENAME_LIST for a directory prefix which is common to as many +# list entries as possible, so that removing this prefix will minimize the +# sum of the lengths of all resulting shortened filenames. +# + +sub get_prefix(@) +{ + my @filename_list = @_; # provided list of filenames + my %prefix; # mapping: prefix -> sum of lengths + my $current; # Temporary iteration variable + + # Find list of prefixes + foreach (@filename_list) + { + # Need explicit assignment to get a copy of $_ so that + # shortening the contained prefix does not affect the list + $current = shorten_prefix($_); + while ($current = shorten_prefix($current)) + { + # Skip rest if the remaining prefix has already been + # added to hash + if ($prefix{$current}) { last; } + + # Initialize with 0 + $prefix{$current}="0"; + } + + } + + # Calculate sum of lengths for all prefixes + foreach $current (keys(%prefix)) + { + foreach (@filename_list) + { + # Add original length + $prefix{$current} += length($_); + + # Check whether prefix matches + if (substr($_, 0, length($current)) eq $current) + { + # Subtract prefix length for this filename + $prefix{$current} -= length($current); + } + } + } + + # Find and return prefix with minimal sum + $current = (keys(%prefix))[0]; + + foreach (keys(%prefix)) + { + if ($prefix{$_} < $prefix{$current}) + { + $current = $_; + } + } + + return($current); +} + + +# +# shorten_prefix(prefix) +# +# Return PREFIX shortened by last directory component. +# + +sub shorten_prefix($) +{ + my @list = split("/", $_[0]); + + pop(@list); + return join("/", @list); +} + + + +# +# get_dir_list(filename_list) +# +# Return sorted list of directories for each entry in given FILENAME_LIST. +# + +sub get_dir_list(@) +{ + my %result; + + foreach (@_) + { + $result{shorten_prefix($_)} = ""; + } + + return(sort(keys(%result))); +} + + +# +# get_relative_base_path(subdirectory) +# +# Return a relative path string which references the base path when applied +# in SUBDIRECTORY. +# +# Example: get_relative_base_path("fs/mm") -> "../../" +# + +sub get_relative_base_path($) +{ + my $result = ""; + my $index; + + # Make an empty directory path a special case + if (!$_[0]) { return(""); } + + # Count number of /s in path + $index = ($_[0] =~ s/\//\//g); + + # Add a ../ to $result for each / in the directory path + 1 + for (; $index>=0; $index--) + { + $result .= "../"; + } + + return $result; +} + + +# +# read_testfile(test_filename) +# +# Read in file TEST_FILENAME which contains test descriptions in the format: +# +# TN:<whitespace><test name> +# TD:<whitespace><test description> +# +# for each test case. Return a reference to a hash containing a mapping +# +# test name -> test description. +# +# Die on error. +# + +sub read_testfile($) +{ + my %result; + my $test_name; + my $changed_testname; + local *TEST_HANDLE; + + open(TEST_HANDLE, "<".$_[0]) + or die("ERROR: cannot open $_[0]!\n"); + + while (<TEST_HANDLE>) + { + chomp($_); + + # Match lines beginning with TN:<whitespace(s)> + if (/^TN:\s+(.*?)\s*$/) + { + # Store name for later use + $test_name = $1; + if ($test_name =~ s/\W/_/g) + { + $changed_testname = 1; + } + } + + # Match lines beginning with TD:<whitespace(s)> + if (/^TD:\s+(.*?)\s*$/) + { + # Check for empty line + if ($1) + { + # Add description to hash + $result{$test_name} .= " $1"; + } + else + { + # Add empty line + $result{$test_name} .= "\n\n"; + } + } + } + + close(TEST_HANDLE); + + if ($changed_testname) + { + warn("WARNING: invalid characters removed from testname in ". + "descriptions file $_[0]\n"); + } + + return \%result; +} + + +# +# escape_html(STRING) +# +# Return a copy of STRING in which all occurrences of HTML special characters +# are escaped. +# + +sub escape_html($) +{ + my $string = $_[0]; + + if (!$string) { return ""; } + + $string =~ s/&/&/g; # & -> & + $string =~ s/</</g; # < -> < + $string =~ s/>/>/g; # > -> > + $string =~ s/\"/"/g; # " -> " + + while ($string =~ /^([^\t]*)(\t)/) + { + my $replacement = " "x($tab_size - (length($1) % $tab_size)); + $string =~ s/^([^\t]*)(\t)/$1$replacement/; + } + + $string =~ s/\n/<br>/g; # \n -> <br> + + return $string; +} + + +# +# get_date_string() +# +# Return the current date in the form: yyyy-mm-dd +# + +sub get_date_string() +{ + my $year; + my $month; + my $day; + + ($year, $month, $day) = (localtime())[5, 4, 3]; + + return sprintf("%d-%02d-%02d", $year+1900, $month+1, $day); +} + + +# +# create_sub_dir(dir_name) +# +# Create subdirectory DIR_NAME if it does not already exist, including all its +# parent directories. +# +# Die on error. +# + +sub create_sub_dir($) +{ + my ($dir) = @_; + + system("mkdir", "-p" ,$dir) + and die("ERROR: cannot create directory $dir!\n"); +} + + +# +# write_description_file(descriptions, overall_found, overall_hit, +# total_fn_found, total_fn_hit, total_br_found, +# total_br_hit) +# +# Write HTML file containing all test case descriptions. DESCRIPTIONS is a +# reference to a hash containing a mapping +# +# test case name -> test case description +# +# Die on error. +# + +sub write_description_file($$$$$$$) +{ + my %description = %{$_[0]}; + my $found = $_[1]; + my $hit = $_[2]; + my $fn_found = $_[3]; + my $fn_hit = $_[4]; + my $br_found = $_[5]; + my $br_hit = $_[6]; + my $test_name; + local *HTML_HANDLE; + + html_create(*HTML_HANDLE,"descriptions.$html_ext"); + write_html_prolog(*HTML_HANDLE, "", "LCOV - test case descriptions"); + write_header(*HTML_HANDLE, 3, "", "", $found, $hit, $fn_found, + $fn_hit, $br_found, $br_hit, 0); + + write_test_table_prolog(*HTML_HANDLE, + "Test case descriptions - alphabetical list"); + + foreach $test_name (sort(keys(%description))) + { + write_test_table_entry(*HTML_HANDLE, $test_name, + escape_html($description{$test_name})); + } + + write_test_table_epilog(*HTML_HANDLE); + write_html_epilog(*HTML_HANDLE, ""); + + close(*HTML_HANDLE); +} + + + +# +# write_png_files() +# +# Create all necessary .png files for the HTML-output in the current +# directory. .png-files are used as bar graphs. +# +# Die on error. +# + +sub write_png_files() +{ + my %data; + local *PNG_HANDLE; + + $data{"ruby.png"} = + [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, + 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52, 0x00, 0x00, 0x00, 0x01, + 0x00, 0x00, 0x00, 0x01, 0x01, 0x03, 0x00, 0x00, 0x00, 0x25, + 0xdb, 0x56, 0xca, 0x00, 0x00, 0x00, 0x07, 0x74, 0x49, 0x4d, + 0x45, 0x07, 0xd2, 0x07, 0x11, 0x0f, 0x18, 0x10, 0x5d, 0x57, + 0x34, 0x6e, 0x00, 0x00, 0x00, 0x09, 0x70, 0x48, 0x59, 0x73, + 0x00, 0x00, 0x0b, 0x12, 0x00, 0x00, 0x0b, 0x12, 0x01, 0xd2, + 0xdd, 0x7e, 0xfc, 0x00, 0x00, 0x00, 0x04, 0x67, 0x41, 0x4d, + 0x41, 0x00, 0x00, 0xb1, 0x8f, 0x0b, 0xfc, 0x61, 0x05, 0x00, + 0x00, 0x00, 0x06, 0x50, 0x4c, 0x54, 0x45, 0xff, 0x35, 0x2f, + 0x00, 0x00, 0x00, 0xd0, 0x33, 0x9a, 0x9d, 0x00, 0x00, 0x00, + 0x0a, 0x49, 0x44, 0x41, 0x54, 0x78, 0xda, 0x63, 0x60, 0x00, + 0x00, 0x00, 0x02, 0x00, 0x01, 0xe5, 0x27, 0xde, 0xfc, 0x00, + 0x00, 0x00, 0x00, 0x49, 0x45, 0x4e, 0x44, 0xae, 0x42, 0x60, + 0x82]; + $data{"amber.png"} = + [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, + 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52, 0x00, 0x00, 0x00, 0x01, + 0x00, 0x00, 0x00, 0x01, 0x01, 0x03, 0x00, 0x00, 0x00, 0x25, + 0xdb, 0x56, 0xca, 0x00, 0x00, 0x00, 0x07, 0x74, 0x49, 0x4d, + 0x45, 0x07, 0xd2, 0x07, 0x11, 0x0f, 0x28, 0x04, 0x98, 0xcb, + 0xd6, 0xe0, 0x00, 0x00, 0x00, 0x09, 0x70, 0x48, 0x59, 0x73, + 0x00, 0x00, 0x0b, 0x12, 0x00, 0x00, 0x0b, 0x12, 0x01, 0xd2, + 0xdd, 0x7e, 0xfc, 0x00, 0x00, 0x00, 0x04, 0x67, 0x41, 0x4d, + 0x41, 0x00, 0x00, 0xb1, 0x8f, 0x0b, 0xfc, 0x61, 0x05, 0x00, + 0x00, 0x00, 0x06, 0x50, 0x4c, 0x54, 0x45, 0xff, 0xe0, 0x50, + 0x00, 0x00, 0x00, 0xa2, 0x7a, 0xda, 0x7e, 0x00, 0x00, 0x00, + 0x0a, 0x49, 0x44, 0x41, 0x54, 0x78, 0xda, 0x63, 0x60, 0x00, + 0x00, 0x00, 0x02, 0x00, 0x01, 0xe5, 0x27, 0xde, 0xfc, 0x00, + 0x00, 0x00, 0x00, 0x49, 0x45, 0x4e, 0x44, 0xae, 0x42, 0x60, + 0x82]; + $data{"emerald.png"} = + [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, + 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52, 0x00, 0x00, 0x00, 0x01, + 0x00, 0x00, 0x00, 0x01, 0x01, 0x03, 0x00, 0x00, 0x00, 0x25, + 0xdb, 0x56, 0xca, 0x00, 0x00, 0x00, 0x07, 0x74, 0x49, 0x4d, + 0x45, 0x07, 0xd2, 0x07, 0x11, 0x0f, 0x22, 0x2b, 0xc9, 0xf5, + 0x03, 0x33, 0x00, 0x00, 0x00, 0x09, 0x70, 0x48, 0x59, 0x73, + 0x00, 0x00, 0x0b, 0x12, 0x00, 0x00, 0x0b, 0x12, 0x01, 0xd2, + 0xdd, 0x7e, 0xfc, 0x00, 0x00, 0x00, 0x04, 0x67, 0x41, 0x4d, + 0x41, 0x00, 0x00, 0xb1, 0x8f, 0x0b, 0xfc, 0x61, 0x05, 0x00, + 0x00, 0x00, 0x06, 0x50, 0x4c, 0x54, 0x45, 0x1b, 0xea, 0x59, + 0x0a, 0x0a, 0x0a, 0x0f, 0xba, 0x50, 0x83, 0x00, 0x00, 0x00, + 0x0a, 0x49, 0x44, 0x41, 0x54, 0x78, 0xda, 0x63, 0x60, 0x00, + 0x00, 0x00, 0x02, 0x00, 0x01, 0xe5, 0x27, 0xde, 0xfc, 0x00, + 0x00, 0x00, 0x00, 0x49, 0x45, 0x4e, 0x44, 0xae, 0x42, 0x60, + 0x82]; + $data{"snow.png"} = + [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, + 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52, 0x00, 0x00, 0x00, 0x01, + 0x00, 0x00, 0x00, 0x01, 0x01, 0x03, 0x00, 0x00, 0x00, 0x25, + 0xdb, 0x56, 0xca, 0x00, 0x00, 0x00, 0x07, 0x74, 0x49, 0x4d, + 0x45, 0x07, 0xd2, 0x07, 0x11, 0x0f, 0x1e, 0x1d, 0x75, 0xbc, + 0xef, 0x55, 0x00, 0x00, 0x00, 0x09, 0x70, 0x48, 0x59, 0x73, + 0x00, 0x00, 0x0b, 0x12, 0x00, 0x00, 0x0b, 0x12, 0x01, 0xd2, + 0xdd, 0x7e, 0xfc, 0x00, 0x00, 0x00, 0x04, 0x67, 0x41, 0x4d, + 0x41, 0x00, 0x00, 0xb1, 0x8f, 0x0b, 0xfc, 0x61, 0x05, 0x00, + 0x00, 0x00, 0x06, 0x50, 0x4c, 0x54, 0x45, 0xff, 0xff, 0xff, + 0x00, 0x00, 0x00, 0x55, 0xc2, 0xd3, 0x7e, 0x00, 0x00, 0x00, + 0x0a, 0x49, 0x44, 0x41, 0x54, 0x78, 0xda, 0x63, 0x60, 0x00, + 0x00, 0x00, 0x02, 0x00, 0x01, 0xe5, 0x27, 0xde, 0xfc, 0x00, + 0x00, 0x00, 0x00, 0x49, 0x45, 0x4e, 0x44, 0xae, 0x42, 0x60, + 0x82]; + $data{"glass.png"} = + [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, + 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52, 0x00, 0x00, 0x00, 0x01, + 0x00, 0x00, 0x00, 0x01, 0x01, 0x03, 0x00, 0x00, 0x00, 0x25, + 0xdb, 0x56, 0xca, 0x00, 0x00, 0x00, 0x04, 0x67, 0x41, 0x4d, + 0x41, 0x00, 0x00, 0xb1, 0x8f, 0x0b, 0xfc, 0x61, 0x05, 0x00, + 0x00, 0x00, 0x06, 0x50, 0x4c, 0x54, 0x45, 0xff, 0xff, 0xff, + 0x00, 0x00, 0x00, 0x55, 0xc2, 0xd3, 0x7e, 0x00, 0x00, 0x00, + 0x01, 0x74, 0x52, 0x4e, 0x53, 0x00, 0x40, 0xe6, 0xd8, 0x66, + 0x00, 0x00, 0x00, 0x01, 0x62, 0x4b, 0x47, 0x44, 0x00, 0x88, + 0x05, 0x1d, 0x48, 0x00, 0x00, 0x00, 0x09, 0x70, 0x48, 0x59, + 0x73, 0x00, 0x00, 0x0b, 0x12, 0x00, 0x00, 0x0b, 0x12, 0x01, + 0xd2, 0xdd, 0x7e, 0xfc, 0x00, 0x00, 0x00, 0x07, 0x74, 0x49, + 0x4d, 0x45, 0x07, 0xd2, 0x07, 0x13, 0x0f, 0x08, 0x19, 0xc4, + 0x40, 0x56, 0x10, 0x00, 0x00, 0x00, 0x0a, 0x49, 0x44, 0x41, + 0x54, 0x78, 0x9c, 0x63, 0x60, 0x00, 0x00, 0x00, 0x02, 0x00, + 0x01, 0x48, 0xaf, 0xa4, 0x71, 0x00, 0x00, 0x00, 0x00, 0x49, + 0x45, 0x4e, 0x44, 0xae, 0x42, 0x60, 0x82]; + $data{"updown.png"} = + [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, + 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52, 0x00, 0x00, 0x00, 0x0a, + 0x00, 0x00, 0x00, 0x0e, 0x08, 0x06, 0x00, 0x00, 0x00, 0x16, + 0xa3, 0x8d, 0xab, 0x00, 0x00, 0x00, 0x3c, 0x49, 0x44, 0x41, + 0x54, 0x28, 0xcf, 0x63, 0x60, 0x40, 0x03, 0xff, 0xa1, 0x00, + 0x5d, 0x9c, 0x11, 0x5d, 0x11, 0x8a, 0x24, 0x23, 0x23, 0x23, + 0x86, 0x42, 0x6c, 0xa6, 0x20, 0x2b, 0x66, 0xc4, 0xa7, 0x08, + 0x59, 0x31, 0x23, 0x21, 0x45, 0x30, 0xc0, 0xc4, 0x30, 0x60, + 0x80, 0xfa, 0x6e, 0x24, 0x3e, 0x78, 0x48, 0x0a, 0x70, 0x62, + 0xa2, 0x90, 0x81, 0xd8, 0x44, 0x01, 0x00, 0xe9, 0x5c, 0x2f, + 0xf5, 0xe2, 0x9d, 0x0f, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x49, + 0x45, 0x4e, 0x44, 0xae, 0x42, 0x60, 0x82] if ($sort); + foreach (keys(%data)) + { + open(PNG_HANDLE, ">".$_) + or die("ERROR: cannot create $_!\n"); + binmode(PNG_HANDLE); + print(PNG_HANDLE map(chr,@{$data{$_}})); + close(PNG_HANDLE); + } +} + + +# +# write_htaccess_file() +# + +sub write_htaccess_file() +{ + local *HTACCESS_HANDLE; + my $htaccess_data; + + open(*HTACCESS_HANDLE, ">.htaccess") + or die("ERROR: cannot open .htaccess for writing!\n"); + + $htaccess_data = (<<"END_OF_HTACCESS") +AddEncoding x-gzip .html +END_OF_HTACCESS + ; + + print(HTACCESS_HANDLE $htaccess_data); + close(*HTACCESS_HANDLE); +} + + +# +# write_css_file() +# +# Write the cascading style sheet file gcov.css to the current directory. +# This file defines basic layout attributes of all generated HTML pages. +# + +sub write_css_file() +{ + local *CSS_HANDLE; + + # Check for a specified external style sheet file + if ($css_filename) + { + # Simply copy that file + system("cp", $css_filename, "gcov.css") + and die("ERROR: cannot copy file $css_filename!\n"); + return; + } + + open(CSS_HANDLE, ">gcov.css") + or die ("ERROR: cannot open gcov.css for writing!\n"); + + + # ************************************************************* + + my $css_data = ($_=<<"END_OF_CSS") + /* All views: initial background and text color */ + body + { + color: #000000; + background-color: #FFFFFF; + } + + /* All views: standard link format*/ + a:link + { + color: #284FA8; + text-decoration: underline; + } + + /* All views: standard link - visited format */ + a:visited + { + color: #00CB40; + text-decoration: underline; + } + + /* All views: standard link - activated format */ + a:active + { + color: #FF0040; + text-decoration: underline; + } + + /* All views: main title format */ + td.title + { + text-align: center; + padding-bottom: 10px; + font-family: sans-serif; + font-size: 20pt; + font-style: italic; + font-weight: bold; + } + + /* All views: header item format */ + td.headerItem + { + text-align: right; + padding-right: 6px; + font-family: sans-serif; + font-weight: bold; + vertical-align: top; + white-space: nowrap; + } + + /* All views: header item value format */ + td.headerValue + { + text-align: left; + color: #284FA8; + font-family: sans-serif; + font-weight: bold; + white-space: nowrap; + } + + /* All views: header item coverage table heading */ + td.headerCovTableHead + { + text-align: center; + padding-right: 6px; + padding-left: 6px; + padding-bottom: 0px; + font-family: sans-serif; + font-size: 80%; + white-space: nowrap; + } + + /* All views: header item coverage table entry */ + td.headerCovTableEntry + { + text-align: right; + color: #284FA8; + font-family: sans-serif; + font-weight: bold; + white-space: nowrap; + padding-left: 12px; + padding-right: 4px; + background-color: #DAE7FE; + } + + /* All views: header item coverage table entry for high coverage rate */ + td.headerCovTableEntryHi + { + text-align: right; + color: #000000; + font-family: sans-serif; + font-weight: bold; + white-space: nowrap; + padding-left: 12px; + padding-right: 4px; + background-color: #A7FC9D; + } + + /* All views: header item coverage table entry for medium coverage rate */ + td.headerCovTableEntryMed + { + text-align: right; + color: #000000; + font-family: sans-serif; + font-weight: bold; + white-space: nowrap; + padding-left: 12px; + padding-right: 4px; + background-color: #FFEA20; + } + + /* All views: header item coverage table entry for ow coverage rate */ + td.headerCovTableEntryLo + { + text-align: right; + color: #000000; + font-family: sans-serif; + font-weight: bold; + white-space: nowrap; + padding-left: 12px; + padding-right: 4px; + background-color: #FF0000; + } + + /* All views: header legend value for legend entry */ + td.headerValueLeg + { + text-align: left; + color: #000000; + font-family: sans-serif; + font-size: 80%; + white-space: nowrap; + padding-top: 4px; + } + + /* All views: color of horizontal ruler */ + td.ruler + { + background-color: #6688D4; + } + + /* All views: version string format */ + td.versionInfo + { + text-align: center; + padding-top: 2px; + font-family: sans-serif; + font-style: italic; + } + + /* Directory view/File view (all)/Test case descriptions: + table headline format */ + td.tableHead + { + text-align: center; + color: #FFFFFF; + background-color: #6688D4; + font-family: sans-serif; + font-size: 120%; + font-weight: bold; + white-space: nowrap; + padding-left: 4px; + padding-right: 4px; + } + + span.tableHeadSort + { + padding-right: 4px; + } + + /* Directory view/File view (all): filename entry format */ + td.coverFile + { + text-align: left; + padding-left: 10px; + padding-right: 20px; + color: #284FA8; + background-color: #DAE7FE; + font-family: monospace; + } + + /* Directory view/File view (all): bar-graph entry format*/ + td.coverBar + { + padding-left: 10px; + padding-right: 10px; + background-color: #DAE7FE; + } + + /* Directory view/File view (all): bar-graph outline color */ + td.coverBarOutline + { + background-color: #000000; + } + + /* Directory view/File view (all): percentage entry for files with + high coverage rate */ + td.coverPerHi + { + text-align: right; + padding-left: 10px; + padding-right: 10px; + background-color: #A7FC9D; + font-weight: bold; + font-family: sans-serif; + } + + /* Directory view/File view (all): line count entry for files with + high coverage rate */ + td.coverNumHi + { + text-align: right; + padding-left: 10px; + padding-right: 10px; + background-color: #A7FC9D; + white-space: nowrap; + font-family: sans-serif; + } + + /* Directory view/File view (all): percentage entry for files with + medium coverage rate */ + td.coverPerMed + { + text-align: right; + padding-left: 10px; + padding-right: 10px; + background-color: #FFEA20; + font-weight: bold; + font-family: sans-serif; + } + + /* Directory view/File view (all): line count entry for files with + medium coverage rate */ + td.coverNumMed + { + text-align: right; + padding-left: 10px; + padding-right: 10px; + background-color: #FFEA20; + white-space: nowrap; + font-family: sans-serif; + } + + /* Directory view/File view (all): percentage entry for files with + low coverage rate */ + td.coverPerLo + { + text-align: right; + padding-left: 10px; + padding-right: 10px; + background-color: #FF0000; + font-weight: bold; + font-family: sans-serif; + } + + /* Directory view/File view (all): line count entry for files with + low coverage rate */ + td.coverNumLo + { + text-align: right; + padding-left: 10px; + padding-right: 10px; + background-color: #FF0000; + white-space: nowrap; + font-family: sans-serif; + } + + /* File view (all): "show/hide details" link format */ + a.detail:link + { + color: #B8D0FF; + font-size:80%; + } + + /* File view (all): "show/hide details" link - visited format */ + a.detail:visited + { + color: #B8D0FF; + font-size:80%; + } + + /* File view (all): "show/hide details" link - activated format */ + a.detail:active + { + color: #FFFFFF; + font-size:80%; + } + + /* File view (detail): test name entry */ + td.testName + { + text-align: right; + padding-right: 10px; + background-color: #DAE7FE; + font-family: sans-serif; + } + + /* File view (detail): test percentage entry */ + td.testPer + { + text-align: right; + padding-left: 10px; + padding-right: 10px; + background-color: #DAE7FE; + font-family: sans-serif; + } + + /* File view (detail): test lines count entry */ + td.testNum + { + text-align: right; + padding-left: 10px; + padding-right: 10px; + background-color: #DAE7FE; + font-family: sans-serif; + } + + /* Test case descriptions: test name format*/ + dt + { + font-family: sans-serif; + font-weight: bold; + } + + /* Test case descriptions: description table body */ + td.testDescription + { + padding-top: 10px; + padding-left: 30px; + padding-bottom: 10px; + padding-right: 30px; + background-color: #DAE7FE; + } + + /* Source code view: function entry */ + td.coverFn + { + text-align: left; + padding-left: 10px; + padding-right: 20px; + color: #284FA8; + background-color: #DAE7FE; + font-family: monospace; + } + + /* Source code view: function entry zero count*/ + td.coverFnLo + { + text-align: right; + padding-left: 10px; + padding-right: 10px; + background-color: #FF0000; + font-weight: bold; + font-family: sans-serif; + } + + /* Source code view: function entry nonzero count*/ + td.coverFnHi + { + text-align: right; + padding-left: 10px; + padding-right: 10px; + background-color: #DAE7FE; + font-weight: bold; + font-family: sans-serif; + } + + /* Source code view: source code format */ + pre.source + { + font-family: monospace; + white-space: pre; + margin-top: 2px; + } + + /* Source code view: line number format */ + span.lineNum + { + background-color: #EFE383; + } + + /* Source code view: format for lines which were executed */ + td.lineCov, + span.lineCov + { + background-color: #CAD7FE; + } + + /* Source code view: format for Cov legend */ + span.coverLegendCov + { + padding-left: 10px; + padding-right: 10px; + padding-bottom: 2px; + background-color: #CAD7FE; + } + + /* Source code view: format for lines which were not executed */ + td.lineNoCov, + span.lineNoCov + { + background-color: #FF6230; + } + + /* Source code view: format for NoCov legend */ + span.coverLegendNoCov + { + padding-left: 10px; + padding-right: 10px; + padding-bottom: 2px; + background-color: #FF6230; + } + + /* Source code view (function table): standard link - visited format */ + td.lineNoCov > a:visited, + td.lineCov > a:visited + { + color: black; + text-decoration: underline; + } + + /* Source code view: format for lines which were executed only in a + previous version */ + span.lineDiffCov + { + background-color: #B5F7AF; + } + + /* Source code view: format for branches which were executed + * and taken */ + span.branchCov + { + background-color: #CAD7FE; + } + + /* Source code view: format for branches which were executed + * but not taken */ + span.branchNoCov + { + background-color: #FF6230; + } + + /* Source code view: format for branches which were not executed */ + span.branchNoExec + { + background-color: #FF6230; + } + + /* Source code view: format for the source code heading line */ + pre.sourceHeading + { + white-space: pre; + font-family: monospace; + font-weight: bold; + margin: 0px; + } + + /* All views: header legend value for low rate */ + td.headerValueLegL + { + font-family: sans-serif; + text-align: center; + white-space: nowrap; + padding-left: 4px; + padding-right: 2px; + background-color: #FF0000; + font-size: 80%; + } + + /* All views: header legend value for med rate */ + td.headerValueLegM + { + font-family: sans-serif; + text-align: center; + white-space: nowrap; + padding-left: 2px; + padding-right: 2px; + background-color: #FFEA20; + font-size: 80%; + } + + /* All views: header legend value for hi rate */ + td.headerValueLegH + { + font-family: sans-serif; + text-align: center; + white-space: nowrap; + padding-left: 2px; + padding-right: 4px; + background-color: #A7FC9D; + font-size: 80%; + } + + /* All views except source code view: legend format for low coverage */ + span.coverLegendCovLo + { + padding-left: 10px; + padding-right: 10px; + padding-top: 2px; + background-color: #FF0000; + } + + /* All views except source code view: legend format for med coverage */ + span.coverLegendCovMed + { + padding-left: 10px; + padding-right: 10px; + padding-top: 2px; + background-color: #FFEA20; + } + + /* All views except source code view: legend format for hi coverage */ + span.coverLegendCovHi + { + padding-left: 10px; + padding-right: 10px; + padding-top: 2px; + background-color: #A7FC9D; + } +END_OF_CSS + ; + + # ************************************************************* + + + # Remove leading tab from all lines + $css_data =~ s/^\t//gm; + + print(CSS_HANDLE $css_data); + + close(CSS_HANDLE); +} + + +# +# get_bar_graph_code(base_dir, cover_found, cover_hit) +# +# Return a string containing HTML code which implements a bar graph display +# for a coverage rate of cover_hit * 100 / cover_found. +# + +sub get_bar_graph_code($$$) +{ + my $rate; + my $alt; + my $width; + my $remainder; + my $png_name; + my $graph_code; + + # Check number of instrumented lines + if ($_[1] == 0) { return ""; } + + $rate = $_[2] * 100 / $_[1]; + $alt = sprintf("%.1f", $rate)."%"; + $width = sprintf("%.0f", $rate); + $remainder = sprintf("%d", 100-$width); + + # Decide which .png file to use + $png_name = $rate_png[classify_rate($_[1], $_[2], $med_limit, + $hi_limit)]; + + if ($width == 0) + { + # Zero coverage + $graph_code = (<<END_OF_HTML) + <table border=0 cellspacing=0 cellpadding=1><tr><td class="coverBarOutline"><img src="$_[0]snow.png" width=100 height=10 alt="$alt"></td></tr></table> +END_OF_HTML + ; + } + elsif ($width == 100) + { + # Full coverage + $graph_code = (<<END_OF_HTML) + <table border=0 cellspacing=0 cellpadding=1><tr><td class="coverBarOutline"><img src="$_[0]$png_name" width=100 height=10 alt="$alt"></td></tr></table> +END_OF_HTML + ; + } + else + { + # Positive coverage + $graph_code = (<<END_OF_HTML) + <table border=0 cellspacing=0 cellpadding=1><tr><td class="coverBarOutline"><img src="$_[0]$png_name" width=$width height=10 alt="$alt"><img src="$_[0]snow.png" width=$remainder height=10 alt="$alt"></td></tr></table> +END_OF_HTML + ; + } + + # Remove leading tabs from all lines + $graph_code =~ s/^\t+//gm; + chomp($graph_code); + + return($graph_code); +} + +# +# sub classify_rate(found, hit, med_limit, high_limit) +# +# Return 0 for low rate, 1 for medium rate and 2 for hi rate. +# + +sub classify_rate($$$$) +{ + my ($found, $hit, $med, $hi) = @_; + my $rate; + + if ($found == 0) { + return 2; + } + $rate = $hit * 100 / $found; + if ($rate < $med) { + return 0; + } elsif ($rate < $hi) { + return 1; + } + return 2; +} + + +# +# write_html(filehandle, html_code) +# +# Write out HTML_CODE to FILEHANDLE while removing a leading tabulator mark +# in each line of HTML_CODE. +# + +sub write_html(*$) +{ + local *HTML_HANDLE = $_[0]; + my $html_code = $_[1]; + + # Remove leading tab from all lines + $html_code =~ s/^\t//gm; + + print(HTML_HANDLE $html_code) + or die("ERROR: cannot write HTML data ($!)\n"); +} + + +# +# write_html_prolog(filehandle, base_dir, pagetitle) +# +# Write an HTML prolog common to all HTML files to FILEHANDLE. PAGETITLE will +# be used as HTML page title. BASE_DIR contains a relative path which points +# to the base directory. +# + +sub write_html_prolog(*$$) +{ + my $basedir = $_[1]; + my $pagetitle = $_[2]; + my $prolog; + + $prolog = $html_prolog; + $prolog =~ s/\@pagetitle\@/$pagetitle/g; + $prolog =~ s/\@basedir\@/$basedir/g; + + write_html($_[0], $prolog); +} + + +# +# write_header_prolog(filehandle, base_dir) +# +# Write beginning of page header HTML code. +# + +sub write_header_prolog(*$) +{ + # ************************************************************* + + write_html($_[0], <<END_OF_HTML) + <table width="100%" border=0 cellspacing=0 cellpadding=0> + <tr><td class="title">$title</td></tr> + <tr><td class="ruler"><img src="$_[1]glass.png" width=3 height=3 alt=""></td></tr> + + <tr> + <td width="100%"> + <table cellpadding=1 border=0 width="100%"> +END_OF_HTML + ; + + # ************************************************************* +} + + +# +# write_header_line(handle, content) +# +# Write a header line with the specified table contents. +# + +sub write_header_line(*@) +{ + my ($handle, @content) = @_; + my $entry; + + write_html($handle, " <tr>\n"); + foreach $entry (@content) { + my ($width, $class, $text, $colspan) = @{$entry}; + + if (defined($width)) { + $width = " width=\"$width\""; + } else { + $width = ""; + } + if (defined($class)) { + $class = " class=\"$class\""; + } else { + $class = ""; + } + if (defined($colspan)) { + $colspan = " colspan=\"$colspan\""; + } else { + $colspan = ""; + } + $text = "" if (!defined($text)); + write_html($handle, + " <td$width$class$colspan>$text</td>\n"); + } + write_html($handle, " </tr>\n"); +} + + +# +# write_header_epilog(filehandle, base_dir) +# +# Write end of page header HTML code. +# + +sub write_header_epilog(*$) +{ + # ************************************************************* + + write_html($_[0], <<END_OF_HTML) + <tr><td><img src="$_[1]glass.png" width=3 height=3 alt=""></td></tr> + </table> + </td> + </tr> + + <tr><td class="ruler"><img src="$_[1]glass.png" width=3 height=3 alt=""></td></tr> + </table> + +END_OF_HTML + ; + + # ************************************************************* +} + + +# +# write_file_table_prolog(handle, file_heading, ([heading, num_cols], ...)) +# +# Write heading for file table. +# + +sub write_file_table_prolog(*$@) +{ + my ($handle, $file_heading, @columns) = @_; + my $num_columns = 0; + my $file_width; + my $col; + my $width; + + $width = 20 if (scalar(@columns) == 1); + $width = 10 if (scalar(@columns) == 2); + $width = 8 if (scalar(@columns) > 2); + + foreach $col (@columns) { + my ($heading, $cols) = @{$col}; + + $num_columns += $cols; + } + $file_width = 100 - $num_columns * $width; + + # Table definition + write_html($handle, <<END_OF_HTML); + <center> + <table width="80%" cellpadding=1 cellspacing=1 border=0> + + <tr> + <td width="$file_width%"><br></td> +END_OF_HTML + # Empty first row + foreach $col (@columns) { + my ($heading, $cols) = @{$col}; + + while ($cols-- > 0) { + write_html($handle, <<END_OF_HTML); + <td width="$width%"></td> +END_OF_HTML + } + } + # Next row + write_html($handle, <<END_OF_HTML); + </tr> + + <tr> + <td class="tableHead">$file_heading</td> +END_OF_HTML + # Heading row + foreach $col (@columns) { + my ($heading, $cols) = @{$col}; + my $colspan = ""; + + $colspan = " colspan=$cols" if ($cols > 1); + write_html($handle, <<END_OF_HTML); + <td class="tableHead"$colspan>$heading</td> +END_OF_HTML + } + write_html($handle, <<END_OF_HTML); + </tr> +END_OF_HTML +} + + +# write_file_table_entry(handle, base_dir, filename, page_link, +# ([ found, hit, med_limit, hi_limit, graph ], ..) +# +# Write an entry of the file table. +# + +sub write_file_table_entry(*$$$@) +{ + my ($handle, $base_dir, $filename, $page_link, @entries) = @_; + my $file_code; + my $entry; + + # Add link to source if provided + if (defined($page_link) && $page_link ne "") { + $file_code = "<a href=\"$page_link\">$filename</a>"; + } else { + $file_code = $filename; + } + + # First column: filename + write_html($handle, <<END_OF_HTML); + <tr> + <td class="coverFile">$file_code</td> +END_OF_HTML + # Columns as defined + foreach $entry (@entries) { + my ($found, $hit, $med, $hi, $graph) = @{$entry}; + my $bar_graph; + my $class; + my $rate; + + # Generate bar graph if requested + if ($graph) { + $bar_graph = get_bar_graph_code($base_dir, $found, + $hit); + write_html($handle, <<END_OF_HTML); + <td class="coverBar" align="center"> + $bar_graph + </td> +END_OF_HTML + } + # Get rate color and text + if ($found == 0) { + $rate = "-"; + $class = "Hi"; + } else { + $rate = sprintf("%.1f %%", $hit * 100 / $found); + $class = $rate_name[classify_rate($found, $hit, + $med, $hi)]; + } + write_html($handle, <<END_OF_HTML); + <td class="coverPer$class">$rate</td> + <td class="coverNum$class">$hit / $found</td> +END_OF_HTML + } + # End of row + write_html($handle, <<END_OF_HTML); + </tr> +END_OF_HTML +} + + +# +# write_file_table_detail_entry(filehandle, test_name, ([found, hit], ...)) +# +# Write entry for detail section in file table. +# + +sub write_file_table_detail_entry(*$@) +{ + my ($handle, $test, @entries) = @_; + my $entry; + + if ($test eq "") { + $test = "<span style=\"font-style:italic\"><unnamed></span>"; + } elsif ($test =~ /^(.*),diff$/) { + $test = $1." (converted)"; + } + # Testname + write_html($handle, <<END_OF_HTML); + <tr> + <td class="testName" colspan=2>$test</td> +END_OF_HTML + # Test data + foreach $entry (@entries) { + my ($found, $hit) = @{$entry}; + my $rate = "-"; + + if ($found > 0) { + $rate = sprintf("%.1f %%", $hit * 100 / $found); + } + write_html($handle, <<END_OF_HTML); + <td class="testPer">$rate</td> + <td class="testNum">$hit / $found</td> +END_OF_HTML + } + + write_html($handle, <<END_OF_HTML); + </tr> + +END_OF_HTML + + # ************************************************************* +} + + +# +# write_file_table_epilog(filehandle) +# +# Write end of file table HTML code. +# + +sub write_file_table_epilog(*) +{ + # ************************************************************* + + write_html($_[0], <<END_OF_HTML) + </table> + </center> + <br> + +END_OF_HTML + ; + + # ************************************************************* +} + + +# +# write_test_table_prolog(filehandle, table_heading) +# +# Write heading for test case description table. +# + +sub write_test_table_prolog(*$) +{ + # ************************************************************* + + write_html($_[0], <<END_OF_HTML) + <center> + <table width="80%" cellpadding=2 cellspacing=1 border=0> + + <tr> + <td><br></td> + </tr> + + <tr> + <td class="tableHead">$_[1]</td> + </tr> + + <tr> + <td class="testDescription"> + <dl> +END_OF_HTML + ; + + # ************************************************************* +} + + +# +# write_test_table_entry(filehandle, test_name, test_description) +# +# Write entry for the test table. +# + +sub write_test_table_entry(*$$) +{ + # ************************************************************* + + write_html($_[0], <<END_OF_HTML) + <dt>$_[1]<a name="$_[1]"> </a></dt> + <dd>$_[2]<br><br></dd> +END_OF_HTML + ; + + # ************************************************************* +} + + +# +# write_test_table_epilog(filehandle) +# +# Write end of test description table HTML code. +# + +sub write_test_table_epilog(*) +{ + # ************************************************************* + + write_html($_[0], <<END_OF_HTML) + </dl> + </td> + </tr> + </table> + </center> + <br> + +END_OF_HTML + ; + + # ************************************************************* +} + + +sub fmt_centered($$) +{ + my ($width, $text) = @_; + my $w0 = length($text); + my $w1 = int(($width - $w0) / 2); + my $w2 = $width - $w0 - $w1; + + return (" "x$w1).$text.(" "x$w2); +} + + +# +# write_source_prolog(filehandle) +# +# Write start of source code table. +# + +sub write_source_prolog(*) +{ + my $lineno_heading = " "; + my $branch_heading = ""; + my $line_heading = fmt_centered($line_field_width, "Line data"); + my $source_heading = " Source code"; + + if ($br_coverage) { + $branch_heading = fmt_centered($br_field_width, "Branch data"). + " "; + } + # ************************************************************* + + write_html($_[0], <<END_OF_HTML) + <table cellpadding=0 cellspacing=0 border=0> + <tr> + <td><br></td> + </tr> + <tr> + <td> +<pre class="sourceHeading">${lineno_heading}${branch_heading}${line_heading} ${source_heading}</pre> +<pre class="source"> +END_OF_HTML + ; + + # ************************************************************* +} + + +# +# get_branch_blocks(brdata) +# +# Group branches that belong to the same basic block. +# +# Returns: [block1, block2, ...] +# block: [branch1, branch2, ...] +# branch: [block_num, branch_num, taken_count, text_length, open, close] +# + +sub get_branch_blocks($) +{ + my ($brdata) = @_; + my $last_block_num; + my $block = []; + my @blocks; + my $i; + my $num = br_ivec_len($brdata); + + # Group branches + for ($i = 0; $i < $num; $i++) { + my ($block_num, $branch, $taken) = br_ivec_get($brdata, $i); + my $br; + + if (defined($last_block_num) && $block_num != $last_block_num) { + push(@blocks, $block); + $block = []; + } + $br = [$block_num, $branch, $taken, 3, 0, 0]; + push(@{$block}, $br); + $last_block_num = $block_num; + } + push(@blocks, $block) if (scalar(@{$block}) > 0); + + # Add braces to first and last branch in group + foreach $block (@blocks) { + $block->[0]->[$BR_OPEN] = 1; + $block->[0]->[$BR_LEN]++; + $block->[scalar(@{$block}) - 1]->[$BR_CLOSE] = 1; + $block->[scalar(@{$block}) - 1]->[$BR_LEN]++; + } + + return @blocks; +} + +# +# get_block_len(block) +# +# Calculate total text length of all branches in a block of branches. +# + +sub get_block_len($) +{ + my ($block) = @_; + my $len = 0; + my $branch; + + foreach $branch (@{$block}) { + $len += $branch->[$BR_LEN]; + } + + return $len; +} + + +# +# get_branch_html(brdata) +# +# Return a list of HTML lines which represent the specified branch coverage +# data in source code view. +# + +sub get_branch_html($) +{ + my ($brdata) = @_; + my @blocks = get_branch_blocks($brdata); + my $block; + my $branch; + my $line_len = 0; + my $line = []; # [branch2|" ", branch|" ", ...] + my @lines; # [line1, line2, ...] + my @result; + + # Distribute blocks to lines + foreach $block (@blocks) { + my $block_len = get_block_len($block); + + # Does this block fit into the current line? + if ($line_len + $block_len <= $br_field_width) { + # Add it + $line_len += $block_len; + push(@{$line}, @{$block}); + next; + } elsif ($block_len <= $br_field_width) { + # It would fit if the line was empty - add it to new + # line + push(@lines, $line); + $line_len = $block_len; + $line = [ @{$block} ]; + next; + } + # Split the block into several lines + foreach $branch (@{$block}) { + if ($line_len + $branch->[$BR_LEN] >= $br_field_width) { + # Start a new line + if (($line_len + 1 <= $br_field_width) && + scalar(@{$line}) > 0 && + !$line->[scalar(@$line) - 1]->[$BR_CLOSE]) { + # Try to align branch symbols to be in + # one # row + push(@{$line}, " "); + } + push(@lines, $line); + $line_len = 0; + $line = []; + } + push(@{$line}, $branch); + $line_len += $branch->[$BR_LEN]; + } + } + push(@lines, $line); + + # Convert to HTML + foreach $line (@lines) { + my $current = ""; + my $current_len = 0; + + foreach $branch (@$line) { + # Skip alignment space + if ($branch eq " ") { + $current .= " "; + $current_len++; + next; + } + + my ($block_num, $br_num, $taken, $len, $open, $close) = + @{$branch}; + my $class; + my $title; + my $text; + + if ($taken eq '-') { + $class = "branchNoExec"; + $text = " # "; + $title = "Branch $br_num was not executed"; + } elsif ($taken == 0) { + $class = "branchNoCov"; + $text = " - "; + $title = "Branch $br_num was not taken"; + } else { + $class = "branchCov"; + $text = " + "; + $title = "Branch $br_num was taken $taken ". + "time"; + $title .= "s" if ($taken > 1); + } + $current .= "[" if ($open); + $current .= "<span class=\"$class\" title=\"$title\">"; + $current .= $text."</span>"; + $current .= "]" if ($close); + $current_len += $len; + } + + # Right-align result text + if ($current_len < $br_field_width) { + $current = (" "x($br_field_width - $current_len)). + $current; + } + push(@result, $current); + } + + return @result; +} + + +# +# format_count(count, width) +# +# Return a right-aligned representation of count that fits in width characters. +# + +sub format_count($$) +{ + my ($count, $width) = @_; + my $result; + my $exp; + + $result = sprintf("%*.0f", $width, $count); + while (length($result) > $width) { + last if ($count < 10); + $exp++; + $count = int($count/10); + $result = sprintf("%*s", $width, ">$count*10^$exp"); + } + return $result; +} + +# +# write_source_line(filehandle, line_num, source, hit_count, converted, +# brdata, add_anchor) +# +# Write formatted source code line. Return a line in a format as needed +# by gen_png() +# + +sub write_source_line(*$$$$$$) +{ + my ($handle, $line, $source, $count, $converted, $brdata, + $add_anchor) = @_; + my $source_format; + my $count_format; + my $result; + my $anchor_start = ""; + my $anchor_end = ""; + my $count_field_width = $line_field_width - 1; + my @br_html; + my $html; + + # Get branch HTML data for this line + @br_html = get_branch_html($brdata) if ($br_coverage); + + if (!defined($count)) { + $result = ""; + $source_format = ""; + $count_format = " "x$count_field_width; + } + elsif ($count == 0) { + $result = $count; + $source_format = '<span class="lineNoCov">'; + $count_format = format_count($count, $count_field_width); + } + elsif ($converted && defined($highlight)) { + $result = "*".$count; + $source_format = '<span class="lineDiffCov">'; + $count_format = format_count($count, $count_field_width); + } + else { + $result = $count; + $source_format = '<span class="lineCov">'; + $count_format = format_count($count, $count_field_width); + } + $result .= ":".$source; + + # Write out a line number navigation anchor every $nav_resolution + # lines if necessary + if ($add_anchor) + { + $anchor_start = "<a name=\"$_[1]\">"; + $anchor_end = "</a>"; + } + + + # ************************************************************* + + $html = $anchor_start; + $html .= "<span class=\"lineNum\">".sprintf("%8d", $line)." </span>"; + $html .= shift(@br_html).":" if ($br_coverage); + $html .= "$source_format$count_format : "; + $html .= escape_html($source); + $html .= "</span>" if ($source_format); + $html .= $anchor_end."\n"; + + write_html($handle, $html); + + if ($br_coverage) { + # Add lines for overlong branch information + foreach (@br_html) { + write_html($handle, "<span class=\"lineNum\">". + " </span>$_\n"); + } + } + # ************************************************************* + + return($result); +} + + +# +# write_source_epilog(filehandle) +# +# Write end of source code table. +# + +sub write_source_epilog(*) +{ + # ************************************************************* + + write_html($_[0], <<END_OF_HTML) + </pre> + </td> + </tr> + </table> + <br> + +END_OF_HTML + ; + + # ************************************************************* +} + + +# +# write_html_epilog(filehandle, base_dir[, break_frames]) +# +# Write HTML page footer to FILEHANDLE. BREAK_FRAMES should be set when +# this page is embedded in a frameset, clicking the URL link will then +# break this frameset. +# + +sub write_html_epilog(*$;$) +{ + my $basedir = $_[1]; + my $break_code = ""; + my $epilog; + + if (defined($_[2])) + { + $break_code = " target=\"_parent\""; + } + + # ************************************************************* + + write_html($_[0], <<END_OF_HTML) + <table width="100%" border=0 cellspacing=0 cellpadding=0> + <tr><td class="ruler"><img src="$_[1]glass.png" width=3 height=3 alt=""></td></tr> + <tr><td class="versionInfo">Generated by: <a href="$lcov_url"$break_code>$lcov_version</a></td></tr> + </table> + <br> +END_OF_HTML + ; + + $epilog = $html_epilog; + $epilog =~ s/\@basedir\@/$basedir/g; + + write_html($_[0], $epilog); +} + + +# +# write_frameset(filehandle, basedir, basename, pagetitle) +# +# + +sub write_frameset(*$$$) +{ + my $frame_width = $overview_width + 40; + + # ************************************************************* + + write_html($_[0], <<END_OF_HTML) + <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Frameset//EN"> + + <html lang="en"> + + <head> + <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"> + <title>$_[3]</title> + <link rel="stylesheet" type="text/css" href="$_[1]gcov.css"> + </head> + + <frameset cols="$frame_width,*"> + <frame src="$_[2].gcov.overview.$html_ext" name="overview"> + <frame src="$_[2].gcov.$html_ext" name="source"> + <noframes> + <center>Frames not supported by your browser!<br></center> + </noframes> + </frameset> + + </html> +END_OF_HTML + ; + + # ************************************************************* +} + + +# +# sub write_overview_line(filehandle, basename, line, link) +# +# + +sub write_overview_line(*$$$) +{ + my $y1 = $_[2] - 1; + my $y2 = $y1 + $nav_resolution - 1; + my $x2 = $overview_width - 1; + + # ************************************************************* + + write_html($_[0], <<END_OF_HTML) + <area shape="rect" coords="0,$y1,$x2,$y2" href="$_[1].gcov.$html_ext#$_[3]" target="source" alt="overview"> +END_OF_HTML + ; + + # ************************************************************* +} + + +# +# write_overview(filehandle, basedir, basename, pagetitle, lines) +# +# + +sub write_overview(*$$$$) +{ + my $index; + my $max_line = $_[4] - 1; + my $offset; + + # ************************************************************* + + write_html($_[0], <<END_OF_HTML) + <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> + + <html lang="en"> + + <head> + <title>$_[3]</title> + <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"> + <link rel="stylesheet" type="text/css" href="$_[1]gcov.css"> + </head> + + <body> + <map name="overview"> +END_OF_HTML + ; + + # ************************************************************* + + # Make $offset the next higher multiple of $nav_resolution + $offset = ($nav_offset + $nav_resolution - 1) / $nav_resolution; + $offset = sprintf("%d", $offset ) * $nav_resolution; + + # Create image map for overview image + for ($index = 1; $index <= $_[4]; $index += $nav_resolution) + { + # Enforce nav_offset + if ($index < $offset + 1) + { + write_overview_line($_[0], $_[2], $index, 1); + } + else + { + write_overview_line($_[0], $_[2], $index, $index - $offset); + } + } + + # ************************************************************* + + write_html($_[0], <<END_OF_HTML) + </map> + + <center> + <a href="$_[2].gcov.$html_ext#top" target="source">Top</a><br><br> + <img src="$_[2].gcov.png" width=$overview_width height=$max_line alt="Overview" border=0 usemap="#overview"> + </center> + </body> + </html> +END_OF_HTML + ; + + # ************************************************************* +} + + +# format_rate(found, hit) +# +# Return formatted percent string for coverage rate. +# + +sub format_rate($$) +{ + return $_[0] == 0 ? "-" : sprintf("%.1f", $_[1] * 100 / $_[0])." %"; +} + + +sub max($$) +{ + my ($a, $b) = @_; + + return $a if ($a > $b); + return $b; +} + + +# +# write_header(filehandle, type, trunc_file_name, rel_file_name, lines_found, +# lines_hit, funcs_found, funcs_hit, sort_type) +# +# Write a complete standard page header. TYPE may be (0, 1, 2, 3, 4) +# corresponding to (directory view header, file view header, source view +# header, test case description header, function view header) +# + +sub write_header(*$$$$$$$$$$) +{ + local *HTML_HANDLE = $_[0]; + my $type = $_[1]; + my $trunc_name = $_[2]; + my $rel_filename = $_[3]; + my $lines_found = $_[4]; + my $lines_hit = $_[5]; + my $fn_found = $_[6]; + my $fn_hit = $_[7]; + my $br_found = $_[8]; + my $br_hit = $_[9]; + my $sort_type = $_[10]; + my $base_dir; + my $view; + my $test; + my $base_name; + my $style; + my $rate; + my @row_left; + my @row_right; + my $num_rows; + my $i; + + $base_name = basename($rel_filename); + + # Prepare text for "current view" field + if ($type == $HDR_DIR) + { + # Main overview + $base_dir = ""; + $view = $overview_title; + } + elsif ($type == $HDR_FILE) + { + # Directory overview + $base_dir = get_relative_base_path($rel_filename); + $view = "<a href=\"$base_dir"."index.$html_ext\">". + "$overview_title</a> - $trunc_name"; + } + elsif ($type == $HDR_SOURCE || $type == $HDR_FUNC) + { + # File view + my $dir_name = dirname($rel_filename); + + $base_dir = get_relative_base_path($dir_name); + if ($frames) + { + # Need to break frameset when clicking any of these + # links + $view = "<a href=\"$base_dir"."index.$html_ext\" ". + "target=\"_parent\">$overview_title</a> - ". + "<a href=\"index.$html_ext\" target=\"_parent\">". + "$dir_name</a> - $base_name"; + } + else + { + $view = "<a href=\"$base_dir"."index.$html_ext\">". + "$overview_title</a> - ". + "<a href=\"index.$html_ext\">". + "$dir_name</a> - $base_name"; + } + + # Add function suffix + if ($func_coverage) { + $view .= "<span style=\"font-size: 80%;\">"; + if ($type == $HDR_SOURCE) { + $view .= " (source / <a href=\"$base_name.func.$html_ext\">functions</a>)"; + } elsif ($type == $HDR_FUNC) { + $view .= " (<a href=\"$base_name.gcov.$html_ext\">source</a> / functions)"; + } + $view .= "</span>"; + } + } + elsif ($type == $HDR_TESTDESC) + { + # Test description header + $base_dir = ""; + $view = "<a href=\"$base_dir"."index.$html_ext\">". + "$overview_title</a> - test case descriptions"; + } + + # Prepare text for "test" field + $test = escape_html($test_title); + + # Append link to test description page if available + if (%test_description && ($type != $HDR_TESTDESC)) + { + if ($frames && ($type == $HDR_SOURCE || $type == $HDR_FUNC)) + { + # Need to break frameset when clicking this link + $test .= " ( <span style=\"font-size:80%;\">". + "<a href=\"$base_dir". + "descriptions.$html_ext\" target=\"_parent\">". + "view descriptions</a></span> )"; + } + else + { + $test .= " ( <span style=\"font-size:80%;\">". + "<a href=\"$base_dir". + "descriptions.$html_ext\">". + "view descriptions</a></span> )"; + } + } + + # Write header + write_header_prolog(*HTML_HANDLE, $base_dir); + + # Left row + push(@row_left, [[ "10%", "headerItem", "Current view:" ], + [ "35%", "headerValue", $view ]]); + push(@row_left, [[undef, "headerItem", "Test:"], + [undef, "headerValue", $test]]); + push(@row_left, [[undef, "headerItem", "Date:"], + [undef, "headerValue", $date]]); + + # Right row + if ($legend && ($type == $HDR_SOURCE || $type == $HDR_FUNC)) { + my $text = <<END_OF_HTML; + Lines: + <span class="coverLegendCov">hit</span> + <span class="coverLegendNoCov">not hit</span> +END_OF_HTML + if ($br_coverage) { + $text .= <<END_OF_HTML; + | Branches: + <span class="coverLegendCov">+</span> taken + <span class="coverLegendNoCov">-</span> not taken + <span class="coverLegendNoCov">#</span> not executed +END_OF_HTML + } + push(@row_left, [[undef, "headerItem", "Legend:"], + [undef, "headerValueLeg", $text]]); + } elsif ($legend && ($type != $HDR_TESTDESC)) { + my $text = <<END_OF_HTML; + Rating: + <span class="coverLegendCovLo" title="Coverage rates below $med_limit % are classified as low">low: < $med_limit %</span> + <span class="coverLegendCovMed" title="Coverage rates between $med_limit % and $hi_limit % are classified as medium">medium: >= $med_limit %</span> + <span class="coverLegendCovHi" title="Coverage rates of $hi_limit % and more are classified as high">high: >= $hi_limit %</span> +END_OF_HTML + push(@row_left, [[undef, "headerItem", "Legend:"], + [undef, "headerValueLeg", $text]]); + } + if ($type == $HDR_TESTDESC) { + push(@row_right, [[ "55%" ]]); + } else { + push(@row_right, [["15%", undef, undef ], + ["10%", "headerCovTableHead", "Hit" ], + ["10%", "headerCovTableHead", "Total" ], + ["15%", "headerCovTableHead", "Coverage"]]); + } + # Line coverage + $style = $rate_name[classify_rate($lines_found, $lines_hit, + $med_limit, $hi_limit)]; + $rate = format_rate($lines_found, $lines_hit); + push(@row_right, [[undef, "headerItem", "Lines:"], + [undef, "headerCovTableEntry", $lines_hit], + [undef, "headerCovTableEntry", $lines_found], + [undef, "headerCovTableEntry$style", $rate]]) + if ($type != $HDR_TESTDESC); + # Function coverage + if ($func_coverage) { + $style = $rate_name[classify_rate($fn_found, $fn_hit, + $fn_med_limit, $fn_hi_limit)]; + $rate = format_rate($fn_found, $fn_hit); + push(@row_right, [[undef, "headerItem", "Functions:"], + [undef, "headerCovTableEntry", $fn_hit], + [undef, "headerCovTableEntry", $fn_found], + [undef, "headerCovTableEntry$style", $rate]]) + if ($type != $HDR_TESTDESC); + } + # Branch coverage + if ($br_coverage) { + $style = $rate_name[classify_rate($br_found, $br_hit, + $br_med_limit, $br_hi_limit)]; + $rate = format_rate($br_found, $br_hit); + push(@row_right, [[undef, "headerItem", "Branches:"], + [undef, "headerCovTableEntry", $br_hit], + [undef, "headerCovTableEntry", $br_found], + [undef, "headerCovTableEntry$style", $rate]]) + if ($type != $HDR_TESTDESC); + } + + # Print rows + $num_rows = max(scalar(@row_left), scalar(@row_right)); + for ($i = 0; $i < $num_rows; $i++) { + my $left = $row_left[$i]; + my $right = $row_right[$i]; + + if (!defined($left)) { + $left = [[undef, undef, undef], [undef, undef, undef]]; + } + if (!defined($right)) { + $right = []; + } + write_header_line(*HTML_HANDLE, @{$left}, + [ $i == 0 ? "5%" : undef, undef, undef], + @{$right}); + } + + # Fourth line + write_header_epilog(*HTML_HANDLE, $base_dir); +} + + +# +# get_sorted_keys(hash_ref, sort_type) +# + +sub get_sorted_keys($$) +{ + my ($hash, $type) = @_; + + if ($type == $SORT_FILE) { + # Sort by name + return sort(keys(%{$hash})); + } elsif ($type == $SORT_LINE) { + # Sort by line coverage + return sort({$hash->{$a}[7] <=> $hash->{$b}[7]} keys(%{$hash})); + } elsif ($type == $SORT_FUNC) { + # Sort by function coverage; + return sort({$hash->{$a}[8] <=> $hash->{$b}[8]} keys(%{$hash})); + } elsif ($type == $SORT_BRANCH) { + # Sort by br coverage; + return sort({$hash->{$a}[9] <=> $hash->{$b}[9]} keys(%{$hash})); + } +} + +sub get_sort_code($$$) +{ + my ($link, $alt, $base) = @_; + my $png; + my $link_start; + my $link_end; + + if (!defined($link)) { + $png = "glass.png"; + $link_start = ""; + $link_end = ""; + } else { + $png = "updown.png"; + $link_start = '<a href="'.$link.'">'; + $link_end = "</a>"; + } + + return ' <span class="tableHeadSort">'.$link_start. + '<img src="'.$base.$png.'" width=10 height=14 '. + 'alt="'.$alt.'" title="'.$alt.'" border=0>'.$link_end.'</span>'; +} + +sub get_file_code($$$$) +{ + my ($type, $text, $sort_button, $base) = @_; + my $result = $text; + my $link; + + if ($sort_button) { + if ($type == $HEAD_NO_DETAIL) { + $link = "index.$html_ext"; + } else { + $link = "index-detail.$html_ext"; + } + } + $result .= get_sort_code($link, "Sort by name", $base); + + return $result; +} + +sub get_line_code($$$$$) +{ + my ($type, $sort_type, $text, $sort_button, $base) = @_; + my $result = $text; + my $sort_link; + + if ($type == $HEAD_NO_DETAIL) { + # Just text + if ($sort_button) { + $sort_link = "index-sort-l.$html_ext"; + } + } elsif ($type == $HEAD_DETAIL_HIDDEN) { + # Text + link to detail view + $result .= ' ( <a class="detail" href="index-detail'. + $fileview_sortname[$sort_type].'.'.$html_ext. + '">show details</a> )'; + if ($sort_button) { + $sort_link = "index-sort-l.$html_ext"; + } + } else { + # Text + link to standard view + $result .= ' ( <a class="detail" href="index'. + $fileview_sortname[$sort_type].'.'.$html_ext. + '">hide details</a> )'; + if ($sort_button) { + $sort_link = "index-detail-sort-l.$html_ext"; + } + } + # Add sort button + $result .= get_sort_code($sort_link, "Sort by line coverage", $base); + + return $result; +} + +sub get_func_code($$$$) +{ + my ($type, $text, $sort_button, $base) = @_; + my $result = $text; + my $link; + + if ($sort_button) { + if ($type == $HEAD_NO_DETAIL) { + $link = "index-sort-f.$html_ext"; + } else { + $link = "index-detail-sort-f.$html_ext"; + } + } + $result .= get_sort_code($link, "Sort by function coverage", $base); + return $result; +} + +sub get_br_code($$$$) +{ + my ($type, $text, $sort_button, $base) = @_; + my $result = $text; + my $link; + + if ($sort_button) { + if ($type == $HEAD_NO_DETAIL) { + $link = "index-sort-b.$html_ext"; + } else { + $link = "index-detail-sort-b.$html_ext"; + } + } + $result .= get_sort_code($link, "Sort by branch coverage", $base); + return $result; +} + +# +# write_file_table(filehandle, base_dir, overview, testhash, testfnchash, +# testbrhash, fileview, sort_type) +# +# Write a complete file table. OVERVIEW is a reference to a hash containing +# the following mapping: +# +# filename -> "lines_found,lines_hit,funcs_found,funcs_hit,page_link, +# func_link" +# +# TESTHASH is a reference to the following hash: +# +# filename -> \%testdata +# %testdata: name of test affecting this file -> \%testcount +# %testcount: line number -> execution count for a single test +# +# Heading of first column is "Filename" if FILEVIEW is true, "Directory name" +# otherwise. +# + +sub write_file_table(*$$$$$$$) +{ + local *HTML_HANDLE = $_[0]; + my $base_dir = $_[1]; + my $overview = $_[2]; + my $testhash = $_[3]; + my $testfnchash = $_[4]; + my $testbrhash = $_[5]; + my $fileview = $_[6]; + my $sort_type = $_[7]; + my $filename; + my $bar_graph; + my $hit; + my $found; + my $fn_found; + my $fn_hit; + my $br_found; + my $br_hit; + my $page_link; + my $testname; + my $testdata; + my $testfncdata; + my $testbrdata; + my %affecting_tests; + my $line_code = ""; + my $func_code; + my $br_code; + my $file_code; + my @head_columns; + + # Determine HTML code for column headings + if (($base_dir ne "") && $show_details) + { + my $detailed = keys(%{$testhash}); + + $file_code = get_file_code($detailed ? $HEAD_DETAIL_HIDDEN : + $HEAD_NO_DETAIL, + $fileview ? "Filename" : "Directory", + $sort && $sort_type != $SORT_FILE, + $base_dir); + $line_code = get_line_code($detailed ? $HEAD_DETAIL_SHOWN : + $HEAD_DETAIL_HIDDEN, + $sort_type, + "Line Coverage", + $sort && $sort_type != $SORT_LINE, + $base_dir); + $func_code = get_func_code($detailed ? $HEAD_DETAIL_HIDDEN : + $HEAD_NO_DETAIL, + "Functions", + $sort && $sort_type != $SORT_FUNC, + $base_dir); + $br_code = get_br_code($detailed ? $HEAD_DETAIL_HIDDEN : + $HEAD_NO_DETAIL, + "Branches", + $sort && $sort_type != $SORT_BRANCH, + $base_dir); + } else { + $file_code = get_file_code($HEAD_NO_DETAIL, + $fileview ? "Filename" : "Directory", + $sort && $sort_type != $SORT_FILE, + $base_dir); + $line_code = get_line_code($HEAD_NO_DETAIL, $sort_type, "Line Coverage", + $sort && $sort_type != $SORT_LINE, + $base_dir); + $func_code = get_func_code($HEAD_NO_DETAIL, "Functions", + $sort && $sort_type != $SORT_FUNC, + $base_dir); + $br_code = get_br_code($HEAD_NO_DETAIL, "Branches", + $sort && $sort_type != $SORT_BRANCH, + $base_dir); + } + push(@head_columns, [ $line_code, 3 ]); + push(@head_columns, [ $func_code, 2]) if ($func_coverage); + push(@head_columns, [ $br_code, 2]) if ($br_coverage); + + write_file_table_prolog(*HTML_HANDLE, $file_code, @head_columns); + + foreach $filename (get_sorted_keys($overview, $sort_type)) + { + my @columns; + ($found, $hit, $fn_found, $fn_hit, $br_found, $br_hit, + $page_link) = @{$overview->{$filename}}; + + # Line coverage + push(@columns, [$found, $hit, $med_limit, $hi_limit, 1]); + # Function coverage + if ($func_coverage) { + push(@columns, [$fn_found, $fn_hit, $fn_med_limit, + $fn_hi_limit, 0]); + } + # Branch coverage + if ($br_coverage) { + push(@columns, [$br_found, $br_hit, $br_med_limit, + $br_hi_limit, 0]); + } + write_file_table_entry(*HTML_HANDLE, $base_dir, $filename, + $page_link, @columns); + + $testdata = $testhash->{$filename}; + $testfncdata = $testfnchash->{$filename}; + $testbrdata = $testbrhash->{$filename}; + + # Check whether we should write test specific coverage + # as well + if (!($show_details && $testdata)) { next; } + + # Filter out those tests that actually affect this file + %affecting_tests = %{ get_affecting_tests($testdata, + $testfncdata, $testbrdata) }; + + # Does any of the tests affect this file at all? + if (!%affecting_tests) { next; } + + foreach $testname (keys(%affecting_tests)) + { + my @results; + ($found, $hit, $fn_found, $fn_hit, $br_found, $br_hit) = + split(",", $affecting_tests{$testname}); + + # Insert link to description of available + if ($test_description{$testname}) + { + $testname = "<a href=\"$base_dir". + "descriptions.$html_ext#$testname\">". + "$testname</a>"; + } + + push(@results, [$found, $hit]); + push(@results, [$fn_found, $fn_hit]) if ($func_coverage); + push(@results, [$br_found, $br_hit]) if ($br_coverage); + write_file_table_detail_entry(*HTML_HANDLE, $testname, + @results); + } + } + + write_file_table_epilog(*HTML_HANDLE); +} + + +# +# get_found_and_hit(hash) +# +# Return the count for entries (found) and entries with an execution count +# greater than zero (hit) in a hash (linenumber -> execution count) as +# a list (found, hit) +# + +sub get_found_and_hit($) +{ + my %hash = %{$_[0]}; + my $found = 0; + my $hit = 0; + + # Calculate sum + $found = 0; + $hit = 0; + + foreach (keys(%hash)) + { + $found++; + if ($hash{$_}>0) { $hit++; } + } + + return ($found, $hit); +} + + +# +# get_func_found_and_hit(sumfnccount) +# +# Return (f_found, f_hit) for sumfnccount +# + +sub get_func_found_and_hit($) +{ + my ($sumfnccount) = @_; + my $function; + my $fn_found; + my $fn_hit; + + $fn_found = scalar(keys(%{$sumfnccount})); + $fn_hit = 0; + foreach $function (keys(%{$sumfnccount})) { + if ($sumfnccount->{$function} > 0) { + $fn_hit++; + } + } + return ($fn_found, $fn_hit); +} + + +# +# br_taken_to_num(taken) +# +# Convert a branch taken value .info format to number format. +# + +sub br_taken_to_num($) +{ + my ($taken) = @_; + + return 0 if ($taken eq '-'); + return $taken + 1; +} + + +# +# br_num_to_taken(taken) +# +# Convert a branch taken value in number format to .info format. +# + +sub br_num_to_taken($) +{ + my ($taken) = @_; + + return '-' if ($taken == 0); + return $taken - 1; +} + + +# +# br_taken_add(taken1, taken2) +# +# Return the result of taken1 + taken2 for 'branch taken' values. +# + +sub br_taken_add($$) +{ + my ($t1, $t2) = @_; + + return $t1 if (!defined($t2)); + return $t2 if (!defined($t1)); + return $t1 if ($t2 eq '-'); + return $t2 if ($t1 eq '-'); + return $t1 + $t2; +} + + +# +# br_taken_sub(taken1, taken2) +# +# Return the result of taken1 - taken2 for 'branch taken' values. Return 0 +# if the result would become negative. +# + +sub br_taken_sub($$) +{ + my ($t1, $t2) = @_; + + return $t1 if (!defined($t2)); + return undef if (!defined($t1)); + return $t1 if ($t1 eq '-'); + return $t1 if ($t2 eq '-'); + return 0 if $t2 > $t1; + return $t1 - $t2; +} + + +# +# br_ivec_len(vector) +# +# Return the number of entries in the branch coverage vector. +# + +sub br_ivec_len($) +{ + my ($vec) = @_; + + return 0 if (!defined($vec)); + return (length($vec) * 8 / $BR_VEC_WIDTH) / $BR_VEC_ENTRIES; +} + + +# +# br_ivec_get(vector, number) +# +# Return an entry from the branch coverage vector. +# + +sub br_ivec_get($$) +{ + my ($vec, $num) = @_; + my $block; + my $branch; + my $taken; + my $offset = $num * $BR_VEC_ENTRIES; + + # Retrieve data from vector + $block = vec($vec, $offset + $BR_BLOCK, $BR_VEC_WIDTH); + $branch = vec($vec, $offset + $BR_BRANCH, $BR_VEC_WIDTH); + $taken = vec($vec, $offset + $BR_TAKEN, $BR_VEC_WIDTH); + + # Decode taken value from an integer + $taken = br_num_to_taken($taken); + + return ($block, $branch, $taken); +} + + +# +# br_ivec_push(vector, block, branch, taken) +# +# Add an entry to the branch coverage vector. If an entry with the same +# branch ID already exists, add the corresponding taken values. +# + +sub br_ivec_push($$$$) +{ + my ($vec, $block, $branch, $taken) = @_; + my $offset; + my $num = br_ivec_len($vec); + my $i; + + $vec = "" if (!defined($vec)); + + # Check if branch already exists in vector + for ($i = 0; $i < $num; $i++) { + my ($v_block, $v_branch, $v_taken) = br_ivec_get($vec, $i); + + next if ($v_block != $block || $v_branch != $branch); + + # Add taken counts + $taken = br_taken_add($taken, $v_taken); + last; + } + + $offset = $i * $BR_VEC_ENTRIES; + $taken = br_taken_to_num($taken); + + # Add to vector + vec($vec, $offset + $BR_BLOCK, $BR_VEC_WIDTH) = $block; + vec($vec, $offset + $BR_BRANCH, $BR_VEC_WIDTH) = $branch; + vec($vec, $offset + $BR_TAKEN, $BR_VEC_WIDTH) = $taken; + + return $vec; +} + + +# +# get_br_found_and_hit(sumbrcount) +# +# Return (br_found, br_hit) for sumbrcount +# + +sub get_br_found_and_hit($) +{ + my ($sumbrcount) = @_; + my $line; + my $br_found = 0; + my $br_hit = 0; + + foreach $line (keys(%{$sumbrcount})) { + my $brdata = $sumbrcount->{$line}; + my $i; + my $num = br_ivec_len($brdata); + + for ($i = 0; $i < $num; $i++) { + my $taken; + + (undef, undef, $taken) = br_ivec_get($brdata, $i); + + $br_found++; + $br_hit++ if ($taken ne "-" && $taken > 0); + } + } + + return ($br_found, $br_hit); +} + + +# +# get_affecting_tests(testdata, testfncdata, testbrdata) +# +# HASHREF contains a mapping filename -> (linenumber -> exec count). Return +# a hash containing mapping filename -> "lines found, lines hit" for each +# filename which has a nonzero hit count. +# + +sub get_affecting_tests($$$) +{ + my ($testdata, $testfncdata, $testbrdata) = @_; + my $testname; + my $testcount; + my $testfnccount; + my $testbrcount; + my %result; + my $found; + my $hit; + my $fn_found; + my $fn_hit; + my $br_found; + my $br_hit; + + foreach $testname (keys(%{$testdata})) + { + # Get (line number -> count) hash for this test case + $testcount = $testdata->{$testname}; + $testfnccount = $testfncdata->{$testname}; + $testbrcount = $testbrdata->{$testname}; + + # Calculate sum + ($found, $hit) = get_found_and_hit($testcount); + ($fn_found, $fn_hit) = get_func_found_and_hit($testfnccount); + ($br_found, $br_hit) = get_br_found_and_hit($testbrcount); + + if ($hit>0) + { + $result{$testname} = "$found,$hit,$fn_found,$fn_hit,". + "$br_found,$br_hit"; + } + } + + return(\%result); +} + + +sub get_hash_reverse($) +{ + my ($hash) = @_; + my %result; + + foreach (keys(%{$hash})) { + $result{$hash->{$_}} = $_; + } + + return \%result; +} + +# +# write_source(filehandle, source_filename, count_data, checksum_data, +# converted_data, func_data, sumbrcount) +# +# Write an HTML view of a source code file. Returns a list containing +# data as needed by gen_png(). +# +# Die on error. +# + +sub write_source($$$$$$$) +{ + local *HTML_HANDLE = $_[0]; + local *SOURCE_HANDLE; + my $source_filename = $_[1]; + my %count_data; + my $line_number; + my @result; + my $checkdata = $_[3]; + my $converted = $_[4]; + my $funcdata = $_[5]; + my $sumbrcount = $_[6]; + my $datafunc = get_hash_reverse($funcdata); + my $add_anchor; + + if ($_[2]) + { + %count_data = %{$_[2]}; + } + + open(SOURCE_HANDLE, "<".$source_filename) + or die("ERROR: cannot open $source_filename for reading!\n"); + + write_source_prolog(*HTML_HANDLE); + + for ($line_number = 1; <SOURCE_HANDLE> ; $line_number++) + { + chomp($_); + + # Also remove CR from line-end + s/\015$//; + + # Source code matches coverage data? + if (defined($checkdata->{$line_number}) && + ($checkdata->{$line_number} ne md5_base64($_))) + { + die("ERROR: checksum mismatch at $source_filename:". + "$line_number\n"); + } + + $add_anchor = 0; + if ($frames) { + if (($line_number - 1) % $nav_resolution == 0) { + $add_anchor = 1; + } + } + if ($func_coverage) { + if ($line_number == 1) { + $add_anchor = 1; + } elsif (defined($datafunc->{$line_number + + $func_offset})) { + $add_anchor = 1; + } + } + push (@result, + write_source_line(HTML_HANDLE, $line_number, + $_, $count_data{$line_number}, + $converted->{$line_number}, + $sumbrcount->{$line_number}, $add_anchor)); + } + + close(SOURCE_HANDLE); + write_source_epilog(*HTML_HANDLE); + return(@result); +} + + +sub funcview_get_func_code($$$) +{ + my ($name, $base, $type) = @_; + my $result; + my $link; + + if ($sort && $type == 1) { + $link = "$name.func.$html_ext"; + } + $result = "Function Name"; + $result .= get_sort_code($link, "Sort by function name", $base); + + return $result; +} + +sub funcview_get_count_code($$$) +{ + my ($name, $base, $type) = @_; + my $result; + my $link; + + if ($sort && $type == 0) { + $link = "$name.func-sort-c.$html_ext"; + } + $result = "Hit count"; + $result .= get_sort_code($link, "Sort by hit count", $base); + + return $result; +} + +# +# funcview_get_sorted(funcdata, sumfncdata, sort_type) +# +# Depending on the value of sort_type, return a list of functions sorted +# by name (type 0) or by the associated call count (type 1). +# + +sub funcview_get_sorted($$$) +{ + my ($funcdata, $sumfncdata, $type) = @_; + + if ($type == 0) { + return sort(keys(%{$funcdata})); + } + return sort({$sumfncdata->{$b} <=> $sumfncdata->{$a}} + keys(%{$sumfncdata})); +} + +# +# write_function_table(filehandle, source_file, sumcount, funcdata, +# sumfnccount, testfncdata, sumbrcount, testbrdata, +# base_name, base_dir, sort_type) +# +# Write an HTML table listing all functions in a source file, including +# also function call counts and line coverages inside of each function. +# +# Die on error. +# + +sub write_function_table(*$$$$$$$$$$) +{ + local *HTML_HANDLE = $_[0]; + my $source = $_[1]; + my $sumcount = $_[2]; + my $funcdata = $_[3]; + my $sumfncdata = $_[4]; + my $testfncdata = $_[5]; + my $sumbrcount = $_[6]; + my $testbrdata = $_[7]; + my $name = $_[8]; + my $base = $_[9]; + my $type = $_[10]; + my $func; + my $func_code; + my $count_code; + + # Get HTML code for headings + $func_code = funcview_get_func_code($name, $base, $type); + $count_code = funcview_get_count_code($name, $base, $type); + write_html(*HTML_HANDLE, <<END_OF_HTML) + <center> + <table width="60%" cellpadding=1 cellspacing=1 border=0> + <tr><td><br></td></tr> + <tr> + <td width="80%" class="tableHead">$func_code</td> + <td width="20%" class="tableHead">$count_code</td> + </tr> +END_OF_HTML + ; + + # Get a sorted table + foreach $func (funcview_get_sorted($funcdata, $sumfncdata, $type)) { + if (!defined($funcdata->{$func})) + { + next; + } + + my $startline = $funcdata->{$func} - $func_offset; + my $name = $func; + my $count = $sumfncdata->{$name}; + my $countstyle; + + # Demangle C++ function names if requested + if ($demangle_cpp) { + $name = `c++filt "$name"`; + chomp($name); + } + # Escape any remaining special characters + $name = escape_html($name); + if ($startline < 1) { + $startline = 1; + } + if ($count == 0) { + $countstyle = "coverFnLo"; + } else { + $countstyle = "coverFnHi"; + } + + write_html(*HTML_HANDLE, <<END_OF_HTML) + <tr> + <td class="coverFn"><a href="$source#$startline">$name</a></td> + <td class="$countstyle">$count</td> + </tr> +END_OF_HTML + ; + } + write_html(*HTML_HANDLE, <<END_OF_HTML) + </table> + <br> + </center> +END_OF_HTML + ; +} + + +# +# info(printf_parameter) +# +# Use printf to write PRINTF_PARAMETER to stdout only when the $quiet flag +# is not set. +# + +sub info(@) +{ + if (!$quiet) + { + # Print info string + printf(@_); + } +} + + +# +# subtract_counts(data_ref, base_ref) +# + +sub subtract_counts($$) +{ + my %data = %{$_[0]}; + my %base = %{$_[1]}; + my $line; + my $data_count; + my $base_count; + my $hit = 0; + my $found = 0; + + foreach $line (keys(%data)) + { + $found++; + $data_count = $data{$line}; + $base_count = $base{$line}; + + if (defined($base_count)) + { + $data_count -= $base_count; + + # Make sure we don't get negative numbers + if ($data_count<0) { $data_count = 0; } + } + + $data{$line} = $data_count; + if ($data_count > 0) { $hit++; } + } + + return (\%data, $found, $hit); +} + + +# +# subtract_fnccounts(data, base) +# +# Subtract function call counts found in base from those in data. +# Return (data, f_found, f_hit). +# + +sub subtract_fnccounts($$) +{ + my %data; + my %base; + my $func; + my $data_count; + my $base_count; + my $fn_hit = 0; + my $fn_found = 0; + + %data = %{$_[0]} if (defined($_[0])); + %base = %{$_[1]} if (defined($_[1])); + foreach $func (keys(%data)) { + $fn_found++; + $data_count = $data{$func}; + $base_count = $base{$func}; + + if (defined($base_count)) { + $data_count -= $base_count; + + # Make sure we don't get negative numbers + if ($data_count < 0) { + $data_count = 0; + } + } + + $data{$func} = $data_count; + if ($data_count > 0) { + $fn_hit++; + } + } + + return (\%data, $fn_found, $fn_hit); +} + + +# +# apply_baseline(data_ref, baseline_ref) +# +# Subtract the execution counts found in the baseline hash referenced by +# BASELINE_REF from actual data in DATA_REF. +# + +sub apply_baseline($$) +{ + my %data_hash = %{$_[0]}; + my %base_hash = %{$_[1]}; + my $filename; + my $testname; + my $data; + my $data_testdata; + my $data_funcdata; + my $data_checkdata; + my $data_testfncdata; + my $data_testbrdata; + my $data_count; + my $data_testfnccount; + my $data_testbrcount; + my $base; + my $base_checkdata; + my $base_sumfnccount; + my $base_sumbrcount; + my $base_count; + my $sumcount; + my $sumfnccount; + my $sumbrcount; + my $found; + my $hit; + my $fn_found; + my $fn_hit; + my $br_found; + my $br_hit; + + foreach $filename (keys(%data_hash)) + { + # Get data set for data and baseline + $data = $data_hash{$filename}; + $base = $base_hash{$filename}; + + # Skip data entries for which no base entry exists + if (!defined($base)) + { + next; + } + + # Get set entries for data and baseline + ($data_testdata, undef, $data_funcdata, $data_checkdata, + $data_testfncdata, undef, $data_testbrdata) = + get_info_entry($data); + (undef, $base_count, undef, $base_checkdata, undef, + $base_sumfnccount, undef, $base_sumbrcount) = + get_info_entry($base); + + # Check for compatible checksums + merge_checksums($data_checkdata, $base_checkdata, $filename); + + # sumcount has to be calculated anew + $sumcount = {}; + $sumfnccount = {}; + $sumbrcount = {}; + + # For each test case, subtract test specific counts + foreach $testname (keys(%{$data_testdata})) + { + # Get counts of both data and baseline + $data_count = $data_testdata->{$testname}; + $data_testfnccount = $data_testfncdata->{$testname}; + $data_testbrcount = $data_testbrdata->{$testname}; + + ($data_count, undef, $hit) = + subtract_counts($data_count, $base_count); + ($data_testfnccount) = + subtract_fnccounts($data_testfnccount, + $base_sumfnccount); + ($data_testbrcount) = + combine_brcount($data_testbrcount, + $base_sumbrcount, $BR_SUB); + + + # Check whether this test case did hit any line at all + if ($hit > 0) + { + # Write back resulting hash + $data_testdata->{$testname} = $data_count; + $data_testfncdata->{$testname} = + $data_testfnccount; + $data_testbrdata->{$testname} = + $data_testbrcount; + } + else + { + # Delete test case which did not impact this + # file + delete($data_testdata->{$testname}); + delete($data_testfncdata->{$testname}); + delete($data_testbrdata->{$testname}); + } + + # Add counts to sum of counts + ($sumcount, $found, $hit) = + add_counts($sumcount, $data_count); + ($sumfnccount, $fn_found, $fn_hit) = + add_fnccount($sumfnccount, $data_testfnccount); + ($sumbrcount, $br_found, $br_hit) = + combine_brcount($sumbrcount, $data_testbrcount, + $BR_ADD); + } + + # Write back resulting entry + set_info_entry($data, $data_testdata, $sumcount, $data_funcdata, + $data_checkdata, $data_testfncdata, $sumfnccount, + $data_testbrdata, $sumbrcount, $found, $hit, + $fn_found, $fn_hit, $br_found, $br_hit); + + $data_hash{$filename} = $data; + } + + return (\%data_hash); +} + + +# +# remove_unused_descriptions() +# +# Removes all test descriptions from the global hash %test_description which +# are not present in %info_data. +# + +sub remove_unused_descriptions() +{ + my $filename; # The current filename + my %test_list; # Hash containing found test names + my $test_data; # Reference to hash test_name -> count_data + my $before; # Initial number of descriptions + my $after; # Remaining number of descriptions + + $before = scalar(keys(%test_description)); + + foreach $filename (keys(%info_data)) + { + ($test_data) = get_info_entry($info_data{$filename}); + foreach (keys(%{$test_data})) + { + $test_list{$_} = ""; + } + } + + # Remove descriptions for tests which are not in our list + foreach (keys(%test_description)) + { + if (!defined($test_list{$_})) + { + delete($test_description{$_}); + } + } + + $after = scalar(keys(%test_description)); + if ($after < $before) + { + info("Removed ".($before - $after). + " unused descriptions, $after remaining.\n"); + } +} + + +# +# apply_prefix(filename, prefix) +# +# If FILENAME begins with PREFIX, remove PREFIX from FILENAME and return +# resulting string, otherwise return FILENAME. +# + +sub apply_prefix($$) +{ + my $filename = $_[0]; + my $prefix = $_[1]; + + if (defined($prefix) && ($prefix ne "")) + { + if ($filename =~ /^\Q$prefix\E\/(.*)$/) + { + return substr($filename, length($prefix) + 1); + } + } + + return $filename; +} + + +# +# system_no_output(mode, parameters) +# +# Call an external program using PARAMETERS while suppressing depending on +# the value of MODE: +# +# MODE & 1: suppress STDOUT +# MODE & 2: suppress STDERR +# +# Return 0 on success, non-zero otherwise. +# + +sub system_no_output($@) +{ + my $mode = shift; + my $result; + local *OLD_STDERR; + local *OLD_STDOUT; + + # Save old stdout and stderr handles + ($mode & 1) && open(OLD_STDOUT, ">>&STDOUT"); + ($mode & 2) && open(OLD_STDERR, ">>&STDERR"); + + # Redirect to /dev/null + ($mode & 1) && open(STDOUT, ">/dev/null"); + ($mode & 2) && open(STDERR, ">/dev/null"); + + system(@_); + $result = $?; + + # Close redirected handles + ($mode & 1) && close(STDOUT); + ($mode & 2) && close(STDERR); + + # Restore old handles + ($mode & 1) && open(STDOUT, ">>&OLD_STDOUT"); + ($mode & 2) && open(STDERR, ">>&OLD_STDERR"); + + return $result; +} + + +# +# read_config(filename) +# +# Read configuration file FILENAME and return a reference to a hash containing +# all valid key=value pairs found. +# + +sub read_config($) +{ + my $filename = $_[0]; + my %result; + my $key; + my $value; + local *HANDLE; + + if (!open(HANDLE, "<$filename")) + { + warn("WARNING: cannot read configuration file $filename\n"); + return undef; + } + while (<HANDLE>) + { + chomp; + # Skip comments + s/#.*//; + # Remove leading blanks + s/^\s+//; + # Remove trailing blanks + s/\s+$//; + next unless length; + ($key, $value) = split(/\s*=\s*/, $_, 2); + if (defined($key) && defined($value)) + { + $result{$key} = $value; + } + else + { + warn("WARNING: malformed statement in line $. ". + "of configuration file $filename\n"); + } + } + close(HANDLE); + return \%result; +} + + +# +# apply_config(REF) +# +# REF is a reference to a hash containing the following mapping: +# +# key_string => var_ref +# +# where KEY_STRING is a keyword and VAR_REF is a reference to an associated +# variable. If the global configuration hash CONFIG contains a value for +# keyword KEY_STRING, VAR_REF will be assigned the value for that keyword. +# + +sub apply_config($) +{ + my $ref = $_[0]; + + foreach (keys(%{$ref})) + { + if (defined($config->{$_})) + { + ${$ref->{$_}} = $config->{$_}; + } + } +} + + +# +# get_html_prolog(FILENAME) +# +# If FILENAME is defined, return contents of file. Otherwise return default +# HTML prolog. Die on error. +# + +sub get_html_prolog($) +{ + my $filename = $_[0]; + my $result = ""; + + if (defined($filename)) + { + local *HANDLE; + + open(HANDLE, "<".$filename) + or die("ERROR: cannot open html prolog $filename!\n"); + while (<HANDLE>) + { + $result .= $_; + } + close(HANDLE); + } + else + { + $result = <<END_OF_HTML +<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> + +<html lang="en"> + +<head> + <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"> + <title>\@pagetitle\@</title> + <link rel="stylesheet" type="text/css" href="\@basedir\@gcov.css"> +</head> + +<body> + +END_OF_HTML + ; + } + + return $result; +} + + +# +# get_html_epilog(FILENAME) +# +# If FILENAME is defined, return contents of file. Otherwise return default +# HTML epilog. Die on error. +# +sub get_html_epilog($) +{ + my $filename = $_[0]; + my $result = ""; + + if (defined($filename)) + { + local *HANDLE; + + open(HANDLE, "<".$filename) + or die("ERROR: cannot open html epilog $filename!\n"); + while (<HANDLE>) + { + $result .= $_; + } + close(HANDLE); + } + else + { + $result = <<END_OF_HTML + +</body> +</html> +END_OF_HTML + ; + } + + return $result; + +} + +sub warn_handler($) +{ + my ($msg) = @_; + + warn("$tool_name: $msg"); +} + +sub die_handler($) +{ + my ($msg) = @_; + + die("$tool_name: $msg"); +} |