aboutsummaryrefslogtreecommitdiff
path: root/contrib/mklog.pl
diff options
context:
space:
mode:
Diffstat (limited to 'contrib/mklog.pl')
-rwxr-xr-xcontrib/mklog.pl362
1 files changed, 362 insertions, 0 deletions
diff --git a/contrib/mklog.pl b/contrib/mklog.pl
new file mode 100755
index 00000000000..ff20cf1ba0f
--- /dev/null
+++ b/contrib/mklog.pl
@@ -0,0 +1,362 @@
+#!/usr/bin/perl
+# Copyright (C) 2012-2017 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;
generated by cgit v1.2.3 (git 2.25.1) at 2024-06-18 11:01:13 +0000