make/scripts/webrev.ksh

#!/bin/ksh -p
#
# CDDL HEADER START
#
# The contents of this file are subject to the terms of the
# Common Development and Distribution License (the "License").
# You may not use this file except in compliance with the License.
#
# You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
# or http://www.opensolaris.org/os/licensing.
# See the License for the specific language governing permissions
# and limitations under the License.
#
# When distributing Covered Code, include this CDDL HEADER in each
# file and include the License file at usr/src/OPENSOLARIS.LICENSE.
# If applicable, add the following below this CDDL HEADER, with the
# fields enclosed by brackets "[]" replaced with your own identifying
# information: Portions Copyright [yyyy] [name of copyright owner]
#
# CDDL HEADER END
#
# Copyright (c) 2008, 2013, Oracle and/or its affiliates. All rights reserved.
# Use is subject to license terms.
#
# This script takes a file list and a workspace and builds a set of html files
# suitable for doing a code review of source changes via a web page.
# Documentation is available via 'webrev -h'.
#

WEBREV_UPDATED=25.1-hg+openjdk.java.net

HTML='<?xml version="1.0"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">\n'

FRAMEHTML='<?xml version="1.0"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Frameset//EN"
    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-frameset.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">\n'

STDHEAD='<meta charset="utf-8">
<meta http-equiv="cache-control" content="no-cache" />
<meta http-equiv="Pragma" content="no-cache" />
<meta http-equiv="Expires" content="-1" />
<!--
   Note to customizers: the body of the webrev is IDed as SUNWwebrev
   to allow easy overriding by users of webrev via the userContent.css
   mechanism available in some browsers.

   For example, to have all "removed" information be red instead of
   brown, set a rule in your userContent.css file like:

       body#SUNWwebrev span.removed { color: red ! important; }
-->
<style type="text/css" media="screen">
body {
    background-color: #eeeeee;
}
hr {
    border: none 0;
    border-top: 1px solid #aaa;
    height: 1px;
}
div.summary {
    font-size: .8em;
    border-bottom: 1px solid #aaa;
    padding-left: 1em;
    padding-right: 1em;
}
div.summary h2 {
    margin-bottom: 0.3em;
}
div.summary table th {
    text-align: right;
    vertical-align: top;
    white-space: nowrap;
}
span.lineschanged {
    font-size: 0.7em;
}
span.oldmarker {
    color: red;
    font-size: large;
    font-weight: bold;
}
span.newmarker {
    color: green;
    font-size: large;
    font-weight: bold;
}
span.removed {
    color: brown;
}
span.changed {
    color: blue;
}
span.new {
    color: blue;
    font-weight: bold;
}
a.print { font-size: x-small; }

</style>

<style type="text/css" media="print">
pre { font-size: 0.8em; font-family: courier, monospace; }
span.removed { color: #444; font-style: italic }
span.changed { font-weight: bold; }
span.new { font-weight: bold; }
span.newmarker { font-size: 1.2em; font-weight: bold; }
span.oldmarker { font-size: 1.2em; font-weight: bold; }
a.print {display: none}
hr { border: none 0; border-top: 1px solid #aaa; height: 1px; }
</style>
'

#
# UDiffs need a slightly different CSS rule for 'new' items (we don't
# want them to be bolded as we do in cdiffs or sdiffs).
#
UDIFFCSS='
<style type="text/css" media="screen">
span.new {
    color: blue;
    font-weight: normal;
}
</style>
'

#
# input_cmd | html_quote | output_cmd
# or
# html_quote filename | output_cmd
#
# Make a piece of source code safe for display in an HTML <pre> block.
#
html_quote()
{
	sed -e "s/&/\&amp;/g" -e "s/&amp;#\([x]*[0-9A-Fa-f]\{2,5\}\);/\&#\1;/g" -e "s/</\&lt;/g" -e "s/>/\&gt;/g" "$@" | expand
}

#
# input_cmd | html_quote | output_cmd
# or
# html_dequote filename | output_cmd
#
# Replace HTML entities with literals
#
html_dequote()
{
	sed -e "s/&quot;/\"/g" -e "s/&apos;/\'/g" -e "s/&amp;/\&/g" -e "s/&lt;/<'/g" -e "s/&gt;/>/g" "$@" | expand
}

#
# input_cmd | bug2url | output_cmd
#
# Scan for bugids and insert <a> links to the relevent bug database.
#
bug2url()
{
	sed -e 's|[0-9]\{5,\}|<a href=\"'$BUGURL$IDPREFIX'&\">&</a>|g'
}

#
# strip_unchanged <infile> | output_cmd
#
# Removes chunks of sdiff documents that have not changed. This makes it
# easier for a code reviewer to find the bits that have changed.
#
# Deleted lines of text are replaced by a horizontal rule. Some
# identical lines are retained before and after the changed lines to
# provide some context.  The number of these lines is controlled by the
# variable C in the $AWK script below.
#
# The script detects changed lines as any line that has a "<span class="
# string embedded (unchanged lines have no particular class and are not
# part of a <span>).  Blank lines (without a sequence number) are also
# detected since they flag lines that have been inserted or deleted.
#
strip_unchanged()
{
	$AWK '
	BEGIN	{ C = c = 20 }
	NF == 0 || /span class=/ {
		if (c > C) {
			c -= C
			inx = 0
			if (c > C) {
				print "\n</pre><hr></hr><pre>"
				inx = c % C
				c = C
			}

			for (i = 0; i < c; i++)
				print ln[(inx + i) % C]
		}
		c = 0;
		print
		next
	}
	{	if (c >= C) {
			ln[c % C] = $0
			c++;
			next;
		}
		c++;
		print
	}
	END	{ if (c > (C * 2)) print "\n</pre><hr></hr>" }

	' $1
}

#
# sdiff_to_html
#
# This function takes two files as arguments, obtains their diff, and
# processes the diff output to present the files as an HTML document with
# the files displayed side-by-side, differences shown in color.  It also
# takes a delta comment, rendered as an HTML snippet, as the third
# argument.  The function takes two files as arguments, then the name of
# file, the path, and the comment.  The HTML will be delivered on stdout,
# e.g.
#
#   $ sdiff_to_html old/usr/src/tools/scripts/webrev.sh \
#         new/usr/src/tools/scripts/webrev.sh \
#         webrev.sh usr/src/tools/scripts \
#         '<a href="https://bugs.openjdk.java.net/browse/JDK-1234567">
#          JDK-1234567</a> my bugid' > <file>.html
#
# framed_sdiff() is then called which creates $2.frames.html
# in the webrev tree.
#
# FYI: This function is rather unusual in its use of awk.  The initial
# diff run produces conventional diff output showing changed lines mixed
# with editing codes.  The changed lines are ignored - we're interested in
# the editing codes, e.g.
#
#      8c8
#      57a61
#      63c66,76
#      68,93d80
#      106d90
#      108,110d91
#
#  These editing codes are parsed by the awk script and used to generate
#  another awk script that generates HTML, e.g the above lines would turn
#  into something like this:
#
#      BEGIN { printf "<pre>\n" }
#      function sp(n) {for (i=0;i<n;i++)printf "\n"}
#      function wl(n) {printf "<font color=%s>%4d %s </font>\n", n, NR, $0}
#      NR==8           {wl("#7A7ADD");next}
#      NR==54          {wl("#7A7ADD");sp(3);next}
#      NR==56          {wl("#7A7ADD");next}
#      NR==57          {wl("black");printf "\n"; next}
#        :               :
#
#  This script is then run on the original source file to generate the
#  HTML that corresponds to the source file.
#
#  The two HTML files are then combined into a single piece of HTML that
#  uses an HTML table construct to present the files side by side.  You'll
#  notice that the changes are color-coded:
#
#   black     - unchanged lines
#   blue      - changed lines
#   bold blue - new lines
#   brown     - deleted lines
#
#  Blank lines are inserted in each file to keep unchanged lines in sync
#  (side-by-side).  This format is familiar to users of sdiff(1) or
#  Teamware's filemerge tool.
#
sdiff_to_html()
{
	diff -b $1 $2 > /tmp/$$.diffs

	TNAME=$3
	TPATH=$4
	COMMENT=$5

	#
	#  Now we have the diffs, generate the HTML for the old file.
	#
	$AWK '
	BEGIN	{
		printf "function sp(n) {for (i=0;i<n;i++)printf \"\\n\"}\n"
		printf "function removed() "
		printf "{printf \"<span class=\\\"removed\\\">%%4d %%s</span>\\n\", NR, $0}\n"
		printf "function changed() "
		printf "{printf \"<span class=\\\"changed\\\">%%4d %%s</span>\\n\", NR, $0}\n"
		printf "function bl() {printf \"%%4d %%s\\n\", NR, $0}\n"
}
	/^</	{next}
	/^>/	{next}
	/^---/	{next}

	{
	split($1, a, /[cad]/) ;
	if (index($1, "a")) {
		if (a[1] == 0) {
			n = split(a[2], r, /,/);
			if (n == 1)
				printf "BEGIN\t\t{sp(1)}\n"
			else
				printf "BEGIN\t\t{sp(%d)}\n",\
				(r[2] - r[1]) + 1
			next
		}

		printf "NR==%s\t\t{", a[1]
		n = split(a[2], r, /,/);
		s = r[1];
		if (n == 1)
			printf "bl();printf \"\\n\"; next}\n"
		else {
			n = r[2] - r[1]
			printf "bl();sp(%d);next}\n",\
			(r[2] - r[1]) + 1
		}
		next
	}
	if (index($1, "d")) {
		n = split(a[1], r, /,/);
		n1 = r[1]
		n2 = r[2]
		if (n == 1)
			printf "NR==%s\t\t{removed(); next}\n" , n1
		else
			printf "NR==%s,NR==%s\t{removed(); next}\n" , n1, n2
		next
	}
	if (index($1, "c")) {
		n = split(a[1], r, /,/);
		n1 = r[1]
		n2 = r[2]
		final = n2
		d1 = 0
		if (n == 1)
			printf "NR==%s\t\t{changed();" , n1
		else {
			d1 = n2 - n1
			printf "NR==%s,NR==%s\t{changed();" , n1, n2
		}
		m = split(a[2], r, /,/);
		n1 = r[1]
		n2 = r[2]
		if (m > 1) {
			d2  = n2 - n1
			if (d2 > d1) {
				if (n > 1) printf "if (NR==%d)", final
				printf "sp(%d);", d2 - d1
			}
		}
		printf "next}\n" ;

		next
	}
	}

	END	{ printf "{printf \"%%4d %%s\\n\", NR, $0 }\n" }
	' /tmp/$$.diffs > /tmp/$$.file1

	#
	#  Now generate the HTML for the new file
	#
	$AWK '
	BEGIN	{
		printf "function sp(n) {for (i=0;i<n;i++)printf \"\\n\"}\n"
		printf "function new() "
		printf "{printf \"<span class=\\\"new\\\">%%4d %%s</span>\\n\", NR, $0}\n"
		printf "function changed() "
		printf "{printf \"<span class=\\\"changed\\\">%%4d %%s</span>\\n\", NR, $0}\n"
		printf "function bl() {printf \"%%4d %%s\\n\", NR, $0}\n"
	}

	/^</	{next}
	/^>/	{next}
	/^---/	{next}

	{
	split($1, a, /[cad]/) ;
	if (index($1, "d")) {
		if (a[2] == 0) {
			n = split(a[1], r, /,/);
			if (n == 1)
				printf "BEGIN\t\t{sp(1)}\n"
			else
				printf "BEGIN\t\t{sp(%d)}\n",\
				(r[2] - r[1]) + 1
			next
		}

		printf "NR==%s\t\t{", a[2]
		n = split(a[1], r, /,/);
		s = r[1];
		if (n == 1)
			printf "bl();printf \"\\n\"; next}\n"
		else {
			n = r[2] - r[1]
			printf "bl();sp(%d);next}\n",\
			(r[2] - r[1]) + 1
		}
		next
	}
	if (index($1, "a")) {
		n = split(a[2], r, /,/);
		n1 = r[1]
		n2 = r[2]
		if (n == 1)
			printf "NR==%s\t\t{new() ; next}\n" , n1
		else
			printf "NR==%s,NR==%s\t{new() ; next}\n" , n1, n2
		next
	}
	if (index($1, "c")) {
		n = split(a[2], r, /,/);
		n1 = r[1]
		n2 = r[2]
		final = n2
		d2 = 0;
		if (n == 1) {
			final = n1
			printf "NR==%s\t\t{changed();" , n1
		} else {
			d2 = n2 - n1
			printf "NR==%s,NR==%s\t{changed();" , n1, n2
		}
		m = split(a[1], r, /,/);
		n1 = r[1]
		n2 = r[2]
		if (m > 1) {
			d1  = n2 - n1
			if (d1 > d2) {
				if (n > 1) printf "if (NR==%d)", final
				printf "sp(%d);", d1 - d2
			}
		}
		printf "next}\n" ;
		next
	}
	}
	END	{ printf "{printf \"%%4d %%s\\n\", NR, $0 }\n" }
	' /tmp/$$.diffs > /tmp/$$.file2

	#
	# Post-process the HTML files by running them back through $AWK
	#
	html_quote < $1 | $AWK -f /tmp/$$.file1 > /tmp/$$.file1.html

	html_quote < $2 | $AWK -f /tmp/$$.file2 > /tmp/$$.file2.html

	#
	# Now combine into a valid HTML file and side-by-side into a table
	#
	print "$HTML<head>$STDHEAD"
	print "<title>$WNAME Sdiff $TPATH </title>"
	print "</head><body id=\"SUNWwebrev\">"
	print "<h2>$TPATH/$TNAME</h2>"
        print "<a class=\"print\" href=\"javascript:print()\">Print this page</a>"
	print "<pre>$COMMENT</pre>\n"
	print "<table><tr valign=\"top\">"
	print "<td><pre>"

	strip_unchanged /tmp/$$.file1.html

	print "</pre></td><td><pre>"

	strip_unchanged /tmp/$$.file2.html

	print "</pre></td>"
	print "</tr></table>"
	print "</body></html>"

	framed_sdiff $TNAME $TPATH /tmp/$$.file1.html /tmp/$$.file2.html \
	    "$COMMENT"
}


#
# framed_sdiff <filename> <filepath> <lhsfile> <rhsfile> <comment>
#
# Expects lefthand and righthand side html files created by sdiff_to_html.
# We use insert_anchors() to augment those with HTML navigation anchors,
# and then emit the main frame.  Content is placed into:
#
#    $WDIR/DIR/$TNAME.lhs.html
#    $WDIR/DIR/$TNAME.rhs.html
#    $WDIR/DIR/$TNAME.frames.html
#
# NOTE: We rely on standard usage of $WDIR and $DIR.
#
function framed_sdiff
{
	typeset TNAME=$1
	typeset TPATH=$2
	typeset lhsfile=$3
	typeset rhsfile=$4
	typeset comments=$5
	typeset RTOP

	# Enable html files to access WDIR via a relative path.
	RTOP=$(relative_dir $TPATH $WDIR)

	# Make the rhs/lhs files and output the frameset file.
	print "$HTML<head>$STDHEAD" > $WDIR/$DIR/$TNAME.lhs.html

	cat >> $WDIR/$DIR/$TNAME.lhs.html <<-EOF
	    <script type="text/javascript" src="$RTOP/ancnav.js"></script>
	    </head>
	    <body id="SUNWwebrev" onkeypress="keypress(event);">
	    <a name="0"></a>
	    <pre>$comments</pre><hr></hr>
	EOF

	cp $WDIR/$DIR/$TNAME.lhs.html $WDIR/$DIR/$TNAME.rhs.html

	insert_anchors $lhsfile >> $WDIR/$DIR/$TNAME.lhs.html
	insert_anchors $rhsfile >> $WDIR/$DIR/$TNAME.rhs.html

	close='</body></html>'

	print $close >> $WDIR/$DIR/$TNAME.lhs.html
	print $close >> $WDIR/$DIR/$TNAME.rhs.html

	print "$FRAMEHTML<head>$STDHEAD" > $WDIR/$DIR/$TNAME.frames.html
	print "<title>$WNAME Framed-Sdiff " \
	    "$TPATH/$TNAME</title> </head>" >> $WDIR/$DIR/$TNAME.frames.html
	cat >> $WDIR/$DIR/$TNAME.frames.html <<-EOF
	  <frameset rows="*,60">
	    <frameset cols="50%,50%">
	      <frame src="$TNAME.lhs.html" scrolling="auto" name="lhs" />
	      <frame src="$TNAME.rhs.html" scrolling="auto" name="rhs" />
	    </frameset>
	  <frame src="$RTOP/ancnav.html" scrolling="no" marginwidth="0"
	   marginheight="0" name="nav" />
	  <noframes>
            <body id="SUNWwebrev">
	      Alas 'frames' webrev requires that your browser supports frames
	      and has the feature enabled.
            </body>
	  </noframes>
	  </frameset>
	</html>
	EOF
}


#
# fix_postscript
#
# Merge codereview output files to a single conforming postscript file, by:
# 	- removing all extraneous headers/trailers
#	- making the page numbers right
#	- removing pages devoid of contents which confuse some
#	  postscript readers.
#
# From Casper.
#
function fix_postscript
{
	infile=$1

	cat > /tmp/$$.crmerge.pl << \EOF

	print scalar(<>);		# %!PS-Adobe---
	print "%%Orientation: Landscape\n";

	$pno = 0;
	$doprint = 1;

	$page = "";

	while (<>) {
		next if (/^%%Pages:\s*\d+/);

		if (/^%%Page:/) {
			if ($pno == 0 || $page =~ /\)S/) {
				# Header or single page containing text
				print "%%Page: ? $pno\n" if ($pno > 0);
				print $page;
				$pno++;
			} else {
				# Empty page, skip it.
			}
			$page = "";
			$doprint = 1;
			next;
		}

		# Skip from %%Trailer of one document to Endprolog
		# %%Page of the next
		$doprint = 0 if (/^%%Trailer/);
		$page .= $_ if ($doprint);
	}

	if ($page =~ /\)S/) {
		print "%%Page: ? $pno\n";
		print $page;
	} else {
		$pno--;
	}
	print "%%Trailer\n%%Pages: $pno\n";
EOF

	$PERL /tmp/$$.crmerge.pl < $infile
}


