X-Git-Url: http://ftp.safe.ca/?a=blobdiff_plain;f=scripts%2Fcheckpatch.pl;h=277c32647f36d84dc805efcd33f7ac1449a31ed1;hb=f61534dfd38f895b203e2aadaba04f21a992ca8c;hp=39339529b99b9662169f7484099a9bd0253326a3;hpb=389834b680c13f4727c14f70fa71c2c5678b6081;p=safe%2Fjmp%2Flinux-2.6 diff --git a/scripts/checkpatch.pl b/scripts/checkpatch.pl index 3933952..277c326 100755 --- a/scripts/checkpatch.pl +++ b/scripts/checkpatch.pl @@ -1,14 +1,15 @@ #!/usr/bin/perl -w # (c) 2001, Dave Jones. (the file handling bit) -# (c) 2005, Joel Scohpp (the ugly bit) +# (c) 2005, Joel Schopp (the ugly bit) # (c) 2007, Andy Whitcroft (new conditions, test suite, etc) # Licensed under the terms of the GNU GPL License version 2 use strict; my $P = $0; +$P =~ s@.*/@@g; -my $V = '0.03'; +my $V = '0.06'; use Getopt::Long qw(:config no_auto_abbrev); @@ -16,17 +17,19 @@ my $quiet = 0; my $tree = 1; my $chk_signoff = 1; my $chk_patch = 1; +my $tst_type = 0; GetOptions( 'q|quiet' => \$quiet, 'tree!' => \$tree, 'signoff!' => \$chk_signoff, 'patch!' => \$chk_patch, + 'test-type!' => \$tst_type, ) or exit; my $exit = 0; if ($#ARGV < 0) { - print "usage: patchstylecheckemail.pl [options] patchfile\n"; + print "usage: $P [options] patchfile\n"; print "version: $V\n"; print "options: -q => quiet\n"; print " --no-tree => run without a kernel tree\n"; @@ -59,15 +62,15 @@ if ($tree && -f $removal) { } } -my @lines = (); +my @rawlines = (); while (<>) { chomp; - push(@lines, $_); + push(@rawlines, $_); if (eof(ARGV)) { - if (!process($ARGV, @lines)) { + if (!process($ARGV, @rawlines)) { $exit = 1; } - @lines = (); + @rawlines = (); } } @@ -118,24 +121,57 @@ sub line_stats { return (length($line), length($white)); } +sub sanitise_line { + my ($line) = @_; + + my $res = ''; + my $l = ''; + + my $quote = ''; + + foreach my $c (split(//, $line)) { + if ($l ne "\\" && ($c eq "'" || $c eq '"')) { + if ($quote eq '') { + $quote = $c; + $res .= $c; + $l = $c; + next; + } elsif ($quote eq $c) { + $quote = ''; + } + } + if ($quote && $c ne "\t") { + $res .= "X"; + } else { + $res .= $c; + } + + $l = $c; + } + + return $res; +} + sub ctx_block_get { - my ($linenr, $remain, $outer) = @_; + my ($linenr, $remain, $outer, $open, $close) = @_; my $line; my $start = $linenr - 1; - my $end = $linenr - 1 + $remain; my $blk = ''; my @o; my @c; my @res = (); - for ($line = $start; $line < $end; $line++) { - $blk .= $lines[$line]; + for ($line = $start; $remain > 0; $line++) { + next if ($rawlines[$line] =~ /^-/); + $remain--; + + $blk .= $rawlines[$line]; - @o = ($blk =~ /\{/g); - @c = ($blk =~ /\}/g); + @o = ($blk =~ /$open/g); + @c = ($blk =~ /$close/g); if (!$outer || (scalar(@o) - scalar(@c)) == 1) { - push(@res, $lines[$line]); + push(@res, $rawlines[$line]); } last if (scalar(@o) == scalar(@c)); @@ -146,19 +182,24 @@ sub ctx_block_get { sub ctx_block_outer { my ($linenr, $remain) = @_; - return ctx_block_get($linenr, $remain, 1); + return ctx_block_get($linenr, $remain, 1, '\{', '\}'); } sub ctx_block { my ($linenr, $remain) = @_; - return ctx_block_get($linenr, $remain, 0); + return ctx_block_get($linenr, $remain, 0, '\{', '\}'); +} +sub ctx_statement { + my ($linenr, $remain) = @_; + + return ctx_block_get($linenr, $remain, 0, '\(', '\)'); } sub ctx_locate_comment { my ($first_line, $end_line) = @_; # Catch a comment on the end of the line itself. - my ($current_comment) = ($lines[$end_line - 1] =~ m@.*(/\*.*\*/)\s*$@); + my ($current_comment) = ($rawlines[$end_line - 1] =~ m@.*(/\*.*\*/)\s*$@); return $current_comment if (defined $current_comment); # Look through the context and try and figure out if there is a @@ -166,8 +207,8 @@ sub ctx_locate_comment { my $in_comment = 0; $current_comment = ''; for (my $linenr = $first_line; $linenr < $end_line; $linenr++) { - my $line = $lines[$linenr - 1]; - ##warn " $line\n"; + my $line = $rawlines[$linenr - 1]; + #warn " $line\n"; if ($linenr == $first_line and $line =~ m@^.\s*\*@) { $in_comment = 1; } @@ -190,7 +231,7 @@ sub ctx_has_comment { my ($first_line, $end_line) = @_; my $cmt = ctx_locate_comment($first_line, $end_line); - ##print "LINE: $lines[$end_line - 1 ]\n"; + ##print "LINE: $rawlines[$end_line - 1 ]\n"; ##print "CMMT: $cmt\n"; return ($cmt ne ''); @@ -205,10 +246,6 @@ sub cat_vet { return $vet; } -sub has_non_quoted { - return ($_[0] =~ m{$_[1]} and $_[0] !~ m{\".*$_[1].*\"}); -} - sub process { my $filename = shift; my @lines = @_; @@ -234,12 +271,48 @@ sub process { my $in_comment = 0; my $first_line = 0; + my $Ident = qr{[A-Za-z\d_]+}; + my $Storage = qr{extern|static}; + my $Sparse = qr{__user|__kernel|__force|__iomem}; + my $NonptrType = qr{ + \b + (?:const\s+)? + (?:unsigned\s+)? + (?: + void| + char| + short| + int| + long| + unsigned| + float| + double| + long\s+int| + long\s+long| + long\s+long\s+int| + struct\s+$Ident| + union\s+$Ident| + ${Ident}_t + ) + (?:\s+$Sparse)* + \b + }x; + my $Type = qr{ + \b$NonptrType\b + (?:\s*\*+\s*const|\s*\*+)? + }x; + my $Declare = qr{(?:$Storage\s+)?$Type}; + my $Attribute = qr{__read_mostly|__init|__initdata}; + foreach my $line (@lines) { $linenr++; + my $rawline = $line; + #extract the filename as it passes if ($line=~/^\+\+\+\s+(\S+)/) { $realfile=$1; + $realfile =~ s@^[^/]*/@@; $in_comment = 0; next; } @@ -287,24 +360,24 @@ sub process { # Track the previous line. ($prevline, $stashline) = ($stashline, $line); ($previndent, $stashindent) = ($stashindent, $indent); + } elsif ($realcnt == 1) { + $realcnt--; } #make up the handle for any error we report on this line $here = "#$linenr: "; $here .= "FILE: $realfile:$realline:" if ($realcnt != 0); + my $hereline = "$here\n$line\n"; my $herecurr = "$here\n$line\n\n"; my $hereprev = "$here\n$prevline\n$line\n\n"; #check the patch for a signoff: - if ($line =~ /^\s*Signed-off-by:\s/) { - $signoff++; - - } elsif ($line =~ /^\s*signed-off-by:/i) { + if ($line =~ /^\s*signed-off-by:/i) { # This is a signoff, if ugly, so do not double report. $signoff++; if (!($line =~ /^\s*Signed-off-by:/)) { - print "use Signed-off-by:\n"; + print "Signed-off-by: is the preferred form\n"; print "$herecurr"; $clean = 0; } @@ -315,21 +388,28 @@ sub process { } } -#ignore lines not being added - if ($line=~/^[^\+]/) {next;} +# Check for wrappage within a valid hunk of the file + if ($realcnt != 0 && $line !~ m{^(?:\+|-| |$)}) { + print "patch seems to be corrupt (line wrapped?) [$realcnt]\n"; + print "$herecurr"; + $clean = 0; + } + +#ignore lines being removed + if ($line=~/^-/) {next;} -# check we are in a valid source file *.[hcsS] if not then ignore this hunk - next if ($realfile !~ /\.[hcsS]$/); +# check we are in a valid source file if not then ignore this hunk + next if ($realfile !~ /\.(h|c|s|S|pl|sh)$/); #trailing whitespace - if ($line=~/\S\s+$/) { + if ($line =~ /^\+.*\S\s+$/ || $line =~ /^\+\s+$/) { my $herevet = "$here\n" . cat_vet($line) . "\n\n"; print "trailing whitespace\n"; print "$herevet"; $clean = 0; } #80 column limit - if (!($prevline=~/\/\*\*/) && $length > 80) { + if ($line =~ /^\+/ && !($prevline=~/\/\*\*/) && $length > 80) { print "line over 80 characters\n"; print "$herecurr"; $clean = 0; @@ -353,48 +433,128 @@ sub process { # next if ($in_comment); +# Remove comments from the line before processing. + $line =~ s@/\*.*\*/@@g; + $line =~ s@/\*.*@@; + $line =~ s@.*\*/@@; + +# Standardise the strings and chars within the input to simplify matching. + $line = sanitise_line($line); + +# +# Checks which may be anchored in the context. +# + +# Check for switch () and associated case and default +# statements should be at the same indent. + if ($line=~/\bswitch\s*\(.*\)/) { + my $err = ''; + my $sep = ''; + my @ctx = ctx_block_outer($linenr, $realcnt); + shift(@ctx); + for my $ctx (@ctx) { + my ($clen, $cindent) = line_stats($ctx); + if ($ctx =~ /^\+\s*(case\s+|default:)/ && + $indent != $cindent) { + $err .= "$sep$ctx\n"; + $sep = ''; + } else { + $sep = "[...]\n"; + } + } + if ($err ne '') { + print "switch and case should be at the same indent\n"; + print "$here\n$line\n$err\n"; + $clean = 0; + } + } + +#ignore lines not being added + if ($line=~/^[^\+]/) {next;} + +# TEST: allow direct testing of the type matcher. + if ($tst_type && $line =~ /^.$Declare$/) { + print "TEST: is type $Declare\n"; + print "$herecurr"; + $clean = 0; + next; + } + +# +# Checks which are anchored on the added line. +# + +# check for malformed paths in #include statements (uses RAW line) + if ($rawline =~ m{^.#\s*include\s+[<"](.*)[">]}) { + my $path = $1; + if ($path =~ m{//}) { + print "malformed #include filename\n"; + print "$herecurr"; + $clean = 0; + } + # Sanitise this special form of string. + $path = 'X' x length($path); + $line =~ s{\<.*\>}{<$path>}; + } + # no C99 // comments - if (has_non_quoted($line, '//')) { + if ($line =~ m{//}) { print "do not use C99 // comments\n"; print "$herecurr"; $clean = 0; } - - # Remove comments from the line before processing. - $line =~ s@/\*.*\*/@@g; - $line =~ s@/\*.*@@; - $line =~ s@.*\*/@@; + # Remove C99 comments. $line =~ s@//.*@@; #EXPORT_SYMBOL should immediately follow its function closing }. - if (($line =~ /EXPORT_SYMBOL.*\(.*\)/) || - ($line =~ /EXPORT_UNUSED_SYMBOL.*\(.*\)/)) { + if (($line =~ /EXPORT_SYMBOL.*\((.*)\)/) || + ($line =~ /EXPORT_UNUSED_SYMBOL.*\((.*)\)/)) { + my $name = $1; if (($prevline !~ /^}/) && ($prevline !~ /^\+}/) && - ($prevline !~ /^ }/)) { - print "EXPORT_SYMBOL(func); should immediately follow its function\n"; + ($prevline !~ /^ }/) && + ($prevline !~ /\s$name(?:\s+$Attribute)?\s*(?:;|=)/)) { + print "EXPORT_SYMBOL(foo); should immediately follow its function/variable\n"; print "$herecurr"; $clean = 0; } } - # check for static initialisers. +# check for static initialisers. if ($line=~/\s*static\s.*=\s+(0|NULL);/) { print "do not initialise statics to 0 or NULL\n"; print "$herecurr"; $clean = 0; } - # check for new typedefs. - if ($line=~/\s*typedef\s/) { +# check for new typedefs, only function parameters and sparse annotations +# make sense. + if ($line =~ /\btypedef\s/ && + $line !~ /\btypedef\s+$Type\s+\(\s*$Ident\s*\)\s*\(/ && + $line !~ /\b__bitwise(?:__|)\b/) { print "do not add new typedefs\n"; print "$herecurr"; $clean = 0; } # * goes on variable not on type - if ($line=~/[A-Za-z\d_]+\* [A-Za-z\d_]+/) { - print "\"foo* bar\" should be \"foo *bar\"\n"; + if ($line =~ m{\($NonptrType(\*+)(?:\s+const)?\)}) { + print "\"(foo$1)\" should be \"(foo $1)\"\n"; + print "$herecurr"; + $clean = 0; + + } elsif ($line =~ m{\($NonptrType\s+(\*+)(?!\s+const)\s+\)}) { + print "\"(foo $1 )\" should be \"(foo $1)\"\n"; + print "$herecurr"; + $clean = 0; + + } elsif ($line =~ m{$NonptrType(\*+)(?:\s+const)?\s+[A-Za-z\d_]+}) { + print "\"foo$1 bar\" should be \"foo $1bar\"\n"; + print "$herecurr"; + $clean = 0; + + } elsif ($line =~ m{$NonptrType\s+(\*+)(?!\s+const)\s+[A-Za-z\d_]+}) { + print "\"foo $1 bar\" should be \"foo $1bar\"\n"; print "$herecurr"; $clean = 0; } @@ -406,30 +566,50 @@ sub process { # $clean = 0; # } -# printk should use KERN_* levels +# printk should use KERN_* levels. Note that follow on printk's on the +# same line do not need a level, so we use the current block context +# to try and find and validate the current printk. In summary the current +# printk includes all preceeding printk's which have no newline on the end. +# we assume the first bad printk is the one to report. if ($line =~ /\bprintk\((?!KERN_)/) { - print "printk() should include KERN_ facility level\n"; - print "$herecurr"; - $clean = 0; + my $ok = 0; + for (my $ln = $linenr - 1; $ln >= $first_line; $ln--) { + #print "CHECK<$lines[$ln - 1]\n"; + # we have a preceeding printk if it ends + # with "\n" ignore it, else it is to blame + if ($lines[$ln - 1] =~ m{\bprintk\(}) { + if ($rawlines[$ln - 1] !~ m{\\n"}) { + $ok = 1; + } + last; + } + } + if ($ok == 0) { + print "printk() should include KERN_ facility level\n"; + print "$herecurr"; + $clean = 0; + } } -#function brace can't be on same line, except for #defines of do while, or if closed on same line - if (($line=~/[A-Za-z\d_]+\**\s+\**[A-Za-z\d_]+\(.*\).* {/) and +# function brace can't be on same line, except for #defines of do while, +# or if closed on same line + if (($line=~/$Type\s*[A-Za-z\d_]+\(.*\).* {/) and !($line=~/\#define.*do\s{/) and !($line=~/}/)) { print "braces following function declarations go on the next line\n"; print "$herecurr"; $clean = 0; } + +# Check operator spacing. # Note we expand the line with the leading + as the real # line will be displayed with the leading + and the tabs # will therefore also expand that way. my $opline = $line; $opline = expand_tabs($opline); - $opline =~ s/^.//; + $opline =~ s/^./ /; if (!($line=~/\#\s*include/)) { - # Check operator spacing. my @elements = split(/(<<=|>>=|<=|>=|==|!=|\+=|-=|\*=|\/=|%=|\^=|\|=|&=|->|<<|>>|<|>|=|!|~|&&|\|\||,|\^|\+\+|--|;|&|\||\+|-|\*|\/\/|\/)/, $opline); - my $off = 1; + my $off = 0; for (my $n = 0; $n < $#elements; $n += 2) { $off += length($elements[$n]); @@ -452,19 +632,32 @@ sub process { $c = 'E'; } + # Pick up the preceeding and succeeding characters. + my $ca = substr($opline, $off - 1, 1); + my $cc = ''; + if (length($opline) >= ($off + length($elements[$n + 1]))) { + $cc = substr($opline, $off + length($elements[$n + 1])); + } + my $ctx = "${a}x${c}"; my $at = "(ctx:$ctx)"; my $ptr = (" " x $off) . "^"; - my $hereptr = "$here\n$line\n$ptr\n\n"; + my $hereptr = "$hereline$ptr\n\n"; ##print "<$s1:$op:$s2> <$elements[$n]:$elements[$n + 1]:$elements[$n + 2]>\n"; - # Skip things apparently in quotes. - next if ($line=~/\".*\Q$op\E.*\"/ or $line=~/\'\Q$op\E\'/); - # We need ; as an operator. // is a comment. - if ($op eq ';' or $op eq '//') { + # ; should have either the end of line or a space or \ after it + if ($op eq ';') { + if ($ctx !~ /.x[WE]/ && $cc !~ /^\\/) { + print "need space after that '$op' $at\n"; + print "$hereptr"; + $clean = 0; + } + + # // is a comment + } elsif ($op eq '//') { # -> should have no spaces } elsif ($op eq '->') { @@ -476,7 +669,7 @@ sub process { # , must have a space on the right. } elsif ($op eq ',') { - if ($ctx !~ /.xW|.xE/) { + if ($ctx !~ /.xW|.xE/ && $cc !~ /^}/) { print "need space after that '$op' $at\n"; print "$hereptr"; $clean = 0; @@ -497,11 +690,16 @@ sub process { # unary ++ and unary -- are allowed no space on one side. } elsif ($op eq '++' or $op eq '--') { - if ($ctx !~ /[WOB]x[^W]|[^W]x[WOB]/) { + if ($ctx !~ /[WOB]x[^W]/ && $ctx !~ /[^W]x[WOBE]/) { print "need space one side of that '$op' $at\n"; print "$hereptr"; $clean = 0; } + if ($ctx =~ /Wx./ && $cc =~ /^;/) { + print "no space before that '$op' $at\n"; + print "$hereptr"; + $clean = 0; + } # & is both unary and binary # unary: @@ -515,20 +713,26 @@ sub process { # # - is the same # - # * is the same only adding: - # type: - # (foo *) - # (foo **) - # } elsif ($op eq '&' or $op eq '-') { - if ($ctx !~ /VxV|[EWB]x[WE]|[EWB]x[VO]/) { + if ($ctx !~ /VxV|[EW]x[WE]|[EWB]x[VO]/) { print "need space before that '$op' $at\n"; print "$hereptr"; $clean = 0; } + # * is the same as & only adding: + # type: + # (foo *) + # (foo **) + # } elsif ($op eq '*') { - if ($ctx !~ /VxV|[EWB]x[WE]|[EWB]x[VO]|[EWO]x[OBV]/) { + if ($ca eq '*') { + if ($cc =~ /^\s(?!\s*const)/) { + print "no space after that '$op' $at\n"; + print "$hereptr"; + $clean = 0; + } + } elsif ($ctx !~ /VxV|[EW]x[WE]|[EWB]x[VO]|OxV|WxB|BxB/) { print "need space before that '$op' $at\n"; print "$hereptr"; $clean = 0; @@ -577,8 +781,9 @@ sub process { } # Check for illegal assignment in if conditional. - if ($line=~/\b(if|while)\s*\(.*[^<>!=]=[^=].*\)/) { - print "do not use assignment in condition\n"; + if ($line=~/\bif\s*\(.*[^<>!=]=[^=].*\)/) { + #next if ($line=~/\".*\Q$op\E.*\"/ or $line=~/\'\Q$op\E\'/); + print "do not use assignment in if condition\n"; print "$herecurr"; $clean = 0; } @@ -592,30 +797,6 @@ sub process { $clean = 0; } - # Check for switch () and associated case and default - # statements should be at the same indent. - if ($line=~/\bswitch\s*\(.*\)/) { - my $err = ''; - my $sep = ''; - my @ctx = ctx_block_outer($linenr, $realcnt); - shift(@ctx); - for my $ctx (@ctx) { - my ($clen, $cindent) = line_stats($ctx); - if ($ctx =~ /\s*(case\s+|default:)/ && - $indent != $cindent) { - $err .= "$sep$ctx\n"; - $sep = ''; - } else { - $sep = "[...]\n"; - } - } - if ($err ne '') { - print "switch and case should be at the same indent\n"; - print "$here\n$line\n$err\n"; - $clean = 0; - } - } - #studly caps, commented out until figure out how to distinguish between use of existing and adding new # if (($line=~/[\w_][a-z\d]+[A-Z]/) and !($line=~/print/)) { # print "No studly caps, use _\n"; @@ -630,8 +811,8 @@ sub process { $clean = 0; } -#warn if is #included and is available. - if ($tree && $line =~ qr|\s*\#\s*include\s*\|) { +#warn if is #included and is available (uses RAW line) + if ($tree && $rawline =~ m{^.\#\s*include\s*\}) { my $checkfile = "include/linux/$1.h"; if (-f $checkfile) { print "Use #include instead of \n"; @@ -640,17 +821,18 @@ sub process { } } -#if/while/etc brace do not go on next line, unless #defining a do while loop, or if that brace on the next line is for something else - if ($prevline=~/\b(if|while|for|switch)\s*\(/) { +# if/while/etc brace do not go on next line, unless defining a do while loop, +# or if that brace on the next line is for something else + if ($prevline=~/\b(?:(if|while|for|switch)\s*\(|do\b|else\b)/) { my @opened = $prevline=~/\(/g; my @closed = $prevline=~/\)/g; my $nr_line = $linenr; - my $remaining = $realcnt; + my $remaining = $realcnt - 1; my $next_line = $line; my $extra_lines = 0; my $display_segment = $prevline; - while ($remaining > 1 && scalar @opened > scalar @closed) { + while ($remaining > 0 && scalar @opened > scalar @closed) { $prevline .= $next_line; $display_segment .= "\n" . $next_line; $next_line = $lines[$nr_line]; @@ -661,26 +843,56 @@ sub process { @closed = $prevline=~/\)/g; } - if (($prevline=~/\b(if|while|for|switch)\s*\(.*\)\s*$/) and ($next_line=~/{/) and - !($next_line=~/\b(if|while|for)/) and !($next_line=~/\#define.*do.*while/)) { + if (($prevline=~/\b(?:(if|while|for|switch)\s*\(.*\)|do|else)\s*$/) and ($next_line=~/{/) and + !($next_line=~/\b(?:if|while|for|switch|do|else)\b/) and !($next_line=~/\#define.*do.*while/)) { print "That { should be on the previous line\n"; print "$here\n$display_segment\n$next_line\n\n"; $clean = 0; } } -#multiline macros should be enclosed in a do while loop - if (($prevline=~/\#define.*\\/) and !($prevline=~/do\s+{/) and - !($prevline=~/\(\{/) and ($line=~/;\s*\\/) and - !($line=~/do.*{/) and !($line=~/\(\{/)) { - print "Macros with multiple statements should be enclosed in a do - while loop\n"; - print "$hereprev"; +# if and else should not have general statements after it + if ($line =~ /^.\s*(?:}\s*)?else\b(.*)/ && + $1 !~ /^\s*(?:\sif|{|$)/) { + print "trailing statements should be on next line\n"; + print "$herecurr"; $clean = 0; } -# don't include deprecated include files +# multi-statement macros should be enclosed in a do while loop, grab the +# first statement and ensure its the whole macro if its not enclosed +# in a known goot container + if (($prevline=~/\#define.*\\/) and + !($prevline=~/do\s+{/) and !($prevline=~/\(\{/) and + !($line=~/do.*{/) and !($line=~/\(\{/) and + !($line=~/^.\s*$Declare\s/)) { + # Grab the first statement, if that is the entire macro + # its ok. This may start either on the #define line + # or the one below. + my $ln = $linenr; + my $cnt = $realcnt; + + # If the macro starts on the define line start there. + if ($prevline !~ m{^.#\s*define\s*$Ident(?:\([^\)]*\))?\s*\\\s*$}) { + $ln--; + $cnt++; + } + my $ctx = join('', ctx_statement($ln, $cnt)); + + if ($ctx =~ /\\$/) { + if ($ctx =~ /;/) { + print "Macros with multiple statements should be enclosed in a do - while loop\n"; + } else { + print "Macros with complex values should be enclosed in parenthesis\n"; + } + print "$hereprev"; + $clean = 0; + } + } + +# don't include deprecated include files (uses RAW line) for my $inc (@dep_includes) { - if ($line =~ m@\#\s*include\s*\<$inc>@) { + if ($rawline =~ m@\#\s*include\s*\<$inc>@) { print "Don't use <$inc>: see Documentation/feature-removal-schedule.txt\n"; print "$herecurr"; $clean = 0; @@ -689,7 +901,7 @@ sub process { # don't use deprecated functions for my $func (@dep_functions) { - if (has_non_quoted($line, '\b' . $func . '\b')) { + if ($line =~ /\b$func\b/) { print "Don't use $func(): see Documentation/feature-removal-schedule.txt\n"; print "$herecurr"; $clean = 0; @@ -697,19 +909,26 @@ sub process { } # no volatiles please - if (has_non_quoted($line, '\bvolatile\b')) { + if ($line =~ /\bvolatile\b/ && $line !~ /\basm\s+volatile\b/) { print "Use of volatile is usually wrong: see Documentation/volatile-considered-harmful.txt\n"; print "$herecurr"; $clean = 0; } -# warn about #ifdefs in C files - if ($line =~ /^.#\s*if(|n)def/ && ($realfile =~ /\.c$/)) { - print "#ifdef in C files should be avoided\n"; +# warn about #if 0 + if ($line =~ /^.#\s*if\s+0\b/) { + print "#if 0 -- if this code redundant remove it\n"; print "$herecurr"; $clean = 0; } +# warn about #ifdefs in C files +# if ($line =~ /^.#\s*if(|n)def/ && ($realfile =~ /\.c$/)) { +# print "#ifdef in C files should be avoided\n"; +# print "$herecurr"; +# $clean = 0; +# } + # check for spinlock_t definitions without a comment. if ($line =~ /^.\s*(struct\s+mutex|spinlock_t)\s+\S+;/) { my $which = $1; @@ -733,6 +952,13 @@ sub process { print "$herecurr"; $clean = 0; } + + if ($line =~ /$Type\s+(?:inline|__always_inline)\b/ || + $line =~ /\b(?:inline|always_inline)\s+$Storage/) { + print "inline keyword should sit between storage class and type\n"; + print "$herecurr"; + $clean = 0; + } } if ($chk_patch && !$is_patch) {