scripts/checkpatch.pl

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