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