[gcc.git] / contrib / legacy / mklog.pl

#!/usr/bin/perl
# Copyright (C) 2012-2024 Free Software Foundation, Inc.
#
# This file is part of GCC.
#
# GCC is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 3, or (at your option)
# any later version.
#
# GCC is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with GCC; see the file COPYING.  If not, write to
# the Free Software Foundation, 51 Franklin Street, Fifth Floor,
# Boston, MA 02110-1301, USA.

# This script parses a .diff file generated with 'diff -up' or 'diff -cp'
# and adds a skeleton ChangeLog file to the file. It does not try to be
# very smart when parsing function names, but it produces a reasonable
# approximation.
#
# Author: Diego Novillo <dnovillo@google.com> and
#         Cary Coutant <ccoutant@google.com>

use File::Temp;
use File::Copy qw(cp mv);

$date = `date +%Y-%m-%d`; chop ($date);

$dot_mklog_format_msg =
    "The .mklog format is:\n"
    . "NAME = ...\n"
    . "EMAIL = ...\n";

# Create a .mklog to reflect your profile, if necessary.
my $conf = "$ENV{HOME}/.mklog";
if (-f "$conf") {
    open (CONF, "$conf")
	or die "Could not open file '$conf' for reading: $!\n";
    while (<CONF>) {
	if (m/^\s*NAME\s*=\s*(.*?)\s*$/) {
	    $name = $1;
	} elsif (m/^\s*EMAIL\s*=\s*(.*?)\s*$/) {
	    $addr = $1;
	}
    }
    if (!($name && $addr)) {
	die "Could not read .mklog settings.\n"
	    . $dot_mklog_format_msg;
    }
} else {
    $name = `git config user.name`;
    chomp($name);
    $addr = `git config user.email`;
    chomp($addr);

    if (!($name && $addr)) {
	die "Could not read git user.name and user.email settings.\n"
	    . "Please add missing git settings, or create a .mklog file in"
	    . " $ENV{HOME}.\n"
	    . $dot_mklog_format_msg;
    }
}

$gcc_root = $0;
$gcc_root =~ s/[^\\\/]+$/../;

#-----------------------------------------------------------------------------
# Program starts here. You should not need to edit anything below this
# line.
#-----------------------------------------------------------------------------
$inline = 0;
if ($#ARGV == 1 && ("$ARGV[0]" eq "-i" || "$ARGV[0]" eq "--inline")) {
	shift;
	$inline = 1;
} elsif ($#ARGV != 0) {
    $prog = `basename $0`; chop ($prog);
    print <<EOF;
usage: $prog [ -i | --inline ] file.diff

Generate ChangeLog template for file.diff.
It assumes that patch has been created with -up or -cp.
When -i is used, the ChangeLog template is followed by the contents of
file.diff.
When file.diff is -, read standard input.
When -i is used and file.diff is not -, it writes to file.diff, otherwise it
writes to stdout.
EOF
    exit 1;
}

$diff = $ARGV[0];
$dir = `dirname $diff`; chop ($dir);
$basename = `basename $diff`; chop ($basename);
$hdrline = "$date  $name  <$addr>";

sub get_clname ($) {
	return ('ChangeLog', $_[0]) if ($_[0] !~ /[\/\\]/);

	my $dirname = $_[0];
	while ($dirname) {
		my $clname = "$dirname/ChangeLog";
		if (-f "$gcc_root/$clname" || -f "$clname") {
			my $relname = substr ($_[0], length ($dirname) + 1);
			return ($clname, $relname);
		} else {
			$dirname =~ s/[\/\\]?[^\/\\]*$//;
		} 
	}

	return ('Unknown ChangeLog', $_[0]);
}

sub remove_suffixes ($) {
	my $filename = $_[0];
	$filename =~ s/^[ab]\///;
	$filename =~ s/\.jj$//;
	return $filename;
}

sub is_context_hunk_start {
	return @_[0] =~ /^\*\*\*\*\*\** ([a-zA-Z0-9_].*)/;
}