#
# input_cmd | insert_anchors | output_cmd
#
# Flag blocks of difference with sequentially numbered invisible
# anchors.  These are used to drive the frames version of the
# sdiffs output.
#
# NOTE: Anchor zero flags the top of the file irrespective of changes,
# an additional anchor is also appended to flag the bottom.
#
# The script detects changed lines as any line that has a "<span
# class=" string embedded (unchanged lines have no class set and are
# not part of a <span>.  Blank lines (without a sequence number)
# are also detected since they flag lines that have been inserted or
# deleted.
#
function insert_anchors
{
	$AWK '
	function ia() {
		# This should be able to be a singleton <a /> but that
		# seems to trigger a bug in firefox a:hover rule processing
		printf "<a name=\"%d\" id=\"anc%d\"></a>", anc, anc++;
	}

	BEGIN {
		anc=1;
		inblock=1;
		printf "<pre>\n";
	}
	NF == 0 || /^<span class=/ {
		if (inblock == 0) {
			ia();
			inblock=1;
		}
		print;
		next;
	}
	{
		inblock=0;
		print;
	}
	END {
		ia();

		printf "<b style=\"font-size: large; color: red\">";
		printf "--- EOF ---</b>"
        	for(i=0;i<8;i++) printf "\n\n\n\n\n\n\n\n\n\n";
		printf "</pre>"
		printf "<form name=\"eof\">";
		printf "<input name=\"value\" value=\"%d\" type=\"hidden\" />",
		    anc - 1;
		printf "</form>";
	}
	' $1
}


#
# relative_dir
#
# Print a relative return path from $1 to $2.  For example if
# $1=/tmp/myreview/raw_files/usr/src/tools/scripts and $2=/tmp/myreview,
# this function would print "../../../../".
#
# In the event that $1 is not in $2 a warning is printed to stderr,
# and $2 is returned-- the result of this is that the resulting webrev
# is not relocatable.
#
function relative_dir
{
    d1=$1
    d2=$2
    if [[ "$d1" == "." ]]; then
	print "."
    else
	typeset cur="${d1##$d2?(/)}"
	typeset ret=""
	if [[ $d2 == $cur ]]; then   # Should never happen.
		# Should never happen.
		print -u2 "\nWARNING: relative_dir: \"$1\" not relative "
		print -u2 "to \"$2\".  Check input paths.  Framed webrev "
		print -u2 "will not be relocatable!"
		print $2
		return
	fi

	while [[ -n ${cur} ]];
	do
		cur=${cur%%*(/)*([!/])}
		if [[ -z $ret ]]; then
			ret=".."
		else
			ret="../$ret"
		fi
	done
	print $ret
    fi
}


