scripts/checkpatch.pl

   1 #!/usr/bin/perl -w
   2 # (c) 2001, Dave Jones. (the file handling bit)
   3 # (c) 2005, Joel Schopp <jschopp@austin.ibm.com> (the ugly bit)
   4 # (c) 2007,2008, Andy Whitcroft <apw@uk.ibm.com> (new conditions, test suite)
   5 # (c) 2008-2010 Andy Whitcroft <apw@canonical.com>
   6 # Licensed under the terms of the GNU GPL License version 2
   7
   8 use strict;
   9 use POSIX;
  10 use File::Basename;
  11 use Cwd 'abs_path';
  12
  13 my $P = $0;
  14 my $D = dirname(abs_path($P));
  15
  16 my $V = '0.32';
  17
  18 use Getopt::Long qw(:config no_auto_abbrev);
  19
  20 my $quiet = 0;
  21 my $tree = 1;
  22 my $chk_signoff = 1;
  23 my $chk_patch = 1;
  24 my $tst_only;
  25 my $emacs = 0;
  26 my $terse = 0;
  27 my $file = 0;
  28 my $check = 0;
  29 my $check_orig = 0;
  30 my $summary = 1;
  31 my $mailback = 0;
  32 my $summary_file = 0;
  33 my $show_types = 0;
  34 my $fix = 0;
  35 my $fix_inplace = 0;
  36 my $root;
  37 my %debug;
  38 my %camelcase = ();
  39 my %use_type = ();
  40 my @use = ();
  41 my %ignore_type = ();
  42 my @ignore = ();
  43 my $help = 0;
  44 my $configuration_file = ".checkpatch.conf";
  45 my $max_line_length = 80;
  46 my $ignore_perl_version = 0;
  47 my $minimum_perl_version = 5.10.0;
  48 my $min_conf_desc_length = 4;
  49 my $spelling_file = "$D/spelling.txt";
  50 my $codespell = 0;
  51 my $codespellfile = "/usr/local/share/codespell/dictionary.txt";
  52
  53 sub help {
  54         my ($exitcode) = @_;
  55
  56         print << "EOM";
  57 Usage: $P [OPTION]... [FILE]...
  58 Version: $V
  59
  60 Options:
  61   -q, --quiet                quiet
  62   --no-tree                  run without a kernel tree
  63   --no-signoff               do not check for 'Signed-off-by' line
  64   --patch                    treat FILE as patchfile (default)
  65   --emacs                    emacs compile window format
  66   --terse                    one line per report
  67   -f, --file                 treat FILE as regular source file
  68   --subjective, --strict     enable more subjective tests
  69   --types TYPE(,TYPE2...)    show only these comma separated message types
  70   --ignore TYPE(,TYPE2...)   ignore various comma separated message types
  71   --max-line-length=n        set the maximum line length, if exceeded, warn
  72   --min-conf-desc-length=n   set the min description length, if shorter, warn
  73   --show-types               show the message "types" in the output
  74   --root=PATH                PATH to the kernel tree root
  75   --no-summary               suppress the per-file summary
  76   --mailback                 only produce a report in case of warnings/errors
  77   --summary-file             include the filename in summary
  78   --debug KEY=[0|1]          turn on/off debugging of KEY, where KEY is one of
  79                              'values', 'possible', 'type', and 'attr' (default
  80                              is all off)
  81   --test-only=WORD           report only warnings/errors containing WORD
  82                              literally
  83   --fix                      EXPERIMENTAL - may create horrible results
  84                              If correctable single-line errors exist, create
  85                              "<inputfile>.EXPERIMENTAL-checkpatch-fixes"
  86                              with potential errors corrected to the preferred
  87                              checkpatch style
  88   --fix-inplace              EXPERIMENTAL - may create horrible results
  89                              Is the same as --fix, but overwrites the input
  90                              file.  It's your fault if there's no backup or git
  91   --ignore-perl-version      override checking of perl version.  expect
  92                              runtime errors.
  93   --codespell                Use the codespell dictionary for spelling/typos
  94                              (default:/usr/local/share/codespell/dictionary.txt)
  95   --codespellfile            Use this codespell dictionary
  96   -h, --help, --version      display this help and exit
  97
  98 When FILE is - read standard input.
  99 EOM
 100
 101         exit($exitcode);
 102 }
 103
 104 my $conf = which_conf($configuration_file);
 105 if (-f $conf) {
 106         my @conf_args;
 107         open(my $conffile, '<', "$conf")
 108             or warn "$P: Can't find a readable $configuration_file file $!\n";
 109
 110         while (<$conffile>) {
 111                 my $line = $_;
 112
 113                 $line =~ s/\s*\n?$//g;
 114                 $line =~ s/^\s*//g;
 115                 $line =~ s/\s+/ /g;
 116
 117                 next if ($line =~ m/^\s*#/);
 118                 next if ($line =~ m/^\s*$/);
 119
 120                 my @words = split(" ", $line);
 121                 foreach my $word (@words) {
 122                         last if ($word =~ m/^#/);
 123                         push (@conf_args, $word);
 124                 }
 125         }
 126         close($conffile);
 127         unshift(@ARGV, @conf_args) if @conf_args;
 128 }
 129
 130 GetOptions(
 131         'q|quiet+'      => \$quiet,
 132         'tree!'         => \$tree,
 133         'signoff!'      => \$chk_signoff,
 134         'patch!'        => \$chk_patch,
 135         'emacs!'        => \$emacs,
 136         'terse!'        => \$terse,
 137         'f|file!'       => \$file,
 138         'subjective!'   => \$check,
 139         'strict!'       => \$check,
 140         'ignore=s'      => \@ignore,
 141         'types=s'       => \@use,
 142         'show-types!'   => \$show_types,
 143         'max-line-length=i' => \$max_line_length,
 144         'min-conf-desc-length=i' => \$min_conf_desc_length,
 145         'root=s'        => \$root,
 146         'summary!'      => \$summary,
 147         'mailback!'     => \$mailback,
 148         'summary-file!' => \$summary_file,
 149         'fix!'          => \$fix,
 150         'fix-inplace!'  => \$fix_inplace,
 151         'ignore-perl-version!' => \$ignore_perl_version,
 152         'debug=s'       => \%debug,
 153         'test-only=s'   => \$tst_only,
 154         'codespell!'    => \$codespell,
 155         'codespellfile=s'       => \$codespellfile,
 156         'h|help'        => \$help,
 157         'version'       => \$help
 158 ) or help(1);
 159
 160 help(0) if ($help);
 161
 162 $fix = 1 if ($fix_inplace);
 163 $check_orig = $check;
 164
 165 my $exit = 0;
 166
 167 if ($^V && $^V lt $minimum_perl_version) {
 168         printf "$P: requires at least perl version %vd\n", $minimum_perl_version;
 169         if (!$ignore_perl_version) {
 170                 exit(1);
 171         }
 172 }
 173
 174 if ($#ARGV < 0) {
 175         print "$P: no input files\n";
 176         exit(1);
 177 }
 178
 179 sub hash_save_array_words {
 180         my ($hashRef, $arrayRef) = @_;
 181
 182         my @array = split(/,/, join(',', @$arrayRef));
 183         foreach my $word (@array) {
 184                 $word =~ s/\s*\n?$//g;
 185                 $word =~ s/^\s*//g;
 186                 $word =~ s/\s+/ /g;
 187                 $word =~ tr/[a-z]/[A-Z]/;
 188
 189                 next if ($word =~ m/^\s*#/);
 190                 next if ($word =~ m/^\s*$/);
 191
 192                 $hashRef->{$word}++;
 193         }
 194 }
 195
 196 sub hash_show_words {
 197         my ($hashRef, $prefix) = @_;
 198
 199         if ($quiet == 0 && keys %$hashRef) {
 200                 print "NOTE: $prefix message types:";
 201                 foreach my $word (sort keys %$hashRef) {
 202                         print " $word";
 203                 }
 204                 print "\n\n";
 205         }
 206 }
 207
 208 hash_save_array_words(\%ignore_type, \@ignore);
 209 hash_save_array_words(\%use_type, \@use);
 210
 211 my $dbg_values = 0;
 212 my $dbg_possible = 0;
 213 my $dbg_type = 0;
 214 my $dbg_attr = 0;
 215 for my $key (keys %debug) {
 216         ## no critic
 217         eval "\${dbg_$key} = '$debug{$key}';";
 218         die "$@" if ($@);
 219 }
 220
 221 my $rpt_cleaners = 0;
 222
 223 if ($terse) {
 224         $emacs = 1;
 225         $quiet++;
 226 }
 227
 228 if ($tree) {
 229         if (defined $root) {
 230                 if (!top_of_kernel_tree($root)) {
 231                         die "$P: $root: --root does not point at a valid tree\n";
 232                 }
 233         } else {
 234                 if (top_of_kernel_tree('.')) {
 235                         $root = '.';
 236                 } elsif ($0 =~ m@(.*)/scripts/[^/]*$@ &&
 237                                                 top_of_kernel_tree($1)) {
 238                         $root = $1;
 239                 }
 240         }
 241
 242         if (!defined $root) {
 243                 print "Must be run from the top-level dir. of a kernel tree\n";
 244                 exit(2);
 245         }
 246 }
 247
 248 my $emitted_corrupt = 0;
 249
 250 our $Ident      = qr{
 251                         [A-Za-z_][A-Za-z\d_]*
 252                         (?:\s*\#\#\s*[A-Za-z_][A-Za-z\d_]*)*
 253                 }x;
 254 our $Storage    = qr{extern|static|asmlinkage};
 255 our $Sparse     = qr{
 256                         __user|
 257                         __kernel|
 258                         __force|
 259                         __iomem|
 260                         __must_check|
 261                         __init_refok|
 262                         __kprobes|
 263                         __ref|
 264                         __rcu
 265                 }x;
 266 our $InitAttributePrefix = qr{__(?:mem|cpu|dev|net_|)};
 267 our $InitAttributeData = qr{$InitAttributePrefix(?:initdata\b)};
 268 our $InitAttributeConst = qr{$InitAttributePrefix(?:initconst\b)};
 269 our $InitAttributeInit = qr{$InitAttributePrefix(?:init\b)};
 270 our $InitAttribute = qr{$InitAttributeData|$InitAttributeConst|$InitAttributeInit};
 271
 272 # Notes to $Attribute:
 273 # We need \b after 'init' otherwise 'initconst' will cause a false positive in a check
 274 our $Attribute  = qr{
 275                         const|
 276                         __percpu|
 277                         __nocast|
 278                         __safe|
 279                         __bitwise__|
 280                         __packed__|
 281                         __packed2__|
 282                         __naked|
 283                         __maybe_unused|
 284                         __always_unused|
 285                         __noreturn|
 286                         __used|
 287                         __cold|
 288                         __pure|
 289                         __noclone|
 290                         __deprecated|
 291                         __read_mostly|
 292                         __kprobes|
 293                         $InitAttribute|
 294                         ____cacheline_aligned|
 295                         ____cacheline_aligned_in_smp|
 296                         ____cacheline_internodealigned_in_smp|
 297                         __weak
 298                   }x;
 299 our $Modifier;
 300 our $Inline     = qr{inline|__always_inline|noinline|__inline|__inline__};
 301 our $Member     = qr{->$Ident|\.$Ident|\[[^]]*\]};
 302 our $Lval       = qr{$Ident(?:$Member)*};
 303
 304 our $Int_type   = qr{(?i)llu|ull|ll|lu|ul|l|u};
 305 our $Binary     = qr{(?i)0b[01]+$Int_type?};
 306 our $Hex        = qr{(?i)0x[0-9a-f]+$Int_type?};
 307 our $Int        = qr{[0-9]+$Int_type?};
 308 our $Octal      = qr{0[0-7]+$Int_type?};
 309 our $String     = qr{"[X\t]*"};
 310 our $Float_hex  = qr{(?i)0x[0-9a-f]+p-?[0-9]+[fl]?};
 311 our $Float_dec  = qr{(?i)(?:[0-9]+\.[0-9]*|[0-9]*\.[0-9]+)(?:e-?[0-9]+)?[fl]?};
 312 our $Float_int  = qr{(?i)[0-9]+e-?[0-9]+[fl]?};
 313 our $Float      = qr{$Float_hex|$Float_dec|$Float_int};
 314 our $Constant   = qr{$Float|$Binary|$Octal|$Hex|$Int};
 315 our $Assignment = qr{\*\=|/=|%=|\+=|-=|<<=|>>=|&=|\^=|\|=|=};
 316 our $Compare    = qr{<=|>=|==|!=|<|(?<!-)>};
 317 our $Arithmetic = qr{\+|-|\*|\/|%};
 318 our $Operators  = qr{
 319                         <=|>=|==|!=|
 320                         =>|->|<<|>>|<|>|!|~|
 321                         &&|\|\||,|\^|\+\+|--|&|\||$Arithmetic
 322                   }x;
 323
 324 our $c90_Keywords = qr{do|for|while|if|else|return|goto|continue|switch|default|case|break}x;
 325
 326 our $BasicType;
 327 our $NonptrType;
 328 our $NonptrTypeMisordered;
 329 our $NonptrTypeWithAttr;
 330 our $Type;
 331 our $TypeMisordered;
 332 our $Declare;
 333 our $DeclareMisordered;
 334
 335 our $NON_ASCII_UTF8     = qr{
 336         [\xC2-\xDF][\x80-\xBF]               # non-overlong 2-byte
 337         |  \xE0[\xA0-\xBF][\x80-\xBF]        # excluding overlongs
 338         | [\xE1-\xEC\xEE\xEF][\x80-\xBF]{2}  # straight 3-byte
 339         |  \xED[\x80-\x9F][\x80-\xBF]        # excluding surrogates
 340         |  \xF0[\x90-\xBF][\x80-\xBF]{2}     # planes 1-3
 341         | [\xF1-\xF3][\x80-\xBF]{3}          # planes 4-15
 342         |  \xF4[\x80-\x8F][\x80-\xBF]{2}     # plane 16
 343 }x;
 344
 345 our $UTF8       = qr{
 346         [\x09\x0A\x0D\x20-\x7E]              # ASCII
 347         | $NON_ASCII_UTF8
 348 }x;
 349
 350 our $typeOtherOSTypedefs = qr{(?x:
 351         u_(?:char|short|int|long) |          # bsd
 352         u(?:nchar|short|int|long)            # sysv
 353 )};
 354
 355 our $typeTypedefs = qr{(?x:
 356         (?:__)?(?:u|s|be|le)(?:8|16|32|64)|
 357         atomic_t
 358 )};
 359
 360 our $logFunctions = qr{(?x:
 361         printk(?:_ratelimited|_once|)|
 362         (?:[a-z0-9]+_){1,2}(?:printk|emerg|alert|crit|err|warning|warn|notice|info|debug|dbg|vdbg|devel|cont|WARN)(?:_ratelimited|_once|)|
 363         WARN(?:_RATELIMIT|_ONCE|)|
 364         panic|
 365         MODULE_[A-Z_]+|
 366         seq_vprintf|seq_printf|seq_puts
 367 )};
 368
 369 our $signature_tags = qr{(?xi:
 370         Signed-off-by:|
 371         Acked-by:|
 372         Tested-by:|
 373         Reviewed-by:|
 374         Reported-by:|
 375         Suggested-by:|
 376         To:|
 377         Cc:
 378 )};
 379
 380 our @typeListMisordered = (
 381         qr{char\s+(?:un)?signed},
 382         qr{int\s+(?:(?:un)?signed\s+)?short\s},
 383         qr{int\s+short(?:\s+(?:un)?signed)},
 384         qr{short\s+int(?:\s+(?:un)?signed)},
 385         qr{(?:un)?signed\s+int\s+short},
 386         qr{short\s+(?:un)?signed},
 387         qr{long\s+int\s+(?:un)?signed},
 388         qr{int\s+long\s+(?:un)?signed},
 389         qr{long\s+(?:un)?signed\s+int},
 390         qr{int\s+(?:un)?signed\s+long},
 391         qr{int\s+(?:un)?signed},
 392         qr{int\s+long\s+long\s+(?:un)?signed},
 393         qr{long\s+long\s+int\s+(?:un)?signed},
 394         qr{long\s+long\s+(?:un)?signed\s+int},
 395         qr{long\s+long\s+(?:un)?signed},
 396         qr{long\s+(?:un)?signed},
 397 );
 398
 399 our @typeList = (
 400         qr{void},
 401         qr{(?:(?:un)?signed\s+)?char},
 402         qr{(?:(?:un)?signed\s+)?short\s+int},
 403         qr{(?:(?:un)?signed\s+)?short},
 404         qr{(?:(?:un)?signed\s+)?int},
 405         qr{(?:(?:un)?signed\s+)?long\s+int},
 406         qr{(?:(?:un)?signed\s+)?long\s+long\s+int},
 407         qr{(?:(?:un)?signed\s+)?long\s+long},
 408         qr{(?:(?:un)?signed\s+)?long},
 409         qr{(?:un)?signed},
 410         qr{float},
 411         qr{double},
 412         qr{bool},
 413         qr{struct\s+$Ident},
 414         qr{union\s+$Ident},
 415         qr{enum\s+$Ident},
 416         qr{${Ident}_t},
 417         qr{${Ident}_handler},
 418         qr{${Ident}_handler_fn},
 419         @typeListMisordered,
 420 );
 421 our @typeListWithAttr = (
 422         @typeList,
 423         qr{struct\s+$InitAttribute\s+$Ident},
 424         qr{union\s+$InitAttribute\s+$Ident},
 425 );
 426
 427 our @modifierList = (
 428         qr{fastcall},
 429 );
 430
 431 our @mode_permission_funcs = (
 432         ["module_param", 3],
 433         ["module_param_(?:array|named|string)", 4],
 434         ["module_param_array_named", 5],
 435         ["debugfs_create_(?:file|u8|u16|u32|u64|x8|x16|x32|x64|size_t|atomic_t|bool|blob|regset32|u32_array)", 2],
 436         ["proc_create(?:_data|)", 2],
 437         ["(?:CLASS|DEVICE|SENSOR)_ATTR", 2],
 438 );
 439
 440 #Create a search pattern for all these functions to speed up a loop below
 441 our $mode_perms_search = "";
 442 foreach my $entry (@mode_permission_funcs) {
 443         $mode_perms_search .= '|' if ($mode_perms_search ne "");
 444         $mode_perms_search .= $entry->[0];
 445 }
 446
 447 our $mode_perms_world_writable = qr{
 448         S_IWUGO         |
 449         S_IWOTH         |
 450         S_IRWXUGO       |
 451         S_IALLUGO       |
 452         0[0-7][0-7][2367]
 453 }x;
 454
 455 our $allowed_asm_includes = qr{(?x:
 456         irq|
 457         memory|
 458         time|
 459         reboot
 460 )};
 461 # memory.h: ARM has a custom one
 462
 463 # Load common spelling mistakes and build regular expression list.
 464 my $misspellings;
 465 my %spelling_fix;
 466
 467 if (open(my $spelling, '<', $spelling_file)) {
 468         while (<$spelling>) {
 469                 my $line = $_;
 470
 471                 $line =~ s/\s*\n?$//g;
 472                 $line =~ s/^\s*//g;
 473
 474                 next if ($line =~ m/^\s*#/);
 475                 next if ($line =~ m/^\s*$/);
 476
 477                 my ($suspect, $fix) = split(/\|\|/, $line);
 478
 479                 $spelling_fix{$suspect} = $fix;
 480         }
 481         close($spelling);
 482 } else {
 483         warn "No typos will be found - file '$spelling_file': $!\n";
 484 }
 485
 486 if ($codespell) {
 487         if (open(my $spelling, '<', $codespellfile)) {
 488                 while (<$spelling>) {
 489                         my $line = $_;
 490
 491                         $line =~ s/\s*\n?$//g;
 492                         $line =~ s/^\s*//g;
 493
 494                         next if ($line =~ m/^\s*#/);
 495                         next if ($line =~ m/^\s*$/);
 496                         next if ($line =~ m/, disabled/i);
 497
 498                         $line =~ s/,.*$//;
 499
 500                         my ($suspect, $fix) = split(/->/, $line);
 501
 502                         $spelling_fix{$suspect} = $fix;
 503                 }
 504                 close($spelling);
 505         } else {
 506                 warn "No codespell typos will be found - file '$codespellfile': $!\n";
 507         }
 508 }
 509
 510 $misspellings = join("|", sort keys %spelling_fix) if keys %spelling_fix;
 511
 512 sub build_types {
 513         my $mods = "(?x:  \n" . join("|\n  ", @modifierList) . "\n)";
 514         my $all = "(?x:  \n" . join("|\n  ", @typeList) . "\n)";
 515         my $Misordered = "(?x:  \n" . join("|\n  ", @typeListMisordered) . "\n)";
 516         my $allWithAttr = "(?x:  \n" . join("|\n  ", @typeListWithAttr) . "\n)";
 517         $Modifier       = qr{(?:$Attribute|$Sparse|$mods)};
 518         $BasicType      = qr{
 519                                 (?:$typeOtherOSTypedefs\b)|
 520                                 (?:$typeTypedefs\b)|
 521                                 (?:${all}\b)
 522                 }x;
 523         $NonptrType     = qr{
 524                         (?:$Modifier\s+|const\s+)*
 525                         (?:
 526                                 (?:typeof|__typeof__)\s*\([^\)]*\)|
 527                                 (?:$typeOtherOSTypedefs\b)|
 528                                 (?:$typeTypedefs\b)|
 529                                 (?:${all}\b)
 530                         )
 531                         (?:\s+$Modifier|\s+const)*
 532                   }x;
 533         $NonptrTypeMisordered   = qr{
 534                         (?:$Modifier\s+|const\s+)*
 535                         (?:
 536                                 (?:${Misordered}\b)
 537                         )
 538                         (?:\s+$Modifier|\s+const)*
 539                   }x;
 540         $NonptrTypeWithAttr     = qr{
 541                         (?:$Modifier\s+|const\s+)*
 542                         (?:
 543                                 (?:typeof|__typeof__)\s*\([^\)]*\)|
 544                                 (?:$typeTypedefs\b)|
 545                                 (?:$typeOtherOSTypedefs\b)|
 546                                 (?:${allWithAttr}\b)
 547                         )
 548                         (?:\s+$Modifier|\s+const)*
 549                   }x;
 550         $Type   = qr{
 551                         $NonptrType
 552                         (?:(?:\s|\*|\[\])+\s*const|(?:\s|\*\s*(?:const\s*)?|\[\])+|(?:\s*\[\s*\])+)?
 553                         (?:\s+$Inline|\s+$Modifier)*
 554                   }x;
 555         $TypeMisordered = qr{
 556                         $NonptrTypeMisordered
 557                         (?:(?:\s|\*|\[\])+\s*const|(?:\s|\*\s*(?:const\s*)?|\[\])+|(?:\s*\[\s*\])+)?
 558                         (?:\s+$Inline|\s+$Modifier)*
 559                   }x;
 560         $Declare        = qr{(?:$Storage\s+(?:$Inline\s+)?)?$Type};
 561         $DeclareMisordered      = qr{(?:$Storage\s+(?:$Inline\s+)?)?$TypeMisordered};
 562 }
 563 build_types();
 564
 565 our $Typecast   = qr{\s*(\(\s*$NonptrType\s*\)){0,1}\s*};
 566
 567 # Using $balanced_parens, $LvalOrFunc, or $FuncArg
 568 # requires at least perl version v5.10.0
 569 # Any use must be runtime checked with $^V
 570
 571 our $balanced_parens = qr/(\((?:[^\(\)]++|(?-1))*\))/;
 572 our $LvalOrFunc = qr{((?:[\&\*]\s*)?$Lval)\s*($balanced_parens{0,1})\s*};
 573 our $FuncArg = qr{$Typecast{0,1}($LvalOrFunc|$Constant|$String)};
 574
 575 our $declaration_macros = qr{(?x:
 576         (?:$Storage\s+)?(?:[A-Z_][A-Z0-9]*_){0,2}(?:DEFINE|DECLARE)(?:_[A-Z0-9]+){1,2}\s*\(|
 577         (?:$Storage\s+)?LIST_HEAD\s*\(|
 578         (?:$Storage\s+)?${Type}\s+uninitialized_var\s*\(
 579 )};
 580
 581 sub deparenthesize {
 582         my ($string) = @_;
 583         return "" if (!defined($string));
 584
 585         while ($string =~ /^\s*\(.*\)\s*$/) {
 586                 $string =~ s@^\s*\(\s*@@;
 587                 $string =~ s@\s*\)\s*$@@;
 588         }
 589
 590         $string =~ s@\s+@ @g;
 591
 592         return $string;
 593 }
 594
 595 sub seed_camelcase_file {
 596         my ($file) = @_;
 597
 598         return if (!(-f $file));
 599
 600         local $/;
 601
 602         open(my $include_file, '<', "$file")
 603             or warn "$P: Can't read '$file' $!\n";
 604         my $text = <$include_file>;
 605         close($include_file);
 606
 607         my @lines = split('\n', $text);
 608
 609         foreach my $line (@lines) {
 610                 next if ($line !~ /(?:[A-Z][a-z]|[a-z][A-Z])/);
 611                 if ($line =~ /^[ \t]*(?:#[ \t]*define|typedef\s+$Type)\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)/) {
 612                         $camelcase{$1} = 1;
 613                 } elsif ($line =~ /^\s*$Declare\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)\s*[\(\[,;]/) {
 614                         $camelcase{$1} = 1;
 615                 } elsif ($line =~ /^\s*(?:union|struct|enum)\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)\s*[;\{]/) {
 616                         $camelcase{$1} = 1;
 617                 }
 618         }
 619 }
 620
 621 my $camelcase_seeded = 0;
 622 sub seed_camelcase_includes {
 623         return if ($camelcase_seeded);
 624
 625         my $files;
 626         my $camelcase_cache = "";
 627         my @include_files = ();
 628
 629         $camelcase_seeded = 1;
 630
 631         if (-e ".git") {
 632                 my $git_last_include_commit = `git log --no-merges --pretty=format:"%h%n" -1 -- include`;
 633                 chomp $git_last_include_commit;
 634                 $camelcase_cache = ".checkpatch-camelcase.git.$git_last_include_commit";
 635         } else {
 636                 my $last_mod_date = 0;
 637                 $files = `find $root/include -name "*.h"`;
 638                 @include_files = split('\n', $files);
 639                 foreach my $file (@include_files) {
 640                         my $date = POSIX::strftime("%Y%m%d%H%M",
 641                                                    localtime((stat $file)[9]));
 642                         $last_mod_date = $date if ($last_mod_date < $date);
 643                 }
 644                 $camelcase_cache = ".checkpatch-camelcase.date.$last_mod_date";
 645         }
 646
 647         if ($camelcase_cache ne "" && -f $camelcase_cache) {
 648                 open(my $camelcase_file, '<', "$camelcase_cache")
 649                     or warn "$P: Can't read '$camelcase_cache' $!\n";
 650                 while (<$camelcase_file>) {
 651                         chomp;
 652                         $camelcase{$_} = 1;
 653                 }
 654                 close($camelcase_file);
 655
 656                 return;
 657         }
 658
 659         if (-e ".git") {
 660                 $files = `git ls-files "include/*.h"`;
 661                 @include_files = split('\n', $files);
 662         }
 663
 664         foreach my $file (@include_files) {
 665                 seed_camelcase_file($file);
 666         }
 667
 668         if ($camelcase_cache ne "") {
 669                 unlink glob ".checkpatch-camelcase.*";
 670                 open(my $camelcase_file, '>', "$camelcase_cache")
 671                     or warn "$P: Can't write '$camelcase_cache' $!\n";
 672                 foreach (sort { lc($a) cmp lc($b) } keys(%camelcase)) {
 673                         print $camelcase_file ("$_\n");
 674                 }
 675                 close($camelcase_file);
 676         }
 677 }
 678
 679 sub git_commit_info {
 680         my ($commit, $id, $desc) = @_;
 681
 682         return ($id, $desc) if ((which("git") eq "") || !(-e ".git"));
 683
 684         my $output = `git log --no-color --format='%H %s' -1 $commit 2>&1`;
 685         $output =~ s/^\s*//gm;
 686         my @lines = split("\n", $output);
 687
 688         return ($id, $desc) if ($#lines < 0);
 689
 690         if ($lines[0] =~ /^error: short SHA1 $commit is ambiguous\./) {
 691 # Maybe one day convert this block of bash into something that returns
 692 # all matching commit ids, but it's very slow...
 693 #
 694 #               echo "checking commits $1..."
 695 #               git rev-list --remotes | grep -i "^$1" |
 696 #               while read line ; do
 697 #                   git log --format='%H %s' -1 $line |
 698 #                   echo "commit $(cut -c 1-12,41-)"
 699 #               done
 700         } elsif ($lines[0] =~ /^fatal: ambiguous argument '$commit': unknown revision or path not in the working tree\./) {
 701         } else {
 702                 $id = substr($lines[0], 0, 12);
 703                 $desc = substr($lines[0], 41);
 704         }
 705
 706         return ($id, $desc);
 707 }
 708
 709 $chk_signoff = 0 if ($file);
 710
 711 my @rawlines = ();
 712 my @lines = ();
 713 my @fixed = ();
 714 my @fixed_inserted = ();
 715 my @fixed_deleted = ();
 716 my $fixlinenr = -1;
 717
 718 my $vname;
 719 for my $filename (@ARGV) {
 720         my $FILE;
 721         if ($file) {
 722                 open($FILE, '-|', "diff -u /dev/null $filename") ||
 723                         die "$P: $filename: diff failed - $!\n";
 724         } elsif ($filename eq '-') {
 725                 open($FILE, '<&STDIN');
 726         } else {
 727                 open($FILE, '<', "$filename") ||
 728                         die "$P: $filename: open failed - $!\n";
 729         }
 730         if ($filename eq '-') {
 731                 $vname = 'Your patch';
 732         } else {
 733                 $vname = $filename;
 734         }
 735         while (<$FILE>) {
 736                 chomp;
 737                 push(@rawlines, $_);
 738         }
 739         close($FILE);
 740         if (!process($filename)) {
 741                 $exit = 1;
 742         }
 743         @rawlines = ();
 744         @lines = ();
 745         @fixed = ();
 746         @fixed_inserted = ();
 747         @fixed_deleted = ();
 748         $fixlinenr = -1;
 749 }
 750
 751 exit($exit);
 752
 753 sub top_of_kernel_tree {
 754         my ($root) = @_;
 755
 756         my @tree_check = (
 757                 "COPYING", "CREDITS", "Kbuild", "MAINTAINERS", "Makefile",
 758                 "README", "Documentation", "arch", "include", "drivers",
 759                 "fs", "init", "ipc", "kernel", "lib", "scripts",
 760         );
 761
 762         foreach my $check (@tree_check) {
 763                 if (! -e $root . '/' . $check) {
 764                         return 0;
 765                 }
 766         }
 767         return 1;
 768 }
 769
 770 sub parse_email {
 771         my ($formatted_email) = @_;
 772
 773         my $name = "";
 774         my $address = "";
 775         my $comment = "";
 776
 777         if ($formatted_email =~ /^(.*)<(\S+\@\S+)>(.*)$/) {
 778                 $name = $1;
 779                 $address = $2;
 780                 $comment = $3 if defined $3;
 781         } elsif ($formatted_email =~ /^\s*<(\S+\@\S+)>(.*)$/) {
 782                 $address = $1;
 783                 $comment = $2 if defined $2;
 784         } elsif ($formatted_email =~ /(\S+\@\S+)(.*)$/) {
 785                 $address = $1;
 786                 $comment = $2 if defined $2;
 787                 $formatted_email =~ s/$address.*$//;
 788                 $name = $formatted_email;
 789                 $name = trim($name);
 790                 $name =~ s/^\"|\"$//g;
 791                 # If there's a name left after stripping spaces and
 792                 # leading quotes, and the address doesn't have both
 793                 # leading and trailing angle brackets, the address
 794                 # is invalid. ie:
 795                 #   "joe smith joe@smith.com" bad
 796                 #   "joe smith <joe@smith.com" bad
 797                 if ($name ne "" && $address !~ /^<[^>]+>$/) {
 798                         $name = "";
 799                         $address = "";
 800                         $comment = "";
 801                 }
 802         }
 803
 804         $name = trim($name);
 805         $name =~ s/^\"|\"$//g;
 806         $address = trim($address);
 807         $address =~ s/^\<|\>$//g;
 808
 809         if ($name =~ /[^\w \-]/i) { ##has "must quote" chars
 810                 $name =~ s/(?<!\\)"/\\"/g; ##escape quotes
 811                 $name = "\"$name\"";
 812         }
 813
 814         return ($name, $address, $comment);
 815 }
 816
 817 sub format_email {
 818         my ($name, $address) = @_;
 819
 820         my $formatted_email;
 821
 822         $name = trim($name);
 823         $name =~ s/^\"|\"$//g;
 824         $address = trim($address);
 825
 826         if ($name =~ /[^\w \-]/i) { ##has "must quote" chars
 827                 $name =~ s/(?<!\\)"/\\"/g; ##escape quotes
 828                 $name = "\"$name\"";
 829         }
 830
 831         if ("$name" eq "") {
 832                 $formatted_email = "$address";
 833         } else {
 834                 $formatted_email = "$name <$address>";
 835         }
 836
 837         return $formatted_email;
 838 }
 839
 840 sub which {
 841         my ($bin) = @_;
 842
 843         foreach my $path (split(/:/, $ENV{PATH})) {
 844                 if (-e "$path/$bin") {
 845                         return "$path/$bin";
 846                 }
 847         }
 848
 849         return "";
 850 }
 851
 852 sub which_conf {
 853         my ($conf) = @_;
 854
 855         foreach my $path (split(/:/, ".:$ENV{HOME}:.scripts")) {
 856                 if (-e "$path/$conf") {
 857                         return "$path/$conf";
 858                 }
 859         }
 860
 861         return "";
 862 }
 863
 864 sub expand_tabs {
 865         my ($str) = @_;
 866
 867         my $res = '';
 868         my $n = 0;
 869         for my $c (split(//, $str)) {
 870                 if ($c eq "\t") {
 871                         $res .= ' ';
 872                         $n++;
 873                         for (; ($n % 8) != 0; $n++) {
 874                                 $res .= ' ';
 875                         }
 876                         next;
 877                 }
 878                 $res .= $c;
 879                 $n++;
 880         }
 881
 882         return $res;
 883 }
 884 sub copy_spacing {
 885         (my $res = shift) =~ tr/\t/ /c;
 886         return $res;
 887 }
 888
 889 sub line_stats {
 890         my ($line) = @_;
 891
 892         # Drop the diff line leader and expand tabs
 893         $line =~ s/^.//;
 894         $line = expand_tabs($line);
 895
 896         # Pick the indent from the front of the line.
 897         my ($white) = ($line =~ /^(\s*)/);
 898
 899         return (length($line), length($white));
 900 }
 901
 902 my $sanitise_quote = '';
 903
 904 sub sanitise_line_reset {
 905         my ($in_comment) = @_;
 906
 907         if ($in_comment) {
 908                 $sanitise_quote = '*/';
 909         } else {
 910                 $sanitise_quote = '';
 911         }
 912 }
 913 sub sanitise_line {
 914         my ($line) = @_;
 915
 916         my $res = '';
 917         my $l = '';
 918
 919         my $qlen = 0;
 920         my $off = 0;
 921         my $c;
 922
 923         # Always copy over the diff marker.
 924         $res = substr($line, 0, 1);
 925
 926         for ($off = 1; $off < length($line); $off++) {
 927                 $c = substr($line, $off, 1);
 928
 929                 # Comments we are wacking completly including the begin
 930                 # and end, all to $;.
 931                 if ($sanitise_quote eq '' && substr($line, $off, 2) eq '/*') {
 932                         $sanitise_quote = '*/';
 933
 934                         substr($res, $off, 2, "$;$;");
 935                         $off++;
 936                         next;
 937                 }
 938                 if ($sanitise_quote eq '*/' && substr($line, $off, 2) eq '*/') {
 939                         $sanitise_quote = '';
 940                         substr($res, $off, 2, "$;$;");
 941                         $off++;
 942                         next;
 943                 }
 944                 if ($sanitise_quote eq '' && substr($line, $off, 2) eq '//') {
 945                         $sanitise_quote = '//';
 946
 947                         substr($res, $off, 2, $sanitise_quote);
 948                         $off++;
 949                         next;
 950                 }
 951
 952                 # A \ in a string means ignore the next character.
 953                 if (($sanitise_quote eq "'" || $sanitise_quote eq '"') &&
 954                     $c eq "\\") {
 955                         substr($res, $off, 2, 'XX');
 956                         $off++;
 957                         next;
 958                 }
 959                 # Regular quotes.
 960                 if ($c eq "'" || $c eq '"') {
 961                         if ($sanitise_quote eq '') {
 962                                 $sanitise_quote = $c;
 963
 964                                 substr($res, $off, 1, $c);
 965                                 next;
 966                         } elsif ($sanitise_quote eq $c) {
 967                                 $sanitise_quote = '';
 968                         }
 969                 }
 970
 971                 #print "c<$c> SQ<$sanitise_quote>\n";
 972                 if ($off != 0 && $sanitise_quote eq '*/' && $c ne "\t") {
 973                         substr($res, $off, 1, $;);
 974                 } elsif ($off != 0 && $sanitise_quote eq '//' && $c ne "\t") {
 975                         substr($res, $off, 1, $;);
 976                 } elsif ($off != 0 && $sanitise_quote && $c ne "\t") {
 977                         substr($res, $off, 1, 'X');
 978                 } else {
 979                         substr($res, $off, 1, $c);
 980                 }
 981         }
 982
 983         if ($sanitise_quote eq '//') {
 984                 $sanitise_quote = '';
 985         }
 986
 987         # The pathname on a #include may be surrounded by '<' and '>'.
 988         if ($res =~ /^.\s*\#\s*include\s+\<(.*)\>/) {
 989                 my $clean = 'X' x length($1);
 990                 $res =~ s@\<.*\>@<$clean>@;
 991
 992         # The whole of a #error is a string.
 993         } elsif ($res =~ /^.\s*\#\s*(?:error|warning)\s+(.*)\b/) {
 994                 my $clean = 'X' x length($1);
 995                 $res =~ s@(\#\s*(?:error|warning)\s+).*@$1$clean@;
 996         }
 997
 998         return $res;
 999 }
1000
1001 sub get_quoted_string {
1002         my ($line, $rawline) = @_;
1003
1004         return "" if ($line !~ m/(\"[X\t]+\")/g);
1005         return substr($rawline, $-[0], $+[0] - $-[0]);
1006 }
1007
1008 sub ctx_statement_block {
1009         my ($linenr, $remain, $off) = @_;
1010         my $line = $linenr - 1;
1011         my $blk = '';
1012         my $soff = $off;
1013         my $coff = $off - 1;
1014         my $coff_set = 0;
1015
1016         my $loff = 0;
1017
1018         my $type = '';
1019         my $level = 0;
1020         my @stack = ();
1021         my $p;
1022         my $c;
1023         my $len = 0;
1024
1025         my $remainder;
1026         while (1) {
1027                 @stack = (['', 0]) if ($#stack == -1);
1028
1029                 #warn "CSB: blk<$blk> remain<$remain>\n";
1030                 # If we are about to drop off the end, pull in more
1031                 # context.
1032                 if ($off >= $len) {
1033                         for (; $remain > 0; $line++) {
1034                                 last if (!defined $lines[$line]);
1035                                 next if ($lines[$line] =~ /^-/);
1036                                 $remain--;
1037                                 $loff = $len;
1038                                 $blk .= $lines[$line] . "\n";
1039                                 $len = length($blk);
1040                                 $line++;
1041                                 last;
1042                         }
1043                         # Bail if there is no further context.
1044                         #warn "CSB: blk<$blk> off<$off> len<$len>\n";
1045                         if ($off >= $len) {
1046                                 last;
1047                         }
1048                         if ($level == 0 && substr($blk, $off) =~ /^.\s*#\s*define/) {
1049                                 $level++;
1050                                 $type = '#';
1051                         }
1052                 }
1053                 $p = $c;
1054                 $c = substr($blk, $off, 1);
1055                 $remainder = substr($blk, $off);
1056
1057                 #warn "CSB: c<$c> type<$type> level<$level> remainder<$remainder> coff_set<$coff_set>\n";
1058
1059                 # Handle nested #if/#else.
1060                 if ($remainder =~ /^#\s*(?:ifndef|ifdef|if)\s/) {
1061                         push(@stack, [ $type, $level ]);
1062                 } elsif ($remainder =~ /^#\s*(?:else|elif)\b/) {
1063                         ($type, $level) = @{$stack[$#stack - 1]};
1064                 } elsif ($remainder =~ /^#\s*endif\b/) {
1065                         ($type, $level) = @{pop(@stack)};
1066                 }
1067
1068                 # Statement ends at the ';' or a close '}' at the
1069                 # outermost level.
1070                 if ($level == 0 && $c eq ';') {
1071                         last;
1072                 }
1073
1074                 # An else is really a conditional as long as its not else if
1075                 if ($level == 0 && $coff_set == 0 &&
1076                                 (!defined($p) || $p =~ /(?:\s|\}|\+)/) &&
1077                                 $remainder =~ /^(else)(?:\s|{)/ &&
1078                                 $remainder !~ /^else\s+if\b/) {
1079                         $coff = $off + length($1) - 1;
1080                         $coff_set = 1;
1081                         #warn "CSB: mark coff<$coff> soff<$soff> 1<$1>\n";
1082                         #warn "[" . substr($blk, $soff, $coff - $soff + 1) . "]\n";
1083                 }
1084
1085                 if (($type eq '' || $type eq '(') && $c eq '(') {
1086                         $level++;
1087                         $type = '(';
1088                 }
1089                 if ($type eq '(' && $c eq ')') {
1090                         $level--;
1091                         $type = ($level != 0)? '(' : '';
1092
1093                         if ($level == 0 && $coff < $soff) {
1094                                 $coff = $off;
1095                                 $coff_set = 1;
1096                                 #warn "CSB: mark coff<$coff>\n";
1097                         }
1098                 }
1099                 if (($type eq '' || $type eq '{') && $c eq '{') {
1100                         $level++;
1101                         $type = '{';
1102                 }
1103                 if ($type eq '{' && $c eq '}') {
1104                         $level--;
1105                         $type = ($level != 0)? '{' : '';
1106
1107                         if ($level == 0) {
1108                                 if (substr($blk, $off + 1, 1) eq ';') {
1109                                         $off++;
1110                                 }
1111                                 last;
1112                         }
1113                 }
1114                 # Preprocessor commands end at the newline unless escaped.
1115                 if ($type eq '#' && $c eq "\n" && $p ne "\\") {
1116                         $level--;
1117                         $type = '';
1118                         $off++;
1119                         last;
1120                 }
1121                 $off++;
1122         }
1123         # We are truly at the end, so shuffle to the next line.
1124         if ($off == $len) {
1125                 $loff = $len + 1;
1126                 $line++;
1127                 $remain--;
1128         }
1129
1130         my $statement = substr($blk, $soff, $off - $soff + 1);
1131         my $condition = substr($blk, $soff, $coff - $soff + 1);
1132
1133         #warn "STATEMENT<$statement>\n";
1134         #warn "CONDITION<$condition>\n";
1135
1136         #print "coff<$coff> soff<$off> loff<$loff>\n";
1137
1138         return ($statement, $condition,
1139                         $line, $remain + 1, $off - $loff + 1, $level);
1140 }
1141
1142 sub statement_lines {
1143         my ($stmt) = @_;
1144
1145         # Strip the diff line prefixes and rip blank lines at start and end.
1146         $stmt =~ s/(^|\n)./$1/g;
1147         $stmt =~ s/^\s*//;
1148         $stmt =~ s/\s*$//;
1149
1150         my @stmt_lines = ($stmt =~ /\n/g);
1151
1152         return $#stmt_lines + 2;
1153 }
1154
1155 sub statement_rawlines {
1156         my ($stmt) = @_;
1157
1158         my @stmt_lines = ($stmt =~ /\n/g);
1159
1160         return $#stmt_lines + 2;
1161 }
1162
1163 sub statement_block_size {
1164         my ($stmt) = @_;
1165
1166         $stmt =~ s/(^|\n)./$1/g;
1167         $stmt =~ s/^\s*{//;
1168         $stmt =~ s/}\s*$//;
1169         $stmt =~ s/^\s*//;
1170         $stmt =~ s/\s*$//;
1171
1172         my @stmt_lines = ($stmt =~ /\n/g);
1173         my @stmt_statements = ($stmt =~ /;/g);
1174
1175         my $stmt_lines = $#stmt_lines + 2;
1176         my $stmt_statements = $#stmt_statements + 1;
1177
1178         if ($stmt_lines > $stmt_statements) {
1179                 return $stmt_lines;
1180         } else {
1181                 return $stmt_statements;
1182         }
1183 }
1184
1185 sub ctx_statement_full {
1186         my ($linenr, $remain, $off) = @_;
1187         my ($statement, $condition, $level);
1188
1189         my (@chunks);
1190
1191         # Grab the first conditional/block pair.
1192         ($statement, $condition, $linenr, $remain, $off, $level) =
1193                                 ctx_statement_block($linenr, $remain, $off);
1194         #print "F: c<$condition> s<$statement> remain<$remain>\n";
1195         push(@chunks, [ $condition, $statement ]);
1196         if (!($remain > 0 && $condition =~ /^\s*(?:\n[+-])?\s*(?:if|else|do)\b/s)) {
1197                 return ($level, $linenr, @chunks);
1198         }
1199
1200         # Pull in the following conditional/block pairs and see if they
1201         # could continue the statement.
1202         for (;;) {
1203                 ($statement, $condition, $linenr, $remain, $off, $level) =
1204                                 ctx_statement_block($linenr, $remain, $off);
1205                 #print "C: c<$condition> s<$statement> remain<$remain>\n";
1206                 last if (!($remain > 0 && $condition =~ /^(?:\s*\n[+-])*\s*(?:else|do)\b/s));
1207                 #print "C: push\n";
1208                 push(@chunks, [ $condition, $statement ]);
1209         }
1210
1211         return ($level, $linenr, @chunks);
1212 }
1213
1214 sub ctx_block_get {
1215         my ($linenr, $remain, $outer, $open, $close, $off) = @_;
1216         my $line;
1217         my $start = $linenr - 1;
1218         my $blk = '';
1219         my @o;
1220         my @c;
1221         my @res = ();
1222
1223         my $level = 0;
1224         my @stack = ($level);
1225         for ($line = $start; $remain > 0; $line++) {
1226                 next if ($rawlines[$line] =~ /^-/);
1227                 $remain--;
1228
1229                 $blk .= $rawlines[$line];
1230
1231                 # Handle nested #if/#else.
1232                 if ($lines[$line] =~ /^.\s*#\s*(?:ifndef|ifdef|if)\s/) {
1233                         push(@stack, $level);
1234                 } elsif ($lines[$line] =~ /^.\s*#\s*(?:else|elif)\b/) {
1235                         $level = $stack[$#stack - 1];
1236                 } elsif ($lines[$line] =~ /^.\s*#\s*endif\b/) {
1237                         $level = pop(@stack);
1238                 }
1239
1240                 foreach my $c (split(//, $lines[$line])) {
1241                         ##print "C<$c>L<$level><$open$close>O<$off>\n";
1242                         if ($off > 0) {
1243                                 $off--;
1244                                 next;
1245                         }
1246
1247                         if ($c eq $close && $level > 0) {
1248                                 $level--;
1249                                 last if ($level == 0);
1250                         } elsif ($c eq $open) {
1251                                 $level++;
1252                         }
1253                 }
1254
1255                 if (!$outer || $level <= 1) {
1256                         push(@res, $rawlines[$line]);
1257                 }
1258
1259                 last if ($level == 0);
1260         }
1261
1262         return ($level, @res);
1263 }
1264 sub ctx_block_outer {
1265         my ($linenr, $remain) = @_;
1266
1267         my ($level, @r) = ctx_block_get($linenr, $remain, 1, '{', '}', 0);
1268         return @r;
1269 }
1270 sub ctx_block {
1271         my ($linenr, $remain) = @_;
1272
1273         my ($level, @r) = ctx_block_get($linenr, $remain, 0, '{', '}', 0);
1274         return @r;
1275 }
1276 sub ctx_statement {
1277         my ($linenr, $remain, $off) = @_;
1278
1279         my ($level, @r) = ctx_block_get($linenr, $remain, 0, '(', ')', $off);
1280         return @r;
1281 }
1282 sub ctx_block_level {
1283         my ($linenr, $remain) = @_;
1284
1285         return ctx_block_get($linenr, $remain, 0, '{', '}', 0);
1286 }
1287 sub ctx_statement_level {
1288         my ($linenr, $remain, $off) = @_;
1289
1290         return ctx_block_get($linenr, $remain, 0, '(', ')', $off);
1291 }
1292
1293 sub ctx_locate_comment {
1294         my ($first_line, $end_line) = @_;
1295
1296         # Catch a comment on the end of the line itself.
1297         my ($current_comment) = ($rawlines[$end_line - 1] =~ m@.*(/\*.*\*/)\s*(?:\\\s*)?$@);
1298         return $current_comment if (defined $current_comment);
1299
1300         # Look through the context and try and figure out if there is a
1301         # comment.
1302         my $in_comment = 0;
1303         $current_comment = '';
1304         for (my $linenr = $first_line; $linenr < $end_line; $linenr++) {
1305                 my $line = $rawlines[$linenr - 1];
1306                 #warn "           $line\n";
1307                 if ($linenr == $first_line and $line =~ m@^.\s*\*@) {
1308                         $in_comment = 1;
1309                 }
1310                 if ($line =~ m@/\*@) {
1311                         $in_comment = 1;
1312                 }
1313                 if (!$in_comment && $current_comment ne '') {
1314                         $current_comment = '';
1315                 }
1316                 $current_comment .= $line . "\n" if ($in_comment);
1317                 if ($line =~ m@\*/@) {
1318                         $in_comment = 0;
1319                 }
1320         }
1321
1322         chomp($current_comment);
1323         return($current_comment);
1324 }
1325 sub ctx_has_comment {
1326         my ($first_line, $end_line) = @_;
1327         my $cmt = ctx_locate_comment($first_line, $end_line);
1328
1329         ##print "LINE: $rawlines[$end_line - 1 ]\n";
1330         ##print "CMMT: $cmt\n";
1331
1332         return ($cmt ne '');
1333 }
1334
1335 sub raw_line {
1336         my ($linenr, $cnt) = @_;
1337
1338         my $offset = $linenr - 1;
1339         $cnt++;
1340
1341         my $line;
1342         while ($cnt) {
1343                 $line = $rawlines[$offset++];
1344                 next if (defined($line) && $line =~ /^-/);
1345                 $cnt--;
1346         }
1347
1348         return $line;
1349 }
1350
1351 sub cat_vet {
1352         my ($vet) = @_;
1353         my ($res, $coded);
1354
1355         $res = '';
1356         while ($vet =~ /([^[:cntrl:]]*)([[:cntrl:]]|$)/g) {
1357                 $res .= $1;
1358                 if ($2 ne '') {
1359                         $coded = sprintf("^%c", unpack('C', $2) + 64);
1360                         $res .= $coded;
1361                 }
1362         }
1363         $res =~ s/$/\$/;
1364
1365         return $res;
1366 }
1367
1368 my $av_preprocessor = 0;
1369 my $av_pending;
1370 my @av_paren_type;
1371 my $av_pend_colon;
1372
1373 sub annotate_reset {
1374         $av_preprocessor = 0;
1375         $av_pending = '_';
1376         @av_paren_type = ('E');
1377         $av_pend_colon = 'O';
1378 }
1379
1380 sub annotate_values {
1381         my ($stream, $type) = @_;
1382
1383         my $res;
1384         my $var = '_' x length($stream);
1385         my $cur = $stream;
1386
1387         print "$stream\n" if ($dbg_values > 1);
1388
1389         while (length($cur)) {
1390                 @av_paren_type = ('E') if ($#av_paren_type < 0);
1391                 print " <" . join('', @av_paren_type) .
1392                                 "> <$type> <$av_pending>" if ($dbg_values > 1);
1393                 if ($cur =~ /^(\s+)/o) {
1394                         print "WS($1)\n" if ($dbg_values > 1);
1395                         if ($1 =~ /\n/ && $av_preprocessor) {
1396                                 $type = pop(@av_paren_type);
1397                                 $av_preprocessor = 0;
1398                         }
1399
1400                 } elsif ($cur =~ /^(\(\s*$Type\s*)\)/ && $av_pending eq '_') {
1401                         print "CAST($1)\n" if ($dbg_values > 1);
1402                         push(@av_paren_type, $type);
1403                         $type = 'c';
1404
1405                 } elsif ($cur =~ /^($Type)\s*(?:$Ident|,|\)|\(|\s*$)/) {
1406                         print "DECLARE($1)\n" if ($dbg_values > 1);
1407                         $type = 'T';
1408
1409                 } elsif ($cur =~ /^($Modifier)\s*/) {
1410                         print "MODIFIER($1)\n" if ($dbg_values > 1);
1411                         $type = 'T';
1412
1413                 } elsif ($cur =~ /^(\#\s*define\s*$Ident)(\(?)/o) {
1414                         print "DEFINE($1,$2)\n" if ($dbg_values > 1);
1415                         $av_preprocessor = 1;
1416                         push(@av_paren_type, $type);
1417                         if ($2 ne '') {
1418                                 $av_pending = 'N';
1419                         }
1420                         $type = 'E';
1421
1422                 } elsif ($cur =~ /^(\#\s*(?:undef\s*$Ident|include\b))/o) {
1423                         print "UNDEF($1)\n" if ($dbg_values > 1);
1424                         $av_preprocessor = 1;
1425                         push(@av_paren_type, $type);
1426
1427                 } elsif ($cur =~ /^(\#\s*(?:ifdef|ifndef|if))/o) {
1428                         print "PRE_START($1)\n" if ($dbg_values > 1);
1429                         $av_preprocessor = 1;
1430
1431                         push(@av_paren_type, $type);
1432                         push(@av_paren_type, $type);
1433                         $type = 'E';
1434
1435                 } elsif ($cur =~ /^(\#\s*(?:else|elif))/o) {
1436                         print "PRE_RESTART($1)\n" if ($dbg_values > 1);
1437                         $av_preprocessor = 1;
1438
1439                         push(@av_paren_type, $av_paren_type[$#av_paren_type]);
1440
1441                         $type = 'E';
1442
1443                 } elsif ($cur =~ /^(\#\s*(?:endif))/o) {
1444                         print "PRE_END($1)\n" if ($dbg_values > 1);
1445
1446                         $av_preprocessor = 1;
1447
1448                         # Assume all arms of the conditional end as this
1449                         # one does, and continue as if the #endif was not here.
1450                         pop(@av_paren_type);
1451                         push(@av_paren_type, $type);
1452                         $type = 'E';
1453
1454                 } elsif ($cur =~ /^(\\\n)/o) {
1455                         print "PRECONT($1)\n" if ($dbg_values > 1);
1456
1457                 } elsif ($cur =~ /^(__attribute__)\s*\(?/o) {
1458                         print "ATTR($1)\n" if ($dbg_values > 1);
1459                         $av_pending = $type;
1460                         $type = 'N';
1461
1462                 } elsif ($cur =~ /^(sizeof)\s*(\()?/o) {
1463                         print "SIZEOF($1)\n" if ($dbg_values > 1);
1464                         if (defined $2) {
1465                                 $av_pending = 'V';
1466                         }
1467                         $type = 'N';
1468
1469                 } elsif ($cur =~ /^(if|while|for)\b/o) {
1470                         print "COND($1)\n" if ($dbg_values > 1);
1471                         $av_pending = 'E';
1472                         $type = 'N';
1473
1474                 } elsif ($cur =~/^(case)/o) {
1475                         print "CASE($1)\n" if ($dbg_values > 1);
1476                         $av_pend_colon = 'C';
1477                         $type = 'N';
1478
1479                 } elsif ($cur =~/^(return|else|goto|typeof|__typeof__)\b/o) {
1480                         print "KEYWORD($1)\n" if ($dbg_values > 1);
1481                         $type = 'N';
1482
1483                 } elsif ($cur =~ /^(\()/o) {
1484                         print "PAREN('$1')\n" if ($dbg_values > 1);
1485                         push(@av_paren_type, $av_pending);
1486                         $av_pending = '_';
1487                         $type = 'N';
1488
1489                 } elsif ($cur =~ /^(\))/o) {
1490                         my $new_type = pop(@av_paren_type);
1491                         if ($new_type ne '_') {
1492                                 $type = $new_type;
1493                                 print "PAREN('$1') -> $type\n"
1494                                                         if ($dbg_values > 1);
1495                         } else {
1496                                 print "PAREN('$1')\n" if ($dbg_values > 1);
1497                         }
1498
1499                 } elsif ($cur =~ /^($Ident)\s*\(/o) {
1500                         print "FUNC($1)\n" if ($dbg_values > 1);
1501                         $type = 'V';
1502                         $av_pending = 'V';
1503
1504                 } elsif ($cur =~ /^($Ident\s*):(?:\s*\d+\s*(,|=|;))?/) {
1505                         if (defined $2 && $type eq 'C' || $type eq 'T') {
1506                                 $av_pend_colon = 'B';
1507                         } elsif ($type eq 'E') {
1508                                 $av_pend_colon = 'L';
1509                         }
1510                         print "IDENT_COLON($1,$type>$av_pend_colon)\n" if ($dbg_values > 1);
1511                         $type = 'V';
1512
1513                 } elsif ($cur =~ /^($Ident|$Constant)/o) {
1514                         print "IDENT($1)\n" if ($dbg_values > 1);
1515                         $type = 'V';
1516
1517                 } elsif ($cur =~ /^($Assignment)/o) {
1518                         print "ASSIGN($1)\n" if ($dbg_values > 1);
1519                         $type = 'N';
1520
1521                 } elsif ($cur =~/^(;|{|})/) {
1522                         print "END($1)\n" if ($dbg_values > 1);
1523                         $type = 'E';
1524                         $av_pend_colon = 'O';
1525
1526                 } elsif ($cur =~/^(,)/) {
1527                         print "COMMA($1)\n" if ($dbg_values > 1);
1528                         $type = 'C';
1529
1530                 } elsif ($cur =~ /^(\?)/o) {
1531                         print "QUESTION($1)\n" if ($dbg_values > 1);
1532                         $type = 'N';
1533
1534                 } elsif ($cur =~ /^(:)/o) {
1535                         print "COLON($1,$av_pend_colon)\n" if ($dbg_values > 1);
1536
1537                         substr($var, length($res), 1, $av_pend_colon);
1538                         if ($av_pend_colon eq 'C' || $av_pend_colon eq 'L') {
1539                                 $type = 'E';
1540                         } else {
1541                                 $type = 'N';
1542                         }
1543                         $av_pend_colon = 'O';
1544
1545                 } elsif ($cur =~ /^(\[)/o) {
1546                         print "CLOSE($1)\n" if ($dbg_values > 1);
1547                         $type = 'N';
1548
1549                 } elsif ($cur =~ /^(-(?![->])|\+(?!\+)|\*|\&\&|\&)/o) {
1550                         my $variant;
1551
1552                         print "OPV($1)\n" if ($dbg_values > 1);
1553                         if ($type eq 'V') {
1554                                 $variant = 'B';
1555                         } else {
1556                                 $variant = 'U';
1557                         }
1558
1559                         substr($var, length($res), 1, $variant);
1560                         $type = 'N';
1561
1562                 } elsif ($cur =~ /^($Operators)/o) {
1563                         print "OP($1)\n" if ($dbg_values > 1);
1564                         if ($1 ne '++' && $1 ne '--') {
1565                                 $type = 'N';
1566                         }
1567
1568                 } elsif ($cur =~ /(^.)/o) {
1569                         print "C($1)\n" if ($dbg_values > 1);
1570                 }
1571                 if (defined $1) {
1572                         $cur = substr($cur, length($1));
1573                         $res .= $type x length($1);
1574                 }
1575         }
1576
1577         return ($res, $var);
1578 }
1579
1580 sub possible {
1581         my ($possible, $line) = @_;
1582         my $notPermitted = qr{(?:
1583                 ^(?:
1584                         $Modifier|
1585                         $Storage|
1586                         $Type|
1587                         DEFINE_\S+
1588                 )$|
1589                 ^(?:
1590                         goto|
1591                         return|
1592                         case|
1593                         else|
1594                         asm|__asm__|
1595                         do|
1596                         \#|
1597                         \#\#|
1598                 )(?:\s|$)|
1599                 ^(?:typedef|struct|enum)\b
1600             )}x;
1601         warn "CHECK<$possible> ($line)\n" if ($dbg_possible > 2);
1602         if ($possible !~ $notPermitted) {
1603                 # Check for modifiers.
1604                 $possible =~ s/\s*$Storage\s*//g;
1605                 $possible =~ s/\s*$Sparse\s*//g;
1606                 if ($possible =~ /^\s*$/) {
1607
1608                 } elsif ($possible =~ /\s/) {
1609                         $possible =~ s/\s*$Type\s*//g;
1610                         for my $modifier (split(' ', $possible)) {
1611                                 if ($modifier !~ $notPermitted) {
1612                                         warn "MODIFIER: $modifier ($possible) ($line)\n" if ($dbg_possible);
1613                                         push(@modifierList, $modifier);
1614                                 }
1615                         }
1616
1617                 } else {
1618                         warn "POSSIBLE: $possible ($line)\n" if ($dbg_possible);
1619                         push(@typeList, $possible);
1620                 }
1621                 build_types();
1622         } else {
1623                 warn "NOTPOSS: $possible ($line)\n" if ($dbg_possible > 1);
1624         }
1625 }
1626
1627 my $prefix = '';
1628
1629 sub show_type {
1630         my ($type) = @_;
1631
1632         return defined $use_type{$type} if (scalar keys %use_type > 0);
1633
1634         return !defined $ignore_type{$type};
1635 }
1636
1637 sub report {
1638         my ($level, $type, $msg) = @_;
1639
1640         if (!show_type($type) ||
1641             (defined $tst_only && $msg !~ /\Q$tst_only\E/)) {
1642                 return 0;
1643         }
1644         my $line;
1645         if ($show_types) {
1646                 $line = "$prefix$level:$type: $msg\n";
1647         } else {
1648                 $line = "$prefix$level: $msg\n";
1649         }
1650         $line = (split('\n', $line))[0] . "\n" if ($terse);
1651
1652         push(our @report, $line);
1653
1654         return 1;
1655 }
1656
1657 sub report_dump {
1658         our @report;
1659 }
1660
1661 sub fixup_current_range {
1662         my ($lineRef, $offset, $length) = @_;
1663
1664         if ($$lineRef =~ /^\@\@ -\d+,\d+ \+(\d+),(\d+) \@\@/) {
1665                 my $o = $1;
1666                 my $l = $2;
1667                 my $no = $o + $offset;
1668                 my $nl = $l + $length;
1669                 $$lineRef =~ s/\+$o,$l \@\@/\+$no,$nl \@\@/;
1670         }
1671 }
1672
1673 sub fix_inserted_deleted_lines {
1674         my ($linesRef, $insertedRef, $deletedRef) = @_;
1675
1676         my $range_last_linenr = 0;
1677         my $delta_offset = 0;
1678
1679         my $old_linenr = 0;
1680         my $new_linenr = 0;
1681
1682         my $next_insert = 0;
1683         my $next_delete = 0;
1684
1685         my @lines = ();
1686
1687         my $inserted = @{$insertedRef}[$next_insert++];
1688         my $deleted = @{$deletedRef}[$next_delete++];
1689
1690         foreach my $old_line (@{$linesRef}) {
1691                 my $save_line = 1;
1692                 my $line = $old_line;   #don't modify the array
1693                 if ($line =~ /^(?:\+\+\+|\-\-\-)\s+\S+/) {      #new filename
1694                         $delta_offset = 0;
1695                 } elsif ($line =~ /^\@\@ -\d+,\d+ \+\d+,\d+ \@\@/) {    #new hunk
1696                         $range_last_linenr = $new_linenr;
1697                         fixup_current_range(\$line, $delta_offset, 0);
1698                 }
1699
1700                 while (defined($deleted) && ${$deleted}{'LINENR'} == $old_linenr) {
1701                         $deleted = @{$deletedRef}[$next_delete++];
1702                         $save_line = 0;
1703                         fixup_current_range(\$lines[$range_last_linenr], $delta_offset--, -1);
1704                 }
1705
1706                 while (defined($inserted) && ${$inserted}{'LINENR'} == $old_linenr) {
1707                         push(@lines, ${$inserted}{'LINE'});
1708                         $inserted = @{$insertedRef}[$next_insert++];
1709                         $new_linenr++;
1710                         fixup_current_range(\$lines[$range_last_linenr], $delta_offset++, 1);
1711                 }
1712
1713                 if ($save_line) {
1714                         push(@lines, $line);
1715                         $new_linenr++;
1716                 }
1717
1718                 $old_linenr++;
1719         }
1720
1721         return @lines;
1722 }
1723
1724 sub fix_insert_line {
1725         my ($linenr, $line) = @_;
1726
1727         my $inserted = {
1728                 LINENR => $linenr,
1729                 LINE => $line,
1730         };
1731         push(@fixed_inserted, $inserted);
1732 }
1733
1734 sub fix_delete_line {
1735         my ($linenr, $line) = @_;
1736
1737         my $deleted = {
1738                 LINENR => $linenr,
1739                 LINE => $line,
1740         };
1741
1742         push(@fixed_deleted, $deleted);
1743 }
1744
1745 sub ERROR {
1746         my ($type, $msg) = @_;
1747
1748         if (report("ERROR", $type, $msg)) {
1749                 our $clean = 0;
1750                 our $cnt_error++;
1751                 return 1;
1752         }
1753         return 0;
1754 }
1755 sub WARN {
1756         my ($type, $msg) = @_;
1757
1758         if (report("WARNING", $type, $msg)) {
1759                 our $clean = 0;
1760                 our $cnt_warn++;
1761                 return 1;
1762         }
1763         return 0;
1764 }
1765 sub CHK {
1766         my ($type, $msg) = @_;
1767
1768         if ($check && report("CHECK", $type, $msg)) {
1769                 our $clean = 0;
1770                 our $cnt_chk++;
1771                 return 1;
1772         }
1773         return 0;
1774 }
1775
1776 sub check_absolute_file {
1777         my ($absolute, $herecurr) = @_;
1778         my $file = $absolute;
1779
1780         ##print "absolute<$absolute>\n";
1781
1782         # See if any suffix of this path is a path within the tree.
1783         while ($file =~ s@^[^/]*/@@) {
1784                 if (-f "$root/$file") {
1785                         ##print "file<$file>\n";
1786                         last;
1787                 }
1788         }
1789         if (! -f _)  {
1790                 return 0;
1791         }
1792
1793         # It is, so see if the prefix is acceptable.
1794         my $prefix = $absolute;
1795         substr($prefix, -length($file)) = '';
1796
1797         ##print "prefix<$prefix>\n";
1798         if ($prefix ne ".../") {
1799                 WARN("USE_RELATIVE_PATH",
1800                      "use relative pathname instead of absolute in changelog text\n" . $herecurr);
1801         }
1802 }
1803
1804 sub trim {
1805         my ($string) = @_;
1806
1807         $string =~ s/^\s+|\s+$//g;
1808
1809         return $string;
1810 }
1811
1812 sub ltrim {
1813         my ($string) = @_;
1814
1815         $string =~ s/^\s+//;
1816
1817         return $string;
1818 }
1819
1820 sub rtrim {
1821         my ($string) = @_;
1822
1823         $string =~ s/\s+$//;
1824
1825         return $string;
1826 }
1827
1828 sub string_find_replace {
1829         my ($string, $find, $replace) = @_;
1830
1831         $string =~ s/$find/$replace/g;
1832
1833         return $string;
1834 }
1835
1836 sub tabify {
1837         my ($leading) = @_;
1838
1839         my $source_indent = 8;
1840         my $max_spaces_before_tab = $source_indent - 1;
1841         my $spaces_to_tab = " " x $source_indent;
1842
1843         #convert leading spaces to tabs
1844         1 while $leading =~ s@^([\t]*)$spaces_to_tab@$1\t@g;
1845         #Remove spaces before a tab
1846         1 while $leading =~ s@^([\t]*)( {1,$max_spaces_before_tab})\t@$1\t@g;
1847
1848         return "$leading";
1849 }
1850
1851 sub pos_last_openparen {
1852         my ($line) = @_;
1853
1854         my $pos = 0;
1855
1856         my $opens = $line =~ tr/\(/\(/;
1857         my $closes = $line =~ tr/\)/\)/;
1858
1859         my $last_openparen = 0;
1860
1861         if (($opens == 0) || ($closes >= $opens)) {
1862                 return -1;
1863         }
1864
1865         my $len = length($line);
1866
1867         for ($pos = 0; $pos < $len; $pos++) {
1868                 my $string = substr($line, $pos);
1869                 if ($string =~ /^($FuncArg|$balanced_parens)/) {
1870                         $pos += length($1) - 1;
1871                 } elsif (substr($line, $pos, 1) eq '(') {
1872                         $last_openparen = $pos;
1873                 } elsif (index($string, '(') == -1) {
1874                         last;
1875                 }
1876         }
1877
1878         return length(expand_tabs(substr($line, 0, $last_openparen))) + 1;
1879 }
1880
1881 sub process {
1882         my $filename = shift;
1883
1884         my $linenr=0;
1885         my $prevline="";
1886         my $prevrawline="";
1887         my $stashline="";
1888         my $stashrawline="";
1889
1890         my $length;
1891         my $indent;
1892         my $previndent=0;
1893         my $stashindent=0;
1894
1895         our $clean = 1;
1896         my $signoff = 0;
1897         my $is_patch = 0;
1898
1899         my $in_header_lines = $file ? 0 : 1;
1900         my $in_commit_log = 0;          #Scanning lines before patch
1901         my $commit_log_long_line = 0;
1902         my $reported_maintainer_file = 0;
1903         my $non_utf8_charset = 0;
1904
1905         my $last_blank_line = 0;
1906         my $last_coalesced_string_linenr = -1;
1907
1908         our @report = ();
1909         our $cnt_lines = 0;
1910         our $cnt_error = 0;
1911         our $cnt_warn = 0;
1912         our $cnt_chk = 0;
1913
1914         # Trace the real file/line as we go.
1915         my $realfile = '';
1916         my $realline = 0;
1917         my $realcnt = 0;
1918         my $here = '';
1919         my $in_comment = 0;
1920         my $comment_edge = 0;
1921         my $first_line = 0;
1922         my $p1_prefix = '';
1923
1924         my $prev_values = 'E';
1925
1926         # suppression flags
1927         my %suppress_ifbraces;
1928         my %suppress_whiletrailers;
1929         my %suppress_export;
1930         my $suppress_statement = 0;
1931
1932         my %signatures = ();
1933
1934         # Pre-scan the patch sanitizing the lines.
1935         # Pre-scan the patch looking for any __setup documentation.
1936         #
1937         my @setup_docs = ();
1938         my $setup_docs = 0;
1939
1940         my $camelcase_file_seeded = 0;
1941
1942         sanitise_line_reset();
1943         my $line;
1944         foreach my $rawline (@rawlines) {
1945                 $linenr++;
1946                 $line = $rawline;
1947
1948                 push(@fixed, $rawline) if ($fix);
1949
1950                 if ($rawline=~/^\+\+\+\s+(\S+)/) {
1951                         $setup_docs = 0;
1952                         if ($1 =~ m@Documentation/kernel-parameters.txt$@) {
1953                                 $setup_docs = 1;
1954                         }
1955                         #next;
1956                 }
1957                 if ($rawline=~/^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@/) {
1958                         $realline=$1-1;
1959                         if (defined $2) {
1960                                 $realcnt=$3+1;
1961                         } else {
1962                                 $realcnt=1+1;
1963                         }
1964                         $in_comment = 0;
1965
1966                         # Guestimate if this is a continuing comment.  Run
1967                         # the context looking for a comment "edge".  If this
1968                         # edge is a close comment then we must be in a comment
1969                         # at context start.
1970                         my $edge;
1971                         my $cnt = $realcnt;
1972                         for (my $ln = $linenr + 1; $cnt > 0; $ln++) {
1973                                 next if (defined $rawlines[$ln - 1] &&
1974                                          $rawlines[$ln - 1] =~ /^-/);
1975                                 $cnt--;
1976                                 #print "RAW<$rawlines[$ln - 1]>\n";
1977                                 last if (!defined $rawlines[$ln - 1]);
1978                                 if ($rawlines[$ln - 1] =~ m@(/\*|\*/)@ &&
1979                                     $rawlines[$ln - 1] !~ m@"[^"]*(?:/\*|\*/)[^"]*"@) {
1980                                         ($edge) = $1;
1981                                         last;
1982                                 }
1983                         }
1984                         if (defined $edge && $edge eq '*/') {
1985                                 $in_comment = 1;
1986                         }
1987
1988                         # Guestimate if this is a continuing comment.  If this
1989                         # is the start of a diff block and this line starts
1990                         # ' *' then it is very likely a comment.
1991                         if (!defined $edge &&
1992                             $rawlines[$linenr] =~ m@^.\s*(?:\*\*+| \*)(?:\s|$)@)
1993                         {
1994                                 $in_comment = 1;
1995                         }
1996
1997                         ##print "COMMENT:$in_comment edge<$edge> $rawline\n";
1998                         sanitise_line_reset($in_comment);
1999
2000                 } elsif ($realcnt && $rawline =~ /^(?:\+| |$)/) {
2001                         # Standardise the strings and chars within the input to
2002                         # simplify matching -- only bother with positive lines.
2003                         $line = sanitise_line($rawline);
2004                 }
2005                 push(@lines, $line);
2006
2007                 if ($realcnt > 1) {
2008                         $realcnt-- if ($line =~ /^(?:\+| |$)/);
2009                 } else {
2010                         $realcnt = 0;
2011                 }
2012
2013                 #print "==>$rawline\n";
2014                 #print "-->$line\n";
2015
2016                 if ($setup_docs && $line =~ /^\+/) {
2017                         push(@setup_docs, $line);
2018                 }
2019         }
2020
2021         $prefix = '';
2022
2023         $realcnt = 0;
2024         $linenr = 0;
2025         $fixlinenr = -1;
2026         foreach my $line (@lines) {
2027                 $linenr++;
2028                 $fixlinenr++;
2029                 my $sline = $line;      #copy of $line
2030                 $sline =~ s/$;/ /g;     #with comments as spaces
2031
2032                 my $rawline = $rawlines[$linenr - 1];
2033
2034 #extract the line range in the file after the patch is applied
2035                 if ($line=~/^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@/) {
2036                         $is_patch = 1;
2037                         $first_line = $linenr + 1;
2038                         $realline=$1-1;
2039                         if (defined $2) {
2040                                 $realcnt=$3+1;
2041                         } else {
2042                                 $realcnt=1+1;
2043                         }
2044                         annotate_reset();
2045                         $prev_values = 'E';
2046
2047                         %suppress_ifbraces = ();
2048                         %suppress_whiletrailers = ();
2049                         %suppress_export = ();
2050                         $suppress_statement = 0;
2051                         next;
2052
2053 # track the line number as we move through the hunk, note that
2054 # new versions of GNU diff omit the leading space on completely
2055 # blank context lines so we need to count that too.
2056                 } elsif ($line =~ /^( |\+|$)/) {
2057                         $realline++;
2058                         $realcnt-- if ($realcnt != 0);
2059
2060                         # Measure the line length and indent.
2061                         ($length, $indent) = line_stats($rawline);
2062
2063                         # Track the previous line.
2064                         ($prevline, $stashline) = ($stashline, $line);
2065                         ($previndent, $stashindent) = ($stashindent, $indent);
2066                         ($prevrawline, $stashrawline) = ($stashrawline, $rawline);
2067
2068                         #warn "line<$line>\n";
2069
2070                 } elsif ($realcnt == 1) {
2071                         $realcnt--;
2072                 }
2073
2074                 my $hunk_line = ($realcnt != 0);
2075
2076 #make up the handle for any error we report on this line
2077                 $prefix = "$filename:$realline: " if ($emacs && $file);
2078                 $prefix = "$filename:$linenr: " if ($emacs && !$file);
2079
2080                 $here = "#$linenr: " if (!$file);
2081                 $here = "#$realline: " if ($file);
2082
2083                 my $found_file = 0;
2084                 # extract the filename as it passes
2085                 if ($line =~ /^diff --git.*?(\S+)$/) {
2086                         $realfile = $1;
2087                         $realfile =~ s@^([^/]*)/@@ if (!$file);
2088                         $in_commit_log = 0;
2089                         $found_file = 1;
2090                 } elsif ($line =~ /^\+\+\+\s+(\S+)/) {
2091                         $realfile = $1;
2092                         $realfile =~ s@^([^/]*)/@@ if (!$file);
2093                         $in_commit_log = 0;
2094
2095                         $p1_prefix = $1;
2096                         if (!$file && $tree && $p1_prefix ne '' &&
2097                             -e "$root/$p1_prefix") {
2098                                 WARN("PATCH_PREFIX",
2099                                      "patch prefix '$p1_prefix' exists, appears to be a -p0 patch\n");
2100                         }
2101
2102                         if ($realfile =~ m@^include/asm/@) {
2103                                 ERROR("MODIFIED_INCLUDE_ASM",
2104                                       "do not modify files in include/asm, change architecture specific files in include/asm-<architecture>\n" . "$here$rawline\n");
2105                         }
2106                         $found_file = 1;
2107                 }
2108
2109                 if ($found_file) {
2110                         if ($realfile =~ m@^(drivers/net/|net/)@) {
2111                                 $check = 1;
2112                         } else {
2113                                 $check = $check_orig;
2114                         }
2115                         next;
2116                 }
2117
2118                 $here .= "FILE: $realfile:$realline:" if ($realcnt != 0);
2119
2120                 my $hereline = "$here\n$rawline\n";
2121                 my $herecurr = "$here\n$rawline\n";
2122                 my $hereprev = "$here\n$prevrawline\n$rawline\n";
2123
2124                 $cnt_lines++ if ($realcnt != 0);
2125
2126 # Check for incorrect file permissions
2127                 if ($line =~ /^new (file )?mode.*[7531]\d{0,2}$/) {
2128                         my $permhere = $here . "FILE: $realfile\n";
2129                         if ($realfile !~ m@scripts/@ &&
2130                             $realfile !~ /\.(py|pl|awk|sh)$/) {
2131                                 ERROR("EXECUTE_PERMISSIONS",
2132                                       "do not set execute permissions for source files\n" . $permhere);
2133                         }
2134                 }
2135
2136 # Check the patch for a signoff:
2137                 if ($line =~ /^\s*signed-off-by:/i) {
2138                         $signoff++;
2139                         $in_commit_log = 0;
2140                 }
2141
2142 # Check if MAINTAINERS is being updated.  If so, there's probably no need to
2143 # emit the "does MAINTAINERS need updating?" message on file add/move/delete
2144                 if ($line =~ /^\s*MAINTAINERS\s*\|/) {
2145                         $reported_maintainer_file = 1;
2146                 }
2147
2148 # Check signature styles
2149                 if (!$in_header_lines &&
2150                     $line =~ /^(\s*)([a-z0-9_-]+by:|$signature_tags)(\s*)(.*)/i) {
2151                         my $space_before = $1;
2152                         my $sign_off = $2;
2153                         my $space_after = $3;
2154                         my $email = $4;
2155                         my $ucfirst_sign_off = ucfirst(lc($sign_off));
2156
2157                         if ($sign_off !~ /$signature_tags/) {
2158                                 WARN("BAD_SIGN_OFF",
2159                                      "Non-standard signature: $sign_off\n" . $herecurr);
2160                         }
2161                         if (defined $space_before && $space_before ne "") {
2162                                 if (WARN("BAD_SIGN_OFF",
2163                                          "Do not use whitespace before $ucfirst_sign_off\n" . $herecurr) &&
2164                                     $fix) {
2165                                         $fixed[$fixlinenr] =
2166                                             "$ucfirst_sign_off $email";
2167                                 }
2168                         }
2169                         if ($sign_off =~ /-by:$/i && $sign_off ne $ucfirst_sign_off) {
2170                                 if (WARN("BAD_SIGN_OFF",
2171                                          "'$ucfirst_sign_off' is the preferred signature form\n" . $herecurr) &&
2172                                     $fix) {
2173                                         $fixed[$fixlinenr] =
2174                                             "$ucfirst_sign_off $email";
2175                                 }
2176
2177                         }
2178                         if (!defined $space_after || $space_after ne " ") {
2179                                 if (WARN("BAD_SIGN_OFF",
2180                                          "Use a single space after $ucfirst_sign_off\n" . $herecurr) &&
2181                                     $fix) {
2182                                         $fixed[$fixlinenr] =
2183                                             "$ucfirst_sign_off $email";
2184                                 }
2185                         }
2186
2187                         my ($email_name, $email_address, $comment) = parse_email($email);
2188                         my $suggested_email = format_email(($email_name, $email_address));
2189                         if ($suggested_email eq "") {
2190                                 ERROR("BAD_SIGN_OFF",
2191                                       "Unrecognized email address: '$email'\n" . $herecurr);
2192                         } else {
2193                                 my $dequoted = $suggested_email;
2194                                 $dequoted =~ s/^"//;
2195                                 $dequoted =~ s/" </ </;
2196                                 # Don't force email to have quotes
2197                                 # Allow just an angle bracketed address
2198                                 if ("$dequoted$comment" ne $email &&
2199                                     "<$email_address>$comment" ne $email &&
2200                                     "$suggested_email$comment" ne $email) {
2201                                         WARN("BAD_SIGN_OFF",
2202                                              "email address '$email' might be better as '$suggested_email$comment'\n" . $herecurr);
2203                                 }
2204                         }
2205
2206 # Check for duplicate signatures
2207                         my $sig_nospace = $line;
2208                         $sig_nospace =~ s/\s//g;
2209                         $sig_nospace = lc($sig_nospace);
2210                         if (defined $signatures{$sig_nospace}) {
2211                                 WARN("BAD_SIGN_OFF",
2212                                      "Duplicate signature\n" . $herecurr);
2213                         } else {
2214                                 $signatures{$sig_nospace} = 1;
2215                         }
2216                 }
2217
2218 # Check email subject for common tools that don't need to be mentioned
2219                 if ($in_header_lines &&
2220                     $line =~ /^Subject:.*\b(?:checkpatch|sparse|smatch)\b[^:]/i) {
2221                         WARN("EMAIL_SUBJECT",
2222                              "A patch subject line should describe the change not the tool that found it\n" . $herecurr);
2223                 }
2224
2225 # Check for old stable address
2226                 if ($line =~ /^\s*cc:\s*.*<?\bstable\@kernel\.org\b>?.*$/i) {
2227                         ERROR("STABLE_ADDRESS",
2228                               "The 'stable' address should be 'stable\@vger.kernel.org'\n" . $herecurr);
2229                 }
2230
2231 # Check for unwanted Gerrit info
2232                 if ($in_commit_log && $line =~ /^\s*change-id:/i) {
2233                         ERROR("GERRIT_CHANGE_ID",
2234                               "Remove Gerrit Change-Id's before submitting upstream.\n" . $herecurr);
2235                 }
2236
2237 # Check for line lengths > 75 in commit log, warn once
2238                 if ($in_commit_log && !$commit_log_long_line &&
2239                     length($line) > 75) {
2240                         WARN("COMMIT_LOG_LONG_LINE",
2241                              "Possible unwrapped commit description (prefer a maximum 75 chars per line)\n" . $herecurr);
2242                         $commit_log_long_line = 1;
2243                 }
2244
2245 # Check for git id commit length and improperly formed commit descriptions
2246                 if ($in_commit_log && $line =~ /\b(c)ommit\s+([0-9a-f]{5,})/i) {
2247                         my $init_char = $1;
2248                         my $orig_commit = lc($2);
2249                         my $short = 1;
2250                         my $long = 0;
2251                         my $case = 1;
2252                         my $space = 1;
2253                         my $hasdesc = 0;
2254                         my $hasparens = 0;
2255                         my $id = '0123456789ab';
2256                         my $orig_desc = "commit description";
2257                         my $description = "";
2258
2259                         $short = 0 if ($line =~ /\bcommit\s+[0-9a-f]{12,40}/i);
2260                         $long = 1 if ($line =~ /\bcommit\s+[0-9a-f]{41,}/i);
2261                         $space = 0 if ($line =~ /\bcommit [0-9a-f]/i);
2262                         $case = 0 if ($line =~ /\b[Cc]ommit\s+[0-9a-f]{5,40}[^A-F]/);
2263                         if ($line =~ /\bcommit\s+[0-9a-f]{5,}\s+\("([^"]+)"\)/i) {
2264                                 $orig_desc = $1;
2265                                 $hasparens = 1;
2266                         } elsif ($line =~ /\bcommit\s+[0-9a-f]{5,}\s*$/i &&
2267                                  defined $rawlines[$linenr] &&
2268                                  $rawlines[$linenr] =~ /^\s*\("([^"]+)"\)/) {
2269                                 $orig_desc = $1;
2270                                 $hasparens = 1;
2271                         } elsif ($line =~ /\bcommit\s+[0-9a-f]{5,}\s+\("[^"]+$/i &&
2272                                  defined $rawlines[$linenr] &&
2273                                  $rawlines[$linenr] =~ /^\s*[^"]+"\)/) {
2274                                 $line =~ /\bcommit\s+[0-9a-f]{5,}\s+\("([^"]+)$/i;
2275                                 $orig_desc = $1;
2276                                 $rawlines[$linenr] =~ /^\s*([^"]+)"\)/;
2277                                 $orig_desc .= " " . $1;
2278                                 $hasparens = 1;
2279                         }
2280
2281                         ($id, $description) = git_commit_info($orig_commit,
2282                                                               $id, $orig_desc);
2283
2284                         if ($short || $long || $space || $case || ($orig_desc ne $description) || !$hasparens) {
2285                                 ERROR("GIT_COMMIT_ID",
2286                                       "Please use git commit description style 'commit <12+ chars of sha1> (\"<title line>\")' - ie: '${init_char}ommit $id (\"$description\")'\n" . $herecurr);
2287                         }
2288                 }
2289
2290 # Check for added, moved or deleted files
2291                 if (!$reported_maintainer_file && !$in_commit_log &&
2292                     ($line =~ /^(?:new|deleted) file mode\s*\d+\s*$/ ||
2293                      $line =~ /^rename (?:from|to) [\w\/\.\-]+\s*$/ ||
2294                      ($line =~ /\{\s*([\w\/\.\-]*)\s*\=\>\s*([\w\/\.\-]*)\s*\}/ &&
2295                       (defined($1) || defined($2))))) {
2296                         $reported_maintainer_file = 1;
2297                         WARN("FILE_PATH_CHANGES",
2298                              "added, moved or deleted file(s), does MAINTAINERS need updating?\n" . $herecurr);
2299                 }
2300
2301 # Check for wrappage within a valid hunk of the file
2302                 if ($realcnt != 0 && $line !~ m{^(?:\+|-| |\\ No newline|$)}) {
2303                         ERROR("CORRUPTED_PATCH",
2304                               "patch seems to be corrupt (line wrapped?)\n" .
2305                                 $herecurr) if (!$emitted_corrupt++);
2306                 }
2307
2308 # Check for absolute kernel paths.
2309                 if ($tree) {
2310                         while ($line =~ m{(?:^|\s)(/\S*)}g) {
2311                                 my $file = $1;
2312
2313                                 if ($file =~ m{^(.*?)(?::\d+)+:?$} &&
2314                                     check_absolute_file($1, $herecurr)) {
2315                                         #
2316                                 } else {
2317                                         check_absolute_file($file, $herecurr);
2318                                 }
2319                         }
2320                 }
2321
2322 # UTF-8 regex found at http://www.w3.org/International/questions/qa-forms-utf-8.en.php
2323                 if (($realfile =~ /^$/ || $line =~ /^\+/) &&
2324                     $rawline !~ m/^$UTF8*$/) {
2325                         my ($utf8_prefix) = ($rawline =~ /^($UTF8*)/);
2326
2327                         my $blank = copy_spacing($rawline);
2328                         my $ptr = substr($blank, 0, length($utf8_prefix)) . "^";
2329                         my $hereptr = "$hereline$ptr\n";
2330
2331                         CHK("INVALID_UTF8",
2332                             "Invalid UTF-8, patch and commit message should be encoded in UTF-8\n" . $hereptr);
2333                 }
2334
2335 # Check if it's the start of a commit log
2336 # (not a header line and we haven't seen the patch filename)
2337                 if ($in_header_lines && $realfile =~ /^$/ &&
2338                     !($rawline =~ /^\s+\S/ ||
2339                       $rawline =~ /^(commit\b|from\b|[\w-]+:).*$/i)) {
2340                         $in_header_lines = 0;
2341                         $in_commit_log = 1;
2342                 }
2343
2344 # Check if there is UTF-8 in a commit log when a mail header has explicitly
2345 # declined it, i.e defined some charset where it is missing.
2346                 if ($in_header_lines &&
2347                     $rawline =~ /^Content-Type:.+charset="(.+)".*$/ &&
2348                     $1 !~ /utf-8/i) {
2349                         $non_utf8_charset = 1;
2350                 }
2351
2352                 if ($in_commit_log && $non_utf8_charset && $realfile =~ /^$/ &&
2353                     $rawline =~ /$NON_ASCII_UTF8/) {
2354                         WARN("UTF8_BEFORE_PATCH",
2355                             "8-bit UTF-8 used in possible commit log\n" . $herecurr);
2356                 }
2357
2358 # Check for various typo / spelling mistakes
2359                 if (defined($misspellings) &&
2360                     ($in_commit_log || $line =~ /^(?:\+|Subject:)/i)) {
2361                         while ($rawline =~ /(?:^|[^a-z@])($misspellings)(?:\b|$|[^a-z@])/gi) {
2362                                 my $typo = $1;
2363                                 my $typo_fix = $spelling_fix{lc($typo)};
2364                                 $typo_fix = ucfirst($typo_fix) if ($typo =~ /^[A-Z]/);
2365                                 $typo_fix = uc($typo_fix) if ($typo =~ /^[A-Z]+$/);
2366                                 my $msg_type = \&WARN;
2367                                 $msg_type = \&CHK if ($file);
2368                                 if (&{$msg_type}("TYPO_SPELLING",
2369                                                  "'$typo' may be misspelled - perhaps '$typo_fix'?\n" . $herecurr) &&
2370                                     $fix) {
2371                                         $fixed[$fixlinenr] =~ s/(^|[^A-Za-z@])($typo)($|[^A-Za-z@])/$1$typo_fix$3/;
2372                                 }
2373                         }
2374                 }
2375
2376 # ignore non-hunk lines and lines being removed
2377                 next if (!$hunk_line || $line =~ /^-/);
2378
2379 #trailing whitespace
2380                 if ($line =~ /^\+.*\015/) {
2381                         my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2382                         if (ERROR("DOS_LINE_ENDINGS",
2383                                   "DOS line endings\n" . $herevet) &&
2384                             $fix) {
2385                                 $fixed[$fixlinenr] =~ s/[\s\015]+$//;
2386                         }
2387                 } elsif ($rawline =~ /^\+.*\S\s+$/ || $rawline =~ /^\+\s+$/) {
2388                         my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2389                         if (ERROR("TRAILING_WHITESPACE",
2390                                   "trailing whitespace\n" . $herevet) &&
2391                             $fix) {
2392                                 $fixed[$fixlinenr] =~ s/\s+$//;
2393                         }
2394
2395                         $rpt_cleaners = 1;
2396                 }
2397
2398 # Check for FSF mailing addresses.
2399                 if ($rawline =~ /\bwrite to the Free/i ||
2400                     $rawline =~ /\b59\s+Temple\s+Pl/i ||
2401                     $rawline =~ /\b51\s+Franklin\s+St/i) {
2402                         my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2403                         my $msg_type = \&ERROR;
2404                         $msg_type = \&CHK if ($file);
2405                         &{$msg_type}("FSF_MAILING_ADDRESS",
2406                                      "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)
2407                 }
2408
2409 # check for Kconfig help text having a real description
2410 # Only applies when adding the entry originally, after that we do not have
2411 # sufficient context to determine whether it is indeed long enough.
2412                 if ($realfile =~ /Kconfig/ &&
2413                     $line =~ /^\+\s*config\s+/) {
2414                         my $length = 0;
2415                         my $cnt = $realcnt;
2416                         my $ln = $linenr + 1;
2417                         my $f;
2418                         my $is_start = 0;
2419                         my $is_end = 0;
2420                         for (; $cnt > 0 && defined $lines[$ln - 1]; $ln++) {
2421                                 $f = $lines[$ln - 1];
2422                                 $cnt-- if ($lines[$ln - 1] !~ /^-/);
2423                                 $is_end = $lines[$ln - 1] =~ /^\+/;
2424
2425                                 next if ($f =~ /^-/);
2426                                 last if (!$file && $f =~ /^\@\@/);
2427
2428                                 if ($lines[$ln - 1] =~ /^\+\s*(?:bool|tristate)\s*\"/) {
2429                                         $is_start = 1;
2430                                 } elsif ($lines[$ln - 1] =~ /^\+\s*(?:---)?help(?:---)?$/) {
2431                                         $length = -1;
2432                                 }
2433
2434                                 $f =~ s/^.//;
2435                                 $f =~ s/#.*//;
2436                                 $f =~ s/^\s+//;
2437                                 next if ($f =~ /^$/);
2438                                 if ($f =~ /^\s*config\s/) {
2439                                         $is_end = 1;
2440                                         last;
2441                                 }
2442                                 $length++;
2443                         }
2444                         if ($is_start && $is_end && $length < $min_conf_desc_length) {
2445                                 WARN("CONFIG_DESCRIPTION",
2446                                      "please write a paragraph that describes the config symbol fully\n" . $herecurr);
2447                         }
2448                         #print "is_start<$is_start> is_end<$is_end> length<$length>\n";
2449                 }
2450
2451 # discourage the addition of CONFIG_EXPERIMENTAL in Kconfig.
2452                 if ($realfile =~ /Kconfig/ &&
2453                     $line =~ /.\s*depends on\s+.*\bEXPERIMENTAL\b/) {
2454                         WARN("CONFIG_EXPERIMENTAL",
2455                              "Use of CONFIG_EXPERIMENTAL is deprecated. For alternatives, see https://lkml.org/lkml/2012/10/23/580\n");
2456                 }
2457
2458 # discourage the use of boolean for type definition attributes of Kconfig options
2459                 if ($realfile =~ /Kconfig/ &&
2460                     $line =~ /^\+\s*\bboolean\b/) {
2461                         WARN("CONFIG_TYPE_BOOLEAN",
2462                              "Use of boolean is deprecated, please use bool instead.\n" . $herecurr);
2463                 }
2464
2465                 if (($realfile =~ /Makefile.*/ || $realfile =~ /Kbuild.*/) &&
2466                     ($line =~ /\+(EXTRA_[A-Z]+FLAGS).*/)) {
2467                         my $flag = $1;
2468                         my $replacement = {
2469                                 'EXTRA_AFLAGS' =>   'asflags-y',
2470                                 'EXTRA_CFLAGS' =>   'ccflags-y',
2471                                 'EXTRA_CPPFLAGS' => 'cppflags-y',
2472                                 'EXTRA_LDFLAGS' =>  'ldflags-y',
2473                         };
2474
2475                         WARN("DEPRECATED_VARIABLE",
2476                              "Use of $flag is deprecated, please use \`$replacement->{$flag} instead.\n" . $herecurr) if ($replacement->{$flag});
2477                 }
2478
2479 # check for DT compatible documentation
2480                 if (defined $root &&
2481                         (($realfile =~ /\.dtsi?$/ && $line =~ /^\+\s*compatible\s*=\s*\"/) ||
2482                          ($realfile =~ /\.[ch]$/ && $line =~ /^\+.*\.compatible\s*=\s*\"/))) {
2483
2484                         my @compats = $rawline =~ /\"([a-zA-Z0-9\-\,\.\+_]+)\"/g;
2485
2486                         my $dt_path = $root . "/Documentation/devicetree/bindings/";
2487                         my $vp_file = $dt_path . "vendor-prefixes.txt";
2488
2489                         foreach my $compat (@compats) {
2490                                 my $compat2 = $compat;
2491                                 $compat2 =~ s/\,[a-zA-Z0-9]*\-/\,<\.\*>\-/;
2492                                 my $compat3 = $compat;
2493                                 $compat3 =~ s/\,([a-z]*)[0-9]*\-/\,$1<\.\*>\-/;
2494                                 `grep -Erq "$compat|$compat2|$compat3" $dt_path`;
2495                                 if ( $? >> 8 ) {
2496                                         WARN("UNDOCUMENTED_DT_STRING",
2497                                              "DT compatible string \"$compat\" appears un-documented -- check $dt_path\n" . $herecurr);
2498                                 }
2499
2500                                 next if $compat !~ /^([a-zA-Z0-9\-]+)\,/;
2501                                 my $vendor = $1;
2502                                 `grep -Eq "^$vendor\\b" $vp_file`;
2503                                 if ( $? >> 8 ) {
2504                                         WARN("UNDOCUMENTED_DT_STRING",
2505                                              "DT compatible string vendor \"$vendor\" appears un-documented -- check $vp_file\n" . $herecurr);
2506                                 }
2507                         }
2508                 }
2509
2510 # check we are in a valid source file if not then ignore this hunk
2511                 next if ($realfile !~ /\.(h|c|s|S|pl|sh|dtsi|dts)$/);
2512
2513 #line length limit
2514                 if ($line =~ /^\+/ && $prevrawline !~ /\/\*\*/ &&
2515                     $rawline !~ /^.\s*\*\s*\@$Ident\s/ &&
2516                     !($line =~ /^\+\s*$logFunctions\s*\(\s*(?:(KERN_\S+\s*|[^"]*))?$String\s*(?:|,|\)\s*;)\s*$/ ||
2517                       $line =~ /^\+\s*$String\s*(?:\s*|,|\)\s*;)\s*$/ ||
2518                       $line =~ /^\+\s*#\s*define\s+\w+\s+$String$/) &&
2519                     $length > $max_line_length)
2520                 {
2521                         WARN("LONG_LINE",
2522                              "line over $max_line_length characters\n" . $herecurr);
2523                 }
2524
2525 # check for adding lines without a newline.
2526                 if ($line =~ /^\+/ && defined $lines[$linenr] && $lines[$linenr] =~ /^\\ No newline at end of file/) {
2527                         WARN("MISSING_EOF_NEWLINE",
2528                              "adding a line without newline at end of file\n" . $herecurr);
2529                 }
2530
2531 # Blackfin: use hi/lo macros
2532                 if ($realfile =~ m@arch/blackfin/.*\.S$@) {
2533                         if ($line =~ /\.[lL][[:space:]]*=.*&[[:space:]]*0x[fF][fF][fF][fF]/) {
2534                                 my $herevet = "$here\n" . cat_vet($line) . "\n";
2535                                 ERROR("LO_MACRO",
2536                                       "use the LO() macro, not (... & 0xFFFF)\n" . $herevet);
2537                         }
2538                         if ($line =~ /\.[hH][[:space:]]*=.*>>[[:space:]]*16/) {
2539                                 my $herevet = "$here\n" . cat_vet($line) . "\n";
2540                                 ERROR("HI_MACRO",
2541                                       "use the HI() macro, not (... >> 16)\n" . $herevet);
2542                         }
2543                 }
2544
2545 # check we are in a valid source file C or perl if not then ignore this hunk
2546                 next if ($realfile !~ /\.(h|c|pl|dtsi|dts)$/);
2547
2548 # at the beginning of a line any tabs must come first and anything
2549 # more than 8 must use tabs.
2550                 if ($rawline =~ /^\+\s* \t\s*\S/ ||
2551                     $rawline =~ /^\+\s*        \s*/) {
2552                         my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2553                         $rpt_cleaners = 1;
2554                         if (ERROR("CODE_INDENT",
2555                                   "code indent should use tabs where possible\n" . $herevet) &&
2556                             $fix) {
2557                                 $fixed[$fixlinenr] =~ s/^\+([ \t]+)/"\+" . tabify($1)/e;
2558                         }
2559                 }
2560
2561 # check for space before tabs.
2562                 if ($rawline =~ /^\+/ && $rawline =~ / \t/) {
2563                         my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2564                         if (WARN("SPACE_BEFORE_TAB",
2565                                 "please, no space before tabs\n" . $herevet) &&
2566                             $fix) {
2567                                 while ($fixed[$fixlinenr] =~
2568                                            s/(^\+.*) {8,8}\t/$1\t\t/) {}
2569                                 while ($fixed[$fixlinenr] =~
2570                                            s/(^\+.*) +\t/$1\t/) {}
2571                         }
2572                 }
2573
2574 # check for && or || at the start of a line
2575                 if ($rawline =~ /^\+\s*(&&|\|\|)/) {
2576                         CHK("LOGICAL_CONTINUATIONS",
2577                             "Logical continuations should be on the previous line\n" . $hereprev);
2578                 }
2579
2580 # check multi-line statement indentation matches previous line
2581                 if ($^V && $^V ge 5.10.0 &&
2582                     $prevline =~ /^\+([ \t]*)((?:$c90_Keywords(?:\s+if)\s*)|(?:$Declare\s*)?(?:$Ident|\(\s*\*\s*$Ident\s*\))\s*|$Ident\s*=\s*$Ident\s*)\(.*(\&\&|\|\||,)\s*$/) {
2583                         $prevline =~ /^\+(\t*)(.*)$/;
2584                         my $oldindent = $1;
2585                         my $rest = $2;
2586
2587                         my $pos = pos_last_openparen($rest);
2588                         if ($pos >= 0) {
2589                                 $line =~ /^(\+| )([ \t]*)/;
2590                                 my $newindent = $2;
2591
2592                                 my $goodtabindent = $oldindent .
2593                                         "\t" x ($pos / 8) .
2594                                         " "  x ($pos % 8);
2595                                 my $goodspaceindent = $oldindent . " "  x $pos;
2596
2597                                 if ($newindent ne $goodtabindent &&
2598                                     $newindent ne $goodspaceindent) {
2599
2600                                         if (CHK("PARENTHESIS_ALIGNMENT",
2601                                                 "Alignment should match open parenthesis\n" . $hereprev) &&
2602                                             $fix && $line =~ /^\+/) {
2603                                                 $fixed[$fixlinenr] =~
2604                                                     s/^\+[ \t]*/\+$goodtabindent/;
2605                                         }
2606                                 }
2607                         }
2608                 }
2609
2610 # check for space after cast like "(int) foo" or "(struct foo) bar"
2611 # avoid checking a few false positives:
2612 #   "sizeof(<type>)" or "__alignof__(<type>)"
2613 #   function pointer declarations like "(*foo)(int) = bar;"
2614 #   structure definitions like "(struct foo) { 0 };"
2615 #   multiline macros that define functions
2616 #   known attributes or the __attribute__ keyword
2617                 if ($line =~ /^\+(.*)\(\s*$Type\s*\)([ \t]++)((?![={]|\\$|$Attribute|__attribute__))/ &&
2618                     (!defined($1) || $1 !~ /\b(?:sizeof|__alignof__)\s*$/)) {
2619                         if (CHK("SPACING",
2620                                 "No space is necessary after a cast\n" . $herecurr) &&
2621                             $fix) {
2622                                 $fixed[$fixlinenr] =~
2623                                     s/(\(\s*$Type\s*\))[ \t]+/$1/;
2624                         }
2625                 }
2626
2627                 if ($realfile =~ m@^(drivers/net/|net/)@ &&
2628                     $prevrawline =~ /^\+[ \t]*\/\*[ \t]*$/ &&
2629                     $rawline =~ /^\+[ \t]*\*/ &&
2630                     $realline > 2) {
2631                         WARN("NETWORKING_BLOCK_COMMENT_STYLE",
2632                              "networking block comments don't use an empty /* line, use /* Comment...\n" . $hereprev);
2633                 }
2634
2635                 if ($realfile =~ m@^(drivers/net/|net/)@ &&
2636                     $prevrawline =~ /^\+[ \t]*\/\*/ &&          #starting /*
2637                     $prevrawline !~ /\*\/[ \t]*$/ &&            #no trailing */
2638                     $rawline =~ /^\+/ &&                        #line is new
2639                     $rawline !~ /^\+[ \t]*\*/) {                #no leading *
2640                         WARN("NETWORKING_BLOCK_COMMENT_STYLE",
2641                              "networking block comments start with * on subsequent lines\n" . $hereprev);
2642                 }
2643
2644                 if ($realfile =~ m@^(drivers/net/|net/)@ &&
2645                     $rawline !~ m@^\+[ \t]*\*/[ \t]*$@ &&       #trailing */
2646                     $rawline !~ m@^\+.*/\*.*\*/[ \t]*$@ &&      #inline /*...*/
2647                     $rawline !~ m@^\+.*\*{2,}/[ \t]*$@ &&       #trailing **/
2648                     $rawline =~ m@^\+[ \t]*.+\*\/[ \t]*$@) {    #non blank */
2649                         WARN("NETWORKING_BLOCK_COMMENT_STYLE",
2650                              "networking block comments put the trailing */ on a separate line\n" . $herecurr);
2651                 }
2652
2653 # check for missing blank lines after struct/union declarations
2654 # with exceptions for various attributes and macros
2655                 if ($prevline =~ /^[\+ ]};?\s*$/ &&
2656                     $line =~ /^\+/ &&
2657                     !($line =~ /^\+\s*$/ ||
2658                       $line =~ /^\+\s*EXPORT_SYMBOL/ ||
2659                       $line =~ /^\+\s*MODULE_/i ||
2660                       $line =~ /^\+\s*\#\s*(?:end|elif|else)/ ||
2661                       $line =~ /^\+[a-z_]*init/ ||
2662                       $line =~ /^\+\s*(?:static\s+)?[A-Z_]*ATTR/ ||
2663                       $line =~ /^\+\s*DECLARE/ ||
2664                       $line =~ /^\+\s*__setup/)) {
2665                         if (CHK("LINE_SPACING",
2666                                 "Please use a blank line after function/struct/union/enum declarations\n" . $hereprev) &&
2667                             $fix) {
2668                                 fix_insert_line($fixlinenr, "\+");
2669                         }
2670                 }
2671
2672 # check for multiple consecutive blank lines
2673                 if ($prevline =~ /^[\+ ]\s*$/ &&
2674                     $line =~ /^\+\s*$/ &&
2675                     $last_blank_line != ($linenr - 1)) {
2676                         if (CHK("LINE_SPACING",
2677                                 "Please don't use multiple blank lines\n" . $hereprev) &&
2678                             $fix) {
2679                                 fix_delete_line($fixlinenr, $rawline);
2680                         }
2681
2682                         $last_blank_line = $linenr;
2683                 }
2684
2685 # check for missing blank lines after declarations
2686                 if ($sline =~ /^\+\s+\S/ &&                     #Not at char 1
2687                         # actual declarations
2688                     ($prevline =~ /^\+\s+$Declare\s*$Ident\s*[=,;:\[]/ ||
2689                         # function pointer declarations
2690                      $prevline =~ /^\+\s+$Declare\s*\(\s*\*\s*$Ident\s*\)\s*[=,;:\[\(]/ ||
2691                         # foo bar; where foo is some local typedef or #define
2692                      $prevline =~ /^\+\s+$Ident(?:\s+|\s*\*\s*)$Ident\s*[=,;\[]/ ||
2693                         # known declaration macros
2694                      $prevline =~ /^\+\s+$declaration_macros/) &&
2695                         # for "else if" which can look like "$Ident $Ident"
2696                     !($prevline =~ /^\+\s+$c90_Keywords\b/ ||
2697                         # other possible extensions of declaration lines
2698                       $prevline =~ /(?:$Compare|$Assignment|$Operators)\s*$/ ||
2699                         # not starting a section or a macro "\" extended line
2700                       $prevline =~ /(?:\{\s*|\\)$/) &&
2701                         # looks like a declaration
2702                     !($sline =~ /^\+\s+$Declare\s*$Ident\s*[=,;:\[]/ ||
2703                         # function pointer declarations
2704                       $sline =~ /^\+\s+$Declare\s*\(\s*\*\s*$Ident\s*\)\s*[=,;:\[\(]/ ||
2705                         # foo bar; where foo is some local typedef or #define
2706                       $sline =~ /^\+\s+$Ident(?:\s+|\s*\*\s*)$Ident\s*[=,;\[]/ ||
2707                         # known declaration macros
2708                       $sline =~ /^\+\s+$declaration_macros/ ||
2709                         # start of struct or union or enum
2710                       $sline =~ /^\+\s+(?:union|struct|enum|typedef)\b/ ||
2711                         # start or end of block or continuation of declaration
2712                       $sline =~ /^\+\s+(?:$|[\{\}\.\#\"\?\:\(\[])/ ||
2713                         # bitfield continuation
2714                       $sline =~ /^\+\s+$Ident\s*:\s*\d+\s*[,;]/ ||
2715                         # other possible extensions of declaration lines
2716                       $sline =~ /^\+\s+\(?\s*(?:$Compare|$Assignment|$Operators)/) &&
2717                         # indentation of previous and current line are the same
2718                     (($prevline =~ /\+(\s+)\S/) && $sline =~ /^\+$1\S/)) {
2719                         if (WARN("LINE_SPACING",
2720                                  "Missing a blank line after declarations\n" . $hereprev) &&
2721                             $fix) {
2722                                 fix_insert_line($fixlinenr, "\+");
2723                         }
2724                 }
2725
2726 # check for spaces at the beginning of a line.
2727 # Exceptions:
2728 #  1) within comments
2729 #  2) indented preprocessor commands
2730 #  3) hanging labels
2731                 if ($rawline =~ /^\+ / && $line !~ /^\+ *(?:$;|#|$Ident:)/)  {
2732                         my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2733                         if (WARN("LEADING_SPACE",
2734                                  "please, no spaces at the start of a line\n" . $herevet) &&
2735                             $fix) {
2736                                 $fixed[$fixlinenr] =~ s/^\+([ \t]+)/"\+" . tabify($1)/e;
2737                         }
2738                 }
2739
2740 # check we are in a valid C source file if not then ignore this hunk
2741                 next if ($realfile !~ /\.(h|c)$/);
2742
2743 # check indentation of any line with a bare else
2744 # (but not if it is a multiple line "if (foo) return bar; else return baz;")
2745 # if the previous line is a break or return and is indented 1 tab more...
2746                 if ($sline =~ /^\+([\t]+)(?:}[ \t]*)?else(?:[ \t]*{)?\s*$/) {
2747                         my $tabs = length($1) + 1;
2748                         if ($prevline =~ /^\+\t{$tabs,$tabs}break\b/ ||
2749                             ($prevline =~ /^\+\t{$tabs,$tabs}return\b/ &&
2750                              defined $lines[$linenr] &&
2751                              $lines[$linenr] !~ /^[ \+]\t{$tabs,$tabs}return/)) {
2752                                 WARN("UNNECESSARY_ELSE",
2753                                      "else is not generally useful after a break or return\n" . $hereprev);
2754                         }
2755                 }
2756
2757 # check indentation of a line with a break;
2758 # if the previous line is a goto or return and is indented the same # of tabs
2759                 if ($sline =~ /^\+([\t]+)break\s*;\s*$/) {
2760                         my $tabs = $1;
2761                         if ($prevline =~ /^\+$tabs(?:goto|return)\b/) {
2762                                 WARN("UNNECESSARY_BREAK",
2763                                      "break is not useful after a goto or return\n" . $hereprev);
2764                         }
2765                 }
2766
2767 # discourage the addition of CONFIG_EXPERIMENTAL in #if(def).
2768                 if ($line =~ /^\+\s*\#\s*if.*\bCONFIG_EXPERIMENTAL\b/) {
2769                         WARN("CONFIG_EXPERIMENTAL",
2770                              "Use of CONFIG_EXPERIMENTAL is deprecated. For alternatives, see https://lkml.org/lkml/2012/10/23/580\n");
2771                 }
2772
2773 # check for RCS/CVS revision markers
2774                 if ($rawline =~ /^\+.*\$(Revision|Log|Id)(?:\$|)/) {
2775                         WARN("CVS_KEYWORD",
2776                              "CVS style keyword markers, these will _not_ be updated\n". $herecurr);
2777                 }
2778
2779 # Blackfin: don't use __builtin_bfin_[cs]sync
2780                 if ($line =~ /__builtin_bfin_csync/) {
2781                         my $herevet = "$here\n" . cat_vet($line) . "\n";
2782                         ERROR("CSYNC",
2783                               "use the CSYNC() macro in asm/blackfin.h\n" . $herevet);
2784                 }
2785                 if ($line =~ /__builtin_bfin_ssync/) {
2786                         my $herevet = "$here\n" . cat_vet($line) . "\n";
2787                         ERROR("SSYNC",
2788                               "use the SSYNC() macro in asm/blackfin.h\n" . $herevet);
2789                 }
2790
2791 # check for old HOTPLUG __dev<foo> section markings
2792                 if ($line =~ /\b(__dev(init|exit)(data|const|))\b/) {
2793                         WARN("HOTPLUG_SECTION",
2794                              "Using $1 is unnecessary\n" . $herecurr);
2795                 }
2796
2797 # Check for potential 'bare' types
2798                 my ($stat, $cond, $line_nr_next, $remain_next, $off_next,
2799                     $realline_next);
2800 #print "LINE<$line>\n";
2801                 if ($linenr >= $suppress_statement &&
2802                     $realcnt && $sline =~ /.\s*\S/) {
2803                         ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
2804                                 ctx_statement_block($linenr, $realcnt, 0);
2805                         $stat =~ s/\n./\n /g;
2806                         $cond =~ s/\n./\n /g;
2807
2808 #print "linenr<$linenr> <$stat>\n";
2809                         # If this statement has no statement boundaries within
2810                         # it there is no point in retrying a statement scan
2811                         # until we hit end of it.
2812                         my $frag = $stat; $frag =~ s/;+\s*$//;
2813                         if ($frag !~ /(?:{|;)/) {
2814 #print "skip<$line_nr_next>\n";
2815                                 $suppress_statement = $line_nr_next;
2816                         }
2817
2818                         # Find the real next line.
2819                         $realline_next = $line_nr_next;
2820                         if (defined $realline_next &&
2821                             (!defined $lines[$realline_next - 1] ||
2822                              substr($lines[$realline_next - 1], $off_next) =~ /^\s*$/)) {
2823                                 $realline_next++;
2824                         }
2825
2826                         my $s = $stat;
2827                         $s =~ s/{.*$//s;
2828
2829                         # Ignore goto labels.
2830                         if ($s =~ /$Ident:\*$/s) {
2831
2832                         # Ignore functions being called
2833                         } elsif ($s =~ /^.\s*$Ident\s*\(/s) {
2834
2835                         } elsif ($s =~ /^.\s*else\b/s) {
2836
2837                         # declarations always start with types
2838                         } 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) {
2839                                 my $type = $1;
2840                                 $type =~ s/\s+/ /g;
2841                                 possible($type, "A:" . $s);
2842
2843                         # definitions in global scope can only start with types
2844                         } elsif ($s =~ /^.(?:$Storage\s+)?(?:$Inline\s+)?(?:const\s+)?($Ident)\b\s*(?!:)/s) {
2845                                 possible($1, "B:" . $s);
2846                         }
2847
2848                         # any (foo ... *) is a pointer cast, and foo is a type
2849                         while ($s =~ /\(($Ident)(?:\s+$Sparse)*[\s\*]+\s*\)/sg) {
2850                                 possible($1, "C:" . $s);
2851                         }
2852
2853                         # Check for any sort of function declaration.
2854                         # int foo(something bar, other baz);
2855                         # void (*store_gdt)(x86_descr_ptr *);
2856                         if ($prev_values eq 'E' && $s =~ /^(.(?:typedef\s*)?(?:(?:$Storage|$Inline)\s*)*\s*$Type\s*(?:\b$Ident|\(\*\s*$Ident\))\s*)\(/s) {
2857                                 my ($name_len) = length($1);
2858
2859                                 my $ctx = $s;
2860                                 substr($ctx, 0, $name_len + 1, '');
2861                                 $ctx =~ s/\)[^\)]*$//;
2862
2863                                 for my $arg (split(/\s*,\s*/, $ctx)) {
2864                                         if ($arg =~ /^(?:const\s+)?($Ident)(?:\s+$Sparse)*\s*\**\s*(:?\b$Ident)?$/s || $arg =~ /^($Ident)$/s) {
2865
2866                                                 possible($1, "D:" . $s);
2867                                         }
2868                                 }
2869                         }
2870
2871                 }
2872
2873 #
2874 # Checks which may be anchored in the context.
2875 #
2876
2877 # Check for switch () and associated case and default
2878 # statements should be at the same indent.
2879                 if ($line=~/\bswitch\s*\(.*\)/) {
2880                         my $err = '';
2881                         my $sep = '';
2882                         my @ctx = ctx_block_outer($linenr, $realcnt);
2883                         shift(@ctx);
2884                         for my $ctx (@ctx) {
2885                                 my ($clen, $cindent) = line_stats($ctx);
2886                                 if ($ctx =~ /^\+\s*(case\s+|default:)/ &&
2887                                                         $indent != $cindent) {
2888                                         $err .= "$sep$ctx\n";
2889                                         $sep = '';
2890                                 } else {
2891                                         $sep = "[...]\n";
2892                                 }
2893                         }
2894                         if ($err ne '') {
2895                                 ERROR("SWITCH_CASE_INDENT_LEVEL",
2896                                       "switch and case should be at the same indent\n$hereline$err");
2897                         }
2898                 }
2899
2900 # if/while/etc brace do not go on next line, unless defining a do while loop,
2901 # or if that brace on the next line is for something else
2902                 if ($line =~ /(.*)\b((?:if|while|for|switch|(?:[a-z_]+|)for_each[a-z_]+)\s*\(|do\b|else\b)/ && $line !~ /^.\s*\#/) {
2903                         my $pre_ctx = "$1$2";
2904
2905                         my ($level, @ctx) = ctx_statement_level($linenr, $realcnt, 0);
2906
2907                         if ($line =~ /^\+\t{6,}/) {
2908                                 WARN("DEEP_INDENTATION",
2909                                      "Too many leading tabs - consider code refactoring\n" . $herecurr);
2910                         }
2911
2912                         my $ctx_cnt = $realcnt - $#ctx - 1;
2913                         my $ctx = join("\n", @ctx);
2914
2915                         my $ctx_ln = $linenr;
2916                         my $ctx_skip = $realcnt;
2917
2918                         while ($ctx_skip > $ctx_cnt || ($ctx_skip == $ctx_cnt &&
2919                                         defined $lines[$ctx_ln - 1] &&
2920                                         $lines[$ctx_ln - 1] =~ /^-/)) {
2921                                 ##print "SKIP<$ctx_skip> CNT<$ctx_cnt>\n";
2922                                 $ctx_skip-- if (!defined $lines[$ctx_ln - 1] || $lines[$ctx_ln - 1] !~ /^-/);
2923                                 $ctx_ln++;
2924                         }
2925
2926                         #print "realcnt<$realcnt> ctx_cnt<$ctx_cnt>\n";
2927                         #print "pre<$pre_ctx>\nline<$line>\nctx<$ctx>\nnext<$lines[$ctx_ln - 1]>\n";
2928
2929                         if ($ctx !~ /{\s*/ && defined($lines[$ctx_ln - 1]) && $lines[$ctx_ln - 1] =~ /^\+\s*{/) {
2930                                 ERROR("OPEN_BRACE",
2931                                       "that open brace { should be on the previous line\n" .
2932                                         "$here\n$ctx\n$rawlines[$ctx_ln - 1]\n");
2933                         }
2934                         if ($level == 0 && $pre_ctx !~ /}\s*while\s*\($/ &&
2935                             $ctx =~ /\)\s*\;\s*$/ &&
2936                             defined $lines[$ctx_ln - 1])
2937                         {
2938                                 my ($nlength, $nindent) = line_stats($lines[$ctx_ln - 1]);
2939                                 if ($nindent > $indent) {
2940                                         WARN("TRAILING_SEMICOLON",
2941                                              "trailing semicolon indicates no statements, indent implies otherwise\n" .
2942                                                 "$here\n$ctx\n$rawlines[$ctx_ln - 1]\n");
2943                                 }
2944                         }
2945                 }
2946
2947 # Check relative indent for conditionals and blocks.
2948                 if ($line =~ /\b(?:(?:if|while|for|(?:[a-z_]+|)for_each[a-z_]+)\s*\(|do\b)/ && $line !~ /^.\s*#/ && $line !~ /\}\s*while\s*/) {
2949                         ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
2950                                 ctx_statement_block($linenr, $realcnt, 0)
2951                                         if (!defined $stat);
2952                         my ($s, $c) = ($stat, $cond);
2953
2954                         substr($s, 0, length($c), '');
2955
2956                         # Make sure we remove the line prefixes as we have
2957                         # none on the first line, and are going to readd them
2958                         # where necessary.
2959                         $s =~ s/\n./\n/gs;
2960
2961                         # Find out how long the conditional actually is.
2962                         my @newlines = ($c =~ /\n/gs);
2963                         my $cond_lines = 1 + $#newlines;
2964
2965                         # We want to check the first line inside the block
2966                         # starting at the end of the conditional, so remove:
2967                         #  1) any blank line termination
2968                         #  2) any opening brace { on end of the line
2969                         #  3) any do (...) {
2970                         my $continuation = 0;
2971                         my $check = 0;
2972                         $s =~ s/^.*\bdo\b//;
2973                         $s =~ s/^\s*{//;
2974                         if ($s =~ s/^\s*\\//) {
2975                                 $continuation = 1;
2976                         }
2977                         if ($s =~ s/^\s*?\n//) {
2978                                 $check = 1;
2979                                 $cond_lines++;
2980                         }
2981
2982                         # Also ignore a loop construct at the end of a
2983                         # preprocessor statement.
2984                         if (($prevline =~ /^.\s*#\s*define\s/ ||
2985                             $prevline =~ /\\\s*$/) && $continuation == 0) {
2986                                 $check = 0;
2987                         }
2988
2989                         my $cond_ptr = -1;
2990                         $continuation = 0;
2991                         while ($cond_ptr != $cond_lines) {
2992                                 $cond_ptr = $cond_lines;
2993
2994                                 # If we see an #else/#elif then the code
2995                                 # is not linear.
2996                                 if ($s =~ /^\s*\#\s*(?:else|elif)/) {
2997                                         $check = 0;
2998                                 }
2999
3000                                 # Ignore:
3001                                 #  1) blank lines, they should be at 0,
3002                                 #  2) preprocessor lines, and
3003                                 #  3) labels.
3004                                 if ($continuation ||
3005                                     $s =~ /^\s*?\n/ ||
3006                                     $s =~ /^\s*#\s*?/ ||
3007                                     $s =~ /^\s*$Ident\s*:/) {
3008                                         $continuation = ($s =~ /^.*?\\\n/) ? 1 : 0;
3009                                         if ($s =~ s/^.*?\n//) {
3010                                                 $cond_lines++;
3011                                         }
3012                                 }
3013                         }
3014
3015                         my (undef, $sindent) = line_stats("+" . $s);
3016                         my $stat_real = raw_line($linenr, $cond_lines);
3017
3018                         # Check if either of these lines are modified, else
3019                         # this is not this patch's fault.
3020                         if (!defined($stat_real) ||
3021                             $stat !~ /^\+/ && $stat_real !~ /^\+/) {
3022                                 $check = 0;
3023                         }
3024                         if (defined($stat_real) && $cond_lines > 1) {
3025                                 $stat_real = "[...]\n$stat_real";
3026                         }
3027
3028                         #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";
3029
3030                         if ($check && (($sindent % 8) != 0 ||
3031                             ($sindent <= $indent && $s ne ''))) {
3032                                 WARN("SUSPECT_CODE_INDENT",
3033                                      "suspect code indent for conditional statements ($indent, $sindent)\n" . $herecurr . "$stat_real\n");
3034                         }
3035                 }
3036
3037                 # Track the 'values' across context and added lines.
3038                 my $opline = $line; $opline =~ s/^./ /;
3039                 my ($curr_values, $curr_vars) =
3040                                 annotate_values($opline . "\n", $prev_values);
3041                 $curr_values = $prev_values . $curr_values;
3042                 if ($dbg_values) {
3043                         my $outline = $opline; $outline =~ s/\t/ /g;
3044                         print "$linenr > .$outline\n";
3045                         print "$linenr > $curr_values\n";
3046                         print "$linenr >  $curr_vars\n";
3047                 }
3048                 $prev_values = substr($curr_values, -1);
3049
3050 #ignore lines not being added
3051                 next if ($line =~ /^[^\+]/);
3052
3053 # TEST: allow direct testing of the type matcher.
3054                 if ($dbg_type) {
3055                         if ($line =~ /^.\s*$Declare\s*$/) {
3056                                 ERROR("TEST_TYPE",
3057                                       "TEST: is type\n" . $herecurr);
3058                         } elsif ($dbg_type > 1 && $line =~ /^.+($Declare)/) {
3059                                 ERROR("TEST_NOT_TYPE",
3060                                       "TEST: is not type ($1 is)\n". $herecurr);
3061                         }
3062                         next;
3063                 }
3064 # TEST: allow direct testing of the attribute matcher.
3065                 if ($dbg_attr) {
3066                         if ($line =~ /^.\s*$Modifier\s*$/) {
3067                                 ERROR("TEST_ATTR",
3068                                       "TEST: is attr\n" . $herecurr);
3069                         } elsif ($dbg_attr > 1 && $line =~ /^.+($Modifier)/) {
3070                                 ERROR("TEST_NOT_ATTR",
3071                                       "TEST: is not attr ($1 is)\n". $herecurr);
3072                         }
3073                         next;
3074                 }
3075
3076 # check for initialisation to aggregates open brace on the next line
3077                 if ($line =~ /^.\s*{/ &&
3078                     $prevline =~ /(?:^|[^=])=\s*$/) {
3079                         if (ERROR("OPEN_BRACE",
3080                                   "that open brace { should be on the previous line\n" . $hereprev) &&
3081                             $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
3082                                 fix_delete_line($fixlinenr - 1, $prevrawline);
3083                                 fix_delete_line($fixlinenr, $rawline);
3084                                 my $fixedline = $prevrawline;
3085                                 $fixedline =~ s/\s*=\s*$/ = {/;
3086                                 fix_insert_line($fixlinenr, $fixedline);
3087                                 $fixedline = $line;
3088                                 $fixedline =~ s/^(.\s*){\s*/$1/;
3089                                 fix_insert_line($fixlinenr, $fixedline);
3090                         }
3091                 }
3092
3093 #
3094 # Checks which are anchored on the added line.
3095 #
3096
3097 # check for malformed paths in #include statements (uses RAW line)
3098                 if ($rawline =~ m{^.\s*\#\s*include\s+[<"](.*)[">]}) {
3099                         my $path = $1;
3100                         if ($path =~ m{//}) {
3101                                 ERROR("MALFORMED_INCLUDE",
3102                                       "malformed #include filename\n" . $herecurr);
3103                         }
3104                         if ($path =~ "^uapi/" && $realfile =~ m@\binclude/uapi/@) {
3105                                 ERROR("UAPI_INCLUDE",
3106                                       "No #include in ...include/uapi/... should use a uapi/ path prefix\n" . $herecurr);
3107                         }
3108                 }
3109
3110 # no C99 // comments
3111                 if ($line =~ m{//}) {
3112                         if (ERROR("C99_COMMENTS",
3113                                   "do not use C99 // comments\n" . $herecurr) &&
3114                             $fix) {
3115                                 my $line = $fixed[$fixlinenr];
3116                                 if ($line =~ /\/\/(.*)$/) {
3117                                         my $comment = trim($1);
3118                                         $fixed[$fixlinenr] =~ s@\/\/(.*)$@/\* $comment \*/@;
3119                                 }
3120                         }
3121                 }
3122                 # Remove C99 comments.
3123                 $line =~ s@//.*@@;
3124                 $opline =~ s@//.*@@;
3125
3126 # EXPORT_SYMBOL should immediately follow the thing it is exporting, consider
3127 # the whole statement.
3128 #print "APW <$lines[$realline_next - 1]>\n";
3129                 if (defined $realline_next &&
3130                     exists $lines[$realline_next - 1] &&
3131                     !defined $suppress_export{$realline_next} &&
3132                     ($lines[$realline_next - 1] =~ /EXPORT_SYMBOL.*\((.*)\)/ ||
3133                      $lines[$realline_next - 1] =~ /EXPORT_UNUSED_SYMBOL.*\((.*)\)/)) {
3134                         # Handle definitions which produce identifiers with
3135                         # a prefix:
3136                         #   XXX(foo);
3137                         #   EXPORT_SYMBOL(something_foo);
3138                         my $name = $1;
3139                         if ($stat =~ /^(?:.\s*}\s*\n)?.([A-Z_]+)\s*\(\s*($Ident)/ &&
3140                             $name =~ /^${Ident}_$2/) {
3141 #print "FOO C name<$name>\n";
3142                                 $suppress_export{$realline_next} = 1;
3143
3144                         } elsif ($stat !~ /(?:
3145                                 \n.}\s*$|
3146                                 ^.DEFINE_$Ident\(\Q$name\E\)|
3147                                 ^.DECLARE_$Ident\(\Q$name\E\)|
3148                                 ^.LIST_HEAD\(\Q$name\E\)|
3149                                 ^.(?:$Storage\s+)?$Type\s*\(\s*\*\s*\Q$name\E\s*\)\s*\(|
3150                                 \b\Q$name\E(?:\s+$Attribute)*\s*(?:;|=|\[|\()
3151                             )/x) {
3152 #print "FOO A<$lines[$realline_next - 1]> stat<$stat> name<$name>\n";
3153                                 $suppress_export{$realline_next} = 2;
3154                         } else {
3155                                 $suppress_export{$realline_next} = 1;
3156                         }
3157                 }
3158                 if (!defined $suppress_export{$linenr} &&
3159                     $prevline =~ /^.\s*$/ &&
3160                     ($line =~ /EXPORT_SYMBOL.*\((.*)\)/ ||
3161                      $line =~ /EXPORT_UNUSED_SYMBOL.*\((.*)\)/)) {
3162 #print "FOO B <$lines[$linenr - 1]>\n";
3163                         $suppress_export{$linenr} = 2;
3164                 }
3165                 if (defined $suppress_export{$linenr} &&
3166                     $suppress_export{$linenr} == 2) {
3167                         WARN("EXPORT_SYMBOL",
3168                              "EXPORT_SYMBOL(foo); should immediately follow its function/variable\n" . $herecurr);
3169                 }
3170
3171 # check for global initialisers.
3172                 if ($line =~ /^\+(\s*$Type\s*$Ident\s*(?:\s+$Modifier))*\s*=\s*(0|NULL|false)\s*;/) {
3173                         if (ERROR("GLOBAL_INITIALISERS",
3174                                   "do not initialise globals to 0 or NULL\n" .
3175                                       $herecurr) &&
3176                             $fix) {
3177                                 $fixed[$fixlinenr] =~ s/($Type\s*$Ident\s*(?:\s+$Modifier))*\s*=\s*(0|NULL|false)\s*;/$1;/;
3178                         }
3179                 }
3180 # check for static initialisers.
3181                 if ($line =~ /^\+.*\bstatic\s.*=\s*(0|NULL|false)\s*;/) {
3182                         if (ERROR("INITIALISED_STATIC",
3183                                   "do not initialise statics to 0 or NULL\n" .
3184                                       $herecurr) &&
3185                             $fix) {
3186                                 $fixed[$fixlinenr] =~ s/(\bstatic\s.*?)\s*=\s*(0|NULL|false)\s*;/$1;/;
3187                         }
3188                 }
3189
3190 # check for misordered declarations of char/short/int/long with signed/unsigned
3191                 while ($sline =~ m{(\b$TypeMisordered\b)}g) {
3192                         my $tmp = trim($1);
3193                         WARN("MISORDERED_TYPE",
3194                              "type '$tmp' should be specified in [[un]signed] [short|int|long|long long] order\n" . $herecurr);
3195                 }
3196
3197 # check for static const char * arrays.
3198                 if ($line =~ /\bstatic\s+const\s+char\s*\*\s*(\w+)\s*\[\s*\]\s*=\s*/) {
3199                         WARN("STATIC_CONST_CHAR_ARRAY",
3200                              "static const char * array should probably be static const char * const\n" .
3201                                 $herecurr);
3202                }
3203
3204 # check for static char foo[] = "bar" declarations.
3205                 if ($line =~ /\bstatic\s+char\s+(\w+)\s*\[\s*\]\s*=\s*"/) {
3206                         WARN("STATIC_CONST_CHAR_ARRAY",
3207                              "static char array declaration should probably be static const char\n" .
3208                                 $herecurr);
3209                }
3210
3211 # check for const <foo> const where <foo> is not a pointer or array type
3212                 if ($sline =~ /\bconst\s+($BasicType)\s+const\b/) {
3213                         my $found = $1;
3214                         if ($sline =~ /\bconst\s+\Q$found\E\s+const\b\s*\*/) {
3215                                 WARN("CONST_CONST",
3216                                      "'const $found const *' should probably be 'const $found * const'\n" . $herecurr);
3217                         } elsif ($sline !~ /\bconst\s+\Q$found\E\s+const\s+\w+\s*\[/) {
3218                                 WARN("CONST_CONST",
3219                                      "'const $found const' should probably be 'const $found'\n" . $herecurr);
3220                         }
3221                 }
3222
3223 # check for non-global char *foo[] = {"bar", ...} declarations.
3224                 if ($line =~ /^.\s+(?:static\s+|const\s+)?char\s+\*\s*\w+\s*\[\s*\]\s*=\s*\{/) {
3225                         WARN("STATIC_CONST_CHAR_ARRAY",
3226                              "char * array declaration might be better as static const\n" .
3227                                 $herecurr);
3228                }
3229
3230 # check for sizeof(foo)/sizeof(foo[0]) that could be ARRAY_SIZE(foo)
3231                 if ($line =~ m@\bsizeof\s*\(\s*($Lval)\s*\)@) {
3232                         my $array = $1;
3233                         if ($line =~ m@\b(sizeof\s*\(\s*\Q$array\E\s*\)\s*/\s*sizeof\s*\(\s*\Q$array\E\s*\[\s*0\s*\]\s*\))@) {
3234                                 my $array_div = $1;
3235                                 if (WARN("ARRAY_SIZE",
3236                                          "Prefer ARRAY_SIZE($array)\n" . $herecurr) &&
3237                                     $fix) {
3238                                         $fixed[$fixlinenr] =~ s/\Q$array_div\E/ARRAY_SIZE($array)/;
3239                                 }
3240                         }
3241                 }
3242
3243 # check for function declarations without arguments like "int foo()"
3244                 if ($line =~ /(\b$Type\s+$Ident)\s*\(\s*\)/) {
3245                         if (ERROR("FUNCTION_WITHOUT_ARGS",
3246                                   "Bad function definition - $1() should probably be $1(void)\n" . $herecurr) &&
3247                             $fix) {
3248                                 $fixed[$fixlinenr] =~ s/(\b($Type)\s+($Ident))\s*\(\s*\)/$2 $3(void)/;
3249                         }
3250                 }
3251
3252 # check for uses of DEFINE_PCI_DEVICE_TABLE
3253                 if ($line =~ /\bDEFINE_PCI_DEVICE_TABLE\s*\(\s*(\w+)\s*\)\s*=/) {
3254                         if (WARN("DEFINE_PCI_DEVICE_TABLE",
3255                                  "Prefer struct pci_device_id over deprecated DEFINE_PCI_DEVICE_TABLE\n" . $herecurr) &&
3256                             $fix) {
3257                                 $fixed[$fixlinenr] =~ s/\b(?:static\s+|)DEFINE_PCI_DEVICE_TABLE\s*\(\s*(\w+)\s*\)\s*=\s*/static const struct pci_device_id $1\[\] = /;
3258                         }
3259                 }
3260
3261 # check for new typedefs, only function parameters and sparse annotations
3262 # make sense.
3263                 if ($line =~ /\btypedef\s/ &&
3264                     $line !~ /\btypedef\s+$Type\s*\(\s*\*?$Ident\s*\)\s*\(/ &&
3265                     $line !~ /\btypedef\s+$Type\s+$Ident\s*\(/ &&
3266                     $line !~ /\b$typeTypedefs\b/ &&
3267                     $line !~ /\b$typeOtherOSTypedefs\b/ &&
3268                     $line !~ /\b__bitwise(?:__|)\b/) {
3269                         WARN("NEW_TYPEDEFS",
3270                              "do not add new typedefs\n" . $herecurr);
3271                 }
3272
3273 # * goes on variable not on type
3274                 # (char*[ const])
3275                 while ($line =~ m{(\($NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)\))}g) {
3276                         #print "AA<$1>\n";
3277                         my ($ident, $from, $to) = ($1, $2, $2);
3278
3279                         # Should start with a space.
3280                         $to =~ s/^(\S)/ $1/;
3281                         # Should not end with a space.
3282                         $to =~ s/\s+$//;
3283                         # '*'s should not have spaces between.
3284                         while ($to =~ s/\*\s+\*/\*\*/) {
3285                         }
3286
3287 ##                      print "1: from<$from> to<$to> ident<$ident>\n";
3288                         if ($from ne $to) {
3289                                 if (ERROR("POINTER_LOCATION",
3290                                           "\"(foo$from)\" should be \"(foo$to)\"\n" .  $herecurr) &&
3291                                     $fix) {
3292                                         my $sub_from = $ident;
3293                                         my $sub_to = $ident;
3294                                         $sub_to =~ s/\Q$from\E/$to/;
3295                                         $fixed[$fixlinenr] =~
3296                                             s@\Q$sub_from\E@$sub_to@;
3297                                 }
3298                         }
3299                 }
3300                 while ($line =~ m{(\b$NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)($Ident))}g) {
3301                         #print "BB<$1>\n";
3302                         my ($match, $from, $to, $ident) = ($1, $2, $2, $3);
3303
3304                         # Should start with a space.
3305                         $to =~ s/^(\S)/ $1/;
3306                         # Should not end with a space.
3307                         $to =~ s/\s+$//;
3308                         # '*'s should not have spaces between.
3309                         while ($to =~ s/\*\s+\*/\*\*/) {
3310                         }
3311                         # Modifiers should have spaces.
3312                         $to =~ s/(\b$Modifier$)/$1 /;
3313
3314 ##                      print "2: from<$from> to<$to> ident<$ident>\n";
3315                         if ($from ne $to && $ident !~ /^$Modifier$/) {
3316                                 if (ERROR("POINTER_LOCATION",
3317                                           "\"foo${from}bar\" should be \"foo${to}bar\"\n" .  $herecurr) &&
3318                                     $fix) {
3319
3320                                         my $sub_from = $match;
3321                                         my $sub_to = $match;
3322                                         $sub_to =~ s/\Q$from\E/$to/;
3323                                         $fixed[$fixlinenr] =~
3324                                             s@\Q$sub_from\E@$sub_to@;
3325                                 }
3326                         }
3327                 }
3328
3329 # # no BUG() or BUG_ON()
3330 #               if ($line =~ /\b(BUG|BUG_ON)\b/) {
3331 #                       print "Try to use WARN_ON & Recovery code rather than BUG() or BUG_ON()\n";
3332 #                       print "$herecurr";
3333 #                       $clean = 0;
3334 #               }
3335
3336                 if ($line =~ /\bLINUX_VERSION_CODE\b/) {
3337                         WARN("LINUX_VERSION_CODE",
3338                              "LINUX_VERSION_CODE should be avoided, code should be for the version to which it is merged\n" . $herecurr);
3339                 }
3340
3341 # check for uses of printk_ratelimit
3342                 if ($line =~ /\bprintk_ratelimit\s*\(/) {
3343                         WARN("PRINTK_RATELIMITED",
3344                              "Prefer printk_ratelimited or pr_<level>_ratelimited to printk_ratelimit\n" . $herecurr);
3345                 }
3346
3347 # printk should use KERN_* levels.  Note that follow on printk's on the
3348 # same line do not need a level, so we use the current block context
3349 # to try and find and validate the current printk.  In summary the current
3350 # printk includes all preceding printk's which have no newline on the end.
3351 # we assume the first bad printk is the one to report.
3352                 if ($line =~ /\bprintk\((?!KERN_)\s*"/) {
3353                         my $ok = 0;
3354                         for (my $ln = $linenr - 1; $ln >= $first_line; $ln--) {
3355                                 #print "CHECK<$lines[$ln - 1]\n";
3356                                 # we have a preceding printk if it ends
3357                                 # with "\n" ignore it, else it is to blame
3358                                 if ($lines[$ln - 1] =~ m{\bprintk\(}) {
3359                                         if ($rawlines[$ln - 1] !~ m{\\n"}) {
3360                                                 $ok = 1;
3361                                         }
3362                                         last;
3363                                 }
3364                         }
3365                         if ($ok == 0) {
3366                                 WARN("PRINTK_WITHOUT_KERN_LEVEL",
3367                                      "printk() should include KERN_ facility level\n" . $herecurr);
3368                         }
3369                 }
3370
3371                 if ($line =~ /\bprintk\s*\(\s*KERN_([A-Z]+)/) {
3372                         my $orig = $1;
3373                         my $level = lc($orig);
3374                         $level = "warn" if ($level eq "warning");
3375                         my $level2 = $level;
3376                         $level2 = "dbg" if ($level eq "debug");
3377                         WARN("PREFER_PR_LEVEL",
3378                              "Prefer [subsystem eg: netdev]_$level2([subsystem]dev, ... then dev_$level2(dev, ... then pr_$level(...  to printk(KERN_$orig ...\n" . $herecurr);
3379                 }
3380
3381                 if ($line =~ /\bpr_warning\s*\(/) {
3382                         if (WARN("PREFER_PR_LEVEL",
3383                                  "Prefer pr_warn(... to pr_warning(...\n" . $herecurr) &&
3384                             $fix) {
3385                                 $fixed[$fixlinenr] =~
3386                                     s/\bpr_warning\b/pr_warn/;
3387                         }
3388                 }
3389
3390                 if ($line =~ /\bdev_printk\s*\(\s*KERN_([A-Z]+)/) {
3391                         my $orig = $1;
3392                         my $level = lc($orig);
3393                         $level = "warn" if ($level eq "warning");
3394                         $level = "dbg" if ($level eq "debug");
3395                         WARN("PREFER_DEV_LEVEL",
3396                              "Prefer dev_$level(... to dev_printk(KERN_$orig, ...\n" . $herecurr);
3397                 }
3398
3399 # ENOSYS means "bad syscall nr" and nothing else.  This will have a small
3400 # number of false positives, but assembly files are not checked, so at
3401 # least the arch entry code will not trigger this warning.
3402                 if ($line =~ /\bENOSYS\b/) {
3403                         WARN("ENOSYS",
3404                              "ENOSYS means 'invalid syscall nr' and nothing else\n" . $herecurr);
3405                 }
3406
3407 # function brace can't be on same line, except for #defines of do while,
3408 # or if closed on same line
3409                 if (($line=~/$Type\s*$Ident\(.*\).*\s*{/) and
3410                     !($line=~/\#\s*define.*do\s{/) and !($line=~/}/)) {
3411                         if (ERROR("OPEN_BRACE",
3412                                   "open brace '{' following function declarations go on the next line\n" . $herecurr) &&
3413                             $fix) {
3414                                 fix_delete_line($fixlinenr, $rawline);
3415                                 my $fixed_line = $rawline;
3416                                 $fixed_line =~ /(^..*$Type\s*$Ident\(.*\)\s*){(.*)$/;
3417                                 my $line1 = $1;
3418                                 my $line2 = $2;
3419                                 fix_insert_line($fixlinenr, ltrim($line1));
3420                                 fix_insert_line($fixlinenr, "\+{");
3421                                 if ($line2 !~ /^\s*$/) {
3422                                         fix_insert_line($fixlinenr, "\+\t" . trim($line2));
3423                                 }
3424                         }
3425                 }
3426
3427 # open braces for enum, union and struct go on the same line.
3428                 if ($line =~ /^.\s*{/ &&
3429                     $prevline =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident)?\s*$/) {
3430                         if (ERROR("OPEN_BRACE",
3431                                   "open brace '{' following $1 go on the same line\n" . $hereprev) &&
3432                             $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
3433                                 fix_delete_line($fixlinenr - 1, $prevrawline);
3434                                 fix_delete_line($fixlinenr, $rawline);
3435                                 my $fixedline = rtrim($prevrawline) . " {";
3436                                 fix_insert_line($fixlinenr, $fixedline);
3437                                 $fixedline = $rawline;
3438                                 $fixedline =~ s/^(.\s*){\s*/$1\t/;
3439                                 if ($fixedline !~ /^\+\s*$/) {
3440                                         fix_insert_line($fixlinenr, $fixedline);
3441                                 }
3442                         }
3443                 }
3444
3445 # missing space after union, struct or enum definition
3446                 if ($line =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident){1,2}[=\{]/) {
3447                         if (WARN("SPACING",
3448                                  "missing space after $1 definition\n" . $herecurr) &&
3449                             $fix) {
3450                                 $fixed[$fixlinenr] =~
3451                                     s/^(.\s*(?:typedef\s+)?(?:enum|union|struct)(?:\s+$Ident){1,2})([=\{])/$1 $2/;
3452                         }
3453                 }
3454
3455 # Function pointer declarations
3456 # check spacing between type, funcptr, and args
3457 # canonical declaration is "type (*funcptr)(args...)"
3458                 if ($line =~ /^.\s*($Declare)\((\s*)\*(\s*)($Ident)(\s*)\)(\s*)\(/) {
3459                         my $declare = $1;
3460                         my $pre_pointer_space = $2;
3461                         my $post_pointer_space = $3;
3462                         my $funcname = $4;
3463                         my $post_funcname_space = $5;
3464                         my $pre_args_space = $6;
3465
3466 # the $Declare variable will capture all spaces after the type
3467 # so check it for a missing trailing missing space but pointer return types
3468 # don't need a space so don't warn for those.
3469                         my $post_declare_space = "";
3470                         if ($declare =~ /(\s+)$/) {
3471                                 $post_declare_space = $1;
3472                                 $declare = rtrim($declare);
3473                         }
3474                         if ($declare !~ /\*$/ && $post_declare_space =~ /^$/) {
3475                                 WARN("SPACING",
3476                                      "missing space after return type\n" . $herecurr);
3477                                 $post_declare_space = " ";
3478                         }
3479
3480 # unnecessary space "type  (*funcptr)(args...)"
3481 # This test is not currently implemented because these declarations are
3482 # equivalent to
3483 #       int  foo(int bar, ...)
3484 # and this is form shouldn't/doesn't generate a checkpatch warning.
3485 #
3486 #                       elsif ($declare =~ /\s{2,}$/) {
3487 #                               WARN("SPACING",
3488 #                                    "Multiple spaces after return type\n" . $herecurr);
3489 #                       }
3490
3491 # unnecessary space "type ( *funcptr)(args...)"
3492                         if (defined $pre_pointer_space &&
3493                             $pre_pointer_space =~ /^\s/) {
3494                                 WARN("SPACING",
3495                                      "Unnecessary space after function pointer open parenthesis\n" . $herecurr);
3496                         }
3497
3498 # unnecessary space "type (* funcptr)(args...)"
3499                         if (defined $post_pointer_space &&
3500                             $post_pointer_space =~ /^\s/) {
3501                                 WARN("SPACING",
3502                                      "Unnecessary space before function pointer name\n" . $herecurr);
3503                         }
3504
3505 # unnecessary space "type (*funcptr )(args...)"
3506                         if (defined $post_funcname_space &&
3507                             $post_funcname_space =~ /^\s/) {
3508                                 WARN("SPACING",
3509                                      "Unnecessary space after function pointer name\n" . $herecurr);
3510                         }
3511
3512 # unnecessary space "type (*funcptr) (args...)"
3513                         if (defined $pre_args_space &&
3514                             $pre_args_space =~ /^\s/) {
3515                                 WARN("SPACING",
3516                                      "Unnecessary space before function pointer arguments\n" . $herecurr);
3517                         }
3518
3519                         if (show_type("SPACING") && $fix) {
3520                                 $fixed[$fixlinenr] =~
3521                                     s/^(.\s*)$Declare\s*\(\s*\*\s*$Ident\s*\)\s*\(/$1 . $declare . $post_declare_space . '(*' . $funcname . ')('/ex;
3522                         }
3523                 }
3524
3525 # check for spacing round square brackets; allowed:
3526 #  1. with a type on the left -- int [] a;
3527 #  2. at the beginning of a line for slice initialisers -- [0...10] = 5,
3528 #  3. inside a curly brace -- = { [0...10] = 5 }
3529                 while ($line =~ /(.*?\s)\[/g) {
3530                         my ($where, $prefix) = ($-[1], $1);
3531                         if ($prefix !~ /$Type\s+$/ &&
3532                             ($where != 0 || $prefix !~ /^.\s+$/) &&
3533                             $prefix !~ /[{,]\s+$/) {
3534                                 if (ERROR("BRACKET_SPACE",
3535                                           "space prohibited before open square bracket '['\n" . $herecurr) &&
3536                                     $fix) {
3537                                     $fixed[$fixlinenr] =~
3538                                         s/^(\+.*?)\s+\[/$1\[/;
3539                                 }
3540                         }
3541                 }
3542
3543 # check for spaces between functions and their parentheses.
3544                 while ($line =~ /($Ident)\s+\(/g) {
3545                         my $name = $1;
3546                         my $ctx_before = substr($line, 0, $-[1]);
3547                         my $ctx = "$ctx_before$name";
3548
3549                         # Ignore those directives where spaces _are_ permitted.
3550                         if ($name =~ /^(?:
3551                                 if|for|while|switch|return|case|
3552                                 volatile|__volatile__|
3553                                 __attribute__|format|__extension__|
3554                                 asm|__asm__)$/x)
3555                         {
3556                         # cpp #define statements have non-optional spaces, ie
3557                         # if there is a space between the name and the open
3558                         # parenthesis it is simply not a parameter group.
3559                         } elsif ($ctx_before =~ /^.\s*\#\s*define\s*$/) {
3560
3561                         # cpp #elif statement condition may start with a (
3562                         } elsif ($ctx =~ /^.\s*\#\s*elif\s*$/) {
3563
3564                         # If this whole things ends with a type its most
3565                         # likely a typedef for a function.
3566                         } elsif ($ctx =~ /$Type$/) {
3567
3568                         } else {
3569                                 if (WARN("SPACING",
3570                                          "space prohibited between function name and open parenthesis '('\n" . $herecurr) &&
3571                                              $fix) {
3572                                         $fixed[$fixlinenr] =~
3573                                             s/\b$name\s+\(/$name\(/;
3574                                 }
3575                         }
3576                 }
3577
3578 # Check operator spacing.
3579                 if (!($line=~/\#\s*include/)) {
3580                         my $fixed_line = "";
3581                         my $line_fixed = 0;
3582
3583                         my $ops = qr{
3584                                 <<=|>>=|<=|>=|==|!=|
3585                                 \+=|-=|\*=|\/=|%=|\^=|\|=|&=|
3586                                 =>|->|<<|>>|<|>|=|!|~|
3587                                 &&|\|\||,|\^|\+\+|--|&|\||\+|-|\*|\/|%|
3588                                 \?:|\?|:
3589                         }x;
3590                         my @elements = split(/($ops|;)/, $opline);
3591
3592 ##                      print("element count: <" . $#elements . ">\n");
3593 ##                      foreach my $el (@elements) {
3594 ##                              print("el: <$el>\n");
3595 ##                      }
3596
3597                         my @fix_elements = ();
3598                         my $off = 0;
3599
3600                         foreach my $el (@elements) {
3601                                 push(@fix_elements, substr($rawline, $off, length($el)));
3602                                 $off += length($el);
3603                         }
3604
3605                         $off = 0;
3606
3607                         my $blank = copy_spacing($opline);
3608                         my $last_after = -1;
3609
3610                         for (my $n = 0; $n < $#elements; $n += 2) {
3611
3612                                 my $good = $fix_elements[$n] . $fix_elements[$n + 1];
3613
3614 ##                              print("n: <$n> good: <$good>\n");
3615
3616                                 $off += length($elements[$n]);
3617
3618                                 # Pick up the preceding and succeeding characters.
3619                                 my $ca = substr($opline, 0, $off);
3620                                 my $cc = '';
3621                                 if (length($opline) >= ($off + length($elements[$n + 1]))) {
3622                                         $cc = substr($opline, $off + length($elements[$n + 1]));
3623                                 }
3624                                 my $cb = "$ca$;$cc";
3625
3626                                 my $a = '';
3627                                 $a = 'V' if ($elements[$n] ne '');
3628                                 $a = 'W' if ($elements[$n] =~ /\s$/);
3629                                 $a = 'C' if ($elements[$n] =~ /$;$/);
3630                                 $a = 'B' if ($elements[$n] =~ /(\[|\()$/);
3631                                 $a = 'O' if ($elements[$n] eq '');
3632                                 $a = 'E' if ($ca =~ /^\s*$/);
3633
3634                                 my $op = $elements[$n + 1];
3635
3636                                 my $c = '';
3637                                 if (defined $elements[$n + 2]) {
3638                                         $c = 'V' if ($elements[$n + 2] ne '');
3639                                         $c = 'W' if ($elements[$n + 2] =~ /^\s/);
3640                                         $c = 'C' if ($elements[$n + 2] =~ /^$;/);
3641                                         $c = 'B' if ($elements[$n + 2] =~ /^(\)|\]|;)/);
3642                                         $c = 'O' if ($elements[$n + 2] eq '');
3643                                         $c = 'E' if ($elements[$n + 2] =~ /^\s*\\$/);
3644                                 } else {
3645                                         $c = 'E';
3646                                 }
3647
3648                                 my $ctx = "${a}x${c}";
3649
3650                                 my $at = "(ctx:$ctx)";
3651
3652                                 my $ptr = substr($blank, 0, $off) . "^";
3653                                 my $hereptr = "$hereline$ptr\n";
3654
3655                                 # Pull out the value of this operator.
3656                                 my $op_type = substr($curr_values, $off + 1, 1);
3657
3658                                 # Get the full operator variant.
3659                                 my $opv = $op . substr($curr_vars, $off, 1);
3660
3661                                 # Ignore operators passed as parameters.
3662                                 if ($op_type ne 'V' &&
3663                                     $ca =~ /\s$/ && $cc =~ /^\s*[,\)]/) {
3664
3665 #                               # Ignore comments
3666 #                               } elsif ($op =~ /^$;+$/) {
3667
3668                                 # ; should have either the end of line or a space or \ after it
3669                                 } elsif ($op eq ';') {
3670                                         if ($ctx !~ /.x[WEBC]/ &&
3671                                             $cc !~ /^\\/ && $cc !~ /^;/) {
3672                                                 if (ERROR("SPACING",
3673                                                           "space required after that '$op' $at\n" . $hereptr)) {
3674                                                         $good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";
3675                                                         $line_fixed = 1;
3676                                                 }
3677                                         }
3678
3679                                 # // is a comment
3680                                 } elsif ($op eq '//') {
3681
3682                                 #   :   when part of a bitfield
3683                                 } elsif ($opv eq ':B') {
3684                                         # skip the bitfield test for now
3685
3686                                 # No spaces for:
3687                                 #   ->
3688                                 } elsif ($op eq '->') {
3689                                         if ($ctx =~ /Wx.|.xW/) {
3690                                                 if (ERROR("SPACING",
3691                                                           "spaces prohibited around that '$op' $at\n" . $hereptr)) {
3692                                                         $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
3693                                                         if (defined $fix_elements[$n + 2]) {
3694                                                                 $fix_elements[$n + 2] =~ s/^\s+//;
3695                                                         }
3696                                                         $line_fixed = 1;
3697                                                 }
3698                                         }
3699
3700                                 # , must not have a space before and must have a space on the right.
3701                                 } elsif ($op eq ',') {
3702                                         my $rtrim_before = 0;
3703                                         my $space_after = 0;
3704                                         if ($ctx =~ /Wx./) {
3705                                                 if (ERROR("SPACING",
3706                                                           "space prohibited before that '$op' $at\n" . $hereptr)) {
3707                                                         $line_fixed = 1;
3708                                                         $rtrim_before = 1;
3709                                                 }
3710                                         }
3711                                         if ($ctx !~ /.x[WEC]/ && $cc !~ /^}/) {
3712                                                 if (ERROR("SPACING",
3713                                                           "space required after that '$op' $at\n" . $hereptr)) {
3714                                                         $line_fixed = 1;
3715                                                         $last_after = $n;
3716                                                         $space_after = 1;
3717                                                 }
3718                                         }
3719                                         if ($rtrim_before || $space_after) {
3720                                                 if ($rtrim_before) {
3721                                                         $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
3722                                                 } else {
3723                                                         $good = $fix_elements[$n] . trim($fix_elements[$n + 1]);
3724                                                 }
3725                                                 if ($space_after) {
3726                                                         $good .= " ";
3727                                                 }
3728                                         }
3729
3730                                 # '*' as part of a type definition -- reported already.
3731                                 } elsif ($opv eq '*_') {
3732                                         #warn "'*' is part of type\n";
3733
3734                                 # unary operators should have a space before and
3735                                 # none after.  May be left adjacent to another
3736                                 # unary operator, or a cast
3737                                 } elsif ($op eq '!' || $op eq '~' ||
3738                                          $opv eq '*U' || $opv eq '-U' ||
3739                                          $opv eq '&U' || $opv eq '&&U') {
3740                                         if ($ctx !~ /[WEBC]x./ && $ca !~ /(?:\)|!|~|\*|-|\&|\||\+\+|\-\-|\{)$/) {
3741                                                 if (ERROR("SPACING",
3742                                                           "space required before that '$op' $at\n" . $hereptr)) {
3743                                                         if ($n != $last_after + 2) {
3744                                                                 $good = $fix_elements[$n] . " " . ltrim($fix_elements[$n + 1]);
3745                                                                 $line_fixed = 1;
3746                                                         }
3747                                                 }
3748                                         }
3749                                         if ($op eq '*' && $cc =~/\s*$Modifier\b/) {
3750                                                 # A unary '*' may be const
3751
3752                                         } elsif ($ctx =~ /.xW/) {
3753                                                 if (ERROR("SPACING",
3754                                                           "space prohibited after that '$op' $at\n" . $hereptr)) {
3755                                                         $good = $fix_elements[$n] . rtrim($fix_elements[$n + 1]);
3756                                                         if (defined $fix_elements[$n + 2]) {
3757                                                                 $fix_elements[$n + 2] =~ s/^\s+//;
3758                                                         }
3759                                                         $line_fixed = 1;
3760                                                 }
3761                                         }
3762
3763                                 # unary ++ and unary -- are allowed no space on one side.
3764                                 } elsif ($op eq '++' or $op eq '--') {
3765                                         if ($ctx !~ /[WEOBC]x[^W]/ && $ctx !~ /[^W]x[WOBEC]/) {
3766                                                 if (ERROR("SPACING",
3767                                                           "space required one side of that '$op' $at\n" . $hereptr)) {
3768                                                         $good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";
3769                                                         $line_fixed = 1;
3770                                                 }
3771                                         }
3772                                         if ($ctx =~ /Wx[BE]/ ||
3773                                             ($ctx =~ /Wx./ && $cc =~ /^;/)) {
3774                                                 if (ERROR("SPACING",
3775                                                           "space prohibited before that '$op' $at\n" . $hereptr)) {
3776                                                         $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
3777                                                         $line_fixed = 1;
3778                                                 }
3779                                         }
3780                                         if ($ctx =~ /ExW/) {
3781                                                 if (ERROR("SPACING",
3782                                                           "space prohibited after that '$op' $at\n" . $hereptr)) {
3783                                                         $good = $fix_elements[$n] . trim($fix_elements[$n + 1]);
3784                                                         if (defined $fix_elements[$n + 2]) {
3785                                                                 $fix_elements[$n + 2] =~ s/^\s+//;
3786                                                         }
3787                                                         $line_fixed = 1;
3788                                                 }
3789                                         }
3790
3791                                 # << and >> may either have or not have spaces both sides
3792                                 } elsif ($op eq '<<' or $op eq '>>' or
3793                                          $op eq '&' or $op eq '^' or $op eq '|' or
3794                                          $op eq '+' or $op eq '-' or
3795                                          $op eq '*' or $op eq '/' or
3796                                          $op eq '%')
3797                                 {
3798                                         if ($check) {
3799                                                 if (defined $fix_elements[$n + 2] && $ctx !~ /[EW]x[EW]/) {
3800                                                         if (CHK("SPACING",
3801                                                                 "spaces preferred around that '$op' $at\n" . $hereptr)) {
3802                                                                 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
3803                                                                 $fix_elements[$n + 2] =~ s/^\s+//;
3804                                                                 $line_fixed = 1;
3805                                                         }
3806                                                 } elsif (!defined $fix_elements[$n + 2] && $ctx !~ /Wx[OE]/) {
3807                                                         if (CHK("SPACING",
3808                                                                 "space preferred before that '$op' $at\n" . $hereptr)) {
3809                                                                 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]);
3810                                                                 $line_fixed = 1;
3811                                                         }
3812                                                 }
3813                                         } elsif ($ctx =~ /Wx[^WCE]|[^WCE]xW/) {
3814                                                 if (ERROR("SPACING",
3815                                                           "need consistent spacing around '$op' $at\n" . $hereptr)) {
3816                                                         $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
3817                                                         if (defined $fix_elements[$n + 2]) {
3818                                                                 $fix_elements[$n + 2] =~ s/^\s+//;
3819                                                         }
3820                                                         $line_fixed = 1;
3821                                                 }
3822                                         }
3823
3824                                 # A colon needs no spaces before when it is
3825                                 # terminating a case value or a label.
3826                                 } elsif ($opv eq ':C' || $opv eq ':L') {
3827                                         if ($ctx =~ /Wx./) {
3828                                                 if (ERROR("SPACING",
3829                                                           "space prohibited before that '$op' $at\n" . $hereptr)) {
3830                                                         $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
3831                                                         $line_fixed = 1;
3832                                                 }
3833                                         }
3834
3835                                 # All the others need spaces both sides.
3836                                 } elsif ($ctx !~ /[EWC]x[CWE]/) {
3837                                         my $ok = 0;
3838
3839                                         # Ignore email addresses <foo@bar>
3840                                         if (($op eq '<' &&
3841                                              $cc =~ /^\S+\@\S+>/) ||
3842                                             ($op eq '>' &&
3843                                              $ca =~ /<\S+\@\S+$/))
3844                                         {
3845                                                 $ok = 1;
3846                                         }
3847
3848                                         # for asm volatile statements
3849                                         # ignore a colon with another
3850                                         # colon immediately before or after
3851                                         if (($op eq ':') &&
3852                                             ($ca =~ /:$/ || $cc =~ /^:/)) {
3853                                                 $ok = 1;
3854                                         }
3855
3856                                         # messages are ERROR, but ?: are CHK
3857                                         if ($ok == 0) {
3858                                                 my $msg_type = \&ERROR;
3859                                                 $msg_type = \&CHK if (($op eq '?:' || $op eq '?' || $op eq ':') && $ctx =~ /VxV/);
3860
3861                                                 if (&{$msg_type}("SPACING",
3862                                                                  "spaces required around that '$op' $at\n" . $hereptr)) {
3863                                                         $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
3864                                                         if (defined $fix_elements[$n + 2]) {
3865                                                                 $fix_elements[$n + 2] =~ s/^\s+//;
3866                                                         }
3867                                                         $line_fixed = 1;
3868                                                 }
3869                                         }
3870                                 }
3871                                 $off += length($elements[$n + 1]);
3872
3873 ##                              print("n: <$n> GOOD: <$good>\n");
3874
3875                                 $fixed_line = $fixed_line . $good;
3876                         }
3877
3878                         if (($#elements % 2) == 0) {
3879                                 $fixed_line = $fixed_line . $fix_elements[$#elements];
3880                         }
3881
3882                         if ($fix && $line_fixed && $fixed_line ne $fixed[$fixlinenr]) {
3883                                 $fixed[$fixlinenr] = $fixed_line;
3884                         }
3885
3886
3887                 }
3888
3889 # check for whitespace before a non-naked semicolon
3890                 if ($line =~ /^\+.*\S\s+;\s*$/) {
3891                         if (WARN("SPACING",
3892                                  "space prohibited before semicolon\n" . $herecurr) &&
3893                             $fix) {
3894                                 1 while $fixed[$fixlinenr] =~
3895                                     s/^(\+.*\S)\s+;/$1;/;
3896                         }
3897                 }
3898
3899 # check for multiple assignments
3900                 if ($line =~ /^.\s*$Lval\s*=\s*$Lval\s*=(?!=)/) {
3901                         CHK("MULTIPLE_ASSIGNMENTS",
3902                             "multiple assignments should be avoided\n" . $herecurr);
3903                 }
3904
3905 ## # check for multiple declarations, allowing for a function declaration
3906 ## # continuation.
3907 ##              if ($line =~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Ident.*/ &&
3908 ##                  $line !~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Type\s*$Ident.*/) {
3909 ##
3910 ##                      # Remove any bracketed sections to ensure we do not
3911 ##                      # falsly report the parameters of functions.
3912 ##                      my $ln = $line;
3913 ##                      while ($ln =~ s/\([^\(\)]*\)//g) {
3914 ##                      }
3915 ##                      if ($ln =~ /,/) {
3916 ##                              WARN("MULTIPLE_DECLARATION",
3917 ##                                   "declaring multiple variables together should be avoided\n" . $herecurr);
3918 ##                      }
3919 ##              }
3920
3921 #need space before brace following if, while, etc
3922                 if (($line =~ /\(.*\){/ && $line !~ /\($Type\){/) ||
3923                     $line =~ /do{/) {
3924                         if (ERROR("SPACING",
3925                                   "space required before the open brace '{'\n" . $herecurr) &&
3926                             $fix) {
3927                                 $fixed[$fixlinenr] =~ s/^(\+.*(?:do|\))){/$1 {/;
3928                         }
3929                 }
3930
3931 ## # check for blank lines before declarations
3932 ##              if ($line =~ /^.\t+$Type\s+$Ident(?:\s*=.*)?;/ &&
3933 ##                  $prevrawline =~ /^.\s*$/) {
3934 ##                      WARN("SPACING",
3935 ##                           "No blank lines before declarations\n" . $hereprev);
3936 ##              }
3937 ##
3938
3939 # closing brace should have a space following it when it has anything
3940 # on the line
3941                 if ($line =~ /}(?!(?:,|;|\)))\S/) {
3942                         if (ERROR("SPACING",
3943                                   "space required after that close brace '}'\n" . $herecurr) &&
3944                             $fix) {
3945                                 $fixed[$fixlinenr] =~
3946                                     s/}((?!(?:,|;|\)))\S)/} $1/;
3947                         }
3948                 }
3949
3950 # check spacing on square brackets
3951                 if ($line =~ /\[\s/ && $line !~ /\[\s*$/) {
3952                         if (ERROR("SPACING",
3953                                   "space prohibited after that open square bracket '['\n" . $herecurr) &&
3954                             $fix) {
3955                                 $fixed[$fixlinenr] =~
3956                                     s/\[\s+/\[/;
3957                         }
3958                 }
3959                 if ($line =~ /\s\]/) {
3960                         if (ERROR("SPACING",
3961                                   "space prohibited before that close square bracket ']'\n" . $herecurr) &&
3962                             $fix) {
3963                                 $fixed[$fixlinenr] =~
3964                                     s/\s+\]/\]/;
3965                         }
3966                 }
3967
3968 # check spacing on parentheses
3969                 if ($line =~ /\(\s/ && $line !~ /\(\s*(?:\\)?$/ &&
3970                     $line !~ /for\s*\(\s+;/) {
3971                         if (ERROR("SPACING",
3972                                   "space prohibited after that open parenthesis '('\n" . $herecurr) &&
3973                             $fix) {
3974                                 $fixed[$fixlinenr] =~
3975                                     s/\(\s+/\(/;
3976                         }
3977                 }
3978                 if ($line =~ /(\s+)\)/ && $line !~ /^.\s*\)/ &&
3979                     $line !~ /for\s*\(.*;\s+\)/ &&
3980                     $line !~ /:\s+\)/) {
3981                         if (ERROR("SPACING",
3982                                   "space prohibited before that close parenthesis ')'\n" . $herecurr) &&
3983                             $fix) {
3984                                 $fixed[$fixlinenr] =~
3985                                     s/\s+\)/\)/;
3986                         }
3987                 }
3988
3989 # check unnecessary parentheses around addressof/dereference single $Lvals
3990 # ie: &(foo->bar) should be &foo->bar and *(foo->bar) should be *foo->bar
3991
3992                 while ($line =~ /(?:[^&]&\s*|\*)\(\s*($Ident\s*(?:$Member\s*)+)\s*\)/g) {
3993                         my $var = $1;
3994                         if (CHK("UNNECESSARY_PARENTHESES",
3995                                 "Unnecessary parentheses around $var\n" . $herecurr) &&
3996                             $fix) {
3997                                 $fixed[$fixlinenr] =~ s/\(\s*\Q$var\E\s*\)/$var/;
3998                         }
3999                 }
4000
4001 # check for unnecessary parentheses around function pointer uses
4002 # ie: (foo->bar)(); should be foo->bar();
4003 # but not "if (foo->bar) (" to avoid some false positives
4004                 if ($line =~ /(\bif\s*|)(\(\s*$Ident\s*(?:$Member\s*)+\))[ \t]*\(/ && $1 !~ /^if/) {
4005                         my $var = $2;
4006                         if (CHK("UNNECESSARY_PARENTHESES",
4007                                 "Unnecessary parentheses around function pointer $var\n" . $herecurr) &&
4008                             $fix) {
4009                                 my $var2 = deparenthesize($var);
4010                                 $var2 =~ s/\s//g;
4011                                 $fixed[$fixlinenr] =~ s/\Q$var\E/$var2/;
4012                         }
4013                 }
4014
4015 #goto labels aren't indented, allow a single space however
4016                 if ($line=~/^.\s+[A-Za-z\d_]+:(?![0-9]+)/ and
4017                    !($line=~/^. [A-Za-z\d_]+:/) and !($line=~/^.\s+default:/)) {
4018                         if (WARN("INDENTED_LABEL",
4019                                  "labels should not be indented\n" . $herecurr) &&
4020                             $fix) {
4021                                 $fixed[$fixlinenr] =~
4022                                     s/^(.)\s+/$1/;
4023                         }
4024                 }
4025
4026 # return is not a function
4027                 if (defined($stat) && $stat =~ /^.\s*return(\s*)\(/s) {
4028                         my $spacing = $1;
4029                         if ($^V && $^V ge 5.10.0 &&
4030                             $stat =~ /^.\s*return\s*($balanced_parens)\s*;\s*$/) {
4031                                 my $value = $1;
4032                                 $value = deparenthesize($value);
4033                                 if ($value =~ m/^\s*$FuncArg\s*(?:\?|$)/) {
4034                                         ERROR("RETURN_PARENTHESES",
4035                                               "return is not a function, parentheses are not required\n" . $herecurr);
4036                                 }
4037                         } elsif ($spacing !~ /\s+/) {
4038                                 ERROR("SPACING",
4039                                       "space required before the open parenthesis '('\n" . $herecurr);
4040                         }
4041                 }
4042
4043 # unnecessary return in a void function
4044 # at end-of-function, with the previous line a single leading tab, then return;
4045 # and the line before that not a goto label target like "out:"
4046                 if ($sline =~ /^[ \+]}\s*$/ &&
4047                     $prevline =~ /^\+\treturn\s*;\s*$/ &&
4048                     $linenr >= 3 &&
4049                     $lines[$linenr - 3] =~ /^[ +]/ &&
4050                     $lines[$linenr - 3] !~ /^[ +]\s*$Ident\s*:/) {
4051                         WARN("RETURN_VOID",
4052                              "void function return statements are not generally useful\n" . $hereprev);
4053                }
4054
4055 # if statements using unnecessary parentheses - ie: if ((foo == bar))
4056                 if ($^V && $^V ge 5.10.0 &&
4057                     $line =~ /\bif\s*((?:\(\s*){2,})/) {
4058                         my $openparens = $1;
4059                         my $count = $openparens =~ tr@\(@\(@;
4060                         my $msg = "";
4061                         if ($line =~ /\bif\s*(?:\(\s*){$count,$count}$LvalOrFunc\s*($Compare)\s*$LvalOrFunc(?:\s*\)){$count,$count}/) {
4062                                 my $comp = $4;  #Not $1 because of $LvalOrFunc
4063                                 $msg = " - maybe == should be = ?" if ($comp eq "==");
4064                                 WARN("UNNECESSARY_PARENTHESES",
4065                                      "Unnecessary parentheses$msg\n" . $herecurr);
4066                         }
4067                 }
4068
4069 # Return of what appears to be an errno should normally be negative
4070                 if ($sline =~ /\breturn(?:\s*\(+\s*|\s+)(E[A-Z]+)(?:\s*\)+\s*|\s*)[;:,]/) {
4071                         my $name = $1;
4072                         if ($name ne 'EOF' && $name ne 'ERROR') {
4073                                 WARN("USE_NEGATIVE_ERRNO",
4074                                      "return of an errno should typically be negative (ie: return -$1)\n" . $herecurr);
4075                         }
4076                 }
4077
4078 # Need a space before open parenthesis after if, while etc
4079                 if ($line =~ /\b(if|while|for|switch)\(/) {
4080                         if (ERROR("SPACING",
4081                                   "space required before the open parenthesis '('\n" . $herecurr) &&
4082                             $fix) {
4083                                 $fixed[$fixlinenr] =~
4084                                     s/\b(if|while|for|switch)\(/$1 \(/;
4085                         }
4086                 }
4087
4088 # Check for illegal assignment in if conditional -- and check for trailing
4089 # statements after the conditional.
4090                 if ($line =~ /do\s*(?!{)/) {
4091                         ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
4092                                 ctx_statement_block($linenr, $realcnt, 0)
4093                                         if (!defined $stat);
4094                         my ($stat_next) = ctx_statement_block($line_nr_next,
4095                                                 $remain_next, $off_next);
4096                         $stat_next =~ s/\n./\n /g;
4097                         ##print "stat<$stat> stat_next<$stat_next>\n";
4098
4099                         if ($stat_next =~ /^\s*while\b/) {
4100                                 # If the statement carries leading newlines,
4101                                 # then count those as offsets.
4102                                 my ($whitespace) =
4103                                         ($stat_next =~ /^((?:\s*\n[+-])*\s*)/s);
4104                                 my $offset =
4105                                         statement_rawlines($whitespace) - 1;
4106
4107                                 $suppress_whiletrailers{$line_nr_next +
4108                                                                 $offset} = 1;
4109                         }
4110                 }
4111                 if (!defined $suppress_whiletrailers{$linenr} &&
4112                     defined($stat) && defined($cond) &&
4113                     $line =~ /\b(?:if|while|for)\s*\(/ && $line !~ /^.\s*#/) {
4114                         my ($s, $c) = ($stat, $cond);
4115
4116                         if ($c =~ /\bif\s*\(.*[^<>!=]=[^=].*/s) {
4117                                 ERROR("ASSIGN_IN_IF",
4118                                       "do not use assignment in if condition\n" . $herecurr);
4119                         }
4120
4121                         # Find out what is on the end of the line after the
4122                         # conditional.
4123                         substr($s, 0, length($c), '');
4124                         $s =~ s/\n.*//g;
4125                         $s =~ s/$;//g;  # Remove any comments
4126                         if (length($c) && $s !~ /^\s*{?\s*\\*\s*$/ &&
4127                             $c !~ /}\s*while\s*/)
4128                         {
4129                                 # Find out how long the conditional actually is.
4130                                 my @newlines = ($c =~ /\n/gs);
4131                                 my $cond_lines = 1 + $#newlines;
4132                                 my $stat_real = '';
4133
4134                                 $stat_real = raw_line($linenr, $cond_lines)
4135                                                         . "\n" if ($cond_lines);
4136                                 if (defined($stat_real) && $cond_lines > 1) {
4137                                         $stat_real = "[...]\n$stat_real";
4138                                 }
4139
4140                                 ERROR("TRAILING_STATEMENTS",
4141                                       "trailing statements should be on next line\n" . $herecurr . $stat_real);
4142                         }
4143                 }
4144
4145 # Check for bitwise tests written as boolean
4146                 if ($line =~ /
4147                         (?:
4148                                 (?:\[|\(|\&\&|\|\|)
4149                                 \s*0[xX][0-9]+\s*
4150                                 (?:\&\&|\|\|)
4151                         |
4152                                 (?:\&\&|\|\|)
4153                                 \s*0[xX][0-9]+\s*
4154                                 (?:\&\&|\|\||\)|\])
4155                         )/x)
4156                 {
4157                         WARN("HEXADECIMAL_BOOLEAN_TEST",
4158                              "boolean test with hexadecimal, perhaps just 1 \& or \|?\n" . $herecurr);
4159                 }
4160
4161 # if and else should not have general statements after it
4162                 if ($line =~ /^.\s*(?:}\s*)?else\b(.*)/) {
4163                         my $s = $1;
4164                         $s =~ s/$;//g;  # Remove any comments
4165                         if ($s !~ /^\s*(?:\sif|(?:{|)\s*\\?\s*$)/) {
4166                                 ERROR("TRAILING_STATEMENTS",
4167                                       "trailing statements should be on next line\n" . $herecurr);
4168                         }
4169                 }
4170 # if should not continue a brace
4171                 if ($line =~ /}\s*if\b/) {
4172                         ERROR("TRAILING_STATEMENTS",
4173                               "trailing statements should be on next line (or did you mean 'else if'?)\n" .
4174                                 $herecurr);
4175                 }
4176 # case and default should not have general statements after them
4177                 if ($line =~ /^.\s*(?:case\s*.*|default\s*):/g &&
4178                     $line !~ /\G(?:
4179                         (?:\s*$;*)(?:\s*{)?(?:\s*$;*)(?:\s*\\)?\s*$|
4180                         \s*return\s+
4181                     )/xg)
4182                 {
4183                         ERROR("TRAILING_STATEMENTS",
4184                               "trailing statements should be on next line\n" . $herecurr);
4185                 }
4186
4187                 # Check for }<nl>else {, these must be at the same
4188                 # indent level to be relevant to each other.
4189                 if ($prevline=~/}\s*$/ and $line=~/^.\s*else\s*/ &&
4190                     $previndent == $indent) {
4191                         if (ERROR("ELSE_AFTER_BRACE",
4192                                   "else should follow close brace '}'\n" . $hereprev) &&
4193                             $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
4194                                 fix_delete_line($fixlinenr - 1, $prevrawline);
4195                                 fix_delete_line($fixlinenr, $rawline);
4196                                 my $fixedline = $prevrawline;
4197                                 $fixedline =~ s/}\s*$//;
4198                                 if ($fixedline !~ /^\+\s*$/) {
4199                                         fix_insert_line($fixlinenr, $fixedline);
4200                                 }
4201                                 $fixedline = $rawline;
4202                                 $fixedline =~ s/^(.\s*)else/$1} else/;
4203                                 fix_insert_line($fixlinenr, $fixedline);
4204                         }
4205                 }
4206
4207                 if ($prevline=~/}\s*$/ and $line=~/^.\s*while\s*/ &&
4208                     $previndent == $indent) {
4209                         my ($s, $c) = ctx_statement_block($linenr, $realcnt, 0);
4210
4211                         # Find out what is on the end of the line after the
4212                         # conditional.
4213                         substr($s, 0, length($c), '');
4214                         $s =~ s/\n.*//g;
4215
4216                         if ($s =~ /^\s*;/) {
4217                                 if (ERROR("WHILE_AFTER_BRACE",
4218                                           "while should follow close brace '}'\n" . $hereprev) &&
4219                                     $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
4220                                         fix_delete_line($fixlinenr - 1, $prevrawline);
4221                                         fix_delete_line($fixlinenr, $rawline);
4222                                         my $fixedline = $prevrawline;
4223                                         my $trailing = $rawline;
4224                                         $trailing =~ s/^\+//;
4225                                         $trailing = trim($trailing);
4226                                         $fixedline =~ s/}\s*$/} $trailing/;
4227                                         fix_insert_line($fixlinenr, $fixedline);
4228                                 }
4229                         }
4230                 }
4231
4232 #Specific variable tests
4233                 while ($line =~ m{($Constant|$Lval)}g) {
4234                         my $var = $1;
4235
4236 #gcc binary extension
4237                         if ($var =~ /^$Binary$/) {
4238                                 if (WARN("GCC_BINARY_CONSTANT",
4239                                          "Avoid gcc v4.3+ binary constant extension: <$var>\n" . $herecurr) &&
4240                                     $fix) {
4241                                         my $hexval = sprintf("0x%x", oct($var));
4242                                         $fixed[$fixlinenr] =~
4243                                             s/\b$var\b/$hexval/;
4244                                 }
4245                         }
4246
4247 #CamelCase
4248                         if ($var !~ /^$Constant$/ &&
4249                             $var =~ /[A-Z][a-z]|[a-z][A-Z]/ &&
4250 #Ignore Page<foo> variants
4251                             $var !~ /^(?:Clear|Set|TestClear|TestSet|)Page[A-Z]/ &&
4252 #Ignore SI style variants like nS, mV and dB (ie: max_uV, regulator_min_uA_show)
4253                             $var !~ /^(?:[a-z_]*?)_?[a-z][A-Z](?:_[a-z_]+)?$/ &&
4254 #Ignore some three character SI units explicitly, like MiB and KHz
4255                             $var !~ /^(?:[a-z_]*?)_?(?:[KMGT]iB|[KMGT]?Hz)(?:_[a-z_]+)?$/) {
4256                                 while ($var =~ m{($Ident)}g) {
4257                                         my $word = $1;
4258                                         next if ($word !~ /[A-Z][a-z]|[a-z][A-Z]/);
4259                                         if ($check) {
4260                                                 seed_camelcase_includes();
4261                                                 if (!$file && !$camelcase_file_seeded) {
4262                                                         seed_camelcase_file($realfile);
4263                                                         $camelcase_file_seeded = 1;
4264                                                 }
4265                                         }
4266                                         if (!defined $camelcase{$word}) {
4267                                                 $camelcase{$word} = 1;
4268                                                 CHK("CAMELCASE",
4269                                                     "Avoid CamelCase: <$word>\n" . $herecurr);
4270                                         }
4271                                 }
4272                         }
4273                 }
4274
4275 #no spaces allowed after \ in define
4276                 if ($line =~ /\#\s*define.*\\\s+$/) {
4277                         if (WARN("WHITESPACE_AFTER_LINE_CONTINUATION",
4278                                  "Whitespace after \\ makes next lines useless\n" . $herecurr) &&
4279                             $fix) {
4280                                 $fixed[$fixlinenr] =~ s/\s+$//;
4281                         }
4282                 }
4283
4284 # warn if <asm/foo.h> is #included and <linux/foo.h> is available and includes
4285 # itself <asm/foo.h> (uses RAW line)
4286                 if ($tree && $rawline =~ m{^.\s*\#\s*include\s*\<asm\/(.*)\.h\>}) {
4287                         my $file = "$1.h";
4288                         my $checkfile = "include/linux/$file";
4289                         if (-f "$root/$checkfile" &&
4290                             $realfile ne $checkfile &&
4291                             $1 !~ /$allowed_asm_includes/)
4292                         {
4293                                 my $asminclude = `grep -Ec "#include\\s+<asm/$file>" $root/$checkfile`;
4294                                 if ($asminclude > 0) {
4295                                         if ($realfile =~ m{^arch/}) {
4296                                                 CHK("ARCH_INCLUDE_LINUX",
4297                                                     "Consider using #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
4298                                         } else {
4299                                                 WARN("INCLUDE_LINUX",
4300                                                      "Use #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
4301                                         }
4302                                 }
4303                         }
4304                 }
4305
4306 # multi-statement macros should be enclosed in a do while loop, grab the
4307 # first statement and ensure its the whole macro if its not enclosed
4308 # in a known good container
4309                 if ($realfile !~ m@/vmlinux.lds.h$@ &&
4310                     $line =~ /^.\s*\#\s*define\s*$Ident(\()?/) {
4311                         my $ln = $linenr;
4312                         my $cnt = $realcnt;
4313                         my ($off, $dstat, $dcond, $rest);
4314                         my $ctx = '';
4315                         my $has_flow_statement = 0;
4316                         my $has_arg_concat = 0;
4317                         ($dstat, $dcond, $ln, $cnt, $off) =
4318                                 ctx_statement_block($linenr, $realcnt, 0);
4319                         $ctx = $dstat;
4320                         #print "dstat<$dstat> dcond<$dcond> cnt<$cnt> off<$off>\n";
4321                         #print "LINE<$lines[$ln-1]> len<" . length($lines[$ln-1]) . "\n";
4322
4323                         $has_flow_statement = 1 if ($ctx =~ /\b(goto|return)\b/);
4324                         $has_arg_concat = 1 if ($ctx =~ /\#\#/);
4325
4326                         $dstat =~ s/^.\s*\#\s*define\s+$Ident(?:\([^\)]*\))?\s*//;
4327                         $dstat =~ s/$;//g;
4328                         $dstat =~ s/\\\n.//g;
4329                         $dstat =~ s/^\s*//s;
4330                         $dstat =~ s/\s*$//s;
4331
4332                         # Flatten any parentheses and braces
4333                         while ($dstat =~ s/\([^\(\)]*\)/1/ ||
4334                                $dstat =~ s/\{[^\{\}]*\}/1/ ||
4335                                $dstat =~ s/\[[^\[\]]*\]/1/)
4336                         {
4337                         }
4338
4339                         # Flatten any obvious string concatentation.
4340                         while ($dstat =~ s/("X*")\s*$Ident/$1/ ||
4341                                $dstat =~ s/$Ident\s*("X*")/$1/)
4342                         {
4343                         }
4344
4345                         my $exceptions = qr{
4346                                 $Declare|
4347                                 module_param_named|
4348                                 MODULE_PARM_DESC|
4349                                 DECLARE_PER_CPU|
4350                                 DEFINE_PER_CPU|
4351                                 __typeof__\(|
4352                                 union|
4353                                 struct|
4354                                 \.$Ident\s*=\s*|
4355                                 ^\"|\"$
4356                         }x;
4357                         #print "REST<$rest> dstat<$dstat> ctx<$ctx>\n";
4358                         if ($dstat ne '' &&
4359                             $dstat !~ /^(?:$Ident|-?$Constant),$/ &&                    # 10, // foo(),
4360                             $dstat !~ /^(?:$Ident|-?$Constant);$/ &&                    # foo();
4361                             $dstat !~ /^[!~-]?(?:$Lval|$Constant)$/ &&          # 10 // foo() // !foo // ~foo // -foo // foo->bar // foo.bar->baz
4362                             $dstat !~ /^'X'$/ && $dstat !~ /^'XX'$/ &&                  # character constants
4363                             $dstat !~ /$exceptions/ &&
4364                             $dstat !~ /^\.$Ident\s*=/ &&                                # .foo =
4365                             $dstat !~ /^(?:\#\s*$Ident|\#\s*$Constant)\s*$/ &&          # stringification #foo
4366                             $dstat !~ /^do\s*$Constant\s*while\s*$Constant;?$/ &&       # do {...} while (...); // do {...} while (...)
4367                             $dstat !~ /^for\s*$Constant$/ &&                            # for (...)
4368                             $dstat !~ /^for\s*$Constant\s+(?:$Ident|-?$Constant)$/ &&   # for (...) bar()
4369                             $dstat !~ /^do\s*{/ &&                                      # do {...
4370                             $dstat !~ /^\({/ &&                                         # ({...
4371                             $ctx !~ /^.\s*#\s*define\s+TRACE_(?:SYSTEM|INCLUDE_FILE|INCLUDE_PATH)\b/)
4372                         {
4373                                 $ctx =~ s/\n*$//;
4374                                 my $herectx = $here . "\n";
4375                                 my $cnt = statement_rawlines($ctx);
4376
4377                                 for (my $n = 0; $n < $cnt; $n++) {
4378                                         $herectx .= raw_line($linenr, $n) . "\n";
4379                                 }
4380
4381                                 if ($dstat =~ /;/) {
4382                                         ERROR("MULTISTATEMENT_MACRO_USE_DO_WHILE",
4383                                               "Macros with multiple statements should be enclosed in a do - while loop\n" . "$herectx");
4384                                 } else {
4385                                         ERROR("COMPLEX_MACRO",
4386                                               "Macros with complex values should be enclosed in parentheses\n" . "$herectx");
4387                                 }
4388                         }
4389
4390 # check for macros with flow control, but without ## concatenation
4391 # ## concatenation is commonly a macro that defines a function so ignore those
4392                         if ($has_flow_statement && !$has_arg_concat) {
4393                                 my $herectx = $here . "\n";
4394                                 my $cnt = statement_rawlines($ctx);
4395
4396                                 for (my $n = 0; $n < $cnt; $n++) {
4397                                         $herectx .= raw_line($linenr, $n) . "\n";
4398                                 }
4399                                 WARN("MACRO_WITH_FLOW_CONTROL",
4400                                      "Macros with flow control statements should be avoided\n" . "$herectx");
4401                         }
4402
4403 # check for line continuations outside of #defines, preprocessor #, and asm
4404
4405                 } else {
4406                         if ($prevline !~ /^..*\\$/ &&
4407                             $line !~ /^\+\s*\#.*\\$/ &&         # preprocessor
4408                             $line !~ /^\+.*\b(__asm__|asm)\b.*\\$/ &&   # asm
4409                             $line =~ /^\+.*\\$/) {
4410                                 WARN("LINE_CONTINUATIONS",
4411                                      "Avoid unnecessary line continuations\n" . $herecurr);
4412                         }
4413                 }
4414
4415 # do {} while (0) macro tests:
4416 # single-statement macros do not need to be enclosed in do while (0) loop,
4417 # macro should not end with a semicolon
4418                 if ($^V && $^V ge 5.10.0 &&
4419                     $realfile !~ m@/vmlinux.lds.h$@ &&
4420                     $line =~ /^.\s*\#\s*define\s+$Ident(\()?/) {
4421                         my $ln = $linenr;
4422                         my $cnt = $realcnt;
4423                         my ($off, $dstat, $dcond, $rest);
4424                         my $ctx = '';
4425                         ($dstat, $dcond, $ln, $cnt, $off) =
4426                                 ctx_statement_block($linenr, $realcnt, 0);
4427                         $ctx = $dstat;
4428
4429                         $dstat =~ s/\\\n.//g;
4430                         $dstat =~ s/$;/ /g;
4431
4432                         if ($dstat =~ /^\+\s*#\s*define\s+$Ident\s*${balanced_parens}\s*do\s*{(.*)\s*}\s*while\s*\(\s*0\s*\)\s*([;\s]*)\s*$/) {
4433                                 my $stmts = $2;
4434                                 my $semis = $3;
4435
4436                                 $ctx =~ s/\n*$//;
4437                                 my $cnt = statement_rawlines($ctx);
4438                                 my $herectx = $here . "\n";
4439
4440                                 for (my $n = 0; $n < $cnt; $n++) {
4441                                         $herectx .= raw_line($linenr, $n) . "\n";
4442                                 }
4443
4444                                 if (($stmts =~ tr/;/;/) == 1 &&
4445                                     $stmts !~ /^\s*(if|while|for|switch)\b/) {
4446                                         WARN("SINGLE_STATEMENT_DO_WHILE_MACRO",
4447                                              "Single statement macros should not use a do {} while (0) loop\n" . "$herectx");
4448                                 }
4449                                 if (defined $semis && $semis ne "") {
4450                                         WARN("DO_WHILE_MACRO_WITH_TRAILING_SEMICOLON",
4451                                              "do {} while (0) macros should not be semicolon terminated\n" . "$herectx");
4452                                 }
4453                         } elsif ($dstat =~ /^\+\s*#\s*define\s+$Ident.*;\s*$/) {
4454                                 $ctx =~ s/\n*$//;
4455                                 my $cnt = statement_rawlines($ctx);
4456                                 my $herectx = $here . "\n";
4457
4458                                 for (my $n = 0; $n < $cnt; $n++) {
4459                                         $herectx .= raw_line($linenr, $n) . "\n";
4460                                 }
4461
4462                                 WARN("TRAILING_SEMICOLON",
4463                                      "macros should not use a trailing semicolon\n" . "$herectx");
4464                         }
4465                 }
4466
4467 # make sure symbols are always wrapped with VMLINUX_SYMBOL() ...
4468 # all assignments may have only one of the following with an assignment:
4469 #       .
4470 #       ALIGN(...)
4471 #       VMLINUX_SYMBOL(...)
4472                 if ($realfile eq 'vmlinux.lds.h' && $line =~ /(?:(?:^|\s)$Ident\s*=|=\s*$Ident(?:\s|$))/) {
4473                         WARN("MISSING_VMLINUX_SYMBOL",
4474                              "vmlinux.lds.h needs VMLINUX_SYMBOL() around C-visible symbols\n" . $herecurr);
4475                 }
4476
4477 # check for redundant bracing round if etc
4478                 if ($line =~ /(^.*)\bif\b/ && $1 !~ /else\s*$/) {
4479                         my ($level, $endln, @chunks) =
4480                                 ctx_statement_full($linenr, $realcnt, 1);
4481                         #print "chunks<$#chunks> linenr<$linenr> endln<$endln> level<$level>\n";
4482                         #print "APW: <<$chunks[1][0]>><<$chunks[1][1]>>\n";
4483                         if ($#chunks > 0 && $level == 0) {
4484                                 my @allowed = ();
4485                                 my $allow = 0;
4486                                 my $seen = 0;
4487                                 my $herectx = $here . "\n";
4488                                 my $ln = $linenr - 1;
4489                                 for my $chunk (@chunks) {
4490                                         my ($cond, $block) = @{$chunk};
4491
4492                                         # If the condition carries leading newlines, then count those as offsets.
4493                                         my ($whitespace) = ($cond =~ /^((?:\s*\n[+-])*\s*)/s);
4494                                         my $offset = statement_rawlines($whitespace) - 1;
4495
4496                                         $allowed[$allow] = 0;
4497                                         #print "COND<$cond> whitespace<$whitespace> offset<$offset>\n";
4498
4499                                         # We have looked at and allowed this specific line.
4500                                         $suppress_ifbraces{$ln + $offset} = 1;
4501
4502                                         $herectx .= "$rawlines[$ln + $offset]\n[...]\n";
4503                                         $ln += statement_rawlines($block) - 1;
4504
4505                                         substr($block, 0, length($cond), '');
4506
4507                                         $seen++ if ($block =~ /^\s*{/);
4508
4509                                         #print "cond<$cond> block<$block> allowed<$allowed[$allow]>\n";
4510                                         if (statement_lines($cond) > 1) {
4511                                                 #print "APW: ALLOWED: cond<$cond>\n";
4512                                                 $allowed[$allow] = 1;
4513                                         }
4514                                         if ($block =~/\b(?:if|for|while)\b/) {
4515                                                 #print "APW: ALLOWED: block<$block>\n";
4516                                                 $allowed[$allow] = 1;
4517                                         }
4518                                         if (statement_block_size($block) > 1) {
4519                                                 #print "APW: ALLOWED: lines block<$block>\n";
4520                                                 $allowed[$allow] = 1;
4521                                         }
4522                                         $allow++;
4523                                 }
4524                                 if ($seen) {
4525                                         my $sum_allowed = 0;
4526                                         foreach (@allowed) {
4527                                                 $sum_allowed += $_;
4528                                         }
4529                                         if ($sum_allowed == 0) {
4530                                                 WARN("BRACES",
4531                                                      "braces {} are not necessary for any arm of this statement\n" . $herectx);
4532                                         } elsif ($sum_allowed != $allow &&
4533                                                  $seen != $allow) {
4534                                                 CHK("BRACES",
4535                                                     "braces {} should be used on all arms of this statement\n" . $herectx);
4536                                         }
4537                                 }
4538                         }
4539                 }
4540                 if (!defined $suppress_ifbraces{$linenr - 1} &&
4541                                         $line =~ /\b(if|while|for|else)\b/) {
4542                         my $allowed = 0;
4543
4544                         # Check the pre-context.
4545                         if (substr($line, 0, $-[0]) =~ /(\}\s*)$/) {
4546                                 #print "APW: ALLOWED: pre<$1>\n";
4547                                 $allowed = 1;
4548                         }
4549
4550                         my ($level, $endln, @chunks) =
4551                                 ctx_statement_full($linenr, $realcnt, $-[0]);
4552
4553                         # Check the condition.
4554                         my ($cond, $block) = @{$chunks[0]};
4555                         #print "CHECKING<$linenr> cond<$cond> block<$block>\n";
4556                         if (defined $cond) {
4557                                 substr($block, 0, length($cond), '');
4558                         }
4559                         if (statement_lines($cond) > 1) {
4560                                 #print "APW: ALLOWED: cond<$cond>\n";
4561                                 $allowed = 1;
4562                         }
4563                         if ($block =~/\b(?:if|for|while)\b/) {
4564                                 #print "APW: ALLOWED: block<$block>\n";
4565                                 $allowed = 1;
4566                         }
4567                         if (statement_block_size($block) > 1) {
4568                                 #print "APW: ALLOWED: lines block<$block>\n";
4569                                 $allowed = 1;
4570                         }
4571                         # Check the post-context.
4572                         if (defined $chunks[1]) {
4573                                 my ($cond, $block) = @{$chunks[1]};
4574                                 if (defined $cond) {
4575                                         substr($block, 0, length($cond), '');
4576                                 }
4577                                 if ($block =~ /^\s*\{/) {
4578                                         #print "APW: ALLOWED: chunk-1 block<$block>\n";
4579                                         $allowed = 1;
4580                                 }
4581                         }
4582                         if ($level == 0 && $block =~ /^\s*\{/ && !$allowed) {
4583                                 my $herectx = $here . "\n";
4584                                 my $cnt = statement_rawlines($block);
4585
4586                                 for (my $n = 0; $n < $cnt; $n++) {
4587                                         $herectx .= raw_line($linenr, $n) . "\n";
4588                                 }
4589
4590                                 WARN("BRACES",
4591                                      "braces {} are not necessary for single statement blocks\n" . $herectx);
4592                         }
4593                 }
4594
4595 # check for unnecessary blank lines around braces
4596                 if (($line =~ /^.\s*}\s*$/ && $prevrawline =~ /^.\s*$/)) {
4597                         if (CHK("BRACES",
4598                                 "Blank lines aren't necessary before a close brace '}'\n" . $hereprev) &&
4599                             $fix && $prevrawline =~ /^\+/) {
4600                                 fix_delete_line($fixlinenr - 1, $prevrawline);
4601                         }
4602                 }
4603                 if (($rawline =~ /^.\s*$/ && $prevline =~ /^..*{\s*$/)) {
4604                         if (CHK("BRACES",
4605                                 "Blank lines aren't necessary after an open brace '{'\n" . $hereprev) &&
4606                             $fix) {
4607                                 fix_delete_line($fixlinenr, $rawline);
4608                         }
4609                 }
4610
4611 # no volatiles please
4612                 my $asm_volatile = qr{\b(__asm__|asm)\s+(__volatile__|volatile)\b};
4613                 if ($line =~ /\bvolatile\b/ && $line !~ /$asm_volatile/) {
4614                         WARN("VOLATILE",
4615                              "Use of volatile is usually wrong: see Documentation/volatile-considered-harmful.txt\n" . $herecurr);
4616                 }
4617
4618 # Check for user-visible strings broken across lines, which breaks the ability
4619 # to grep for the string.  Make exceptions when the previous string ends in a
4620 # newline (multiple lines in one string constant) or '\t', '\r', ';', or '{'
4621 # (common in inline assembly) or is a octal \123 or hexadecimal \xaf value
4622                 if ($line =~ /^\+\s*"[X\t]*"/ &&
4623                     $prevline =~ /"\s*$/ &&
4624                     $prevrawline !~ /(?:\\(?:[ntr]|[0-7]{1,3}|x[0-9a-fA-F]{1,2})|;\s*|\{\s*)"\s*$/) {
4625                         if (WARN("SPLIT_STRING",
4626                                  "quoted string split across lines\n" . $hereprev) &&
4627                                      $fix &&
4628                                      $prevrawline =~ /^\+.*"\s*$/ &&
4629                                      $last_coalesced_string_linenr != $linenr - 1) {
4630                                 my $extracted_string = get_quoted_string($line, $rawline);
4631                                 my $comma_close = "";
4632                                 if ($rawline =~ /\Q$extracted_string\E(\s*\)\s*;\s*$|\s*,\s*)/) {
4633                                         $comma_close = $1;
4634                                 }
4635
4636                                 fix_delete_line($fixlinenr - 1, $prevrawline);
4637                                 fix_delete_line($fixlinenr, $rawline);
4638                                 my $fixedline = $prevrawline;
4639                                 $fixedline =~ s/"\s*$//;
4640                                 $fixedline .= substr($extracted_string, 1) . trim($comma_close);
4641                                 fix_insert_line($fixlinenr - 1, $fixedline);
4642                                 $fixedline = $rawline;
4643                                 $fixedline =~ s/\Q$extracted_string\E\Q$comma_close\E//;
4644                                 if ($fixedline !~ /\+\s*$/) {
4645                                         fix_insert_line($fixlinenr, $fixedline);
4646                                 }
4647                                 $last_coalesced_string_linenr = $linenr;
4648                         }
4649                 }
4650
4651 # check for missing a space in a string concatenation
4652                 if ($prevrawline =~ /[^\\]\w"$/ && $rawline =~ /^\+[\t ]+"\w/) {
4653                         WARN('MISSING_SPACE',
4654                              "break quoted strings at a space character\n" . $hereprev);
4655                 }
4656
4657 # check for spaces before a quoted newline
4658                 if ($rawline =~ /^.*\".*\s\\n/) {
4659                         if (WARN("QUOTED_WHITESPACE_BEFORE_NEWLINE",
4660                                  "unnecessary whitespace before a quoted newline\n" . $herecurr) &&
4661                             $fix) {
4662                                 $fixed[$fixlinenr] =~ s/^(\+.*\".*)\s+\\n/$1\\n/;
4663                         }
4664
4665                 }
4666
4667 # concatenated string without spaces between elements
4668                 if ($line =~ /"X+"[A-Z_]+/ || $line =~ /[A-Z_]+"X+"/) {
4669                         CHK("CONCATENATED_STRING",
4670                             "Concatenated strings should use spaces between elements\n" . $herecurr);
4671                 }
4672
4673 # uncoalesced string fragments
4674                 if ($line =~ /"X*"\s*"/) {
4675                         WARN("STRING_FRAGMENTS",
4676                              "Consecutive strings are generally better as a single string\n" . $herecurr);
4677                 }
4678
4679 # check for %L{u,d,i} in strings
4680                 my $string;
4681                 while ($line =~ /(?:^|")([X\t]*)(?:"|$)/g) {
4682                         $string = substr($rawline, $-[1], $+[1] - $-[1]);
4683                         $string =~ s/%%/__/g;
4684                         if ($string =~ /(?<!%)%L[udi]/) {
4685                                 WARN("PRINTF_L",
4686                                      "\%Ld/%Lu are not-standard C, use %lld/%llu\n" . $herecurr);
4687                                 last;
4688                         }
4689                 }
4690
4691 # check for line continuations in quoted strings with odd counts of "
4692                 if ($rawline =~ /\\$/ && $rawline =~ tr/"/"/ % 2) {
4693                         WARN("LINE_CONTINUATIONS",
4694                              "Avoid line continuations in quoted strings\n" . $herecurr);
4695                 }
4696
4697 # warn about #if 0
4698                 if ($line =~ /^.\s*\#\s*if\s+0\b/) {
4699                         CHK("REDUNDANT_CODE",
4700                             "if this code is redundant consider removing it\n" .
4701                                 $herecurr);
4702                 }
4703
4704 # check for needless "if (<foo>) fn(<foo>)" uses
4705                 if ($prevline =~ /\bif\s*\(\s*($Lval)\s*\)/) {
4706                         my $expr = '\s*\(\s*' . quotemeta($1) . '\s*\)\s*;';
4707                         if ($line =~ /\b(kfree|usb_free_urb|debugfs_remove(?:_recursive)?)$expr/) {
4708                                 WARN('NEEDLESS_IF',
4709                                      "$1(NULL) is safe and this check is probably not required\n" . $hereprev);
4710                         }
4711                 }
4712
4713 # check for unnecessary "Out of Memory" messages
4714                 if ($line =~ /^\+.*\b$logFunctions\s*\(/ &&
4715                     $prevline =~ /^[ \+]\s*if\s*\(\s*(\!\s*|NULL\s*==\s*)?($Lval)(\s*==\s*NULL\s*)?\s*\)/ &&
4716                     (defined $1 || defined $3) &&
4717                     $linenr > 3) {
4718                         my $testval = $2;
4719                         my $testline = $lines[$linenr - 3];
4720
4721                         my ($s, $c) = ctx_statement_block($linenr - 3, $realcnt, 0);
4722 #                       print("line: <$line>\nprevline: <$prevline>\ns: <$s>\nc: <$c>\n\n\n");
4723
4724                         if ($c =~ /(?:^|\n)[ \+]\s*(?:$Type\s*)?\Q$testval\E\s*=\s*(?:\([^\)]*\)\s*)?\s*(?:devm_)?(?:[kv][czm]alloc(?:_node|_array)?\b|kstrdup|(?:dev_)?alloc_skb)/) {
4725                                 WARN("OOM_MESSAGE",
4726                                      "Possible unnecessary 'out of memory' message\n" . $hereprev);
4727                         }
4728                 }
4729
4730 # check for logging functions with KERN_<LEVEL>
4731                 if ($line !~ /printk(?:_ratelimited|_once)?\s*\(/ &&
4732                     $line =~ /\b$logFunctions\s*\(.*\b(KERN_[A-Z]+)\b/) {
4733                         my $level = $1;
4734                         if (WARN("UNNECESSARY_KERN_LEVEL",
4735                                  "Possible unnecessary $level\n" . $herecurr) &&
4736                             $fix) {
4737                                 $fixed[$fixlinenr] =~ s/\s*$level\s*//;
4738                         }
4739                 }
4740
4741 # check for mask then right shift without a parentheses
4742                 if ($^V && $^V ge 5.10.0 &&
4743                     $line =~ /$LvalOrFunc\s*\&\s*($LvalOrFunc)\s*>>/ &&
4744                     $4 !~ /^\&/) { # $LvalOrFunc may be &foo, ignore if so
4745                         WARN("MASK_THEN_SHIFT",
4746                              "Possible precedence defect with mask then right shift - may need parentheses\n" . $herecurr);
4747                 }
4748
4749 # check for pointer comparisons to NULL
4750                 if ($^V && $^V ge 5.10.0) {
4751                         while ($line =~ /\b$LvalOrFunc\s*(==|\!=)\s*NULL\b/g) {
4752                                 my $val = $1;
4753                                 my $equal = "!";
4754                                 $equal = "" if ($4 eq "!=");
4755                                 if (CHK("COMPARISON_TO_NULL",
4756                                         "Comparison to NULL could be written \"${equal}${val}\"\n" . $herecurr) &&
4757                                             $fix) {
4758                                         $fixed[$fixlinenr] =~ s/\b\Q$val\E\s*(?:==|\!=)\s*NULL\b/$equal$val/;
4759                                 }
4760                         }
4761                 }
4762
4763 # check for bad placement of section $InitAttribute (e.g.: __initdata)
4764                 if ($line =~ /(\b$InitAttribute\b)/) {
4765                         my $attr = $1;
4766                         if ($line =~ /^\+\s*static\s+(?:const\s+)?(?:$attr\s+)?($NonptrTypeWithAttr)\s+(?:$attr\s+)?($Ident(?:\[[^]]*\])?)\s*[=;]/) {
4767                                 my $ptr = $1;
4768                                 my $var = $2;
4769                                 if ((($ptr =~ /\b(union|struct)\s+$attr\b/ &&
4770                                       ERROR("MISPLACED_INIT",
4771                                             "$attr should be placed after $var\n" . $herecurr)) ||
4772                                      ($ptr !~ /\b(union|struct)\s+$attr\b/ &&
4773                                       WARN("MISPLACED_INIT",
4774                                            "$attr should be placed after $var\n" . $herecurr))) &&
4775                                     $fix) {
4776                                         $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;
4777                                 }
4778                         }
4779                 }
4780
4781 # check for $InitAttributeData (ie: __initdata) with const
4782                 if ($line =~ /\bconst\b/ && $line =~ /($InitAttributeData)/) {
4783                         my $attr = $1;
4784                         $attr =~ /($InitAttributePrefix)(.*)/;
4785                         my $attr_prefix = $1;
4786                         my $attr_type = $2;
4787                         if (ERROR("INIT_ATTRIBUTE",
4788                                   "Use of const init definition must use ${attr_prefix}initconst\n" . $herecurr) &&
4789                             $fix) {
4790                                 $fixed[$fixlinenr] =~
4791                                     s/$InitAttributeData/${attr_prefix}initconst/;
4792                         }
4793                 }
4794
4795 # check for $InitAttributeConst (ie: __initconst) without const
4796                 if ($line !~ /\bconst\b/ && $line =~ /($InitAttributeConst)/) {
4797                         my $attr = $1;
4798                         if (ERROR("INIT_ATTRIBUTE",
4799                                   "Use of $attr requires a separate use of const\n" . $herecurr) &&
4800                             $fix) {
4801                                 my $lead = $fixed[$fixlinenr] =~
4802                                     /(^\+\s*(?:static\s+))/;
4803                                 $lead = rtrim($1);
4804                                 $lead = "$lead " if ($lead !~ /^\+$/);
4805                                 $lead = "${lead}const ";
4806                                 $fixed[$fixlinenr] =~ s/(^\+\s*(?:static\s+))/$lead/;
4807                         }
4808                 }
4809
4810 # check for __read_mostly with const non-pointer (should just be const)
4811                 if ($line =~ /\b__read_mostly\b/ &&
4812                     $line =~ /($Type)\s*$Ident/ && $1 !~ /\*\s*$/ && $1 =~ /\bconst\b/) {
4813                         if (ERROR("CONST_READ_MOSTLY",
4814                                   "Invalid use of __read_mostly with const type\n" . $herecurr) &&
4815                             $fix) {
4816                                 $fixed[$fixlinenr] =~ s/\s+__read_mostly\b//;
4817                         }
4818                 }
4819
4820 # don't use __constant_<foo> functions outside of include/uapi/
4821                 if ($realfile !~ m@^include/uapi/@ &&
4822                     $line =~ /(__constant_(?:htons|ntohs|[bl]e(?:16|32|64)_to_cpu|cpu_to_[bl]e(?:16|32|64)))\s*\(/) {
4823                         my $constant_func = $1;
4824                         my $func = $constant_func;
4825                         $func =~ s/^__constant_//;
4826                         if (WARN("CONSTANT_CONVERSION",
4827                                  "$constant_func should be $func\n" . $herecurr) &&
4828                             $fix) {
4829                                 $fixed[$fixlinenr] =~ s/\b$constant_func\b/$func/g;
4830                         }
4831                 }
4832
4833 # prefer usleep_range over udelay
4834                 if ($line =~ /\budelay\s*\(\s*(\d+)\s*\)/) {
4835                         my $delay = $1;
4836                         # ignore udelay's < 10, however
4837                         if (! ($delay < 10) ) {
4838                                 CHK("USLEEP_RANGE",
4839                                     "usleep_range is preferred over udelay; see Documentation/timers/timers-howto.txt\n" . $herecurr);
4840                         }
4841                         if ($delay > 2000) {
4842                                 WARN("LONG_UDELAY",
4843                                      "long udelay - prefer mdelay; see arch/arm/include/asm/delay.h\n" . $herecurr);
4844                         }
4845                 }
4846
4847 # warn about unexpectedly long msleep's
4848                 if ($line =~ /\bmsleep\s*\((\d+)\);/) {
4849                         if ($1 < 20) {
4850                                 WARN("MSLEEP",
4851                                      "msleep < 20ms can sleep for up to 20ms; see Documentation/timers/timers-howto.txt\n" . $herecurr);
4852                         }
4853                 }
4854
4855 # check for comparisons of jiffies
4856                 if ($line =~ /\bjiffies\s*$Compare|$Compare\s*jiffies\b/) {
4857                         WARN("JIFFIES_COMPARISON",
4858                              "Comparing jiffies is almost always wrong; prefer time_after, time_before and friends\n" . $herecurr);
4859                 }
4860
4861 # check for comparisons of get_jiffies_64()
4862                 if ($line =~ /\bget_jiffies_64\s*\(\s*\)\s*$Compare|$Compare\s*get_jiffies_64\s*\(\s*\)/) {
4863                         WARN("JIFFIES_COMPARISON",
4864                              "Comparing get_jiffies_64() is almost always wrong; prefer time_after64, time_before64 and friends\n" . $herecurr);
4865                 }
4866
4867 # warn about #ifdefs in C files
4868 #               if ($line =~ /^.\s*\#\s*if(|n)def/ && ($realfile =~ /\.c$/)) {
4869 #                       print "#ifdef in C files should be avoided\n";
4870 #                       print "$herecurr";
4871 #                       $clean = 0;
4872 #               }
4873
4874 # warn about spacing in #ifdefs
4875                 if ($line =~ /^.\s*\#\s*(ifdef|ifndef|elif)\s\s+/) {
4876                         if (ERROR("SPACING",
4877                                   "exactly one space required after that #$1\n" . $herecurr) &&
4878                             $fix) {
4879                                 $fixed[$fixlinenr] =~
4880                                     s/^(.\s*\#\s*(ifdef|ifndef|elif))\s{2,}/$1 /;
4881                         }
4882
4883                 }
4884
4885 # check for spinlock_t definitions without a comment.
4886                 if ($line =~ /^.\s*(struct\s+mutex|spinlock_t)\s+\S+;/ ||
4887                     $line =~ /^.\s*(DEFINE_MUTEX)\s*\(/) {
4888                         my $which = $1;
4889                         if (!ctx_has_comment($first_line, $linenr)) {
4890                                 CHK("UNCOMMENTED_DEFINITION",
4891                                     "$1 definition without comment\n" . $herecurr);
4892                         }
4893                 }
4894 # check for memory barriers without a comment.
4895                 if ($line =~ /\b(mb|rmb|wmb|read_barrier_depends|smp_mb|smp_rmb|smp_wmb|smp_read_barrier_depends)\(/) {
4896                         if (!ctx_has_comment($first_line, $linenr)) {
4897                                 WARN("MEMORY_BARRIER",
4898                                      "memory barrier without comment\n" . $herecurr);
4899                         }
4900                 }
4901 # check of hardware specific defines
4902                 if ($line =~ m@^.\s*\#\s*if.*\b(__i386__|__powerpc64__|__sun__|__s390x__)\b@ && $realfile !~ m@include/asm-@) {
4903                         CHK("ARCH_DEFINES",
4904                             "architecture specific defines should be avoided\n" .  $herecurr);
4905                 }
4906
4907 # Check that the storage class is at the beginning of a declaration
4908                 if ($line =~ /\b$Storage\b/ && $line !~ /^.\s*$Storage\b/) {
4909                         WARN("STORAGE_CLASS",
4910                              "storage class should be at the beginning of the declaration\n" . $herecurr)
4911                 }
4912
4913 # check the location of the inline attribute, that it is between
4914 # storage class and type.
4915                 if ($line =~ /\b$Type\s+$Inline\b/ ||
4916                     $line =~ /\b$Inline\s+$Storage\b/) {
4917                         ERROR("INLINE_LOCATION",
4918                               "inline keyword should sit between storage class and type\n" . $herecurr);
4919                 }
4920
4921 # Check for __inline__ and __inline, prefer inline
4922                 if ($realfile !~ m@\binclude/uapi/@ &&
4923                     $line =~ /\b(__inline__|__inline)\b/) {
4924                         if (WARN("INLINE",
4925                                  "plain inline is preferred over $1\n" . $herecurr) &&
4926                             $fix) {
4927                                 $fixed[$fixlinenr] =~ s/\b(__inline__|__inline)\b/inline/;
4928
4929                         }
4930                 }
4931
4932 # Check for __attribute__ packed, prefer __packed
4933                 if ($realfile !~ m@\binclude/uapi/@ &&
4934                     $line =~ /\b__attribute__\s*\(\s*\(.*\bpacked\b/) {
4935                         WARN("PREFER_PACKED",
4936                              "__packed is preferred over __attribute__((packed))\n" . $herecurr);
4937                 }
4938
4939 # Check for __attribute__ aligned, prefer __aligned
4940                 if ($realfile !~ m@\binclude/uapi/@ &&
4941                     $line =~ /\b__attribute__\s*\(\s*\(.*aligned/) {
4942                         WARN("PREFER_ALIGNED",
4943                              "__aligned(size) is preferred over __attribute__((aligned(size)))\n" . $herecurr);
4944                 }
4945
4946 # Check for __attribute__ format(printf, prefer __printf
4947                 if ($realfile !~ m@\binclude/uapi/@ &&
4948                     $line =~ /\b__attribute__\s*\(\s*\(\s*format\s*\(\s*printf/) {
4949                         if (WARN("PREFER_PRINTF",
4950                                  "__printf(string-index, first-to-check) is preferred over __attribute__((format(printf, string-index, first-to-check)))\n" . $herecurr) &&
4951                             $fix) {
4952                                 $fixed[$fixlinenr] =~ s/\b__attribute__\s*\(\s*\(\s*format\s*\(\s*printf\s*,\s*(.*)\)\s*\)\s*\)/"__printf(" . trim($1) . ")"/ex;
4953
4954                         }
4955                 }
4956
4957 # Check for __attribute__ format(scanf, prefer __scanf
4958                 if ($realfile !~ m@\binclude/uapi/@ &&
4959                     $line =~ /\b__attribute__\s*\(\s*\(\s*format\s*\(\s*scanf\b/) {
4960                         if (WARN("PREFER_SCANF",
4961                                  "__scanf(string-index, first-to-check) is preferred over __attribute__((format(scanf, string-index, first-to-check)))\n" . $herecurr) &&
4962                             $fix) {
4963                                 $fixed[$fixlinenr] =~ s/\b__attribute__\s*\(\s*\(\s*format\s*\(\s*scanf\s*,\s*(.*)\)\s*\)\s*\)/"__scanf(" . trim($1) . ")"/ex;
4964                         }
4965                 }
4966
4967 # Check for __attribute__ weak, or __weak declarations (may have link issues)
4968                 if ($^V && $^V ge 5.10.0 &&
4969                     $line =~ /(?:$Declare|$DeclareMisordered)\s*$Ident\s*$balanced_parens\s*(?:$Attribute)?\s*;/ &&
4970                     ($line =~ /\b__attribute__\s*\(\s*\(.*\bweak\b/ ||
4971                      $line =~ /\b__weak\b/)) {
4972                         ERROR("WEAK_DECLARATION",
4973                               "Using weak declarations can have unintended link defects\n" . $herecurr);
4974                 }
4975
4976 # check for sizeof(&)
4977                 if ($line =~ /\bsizeof\s*\(\s*\&/) {
4978                         WARN("SIZEOF_ADDRESS",
4979                              "sizeof(& should be avoided\n" . $herecurr);
4980                 }
4981
4982 # check for sizeof without parenthesis
4983                 if ($line =~ /\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/) {
4984                         if (WARN("SIZEOF_PARENTHESIS",
4985                                  "sizeof $1 should be sizeof($1)\n" . $herecurr) &&
4986                             $fix) {
4987                                 $fixed[$fixlinenr] =~ s/\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/"sizeof(" . trim($1) . ")"/ex;
4988                         }
4989                 }
4990
4991 # check for struct spinlock declarations
4992                 if ($line =~ /^.\s*\bstruct\s+spinlock\s+\w+\s*;/) {
4993                         WARN("USE_SPINLOCK_T",
4994                              "struct spinlock should be spinlock_t\n" . $herecurr);
4995                 }
4996
4997 # check for seq_printf uses that could be seq_puts
4998                 if ($sline =~ /\bseq_printf\s*\(.*"\s*\)\s*;\s*$/) {
4999                         my $fmt = get_quoted_string($line, $rawline);
5000                         $fmt =~ s/%%//g;
5001                         if ($fmt !~ /%/) {
5002                                 if (WARN("PREFER_SEQ_PUTS",
5003                                          "Prefer seq_puts to seq_printf\n" . $herecurr) &&
5004                                     $fix) {
5005                                         $fixed[$fixlinenr] =~ s/\bseq_printf\b/seq_puts/;
5006                                 }
5007                         }
5008                 }
5009
5010 # Check for misused memsets
5011                 if ($^V && $^V ge 5.10.0 &&
5012                     defined $stat &&
5013                     $stat =~ /^\+(?:.*?)\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*$FuncArg\s*\)/s) {
5014
5015                         my $ms_addr = $2;
5016                         my $ms_val = $7;
5017                         my $ms_size = $12;
5018
5019                         if ($ms_size =~ /^(0x|)0$/i) {
5020                                 ERROR("MEMSET",
5021                                       "memset to 0's uses 0 as the 2nd argument, not the 3rd\n" . "$here\n$stat\n");
5022                         } elsif ($ms_size =~ /^(0x|)1$/i) {
5023                                 WARN("MEMSET",
5024                                      "single byte memset is suspicious. Swapped 2nd/3rd argument?\n" . "$here\n$stat\n");
5025                         }
5026                 }
5027
5028 # Check for memcpy(foo, bar, ETH_ALEN) that could be ether_addr_copy(foo, bar)
5029                 if ($^V && $^V ge 5.10.0 &&
5030                     $line =~ /^\+(?:.*?)\bmemcpy\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/s) {
5031                         if (WARN("PREFER_ETHER_ADDR_COPY",
5032                                  "Prefer ether_addr_copy() over memcpy() if the Ethernet addresses are __aligned(2)\n" . $herecurr) &&
5033                             $fix) {
5034                                 $fixed[$fixlinenr] =~ s/\bmemcpy\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/ether_addr_copy($2, $7)/;
5035                         }
5036                 }
5037
5038 # typecasts on min/max could be min_t/max_t
5039                 if ($^V && $^V ge 5.10.0 &&
5040                     defined $stat &&
5041                     $stat =~ /^\+(?:.*?)\b(min|max)\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\)/) {
5042                         if (defined $2 || defined $7) {
5043                                 my $call = $1;
5044                                 my $cast1 = deparenthesize($2);
5045                                 my $arg1 = $3;
5046                                 my $cast2 = deparenthesize($7);
5047                                 my $arg2 = $8;
5048                                 my $cast;
5049
5050                                 if ($cast1 ne "" && $cast2 ne "" && $cast1 ne $cast2) {
5051                                         $cast = "$cast1 or $cast2";
5052                                 } elsif ($cast1 ne "") {
5053                                         $cast = $cast1;
5054                                 } else {
5055                                         $cast = $cast2;
5056                                 }
5057                                 WARN("MINMAX",
5058                                      "$call() should probably be ${call}_t($cast, $arg1, $arg2)\n" . "$here\n$stat\n");
5059                         }
5060                 }
5061
5062 # check usleep_range arguments
5063                 if ($^V && $^V ge 5.10.0 &&
5064                     defined $stat &&
5065                     $stat =~ /^\+(?:.*?)\busleep_range\s*\(\s*($FuncArg)\s*,\s*($FuncArg)\s*\)/) {
5066                         my $min = $1;
5067                         my $max = $7;
5068                         if ($min eq $max) {
5069                                 WARN("USLEEP_RANGE",
5070                                      "usleep_range should not use min == max args; see Documentation/timers/timers-howto.txt\n" . "$here\n$stat\n");
5071                         } elsif ($min =~ /^\d+$/ && $max =~ /^\d+$/ &&
5072                                  $min > $max) {
5073                                 WARN("USLEEP_RANGE",
5074                                      "usleep_range args reversed, use min then max; see Documentation/timers/timers-howto.txt\n" . "$here\n$stat\n");
5075                         }
5076                 }
5077
5078 # check for naked sscanf
5079                 if ($^V && $^V ge 5.10.0 &&
5080                     defined $stat &&
5081                     $line =~ /\bsscanf\b/ &&
5082                     ($stat !~ /$Ident\s*=\s*sscanf\s*$balanced_parens/ &&
5083                      $stat !~ /\bsscanf\s*$balanced_parens\s*(?:$Compare)/ &&
5084                      $stat !~ /(?:$Compare)\s*\bsscanf\s*$balanced_parens/)) {
5085                         my $lc = $stat =~ tr@\n@@;
5086                         $lc = $lc + $linenr;
5087                         my $stat_real = raw_line($linenr, 0);
5088                         for (my $count = $linenr + 1; $count <= $lc; $count++) {
5089                                 $stat_real = $stat_real . "\n" . raw_line($count, 0);
5090                         }
5091                         WARN("NAKED_SSCANF",
5092                              "unchecked sscanf return value\n" . "$here\n$stat_real\n");
5093                 }
5094
5095 # check for simple sscanf that should be kstrto<foo>
5096                 if ($^V && $^V ge 5.10.0 &&
5097                     defined $stat &&
5098                     $line =~ /\bsscanf\b/) {
5099                         my $lc = $stat =~ tr@\n@@;
5100                         $lc = $lc + $linenr;
5101                         my $stat_real = raw_line($linenr, 0);
5102                         for (my $count = $linenr + 1; $count <= $lc; $count++) {
5103                                 $stat_real = $stat_real . "\n" . raw_line($count, 0);
5104                         }
5105                         if ($stat_real =~ /\bsscanf\b\s*\(\s*$FuncArg\s*,\s*("[^"]+")/) {
5106                                 my $format = $6;
5107                                 my $count = $format =~ tr@%@%@;
5108                                 if ($count == 1 &&
5109                                     $format =~ /^"\%(?i:ll[udxi]|[udxi]ll|ll|[hl]h?[udxi]|[udxi][hl]h?|[hl]h?|[udxi])"$/) {
5110                                         WARN("SSCANF_TO_KSTRTO",
5111                                              "Prefer kstrto<type> to single variable sscanf\n" . "$here\n$stat_real\n");
5112                                 }
5113                         }
5114                 }
5115
5116 # check for new externs in .h files.
5117                 if ($realfile =~ /\.h$/ &&
5118                     $line =~ /^\+\s*(extern\s+)$Type\s*$Ident\s*\(/s) {
5119                         if (CHK("AVOID_EXTERNS",
5120                                 "extern prototypes should be avoided in .h files\n" . $herecurr) &&
5121                             $fix) {
5122                                 $fixed[$fixlinenr] =~ s/(.*)\bextern\b\s*(.*)/$1$2/;
5123                         }
5124                 }
5125
5126 # check for new externs in .c files.
5127                 if ($realfile =~ /\.c$/ && defined $stat &&
5128                     $stat =~ /^.\s*(?:extern\s+)?$Type\s+($Ident)(\s*)\(/s)
5129                 {
5130                         my $function_name = $1;
5131                         my $paren_space = $2;
5132
5133                         my $s = $stat;
5134                         if (defined $cond) {
5135                                 substr($s, 0, length($cond), '');
5136                         }
5137                         if ($s =~ /^\s*;/ &&
5138                             $function_name ne 'uninitialized_var')
5139                         {
5140                                 WARN("AVOID_EXTERNS",
5141                                      "externs should be avoided in .c files\n" .  $herecurr);
5142                         }
5143
5144                         if ($paren_space =~ /\n/) {
5145                                 WARN("FUNCTION_ARGUMENTS",
5146                                      "arguments for function declarations should follow identifier\n" . $herecurr);
5147                         }
5148
5149                 } elsif ($realfile =~ /\.c$/ && defined $stat &&
5150                     $stat =~ /^.\s*extern\s+/)
5151                 {
5152                         WARN("AVOID_EXTERNS",
5153                              "externs should be avoided in .c files\n" .  $herecurr);
5154                 }
5155
5156 # checks for new __setup's
5157                 if ($rawline =~ /\b__setup\("([^"]*)"/) {
5158                         my $name = $1;
5159
5160                         if (!grep(/$name/, @setup_docs)) {
5161                                 CHK("UNDOCUMENTED_SETUP",
5162                                     "__setup appears un-documented -- check Documentation/kernel-parameters.txt\n" . $herecurr);
5163                         }
5164                 }
5165
5166 # check for pointless casting of kmalloc return
5167                 if ($line =~ /\*\s*\)\s*[kv][czm]alloc(_node){0,1}\b/) {
5168                         WARN("UNNECESSARY_CASTS",
5169                              "unnecessary cast may hide bugs, see http://c-faq.com/malloc/mallocnocast.html\n" . $herecurr);
5170                 }
5171
5172 # alloc style
5173 # p = alloc(sizeof(struct foo), ...) should be p = alloc(sizeof(*p), ...)
5174                 if ($^V && $^V ge 5.10.0 &&
5175                     $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*([kv][mz]alloc(?:_node)?)\s*\(\s*(sizeof\s*\(\s*struct\s+$Lval\s*\))/) {
5176                         CHK("ALLOC_SIZEOF_STRUCT",
5177                             "Prefer $3(sizeof(*$1)...) over $3($4...)\n" . $herecurr);
5178                 }
5179
5180 # check for k[mz]alloc with multiplies that could be kmalloc_array/kcalloc
5181                 if ($^V && $^V ge 5.10.0 &&
5182                     $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*(k[mz]alloc)\s*\(\s*($FuncArg)\s*\*\s*($FuncArg)\s*,/) {
5183                         my $oldfunc = $3;
5184                         my $a1 = $4;
5185                         my $a2 = $10;
5186                         my $newfunc = "kmalloc_array";
5187                         $newfunc = "kcalloc" if ($oldfunc eq "kzalloc");
5188                         my $r1 = $a1;
5189                         my $r2 = $a2;
5190                         if ($a1 =~ /^sizeof\s*\S/) {
5191                                 $r1 = $a2;
5192                                 $r2 = $a1;
5193                         }
5194                         if ($r1 !~ /^sizeof\b/ && $r2 =~ /^sizeof\s*\S/ &&
5195                             !($r1 =~ /^$Constant$/ || $r1 =~ /^[A-Z_][A-Z0-9_]*$/)) {
5196                                 if (WARN("ALLOC_WITH_MULTIPLY",
5197                                          "Prefer $newfunc over $oldfunc with multiply\n" . $herecurr) &&
5198                                     $fix) {
5199                                         $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;
5200
5201                                 }
5202                         }
5203                 }
5204
5205 # check for krealloc arg reuse
5206                 if ($^V && $^V ge 5.10.0 &&
5207                     $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*krealloc\s*\(\s*\1\s*,/) {
5208                         WARN("KREALLOC_ARG_REUSE",
5209                              "Reusing the krealloc arg is almost always a bug\n" . $herecurr);
5210                 }
5211
5212 # check for alloc argument mismatch
5213                 if ($line =~ /\b(kcalloc|kmalloc_array)\s*\(\s*sizeof\b/) {
5214                         WARN("ALLOC_ARRAY_ARGS",
5215                              "$1 uses number as first arg, sizeof is generally wrong\n" . $herecurr);
5216                 }
5217
5218 # check for multiple semicolons
5219                 if ($line =~ /;\s*;\s*$/) {
5220                         if (WARN("ONE_SEMICOLON",
5221                                  "Statements terminations use 1 semicolon\n" . $herecurr) &&
5222                             $fix) {
5223                                 $fixed[$fixlinenr] =~ s/(\s*;\s*){2,}$/;/g;
5224                         }
5225                 }
5226
5227 # check for #defines like: 1 << <digit> that could be BIT(digit)
5228                 if ($line =~ /#\s*define\s+\w+\s+\(?\s*1\s*([ulUL]*)\s*\<\<\s*(?:\d+|$Ident)\s*\)?/) {
5229                         my $ull = "";
5230                         $ull = "_ULL" if (defined($1) && $1 =~ /ll/i);
5231                         if (CHK("BIT_MACRO",
5232                                 "Prefer using the BIT$ull macro\n" . $herecurr) &&
5233                             $fix) {
5234                                 $fixed[$fixlinenr] =~ s/\(?\s*1\s*[ulUL]*\s*<<\s*(\d+|$Ident)\s*\)?/BIT${ull}($1)/;
5235                         }
5236                 }
5237
5238 # check for case / default statements not preceded by break/fallthrough/switch
5239                 if ($line =~ /^.\s*(?:case\s+(?:$Ident|$Constant)\s*|default):/) {
5240                         my $has_break = 0;
5241                         my $has_statement = 0;
5242                         my $count = 0;
5243                         my $prevline = $linenr;
5244                         while ($prevline > 1 && ($file || $count < 3) && !$has_break) {
5245                                 $prevline--;
5246                                 my $rline = $rawlines[$prevline - 1];
5247                                 my $fline = $lines[$prevline - 1];
5248                                 last if ($fline =~ /^\@\@/);
5249                                 next if ($fline =~ /^\-/);
5250                                 next if ($fline =~ /^.(?:\s*(?:case\s+(?:$Ident|$Constant)[\s$;]*|default):[\s$;]*)*$/);
5251                                 $has_break = 1 if ($rline =~ /fall[\s_-]*(through|thru)/i);
5252                                 next if ($fline =~ /^.[\s$;]*$/);
5253                                 $has_statement = 1;
5254                                 $count++;
5255                                 $has_break = 1 if ($fline =~ /\bswitch\b|\b(?:break\s*;[\s$;]*$|return\b|goto\b|continue\b)/);
5256                         }
5257                         if (!$has_break && $has_statement) {
5258                                 WARN("MISSING_BREAK",
5259                                      "Possible switch case/default not preceeded by break or fallthrough comment\n" . $herecurr);
5260                         }
5261                 }
5262
5263 # check for switch/default statements without a break;
5264                 if ($^V && $^V ge 5.10.0 &&
5265                     defined $stat &&
5266                     $stat =~ /^\+[$;\s]*(?:case[$;\s]+\w+[$;\s]*:[$;\s]*|)*[$;\s]*\bdefault[$;\s]*:[$;\s]*;/g) {
5267                         my $ctx = '';
5268                         my $herectx = $here . "\n";
5269                         my $cnt = statement_rawlines($stat);
5270                         for (my $n = 0; $n < $cnt; $n++) {
5271                                 $herectx .= raw_line($linenr, $n) . "\n";
5272                         }
5273                         WARN("DEFAULT_NO_BREAK",
5274                              "switch default: should use break\n" . $herectx);
5275                 }
5276
5277 # check for gcc specific __FUNCTION__
5278                 if ($line =~ /\b__FUNCTION__\b/) {
5279                         if (WARN("USE_FUNC",
5280                                  "__func__ should be used instead of gcc specific __FUNCTION__\n"  . $herecurr) &&
5281                             $fix) {
5282                                 $fixed[$fixlinenr] =~ s/\b__FUNCTION__\b/__func__/g;
5283                         }
5284                 }
5285
5286 # check for uses of __DATE__, __TIME__, __TIMESTAMP__
5287                 while ($line =~ /\b(__(?:DATE|TIME|TIMESTAMP)__)\b/g) {
5288                         ERROR("DATE_TIME",
5289                               "Use of the '$1' macro makes the build non-deterministic\n" . $herecurr);
5290                 }
5291
5292 # check for use of yield()
5293                 if ($line =~ /\byield\s*\(\s*\)/) {
5294                         WARN("YIELD",
5295                              "Using yield() is generally wrong. See yield() kernel-doc (sched/core.c)\n"  . $herecurr);
5296                 }
5297
5298 # check for comparisons against true and false
5299                 if ($line =~ /\+\s*(.*?)\b(true|false|$Lval)\s*(==|\!=)\s*(true|false|$Lval)\b(.*)$/i) {
5300                         my $lead = $1;
5301                         my $arg = $2;
5302                         my $test = $3;
5303                         my $otype = $4;
5304                         my $trail = $5;
5305                         my $op = "!";
5306
5307                         ($arg, $otype) = ($otype, $arg) if ($arg =~ /^(?:true|false)$/i);
5308
5309                         my $type = lc($otype);
5310                         if ($type =~ /^(?:true|false)$/) {
5311                                 if (("$test" eq "==" && "$type" eq "true") ||
5312                                     ("$test" eq "!=" && "$type" eq "false")) {
5313                                         $op = "";
5314                                 }
5315
5316                                 CHK("BOOL_COMPARISON",
5317                                     "Using comparison to $otype is error prone\n" . $herecurr);
5318
5319 ## maybe suggesting a correct construct would better
5320 ##                                  "Using comparison to $otype is error prone.  Perhaps use '${lead}${op}${arg}${trail}'\n" . $herecurr);
5321
5322                         }
5323                 }
5324
5325 # check for semaphores initialized locked
5326                 if ($line =~ /^.\s*sema_init.+,\W?0\W?\)/) {
5327                         WARN("CONSIDER_COMPLETION",
5328                              "consider using a completion\n" . $herecurr);
5329                 }
5330
5331 # recommend kstrto* over simple_strto* and strict_strto*
5332                 if ($line =~ /\b((simple|strict)_(strto(l|ll|ul|ull)))\s*\(/) {
5333                         WARN("CONSIDER_KSTRTO",
5334                              "$1 is obsolete, use k$3 instead\n" . $herecurr);
5335                 }
5336
5337 # check for __initcall(), use device_initcall() explicitly or more appropriate function please
5338                 if ($line =~ /^.\s*__initcall\s*\(/) {
5339                         WARN("USE_DEVICE_INITCALL",
5340                              "please use device_initcall() or more appropriate function instead of __initcall() (see include/linux/init.h)\n" . $herecurr);
5341                 }
5342
5343 # check for various structs that are normally const (ops, kgdb, device_tree)
5344                 my $const_structs = qr{
5345                                 acpi_dock_ops|
5346                                 address_space_operations|
5347                                 backlight_ops|
5348                                 block_device_operations|
5349                                 dentry_operations|
5350                                 dev_pm_ops|
5351                                 dma_map_ops|
5352                                 extent_io_ops|
5353                                 file_lock_operations|
5354                                 file_operations|
5355                                 hv_ops|
5356                                 ide_dma_ops|
5357                                 intel_dvo_dev_ops|
5358                                 item_operations|
5359                                 iwl_ops|
5360                                 kgdb_arch|
5361                                 kgdb_io|
5362                                 kset_uevent_ops|
5363                                 lock_manager_operations|
5364                                 microcode_ops|
5365                                 mtrr_ops|
5366                                 neigh_ops|
5367                                 nlmsvc_binding|
5368                                 of_device_id|
5369                                 pci_raw_ops|
5370                                 pipe_buf_operations|
5371                                 platform_hibernation_ops|
5372                                 platform_suspend_ops|
5373                                 proto_ops|
5374                                 rpc_pipe_ops|
5375                                 seq_operations|
5376                                 snd_ac97_build_ops|
5377                                 soc_pcmcia_socket_ops|
5378                                 stacktrace_ops|
5379                                 sysfs_ops|
5380                                 tty_operations|
5381                                 uart_ops|
5382                                 usb_mon_operations|
5383                                 wd_ops}x;
5384                 if ($line !~ /\bconst\b/ &&
5385                     $line =~ /\bstruct\s+($const_structs)\b/) {
5386                         WARN("CONST_STRUCT",
5387                              "struct $1 should normally be const\n" .
5388                                 $herecurr);
5389                 }
5390
5391 # use of NR_CPUS is usually wrong
5392 # ignore definitions of NR_CPUS and usage to define arrays as likely right
5393                 if ($line =~ /\bNR_CPUS\b/ &&
5394                     $line !~ /^.\s*\s*#\s*if\b.*\bNR_CPUS\b/ &&
5395                     $line !~ /^.\s*\s*#\s*define\b.*\bNR_CPUS\b/ &&
5396                     $line !~ /^.\s*$Declare\s.*\[[^\]]*NR_CPUS[^\]]*\]/ &&
5397                     $line !~ /\[[^\]]*\.\.\.[^\]]*NR_CPUS[^\]]*\]/ &&
5398                     $line !~ /\[[^\]]*NR_CPUS[^\]]*\.\.\.[^\]]*\]/)
5399                 {
5400                         WARN("NR_CPUS",
5401                              "usage of NR_CPUS is often wrong - consider using cpu_possible(), num_possible_cpus(), for_each_possible_cpu(), etc\n" . $herecurr);
5402                 }
5403
5404 # Use of __ARCH_HAS_<FOO> or ARCH_HAVE_<BAR> is wrong.
5405                 if ($line =~ /\+\s*#\s*define\s+((?:__)?ARCH_(?:HAS|HAVE)\w*)\b/) {
5406                         ERROR("DEFINE_ARCH_HAS",
5407                               "#define of '$1' is wrong - use Kconfig variables or standard guards instead\n" . $herecurr);
5408                 }
5409
5410 # likely/unlikely comparisons similar to "(likely(foo) > 0)"
5411                 if ($^V && $^V ge 5.10.0 &&
5412                     $line =~ /\b((?:un)?likely)\s*\(\s*$FuncArg\s*\)\s*$Compare/) {
5413                         WARN("LIKELY_MISUSE",
5414                              "Using $1 should generally have parentheses around the comparison\n" . $herecurr);
5415                 }
5416
5417 # whine mightly about in_atomic
5418                 if ($line =~ /\bin_atomic\s*\(/) {
5419                         if ($realfile =~ m@^drivers/@) {
5420                                 ERROR("IN_ATOMIC",
5421                                       "do not use in_atomic in drivers\n" . $herecurr);
5422                         } elsif ($realfile !~ m@^kernel/@) {
5423                                 WARN("IN_ATOMIC",
5424                                      "use of in_atomic() is incorrect outside core kernel code\n" . $herecurr);
5425                         }
5426                 }
5427
5428 # check for lockdep_set_novalidate_class
5429                 if ($line =~ /^.\s*lockdep_set_novalidate_class\s*\(/ ||
5430                     $line =~ /__lockdep_no_validate__\s*\)/ ) {
5431                         if ($realfile !~ m@^kernel/lockdep@ &&
5432                             $realfile !~ m@^include/linux/lockdep@ &&
5433                             $realfile !~ m@^drivers/base/core@) {
5434                                 ERROR("LOCKDEP",
5435                                       "lockdep_no_validate class is reserved for device->mutex.\n" . $herecurr);
5436                         }
5437                 }
5438
5439                 if ($line =~ /debugfs_create_\w+.*\b$mode_perms_world_writable\b/ ||
5440                     $line =~ /DEVICE_ATTR.*\b$mode_perms_world_writable\b/) {
5441                         WARN("EXPORTED_WORLD_WRITABLE",
5442                              "Exporting world writable files is usually an error. Consider more restrictive permissions.\n" . $herecurr);
5443                 }
5444
5445 # Mode permission misuses where it seems decimal should be octal
5446 # This uses a shortcut match to avoid unnecessary uses of a slow foreach loop
5447                 if ($^V && $^V ge 5.10.0 &&
5448                     $line =~ /$mode_perms_search/) {
5449                         foreach my $entry (@mode_permission_funcs) {
5450                                 my $func = $entry->[0];
5451                                 my $arg_pos = $entry->[1];
5452
5453                                 my $skip_args = "";
5454                                 if ($arg_pos > 1) {
5455                                         $arg_pos--;
5456                                         $skip_args = "(?:\\s*$FuncArg\\s*,\\s*){$arg_pos,$arg_pos}";
5457                                 }
5458                                 my $test = "\\b$func\\s*\\(${skip_args}([\\d]+)\\s*[,\\)]";
5459                                 if ($line =~ /$test/) {
5460                                         my $val = $1;
5461                                         $val = $6 if ($skip_args ne "");
5462
5463                                         if ($val !~ /^0$/ &&
5464                                             (($val =~ /^$Int$/ && $val !~ /^$Octal$/) ||
5465                                              length($val) ne 4)) {
5466                                                 ERROR("NON_OCTAL_PERMISSIONS",
5467                                                       "Use 4 digit octal (0777) not decimal permissions\n" . $herecurr);
5468                                         } elsif ($val =~ /^$Octal$/ && (oct($val) & 02)) {
5469                                                 ERROR("EXPORTED_WORLD_WRITABLE",
5470                                                       "Exporting writable files is usually an error. Consider more restrictive permissions.\n" . $herecurr);
5471                                         }
5472                                 }
5473                         }
5474                 }
5475         }
5476
5477         # If we have no input at all, then there is nothing to report on
5478         # so just keep quiet.
5479         if ($#rawlines == -1) {
5480                 exit(0);
5481         }
5482
5483         # In mailback mode only produce a report in the negative, for
5484         # things that appear to be patches.
5485         if ($mailback && ($clean == 1 || !$is_patch)) {
5486                 exit(0);
5487         }
5488
5489         # This is not a patch, and we are are in 'no-patch' mode so
5490         # just keep quiet.
5491         if (!$chk_patch && !$is_patch) {
5492                 exit(0);
5493         }
5494
5495         if (!$is_patch) {
5496                 ERROR("NOT_UNIFIED_DIFF",
5497                       "Does not appear to be a unified-diff format patch\n");
5498         }
5499         if ($is_patch && $chk_signoff && $signoff == 0) {
5500                 ERROR("MISSING_SIGN_OFF",
5501                       "Missing Signed-off-by: line(s)\n");
5502         }
5503
5504         print report_dump();
5505         if ($summary && !($clean == 1 && $quiet == 1)) {
5506                 print "$filename " if ($summary_file);
5507                 print "total: $cnt_error errors, $cnt_warn warnings, " .
5508                         (($check)? "$cnt_chk checks, " : "") .
5509                         "$cnt_lines lines checked\n";
5510                 print "\n" if ($quiet == 0);
5511         }
5512
5513         if ($quiet == 0) {
5514
5515                 if ($^V lt 5.10.0) {
5516                         print("NOTE: perl $^V is not modern enough to detect all possible issues.\n");
5517                         print("An upgrade to at least perl v5.10.0 is suggested.\n\n");
5518                 }
5519
5520                 # If there were whitespace errors which cleanpatch can fix
5521                 # then suggest that.
5522                 if ($rpt_cleaners) {
5523                         print "NOTE: whitespace errors detected, you may wish to use scripts/cleanpatch or\n";
5524                         print "      scripts/cleanfile\n\n";
5525                         $rpt_cleaners = 0;
5526                 }
5527         }
5528
5529         hash_show_words(\%use_type, "Used");
5530         hash_show_words(\%ignore_type, "Ignored");
5531
5532         if ($clean == 0 && $fix &&
5533             ("@rawlines" ne "@fixed" ||
5534              $#fixed_inserted >= 0 || $#fixed_deleted >= 0)) {
5535                 my $newfile = $filename;
5536                 $newfile .= ".EXPERIMENTAL-checkpatch-fixes" if (!$fix_inplace);
5537                 my $linecount = 0;
5538                 my $f;
5539
5540                 @fixed = fix_inserted_deleted_lines(\@fixed, \@fixed_inserted, \@fixed_deleted);
5541
5542                 open($f, '>', $newfile)
5543                     or die "$P: Can't open $newfile for write\n";
5544                 foreach my $fixed_line (@fixed) {
5545                         $linecount++;
5546                         if ($file) {
5547                                 if ($linecount > 3) {
5548                                         $fixed_line =~ s/^\+//;
5549                                         print $f $fixed_line . "\n";
5550                                 }
5551                         } else {
5552                                 print $f $fixed_line . "\n";
5553                         }
5554                 }
5555                 close($f);
5556
5557                 if (!$quiet) {
5558                         print << "EOM";
5559 Wrote EXPERIMENTAL --fix correction(s) to '$newfile'
5560
5561 Do _NOT_ trust the results written to this file.
5562 Do _NOT_ submit these changes without inspecting them for correctness.
5563
5564 This EXPERIMENTAL file is simply a convenience to help rewrite patches.
5565 No warranties, expressed or implied...
5566
5567 EOM
5568                 }
5569         }
5570
5571         if ($clean == 1 && $quiet == 0) {
5572                 print "$vname has no obvious style problems and is ready for submission.\n"
5573         }
5574         if ($clean == 0 && $quiet == 0) {
5575                 print << "EOM";
5576 $vname has style problems, please review.
5577
5578 If any of these errors are false positives, please report
5579 them to the maintainer, see CHECKPATCH in MAINTAINERS.
5580 EOM
5581         }
5582
5583         return $clean;
5584 }