#!/usr/bin/ksh93 -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) 2002, 2010, Oracle and/or its affiliates. All rights reserved. # # Copyright 2008, 2010, Richard Lowe # # 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 the manual page, webrev.1, or just # type 'webrev -h'. # # Acknowledgements to contributors to webrev are listed in the webrev(1) # man page. # REMOVED_COLOR=brown CHANGED_COLOR=blue NEW_COLOR=blue HTML=' \n' FRAMEHTML=' \n' STDHEAD=' ' # # 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=' ' # # Display remote target with prefix and trailing slash. # function print_upload_header { typeset -r prefix=$1 typeset display_target if [[ -z $tflag ]]; then display_target=${prefix}${remote_target} else display_target=${remote_target} fi if [[ ${display_target} != */ ]]; then display_target=${display_target}/ fi print " Upload to: ${display_target}\n" \ " Uploading: \c" } # # Upload the webrev via rsync. Return 0 on success, 1 on error. # function rsync_upload { if (( $# != 2 )); then print "\nERROR: rsync_upload: wrong usage ($#)" exit 1 fi typeset -r dst=$1 integer -r print_err_msg=$2 print_upload_header ${rsync_prefix} print "rsync ... \c" typeset -r err_msg=$( $MKTEMP /tmp/rsync_err.XXXXXX ) if [[ -z $err_msg ]]; then print "\nERROR: rsync_upload: cannot create temporary file" return 1 fi # # The source directory must end with a slash in order to copy just # directory contents, not the whole directory. # typeset src_dir=$WDIR if [[ ${src_dir} != */ ]]; then src_dir=${src_dir}/ fi $RSYNC -r -q ${src_dir} $dst 2>$err_msg if (( $? != 0 )); then if (( ${print_err_msg} > 0 )); then print "Failed.\nERROR: rsync failed" print "src dir: '${src_dir}'\ndst dir: '$dst'" print "error messages:" $SED 's/^/> /' $err_msg rm -f $err_msg fi return 1 fi rm -f $err_msg print "Done." return 0 } # # Create directories on remote host using SFTP. Return 0 on success, # 1 on failure. # function remote_mkdirs { typeset -r dir_spec=$1 typeset -r host_spec=$2 # # If the supplied path is absolute we assume all directories are # created, otherwise try to create all directories in the path # except the last one which will be created by scp. # if [[ "${dir_spec}" == */* && "${dir_spec}" != /* ]]; then print "mkdirs \c" # # Remove the last directory from directory specification. # typeset -r dirs_mk=${dir_spec%/*} typeset -r batch_file_mkdir=$( $MKTEMP \ /tmp/webrev_mkdir.XXXXXX ) if [[ -z $batch_file_mkdir ]]; then print "\nERROR: remote_mkdirs:" \ "cannot create temporary file for batch file" return 1 fi OLDIFS=$IFS IFS=/ typeset dir for dir in ${dirs_mk}; do # # Use the '-' prefix to ignore mkdir errors in order # to avoid an error in case the directory already # exists. We check the directory with chdir to be sure # there is one. # print -- "-mkdir ${dir}" >> ${batch_file_mkdir} print "chdir ${dir}" >> ${batch_file_mkdir} done IFS=$OLDIFS typeset -r sftp_err_msg=$( $MKTEMP /tmp/webrev_scp_err.XXXXXX ) if [[ -z ${sftp_err_msg} ]]; then print "\nERROR: remote_mkdirs:" \ "cannot create temporary file for error messages" return 1 fi $SFTP -b ${batch_file_mkdir} ${host_spec} 2>${sftp_err_msg} 1>&2 if (( $? != 0 )); then print "\nERROR: failed to create remote directories" print "error messages:" $SED 's/^/> /' ${sftp_err_msg} rm -f ${sftp_err_msg} ${batch_file_mkdir} return 1 fi rm -f ${sftp_err_msg} ${batch_file_mkdir} fi return 0 } # # Upload the webrev via SSH. Return 0 on success, 1 on error. # function ssh_upload { if (( $# != 1 )); then print "\nERROR: ssh_upload: wrong number of arguments" exit 1 fi typeset dst=$1 typeset -r host_spec=${dst%%:*} typeset -r dir_spec=${dst#*:} # # Display the upload information before calling delete_webrev # because it will also print its progress. # print_upload_header ${ssh_prefix} # # If the deletion was explicitly requested there is no need # to perform it again. # if [[ -z $Dflag ]]; then # # We do not care about return value because this might be # the first time this directory is uploaded. # delete_webrev 0 fi # # Create remote directories. Any error reporting will be done # in remote_mkdirs function. # remote_mkdirs ${dir_spec} ${host_spec} if (( $? != 0 )); then return 1 fi print "upload ... \c" typeset -r scp_err_msg=$( $MKTEMP /tmp/scp_err.XXXXXX ) if [[ -z ${scp_err_msg} ]]; then print "\nERROR: ssh_upload:" \ "cannot create temporary file for error messages" return 1 fi $SCP -q -C -B -o PreferredAuthentications=publickey -r \ $WDIR $dst 2>${scp_err_msg} if (( $? != 0 )); then print "Failed.\nERROR: scp failed" print "src dir: '$WDIR'\ndst dir: '$dst'" print "error messages:" $SED 's/^/> /' ${scp_err_msg} rm -f ${scp_err_msg} return 1 fi rm -f ${scp_err_msg} print "Done." return 0 } # # Delete webrev at remote site. Return 0 on success, 1 or exit code from sftp # on failure. If first argument is 1 then perform the check of sftp return # value otherwise ignore it. If second argument is present it means this run # only performs deletion. # function delete_webrev { if (( $# < 1 )); then print "delete_webrev: wrong number of arguments" exit 1 fi integer -r check=$1 integer delete_only=0 if (( $# == 2 )); then delete_only=1 fi # # Strip the transport specification part of remote target first. # typeset -r stripped_target=${remote_target##*://} typeset -r host_spec=${stripped_target%%:*} typeset -r dir_spec=${stripped_target#*:} typeset dir_rm # # Do not accept an absolute path. # if [[ ${dir_spec} == /* ]]; then return 1 fi # # Strip the ending slash. # if [[ ${dir_spec} == */ ]]; then dir_rm=${dir_spec%%/} else dir_rm=${dir_spec} fi if (( ${delete_only} > 0 )); then print " Removing: \c" else print "rmdir \c" fi if [[ -z "$dir_rm" ]]; then print "\nERROR: empty directory for removal" return 1 fi # # Prepare batch file. # typeset -r batch_file_rm=$( $MKTEMP /tmp/webrev_remove.XXXXXX ) if [[ -z $batch_file_rm ]]; then print "\nERROR: delete_webrev: cannot create temporary file" return 1 fi print "rename $dir_rm $TRASH_DIR/removed.$$" > $batch_file_rm # # Perform remote deletion and remove the batch file. # typeset -r sftp_err_msg=$( $MKTEMP /tmp/webrev_scp_err.XXXXXX ) if [[ -z ${sftp_err_msg} ]]; then print "\nERROR: delete_webrev:" \ "cannot create temporary file for error messages" return 1 fi $SFTP -b $batch_file_rm $host_spec 2>${sftp_err_msg} 1>&2 integer -r ret=$? rm -f $batch_file_rm if (( $ret != 0 && $check > 0 )); then print "Failed.\nERROR: failed to remove remote directories" print "error messages:" $SED 's/^/> /' ${sftp_err_msg} rm -f ${sftp_err_msg} return $ret fi rm -f ${sftp_err_msg} if (( ${delete_only} > 0 )); then print "Done." fi return 0 } # # Upload webrev to remote site # function upload_webrev { integer ret if [[ ! -d "$WDIR" ]]; then print "\nERROR: webrev directory '$WDIR' does not exist" return 1 fi # # Perform a late check to make sure we do not upload closed source # to remote target when -n is used. If the user used custom remote # target he probably knows what he is doing. # if [[ -n $nflag && -z $tflag ]]; then $FIND $WDIR -type d -name closed \ | $GREP closed >/dev/null if (( $? == 0 )); then print "\nERROR: directory '$WDIR' contains" \ "\"closed\" directory" return 1 fi fi # # We have the URI for remote destination now so let's start the upload. # if [[ -n $tflag ]]; then if [[ "${remote_target}" == ${rsync_prefix}?* ]]; then rsync_upload ${remote_target##$rsync_prefix} 1 ret=$? return $ret elif [[ "${remote_target}" == ${ssh_prefix}?* ]]; then ssh_upload ${remote_target##$ssh_prefix} ret=$? return $ret fi else # # Try rsync first and fallback to SSH in case it fails. # rsync_upload ${remote_target} 0 ret=$? if (( $ret != 0 )); then print "Failed. (falling back to SSH)" ssh_upload ${remote_target} ret=$? fi return $ret fi } # # input_cmd | url_encode | output_cmd # # URL-encode (percent-encode) reserved characters as defined in RFC 3986. # # Reserved characters are: :/?#[]@!$&'()*+,;= # # While not a reserved character itself, percent '%' is reserved by definition # so encode it first to avoid recursive transformation, and skip '/' which is # a path delimiter. # # The quotation character is deliberately not escaped in order to make # the substitution work with GNU sed. # function url_encode { $SED -e "s|%|%25|g" -e "s|:|%3A|g" -e "s|\&|%26|g" \ -e "s|?|%3F|g" -e "s|#|%23|g" -e "s|\[|%5B|g" \ -e "s|*|%2A|g" -e "s|@|%40|g" -e "s|\!|%21|g" \ -e "s|=|%3D|g" -e "s|;|%3B|g" -e "s|\]|%5D|g" \ -e "s|(|%28|g" -e "s|)|%29|g" -e "s|'|%27|g" \ -e "s|+|%2B|g" -e "s|\,|%2C|g" -e "s|\\\$|%24|g" } # # input_cmd | html_quote | output_cmd # or # html_quote filename | output_cmd # # Make a piece of source code safe for display in an HTML
 block.