#
# frame_nav_js
#
# Emit javascript for frame navigation
#
function frame_nav_js
{
cat << \EOF
var myInt;
var scrolling=0;
var sfactor = 3;
var scount=10;

function scrollByPix() {
	if (scount<=0) {
		sfactor*=1.2;
		scount=10;
	}
	parent.lhs.scrollBy(0,sfactor);
	parent.rhs.scrollBy(0,sfactor);
	scount--;
}

function scrollToAnc(num) {

	// Update the value of the anchor in the form which we use as
	// storage for this value.  setAncValue() will take care of
	// correcting for overflow and underflow of the value and return
	// us the new value.
	num = setAncValue(num);

	// Set location and scroll back a little to expose previous
	// lines.
	//
	// Note that this could be improved: it is possible although
	// complex to compute the x and y position of an anchor, and to
	// scroll to that location directly.
	//
	parent.lhs.location.replace(parent.lhs.location.pathname + "#" + num);
	parent.rhs.location.replace(parent.rhs.location.pathname + "#" + num);

	parent.lhs.scrollBy(0,-30);
	parent.rhs.scrollBy(0,-30);
}

function getAncValue()
{
	return (parseInt(parent.nav.document.diff.real.value));
}

function setAncValue(val)
{
	if (val <= 0) {
		val = 0;
		parent.nav.document.diff.real.value = val;
		parent.nav.document.diff.display.value = "BOF";
		return (val);
	}

	//
	// The way we compute the max anchor value is to stash it
	// inline in the left and right hand side pages-- it's the same
	// on each side, so we pluck from the left.
	//
	maxval = parent.lhs.document.eof.value.value;
	if (val < maxval) {
		parent.nav.document.diff.real.value = val;
		parent.nav.document.diff.display.value = val.toString();
		return (val);
	}

	// this must be: val >= maxval
	val = maxval;
	parent.nav.document.diff.real.value = val;
	parent.nav.document.diff.display.value = "EOF";
	return (val);
}

function stopScroll() {
	if (scrolling==1) {
		clearInterval(myInt);
		scrolling=0;
	}
}

function startScroll() {
	stopScroll();
	scrolling=1;
	myInt=setInterval("scrollByPix()",10);
}

function handlePress(b) {

	switch (b) {
	    case 1 :
		scrollToAnc(-1);
		break;
	    case 2 :
		scrollToAnc(getAncValue() - 1);
		break;
	    case 3 :
		sfactor=-3;
		startScroll();
		break;
	    case 4 :
		sfactor=3;
		startScroll();
		break;
	    case 5 :
		scrollToAnc(getAncValue() + 1);
		break;
	    case 6 :
		scrollToAnc(999999);
		break;
	}
}

function handleRelease(b) {
	stopScroll();
}

function keypress(ev) {
	var keynum;
	var keychar;

	if (window.event) { // IE
		keynum = ev.keyCode;
	} else if (ev.which) { // non-IE
		keynum = ev.which;
	}

	keychar = String.fromCharCode(keynum);

	if (keychar == "k") {
		handlePress(2);
		return (0);
	} else if (keychar == "j" || keychar == " ") {
		handlePress(5);
		return (0);
	}
	return (1);
}

function ValidateDiffNum(){
	val = parent.nav.document.diff.display.value;
	if (val == "EOF") {
		scrollToAnc(999999);
		return;
	}

	if (val == "BOF") {
		scrollToAnc(0);
		return;
	}

        i=parseInt(val);
        if (isNaN(i)) {
                parent.nav.document.diff.display.value = getAncValue();
        } else {
                scrollToAnc(i);
        }
        return false;
}

EOF
}

