blob: 4142f5c837e21bd912b0770e68cc427c308dec16 [file] [log] [blame]
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02001#!/usr/bin/env perl
Joe Hershberger05622192011-10-18 10:06:59 +00002# (c) 2001, Dave Jones. (the file handling bit)
3# (c) 2005, Joel Schopp <jschopp@austin.ibm.com> (the ugly bit)
4# (c) 2007,2008, Andy Whitcroft <apw@uk.ibm.com> (new conditions, test suite)
5# (c) 2008-2010 Andy Whitcroft <apw@canonical.com>
6# Licensed under the terms of the GNU GPL License version 2
7
8use strict;
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02009use warnings;
Tom Rini6b9709d2014-02-27 08:27:28 -050010use POSIX;
Dan Murphyc10e0f52017-01-31 14:15:53 -060011use File::Basename;
12use Cwd 'abs_path';
Heinrich Schuchardt6305db92017-09-12 09:57:45 +020013use Term::ANSIColor qw(:constants);
Joe Hershberger05622192011-10-18 10:06:59 +000014
15my $P = $0;
Dan Murphyc10e0f52017-01-31 14:15:53 -060016my $D = dirname(abs_path($P));
Joe Hershberger05622192011-10-18 10:06:59 +000017
18my $V = '0.32';
19
20use Getopt::Long qw(:config no_auto_abbrev);
21
22my $quiet = 0;
23my $tree = 1;
24my $chk_signoff = 1;
25my $chk_patch = 1;
26my $tst_only;
27my $emacs = 0;
28my $terse = 0;
Heinrich Schuchardt6305db92017-09-12 09:57:45 +020029my $showfile = 0;
Joe Hershberger05622192011-10-18 10:06:59 +000030my $file = 0;
Heinrich Schuchardt6305db92017-09-12 09:57:45 +020031my $git = 0;
32my %git_commits = ();
Joe Hershberger05622192011-10-18 10:06:59 +000033my $check = 0;
Heinrich Schuchardt6305db92017-09-12 09:57:45 +020034my $check_orig = 0;
Joe Hershberger05622192011-10-18 10:06:59 +000035my $summary = 1;
36my $mailback = 0;
37my $summary_file = 0;
38my $show_types = 0;
Heinrich Schuchardt6305db92017-09-12 09:57:45 +020039my $list_types = 0;
Tom Rini6b9709d2014-02-27 08:27:28 -050040my $fix = 0;
41my $fix_inplace = 0;
Joe Hershberger05622192011-10-18 10:06:59 +000042my $root;
43my %debug;
Tom Rini6b9709d2014-02-27 08:27:28 -050044my %camelcase = ();
45my %use_type = ();
46my @use = ();
Joe Hershberger05622192011-10-18 10:06:59 +000047my %ignore_type = ();
48my @ignore = ();
49my $help = 0;
50my $configuration_file = ".checkpatch.conf";
Kim Phillipsd45a6ae2013-02-28 12:53:52 +000051my $max_line_length = 80;
Tom Rini6b9709d2014-02-27 08:27:28 -050052my $ignore_perl_version = 0;
53my $minimum_perl_version = 5.10.0;
Heinrich Schuchardt6305db92017-09-12 09:57:45 +020054my $min_conf_desc_length = 4;
Dan Murphyc10e0f52017-01-31 14:15:53 -060055my $spelling_file = "$D/spelling.txt";
56my $codespell = 0;
57my $codespellfile = "/usr/share/codespell/dictionary.txt";
Heinrich Schuchardt6305db92017-09-12 09:57:45 +020058my $conststructsfile = "$D/const_structs.checkpatch";
59my $typedefsfile = "";
60my $color = "auto";
61my $allow_c99_comments = 1;
Joe Hershberger05622192011-10-18 10:06:59 +000062
63sub help {
64 my ($exitcode) = @_;
65
66 print << "EOM";
67Usage: $P [OPTION]... [FILE]...
68Version: $V
69
70Options:
71 -q, --quiet quiet
72 --no-tree run without a kernel tree
73 --no-signoff do not check for 'Signed-off-by' line
74 --patch treat FILE as patchfile (default)
75 --emacs emacs compile window format
76 --terse one line per report
Heinrich Schuchardt6305db92017-09-12 09:57:45 +020077 --showfile emit diffed file position, not input file position
78 -g, --git treat FILE as a single commit or git revision range
79 single git commit with:
80 <rev>
81 <rev>^
82 <rev>~n
83 multiple git commits with:
84 <rev1>..<rev2>
85 <rev1>...<rev2>
86 <rev>-<count>
87 git merges are ignored
Joe Hershberger05622192011-10-18 10:06:59 +000088 -f, --file treat FILE as regular source file
89 --subjective, --strict enable more subjective tests
Heinrich Schuchardt6305db92017-09-12 09:57:45 +020090 --list-types list the possible message types
Tom Rini6b9709d2014-02-27 08:27:28 -050091 --types TYPE(,TYPE2...) show only these comma separated message types
Joe Hershberger05622192011-10-18 10:06:59 +000092 --ignore TYPE(,TYPE2...) ignore various comma separated message types
Heinrich Schuchardt6305db92017-09-12 09:57:45 +020093 --show-types show the specific message type in the output
Kim Phillipsd45a6ae2013-02-28 12:53:52 +000094 --max-line-length=n set the maximum line length, if exceeded, warn
Heinrich Schuchardt6305db92017-09-12 09:57:45 +020095 --min-conf-desc-length=n set the min description length, if shorter, warn
Joe Hershberger05622192011-10-18 10:06:59 +000096 --root=PATH PATH to the kernel tree root
97 --no-summary suppress the per-file summary
98 --mailback only produce a report in case of warnings/errors
99 --summary-file include the filename in summary
100 --debug KEY=[0|1] turn on/off debugging of KEY, where KEY is one of
101 'values', 'possible', 'type', and 'attr' (default
102 is all off)
103 --test-only=WORD report only warnings/errors containing WORD
104 literally
Tom Rini6b9709d2014-02-27 08:27:28 -0500105 --fix EXPERIMENTAL - may create horrible results
106 If correctable single-line errors exist, create
107 "<inputfile>.EXPERIMENTAL-checkpatch-fixes"
108 with potential errors corrected to the preferred
109 checkpatch style
110 --fix-inplace EXPERIMENTAL - may create horrible results
111 Is the same as --fix, but overwrites the input
112 file. It's your fault if there's no backup or git
113 --ignore-perl-version override checking of perl version. expect
114 runtime errors.
Dan Murphyc10e0f52017-01-31 14:15:53 -0600115 --codespell Use the codespell dictionary for spelling/typos
Heinrich Schuchardt6305db92017-09-12 09:57:45 +0200116 (default:/usr/share/codespell/dictionary.txt)
Dan Murphyc10e0f52017-01-31 14:15:53 -0600117 --codespellfile Use this codespell dictionary
Heinrich Schuchardt6305db92017-09-12 09:57:45 +0200118 --typedefsfile Read additional types from this file
119 --color[=WHEN] Use colors 'always', 'never', or only when output
120 is a terminal ('auto'). Default is 'auto'.
Joe Hershberger05622192011-10-18 10:06:59 +0000121 -h, --help, --version display this help and exit
122
123When FILE is - read standard input.
124EOM
125
126 exit($exitcode);
127}
128
Heinrich Schuchardt6305db92017-09-12 09:57:45 +0200129sub uniq {
130 my %seen;
131 return grep { !$seen{$_}++ } @_;
132}
133
134sub list_types {
135 my ($exitcode) = @_;
136
137 my $count = 0;
138
139 local $/ = undef;
140
141 open(my $script, '<', abs_path($P)) or
142 die "$P: Can't read '$P' $!\n";
143
144 my $text = <$script>;
145 close($script);
146
147 my @types = ();
148 for ($text =~ /\b(?:(?:CHK|WARN|ERROR)\s*\(\s*"([^"]+)")/g) {
149 push (@types, $_);
150 }
151 @types = sort(uniq(@types));
152 print("#\tMessage type\n\n");
153 foreach my $type (@types) {
154 print(++$count . "\t" . $type . "\n");
155 }
156
157 exit($exitcode);
158}
159
Joe Hershberger05622192011-10-18 10:06:59 +0000160my $conf = which_conf($configuration_file);
161if (-f $conf) {
162 my @conf_args;
163 open(my $conffile, '<', "$conf")
164 or warn "$P: Can't find a readable $configuration_file file $!\n";
165
166 while (<$conffile>) {
167 my $line = $_;
168
169 $line =~ s/\s*\n?$//g;
170 $line =~ s/^\s*//g;
171 $line =~ s/\s+/ /g;
172
173 next if ($line =~ m/^\s*#/);
174 next if ($line =~ m/^\s*$/);
175
176 my @words = split(" ", $line);
177 foreach my $word (@words) {
178 last if ($word =~ m/^#/);
179 push (@conf_args, $word);
180 }
181 }
182 close($conffile);
183 unshift(@ARGV, @conf_args) if @conf_args;
184}
185
Heinrich Schuchardt6305db92017-09-12 09:57:45 +0200186# Perl's Getopt::Long allows options to take optional arguments after a space.
187# Prevent --color by itself from consuming other arguments
188foreach (@ARGV) {
189 if ($_ eq "--color" || $_ eq "-color") {
190 $_ = "--color=$color";
191 }
192}
193
Joe Hershberger05622192011-10-18 10:06:59 +0000194GetOptions(
195 'q|quiet+' => \$quiet,
196 'tree!' => \$tree,
197 'signoff!' => \$chk_signoff,
198 'patch!' => \$chk_patch,
199 'emacs!' => \$emacs,
200 'terse!' => \$terse,
Heinrich Schuchardt6305db92017-09-12 09:57:45 +0200201 'showfile!' => \$showfile,
Joe Hershberger05622192011-10-18 10:06:59 +0000202 'f|file!' => \$file,
Heinrich Schuchardt6305db92017-09-12 09:57:45 +0200203 'g|git!' => \$git,
Joe Hershberger05622192011-10-18 10:06:59 +0000204 'subjective!' => \$check,
205 'strict!' => \$check,
206 'ignore=s' => \@ignore,
Tom Rini6b9709d2014-02-27 08:27:28 -0500207 'types=s' => \@use,
Joe Hershberger05622192011-10-18 10:06:59 +0000208 'show-types!' => \$show_types,
Heinrich Schuchardt6305db92017-09-12 09:57:45 +0200209 'list-types!' => \$list_types,
Kim Phillipsd45a6ae2013-02-28 12:53:52 +0000210 'max-line-length=i' => \$max_line_length,
Heinrich Schuchardt6305db92017-09-12 09:57:45 +0200211 'min-conf-desc-length=i' => \$min_conf_desc_length,
Joe Hershberger05622192011-10-18 10:06:59 +0000212 'root=s' => \$root,
213 'summary!' => \$summary,
214 'mailback!' => \$mailback,
215 'summary-file!' => \$summary_file,
Tom Rini6b9709d2014-02-27 08:27:28 -0500216 'fix!' => \$fix,
217 'fix-inplace!' => \$fix_inplace,
218 'ignore-perl-version!' => \$ignore_perl_version,
Joe Hershberger05622192011-10-18 10:06:59 +0000219 'debug=s' => \%debug,
220 'test-only=s' => \$tst_only,
Heinrich Schuchardt6305db92017-09-12 09:57:45 +0200221 'codespell!' => \$codespell,
222 'codespellfile=s' => \$codespellfile,
223 'typedefsfile=s' => \$typedefsfile,
224 'color=s' => \$color,
225 'no-color' => \$color, #keep old behaviors of -nocolor
226 'nocolor' => \$color, #keep old behaviors of -nocolor
Joe Hershberger05622192011-10-18 10:06:59 +0000227 'h|help' => \$help,
228 'version' => \$help
229) or help(1);
230
231help(0) if ($help);
232
Heinrich Schuchardt6305db92017-09-12 09:57:45 +0200233list_types(0) if ($list_types);
234
Tom Rini6b9709d2014-02-27 08:27:28 -0500235$fix = 1 if ($fix_inplace);
Heinrich Schuchardt6305db92017-09-12 09:57:45 +0200236$check_orig = $check;
Tom Rini6b9709d2014-02-27 08:27:28 -0500237
Joe Hershberger05622192011-10-18 10:06:59 +0000238my $exit = 0;
239
Tom Rini6b9709d2014-02-27 08:27:28 -0500240if ($^V && $^V lt $minimum_perl_version) {
241 printf "$P: requires at least perl version %vd\n", $minimum_perl_version;
242 if (!$ignore_perl_version) {
243 exit(1);
244 }
245}
246
Heinrich Schuchardt6305db92017-09-12 09:57:45 +0200247#if no filenames are given, push '-' to read patch from stdin
Joe Hershberger05622192011-10-18 10:06:59 +0000248if ($#ARGV < 0) {
Heinrich Schuchardt6305db92017-09-12 09:57:45 +0200249 push(@ARGV, '-');
250}
251
252if ($color =~ /^[01]$/) {
253 $color = !$color;
254} elsif ($color =~ /^always$/i) {
255 $color = 1;
256} elsif ($color =~ /^never$/i) {
257 $color = 0;
258} elsif ($color =~ /^auto$/i) {
259 $color = (-t STDOUT);
260} else {
261 die "Invalid color mode: $color\n";
Joe Hershberger05622192011-10-18 10:06:59 +0000262}
263
Tom Rini6b9709d2014-02-27 08:27:28 -0500264sub hash_save_array_words {
265 my ($hashRef, $arrayRef) = @_;
Joe Hershberger05622192011-10-18 10:06:59 +0000266
Tom Rini6b9709d2014-02-27 08:27:28 -0500267 my @array = split(/,/, join(',', @$arrayRef));
268 foreach my $word (@array) {
269 $word =~ s/\s*\n?$//g;
270 $word =~ s/^\s*//g;
271 $word =~ s/\s+/ /g;
272 $word =~ tr/[a-z]/[A-Z]/;
Joe Hershberger05622192011-10-18 10:06:59 +0000273
Tom Rini6b9709d2014-02-27 08:27:28 -0500274 next if ($word =~ m/^\s*#/);
275 next if ($word =~ m/^\s*$/);
276
277 $hashRef->{$word}++;
278 }
Joe Hershberger05622192011-10-18 10:06:59 +0000279}
280
Tom Rini6b9709d2014-02-27 08:27:28 -0500281sub hash_show_words {
282 my ($hashRef, $prefix) = @_;
283
Heinrich Schuchardt6305db92017-09-12 09:57:45 +0200284 if (keys %$hashRef) {
285 print "\nNOTE: $prefix message types:";
Tom Rini6b9709d2014-02-27 08:27:28 -0500286 foreach my $word (sort keys %$hashRef) {
287 print " $word";
288 }
Heinrich Schuchardt6305db92017-09-12 09:57:45 +0200289 print "\n";
Tom Rini6b9709d2014-02-27 08:27:28 -0500290 }
291}
292
293hash_save_array_words(\%ignore_type, \@ignore);
294hash_save_array_words(\%use_type, \@use);
295
Joe Hershberger05622192011-10-18 10:06:59 +0000296my $dbg_values = 0;
297my $dbg_possible = 0;
298my $dbg_type = 0;
299my $dbg_attr = 0;
300for my $key (keys %debug) {
301 ## no critic
302 eval "\${dbg_$key} = '$debug{$key}';";
303 die "$@" if ($@);
304}
305
306my $rpt_cleaners = 0;
307
308if ($terse) {
309 $emacs = 1;
310 $quiet++;
311}
312
313if ($tree) {
314 if (defined $root) {
315 if (!top_of_kernel_tree($root)) {
316 die "$P: $root: --root does not point at a valid tree\n";
317 }
318 } else {
319 if (top_of_kernel_tree('.')) {
320 $root = '.';
321 } elsif ($0 =~ m@(.*)/scripts/[^/]*$@ &&
322 top_of_kernel_tree($1)) {
323 $root = $1;
324 }
325 }
326
327 if (!defined $root) {
328 print "Must be run from the top-level dir. of a kernel tree\n";
329 exit(2);
330 }
331}
332
333my $emitted_corrupt = 0;
334
335our $Ident = qr{
336 [A-Za-z_][A-Za-z\d_]*
337 (?:\s*\#\#\s*[A-Za-z_][A-Za-z\d_]*)*
338 }x;
339our $Storage = qr{extern|static|asmlinkage};
340our $Sparse = qr{
341 __user|
342 __kernel|
343 __force|
344 __iomem|
345 __must_check|
346 __init_refok|
347 __kprobes|
348 __ref|
Heinrich Schuchardt6305db92017-09-12 09:57:45 +0200349 __rcu|
350 __private
Joe Hershberger05622192011-10-18 10:06:59 +0000351 }x;
Tom Rini6b9709d2014-02-27 08:27:28 -0500352our $InitAttributePrefix = qr{__(?:mem|cpu|dev|net_|)};
353our $InitAttributeData = qr{$InitAttributePrefix(?:initdata\b)};
354our $InitAttributeConst = qr{$InitAttributePrefix(?:initconst\b)};
355our $InitAttributeInit = qr{$InitAttributePrefix(?:init\b)};
356our $InitAttribute = qr{$InitAttributeData|$InitAttributeConst|$InitAttributeInit};
Joe Hershberger05622192011-10-18 10:06:59 +0000357
358# Notes to $Attribute:
359# We need \b after 'init' otherwise 'initconst' will cause a false positive in a check
360our $Attribute = qr{
361 const|
362 __percpu|
363 __nocast|
364 __safe|
Heinrich Schuchardt6305db92017-09-12 09:57:45 +0200365 __bitwise|
Joe Hershberger05622192011-10-18 10:06:59 +0000366 __packed__|
367 __packed2__|
368 __naked|
369 __maybe_unused|
370 __always_unused|
371 __noreturn|
372 __used|
373 __cold|
Heinrich Schuchardt6305db92017-09-12 09:57:45 +0200374 __pure|
Joe Hershberger05622192011-10-18 10:06:59 +0000375 __noclone|
376 __deprecated|
377 __read_mostly|
378 __kprobes|
Tom Rini6b9709d2014-02-27 08:27:28 -0500379 $InitAttribute|
Joe Hershberger05622192011-10-18 10:06:59 +0000380 ____cacheline_aligned|
381 ____cacheline_aligned_in_smp|
382 ____cacheline_internodealigned_in_smp|
383 __weak
384 }x;
385our $Modifier;
Heinrich Schuchardt6305db92017-09-12 09:57:45 +0200386our $Inline = qr{inline|__always_inline|noinline|__inline|__inline__};
Joe Hershberger05622192011-10-18 10:06:59 +0000387our $Member = qr{->$Ident|\.$Ident|\[[^]]*\]};
388our $Lval = qr{$Ident(?:$Member)*};
389
Tom Rini6b9709d2014-02-27 08:27:28 -0500390our $Int_type = qr{(?i)llu|ull|ll|lu|ul|l|u};
391our $Binary = qr{(?i)0b[01]+$Int_type?};
392our $Hex = qr{(?i)0x[0-9a-f]+$Int_type?};
393our $Int = qr{[0-9]+$Int_type?};
Heinrich Schuchardt6305db92017-09-12 09:57:45 +0200394our $Octal = qr{0[0-7]+$Int_type?};
395our $String = qr{"[X\t]*"};
Kim Phillipsd45a6ae2013-02-28 12:53:52 +0000396our $Float_hex = qr{(?i)0x[0-9a-f]+p-?[0-9]+[fl]?};
397our $Float_dec = qr{(?i)(?:[0-9]+\.[0-9]*|[0-9]*\.[0-9]+)(?:e-?[0-9]+)?[fl]?};
398our $Float_int = qr{(?i)[0-9]+e-?[0-9]+[fl]?};
399our $Float = qr{$Float_hex|$Float_dec|$Float_int};
Heinrich Schuchardt6305db92017-09-12 09:57:45 +0200400our $Constant = qr{$Float|$Binary|$Octal|$Hex|$Int};
Kim Phillipsd45a6ae2013-02-28 12:53:52 +0000401our $Assignment = qr{\*\=|/=|%=|\+=|-=|<<=|>>=|&=|\^=|\|=|=};
Heinrich Schuchardt6305db92017-09-12 09:57:45 +0200402our $Compare = qr{<=|>=|==|!=|<|(?<!-)>};
Tom Rini6b9709d2014-02-27 08:27:28 -0500403our $Arithmetic = qr{\+|-|\*|\/|%};
Joe Hershberger05622192011-10-18 10:06:59 +0000404our $Operators = qr{
405 <=|>=|==|!=|
406 =>|->|<<|>>|<|>|!|~|
Tom Rini6b9709d2014-02-27 08:27:28 -0500407 &&|\|\||,|\^|\+\+|--|&|\||$Arithmetic
Joe Hershberger05622192011-10-18 10:06:59 +0000408 }x;
409
Heinrich Schuchardt6305db92017-09-12 09:57:45 +0200410our $c90_Keywords = qr{do|for|while|if|else|return|goto|continue|switch|default|case|break}x;
411
412our $BasicType;
Joe Hershberger05622192011-10-18 10:06:59 +0000413our $NonptrType;
Heinrich Schuchardt6305db92017-09-12 09:57:45 +0200414our $NonptrTypeMisordered;
Tom Rini6b9709d2014-02-27 08:27:28 -0500415our $NonptrTypeWithAttr;
Joe Hershberger05622192011-10-18 10:06:59 +0000416our $Type;
Heinrich Schuchardt6305db92017-09-12 09:57:45 +0200417our $TypeMisordered;
Joe Hershberger05622192011-10-18 10:06:59 +0000418our $Declare;
Heinrich Schuchardt6305db92017-09-12 09:57:45 +0200419our $DeclareMisordered;
Joe Hershberger05622192011-10-18 10:06:59 +0000420
Kim Phillipsd45a6ae2013-02-28 12:53:52 +0000421our $NON_ASCII_UTF8 = qr{
422 [\xC2-\xDF][\x80-\xBF] # non-overlong 2-byte
Joe Hershberger05622192011-10-18 10:06:59 +0000423 | \xE0[\xA0-\xBF][\x80-\xBF] # excluding overlongs
424 | [\xE1-\xEC\xEE\xEF][\x80-\xBF]{2} # straight 3-byte
425 | \xED[\x80-\x9F][\x80-\xBF] # excluding surrogates
426 | \xF0[\x90-\xBF][\x80-\xBF]{2} # planes 1-3
427 | [\xF1-\xF3][\x80-\xBF]{3} # planes 4-15
428 | \xF4[\x80-\x8F][\x80-\xBF]{2} # plane 16
429}x;
430
Kim Phillipsd45a6ae2013-02-28 12:53:52 +0000431our $UTF8 = qr{
432 [\x09\x0A\x0D\x20-\x7E] # ASCII
433 | $NON_ASCII_UTF8
434}x;
435
Heinrich Schuchardt6305db92017-09-12 09:57:45 +0200436our $typeC99Typedefs = qr{(?:__)?(?:[us]_?)?int_?(?:8|16|32|64)_t};
437our $typeOtherOSTypedefs = qr{(?x:
438 u_(?:char|short|int|long) | # bsd
439 u(?:nchar|short|int|long) # sysv
440)};
441our $typeKernelTypedefs = qr{(?x:
Joe Hershberger05622192011-10-18 10:06:59 +0000442 (?:__)?(?:u|s|be|le)(?:8|16|32|64)|
443 atomic_t
444)};
Heinrich Schuchardt6305db92017-09-12 09:57:45 +0200445our $typeTypedefs = qr{(?x:
446 $typeC99Typedefs\b|
447 $typeOtherOSTypedefs\b|
448 $typeKernelTypedefs\b
449)};
450
451our $zero_initializer = qr{(?:(?:0[xX])?0+$Int_type?|NULL|false)\b};
Joe Hershberger05622192011-10-18 10:06:59 +0000452
453our $logFunctions = qr{(?x:
Heinrich Schuchardt6305db92017-09-12 09:57:45 +0200454 printk(?:_ratelimited|_once|_deferred_once|_deferred|)|
Tom Rini6b9709d2014-02-27 08:27:28 -0500455 (?:[a-z0-9]+_){1,2}(?:printk|emerg|alert|crit|err|warning|warn|notice|info|debug|dbg|vdbg|devel|cont|WARN)(?:_ratelimited|_once|)|
Joe Hershberger05622192011-10-18 10:06:59 +0000456 WARN(?:_RATELIMIT|_ONCE|)|
457 panic|
Tom Rini6b9709d2014-02-27 08:27:28 -0500458 MODULE_[A-Z_]+|
459 seq_vprintf|seq_printf|seq_puts
Joe Hershberger05622192011-10-18 10:06:59 +0000460)};
461
462our $signature_tags = qr{(?xi:
463 Signed-off-by:|
464 Acked-by:|
465 Tested-by:|
466 Reviewed-by:|
467 Reported-by:|
Tom Rini6b9709d2014-02-27 08:27:28 -0500468 Suggested-by:|
Joe Hershberger05622192011-10-18 10:06:59 +0000469 To:|
470 Cc:
471)};
472
Heinrich Schuchardt6305db92017-09-12 09:57:45 +0200473our @typeListMisordered = (
474 qr{char\s+(?:un)?signed},
475 qr{int\s+(?:(?:un)?signed\s+)?short\s},
476 qr{int\s+short(?:\s+(?:un)?signed)},
477 qr{short\s+int(?:\s+(?:un)?signed)},
478 qr{(?:un)?signed\s+int\s+short},
479 qr{short\s+(?:un)?signed},
480 qr{long\s+int\s+(?:un)?signed},
481 qr{int\s+long\s+(?:un)?signed},
482 qr{long\s+(?:un)?signed\s+int},
483 qr{int\s+(?:un)?signed\s+long},
484 qr{int\s+(?:un)?signed},
485 qr{int\s+long\s+long\s+(?:un)?signed},
486 qr{long\s+long\s+int\s+(?:un)?signed},
487 qr{long\s+long\s+(?:un)?signed\s+int},
488 qr{long\s+long\s+(?:un)?signed},
489 qr{long\s+(?:un)?signed},
490);
491
Joe Hershberger05622192011-10-18 10:06:59 +0000492our @typeList = (
493 qr{void},
Heinrich Schuchardt6305db92017-09-12 09:57:45 +0200494 qr{(?:(?:un)?signed\s+)?char},
495 qr{(?:(?:un)?signed\s+)?short\s+int},
496 qr{(?:(?:un)?signed\s+)?short},
497 qr{(?:(?:un)?signed\s+)?int},
498 qr{(?:(?:un)?signed\s+)?long\s+int},
499 qr{(?:(?:un)?signed\s+)?long\s+long\s+int},
500 qr{(?:(?:un)?signed\s+)?long\s+long},
501 qr{(?:(?:un)?signed\s+)?long},
502 qr{(?:un)?signed},
Joe Hershberger05622192011-10-18 10:06:59 +0000503 qr{float},
504 qr{double},
505 qr{bool},
506 qr{struct\s+$Ident},
507 qr{union\s+$Ident},
508 qr{enum\s+$Ident},
509 qr{${Ident}_t},
510 qr{${Ident}_handler},
511 qr{${Ident}_handler_fn},
Heinrich Schuchardt6305db92017-09-12 09:57:45 +0200512 @typeListMisordered,
Joe Hershberger05622192011-10-18 10:06:59 +0000513);
Heinrich Schuchardt6305db92017-09-12 09:57:45 +0200514
515our $C90_int_types = qr{(?x:
516 long\s+long\s+int\s+(?:un)?signed|
517 long\s+long\s+(?:un)?signed\s+int|
518 long\s+long\s+(?:un)?signed|
519 (?:(?:un)?signed\s+)?long\s+long\s+int|
520 (?:(?:un)?signed\s+)?long\s+long|
521 int\s+long\s+long\s+(?:un)?signed|
522 int\s+(?:(?:un)?signed\s+)?long\s+long|
523
524 long\s+int\s+(?:un)?signed|
525 long\s+(?:un)?signed\s+int|
526 long\s+(?:un)?signed|
527 (?:(?:un)?signed\s+)?long\s+int|
528 (?:(?:un)?signed\s+)?long|
529 int\s+long\s+(?:un)?signed|
530 int\s+(?:(?:un)?signed\s+)?long|
531
532 int\s+(?:un)?signed|
533 (?:(?:un)?signed\s+)?int
534)};
535
536our @typeListFile = ();
Tom Rini6b9709d2014-02-27 08:27:28 -0500537our @typeListWithAttr = (
538 @typeList,
539 qr{struct\s+$InitAttribute\s+$Ident},
540 qr{union\s+$InitAttribute\s+$Ident},
541);
542
Joe Hershberger05622192011-10-18 10:06:59 +0000543our @modifierList = (
544 qr{fastcall},
545);
Heinrich Schuchardt6305db92017-09-12 09:57:45 +0200546our @modifierListFile = ();
547
548our @mode_permission_funcs = (
549 ["module_param", 3],
550 ["module_param_(?:array|named|string)", 4],
551 ["module_param_array_named", 5],
552 ["debugfs_create_(?:file|u8|u16|u32|u64|x8|x16|x32|x64|size_t|atomic_t|bool|blob|regset32|u32_array)", 2],
553 ["proc_create(?:_data|)", 2],
554 ["(?:CLASS|DEVICE|SENSOR|SENSOR_DEVICE|IIO_DEVICE)_ATTR", 2],
555 ["IIO_DEV_ATTR_[A-Z_]+", 1],
556 ["SENSOR_(?:DEVICE_|)ATTR_2", 2],
557 ["SENSOR_TEMPLATE(?:_2|)", 3],
558 ["__ATTR", 2],
559);
560
561#Create a search pattern for all these functions to speed up a loop below
562our $mode_perms_search = "";
563foreach my $entry (@mode_permission_funcs) {
564 $mode_perms_search .= '|' if ($mode_perms_search ne "");
565 $mode_perms_search .= $entry->[0];
566}
567
568our $mode_perms_world_writable = qr{
569 S_IWUGO |
570 S_IWOTH |
571 S_IRWXUGO |
572 S_IALLUGO |
573 0[0-7][0-7][2367]
574}x;
575
576our %mode_permission_string_types = (
577 "S_IRWXU" => 0700,
578 "S_IRUSR" => 0400,
579 "S_IWUSR" => 0200,
580 "S_IXUSR" => 0100,
581 "S_IRWXG" => 0070,
582 "S_IRGRP" => 0040,
583 "S_IWGRP" => 0020,
584 "S_IXGRP" => 0010,
585 "S_IRWXO" => 0007,
586 "S_IROTH" => 0004,
587 "S_IWOTH" => 0002,
588 "S_IXOTH" => 0001,
589 "S_IRWXUGO" => 0777,
590 "S_IRUGO" => 0444,
591 "S_IWUGO" => 0222,
592 "S_IXUGO" => 0111,
593);
594
595#Create a search pattern for all these strings to speed up a loop below
596our $mode_perms_string_search = "";
597foreach my $entry (keys %mode_permission_string_types) {
598 $mode_perms_string_search .= '|' if ($mode_perms_string_search ne "");
599 $mode_perms_string_search .= $entry;
600}
Joe Hershberger05622192011-10-18 10:06:59 +0000601
602our $allowed_asm_includes = qr{(?x:
603 irq|
Heinrich Schuchardt6305db92017-09-12 09:57:45 +0200604 memory|
605 time|
606 reboot
Joe Hershberger05622192011-10-18 10:06:59 +0000607)};
608# memory.h: ARM has a custom one
609
Dan Murphyc10e0f52017-01-31 14:15:53 -0600610# Load common spelling mistakes and build regular expression list.
611my $misspellings;
612my %spelling_fix;
613
614if (open(my $spelling, '<', $spelling_file)) {
615 while (<$spelling>) {
616 my $line = $_;
617
618 $line =~ s/\s*\n?$//g;
619 $line =~ s/^\s*//g;
620
621 next if ($line =~ m/^\s*#/);
622 next if ($line =~ m/^\s*$/);
623
624 my ($suspect, $fix) = split(/\|\|/, $line);
625
626 $spelling_fix{$suspect} = $fix;
627 }
628 close($spelling);
629} else {
630 warn "No typos will be found - file '$spelling_file': $!\n";
631}
632
633if ($codespell) {
634 if (open(my $spelling, '<', $codespellfile)) {
635 while (<$spelling>) {
636 my $line = $_;
637
638 $line =~ s/\s*\n?$//g;
639 $line =~ s/^\s*//g;
640
641 next if ($line =~ m/^\s*#/);
642 next if ($line =~ m/^\s*$/);
643 next if ($line =~ m/, disabled/i);
644
645 $line =~ s/,.*$//;
646
647 my ($suspect, $fix) = split(/->/, $line);
648
649 $spelling_fix{$suspect} = $fix;
650 }
651 close($spelling);
652 } else {
653 warn "No codespell typos will be found - file '$codespellfile': $!\n";
654 }
655}
656
657$misspellings = join("|", sort keys %spelling_fix) if keys %spelling_fix;
658
Heinrich Schuchardt6305db92017-09-12 09:57:45 +0200659sub read_words {
660 my ($wordsRef, $file) = @_;
661
662 if (open(my $words, '<', $file)) {
663 while (<$words>) {
664 my $line = $_;
665
666 $line =~ s/\s*\n?$//g;
667 $line =~ s/^\s*//g;
668
669 next if ($line =~ m/^\s*#/);
670 next if ($line =~ m/^\s*$/);
671 if ($line =~ /\s/) {
672 print("$file: '$line' invalid - ignored\n");
673 next;
674 }
675
676 $$wordsRef .= '|' if ($$wordsRef ne "");
677 $$wordsRef .= $line;
678 }
679 close($file);
680 return 1;
681 }
682
683 return 0;
684}
685
686my $const_structs = "";
687read_words(\$const_structs, $conststructsfile)
688 or warn "No structs that should be const will be found - file '$conststructsfile': $!\n";
689
690my $typeOtherTypedefs = "";
691if (length($typedefsfile)) {
692 read_words(\$typeOtherTypedefs, $typedefsfile)
693 or warn "No additional types will be considered - file '$typedefsfile': $!\n";
694}
695$typeTypedefs .= '|' . $typeOtherTypedefs if ($typeOtherTypedefs ne "");
Dan Murphyc10e0f52017-01-31 14:15:53 -0600696
Joe Hershberger05622192011-10-18 10:06:59 +0000697sub build_types {
Heinrich Schuchardt6305db92017-09-12 09:57:45 +0200698 my $mods = "(?x: \n" . join("|\n ", (@modifierList, @modifierListFile)) . "\n)";
699 my $all = "(?x: \n" . join("|\n ", (@typeList, @typeListFile)) . "\n)";
700 my $Misordered = "(?x: \n" . join("|\n ", @typeListMisordered) . "\n)";
Tom Rini6b9709d2014-02-27 08:27:28 -0500701 my $allWithAttr = "(?x: \n" . join("|\n ", @typeListWithAttr) . "\n)";
Joe Hershberger05622192011-10-18 10:06:59 +0000702 $Modifier = qr{(?:$Attribute|$Sparse|$mods)};
Heinrich Schuchardt6305db92017-09-12 09:57:45 +0200703 $BasicType = qr{
704 (?:$typeTypedefs\b)|
705 (?:${all}\b)
706 }x;
Joe Hershberger05622192011-10-18 10:06:59 +0000707 $NonptrType = qr{
708 (?:$Modifier\s+|const\s+)*
709 (?:
Kim Phillipsd45a6ae2013-02-28 12:53:52 +0000710 (?:typeof|__typeof__)\s*\([^\)]*\)|
Joe Hershberger05622192011-10-18 10:06:59 +0000711 (?:$typeTypedefs\b)|
712 (?:${all}\b)
713 )
714 (?:\s+$Modifier|\s+const)*
715 }x;
Heinrich Schuchardt6305db92017-09-12 09:57:45 +0200716 $NonptrTypeMisordered = qr{
717 (?:$Modifier\s+|const\s+)*
718 (?:
719 (?:${Misordered}\b)
720 )
721 (?:\s+$Modifier|\s+const)*
722 }x;
Tom Rini6b9709d2014-02-27 08:27:28 -0500723 $NonptrTypeWithAttr = qr{
724 (?:$Modifier\s+|const\s+)*
725 (?:
726 (?:typeof|__typeof__)\s*\([^\)]*\)|
727 (?:$typeTypedefs\b)|
728 (?:${allWithAttr}\b)
729 )
730 (?:\s+$Modifier|\s+const)*
731 }x;
Joe Hershberger05622192011-10-18 10:06:59 +0000732 $Type = qr{
733 $NonptrType
Heinrich Schuchardt6305db92017-09-12 09:57:45 +0200734 (?:(?:\s|\*|\[\])+\s*const|(?:\s|\*\s*(?:const\s*)?|\[\])+|(?:\s*\[\s*\])+)?
Joe Hershberger05622192011-10-18 10:06:59 +0000735 (?:\s+$Inline|\s+$Modifier)*
736 }x;
Heinrich Schuchardt6305db92017-09-12 09:57:45 +0200737 $TypeMisordered = qr{
738 $NonptrTypeMisordered
739 (?:(?:\s|\*|\[\])+\s*const|(?:\s|\*\s*(?:const\s*)?|\[\])+|(?:\s*\[\s*\])+)?
740 (?:\s+$Inline|\s+$Modifier)*
741 }x;
742 $Declare = qr{(?:$Storage\s+(?:$Inline\s+)?)?$Type};
743 $DeclareMisordered = qr{(?:$Storage\s+(?:$Inline\s+)?)?$TypeMisordered};
Joe Hershberger05622192011-10-18 10:06:59 +0000744}
745build_types();
746
Joe Hershberger05622192011-10-18 10:06:59 +0000747our $Typecast = qr{\s*(\(\s*$NonptrType\s*\)){0,1}\s*};
Kim Phillipsd45a6ae2013-02-28 12:53:52 +0000748
749# Using $balanced_parens, $LvalOrFunc, or $FuncArg
750# requires at least perl version v5.10.0
751# Any use must be runtime checked with $^V
752
753our $balanced_parens = qr/(\((?:[^\(\)]++|(?-1))*\))/;
Heinrich Schuchardt6305db92017-09-12 09:57:45 +0200754our $LvalOrFunc = qr{((?:[\&\*]\s*)?$Lval)\s*($balanced_parens{0,1})\s*};
755our $FuncArg = qr{$Typecast{0,1}($LvalOrFunc|$Constant|$String)};
756
757our $declaration_macros = qr{(?x:
758 (?:$Storage\s+)?(?:[A-Z_][A-Z0-9]*_){0,2}(?:DEFINE|DECLARE)(?:_[A-Z0-9]+){1,6}\s*\(|
759 (?:$Storage\s+)?[HLP]?LIST_HEAD\s*\(|
760 (?:$Storage\s+)?${Type}\s+uninitialized_var\s*\(
761)};
Joe Hershberger05622192011-10-18 10:06:59 +0000762
763sub deparenthesize {
764 my ($string) = @_;
765 return "" if (!defined($string));
Heinrich Schuchardt6305db92017-09-12 09:57:45 +0200766
767 while ($string =~ /^\s*\(.*\)\s*$/) {
768 $string =~ s@^\s*\(\s*@@;
769 $string =~ s@\s*\)\s*$@@;
770 }
771
Joe Hershberger05622192011-10-18 10:06:59 +0000772 $string =~ s@\s+@ @g;
Heinrich Schuchardt6305db92017-09-12 09:57:45 +0200773
Joe Hershberger05622192011-10-18 10:06:59 +0000774 return $string;
775}
776
Tom Rini6b9709d2014-02-27 08:27:28 -0500777sub seed_camelcase_file {
778 my ($file) = @_;
779
780 return if (!(-f $file));
781
782 local $/;
783
784 open(my $include_file, '<', "$file")
785 or warn "$P: Can't read '$file' $!\n";
786 my $text = <$include_file>;
787 close($include_file);
788
789 my @lines = split('\n', $text);
790
791 foreach my $line (@lines) {
792 next if ($line !~ /(?:[A-Z][a-z]|[a-z][A-Z])/);
793 if ($line =~ /^[ \t]*(?:#[ \t]*define|typedef\s+$Type)\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)/) {
794 $camelcase{$1} = 1;
795 } elsif ($line =~ /^\s*$Declare\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)\s*[\(\[,;]/) {
796 $camelcase{$1} = 1;
797 } elsif ($line =~ /^\s*(?:union|struct|enum)\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)\s*[;\{]/) {
798 $camelcase{$1} = 1;
799 }
800 }
801}
802
Heinrich Schuchardt6305db92017-09-12 09:57:45 +0200803sub is_maintained_obsolete {
804 my ($filename) = @_;
805
806 return 0 if (!$tree || !(-e "$root/scripts/get_maintainer.pl"));
807
808 my $status = `perl $root/scripts/get_maintainer.pl --status --nom --nol --nogit --nogit-fallback -f $filename 2>&1`;
809
810 return $status =~ /obsolete/i;
811}
812
Tom Rini6b9709d2014-02-27 08:27:28 -0500813my $camelcase_seeded = 0;
814sub seed_camelcase_includes {
815 return if ($camelcase_seeded);
816
817 my $files;
818 my $camelcase_cache = "";
819 my @include_files = ();
820
821 $camelcase_seeded = 1;
822
823 if (-e ".git") {
824 my $git_last_include_commit = `git log --no-merges --pretty=format:"%h%n" -1 -- include`;
825 chomp $git_last_include_commit;
826 $camelcase_cache = ".checkpatch-camelcase.git.$git_last_include_commit";
827 } else {
828 my $last_mod_date = 0;
829 $files = `find $root/include -name "*.h"`;
830 @include_files = split('\n', $files);
831 foreach my $file (@include_files) {
832 my $date = POSIX::strftime("%Y%m%d%H%M",
833 localtime((stat $file)[9]));
834 $last_mod_date = $date if ($last_mod_date < $date);
835 }
836 $camelcase_cache = ".checkpatch-camelcase.date.$last_mod_date";
837 }
838
839 if ($camelcase_cache ne "" && -f $camelcase_cache) {
840 open(my $camelcase_file, '<', "$camelcase_cache")
841 or warn "$P: Can't read '$camelcase_cache' $!\n";
842 while (<$camelcase_file>) {
843 chomp;
844 $camelcase{$_} = 1;
845 }
846 close($camelcase_file);
847
848 return;
849 }
850
851 if (-e ".git") {
852 $files = `git ls-files "include/*.h"`;
853 @include_files = split('\n', $files);
854 }
855
856 foreach my $file (@include_files) {
857 seed_camelcase_file($file);
858 }
859
860 if ($camelcase_cache ne "") {
861 unlink glob ".checkpatch-camelcase.*";
862 open(my $camelcase_file, '>', "$camelcase_cache")
863 or warn "$P: Can't write '$camelcase_cache' $!\n";
864 foreach (sort { lc($a) cmp lc($b) } keys(%camelcase)) {
865 print $camelcase_file ("$_\n");
866 }
867 close($camelcase_file);
868 }
869}
870
Heinrich Schuchardt6305db92017-09-12 09:57:45 +0200871sub git_commit_info {
872 my ($commit, $id, $desc) = @_;
873
874 return ($id, $desc) if ((which("git") eq "") || !(-e ".git"));
875
876 my $output = `git log --no-color --format='%H %s' -1 $commit 2>&1`;
877 $output =~ s/^\s*//gm;
878 my @lines = split("\n", $output);
879
880 return ($id, $desc) if ($#lines < 0);
881
882 if ($lines[0] =~ /^error: short SHA1 $commit is ambiguous\./) {
883# Maybe one day convert this block of bash into something that returns
884# all matching commit ids, but it's very slow...
885#
886# echo "checking commits $1..."
887# git rev-list --remotes | grep -i "^$1" |
888# while read line ; do
889# git log --format='%H %s' -1 $line |
890# echo "commit $(cut -c 1-12,41-)"
891# done
892 } elsif ($lines[0] =~ /^fatal: ambiguous argument '$commit': unknown revision or path not in the working tree\./) {
893 $id = undef;
894 } else {
895 $id = substr($lines[0], 0, 12);
896 $desc = substr($lines[0], 41);
897 }
898
899 return ($id, $desc);
900}
901
Joe Hershberger05622192011-10-18 10:06:59 +0000902$chk_signoff = 0 if ($file);
903
Joe Hershberger05622192011-10-18 10:06:59 +0000904my @rawlines = ();
905my @lines = ();
Tom Rini6b9709d2014-02-27 08:27:28 -0500906my @fixed = ();
Heinrich Schuchardt6305db92017-09-12 09:57:45 +0200907my @fixed_inserted = ();
908my @fixed_deleted = ();
Dan Murphyc10e0f52017-01-31 14:15:53 -0600909my $fixlinenr = -1;
910
Heinrich Schuchardt6305db92017-09-12 09:57:45 +0200911# If input is git commits, extract all commits from the commit expressions.
912# For example, HEAD-3 means we need check 'HEAD, HEAD~1, HEAD~2'.
913die "$P: No git repository found\n" if ($git && !-e ".git");
914
915if ($git) {
916 my @commits = ();
917 foreach my $commit_expr (@ARGV) {
918 my $git_range;
919 if ($commit_expr =~ m/^(.*)-(\d+)$/) {
920 $git_range = "-$2 $1";
921 } elsif ($commit_expr =~ m/\.\./) {
922 $git_range = "$commit_expr";
923 } else {
924 $git_range = "-1 $commit_expr";
925 }
926 my $lines = `git log --no-color --no-merges --pretty=format:'%H %s' $git_range`;
927 foreach my $line (split(/\n/, $lines)) {
928 $line =~ /^([0-9a-fA-F]{40,40}) (.*)$/;
929 next if (!defined($1) || !defined($2));
930 my $sha1 = $1;
931 my $subject = $2;
932 unshift(@commits, $sha1);
933 $git_commits{$sha1} = $subject;
934 }
935 }
936 die "$P: no git commits after extraction!\n" if (@commits == 0);
937 @ARGV = @commits;
938}
939
940my $vname;
Joe Hershberger05622192011-10-18 10:06:59 +0000941for my $filename (@ARGV) {
942 my $FILE;
Heinrich Schuchardt6305db92017-09-12 09:57:45 +0200943 if ($git) {
944 open($FILE, '-|', "git format-patch -M --stdout -1 $filename") ||
945 die "$P: $filename: git format-patch failed - $!\n";
946 } elsif ($file) {
Joe Hershberger05622192011-10-18 10:06:59 +0000947 open($FILE, '-|', "diff -u /dev/null $filename") ||
948 die "$P: $filename: diff failed - $!\n";
949 } elsif ($filename eq '-') {
950 open($FILE, '<&STDIN');
951 } else {
952 open($FILE, '<', "$filename") ||
953 die "$P: $filename: open failed - $!\n";
954 }
955 if ($filename eq '-') {
956 $vname = 'Your patch';
Heinrich Schuchardt6305db92017-09-12 09:57:45 +0200957 } elsif ($git) {
958 $vname = "Commit " . substr($filename, 0, 12) . ' ("' . $git_commits{$filename} . '")';
Joe Hershberger05622192011-10-18 10:06:59 +0000959 } else {
960 $vname = $filename;
961 }
962 while (<$FILE>) {
963 chomp;
964 push(@rawlines, $_);
965 }
966 close($FILE);
Heinrich Schuchardt6305db92017-09-12 09:57:45 +0200967
968 if ($#ARGV > 0 && $quiet == 0) {
969 print '-' x length($vname) . "\n";
970 print "$vname\n";
971 print '-' x length($vname) . "\n";
972 }
973
Joe Hershberger05622192011-10-18 10:06:59 +0000974 if (!process($filename)) {
975 $exit = 1;
976 }
977 @rawlines = ();
978 @lines = ();
Tom Rini6b9709d2014-02-27 08:27:28 -0500979 @fixed = ();
Heinrich Schuchardt6305db92017-09-12 09:57:45 +0200980 @fixed_inserted = ();
981 @fixed_deleted = ();
982 $fixlinenr = -1;
983 @modifierListFile = ();
984 @typeListFile = ();
985 build_types();
986}
987
988if (!$quiet) {
989 hash_show_words(\%use_type, "Used");
990 hash_show_words(\%ignore_type, "Ignored");
991
992 if ($^V lt 5.10.0) {
993 print << "EOM"
994
995NOTE: perl $^V is not modern enough to detect all possible issues.
996 An upgrade to at least perl v5.10.0 is suggested.
997EOM
998 }
999 if ($exit) {
1000 print << "EOM"
1001
1002NOTE: If any of the errors are false positives, please report
1003 them to the maintainer, see CHECKPATCH in MAINTAINERS.
1004EOM
1005 }
Joe Hershberger05622192011-10-18 10:06:59 +00001006}
1007
1008exit($exit);
1009
1010sub top_of_kernel_tree {
1011 my ($root) = @_;
1012
1013 my @tree_check = (
Tom Rini6b9709d2014-02-27 08:27:28 -05001014 "COPYING", "CREDITS", "Kbuild", "MAINTAINERS", "Makefile",
Joe Hershberger05622192011-10-18 10:06:59 +00001015 "README", "Documentation", "arch", "include", "drivers",
1016 "fs", "init", "ipc", "kernel", "lib", "scripts",
1017 );
1018
1019 foreach my $check (@tree_check) {
1020 if (! -e $root . '/' . $check) {
1021 return 0;
1022 }
1023 }
1024 return 1;
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00001025}
Joe Hershberger05622192011-10-18 10:06:59 +00001026
1027sub parse_email {
1028 my ($formatted_email) = @_;
1029
1030 my $name = "";
1031 my $address = "";
1032 my $comment = "";
1033
1034 if ($formatted_email =~ /^(.*)<(\S+\@\S+)>(.*)$/) {
1035 $name = $1;
1036 $address = $2;
1037 $comment = $3 if defined $3;
1038 } elsif ($formatted_email =~ /^\s*<(\S+\@\S+)>(.*)$/) {
1039 $address = $1;
1040 $comment = $2 if defined $2;
1041 } elsif ($formatted_email =~ /(\S+\@\S+)(.*)$/) {
1042 $address = $1;
1043 $comment = $2 if defined $2;
1044 $formatted_email =~ s/$address.*$//;
1045 $name = $formatted_email;
Tom Rini6b9709d2014-02-27 08:27:28 -05001046 $name = trim($name);
Joe Hershberger05622192011-10-18 10:06:59 +00001047 $name =~ s/^\"|\"$//g;
1048 # If there's a name left after stripping spaces and
1049 # leading quotes, and the address doesn't have both
1050 # leading and trailing angle brackets, the address
1051 # is invalid. ie:
1052 # "joe smith joe@smith.com" bad
1053 # "joe smith <joe@smith.com" bad
1054 if ($name ne "" && $address !~ /^<[^>]+>$/) {
1055 $name = "";
1056 $address = "";
1057 $comment = "";
1058 }
1059 }
1060
Tom Rini6b9709d2014-02-27 08:27:28 -05001061 $name = trim($name);
Joe Hershberger05622192011-10-18 10:06:59 +00001062 $name =~ s/^\"|\"$//g;
Tom Rini6b9709d2014-02-27 08:27:28 -05001063 $address = trim($address);
Joe Hershberger05622192011-10-18 10:06:59 +00001064 $address =~ s/^\<|\>$//g;
1065
1066 if ($name =~ /[^\w \-]/i) { ##has "must quote" chars
1067 $name =~ s/(?<!\\)"/\\"/g; ##escape quotes
1068 $name = "\"$name\"";
1069 }
1070
1071 return ($name, $address, $comment);
1072}
1073
1074sub format_email {
1075 my ($name, $address) = @_;
1076
1077 my $formatted_email;
1078
Tom Rini6b9709d2014-02-27 08:27:28 -05001079 $name = trim($name);
Joe Hershberger05622192011-10-18 10:06:59 +00001080 $name =~ s/^\"|\"$//g;
Tom Rini6b9709d2014-02-27 08:27:28 -05001081 $address = trim($address);
Joe Hershberger05622192011-10-18 10:06:59 +00001082
1083 if ($name =~ /[^\w \-]/i) { ##has "must quote" chars
1084 $name =~ s/(?<!\\)"/\\"/g; ##escape quotes
1085 $name = "\"$name\"";
1086 }
1087
1088 if ("$name" eq "") {
1089 $formatted_email = "$address";
1090 } else {
1091 $formatted_email = "$name <$address>";
1092 }
1093
1094 return $formatted_email;
1095}
1096
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02001097sub which {
1098 my ($bin) = @_;
1099
1100 foreach my $path (split(/:/, $ENV{PATH})) {
1101 if (-e "$path/$bin") {
1102 return "$path/$bin";
1103 }
1104 }
1105
1106 return "";
1107}
1108
Joe Hershberger05622192011-10-18 10:06:59 +00001109sub which_conf {
1110 my ($conf) = @_;
1111
1112 foreach my $path (split(/:/, ".:$ENV{HOME}:.scripts")) {
1113 if (-e "$path/$conf") {
1114 return "$path/$conf";
1115 }
1116 }
1117
1118 return "";
1119}
1120
1121sub expand_tabs {
1122 my ($str) = @_;
1123
1124 my $res = '';
1125 my $n = 0;
1126 for my $c (split(//, $str)) {
1127 if ($c eq "\t") {
1128 $res .= ' ';
1129 $n++;
1130 for (; ($n % 8) != 0; $n++) {
1131 $res .= ' ';
1132 }
1133 next;
1134 }
1135 $res .= $c;
1136 $n++;
1137 }
1138
1139 return $res;
1140}
1141sub copy_spacing {
1142 (my $res = shift) =~ tr/\t/ /c;
1143 return $res;
1144}
1145
1146sub line_stats {
1147 my ($line) = @_;
1148
1149 # Drop the diff line leader and expand tabs
1150 $line =~ s/^.//;
1151 $line = expand_tabs($line);
1152
1153 # Pick the indent from the front of the line.
1154 my ($white) = ($line =~ /^(\s*)/);
1155
1156 return (length($line), length($white));
1157}
1158
1159my $sanitise_quote = '';
1160
1161sub sanitise_line_reset {
1162 my ($in_comment) = @_;
1163
1164 if ($in_comment) {
1165 $sanitise_quote = '*/';
1166 } else {
1167 $sanitise_quote = '';
1168 }
1169}
1170sub sanitise_line {
1171 my ($line) = @_;
1172
1173 my $res = '';
1174 my $l = '';
1175
1176 my $qlen = 0;
1177 my $off = 0;
1178 my $c;
1179
1180 # Always copy over the diff marker.
1181 $res = substr($line, 0, 1);
1182
1183 for ($off = 1; $off < length($line); $off++) {
1184 $c = substr($line, $off, 1);
1185
1186 # Comments we are wacking completly including the begin
1187 # and end, all to $;.
1188 if ($sanitise_quote eq '' && substr($line, $off, 2) eq '/*') {
1189 $sanitise_quote = '*/';
1190
1191 substr($res, $off, 2, "$;$;");
1192 $off++;
1193 next;
1194 }
1195 if ($sanitise_quote eq '*/' && substr($line, $off, 2) eq '*/') {
1196 $sanitise_quote = '';
1197 substr($res, $off, 2, "$;$;");
1198 $off++;
1199 next;
1200 }
1201 if ($sanitise_quote eq '' && substr($line, $off, 2) eq '//') {
1202 $sanitise_quote = '//';
1203
1204 substr($res, $off, 2, $sanitise_quote);
1205 $off++;
1206 next;
1207 }
1208
1209 # A \ in a string means ignore the next character.
1210 if (($sanitise_quote eq "'" || $sanitise_quote eq '"') &&
1211 $c eq "\\") {
1212 substr($res, $off, 2, 'XX');
1213 $off++;
1214 next;
1215 }
1216 # Regular quotes.
1217 if ($c eq "'" || $c eq '"') {
1218 if ($sanitise_quote eq '') {
1219 $sanitise_quote = $c;
1220
1221 substr($res, $off, 1, $c);
1222 next;
1223 } elsif ($sanitise_quote eq $c) {
1224 $sanitise_quote = '';
1225 }
1226 }
1227
1228 #print "c<$c> SQ<$sanitise_quote>\n";
1229 if ($off != 0 && $sanitise_quote eq '*/' && $c ne "\t") {
1230 substr($res, $off, 1, $;);
1231 } elsif ($off != 0 && $sanitise_quote eq '//' && $c ne "\t") {
1232 substr($res, $off, 1, $;);
1233 } elsif ($off != 0 && $sanitise_quote && $c ne "\t") {
1234 substr($res, $off, 1, 'X');
1235 } else {
1236 substr($res, $off, 1, $c);
1237 }
1238 }
1239
1240 if ($sanitise_quote eq '//') {
1241 $sanitise_quote = '';
1242 }
1243
1244 # The pathname on a #include may be surrounded by '<' and '>'.
1245 if ($res =~ /^.\s*\#\s*include\s+\<(.*)\>/) {
1246 my $clean = 'X' x length($1);
1247 $res =~ s@\<.*\>@<$clean>@;
1248
1249 # The whole of a #error is a string.
1250 } elsif ($res =~ /^.\s*\#\s*(?:error|warning)\s+(.*)\b/) {
1251 my $clean = 'X' x length($1);
1252 $res =~ s@(\#\s*(?:error|warning)\s+).*@$1$clean@;
1253 }
1254
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02001255 if ($allow_c99_comments && $res =~ m@(//.*$)@) {
1256 my $match = $1;
1257 $res =~ s/\Q$match\E/"$;" x length($match)/e;
1258 }
1259
Joe Hershberger05622192011-10-18 10:06:59 +00001260 return $res;
1261}
1262
Tom Rini6b9709d2014-02-27 08:27:28 -05001263sub get_quoted_string {
1264 my ($line, $rawline) = @_;
1265
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02001266 return "" if ($line !~ m/($String)/g);
Tom Rini6b9709d2014-02-27 08:27:28 -05001267 return substr($rawline, $-[0], $+[0] - $-[0]);
1268}
1269
Joe Hershberger05622192011-10-18 10:06:59 +00001270sub ctx_statement_block {
1271 my ($linenr, $remain, $off) = @_;
1272 my $line = $linenr - 1;
1273 my $blk = '';
1274 my $soff = $off;
1275 my $coff = $off - 1;
1276 my $coff_set = 0;
1277
1278 my $loff = 0;
1279
1280 my $type = '';
1281 my $level = 0;
1282 my @stack = ();
1283 my $p;
1284 my $c;
1285 my $len = 0;
1286
1287 my $remainder;
1288 while (1) {
1289 @stack = (['', 0]) if ($#stack == -1);
1290
1291 #warn "CSB: blk<$blk> remain<$remain>\n";
1292 # If we are about to drop off the end, pull in more
1293 # context.
1294 if ($off >= $len) {
1295 for (; $remain > 0; $line++) {
1296 last if (!defined $lines[$line]);
1297 next if ($lines[$line] =~ /^-/);
1298 $remain--;
1299 $loff = $len;
1300 $blk .= $lines[$line] . "\n";
1301 $len = length($blk);
1302 $line++;
1303 last;
1304 }
1305 # Bail if there is no further context.
1306 #warn "CSB: blk<$blk> off<$off> len<$len>\n";
1307 if ($off >= $len) {
1308 last;
1309 }
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00001310 if ($level == 0 && substr($blk, $off) =~ /^.\s*#\s*define/) {
1311 $level++;
1312 $type = '#';
1313 }
Joe Hershberger05622192011-10-18 10:06:59 +00001314 }
1315 $p = $c;
1316 $c = substr($blk, $off, 1);
1317 $remainder = substr($blk, $off);
1318
1319 #warn "CSB: c<$c> type<$type> level<$level> remainder<$remainder> coff_set<$coff_set>\n";
1320
1321 # Handle nested #if/#else.
1322 if ($remainder =~ /^#\s*(?:ifndef|ifdef|if)\s/) {
1323 push(@stack, [ $type, $level ]);
1324 } elsif ($remainder =~ /^#\s*(?:else|elif)\b/) {
1325 ($type, $level) = @{$stack[$#stack - 1]};
1326 } elsif ($remainder =~ /^#\s*endif\b/) {
1327 ($type, $level) = @{pop(@stack)};
1328 }
1329
1330 # Statement ends at the ';' or a close '}' at the
1331 # outermost level.
1332 if ($level == 0 && $c eq ';') {
1333 last;
1334 }
1335
1336 # An else is really a conditional as long as its not else if
1337 if ($level == 0 && $coff_set == 0 &&
1338 (!defined($p) || $p =~ /(?:\s|\}|\+)/) &&
1339 $remainder =~ /^(else)(?:\s|{)/ &&
1340 $remainder !~ /^else\s+if\b/) {
1341 $coff = $off + length($1) - 1;
1342 $coff_set = 1;
1343 #warn "CSB: mark coff<$coff> soff<$soff> 1<$1>\n";
1344 #warn "[" . substr($blk, $soff, $coff - $soff + 1) . "]\n";
1345 }
1346
1347 if (($type eq '' || $type eq '(') && $c eq '(') {
1348 $level++;
1349 $type = '(';
1350 }
1351 if ($type eq '(' && $c eq ')') {
1352 $level--;
1353 $type = ($level != 0)? '(' : '';
1354
1355 if ($level == 0 && $coff < $soff) {
1356 $coff = $off;
1357 $coff_set = 1;
1358 #warn "CSB: mark coff<$coff>\n";
1359 }
1360 }
1361 if (($type eq '' || $type eq '{') && $c eq '{') {
1362 $level++;
1363 $type = '{';
1364 }
1365 if ($type eq '{' && $c eq '}') {
1366 $level--;
1367 $type = ($level != 0)? '{' : '';
1368
1369 if ($level == 0) {
1370 if (substr($blk, $off + 1, 1) eq ';') {
1371 $off++;
1372 }
1373 last;
1374 }
1375 }
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00001376 # Preprocessor commands end at the newline unless escaped.
1377 if ($type eq '#' && $c eq "\n" && $p ne "\\") {
1378 $level--;
1379 $type = '';
1380 $off++;
1381 last;
1382 }
Joe Hershberger05622192011-10-18 10:06:59 +00001383 $off++;
1384 }
1385 # We are truly at the end, so shuffle to the next line.
1386 if ($off == $len) {
1387 $loff = $len + 1;
1388 $line++;
1389 $remain--;
1390 }
1391
1392 my $statement = substr($blk, $soff, $off - $soff + 1);
1393 my $condition = substr($blk, $soff, $coff - $soff + 1);
1394
1395 #warn "STATEMENT<$statement>\n";
1396 #warn "CONDITION<$condition>\n";
1397
1398 #print "coff<$coff> soff<$off> loff<$loff>\n";
1399
1400 return ($statement, $condition,
1401 $line, $remain + 1, $off - $loff + 1, $level);
1402}
1403
1404sub statement_lines {
1405 my ($stmt) = @_;
1406
1407 # Strip the diff line prefixes and rip blank lines at start and end.
1408 $stmt =~ s/(^|\n)./$1/g;
1409 $stmt =~ s/^\s*//;
1410 $stmt =~ s/\s*$//;
1411
1412 my @stmt_lines = ($stmt =~ /\n/g);
1413
1414 return $#stmt_lines + 2;
1415}
1416
1417sub statement_rawlines {
1418 my ($stmt) = @_;
1419
1420 my @stmt_lines = ($stmt =~ /\n/g);
1421
1422 return $#stmt_lines + 2;
1423}
1424
1425sub statement_block_size {
1426 my ($stmt) = @_;
1427
1428 $stmt =~ s/(^|\n)./$1/g;
1429 $stmt =~ s/^\s*{//;
1430 $stmt =~ s/}\s*$//;
1431 $stmt =~ s/^\s*//;
1432 $stmt =~ s/\s*$//;
1433
1434 my @stmt_lines = ($stmt =~ /\n/g);
1435 my @stmt_statements = ($stmt =~ /;/g);
1436
1437 my $stmt_lines = $#stmt_lines + 2;
1438 my $stmt_statements = $#stmt_statements + 1;
1439
1440 if ($stmt_lines > $stmt_statements) {
1441 return $stmt_lines;
1442 } else {
1443 return $stmt_statements;
1444 }
1445}
1446
1447sub ctx_statement_full {
1448 my ($linenr, $remain, $off) = @_;
1449 my ($statement, $condition, $level);
1450
1451 my (@chunks);
1452
1453 # Grab the first conditional/block pair.
1454 ($statement, $condition, $linenr, $remain, $off, $level) =
1455 ctx_statement_block($linenr, $remain, $off);
1456 #print "F: c<$condition> s<$statement> remain<$remain>\n";
1457 push(@chunks, [ $condition, $statement ]);
1458 if (!($remain > 0 && $condition =~ /^\s*(?:\n[+-])?\s*(?:if|else|do)\b/s)) {
1459 return ($level, $linenr, @chunks);
1460 }
1461
1462 # Pull in the following conditional/block pairs and see if they
1463 # could continue the statement.
1464 for (;;) {
1465 ($statement, $condition, $linenr, $remain, $off, $level) =
1466 ctx_statement_block($linenr, $remain, $off);
1467 #print "C: c<$condition> s<$statement> remain<$remain>\n";
1468 last if (!($remain > 0 && $condition =~ /^(?:\s*\n[+-])*\s*(?:else|do)\b/s));
1469 #print "C: push\n";
1470 push(@chunks, [ $condition, $statement ]);
1471 }
1472
1473 return ($level, $linenr, @chunks);
1474}
1475
1476sub ctx_block_get {
1477 my ($linenr, $remain, $outer, $open, $close, $off) = @_;
1478 my $line;
1479 my $start = $linenr - 1;
1480 my $blk = '';
1481 my @o;
1482 my @c;
1483 my @res = ();
1484
1485 my $level = 0;
1486 my @stack = ($level);
1487 for ($line = $start; $remain > 0; $line++) {
1488 next if ($rawlines[$line] =~ /^-/);
1489 $remain--;
1490
1491 $blk .= $rawlines[$line];
1492
1493 # Handle nested #if/#else.
1494 if ($lines[$line] =~ /^.\s*#\s*(?:ifndef|ifdef|if)\s/) {
1495 push(@stack, $level);
1496 } elsif ($lines[$line] =~ /^.\s*#\s*(?:else|elif)\b/) {
1497 $level = $stack[$#stack - 1];
1498 } elsif ($lines[$line] =~ /^.\s*#\s*endif\b/) {
1499 $level = pop(@stack);
1500 }
1501
1502 foreach my $c (split(//, $lines[$line])) {
1503 ##print "C<$c>L<$level><$open$close>O<$off>\n";
1504 if ($off > 0) {
1505 $off--;
1506 next;
1507 }
1508
1509 if ($c eq $close && $level > 0) {
1510 $level--;
1511 last if ($level == 0);
1512 } elsif ($c eq $open) {
1513 $level++;
1514 }
1515 }
1516
1517 if (!$outer || $level <= 1) {
1518 push(@res, $rawlines[$line]);
1519 }
1520
1521 last if ($level == 0);
1522 }
1523
1524 return ($level, @res);
1525}
1526sub ctx_block_outer {
1527 my ($linenr, $remain) = @_;
1528
1529 my ($level, @r) = ctx_block_get($linenr, $remain, 1, '{', '}', 0);
1530 return @r;
1531}
1532sub ctx_block {
1533 my ($linenr, $remain) = @_;
1534
1535 my ($level, @r) = ctx_block_get($linenr, $remain, 0, '{', '}', 0);
1536 return @r;
1537}
1538sub ctx_statement {
1539 my ($linenr, $remain, $off) = @_;
1540
1541 my ($level, @r) = ctx_block_get($linenr, $remain, 0, '(', ')', $off);
1542 return @r;
1543}
1544sub ctx_block_level {
1545 my ($linenr, $remain) = @_;
1546
1547 return ctx_block_get($linenr, $remain, 0, '{', '}', 0);
1548}
1549sub ctx_statement_level {
1550 my ($linenr, $remain, $off) = @_;
1551
1552 return ctx_block_get($linenr, $remain, 0, '(', ')', $off);
1553}
1554
1555sub ctx_locate_comment {
1556 my ($first_line, $end_line) = @_;
1557
1558 # Catch a comment on the end of the line itself.
1559 my ($current_comment) = ($rawlines[$end_line - 1] =~ m@.*(/\*.*\*/)\s*(?:\\\s*)?$@);
1560 return $current_comment if (defined $current_comment);
1561
1562 # Look through the context and try and figure out if there is a
1563 # comment.
1564 my $in_comment = 0;
1565 $current_comment = '';
1566 for (my $linenr = $first_line; $linenr < $end_line; $linenr++) {
1567 my $line = $rawlines[$linenr - 1];
1568 #warn " $line\n";
1569 if ($linenr == $first_line and $line =~ m@^.\s*\*@) {
1570 $in_comment = 1;
1571 }
1572 if ($line =~ m@/\*@) {
1573 $in_comment = 1;
1574 }
1575 if (!$in_comment && $current_comment ne '') {
1576 $current_comment = '';
1577 }
1578 $current_comment .= $line . "\n" if ($in_comment);
1579 if ($line =~ m@\*/@) {
1580 $in_comment = 0;
1581 }
1582 }
1583
1584 chomp($current_comment);
1585 return($current_comment);
1586}
1587sub ctx_has_comment {
1588 my ($first_line, $end_line) = @_;
1589 my $cmt = ctx_locate_comment($first_line, $end_line);
1590
1591 ##print "LINE: $rawlines[$end_line - 1 ]\n";
1592 ##print "CMMT: $cmt\n";
1593
1594 return ($cmt ne '');
1595}
1596
1597sub raw_line {
1598 my ($linenr, $cnt) = @_;
1599
1600 my $offset = $linenr - 1;
1601 $cnt++;
1602
1603 my $line;
1604 while ($cnt) {
1605 $line = $rawlines[$offset++];
1606 next if (defined($line) && $line =~ /^-/);
1607 $cnt--;
1608 }
1609
1610 return $line;
1611}
1612
1613sub cat_vet {
1614 my ($vet) = @_;
1615 my ($res, $coded);
1616
1617 $res = '';
1618 while ($vet =~ /([^[:cntrl:]]*)([[:cntrl:]]|$)/g) {
1619 $res .= $1;
1620 if ($2 ne '') {
1621 $coded = sprintf("^%c", unpack('C', $2) + 64);
1622 $res .= $coded;
1623 }
1624 }
1625 $res =~ s/$/\$/;
1626
1627 return $res;
1628}
1629
1630my $av_preprocessor = 0;
1631my $av_pending;
1632my @av_paren_type;
1633my $av_pend_colon;
1634
1635sub annotate_reset {
1636 $av_preprocessor = 0;
1637 $av_pending = '_';
1638 @av_paren_type = ('E');
1639 $av_pend_colon = 'O';
1640}
1641
1642sub annotate_values {
1643 my ($stream, $type) = @_;
1644
1645 my $res;
1646 my $var = '_' x length($stream);
1647 my $cur = $stream;
1648
1649 print "$stream\n" if ($dbg_values > 1);
1650
1651 while (length($cur)) {
1652 @av_paren_type = ('E') if ($#av_paren_type < 0);
1653 print " <" . join('', @av_paren_type) .
1654 "> <$type> <$av_pending>" if ($dbg_values > 1);
1655 if ($cur =~ /^(\s+)/o) {
1656 print "WS($1)\n" if ($dbg_values > 1);
1657 if ($1 =~ /\n/ && $av_preprocessor) {
1658 $type = pop(@av_paren_type);
1659 $av_preprocessor = 0;
1660 }
1661
1662 } elsif ($cur =~ /^(\(\s*$Type\s*)\)/ && $av_pending eq '_') {
1663 print "CAST($1)\n" if ($dbg_values > 1);
1664 push(@av_paren_type, $type);
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00001665 $type = 'c';
Joe Hershberger05622192011-10-18 10:06:59 +00001666
1667 } elsif ($cur =~ /^($Type)\s*(?:$Ident|,|\)|\(|\s*$)/) {
1668 print "DECLARE($1)\n" if ($dbg_values > 1);
1669 $type = 'T';
1670
1671 } elsif ($cur =~ /^($Modifier)\s*/) {
1672 print "MODIFIER($1)\n" if ($dbg_values > 1);
1673 $type = 'T';
1674
1675 } elsif ($cur =~ /^(\#\s*define\s*$Ident)(\(?)/o) {
1676 print "DEFINE($1,$2)\n" if ($dbg_values > 1);
1677 $av_preprocessor = 1;
1678 push(@av_paren_type, $type);
1679 if ($2 ne '') {
1680 $av_pending = 'N';
1681 }
1682 $type = 'E';
1683
1684 } elsif ($cur =~ /^(\#\s*(?:undef\s*$Ident|include\b))/o) {
1685 print "UNDEF($1)\n" if ($dbg_values > 1);
1686 $av_preprocessor = 1;
1687 push(@av_paren_type, $type);
1688
1689 } elsif ($cur =~ /^(\#\s*(?:ifdef|ifndef|if))/o) {
1690 print "PRE_START($1)\n" if ($dbg_values > 1);
1691 $av_preprocessor = 1;
1692
1693 push(@av_paren_type, $type);
1694 push(@av_paren_type, $type);
1695 $type = 'E';
1696
1697 } elsif ($cur =~ /^(\#\s*(?:else|elif))/o) {
1698 print "PRE_RESTART($1)\n" if ($dbg_values > 1);
1699 $av_preprocessor = 1;
1700
1701 push(@av_paren_type, $av_paren_type[$#av_paren_type]);
1702
1703 $type = 'E';
1704
1705 } elsif ($cur =~ /^(\#\s*(?:endif))/o) {
1706 print "PRE_END($1)\n" if ($dbg_values > 1);
1707
1708 $av_preprocessor = 1;
1709
1710 # Assume all arms of the conditional end as this
1711 # one does, and continue as if the #endif was not here.
1712 pop(@av_paren_type);
1713 push(@av_paren_type, $type);
1714 $type = 'E';
1715
1716 } elsif ($cur =~ /^(\\\n)/o) {
1717 print "PRECONT($1)\n" if ($dbg_values > 1);
1718
1719 } elsif ($cur =~ /^(__attribute__)\s*\(?/o) {
1720 print "ATTR($1)\n" if ($dbg_values > 1);
1721 $av_pending = $type;
1722 $type = 'N';
1723
1724 } elsif ($cur =~ /^(sizeof)\s*(\()?/o) {
1725 print "SIZEOF($1)\n" if ($dbg_values > 1);
1726 if (defined $2) {
1727 $av_pending = 'V';
1728 }
1729 $type = 'N';
1730
1731 } elsif ($cur =~ /^(if|while|for)\b/o) {
1732 print "COND($1)\n" if ($dbg_values > 1);
1733 $av_pending = 'E';
1734 $type = 'N';
1735
1736 } elsif ($cur =~/^(case)/o) {
1737 print "CASE($1)\n" if ($dbg_values > 1);
1738 $av_pend_colon = 'C';
1739 $type = 'N';
1740
1741 } elsif ($cur =~/^(return|else|goto|typeof|__typeof__)\b/o) {
1742 print "KEYWORD($1)\n" if ($dbg_values > 1);
1743 $type = 'N';
1744
1745 } elsif ($cur =~ /^(\()/o) {
1746 print "PAREN('$1')\n" if ($dbg_values > 1);
1747 push(@av_paren_type, $av_pending);
1748 $av_pending = '_';
1749 $type = 'N';
1750
1751 } elsif ($cur =~ /^(\))/o) {
1752 my $new_type = pop(@av_paren_type);
1753 if ($new_type ne '_') {
1754 $type = $new_type;
1755 print "PAREN('$1') -> $type\n"
1756 if ($dbg_values > 1);
1757 } else {
1758 print "PAREN('$1')\n" if ($dbg_values > 1);
1759 }
1760
1761 } elsif ($cur =~ /^($Ident)\s*\(/o) {
1762 print "FUNC($1)\n" if ($dbg_values > 1);
1763 $type = 'V';
1764 $av_pending = 'V';
1765
1766 } elsif ($cur =~ /^($Ident\s*):(?:\s*\d+\s*(,|=|;))?/) {
1767 if (defined $2 && $type eq 'C' || $type eq 'T') {
1768 $av_pend_colon = 'B';
1769 } elsif ($type eq 'E') {
1770 $av_pend_colon = 'L';
1771 }
1772 print "IDENT_COLON($1,$type>$av_pend_colon)\n" if ($dbg_values > 1);
1773 $type = 'V';
1774
1775 } elsif ($cur =~ /^($Ident|$Constant)/o) {
1776 print "IDENT($1)\n" if ($dbg_values > 1);
1777 $type = 'V';
1778
1779 } elsif ($cur =~ /^($Assignment)/o) {
1780 print "ASSIGN($1)\n" if ($dbg_values > 1);
1781 $type = 'N';
1782
1783 } elsif ($cur =~/^(;|{|})/) {
1784 print "END($1)\n" if ($dbg_values > 1);
1785 $type = 'E';
1786 $av_pend_colon = 'O';
1787
1788 } elsif ($cur =~/^(,)/) {
1789 print "COMMA($1)\n" if ($dbg_values > 1);
1790 $type = 'C';
1791
1792 } elsif ($cur =~ /^(\?)/o) {
1793 print "QUESTION($1)\n" if ($dbg_values > 1);
1794 $type = 'N';
1795
1796 } elsif ($cur =~ /^(:)/o) {
1797 print "COLON($1,$av_pend_colon)\n" if ($dbg_values > 1);
1798
1799 substr($var, length($res), 1, $av_pend_colon);
1800 if ($av_pend_colon eq 'C' || $av_pend_colon eq 'L') {
1801 $type = 'E';
1802 } else {
1803 $type = 'N';
1804 }
1805 $av_pend_colon = 'O';
1806
1807 } elsif ($cur =~ /^(\[)/o) {
1808 print "CLOSE($1)\n" if ($dbg_values > 1);
1809 $type = 'N';
1810
1811 } elsif ($cur =~ /^(-(?![->])|\+(?!\+)|\*|\&\&|\&)/o) {
1812 my $variant;
1813
1814 print "OPV($1)\n" if ($dbg_values > 1);
1815 if ($type eq 'V') {
1816 $variant = 'B';
1817 } else {
1818 $variant = 'U';
1819 }
1820
1821 substr($var, length($res), 1, $variant);
1822 $type = 'N';
1823
1824 } elsif ($cur =~ /^($Operators)/o) {
1825 print "OP($1)\n" if ($dbg_values > 1);
1826 if ($1 ne '++' && $1 ne '--') {
1827 $type = 'N';
1828 }
1829
1830 } elsif ($cur =~ /(^.)/o) {
1831 print "C($1)\n" if ($dbg_values > 1);
1832 }
1833 if (defined $1) {
1834 $cur = substr($cur, length($1));
1835 $res .= $type x length($1);
1836 }
1837 }
1838
1839 return ($res, $var);
1840}
1841
1842sub possible {
1843 my ($possible, $line) = @_;
1844 my $notPermitted = qr{(?:
1845 ^(?:
1846 $Modifier|
1847 $Storage|
1848 $Type|
1849 DEFINE_\S+
1850 )$|
1851 ^(?:
1852 goto|
1853 return|
1854 case|
1855 else|
1856 asm|__asm__|
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00001857 do|
1858 \#|
1859 \#\#|
Joe Hershberger05622192011-10-18 10:06:59 +00001860 )(?:\s|$)|
1861 ^(?:typedef|struct|enum)\b
1862 )}x;
1863 warn "CHECK<$possible> ($line)\n" if ($dbg_possible > 2);
1864 if ($possible !~ $notPermitted) {
1865 # Check for modifiers.
1866 $possible =~ s/\s*$Storage\s*//g;
1867 $possible =~ s/\s*$Sparse\s*//g;
1868 if ($possible =~ /^\s*$/) {
1869
1870 } elsif ($possible =~ /\s/) {
1871 $possible =~ s/\s*$Type\s*//g;
1872 for my $modifier (split(' ', $possible)) {
1873 if ($modifier !~ $notPermitted) {
1874 warn "MODIFIER: $modifier ($possible) ($line)\n" if ($dbg_possible);
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02001875 push(@modifierListFile, $modifier);
Joe Hershberger05622192011-10-18 10:06:59 +00001876 }
1877 }
1878
1879 } else {
1880 warn "POSSIBLE: $possible ($line)\n" if ($dbg_possible);
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02001881 push(@typeListFile, $possible);
Joe Hershberger05622192011-10-18 10:06:59 +00001882 }
1883 build_types();
1884 } else {
1885 warn "NOTPOSS: $possible ($line)\n" if ($dbg_possible > 1);
1886 }
1887}
1888
1889my $prefix = '';
1890
1891sub show_type {
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02001892 my ($type) = @_;
Tom Rini6b9709d2014-02-27 08:27:28 -05001893
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02001894 $type =~ tr/[a-z]/[A-Z]/;
1895
1896 return defined $use_type{$type} if (scalar keys %use_type > 0);
1897
1898 return !defined $ignore_type{$type};
Joe Hershberger05622192011-10-18 10:06:59 +00001899}
1900
1901sub report {
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02001902 my ($level, $type, $msg) = @_;
1903
1904 if (!show_type($type) ||
1905 (defined $tst_only && $msg !~ /\Q$tst_only\E/)) {
Joe Hershberger05622192011-10-18 10:06:59 +00001906 return 0;
1907 }
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02001908 my $output = '';
1909 if ($color) {
1910 if ($level eq 'ERROR') {
1911 $output .= RED;
1912 } elsif ($level eq 'WARNING') {
1913 $output .= YELLOW;
1914 } else {
1915 $output .= GREEN;
1916 }
Joe Hershberger05622192011-10-18 10:06:59 +00001917 }
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02001918 $output .= $prefix . $level . ':';
1919 if ($show_types) {
1920 $output .= BLUE if ($color);
1921 $output .= "$type:";
1922 }
1923 $output .= RESET if ($color);
1924 $output .= ' ' . $msg . "\n";
Joe Hershberger05622192011-10-18 10:06:59 +00001925
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02001926 if ($showfile) {
1927 my @lines = split("\n", $output, -1);
1928 splice(@lines, 1, 1);
1929 $output = join("\n", @lines);
1930 }
1931 $output = (split('\n', $output))[0] . "\n" if ($terse);
1932
1933 push(our @report, $output);
Joe Hershberger05622192011-10-18 10:06:59 +00001934
1935 return 1;
1936}
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02001937
Joe Hershberger05622192011-10-18 10:06:59 +00001938sub report_dump {
1939 our @report;
1940}
1941
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02001942sub fixup_current_range {
1943 my ($lineRef, $offset, $length) = @_;
1944
1945 if ($$lineRef =~ /^\@\@ -\d+,\d+ \+(\d+),(\d+) \@\@/) {
1946 my $o = $1;
1947 my $l = $2;
1948 my $no = $o + $offset;
1949 my $nl = $l + $length;
1950 $$lineRef =~ s/\+$o,$l \@\@/\+$no,$nl \@\@/;
1951 }
1952}
1953
1954sub fix_inserted_deleted_lines {
1955 my ($linesRef, $insertedRef, $deletedRef) = @_;
1956
1957 my $range_last_linenr = 0;
1958 my $delta_offset = 0;
1959
1960 my $old_linenr = 0;
1961 my $new_linenr = 0;
1962
1963 my $next_insert = 0;
1964 my $next_delete = 0;
1965
1966 my @lines = ();
1967
1968 my $inserted = @{$insertedRef}[$next_insert++];
1969 my $deleted = @{$deletedRef}[$next_delete++];
1970
1971 foreach my $old_line (@{$linesRef}) {
1972 my $save_line = 1;
1973 my $line = $old_line; #don't modify the array
1974 if ($line =~ /^(?:\+\+\+|\-\-\-)\s+\S+/) { #new filename
1975 $delta_offset = 0;
1976 } elsif ($line =~ /^\@\@ -\d+,\d+ \+\d+,\d+ \@\@/) { #new hunk
1977 $range_last_linenr = $new_linenr;
1978 fixup_current_range(\$line, $delta_offset, 0);
1979 }
1980
1981 while (defined($deleted) && ${$deleted}{'LINENR'} == $old_linenr) {
1982 $deleted = @{$deletedRef}[$next_delete++];
1983 $save_line = 0;
1984 fixup_current_range(\$lines[$range_last_linenr], $delta_offset--, -1);
1985 }
1986
1987 while (defined($inserted) && ${$inserted}{'LINENR'} == $old_linenr) {
1988 push(@lines, ${$inserted}{'LINE'});
1989 $inserted = @{$insertedRef}[$next_insert++];
1990 $new_linenr++;
1991 fixup_current_range(\$lines[$range_last_linenr], $delta_offset++, 1);
1992 }
1993
1994 if ($save_line) {
1995 push(@lines, $line);
1996 $new_linenr++;
1997 }
1998
1999 $old_linenr++;
2000 }
2001
2002 return @lines;
2003}
2004
2005sub fix_insert_line {
2006 my ($linenr, $line) = @_;
2007
2008 my $inserted = {
2009 LINENR => $linenr,
2010 LINE => $line,
2011 };
2012 push(@fixed_inserted, $inserted);
2013}
2014
2015sub fix_delete_line {
2016 my ($linenr, $line) = @_;
2017
2018 my $deleted = {
2019 LINENR => $linenr,
2020 LINE => $line,
2021 };
2022
2023 push(@fixed_deleted, $deleted);
2024}
2025
Joe Hershberger05622192011-10-18 10:06:59 +00002026sub ERROR {
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02002027 my ($type, $msg) = @_;
2028
2029 if (report("ERROR", $type, $msg)) {
Joe Hershberger05622192011-10-18 10:06:59 +00002030 our $clean = 0;
2031 our $cnt_error++;
Tom Rini6b9709d2014-02-27 08:27:28 -05002032 return 1;
Joe Hershberger05622192011-10-18 10:06:59 +00002033 }
Tom Rini6b9709d2014-02-27 08:27:28 -05002034 return 0;
Joe Hershberger05622192011-10-18 10:06:59 +00002035}
2036sub WARN {
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02002037 my ($type, $msg) = @_;
2038
2039 if (report("WARNING", $type, $msg)) {
Joe Hershberger05622192011-10-18 10:06:59 +00002040 our $clean = 0;
2041 our $cnt_warn++;
Tom Rini6b9709d2014-02-27 08:27:28 -05002042 return 1;
Joe Hershberger05622192011-10-18 10:06:59 +00002043 }
Tom Rini6b9709d2014-02-27 08:27:28 -05002044 return 0;
Joe Hershberger05622192011-10-18 10:06:59 +00002045}
2046sub CHK {
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02002047 my ($type, $msg) = @_;
2048
2049 if ($check && report("CHECK", $type, $msg)) {
Joe Hershberger05622192011-10-18 10:06:59 +00002050 our $clean = 0;
2051 our $cnt_chk++;
Tom Rini6b9709d2014-02-27 08:27:28 -05002052 return 1;
Joe Hershberger05622192011-10-18 10:06:59 +00002053 }
Tom Rini6b9709d2014-02-27 08:27:28 -05002054 return 0;
Joe Hershberger05622192011-10-18 10:06:59 +00002055}
2056
2057sub check_absolute_file {
2058 my ($absolute, $herecurr) = @_;
2059 my $file = $absolute;
2060
2061 ##print "absolute<$absolute>\n";
2062
2063 # See if any suffix of this path is a path within the tree.
2064 while ($file =~ s@^[^/]*/@@) {
2065 if (-f "$root/$file") {
2066 ##print "file<$file>\n";
2067 last;
2068 }
2069 }
2070 if (! -f _) {
2071 return 0;
2072 }
2073
2074 # It is, so see if the prefix is acceptable.
2075 my $prefix = $absolute;
2076 substr($prefix, -length($file)) = '';
2077
2078 ##print "prefix<$prefix>\n";
2079 if ($prefix ne ".../") {
2080 WARN("USE_RELATIVE_PATH",
2081 "use relative pathname instead of absolute in changelog text\n" . $herecurr);
2082 }
2083}
2084
Tom Rini6b9709d2014-02-27 08:27:28 -05002085sub trim {
2086 my ($string) = @_;
2087
2088 $string =~ s/^\s+|\s+$//g;
2089
2090 return $string;
2091}
2092
2093sub ltrim {
2094 my ($string) = @_;
2095
2096 $string =~ s/^\s+//;
2097
2098 return $string;
2099}
2100
2101sub rtrim {
2102 my ($string) = @_;
2103
2104 $string =~ s/\s+$//;
2105
2106 return $string;
2107}
2108
2109sub string_find_replace {
2110 my ($string, $find, $replace) = @_;
2111
2112 $string =~ s/$find/$replace/g;
2113
2114 return $string;
2115}
2116
2117sub tabify {
2118 my ($leading) = @_;
2119
2120 my $source_indent = 8;
2121 my $max_spaces_before_tab = $source_indent - 1;
2122 my $spaces_to_tab = " " x $source_indent;
2123
2124 #convert leading spaces to tabs
2125 1 while $leading =~ s@^([\t]*)$spaces_to_tab@$1\t@g;
2126 #Remove spaces before a tab
2127 1 while $leading =~ s@^([\t]*)( {1,$max_spaces_before_tab})\t@$1\t@g;
2128
2129 return "$leading";
2130}
2131
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00002132sub pos_last_openparen {
2133 my ($line) = @_;
2134
2135 my $pos = 0;
2136
2137 my $opens = $line =~ tr/\(/\(/;
2138 my $closes = $line =~ tr/\)/\)/;
2139
2140 my $last_openparen = 0;
2141
2142 if (($opens == 0) || ($closes >= $opens)) {
2143 return -1;
2144 }
2145
2146 my $len = length($line);
2147
2148 for ($pos = 0; $pos < $len; $pos++) {
2149 my $string = substr($line, $pos);
2150 if ($string =~ /^($FuncArg|$balanced_parens)/) {
2151 $pos += length($1) - 1;
2152 } elsif (substr($line, $pos, 1) eq '(') {
2153 $last_openparen = $pos;
2154 } elsif (index($string, '(') == -1) {
2155 last;
2156 }
2157 }
2158
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02002159 return length(expand_tabs(substr($line, 0, $last_openparen))) + 1;
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00002160}
2161
Joe Hershberger05622192011-10-18 10:06:59 +00002162sub process {
2163 my $filename = shift;
2164
2165 my $linenr=0;
2166 my $prevline="";
2167 my $prevrawline="";
2168 my $stashline="";
2169 my $stashrawline="";
2170
2171 my $length;
2172 my $indent;
2173 my $previndent=0;
2174 my $stashindent=0;
2175
2176 our $clean = 1;
2177 my $signoff = 0;
2178 my $is_patch = 0;
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02002179 my $in_header_lines = $file ? 0 : 1;
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00002180 my $in_commit_log = 0; #Scanning lines before patch
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02002181 my $has_commit_log = 0; #Encountered lines before patch
2182 my $commit_log_possible_stack_dump = 0;
2183 my $commit_log_long_line = 0;
2184 my $commit_log_has_diff = 0;
2185 my $reported_maintainer_file = 0;
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00002186 my $non_utf8_charset = 0;
2187
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02002188 my $last_blank_line = 0;
2189 my $last_coalesced_string_linenr = -1;
2190
Joe Hershberger05622192011-10-18 10:06:59 +00002191 our @report = ();
2192 our $cnt_lines = 0;
2193 our $cnt_error = 0;
2194 our $cnt_warn = 0;
2195 our $cnt_chk = 0;
2196
2197 # Trace the real file/line as we go.
2198 my $realfile = '';
2199 my $realline = 0;
2200 my $realcnt = 0;
2201 my $here = '';
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02002202 my $context_function; #undef'd unless there's a known function
Joe Hershberger05622192011-10-18 10:06:59 +00002203 my $in_comment = 0;
2204 my $comment_edge = 0;
2205 my $first_line = 0;
2206 my $p1_prefix = '';
2207
2208 my $prev_values = 'E';
2209
2210 # suppression flags
2211 my %suppress_ifbraces;
2212 my %suppress_whiletrailers;
2213 my %suppress_export;
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00002214 my $suppress_statement = 0;
2215
Tom Rini6b9709d2014-02-27 08:27:28 -05002216 my %signatures = ();
Joe Hershberger05622192011-10-18 10:06:59 +00002217
2218 # Pre-scan the patch sanitizing the lines.
2219 # Pre-scan the patch looking for any __setup documentation.
2220 #
2221 my @setup_docs = ();
2222 my $setup_docs = 0;
2223
Tom Rini6b9709d2014-02-27 08:27:28 -05002224 my $camelcase_file_seeded = 0;
2225
Joe Hershberger05622192011-10-18 10:06:59 +00002226 sanitise_line_reset();
2227 my $line;
2228 foreach my $rawline (@rawlines) {
2229 $linenr++;
2230 $line = $rawline;
2231
Tom Rini6b9709d2014-02-27 08:27:28 -05002232 push(@fixed, $rawline) if ($fix);
2233
Joe Hershberger05622192011-10-18 10:06:59 +00002234 if ($rawline=~/^\+\+\+\s+(\S+)/) {
2235 $setup_docs = 0;
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02002236 if ($1 =~ m@Documentation/admin-guide/kernel-parameters.rst$@) {
Joe Hershberger05622192011-10-18 10:06:59 +00002237 $setup_docs = 1;
2238 }
2239 #next;
2240 }
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02002241 if ($rawline =~ /^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@/) {
Joe Hershberger05622192011-10-18 10:06:59 +00002242 $realline=$1-1;
2243 if (defined $2) {
2244 $realcnt=$3+1;
2245 } else {
2246 $realcnt=1+1;
2247 }
2248 $in_comment = 0;
2249
2250 # Guestimate if this is a continuing comment. Run
2251 # the context looking for a comment "edge". If this
2252 # edge is a close comment then we must be in a comment
2253 # at context start.
2254 my $edge;
2255 my $cnt = $realcnt;
2256 for (my $ln = $linenr + 1; $cnt > 0; $ln++) {
2257 next if (defined $rawlines[$ln - 1] &&
2258 $rawlines[$ln - 1] =~ /^-/);
2259 $cnt--;
2260 #print "RAW<$rawlines[$ln - 1]>\n";
2261 last if (!defined $rawlines[$ln - 1]);
2262 if ($rawlines[$ln - 1] =~ m@(/\*|\*/)@ &&
2263 $rawlines[$ln - 1] !~ m@"[^"]*(?:/\*|\*/)[^"]*"@) {
2264 ($edge) = $1;
2265 last;
2266 }
2267 }
2268 if (defined $edge && $edge eq '*/') {
2269 $in_comment = 1;
2270 }
2271
2272 # Guestimate if this is a continuing comment. If this
2273 # is the start of a diff block and this line starts
2274 # ' *' then it is very likely a comment.
2275 if (!defined $edge &&
2276 $rawlines[$linenr] =~ m@^.\s*(?:\*\*+| \*)(?:\s|$)@)
2277 {
2278 $in_comment = 1;
2279 }
2280
2281 ##print "COMMENT:$in_comment edge<$edge> $rawline\n";
2282 sanitise_line_reset($in_comment);
2283
2284 } elsif ($realcnt && $rawline =~ /^(?:\+| |$)/) {
2285 # Standardise the strings and chars within the input to
2286 # simplify matching -- only bother with positive lines.
2287 $line = sanitise_line($rawline);
2288 }
2289 push(@lines, $line);
2290
2291 if ($realcnt > 1) {
2292 $realcnt-- if ($line =~ /^(?:\+| |$)/);
2293 } else {
2294 $realcnt = 0;
2295 }
2296
2297 #print "==>$rawline\n";
2298 #print "-->$line\n";
2299
2300 if ($setup_docs && $line =~ /^\+/) {
2301 push(@setup_docs, $line);
2302 }
2303 }
2304
2305 $prefix = '';
2306
2307 $realcnt = 0;
2308 $linenr = 0;
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02002309 $fixlinenr = -1;
Joe Hershberger05622192011-10-18 10:06:59 +00002310 foreach my $line (@lines) {
2311 $linenr++;
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02002312 $fixlinenr++;
Tom Rini6b9709d2014-02-27 08:27:28 -05002313 my $sline = $line; #copy of $line
2314 $sline =~ s/$;/ /g; #with comments as spaces
Joe Hershberger05622192011-10-18 10:06:59 +00002315
2316 my $rawline = $rawlines[$linenr - 1];
2317
2318#extract the line range in the file after the patch is applied
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02002319 if (!$in_commit_log &&
2320 $line =~ /^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@(.*)/) {
2321 my $context = $4;
Joe Hershberger05622192011-10-18 10:06:59 +00002322 $is_patch = 1;
2323 $first_line = $linenr + 1;
2324 $realline=$1-1;
2325 if (defined $2) {
2326 $realcnt=$3+1;
2327 } else {
2328 $realcnt=1+1;
2329 }
2330 annotate_reset();
2331 $prev_values = 'E';
2332
2333 %suppress_ifbraces = ();
2334 %suppress_whiletrailers = ();
2335 %suppress_export = ();
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00002336 $suppress_statement = 0;
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02002337 if ($context =~ /\b(\w+)\s*\(/) {
2338 $context_function = $1;
2339 } else {
2340 undef $context_function;
2341 }
Joe Hershberger05622192011-10-18 10:06:59 +00002342 next;
2343
2344# track the line number as we move through the hunk, note that
2345# new versions of GNU diff omit the leading space on completely
2346# blank context lines so we need to count that too.
2347 } elsif ($line =~ /^( |\+|$)/) {
2348 $realline++;
2349 $realcnt-- if ($realcnt != 0);
2350
2351 # Measure the line length and indent.
2352 ($length, $indent) = line_stats($rawline);
2353
2354 # Track the previous line.
2355 ($prevline, $stashline) = ($stashline, $line);
2356 ($previndent, $stashindent) = ($stashindent, $indent);
2357 ($prevrawline, $stashrawline) = ($stashrawline, $rawline);
2358
2359 #warn "line<$line>\n";
2360
2361 } elsif ($realcnt == 1) {
2362 $realcnt--;
2363 }
2364
2365 my $hunk_line = ($realcnt != 0);
2366
Joe Hershberger05622192011-10-18 10:06:59 +00002367 $here = "#$linenr: " if (!$file);
2368 $here = "#$realline: " if ($file);
2369
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02002370 my $found_file = 0;
Joe Hershberger05622192011-10-18 10:06:59 +00002371 # extract the filename as it passes
2372 if ($line =~ /^diff --git.*?(\S+)$/) {
2373 $realfile = $1;
Tom Rini6b9709d2014-02-27 08:27:28 -05002374 $realfile =~ s@^([^/]*)/@@ if (!$file);
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00002375 $in_commit_log = 0;
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02002376 $found_file = 1;
Joe Hershberger05622192011-10-18 10:06:59 +00002377 } elsif ($line =~ /^\+\+\+\s+(\S+)/) {
2378 $realfile = $1;
Tom Rini6b9709d2014-02-27 08:27:28 -05002379 $realfile =~ s@^([^/]*)/@@ if (!$file);
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00002380 $in_commit_log = 0;
Joe Hershberger05622192011-10-18 10:06:59 +00002381
2382 $p1_prefix = $1;
2383 if (!$file && $tree && $p1_prefix ne '' &&
2384 -e "$root/$p1_prefix") {
2385 WARN("PATCH_PREFIX",
2386 "patch prefix '$p1_prefix' exists, appears to be a -p0 patch\n");
2387 }
2388
2389 if ($realfile =~ m@^include/asm/@) {
2390 ERROR("MODIFIED_INCLUDE_ASM",
2391 "do not modify files in include/asm, change architecture specific files in include/asm-<architecture>\n" . "$here$rawline\n");
2392 }
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02002393 $found_file = 1;
2394 }
2395
2396#make up the handle for any error we report on this line
2397 if ($showfile) {
2398 $prefix = "$realfile:$realline: "
2399 } elsif ($emacs) {
2400 if ($file) {
2401 $prefix = "$filename:$realline: ";
2402 } else {
2403 $prefix = "$filename:$linenr: ";
2404 }
2405 }
2406
2407 if ($found_file) {
2408 if (is_maintained_obsolete($realfile)) {
2409 WARN("OBSOLETE",
2410 "$realfile is marked as 'obsolete' in the MAINTAINERS hierarchy. No unnecessary modifications please.\n");
2411 }
2412 if ($realfile =~ m@^(?:drivers/net/|net/|drivers/staging/)@) {
2413 $check = 1;
2414 } else {
2415 $check = $check_orig;
2416 }
Joe Hershberger05622192011-10-18 10:06:59 +00002417 next;
2418 }
2419
2420 $here .= "FILE: $realfile:$realline:" if ($realcnt != 0);
2421
2422 my $hereline = "$here\n$rawline\n";
2423 my $herecurr = "$here\n$rawline\n";
2424 my $hereprev = "$here\n$prevrawline\n$rawline\n";
2425
2426 $cnt_lines++ if ($realcnt != 0);
2427
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02002428# Check if the commit log has what seems like a diff which can confuse patch
2429 if ($in_commit_log && !$commit_log_has_diff &&
2430 (($line =~ m@^\s+diff\b.*a/[\w/]+@ &&
2431 $line =~ m@^\s+diff\b.*a/([\w/]+)\s+b/$1\b@) ||
2432 $line =~ m@^\s*(?:\-\-\-\s+a/|\+\+\+\s+b/)@ ||
2433 $line =~ m/^\s*\@\@ \-\d+,\d+ \+\d+,\d+ \@\@/)) {
2434 ERROR("DIFF_IN_COMMIT_MSG",
2435 "Avoid using diff content in the commit message - patch(1) might not work\n" . $herecurr);
2436 $commit_log_has_diff = 1;
2437 }
2438
Joe Hershberger05622192011-10-18 10:06:59 +00002439# Check for incorrect file permissions
2440 if ($line =~ /^new (file )?mode.*[7531]\d{0,2}$/) {
2441 my $permhere = $here . "FILE: $realfile\n";
Tom Rini6b9709d2014-02-27 08:27:28 -05002442 if ($realfile !~ m@scripts/@ &&
2443 $realfile !~ /\.(py|pl|awk|sh)$/) {
Joe Hershberger05622192011-10-18 10:06:59 +00002444 ERROR("EXECUTE_PERMISSIONS",
2445 "do not set execute permissions for source files\n" . $permhere);
2446 }
2447 }
2448
2449# Check the patch for a signoff:
2450 if ($line =~ /^\s*signed-off-by:/i) {
2451 $signoff++;
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00002452 $in_commit_log = 0;
Joe Hershberger05622192011-10-18 10:06:59 +00002453 }
2454
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02002455# Check if MAINTAINERS is being updated. If so, there's probably no need to
2456# emit the "does MAINTAINERS need updating?" message on file add/move/delete
2457 if ($line =~ /^\s*MAINTAINERS\s*\|/) {
2458 $reported_maintainer_file = 1;
2459 }
2460
Joe Hershberger05622192011-10-18 10:06:59 +00002461# Check signature styles
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00002462 if (!$in_header_lines &&
2463 $line =~ /^(\s*)([a-z0-9_-]+by:|$signature_tags)(\s*)(.*)/i) {
Joe Hershberger05622192011-10-18 10:06:59 +00002464 my $space_before = $1;
2465 my $sign_off = $2;
2466 my $space_after = $3;
2467 my $email = $4;
2468 my $ucfirst_sign_off = ucfirst(lc($sign_off));
2469
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00002470 if ($sign_off !~ /$signature_tags/) {
2471 WARN("BAD_SIGN_OFF",
2472 "Non-standard signature: $sign_off\n" . $herecurr);
2473 }
Joe Hershberger05622192011-10-18 10:06:59 +00002474 if (defined $space_before && $space_before ne "") {
Tom Rini6b9709d2014-02-27 08:27:28 -05002475 if (WARN("BAD_SIGN_OFF",
2476 "Do not use whitespace before $ucfirst_sign_off\n" . $herecurr) &&
2477 $fix) {
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02002478 $fixed[$fixlinenr] =
Tom Rini6b9709d2014-02-27 08:27:28 -05002479 "$ucfirst_sign_off $email";
2480 }
Joe Hershberger05622192011-10-18 10:06:59 +00002481 }
2482 if ($sign_off =~ /-by:$/i && $sign_off ne $ucfirst_sign_off) {
Tom Rini6b9709d2014-02-27 08:27:28 -05002483 if (WARN("BAD_SIGN_OFF",
2484 "'$ucfirst_sign_off' is the preferred signature form\n" . $herecurr) &&
2485 $fix) {
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02002486 $fixed[$fixlinenr] =
Tom Rini6b9709d2014-02-27 08:27:28 -05002487 "$ucfirst_sign_off $email";
2488 }
2489
Joe Hershberger05622192011-10-18 10:06:59 +00002490 }
2491 if (!defined $space_after || $space_after ne " ") {
Tom Rini6b9709d2014-02-27 08:27:28 -05002492 if (WARN("BAD_SIGN_OFF",
2493 "Use a single space after $ucfirst_sign_off\n" . $herecurr) &&
2494 $fix) {
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02002495 $fixed[$fixlinenr] =
Tom Rini6b9709d2014-02-27 08:27:28 -05002496 "$ucfirst_sign_off $email";
2497 }
Joe Hershberger05622192011-10-18 10:06:59 +00002498 }
2499
2500 my ($email_name, $email_address, $comment) = parse_email($email);
2501 my $suggested_email = format_email(($email_name, $email_address));
2502 if ($suggested_email eq "") {
2503 ERROR("BAD_SIGN_OFF",
2504 "Unrecognized email address: '$email'\n" . $herecurr);
2505 } else {
2506 my $dequoted = $suggested_email;
2507 $dequoted =~ s/^"//;
2508 $dequoted =~ s/" </ </;
2509 # Don't force email to have quotes
2510 # Allow just an angle bracketed address
2511 if ("$dequoted$comment" ne $email &&
2512 "<$email_address>$comment" ne $email &&
2513 "$suggested_email$comment" ne $email) {
2514 WARN("BAD_SIGN_OFF",
2515 "email address '$email' might be better as '$suggested_email$comment'\n" . $herecurr);
2516 }
2517 }
Tom Rini6b9709d2014-02-27 08:27:28 -05002518
2519# Check for duplicate signatures
2520 my $sig_nospace = $line;
2521 $sig_nospace =~ s/\s//g;
2522 $sig_nospace = lc($sig_nospace);
2523 if (defined $signatures{$sig_nospace}) {
2524 WARN("BAD_SIGN_OFF",
2525 "Duplicate signature\n" . $herecurr);
2526 } else {
2527 $signatures{$sig_nospace} = 1;
2528 }
Joe Hershberger05622192011-10-18 10:06:59 +00002529 }
2530
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02002531# Check email subject for common tools that don't need to be mentioned
2532 if ($in_header_lines &&
2533 $line =~ /^Subject:.*\b(?:checkpatch|sparse|smatch)\b[^:]/i) {
2534 WARN("EMAIL_SUBJECT",
2535 "A patch subject line should describe the change not the tool that found it\n" . $herecurr);
2536 }
2537
2538# Check for old stable address
2539 if ($line =~ /^\s*cc:\s*.*<?\bstable\@kernel\.org\b>?.*$/i) {
2540 ERROR("STABLE_ADDRESS",
2541 "The 'stable' address should be 'stable\@vger.kernel.org'\n" . $herecurr);
2542 }
2543
2544# Check for unwanted Gerrit info
2545 if ($in_commit_log && $line =~ /^\s*change-id:/i) {
2546 ERROR("GERRIT_CHANGE_ID",
2547 "Remove Gerrit Change-Id's before submitting upstream.\n" . $herecurr);
2548 }
2549
2550# Check if the commit log is in a possible stack dump
2551 if ($in_commit_log && !$commit_log_possible_stack_dump &&
2552 ($line =~ /^\s*(?:WARNING:|BUG:)/ ||
2553 $line =~ /^\s*\[\s*\d+\.\d{6,6}\s*\]/ ||
2554 # timestamp
2555 $line =~ /^\s*\[\<[0-9a-fA-F]{8,}\>\]/)) {
2556 # stack dump address
2557 $commit_log_possible_stack_dump = 1;
2558 }
2559
2560# Check for line lengths > 75 in commit log, warn once
2561 if ($in_commit_log && !$commit_log_long_line &&
2562 length($line) > 75 &&
2563 !($line =~ /^\s*[a-zA-Z0-9_\/\.]+\s+\|\s+\d+/ ||
2564 # file delta changes
2565 $line =~ /^\s*(?:[\w\.\-]+\/)++[\w\.\-]+:/ ||
2566 # filename then :
2567 $line =~ /^\s*(?:Fixes:|Link:)/i ||
2568 # A Fixes: or Link: line
2569 $commit_log_possible_stack_dump)) {
2570 WARN("COMMIT_LOG_LONG_LINE",
2571 "Possible unwrapped commit description (prefer a maximum 75 chars per line)\n" . $herecurr);
2572 $commit_log_long_line = 1;
2573 }
2574
2575# Reset possible stack dump if a blank line is found
2576 if ($in_commit_log && $commit_log_possible_stack_dump &&
2577 $line =~ /^\s*$/) {
2578 $commit_log_possible_stack_dump = 0;
2579 }
2580
2581# Check for git id commit length and improperly formed commit descriptions
2582 if ($in_commit_log && !$commit_log_possible_stack_dump &&
2583 $line !~ /^\s*(?:Link|Patchwork|http|https|BugLink):/i &&
2584 $line !~ /^This reverts commit [0-9a-f]{7,40}/ &&
2585 ($line =~ /\bcommit\s+[0-9a-f]{5,}\b/i ||
2586 ($line =~ /(?:\s|^)[0-9a-f]{12,40}(?:[\s"'\(\[]|$)/i &&
2587 $line !~ /[\<\[][0-9a-f]{12,40}[\>\]]/i &&
2588 $line !~ /\bfixes:\s*[0-9a-f]{12,40}/i))) {
2589 my $init_char = "c";
2590 my $orig_commit = "";
2591 my $short = 1;
2592 my $long = 0;
2593 my $case = 1;
2594 my $space = 1;
2595 my $hasdesc = 0;
2596 my $hasparens = 0;
2597 my $id = '0123456789ab';
2598 my $orig_desc = "commit description";
2599 my $description = "";
2600
2601 if ($line =~ /\b(c)ommit\s+([0-9a-f]{5,})\b/i) {
2602 $init_char = $1;
2603 $orig_commit = lc($2);
2604 } elsif ($line =~ /\b([0-9a-f]{12,40})\b/i) {
2605 $orig_commit = lc($1);
2606 }
2607
2608 $short = 0 if ($line =~ /\bcommit\s+[0-9a-f]{12,40}/i);
2609 $long = 1 if ($line =~ /\bcommit\s+[0-9a-f]{41,}/i);
2610 $space = 0 if ($line =~ /\bcommit [0-9a-f]/i);
2611 $case = 0 if ($line =~ /\b[Cc]ommit\s+[0-9a-f]{5,40}[^A-F]/);
2612 if ($line =~ /\bcommit\s+[0-9a-f]{5,}\s+\("([^"]+)"\)/i) {
2613 $orig_desc = $1;
2614 $hasparens = 1;
2615 } elsif ($line =~ /\bcommit\s+[0-9a-f]{5,}\s*$/i &&
2616 defined $rawlines[$linenr] &&
2617 $rawlines[$linenr] =~ /^\s*\("([^"]+)"\)/) {
2618 $orig_desc = $1;
2619 $hasparens = 1;
2620 } elsif ($line =~ /\bcommit\s+[0-9a-f]{5,}\s+\("[^"]+$/i &&
2621 defined $rawlines[$linenr] &&
2622 $rawlines[$linenr] =~ /^\s*[^"]+"\)/) {
2623 $line =~ /\bcommit\s+[0-9a-f]{5,}\s+\("([^"]+)$/i;
2624 $orig_desc = $1;
2625 $rawlines[$linenr] =~ /^\s*([^"]+)"\)/;
2626 $orig_desc .= " " . $1;
2627 $hasparens = 1;
2628 }
2629
2630 ($id, $description) = git_commit_info($orig_commit,
2631 $id, $orig_desc);
2632
2633 if (defined($id) &&
2634 ($short || $long || $space || $case || ($orig_desc ne $description) || !$hasparens)) {
2635 ERROR("GIT_COMMIT_ID",
2636 "Please use git commit description style 'commit <12+ chars of sha1> (\"<title line>\")' - ie: '${init_char}ommit $id (\"$description\")'\n" . $herecurr);
2637 }
2638 }
2639
2640# Check for added, moved or deleted files
2641 if (!$reported_maintainer_file && !$in_commit_log &&
2642 ($line =~ /^(?:new|deleted) file mode\s*\d+\s*$/ ||
2643 $line =~ /^rename (?:from|to) [\w\/\.\-]+\s*$/ ||
2644 ($line =~ /\{\s*([\w\/\.\-]*)\s*\=\>\s*([\w\/\.\-]*)\s*\}/ &&
2645 (defined($1) || defined($2))))) {
2646 $is_patch = 1;
2647 $reported_maintainer_file = 1;
2648 WARN("FILE_PATH_CHANGES",
2649 "added, moved or deleted file(s), does MAINTAINERS need updating?\n" . $herecurr);
2650 }
2651
Joe Hershberger05622192011-10-18 10:06:59 +00002652# Check for wrappage within a valid hunk of the file
2653 if ($realcnt != 0 && $line !~ m{^(?:\+|-| |\\ No newline|$)}) {
2654 ERROR("CORRUPTED_PATCH",
2655 "patch seems to be corrupt (line wrapped?)\n" .
2656 $herecurr) if (!$emitted_corrupt++);
2657 }
2658
Joe Hershberger05622192011-10-18 10:06:59 +00002659# UTF-8 regex found at http://www.w3.org/International/questions/qa-forms-utf-8.en.php
2660 if (($realfile =~ /^$/ || $line =~ /^\+/) &&
2661 $rawline !~ m/^$UTF8*$/) {
2662 my ($utf8_prefix) = ($rawline =~ /^($UTF8*)/);
2663
2664 my $blank = copy_spacing($rawline);
2665 my $ptr = substr($blank, 0, length($utf8_prefix)) . "^";
2666 my $hereptr = "$hereline$ptr\n";
2667
2668 CHK("INVALID_UTF8",
2669 "Invalid UTF-8, patch and commit message should be encoded in UTF-8\n" . $hereptr);
2670 }
2671
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00002672# Check if it's the start of a commit log
2673# (not a header line and we haven't seen the patch filename)
2674 if ($in_header_lines && $realfile =~ /^$/ &&
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02002675 !($rawline =~ /^\s+(?:\S|$)/ ||
2676 $rawline =~ /^(?:commit\b|from\b|[\w-]+:)/i)) {
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00002677 $in_header_lines = 0;
2678 $in_commit_log = 1;
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02002679 $has_commit_log = 1;
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00002680 }
2681
2682# Check if there is UTF-8 in a commit log when a mail header has explicitly
2683# declined it, i.e defined some charset where it is missing.
2684 if ($in_header_lines &&
2685 $rawline =~ /^Content-Type:.+charset="(.+)".*$/ &&
2686 $1 !~ /utf-8/i) {
2687 $non_utf8_charset = 1;
2688 }
2689
2690 if ($in_commit_log && $non_utf8_charset && $realfile =~ /^$/ &&
2691 $rawline =~ /$NON_ASCII_UTF8/) {
2692 WARN("UTF8_BEFORE_PATCH",
2693 "8-bit UTF-8 used in possible commit log\n" . $herecurr);
2694 }
2695
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02002696# Check for absolute kernel paths in commit message
2697 if ($tree && $in_commit_log) {
2698 while ($line =~ m{(?:^|\s)(/\S*)}g) {
2699 my $file = $1;
2700
2701 if ($file =~ m{^(.*?)(?::\d+)+:?$} &&
2702 check_absolute_file($1, $herecurr)) {
2703 #
2704 } else {
2705 check_absolute_file($file, $herecurr);
2706 }
2707 }
2708 }
2709
Dan Murphyc10e0f52017-01-31 14:15:53 -06002710# Check for various typo / spelling mistakes
2711 if (defined($misspellings) &&
2712 ($in_commit_log || $line =~ /^(?:\+|Subject:)/i)) {
2713 while ($rawline =~ /(?:^|[^a-z@])($misspellings)(?:\b|$|[^a-z@])/gi) {
2714 my $typo = $1;
2715 my $typo_fix = $spelling_fix{lc($typo)};
2716 $typo_fix = ucfirst($typo_fix) if ($typo =~ /^[A-Z]/);
2717 $typo_fix = uc($typo_fix) if ($typo =~ /^[A-Z]+$/);
2718 my $msg_type = \&WARN;
2719 $msg_type = \&CHK if ($file);
2720 if (&{$msg_type}("TYPO_SPELLING",
2721 "'$typo' may be misspelled - perhaps '$typo_fix'?\n" . $herecurr) &&
2722 $fix) {
2723 $fixed[$fixlinenr] =~ s/(^|[^A-Za-z@])($typo)($|[^A-Za-z@])/$1$typo_fix$3/;
2724 }
2725 }
2726 }
2727
Joe Hershberger05622192011-10-18 10:06:59 +00002728# ignore non-hunk lines and lines being removed
2729 next if (!$hunk_line || $line =~ /^-/);
2730
2731#trailing whitespace
2732 if ($line =~ /^\+.*\015/) {
2733 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
Tom Rini6b9709d2014-02-27 08:27:28 -05002734 if (ERROR("DOS_LINE_ENDINGS",
2735 "DOS line endings\n" . $herevet) &&
2736 $fix) {
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02002737 $fixed[$fixlinenr] =~ s/[\s\015]+$//;
Tom Rini6b9709d2014-02-27 08:27:28 -05002738 }
Joe Hershberger05622192011-10-18 10:06:59 +00002739 } elsif ($rawline =~ /^\+.*\S\s+$/ || $rawline =~ /^\+\s+$/) {
2740 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
Tom Rini6b9709d2014-02-27 08:27:28 -05002741 if (ERROR("TRAILING_WHITESPACE",
2742 "trailing whitespace\n" . $herevet) &&
2743 $fix) {
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02002744 $fixed[$fixlinenr] =~ s/\s+$//;
Tom Rini6b9709d2014-02-27 08:27:28 -05002745 }
2746
Joe Hershberger05622192011-10-18 10:06:59 +00002747 $rpt_cleaners = 1;
2748 }
2749
Tom Rini6b9709d2014-02-27 08:27:28 -05002750# Check for FSF mailing addresses.
2751 if ($rawline =~ /\bwrite to the Free/i ||
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02002752 $rawline =~ /\b675\s+Mass\s+Ave/i ||
Tom Rini6b9709d2014-02-27 08:27:28 -05002753 $rawline =~ /\b59\s+Temple\s+Pl/i ||
2754 $rawline =~ /\b51\s+Franklin\s+St/i) {
2755 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2756 my $msg_type = \&ERROR;
2757 $msg_type = \&CHK if ($file);
2758 &{$msg_type}("FSF_MAILING_ADDRESS",
2759 "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)
2760 }
2761
Joe Hershberger05622192011-10-18 10:06:59 +00002762# check for Kconfig help text having a real description
2763# Only applies when adding the entry originally, after that we do not have
2764# sufficient context to determine whether it is indeed long enough.
2765 if ($realfile =~ /Kconfig/ &&
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02002766 $line =~ /^\+\s*config\s+/) {
Joe Hershberger05622192011-10-18 10:06:59 +00002767 my $length = 0;
2768 my $cnt = $realcnt;
2769 my $ln = $linenr + 1;
2770 my $f;
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00002771 my $is_start = 0;
Joe Hershberger05622192011-10-18 10:06:59 +00002772 my $is_end = 0;
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00002773 for (; $cnt > 0 && defined $lines[$ln - 1]; $ln++) {
Joe Hershberger05622192011-10-18 10:06:59 +00002774 $f = $lines[$ln - 1];
2775 $cnt-- if ($lines[$ln - 1] !~ /^-/);
2776 $is_end = $lines[$ln - 1] =~ /^\+/;
Joe Hershberger05622192011-10-18 10:06:59 +00002777
2778 next if ($f =~ /^-/);
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02002779 last if (!$file && $f =~ /^\@\@/);
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00002780
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02002781 if ($lines[$ln - 1] =~ /^\+\s*(?:bool|tristate)\s*\"/) {
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00002782 $is_start = 1;
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02002783 } elsif ($lines[$ln - 1] =~ /^\+\s*(?:---)?help(?:---)?$/) {
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00002784 $length = -1;
2785 }
2786
Joe Hershberger05622192011-10-18 10:06:59 +00002787 $f =~ s/^.//;
2788 $f =~ s/#.*//;
2789 $f =~ s/^\s+//;
2790 next if ($f =~ /^$/);
2791 if ($f =~ /^\s*config\s/) {
2792 $is_end = 1;
2793 last;
2794 }
2795 $length++;
2796 }
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02002797 if ($is_start && $is_end && $length < $min_conf_desc_length) {
2798 WARN("CONFIG_DESCRIPTION",
2799 "please write a paragraph that describes the config symbol fully\n" . $herecurr);
2800 }
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00002801 #print "is_start<$is_start> is_end<$is_end> length<$length>\n";
2802 }
2803
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02002804# check for MAINTAINERS entries that don't have the right form
2805 if ($realfile =~ /^MAINTAINERS$/ &&
2806 $rawline =~ /^\+[A-Z]:/ &&
2807 $rawline !~ /^\+[A-Z]:\t\S/) {
2808 if (WARN("MAINTAINERS_STYLE",
2809 "MAINTAINERS entries use one tab after TYPE:\n" . $herecurr) &&
2810 $fix) {
2811 $fixed[$fixlinenr] =~ s/^(\+[A-Z]):\s*/$1:\t/;
2812 }
2813 }
2814
2815# discourage the use of boolean for type definition attributes of Kconfig options
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00002816 if ($realfile =~ /Kconfig/ &&
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02002817 $line =~ /^\+\s*\bboolean\b/) {
2818 WARN("CONFIG_TYPE_BOOLEAN",
2819 "Use of boolean is deprecated, please use bool instead.\n" . $herecurr);
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00002820 }
2821
2822 if (($realfile =~ /Makefile.*/ || $realfile =~ /Kbuild.*/) &&
2823 ($line =~ /\+(EXTRA_[A-Z]+FLAGS).*/)) {
2824 my $flag = $1;
2825 my $replacement = {
2826 'EXTRA_AFLAGS' => 'asflags-y',
2827 'EXTRA_CFLAGS' => 'ccflags-y',
2828 'EXTRA_CPPFLAGS' => 'cppflags-y',
2829 'EXTRA_LDFLAGS' => 'ldflags-y',
2830 };
2831
2832 WARN("DEPRECATED_VARIABLE",
2833 "Use of $flag is deprecated, please use \`$replacement->{$flag} instead.\n" . $herecurr) if ($replacement->{$flag});
Joe Hershberger05622192011-10-18 10:06:59 +00002834 }
2835
Tom Rini6b9709d2014-02-27 08:27:28 -05002836# check for DT compatible documentation
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02002837 if (defined $root &&
2838 (($realfile =~ /\.dtsi?$/ && $line =~ /^\+\s*compatible\s*=\s*\"/) ||
2839 ($realfile =~ /\.[ch]$/ && $line =~ /^\+.*\.compatible\s*=\s*\"/))) {
2840
Tom Rini6b9709d2014-02-27 08:27:28 -05002841 my @compats = $rawline =~ /\"([a-zA-Z0-9\-\,\.\+_]+)\"/g;
2842
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02002843 my $dt_path = $root . "/Documentation/devicetree/bindings/";
2844 my $vp_file = $dt_path . "vendor-prefixes.txt";
2845
Tom Rini6b9709d2014-02-27 08:27:28 -05002846 foreach my $compat (@compats) {
2847 my $compat2 = $compat;
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02002848 $compat2 =~ s/\,[a-zA-Z0-9]*\-/\,<\.\*>\-/;
2849 my $compat3 = $compat;
2850 $compat3 =~ s/\,([a-z]*)[0-9]*\-/\,$1<\.\*>\-/;
2851 `grep -Erq "$compat|$compat2|$compat3" $dt_path`;
Tom Rini6b9709d2014-02-27 08:27:28 -05002852 if ( $? >> 8 ) {
2853 WARN("UNDOCUMENTED_DT_STRING",
2854 "DT compatible string \"$compat\" appears un-documented -- check $dt_path\n" . $herecurr);
2855 }
2856
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02002857 next if $compat !~ /^([a-zA-Z0-9\-]+)\,/;
2858 my $vendor = $1;
2859 `grep -Eq "^$vendor\\b" $vp_file`;
Tom Rini6b9709d2014-02-27 08:27:28 -05002860 if ( $? >> 8 ) {
2861 WARN("UNDOCUMENTED_DT_STRING",
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02002862 "DT compatible string vendor \"$vendor\" appears un-documented -- check $vp_file\n" . $herecurr);
Tom Rini6b9709d2014-02-27 08:27:28 -05002863 }
2864 }
2865 }
2866
Joe Hershberger05622192011-10-18 10:06:59 +00002867# check we are in a valid source file if not then ignore this hunk
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02002868 next if ($realfile !~ /\.(h|c|s|S|sh|dtsi|dts)$/);
Joe Hershberger05622192011-10-18 10:06:59 +00002869
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02002870# line length limit (with some exclusions)
2871#
2872# There are a few types of lines that may extend beyond $max_line_length:
2873# logging functions like pr_info that end in a string
2874# lines with a single string
2875# #defines that are a single string
2876#
2877# There are 3 different line length message types:
2878# LONG_LINE_COMMENT a comment starts before but extends beyond $max_linelength
2879# LONG_LINE_STRING a string starts before but extends beyond $max_line_length
2880# LONG_LINE all other lines longer than $max_line_length
2881#
2882# if LONG_LINE is ignored, the other 2 types are also ignored
2883#
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00002884
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02002885 if ($line =~ /^\+/ && $length > $max_line_length) {
2886 my $msg_type = "LONG_LINE";
Joe Hershberger05622192011-10-18 10:06:59 +00002887
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02002888 # Check the allowed long line types first
2889
2890 # logging functions that end in a string that starts
2891 # before $max_line_length
2892 if ($line =~ /^\+\s*$logFunctions\s*\(\s*(?:(?:KERN_\S+\s*|[^"]*))?($String\s*(?:|,|\)\s*;)\s*)$/ &&
2893 length(expand_tabs(substr($line, 1, length($line) - length($1) - 1))) <= $max_line_length) {
2894 $msg_type = "";
2895
2896 # lines with only strings (w/ possible termination)
2897 # #defines with only strings
2898 } elsif ($line =~ /^\+\s*$String\s*(?:\s*|,|\)\s*;)\s*$/ ||
2899 $line =~ /^\+\s*#\s*define\s+\w+\s+$String$/) {
2900 $msg_type = "";
2901
2902 # EFI_GUID is another special case
2903 } elsif ($line =~ /^\+.*\bEFI_GUID\s*\(/) {
2904 $msg_type = "";
2905
2906 # Otherwise set the alternate message types
2907
2908 # a comment starts before $max_line_length
2909 } elsif ($line =~ /($;[\s$;]*)$/ &&
2910 length(expand_tabs(substr($line, 1, length($line) - length($1) - 1))) <= $max_line_length) {
2911 $msg_type = "LONG_LINE_COMMENT"
2912
2913 # a quoted string starts before $max_line_length
2914 } elsif ($sline =~ /\s*($String(?:\s*(?:\\|,\s*|\)\s*;\s*))?)$/ &&
2915 length(expand_tabs(substr($line, 1, length($line) - length($1) - 1))) <= $max_line_length) {
2916 $msg_type = "LONG_LINE_STRING"
Tom Rini6b9709d2014-02-27 08:27:28 -05002917 }
2918
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02002919 if ($msg_type ne "" &&
2920 (show_type("LONG_LINE") || show_type($msg_type))) {
2921 WARN($msg_type,
2922 "line over $max_line_length characters\n" . $herecurr);
2923 }
Joe Hershberger05622192011-10-18 10:06:59 +00002924 }
2925
2926# check for adding lines without a newline.
2927 if ($line =~ /^\+/ && defined $lines[$linenr] && $lines[$linenr] =~ /^\\ No newline at end of file/) {
2928 WARN("MISSING_EOF_NEWLINE",
2929 "adding a line without newline at end of file\n" . $herecurr);
2930 }
2931
2932# Blackfin: use hi/lo macros
2933 if ($realfile =~ m@arch/blackfin/.*\.S$@) {
2934 if ($line =~ /\.[lL][[:space:]]*=.*&[[:space:]]*0x[fF][fF][fF][fF]/) {
2935 my $herevet = "$here\n" . cat_vet($line) . "\n";
2936 ERROR("LO_MACRO",
2937 "use the LO() macro, not (... & 0xFFFF)\n" . $herevet);
2938 }
2939 if ($line =~ /\.[hH][[:space:]]*=.*>>[[:space:]]*16/) {
2940 my $herevet = "$here\n" . cat_vet($line) . "\n";
2941 ERROR("HI_MACRO",
2942 "use the HI() macro, not (... >> 16)\n" . $herevet);
2943 }
2944 }
2945
2946# check we are in a valid source file C or perl if not then ignore this hunk
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02002947 next if ($realfile !~ /\.(h|c|pl|dtsi|dts)$/);
Joe Hershberger05622192011-10-18 10:06:59 +00002948
2949# at the beginning of a line any tabs must come first and anything
2950# more than 8 must use tabs.
2951 if ($rawline =~ /^\+\s* \t\s*\S/ ||
2952 $rawline =~ /^\+\s* \s*/) {
2953 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
Joe Hershberger05622192011-10-18 10:06:59 +00002954 $rpt_cleaners = 1;
Tom Rini6b9709d2014-02-27 08:27:28 -05002955 if (ERROR("CODE_INDENT",
2956 "code indent should use tabs where possible\n" . $herevet) &&
2957 $fix) {
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02002958 $fixed[$fixlinenr] =~ s/^\+([ \t]+)/"\+" . tabify($1)/e;
Tom Rini6b9709d2014-02-27 08:27:28 -05002959 }
Joe Hershberger05622192011-10-18 10:06:59 +00002960 }
2961
2962# check for space before tabs.
2963 if ($rawline =~ /^\+/ && $rawline =~ / \t/) {
2964 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
Tom Rini6b9709d2014-02-27 08:27:28 -05002965 if (WARN("SPACE_BEFORE_TAB",
2966 "please, no space before tabs\n" . $herevet) &&
2967 $fix) {
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02002968 while ($fixed[$fixlinenr] =~
Joe Perchese3a4fac2014-09-23 12:41:02 +02002969 s/(^\+.*) {8,8}\t/$1\t\t/) {}
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02002970 while ($fixed[$fixlinenr] =~
Tom Rini6b9709d2014-02-27 08:27:28 -05002971 s/(^\+.*) +\t/$1\t/) {}
2972 }
Joe Hershberger05622192011-10-18 10:06:59 +00002973 }
2974
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00002975# check for && or || at the start of a line
2976 if ($rawline =~ /^\+\s*(&&|\|\|)/) {
2977 CHK("LOGICAL_CONTINUATIONS",
2978 "Logical continuations should be on the previous line\n" . $hereprev);
2979 }
2980
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02002981# check indentation starts on a tab stop
2982 if ($^V && $^V ge 5.10.0 &&
2983 $sline =~ /^\+\t+( +)(?:$c90_Keywords\b|\{\s*$|\}\s*(?:else\b|while\b|\s*$))/) {
2984 my $indent = length($1);
2985 if ($indent % 8) {
2986 if (WARN("TABSTOP",
2987 "Statements should start on a tabstop\n" . $herecurr) &&
2988 $fix) {
2989 $fixed[$fixlinenr] =~ s@(^\+\t+) +@$1 . "\t" x ($indent/8)@e;
2990 }
2991 }
2992 }
2993
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00002994# check multi-line statement indentation matches previous line
2995 if ($^V && $^V ge 5.10.0 &&
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02002996 $prevline =~ /^\+([ \t]*)((?:$c90_Keywords(?:\s+if)\s*)|(?:$Declare\s*)?(?:$Ident|\(\s*\*\s*$Ident\s*\))\s*|(?:\*\s*)*$Lval\s*=\s*$Ident\s*)\(.*(\&\&|\|\||,)\s*$/) {
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00002997 $prevline =~ /^\+(\t*)(.*)$/;
2998 my $oldindent = $1;
2999 my $rest = $2;
3000
3001 my $pos = pos_last_openparen($rest);
3002 if ($pos >= 0) {
3003 $line =~ /^(\+| )([ \t]*)/;
3004 my $newindent = $2;
3005
3006 my $goodtabindent = $oldindent .
3007 "\t" x ($pos / 8) .
3008 " " x ($pos % 8);
3009 my $goodspaceindent = $oldindent . " " x $pos;
3010
3011 if ($newindent ne $goodtabindent &&
3012 $newindent ne $goodspaceindent) {
Tom Rini6b9709d2014-02-27 08:27:28 -05003013
3014 if (CHK("PARENTHESIS_ALIGNMENT",
3015 "Alignment should match open parenthesis\n" . $hereprev) &&
3016 $fix && $line =~ /^\+/) {
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02003017 $fixed[$fixlinenr] =~
Tom Rini6b9709d2014-02-27 08:27:28 -05003018 s/^\+[ \t]*/\+$goodtabindent/;
3019 }
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00003020 }
3021 }
3022 }
3023
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02003024# check for space after cast like "(int) foo" or "(struct foo) bar"
3025# avoid checking a few false positives:
3026# "sizeof(<type>)" or "__alignof__(<type>)"
3027# function pointer declarations like "(*foo)(int) = bar;"
3028# structure definitions like "(struct foo) { 0 };"
3029# multiline macros that define functions
3030# known attributes or the __attribute__ keyword
3031 if ($line =~ /^\+(.*)\(\s*$Type\s*\)([ \t]++)((?![={]|\\$|$Attribute|__attribute__))/ &&
3032 (!defined($1) || $1 !~ /\b(?:sizeof|__alignof__)\s*$/)) {
Tom Rini6b9709d2014-02-27 08:27:28 -05003033 if (CHK("SPACING",
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02003034 "No space is necessary after a cast\n" . $herecurr) &&
Tom Rini6b9709d2014-02-27 08:27:28 -05003035 $fix) {
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02003036 $fixed[$fixlinenr] =~
3037 s/(\(\s*$Type\s*\))[ \t]+/$1/;
Tom Rini6b9709d2014-02-27 08:27:28 -05003038 }
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00003039 }
3040
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02003041# Block comment styles
3042# Networking with an initial /*
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00003043 if ($realfile =~ m@^(drivers/net/|net/)@ &&
Tom Rini6b9709d2014-02-27 08:27:28 -05003044 $prevrawline =~ /^\+[ \t]*\/\*[ \t]*$/ &&
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02003045 $rawline =~ /^\+[ \t]*\*/ &&
3046 $realline > 2) {
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00003047 WARN("NETWORKING_BLOCK_COMMENT_STYLE",
3048 "networking block comments don't use an empty /* line, use /* Comment...\n" . $hereprev);
3049 }
3050
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02003051# Block comments use * on subsequent lines
3052 if ($prevline =~ /$;[ \t]*$/ && #ends in comment
3053 $prevrawline =~ /^\+.*?\/\*/ && #starting /*
Tom Rini6b9709d2014-02-27 08:27:28 -05003054 $prevrawline !~ /\*\/[ \t]*$/ && #no trailing */
3055 $rawline =~ /^\+/ && #line is new
3056 $rawline !~ /^\+[ \t]*\*/) { #no leading *
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02003057 WARN("BLOCK_COMMENT_STYLE",
3058 "Block comments use * on subsequent lines\n" . $hereprev);
Tom Rini6b9709d2014-02-27 08:27:28 -05003059 }
3060
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02003061# Block comments use */ on trailing lines
3062 if ($rawline !~ m@^\+[ \t]*\*/[ \t]*$@ && #trailing */
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00003063 $rawline !~ m@^\+.*/\*.*\*/[ \t]*$@ && #inline /*...*/
3064 $rawline !~ m@^\+.*\*{2,}/[ \t]*$@ && #trailing **/
3065 $rawline =~ m@^\+[ \t]*.+\*\/[ \t]*$@) { #non blank */
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02003066 WARN("BLOCK_COMMENT_STYLE",
3067 "Block comments use a trailing */ on a separate line\n" . $herecurr);
3068 }
3069
3070# Block comment * alignment
3071 if ($prevline =~ /$;[ \t]*$/ && #ends in comment
3072 $line =~ /^\+[ \t]*$;/ && #leading comment
3073 $rawline =~ /^\+[ \t]*\*/ && #leading *
3074 (($prevrawline =~ /^\+.*?\/\*/ && #leading /*
3075 $prevrawline !~ /\*\/[ \t]*$/) || #no trailing */
3076 $prevrawline =~ /^\+[ \t]*\*/)) { #leading *
3077 my $oldindent;
3078 $prevrawline =~ m@^\+([ \t]*/?)\*@;
3079 if (defined($1)) {
3080 $oldindent = expand_tabs($1);
3081 } else {
3082 $prevrawline =~ m@^\+(.*/?)\*@;
3083 $oldindent = expand_tabs($1);
3084 }
3085 $rawline =~ m@^\+([ \t]*)\*@;
3086 my $newindent = $1;
3087 $newindent = expand_tabs($newindent);
3088 if (length($oldindent) ne length($newindent)) {
3089 WARN("BLOCK_COMMENT_STYLE",
3090 "Block comments should align the * on each line\n" . $hereprev);
3091 }
3092 }
3093
3094# check for missing blank lines after struct/union declarations
3095# with exceptions for various attributes and macros
3096 if ($prevline =~ /^[\+ ]};?\s*$/ &&
3097 $line =~ /^\+/ &&
3098 !($line =~ /^\+\s*$/ ||
3099 $line =~ /^\+\s*EXPORT_SYMBOL/ ||
3100 $line =~ /^\+\s*MODULE_/i ||
3101 $line =~ /^\+\s*\#\s*(?:end|elif|else)/ ||
3102 $line =~ /^\+[a-z_]*init/ ||
3103 $line =~ /^\+\s*(?:static\s+)?[A-Z_]*ATTR/ ||
3104 $line =~ /^\+\s*DECLARE/ ||
3105 $line =~ /^\+\s*__setup/)) {
3106 if (CHK("LINE_SPACING",
3107 "Please use a blank line after function/struct/union/enum declarations\n" . $hereprev) &&
3108 $fix) {
3109 fix_insert_line($fixlinenr, "\+");
3110 }
3111 }
3112
3113# check for multiple consecutive blank lines
3114 if ($prevline =~ /^[\+ ]\s*$/ &&
3115 $line =~ /^\+\s*$/ &&
3116 $last_blank_line != ($linenr - 1)) {
3117 if (CHK("LINE_SPACING",
3118 "Please don't use multiple blank lines\n" . $hereprev) &&
3119 $fix) {
3120 fix_delete_line($fixlinenr, $rawline);
3121 }
3122
3123 $last_blank_line = $linenr;
3124 }
3125
3126# check for missing blank lines after declarations
3127 if ($sline =~ /^\+\s+\S/ && #Not at char 1
3128 # actual declarations
3129 ($prevline =~ /^\+\s+$Declare\s*$Ident\s*[=,;:\[]/ ||
3130 # function pointer declarations
3131 $prevline =~ /^\+\s+$Declare\s*\(\s*\*\s*$Ident\s*\)\s*[=,;:\[\(]/ ||
3132 # foo bar; where foo is some local typedef or #define
3133 $prevline =~ /^\+\s+$Ident(?:\s+|\s*\*\s*)$Ident\s*[=,;\[]/ ||
3134 # known declaration macros
3135 $prevline =~ /^\+\s+$declaration_macros/) &&
3136 # for "else if" which can look like "$Ident $Ident"
3137 !($prevline =~ /^\+\s+$c90_Keywords\b/ ||
3138 # other possible extensions of declaration lines
3139 $prevline =~ /(?:$Compare|$Assignment|$Operators)\s*$/ ||
3140 # not starting a section or a macro "\" extended line
3141 $prevline =~ /(?:\{\s*|\\)$/) &&
3142 # looks like a declaration
3143 !($sline =~ /^\+\s+$Declare\s*$Ident\s*[=,;:\[]/ ||
3144 # function pointer declarations
3145 $sline =~ /^\+\s+$Declare\s*\(\s*\*\s*$Ident\s*\)\s*[=,;:\[\(]/ ||
3146 # foo bar; where foo is some local typedef or #define
3147 $sline =~ /^\+\s+$Ident(?:\s+|\s*\*\s*)$Ident\s*[=,;\[]/ ||
3148 # known declaration macros
3149 $sline =~ /^\+\s+$declaration_macros/ ||
3150 # start of struct or union or enum
3151 $sline =~ /^\+\s+(?:union|struct|enum|typedef)\b/ ||
3152 # start or end of block or continuation of declaration
3153 $sline =~ /^\+\s+(?:$|[\{\}\.\#\"\?\:\(\[])/ ||
3154 # bitfield continuation
3155 $sline =~ /^\+\s+$Ident\s*:\s*\d+\s*[,;]/ ||
3156 # other possible extensions of declaration lines
3157 $sline =~ /^\+\s+\(?\s*(?:$Compare|$Assignment|$Operators)/) &&
3158 # indentation of previous and current line are the same
3159 (($prevline =~ /\+(\s+)\S/) && $sline =~ /^\+$1\S/)) {
3160 if (WARN("LINE_SPACING",
3161 "Missing a blank line after declarations\n" . $hereprev) &&
3162 $fix) {
3163 fix_insert_line($fixlinenr, "\+");
3164 }
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00003165 }
3166
Joe Hershberger05622192011-10-18 10:06:59 +00003167# check for spaces at the beginning of a line.
3168# Exceptions:
3169# 1) within comments
3170# 2) indented preprocessor commands
3171# 3) hanging labels
Tom Rini6b9709d2014-02-27 08:27:28 -05003172 if ($rawline =~ /^\+ / && $line !~ /^\+ *(?:$;|#|$Ident:)/) {
Joe Hershberger05622192011-10-18 10:06:59 +00003173 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
Tom Rini6b9709d2014-02-27 08:27:28 -05003174 if (WARN("LEADING_SPACE",
3175 "please, no spaces at the start of a line\n" . $herevet) &&
3176 $fix) {
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02003177 $fixed[$fixlinenr] =~ s/^\+([ \t]+)/"\+" . tabify($1)/e;
Tom Rini6b9709d2014-02-27 08:27:28 -05003178 }
Joe Hershberger05622192011-10-18 10:06:59 +00003179 }
3180
3181# check we are in a valid C source file if not then ignore this hunk
3182 next if ($realfile !~ /\.(h|c)$/);
3183
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02003184# check if this appears to be the start function declaration, save the name
3185 if ($sline =~ /^\+\{\s*$/ &&
3186 $prevline =~ /^\+(?:(?:(?:$Storage|$Inline)\s*)*\s*$Type\s*)?($Ident)\(/) {
3187 $context_function = $1;
3188 }
3189
3190# check if this appears to be the end of function declaration
3191 if ($sline =~ /^\+\}\s*$/) {
3192 undef $context_function;
3193 }
3194
3195# check indentation of any line with a bare else
3196# (but not if it is a multiple line "if (foo) return bar; else return baz;")
3197# if the previous line is a break or return and is indented 1 tab more...
3198 if ($sline =~ /^\+([\t]+)(?:}[ \t]*)?else(?:[ \t]*{)?\s*$/) {
3199 my $tabs = length($1) + 1;
3200 if ($prevline =~ /^\+\t{$tabs,$tabs}break\b/ ||
3201 ($prevline =~ /^\+\t{$tabs,$tabs}return\b/ &&
3202 defined $lines[$linenr] &&
3203 $lines[$linenr] !~ /^[ \+]\t{$tabs,$tabs}return/)) {
3204 WARN("UNNECESSARY_ELSE",
3205 "else is not generally useful after a break or return\n" . $hereprev);
3206 }
3207 }
3208
3209# check indentation of a line with a break;
3210# if the previous line is a goto or return and is indented the same # of tabs
3211 if ($sline =~ /^\+([\t]+)break\s*;\s*$/) {
3212 my $tabs = $1;
3213 if ($prevline =~ /^\+$tabs(?:goto|return)\b/) {
3214 WARN("UNNECESSARY_BREAK",
3215 "break is not useful after a goto or return\n" . $hereprev);
3216 }
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00003217 }
3218
Joe Hershberger05622192011-10-18 10:06:59 +00003219# check for RCS/CVS revision markers
3220 if ($rawline =~ /^\+.*\$(Revision|Log|Id)(?:\$|)/) {
3221 WARN("CVS_KEYWORD",
3222 "CVS style keyword markers, these will _not_ be updated\n". $herecurr);
3223 }
3224
3225# Blackfin: don't use __builtin_bfin_[cs]sync
3226 if ($line =~ /__builtin_bfin_csync/) {
3227 my $herevet = "$here\n" . cat_vet($line) . "\n";
3228 ERROR("CSYNC",
3229 "use the CSYNC() macro in asm/blackfin.h\n" . $herevet);
3230 }
3231 if ($line =~ /__builtin_bfin_ssync/) {
3232 my $herevet = "$here\n" . cat_vet($line) . "\n";
3233 ERROR("SSYNC",
3234 "use the SSYNC() macro in asm/blackfin.h\n" . $herevet);
3235 }
3236
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00003237# check for old HOTPLUG __dev<foo> section markings
3238 if ($line =~ /\b(__dev(init|exit)(data|const|))\b/) {
3239 WARN("HOTPLUG_SECTION",
3240 "Using $1 is unnecessary\n" . $herecurr);
3241 }
3242
Joe Hershberger05622192011-10-18 10:06:59 +00003243# Check for potential 'bare' types
3244 my ($stat, $cond, $line_nr_next, $remain_next, $off_next,
3245 $realline_next);
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00003246#print "LINE<$line>\n";
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02003247 if ($linenr > $suppress_statement &&
Tom Rini6b9709d2014-02-27 08:27:28 -05003248 $realcnt && $sline =~ /.\s*\S/) {
Joe Hershberger05622192011-10-18 10:06:59 +00003249 ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
3250 ctx_statement_block($linenr, $realcnt, 0);
3251 $stat =~ s/\n./\n /g;
3252 $cond =~ s/\n./\n /g;
3253
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00003254#print "linenr<$linenr> <$stat>\n";
3255 # If this statement has no statement boundaries within
3256 # it there is no point in retrying a statement scan
3257 # until we hit end of it.
3258 my $frag = $stat; $frag =~ s/;+\s*$//;
3259 if ($frag !~ /(?:{|;)/) {
3260#print "skip<$line_nr_next>\n";
3261 $suppress_statement = $line_nr_next;
3262 }
3263
Joe Hershberger05622192011-10-18 10:06:59 +00003264 # Find the real next line.
3265 $realline_next = $line_nr_next;
3266 if (defined $realline_next &&
3267 (!defined $lines[$realline_next - 1] ||
3268 substr($lines[$realline_next - 1], $off_next) =~ /^\s*$/)) {
3269 $realline_next++;
3270 }
3271
3272 my $s = $stat;
3273 $s =~ s/{.*$//s;
3274
3275 # Ignore goto labels.
3276 if ($s =~ /$Ident:\*$/s) {
3277
3278 # Ignore functions being called
3279 } elsif ($s =~ /^.\s*$Ident\s*\(/s) {
3280
3281 } elsif ($s =~ /^.\s*else\b/s) {
3282
3283 # declarations always start with types
3284 } 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) {
3285 my $type = $1;
3286 $type =~ s/\s+/ /g;
3287 possible($type, "A:" . $s);
3288
3289 # definitions in global scope can only start with types
3290 } elsif ($s =~ /^.(?:$Storage\s+)?(?:$Inline\s+)?(?:const\s+)?($Ident)\b\s*(?!:)/s) {
3291 possible($1, "B:" . $s);
3292 }
3293
3294 # any (foo ... *) is a pointer cast, and foo is a type
3295 while ($s =~ /\(($Ident)(?:\s+$Sparse)*[\s\*]+\s*\)/sg) {
3296 possible($1, "C:" . $s);
3297 }
3298
3299 # Check for any sort of function declaration.
3300 # int foo(something bar, other baz);
3301 # void (*store_gdt)(x86_descr_ptr *);
3302 if ($prev_values eq 'E' && $s =~ /^(.(?:typedef\s*)?(?:(?:$Storage|$Inline)\s*)*\s*$Type\s*(?:\b$Ident|\(\*\s*$Ident\))\s*)\(/s) {
3303 my ($name_len) = length($1);
3304
3305 my $ctx = $s;
3306 substr($ctx, 0, $name_len + 1, '');
3307 $ctx =~ s/\)[^\)]*$//;
3308
3309 for my $arg (split(/\s*,\s*/, $ctx)) {
3310 if ($arg =~ /^(?:const\s+)?($Ident)(?:\s+$Sparse)*\s*\**\s*(:?\b$Ident)?$/s || $arg =~ /^($Ident)$/s) {
3311
3312 possible($1, "D:" . $s);
3313 }
3314 }
3315 }
3316
3317 }
3318
3319#
3320# Checks which may be anchored in the context.
3321#
3322
3323# Check for switch () and associated case and default
3324# statements should be at the same indent.
3325 if ($line=~/\bswitch\s*\(.*\)/) {
3326 my $err = '';
3327 my $sep = '';
3328 my @ctx = ctx_block_outer($linenr, $realcnt);
3329 shift(@ctx);
3330 for my $ctx (@ctx) {
3331 my ($clen, $cindent) = line_stats($ctx);
3332 if ($ctx =~ /^\+\s*(case\s+|default:)/ &&
3333 $indent != $cindent) {
3334 $err .= "$sep$ctx\n";
3335 $sep = '';
3336 } else {
3337 $sep = "[...]\n";
3338 }
3339 }
3340 if ($err ne '') {
3341 ERROR("SWITCH_CASE_INDENT_LEVEL",
3342 "switch and case should be at the same indent\n$hereline$err");
3343 }
3344 }
3345
3346# if/while/etc brace do not go on next line, unless defining a do while loop,
3347# or if that brace on the next line is for something else
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02003348 if ($line =~ /(.*)\b((?:if|while|for|switch|(?:[a-z_]+|)for_each[a-z_]+)\s*\(|do\b|else\b)/ && $line !~ /^.\s*\#/) {
Joe Hershberger05622192011-10-18 10:06:59 +00003349 my $pre_ctx = "$1$2";
3350
3351 my ($level, @ctx) = ctx_statement_level($linenr, $realcnt, 0);
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00003352
3353 if ($line =~ /^\+\t{6,}/) {
3354 WARN("DEEP_INDENTATION",
3355 "Too many leading tabs - consider code refactoring\n" . $herecurr);
3356 }
3357
Joe Hershberger05622192011-10-18 10:06:59 +00003358 my $ctx_cnt = $realcnt - $#ctx - 1;
3359 my $ctx = join("\n", @ctx);
3360
3361 my $ctx_ln = $linenr;
3362 my $ctx_skip = $realcnt;
3363
3364 while ($ctx_skip > $ctx_cnt || ($ctx_skip == $ctx_cnt &&
3365 defined $lines[$ctx_ln - 1] &&
3366 $lines[$ctx_ln - 1] =~ /^-/)) {
3367 ##print "SKIP<$ctx_skip> CNT<$ctx_cnt>\n";
3368 $ctx_skip-- if (!defined $lines[$ctx_ln - 1] || $lines[$ctx_ln - 1] !~ /^-/);
3369 $ctx_ln++;
3370 }
3371
3372 #print "realcnt<$realcnt> ctx_cnt<$ctx_cnt>\n";
3373 #print "pre<$pre_ctx>\nline<$line>\nctx<$ctx>\nnext<$lines[$ctx_ln - 1]>\n";
3374
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02003375 if ($ctx !~ /{\s*/ && defined($lines[$ctx_ln - 1]) && $lines[$ctx_ln - 1] =~ /^\+\s*{/) {
Joe Hershberger05622192011-10-18 10:06:59 +00003376 ERROR("OPEN_BRACE",
3377 "that open brace { should be on the previous line\n" .
3378 "$here\n$ctx\n$rawlines[$ctx_ln - 1]\n");
3379 }
3380 if ($level == 0 && $pre_ctx !~ /}\s*while\s*\($/ &&
3381 $ctx =~ /\)\s*\;\s*$/ &&
3382 defined $lines[$ctx_ln - 1])
3383 {
3384 my ($nlength, $nindent) = line_stats($lines[$ctx_ln - 1]);
3385 if ($nindent > $indent) {
3386 WARN("TRAILING_SEMICOLON",
3387 "trailing semicolon indicates no statements, indent implies otherwise\n" .
3388 "$here\n$ctx\n$rawlines[$ctx_ln - 1]\n");
3389 }
3390 }
3391 }
3392
3393# Check relative indent for conditionals and blocks.
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02003394 if ($line =~ /\b(?:(?:if|while|for|(?:[a-z_]+|)for_each[a-z_]+)\s*\(|(?:do|else)\b)/ && $line !~ /^.\s*#/ && $line !~ /\}\s*while\s*/) {
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00003395 ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
3396 ctx_statement_block($linenr, $realcnt, 0)
3397 if (!defined $stat);
Joe Hershberger05622192011-10-18 10:06:59 +00003398 my ($s, $c) = ($stat, $cond);
3399
3400 substr($s, 0, length($c), '');
3401
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02003402 # remove inline comments
3403 $s =~ s/$;/ /g;
3404 $c =~ s/$;/ /g;
Joe Hershberger05622192011-10-18 10:06:59 +00003405
3406 # Find out how long the conditional actually is.
3407 my @newlines = ($c =~ /\n/gs);
3408 my $cond_lines = 1 + $#newlines;
3409
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02003410 # Make sure we remove the line prefixes as we have
3411 # none on the first line, and are going to readd them
3412 # where necessary.
3413 $s =~ s/\n./\n/gs;
3414 while ($s =~ /\n\s+\\\n/) {
3415 $cond_lines += $s =~ s/\n\s+\\\n/\n/g;
3416 }
3417
Joe Hershberger05622192011-10-18 10:06:59 +00003418 # We want to check the first line inside the block
3419 # starting at the end of the conditional, so remove:
3420 # 1) any blank line termination
3421 # 2) any opening brace { on end of the line
3422 # 3) any do (...) {
3423 my $continuation = 0;
3424 my $check = 0;
3425 $s =~ s/^.*\bdo\b//;
3426 $s =~ s/^\s*{//;
3427 if ($s =~ s/^\s*\\//) {
3428 $continuation = 1;
3429 }
3430 if ($s =~ s/^\s*?\n//) {
3431 $check = 1;
3432 $cond_lines++;
3433 }
3434
3435 # Also ignore a loop construct at the end of a
3436 # preprocessor statement.
3437 if (($prevline =~ /^.\s*#\s*define\s/ ||
3438 $prevline =~ /\\\s*$/) && $continuation == 0) {
3439 $check = 0;
3440 }
3441
3442 my $cond_ptr = -1;
3443 $continuation = 0;
3444 while ($cond_ptr != $cond_lines) {
3445 $cond_ptr = $cond_lines;
3446
3447 # If we see an #else/#elif then the code
3448 # is not linear.
3449 if ($s =~ /^\s*\#\s*(?:else|elif)/) {
3450 $check = 0;
3451 }
3452
3453 # Ignore:
3454 # 1) blank lines, they should be at 0,
3455 # 2) preprocessor lines, and
3456 # 3) labels.
3457 if ($continuation ||
3458 $s =~ /^\s*?\n/ ||
3459 $s =~ /^\s*#\s*?/ ||
3460 $s =~ /^\s*$Ident\s*:/) {
3461 $continuation = ($s =~ /^.*?\\\n/) ? 1 : 0;
3462 if ($s =~ s/^.*?\n//) {
3463 $cond_lines++;
3464 }
3465 }
3466 }
3467
3468 my (undef, $sindent) = line_stats("+" . $s);
3469 my $stat_real = raw_line($linenr, $cond_lines);
3470
3471 # Check if either of these lines are modified, else
3472 # this is not this patch's fault.
3473 if (!defined($stat_real) ||
3474 $stat !~ /^\+/ && $stat_real !~ /^\+/) {
3475 $check = 0;
3476 }
3477 if (defined($stat_real) && $cond_lines > 1) {
3478 $stat_real = "[...]\n$stat_real";
3479 }
3480
3481 #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";
3482
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02003483 if ($check && $s ne '' &&
3484 (($sindent % 8) != 0 ||
3485 ($sindent < $indent) ||
3486 ($sindent == $indent &&
3487 ($s !~ /^\s*(?:\}|\{|else\b)/)) ||
3488 ($sindent > $indent + 8))) {
Joe Hershberger05622192011-10-18 10:06:59 +00003489 WARN("SUSPECT_CODE_INDENT",
3490 "suspect code indent for conditional statements ($indent, $sindent)\n" . $herecurr . "$stat_real\n");
3491 }
3492 }
3493
3494 # Track the 'values' across context and added lines.
3495 my $opline = $line; $opline =~ s/^./ /;
3496 my ($curr_values, $curr_vars) =
3497 annotate_values($opline . "\n", $prev_values);
3498 $curr_values = $prev_values . $curr_values;
3499 if ($dbg_values) {
3500 my $outline = $opline; $outline =~ s/\t/ /g;
3501 print "$linenr > .$outline\n";
3502 print "$linenr > $curr_values\n";
3503 print "$linenr > $curr_vars\n";
3504 }
3505 $prev_values = substr($curr_values, -1);
3506
3507#ignore lines not being added
Tom Rini6b9709d2014-02-27 08:27:28 -05003508 next if ($line =~ /^[^\+]/);
Joe Hershberger05622192011-10-18 10:06:59 +00003509
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02003510# check for dereferences that span multiple lines
3511 if ($prevline =~ /^\+.*$Lval\s*(?:\.|->)\s*$/ &&
3512 $line =~ /^\+\s*(?!\#\s*(?!define\s+|if))\s*$Lval/) {
3513 $prevline =~ /($Lval\s*(?:\.|->))\s*$/;
3514 my $ref = $1;
3515 $line =~ /^.\s*($Lval)/;
3516 $ref .= $1;
3517 $ref =~ s/\s//g;
3518 WARN("MULTILINE_DEREFERENCE",
3519 "Avoid multiple line dereference - prefer '$ref'\n" . $hereprev);
3520 }
3521
3522# check for declarations of signed or unsigned without int
3523 while ($line =~ m{\b($Declare)\s*(?!char\b|short\b|int\b|long\b)\s*($Ident)?\s*[=,;\[\)\(]}g) {
3524 my $type = $1;
3525 my $var = $2;
3526 $var = "" if (!defined $var);
3527 if ($type =~ /^(?:(?:$Storage|$Inline|$Attribute)\s+)*((?:un)?signed)((?:\s*\*)*)\s*$/) {
3528 my $sign = $1;
3529 my $pointer = $2;
3530
3531 $pointer = "" if (!defined $pointer);
3532
3533 if (WARN("UNSPECIFIED_INT",
3534 "Prefer '" . trim($sign) . " int" . rtrim($pointer) . "' to bare use of '$sign" . rtrim($pointer) . "'\n" . $herecurr) &&
3535 $fix) {
3536 my $decl = trim($sign) . " int ";
3537 my $comp_pointer = $pointer;
3538 $comp_pointer =~ s/\s//g;
3539 $decl .= $comp_pointer;
3540 $decl = rtrim($decl) if ($var eq "");
3541 $fixed[$fixlinenr] =~ s@\b$sign\s*\Q$pointer\E\s*$var\b@$decl$var@;
3542 }
3543 }
3544 }
3545
Joe Hershberger05622192011-10-18 10:06:59 +00003546# TEST: allow direct testing of the type matcher.
3547 if ($dbg_type) {
3548 if ($line =~ /^.\s*$Declare\s*$/) {
3549 ERROR("TEST_TYPE",
3550 "TEST: is type\n" . $herecurr);
3551 } elsif ($dbg_type > 1 && $line =~ /^.+($Declare)/) {
3552 ERROR("TEST_NOT_TYPE",
3553 "TEST: is not type ($1 is)\n". $herecurr);
3554 }
3555 next;
3556 }
3557# TEST: allow direct testing of the attribute matcher.
3558 if ($dbg_attr) {
3559 if ($line =~ /^.\s*$Modifier\s*$/) {
3560 ERROR("TEST_ATTR",
3561 "TEST: is attr\n" . $herecurr);
3562 } elsif ($dbg_attr > 1 && $line =~ /^.+($Modifier)/) {
3563 ERROR("TEST_NOT_ATTR",
3564 "TEST: is not attr ($1 is)\n". $herecurr);
3565 }
3566 next;
3567 }
3568
3569# check for initialisation to aggregates open brace on the next line
3570 if ($line =~ /^.\s*{/ &&
3571 $prevline =~ /(?:^|[^=])=\s*$/) {
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02003572 if (ERROR("OPEN_BRACE",
3573 "that open brace { should be on the previous line\n" . $hereprev) &&
3574 $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
3575 fix_delete_line($fixlinenr - 1, $prevrawline);
3576 fix_delete_line($fixlinenr, $rawline);
3577 my $fixedline = $prevrawline;
3578 $fixedline =~ s/\s*=\s*$/ = {/;
3579 fix_insert_line($fixlinenr, $fixedline);
3580 $fixedline = $line;
3581 $fixedline =~ s/^(.\s*)\{\s*/$1/;
3582 fix_insert_line($fixlinenr, $fixedline);
3583 }
Joe Hershberger05622192011-10-18 10:06:59 +00003584 }
3585
3586#
3587# Checks which are anchored on the added line.
3588#
3589
3590# check for malformed paths in #include statements (uses RAW line)
3591 if ($rawline =~ m{^.\s*\#\s*include\s+[<"](.*)[">]}) {
3592 my $path = $1;
3593 if ($path =~ m{//}) {
3594 ERROR("MALFORMED_INCLUDE",
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00003595 "malformed #include filename\n" . $herecurr);
3596 }
3597 if ($path =~ "^uapi/" && $realfile =~ m@\binclude/uapi/@) {
3598 ERROR("UAPI_INCLUDE",
3599 "No #include in ...include/uapi/... should use a uapi/ path prefix\n" . $herecurr);
Joe Hershberger05622192011-10-18 10:06:59 +00003600 }
3601 }
3602
3603# no C99 // comments
3604 if ($line =~ m{//}) {
Tom Rini6b9709d2014-02-27 08:27:28 -05003605 if (ERROR("C99_COMMENTS",
3606 "do not use C99 // comments\n" . $herecurr) &&
3607 $fix) {
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02003608 my $line = $fixed[$fixlinenr];
Tom Rini6b9709d2014-02-27 08:27:28 -05003609 if ($line =~ /\/\/(.*)$/) {
3610 my $comment = trim($1);
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02003611 $fixed[$fixlinenr] =~ s@\/\/(.*)$@/\* $comment \*/@;
Tom Rini6b9709d2014-02-27 08:27:28 -05003612 }
3613 }
Joe Hershberger05622192011-10-18 10:06:59 +00003614 }
3615 # Remove C99 comments.
3616 $line =~ s@//.*@@;
3617 $opline =~ s@//.*@@;
3618
3619# EXPORT_SYMBOL should immediately follow the thing it is exporting, consider
3620# the whole statement.
3621#print "APW <$lines[$realline_next - 1]>\n";
3622 if (defined $realline_next &&
3623 exists $lines[$realline_next - 1] &&
3624 !defined $suppress_export{$realline_next} &&
3625 ($lines[$realline_next - 1] =~ /EXPORT_SYMBOL.*\((.*)\)/ ||
3626 $lines[$realline_next - 1] =~ /EXPORT_UNUSED_SYMBOL.*\((.*)\)/)) {
3627 # Handle definitions which produce identifiers with
3628 # a prefix:
3629 # XXX(foo);
3630 # EXPORT_SYMBOL(something_foo);
3631 my $name = $1;
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00003632 if ($stat =~ /^(?:.\s*}\s*\n)?.([A-Z_]+)\s*\(\s*($Ident)/ &&
Joe Hershberger05622192011-10-18 10:06:59 +00003633 $name =~ /^${Ident}_$2/) {
3634#print "FOO C name<$name>\n";
3635 $suppress_export{$realline_next} = 1;
3636
3637 } elsif ($stat !~ /(?:
3638 \n.}\s*$|
3639 ^.DEFINE_$Ident\(\Q$name\E\)|
3640 ^.DECLARE_$Ident\(\Q$name\E\)|
3641 ^.LIST_HEAD\(\Q$name\E\)|
3642 ^.(?:$Storage\s+)?$Type\s*\(\s*\*\s*\Q$name\E\s*\)\s*\(|
3643 \b\Q$name\E(?:\s+$Attribute)*\s*(?:;|=|\[|\()
3644 )/x) {
3645#print "FOO A<$lines[$realline_next - 1]> stat<$stat> name<$name>\n";
3646 $suppress_export{$realline_next} = 2;
3647 } else {
3648 $suppress_export{$realline_next} = 1;
3649 }
3650 }
3651 if (!defined $suppress_export{$linenr} &&
3652 $prevline =~ /^.\s*$/ &&
3653 ($line =~ /EXPORT_SYMBOL.*\((.*)\)/ ||
3654 $line =~ /EXPORT_UNUSED_SYMBOL.*\((.*)\)/)) {
3655#print "FOO B <$lines[$linenr - 1]>\n";
3656 $suppress_export{$linenr} = 2;
3657 }
3658 if (defined $suppress_export{$linenr} &&
3659 $suppress_export{$linenr} == 2) {
3660 WARN("EXPORT_SYMBOL",
3661 "EXPORT_SYMBOL(foo); should immediately follow its function/variable\n" . $herecurr);
3662 }
3663
3664# check for global initialisers.
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02003665 if ($line =~ /^\+$Type\s*$Ident(?:\s+$Modifier)*\s*=\s*($zero_initializer)\s*;/) {
Tom Rini6b9709d2014-02-27 08:27:28 -05003666 if (ERROR("GLOBAL_INITIALISERS",
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02003667 "do not initialise globals to $1\n" . $herecurr) &&
Tom Rini6b9709d2014-02-27 08:27:28 -05003668 $fix) {
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02003669 $fixed[$fixlinenr] =~ s/(^.$Type\s*$Ident(?:\s+$Modifier)*)\s*=\s*$zero_initializer\s*;/$1;/;
Tom Rini6b9709d2014-02-27 08:27:28 -05003670 }
Joe Hershberger05622192011-10-18 10:06:59 +00003671 }
3672# check for static initialisers.
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02003673 if ($line =~ /^\+.*\bstatic\s.*=\s*($zero_initializer)\s*;/) {
Tom Rini6b9709d2014-02-27 08:27:28 -05003674 if (ERROR("INITIALISED_STATIC",
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02003675 "do not initialise statics to $1\n" .
Tom Rini6b9709d2014-02-27 08:27:28 -05003676 $herecurr) &&
3677 $fix) {
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02003678 $fixed[$fixlinenr] =~ s/(\bstatic\s.*?)\s*=\s*$zero_initializer\s*;/$1;/;
Tom Rini6b9709d2014-02-27 08:27:28 -05003679 }
Joe Hershberger05622192011-10-18 10:06:59 +00003680 }
3681
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02003682# check for misordered declarations of char/short/int/long with signed/unsigned
3683 while ($sline =~ m{(\b$TypeMisordered\b)}g) {
3684 my $tmp = trim($1);
3685 WARN("MISORDERED_TYPE",
3686 "type '$tmp' should be specified in [[un]signed] [short|int|long|long long] order\n" . $herecurr);
3687 }
3688
Joe Hershberger05622192011-10-18 10:06:59 +00003689# check for static const char * arrays.
3690 if ($line =~ /\bstatic\s+const\s+char\s*\*\s*(\w+)\s*\[\s*\]\s*=\s*/) {
3691 WARN("STATIC_CONST_CHAR_ARRAY",
3692 "static const char * array should probably be static const char * const\n" .
3693 $herecurr);
3694 }
3695
3696# check for static char foo[] = "bar" declarations.
3697 if ($line =~ /\bstatic\s+char\s+(\w+)\s*\[\s*\]\s*=\s*"/) {
3698 WARN("STATIC_CONST_CHAR_ARRAY",
3699 "static char array declaration should probably be static const char\n" .
3700 $herecurr);
3701 }
3702
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02003703# check for const <foo> const where <foo> is not a pointer or array type
3704 if ($sline =~ /\bconst\s+($BasicType)\s+const\b/) {
3705 my $found = $1;
3706 if ($sline =~ /\bconst\s+\Q$found\E\s+const\b\s*\*/) {
3707 WARN("CONST_CONST",
3708 "'const $found const *' should probably be 'const $found * const'\n" . $herecurr);
3709 } elsif ($sline !~ /\bconst\s+\Q$found\E\s+const\s+\w+\s*\[/) {
3710 WARN("CONST_CONST",
3711 "'const $found const' should probably be 'const $found'\n" . $herecurr);
3712 }
3713 }
3714
3715# check for non-global char *foo[] = {"bar", ...} declarations.
3716 if ($line =~ /^.\s+(?:static\s+|const\s+)?char\s+\*\s*\w+\s*\[\s*\]\s*=\s*\{/) {
3717 WARN("STATIC_CONST_CHAR_ARRAY",
3718 "char * array declaration might be better as static const\n" .
3719 $herecurr);
3720 }
3721
3722# check for sizeof(foo)/sizeof(foo[0]) that could be ARRAY_SIZE(foo)
3723 if ($line =~ m@\bsizeof\s*\(\s*($Lval)\s*\)@) {
3724 my $array = $1;
3725 if ($line =~ m@\b(sizeof\s*\(\s*\Q$array\E\s*\)\s*/\s*sizeof\s*\(\s*\Q$array\E\s*\[\s*0\s*\]\s*\))@) {
3726 my $array_div = $1;
3727 if (WARN("ARRAY_SIZE",
3728 "Prefer ARRAY_SIZE($array)\n" . $herecurr) &&
3729 $fix) {
3730 $fixed[$fixlinenr] =~ s/\Q$array_div\E/ARRAY_SIZE($array)/;
3731 }
3732 }
3733 }
3734
Tom Rini6b9709d2014-02-27 08:27:28 -05003735# check for function declarations without arguments like "int foo()"
3736 if ($line =~ /(\b$Type\s+$Ident)\s*\(\s*\)/) {
3737 if (ERROR("FUNCTION_WITHOUT_ARGS",
3738 "Bad function definition - $1() should probably be $1(void)\n" . $herecurr) &&
3739 $fix) {
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02003740 $fixed[$fixlinenr] =~ s/(\b($Type)\s+($Ident))\s*\(\s*\)/$2 $3(void)/;
Tom Rini6b9709d2014-02-27 08:27:28 -05003741 }
Joe Hershberger05622192011-10-18 10:06:59 +00003742 }
3743
3744# check for new typedefs, only function parameters and sparse annotations
3745# make sense.
3746 if ($line =~ /\btypedef\s/ &&
3747 $line !~ /\btypedef\s+$Type\s*\(\s*\*?$Ident\s*\)\s*\(/ &&
3748 $line !~ /\btypedef\s+$Type\s+$Ident\s*\(/ &&
3749 $line !~ /\b$typeTypedefs\b/ &&
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02003750 $line !~ /\b__bitwise\b/) {
Joe Hershberger05622192011-10-18 10:06:59 +00003751 WARN("NEW_TYPEDEFS",
3752 "do not add new typedefs\n" . $herecurr);
3753 }
3754
3755# * goes on variable not on type
3756 # (char*[ const])
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00003757 while ($line =~ m{(\($NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)\))}g) {
3758 #print "AA<$1>\n";
Tom Rini6b9709d2014-02-27 08:27:28 -05003759 my ($ident, $from, $to) = ($1, $2, $2);
Joe Hershberger05622192011-10-18 10:06:59 +00003760
3761 # Should start with a space.
3762 $to =~ s/^(\S)/ $1/;
3763 # Should not end with a space.
3764 $to =~ s/\s+$//;
3765 # '*'s should not have spaces between.
3766 while ($to =~ s/\*\s+\*/\*\*/) {
3767 }
3768
Tom Rini6b9709d2014-02-27 08:27:28 -05003769## print "1: from<$from> to<$to> ident<$ident>\n";
Joe Hershberger05622192011-10-18 10:06:59 +00003770 if ($from ne $to) {
Tom Rini6b9709d2014-02-27 08:27:28 -05003771 if (ERROR("POINTER_LOCATION",
3772 "\"(foo$from)\" should be \"(foo$to)\"\n" . $herecurr) &&
3773 $fix) {
3774 my $sub_from = $ident;
3775 my $sub_to = $ident;
3776 $sub_to =~ s/\Q$from\E/$to/;
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02003777 $fixed[$fixlinenr] =~
Tom Rini6b9709d2014-02-27 08:27:28 -05003778 s@\Q$sub_from\E@$sub_to@;
3779 }
Joe Hershberger05622192011-10-18 10:06:59 +00003780 }
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00003781 }
3782 while ($line =~ m{(\b$NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)($Ident))}g) {
3783 #print "BB<$1>\n";
Tom Rini6b9709d2014-02-27 08:27:28 -05003784 my ($match, $from, $to, $ident) = ($1, $2, $2, $3);
Joe Hershberger05622192011-10-18 10:06:59 +00003785
3786 # Should start with a space.
3787 $to =~ s/^(\S)/ $1/;
3788 # Should not end with a space.
3789 $to =~ s/\s+$//;
3790 # '*'s should not have spaces between.
3791 while ($to =~ s/\*\s+\*/\*\*/) {
3792 }
3793 # Modifiers should have spaces.
3794 $to =~ s/(\b$Modifier$)/$1 /;
3795
Tom Rini6b9709d2014-02-27 08:27:28 -05003796## print "2: from<$from> to<$to> ident<$ident>\n";
Joe Hershberger05622192011-10-18 10:06:59 +00003797 if ($from ne $to && $ident !~ /^$Modifier$/) {
Tom Rini6b9709d2014-02-27 08:27:28 -05003798 if (ERROR("POINTER_LOCATION",
3799 "\"foo${from}bar\" should be \"foo${to}bar\"\n" . $herecurr) &&
3800 $fix) {
3801
3802 my $sub_from = $match;
3803 my $sub_to = $match;
3804 $sub_to =~ s/\Q$from\E/$to/;
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02003805 $fixed[$fixlinenr] =~
Tom Rini6b9709d2014-02-27 08:27:28 -05003806 s@\Q$sub_from\E@$sub_to@;
3807 }
Joe Hershberger05622192011-10-18 10:06:59 +00003808 }
3809 }
3810
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02003811# avoid BUG() or BUG_ON()
3812 if ($line =~ /\b(?:BUG|BUG_ON)\b/) {
3813 my $msg_type = \&WARN;
3814 $msg_type = \&CHK if ($file);
3815 &{$msg_type}("AVOID_BUG",
3816 "Avoid crashing the kernel - try using WARN_ON & recovery code rather than BUG() or BUG_ON()\n" . $herecurr);
3817 }
Joe Hershberger05622192011-10-18 10:06:59 +00003818
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02003819# avoid LINUX_VERSION_CODE
Joe Hershberger05622192011-10-18 10:06:59 +00003820 if ($line =~ /\bLINUX_VERSION_CODE\b/) {
3821 WARN("LINUX_VERSION_CODE",
3822 "LINUX_VERSION_CODE should be avoided, code should be for the version to which it is merged\n" . $herecurr);
3823 }
3824
3825# check for uses of printk_ratelimit
3826 if ($line =~ /\bprintk_ratelimit\s*\(/) {
3827 WARN("PRINTK_RATELIMITED",
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02003828 "Prefer printk_ratelimited or pr_<level>_ratelimited to printk_ratelimit\n" . $herecurr);
Joe Hershberger05622192011-10-18 10:06:59 +00003829 }
3830
3831# printk should use KERN_* levels. Note that follow on printk's on the
3832# same line do not need a level, so we use the current block context
3833# to try and find and validate the current printk. In summary the current
3834# printk includes all preceding printk's which have no newline on the end.
3835# we assume the first bad printk is the one to report.
3836 if ($line =~ /\bprintk\((?!KERN_)\s*"/) {
3837 my $ok = 0;
3838 for (my $ln = $linenr - 1; $ln >= $first_line; $ln--) {
3839 #print "CHECK<$lines[$ln - 1]\n";
3840 # we have a preceding printk if it ends
3841 # with "\n" ignore it, else it is to blame
3842 if ($lines[$ln - 1] =~ m{\bprintk\(}) {
3843 if ($rawlines[$ln - 1] !~ m{\\n"}) {
3844 $ok = 1;
3845 }
3846 last;
3847 }
3848 }
3849 if ($ok == 0) {
3850 WARN("PRINTK_WITHOUT_KERN_LEVEL",
3851 "printk() should include KERN_ facility level\n" . $herecurr);
3852 }
3853 }
3854
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00003855 if ($line =~ /\bprintk\s*\(\s*KERN_([A-Z]+)/) {
3856 my $orig = $1;
3857 my $level = lc($orig);
3858 $level = "warn" if ($level eq "warning");
3859 my $level2 = $level;
3860 $level2 = "dbg" if ($level eq "debug");
3861 WARN("PREFER_PR_LEVEL",
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02003862 "Prefer [subsystem eg: netdev]_$level2([subsystem]dev, ... then dev_$level2(dev, ... then pr_$level(... to printk(KERN_$orig ...\n" . $herecurr);
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00003863 }
3864
3865 if ($line =~ /\bpr_warning\s*\(/) {
Tom Rini6b9709d2014-02-27 08:27:28 -05003866 if (WARN("PREFER_PR_LEVEL",
3867 "Prefer pr_warn(... to pr_warning(...\n" . $herecurr) &&
3868 $fix) {
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02003869 $fixed[$fixlinenr] =~
Tom Rini6b9709d2014-02-27 08:27:28 -05003870 s/\bpr_warning\b/pr_warn/;
3871 }
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00003872 }
3873
3874 if ($line =~ /\bdev_printk\s*\(\s*KERN_([A-Z]+)/) {
3875 my $orig = $1;
3876 my $level = lc($orig);
3877 $level = "warn" if ($level eq "warning");
3878 $level = "dbg" if ($level eq "debug");
3879 WARN("PREFER_DEV_LEVEL",
3880 "Prefer dev_$level(... to dev_printk(KERN_$orig, ...\n" . $herecurr);
3881 }
3882
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02003883# ENOSYS means "bad syscall nr" and nothing else. This will have a small
3884# number of false positives, but assembly files are not checked, so at
3885# least the arch entry code will not trigger this warning.
3886 if ($line =~ /\bENOSYS\b/) {
3887 WARN("ENOSYS",
3888 "ENOSYS means 'invalid syscall nr' and nothing else\n" . $herecurr);
3889 }
3890
Joe Hershberger05622192011-10-18 10:06:59 +00003891# function brace can't be on same line, except for #defines of do while,
3892# or if closed on same line
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02003893 if (($line=~/$Type\s*$Ident\(.*\).*\s*{/) and
Heiko Schocherd8a1a302016-01-04 09:17:19 +01003894 !($line=~/\#\s*define.*do\s\{/) and !($line=~/}/)) {
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02003895 if (ERROR("OPEN_BRACE",
3896 "open brace '{' following function declarations go on the next line\n" . $herecurr) &&
3897 $fix) {
3898 fix_delete_line($fixlinenr, $rawline);
3899 my $fixed_line = $rawline;
3900 $fixed_line =~ /(^..*$Type\s*$Ident\(.*\)\s*){(.*)$/;
3901 my $line1 = $1;
3902 my $line2 = $2;
3903 fix_insert_line($fixlinenr, ltrim($line1));
3904 fix_insert_line($fixlinenr, "\+{");
3905 if ($line2 !~ /^\s*$/) {
3906 fix_insert_line($fixlinenr, "\+\t" . trim($line2));
3907 }
3908 }
Joe Hershberger05622192011-10-18 10:06:59 +00003909 }
3910
3911# open braces for enum, union and struct go on the same line.
3912 if ($line =~ /^.\s*{/ &&
3913 $prevline =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident)?\s*$/) {
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02003914 if (ERROR("OPEN_BRACE",
3915 "open brace '{' following $1 go on the same line\n" . $hereprev) &&
3916 $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
3917 fix_delete_line($fixlinenr - 1, $prevrawline);
3918 fix_delete_line($fixlinenr, $rawline);
3919 my $fixedline = rtrim($prevrawline) . " {";
3920 fix_insert_line($fixlinenr, $fixedline);
3921 $fixedline = $rawline;
3922 $fixedline =~ s/^(.\s*)\{\s*/$1\t/;
3923 if ($fixedline !~ /^\+\s*$/) {
3924 fix_insert_line($fixlinenr, $fixedline);
3925 }
3926 }
Joe Hershberger05622192011-10-18 10:06:59 +00003927 }
3928
3929# missing space after union, struct or enum definition
Tom Rini6b9709d2014-02-27 08:27:28 -05003930 if ($line =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident){1,2}[=\{]/) {
3931 if (WARN("SPACING",
3932 "missing space after $1 definition\n" . $herecurr) &&
3933 $fix) {
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02003934 $fixed[$fixlinenr] =~
Tom Rini6b9709d2014-02-27 08:27:28 -05003935 s/^(.\s*(?:typedef\s+)?(?:enum|union|struct)(?:\s+$Ident){1,2})([=\{])/$1 $2/;
3936 }
3937 }
3938
3939# Function pointer declarations
3940# check spacing between type, funcptr, and args
3941# canonical declaration is "type (*funcptr)(args...)"
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02003942 if ($line =~ /^.\s*($Declare)\((\s*)\*(\s*)($Ident)(\s*)\)(\s*)\(/) {
Tom Rini6b9709d2014-02-27 08:27:28 -05003943 my $declare = $1;
3944 my $pre_pointer_space = $2;
3945 my $post_pointer_space = $3;
3946 my $funcname = $4;
3947 my $post_funcname_space = $5;
3948 my $pre_args_space = $6;
3949
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02003950# the $Declare variable will capture all spaces after the type
3951# so check it for a missing trailing missing space but pointer return types
3952# don't need a space so don't warn for those.
3953 my $post_declare_space = "";
3954 if ($declare =~ /(\s+)$/) {
3955 $post_declare_space = $1;
3956 $declare = rtrim($declare);
3957 }
3958 if ($declare !~ /\*$/ && $post_declare_space =~ /^$/) {
Tom Rini6b9709d2014-02-27 08:27:28 -05003959 WARN("SPACING",
3960 "missing space after return type\n" . $herecurr);
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02003961 $post_declare_space = " ";
Tom Rini6b9709d2014-02-27 08:27:28 -05003962 }
3963
3964# unnecessary space "type (*funcptr)(args...)"
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02003965# This test is not currently implemented because these declarations are
3966# equivalent to
3967# int foo(int bar, ...)
3968# and this is form shouldn't/doesn't generate a checkpatch warning.
3969#
3970# elsif ($declare =~ /\s{2,}$/) {
3971# WARN("SPACING",
3972# "Multiple spaces after return type\n" . $herecurr);
3973# }
Tom Rini6b9709d2014-02-27 08:27:28 -05003974
3975# unnecessary space "type ( *funcptr)(args...)"
3976 if (defined $pre_pointer_space &&
3977 $pre_pointer_space =~ /^\s/) {
3978 WARN("SPACING",
3979 "Unnecessary space after function pointer open parenthesis\n" . $herecurr);
3980 }
3981
3982# unnecessary space "type (* funcptr)(args...)"
3983 if (defined $post_pointer_space &&
3984 $post_pointer_space =~ /^\s/) {
3985 WARN("SPACING",
3986 "Unnecessary space before function pointer name\n" . $herecurr);
3987 }
3988
3989# unnecessary space "type (*funcptr )(args...)"
3990 if (defined $post_funcname_space &&
3991 $post_funcname_space =~ /^\s/) {
3992 WARN("SPACING",
3993 "Unnecessary space after function pointer name\n" . $herecurr);
3994 }
3995
3996# unnecessary space "type (*funcptr) (args...)"
3997 if (defined $pre_args_space &&
3998 $pre_args_space =~ /^\s/) {
3999 WARN("SPACING",
4000 "Unnecessary space before function pointer arguments\n" . $herecurr);
4001 }
4002
4003 if (show_type("SPACING") && $fix) {
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02004004 $fixed[$fixlinenr] =~
4005 s/^(.\s*)$Declare\s*\(\s*\*\s*$Ident\s*\)\s*\(/$1 . $declare . $post_declare_space . '(*' . $funcname . ')('/ex;
Tom Rini6b9709d2014-02-27 08:27:28 -05004006 }
Joe Hershberger05622192011-10-18 10:06:59 +00004007 }
4008
4009# check for spacing round square brackets; allowed:
4010# 1. with a type on the left -- int [] a;
4011# 2. at the beginning of a line for slice initialisers -- [0...10] = 5,
4012# 3. inside a curly brace -- = { [0...10] = 5 }
4013 while ($line =~ /(.*?\s)\[/g) {
4014 my ($where, $prefix) = ($-[1], $1);
4015 if ($prefix !~ /$Type\s+$/ &&
4016 ($where != 0 || $prefix !~ /^.\s+$/) &&
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00004017 $prefix !~ /[{,]\s+$/) {
Tom Rini6b9709d2014-02-27 08:27:28 -05004018 if (ERROR("BRACKET_SPACE",
4019 "space prohibited before open square bracket '['\n" . $herecurr) &&
4020 $fix) {
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02004021 $fixed[$fixlinenr] =~
Tom Rini6b9709d2014-02-27 08:27:28 -05004022 s/^(\+.*?)\s+\[/$1\[/;
4023 }
Joe Hershberger05622192011-10-18 10:06:59 +00004024 }
4025 }
4026
4027# check for spaces between functions and their parentheses.
4028 while ($line =~ /($Ident)\s+\(/g) {
4029 my $name = $1;
4030 my $ctx_before = substr($line, 0, $-[1]);
4031 my $ctx = "$ctx_before$name";
4032
4033 # Ignore those directives where spaces _are_ permitted.
4034 if ($name =~ /^(?:
4035 if|for|while|switch|return|case|
4036 volatile|__volatile__|
4037 __attribute__|format|__extension__|
4038 asm|__asm__)$/x)
4039 {
Joe Hershberger05622192011-10-18 10:06:59 +00004040 # cpp #define statements have non-optional spaces, ie
4041 # if there is a space between the name and the open
4042 # parenthesis it is simply not a parameter group.
4043 } elsif ($ctx_before =~ /^.\s*\#\s*define\s*$/) {
4044
4045 # cpp #elif statement condition may start with a (
4046 } elsif ($ctx =~ /^.\s*\#\s*elif\s*$/) {
4047
4048 # If this whole things ends with a type its most
4049 # likely a typedef for a function.
4050 } elsif ($ctx =~ /$Type$/) {
4051
4052 } else {
Tom Rini6b9709d2014-02-27 08:27:28 -05004053 if (WARN("SPACING",
4054 "space prohibited between function name and open parenthesis '('\n" . $herecurr) &&
4055 $fix) {
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02004056 $fixed[$fixlinenr] =~
Tom Rini6b9709d2014-02-27 08:27:28 -05004057 s/\b$name\s+\(/$name\(/;
4058 }
Joe Hershberger05622192011-10-18 10:06:59 +00004059 }
4060 }
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00004061
Joe Hershberger05622192011-10-18 10:06:59 +00004062# Check operator spacing.
4063 if (!($line=~/\#\s*include/)) {
Tom Rini6b9709d2014-02-27 08:27:28 -05004064 my $fixed_line = "";
4065 my $line_fixed = 0;
4066
Joe Hershberger05622192011-10-18 10:06:59 +00004067 my $ops = qr{
4068 <<=|>>=|<=|>=|==|!=|
4069 \+=|-=|\*=|\/=|%=|\^=|\|=|&=|
4070 =>|->|<<|>>|<|>|=|!|~|
4071 &&|\|\||,|\^|\+\+|--|&|\||\+|-|\*|\/|%|
Tom Rini6b9709d2014-02-27 08:27:28 -05004072 \?:|\?|:
Joe Hershberger05622192011-10-18 10:06:59 +00004073 }x;
4074 my @elements = split(/($ops|;)/, $opline);
Tom Rini6b9709d2014-02-27 08:27:28 -05004075
4076## print("element count: <" . $#elements . ">\n");
4077## foreach my $el (@elements) {
4078## print("el: <$el>\n");
4079## }
4080
4081 my @fix_elements = ();
Joe Hershberger05622192011-10-18 10:06:59 +00004082 my $off = 0;
4083
Tom Rini6b9709d2014-02-27 08:27:28 -05004084 foreach my $el (@elements) {
4085 push(@fix_elements, substr($rawline, $off, length($el)));
4086 $off += length($el);
4087 }
4088
4089 $off = 0;
4090
Joe Hershberger05622192011-10-18 10:06:59 +00004091 my $blank = copy_spacing($opline);
Tom Rini6b9709d2014-02-27 08:27:28 -05004092 my $last_after = -1;
Joe Hershberger05622192011-10-18 10:06:59 +00004093
4094 for (my $n = 0; $n < $#elements; $n += 2) {
Tom Rini6b9709d2014-02-27 08:27:28 -05004095
4096 my $good = $fix_elements[$n] . $fix_elements[$n + 1];
4097
4098## print("n: <$n> good: <$good>\n");
4099
Joe Hershberger05622192011-10-18 10:06:59 +00004100 $off += length($elements[$n]);
4101
4102 # Pick up the preceding and succeeding characters.
4103 my $ca = substr($opline, 0, $off);
4104 my $cc = '';
4105 if (length($opline) >= ($off + length($elements[$n + 1]))) {
4106 $cc = substr($opline, $off + length($elements[$n + 1]));
4107 }
4108 my $cb = "$ca$;$cc";
4109
4110 my $a = '';
4111 $a = 'V' if ($elements[$n] ne '');
4112 $a = 'W' if ($elements[$n] =~ /\s$/);
4113 $a = 'C' if ($elements[$n] =~ /$;$/);
4114 $a = 'B' if ($elements[$n] =~ /(\[|\()$/);
4115 $a = 'O' if ($elements[$n] eq '');
4116 $a = 'E' if ($ca =~ /^\s*$/);
4117
4118 my $op = $elements[$n + 1];
4119
4120 my $c = '';
4121 if (defined $elements[$n + 2]) {
4122 $c = 'V' if ($elements[$n + 2] ne '');
4123 $c = 'W' if ($elements[$n + 2] =~ /^\s/);
4124 $c = 'C' if ($elements[$n + 2] =~ /^$;/);
4125 $c = 'B' if ($elements[$n + 2] =~ /^(\)|\]|;)/);
4126 $c = 'O' if ($elements[$n + 2] eq '');
4127 $c = 'E' if ($elements[$n + 2] =~ /^\s*\\$/);
4128 } else {
4129 $c = 'E';
4130 }
4131
4132 my $ctx = "${a}x${c}";
4133
4134 my $at = "(ctx:$ctx)";
4135
4136 my $ptr = substr($blank, 0, $off) . "^";
4137 my $hereptr = "$hereline$ptr\n";
4138
4139 # Pull out the value of this operator.
4140 my $op_type = substr($curr_values, $off + 1, 1);
4141
4142 # Get the full operator variant.
4143 my $opv = $op . substr($curr_vars, $off, 1);
4144
4145 # Ignore operators passed as parameters.
4146 if ($op_type ne 'V' &&
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02004147 $ca =~ /\s$/ && $cc =~ /^\s*[,\)]/) {
Joe Hershberger05622192011-10-18 10:06:59 +00004148
4149# # Ignore comments
4150# } elsif ($op =~ /^$;+$/) {
4151
4152 # ; should have either the end of line or a space or \ after it
4153 } elsif ($op eq ';') {
4154 if ($ctx !~ /.x[WEBC]/ &&
4155 $cc !~ /^\\/ && $cc !~ /^;/) {
Tom Rini6b9709d2014-02-27 08:27:28 -05004156 if (ERROR("SPACING",
4157 "space required after that '$op' $at\n" . $hereptr)) {
4158 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";
4159 $line_fixed = 1;
4160 }
Joe Hershberger05622192011-10-18 10:06:59 +00004161 }
4162
4163 # // is a comment
4164 } elsif ($op eq '//') {
4165
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02004166 # : when part of a bitfield
4167 } elsif ($opv eq ':B') {
4168 # skip the bitfield test for now
4169
Joe Hershberger05622192011-10-18 10:06:59 +00004170 # No spaces for:
4171 # ->
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02004172 } elsif ($op eq '->') {
Joe Hershberger05622192011-10-18 10:06:59 +00004173 if ($ctx =~ /Wx.|.xW/) {
Tom Rini6b9709d2014-02-27 08:27:28 -05004174 if (ERROR("SPACING",
4175 "spaces prohibited around that '$op' $at\n" . $hereptr)) {
4176 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
4177 if (defined $fix_elements[$n + 2]) {
4178 $fix_elements[$n + 2] =~ s/^\s+//;
4179 }
4180 $line_fixed = 1;
4181 }
Joe Hershberger05622192011-10-18 10:06:59 +00004182 }
4183
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02004184 # , must not have a space before and must have a space on the right.
Joe Hershberger05622192011-10-18 10:06:59 +00004185 } elsif ($op eq ',') {
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02004186 my $rtrim_before = 0;
4187 my $space_after = 0;
4188 if ($ctx =~ /Wx./) {
4189 if (ERROR("SPACING",
4190 "space prohibited before that '$op' $at\n" . $hereptr)) {
4191 $line_fixed = 1;
4192 $rtrim_before = 1;
4193 }
4194 }
Joe Hershberger05622192011-10-18 10:06:59 +00004195 if ($ctx !~ /.x[WEC]/ && $cc !~ /^}/) {
Tom Rini6b9709d2014-02-27 08:27:28 -05004196 if (ERROR("SPACING",
4197 "space required after that '$op' $at\n" . $hereptr)) {
Tom Rini6b9709d2014-02-27 08:27:28 -05004198 $line_fixed = 1;
4199 $last_after = $n;
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02004200 $space_after = 1;
4201 }
4202 }
4203 if ($rtrim_before || $space_after) {
4204 if ($rtrim_before) {
4205 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
4206 } else {
4207 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]);
4208 }
4209 if ($space_after) {
4210 $good .= " ";
Tom Rini6b9709d2014-02-27 08:27:28 -05004211 }
Joe Hershberger05622192011-10-18 10:06:59 +00004212 }
4213
4214 # '*' as part of a type definition -- reported already.
4215 } elsif ($opv eq '*_') {
4216 #warn "'*' is part of type\n";
4217
4218 # unary operators should have a space before and
4219 # none after. May be left adjacent to another
4220 # unary operator, or a cast
4221 } elsif ($op eq '!' || $op eq '~' ||
4222 $opv eq '*U' || $opv eq '-U' ||
4223 $opv eq '&U' || $opv eq '&&U') {
4224 if ($ctx !~ /[WEBC]x./ && $ca !~ /(?:\)|!|~|\*|-|\&|\||\+\+|\-\-|\{)$/) {
Tom Rini6b9709d2014-02-27 08:27:28 -05004225 if (ERROR("SPACING",
4226 "space required before that '$op' $at\n" . $hereptr)) {
4227 if ($n != $last_after + 2) {
4228 $good = $fix_elements[$n] . " " . ltrim($fix_elements[$n + 1]);
4229 $line_fixed = 1;
4230 }
4231 }
Joe Hershberger05622192011-10-18 10:06:59 +00004232 }
4233 if ($op eq '*' && $cc =~/\s*$Modifier\b/) {
4234 # A unary '*' may be const
4235
4236 } elsif ($ctx =~ /.xW/) {
Tom Rini6b9709d2014-02-27 08:27:28 -05004237 if (ERROR("SPACING",
4238 "space prohibited after that '$op' $at\n" . $hereptr)) {
4239 $good = $fix_elements[$n] . rtrim($fix_elements[$n + 1]);
4240 if (defined $fix_elements[$n + 2]) {
4241 $fix_elements[$n + 2] =~ s/^\s+//;
4242 }
4243 $line_fixed = 1;
4244 }
Joe Hershberger05622192011-10-18 10:06:59 +00004245 }
4246
4247 # unary ++ and unary -- are allowed no space on one side.
4248 } elsif ($op eq '++' or $op eq '--') {
4249 if ($ctx !~ /[WEOBC]x[^W]/ && $ctx !~ /[^W]x[WOBEC]/) {
Tom Rini6b9709d2014-02-27 08:27:28 -05004250 if (ERROR("SPACING",
4251 "space required one side of that '$op' $at\n" . $hereptr)) {
4252 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";
4253 $line_fixed = 1;
4254 }
Joe Hershberger05622192011-10-18 10:06:59 +00004255 }
4256 if ($ctx =~ /Wx[BE]/ ||
4257 ($ctx =~ /Wx./ && $cc =~ /^;/)) {
Tom Rini6b9709d2014-02-27 08:27:28 -05004258 if (ERROR("SPACING",
4259 "space prohibited before that '$op' $at\n" . $hereptr)) {
4260 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
4261 $line_fixed = 1;
4262 }
Joe Hershberger05622192011-10-18 10:06:59 +00004263 }
4264 if ($ctx =~ /ExW/) {
Tom Rini6b9709d2014-02-27 08:27:28 -05004265 if (ERROR("SPACING",
4266 "space prohibited after that '$op' $at\n" . $hereptr)) {
4267 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]);
4268 if (defined $fix_elements[$n + 2]) {
4269 $fix_elements[$n + 2] =~ s/^\s+//;
4270 }
4271 $line_fixed = 1;
4272 }
Joe Hershberger05622192011-10-18 10:06:59 +00004273 }
4274
Joe Hershberger05622192011-10-18 10:06:59 +00004275 # << and >> may either have or not have spaces both sides
4276 } elsif ($op eq '<<' or $op eq '>>' or
4277 $op eq '&' or $op eq '^' or $op eq '|' or
4278 $op eq '+' or $op eq '-' or
4279 $op eq '*' or $op eq '/' or
4280 $op eq '%')
4281 {
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02004282 if ($check) {
4283 if (defined $fix_elements[$n + 2] && $ctx !~ /[EW]x[EW]/) {
4284 if (CHK("SPACING",
4285 "spaces preferred around that '$op' $at\n" . $hereptr)) {
4286 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
4287 $fix_elements[$n + 2] =~ s/^\s+//;
4288 $line_fixed = 1;
4289 }
4290 } elsif (!defined $fix_elements[$n + 2] && $ctx !~ /Wx[OE]/) {
4291 if (CHK("SPACING",
4292 "space preferred before that '$op' $at\n" . $hereptr)) {
4293 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]);
4294 $line_fixed = 1;
4295 }
4296 }
4297 } elsif ($ctx =~ /Wx[^WCE]|[^WCE]xW/) {
Tom Rini6b9709d2014-02-27 08:27:28 -05004298 if (ERROR("SPACING",
4299 "need consistent spacing around '$op' $at\n" . $hereptr)) {
4300 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
4301 if (defined $fix_elements[$n + 2]) {
4302 $fix_elements[$n + 2] =~ s/^\s+//;
4303 }
4304 $line_fixed = 1;
4305 }
Joe Hershberger05622192011-10-18 10:06:59 +00004306 }
4307
4308 # A colon needs no spaces before when it is
4309 # terminating a case value or a label.
4310 } elsif ($opv eq ':C' || $opv eq ':L') {
4311 if ($ctx =~ /Wx./) {
Tom Rini6b9709d2014-02-27 08:27:28 -05004312 if (ERROR("SPACING",
4313 "space prohibited before that '$op' $at\n" . $hereptr)) {
4314 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
4315 $line_fixed = 1;
4316 }
Joe Hershberger05622192011-10-18 10:06:59 +00004317 }
4318
4319 # All the others need spaces both sides.
4320 } elsif ($ctx !~ /[EWC]x[CWE]/) {
4321 my $ok = 0;
4322
4323 # Ignore email addresses <foo@bar>
4324 if (($op eq '<' &&
4325 $cc =~ /^\S+\@\S+>/) ||
4326 ($op eq '>' &&
4327 $ca =~ /<\S+\@\S+$/))
4328 {
Tom Rini6b9709d2014-02-27 08:27:28 -05004329 $ok = 1;
Joe Hershberger05622192011-10-18 10:06:59 +00004330 }
4331
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02004332 # for asm volatile statements
4333 # ignore a colon with another
4334 # colon immediately before or after
4335 if (($op eq ':') &&
4336 ($ca =~ /:$/ || $cc =~ /^:/)) {
4337 $ok = 1;
4338 }
4339
Tom Rini6b9709d2014-02-27 08:27:28 -05004340 # messages are ERROR, but ?: are CHK
Joe Hershberger05622192011-10-18 10:06:59 +00004341 if ($ok == 0) {
Tom Rini6b9709d2014-02-27 08:27:28 -05004342 my $msg_type = \&ERROR;
4343 $msg_type = \&CHK if (($op eq '?:' || $op eq '?' || $op eq ':') && $ctx =~ /VxV/);
4344
4345 if (&{$msg_type}("SPACING",
4346 "spaces required around that '$op' $at\n" . $hereptr)) {
4347 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
4348 if (defined $fix_elements[$n + 2]) {
4349 $fix_elements[$n + 2] =~ s/^\s+//;
4350 }
4351 $line_fixed = 1;
4352 }
Joe Hershberger05622192011-10-18 10:06:59 +00004353 }
4354 }
4355 $off += length($elements[$n + 1]);
Tom Rini6b9709d2014-02-27 08:27:28 -05004356
4357## print("n: <$n> GOOD: <$good>\n");
4358
4359 $fixed_line = $fixed_line . $good;
4360 }
4361
4362 if (($#elements % 2) == 0) {
4363 $fixed_line = $fixed_line . $fix_elements[$#elements];
4364 }
4365
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02004366 if ($fix && $line_fixed && $fixed_line ne $fixed[$fixlinenr]) {
4367 $fixed[$fixlinenr] = $fixed_line;
Tom Rini6b9709d2014-02-27 08:27:28 -05004368 }
4369
4370
4371 }
4372
4373# check for whitespace before a non-naked semicolon
4374 if ($line =~ /^\+.*\S\s+;\s*$/) {
4375 if (WARN("SPACING",
4376 "space prohibited before semicolon\n" . $herecurr) &&
4377 $fix) {
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02004378 1 while $fixed[$fixlinenr] =~
Tom Rini6b9709d2014-02-27 08:27:28 -05004379 s/^(\+.*\S)\s+;/$1;/;
Joe Hershberger05622192011-10-18 10:06:59 +00004380 }
4381 }
4382
4383# check for multiple assignments
4384 if ($line =~ /^.\s*$Lval\s*=\s*$Lval\s*=(?!=)/) {
4385 CHK("MULTIPLE_ASSIGNMENTS",
4386 "multiple assignments should be avoided\n" . $herecurr);
4387 }
4388
4389## # check for multiple declarations, allowing for a function declaration
4390## # continuation.
4391## if ($line =~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Ident.*/ &&
4392## $line !~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Type\s*$Ident.*/) {
4393##
4394## # Remove any bracketed sections to ensure we do not
4395## # falsly report the parameters of functions.
4396## my $ln = $line;
4397## while ($ln =~ s/\([^\(\)]*\)//g) {
4398## }
4399## if ($ln =~ /,/) {
4400## WARN("MULTIPLE_DECLARATION",
4401## "declaring multiple variables together should be avoided\n" . $herecurr);
4402## }
4403## }
4404
4405#need space before brace following if, while, etc
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02004406 if (($line =~ /\(.*\)\{/ && $line !~ /\($Type\)\{/) ||
Heiko Schocherd8a1a302016-01-04 09:17:19 +01004407 $line =~ /do\{/) {
Tom Rini6b9709d2014-02-27 08:27:28 -05004408 if (ERROR("SPACING",
4409 "space required before the open brace '{'\n" . $herecurr) &&
4410 $fix) {
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02004411 $fixed[$fixlinenr] =~ s/^(\+.*(?:do|\)))\{/$1 {/;
Tom Rini6b9709d2014-02-27 08:27:28 -05004412 }
Joe Hershberger05622192011-10-18 10:06:59 +00004413 }
4414
Tom Rini6b9709d2014-02-27 08:27:28 -05004415## # check for blank lines before declarations
4416## if ($line =~ /^.\t+$Type\s+$Ident(?:\s*=.*)?;/ &&
4417## $prevrawline =~ /^.\s*$/) {
4418## WARN("SPACING",
4419## "No blank lines before declarations\n" . $hereprev);
4420## }
4421##
4422
Joe Hershberger05622192011-10-18 10:06:59 +00004423# closing brace should have a space following it when it has anything
4424# on the line
4425 if ($line =~ /}(?!(?:,|;|\)))\S/) {
Tom Rini6b9709d2014-02-27 08:27:28 -05004426 if (ERROR("SPACING",
4427 "space required after that close brace '}'\n" . $herecurr) &&
4428 $fix) {
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02004429 $fixed[$fixlinenr] =~
Tom Rini6b9709d2014-02-27 08:27:28 -05004430 s/}((?!(?:,|;|\)))\S)/} $1/;
4431 }
Joe Hershberger05622192011-10-18 10:06:59 +00004432 }
4433
4434# check spacing on square brackets
4435 if ($line =~ /\[\s/ && $line !~ /\[\s*$/) {
Tom Rini6b9709d2014-02-27 08:27:28 -05004436 if (ERROR("SPACING",
4437 "space prohibited after that open square bracket '['\n" . $herecurr) &&
4438 $fix) {
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02004439 $fixed[$fixlinenr] =~
Tom Rini6b9709d2014-02-27 08:27:28 -05004440 s/\[\s+/\[/;
4441 }
Joe Hershberger05622192011-10-18 10:06:59 +00004442 }
4443 if ($line =~ /\s\]/) {
Tom Rini6b9709d2014-02-27 08:27:28 -05004444 if (ERROR("SPACING",
4445 "space prohibited before that close square bracket ']'\n" . $herecurr) &&
4446 $fix) {
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02004447 $fixed[$fixlinenr] =~
Tom Rini6b9709d2014-02-27 08:27:28 -05004448 s/\s+\]/\]/;
4449 }
Joe Hershberger05622192011-10-18 10:06:59 +00004450 }
4451
4452# check spacing on parentheses
4453 if ($line =~ /\(\s/ && $line !~ /\(\s*(?:\\)?$/ &&
4454 $line !~ /for\s*\(\s+;/) {
Tom Rini6b9709d2014-02-27 08:27:28 -05004455 if (ERROR("SPACING",
4456 "space prohibited after that open parenthesis '('\n" . $herecurr) &&
4457 $fix) {
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02004458 $fixed[$fixlinenr] =~
Tom Rini6b9709d2014-02-27 08:27:28 -05004459 s/\(\s+/\(/;
4460 }
Joe Hershberger05622192011-10-18 10:06:59 +00004461 }
4462 if ($line =~ /(\s+)\)/ && $line !~ /^.\s*\)/ &&
4463 $line !~ /for\s*\(.*;\s+\)/ &&
4464 $line !~ /:\s+\)/) {
Tom Rini6b9709d2014-02-27 08:27:28 -05004465 if (ERROR("SPACING",
4466 "space prohibited before that close parenthesis ')'\n" . $herecurr) &&
4467 $fix) {
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02004468 $fixed[$fixlinenr] =~
Tom Rini6b9709d2014-02-27 08:27:28 -05004469 s/\s+\)/\)/;
4470 }
Joe Hershberger05622192011-10-18 10:06:59 +00004471 }
4472
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02004473# check unnecessary parentheses around addressof/dereference single $Lvals
4474# ie: &(foo->bar) should be &foo->bar and *(foo->bar) should be *foo->bar
4475
4476 while ($line =~ /(?:[^&]&\s*|\*)\(\s*($Ident\s*(?:$Member\s*)+)\s*\)/g) {
4477 my $var = $1;
4478 if (CHK("UNNECESSARY_PARENTHESES",
4479 "Unnecessary parentheses around $var\n" . $herecurr) &&
4480 $fix) {
4481 $fixed[$fixlinenr] =~ s/\(\s*\Q$var\E\s*\)/$var/;
4482 }
4483 }
4484
4485# check for unnecessary parentheses around function pointer uses
4486# ie: (foo->bar)(); should be foo->bar();
4487# but not "if (foo->bar) (" to avoid some false positives
4488 if ($line =~ /(\bif\s*|)(\(\s*$Ident\s*(?:$Member\s*)+\))[ \t]*\(/ && $1 !~ /^if/) {
4489 my $var = $2;
4490 if (CHK("UNNECESSARY_PARENTHESES",
4491 "Unnecessary parentheses around function pointer $var\n" . $herecurr) &&
4492 $fix) {
4493 my $var2 = deparenthesize($var);
4494 $var2 =~ s/\s//g;
4495 $fixed[$fixlinenr] =~ s/\Q$var\E/$var2/;
4496 }
4497 }
4498
Joe Hershberger05622192011-10-18 10:06:59 +00004499#goto labels aren't indented, allow a single space however
4500 if ($line=~/^.\s+[A-Za-z\d_]+:(?![0-9]+)/ and
4501 !($line=~/^. [A-Za-z\d_]+:/) and !($line=~/^.\s+default:/)) {
Tom Rini6b9709d2014-02-27 08:27:28 -05004502 if (WARN("INDENTED_LABEL",
4503 "labels should not be indented\n" . $herecurr) &&
4504 $fix) {
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02004505 $fixed[$fixlinenr] =~
Tom Rini6b9709d2014-02-27 08:27:28 -05004506 s/^(.)\s+/$1/;
4507 }
Joe Hershberger05622192011-10-18 10:06:59 +00004508 }
4509
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02004510# return is not a function
Tom Rini6b9709d2014-02-27 08:27:28 -05004511 if (defined($stat) && $stat =~ /^.\s*return(\s*)\(/s) {
Joe Hershberger05622192011-10-18 10:06:59 +00004512 my $spacing = $1;
Tom Rini6b9709d2014-02-27 08:27:28 -05004513 if ($^V && $^V ge 5.10.0 &&
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02004514 $stat =~ /^.\s*return\s*($balanced_parens)\s*;\s*$/) {
4515 my $value = $1;
4516 $value = deparenthesize($value);
4517 if ($value =~ m/^\s*$FuncArg\s*(?:\?|$)/) {
4518 ERROR("RETURN_PARENTHESES",
4519 "return is not a function, parentheses are not required\n" . $herecurr);
4520 }
Joe Hershberger05622192011-10-18 10:06:59 +00004521 } elsif ($spacing !~ /\s+/) {
4522 ERROR("SPACING",
4523 "space required before the open parenthesis '('\n" . $herecurr);
4524 }
4525 }
Tom Rini6b9709d2014-02-27 08:27:28 -05004526
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02004527# unnecessary return in a void function
4528# at end-of-function, with the previous line a single leading tab, then return;
4529# and the line before that not a goto label target like "out:"
4530 if ($sline =~ /^[ \+]}\s*$/ &&
4531 $prevline =~ /^\+\treturn\s*;\s*$/ &&
4532 $linenr >= 3 &&
4533 $lines[$linenr - 3] =~ /^[ +]/ &&
4534 $lines[$linenr - 3] !~ /^[ +]\s*$Ident\s*:/) {
4535 WARN("RETURN_VOID",
4536 "void function return statements are not generally useful\n" . $hereprev);
4537 }
4538
Tom Rini6b9709d2014-02-27 08:27:28 -05004539# if statements using unnecessary parentheses - ie: if ((foo == bar))
4540 if ($^V && $^V ge 5.10.0 &&
4541 $line =~ /\bif\s*((?:\(\s*){2,})/) {
4542 my $openparens = $1;
4543 my $count = $openparens =~ tr@\(@\(@;
4544 my $msg = "";
4545 if ($line =~ /\bif\s*(?:\(\s*){$count,$count}$LvalOrFunc\s*($Compare)\s*$LvalOrFunc(?:\s*\)){$count,$count}/) {
4546 my $comp = $4; #Not $1 because of $LvalOrFunc
4547 $msg = " - maybe == should be = ?" if ($comp eq "==");
4548 WARN("UNNECESSARY_PARENTHESES",
4549 "Unnecessary parentheses$msg\n" . $herecurr);
4550 }
4551 }
4552
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02004553# comparisons with a constant or upper case identifier on the left
4554# avoid cases like "foo + BAR < baz"
4555# only fix matches surrounded by parentheses to avoid incorrect
4556# conversions like "FOO < baz() + 5" being "misfixed" to "baz() > FOO + 5"
4557 if ($^V && $^V ge 5.10.0 &&
4558 $line =~ /^\+(.*)\b($Constant|[A-Z_][A-Z0-9_]*)\s*($Compare)\s*($LvalOrFunc)/) {
4559 my $lead = $1;
4560 my $const = $2;
4561 my $comp = $3;
4562 my $to = $4;
4563 my $newcomp = $comp;
4564 if ($lead !~ /(?:$Operators|\.)\s*$/ &&
4565 $to !~ /^(?:Constant|[A-Z_][A-Z0-9_]*)$/ &&
4566 WARN("CONSTANT_COMPARISON",
4567 "Comparisons should place the constant on the right side of the test\n" . $herecurr) &&
4568 $fix) {
4569 if ($comp eq "<") {
4570 $newcomp = ">";
4571 } elsif ($comp eq "<=") {
4572 $newcomp = ">=";
4573 } elsif ($comp eq ">") {
4574 $newcomp = "<";
4575 } elsif ($comp eq ">=") {
4576 $newcomp = "<=";
4577 }
4578 $fixed[$fixlinenr] =~ s/\(\s*\Q$const\E\s*$Compare\s*\Q$to\E\s*\)/($to $newcomp $const)/;
4579 }
4580 }
4581
4582# Return of what appears to be an errno should normally be negative
4583 if ($sline =~ /\breturn(?:\s*\(+\s*|\s+)(E[A-Z]+)(?:\s*\)+\s*|\s*)[;:,]/) {
Joe Hershberger05622192011-10-18 10:06:59 +00004584 my $name = $1;
4585 if ($name ne 'EOF' && $name ne 'ERROR') {
4586 WARN("USE_NEGATIVE_ERRNO",
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02004587 "return of an errno should typically be negative (ie: return -$1)\n" . $herecurr);
Joe Hershberger05622192011-10-18 10:06:59 +00004588 }
4589 }
4590
Joe Hershberger05622192011-10-18 10:06:59 +00004591# Need a space before open parenthesis after if, while etc
Tom Rini6b9709d2014-02-27 08:27:28 -05004592 if ($line =~ /\b(if|while|for|switch)\(/) {
4593 if (ERROR("SPACING",
4594 "space required before the open parenthesis '('\n" . $herecurr) &&
4595 $fix) {
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02004596 $fixed[$fixlinenr] =~
Tom Rini6b9709d2014-02-27 08:27:28 -05004597 s/\b(if|while|for|switch)\(/$1 \(/;
4598 }
Joe Hershberger05622192011-10-18 10:06:59 +00004599 }
4600
4601# Check for illegal assignment in if conditional -- and check for trailing
4602# statements after the conditional.
4603 if ($line =~ /do\s*(?!{)/) {
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00004604 ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
4605 ctx_statement_block($linenr, $realcnt, 0)
4606 if (!defined $stat);
Joe Hershberger05622192011-10-18 10:06:59 +00004607 my ($stat_next) = ctx_statement_block($line_nr_next,
4608 $remain_next, $off_next);
4609 $stat_next =~ s/\n./\n /g;
4610 ##print "stat<$stat> stat_next<$stat_next>\n";
4611
4612 if ($stat_next =~ /^\s*while\b/) {
4613 # If the statement carries leading newlines,
4614 # then count those as offsets.
4615 my ($whitespace) =
4616 ($stat_next =~ /^((?:\s*\n[+-])*\s*)/s);
4617 my $offset =
4618 statement_rawlines($whitespace) - 1;
4619
4620 $suppress_whiletrailers{$line_nr_next +
4621 $offset} = 1;
4622 }
4623 }
4624 if (!defined $suppress_whiletrailers{$linenr} &&
Tom Rini6b9709d2014-02-27 08:27:28 -05004625 defined($stat) && defined($cond) &&
Joe Hershberger05622192011-10-18 10:06:59 +00004626 $line =~ /\b(?:if|while|for)\s*\(/ && $line !~ /^.\s*#/) {
4627 my ($s, $c) = ($stat, $cond);
4628
4629 if ($c =~ /\bif\s*\(.*[^<>!=]=[^=].*/s) {
4630 ERROR("ASSIGN_IN_IF",
4631 "do not use assignment in if condition\n" . $herecurr);
4632 }
4633
4634 # Find out what is on the end of the line after the
4635 # conditional.
4636 substr($s, 0, length($c), '');
4637 $s =~ s/\n.*//g;
4638 $s =~ s/$;//g; # Remove any comments
4639 if (length($c) && $s !~ /^\s*{?\s*\\*\s*$/ &&
4640 $c !~ /}\s*while\s*/)
4641 {
4642 # Find out how long the conditional actually is.
4643 my @newlines = ($c =~ /\n/gs);
4644 my $cond_lines = 1 + $#newlines;
4645 my $stat_real = '';
4646
4647 $stat_real = raw_line($linenr, $cond_lines)
4648 . "\n" if ($cond_lines);
4649 if (defined($stat_real) && $cond_lines > 1) {
4650 $stat_real = "[...]\n$stat_real";
4651 }
4652
4653 ERROR("TRAILING_STATEMENTS",
4654 "trailing statements should be on next line\n" . $herecurr . $stat_real);
4655 }
4656 }
4657
4658# Check for bitwise tests written as boolean
4659 if ($line =~ /
4660 (?:
4661 (?:\[|\(|\&\&|\|\|)
4662 \s*0[xX][0-9]+\s*
4663 (?:\&\&|\|\|)
4664 |
4665 (?:\&\&|\|\|)
4666 \s*0[xX][0-9]+\s*
4667 (?:\&\&|\|\||\)|\])
4668 )/x)
4669 {
4670 WARN("HEXADECIMAL_BOOLEAN_TEST",
4671 "boolean test with hexadecimal, perhaps just 1 \& or \|?\n" . $herecurr);
4672 }
4673
4674# if and else should not have general statements after it
4675 if ($line =~ /^.\s*(?:}\s*)?else\b(.*)/) {
4676 my $s = $1;
4677 $s =~ s/$;//g; # Remove any comments
4678 if ($s !~ /^\s*(?:\sif|(?:{|)\s*\\?\s*$)/) {
4679 ERROR("TRAILING_STATEMENTS",
4680 "trailing statements should be on next line\n" . $herecurr);
4681 }
4682 }
4683# if should not continue a brace
4684 if ($line =~ /}\s*if\b/) {
4685 ERROR("TRAILING_STATEMENTS",
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02004686 "trailing statements should be on next line (or did you mean 'else if'?)\n" .
Joe Hershberger05622192011-10-18 10:06:59 +00004687 $herecurr);
4688 }
4689# case and default should not have general statements after them
4690 if ($line =~ /^.\s*(?:case\s*.*|default\s*):/g &&
4691 $line !~ /\G(?:
4692 (?:\s*$;*)(?:\s*{)?(?:\s*$;*)(?:\s*\\)?\s*$|
4693 \s*return\s+
4694 )/xg)
4695 {
4696 ERROR("TRAILING_STATEMENTS",
4697 "trailing statements should be on next line\n" . $herecurr);
4698 }
4699
4700 # Check for }<nl>else {, these must be at the same
4701 # indent level to be relevant to each other.
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02004702 if ($prevline=~/}\s*$/ and $line=~/^.\s*else\s*/ &&
4703 $previndent == $indent) {
4704 if (ERROR("ELSE_AFTER_BRACE",
4705 "else should follow close brace '}'\n" . $hereprev) &&
4706 $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
4707 fix_delete_line($fixlinenr - 1, $prevrawline);
4708 fix_delete_line($fixlinenr, $rawline);
4709 my $fixedline = $prevrawline;
4710 $fixedline =~ s/}\s*$//;
4711 if ($fixedline !~ /^\+\s*$/) {
4712 fix_insert_line($fixlinenr, $fixedline);
4713 }
4714 $fixedline = $rawline;
4715 $fixedline =~ s/^(.\s*)else/$1} else/;
4716 fix_insert_line($fixlinenr, $fixedline);
4717 }
Joe Hershberger05622192011-10-18 10:06:59 +00004718 }
4719
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02004720 if ($prevline=~/}\s*$/ and $line=~/^.\s*while\s*/ &&
4721 $previndent == $indent) {
Joe Hershberger05622192011-10-18 10:06:59 +00004722 my ($s, $c) = ctx_statement_block($linenr, $realcnt, 0);
4723
4724 # Find out what is on the end of the line after the
4725 # conditional.
4726 substr($s, 0, length($c), '');
4727 $s =~ s/\n.*//g;
4728
4729 if ($s =~ /^\s*;/) {
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02004730 if (ERROR("WHILE_AFTER_BRACE",
4731 "while should follow close brace '}'\n" . $hereprev) &&
4732 $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
4733 fix_delete_line($fixlinenr - 1, $prevrawline);
4734 fix_delete_line($fixlinenr, $rawline);
4735 my $fixedline = $prevrawline;
4736 my $trailing = $rawline;
4737 $trailing =~ s/^\+//;
4738 $trailing = trim($trailing);
4739 $fixedline =~ s/}\s*$/} $trailing/;
4740 fix_insert_line($fixlinenr, $fixedline);
4741 }
Joe Hershberger05622192011-10-18 10:06:59 +00004742 }
4743 }
4744
Tom Rini6b9709d2014-02-27 08:27:28 -05004745#Specific variable tests
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00004746 while ($line =~ m{($Constant|$Lval)}g) {
4747 my $var = $1;
Tom Rini6b9709d2014-02-27 08:27:28 -05004748
4749#gcc binary extension
4750 if ($var =~ /^$Binary$/) {
4751 if (WARN("GCC_BINARY_CONSTANT",
4752 "Avoid gcc v4.3+ binary constant extension: <$var>\n" . $herecurr) &&
4753 $fix) {
4754 my $hexval = sprintf("0x%x", oct($var));
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02004755 $fixed[$fixlinenr] =~
Tom Rini6b9709d2014-02-27 08:27:28 -05004756 s/\b$var\b/$hexval/;
4757 }
4758 }
4759
4760#CamelCase
4761 if ($var !~ /^$Constant$/ &&
4762 $var =~ /[A-Z][a-z]|[a-z][A-Z]/ &&
4763#Ignore Page<foo> variants
4764 $var !~ /^(?:Clear|Set|TestClear|TestSet|)Page[A-Z]/ &&
4765#Ignore SI style variants like nS, mV and dB (ie: max_uV, regulator_min_uA_show)
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02004766 $var !~ /^(?:[a-z_]*?)_?[a-z][A-Z](?:_[a-z_]+)?$/ &&
4767#Ignore some three character SI units explicitly, like MiB and KHz
4768 $var !~ /^(?:[a-z_]*?)_?(?:[KMGT]iB|[KMGT]?Hz)(?:_[a-z_]+)?$/) {
Tom Rini6b9709d2014-02-27 08:27:28 -05004769 while ($var =~ m{($Ident)}g) {
4770 my $word = $1;
4771 next if ($word !~ /[A-Z][a-z]|[a-z][A-Z]/);
4772 if ($check) {
4773 seed_camelcase_includes();
4774 if (!$file && !$camelcase_file_seeded) {
4775 seed_camelcase_file($realfile);
4776 $camelcase_file_seeded = 1;
4777 }
4778 }
4779 if (!defined $camelcase{$word}) {
4780 $camelcase{$word} = 1;
4781 CHK("CAMELCASE",
4782 "Avoid CamelCase: <$word>\n" . $herecurr);
4783 }
4784 }
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00004785 }
4786 }
Joe Hershberger05622192011-10-18 10:06:59 +00004787
4788#no spaces allowed after \ in define
Tom Rini6b9709d2014-02-27 08:27:28 -05004789 if ($line =~ /\#\s*define.*\\\s+$/) {
4790 if (WARN("WHITESPACE_AFTER_LINE_CONTINUATION",
4791 "Whitespace after \\ makes next lines useless\n" . $herecurr) &&
4792 $fix) {
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02004793 $fixed[$fixlinenr] =~ s/\s+$//;
Tom Rini6b9709d2014-02-27 08:27:28 -05004794 }
Joe Hershberger05622192011-10-18 10:06:59 +00004795 }
4796
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02004797# warn if <asm/foo.h> is #included and <linux/foo.h> is available and includes
4798# itself <asm/foo.h> (uses RAW line)
Joe Hershberger05622192011-10-18 10:06:59 +00004799 if ($tree && $rawline =~ m{^.\s*\#\s*include\s*\<asm\/(.*)\.h\>}) {
4800 my $file = "$1.h";
4801 my $checkfile = "include/linux/$file";
4802 if (-f "$root/$checkfile" &&
4803 $realfile ne $checkfile &&
4804 $1 !~ /$allowed_asm_includes/)
4805 {
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02004806 my $asminclude = `grep -Ec "#include\\s+<asm/$file>" $root/$checkfile`;
4807 if ($asminclude > 0) {
4808 if ($realfile =~ m{^arch/}) {
4809 CHK("ARCH_INCLUDE_LINUX",
4810 "Consider using #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
4811 } else {
4812 WARN("INCLUDE_LINUX",
4813 "Use #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
4814 }
Joe Hershberger05622192011-10-18 10:06:59 +00004815 }
4816 }
4817 }
4818
4819# multi-statement macros should be enclosed in a do while loop, grab the
4820# first statement and ensure its the whole macro if its not enclosed
4821# in a known good container
4822 if ($realfile !~ m@/vmlinux.lds.h$@ &&
4823 $line =~ /^.\s*\#\s*define\s*$Ident(\()?/) {
4824 my $ln = $linenr;
4825 my $cnt = $realcnt;
4826 my ($off, $dstat, $dcond, $rest);
4827 my $ctx = '';
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02004828 my $has_flow_statement = 0;
4829 my $has_arg_concat = 0;
Joe Hershberger05622192011-10-18 10:06:59 +00004830 ($dstat, $dcond, $ln, $cnt, $off) =
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00004831 ctx_statement_block($linenr, $realcnt, 0);
4832 $ctx = $dstat;
Joe Hershberger05622192011-10-18 10:06:59 +00004833 #print "dstat<$dstat> dcond<$dcond> cnt<$cnt> off<$off>\n";
4834 #print "LINE<$lines[$ln-1]> len<" . length($lines[$ln-1]) . "\n";
4835
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02004836 $has_flow_statement = 1 if ($ctx =~ /\b(goto|return)\b/);
4837 $has_arg_concat = 1 if ($ctx =~ /\#\#/ && $ctx !~ /\#\#\s*(?:__VA_ARGS__|args)\b/);
4838
4839 $dstat =~ s/^.\s*\#\s*define\s+$Ident(\([^\)]*\))?\s*//;
4840 my $define_args = $1;
4841 my $define_stmt = $dstat;
4842 my @def_args = ();
4843
4844 if (defined $define_args && $define_args ne "") {
4845 $define_args = substr($define_args, 1, length($define_args) - 2);
4846 $define_args =~ s/\s*//g;
4847 @def_args = split(",", $define_args);
4848 }
4849
Joe Hershberger05622192011-10-18 10:06:59 +00004850 $dstat =~ s/$;//g;
4851 $dstat =~ s/\\\n.//g;
4852 $dstat =~ s/^\s*//s;
4853 $dstat =~ s/\s*$//s;
4854
4855 # Flatten any parentheses and braces
4856 while ($dstat =~ s/\([^\(\)]*\)/1/ ||
4857 $dstat =~ s/\{[^\{\}]*\}/1/ ||
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02004858 $dstat =~ s/.\[[^\[\]]*\]/1/)
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00004859 {
4860 }
4861
4862 # Flatten any obvious string concatentation.
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02004863 while ($dstat =~ s/($String)\s*$Ident/$1/ ||
4864 $dstat =~ s/$Ident\s*($String)/$1/)
Joe Hershberger05622192011-10-18 10:06:59 +00004865 {
4866 }
4867
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02004868 # Make asm volatile uses seem like a generic function
4869 $dstat =~ s/\b_*asm_*\s+_*volatile_*\b/asm_volatile/g;
4870
Joe Hershberger05622192011-10-18 10:06:59 +00004871 my $exceptions = qr{
4872 $Declare|
4873 module_param_named|
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00004874 MODULE_PARM_DESC|
Joe Hershberger05622192011-10-18 10:06:59 +00004875 DECLARE_PER_CPU|
4876 DEFINE_PER_CPU|
4877 __typeof__\(|
4878 union|
4879 struct|
4880 \.$Ident\s*=\s*|
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02004881 ^\"|\"$|
4882 ^\[
Joe Hershberger05622192011-10-18 10:06:59 +00004883 }x;
4884 #print "REST<$rest> dstat<$dstat> ctx<$ctx>\n";
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02004885
4886 $ctx =~ s/\n*$//;
4887 my $herectx = $here . "\n";
4888 my $stmt_cnt = statement_rawlines($ctx);
4889
4890 for (my $n = 0; $n < $stmt_cnt; $n++) {
4891 $herectx .= raw_line($linenr, $n) . "\n";
4892 }
4893
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00004894 if ($dstat ne '' &&
4895 $dstat !~ /^(?:$Ident|-?$Constant),$/ && # 10, // foo(),
4896 $dstat !~ /^(?:$Ident|-?$Constant);$/ && # foo();
Tom Rini6b9709d2014-02-27 08:27:28 -05004897 $dstat !~ /^[!~-]?(?:$Lval|$Constant)$/ && # 10 // foo() // !foo // ~foo // -foo // foo->bar // foo.bar->baz
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02004898 $dstat !~ /^'X'$/ && $dstat !~ /^'XX'$/ && # character constants
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00004899 $dstat !~ /$exceptions/ &&
4900 $dstat !~ /^\.$Ident\s*=/ && # .foo =
Tom Rini6b9709d2014-02-27 08:27:28 -05004901 $dstat !~ /^(?:\#\s*$Ident|\#\s*$Constant)\s*$/ && # stringification #foo
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00004902 $dstat !~ /^do\s*$Constant\s*while\s*$Constant;?$/ && # do {...} while (...); // do {...} while (...)
4903 $dstat !~ /^for\s*$Constant$/ && # for (...)
4904 $dstat !~ /^for\s*$Constant\s+(?:$Ident|-?$Constant)$/ && # for (...) bar()
4905 $dstat !~ /^do\s*{/ && # do {...
Heiko Schocherd8a1a302016-01-04 09:17:19 +01004906 $dstat !~ /^\(\{/ && # ({...
Tom Rini6b9709d2014-02-27 08:27:28 -05004907 $ctx !~ /^.\s*#\s*define\s+TRACE_(?:SYSTEM|INCLUDE_FILE|INCLUDE_PATH)\b/)
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00004908 {
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02004909 if ($dstat =~ /^\s*if\b/) {
4910 ERROR("MULTISTATEMENT_MACRO_USE_DO_WHILE",
4911 "Macros starting with if should be enclosed by a do - while loop to avoid possible if/else logic defects\n" . "$herectx");
4912 } elsif ($dstat =~ /;/) {
4913 ERROR("MULTISTATEMENT_MACRO_USE_DO_WHILE",
4914 "Macros with multiple statements should be enclosed in a do - while loop\n" . "$herectx");
4915 } else {
4916 ERROR("COMPLEX_MACRO",
4917 "Macros with complex values should be enclosed in parentheses\n" . "$herectx");
4918 }
4919
4920 }
4921
4922 # Make $define_stmt single line, comment-free, etc
4923 my @stmt_array = split('\n', $define_stmt);
4924 my $first = 1;
4925 $define_stmt = "";
4926 foreach my $l (@stmt_array) {
4927 $l =~ s/\\$//;
4928 if ($first) {
4929 $define_stmt = $l;
4930 $first = 0;
4931 } elsif ($l =~ /^[\+ ]/) {
4932 $define_stmt .= substr($l, 1);
4933 }
4934 }
4935 $define_stmt =~ s/$;//g;
4936 $define_stmt =~ s/\s+/ /g;
4937 $define_stmt = trim($define_stmt);
4938
4939# check if any macro arguments are reused (ignore '...' and 'type')
4940 foreach my $arg (@def_args) {
4941 next if ($arg =~ /\.\.\./);
4942 next if ($arg =~ /^type$/i);
4943 my $tmp_stmt = $define_stmt;
4944 $tmp_stmt =~ s/\b(typeof|__typeof__|__builtin\w+|typecheck\s*\(\s*$Type\s*,|\#+)\s*\(*\s*$arg\s*\)*\b//g;
4945 $tmp_stmt =~ s/\#+\s*$arg\b//g;
4946 $tmp_stmt =~ s/\b$arg\s*\#\#//g;
4947 my $use_cnt = $tmp_stmt =~ s/\b$arg\b//g;
4948 if ($use_cnt > 1) {
4949 CHK("MACRO_ARG_REUSE",
4950 "Macro argument reuse '$arg' - possible side-effects?\n" . "$herectx");
4951 }
4952# check if any macro arguments may have other precedence issues
4953 if ($tmp_stmt =~ m/($Operators)?\s*\b$arg\b\s*($Operators)?/m &&
4954 ((defined($1) && $1 ne ',') ||
4955 (defined($2) && $2 ne ','))) {
4956 CHK("MACRO_ARG_PRECEDENCE",
4957 "Macro argument '$arg' may be better as '($arg)' to avoid precedence issues\n" . "$herectx");
4958 }
4959 }
4960
4961# check for macros with flow control, but without ## concatenation
4962# ## concatenation is commonly a macro that defines a function so ignore those
4963 if ($has_flow_statement && !$has_arg_concat) {
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00004964 my $herectx = $here . "\n";
4965 my $cnt = statement_rawlines($ctx);
4966
4967 for (my $n = 0; $n < $cnt; $n++) {
4968 $herectx .= raw_line($linenr, $n) . "\n";
Joe Hershberger05622192011-10-18 10:06:59 +00004969 }
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02004970 WARN("MACRO_WITH_FLOW_CONTROL",
4971 "Macros with flow control statements should be avoided\n" . "$herectx");
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00004972 }
4973
4974# check for line continuations outside of #defines, preprocessor #, and asm
4975
4976 } else {
4977 if ($prevline !~ /^..*\\$/ &&
4978 $line !~ /^\+\s*\#.*\\$/ && # preprocessor
4979 $line !~ /^\+.*\b(__asm__|asm)\b.*\\$/ && # asm
4980 $line =~ /^\+.*\\$/) {
4981 WARN("LINE_CONTINUATIONS",
4982 "Avoid unnecessary line continuations\n" . $herecurr);
4983 }
4984 }
4985
4986# do {} while (0) macro tests:
4987# single-statement macros do not need to be enclosed in do while (0) loop,
4988# macro should not end with a semicolon
4989 if ($^V && $^V ge 5.10.0 &&
4990 $realfile !~ m@/vmlinux.lds.h$@ &&
4991 $line =~ /^.\s*\#\s*define\s+$Ident(\()?/) {
4992 my $ln = $linenr;
4993 my $cnt = $realcnt;
4994 my ($off, $dstat, $dcond, $rest);
4995 my $ctx = '';
4996 ($dstat, $dcond, $ln, $cnt, $off) =
4997 ctx_statement_block($linenr, $realcnt, 0);
4998 $ctx = $dstat;
4999
5000 $dstat =~ s/\\\n.//g;
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02005001 $dstat =~ s/$;/ /g;
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00005002
5003 if ($dstat =~ /^\+\s*#\s*define\s+$Ident\s*${balanced_parens}\s*do\s*{(.*)\s*}\s*while\s*\(\s*0\s*\)\s*([;\s]*)\s*$/) {
5004 my $stmts = $2;
5005 my $semis = $3;
5006
5007 $ctx =~ s/\n*$//;
5008 my $cnt = statement_rawlines($ctx);
5009 my $herectx = $here . "\n";
5010
5011 for (my $n = 0; $n < $cnt; $n++) {
5012 $herectx .= raw_line($linenr, $n) . "\n";
5013 }
5014
5015 if (($stmts =~ tr/;/;/) == 1 &&
5016 $stmts !~ /^\s*(if|while|for|switch)\b/) {
5017 WARN("SINGLE_STATEMENT_DO_WHILE_MACRO",
5018 "Single statement macros should not use a do {} while (0) loop\n" . "$herectx");
5019 }
5020 if (defined $semis && $semis ne "") {
5021 WARN("DO_WHILE_MACRO_WITH_TRAILING_SEMICOLON",
5022 "do {} while (0) macros should not be semicolon terminated\n" . "$herectx");
Joe Hershberger05622192011-10-18 10:06:59 +00005023 }
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02005024 } elsif ($dstat =~ /^\+\s*#\s*define\s+$Ident.*;\s*$/) {
5025 $ctx =~ s/\n*$//;
5026 my $cnt = statement_rawlines($ctx);
5027 my $herectx = $here . "\n";
5028
5029 for (my $n = 0; $n < $cnt; $n++) {
5030 $herectx .= raw_line($linenr, $n) . "\n";
5031 }
5032
5033 WARN("TRAILING_SEMICOLON",
5034 "macros should not use a trailing semicolon\n" . "$herectx");
Joe Hershberger05622192011-10-18 10:06:59 +00005035 }
5036 }
5037
5038# make sure symbols are always wrapped with VMLINUX_SYMBOL() ...
5039# all assignments may have only one of the following with an assignment:
5040# .
5041# ALIGN(...)
5042# VMLINUX_SYMBOL(...)
5043 if ($realfile eq 'vmlinux.lds.h' && $line =~ /(?:(?:^|\s)$Ident\s*=|=\s*$Ident(?:\s|$))/) {
5044 WARN("MISSING_VMLINUX_SYMBOL",
5045 "vmlinux.lds.h needs VMLINUX_SYMBOL() around C-visible symbols\n" . $herecurr);
5046 }
5047
5048# check for redundant bracing round if etc
5049 if ($line =~ /(^.*)\bif\b/ && $1 !~ /else\s*$/) {
5050 my ($level, $endln, @chunks) =
5051 ctx_statement_full($linenr, $realcnt, 1);
5052 #print "chunks<$#chunks> linenr<$linenr> endln<$endln> level<$level>\n";
5053 #print "APW: <<$chunks[1][0]>><<$chunks[1][1]>>\n";
5054 if ($#chunks > 0 && $level == 0) {
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00005055 my @allowed = ();
5056 my $allow = 0;
Joe Hershberger05622192011-10-18 10:06:59 +00005057 my $seen = 0;
5058 my $herectx = $here . "\n";
5059 my $ln = $linenr - 1;
5060 for my $chunk (@chunks) {
5061 my ($cond, $block) = @{$chunk};
5062
5063 # If the condition carries leading newlines, then count those as offsets.
5064 my ($whitespace) = ($cond =~ /^((?:\s*\n[+-])*\s*)/s);
5065 my $offset = statement_rawlines($whitespace) - 1;
5066
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00005067 $allowed[$allow] = 0;
Joe Hershberger05622192011-10-18 10:06:59 +00005068 #print "COND<$cond> whitespace<$whitespace> offset<$offset>\n";
5069
5070 # We have looked at and allowed this specific line.
5071 $suppress_ifbraces{$ln + $offset} = 1;
5072
5073 $herectx .= "$rawlines[$ln + $offset]\n[...]\n";
5074 $ln += statement_rawlines($block) - 1;
5075
5076 substr($block, 0, length($cond), '');
5077
5078 $seen++ if ($block =~ /^\s*{/);
5079
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00005080 #print "cond<$cond> block<$block> allowed<$allowed[$allow]>\n";
Joe Hershberger05622192011-10-18 10:06:59 +00005081 if (statement_lines($cond) > 1) {
5082 #print "APW: ALLOWED: cond<$cond>\n";
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00005083 $allowed[$allow] = 1;
Joe Hershberger05622192011-10-18 10:06:59 +00005084 }
5085 if ($block =~/\b(?:if|for|while)\b/) {
5086 #print "APW: ALLOWED: block<$block>\n";
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00005087 $allowed[$allow] = 1;
Joe Hershberger05622192011-10-18 10:06:59 +00005088 }
5089 if (statement_block_size($block) > 1) {
5090 #print "APW: ALLOWED: lines block<$block>\n";
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00005091 $allowed[$allow] = 1;
Joe Hershberger05622192011-10-18 10:06:59 +00005092 }
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00005093 $allow++;
Joe Hershberger05622192011-10-18 10:06:59 +00005094 }
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00005095 if ($seen) {
5096 my $sum_allowed = 0;
5097 foreach (@allowed) {
5098 $sum_allowed += $_;
5099 }
5100 if ($sum_allowed == 0) {
5101 WARN("BRACES",
5102 "braces {} are not necessary for any arm of this statement\n" . $herectx);
5103 } elsif ($sum_allowed != $allow &&
5104 $seen != $allow) {
5105 CHK("BRACES",
5106 "braces {} should be used on all arms of this statement\n" . $herectx);
5107 }
Joe Hershberger05622192011-10-18 10:06:59 +00005108 }
5109 }
5110 }
5111 if (!defined $suppress_ifbraces{$linenr - 1} &&
5112 $line =~ /\b(if|while|for|else)\b/) {
5113 my $allowed = 0;
5114
5115 # Check the pre-context.
5116 if (substr($line, 0, $-[0]) =~ /(\}\s*)$/) {
5117 #print "APW: ALLOWED: pre<$1>\n";
5118 $allowed = 1;
5119 }
5120
5121 my ($level, $endln, @chunks) =
5122 ctx_statement_full($linenr, $realcnt, $-[0]);
5123
5124 # Check the condition.
5125 my ($cond, $block) = @{$chunks[0]};
5126 #print "CHECKING<$linenr> cond<$cond> block<$block>\n";
5127 if (defined $cond) {
5128 substr($block, 0, length($cond), '');
5129 }
5130 if (statement_lines($cond) > 1) {
5131 #print "APW: ALLOWED: cond<$cond>\n";
5132 $allowed = 1;
5133 }
5134 if ($block =~/\b(?:if|for|while)\b/) {
5135 #print "APW: ALLOWED: block<$block>\n";
5136 $allowed = 1;
5137 }
5138 if (statement_block_size($block) > 1) {
5139 #print "APW: ALLOWED: lines block<$block>\n";
5140 $allowed = 1;
5141 }
5142 # Check the post-context.
5143 if (defined $chunks[1]) {
5144 my ($cond, $block) = @{$chunks[1]};
5145 if (defined $cond) {
5146 substr($block, 0, length($cond), '');
5147 }
5148 if ($block =~ /^\s*\{/) {
5149 #print "APW: ALLOWED: chunk-1 block<$block>\n";
5150 $allowed = 1;
5151 }
5152 }
5153 if ($level == 0 && $block =~ /^\s*\{/ && !$allowed) {
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00005154 my $herectx = $here . "\n";
Joe Hershberger05622192011-10-18 10:06:59 +00005155 my $cnt = statement_rawlines($block);
5156
5157 for (my $n = 0; $n < $cnt; $n++) {
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00005158 $herectx .= raw_line($linenr, $n) . "\n";
Joe Hershberger05622192011-10-18 10:06:59 +00005159 }
5160
5161 WARN("BRACES",
5162 "braces {} are not necessary for single statement blocks\n" . $herectx);
5163 }
5164 }
5165
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02005166# check for single line unbalanced braces
5167 if ($sline =~ /^.\s*\}\s*else\s*$/ ||
5168 $sline =~ /^.\s*else\s*\{\s*$/) {
5169 CHK("BRACES", "Unbalanced braces around else statement\n" . $herecurr);
5170 }
5171
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00005172# check for unnecessary blank lines around braces
Tom Rini6b9709d2014-02-27 08:27:28 -05005173 if (($line =~ /^.\s*}\s*$/ && $prevrawline =~ /^.\s*$/)) {
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02005174 if (CHK("BRACES",
5175 "Blank lines aren't necessary before a close brace '}'\n" . $hereprev) &&
5176 $fix && $prevrawline =~ /^\+/) {
5177 fix_delete_line($fixlinenr - 1, $prevrawline);
5178 }
Joe Hershberger05622192011-10-18 10:06:59 +00005179 }
Tom Rini6b9709d2014-02-27 08:27:28 -05005180 if (($rawline =~ /^.\s*$/ && $prevline =~ /^..*{\s*$/)) {
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02005181 if (CHK("BRACES",
5182 "Blank lines aren't necessary after an open brace '{'\n" . $hereprev) &&
5183 $fix) {
5184 fix_delete_line($fixlinenr, $rawline);
5185 }
Joe Hershberger05622192011-10-18 10:06:59 +00005186 }
5187
5188# no volatiles please
5189 my $asm_volatile = qr{\b(__asm__|asm)\s+(__volatile__|volatile)\b};
5190 if ($line =~ /\bvolatile\b/ && $line !~ /$asm_volatile/) {
5191 WARN("VOLATILE",
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02005192 "Use of volatile is usually wrong: see Documentation/process/volatile-considered-harmful.rst\n" . $herecurr);
5193 }
5194
5195# Check for user-visible strings broken across lines, which breaks the ability
5196# to grep for the string. Make exceptions when the previous string ends in a
5197# newline (multiple lines in one string constant) or '\t', '\r', ';', or '{'
5198# (common in inline assembly) or is a octal \123 or hexadecimal \xaf value
5199 if ($line =~ /^\+\s*$String/ &&
5200 $prevline =~ /"\s*$/ &&
5201 $prevrawline !~ /(?:\\(?:[ntr]|[0-7]{1,3}|x[0-9a-fA-F]{1,2})|;\s*|\{\s*)"\s*$/) {
5202 if (WARN("SPLIT_STRING",
5203 "quoted string split across lines\n" . $hereprev) &&
5204 $fix &&
5205 $prevrawline =~ /^\+.*"\s*$/ &&
5206 $last_coalesced_string_linenr != $linenr - 1) {
5207 my $extracted_string = get_quoted_string($line, $rawline);
5208 my $comma_close = "";
5209 if ($rawline =~ /\Q$extracted_string\E(\s*\)\s*;\s*$|\s*,\s*)/) {
5210 $comma_close = $1;
5211 }
5212
5213 fix_delete_line($fixlinenr - 1, $prevrawline);
5214 fix_delete_line($fixlinenr, $rawline);
5215 my $fixedline = $prevrawline;
5216 $fixedline =~ s/"\s*$//;
5217 $fixedline .= substr($extracted_string, 1) . trim($comma_close);
5218 fix_insert_line($fixlinenr - 1, $fixedline);
5219 $fixedline = $rawline;
5220 $fixedline =~ s/\Q$extracted_string\E\Q$comma_close\E//;
5221 if ($fixedline !~ /\+\s*$/) {
5222 fix_insert_line($fixlinenr, $fixedline);
5223 }
5224 $last_coalesced_string_linenr = $linenr;
5225 }
5226 }
5227
5228# check for missing a space in a string concatenation
5229 if ($prevrawline =~ /[^\\]\w"$/ && $rawline =~ /^\+[\t ]+"\w/) {
5230 WARN('MISSING_SPACE',
5231 "break quoted strings at a space character\n" . $hereprev);
5232 }
5233
5234# check for an embedded function name in a string when the function is known
5235# This does not work very well for -f --file checking as it depends on patch
5236# context providing the function name or a single line form for in-file
5237# function declarations
5238 if ($line =~ /^\+.*$String/ &&
5239 defined($context_function) &&
5240 get_quoted_string($line, $rawline) =~ /\b$context_function\b/ &&
5241 length(get_quoted_string($line, $rawline)) != (length($context_function) + 2)) {
5242 WARN("EMBEDDED_FUNCTION_NAME",
5243 "Prefer using '\"%s...\", __func__' to using '$context_function', this function's name, in a string\n" . $herecurr);
5244 }
5245
5246# check for spaces before a quoted newline
5247 if ($rawline =~ /^.*\".*\s\\n/) {
5248 if (WARN("QUOTED_WHITESPACE_BEFORE_NEWLINE",
5249 "unnecessary whitespace before a quoted newline\n" . $herecurr) &&
5250 $fix) {
5251 $fixed[$fixlinenr] =~ s/^(\+.*\".*)\s+\\n/$1\\n/;
5252 }
5253
5254 }
5255
5256# concatenated string without spaces between elements
5257 if ($line =~ /$String[A-Z_]/ || $line =~ /[A-Za-z0-9_]$String/) {
5258 CHK("CONCATENATED_STRING",
5259 "Concatenated strings should use spaces between elements\n" . $herecurr);
5260 }
5261
5262# uncoalesced string fragments
5263 if ($line =~ /$String\s*"/) {
5264 WARN("STRING_FRAGMENTS",
5265 "Consecutive strings are generally better as a single string\n" . $herecurr);
5266 }
5267
5268# check for non-standard and hex prefixed decimal printf formats
5269 my $show_L = 1; #don't show the same defect twice
5270 my $show_Z = 1;
5271 while ($line =~ /(?:^|")([X\t]*)(?:"|$)/g) {
5272 my $string = substr($rawline, $-[1], $+[1] - $-[1]);
5273 $string =~ s/%%/__/g;
5274 # check for %L
5275 if ($show_L && $string =~ /%[\*\d\.\$]*L([diouxX])/) {
5276 WARN("PRINTF_L",
5277 "\%L$1 is non-standard C, use %ll$1\n" . $herecurr);
5278 $show_L = 0;
5279 }
5280 # check for %Z
5281 if ($show_Z && $string =~ /%[\*\d\.\$]*Z([diouxX])/) {
5282 WARN("PRINTF_Z",
5283 "%Z$1 is non-standard C, use %z$1\n" . $herecurr);
5284 $show_Z = 0;
5285 }
5286 # check for 0x<decimal>
5287 if ($string =~ /0x%[\*\d\.\$\Llzth]*[diou]/) {
5288 ERROR("PRINTF_0XDECIMAL",
5289 "Prefixing 0x with decimal output is defective\n" . $herecurr);
5290 }
5291 }
5292
5293# check for line continuations in quoted strings with odd counts of "
5294 if ($rawline =~ /\\$/ && $rawline =~ tr/"/"/ % 2) {
5295 WARN("LINE_CONTINUATIONS",
5296 "Avoid line continuations in quoted strings\n" . $herecurr);
Joe Hershberger05622192011-10-18 10:06:59 +00005297 }
5298
5299# warn about #if 0
5300 if ($line =~ /^.\s*\#\s*if\s+0\b/) {
5301 CHK("REDUNDANT_CODE",
5302 "if this code is redundant consider removing it\n" .
5303 $herecurr);
5304 }
5305
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00005306# check for needless "if (<foo>) fn(<foo>)" uses
5307 if ($prevline =~ /\bif\s*\(\s*($Lval)\s*\)/) {
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02005308 my $tested = quotemeta($1);
5309 my $expr = '\s*\(\s*' . $tested . '\s*\)\s*;';
5310 if ($line =~ /\b(kfree|usb_free_urb|debugfs_remove(?:_recursive)?|(?:kmem_cache|mempool|dma_pool)_destroy)$expr/) {
5311 my $func = $1;
5312 if (WARN('NEEDLESS_IF',
5313 "$func(NULL) is safe and this check is probably not required\n" . $hereprev) &&
5314 $fix) {
5315 my $do_fix = 1;
5316 my $leading_tabs = "";
5317 my $new_leading_tabs = "";
5318 if ($lines[$linenr - 2] =~ /^\+(\t*)if\s*\(\s*$tested\s*\)\s*$/) {
5319 $leading_tabs = $1;
5320 } else {
5321 $do_fix = 0;
5322 }
5323 if ($lines[$linenr - 1] =~ /^\+(\t+)$func\s*\(\s*$tested\s*\)\s*;\s*$/) {
5324 $new_leading_tabs = $1;
5325 if (length($leading_tabs) + 1 ne length($new_leading_tabs)) {
5326 $do_fix = 0;
5327 }
5328 } else {
5329 $do_fix = 0;
5330 }
5331 if ($do_fix) {
5332 fix_delete_line($fixlinenr - 1, $prevrawline);
5333 $fixed[$fixlinenr] =~ s/^\+$new_leading_tabs/\+$leading_tabs/;
5334 }
5335 }
5336 }
5337 }
5338
5339# check for unnecessary "Out of Memory" messages
5340 if ($line =~ /^\+.*\b$logFunctions\s*\(/ &&
5341 $prevline =~ /^[ \+]\s*if\s*\(\s*(\!\s*|NULL\s*==\s*)?($Lval)(\s*==\s*NULL\s*)?\s*\)/ &&
5342 (defined $1 || defined $3) &&
5343 $linenr > 3) {
5344 my $testval = $2;
5345 my $testline = $lines[$linenr - 3];
5346
5347 my ($s, $c) = ctx_statement_block($linenr - 3, $realcnt, 0);
5348# print("line: <$line>\nprevline: <$prevline>\ns: <$s>\nc: <$c>\n\n\n");
5349
5350 if ($s =~ /(?:^|\n)[ \+]\s*(?:$Type\s*)?\Q$testval\E\s*=\s*(?:\([^\)]*\)\s*)?\s*(?:devm_)?(?:[kv][czm]alloc(?:_node|_array)?\b|kstrdup|kmemdup|(?:dev_)?alloc_skb)/) {
5351 WARN("OOM_MESSAGE",
5352 "Possible unnecessary 'out of memory' message\n" . $hereprev);
5353 }
5354 }
5355
5356# check for logging functions with KERN_<LEVEL>
5357 if ($line !~ /printk(?:_ratelimited|_once)?\s*\(/ &&
5358 $line =~ /\b$logFunctions\s*\(.*\b(KERN_[A-Z]+)\b/) {
5359 my $level = $1;
5360 if (WARN("UNNECESSARY_KERN_LEVEL",
5361 "Possible unnecessary $level\n" . $herecurr) &&
5362 $fix) {
5363 $fixed[$fixlinenr] =~ s/\s*$level\s*//;
5364 }
5365 }
5366
5367# check for logging continuations
5368 if ($line =~ /\bprintk\s*\(\s*KERN_CONT\b|\bpr_cont\s*\(/) {
5369 WARN("LOGGING_CONTINUATION",
5370 "Avoid logging continuation uses where feasible\n" . $herecurr);
5371 }
5372
5373# check for mask then right shift without a parentheses
5374 if ($^V && $^V ge 5.10.0 &&
5375 $line =~ /$LvalOrFunc\s*\&\s*($LvalOrFunc)\s*>>/ &&
5376 $4 !~ /^\&/) { # $LvalOrFunc may be &foo, ignore if so
5377 WARN("MASK_THEN_SHIFT",
5378 "Possible precedence defect with mask then right shift - may need parentheses\n" . $herecurr);
5379 }
5380
5381# check for pointer comparisons to NULL
5382 if ($^V && $^V ge 5.10.0) {
5383 while ($line =~ /\b$LvalOrFunc\s*(==|\!=)\s*NULL\b/g) {
5384 my $val = $1;
5385 my $equal = "!";
5386 $equal = "" if ($4 eq "!=");
5387 if (CHK("COMPARISON_TO_NULL",
5388 "Comparison to NULL could be written \"${equal}${val}\"\n" . $herecurr) &&
5389 $fix) {
5390 $fixed[$fixlinenr] =~ s/\b\Q$val\E\s*(?:==|\!=)\s*NULL\b/$equal$val/;
5391 }
Joe Hershberger05622192011-10-18 10:06:59 +00005392 }
5393 }
5394
Tom Rini6b9709d2014-02-27 08:27:28 -05005395# check for bad placement of section $InitAttribute (e.g.: __initdata)
5396 if ($line =~ /(\b$InitAttribute\b)/) {
5397 my $attr = $1;
5398 if ($line =~ /^\+\s*static\s+(?:const\s+)?(?:$attr\s+)?($NonptrTypeWithAttr)\s+(?:$attr\s+)?($Ident(?:\[[^]]*\])?)\s*[=;]/) {
5399 my $ptr = $1;
5400 my $var = $2;
5401 if ((($ptr =~ /\b(union|struct)\s+$attr\b/ &&
5402 ERROR("MISPLACED_INIT",
5403 "$attr should be placed after $var\n" . $herecurr)) ||
5404 ($ptr !~ /\b(union|struct)\s+$attr\b/ &&
5405 WARN("MISPLACED_INIT",
5406 "$attr should be placed after $var\n" . $herecurr))) &&
5407 $fix) {
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02005408 $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;
Tom Rini6b9709d2014-02-27 08:27:28 -05005409 }
5410 }
5411 }
5412
5413# check for $InitAttributeData (ie: __initdata) with const
5414 if ($line =~ /\bconst\b/ && $line =~ /($InitAttributeData)/) {
5415 my $attr = $1;
5416 $attr =~ /($InitAttributePrefix)(.*)/;
5417 my $attr_prefix = $1;
5418 my $attr_type = $2;
5419 if (ERROR("INIT_ATTRIBUTE",
5420 "Use of const init definition must use ${attr_prefix}initconst\n" . $herecurr) &&
5421 $fix) {
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02005422 $fixed[$fixlinenr] =~
Tom Rini6b9709d2014-02-27 08:27:28 -05005423 s/$InitAttributeData/${attr_prefix}initconst/;
5424 }
5425 }
5426
5427# check for $InitAttributeConst (ie: __initconst) without const
5428 if ($line !~ /\bconst\b/ && $line =~ /($InitAttributeConst)/) {
5429 my $attr = $1;
5430 if (ERROR("INIT_ATTRIBUTE",
5431 "Use of $attr requires a separate use of const\n" . $herecurr) &&
5432 $fix) {
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02005433 my $lead = $fixed[$fixlinenr] =~
Tom Rini6b9709d2014-02-27 08:27:28 -05005434 /(^\+\s*(?:static\s+))/;
5435 $lead = rtrim($1);
5436 $lead = "$lead " if ($lead !~ /^\+$/);
5437 $lead = "${lead}const ";
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02005438 $fixed[$fixlinenr] =~ s/(^\+\s*(?:static\s+))/$lead/;
5439 }
5440 }
5441
5442# check for __read_mostly with const non-pointer (should just be const)
5443 if ($line =~ /\b__read_mostly\b/ &&
5444 $line =~ /($Type)\s*$Ident/ && $1 !~ /\*\s*$/ && $1 =~ /\bconst\b/) {
5445 if (ERROR("CONST_READ_MOSTLY",
5446 "Invalid use of __read_mostly with const type\n" . $herecurr) &&
5447 $fix) {
5448 $fixed[$fixlinenr] =~ s/\s+__read_mostly\b//;
5449 }
5450 }
5451
5452# don't use __constant_<foo> functions outside of include/uapi/
5453 if ($realfile !~ m@^include/uapi/@ &&
5454 $line =~ /(__constant_(?:htons|ntohs|[bl]e(?:16|32|64)_to_cpu|cpu_to_[bl]e(?:16|32|64)))\s*\(/) {
5455 my $constant_func = $1;
5456 my $func = $constant_func;
5457 $func =~ s/^__constant_//;
5458 if (WARN("CONSTANT_CONVERSION",
5459 "$constant_func should be $func\n" . $herecurr) &&
5460 $fix) {
5461 $fixed[$fixlinenr] =~ s/\b$constant_func\b/$func/g;
Tom Rini6b9709d2014-02-27 08:27:28 -05005462 }
5463 }
5464
Joe Hershberger05622192011-10-18 10:06:59 +00005465# prefer usleep_range over udelay
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00005466 if ($line =~ /\budelay\s*\(\s*(\d+)\s*\)/) {
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02005467 my $delay = $1;
Joe Hershberger05622192011-10-18 10:06:59 +00005468 # ignore udelay's < 10, however
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02005469 if (! ($delay < 10) ) {
Joe Hershberger05622192011-10-18 10:06:59 +00005470 CHK("USLEEP_RANGE",
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02005471 "usleep_range is preferred over udelay; see Documentation/timers/timers-howto.txt\n" . $herecurr);
5472 }
5473 if ($delay > 2000) {
5474 WARN("LONG_UDELAY",
5475 "long udelay - prefer mdelay; see arch/arm/include/asm/delay.h\n" . $herecurr);
Joe Hershberger05622192011-10-18 10:06:59 +00005476 }
5477 }
5478
5479# warn about unexpectedly long msleep's
5480 if ($line =~ /\bmsleep\s*\((\d+)\);/) {
5481 if ($1 < 20) {
5482 WARN("MSLEEP",
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02005483 "msleep < 20ms can sleep for up to 20ms; see Documentation/timers/timers-howto.txt\n" . $herecurr);
Joe Hershberger05622192011-10-18 10:06:59 +00005484 }
5485 }
5486
Tom Rini6b9709d2014-02-27 08:27:28 -05005487# check for comparisons of jiffies
5488 if ($line =~ /\bjiffies\s*$Compare|$Compare\s*jiffies\b/) {
5489 WARN("JIFFIES_COMPARISON",
5490 "Comparing jiffies is almost always wrong; prefer time_after, time_before and friends\n" . $herecurr);
5491 }
5492
5493# check for comparisons of get_jiffies_64()
5494 if ($line =~ /\bget_jiffies_64\s*\(\s*\)\s*$Compare|$Compare\s*get_jiffies_64\s*\(\s*\)/) {
5495 WARN("JIFFIES_COMPARISON",
5496 "Comparing get_jiffies_64() is almost always wrong; prefer time_after64, time_before64 and friends\n" . $herecurr);
5497 }
5498
Joe Hershberger05622192011-10-18 10:06:59 +00005499# warn about #ifdefs in C files
5500# if ($line =~ /^.\s*\#\s*if(|n)def/ && ($realfile =~ /\.c$/)) {
5501# print "#ifdef in C files should be avoided\n";
5502# print "$herecurr";
5503# $clean = 0;
5504# }
5505
5506# warn about spacing in #ifdefs
5507 if ($line =~ /^.\s*\#\s*(ifdef|ifndef|elif)\s\s+/) {
Tom Rini6b9709d2014-02-27 08:27:28 -05005508 if (ERROR("SPACING",
5509 "exactly one space required after that #$1\n" . $herecurr) &&
5510 $fix) {
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02005511 $fixed[$fixlinenr] =~
Tom Rini6b9709d2014-02-27 08:27:28 -05005512 s/^(.\s*\#\s*(ifdef|ifndef|elif))\s{2,}/$1 /;
5513 }
5514
Joe Hershberger05622192011-10-18 10:06:59 +00005515 }
5516
5517# check for spinlock_t definitions without a comment.
5518 if ($line =~ /^.\s*(struct\s+mutex|spinlock_t)\s+\S+;/ ||
5519 $line =~ /^.\s*(DEFINE_MUTEX)\s*\(/) {
5520 my $which = $1;
5521 if (!ctx_has_comment($first_line, $linenr)) {
5522 CHK("UNCOMMENTED_DEFINITION",
5523 "$1 definition without comment\n" . $herecurr);
5524 }
5525 }
5526# check for memory barriers without a comment.
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02005527
5528 my $barriers = qr{
5529 mb|
5530 rmb|
5531 wmb|
5532 read_barrier_depends
5533 }x;
5534 my $barrier_stems = qr{
5535 mb__before_atomic|
5536 mb__after_atomic|
5537 store_release|
5538 load_acquire|
5539 store_mb|
5540 (?:$barriers)
5541 }x;
5542 my $all_barriers = qr{
5543 (?:$barriers)|
5544 smp_(?:$barrier_stems)|
5545 virt_(?:$barrier_stems)
5546 }x;
5547
5548 if ($line =~ /\b(?:$all_barriers)\s*\(/) {
Joe Hershberger05622192011-10-18 10:06:59 +00005549 if (!ctx_has_comment($first_line, $linenr)) {
Tom Rini6b9709d2014-02-27 08:27:28 -05005550 WARN("MEMORY_BARRIER",
5551 "memory barrier without comment\n" . $herecurr);
Joe Hershberger05622192011-10-18 10:06:59 +00005552 }
5553 }
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02005554
5555 my $underscore_smp_barriers = qr{__smp_(?:$barrier_stems)}x;
5556
5557 if ($realfile !~ m@^include/asm-generic/@ &&
5558 $realfile !~ m@/barrier\.h$@ &&
5559 $line =~ m/\b(?:$underscore_smp_barriers)\s*\(/ &&
5560 $line !~ m/^.\s*\#\s*define\s+(?:$underscore_smp_barriers)\s*\(/) {
5561 WARN("MEMORY_BARRIER",
5562 "__smp memory barriers shouldn't be used outside barrier.h and asm-generic\n" . $herecurr);
5563 }
5564
5565# check for waitqueue_active without a comment.
5566 if ($line =~ /\bwaitqueue_active\s*\(/) {
5567 if (!ctx_has_comment($first_line, $linenr)) {
5568 WARN("WAITQUEUE_ACTIVE",
5569 "waitqueue_active without comment\n" . $herecurr);
5570 }
5571 }
5572
Joe Hershberger05622192011-10-18 10:06:59 +00005573# check of hardware specific defines
5574 if ($line =~ m@^.\s*\#\s*if.*\b(__i386__|__powerpc64__|__sun__|__s390x__)\b@ && $realfile !~ m@include/asm-@) {
5575 CHK("ARCH_DEFINES",
5576 "architecture specific defines should be avoided\n" . $herecurr);
5577 }
5578
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02005579# check that the storage class is not after a type
5580 if ($line =~ /\b($Type)\s+($Storage)\b/) {
Joe Hershberger05622192011-10-18 10:06:59 +00005581 WARN("STORAGE_CLASS",
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02005582 "storage class '$2' should be located before type '$1'\n" . $herecurr);
5583 }
5584# Check that the storage class is at the beginning of a declaration
5585 if ($line =~ /\b$Storage\b/ &&
5586 $line !~ /^.\s*$Storage/ &&
5587 $line =~ /^.\s*(.+?)\$Storage\s/ &&
5588 $1 !~ /[\,\)]\s*$/) {
5589 WARN("STORAGE_CLASS",
5590 "storage class should be at the beginning of the declaration\n" . $herecurr);
Joe Hershberger05622192011-10-18 10:06:59 +00005591 }
5592
5593# check the location of the inline attribute, that it is between
5594# storage class and type.
5595 if ($line =~ /\b$Type\s+$Inline\b/ ||
5596 $line =~ /\b$Inline\s+$Storage\b/) {
5597 ERROR("INLINE_LOCATION",
5598 "inline keyword should sit between storage class and type\n" . $herecurr);
5599 }
5600
5601# Check for __inline__ and __inline, prefer inline
Tom Rini6b9709d2014-02-27 08:27:28 -05005602 if ($realfile !~ m@\binclude/uapi/@ &&
5603 $line =~ /\b(__inline__|__inline)\b/) {
5604 if (WARN("INLINE",
5605 "plain inline is preferred over $1\n" . $herecurr) &&
5606 $fix) {
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02005607 $fixed[$fixlinenr] =~ s/\b(__inline__|__inline)\b/inline/;
Tom Rini6b9709d2014-02-27 08:27:28 -05005608
5609 }
Joe Hershberger05622192011-10-18 10:06:59 +00005610 }
5611
5612# Check for __attribute__ packed, prefer __packed
Tom Rini6b9709d2014-02-27 08:27:28 -05005613 if ($realfile !~ m@\binclude/uapi/@ &&
5614 $line =~ /\b__attribute__\s*\(\s*\(.*\bpacked\b/) {
Joe Hershberger05622192011-10-18 10:06:59 +00005615 WARN("PREFER_PACKED",
5616 "__packed is preferred over __attribute__((packed))\n" . $herecurr);
5617 }
5618
Heinrich Schuchardt5c761ce2017-09-13 04:59:05 +02005619# Check for new packed members, warn to use care
5620 if ($realfile !~ m@\binclude/uapi/@ &&
5621 $line =~ /\b(__attribute__\s*\(\s*\(.*\bpacked|__packed)\b/) {
5622 WARN("NEW_PACKED",
5623 "Adding new packed members is to be done with care\n" . $herecurr);
5624 }
5625
Joe Hershberger05622192011-10-18 10:06:59 +00005626# Check for __attribute__ aligned, prefer __aligned
Tom Rini6b9709d2014-02-27 08:27:28 -05005627 if ($realfile !~ m@\binclude/uapi/@ &&
5628 $line =~ /\b__attribute__\s*\(\s*\(.*aligned/) {
Joe Hershberger05622192011-10-18 10:06:59 +00005629 WARN("PREFER_ALIGNED",
5630 "__aligned(size) is preferred over __attribute__((aligned(size)))\n" . $herecurr);
5631 }
5632
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00005633# Check for __attribute__ format(printf, prefer __printf
Tom Rini6b9709d2014-02-27 08:27:28 -05005634 if ($realfile !~ m@\binclude/uapi/@ &&
5635 $line =~ /\b__attribute__\s*\(\s*\(\s*format\s*\(\s*printf/) {
5636 if (WARN("PREFER_PRINTF",
5637 "__printf(string-index, first-to-check) is preferred over __attribute__((format(printf, string-index, first-to-check)))\n" . $herecurr) &&
5638 $fix) {
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02005639 $fixed[$fixlinenr] =~ s/\b__attribute__\s*\(\s*\(\s*format\s*\(\s*printf\s*,\s*(.*)\)\s*\)\s*\)/"__printf(" . trim($1) . ")"/ex;
Tom Rini6b9709d2014-02-27 08:27:28 -05005640
5641 }
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00005642 }
5643
5644# Check for __attribute__ format(scanf, prefer __scanf
Tom Rini6b9709d2014-02-27 08:27:28 -05005645 if ($realfile !~ m@\binclude/uapi/@ &&
5646 $line =~ /\b__attribute__\s*\(\s*\(\s*format\s*\(\s*scanf\b/) {
5647 if (WARN("PREFER_SCANF",
5648 "__scanf(string-index, first-to-check) is preferred over __attribute__((format(scanf, string-index, first-to-check)))\n" . $herecurr) &&
5649 $fix) {
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02005650 $fixed[$fixlinenr] =~ s/\b__attribute__\s*\(\s*\(\s*format\s*\(\s*scanf\s*,\s*(.*)\)\s*\)\s*\)/"__scanf(" . trim($1) . ")"/ex;
5651 }
5652 }
5653
5654# Check for __attribute__ weak, or __weak declarations (may have link issues)
5655 if ($^V && $^V ge 5.10.0 &&
5656 $line =~ /(?:$Declare|$DeclareMisordered)\s*$Ident\s*$balanced_parens\s*(?:$Attribute)?\s*;/ &&
5657 ($line =~ /\b__attribute__\s*\(\s*\(.*\bweak\b/ ||
5658 $line =~ /\b__weak\b/)) {
5659 ERROR("WEAK_DECLARATION",
5660 "Using weak declarations can have unintended link defects\n" . $herecurr);
5661 }
5662
5663# check for c99 types like uint8_t used outside of uapi/ and tools/
5664 if ($realfile !~ m@\binclude/uapi/@ &&
5665 $realfile !~ m@\btools/@ &&
5666 $line =~ /\b($Declare)\s*$Ident\s*[=;,\[]/) {
5667 my $type = $1;
5668 if ($type =~ /\b($typeC99Typedefs)\b/) {
5669 $type = $1;
5670 my $kernel_type = 'u';
5671 $kernel_type = 's' if ($type =~ /^_*[si]/);
5672 $type =~ /(\d+)/;
5673 $kernel_type .= $1;
5674 if (CHK("PREFER_KERNEL_TYPES",
5675 "Prefer kernel type '$kernel_type' over '$type'\n" . $herecurr) &&
5676 $fix) {
5677 $fixed[$fixlinenr] =~ s/\b$type\b/$kernel_type/;
5678 }
5679 }
5680 }
5681
5682# check for cast of C90 native int or longer types constants
5683 if ($line =~ /(\(\s*$C90_int_types\s*\)\s*)($Constant)\b/) {
5684 my $cast = $1;
5685 my $const = $2;
5686 if (WARN("TYPECAST_INT_CONSTANT",
5687 "Unnecessary typecast of c90 int constant\n" . $herecurr) &&
5688 $fix) {
5689 my $suffix = "";
5690 my $newconst = $const;
5691 $newconst =~ s/${Int_type}$//;
5692 $suffix .= 'U' if ($cast =~ /\bunsigned\b/);
5693 if ($cast =~ /\blong\s+long\b/) {
5694 $suffix .= 'LL';
5695 } elsif ($cast =~ /\blong\b/) {
5696 $suffix .= 'L';
5697 }
5698 $fixed[$fixlinenr] =~ s/\Q$cast\E$const\b/$newconst$suffix/;
Tom Rini6b9709d2014-02-27 08:27:28 -05005699 }
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00005700 }
5701
Joe Hershberger05622192011-10-18 10:06:59 +00005702# check for sizeof(&)
5703 if ($line =~ /\bsizeof\s*\(\s*\&/) {
5704 WARN("SIZEOF_ADDRESS",
5705 "sizeof(& should be avoided\n" . $herecurr);
5706 }
5707
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00005708# check for sizeof without parenthesis
5709 if ($line =~ /\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/) {
Tom Rini6b9709d2014-02-27 08:27:28 -05005710 if (WARN("SIZEOF_PARENTHESIS",
5711 "sizeof $1 should be sizeof($1)\n" . $herecurr) &&
5712 $fix) {
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02005713 $fixed[$fixlinenr] =~ s/\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/"sizeof(" . trim($1) . ")"/ex;
Tom Rini6b9709d2014-02-27 08:27:28 -05005714 }
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00005715 }
5716
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00005717# check for struct spinlock declarations
5718 if ($line =~ /^.\s*\bstruct\s+spinlock\s+\w+\s*;/) {
5719 WARN("USE_SPINLOCK_T",
5720 "struct spinlock should be spinlock_t\n" . $herecurr);
5721 }
5722
Tom Rini6b9709d2014-02-27 08:27:28 -05005723# check for seq_printf uses that could be seq_puts
5724 if ($sline =~ /\bseq_printf\s*\(.*"\s*\)\s*;\s*$/) {
5725 my $fmt = get_quoted_string($line, $rawline);
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02005726 $fmt =~ s/%%//g;
5727 if ($fmt !~ /%/) {
Tom Rini6b9709d2014-02-27 08:27:28 -05005728 if (WARN("PREFER_SEQ_PUTS",
5729 "Prefer seq_puts to seq_printf\n" . $herecurr) &&
5730 $fix) {
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02005731 $fixed[$fixlinenr] =~ s/\bseq_printf\b/seq_puts/;
Tom Rini6b9709d2014-02-27 08:27:28 -05005732 }
5733 }
5734 }
5735
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02005736 # check for vsprintf extension %p<foo> misuses
5737 if ($^V && $^V ge 5.10.0 &&
5738 defined $stat &&
5739 $stat =~ /^\+(?![^\{]*\{\s*).*\b(\w+)\s*\(.*$String\s*,/s &&
5740 $1 !~ /^_*volatile_*$/) {
5741 my $bad_extension = "";
5742 my $lc = $stat =~ tr@\n@@;
5743 $lc = $lc + $linenr;
5744 for (my $count = $linenr; $count <= $lc; $count++) {
5745 my $fmt = get_quoted_string($lines[$count - 1], raw_line($count, 0));
5746 $fmt =~ s/%%//g;
5747 if ($fmt =~ /(\%[\*\d\.]*p(?![\WFfSsBKRraEhMmIiUDdgVCbGNO]).)/) {
5748 $bad_extension = $1;
5749 last;
5750 }
5751 }
5752 if ($bad_extension ne "") {
5753 my $stat_real = raw_line($linenr, 0);
5754 for (my $count = $linenr + 1; $count <= $lc; $count++) {
5755 $stat_real = $stat_real . "\n" . raw_line($count, 0);
5756 }
5757 WARN("VSPRINTF_POINTER_EXTENSION",
5758 "Invalid vsprintf pointer extension '$bad_extension'\n" . "$here\n$stat_real\n");
5759 }
5760 }
5761
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00005762# Check for misused memsets
5763 if ($^V && $^V ge 5.10.0 &&
5764 defined $stat &&
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02005765 $stat =~ /^\+(?:.*?)\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*$FuncArg\s*\)/) {
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00005766
5767 my $ms_addr = $2;
5768 my $ms_val = $7;
5769 my $ms_size = $12;
5770
5771 if ($ms_size =~ /^(0x|)0$/i) {
5772 ERROR("MEMSET",
5773 "memset to 0's uses 0 as the 2nd argument, not the 3rd\n" . "$here\n$stat\n");
5774 } elsif ($ms_size =~ /^(0x|)1$/i) {
5775 WARN("MEMSET",
5776 "single byte memset is suspicious. Swapped 2nd/3rd argument?\n" . "$here\n$stat\n");
5777 }
5778 }
5779
Tom Rini6b9709d2014-02-27 08:27:28 -05005780# Check for memcpy(foo, bar, ETH_ALEN) that could be ether_addr_copy(foo, bar)
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02005781# if ($^V && $^V ge 5.10.0 &&
5782# defined $stat &&
5783# $stat =~ /^\+(?:.*?)\bmemcpy\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/) {
5784# if (WARN("PREFER_ETHER_ADDR_COPY",
5785# "Prefer ether_addr_copy() over memcpy() if the Ethernet addresses are __aligned(2)\n" . "$here\n$stat\n") &&
5786# $fix) {
5787# $fixed[$fixlinenr] =~ s/\bmemcpy\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/ether_addr_copy($2, $7)/;
5788# }
5789# }
5790
5791# Check for memcmp(foo, bar, ETH_ALEN) that could be ether_addr_equal*(foo, bar)
5792# if ($^V && $^V ge 5.10.0 &&
5793# defined $stat &&
5794# $stat =~ /^\+(?:.*?)\bmemcmp\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/) {
5795# WARN("PREFER_ETHER_ADDR_EQUAL",
5796# "Prefer ether_addr_equal() or ether_addr_equal_unaligned() over memcmp()\n" . "$here\n$stat\n")
5797# }
5798
5799# check for memset(foo, 0x0, ETH_ALEN) that could be eth_zero_addr
5800# check for memset(foo, 0xFF, ETH_ALEN) that could be eth_broadcast_addr
5801# if ($^V && $^V ge 5.10.0 &&
5802# defined $stat &&
5803# $stat =~ /^\+(?:.*?)\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/) {
5804#
5805# my $ms_val = $7;
5806#
5807# if ($ms_val =~ /^(?:0x|)0+$/i) {
5808# if (WARN("PREFER_ETH_ZERO_ADDR",
5809# "Prefer eth_zero_addr over memset()\n" . "$here\n$stat\n") &&
5810# $fix) {
5811# $fixed[$fixlinenr] =~ s/\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*,\s*ETH_ALEN\s*\)/eth_zero_addr($2)/;
5812# }
5813# } elsif ($ms_val =~ /^(?:0xff|255)$/i) {
5814# if (WARN("PREFER_ETH_BROADCAST_ADDR",
5815# "Prefer eth_broadcast_addr() over memset()\n" . "$here\n$stat\n") &&
5816# $fix) {
5817# $fixed[$fixlinenr] =~ s/\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*,\s*ETH_ALEN\s*\)/eth_broadcast_addr($2)/;
5818# }
5819# }
5820# }
Tom Rini6b9709d2014-02-27 08:27:28 -05005821
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00005822# typecasts on min/max could be min_t/max_t
5823 if ($^V && $^V ge 5.10.0 &&
5824 defined $stat &&
5825 $stat =~ /^\+(?:.*?)\b(min|max)\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\)/) {
5826 if (defined $2 || defined $7) {
5827 my $call = $1;
5828 my $cast1 = deparenthesize($2);
5829 my $arg1 = $3;
5830 my $cast2 = deparenthesize($7);
5831 my $arg2 = $8;
5832 my $cast;
5833
5834 if ($cast1 ne "" && $cast2 ne "" && $cast1 ne $cast2) {
5835 $cast = "$cast1 or $cast2";
5836 } elsif ($cast1 ne "") {
5837 $cast = $cast1;
5838 } else {
5839 $cast = $cast2;
5840 }
5841 WARN("MINMAX",
5842 "$call() should probably be ${call}_t($cast, $arg1, $arg2)\n" . "$here\n$stat\n");
5843 }
5844 }
5845
5846# check usleep_range arguments
5847 if ($^V && $^V ge 5.10.0 &&
5848 defined $stat &&
5849 $stat =~ /^\+(?:.*?)\busleep_range\s*\(\s*($FuncArg)\s*,\s*($FuncArg)\s*\)/) {
5850 my $min = $1;
5851 my $max = $7;
5852 if ($min eq $max) {
5853 WARN("USLEEP_RANGE",
5854 "usleep_range should not use min == max args; see Documentation/timers/timers-howto.txt\n" . "$here\n$stat\n");
5855 } elsif ($min =~ /^\d+$/ && $max =~ /^\d+$/ &&
5856 $min > $max) {
5857 WARN("USLEEP_RANGE",
5858 "usleep_range args reversed, use min then max; see Documentation/timers/timers-howto.txt\n" . "$here\n$stat\n");
5859 }
5860 }
5861
Tom Rini6b9709d2014-02-27 08:27:28 -05005862# check for naked sscanf
5863 if ($^V && $^V ge 5.10.0 &&
5864 defined $stat &&
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02005865 $line =~ /\bsscanf\b/ &&
Tom Rini6b9709d2014-02-27 08:27:28 -05005866 ($stat !~ /$Ident\s*=\s*sscanf\s*$balanced_parens/ &&
5867 $stat !~ /\bsscanf\s*$balanced_parens\s*(?:$Compare)/ &&
5868 $stat !~ /(?:$Compare)\s*\bsscanf\s*$balanced_parens/)) {
5869 my $lc = $stat =~ tr@\n@@;
5870 $lc = $lc + $linenr;
5871 my $stat_real = raw_line($linenr, 0);
5872 for (my $count = $linenr + 1; $count <= $lc; $count++) {
5873 $stat_real = $stat_real . "\n" . raw_line($count, 0);
5874 }
5875 WARN("NAKED_SSCANF",
5876 "unchecked sscanf return value\n" . "$here\n$stat_real\n");
5877 }
5878
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02005879# check for simple sscanf that should be kstrto<foo>
5880 if ($^V && $^V ge 5.10.0 &&
5881 defined $stat &&
5882 $line =~ /\bsscanf\b/) {
5883 my $lc = $stat =~ tr@\n@@;
5884 $lc = $lc + $linenr;
5885 my $stat_real = raw_line($linenr, 0);
5886 for (my $count = $linenr + 1; $count <= $lc; $count++) {
5887 $stat_real = $stat_real . "\n" . raw_line($count, 0);
5888 }
5889 if ($stat_real =~ /\bsscanf\b\s*\(\s*$FuncArg\s*,\s*("[^"]+")/) {
5890 my $format = $6;
5891 my $count = $format =~ tr@%@%@;
5892 if ($count == 1 &&
5893 $format =~ /^"\%(?i:ll[udxi]|[udxi]ll|ll|[hl]h?[udxi]|[udxi][hl]h?|[hl]h?|[udxi])"$/) {
5894 WARN("SSCANF_TO_KSTRTO",
5895 "Prefer kstrto<type> to single variable sscanf\n" . "$here\n$stat_real\n");
5896 }
5897 }
5898 }
5899
Tom Rini6b9709d2014-02-27 08:27:28 -05005900# check for new externs in .h files.
5901 if ($realfile =~ /\.h$/ &&
5902 $line =~ /^\+\s*(extern\s+)$Type\s*$Ident\s*\(/s) {
5903 if (CHK("AVOID_EXTERNS",
5904 "extern prototypes should be avoided in .h files\n" . $herecurr) &&
5905 $fix) {
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02005906 $fixed[$fixlinenr] =~ s/(.*)\bextern\b\s*(.*)/$1$2/;
Tom Rini6b9709d2014-02-27 08:27:28 -05005907 }
5908 }
5909
Joe Hershberger05622192011-10-18 10:06:59 +00005910# check for new externs in .c files.
5911 if ($realfile =~ /\.c$/ && defined $stat &&
5912 $stat =~ /^.\s*(?:extern\s+)?$Type\s+($Ident)(\s*)\(/s)
5913 {
5914 my $function_name = $1;
5915 my $paren_space = $2;
5916
5917 my $s = $stat;
5918 if (defined $cond) {
5919 substr($s, 0, length($cond), '');
5920 }
5921 if ($s =~ /^\s*;/ &&
5922 $function_name ne 'uninitialized_var')
5923 {
5924 WARN("AVOID_EXTERNS",
5925 "externs should be avoided in .c files\n" . $herecurr);
5926 }
5927
5928 if ($paren_space =~ /\n/) {
5929 WARN("FUNCTION_ARGUMENTS",
5930 "arguments for function declarations should follow identifier\n" . $herecurr);
5931 }
5932
5933 } elsif ($realfile =~ /\.c$/ && defined $stat &&
5934 $stat =~ /^.\s*extern\s+/)
5935 {
5936 WARN("AVOID_EXTERNS",
5937 "externs should be avoided in .c files\n" . $herecurr);
5938 }
5939
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02005940# check for function declarations that have arguments without identifier names
5941 if (defined $stat &&
5942 $stat =~ /^.\s*(?:extern\s+)?$Type\s*$Ident\s*\(\s*([^{]+)\s*\)\s*;/s &&
5943 $1 ne "void") {
5944 my $args = trim($1);
5945 while ($args =~ m/\s*($Type\s*(?:$Ident|\(\s*\*\s*$Ident?\s*\)\s*$balanced_parens)?)/g) {
5946 my $arg = trim($1);
5947 if ($arg =~ /^$Type$/ && $arg !~ /enum\s+$Ident$/) {
5948 WARN("FUNCTION_ARGUMENTS",
5949 "function definition argument '$arg' should also have an identifier name\n" . $herecurr);
5950 }
5951 }
5952 }
5953
5954# check for function definitions
5955 if ($^V && $^V ge 5.10.0 &&
5956 defined $stat &&
5957 $stat =~ /^.\s*(?:$Storage\s+)?$Type\s*($Ident)\s*$balanced_parens\s*{/s) {
5958 $context_function = $1;
5959
5960# check for multiline function definition with misplaced open brace
5961 my $ok = 0;
5962 my $cnt = statement_rawlines($stat);
5963 my $herectx = $here . "\n";
5964 for (my $n = 0; $n < $cnt; $n++) {
5965 my $rl = raw_line($linenr, $n);
5966 $herectx .= $rl . "\n";
5967 $ok = 1 if ($rl =~ /^[ \+]\{/);
5968 $ok = 1 if ($rl =~ /\{/ && $n == 0);
5969 last if $rl =~ /^[ \+].*\{/;
5970 }
5971 if (!$ok) {
5972 ERROR("OPEN_BRACE",
5973 "open brace '{' following function definitions go on the next line\n" . $herectx);
5974 }
5975 }
5976
Joe Hershberger05622192011-10-18 10:06:59 +00005977# checks for new __setup's
5978 if ($rawline =~ /\b__setup\("([^"]*)"/) {
5979 my $name = $1;
5980
5981 if (!grep(/$name/, @setup_docs)) {
5982 CHK("UNDOCUMENTED_SETUP",
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02005983 "__setup appears un-documented -- check Documentation/admin-guide/kernel-parameters.rst\n" . $herecurr);
Joe Hershberger05622192011-10-18 10:06:59 +00005984 }
5985 }
5986
5987# check for pointless casting of kmalloc return
5988 if ($line =~ /\*\s*\)\s*[kv][czm]alloc(_node){0,1}\b/) {
5989 WARN("UNNECESSARY_CASTS",
5990 "unnecessary cast may hide bugs, see http://c-faq.com/malloc/mallocnocast.html\n" . $herecurr);
5991 }
5992
Tom Rini6b9709d2014-02-27 08:27:28 -05005993# alloc style
5994# p = alloc(sizeof(struct foo), ...) should be p = alloc(sizeof(*p), ...)
5995 if ($^V && $^V ge 5.10.0 &&
5996 $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*([kv][mz]alloc(?:_node)?)\s*\(\s*(sizeof\s*\(\s*struct\s+$Lval\s*\))/) {
5997 CHK("ALLOC_SIZEOF_STRUCT",
5998 "Prefer $3(sizeof(*$1)...) over $3($4...)\n" . $herecurr);
5999 }
6000
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02006001# check for k[mz]alloc with multiplies that could be kmalloc_array/kcalloc
6002 if ($^V && $^V ge 5.10.0 &&
6003 defined $stat &&
6004 $stat =~ /^\+\s*($Lval)\s*\=\s*(?:$balanced_parens)?\s*(k[mz]alloc)\s*\(\s*($FuncArg)\s*\*\s*($FuncArg)\s*,/) {
6005 my $oldfunc = $3;
6006 my $a1 = $4;
6007 my $a2 = $10;
6008 my $newfunc = "kmalloc_array";
6009 $newfunc = "kcalloc" if ($oldfunc eq "kzalloc");
6010 my $r1 = $a1;
6011 my $r2 = $a2;
6012 if ($a1 =~ /^sizeof\s*\S/) {
6013 $r1 = $a2;
6014 $r2 = $a1;
6015 }
6016 if ($r1 !~ /^sizeof\b/ && $r2 =~ /^sizeof\s*\S/ &&
6017 !($r1 =~ /^$Constant$/ || $r1 =~ /^[A-Z_][A-Z0-9_]*$/)) {
6018 my $ctx = '';
6019 my $herectx = $here . "\n";
6020 my $cnt = statement_rawlines($stat);
6021 for (my $n = 0; $n < $cnt; $n++) {
6022 $herectx .= raw_line($linenr, $n) . "\n";
6023 }
6024 if (WARN("ALLOC_WITH_MULTIPLY",
6025 "Prefer $newfunc over $oldfunc with multiply\n" . $herectx) &&
6026 $cnt == 1 &&
6027 $fix) {
6028 $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;
6029 }
6030 }
6031 }
6032
Tom Rini6b9709d2014-02-27 08:27:28 -05006033# check for krealloc arg reuse
6034 if ($^V && $^V ge 5.10.0 &&
6035 $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*krealloc\s*\(\s*\1\s*,/) {
6036 WARN("KREALLOC_ARG_REUSE",
6037 "Reusing the krealloc arg is almost always a bug\n" . $herecurr);
6038 }
6039
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00006040# check for alloc argument mismatch
6041 if ($line =~ /\b(kcalloc|kmalloc_array)\s*\(\s*sizeof\b/) {
6042 WARN("ALLOC_ARRAY_ARGS",
6043 "$1 uses number as first arg, sizeof is generally wrong\n" . $herecurr);
Joe Hershberger05622192011-10-18 10:06:59 +00006044 }
6045
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00006046# check for multiple semicolons
6047 if ($line =~ /;\s*;\s*$/) {
Tom Rini6b9709d2014-02-27 08:27:28 -05006048 if (WARN("ONE_SEMICOLON",
6049 "Statements terminations use 1 semicolon\n" . $herecurr) &&
6050 $fix) {
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02006051 $fixed[$fixlinenr] =~ s/(\s*;\s*){2,}$/;/g;
6052 }
6053 }
6054
6055# check for #defines like: 1 << <digit> that could be BIT(digit), it is not exported to uapi
6056 if ($realfile !~ m@^include/uapi/@ &&
6057 $line =~ /#\s*define\s+\w+\s+\(?\s*1\s*([ulUL]*)\s*\<\<\s*(?:\d+|$Ident)\s*\)?/) {
6058 my $ull = "";
6059 $ull = "_ULL" if (defined($1) && $1 =~ /ll/i);
6060 if (CHK("BIT_MACRO",
6061 "Prefer using the BIT$ull macro\n" . $herecurr) &&
6062 $fix) {
6063 $fixed[$fixlinenr] =~ s/\(?\s*1\s*[ulUL]*\s*<<\s*(\d+|$Ident)\s*\)?/BIT${ull}($1)/;
6064 }
6065 }
6066
6067# check for #if defined CONFIG_<FOO> || defined CONFIG_<FOO>_MODULE
6068 if ($line =~ /^\+\s*#\s*if\s+defined(?:\s*\(?\s*|\s+)(CONFIG_[A-Z_]+)\s*\)?\s*\|\|\s*defined(?:\s*\(?\s*|\s+)\1_MODULE\s*\)?\s*$/) {
6069 my $config = $1;
6070 if (WARN("PREFER_IS_ENABLED",
6071 "Prefer IS_ENABLED(<FOO>) to CONFIG_<FOO> || CONFIG_<FOO>_MODULE\n" . $herecurr) &&
6072 $fix) {
6073 $fixed[$fixlinenr] = "\+#if IS_ENABLED($config)";
Tom Rini6b9709d2014-02-27 08:27:28 -05006074 }
6075 }
6076
Robert P. J. Dayfc0b5942016-09-07 14:27:59 -04006077# check for case / default statements not preceded by break/fallthrough/switch
Tom Rini6b9709d2014-02-27 08:27:28 -05006078 if ($line =~ /^.\s*(?:case\s+(?:$Ident|$Constant)\s*|default):/) {
6079 my $has_break = 0;
6080 my $has_statement = 0;
6081 my $count = 0;
6082 my $prevline = $linenr;
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02006083 while ($prevline > 1 && ($file || $count < 3) && !$has_break) {
Tom Rini6b9709d2014-02-27 08:27:28 -05006084 $prevline--;
6085 my $rline = $rawlines[$prevline - 1];
6086 my $fline = $lines[$prevline - 1];
6087 last if ($fline =~ /^\@\@/);
6088 next if ($fline =~ /^\-/);
6089 next if ($fline =~ /^.(?:\s*(?:case\s+(?:$Ident|$Constant)[\s$;]*|default):[\s$;]*)*$/);
6090 $has_break = 1 if ($rline =~ /fall[\s_-]*(through|thru)/i);
6091 next if ($fline =~ /^.[\s$;]*$/);
6092 $has_statement = 1;
6093 $count++;
6094 $has_break = 1 if ($fline =~ /\bswitch\b|\b(?:break\s*;[\s$;]*$|return\b|goto\b|continue\b)/);
6095 }
6096 if (!$has_break && $has_statement) {
6097 WARN("MISSING_BREAK",
Robert P. J. Dayfc0b5942016-09-07 14:27:59 -04006098 "Possible switch case/default not preceded by break or fallthrough comment\n" . $herecurr);
Tom Rini6b9709d2014-02-27 08:27:28 -05006099 }
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00006100 }
6101
6102# check for switch/default statements without a break;
6103 if ($^V && $^V ge 5.10.0 &&
6104 defined $stat &&
6105 $stat =~ /^\+[$;\s]*(?:case[$;\s]+\w+[$;\s]*:[$;\s]*|)*[$;\s]*\bdefault[$;\s]*:[$;\s]*;/g) {
6106 my $ctx = '';
6107 my $herectx = $here . "\n";
6108 my $cnt = statement_rawlines($stat);
6109 for (my $n = 0; $n < $cnt; $n++) {
6110 $herectx .= raw_line($linenr, $n) . "\n";
6111 }
6112 WARN("DEFAULT_NO_BREAK",
6113 "switch default: should use break\n" . $herectx);
Eric Nelson172a3a82012-05-02 20:32:18 -07006114 }
6115
Joe Hershberger05622192011-10-18 10:06:59 +00006116# check for gcc specific __FUNCTION__
Tom Rini6b9709d2014-02-27 08:27:28 -05006117 if ($line =~ /\b__FUNCTION__\b/) {
6118 if (WARN("USE_FUNC",
6119 "__func__ should be used instead of gcc specific __FUNCTION__\n" . $herecurr) &&
6120 $fix) {
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02006121 $fixed[$fixlinenr] =~ s/\b__FUNCTION__\b/__func__/g;
Tom Rini6b9709d2014-02-27 08:27:28 -05006122 }
Joe Hershberger05622192011-10-18 10:06:59 +00006123 }
6124
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02006125# check for uses of __DATE__, __TIME__, __TIMESTAMP__
6126 while ($line =~ /\b(__(?:DATE|TIME|TIMESTAMP)__)\b/g) {
6127 ERROR("DATE_TIME",
6128 "Use of the '$1' macro makes the build non-deterministic\n" . $herecurr);
6129 }
6130
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00006131# check for use of yield()
6132 if ($line =~ /\byield\s*\(\s*\)/) {
6133 WARN("YIELD",
6134 "Using yield() is generally wrong. See yield() kernel-doc (sched/core.c)\n" . $herecurr);
6135 }
6136
Tom Rini6b9709d2014-02-27 08:27:28 -05006137# check for comparisons against true and false
6138 if ($line =~ /\+\s*(.*?)\b(true|false|$Lval)\s*(==|\!=)\s*(true|false|$Lval)\b(.*)$/i) {
6139 my $lead = $1;
6140 my $arg = $2;
6141 my $test = $3;
6142 my $otype = $4;
6143 my $trail = $5;
6144 my $op = "!";
6145
6146 ($arg, $otype) = ($otype, $arg) if ($arg =~ /^(?:true|false)$/i);
6147
6148 my $type = lc($otype);
6149 if ($type =~ /^(?:true|false)$/) {
6150 if (("$test" eq "==" && "$type" eq "true") ||
6151 ("$test" eq "!=" && "$type" eq "false")) {
6152 $op = "";
6153 }
6154
6155 CHK("BOOL_COMPARISON",
6156 "Using comparison to $otype is error prone\n" . $herecurr);
6157
6158## maybe suggesting a correct construct would better
6159## "Using comparison to $otype is error prone. Perhaps use '${lead}${op}${arg}${trail}'\n" . $herecurr);
6160
6161 }
6162 }
6163
Joe Hershberger05622192011-10-18 10:06:59 +00006164# check for semaphores initialized locked
6165 if ($line =~ /^.\s*sema_init.+,\W?0\W?\)/) {
6166 WARN("CONSIDER_COMPLETION",
6167 "consider using a completion\n" . $herecurr);
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00006168 }
Joe Hershberger05622192011-10-18 10:06:59 +00006169
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00006170# recommend kstrto* over simple_strto* and strict_strto*
6171 if ($line =~ /\b((simple|strict)_(strto(l|ll|ul|ull)))\s*\(/) {
Joe Hershberger05622192011-10-18 10:06:59 +00006172 WARN("CONSIDER_KSTRTO",
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00006173 "$1 is obsolete, use k$3 instead\n" . $herecurr);
Joe Hershberger05622192011-10-18 10:06:59 +00006174 }
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00006175
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02006176# check for __initcall(), use device_initcall() explicitly or more appropriate function please
Joe Hershberger05622192011-10-18 10:06:59 +00006177 if ($line =~ /^.\s*__initcall\s*\(/) {
6178 WARN("USE_DEVICE_INITCALL",
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02006179 "please use device_initcall() or more appropriate function instead of __initcall() (see include/linux/init.h)\n" . $herecurr);
Joe Hershberger05622192011-10-18 10:06:59 +00006180 }
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00006181
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02006182# check for various structs that are normally const (ops, kgdb, device_tree)
6183# and avoid what seem like struct definitions 'struct foo {'
Joe Hershberger05622192011-10-18 10:06:59 +00006184 if ($line !~ /\bconst\b/ &&
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02006185 $line =~ /\bstruct\s+($const_structs)\b(?!\s*\{)/) {
Joe Hershberger05622192011-10-18 10:06:59 +00006186 WARN("CONST_STRUCT",
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02006187 "struct $1 should normally be const\n" . $herecurr);
Joe Hershberger05622192011-10-18 10:06:59 +00006188 }
6189
6190# use of NR_CPUS is usually wrong
6191# ignore definitions of NR_CPUS and usage to define arrays as likely right
6192 if ($line =~ /\bNR_CPUS\b/ &&
6193 $line !~ /^.\s*\s*#\s*if\b.*\bNR_CPUS\b/ &&
6194 $line !~ /^.\s*\s*#\s*define\b.*\bNR_CPUS\b/ &&
6195 $line !~ /^.\s*$Declare\s.*\[[^\]]*NR_CPUS[^\]]*\]/ &&
6196 $line !~ /\[[^\]]*\.\.\.[^\]]*NR_CPUS[^\]]*\]/ &&
6197 $line !~ /\[[^\]]*NR_CPUS[^\]]*\.\.\.[^\]]*\]/)
6198 {
6199 WARN("NR_CPUS",
6200 "usage of NR_CPUS is often wrong - consider using cpu_possible(), num_possible_cpus(), for_each_possible_cpu(), etc\n" . $herecurr);
6201 }
6202
Tom Rini6b9709d2014-02-27 08:27:28 -05006203# Use of __ARCH_HAS_<FOO> or ARCH_HAVE_<BAR> is wrong.
6204 if ($line =~ /\+\s*#\s*define\s+((?:__)?ARCH_(?:HAS|HAVE)\w*)\b/) {
6205 ERROR("DEFINE_ARCH_HAS",
6206 "#define of '$1' is wrong - use Kconfig variables or standard guards instead\n" . $herecurr);
6207 }
6208
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02006209# likely/unlikely comparisons similar to "(likely(foo) > 0)"
6210 if ($^V && $^V ge 5.10.0 &&
6211 $line =~ /\b((?:un)?likely)\s*\(\s*$FuncArg\s*\)\s*$Compare/) {
6212 WARN("LIKELY_MISUSE",
6213 "Using $1 should generally have parentheses around the comparison\n" . $herecurr);
Joe Hershberger05622192011-10-18 10:06:59 +00006214 }
6215
6216# whine mightly about in_atomic
6217 if ($line =~ /\bin_atomic\s*\(/) {
6218 if ($realfile =~ m@^drivers/@) {
6219 ERROR("IN_ATOMIC",
6220 "do not use in_atomic in drivers\n" . $herecurr);
6221 } elsif ($realfile !~ m@^kernel/@) {
6222 WARN("IN_ATOMIC",
6223 "use of in_atomic() is incorrect outside core kernel code\n" . $herecurr);
6224 }
6225 }
6226
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02006227# whine about ACCESS_ONCE
6228 if ($^V && $^V ge 5.10.0 &&
6229 $line =~ /\bACCESS_ONCE\s*$balanced_parens\s*(=(?!=))?\s*($FuncArg)?/) {
6230 my $par = $1;
6231 my $eq = $2;
6232 my $fun = $3;
6233 $par =~ s/^\(\s*(.*)\s*\)$/$1/;
6234 if (defined($eq)) {
6235 if (WARN("PREFER_WRITE_ONCE",
6236 "Prefer WRITE_ONCE(<FOO>, <BAR>) over ACCESS_ONCE(<FOO>) = <BAR>\n" . $herecurr) &&
6237 $fix) {
6238 $fixed[$fixlinenr] =~ s/\bACCESS_ONCE\s*\(\s*\Q$par\E\s*\)\s*$eq\s*\Q$fun\E/WRITE_ONCE($par, $fun)/;
6239 }
6240 } else {
6241 if (WARN("PREFER_READ_ONCE",
6242 "Prefer READ_ONCE(<FOO>) over ACCESS_ONCE(<FOO>)\n" . $herecurr) &&
6243 $fix) {
6244 $fixed[$fixlinenr] =~ s/\bACCESS_ONCE\s*\(\s*\Q$par\E\s*\)/READ_ONCE($par)/;
6245 }
6246 }
6247 }
6248
6249# check for mutex_trylock_recursive usage
6250 if ($line =~ /mutex_trylock_recursive/) {
6251 ERROR("LOCKING",
6252 "recursive locking is bad, do not use this ever.\n" . $herecurr);
6253 }
6254
Joe Hershberger05622192011-10-18 10:06:59 +00006255# check for lockdep_set_novalidate_class
6256 if ($line =~ /^.\s*lockdep_set_novalidate_class\s*\(/ ||
6257 $line =~ /__lockdep_no_validate__\s*\)/ ) {
6258 if ($realfile !~ m@^kernel/lockdep@ &&
6259 $realfile !~ m@^include/linux/lockdep@ &&
6260 $realfile !~ m@^drivers/base/core@) {
6261 ERROR("LOCKDEP",
6262 "lockdep_no_validate class is reserved for device->mutex.\n" . $herecurr);
6263 }
6264 }
6265
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02006266 if ($line =~ /debugfs_create_\w+.*\b$mode_perms_world_writable\b/ ||
6267 $line =~ /DEVICE_ATTR.*\b$mode_perms_world_writable\b/) {
Joe Hershberger05622192011-10-18 10:06:59 +00006268 WARN("EXPORTED_WORLD_WRITABLE",
6269 "Exporting world writable files is usually an error. Consider more restrictive permissions.\n" . $herecurr);
6270 }
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02006271
6272# Mode permission misuses where it seems decimal should be octal
6273# This uses a shortcut match to avoid unnecessary uses of a slow foreach loop
6274 if ($^V && $^V ge 5.10.0 &&
6275 defined $stat &&
6276 $line =~ /$mode_perms_search/) {
6277 foreach my $entry (@mode_permission_funcs) {
6278 my $func = $entry->[0];
6279 my $arg_pos = $entry->[1];
6280
6281 my $lc = $stat =~ tr@\n@@;
6282 $lc = $lc + $linenr;
6283 my $stat_real = raw_line($linenr, 0);
6284 for (my $count = $linenr + 1; $count <= $lc; $count++) {
6285 $stat_real = $stat_real . "\n" . raw_line($count, 0);
6286 }
6287
6288 my $skip_args = "";
6289 if ($arg_pos > 1) {
6290 $arg_pos--;
6291 $skip_args = "(?:\\s*$FuncArg\\s*,\\s*){$arg_pos,$arg_pos}";
6292 }
6293 my $test = "\\b$func\\s*\\(${skip_args}($FuncArg(?:\\|\\s*$FuncArg)*)\\s*[,\\)]";
6294 if ($stat =~ /$test/) {
6295 my $val = $1;
6296 $val = $6 if ($skip_args ne "");
6297 if (($val =~ /^$Int$/ && $val !~ /^$Octal$/) ||
6298 ($val =~ /^$Octal$/ && length($val) ne 4)) {
6299 ERROR("NON_OCTAL_PERMISSIONS",
6300 "Use 4 digit octal (0777) not decimal permissions\n" . "$here\n" . $stat_real);
6301 }
6302 if ($val =~ /^$Octal$/ && (oct($val) & 02)) {
6303 ERROR("EXPORTED_WORLD_WRITABLE",
6304 "Exporting writable files is usually an error. Consider more restrictive permissions.\n" . "$here\n" . $stat_real);
6305 }
6306 }
6307 }
6308 }
6309
6310# check for uses of S_<PERMS> that could be octal for readability
6311 if ($line =~ /\b$mode_perms_string_search\b/) {
6312 my $val = "";
6313 my $oval = "";
6314 my $to = 0;
6315 my $curpos = 0;
6316 my $lastpos = 0;
6317 while ($line =~ /\b(($mode_perms_string_search)\b(?:\s*\|\s*)?\s*)/g) {
6318 $curpos = pos($line);
6319 my $match = $2;
6320 my $omatch = $1;
6321 last if ($lastpos > 0 && ($curpos - length($omatch) != $lastpos));
6322 $lastpos = $curpos;
6323 $to |= $mode_permission_string_types{$match};
6324 $val .= '\s*\|\s*' if ($val ne "");
6325 $val .= $match;
6326 $oval .= $omatch;
6327 }
6328 $oval =~ s/^\s*\|\s*//;
6329 $oval =~ s/\s*\|\s*$//;
6330 my $octal = sprintf("%04o", $to);
6331 if (WARN("SYMBOLIC_PERMS",
6332 "Symbolic permissions '$oval' are not preferred. Consider using octal permissions '$octal'.\n" . $herecurr) &&
6333 $fix) {
6334 $fixed[$fixlinenr] =~ s/$val/$octal/;
6335 }
6336 }
6337
6338# validate content of MODULE_LICENSE against list from include/linux/module.h
6339 if ($line =~ /\bMODULE_LICENSE\s*\(\s*($String)\s*\)/) {
6340 my $extracted_string = get_quoted_string($line, $rawline);
6341 my $valid_licenses = qr{
6342 GPL|
6343 GPL\ v2|
6344 GPL\ and\ additional\ rights|
6345 Dual\ BSD/GPL|
6346 Dual\ MIT/GPL|
6347 Dual\ MPL/GPL|
6348 Proprietary
6349 }x;
6350 if ($extracted_string !~ /^"(?:$valid_licenses)"$/x) {
6351 WARN("MODULE_LICENSE",
6352 "unknown module license " . $extracted_string . "\n" . $herecurr);
6353 }
6354 }
Joe Hershberger05622192011-10-18 10:06:59 +00006355 }
6356
6357 # If we have no input at all, then there is nothing to report on
6358 # so just keep quiet.
6359 if ($#rawlines == -1) {
6360 exit(0);
6361 }
6362
6363 # In mailback mode only produce a report in the negative, for
6364 # things that appear to be patches.
6365 if ($mailback && ($clean == 1 || !$is_patch)) {
6366 exit(0);
6367 }
6368
6369 # This is not a patch, and we are are in 'no-patch' mode so
6370 # just keep quiet.
6371 if (!$chk_patch && !$is_patch) {
6372 exit(0);
6373 }
6374
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02006375 if (!$is_patch && $file !~ /cover-letter\.patch$/) {
Joe Hershberger05622192011-10-18 10:06:59 +00006376 ERROR("NOT_UNIFIED_DIFF",
6377 "Does not appear to be a unified-diff format patch\n");
6378 }
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02006379 if ($is_patch && $has_commit_log && $chk_signoff && $signoff == 0) {
Joe Hershberger05622192011-10-18 10:06:59 +00006380 ERROR("MISSING_SIGN_OFF",
6381 "Missing Signed-off-by: line(s)\n");
6382 }
6383
6384 print report_dump();
6385 if ($summary && !($clean == 1 && $quiet == 1)) {
6386 print "$filename " if ($summary_file);
6387 print "total: $cnt_error errors, $cnt_warn warnings, " .
6388 (($check)? "$cnt_chk checks, " : "") .
6389 "$cnt_lines lines checked\n";
Joe Hershberger05622192011-10-18 10:06:59 +00006390 }
6391
6392 if ($quiet == 0) {
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02006393 # If there were any defects found and not already fixing them
6394 if (!$clean and !$fix) {
6395 print << "EOM"
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00006396
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02006397NOTE: For some of the reported defects, checkpatch may be able to
6398 mechanically convert to the typical style using --fix or --fix-inplace.
6399EOM
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00006400 }
Joe Hershberger05622192011-10-18 10:06:59 +00006401 # If there were whitespace errors which cleanpatch can fix
6402 # then suggest that.
6403 if ($rpt_cleaners) {
Joe Hershberger05622192011-10-18 10:06:59 +00006404 $rpt_cleaners = 0;
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02006405 print << "EOM"
6406
6407NOTE: Whitespace errors detected.
6408 You may wish to use scripts/cleanpatch or scripts/cleanfile
6409EOM
Joe Hershberger05622192011-10-18 10:06:59 +00006410 }
6411 }
6412
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02006413 if ($clean == 0 && $fix &&
6414 ("@rawlines" ne "@fixed" ||
6415 $#fixed_inserted >= 0 || $#fixed_deleted >= 0)) {
Tom Rini6b9709d2014-02-27 08:27:28 -05006416 my $newfile = $filename;
6417 $newfile .= ".EXPERIMENTAL-checkpatch-fixes" if (!$fix_inplace);
6418 my $linecount = 0;
6419 my $f;
6420
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02006421 @fixed = fix_inserted_deleted_lines(\@fixed, \@fixed_inserted, \@fixed_deleted);
6422
Tom Rini6b9709d2014-02-27 08:27:28 -05006423 open($f, '>', $newfile)
6424 or die "$P: Can't open $newfile for write\n";
6425 foreach my $fixed_line (@fixed) {
6426 $linecount++;
6427 if ($file) {
6428 if ($linecount > 3) {
6429 $fixed_line =~ s/^\+//;
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02006430 print $f $fixed_line . "\n";
Tom Rini6b9709d2014-02-27 08:27:28 -05006431 }
6432 } else {
6433 print $f $fixed_line . "\n";
6434 }
6435 }
6436 close($f);
6437
6438 if (!$quiet) {
6439 print << "EOM";
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02006440
Tom Rini6b9709d2014-02-27 08:27:28 -05006441Wrote EXPERIMENTAL --fix correction(s) to '$newfile'
6442
6443Do _NOT_ trust the results written to this file.
6444Do _NOT_ submit these changes without inspecting them for correctness.
6445
6446This EXPERIMENTAL file is simply a convenience to help rewrite patches.
6447No warranties, expressed or implied...
Tom Rini6b9709d2014-02-27 08:27:28 -05006448EOM
6449 }
Joe Hershberger05622192011-10-18 10:06:59 +00006450 }
6451
Heinrich Schuchardt6305db92017-09-12 09:57:45 +02006452 if ($quiet == 0) {
6453 print "\n";
6454 if ($clean == 1) {
6455 print "$vname has no obvious style problems and is ready for submission.\n";
6456 } else {
6457 print "$vname has style problems, please review.\n";
6458 }
Joe Hershberger05622192011-10-18 10:06:59 +00006459 }
Joe Hershberger05622192011-10-18 10:06:59 +00006460 return $clean;
6461}