sub is_unified_hunk_start {
	return @_[0] =~ /^@@ .* @@ ([a-zA-Z0-9_].*)/;
}

# Check if line is a top-level declaration.
sub is_top_level {
	my ($function, $is_context_diff) = (@_);
	if (is_unified_hunk_start ($function)
	    || is_context_hunk_start ($function)) {
	    return 1;
	}
	if ($is_context_diff) {
		$function =~ s/^..//;
	} else {
		$function =~ s/^.//;
	}
	return $function && $function !~ /^[\s{#]/;
}

# Read contents of .diff file
open (DFILE, $diff) or die "Could not open file $diff for reading";
chomp (my @diff_lines = <DFILE>);
close (DFILE);

# Array diff_lines is modified by the log generation, so save a copy in
# orig_diff_lines if needed.
if ($inline) {
    @orig_diff_lines = @diff_lines;
}

# For every file in the .diff print all the function names in ChangeLog
# format.
%cl_entries = ();
$change_msg = undef;
$look_for_funs = 0;
$clname = get_clname('');
$line_idx = 0;
foreach (@diff_lines) {
    # Stop processing functions if we found a new file.
	# Remember both left and right names because one may be /dev/null.
    # Don't be fooled by line markers in case of context diff.
    if (!/\*\*\*$/ && /^[+*][+*][+*] +(\S+)/) {
		$left = remove_suffixes ($1);
		$look_for_funs = 0;
	}
    if (!/---$/ && /^--- +(\S+)?/) {
		$right = remove_suffixes ($1);
		$look_for_funs = 0;
	}

	# Check if the body of diff started.
	# We should now have both left and right name,
	# so we can decide filename.

    if ($left && (/^\*{15}/ || /^@@ /)) {
	# If we have not seen any function names in the previous file (ie,
	# $change_msg is empty), we just write out a ':' before starting the next
	# file.
	if ($clname) {
		$cl_entries{$clname} .= $change_msg ? "$change_msg" : ":\n";
	}

	if ($left eq $right) {
		$filename = $left;
	} elsif($left eq '/dev/null') {
		$filename = $right;
	} elsif($right eq '/dev/null') {
		$filename = $left;
	} else {
		my @ldirs = split /[\/\\]/, $left;
		my @rdirs = split /[\/\\]/, $right;

		$filename = '';
		while ((my $l = pop @ldirs) && (my $r = pop @rdirs)) {
			last if ($l ne $r);
			$filename = "$l/$filename";
		}
		$filename =~ s/\/$//;

		if (!$filename) {
			print STDERR "Error: failed to parse diff for $left and $right\n";
			exit 1;
		}
	}
	$left = $right = undef;
	($clname, $relname) = get_clname ($filename);
	$cl_entries{$clname} .= "\t* $relname";
	$change_msg = '';
	$look_for_funs = $filename =~ '\.(c|cpp|C|cc|h|inc|def)$';
    }

    # Context diffs have extra whitespace after first char;
    # remove it to make matching easier.
    if ($is_context_diff) {
      s/^([-+! ]) /\1/;
    }

    # Remember the last line in a diff block that might start
    # a new function.
    if (/^[-+! ]([a-zA-Z0-9_].*)/) {
        $save_fn = $1;
    }

    # Check if file is newly added.
    # Two patterns: for context and unified diff.
    if (/^\*\*\* 0 \*\*\*\*/
        || /^@@ -0,0 \+1.* @@/) {
        $change_msg = $filename =~ /testsuite.*(?<!\.exp)$/ ? ": New test.\n" : ": New file.\n";
        $look_for_funs = 0;
    }

    # Check if file was removed.
    # Two patterns: for context and unified diff.
    if (/^--- 0 ----/
        || /^@@ -1.* \+0,0 @@/) {
        $change_msg = ": Remove.\n";
        $look_for_funs = 0;
    }

    if (is_unified_hunk_start ($diff_lines[$line_idx])) {
        $is_context_diff = 0;
    }
    elsif (is_context_hunk_start ($diff_lines[$line_idx])) {
	    $is_context_diff = 1;
    }

    # If we find a new function, print it in brackets.  Special case if
    # this is the first function in a file.  
    #
    # Note that we don't try too hard to find good matches.  This should
    # return a superset of the actual set of functions in the .diff file.
    #
    # The first pattern works with context diff files (diff -c). The
    # second pattern works with unified diff files (diff -u).
    #
    # The third pattern looks for the starts of functions or classes
    # within a diff block both for context and unified diff files.
    if ($look_for_funs
        && (/^\*\*\*\*\*\** ([a-zA-Z0-9_].*)/
	|| /^@@ .* @@ ([a-zA-Z0-9_].*)/
	|| /^[-+! ](\{)/))
      {
	$_ = $1;
	my $fn;
	if (/^\{/) {
	    # Beginning of a new function.
	    $_ = $save_fn;
	} else {
	    $save_fn = "";
	}
	if (/;$/) {
	    # No usable function name found.
	} elsif (/^((class|struct|union|enum) [a-zA-Z0-9_]+)/) {
	    # Discard stuff after the class/struct/etc. tag.
	    $fn = $1;
	} elsif (/([a-zA-Z0-9_][^(]*)\(/) {
	    # Discard template and function parameters.
	    $fn = $1;
	    1 while ($fn =~ s/<[^<>]*>//);
	    $fn =~ s/[ \t]*$//;
	}
	# Check is function really modified
	$no_real_change = 0;
	$idx = $line_idx;
	# Skip line info in context diffs.
	while ($idx <= $#diff_lines && $is_context_diff
               && $diff_lines[$idx + 1] =~ /^[-\*]{3} [0-9]/) {
		++$idx;
	}
	# Check all lines till the first change
	# for the presence of really changed function
	do {
		++$idx;
		$no_real_change = $idx > $#diff_lines
				  || is_top_level ($diff_lines[$idx], $is_context_diff);
	} while (!$no_real_change && ($diff_lines[$idx] !~ /^[-+!]/));
	if ($fn && !$seen_names{$fn} && !$no_real_change) {
	    # If this is the first function in the file, we display it next
	    # to the filename, so we need an extra space before the opening
	    # brace.
	    if (!$change_msg) {
		$change_msg .= " ";
	    } else {
		$change_msg .= "\t";
	    }

		$change_msg .= "($fn):\n";
	    $seen_names{$fn} = 1;
	}
    }
	$line_idx++;
}

# If we have not seen any function names (ie, $change_msg is empty), we just
# write out a ':'. This happens when there is only one file with no
# functions.
$cl_entries{$clname} .= $change_msg ? "$change_msg\n" : ":\n";

if ($inline && $diff ne "-") {
	# Get a temp filename, rather than an open filehandle, because we use
	# the open to truncate.
	$tmp = mktemp("tmp.XXXXXXXX") or die "Could not create temp file: $!";

	# Copy the permissions to the temp file (in File::Copy module version
	# 2.15 and later).
	cp $diff, $tmp or die "Could not copy patch file to temp file: $!";

	# Open the temp file, clearing contents.
	open (OUTPUTFILE, '>', $tmp) or die "Could not open temp file: $!";
} else {
	*OUTPUTFILE = STDOUT;
}

# Print the log
foreach my $clname (keys %cl_entries) {
	print OUTPUTFILE "$clname:\n\n$hdrline\n\n$cl_entries{$clname}\n";
}

if ($inline) {
	# Append the patch to the log
	foreach (@orig_diff_lines) {
		print OUTPUTFILE "$_\n";
	}
}

if ($inline && $diff ne "-") {
	# Close $tmp
	close(OUTPUTFILE);

	# Write new contents to $diff atomically
	mv $tmp, $diff or die "Could not move temp file to patch file: $!";
}

exit 0;
Commit	Line	Data
ba0d684e	1	#!/usr/bin/perl
a945c346	2	# Copyright (C) 2012-2024 Free Software Foundation, Inc.
ba0d684e DN	3	#
	4	# This file is part of GCC.
	5	#
	6	# GCC is free software; you can redistribute it and/or modify
	7	# it under the terms of the GNU General Public License as published by
	8	# the Free Software Foundation; either version 3, or (at your option)
	9	# any later version.
	10	#
	11	# GCC is distributed in the hope that it will be useful,
	12	# but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	# GNU General Public License for more details.
	15	#
	16	# You should have received a copy of the GNU General Public License
	17	# along with GCC; see the file COPYING. If not, write to
	18	# the Free Software Foundation, 51 Franklin Street, Fifth Floor,
	19	# Boston, MA 02110-1301, USA.
	20
	21	# This script parses a .diff file generated with 'diff -up' or 'diff -cp'
64688189	22	# and adds a skeleton ChangeLog file to the file. It does not try to be
ba0d684e DN	23	# very smart when parsing function names, but it produces a reasonable
	24	# approximation.
	25	#
	26	# Author: Diego Novillo <dnovillo@google.com> and
	27	# Cary Coutant <ccoutant@google.com>
	28
38278d8a TV	29	use File::Temp;
	30	use File::Copy qw(cp mv);
	31
ba0d684e DN	32	$date = `date +%Y-%m-%d`; chop ($date);
ba0d684e DN	33
fdb424cf TV	34	$dot_mklog_format_msg =
	35	"The .mklog format is:\n"
	36	. "NAME = ...\n"
	37	. "EMAIL = ...\n";
26b08681	38
fdb424cf TV	39	# Create a .mklog to reflect your profile, if necessary.
	40	my $conf = "$ENV{HOME}/.mklog";
	41	if (-f "$conf") {
	42	open (CONF, "$conf")
	43	or die "Could not open file '$conf' for reading: $!\n";
	44	while (<CONF>) {
	45	if (m/^\sNAME\s=\s(.?)\s*$/) {
	46	$name = $1;
	47	} elsif (m/^\sEMAIL\s=\s(.?)\s*$/) {
	48	$addr = $1;
	49	}
	50	}
	51	if (!($name && $addr)) {
	52	die "Could not read .mklog settings.\n"
	53	. $dot_mklog_format_msg;
	54	}
	55	} else {
	56	$name = `git config user.name`;
	57	chomp($name);
	58	$addr = `git config user.email`;
	59	chomp($addr);
863aa163	60
fdb424cf TV	61	if (!($name && $addr)) {
	62	die "Could not read git user.name and user.email settings.\n"
	63	. "Please add missing git settings, or create a .mklog file in"
	64	. " $ENV{HOME}.\n"
	65	. $dot_mklog_format_msg;
	66	}
863aa163	67	}
ba0d684e	68
fdb424cf TV	69	$gcc_root = $0;
	70	$gcc_root =~ s/[^\\\/]+$/../;
	71
ba0d684e DN	72	#-----------------------------------------------------------------------------
	73	# Program starts here. You should not need to edit anything below this
	74	# line.
	75	#-----------------------------------------------------------------------------
38278d8a TV	76	$inline = 0;
	77	if ($#ARGV == 1 && ("$ARGV[0]" eq "-i" \|\| "$ARGV[0]" eq "--inline")) {
	78	shift;
	79	$inline = 1;
	80	} elsif ($#ARGV != 0) {
ba0d684e	81	$prog = `basename $0`; chop ($prog);
633e5fbb	82	print <<EOF;
38278d8a	83	usage: $prog [ -i \| --inline ] file.diff
633e5fbb TS	84
	85	Generate ChangeLog template for file.diff.
	86	It assumes that patch has been created with -up or -cp.
38278d8a TV	87	When -i is used, the ChangeLog template is followed by the contents of
38278d8a TV	88	file.diff.
633e5fbb	89	When file.diff is -, read standard input.
38278d8a TV	90	When -i is used and file.diff is not -, it writes to file.diff, otherwise it
38278d8a TV	91	writes to stdout.
633e5fbb	92	EOF
ba0d684e DN	93	exit 1;
	94	}
	95
	96	$diff = $ARGV[0];
	97	$dir = `dirname $diff`; chop ($dir);
	98	$basename = `basename $diff`; chop ($basename);
ba0d684e DN	99	$hdrline = "$date $name <$addr>";
ba0d684e DN	100
b654717c YG	101	sub get_clname ($) {
b654717c YG	102	return ('ChangeLog', $_[0]) if ($_[0] !~ /[\/\\]/);
26b08681	103
26b08681 YG	104	my $dirname = $_[0];
	105	while ($dirname) {
	106	my $clname = "$dirname/ChangeLog";
1f347c50	107	if (-f "$gcc_root/$clname" \|\| -f "$clname") {
b654717c YG	108	my $relname = substr ($_[0], length ($dirname) + 1);
b654717c YG	109	return ($clname, $relname);
26b08681 YG	110	} else {
	111	$dirname =~ s/[\/\\]?[^\/\\]*$//;
	112	}
	113	}
b654717c YG	114
	115	return ('Unknown ChangeLog', $_[0]);
	116	}
	117
	118	sub remove_suffixes ($) {
	119	my $filename = $_[0];
	120	$filename =~ s/^[ab]\///;
	121	$filename =~ s/\.jj$//;
	122	return $filename;
26b08681	123	}
ba0d684e	124
a8cfbbdc MZ	125	sub is_context_hunk_start {
	126	return @_[0] =~ /^\\\\\\* ([a-zA-Z0-9_].*)/;
	127	}
	128
	129	sub is_unified_hunk_start {
	130	return @_[0] =~ /^@@ .* @@ ([a-zA-Z0-9_].*)/;
	131	}
	132
69b09963	133	# Check if line is a top-level declaration.
69b09963	134	sub is_top_level {
e8b37cb6	135	my ($function, $is_context_diff) = (@_);
a8cfbbdc MZ	136	if (is_unified_hunk_start ($function)
	137	\|\| is_context_hunk_start ($function)) {
	138	return 1;
	139	}
e8b37cb6 TU	140	if ($is_context_diff) {
	141	$function =~ s/^..//;
	142	} else {
	143	$function =~ s/^.//;
	144	}
a92a1c27	145	return $function && $function !~ /^[\s{#]/;
e8b37cb6 TU	146	}
e8b37cb6 TU	147
78d7f09f TV	148	# Read contents of .diff file
	149	open (DFILE, $diff) or die "Could not open file $diff for reading";
	150	chomp (my @diff_lines = <DFILE>);
	151	close (DFILE);
	152
	153	# Array diff_lines is modified by the log generation, so save a copy in
	154	# orig_diff_lines if needed.
	155	if ($inline) {
	156	@orig_diff_lines = @diff_lines;
	157	}
	158
ba0d684e DN	159	# For every file in the .diff print all the function names in ChangeLog
ba0d684e DN	160	# format.
b654717c YG	161	%cl_entries = ();
	162	$change_msg = undef;
	163	$look_for_funs = 0;
26b08681	164	$clname = get_clname('');
e8b37cb6 TU	165	$line_idx = 0;
e8b37cb6 TU	166	foreach (@diff_lines) {
69b09963	167	# Stop processing functions if we found a new file.
b654717c	168	# Remember both left and right names because one may be /dev/null.
69b09963 YG	169	# Don't be fooled by line markers in case of context diff.
69b09963 YG	170	if (!/\\\$/ && /^[+][+][+] +(\S+)/) {
b654717c YG	171	$left = remove_suffixes ($1);
	172	$look_for_funs = 0;
	173	}
69b09963	174	if (!/---$/ && /^--- +(\S+)?/) {
b654717c YG	175	$right = remove_suffixes ($1);
	176	$look_for_funs = 0;
	177	}
	178
	179	# Check if the body of diff started.
	180	# We should now have both left and right name,
	181	# so we can decide filename.
	182
69b09963	183	if ($left && (/^\*{15}/ \|\| /^@@ /)) {
ba0d684e	184	# If we have not seen any function names in the previous file (ie,
b654717c	185	# $change_msg is empty), we just write out a ':' before starting the next
ba0d684e	186	# file.
b654717c YG	187	if ($clname) {
	188	$cl_entries{$clname} .= $change_msg ? "$change_msg" : ":\n";
	189	}
	190
	191	if ($left eq $right) {
	192	$filename = $left;
	193	} elsif($left eq '/dev/null') {
	194	$filename = $right;
	195	} elsif($right eq '/dev/null') {
	196	$filename = $left;
	197	} else {
883b0e46 YG	198	my @ldirs = split /[\/\\]/, $left;
	199	my @rdirs = split /[\/\\]/, $right;
	200
	201	$filename = '';
	202	while ((my $l = pop @ldirs) && (my $r = pop @rdirs)) {
	203	last if ($l ne $r);
	204	$filename = "$l/$filename";
	205	}
	206	$filename =~ s/\/$//;
	207
	208	if (!$filename) {
	209	print STDERR "Error: failed to parse diff for $left and $right\n";
	210	exit 1;
	211	}
ba0d684e	212	}
b654717c YG	213	$left = $right = undef;
	214	($clname, $relname) = get_clname ($filename);
	215	$cl_entries{$clname} .= "\t* $relname";
	216	$change_msg = '';
	217	$look_for_funs = $filename =~ '\.(c\|cpp\|C\|cc\|h\|inc\|def)$';
ba0d684e DN	218	}
ba0d684e DN	219
69b09963 YG	220	# Context diffs have extra whitespace after first char;
	221	# remove it to make matching easier.
	222	if ($is_context_diff) {
	223	s/^([-+! ]) /\1/;
	224	}
	225
	226	# Remember the last line in a diff block that might start
ba0d684e	227	# a new function.
69b09963	228	if (/^[-+! ]([a-zA-Z0-9_].*)/) {
ba0d684e DN	229	$save_fn = $1;
	230	}
	231
b654717c YG	232	# Check if file is newly added.
	233	# Two patterns: for context and unified diff.
	234	if (/^\\\* 0 \\\\/
	235	\|\| /^@@ -0,0 \+1.* @@/) {
	236	$change_msg = $filename =~ /testsuite.*(?<!\.exp)$/ ? ": New test.\n" : ": New file.\n";
	237	$look_for_funs = 0;
	238	}
	239
	240	# Check if file was removed.
	241	# Two patterns: for context and unified diff.
	242	if (/^--- 0 ----/
	243	\|\| /^@@ -1.* \+0,0 @@/) {
	244	$change_msg = ": Remove.\n";
	245	$look_for_funs = 0;
	246	}
	247
a8cfbbdc	248	if (is_unified_hunk_start ($diff_lines[$line_idx])) {
69b09963	249	$is_context_diff = 0;
e8b37cb6	250	}
a8cfbbdc	251	elsif (is_context_hunk_start ($diff_lines[$line_idx])) {
e8b37cb6 TU	252	$is_context_diff = 1;
	253	}
	254
ba0d684e DN	255	# If we find a new function, print it in brackets. Special case if
	256	# this is the first function in a file.
	257	#
	258	# Note that we don't try too hard to find good matches. This should
	259	# return a superset of the actual set of functions in the .diff file.
	260	#
69b09963 YG	261	# The first pattern works with context diff files (diff -c). The
69b09963 YG	262	# second pattern works with unified diff files (diff -u).
ba0d684e	263	#
69b09963 YG	264	# The third pattern looks for the starts of functions or classes
69b09963 YG	265	# within a diff block both for context and unified diff files.
b654717c YG	266	if ($look_for_funs
b654717c YG	267	&& (/^\\\\\\* ([a-zA-Z0-9_].*)/
ba0d684e	268	\|\| /^@@ .* @@ ([a-zA-Z0-9_].*)/
69b09963	269	\|\| /^[-+! ](\{)/))
ba0d684e DN	270	{
	271	$_ = $1;
	272	my $fn;
	273	if (/^\{/) {
	274	# Beginning of a new function.
	275	$_ = $save_fn;
	276	} else {
	277	$save_fn = "";
	278	}
	279	if (/;$/) {
	280	# No usable function name found.
	281	} elsif (/^((class\|struct\|union\|enum) [a-zA-Z0-9_]+)/) {
	282	# Discard stuff after the class/struct/etc. tag.
	283	$fn = $1;
	284	} elsif (/([a-zA-Z0-9_][^(]*)\(/) {
	285	# Discard template and function parameters.
	286	$fn = $1;
	287	1 while ($fn =~ s/<[^<>]*>//);
	288	$fn =~ s/[ \t]*$//;
	289	}
e8b37cb6 TU	290	# Check is function really modified
e8b37cb6 TU	291	$no_real_change = 0;
a8cfbbdc	292	$idx = $line_idx;
69b09963	293	# Skip line info in context diffs.
a8cfbbdc MZ	294	while ($idx <= $#diff_lines && $is_context_diff
	295	&& $diff_lines[$idx + 1] =~ /^[-\*]{3} [0-9]/) {
	296	++$idx;
	297	}
e8b37cb6 TU	298	# Check all lines till the first change
e8b37cb6 TU	299	# for the presence of really changed function
a8cfbbdc MZ	300	do {
	301	++$idx;
	302	$no_real_change = $idx > $#diff_lines
	303	\|\| is_top_level ($diff_lines[$idx], $is_context_diff);
	304	} while (!$no_real_change && ($diff_lines[$idx] !~ /^[-+!]/));
e8b37cb6	305	if ($fn && !$seen_names{$fn} && !$no_real_change) {
ba0d684e DN	306	# If this is the first function in the file, we display it next
	307	# to the filename, so we need an extra space before the opening
	308	# brace.
b654717c YG	309	if (!$change_msg) {
b654717c YG	310	$change_msg .= " ";
ba0d684e	311	} else {
b654717c	312	$change_msg .= "\t";
ba0d684e DN	313	}
ba0d684e DN	314
b654717c	315	$change_msg .= "($fn):\n";
ba0d684e DN	316	$seen_names{$fn} = 1;
	317	}
	318	}
e8b37cb6	319	$line_idx++;
ba0d684e DN	320	}
ba0d684e DN	321
b654717c	322	# If we have not seen any function names (ie, $change_msg is empty), we just
ba0d684e DN	323	# write out a ':'. This happens when there is only one file with no
ba0d684e DN	324	# functions.
69b09963	325	$cl_entries{$clname} .= $change_msg ? "$change_msg\n" : ":\n";
26b08681	326
38278d8a TV	327	if ($inline && $diff ne "-") {
	328	# Get a temp filename, rather than an open filehandle, because we use
	329	# the open to truncate.
	330	$tmp = mktemp("tmp.XXXXXXXX") or die "Could not create temp file: $!";
	331
	332	# Copy the permissions to the temp file (in File::Copy module version
	333	# 2.15 and later).
	334	cp $diff, $tmp or die "Could not copy patch file to temp file: $!";
	335
	336	# Open the temp file, clearing contents.
	337	open (OUTPUTFILE, '>', $tmp) or die "Could not open temp file: $!";
	338	} else {
	339	*OUTPUTFILE = STDOUT;
	340	}
	341
	342	# Print the log
26b08681	343	foreach my $clname (keys %cl_entries) {
38278d8a TV	344	print OUTPUTFILE "$clname:\n\n$hdrline\n\n$cl_entries{$clname}\n";
	345	}
	346
	347	if ($inline) {
	348	# Append the patch to the log
78d7f09f	349	foreach (@orig_diff_lines) {
38278d8a TV	350	print OUTPUTFILE "$_\n";
	351	}
	352	}
	353
	354	if ($inline && $diff ne "-") {
	355	# Close $tmp
	356	close(OUTPUTFILE);
	357
	358	# Write new contents to $diff atomically
	359	mv $tmp, $diff or die "Could not move temp file to patch file: $!";
ba0d684e DN	360	}
ba0d684e DN	361
ba0d684e	362	exit 0;