#
# frame_navigation
#
# Output anchor navigation file for framed sdiffs.
#
function frame_navigation
{
	print "$HTML<head>$STDHEAD"

	cat << \EOF
<title>Anchor Navigation</title>
<meta http-equiv="Content-Script-Type" content="text/javascript" />
<meta http-equiv="Content-Type" content="text/html" />

<style type="text/css">
    div.button td { padding-left: 5px; padding-right: 5px;
		    background-color: #eee; text-align: center;
		    border: 1px #444 outset; cursor: pointer; }
    div.button a { font-weight: bold; color: black }
    div.button td:hover { background: #ffcc99; }
</style>
EOF

	print "<script type=\"text/javascript\" src=\"ancnav.js\"></script>"

	cat << \EOF
</head>
<body id="SUNWwebrev" bgcolor="#eeeeee" onload="document.diff.real.focus();"
	onkeypress="keypress(event);">
    <noscript lang="javascript">
      <center>
	<p><big>Framed Navigation controls require Javascript</big><br />
	Either this browser is incompatable or javascript is not enabled</p>
      </center>
    </noscript>
    <table width="100%" border="0" align="center">
	<tr>
          <td valign="middle" width="25%">Diff navigation:
          Use 'j' and 'k' for next and previous diffs; or use buttons
          at right</td>
	  <td align="center" valign="top" width="50%">
	    <div class="button">
	      <table border="0" align="center">
                  <tr>
		    <td>
		      <a onMouseDown="handlePress(1);return true;"
			 onMouseUp="handleRelease(1);return true;"
			 onMouseOut="handleRelease(1);return true;"
			 onClick="return false;"
			 title="Go to Beginning Of file">BOF</a></td>
		    <td>
		      <a onMouseDown="handlePress(3);return true;"
			 onMouseUp="handleRelease(3);return true;"
			 onMouseOut="handleRelease(3);return true;"
			 title="Scroll Up: Press and Hold to accelerate"
			 onClick="return false;">Scroll Up</a></td>
		    <td>
		      <a onMouseDown="handlePress(2);return true;"
			 onMouseUp="handleRelease(2);return true;"
			 onMouseOut="handleRelease(2);return true;"
			 title="Go to previous Diff"
			 onClick="return false;">Prev Diff</a>
		    </td></tr>

		  <tr>
		    <td>
		      <a onMouseDown="handlePress(6);return true;"
			 onMouseUp="handleRelease(6);return true;"
			 onMouseOut="handleRelease(6);return true;"
			 onClick="return false;"
			 title="Go to End Of File">EOF</a></td>
		    <td>
		      <a onMouseDown="handlePress(4);return true;"
			 onMouseUp="handleRelease(4);return true;"
			 onMouseOut="handleRelease(4);return true;"
			 title="Scroll Down: Press and Hold to accelerate"
			 onClick="return false;">Scroll Down</a></td>
		    <td>
		      <a onMouseDown="handlePress(5);return true;"
			 onMouseUp="handleRelease(5);return true;"
			 onMouseOut="handleRelease(5);return true;"
			 title="Go to next Diff"
			 onClick="return false;">Next Diff</a></td>
		  </tr>
              </table>
	    </div>
	  </td>
	  <th valign="middle" width="25%">
	    <form action="" name="diff" onsubmit="return ValidateDiffNum();">
		<input name="display" value="BOF" size="8" type="text" />
		<input name="real" value="0" size="8" type="hidden" />
	    </form>
	  </th>
	</tr>
    </table>
  </body>
</html>
EOF
}


#
# diff_to_html <filename> <filepath> { U | C } <comment>
#
# Processes the output of diff to produce an HTML file representing either
# context or unified diffs.
#
diff_to_html()
{
	TNAME=$1
	TPATH=$2
	DIFFTYPE=$3
	COMMENT=$4

	print "$HTML<head>$STDHEAD"
	print "<title>$WNAME ${DIFFTYPE}diff $TPATH</title>"

	if [[ $DIFFTYPE == "U" ]]; then
		print "$UDIFFCSS"
	fi

	cat <<-EOF
	</head>
	<body id="SUNWwebrev">
	<h2>$TPATH</h2>
        <a class="print" href="javascript:print()">Print this page</a>
	<pre>$COMMENT</pre>
        <pre>
EOF

	html_quote | $AWK '
	/^--- new/	{ next }
	/^\+\+\+ new/	{ next }
	/^--- old/	{ next }
	/^\*\*\* old/	{ next }
	/^\*\*\*\*/	{ next }
	/^-------/	{ printf "<center><h1>%s</h1></center>\n", $0; next }
	/^\@\@.*\@\@$/	{ printf "</pre><hr /><pre>\n";
			  printf "<span class=\"newmarker\">%s</span>\n", $0;
			  next}

	/^\*\*\*/	{ printf "<hr /><span class=\"oldmarker\">%s</span>\n", $0;
			  next}
	/^---/		{ printf "<span class=\"newmarker\">%s</span>\n", $0;
			  next}
	/^\+/		{printf "<span class=\"new\">%s</span>\n", $0; next}
	/^!/		{printf "<span class=\"changed\">%s</span>\n", $0; next}
	/^-/		{printf "<span class=\"removed\">%s</span>\n", $0; next}
			{printf "%s\n", $0; next}
	'

	print "</pre></body></html>\n"
}


#
# source_to_html { new | old } <filename>
#
# Process a plain vanilla source file to transform it into an HTML file.
#
source_to_html()
{
	WHICH=$1
	TNAME=$2

	print "$HTML<head>$STDHEAD"
	print "<title>$WHICH $TNAME</title>"
	print "<body id=\"SUNWwebrev\">"
	print "<pre>"
	html_quote | $AWK '{line += 1 ; printf "%4d %s\n", line, $0 }'
	print "</pre></body></html>"
}

comments_from_mercurial()
{
	fmt=$1
	pfile=$PWS/$2
	cfile=$CWS/$3

        logdir=`dirname $cfile`
        logf=`basename $cfile`
        if [ -d $logdir ]; then
            ( cd $logdir;
	        active=`hg status $logf 2>/dev/null`
                # If the output from 'hg status' is not empty, it means the file
                # hasn't been committed, so don't fetch comments.
	        if [[ -z $active ]] ; then
                    if [[ -n $ALL_CREV ]]; then
                        rev_opt=
                        for rev in $ALL_CREV; do
                            rev_opt="$rev_opt --rev $rev"
                        done
                        comm=`hg log $rev_opt --follow --template 'rev {rev} : {desc}\n' $logf`
                    elif [[ -n $FIRST_CREV ]]; then
		        comm=`hg log --rev $FIRST_CREV:tip --follow --template 'rev {rev} : {desc}\n' $logf`
                    else
		        comm=`hg log -l1 --follow --template 'rev {rev} : {desc}\n' $logf`
                    fi
	        else
	            comm=""
	        fi
	        if [[ $fmt == "text" ]]; then
	            print "$comm"
	            return
	        fi

	        print "$comm" | html_quote | bug2url
                )
        fi
}


#
# getcomments {text|html} filepath parentpath
#
# Fetch the comments depending on what SCM mode we're in.
#
getcomments()
{
	typeset fmt=$1
	typeset p=$2
	typeset pp=$3

	comments_from_mercurial $fmt $pp $p
}

#
# printCI <total-changed> <inserted> <deleted> <modified> <unchanged>
#
# Print out Code Inspection figures similar to sccs-prt(1) format.
#
function printCI
{
	integer tot=$1 ins=$2 del=$3 mod=$4 unc=$5
	typeset str
	if (( tot == 1 )); then
		str="line"
	else
		str="lines"
	fi
	printf '%d %s changed: %d ins; %d del; %d mod; %d unchg' \
	    $tot $str $ins $del $mod $unc
}


#
# difflines <oldfile> <newfile>
#
# Calculate and emit number of added, removed, modified and unchanged lines,
# and total lines changed, the sum of added + removed + modified.
#
function difflines
{
	integer tot mod del ins unc err
	typeset filename

	eval $( diff -e $1 $2 | $AWK '
	# Change range of lines: N,Nc
	/^[0-9]*,[0-9]*c$/ {
		n=split(substr($1,1,length($1)-1), counts, ",");
		if (n != 2) {
		    error=2
		    exit;
		}
		#
		# 3,5c means lines 3 , 4 and 5 are changed, a total of 3 lines.
		# following would be 5 - 3 = 2! Hence +1 for correction.
		#
		r=(counts[2]-counts[1])+1;

		#
		# Now count replacement lines: each represents a change instead
		# of a delete, so increment c and decrement r.
		#
		while (getline != /^\.$/) {
			c++;
			r--;
		}
		#
		# If there were more replacement lines than original lines,
		# then r will be negative; in this case there are no deletions,
		# but there are r changes that should be counted as adds, and
		# since r is negative, subtract it from a and add it to c.
		#
		if (r < 0) {
			a-=r;
			c+=r;
		}

		#
		# If there were more original lines than replacement lines, then
		# r will be positive; in this case, increment d by that much.
		#
		if (r > 0) {
			d+=r;
		}
		next;
	}

	# Change lines: Nc
	/^[0-9].*c$/ {
		# The first line is a replacement; any more are additions.
		if (getline != /^\.$/) {
			c++;
			while (getline != /^\.$/) a++;
		}
		next;
	}

	# Add lines: both Na and N,Na
	/^[0-9].*a$/ {
		while (getline != /^\.$/) a++;
		next;
	}

	# Delete range of lines: N,Nd
	/^[0-9]*,[0-9]*d$/ {
		n=split(substr($1,1,length($1)-1), counts, ",");
		if (n != 2) {
			error=2
			exit;
		}
		#
		# 3,5d means lines 3 , 4 and 5 are deleted, a total of 3 lines.
		# following would be 5 - 3 = 2! Hence +1 for correction.
		#
		r=(counts[2]-counts[1])+1;
		d+=r;
		next;
	}

	# Delete line: Nd.   For example 10d says line 10 is deleted.
	/^[0-9]*d$/ {d++; next}

	# Should not get here!
	{
		error=1;
		exit;
	}

	# Finish off - print results
	END {
		printf("tot=%d;mod=%d;del=%d;ins=%d;err=%d\n",
		    (c+d+a), c, d, a, error);
	}' )

	# End of $AWK, Check to see if any trouble occurred.
	if (( $? > 0 || err > 0 )); then
		print "Unexpected Error occurred reading" \
		    "\`diff -e $1 $2\`: \$?=$?, err=" $err
		return
	fi

	# Accumulate totals
	(( TOTL += tot ))
	(( TMOD += mod ))
	(( TDEL += del ))
	(( TINS += ins ))
	# Calculate unchanged lines
	unc=`wc -l < $1`
	if (( unc > 0 )); then
		(( unc -= del + mod ))
		(( TUNC += unc ))
	fi
	# print summary
	print "<span class=\"lineschanged\">\c"
	printCI $tot $ins $del $mod $unc
	print "</span>"
}

function outgoing_from_mercurial_forest
{
    hg foutgoing --template 'rev: {rev}\n' $OUTPWS | $FILTER | $AWK '
        BEGIN           {ntree=0}
        /^comparing/    {next}
        /^no changes/   {next}
        /^searching/    {next}
	/^\[.*\]$/	{tree=substr($1,2,length($1)-2);
                         trees[ntree++] = tree;
                         revs[tree]=-1;
                         next}
        /^rev:/   {rev=$2+0;
                   if (revs[tree] == -1 || rev < revs[tree])
                        { revs[tree] = rev; };
                  next;}
        END       {for (tree in trees)
                        { rev=revs[trees[tree]];
                          if (rev > 0)
                                {printf("%s %d\n",trees[tree],rev-1)}
                        }}' | while read LINE
    do
        set - $LINE
        TREE=$1
        REV=$2
        A=`hg -R $CWS/$TREE log --rev $REV --template '{node}'`
        FSTAT_OPT="--rev $A"
        print "Revision: $A $REV" >> $FLIST
        treestatus $TREE
    done
}

function flist_from_mercurial_forest
{
    rm -f $FLIST
    if [ -z "$Nflag" ]; then
        print " File list from hg foutgoing $PWS ..."
        outgoing_from_mercurial_forest
        HG_LIST_FROM_COMMIT=1
    fi
    if [ ! -f $FLIST ]; then
        # hg commit hasn't been run see what is lying around
        print "\n No outgoing, perhaps you haven't commited."
        print " File list from hg fstatus -mard ...\c"
        FSTAT_OPT=
        fstatus
        HG_LIST_FROM_COMMIT=
    fi
    print " Done."
}

#
# Used when dealing with the result of 'hg foutgoing'
# When now go down the tree and generate the change list
#
function treestatus
{
    TREE=$1
    HGCMD="hg -R $CWS/$TREE status $FSTAT_OPT"

    $HGCMD -mdn 2>/dev/null | $FILTER | while read F
    do
        echo $TREE/$F
    done >> $FLIST

    # Then all the added files
    # But some of these could have been "moved" or renamed ones or copied ones
    # so let's make sure we get the proper info
    # hg status -aC will produce something like:
    #	A subdir/File3
    #	A subdir/File4
    #	  File4
    #	A subdir/File5
    # The first and last are simple addition while the middle one
    # is a move/rename or a copy.  We can't distinguish from a rename vs a copy
    # without also getting the status of removed files.  The middle case above
    # is a rename if File4 is also shown a being removed.  If File4 is not a
    # removed file, then the middle case is a copy from File4 to subdir/File4
    # FIXME - we're not distinguishing copy from rename
    $HGCMD -aC | $FILTER | while read LINE; do
	ldone=""
	while [ -z "$ldone" ]; do
	    ldone="1"
	    set - $LINE
	    if [ $# -eq 2 -a "$1" == "A" ]; then
		AFILE=$2
		if read LINE2; then
		    set - $LINE2
		    if [ $# -eq 1 ]; then
			echo $TREE/$AFILE $TREE/$1 >>$FLIST
		    elif [ $# -eq 2 ]; then
			echo $TREE/$AFILE >>$FLIST
			LINE=$LINE2
			ldone=""
		    fi
		else
		    echo $TREE/$AFILE >>$FLIST
		fi
	    fi
	done
    done
    $HGCMD -rn | $FILTER | while read RFILE; do
	grep "$TREE/$RFILE" $FLIST >/dev/null
	if [ $? -eq 1 ]; then
	    echo $TREE/$RFILE >>$FLIST
	fi
    done
}

function fstatus
{
    #
    # forest extension is still being changed. For instance the output
    # of fstatus used to no prepend the tree path to filenames, but
    # this has changed recently. AWK code below does try to handle both
    # cases
    #
    hg fstatus -mdn $FSTAT_OPT 2>/dev/null | $FILTER | $AWK '
	/^\[.*\]$/	{tree=substr($1,2,length($1)-2); next}
	$1 != ""	{n=index($1,tree);
			 if (n == 0)
				{ printf("%s/%s\n",tree,$1)}
			 else
				{ printf("%s\n",$1)}}' >> $FLIST

    #
    # There is a bug in the output of fstatus -aC on recent versions: it
    # inserts a space between the name of the tree and the filename of the
    # old file. e.g.:
    #
    # $ hg fstatus -aC
    # [.]
    #
    # [MyWS]
    # A MyWS/subdir/File2
    #  MyWS/ File2
    #
    # [MyWS2]
    #

    hg fstatus -aC $FSTAT_OPT 2>/dev/null | $FILTER | $AWK '
	/^\[.*\]$/	{tree=substr($1,2,length($1)-2); next}
	/^A .*/		{n=index($2,tree);
			 if (n == 0)
				{ printf("A %s/%s\n",tree,$2)}
			 else
				{ printf("A %s\n",$2)};
			 next}
	/^ /		{n=index($1,tree);
			 if (n == 0)
				{ printf("%s/%s\n",tree,$1)}
			 else
				{ if (NF == 2)
					printf("%s/%s\n",tree,$2)
				  else
					printf("%s\n",$1)
				};
			 next}
	' | while read LINE; do
	ldone=""
	while [ -z "$ldone" ]; do
	    ldone="1"
	    set - $LINE
	    if [ $# -eq 2 -a "$1" == "A" ]; then
		AFILE=$2
		if read LINE2; then
		    set - $LINE2
		    if [ $# -eq 1 ]; then
			echo $AFILE $1 >>$FLIST
		    elif [ $# -eq 2 ]; then
			echo $AFILE >>$FLIST
			LINE=$LINE2
			ldone=""
		    fi
		else
		    echo $AFILE >>$FLIST
		fi
	    fi
	done
    done
    hg fstatus -rn $FSTAT_OPT 2>/dev/null | $FILTER | $AWK '
	/^\[.*\]$/	{tree=substr($1,2,length($1)-2); next}
	$1 != ""	{n=index($1,tree);
			 if (n == 0)
				{ printf("%s/%s\n",tree,$1)}
			 else
				{ printf("%s\n",$1)}}' | while read RFILE; do
	grep "$RFILE" $FLIST >/dev/null
	if [ $? -eq 1 ]; then
	    echo $RFILE >>$FLIST
	fi
    done
}

#
# flist_from_mercurial $PWS
#
# Only local file based repositories are supported at present
# since even though we can determine the list from the parent finding
# the changes is harder.
#
# We first look for any outgoing files, this is for when the user has
# run hg commit.  If we don't find any then we look with hg status.
#
# We need at least one of default-push or default paths set in .hg/hgrc
# If neither are set we don't know who to compare with.

function flist_from_mercurial
{
#	if [ "${PWS##ssh://}" != "$PWS" -o \
#	     "${PWS##http://}" != "$PWS" -o \
#	     "${PWS##https://}" != "$PWS" ]; then
#		print "Remote Mercurial repositories not currently supported."
#		print "Set default and/or default-push to a local repository"
#		exit
#	fi
    if [[ -n $forestflag ]]; then
        HG_LIST_FROM_COMMIT=
	flist_from_mercurial_forest
    else
        STATUS_REV=
        if [[ -n $rflag ]]; then
            STATUS_REV="--rev $PARENT_REV"
        elif [[ -n $OUTREV ]]; then
            STATUS_REV="--rev $OUTREV"
        else
            # hg commit hasn't been run see what is lying around
            print "\n No outgoing, perhaps you haven't commited."
        fi
	# First let's list all the modified or deleted files

	hg status $STATUS_REV -mdn | $FILTER > $FLIST

	# Then all the added files
	# But some of these could have been "moved" or renamed ones
	# so let's make sure we get the proper info
	# hg status -aC will produce something like:
	#	A subdir/File3
	#	A subdir/File4
	#	  File4
	#	A subdir/File5
        # The first and last are simple addition while the middle one
        # is a move/rename or a copy.  We can't distinguish from a rename vs a copy
        # without also getting the status of removed files.  The middle case above
        # is a rename if File4 is also shown a being removed.  If File4 is not a
        # removed file, then the middle case is a copy from File4 to subdir/File4
        # FIXME - we're not distinguishing copy from rename

	hg status $STATUS_REV -aC | $FILTER >$FLIST.temp
	while read LINE; do
	    ldone=""
	    while [ -z "$ldone" ]; do
		ldone="1"
		set - $LINE
		if [ $# -eq 2 -a "$1" == "A" ]; then
		    AFILE=$2
		    if read LINE2; then
			set - $LINE2
			if [ $# -eq 1 ]; then
			    echo $AFILE $1 >>$FLIST
			elif [ $# -eq 2 ]; then
			    echo $AFILE >>$FLIST
			    LINE=$LINE2
			    ldone=""
			fi
		    else
			echo $AFILE >>$FLIST
		    fi
		fi
	    done
	done < $FLIST.temp
	hg status $STATUS_REV -rn | $FILTER > $FLIST.temp
	while read RFILE; do
	    grep "$RFILE" $FLIST >/dev/null
	    if [ $? -eq 1 ]; then
		echo $RFILE >>$FLIST
	    fi
	done < $FLIST.temp
	rm -f $FLIST.temp
    fi
}

function env_from_flist
{
	[[ -r $FLIST ]] || return

	#
	# Use "eval" to set env variables that are listed in the file
	# list.  Then copy those into our local versions of those
	# variables if they have not been set already.
	#
	eval `sed -e "s/#.*$//" $FLIST | grep = `

	[[ -z $codemgr_ws && -n $CODEMGR_WS ]] && codemgr_ws=$CODEMGR_WS

	#
	# Check to see if CODEMGR_PARENT is set in the flist file.
	#
	[[ -z $codemgr_parent && -n $CODEMGR_PARENT ]] && \
	    codemgr_parent=$CODEMGR_PARENT
}

#
# detect_scm
#
# We dynamically test the SCM type; this allows future extensions to
# new SCM types
#
function detect_scm
{
	if hg root >/dev/null ; then
		print "mercurial"
	else
		print "unknown"
	fi
}

function look_for_prog
{
	typeset path
	typeset ppath
	typeset progname=$1

	DEVTOOLS=
	OS=`uname`
	if [[ "$OS" == "SunOS" ]]; then
	    DEVTOOLS="/java/devtools/`uname -p`/bin"
	elif [[ "$OS" == "Linux" ]]; then
	    DEVTOOLS="/java/devtools/linux/bin"
	fi

	ppath=$PATH
	ppath=$ppath:/usr/sfw/bin:/usr/bin:/usr/sbin
	ppath=$ppath:/opt/teamware/bin:/opt/onbld/bin
	ppath=$ppath:/opt/onbld/bin/`uname -p`
	ppath=$ppath:/java/devtools/share/bin:$DEVTOOLS

	PATH=$ppath prog=`whence $progname`
	if [[ -n $prog ]]; then
		print $prog
	fi
}

#
# Find the parent for $1
#
function find_outrev
{
    crev=$1
    prev=`hg log -r $crev --template '{parents}\n'`
    if [[ -z "$prev" ]]
    then
	# No specific parent means previous changeset is parent
	prev=`expr $crev - 1`
    else
	# Format is either of the following two:
	# 546:7df6fcf1183b
	# 548:16f1915bb5cd 547:ffaa4e775815
	prev=`echo $prev | sed -e 's/\([0-9]*\):.*/\1/'`
    fi
    print $prev
}

function extract_ssh_infos
{
    CMD=$1
    if expr "$CMD" : 'ssh://[^/]*@' >/dev/null; then
	ssh_user=`echo $CMD | sed -e 's/ssh:\/\/\(.*\)@.*/\1/'`
	ssh_host=`echo $CMD | sed -e 's/ssh:\/\/.*@\([^/]*\)\/.*/\1/'`
	ssh_dir=`echo $CMD | sed -e 's/ssh:\/\/.*@[^/]*\/\(.*\)/\1/'`
    else
	ssh_user=
	ssh_host=`echo $CMD | sed -e 's/ssh:\/\/\([^/]*\)\/.*/\1/'`
	ssh_dir=`echo $CMD | sed -e 's/ssh:\/\/[^/]*\/\(.*\)/\1/'`
    fi

}

function build_old_new_mercurial
{
	olddir=$1
	newdir=$2
	DIR=$3
	F=$4
	#
	# new version of the file.
	#
	rm -rf $newdir/$DIR/$F
	if [ -f $F ]; then
	    cp $F  $newdir/$DIR/$F
	fi

	#
	# Old version of the file.
	#
	rm -rf $olddir/$DIR/$F

	if [ -n "$PWS" ]; then
	    if expr "$PWS" : 'ssh://' >/dev/null
	    then
		extract_ssh_infos $PWS
		if [ -n "$ssh_user" ]; then
		    parent="ssh -l $ssh_user $ssh_host hg -R $ssh_dir --cwd $ssh_dir"
		else
		    parent="ssh $ssh_host hg -R $ssh_dir --cwd $ssh_dir"
		fi
	    else
		parent="hg -R $PWS --cwd $PWS"
	    fi
	else
	    parent=""
	fi

	if [ -z "$rename" ]; then
	    if [ -n "$rflag" ]; then
		parentrev=$PARENT_REV
	    elif [ "$HG_LIST_FROM_COMMIT" -eq 1 ]; then
                parentrev=$OUTREV
	    else
                if [[ -n $HG_BRANCH ]]; then
                    parentrev=$HG_BRANCH
                else
		    parentrev="tip"
                fi
	    fi

	    if [ -n "$parentrev" ]; then
		if [ -z "$parent" ]; then
		    hg cat --rev $parentrev --output $olddir/$DIR/$F $F 2>/dev/null
		else
		    # when specifying a workspace we have to provide
		    # the full path
		    $parent cat --rev $parentrev --output $olddir/$DIR/$F $DIR/$F 2>/dev/null
		fi
	    fi
	else
	    # It's a rename (or a move), or a copy, so let's make sure we move
	    # to the right directory first, then restore it once done
	    current_dir=`pwd`
	    hg_root=`hg root`
	    cd $CWS
	    if [ -n "$rflag" ]; then
		parentrev=$PARENT_REV
	    elif [ "$HG_LIST_FROM_COMMIT" -eq 1 ]; then
                parentrev=$OUTREV
	    fi
	    if [ -z "$parentrev" ]; then
		parentrev=`hg log -l1 $PDIR/$PF | $AWK -F: '/changeset/ {print $2}'`
	    fi
	    if [ -n "$parentrev" ]; then
		mkdir -p $olddir/$PDIR
		if [ -z "$parent" ]; then
		    hg cat -R $hg_root --rev $parentrev --output $olddir/$PDIR/$PF $PDIR/$PF 2>/dev/null
		else
		    $parent cat --rev $parentrev --output $olddir/$PDIR/$PF $PDIR/$PF 2>/dev/null
		fi
	    fi
	    cd $current_dir
	fi
}

function build_old_new
{
	if [[ $SCM_MODE == "mercurial" ]]; then
		build_old_new_mercurial $@
	fi
}


#
# Usage message.
#
function usage
{
	print "Usage:\twebrev [options]
	webrev [options] ( <file> | - )

Options:
	-v: Print the version of this tool.
        -b: Do not ignore changes in the amount of white space.
        -c <CR#>: Include link to CR (aka bugid) in the main page.
	-i <filename>: Include <filename> in the index.html file.
	-o <outdir>: Output webrev to specified directory.
	-p <compare-against>: Use specified parent wkspc or basis for comparison
        -u <username>: Use that username instead of 'guessing' one.
	-m: Forces the use of Mercurial

Mercurial only options:
	-r rev: Compare against a specified revision
	-N: Skip 'hg outgoing', use only 'hg status'
	-f: Use the forest extension

Arguments:
	<file>: Optional file containing list of files to include in webrev
        -: read list of files to include in webrev from standard input

Environment:
	WDIR: Control the output directory.
	WEBREV_BUGURL: Control the URL prefix for bugids.

"

	exit 2
}

#
#
# Main program starts here
#
#
LANG="C"
LC_ALL="C"
export LANG LC_ALL
trap "rm -f /tmp/$$.* ; exit" 0 1 2 3 15

set +o noclobber

[[ -z $WDIFF ]] && WDIFF=`look_for_prog wdiff`
[[ -z $CODEREVIEW ]] && CODEREVIEW=`look_for_prog codereview`
[[ -z $PS2PDF ]] && PS2PDF=`look_for_prog ps2pdf`
[[ -z $PERL ]] && PERL=`look_for_prog perl`
[[ -z $SCCS ]] && SCCS=`look_for_prog sccs`
[[ -z $AWK ]] && AWK=`look_for_prog nawk`
[[ -z $AWK ]] && AWK=`look_for_prog gawk`
[[ -z $AWK ]] && AWK=`look_for_prog awk`
[[ -z $JAR ]] && JAR=`look_for_prog jar`
[[ -z $ZIP ]] && ZIP=`look_for_prog zip`
[[ -z $GETENT ]] && GETENT=`look_for_prog getent`
[[ -z $WGET ]] && WGET=`look_for_prog wget`

if uname | grep CYGWIN >/dev/null
then
        ISWIN=1
        # Under windows mercurial outputs '\' instead of '/'
        FILTER="tr '\\\\' '/'"
else
        FILTER="cat"
fi

if [[ ! -x $PERL ]]; then
	print -u2 "Error: No perl interpreter found.  Exiting."
	exit 1
fi

#
# These aren't fatal, but we want to note them to the user.
#
# [[ ! -x $CODEREVIEW ]] && print -u2 "WARNING: codereview(1) not found."
# [[ ! -x $PS2PDF ]] && print -u2 "WARNING: ps2pdf(1) not found."
# [[ ! -x $WDIFF ]] && print -u2 "WARNING: wdiff not found."

# Declare global total counters.
integer TOTL TINS TDEL TMOD TUNC

flist_mode=
flist_file=
bflag=
iflag=
oflag=
pflag=
uflag=
Oflag=
rflag=
Nflag=
forestflag=
while getopts "c:i:o:p:r:u:mONvfb" opt
do
	case $opt in
        b)      bflag=1;;

	i)	iflag=1
		INCLUDE_FILE=$OPTARG;;

	o)	oflag=1
		WDIR=$OPTARG;;

	p)	pflag=1
		codemgr_parent=$OPTARG;;

	u)      uflag=1
		username=$OPTARG;;

        c)      if [[ -z $CRID ]]; then
                   CRID=$OPTARG
                else
                   CRID="$CRID $OPTARG"
                fi;;

	m)	SCM_MODE="mercurial";;

	O)	Oflag=1;; # ignored (bugs are now all visible at bugs.openjdk.java.net)

	N)	Nflag=1;;

	f)	forestflag=1;;

	r)	rflag=1
		PARENT_REV=$OPTARG;;

	v)	print "$0 version: $WEBREV_UPDATED";;


	?)	usage;;
	esac
