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