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? (a single leading tab, then return;) 3480 if ($sline =~ /^\+\treturn\s*;\s*$/ && 3481 $prevline =~ /^\+/) { 3482 WARN("RETURN_VOID", 3483 "void function return statements are not generally useful\n" . $herecurr); 3484 } 3485 3486# if statements using unnecessary parentheses - ie: if ((foo == bar)) 3487 if ($^V && $^V ge 5.10.0 && 3488 $line =~ /\bif\s*((?:\(\s*){2,})/) { 3489 my $openparens = $1; 3490 my $count = $openparens =~ tr@\(@\(@; 3491 my $msg = ""; 3492 if ($line =~ /\bif\s*(?:\(\s*){$count,$count}$LvalOrFunc\s*($Compare)\s*$LvalOrFunc(?:\s*\)){$count,$count}/) { 3493 my $comp = $4; #Not $1 because of $LvalOrFunc 3494 $msg = " - maybe == should be = ?" if ($comp eq "=="); 3495 WARN("UNNECESSARY_PARENTHESES", 3496 "Unnecessary parentheses$msg\n" . $herecurr); 3497 } 3498 } 3499 3500# Return of what appears to be an errno should normally be -'ve 3501 if ($line =~ /^.\s*return\s*(E[A-Z]*)\s*;/) { 3502 my $name = $1; 3503 if ($name ne 'EOF' && $name ne 'ERROR') { 3504 WARN("USE_NEGATIVE_ERRNO", 3505 "return of an errno should typically be -ve (return -$1)\n" . $herecurr); 3506 } 3507 } 3508 3509# Need a space before open parenthesis after if, while etc 3510 if ($line =~ /\b(if|while|for|switch)\(/) { 3511 if (ERROR("SPACING", 3512 "space required before the open parenthesis '('\n" . $herecurr) && 3513 $fix) { 3514 $fixed[$linenr - 1] =~ 3515 s/\b(if|while|for|switch)\(/$1 \(/; 3516 } 3517 } 3518 3519# Check for illegal assignment in if conditional -- and check for trailing 3520# statements after the conditional. 3521 if ($line =~ /do\s*(?!{)/) { 3522 ($stat, $cond, $line_nr_next, $remain_next, $off_next) = 3523 ctx_statement_block($linenr, $realcnt, 0) 3524 if (!defined $stat); 3525 my ($stat_next) = ctx_statement_block($line_nr_next, 3526 $remain_next, $off_next); 3527 $stat_next =~ s/\n./\n /g; 3528 ##print "stat<$stat> stat_next<$stat_next>\n"; 3529 3530 if ($stat_next =~ /^\s*while\b/) { 3531 # If the statement carries leading newlines, 3532 # then count those as offsets. 3533 my ($whitespace) = 3534 ($stat_next =~ /^((?:\s*\n[+-])*\s*)/s); 3535 my $offset = 3536 statement_rawlines($whitespace) - 1; 3537 3538 $suppress_whiletrailers{$line_nr_next + 3539 $offset} = 1; 3540 } 3541 } 3542 if (!defined $suppress_whiletrailers{$linenr} && 3543 defined($stat) && defined($cond) && 3544 $line =~ /\b(?:if|while|for)\s*\(/ && $line !~ /^.\s*#/) { 3545 my ($s, $c) = ($stat, $cond); 3546 3547 if ($c =~ /\bif\s*\(.*[^<>!=]=[^=].*/s) { 3548 ERROR("ASSIGN_IN_IF", 3549 "do not use assignment in if condition\n" . $herecurr); 3550 } 3551 3552 # Find out what is on the end of the line after the 3553 # conditional. 3554 substr($s, 0, length($c), ''); 3555 $s =~ s/\n.*//g; 3556 $s =~ s/$;//g; # Remove any comments 3557 if (length($c) && $s !~ /^\s*{?\s*\\*\s*$/ && 3558 $c !~ /}\s*while\s*/) 3559 { 3560 # Find out how long the conditional actually is. 3561 my @newlines = ($c =~ /\n/gs); 3562 my $cond_lines = 1 + $#newlines; 3563 my $stat_real = ''; 3564 3565 $stat_real = raw_line($linenr, $cond_lines) 3566 . "\n" if ($cond_lines); 3567 if (defined($stat_real) && $cond_lines > 1) { 3568 $stat_real = "[...]\n$stat_real"; 3569 } 3570 3571 ERROR("TRAILING_STATEMENTS", 3572 "trailing statements should be on next line\n" . $herecurr . $stat_real); 3573 } 3574 } 3575 3576# Check for bitwise tests written as boolean 3577 if ($line =~ / 3578 (?: 3579 (?:\[|\(|\&\&|\|\|) 3580 \s*0[xX][0-9]+\s* 3581 (?:\&\&|\|\|) 3582 | 3583 (?:\&\&|\|\|) 3584 \s*0[xX][0-9]+\s* 3585 (?:\&\&|\|\||\)|\]) 3586 )/x) 3587 { 3588 WARN("HEXADECIMAL_BOOLEAN_TEST", 3589 "boolean test with hexadecimal, perhaps just 1 \& or \|?\n" . $herecurr); 3590 } 3591 3592# if and else should not have general statements after it 3593 if ($line =~ /^.\s*(?:}\s*)?else\b(.*)/) { 3594 my $s = $1; 3595 $s =~ s/$;//g; # Remove any comments 3596 if ($s !~ /^\s*(?:\sif|(?:{|)\s*\\?\s*$)/) { 3597 ERROR("TRAILING_STATEMENTS", 3598 "trailing statements should be on next line\n" . $herecurr); 3599 } 3600 } 3601# if should not continue a brace 3602 if ($line =~ /}\s*if\b/) { 3603 ERROR("TRAILING_STATEMENTS", 3604 "trailing statements should be on next line\n" . 3605 $herecurr); 3606 } 3607# case and default should not have general statements after them 3608 if ($line =~ /^.\s*(?:case\s*.*|default\s*):/g && 3609 $line !~ /\G(?: 3610 (?:\s*$;*)(?:\s*{)?(?:\s*$;*)(?:\s*\\)?\s*$| 3611 \s*return\s+ 3612 )/xg) 3613 { 3614 ERROR("TRAILING_STATEMENTS", 3615 "trailing statements should be on next line\n" . $herecurr); 3616 } 3617 3618 # Check for }<nl>else {, these must be at the same 3619 # indent level to be relevant to each other. 3620 if ($prevline=~/}\s*$/ and $line=~/^.\s*else\s*/ and 3621 $previndent == $indent) { 3622 ERROR("ELSE_AFTER_BRACE", 3623 "else should follow close brace '}'\n" . $hereprev); 3624 } 3625 3626 if ($prevline=~/}\s*$/ and $line=~/^.\s*while\s*/ and 3627 $previndent == $indent) { 3628 my ($s, $c) = ctx_statement_block($linenr, $realcnt, 0); 3629 3630 # Find out what is on the end of the line after the 3631 # conditional. 3632 substr($s, 0, length($c), ''); 3633 $s =~ s/\n.*//g; 3634 3635 if ($s =~ /^\s*;/) { 3636 ERROR("WHILE_AFTER_BRACE", 3637 "while should follow close brace '}'\n" . $hereprev); 3638 } 3639 } 3640 3641#Specific variable tests 3642 while ($line =~ m{($Constant|$Lval)}g) { 3643 my $var = $1; 3644 3645#gcc binary extension 3646 if ($var =~ /^$Binary$/) { 3647 if (WARN("GCC_BINARY_CONSTANT", 3648 "Avoid gcc v4.3+ binary constant extension: <$var>\n" . $herecurr) && 3649 $fix) { 3650 my $hexval = sprintf("0x%x", oct($var)); 3651 $fixed[$linenr - 1] =~ 3652 s/\b$var\b/$hexval/; 3653 } 3654 } 3655 3656#CamelCase 3657 if ($var !~ /^$Constant$/ && 3658 $var =~ /[A-Z][a-z]|[a-z][A-Z]/ && 3659#Ignore Page<foo> variants 3660 $var !~ /^(?:Clear|Set|TestClear|TestSet|)Page[A-Z]/ && 3661#Ignore SI style variants like nS, mV and dB (ie: max_uV, regulator_min_uA_show) 3662 $var !~ /^(?:[a-z_]*?)_?[a-z][A-Z](?:_[a-z_]+)?$/) { 3663 while ($var =~ m{($Ident)}g) { 3664 my $word = $1; 3665 next if ($word !~ /[A-Z][a-z]|[a-z][A-Z]/); 3666 if ($check) { 3667 seed_camelcase_includes(); 3668 if (!$file && !$camelcase_file_seeded) { 3669 seed_camelcase_file($realfile); 3670 $camelcase_file_seeded = 1; 3671 } 3672 } 3673 if (!defined $camelcase{$word}) { 3674 $camelcase{$word} = 1; 3675 CHK("CAMELCASE", 3676 "Avoid CamelCase: <$word>\n" . $herecurr); 3677 } 3678 } 3679 } 3680 } 3681 3682#no spaces allowed after \ in define 3683 if ($line =~ /\#\s*define.*\\\s+$/) { 3684 if (WARN("WHITESPACE_AFTER_LINE_CONTINUATION", 3685 "Whitespace after \\ makes next lines useless\n" . $herecurr) && 3686 $fix) { 3687 $fixed[$linenr - 1] =~ s/\s+$//; 3688 } 3689 } 3690 3691#warn if <asm/foo.h> is #included and <linux/foo.h> is available (uses RAW line) 3692 if ($tree && $rawline =~ m{^.\s*\#\s*include\s*\<asm\/(.*)\.h\>}) { 3693 my $file = "$1.h"; 3694 my $checkfile = "include/linux/$file"; 3695 if (-f "$root/$checkfile" && 3696 $realfile ne $checkfile && 3697 $1 !~ /$allowed_asm_includes/) 3698 { 3699 if ($realfile =~ m{^arch/}) { 3700 CHK("ARCH_INCLUDE_LINUX", 3701 "Consider using #include <linux/$file> instead of <asm/$file>\n" . $herecurr); 3702 } else { 3703 WARN("INCLUDE_LINUX", 3704 "Use #include <linux/$file> instead of <asm/$file>\n" . $herecurr); 3705 } 3706 } 3707 } 3708 3709# multi-statement macros should be enclosed in a do while loop, grab the 3710# first statement and ensure its the whole macro if its not enclosed 3711# in a known good container 3712 if ($realfile !~ m@/vmlinux.lds.h$@ && 3713 $line =~ /^.\s*\#\s*define\s*$Ident(\()?/) { 3714 my $ln = $linenr; 3715 my $cnt = $realcnt; 3716 my ($off, $dstat, $dcond, $rest); 3717 my $ctx = ''; 3718 ($dstat, $dcond, $ln, $cnt, $off) = 3719 ctx_statement_block($linenr, $realcnt, 0); 3720 $ctx = $dstat; 3721 #print "dstat<$dstat> dcond<$dcond> cnt<$cnt> off<$off>\n"; 3722 #print "LINE<$lines[$ln-1]> len<" . length($lines[$ln-1]) . "\n"; 3723 3724 $dstat =~ s/^.\s*\#\s*define\s+$Ident(?:\([^\)]*\))?\s*//; 3725 $dstat =~ s/$;//g; 3726 $dstat =~ s/\\\n.//g; 3727 $dstat =~ s/^\s*//s; 3728 $dstat =~ s/\s*$//s; 3729 3730 # Flatten any parentheses and braces 3731 while ($dstat =~ s/\([^\(\)]*\)/1/ || 3732 $dstat =~ s/\{[^\{\}]*\}/1/ || 3733 $dstat =~ s/\[[^\[\]]*\]/1/) 3734 { 3735 } 3736 3737 # Flatten any obvious string concatentation. 3738 while ($dstat =~ s/("X*")\s*$Ident/$1/ || 3739 $dstat =~ s/$Ident\s*("X*")/$1/) 3740 { 3741 } 3742 3743 my $exceptions = qr{ 3744 $Declare| 3745 module_param_named| 3746 MODULE_PARM_DESC| 3747 DECLARE_PER_CPU| 3748 DEFINE_PER_CPU| 3749 __typeof__\(| 3750 union| 3751 struct| 3752 \.$Ident\s*=\s*| 3753 ^\"|\"$ 3754 }x; 3755 #print "REST<$rest> dstat<$dstat> ctx<$ctx>\n"; 3756 if ($dstat ne '' && 3757 $dstat !~ /^(?:$Ident|-?$Constant),$/ && # 10, // foo(), 3758 $dstat !~ /^(?:$Ident|-?$Constant);$/ && # foo(); 3759 $dstat !~ /^[!~-]?(?:$Lval|$Constant)$/ && # 10 // foo() // !foo // ~foo // -foo // foo->bar // foo.bar->baz 3760 $dstat !~ /^'X'$/ && # character constants 3761 $dstat !~ /$exceptions/ && 3762 $dstat !~ /^\.$Ident\s*=/ && # .foo = 3763 $dstat !~ /^(?:\#\s*$Ident|\#\s*$Constant)\s*$/ && # stringification #foo 3764 $dstat !~ /^do\s*$Constant\s*while\s*$Constant;?$/ && # do {...} while (...); // do {...} while (...) 3765 $dstat !~ /^for\s*$Constant$/ && # for (...) 3766 $dstat !~ /^for\s*$Constant\s+(?:$Ident|-?$Constant)$/ && # for (...) bar() 3767 $dstat !~ /^do\s*{/ && # do {... 3768 $dstat !~ /^\({/ && # ({... 3769 $ctx !~ /^.\s*#\s*define\s+TRACE_(?:SYSTEM|INCLUDE_FILE|INCLUDE_PATH)\b/) 3770 { 3771 $ctx =~ s/\n*$//; 3772 my $herectx = $here . "\n"; 3773 my $cnt = statement_rawlines($ctx); 3774 3775 for (my $n = 0; $n < $cnt; $n++) { 3776 $herectx .= raw_line($linenr, $n) . "\n"; 3777 } 3778 3779 if ($dstat =~ /;/) { 3780 ERROR("MULTISTATEMENT_MACRO_USE_DO_WHILE", 3781 "Macros with multiple statements should be enclosed in a do - while loop\n" . "$herectx"); 3782 } else { 3783 ERROR("COMPLEX_MACRO", 3784 "Macros with complex values should be enclosed in parenthesis\n" . "$herectx"); 3785 } 3786 } 3787 3788# check for line continuations outside of #defines, preprocessor #, and asm 3789 3790 } else { 3791 if ($prevline !~ /^..*\\$/ && 3792 $line !~ /^\+\s*\#.*\\$/ && # preprocessor 3793 $line !~ /^\+.*\b(__asm__|asm)\b.*\\$/ && # asm 3794 $line =~ /^\+.*\\$/) { 3795 WARN("LINE_CONTINUATIONS", 3796 "Avoid unnecessary line continuations\n" . $herecurr); 3797 } 3798 } 3799 3800# do {} while (0) macro tests: 3801# single-statement macros do not need to be enclosed in do while (0) loop, 3802# macro should not end with a semicolon 3803 if ($^V && $^V ge 5.10.0 && 3804 $realfile !~ m@/vmlinux.lds.h$@ && 3805 $line =~ /^.\s*\#\s*define\s+$Ident(\()?/) { 3806 my $ln = $linenr; 3807 my $cnt = $realcnt; 3808 my ($off, $dstat, $dcond, $rest); 3809 my $ctx = ''; 3810 ($dstat, $dcond, $ln, $cnt, $off) = 3811 ctx_statement_block($linenr, $realcnt, 0); 3812 $ctx = $dstat; 3813 3814 $dstat =~ s/\\\n.//g; 3815 3816 if ($dstat =~ /^\+\s*#\s*define\s+$Ident\s*${balanced_parens}\s*do\s*{(.*)\s*}\s*while\s*\(\s*0\s*\)\s*([;\s]*)\s*$/) { 3817 my $stmts = $2; 3818 my $semis = $3; 3819 3820 $ctx =~ s/\n*$//; 3821 my $cnt = statement_rawlines($ctx); 3822 my $herectx = $here . "\n"; 3823 3824 for (my $n = 0; $n < $cnt; $n++) { 3825 $herectx .= raw_line($linenr, $n) . "\n"; 3826 } 3827 3828 if (($stmts =~ tr/;/;/) == 1 && 3829 $stmts !~ /^\s*(if|while|for|switch)\b/) { 3830 WARN("SINGLE_STATEMENT_DO_WHILE_MACRO", 3831 "Single statement macros should not use a do {} while (0) loop\n" . "$herectx"); 3832 } 3833 if (defined $semis && $semis ne "") { 3834 WARN("DO_WHILE_MACRO_WITH_TRAILING_SEMICOLON", 3835 "do {} while (0) macros should not be semicolon terminated\n" . "$herectx"); 3836 } 3837 } elsif ($dstat =~ /^\+\s*#\s*define\s+$Ident.*;\s*$/) { 3838 $ctx =~ s/\n*$//; 3839 my $cnt = statement_rawlines($ctx); 3840 my $herectx = $here . "\n"; 3841 3842 for (my $n = 0; $n < $cnt; $n++) { 3843 $herectx .= raw_line($linenr, $n) . "\n"; 3844 } 3845 3846 WARN("TRAILING_SEMICOLON", 3847 "macros should not use a trailing semicolon\n" . "$herectx"); 3848 } 3849 } 3850 3851# make sure symbols are always wrapped with VMLINUX_SYMBOL() ... 3852# all assignments may have only one of the following with an assignment: 3853# . 3854# ALIGN(...) 3855# VMLINUX_SYMBOL(...) 3856 if ($realfile eq 'vmlinux.lds.h' && $line =~ /(?:(?:^|\s)$Ident\s*=|=\s*$Ident(?:\s|$))/) { 3857 WARN("MISSING_VMLINUX_SYMBOL", 3858 "vmlinux.lds.h needs VMLINUX_SYMBOL() around C-visible symbols\n" . $herecurr); 3859 } 3860 3861# check for redundant bracing round if etc 3862 if ($line =~ /(^.*)\bif\b/ && $1 !~ /else\s*$/) { 3863 my ($level, $endln, @chunks) = 3864 ctx_statement_full($linenr, $realcnt, 1); 3865 #print "chunks<$#chunks> linenr<$linenr> endln<$endln> level<$level>\n"; 3866 #print "APW: <<$chunks[1][0]>><<$chunks[1][1]>>\n"; 3867 if ($#chunks > 0 && $level == 0) { 3868 my @allowed = (); 3869 my $allow = 0; 3870 my $seen = 0; 3871 my $herectx = $here . "\n"; 3872 my $ln = $linenr - 1; 3873 for my $chunk (@chunks) { 3874 my ($cond, $block) = @{$chunk}; 3875 3876 # If the condition carries leading newlines, then count those as offsets. 3877 my ($whitespace) = ($cond =~ /^((?:\s*\n[+-])*\s*)/s); 3878 my $offset = statement_rawlines($whitespace) - 1; 3879 3880 $allowed[$allow] = 0; 3881 #print "COND<$cond> whitespace<$whitespace> offset<$offset>\n"; 3882 3883 # We have looked at and allowed this specific line. 3884 $suppress_ifbraces{$ln + $offset} = 1; 3885 3886 $herectx .= "$rawlines[$ln + $offset]\n[...]\n"; 3887 $ln += statement_rawlines($block) - 1; 3888 3889 substr($block, 0, length($cond), ''); 3890 3891 $seen++ if ($block =~ /^\s*{/); 3892 3893 #print "cond<$cond> block<$block> allowed<$allowed[$allow]>\n"; 3894 if (statement_lines($cond) > 1) { 3895 #print "APW: ALLOWED: cond<$cond>\n"; 3896 $allowed[$allow] = 1; 3897 } 3898 if ($block =~/\b(?:if|for|while)\b/) { 3899 #print "APW: ALLOWED: block<$block>\n"; 3900 $allowed[$allow] = 1; 3901 } 3902 if (statement_block_size($block) > 1) { 3903 #print "APW: ALLOWED: lines block<$block>\n"; 3904 $allowed[$allow] = 1; 3905 } 3906 $allow++; 3907 } 3908 if ($seen) { 3909 my $sum_allowed = 0; 3910 foreach (@allowed) { 3911 $sum_allowed += $_; 3912 } 3913 if ($sum_allowed == 0) { 3914 WARN("BRACES", 3915 "braces {} are not necessary for any arm of this statement\n" . $herectx); 3916 } elsif ($sum_allowed != $allow && 3917 $seen != $allow) { 3918 CHK("BRACES", 3919 "braces {} should be used on all arms of this statement\n" . $herectx); 3920 } 3921 } 3922 } 3923 } 3924 if (!defined $suppress_ifbraces{$linenr - 1} && 3925 $line =~ /\b(if|while|for|else)\b/) { 3926 my $allowed = 0; 3927 3928 # Check the pre-context. 3929 if (substr($line, 0, $-[0]) =~ /(\}\s*)$/) { 3930 #print "APW: ALLOWED: pre<$1>\n"; 3931 $allowed = 1; 3932 } 3933 3934 my ($level, $endln, @chunks) = 3935 ctx_statement_full($linenr, $realcnt, $-[0]); 3936 3937 # Check the condition. 3938 my ($cond, $block) = @{$chunks[0]}; 3939 #print "CHECKING<$linenr> cond<$cond> block<$block>\n"; 3940 if (defined $cond) { 3941 substr($block, 0, length($cond), ''); 3942 } 3943 if (statement_lines($cond) > 1) { 3944 #print "APW: ALLOWED: cond<$cond>\n"; 3945 $allowed = 1; 3946 } 3947 if ($block =~/\b(?:if|for|while)\b/) { 3948 #print "APW: ALLOWED: block<$block>\n"; 3949 $allowed = 1; 3950 } 3951 if (statement_block_size($block) > 1) { 3952 #print "APW: ALLOWED: lines block<$block>\n"; 3953 $allowed = 1; 3954 } 3955 # Check the post-context. 3956 if (defined $chunks[1]) { 3957 my ($cond, $block) = @{$chunks[1]}; 3958 if (defined $cond) { 3959 substr($block, 0, length($cond), ''); 3960 } 3961 if ($block =~ /^\s*\{/) { 3962 #print "APW: ALLOWED: chunk-1 block<$block>\n"; 3963 $allowed = 1; 3964 } 3965 } 3966 if ($level == 0 && $block =~ /^\s*\{/ && !$allowed) { 3967 my $herectx = $here . "\n"; 3968 my $cnt = statement_rawlines($block); 3969 3970 for (my $n = 0; $n < $cnt; $n++) { 3971 $herectx .= raw_line($linenr, $n) . "\n"; 3972 } 3973 3974 WARN("BRACES", 3975 "braces {} are not necessary for single statement blocks\n" . $herectx); 3976 } 3977 } 3978 3979# check for unnecessary blank lines around braces 3980 if (($line =~ /^.\s*}\s*$/ && $prevrawline =~ /^.\s*$/)) { 3981 CHK("BRACES", 3982 "Blank lines aren't necessary before a close brace '}'\n" . $hereprev); 3983 } 3984 if (($rawline =~ /^.\s*$/ && $prevline =~ /^..*{\s*$/)) { 3985 CHK("BRACES", 3986 "Blank lines aren't necessary after an open brace '{'\n" . $hereprev); 3987 } 3988 3989# no volatiles please 3990 my $asm_volatile = qr{\b(__asm__|asm)\s+(__volatile__|volatile)\b}; 3991 if ($line =~ /\bvolatile\b/ && $line !~ /$asm_volatile/) { 3992 WARN("VOLATILE", 3993 "Use of volatile is usually wrong: see Documentation/volatile-considered-harmful.txt\n" . $herecurr); 3994 } 3995 3996# warn about #if 0 3997 if ($line =~ /^.\s*\#\s*if\s+0\b/) { 3998 CHK("REDUNDANT_CODE", 3999 "if this code is redundant consider removing it\n" . 4000 $herecurr); 4001 } 4002 4003# check for needless "if (<foo>) fn(<foo>)" uses 4004 if ($prevline =~ /\bif\s*\(\s*($Lval)\s*\)/) { 4005 my $expr = '\s*\(\s*' . quotemeta($1) . '\s*\)\s*;'; 4006 if ($line =~ /\b(kfree|usb_free_urb|debugfs_remove(?:_recursive)?)$expr/) { 4007 WARN('NEEDLESS_IF', 4008 "$1(NULL) is safe this check is probably not required\n" . $hereprev); 4009 } 4010 } 4011 4012# check for bad placement of section $InitAttribute (e.g.: __initdata) 4013 if ($line =~ /(\b$InitAttribute\b)/) { 4014 my $attr = $1; 4015 if ($line =~ /^\+\s*static\s+(?:const\s+)?(?:$attr\s+)?($NonptrTypeWithAttr)\s+(?:$attr\s+)?($Ident(?:\[[^]]*\])?)\s*[=;]/) { 4016 my $ptr = $1; 4017 my $var = $2; 4018 if ((($ptr =~ /\b(union|struct)\s+$attr\b/ && 4019 ERROR("MISPLACED_INIT", 4020 "$attr should be placed after $var\n" . $herecurr)) || 4021 ($ptr !~ /\b(union|struct)\s+$attr\b/ && 4022 WARN("MISPLACED_INIT", 4023 "$attr should be placed after $var\n" . $herecurr))) && 4024 $fix) { 4025 $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; 4026 } 4027 } 4028 } 4029 4030# check for $InitAttributeData (ie: __initdata) with const 4031 if ($line =~ /\bconst\b/ && $line =~ /($InitAttributeData)/) { 4032 my $attr = $1; 4033 $attr =~ /($InitAttributePrefix)(.*)/; 4034 my $attr_prefix = $1; 4035 my $attr_type = $2; 4036 if (ERROR("INIT_ATTRIBUTE", 4037 "Use of const init definition must use ${attr_prefix}initconst\n" . $herecurr) && 4038 $fix) { 4039 $fixed[$linenr - 1] =~ 4040 s/$InitAttributeData/${attr_prefix}initconst/; 4041 } 4042 } 4043 4044# check for $InitAttributeConst (ie: __initconst) without const 4045 if ($line !~ /\bconst\b/ && $line =~ /($InitAttributeConst)/) { 4046 my $attr = $1; 4047 if (ERROR("INIT_ATTRIBUTE", 4048 "Use of $attr requires a separate use of const\n" . $herecurr) && 4049 $fix) { 4050 my $lead = $fixed[$linenr - 1] =~ 4051 /(^\+\s*(?:static\s+))/; 4052 $lead = rtrim($1); 4053 $lead = "$lead " if ($lead !~ /^\+$/); 4054 $lead = "${lead}const "; 4055 $fixed[$linenr - 1] =~ s/(^\+\s*(?:static\s+))/$lead/; 4056 } 4057 } 4058 4059# don't use __constant_<foo> functions outside of include/uapi/ 4060 if ($realfile !~ m@^include/uapi/@ && 4061 $line =~ /(__constant_(?:htons|ntohs|[bl]e(?:16|32|64)_to_cpu|cpu_to_[bl]e(?:16|32|64)))\s*\(/) { 4062 my $constant_func = $1; 4063 my $func = $constant_func; 4064 $func =~ s/^__constant_//; 4065 if (WARN("CONSTANT_CONVERSION", 4066 "$constant_func should be $func\n" . $herecurr) && 4067 $fix) { 4068 $fixed[$linenr - 1] =~ s/\b$constant_func\b/$func/g; 4069 } 4070 } 4071 4072# prefer usleep_range over udelay 4073 if ($line =~ /\budelay\s*\(\s*(\d+)\s*\)/) { 4074 my $delay = $1; 4075 # ignore udelay's < 10, however 4076 if (! ($delay < 10) ) { 4077 CHK("USLEEP_RANGE", 4078 "usleep_range is preferred over udelay; see Documentation/timers/timers-howto.txt\n" . $herecurr); 4079 } 4080 if ($delay > 2000) { 4081 WARN("LONG_UDELAY", 4082 "long udelay - prefer mdelay; see arch/arm/include/asm/delay.h\n" . $herecurr); 4083 } 4084 } 4085 4086# warn about unexpectedly long msleep's 4087 if ($line =~ /\bmsleep\s*\((\d+)\);/) { 4088 if ($1 < 20) { 4089 WARN("MSLEEP", 4090 "msleep < 20ms can sleep for up to 20ms; see Documentation/timers/timers-howto.txt\n" . $herecurr); 4091 } 4092 } 4093 4094# check for comparisons of jiffies 4095 if ($line =~ /\bjiffies\s*$Compare|$Compare\s*jiffies\b/) { 4096 WARN("JIFFIES_COMPARISON", 4097 "Comparing jiffies is almost always wrong; prefer time_after, time_before and friends\n" . $herecurr); 4098 } 4099 4100# check for comparisons of get_jiffies_64() 4101 if ($line =~ /\bget_jiffies_64\s*\(\s*\)\s*$Compare|$Compare\s*get_jiffies_64\s*\(\s*\)/) { 4102 WARN("JIFFIES_COMPARISON", 4103 "Comparing get_jiffies_64() is almost always wrong; prefer time_after64, time_before64 and friends\n" . $herecurr); 4104 } 4105 4106# warn about #ifdefs in C files 4107# if ($line =~ /^.\s*\#\s*if(|n)def/ && ($realfile =~ /\.c$/)) { 4108# print "#ifdef in C files should be avoided\n"; 4109# print "$herecurr"; 4110# $clean = 0; 4111# } 4112 4113# warn about spacing in #ifdefs 4114 if ($line =~ /^.\s*\#\s*(ifdef|ifndef|elif)\s\s+/) { 4115 if (ERROR("SPACING", 4116 "exactly one space required after that #$1\n" . $herecurr) && 4117 $fix) { 4118 $fixed[$linenr - 1] =~ 4119 s/^(.\s*\#\s*(ifdef|ifndef|elif))\s{2,}/$1 /; 4120 } 4121 4122 } 4123 4124# check for spinlock_t definitions without a comment. 4125 if ($line =~ /^.\s*(struct\s+mutex|spinlock_t)\s+\S+;/ || 4126 $line =~ /^.\s*(DEFINE_MUTEX)\s*\(/) { 4127 my $which = $1; 4128 if (!ctx_has_comment($first_line, $linenr)) { 4129 CHK("UNCOMMENTED_DEFINITION", 4130 "$1 definition without comment\n" . $herecurr); 4131 } 4132 } 4133# check for memory barriers without a comment. 4134 if ($line =~ /\b(mb|rmb|wmb|read_barrier_depends|smp_mb|smp_rmb|smp_wmb|smp_read_barrier_depends)\(/) { 4135 if (!ctx_has_comment($first_line, $linenr)) { 4136 WARN("MEMORY_BARRIER", 4137 "memory barrier without comment\n" . $herecurr); 4138 } 4139 } 4140# check of hardware specific defines 4141 if ($line =~ m@^.\s*\#\s*if.*\b(__i386__|__powerpc64__|__sun__|__s390x__)\b@ && $realfile !~ m@include/asm-@) { 4142 CHK("ARCH_DEFINES", 4143 "architecture specific defines should be avoided\n" . $herecurr); 4144 } 4145 4146# Check that the storage class is at the beginning of a declaration 4147 if ($line =~ /\b$Storage\b/ && $line !~ /^.\s*$Storage\b/) { 4148 WARN("STORAGE_CLASS", 4149 "storage class should be at the beginning of the declaration\n" . $herecurr) 4150 } 4151 4152# check the location of the inline attribute, that it is between 4153# storage class and type. 4154 if ($line =~ /\b$Type\s+$Inline\b/ || 4155 $line =~ /\b$Inline\s+$Storage\b/) { 4156 ERROR("INLINE_LOCATION", 4157 "inline keyword should sit between storage class and type\n" . $herecurr); 4158 } 4159 4160# Check for __inline__ and __inline, prefer inline 4161 if ($realfile !~ m@\binclude/uapi/@ && 4162 $line =~ /\b(__inline__|__inline)\b/) { 4163 if (WARN("INLINE", 4164 "plain inline is preferred over $1\n" . $herecurr) && 4165 $fix) { 4166 $fixed[$linenr - 1] =~ s/\b(__inline__|__inline)\b/inline/; 4167 4168 } 4169 } 4170 4171# Check for __attribute__ packed, prefer __packed 4172 if ($realfile !~ m@\binclude/uapi/@ && 4173 $line =~ /\b__attribute__\s*\(\s*\(.*\bpacked\b/) { 4174 WARN("PREFER_PACKED", 4175 "__packed is preferred over __attribute__((packed))\n" . $herecurr); 4176 } 4177 4178# Check for __attribute__ aligned, prefer __aligned 4179 if ($realfile !~ m@\binclude/uapi/@ && 4180 $line =~ /\b__attribute__\s*\(\s*\(.*aligned/) { 4181 WARN("PREFER_ALIGNED", 4182 "__aligned(size) is preferred over __attribute__((aligned(size)))\n" . $herecurr); 4183 } 4184 4185# Check for __attribute__ format(printf, prefer __printf 4186 if ($realfile !~ m@\binclude/uapi/@ && 4187 $line =~ /\b__attribute__\s*\(\s*\(\s*format\s*\(\s*printf/) { 4188 if (WARN("PREFER_PRINTF", 4189 "__printf(string-index, first-to-check) is preferred over __attribute__((format(printf, string-index, first-to-check)))\n" . $herecurr) && 4190 $fix) { 4191 $fixed[$linenr - 1] =~ s/\b__attribute__\s*\(\s*\(\s*format\s*\(\s*printf\s*,\s*(.*)\)\s*\)\s*\)/"__printf(" . trim($1) . ")"/ex; 4192 4193 } 4194 } 4195 4196# Check for __attribute__ format(scanf, prefer __scanf 4197 if ($realfile !~ m@\binclude/uapi/@ && 4198 $line =~ /\b__attribute__\s*\(\s*\(\s*format\s*\(\s*scanf\b/) { 4199 if (WARN("PREFER_SCANF", 4200 "__scanf(string-index, first-to-check) is preferred over __attribute__((format(scanf, string-index, first-to-check)))\n" . $herecurr) && 4201 $fix) { 4202 $fixed[$linenr - 1] =~ s/\b__attribute__\s*\(\s*\(\s*format\s*\(\s*scanf\s*,\s*(.*)\)\s*\)\s*\)/"__scanf(" . trim($1) . ")"/ex; 4203 } 4204 } 4205 4206# check for sizeof(&) 4207 if ($line =~ /\bsizeof\s*\(\s*\&/) { 4208 WARN("SIZEOF_ADDRESS", 4209 "sizeof(& should be avoided\n" . $herecurr); 4210 } 4211 4212# check for sizeof without parenthesis 4213 if ($line =~ /\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/) { 4214 if (WARN("SIZEOF_PARENTHESIS", 4215 "sizeof $1 should be sizeof($1)\n" . $herecurr) && 4216 $fix) { 4217 $fixed[$linenr - 1] =~ s/\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/"sizeof(" . trim($1) . ")"/ex; 4218 } 4219 } 4220 4221# check for line continuations in quoted strings with odd counts of " 4222 if ($rawline =~ /\\$/ && $rawline =~ tr/"/"/ % 2) { 4223 WARN("LINE_CONTINUATIONS", 4224 "Avoid line continuations in quoted strings\n" . $herecurr); 4225 } 4226 4227# check for struct spinlock declarations 4228 if ($line =~ /^.\s*\bstruct\s+spinlock\s+\w+\s*;/) { 4229 WARN("USE_SPINLOCK_T", 4230 "struct spinlock should be spinlock_t\n" . $herecurr); 4231 } 4232 4233# check for seq_printf uses that could be seq_puts 4234 if ($sline =~ /\bseq_printf\s*\(.*"\s*\)\s*;\s*$/) { 4235 my $fmt = get_quoted_string($line, $rawline); 4236 if ($fmt ne "" && $fmt !~ /[^\\]\%/) { 4237 if (WARN("PREFER_SEQ_PUTS", 4238 "Prefer seq_puts to seq_printf\n" . $herecurr) && 4239 $fix) { 4240 $fixed[$linenr - 1] =~ s/\bseq_printf\b/seq_puts/; 4241 } 4242 } 4243 } 4244 4245# Check for misused memsets 4246 if ($^V && $^V ge 5.10.0 && 4247 defined $stat && 4248 $stat =~ /^\+(?:.*?)\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*$FuncArg\s*\)/s) { 4249 4250 my $ms_addr = $2; 4251 my $ms_val = $7; 4252 my $ms_size = $12; 4253 4254 if ($ms_size =~ /^(0x|)0$/i) { 4255 ERROR("MEMSET", 4256 "memset to 0's uses 0 as the 2nd argument, not the 3rd\n" . "$here\n$stat\n"); 4257 } elsif ($ms_size =~ /^(0x|)1$/i) { 4258 WARN("MEMSET", 4259 "single byte memset is suspicious. Swapped 2nd/3rd argument?\n" . "$here\n$stat\n"); 4260 } 4261 } 4262 4263# Check for memcpy(foo, bar, ETH_ALEN) that could be ether_addr_copy(foo, bar) 4264 if ($^V && $^V ge 5.10.0 && 4265 $line =~ /^\+(?:.*?)\bmemcpy\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/s) { 4266 if (WARN("PREFER_ETHER_ADDR_COPY", 4267 "Prefer ether_addr_copy() over memcpy() if the Ethernet addresses are __aligned(2)\n" . $herecurr) && 4268 $fix) { 4269 $fixed[$linenr - 1] =~ s/\bmemcpy\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/ether_addr_copy($2, $7)/; 4270 } 4271 } 4272 4273# typecasts on min/max could be min_t/max_t 4274 if ($^V && $^V ge 5.10.0 && 4275 defined $stat && 4276 $stat =~ /^\+(?:.*?)\b(min|max)\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\)/) { 4277 if (defined $2 || defined $7) { 4278 my $call = $1; 4279 my $cast1 = deparenthesize($2); 4280 my $arg1 = $3; 4281 my $cast2 = deparenthesize($7); 4282 my $arg2 = $8; 4283 my $cast; 4284 4285 if ($cast1 ne "" && $cast2 ne "" && $cast1 ne $cast2) { 4286 $cast = "$cast1 or $cast2"; 4287 } elsif ($cast1 ne "") { 4288 $cast = $cast1; 4289 } else { 4290 $cast = $cast2; 4291 } 4292 WARN("MINMAX", 4293 "$call() should probably be ${call}_t($cast, $arg1, $arg2)\n" . "$here\n$stat\n"); 4294 } 4295 } 4296 4297# check usleep_range arguments 4298 if ($^V && $^V ge 5.10.0 && 4299 defined $stat && 4300 $stat =~ /^\+(?:.*?)\busleep_range\s*\(\s*($FuncArg)\s*,\s*($FuncArg)\s*\)/) { 4301 my $min = $1; 4302 my $max = $7; 4303 if ($min eq $max) { 4304 WARN("USLEEP_RANGE", 4305 "usleep_range should not use min == max args; see Documentation/timers/timers-howto.txt\n" . "$here\n$stat\n"); 4306 } elsif ($min =~ /^\d+$/ && $max =~ /^\d+$/ && 4307 $min > $max) { 4308 WARN("USLEEP_RANGE", 4309 "usleep_range args reversed, use min then max; see Documentation/timers/timers-howto.txt\n" . "$here\n$stat\n"); 4310 } 4311 } 4312 4313# check for naked sscanf 4314 if ($^V && $^V ge 5.10.0 && 4315 defined $stat && 4316 $line =~ /\bsscanf\b/ && 4317 ($stat !~ /$Ident\s*=\s*sscanf\s*$balanced_parens/ && 4318 $stat !~ /\bsscanf\s*$balanced_parens\s*(?:$Compare)/ && 4319 $stat !~ /(?:$Compare)\s*\bsscanf\s*$balanced_parens/)) { 4320 my $lc = $stat =~ tr@\n@@; 4321 $lc = $lc + $linenr; 4322 my $stat_real = raw_line($linenr, 0); 4323 for (my $count = $linenr + 1; $count <= $lc; $count++) { 4324 $stat_real = $stat_real . "\n" . raw_line($count, 0); 4325 } 4326 WARN("NAKED_SSCANF", 4327 "unchecked sscanf return value\n" . "$here\n$stat_real\n"); 4328 } 4329 4330# check for simple sscanf that should be kstrto<foo> 4331 if ($^V && $^V ge 5.10.0 && 4332 defined $stat && 4333 $line =~ /\bsscanf\b/) { 4334 my $lc = $stat =~ tr@\n@@; 4335 $lc = $lc + $linenr; 4336 my $stat_real = raw_line($linenr, 0); 4337 for (my $count = $linenr + 1; $count <= $lc; $count++) { 4338 $stat_real = $stat_real . "\n" . raw_line($count, 0); 4339 } 4340 if ($stat_real =~ /\bsscanf\b\s*\(\s*$FuncArg\s*,\s*("[^"]+")/) { 4341 my $format = $6; 4342 my $count = $format =~ tr@%@%@; 4343 if ($count == 1 && 4344 $format =~ /^"\%(?i:ll[udxi]|[udxi]ll|ll|[hl]h?[udxi]|[udxi][hl]h?|[hl]h?|[udxi])"$/) { 4345 WARN("SSCANF_TO_KSTRTO", 4346 "Prefer kstrto<type> to single variable sscanf\n" . "$here\n$stat_real\n"); 4347 } 4348 } 4349 } 4350 4351# check for new externs in .h files. 4352 if ($realfile =~ /\.h$/ && 4353 $line =~ /^\+\s*(extern\s+)$Type\s*$Ident\s*\(/s) { 4354 if (CHK("AVOID_EXTERNS", 4355 "extern prototypes should be avoided in .h files\n" . $herecurr) && 4356 $fix) { 4357 $fixed[$linenr - 1] =~ s/(.*)\bextern\b\s*(.*)/$1$2/; 4358 } 4359 } 4360 4361# check for new externs in .c files. 4362 if ($realfile =~ /\.c$/ && defined $stat && 4363 $stat =~ /^.\s*(?:extern\s+)?$Type\s+($Ident)(\s*)\(/s) 4364 { 4365 my $function_name = $1; 4366 my $paren_space = $2; 4367 4368 my $s = $stat; 4369 if (defined $cond) { 4370 substr($s, 0, length($cond), ''); 4371 } 4372 if ($s =~ /^\s*;/ && 4373 $function_name ne 'uninitialized_var') 4374 { 4375 WARN("AVOID_EXTERNS", 4376 "externs should be avoided in .c files\n" . $herecurr); 4377 } 4378 4379 if ($paren_space =~ /\n/) { 4380 WARN("FUNCTION_ARGUMENTS", 4381 "arguments for function declarations should follow identifier\n" . $herecurr); 4382 } 4383 4384 } elsif ($realfile =~ /\.c$/ && defined $stat && 4385 $stat =~ /^.\s*extern\s+/) 4386 { 4387 WARN("AVOID_EXTERNS", 4388 "externs should be avoided in .c files\n" . $herecurr); 4389 } 4390 4391# checks for new __setup's 4392 if ($rawline =~ /\b__setup\("([^"]*)"/) { 4393 my $name = $1; 4394 4395 if (!grep(/$name/, @setup_docs)) { 4396 CHK("UNDOCUMENTED_SETUP", 4397 "__setup appears un-documented -- check Documentation/kernel-parameters.txt\n" . $herecurr); 4398 } 4399 } 4400 4401# check for pointless casting of kmalloc return 4402 if ($line =~ /\*\s*\)\s*[kv][czm]alloc(_node){0,1}\b/) { 4403 WARN("UNNECESSARY_CASTS", 4404 "unnecessary cast may hide bugs, see http://c-faq.com/malloc/mallocnocast.html\n" . $herecurr); 4405 } 4406 4407# alloc style 4408# p = alloc(sizeof(struct foo), ...) should be p = alloc(sizeof(*p), ...) 4409 if ($^V && $^V ge 5.10.0 && 4410 $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*([kv][mz]alloc(?:_node)?)\s*\(\s*(sizeof\s*\(\s*struct\s+$Lval\s*\))/) { 4411 CHK("ALLOC_SIZEOF_STRUCT", 4412 "Prefer $3(sizeof(*$1)...) over $3($4...)\n" . $herecurr); 4413 } 4414 4415# check for k[mz]alloc with multiplies that could be kmalloc_array/kcalloc 4416 if ($^V && $^V ge 5.10.0 && 4417 $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*(k[mz]alloc)\s*\(\s*($FuncArg)\s*\*\s*($FuncArg)/) { 4418 my $oldfunc = $3; 4419 my $a1 = $4; 4420 my $a2 = $10; 4421 my $newfunc = "kmalloc_array"; 4422 $newfunc = "kcalloc" if ($oldfunc eq "kzalloc"); 4423 if ($a1 =~ /^sizeof\s*\S/ || $a2 =~ /^sizeof\s*\S/) { 4424 if (WARN("ALLOC_WITH_MULTIPLY", 4425 "Prefer $newfunc over $oldfunc with multiply\n" . $herecurr) && 4426 $fix) { 4427 my $r1 = $a1; 4428 my $r2 = $a2; 4429 if ($a1 =~ /^sizeof\s*\S/) { 4430 $r1 = $a2; 4431 $r2 = $a1; 4432 } 4433 $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; 4434 4435 } 4436 } 4437 } 4438 4439# check for krealloc arg reuse 4440 if ($^V && $^V ge 5.10.0 && 4441 $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*krealloc\s*\(\s*\1\s*,/) { 4442 WARN("KREALLOC_ARG_REUSE", 4443 "Reusing the krealloc arg is almost always a bug\n" . $herecurr); 4444 } 4445 4446# check for alloc argument mismatch 4447 if ($line =~ /\b(kcalloc|kmalloc_array)\s*\(\s*sizeof\b/) { 4448 WARN("ALLOC_ARRAY_ARGS", 4449 "$1 uses number as first arg, sizeof is generally wrong\n" . $herecurr); 4450 } 4451 4452# check for multiple semicolons 4453 if ($line =~ /;\s*;\s*$/) { 4454 if (WARN("ONE_SEMICOLON", 4455 "Statements terminations use 1 semicolon\n" . $herecurr) && 4456 $fix) { 4457 $fixed[$linenr - 1] =~ s/(\s*;\s*){2,}$/;/g; 4458 } 4459 } 4460 4461# check for case / default statements not preceeded by break/fallthrough/switch 4462 if ($line =~ /^.\s*(?:case\s+(?:$Ident|$Constant)\s*|default):/) { 4463 my $has_break = 0; 4464 my $has_statement = 0; 4465 my $count = 0; 4466 my $prevline = $linenr; 4467 while ($prevline > 1 && $count < 3 && !$has_break) { 4468 $prevline--; 4469 my $rline = $rawlines[$prevline - 1]; 4470 my $fline = $lines[$prevline - 1]; 4471 last if ($fline =~ /^\@\@/); 4472 next if ($fline =~ /^\-/); 4473 next if ($fline =~ /^.(?:\s*(?:case\s+(?:$Ident|$Constant)[\s$;]*|default):[\s$;]*)*$/); 4474 $has_break = 1 if ($rline =~ /fall[\s_-]*(through|thru)/i); 4475 next if ($fline =~ /^.[\s$;]*$/); 4476 $has_statement = 1; 4477 $count++; 4478 $has_break = 1 if ($fline =~ /\bswitch\b|\b(?:break\s*;[\s$;]*$|return\b|goto\b|continue\b)/); 4479 } 4480 if (!$has_break && $has_statement) { 4481 WARN("MISSING_BREAK", 4482 "Possible switch case/default not preceeded by break or fallthrough comment\n" . $herecurr); 4483 } 4484 } 4485 4486# check for switch/default statements without a break; 4487 if ($^V && $^V ge 5.10.0 && 4488 defined $stat && 4489 $stat =~ /^\+[$;\s]*(?:case[$;\s]+\w+[$;\s]*:[$;\s]*|)*[$;\s]*\bdefault[$;\s]*:[$;\s]*;/g) { 4490 my $ctx = ''; 4491 my $herectx = $here . "\n"; 4492 my $cnt = statement_rawlines($stat); 4493 for (my $n = 0; $n < $cnt; $n++) { 4494 $herectx .= raw_line($linenr, $n) . "\n"; 4495 } 4496 WARN("DEFAULT_NO_BREAK", 4497 "switch default: should use break\n" . $herectx); 4498 } 4499 4500# check for gcc specific __FUNCTION__ 4501 if ($line =~ /\b__FUNCTION__\b/) { 4502 if (WARN("USE_FUNC", 4503 "__func__ should be used instead of gcc specific __FUNCTION__\n" . $herecurr) && 4504 $fix) { 4505 $fixed[$linenr - 1] =~ s/\b__FUNCTION__\b/__func__/g; 4506 } 4507 } 4508 4509# check for use of yield() 4510 if ($line =~ /\byield\s*\(\s*\)/) { 4511 WARN("YIELD", 4512 "Using yield() is generally wrong. See yield() kernel-doc (sched/core.c)\n" . $herecurr); 4513 } 4514 4515# check for comparisons against true and false 4516 if ($line =~ /\+\s*(.*?)\b(true|false|$Lval)\s*(==|\!=)\s*(true|false|$Lval)\b(.*)$/i) { 4517 my $lead = $1; 4518 my $arg = $2; 4519 my $test = $3; 4520 my $otype = $4; 4521 my $trail = $5; 4522 my $op = "!"; 4523 4524 ($arg, $otype) = ($otype, $arg) if ($arg =~ /^(?:true|false)$/i); 4525 4526 my $type = lc($otype); 4527 if ($type =~ /^(?:true|false)$/) { 4528 if (("$test" eq "==" && "$type" eq "true") || 4529 ("$test" eq "!=" && "$type" eq "false")) { 4530 $op = ""; 4531 } 4532 4533 CHK("BOOL_COMPARISON", 4534 "Using comparison to $otype is error prone\n" . $herecurr); 4535 4536## maybe suggesting a correct construct would better 4537## "Using comparison to $otype is error prone. Perhaps use '${lead}${op}${arg}${trail}'\n" . $herecurr); 4538 4539 } 4540 } 4541 4542# check for semaphores initialized locked 4543 if ($line =~ /^.\s*sema_init.+,\W?0\W?\)/) { 4544 WARN("CONSIDER_COMPLETION", 4545 "consider using a completion\n" . $herecurr); 4546 } 4547 4548# recommend kstrto* over simple_strto* and strict_strto* 4549 if ($line =~ /\b((simple|strict)_(strto(l|ll|ul|ull)))\s*\(/) { 4550 WARN("CONSIDER_KSTRTO", 4551 "$1 is obsolete, use k$3 instead\n" . $herecurr); 4552 } 4553 4554# check for __initcall(), use device_initcall() explicitly or more appropriate function please 4555 if ($line =~ /^.\s*__initcall\s*\(/) { 4556 WARN("USE_DEVICE_INITCALL", 4557 "please use device_initcall() or more appropriate function instead of __initcall() (see include/linux/init.h)\n" . $herecurr); 4558 } 4559 4560# check for various ops structs, ensure they are const. 4561 my $struct_ops = qr{acpi_dock_ops| 4562 address_space_operations| 4563 backlight_ops| 4564 block_device_operations| 4565 dentry_operations| 4566 dev_pm_ops| 4567 dma_map_ops| 4568 extent_io_ops| 4569 file_lock_operations| 4570 file_operations| 4571 hv_ops| 4572 ide_dma_ops| 4573 intel_dvo_dev_ops| 4574 item_operations| 4575 iwl_ops| 4576 kgdb_arch| 4577 kgdb_io| 4578 kset_uevent_ops| 4579 lock_manager_operations| 4580 microcode_ops| 4581 mtrr_ops| 4582 neigh_ops| 4583 nlmsvc_binding| 4584 pci_raw_ops| 4585 pipe_buf_operations| 4586 platform_hibernation_ops| 4587 platform_suspend_ops| 4588 proto_ops| 4589 rpc_pipe_ops| 4590 seq_operations| 4591 snd_ac97_build_ops| 4592 soc_pcmcia_socket_ops| 4593 stacktrace_ops| 4594 sysfs_ops| 4595 tty_operations| 4596 usb_mon_operations| 4597 wd_ops}x; 4598 if ($line !~ /\bconst\b/ && 4599 $line =~ /\bstruct\s+($struct_ops)\b/) { 4600 WARN("CONST_STRUCT", 4601 "struct $1 should normally be const\n" . 4602 $herecurr); 4603 } 4604 4605# use of NR_CPUS is usually wrong 4606# ignore definitions of NR_CPUS and usage to define arrays as likely right 4607 if ($line =~ /\bNR_CPUS\b/ && 4608 $line !~ /^.\s*\s*#\s*if\b.*\bNR_CPUS\b/ && 4609 $line !~ /^.\s*\s*#\s*define\b.*\bNR_CPUS\b/ && 4610 $line !~ /^.\s*$Declare\s.*\[[^\]]*NR_CPUS[^\]]*\]/ && 4611 $line !~ /\[[^\]]*\.\.\.[^\]]*NR_CPUS[^\]]*\]/ && 4612 $line !~ /\[[^\]]*NR_CPUS[^\]]*\.\.\.[^\]]*\]/) 4613 { 4614 WARN("NR_CPUS", 4615 "usage of NR_CPUS is often wrong - consider using cpu_possible(), num_possible_cpus(), for_each_possible_cpu(), etc\n" . $herecurr); 4616 } 4617 4618# Use of __ARCH_HAS_<FOO> or ARCH_HAVE_<BAR> is wrong. 4619 if ($line =~ /\+\s*#\s*define\s+((?:__)?ARCH_(?:HAS|HAVE)\w*)\b/) { 4620 ERROR("DEFINE_ARCH_HAS", 4621 "#define of '$1' is wrong - use Kconfig variables or standard guards instead\n" . $herecurr); 4622 } 4623 4624# check for %L{u,d,i} in strings 4625 my $string; 4626 while ($line =~ /(?:^|")([X\t]*)(?:"|$)/g) { 4627 $string = substr($rawline, $-[1], $+[1] - $-[1]); 4628 $string =~ s/%%/__/g; 4629 if ($string =~ /(?<!%)%L[udi]/) { 4630 WARN("PRINTF_L", 4631 "\%Ld/%Lu are not-standard C, use %lld/%llu\n" . $herecurr); 4632 last; 4633 } 4634 } 4635 4636# whine mightly about in_atomic 4637 if ($line =~ /\bin_atomic\s*\(/) { 4638 if ($realfile =~ m@^drivers/@) { 4639 ERROR("IN_ATOMIC", 4640 "do not use in_atomic in drivers\n" . $herecurr); 4641 } elsif ($realfile !~ m@^kernel/@) { 4642 WARN("IN_ATOMIC", 4643 "use of in_atomic() is incorrect outside core kernel code\n" . $herecurr); 4644 } 4645 } 4646 4647# check for lockdep_set_novalidate_class 4648 if ($line =~ /^.\s*lockdep_set_novalidate_class\s*\(/ || 4649 $line =~ /__lockdep_no_validate__\s*\)/ ) { 4650 if ($realfile !~ m@^kernel/lockdep@ && 4651 $realfile !~ m@^include/linux/lockdep@ && 4652 $realfile !~ m@^drivers/base/core@) { 4653 ERROR("LOCKDEP", 4654 "lockdep_no_validate class is reserved for device->mutex.\n" . $herecurr); 4655 } 4656 } 4657 4658 if ($line =~ /debugfs_create_file.*S_IWUGO/ || 4659 $line =~ /DEVICE_ATTR.*S_IWUGO/ ) { 4660 WARN("EXPORTED_WORLD_WRITABLE", 4661 "Exporting world writable files is usually an error. Consider more restrictive permissions.\n" . $herecurr); 4662 } 4663 4664# Mode permission misuses where it seems decimal should be octal 4665# This uses a shortcut match to avoid unnecessary uses of a slow foreach loop 4666 if ($^V && $^V ge 5.10.0 && 4667 $line =~ /$mode_perms_search/) { 4668 foreach my $entry (@mode_permission_funcs) { 4669 my $func = $entry->[0]; 4670 my $arg_pos = $entry->[1]; 4671 4672 my $skip_args = ""; 4673 if ($arg_pos > 1) { 4674 $arg_pos--; 4675 $skip_args = "(?:\\s*$FuncArg\\s*,\\s*){$arg_pos,$arg_pos}"; 4676 } 4677 my $test = "\\b$func\\s*\\(${skip_args}([\\d]+)\\s*[,\\)]"; 4678 if ($line =~ /$test/) { 4679 my $val = $1; 4680 $val = $6 if ($skip_args ne ""); 4681 4682 if ($val !~ /^0$/ && 4683 (($val =~ /^$Int$/ && $val !~ /^$Octal$/) || 4684 length($val) ne 4)) { 4685 ERROR("NON_OCTAL_PERMISSIONS", 4686 "Use 4 digit octal (0777) not decimal permissions\n" . $herecurr); 4687 } 4688 } 4689 } 4690 } 4691 } 4692 4693 # If we have no input at all, then there is nothing to report on 4694 # so just keep quiet. 4695 if ($#rawlines == -1) { 4696 exit(0); 4697 } 4698 4699 # In mailback mode only produce a report in the negative, for 4700 # things that appear to be patches. 4701 if ($mailback && ($clean == 1 || !$is_patch)) { 4702 exit(0); 4703 } 4704 4705 # This is not a patch, and we are are in 'no-patch' mode so 4706 # just keep quiet. 4707 if (!$chk_patch && !$is_patch) { 4708 exit(0); 4709 } 4710 4711 if (!$is_patch) { 4712 ERROR("NOT_UNIFIED_DIFF", 4713 "Does not appear to be a unified-diff format patch\n"); 4714 } 4715 if ($is_patch && $chk_signoff && $signoff == 0) { 4716 ERROR("MISSING_SIGN_OFF", 4717 "Missing Signed-off-by: line(s)\n"); 4718 } 4719 4720 print report_dump(); 4721 if ($summary && !($clean == 1 && $quiet == 1)) { 4722 print "$filename " if ($summary_file); 4723 print "total: $cnt_error errors, $cnt_warn warnings, " . 4724 (($check)? "$cnt_chk checks, " : "") . 4725 "$cnt_lines lines checked\n"; 4726 print "\n" if ($quiet == 0); 4727 } 4728 4729 if ($quiet == 0) { 4730 4731 if ($^V lt 5.10.0) { 4732 print("NOTE: perl $^V is not modern enough to detect all possible issues.\n"); 4733 print("An upgrade to at least perl v5.10.0 is suggested.\n\n"); 4734 } 4735 4736 # If there were whitespace errors which cleanpatch can fix 4737 # then suggest that. 4738 if ($rpt_cleaners) { 4739 print "NOTE: whitespace errors detected, you may wish to use scripts/cleanpatch or\n"; 4740 print " scripts/cleanfile\n\n"; 4741 $rpt_cleaners = 0; 4742 } 4743 } 4744 4745 hash_show_words(\%use_type, "Used"); 4746 hash_show_words(\%ignore_type, "Ignored"); 4747 4748 if ($clean == 0 && $fix && "@rawlines" ne "@fixed") { 4749 my $newfile = $filename; 4750 $newfile .= ".EXPERIMENTAL-checkpatch-fixes" if (!$fix_inplace); 4751 my $linecount = 0; 4752 my $f; 4753 4754 open($f, '>', $newfile) 4755 or die "$P: Can't open $newfile for write\n"; 4756 foreach my $fixed_line (@fixed) { 4757 $linecount++; 4758 if ($file) { 4759 if ($linecount > 3) { 4760 $fixed_line =~ s/^\+//; 4761 print $f $fixed_line. "\n"; 4762 } 4763 } else { 4764 print $f $fixed_line . "\n"; 4765 } 4766 } 4767 close($f); 4768 4769 if (!$quiet) { 4770 print << "EOM"; 4771Wrote EXPERIMENTAL --fix correction(s) to '$newfile' 4772 4773Do _NOT_ trust the results written to this file. 4774Do _NOT_ submit these changes without inspecting them for correctness. 4775 4776This EXPERIMENTAL file is simply a convenience to help rewrite patches. 4777No warranties, expressed or implied... 4778 4779EOM 4780 } 4781 } 4782 4783 if ($clean == 1 && $quiet == 0) { 4784 print "$vname has no obvious style problems and is ready for submission.\n" 4785 } 4786 if ($clean == 0 && $quiet == 0) { 4787 print << "EOM"; 4788$vname has style problems, please review. 4789 4790If any of these errors are false positives, please report 4791them to the maintainer, see CHECKPATCH in MAINTAINERS. 4792EOM 4793 } 4794 4795 return $clean; 4796} 4797