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