done

FLIST=/tmp/$$.flist
HG_LIST_FROM_COMMIT=

if [[ -n $forestflag && -n $rflag ]]; then
    print "The -r <rev> flag is incompatible with the use of forests"
    exit 2
fi

#
# If this manually set as the parent, and it appears to be an earlier webrev,
# then note that fact and set the parent to the raw_files/new subdirectory.
#
if [[ -n $pflag && -d $codemgr_parent/raw_files/new ]]; then
	parent_webrev="$codemgr_parent"
	codemgr_parent="$codemgr_parent/raw_files/new"
fi

shift $(($OPTIND - 1))

if [[ $1 == "-" ]]; then
	cat > $FLIST
	flist_mode="stdin"
	flist_done=1
	shift
elif [[ -n $1 ]]; then
	if [[ ! -r $1 ]]; then
		print -u2 "$1: no such file or not readable"
		usage
	fi
	cat $1 > $FLIST
	flist_mode="file"
	flist_file=$1
	flist_done=1
	shift
else
	flist_mode="auto"
fi

#
# Before we go on to further consider -l and -w, work out which SCM we think
# is in use.
#
if [[ -z $SCM_MODE ]]; then
    SCM_MODE=`detect_scm $FLIST`
fi
if [[ $SCM_MODE == "unknown" ]]; then
       print -u2 "Unable to determine SCM type currently in use."
       print -u2 "For mercurial: webrev runs 'hg root'."
       exit 1
