| blob | eee8d6ee38e3a0114df72bdc54e5df6980d70cd2 |
1 #!/usr/bin/perl -w
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
51 Options:
54 --emacs emacs compile window format
55 --terse one line per report
68 is all off)
70 literally
73 "<inputfile>.EXPERIMENTAL-checkpatch-fixes"
74 with potential errors corrected to the preferred
75 checkpatch style
80 runtime errors.
84 EOM
87 }
109 }
110 }
113 }
115 GetOptions(
150 }
151 }
156 }
172 }
173 }
182 }
184 }
185 }
195 ## no critic
198 }
205 }
215 __user|
216 __kernel|
217 __force|
218 __iomem|
219 __must_check|
220 __init_refok|
221 __kprobes|
222 __ref|
223 __rcu
231 # Notes to $Attribute:
232 # We need \b after 'init' otherwise 'initconst' will cause a false positive in a check
234 const|
235 __percpu|
236 __nocast|
237 __safe|
238 __bitwise__|
239 __packed__|
240 __packed2__|
241 __naked|
242 __maybe_unused|
243 __always_unused|
244 __noreturn|
245 __used|
246 __cold|
247 __noclone|
248 __deprecated|
249 __read_mostly|
250 __kprobes|
252 ____cacheline_aligned|
253 ____cacheline_aligned_in_smp|
254 ____cacheline_internodealigned_in_smp|
255 __weak
276 <=|>=|==|!=|
277 =>|->|<<|>>|<|>|!|~|
305 atomic_t
306 )};
310 (?:[a-z0-9]+_){1,2}(?:printk|emerg|alert|crit|err|warning|warn|notice|info|debug|dbg|vdbg|devel|cont|WARN)(?:_ratelimited|_once|)|
312 panic|
315 )};
324 To:|
325 Cc:
326 )};
347 );
352 );
356 );
362 ["debugfs_create_(?:file|u8|u16|u32|u64|x8|x16|x32|x64|size_t|atomic_t|bool|blob|regset32|u32_array)", 2],
365 );
367 #Create a search pattern for all these functions to speed up a loop below
372 }
375 irq|
376 memory
377 )};
378 # memory.h: ARM has a custom one
391 )
400 )
404 $NonptrType
409 }
410 build_types();
414 # Using $balanced_parens, $LvalOrFunc, or $FuncArg
415 # requires at least perl version v5.10.0
416 # Any use must be runtime checked with $^V
429 }
434 }
458 }
459 }
460 }
484 }
486 }
494 }
498 }
503 }
507 }
515 }
517 }
518 }
534 }
539 }
543 }
547 }
551 }
576 # If there's a name left after stripping spaces and
577 # leading quotes, and the address doesn't have both
578 # leading and trailing angle brackets, the address
579 # is invalid. ie:
580 # "joe smith joe@smith.com" bad
581 # "joe smith <joe@smith.com" bad
586 }
587 }
597 }
600 }
614 }
620 }
623 }
631 }
632 }
635 }
648 }
650 }
653 }
656 }
660 }
665 # Drop the diff line leader and expand tabs
669 # Pick the indent from the front of the line.
673 }
684 }
685 }
696 # Always copy over the diff marker.
702 # Comments we are wacking completly including the begin
703 # and end, all to $;.
710 }
716 }
723 }
725 # A \ in a string means ignore the next character.
731 }
732 # Regular quotes.
741 }
742 }
744 #print "c<$c> SQ<$sanitise_quote>\n";
753 }
754 }
758 }
760 # The pathname on a #include may be surrounded by '<' and '>'.
765 # The whole of a #error is a string.
769 }
772 }
779 }
802 #warn "CSB: blk<$blk> remain<$remain>\n";
803 # If we are about to drop off the end, pull in more
804 # context.
815 }
816 # Bail if there is no further context.
817 #warn "CSB: blk<$blk> off<$off> len<$len>\n";
820 }
824 }
825 }
830 #warn "CSB: c<$c> type<$type> level<$level> remainder<$remainder> coff_set<$coff_set>\n";
832 # Handle nested #if/#else.
839 }
841 # Statement ends at the ';' or a close '}' at the
842 # outermost level.
845 }
847 # An else is really a conditional as long as its not else if
854 #warn "CSB: mark coff<$coff> soff<$soff> 1<$1>\n";
855 #warn "[" . substr($blk, $soff, $coff - $soff + 1) . "]\n";
856 }
861 }
869 #warn "CSB: mark coff<$coff>\n";
870 }
871 }
875 }
883 }
885 }
886 }
887 # Preprocessor commands end at the newline unless escaped.
893 }
895 }
896 # We are truly at the end, so shuffle to the next line.
901 }
906 #warn "STATEMENT<$statement>\n";
907 #warn "CONDITION<$condition>\n";
909 #print "coff<$coff> soff<$off> loff<$loff>\n";
913 }
918 # Strip the diff line prefixes and rip blank lines at start and end.
926 }
934 }
955 }
956 }
964 # Grab the first conditional/block pair.
967 #print "F: c<$condition> s<$statement> remain<$remain>\n";
971 }
973 # Pull in the following conditional/block pairs and see if they
974 # could continue the statement.
978 #print "C: c<$condition> s<$statement> remain<$remain>\n";
980 #print "C: push\n";
982 }
985 }
1004 # Handle nested #if/#else.
1011 }
1014 ##print "C<$c>L<$level><$open$close>O<$off>\n";
1018 }
1025 }
1026 }
1030 }
1033 }
1036 }
1042 }
1048 }
1054 }
1059 }
1064 }
1069 # Catch a comment on the end of the line itself.
1073 # Look through the context and try and figure out if there is a
1074 # comment.
1079 #warn " $line\n";
1082 }
1085 }
1088 }
1092 }
1093 }
1097 }
1102 ##print "LINE: $rawlines[$end_line - 1 ]\n";
1103 ##print "CMMT: $cmt\n";
1106 }
1119 }
1122 }
1134 }
1135 }
1139 }
1151 }
1171 }
1192 }
1221 # Assume all arms of the conditional end as this
1222 # one does, and continue as if the #endif was not here.
1239 }
1270 }
1282 }
1315 }
1330 }
1339 }
1343 }
1347 }
1348 }
1351 }
1360 DEFINE_\S+
1361 )$|
1365 case|
1369 \#|
1370 \#\#|
1376 # Check for modifiers.
1387 }
1388 }
1393 }
1394 build_types();
1397 }
1398 }
1408 }
1416 }
1422 }
1428 }
1432 }
1441 }
1443 }
1451 }
1453 }
1461 }
1463 }
1471 }
1479 }
1487 }
1495 }
1504 #convert leading spaces to tabs
1506 #Remove spaces before a tab
1510 }
1524 }
1536 }
1537 }
1540 }
1571 # Trace the real file/line as we go.
1583 # suppression flags
1591 # Pre-scan the patch sanitizing the lines.
1592 # Pre-scan the patch looking for any __setup documentation.
1593 #
1599 sanitise_line_reset();
1611 }
1612 #next;
1613 }
1620 }
1623 # Guestimate if this is a continuing comment. Run
1624 # the context looking for a comment "edge". If this
1625 # edge is a close comment then we must be in a comment
1626 # at context start.
1633 #print "RAW<$rawlines[$ln - 1]>\n";
1639 }
1640 }
1643 }
1645 # Guestimate if this is a continuing comment. If this
1646 # is the start of a diff block and this line starts
1647 # ' *' then it is very likely a comment.
1650 {
1652 }
1654 ##print "COMMENT:$in_comment edge<$edge> $rawline\n";
1658 # Standardise the strings and chars within the input to
1659 # simplify matching -- only bother with positive lines.
1661 }
1668 }
1670 #print "==>$rawline\n";
1671 #print "-->$line\n";
1675 }
1676 }
1689 #extract the line range in the file after the patch is applied
1698 }
1699 annotate_reset();
1708 # track the line number as we move through the hunk, note that
1709 # new versions of GNU diff omit the leading space on completely
1710 # blank context lines so we need to count that too.
1715 # Measure the line length and indent.
1718 # Track the previous line.
1723 #warn "line<$line>\n";
1727 }
1731 #make up the handle for any error we report on this line
1738 # extract the filename as it passes
1749 }
1759 # Check for incorrect file permissions
1766 }
1767 }
1769 # Check the patch for a signoff:
1773 }
1775 # Check for wrappage within a valid hunk of the file
1780 }
1782 # UTF-8 regex found at http://www.w3.org/International/questions/qa-forms-utf-8.en.php
1793 }
1795 # Check if it's the start of a commit log
1796 # (not a header line and we haven't seen the patch filename)
1801 }
1803 # Check if there is UTF-8 in a commit log when a mail header has explicitly
1804 # declined it, i.e defined some charset where it is missing.
1809 }
1815 }
1817 # ignore non-hunk lines and lines being removed
1820 #trailing whitespace
1827 }
1834 }
1837 }
1839 # Check for FSF mailing addresses.
1847 "Do not include the paragraph about writing to the Free Software Foundation's mailing address from the sample GPL notice. The FSF has changed addresses in the past, and may do so again. Linux already includes a copy of the GPL.\n" . $herevet)
1848 }
1850 # check we are in a valid source file if not then ignore this hunk
1853 #line length limit
1856 !($line =~ /^\+\s*$logFunctions\s*\(\s*(?:(KERN_\S+\s*|[^"]*))?"[X\t]*"\s*(?:|,|\)\s*;)\s*$/ ||
1859 {
1862 }
1864 # Check for user-visible strings broken across lines, which breaks the ability
1865 # to grep for the string. Make exceptions when the previous string ends in a
1866 # newline (multiple lines in one string constant) or '\t', '\r', ';', or '{'
1867 # (common in inline assembly) or is a octal \123 or hexadecimal \xaf value
1873 }
1875 # check for spaces before a quoted newline
1881 }
1883 }
1885 # check for adding lines without a newline.
1886 if ($line =~ /^\+/ && defined $lines[$linenr] && $lines[$linenr] =~ /^\\ No newline at end of file/) {
1889 }
1891 # check we are in a valid source file C or perl if not then ignore this hunk
1894 # at the beginning of a line any tabs must come first and anything
1895 # more than 8 must use tabs.
1904 }
1905 }
1907 # check for space before tabs.
1917 }
1918 }
1920 # check for && or || at the start of a line
1924 }
1926 # check multi-line statement indentation matches previous line
1928 $prevline =~ /^\+([ \t]*)((?:$c90_Keywords(?:\s+if)\s*)|(?:$Declare\s*)?(?:$Ident|\(\s*\*\s*$Ident\s*\))\s*|$Ident\s*=\s*$Ident\s*)\(.*(\&\&|\|\||,)\s*$/) {
1951 }
1952 }
1953 }
1954 }
1962 }
1963 }
1965 # check for spaces at the beginning of a line.
1966 # Exceptions:
1967 # 1) within comments
1968 # 2) indented preprocessor commands
1969 # 3) hanging labels
1976 }
1977 }
1979 # check we are in a valid C source file if not then ignore this hunk
1982 # check for RCS/CVS revision markers
1986 }
1988 # Check for potential 'bare' types
1991 #print "LINE<$line>\n";
1999 #print "linenr<$linenr> <$stat>\n";
2000 # If this statement has no statement boundaries within
2001 # it there is no point in retrying a statement scan
2002 # until we hit end of it.
2005 #print "skip<$line_nr_next>\n";
2007 }
2009 # Find the real next line.
2015 }
2020 # Ignore goto labels.
2023 # Ignore functions being called
2028 # declarations always start with types
2029 } 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) {
2034 # definitions in global scope can only start with types
2037 }
2039 # any (foo ... *) is a pointer cast, and foo is a type
2042 }
2044 # Check for any sort of function declaration.
2045 # int foo(something bar, other baz);
2046 # void (*store_gdt)(x86_descr_ptr *);
2047 if ($prev_values eq 'E' && $s =~ /^(.(?:typedef\s*)?(?:(?:$Storage|$Inline)\s*)*\s*$Type\s*(?:\b$Ident|\(\*\s*$Ident\))\s*)\(/s) {
2055 if ($arg =~ /^(?:const\s+)?($Ident)(?:\s+$Sparse)*\s*\**\s*(:?\b$Ident)?$/s || $arg =~ /^($Ident)$/s) {
2058 }
2059 }
2060 }
2062 }
2064 #
2065 # Checks which may be anchored in the context.
2066 #
2068 # Check for switch () and associated case and default
2069 # statements should be at the same indent.
2083 }
2084 }
2088 }
2089 }
2091 # if/while/etc brace do not go on next line, unless defining a do while loop,
2092 # or if that brace on the next line is for something else
2101 }
2112 ##print "SKIP<$ctx_skip> CNT<$ctx_cnt>\n";
2115 }
2117 #print "realcnt<$realcnt> ctx_cnt<$ctx_cnt>\n";
2118 #print "pre<$pre_ctx>\nline<$line>\nctx<$ctx>\nnext<$lines[$ctx_ln - 1]>\n";
2124 }
2128 {
2134 }
2135 }
2136 }
2138 # Check relative indent for conditionals and blocks.
2139 if ($line =~ /\b(?:(?:if|while|for)\s*\(|do\b)/ && $line !~ /^.\s*#/ && $line !~ /\}\s*while\s*/) {
2147 # Make sure we remove the line prefixes as we have
2148 # none on the first line, and are going to readd them
2149 # where necessary.
2152 # Find out how long the conditional actually is.
2156 # We want to check the first line inside the block
2157 # starting at the end of the conditional, so remove:
2158 # 1) any blank line termination
2159 # 2) any opening brace { on end of the line
2160 # 3) any do (...) {
2167 }
2171 }
2173 # Also ignore a loop construct at the end of a
2174 # preprocessor statement.
2178 }
2185 # If we see an #else/#elif then the code
2186 # is not linear.
2189 }
2191 # Ignore:
2192 # 1) blank lines, they should be at 0,
2193 # 2) preprocessor lines, and
2194 # 3) labels.
2202 }
2203 }
2204 }
2209 # Check if either of these lines are modified, else
2210 # this is not this patch's fault.
2214 }
2217 }
2219 #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";
2224 "suspect code indent for conditional statements ($indent, $sindent)\n" . $herecurr . "$stat_real\n");
2225 }
2226 }
2228 # Track the 'values' across context and added lines.
2238 }
2241 #ignore lines not being added
2244 # TEST: allow direct testing of the type matcher.
2252 }
2254 }
2255 # TEST: allow direct testing of the attribute matcher.
2263 }
2265 }
2267 # check for initialisation to aggregates open brace on the next line
2272 }
2274 #
2275 # Checks which are anchored on the added line.
2276 #
2278 # check for malformed paths in #include statements (uses RAW line)
2284 }
2285 }
2287 # no C99 // comments
2296 }
2297 }
2298 }
2299 # Remove C99 comments.
2303 # check for global initialisers.
2310 }
2311 }
2312 # check for static initialisers.
2319 }
2320 }
2322 # check for static const char * arrays.
2327 }
2329 # check for static char foo[] = "bar" declarations.
2334 }
2336 # check for non-global char *foo[] = {"bar", ...} declarations.
2341 }
2343 # check for function declarations without arguments like "int foo()"
2349 }
2350 }
2352 # check for new typedefs, only function parameters and sparse annotations
2353 # make sense.
2361 }
2363 # * goes on variable not on type
2364 # (char*[ const])
2366 #print "AA<$1>\n";
2369 # Should start with a space.
2371 # Should not end with a space.
2373 # '*'s should not have spaces between.
2375 }
2377 ## print "1: from<$from> to<$to> ident<$ident>\n";
2387 }
2388 }
2389 }
2391 #print "BB<$1>\n";
2394 # Should start with a space.
2396 # Should not end with a space.
2398 # '*'s should not have spaces between.
2400 }
2401 # Modifiers should have spaces.
2404 ## print "2: from<$from> to<$to> ident<$ident>\n";
2415 }
2416 }
2417 }
2420 # function brace can't be on same line, except for #defines of do while,
2421 # or if closed on same line
2428 }
2430 # open braces for enum, union and struct go on the same line.
2435 }
2437 # missing space after union, struct or enum definition
2444 }
2445 }
2447 # Function pointer declarations
2448 # check spacing between type, funcptr, and args
2449 # canonical declaration is "type (*funcptr)(args...)"
2458 # the $Declare variable will capture all spaces after the type
2459 # so check it for a missing trailing missing space but pointer return types
2460 # don't need a space so don't warn for those.
2465 }
2470 }
2472 # unnecessary space "type (*funcptr)(args...)"
2473 # This test is not currently implemented because these declarations are
2474 # equivalent to
2475 # int foo(int bar, ...)
2476 # and this is form shouldn't/doesn't generate a checkpatch warning.
2477 #
2478 # elsif ($declare =~ /\s{2,}$/) {
2479 # WARN("SPACING",
2480 # "Multiple spaces after return type\n" . $herecurr);
2481 # }
2483 # unnecessary space "type ( *funcptr)(args...)"
2488 }
2490 # unnecessary space "type (* funcptr)(args...)"
2495 }
2497 # unnecessary space "type (*funcptr )(args...)"
2502 }
2504 # unnecessary space "type (*funcptr) (args...)"
2509 }
2513 s/^(.\s*)$Declare\s*\(\s*\*\s*$Ident\s*\)\s*\(/$1 . $declare . $post_declare_space . '(*' . $funcname . ')('/ex;
2514 }
2515 }
2517 # check for spacing round square brackets; allowed:
2518 # 1. with a type on the left -- int [] a;
2519 # 2. at the beginning of a line for slice initialisers -- [0...10] = 5,
2520 # 3. inside a curly brace -- = { [0...10] = 5 }
2531 }
2532 }
2533 }
2535 # check for spaces between functions and their parentheses.
2541 # Ignore those directives where spaces _are_ permitted.
2547 {
2548 # cpp #define statements have non-optional spaces, ie
2549 # if there is a space between the name and the open
2550 # parenthesis it is simply not a parameter group.
2553 # cpp #elif statement condition may start with a (
2556 # If this whole things ends with a type its most
2557 # likely a typedef for a function.
2566 }
2567 }
2568 }
2570 # Check operator spacing.
2576 <<=|>>=|<=|>=|==|!=|
2578 =>|->|<<|>>|<|>|=|!|~|
2590 }
2601 ## print("n: <$n> good: <$good>\n");
2605 # Pick up the preceding and succeeding characters.
2610 }
2633 }
2642 # Pull out the value of this operator.
2645 # Get the full operator variant.
2648 # Ignore operators passed as parameters.
2652 # # Ignore comments
2653 # } elsif ($op =~ /^$;+$/) {
2655 # ; should have either the end of line or a space or \ after it
2663 }
2664 }
2666 # // is a comment
2669 # : when part of a bitfield
2671 # skip the bitfield test for now
2673 # No spaces for:
2674 # ->
2682 }
2684 }
2685 }
2687 # , must have a space on the right.
2695 }
2696 }
2698 # '*' as part of a type definition -- reported already.
2700 #warn "'*' is part of type\n";
2702 # unary operators should have a space before and
2703 # none after. May be left adjacent to another
2704 # unary operator, or a cast
2714 }
2715 }
2716 }
2718 # A unary '*' may be const
2726 }
2728 }
2729 }
2731 # unary ++ and unary -- are allowed no space on one side.
2738 }
2739 }
2746 }
2747 }
2754 }
2756 }
2757 }
2759 # << and >> may either have or not have spaces both sides
2765 {
2772 }
2774 }
2775 }
2777 # A colon needs no spaces before when it is
2778 # terminating a case value or a label.
2785 }
2786 }
2788 # All the others need spaces both sides.
2792 # Ignore email addresses <foo@bar>
2797 {
2799 }
2801 # messages are ERROR, but ?: are CHK
2811 }
2813 }
2814 }
2815 }
2818 ## print("n: <$n> GOOD: <$good>\n");
2821 }
2825 }
2829 }
2832 }
2834 # check for whitespace before a non-naked semicolon
2841 }
2842 }
2844 # check for multiple assignments
2848 }
2851 #need space before brace following if, while, etc
2858 }
2859 }
2861 # closing brace should have a space following it when it has anything
2862 # on the line
2869 }
2870 }
2872 # check spacing on square brackets
2879 }
2880 }
2887 }
2888 }
2890 # check spacing on parentheses
2898 }
2899 }
2908 }
2909 }
2911 #goto labels aren't indented, allow a single space however
2919 }
2920 }
2922 # return is not a function
2932 }
2936 }
2937 }
2939 # if statements using unnecessary parentheses - ie: if ((foo == bar))
2945 if ($line =~ /\bif\s*(?:\(\s*){$count,$count}$LvalOrFunc\s*($Compare)\s*$LvalOrFunc(?:\s*\)){$count,$count}/) {
2950 }
2951 }
2953 # Return of what appears to be an errno should normally be -'ve
2959 }
2960 }
2962 # Need a space before open parenthesis after if, while etc
2969 }
2970 }
2972 # Check for illegal assignment in if conditional -- and check for trailing
2973 # statements after the conditional.
2981 ##print "stat<$stat> stat_next<$stat_next>\n";
2984 # If the statement carries leading newlines,
2985 # then count those as offsets.
2993 }
2994 }
3003 }
3005 # Find out what is on the end of the line after the
3006 # conditional.
3012 {
3013 # Find out how long the conditional actually is.
3022 }
3026 }
3027 }
3029 # Check for bitwise tests written as boolean
3035 |
3040 {
3043 }
3045 # if and else should not have general statements after it
3052 }
3053 }
3054 # if should not continue a brace
3059 }
3060 # case and default should not have general statements after them
3066 {
3069 }
3071 # Check for }<nl>else {, these must be at the same
3072 # indent level to be relevant to each other.
3077 }
3083 # Find out what is on the end of the line after the
3084 # conditional.
3091 }
3092 }
3094 #Specific variable tests
3098 #gcc binary extension
3106 }
3107 }
3109 #CamelCase
3112 #Ignore Page<foo> variants
3114 #Ignore SI style variants like nS, mV and dB (ie: max_uV, regulator_min_uA_show)
3120 seed_camelcase_includes();
3124 }
3125 }
3130 }
3131 }
3132 }
3133 }
3135 #no spaces allowed after \ in define
3141 }
3142 }
3144 # multi-statement macros should be enclosed in a do while loop, grab the
3145 # first statement and ensure its the whole macro if its not enclosed
3146 # in a known good container
3156 #print "dstat<$dstat> dcond<$dcond> cnt<$cnt> off<$off>\n";
3157 #print "LINE<$lines[$ln-1]> len<" . length($lines[$ln-1]) . "\n";
3165 # Flatten any parentheses and braces
3169 {
3170 }
3172 # Flatten any obvious string concatentation.
3175 {
3176 }
3180 module_param_named|
3181 MODULE_PARM_DESC|
3182 DECLARE_PER_CPU|
3183 DEFINE_PER_CPU|
3184 __typeof__\(|
3185 union|
3186 struct|
3190 #print "REST<$rest> dstat<$dstat> ctx<$ctx>\n";
3194 $dstat !~ /^[!~-]?(?:$Lval|$Constant)$/ && # 10 // foo() // !foo // ~foo // -foo // foo->bar // foo.bar->baz
3199 $dstat !~ /^do\s*$Constant\s*while\s*$Constant;?$/ && # do {...} while (...); // do {...} while (...)
3205 {
3212 }
3220 }
3221 }
3223 # check for line continuations outside of #defines, preprocessor #, and asm
3232 }
3233 }
3235 # do {} while (0) macro tests:
3236 # single-statement macros do not need to be enclosed in do while (0) loop,
3237 # macro should not end with a semicolon
3251 if ($dstat =~ /^\+\s*#\s*define\s+$Ident\s*${balanced_parens}\s*do\s*{(.*)\s*}\s*while\s*\(\s*0\s*\)\s*([;\s]*)\s*$/) {
3261 }
3267 }
3271 }
3272 }
3273 }
3275 # check for redundant bracing round if etc
3279 #print "chunks<$#chunks> linenr<$linenr> endln<$endln> level<$level>\n";
3280 #print "APW: <<$chunks[1][0]>><<$chunks[1][1]>>\n";
3290 # If the condition carries leading newlines, then count those as offsets.
3295 #print "COND<$cond> whitespace<$whitespace> offset<$offset>\n";
3297 # We have looked at and allowed this specific line.
3307 #print "cond<$cond> block<$block> allowed<$allowed[$allow]>\n";
3309 #print "APW: ALLOWED: cond<$cond>\n";
3311 }
3313 #print "APW: ALLOWED: block<$block>\n";
3315 }
3317 #print "APW: ALLOWED: lines block<$block>\n";
3319 }
3321 }
3326 }
3334 }
3335 }
3336 }
3337 }
3342 # Check the pre-context.
3344 #print "APW: ALLOWED: pre<$1>\n";
3346 }
3351 # Check the condition.
3353 #print "CHECKING<$linenr> cond<$cond> block<$block>\n";
3356 }
3358 #print "APW: ALLOWED: cond<$cond>\n";
3360 }
3362 #print "APW: ALLOWED: block<$block>\n";
3364 }
3366 #print "APW: ALLOWED: lines block<$block>\n";
3368 }
3369 # Check the post-context.
3374 }
3376 #print "APW: ALLOWED: chunk-1 block<$block>\n";
3378 }
3379 }
3386 }
3390 }
3391 }
3393 # check for unnecessary blank lines around braces
3397 }
3401 }
3403 # warn about #if 0
3408 }
3410 # check for needless "if (<foo>) fn(<foo>)" uses
3416 }
3417 }
3419 # check for bad placement of section $InitAttribute (e.g.: __initdata)
3422 if ($line =~ /^\+\s*static\s+(?:const\s+)?(?:$attr\s+)?($NonptrTypeWithAttr)\s+(?:$attr\s+)?($Ident(?:\[[^]]*\])?)\s*[=;]/) {
3432 $fixed[$linenr - 1] =~ s/(\bstatic\s+(?:const\s+)?)(?:$attr\s+)?($NonptrTypeWithAttr)\s+(?:$attr\s+)?($Ident(?:\[[^]]*\])?)\s*([=;])\s*/"$1" . trim(string_find_replace($2, "\\s*$attr\\s*", " ")) . " " . trim(string_find_replace($3, "\\s*$attr\\s*", "")) . " $attr" . ("$4" eq ";" ? ";" : " = ")/e;
3433 }
3434 }
3435 }
3437 # check for $InitAttributeData (ie: __initdata) with const
3448 }
3449 }
3451 # check for $InitAttributeConst (ie: __initconst) without const
3463 }
3464 }
3466 # warn about #ifdefs in C files
3467 # if ($line =~ /^.\s*\#\s*if(|n)def/ && ($realfile =~ /\.c$/)) {
3468 # print "#ifdef in C files should be avoided\n";
3469 # print "$herecurr";
3470 # $clean = 0;
3471 # }
3473 # warn about spacing in #ifdefs
3480 }
3482 }
3484 # Check that the storage class is at the beginning of a declaration
3488 }
3490 # check the location of the inline attribute, that it is between
3491 # storage class and type.
3496 }
3498 # Check for __inline__ and __inline, prefer inline
3506 }
3507 }
3509 # Check for __attribute__ packed, prefer __packed
3514 }
3516 # Check for __attribute__ aligned, prefer __aligned
3521 }
3523 # Check for __attribute__ format(printf, prefer __printf
3527 "__printf(string-index, first-to-check) is preferred over __attribute__((format(printf, string-index, first-to-check)))\n" . $herecurr) &&
3529 $fixed[$linenr - 1] =~ s/\b__attribute__\s*\(\s*\(\s*format\s*\(\s*printf\s*,\s*(.*)\)\s*\)\s*\)/"__printf(" . trim($1) . ")"/ex;
3531 }
3532 }
3534 # Check for __attribute__ format(scanf, prefer __scanf
3538 "__scanf(string-index, first-to-check) is preferred over __attribute__((format(scanf, string-index, first-to-check)))\n" . $herecurr) &&
3540 $fixed[$linenr - 1] =~ s/\b__attribute__\s*\(\s*\(\s*format\s*\(\s*scanf\s*,\s*(.*)\)\s*\)\s*\)/"__scanf(" . trim($1) . ")"/ex;
3541 }
3542 }
3544 # check for sizeof(&)
3548 }
3550 # check for sizeof without parenthesis
3555 $fixed[$linenr - 1] =~ s/\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/"sizeof(" . trim($1) . ")"/ex;
3556 }
3557 }
3559 # check for line continuations in quoted strings with odd counts of "
3563 }
3565 # Check for misused memsets
3580 }
3581 }
3583 # typecasts on min/max could be min_t/max_t
3601 }
3604 }
3605 }
3607 # check for naked sscanf
3619 }
3622 }
3624 # check for new externs in .h files.
3631 }
3632 }
3634 # check for new externs in .c files.
3637 {
3644 }
3647 {
3650 }
3655 }
3659 {
3662 }
3665 # check for multiple semicolons
3671 }
3672 }
3674 # check for case / default statements not preceeded by break/fallthrough/switch
3692 }
3696 }
3697 }
3699 # check for switch/default statements without a break;
3708 }
3711 }
3713 # check for gcc specific __FUNCTION__
3719 }
3720 }
3722 # check for comparisons against true and false
3738 }
3743 ## maybe suggesting a correct construct would better
3744 ## "Using comparison to $otype is error prone. Perhaps use '${lead}${op}${arg}${trail}'\n" . $herecurr);
3746 }
3747 }
3749 # check for %L{u,d,i} in strings
3758 }
3759 }
3761 # Mode permission misuses where it seems decimal should be octal
3762 # This uses a shortcut match to avoid unnecessary uses of a slow foreach loop
3773 }
3784 }
3785 }
3786 }
3787 }
3788 }
3790 # If we have no input at all, then there is nothing to report on
3791 # so just keep quiet.
3794 }
3796 # In mailback mode only produce a report in the negative, for
3797 # things that appear to be patches.
3800 }
3802 # This is not a patch, and we are are in 'no-patch' mode so
3803 # just keep quiet.
3806 }
3811 }
3820 }
3827 }
3829 # If there were whitespace errors which cleanpatch can fix
3830 # then suggest that.
3835 }
3836 }
3855 }
3858 }
3859 }
3866 Do _NOT_ trust the results written to this file.
3869 This EXPERIMENTAL file is simply a convenience to help rewrite patches.
3872 EOM
3873 }
3874 }
3878 }
3883 EOM
3884 }
3887 }