lcov-1.7 into third_party for code coverage on POSIX systems....

third_party/lcov/bin/genhtml

+#!/usr/bin/perl -w
+#
+#   Copyright (c) International Business Machines  Corp., 2002
+#
+#   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.7";
+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
+our $hi_limit   = 50;
+our $med_limit  = 15;
+
+# For function coverage
+our $fn_hi_limit        = 90;
+our $fn_med_limit       = 75;
+
+# 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 = "directory";
+
+# 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 split_filename($);
+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($);
+
+
+# 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_rable(*$$$);
+
+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_heading(*$$$);
+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 $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 @fileview_sortlist;
+our @fileview_sortname = ("", "-sort-l", "-sort-f");
+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;
+
+# 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 (-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_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_sort"                  => \$sort,
+                });
+}
+
+# Parse command line options
+if (!GetOptions("output-directory=s"    => \$output_directory,
+                "title=s"               => \$test_title,
+                "description-file=s"    => \$desc_filename,
+                "keep-descriptions"     => \$keep_descriptions,
+                "css-file=s"            => \$css_filename,
+                "baseline-file=s"       => \$base_filename,
+                "prefix=s"              => \$dir_prefix,
+                "num-spaces=i"          => \$tab_size,
+                "no-prefix"             => \$no_prefix,
+                "no-sourceview"         => \$no_sourceview,
+                "show-details"          => \$show_details,
+                "frames"                => \$frames,
+                "highlight"             => \$highlight,
+                "legend"                => \$legend,
+                "quiet"                 => \$quiet,
+                "help|h|?"              => \$help,
+                "version"               => \$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,
+                "sort"                  => \$sort,
+                "no-sort"               => \$no_sort,
+                ))
+{
+        print(STDERR "Use $tool_name --help to get usage information\n");
+        exit(1);
+} else {
+        # Merge options
+        if ($no_func_coverage) {
+                $func_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;
+}
+
+if ($sort) {
+        @funcview_sortlist = (0, 1);
+        if ($func_coverage) {
+                @fileview_sortlist = (0, 1, 2);
+        } else {
+                @fileview_sortlist = (0, 1);
+        }
+} else {
+        @fileview_sortlist = (0);
+        @funcview_sortlist = (0);
+}
+
+if ($frames)
+{
+        # Include genpng code needed for overview image generation
+        do("$tool_dir/genpng");
+}
+
+# Make sure output_directory exists, create it if necessary
+if ($output_directory)
+{
+        stat($output_directory);
+
+        if (! -e _)
+        {
+                system("mkdir", "-p", $output_directory)
+                        and die("ERROR: cannot create directory $_!\n");
+        }
+}
+
+# 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
+
+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
+
+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);
+}
+
+
+#
+# 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 $overall_found = 0;
+        my $overall_hit = 0;
+        my $total_fn_found = 0;
+        my $total_fn_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)
+                        = 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, $link_name,
+                                        get_rate($lines_found, $lines_hit),
+                                        get_rate($fn_found, $fn_hit)];
+                $overall_found  += $lines_found;
+                $overall_hit    += $lines_hit;
+                $total_fn_found += $fn_found;
+                $total_fn_hit   += $fn_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, \%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);
+        }
+
+        chdir($cwd);
+
+        info("Overall coverage rate:\n");
+
+        if ($overall_found == 0)
+        {
+                info("  lines......: no data found\n");
+                return;
+        }
+        info("  lines......: %.1f%% (%d of %d lines)\n",
+             $overall_hit * 100 / $overall_found, $overall_hit,
+             $overall_found,);
+
+        if ($func_coverage)
+        {
+                if ($total_fn_found == 0)
+                {
+                        info("  functions..: no data found\n");
+                }
+                else
+                {
+                        info("  functions..: %.1f%% (%d of %d functions)\n",
+                             $total_fn_hit * 100 / $total_fn_found,
+                             $total_fn_hit, $total_fn_found);
+
+                }
+        }
+
+}
+
+#
+# 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, $overview,
+            $testhash, $testfnchash, $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, $sort_type);
+        write_file_table(*HTML_HANDLE, $base_dir, $overview, $testhash,
+                         $testfnchash, $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 $overall_found=0;
+        my $overall_hit=0;
+        my $total_fn_found=0;
+        my $total_fn_hit=0;
+        my $base_name;
+        my $extension;
+        my $testdata;
+        my %testhash;
+        my $testfncdata;
+        my %testfnchash;
+        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, $testdata,
+                 $testfncdata) = 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, $page_link,
+                                         get_rate($lines_found, $lines_hit),
+                                         get_rate($fn_found, $fn_hit)];
+
+                $testhash{$base_name} = $testdata;
+                $testfnchash{$base_name} = $testfncdata;
+
+                $overall_found  += $lines_found;
+                $overall_hit    += $lines_hit;
+
+                $total_fn_found += $fn_found;
+                $total_fn_hit   += $fn_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,
+                               \%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, \%overview, \%testhash,
+                               \%testfnchash, 1, $_);
+        }
+
+        # Calculate resulting line counts
+        return ($overall_found, $overall_hit, $total_fn_found, $total_fn_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,
+            $sumcount, $funcdata, $sumfnccount, $testfncdata, $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, $sort_type);
+        write_function_table(*HTML_HANDLE, "$base_name.gcov.$html_ext",
+                             $sumcount, $funcdata,
+                             $sumfnccount, $testfncdata, $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 $lines_found;
+        my $lines_hit;
+        my $fn_found;
+        my $fn_hit;
+        my $converted;
+        my @source;
+        my $pagetitle;
+        local *HTML_HANDLE;
+
+        ($testdata, $sumcount, $funcdata, $checkdata, $testfncdata,
+         $sumfnccount, $lines_found, $lines_hit, $fn_found, $fn_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, $testdata);
+        }
+
+        $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, 0);
+        @source = write_source(*HTML_HANDLE, $filename, $sumcount, $checkdata,
+                               $converted, $funcdata);
+
+        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, $sumcount,
+                                            $funcdata, $sumfnccount,
+                                            $testfncdata, $_);
+                }
+        }
+
+        # Additional files are needed in case of frame output
+        if (!$frames)
+        {
+                return ($lines_found, $lines_hit,
+                        $fn_found, $fn_hit, $testdata);
+        }
+
+        # 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, $testdata,
+                $testfncdata);
+}
+
+
+#
+# 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
+#
+# %testdata   : name of test affecting this file -> \%testcount
+# %testfncdata: name of test affecting this file -> \%testfnccount
+#
+# %testcount   : line number   -> execution count for a single test
+# %testfnccount: function name -> execution count for a single test
+# %sumcount    : line number   -> execution count for all tests
+# %sumfnccount : function name -> execution count for all tests
+# %funcdata    : function name -> line number
+# %checkdata   : line number   -> checksum of source code line
+# 
+# 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 $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
+        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:([^,]*)/ && do
+                        {
+                                # Test name information found
+                                $testname = defined($1) ? $1 : "";
+                                if ($testname =~ s/\W/_/g)
+                                {
+                                        $changed_testname = 1;
+                                }
+                                last;
+                        };
+
+                        /^[SK]F:(.*)/ && do
+                        {
+                                # Filename information found
+                                # Retrieve data for new entry
+                                $filename = $1;
+
+                                $data = $result{$filename};
+                                ($testdata, $sumcount, $funcdata, $checkdata,
+                                 $testfncdata, $sumfnccount) =
+                                        get_info_entry($data);
+
+                                if (defined($testname))
+                                {
+                                        $testcount = $testdata->{$testname};
+                                        $testfnccount = $testfncdata->{$testname};
+                                }
+                                else
+                                {
+                                        $testcount = {};
+                                        $testfnccount = {};
+                                }
+                                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;
+                        };
+                        /^end_of_record/ && do
+                        {
+                                # Found end of section marker
+                                if ($filename)
+                                {
+                                        # Store current section data
+                                        if (defined($testname))
+                                        {
+                                                $testdata->{$testname} =
+                                                        $testcount;
+                                                $testfncdata->{$testname} =
+                                                        $testfnccount;
+                                        }       
+
+                                        set_info_entry($data, $testdata,
+                                                       $sumcount, $funcdata,
+                                                       $checkdata, $testfncdata,
+                                                       $sumfnccount);
+                                        $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) = 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;
+        }
+
+        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 $lines_found = $_[0]->{"found"};
+        my $lines_hit = $_[0]->{"hit"};
+        my $fn_found = $_[0]->{"f_found"};
+        my $fn_hit = $_[0]->{"f_hit"};
+
+        return ($testdata_ref, $sumcount_ref, $funcdata_ref, $checkdata_ref,
+                $testfncdata, $sumfnccount, $lines_found, $lines_hit,
+                $fn_found, $fn_hit);
+}
+
+
+#
+# set_info_entry(hash_ref, testdata_ref, sumcount_ref, funcdata_ref,
+#                checkdata_ref, testfncdata_ref, sumfcncount_ref[,lines_found,
+#                lines_hit, f_found, f_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];
+
+        if (defined($_[7])) { $data_ref->{"found"} = $_[7]; }
+        if (defined($_[8])) { $data_ref->{"hit"} = $_[8]; }
+        if (defined($_[9])) { $data_ref->{"f_found"} = $_[9]; }
+        if (defined($_[10])) { $data_ref->{"f_hit"} = $_[10]; }
+}
+
+
+#
+# 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;
+
+        %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;
+
+        %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;
+}
+
+#
+# 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 $entry2 = $_[1];     # Reference to hash containing second entry
+        my $testdata2;
+        my $sumcount2;
+        my $funcdata2;
+        my $checkdata2;
+        my $testfncdata2;
+        my $sumfnccount2;
+
+        my %result;             # Hash containing combined entry
+        my %result_testdata;
+        my $result_sumcount = {};
+        my $result_funcdata;
+        my $result_testfncdata;
+        my $result_sumfnccount;
+        my $lines_found;
+        my $lines_hit;
+        my $fn_found;
+        my $fn_hit;
+
+        my $testname;
+        my $filename = $_[2];
+
+        # Retrieve data
+        ($testdata1, $sumcount1, $funcdata1, $checkdata1, $testfncdata1,
+         $sumfnccount1) = get_info_entry($entry1);
+        ($testdata2, $sumcount2, $funcdata2, $checkdata2, $testfncdata2,
+         $sumfnccount2) = 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 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, $lines_found, $lines_hit,
+                       $fn_found, $fn_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/&/&amp;/g;         # & -> &amp;
+        $string =~ s/</&lt;/g;          # < -> &lt;
+        $string =~ s/>/&gt;/g;          # > -> &gt;
+        $string =~ s/\"/&quot;/g;       # " -> &quot;
+
+        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($)
+{
+        system("mkdir", "-p" ,$_[0])
+                and die("ERROR: cannot create directory $_!\n");
+}
+
+
+#
+# write_description_file(descriptions, overall_found, overall_hit,
+#                        total_fn_found, total_fn_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 $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, 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 item for legend entry */
+        td.headerItemLeg
+        {
+          text-align: right;
+          padding-right: 6px;
+          font-family: sans-serif;
+          font-weight: bold;
+          vertical-align: bottom;
+          white-space: nowrap;
+        }
+
+        /* 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;
+        }
+        
+        /* 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;
+        }
+        
+        /* Directory view/File view (all): legend entry for high coverage
+           rate */
+        span.coverLegendHi
+        {
+          padding-left: 10px;
+          padding-right: 10px;
+          padding-bottom: 2px;
+          background-color: #A7FC9D;
+        }
+        
+        /* 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;
+        }
+        
+        /* 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;
+        }
+        
+        /* Directory view/File view (all): legend entry for medium coverage
+           rate */
+        span.coverLegendMed
+        {
+          padding-left: 10px;
+          padding-right: 10px;
+          padding-bottom: 2px;
+          background-color: #FFEA20;
+        }
+        
+        /* 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;
+        }
+        
+        /* 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;
+        }
+        
+        /* Directory view/File view (all): legend entry for low coverage
+           rate */
+        span.coverLegendLo
+        {
+          padding-left: 10px;
+          padding-right: 10px;
+          padding-bottom: 2px;
+          background-color: #FF0000;
+        }
+        
+        /* File view (all): "show/hide details" link format */
+        a.detail:link
+        {
+          color: #B8D0FF;
+        }
+        
+        /* File view (all): "show/hide details" link - visited format */
+        a.detail:visited
+        {
+          color: #B8D0FF;
+        }
+        
+        /* File view (all): "show/hide details" link - activated format */
+        a.detail:active
+        {
+          color: #FFFFFF;
+        }
+        
+        /* File view (detail): test name table headline format */
+        td.testNameHead
+        {
+          text-align: right;
+          padding-right: 10px;
+          background-color: #DAE7FE;
+          font-family: sans-serif;
+          font-weight: bold;
+        }
+        
+        /* File view (detail): test lines table headline format */
+        td.testLinesHead
+        {
+          text-align: center;
+          background-color: #DAE7FE;
+          font-family: sans-serif;
+          font-weight: bold;
+        }
+        
+        /* File view (detail): test name entry */
+        td.testName
+        {
+          text-align: right;
+          padding-right: 10px;
+          background-color: #DAE7FE;
+        }
+        
+        /* File view (detail): test percentage entry */
+        td.testPer
+        {
+          text-align: right;
+          padding-left: 10px;
+          padding-right: 10px; 
+          background-color: #DAE7FE;
+        }
+        
+        /* File view (detail): test lines count entry */
+        td.testNum
+        {
+          text-align: right;
+          padding-left: 10px;
+          padding-right: 10px; 
+          background-color: #DAE7FE;
+        }
+        
+        /* 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;
+        }
+
+        /* Source code view: function entry nonzero count*/
+        td.coverFnHi
+        {
+          text-align: right;
+          padding-left: 10px;
+          padding-right: 10px;
+          background-color: #DAE7FE;
+          font-weight: bold;
+        }
+
+        /* Source code view: source code format */
+        /* Source code view: source code format */
+        pre.source
+        {
+          font-family: monospace;
+          white-space: pre;
+        }
+        
+        /* 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: #FF0000;
+        }
+        
+        /* 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 DiffCov legend */
+        span.LegendDiffCov
+        {
+          text-align: center;
+          padding-left: 10px;
+          padding-right: 10px;
+          background-color: #B5F7AF;
+        }
+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(filehandle, type, additional params..)
+#
+# Write a header line.
+#
+
+sub write_header_line(*$@)
+{
+        my $HANDLE = shift;
+        my $type = shift;
+        my @args = @_;
+
+        # Reduce indentation by using gotos
+        if ($type eq 0) {
+                goto header;
+        } elsif ($type eq 1) {
+                goto body;
+        } elsif ($type eq 2) {
+                goto legend_dir;
+        } elsif ($type eq 3) {
+                goto legend_source;
+        } elsif ($type eq 4) {
+                goto half_body;
+        }
+
+header:
+        # *************************************************************
+        write_html($HANDLE, <<END_OF_HTML);
+        <tr>
+          <td width="5%"></td>
+          <td width="10%" class="headerItem">$args[0]</td>
+          <td width="35%" class="headerValue">$args[1]</td>
+          <td width="10%"></td>
+          <td width="10%" class="headerCovTableHead">$args[2]</td>
+          <td width="10%" class="headerCovTableHead">$args[3]</td>
+          <td width="15%" class="headerCovTableHead">$args[4]</td>
+          <td width="5%"></td>
+        </tr>
+END_OF_HTML
+        # *************************************************************
+        return;
+
+body:
+        # *************************************************************
+        write_html($HANDLE, <<END_OF_HTML);
+        <tr>
+          <td></td>
+          <td class="headerItem">$args[0]</td>
+          <td class="headerValue">$args[1]</td>
+          <td class="headerItem">$args[2]</td>
+          <td class="headerCovTableEntry">$args[3]</td>
+          <td class="headerCovTableEntry">$args[4]</td>
+          <td class="headerCovTableEntry$args[5]">$args[6]</td>
+        </tr>
+END_OF_HTML
+        # *************************************************************
+        return;
+
+half_body:
+        # *************************************************************
+        write_html($HANDLE, <<END_OF_HTML);
+        <tr>
+          <td></td>
+          <td class="headerItem">$args[0]</td>
+          <td class="headerValue">$args[1]</td>
+        </tr>
+END_OF_HTML
+        # *************************************************************
+        return;
+
+legend_dir:
+        # *************************************************************
+        write_html($HANDLE, <<END_OF_HTML);
+        <tr>
+          <td></td>
+          <td class="headerItemLeg">$args[0]</td>
+          <td class="headerValueLeg">
+$args[1]          </td>
+          <td></td>
+          <td class="headerValueLeg" colspan=3>
+$args[2]          </td>
+        </tr>
+END_OF_HTML
+        # *************************************************************
+        return;
+
+legend_source:
+        # *************************************************************
+        write_html($HANDLE, <<END_OF_HTML);
+        <tr>
+          <td></td>
+          <td class="headerItem">$args[0]</td>
+          <td class="headerValueLeg" colspan=5>
+            <span class="coverLegendNoCov">$args[1]</span>
+            <span class="coverLegendCov">$args[2]</span>
+          </td>
+        </tr>
+END_OF_HTML
+        # *************************************************************
+}
+
+
+#
+# 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(filehandle, file_heading, lines_heading, func_heading)
+#
+# Write heading for file table.
+#
+
+sub write_file_table_prolog(*$$$)
+{
+        # *************************************************************
+
+        if ($func_coverage)
+        {
+                write_html($_[0], <<END_OF_HTML)
+          <center>
+          <table width="80%" cellpadding=1 cellspacing=1 border=0>
+
+            <tr>
+              <td width="45%"><br></td>
+              <td width="15%"></td>
+              <td width="10%"></td>
+              <td width="10%"></td>
+              <td width="10%"></td>
+              <td width="10%"></td>
+            </tr>
+
+            <tr>
+              <td class="tableHead">$_[1]</td>
+              <td class="tableHead" colspan=3>$_[2]</td>
+              <td class="tableHead" colspan=2>$_[3]</td>
+            </tr>
+
+END_OF_HTML
+                ;
+        }
+        else
+        {
+                write_html($_[0], <<END_OF_HTML)
+          <center>
+          <table width="80%" cellpadding=1 cellspacing=1 border=0>
+
+            <tr>
+              <td width="50%"><br></td>
+              <td width="15%"></td>
+              <td width="15%"></td>
+              <td width="20%"></td>
+            </tr>
+
+            <tr>
+              <td class="tableHead">$_[1]</td>
+              <td class="tableHead" colspan=3>$_[2]</td>
+            </tr>
+
+END_OF_HTML
+                ;
+        }
+
+        # *************************************************************
+}
+
+
+#
+# write_file_table_entry(filehandle, cover_filename, cover_bar_graph,
+#                        cover_found, cover_hit, fn_found, fn_hit,
+#                        page_link, func_link)
+#
+# Write an entry of the file table.
+#
+
+sub write_file_table_entry(*$$$$$$$)
+{
+        local *HANDLE = shift;
+        my ($filename, $bar_graph, $found, $hit, $fn_found, $fn_hit,
+            $page_link) = @_;
+        my $rate;
+        my $rate_string;
+        my $funcs_string;
+        my $class_lines = "Lo";
+        my $class_funcs = "Hi";
+        my $file_code;
+
+        # 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;
+        }
+
+        # Get line coverage rate
+        if ($found > 0)
+        {
+                $rate = $hit * 100 / $found;
+                $rate_string = sprintf("%.1f", $rate)."&nbsp;%";
+                
+                $class_lines = $rate_name[classify_rate($found, $hit,
+                                          $med_limit, $hi_limit)];
+        }
+        else
+        {
+                $rate_string = "-";
+        }
+
+        # Get function coverage rate
+        if ($fn_found > 0)
+        {
+                $rate = $fn_hit * 100 / $fn_found;
+                $class_funcs = $rate_name[classify_rate($fn_found, $fn_hit,
+                                          $fn_med_limit, $fn_hi_limit)];
+                $funcs_string = sprintf("%.1f", $rate)."&nbsp;%";               
+        }
+        else
+        {
+                # Define 0 of 0 functions as 100%
+                $rate = 100;
+                $funcs_string = "-";
+        }
+
+        # *************************************************************
+
+        write_html(*HANDLE, <<END_OF_HTML)
+            <tr>
+              <td class="coverFile">$file_code</td>
+              <td class="coverBar" align="center">
+                $bar_graph
+              </td>
+              <td class="coverPer$class_lines">$rate_string</td>
+              <td class="coverNum$class_lines">$hit / $found</td>
+END_OF_HTML
+        ;
+
+        if ($func_coverage)
+        {
+                write_html(*HANDLE, <<END_OF_HTML)
+              <td class="coverPer$class_funcs">$funcs_string</td>
+              <td class="coverNum$class_funcs">$fn_hit / $fn_found</td>
+END_OF_HTML
+                ;
+        }
+        write_html(*HANDLE, <<END_OF_HTML)
+            </tr>
+END_OF_HTML
+        ;
+
+        # *************************************************************
+}
+
+
+#
+# write_file_table_detail_heading(filehandle, left_heading, right_heading)
+#
+# Write heading for detail section in file table.
+#
+
+sub write_file_table_detail_heading(*$$$)
+{
+        my $func_rows = "";
+
+        if ($func_coverage)
+        {
+                $func_rows = "<td class=\"testLinesHead\" colspan=2>$_[3]</td>";
+        }
+
+        # *************************************************************
+        write_html($_[0], <<END_OF_HTML)
+            <tr>
+              <td class="testNameHead" colspan=2>$_[1]</td>
+              <td class="testLinesHead" colspan=2>$_[2]</td>
+              $func_rows
+            </tr>
+
+END_OF_HTML
+        ;
+
+        # *************************************************************
+}
+
+
+#
+# write_file_table_detail_entry(filehandle, test_name,
+#               cover_found, cover_hit, func_found, func_hit)
+#
+# Write entry for detail section in file table.
+#
+
+sub write_file_table_detail_entry(*$$$$$)
+{
+        my $rate;
+        my $func_rate;
+        my $name = $_[1];
+        
+        if ($_[2]>0)
+        {
+                $rate = sprintf("%.1f", $_[3]*100/$_[2])."&nbsp;%";
+        }
+        else
+        {
+                $rate = "-";
+        }
+
+        if ($_[4]>0)
+        {
+                $func_rate = sprintf("%.1f", $_[5]*100/$_[4])."&nbsp;%";
+        }
+        else
+        {
+                $func_rate = "-";
+        }
+
+        if ($name =~ /^(.*),diff$/)
+        {
+                $name = $1." (converted)";
+        }
+
+        if ($name eq "")
+        {
+                $name = "<span style=\"font-style:italic\">&lt;unnamed&gt;</span>";
+        }
+
+        # *************************************************************
+
+        write_html($_[0], <<END_OF_HTML)
+            <tr>
+              <td class="testName" colspan=2>$name</td>
+              <td class="testPer">$rate</td>
+              <td class="testNum">$_[3]&nbsp;/&nbsp;$_[2]&nbsp;lines</td>
+END_OF_HTML
+        ;
+        if ($func_coverage)
+        {
+                write_html($_[0], <<END_OF_HTML)
+              <td class="testPer">$func_rate</td>
+              <td class="testNum">$_[5]&nbsp;/&nbsp;$_[4]</td>
+END_OF_HTML
+                ;
+        }
+        write_html($_[0], <<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]">&nbsp;</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
+        ;
+
+        # *************************************************************
+}
+
+
+#
+# write_source_prolog(filehandle)
+#
+# Write start of source code table.
+#
+
+sub write_source_prolog(*)
+{
+        # *************************************************************
+
+        write_html($_[0], <<END_OF_HTML)
+          <table cellpadding=0 cellspacing=0 border=0>
+            <tr>
+              <td><br></td>
+            </tr>
+            <tr>
+              <td><pre class="source">
+END_OF_HTML
+        ;
+
+        # *************************************************************
+}
+
+
+#
+# write_source_line(filehandle, line_num, source, hit_count, converted,
+#                   add_anchor)
+#
+# Write formatted source code line. Return a line in a format as needed
+# by gen_png()
+#
+
+sub write_source_line(*$$$$$)
+{
+        my $source_format;
+        my $count;
+        my $result;
+        my $anchor_start = "";
+        my $anchor_end = "";
+
+        if (!(defined$_[3]))
+        {
+                $result         = "";
+                $source_format  = "";
+                $count          = " "x15;
+        }
+        elsif ($_[3] == 0)
+        {
+                $result         = $_[3];
+                $source_format  = '<span class="lineNoCov">';
+                $count          = sprintf("%15d", $_[3]);
+        }
+        elsif ($_[4] && defined($highlight))
+        {
+                $result         = "*".$_[3];
+                $source_format  = '<span class="lineDiffCov">';
+                $count          = sprintf("%15d", $_[3]);
+        }
+        else
+        {
+                $result         = $_[3];
+                $source_format  = '<span class="lineCov">';
+                $count          = sprintf("%15d", $_[3]);
+        }
+
+        $result .= ":".$_[2];
+
+        # Write out a line number navigation anchor every $nav_resolution
+        # lines if necessary
+        if ($_[5])
+        {
+                $anchor_start   = "<a name=\"$_[1]\">";
+                $anchor_end     = "</a>";
+        }
+
+
+        # *************************************************************
+
+        write_html($_[0],
+                   $anchor_start.
+                   '<span class="lineNum">'.sprintf("%8d", $_[1]).
+                   " </span>$source_format$count : ".
+                   escape_html($_[2]).($source_format?"</span>":"").
+                   $anchor_end."\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
+        ;
+
+        # *************************************************************
+}
+
+
+# rate_to_col(found, hit)
+#
+# Return Lo, Med or Hi, depending on the coverage rate.
+#
+
+sub rate_to_col($$)
+{
+        my ($found, $hit) = @_;
+        my $rate;
+
+        if ($found == 0) {
+                return "Hi";
+        }
+        $rate = 100 * $hit / $found;
+        if ($rate < $med_limit) {
+                return "Lo";
+        } elsif ($rate < $hi_limit) {
+                return "Med";
+        }
+        return "Hi";
+}
+
+# format_rate(found, hit)
+#
+# Return formatted percent string for coverage rate.
+#
+
+sub format_rate($$)
+{       
+        return $_[0] == 0 ? "-" : sprintf("%.1f", $_[1] * 100 / $_[0])." %";
+}
+
+sub get_legend_code($$$)
+{
+        my ($text, $med, $hi) = @_;
+        my $result;
+
+        $result = <<EOF;
+                    $text<br>
+                    <span class="coverLegendLo">0% to $med%</span>
+                    <span class="coverLegendMed">$med% to $hi%</span>
+                    <span class="coverLegendHi">$hi% to 100%</span>
+EOF
+        return $result;
+}
+
+#
+# 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 $sort_type = $_[8];
+        my $base_dir;
+        my $view;
+        my $test;
+        my $base_name;
+
+        $base_name = basename($rel_filename);
+
+        # Prepare text for "current view" field
+        if ($type == 0)
+        {
+                # Main overview
+                $base_dir = "";
+                $view = $overview_title;
+        }
+        elsif ($type == 1)
+        {
+                # 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 == 2 || $type == 4)
+        {
+                # 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) {
+                        if ($type == 2) {
+                                $view .= " (source / <a href=\"$base_name.func.$html_ext\">functions</a>)";
+                        } elsif ($type == 4) {
+                                $view .= " (<a href=\"$base_name.gcov.$html_ext\">source</a> / functions)";
+                        }
+                }
+        }
+        elsif ($type == 3)
+        {
+                # 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 != 3))
+        {
+                if ($frames && ($type == 2 || $type == 4))
+                {
+                        # Need to break frameset when clicking this link
+                        $test .= " ( <a href=\"$base_dir".
+                                 "descriptions.$html_ext\" target=\"_parent\">".
+                                 "view descriptions</a> )";
+                }
+                else
+                {
+                        $test .= " ( <a href=\"$base_dir".
+                                 "descriptions.$html_ext\">".
+                                 "view descriptions</a> )";
+                }
+        }
+
+        # Write header
+        write_header_prolog(*HTML_HANDLE, $base_dir);
+        write_header_line(*HTML_HANDLE, 0, "Current view:", $view,
+                          "Found", "Hit", "Coverage");
+        write_header_line(*HTML_HANDLE, 1, "Test:", $test, "Lines:",
+                          $lines_found, $lines_hit,
+                          $rate_name[classify_rate($lines_found, $lines_hit,
+                                                   $med_limit, $hi_limit)],
+                          format_rate($lines_found, $lines_hit));
+        if ($func_coverage) {
+                write_header_line(*HTML_HANDLE, 1, "Date:", $date, "Functions:",
+                                  $fn_found, $fn_hit,
+                                  $rate_name[classify_rate($fn_found,
+                                                           $fn_hit,
+                                                           $fn_med_limit,
+                                                           $fn_hi_limit)],
+                                  format_rate($fn_found, $fn_hit));
+        } else {
+                write_header_line(*HTML_HANDLE, 4, "Date:", $date);
+        }
+        if ($legend) {
+                if ($type == 0 || $type == 1) {
+                        my $line_code = get_legend_code("Line coverage:",
+                                                $med_limit, $hi_limit);
+                        my $func_code = "";
+
+                        if ($func_coverage) {
+                                $func_code = get_legend_code(
+                                                "Function coverage:",
+                                                $fn_med_limit,
+                                                $fn_hi_limit);
+                        }
+                        write_header_line(*HTML_HANDLE, 2, "Colors:",
+                                $line_code, $func_code);
+                } elsif ($type == 2 || $type == 4) {
+                        write_header_line(*HTML_HANDLE, 3, "Colors:",
+                                          "not hit", "hit");
+                }
+        }
+        write_header_epilog(*HTML_HANDLE, $base_dir);
+}
+
+
+#
+# split_filename(filename)
+#
+# Return (path, filename, extension) for a given FILENAME.
+#
+
+sub split_filename($)
+{
+        if (!$_[0]) { return(); }
+        my @path_components = split('/', $_[0]);
+        my @file_components = split('\.', pop(@path_components));
+        my $extension = pop(@file_components);
+
+        return (join("/",@path_components), join(".",@file_components),
+                $extension);
+}
+
+#
+# get_sorted_keys(hash_ref, sort_type)
+#
+
+sub get_sorted_keys($$)
+{
+        my ($hash, $type) = @_;
+
+        if ($type == 0) {
+                # Sort by name
+                return sort(keys(%{$hash}));
+        } elsif ($type == 1) {
+                # Sort by line coverage
+                return sort({$hash->{$a}[5] <=> $hash->{$b}[5]} keys(%{$hash}));
+        } elsif ($type == 2) {
+                # Sort by function coverage;
+                return sort({$hash->{$a}[6] <=> $hash->{$b}[6]} 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 == 1) {
+                        $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 == 1) {
+                # Just text
+                if ($sort_button) {
+                        $sort_link = "index-sort-l.$html_ext";
+                }
+        } elsif ($type == 2) {
+                # 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 == 1) {
+                        $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;
+}
+
+#
+# write_file_table(filehandle, base_dir, overview, testhash, testfnchash,
+#                  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 $fileview = $_[5];
+        my $sort_type = $_[6];
+        my $filename;
+        my $bar_graph;
+        my $hit;
+        my $found;
+        my $fn_found;
+        my $fn_hit;
+        my $page_link;
+        my $testname;
+        my $testdata;
+        my $testfncdata;
+        my $testcount;
+        my $testfnccount;
+        my %affecting_tests;
+        my $line_code = "";
+        my $func_code;
+        my $file_code;
+
+        # Determine HTML code for column headings
+        if (($base_dir ne "") && $show_details)
+        {
+                my $detailed = keys(%{$testhash});
+
+                $file_code = get_file_code($detailed ? 2 : 1,
+                                        $fileview ? "Filename" : "Directory",
+                                        $sort && $sort_type != 0, $base_dir);
+                $line_code = get_line_code($detailed ? 3 : 2, $sort_type,
+                                        "Line Coverage",
+                                        $sort && $sort_type != 1, $base_dir);
+                $func_code = get_func_code($detailed ? 2 : 1, "Functions",
+                                        $sort && $sort_type != 2, $base_dir);
+        } else {
+                $file_code = get_file_code(1,
+                                        $fileview ? "Filename" : "Directory",
+                                        $sort && $sort_type != 0, $base_dir);
+                $line_code = get_line_code(1, $sort_type, "Line Coverage",
+                                        $sort && $sort_type != 1, $base_dir);
+                $func_code = get_func_code(1, "Functions",
+                                        $sort && $sort_type != 2, $base_dir);
+        }
+
+        write_file_table_prolog(*HTML_HANDLE, $file_code, $line_code,
+                                $func_code);
+
+        foreach $filename (get_sorted_keys($overview, $sort_type))
+        {
+                ($found, $hit, $fn_found, $fn_hit, $page_link)
+                        = @{$overview->{$filename}};
+                $bar_graph = get_bar_graph_code($base_dir, $found, $hit);
+
+                $testdata = $testhash->{$filename};
+                $testfncdata = $testfnchash->{$filename};
+
+                write_file_table_entry(*HTML_HANDLE, $filename, $bar_graph,
+                                       $found, $hit, $fn_found, $fn_hit,
+                                       $page_link);
+
+                # 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) };
+
+                # Does any of the tests affect this file at all?
+                if (!%affecting_tests) { next; }
+
+                # Write test details for this entry
+                write_file_table_detail_heading(*HTML_HANDLE, "Test name",
+                                                "Lines hit", "Functions hit");
+
+                foreach $testname (keys(%affecting_tests))
+                {
+                        ($found, $hit, $fn_found, $fn_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>";
+                        }
+
+                        write_file_table_detail_entry(*HTML_HANDLE, $testname,
+                                $found, $hit, $fn_found, $fn_hit);
+                }
+        }
+
+        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);
+}
+
+
+#
+# get_affecting_tests(testdata, testfncdata)
+#
+# 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 = $_[0];
+        my $testfncdata = $_[1];
+        my $testname;
+        my $testcount;
+        my $testfnccount;
+        my %result;
+        my $found;
+        my $hit;
+        my $fn_found;
+        my $fn_hit;
+
+        foreach $testname (keys(%{$testdata}))
+        {
+                # Get (line number -> count) hash for this test case
+                $testcount = $testdata->{$testname};
+                $testfnccount = $testfncdata->{$testname};
+
+                # Calculate sum
+                ($found, $hit) = get_found_and_hit($testcount);
+                ($fn_found, $fn_hit) = get_func_found_and_hit($testfnccount);
+
+                if ($hit>0)
+                {
+                        $result{$testname} = "$found,$hit,$fn_found,$fn_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)
+#
+# 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 $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($_);
+
+                # 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},
+                                        $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)
+#
+# 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 $name = $_[6];
+        my $base = $_[7];
+        my $type = $_[8];
+        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)) {
+                my $startline = $funcdata->{$func} - $func_offset;
+                my $name = escape_html($func);
+                my $count = $sumfncdata->{$name};
+                my $countstyle;
+
+                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 = %{$_[0]};
+        my %base = %{$_[1]};
+        my $func;
+        my $data_count;
+        my $base_count;
+        my $fn_hit = 0;
+        my $fn_found = 0;
+
+        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_count;
+        my $data_testfnccount;
+        my $base;
+        my $base_checkdata;
+        my $base_sumfnccount;
+        my $base_count;
+        my $sumcount;
+        my $sumfnccount;
+        my $found;
+        my $hit;
+        my $fn_found;
+        my $fn_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) = get_info_entry($data);
+                (undef, $base_count, undef, $base_checkdata, undef,
+                 $base_sumfnccount) = get_info_entry($base);
+
+                # Check for compatible checksums
+                merge_checksums($data_checkdata, $base_checkdata, $filename);
+
+                # sumcount has to be calculated anew
+                $sumcount = {};
+                $sumfnccount = {};
+
+                # 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_count, undef, $hit) =
+                                subtract_counts($data_count, $base_count);
+                        ($data_testfnccount) =
+                                subtract_fnccounts($data_testfnccount,
+                                                   $base_sumfnccount);
+
+                        # 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;
+                        }
+                        else
+                        {
+                                # Delete test case which did not impact this
+                                # file
+                                delete($data_testdata->{$testname});
+                                delete($data_testfncdata->{$testname});
+                        }
+
+                        # Add counts to sum of counts
+                        ($sumcount, $found, $hit) =
+                                add_counts($sumcount, $data_count);
+                        ($sumfnccount, $fn_found, $fn_hit) =
+                                add_fnccounts($sumfnccount, $data_testfnccount);
+                }
+
+                # Write back resulting entry
+                set_info_entry($data, $data_testdata, $sumcount, $data_funcdata,
+                               $data_checkdata, $data_testfncdata, $sumfnccount,
+                               $found, $hit, $fn_found, $fn_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");
+}