|
111
|
1 #!/usr/bin/perl
|
|
|
2 # Copyright (C) 2012-2017 Free Software Foundation, Inc.
|
|
|
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'
|
|
|
22 # and adds a skeleton ChangeLog file to the file. It does not try to be
|
|
|
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
|
|
|
29 use File::Temp;
|
|
|
30 use File::Copy qw(cp mv);
|
|
|
31
|
|
|
32 $date = `date +%Y-%m-%d`; chop ($date);
|
|
|
33
|
|
|
34 $dot_mklog_format_msg =
|
|
|
35 "The .mklog format is:\n"
|
|
|
36 . "NAME = ...\n"
|
|
|
37 . "EMAIL = ...\n";
|
|
|
38
|
|
|
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/^\s*NAME\s*=\s*(.*?)\s*$/) {
|
|
|
46 $name = $1;
|
|
|
47 } elsif (m/^\s*EMAIL\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);
|
|
|
60
|
|
|
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 }
|
|
|
67 }
|
|
|
68
|
|
|
69 $gcc_root = $0;
|
|
|
70 $gcc_root =~ s/[^\\\/]+$/../;
|
|
|
71
|
|
|
72 #-----------------------------------------------------------------------------
|
|
|
73 # Program starts here. You should not need to edit anything below this
|
|
|
74 # line.
|
|
|
75 #-----------------------------------------------------------------------------
|
|
|
76 $inline = 0;
|
|
|
77 if ($#ARGV == 1 && ("$ARGV[0]" eq "-i" || "$ARGV[0]" eq "--inline")) {
|
|
|
78 shift;
|
|
|
79 $inline = 1;
|
|
|
80 } elsif ($#ARGV != 0) {
|
|
|
81 $prog = `basename $0`; chop ($prog);
|
|
|
82 print <<EOF;
|
|
|
83 usage: $prog [ -i | --inline ] file.diff
|
|
|
84
|
|
|
85 Generate ChangeLog template for file.diff.
|
|
|
86 It assumes that patch has been created with -up or -cp.
|
|
|
87 When -i is used, the ChangeLog template is followed by the contents of
|
|
|
88 file.diff.
|
|
|
89 When file.diff is -, read standard input.
|
|
|
90 When -i is used and file.diff is not -, it writes to file.diff, otherwise it
|
|
|
91 writes to stdout.
|
|
|
92 EOF
|
|
|
93 exit 1;
|
|
|
94 }
|
|
|
95
|
|
|
96 $diff = $ARGV[0];
|
|
|
97 $dir = `dirname $diff`; chop ($dir);
|
|
|
98 $basename = `basename $diff`; chop ($basename);
|
|
|
99 $hdrline = "$date $name <$addr>";
|
|
|
100
|
|
|
101 sub get_clname ($) {
|
|
|
102 return ('ChangeLog', $_[0]) if ($_[0] !~ /[\/\\]/);
|
|
|
103
|
|
|
104 my $dirname = $_[0];
|
|
|
105 while ($dirname) {
|
|
|
106 my $clname = "$dirname/ChangeLog";
|
|
|
107 if (-f "$gcc_root/$clname" || -f "$clname") {
|
|
|
108 my $relname = substr ($_[0], length ($dirname) + 1);
|
|
|
109 return ($clname, $relname);
|
|
|
110 } else {
|
|
|
111 $dirname =~ s/[\/\\]?[^\/\\]*$//;
|
|
|
112 }
|
|
|
113 }
|
|
|
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;
|
|
|
123 }
|
|
|
124
|
|
|
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
|
|
|
133 # Check if line is a top-level declaration.
|
|
|
134 sub is_top_level {
|
|
|
135 my ($function, $is_context_diff) = (@_);
|
|
|
136 if (is_unified_hunk_start ($function)
|
|
|
137 || is_context_hunk_start ($function)) {
|
|
|
138 return 1;
|
|
|
139 }
|
|
|
140 if ($is_context_diff) {
|
|
|
141 $function =~ s/^..//;
|
|
|
142 } else {
|
|
|
143 $function =~ s/^.//;
|
|
|
144 }
|
|
|
145 return $function && $function !~ /^[\s{#]/;
|
|
|
146 }
|
|
|
147
|
|
|
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
|
|
|
159 # For every file in the .diff print all the function names in ChangeLog
|
|
|
160 # format.
|
|
|
161 %cl_entries = ();
|
|
|
162 $change_msg = undef;
|
|
|
163 $look_for_funs = 0;
|
|
|
164 $clname = get_clname('');
|
|
|
165 $line_idx = 0;
|
|
|
166 foreach (@diff_lines) {
|
|
|
167 # Stop processing functions if we found a new file.
|
|
|
168 # Remember both left and right names because one may be /dev/null.
|
|
|
169 # Don't be fooled by line markers in case of context diff.
|
|
|
170 if (!/\*\*\*$/ && /^[+*][+*][+*] +(\S+)/) {
|
|
|
171 $left = remove_suffixes ($1);
|
|
|
172 $look_for_funs = 0;
|
|
|
173 }
|
|
|
174 if (!/---$/ && /^--- +(\S+)?/) {
|
|
|
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
|
|
|
183 if ($left && (/^\*{15}/ || /^@@ /)) {
|
|
|
184 # If we have not seen any function names in the previous file (ie,
|
|
|
185 # $change_msg is empty), we just write out a ':' before starting the next
|
|
|
186 # file.
|
|
|
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 {
|
|
|
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 }
|
|
|
212 }
|
|
|
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)$';
|
|
|
218 }
|
|
|
219
|
|
|
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
|
|
|
227 # a new function.
|
|
|
228 if (/^[-+! ]([a-zA-Z0-9_].*)/) {
|
|
|
229 $save_fn = $1;
|
|
|
230 }
|
|
|
231
|
|
|
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
|
|
|
248 if (is_unified_hunk_start ($diff_lines[$line_idx])) {
|
|
|
249 $is_context_diff = 0;
|
|
|
250 }
|
|
|
251 elsif (is_context_hunk_start ($diff_lines[$line_idx])) {
|
|
|
252 $is_context_diff = 1;
|
|
|
253 }
|
|
|
254
|
|
|
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 #
|
|
|
261 # The first pattern works with context diff files (diff -c). The
|
|
|
262 # second pattern works with unified diff files (diff -u).
|
|
|
263 #
|
|
|
264 # The third pattern looks for the starts of functions or classes
|
|
|
265 # within a diff block both for context and unified diff files.
|
|
|
266 if ($look_for_funs
|
|
|
267 && (/^\*\*\*\*\*\** ([a-zA-Z0-9_].*)/
|
|
|
268 || /^@@ .* @@ ([a-zA-Z0-9_].*)/
|
|
|
269 || /^[-+! ](\{)/))
|
|
|
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 }
|
|
|
290 # Check is function really modified
|
|
|
291 $no_real_change = 0;
|
|
|
292 $idx = $line_idx;
|
|
|
293 # Skip line info in context diffs.
|
|
|
294 while ($idx <= $#diff_lines && $is_context_diff
|
|
|
295 && $diff_lines[$idx + 1] =~ /^[-\*]{3} [0-9]/) {
|
|
|
296 ++$idx;
|
|
|
297 }
|
|
|
298 # Check all lines till the first change
|
|
|
299 # for the presence of really changed function
|
|
|
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] !~ /^[-+!]/));
|
|
|
305 if ($fn && !$seen_names{$fn} && !$no_real_change) {
|
|
|
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.
|
|
|
309 if (!$change_msg) {
|
|
|
310 $change_msg .= " ";
|
|
|
311 } else {
|
|
|
312 $change_msg .= "\t";
|
|
|
313 }
|
|
|
314
|
|
|
315 $change_msg .= "($fn):\n";
|
|
|
316 $seen_names{$fn} = 1;
|
|
|
317 }
|
|
|
318 }
|
|
|
319 $line_idx++;
|
|
|
320 }
|
|
|
321
|
|
|
322 # If we have not seen any function names (ie, $change_msg is empty), we just
|
|
|
323 # write out a ':'. This happens when there is only one file with no
|
|
|
324 # functions.
|
|
|
325 $cl_entries{$clname} .= $change_msg ? "$change_msg\n" : ":\n";
|
|
|
326
|
|
|
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
|
|
|
343 foreach my $clname (keys %cl_entries) {
|
|
|
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
|
|
|
349 foreach (@orig_diff_lines) {
|
|
|
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: $!";
|
|
|
360 }
|
|
|
361
|
|
|
362 exit 0;
|