#
html_quote()
{
	$SED -e "s/&/\&/g" -e "s//\>/g" "$@" | expand
}

# 
# Trim a digest-style revision to a conventionally readable yet useful length
#
trim_digest()
{
	typeset digest=$1

	echo $digest | $SED -e 's/\([0-9a-f]\{12\}\).*/\1/'
}

#
# input_cmd | its2url | output_cmd
#
# Scan for information tracking system references and insert  links to the
# relevant databases.
#
its2url()
{
	$SED -f ${its_sed_script}
}

#
# strip_unchanged  | 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 " C) {
			c -= C
			inx = 0
			if (c > C) {
				print "\n

"
				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

" } ' $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 \ # ' # 1234567 my bugid' > .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 "
\n" }
#      function sp(n) {for (i=0;i%4d %s \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%%4d %%s\\n\", NR, $0}\n"
		printf "function changed() "
		printf "{printf \"%%4d %%s\\n\", NR, $0}\n"
		printf "function bl() {printf \"%%4d %%s\\n\", NR, $0}\n"
}
	/^/	{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%%4d %%s\\n\", NR, $0}\n"
		printf "function changed() "
		printf "{printf \"%%4d %%s\\n\", NR, $0}\n"
		printf "function bl() {printf \"%%4d %%s\\n\", NR, $0}\n"
	}

	/^/	{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$STDHEAD"
	print "$WNAME Sdiff $TPATH/$TNAME"
	print ""
        print "Print this page"
	print "
$COMMENT
\n" print "" print "" print "
"

	strip_unchanged /tmp/$$.file1.html

	print "
"

	strip_unchanged /tmp/$$.file2.html

	print "
" print "" framed_sdiff $TNAME $TPATH /tmp/$$.file1.html /tmp/$$.file2.html \ "$COMMENT" } # # framed_sdiff # # 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$STDHEAD" > $WDIR/$DIR/$TNAME.lhs.html cat >> $WDIR/$DIR/$TNAME.lhs.html <<-EOF
$comments

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='' print $close >> $WDIR/$DIR/$TNAME.lhs.html print $close >> $WDIR/$DIR/$TNAME.rhs.html print "$FRAMEHTML$STDHEAD" > $WDIR/$DIR/$TNAME.frames.html print "$WNAME Framed-Sdiff " \ "$TPATH/$TNAME " >> $WDIR/$DIR/$TNAME.frames.html cat >> $WDIR/$DIR/$TNAME.frames.html <<-EOF <body id="SUNWwebrev"> Alas 'frames' webrev requires that your browser supports frames and has the feature enabled. </body> 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 "", anc, anc++; } BEGIN { anc=1; inblock=1; printf "
\n";
	}
	NF == 0 || /^";
		printf "--- EOF ---"
		for(i=0;i<8;i++) printf "\n\n\n\n\n\n\n\n\n\n";
		printf "
