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