Back to home page

LXR

 
 

    


0001 #!/usr/bin/perl -w
0002 # (c) 2001, Dave Jones. (the file handling bit)
0003 # (c) 2005, Joel Schopp <jschopp@austin.ibm.com> (the ugly bit)
0004 # (c) 2007,2008, Andy Whitcroft <apw@uk.ibm.com> (new conditions, test suite)
0005 # (c) 2008-2010 Andy Whitcroft <apw@canonical.com>
0006 # Licensed under the terms of the GNU GPL License version 2
0007 
0008 use strict;
0009 use POSIX;
0010 use File::Basename;
0011 use Cwd 'abs_path';
0012 use Term::ANSIColor qw(:constants);
0013 
0014 my $P = $0;
0015 my $D = dirname(abs_path($P));
0016 
0017 my $V = '0.32';
0018 
0019 use Getopt::Long qw(:config no_auto_abbrev);
0020 
0021 my $quiet = 0;
0022 my $tree = 1;
0023 my $chk_signoff = 1;
0024 my $chk_patch = 1;
0025 my $tst_only;
0026 my $emacs = 0;
0027 my $terse = 0;
0028 my $showfile = 0;
0029 my $file = 0;
0030 my $git = 0;
0031 my %git_commits = ();
0032 my $check = 0;
0033 my $check_orig = 0;
0034 my $summary = 1;
0035 my $mailback = 0;
0036 my $summary_file = 0;
0037 my $show_types = 0;
0038 my $list_types = 0;
0039 my $fix = 0;
0040 my $fix_inplace = 0;
0041 my $root;
0042 my %debug;
0043 my %camelcase = ();
0044 my %use_type = ();
0045 my @use = ();
0046 my %ignore_type = ();
0047 my @ignore = ();
0048 my $help = 0;
0049 my $configuration_file = ".checkpatch.conf";
0050 my $max_line_length = 80;
0051 my $ignore_perl_version = 0;
0052 my $minimum_perl_version = 5.10.0;
0053 my $min_conf_desc_length = 4;
0054 my $spelling_file = "$D/spelling.txt";
0055 my $codespell = 0;
0056 my $codespellfile = "/usr/share/codespell/dictionary.txt";
0057 my $conststructsfile = "$D/const_structs.checkpatch";
0058 my $color = 1;
0059 my $allow_c99_comments = 1;
0060 
0061 sub help {
0062     my ($exitcode) = @_;
0063 
0064     print << "EOM";
0065 Usage: $P [OPTION]... [FILE]...
0066 Version: $V
0067 
0068 Options:
0069   -q, --quiet                quiet
0070   --no-tree                  run without a kernel tree
0071   --no-signoff               do not check for 'Signed-off-by' line
0072   --patch                    treat FILE as patchfile (default)
0073   --emacs                    emacs compile window format
0074   --terse                    one line per report
0075   --showfile                 emit diffed file position, not input file position
0076   -g, --git                  treat FILE as a single commit or git revision range
0077                              single git commit with:
0078                                <rev>
0079                                <rev>^
0080                                <rev>~n
0081                              multiple git commits with:
0082                                <rev1>..<rev2>
0083                                <rev1>...<rev2>
0084                                <rev>-<count>
0085                              git merges are ignored
0086   -f, --file                 treat FILE as regular source file
0087   --subjective, --strict     enable more subjective tests
0088   --list-types               list the possible message types
0089   --types TYPE(,TYPE2...)    show only these comma separated message types
0090   --ignore TYPE(,TYPE2...)   ignore various comma separated message types
0091   --show-types               show the specific message type in the output
0092   --max-line-length=n        set the maximum line length, if exceeded, warn
0093   --min-conf-desc-length=n   set the min description length, if shorter, warn
0094   --root=PATH                PATH to the kernel tree root
0095   --no-summary               suppress the per-file summary
0096   --mailback                 only produce a report in case of warnings/errors
0097   --summary-file             include the filename in summary
0098   --debug KEY=[0|1]          turn on/off debugging of KEY, where KEY is one of
0099                              'values', 'possible', 'type', and 'attr' (default
0100                              is all off)
0101   --test-only=WORD           report only warnings/errors containing WORD
0102                              literally
0103   --fix                      EXPERIMENTAL - may create horrible results
0104                              If correctable single-line errors exist, create
0105                              "<inputfile>.EXPERIMENTAL-checkpatch-fixes"
0106                              with potential errors corrected to the preferred
0107                              checkpatch style
0108   --fix-inplace              EXPERIMENTAL - may create horrible results
0109                              Is the same as --fix, but overwrites the input
0110                              file.  It's your fault if there's no backup or git
0111   --ignore-perl-version      override checking of perl version.  expect
0112                              runtime errors.
0113   --codespell                Use the codespell dictionary for spelling/typos
0114                              (default:/usr/share/codespell/dictionary.txt)
0115   --codespellfile            Use this codespell dictionary
0116   --color                    Use colors when output is STDOUT (default: on)
0117   -h, --help, --version      display this help and exit
0118 
0119 When FILE is - read standard input.
0120 EOM
0121 
0122     exit($exitcode);
0123 }
0124 
0125 sub uniq {
0126     my %seen;
0127     return grep { !$seen{$_}++ } @_;
0128 }
0129 
0130 sub list_types {
0131     my ($exitcode) = @_;
0132 
0133     my $count = 0;
0134 
0135     local $/ = undef;
0136 
0137     open(my $script, '<', abs_path($P)) or
0138         die "$P: Can't read '$P' $!\n";
0139 
0140     my $text = <$script>;
0141     close($script);
0142 
0143     my @types = ();
0144     for ($text =~ /\b(?:(?:CHK|WARN|ERROR)\s*\(\s*"([^"]+)")/g) {
0145         push (@types, $_);
0146     }
0147     @types = sort(uniq(@types));
0148     print("#\tMessage type\n\n");
0149     foreach my $type (@types) {
0150         print(++$count . "\t" . $type . "\n");
0151     }
0152 
0153     exit($exitcode);
0154 }
0155 
0156 my $conf = which_conf($configuration_file);
0157 if (-f $conf) {
0158     my @conf_args;
0159     open(my $conffile, '<', "$conf")
0160         or warn "$P: Can't find a readable $configuration_file file $!\n";
0161 
0162     while (<$conffile>) {
0163         my $line = $_;
0164 
0165         $line =~ s/\s*\n?$//g;
0166         $line =~ s/^\s*//g;
0167         $line =~ s/\s+/ /g;
0168 
0169         next if ($line =~ m/^\s*#/);
0170         next if ($line =~ m/^\s*$/);
0171 
0172         my @words = split(" ", $line);
0173         foreach my $word (@words) {
0174             last if ($word =~ m/^#/);
0175             push (@conf_args, $word);
0176         }
0177     }
0178     close($conffile);
0179     unshift(@ARGV, @conf_args) if @conf_args;
0180 }
0181 
0182 GetOptions(
0183     'q|quiet+'  => \$quiet,
0184     'tree!'     => \$tree,
0185     'signoff!'  => \$chk_signoff,
0186     'patch!'    => \$chk_patch,
0187     'emacs!'    => \$emacs,
0188     'terse!'    => \$terse,
0189     'showfile!' => \$showfile,
0190     'f|file!'   => \$file,
0191     'g|git!'    => \$git,
0192     'subjective!'   => \$check,
0193     'strict!'   => \$check,
0194     'ignore=s'  => \@ignore,
0195     'types=s'   => \@use,
0196     'show-types!'   => \$show_types,
0197     'list-types!'   => \$list_types,
0198     'max-line-length=i' => \$max_line_length,
0199     'min-conf-desc-length=i' => \$min_conf_desc_length,
0200     'root=s'    => \$root,
0201     'summary!'  => \$summary,
0202     'mailback!' => \$mailback,
0203     'summary-file!' => \$summary_file,
0204     'fix!'      => \$fix,
0205     'fix-inplace!'  => \$fix_inplace,
0206     'ignore-perl-version!' => \$ignore_perl_version,
0207     'debug=s'   => \%debug,
0208     'test-only=s'   => \$tst_only,
0209     'codespell!'    => \$codespell,
0210     'codespellfile=s'   => \$codespellfile,
0211     'color!'    => \$color,
0212     'h|help'    => \$help,
0213     'version'   => \$help
0214 ) or help(1);
0215 
0216 help(0) if ($help);
0217 
0218 list_types(0) if ($list_types);
0219 
0220 $fix = 1 if ($fix_inplace);
0221 $check_orig = $check;
0222 
0223 my $exit = 0;
0224 
0225 if ($^V && $^V lt $minimum_perl_version) {
0226     printf "$P: requires at least perl version %vd\n", $minimum_perl_version;
0227     if (!$ignore_perl_version) {
0228         exit(1);
0229     }
0230 }
0231 
0232 #if no filenames are given, push '-' to read patch from stdin
0233 if ($#ARGV < 0) {
0234     push(@ARGV, '-');
0235 }
0236 
0237 sub hash_save_array_words {
0238     my ($hashRef, $arrayRef) = @_;
0239 
0240     my @array = split(/,/, join(',', @$arrayRef));
0241     foreach my $word (@array) {
0242         $word =~ s/\s*\n?$//g;
0243         $word =~ s/^\s*//g;
0244         $word =~ s/\s+/ /g;
0245         $word =~ tr/[a-z]/[A-Z]/;
0246 
0247         next if ($word =~ m/^\s*#/);
0248         next if ($word =~ m/^\s*$/);
0249 
0250         $hashRef->{$word}++;
0251     }
0252 }
0253 
0254 sub hash_show_words {
0255     my ($hashRef, $prefix) = @_;
0256 
0257     if (keys %$hashRef) {
0258         print "\nNOTE: $prefix message types:";
0259         foreach my $word (sort keys %$hashRef) {
0260             print " $word";
0261         }
0262         print "\n";
0263     }
0264 }
0265 
0266 hash_save_array_words(\%ignore_type, \@ignore);
0267 hash_save_array_words(\%use_type, \@use);
0268 
0269 my $dbg_values = 0;
0270 my $dbg_possible = 0;
0271 my $dbg_type = 0;
0272 my $dbg_attr = 0;
0273 for my $key (keys %debug) {
0274     ## no critic
0275     eval "\${dbg_$key} = '$debug{$key}';";
0276     die "$@" if ($@);
0277 }
0278 
0279 my $rpt_cleaners = 0;
0280 
0281 if ($terse) {
0282     $emacs = 1;
0283     $quiet++;
0284 }
0285 
0286 if ($tree) {
0287     if (defined $root) {
0288         if (!top_of_kernel_tree($root)) {
0289             die "$P: $root: --root does not point at a valid tree\n";
0290         }
0291     } else {
0292         if (top_of_kernel_tree('.')) {
0293             $root = '.';
0294         } elsif ($0 =~ m@(.*)/scripts/[^/]*$@ &&
0295                         top_of_kernel_tree($1)) {
0296             $root = $1;
0297         }
0298     }
0299 
0300     if (!defined $root) {
0301         print "Must be run from the top-level dir. of a kernel tree\n";
0302         exit(2);
0303     }
0304 }
0305 
0306 my $emitted_corrupt = 0;
0307 
0308 our $Ident  = qr{
0309             [A-Za-z_][A-Za-z\d_]*
0310             (?:\s*\#\#\s*[A-Za-z_][A-Za-z\d_]*)*
0311         }x;
0312 our $Storage    = qr{extern|static|asmlinkage};
0313 our $Sparse = qr{
0314             __user|
0315             __kernel|
0316             __force|
0317             __iomem|
0318             __must_check|
0319             __init_refok|
0320             __kprobes|
0321             __ref|
0322             __rcu|
0323             __private
0324         }x;
0325 our $InitAttributePrefix = qr{__(?:mem|cpu|dev|net_|)};
0326 our $InitAttributeData = qr{$InitAttributePrefix(?:initdata\b)};
0327 our $InitAttributeConst = qr{$InitAttributePrefix(?:initconst\b)};
0328 our $InitAttributeInit = qr{$InitAttributePrefix(?:init\b)};
0329 our $InitAttribute = qr{$InitAttributeData|$InitAttributeConst|$InitAttributeInit};
0330 
0331 # Notes to $Attribute:
0332 # We need \b after 'init' otherwise 'initconst' will cause a false positive in a check
0333 our $Attribute  = qr{
0334             const|
0335             __percpu|
0336             __nocast|
0337             __safe|
0338             __bitwise|
0339             __packed__|
0340             __packed2__|
0341             __naked|
0342             __maybe_unused|
0343             __always_unused|
0344             __noreturn|
0345             __used|
0346             __cold|
0347             __pure|
0348             __noclone|
0349             __deprecated|
0350             __read_mostly|
0351             __kprobes|
0352             $InitAttribute|
0353             ____cacheline_aligned|
0354             ____cacheline_aligned_in_smp|
0355             ____cacheline_internodealigned_in_smp|
0356             __weak
0357           }x;
0358 our $Modifier;
0359 our $Inline = qr{inline|__always_inline|noinline|__inline|__inline__};
0360 our $Member = qr{->$Ident|\.$Ident|\[[^]]*\]};
0361 our $Lval   = qr{$Ident(?:$Member)*};
0362 
0363 our $Int_type   = qr{(?i)llu|ull|ll|lu|ul|l|u};
0364 our $Binary = qr{(?i)0b[01]+$Int_type?};
0365 our $Hex    = qr{(?i)0x[0-9a-f]+$Int_type?};
0366 our $Int    = qr{[0-9]+$Int_type?};
0367 our $Octal  = qr{0[0-7]+$Int_type?};
0368 our $String = qr{"[X\t]*"};
0369 our $Float_hex  = qr{(?i)0x[0-9a-f]+p-?[0-9]+[fl]?};
0370 our $Float_dec  = qr{(?i)(?:[0-9]+\.[0-9]*|[0-9]*\.[0-9]+)(?:e-?[0-9]+)?[fl]?};
0371 our $Float_int  = qr{(?i)[0-9]+e-?[0-9]+[fl]?};
0372 our $Float  = qr{$Float_hex|$Float_dec|$Float_int};
0373 our $Constant   = qr{$Float|$Binary|$Octal|$Hex|$Int};
0374 our $Assignment = qr{\*\=|/=|%=|\+=|-=|<<=|>>=|&=|\^=|\|=|=};
0375 our $Compare    = qr{<=|>=|==|!=|<|(?<!-)>};
0376 our $Arithmetic = qr{\+|-|\*|\/|%};
0377 our $Operators  = qr{
0378             <=|>=|==|!=|
0379             =>|->|<<|>>|<|>|!|~|
0380             &&|\|\||,|\^|\+\+|--|&|\||$Arithmetic
0381           }x;
0382 
0383 our $c90_Keywords = qr{do|for|while|if|else|return|goto|continue|switch|default|case|break}x;
0384 
0385 our $BasicType;
0386 our $NonptrType;
0387 our $NonptrTypeMisordered;
0388 our $NonptrTypeWithAttr;
0389 our $Type;
0390 our $TypeMisordered;
0391 our $Declare;
0392 our $DeclareMisordered;
0393 
0394 our $NON_ASCII_UTF8 = qr{
0395     [\xC2-\xDF][\x80-\xBF]               # non-overlong 2-byte
0396     |  \xE0[\xA0-\xBF][\x80-\xBF]        # excluding overlongs
0397     | [\xE1-\xEC\xEE\xEF][\x80-\xBF]{2}  # straight 3-byte
0398     |  \xED[\x80-\x9F][\x80-\xBF]        # excluding surrogates
0399     |  \xF0[\x90-\xBF][\x80-\xBF]{2}     # planes 1-3
0400     | [\xF1-\xF3][\x80-\xBF]{3}          # planes 4-15
0401     |  \xF4[\x80-\x8F][\x80-\xBF]{2}     # plane 16
0402 }x;
0403 
0404 our $UTF8   = qr{
0405     [\x09\x0A\x0D\x20-\x7E]              # ASCII
0406     | $NON_ASCII_UTF8
0407 }x;
0408 
0409 our $typeC99Typedefs = qr{(?:__)?(?:[us]_?)?int_?(?:8|16|32|64)_t};
0410 our $typeOtherOSTypedefs = qr{(?x:
0411     u_(?:char|short|int|long) |          # bsd
0412     u(?:nchar|short|int|long)            # sysv
0413 )};
0414 our $typeKernelTypedefs = qr{(?x:
0415     (?:__)?(?:u|s|be|le)(?:8|16|32|64)|
0416     atomic_t
0417 )};
0418 our $typeTypedefs = qr{(?x:
0419     $typeC99Typedefs\b|
0420     $typeOtherOSTypedefs\b|
0421     $typeKernelTypedefs\b
0422 )};
0423 
0424 our $zero_initializer = qr{(?:(?:0[xX])?0+$Int_type?|NULL|false)\b};
0425 
0426 our $logFunctions = qr{(?x:
0427     printk(?:_ratelimited|_once|)|
0428     (?:[a-z0-9]+_){1,2}(?:printk|emerg|alert|crit|err|warning|warn|notice|info|debug|dbg|vdbg|devel|cont|WARN)(?:_ratelimited|_once|)|
0429     WARN(?:_RATELIMIT|_ONCE|)|
0430     panic|
0431     MODULE_[A-Z_]+|
0432     seq_vprintf|seq_printf|seq_puts
0433 )};
0434 
0435 our $signature_tags = qr{(?xi:
0436     Signed-off-by:|
0437     Acked-by:|
0438     Tested-by:|
0439     Reviewed-by:|
0440     Reported-by:|
0441     Suggested-by:|
0442     To:|
0443     Cc:
0444 )};
0445 
0446 our @typeListMisordered = (
0447     qr{char\s+(?:un)?signed},
0448     qr{int\s+(?:(?:un)?signed\s+)?short\s},
0449     qr{int\s+short(?:\s+(?:un)?signed)},
0450     qr{short\s+int(?:\s+(?:un)?signed)},
0451     qr{(?:un)?signed\s+int\s+short},
0452     qr{short\s+(?:un)?signed},
0453     qr{long\s+int\s+(?:un)?signed},
0454     qr{int\s+long\s+(?:un)?signed},
0455     qr{long\s+(?:un)?signed\s+int},
0456     qr{int\s+(?:un)?signed\s+long},
0457     qr{int\s+(?:un)?signed},
0458     qr{int\s+long\s+long\s+(?:un)?signed},
0459     qr{long\s+long\s+int\s+(?:un)?signed},
0460     qr{long\s+long\s+(?:un)?signed\s+int},
0461     qr{long\s+long\s+(?:un)?signed},
0462     qr{long\s+(?:un)?signed},
0463 );
0464 
0465 our @typeList = (
0466     qr{void},
0467     qr{(?:(?:un)?signed\s+)?char},
0468     qr{(?:(?:un)?signed\s+)?short\s+int},
0469     qr{(?:(?:un)?signed\s+)?short},
0470     qr{(?:(?:un)?signed\s+)?int},
0471     qr{(?:(?:un)?signed\s+)?long\s+int},
0472     qr{(?:(?:un)?signed\s+)?long\s+long\s+int},
0473     qr{(?:(?:un)?signed\s+)?long\s+long},
0474     qr{(?:(?:un)?signed\s+)?long},
0475     qr{(?:un)?signed},
0476     qr{float},
0477     qr{double},
0478     qr{bool},
0479     qr{struct\s+$Ident},
0480     qr{union\s+$Ident},
0481     qr{enum\s+$Ident},
0482     qr{${Ident}_t},
0483     qr{${Ident}_handler},
0484     qr{${Ident}_handler_fn},
0485     @typeListMisordered,
0486 );
0487 
0488 our $C90_int_types = qr{(?x:
0489     long\s+long\s+int\s+(?:un)?signed|
0490     long\s+long\s+(?:un)?signed\s+int|
0491     long\s+long\s+(?:un)?signed|
0492     (?:(?:un)?signed\s+)?long\s+long\s+int|
0493     (?:(?:un)?signed\s+)?long\s+long|
0494     int\s+long\s+long\s+(?:un)?signed|
0495     int\s+(?:(?:un)?signed\s+)?long\s+long|
0496 
0497     long\s+int\s+(?:un)?signed|
0498     long\s+(?:un)?signed\s+int|
0499     long\s+(?:un)?signed|
0500     (?:(?:un)?signed\s+)?long\s+int|
0501     (?:(?:un)?signed\s+)?long|
0502     int\s+long\s+(?:un)?signed|
0503     int\s+(?:(?:un)?signed\s+)?long|
0504 
0505     int\s+(?:un)?signed|
0506     (?:(?:un)?signed\s+)?int
0507 )};
0508 
0509 our @typeListFile = ();
0510 our @typeListWithAttr = (
0511     @typeList,
0512     qr{struct\s+$InitAttribute\s+$Ident},
0513     qr{union\s+$InitAttribute\s+$Ident},
0514 );
0515 
0516 our @modifierList = (
0517     qr{fastcall},
0518 );
0519 our @modifierListFile = ();
0520 
0521 our @mode_permission_funcs = (
0522     ["module_param", 3],
0523     ["module_param_(?:array|named|string)", 4],
0524     ["module_param_array_named", 5],
0525     ["debugfs_create_(?:file|u8|u16|u32|u64|x8|x16|x32|x64|size_t|atomic_t|bool|blob|regset32|u32_array)", 2],
0526     ["proc_create(?:_data|)", 2],
0527     ["(?:CLASS|DEVICE|SENSOR|SENSOR_DEVICE|IIO_DEVICE)_ATTR", 2],
0528     ["IIO_DEV_ATTR_[A-Z_]+", 1],
0529     ["SENSOR_(?:DEVICE_|)ATTR_2", 2],
0530     ["SENSOR_TEMPLATE(?:_2|)", 3],
0531     ["__ATTR", 2],
0532 );
0533 
0534 #Create a search pattern for all these functions to speed up a loop below
0535 our $mode_perms_search = "";
0536 foreach my $entry (@mode_permission_funcs) {
0537     $mode_perms_search .= '|' if ($mode_perms_search ne "");
0538     $mode_perms_search .= $entry->[0];
0539 }
0540 
0541 our $mode_perms_world_writable = qr{
0542     S_IWUGO     |
0543     S_IWOTH     |
0544     S_IRWXUGO   |
0545     S_IALLUGO   |
0546     0[0-7][0-7][2367]
0547 }x;
0548 
0549 our %mode_permission_string_types = (
0550     "S_IRWXU" => 0700,
0551     "S_IRUSR" => 0400,
0552     "S_IWUSR" => 0200,
0553     "S_IXUSR" => 0100,
0554     "S_IRWXG" => 0070,
0555     "S_IRGRP" => 0040,
0556     "S_IWGRP" => 0020,
0557     "S_IXGRP" => 0010,
0558     "S_IRWXO" => 0007,
0559     "S_IROTH" => 0004,
0560     "S_IWOTH" => 0002,
0561     "S_IXOTH" => 0001,
0562     "S_IRWXUGO" => 0777,
0563     "S_IRUGO" => 0444,
0564     "S_IWUGO" => 0222,
0565     "S_IXUGO" => 0111,
0566 );
0567 
0568 #Create a search pattern for all these strings to speed up a loop below
0569 our $mode_perms_string_search = "";
0570 foreach my $entry (keys %mode_permission_string_types) {
0571     $mode_perms_string_search .= '|' if ($mode_perms_string_search ne "");
0572     $mode_perms_string_search .= $entry;
0573 }
0574 
0575 our $allowed_asm_includes = qr{(?x:
0576     irq|
0577     memory|
0578     time|
0579     reboot
0580 )};
0581 # memory.h: ARM has a custom one
0582 
0583 # Load common spelling mistakes and build regular expression list.
0584 my $misspellings;
0585 my %spelling_fix;
0586 
0587 if (open(my $spelling, '<', $spelling_file)) {
0588     while (<$spelling>) {
0589         my $line = $_;
0590 
0591         $line =~ s/\s*\n?$//g;
0592         $line =~ s/^\s*//g;
0593 
0594         next if ($line =~ m/^\s*#/);
0595         next if ($line =~ m/^\s*$/);
0596 
0597         my ($suspect, $fix) = split(/\|\|/, $line);
0598 
0599         $spelling_fix{$suspect} = $fix;
0600     }
0601     close($spelling);
0602 } else {
0603     warn "No typos will be found - file '$spelling_file': $!\n";
0604 }
0605 
0606 if ($codespell) {
0607     if (open(my $spelling, '<', $codespellfile)) {
0608         while (<$spelling>) {
0609             my $line = $_;
0610 
0611             $line =~ s/\s*\n?$//g;
0612             $line =~ s/^\s*//g;
0613 
0614             next if ($line =~ m/^\s*#/);
0615             next if ($line =~ m/^\s*$/);
0616             next if ($line =~ m/, disabled/i);
0617 
0618             $line =~ s/,.*$//;
0619 
0620             my ($suspect, $fix) = split(/->/, $line);
0621 
0622             $spelling_fix{$suspect} = $fix;
0623         }
0624         close($spelling);
0625     } else {
0626         warn "No codespell typos will be found - file '$codespellfile': $!\n";
0627     }
0628 }
0629 
0630 $misspellings = join("|", sort keys %spelling_fix) if keys %spelling_fix;
0631 
0632 my $const_structs = "";
0633 if (open(my $conststructs, '<', $conststructsfile)) {
0634     while (<$conststructs>) {
0635         my $line = $_;
0636 
0637         $line =~ s/\s*\n?$//g;
0638         $line =~ s/^\s*//g;
0639 
0640         next if ($line =~ m/^\s*#/);
0641         next if ($line =~ m/^\s*$/);
0642         if ($line =~ /\s/) {
0643             print("$conststructsfile: '$line' invalid - ignored\n");
0644             next;
0645         }
0646 
0647         $const_structs .= '|' if ($const_structs ne "");
0648         $const_structs .= $line;
0649     }
0650     close($conststructsfile);
0651 } else {
0652     warn "No structs that should be const will be found - file '$conststructsfile': $!\n";
0653 }
0654 
0655 sub build_types {
0656     my $mods = "(?x:  \n" . join("|\n  ", (@modifierList, @modifierListFile)) . "\n)";
0657     my $all = "(?x:  \n" . join("|\n  ", (@typeList, @typeListFile)) . "\n)";
0658     my $Misordered = "(?x:  \n" . join("|\n  ", @typeListMisordered) . "\n)";
0659     my $allWithAttr = "(?x:  \n" . join("|\n  ", @typeListWithAttr) . "\n)";
0660     $Modifier   = qr{(?:$Attribute|$Sparse|$mods)};
0661     $BasicType  = qr{
0662                 (?:$typeTypedefs\b)|
0663                 (?:${all}\b)
0664         }x;
0665     $NonptrType = qr{
0666             (?:$Modifier\s+|const\s+)*
0667             (?:
0668                 (?:typeof|__typeof__)\s*\([^\)]*\)|
0669                 (?:$typeTypedefs\b)|
0670                 (?:${all}\b)
0671             )
0672             (?:\s+$Modifier|\s+const)*
0673           }x;
0674     $NonptrTypeMisordered   = qr{
0675             (?:$Modifier\s+|const\s+)*
0676             (?:
0677                 (?:${Misordered}\b)
0678             )
0679             (?:\s+$Modifier|\s+const)*
0680           }x;
0681     $NonptrTypeWithAttr = qr{
0682             (?:$Modifier\s+|const\s+)*
0683             (?:
0684                 (?:typeof|__typeof__)\s*\([^\)]*\)|
0685                 (?:$typeTypedefs\b)|
0686                 (?:${allWithAttr}\b)
0687             )
0688             (?:\s+$Modifier|\s+const)*
0689           }x;
0690     $Type   = qr{
0691             $NonptrType
0692             (?:(?:\s|\*|\[\])+\s*const|(?:\s|\*\s*(?:const\s*)?|\[\])+|(?:\s*\[\s*\])+)?
0693             (?:\s+$Inline|\s+$Modifier)*
0694           }x;
0695     $TypeMisordered = qr{
0696             $NonptrTypeMisordered
0697             (?:(?:\s|\*|\[\])+\s*const|(?:\s|\*\s*(?:const\s*)?|\[\])+|(?:\s*\[\s*\])+)?
0698             (?:\s+$Inline|\s+$Modifier)*
0699           }x;
0700     $Declare    = qr{(?:$Storage\s+(?:$Inline\s+)?)?$Type};
0701     $DeclareMisordered  = qr{(?:$Storage\s+(?:$Inline\s+)?)?$TypeMisordered};
0702 }
0703 build_types();
0704 
0705 our $Typecast   = qr{\s*(\(\s*$NonptrType\s*\)){0,1}\s*};
0706 
0707 # Using $balanced_parens, $LvalOrFunc, or $FuncArg
0708 # requires at least perl version v5.10.0
0709 # Any use must be runtime checked with $^V
0710 
0711 our $balanced_parens = qr/(\((?:[^\(\)]++|(?-1))*\))/;
0712 our $LvalOrFunc = qr{((?:[\&\*]\s*)?$Lval)\s*($balanced_parens{0,1})\s*};
0713 our $FuncArg = qr{$Typecast{0,1}($LvalOrFunc|$Constant|$String)};
0714 
0715 our $declaration_macros = qr{(?x:
0716     (?:$Storage\s+)?(?:[A-Z_][A-Z0-9]*_){0,2}(?:DEFINE|DECLARE)(?:_[A-Z0-9]+){1,6}\s*\(|
0717     (?:$Storage\s+)?LIST_HEAD\s*\(|
0718     (?:$Storage\s+)?${Type}\s+uninitialized_var\s*\(
0719 )};
0720 
0721 sub deparenthesize {
0722     my ($string) = @_;
0723     return "" if (!defined($string));
0724 
0725     while ($string =~ /^\s*\(.*\)\s*$/) {
0726         $string =~ s@^\s*\(\s*@@;
0727         $string =~ s@\s*\)\s*$@@;
0728     }
0729 
0730     $string =~ s@\s+@ @g;
0731 
0732     return $string;
0733 }
0734 
0735 sub seed_camelcase_file {
0736     my ($file) = @_;
0737 
0738     return if (!(-f $file));
0739 
0740     local $/;
0741 
0742     open(my $include_file, '<', "$file")
0743         or warn "$P: Can't read '$file' $!\n";
0744     my $text = <$include_file>;
0745     close($include_file);
0746 
0747     my @lines = split('\n', $text);
0748 
0749     foreach my $line (@lines) {
0750         next if ($line !~ /(?:[A-Z][a-z]|[a-z][A-Z])/);
0751         if ($line =~ /^[ \t]*(?:#[ \t]*define|typedef\s+$Type)\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)/) {
0752             $camelcase{$1} = 1;
0753         } elsif ($line =~ /^\s*$Declare\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)\s*[\(\[,;]/) {
0754             $camelcase{$1} = 1;
0755         } elsif ($line =~ /^\s*(?:union|struct|enum)\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)\s*[;\{]/) {
0756             $camelcase{$1} = 1;
0757         }
0758     }
0759 }
0760 
0761 sub is_maintained_obsolete {
0762     my ($filename) = @_;
0763 
0764     return 0 if (!$tree || !(-e "$root/scripts/get_maintainer.pl"));
0765 
0766     my $status = `perl $root/scripts/get_maintainer.pl --status --nom --nol --nogit --nogit-fallback -f $filename 2>&1`;
0767 
0768     return $status =~ /obsolete/i;
0769 }
0770 
0771 my $camelcase_seeded = 0;
0772 sub seed_camelcase_includes {
0773     return if ($camelcase_seeded);
0774 
0775     my $files;
0776     my $camelcase_cache = "";
0777     my @include_files = ();
0778 
0779     $camelcase_seeded = 1;
0780 
0781     if (-e ".git") {
0782         my $git_last_include_commit = `git log --no-merges --pretty=format:"%h%n" -1 -- include`;
0783         chomp $git_last_include_commit;
0784         $camelcase_cache = ".checkpatch-camelcase.git.$git_last_include_commit";
0785     } else {
0786         my $last_mod_date = 0;
0787         $files = `find $root/include -name "*.h"`;
0788         @include_files = split('\n', $files);
0789         foreach my $file (@include_files) {
0790             my $date = POSIX::strftime("%Y%m%d%H%M",
0791                            localtime((stat $file)[9]));
0792             $last_mod_date = $date if ($last_mod_date < $date);
0793         }
0794         $camelcase_cache = ".checkpatch-camelcase.date.$last_mod_date";
0795     }
0796 
0797     if ($camelcase_cache ne "" && -f $camelcase_cache) {
0798         open(my $camelcase_file, '<', "$camelcase_cache")
0799             or warn "$P: Can't read '$camelcase_cache' $!\n";
0800         while (<$camelcase_file>) {
0801             chomp;
0802             $camelcase{$_} = 1;
0803         }
0804         close($camelcase_file);
0805 
0806         return;
0807     }
0808 
0809     if (-e ".git") {
0810         $files = `git ls-files "include/*.h"`;
0811         @include_files = split('\n', $files);
0812     }
0813 
0814     foreach my $file (@include_files) {
0815         seed_camelcase_file($file);
0816     }
0817 
0818     if ($camelcase_cache ne "") {
0819         unlink glob ".checkpatch-camelcase.*";
0820         open(my $camelcase_file, '>', "$camelcase_cache")
0821             or warn "$P: Can't write '$camelcase_cache' $!\n";
0822         foreach (sort { lc($a) cmp lc($b) } keys(%camelcase)) {
0823             print $camelcase_file ("$_\n");
0824         }
0825         close($camelcase_file);
0826     }
0827 }
0828 
0829 sub git_commit_info {
0830     my ($commit, $id, $desc) = @_;
0831 
0832     return ($id, $desc) if ((which("git") eq "") || !(-e ".git"));
0833 
0834     my $output = `git log --no-color --format='%H %s' -1 $commit 2>&1`;
0835     $output =~ s/^\s*//gm;
0836     my @lines = split("\n", $output);
0837 
0838     return ($id, $desc) if ($#lines < 0);
0839 
0840     if ($lines[0] =~ /^error: short SHA1 $commit is ambiguous\./) {
0841 # Maybe one day convert this block of bash into something that returns
0842 # all matching commit ids, but it's very slow...
0843 #
0844 #       echo "checking commits $1..."
0845 #       git rev-list --remotes | grep -i "^$1" |
0846 #       while read line ; do
0847 #           git log --format='%H %s' -1 $line |
0848 #           echo "commit $(cut -c 1-12,41-)"
0849 #       done
0850     } elsif ($lines[0] =~ /^fatal: ambiguous argument '$commit': unknown revision or path not in the working tree\./) {
0851     } else {
0852         $id = substr($lines[0], 0, 12);
0853         $desc = substr($lines[0], 41);
0854     }
0855 
0856     return ($id, $desc);
0857 }
0858 
0859 $chk_signoff = 0 if ($file);
0860 
0861 my @rawlines = ();
0862 my @lines = ();
0863 my @fixed = ();
0864 my @fixed_inserted = ();
0865 my @fixed_deleted = ();
0866 my $fixlinenr = -1;
0867 
0868 # If input is git commits, extract all commits from the commit expressions.
0869 # For example, HEAD-3 means we need check 'HEAD, HEAD~1, HEAD~2'.
0870 die "$P: No git repository found\n" if ($git && !-e ".git");
0871 
0872 if ($git) {
0873     my @commits = ();
0874     foreach my $commit_expr (@ARGV) {
0875         my $git_range;
0876         if ($commit_expr =~ m/^(.*)-(\d+)$/) {
0877             $git_range = "-$2 $1";
0878         } elsif ($commit_expr =~ m/\.\./) {
0879             $git_range = "$commit_expr";
0880         } else {
0881             $git_range = "-1 $commit_expr";
0882         }
0883         my $lines = `git log --no-color --no-merges --pretty=format:'%H %s' $git_range`;
0884         foreach my $line (split(/\n/, $lines)) {
0885             $line =~ /^([0-9a-fA-F]{40,40}) (.*)$/;
0886             next if (!defined($1) || !defined($2));
0887             my $sha1 = $1;
0888             my $subject = $2;
0889             unshift(@commits, $sha1);
0890             $git_commits{$sha1} = $subject;
0891         }
0892     }
0893     die "$P: no git commits after extraction!\n" if (@commits == 0);
0894     @ARGV = @commits;
0895 }
0896 
0897 my $vname;
0898 for my $filename (@ARGV) {
0899     my $FILE;
0900     if ($git) {
0901         open($FILE, '-|', "git format-patch -M --stdout -1 $filename") ||
0902             die "$P: $filename: git format-patch failed - $!\n";
0903     } elsif ($file) {
0904         open($FILE, '-|', "diff -u /dev/null $filename") ||
0905             die "$P: $filename: diff failed - $!\n";
0906     } elsif ($filename eq '-') {
0907         open($FILE, '<&STDIN');
0908     } else {
0909         open($FILE, '<', "$filename") ||
0910             die "$P: $filename: open failed - $!\n";
0911     }
0912     if ($filename eq '-') {
0913         $vname = 'Your patch';
0914     } elsif ($git) {
0915         $vname = "Commit " . substr($filename, 0, 12) . ' ("' . $git_commits{$filename} . '")';
0916     } else {
0917         $vname = $filename;
0918     }
0919     while (<$FILE>) {
0920         chomp;
0921         push(@rawlines, $_);
0922     }
0923     close($FILE);
0924 
0925     if ($#ARGV > 0 && $quiet == 0) {
0926         print '-' x length($vname) . "\n";
0927         print "$vname\n";
0928         print '-' x length($vname) . "\n";
0929     }
0930 
0931     if (!process($filename)) {
0932         $exit = 1;
0933     }
0934     @rawlines = ();
0935     @lines = ();
0936     @fixed = ();
0937     @fixed_inserted = ();
0938     @fixed_deleted = ();
0939     $fixlinenr = -1;
0940     @modifierListFile = ();
0941     @typeListFile = ();
0942     build_types();
0943 }
0944 
0945 if (!$quiet) {
0946     hash_show_words(\%use_type, "Used");
0947     hash_show_words(\%ignore_type, "Ignored");
0948 
0949     if ($^V lt 5.10.0) {
0950         print << "EOM"
0951 
0952 NOTE: perl $^V is not modern enough to detect all possible issues.
0953       An upgrade to at least perl v5.10.0 is suggested.
0954 EOM
0955     }
0956     if ($exit) {
0957         print << "EOM"
0958 
0959 NOTE: If any of the errors are false positives, please report
0960       them to the maintainer, see CHECKPATCH in MAINTAINERS.
0961 EOM
0962     }
0963 }
0964 
0965 exit($exit);
0966 
0967 sub top_of_kernel_tree {
0968     my ($root) = @_;
0969 
0970     my @tree_check = (
0971         "COPYING", "CREDITS", "Kbuild", "MAINTAINERS", "Makefile",
0972         "README", "Documentation", "arch", "include", "drivers",
0973         "fs", "init", "ipc", "kernel", "lib", "scripts",
0974     );
0975 
0976     foreach my $check (@tree_check) {
0977         if (! -e $root . '/' . $check) {
0978             return 0;
0979         }
0980     }
0981     return 1;
0982 }
0983 
0984 sub parse_email {
0985     my ($formatted_email) = @_;
0986 
0987     my $name = "";
0988     my $address = "";
0989     my $comment = "";
0990 
0991     if ($formatted_email =~ /^(.*)<(\S+\@\S+)>(.*)$/) {
0992         $name = $1;
0993         $address = $2;
0994         $comment = $3 if defined $3;
0995     } elsif ($formatted_email =~ /^\s*<(\S+\@\S+)>(.*)$/) {
0996         $address = $1;
0997         $comment = $2 if defined $2;
0998     } elsif ($formatted_email =~ /(\S+\@\S+)(.*)$/) {
0999         $address = $1;
1000         $comment = $2 if defined $2;
1001         $formatted_email =~ s/$address.*$//;
1002         $name = $formatted_email;
1003         $name = trim($name);
1004         $name =~ s/^\"|\"$//g;
1005         # If there's a name left after stripping spaces and
1006         # leading quotes, and the address doesn't have both
1007         # leading and trailing angle brackets, the address
1008         # is invalid. ie:
1009         #   "joe smith joe@smith.com" bad
1010         #   "joe smith <joe@smith.com" bad
1011         if ($name ne "" && $address !~ /^<[^>]+>$/) {
1012             $name = "";
1013             $address = "";
1014             $comment = "";
1015         }
1016     }
1017 
1018     $name = trim($name);
1019     $name =~ s/^\"|\"$//g;
1020     $address = trim($address);
1021     $address =~ s/^\<|\>$//g;
1022 
1023     if ($name =~ /[^\w \-]/i) { ##has "must quote" chars
1024         $name =~ s/(?<!\\)"/\\"/g; ##escape quotes
1025         $name = "\"$name\"";
1026     }
1027 
1028     return ($name, $address, $comment);
1029 }
1030 
1031 sub format_email {
1032     my ($name, $address) = @_;
1033 
1034     my $formatted_email;
1035 
1036     $name = trim($name);
1037     $name =~ s/^\"|\"$//g;
1038     $address = trim($address);
1039 
1040     if ($name =~ /[^\w \-]/i) { ##has "must quote" chars
1041         $name =~ s/(?<!\\)"/\\"/g; ##escape quotes
1042         $name = "\"$name\"";
1043     }
1044 
1045     if ("$name" eq "") {
1046         $formatted_email = "$address";
1047     } else {
1048         $formatted_email = "$name <$address>";
1049     }
1050 
1051     return $formatted_email;
1052 }
1053 
1054 sub which {
1055     my ($bin) = @_;
1056 
1057     foreach my $path (split(/:/, $ENV{PATH})) {
1058         if (-e "$path/$bin") {
1059             return "$path/$bin";
1060         }
1061     }
1062 
1063     return "";
1064 }
1065 
1066 sub which_conf {
1067     my ($conf) = @_;
1068 
1069     foreach my $path (split(/:/, ".:$ENV{HOME}:.scripts")) {
1070         if (-e "$path/$conf") {
1071             return "$path/$conf";
1072         }
1073     }
1074 
1075     return "";
1076 }
1077 
1078 sub expand_tabs {
1079     my ($str) = @_;
1080 
1081     my $res = '';
1082     my $n = 0;
1083     for my $c (split(//, $str)) {
1084         if ($c eq "\t") {
1085             $res .= ' ';
1086             $n++;
1087             for (; ($n % 8) != 0; $n++) {
1088                 $res .= ' ';
1089             }
1090             next;
1091         }
1092         $res .= $c;
1093         $n++;
1094     }
1095 
1096     return $res;
1097 }
1098 sub copy_spacing {
1099     (my $res = shift) =~ tr/\t/ /c;
1100     return $res;
1101 }
1102 
1103 sub line_stats {
1104     my ($line) = @_;
1105 
1106     # Drop the diff line leader and expand tabs
1107     $line =~ s/^.//;
1108     $line = expand_tabs($line);
1109 
1110     # Pick the indent from the front of the line.
1111     my ($white) = ($line =~ /^(\s*)/);
1112 
1113     return (length($line), length($white));
1114 }
1115 
1116 my $sanitise_quote = '';
1117 
1118 sub sanitise_line_reset {
1119     my ($in_comment) = @_;
1120 
1121     if ($in_comment) {
1122         $sanitise_quote = '*/';
1123     } else {
1124         $sanitise_quote = '';
1125     }
1126 }
1127 sub sanitise_line {
1128     my ($line) = @_;
1129 
1130     my $res = '';
1131     my $l = '';
1132 
1133     my $qlen = 0;
1134     my $off = 0;
1135     my $c;
1136 
1137     # Always copy over the diff marker.
1138     $res = substr($line, 0, 1);
1139 
1140     for ($off = 1; $off < length($line); $off++) {
1141         $c = substr($line, $off, 1);
1142 
1143         # Comments we are wacking completly including the begin
1144         # and end, all to $;.
1145         if ($sanitise_quote eq '' && substr($line, $off, 2) eq '/*') {
1146             $sanitise_quote = '*/';
1147 
1148             substr($res, $off, 2, "$;$;");
1149             $off++;
1150             next;
1151         }
1152         if ($sanitise_quote eq '*/' && substr($line, $off, 2) eq '*/') {
1153             $sanitise_quote = '';
1154             substr($res, $off, 2, "$;$;");
1155             $off++;
1156             next;
1157         }
1158         if ($sanitise_quote eq '' && substr($line, $off, 2) eq '//') {
1159             $sanitise_quote = '//';
1160 
1161             substr($res, $off, 2, $sanitise_quote);
1162             $off++;
1163             next;
1164         }
1165 
1166         # A \ in a string means ignore the next character.
1167         if (($sanitise_quote eq "'" || $sanitise_quote eq '"') &&
1168             $c eq "\\") {
1169             substr($res, $off, 2, 'XX');
1170             $off++;
1171             next;
1172         }
1173         # Regular quotes.
1174         if ($c eq "'" || $c eq '"') {
1175             if ($sanitise_quote eq '') {
1176                 $sanitise_quote = $c;
1177 
1178                 substr($res, $off, 1, $c);
1179                 next;
1180             } elsif ($sanitise_quote eq $c) {
1181                 $sanitise_quote = '';
1182             }
1183         }
1184 
1185         #print "c<$c> SQ<$sanitise_quote>\n";
1186         if ($off != 0 && $sanitise_quote eq '*/' && $c ne "\t") {
1187             substr($res, $off, 1, $;);
1188         } elsif ($off != 0 && $sanitise_quote eq '//' && $c ne "\t") {
1189             substr($res, $off, 1, $;);
1190         } elsif ($off != 0 && $sanitise_quote && $c ne "\t") {
1191             substr($res, $off, 1, 'X');
1192         } else {
1193             substr($res, $off, 1, $c);
1194         }
1195     }
1196 
1197     if ($sanitise_quote eq '//') {
1198         $sanitise_quote = '';
1199     }
1200 
1201     # The pathname on a #include may be surrounded by '<' and '>'.
1202     if ($res =~ /^.\s*\#\s*include\s+\<(.*)\>/) {
1203         my $clean = 'X' x length($1);
1204         $res =~ s@\<.*\>@<$clean>@;
1205 
1206     # The whole of a #error is a string.
1207     } elsif ($res =~ /^.\s*\#\s*(?:error|warning)\s+(.*)\b/) {
1208         my $clean = 'X' x length($1);
1209         $res =~ s@(\#\s*(?:error|warning)\s+).*@$1$clean@;
1210     }
1211 
1212     if ($allow_c99_comments && $res =~ m@(//.*$)@) {
1213         my $match = $1;
1214         $res =~ s/\Q$match\E/"$;" x length($match)/e;
1215     }
1216 
1217     return $res;
1218 }
1219 
1220 sub get_quoted_string {
1221     my ($line, $rawline) = @_;
1222 
1223     return "" if ($line !~ m/($String)/g);
1224     return substr($rawline, $-[0], $+[0] - $-[0]);
1225 }
1226 
1227 sub ctx_statement_block {
1228     my ($linenr, $remain, $off) = @_;
1229     my $line = $linenr - 1;
1230     my $blk = '';
1231     my $soff = $off;
1232     my $coff = $off - 1;
1233     my $coff_set = 0;
1234 
1235     my $loff = 0;
1236 
1237     my $type = '';
1238     my $level = 0;
1239     my @stack = ();
1240     my $p;
1241     my $c;
1242     my $len = 0;
1243 
1244     my $remainder;
1245     while (1) {
1246         @stack = (['', 0]) if ($#stack == -1);
1247 
1248         #warn "CSB: blk<$blk> remain<$remain>\n";
1249         # If we are about to drop off the end, pull in more
1250         # context.
1251         if ($off >= $len) {
1252             for (; $remain > 0; $line++) {
1253                 last if (!defined $lines[$line]);
1254                 next if ($lines[$line] =~ /^-/);
1255                 $remain--;
1256                 $loff = $len;
1257                 $blk .= $lines[$line] . "\n";
1258                 $len = length($blk);
1259                 $line++;
1260                 last;
1261             }
1262             # Bail if there is no further context.
1263             #warn "CSB: blk<$blk> off<$off> len<$len>\n";
1264             if ($off >= $len) {
1265                 last;
1266             }
1267             if ($level == 0 && substr($blk, $off) =~ /^.\s*#\s*define/) {
1268                 $level++;
1269                 $type = '#';
1270             }
1271         }
1272         $p = $c;
1273         $c = substr($blk, $off, 1);
1274         $remainder = substr($blk, $off);
1275 
1276         #warn "CSB: c<$c> type<$type> level<$level> remainder<$remainder> coff_set<$coff_set>\n";
1277 
1278         # Handle nested #if/#else.
1279         if ($remainder =~ /^#\s*(?:ifndef|ifdef|if)\s/) {
1280             push(@stack, [ $type, $level ]);
1281         } elsif ($remainder =~ /^#\s*(?:else|elif)\b/) {
1282             ($type, $level) = @{$stack[$#stack - 1]};
1283         } elsif ($remainder =~ /^#\s*endif\b/) {
1284             ($type, $level) = @{pop(@stack)};
1285         }
1286 
1287         # Statement ends at the ';' or a close '}' at the
1288         # outermost level.
1289         if ($level == 0 && $c eq ';') {
1290             last;
1291         }
1292 
1293         # An else is really a conditional as long as its not else if
1294         if ($level == 0 && $coff_set == 0 &&
1295                 (!defined($p) || $p =~ /(?:\s|\}|\+)/) &&
1296                 $remainder =~ /^(else)(?:\s|{)/ &&
1297                 $remainder !~ /^else\s+if\b/) {
1298             $coff = $off + length($1) - 1;
1299             $coff_set = 1;
1300             #warn "CSB: mark coff<$coff> soff<$soff> 1<$1>\n";
1301             #warn "[" . substr($blk, $soff, $coff - $soff + 1) . "]\n";
1302         }
1303 
1304         if (($type eq '' || $type eq '(') && $c eq '(') {
1305             $level++;
1306             $type = '(';
1307         }
1308         if ($type eq '(' && $c eq ')') {
1309             $level--;
1310             $type = ($level != 0)? '(' : '';
1311 
1312             if ($level == 0 && $coff < $soff) {
1313                 $coff = $off;
1314                 $coff_set = 1;
1315                 #warn "CSB: mark coff<$coff>\n";
1316             }
1317         }
1318         if (($type eq '' || $type eq '{') && $c eq '{') {
1319             $level++;
1320             $type = '{';
1321         }
1322         if ($type eq '{' && $c eq '}') {
1323             $level--;
1324             $type = ($level != 0)? '{' : '';
1325 
1326             if ($level == 0) {
1327                 if (substr($blk, $off + 1, 1) eq ';') {
1328                     $off++;
1329                 }
1330                 last;
1331             }
1332         }
1333         # Preprocessor commands end at the newline unless escaped.
1334         if ($type eq '#' && $c eq "\n" && $p ne "\\") {
1335             $level--;
1336             $type = '';
1337             $off++;
1338             last;
1339         }
1340         $off++;
1341     }
1342     # We are truly at the end, so shuffle to the next line.
1343     if ($off == $len) {
1344         $loff = $len + 1;
1345         $line++;
1346         $remain--;
1347     }
1348 
1349     my $statement = substr($blk, $soff, $off - $soff + 1);
1350     my $condition = substr($blk, $soff, $coff - $soff + 1);
1351 
1352     #warn "STATEMENT<$statement>\n";
1353     #warn "CONDITION<$condition>\n";
1354 
1355     #print "coff<$coff> soff<$off> loff<$loff>\n";
1356 
1357     return ($statement, $condition,
1358             $line, $remain + 1, $off - $loff + 1, $level);
1359 }
1360 
1361 sub statement_lines {
1362     my ($stmt) = @_;
1363 
1364     # Strip the diff line prefixes and rip blank lines at start and end.
1365     $stmt =~ s/(^|\n)./$1/g;
1366     $stmt =~ s/^\s*//;
1367     $stmt =~ s/\s*$//;
1368 
1369     my @stmt_lines = ($stmt =~ /\n/g);
1370 
1371     return $#stmt_lines + 2;
1372 }
1373 
1374 sub statement_rawlines {
1375     my ($stmt) = @_;
1376 
1377     my @stmt_lines = ($stmt =~ /\n/g);
1378 
1379     return $#stmt_lines + 2;
1380 }
1381 
1382 sub statement_block_size {
1383     my ($stmt) = @_;
1384 
1385     $stmt =~ s/(^|\n)./$1/g;
1386     $stmt =~ s/^\s*{//;
1387     $stmt =~ s/}\s*$//;
1388     $stmt =~ s/^\s*//;
1389     $stmt =~ s/\s*$//;
1390 
1391     my @stmt_lines = ($stmt =~ /\n/g);
1392     my @stmt_statements = ($stmt =~ /;/g);
1393 
1394     my $stmt_lines = $#stmt_lines + 2;
1395     my $stmt_statements = $#stmt_statements + 1;
1396 
1397     if ($stmt_lines > $stmt_statements) {
1398         return $stmt_lines;
1399     } else {
1400         return $stmt_statements;
1401     }
1402 }
1403 
1404 sub ctx_statement_full {
1405     my ($linenr, $remain, $off) = @_;
1406     my ($statement, $condition, $level);
1407 
1408     my (@chunks);
1409 
1410     # Grab the first conditional/block pair.
1411     ($statement, $condition, $linenr, $remain, $off, $level) =
1412                 ctx_statement_block($linenr, $remain, $off);
1413     #print "F: c<$condition> s<$statement> remain<$remain>\n";
1414     push(@chunks, [ $condition, $statement ]);
1415     if (!($remain > 0 && $condition =~ /^\s*(?:\n[+-])?\s*(?:if|else|do)\b/s)) {
1416         return ($level, $linenr, @chunks);
1417     }
1418 
1419     # Pull in the following conditional/block pairs and see if they
1420     # could continue the statement.
1421     for (;;) {
1422         ($statement, $condition, $linenr, $remain, $off, $level) =
1423                 ctx_statement_block($linenr, $remain, $off);
1424         #print "C: c<$condition> s<$statement> remain<$remain>\n";
1425         last if (!($remain > 0 && $condition =~ /^(?:\s*\n[+-])*\s*(?:else|do)\b/s));
1426         #print "C: push\n";
1427         push(@chunks, [ $condition, $statement ]);
1428     }
1429 
1430     return ($level, $linenr, @chunks);
1431 }
1432 
1433 sub ctx_block_get {
1434     my ($linenr, $remain, $outer, $open, $close, $off) = @_;
1435     my $line;
1436     my $start = $linenr - 1;
1437     my $blk = '';
1438     my @o;
1439     my @c;
1440     my @res = ();
1441 
1442     my $level = 0;
1443     my @stack = ($level);
1444     for ($line = $start; $remain > 0; $line++) {
1445         next if ($rawlines[$line] =~ /^-/);
1446         $remain--;
1447 
1448         $blk .= $rawlines[$line];
1449 
1450         # Handle nested #if/#else.
1451         if ($lines[$line] =~ /^.\s*#\s*(?:ifndef|ifdef|if)\s/) {
1452             push(@stack, $level);
1453         } elsif ($lines[$line] =~ /^.\s*#\s*(?:else|elif)\b/) {
1454             $level = $stack[$#stack - 1];
1455         } elsif ($lines[$line] =~ /^.\s*#\s*endif\b/) {
1456             $level = pop(@stack);
1457         }
1458 
1459         foreach my $c (split(//, $lines[$line])) {
1460             ##print "C<$c>L<$level><$open$close>O<$off>\n";
1461             if ($off > 0) {
1462                 $off--;
1463                 next;
1464             }
1465 
1466             if ($c eq $close && $level > 0) {
1467                 $level--;
1468                 last if ($level == 0);
1469             } elsif ($c eq $open) {
1470                 $level++;
1471             }
1472         }
1473 
1474         if (!$outer || $level <= 1) {
1475             push(@res, $rawlines[$line]);
1476         }
1477 
1478         last if ($level == 0);
1479     }
1480 
1481     return ($level, @res);
1482 }
1483 sub ctx_block_outer {
1484     my ($linenr, $remain) = @_;
1485 
1486     my ($level, @r) = ctx_block_get($linenr, $remain, 1, '{', '}', 0);
1487     return @r;
1488 }
1489 sub ctx_block {
1490     my ($linenr, $remain) = @_;
1491 
1492     my ($level, @r) = ctx_block_get($linenr, $remain, 0, '{', '}', 0);
1493     return @r;
1494 }
1495 sub ctx_statement {
1496     my ($linenr, $remain, $off) = @_;
1497 
1498     my ($level, @r) = ctx_block_get($linenr, $remain, 0, '(', ')', $off);
1499     return @r;
1500 }
1501 sub ctx_block_level {
1502     my ($linenr, $remain) = @_;
1503 
1504     return ctx_block_get($linenr, $remain, 0, '{', '}', 0);
1505 }
1506 sub ctx_statement_level {
1507     my ($linenr, $remain, $off) = @_;
1508 
1509     return ctx_block_get($linenr, $remain, 0, '(', ')', $off);
1510 }
1511 
1512 sub ctx_locate_comment {
1513     my ($first_line, $end_line) = @_;
1514 
1515     # Catch a comment on the end of the line itself.
1516     my ($current_comment) = ($rawlines[$end_line - 1] =~ m@.*(/\*.*\*/)\s*(?:\\\s*)?$@);
1517     return $current_comment if (defined $current_comment);
1518 
1519     # Look through the context and try and figure out if there is a
1520     # comment.
1521     my $in_comment = 0;
1522     $current_comment = '';
1523     for (my $linenr = $first_line; $linenr < $end_line; $linenr++) {
1524         my $line = $rawlines[$linenr - 1];
1525         #warn "           $line\n";
1526         if ($linenr == $first_line and $line =~ m@^.\s*\*@) {
1527             $in_comment = 1;
1528         }
1529         if ($line =~ m@/\*@) {
1530             $in_comment = 1;
1531         }
1532         if (!$in_comment && $current_comment ne '') {
1533             $current_comment = '';
1534         }
1535         $current_comment .= $line . "\n" if ($in_comment);
1536         if ($line =~ m@\*/@) {
1537             $in_comment = 0;
1538         }
1539     }
1540 
1541     chomp($current_comment);
1542     return($current_comment);
1543 }
1544 sub ctx_has_comment {
1545     my ($first_line, $end_line) = @_;
1546     my $cmt = ctx_locate_comment($first_line, $end_line);
1547 
1548     ##print "LINE: $rawlines[$end_line - 1 ]\n";
1549     ##print "CMMT: $cmt\n";
1550 
1551     return ($cmt ne '');
1552 }
1553 
1554 sub raw_line {
1555     my ($linenr, $cnt) = @_;
1556 
1557     my $offset = $linenr - 1;
1558     $cnt++;
1559 
1560     my $line;
1561     while ($cnt) {
1562         $line = $rawlines[$offset++];
1563         next if (defined($line) && $line =~ /^-/);
1564         $cnt--;
1565     }
1566 
1567     return $line;
1568 }
1569 
1570 sub cat_vet {
1571     my ($vet) = @_;
1572     my ($res, $coded);
1573 
1574     $res = '';
1575     while ($vet =~ /([^[:cntrl:]]*)([[:cntrl:]]|$)/g) {
1576         $res .= $1;
1577         if ($2 ne '') {
1578             $coded = sprintf("^%c", unpack('C', $2) + 64);
1579             $res .= $coded;
1580         }
1581     }
1582     $res =~ s/$/\$/;
1583 
1584     return $res;
1585 }
1586 
1587 my $av_preprocessor = 0;
1588 my $av_pending;
1589 my @av_paren_type;
1590 my $av_pend_colon;
1591 
1592 sub annotate_reset {
1593     $av_preprocessor = 0;
1594     $av_pending = '_';
1595     @av_paren_type = ('E');
1596     $av_pend_colon = 'O';
1597 }
1598 
1599 sub annotate_values {
1600     my ($stream, $type) = @_;
1601 
1602     my $res;
1603     my $var = '_' x length($stream);
1604     my $cur = $stream;
1605 
1606     print "$stream\n" if ($dbg_values > 1);
1607 
1608     while (length($cur)) {
1609         @av_paren_type = ('E') if ($#av_paren_type < 0);
1610         print " <" . join('', @av_paren_type) .
1611                 "> <$type> <$av_pending>" if ($dbg_values > 1);
1612         if ($cur =~ /^(\s+)/o) {
1613             print "WS($1)\n" if ($dbg_values > 1);
1614             if ($1 =~ /\n/ && $av_preprocessor) {
1615                 $type = pop(@av_paren_type);
1616                 $av_preprocessor = 0;
1617             }
1618 
1619         } elsif ($cur =~ /^(\(\s*$Type\s*)\)/ && $av_pending eq '_') {
1620             print "CAST($1)\n" if ($dbg_values > 1);
1621             push(@av_paren_type, $type);
1622             $type = 'c';
1623 
1624         } elsif ($cur =~ /^($Type)\s*(?:$Ident|,|\)|\(|\s*$)/) {
1625             print "DECLARE($1)\n" if ($dbg_values > 1);
1626             $type = 'T';
1627 
1628         } elsif ($cur =~ /^($Modifier)\s*/) {
1629             print "MODIFIER($1)\n" if ($dbg_values > 1);
1630             $type = 'T';
1631 
1632         } elsif ($cur =~ /^(\#\s*define\s*$Ident)(\(?)/o) {
1633             print "DEFINE($1,$2)\n" if ($dbg_values > 1);
1634             $av_preprocessor = 1;
1635             push(@av_paren_type, $type);
1636             if ($2 ne '') {
1637                 $av_pending = 'N';
1638             }
1639             $type = 'E';
1640 
1641         } elsif ($cur =~ /^(\#\s*(?:undef\s*$Ident|include\b))/o) {
1642             print "UNDEF($1)\n" if ($dbg_values > 1);
1643             $av_preprocessor = 1;
1644             push(@av_paren_type, $type);
1645 
1646         } elsif ($cur =~ /^(\#\s*(?:ifdef|ifndef|if))/o) {
1647             print "PRE_START($1)\n" if ($dbg_values > 1);
1648             $av_preprocessor = 1;
1649 
1650             push(@av_paren_type, $type);
1651             push(@av_paren_type, $type);
1652             $type = 'E';
1653 
1654         } elsif ($cur =~ /^(\#\s*(?:else|elif))/o) {
1655             print "PRE_RESTART($1)\n" if ($dbg_values > 1);
1656             $av_preprocessor = 1;
1657 
1658             push(@av_paren_type, $av_paren_type[$#av_paren_type]);
1659 
1660             $type = 'E';
1661 
1662         } elsif ($cur =~ /^(\#\s*(?:endif))/o) {
1663             print "PRE_END($1)\n" if ($dbg_values > 1);
1664 
1665             $av_preprocessor = 1;
1666 
1667             # Assume all arms of the conditional end as this
1668             # one does, and continue as if the #endif was not here.
1669             pop(@av_paren_type);
1670             push(@av_paren_type, $type);
1671             $type = 'E';
1672 
1673         } elsif ($cur =~ /^(\\\n)/o) {
1674             print "PRECONT($1)\n" if ($dbg_values > 1);
1675 
1676         } elsif ($cur =~ /^(__attribute__)\s*\(?/o) {
1677             print "ATTR($1)\n" if ($dbg_values > 1);
1678             $av_pending = $type;
1679             $type = 'N';
1680 
1681         } elsif ($cur =~ /^(sizeof)\s*(\()?/o) {
1682             print "SIZEOF($1)\n" if ($dbg_values > 1);
1683             if (defined $2) {
1684                 $av_pending = 'V';
1685             }
1686             $type = 'N';
1687 
1688         } elsif ($cur =~ /^(if|while|for)\b/o) {
1689             print "COND($1)\n" if ($dbg_values > 1);
1690             $av_pending = 'E';
1691             $type = 'N';
1692 
1693         } elsif ($cur =~/^(case)/o) {
1694             print "CASE($1)\n" if ($dbg_values > 1);
1695             $av_pend_colon = 'C';
1696             $type = 'N';
1697 
1698         } elsif ($cur =~/^(return|else|goto|typeof|__typeof__)\b/o) {
1699             print "KEYWORD($1)\n" if ($dbg_values > 1);
1700             $type = 'N';
1701 
1702         } elsif ($cur =~ /^(\()/o) {
1703             print "PAREN('$1')\n" if ($dbg_values > 1);
1704             push(@av_paren_type, $av_pending);
1705             $av_pending = '_';
1706             $type = 'N';
1707 
1708         } elsif ($cur =~ /^(\))/o) {
1709             my $new_type = pop(@av_paren_type);
1710             if ($new_type ne '_') {
1711                 $type = $new_type;
1712                 print "PAREN('$1') -> $type\n"
1713                             if ($dbg_values > 1);
1714             } else {
1715                 print "PAREN('$1')\n" if ($dbg_values > 1);
1716             }
1717 
1718         } elsif ($cur =~ /^($Ident)\s*\(/o) {
1719             print "FUNC($1)\n" if ($dbg_values > 1);
1720             $type = 'V';
1721             $av_pending = 'V';
1722 
1723         } elsif ($cur =~ /^($Ident\s*):(?:\s*\d+\s*(,|=|;))?/) {
1724             if (defined $2 && $type eq 'C' || $type eq 'T') {
1725                 $av_pend_colon = 'B';
1726             } elsif ($type eq 'E') {
1727                 $av_pend_colon = 'L';
1728             }
1729             print "IDENT_COLON($1,$type>$av_pend_colon)\n" if ($dbg_values > 1);
1730             $type = 'V';
1731 
1732         } elsif ($cur =~ /^($Ident|$Constant)/o) {
1733             print "IDENT($1)\n" if ($dbg_values > 1);
1734             $type = 'V';
1735 
1736         } elsif ($cur =~ /^($Assignment)/o) {
1737             print "ASSIGN($1)\n" if ($dbg_values > 1);
1738             $type = 'N';
1739 
1740         } elsif ($cur =~/^(;|{|})/) {
1741             print "END($1)\n" if ($dbg_values > 1);
1742             $type = 'E';
1743             $av_pend_colon = 'O';
1744 
1745         } elsif ($cur =~/^(,)/) {
1746             print "COMMA($1)\n" if ($dbg_values > 1);
1747             $type = 'C';
1748 
1749         } elsif ($cur =~ /^(\?)/o) {
1750             print "QUESTION($1)\n" if ($dbg_values > 1);
1751             $type = 'N';
1752 
1753         } elsif ($cur =~ /^(:)/o) {
1754             print "COLON($1,$av_pend_colon)\n" if ($dbg_values > 1);
1755 
1756             substr($var, length($res), 1, $av_pend_colon);
1757             if ($av_pend_colon eq 'C' || $av_pend_colon eq 'L') {
1758                 $type = 'E';
1759             } else {
1760                 $type = 'N';
1761             }
1762             $av_pend_colon = 'O';
1763 
1764         } elsif ($cur =~ /^(\[)/o) {
1765             print "CLOSE($1)\n" if ($dbg_values > 1);
1766             $type = 'N';
1767 
1768         } elsif ($cur =~ /^(-(?![->])|\+(?!\+)|\*|\&\&|\&)/o) {
1769             my $variant;
1770 
1771             print "OPV($1)\n" if ($dbg_values > 1);
1772             if ($type eq 'V') {
1773                 $variant = 'B';
1774             } else {
1775                 $variant = 'U';
1776             }
1777 
1778             substr($var, length($res), 1, $variant);
1779             $type = 'N';
1780 
1781         } elsif ($cur =~ /^($Operators)/o) {
1782             print "OP($1)\n" if ($dbg_values > 1);
1783             if ($1 ne '++' && $1 ne '--') {
1784                 $type = 'N';
1785             }
1786 
1787         } elsif ($cur =~ /(^.)/o) {
1788             print "C($1)\n" if ($dbg_values > 1);
1789         }
1790         if (defined $1) {
1791             $cur = substr($cur, length($1));
1792             $res .= $type x length($1);
1793         }
1794     }
1795 
1796     return ($res, $var);
1797 }
1798 
1799 sub possible {
1800     my ($possible, $line) = @_;
1801     my $notPermitted = qr{(?:
1802         ^(?:
1803             $Modifier|
1804             $Storage|
1805             $Type|
1806             DEFINE_\S+
1807         )$|
1808         ^(?:
1809             goto|
1810             return|
1811             case|
1812             else|
1813             asm|__asm__|
1814             do|
1815             \#|
1816             \#\#|
1817         )(?:\s|$)|
1818         ^(?:typedef|struct|enum)\b
1819         )}x;
1820     warn "CHECK<$possible> ($line)\n" if ($dbg_possible > 2);
1821     if ($possible !~ $notPermitted) {
1822         # Check for modifiers.
1823         $possible =~ s/\s*$Storage\s*//g;
1824         $possible =~ s/\s*$Sparse\s*//g;
1825         if ($possible =~ /^\s*$/) {
1826 
1827         } elsif ($possible =~ /\s/) {
1828             $possible =~ s/\s*$Type\s*//g;
1829             for my $modifier (split(' ', $possible)) {
1830                 if ($modifier !~ $notPermitted) {
1831                     warn "MODIFIER: $modifier ($possible) ($line)\n" if ($dbg_possible);
1832                     push(@modifierListFile, $modifier);
1833                 }
1834             }
1835 
1836         } else {
1837             warn "POSSIBLE: $possible ($line)\n" if ($dbg_possible);
1838             push(@typeListFile, $possible);
1839         }
1840         build_types();
1841     } else {
1842         warn "NOTPOSS: $possible ($line)\n" if ($dbg_possible > 1);
1843     }
1844 }
1845 
1846 my $prefix = '';
1847 
1848 sub show_type {
1849     my ($type) = @_;
1850 
1851     return defined $use_type{$type} if (scalar keys %use_type > 0);
1852 
1853     return !defined $ignore_type{$type};
1854 }
1855 
1856 sub report {
1857     my ($level, $type, $msg) = @_;
1858 
1859     if (!show_type($type) ||
1860         (defined $tst_only && $msg !~ /\Q$tst_only\E/)) {
1861         return 0;
1862     }
1863     my $output = '';
1864     if (-t STDOUT && $color) {
1865         if ($level eq 'ERROR') {
1866             $output .= RED;
1867         } elsif ($level eq 'WARNING') {
1868             $output .= YELLOW;
1869         } else {
1870             $output .= GREEN;
1871         }
1872     }
1873     $output .= $prefix . $level . ':';
1874     if ($show_types) {
1875         $output .= BLUE if (-t STDOUT && $color);
1876         $output .= "$type:";
1877     }
1878     $output .= RESET if (-t STDOUT && $color);
1879     $output .= ' ' . $msg . "\n";
1880 
1881     if ($showfile) {
1882         my @lines = split("\n", $output, -1);
1883         splice(@lines, 1, 1);
1884         $output = join("\n", @lines);
1885     }
1886     $output = (split('\n', $output))[0] . "\n" if ($terse);
1887 
1888     push(our @report, $output);
1889 
1890     return 1;
1891 }
1892 
1893 sub report_dump {
1894     our @report;
1895 }
1896 
1897 sub fixup_current_range {
1898     my ($lineRef, $offset, $length) = @_;
1899 
1900     if ($$lineRef =~ /^\@\@ -\d+,\d+ \+(\d+),(\d+) \@\@/) {
1901         my $o = $1;
1902         my $l = $2;
1903         my $no = $o + $offset;
1904         my $nl = $l + $length;
1905         $$lineRef =~ s/\+$o,$l \@\@/\+$no,$nl \@\@/;
1906     }
1907 }
1908 
1909 sub fix_inserted_deleted_lines {
1910     my ($linesRef, $insertedRef, $deletedRef) = @_;
1911 
1912     my $range_last_linenr = 0;
1913     my $delta_offset = 0;
1914 
1915     my $old_linenr = 0;
1916     my $new_linenr = 0;
1917 
1918     my $next_insert = 0;
1919     my $next_delete = 0;
1920 
1921     my @lines = ();
1922 
1923     my $inserted = @{$insertedRef}[$next_insert++];
1924     my $deleted = @{$deletedRef}[$next_delete++];
1925 
1926     foreach my $old_line (@{$linesRef}) {
1927         my $save_line = 1;
1928         my $line = $old_line;   #don't modify the array
1929         if ($line =~ /^(?:\+\+\+|\-\-\-)\s+\S+/) {  #new filename
1930             $delta_offset = 0;
1931         } elsif ($line =~ /^\@\@ -\d+,\d+ \+\d+,\d+ \@\@/) {    #new hunk
1932             $range_last_linenr = $new_linenr;
1933             fixup_current_range(\$line, $delta_offset, 0);
1934         }
1935 
1936         while (defined($deleted) && ${$deleted}{'LINENR'} == $old_linenr) {
1937             $deleted = @{$deletedRef}[$next_delete++];
1938             $save_line = 0;
1939             fixup_current_range(\$lines[$range_last_linenr], $delta_offset--, -1);
1940         }
1941 
1942         while (defined($inserted) && ${$inserted}{'LINENR'} == $old_linenr) {
1943             push(@lines, ${$inserted}{'LINE'});
1944             $inserted = @{$insertedRef}[$next_insert++];
1945             $new_linenr++;
1946             fixup_current_range(\$lines[$range_last_linenr], $delta_offset++, 1);
1947         }
1948 
1949         if ($save_line) {
1950             push(@lines, $line);
1951             $new_linenr++;
1952         }
1953 
1954         $old_linenr++;
1955     }
1956 
1957     return @lines;
1958 }
1959 
1960 sub fix_insert_line {
1961     my ($linenr, $line) = @_;
1962 
1963     my $inserted = {
1964         LINENR => $linenr,
1965         LINE => $line,
1966     };
1967     push(@fixed_inserted, $inserted);
1968 }
1969 
1970 sub fix_delete_line {
1971     my ($linenr, $line) = @_;
1972 
1973     my $deleted = {
1974         LINENR => $linenr,
1975         LINE => $line,
1976     };
1977 
1978     push(@fixed_deleted, $deleted);
1979 }
1980 
1981 sub ERROR {
1982     my ($type, $msg) = @_;
1983 
1984     if (report("ERROR", $type, $msg)) {
1985         our $clean = 0;
1986         our $cnt_error++;
1987         return 1;
1988     }
1989     return 0;
1990 }
1991 sub WARN {
1992     my ($type, $msg) = @_;
1993 
1994     if (report("WARNING", $type, $msg)) {
1995         our $clean = 0;
1996         our $cnt_warn++;
1997         return 1;
1998     }
1999     return 0;
2000 }
2001 sub CHK {
2002     my ($type, $msg) = @_;
2003 
2004     if ($check && report("CHECK", $type, $msg)) {
2005         our $clean = 0;
2006         our $cnt_chk++;
2007         return 1;
2008     }
2009     return 0;
2010 }
2011 
2012 sub check_absolute_file {
2013     my ($absolute, $herecurr) = @_;
2014     my $file = $absolute;
2015 
2016     ##print "absolute<$absolute>\n";
2017 
2018     # See if any suffix of this path is a path within the tree.
2019     while ($file =~ s@^[^/]*/@@) {
2020         if (-f "$root/$file") {
2021             ##print "file<$file>\n";
2022             last;
2023         }
2024     }
2025     if (! -f _)  {
2026         return 0;
2027     }
2028 
2029     # It is, so see if the prefix is acceptable.
2030     my $prefix = $absolute;
2031     substr($prefix, -length($file)) = '';
2032 
2033     ##print "prefix<$prefix>\n";
2034     if ($prefix ne ".../") {
2035         WARN("USE_RELATIVE_PATH",
2036              "use relative pathname instead of absolute in changelog text\n" . $herecurr);
2037     }
2038 }
2039 
2040 sub trim {
2041     my ($string) = @_;
2042 
2043     $string =~ s/^\s+|\s+$//g;
2044 
2045     return $string;
2046 }
2047 
2048 sub ltrim {
2049     my ($string) = @_;
2050 
2051     $string =~ s/^\s+//;
2052 
2053     return $string;
2054 }
2055 
2056 sub rtrim {
2057     my ($string) = @_;
2058 
2059     $string =~ s/\s+$//;
2060 
2061     return $string;
2062 }
2063 
2064 sub string_find_replace {
2065     my ($string, $find, $replace) = @_;
2066 
2067     $string =~ s/$find/$replace/g;
2068 
2069     return $string;
2070 }
2071 
2072 sub tabify {
2073     my ($leading) = @_;
2074 
2075     my $source_indent = 8;
2076     my $max_spaces_before_tab = $source_indent - 1;
2077     my $spaces_to_tab = " " x $source_indent;
2078 
2079     #convert leading spaces to tabs
2080     1 while $leading =~ s@^([\t]*)$spaces_to_tab@$1\t@g;
2081     #Remove spaces before a tab
2082     1 while $leading =~ s@^([\t]*)( {1,$max_spaces_before_tab})\t@$1\t@g;
2083 
2084     return "$leading";
2085 }
2086 
2087 sub pos_last_openparen {
2088     my ($line) = @_;
2089 
2090     my $pos = 0;
2091 
2092     my $opens = $line =~ tr/\(/\(/;
2093     my $closes = $line =~ tr/\)/\)/;
2094 
2095     my $last_openparen = 0;
2096 
2097     if (($opens == 0) || ($closes >= $opens)) {
2098         return -1;
2099     }
2100 
2101     my $len = length($line);
2102 
2103     for ($pos = 0; $pos < $len; $pos++) {
2104         my $string = substr($line, $pos);
2105         if ($string =~ /^($FuncArg|$balanced_parens)/) {
2106             $pos += length($1) - 1;
2107         } elsif (substr($line, $pos, 1) eq '(') {
2108             $last_openparen = $pos;
2109         } elsif (index($string, '(') == -1) {
2110             last;
2111         }
2112     }
2113 
2114     return length(expand_tabs(substr($line, 0, $last_openparen))) + 1;
2115 }
2116 
2117 sub process {
2118     my $filename = shift;
2119 
2120     my $linenr=0;
2121     my $prevline="";
2122     my $prevrawline="";
2123     my $stashline="";
2124     my $stashrawline="";
2125 
2126     my $length;
2127     my $indent;
2128     my $previndent=0;
2129     my $stashindent=0;
2130 
2131     our $clean = 1;
2132     my $signoff = 0;
2133     my $is_patch = 0;
2134     my $in_header_lines = $file ? 0 : 1;
2135     my $in_commit_log = 0;      #Scanning lines before patch
2136     my $has_commit_log = 0;     #Encountered lines before patch
2137        my $commit_log_possible_stack_dump = 0;
2138     my $commit_log_long_line = 0;
2139     my $commit_log_has_diff = 0;
2140     my $reported_maintainer_file = 0;
2141     my $non_utf8_charset = 0;
2142 
2143     my $last_blank_line = 0;
2144     my $last_coalesced_string_linenr = -1;
2145 
2146     our @report = ();
2147     our $cnt_lines = 0;
2148     our $cnt_error = 0;
2149     our $cnt_warn = 0;
2150     our $cnt_chk = 0;
2151 
2152     # Trace the real file/line as we go.
2153     my $realfile = '';
2154     my $realline = 0;
2155     my $realcnt = 0;
2156     my $here = '';
2157     my $in_comment = 0;
2158     my $comment_edge = 0;
2159     my $first_line = 0;
2160     my $p1_prefix = '';
2161 
2162     my $prev_values = 'E';
2163 
2164     # suppression flags
2165     my %suppress_ifbraces;
2166     my %suppress_whiletrailers;
2167     my %suppress_export;
2168     my $suppress_statement = 0;
2169 
2170     my %signatures = ();
2171 
2172     # Pre-scan the patch sanitizing the lines.
2173     # Pre-scan the patch looking for any __setup documentation.
2174     #
2175     my @setup_docs = ();
2176     my $setup_docs = 0;
2177 
2178     my $camelcase_file_seeded = 0;
2179 
2180     sanitise_line_reset();
2181     my $line;
2182     foreach my $rawline (@rawlines) {
2183         $linenr++;
2184         $line = $rawline;
2185 
2186         push(@fixed, $rawline) if ($fix);
2187 
2188         if ($rawline=~/^\+\+\+\s+(\S+)/) {
2189             $setup_docs = 0;
2190             if ($1 =~ m@Documentation/admin-guide/kernel-parameters.rst$@) {
2191                 $setup_docs = 1;
2192             }
2193             #next;
2194         }
2195         if ($rawline=~/^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@/) {
2196             $realline=$1-1;
2197             if (defined $2) {
2198                 $realcnt=$3+1;
2199             } else {
2200                 $realcnt=1+1;
2201             }
2202             $in_comment = 0;
2203 
2204             # Guestimate if this is a continuing comment.  Run
2205             # the context looking for a comment "edge".  If this
2206             # edge is a close comment then we must be in a comment
2207             # at context start.
2208             my $edge;
2209             my $cnt = $realcnt;
2210             for (my $ln = $linenr + 1; $cnt > 0; $ln++) {
2211                 next if (defined $rawlines[$ln - 1] &&
2212                      $rawlines[$ln - 1] =~ /^-/);
2213                 $cnt--;
2214                 #print "RAW<$rawlines[$ln - 1]>\n";
2215                 last if (!defined $rawlines[$ln - 1]);
2216                 if ($rawlines[$ln - 1] =~ m@(/\*|\*/)@ &&
2217                     $rawlines[$ln - 1] !~ m@"[^"]*(?:/\*|\*/)[^"]*"@) {
2218                     ($edge) = $1;
2219                     last;
2220                 }
2221             }
2222             if (defined $edge && $edge eq '*/') {
2223                 $in_comment = 1;
2224             }
2225 
2226             # Guestimate if this is a continuing comment.  If this
2227             # is the start of a diff block and this line starts
2228             # ' *' then it is very likely a comment.
2229             if (!defined $edge &&
2230                 $rawlines[$linenr] =~ m@^.\s*(?:\*\*+| \*)(?:\s|$)@)
2231             {
2232                 $in_comment = 1;
2233             }
2234 
2235             ##print "COMMENT:$in_comment edge<$edge> $rawline\n";
2236             sanitise_line_reset($in_comment);
2237 
2238         } elsif ($realcnt && $rawline =~ /^(?:\+| |$)/) {
2239             # Standardise the strings and chars within the input to
2240             # simplify matching -- only bother with positive lines.
2241             $line = sanitise_line($rawline);
2242         }
2243         push(@lines, $line);
2244 
2245         if ($realcnt > 1) {
2246             $realcnt-- if ($line =~ /^(?:\+| |$)/);
2247         } else {
2248             $realcnt = 0;
2249         }
2250 
2251         #print "==>$rawline\n";
2252         #print "-->$line\n";
2253 
2254         if ($setup_docs && $line =~ /^\+/) {
2255             push(@setup_docs, $line);
2256         }
2257     }
2258 
2259     $prefix = '';
2260 
2261     $realcnt = 0;
2262     $linenr = 0;
2263     $fixlinenr = -1;
2264     foreach my $line (@lines) {
2265         $linenr++;
2266         $fixlinenr++;
2267         my $sline = $line;  #copy of $line
2268         $sline =~ s/$;/ /g; #with comments as spaces
2269 
2270         my $rawline = $rawlines[$linenr - 1];
2271 
2272 #extract the line range in the file after the patch is applied
2273         if (!$in_commit_log &&
2274             $line =~ /^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@/) {
2275             $is_patch = 1;
2276             $first_line = $linenr + 1;
2277             $realline=$1-1;
2278             if (defined $2) {
2279                 $realcnt=$3+1;
2280             } else {
2281                 $realcnt=1+1;
2282             }
2283             annotate_reset();
2284             $prev_values = 'E';
2285 
2286             %suppress_ifbraces = ();
2287             %suppress_whiletrailers = ();
2288             %suppress_export = ();
2289             $suppress_statement = 0;
2290             next;
2291 
2292 # track the line number as we move through the hunk, note that
2293 # new versions of GNU diff omit the leading space on completely
2294 # blank context lines so we need to count that too.
2295         } elsif ($line =~ /^( |\+|$)/) {
2296             $realline++;
2297             $realcnt-- if ($realcnt != 0);
2298 
2299             # Measure the line length and indent.
2300             ($length, $indent) = line_stats($rawline);
2301 
2302             # Track the previous line.
2303             ($prevline, $stashline) = ($stashline, $line);
2304             ($previndent, $stashindent) = ($stashindent, $indent);
2305             ($prevrawline, $stashrawline) = ($stashrawline, $rawline);
2306 
2307             #warn "line<$line>\n";
2308 
2309         } elsif ($realcnt == 1) {
2310             $realcnt--;
2311         }
2312 
2313         my $hunk_line = ($realcnt != 0);
2314 
2315         $here = "#$linenr: " if (!$file);
2316         $here = "#$realline: " if ($file);
2317 
2318         my $found_file = 0;
2319         # extract the filename as it passes
2320         if ($line =~ /^diff --git.*?(\S+)$/) {
2321             $realfile = $1;
2322             $realfile =~ s@^([^/]*)/@@ if (!$file);
2323             $in_commit_log = 0;
2324             $found_file = 1;
2325         } elsif ($line =~ /^\+\+\+\s+(\S+)/) {
2326             $realfile = $1;
2327             $realfile =~ s@^([^/]*)/@@ if (!$file);
2328             $in_commit_log = 0;
2329 
2330             $p1_prefix = $1;
2331             if (!$file && $tree && $p1_prefix ne '' &&
2332                 -e "$root/$p1_prefix") {
2333                 WARN("PATCH_PREFIX",
2334                      "patch prefix '$p1_prefix' exists, appears to be a -p0 patch\n");
2335             }
2336 
2337             if ($realfile =~ m@^include/asm/@) {
2338                 ERROR("MODIFIED_INCLUDE_ASM",
2339                       "do not modify files in include/asm, change architecture specific files in include/asm-<architecture>\n" . "$here$rawline\n");
2340             }
2341             $found_file = 1;
2342         }
2343 
2344 #make up the handle for any error we report on this line
2345         if ($showfile) {
2346             $prefix = "$realfile:$realline: "
2347         } elsif ($emacs) {
2348             if ($file) {
2349                 $prefix = "$filename:$realline: ";
2350             } else {
2351                 $prefix = "$filename:$linenr: ";
2352             }
2353         }
2354 
2355         if ($found_file) {
2356             if (is_maintained_obsolete($realfile)) {
2357                 WARN("OBSOLETE",
2358                      "$realfile is marked as 'obsolete' in the MAINTAINERS hierarchy.  No unnecessary modifications please.\n");
2359             }
2360             if ($realfile =~ m@^(?:drivers/net/|net/|drivers/staging/)@) {
2361                 $check = 1;
2362             } else {
2363                 $check = $check_orig;
2364             }
2365             next;
2366         }
2367 
2368         $here .= "FILE: $realfile:$realline:" if ($realcnt != 0);
2369 
2370         my $hereline = "$here\n$rawline\n";
2371         my $herecurr = "$here\n$rawline\n";
2372         my $hereprev = "$here\n$prevrawline\n$rawline\n";
2373 
2374         $cnt_lines++ if ($realcnt != 0);
2375 
2376 # Check if the commit log has what seems like a diff which can confuse patch
2377         if ($in_commit_log && !$commit_log_has_diff &&
2378             (($line =~ m@^\s+diff\b.*a/[\w/]+@ &&
2379               $line =~ m@^\s+diff\b.*a/([\w/]+)\s+b/$1\b@) ||
2380              $line =~ m@^\s*(?:\-\-\-\s+a/|\+\+\+\s+b/)@ ||
2381              $line =~ m/^\s*\@\@ \-\d+,\d+ \+\d+,\d+ \@\@/)) {
2382             ERROR("DIFF_IN_COMMIT_MSG",
2383                   "Avoid using diff content in the commit message - patch(1) might not work\n" . $herecurr);
2384             $commit_log_has_diff = 1;
2385         }
2386 
2387 # Check for incorrect file permissions
2388         if ($line =~ /^new (file )?mode.*[7531]\d{0,2}$/) {
2389             my $permhere = $here . "FILE: $realfile\n";
2390             if ($realfile !~ m@scripts/@ &&
2391                 $realfile !~ /\.(py|pl|awk|sh)$/) {
2392                 ERROR("EXECUTE_PERMISSIONS",
2393                       "do not set execute permissions for source files\n" . $permhere);
2394             }
2395         }
2396 
2397 # Check the patch for a signoff:
2398         if ($line =~ /^\s*signed-off-by:/i) {
2399             $signoff++;
2400             $in_commit_log = 0;
2401         }
2402 
2403 # Check if MAINTAINERS is being updated.  If so, there's probably no need to
2404 # emit the "does MAINTAINERS need updating?" message on file add/move/delete
2405         if ($line =~ /^\s*MAINTAINERS\s*\|/) {
2406             $reported_maintainer_file = 1;
2407         }
2408 
2409 # Check signature styles
2410         if (!$in_header_lines &&
2411             $line =~ /^(\s*)([a-z0-9_-]+by:|$signature_tags)(\s*)(.*)/i) {
2412             my $space_before = $1;
2413             my $sign_off = $2;
2414             my $space_after = $3;
2415             my $email = $4;
2416             my $ucfirst_sign_off = ucfirst(lc($sign_off));
2417 
2418             if ($sign_off !~ /$signature_tags/) {
2419                 WARN("BAD_SIGN_OFF",
2420                      "Non-standard signature: $sign_off\n" . $herecurr);
2421             }
2422             if (defined $space_before && $space_before ne "") {
2423                 if (WARN("BAD_SIGN_OFF",
2424                      "Do not use whitespace before $ucfirst_sign_off\n" . $herecurr) &&
2425                     $fix) {
2426                     $fixed[$fixlinenr] =
2427                         "$ucfirst_sign_off $email";
2428                 }
2429             }
2430             if ($sign_off =~ /-by:$/i && $sign_off ne $ucfirst_sign_off) {
2431                 if (WARN("BAD_SIGN_OFF",
2432                      "'$ucfirst_sign_off' is the preferred signature form\n" . $herecurr) &&
2433                     $fix) {
2434                     $fixed[$fixlinenr] =
2435                         "$ucfirst_sign_off $email";
2436                 }
2437 
2438             }
2439             if (!defined $space_after || $space_after ne " ") {
2440                 if (WARN("BAD_SIGN_OFF",
2441                      "Use a single space after $ucfirst_sign_off\n" . $herecurr) &&
2442                     $fix) {
2443                     $fixed[$fixlinenr] =
2444                         "$ucfirst_sign_off $email";
2445                 }
2446             }
2447 
2448             my ($email_name, $email_address, $comment) = parse_email($email);
2449             my $suggested_email = format_email(($email_name, $email_address));
2450             if ($suggested_email eq "") {
2451                 ERROR("BAD_SIGN_OFF",
2452                       "Unrecognized email address: '$email'\n" . $herecurr);
2453             } else {
2454                 my $dequoted = $suggested_email;
2455                 $dequoted =~ s/^"//;
2456                 $dequoted =~ s/" </ </;
2457                 # Don't force email to have quotes
2458                 # Allow just an angle bracketed address
2459                 if ("$dequoted$comment" ne $email &&
2460                     "<$email_address>$comment" ne $email &&
2461                     "$suggested_email$comment" ne $email) {
2462                     WARN("BAD_SIGN_OFF",
2463                          "email address '$email' might be better as '$suggested_email$comment'\n" . $herecurr);
2464                 }
2465             }
2466 
2467 # Check for duplicate signatures
2468             my $sig_nospace = $line;
2469             $sig_nospace =~ s/\s//g;
2470             $sig_nospace = lc($sig_nospace);
2471             if (defined $signatures{$sig_nospace}) {
2472                 WARN("BAD_SIGN_OFF",
2473                      "Duplicate signature\n" . $herecurr);
2474             } else {
2475                 $signatures{$sig_nospace} = 1;
2476             }
2477         }
2478 
2479 # Check email subject for common tools that don't need to be mentioned
2480         if ($in_header_lines &&
2481             $line =~ /^Subject:.*\b(?:checkpatch|sparse|smatch)\b[^:]/i) {
2482             WARN("EMAIL_SUBJECT",
2483                  "A patch subject line should describe the change not the tool that found it\n" . $herecurr);
2484         }
2485 
2486 # Check for old stable address
2487         if ($line =~ /^\s*cc:\s*.*<?\bstable\@kernel\.org\b>?.*$/i) {
2488             ERROR("STABLE_ADDRESS",
2489                   "The 'stable' address should be 'stable\@vger.kernel.org'\n" . $herecurr);
2490         }
2491 
2492 # Check for unwanted Gerrit info
2493         if ($in_commit_log && $line =~ /^\s*change-id:/i) {
2494             ERROR("GERRIT_CHANGE_ID",
2495                   "Remove Gerrit Change-Id's before submitting upstream.\n" . $herecurr);
2496         }
2497 
2498 # Check if the commit log is in a possible stack dump
2499         if ($in_commit_log && !$commit_log_possible_stack_dump &&
2500             ($line =~ /^\s*(?:WARNING:|BUG:)/ ||
2501              $line =~ /^\s*\[\s*\d+\.\d{6,6}\s*\]/ ||
2502                     # timestamp
2503              $line =~ /^\s*\[\<[0-9a-fA-F]{8,}\>\]/)) {
2504                     # stack dump address
2505             $commit_log_possible_stack_dump = 1;
2506         }
2507 
2508 # Check for line lengths > 75 in commit log, warn once
2509         if ($in_commit_log && !$commit_log_long_line &&
2510             length($line) > 75 &&
2511             !($line =~ /^\s*[a-zA-Z0-9_\/\.]+\s+\|\s+\d+/ ||
2512                     # file delta changes
2513               $line =~ /^\s*(?:[\w\.\-]+\/)++[\w\.\-]+:/ ||
2514                     # filename then :
2515               $line =~ /^\s*(?:Fixes:|Link:)/i ||
2516                     # A Fixes: or Link: line
2517               $commit_log_possible_stack_dump)) {
2518             WARN("COMMIT_LOG_LONG_LINE",
2519                  "Possible unwrapped commit description (prefer a maximum 75 chars per line)\n" . $herecurr);
2520             $commit_log_long_line = 1;
2521         }
2522 
2523 # Reset possible stack dump if a blank line is found
2524         if ($in_commit_log && $commit_log_possible_stack_dump &&
2525             $line =~ /^\s*$/) {
2526             $commit_log_possible_stack_dump = 0;
2527         }
2528 
2529 # Check for git id commit length and improperly formed commit descriptions
2530         if ($in_commit_log && !$commit_log_possible_stack_dump &&
2531             $line !~ /^\s*(?:Link|Patchwork|http|https|BugLink):/i &&
2532             ($line =~ /\bcommit\s+[0-9a-f]{5,}\b/i ||
2533              ($line =~ /(?:\s|^)[0-9a-f]{12,40}(?:[\s"'\(\[]|$)/i &&
2534               $line !~ /[\<\[][0-9a-f]{12,40}[\>\]]/i &&
2535               $line !~ /\bfixes:\s*[0-9a-f]{12,40}/i))) {
2536             my $init_char = "c";
2537             my $orig_commit = "";
2538             my $short = 1;
2539             my $long = 0;
2540             my $case = 1;
2541             my $space = 1;
2542             my $hasdesc = 0;
2543             my $hasparens = 0;
2544             my $id = '0123456789ab';
2545             my $orig_desc = "commit description";
2546             my $description = "";
2547 
2548             if ($line =~ /\b(c)ommit\s+([0-9a-f]{5,})\b/i) {
2549                 $init_char = $1;
2550                 $orig_commit = lc($2);
2551             } elsif ($line =~ /\b([0-9a-f]{12,40})\b/i) {
2552                 $orig_commit = lc($1);
2553             }
2554 
2555             $short = 0 if ($line =~ /\bcommit\s+[0-9a-f]{12,40}/i);
2556             $long = 1 if ($line =~ /\bcommit\s+[0-9a-f]{41,}/i);
2557             $space = 0 if ($line =~ /\bcommit [0-9a-f]/i);
2558             $case = 0 if ($line =~ /\b[Cc]ommit\s+[0-9a-f]{5,40}[^A-F]/);
2559             if ($line =~ /\bcommit\s+[0-9a-f]{5,}\s+\("([^"]+)"\)/i) {
2560                 $orig_desc = $1;
2561                 $hasparens = 1;
2562             } elsif ($line =~ /\bcommit\s+[0-9a-f]{5,}\s*$/i &&
2563                  defined $rawlines[$linenr] &&
2564                  $rawlines[$linenr] =~ /^\s*\("([^"]+)"\)/) {
2565                 $orig_desc = $1;
2566                 $hasparens = 1;
2567             } elsif ($line =~ /\bcommit\s+[0-9a-f]{5,}\s+\("[^"]+$/i &&
2568                  defined $rawlines[$linenr] &&
2569                  $rawlines[$linenr] =~ /^\s*[^"]+"\)/) {
2570                 $line =~ /\bcommit\s+[0-9a-f]{5,}\s+\("([^"]+)$/i;
2571                 $orig_desc = $1;
2572                 $rawlines[$linenr] =~ /^\s*([^"]+)"\)/;
2573                 $orig_desc .= " " . $1;
2574                 $hasparens = 1;
2575             }
2576 
2577             ($id, $description) = git_commit_info($orig_commit,
2578                                   $id, $orig_desc);
2579 
2580             if ($short || $long || $space || $case || ($orig_desc ne $description) || !$hasparens) {
2581                 ERROR("GIT_COMMIT_ID",
2582                       "Please use git commit description style 'commit <12+ chars of sha1> (\"<title line>\")' - ie: '${init_char}ommit $id (\"$description\")'\n" . $herecurr);
2583             }
2584         }
2585 
2586 # Check for added, moved or deleted files
2587         if (!$reported_maintainer_file && !$in_commit_log &&
2588             ($line =~ /^(?:new|deleted) file mode\s*\d+\s*$/ ||
2589              $line =~ /^rename (?:from|to) [\w\/\.\-]+\s*$/ ||
2590              ($line =~ /\{\s*([\w\/\.\-]*)\s*\=\>\s*([\w\/\.\-]*)\s*\}/ &&
2591               (defined($1) || defined($2))))) {
2592             $is_patch = 1;
2593             $reported_maintainer_file = 1;
2594             WARN("FILE_PATH_CHANGES",
2595                  "added, moved or deleted file(s), does MAINTAINERS need updating?\n" . $herecurr);
2596         }
2597 
2598 # Check for wrappage within a valid hunk of the file
2599         if ($realcnt != 0 && $line !~ m{^(?:\+|-| |\\ No newline|$)}) {
2600             ERROR("CORRUPTED_PATCH",
2601                   "patch seems to be corrupt (line wrapped?)\n" .
2602                 $herecurr) if (!$emitted_corrupt++);
2603         }
2604 
2605 # UTF-8 regex found at http://www.w3.org/International/questions/qa-forms-utf-8.en.php
2606         if (($realfile =~ /^$/ || $line =~ /^\+/) &&
2607             $rawline !~ m/^$UTF8*$/) {
2608             my ($utf8_prefix) = ($rawline =~ /^($UTF8*)/);
2609 
2610             my $blank = copy_spacing($rawline);
2611             my $ptr = substr($blank, 0, length($utf8_prefix)) . "^";
2612             my $hereptr = "$hereline$ptr\n";
2613 
2614             CHK("INVALID_UTF8",
2615                 "Invalid UTF-8, patch and commit message should be encoded in UTF-8\n" . $hereptr);
2616         }
2617 
2618 # Check if it's the start of a commit log
2619 # (not a header line and we haven't seen the patch filename)
2620         if ($in_header_lines && $realfile =~ /^$/ &&
2621             !($rawline =~ /^\s+\S/ ||
2622               $rawline =~ /^(commit\b|from\b|[\w-]+:).*$/i)) {
2623             $in_header_lines = 0;
2624             $in_commit_log = 1;
2625             $has_commit_log = 1;
2626         }
2627 
2628 # Check if there is UTF-8 in a commit log when a mail header has explicitly
2629 # declined it, i.e defined some charset where it is missing.
2630         if ($in_header_lines &&
2631             $rawline =~ /^Content-Type:.+charset="(.+)".*$/ &&
2632             $1 !~ /utf-8/i) {
2633             $non_utf8_charset = 1;
2634         }
2635 
2636         if ($in_commit_log && $non_utf8_charset && $realfile =~ /^$/ &&
2637             $rawline =~ /$NON_ASCII_UTF8/) {
2638             WARN("UTF8_BEFORE_PATCH",
2639                 "8-bit UTF-8 used in possible commit log\n" . $herecurr);
2640         }
2641 
2642 # Check for absolute kernel paths in commit message
2643         if ($tree && $in_commit_log) {
2644             while ($line =~ m{(?:^|\s)(/\S*)}g) {
2645                 my $file = $1;
2646 
2647                 if ($file =~ m{^(.*?)(?::\d+)+:?$} &&
2648                     check_absolute_file($1, $herecurr)) {
2649                     #
2650                 } else {
2651                     check_absolute_file($file, $herecurr);
2652                 }
2653             }
2654         }
2655 
2656 # Check for various typo / spelling mistakes
2657         if (defined($misspellings) &&
2658             ($in_commit_log || $line =~ /^(?:\+|Subject:)/i)) {
2659             while ($rawline =~ /(?:^|[^a-z@])($misspellings)(?:\b|$|[^a-z@])/gi) {
2660                 my $typo = $1;
2661                 my $typo_fix = $spelling_fix{lc($typo)};
2662                 $typo_fix = ucfirst($typo_fix) if ($typo =~ /^[A-Z]/);
2663                 $typo_fix = uc($typo_fix) if ($typo =~ /^[A-Z]+$/);
2664                 my $msg_type = \&WARN;
2665                 $msg_type = \&CHK if ($file);
2666                 if (&{$msg_type}("TYPO_SPELLING",
2667                          "'$typo' may be misspelled - perhaps '$typo_fix'?\n" . $herecurr) &&
2668                     $fix) {
2669                     $fixed[$fixlinenr] =~ s/(^|[^A-Za-z@])($typo)($|[^A-Za-z@])/$1$typo_fix$3/;
2670                 }
2671             }
2672         }
2673 
2674 # ignore non-hunk lines and lines being removed
2675         next if (!$hunk_line || $line =~ /^-/);
2676 
2677 #trailing whitespace
2678         if ($line =~ /^\+.*\015/) {
2679             my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2680             if (ERROR("DOS_LINE_ENDINGS",
2681                   "DOS line endings\n" . $herevet) &&
2682                 $fix) {
2683                 $fixed[$fixlinenr] =~ s/[\s\015]+$//;
2684             }
2685         } elsif ($rawline =~ /^\+.*\S\s+$/ || $rawline =~ /^\+\s+$/) {
2686             my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2687             if (ERROR("TRAILING_WHITESPACE",
2688                   "trailing whitespace\n" . $herevet) &&
2689                 $fix) {
2690                 $fixed[$fixlinenr] =~ s/\s+$//;
2691             }
2692 
2693             $rpt_cleaners = 1;
2694         }
2695 
2696 # Check for FSF mailing addresses.
2697         if ($rawline =~ /\bwrite to the Free/i ||
2698             $rawline =~ /\b59\s+Temple\s+Pl/i ||
2699             $rawline =~ /\b51\s+Franklin\s+St/i) {
2700             my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2701             my $msg_type = \&ERROR;
2702             $msg_type = \&CHK if ($file);
2703             &{$msg_type}("FSF_MAILING_ADDRESS",
2704                      "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)
2705         }
2706 
2707 # check for Kconfig help text having a real description
2708 # Only applies when adding the entry originally, after that we do not have
2709 # sufficient context to determine whether it is indeed long enough.
2710         if ($realfile =~ /Kconfig/ &&
2711             $line =~ /^\+\s*config\s+/) {
2712             my $length = 0;
2713             my $cnt = $realcnt;
2714             my $ln = $linenr + 1;
2715             my $f;
2716             my $is_start = 0;
2717             my $is_end = 0;
2718             for (; $cnt > 0 && defined $lines[$ln - 1]; $ln++) {
2719                 $f = $lines[$ln - 1];
2720                 $cnt-- if ($lines[$ln - 1] !~ /^-/);
2721                 $is_end = $lines[$ln - 1] =~ /^\+/;
2722 
2723                 next if ($f =~ /^-/);
2724                 last if (!$file && $f =~ /^\@\@/);
2725 
2726                 if ($lines[$ln - 1] =~ /^\+\s*(?:bool|tristate)\s*\"/) {
2727                     $is_start = 1;
2728                 } elsif ($lines[$ln - 1] =~ /^\+\s*(?:---)?help(?:---)?$/) {
2729                     $length = -1;
2730                 }
2731 
2732                 $f =~ s/^.//;
2733                 $f =~ s/#.*//;
2734                 $f =~ s/^\s+//;
2735                 next if ($f =~ /^$/);
2736                 if ($f =~ /^\s*config\s/) {
2737                     $is_end = 1;
2738                     last;
2739                 }
2740                 $length++;
2741             }
2742             if ($is_start && $is_end && $length < $min_conf_desc_length) {
2743                 WARN("CONFIG_DESCRIPTION",
2744                      "please write a paragraph that describes the config symbol fully\n" . $herecurr);
2745             }
2746             #print "is_start<$is_start> is_end<$is_end> length<$length>\n";
2747         }
2748 
2749 # discourage the addition of CONFIG_EXPERIMENTAL in Kconfig.
2750         if ($realfile =~ /Kconfig/ &&
2751             $line =~ /.\s*depends on\s+.*\bEXPERIMENTAL\b/) {
2752             WARN("CONFIG_EXPERIMENTAL",
2753                  "Use of CONFIG_EXPERIMENTAL is deprecated. For alternatives, see https://lkml.org/lkml/2012/10/23/580\n");
2754         }
2755 
2756 # discourage the use of boolean for type definition attributes of Kconfig options
2757         if ($realfile =~ /Kconfig/ &&
2758             $line =~ /^\+\s*\bboolean\b/) {
2759             WARN("CONFIG_TYPE_BOOLEAN",
2760                  "Use of boolean is deprecated, please use bool instead.\n" . $herecurr);
2761         }
2762 
2763         if (($realfile =~ /Makefile.*/ || $realfile =~ /Kbuild.*/) &&
2764             ($line =~ /\+(EXTRA_[A-Z]+FLAGS).*/)) {
2765             my $flag = $1;
2766             my $replacement = {
2767                 'EXTRA_AFLAGS' =>   'asflags-y',
2768                 'EXTRA_CFLAGS' =>   'ccflags-y',
2769                 'EXTRA_CPPFLAGS' => 'cppflags-y',
2770                 'EXTRA_LDFLAGS' =>  'ldflags-y',
2771             };
2772 
2773             WARN("DEPRECATED_VARIABLE",
2774                  "Use of $flag is deprecated, please use \`$replacement->{$flag} instead.\n" . $herecurr) if ($replacement->{$flag});
2775         }
2776 
2777 # check for DT compatible documentation
2778         if (defined $root &&
2779             (($realfile =~ /\.dtsi?$/ && $line =~ /^\+\s*compatible\s*=\s*\"/) ||
2780              ($realfile =~ /\.[ch]$/ && $line =~ /^\+.*\.compatible\s*=\s*\"/))) {
2781 
2782             my @compats = $rawline =~ /\"([a-zA-Z0-9\-\,\.\+_]+)\"/g;
2783 
2784             my $dt_path = $root . "/Documentation/devicetree/bindings/";
2785             my $vp_file = $dt_path . "vendor-prefixes.txt";
2786 
2787             foreach my $compat (@compats) {
2788                 my $compat2 = $compat;
2789                 $compat2 =~ s/\,[a-zA-Z0-9]*\-/\,<\.\*>\-/;
2790                 my $compat3 = $compat;
2791                 $compat3 =~ s/\,([a-z]*)[0-9]*\-/\,$1<\.\*>\-/;
2792                 `grep -Erq "$compat|$compat2|$compat3" $dt_path`;
2793                 if ( $? >> 8 ) {
2794                     WARN("UNDOCUMENTED_DT_STRING",
2795                          "DT compatible string \"$compat\" appears un-documented -- check $dt_path\n" . $herecurr);
2796                 }
2797 
2798                 next if $compat !~ /^([a-zA-Z0-9\-]+)\,/;
2799                 my $vendor = $1;
2800                 `grep -Eq "^$vendor\\b" $vp_file`;
2801                 if ( $? >> 8 ) {
2802                     WARN("UNDOCUMENTED_DT_STRING",
2803                          "DT compatible string vendor \"$vendor\" appears un-documented -- check $vp_file\n" . $herecurr);
2804                 }
2805             }
2806         }
2807 
2808 # check we are in a valid source file if not then ignore this hunk
2809         next if ($realfile !~ /\.(h|c|s|S|sh|dtsi|dts)$/);
2810 
2811 # line length limit (with some exclusions)
2812 #
2813 # There are a few types of lines that may extend beyond $max_line_length:
2814 #   logging functions like pr_info that end in a string
2815 #   lines with a single string
2816 #   #defines that are a single string
2817 #
2818 # There are 3 different line length message types:
2819 # LONG_LINE_COMMENT a comment starts before but extends beyond $max_linelength
2820 # LONG_LINE_STRING  a string starts before but extends beyond $max_line_length
2821 # LONG_LINE     all other lines longer than $max_line_length
2822 #
2823 # if LONG_LINE is ignored, the other 2 types are also ignored
2824 #
2825 
2826         if ($line =~ /^\+/ && $length > $max_line_length) {
2827             my $msg_type = "LONG_LINE";
2828 
2829             # Check the allowed long line types first
2830 
2831             # logging functions that end in a string that starts
2832             # before $max_line_length
2833             if ($line =~ /^\+\s*$logFunctions\s*\(\s*(?:(?:KERN_\S+\s*|[^"]*))?($String\s*(?:|,|\)\s*;)\s*)$/ &&
2834                 length(expand_tabs(substr($line, 1, length($line) - length($1) - 1))) <= $max_line_length) {
2835                 $msg_type = "";
2836 
2837             # lines with only strings (w/ possible termination)
2838             # #defines with only strings
2839             } elsif ($line =~ /^\+\s*$String\s*(?:\s*|,|\)\s*;)\s*$/ ||
2840                  $line =~ /^\+\s*#\s*define\s+\w+\s+$String$/) {
2841                 $msg_type = "";
2842 
2843             # EFI_GUID is another special case
2844             } elsif ($line =~ /^\+.*\bEFI_GUID\s*\(/) {
2845                 $msg_type = "";
2846 
2847             # Otherwise set the alternate message types
2848 
2849             # a comment starts before $max_line_length
2850             } elsif ($line =~ /($;[\s$;]*)$/ &&
2851                  length(expand_tabs(substr($line, 1, length($line) - length($1) - 1))) <= $max_line_length) {
2852                 $msg_type = "LONG_LINE_COMMENT"
2853 
2854             # a quoted string starts before $max_line_length
2855             } elsif ($sline =~ /\s*($String(?:\s*(?:\\|,\s*|\)\s*;\s*))?)$/ &&
2856                  length(expand_tabs(substr($line, 1, length($line) - length($1) - 1))) <= $max_line_length) {
2857                 $msg_type = "LONG_LINE_STRING"
2858             }
2859 
2860             if ($msg_type ne "" &&
2861                 (show_type("LONG_LINE") || show_type($msg_type))) {
2862                 WARN($msg_type,
2863                      "line over $max_line_length characters\n" . $herecurr);
2864             }
2865         }
2866 
2867 # check for adding lines without a newline.
2868         if ($line =~ /^\+/ && defined $lines[$linenr] && $lines[$linenr] =~ /^\\ No newline at end of file/) {
2869             WARN("MISSING_EOF_NEWLINE",
2870                  "adding a line without newline at end of file\n" . $herecurr);
2871         }
2872 
2873 # Blackfin: use hi/lo macros
2874         if ($realfile =~ m@arch/blackfin/.*\.S$@) {
2875             if ($line =~ /\.[lL][[:space:]]*=.*&[[:space:]]*0x[fF][fF][fF][fF]/) {
2876                 my $herevet = "$here\n" . cat_vet($line) . "\n";
2877                 ERROR("LO_MACRO",
2878                       "use the LO() macro, not (... & 0xFFFF)\n" . $herevet);
2879             }
2880             if ($line =~ /\.[hH][[:space:]]*=.*>>[[:space:]]*16/) {
2881                 my $herevet = "$here\n" . cat_vet($line) . "\n";
2882                 ERROR("HI_MACRO",
2883                       "use the HI() macro, not (... >> 16)\n" . $herevet);
2884             }
2885         }
2886 
2887 # check we are in a valid source file C or perl if not then ignore this hunk
2888         next if ($realfile !~ /\.(h|c|pl|dtsi|dts)$/);
2889 
2890 # at the beginning of a line any tabs must come first and anything
2891 # more than 8 must use tabs.
2892         if ($rawline =~ /^\+\s* \t\s*\S/ ||
2893             $rawline =~ /^\+\s*        \s*/) {
2894             my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2895             $rpt_cleaners = 1;
2896             if (ERROR("CODE_INDENT",
2897                   "code indent should use tabs where possible\n" . $herevet) &&
2898                 $fix) {
2899                 $fixed[$fixlinenr] =~ s/^\+([ \t]+)/"\+" . tabify($1)/e;
2900             }
2901         }
2902 
2903 # check for space before tabs.
2904         if ($rawline =~ /^\+/ && $rawline =~ / \t/) {
2905             my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2906             if (WARN("SPACE_BEFORE_TAB",
2907                 "please, no space before tabs\n" . $herevet) &&
2908                 $fix) {
2909                 while ($fixed[$fixlinenr] =~
2910                        s/(^\+.*) {8,8}\t/$1\t\t/) {}
2911                 while ($fixed[$fixlinenr] =~
2912                        s/(^\+.*) +\t/$1\t/) {}
2913             }
2914         }
2915 
2916 # check for && or || at the start of a line
2917         if ($rawline =~ /^\+\s*(&&|\|\|)/) {
2918             CHK("LOGICAL_CONTINUATIONS",
2919                 "Logical continuations should be on the previous line\n" . $hereprev);
2920         }
2921 
2922 # check indentation starts on a tab stop
2923         if ($^V && $^V ge 5.10.0 &&
2924             $sline =~ /^\+\t+( +)(?:$c90_Keywords\b|\{\s*$|\}\s*(?:else\b|while\b|\s*$))/) {
2925             my $indent = length($1);
2926             if ($indent % 8) {
2927                 if (WARN("TABSTOP",
2928                      "Statements should start on a tabstop\n" . $herecurr) &&
2929                     $fix) {
2930                     $fixed[$fixlinenr] =~ s@(^\+\t+) +@$1 . "\t" x ($indent/8)@e;
2931                 }
2932             }
2933         }
2934 
2935 # check multi-line statement indentation matches previous line
2936         if ($^V && $^V ge 5.10.0 &&
2937             $prevline =~ /^\+([ \t]*)((?:$c90_Keywords(?:\s+if)\s*)|(?:$Declare\s*)?(?:$Ident|\(\s*\*\s*$Ident\s*\))\s*|$Ident\s*=\s*$Ident\s*)\(.*(\&\&|\|\||,)\s*$/) {
2938             $prevline =~ /^\+(\t*)(.*)$/;
2939             my $oldindent = $1;
2940             my $rest = $2;
2941 
2942             my $pos = pos_last_openparen($rest);
2943             if ($pos >= 0) {
2944                 $line =~ /^(\+| )([ \t]*)/;
2945                 my $newindent = $2;
2946 
2947                 my $goodtabindent = $oldindent .
2948                     "\t" x ($pos / 8) .
2949                     " "  x ($pos % 8);
2950                 my $goodspaceindent = $oldindent . " "  x $pos;
2951 
2952                 if ($newindent ne $goodtabindent &&
2953                     $newindent ne $goodspaceindent) {
2954 
2955                     if (CHK("PARENTHESIS_ALIGNMENT",
2956                         "Alignment should match open parenthesis\n" . $hereprev) &&
2957                         $fix && $line =~ /^\+/) {
2958                         $fixed[$fixlinenr] =~
2959                             s/^\+[ \t]*/\+$goodtabindent/;
2960                     }
2961                 }
2962             }
2963         }
2964 
2965 # check for space after cast like "(int) foo" or "(struct foo) bar"
2966 # avoid checking a few false positives:
2967 #   "sizeof(<type>)" or "__alignof__(<type>)"
2968 #   function pointer declarations like "(*foo)(int) = bar;"
2969 #   structure definitions like "(struct foo) { 0 };"
2970 #   multiline macros that define functions
2971 #   known attributes or the __attribute__ keyword
2972         if ($line =~ /^\+(.*)\(\s*$Type\s*\)([ \t]++)((?![={]|\\$|$Attribute|__attribute__))/ &&
2973             (!defined($1) || $1 !~ /\b(?:sizeof|__alignof__)\s*$/)) {
2974             if (CHK("SPACING",
2975                 "No space is necessary after a cast\n" . $herecurr) &&
2976                 $fix) {
2977                 $fixed[$fixlinenr] =~
2978                     s/(\(\s*$Type\s*\))[ \t]+/$1/;
2979             }
2980         }
2981 
2982 # Block comment styles
2983 # Networking with an initial /*
2984         if ($realfile =~ m@^(drivers/net/|net/)@ &&
2985             $prevrawline =~ /^\+[ \t]*\/\*[ \t]*$/ &&
2986             $rawline =~ /^\+[ \t]*\*/ &&
2987             $realline > 2) {
2988             WARN("NETWORKING_BLOCK_COMMENT_STYLE",
2989                  "networking block comments don't use an empty /* line, use /* Comment...\n" . $hereprev);        }
2990 
2991 
2992 # Block comments use * on subsequent lines
2993         if ($prevline =~ /$;[ \t]*$/ &&         #ends in comment
2994             $prevrawline =~ /^\+.*?\/\*/ &&     #starting /*
2995             $prevrawline !~ /\*\/[ \t]*$/ &&        #no trailing */
2996             $rawline =~ /^\+/ &&            #line is new
2997             $rawline !~ /^\+[ \t]*\*/) {        #no leading *
2998             WARN("BLOCK_COMMENT_STYLE",
2999                  "Block comments use * on subsequent lines\n" . $hereprev);
3000         }
3001 
3002 # Block comments use */ on trailing lines
3003         if ($rawline !~ m@^\+[ \t]*\*/[ \t]*$@ &&   #trailing */
3004             $rawline !~ m@^\+.*/\*.*\*/[ \t]*$@ &&  #inline /*...*/
3005             $rawline !~ m@^\+.*\*{2,}/[ \t]*$@ &&   #trailing **/
3006             $rawline =~ m@^\+[ \t]*.+\*\/[ \t]*$@) {    #non blank */
3007             WARN("BLOCK_COMMENT_STYLE",
3008                  "Block comments use a trailing */ on a separate line\n" . $herecurr);
3009         }
3010 
3011 # Block comment * alignment
3012         if ($prevline =~ /$;[ \t]*$/ &&         #ends in comment
3013             $line =~ /^\+[ \t]*$;/ &&           #leading comment
3014             $rawline =~ /^\+[ \t]*\*/ &&        #leading *
3015             (($prevrawline =~ /^\+.*?\/\*/ &&       #leading /*
3016               $prevrawline !~ /\*\/[ \t]*$/) ||     #no trailing */
3017              $prevrawline =~ /^\+[ \t]*\*/)) {      #leading *
3018             my $oldindent;
3019             $prevrawline =~ m@^\+([ \t]*/?)\*@;
3020             if (defined($1)) {
3021                 $oldindent = expand_tabs($1);
3022             } else {
3023                 $prevrawline =~ m@^\+(.*/?)\*@;
3024                 $oldindent = expand_tabs($1);
3025             }
3026             $rawline =~ m@^\+([ \t]*)\*@;
3027             my $newindent = $1;
3028             $newindent = expand_tabs($newindent);
3029             if (length($oldindent) ne length($newindent)) {
3030                 WARN("BLOCK_COMMENT_STYLE",
3031                      "Block comments should align the * on each line\n" . $hereprev);
3032             }
3033         }
3034 
3035 # check for missing blank lines after struct/union declarations
3036 # with exceptions for various attributes and macros
3037         if ($prevline =~ /^[\+ ]};?\s*$/ &&
3038             $line =~ /^\+/ &&
3039             !($line =~ /^\+\s*$/ ||
3040               $line =~ /^\+\s*EXPORT_SYMBOL/ ||
3041               $line =~ /^\+\s*MODULE_/i ||
3042               $line =~ /^\+\s*\#\s*(?:end|elif|else)/ ||
3043               $line =~ /^\+[a-z_]*init/ ||
3044               $line =~ /^\+\s*(?:static\s+)?[A-Z_]*ATTR/ ||
3045               $line =~ /^\+\s*DECLARE/ ||
3046               $line =~ /^\+\s*__setup/)) {
3047             if (CHK("LINE_SPACING",
3048                 "Please use a blank line after function/struct/union/enum declarations\n" . $hereprev) &&
3049                 $fix) {
3050                 fix_insert_line($fixlinenr, "\+");
3051             }
3052         }
3053 
3054 # check for multiple consecutive blank lines
3055         if ($prevline =~ /^[\+ ]\s*$/ &&
3056             $line =~ /^\+\s*$/ &&
3057             $last_blank_line != ($linenr - 1)) {
3058             if (CHK("LINE_SPACING",
3059                 "Please don't use multiple blank lines\n" . $hereprev) &&
3060                 $fix) {
3061                 fix_delete_line($fixlinenr, $rawline);
3062             }
3063 
3064             $last_blank_line = $linenr;
3065         }
3066 
3067 # check for missing blank lines after declarations
3068         if ($sline =~ /^\+\s+\S/ &&         #Not at char 1
3069             # actual declarations
3070             ($prevline =~ /^\+\s+$Declare\s*$Ident\s*[=,;:\[]/ ||
3071             # function pointer declarations
3072              $prevline =~ /^\+\s+$Declare\s*\(\s*\*\s*$Ident\s*\)\s*[=,;:\[\(]/ ||
3073             # foo bar; where foo is some local typedef or #define
3074              $prevline =~ /^\+\s+$Ident(?:\s+|\s*\*\s*)$Ident\s*[=,;\[]/ ||
3075             # known declaration macros
3076              $prevline =~ /^\+\s+$declaration_macros/) &&
3077             # for "else if" which can look like "$Ident $Ident"
3078             !($prevline =~ /^\+\s+$c90_Keywords\b/ ||
3079             # other possible extensions of declaration lines
3080               $prevline =~ /(?:$Compare|$Assignment|$Operators)\s*$/ ||
3081             # not starting a section or a macro "\" extended line
3082               $prevline =~ /(?:\{\s*|\\)$/) &&
3083             # looks like a declaration
3084             !($sline =~ /^\+\s+$Declare\s*$Ident\s*[=,;:\[]/ ||
3085             # function pointer declarations
3086               $sline =~ /^\+\s+$Declare\s*\(\s*\*\s*$Ident\s*\)\s*[=,;:\[\(]/ ||
3087             # foo bar; where foo is some local typedef or #define
3088               $sline =~ /^\+\s+$Ident(?:\s+|\s*\*\s*)$Ident\s*[=,;\[]/ ||
3089             # known declaration macros
3090               $sline =~ /^\+\s+$declaration_macros/ ||
3091             # start of struct or union or enum
3092               $sline =~ /^\+\s+(?:union|struct|enum|typedef)\b/ ||
3093             # start or end of block or continuation of declaration
3094               $sline =~ /^\+\s+(?:$|[\{\}\.\#\"\?\:\(\[])/ ||
3095             # bitfield continuation
3096               $sline =~ /^\+\s+$Ident\s*:\s*\d+\s*[,;]/ ||
3097             # other possible extensions of declaration lines
3098               $sline =~ /^\+\s+\(?\s*(?:$Compare|$Assignment|$Operators)/) &&
3099             # indentation of previous and current line are the same
3100             (($prevline =~ /\+(\s+)\S/) && $sline =~ /^\+$1\S/)) {
3101             if (WARN("LINE_SPACING",
3102                  "Missing a blank line after declarations\n" . $hereprev) &&
3103                 $fix) {
3104                 fix_insert_line($fixlinenr, "\+");
3105             }
3106         }
3107 
3108 # check for spaces at the beginning of a line.
3109 # Exceptions:
3110 #  1) within comments
3111 #  2) indented preprocessor commands
3112 #  3) hanging labels
3113         if ($rawline =~ /^\+ / && $line !~ /^\+ *(?:$;|#|$Ident:)/)  {
3114             my $herevet = "$here\n" . cat_vet($rawline) . "\n";
3115             if (WARN("LEADING_SPACE",
3116                  "please, no spaces at the start of a line\n" . $herevet) &&
3117                 $fix) {
3118                 $fixed[$fixlinenr] =~ s/^\+([ \t]+)/"\+" . tabify($1)/e;
3119             }
3120         }
3121 
3122 # check we are in a valid C source file if not then ignore this hunk
3123         next if ($realfile !~ /\.(h|c)$/);
3124 
3125 # check indentation of any line with a bare else
3126 # (but not if it is a multiple line "if (foo) return bar; else return baz;")
3127 # if the previous line is a break or return and is indented 1 tab more...
3128         if ($sline =~ /^\+([\t]+)(?:}[ \t]*)?else(?:[ \t]*{)?\s*$/) {
3129             my $tabs = length($1) + 1;
3130             if ($prevline =~ /^\+\t{$tabs,$tabs}break\b/ ||
3131                 ($prevline =~ /^\+\t{$tabs,$tabs}return\b/ &&
3132                  defined $lines[$linenr] &&
3133                  $lines[$linenr] !~ /^[ \+]\t{$tabs,$tabs}return/)) {
3134                 WARN("UNNECESSARY_ELSE",
3135                      "else is not generally useful after a break or return\n" . $hereprev);
3136             }
3137         }
3138 
3139 # check indentation of a line with a break;
3140 # if the previous line is a goto or return and is indented the same # of tabs
3141         if ($sline =~ /^\+([\t]+)break\s*;\s*$/) {
3142             my $tabs = $1;
3143             if ($prevline =~ /^\+$tabs(?:goto|return)\b/) {
3144                 WARN("UNNECESSARY_BREAK",
3145                      "break is not useful after a goto or return\n" . $hereprev);
3146             }
3147         }
3148 
3149 # discourage the addition of CONFIG_EXPERIMENTAL in #if(def).
3150         if ($line =~ /^\+\s*\#\s*if.*\bCONFIG_EXPERIMENTAL\b/) {
3151             WARN("CONFIG_EXPERIMENTAL",
3152                  "Use of CONFIG_EXPERIMENTAL is deprecated. For alternatives, see https://lkml.org/lkml/2012/10/23/580\n");
3153         }
3154 
3155 # check for RCS/CVS revision markers
3156         if ($rawline =~ /^\+.*\$(Revision|Log|Id)(?:\$|)/) {
3157             WARN("CVS_KEYWORD",
3158                  "CVS style keyword markers, these will _not_ be updated\n". $herecurr);
3159         }
3160 
3161 # Blackfin: don't use __builtin_bfin_[cs]sync
3162         if ($line =~ /__builtin_bfin_csync/) {
3163             my $herevet = "$here\n" . cat_vet($line) . "\n";
3164             ERROR("CSYNC",
3165                   "use the CSYNC() macro in asm/blackfin.h\n" . $herevet);
3166         }
3167         if ($line =~ /__builtin_bfin_ssync/) {
3168             my $herevet = "$here\n" . cat_vet($line) . "\n";
3169             ERROR("SSYNC",
3170                   "use the SSYNC() macro in asm/blackfin.h\n" . $herevet);
3171         }
3172 
3173 # check for old HOTPLUG __dev<foo> section markings
3174         if ($line =~ /\b(__dev(init|exit)(data|const|))\b/) {
3175             WARN("HOTPLUG_SECTION",
3176                  "Using $1 is unnecessary\n" . $herecurr);
3177         }
3178 
3179 # Check for potential 'bare' types
3180         my ($stat, $cond, $line_nr_next, $remain_next, $off_next,
3181             $realline_next);
3182 #print "LINE<$line>\n";
3183         if ($linenr >= $suppress_statement &&
3184             $realcnt && $sline =~ /.\s*\S/) {
3185             ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
3186                 ctx_statement_block($linenr, $realcnt, 0);
3187             $stat =~ s/\n./\n /g;
3188             $cond =~ s/\n./\n /g;
3189 
3190 #print "linenr<$linenr> <$stat>\n";
3191             # If this statement has no statement boundaries within
3192             # it there is no point in retrying a statement scan
3193             # until we hit end of it.
3194             my $frag = $stat; $frag =~ s/;+\s*$//;
3195             if ($frag !~ /(?:{|;)/) {
3196 #print "skip<$line_nr_next>\n";
3197                 $suppress_statement = $line_nr_next;
3198             }
3199 
3200             # Find the real next line.
3201             $realline_next = $line_nr_next;
3202             if (defined $realline_next &&
3203                 (!defined $lines[$realline_next - 1] ||
3204                  substr($lines[$realline_next - 1], $off_next) =~ /^\s*$/)) {
3205                 $realline_next++;
3206             }
3207 
3208             my $s = $stat;
3209             $s =~ s/{.*$//s;
3210 
3211             # Ignore goto labels.
3212             if ($s =~ /$Ident:\*$/s) {
3213 
3214             # Ignore functions being called
3215             } elsif ($s =~ /^.\s*$Ident\s*\(/s) {
3216 
3217             } elsif ($s =~ /^.\s*else\b/s) {
3218 
3219             # declarations always start with types
3220             } 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) {
3221                 my $type = $1;
3222                 $type =~ s/\s+/ /g;
3223                 possible($type, "A:" . $s);
3224 
3225             # definitions in global scope can only start with types
3226             } elsif ($s =~ /^.(?:$Storage\s+)?(?:$Inline\s+)?(?:const\s+)?($Ident)\b\s*(?!:)/s) {
3227                 possible($1, "B:" . $s);
3228             }
3229 
3230             # any (foo ... *) is a pointer cast, and foo is a type
3231             while ($s =~ /\(($Ident)(?:\s+$Sparse)*[\s\*]+\s*\)/sg) {
3232                 possible($1, "C:" . $s);
3233             }
3234 
3235             # Check for any sort of function declaration.
3236             # int foo(something bar, other baz);
3237             # void (*store_gdt)(x86_descr_ptr *);
3238             if ($prev_values eq 'E' && $s =~ /^(.(?:typedef\s*)?(?:(?:$Storage|$Inline)\s*)*\s*$Type\s*(?:\b$Ident|\(\*\s*$Ident\))\s*)\(/s) {
3239                 my ($name_len) = length($1);
3240 
3241                 my $ctx = $s;
3242                 substr($ctx, 0, $name_len + 1, '');
3243                 $ctx =~ s/\)[^\)]*$//;
3244 
3245                 for my $arg (split(/\s*,\s*/, $ctx)) {
3246                     if ($arg =~ /^(?:const\s+)?($Ident)(?:\s+$Sparse)*\s*\**\s*(:?\b$Ident)?$/s || $arg =~ /^($Ident)$/s) {
3247 
3248                         possible($1, "D:" . $s);
3249                     }
3250                 }
3251             }
3252 
3253         }
3254 
3255 #
3256 # Checks which may be anchored in the context.
3257 #
3258 
3259 # Check for switch () and associated case and default
3260 # statements should be at the same indent.
3261         if ($line=~/\bswitch\s*\(.*\)/) {
3262             my $err = '';
3263             my $sep = '';
3264             my @ctx = ctx_block_outer($linenr, $realcnt);
3265             shift(@ctx);
3266             for my $ctx (@ctx) {
3267                 my ($clen, $cindent) = line_stats($ctx);
3268                 if ($ctx =~ /^\+\s*(case\s+|default:)/ &&
3269                             $indent != $cindent) {
3270                     $err .= "$sep$ctx\n";
3271                     $sep = '';
3272                 } else {
3273                     $sep = "[...]\n";
3274                 }
3275             }
3276             if ($err ne '') {
3277                 ERROR("SWITCH_CASE_INDENT_LEVEL",
3278                       "switch and case should be at the same indent\n$hereline$err");
3279             }
3280         }
3281 
3282 # if/while/etc brace do not go on next line, unless defining a do while loop,
3283 # or if that brace on the next line is for something else
3284         if ($line =~ /(.*)\b((?:if|while|for|switch|(?:[a-z_]+|)for_each[a-z_]+)\s*\(|do\b|else\b)/ && $line !~ /^.\s*\#/) {
3285             my $pre_ctx = "$1$2";
3286 
3287             my ($level, @ctx) = ctx_statement_level($linenr, $realcnt, 0);
3288 
3289             if ($line =~ /^\+\t{6,}/) {
3290                 WARN("DEEP_INDENTATION",
3291                      "Too many leading tabs - consider code refactoring\n" . $herecurr);
3292             }
3293 
3294             my $ctx_cnt = $realcnt - $#ctx - 1;
3295             my $ctx = join("\n", @ctx);
3296 
3297             my $ctx_ln = $linenr;
3298             my $ctx_skip = $realcnt;
3299 
3300             while ($ctx_skip > $ctx_cnt || ($ctx_skip == $ctx_cnt &&
3301                     defined $lines[$ctx_ln - 1] &&
3302                     $lines[$ctx_ln - 1] =~ /^-/)) {
3303                 ##print "SKIP<$ctx_skip> CNT<$ctx_cnt>\n";
3304                 $ctx_skip-- if (!defined $lines[$ctx_ln - 1] || $lines[$ctx_ln - 1] !~ /^-/);
3305                 $ctx_ln++;
3306             }
3307 
3308             #print "realcnt<$realcnt> ctx_cnt<$ctx_cnt>\n";
3309             #print "pre<$pre_ctx>\nline<$line>\nctx<$ctx>\nnext<$lines[$ctx_ln - 1]>\n";
3310 
3311             if ($ctx !~ /{\s*/ && defined($lines[$ctx_ln - 1]) && $lines[$ctx_ln - 1] =~ /^\+\s*{/) {
3312                 ERROR("OPEN_BRACE",
3313                       "that open brace { should be on the previous line\n" .
3314                     "$here\n$ctx\n$rawlines[$ctx_ln - 1]\n");
3315             }
3316             if ($level == 0 && $pre_ctx !~ /}\s*while\s*\($/ &&
3317                 $ctx =~ /\)\s*\;\s*$/ &&
3318                 defined $lines[$ctx_ln - 1])
3319             {
3320                 my ($nlength, $nindent) = line_stats($lines[$ctx_ln - 1]);
3321                 if ($nindent > $indent) {
3322                     WARN("TRAILING_SEMICOLON",
3323                          "trailing semicolon indicates no statements, indent implies otherwise\n" .
3324                         "$here\n$ctx\n$rawlines[$ctx_ln - 1]\n");
3325                 }
3326             }
3327         }
3328 
3329 # Check relative indent for conditionals and blocks.
3330         if ($line =~ /\b(?:(?:if|while|for|(?:[a-z_]+|)for_each[a-z_]+)\s*\(|do\b)/ && $line !~ /^.\s*#/ && $line !~ /\}\s*while\s*/) {
3331             ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
3332                 ctx_statement_block($linenr, $realcnt, 0)
3333                     if (!defined $stat);
3334             my ($s, $c) = ($stat, $cond);
3335 
3336             substr($s, 0, length($c), '');
3337 
3338             # remove inline comments
3339             $s =~ s/$;/ /g;
3340             $c =~ s/$;/ /g;
3341 
3342             # Find out how long the conditional actually is.
3343             my @newlines = ($c =~ /\n/gs);
3344             my $cond_lines = 1 + $#newlines;
3345 
3346             # Make sure we remove the line prefixes as we have
3347             # none on the first line, and are going to readd them
3348             # where necessary.
3349             $s =~ s/\n./\n/gs;
3350             while ($s =~ /\n\s+\\\n/) {
3351                 $cond_lines += $s =~ s/\n\s+\\\n/\n/g;
3352             }
3353 
3354             # We want to check the first line inside the block
3355             # starting at the end of the conditional, so remove:
3356             #  1) any blank line termination
3357             #  2) any opening brace { on end of the line
3358             #  3) any do (...) {
3359             my $continuation = 0;
3360             my $check = 0;
3361             $s =~ s/^.*\bdo\b//;
3362             $s =~ s/^\s*{//;
3363             if ($s =~ s/^\s*\\//) {
3364                 $continuation = 1;
3365             }
3366             if ($s =~ s/^\s*?\n//) {
3367                 $check = 1;
3368                 $cond_lines++;
3369             }
3370 
3371             # Also ignore a loop construct at the end of a
3372             # preprocessor statement.
3373             if (($prevline =~ /^.\s*#\s*define\s/ ||
3374                 $prevline =~ /\\\s*$/) && $continuation == 0) {
3375                 $check = 0;
3376             }
3377 
3378             my $cond_ptr = -1;
3379             $continuation = 0;
3380             while ($cond_ptr != $cond_lines) {
3381                 $cond_ptr = $cond_lines;
3382 
3383                 # If we see an #else/#elif then the code
3384                 # is not linear.
3385                 if ($s =~ /^\s*\#\s*(?:else|elif)/) {
3386                     $check = 0;
3387                 }
3388 
3389                 # Ignore:
3390                 #  1) blank lines, they should be at 0,
3391                 #  2) preprocessor lines, and
3392                 #  3) labels.
3393                 if ($continuation ||
3394                     $s =~ /^\s*?\n/ ||
3395                     $s =~ /^\s*#\s*?/ ||
3396                     $s =~ /^\s*$Ident\s*:/) {
3397                     $continuation = ($s =~ /^.*?\\\n/) ? 1 : 0;
3398                     if ($s =~ s/^.*?\n//) {
3399                         $cond_lines++;
3400                     }
3401                 }
3402             }
3403 
3404             my (undef, $sindent) = line_stats("+" . $s);
3405             my $stat_real = raw_line($linenr, $cond_lines);
3406 
3407             # Check if either of these lines are modified, else
3408             # this is not this patch's fault.
3409             if (!defined($stat_real) ||
3410                 $stat !~ /^\+/ && $stat_real !~ /^\+/) {
3411                 $check = 0;
3412             }
3413             if (defined($stat_real) && $cond_lines > 1) {
3414                 $stat_real = "[...]\n$stat_real";
3415             }
3416 
3417             #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";
3418 
3419             if ($check && $s ne '' &&
3420                 (($sindent % 8) != 0 ||
3421                  ($sindent < $indent) ||
3422                  ($sindent > $indent + 8))) {
3423                 WARN("SUSPECT_CODE_INDENT",
3424                      "suspect code indent for conditional statements ($indent, $sindent)\n" . $herecurr . "$stat_real\n");
3425             }
3426         }
3427 
3428         # Track the 'values' across context and added lines.
3429         my $opline = $line; $opline =~ s/^./ /;
3430         my ($curr_values, $curr_vars) =
3431                 annotate_values($opline . "\n", $prev_values);
3432         $curr_values = $prev_values . $curr_values;
3433         if ($dbg_values) {
3434             my $outline = $opline; $outline =~ s/\t/ /g;
3435             print "$linenr > .$outline\n";
3436             print "$linenr > $curr_values\n";
3437             print "$linenr >  $curr_vars\n";
3438         }
3439         $prev_values = substr($curr_values, -1);
3440 
3441 #ignore lines not being added
3442         next if ($line =~ /^[^\+]/);
3443 
3444 # check for dereferences that span multiple lines
3445         if ($prevline =~ /^\+.*$Lval\s*(?:\.|->)\s*$/ &&
3446             $line =~ /^\+\s*(?!\#\s*(?!define\s+|if))\s*$Lval/) {
3447             $prevline =~ /($Lval\s*(?:\.|->))\s*$/;
3448             my $ref = $1;
3449             $line =~ /^.\s*($Lval)/;
3450             $ref .= $1;
3451             $ref =~ s/\s//g;
3452             WARN("MULTILINE_DEREFERENCE",
3453                  "Avoid multiple line dereference - prefer '$ref'\n" . $hereprev);
3454         }
3455 
3456 # check for declarations of signed or unsigned without int
3457         while ($line =~ m{\b($Declare)\s*(?!char\b|short\b|int\b|long\b)\s*($Ident)?\s*[=,;\[\)\(]}g) {
3458             my $type = $1;
3459             my $var = $2;
3460             $var = "" if (!defined $var);
3461             if ($type =~ /^(?:(?:$Storage|$Inline|$Attribute)\s+)*((?:un)?signed)((?:\s*\*)*)\s*$/) {
3462                 my $sign = $1;
3463                 my $pointer = $2;
3464 
3465                 $pointer = "" if (!defined $pointer);
3466 
3467                 if (WARN("UNSPECIFIED_INT",
3468                      "Prefer '" . trim($sign) . " int" . rtrim($pointer) . "' to bare use of '$sign" . rtrim($pointer) . "'\n" . $herecurr) &&
3469                     $fix) {
3470                     my $decl = trim($sign) . " int ";
3471                     my $comp_pointer = $pointer;
3472                     $comp_pointer =~ s/\s//g;
3473                     $decl .= $comp_pointer;
3474                     $decl = rtrim($decl) if ($var eq "");
3475                     $fixed[$fixlinenr] =~ s@\b$sign\s*\Q$pointer\E\s*$var\b@$decl$var@;
3476                 }
3477             }
3478         }
3479 
3480 # TEST: allow direct testing of the type matcher.
3481         if ($dbg_type) {
3482             if ($line =~ /^.\s*$Declare\s*$/) {
3483                 ERROR("TEST_TYPE",
3484                       "TEST: is type\n" . $herecurr);
3485             } elsif ($dbg_type > 1 && $line =~ /^.+($Declare)/) {
3486                 ERROR("TEST_NOT_TYPE",
3487                       "TEST: is not type ($1 is)\n". $herecurr);
3488             }
3489             next;
3490         }
3491 # TEST: allow direct testing of the attribute matcher.
3492         if ($dbg_attr) {
3493             if ($line =~ /^.\s*$Modifier\s*$/) {
3494                 ERROR("TEST_ATTR",
3495                       "TEST: is attr\n" . $herecurr);
3496             } elsif ($dbg_attr > 1 && $line =~ /^.+($Modifier)/) {
3497                 ERROR("TEST_NOT_ATTR",
3498                       "TEST: is not attr ($1 is)\n". $herecurr);
3499             }
3500             next;
3501         }
3502 
3503 # check for initialisation to aggregates open brace on the next line
3504         if ($line =~ /^.\s*{/ &&
3505             $prevline =~ /(?:^|[^=])=\s*$/) {
3506             if (ERROR("OPEN_BRACE",
3507                   "that open brace { should be on the previous line\n" . $hereprev) &&
3508                 $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
3509                 fix_delete_line($fixlinenr - 1, $prevrawline);
3510                 fix_delete_line($fixlinenr, $rawline);
3511                 my $fixedline = $prevrawline;
3512                 $fixedline =~ s/\s*=\s*$/ = {/;
3513                 fix_insert_line($fixlinenr, $fixedline);
3514                 $fixedline = $line;
3515                 $fixedline =~ s/^(.\s*){\s*/$1/;
3516                 fix_insert_line($fixlinenr, $fixedline);
3517             }
3518         }
3519 
3520 #
3521 # Checks which are anchored on the added line.
3522 #
3523 
3524 # check for malformed paths in #include statements (uses RAW line)
3525         if ($rawline =~ m{^.\s*\#\s*include\s+[<"](.*)[">]}) {
3526             my $path = $1;
3527             if ($path =~ m{//}) {
3528                 ERROR("MALFORMED_INCLUDE",
3529                       "malformed #include filename\n" . $herecurr);
3530             }
3531             if ($path =~ "^uapi/" && $realfile =~ m@\binclude/uapi/@) {
3532                 ERROR("UAPI_INCLUDE",
3533                       "No #include in ...include/uapi/... should use a uapi/ path prefix\n" . $herecurr);
3534             }
3535         }
3536 
3537 # no C99 // comments
3538         if ($line =~ m{//}) {
3539             if (ERROR("C99_COMMENTS",
3540                   "do not use C99 // comments\n" . $herecurr) &&
3541                 $fix) {
3542                 my $line = $fixed[$fixlinenr];
3543                 if ($line =~ /\/\/(.*)$/) {
3544                     my $comment = trim($1);
3545                     $fixed[$fixlinenr] =~ s@\/\/(.*)$@/\* $comment \*/@;
3546                 }
3547             }
3548         }
3549         # Remove C99 comments.
3550         $line =~ s@//.*@@;
3551         $opline =~ s@//.*@@;
3552 
3553 # EXPORT_SYMBOL should immediately follow the thing it is exporting, consider
3554 # the whole statement.
3555 #print "APW <$lines[$realline_next - 1]>\n";
3556         if (defined $realline_next &&
3557             exists $lines[$realline_next - 1] &&
3558             !defined $suppress_export{$realline_next} &&
3559             ($lines[$realline_next - 1] =~ /EXPORT_SYMBOL.*\((.*)\)/ ||
3560              $lines[$realline_next - 1] =~ /EXPORT_UNUSED_SYMBOL.*\((.*)\)/)) {
3561             # Handle definitions which produce identifiers with
3562             # a prefix:
3563             #   XXX(foo);
3564             #   EXPORT_SYMBOL(something_foo);
3565             my $name = $1;
3566             if ($stat =~ /^(?:.\s*}\s*\n)?.([A-Z_]+)\s*\(\s*($Ident)/ &&
3567                 $name =~ /^${Ident}_$2/) {
3568 #print "FOO C name<$name>\n";
3569                 $suppress_export{$realline_next} = 1;
3570 
3571             } elsif ($stat !~ /(?:
3572                 \n.}\s*$|
3573                 ^.DEFINE_$Ident\(\Q$name\E\)|
3574                 ^.DECLARE_$Ident\(\Q$name\E\)|
3575                 ^.LIST_HEAD\(\Q$name\E\)|
3576                 ^.(?:$Storage\s+)?$Type\s*\(\s*\*\s*\Q$name\E\s*\)\s*\(|
3577                 \b\Q$name\E(?:\s+$Attribute)*\s*(?:;|=|\[|\()
3578                 )/x) {
3579 #print "FOO A<$lines[$realline_next - 1]> stat<$stat> name<$name>\n";
3580                 $suppress_export{$realline_next} = 2;
3581             } else {
3582                 $suppress_export{$realline_next} = 1;
3583             }
3584         }
3585         if (!defined $suppress_export{$linenr} &&
3586             $prevline =~ /^.\s*$/ &&
3587             ($line =~ /EXPORT_SYMBOL.*\((.*)\)/ ||
3588              $line =~ /EXPORT_UNUSED_SYMBOL.*\((.*)\)/)) {
3589 #print "FOO B <$lines[$linenr - 1]>\n";
3590             $suppress_export{$linenr} = 2;
3591         }
3592         if (defined $suppress_export{$linenr} &&
3593             $suppress_export{$linenr} == 2) {
3594             WARN("EXPORT_SYMBOL",
3595                  "EXPORT_SYMBOL(foo); should immediately follow its function/variable\n" . $herecurr);
3596         }
3597 
3598 # check for global initialisers.
3599         if ($line =~ /^\+$Type\s*$Ident(?:\s+$Modifier)*\s*=\s*($zero_initializer)\s*;/) {
3600             if (ERROR("GLOBAL_INITIALISERS",
3601                   "do not initialise globals to $1\n" . $herecurr) &&
3602                 $fix) {
3603                 $fixed[$fixlinenr] =~ s/(^.$Type\s*$Ident(?:\s+$Modifier)*)\s*=\s*$zero_initializer\s*;/$1;/;
3604             }
3605         }
3606 # check for static initialisers.
3607         if ($line =~ /^\+.*\bstatic\s.*=\s*($zero_initializer)\s*;/) {
3608             if (ERROR("INITIALISED_STATIC",
3609                   "do not initialise statics to $1\n" .
3610                       $herecurr) &&
3611                 $fix) {
3612                 $fixed[$fixlinenr] =~ s/(\bstatic\s.*?)\s*=\s*$zero_initializer\s*;/$1;/;
3613             }
3614         }
3615 
3616 # check for misordered declarations of char/short/int/long with signed/unsigned
3617         while ($sline =~ m{(\b$TypeMisordered\b)}g) {
3618             my $tmp = trim($1);
3619             WARN("MISORDERED_TYPE",
3620                  "type '$tmp' should be specified in [[un]signed] [short|int|long|long long] order\n" . $herecurr);
3621         }
3622 
3623 # check for static const char * arrays.
3624         if ($line =~ /\bstatic\s+const\s+char\s*\*\s*(\w+)\s*\[\s*\]\s*=\s*/) {
3625             WARN("STATIC_CONST_CHAR_ARRAY",
3626                  "static const char * array should probably be static const char * const\n" .
3627                 $herecurr);
3628                }
3629 
3630 # check for static char foo[] = "bar" declarations.
3631         if ($line =~ /\bstatic\s+char\s+(\w+)\s*\[\s*\]\s*=\s*"/) {
3632             WARN("STATIC_CONST_CHAR_ARRAY",
3633                  "static char array declaration should probably be static const char\n" .
3634                 $herecurr);
3635                }
3636 
3637 # check for const <foo> const where <foo> is not a pointer or array type
3638         if ($sline =~ /\bconst\s+($BasicType)\s+const\b/) {
3639             my $found = $1;
3640             if ($sline =~ /\bconst\s+\Q$found\E\s+const\b\s*\*/) {
3641                 WARN("CONST_CONST",
3642                      "'const $found const *' should probably be 'const $found * const'\n" . $herecurr);
3643             } elsif ($sline !~ /\bconst\s+\Q$found\E\s+const\s+\w+\s*\[/) {
3644                 WARN("CONST_CONST",
3645                      "'const $found const' should probably be 'const $found'\n" . $herecurr);
3646             }
3647         }
3648 
3649 # check for non-global char *foo[] = {"bar", ...} declarations.
3650         if ($line =~ /^.\s+(?:static\s+|const\s+)?char\s+\*\s*\w+\s*\[\s*\]\s*=\s*\{/) {
3651             WARN("STATIC_CONST_CHAR_ARRAY",
3652                  "char * array declaration might be better as static const\n" .
3653                 $herecurr);
3654                }
3655 
3656 # check for sizeof(foo)/sizeof(foo[0]) that could be ARRAY_SIZE(foo)
3657         if ($line =~ m@\bsizeof\s*\(\s*($Lval)\s*\)@) {
3658             my $array = $1;
3659             if ($line =~ m@\b(sizeof\s*\(\s*\Q$array\E\s*\)\s*/\s*sizeof\s*\(\s*\Q$array\E\s*\[\s*0\s*\]\s*\))@) {
3660                 my $array_div = $1;
3661                 if (WARN("ARRAY_SIZE",
3662                      "Prefer ARRAY_SIZE($array)\n" . $herecurr) &&
3663                     $fix) {
3664                     $fixed[$fixlinenr] =~ s/\Q$array_div\E/ARRAY_SIZE($array)/;
3665                 }
3666             }
3667         }
3668 
3669 # check for function declarations without arguments like "int foo()"
3670         if ($line =~ /(\b$Type\s+$Ident)\s*\(\s*\)/) {
3671             if (ERROR("FUNCTION_WITHOUT_ARGS",
3672                   "Bad function definition - $1() should probably be $1(void)\n" . $herecurr) &&
3673                 $fix) {
3674                 $fixed[$fixlinenr] =~ s/(\b($Type)\s+($Ident))\s*\(\s*\)/$2 $3(void)/;
3675             }
3676         }
3677 
3678 # check for new typedefs, only function parameters and sparse annotations
3679 # make sense.
3680         if ($line =~ /\btypedef\s/ &&
3681             $line !~ /\btypedef\s+$Type\s*\(\s*\*?$Ident\s*\)\s*\(/ &&
3682             $line !~ /\btypedef\s+$Type\s+$Ident\s*\(/ &&
3683             $line !~ /\b$typeTypedefs\b/ &&
3684             $line !~ /\b__bitwise\b/) {
3685             WARN("NEW_TYPEDEFS",
3686                  "do not add new typedefs\n" . $herecurr);
3687         }
3688 
3689 # * goes on variable not on type
3690         # (char*[ const])
3691         while ($line =~ m{(\($NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)\))}g) {
3692             #print "AA<$1>\n";
3693             my ($ident, $from, $to) = ($1, $2, $2);
3694 
3695             # Should start with a space.
3696             $to =~ s/^(\S)/ $1/;
3697             # Should not end with a space.
3698             $to =~ s/\s+$//;
3699             # '*'s should not have spaces between.
3700             while ($to =~ s/\*\s+\*/\*\*/) {
3701             }
3702 
3703 ##          print "1: from<$from> to<$to> ident<$ident>\n";
3704             if ($from ne $to) {
3705                 if (ERROR("POINTER_LOCATION",
3706                       "\"(foo$from)\" should be \"(foo$to)\"\n" .  $herecurr) &&
3707                     $fix) {
3708                     my $sub_from = $ident;
3709                     my $sub_to = $ident;
3710                     $sub_to =~ s/\Q$from\E/$to/;
3711                     $fixed[$fixlinenr] =~
3712                         s@\Q$sub_from\E@$sub_to@;
3713                 }
3714             }
3715         }
3716         while ($line =~ m{(\b$NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)($Ident))}g) {
3717             #print "BB<$1>\n";
3718             my ($match, $from, $to, $ident) = ($1, $2, $2, $3);
3719 
3720             # Should start with a space.
3721             $to =~ s/^(\S)/ $1/;
3722             # Should not end with a space.
3723             $to =~ s/\s+$//;
3724             # '*'s should not have spaces between.
3725             while ($to =~ s/\*\s+\*/\*\*/) {
3726             }
3727             # Modifiers should have spaces.
3728             $to =~ s/(\b$Modifier$)/$1 /;
3729 
3730 ##          print "2: from<$from> to<$to> ident<$ident>\n";
3731             if ($from ne $to && $ident !~ /^$Modifier$/) {
3732                 if (ERROR("POINTER_LOCATION",
3733                       "\"foo${from}bar\" should be \"foo${to}bar\"\n" .  $herecurr) &&
3734                     $fix) {
3735 
3736                     my $sub_from = $match;
3737                     my $sub_to = $match;
3738                     $sub_to =~ s/\Q$from\E/$to/;
3739                     $fixed[$fixlinenr] =~
3740                         s@\Q$sub_from\E@$sub_to@;
3741                 }
3742             }
3743         }
3744 
3745 # avoid BUG() or BUG_ON()
3746         if ($line =~ /\b(?:BUG|BUG_ON)\b/) {
3747             my $msg_type = \&WARN;
3748             $msg_type = \&CHK if ($file);
3749             &{$msg_type}("AVOID_BUG",
3750                      "Avoid crashing the kernel - try using WARN_ON & recovery code rather than BUG() or BUG_ON()\n" . $herecurr);
3751         }
3752 
3753 # avoid LINUX_VERSION_CODE
3754         if ($line =~ /\bLINUX_VERSION_CODE\b/) {
3755             WARN("LINUX_VERSION_CODE",
3756                  "LINUX_VERSION_CODE should be avoided, code should be for the version to which it is merged\n" . $herecurr);
3757         }
3758 
3759 # check for uses of printk_ratelimit
3760         if ($line =~ /\bprintk_ratelimit\s*\(/) {
3761             WARN("PRINTK_RATELIMITED",
3762                  "Prefer printk_ratelimited or pr_<level>_ratelimited to printk_ratelimit\n" . $herecurr);
3763         }
3764 
3765 # printk should use KERN_* levels.  Note that follow on printk's on the
3766 # same line do not need a level, so we use the current block context
3767 # to try and find and validate the current printk.  In summary the current
3768 # printk includes all preceding printk's which have no newline on the end.
3769 # we assume the first bad printk is the one to report.
3770         if ($line =~ /\bprintk\((?!KERN_)\s*"/) {
3771             my $ok = 0;
3772             for (my $ln = $linenr - 1; $ln >= $first_line; $ln--) {
3773                 #print "CHECK<$lines[$ln - 1]\n";
3774                 # we have a preceding printk if it ends
3775                 # with "\n" ignore it, else it is to blame
3776                 if ($lines[$ln - 1] =~ m{\bprintk\(}) {
3777                     if ($rawlines[$ln - 1] !~ m{\\n"}) {
3778                         $ok = 1;
3779                     }
3780                     last;
3781                 }
3782             }
3783             if ($ok == 0) {
3784                 WARN("PRINTK_WITHOUT_KERN_LEVEL",
3785                      "printk() should include KERN_ facility level\n" . $herecurr);
3786             }
3787         }
3788 
3789         if ($line =~ /\bprintk\s*\(\s*KERN_([A-Z]+)/) {
3790             my $orig = $1;
3791             my $level = lc($orig);
3792             $level = "warn" if ($level eq "warning");
3793             my $level2 = $level;
3794             $level2 = "dbg" if ($level eq "debug");
3795             WARN("PREFER_PR_LEVEL",
3796                  "Prefer [subsystem eg: netdev]_$level2([subsystem]dev, ... then dev_$level2(dev, ... then pr_$level(...  to printk(KERN_$orig ...\n" . $herecurr);
3797         }
3798 
3799         if ($line =~ /\bpr_warning\s*\(/) {
3800             if (WARN("PREFER_PR_LEVEL",
3801                  "Prefer pr_warn(... to pr_warning(...\n" . $herecurr) &&
3802                 $fix) {
3803                 $fixed[$fixlinenr] =~
3804                     s/\bpr_warning\b/pr_warn/;
3805             }
3806         }
3807 
3808         if ($line =~ /\bdev_printk\s*\(\s*KERN_([A-Z]+)/) {
3809             my $orig = $1;
3810             my $level = lc($orig);
3811             $level = "warn" if ($level eq "warning");
3812             $level = "dbg" if ($level eq "debug");
3813             WARN("PREFER_DEV_LEVEL",
3814                  "Prefer dev_$level(... to dev_printk(KERN_$orig, ...\n" . $herecurr);
3815         }
3816 
3817 # ENOSYS means "bad syscall nr" and nothing else.  This will have a small
3818 # number of false positives, but assembly files are not checked, so at
3819 # least the arch entry code will not trigger this warning.
3820         if ($line =~ /\bENOSYS\b/) {
3821             WARN("ENOSYS",
3822                  "ENOSYS means 'invalid syscall nr' and nothing else\n" . $herecurr);
3823         }
3824 
3825 # function brace can't be on same line, except for #defines of do while,
3826 # or if closed on same line
3827         if (($line=~/$Type\s*$Ident\(.*\).*\s*{/) and
3828             !($line=~/\#\s*define.*do\s\{/) and !($line=~/}/)) {
3829             if (ERROR("OPEN_BRACE",
3830                   "open brace '{' following function declarations go on the next line\n" . $herecurr) &&
3831                 $fix) {
3832                 fix_delete_line($fixlinenr, $rawline);
3833                 my $fixed_line = $rawline;
3834                 $fixed_line =~ /(^..*$Type\s*$Ident\(.*\)\s*){(.*)$/;
3835                 my $line1 = $1;
3836                 my $line2 = $2;
3837                 fix_insert_line($fixlinenr, ltrim($line1));
3838                 fix_insert_line($fixlinenr, "\+{");
3839                 if ($line2 !~ /^\s*$/) {
3840                     fix_insert_line($fixlinenr, "\+\t" . trim($line2));
3841                 }
3842             }
3843         }
3844 
3845 # open braces for enum, union and struct go on the same line.
3846         if ($line =~ /^.\s*{/ &&
3847             $prevline =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident)?\s*$/) {
3848             if (ERROR("OPEN_BRACE",
3849                   "open brace '{' following $1 go on the same line\n" . $hereprev) &&
3850                 $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
3851                 fix_delete_line($fixlinenr - 1, $prevrawline);
3852                 fix_delete_line($fixlinenr, $rawline);
3853                 my $fixedline = rtrim($prevrawline) . " {";
3854                 fix_insert_line($fixlinenr, $fixedline);
3855                 $fixedline = $rawline;
3856                 $fixedline =~ s/^(.\s*){\s*/$1\t/;
3857                 if ($fixedline !~ /^\+\s*$/) {
3858                     fix_insert_line($fixlinenr, $fixedline);
3859                 }
3860             }
3861         }
3862 
3863 # missing space after union, struct or enum definition
3864         if ($line =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident){1,2}[=\{]/) {
3865             if (WARN("SPACING",
3866                  "missing space after $1 definition\n" . $herecurr) &&
3867                 $fix) {
3868                 $fixed[$fixlinenr] =~
3869                     s/^(.\s*(?:typedef\s+)?(?:enum|union|struct)(?:\s+$Ident){1,2})([=\{])/$1 $2/;
3870             }
3871         }
3872 
3873 # Function pointer declarations
3874 # check spacing between type, funcptr, and args
3875 # canonical declaration is "type (*funcptr)(args...)"
3876         if ($line =~ /^.\s*($Declare)\((\s*)\*(\s*)($Ident)(\s*)\)(\s*)\(/) {
3877             my $declare = $1;
3878             my $pre_pointer_space = $2;
3879             my $post_pointer_space = $3;
3880             my $funcname = $4;
3881             my $post_funcname_space = $5;
3882             my $pre_args_space = $6;
3883 
3884 # the $Declare variable will capture all spaces after the type
3885 # so check it for a missing trailing missing space but pointer return types
3886 # don't need a space so don't warn for those.
3887             my $post_declare_space = "";
3888             if ($declare =~ /(\s+)$/) {
3889                 $post_declare_space = $1;
3890                 $declare = rtrim($declare);
3891             }
3892             if ($declare !~ /\*$/ && $post_declare_space =~ /^$/) {
3893                 WARN("SPACING",
3894                      "missing space after return type\n" . $herecurr);
3895                 $post_declare_space = " ";
3896             }
3897 
3898 # unnecessary space "type  (*funcptr)(args...)"
3899 # This test is not currently implemented because these declarations are
3900 # equivalent to
3901 #   int  foo(int bar, ...)
3902 # and this is form shouldn't/doesn't generate a checkpatch warning.
3903 #
3904 #           elsif ($declare =~ /\s{2,}$/) {
3905 #               WARN("SPACING",
3906 #                    "Multiple spaces after return type\n" . $herecurr);
3907 #           }
3908 
3909 # unnecessary space "type ( *funcptr)(args...)"
3910             if (defined $pre_pointer_space &&
3911                 $pre_pointer_space =~ /^\s/) {
3912                 WARN("SPACING",
3913                      "Unnecessary space after function pointer open parenthesis\n" . $herecurr);
3914             }
3915 
3916 # unnecessary space "type (* funcptr)(args...)"
3917             if (defined $post_pointer_space &&
3918                 $post_pointer_space =~ /^\s/) {
3919                 WARN("SPACING",
3920                      "Unnecessary space before function pointer name\n" . $herecurr);
3921             }
3922 
3923 # unnecessary space "type (*funcptr )(args...)"
3924             if (defined $post_funcname_space &&
3925                 $post_funcname_space =~ /^\s/) {
3926                 WARN("SPACING",
3927                      "Unnecessary space after function pointer name\n" . $herecurr);
3928             }
3929 
3930 # unnecessary space "type (*funcptr) (args...)"
3931             if (defined $pre_args_space &&
3932                 $pre_args_space =~ /^\s/) {
3933                 WARN("SPACING",
3934                      "Unnecessary space before function pointer arguments\n" . $herecurr);
3935             }
3936 
3937             if (show_type("SPACING") && $fix) {
3938                 $fixed[$fixlinenr] =~
3939                     s/^(.\s*)$Declare\s*\(\s*\*\s*$Ident\s*\)\s*\(/$1 . $declare . $post_declare_space . '(*' . $funcname . ')('/ex;
3940             }
3941         }
3942 
3943 # check for spacing round square brackets; allowed:
3944 #  1. with a type on the left -- int [] a;
3945 #  2. at the beginning of a line for slice initialisers -- [0...10] = 5,
3946 #  3. inside a curly brace -- = { [0...10] = 5 }
3947         while ($line =~ /(.*?\s)\[/g) {
3948             my ($where, $prefix) = ($-[1], $1);
3949             if ($prefix !~ /$Type\s+$/ &&
3950                 ($where != 0 || $prefix !~ /^.\s+$/) &&
3951                 $prefix !~ /[{,]\s+$/) {
3952                 if (ERROR("BRACKET_SPACE",
3953                       "space prohibited before open square bracket '['\n" . $herecurr) &&
3954                     $fix) {
3955                     $fixed[$fixlinenr] =~
3956                     s/^(\+.*?)\s+\[/$1\[/;
3957                 }
3958             }
3959         }
3960 
3961 # check for spaces between functions and their parentheses.
3962         while ($line =~ /($Ident)\s+\(/g) {
3963             my $name = $1;
3964             my $ctx_before = substr($line, 0, $-[1]);
3965             my $ctx = "$ctx_before$name";
3966 
3967             # Ignore those directives where spaces _are_ permitted.
3968             if ($name =~ /^(?:
3969                 if|for|while|switch|return|case|
3970                 volatile|__volatile__|
3971                 __attribute__|format|__extension__|
3972                 asm|__asm__)$/x)
3973             {
3974             # cpp #define statements have non-optional spaces, ie
3975             # if there is a space between the name and the open
3976             # parenthesis it is simply not a parameter group.
3977             } elsif ($ctx_before =~ /^.\s*\#\s*define\s*$/) {
3978 
3979             # cpp #elif statement condition may start with a (
3980             } elsif ($ctx =~ /^.\s*\#\s*elif\s*$/) {
3981 
3982             # If this whole things ends with a type its most
3983             # likely a typedef for a function.
3984             } elsif ($ctx =~ /$Type$/) {
3985 
3986             } else {
3987                 if (WARN("SPACING",
3988                      "space prohibited between function name and open parenthesis '('\n" . $herecurr) &&
3989                          $fix) {
3990                     $fixed[$fixlinenr] =~
3991                         s/\b$name\s+\(/$name\(/;
3992                 }
3993             }
3994         }
3995 
3996 # Check operator spacing.
3997         if (!($line=~/\#\s*include/)) {
3998             my $fixed_line = "";
3999             my $line_fixed = 0;
4000 
4001             my $ops = qr{
4002                 <<=|>>=|<=|>=|==|!=|
4003                 \+=|-=|\*=|\/=|%=|\^=|\|=|&=|
4004                 =>|->|<<|>>|<|>|=|!|~|
4005                 &&|\|\||,|\^|\+\+|--|&|\||\+|-|\*|\/|%|
4006                 \?:|\?|:
4007             }x;
4008             my @elements = split(/($ops|;)/, $opline);
4009 
4010 ##          print("element count: <" . $#elements . ">\n");
4011 ##          foreach my $el (@elements) {
4012 ##              print("el: <$el>\n");
4013 ##          }
4014 
4015             my @fix_elements = ();
4016             my $off = 0;
4017 
4018             foreach my $el (@elements) {
4019                 push(@fix_elements, substr($rawline, $off, length($el)));
4020                 $off += length($el);
4021             }
4022 
4023             $off = 0;
4024 
4025             my $blank = copy_spacing($opline);
4026             my $last_after = -1;
4027 
4028             for (my $n = 0; $n < $#elements; $n += 2) {
4029 
4030                 my $good = $fix_elements[$n] . $fix_elements[$n + 1];
4031 
4032 ##              print("n: <$n> good: <$good>\n");
4033 
4034                 $off += length($elements[$n]);
4035 
4036                 # Pick up the preceding and succeeding characters.
4037                 my $ca = substr($opline, 0, $off);
4038                 my $cc = '';
4039                 if (length($opline) >= ($off + length($elements[$n + 1]))) {
4040                     $cc = substr($opline, $off + length($elements[$n + 1]));
4041                 }
4042                 my $cb = "$ca$;$cc";
4043 
4044                 my $a = '';
4045                 $a = 'V' if ($elements[$n] ne '');
4046                 $a = 'W' if ($elements[$n] =~ /\s$/);
4047                 $a = 'C' if ($elements[$n] =~ /$;$/);
4048                 $a = 'B' if ($elements[$n] =~ /(\[|\()$/);
4049                 $a = 'O' if ($elements[$n] eq '');
4050                 $a = 'E' if ($ca =~ /^\s*$/);
4051 
4052                 my $op = $elements[$n + 1];
4053 
4054                 my $c = '';
4055                 if (defined $elements[$n + 2]) {
4056                     $c = 'V' if ($elements[$n + 2] ne '');
4057                     $c = 'W' if ($elements[$n + 2] =~ /^\s/);
4058                     $c = 'C' if ($elements[$n + 2] =~ /^$;/);
4059                     $c = 'B' if ($elements[$n + 2] =~ /^(\)|\]|;)/);
4060                     $c = 'O' if ($elements[$n + 2] eq '');
4061                     $c = 'E' if ($elements[$n + 2] =~ /^\s*\\$/);
4062                 } else {
4063                     $c = 'E';
4064                 }
4065 
4066                 my $ctx = "${a}x${c}";
4067 
4068                 my $at = "(ctx:$ctx)";
4069 
4070                 my $ptr = substr($blank, 0, $off) . "^";
4071                 my $hereptr = "$hereline$ptr\n";
4072 
4073                 # Pull out the value of this operator.
4074                 my $op_type = substr($curr_values, $off + 1, 1);
4075 
4076                 # Get the full operator variant.
4077                 my $opv = $op . substr($curr_vars, $off, 1);
4078 
4079                 # Ignore operators passed as parameters.
4080                 if ($op_type ne 'V' &&
4081                     $ca =~ /\s$/ && $cc =~ /^\s*[,\)]/) {
4082 
4083 #               # Ignore comments
4084 #               } elsif ($op =~ /^$;+$/) {
4085 
4086                 # ; should have either the end of line or a space or \ after it
4087                 } elsif ($op eq ';') {
4088                     if ($ctx !~ /.x[WEBC]/ &&
4089                         $cc !~ /^\\/ && $cc !~ /^;/) {
4090                         if (ERROR("SPACING",
4091                               "space required after that '$op' $at\n" . $hereptr)) {
4092                             $good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";
4093                             $line_fixed = 1;
4094                         }
4095                     }
4096 
4097                 # // is a comment
4098                 } elsif ($op eq '//') {
4099 
4100                 #   :   when part of a bitfield
4101                 } elsif ($opv eq ':B') {
4102                     # skip the bitfield test for now
4103 
4104                 # No spaces for:
4105                 #   ->
4106                 } elsif ($op eq '->') {
4107                     if ($ctx =~ /Wx.|.xW/) {
4108                         if (ERROR("SPACING",
4109                               "spaces prohibited around that '$op' $at\n" . $hereptr)) {
4110                             $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
4111                             if (defined $fix_elements[$n + 2]) {
4112                                 $fix_elements[$n + 2] =~ s/^\s+//;
4113                             }
4114                             $line_fixed = 1;
4115                         }
4116                     }
4117 
4118                 # , must not have a space before and must have a space on the right.
4119                 } elsif ($op eq ',') {
4120                     my $rtrim_before = 0;
4121                     my $space_after = 0;
4122                     if ($ctx =~ /Wx./) {
4123                         if (ERROR("SPACING",
4124                               "space prohibited before that '$op' $at\n" . $hereptr)) {
4125                             $line_fixed = 1;
4126                             $rtrim_before = 1;
4127                         }
4128                     }
4129                     if ($ctx !~ /.x[WEC]/ && $cc !~ /^}/) {
4130                         if (ERROR("SPACING",
4131                               "space required after that '$op' $at\n" . $hereptr)) {
4132                             $line_fixed = 1;
4133                             $last_after = $n;
4134                             $space_after = 1;
4135                         }
4136                     }
4137                     if ($rtrim_before || $space_after) {
4138                         if ($rtrim_before) {
4139                             $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
4140                         } else {
4141                             $good = $fix_elements[$n] . trim($fix_elements[$n + 1]);
4142                         }
4143                         if ($space_after) {
4144                             $good .= " ";
4145                         }
4146                     }
4147 
4148                 # '*' as part of a type definition -- reported already.
4149                 } elsif ($opv eq '*_') {
4150                     #warn "'*' is part of type\n";
4151 
4152                 # unary operators should have a space before and
4153                 # none after.  May be left adjacent to another
4154                 # unary operator, or a cast
4155                 } elsif ($op eq '!' || $op eq '~' ||
4156                      $opv eq '*U' || $opv eq '-U' ||
4157                      $opv eq '&U' || $opv eq '&&U') {
4158                     if ($ctx !~ /[WEBC]x./ && $ca !~ /(?:\)|!|~|\*|-|\&|\||\+\+|\-\-|\{)$/) {
4159                         if (ERROR("SPACING",
4160                               "space required before that '$op' $at\n" . $hereptr)) {
4161                             if ($n != $last_after + 2) {
4162                                 $good = $fix_elements[$n] . " " . ltrim($fix_elements[$n + 1]);
4163                                 $line_fixed = 1;
4164                             }
4165                         }
4166                     }
4167                     if ($op eq '*' && $cc =~/\s*$Modifier\b/) {
4168                         # A unary '*' may be const
4169 
4170                     } elsif ($ctx =~ /.xW/) {
4171                         if (ERROR("SPACING",
4172                               "space prohibited after that '$op' $at\n" . $hereptr)) {
4173                             $good = $fix_elements[$n] . rtrim($fix_elements[$n + 1]);
4174                             if (defined $fix_elements[$n + 2]) {
4175                                 $fix_elements[$n + 2] =~ s/^\s+//;
4176                             }
4177                             $line_fixed = 1;
4178                         }
4179                     }
4180 
4181                 # unary ++ and unary -- are allowed no space on one side.
4182                 } elsif ($op eq '++' or $op eq '--') {
4183                     if ($ctx !~ /[WEOBC]x[^W]/ && $ctx !~ /[^W]x[WOBEC]/) {
4184                         if (ERROR("SPACING",
4185                               "space required one side of that '$op' $at\n" . $hereptr)) {
4186                             $good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";
4187                             $line_fixed = 1;
4188                         }
4189                     }
4190                     if ($ctx =~ /Wx[BE]/ ||
4191                         ($ctx =~ /Wx./ && $cc =~ /^;/)) {
4192                         if (ERROR("SPACING",
4193                               "space prohibited before that '$op' $at\n" . $hereptr)) {
4194                             $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
4195                             $line_fixed = 1;
4196                         }
4197                     }
4198                     if ($ctx =~ /ExW/) {
4199                         if (ERROR("SPACING",
4200                               "space prohibited after that '$op' $at\n" . $hereptr)) {
4201                             $good = $fix_elements[$n] . trim($fix_elements[$n + 1]);
4202                             if (defined $fix_elements[$n + 2]) {
4203                                 $fix_elements[$n + 2] =~ s/^\s+//;
4204                             }
4205                             $line_fixed = 1;
4206                         }
4207                     }
4208 
4209                 # << and >> may either have or not have spaces both sides
4210                 } elsif ($op eq '<<' or $op eq '>>' or
4211                      $op eq '&' or $op eq '^' or $op eq '|' or
4212                      $op eq '+' or $op eq '-' or
4213                      $op eq '*' or $op eq '/' or
4214                      $op eq '%')
4215                 {
4216                     if ($check) {
4217                         if (defined $fix_elements[$n + 2] && $ctx !~ /[EW]x[EW]/) {
4218                             if (CHK("SPACING",
4219                                 "spaces preferred around that '$op' $at\n" . $hereptr)) {
4220                                 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
4221                                 $fix_elements[$n + 2] =~ s/^\s+//;
4222                                 $line_fixed = 1;
4223                             }
4224                         } elsif (!defined $fix_elements[$n + 2] && $ctx !~ /Wx[OE]/) {
4225                             if (CHK("SPACING",
4226                                 "space preferred before that '$op' $at\n" . $hereptr)) {
4227                                 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]);
4228                                 $line_fixed = 1;
4229                             }
4230                         }
4231                     } elsif ($ctx =~ /Wx[^WCE]|[^WCE]xW/) {
4232                         if (ERROR("SPACING",
4233                               "need consistent spacing around '$op' $at\n" . $hereptr)) {
4234                             $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
4235                             if (defined $fix_elements[$n + 2]) {
4236                                 $fix_elements[$n + 2] =~ s/^\s+//;
4237                             }
4238                             $line_fixed = 1;
4239                         }
4240                     }
4241 
4242                 # A colon needs no spaces before when it is
4243                 # terminating a case value or a label.
4244                 } elsif ($opv eq ':C' || $opv eq ':L') {
4245                     if ($ctx =~ /Wx./) {
4246                         if (ERROR("SPACING",
4247                               "space prohibited before that '$op' $at\n" . $hereptr)) {
4248                             $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
4249                             $line_fixed = 1;
4250                         }
4251                     }
4252 
4253                 # All the others need spaces both sides.
4254                 } elsif ($ctx !~ /[EWC]x[CWE]/) {
4255                     my $ok = 0;
4256 
4257                     # Ignore email addresses <foo@bar>
4258                     if (($op eq '<' &&
4259                          $cc =~ /^\S+\@\S+>/) ||
4260                         ($op eq '>' &&
4261                          $ca =~ /<\S+\@\S+$/))
4262                     {
4263                             $ok = 1;
4264                     }
4265 
4266                     # for asm volatile statements
4267                     # ignore a colon with another
4268                     # colon immediately before or after
4269                     if (($op eq ':') &&
4270                         ($ca =~ /:$/ || $cc =~ /^:/)) {
4271                         $ok = 1;
4272                     }
4273 
4274                     # messages are ERROR, but ?: are CHK
4275                     if ($ok == 0) {
4276                         my $msg_type = \&ERROR;
4277                         $msg_type = \&CHK if (($op eq '?:' || $op eq '?' || $op eq ':') && $ctx =~ /VxV/);
4278 
4279                         if (&{$msg_type}("SPACING",
4280                                  "spaces required around that '$op' $at\n" . $hereptr)) {
4281                             $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
4282                             if (defined $fix_elements[$n + 2]) {
4283                                 $fix_elements[$n + 2] =~ s/^\s+//;
4284                             }
4285                             $line_fixed = 1;
4286                         }
4287                     }
4288                 }
4289                 $off += length($elements[$n + 1]);
4290 
4291 ##              print("n: <$n> GOOD: <$good>\n");
4292 
4293                 $fixed_line = $fixed_line . $good;
4294             }
4295 
4296             if (($#elements % 2) == 0) {
4297                 $fixed_line = $fixed_line . $fix_elements[$#elements];
4298             }
4299 
4300             if ($fix && $line_fixed && $fixed_line ne $fixed[$fixlinenr]) {
4301                 $fixed[$fixlinenr] = $fixed_line;
4302             }
4303 
4304 
4305         }
4306 
4307 # check for whitespace before a non-naked semicolon
4308         if ($line =~ /^\+.*\S\s+;\s*$/) {
4309             if (WARN("SPACING",
4310                  "space prohibited before semicolon\n" . $herecurr) &&
4311                 $fix) {
4312                 1 while $fixed[$fixlinenr] =~
4313                     s/^(\+.*\S)\s+;/$1;/;
4314             }
4315         }
4316 
4317 # check for multiple assignments
4318         if ($line =~ /^.\s*$Lval\s*=\s*$Lval\s*=(?!=)/) {
4319             CHK("MULTIPLE_ASSIGNMENTS",
4320                 "multiple assignments should be avoided\n" . $herecurr);
4321         }
4322 
4323 ## # check for multiple declarations, allowing for a function declaration
4324 ## # continuation.
4325 ##      if ($line =~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Ident.*/ &&
4326 ##          $line !~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Type\s*$Ident.*/) {
4327 ##
4328 ##          # Remove any bracketed sections to ensure we do not
4329 ##          # falsly report the parameters of functions.
4330 ##          my $ln = $line;
4331 ##          while ($ln =~ s/\([^\(\)]*\)//g) {
4332 ##          }
4333 ##          if ($ln =~ /,/) {
4334 ##              WARN("MULTIPLE_DECLARATION",
4335 ##                   "declaring multiple variables together should be avoided\n" . $herecurr);
4336 ##          }
4337 ##      }
4338 
4339 #need space before brace following if, while, etc
4340         if (($line =~ /\(.*\)\{/ && $line !~ /\($Type\)\{/) ||
4341             $line =~ /do\{/) {
4342             if (ERROR("SPACING",
4343                   "space required before the open brace '{'\n" . $herecurr) &&
4344                 $fix) {
4345                 $fixed[$fixlinenr] =~ s/^(\+.*(?:do|\))){/$1 {/;
4346             }
4347         }
4348 
4349 ## # check for blank lines before declarations
4350 ##      if ($line =~ /^.\t+$Type\s+$Ident(?:\s*=.*)?;/ &&
4351 ##          $prevrawline =~ /^.\s*$/) {
4352 ##          WARN("SPACING",
4353 ##               "No blank lines before declarations\n" . $hereprev);
4354 ##      }
4355 ##
4356 
4357 # closing brace should have a space following it when it has anything
4358 # on the line
4359         if ($line =~ /}(?!(?:,|;|\)))\S/) {
4360             if (ERROR("SPACING",
4361                   "space required after that close brace '}'\n" . $herecurr) &&
4362                 $fix) {
4363                 $fixed[$fixlinenr] =~
4364                     s/}((?!(?:,|;|\)))\S)/} $1/;
4365             }
4366         }
4367 
4368 # check spacing on square brackets
4369         if ($line =~ /\[\s/ && $line !~ /\[\s*$/) {
4370             if (ERROR("SPACING",
4371                   "space prohibited after that open square bracket '['\n" . $herecurr) &&
4372                 $fix) {
4373                 $fixed[$fixlinenr] =~
4374                     s/\[\s+/\[/;
4375             }
4376         }
4377         if ($line =~ /\s\]/) {
4378             if (ERROR("SPACING",
4379                   "space prohibited before that close square bracket ']'\n" . $herecurr) &&
4380                 $fix) {
4381                 $fixed[$fixlinenr] =~
4382                     s/\s+\]/\]/;
4383             }
4384         }
4385 
4386 # check spacing on parentheses
4387         if ($line =~ /\(\s/ && $line !~ /\(\s*(?:\\)?$/ &&
4388             $line !~ /for\s*\(\s+;/) {
4389             if (ERROR("SPACING",
4390                   "space prohibited after that open parenthesis '('\n" . $herecurr) &&
4391                 $fix) {
4392                 $fixed[$fixlinenr] =~
4393                     s/\(\s+/\(/;
4394             }
4395         }
4396         if ($line =~ /(\s+)\)/ && $line !~ /^.\s*\)/ &&
4397             $line !~ /for\s*\(.*;\s+\)/ &&
4398             $line !~ /:\s+\)/) {
4399             if (ERROR("SPACING",
4400                   "space prohibited before that close parenthesis ')'\n" . $herecurr) &&
4401                 $fix) {
4402                 $fixed[$fixlinenr] =~
4403                     s/\s+\)/\)/;
4404             }
4405         }
4406 
4407 # check unnecessary parentheses around addressof/dereference single $Lvals
4408 # ie: &(foo->bar) should be &foo->bar and *(foo->bar) should be *foo->bar
4409 
4410         while ($line =~ /(?:[^&]&\s*|\*)\(\s*($Ident\s*(?:$Member\s*)+)\s*\)/g) {
4411             my $var = $1;
4412             if (CHK("UNNECESSARY_PARENTHESES",
4413                 "Unnecessary parentheses around $var\n" . $herecurr) &&
4414                 $fix) {
4415                 $fixed[$fixlinenr] =~ s/\(\s*\Q$var\E\s*\)/$var/;
4416             }
4417         }
4418 
4419 # check for unnecessary parentheses around function pointer uses
4420 # ie: (foo->bar)(); should be foo->bar();
4421 # but not "if (foo->bar) (" to avoid some false positives
4422         if ($line =~ /(\bif\s*|)(\(\s*$Ident\s*(?:$Member\s*)+\))[ \t]*\(/ && $1 !~ /^if/) {
4423             my $var = $2;
4424             if (CHK("UNNECESSARY_PARENTHESES",
4425                 "Unnecessary parentheses around function pointer $var\n" . $herecurr) &&
4426                 $fix) {
4427                 my $var2 = deparenthesize($var);
4428                 $var2 =~ s/\s//g;
4429                 $fixed[$fixlinenr] =~ s/\Q$var\E/$var2/;
4430             }
4431         }
4432 
4433 #goto labels aren't indented, allow a single space however
4434         if ($line=~/^.\s+[A-Za-z\d_]+:(?![0-9]+)/ and
4435            !($line=~/^. [A-Za-z\d_]+:/) and !($line=~/^.\s+default:/)) {
4436             if (WARN("INDENTED_LABEL",
4437                  "labels should not be indented\n" . $herecurr) &&
4438                 $fix) {
4439                 $fixed[$fixlinenr] =~
4440                     s/^(.)\s+/$1/;
4441             }
4442         }
4443 
4444 # return is not a function
4445         if (defined($stat) && $stat =~ /^.\s*return(\s*)\(/s) {
4446             my $spacing = $1;
4447             if ($^V && $^V ge 5.10.0 &&
4448                 $stat =~ /^.\s*return\s*($balanced_parens)\s*;\s*$/) {
4449                 my $value = $1;
4450                 $value = deparenthesize($value);
4451                 if ($value =~ m/^\s*$FuncArg\s*(?:\?|$)/) {
4452                     ERROR("RETURN_PARENTHESES",
4453                           "return is not a function, parentheses are not required\n" . $herecurr);
4454                 }
4455             } elsif ($spacing !~ /\s+/) {
4456                 ERROR("SPACING",
4457                       "space required before the open parenthesis '('\n" . $herecurr);
4458             }
4459         }
4460 
4461 # unnecessary return in a void function
4462 # at end-of-function, with the previous line a single leading tab, then return;
4463 # and the line before that not a goto label target like "out:"
4464         if ($sline =~ /^[ \+]}\s*$/ &&
4465             $prevline =~ /^\+\treturn\s*;\s*$/ &&
4466             $linenr >= 3 &&
4467             $lines[$linenr - 3] =~ /^[ +]/ &&
4468             $lines[$linenr - 3] !~ /^[ +]\s*$Ident\s*:/) {
4469             WARN("RETURN_VOID",
4470                  "void function return statements are not generally useful\n" . $hereprev);
4471                }
4472 
4473 # if statements using unnecessary parentheses - ie: if ((foo == bar))
4474         if ($^V && $^V ge 5.10.0 &&
4475             $line =~ /\bif\s*((?:\(\s*){2,})/) {
4476             my $openparens = $1;
4477             my $count = $openparens =~ tr@\(@\(@;
4478             my $msg = "";
4479             if ($line =~ /\bif\s*(?:\(\s*){$count,$count}$LvalOrFunc\s*($Compare)\s*$LvalOrFunc(?:\s*\)){$count,$count}/) {
4480                 my $comp = $4;  #Not $1 because of $LvalOrFunc
4481                 $msg = " - maybe == should be = ?" if ($comp eq "==");
4482                 WARN("UNNECESSARY_PARENTHESES",
4483                      "Unnecessary parentheses$msg\n" . $herecurr);
4484             }
4485         }
4486 
4487 # comparisons with a constant or upper case identifier on the left
4488 #   avoid cases like "foo + BAR < baz"
4489 #   only fix matches surrounded by parentheses to avoid incorrect
4490 #   conversions like "FOO < baz() + 5" being "misfixed" to "baz() > FOO + 5"
4491         if ($^V && $^V ge 5.10.0 &&
4492             $line =~ /^\+(.*)\b($Constant|[A-Z_][A-Z0-9_]*)\s*($Compare)\s*($LvalOrFunc)/) {
4493             my $lead = $1;
4494             my $const = $2;
4495             my $comp = $3;
4496             my $to = $4;
4497             my $newcomp = $comp;
4498             if ($lead !~ /(?:$Operators|\.)\s*$/ &&
4499                 $to !~ /^(?:Constant|[A-Z_][A-Z0-9_]*)$/ &&
4500                 WARN("CONSTANT_COMPARISON",
4501                  "Comparisons should place the constant on the right side of the test\n" . $herecurr) &&
4502                 $fix) {
4503                 if ($comp eq "<") {
4504                     $newcomp = ">";
4505                 } elsif ($comp eq "<=") {
4506                     $newcomp = ">=";
4507                 } elsif ($comp eq ">") {
4508                     $newcomp = "<";
4509                 } elsif ($comp eq ">=") {
4510                     $newcomp = "<=";
4511                 }
4512                 $fixed[$fixlinenr] =~ s/\(\s*\Q$const\E\s*$Compare\s*\Q$to\E\s*\)/($to $newcomp $const)/;
4513             }
4514         }
4515 
4516 # Return of what appears to be an errno should normally be negative
4517         if ($sline =~ /\breturn(?:\s*\(+\s*|\s+)(E[A-Z]+)(?:\s*\)+\s*|\s*)[;:,]/) {
4518             my $name = $1;
4519             if ($name ne 'EOF' && $name ne 'ERROR') {
4520                 WARN("USE_NEGATIVE_ERRNO",
4521                      "return of an errno should typically be negative (ie: return -$1)\n" . $herecurr);
4522             }
4523         }
4524 
4525 # Need a space before open parenthesis after if, while etc
4526         if ($line =~ /\b(if|while|for|switch)\(/) {
4527             if (ERROR("SPACING",
4528                   "space required before the open parenthesis '('\n" . $herecurr) &&
4529                 $fix) {
4530                 $fixed[$fixlinenr] =~
4531                     s/\b(if|while|for|switch)\(/$1 \(/;
4532             }
4533         }
4534 
4535 # Check for illegal assignment in if conditional -- and check for trailing
4536 # statements after the conditional.
4537         if ($line =~ /do\s*(?!{)/) {
4538             ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
4539                 ctx_statement_block($linenr, $realcnt, 0)
4540                     if (!defined $stat);
4541             my ($stat_next) = ctx_statement_block($line_nr_next,
4542                         $remain_next, $off_next);
4543             $stat_next =~ s/\n./\n /g;
4544             ##print "stat<$stat> stat_next<$stat_next>\n";
4545 
4546             if ($stat_next =~ /^\s*while\b/) {
4547                 # If the statement carries leading newlines,
4548                 # then count those as offsets.
4549                 my ($whitespace) =
4550                     ($stat_next =~ /^((?:\s*\n[+-])*\s*)/s);
4551                 my $offset =
4552                     statement_rawlines($whitespace) - 1;
4553 
4554                 $suppress_whiletrailers{$line_nr_next +
4555                                 $offset} = 1;
4556             }
4557         }
4558         if (!defined $suppress_whiletrailers{$linenr} &&
4559             defined($stat) && defined($cond) &&
4560             $line =~ /\b(?:if|while|for)\s*\(/ && $line !~ /^.\s*#/) {
4561             my ($s, $c) = ($stat, $cond);
4562 
4563             if ($c =~ /\bif\s*\(.*[^<>!=]=[^=].*/s) {
4564                 ERROR("ASSIGN_IN_IF",
4565                       "do not use assignment in if condition\n" . $herecurr);
4566             }
4567 
4568             # Find out what is on the end of the line after the
4569             # conditional.
4570             substr($s, 0, length($c), '');
4571             $s =~ s/\n.*//g;
4572             $s =~ s/$;//g;  # Remove any comments
4573             if (length($c) && $s !~ /^\s*{?\s*\\*\s*$/ &&
4574                 $c !~ /}\s*while\s*/)
4575             {
4576                 # Find out how long the conditional actually is.
4577                 my @newlines = ($c =~ /\n/gs);
4578                 my $cond_lines = 1 + $#newlines;
4579                 my $stat_real = '';
4580 
4581                 $stat_real = raw_line($linenr, $cond_lines)
4582                             . "\n" if ($cond_lines);
4583                 if (defined($stat_real) && $cond_lines > 1) {
4584                     $stat_real = "[...]\n$stat_real";
4585                 }
4586 
4587                 ERROR("TRAILING_STATEMENTS",
4588                       "trailing statements should be on next line\n" . $herecurr . $stat_real);
4589             }
4590         }
4591 
4592 # Check for bitwise tests written as boolean
4593         if ($line =~ /
4594             (?:
4595                 (?:\[|\(|\&\&|\|\|)
4596                 \s*0[xX][0-9]+\s*
4597                 (?:\&\&|\|\|)
4598             |
4599                 (?:\&\&|\|\|)
4600                 \s*0[xX][0-9]+\s*
4601                 (?:\&\&|\|\||\)|\])
4602             )/x)
4603         {
4604             WARN("HEXADECIMAL_BOOLEAN_TEST",
4605                  "boolean test with hexadecimal, perhaps just 1 \& or \|?\n" . $herecurr);
4606         }
4607 
4608 # if and else should not have general statements after it
4609         if ($line =~ /^.\s*(?:}\s*)?else\b(.*)/) {
4610             my $s = $1;
4611             $s =~ s/$;//g;  # Remove any comments
4612             if ($s !~ /^\s*(?:\sif|(?:{|)\s*\\?\s*$)/) {
4613                 ERROR("TRAILING_STATEMENTS",
4614                       "trailing statements should be on next line\n" . $herecurr);
4615             }
4616         }
4617 # if should not continue a brace
4618         if ($line =~ /}\s*if\b/) {
4619             ERROR("TRAILING_STATEMENTS",
4620                   "trailing statements should be on next line (or did you mean 'else if'?)\n" .
4621                 $herecurr);
4622         }
4623 # case and default should not have general statements after them
4624         if ($line =~ /^.\s*(?:case\s*.*|default\s*):/g &&
4625             $line !~ /\G(?:
4626             (?:\s*$;*)(?:\s*{)?(?:\s*$;*)(?:\s*\\)?\s*$|
4627             \s*return\s+
4628             )/xg)
4629         {
4630             ERROR("TRAILING_STATEMENTS",
4631                   "trailing statements should be on next line\n" . $herecurr);
4632         }
4633 
4634         # Check for }<nl>else {, these must be at the same
4635         # indent level to be relevant to each other.
4636         if ($prevline=~/}\s*$/ and $line=~/^.\s*else\s*/ &&
4637             $previndent == $indent) {
4638             if (ERROR("ELSE_AFTER_BRACE",
4639                   "else should follow close brace '}'\n" . $hereprev) &&
4640                 $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
4641                 fix_delete_line($fixlinenr - 1, $prevrawline);
4642                 fix_delete_line($fixlinenr, $rawline);
4643                 my $fixedline = $prevrawline;
4644                 $fixedline =~ s/}\s*$//;
4645                 if ($fixedline !~ /^\+\s*$/) {
4646                     fix_insert_line($fixlinenr, $fixedline);
4647                 }
4648                 $fixedline = $rawline;
4649                 $fixedline =~ s/^(.\s*)else/$1} else/;
4650                 fix_insert_line($fixlinenr, $fixedline);
4651             }
4652         }
4653 
4654         if ($prevline=~/}\s*$/ and $line=~/^.\s*while\s*/ &&
4655             $previndent == $indent) {
4656             my ($s, $c) = ctx_statement_block($linenr, $realcnt, 0);
4657 
4658             # Find out what is on the end of the line after the
4659             # conditional.
4660             substr($s, 0, length($c), '');
4661             $s =~ s/\n.*//g;
4662 
4663             if ($s =~ /^\s*;/) {
4664                 if (ERROR("WHILE_AFTER_BRACE",
4665                       "while should follow close brace '}'\n" . $hereprev) &&
4666                     $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
4667                     fix_delete_line($fixlinenr - 1, $prevrawline);
4668                     fix_delete_line($fixlinenr, $rawline);
4669                     my $fixedline = $prevrawline;
4670                     my $trailing = $rawline;
4671                     $trailing =~ s/^\+//;
4672                     $trailing = trim($trailing);
4673                     $fixedline =~ s/}\s*$/} $trailing/;
4674                     fix_insert_line($fixlinenr, $fixedline);
4675                 }
4676             }
4677         }
4678 
4679 #Specific variable tests
4680         while ($line =~ m{($Constant|$Lval)}g) {
4681             my $var = $1;
4682 
4683 #gcc binary extension
4684             if ($var =~ /^$Binary$/) {
4685                 if (WARN("GCC_BINARY_CONSTANT",
4686                      "Avoid gcc v4.3+ binary constant extension: <$var>\n" . $herecurr) &&
4687                     $fix) {
4688                     my $hexval = sprintf("0x%x", oct($var));
4689                     $fixed[$fixlinenr] =~
4690                         s/\b$var\b/$hexval/;
4691                 }
4692             }
4693 
4694 #CamelCase
4695             if ($var !~ /^$Constant$/ &&
4696                 $var =~ /[A-Z][a-z]|[a-z][A-Z]/ &&
4697 #Ignore Page<foo> variants
4698                 $var !~ /^(?:Clear|Set|TestClear|TestSet|)Page[A-Z]/ &&
4699 #Ignore SI style variants like nS, mV and dB (ie: max_uV, regulator_min_uA_show)
4700                 $var !~ /^(?:[a-z_]*?)_?[a-z][A-Z](?:_[a-z_]+)?$/ &&
4701 #Ignore some three character SI units explicitly, like MiB and KHz
4702                 $var !~ /^(?:[a-z_]*?)_?(?:[KMGT]iB|[KMGT]?Hz)(?:_[a-z_]+)?$/) {
4703                 while ($var =~ m{($Ident)}g) {
4704                     my $word = $1;
4705                     next if ($word !~ /[A-Z][a-z]|[a-z][A-Z]/);
4706                     if ($check) {
4707                         seed_camelcase_includes();
4708                         if (!$file && !$camelcase_file_seeded) {
4709                             seed_camelcase_file($realfile);
4710                             $camelcase_file_seeded = 1;
4711                         }
4712                     }
4713                     if (!defined $camelcase{$word}) {
4714                         $camelcase{$word} = 1;
4715                         CHK("CAMELCASE",
4716                             "Avoid CamelCase: <$word>\n" . $herecurr);
4717                     }
4718                 }
4719             }
4720         }
4721 
4722 #no spaces allowed after \ in define
4723         if ($line =~ /\#\s*define.*\\\s+$/) {
4724             if (WARN("WHITESPACE_AFTER_LINE_CONTINUATION",
4725                  "Whitespace after \\ makes next lines useless\n" . $herecurr) &&
4726                 $fix) {
4727                 $fixed[$fixlinenr] =~ s/\s+$//;
4728             }
4729         }
4730 
4731 # warn if <asm/foo.h> is #included and <linux/foo.h> is available and includes
4732 # itself <asm/foo.h> (uses RAW line)
4733         if ($tree && $rawline =~ m{^.\s*\#\s*include\s*\<asm\/(.*)\.h\>}) {
4734             my $file = "$1.h";
4735             my $checkfile = "include/linux/$file";
4736             if (-f "$root/$checkfile" &&
4737                 $realfile ne $checkfile &&
4738                 $1 !~ /$allowed_asm_includes/)
4739             {
4740                 my $asminclude = `grep -Ec "#include\\s+<asm/$file>" $root/$checkfile`;
4741                 if ($asminclude > 0) {
4742                     if ($realfile =~ m{^arch/}) {
4743                         CHK("ARCH_INCLUDE_LINUX",
4744                             "Consider using #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
4745                     } else {
4746                         WARN("INCLUDE_LINUX",
4747                              "Use #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
4748                     }
4749                 }
4750             }
4751         }
4752 
4753 # multi-statement macros should be enclosed in a do while loop, grab the
4754 # first statement and ensure its the whole macro if its not enclosed
4755 # in a known good container
4756         if ($realfile !~ m@/vmlinux.lds.h$@ &&
4757             $line =~ /^.\s*\#\s*define\s*$Ident(\()?/) {
4758             my $ln = $linenr;
4759             my $cnt = $realcnt;
4760             my ($off, $dstat, $dcond, $rest);
4761             my $ctx = '';
4762             my $has_flow_statement = 0;
4763             my $has_arg_concat = 0;
4764             ($dstat, $dcond, $ln, $cnt, $off) =
4765                 ctx_statement_block($linenr, $realcnt, 0);
4766             $ctx = $dstat;
4767             #print "dstat<$dstat> dcond<$dcond> cnt<$cnt> off<$off>\n";
4768             #print "LINE<$lines[$ln-1]> len<" . length($lines[$ln-1]) . "\n";
4769 
4770             $has_flow_statement = 1 if ($ctx =~ /\b(goto|return)\b/);
4771             $has_arg_concat = 1 if ($ctx =~ /\#\#/ && $ctx !~ /\#\#\s*(?:__VA_ARGS__|args)\b/);
4772 
4773             $dstat =~ s/^.\s*\#\s*define\s+$Ident(\([^\)]*\))?\s*//;
4774             my $define_args = $1;
4775             my $define_stmt = $dstat;
4776             my @def_args = ();
4777 
4778             if (defined $define_args && $define_args ne "") {
4779                 $define_args = substr($define_args, 1, length($define_args) - 2);
4780                 $define_args =~ s/\s*//g;
4781                 @def_args = split(",", $define_args);
4782             }
4783 
4784             $dstat =~ s/$;//g;
4785             $dstat =~ s/\\\n.//g;
4786             $dstat =~ s/^\s*//s;
4787             $dstat =~ s/\s*$//s;
4788 
4789             # Flatten any parentheses and braces
4790             while ($dstat =~ s/\([^\(\)]*\)/1/ ||
4791                    $dstat =~ s/\{[^\{\}]*\}/1/ ||
4792                    $dstat =~ s/.\[[^\[\]]*\]/1/)
4793             {
4794             }
4795 
4796             # Flatten any obvious string concatentation.
4797             while ($dstat =~ s/($String)\s*$Ident/$1/ ||
4798                    $dstat =~ s/$Ident\s*($String)/$1/)
4799             {
4800             }
4801 
4802             # Make asm volatile uses seem like a generic function
4803             $dstat =~ s/\b_*asm_*\s+_*volatile_*\b/asm_volatile/g;
4804 
4805             my $exceptions = qr{
4806                 $Declare|
4807                 module_param_named|
4808                 MODULE_PARM_DESC|
4809                 DECLARE_PER_CPU|
4810                 DEFINE_PER_CPU|
4811                 __typeof__\(|
4812                 union|
4813                 struct|
4814                 \.$Ident\s*=\s*|
4815                 ^\"|\"$|
4816                 ^\[
4817             }x;
4818             #print "REST<$rest> dstat<$dstat> ctx<$ctx>\n";
4819 
4820             $ctx =~ s/\n*$//;
4821             my $herectx = $here . "\n";
4822             my $stmt_cnt = statement_rawlines($ctx);
4823 
4824             for (my $n = 0; $n < $stmt_cnt; $n++) {
4825                 $herectx .= raw_line($linenr, $n) . "\n";
4826             }
4827 
4828             if ($dstat ne '' &&
4829                 $dstat !~ /^(?:$Ident|-?$Constant),$/ &&            # 10, // foo(),
4830                 $dstat !~ /^(?:$Ident|-?$Constant);$/ &&            # foo();
4831                 $dstat !~ /^[!~-]?(?:$Lval|$Constant)$/ &&      # 10 // foo() // !foo // ~foo // -foo // foo->bar // foo.bar->baz
4832                 $dstat !~ /^'X'$/ && $dstat !~ /^'XX'$/ &&          # character constants
4833                 $dstat !~ /$exceptions/ &&
4834                 $dstat !~ /^\.$Ident\s*=/ &&                # .foo =
4835                 $dstat !~ /^(?:\#\s*$Ident|\#\s*$Constant)\s*$/ &&      # stringification #foo
4836                 $dstat !~ /^do\s*$Constant\s*while\s*$Constant;?$/ &&   # do {...} while (...); // do {...} while (...)
4837                 $dstat !~ /^for\s*$Constant$/ &&                # for (...)
4838                 $dstat !~ /^for\s*$Constant\s+(?:$Ident|-?$Constant)$/ &&   # for (...) bar()
4839                 $dstat !~ /^do\s*{/ &&                  # do {...
4840                 $dstat !~ /^\(\{/ &&                        # ({...
4841                 $ctx !~ /^.\s*#\s*define\s+TRACE_(?:SYSTEM|INCLUDE_FILE|INCLUDE_PATH)\b/)
4842             {
4843 
4844                 if ($dstat =~ /;/) {
4845                     ERROR("MULTISTATEMENT_MACRO_USE_DO_WHILE",
4846                           "Macros with multiple statements should be enclosed in a do - while loop\n" . "$herectx");
4847                 } else {
4848                     ERROR("COMPLEX_MACRO",
4849                           "Macros with complex values should be enclosed in parentheses\n" . "$herectx");
4850                 }
4851 
4852             }
4853 
4854             # Make $define_stmt single line, comment-free, etc
4855             my @stmt_array = split('\n', $define_stmt);
4856             my $first = 1;
4857             $define_stmt = "";
4858             foreach my $l (@stmt_array) {
4859                 $l =~ s/\\$//;
4860                 if ($first) {
4861                     $define_stmt = $l;
4862                     $first = 0;
4863                 } elsif ($l =~ /^[\+ ]/) {
4864                     $define_stmt .= substr($l, 1);
4865                 }
4866             }
4867             $define_stmt =~ s/$;//g;
4868             $define_stmt =~ s/\s+/ /g;
4869             $define_stmt = trim($define_stmt);
4870 
4871 # check if any macro arguments are reused (ignore '...' and 'type')
4872             foreach my $arg (@def_args) {
4873                     next if ($arg =~ /\.\.\./);
4874                     next if ($arg =~ /^type$/i);
4875                 my $tmp = $define_stmt;
4876                 $tmp =~ s/\b(typeof|__typeof__|__builtin\w+|typecheck\s*\(\s*$Type\s*,|\#+)\s*\(*\s*$arg\s*\)*\b//g;
4877                 $tmp =~ s/\#+\s*$arg\b//g;
4878                 $tmp =~ s/\b$arg\s*\#\#//g;
4879                 my $use_cnt = $tmp =~ s/\b$arg\b//g;
4880                 if ($use_cnt > 1) {
4881                     CHK("MACRO_ARG_REUSE",
4882                         "Macro argument reuse '$arg' - possible side-effects?\n" . "$herectx");
4883                     }
4884 # check if any macro arguments may have other precedence issues
4885                 if ($define_stmt =~ m/($Operators)?\s*\b$arg\b\s*($Operators)?/m &&
4886                     ((defined($1) && $1 ne ',') ||
4887                      (defined($2) && $2 ne ','))) {
4888                     CHK("MACRO_ARG_PRECEDENCE",
4889                         "Macro argument '$arg' may be better as '($arg)' to avoid precedence issues\n" . "$herectx");
4890                 }
4891             }
4892 
4893 # check for macros with flow control, but without ## concatenation
4894 # ## concatenation is commonly a macro that defines a function so ignore those
4895             if ($has_flow_statement && !$has_arg_concat) {
4896                 my $herectx = $here . "\n";
4897                 my $cnt = statement_rawlines($ctx);
4898 
4899                 for (my $n = 0; $n < $cnt; $n++) {
4900                     $herectx .= raw_line($linenr, $n) . "\n";
4901                 }
4902                 WARN("MACRO_WITH_FLOW_CONTROL",
4903                      "Macros with flow control statements should be avoided\n" . "$herectx");
4904             }
4905 
4906 # check for line continuations outside of #defines, preprocessor #, and asm
4907 
4908         } else {
4909             if ($prevline !~ /^..*\\$/ &&
4910                 $line !~ /^\+\s*\#.*\\$/ &&     # preprocessor
4911                 $line !~ /^\+.*\b(__asm__|asm)\b.*\\$/ &&   # asm
4912                 $line =~ /^\+.*\\$/) {
4913                 WARN("LINE_CONTINUATIONS",
4914                      "Avoid unnecessary line continuations\n" . $herecurr);
4915             }
4916         }
4917 
4918 # do {} while (0) macro tests:
4919 # single-statement macros do not need to be enclosed in do while (0) loop,
4920 # macro should not end with a semicolon
4921         if ($^V && $^V ge 5.10.0 &&
4922             $realfile !~ m@/vmlinux.lds.h$@ &&
4923             $line =~ /^.\s*\#\s*define\s+$Ident(\()?/) {
4924             my $ln = $linenr;
4925             my $cnt = $realcnt;
4926             my ($off, $dstat, $dcond, $rest);
4927             my $ctx = '';
4928             ($dstat, $dcond, $ln, $cnt, $off) =
4929                 ctx_statement_block($linenr, $realcnt, 0);
4930             $ctx = $dstat;
4931 
4932             $dstat =~ s/\\\n.//g;
4933             $dstat =~ s/$;/ /g;
4934 
4935             if ($dstat =~ /^\+\s*#\s*define\s+$Ident\s*${balanced_parens}\s*do\s*{(.*)\s*}\s*while\s*\(\s*0\s*\)\s*([;\s]*)\s*$/) {
4936                 my $stmts = $2;
4937                 my $semis = $3;
4938 
4939                 $ctx =~ s/\n*$//;
4940                 my $cnt = statement_rawlines($ctx);
4941                 my $herectx = $here . "\n";
4942 
4943                 for (my $n = 0; $n < $cnt; $n++) {
4944                     $herectx .= raw_line($linenr, $n) . "\n";
4945                 }
4946 
4947                 if (($stmts =~ tr/;/;/) == 1 &&
4948                     $stmts !~ /^\s*(if|while|for|switch)\b/) {
4949                     WARN("SINGLE_STATEMENT_DO_WHILE_MACRO",
4950                          "Single statement macros should not use a do {} while (0) loop\n" . "$herectx");
4951                 }
4952                 if (defined $semis && $semis ne "") {
4953                     WARN("DO_WHILE_MACRO_WITH_TRAILING_SEMICOLON",
4954                          "do {} while (0) macros should not be semicolon terminated\n" . "$herectx");
4955                 }
4956             } elsif ($dstat =~ /^\+\s*#\s*define\s+$Ident.*;\s*$/) {
4957                 $ctx =~ s/\n*$//;
4958                 my $cnt = statement_rawlines($ctx);
4959                 my $herectx = $here . "\n";
4960 
4961                 for (my $n = 0; $n < $cnt; $n++) {
4962                     $herectx .= raw_line($linenr, $n) . "\n";
4963                 }
4964 
4965                 WARN("TRAILING_SEMICOLON",
4966                      "macros should not use a trailing semicolon\n" . "$herectx");
4967             }
4968         }
4969 
4970 # make sure symbols are always wrapped with VMLINUX_SYMBOL() ...
4971 # all assignments may have only one of the following with an assignment:
4972 #   .
4973 #   ALIGN(...)
4974 #   VMLINUX_SYMBOL(...)
4975         if ($realfile eq 'vmlinux.lds.h' && $line =~ /(?:(?:^|\s)$Ident\s*=|=\s*$Ident(?:\s|$))/) {
4976             WARN("MISSING_VMLINUX_SYMBOL",
4977                  "vmlinux.lds.h needs VMLINUX_SYMBOL() around C-visible symbols\n" . $herecurr);
4978         }
4979 
4980 # check for redundant bracing round if etc
4981         if ($line =~ /(^.*)\bif\b/ && $1 !~ /else\s*$/) {
4982             my ($level, $endln, @chunks) =
4983                 ctx_statement_full($linenr, $realcnt, 1);
4984             #print "chunks<$#chunks> linenr<$linenr> endln<$endln> level<$level>\n";
4985             #print "APW: <<$chunks[1][0]>><<$chunks[1][1]>>\n";
4986             if ($#chunks > 0 && $level == 0) {
4987                 my @allowed = ();
4988                 my $allow = 0;
4989                 my $seen = 0;
4990                 my $herectx = $here . "\n";
4991                 my $ln = $linenr - 1;
4992                 for my $chunk (@chunks) {
4993                     my ($cond, $block) = @{$chunk};
4994 
4995                     # If the condition carries leading newlines, then count those as offsets.
4996                     my ($whitespace) = ($cond =~ /^((?:\s*\n[+-])*\s*)/s);
4997                     my $offset = statement_rawlines($whitespace) - 1;
4998 
4999                     $allowed[$allow] = 0;
5000                     #print "COND<$cond> whitespace<$whitespace> offset<$offset>\n";
5001 
5002                     # We have looked at and allowed this specific line.
5003                     $suppress_ifbraces{$ln + $offset} = 1;
5004 
5005                     $herectx .= "$rawlines[$ln + $offset]\n[...]\n";
5006                     $ln += statement_rawlines($block) - 1;
5007 
5008                     substr($block, 0, length($cond), '');
5009 
5010                     $seen++ if ($block =~ /^\s*{/);
5011 
5012                     #print "cond<$cond> block<$block> allowed<$allowed[$allow]>\n";
5013                     if (statement_lines($cond) > 1) {
5014                         #print "APW: ALLOWED: cond<$cond>\n";
5015                         $allowed[$allow] = 1;
5016                     }
5017                     if ($block =~/\b(?:if|for|while)\b/) {
5018                         #print "APW: ALLOWED: block<$block>\n";
5019                         $allowed[$allow] = 1;
5020                     }
5021                     if (statement_block_size($block) > 1) {
5022                         #print "APW: ALLOWED: lines block<$block>\n";
5023                         $allowed[$allow] = 1;
5024                     }
5025                     $allow++;
5026                 }
5027                 if ($seen) {
5028                     my $sum_allowed = 0;
5029                     foreach (@allowed) {
5030                         $sum_allowed += $_;
5031                     }
5032                     if ($sum_allowed == 0) {
5033                         WARN("BRACES",
5034                              "braces {} are not necessary for any arm of this statement\n" . $herectx);
5035                     } elsif ($sum_allowed != $allow &&
5036                          $seen != $allow) {
5037                         CHK("BRACES",
5038                             "braces {} should be used on all arms of this statement\n" . $herectx);
5039                     }
5040                 }
5041             }
5042         }
5043         if (!defined $suppress_ifbraces{$linenr - 1} &&
5044                     $line =~ /\b(if|while|for|else)\b/) {
5045             my $allowed = 0;
5046 
5047             # Check the pre-context.
5048             if (substr($line, 0, $-[0]) =~ /(\}\s*)$/) {
5049                 #print "APW: ALLOWED: pre<$1>\n";
5050                 $allowed = 1;
5051             }
5052 
5053             my ($level, $endln, @chunks) =
5054                 ctx_statement_full($linenr, $realcnt, $-[0]);
5055 
5056             # Check the condition.
5057             my ($cond, $block) = @{$chunks[0]};
5058             #print "CHECKING<$linenr> cond<$cond> block<$block>\n";
5059             if (defined $cond) {
5060                 substr($block, 0, length($cond), '');
5061             }
5062             if (statement_lines($cond) > 1) {
5063                 #print "APW: ALLOWED: cond<$cond>\n";
5064                 $allowed = 1;
5065             }
5066             if ($block =~/\b(?:if|for|while)\b/) {
5067                 #print "APW: ALLOWED: block<$block>\n";
5068                 $allowed = 1;
5069             }
5070             if (statement_block_size($block) > 1) {
5071                 #print "APW: ALLOWED: lines block<$block>\n";
5072                 $allowed = 1;
5073             }
5074             # Check the post-context.
5075             if (defined $chunks[1]) {
5076                 my ($cond, $block) = @{$chunks[1]};
5077                 if (defined $cond) {
5078                     substr($block, 0, length($cond), '');
5079                 }
5080                 if ($block =~ /^\s*\{/) {
5081                     #print "APW: ALLOWED: chunk-1 block<$block>\n";
5082                     $allowed = 1;
5083                 }
5084             }
5085             if ($level == 0 && $block =~ /^\s*\{/ && !$allowed) {
5086                 my $herectx = $here . "\n";
5087                 my $cnt = statement_rawlines($block);
5088 
5089                 for (my $n = 0; $n < $cnt; $n++) {
5090                     $herectx .= raw_line($linenr, $n) . "\n";
5091                 }
5092 
5093                 WARN("BRACES",
5094                      "braces {} are not necessary for single statement blocks\n" . $herectx);
5095             }
5096         }
5097 
5098 # check for unnecessary blank lines around braces
5099         if (($line =~ /^.\s*}\s*$/ && $prevrawline =~ /^.\s*$/)) {
5100             if (CHK("BRACES",
5101                 "Blank lines aren't necessary before a close brace '}'\n" . $hereprev) &&
5102                 $fix && $prevrawline =~ /^\+/) {
5103                 fix_delete_line($fixlinenr - 1, $prevrawline);
5104             }
5105         }
5106         if (($rawline =~ /^.\s*$/ && $prevline =~ /^..*{\s*$/)) {
5107             if (CHK("BRACES",
5108                 "Blank lines aren't necessary after an open brace '{'\n" . $hereprev) &&
5109                 $fix) {
5110                 fix_delete_line($fixlinenr, $rawline);
5111             }
5112         }
5113 
5114 # no volatiles please
5115         my $asm_volatile = qr{\b(__asm__|asm)\s+(__volatile__|volatile)\b};
5116         if ($line =~ /\bvolatile\b/ && $line !~ /$asm_volatile/) {
5117             WARN("VOLATILE",
5118                  "Use of volatile is usually wrong: see Documentation/process/volatile-considered-harmful.rst\n" . $herecurr);
5119         }
5120 
5121 # Check for user-visible strings broken across lines, which breaks the ability
5122 # to grep for the string.  Make exceptions when the previous string ends in a
5123 # newline (multiple lines in one string constant) or '\t', '\r', ';', or '{'
5124 # (common in inline assembly) or is a octal \123 or hexadecimal \xaf value
5125         if ($line =~ /^\+\s*$String/ &&
5126             $prevline =~ /"\s*$/ &&
5127             $prevrawline !~ /(?:\\(?:[ntr]|[0-7]{1,3}|x[0-9a-fA-F]{1,2})|;\s*|\{\s*)"\s*$/) {
5128             if (WARN("SPLIT_STRING",
5129                  "quoted string split across lines\n" . $hereprev) &&
5130                      $fix &&
5131                      $prevrawline =~ /^\+.*"\s*$/ &&
5132                      $last_coalesced_string_linenr != $linenr - 1) {
5133                 my $extracted_string = get_quoted_string($line, $rawline);
5134                 my $comma_close = "";
5135                 if ($rawline =~ /\Q$extracted_string\E(\s*\)\s*;\s*$|\s*,\s*)/) {
5136                     $comma_close = $1;
5137                 }
5138 
5139                 fix_delete_line($fixlinenr - 1, $prevrawline);
5140                 fix_delete_line($fixlinenr, $rawline);
5141                 my $fixedline = $prevrawline;
5142                 $fixedline =~ s/"\s*$//;
5143                 $fixedline .= substr($extracted_string, 1) . trim($comma_close);
5144                 fix_insert_line($fixlinenr - 1, $fixedline);
5145                 $fixedline = $rawline;
5146                 $fixedline =~ s/\Q$extracted_string\E\Q$comma_close\E//;
5147                 if ($fixedline !~ /\+\s*$/) {
5148                     fix_insert_line($fixlinenr, $fixedline);
5149                 }
5150                 $last_coalesced_string_linenr = $linenr;
5151             }
5152         }
5153 
5154 # check for missing a space in a string concatenation
5155         if ($prevrawline =~ /[^\\]\w"$/ && $rawline =~ /^\+[\t ]+"\w/) {
5156             WARN('MISSING_SPACE',
5157                  "break quoted strings at a space character\n" . $hereprev);
5158         }
5159 
5160 # check for spaces before a quoted newline
5161         if ($rawline =~ /^.*\".*\s\\n/) {
5162             if (WARN("QUOTED_WHITESPACE_BEFORE_NEWLINE",
5163                  "unnecessary whitespace before a quoted newline\n" . $herecurr) &&
5164                 $fix) {
5165                 $fixed[$fixlinenr] =~ s/^(\+.*\".*)\s+\\n/$1\\n/;
5166             }
5167 
5168         }
5169 
5170 # concatenated string without spaces between elements
5171         if ($line =~ /$String[A-Z_]/ || $line =~ /[A-Za-z0-9_]$String/) {
5172             CHK("CONCATENATED_STRING",
5173                 "Concatenated strings should use spaces between elements\n" . $herecurr);
5174         }
5175 
5176 # uncoalesced string fragments
5177         if ($line =~ /$String\s*"/) {
5178             WARN("STRING_FRAGMENTS",
5179                  "Consecutive strings are generally better as a single string\n" . $herecurr);
5180         }
5181 
5182 # check for %L{u,d,i} and 0x%[udi] in strings
5183         my $string;
5184         while ($line =~ /(?:^|")([X\t]*)(?:"|$)/g) {
5185             $string = substr($rawline, $-[1], $+[1] - $-[1]);
5186             $string =~ s/%%/__/g;
5187             if ($string =~ /(?<!%)%[\*\d\.\$]*L[udi]/) {
5188                 WARN("PRINTF_L",
5189                      "\%Ld/%Lu are not-standard C, use %lld/%llu\n" . $herecurr);
5190                 last;
5191             }
5192             if ($string =~ /0x%[\*\d\.\$\Llzth]*[udi]/) {
5193                 ERROR("PRINTF_0xDECIMAL",
5194                       "Prefixing 0x with decimal output is defective\n" . $herecurr);
5195             }
5196         }
5197 
5198 # check for line continuations in quoted strings with odd counts of "
5199         if ($rawline =~ /\\$/ && $rawline =~ tr/"/"/ % 2) {
5200             WARN("LINE_CONTINUATIONS",
5201                  "Avoid line continuations in quoted strings\n" . $herecurr);
5202         }
5203 
5204 # warn about #if 0
5205         if ($line =~ /^.\s*\#\s*if\s+0\b/) {
5206             CHK("REDUNDANT_CODE",
5207                 "if this code is redundant consider removing it\n" .
5208                 $herecurr);
5209         }
5210 
5211 # check for needless "if (<foo>) fn(<foo>)" uses
5212         if ($prevline =~ /\bif\s*\(\s*($Lval)\s*\)/) {
5213             my $tested = quotemeta($1);
5214             my $expr = '\s*\(\s*' . $tested . '\s*\)\s*;';
5215             if ($line =~ /\b(kfree|usb_free_urb|debugfs_remove(?:_recursive)?|(?:kmem_cache|mempool|dma_pool)_destroy)$expr/) {
5216                 my $func = $1;
5217                 if (WARN('NEEDLESS_IF',
5218                      "$func(NULL) is safe and this check is probably not required\n" . $hereprev) &&
5219                     $fix) {
5220                     my $do_fix = 1;
5221                     my $leading_tabs = "";
5222                     my $new_leading_tabs = "";
5223                     if ($lines[$linenr - 2] =~ /^\+(\t*)if\s*\(\s*$tested\s*\)\s*$/) {
5224                         $leading_tabs = $1;
5225                     } else {
5226                         $do_fix = 0;
5227                     }
5228                     if ($lines[$linenr - 1] =~ /^\+(\t+)$func\s*\(\s*$tested\s*\)\s*;\s*$/) {
5229                         $new_leading_tabs = $1;
5230                         if (length($leading_tabs) + 1 ne length($new_leading_tabs)) {
5231                             $do_fix = 0;
5232                         }
5233                     } else {
5234                         $do_fix = 0;
5235                     }
5236                     if ($do_fix) {
5237                         fix_delete_line($fixlinenr - 1, $prevrawline);
5238                         $fixed[$fixlinenr] =~ s/^\+$new_leading_tabs/\+$leading_tabs/;
5239                     }
5240                 }
5241             }
5242         }
5243 
5244 # check for unnecessary "Out of Memory" messages
5245         if ($line =~ /^\+.*\b$logFunctions\s*\(/ &&
5246             $prevline =~ /^[ \+]\s*if\s*\(\s*(\!\s*|NULL\s*==\s*)?($Lval)(\s*==\s*NULL\s*)?\s*\)/ &&
5247             (defined $1 || defined $3) &&
5248             $linenr > 3) {
5249             my $testval = $2;
5250             my $testline = $lines[$linenr - 3];
5251 
5252             my ($s, $c) = ctx_statement_block($linenr - 3, $realcnt, 0);
5253 #           print("line: <$line>\nprevline: <$prevline>\ns: <$s>\nc: <$c>\n\n\n");
5254 
5255             if ($c =~ /(?:^|\n)[ \+]\s*(?:$Type\s*)?\Q$testval\E\s*=\s*(?:\([^\)]*\)\s*)?\s*(?:devm_)?(?:[kv][czm]alloc(?:_node|_array)?\b|kstrdup|(?:dev_)?alloc_skb)/) {
5256                 WARN("OOM_MESSAGE",
5257                      "Possible unnecessary 'out of memory' message\n" . $hereprev);
5258             }
5259         }
5260 
5261 # check for logging functions with KERN_<LEVEL>
5262         if ($line !~ /printk(?:_ratelimited|_once)?\s*\(/ &&
5263             $line =~ /\b$logFunctions\s*\(.*\b(KERN_[A-Z]+)\b/) {
5264             my $level = $1;
5265             if (WARN("UNNECESSARY_KERN_LEVEL",
5266                  "Possible unnecessary $level\n" . $herecurr) &&
5267                 $fix) {
5268                 $fixed[$fixlinenr] =~ s/\s*$level\s*//;
5269             }
5270         }
5271 
5272 # check for mask then right shift without a parentheses
5273         if ($^V && $^V ge 5.10.0 &&
5274             $line =~ /$LvalOrFunc\s*\&\s*($LvalOrFunc)\s*>>/ &&
5275             $4 !~ /^\&/) { # $LvalOrFunc may be &foo, ignore if so
5276             WARN("MASK_THEN_SHIFT",
5277                  "Possible precedence defect with mask then right shift - may need parentheses\n" . $herecurr);
5278         }
5279 
5280 # check for pointer comparisons to NULL
5281         if ($^V && $^V ge 5.10.0) {
5282             while ($line =~ /\b$LvalOrFunc\s*(==|\!=)\s*NULL\b/g) {
5283                 my $val = $1;
5284                 my $equal = "!";
5285                 $equal = "" if ($4 eq "!=");
5286                 if (CHK("COMPARISON_TO_NULL",
5287                     "Comparison to NULL could be written \"${equal}${val}\"\n" . $herecurr) &&
5288                         $fix) {
5289                     $fixed[$fixlinenr] =~ s/\b\Q$val\E\s*(?:==|\!=)\s*NULL\b/$equal$val/;
5290                 }
5291             }
5292         }
5293 
5294 # check for bad placement of section $InitAttribute (e.g.: __initdata)
5295         if ($line =~ /(\b$InitAttribute\b)/) {
5296             my $attr = $1;
5297             if ($line =~ /^\+\s*static\s+(?:const\s+)?(?:$attr\s+)?($NonptrTypeWithAttr)\s+(?:$attr\s+)?($Ident(?:\[[^]]*\])?)\s*[=;]/) {
5298                 my $ptr = $1;
5299                 my $var = $2;
5300                 if ((($ptr =~ /\b(union|struct)\s+$attr\b/ &&
5301                       ERROR("MISPLACED_INIT",
5302                         "$attr should be placed after $var\n" . $herecurr)) ||
5303                      ($ptr !~ /\b(union|struct)\s+$attr\b/ &&
5304                       WARN("MISPLACED_INIT",
5305                        "$attr should be placed after $var\n" . $herecurr))) &&
5306                     $fix) {
5307                     $fixed[$fixlinenr] =~ 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;
5308                 }
5309             }
5310         }
5311 
5312 # check for $InitAttributeData (ie: __initdata) with const
5313         if ($line =~ /\bconst\b/ && $line =~ /($InitAttributeData)/) {
5314             my $attr = $1;
5315             $attr =~ /($InitAttributePrefix)(.*)/;
5316             my $attr_prefix = $1;
5317             my $attr_type = $2;
5318             if (ERROR("INIT_ATTRIBUTE",
5319                   "Use of const init definition must use ${attr_prefix}initconst\n" . $herecurr) &&
5320                 $fix) {
5321                 $fixed[$fixlinenr] =~
5322                     s/$InitAttributeData/${attr_prefix}initconst/;
5323             }
5324         }
5325 
5326 # check for $InitAttributeConst (ie: __initconst) without const
5327         if ($line !~ /\bconst\b/ && $line =~ /($InitAttributeConst)/) {
5328             my $attr = $1;
5329             if (ERROR("INIT_ATTRIBUTE",
5330                   "Use of $attr requires a separate use of const\n" . $herecurr) &&
5331                 $fix) {
5332                 my $lead = $fixed[$fixlinenr] =~
5333                     /(^\+\s*(?:static\s+))/;
5334                 $lead = rtrim($1);
5335                 $lead = "$lead " if ($lead !~ /^\+$/);
5336                 $lead = "${lead}const ";
5337                 $fixed[$fixlinenr] =~ s/(^\+\s*(?:static\s+))/$lead/;
5338             }
5339         }
5340 
5341 # check for __read_mostly with const non-pointer (should just be const)
5342         if ($line =~ /\b__read_mostly\b/ &&
5343             $line =~ /($Type)\s*$Ident/ && $1 !~ /\*\s*$/ && $1 =~ /\bconst\b/) {
5344             if (ERROR("CONST_READ_MOSTLY",
5345                   "Invalid use of __read_mostly with const type\n" . $herecurr) &&
5346                 $fix) {
5347                 $fixed[$fixlinenr] =~ s/\s+__read_mostly\b//;
5348             }
5349         }
5350 
5351 # don't use __constant_<foo> functions outside of include/uapi/
5352         if ($realfile !~ m@^include/uapi/@ &&
5353             $line =~ /(__constant_(?:htons|ntohs|[bl]e(?:16|32|64)_to_cpu|cpu_to_[bl]e(?:16|32|64)))\s*\(/) {
5354             my $constant_func = $1;
5355             my $func = $constant_func;
5356             $func =~ s/^__constant_//;
5357             if (WARN("CONSTANT_CONVERSION",
5358                  "$constant_func should be $func\n" . $herecurr) &&
5359                 $fix) {
5360                 $fixed[$fixlinenr] =~ s/\b$constant_func\b/$func/g;
5361             }
5362         }
5363 
5364 # prefer usleep_range over udelay
5365         if ($line =~ /\budelay\s*\(\s*(\d+)\s*\)/) {
5366             my $delay = $1;
5367             # ignore udelay's < 10, however
5368             if (! ($delay < 10) ) {
5369                 CHK("USLEEP_RANGE",
5370                     "usleep_range is preferred over udelay; see Documentation/timers/timers-howto.txt\n" . $herecurr);
5371             }
5372             if ($delay > 2000) {
5373                 WARN("LONG_UDELAY",
5374                      "long udelay - prefer mdelay; see arch/arm/include/asm/delay.h\n" . $herecurr);
5375             }
5376         }
5377 
5378 # warn about unexpectedly long msleep's
5379         if ($line =~ /\bmsleep\s*\((\d+)\);/) {
5380             if ($1 < 20) {
5381                 WARN("MSLEEP",
5382                      "msleep < 20ms can sleep for up to 20ms; see Documentation/timers/timers-howto.txt\n" . $herecurr);
5383             }
5384         }
5385 
5386 # check for comparisons of jiffies
5387         if ($line =~ /\bjiffies\s*$Compare|$Compare\s*jiffies\b/) {
5388             WARN("JIFFIES_COMPARISON",
5389                  "Comparing jiffies is almost always wrong; prefer time_after, time_before and friends\n" . $herecurr);
5390         }
5391 
5392 # check for comparisons of get_jiffies_64()
5393         if ($line =~ /\bget_jiffies_64\s*\(\s*\)\s*$Compare|$Compare\s*get_jiffies_64\s*\(\s*\)/) {
5394             WARN("JIFFIES_COMPARISON",
5395                  "Comparing get_jiffies_64() is almost always wrong; prefer time_after64, time_before64 and friends\n" . $herecurr);
5396         }
5397 
5398 # warn about #ifdefs in C files
5399 #       if ($line =~ /^.\s*\#\s*if(|n)def/ && ($realfile =~ /\.c$/)) {
5400 #           print "#ifdef in C files should be avoided\n";
5401 #           print "$herecurr";
5402 #           $clean = 0;
5403 #       }
5404 
5405 # warn about spacing in #ifdefs
5406         if ($line =~ /^.\s*\#\s*(ifdef|ifndef|elif)\s\s+/) {
5407             if (ERROR("SPACING",
5408                   "exactly one space required after that #$1\n" . $herecurr) &&
5409                 $fix) {
5410                 $fixed[$fixlinenr] =~
5411                     s/^(.\s*\#\s*(ifdef|ifndef|elif))\s{2,}/$1 /;
5412             }
5413 
5414         }
5415 
5416 # check for spinlock_t definitions without a comment.
5417         if ($line =~ /^.\s*(struct\s+mutex|spinlock_t)\s+\S+;/ ||
5418             $line =~ /^.\s*(DEFINE_MUTEX)\s*\(/) {
5419             my $which = $1;
5420             if (!ctx_has_comment($first_line, $linenr)) {
5421                 CHK("UNCOMMENTED_DEFINITION",
5422                     "$1 definition without comment\n" . $herecurr);
5423             }
5424         }
5425 # check for memory barriers without a comment.
5426 
5427         my $barriers = qr{
5428             mb|
5429             rmb|
5430             wmb|
5431             read_barrier_depends
5432         }x;
5433         my $barrier_stems = qr{
5434             mb__before_atomic|
5435             mb__after_atomic|
5436             store_release|
5437             load_acquire|
5438             store_mb|
5439             (?:$barriers)
5440         }x;
5441         my $all_barriers = qr{
5442             (?:$barriers)|
5443             smp_(?:$barrier_stems)|
5444             virt_(?:$barrier_stems)
5445         }x;
5446 
5447         if ($line =~ /\b(?:$all_barriers)\s*\(/) {
5448             if (!ctx_has_comment($first_line, $linenr)) {
5449                 WARN("MEMORY_BARRIER",
5450                      "memory barrier without comment\n" . $herecurr);
5451             }
5452         }
5453 
5454         my $underscore_smp_barriers = qr{__smp_(?:$barrier_stems)}x;
5455 
5456         if ($realfile !~ m@^include/asm-generic/@ &&
5457             $realfile !~ m@/barrier\.h$@ &&
5458             $line =~ m/\b(?:$underscore_smp_barriers)\s*\(/ &&
5459             $line !~ m/^.\s*\#\s*define\s+(?:$underscore_smp_barriers)\s*\(/) {
5460             WARN("MEMORY_BARRIER",
5461                  "__smp memory barriers shouldn't be used outside barrier.h and asm-generic\n" . $herecurr);
5462         }
5463 
5464 # check for waitqueue_active without a comment.
5465         if ($line =~ /\bwaitqueue_active\s*\(/) {
5466             if (!ctx_has_comment($first_line, $linenr)) {
5467                 WARN("WAITQUEUE_ACTIVE",
5468                      "waitqueue_active without comment\n" . $herecurr);
5469             }
5470         }
5471 
5472 # Check for expedited grace periods that interrupt non-idle non-nohz
5473 # online CPUs.  These expedited can therefore degrade real-time response
5474 # if used carelessly, and should be avoided where not absolutely
5475 # needed.  It is always OK to use synchronize_rcu_expedited() and
5476 # synchronize_sched_expedited() at boot time (before real-time applications
5477 # start) and in error situations where real-time response is compromised in
5478 # any case.  Note that synchronize_srcu_expedited() does -not- interrupt
5479 # other CPUs, so don't warn on uses of synchronize_srcu_expedited().
5480 # Of course, nothing comes for free, and srcu_read_lock() and
5481 # srcu_read_unlock() do contain full memory barriers in payment for
5482 # synchronize_srcu_expedited() non-interruption properties.
5483         if ($line =~ /\b(synchronize_rcu_expedited|synchronize_sched_expedited)\(/) {
5484             WARN("EXPEDITED_RCU_GRACE_PERIOD",
5485                  "expedited RCU grace periods should be avoided where they can degrade real-time response\n" . $herecurr);
5486 
5487         }
5488 
5489 # check of hardware specific defines
5490         if ($line =~ m@^.\s*\#\s*if.*\b(__i386__|__powerpc64__|__sun__|__s390x__)\b@ && $realfile !~ m@include/asm-@) {
5491             CHK("ARCH_DEFINES",
5492                 "architecture specific defines should be avoided\n" .  $herecurr);
5493         }
5494 
5495 # Check that the storage class is at the beginning of a declaration
5496         if ($line =~ /\b$Storage\b/ && $line !~ /^.\s*$Storage\b/) {
5497             WARN("STORAGE_CLASS",
5498                  "storage class should be at the beginning of the declaration\n" . $herecurr)
5499         }
5500 
5501 # check the location of the inline attribute, that it is between
5502 # storage class and type.
5503         if ($line =~ /\b$Type\s+$Inline\b/ ||
5504             $line =~ /\b$Inline\s+$Storage\b/) {
5505             ERROR("INLINE_LOCATION",
5506                   "inline keyword should sit between storage class and type\n" . $herecurr);
5507         }
5508 
5509 # Check for __inline__ and __inline, prefer inline
5510         if ($realfile !~ m@\binclude/uapi/@ &&
5511             $line =~ /\b(__inline__|__inline)\b/) {
5512             if (WARN("INLINE",
5513                  "plain inline is preferred over $1\n" . $herecurr) &&
5514                 $fix) {
5515                 $fixed[$fixlinenr] =~ s/\b(__inline__|__inline)\b/inline/;
5516 
5517             }
5518         }
5519 
5520 # Check for __attribute__ packed, prefer __packed
5521         if ($realfile !~ m@\binclude/uapi/@ &&
5522             $line =~ /\b__attribute__\s*\(\s*\(.*\bpacked\b/) {
5523             WARN("PREFER_PACKED",
5524                  "__packed is preferred over __attribute__((packed))\n" . $herecurr);
5525         }
5526 
5527 # Check for __attribute__ aligned, prefer __aligned
5528         if ($realfile !~ m@\binclude/uapi/@ &&
5529             $line =~ /\b__attribute__\s*\(\s*\(.*aligned/) {
5530             WARN("PREFER_ALIGNED",
5531                  "__aligned(size) is preferred over __attribute__((aligned(size)))\n" . $herecurr);
5532         }
5533 
5534 # Check for __attribute__ format(printf, prefer __printf
5535         if ($realfile !~ m@\binclude/uapi/@ &&
5536             $line =~ /\b__attribute__\s*\(\s*\(\s*format\s*\(\s*printf/) {
5537             if (WARN("PREFER_PRINTF",
5538                  "__printf(string-index, first-to-check) is preferred over __attribute__((format(printf, string-index, first-to-check)))\n" . $herecurr) &&
5539                 $fix) {
5540                 $fixed[$fixlinenr] =~ s/\b__attribute__\s*\(\s*\(\s*format\s*\(\s*printf\s*,\s*(.*)\)\s*\)\s*\)/"__printf(" . trim($1) . ")"/ex;
5541 
5542             }
5543         }
5544 
5545 # Check for __attribute__ format(scanf, prefer __scanf
5546         if ($realfile !~ m@\binclude/uapi/@ &&
5547             $line =~ /\b__attribute__\s*\(\s*\(\s*format\s*\(\s*scanf\b/) {
5548             if (WARN("PREFER_SCANF",
5549                  "__scanf(string-index, first-to-check) is preferred over __attribute__((format(scanf, string-index, first-to-check)))\n" . $herecurr) &&
5550                 $fix) {
5551                 $fixed[$fixlinenr] =~ s/\b__attribute__\s*\(\s*\(\s*format\s*\(\s*scanf\s*,\s*(.*)\)\s*\)\s*\)/"__scanf(" . trim($1) . ")"/ex;
5552             }
5553         }
5554 
5555 # Check for __attribute__ weak, or __weak declarations (may have link issues)
5556         if ($^V && $^V ge 5.10.0 &&
5557             $line =~ /(?:$Declare|$DeclareMisordered)\s*$Ident\s*$balanced_parens\s*(?:$Attribute)?\s*;/ &&
5558             ($line =~ /\b__attribute__\s*\(\s*\(.*\bweak\b/ ||
5559              $line =~ /\b__weak\b/)) {
5560             ERROR("WEAK_DECLARATION",
5561                   "Using weak declarations can have unintended link defects\n" . $herecurr);
5562         }
5563 
5564 # check for c99 types like uint8_t used outside of uapi/ and tools/
5565         if ($realfile !~ m@\binclude/uapi/@ &&
5566             $realfile !~ m@\btools/@ &&
5567             $line =~ /\b($Declare)\s*$Ident\s*[=;,\[]/) {
5568             my $type = $1;
5569             if ($type =~ /\b($typeC99Typedefs)\b/) {
5570                 $type = $1;
5571                 my $kernel_type = 'u';
5572                 $kernel_type = 's' if ($type =~ /^_*[si]/);
5573                 $type =~ /(\d+)/;
5574                 $kernel_type .= $1;
5575                 if (CHK("PREFER_KERNEL_TYPES",
5576                     "Prefer kernel type '$kernel_type' over '$type'\n" . $herecurr) &&
5577                     $fix) {
5578                     $fixed[$fixlinenr] =~ s/\b$type\b/$kernel_type/;
5579                 }
5580             }
5581         }
5582 
5583 # check for cast of C90 native int or longer types constants
5584         if ($line =~ /(\(\s*$C90_int_types\s*\)\s*)($Constant)\b/) {
5585             my $cast = $1;
5586             my $const = $2;
5587             if (WARN("TYPECAST_INT_CONSTANT",
5588                  "Unnecessary typecast of c90 int constant\n" . $herecurr) &&
5589                 $fix) {
5590                 my $suffix = "";
5591                 my $newconst = $const;
5592                 $newconst =~ s/${Int_type}$//;
5593                 $suffix .= 'U' if ($cast =~ /\bunsigned\b/);
5594                 if ($cast =~ /\blong\s+long\b/) {
5595                     $suffix .= 'LL';
5596                 } elsif ($cast =~ /\blong\b/) {
5597                     $suffix .= 'L';
5598                 }
5599                 $fixed[$fixlinenr] =~ s/\Q$cast\E$const\b/$newconst$suffix/;
5600             }
5601         }
5602 
5603 # check for sizeof(&)
5604         if ($line =~ /\bsizeof\s*\(\s*\&/) {
5605             WARN("SIZEOF_ADDRESS",
5606                  "sizeof(& should be avoided\n" . $herecurr);
5607         }
5608 
5609 # check for sizeof without parenthesis
5610         if ($line =~ /\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/) {
5611             if (WARN("SIZEOF_PARENTHESIS",
5612                  "sizeof $1 should be sizeof($1)\n" . $herecurr) &&
5613                 $fix) {
5614                 $fixed[$fixlinenr] =~ s/\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/"sizeof(" . trim($1) . ")"/ex;
5615             }
5616         }
5617 
5618 # check for struct spinlock declarations
5619         if ($line =~ /^.\s*\bstruct\s+spinlock\s+\w+\s*;/) {
5620             WARN("USE_SPINLOCK_T",
5621                  "struct spinlock should be spinlock_t\n" . $herecurr);
5622         }
5623 
5624 # check for seq_printf uses that could be seq_puts
5625         if ($sline =~ /\bseq_printf\s*\(.*"\s*\)\s*;\s*$/) {
5626             my $fmt = get_quoted_string($line, $rawline);
5627             $fmt =~ s/%%//g;
5628             if ($fmt !~ /%/) {
5629                 if (WARN("PREFER_SEQ_PUTS",
5630                      "Prefer seq_puts to seq_printf\n" . $herecurr) &&
5631                     $fix) {
5632                     $fixed[$fixlinenr] =~ s/\bseq_printf\b/seq_puts/;
5633                 }
5634             }
5635         }
5636 
5637 # Check for misused memsets
5638         if ($^V && $^V ge 5.10.0 &&
5639             defined $stat &&
5640             $stat =~ /^\+(?:.*?)\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*$FuncArg\s*\)/) {
5641 
5642             my $ms_addr = $2;
5643             my $ms_val = $7;
5644             my $ms_size = $12;
5645 
5646             if ($ms_size =~ /^(0x|)0$/i) {
5647                 ERROR("MEMSET",
5648                       "memset to 0's uses 0 as the 2nd argument, not the 3rd\n" . "$here\n$stat\n");
5649             } elsif ($ms_size =~ /^(0x|)1$/i) {
5650                 WARN("MEMSET",
5651                      "single byte memset is suspicious. Swapped 2nd/3rd argument?\n" . "$here\n$stat\n");
5652             }
5653         }
5654 
5655 # Check for memcpy(foo, bar, ETH_ALEN) that could be ether_addr_copy(foo, bar)
5656 #       if ($^V && $^V ge 5.10.0 &&
5657 #           defined $stat &&
5658 #           $stat =~ /^\+(?:.*?)\bmemcpy\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/) {
5659 #           if (WARN("PREFER_ETHER_ADDR_COPY",
5660 #                "Prefer ether_addr_copy() over memcpy() if the Ethernet addresses are __aligned(2)\n" . "$here\n$stat\n") &&
5661 #               $fix) {
5662 #               $fixed[$fixlinenr] =~ s/\bmemcpy\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/ether_addr_copy($2, $7)/;
5663 #           }
5664 #       }
5665 
5666 # Check for memcmp(foo, bar, ETH_ALEN) that could be ether_addr_equal*(foo, bar)
5667 #       if ($^V && $^V ge 5.10.0 &&
5668 #           defined $stat &&
5669 #           $stat =~ /^\+(?:.*?)\bmemcmp\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/) {
5670 #           WARN("PREFER_ETHER_ADDR_EQUAL",
5671 #                "Prefer ether_addr_equal() or ether_addr_equal_unaligned() over memcmp()\n" . "$here\n$stat\n")
5672 #       }
5673 
5674 # check for memset(foo, 0x0, ETH_ALEN) that could be eth_zero_addr
5675 # check for memset(foo, 0xFF, ETH_ALEN) that could be eth_broadcast_addr
5676 #       if ($^V && $^V ge 5.10.0 &&
5677 #           defined $stat &&
5678 #           $stat =~ /^\+(?:.*?)\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/) {
5679 #
5680 #           my $ms_val = $7;
5681 #
5682 #           if ($ms_val =~ /^(?:0x|)0+$/i) {
5683 #               if (WARN("PREFER_ETH_ZERO_ADDR",
5684 #                    "Prefer eth_zero_addr over memset()\n" . "$here\n$stat\n") &&
5685 #                   $fix) {
5686 #                   $fixed[$fixlinenr] =~ s/\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*,\s*ETH_ALEN\s*\)/eth_zero_addr($2)/;
5687 #               }
5688 #           } elsif ($ms_val =~ /^(?:0xff|255)$/i) {
5689 #               if (WARN("PREFER_ETH_BROADCAST_ADDR",
5690 #                    "Prefer eth_broadcast_addr() over memset()\n" . "$here\n$stat\n") &&
5691 #                   $fix) {
5692 #                   $fixed[$fixlinenr] =~ s/\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*,\s*ETH_ALEN\s*\)/eth_broadcast_addr($2)/;
5693 #               }
5694 #           }
5695 #       }
5696 
5697 # typecasts on min/max could be min_t/max_t
5698         if ($^V && $^V ge 5.10.0 &&
5699             defined $stat &&
5700             $stat =~ /^\+(?:.*?)\b(min|max)\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\)/) {
5701             if (defined $2 || defined $7) {
5702                 my $call = $1;
5703                 my $cast1 = deparenthesize($2);
5704                 my $arg1 = $3;
5705                 my $cast2 = deparenthesize($7);
5706                 my $arg2 = $8;
5707                 my $cast;
5708 
5709                 if ($cast1 ne "" && $cast2 ne "" && $cast1 ne $cast2) {
5710                     $cast = "$cast1 or $cast2";
5711                 } elsif ($cast1 ne "") {
5712                     $cast = $cast1;
5713                 } else {
5714                     $cast = $cast2;
5715                 }
5716                 WARN("MINMAX",
5717                      "$call() should probably be ${call}_t($cast, $arg1, $arg2)\n" . "$here\n$stat\n");
5718             }
5719         }
5720 
5721 # check usleep_range arguments
5722         if ($^V && $^V ge 5.10.0 &&
5723             defined $stat &&
5724             $stat =~ /^\+(?:.*?)\busleep_range\s*\(\s*($FuncArg)\s*,\s*($FuncArg)\s*\)/) {
5725             my $min = $1;
5726             my $max = $7;
5727             if ($min eq $max) {
5728                 WARN("USLEEP_RANGE",
5729                      "usleep_range should not use min == max args; see Documentation/timers/timers-howto.txt\n" . "$here\n$stat\n");
5730             } elsif ($min =~ /^\d+$/ && $max =~ /^\d+$/ &&
5731                  $min > $max) {
5732                 WARN("USLEEP_RANGE",
5733                      "usleep_range args reversed, use min then max; see Documentation/timers/timers-howto.txt\n" . "$here\n$stat\n");
5734             }
5735         }
5736 
5737 # check for naked sscanf
5738         if ($^V && $^V ge 5.10.0 &&
5739             defined $stat &&
5740             $line =~ /\bsscanf\b/ &&
5741             ($stat !~ /$Ident\s*=\s*sscanf\s*$balanced_parens/ &&
5742              $stat !~ /\bsscanf\s*$balanced_parens\s*(?:$Compare)/ &&
5743              $stat !~ /(?:$Compare)\s*\bsscanf\s*$balanced_parens/)) {
5744             my $lc = $stat =~ tr@\n@@;
5745             $lc = $lc + $linenr;
5746             my $stat_real = raw_line($linenr, 0);
5747                 for (my $count = $linenr + 1; $count <= $lc; $count++) {
5748                 $stat_real = $stat_real . "\n" . raw_line($count, 0);
5749             }
5750             WARN("NAKED_SSCANF",
5751                  "unchecked sscanf return value\n" . "$here\n$stat_real\n");
5752         }
5753 
5754 # check for simple sscanf that should be kstrto<foo>
5755         if ($^V && $^V ge 5.10.0 &&
5756             defined $stat &&
5757             $line =~ /\bsscanf\b/) {
5758             my $lc = $stat =~ tr@\n@@;
5759             $lc = $lc + $linenr;
5760             my $stat_real = raw_line($linenr, 0);
5761                 for (my $count = $linenr + 1; $count <= $lc; $count++) {
5762                 $stat_real = $stat_real . "\n" . raw_line($count, 0);
5763             }
5764             if ($stat_real =~ /\bsscanf\b\s*\(\s*$FuncArg\s*,\s*("[^"]+")/) {
5765                 my $format = $6;
5766                 my $count = $format =~ tr@%@%@;
5767                 if ($count == 1 &&
5768                     $format =~ /^"\%(?i:ll[udxi]|[udxi]ll|ll|[hl]h?[udxi]|[udxi][hl]h?|[hl]h?|[udxi])"$/) {
5769                     WARN("SSCANF_TO_KSTRTO",
5770                          "Prefer kstrto<type> to single variable sscanf\n" . "$here\n$stat_real\n");
5771                 }
5772             }
5773         }
5774 
5775 # check for new externs in .h files.
5776         if ($realfile =~ /\.h$/ &&
5777             $line =~ /^\+\s*(extern\s+)$Type\s*$Ident\s*\(/s) {
5778             if (CHK("AVOID_EXTERNS",
5779                 "extern prototypes should be avoided in .h files\n" . $herecurr) &&
5780                 $fix) {
5781                 $fixed[$fixlinenr] =~ s/(.*)\bextern\b\s*(.*)/$1$2/;
5782             }
5783         }
5784 
5785 # check for new externs in .c files.
5786         if ($realfile =~ /\.c$/ && defined $stat &&
5787             $stat =~ /^.\s*(?:extern\s+)?$Type\s+($Ident)(\s*)\(/s)
5788         {
5789             my $function_name = $1;
5790             my $paren_space = $2;
5791 
5792             my $s = $stat;
5793             if (defined $cond) {
5794                 substr($s, 0, length($cond), '');
5795             }
5796             if ($s =~ /^\s*;/ &&
5797                 $function_name ne 'uninitialized_var')
5798             {
5799                 WARN("AVOID_EXTERNS",
5800                      "externs should be avoided in .c files\n" .  $herecurr);
5801             }
5802 
5803             if ($paren_space =~ /\n/) {
5804                 WARN("FUNCTION_ARGUMENTS",
5805                      "arguments for function declarations should follow identifier\n" . $herecurr);
5806             }
5807 
5808         } elsif ($realfile =~ /\.c$/ && defined $stat &&
5809             $stat =~ /^.\s*extern\s+/)
5810         {
5811             WARN("AVOID_EXTERNS",
5812                  "externs should be avoided in .c files\n" .  $herecurr);
5813         }
5814 
5815         if ($realfile =~ /\.[ch]$/ && defined $stat &&
5816             $stat =~ /^.\s*(?:extern\s+)?$Type\s*$Ident\s*\(\s*([^{]+)\s*\)\s*;/s &&
5817             $1 ne "void") {
5818             my $args = trim($1);
5819             while ($args =~ m/\s*($Type\s*(?:$Ident|\(\s*\*\s*$Ident?\s*\)\s*$balanced_parens)?)/g) {
5820                 my $arg = trim($1);
5821                 if ($arg =~ /^$Type$/ && $arg !~ /enum\s+$Ident$/) {
5822                     WARN("FUNCTION_ARGUMENTS",
5823                          "function definition argument '$arg' should also have an identifier name\n" . $herecurr);
5824                 }
5825             }
5826         }
5827 
5828 # checks for new __setup's
5829         if ($rawline =~ /\b__setup\("([^"]*)"/) {
5830             my $name = $1;
5831 
5832             if (!grep(/$name/, @setup_docs)) {
5833                 CHK("UNDOCUMENTED_SETUP",
5834                     "__setup appears un-documented -- check Documentation/admin-guide/kernel-parameters.rst\n" . $herecurr);
5835             }
5836         }
5837 
5838 # check for pointless casting of kmalloc return
5839         if ($line =~ /\*\s*\)\s*[kv][czm]alloc(_node){0,1}\b/) {
5840             WARN("UNNECESSARY_CASTS",
5841                  "unnecessary cast may hide bugs, see http://c-faq.com/malloc/mallocnocast.html\n" . $herecurr);
5842         }
5843 
5844 # alloc style
5845 # p = alloc(sizeof(struct foo), ...) should be p = alloc(sizeof(*p), ...)
5846         if ($^V && $^V ge 5.10.0 &&
5847             $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*([kv][mz]alloc(?:_node)?)\s*\(\s*(sizeof\s*\(\s*struct\s+$Lval\s*\))/) {
5848             CHK("ALLOC_SIZEOF_STRUCT",
5849                 "Prefer $3(sizeof(*$1)...) over $3($4...)\n" . $herecurr);
5850         }
5851 
5852 # check for k[mz]alloc with multiplies that could be kmalloc_array/kcalloc
5853         if ($^V && $^V ge 5.10.0 &&
5854             $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*(k[mz]alloc)\s*\(\s*($FuncArg)\s*\*\s*($FuncArg)\s*,/) {
5855             my $oldfunc = $3;
5856             my $a1 = $4;
5857             my $a2 = $10;
5858             my $newfunc = "kmalloc_array";
5859             $newfunc = "kcalloc" if ($oldfunc eq "kzalloc");
5860             my $r1 = $a1;
5861             my $r2 = $a2;
5862             if ($a1 =~ /^sizeof\s*\S/) {
5863                 $r1 = $a2;
5864                 $r2 = $a1;
5865             }
5866             if ($r1 !~ /^sizeof\b/ && $r2 =~ /^sizeof\s*\S/ &&
5867                 !($r1 =~ /^$Constant$/ || $r1 =~ /^[A-Z_][A-Z0-9_]*$/)) {
5868                 if (WARN("ALLOC_WITH_MULTIPLY",
5869                      "Prefer $newfunc over $oldfunc with multiply\n" . $herecurr) &&
5870                     $fix) {
5871                     $fixed[$fixlinenr] =~ s/\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*(k[mz]alloc)\s*\(\s*($FuncArg)\s*\*\s*($FuncArg)/$1 . ' = ' . "$newfunc(" . trim($r1) . ', ' . trim($r2)/e;
5872 
5873                 }
5874             }
5875         }
5876 
5877 # check for krealloc arg reuse
5878         if ($^V && $^V ge 5.10.0 &&
5879             $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*krealloc\s*\(\s*\1\s*,/) {
5880             WARN("KREALLOC_ARG_REUSE",
5881                  "Reusing the krealloc arg is almost always a bug\n" . $herecurr);
5882         }
5883 
5884 # check for alloc argument mismatch
5885         if ($line =~ /\b(kcalloc|kmalloc_array)\s*\(\s*sizeof\b/) {
5886             WARN("ALLOC_ARRAY_ARGS",
5887                  "$1 uses number as first arg, sizeof is generally wrong\n" . $herecurr);
5888         }
5889 
5890 # check for multiple semicolons
5891         if ($line =~ /;\s*;\s*$/) {
5892             if (WARN("ONE_SEMICOLON",
5893                  "Statements terminations use 1 semicolon\n" . $herecurr) &&
5894                 $fix) {
5895                 $fixed[$fixlinenr] =~ s/(\s*;\s*){2,}$/;/g;
5896             }
5897         }
5898 
5899 # check for #defines like: 1 << <digit> that could be BIT(digit), it is not exported to uapi
5900         if ($realfile !~ m@^include/uapi/@ &&
5901             $line =~ /#\s*define\s+\w+\s+\(?\s*1\s*([ulUL]*)\s*\<\<\s*(?:\d+|$Ident)\s*\)?/) {
5902             my $ull = "";
5903             $ull = "_ULL" if (defined($1) && $1 =~ /ll/i);
5904             if (CHK("BIT_MACRO",
5905                 "Prefer using the BIT$ull macro\n" . $herecurr) &&
5906                 $fix) {
5907                 $fixed[$fixlinenr] =~ s/\(?\s*1\s*[ulUL]*\s*<<\s*(\d+|$Ident)\s*\)?/BIT${ull}($1)/;
5908             }
5909         }
5910 
5911 # check for #if defined CONFIG_<FOO> || defined CONFIG_<FOO>_MODULE
5912         if ($line =~ /^\+\s*#\s*if\s+defined(?:\s*\(?\s*|\s+)(CONFIG_[A-Z_]+)\s*\)?\s*\|\|\s*defined(?:\s*\(?\s*|\s+)\1_MODULE\s*\)?\s*$/) {
5913             my $config = $1;
5914             if (WARN("PREFER_IS_ENABLED",
5915                  "Prefer IS_ENABLED(<FOO>) to CONFIG_<FOO> || CONFIG_<FOO>_MODULE\n" . $herecurr) &&
5916                 $fix) {
5917                 $fixed[$fixlinenr] = "\+#if IS_ENABLED($config)";
5918             }
5919         }
5920 
5921 # check for case / default statements not preceded by break/fallthrough/switch
5922         if ($line =~ /^.\s*(?:case\s+(?:$Ident|$Constant)\s*|default):/) {
5923             my $has_break = 0;
5924             my $has_statement = 0;
5925             my $count = 0;
5926             my $prevline = $linenr;
5927             while ($prevline > 1 && ($file || $count < 3) && !$has_break) {
5928                 $prevline--;
5929                 my $rline = $rawlines[$prevline - 1];
5930                 my $fline = $lines[$prevline - 1];
5931                 last if ($fline =~ /^\@\@/);
5932                 next if ($fline =~ /^\-/);
5933                 next if ($fline =~ /^.(?:\s*(?:case\s+(?:$Ident|$Constant)[\s$;]*|default):[\s$;]*)*$/);
5934                 $has_break = 1 if ($rline =~ /fall[\s_-]*(through|thru)/i);
5935                 next if ($fline =~ /^.[\s$;]*$/);
5936                 $has_statement = 1;
5937                 $count++;
5938                 $has_break = 1 if ($fline =~ /\bswitch\b|\b(?:break\s*;[\s$;]*$|return\b|goto\b|continue\b)/);
5939             }
5940             if (!$has_break && $has_statement) {
5941                 WARN("MISSING_BREAK",
5942                      "Possible switch case/default not preceded by break or fallthrough comment\n" . $herecurr);
5943             }
5944         }
5945 
5946 # check for switch/default statements without a break;
5947         if ($^V && $^V ge 5.10.0 &&
5948             defined $stat &&
5949             $stat =~ /^\+[$;\s]*(?:case[$;\s]+\w+[$;\s]*:[$;\s]*|)*[$;\s]*\bdefault[$;\s]*:[$;\s]*;/g) {
5950             my $ctx = '';
5951             my $herectx = $here . "\n";
5952             my $cnt = statement_rawlines($stat);
5953             for (my $n = 0; $n < $cnt; $n++) {
5954                 $herectx .= raw_line($linenr, $n) . "\n";
5955             }
5956             WARN("DEFAULT_NO_BREAK",
5957                  "switch default: should use break\n" . $herectx);
5958         }
5959 
5960 # check for gcc specific __FUNCTION__
5961         if ($line =~ /\b__FUNCTION__\b/) {
5962             if (WARN("USE_FUNC",
5963                  "__func__ should be used instead of gcc specific __FUNCTION__\n"  . $herecurr) &&
5964                 $fix) {
5965                 $fixed[$fixlinenr] =~ s/\b__FUNCTION__\b/__func__/g;
5966             }
5967         }
5968 
5969 # check for uses of __DATE__, __TIME__, __TIMESTAMP__
5970         while ($line =~ /\b(__(?:DATE|TIME|TIMESTAMP)__)\b/g) {
5971             ERROR("DATE_TIME",
5972                   "Use of the '$1' macro makes the build non-deterministic\n" . $herecurr);
5973         }
5974 
5975 # check for use of yield()
5976         if ($line =~ /\byield\s*\(\s*\)/) {
5977             WARN("YIELD",
5978                  "Using yield() is generally wrong. See yield() kernel-doc (sched/core.c)\n"  . $herecurr);
5979         }
5980 
5981 # check for comparisons against true and false
5982         if ($line =~ /\+\s*(.*?)\b(true|false|$Lval)\s*(==|\!=)\s*(true|false|$Lval)\b(.*)$/i) {
5983             my $lead = $1;
5984             my $arg = $2;
5985             my $test = $3;
5986             my $otype = $4;
5987             my $trail = $5;
5988             my $op = "!";
5989 
5990             ($arg, $otype) = ($otype, $arg) if ($arg =~ /^(?:true|false)$/i);
5991 
5992             my $type = lc($otype);
5993             if ($type =~ /^(?:true|false)$/) {
5994                 if (("$test" eq "==" && "$type" eq "true") ||
5995                     ("$test" eq "!=" && "$type" eq "false")) {
5996                     $op = "";
5997                 }
5998 
5999                 CHK("BOOL_COMPARISON",
6000                     "Using comparison to $otype is error prone\n" . $herecurr);
6001 
6002 ## maybe suggesting a correct construct would better
6003 ##                  "Using comparison to $otype is error prone.  Perhaps use '${lead}${op}${arg}${trail}'\n" . $herecurr);
6004 
6005             }
6006         }
6007 
6008 # check for semaphores initialized locked
6009         if ($line =~ /^.\s*sema_init.+,\W?0\W?\)/) {
6010             WARN("CONSIDER_COMPLETION",
6011                  "consider using a completion\n" . $herecurr);
6012         }
6013 
6014 # recommend kstrto* over simple_strto* and strict_strto*
6015         if ($line =~ /\b((simple|strict)_(strto(l|ll|ul|ull)))\s*\(/) {
6016             WARN("CONSIDER_KSTRTO",
6017                  "$1 is obsolete, use k$3 instead\n" . $herecurr);
6018         }
6019 
6020 # check for __initcall(), use device_initcall() explicitly or more appropriate function please
6021         if ($line =~ /^.\s*__initcall\s*\(/) {
6022             WARN("USE_DEVICE_INITCALL",
6023                  "please use device_initcall() or more appropriate function instead of __initcall() (see include/linux/init.h)\n" . $herecurr);
6024         }
6025 
6026 # check for various structs that are normally const (ops, kgdb, device_tree)
6027         if ($line !~ /\bconst\b/ &&
6028             $line =~ /\bstruct\s+($const_structs)\b/) {
6029             WARN("CONST_STRUCT",
6030                  "struct $1 should normally be const\n" .
6031                 $herecurr);
6032         }
6033 
6034 # use of NR_CPUS is usually wrong
6035 # ignore definitions of NR_CPUS and usage to define arrays as likely right
6036         if ($line =~ /\bNR_CPUS\b/ &&
6037             $line !~ /^.\s*\s*#\s*if\b.*\bNR_CPUS\b/ &&
6038             $line !~ /^.\s*\s*#\s*define\b.*\bNR_CPUS\b/ &&
6039             $line !~ /^.\s*$Declare\s.*\[[^\]]*NR_CPUS[^\]]*\]/ &&
6040             $line !~ /\[[^\]]*\.\.\.[^\]]*NR_CPUS[^\]]*\]/ &&
6041             $line !~ /\[[^\]]*NR_CPUS[^\]]*\.\.\.[^\]]*\]/)
6042         {
6043             WARN("NR_CPUS",
6044                  "usage of NR_CPUS is often wrong - consider using cpu_possible(), num_possible_cpus(), for_each_possible_cpu(), etc\n" . $herecurr);
6045         }
6046 
6047 # Use of __ARCH_HAS_<FOO> or ARCH_HAVE_<BAR> is wrong.
6048         if ($line =~ /\+\s*#\s*define\s+((?:__)?ARCH_(?:HAS|HAVE)\w*)\b/) {
6049             ERROR("DEFINE_ARCH_HAS",
6050                   "#define of '$1' is wrong - use Kconfig variables or standard guards instead\n" . $herecurr);
6051         }
6052 
6053 # likely/unlikely comparisons similar to "(likely(foo) > 0)"
6054         if ($^V && $^V ge 5.10.0 &&
6055             $line =~ /\b((?:un)?likely)\s*\(\s*$FuncArg\s*\)\s*$Compare/) {
6056             WARN("LIKELY_MISUSE",
6057                  "Using $1 should generally have parentheses around the comparison\n" . $herecurr);
6058         }
6059 
6060 # whine mightly about in_atomic
6061         if ($line =~ /\bin_atomic\s*\(/) {
6062             if ($realfile =~ m@^drivers/@) {
6063                 ERROR("IN_ATOMIC",
6064                       "do not use in_atomic in drivers\n" . $herecurr);
6065             } elsif ($realfile !~ m@^kernel/@) {
6066                 WARN("IN_ATOMIC",
6067                      "use of in_atomic() is incorrect outside core kernel code\n" . $herecurr);
6068             }
6069         }
6070 
6071 # whine about ACCESS_ONCE
6072         if ($^V && $^V ge 5.10.0 &&
6073             $line =~ /\bACCESS_ONCE\s*$balanced_parens\s*(=(?!=))?\s*($FuncArg)?/) {
6074             my $par = $1;
6075             my $eq = $2;
6076             my $fun = $3;
6077             $par =~ s/^\(\s*(.*)\s*\)$/$1/;
6078             if (defined($eq)) {
6079                 if (WARN("PREFER_WRITE_ONCE",
6080                      "Prefer WRITE_ONCE(<FOO>, <BAR>) over ACCESS_ONCE(<FOO>) = <BAR>\n" . $herecurr) &&
6081                     $fix) {
6082                     $fixed[$fixlinenr] =~ s/\bACCESS_ONCE\s*\(\s*\Q$par\E\s*\)\s*$eq\s*\Q$fun\E/WRITE_ONCE($par, $fun)/;
6083                 }
6084             } else {
6085                 if (WARN("PREFER_READ_ONCE",
6086                      "Prefer READ_ONCE(<FOO>) over ACCESS_ONCE(<FOO>)\n" . $herecurr) &&
6087                     $fix) {
6088                     $fixed[$fixlinenr] =~ s/\bACCESS_ONCE\s*\(\s*\Q$par\E\s*\)/READ_ONCE($par)/;
6089                 }
6090             }
6091         }
6092 
6093 # check for mutex_trylock_recursive usage
6094         if ($line =~ /mutex_trylock_recursive/) {
6095             ERROR("LOCKING",
6096                   "recursive locking is bad, do not use this ever.\n" . $herecurr);
6097         }
6098 
6099 # check for lockdep_set_novalidate_class
6100         if ($line =~ /^.\s*lockdep_set_novalidate_class\s*\(/ ||
6101             $line =~ /__lockdep_no_validate__\s*\)/ ) {
6102             if ($realfile !~ m@^kernel/lockdep@ &&
6103                 $realfile !~ m@^include/linux/lockdep@ &&
6104                 $realfile !~ m@^drivers/base/core@) {
6105                 ERROR("LOCKDEP",
6106                       "lockdep_no_validate class is reserved for device->mutex.\n" . $herecurr);
6107             }
6108         }
6109 
6110         if ($line =~ /debugfs_create_\w+.*\b$mode_perms_world_writable\b/ ||
6111             $line =~ /DEVICE_ATTR.*\b$mode_perms_world_writable\b/) {
6112             WARN("EXPORTED_WORLD_WRITABLE",
6113                  "Exporting world writable files is usually an error. Consider more restrictive permissions.\n" . $herecurr);
6114         }
6115 
6116 # Mode permission misuses where it seems decimal should be octal
6117 # This uses a shortcut match to avoid unnecessary uses of a slow foreach loop
6118         if ($^V && $^V ge 5.10.0 &&
6119             defined $stat &&
6120             $line =~ /$mode_perms_search/) {
6121             foreach my $entry (@mode_permission_funcs) {
6122                 my $func = $entry->[0];
6123                 my $arg_pos = $entry->[1];
6124 
6125                 my $lc = $stat =~ tr@\n@@;
6126                 $lc = $lc + $linenr;
6127                 my $stat_real = raw_line($linenr, 0);
6128                 for (my $count = $linenr + 1; $count <= $lc; $count++) {
6129                     $stat_real = $stat_real . "\n" . raw_line($count, 0);
6130                 }
6131 
6132                 my $skip_args = "";
6133                 if ($arg_pos > 1) {
6134                     $arg_pos--;
6135                     $skip_args = "(?:\\s*$FuncArg\\s*,\\s*){$arg_pos,$arg_pos}";
6136                 }
6137                 my $test = "\\b$func\\s*\\(${skip_args}($FuncArg(?:\\|\\s*$FuncArg)*)\\s*[,\\)]";
6138                 if ($stat =~ /$test/) {
6139                     my $val = $1;
6140                     $val = $6 if ($skip_args ne "");
6141                     if (($val =~ /^$Int$/ && $val !~ /^$Octal$/) ||
6142                         ($val =~ /^$Octal$/ && length($val) ne 4)) {
6143                         ERROR("NON_OCTAL_PERMISSIONS",
6144                               "Use 4 digit octal (0777) not decimal permissions\n" . "$here\n" . $stat_real);
6145                     }
6146                     if ($val =~ /^$Octal$/ && (oct($val) & 02)) {
6147                         ERROR("EXPORTED_WORLD_WRITABLE",
6148                               "Exporting writable files is usually an error. Consider more restrictive permissions.\n" . "$here\n" . $stat_real);
6149                     }
6150                 }
6151             }
6152         }
6153 
6154 # check for uses of S_<PERMS> that could be octal for readability
6155         if ($line =~ /\b$mode_perms_string_search\b/) {
6156             my $val = "";
6157             my $oval = "";
6158             my $to = 0;
6159             my $curpos = 0;
6160             my $lastpos = 0;
6161             while ($line =~ /\b(($mode_perms_string_search)\b(?:\s*\|\s*)?\s*)/g) {
6162                 $curpos = pos($line);
6163                 my $match = $2;
6164                 my $omatch = $1;
6165                 last if ($lastpos > 0 && ($curpos - length($omatch) != $lastpos));
6166                 $lastpos = $curpos;
6167                 $to |= $mode_permission_string_types{$match};
6168                 $val .= '\s*\|\s*' if ($val ne "");
6169                 $val .= $match;
6170                 $oval .= $omatch;
6171             }
6172             $oval =~ s/^\s*\|\s*//;
6173             $oval =~ s/\s*\|\s*$//;
6174             my $octal = sprintf("%04o", $to);
6175             if (WARN("SYMBOLIC_PERMS",
6176                  "Symbolic permissions '$oval' are not preferred. Consider using octal permissions '$octal'.\n" . $herecurr) &&
6177                 $fix) {
6178                 $fixed[$fixlinenr] =~ s/$val/$octal/;
6179             }
6180         }
6181 
6182 # validate content of MODULE_LICENSE against list from include/linux/module.h
6183         if ($line =~ /\bMODULE_LICENSE\s*\(\s*($String)\s*\)/) {
6184             my $extracted_string = get_quoted_string($line, $rawline);
6185             my $valid_licenses = qr{
6186                         GPL|
6187                         GPL\ v2|
6188                         GPL\ and\ additional\ rights|
6189                         Dual\ BSD/GPL|
6190                         Dual\ MIT/GPL|
6191                         Dual\ MPL/GPL|
6192                         Proprietary
6193                     }x;
6194             if ($extracted_string !~ /^"(?:$valid_licenses)"$/x) {
6195                 WARN("MODULE_LICENSE",
6196                      "unknown module license " . $extracted_string . "\n" . $herecurr);
6197             }
6198         }
6199     }
6200 
6201     # If we have no input at all, then there is nothing to report on
6202     # so just keep quiet.
6203     if ($#rawlines == -1) {
6204         exit(0);
6205     }
6206 
6207     # In mailback mode only produce a report in the negative, for
6208     # things that appear to be patches.
6209     if ($mailback && ($clean == 1 || !$is_patch)) {
6210         exit(0);
6211     }
6212 
6213     # This is not a patch, and we are are in 'no-patch' mode so
6214     # just keep quiet.
6215     if (!$chk_patch && !$is_patch) {
6216         exit(0);
6217     }
6218 
6219     if (!$is_patch && $file !~ /cover-letter\.patch$/) {
6220         ERROR("NOT_UNIFIED_DIFF",
6221               "Does not appear to be a unified-diff format patch\n");
6222     }
6223     if ($is_patch && $has_commit_log && $chk_signoff && $signoff == 0) {
6224         ERROR("MISSING_SIGN_OFF",
6225               "Missing Signed-off-by: line(s)\n");
6226     }
6227 
6228     print report_dump();
6229     if ($summary && !($clean == 1 && $quiet == 1)) {
6230         print "$filename " if ($summary_file);
6231         print "total: $cnt_error errors, $cnt_warn warnings, " .
6232             (($check)? "$cnt_chk checks, " : "") .
6233             "$cnt_lines lines checked\n";
6234     }
6235 
6236     if ($quiet == 0) {
6237         # If there were any defects found and not already fixing them
6238         if (!$clean and !$fix) {
6239             print << "EOM"
6240 
6241 NOTE: For some of the reported defects, checkpatch may be able to
6242       mechanically convert to the typical style using --fix or --fix-inplace.
6243 EOM
6244         }
6245         # If there were whitespace errors which cleanpatch can fix
6246         # then suggest that.
6247         if ($rpt_cleaners) {
6248             $rpt_cleaners = 0;
6249             print << "EOM"
6250 
6251 NOTE: Whitespace errors detected.
6252       You may wish to use scripts/cleanpatch or scripts/cleanfile
6253 EOM
6254         }
6255     }
6256 
6257     if ($clean == 0 && $fix &&
6258         ("@rawlines" ne "@fixed" ||
6259          $#fixed_inserted >= 0 || $#fixed_deleted >= 0)) {
6260         my $newfile = $filename;
6261         $newfile .= ".EXPERIMENTAL-checkpatch-fixes" if (!$fix_inplace);
6262         my $linecount = 0;
6263         my $f;
6264 
6265         @fixed = fix_inserted_deleted_lines(\@fixed, \@fixed_inserted, \@fixed_deleted);
6266 
6267         open($f, '>', $newfile)
6268             or die "$P: Can't open $newfile for write\n";
6269         foreach my $fixed_line (@fixed) {
6270             $linecount++;
6271             if ($file) {
6272                 if ($linecount > 3) {
6273                     $fixed_line =~ s/^\+//;
6274                     print $f $fixed_line . "\n";
6275                 }
6276             } else {
6277                 print $f $fixed_line . "\n";
6278             }
6279         }
6280         close($f);
6281 
6282         if (!$quiet) {
6283             print << "EOM";
6284 
6285 Wrote EXPERIMENTAL --fix correction(s) to '$newfile'
6286 
6287 Do _NOT_ trust the results written to this file.
6288 Do _NOT_ submit these changes without inspecting them for correctness.
6289 
6290 This EXPERIMENTAL file is simply a convenience to help rewrite patches.
6291 No warranties, expressed or implied...
6292 EOM
6293         }
6294     }
6295 
6296     if ($quiet == 0) {
6297         print "\n";
6298         if ($clean == 1) {
6299             print "$vname has no obvious style problems and is ready for submission.\n";
6300         } else {
6301             print "$vname has style problems, please review.\n";
6302         }
6303     }
6304     return $clean;
6305 }