| blob | d768171dcfaae012bbcdf9f0cd04329c438ed8ae |
1 #!/usr/bin/env perl
2 # (c) 2001, Dave Jones. (the file handling bit)
3 # (c) 2005, Joel Schopp <jschopp@austin.ibm.com> (the ugly bit)
4 # (c) 2007,2008, Andy Whitcroft <apw@uk.ibm.com> (new conditions, test suite)
5 # (c) 2008-2010 Andy Whitcroft <apw@canonical.com>
6 # Licensed under the terms of the GNU GPL License version 2
43 Usage:
50 Options:
54 --patch treat FILE as patchfile
55 --branch treat args as GIT revision list
56 --emacs emacs compile window format
57 --terse one line per report
66 is all off)
68 literally
74 EOM
77 }
79 # Perl's Getopt::Long allows options to take optional arguments after a space.
80 # Prevent --color by itself from consuming other arguments
84 }
85 }
87 GetOptions(
117 }
129 }
136 }
143 }
150 }
156 }
159 }
169 }
179 ## no critic
182 }
189 }
195 }
202 }
203 }
208 }
209 }
219 __force
222 # Notes to $Attribute:
224 const|
225 volatile|
226 G_NORETURN|
227 G_GNUC_WARN_UNUSED_RESULT|
228 G_GNUC_NULL_TERMINATED|
229 QEMU_PACKED|
230 G_GNUC_PRINTF
241 <=|>=|==|!=|
242 =>|->|<<|>>|<|>|!|~|
265 # some readers default to ISO-8859-1 when showing email source. detect
266 # when UTF-8 is incorrectly interpreted as ISO-8859-1 and reencoded back.
267 # False positives are possible but very unlikely.
278 # There are still some false positives, but this catches most
279 # common cases.
286 )};
309 # external libraries
311 # Glib definitions
338 );
340 # This can be modified by sub possible. Since it can be empty, be careful
341 # about regexes that always match, because they can cause infinite loops.
343 );
352 }
359 )
363 $NonptrType
368 }
369 build_types();
390 }
411 }
421 }
425 }
429 }
441 }
446 }
451 }
455 }
458 }
459 }
470 );
475 }
476 }
478 }
491 }
493 }
496 }
499 }
503 }
508 # Drop the diff line leader and expand tabs
512 # Pick the indent from the front of the line.
516 }
527 }
528 }
539 # Always copy over the diff marker.
545 # Comments we are wacking completely including the begin
546 # and end, all to $;.
553 }
559 }
566 }
568 # A \ in a string means ignore the next character.
574 }
575 # Regular quotes.
584 }
585 }
587 #print "c<$c> SQ<$sanitise_quote>\n";
596 }
597 }
601 }
603 # The pathname on a #include may be surrounded by '<' and '>'.
608 # The whole of a #error is a string.
612 }
615 }
638 #warn "CSB: blk<$blk> remain<$remain>\n";
639 # If we are about to drop off the end, pull in more
640 # context.
651 }
652 # Bail if there is no further context.
653 #warn "CSB: blk<$blk> off<$off> len<$len>\n";
656 }
657 }
662 #warn "CSB: c<$c> type<$type> level<$level> remainder<$remainder> coff_set<$coff_set>\n";
664 # Handle nested #if/#else.
671 }
673 # Statement ends at the ';' or a close '}' at the
674 # outermost level.
677 }
679 # An else is really a conditional as long as its not else if
686 #warn "CSB: mark coff<$coff> soff<$soff> 1<$1>\n";
687 #warn "[" . substr($blk, $soff, $coff - $soff + 1) . "]\n";
688 }
693 }
701 #warn "CSB: mark coff<$coff>\n";
702 }
703 }
707 }
715 }
717 }
718 }
720 }
721 # We are truly at the end, so shuffle to the next line.
726 }
731 #warn "STATEMENT<$statement>\n";
732 #warn "CONDITION<$condition>\n";
734 #print "coff<$coff> soff<$off> loff<$loff>\n";
738 }
743 # Strip the diff line prefixes and rip blank lines at start and end.
751 }
759 }
780 }
781 }
789 # Grab the first conditional/block pair.
792 #print "F: c<$condition> s<$statement> remain<$remain>\n";
796 }
798 # Pull in the following conditional/block pairs and see if they
799 # could continue the statement.
803 #print "C: c<$condition> s<$statement> remain<$remain>\n";
805 #print "C: push\n";
807 }
810 }
829 # Handle nested #if/#else.
836 }
839 ##print "C<$c>L<$level><$open$close>O<$off>\n";
843 }
850 }
851 }
855 }
858 }
861 }
867 }
873 }
879 }
884 }
889 }
894 # Catch a comment on the end of the line itself.
898 # Look through the context and try and figure out if there is a
899 # comment.
904 #warn " $line\n";
907 }
910 }
913 }
917 }
918 }
922 }
927 ##print "LINE: $rawlines[$end_line - 1 ]\n";
928 ##print "CMMT: $cmt\n";
931 }
944 }
947 }
959 }
960 }
964 }
976 }
996 }
1017 }
1046 # Assume all arms of the conditional end as this
1047 # one does, and continue as if the #endif was not here.
1064 }
1095 }
1107 }
1140 }
1155 }
1164 }
1168 }
1172 }
1173 }
1176 }
1185 DEFINE_\S+
1186 )$|
1190 case|
1193 do
1196 ^\#
1200 # Check for modifiers.
1211 }
1212 }
1217 }
1218 build_types();
1221 }
1222 }
1230 }
1246 }
1249 }
1254 }
1255 }
1260 }
1261 }
1263 # According to tests/qtest/bios-tables-test.c: do not
1264 # change expected file in the same commit with adding test
1268 # Note: shell script that rebuilds the expected files is in the same
1269 # directory as files themselves.
1270 # Note: allowed diff list can be changed both when changing expected
1271 # files and when changing tests.
1276 }
1283 }
1284 }
1315 # Trace the real file/line as we go.
1327 # suppression flags
1335 # Pre-scan the patch sanitizing the lines.
1337 sanitise_line_reset();
1349 }
1352 # Guestimate if this is a continuing comment. Run
1353 # the context looking for a comment "edge". If this
1354 # edge is a close comment then we must be in a comment
1355 # at context start.
1362 #print "RAW<$rawlines[$ln - 1]>\n";
1368 }
1369 }
1372 }
1374 # Guestimate if this is a continuing comment. If this
1375 # is the start of a diff block and this line starts
1376 # ' *' then it is very likely a comment.
1379 {
1381 }
1383 ##print "COMMENT:$in_comment edge<$edge> $rawline\n";
1387 # Standardise the strings and chars within the input to
1388 # simplify matching -- only bother with positive lines.
1390 }
1397 }
1399 #print "==>$rawline\n";
1400 #print "-->$line\n";
1401 }
1412 #extract the line range in the file after the patch is applied
1421 }
1422 annotate_reset();
1430 # track the line number as we move through the hunk, note that
1431 # new versions of GNU diff omit the leading space on completely
1432 # blank context lines so we need to count that too.
1437 # Measure the line length and indent.
1440 # Track the previous line.
1445 #warn "line<$line>\n";
1449 }
1453 #make up the handle for any error we report on this line
1460 # extract the filename as it passes
1474 }
1477 }
1487 # Check for incorrect file permissions
1492 }
1493 }
1495 # Only allow Python 3 interpreter
1499 }
1501 # Accept git diff extended headers as valid patches
1504 }
1508 }
1510 #check the patch for a signoff:
1512 # This is a signoff, if ugly, so do not double report.
1519 }
1523 }
1524 }
1526 # Check if MAINTAINERS is being updated. If so, there's probably no need to
1527 # emit the "does MAINTAINERS need updating?" message on file add/move/delete
1530 }
1532 # Check for added, moved or deleted files
1543 }
1545 # Check for wrappage within a valid hunk of the file
1549 }
1551 # UTF-8 regex found at http://www.w3.org/International/questions/qa-forms-utf-8.en.php
1561 }
1565 }
1566 # Check if it's the start of a commit log
1567 # (not a header line and we haven't seen the patch filename)
1573 }
1575 # Check if there is UTF-8 in a commit log when a mail header has explicitly
1576 # declined it, i.e defined some charset where it is missing.
1581 }
1586 }
1588 # ignore non-hunk lines and lines being removed
1591 # ignore files that are being periodically imported from Linux
1594 #trailing whitespace
1602 # TODO: properly check we're in a code block
1603 # (surrounding text is 4-column aligned)
1608 }
1613 }
1615 # checks for trace-events files
1624 # don't consider groups splitted by [.:/ ], like 2A.20:12ab
1631 }
1632 }
1633 }
1635 # check we are in a valid source file if not then ignore this hunk
1638 #90 column limit; exempt URLs, if no other words on line
1643 {
1648 }
1649 }
1651 # check for spaces before a quoted newline
1654 }
1656 # check for adding lines without a newline.
1657 if ($line =~ /^\+/ && defined $lines[$linenr] && $lines[$linenr] =~ /^\\ No newline at end of file/) {
1659 }
1661 # check for RCS/CVS revision markers
1664 }
1666 # tabs are only allowed in assembly source code, and in
1667 # some scripts we imported from other projects.
1676 }
1678 # check we are in a valid C source file if not then ignore this hunk
1681 # Block comment styles
1683 # Block comments use /* on a line of its own
1686 }
1689 }
1691 # Block comments use * on subsequent lines
1698 }
1700 # Block comments use */ on trailing lines
1706 }
1708 # Block comment * alignment
1722 }
1728 }
1729 }
1731 # Check for potential 'bare' types
1740 # Find the real next line.
1746 }
1751 # Ignore goto labels.
1754 # Ignore functions being called
1759 # declarations always start with types
1760 } elsif ($prev_values eq 'E' && $s =~ /^.\s*(?:$Storage\s+)?(?:$Inline\s+)?(?:const\s+)?((?:\s*$Ident)+?)\b(?:\s+$Sparse)?\s*\**\s*(?:$Ident|\(\*[^\)]*\))(?:\s*$Modifier)?\s*(?:;|=|,|\()/s) {
1765 # definitions in global scope can only start with types
1768 }
1770 # any (foo ... *) is a pointer cast, and foo is a type
1773 }
1775 # Check for any sort of function declaration.
1776 # int foo(something bar, other baz);
1777 # void (*store_gdt)(x86_descr_ptr *);
1778 if ($prev_values eq 'E' && $s =~ /^(.(?:typedef\s*)?(?:(?:$Storage|$Inline)\s*)*\s*$Type\s*(?:\b$Ident|\(\*\s*$Ident\))\s*)\(/s) {
1786 if ($arg =~ /^(?:const\s+)?($Ident)(?:\s+$Sparse)*\s*\**\s*(:?\b$Ident)?$/s || $arg =~ /^($Ident)$/s) {
1789 }
1790 }
1791 }
1793 }
1795 #
1796 # Checks which may be anchored in the context.
1797 #
1799 # Check for switch () and associated case and default
1800 # statements should be at the same indent.
1814 }
1815 }
1818 }
1819 }
1821 # if/while/etc brace do not go on next line, unless defining a do while loop,
1822 # or if that brace on the next line is for something else
1836 ##print "SKIP<$ctx_skip> CNT<$ctx_cnt>\n";
1839 }
1841 #print "realcnt<$realcnt> ctx_cnt<$ctx_cnt>\n";
1842 #print "pre<$pre_ctx>\nline<$line>\nctx<$ctx>\nnext<$lines[$ctx_ln - 1]>\n";
1844 # The length of the "previous line" is checked against 80 because it
1845 # includes the + at the beginning of the line (if the actual line has
1846 # 79 or 80 characters, it is no longer possible to add a space and an
1847 # opening brace there)
1853 }
1857 {
1862 }
1863 }
1864 }
1866 # 'do ... while (0/false)' only makes sense in macros, without trailing ';'
1869 }
1871 # Check superfluous trailing ';'
1874 }
1876 # Check relative indent for conditionals and blocks.
1877 if ($line =~ /\b(?:(?:if|while|for)\s*\(|do\b)/ && $line !~ /^.\s*#/ && $line !~ /\}\s*while\s*/) {
1882 # Make sure we remove the line prefixes as we have
1883 # none on the first line, and are going to re-add them
1884 # where necessary.
1887 # Find out how long the conditional actually is.
1891 # We want to check the first line inside the block
1892 # starting at the end of the conditional, so remove:
1893 # 1) any blank line termination
1894 # 2) any opening brace { on end of the line
1895 # 3) any do (...) {
1902 }
1906 }
1908 # Also ignore a loop construct at the end of a
1909 # preprocessor statement.
1913 }
1920 # If we see an #else/#elif then the code
1921 # is not linear.
1924 }
1926 # Ignore:
1927 # 1) blank lines, they should be at 0,
1928 # 2) preprocessor lines, and
1929 # 3) labels.
1937 }
1938 }
1939 }
1944 # Check if either of these lines are modified, else
1945 # this is not this patch's fault.
1949 }
1952 }
1954 #print "line<$line> prevline<$prevline> indent<$indent> sindent<$sindent> check<$check> continuation<$continuation> s<$s> cond_lines<$cond_lines> stat_real<$stat_real> stat<$stat>\n";
1958 ERROR("suspect code indent for conditional statements ($indent, $sindent)\n" . $herecurr . "$stat_real\n");
1959 }
1960 }
1962 # Track the 'values' across context and added lines.
1972 }
1975 #ignore lines not being added
1978 # TEST: allow direct testing of the type matcher.
1984 }
1986 }
1987 # TEST: allow direct testing of the attribute matcher.
1993 }
1995 }
1997 # check for initialisation to aggregates open brace on the next line
2001 }
2003 #
2004 # Checks which are anchored on the added line.
2005 #
2007 # check for malformed paths in #include statements (uses RAW line)
2013 }
2014 }
2016 # no C99 // comments
2020 }
2021 # Remove C99 comments.
2025 # check for global initialisers.
2029 }
2030 # check for static initialisers.
2034 }
2036 # * goes on variable not on type
2037 # (char*[ const])
2041 # Should start with a space.
2043 # Should not end with a space.
2045 # '*'s should not have spaces between.
2047 }
2049 #print "from<$from> to<$to>\n";
2052 }
2056 # Should start with a space.
2058 # Should not end with a space.
2060 # '*'s should not have spaces between.
2062 }
2063 # Modifiers should have spaces.
2066 #print "from<$from> to<$to> ident<$ident>\n";
2069 }
2070 }
2072 # function brace can't be on same line, except for #defines of do while,
2073 # or if closed on same line
2077 }
2079 # open braces for enum, union and struct go on the same line.
2083 }
2085 # missing space after union, struct or enum definition
2088 }
2090 # check for spacing round square brackets; allowed:
2091 # 1. with a type on the left -- int [] a;
2092 # 2. at the beginning of a line for slice initialisers -- [0...10] = 5,
2093 # 3. inside a curly brace -- = { [0...10] = 5 }
2094 # 4. after a comma -- [1] = 5, [2] = 6
2095 # 5. in a macro definition -- #define abc(x) [x] = y
2103 }
2104 }
2106 # check for spaces between functions and their parentheses.
2112 # Ignore those directives where spaces _are_ permitted.
2118 {
2120 # Ignore 'catch (...)' in C++
2123 # cpp #define statements have non-optional spaces, ie
2124 # if there is a space between the name and the open
2125 # parenthesis it is simply not a parameter group.
2128 # cpp #elif statement condition may start with a (
2131 # If this whole things ends with a type its most
2132 # likely a typedef for a function.
2137 }
2138 }
2139 # Check operator spacing.
2142 <<=|>>=|<=|>=|==|!=|
2144 =>|->|<<|>>|<|>|=|!|~|
2156 # Pick up the preceding and succeeding characters.
2161 }
2184 }
2193 # Pull out the value of this operator.
2196 # Get the full operator variant.
2199 # Ignore operators passed as parameters.
2203 # # Ignore comments
2204 # } elsif ($op =~ /^$;+$/) {
2206 # ; should have either the end of line or a space or \ after it
2211 }
2213 # // is a comment
2216 # Ignore : used in class declaration in C++
2220 # No spaces for:
2221 # ->
2222 # : when part of a bitfield
2226 }
2228 # , must have a space on the right.
2229 # not required when having a single },{ on one line
2234 }
2236 # '*' as part of a type definition -- reported already.
2238 #warn "'*' is part of type\n";
2240 # unary operators should have a space before and
2241 # none after. May be left adjacent to another
2242 # unary operator, or a cast
2247 # '~' used as a name of Destructor
2251 }
2253 # A unary '*' may be const
2257 }
2259 # unary ++ and unary -- are allowed no space on one side.
2263 }
2267 }
2270 }
2272 # A colon needs no spaces before when it is
2273 # terminating a case value or a label.
2277 }
2279 # All the others need spaces both sides.
2284 # Ignore template arguments <...> in C++
2287 }
2289 # Ignore :: in C++
2292 }
2293 }
2295 # Ignore email addresses <foo@bar>
2300 {
2302 }
2304 # Ignore ?:
2308 }
2312 }
2313 }
2315 }
2316 }
2318 #need space before brace following if, while, etc
2322 }
2324 # closing brace should have a space following it when it has anything
2325 # on the line
2328 }
2330 # check spacing on square brackets
2333 }
2336 }
2338 # check spacing on parentheses
2342 }
2347 }
2349 # Return is not a function.
2354 # Flatten any parentheses
2362 }
2363 #print "value<$value>\n";
2370 }
2371 }
2372 # Return of what appears to be an errno should normally be -'ve
2377 }
2378 }
2383 }
2385 # Need a space before open parenthesis after if, while etc
2388 }
2390 # Check for illegal assignment in if conditional -- and check for trailing
2391 # statements after the conditional.
2396 ##print "stat<$stat> stat_next<$stat_next>\n";
2399 # If the statement carries leading newlines,
2400 # then count those as offsets.
2408 }
2409 }
2416 }
2418 # Find out what is on the end of the line after the
2419 # conditional.
2425 {
2426 # Find out how long the conditional actually is.
2435 }
2438 }
2439 }
2441 # Check for bitwise tests written as boolean
2447 |
2452 {
2454 }
2456 # if and else should not have general statements after it
2462 }
2463 }
2464 # if should not continue a brace
2468 }
2469 # case and default should not have general statements after them
2475 {
2477 }
2479 # Check for }<nl>else {, these must be at the same
2480 # indent level to be relevant to each other.
2484 }
2490 # Find out what is on the end of the line after the
2491 # conditional.
2497 }
2498 }
2500 #studly caps, commented out until figure out how to distinguish between use of existing and adding new
2501 # if (($line=~/[\w_][a-z\d]+[A-Z]/) and !($line=~/print/)) {
2502 # print "No studly caps, use _\n";
2503 # print "$herecurr";
2504 # $clean = 0;
2505 # }
2507 #no spaces allowed after \ in define
2510 }
2512 # multi-statement macros should be enclosed in a do while loop, grab the
2513 # first statement and ensure its the whole macro if its not enclosed
2514 # in a known good container
2524 # Find the end of the macro and limit our statement
2525 # search to that.
2528 {
2532 }
2537 #print "dstat<$dstat> dcond<$dcond> cnt<$cnt> off<$off>\n";
2538 #print "LINE<$lines[$ln-1]> len<" . length($lines[$ln-1]) . "\n";
2540 # Extract the remainder of the define (if any) and
2541 # rip off surrounding spaces, and trailing \'s.
2544 #print "ADDING cnt<$cnt> $off <" . substr($lines[$ln - 1], $off) . "> rest<$rest>\n";
2548 }
2551 }
2556 # Clean up the original statement.
2561 }
2567 # Flatten any parentheses and braces
2571 {
2572 }
2576 module_param_named|
2577 MODULE_PARAM_DESC|
2578 DECLARE_PER_CPU|
2579 DEFINE_PER_CPU|
2580 __typeof__\(|
2581 union|
2582 struct|
2586 #print "REST<$rest> dstat<$dstat> ctx<$ctx>\n";
2590 {
2591 ERROR("Macros with multiple statements should be enclosed in a do - while loop\n" . "$here\n$ctx\n");
2592 }
2600 {
2602 }
2603 }
2604 }
2606 # check for missing bracing around if etc
2611 # Check the pre-context.
2619 }
2620 }
2627 }
2635 # If the condition carries leading newlines, then count those as offsets.
2639 #print "COND<$cond> whitespace<$whitespace> offset<$offset>\n";
2641 # We have looked at and allowed this specific line.
2660 }
2665 }
2670 }
2671 }
2674 }
2675 }
2676 }
2683 # Check the pre-context.
2691 }
2692 }
2697 # Check the condition.
2703 }
2708 }
2713 }
2718 }
2719 # Check the post-context.
2724 }
2729 }
2730 }
2739 }
2742 }
2743 }
2745 # no volatiles please
2752 }
2754 # warn about #if 0
2758 }
2760 # check for needless g_free() checks
2765 }
2766 }
2768 # warn about #ifdefs in C files
2769 # if ($line =~ /^.\s*\#\s*if(|n)def/ && ($realfile =~ /\.c$/)) {
2770 # print "#ifdef in C files should be avoided\n";
2771 # print "$herecurr";
2772 # $clean = 0;
2773 # }
2775 # warn about spacing in #ifdefs
2778 }
2779 # check for memory barriers without a comment.
2783 }
2784 }
2785 # check of hardware specific defines
2786 # we have e.g. CONFIG_LINUX and CONFIG_WIN32 for common cases
2787 # where they might be necessary.
2790 }
2792 # Check that the storage class is at the beginning of a declaration
2795 }
2797 # check the location of the inline attribute, that it is between
2798 # storage class and type.
2802 }
2804 # check for sizeof(&)
2807 }
2809 # check for new externs in .c files.
2812 {
2819 }
2822 {
2824 }
2828 }
2832 {
2834 }
2836 # check for pointless casting of g_malloc return
2842 }
2843 }
2845 # check for gcc specific __FUNCTION__
2848 }
2850 # recommend g_path_get_* over g_strdup(basename/dirname(...))
2853 }
2855 # enforce g_memdup2() over g_memdup()
2858 }
2860 # recommend qemu_strto* over strto* for numeric conversions
2863 }
2864 # recommend sigaction over signal for portability, when establishing a handler
2867 }
2868 # check for module_init(), use category-specific init macros explicitly please
2871 }
2872 # check for various ops structs, ensure they are const.
2874 BdrvActionOps|
2875 BlockDevOps|
2876 BlockJobDriver|
2877 DisplayChangeListenerOps|
2878 GraphicHwOps|
2879 IDEDMAOps|
2880 KVMCapabilityInfo|
2881 MemoryRegionIOMMUOps|
2882 MemoryRegionOps|
2883 MemoryRegionPortio|
2884 QEMUFileOps|
2885 SCSIBusInfo|
2886 SCSIReqOps|
2888 TypeInfo|
2890 VhostOps|
2891 VMStateDescription|
2897 }
2899 # format strings checks
2904 # check for %L{u,d,i} in strings
2907 }
2908 # check for %# or %0# in printf-style format strings
2913 }
2914 }
2916 # QEMU specific tests
2919 }
2921 # Qemu error function tests
2923 # Find newlines in error messages
2925 error_setg_errno|
2926 error_setg_win32|
2927 error_setg_file_open|
2928 error_set|
2929 error_prepend|
2930 warn_reportf_err|
2931 error_reportf_err|
2932 error_vreport|
2933 warn_vreport|
2934 info_vreport|
2935 error_report|
2936 warn_report|
2937 info_report|
2942 }
2944 # Continue checking for error messages that contains newlines. This
2945 # check handles cases where string literals are spread over multiple lines.
2946 # Example:
2947 # error_report("Error msg line #1"
2948 # "Error msg line #2\n");
2953 # Backtrack to first line that does not contain only a quoted literal
2954 # and assume that it is the start of the statement.
2959 }
2963 }
2964 }
2966 # check for non-portable libc calls that have portable alternatives in QEMU
2969 }
2972 }
2975 }
2978 }
2981 }
2984 }
2987 }
2989 g_assert_cmpint|
2990 g_assert_cmpuint|
2991 g_assert_cmphex|
2992 g_assert_cmpfloat|
2993 g_assert_true|
2994 g_assert_false|
2995 g_assert_nonnull|
2996 g_assert_null|
2997 g_assert_no_error|
2998 g_assert_error|
2999 g_test_assert_expected_messages|
3000 g_test_trap_assert_passed|
3001 g_test_trap_assert_stdout|
3002 g_test_trap_assert_stdout_unmatched|
3003 g_test_trap_assert_stderr|
3008 }
3009 }
3013 }
3015 # If we have no input at all, then there is nothing to report on
3016 # so just keep quiet.
3019 }
3021 # In mailback mode only produce a report in the negative, for
3022 # things that appear to be patches.
3025 }
3027 # This is not a patch, and we are are in 'no-patch' mode so
3028 # just keep quiet.
3031 }
3035 }
3043 }
3046 # If there were whitespace errors which cleanpatch can fix
3047 # then suggest that.
3048 # if ($rpt_cleaners) {
3049 # print "NOTE: whitespace errors detected, you may wish to use scripts/cleanpatch or\n";
3050 # print " scripts/cleanfile\n\n";
3051 # }
3052 }
3056 }
3061 }
3064 }