fi

print -u2 "   SCM detected: $SCM_MODE"


if [[ $SCM_MODE == "mercurial" ]]; then
    #
    # determine Workspace and parent workspace paths
    #
    CWS=`hg root | $FILTER`
    if [[ -n $pflag && -z "$PWS" ]]; then
	OUTPWS=$codemgr_parent
        # Let's try to expand it if it's an alias defined in [paths]
        tmp=`hg path $OUTPWS 2>/dev/null | $FILTER`
        if [[ -n $tmp ]]; then
            OUTPWS="$tmp"
        fi
        if [[ -n $rflag ]]; then
	    if expr "$codemgr_parent" : 'ssh://.*' >/dev/null; then
	        PWS=$codemgr_parent
	    else
	        PWS=`hg -R "$codemgr_parent" root 2>/dev/null | $FILTER`
	    fi
        fi
    fi
    #
    # OUTPWS is the parent repository to use when using 'hg outgoing'
    #
    if [[ -z $Nflag ]]; then
        if [[ -n $forestflag ]]; then
            #
            # for forest we have to rely on properly set default and
            # default-push because they can be different from the top one.
            # unless of course it was explicitly specified with -p
            if [[ -z $pflag ]]; then
                OUTPWS=
            fi
        else
            #
            # Unfortunately mercurial is bugged and doesn't handle
            # aliases correctly in 'hg path default'
            # So let's do it ourselves. Sigh...
            if [[ -z "$OUTPWS" ]]; then
                OUTPWS=`grep default-push $CWS/.hg/hgrc | $AWK '{print $3}' | $FILTER`
            fi
            # Still empty, means no default-push
            if [[ -z "$OUTPWS" ]]; then
                OUTPWS=`grep 'default =' $CWS/.hg/hgrc | $AWK '{print $3}' | $FILTER`
            fi
            # Let's try to expand it if it's an alias defined in [paths]
            tmp=`hg path $OUTPWS 2>/dev/null | $FILTER`
            if [[ -n $tmp ]]; then
                OUTPWS="$tmp"
            fi
        fi
    fi
    #
    # OUTPWS may contain username:password, let's make sure we remove the
    # sensitive information before we print out anything in the HTML
    #
    OUTPWS2=$OUTPWS
    if [[ -n $OUTPWS ]]; then
	if [[ `expr "$OUTPWS" : '.*://[^/]*@.*'` -gt 0 ]]; then
	    # Remove everything between '://' and '@'
	    OUTPWS2=`echo $OUTPWS | sed -e 's/\(.*:\/\/\).*@\(.*\)/\1\2/'`
	fi
    fi

    if [[ -z $HG_BRANCH ]]; then
        HG_BRANCH=`hg branch`
        if [ "$HG_BRANCH" == "default" ]; then
            #
            # 'default' means no particular branch, so let's cancel that
            #
            HG_BRANCH=
        fi
    fi

    if [[ -z $forestflag ]]; then
        if [[ -z $Nflag ]]; then
            #
            # If no "-N", always do "hg outgoing" against parent
            # repository to determine list of outgoing revisions.
            #
            ALL_CREV=`hg outgoing -q --template '{rev}\n' $OUTPWS | sort -n`
            if [[ -n $ALL_CREV ]]; then
                FIRST_CREV=`echo "$ALL_CREV" | head -1`
                #
                # If no "-r", choose revision to compare against by
                # finding the latest revision not in the outgoing list.
                #
                if [[ -z $rflag ]]; then
                    OUTREV=`find_outrev "$FIRST_CREV"`
                    if [[ -n $OUTREV ]]; then
                        HG_LIST_FROM_COMMIT=1
                    fi
                fi
            fi
        elif [[ -n $rflag ]]; then
            #
            # If skipping "hg outgoing" but still comparing against a
            # specific revision (not the tip), set revision for comment
            # accumulation.
            #
            FIRST_CREV=`hg log --rev $PARENT_REV --template '{rev}'`
            FIRST_CREV=`expr $FIRST_CREV + 1`
        fi
    fi
    #Let's check if a merge is needed, if so, issue a warning
    PREV=`hg parent | grep '^tag:.*tip$'`
    if [[ -z $PREV ]]; then
        print "WARNING: parent rev is not tip. Maybe an update or merge is needed"
    fi
fi

if [[ $flist_mode == "stdin" ]]; then
	print -u2 " File list from: standard input"
elif [[ $flist_mode == "file" ]]; then
	print -u2 " File list from: $flist_file"
fi

