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