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
12 use Term::ANSIColor qw(:constants);
15 my $D = dirname(abs_path($P));
19 use Getopt::Long qw(:config no_auto_abbrev);
48 my $configuration_file = ".checkpatch.conf";
49 my $max_line_length = 80;
50 my $ignore_perl_version = 0;
51 my $minimum_perl_version = 5.10.0;
52 my $min_conf_desc_length = 4;
53 my $spelling_file = "$D/spelling.txt";
55 my $codespellfile = "/usr/share/codespell/dictionary.txt";
62 Usage: $P [OPTION]... [FILE]...
67 --no-tree run without a kernel tree
68 --no-signoff do not check for 'Signed-off-by' line
69 --patch treat FILE as patchfile (default)
70 --emacs emacs compile window format
71 --terse one line per report
72 --showfile emit diffed file position, not input file position
73 -g, --git treat FILE as a single commit or git revision range
74 single git commit with:
78 multiple git commits with:
82 git merges are ignored
83 -f, --file treat FILE as regular source file
84 --subjective, --strict enable more subjective tests
85 --list-types list the possible message types
86 --types TYPE(,TYPE2...) show only these comma separated message types
87 --ignore TYPE(,TYPE2...) ignore various comma separated message types
88 --show-types show the specific message type in the output
89 --max-line-length=n set the maximum line length, if exceeded, warn
90 --min-conf-desc-length=n set the min description length, if shorter, warn
91 --root=PATH PATH to the kernel tree root
92 --no-summary suppress the per-file summary
93 --mailback only produce a report in case of warnings/errors
94 --summary-file include the filename in summary
95 --debug KEY=[0|1] turn on/off debugging of KEY, where KEY is one of
96 'values', 'possible', 'type', and 'attr' (default
98 --test-only=WORD report only warnings/errors containing WORD
100 --fix EXPERIMENTAL - may create horrible results
101 If correctable single-line errors exist, create
102 "<inputfile>.EXPERIMENTAL-checkpatch-fixes"
103 with potential errors corrected to the preferred
105 --fix-inplace EXPERIMENTAL - may create horrible results
106 Is the same as --fix, but overwrites the input
107 file. It's your fault if there's no backup or git
108 --ignore-perl-version override checking of perl version. expect
110 --codespell Use the codespell dictionary for spelling/typos
111 (default:/usr/share/codespell/dictionary.txt)
112 --codespellfile Use this codespell dictionary
113 --color Use colors when output is STDOUT (default: on)
114 -h, --help, --version display this help and exit
116 When FILE is - read standard input.
124 return grep { !$seen{$_}++ } @_;
134 open(my $script, '<', abs_path($P)) or
135 die "$P: Can't read '$P' $!\n";
137 my $text = <$script>;
141 for ($text =~ /\b(?:(?:CHK|WARN|ERROR)\s*\(\s*"([^"]+)")/g) {
144 @types = sort(uniq(@types));
145 print("#\tMessage type\n\n");
146 foreach my $type (@types) {
147 print(++$count . "\t" . $type . "\n");
153 my $conf = which_conf($configuration_file);
156 open(my $conffile, '<', "$conf")
157 or warn "$P: Can't find a readable $configuration_file file $!\n";
159 while (<$conffile>) {
162 $line =~ s/\s*\n?$//g;
166 next if ($line =~ m/^\s*#/);
167 next if ($line =~ m/^\s*$/);
169 my @words = split(" ", $line);
170 foreach my $word (@words) {
171 last if ($word =~ m/^#/);
172 push (@conf_args, $word);
176 unshift(@ARGV, @conf_args) if @conf_args;
180 'q|quiet+' => \$quiet,
182 'signoff!' => \$chk_signoff,
183 'patch!' => \$chk_patch,
186 'showfile!' => \$showfile,
189 'subjective!' => \$check,
190 'strict!' => \$check,
191 'ignore=s' => \@ignore,
193 'show-types!' => \$show_types,
194 'list-types!' => \$list_types,
195 'max-line-length=i' => \$max_line_length,
196 'min-conf-desc-length=i' => \$min_conf_desc_length,
198 'summary!' => \$summary,
199 'mailback!' => \$mailback,
200 'summary-file!' => \$summary_file,
202 'fix-inplace!' => \$fix_inplace,
203 'ignore-perl-version!' => \$ignore_perl_version,
204 'debug=s' => \%debug,
205 'test-only=s' => \$tst_only,
206 'codespell!' => \$codespell,
207 'codespellfile=s' => \$codespellfile,
215 list_types(0) if ($list_types);
217 $fix = 1 if ($fix_inplace);
218 $check_orig = $check;
222 if ($^V && $^V lt $minimum_perl_version) {
223 printf "$P: requires at least perl version %vd\n", $minimum_perl_version;
224 if (!$ignore_perl_version) {
230 print "$P: no input files\n";
234 sub hash_save_array_words {
235 my ($hashRef, $arrayRef) = @_;
237 my @array = split(/,/, join(',', @$arrayRef));
238 foreach my $word (@array) {
239 $word =~ s/\s*\n?$//g;
242 $word =~ tr/[a-z]/[A-Z]/;
244 next if ($word =~ m/^\s*#/);
245 next if ($word =~ m/^\s*$/);
251 sub hash_show_words {
252 my ($hashRef, $prefix) = @_;
254 if (keys %$hashRef) {
255 print "\nNOTE: $prefix message types:";
256 foreach my $word (sort keys %$hashRef) {
263 hash_save_array_words(\%ignore_type, \@ignore);
264 hash_save_array_words(\%use_type, \@use);
267 my $dbg_possible = 0;
270 for my $key (keys %debug) {
272 eval "\${dbg_$key} = '$debug{$key}';";
276 my $rpt_cleaners = 0;
285 if (!top_of_kernel_tree($root)) {
286 die "$P: $root: --root does not point at a valid tree\n";
289 if (top_of_kernel_tree('.')) {
291 } elsif ($0 =~ m@(.*)/scripts/[^/]*$@ &&
292 top_of_kernel_tree($1)) {
297 if (!defined $root) {
298 print "Must be run from the top-level dir. of a kernel tree\n";
303 my $emitted_corrupt = 0;
306 [A-Za-z_][A-Za-z\d_]*
307 (?:\s*\#\#\s*[A-Za-z_][A-Za-z\d_]*)*
309 our $Storage = qr{extern|static|asmlinkage};
323 our $InitAttributePrefix = qr{__(?:mem|cpu|dev|net_|)};
324 our $InitAttributeData = qr{$InitAttributePrefix(?:initdata\b)};
325 our $InitAttributeConst = qr{$InitAttributePrefix(?:initconst\b)};
326 our $InitAttributeInit = qr{$InitAttributePrefix(?:init\b)};
327 our $InitAttribute = qr{$InitAttributeData|$InitAttributeConst|$InitAttributeInit};
329 # Notes to $Attribute:
330 # We need \b after 'init' otherwise 'initconst' will cause a false positive in a check
351 ____cacheline_aligned|
352 ____cacheline_aligned_in_smp|
353 ____cacheline_internodealigned_in_smp|
357 our $Inline = qr{inline|__always_inline|noinline|__inline|__inline__};
358 our $Member = qr{->$Ident|\.$Ident|\[[^]]*\]};
359 our $Lval = qr{$Ident(?:$Member)*};
361 our $Int_type = qr{(?i)llu|ull|ll|lu|ul|l|u};
362 our $Binary = qr{(?i)0b[01]+$Int_type?};
363 our $Hex = qr{(?i)0x[0-9a-f]+$Int_type?};
364 our $Int = qr{[0-9]+$Int_type?};
365 our $Octal = qr{0[0-7]+$Int_type?};
366 our $String = qr{"[X\t]*"};
367 our $Float_hex = qr{(?i)0x[0-9a-f]+p-?[0-9]+[fl]?};
368 our $Float_dec = qr{(?i)(?:[0-9]+\.[0-9]*|[0-9]*\.[0-9]+)(?:e-?[0-9]+)?[fl]?};
369 our $Float_int = qr{(?i)[0-9]+e-?[0-9]+[fl]?};
370 our $Float = qr{$Float_hex|$Float_dec|$Float_int};
371 our $Constant = qr{$Float|$Binary|$Octal|$Hex|$Int};
372 our $Assignment = qr{\*\=|/=|%=|\+=|-=|<<=|>>=|&=|\^=|\|=|=};
373 our $Compare = qr{<=|>=|==|!=|<|(?<!-)>};
374 our $Arithmetic = qr{\+|-|\*|\/|%};
378 &&|\|\||,|\^|\+\+|--|&|\||$Arithmetic
381 our $c90_Keywords = qr{do|for|while|if|else|return|goto|continue|switch|default|case|break}x;
385 our $NonptrTypeMisordered;
386 our $NonptrTypeWithAttr;
390 our $DeclareMisordered;
392 our $NON_ASCII_UTF8 = qr{
393 [\xC2-\xDF][\x80-\xBF] # non-overlong 2-byte
394 | \xE0[\xA0-\xBF][\x80-\xBF] # excluding overlongs
395 | [\xE1-\xEC\xEE\xEF][\x80-\xBF]{2} # straight 3-byte
396 | \xED[\x80-\x9F][\x80-\xBF] # excluding surrogates
397 | \xF0[\x90-\xBF][\x80-\xBF]{2} # planes 1-3
398 | [\xF1-\xF3][\x80-\xBF]{3} # planes 4-15
399 | \xF4[\x80-\x8F][\x80-\xBF]{2} # plane 16
403 [\x09\x0A\x0D\x20-\x7E] # ASCII
407 our $typeC99Typedefs = qr{(?:__)?(?:[us]_?)?int_?(?:8|16|32|64)_t};
408 our $typeOtherOSTypedefs = qr{(?x:
409 u_(?:char|short|int|long) | # bsd
410 u(?:nchar|short|int|long) # sysv
412 our $typeKernelTypedefs = qr{(?x:
413 (?:__)?(?:u|s|be|le)(?:8|16|32|64)|
416 our $typeTypedefs = qr{(?x:
418 $typeOtherOSTypedefs\b|
419 $typeKernelTypedefs\b
422 our $zero_initializer = qr{(?:(?:0[xX])?0+$Int_type?|NULL|false)\b};
424 our $logFunctions = qr{(?x:
425 printk(?:_ratelimited|_once|)|
426 (?:[a-z0-9]+_){1,2}(?:printk|emerg|alert|crit|err|warning|warn|notice|info|debug|dbg|vdbg|devel|cont|WARN)(?:_ratelimited|_once|)|
427 WARN(?:_RATELIMIT|_ONCE|)|
430 seq_vprintf|seq_printf|seq_puts
433 our $signature_tags = qr{(?xi:
444 our @typeListMisordered = (
445 qr{char\s+(?:un)?signed},
446 qr{int\s+(?:(?:un)?signed\s+)?short\s},
447 qr{int\s+short(?:\s+(?:un)?signed)},
448 qr{short\s+int(?:\s+(?:un)?signed)},
449 qr{(?:un)?signed\s+int\s+short},
450 qr{short\s+(?:un)?signed},
451 qr{long\s+int\s+(?:un)?signed},
452 qr{int\s+long\s+(?:un)?signed},
453 qr{long\s+(?:un)?signed\s+int},
454 qr{int\s+(?:un)?signed\s+long},
455 qr{int\s+(?:un)?signed},
456 qr{int\s+long\s+long\s+(?:un)?signed},
457 qr{long\s+long\s+int\s+(?:un)?signed},
458 qr{long\s+long\s+(?:un)?signed\s+int},
459 qr{long\s+long\s+(?:un)?signed},
460 qr{long\s+(?:un)?signed},
465 qr{(?:(?:un)?signed\s+)?char},
466 qr{(?:(?:un)?signed\s+)?short\s+int},
467 qr{(?:(?:un)?signed\s+)?short},
468 qr{(?:(?:un)?signed\s+)?int},
469 qr{(?:(?:un)?signed\s+)?long\s+int},
470 qr{(?:(?:un)?signed\s+)?long\s+long\s+int},
471 qr{(?:(?:un)?signed\s+)?long\s+long},
472 qr{(?:(?:un)?signed\s+)?long},
481 qr{${Ident}_handler},
482 qr{${Ident}_handler_fn},
486 our $C90_int_types = qr{(?x:
487 long\s+long\s+int\s+(?:un)?signed|
488 long\s+long\s+(?:un)?signed\s+int|
489 long\s+long\s+(?:un)?signed|
490 (?:(?:un)?signed\s+)?long\s+long\s+int|
491 (?:(?:un)?signed\s+)?long\s+long|
492 int\s+long\s+long\s+(?:un)?signed|
493 int\s+(?:(?:un)?signed\s+)?long\s+long|
495 long\s+int\s+(?:un)?signed|
496 long\s+(?:un)?signed\s+int|
497 long\s+(?:un)?signed|
498 (?:(?:un)?signed\s+)?long\s+int|
499 (?:(?:un)?signed\s+)?long|
500 int\s+long\s+(?:un)?signed|
501 int\s+(?:(?:un)?signed\s+)?long|
504 (?:(?:un)?signed\s+)?int
507 our @typeListFile = ();
508 our @typeListWithAttr = (
510 qr{struct\s+$InitAttribute\s+$Ident},
511 qr{union\s+$InitAttribute\s+$Ident},
514 our @modifierList = (
517 our @modifierListFile = ();
519 our @mode_permission_funcs = (
521 ["module_param_(?:array|named|string)", 4],
522 ["module_param_array_named", 5],
523 ["debugfs_create_(?:file|u8|u16|u32|u64|x8|x16|x32|x64|size_t|atomic_t|bool|blob|regset32|u32_array)", 2],
524 ["proc_create(?:_data|)", 2],
525 ["(?:CLASS|DEVICE|SENSOR)_ATTR", 2],
528 #Create a search pattern for all these functions to speed up a loop below
529 our $mode_perms_search = "";
530 foreach my $entry (@mode_permission_funcs) {
531 $mode_perms_search .= '|' if ($mode_perms_search ne "");
532 $mode_perms_search .= $entry->[0];
535 our $mode_perms_world_writable = qr{
543 our $allowed_asm_includes = qr{(?x:
549 # memory.h: ARM has a custom one
551 # Load common spelling mistakes and build regular expression list.
555 if (open(my $spelling, '<', $spelling_file)) {
556 while (<$spelling>) {
559 $line =~ s/\s*\n?$//g;
562 next if ($line =~ m/^\s*#/);
563 next if ($line =~ m/^\s*$/);
565 my ($suspect, $fix) = split(/\|\|/, $line);
567 $spelling_fix{$suspect} = $fix;
571 warn "No typos will be found - file '$spelling_file': $!\n";
575 if (open(my $spelling, '<', $codespellfile)) {
576 while (<$spelling>) {
579 $line =~ s/\s*\n?$//g;
582 next if ($line =~ m/^\s*#/);
583 next if ($line =~ m/^\s*$/);
584 next if ($line =~ m/, disabled/i);
588 my ($suspect, $fix) = split(/->/, $line);
590 $spelling_fix{$suspect} = $fix;
594 warn "No codespell typos will be found - file '$codespellfile': $!\n";
598 $misspellings = join("|", sort keys %spelling_fix) if keys %spelling_fix;
601 my $mods = "(?x: \n" . join("|\n ", (@modifierList, @modifierListFile)) . "\n)";
602 my $all = "(?x: \n" . join("|\n ", (@typeList, @typeListFile)) . "\n)";
603 my $Misordered = "(?x: \n" . join("|\n ", @typeListMisordered) . "\n)";
604 my $allWithAttr = "(?x: \n" . join("|\n ", @typeListWithAttr) . "\n)";
605 $Modifier = qr{(?:$Attribute|$Sparse|$mods)};
611 (?:$Modifier\s+|const\s+)*
613 (?:typeof|__typeof__)\s*\([^\)]*\)|
617 (?:\s+$Modifier|\s+const)*
619 $NonptrTypeMisordered = qr{
620 (?:$Modifier\s+|const\s+)*
624 (?:\s+$Modifier|\s+const)*
626 $NonptrTypeWithAttr = qr{
627 (?:$Modifier\s+|const\s+)*
629 (?:typeof|__typeof__)\s*\([^\)]*\)|
633 (?:\s+$Modifier|\s+const)*
637 (?:(?:\s|\*|\[\])+\s*const|(?:\s|\*\s*(?:const\s*)?|\[\])+|(?:\s*\[\s*\])+)?
638 (?:\s+$Inline|\s+$Modifier)*
640 $TypeMisordered = qr{
641 $NonptrTypeMisordered
642 (?:(?:\s|\*|\[\])+\s*const|(?:\s|\*\s*(?:const\s*)?|\[\])+|(?:\s*\[\s*\])+)?
643 (?:\s+$Inline|\s+$Modifier)*
645 $Declare = qr{(?:$Storage\s+(?:$Inline\s+)?)?$Type};
646 $DeclareMisordered = qr{(?:$Storage\s+(?:$Inline\s+)?)?$TypeMisordered};
650 our $Typecast = qr{\s*(\(\s*$NonptrType\s*\)){0,1}\s*};
652 # Using $balanced_parens, $LvalOrFunc, or $FuncArg
653 # requires at least perl version v5.10.0
654 # Any use must be runtime checked with $^V
656 our $balanced_parens = qr/(\((?:[^\(\)]++|(?-1))*\))/;
657 our $LvalOrFunc = qr{((?:[\&\*]\s*)?$Lval)\s*($balanced_parens{0,1})\s*};
658 our $FuncArg = qr{$Typecast{0,1}($LvalOrFunc|$Constant|$String)};
660 our $declaration_macros = qr{(?x:
661 (?:$Storage\s+)?(?:[A-Z_][A-Z0-9]*_){0,2}(?:DEFINE|DECLARE)(?:_[A-Z0-9]+){1,6}\s*\(|
662 (?:$Storage\s+)?LIST_HEAD\s*\(|
663 (?:$Storage\s+)?${Type}\s+uninitialized_var\s*\(
668 return "" if (!defined($string));
670 while ($string =~ /^\s*\(.*\)\s*$/) {
671 $string =~ s@^\s*\(\s*@@;
672 $string =~ s@\s*\)\s*$@@;
675 $string =~ s@\s+@ @g;
680 sub seed_camelcase_file {
683 return if (!(-f $file));
687 open(my $include_file, '<', "$file")
688 or warn "$P: Can't read '$file' $!\n";
689 my $text = <$include_file>;
690 close($include_file);
692 my @lines = split('\n', $text);
694 foreach my $line (@lines) {
695 next if ($line !~ /(?:[A-Z][a-z]|[a-z][A-Z])/);
696 if ($line =~ /^[ \t]*(?:#[ \t]*define|typedef\s+$Type)\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)/) {
698 } elsif ($line =~ /^\s*$Declare\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)\s*[\(\[,;]/) {
700 } elsif ($line =~ /^\s*(?:union|struct|enum)\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)\s*[;\{]/) {
706 my $camelcase_seeded = 0;
707 sub seed_camelcase_includes {
708 return if ($camelcase_seeded);
711 my $camelcase_cache = "";
712 my @include_files = ();
714 $camelcase_seeded = 1;
717 my $git_last_include_commit = `git log --no-merges --pretty=format:"%h%n" -1 -- include`;
718 chomp $git_last_include_commit;
719 $camelcase_cache = ".checkpatch-camelcase.git.$git_last_include_commit";
721 my $last_mod_date = 0;
722 $files = `find $root/include -name "*.h"`;
723 @include_files = split('\n', $files);
724 foreach my $file (@include_files) {
725 my $date = POSIX::strftime("%Y%m%d%H%M",
726 localtime((stat $file)[9]));
727 $last_mod_date = $date if ($last_mod_date < $date);
729 $camelcase_cache = ".checkpatch-camelcase.date.$last_mod_date";
732 if ($camelcase_cache ne "" && -f $camelcase_cache) {
733 open(my $camelcase_file, '<', "$camelcase_cache")
734 or warn "$P: Can't read '$camelcase_cache' $!\n";
735 while (<$camelcase_file>) {
739 close($camelcase_file);
745 $files = `git ls-files "include/*.h"`;
746 @include_files = split('\n', $files);
749 foreach my $file (@include_files) {
750 seed_camelcase_file($file);
753 if ($camelcase_cache ne "") {
754 unlink glob ".checkpatch-camelcase.*";
755 open(my $camelcase_file, '>', "$camelcase_cache")
756 or warn "$P: Can't write '$camelcase_cache' $!\n";
757 foreach (sort { lc($a) cmp lc($b) } keys(%camelcase)) {
758 print $camelcase_file ("$_\n");
760 close($camelcase_file);
764 sub git_commit_info {
765 my ($commit, $id, $desc) = @_;
767 return ($id, $desc) if ((which("git") eq "") || !(-e ".git"));
769 my $output = `git log --no-color --format='%H %s' -1 $commit 2>&1`;
770 $output =~ s/^\s*//gm;
771 my @lines = split("\n", $output);
773 return ($id, $desc) if ($#lines < 0);
775 if ($lines[0] =~ /^error: short SHA1 $commit is ambiguous\./) {
776 # Maybe one day convert this block of bash into something that returns
777 # all matching commit ids, but it's very slow...
779 # echo "checking commits $1..."
780 # git rev-list --remotes | grep -i "^$1" |
781 # while read line ; do
782 # git log --format='%H %s' -1 $line |
783 # echo "commit $(cut -c 1-12,41-)"
785 } elsif ($lines[0] =~ /^fatal: ambiguous argument '$commit': unknown revision or path not in the working tree\./) {
787 $id = substr($lines[0], 0, 12);
788 $desc = substr($lines[0], 41);
794 $chk_signoff = 0 if ($file);
799 my @fixed_inserted = ();
800 my @fixed_deleted = ();
803 # If input is git commits, extract all commits from the commit expressions.
804 # For example, HEAD-3 means we need check 'HEAD, HEAD~1, HEAD~2'.
805 die "$P: No git repository found\n" if ($git && !-e ".git");
809 for my $commit_expr (@ARGV) {
811 if ($commit_expr =~ m/-/) {
812 my @tmp = split(/-/, $commit_expr);
813 die "$P: incorrect git commits expression $commit_expr$!\n"
815 $git_range = "-$tmp[1] $tmp[0]";
816 } elsif ($commit_expr =~ m/\.\./) {
817 $git_range = "$commit_expr";
819 if (defined $git_range) {
820 my $lines = `git log --no-merges --pretty=format:'%H' $git_range`;
821 foreach my $line (split(/\n/, $lines)) {
822 unshift(@commits, $line);
825 unshift(@commits, $commit_expr);
828 die "$P: no git commits after extraction!\n" if (@commits == 0);
833 for my $filename (@ARGV) {
836 open($FILE, '-|', "git format-patch -M --stdout -1 $filename") ||
837 die "$P: $filename: git format-patch failed - $!\n";
839 open($FILE, '-|', "diff -u /dev/null $filename") ||
840 die "$P: $filename: diff failed - $!\n";
841 } elsif ($filename eq '-') {
842 open($FILE, '<&STDIN');
844 open($FILE, '<', "$filename") ||
845 die "$P: $filename: open failed - $!\n";
847 if ($filename eq '-') {
848 $vname = 'Your patch';
850 $vname = "Commit " . substr($filename, 0, 12) . `git log -1 --pretty=format:' ("%s")' $filename`;
860 if ($#ARGV > 0 && $quiet == 0) {
861 print '-' x length($vname) . "\n";
863 print '-' x length($vname) . "\n";
866 if (!process($filename)) {
872 @fixed_inserted = ();
875 @modifierListFile = ();
881 hash_show_words(\%use_type, "Used");
882 hash_show_words(\%ignore_type, "Ignored");
887 NOTE: perl $^V is not modern enough to detect all possible issues.
888 An upgrade to at least perl v5.10.0 is suggested.
894 NOTE: If any of the errors are false positives, please report
895 them to the maintainer, see CHECKPATCH in MAINTAINERS.
902 sub top_of_kernel_tree {
906 "COPYING", "CREDITS", "Kbuild", "MAINTAINERS", "Makefile",
907 "README", "Documentation", "arch", "include", "drivers",
908 "fs", "init", "ipc", "kernel", "lib", "scripts",
911 foreach my $check (@tree_check) {
912 if (! -e $root . '/' . $check) {
920 my ($formatted_email) = @_;
926 if ($formatted_email =~ /^(.*)<(\S+\@\S+)>(.*)$/) {
929 $comment = $3 if defined $3;
930 } elsif ($formatted_email =~ /^\s*<(\S+\@\S+)>(.*)$/) {
932 $comment = $2 if defined $2;
933 } elsif ($formatted_email =~ /(\S+\@\S+)(.*)$/) {
935 $comment = $2 if defined $2;
936 $formatted_email =~ s/$address.*$//;
937 $name = $formatted_email;
939 $name =~ s/^\"|\"$//g;
940 # If there's a name left after stripping spaces and
941 # leading quotes, and the address doesn't have both
942 # leading and trailing angle brackets, the address
944 # "joe smith joe@smith.com" bad
945 # "joe smith <joe@smith.com" bad
946 if ($name ne "" && $address !~ /^<[^>]+>$/) {
954 $name =~ s/^\"|\"$//g;
955 $address = trim($address);
956 $address =~ s/^\<|\>$//g;
958 if ($name =~ /[^\w \-]/i) { ##has "must quote" chars
959 $name =~ s/(?<!\\)"/\\"/g; ##escape quotes
963 return ($name, $address, $comment);
967 my ($name, $address) = @_;
972 $name =~ s/^\"|\"$//g;
973 $address = trim($address);
975 if ($name =~ /[^\w \-]/i) { ##has "must quote" chars
976 $name =~ s/(?<!\\)"/\\"/g; ##escape quotes
981 $formatted_email = "$address";
983 $formatted_email = "$name <$address>";
986 return $formatted_email;
992 foreach my $path (split(/:/, $ENV{PATH})) {
993 if (-e "$path/$bin") {
1004 foreach my $path (split(/:/, ".:$ENV{HOME}:.scripts")) {
1005 if (-e "$path/$conf") {
1006 return "$path/$conf";
1018 for my $c (split(//, $str)) {
1022 for (; ($n % 8) != 0; $n++) {
1034 (my $res = shift) =~ tr/\t/ /c;
1041 # Drop the diff line leader and expand tabs
1043 $line = expand_tabs($line);
1045 # Pick the indent from the front of the line.
1046 my ($white) = ($line =~ /^(\s*)/);
1048 return (length($line), length($white));
1051 my $sanitise_quote = '';
1053 sub sanitise_line_reset {
1054 my ($in_comment) = @_;
1057 $sanitise_quote = '*/';
1059 $sanitise_quote = '';
1072 # Always copy over the diff marker.
1073 $res = substr($line, 0, 1);
1075 for ($off = 1; $off < length($line); $off++) {
1076 $c = substr($line, $off, 1);
1078 # Comments we are wacking completly including the begin
1079 # and end, all to $;.
1080 if ($sanitise_quote eq '' && substr($line, $off, 2) eq '/*') {
1081 $sanitise_quote = '*/';
1083 substr($res, $off, 2, "$;$;");
1087 if ($sanitise_quote eq '*/' && substr($line, $off, 2) eq '*/') {
1088 $sanitise_quote = '';
1089 substr($res, $off, 2, "$;$;");
1093 if ($sanitise_quote eq '' && substr($line, $off, 2) eq '//') {
1094 $sanitise_quote = '//';
1096 substr($res, $off, 2, $sanitise_quote);
1101 # A \ in a string means ignore the next character.
1102 if (($sanitise_quote eq "'" || $sanitise_quote eq '"') &&
1104 substr($res, $off, 2, 'XX');
1109 if ($c eq "'" || $c eq '"') {
1110 if ($sanitise_quote eq '') {
1111 $sanitise_quote = $c;
1113 substr($res, $off, 1, $c);
1115 } elsif ($sanitise_quote eq $c) {
1116 $sanitise_quote = '';
1120 #print "c<$c> SQ<$sanitise_quote>\n";
1121 if ($off != 0 && $sanitise_quote eq '*/' && $c ne "\t") {
1122 substr($res, $off, 1, $;);
1123 } elsif ($off != 0 && $sanitise_quote eq '//' && $c ne "\t") {
1124 substr($res, $off, 1, $;);
1125 } elsif ($off != 0 && $sanitise_quote && $c ne "\t") {
1126 substr($res, $off, 1, 'X');
1128 substr($res, $off, 1, $c);
1132 if ($sanitise_quote eq '//') {
1133 $sanitise_quote = '';
1136 # The pathname on a #include may be surrounded by '<' and '>'.
1137 if ($res =~ /^.\s*\#\s*include\s+\<(.*)\>/) {
1138 my $clean = 'X' x length($1);
1139 $res =~ s@\<.*\>@<$clean>@;
1141 # The whole of a #error is a string.
1142 } elsif ($res =~ /^.\s*\#\s*(?:error|warning)\s+(.*)\b/) {
1143 my $clean = 'X' x length($1);
1144 $res =~ s@(\#\s*(?:error|warning)\s+).*@$1$clean@;
1150 sub get_quoted_string {
1151 my ($line, $rawline) = @_;
1153 return "" if ($line !~ m/($String)/g);
1154 return substr($rawline, $-[0], $+[0] - $-[0]);
1157 sub ctx_statement_block {
1158 my ($linenr, $remain, $off) = @_;
1159 my $line = $linenr - 1;
1162 my $coff = $off - 1;
1176 @stack = (['', 0]) if ($#stack == -1);
1178 #warn "CSB: blk<$blk> remain<$remain>\n";
1179 # If we are about to drop off the end, pull in more
1182 for (; $remain > 0; $line++) {
1183 last if (!defined $lines[$line]);
1184 next if ($lines[$line] =~ /^-/);
1187 $blk .= $lines[$line] . "\n";
1188 $len = length($blk);
1192 # Bail if there is no further context.
1193 #warn "CSB: blk<$blk> off<$off> len<$len>\n";
1197 if ($level == 0 && substr($blk, $off) =~ /^.\s*#\s*define/) {
1203 $c = substr($blk, $off, 1);
1204 $remainder = substr($blk, $off);
1206 #warn "CSB: c<$c> type<$type> level<$level> remainder<$remainder> coff_set<$coff_set>\n";
1208 # Handle nested #if/#else.
1209 if ($remainder =~ /^#\s*(?:ifndef|ifdef|if)\s/) {
1210 push(@stack, [ $type, $level ]);
1211 } elsif ($remainder =~ /^#\s*(?:else|elif)\b/) {
1212 ($type, $level) = @{$stack[$#stack - 1]};
1213 } elsif ($remainder =~ /^#\s*endif\b/) {
1214 ($type, $level) = @{pop(@stack)};
1217 # Statement ends at the ';' or a close '}' at the
1219 if ($level == 0 && $c eq ';') {
1223 # An else is really a conditional as long as its not else if
1224 if ($level == 0 && $coff_set == 0 &&
1225 (!defined($p) || $p =~ /(?:\s|\}|\+)/) &&
1226 $remainder =~ /^(else)(?:\s|{)/ &&
1227 $remainder !~ /^else\s+if\b/) {
1228 $coff = $off + length($1) - 1;
1230 #warn "CSB: mark coff<$coff> soff<$soff> 1<$1>\n";
1231 #warn "[" . substr($blk, $soff, $coff - $soff + 1) . "]\n";
1234 if (($type eq '' || $type eq '(') && $c eq '(') {
1238 if ($type eq '(' && $c eq ')') {
1240 $type = ($level != 0)? '(' : '';
1242 if ($level == 0 && $coff < $soff) {
1245 #warn "CSB: mark coff<$coff>\n";
1248 if (($type eq '' || $type eq '{') && $c eq '{') {
1252 if ($type eq '{' && $c eq '}') {
1254 $type = ($level != 0)? '{' : '';
1257 if (substr($blk, $off + 1, 1) eq ';') {
1263 # Preprocessor commands end at the newline unless escaped.
1264 if ($type eq '#' && $c eq "\n" && $p ne "\\") {
1272 # We are truly at the end, so shuffle to the next line.
1279 my $statement = substr($blk, $soff, $off - $soff + 1);
1280 my $condition = substr($blk, $soff, $coff - $soff + 1);
1282 #warn "STATEMENT<$statement>\n";
1283 #warn "CONDITION<$condition>\n";
1285 #print "coff<$coff> soff<$off> loff<$loff>\n";
1287 return ($statement, $condition,
1288 $line, $remain + 1, $off - $loff + 1, $level);
1291 sub statement_lines {
1294 # Strip the diff line prefixes and rip blank lines at start and end.
1295 $stmt =~ s/(^|\n)./$1/g;
1299 my @stmt_lines = ($stmt =~ /\n/g);
1301 return $#stmt_lines + 2;
1304 sub statement_rawlines {
1307 my @stmt_lines = ($stmt =~ /\n/g);
1309 return $#stmt_lines + 2;
1312 sub statement_block_size {
1315 $stmt =~ s/(^|\n)./$1/g;
1321 my @stmt_lines = ($stmt =~ /\n/g);
1322 my @stmt_statements = ($stmt =~ /;/g);
1324 my $stmt_lines = $#stmt_lines + 2;
1325 my $stmt_statements = $#stmt_statements + 1;
1327 if ($stmt_lines > $stmt_statements) {
1330 return $stmt_statements;
1334 sub ctx_statement_full {
1335 my ($linenr, $remain, $off) = @_;
1336 my ($statement, $condition, $level);
1340 # Grab the first conditional/block pair.
1341 ($statement, $condition, $linenr, $remain, $off, $level) =
1342 ctx_statement_block($linenr, $remain, $off);
1343 #print "F: c<$condition> s<$statement> remain<$remain>\n";
1344 push(@chunks, [ $condition, $statement ]);
1345 if (!($remain > 0 && $condition =~ /^\s*(?:\n[+-])?\s*(?:if|else|do)\b/s)) {
1346 return ($level, $linenr, @chunks);
1349 # Pull in the following conditional/block pairs and see if they
1350 # could continue the statement.
1352 ($statement, $condition, $linenr, $remain, $off, $level) =
1353 ctx_statement_block($linenr, $remain, $off);
1354 #print "C: c<$condition> s<$statement> remain<$remain>\n";
1355 last if (!($remain > 0 && $condition =~ /^(?:\s*\n[+-])*\s*(?:else|do)\b/s));
1357 push(@chunks, [ $condition, $statement ]);
1360 return ($level, $linenr, @chunks);
1364 my ($linenr, $remain, $outer, $open, $close, $off) = @_;
1366 my $start = $linenr - 1;
1373 my @stack = ($level);
1374 for ($line = $start; $remain > 0; $line++) {
1375 next if ($rawlines[$line] =~ /^-/);
1378 $blk .= $rawlines[$line];
1380 # Handle nested #if/#else.
1381 if ($lines[$line] =~ /^.\s*#\s*(?:ifndef|ifdef|if)\s/) {
1382 push(@stack, $level);
1383 } elsif ($lines[$line] =~ /^.\s*#\s*(?:else|elif)\b/) {
1384 $level = $stack[$#stack - 1];
1385 } elsif ($lines[$line] =~ /^.\s*#\s*endif\b/) {
1386 $level = pop(@stack);
1389 foreach my $c (split(//, $lines[$line])) {
1390 ##print "C<$c>L<$level><$open$close>O<$off>\n";
1396 if ($c eq $close && $level > 0) {
1398 last if ($level == 0);
1399 } elsif ($c eq $open) {
1404 if (!$outer || $level <= 1) {
1405 push(@res, $rawlines[$line]);
1408 last if ($level == 0);
1411 return ($level, @res);
1413 sub ctx_block_outer {
1414 my ($linenr, $remain) = @_;
1416 my ($level, @r) = ctx_block_get($linenr, $remain, 1, '{', '}', 0);
1420 my ($linenr, $remain) = @_;
1422 my ($level, @r) = ctx_block_get($linenr, $remain, 0, '{', '}', 0);
1426 my ($linenr, $remain, $off) = @_;
1428 my ($level, @r) = ctx_block_get($linenr, $remain, 0, '(', ')', $off);
1431 sub ctx_block_level {
1432 my ($linenr, $remain) = @_;
1434 return ctx_block_get($linenr, $remain, 0, '{', '}', 0);
1436 sub ctx_statement_level {
1437 my ($linenr, $remain, $off) = @_;
1439 return ctx_block_get($linenr, $remain, 0, '(', ')', $off);
1442 sub ctx_locate_comment {
1443 my ($first_line, $end_line) = @_;
1445 # Catch a comment on the end of the line itself.
1446 my ($current_comment) = ($rawlines[$end_line - 1] =~ m@.*(/\*.*\*/)\s*(?:\\\s*)?$@);
1447 return $current_comment if (defined $current_comment);
1449 # Look through the context and try and figure out if there is a
1452 $current_comment = '';
1453 for (my $linenr = $first_line; $linenr < $end_line; $linenr++) {
1454 my $line = $rawlines[$linenr - 1];
1456 if ($linenr == $first_line and $line =~ m@^.\s*\*@) {
1459 if ($line =~ m@/\*@) {
1462 if (!$in_comment && $current_comment ne '') {
1463 $current_comment = '';
1465 $current_comment .= $line . "\n" if ($in_comment);
1466 if ($line =~ m@\*/@) {
1471 chomp($current_comment);
1472 return($current_comment);
1474 sub ctx_has_comment {
1475 my ($first_line, $end_line) = @_;
1476 my $cmt = ctx_locate_comment($first_line, $end_line);
1478 ##print "LINE: $rawlines[$end_line - 1 ]\n";
1479 ##print "CMMT: $cmt\n";
1481 return ($cmt ne '');
1485 my ($linenr, $cnt) = @_;
1487 my $offset = $linenr - 1;
1492 $line = $rawlines[$offset++];
1493 next if (defined($line) && $line =~ /^-/);
1505 while ($vet =~ /([^[:cntrl:]]*)([[:cntrl:]]|$)/g) {
1508 $coded = sprintf("^%c", unpack('C', $2) + 64);
1517 my $av_preprocessor = 0;
1522 sub annotate_reset {
1523 $av_preprocessor = 0;
1525 @av_paren_type = ('E');
1526 $av_pend_colon = 'O';
1529 sub annotate_values {
1530 my ($stream, $type) = @_;
1533 my $var = '_' x length($stream);
1536 print "$stream\n" if ($dbg_values > 1);
1538 while (length($cur)) {
1539 @av_paren_type = ('E') if ($#av_paren_type < 0);
1540 print " <" . join('', @av_paren_type) .
1541 "> <$type> <$av_pending>" if ($dbg_values > 1);
1542 if ($cur =~ /^(\s+)/o) {
1543 print "WS($1)\n" if ($dbg_values > 1);
1544 if ($1 =~ /\n/ && $av_preprocessor) {
1545 $type = pop(@av_paren_type);
1546 $av_preprocessor = 0;
1549 } elsif ($cur =~ /^(\(\s*$Type\s*)\)/ && $av_pending eq '_') {
1550 print "CAST($1)\n" if ($dbg_values > 1);
1551 push(@av_paren_type, $type);
1554 } elsif ($cur =~ /^($Type)\s*(?:$Ident|,|\)|\(|\s*$)/) {
1555 print "DECLARE($1)\n" if ($dbg_values > 1);
1558 } elsif ($cur =~ /^($Modifier)\s*/) {
1559 print "MODIFIER($1)\n" if ($dbg_values > 1);
1562 } elsif ($cur =~ /^(\#\s*define\s*$Ident)(\(?)/o) {
1563 print "DEFINE($1,$2)\n" if ($dbg_values > 1);
1564 $av_preprocessor = 1;
1565 push(@av_paren_type, $type);
1571 } elsif ($cur =~ /^(\#\s*(?:undef\s*$Ident|include\b))/o) {
1572 print "UNDEF($1)\n" if ($dbg_values > 1);
1573 $av_preprocessor = 1;
1574 push(@av_paren_type, $type);
1576 } elsif ($cur =~ /^(\#\s*(?:ifdef|ifndef|if))/o) {
1577 print "PRE_START($1)\n" if ($dbg_values > 1);
1578 $av_preprocessor = 1;
1580 push(@av_paren_type, $type);
1581 push(@av_paren_type, $type);
1584 } elsif ($cur =~ /^(\#\s*(?:else|elif))/o) {
1585 print "PRE_RESTART($1)\n" if ($dbg_values > 1);
1586 $av_preprocessor = 1;
1588 push(@av_paren_type, $av_paren_type[$#av_paren_type]);
1592 } elsif ($cur =~ /^(\#\s*(?:endif))/o) {
1593 print "PRE_END($1)\n" if ($dbg_values > 1);
1595 $av_preprocessor = 1;
1597 # Assume all arms of the conditional end as this
1598 # one does, and continue as if the #endif was not here.
1599 pop(@av_paren_type);
1600 push(@av_paren_type, $type);
1603 } elsif ($cur =~ /^(\\\n)/o) {
1604 print "PRECONT($1)\n" if ($dbg_values > 1);
1606 } elsif ($cur =~ /^(__attribute__)\s*\(?/o) {
1607 print "ATTR($1)\n" if ($dbg_values > 1);
1608 $av_pending = $type;
1611 } elsif ($cur =~ /^(sizeof)\s*(\()?/o) {
1612 print "SIZEOF($1)\n" if ($dbg_values > 1);
1618 } elsif ($cur =~ /^(if|while|for)\b/o) {
1619 print "COND($1)\n" if ($dbg_values > 1);
1623 } elsif ($cur =~/^(case)/o) {
1624 print "CASE($1)\n" if ($dbg_values > 1);
1625 $av_pend_colon = 'C';
1628 } elsif ($cur =~/^(return|else|goto|typeof|__typeof__)\b/o) {
1629 print "KEYWORD($1)\n" if ($dbg_values > 1);
1632 } elsif ($cur =~ /^(\()/o) {
1633 print "PAREN('$1')\n" if ($dbg_values > 1);
1634 push(@av_paren_type, $av_pending);
1638 } elsif ($cur =~ /^(\))/o) {
1639 my $new_type = pop(@av_paren_type);
1640 if ($new_type ne '_') {
1642 print "PAREN('$1') -> $type\n"
1643 if ($dbg_values > 1);
1645 print "PAREN('$1')\n" if ($dbg_values > 1);
1648 } elsif ($cur =~ /^($Ident)\s*\(/o) {
1649 print "FUNC($1)\n" if ($dbg_values > 1);
1653 } elsif ($cur =~ /^($Ident\s*):(?:\s*\d+\s*(,|=|;))?/) {
1654 if (defined $2 && $type eq 'C' || $type eq 'T') {
1655 $av_pend_colon = 'B';
1656 } elsif ($type eq 'E') {
1657 $av_pend_colon = 'L';
1659 print "IDENT_COLON($1,$type>$av_pend_colon)\n" if ($dbg_values > 1);
1662 } elsif ($cur =~ /^($Ident|$Constant)/o) {
1663 print "IDENT($1)\n" if ($dbg_values > 1);
1666 } elsif ($cur =~ /^($Assignment)/o) {
1667 print "ASSIGN($1)\n" if ($dbg_values > 1);
1670 } elsif ($cur =~/^(;|{|})/) {
1671 print "END($1)\n" if ($dbg_values > 1);
1673 $av_pend_colon = 'O';
1675 } elsif ($cur =~/^(,)/) {
1676 print "COMMA($1)\n" if ($dbg_values > 1);
1679 } elsif ($cur =~ /^(\?)/o) {
1680 print "QUESTION($1)\n" if ($dbg_values > 1);
1683 } elsif ($cur =~ /^(:)/o) {
1684 print "COLON($1,$av_pend_colon)\n" if ($dbg_values > 1);
1686 substr($var, length($res), 1, $av_pend_colon);
1687 if ($av_pend_colon eq 'C' || $av_pend_colon eq 'L') {
1692 $av_pend_colon = 'O';
1694 } elsif ($cur =~ /^(\[)/o) {
1695 print "CLOSE($1)\n" if ($dbg_values > 1);
1698 } elsif ($cur =~ /^(-(?![->])|\+(?!\+)|\*|\&\&|\&)/o) {
1701 print "OPV($1)\n" if ($dbg_values > 1);
1708 substr($var, length($res), 1, $variant);
1711 } elsif ($cur =~ /^($Operators)/o) {
1712 print "OP($1)\n" if ($dbg_values > 1);
1713 if ($1 ne '++' && $1 ne '--') {
1717 } elsif ($cur =~ /(^.)/o) {
1718 print "C($1)\n" if ($dbg_values > 1);
1721 $cur = substr($cur, length($1));
1722 $res .= $type x length($1);
1726 return ($res, $var);
1730 my ($possible, $line) = @_;
1731 my $notPermitted = qr{(?:
1748 ^(?:typedef|struct|enum)\b
1750 warn "CHECK<$possible> ($line)\n" if ($dbg_possible > 2);
1751 if ($possible !~ $notPermitted) {
1752 # Check for modifiers.
1753 $possible =~ s/\s*$Storage\s*//g;
1754 $possible =~ s/\s*$Sparse\s*//g;
1755 if ($possible =~ /^\s*$/) {
1757 } elsif ($possible =~ /\s/) {
1758 $possible =~ s/\s*$Type\s*//g;
1759 for my $modifier (split(' ', $possible)) {
1760 if ($modifier !~ $notPermitted) {
1761 warn "MODIFIER: $modifier ($possible) ($line)\n" if ($dbg_possible);
1762 push(@modifierListFile, $modifier);
1767 warn "POSSIBLE: $possible ($line)\n" if ($dbg_possible);
1768 push(@typeListFile, $possible);
1772 warn "NOTPOSS: $possible ($line)\n" if ($dbg_possible > 1);
1781 return defined $use_type{$type} if (scalar keys %use_type > 0);
1783 return !defined $ignore_type{$type};
1787 my ($level, $type, $msg) = @_;
1789 if (!show_type($type) ||
1790 (defined $tst_only && $msg !~ /\Q$tst_only\E/)) {
1794 if (-t STDOUT && $color) {
1795 if ($level eq 'ERROR') {
1797 } elsif ($level eq 'WARNING') {
1803 $output .= $prefix . $level . ':';
1805 $output .= BLUE if (-t STDOUT && $color);
1806 $output .= "$type:";
1808 $output .= RESET if (-t STDOUT && $color);
1809 $output .= ' ' . $msg . "\n";
1812 my @lines = split("\n", $output, -1);
1813 splice(@lines, 1, 1);
1814 $output = join("\n", @lines);
1816 $output = (split('\n', $output))[0] . "\n" if ($terse);
1818 push(our @report, $output);
1827 sub fixup_current_range {
1828 my ($lineRef, $offset, $length) = @_;
1830 if ($$lineRef =~ /^\@\@ -\d+,\d+ \+(\d+),(\d+) \@\@/) {
1833 my $no = $o + $offset;
1834 my $nl = $l + $length;
1835 $$lineRef =~ s/\+$o,$l \@\@/\+$no,$nl \@\@/;
1839 sub fix_inserted_deleted_lines {
1840 my ($linesRef, $insertedRef, $deletedRef) = @_;
1842 my $range_last_linenr = 0;
1843 my $delta_offset = 0;
1848 my $next_insert = 0;
1849 my $next_delete = 0;
1853 my $inserted = @{$insertedRef}[$next_insert++];
1854 my $deleted = @{$deletedRef}[$next_delete++];
1856 foreach my $old_line (@{$linesRef}) {
1858 my $line = $old_line; #don't modify the array
1859 if ($line =~ /^(?:\+\+\+|\-\-\-)\s+\S+/) { #new filename
1861 } elsif ($line =~ /^\@\@ -\d+,\d+ \+\d+,\d+ \@\@/) { #new hunk
1862 $range_last_linenr = $new_linenr;
1863 fixup_current_range(\$line, $delta_offset, 0);
1866 while (defined($deleted) && ${$deleted}{'LINENR'} == $old_linenr) {
1867 $deleted = @{$deletedRef}[$next_delete++];
1869 fixup_current_range(\$lines[$range_last_linenr], $delta_offset--, -1);
1872 while (defined($inserted) && ${$inserted}{'LINENR'} == $old_linenr) {
1873 push(@lines, ${$inserted}{'LINE'});
1874 $inserted = @{$insertedRef}[$next_insert++];
1876 fixup_current_range(\$lines[$range_last_linenr], $delta_offset++, 1);
1880 push(@lines, $line);
1890 sub fix_insert_line {
1891 my ($linenr, $line) = @_;
1897 push(@fixed_inserted, $inserted);
1900 sub fix_delete_line {
1901 my ($linenr, $line) = @_;
1908 push(@fixed_deleted, $deleted);
1912 my ($type, $msg) = @_;
1914 if (report("ERROR", $type, $msg)) {
1922 my ($type, $msg) = @_;
1924 if (report("WARNING", $type, $msg)) {
1932 my ($type, $msg) = @_;
1934 if ($check && report("CHECK", $type, $msg)) {
1942 sub check_absolute_file {
1943 my ($absolute, $herecurr) = @_;
1944 my $file = $absolute;
1946 ##print "absolute<$absolute>\n";
1948 # See if any suffix of this path is a path within the tree.
1949 while ($file =~ s@^[^/]*/@@) {
1950 if (-f "$root/$file") {
1951 ##print "file<$file>\n";
1959 # It is, so see if the prefix is acceptable.
1960 my $prefix = $absolute;
1961 substr($prefix, -length($file)) = '';
1963 ##print "prefix<$prefix>\n";
1964 if ($prefix ne ".../") {
1965 WARN("USE_RELATIVE_PATH",
1966 "use relative pathname instead of absolute in changelog text\n" . $herecurr);
1973 $string =~ s/^\s+|\s+$//g;
1981 $string =~ s/^\s+//;
1989 $string =~ s/\s+$//;
1994 sub string_find_replace {
1995 my ($string, $find, $replace) = @_;
1997 $string =~ s/$find/$replace/g;
2005 my $source_indent = 8;
2006 my $max_spaces_before_tab = $source_indent - 1;
2007 my $spaces_to_tab = " " x $source_indent;
2009 #convert leading spaces to tabs
2010 1 while $leading =~ s@^([\t]*)$spaces_to_tab@$1\t@g;
2011 #Remove spaces before a tab
2012 1 while $leading =~ s@^([\t]*)( {1,$max_spaces_before_tab})\t@$1\t@g;
2017 sub pos_last_openparen {
2022 my $opens = $line =~ tr/\(/\(/;
2023 my $closes = $line =~ tr/\)/\)/;
2025 my $last_openparen = 0;
2027 if (($opens == 0) || ($closes >= $opens)) {
2031 my $len = length($line);
2033 for ($pos = 0; $pos < $len; $pos++) {
2034 my $string = substr($line, $pos);
2035 if ($string =~ /^($FuncArg|$balanced_parens)/) {
2036 $pos += length($1) - 1;
2037 } elsif (substr($line, $pos, 1) eq '(') {
2038 $last_openparen = $pos;
2039 } elsif (index($string, '(') == -1) {
2044 return length(expand_tabs(substr($line, 0, $last_openparen))) + 1;
2048 my $filename = shift;
2054 my $stashrawline="";
2064 my $in_header_lines = $file ? 0 : 1;
2065 my $in_commit_log = 0; #Scanning lines before patch
2066 my $commit_log_possible_stack_dump = 0;
2067 my $commit_log_long_line = 0;
2068 my $commit_log_has_diff = 0;
2069 my $reported_maintainer_file = 0;
2070 my $non_utf8_charset = 0;
2072 my $last_blank_line = 0;
2073 my $last_coalesced_string_linenr = -1;
2081 # Trace the real file/line as we go.
2087 my $comment_edge = 0;
2091 my $prev_values = 'E';
2094 my %suppress_ifbraces;
2095 my %suppress_whiletrailers;
2096 my %suppress_export;
2097 my $suppress_statement = 0;
2099 my %signatures = ();
2101 # Pre-scan the patch sanitizing the lines.
2102 # Pre-scan the patch looking for any __setup documentation.
2104 my @setup_docs = ();
2107 my $camelcase_file_seeded = 0;
2109 sanitise_line_reset();
2111 foreach my $rawline (@rawlines) {
2115 push(@fixed, $rawline) if ($fix);
2117 if ($rawline=~/^\+\+\+\s+(\S+)/) {
2119 if ($1 =~ m@Documentation/kernel-parameters.txt$@) {
2124 if ($rawline=~/^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@/) {
2133 # Guestimate if this is a continuing comment. Run
2134 # the context looking for a comment "edge". If this
2135 # edge is a close comment then we must be in a comment
2139 for (my $ln = $linenr + 1; $cnt > 0; $ln++) {
2140 next if (defined $rawlines[$ln - 1] &&
2141 $rawlines[$ln - 1] =~ /^-/);
2143 #print "RAW<$rawlines[$ln - 1]>\n";
2144 last if (!defined $rawlines[$ln - 1]);
2145 if ($rawlines[$ln - 1] =~ m@(/\*|\*/)@ &&
2146 $rawlines[$ln - 1] !~ m@"[^"]*(?:/\*|\*/)[^"]*"@) {
2151 if (defined $edge && $edge eq '*/') {
2155 # Guestimate if this is a continuing comment. If this
2156 # is the start of a diff block and this line starts
2157 # ' *' then it is very likely a comment.
2158 if (!defined $edge &&
2159 $rawlines[$linenr] =~ m@^.\s*(?:\*\*+| \*)(?:\s|$)@)
2164 ##print "COMMENT:$in_comment edge<$edge> $rawline\n";
2165 sanitise_line_reset($in_comment);
2167 } elsif ($realcnt && $rawline =~ /^(?:\+| |$)/) {
2168 # Standardise the strings and chars within the input to
2169 # simplify matching -- only bother with positive lines.
2170 $line = sanitise_line($rawline);
2172 push(@lines, $line);
2175 $realcnt-- if ($line =~ /^(?:\+| |$)/);
2180 #print "==>$rawline\n";
2181 #print "-->$line\n";
2183 if ($setup_docs && $line =~ /^\+/) {
2184 push(@setup_docs, $line);
2193 foreach my $line (@lines) {
2196 my $sline = $line; #copy of $line
2197 $sline =~ s/$;/ /g; #with comments as spaces
2199 my $rawline = $rawlines[$linenr - 1];
2201 #extract the line range in the file after the patch is applied
2202 if (!$in_commit_log &&
2203 $line =~ /^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@/) {
2205 $first_line = $linenr + 1;
2215 %suppress_ifbraces = ();
2216 %suppress_whiletrailers = ();
2217 %suppress_export = ();
2218 $suppress_statement = 0;
2221 # track the line number as we move through the hunk, note that
2222 # new versions of GNU diff omit the leading space on completely
2223 # blank context lines so we need to count that too.
2224 } elsif ($line =~ /^( |\+|$)/) {
2226 $realcnt-- if ($realcnt != 0);
2228 # Measure the line length and indent.
2229 ($length, $indent) = line_stats($rawline);
2231 # Track the previous line.
2232 ($prevline, $stashline) = ($stashline, $line);
2233 ($previndent, $stashindent) = ($stashindent, $indent);
2234 ($prevrawline, $stashrawline) = ($stashrawline, $rawline);
2236 #warn "line<$line>\n";
2238 } elsif ($realcnt == 1) {
2242 my $hunk_line = ($realcnt != 0);
2244 $here = "#$linenr: " if (!$file);
2245 $here = "#$realline: " if ($file);
2248 # extract the filename as it passes
2249 if ($line =~ /^diff --git.*?(\S+)$/) {
2251 $realfile =~ s@^([^/]*)/@@ if (!$file);
2254 } elsif ($line =~ /^\+\+\+\s+(\S+)/) {
2256 $realfile =~ s@^([^/]*)/@@ if (!$file);
2260 if (!$file && $tree && $p1_prefix ne '' &&
2261 -e "$root/$p1_prefix") {
2262 WARN("PATCH_PREFIX",
2263 "patch prefix '$p1_prefix' exists, appears to be a -p0 patch\n");
2266 if ($realfile =~ m@^include/asm/@) {
2267 ERROR("MODIFIED_INCLUDE_ASM",
2268 "do not modify files in include/asm, change architecture specific files in include/asm-<architecture>\n" . "$here$rawline\n");
2273 #make up the handle for any error we report on this line
2275 $prefix = "$realfile:$realline: "
2278 $prefix = "$filename:$realline: ";
2280 $prefix = "$filename:$linenr: ";
2285 if ($realfile =~ m@^(?:drivers/net/|net/|drivers/staging/)@) {
2288 $check = $check_orig;
2293 $here .= "FILE: $realfile:$realline:" if ($realcnt != 0);
2295 my $hereline = "$here\n$rawline\n";
2296 my $herecurr = "$here\n$rawline\n";
2297 my $hereprev = "$here\n$prevrawline\n$rawline\n";
2299 $cnt_lines++ if ($realcnt != 0);
2301 # Check if the commit log has what seems like a diff which can confuse patch
2302 if ($in_commit_log && !$commit_log_has_diff &&
2303 (($line =~ m@^\s+diff\b.*a/[\w/]+@ &&
2304 $line =~ m@^\s+diff\b.*a/([\w/]+)\s+b/$1\b@) ||
2305 $line =~ m@^\s*(?:\-\-\-\s+a/|\+\+\+\s+b/)@ ||
2306 $line =~ m/^\s*\@\@ \-\d+,\d+ \+\d+,\d+ \@\@/)) {
2307 ERROR("DIFF_IN_COMMIT_MSG",
2308 "Avoid using diff content in the commit message - patch(1) might not work\n" . $herecurr);
2309 $commit_log_has_diff = 1;
2312 # Check for incorrect file permissions
2313 if ($line =~ /^new (file )?mode.*[7531]\d{0,2}$/) {
2314 my $permhere = $here . "FILE: $realfile\n";
2315 if ($realfile !~ m@scripts/@ &&
2316 $realfile !~ /\.(py|pl|awk|sh)$/) {
2317 ERROR("EXECUTE_PERMISSIONS",
2318 "do not set execute permissions for source files\n" . $permhere);
2322 # Check the patch for a signoff:
2323 if ($line =~ /^\s*signed-off-by:/i) {
2328 # Check if MAINTAINERS is being updated. If so, there's probably no need to
2329 # emit the "does MAINTAINERS need updating?" message on file add/move/delete
2330 if ($line =~ /^\s*MAINTAINERS\s*\|/) {
2331 $reported_maintainer_file = 1;
2334 # Check signature styles
2335 if (!$in_header_lines &&
2336 $line =~ /^(\s*)([a-z0-9_-]+by:|$signature_tags)(\s*)(.*)/i) {
2337 my $space_before = $1;
2339 my $space_after = $3;
2341 my $ucfirst_sign_off = ucfirst(lc($sign_off));
2343 if ($sign_off !~ /$signature_tags/) {
2344 WARN("BAD_SIGN_OFF",
2345 "Non-standard signature: $sign_off\n" . $herecurr);
2347 if (defined $space_before && $space_before ne "") {
2348 if (WARN("BAD_SIGN_OFF",
2349 "Do not use whitespace before $ucfirst_sign_off\n" . $herecurr) &&
2351 $fixed[$fixlinenr] =
2352 "$ucfirst_sign_off $email";
2355 if ($sign_off =~ /-by:$/i && $sign_off ne $ucfirst_sign_off) {
2356 if (WARN("BAD_SIGN_OFF",
2357 "'$ucfirst_sign_off' is the preferred signature form\n" . $herecurr) &&
2359 $fixed[$fixlinenr] =
2360 "$ucfirst_sign_off $email";
2364 if (!defined $space_after || $space_after ne " ") {
2365 if (WARN("BAD_SIGN_OFF",
2366 "Use a single space after $ucfirst_sign_off\n" . $herecurr) &&
2368 $fixed[$fixlinenr] =
2369 "$ucfirst_sign_off $email";
2373 my ($email_name, $email_address, $comment) = parse_email($email);
2374 my $suggested_email = format_email(($email_name, $email_address));
2375 if ($suggested_email eq "") {
2376 ERROR("BAD_SIGN_OFF",
2377 "Unrecognized email address: '$email'\n" . $herecurr);
2379 my $dequoted = $suggested_email;
2380 $dequoted =~ s/^"//;
2381 $dequoted =~ s/" </ </;
2382 # Don't force email to have quotes
2383 # Allow just an angle bracketed address
2384 if ("$dequoted$comment" ne $email &&
2385 "<$email_address>$comment" ne $email &&
2386 "$suggested_email$comment" ne $email) {
2387 WARN("BAD_SIGN_OFF",
2388 "email address '$email' might be better as '$suggested_email$comment'\n" . $herecurr);
2392 # Check for duplicate signatures
2393 my $sig_nospace = $line;
2394 $sig_nospace =~ s/\s//g;
2395 $sig_nospace = lc($sig_nospace);
2396 if (defined $signatures{$sig_nospace}) {
2397 WARN("BAD_SIGN_OFF",
2398 "Duplicate signature\n" . $herecurr);
2400 $signatures{$sig_nospace} = 1;
2404 # Check email subject for common tools that don't need to be mentioned
2405 if ($in_header_lines &&
2406 $line =~ /^Subject:.*\b(?:checkpatch|sparse|smatch)\b[^:]/i) {
2407 WARN("EMAIL_SUBJECT",
2408 "A patch subject line should describe the change not the tool that found it\n" . $herecurr);
2411 # Check for old stable address
2412 if ($line =~ /^\s*cc:\s*.*<?\bstable\@kernel\.org\b>?.*$/i) {
2413 ERROR("STABLE_ADDRESS",
2414 "The 'stable' address should be 'stable\@vger.kernel.org'\n" . $herecurr);
2417 # Check for unwanted Gerrit info
2418 if ($in_commit_log && $line =~ /^\s*change-id:/i) {
2419 ERROR("GERRIT_CHANGE_ID",
2420 "Remove Gerrit Change-Id's before submitting upstream.\n" . $herecurr);
2423 # Check if the commit log is in a possible stack dump
2424 if ($in_commit_log && !$commit_log_possible_stack_dump &&
2425 ($line =~ /^\s*(?:WARNING:|BUG:)/ ||
2426 $line =~ /^\s*\[\s*\d+\.\d{6,6}\s*\]/ ||
2428 $line =~ /^\s*\[\<[0-9a-fA-F]{8,}\>\]/)) {
2429 # stack dump address
2430 $commit_log_possible_stack_dump = 1;
2433 # Check for line lengths > 75 in commit log, warn once
2434 if ($in_commit_log && !$commit_log_long_line &&
2435 length($line) > 75 &&
2436 !($line =~ /^\s*[a-zA-Z0-9_\/\.]+\s+\|\s+\d+/ ||
2437 # file delta changes
2438 $line =~ /^\s*(?:[\w\.\-]+\/)++[\w\.\-]+:/ ||
2440 $line =~ /^\s*(?:Fixes:|Link:)/i ||
2441 # A Fixes: or Link: line
2442 $commit_log_possible_stack_dump)) {
2443 WARN("COMMIT_LOG_LONG_LINE",
2444 "Possible unwrapped commit description (prefer a maximum 75 chars per line)\n" . $herecurr);
2445 $commit_log_long_line = 1;
2448 # Reset possible stack dump if a blank line is found
2449 if ($in_commit_log && $commit_log_possible_stack_dump &&
2451 $commit_log_possible_stack_dump = 0;
2454 # Check for git id commit length and improperly formed commit descriptions
2455 if ($in_commit_log && !$commit_log_possible_stack_dump &&
2456 ($line =~ /\bcommit\s+[0-9a-f]{5,}\b/i ||
2457 ($line =~ /\b[0-9a-f]{12,40}\b/i &&
2458 $line !~ /[\<\[][0-9a-f]{12,40}[\>\]]/i &&
2459 $line !~ /\bfixes:\s*[0-9a-f]{12,40}/i))) {
2460 my $init_char = "c";
2461 my $orig_commit = "";
2468 my $id = '0123456789ab';
2469 my $orig_desc = "commit description";
2470 my $description = "";
2472 if ($line =~ /\b(c)ommit\s+([0-9a-f]{5,})\b/i) {
2474 $orig_commit = lc($2);
2475 } elsif ($line =~ /\b([0-9a-f]{12,40})\b/i) {
2476 $orig_commit = lc($1);
2479 $short = 0 if ($line =~ /\bcommit\s+[0-9a-f]{12,40}/i);
2480 $long = 1 if ($line =~ /\bcommit\s+[0-9a-f]{41,}/i);
2481 $space = 0 if ($line =~ /\bcommit [0-9a-f]/i);
2482 $case = 0 if ($line =~ /\b[Cc]ommit\s+[0-9a-f]{5,40}[^A-F]/);
2483 if ($line =~ /\bcommit\s+[0-9a-f]{5,}\s+\("([^"]+)"\)/i) {
2486 } elsif ($line =~ /\bcommit\s+[0-9a-f]{5,}\s*$/i &&
2487 defined $rawlines[$linenr] &&
2488 $rawlines[$linenr] =~ /^\s*\("([^"]+)"\)/) {
2491 } elsif ($line =~ /\bcommit\s+[0-9a-f]{5,}\s+\("[^"]+$/i &&
2492 defined $rawlines[$linenr] &&
2493 $rawlines[$linenr] =~ /^\s*[^"]+"\)/) {
2494 $line =~ /\bcommit\s+[0-9a-f]{5,}\s+\("([^"]+)$/i;
2496 $rawlines[$linenr] =~ /^\s*([^"]+)"\)/;
2497 $orig_desc .= " " . $1;
2501 ($id, $description) = git_commit_info($orig_commit,
2504 if ($short || $long || $space || $case || ($orig_desc ne $description) || !$hasparens) {
2505 ERROR("GIT_COMMIT_ID",
2506 "Please use git commit description style 'commit <12+ chars of sha1> (\"<title line>\")' - ie: '${init_char}ommit $id (\"$description\")'\n" . $herecurr);
2510 # Check for added, moved or deleted files
2511 if (!$reported_maintainer_file && !$in_commit_log &&
2512 ($line =~ /^(?:new|deleted) file mode\s*\d+\s*$/ ||
2513 $line =~ /^rename (?:from|to) [\w\/\.\-]+\s*$/ ||
2514 ($line =~ /\{\s*([\w\/\.\-]*)\s*\=\>\s*([\w\/\.\-]*)\s*\}/ &&
2515 (defined($1) || defined($2))))) {
2516 $reported_maintainer_file = 1;
2517 WARN("FILE_PATH_CHANGES",
2518 "added, moved or deleted file(s), does MAINTAINERS need updating?\n" . $herecurr);
2521 # Check for wrappage within a valid hunk of the file
2522 if ($realcnt != 0 && $line !~ m{^(?:\+|-| |\\ No newline|$)}) {
2523 ERROR("CORRUPTED_PATCH",
2524 "patch seems to be corrupt (line wrapped?)\n" .
2525 $herecurr) if (!$emitted_corrupt++);
2528 # Check for absolute kernel paths.
2530 while ($line =~ m{(?:^|\s)(/\S*)}g) {
2533 if ($file =~ m{^(.*?)(?::\d+)+:?$} &&
2534 check_absolute_file($1, $herecurr)) {
2537 check_absolute_file($file, $herecurr);
2542 # UTF-8 regex found at http://www.w3.org/International/questions/qa-forms-utf-8.en.php
2543 if (($realfile =~ /^$/ || $line =~ /^\+/) &&
2544 $rawline !~ m/^$UTF8*$/) {
2545 my ($utf8_prefix) = ($rawline =~ /^($UTF8*)/);
2547 my $blank = copy_spacing($rawline);
2548 my $ptr = substr($blank, 0, length($utf8_prefix)) . "^";
2549 my $hereptr = "$hereline$ptr\n";
2552 "Invalid UTF-8, patch and commit message should be encoded in UTF-8\n" . $hereptr);
2555 # Check if it's the start of a commit log
2556 # (not a header line and we haven't seen the patch filename)
2557 if ($in_header_lines && $realfile =~ /^$/ &&
2558 !($rawline =~ /^\s+\S/ ||
2559 $rawline =~ /^(commit\b|from\b|[\w-]+:).*$/i)) {
2560 $in_header_lines = 0;
2564 # Check if there is UTF-8 in a commit log when a mail header has explicitly
2565 # declined it, i.e defined some charset where it is missing.
2566 if ($in_header_lines &&
2567 $rawline =~ /^Content-Type:.+charset="(.+)".*$/ &&
2569 $non_utf8_charset = 1;
2572 if ($in_commit_log && $non_utf8_charset && $realfile =~ /^$/ &&
2573 $rawline =~ /$NON_ASCII_UTF8/) {
2574 WARN("UTF8_BEFORE_PATCH",
2575 "8-bit UTF-8 used in possible commit log\n" . $herecurr);
2578 # Check for various typo / spelling mistakes
2579 if (defined($misspellings) &&
2580 ($in_commit_log || $line =~ /^(?:\+|Subject:)/i)) {
2581 while ($rawline =~ /(?:^|[^a-z@])($misspellings)(?:\b|$|[^a-z@])/gi) {
2583 my $typo_fix = $spelling_fix{lc($typo)};
2584 $typo_fix = ucfirst($typo_fix) if ($typo =~ /^[A-Z]/);
2585 $typo_fix = uc($typo_fix) if ($typo =~ /^[A-Z]+$/);
2586 my $msg_type = \&WARN;
2587 $msg_type = \&CHK if ($file);
2588 if (&{$msg_type}("TYPO_SPELLING",
2589 "'$typo' may be misspelled - perhaps '$typo_fix'?\n" . $herecurr) &&
2591 $fixed[$fixlinenr] =~ s/(^|[^A-Za-z@])($typo)($|[^A-Za-z@])/$1$typo_fix$3/;
2596 # ignore non-hunk lines and lines being removed
2597 next if (!$hunk_line || $line =~ /^-/);
2599 #trailing whitespace
2600 if ($line =~ /^\+.*\015/) {
2601 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2602 if (ERROR("DOS_LINE_ENDINGS",
2603 "DOS line endings\n" . $herevet) &&
2605 $fixed[$fixlinenr] =~ s/[\s\015]+$//;
2607 } elsif ($rawline =~ /^\+.*\S\s+$/ || $rawline =~ /^\+\s+$/) {
2608 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2609 if (ERROR("TRAILING_WHITESPACE",
2610 "trailing whitespace\n" . $herevet) &&
2612 $fixed[$fixlinenr] =~ s/\s+$//;
2618 # Check for FSF mailing addresses.
2619 if ($rawline =~ /\bwrite to the Free/i ||
2620 $rawline =~ /\b59\s+Temple\s+Pl/i ||
2621 $rawline =~ /\b51\s+Franklin\s+St/i) {
2622 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2623 my $msg_type = \&ERROR;
2624 $msg_type = \&CHK if ($file);
2625 &{$msg_type}("FSF_MAILING_ADDRESS",
2626 "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)
2629 # check for Kconfig help text having a real description
2630 # Only applies when adding the entry originally, after that we do not have
2631 # sufficient context to determine whether it is indeed long enough.
2632 if ($realfile =~ /Kconfig/ &&
2633 $line =~ /^\+\s*config\s+/) {
2636 my $ln = $linenr + 1;
2640 for (; $cnt > 0 && defined $lines[$ln - 1]; $ln++) {
2641 $f = $lines[$ln - 1];
2642 $cnt-- if ($lines[$ln - 1] !~ /^-/);
2643 $is_end = $lines[$ln - 1] =~ /^\+/;
2645 next if ($f =~ /^-/);
2646 last if (!$file && $f =~ /^\@\@/);
2648 if ($lines[$ln - 1] =~ /^\+\s*(?:bool|tristate)\s*\"/) {
2650 } elsif ($lines[$ln - 1] =~ /^\+\s*(?:---)?help(?:---)?$/) {
2657 next if ($f =~ /^$/);
2658 if ($f =~ /^\s*config\s/) {
2664 if ($is_start && $is_end && $length < $min_conf_desc_length) {
2665 WARN("CONFIG_DESCRIPTION",
2666 "please write a paragraph that describes the config symbol fully\n" . $herecurr);
2668 #print "is_start<$is_start> is_end<$is_end> length<$length>\n";
2671 # discourage the addition of CONFIG_EXPERIMENTAL in Kconfig.
2672 if ($realfile =~ /Kconfig/ &&
2673 $line =~ /.\s*depends on\s+.*\bEXPERIMENTAL\b/) {
2674 WARN("CONFIG_EXPERIMENTAL",
2675 "Use of CONFIG_EXPERIMENTAL is deprecated. For alternatives, see https://lkml.org/lkml/2012/10/23/580\n");
2678 # discourage the use of boolean for type definition attributes of Kconfig options
2679 if ($realfile =~ /Kconfig/ &&
2680 $line =~ /^\+\s*\bboolean\b/) {
2681 WARN("CONFIG_TYPE_BOOLEAN",
2682 "Use of boolean is deprecated, please use bool instead.\n" . $herecurr);
2685 if (($realfile =~ /Makefile.*/ || $realfile =~ /Kbuild.*/) &&
2686 ($line =~ /\+(EXTRA_[A-Z]+FLAGS).*/)) {
2689 'EXTRA_AFLAGS' => 'asflags-y',
2690 'EXTRA_CFLAGS' => 'ccflags-y',
2691 'EXTRA_CPPFLAGS' => 'cppflags-y',
2692 'EXTRA_LDFLAGS' => 'ldflags-y',
2695 WARN("DEPRECATED_VARIABLE",
2696 "Use of $flag is deprecated, please use \`$replacement->{$flag} instead.\n" . $herecurr) if ($replacement->{$flag});
2699 # check for DT compatible documentation
2700 if (defined $root &&
2701 (($realfile =~ /\.dtsi?$/ && $line =~ /^\+\s*compatible\s*=\s*\"/) ||
2702 ($realfile =~ /\.[ch]$/ && $line =~ /^\+.*\.compatible\s*=\s*\"/))) {
2704 my @compats = $rawline =~ /\"([a-zA-Z0-9\-\,\.\+_]+)\"/g;
2706 my $dt_path = $root . "/Documentation/devicetree/bindings/";
2707 my $vp_file = $dt_path . "vendor-prefixes.txt";
2709 foreach my $compat (@compats) {
2710 my $compat2 = $compat;
2711 $compat2 =~ s/\,[a-zA-Z0-9]*\-/\,<\.\*>\-/;
2712 my $compat3 = $compat;
2713 $compat3 =~ s/\,([a-z]*)[0-9]*\-/\,$1<\.\*>\-/;
2714 `grep -Erq "$compat|$compat2|$compat3" $dt_path`;
2716 WARN("UNDOCUMENTED_DT_STRING",
2717 "DT compatible string \"$compat\" appears un-documented -- check $dt_path\n" . $herecurr);
2720 next if $compat !~ /^([a-zA-Z0-9\-]+)\,/;
2722 `grep -Eq "^$vendor\\b" $vp_file`;
2724 WARN("UNDOCUMENTED_DT_STRING",
2725 "DT compatible string vendor \"$vendor\" appears un-documented -- check $vp_file\n" . $herecurr);
2730 # check we are in a valid source file if not then ignore this hunk
2731 next if ($realfile !~ /\.(h|c|s|S|pl|sh|dtsi|dts)$/);
2733 # line length limit (with some exclusions)
2735 # There are a few types of lines that may extend beyond $max_line_length:
2736 # logging functions like pr_info that end in a string
2737 # lines with a single string
2738 # #defines that are a single string
2740 # There are 3 different line length message types:
2741 # LONG_LINE_COMMENT a comment starts before but extends beyond $max_linelength
2742 # LONG_LINE_STRING a string starts before but extends beyond $max_line_length
2743 # LONG_LINE all other lines longer than $max_line_length
2745 # if LONG_LINE is ignored, the other 2 types are also ignored
2748 if ($line =~ /^\+/ && $length > $max_line_length) {
2749 my $msg_type = "LONG_LINE";
2751 # Check the allowed long line types first
2753 # logging functions that end in a string that starts
2754 # before $max_line_length
2755 if ($line =~ /^\+\s*$logFunctions\s*\(\s*(?:(?:KERN_\S+\s*|[^"]*))?($String\s*(?:|,|\)\s*;)\s*)$/ &&
2756 length(expand_tabs(substr($line, 1, length($line) - length($1) - 1))) <= $max_line_length) {
2759 # lines with only strings (w/ possible termination)
2760 # #defines with only strings
2761 } elsif ($line =~ /^\+\s*$String\s*(?:\s*|,|\)\s*;)\s*$/ ||
2762 $line =~ /^\+\s*#\s*define\s+\w+\s+$String$/) {
2765 # Otherwise set the alternate message types
2767 # a comment starts before $max_line_length
2768 } elsif ($line =~ /($;[\s$;]*)$/ &&
2769 length(expand_tabs(substr($line, 1, length($line) - length($1) - 1))) <= $max_line_length) {
2770 $msg_type = "LONG_LINE_COMMENT"
2772 # a quoted string starts before $max_line_length
2773 } elsif ($sline =~ /\s*($String(?:\s*(?:\\|,\s*|\)\s*;\s*))?)$/ &&
2774 length(expand_tabs(substr($line, 1, length($line) - length($1) - 1))) <= $max_line_length) {
2775 $msg_type = "LONG_LINE_STRING"
2778 if ($msg_type ne "" &&
2779 (show_type("LONG_LINE") || show_type($msg_type))) {
2781 "line over $max_line_length characters\n" . $herecurr);
2785 # check for adding lines without a newline.
2786 if ($line =~ /^\+/ && defined $lines[$linenr] && $lines[$linenr] =~ /^\\ No newline at end of file/) {
2787 WARN("MISSING_EOF_NEWLINE",
2788 "adding a line without newline at end of file\n" . $herecurr);
2791 # Blackfin: use hi/lo macros
2792 if ($realfile =~ m@arch/blackfin/.*\.S$@) {
2793 if ($line =~ /\.[lL][[:space:]]*=.*&[[:space:]]*0x[fF][fF][fF][fF]/) {
2794 my $herevet = "$here\n" . cat_vet($line) . "\n";
2796 "use the LO() macro, not (... & 0xFFFF)\n" . $herevet);
2798 if ($line =~ /\.[hH][[:space:]]*=.*>>[[:space:]]*16/) {
2799 my $herevet = "$here\n" . cat_vet($line) . "\n";
2801 "use the HI() macro, not (... >> 16)\n" . $herevet);
2805 # check we are in a valid source file C or perl if not then ignore this hunk
2806 next if ($realfile !~ /\.(h|c|pl|dtsi|dts)$/);
2808 # at the beginning of a line any tabs must come first and anything
2809 # more than 8 must use tabs.
2810 if ($rawline =~ /^\+\s* \t\s*\S/ ||
2811 $rawline =~ /^\+\s* \s*/) {
2812 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2814 if (ERROR("CODE_INDENT",
2815 "code indent should use tabs where possible\n" . $herevet) &&
2817 $fixed[$fixlinenr] =~ s/^\+([ \t]+)/"\+" . tabify($1)/e;
2821 # check for space before tabs.
2822 if ($rawline =~ /^\+/ && $rawline =~ / \t/) {
2823 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2824 if (WARN("SPACE_BEFORE_TAB",
2825 "please, no space before tabs\n" . $herevet) &&
2827 while ($fixed[$fixlinenr] =~
2828 s/(^\+.*) {8,8}\t/$1\t\t/) {}
2829 while ($fixed[$fixlinenr] =~
2830 s/(^\+.*) +\t/$1\t/) {}
2834 # check for && or || at the start of a line
2835 if ($rawline =~ /^\+\s*(&&|\|\|)/) {
2836 CHK("LOGICAL_CONTINUATIONS",
2837 "Logical continuations should be on the previous line\n" . $hereprev);
2840 # check indentation starts on a tab stop
2841 if ($^V && $^V ge 5.10.0 &&
2842 $sline =~ /^\+\t+( +)(?:$c90_Keywords\b|\{\s*$|\}\s*(?:else\b|while\b|\s*$))/) {
2843 my $indent = length($1);
2846 "Statements should start on a tabstop\n" . $herecurr) &&
2848 $fixed[$fixlinenr] =~ s@(^\+\t+) +@$1 . "\t" x ($indent/8)@e;
2853 # check multi-line statement indentation matches previous line
2854 if ($^V && $^V ge 5.10.0 &&
2855 $prevline =~ /^\+([ \t]*)((?:$c90_Keywords(?:\s+if)\s*)|(?:$Declare\s*)?(?:$Ident|\(\s*\*\s*$Ident\s*\))\s*|$Ident\s*=\s*$Ident\s*)\(.*(\&\&|\|\||,)\s*$/) {
2856 $prevline =~ /^\+(\t*)(.*)$/;
2860 my $pos = pos_last_openparen($rest);
2862 $line =~ /^(\+| )([ \t]*)/;
2865 my $goodtabindent = $oldindent .
2868 my $goodspaceindent = $oldindent . " " x $pos;
2870 if ($newindent ne $goodtabindent &&
2871 $newindent ne $goodspaceindent) {
2873 if (CHK("PARENTHESIS_ALIGNMENT",
2874 "Alignment should match open parenthesis\n" . $hereprev) &&
2875 $fix && $line =~ /^\+/) {
2876 $fixed[$fixlinenr] =~
2877 s/^\+[ \t]*/\+$goodtabindent/;
2883 # check for space after cast like "(int) foo" or "(struct foo) bar"
2884 # avoid checking a few false positives:
2885 # "sizeof(<type>)" or "__alignof__(<type>)"
2886 # function pointer declarations like "(*foo)(int) = bar;"
2887 # structure definitions like "(struct foo) { 0 };"
2888 # multiline macros that define functions
2889 # known attributes or the __attribute__ keyword
2890 if ($line =~ /^\+(.*)\(\s*$Type\s*\)([ \t]++)((?![={]|\\$|$Attribute|__attribute__))/ &&
2891 (!defined($1) || $1 !~ /\b(?:sizeof|__alignof__)\s*$/)) {
2893 "No space is necessary after a cast\n" . $herecurr) &&
2895 $fixed[$fixlinenr] =~
2896 s/(\(\s*$Type\s*\))[ \t]+/$1/;
2900 # Block comment styles
2901 # Networking with an initial /*
2902 if ($realfile =~ m@^(drivers/net/|net/)@ &&
2903 $prevrawline =~ /^\+[ \t]*\/\*[ \t]*$/ &&
2904 $rawline =~ /^\+[ \t]*\*/ &&
2906 WARN("NETWORKING_BLOCK_COMMENT_STYLE",
2907 "networking block comments don't use an empty /* line, use /* Comment...\n" . $hereprev);
2910 # Block comments use * on subsequent lines
2911 if ($prevline =~ /$;[ \t]*$/ && #ends in comment
2912 $prevrawline =~ /^\+.*?\/\*/ && #starting /*
2913 $prevrawline !~ /\*\/[ \t]*$/ && #no trailing */
2914 $rawline =~ /^\+/ && #line is new
2915 $rawline !~ /^\+[ \t]*\*/) { #no leading *
2916 WARN("BLOCK_COMMENT_STYLE",
2917 "Block comments use * on subsequent lines\n" . $hereprev);
2920 # Block comments use */ on trailing lines
2921 if ($rawline !~ m@^\+[ \t]*\*/[ \t]*$@ && #trailing */
2922 $rawline !~ m@^\+.*/\*.*\*/[ \t]*$@ && #inline /*...*/
2923 $rawline !~ m@^\+.*\*{2,}/[ \t]*$@ && #trailing **/
2924 $rawline =~ m@^\+[ \t]*.+\*\/[ \t]*$@) { #non blank */
2925 WARN("BLOCK_COMMENT_STYLE",
2926 "Block comments use a trailing */ on a separate line\n" . $herecurr);
2929 # check for missing blank lines after struct/union declarations
2930 # with exceptions for various attributes and macros
2931 if ($prevline =~ /^[\+ ]};?\s*$/ &&
2933 !($line =~ /^\+\s*$/ ||
2934 $line =~ /^\+\s*EXPORT_SYMBOL/ ||
2935 $line =~ /^\+\s*MODULE_/i ||
2936 $line =~ /^\+\s*\#\s*(?:end|elif|else)/ ||
2937 $line =~ /^\+[a-z_]*init/ ||
2938 $line =~ /^\+\s*(?:static\s+)?[A-Z_]*ATTR/ ||
2939 $line =~ /^\+\s*DECLARE/ ||
2940 $line =~ /^\+\s*__setup/)) {
2941 if (CHK("LINE_SPACING",
2942 "Please use a blank line after function/struct/union/enum declarations\n" . $hereprev) &&
2944 fix_insert_line($fixlinenr, "\+");
2948 # check for multiple consecutive blank lines
2949 if ($prevline =~ /^[\+ ]\s*$/ &&
2950 $line =~ /^\+\s*$/ &&
2951 $last_blank_line != ($linenr - 1)) {
2952 if (CHK("LINE_SPACING",
2953 "Please don't use multiple blank lines\n" . $hereprev) &&
2955 fix_delete_line($fixlinenr, $rawline);
2958 $last_blank_line = $linenr;
2961 # check for missing blank lines after declarations
2962 if ($sline =~ /^\+\s+\S/ && #Not at char 1
2963 # actual declarations
2964 ($prevline =~ /^\+\s+$Declare\s*$Ident\s*[=,;:\[]/ ||
2965 # function pointer declarations
2966 $prevline =~ /^\+\s+$Declare\s*\(\s*\*\s*$Ident\s*\)\s*[=,;:\[\(]/ ||
2967 # foo bar; where foo is some local typedef or #define
2968 $prevline =~ /^\+\s+$Ident(?:\s+|\s*\*\s*)$Ident\s*[=,;\[]/ ||
2969 # known declaration macros
2970 $prevline =~ /^\+\s+$declaration_macros/) &&
2971 # for "else if" which can look like "$Ident $Ident"
2972 !($prevline =~ /^\+\s+$c90_Keywords\b/ ||
2973 # other possible extensions of declaration lines
2974 $prevline =~ /(?:$Compare|$Assignment|$Operators)\s*$/ ||
2975 # not starting a section or a macro "\" extended line
2976 $prevline =~ /(?:\{\s*|\\)$/) &&
2977 # looks like a declaration
2978 !($sline =~ /^\+\s+$Declare\s*$Ident\s*[=,;:\[]/ ||
2979 # function pointer declarations
2980 $sline =~ /^\+\s+$Declare\s*\(\s*\*\s*$Ident\s*\)\s*[=,;:\[\(]/ ||
2981 # foo bar; where foo is some local typedef or #define
2982 $sline =~ /^\+\s+$Ident(?:\s+|\s*\*\s*)$Ident\s*[=,;\[]/ ||
2983 # known declaration macros
2984 $sline =~ /^\+\s+$declaration_macros/ ||
2985 # start of struct or union or enum
2986 $sline =~ /^\+\s+(?:union|struct|enum|typedef)\b/ ||
2987 # start or end of block or continuation of declaration
2988 $sline =~ /^\+\s+(?:$|[\{\}\.\#\"\?\:\(\[])/ ||
2989 # bitfield continuation
2990 $sline =~ /^\+\s+$Ident\s*:\s*\d+\s*[,;]/ ||
2991 # other possible extensions of declaration lines
2992 $sline =~ /^\+\s+\(?\s*(?:$Compare|$Assignment|$Operators)/) &&
2993 # indentation of previous and current line are the same
2994 (($prevline =~ /\+(\s+)\S/) && $sline =~ /^\+$1\S/)) {
2995 if (WARN("LINE_SPACING",
2996 "Missing a blank line after declarations\n" . $hereprev) &&
2998 fix_insert_line($fixlinenr, "\+");
3002 # check for spaces at the beginning of a line.
3004 # 1) within comments
3005 # 2) indented preprocessor commands
3007 if ($rawline =~ /^\+ / && $line !~ /^\+ *(?:$;|#|$Ident:)/) {
3008 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
3009 if (WARN("LEADING_SPACE",
3010 "please, no spaces at the start of a line\n" . $herevet) &&
3012 $fixed[$fixlinenr] =~ s/^\+([ \t]+)/"\+" . tabify($1)/e;
3016 # check we are in a valid C source file if not then ignore this hunk
3017 next if ($realfile !~ /\.(h|c)$/);
3019 # check indentation of any line with a bare else
3020 # (but not if it is a multiple line "if (foo) return bar; else return baz;")
3021 # if the previous line is a break or return and is indented 1 tab more...
3022 if ($sline =~ /^\+([\t]+)(?:}[ \t]*)?else(?:[ \t]*{)?\s*$/) {
3023 my $tabs = length($1) + 1;
3024 if ($prevline =~ /^\+\t{$tabs,$tabs}break\b/ ||
3025 ($prevline =~ /^\+\t{$tabs,$tabs}return\b/ &&
3026 defined $lines[$linenr] &&
3027 $lines[$linenr] !~ /^[ \+]\t{$tabs,$tabs}return/)) {
3028 WARN("UNNECESSARY_ELSE",
3029 "else is not generally useful after a break or return\n" . $hereprev);
3033 # check indentation of a line with a break;
3034 # if the previous line is a goto or return and is indented the same # of tabs
3035 if ($sline =~ /^\+([\t]+)break\s*;\s*$/) {
3037 if ($prevline =~ /^\+$tabs(?:goto|return)\b/) {
3038 WARN("UNNECESSARY_BREAK",
3039 "break is not useful after a goto or return\n" . $hereprev);
3043 # discourage the addition of CONFIG_EXPERIMENTAL in #if(def).
3044 if ($line =~ /^\+\s*\#\s*if.*\bCONFIG_EXPERIMENTAL\b/) {
3045 WARN("CONFIG_EXPERIMENTAL",
3046 "Use of CONFIG_EXPERIMENTAL is deprecated. For alternatives, see https://lkml.org/lkml/2012/10/23/580\n");
3049 # check for RCS/CVS revision markers
3050 if ($rawline =~ /^\+.*\$(Revision|Log|Id)(?:\$|)/) {
3052 "CVS style keyword markers, these will _not_ be updated\n". $herecurr);
3055 # Blackfin: don't use __builtin_bfin_[cs]sync
3056 if ($line =~ /__builtin_bfin_csync/) {
3057 my $herevet = "$here\n" . cat_vet($line) . "\n";
3059 "use the CSYNC() macro in asm/blackfin.h\n" . $herevet);
3061 if ($line =~ /__builtin_bfin_ssync/) {
3062 my $herevet = "$here\n" . cat_vet($line) . "\n";
3064 "use the SSYNC() macro in asm/blackfin.h\n" . $herevet);
3067 # check for old HOTPLUG __dev<foo> section markings
3068 if ($line =~ /\b(__dev(init|exit)(data|const|))\b/) {
3069 WARN("HOTPLUG_SECTION",
3070 "Using $1 is unnecessary\n" . $herecurr);
3073 # Check for potential 'bare' types
3074 my ($stat, $cond, $line_nr_next, $remain_next, $off_next,
3076 #print "LINE<$line>\n";
3077 if ($linenr >= $suppress_statement &&
3078 $realcnt && $sline =~ /.\s*\S/) {
3079 ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
3080 ctx_statement_block($linenr, $realcnt, 0);
3081 $stat =~ s/\n./\n /g;
3082 $cond =~ s/\n./\n /g;
3084 #print "linenr<$linenr> <$stat>\n";
3085 # If this statement has no statement boundaries within
3086 # it there is no point in retrying a statement scan
3087 # until we hit end of it.
3088 my $frag = $stat; $frag =~ s/;+\s*$//;
3089 if ($frag !~ /(?:{|;)/) {
3090 #print "skip<$line_nr_next>\n";
3091 $suppress_statement = $line_nr_next;
3094 # Find the real next line.
3095 $realline_next = $line_nr_next;
3096 if (defined $realline_next &&
3097 (!defined $lines[$realline_next - 1] ||
3098 substr($lines[$realline_next - 1], $off_next) =~ /^\s*$/)) {
3105 # Ignore goto labels.
3106 if ($s =~ /$Ident:\*$/s) {
3108 # Ignore functions being called
3109 } elsif ($s =~ /^.\s*$Ident\s*\(/s) {
3111 } elsif ($s =~ /^.\s*else\b/s) {
3113 # declarations always start with types
3114 } 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) {
3117 possible($type, "A:" . $s);
3119 # definitions in global scope can only start with types
3120 } elsif ($s =~ /^.(?:$Storage\s+)?(?:$Inline\s+)?(?:const\s+)?($Ident)\b\s*(?!:)/s) {
3121 possible($1, "B:" . $s);
3124 # any (foo ... *) is a pointer cast, and foo is a type
3125 while ($s =~ /\(($Ident)(?:\s+$Sparse)*[\s\*]+\s*\)/sg) {
3126 possible($1, "C:" . $s);
3129 # Check for any sort of function declaration.
3130 # int foo(something bar, other baz);
3131 # void (*store_gdt)(x86_descr_ptr *);
3132 if ($prev_values eq 'E' && $s =~ /^(.(?:typedef\s*)?(?:(?:$Storage|$Inline)\s*)*\s*$Type\s*(?:\b$Ident|\(\*\s*$Ident\))\s*)\(/s) {
3133 my ($name_len) = length($1);
3136 substr($ctx, 0, $name_len + 1, '');
3137 $ctx =~ s/\)[^\)]*$//;
3139 for my $arg (split(/\s*,\s*/, $ctx)) {
3140 if ($arg =~ /^(?:const\s+)?($Ident)(?:\s+$Sparse)*\s*\**\s*(:?\b$Ident)?$/s || $arg =~ /^($Ident)$/s) {
3142 possible($1, "D:" . $s);
3150 # Checks which may be anchored in the context.
3153 # Check for switch () and associated case and default
3154 # statements should be at the same indent.
3155 if ($line=~/\bswitch\s*\(.*\)/) {
3158 my @ctx = ctx_block_outer($linenr, $realcnt);
3160 for my $ctx (@ctx) {
3161 my ($clen, $cindent) = line_stats($ctx);
3162 if ($ctx =~ /^\+\s*(case\s+|default:)/ &&
3163 $indent != $cindent) {
3164 $err .= "$sep$ctx\n";
3171 ERROR("SWITCH_CASE_INDENT_LEVEL",
3172 "switch and case should be at the same indent\n$hereline$err");
3176 # if/while/etc brace do not go on next line, unless defining a do while loop,
3177 # or if that brace on the next line is for something else
3178 if ($line =~ /(.*)\b((?:if|while|for|switch|(?:[a-z_]+|)for_each[a-z_]+)\s*\(|do\b|else\b)/ && $line !~ /^.\s*\#/) {
3179 my $pre_ctx = "$1$2";
3181 my ($level, @ctx) = ctx_statement_level($linenr, $realcnt, 0);
3183 if ($line =~ /^\+\t{6,}/) {
3184 WARN("DEEP_INDENTATION",
3185 "Too many leading tabs - consider code refactoring\n" . $herecurr);
3188 my $ctx_cnt = $realcnt - $#ctx - 1;
3189 my $ctx = join("\n", @ctx);
3191 my $ctx_ln = $linenr;
3192 my $ctx_skip = $realcnt;
3194 while ($ctx_skip > $ctx_cnt || ($ctx_skip == $ctx_cnt &&
3195 defined $lines[$ctx_ln - 1] &&
3196 $lines[$ctx_ln - 1] =~ /^-/)) {
3197 ##print "SKIP<$ctx_skip> CNT<$ctx_cnt>\n";
3198 $ctx_skip-- if (!defined $lines[$ctx_ln - 1] || $lines[$ctx_ln - 1] !~ /^-/);
3202 #print "realcnt<$realcnt> ctx_cnt<$ctx_cnt>\n";
3203 #print "pre<$pre_ctx>\nline<$line>\nctx<$ctx>\nnext<$lines[$ctx_ln - 1]>\n";
3205 if ($ctx !~ /{\s*/ && defined($lines[$ctx_ln - 1]) && $lines[$ctx_ln - 1] =~ /^\+\s*{/) {
3207 "that open brace { should be on the previous line\n" .
3208 "$here\n$ctx\n$rawlines[$ctx_ln - 1]\n");
3210 if ($level == 0 && $pre_ctx !~ /}\s*while\s*\($/ &&
3211 $ctx =~ /\)\s*\;\s*$/ &&
3212 defined $lines[$ctx_ln - 1])
3214 my ($nlength, $nindent) = line_stats($lines[$ctx_ln - 1]);
3215 if ($nindent > $indent) {
3216 WARN("TRAILING_SEMICOLON",
3217 "trailing semicolon indicates no statements, indent implies otherwise\n" .
3218 "$here\n$ctx\n$rawlines[$ctx_ln - 1]\n");
3223 # Check relative indent for conditionals and blocks.
3224 if ($line =~ /\b(?:(?:if|while|for|(?:[a-z_]+|)for_each[a-z_]+)\s*\(|do\b)/ && $line !~ /^.\s*#/ && $line !~ /\}\s*while\s*/) {
3225 ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
3226 ctx_statement_block($linenr, $realcnt, 0)
3227 if (!defined $stat);
3228 my ($s, $c) = ($stat, $cond);
3230 substr($s, 0, length($c), '');
3232 # remove inline comments
3236 # Find out how long the conditional actually is.
3237 my @newlines = ($c =~ /\n/gs);
3238 my $cond_lines = 1 + $#newlines;
3240 # Make sure we remove the line prefixes as we have
3241 # none on the first line, and are going to readd them
3244 while ($s =~ /\n\s+\\\n/) {
3245 $cond_lines += $s =~ s/\n\s+\\\n/\n/g;
3248 # We want to check the first line inside the block
3249 # starting at the end of the conditional, so remove:
3250 # 1) any blank line termination
3251 # 2) any opening brace { on end of the line
3253 my $continuation = 0;
3255 $s =~ s/^.*\bdo\b//;
3257 if ($s =~ s/^\s*\\//) {
3260 if ($s =~ s/^\s*?\n//) {
3265 # Also ignore a loop construct at the end of a
3266 # preprocessor statement.
3267 if (($prevline =~ /^.\s*#\s*define\s/ ||
3268 $prevline =~ /\\\s*$/) && $continuation == 0) {
3274 while ($cond_ptr != $cond_lines) {
3275 $cond_ptr = $cond_lines;
3277 # If we see an #else/#elif then the code
3279 if ($s =~ /^\s*\#\s*(?:else|elif)/) {
3284 # 1) blank lines, they should be at 0,
3285 # 2) preprocessor lines, and
3287 if ($continuation ||
3289 $s =~ /^\s*#\s*?/ ||
3290 $s =~ /^\s*$Ident\s*:/) {
3291 $continuation = ($s =~ /^.*?\\\n/) ? 1 : 0;
3292 if ($s =~ s/^.*?\n//) {
3298 my (undef, $sindent) = line_stats("+" . $s);
3299 my $stat_real = raw_line($linenr, $cond_lines);
3301 # Check if either of these lines are modified, else
3302 # this is not this patch's fault.
3303 if (!defined($stat_real) ||
3304 $stat !~ /^\+/ && $stat_real !~ /^\+/) {
3307 if (defined($stat_real) && $cond_lines > 1) {
3308 $stat_real = "[...]\n$stat_real";
3311 #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";
3313 if ($check && $s ne '' &&
3314 (($sindent % 8) != 0 ||
3315 ($sindent < $indent) ||
3316 ($sindent > $indent + 8))) {
3317 WARN("SUSPECT_CODE_INDENT",
3318 "suspect code indent for conditional statements ($indent, $sindent)\n" . $herecurr . "$stat_real\n");
3322 # Track the 'values' across context and added lines.
3323 my $opline = $line; $opline =~ s/^./ /;
3324 my ($curr_values, $curr_vars) =
3325 annotate_values($opline . "\n", $prev_values);
3326 $curr_values = $prev_values . $curr_values;
3328 my $outline = $opline; $outline =~ s/\t/ /g;
3329 print "$linenr > .$outline\n";
3330 print "$linenr > $curr_values\n";
3331 print "$linenr > $curr_vars\n";
3333 $prev_values = substr($curr_values, -1);
3335 #ignore lines not being added
3336 next if ($line =~ /^[^\+]/);
3338 # check for declarations of signed or unsigned without int
3339 while ($line =~ m{($Declare)\s*(?!char\b|short\b|int\b|long\b)\s*($Ident)?\s*[=,;\[\)\(]}g) {
3342 $var = "" if (!defined $var);
3343 if ($type =~ /^(?:(?:$Storage|$Inline|$Attribute)\s+)*((?:un)?signed)((?:\s*\*)*)\s*$/) {
3347 $pointer = "" if (!defined $pointer);
3349 if (WARN("UNSPECIFIED_INT",
3350 "Prefer '" . trim($sign) . " int" . rtrim($pointer) . "' to bare use of '$sign" . rtrim($pointer) . "'\n" . $herecurr) &&
3352 my $decl = trim($sign) . " int ";
3353 my $comp_pointer = $pointer;
3354 $comp_pointer =~ s/\s//g;
3355 $decl .= $comp_pointer;
3356 $decl = rtrim($decl) if ($var eq "");
3357 $fixed[$fixlinenr] =~ s@\b$sign\s*\Q$pointer\E\s*$var\b@$decl$var@;
3362 # TEST: allow direct testing of the type matcher.
3364 if ($line =~ /^.\s*$Declare\s*$/) {
3366 "TEST: is type\n" . $herecurr);
3367 } elsif ($dbg_type > 1 && $line =~ /^.+($Declare)/) {
3368 ERROR("TEST_NOT_TYPE",
3369 "TEST: is not type ($1 is)\n". $herecurr);
3373 # TEST: allow direct testing of the attribute matcher.
3375 if ($line =~ /^.\s*$Modifier\s*$/) {
3377 "TEST: is attr\n" . $herecurr);
3378 } elsif ($dbg_attr > 1 && $line =~ /^.+($Modifier)/) {
3379 ERROR("TEST_NOT_ATTR",
3380 "TEST: is not attr ($1 is)\n". $herecurr);
3385 # check for initialisation to aggregates open brace on the next line
3386 if ($line =~ /^.\s*{/ &&
3387 $prevline =~ /(?:^|[^=])=\s*$/) {
3388 if (ERROR("OPEN_BRACE",
3389 "that open brace { should be on the previous line\n" . $hereprev) &&
3390 $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
3391 fix_delete_line($fixlinenr - 1, $prevrawline);
3392 fix_delete_line($fixlinenr, $rawline);
3393 my $fixedline = $prevrawline;
3394 $fixedline =~ s/\s*=\s*$/ = {/;
3395 fix_insert_line($fixlinenr, $fixedline);
3397 $fixedline =~ s/^(.\s*){\s*/$1/;
3398 fix_insert_line($fixlinenr, $fixedline);
3403 # Checks which are anchored on the added line.
3406 # check for malformed paths in #include statements (uses RAW line)
3407 if ($rawline =~ m{^.\s*\#\s*include\s+[<"](.*)[">]}) {
3409 if ($path =~ m{//}) {
3410 ERROR("MALFORMED_INCLUDE",
3411 "malformed #include filename\n" . $herecurr);
3413 if ($path =~ "^uapi/" && $realfile =~ m@\binclude/uapi/@) {
3414 ERROR("UAPI_INCLUDE",
3415 "No #include in ...include/uapi/... should use a uapi/ path prefix\n" . $herecurr);
3419 # no C99 // comments
3420 if ($line =~ m{//}) {
3421 if (ERROR("C99_COMMENTS",
3422 "do not use C99 // comments\n" . $herecurr) &&
3424 my $line = $fixed[$fixlinenr];
3425 if ($line =~ /\/\/(.*)$/) {
3426 my $comment = trim($1);
3427 $fixed[$fixlinenr] =~ s@\/\/(.*)$@/\* $comment \*/@;
3431 # Remove C99 comments.
3433 $opline =~ s@//.*@@;
3435 # EXPORT_SYMBOL should immediately follow the thing it is exporting, consider
3436 # the whole statement.
3437 #print "APW <$lines[$realline_next - 1]>\n";
3438 if (defined $realline_next &&
3439 exists $lines[$realline_next - 1] &&
3440 !defined $suppress_export{$realline_next} &&
3441 ($lines[$realline_next - 1] =~ /EXPORT_SYMBOL.*\((.*)\)/ ||
3442 $lines[$realline_next - 1] =~ /EXPORT_UNUSED_SYMBOL.*\((.*)\)/)) {
3443 # Handle definitions which produce identifiers with
3446 # EXPORT_SYMBOL(something_foo);
3448 if ($stat =~ /^(?:.\s*}\s*\n)?.([A-Z_]+)\s*\(\s*($Ident)/ &&
3449 $name =~ /^${Ident}_$2/) {
3450 #print "FOO C name<$name>\n";
3451 $suppress_export{$realline_next} = 1;
3453 } elsif ($stat !~ /(?:
3455 ^.DEFINE_$Ident\(\Q$name\E\)|
3456 ^.DECLARE_$Ident\(\Q$name\E\)|
3457 ^.LIST_HEAD\(\Q$name\E\)|
3458 ^.(?:$Storage\s+)?$Type\s*\(\s*\*\s*\Q$name\E\s*\)\s*\(|
3459 \b\Q$name\E(?:\s+$Attribute)*\s*(?:;|=|\[|\()
3461 #print "FOO A<$lines[$realline_next - 1]> stat<$stat> name<$name>\n";
3462 $suppress_export{$realline_next} = 2;
3464 $suppress_export{$realline_next} = 1;
3467 if (!defined $suppress_export{$linenr} &&
3468 $prevline =~ /^.\s*$/ &&
3469 ($line =~ /EXPORT_SYMBOL.*\((.*)\)/ ||
3470 $line =~ /EXPORT_UNUSED_SYMBOL.*\((.*)\)/)) {
3471 #print "FOO B <$lines[$linenr - 1]>\n";
3472 $suppress_export{$linenr} = 2;
3474 if (defined $suppress_export{$linenr} &&
3475 $suppress_export{$linenr} == 2) {
3476 WARN("EXPORT_SYMBOL",
3477 "EXPORT_SYMBOL(foo); should immediately follow its function/variable\n" . $herecurr);
3480 # check for global initialisers.
3481 if ($line =~ /^\+$Type\s*$Ident(?:\s+$Modifier)*\s*=\s*($zero_initializer)\s*;/) {
3482 if (ERROR("GLOBAL_INITIALISERS",
3483 "do not initialise globals to $1\n" . $herecurr) &&
3485 $fixed[$fixlinenr] =~ s/(^.$Type\s*$Ident(?:\s+$Modifier)*)\s*=\s*$zero_initializer\s*;/$1;/;
3488 # check for static initialisers.
3489 if ($line =~ /^\+.*\bstatic\s.*=\s*($zero_initializer)\s*;/) {
3490 if (ERROR("INITIALISED_STATIC",
3491 "do not initialise statics to $1\n" .
3494 $fixed[$fixlinenr] =~ s/(\bstatic\s.*?)\s*=\s*$zero_initializer\s*;/$1;/;
3498 # check for misordered declarations of char/short/int/long with signed/unsigned
3499 while ($sline =~ m{(\b$TypeMisordered\b)}g) {
3501 WARN("MISORDERED_TYPE",
3502 "type '$tmp' should be specified in [[un]signed] [short|int|long|long long] order\n" . $herecurr);
3505 # check for static const char * arrays.
3506 if ($line =~ /\bstatic\s+const\s+char\s*\*\s*(\w+)\s*\[\s*\]\s*=\s*/) {
3507 WARN("STATIC_CONST_CHAR_ARRAY",
3508 "static const char * array should probably be static const char * const\n" .
3512 # check for static char foo[] = "bar" declarations.
3513 if ($line =~ /\bstatic\s+char\s+(\w+)\s*\[\s*\]\s*=\s*"/) {
3514 WARN("STATIC_CONST_CHAR_ARRAY",
3515 "static char array declaration should probably be static const char\n" .
3519 # check for const <foo> const where <foo> is not a pointer or array type
3520 if ($sline =~ /\bconst\s+($BasicType)\s+const\b/) {
3522 if ($sline =~ /\bconst\s+\Q$found\E\s+const\b\s*\*/) {
3524 "'const $found const *' should probably be 'const $found * const'\n" . $herecurr);
3525 } elsif ($sline !~ /\bconst\s+\Q$found\E\s+const\s+\w+\s*\[/) {
3527 "'const $found const' should probably be 'const $found'\n" . $herecurr);
3531 # check for non-global char *foo[] = {"bar", ...} declarations.
3532 if ($line =~ /^.\s+(?:static\s+|const\s+)?char\s+\*\s*\w+\s*\[\s*\]\s*=\s*\{/) {
3533 WARN("STATIC_CONST_CHAR_ARRAY",
3534 "char * array declaration might be better as static const\n" .
3538 # check for sizeof(foo)/sizeof(foo[0]) that could be ARRAY_SIZE(foo)
3539 if ($line =~ m@\bsizeof\s*\(\s*($Lval)\s*\)@) {
3541 if ($line =~ m@\b(sizeof\s*\(\s*\Q$array\E\s*\)\s*/\s*sizeof\s*\(\s*\Q$array\E\s*\[\s*0\s*\]\s*\))@) {
3543 if (WARN("ARRAY_SIZE",
3544 "Prefer ARRAY_SIZE($array)\n" . $herecurr) &&
3546 $fixed[$fixlinenr] =~ s/\Q$array_div\E/ARRAY_SIZE($array)/;
3551 # check for function declarations without arguments like "int foo()"
3552 if ($line =~ /(\b$Type\s+$Ident)\s*\(\s*\)/) {
3553 if (ERROR("FUNCTION_WITHOUT_ARGS",
3554 "Bad function definition - $1() should probably be $1(void)\n" . $herecurr) &&
3556 $fixed[$fixlinenr] =~ s/(\b($Type)\s+($Ident))\s*\(\s*\)/$2 $3(void)/;
3560 # check for uses of DEFINE_PCI_DEVICE_TABLE
3561 if ($line =~ /\bDEFINE_PCI_DEVICE_TABLE\s*\(\s*(\w+)\s*\)\s*=/) {
3562 if (WARN("DEFINE_PCI_DEVICE_TABLE",
3563 "Prefer struct pci_device_id over deprecated DEFINE_PCI_DEVICE_TABLE\n" . $herecurr) &&
3565 $fixed[$fixlinenr] =~ s/\b(?:static\s+|)DEFINE_PCI_DEVICE_TABLE\s*\(\s*(\w+)\s*\)\s*=\s*/static const struct pci_device_id $1\[\] = /;
3569 # check for new typedefs, only function parameters and sparse annotations
3571 if ($line =~ /\btypedef\s/ &&
3572 $line !~ /\btypedef\s+$Type\s*\(\s*\*?$Ident\s*\)\s*\(/ &&
3573 $line !~ /\btypedef\s+$Type\s+$Ident\s*\(/ &&
3574 $line !~ /\b$typeTypedefs\b/ &&
3575 $line !~ /\b__bitwise(?:__|)\b/) {
3576 WARN("NEW_TYPEDEFS",
3577 "do not add new typedefs\n" . $herecurr);
3580 # * goes on variable not on type
3582 while ($line =~ m{(\($NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)\))}g) {
3584 my ($ident, $from, $to) = ($1, $2, $2);
3586 # Should start with a space.
3587 $to =~ s/^(\S)/ $1/;
3588 # Should not end with a space.
3590 # '*'s should not have spaces between.
3591 while ($to =~ s/\*\s+\*/\*\*/) {
3594 ## print "1: from<$from> to<$to> ident<$ident>\n";
3596 if (ERROR("POINTER_LOCATION",
3597 "\"(foo$from)\" should be \"(foo$to)\"\n" . $herecurr) &&
3599 my $sub_from = $ident;
3600 my $sub_to = $ident;
3601 $sub_to =~ s/\Q$from\E/$to/;
3602 $fixed[$fixlinenr] =~
3603 s@\Q$sub_from\E@$sub_to@;
3607 while ($line =~ m{(\b$NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)($Ident))}g) {
3609 my ($match, $from, $to, $ident) = ($1, $2, $2, $3);
3611 # Should start with a space.
3612 $to =~ s/^(\S)/ $1/;
3613 # Should not end with a space.
3615 # '*'s should not have spaces between.
3616 while ($to =~ s/\*\s+\*/\*\*/) {
3618 # Modifiers should have spaces.
3619 $to =~ s/(\b$Modifier$)/$1 /;
3621 ## print "2: from<$from> to<$to> ident<$ident>\n";
3622 if ($from ne $to && $ident !~ /^$Modifier$/) {
3623 if (ERROR("POINTER_LOCATION",
3624 "\"foo${from}bar\" should be \"foo${to}bar\"\n" . $herecurr) &&
3627 my $sub_from = $match;
3628 my $sub_to = $match;
3629 $sub_to =~ s/\Q$from\E/$to/;
3630 $fixed[$fixlinenr] =~
3631 s@\Q$sub_from\E@$sub_to@;
3636 # avoid BUG() or BUG_ON()
3637 if ($line =~ /\b(?:BUG|BUG_ON)\b/) {
3638 my $msg_type = \&WARN;
3639 $msg_type = \&CHK if ($file);
3640 &{$msg_type}("AVOID_BUG",
3641 "Avoid crashing the kernel - try using WARN_ON & recovery code rather than BUG() or BUG_ON()\n" . $herecurr);
3644 # avoid LINUX_VERSION_CODE
3645 if ($line =~ /\bLINUX_VERSION_CODE\b/) {
3646 WARN("LINUX_VERSION_CODE",
3647 "LINUX_VERSION_CODE should be avoided, code should be for the version to which it is merged\n" . $herecurr);
3650 # check for uses of printk_ratelimit
3651 if ($line =~ /\bprintk_ratelimit\s*\(/) {
3652 WARN("PRINTK_RATELIMITED",
3653 "Prefer printk_ratelimited or pr_<level>_ratelimited to printk_ratelimit\n" . $herecurr);
3656 # printk should use KERN_* levels. Note that follow on printk's on the
3657 # same line do not need a level, so we use the current block context
3658 # to try and find and validate the current printk. In summary the current
3659 # printk includes all preceding printk's which have no newline on the end.
3660 # we assume the first bad printk is the one to report.
3661 if ($line =~ /\bprintk\((?!KERN_)\s*"/) {
3663 for (my $ln = $linenr - 1; $ln >= $first_line; $ln--) {
3664 #print "CHECK<$lines[$ln - 1]\n";
3665 # we have a preceding printk if it ends
3666 # with "\n" ignore it, else it is to blame
3667 if ($lines[$ln - 1] =~ m{\bprintk\(}) {
3668 if ($rawlines[$ln - 1] !~ m{\\n"}) {
3675 WARN("PRINTK_WITHOUT_KERN_LEVEL",
3676 "printk() should include KERN_ facility level\n" . $herecurr);
3680 if ($line =~ /\bprintk\s*\(\s*KERN_([A-Z]+)/) {
3682 my $level = lc($orig);
3683 $level = "warn" if ($level eq "warning");
3684 my $level2 = $level;
3685 $level2 = "dbg" if ($level eq "debug");
3686 WARN("PREFER_PR_LEVEL",
3687 "Prefer [subsystem eg: netdev]_$level2([subsystem]dev, ... then dev_$level2(dev, ... then pr_$level(... to printk(KERN_$orig ...\n" . $herecurr);
3690 if ($line =~ /\bpr_warning\s*\(/) {
3691 if (WARN("PREFER_PR_LEVEL",
3692 "Prefer pr_warn(... to pr_warning(...\n" . $herecurr) &&
3694 $fixed[$fixlinenr] =~
3695 s/\bpr_warning\b/pr_warn/;
3699 if ($line =~ /\bdev_printk\s*\(\s*KERN_([A-Z]+)/) {
3701 my $level = lc($orig);
3702 $level = "warn" if ($level eq "warning");
3703 $level = "dbg" if ($level eq "debug");
3704 WARN("PREFER_DEV_LEVEL",
3705 "Prefer dev_$level(... to dev_printk(KERN_$orig, ...\n" . $herecurr);
3708 # ENOSYS means "bad syscall nr" and nothing else. This will have a small
3709 # number of false positives, but assembly files are not checked, so at
3710 # least the arch entry code will not trigger this warning.
3711 if ($line =~ /\bENOSYS\b/) {
3713 "ENOSYS means 'invalid syscall nr' and nothing else\n" . $herecurr);
3716 # function brace can't be on same line, except for #defines of do while,
3717 # or if closed on same line
3718 if (($line=~/$Type\s*$Ident\(.*\).*\s*{/) and
3719 !($line=~/\#\s*define.*do\s\{/) and !($line=~/}/)) {
3720 if (ERROR("OPEN_BRACE",
3721 "open brace '{' following function declarations go on the next line\n" . $herecurr) &&
3723 fix_delete_line($fixlinenr, $rawline);
3724 my $fixed_line = $rawline;
3725 $fixed_line =~ /(^..*$Type\s*$Ident\(.*\)\s*){(.*)$/;
3728 fix_insert_line($fixlinenr, ltrim($line1));
3729 fix_insert_line($fixlinenr, "\+{");
3730 if ($line2 !~ /^\s*$/) {
3731 fix_insert_line($fixlinenr, "\+\t" . trim($line2));
3736 # open braces for enum, union and struct go on the same line.
3737 if ($line =~ /^.\s*{/ &&
3738 $prevline =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident)?\s*$/) {
3739 if (ERROR("OPEN_BRACE",
3740 "open brace '{' following $1 go on the same line\n" . $hereprev) &&
3741 $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
3742 fix_delete_line($fixlinenr - 1, $prevrawline);
3743 fix_delete_line($fixlinenr, $rawline);
3744 my $fixedline = rtrim($prevrawline) . " {";
3745 fix_insert_line($fixlinenr, $fixedline);
3746 $fixedline = $rawline;
3747 $fixedline =~ s/^(.\s*){\s*/$1\t/;
3748 if ($fixedline !~ /^\+\s*$/) {
3749 fix_insert_line($fixlinenr, $fixedline);
3754 # missing space after union, struct or enum definition
3755 if ($line =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident){1,2}[=\{]/) {
3757 "missing space after $1 definition\n" . $herecurr) &&
3759 $fixed[$fixlinenr] =~
3760 s/^(.\s*(?:typedef\s+)?(?:enum|union|struct)(?:\s+$Ident){1,2})([=\{])/$1 $2/;
3764 # Function pointer declarations
3765 # check spacing between type, funcptr, and args
3766 # canonical declaration is "type (*funcptr)(args...)"
3767 if ($line =~ /^.\s*($Declare)\((\s*)\*(\s*)($Ident)(\s*)\)(\s*)\(/) {
3769 my $pre_pointer_space = $2;
3770 my $post_pointer_space = $3;
3772 my $post_funcname_space = $5;
3773 my $pre_args_space = $6;
3775 # the $Declare variable will capture all spaces after the type
3776 # so check it for a missing trailing missing space but pointer return types
3777 # don't need a space so don't warn for those.
3778 my $post_declare_space = "";
3779 if ($declare =~ /(\s+)$/) {
3780 $post_declare_space = $1;
3781 $declare = rtrim($declare);
3783 if ($declare !~ /\*$/ && $post_declare_space =~ /^$/) {
3785 "missing space after return type\n" . $herecurr);
3786 $post_declare_space = " ";
3789 # unnecessary space "type (*funcptr)(args...)"
3790 # This test is not currently implemented because these declarations are
3792 # int foo(int bar, ...)
3793 # and this is form shouldn't/doesn't generate a checkpatch warning.
3795 # elsif ($declare =~ /\s{2,}$/) {
3797 # "Multiple spaces after return type\n" . $herecurr);
3800 # unnecessary space "type ( *funcptr)(args...)"
3801 if (defined $pre_pointer_space &&
3802 $pre_pointer_space =~ /^\s/) {
3804 "Unnecessary space after function pointer open parenthesis\n" . $herecurr);
3807 # unnecessary space "type (* funcptr)(args...)"
3808 if (defined $post_pointer_space &&
3809 $post_pointer_space =~ /^\s/) {
3811 "Unnecessary space before function pointer name\n" . $herecurr);
3814 # unnecessary space "type (*funcptr )(args...)"
3815 if (defined $post_funcname_space &&
3816 $post_funcname_space =~ /^\s/) {
3818 "Unnecessary space after function pointer name\n" . $herecurr);
3821 # unnecessary space "type (*funcptr) (args...)"
3822 if (defined $pre_args_space &&
3823 $pre_args_space =~ /^\s/) {
3825 "Unnecessary space before function pointer arguments\n" . $herecurr);
3828 if (show_type("SPACING") && $fix) {
3829 $fixed[$fixlinenr] =~
3830 s/^(.\s*)$Declare\s*\(\s*\*\s*$Ident\s*\)\s*\(/$1 . $declare . $post_declare_space . '(*' . $funcname . ')('/ex;
3834 # check for spacing round square brackets; allowed:
3835 # 1. with a type on the left -- int [] a;
3836 # 2. at the beginning of a line for slice initialisers -- [0...10] = 5,
3837 # 3. inside a curly brace -- = { [0...10] = 5 }
3838 while ($line =~ /(.*?\s)\[/g) {
3839 my ($where, $prefix) = ($-[1], $1);
3840 if ($prefix !~ /$Type\s+$/ &&
3841 ($where != 0 || $prefix !~ /^.\s+$/) &&
3842 $prefix !~ /[{,]\s+$/) {
3843 if (ERROR("BRACKET_SPACE",
3844 "space prohibited before open square bracket '['\n" . $herecurr) &&
3846 $fixed[$fixlinenr] =~
3847 s/^(\+.*?)\s+\[/$1\[/;
3852 # check for spaces between functions and their parentheses.
3853 while ($line =~ /($Ident)\s+\(/g) {
3855 my $ctx_before = substr($line, 0, $-[1]);
3856 my $ctx = "$ctx_before$name";
3858 # Ignore those directives where spaces _are_ permitted.
3860 if|for|while|switch|return|case|
3861 volatile|__volatile__|
3862 __attribute__|format|__extension__|
3865 # cpp #define statements have non-optional spaces, ie
3866 # if there is a space between the name and the open
3867 # parenthesis it is simply not a parameter group.
3868 } elsif ($ctx_before =~ /^.\s*\#\s*define\s*$/) {
3870 # cpp #elif statement condition may start with a (
3871 } elsif ($ctx =~ /^.\s*\#\s*elif\s*$/) {
3873 # If this whole things ends with a type its most
3874 # likely a typedef for a function.
3875 } elsif ($ctx =~ /$Type$/) {
3879 "space prohibited between function name and open parenthesis '('\n" . $herecurr) &&
3881 $fixed[$fixlinenr] =~
3882 s/\b$name\s+\(/$name\(/;
3887 # Check operator spacing.
3888 if (!($line=~/\#\s*include/)) {
3889 my $fixed_line = "";
3893 <<=|>>=|<=|>=|==|!=|
3894 \+=|-=|\*=|\/=|%=|\^=|\|=|&=|
3895 =>|->|<<|>>|<|>|=|!|~|
3896 &&|\|\||,|\^|\+\+|--|&|\||\+|-|\*|\/|%|
3899 my @elements = split(/($ops|;)/, $opline);
3901 ## print("element count: <" . $#elements . ">\n");
3902 ## foreach my $el (@elements) {
3903 ## print("el: <$el>\n");
3906 my @fix_elements = ();
3909 foreach my $el (@elements) {
3910 push(@fix_elements, substr($rawline, $off, length($el)));
3911 $off += length($el);
3916 my $blank = copy_spacing($opline);
3917 my $last_after = -1;
3919 for (my $n = 0; $n < $#elements; $n += 2) {
3921 my $good = $fix_elements[$n] . $fix_elements[$n + 1];
3923 ## print("n: <$n> good: <$good>\n");
3925 $off += length($elements[$n]);
3927 # Pick up the preceding and succeeding characters.
3928 my $ca = substr($opline, 0, $off);
3930 if (length($opline) >= ($off + length($elements[$n + 1]))) {
3931 $cc = substr($opline, $off + length($elements[$n + 1]));
3933 my $cb = "$ca$;$cc";
3936 $a = 'V' if ($elements[$n] ne '');
3937 $a = 'W' if ($elements[$n] =~ /\s$/);
3938 $a = 'C' if ($elements[$n] =~ /$;$/);
3939 $a = 'B' if ($elements[$n] =~ /(\[|\()$/);
3940 $a = 'O' if ($elements[$n] eq '');
3941 $a = 'E' if ($ca =~ /^\s*$/);
3943 my $op = $elements[$n + 1];
3946 if (defined $elements[$n + 2]) {
3947 $c = 'V' if ($elements[$n + 2] ne '');
3948 $c = 'W' if ($elements[$n + 2] =~ /^\s/);
3949 $c = 'C' if ($elements[$n + 2] =~ /^$;/);
3950 $c = 'B' if ($elements[$n + 2] =~ /^(\)|\]|;)/);
3951 $c = 'O' if ($elements[$n + 2] eq '');
3952 $c = 'E' if ($elements[$n + 2] =~ /^\s*\\$/);
3957 my $ctx = "${a}x${c}";
3959 my $at = "(ctx:$ctx)";
3961 my $ptr = substr($blank, 0, $off) . "^";
3962 my $hereptr = "$hereline$ptr\n";
3964 # Pull out the value of this operator.
3965 my $op_type = substr($curr_values, $off + 1, 1);
3967 # Get the full operator variant.
3968 my $opv = $op . substr($curr_vars, $off, 1);
3970 # Ignore operators passed as parameters.
3971 if ($op_type ne 'V' &&
3972 $ca =~ /\s$/ && $cc =~ /^\s*[,\)]/) {
3975 # } elsif ($op =~ /^$;+$/) {
3977 # ; should have either the end of line or a space or \ after it
3978 } elsif ($op eq ';') {
3979 if ($ctx !~ /.x[WEBC]/ &&
3980 $cc !~ /^\\/ && $cc !~ /^;/) {
3981 if (ERROR("SPACING",
3982 "space required after that '$op' $at\n" . $hereptr)) {
3983 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";
3989 } elsif ($op eq '//') {
3991 # : when part of a bitfield
3992 } elsif ($opv eq ':B') {
3993 # skip the bitfield test for now
3997 } elsif ($op eq '->') {
3998 if ($ctx =~ /Wx.|.xW/) {
3999 if (ERROR("SPACING",
4000 "spaces prohibited around that '$op' $at\n" . $hereptr)) {
4001 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
4002 if (defined $fix_elements[$n + 2]) {
4003 $fix_elements[$n + 2] =~ s/^\s+//;
4009 # , must not have a space before and must have a space on the right.
4010 } elsif ($op eq ',') {
4011 my $rtrim_before = 0;
4012 my $space_after = 0;
4013 if ($ctx =~ /Wx./) {
4014 if (ERROR("SPACING",
4015 "space prohibited before that '$op' $at\n" . $hereptr)) {
4020 if ($ctx !~ /.x[WEC]/ && $cc !~ /^}/) {
4021 if (ERROR("SPACING",
4022 "space required after that '$op' $at\n" . $hereptr)) {
4028 if ($rtrim_before || $space_after) {
4029 if ($rtrim_before) {
4030 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
4032 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]);
4039 # '*' as part of a type definition -- reported already.
4040 } elsif ($opv eq '*_') {
4041 #warn "'*' is part of type\n";
4043 # unary operators should have a space before and
4044 # none after. May be left adjacent to another
4045 # unary operator, or a cast
4046 } elsif ($op eq '!' || $op eq '~' ||
4047 $opv eq '*U' || $opv eq '-U' ||
4048 $opv eq '&U' || $opv eq '&&U') {
4049 if ($ctx !~ /[WEBC]x./ && $ca !~ /(?:\)|!|~|\*|-|\&|\||\+\+|\-\-|\{)$/) {
4050 if (ERROR("SPACING",
4051 "space required before that '$op' $at\n" . $hereptr)) {
4052 if ($n != $last_after + 2) {
4053 $good = $fix_elements[$n] . " " . ltrim($fix_elements[$n + 1]);
4058 if ($op eq '*' && $cc =~/\s*$Modifier\b/) {
4059 # A unary '*' may be const
4061 } elsif ($ctx =~ /.xW/) {
4062 if (ERROR("SPACING",
4063 "space prohibited after that '$op' $at\n" . $hereptr)) {
4064 $good = $fix_elements[$n] . rtrim($fix_elements[$n + 1]);
4065 if (defined $fix_elements[$n + 2]) {
4066 $fix_elements[$n + 2] =~ s/^\s+//;
4072 # unary ++ and unary -- are allowed no space on one side.
4073 } elsif ($op eq '++' or $op eq '--') {
4074 if ($ctx !~ /[WEOBC]x[^W]/ && $ctx !~ /[^W]x[WOBEC]/) {
4075 if (ERROR("SPACING",
4076 "space required one side of that '$op' $at\n" . $hereptr)) {
4077 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";
4081 if ($ctx =~ /Wx[BE]/ ||
4082 ($ctx =~ /Wx./ && $cc =~ /^;/)) {
4083 if (ERROR("SPACING",
4084 "space prohibited before that '$op' $at\n" . $hereptr)) {
4085 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
4089 if ($ctx =~ /ExW/) {
4090 if (ERROR("SPACING",
4091 "space prohibited after that '$op' $at\n" . $hereptr)) {
4092 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]);
4093 if (defined $fix_elements[$n + 2]) {
4094 $fix_elements[$n + 2] =~ s/^\s+//;
4100 # << and >> may either have or not have spaces both sides
4101 } elsif ($op eq '<<' or $op eq '>>' or
4102 $op eq '&' or $op eq '^' or $op eq '|' or
4103 $op eq '+' or $op eq '-' or
4104 $op eq '*' or $op eq '/' or
4108 if (defined $fix_elements[$n + 2] && $ctx !~ /[EW]x[EW]/) {
4110 "spaces preferred around that '$op' $at\n" . $hereptr)) {
4111 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
4112 $fix_elements[$n + 2] =~ s/^\s+//;
4115 } elsif (!defined $fix_elements[$n + 2] && $ctx !~ /Wx[OE]/) {
4117 "space preferred before that '$op' $at\n" . $hereptr)) {
4118 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]);
4122 } elsif ($ctx =~ /Wx[^WCE]|[^WCE]xW/) {
4123 if (ERROR("SPACING",
4124 "need consistent spacing around '$op' $at\n" . $hereptr)) {
4125 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
4126 if (defined $fix_elements[$n + 2]) {
4127 $fix_elements[$n + 2] =~ s/^\s+//;
4133 # A colon needs no spaces before when it is
4134 # terminating a case value or a label.
4135 } elsif ($opv eq ':C' || $opv eq ':L') {
4136 if ($ctx =~ /Wx./) {
4137 if (ERROR("SPACING",
4138 "space prohibited before that '$op' $at\n" . $hereptr)) {
4139 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
4144 # All the others need spaces both sides.
4145 } elsif ($ctx !~ /[EWC]x[CWE]/) {
4148 # Ignore email addresses <foo@bar>
4150 $cc =~ /^\S+\@\S+>/) ||
4152 $ca =~ /<\S+\@\S+$/))
4157 # for asm volatile statements
4158 # ignore a colon with another
4159 # colon immediately before or after
4161 ($ca =~ /:$/ || $cc =~ /^:/)) {
4165 # messages are ERROR, but ?: are CHK
4167 my $msg_type = \&ERROR;
4168 $msg_type = \&CHK if (($op eq '?:' || $op eq '?' || $op eq ':') && $ctx =~ /VxV/);
4170 if (&{$msg_type}("SPACING",
4171 "spaces required around that '$op' $at\n" . $hereptr)) {
4172 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
4173 if (defined $fix_elements[$n + 2]) {
4174 $fix_elements[$n + 2] =~ s/^\s+//;
4180 $off += length($elements[$n + 1]);
4182 ## print("n: <$n> GOOD: <$good>\n");
4184 $fixed_line = $fixed_line . $good;
4187 if (($#elements % 2) == 0) {
4188 $fixed_line = $fixed_line . $fix_elements[$#elements];
4191 if ($fix && $line_fixed && $fixed_line ne $fixed[$fixlinenr]) {
4192 $fixed[$fixlinenr] = $fixed_line;
4198 # check for whitespace before a non-naked semicolon
4199 if ($line =~ /^\+.*\S\s+;\s*$/) {
4201 "space prohibited before semicolon\n" . $herecurr) &&
4203 1 while $fixed[$fixlinenr] =~
4204 s/^(\+.*\S)\s+;/$1;/;
4208 # check for multiple assignments
4209 if ($line =~ /^.\s*$Lval\s*=\s*$Lval\s*=(?!=)/) {
4210 CHK("MULTIPLE_ASSIGNMENTS",
4211 "multiple assignments should be avoided\n" . $herecurr);
4214 ## # check for multiple declarations, allowing for a function declaration
4216 ## if ($line =~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Ident.*/ &&
4217 ## $line !~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Type\s*$Ident.*/) {
4219 ## # Remove any bracketed sections to ensure we do not
4220 ## # falsly report the parameters of functions.
4222 ## while ($ln =~ s/\([^\(\)]*\)//g) {
4224 ## if ($ln =~ /,/) {
4225 ## WARN("MULTIPLE_DECLARATION",
4226 ## "declaring multiple variables together should be avoided\n" . $herecurr);
4230 #need space before brace following if, while, etc
4231 if (($line =~ /\(.*\)\{/ && $line !~ /\($Type\)\{/) ||
4233 if (ERROR("SPACING",
4234 "space required before the open brace '{'\n" . $herecurr) &&
4236 $fixed[$fixlinenr] =~ s/^(\+.*(?:do|\))){/$1 {/;
4240 ## # check for blank lines before declarations
4241 ## if ($line =~ /^.\t+$Type\s+$Ident(?:\s*=.*)?;/ &&
4242 ## $prevrawline =~ /^.\s*$/) {
4244 ## "No blank lines before declarations\n" . $hereprev);
4248 # closing brace should have a space following it when it has anything
4250 if ($line =~ /}(?!(?:,|;|\)))\S/) {
4251 if (ERROR("SPACING",
4252 "space required after that close brace '}'\n" . $herecurr) &&
4254 $fixed[$fixlinenr] =~
4255 s/}((?!(?:,|;|\)))\S)/} $1/;
4259 # check spacing on square brackets
4260 if ($line =~ /\[\s/ && $line !~ /\[\s*$/) {
4261 if (ERROR("SPACING",
4262 "space prohibited after that open square bracket '['\n" . $herecurr) &&
4264 $fixed[$fixlinenr] =~
4268 if ($line =~ /\s\]/) {
4269 if (ERROR("SPACING",
4270 "space prohibited before that close square bracket ']'\n" . $herecurr) &&
4272 $fixed[$fixlinenr] =~
4277 # check spacing on parentheses
4278 if ($line =~ /\(\s/ && $line !~ /\(\s*(?:\\)?$/ &&
4279 $line !~ /for\s*\(\s+;/) {
4280 if (ERROR("SPACING",
4281 "space prohibited after that open parenthesis '('\n" . $herecurr) &&
4283 $fixed[$fixlinenr] =~
4287 if ($line =~ /(\s+)\)/ && $line !~ /^.\s*\)/ &&
4288 $line !~ /for\s*\(.*;\s+\)/ &&
4289 $line !~ /:\s+\)/) {
4290 if (ERROR("SPACING",
4291 "space prohibited before that close parenthesis ')'\n" . $herecurr) &&
4293 $fixed[$fixlinenr] =~
4298 # check unnecessary parentheses around addressof/dereference single $Lvals
4299 # ie: &(foo->bar) should be &foo->bar and *(foo->bar) should be *foo->bar
4301 while ($line =~ /(?:[^&]&\s*|\*)\(\s*($Ident\s*(?:$Member\s*)+)\s*\)/g) {
4303 if (CHK("UNNECESSARY_PARENTHESES",
4304 "Unnecessary parentheses around $var\n" . $herecurr) &&
4306 $fixed[$fixlinenr] =~ s/\(\s*\Q$var\E\s*\)/$var/;
4310 # check for unnecessary parentheses around function pointer uses
4311 # ie: (foo->bar)(); should be foo->bar();
4312 # but not "if (foo->bar) (" to avoid some false positives
4313 if ($line =~ /(\bif\s*|)(\(\s*$Ident\s*(?:$Member\s*)+\))[ \t]*\(/ && $1 !~ /^if/) {
4315 if (CHK("UNNECESSARY_PARENTHESES",
4316 "Unnecessary parentheses around function pointer $var\n" . $herecurr) &&
4318 my $var2 = deparenthesize($var);
4320 $fixed[$fixlinenr] =~ s/\Q$var\E/$var2/;
4324 #goto labels aren't indented, allow a single space however
4325 if ($line=~/^.\s+[A-Za-z\d_]+:(?![0-9]+)/ and
4326 !($line=~/^. [A-Za-z\d_]+:/) and !($line=~/^.\s+default:/)) {
4327 if (WARN("INDENTED_LABEL",
4328 "labels should not be indented\n" . $herecurr) &&
4330 $fixed[$fixlinenr] =~
4335 # return is not a function
4336 if (defined($stat) && $stat =~ /^.\s*return(\s*)\(/s) {
4338 if ($^V && $^V ge 5.10.0 &&
4339 $stat =~ /^.\s*return\s*($balanced_parens)\s*;\s*$/) {
4341 $value = deparenthesize($value);
4342 if ($value =~ m/^\s*$FuncArg\s*(?:\?|$)/) {
4343 ERROR("RETURN_PARENTHESES",
4344 "return is not a function, parentheses are not required\n" . $herecurr);
4346 } elsif ($spacing !~ /\s+/) {
4348 "space required before the open parenthesis '('\n" . $herecurr);
4352 # unnecessary return in a void function
4353 # at end-of-function, with the previous line a single leading tab, then return;
4354 # and the line before that not a goto label target like "out:"
4355 if ($sline =~ /^[ \+]}\s*$/ &&
4356 $prevline =~ /^\+\treturn\s*;\s*$/ &&
4358 $lines[$linenr - 3] =~ /^[ +]/ &&
4359 $lines[$linenr - 3] !~ /^[ +]\s*$Ident\s*:/) {
4361 "void function return statements are not generally useful\n" . $hereprev);
4364 # if statements using unnecessary parentheses - ie: if ((foo == bar))
4365 if ($^V && $^V ge 5.10.0 &&
4366 $line =~ /\bif\s*((?:\(\s*){2,})/) {
4367 my $openparens = $1;
4368 my $count = $openparens =~ tr@\(@\(@;
4370 if ($line =~ /\bif\s*(?:\(\s*){$count,$count}$LvalOrFunc\s*($Compare)\s*$LvalOrFunc(?:\s*\)){$count,$count}/) {
4371 my $comp = $4; #Not $1 because of $LvalOrFunc
4372 $msg = " - maybe == should be = ?" if ($comp eq "==");
4373 WARN("UNNECESSARY_PARENTHESES",
4374 "Unnecessary parentheses$msg\n" . $herecurr);
4378 # comparisons with a constant or upper case identifier on the left
4379 # avoid cases like "foo + BAR < baz"
4380 # only fix matches surrounded by parentheses to avoid incorrect
4381 # conversions like "FOO < baz() + 5" being "misfixed" to "baz() > FOO + 5"
4382 if ($^V && $^V ge 5.10.0 &&
4383 $line =~ /^\+(.*)\b($Constant|[A-Z_][A-Z0-9_]*)\s*($Compare)\s*($LvalOrFunc)/) {
4388 my $newcomp = $comp;
4389 if ($lead !~ /(?:$Operators|\.)\s*$/ &&
4390 $to !~ /^(?:Constant|[A-Z_][A-Z0-9_]*)$/ &&
4391 WARN("CONSTANT_COMPARISON",
4392 "Comparisons should place the constant on the right side of the test\n" . $herecurr) &&
4396 } elsif ($comp eq "<=") {
4398 } elsif ($comp eq ">") {
4400 } elsif ($comp eq ">=") {
4403 $fixed[$fixlinenr] =~ s/\(\s*\Q$const\E\s*$Compare\s*\Q$to\E\s*\)/($to $newcomp $const)/;
4407 # Return of what appears to be an errno should normally be negative
4408 if ($sline =~ /\breturn(?:\s*\(+\s*|\s+)(E[A-Z]+)(?:\s*\)+\s*|\s*)[;:,]/) {
4410 if ($name ne 'EOF' && $name ne 'ERROR') {
4411 WARN("USE_NEGATIVE_ERRNO",
4412 "return of an errno should typically be negative (ie: return -$1)\n" . $herecurr);
4416 # Need a space before open parenthesis after if, while etc
4417 if ($line =~ /\b(if|while|for|switch)\(/) {
4418 if (ERROR("SPACING",
4419 "space required before the open parenthesis '('\n" . $herecurr) &&
4421 $fixed[$fixlinenr] =~
4422 s/\b(if|while|for|switch)\(/$1 \(/;
4426 # Check for illegal assignment in if conditional -- and check for trailing
4427 # statements after the conditional.
4428 if ($line =~ /do\s*(?!{)/) {
4429 ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
4430 ctx_statement_block($linenr, $realcnt, 0)
4431 if (!defined $stat);
4432 my ($stat_next) = ctx_statement_block($line_nr_next,
4433 $remain_next, $off_next);
4434 $stat_next =~ s/\n./\n /g;
4435 ##print "stat<$stat> stat_next<$stat_next>\n";
4437 if ($stat_next =~ /^\s*while\b/) {
4438 # If the statement carries leading newlines,
4439 # then count those as offsets.
4441 ($stat_next =~ /^((?:\s*\n[+-])*\s*)/s);
4443 statement_rawlines($whitespace) - 1;
4445 $suppress_whiletrailers{$line_nr_next +
4449 if (!defined $suppress_whiletrailers{$linenr} &&
4450 defined($stat) && defined($cond) &&
4451 $line =~ /\b(?:if|while|for)\s*\(/ && $line !~ /^.\s*#/) {
4452 my ($s, $c) = ($stat, $cond);
4454 if ($c =~ /\bif\s*\(.*[^<>!=]=[^=].*/s) {
4455 ERROR("ASSIGN_IN_IF",
4456 "do not use assignment in if condition\n" . $herecurr);
4459 # Find out what is on the end of the line after the
4461 substr($s, 0, length($c), '');
4463 $s =~ s/$;//g; # Remove any comments
4464 if (length($c) && $s !~ /^\s*{?\s*\\*\s*$/ &&
4465 $c !~ /}\s*while\s*/)
4467 # Find out how long the conditional actually is.
4468 my @newlines = ($c =~ /\n/gs);
4469 my $cond_lines = 1 + $#newlines;
4472 $stat_real = raw_line($linenr, $cond_lines)
4473 . "\n" if ($cond_lines);
4474 if (defined($stat_real) && $cond_lines > 1) {
4475 $stat_real = "[...]\n$stat_real";
4478 ERROR("TRAILING_STATEMENTS",
4479 "trailing statements should be on next line\n" . $herecurr . $stat_real);
4483 # Check for bitwise tests written as boolean
4495 WARN("HEXADECIMAL_BOOLEAN_TEST",
4496 "boolean test with hexadecimal, perhaps just 1 \& or \|?\n" . $herecurr);
4499 # if and else should not have general statements after it
4500 if ($line =~ /^.\s*(?:}\s*)?else\b(.*)/) {
4502 $s =~ s/$;//g; # Remove any comments
4503 if ($s !~ /^\s*(?:\sif|(?:{|)\s*\\?\s*$)/) {
4504 ERROR("TRAILING_STATEMENTS",
4505 "trailing statements should be on next line\n" . $herecurr);
4508 # if should not continue a brace
4509 if ($line =~ /}\s*if\b/) {
4510 ERROR("TRAILING_STATEMENTS",
4511 "trailing statements should be on next line (or did you mean 'else if'?)\n" .
4514 # case and default should not have general statements after them
4515 if ($line =~ /^.\s*(?:case\s*.*|default\s*):/g &&
4517 (?:\s*$;*)(?:\s*{)?(?:\s*$;*)(?:\s*\\)?\s*$|
4521 ERROR("TRAILING_STATEMENTS",
4522 "trailing statements should be on next line\n" . $herecurr);
4525 # Check for }<nl>else {, these must be at the same
4526 # indent level to be relevant to each other.
4527 if ($prevline=~/}\s*$/ and $line=~/^.\s*else\s*/ &&
4528 $previndent == $indent) {
4529 if (ERROR("ELSE_AFTER_BRACE",
4530 "else should follow close brace '}'\n" . $hereprev) &&
4531 $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
4532 fix_delete_line($fixlinenr - 1, $prevrawline);
4533 fix_delete_line($fixlinenr, $rawline);
4534 my $fixedline = $prevrawline;
4535 $fixedline =~ s/}\s*$//;
4536 if ($fixedline !~ /^\+\s*$/) {
4537 fix_insert_line($fixlinenr, $fixedline);
4539 $fixedline = $rawline;
4540 $fixedline =~ s/^(.\s*)else/$1} else/;
4541 fix_insert_line($fixlinenr, $fixedline);
4545 if ($prevline=~/}\s*$/ and $line=~/^.\s*while\s*/ &&
4546 $previndent == $indent) {
4547 my ($s, $c) = ctx_statement_block($linenr, $realcnt, 0);
4549 # Find out what is on the end of the line after the
4551 substr($s, 0, length($c), '');
4554 if ($s =~ /^\s*;/) {
4555 if (ERROR("WHILE_AFTER_BRACE",
4556 "while should follow close brace '}'\n" . $hereprev) &&
4557 $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
4558 fix_delete_line($fixlinenr - 1, $prevrawline);
4559 fix_delete_line($fixlinenr, $rawline);
4560 my $fixedline = $prevrawline;
4561 my $trailing = $rawline;
4562 $trailing =~ s/^\+//;
4563 $trailing = trim($trailing);
4564 $fixedline =~ s/}\s*$/} $trailing/;
4565 fix_insert_line($fixlinenr, $fixedline);
4570 #Specific variable tests
4571 while ($line =~ m{($Constant|$Lval)}g) {
4574 #gcc binary extension
4575 if ($var =~ /^$Binary$/) {
4576 if (WARN("GCC_BINARY_CONSTANT",
4577 "Avoid gcc v4.3+ binary constant extension: <$var>\n" . $herecurr) &&
4579 my $hexval = sprintf("0x%x", oct($var));
4580 $fixed[$fixlinenr] =~
4581 s/\b$var\b/$hexval/;
4586 if ($var !~ /^$Constant$/ &&
4587 $var =~ /[A-Z][a-z]|[a-z][A-Z]/ &&
4588 #Ignore Page<foo> variants
4589 $var !~ /^(?:Clear|Set|TestClear|TestSet|)Page[A-Z]/ &&
4590 #Ignore SI style variants like nS, mV and dB (ie: max_uV, regulator_min_uA_show)
4591 $var !~ /^(?:[a-z_]*?)_?[a-z][A-Z](?:_[a-z_]+)?$/ &&
4592 #Ignore some three character SI units explicitly, like MiB and KHz
4593 $var !~ /^(?:[a-z_]*?)_?(?:[KMGT]iB|[KMGT]?Hz)(?:_[a-z_]+)?$/) {
4594 while ($var =~ m{($Ident)}g) {
4596 next if ($word !~ /[A-Z][a-z]|[a-z][A-Z]/);
4598 seed_camelcase_includes();
4599 if (!$file && !$camelcase_file_seeded) {
4600 seed_camelcase_file($realfile);
4601 $camelcase_file_seeded = 1;
4604 if (!defined $camelcase{$word}) {
4605 $camelcase{$word} = 1;
4607 "Avoid CamelCase: <$word>\n" . $herecurr);
4613 #no spaces allowed after \ in define
4614 if ($line =~ /\#\s*define.*\\\s+$/) {
4615 if (WARN("WHITESPACE_AFTER_LINE_CONTINUATION",
4616 "Whitespace after \\ makes next lines useless\n" . $herecurr) &&
4618 $fixed[$fixlinenr] =~ s/\s+$//;
4622 # warn if <asm/foo.h> is #included and <linux/foo.h> is available and includes
4623 # itself <asm/foo.h> (uses RAW line)
4624 if ($tree && $rawline =~ m{^.\s*\#\s*include\s*\<asm\/(.*)\.h\>}) {
4626 my $checkfile = "include/linux/$file";
4627 if (-f "$root/$checkfile" &&
4628 $realfile ne $checkfile &&
4629 $1 !~ /$allowed_asm_includes/)
4631 my $asminclude = `grep -Ec "#include\\s+<asm/$file>" $root/$checkfile`;
4632 if ($asminclude > 0) {
4633 if ($realfile =~ m{^arch/}) {
4634 CHK("ARCH_INCLUDE_LINUX",
4635 "Consider using #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
4637 WARN("INCLUDE_LINUX",
4638 "Use #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
4644 # multi-statement macros should be enclosed in a do while loop, grab the
4645 # first statement and ensure its the whole macro if its not enclosed
4646 # in a known good container
4647 if ($realfile !~ m@/vmlinux.lds.h$@ &&
4648 $line =~ /^.\s*\#\s*define\s*$Ident(\()?/) {
4651 my ($off, $dstat, $dcond, $rest);
4653 my $has_flow_statement = 0;
4654 my $has_arg_concat = 0;
4655 ($dstat, $dcond, $ln, $cnt, $off) =
4656 ctx_statement_block($linenr, $realcnt, 0);
4658 #print "dstat<$dstat> dcond<$dcond> cnt<$cnt> off<$off>\n";
4659 #print "LINE<$lines[$ln-1]> len<" . length($lines[$ln-1]) . "\n";
4661 $has_flow_statement = 1 if ($ctx =~ /\b(goto|return)\b/);
4662 $has_arg_concat = 1 if ($ctx =~ /\#\#/ && $ctx !~ /\#\#\s*(?:__VA_ARGS__|args)\b/);
4664 $dstat =~ s/^.\s*\#\s*define\s+$Ident(?:\([^\)]*\))?\s*//;
4666 $dstat =~ s/\\\n.//g;
4667 $dstat =~ s/^\s*//s;
4668 $dstat =~ s/\s*$//s;
4670 # Flatten any parentheses and braces
4671 while ($dstat =~ s/\([^\(\)]*\)/1/ ||
4672 $dstat =~ s/\{[^\{\}]*\}/1/ ||
4673 $dstat =~ s/.\[[^\[\]]*\]/1/)
4677 # Flatten any obvious string concatentation.
4678 while ($dstat =~ s/($String)\s*$Ident/$1/ ||
4679 $dstat =~ s/$Ident\s*($String)/$1/)
4683 # Make asm volatile uses seem like a generic function
4684 $dstat =~ s/\b_*asm_*\s+_*volatile_*\b/asm_volatile/g;
4686 my $exceptions = qr{
4699 #print "REST<$rest> dstat<$dstat> ctx<$ctx>\n";
4701 $dstat !~ /^(?:$Ident|-?$Constant),$/ && # 10, // foo(),
4702 $dstat !~ /^(?:$Ident|-?$Constant);$/ && # foo();
4703 $dstat !~ /^[!~-]?(?:$Lval|$Constant)$/ && # 10 // foo() // !foo // ~foo // -foo // foo->bar // foo.bar->baz
4704 $dstat !~ /^'X'$/ && $dstat !~ /^'XX'$/ && # character constants
4705 $dstat !~ /$exceptions/ &&
4706 $dstat !~ /^\.$Ident\s*=/ && # .foo =
4707 $dstat !~ /^(?:\#\s*$Ident|\#\s*$Constant)\s*$/ && # stringification #foo
4708 $dstat !~ /^do\s*$Constant\s*while\s*$Constant;?$/ && # do {...} while (...); // do {...} while (...)
4709 $dstat !~ /^for\s*$Constant$/ && # for (...)
4710 $dstat !~ /^for\s*$Constant\s+(?:$Ident|-?$Constant)$/ && # for (...) bar()
4711 $dstat !~ /^do\s*{/ && # do {...
4712 $dstat !~ /^\(\{/ && # ({...
4713 $ctx !~ /^.\s*#\s*define\s+TRACE_(?:SYSTEM|INCLUDE_FILE|INCLUDE_PATH)\b/)
4716 my $herectx = $here . "\n";
4717 my $cnt = statement_rawlines($ctx);
4719 for (my $n = 0; $n < $cnt; $n++) {
4720 $herectx .= raw_line($linenr, $n) . "\n";
4723 if ($dstat =~ /;/) {
4724 ERROR("MULTISTATEMENT_MACRO_USE_DO_WHILE",
4725 "Macros with multiple statements should be enclosed in a do - while loop\n" . "$herectx");
4727 ERROR("COMPLEX_MACRO",
4728 "Macros with complex values should be enclosed in parentheses\n" . "$herectx");
4732 # check for macros with flow control, but without ## concatenation
4733 # ## concatenation is commonly a macro that defines a function so ignore those
4734 if ($has_flow_statement && !$has_arg_concat) {
4735 my $herectx = $here . "\n";
4736 my $cnt = statement_rawlines($ctx);
4738 for (my $n = 0; $n < $cnt; $n++) {
4739 $herectx .= raw_line($linenr, $n) . "\n";
4741 WARN("MACRO_WITH_FLOW_CONTROL",
4742 "Macros with flow control statements should be avoided\n" . "$herectx");
4745 # check for line continuations outside of #defines, preprocessor #, and asm
4748 if ($prevline !~ /^..*\\$/ &&
4749 $line !~ /^\+\s*\#.*\\$/ && # preprocessor
4750 $line !~ /^\+.*\b(__asm__|asm)\b.*\\$/ && # asm
4751 $line =~ /^\+.*\\$/) {
4752 WARN("LINE_CONTINUATIONS",
4753 "Avoid unnecessary line continuations\n" . $herecurr);
4757 # do {} while (0) macro tests:
4758 # single-statement macros do not need to be enclosed in do while (0) loop,
4759 # macro should not end with a semicolon
4760 if ($^V && $^V ge 5.10.0 &&
4761 $realfile !~ m@/vmlinux.lds.h$@ &&
4762 $line =~ /^.\s*\#\s*define\s+$Ident(\()?/) {
4765 my ($off, $dstat, $dcond, $rest);
4767 ($dstat, $dcond, $ln, $cnt, $off) =
4768 ctx_statement_block($linenr, $realcnt, 0);
4771 $dstat =~ s/\\\n.//g;
4774 if ($dstat =~ /^\+\s*#\s*define\s+$Ident\s*${balanced_parens}\s*do\s*{(.*)\s*}\s*while\s*\(\s*0\s*\)\s*([;\s]*)\s*$/) {
4779 my $cnt = statement_rawlines($ctx);
4780 my $herectx = $here . "\n";
4782 for (my $n = 0; $n < $cnt; $n++) {
4783 $herectx .= raw_line($linenr, $n) . "\n";
4786 if (($stmts =~ tr/;/;/) == 1 &&
4787 $stmts !~ /^\s*(if|while|for|switch)\b/) {
4788 WARN("SINGLE_STATEMENT_DO_WHILE_MACRO",
4789 "Single statement macros should not use a do {} while (0) loop\n" . "$herectx");
4791 if (defined $semis && $semis ne "") {
4792 WARN("DO_WHILE_MACRO_WITH_TRAILING_SEMICOLON",
4793 "do {} while (0) macros should not be semicolon terminated\n" . "$herectx");
4795 } elsif ($dstat =~ /^\+\s*#\s*define\s+$Ident.*;\s*$/) {
4797 my $cnt = statement_rawlines($ctx);
4798 my $herectx = $here . "\n";
4800 for (my $n = 0; $n < $cnt; $n++) {
4801 $herectx .= raw_line($linenr, $n) . "\n";
4804 WARN("TRAILING_SEMICOLON",
4805 "macros should not use a trailing semicolon\n" . "$herectx");
4809 # make sure symbols are always wrapped with VMLINUX_SYMBOL() ...
4810 # all assignments may have only one of the following with an assignment:
4813 # VMLINUX_SYMBOL(...)
4814 if ($realfile eq 'vmlinux.lds.h' && $line =~ /(?:(?:^|\s)$Ident\s*=|=\s*$Ident(?:\s|$))/) {
4815 WARN("MISSING_VMLINUX_SYMBOL",
4816 "vmlinux.lds.h needs VMLINUX_SYMBOL() around C-visible symbols\n" . $herecurr);
4819 # check for redundant bracing round if etc
4820 if ($line =~ /(^.*)\bif\b/ && $1 !~ /else\s*$/) {
4821 my ($level, $endln, @chunks) =
4822 ctx_statement_full($linenr, $realcnt, 1);
4823 #print "chunks<$#chunks> linenr<$linenr> endln<$endln> level<$level>\n";
4824 #print "APW: <<$chunks[1][0]>><<$chunks[1][1]>>\n";
4825 if ($#chunks > 0 && $level == 0) {
4829 my $herectx = $here . "\n";
4830 my $ln = $linenr - 1;
4831 for my $chunk (@chunks) {
4832 my ($cond, $block) = @{$chunk};
4834 # If the condition carries leading newlines, then count those as offsets.
4835 my ($whitespace) = ($cond =~ /^((?:\s*\n[+-])*\s*)/s);
4836 my $offset = statement_rawlines($whitespace) - 1;
4838 $allowed[$allow] = 0;
4839 #print "COND<$cond> whitespace<$whitespace> offset<$offset>\n";
4841 # We have looked at and allowed this specific line.
4842 $suppress_ifbraces{$ln + $offset} = 1;
4844 $herectx .= "$rawlines[$ln + $offset]\n[...]\n";
4845 $ln += statement_rawlines($block) - 1;
4847 substr($block, 0, length($cond), '');
4849 $seen++ if ($block =~ /^\s*{/);
4851 #print "cond<$cond> block<$block> allowed<$allowed[$allow]>\n";
4852 if (statement_lines($cond) > 1) {
4853 #print "APW: ALLOWED: cond<$cond>\n";
4854 $allowed[$allow] = 1;
4856 if ($block =~/\b(?:if|for|while)\b/) {
4857 #print "APW: ALLOWED: block<$block>\n";
4858 $allowed[$allow] = 1;
4860 if (statement_block_size($block) > 1) {
4861 #print "APW: ALLOWED: lines block<$block>\n";
4862 $allowed[$allow] = 1;
4867 my $sum_allowed = 0;
4868 foreach (@allowed) {
4871 if ($sum_allowed == 0) {
4873 "braces {} are not necessary for any arm of this statement\n" . $herectx);
4874 } elsif ($sum_allowed != $allow &&
4877 "braces {} should be used on all arms of this statement\n" . $herectx);
4882 if (!defined $suppress_ifbraces{$linenr - 1} &&
4883 $line =~ /\b(if|while|for|else)\b/) {
4886 # Check the pre-context.
4887 if (substr($line, 0, $-[0]) =~ /(\}\s*)$/) {
4888 #print "APW: ALLOWED: pre<$1>\n";
4892 my ($level, $endln, @chunks) =
4893 ctx_statement_full($linenr, $realcnt, $-[0]);
4895 # Check the condition.
4896 my ($cond, $block) = @{$chunks[0]};
4897 #print "CHECKING<$linenr> cond<$cond> block<$block>\n";
4898 if (defined $cond) {
4899 substr($block, 0, length($cond), '');
4901 if (statement_lines($cond) > 1) {
4902 #print "APW: ALLOWED: cond<$cond>\n";
4905 if ($block =~/\b(?:if|for|while)\b/) {
4906 #print "APW: ALLOWED: block<$block>\n";
4909 if (statement_block_size($block) > 1) {
4910 #print "APW: ALLOWED: lines block<$block>\n";
4913 # Check the post-context.
4914 if (defined $chunks[1]) {
4915 my ($cond, $block) = @{$chunks[1]};
4916 if (defined $cond) {
4917 substr($block, 0, length($cond), '');
4919 if ($block =~ /^\s*\{/) {
4920 #print "APW: ALLOWED: chunk-1 block<$block>\n";
4924 if ($level == 0 && $block =~ /^\s*\{/ && !$allowed) {
4925 my $herectx = $here . "\n";
4926 my $cnt = statement_rawlines($block);
4928 for (my $n = 0; $n < $cnt; $n++) {
4929 $herectx .= raw_line($linenr, $n) . "\n";
4933 "braces {} are not necessary for single statement blocks\n" . $herectx);
4937 # check for unnecessary blank lines around braces
4938 if (($line =~ /^.\s*}\s*$/ && $prevrawline =~ /^.\s*$/)) {
4940 "Blank lines aren't necessary before a close brace '}'\n" . $hereprev) &&
4941 $fix && $prevrawline =~ /^\+/) {
4942 fix_delete_line($fixlinenr - 1, $prevrawline);
4945 if (($rawline =~ /^.\s*$/ && $prevline =~ /^..*{\s*$/)) {
4947 "Blank lines aren't necessary after an open brace '{'\n" . $hereprev) &&
4949 fix_delete_line($fixlinenr, $rawline);
4953 # no volatiles please
4954 my $asm_volatile = qr{\b(__asm__|asm)\s+(__volatile__|volatile)\b};
4955 if ($line =~ /\bvolatile\b/ && $line !~ /$asm_volatile/) {
4957 "Use of volatile is usually wrong: see Documentation/volatile-considered-harmful.txt\n" . $herecurr);
4960 # Check for user-visible strings broken across lines, which breaks the ability
4961 # to grep for the string. Make exceptions when the previous string ends in a
4962 # newline (multiple lines in one string constant) or '\t', '\r', ';', or '{'
4963 # (common in inline assembly) or is a octal \123 or hexadecimal \xaf value
4964 if ($line =~ /^\+\s*$String/ &&
4965 $prevline =~ /"\s*$/ &&
4966 $prevrawline !~ /(?:\\(?:[ntr]|[0-7]{1,3}|x[0-9a-fA-F]{1,2})|;\s*|\{\s*)"\s*$/) {
4967 if (WARN("SPLIT_STRING",
4968 "quoted string split across lines\n" . $hereprev) &&
4970 $prevrawline =~ /^\+.*"\s*$/ &&
4971 $last_coalesced_string_linenr != $linenr - 1) {
4972 my $extracted_string = get_quoted_string($line, $rawline);
4973 my $comma_close = "";
4974 if ($rawline =~ /\Q$extracted_string\E(\s*\)\s*;\s*$|\s*,\s*)/) {
4978 fix_delete_line($fixlinenr - 1, $prevrawline);
4979 fix_delete_line($fixlinenr, $rawline);
4980 my $fixedline = $prevrawline;
4981 $fixedline =~ s/"\s*$//;
4982 $fixedline .= substr($extracted_string, 1) . trim($comma_close);
4983 fix_insert_line($fixlinenr - 1, $fixedline);
4984 $fixedline = $rawline;
4985 $fixedline =~ s/\Q$extracted_string\E\Q$comma_close\E//;
4986 if ($fixedline !~ /\+\s*$/) {
4987 fix_insert_line($fixlinenr, $fixedline);
4989 $last_coalesced_string_linenr = $linenr;
4993 # check for missing a space in a string concatenation
4994 if ($prevrawline =~ /[^\\]\w"$/ && $rawline =~ /^\+[\t ]+"\w/) {
4995 WARN('MISSING_SPACE',
4996 "break quoted strings at a space character\n" . $hereprev);
4999 # check for spaces before a quoted newline
5000 if ($rawline =~ /^.*\".*\s\\n/) {
5001 if (WARN("QUOTED_WHITESPACE_BEFORE_NEWLINE",
5002 "unnecessary whitespace before a quoted newline\n" . $herecurr) &&
5004 $fixed[$fixlinenr] =~ s/^(\+.*\".*)\s+\\n/$1\\n/;
5009 # concatenated string without spaces between elements
5010 if ($line =~ /$String[A-Z_]/ || $line =~ /[A-Za-z0-9_]$String/) {
5011 CHK("CONCATENATED_STRING",
5012 "Concatenated strings should use spaces between elements\n" . $herecurr);
5015 # uncoalesced string fragments
5016 if ($line =~ /$String\s*"/) {
5017 WARN("STRING_FRAGMENTS",
5018 "Consecutive strings are generally better as a single string\n" . $herecurr);
5021 # check for %L{u,d,i} and 0x%[udi] in strings
5023 while ($line =~ /(?:^|")([X\t]*)(?:"|$)/g) {
5024 $string = substr($rawline, $-[1], $+[1] - $-[1]);
5025 $string =~ s/%%/__/g;
5026 if ($string =~ /(?<!%)%[\*\d\.\$]*L[udi]/) {
5028 "\%Ld/%Lu are not-standard C, use %lld/%llu\n" . $herecurr);
5031 if ($string =~ /0x%[\*\d\.\$\Llzth]*[udi]/) {
5032 ERROR("PRINTF_0xDECIMAL",
5033 "Prefixing 0x with decimal output is defective\n" . $herecurr);
5037 # check for line continuations in quoted strings with odd counts of "
5038 if ($rawline =~ /\\$/ && $rawline =~ tr/"/"/ % 2) {
5039 WARN("LINE_CONTINUATIONS",
5040 "Avoid line continuations in quoted strings\n" . $herecurr);
5044 if ($line =~ /^.\s*\#\s*if\s+0\b/) {
5045 CHK("REDUNDANT_CODE",
5046 "if this code is redundant consider removing it\n" .
5050 # check for needless "if (<foo>) fn(<foo>)" uses
5051 if ($prevline =~ /\bif\s*\(\s*($Lval)\s*\)/) {
5052 my $tested = quotemeta($1);
5053 my $expr = '\s*\(\s*' . $tested . '\s*\)\s*;';
5054 if ($line =~ /\b(kfree|usb_free_urb|debugfs_remove(?:_recursive)?|(?:kmem_cache|mempool|dma_pool)_destroy)$expr/) {
5056 if (WARN('NEEDLESS_IF',
5057 "$func(NULL) is safe and this check is probably not required\n" . $hereprev) &&
5060 my $leading_tabs = "";
5061 my $new_leading_tabs = "";
5062 if ($lines[$linenr - 2] =~ /^\+(\t*)if\s*\(\s*$tested\s*\)\s*$/) {
5067 if ($lines[$linenr - 1] =~ /^\+(\t+)$func\s*\(\s*$tested\s*\)\s*;\s*$/) {
5068 $new_leading_tabs = $1;
5069 if (length($leading_tabs) + 1 ne length($new_leading_tabs)) {
5076 fix_delete_line($fixlinenr - 1, $prevrawline);
5077 $fixed[$fixlinenr] =~ s/^\+$new_leading_tabs/\+$leading_tabs/;
5083 # check for unnecessary "Out of Memory" messages
5084 if ($line =~ /^\+.*\b$logFunctions\s*\(/ &&
5085 $prevline =~ /^[ \+]\s*if\s*\(\s*(\!\s*|NULL\s*==\s*)?($Lval)(\s*==\s*NULL\s*)?\s*\)/ &&
5086 (defined $1 || defined $3) &&
5089 my $testline = $lines[$linenr - 3];
5091 my ($s, $c) = ctx_statement_block($linenr - 3, $realcnt, 0);
5092 # print("line: <$line>\nprevline: <$prevline>\ns: <$s>\nc: <$c>\n\n\n");
5094 if ($c =~ /(?:^|\n)[ \+]\s*(?:$Type\s*)?\Q$testval\E\s*=\s*(?:\([^\)]*\)\s*)?\s*(?:devm_)?(?:[kv][czm]alloc(?:_node|_array)?\b|kstrdup|(?:dev_)?alloc_skb)/) {
5096 "Possible unnecessary 'out of memory' message\n" . $hereprev);
5100 # check for logging functions with KERN_<LEVEL>
5101 if ($line !~ /printk(?:_ratelimited|_once)?\s*\(/ &&
5102 $line =~ /\b$logFunctions\s*\(.*\b(KERN_[A-Z]+)\b/) {
5104 if (WARN("UNNECESSARY_KERN_LEVEL",
5105 "Possible unnecessary $level\n" . $herecurr) &&
5107 $fixed[$fixlinenr] =~ s/\s*$level\s*//;
5111 # check for mask then right shift without a parentheses
5112 if ($^V && $^V ge 5.10.0 &&
5113 $line =~ /$LvalOrFunc\s*\&\s*($LvalOrFunc)\s*>>/ &&
5114 $4 !~ /^\&/) { # $LvalOrFunc may be &foo, ignore if so
5115 WARN("MASK_THEN_SHIFT",
5116 "Possible precedence defect with mask then right shift - may need parentheses\n" . $herecurr);
5119 # check for pointer comparisons to NULL
5120 if ($^V && $^V ge 5.10.0) {
5121 while ($line =~ /\b$LvalOrFunc\s*(==|\!=)\s*NULL\b/g) {
5124 $equal = "" if ($4 eq "!=");
5125 if (CHK("COMPARISON_TO_NULL",
5126 "Comparison to NULL could be written \"${equal}${val}\"\n" . $herecurr) &&
5128 $fixed[$fixlinenr] =~ s/\b\Q$val\E\s*(?:==|\!=)\s*NULL\b/$equal$val/;
5133 # check for bad placement of section $InitAttribute (e.g.: __initdata)
5134 if ($line =~ /(\b$InitAttribute\b)/) {
5136 if ($line =~ /^\+\s*static\s+(?:const\s+)?(?:$attr\s+)?($NonptrTypeWithAttr)\s+(?:$attr\s+)?($Ident(?:\[[^]]*\])?)\s*[=;]/) {
5139 if ((($ptr =~ /\b(union|struct)\s+$attr\b/ &&
5140 ERROR("MISPLACED_INIT",
5141 "$attr should be placed after $var\n" . $herecurr)) ||
5142 ($ptr !~ /\b(union|struct)\s+$attr\b/ &&
5143 WARN("MISPLACED_INIT",
5144 "$attr should be placed after $var\n" . $herecurr))) &&
5146 $fixed[$fixlinenr] =~ s/(\bstatic\s+(?:const\s+)?)(?:$attr\s+)?($NonptrTypeWithAttr)\s+(?:$attr\s+)?($Ident(?:\[[^]]*\])?)\s*([=;])\s*/"$1" . trim(string_find_replace($2, "\\s*$attr\\s*", " ")) . " " . trim(string_find_replace($3, "\\s*$attr\\s*", "")) . " $attr" . ("$4" eq ";" ? ";" : " = ")/e;
5151 # check for $InitAttributeData (ie: __initdata) with const
5152 if ($line =~ /\bconst\b/ && $line =~ /($InitAttributeData)/) {
5154 $attr =~ /($InitAttributePrefix)(.*)/;
5155 my $attr_prefix = $1;
5157 if (ERROR("INIT_ATTRIBUTE",
5158 "Use of const init definition must use ${attr_prefix}initconst\n" . $herecurr) &&
5160 $fixed[$fixlinenr] =~
5161 s/$InitAttributeData/${attr_prefix}initconst/;
5165 # check for $InitAttributeConst (ie: __initconst) without const
5166 if ($line !~ /\bconst\b/ && $line =~ /($InitAttributeConst)/) {
5168 if (ERROR("INIT_ATTRIBUTE",
5169 "Use of $attr requires a separate use of const\n" . $herecurr) &&
5171 my $lead = $fixed[$fixlinenr] =~
5172 /(^\+\s*(?:static\s+))/;
5174 $lead = "$lead " if ($lead !~ /^\+$/);
5175 $lead = "${lead}const ";
5176 $fixed[$fixlinenr] =~ s/(^\+\s*(?:static\s+))/$lead/;
5180 # check for __read_mostly with const non-pointer (should just be const)
5181 if ($line =~ /\b__read_mostly\b/ &&
5182 $line =~ /($Type)\s*$Ident/ && $1 !~ /\*\s*$/ && $1 =~ /\bconst\b/) {
5183 if (ERROR("CONST_READ_MOSTLY",
5184 "Invalid use of __read_mostly with const type\n" . $herecurr) &&
5186 $fixed[$fixlinenr] =~ s/\s+__read_mostly\b//;
5190 # don't use __constant_<foo> functions outside of include/uapi/
5191 if ($realfile !~ m@^include/uapi/@ &&
5192 $line =~ /(__constant_(?:htons|ntohs|[bl]e(?:16|32|64)_to_cpu|cpu_to_[bl]e(?:16|32|64)))\s*\(/) {
5193 my $constant_func = $1;
5194 my $func = $constant_func;
5195 $func =~ s/^__constant_//;
5196 if (WARN("CONSTANT_CONVERSION",
5197 "$constant_func should be $func\n" . $herecurr) &&
5199 $fixed[$fixlinenr] =~ s/\b$constant_func\b/$func/g;
5203 # prefer usleep_range over udelay
5204 if ($line =~ /\budelay\s*\(\s*(\d+)\s*\)/) {
5206 # ignore udelay's < 10, however
5207 if (! ($delay < 10) ) {
5209 "usleep_range is preferred over udelay; see Documentation/timers/timers-howto.txt\n" . $herecurr);
5211 if ($delay > 2000) {
5213 "long udelay - prefer mdelay; see arch/arm/include/asm/delay.h\n" . $herecurr);
5217 # warn about unexpectedly long msleep's
5218 if ($line =~ /\bmsleep\s*\((\d+)\);/) {
5221 "msleep < 20ms can sleep for up to 20ms; see Documentation/timers/timers-howto.txt\n" . $herecurr);
5225 # check for comparisons of jiffies
5226 if ($line =~ /\bjiffies\s*$Compare|$Compare\s*jiffies\b/) {
5227 WARN("JIFFIES_COMPARISON",
5228 "Comparing jiffies is almost always wrong; prefer time_after, time_before and friends\n" . $herecurr);
5231 # check for comparisons of get_jiffies_64()
5232 if ($line =~ /\bget_jiffies_64\s*\(\s*\)\s*$Compare|$Compare\s*get_jiffies_64\s*\(\s*\)/) {
5233 WARN("JIFFIES_COMPARISON",
5234 "Comparing get_jiffies_64() is almost always wrong; prefer time_after64, time_before64 and friends\n" . $herecurr);
5237 # warn about #ifdefs in C files
5238 # if ($line =~ /^.\s*\#\s*if(|n)def/ && ($realfile =~ /\.c$/)) {
5239 # print "#ifdef in C files should be avoided\n";
5240 # print "$herecurr";
5244 # warn about spacing in #ifdefs
5245 if ($line =~ /^.\s*\#\s*(ifdef|ifndef|elif)\s\s+/) {
5246 if (ERROR("SPACING",
5247 "exactly one space required after that #$1\n" . $herecurr) &&
5249 $fixed[$fixlinenr] =~
5250 s/^(.\s*\#\s*(ifdef|ifndef|elif))\s{2,}/$1 /;
5255 # check for spinlock_t definitions without a comment.
5256 if ($line =~ /^.\s*(struct\s+mutex|spinlock_t)\s+\S+;/ ||
5257 $line =~ /^.\s*(DEFINE_MUTEX)\s*\(/) {
5259 if (!ctx_has_comment($first_line, $linenr)) {
5260 CHK("UNCOMMENTED_DEFINITION",
5261 "$1 definition without comment\n" . $herecurr);
5264 # check for memory barriers without a comment.
5270 read_barrier_depends
5272 my $barrier_stems = qr{
5280 my $all_barriers = qr{
5282 smp_(?:$barrier_stems)|
5283 virt_(?:$barrier_stems)
5286 if ($line =~ /\b(?:$all_barriers)\s*\(/) {
5287 if (!ctx_has_comment($first_line, $linenr)) {
5288 WARN("MEMORY_BARRIER",
5289 "memory barrier without comment\n" . $herecurr);
5293 my $underscore_smp_barriers = qr{__smp_(?:$barrier_stems)}x;
5295 if ($realfile !~ m@^include/asm-generic/@ &&
5296 $realfile !~ m@/barrier\.h$@ &&
5297 $line =~ m/\b(?:$underscore_smp_barriers)\s*\(/ &&
5298 $line !~ m/^.\s*\#\s*define\s+(?:$underscore_smp_barriers)\s*\(/) {
5299 WARN("MEMORY_BARRIER",
5300 "__smp memory barriers shouldn't be used outside barrier.h and asm-generic\n" . $herecurr);
5303 # check for waitqueue_active without a comment.
5304 if ($line =~ /\bwaitqueue_active\s*\(/) {
5305 if (!ctx_has_comment($first_line, $linenr)) {
5306 WARN("WAITQUEUE_ACTIVE",
5307 "waitqueue_active without comment\n" . $herecurr);
5311 # Check for expedited grace periods that interrupt non-idle non-nohz
5312 # online CPUs. These expedited can therefore degrade real-time response
5313 # if used carelessly, and should be avoided where not absolutely
5314 # needed. It is always OK to use synchronize_rcu_expedited() and
5315 # synchronize_sched_expedited() at boot time (before real-time applications
5316 # start) and in error situations where real-time response is compromised in
5317 # any case. Note that synchronize_srcu_expedited() does -not- interrupt
5318 # other CPUs, so don't warn on uses of synchronize_srcu_expedited().
5319 # Of course, nothing comes for free, and srcu_read_lock() and
5320 # srcu_read_unlock() do contain full memory barriers in payment for
5321 # synchronize_srcu_expedited() non-interruption properties.
5322 if ($line =~ /\b(synchronize_rcu_expedited|synchronize_sched_expedited)\(/) {
5323 WARN("EXPEDITED_RCU_GRACE_PERIOD",
5324 "expedited RCU grace periods should be avoided where they can degrade real-time response\n" . $herecurr);
5328 # check of hardware specific defines
5329 if ($line =~ m@^.\s*\#\s*if.*\b(__i386__|__powerpc64__|__sun__|__s390x__)\b@ && $realfile !~ m@include/asm-@) {
5331 "architecture specific defines should be avoided\n" . $herecurr);
5334 # Check that the storage class is at the beginning of a declaration
5335 if ($line =~ /\b$Storage\b/ && $line !~ /^.\s*$Storage\b/) {
5336 WARN("STORAGE_CLASS",
5337 "storage class should be at the beginning of the declaration\n" . $herecurr)
5340 # check the location of the inline attribute, that it is between
5341 # storage class and type.
5342 if ($line =~ /\b$Type\s+$Inline\b/ ||
5343 $line =~ /\b$Inline\s+$Storage\b/) {
5344 ERROR("INLINE_LOCATION",
5345 "inline keyword should sit between storage class and type\n" . $herecurr);
5348 # Check for __inline__ and __inline, prefer inline
5349 if ($realfile !~ m@\binclude/uapi/@ &&
5350 $line =~ /\b(__inline__|__inline)\b/) {
5352 "plain inline is preferred over $1\n" . $herecurr) &&
5354 $fixed[$fixlinenr] =~ s/\b(__inline__|__inline)\b/inline/;
5359 # Check for __attribute__ packed, prefer __packed
5360 if ($realfile !~ m@\binclude/uapi/@ &&
5361 $line =~ /\b__attribute__\s*\(\s*\(.*\bpacked\b/) {
5362 WARN("PREFER_PACKED",
5363 "__packed is preferred over __attribute__((packed))\n" . $herecurr);
5366 # Check for __attribute__ aligned, prefer __aligned
5367 if ($realfile !~ m@\binclude/uapi/@ &&
5368 $line =~ /\b__attribute__\s*\(\s*\(.*aligned/) {
5369 WARN("PREFER_ALIGNED",
5370 "__aligned(size) is preferred over __attribute__((aligned(size)))\n" . $herecurr);
5373 # Check for __attribute__ format(printf, prefer __printf
5374 if ($realfile !~ m@\binclude/uapi/@ &&
5375 $line =~ /\b__attribute__\s*\(\s*\(\s*format\s*\(\s*printf/) {
5376 if (WARN("PREFER_PRINTF",
5377 "__printf(string-index, first-to-check) is preferred over __attribute__((format(printf, string-index, first-to-check)))\n" . $herecurr) &&
5379 $fixed[$fixlinenr] =~ s/\b__attribute__\s*\(\s*\(\s*format\s*\(\s*printf\s*,\s*(.*)\)\s*\)\s*\)/"__printf(" . trim($1) . ")"/ex;
5384 # Check for __attribute__ format(scanf, prefer __scanf
5385 if ($realfile !~ m@\binclude/uapi/@ &&
5386 $line =~ /\b__attribute__\s*\(\s*\(\s*format\s*\(\s*scanf\b/) {
5387 if (WARN("PREFER_SCANF",
5388 "__scanf(string-index, first-to-check) is preferred over __attribute__((format(scanf, string-index, first-to-check)))\n" . $herecurr) &&
5390 $fixed[$fixlinenr] =~ s/\b__attribute__\s*\(\s*\(\s*format\s*\(\s*scanf\s*,\s*(.*)\)\s*\)\s*\)/"__scanf(" . trim($1) . ")"/ex;
5394 # Check for __attribute__ weak, or __weak declarations (may have link issues)
5395 if ($^V && $^V ge 5.10.0 &&
5396 $line =~ /(?:$Declare|$DeclareMisordered)\s*$Ident\s*$balanced_parens\s*(?:$Attribute)?\s*;/ &&
5397 ($line =~ /\b__attribute__\s*\(\s*\(.*\bweak\b/ ||
5398 $line =~ /\b__weak\b/)) {
5399 ERROR("WEAK_DECLARATION",
5400 "Using weak declarations can have unintended link defects\n" . $herecurr);
5403 # check for c99 types like uint8_t used outside of uapi/
5404 if ($realfile !~ m@\binclude/uapi/@ &&
5405 $line =~ /\b($Declare)\s*$Ident\s*[=;,\[]/) {
5407 if ($type =~ /\b($typeC99Typedefs)\b/) {
5409 my $kernel_type = 'u';
5410 $kernel_type = 's' if ($type =~ /^_*[si]/);
5413 if (CHK("PREFER_KERNEL_TYPES",
5414 "Prefer kernel type '$kernel_type' over '$type'\n" . $herecurr) &&
5416 $fixed[$fixlinenr] =~ s/\b$type\b/$kernel_type/;
5421 # check for cast of C90 native int or longer types constants
5422 if ($line =~ /(\(\s*$C90_int_types\s*\)\s*)($Constant)\b/) {
5425 if (WARN("TYPECAST_INT_CONSTANT",
5426 "Unnecessary typecast of c90 int constant\n" . $herecurr) &&
5429 my $newconst = $const;
5430 $newconst =~ s/${Int_type}$//;
5431 $suffix .= 'U' if ($cast =~ /\bunsigned\b/);
5432 if ($cast =~ /\blong\s+long\b/) {
5434 } elsif ($cast =~ /\blong\b/) {
5437 $fixed[$fixlinenr] =~ s/\Q$cast\E$const\b/$newconst$suffix/;
5441 # check for sizeof(&)
5442 if ($line =~ /\bsizeof\s*\(\s*\&/) {
5443 WARN("SIZEOF_ADDRESS",
5444 "sizeof(& should be avoided\n" . $herecurr);
5447 # check for sizeof without parenthesis
5448 if ($line =~ /\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/) {
5449 if (WARN("SIZEOF_PARENTHESIS",
5450 "sizeof $1 should be sizeof($1)\n" . $herecurr) &&
5452 $fixed[$fixlinenr] =~ s/\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/"sizeof(" . trim($1) . ")"/ex;
5456 # check for struct spinlock declarations
5457 if ($line =~ /^.\s*\bstruct\s+spinlock\s+\w+\s*;/) {
5458 WARN("USE_SPINLOCK_T",
5459 "struct spinlock should be spinlock_t\n" . $herecurr);
5462 # check for seq_printf uses that could be seq_puts
5463 if ($sline =~ /\bseq_printf\s*\(.*"\s*\)\s*;\s*$/) {
5464 my $fmt = get_quoted_string($line, $rawline);
5467 if (WARN("PREFER_SEQ_PUTS",
5468 "Prefer seq_puts to seq_printf\n" . $herecurr) &&
5470 $fixed[$fixlinenr] =~ s/\bseq_printf\b/seq_puts/;
5475 # Check for misused memsets
5476 if ($^V && $^V ge 5.10.0 &&
5478 $stat =~ /^\+(?:.*?)\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*$FuncArg\s*\)/) {
5484 if ($ms_size =~ /^(0x|)0$/i) {
5486 "memset to 0's uses 0 as the 2nd argument, not the 3rd\n" . "$here\n$stat\n");
5487 } elsif ($ms_size =~ /^(0x|)1$/i) {
5489 "single byte memset is suspicious. Swapped 2nd/3rd argument?\n" . "$here\n$stat\n");
5493 # Check for memcpy(foo, bar, ETH_ALEN) that could be ether_addr_copy(foo, bar)
5494 if ($^V && $^V ge 5.10.0 &&
5496 $stat =~ /^\+(?:.*?)\bmemcpy\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/) {
5497 if (WARN("PREFER_ETHER_ADDR_COPY",
5498 "Prefer ether_addr_copy() over memcpy() if the Ethernet addresses are __aligned(2)\n" . "$here\n$stat\n") &&
5500 $fixed[$fixlinenr] =~ s/\bmemcpy\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/ether_addr_copy($2, $7)/;
5504 # Check for memcmp(foo, bar, ETH_ALEN) that could be ether_addr_equal*(foo, bar)
5505 if ($^V && $^V ge 5.10.0 &&
5507 $stat =~ /^\+(?:.*?)\bmemcmp\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/) {
5508 WARN("PREFER_ETHER_ADDR_EQUAL",
5509 "Prefer ether_addr_equal() or ether_addr_equal_unaligned() over memcmp()\n" . "$here\n$stat\n")
5512 # check for memset(foo, 0x0, ETH_ALEN) that could be eth_zero_addr
5513 # check for memset(foo, 0xFF, ETH_ALEN) that could be eth_broadcast_addr
5514 if ($^V && $^V ge 5.10.0 &&
5516 $stat =~ /^\+(?:.*?)\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/) {
5520 if ($ms_val =~ /^(?:0x|)0+$/i) {
5521 if (WARN("PREFER_ETH_ZERO_ADDR",
5522 "Prefer eth_zero_addr over memset()\n" . "$here\n$stat\n") &&
5524 $fixed[$fixlinenr] =~ s/\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*,\s*ETH_ALEN\s*\)/eth_zero_addr($2)/;
5526 } elsif ($ms_val =~ /^(?:0xff|255)$/i) {
5527 if (WARN("PREFER_ETH_BROADCAST_ADDR",
5528 "Prefer eth_broadcast_addr() over memset()\n" . "$here\n$stat\n") &&
5530 $fixed[$fixlinenr] =~ s/\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*,\s*ETH_ALEN\s*\)/eth_broadcast_addr($2)/;
5535 # typecasts on min/max could be min_t/max_t
5536 if ($^V && $^V ge 5.10.0 &&
5538 $stat =~ /^\+(?:.*?)\b(min|max)\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\)/) {
5539 if (defined $2 || defined $7) {
5541 my $cast1 = deparenthesize($2);
5543 my $cast2 = deparenthesize($7);
5547 if ($cast1 ne "" && $cast2 ne "" && $cast1 ne $cast2) {
5548 $cast = "$cast1 or $cast2";
5549 } elsif ($cast1 ne "") {
5555 "$call() should probably be ${call}_t($cast, $arg1, $arg2)\n" . "$here\n$stat\n");
5559 # check usleep_range arguments
5560 if ($^V && $^V ge 5.10.0 &&
5562 $stat =~ /^\+(?:.*?)\busleep_range\s*\(\s*($FuncArg)\s*,\s*($FuncArg)\s*\)/) {
5566 WARN("USLEEP_RANGE",
5567 "usleep_range should not use min == max args; see Documentation/timers/timers-howto.txt\n" . "$here\n$stat\n");
5568 } elsif ($min =~ /^\d+$/ && $max =~ /^\d+$/ &&
5570 WARN("USLEEP_RANGE",
5571 "usleep_range args reversed, use min then max; see Documentation/timers/timers-howto.txt\n" . "$here\n$stat\n");
5575 # check for naked sscanf
5576 if ($^V && $^V ge 5.10.0 &&
5578 $line =~ /\bsscanf\b/ &&
5579 ($stat !~ /$Ident\s*=\s*sscanf\s*$balanced_parens/ &&
5580 $stat !~ /\bsscanf\s*$balanced_parens\s*(?:$Compare)/ &&
5581 $stat !~ /(?:$Compare)\s*\bsscanf\s*$balanced_parens/)) {
5582 my $lc = $stat =~ tr@\n@@;
5583 $lc = $lc + $linenr;
5584 my $stat_real = raw_line($linenr, 0);
5585 for (my $count = $linenr + 1; $count <= $lc; $count++) {
5586 $stat_real = $stat_real . "\n" . raw_line($count, 0);
5588 WARN("NAKED_SSCANF",
5589 "unchecked sscanf return value\n" . "$here\n$stat_real\n");
5592 # check for simple sscanf that should be kstrto<foo>
5593 if ($^V && $^V ge 5.10.0 &&
5595 $line =~ /\bsscanf\b/) {
5596 my $lc = $stat =~ tr@\n@@;
5597 $lc = $lc + $linenr;
5598 my $stat_real = raw_line($linenr, 0);
5599 for (my $count = $linenr + 1; $count <= $lc; $count++) {
5600 $stat_real = $stat_real . "\n" . raw_line($count, 0);
5602 if ($stat_real =~ /\bsscanf\b\s*\(\s*$FuncArg\s*,\s*("[^"]+")/) {
5604 my $count = $format =~ tr@%@%@;
5606 $format =~ /^"\%(?i:ll[udxi]|[udxi]ll|ll|[hl]h?[udxi]|[udxi][hl]h?|[hl]h?|[udxi])"$/) {
5607 WARN("SSCANF_TO_KSTRTO",
5608 "Prefer kstrto<type> to single variable sscanf\n" . "$here\n$stat_real\n");
5613 # check for new externs in .h files.
5614 if ($realfile =~ /\.h$/ &&
5615 $line =~ /^\+\s*(extern\s+)$Type\s*$Ident\s*\(/s) {
5616 if (CHK("AVOID_EXTERNS",
5617 "extern prototypes should be avoided in .h files\n" . $herecurr) &&
5619 $fixed[$fixlinenr] =~ s/(.*)\bextern\b\s*(.*)/$1$2/;
5623 # check for new externs in .c files.
5624 if ($realfile =~ /\.c$/ && defined $stat &&
5625 $stat =~ /^.\s*(?:extern\s+)?$Type\s+($Ident)(\s*)\(/s)
5627 my $function_name = $1;
5628 my $paren_space = $2;
5631 if (defined $cond) {
5632 substr($s, 0, length($cond), '');
5634 if ($s =~ /^\s*;/ &&
5635 $function_name ne 'uninitialized_var')
5637 WARN("AVOID_EXTERNS",
5638 "externs should be avoided in .c files\n" . $herecurr);
5641 if ($paren_space =~ /\n/) {
5642 WARN("FUNCTION_ARGUMENTS",
5643 "arguments for function declarations should follow identifier\n" . $herecurr);
5646 } elsif ($realfile =~ /\.c$/ && defined $stat &&
5647 $stat =~ /^.\s*extern\s+/)
5649 WARN("AVOID_EXTERNS",
5650 "externs should be avoided in .c files\n" . $herecurr);
5653 # checks for new __setup's
5654 if ($rawline =~ /\b__setup\("([^"]*)"/) {
5657 if (!grep(/$name/, @setup_docs)) {
5658 CHK("UNDOCUMENTED_SETUP",
5659 "__setup appears un-documented -- check Documentation/kernel-parameters.txt\n" . $herecurr);
5663 # check for pointless casting of kmalloc return
5664 if ($line =~ /\*\s*\)\s*[kv][czm]alloc(_node){0,1}\b/) {
5665 WARN("UNNECESSARY_CASTS",
5666 "unnecessary cast may hide bugs, see http://c-faq.com/malloc/mallocnocast.html\n" . $herecurr);
5670 # p = alloc(sizeof(struct foo), ...) should be p = alloc(sizeof(*p), ...)
5671 if ($^V && $^V ge 5.10.0 &&
5672 $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*([kv][mz]alloc(?:_node)?)\s*\(\s*(sizeof\s*\(\s*struct\s+$Lval\s*\))/) {
5673 CHK("ALLOC_SIZEOF_STRUCT",
5674 "Prefer $3(sizeof(*$1)...) over $3($4...)\n" . $herecurr);
5677 # check for k[mz]alloc with multiplies that could be kmalloc_array/kcalloc
5678 if ($^V && $^V ge 5.10.0 &&
5679 $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*(k[mz]alloc)\s*\(\s*($FuncArg)\s*\*\s*($FuncArg)\s*,/) {
5683 my $newfunc = "kmalloc_array";
5684 $newfunc = "kcalloc" if ($oldfunc eq "kzalloc");
5687 if ($a1 =~ /^sizeof\s*\S/) {
5691 if ($r1 !~ /^sizeof\b/ && $r2 =~ /^sizeof\s*\S/ &&
5692 !($r1 =~ /^$Constant$/ || $r1 =~ /^[A-Z_][A-Z0-9_]*$/)) {
5693 if (WARN("ALLOC_WITH_MULTIPLY",
5694 "Prefer $newfunc over $oldfunc with multiply\n" . $herecurr) &&
5696 $fixed[$fixlinenr] =~ s/\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*(k[mz]alloc)\s*\(\s*($FuncArg)\s*\*\s*($FuncArg)/$1 . ' = ' . "$newfunc(" . trim($r1) . ', ' . trim($r2)/e;
5702 # check for krealloc arg reuse
5703 if ($^V && $^V ge 5.10.0 &&
5704 $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*krealloc\s*\(\s*\1\s*,/) {
5705 WARN("KREALLOC_ARG_REUSE",
5706 "Reusing the krealloc arg is almost always a bug\n" . $herecurr);
5709 # check for alloc argument mismatch
5710 if ($line =~ /\b(kcalloc|kmalloc_array)\s*\(\s*sizeof\b/) {
5711 WARN("ALLOC_ARRAY_ARGS",
5712 "$1 uses number as first arg, sizeof is generally wrong\n" . $herecurr);
5715 # check for multiple semicolons
5716 if ($line =~ /;\s*;\s*$/) {
5717 if (WARN("ONE_SEMICOLON",
5718 "Statements terminations use 1 semicolon\n" . $herecurr) &&
5720 $fixed[$fixlinenr] =~ s/(\s*;\s*){2,}$/;/g;
5724 # check for #defines like: 1 << <digit> that could be BIT(digit)
5725 if ($line =~ /#\s*define\s+\w+\s+\(?\s*1\s*([ulUL]*)\s*\<\<\s*(?:\d+|$Ident)\s*\)?/) {
5727 $ull = "_ULL" if (defined($1) && $1 =~ /ll/i);
5728 if (CHK("BIT_MACRO",
5729 "Prefer using the BIT$ull macro\n" . $herecurr) &&
5731 $fixed[$fixlinenr] =~ s/\(?\s*1\s*[ulUL]*\s*<<\s*(\d+|$Ident)\s*\)?/BIT${ull}($1)/;
5735 # check for #if defined CONFIG_<FOO> || defined CONFIG_<FOO>_MODULE
5736 if ($line =~ /^\+\s*#\s*if\s+defined(?:\s*\(?\s*|\s+)(CONFIG_[A-Z_]+)\s*\)?\s*\|\|\s*defined(?:\s*\(?\s*|\s+)\1_MODULE\s*\)?\s*$/) {
5738 if (WARN("PREFER_IS_ENABLED",
5739 "Prefer IS_ENABLED(<FOO>) to CONFIG_<FOO> || CONFIG_<FOO>_MODULE\n" . $herecurr) &&
5741 $fixed[$fixlinenr] = "\+#if IS_ENABLED($config)";
5745 # check for case / default statements not preceded by break/fallthrough/switch
5746 if ($line =~ /^.\s*(?:case\s+(?:$Ident|$Constant)\s*|default):/) {
5748 my $has_statement = 0;
5750 my $prevline = $linenr;
5751 while ($prevline > 1 && ($file || $count < 3) && !$has_break) {
5753 my $rline = $rawlines[$prevline - 1];
5754 my $fline = $lines[$prevline - 1];
5755 last if ($fline =~ /^\@\@/);
5756 next if ($fline =~ /^\-/);
5757 next if ($fline =~ /^.(?:\s*(?:case\s+(?:$Ident|$Constant)[\s$;]*|default):[\s$;]*)*$/);
5758 $has_break = 1 if ($rline =~ /fall[\s_-]*(through|thru)/i);
5759 next if ($fline =~ /^.[\s$;]*$/);
5762 $has_break = 1 if ($fline =~ /\bswitch\b|\b(?:break\s*;[\s$;]*$|return\b|goto\b|continue\b)/);
5764 if (!$has_break && $has_statement) {
5765 WARN("MISSING_BREAK",
5766 "Possible switch case/default not preceeded by break or fallthrough comment\n" . $herecurr);
5770 # check for switch/default statements without a break;
5771 if ($^V && $^V ge 5.10.0 &&
5773 $stat =~ /^\+[$;\s]*(?:case[$;\s]+\w+[$;\s]*:[$;\s]*|)*[$;\s]*\bdefault[$;\s]*:[$;\s]*;/g) {
5775 my $herectx = $here . "\n";
5776 my $cnt = statement_rawlines($stat);
5777 for (my $n = 0; $n < $cnt; $n++) {
5778 $herectx .= raw_line($linenr, $n) . "\n";
5780 WARN("DEFAULT_NO_BREAK",
5781 "switch default: should use break\n" . $herectx);
5784 # check for gcc specific __FUNCTION__
5785 if ($line =~ /\b__FUNCTION__\b/) {
5786 if (WARN("USE_FUNC",
5787 "__func__ should be used instead of gcc specific __FUNCTION__\n" . $herecurr) &&
5789 $fixed[$fixlinenr] =~ s/\b__FUNCTION__\b/__func__/g;
5793 # check for uses of __DATE__, __TIME__, __TIMESTAMP__
5794 while ($line =~ /\b(__(?:DATE|TIME|TIMESTAMP)__)\b/g) {
5796 "Use of the '$1' macro makes the build non-deterministic\n" . $herecurr);
5799 # check for use of yield()
5800 if ($line =~ /\byield\s*\(\s*\)/) {
5802 "Using yield() is generally wrong. See yield() kernel-doc (sched/core.c)\n" . $herecurr);
5805 # check for comparisons against true and false
5806 if ($line =~ /\+\s*(.*?)\b(true|false|$Lval)\s*(==|\!=)\s*(true|false|$Lval)\b(.*)$/i) {
5814 ($arg, $otype) = ($otype, $arg) if ($arg =~ /^(?:true|false)$/i);
5816 my $type = lc($otype);
5817 if ($type =~ /^(?:true|false)$/) {
5818 if (("$test" eq "==" && "$type" eq "true") ||
5819 ("$test" eq "!=" && "$type" eq "false")) {
5823 CHK("BOOL_COMPARISON",
5824 "Using comparison to $otype is error prone\n" . $herecurr);
5826 ## maybe suggesting a correct construct would better
5827 ## "Using comparison to $otype is error prone. Perhaps use '${lead}${op}${arg}${trail}'\n" . $herecurr);
5832 # check for semaphores initialized locked
5833 if ($line =~ /^.\s*sema_init.+,\W?0\W?\)/) {
5834 WARN("CONSIDER_COMPLETION",
5835 "consider using a completion\n" . $herecurr);
5838 # recommend kstrto* over simple_strto* and strict_strto*
5839 if ($line =~ /\b((simple|strict)_(strto(l|ll|ul|ull)))\s*\(/) {
5840 WARN("CONSIDER_KSTRTO",
5841 "$1 is obsolete, use k$3 instead\n" . $herecurr);
5844 # check for __initcall(), use device_initcall() explicitly or more appropriate function please
5845 if ($line =~ /^.\s*__initcall\s*\(/) {
5846 WARN("USE_DEVICE_INITCALL",
5847 "please use device_initcall() or more appropriate function instead of __initcall() (see include/linux/init.h)\n" . $herecurr);
5850 # check for various structs that are normally const (ops, kgdb, device_tree)
5851 my $const_structs = qr{
5853 address_space_operations|
5855 block_device_operations|
5860 file_lock_operations|
5870 lock_manager_operations|
5877 pipe_buf_operations|
5878 platform_hibernation_ops|
5879 platform_suspend_ops|
5884 soc_pcmcia_socket_ops|
5891 if ($line !~ /\bconst\b/ &&
5892 $line =~ /\bstruct\s+($const_structs)\b/) {
5893 WARN("CONST_STRUCT",
5894 "struct $1 should normally be const\n" .
5898 # use of NR_CPUS is usually wrong
5899 # ignore definitions of NR_CPUS and usage to define arrays as likely right
5900 if ($line =~ /\bNR_CPUS\b/ &&
5901 $line !~ /^.\s*\s*#\s*if\b.*\bNR_CPUS\b/ &&
5902 $line !~ /^.\s*\s*#\s*define\b.*\bNR_CPUS\b/ &&
5903 $line !~ /^.\s*$Declare\s.*\[[^\]]*NR_CPUS[^\]]*\]/ &&
5904 $line !~ /\[[^\]]*\.\.\.[^\]]*NR_CPUS[^\]]*\]/ &&
5905 $line !~ /\[[^\]]*NR_CPUS[^\]]*\.\.\.[^\]]*\]/)
5908 "usage of NR_CPUS is often wrong - consider using cpu_possible(), num_possible_cpus(), for_each_possible_cpu(), etc\n" . $herecurr);
5911 # Use of __ARCH_HAS_<FOO> or ARCH_HAVE_<BAR> is wrong.
5912 if ($line =~ /\+\s*#\s*define\s+((?:__)?ARCH_(?:HAS|HAVE)\w*)\b/) {
5913 ERROR("DEFINE_ARCH_HAS",
5914 "#define of '$1' is wrong - use Kconfig variables or standard guards instead\n" . $herecurr);
5917 # likely/unlikely comparisons similar to "(likely(foo) > 0)"
5918 if ($^V && $^V ge 5.10.0 &&
5919 $line =~ /\b((?:un)?likely)\s*\(\s*$FuncArg\s*\)\s*$Compare/) {
5920 WARN("LIKELY_MISUSE",
5921 "Using $1 should generally have parentheses around the comparison\n" . $herecurr);
5924 # whine mightly about in_atomic
5925 if ($line =~ /\bin_atomic\s*\(/) {
5926 if ($realfile =~ m@^drivers/@) {
5928 "do not use in_atomic in drivers\n" . $herecurr);
5929 } elsif ($realfile !~ m@^kernel/@) {
5931 "use of in_atomic() is incorrect outside core kernel code\n" . $herecurr);
5935 # whine about ACCESS_ONCE
5936 if ($^V && $^V ge 5.10.0 &&
5937 $line =~ /\bACCESS_ONCE\s*$balanced_parens\s*(=(?!=))?\s*($FuncArg)?/) {
5941 $par =~ s/^\(\s*(.*)\s*\)$/$1/;
5943 if (WARN("PREFER_WRITE_ONCE",
5944 "Prefer WRITE_ONCE(<FOO>, <BAR>) over ACCESS_ONCE(<FOO>) = <BAR>\n" . $herecurr) &&
5946 $fixed[$fixlinenr] =~ s/\bACCESS_ONCE\s*\(\s*\Q$par\E\s*\)\s*$eq\s*\Q$fun\E/WRITE_ONCE($par, $fun)/;
5949 if (WARN("PREFER_READ_ONCE",
5950 "Prefer READ_ONCE(<FOO>) over ACCESS_ONCE(<FOO>)\n" . $herecurr) &&
5952 $fixed[$fixlinenr] =~ s/\bACCESS_ONCE\s*\(\s*\Q$par\E\s*\)/READ_ONCE($par)/;
5957 # check for lockdep_set_novalidate_class
5958 if ($line =~ /^.\s*lockdep_set_novalidate_class\s*\(/ ||
5959 $line =~ /__lockdep_no_validate__\s*\)/ ) {
5960 if ($realfile !~ m@^kernel/lockdep@ &&
5961 $realfile !~ m@^include/linux/lockdep@ &&
5962 $realfile !~ m@^drivers/base/core@) {
5964 "lockdep_no_validate class is reserved for device->mutex.\n" . $herecurr);
5968 if ($line =~ /debugfs_create_\w+.*\b$mode_perms_world_writable\b/ ||
5969 $line =~ /DEVICE_ATTR.*\b$mode_perms_world_writable\b/) {
5970 WARN("EXPORTED_WORLD_WRITABLE",
5971 "Exporting world writable files is usually an error. Consider more restrictive permissions.\n" . $herecurr);
5974 # Mode permission misuses where it seems decimal should be octal
5975 # This uses a shortcut match to avoid unnecessary uses of a slow foreach loop
5976 if ($^V && $^V ge 5.10.0 &&
5977 $line =~ /$mode_perms_search/) {
5978 foreach my $entry (@mode_permission_funcs) {
5979 my $func = $entry->[0];
5980 my $arg_pos = $entry->[1];
5985 $skip_args = "(?:\\s*$FuncArg\\s*,\\s*){$arg_pos,$arg_pos}";
5987 my $test = "\\b$func\\s*\\(${skip_args}([\\d]+)\\s*[,\\)]";
5988 if ($line =~ /$test/) {
5990 $val = $6 if ($skip_args ne "");
5992 if ($val !~ /^0$/ &&
5993 (($val =~ /^$Int$/ && $val !~ /^$Octal$/) ||
5994 length($val) ne 4)) {
5995 ERROR("NON_OCTAL_PERMISSIONS",
5996 "Use 4 digit octal (0777) not decimal permissions\n" . $herecurr);
5997 } elsif ($val =~ /^$Octal$/ && (oct($val) & 02)) {
5998 ERROR("EXPORTED_WORLD_WRITABLE",
5999 "Exporting writable files is usually an error. Consider more restrictive permissions.\n" . $herecurr);
6005 # validate content of MODULE_LICENSE against list from include/linux/module.h
6006 if ($line =~ /\bMODULE_LICENSE\s*\(\s*($String)\s*\)/) {
6007 my $extracted_string = get_quoted_string($line, $rawline);
6008 my $valid_licenses = qr{
6011 GPL\ and\ additional\ rights|
6017 if ($extracted_string !~ /^"(?:$valid_licenses)"$/x) {
6018 WARN("MODULE_LICENSE",
6019 "unknown module license " . $extracted_string . "\n" . $herecurr);
6024 # If we have no input at all, then there is nothing to report on
6025 # so just keep quiet.
6026 if ($#rawlines == -1) {
6030 # In mailback mode only produce a report in the negative, for
6031 # things that appear to be patches.
6032 if ($mailback && ($clean == 1 || !$is_patch)) {
6036 # This is not a patch, and we are are in 'no-patch' mode so
6038 if (!$chk_patch && !$is_patch) {
6042 if (!$is_patch && $file !~ /cover-letter\.patch$/) {
6043 ERROR("NOT_UNIFIED_DIFF",
6044 "Does not appear to be a unified-diff format patch\n");
6046 if ($is_patch && $filename ne '-' && $chk_signoff && $signoff == 0) {
6047 ERROR("MISSING_SIGN_OFF",
6048 "Missing Signed-off-by: line(s)\n");
6051 print report_dump();
6052 if ($summary && !($clean == 1 && $quiet == 1)) {
6053 print "$filename " if ($summary_file);
6054 print "total: $cnt_error errors, $cnt_warn warnings, " .
6055 (($check)? "$cnt_chk checks, " : "") .
6056 "$cnt_lines lines checked\n";
6060 # If there were any defects found and not already fixing them
6061 if (!$clean and !$fix) {
6064 NOTE: For some of the reported defects, checkpatch may be able to
6065 mechanically convert to the typical style using --fix or --fix-inplace.
6068 # If there were whitespace errors which cleanpatch can fix
6069 # then suggest that.
6070 if ($rpt_cleaners) {
6074 NOTE: Whitespace errors detected.
6075 You may wish to use scripts/cleanpatch or scripts/cleanfile
6080 if ($clean == 0 && $fix &&
6081 ("@rawlines" ne "@fixed" ||
6082 $#fixed_inserted >= 0 || $#fixed_deleted >= 0)) {
6083 my $newfile = $filename;
6084 $newfile .= ".EXPERIMENTAL-checkpatch-fixes" if (!$fix_inplace);
6088 @fixed = fix_inserted_deleted_lines(\@fixed, \@fixed_inserted, \@fixed_deleted);
6090 open($f, '>', $newfile)
6091 or die "$P: Can't open $newfile for write\n";
6092 foreach my $fixed_line (@fixed) {
6095 if ($linecount > 3) {
6096 $fixed_line =~ s/^\+//;
6097 print $f $fixed_line . "\n";
6100 print $f $fixed_line . "\n";
6108 Wrote EXPERIMENTAL --fix correction(s) to '$newfile'
6110 Do _NOT_ trust the results written to this file.
6111 Do _NOT_ submit these changes without inspecting them for correctness.
6113 This EXPERIMENTAL file is simply a convenience to help rewrite patches.
6114 No warranties, expressed or implied...
6122 print "$vname has no obvious style problems and is ready for submission.\n";
6124 print "$vname has style problems, please review.\n";