${age_heading} ${owner_heading} ${lineno_heading}${branch_heading}${mcdc_heading}${tla_heading}${line_heading} ${source_heading}
END_OF_HTML
# *************************************************************
}
#
# get_block_len(block)
#
# Calculate total text length of all branches in a block of branches.
#
sub get_block_len($)
{
my ($block) = @_;
my $len = 0;
foreach my $branch (@{$block}) {
$len += $branch->[$BR_LEN];
}
return $len;
}
#
# get_block_list(brdata | mcdc_data, offset)
#
# common method for branch and MC/DC records
# Group elements that belong to the same basic record
#
# Returns: [block1, block2, ...] <- in order of increasing block number/group size
# block: [branch1, branch2, ...] <- in order of increasing branch/expression index
# branch: [block_num, branch_num, taken_count, text_length, open, close]
#
sub get_block_list($$)
{
# only the blocks or groups at location 'offset', if it is defined - see
# PrintCallback::coverpointsAt
my ($data, $offset) = @_;
return () unless defined($data);
my @blocks;
if ('BranchLocation' eq ref($data)) {
my $block = [];
my $last_blkId;
# Group branches
foreach my $blk ($data->blocks(1)) {
next if defined($offset) && $blk->locationOffset() != $offset;
my $blockData = $blk->elements();
my $blkId = $blk->idx();
my $branch = 0;
foreach my $br_elem (@$blockData) {
if (defined($last_blkId) && $blkId ne $last_blkId) {
push(@blocks, $block);
$block = [];
}
my $br = [$blkId, $branch, $br_elem, 3, 0, 0];
push(@{$block}, $br);
$last_blkId = $blkId;
++$branch;
}
}
push(@blocks, $block) if (scalar(@{$block}) > 0);
} else {
die('unexpected ' . ref($data)) unless 'MCDC_Block' eq ref($data);
# Group MC/DC groups
# one groups() call, not one per group: it materializes a fresh hash
my $groups = $data->groups();
foreach my $groupKey (sort keys %$groups) {
next
if defined($offset) &&
(MCDC_Block::parseGroupKey($groupKey))[1] != $offset;
my $exprs = $groups->{$groupKey};
my $block = [];
push(@blocks, $block);
foreach my $expr (@$exprs) {
# display 'true' then 'false' sense - to match what we do for branches
# and to match behaviour of ?: operator
foreach my $sense (1, 0) {
my $cond =
[$groupKey, $expr->index(), $sense, $expr, 3, 0, 0];
push(@{$block}, $cond);
}
}
}
}
# Add braces to first and last branch in group
foreach my $block (@blocks) {
$block->[0]->[$BR_OPEN] = 1;
$block->[0]->[$BR_LEN]++;
$block->[$#$block]->[$BR_CLOSE] = 1;
$block->[$#$block]->[$BR_LEN]++;
}
return @blocks;
}
# distribute blocks into lines - trying to keep groups on a single line,
# if possible
sub distribute_blocks($$)
{
my ($blocks, $field_width) = @_;
my $line_len = 0;
my $line = []; # [branch2|" ", branch|" ", ...]
my @lines; # [line1, line2, ...]
my @result;
# Distribute blocks to lines
foreach my $block (@$blocks) {
my $block_len = get_block_len($block);
# Does this block fit into the current line?
if ($line_len + $block_len <= $field_width) {
# Add it
$line_len += $block_len;
push(@{$line}, @{$block});
next;
} elsif ($block_len <= $field_width) {
# It would fit if the line was empty - add it to new line
push(@lines, $line);
$line_len = $block_len;
$line = [@{$block}];
next;
}
my $split = ($block_len / $field_width) > 2;
# this block is going to take up a bunch of lines -
# add it to a new line
# Split the block into several lines
foreach my $branch (@{$block}) {
if ($line_len + $branch->[$BR_LEN] >= $field_width ||
$split) {
# Start a new line
if (($line_len + 1 <= $field_width) &&
scalar(@{$line}) > 0 &&
!$line->[scalar(@$line) - 1]->[$BR_CLOSE]) {
# Try to align branch symbols to be in
# one # row
push(@{$line}, " ");
}
push(@lines, $line);
$line_len = 0;
$line = [];
$split = 0;
}
push(@{$line}, $branch);
$line_len += $branch->[$BR_LEN];
}
}
push(@lines, $line);
return @lines;
}
#
# tla_class_and_prefix(tla)
#
# The CSS class and the tooltip prefix which a differential coverpoint of this
# TLA is drawn with. Shared by the branch and the MC/DC renderers below - see
# the '@todo' on 'get_mcdc_html'.
#
# An excluded coverpoint has no legacy label ('noBaseline' keeps 'GNC' and 'UNC'
# only) and needs none: the '$excluded' arm of both renderers replaces the class
# and writes its own title. Asking for one is what left the MC/DC tooltip
# opening with a bare ': ', and skipping the whole element to avoid asking is
# what dropped a branch, its closing bracket and its share of the column width.
#
sub tla_class_and_prefix($)
{
my $tla = shift;
return ("tla$tla", '')
if exists($SummaryInfo::excludedCoverpointTla{$tla});
return ("tla$tla", "$tla: ") unless $main::use_legacyLabels;
return ("tla$tla", $SummaryInfo::tlaToLegacySrcLabel{$tla} . ': ');
}
#
# get_branch_html(brdata, printCallbackStruct)
#
# Return a list of HTML lines which represent the specified branch coverage
# data in source code view.
#
sub get_branch_html($$)
{
my ($brdata, $cbdata) = @_;
my $differentialBranch;
my $fileDetail = $cbdata->sourceDetail();
my $lineNo = $cbdata->lineNo();
# build the 'blocks' array from differential data if we have it - from
# the blocks written at this line, which may not be always the line which
# holds them, in the case of a middle line of a multiline statement
my @blocks;
foreach my $at ($cbdata->coverpointsAt(0, $lineNo, $brdata)) {
my ($data, $offset, $isDiff) = @$at;
$differentialBranch = 1 if $isDiff;
push(@blocks, get_block_list($data, $offset));
}
my @lines = distribute_blocks(\@blocks, $br_field_width);
# Convert to HTML
# branch and MC/DC code is similar - but merging only makes things
# more complicated as the details of the text, popups, etc are different
# maybe revisit later
my @result;
my %tlaLinks;
foreach my $line (@lines) {
my $current = "";
my $current_len = 0;
foreach my $branch (@$line) {
# Skip alignment space
if ($branch eq " ") {
$current .= " ";
$current_len++;
next;
}
my ($block_num, $br_num, $br, $len, $open, $close) = @{$branch};
my $class;
my $prefix;
# one call for everything this element needs: under XS that is a
# single Perl<->C++ crossing rather than eight on a path executed
# once per rendered branch. $tla/$base_count come back undef for
# non-differential data.
my ($taken, $count, $excluded, $type_name, $expr, $tla, $base_count)
= $br->render_data();
unless (defined($differentialBranch)) {
# vanilla case - no differential coverage info: ignore any
# differential fields the element happens to carry
$tla = $base_count = undef;
if ($taken eq '-' || $taken == 0) {
$class = "tlaUNC";
} else {
$class = 'tlaGBC';
}
$prefix = '';
} else {
($class, $prefix) = tla_class_and_prefix($tla);
}
my ($char, $title);
my $br_name = $type_name;
$br_name .= ' ' if $br_name;
$br_name .= 'branch ';
$br_name .= defined($expr) ? '"' . $expr . '"' : $br_num;
if ($excluded) {
$class = 'tla' . ($count ? 'ECC' : 'EUC');
$char = 'x';
$title = "$br_name marked unreachable";
} elsif ($taken eq '-') {
$char = "#";
$title = "${prefix}$br_name was not executed";
$title .=
" (previously taken $base_count time" .
(1 == $base_count ? '' : 's') . ')'
if (defined($tla) &&
($tla eq 'LBC' || $tla eq 'ECB'));
} elsif ($taken == 0) {
$char = "-";
$title = "${prefix}$br_name was not taken";
$title .=
" (previously taken $base_count time" .
(1 == $base_count ? '' : 's') . ')'
if (defined($tla) &&
($tla eq 'LBC' || $tla eq 'ECB'));
} else {
$char = "+";
$title = "${prefix}$br_name was taken $taken time" .
(($taken > 1) ? "s" : "");
}
$title = escape_html($title) if defined($expr);
$current .= "[" if ($open);
if (!$main::no_sourceview &&
!$excluded &&
defined($differentialBranch)) {
my $href;
if (exists($tlaLinks{$tla})) {
$href = $tlaLinks{$tla};
} else {
my $next = $fileDetail->nextBranchTlaGroup($tla, $lineNo);
$href =
"CHAR";
$tlaLinks{$tla} = $href;
}
# the cache is per TLA, but the marker character is per branch:
# '#' (never executed) and '-' (reached, not taken) are both
# uncovered, so two branches on one line can share a TLA and
# still need different glyphs. Same placeholder treatment the
# MC/DC loop below gives its sense character
$href =~ s/CHAR/$char/;
$href =~ s#TITLE#$title#;
$current .= " $href ";
} else {
$current .=
" $char ";
}
$current .= "]" if ($close);
$current_len += $len;
}
# Right-align result text
if ($current_len < $br_field_width) {
$current = (" " x ($br_field_width - $current_len)) . $current;
}
push(@result, $current);
}
return @result;
}
sub get_mcdc_html($$)
{
# @todo can be shared with branch, MC/DC
my ($mcdc_data, $cbdata) = @_;
my $differentialMcdc;
my $fileDetail = $cbdata->sourceDetail();
my $lineNo = $cbdata->lineNo();
# build the 'blocks' array from differential data if we have it - see
# get_branch_html
my @blocks;
foreach my $at ($cbdata->coverpointsAt(1, $lineNo, $mcdc_data)) {
my ($data, $offset, $isDiff) = @$at;
$differentialMcdc = 1 if $isDiff;
push(@blocks, get_block_list($data, $offset));
}
my @lines = distribute_blocks(\@blocks, $mcdc_field_width);
# Convert to HTML
# branch and MC/DC code is similar - but merging only makes things
# more complicated as the details of the text, popups, etc are different
# maybe revisit later
my @result;
my %tlaLinks;
foreach my $line (@lines) {
my $current = "";
my $current_len = 0;
foreach my $cond (@$line) {
# Skip alignment space
unless ('ARRAY' eq ref($cond)) {
die("unexpected 'cond' entry '$cond'") unless ($cond eq " ");
$current .= " ";
$current_len++;
next;
}
my ($groupSize, $exprIdx, $sense, $expr, $len, $open, $close) =
@$cond;
die("unexpected expr type") unless ref($expr) eq 'MCDC_Expression';
# one call for everything this element needs - see the comment on
# the corresponding branch loop above
my ($count, $expr_name, $excluded, $multiGroup) =
$expr->render_data($sense);
my $taken;
my $class;
my $prefix;
my $tla;
my $base_count;
if ('ARRAY' ne ref($count)) {
# vanilla case - no differential coverage info
die("differential MC/DC coverage but no TLA")
if defined($differentialMcdc);
$taken = $count;
if ($count == 0) {
$class = "tlaUNC";
} else {
$class = 'tlaGBC';
}
$prefix = '';
} else {
die("differential MC/DC coverage but no TLA")
unless defined($differentialMcdc);
($tla, $base_count, $taken) = @$count;
($class, $prefix) = tla_class_and_prefix($tla);
}
my ($char, $title);
$title =
${prefix} .
($sense ? 'True' : 'False') .
' sense of expression "' .
$expr_name . '" ';
if ($multiGroup) {
$title .= 'in group "' . $expr->groupSize() . '" ';
}
if ($excluded) {
$char = 'x';
$class = 'tla' . ($taken ? 'ECC' : 'EUC');
$title .= "marked unreachable";
} elsif (!defined($taken)) {
$char = '-';
$title .= 'was dropped';
$title .=
' (previously ' .
(1 == $base_count ? '' : 'not ') .
'sensitized)'
if (defined($tla) &&
($tla eq 'LBC' || $tla eq 'ECB'));
} elsif ($taken == 0) {
$char = $sense ? 't' : 'f';
$title .= 'was not sensitized';
$title .=
' (previously ' .
(1 == $base_count ? '' : 'not ') .
'sensitized)'
if (defined($tla) &&
($tla eq 'LBC' || $tla eq 'ECB'));
} else {
$char = $sense ? 'T' : 'F';
$title .= 'was sensitized';
}
$title = escape_html($title);
$current .= "[" if ($open);
if (!$main::no_sourceview &&
!$excluded &&
defined($differentialMcdc)) {
my $href;
if (exists($tlaLinks{$tla})) {
$href = $tlaLinks{$tla};
} else {
my $next = $fileDetail->nextMcdcTlaGroup($tla, $lineNo);
$href =
"SENSE";
# cache the href as 'next' lookup is moderately expensive
$tlaLinks{$tla} = $href;
}
# keep the link but update the sense character
$href =~ s/SENSE/$char/;
$href =~ s#TITLE#$title#;
$current .= " $href ";
} else {
$current .=
" $char ";
}
$current .= "]" if ($close);
$current_len += $len;
}
# Right-align result text
if ($current_len < $mcdc_field_width) {
$current = (" " x ($mcdc_field_width - $current_len)) . $current;
}
push(@result, $current);
}
return @result;
}
#
# format_count(count, width)
#
# Return a right-aligned representation of count that fits in width characters.
#
sub format_count($$)
{
my ($count, $width) = @_;
my $result;
my $exp;
my $negative = 0 > $count;
if ($negative) {
$width -= 2;
$count = -$count;
}
$result = sprintf("%*.0f", $width, $count);
while (length($result) > $width) {
last if ($count < 10);
$exp++;
$count = int($count / 10);
$result = sprintf("%*s", $width, ">$count*10^$exp");
}
if ($negative) {
# surround number with parens
$result =~ s/^( *)(\S+)$/$1\($2\)/;
}
return $result;
}
#
# write_source_line(filehandle, cbdata, source, hit_count, brdata, mcdc,
# printCallbackStruct)
#
# Write formatted source code line. Return a line in a format as needed
# by gen_png()
#
sub write_source_line(*$$$$$$$)
{
my ($handle, $srcline, $count, $showBranches, $brdata, $showMcdc, $mcdc,
$cbdata)
= @_;
my $line = $cbdata->lineNo();
my $fileCovInfo = $cbdata->lineData();
my $sourceDetail = $cbdata->sourceDetail();
my $source = $srcline->text();
my $src_owner = $srcline->owner();
my $src_age = $srcline->age();
my $source_format;
my $count_format;
my $result;
my $anchor_start = "";
my $anchor_end = "";
my $count_field_width = $line_field_width - 1;
my $html;
my $tla;
my $base_count;
my $curr_count;
my $bucket;
my @prevData = ($cbdata->current('tla'),
$cbdata->current('owner'),
$cbdata->current('age'));
# Get branch HTML data for this line
my @br_html;
@br_html = get_branch_html($brdata, $cbdata) if ($showBranches);
my @mcdc_html;
@mcdc_html = get_mcdc_html($mcdc, $cbdata) if ($showMcdc);
my $thisline = $fileCovInfo->lineMap()->{$line};
my $tlaIsHref;
if (!defined($thisline) ||
(!defined($count) &&
!($thisline->in_base() || $thisline->in_curr()))
) {
$result = "";
$source_format = "";
$count_format = " " x $count_field_width;
$tla = $cbdata->tla(undef, $line);
} else {
$base_count = $thisline->base_count();
$curr_count = $thisline->curr_count();
$bucket = $thisline->tla();
# use callback data to keep track of the most recently seen TLA -
# $tla is either " " (3 spaces) if same as previous or if no TLA
# we just stick "TLA " (4 characters) into the fixed-with source
# line - right before the count.
$tla = $cbdata->tla($bucket, $line);
my $class = "tla$bucket";
if ($main::show_tla && $tla =~ /$bucket/) {
# maybe we want to link only the uncovered code categories?
my $next = $sourceDetail->nextTlaGroup($bucket, $line);
$tlaIsHref = 1;
# if no next segment in this category - then go to top to page.
$next = defined($next) ? "L$next" : "top";
my $anchorClass = "";
if ($bucket ne 'UNK') {
$class .= " tlaBg$bucket";
$anchorClass = " class=\"tlaBg$bucket\" ";
}
my $label =
$main::use_legacyLabels ?
$SummaryInfo::tlaToLegacySrcLabel{$bucket} :
$bucket;
my $popup = " title=\"Next $label group\"";
$label .= ' ' x ($main::tla_field_width - length($label));
$tla = "$label";
}
$source_format = "";
my $pchar;
if (exists($lcovutil::pngChar{$bucket})) {
$pchar = $lcovutil::pngChar{$bucket};
} else {
lcovutil::ignorable_error($lcovutil::ERROR_UNKNOWN_CATEGORY,
"unexpected TLA '$bucket'");
$pchar = '';
$count = 0 unless defined($count);
}
if ($bucket eq "ECB" ||
$bucket eq "EUB") {
!defined($count) or
die("excluded code should have undefined count");
# show previous count for excluded code that had been hit
if ($bucket eq "ECB") {
$count_format = format_count(-$base_count, $count_field_width);
} else {
$count_format = " " x $count_field_width;
}
$result = $pchar . $base_count;
} else {
if (!defined($count)) {
# this is manufactured data...make something up
$count = $curr_count;
}
defined($count) && "" ne $count or
die("code should have defined count");
if ($bucket eq 'LBC') {
$count_format = format_count(-$base_count, $count_field_width);
} else {
$count_format = format_count($count, $count_field_width);
}
$result = $pchar . $count;
}
# '$result' is used to generate the PNG frame.
# Only build the (per-source-line) diagnostic string when verbosity is
# actually high enough to print it -- info() would otherwise discard
# the freshly-concatenated string on every single line.
info(2,
" $bucket: line=$line " .
(defined($count) ? "count= $count " : "") .
' curr=' .
(defined($curr_count) ? $curr_count : '-') .
' base=' .
(defined($base_count) ? $base_count : '-') . "\n"
) if ($lcovutil::verbose >= 2);
}
$result .= ":" . $source;
# a coverpoint of a multi-line statement has the date and owner of the
# statement - see 'SourceFile::spanAnnotation' - which is where it is
# counted, in '_countLineTlaData': the statement's own line coverpoint,
# and a baseline one on a later line of it, which the current data merged
# into it
my $attribution;
my ($stmtFirst, $stmtLast) = $fileCovInfo->statement($line);
if (defined($stmtFirst) &&
defined($bucket) &&
($SummaryInfo::tlaLocation{$bucket} & 0x1)) {
$attribution = $sourceDetail->attribution($line);
if ($attribution == $srcline) {
$attribution = undef;
} else {
$src_owner = $attribution->owner();
$src_age = $attribution->age();
}
}
my $tooltip = '';
if (@SourceFile::annotateScript &&
$SourceFile::annotateTooltip ne '') {
my $format = sub {
my $lineData = shift;
my $commitId = $lineData->commit();
return undef
unless (defined($commitId) &&
$commitId ne 'NONE');
my $text = $SourceFile::annotateTooltip;
my $date = $lineData->date();
$date =~ s/(T.+)$//; # just the year/month/day part
foreach my $p (['%U', $lineData->owner()],
['%F', $lineData->full_name()],
['%D', $lineData->date()],
['%d', $date],
['%A', $lineData->age()],
['%C', $commitId],
['%l', $lineData->line()],
) {
# escape the substituted value, not the assembled tooltip: the
# template is the user's own and may legitimately contain
# markup, but the annotation fields come from an external
# script - and a '"' in an author's full name terminates the
# attribute this ends up inside, while a bare '&' is an
# undefined entity reference. The owner column, a hundred
# lines below, escapes the same value already
my $value = escape_html($p->[1]);
$text =~ s/$p->[0]/$value/g;
}
return $text;
};
my $own = &$format($sourceDetail->line($line));
if (defined($attribution)) {
# the statement's attribution, and then the line's own
my $stmt = &$format($attribution);
$own =
(defined($stmt) ? $stmt : '') .
" (statement $stmtFirst-$stmtLast)" .
(defined($own) ? "
$own" : '');
}
$tooltip = " title=\"$own\"" if defined($own);
}
# the decorated source text of this line, computed here because the line
# number cell is written before the source text is
my $callgraphSource = callgraphDecorateSource($source, $cbdata, $line)
if $lcovutil::callgraph_coverage;
# Write out a line number navigation anchor every $nav_resolution
# lines if necessary
$anchor_start = "";
$anchor_end = "";
# *************************************************************
$html = $anchor_start;
# we want to colorize the date/owner part of un-hit lines only
my $html_continuation_leader = ""; # for continued lines
if (defined($main::show_dateBins) &&
$sourceDetail->isProjectFile()) {
DATE_SECTION: {
my $ageLen = $main::age_field_width;
my $ownerLen = $main::owner_field_width;
# need to space over on continuation lines
$html_continuation_leader = ' ' x ($ageLen + $ownerLen + 2);
if (!defined($count) &&
(!defined($main::show_nonCodeOwners) ||
0 == $main::show_nonCodeOwners) &&
(!defined($bucket) ||
!exists($SummaryInfo::excludedTla{$bucket}))
) {
# suppress date- and owner entry on non-code lines
$html .= $html_continuation_leader;
last DATE_SECTION;
}
my $span = "";
my $endspan = "";
my $bgclass = "";
if (defined($count) && 0 == $count) {
# probably want to pick a color based on which
# date bin it is in.
# right now, picking based on TLA.
$bgclass = " class=\"tlaBg$bucket\""
if (defined($bucket) &&
!exists($SummaryInfo::excludedTla{$bucket}));
#$html .= "";
if ("" ne $source_format) {
OWNER: {
if (!defined($src_owner) || !defined($src_age)) {
# maybe this should be a different error type?
lcovutil::ignorable_error(
$lcovutil::ERROR_UNMAPPED_LINE,
"undefined owner/age for $bucket $line " .
$sourceDetail->path());
last OWNER;
}
# add a 'title="tooltip"' popup - to give owner, date, etc
# (the owner name is escaped: see the per-line tooltip)
my $who = escape_html($src_owner);
my $title =
'span title="' . $who . " $src_age days ago";
if (defined($main::show_dateBins)) {
my $bin = SummaryInfo::findAgeBin($src_age);
$title .=
" (bin $bin: " .
$SummaryInfo::ageGroupHeader[$bin] . ")";
}
$title .= "\"";
$span = $source_format;
$span =~ s/span/$title/;
$endspan = "";
}
}
} # OWNER block
# determine if this line is going to be the target of a 'date', 'owner'
# or TLA navigation href.
# - it is possible for any of these to have changed from the previous
# line, even if the others are unchanged:
# - same TLA but different author
# - same author but different date bin, .. and so on
# If it is a leader, then we need to insert the 'owner' and/or 'date'
# link to go to the next group in this bin - even if the owner or
# date bin has not changed from the previous line)
my $tlaChanged = defined($bucket) && $prevData[0] ne $bucket;
my $needOwnerHref = @SourceFile::annotateScript &&
($tlaChanged ||
(defined($bucket) && $prevData[1] ne $src_owner));
my $newBin = SummaryInfo::findAgeBin($src_age);
defined($prevData[2]) || $line == 1 or
die("unexpected uninitialized age");
my $needDateHref = (
$tlaChanged || (defined($bucket) &&
SummaryInfo::findAgeBin($prevData[2]) != $newBin)
);
if ($needDateHref) {
my $matchLine = $cbdata->nextDate($newBin, $bucket);
$needDateHref = 0
if (defined($matchLine) && $matchLine != $line);
}
if ($needOwnerHref) {
# slightly complicated logic:
# - there can be non-code lines owned by someone else
# between code lines owned by '$src_owner', such that the
# all the code lines have the same TLA.
# In that case, we just insert an href at the top of the
# block to take us past all of them - to the next code block
# owned by $src_owner with this TLA, which separated by at least
# one line of code either owned by someone else, or with a different
# TLA.
my $matchLine = $cbdata->nextOwner($src_owner, $bucket);
# don't insert the owner href if this isn't the line we wanted
$needOwnerHref = 0
if (defined($matchLine) && $matchLine != $line);
}
my $age = $cbdata->age($src_age, $line);
my $owner = $cbdata->owner($src_owner);
# this HTML block turns into
# "int name " <- note trailing space
# .. but the age and name might be hrefs
$html .= $span;
# then 5 characters of 'age' (might be empty)
if ($needDateHref) {
# next line with this TLA, in this date bin
my $next =
$sourceDetail->nextInDateBin($newBin, $bucket, $line);
$cbdata->nextDate($newBin, $bucket, $next);
$next = defined($next) ? "L$next" : "top";
my $dateBin = $SummaryInfo::ageGroupHeader[$newBin];
my $label =
$main::use_legacyLabels ?
$SummaryInfo::tlaToLegacySrcLabel{$bucket} :
$bucket;
my $popup =
" title=\"next $label in “$dateBin” bin\"";
$html .= ((' ' x ($ageLen - length($src_age))) .
"$src_age ");
} else {
$html .= sprintf("%${ageLen}s ", $age);
}
if ($needOwnerHref) {
# next line with this TLA, by this owner..
my $next =
$sourceDetail->nextInOwnerBin($src_owner, $bucket, $line);
$cbdata->nextOwner($src_owner, $bucket, $next);
$next = defined($next) ? "L$next" : "top";
my $label =
$main::use_legacyLabels ?
$SummaryInfo::tlaToLegacySrcLabel{$bucket} :
$bucket;
my $popup =
" title=\"next $label in “" .
escape_html($src_owner) .
"” bin\"";
# NOTE: see note below about firefox nested span bug.
# this code just arranges to wrap an explicit 'span' around
# the space.
my $nspace = $ownerLen - length($src_owner);
my $space = $nspace > 0 ? (' ' x $nspace) : '';
my $href = "" .
escape_html(substr($src_owner, 0, $ownerLen)) . '';
if ('' ne $bgclass &&
'' ne $space) {
$html .= "$endspan$href$span";
} else {
$html .= $href;
}
$html .= $space;
} else {
# pad first, then escape: the padding is a column width in
# characters, and escaping makes the string longer
$html .= escape_html(sprintf("%-${ownerLen}s", $owner));
}
$html .= $endspan . ' '; # add trailing space
}
} # DATE_SECTION
# use a different HTML tag if there are deleted lines here
my $deletedLines = $fileCovInfo->deletedLineData($line);
my $lineNumTag = 'lineNum';
my $lineNumTitle = '';
if (defined($deletedLines)) {
my $first = $deletedLines->[0];
my $last = $deletedLines->[1];
die("invalid deleted lines array") unless $first <= $last;
my $count = $last - $first + 1;
$lineNumTitle = ' title="'
.
(($first != $last) ?
"removed $count lines ([$first:$last] inclusive)" :
"removed line $first") .
' from baseline version"';
$lineNumTag = 'lineNumWithDelete';
}
my $lineNumSpan = "";
my $lineNumText = sprintf('%8d', $line);
$html .= "$lineNumSpan$lineNumText ";
#printf("tla= " . $tla);
#printf("html= " . $html);
$html .= shift(@br_html) . ":" if ($showBranches);
$html .= shift(@mcdc_html) . ":" if ($showMcdc);
$tla = ""
if (!defined($main::show_tla));
# NOTE: the 'html2lcov' tool reverses this rendering to recover the original
# source. It relies on the row layout emitted below: a fixed-width gutter
# (line-number, optional branch/MC/DC, and hit-count columns) followed by a
# ' : ' (space-colon-space) separator and then the verbatim source text.
# The gutter width is user-controllable (via the field-width options), so
# html2lcov does not hard-code it; instead it locates the separator as the
# single ' : ' offset common to every row of the page. That works only so
# long as ' : ' is the LAST thing before the source and appears nowhere
# else in the gutter -- the branch/MC/DC columns end with a bare ':' (no
# leading space) and the count column is right-justified digits/spaces.
# The source itself may legitimately contain ' : ' (a C/C++/Verilog/Perl
# ternary 'a ? b : c', a ':' label, a base-class list), which is fine
# because it is always to the RIGHT of this separator. Preserve this
# property if you change the layout, or html2lcov will mis-recover source.
die( "html2lcov depends on ' : ' separating the hit-count column from the "
. "source; hit-count field '$count_format' must not contain it")
if (index($count_format, ' : ') >= 0);
# 'source_format is the colorization, then the 3-letter TLA,
# then the hit count, then the source line
if ($tlaIsHref) {
# there seems to be a bug in firefox:
# link whatever
# renders as if the 'span' didn't exist (so the colorization of the
# link end - and the rest of the line doesn't pick up attributes
# from class 'foo'.
# If I emit it as:
# link whatever
# (i.e., do not nest anchor inside the span) - then it works
$html .= "$tla$source_format $count_format : ";
} else {
$html .= "$source_format$tla $count_format : ";
}
# a later line of a multi-line statement has no coverpoint of its own:
# its source text has the color of the statement's - but its count,
# category and date/owner columns stay empty
my $continuation;
if (!$source_format &&
defined($stmtFirst) &&
$stmtFirst < $line) {
my $leader = $fileCovInfo->lineMap()->{$stmtFirst};
$continuation = $leader->tla()
if (defined($leader) && $leader->in_curr());
}
$html .= "" if defined($continuation);
$html .=
defined($callgraphSource) ? $callgraphSource : escape_html($source);
$html .= "" if ($source_format || defined($continuation));
$html .= $anchor_end . "\n";
write_html($handle, $html);
# Add lines for overlong branch and/or MC/DC information
while (@br_html || @mcdc_html) {
my $br = @br_html ? shift(@br_html) : '';
my $mc = @mcdc_html ? shift(@mcdc_html) : '';
if ($mc) {
# space over far enough to line up with MC/DC extension column
# remove the span and other HTML
my $s = $br;
foreach my $tag ('a', 'span') {
$s =~ s/(<\/$tag>|<$tag.+?>)//g;
}
$br .= ' ' x ($br_field_width - length($s)) . ' ';
die("unexpected lengths") unless $br_field_width >= length($s);
}
write_html($handle,
"$html_continuation_leader$lineNumSpan" .
' ' x 8 .
" $br$mc\n");
}
# *************************************************************
return ($result);
}
#
# write_source_epilog(filehandle)
#
# Write end of source code table.
#
sub write_source_epilog(*)
{
# *************************************************************
write_html($_[0], <
|