if [[ $# -gt 0 ]]; then
	print -u2 "WARNING: unused arguments: $*"
fi

if [[ $SCM_MODE == "mercurial" ]]; then
    if [[ -z $flist_done ]]; then
	flist_from_mercurial $PWS
    fi
fi

#
# If the user didn't specify a -i option, check to see if there is a
# webrev-info file in the workspace directory.
#
if [[ -z $iflag && -r "$CWS/webrev-info" ]]; then
	iflag=1
	INCLUDE_FILE="$CWS/webrev-info"
fi

if [[ -n $iflag ]]; then
	if [[ ! -r $INCLUDE_FILE ]]; then
		print -u2 "include file '$INCLUDE_FILE' does not exist or is" \
		    "not readable."
		exit 1
	else
		#
		# $INCLUDE_FILE may be a relative path, and the script alters
		# PWD, so we just stash a copy in /tmp.
		#
		cp $INCLUDE_FILE /tmp/$$.include
	fi
fi

#
# Output directory.
#
if [[ -z $WDIR ]]; then
    WDIR=$CWS/webrev
else
    # If the output directory doesn't end with '/webrev' or '/webrev/'
    # then add '/webrev'. This is for backward compatibility
    if ! expr $WDIR : '.*/webrev/\?$' >/dev/null
    then
	WDIR=$WDIR/webrev
    fi
fi
# WDIR=${WDIR:-$CWS/webrev}

#
# Name of the webrev, derived from the workspace name; in the
# future this could potentially be an option.
#
# Let's keep what's after the last '/'
WNAME=${CWS##*/}

#
# If WDIR doesn't start with '/' or 'x:' prepend the current dir
#
if [ ${WDIR%%/*} ]; then
    if [[ -n $ISWIN ]]; then
        if [ ${WDIR%%[A-Za-z]:*} ]; then
	    WDIR=$PWD/$WDIR
        fi
    else
	WDIR=$PWD/$WDIR
    fi
fi

if [[ ! -d $WDIR ]]; then
	mkdir -p $WDIR
	[[ $? != 0 ]] && exit 1
fi

#
# Summarize what we're going to do.
#
print "      Workspace: $CWS"
if [[ -n $parent_webrev ]]; then
    print "Compare against: webrev at $parent_webrev"
elif [[ -n $OUTPWS2 ]]; then
    print "Compare against: $OUTPWS2"
fi
if [[ -n $HG_BRANCH ]]; then
    print "         Branch: $HG_BRANCH"
fi
if [[ -n $rflag ]]; then
        print "Compare against version: $PARENT_REV"
fi
[[ -n $INCLUDE_FILE ]] && print "      Including: $INCLUDE_FILE"
print "      Output to: $WDIR"

#
# Save the file list in the webrev dir
#
[[ ! $FLIST -ef $WDIR/file.list ]] && cp $FLIST $WDIR/file.list

#
#    Bug IDs will be replaced by a URL.  Order of precedence
#    is: default location, $WEBREV_BUGURL
#
BUGURL='https://bugs.openjdk.java.net/browse/'
[[ -n $WEBREV_BUGURL ]] && BUGURL="$WEBREV_BUGURL"
IDPREFIX='JDK-'


rm -f $WDIR/$WNAME.patch
rm -f $WDIR/$WNAME.changeset
rm -f $WDIR/$WNAME.ps
rm -f $WDIR/$WNAME.pdf

touch $WDIR/$WNAME.patch

print "   Output Files:"

#
# Clean up the file list: Remove comments, blank lines and env variables.
#
sed -e "s/#.*$//" -e "/=/d" -e "/^[   ]*$/d" $FLIST > /tmp/$$.flist.clean
FLIST=/tmp/$$.flist.clean

#
# Clean up residual raw files
#
if [ -d $WDIR/raw_files ]; then
    rm -rf $WDIR/raw_files 2>/dev/null
fi

#
# Should we ignore changes in white spaces when generating diffs?
#
if [[ -n $bflag ]]; then
    DIFFOPTS="-t"
else
    DIFFOPTS="-bt"
fi
#
# First pass through the files: generate the per-file webrev HTML-files.
#
while read LINE
do
	set - $LINE
	P=$1

        if [[ $1 == "Revision:" ]]; then
            OUTREV=$2
            continue
        fi
	#
	# Normally, each line in the file list is just a pathname of a
	# file that has been modified or created in the child.  A file
	# that is renamed in the child workspace has two names on the
	# line: new name followed by the old name.
	#
	oldname=""
	oldpath=""
	rename=
	if [[ $# -eq 2 ]]; then
		PP=$2			# old filename
		oldname=" (was $PP)"
		oldpath="$PP"
		rename=1
        	PDIR=${PP%/*}
        	if [[ $PDIR == $PP ]]; then
			PDIR="."   # File at root of workspace
		fi

		PF=${PP##*/}

	        DIR=${P%/*}
	        if [[ $DIR == $P ]]; then
			DIR="."   # File at root of workspace
		fi

		F=${P##*/}
        else
	        DIR=${P%/*}
	        if [[ "$DIR" == "$P" ]]; then
			DIR="."   # File at root of workspace
		fi

		F=${P##*/}

		PP=$P
		PDIR=$DIR
		PF=$F
	fi

        # Make the webrev directory if necessary as it may have been
        # removed because it was empty
        if [ ! -d $CWS/$DIR ]; then
	    mkdir -p $CWS/$DIR
        fi

	COMM=`getcomments html $P $PP`

	print "\t$P$oldname\n\t\t\c"

	# Make the webrev mirror directory if necessary
	mkdir -p $WDIR/$DIR

	# cd to the directory so the names are short
	cd $CWS/$DIR

	#
	# We stash old and new files into parallel directories in /tmp
	# and do our diffs there.  This makes it possible to generate
	# clean looking diffs which don't have absolute paths present.
	#
	olddir=$WDIR/raw_files/old
	newdir=$WDIR/raw_files/new
	mkdir -p $olddir
	mkdir -p $newdir
	mkdir -p $olddir/$PDIR
	mkdir -p $newdir/$DIR

	build_old_new $olddir $newdir $DIR $F

	if [[ ! -f $F && ! -f $olddir/$DIR/$F ]]; then
		print "*** Error: file not in parent or child"
		continue
	fi

	cd $WDIR/raw_files
	ofile=old/$PDIR/$PF
	nfile=new/$DIR/$F

	mv_but_nodiff=
	cmp $ofile $nfile > /dev/null 2>&1
	if [[ $? == 0 && $rename == 1 ]]; then
		mv_but_nodiff=1
	fi

        #
        # Cleaning up
        #
        rm -f $WDIR/$DIR/$F.cdiff.html
        rm -f $WDIR/$DIR/$F.udiff.html
        rm -f $WDIR/$DIR/$F.wdiff.html
        rm -f $WDIR/$DIR/$F.sdiff.html
        rm -f $WDIR/$DIR/$F-.html
        rm -f $WDIR/$DIR/$F.html

	its_a_jar=
	if expr $F : '.*\.jar' \| $F : '.*\.zip' >/dev/null; then
	    its_a_jar=1
	    # It's a JAR or ZIP file, let's do it differently
	    if [[ -z $JAR ]]; then
		print "No access to jar, so can't produce diffs for jar or zip files"
	    else
		if [ -f $ofile ]; then
		    $JAR -tvf $ofile >"$ofile".lst
		fi
		if [ -f $nfile ]; then
		    $JAR -tvf $nfile >"$nfile".lst
		fi

		if [[ -f $ofile && -f $nfile && -z $mv_but_nodiff ]]; then

		    ${CDIFFCMD:-diff -bt -C 5} $ofile.lst $nfile.lst > $WDIR/$DIR/$F.cdiff
		    diff_to_html $F $DIR/$F "C" "$COMM" < $WDIR/$DIR/$F.cdiff \
			> $WDIR/$DIR/$F.cdiff.html
		    print " cdiffs\c"

		    ${UDIFFCMD:-diff -bt -U 5} $ofile.lst $nfile.lst > $WDIR/$DIR/$F.udiff
		    diff_to_html $F $DIR/$F "U" "$COMM" < $WDIR/$DIR/$F.udiff \
			> $WDIR/$DIR/$F.udiff.html

		    print " udiffs\c"

		    if [[ -x $WDIFF ]]; then
			$WDIFF -c "$COMM" \
			    -t "$WNAME Wdiff $DIR/$F" $ofile.lst $nfile.lst > \
			    $WDIR/$DIR/$F.wdiff.html 2>/dev/null
			if [[ $? -eq 0 ]]; then
			    print " wdiffs\c"
			else
			    print " wdiffs[fail]\c"
			fi
		    fi

		    sdiff_to_html $ofile $nfile $F $DIR "$COMM" \
			> $WDIR/$DIR/$F.sdiff.html
		    print " sdiffs\c"

		    print " frames\c"

		    rm -f $WDIR/$DIR/$F.cdiff $WDIR/$DIR/$F.udiff

		    difflines $ofile.lst $nfile.lst > $WDIR/$DIR/$F.count

		elif [[ -f $ofile && -f $nfile && -n $mv_but_nodiff ]]; then
		# renamed file: may also have differences
		    difflines $ofile.lst $nfile.lst > $WDIR/$DIR/$F.count
		elif [[ -f $nfile ]]; then
		# new file: count added lines
		    difflines /dev/null $nfile.lst > $WDIR/$DIR/$F.count
		elif [[ -f $ofile ]]; then
		# old file: count deleted lines
		    difflines $ofile.lst /dev/null > $WDIR/$DIR/$F.count
		fi
	    fi
	else

	    #
	    # If we have old and new versions of the file then run the
	    # appropriate diffs.  This is complicated by a couple of factors:
	    #
	    #	- renames must be handled specially: we emit a 'remove'
	    #	  diff and an 'add' diff
	    #	- new files and deleted files must be handled specially
	    #	- Solaris patch(1m) can't cope with file creation
	    #	  (and hence renames) as of this writing.
	    #   - To make matters worse, gnu patch doesn't interpret the
	    #	  output of Solaris diff properly when it comes to
	    #	  adds and deletes.  We need to do some "cleansing"
	    #     transformations:
	    # 	    [to add a file] @@ -1,0 +X,Y @@  -->  @@ -0,0 +X,Y @@
	    #	    [to del a file] @@ -X,Y +1,0 @@  -->  @@ -X,Y +0,0 @@
	    #
	    cleanse_rmfile="sed 's/^\(@@ [0-9+,-]*\) [0-9+,-]* @@$/\1 +0,0 @@/'"
	    cleanse_newfile="sed 's/^@@ [0-9+,-]* \([0-9+,-]* @@\)$/@@ -0,0 \1/'"

            if [[ ! "$HG_LIST_FROM_COMMIT" -eq 1 || ! $flist_mode == "auto" ]];
            then
              # Only need to generate a patch file here if there are no commits in outgoing
              # or if we've specified a file list
              rm -f $WDIR/$DIR/$F.patch
              if [[ -z $rename ]]; then
                  if [ ! -f $ofile ]; then
                      diff -u /dev/null $nfile | sh -c "$cleanse_newfile" \
                          > $WDIR/$DIR/$F.patch
                  elif [ ! -f $nfile ]; then
                      diff -u $ofile /dev/null | sh -c "$cleanse_rmfile" \
                          > $WDIR/$DIR/$F.patch
                  else
                      diff -u $ofile $nfile > $WDIR/$DIR/$F.patch
                  fi
              else
                  diff -u $ofile /dev/null | sh -c "$cleanse_rmfile" \
                      > $WDIR/$DIR/$F.patch

                  diff -u /dev/null $nfile | sh -c "$cleanse_newfile" \
                      >> $WDIR/$DIR/$F.patch

              fi


            #
            # Tack the patch we just made onto the accumulated patch for the
            # whole wad.
            #
              cat $WDIR/$DIR/$F.patch >> $WDIR/$WNAME.patch
            fi

            print " patch\c"

	    if [[ -f $ofile && -f $nfile && -z $mv_but_nodiff ]]; then

		${CDIFFCMD:-diff -bt -C 5} $ofile $nfile > $WDIR/$DIR/$F.cdiff
		diff_to_html $F $DIR/$F "C" "$COMM" < $WDIR/$DIR/$F.cdiff \
		    > $WDIR/$DIR/$F.cdiff.html
		print " cdiffs\c"

		${UDIFFCMD:-diff -bt -U 5} $ofile $nfile > $WDIR/$DIR/$F.udiff
		diff_to_html $F $DIR/$F "U" "$COMM" < $WDIR/$DIR/$F.udiff \
		    > $WDIR/$DIR/$F.udiff.html

		print " udiffs\c"

		if [[ -x $WDIFF ]]; then
		    $WDIFF -c "$COMM" \
			-t "$WNAME Wdiff $DIR/$F" $ofile $nfile > \
			$WDIR/$DIR/$F.wdiff.html 2>/dev/null
		    if [[ $? -eq 0 ]]; then
			print " wdiffs\c"
		    else
			print " wdiffs[fail]\c"
		    fi
		fi

		sdiff_to_html $ofile $nfile $F $DIR "$COMM" \
		    > $WDIR/$DIR/$F.sdiff.html
		print " sdiffs\c"

		print " frames\c"

		rm -f $WDIR/$DIR/$F.cdiff $WDIR/$DIR/$F.udiff

		difflines $ofile $nfile > $WDIR/$DIR/$F.count

	    elif [[ -f $ofile && -f $nfile && -n $mv_but_nodiff ]]; then
		# renamed file: may also have differences
		difflines $ofile $nfile > $WDIR/$DIR/$F.count
	    elif [[ -f $nfile ]]; then
		# new file: count added lines
		difflines /dev/null $nfile > $WDIR/$DIR/$F.count
	    elif [[ -f $ofile ]]; then
		# old file: count deleted lines
		difflines $ofile /dev/null > $WDIR/$DIR/$F.count
	    fi
	fi
	#
	# Now we generate the postscript for this file.  We generate diffs
	# only in the event that there is delta, or the file is new (it seems
	# tree-killing to print out the contents of deleted files).
	#
	if [[ -f $nfile ]]; then
		ocr=$ofile
		[[ ! -f $ofile ]] && ocr=/dev/null

		if [[ -z $mv_but_nodiff ]]; then
			textcomm=`getcomments text $P $PP`
			if [[ -x $CODEREVIEW ]]; then
				$CODEREVIEW -y "$textcomm" \
				    -e $ocr $nfile \
				    > /tmp/$$.psfile 2>/dev/null &&
				    cat /tmp/$$.psfile >> $WDIR/$WNAME.ps
				if [[ $? -eq 0 ]]; then
					print " ps\c"
				else
					print " ps[fail]\c"
				fi
			fi
		fi
	fi

	if [[ -f $ofile && -z $mv_but_nodiff ]]; then
	    if [[ -n $its_a_jar ]]; then
		source_to_html Old $P < $ofile.lst > $WDIR/$DIR/$F-.html
	    else
		source_to_html Old $P < $ofile > $WDIR/$DIR/$F-.html
	    fi
		print " old\c"
	fi

	if [[ -f $nfile ]]; then
	    if [[ -n $its_a_jar ]]; then
		source_to_html New $P < $nfile.lst > $WDIR/$DIR/$F.html
	    else
		source_to_html New $P < $nfile > $WDIR/$DIR/$F.html
	    fi
		print " new\c"
	fi

	print
done < $FLIST

# Create the new style mercurial patch here using hg export -r [all-revs] -g -o $CHANGESETPATH
if [[ $SCM_MODE == "mercurial" ]]; then
  if [[ "$HG_LIST_FROM_COMMIT" -eq 1 && $flist_mode == "auto" ]]; then
    EXPORTCHANGESET="$WNAME.changeset"
    CHANGESETPATH=${WDIR}/${EXPORTCHANGESET}
    rm -f $CHANGESETPATH
    touch $CHANGESETPATH
    if [[ -n $ALL_CREV ]]; then
      rev_opt=
      for rev in $ALL_CREV; do
        rev_opt="$rev_opt --rev $rev"
      done
    elif [[ -n $FIRST_CREV ]]; then
      rev_opt="--rev $FIRST_CREV"
    fi

    if [[ -n $rev_opt ]]; then
      (cd $CWS;hg export -g $rev_opt -o $CHANGESETPATH)
      echo "Created changeset: $CHANGESETPATH" 1>&2
      # Use it in place of the jdk.patch created above
      rm -f $WDIR/$WNAME.patch
    fi
  set +x
  fi
fi

frame_nav_js > $WDIR/ancnav.js
frame_navigation > $WDIR/ancnav.html

if [[ -f $WDIR/$WNAME.ps && -x $CODEREVIEW && -x $PS2PDF ]]; then
	print " Generating PDF: \c"
	fix_postscript $WDIR/$WNAME.ps | $PS2PDF - > $WDIR/$WNAME.pdf
	print "Done."
fi

# Now build the index.html file that contains
# links to the source files and their diffs.

cd $CWS

# Save total changed lines for Code Inspection.
print "$TOTL" > $WDIR/TotalChangedLines

print "     index.html: \c"
INDEXFILE=$WDIR/index.html
exec 3<&1			# duplicate stdout to FD3.
exec 1<&-			# Close stdout.
exec > $INDEXFILE		# Open stdout to index file.

print "$HTML<head>"
print "<meta name=\"scm\" content=\"$SCM_MODE\" />"
print "$STDHEAD"
print "<title>$WNAME</title>"
print "</head>"
print "<body id=\"SUNWwebrev\">"
print "<div class=\"summary\">"
print "<h2>Code Review for $WNAME</h2>"

print "<table>"

if [[ -z $uflag ]]; then
    if [[ $SCM_MODE == "mercurial" ]]; then
        #
        # Let's try to extract the user name from the .hgrc file
        #
	username=`grep '^username' $HOME/.hgrc | sed 's/^username[ ]*=[ ]*\(.*\)/\1/'`
    fi

    if [[ -z $username ]]; then
        #
        # Figure out the username and gcos name.  To maintain compatibility
        # with passwd(4), we must support '&' substitutions.
        #
	username=`id | cut -d '(' -f 2 | cut -d ')' -f 1`
	if [[ -x $GETENT ]]; then
	    realname=`$GETENT passwd $username | cut -d':' -f 5 | cut -d ',' -f 1`
	fi
	userupper=`print "$username" | sed 's/\<./\u&/g'`
	realname=`print $realname | sed s/\&/$userupper/`
    fi
fi

date="on `date`"

if [[ -n "$username" && -n "$realname" ]]; then
	print "<tr><th>Prepared by:</th>"
	print "<td>$realname ($username) $date</td></tr>"
elif [[ -n "$username" ]]; then
	print "<tr><th>Prepared by:</th><td>$username $date</td></tr>"
fi

print "<tr><th>Workspace:</th><td>$CWS</td></tr>"
if [[ -n $parent_webrev ]]; then
        print "<tr><th>Compare against:</th><td>"
	print "webrev at $parent_webrev"
else
    if [[ -n $OUTPWS2 ]]; then
        print "<tr><th>Compare against:</th><td>"
	print "$OUTPWS2"
    fi
fi
print "</td></tr>"
if [[ -n $rflag ]]; then
    print "<tr><th>Compare against version:</th><td>$PARENT_REV</td></tr>"
elif [[ -n $OUTREV ]]; then
    if [[ -z $forestflag ]]; then
        print "<tr><th>Compare against version:</th><td>$OUTREV</td></tr>"
    fi
fi
if [[ -n $HG_BRANCH ]]; then
    print "<tr><th>Branch:</th><td>$HG_BRANCH</td></tr>"
fi

print "<tr><th>Summary of changes:</th><td>"
printCI $TOTL $TINS $TDEL $TMOD $TUNC
print "</td></tr>"

if [[ -f $WDIR/$WNAME.patch ]]; then
  print "<tr><th>Patch of changes:</th><td>"
  print "<a href=\"$WNAME.patch\">$WNAME.patch</a></td></tr>"
elif [[ -f $CHANGESETPATH ]]; then
  print "<tr><th>Changeset:</th><td>"
  print "<a href=\"$EXPORTCHANGESET\">$EXPORTCHANGESET</a></td></tr>"
fi

if [[ -f $WDIR/$WNAME.pdf ]]; then
	print "<tr><th>Printable review:</th><td>"
	print "<a href=\"$WNAME.pdf\">$WNAME.pdf</a></td></tr>"
fi

if [[ -n "$iflag" ]]; then
	print "<tr><th>Author comments:</th><td><div>"
	cat /tmp/$$.include
	print "</div></td></tr>"
fi
# Add links to referenced CRs, if any
# URL has a <title> like:
# <title>[#JDK-8024688] b106-lambda: j.u.Map.merge doesn&#39;t work as specified if contains key:null pair - Java Bug System</title>
# we format this to:
# JDK-8024688: b106-lambda: j.u.Map.merge doesn't work as specified if contains key:null pair
if [[ -n $CRID ]]; then
    for id in $CRID
    do
        #add "JDK-" to raw bug id for openjdk.java.net links.
        id=`echo ${id} | sed 's/^\([0-9]\{5,\}\)$/JDK-\1/'`

        print "<tr><th>Bug id:</th><td>"
        url="${BUGURL}${id}"

        if [[ -n $WGET ]]; then
            msg=`$WGET --timeout=10 --tries=1 -q $url -O - | grep '<title>' | sed 's/<title>\[#\(.*\)\] \(.*\) - Java Bug System<\/title>/\1 : \2/' | html_dequote | html_quote`
        fi
        if [[ -z $msg ]]; then
            msg="${id}"
        fi

        print "<a href=\"$url\">$msg</a>"

        print "</td></tr>"
    done
fi
print "<tr><th>Legend:</th><td>"
print "<b>Modified file</b><br><font color=red><b>Deleted file</b></font><br><font color=green><b>New file</b></font></td></tr>"
print "</table>"
print "</div>"

#
# Second pass through the files: generate the rest of the index file
#
while read LINE
do
	set - $LINE
        if [[ $1 == "Revision:" ]]; then
            FIRST_CREV=`expr $3 + 1`
            continue
        fi
	P=$1

	if [[ $# == 2 ]]; then
		PP=$2
		oldname=" <i>(was $PP)</i>"

	else
		PP=$P
		oldname=""
	fi

	DIR=${P%/*}
	if [[ $DIR == $P ]]; then
		DIR="."   # File at root of workspace
	fi

	# Avoid processing the same file twice.
	# It's possible for renamed files to
	# appear twice in the file list

	F=$WDIR/$P

	print "<p><code>"

	# If there's a diffs file, make diffs links

        NODIFFS=
	if [[ -f $F.cdiff.html ]]; then
		print "<a href=\"$P.cdiff.html\">Cdiffs</a>"
		print "<a href=\"$P.udiff.html\">Udiffs</a>"

		if [[ -f $F.wdiff.html && -x $WDIFF ]]; then
			print "<a href=\"$P.wdiff.html\">Wdiffs</a>"
		fi

		print "<a href=\"$P.sdiff.html\">Sdiffs</a>"

		print "<a href=\"$P.frames.html\">Frames</a>"
	else
                NODIFFS=1
		print " ------ ------ ------"

		if [[ -x $WDIFF ]]; then
			print " ------"
		fi

		print " ------"
	fi

	# If there's an old file, make the link

        NOOLD=
	if [[ -f $F-.html ]]; then
		print "<a href=\"$P-.html\">Old</a>"
	else
                NOOLD=1
		print " ---"
	fi

	# If there's an new file, make the link

        NONEW=
	if [[ -f $F.html ]]; then
		print "<a href=\"$P.html\">New</a>"
	else
                NONEW=1
		print " ---"
	fi

	if [[ -f $F.patch ]]; then
		print "<a href=\"$P.patch\">Patch</a>"
	else
		print " -----"
	fi

	if [[ -f $WDIR/raw_files/new/$P ]]; then
		print "<a href=\"raw_files/new/$P\">Raw</a>"
	else
		print " ---"
	fi
        print "</code>"
        if [[ -n $NODIFFS && -z $oldname ]]; then
            if [[ -n $NOOLD ]]; then
                print "<font color=green><b>$P</b></font>"
            elif [[ -n $NONEW ]]; then
                print "<font color=red><b>$P</b></font>"
            fi
        else
	    print "<b>$P</b> $oldname"
        fi

	print "</p><blockquote>\c"
	# Insert delta comments if any
	comments=`getcomments html $P $PP`
	if [ -n "$comments" ]; then
	    print "<pre>$comments</pre>"
	fi

	# Add additional comments comment

	print "<!-- Add comments to explain changes in $P here -->"

	# Add count of changes.

	if [[ -f $F.count ]]; then
	    cat $F.count
	    rm $F.count
	fi
        print "</blockquote>"
done < $FLIST

print
print
print "<hr />"
print "<p style=\"font-size: small\">"
print "This code review page was prepared using <b>$0</b>"
print "(vers $WEBREV_UPDATED)."
print "</body>"
print "</html>"

if [[ -n $ZIP ]]; then
    # Let's generate a zip file for convenience
    cd $WDIR/..
    if [ -f webrev.zip ]; then
	rm webrev.zip
    fi
    $ZIP -r webrev webrev >/dev/null 2>&1
fi

exec 1<&-			# Close FD 1.
exec 1<&3			# dup FD 3 to restore stdout.
exec 3<&-			# close FD 3.

print "Done."
print "Output to: $WDIR"