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