" printf "
"; printf "", anc - 1; printf "
"; } ' $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 { typeset cur="${1##$2?(/)}" # # If the first path was specified absolutely, and it does # not start with the second path, it's an error. # if [[ "$cur" = "/${1#/}" ]]; then # 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 # # This is kind of ugly. The sed script will do the following: # # 1. Strip off a leading "." or "./": this is important to get # the correct arcnav links for files in $WDIR. # 2. Strip off a trailing "/": this is not strictly necessary, # but is kind of nice, since it doesn't end up in "//" at # the end of a relative path. # 3. Replace all remaining sequences of non-"/" with "..": the # assumption here is that each dirname represents another # level of relative separation. # 4. Append a trailing "/" only for non-empty paths: this way # the caller doesn't need to duplicate this logic, and does # not end up using $RTOP/file for files in $WDIR. # print $cur | $SED -e '{ s:^\./*:: s:/$:: s:[^/][^/]*:..:g s:^\(..*\)$:\1/: }' } # # 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$STDHEAD" cat << \EOF Anchor Navigation EOF print "" cat << \EOF
Diff navigation: Use 'j' and 'k' for next and previous diffs; or use buttons at right
EOF } # # diff_to_html { U | C } # # 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$STDHEAD" print "$WNAME ${DIFFTYPE}diff $TPATH" if [[ $DIFFTYPE == "U" ]]; then print "$UDIFFCSS" fi cat <<-EOF Print this page
$COMMENT
	EOF

	html_quote | $AWK '
	/^--- new/	{ next }
	/^\+\+\+ new/	{ next }
	/^--- old/	{ next }
	/^\*\*\* old/	{ next }
	/^\*\*\*\*/	{ next }
	/^-------/	{ printf "

%s

\n", $0; next } /^\@\@.*\@\@$/ { printf "

\n";
			  printf "%s\n", $0;
			  next}

	/^\*\*\*/	{ printf "
%s\n", $0; next} /^---/ { printf "%s\n", $0; next} /^\+/ {printf "%s\n", $0; next} /^!/ {printf "%s\n", $0; next} /^-/ {printf "%s\n", $0; next} {printf "%s\n", $0; next} ' print "
\n" } # # source_to_html { new | old } # # Process a plain vanilla source file to transform it into an HTML file. # source_to_html() { WHICH=$1 TNAME=$2 print "$HTML$STDHEAD" print "$WNAME $WHICH $TNAME" print "" print "
"
	html_quote | $AWK '{line += 1 ; printf "%4d %s\n", line, $0 }'
	print "
" } # # comments_from_teamware {text|html} parent-file child-file # # Find the first delta in the child that's not in the parent. Get the # newest delta from the parent, get all deltas from the child starting # with that delta, and then get all info starting with the second oldest # delta in that list (the first delta unique to the child). # # This code adapted from Bill Shannon's "spc" script # comments_from_teamware() { fmt=$1 pfile=$PWS/$2 cfile=$CWS/$3 if [[ ! -f $PWS/${2%/*}/SCCS/s.${2##*/} && -n $RWS ]]; then pfile=$RWS/$2 fi if [[ -f $pfile ]]; then psid=$($SCCS prs -d:I: $pfile 2>/dev/null) else psid=1.1 fi set -A sids $($SCCS prs -l -r$psid -d:I: $cfile 2>/dev/null) N=${#sids[@]} nawkprg=' /^COMMENTS:/ {p=1; continue} /^D [0-9]+\.[0-9]+/ {printf "--- %s ---\n", $2; p=0; } NF == 0u { continue } {if (p==0) continue; print $0 }' if [[ $N -ge 2 ]]; then sid1=${sids[$((N-2))]} # Gets 2nd to last sid if [[ $fmt == "text" ]]; then $SCCS prs -l -r$sid1 $cfile 2>/dev/null | \ $AWK "$nawkprg" return fi $SCCS prs -l -r$sid1 $cfile 2>/dev/null | \ html_quote | its2url | $AWK "$nawkprg" fi } # # comments_from_wx {text|html} filepath # # Given the pathname of a file, find its location in a "wx" active # file list and print the following comment. Output is either text or # HTML; if the latter, embedded bugids (sequence of 5 or more digits) # are turned into URLs. # # This is also used with Mercurial and the file list provided by hg-active. # comments_from_wx() { typeset fmt=$1 typeset p=$2 comm=`$AWK ' $1 == "'$p'" { do getline ; while (NF > 0) getline while (NF > 0) { print ; getline } exit }' < $wxfile` if [[ -z $comm ]]; then comm="*** NO COMMENTS ***" fi if [[ $fmt == "text" ]]; then print -- "$comm" return fi print -- "$comm" | html_quote | its2url } # # 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 if [[ -n $Nflag ]]; then return fi # # Mercurial support uses a file list in wx format, so this # will be used there, too # if [[ -n $wxfile ]]; then comments_from_wx $fmt $p else if [[ $SCM_MODE == "teamware" ]]; then comments_from_teamware $fmt $pp $p fi fi } # # printCI # # 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\n' \ $tot $str $ins $del $mod $unc } # # difflines # # 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 "" printCI $tot $ins $del $mod $unc print "" } # # flist_from_wx # # Sets up webrev to source its information from a wx-formatted file. # Sets the global 'wxfile' variable. # function flist_from_wx { typeset argfile=$1 if [[ -n ${argfile%%/*} ]]; then # # If the wx file pathname is relative then make it absolute # because the webrev does a "cd" later on. # wxfile=$PWD/$argfile else wxfile=$argfile fi $AWK '{ c = 1; print; while (getline) { if (NF == 0) { c = -c; continue } if (c > 0) print } }' $wxfile > $FLIST print " Done." } # # flist_from_teamware [ ] # # Generate the file list by extracting file names from a putback -n. Some # names may come from the "update/create" messages and others from the # "currently checked out" warning. Renames are detected here too. Extract # values for CODEMGR_WS and CODEMGR_PARENT from the output of the putback # -n as well, but remove them if they are already defined. # function flist_from_teamware { if [[ -n $codemgr_parent && -z $parent_webrev ]]; then if [[ ! -d $codemgr_parent/Codemgr_wsdata ]]; then print -u2 "parent $codemgr_parent doesn't look like a" \ "valid teamware workspace" exit 1 fi parent_args="-p $codemgr_parent" fi print " File list from: 'putback -n $parent_args $*' ... \c" putback -n $parent_args $* 2>&1 | $AWK ' /^update:|^create:/ {print $2} /^Parent workspace:/ {printf("CODEMGR_PARENT=%s\n",$3)} /^Child workspace:/ {printf("CODEMGR_WS=%s\n",$3)} /^The following files are currently checked out/ {p = 1; continue} NF == 0 {p=0 ; continue} /^rename/ {old=$3} $1 == "to:" {print $2, old} /^"/ {continue} p == 1 {print $1}' | sort -r -k 1,1 -u | sort > $FLIST print " Done." } # # Call hg-active to get the active list output in the wx active list format # function hg_active_wxfile { typeset child=$1 typeset parent=$2 TMPFLIST=/tmp/$$.active $HG_ACTIVE -w $child -p $parent -o $TMPFLIST wxfile=$TMPFLIST } # # flist_from_mercurial # Call hg-active to get a wx-style active list, and hand it off to # flist_from_wx # function flist_from_mercurial { typeset child=$1 typeset parent=$2 print " File list from: hg-active -p $parent ...\c" if [[ ! -x $HG_ACTIVE ]]; then print # Blank line for the \c above print -u2 "Error: hg-active tool not found. Exiting" exit 1 fi hg_active_wxfile $child $parent # flist_from_wx prints the Done, so we don't have to. flist_from_wx $TMPFLIST } # # Transform a specified 'git log' output format into a wx-like active list. # function git_wxfile { typeset child="$1" typeset parent="$2" TMPFLIST=/tmp/$$.active $PERL -e 'my (%files, %realfiles, $msg); my $branch = $ARGV[0]; open(F, "git diff -M --name-status $branch |"); while () { chomp; if (/^R(\d+)\s+([^ ]+)\s+([^ ]+)/) { # rename if ($1 >= 75) { # Probably worth treating as a rename $realfiles{$3} = $2; } else { $realfiles{$3} = $3; $realfiles{$2} = $2; } } else { my $f = (split /\s+/, $_)[1]; $realfiles{$f} = $f; } } close(F); my $state = 1; # 0|comments, 1|files open(F, "git whatchanged --pretty=format:%B $branch.. |"); while () { chomp; if (/^:[0-9]{6}/) { my $fname = (split /\t/, $_)[1]; next if !defined($realfiles{$fname}); # No real change $state = 1; chomp $msg; $files{$fname} .= $msg; } else { if ($state == 1) { $state = 0; $msg = /^\n/ ? "" : "\n"; } $msg .= "$_\n" if ($_); } } close(F); for (sort keys %files) { if ($realfiles{$_} ne $_) { print "$_ $realfiles{$_}\n$files{$_}\n\n"; } else { print "$_\n$files{$_}\n\n" } }' ${parent} > $TMPFLIST wxfile=$TMPFLIST } # # flist_from_git # Build a wx-style active list, and hand it off to flist_from_wx # function flist_from_git { typeset child=$1 typeset parent=$2 print " File list from: git ...\c" git_wxfile "$child" "$parent"; # flist_from_wx prints the Done, so we don't have to. flist_from_wx $TMPFLIST } # # flist_from_subversion # # Generate the file list by extracting file names from svn status. # function flist_from_subversion { CWS=$1 OLDPWD=$2 cd $CWS print -u2 " File list from: svn status ... \c" svn status | $AWK '/^[ACDMR]/ { print $NF }' > $FLIST print -u2 " Done." cd $OLDPWD } 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 = ` if [[ -z $codemgr_ws && -n $CODEMGR_WS ]]; then codemgr_ws=$CODEMGR_WS export CODEMGR_WS fi # # Check to see if CODEMGR_PARENT is set in the flist file. # if [[ -z $codemgr_parent && -n $CODEMGR_PARENT ]]; then codemgr_parent=$CODEMGR_PARENT export CODEMGR_PARENT fi } function look_for_prog { typeset path typeset ppath typeset progname=$1 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` PATH=$ppath prog=`whence $progname` if [[ -n $prog ]]; then print $prog fi } function get_file_mode { $PERL -e ' if (@stat = stat($ARGV[0])) { $mode = $stat[2] & 0777; printf "%03o\n", $mode; exit 0; } else { exit 1; } ' $1 } function build_old_new_teamware { typeset olddir="$1" typeset newdir="$2" # If the child's version doesn't exist then # get a readonly copy. if [[ ! -f $CWS/$DIR/$F && -f $CWS/$DIR/SCCS/s.$F ]]; then $SCCS get -s -p $CWS/$DIR/$F > $CWS/$DIR/$F fi # The following two sections propagate file permissions the # same way SCCS does. If the file is already under version # control, always use permissions from the SCCS/s.file. If # the file is not under SCCS control, use permissions from the # working copy. In all cases, the file copied to the webrev # is set to read only, and group/other permissions are set to # match those of the file owner. This way, even if the file # is currently checked out, the webrev will display the final # permissions that would result after check in. # # Snag new version of file. # rm -f $newdir/$DIR/$F cp $CWS/$DIR/$F $newdir/$DIR/$F if [[ -f $CWS/$DIR/SCCS/s.$F ]]; then chmod `get_file_mode $CWS/$DIR/SCCS/s.$F` \ $newdir/$DIR/$F fi chmod u-w,go=u $newdir/$DIR/$F # # Get the parent's version of the file. First see whether the # child's version is checked out and get the parent's version # with keywords expanded or unexpanded as appropriate. # if [[ -f $PWS/$PDIR/$PF && ! -f $PWS/$PDIR/SCCS/s.$PF && \ ! -f $PWS/$PDIR/SCCS/p.$PF ]]; then # Parent is not a real workspace, but just a raw # directory tree - use the file that's there as # the old file. rm -f $olddir/$PDIR/$PF cp $PWS/$PDIR/$PF $olddir/$PDIR/$PF else if [[ -f $PWS/$PDIR/SCCS/s.$PF ]]; then real_parent=$PWS else real_parent=$RWS fi rm -f $olddir/$PDIR/$PF if [[ -f $real_parent/$PDIR/$PF ]]; then if [ -f $CWS/$DIR/SCCS/p.$F ]; then $SCCS get -s -p -k $real_parent/$PDIR/$PF > \ $olddir/$PDIR/$PF else $SCCS get -s -p $real_parent/$PDIR/$PF > \ $olddir/$PDIR/$PF fi chmod `get_file_mode $real_parent/$PDIR/SCCS/s.$PF` \ $olddir/$PDIR/$PF fi fi if [[ -f $olddir/$PDIR/$PF ]]; then chmod u-w,go=u $olddir/$PDIR/$PF fi } function build_old_new_mercurial { typeset olddir="$1" typeset newdir="$2" typeset old_mode= typeset new_mode= typeset file # # Get old file mode, from the parent revision manifest entry. # Mercurial only stores a "file is executable" flag, but the # manifest will display an octal mode "644" or "755". # if [[ "$PDIR" == "." ]]; then file="$PF" else file="$PDIR/$PF" fi file=`echo $file | $SED 's#/#\\\/#g'` # match the exact filename, and return only the permission digits old_mode=`$SED -n -e "/^\\(...\\) . ${file}$/s//\\1/p" \ < $HG_PARENT_MANIFEST` # # Get new file mode, directly from the filesystem. # Normalize the mode to match Mercurial's behavior. # new_mode=`get_file_mode $CWS/$DIR/$F` if [[ -n "$new_mode" ]]; then if [[ "$new_mode" = *[1357]* ]]; then new_mode=755 else new_mode=644 fi fi # # new version of the file. # rm -rf $newdir/$DIR/$F if [[ -e $CWS/$DIR/$F ]]; then cp $CWS/$DIR/$F $newdir/$DIR/$F if [[ -n $new_mode ]]; then chmod $new_mode $newdir/$DIR/$F else # should never happen print -u2 "ERROR: set mode of $newdir/$DIR/$F" fi fi # # parent's version of the file # # Note that we get this from the last version common to both # ourselves and the parent. References are via $CWS since we have no # guarantee that the parent workspace is reachable via the filesystem. # if [[ -n $parent_webrev && -e $PWS/$PDIR/$PF ]]; then cp $PWS/$PDIR/$PF $olddir/$PDIR/$PF elif [[ -n $HG_PARENT ]]; then hg cat -R $CWS -r $HG_PARENT $CWS/$PDIR/$PF > \ $olddir/$PDIR/$PF 2>/dev/null if (( $? != 0 )); then rm -f $olddir/$PDIR/$PF else if [[ -n $old_mode ]]; then chmod $old_mode $olddir/$PDIR/$PF else # should never happen print -u2 "ERROR: set mode of $olddir/$PDIR/$PF" fi fi fi } function build_old_new_git { typeset olddir="$1" typeset newdir="$2" typeset o_mode= typeset n_mode= typeset o_object= typeset n_object= typeset OWD=$PWD typeset file typeset type cd $CWS # # Get old file and its mode from the git object tree # if [[ "$PDIR" == "." ]]; then file="$PF" else file="$PDIR/$PF" fi if [[ -n $parent_webrev && -e $PWS/$PDIR/$PF ]]; then cp $PWS/$PDIR/$PF $olddir/$PDIR/$PF else $GIT ls-tree $GIT_PARENT $file | read o_mode type o_object junk $GIT cat-file $type $o_object > $olddir/$file 2>/dev/null if (( $? != 0 )); then rm -f $olddir/$file elif [[ -n $o_mode ]]; then # Strip the first 3 digits, to get a regular octal mode o_mode=${o_mode/???/} chmod $o_mode $olddir/$file else # should never happen print -u2 "ERROR: set mode of $olddir/$file" fi fi # # new version of the file. # if [[ "$DIR" == "." ]]; then file="$F" else file="$DIR/$F" fi rm -rf $newdir/$file if [[ -e $CWS/$DIR/$F ]]; then cp $CWS/$DIR/$F $newdir/$DIR/$F chmod $(get_file_mode $CWS/$DIR/$F) $newdir/$DIR/$F fi cd $OWD } function build_old_new_subversion { typeset olddir="$1" typeset newdir="$2" # Snag new version of file. rm -f $newdir/$DIR/$F [[ -e $CWS/$DIR/$F ]] && cp $CWS/$DIR/$F $newdir/$DIR/$F if [[ -n $PWS && -e $PWS/$PDIR/$PF ]]; then cp $PWS/$PDIR/$PF $olddir/$PDIR/$PF else # Get the parent's version of the file. svn status $CWS/$DIR/$F | read stat file if [[ $stat != "A" ]]; then svn cat -r BASE $CWS/$DIR/$F > $olddir/$PDIR/$PF fi fi } function build_old_new_unknown { typeset olddir="$1" typeset newdir="$2" # # Snag new version of file. # rm -f $newdir/$DIR/$F [[ -e $CWS/$DIR/$F ]] && cp $CWS/$DIR/$F $newdir/$DIR/$F # # Snag the parent's version of the file. # if [[ -f $PWS/$PDIR/$PF ]]; then rm -f $olddir/$PDIR/$PF cp $PWS/$PDIR/$PF $olddir/$PDIR/$PF fi } function build_old_new { typeset WDIR=$1 typeset PWS=$2 typeset PDIR=$3 typeset PF=$4 typeset CWS=$5 typeset DIR=$6 typeset F=$7 typeset olddir="$WDIR/raw_files/old" typeset newdir="$WDIR/raw_files/new" mkdir -p $olddir/$PDIR mkdir -p $newdir/$DIR if [[ $SCM_MODE == "teamware" ]]; then build_old_new_teamware "$olddir" "$newdir" elif [[ $SCM_MODE == "mercurial" ]]; then build_old_new_mercurial "$olddir" "$newdir" elif [[ $SCM_MODE == "git" ]]; then build_old_new_git "$olddir" "$newdir" elif [[ $SCM_MODE == "subversion" ]]; then build_old_new_subversion "$olddir" "$newdir" elif [[ $SCM_MODE == "unknown" ]]; then build_old_new_unknown "$olddir" "$newdir" fi if [[ ! -f $olddir/$PDIR/$PF && ! -f $newdir/$DIR/$F ]]; then print "*** Error: file not in parent or child" return 1 fi return 0 } # # Usage message. # function usage { print 'Usage:\twebrev [common-options] webrev [common-options] ( | - ) webrev [common-options] -w Options: -C : Use for the information tracking configuration. -D: delete remote webrev -i : Include in the index.html file. -I : Use for the information tracking registry. -n: do not generate the webrev (useful with -U) -O: Print bugids/arc cases suitable for OpenSolaris. -o : Output webrev to specified directory. -p : Use specified parent wkspc or basis for comparison -t : Specify remote destination for webrev upload -U: upload the webrev to remote destination -w : Use specified wx active file. Environment: WDIR: Control the output directory. WEBREV_TRASH_DIR: Set directory for webrev delete. SCM Specific Options: TeamWare: webrev [common-options] -l [arguments to 'putback'] SCM Environment: CODEMGR_WS: Workspace location. CODEMGR_PARENT: Parent workspace location. ' exit 2 } # # # Main program starts here # # trap "rm -f /tmp/$$.* ; exit" 0 1 2 3 15 set +o noclobber PATH=$(/bin/dirname "$(whence $0)"):$PATH [[ -z $WDIFF ]] && WDIFF=`look_for_prog wdiff` [[ -z $WX ]] && WX=`look_for_prog wx` [[ -z $HG_ACTIVE ]] && HG_ACTIVE=`look_for_prog hg-active` [[ -z $GIT ]] && GIT=`look_for_prog git` [[ -z $WHICH_SCM ]] && WHICH_SCM=`look_for_prog which_scm` [[ -z $CODEREVIEW ]] && CODEREVIEW=`look_for_prog codereview` [[ -z $PS2PDF ]] && PS2PDF=`look_for_prog ps2pdf` [[ -z $PERL ]] && PERL=`look_for_prog perl` [[ -z $RSYNC ]] && RSYNC=`look_for_prog rsync` [[ -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 $SCP ]] && SCP=`look_for_prog scp` [[ -z $SED ]] && SED=`look_for_prog sed` [[ -z $SFTP ]] && SFTP=`look_for_prog sftp` [[ -z $SORT ]] && SORT=`look_for_prog sort` [[ -z $MKTEMP ]] && MKTEMP=`look_for_prog mktemp` [[ -z $GREP ]] && GREP=`look_for_prog grep` [[ -z $FIND ]] && FIND=`look_for_prog find` # set name of trash directory for remote webrev deletion TRASH_DIR=".trash" [[ -n $WEBREV_TRASH_DIR ]] && TRASH_DIR=$WEBREV_TRASH_DIR if [[ ! -x $PERL ]]; then print -u2 "Error: No perl interpreter found. Exiting." exit 1 fi if [[ ! -x $WHICH_SCM ]]; then print -u2 "Error: Could not find which_scm. Exiting." exit 1 fi # # These aren't fatal, but we want to note them to the user. # We don't warn on the absence of 'wx' until later when we've # determined that we actually need to try to invoke it. # [[ ! -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 # default remote host for upload/delete typeset -r DEFAULT_REMOTE_HOST="cr.opensolaris.org" # prefixes for upload targets typeset -r rsync_prefix="rsync://" typeset -r ssh_prefix="ssh://" Cflag= Dflag= flist_mode= flist_file= iflag= Iflag= lflag= Nflag= nflag= Oflag= oflag= pflag= tflag= uflag= Uflag= wflag= remote_target= # # NOTE: when adding/removing options it is necessary to sync the list # with usr/src/tools/onbld/hgext/cdm.py # while getopts "C:Di:I:lnNo:Op:t:Uw" opt do case $opt in C) Cflag=1 ITSCONF=$OPTARG;; D) Dflag=1;; i) iflag=1 INCLUDE_FILE=$OPTARG;; I) Iflag=1 ITSREG=$OPTARG;; # # If -l has been specified, we need to abort further options # processing, because subsequent arguments are going to be # arguments to 'putback -n'. # l) lflag=1 break;; N) Nflag=1;; n) nflag=1;; O) Oflag=1;; o) oflag=1 # Strip the trailing slash to correctly form remote target. WDIR=${OPTARG%/};; p) pflag=1 codemgr_parent=$OPTARG;; t) tflag=1 remote_target=$OPTARG;; U) Uflag=1;; w) wflag=1;; ?) usage;; esac done FLIST=/tmp/$$.flist if [[ -n $wflag && -n $lflag ]]; then usage fi # more sanity checking if [[ -n $nflag && -z $Uflag ]]; then print "it does not make sense to skip webrev generation" \ "without -U" exit 1 fi if [[ -n $tflag && -z $Uflag && -z $Dflag ]]; then echo "remote target has to be used only for upload or delete" exit 1 fi # # For the invocation "webrev -n -U" with no other options, webrev will assume # that the webrev exists in ${CWS}/webrev, but will upload it using the name # $(basename ${CWS}). So we need to get CWS set before we skip any remaining # logic. # $WHICH_SCM | read SCM_MODE junk || exit 1 if [[ $SCM_MODE == "teamware" ]]; then # # Teamware priorities: # 1. CODEMGR_WS from the environment # 2. workspace name # [[ -z $codemgr_ws && -n $CODEMGR_WS ]] && codemgr_ws=$CODEMGR_WS if [[ -n $codemgr_ws && ! -d $codemgr_ws ]]; then print -u2 "$codemgr_ws: no such workspace" exit 1 fi [[ -z $codemgr_ws ]] && codemgr_ws=$(workspace name) codemgr_ws=$(cd $codemgr_ws;print $PWD) CODEMGR_WS=$codemgr_ws CWS=$codemgr_ws elif [[ $SCM_MODE == "mercurial" ]]; then # # Mercurial priorities: # 1. hg root from CODEMGR_WS environment variable # 1a. hg root from CODEMGR_WS/usr/closed if we're somewhere under # usr/closed when we run webrev # 2. hg root from directory of invocation # if [[ ${PWD} =~ "usr/closed" ]]; then testparent=${CODEMGR_WS}/usr/closed # If we're in OpenSolaris mode, we enforce a minor policy: # help to make sure the reviewer doesn't accidentally publish # source which is under usr/closed if [[ -n "$Oflag" ]]; then print -u2 "OpenSolaris output not permitted with" \ "usr/closed changes" exit 1 fi else testparent=${CODEMGR_WS} fi [[ -z $codemgr_ws && -n $testparent ]] && \ codemgr_ws=$(hg root -R $testparent 2>/dev/null) [[ -z $codemgr_ws ]] && codemgr_ws=$(hg root 2>/dev/null) CWS=$codemgr_ws elif [[ $SCM_MODE == "git" ]]; then # # Git priorities: # 1. git rev-parse --git-dir from CODEMGR_WS environment variable # 2. git rev-parse --git-dir from directory of invocation # [[ -z $codemgr_ws && -n $CODEMGR_WS ]] && \ codemgr_ws=$($GIT --git-dir=$CODEMGR_WS/.git rev-parse --git-dir \ 2>/dev/null) [[ -z $codemgr_ws ]] && \ codemgr_ws=$($GIT rev-parse --git-dir 2>/dev/null) if [[ "$codemgr_ws" == ".git" ]]; then codemgr_ws="${PWD}/${codemgr_ws}" fi codemgr_ws=$(dirname $codemgr_ws) # Lose the '/.git' CWS="$codemgr_ws" elif [[ $SCM_MODE == "subversion" ]]; then # # Subversion priorities: # 1. CODEMGR_WS from environment # 2. Relative path from current directory to SVN repository root # if [[ -n $CODEMGR_WS && -d $CODEMGR_WS/.svn ]]; then CWS=$CODEMGR_WS else svn info | while read line; do if [[ $line == "URL: "* ]]; then url=${line#URL: } elif [[ $line == "Repository Root: "* ]]; then repo=${line#Repository Root: } fi done rel=${url#$repo} CWS=${PWD%$rel} fi fi # # If no SCM has been determined, take either the environment setting # setting for CODEMGR_WS, or the current directory if that wasn't set. # if [[ -z ${CWS} ]]; then CWS=${CODEMGR_WS:-.} fi # # If the command line options indicate no webrev generation, either # explicitly (-n) or implicitly (-D but not -U), then there's a whole # ton of logic we can skip. # # Instead of increasing indentation, we intentionally leave this loop # body open here, and exit via break from multiple points within. # Search for DO_EVERYTHING below to find the break points and closure. # for do_everything in 1; do # DO_EVERYTHING: break point if [[ -n $nflag || ( -z $Uflag && -n $Dflag ) ]]; then break 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=$(readlink -f "$codemgr_parent") codemgr_parent=$(readlink -f "$codemgr_parent/raw_files/new") fi if [[ -z $wflag && -z $lflag ]]; then 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 fi # # Before we go on to further consider -l and -w, work out which SCM we think # is in use. # case "$SCM_MODE" in teamware|mercurial|git|subversion) ;; unknown) if [[ $flist_mode == "auto" ]]; then print -u2 "Unable to determine SCM in use and file list not specified" print -u2 "See which_scm(1) for SCM detection information." exit 1 fi ;; *) if [[ $flist_mode == "auto" ]]; then print -u2 "Unsupported SCM in use ($SCM_MODE) and file list not specified" exit 1 fi ;; esac print -u2 " SCM detected: $SCM_MODE" if [[ -n $lflag ]]; then # # If the -l flag is given instead of the name of a file list, # then generate the file list by extracting file names from a # putback -n. # shift $(($OPTIND - 1)) if [[ $SCM_MODE == "teamware" ]]; then flist_from_teamware "$*" else print -u2 -- "Error: -l option only applies to TeamWare" exit 1 fi flist_done=1 shift $# elif [[ -n $wflag ]]; then # # If the -w is given then assume the file list is in Bonwick's "wx" # command format, i.e. pathname lines alternating with SCCS comment # lines with blank lines as separators. Use the SCCS comments later # in building the index.html file. # shift $(($OPTIND - 1)) wxfile=$1 if [[ -z $wxfile && -n $CODEMGR_WS ]]; then if [[ -r $CODEMGR_WS/wx/active ]]; then wxfile=$CODEMGR_WS/wx/active fi fi [[ -z $wxfile ]] && print -u2 "wx file not specified, and could not " \ "be auto-detected (check \$CODEMGR_WS)" && exit 1 if [[ ! -r $wxfile ]]; then print -u2 "$wxfile: no such file or not readable" usage fi print -u2 " File list from: wx 'active' file '$wxfile' ... \c" flist_from_wx $wxfile flist_done=1 if [[ -n "$*" ]]; then shift fi elif [[ $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 # # Before we entered the DO_EVERYTHING loop, we should have already set CWS # and CODEMGR_WS as needed. Here, we set the parent workspace. # if [[ $SCM_MODE == "teamware" ]]; then # # Teamware priorities: # # 1) via -p command line option # 2) in the user environment # 3) in the flist # 4) automatically based on the workspace # # # For 1, codemgr_parent will already be set. Here's 2: # [[ -z $codemgr_parent && -n $CODEMGR_PARENT ]] && \ codemgr_parent=$CODEMGR_PARENT if [[ -n $codemgr_parent && ! -d $codemgr_parent ]]; then print -u2 "$codemgr_parent: no such directory" exit 1 fi # # If we're in auto-detect mode and we haven't already gotten the file # list, then see if we can get it by probing for wx. # if [[ -z $flist_done && $flist_mode == "auto" && -n $codemgr_ws ]]; then if [[ ! -x $WX ]]; then print -u2 "WARNING: wx not found!" fi # # We need to use wx list -w so that we get renamed files, etc. # but only if a wx active file exists-- otherwise wx will # hang asking us to initialize our wx information. # if [[ -x $WX && -f $codemgr_ws/wx/active ]]; then print -u2 " File list from: 'wx list -w' ... \c" $WX list -w > $FLIST $WX comments > /tmp/$$.wx_comments wxfile=/tmp/$$.wx_comments print -u2 "done" flist_done=1 fi fi # # If by hook or by crook we've gotten a file list by now (perhaps # from the command line), eval it to extract environment variables from # it: This is method 3 for finding the parent. # if [[ -z $flist_done ]]; then flist_from_teamware fi env_from_flist # # (4) If we still don't have a value for codemgr_parent, get it # from workspace. # [[ -z $codemgr_parent ]] && codemgr_parent=`workspace parent` if [[ ! -d $codemgr_parent ]]; then print -u2 "$CODEMGR_PARENT: no such parent workspace" exit 1 fi PWS=$codemgr_parent [[ -n $parent_webrev ]] && RWS=$(workspace parent $CWS) elif [[ $SCM_MODE == "mercurial" ]]; then # # Parent can either be specified with -p # Specified with CODEMGR_PARENT in the environment # or taken from hg's default path. # if [[ -z $codemgr_parent && -n $CODEMGR_PARENT ]]; then codemgr_parent=$CODEMGR_PARENT fi if [[ -z $codemgr_parent ]]; then codemgr_parent=`hg path -R $codemgr_ws default 2>/dev/null` fi PWS=$codemgr_parent # # If the parent is a webrev, we want to do some things against # the natural workspace parent (file list, comments, etc) # if [[ -n $parent_webrev ]]; then real_parent=$(hg path -R $codemgr_ws default 2>/dev/null) else real_parent=$PWS fi # # If hg-active exists, then we run it. In the case of no explicit # flist given, we'll use it for our comments. In the case of an # explicit flist given we'll try to use it for comments for any # files mentioned in the flist. # if [[ -z $flist_done ]]; then flist_from_mercurial $CWS $real_parent flist_done=1 fi # # If we have a file list now, pull out any variables set # therein. We do this now (rather than when we possibly use # hg-active to find comments) to avoid stomping specifications # in the user-specified flist. # if [[ -n $flist_done ]]; then env_from_flist fi # # Only call hg-active if we don't have a wx formatted file already # if [[ -x $HG_ACTIVE && -z $wxfile ]]; then print " Comments from: hg-active -p $real_parent ...\c" hg_active_wxfile $CWS $real_parent print " Done." fi # # At this point we must have a wx flist either from hg-active, # or in general. Use it to try and find our parent revision, # if we don't have one. # if [[ -z $HG_PARENT ]]; then eval `$SED -e "s/#.*$//" $wxfile | $GREP HG_PARENT=` fi # # If we still don't have a parent, we must have been given a # wx-style active list with no HG_PARENT specification, run # hg-active and pull an HG_PARENT out of it, ignore the rest. # if [[ -z $HG_PARENT && -x $HG_ACTIVE ]]; then $HG_ACTIVE -w $codemgr_ws -p $real_parent | \ eval `$SED -e "s/#.*$//" | $GREP HG_PARENT=` elif [[ -z $HG_PARENT ]]; then print -u2 "Error: Cannot discover parent revision" exit 1 fi pnode=$(trim_digest $HG_PARENT) PRETTY_PWS="${PWS} (at ${pnode})" cnode=$(hg parent -R $codemgr_ws --template '{node|short}' \ 2>/dev/null) PRETTY_CWS="${CWS} (at ${cnode})"} elif [[ $SCM_MODE == "git" ]]; then # # Parent can either be specified with -p, or specified with # CODEMGR_PARENT in the environment. # if [[ -z $codemgr_parent && -n $CODEMGR_PARENT ]]; then codemgr_parent=$CODEMGR_PARENT fi # Try to figure out the parent based on the branch the current # branch is tracking, if we fail, use origin/master this_branch=$($GIT branch | nawk '$1 == "*" { print $2 }') par_branch="origin/master" # If we're not on a branch there's nothing we can do if [[ $this_branch != "(no branch)" ]]; then $GIT for-each-ref \ --format='%(refname:short) %(upstream:short)' refs/heads/ | \ while read local remote; do \ [[ "$local" == "$this_branch" ]] && par_branch="$remote"; \ done fi if [[ -z $codemgr_parent ]]; then codemgr_parent=$par_branch fi PWS=$codemgr_parent # # If the parent is a webrev, we want to do some things against # the natural workspace parent (file list, comments, etc) # if [[ -n $parent_webrev ]]; then real_parent=$par_branch else real_parent=$PWS fi if [[ -z $flist_done ]]; then flist_from_git "$CWS" "$real_parent" flist_done=1 fi # # If we have a file list now, pull out any variables set # therein. # if [[ -n $flist_done ]]; then env_from_flist fi # # If we don't have a wx-format file list, build one we can pull change # comments from. # if [[ -z $wxfile ]]; then print " Comments from: git...\c" git_wxfile "$CWS" "$real_parent" print " Done." fi if [[ -z $GIT_PARENT ]]; then GIT_PARENT=$($GIT merge-base "$real_parent" HEAD) fi if [[ -z $GIT_PARENT ]]; then print -u2 "Error: Cannot discover parent revision" exit 1 fi pnode=$(trim_digest $GIT_PARENT) if [[ $real_parent == */* ]]; then origin=$(echo $real_parent | cut -d/ -f1) origin=$($GIT remote -v | \ $AWK '$1 == "'$origin'" { print $2; exit }') PRETTY_PWS="${PWS} (${origin} at ${pnode})" else PRETTY_PWS="${PWS} (at ${pnode})" fi cnode=$($GIT --git-dir=${codemgr_ws}/.git rev-parse --short=12 HEAD \ 2>/dev/null) PRETTY_CWS="${CWS} (at ${cnode})" elif [[ $SCM_MODE == "subversion" ]]; then # # We only will have a real parent workspace in the case one # was specified (be it an older webrev, or another checkout). # [[ -n $codemgr_parent ]] && PWS=$codemgr_parent if [[ -z $flist_done && $flist_mode == "auto" ]]; then flist_from_subversion $CWS $OLDPWD fi else if [[ $SCM_MODE == "unknown" ]]; then print -u2 " Unknown type of SCM in use" else print -u2 " Unsupported SCM in use: $SCM_MODE" fi env_from_flist if [[ -z $CODEMGR_WS ]]; then print -u2 "SCM not detected/supported and CODEMGR_WS not specified" exit 1 fi if [[ -z $CODEMGR_PARENT ]]; then print -u2 "SCM not detected/supported and CODEMGR_PARENT not specified" exit 1 fi CWS=$CODEMGR_WS PWS=$CODEMGR_PARENT 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 # DO_EVERYTHING: break point if [[ -n $Nflag ]]; then break fi typeset -A itsinfo typeset -r its_sed_script=/tmp/$$.its_sed valid_prefixes= if [[ -z $nflag ]]; then DEFREGFILE="$(/bin/dirname "$(whence $0)")/../etc/its.reg" if [[ -n $Iflag ]]; then REGFILE=$ITSREG elif [[ -r $HOME/.its.reg ]]; then REGFILE=$HOME/.its.reg else REGFILE=$DEFREGFILE fi if [[ ! -r $REGFILE ]]; then print "ERROR: Unable to read database registry file $REGFILE" exit 1 elif [[ $REGFILE != $DEFREGFILE ]]; then print " its.reg from: $REGFILE" fi $SED -e '/^#/d' -e '/^[ ]*$/d' $REGFILE | while read LINE; do name=${LINE%%=*} value="${LINE#*=}" if [[ $name == PREFIX ]]; then p=${value} valid_prefixes="${p} ${valid_prefixes}" else itsinfo["${p}_${name}"]="${value}" fi done DEFCONFFILE="$(/bin/dirname "$(whence $0)")/../etc/its.conf" CONFFILES=$DEFCONFFILE if [[ -r $HOME/.its.conf ]]; then CONFFILES="${CONFFILES} $HOME/.its.conf" fi if [[ -n $Cflag ]]; then CONFFILES="${CONFFILES} ${ITSCONF}" fi its_domain= its_priority= for cf in ${CONFFILES}; do if [[ ! -r $cf ]]; then print "ERROR: Unable to read database configuration file $cf" exit 1 elif [[ $cf != $DEFCONFFILE ]]; then print " its.conf: reading $cf" fi $SED -e '/^#/d' -e '/^[ ]*$/d' $cf | while read LINE; do eval "${LINE}" done done # # If an information tracking system is explicitly identified by prefix, # we want to disregard the specified priorities and resolve it accordingly. # # To that end, we'll build a sed script to do each valid prefix in turn. # for p in ${valid_prefixes}; do # # When an informational URL was provided, translate it to a # hyperlink. When omitted, simply use the prefix text. # if [[ -z ${itsinfo["${p}_INFO"]} ]]; then itsinfo["${p}_INFO"]=${p} else itsinfo["${p}_INFO"]="${p}" fi # # Assume that, for this invocation of webrev, all references # to this information tracking system should resolve through # the same URL. # # If the caller specified -O, then always use EXTERNAL_URL. # # Otherwise, look in the list of domains for a matching # INTERNAL_URL. # [[ -z $Oflag ]] && for d in ${its_domain}; do if [[ -n ${itsinfo["${p}_INTERNAL_URL_${d}"]} ]]; then itsinfo["${p}_URL"]="${itsinfo[${p}_INTERNAL_URL_${d}]}" break fi done if [[ -z ${itsinfo["${p}_URL"]} ]]; then itsinfo["${p}_URL"]="${itsinfo[${p}_EXTERNAL_URL]}" fi # # Turn the destination URL into a hyperlink # itsinfo["${p}_URL"]="&" # The character class below contains a literal tab print "/^${p}[: ]/ { s;${itsinfo[${p}_REGEX]};${itsinfo[${p}_URL]};g s;^${p};${itsinfo[${p}_INFO]}; }" >> ${its_sed_script} done # # The previous loop took care of explicit specification. Now use # the configured priorities to attempt implicit translations. # for p in ${its_priority}; do print "/^${itsinfo[${p}_REGEX]}[ ]/ { s;^${itsinfo[${p}_REGEX]};${itsinfo[${p}_URL]};g }" >> ${its_sed_script} done fi # # Search for DO_EVERYTHING above for matching "for" statement # and explanation of this terminator. # done # # Output directory. # WDIR=${WDIR:-$CWS/webrev} # # Name of the webrev, derived from the workspace name or output directory; # in the future this could potentially be an option. # if [[ -n $oflag ]]; then WNAME=${WDIR##*/} else WNAME=${CWS##*/} fi # Make sure remote target is well formed for remote upload/delete. if [[ -n $Dflag || -n $Uflag ]]; then # # If remote target is not specified, build it from scratch using # the default values. # if [[ -z $tflag ]]; then remote_target=${DEFAULT_REMOTE_HOST}:${WNAME} else # # Check upload target prefix first. # if [[ "${remote_target}" != ${rsync_prefix}* && "${remote_target}" != ${ssh_prefix}* ]]; then print "ERROR: invalid prefix of upload URI" \ "($remote_target)" exit 1 fi # # If destination specification is not in the form of # host_spec:remote_dir then assume it is just remote hostname # and append a colon and destination directory formed from # local webrev directory name. # typeset target_no_prefix=${remote_target##*://} if [[ ${target_no_prefix} == *:* ]]; then if [[ "${remote_target}" == *: ]]; then remote_target=${remote_target}${WNAME} fi else if [[ ${target_no_prefix} == */* ]]; then print "ERROR: badly formed upload URI" \ "($remote_target)" exit 1 else remote_target=${remote_target}:${WNAME} fi fi fi # # Strip trailing slash. Each upload method will deal with directory # specification separately. # remote_target=${remote_target%/} fi # # Option -D by itself (option -U not present) implies no webrev generation. # if [[ -z $Uflag && -n $Dflag ]]; then delete_webrev 1 1 exit $? fi # # Do not generate the webrev, just upload it or delete it. # if [[ -n $nflag ]]; then if [[ -n $Dflag ]]; then delete_webrev 1 1 (( $? == 0 )) || exit $? fi if [[ -n $Uflag ]]; then upload_webrev exit $? fi fi if [ "${WDIR%%/*}" ]; then WDIR=$PWD/$WDIR fi if [[ ! -d $WDIR ]]; then mkdir -p $WDIR (( $? != 0 )) && exit 1 fi # # Summarize what we're going to do. # print " Workspace: ${PRETTY_CWS:-$CWS}" if [[ -n $parent_webrev ]]; then print "Compare against: webrev at $parent_webrev" else print "Compare against: ${PRETTY_PWS:-$PWS}" 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 rm -f $WDIR/$WNAME.patch 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 # # For Mercurial, create a cache of manifest entries. # if [[ $SCM_MODE == "mercurial" ]]; then # # Transform the FLIST into a temporary sed script that matches # relevant entries in the Mercurial manifest as follows: # 1) The script will be used against the parent revision manifest, # so for FLIST lines that have two filenames (a renamed file) # keep only the old name. # 2) Escape all forward slashes the filename. # 3) Change the filename into another sed command that matches # that file in "hg manifest -v" output: start of line, three # octal digits for file permissions, space, a file type flag # character, space, the filename, end of line. # 4) Eliminate any duplicate entries. (This can occur if a # file has been used as the source of an hg cp and it's # also been modified in the same changeset.) # SEDFILE=/tmp/$$.manifest.sed $SED ' s#^[^ ]* ## s#/#\\\/#g s#^.*$#/^... . &$/p# ' < $FLIST | $SORT -u > $SEDFILE # # Apply the generated script to the output of "hg manifest -v" # to get the relevant subset for this webrev. # HG_PARENT_MANIFEST=/tmp/$$.manifest hg -R $CWS manifest -v -r $HG_PARENT | $SED -n -f $SEDFILE > $HG_PARENT_MANIFEST fi # # First pass through the files: generate the per-file webrev HTML-files. # cat $FLIST | while read LINE do set - $LINE P=$1 # # 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 if [[ -f $PP ]]; then oldname=" (copied from $PP)" else oldname=" (renamed from $PP)" fi 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 COMM=`getcomments html $P $PP` print "\t$P$oldname\n\t\t\c" # Make the webrev mirror directory if necessary mkdir -p $WDIR/$DIR # # We stash old and new files into parallel directories in $WDIR # and do our diffs there. This makes it possible to generate # clean looking diffs which don't have absolute paths present. # build_old_new "$WDIR" "$PWS" "$PDIR" "$PF" "$CWS" "$DIR" "$F" || \ continue # # Keep the old PWD around, so we can safely switch back after # diff generation, such that build_old_new runs in a # consistent environment. # OWD=$PWD 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 # # 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/'" 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 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 # # 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 ]]; then source_to_html Old $PP < $ofile > $WDIR/$DIR/$F-.html print " old\c" fi if [[ -f $nfile ]]; then source_to_html New $P < $nfile > $WDIR/$DIR/$F.html print " new\c" fi cd $OWD print done frame_nav_js > $WDIR/ancnav.js frame_navigation > $WDIR/ancnav.html if [[ ! -f $WDIR/$WNAME.ps ]]; then print " Generating PDF: Skipped: no output available" elif [[ -x $CODEREVIEW && -x $PS2PDF ]]; then print " Generating PDF: \c" fix_postscript $WDIR/$WNAME.ps | $PS2PDF - > $WDIR/$WNAME.pdf print "Done." else print " Generating PDF: Skipped: missing 'ps2pdf' or 'codereview'" fi # If we're in OpenSolaris mode and there's a closed dir under $WDIR, # delete it - prevent accidental publishing of closed source if [[ -n "$Oflag" ]]; then $FIND $WDIR -type d -name closed -exec /bin/rm -rf {} \; 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$STDHEAD" print "$WNAME" print "" print "" print "
" print "

Code Review for $WNAME

" print "" # # Get the preparer's name: # # If the SCM detected is Mercurial, and the configuration property # ui.username is available, use that, but be careful to properly escape # angle brackets (HTML syntax characters) in the email address. # # Otherwise, use the current userid in the form "John Doe (jdoe)", but # to maintain compatibility with passwd(4), we must support '&' substitutions. # preparer= if [[ "$SCM_MODE" == mercurial ]]; then preparer=`hg showconfig ui.username 2>/dev/null` if [[ -n "$preparer" ]]; then preparer="$(echo "$preparer" | html_quote)" fi fi if [[ -z "$preparer" ]]; then preparer=$( $PERL -e ' ($login, $pw, $uid, $gid, $quota, $cmt, $gcos) = getpwuid($<); if ($login) { $gcos =~ s/\&/ucfirst($login)/e; printf "%s (%s)\n", $gcos, $login; } else { printf "(unknown)\n"; } ') fi PREPDATE=$(LC_ALL=C /usr/bin/date +%Y-%b-%d\ %R\ %z\ %Z) print "" print "" print "" print "" if [[ -f $WDIR/$WNAME.patch ]]; then wpatch_url="$(print $WNAME.patch | url_encode)" print "" fi if [[ -f $WDIR/$WNAME.pdf ]]; then wpdf_url="$(print $WNAME.pdf | url_encode)" print "" fi if [[ -n "$iflag" ]]; then print "" fi print "
Prepared by:$preparer on $PREPDATE
Workspace:${PRETTY_CWS:-$CWS}" print "
Compare against:" if [[ -n $parent_webrev ]]; then print "webrev at $parent_webrev" else print "${PRETTY_PWS:-$PWS}" fi print "
Summary of changes:" printCI $TOTL $TINS $TDEL $TMOD $TUNC print "
Patch of changes:" print "$WNAME.patch
Printable review:" print "$WNAME.pdf
Author comments:
" cat /tmp/$$.include print "
" print "
" # # Second pass through the files: generate the rest of the index file # cat $FLIST | while read LINE do set - $LINE P=$1 if [[ $# == 2 ]]; then PP=$2 oldname="$PP" else PP=$P oldname="" fi mv_but_nodiff= cmp $WDIR/raw_files/old/$PP $WDIR/raw_files/new/$P > /dev/null 2>&1 if [[ $? == 0 && -n "$oldname" ]]; then mv_but_nodiff=1 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 "

" # If there's a diffs file, make diffs links if [[ -f $F.cdiff.html ]]; then cdiff_url="$(print $P.cdiff.html | url_encode)" udiff_url="$(print $P.udiff.html | url_encode)" print "Cdiffs" print "Udiffs" if [[ -f $F.wdiff.html && -x $WDIFF ]]; then wdiff_url="$(print $P.wdiff.html | url_encode)" print "Wdiffs" fi sdiff_url="$(print $P.sdiff.html | url_encode)" print "Sdiffs" frames_url="$(print $P.frames.html | url_encode)" print "Frames" else print " ------ ------ ------" if [[ -x $WDIFF ]]; then print " ------" fi print " ------" fi # If there's an old file, make the link if [[ -f $F-.html ]]; then oldfile_url="$(print $P-.html | url_encode)" print "Old" else print " ---" fi # If there's an new file, make the link if [[ -f $F.html ]]; then newfile_url="$(print $P.html | url_encode)" print "New" else print " ---" fi if [[ -f $F.patch ]]; then patch_url="$(print $P.patch | url_encode)" print "Patch" else print " -----" fi if [[ -f $WDIR/raw_files/new/$P ]]; then rawfiles_url="$(print raw_files/new/$P | url_encode)" print "Raw" else print " ---" fi print "$P" # For renamed files, clearly state whether or not they are modified if [[ -f "$oldname" ]]; then if [[ -n "$mv_but_nodiff" ]]; then print "(copied from $oldname)" else print "(copied and modified from $oldname)" fi elif [[ -n "$oldname" ]]; then if [[ -n "$mv_but_nodiff" ]]; then print "(renamed from $oldname)" else print "(renamed and modified from $oldname)" fi fi # If there's an old file, but no new file, the file was deleted if [[ -f $F-.html && ! -f $F.html ]]; then print " (deleted)" fi # # Check for usr/closed and deleted_files/usr/closed # if [ ! -z "$Oflag" ]; then if [[ $P == usr/closed/* || \ $P == deleted_files/usr/closed/* ]]; then print "  Closed source: omitted from" \ "this review" fi fi print "

" # Insert delta comments print "
"
	getcomments html $P $PP
	print "
" # Add additional comments comment print "" # Add count of changes. if [[ -f $F.count ]]; then cat $F.count rm $F.count fi if [[ $SCM_MODE == "teamware" || $SCM_MODE == "mercurial" || $SCM_MODE == "unknown" ]]; then # Include warnings for important file mode situations: # 1) New executable files # 2) Permission changes of any kind # 3) Existing executable files old_mode= if [[ -f $WDIR/raw_files/old/$PP ]]; then old_mode=`get_file_mode $WDIR/raw_files/old/$PP` fi new_mode= if [[ -f $WDIR/raw_files/new/$P ]]; then new_mode=`get_file_mode $WDIR/raw_files/new/$P` fi if [[ -z "$old_mode" && "$new_mode" = *[1357]* ]]; then print "" print "

new executable file: mode $new_mode

" print "
" elif [[ -n "$old_mode" && -n "$new_mode" && "$old_mode" != "$new_mode" ]]; then print "" print "

mode change: $old_mode to $new_mode

" print "
" elif [[ "$new_mode" = *[1357]* ]]; then print "" print "

executable file: mode $new_mode

" print "
" fi fi print "
" done print print print "
" print "

" print "This code review page was prepared using $0." print "Webrev is maintained by the " print "illumos project. The latest version may be obtained" print "here.

" print "" print "" exec 1<&- # Close FD 1. exec 1<&3 # dup FD 3 to restore stdout. exec 3<&- # close FD 3. print "Done." # # If remote deletion was specified and fails do not continue. # if [[ -n $Dflag ]]; then delete_webrev 1 1 (( $? == 0 )) || exit $? fi if [[ -n $Uflag ]]; then upload_webrev exit $? fi