blob: 4de3cc42fc50dca7a3d620ccca99cb4a55b685f5 [file] [log] [blame]
Andy Whitcroft0a920b52007-06-01 00:46:48 -07001#!/usr/bin/perl -w
Dave Jonesdbf004d2010-01-12 16:59:52 -05002# (c) 2001, Dave Jones. (the file handling bit)
Andy Whitcroft00df3442007-06-08 13:47:06 -07003# (c) 2005, Joel Schopp <jschopp@austin.ibm.com> (the ugly bit)
Andy Whitcroft2a5a2c22009-01-06 14:41:23 -08004# (c) 2007,2008, Andy Whitcroft <apw@uk.ibm.com> (new conditions, test suite)
Andy Whitcroft015830b2010-10-26 14:23:17 -07005# (c) 2008-2010 Andy Whitcroft <apw@canonical.com>
Andy Whitcroft0a920b52007-06-01 00:46:48 -07006# Licensed under the terms of the GNU GPL License version 2
7
8use strict;
Joe Perchesc707a812013-07-08 16:00:43 -07009use POSIX;
Joe Perches36061e32014-12-10 15:51:43 -080010use File::Basename;
11use Cwd 'abs_path';
Joe Perches57230292015-06-25 15:03:03 -070012use Term::ANSIColor qw(:constants);
Andy Whitcroft0a920b52007-06-01 00:46:48 -070013
14my $P = $0;
Joe Perches36061e32014-12-10 15:51:43 -080015my $D = dirname(abs_path($P));
Andy Whitcroft0a920b52007-06-01 00:46:48 -070016
Joe Perches000d1cc12011-07-25 17:13:25 -070017my $V = '0.32';
Andy Whitcroft0a920b52007-06-01 00:46:48 -070018
19use Getopt::Long qw(:config no_auto_abbrev);
20
21my $quiet = 0;
22my $tree = 1;
23my $chk_signoff = 1;
24my $chk_patch = 1;
Andy Whitcroft773647a2008-03-28 14:15:58 -070025my $tst_only;
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -070026my $emacs = 0;
Andy Whitcroft8905a672007-11-28 16:21:06 -080027my $terse = 0;
Joe Perches34d88152015-06-25 15:03:05 -070028my $showfile = 0;
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -070029my $file = 0;
Du, Changbin4a593c32016-05-20 17:04:16 -070030my $git = 0;
Joe Perches0dea9f12016-05-20 17:04:19 -070031my %git_commits = ();
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -070032my $check = 0;
Joe Perches2ac73b4f2014-06-04 16:12:05 -070033my $check_orig = 0;
Andy Whitcroft8905a672007-11-28 16:21:06 -080034my $summary = 1;
35my $mailback = 0;
Andy Whitcroft13214ad2008-02-08 04:22:03 -080036my $summary_file = 0;
Joe Perches000d1cc12011-07-25 17:13:25 -070037my $show_types = 0;
Joe Perches3beb42e2016-05-20 17:04:14 -070038my $list_types = 0;
Joe Perches3705ce52013-07-03 15:05:31 -070039my $fix = 0;
Joe Perches9624b8d2014-01-23 15:54:44 -080040my $fix_inplace = 0;
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -070041my $root;
Andy Whitcroftc2fdda02008-02-08 04:20:54 -080042my %debug;
Joe Perches34456862013-07-03 15:05:34 -070043my %camelcase = ();
Joe Perches91bfe482013-09-11 14:23:59 -070044my %use_type = ();
45my @use = ();
46my %ignore_type = ();
Joe Perches000d1cc12011-07-25 17:13:25 -070047my @ignore = ();
Hannes Eder77f5b102009-09-21 17:04:37 -070048my $help = 0;
Joe Perches000d1cc12011-07-25 17:13:25 -070049my $configuration_file = ".checkpatch.conf";
Joe Perches6cd7f382012-12-17 16:01:54 -080050my $max_line_length = 80;
Dave Hansend62a2012013-09-11 14:23:56 -070051my $ignore_perl_version = 0;
52my $minimum_perl_version = 5.10.0;
Vadim Bendebury56193272014-10-13 15:51:48 -070053my $min_conf_desc_length = 4;
Kees Cook66b47b42014-10-13 15:51:57 -070054my $spelling_file = "$D/spelling.txt";
Joe Perchesebfd7d62015-04-16 12:44:14 -070055my $codespell = 0;
Maxim Uvarovf1a63672015-06-25 15:03:08 -070056my $codespellfile = "/usr/share/codespell/dictionary.txt";
Joe Perches57230292015-06-25 15:03:03 -070057my $color = 1;
Joe Perchesdadf6802016-08-02 14:04:33 -070058my $allow_c99_comments = 1;
Hannes Eder77f5b102009-09-21 17:04:37 -070059
60sub help {
61 my ($exitcode) = @_;
62
63 print << "EOM";
64Usage: $P [OPTION]... [FILE]...
65Version: $V
66
67Options:
68 -q, --quiet quiet
69 --no-tree run without a kernel tree
70 --no-signoff do not check for 'Signed-off-by' line
71 --patch treat FILE as patchfile (default)
72 --emacs emacs compile window format
73 --terse one line per report
Joe Perches34d88152015-06-25 15:03:05 -070074 --showfile emit diffed file position, not input file position
Du, Changbin4a593c32016-05-20 17:04:16 -070075 -g, --git treat FILE as a single commit or git revision range
76 single git commit with:
77 <rev>
78 <rev>^
79 <rev>~n
80 multiple git commits with:
81 <rev1>..<rev2>
82 <rev1>...<rev2>
83 <rev>-<count>
84 git merges are ignored
Hannes Eder77f5b102009-09-21 17:04:37 -070085 -f, --file treat FILE as regular source file
86 --subjective, --strict enable more subjective tests
Joe Perches3beb42e2016-05-20 17:04:14 -070087 --list-types list the possible message types
Joe Perches91bfe482013-09-11 14:23:59 -070088 --types TYPE(,TYPE2...) show only these comma separated message types
Joe Perches000d1cc12011-07-25 17:13:25 -070089 --ignore TYPE(,TYPE2...) ignore various comma separated message types
Joe Perches3beb42e2016-05-20 17:04:14 -070090 --show-types show the specific message type in the output
Joe Perches6cd7f382012-12-17 16:01:54 -080091 --max-line-length=n set the maximum line length, if exceeded, warn
Vadim Bendebury56193272014-10-13 15:51:48 -070092 --min-conf-desc-length=n set the min description length, if shorter, warn
Hannes Eder77f5b102009-09-21 17:04:37 -070093 --root=PATH PATH to the kernel tree root
94 --no-summary suppress the per-file summary
95 --mailback only produce a report in case of warnings/errors
96 --summary-file include the filename in summary
97 --debug KEY=[0|1] turn on/off debugging of KEY, where KEY is one of
98 'values', 'possible', 'type', and 'attr' (default
99 is all off)
100 --test-only=WORD report only warnings/errors containing WORD
101 literally
Joe Perches3705ce52013-07-03 15:05:31 -0700102 --fix EXPERIMENTAL - may create horrible results
103 If correctable single-line errors exist, create
104 "<inputfile>.EXPERIMENTAL-checkpatch-fixes"
105 with potential errors corrected to the preferred
106 checkpatch style
Joe Perches9624b8d2014-01-23 15:54:44 -0800107 --fix-inplace EXPERIMENTAL - may create horrible results
108 Is the same as --fix, but overwrites the input
109 file. It's your fault if there's no backup or git
Dave Hansend62a2012013-09-11 14:23:56 -0700110 --ignore-perl-version override checking of perl version. expect
111 runtime errors.
Joe Perchesebfd7d62015-04-16 12:44:14 -0700112 --codespell Use the codespell dictionary for spelling/typos
Maxim Uvarovf1a63672015-06-25 15:03:08 -0700113 (default:/usr/share/codespell/dictionary.txt)
Joe Perchesebfd7d62015-04-16 12:44:14 -0700114 --codespellfile Use this codespell dictionary
Joe Perches57230292015-06-25 15:03:03 -0700115 --color Use colors when output is STDOUT (default: on)
Hannes Eder77f5b102009-09-21 17:04:37 -0700116 -h, --help, --version display this help and exit
117
118When FILE is - read standard input.
119EOM
120
121 exit($exitcode);
122}
123
Joe Perches3beb42e2016-05-20 17:04:14 -0700124sub uniq {
125 my %seen;
126 return grep { !$seen{$_}++ } @_;
127}
128
129sub list_types {
130 my ($exitcode) = @_;
131
132 my $count = 0;
133
134 local $/ = undef;
135
136 open(my $script, '<', abs_path($P)) or
137 die "$P: Can't read '$P' $!\n";
138
139 my $text = <$script>;
140 close($script);
141
142 my @types = ();
143 for ($text =~ /\b(?:(?:CHK|WARN|ERROR)\s*\(\s*"([^"]+)")/g) {
144 push (@types, $_);
145 }
146 @types = sort(uniq(@types));
147 print("#\tMessage type\n\n");
148 foreach my $type (@types) {
149 print(++$count . "\t" . $type . "\n");
150 }
151
152 exit($exitcode);
153}
154
Joe Perches000d1cc12011-07-25 17:13:25 -0700155my $conf = which_conf($configuration_file);
156if (-f $conf) {
157 my @conf_args;
158 open(my $conffile, '<', "$conf")
159 or warn "$P: Can't find a readable $configuration_file file $!\n";
160
161 while (<$conffile>) {
162 my $line = $_;
163
164 $line =~ s/\s*\n?$//g;
165 $line =~ s/^\s*//g;
166 $line =~ s/\s+/ /g;
167
168 next if ($line =~ m/^\s*#/);
169 next if ($line =~ m/^\s*$/);
170
171 my @words = split(" ", $line);
172 foreach my $word (@words) {
173 last if ($word =~ m/^#/);
174 push (@conf_args, $word);
175 }
176 }
177 close($conffile);
178 unshift(@ARGV, @conf_args) if @conf_args;
179}
180
Andy Whitcroft0a920b52007-06-01 00:46:48 -0700181GetOptions(
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700182 'q|quiet+' => \$quiet,
Andy Whitcroft0a920b52007-06-01 00:46:48 -0700183 'tree!' => \$tree,
184 'signoff!' => \$chk_signoff,
185 'patch!' => \$chk_patch,
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700186 'emacs!' => \$emacs,
Andy Whitcroft8905a672007-11-28 16:21:06 -0800187 'terse!' => \$terse,
Joe Perches34d88152015-06-25 15:03:05 -0700188 'showfile!' => \$showfile,
Hannes Eder77f5b102009-09-21 17:04:37 -0700189 'f|file!' => \$file,
Du, Changbin4a593c32016-05-20 17:04:16 -0700190 'g|git!' => \$git,
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700191 'subjective!' => \$check,
192 'strict!' => \$check,
Joe Perches000d1cc12011-07-25 17:13:25 -0700193 'ignore=s' => \@ignore,
Joe Perches91bfe482013-09-11 14:23:59 -0700194 'types=s' => \@use,
Joe Perches000d1cc12011-07-25 17:13:25 -0700195 'show-types!' => \$show_types,
Joe Perches3beb42e2016-05-20 17:04:14 -0700196 'list-types!' => \$list_types,
Joe Perches6cd7f382012-12-17 16:01:54 -0800197 'max-line-length=i' => \$max_line_length,
Vadim Bendebury56193272014-10-13 15:51:48 -0700198 'min-conf-desc-length=i' => \$min_conf_desc_length,
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700199 'root=s' => \$root,
Andy Whitcroft8905a672007-11-28 16:21:06 -0800200 'summary!' => \$summary,
201 'mailback!' => \$mailback,
Andy Whitcroft13214ad2008-02-08 04:22:03 -0800202 'summary-file!' => \$summary_file,
Joe Perches3705ce52013-07-03 15:05:31 -0700203 'fix!' => \$fix,
Joe Perches9624b8d2014-01-23 15:54:44 -0800204 'fix-inplace!' => \$fix_inplace,
Dave Hansend62a2012013-09-11 14:23:56 -0700205 'ignore-perl-version!' => \$ignore_perl_version,
Andy Whitcroftc2fdda02008-02-08 04:20:54 -0800206 'debug=s' => \%debug,
Andy Whitcroft773647a2008-03-28 14:15:58 -0700207 'test-only=s' => \$tst_only,
Joe Perchesebfd7d62015-04-16 12:44:14 -0700208 'codespell!' => \$codespell,
209 'codespellfile=s' => \$codespellfile,
Joe Perches57230292015-06-25 15:03:03 -0700210 'color!' => \$color,
Hannes Eder77f5b102009-09-21 17:04:37 -0700211 'h|help' => \$help,
212 'version' => \$help
213) or help(1);
214
215help(0) if ($help);
Andy Whitcroft0a920b52007-06-01 00:46:48 -0700216
Joe Perches3beb42e2016-05-20 17:04:14 -0700217list_types(0) if ($list_types);
218
Joe Perches9624b8d2014-01-23 15:54:44 -0800219$fix = 1 if ($fix_inplace);
Joe Perches2ac73b4f2014-06-04 16:12:05 -0700220$check_orig = $check;
Joe Perches9624b8d2014-01-23 15:54:44 -0800221
Andy Whitcroft0a920b52007-06-01 00:46:48 -0700222my $exit = 0;
223
Dave Hansend62a2012013-09-11 14:23:56 -0700224if ($^V && $^V lt $minimum_perl_version) {
225 printf "$P: requires at least perl version %vd\n", $minimum_perl_version;
226 if (!$ignore_perl_version) {
227 exit(1);
228 }
229}
230
Allen Hubbe45107ff2016-08-02 14:04:47 -0700231#if no filenames are given, push '-' to read patch from stdin
Andy Whitcroft0a920b52007-06-01 00:46:48 -0700232if ($#ARGV < 0) {
Allen Hubbe45107ff2016-08-02 14:04:47 -0700233 push(@ARGV, '-');
Andy Whitcroft0a920b52007-06-01 00:46:48 -0700234}
235
Joe Perches91bfe482013-09-11 14:23:59 -0700236sub hash_save_array_words {
237 my ($hashRef, $arrayRef) = @_;
Joe Perches000d1cc12011-07-25 17:13:25 -0700238
Joe Perches91bfe482013-09-11 14:23:59 -0700239 my @array = split(/,/, join(',', @$arrayRef));
240 foreach my $word (@array) {
241 $word =~ s/\s*\n?$//g;
242 $word =~ s/^\s*//g;
243 $word =~ s/\s+/ /g;
244 $word =~ tr/[a-z]/[A-Z]/;
Joe Perches000d1cc12011-07-25 17:13:25 -0700245
Joe Perches91bfe482013-09-11 14:23:59 -0700246 next if ($word =~ m/^\s*#/);
247 next if ($word =~ m/^\s*$/);
248
249 $hashRef->{$word}++;
250 }
Joe Perches000d1cc12011-07-25 17:13:25 -0700251}
252
Joe Perches91bfe482013-09-11 14:23:59 -0700253sub hash_show_words {
254 my ($hashRef, $prefix) = @_;
255
Joe Perches3c816e42015-06-25 15:03:29 -0700256 if (keys %$hashRef) {
Joe Perchesd8469f12015-06-25 15:03:00 -0700257 print "\nNOTE: $prefix message types:";
Joe Perches58cb3cf2013-09-11 14:24:04 -0700258 foreach my $word (sort keys %$hashRef) {
Joe Perches91bfe482013-09-11 14:23:59 -0700259 print " $word";
260 }
Joe Perchesd8469f12015-06-25 15:03:00 -0700261 print "\n";
Joe Perches91bfe482013-09-11 14:23:59 -0700262 }
263}
264
265hash_save_array_words(\%ignore_type, \@ignore);
266hash_save_array_words(\%use_type, \@use);
267
Andy Whitcroftc2fdda02008-02-08 04:20:54 -0800268my $dbg_values = 0;
269my $dbg_possible = 0;
Andy Whitcroft7429c692008-07-23 21:29:06 -0700270my $dbg_type = 0;
Andy Whitcrofta1ef2772008-10-15 22:02:17 -0700271my $dbg_attr = 0;
Andy Whitcroftc2fdda02008-02-08 04:20:54 -0800272for my $key (keys %debug) {
Andy Whitcroft21caa132009-01-06 14:41:30 -0800273 ## no critic
274 eval "\${dbg_$key} = '$debug{$key}';";
275 die "$@" if ($@);
Andy Whitcroftc2fdda02008-02-08 04:20:54 -0800276}
277
Andy Whitcroftd2c0a232010-10-26 14:23:12 -0700278my $rpt_cleaners = 0;
279
Andy Whitcroft8905a672007-11-28 16:21:06 -0800280if ($terse) {
281 $emacs = 1;
282 $quiet++;
283}
284
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700285if ($tree) {
286 if (defined $root) {
287 if (!top_of_kernel_tree($root)) {
288 die "$P: $root: --root does not point at a valid tree\n";
289 }
290 } else {
291 if (top_of_kernel_tree('.')) {
292 $root = '.';
293 } elsif ($0 =~ m@(.*)/scripts/[^/]*$@ &&
294 top_of_kernel_tree($1)) {
295 $root = $1;
296 }
297 }
298
299 if (!defined $root) {
300 print "Must be run from the top-level dir. of a kernel tree\n";
301 exit(2);
302 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -0700303}
304
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700305my $emitted_corrupt = 0;
306
Andy Whitcroft2ceb5322009-10-26 16:50:14 -0700307our $Ident = qr{
308 [A-Za-z_][A-Za-z\d_]*
309 (?:\s*\#\#\s*[A-Za-z_][A-Za-z\d_]*)*
310 }x;
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700311our $Storage = qr{extern|static|asmlinkage};
312our $Sparse = qr{
313 __user|
314 __kernel|
315 __force|
316 __iomem|
317 __must_check|
318 __init_refok|
Andy Whitcroft417495e2009-02-27 14:03:08 -0800319 __kprobes|
Sven Eckelmann165e72a2011-07-25 17:13:23 -0700320 __ref|
Boqun Fengad315452015-12-29 12:18:46 +0800321 __rcu|
322 __private
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700323 }x;
Joe Perchese970b882013-11-12 15:10:10 -0800324our $InitAttributePrefix = qr{__(?:mem|cpu|dev|net_|)};
325our $InitAttributeData = qr{$InitAttributePrefix(?:initdata\b)};
326our $InitAttributeConst = qr{$InitAttributePrefix(?:initconst\b)};
327our $InitAttributeInit = qr{$InitAttributePrefix(?:init\b)};
328our $InitAttribute = qr{$InitAttributeData|$InitAttributeConst|$InitAttributeInit};
Joe Perches8716de32013-09-11 14:24:05 -0700329
Wolfram Sang52131292010-03-05 13:43:51 -0800330# Notes to $Attribute:
331# We need \b after 'init' otherwise 'initconst' will cause a false positive in a check
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700332our $Attribute = qr{
333 const|
Joe Perches03f1df72010-10-26 14:23:16 -0700334 __percpu|
335 __nocast|
336 __safe|
337 __bitwise__|
338 __packed__|
339 __packed2__|
340 __naked|
341 __maybe_unused|
342 __always_unused|
343 __noreturn|
344 __used|
345 __cold|
Joe Perchese23ef1f2015-02-13 14:38:24 -0800346 __pure|
Joe Perches03f1df72010-10-26 14:23:16 -0700347 __noclone|
348 __deprecated|
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700349 __read_mostly|
350 __kprobes|
Joe Perches8716de32013-09-11 14:24:05 -0700351 $InitAttribute|
Andy Whitcroft24e1d812008-10-15 22:02:18 -0700352 ____cacheline_aligned|
353 ____cacheline_aligned_in_smp|
Andy Whitcroft5fe3af12009-01-06 14:41:18 -0800354 ____cacheline_internodealigned_in_smp|
355 __weak
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700356 }x;
Andy Whitcroftc45dcab2008-06-05 22:46:01 -0700357our $Modifier;
Joe Perches91cb5192014-04-03 14:49:32 -0700358our $Inline = qr{inline|__always_inline|noinline|__inline|__inline__};
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700359our $Member = qr{->$Ident|\.$Ident|\[[^]]*\]};
360our $Lval = qr{$Ident(?:$Member)*};
361
Joe Perches95e2c602013-07-03 15:05:20 -0700362our $Int_type = qr{(?i)llu|ull|ll|lu|ul|l|u};
363our $Binary = qr{(?i)0b[01]+$Int_type?};
364our $Hex = qr{(?i)0x[0-9a-f]+$Int_type?};
365our $Int = qr{[0-9]+$Int_type?};
Joe Perches24358802014-04-03 14:49:13 -0700366our $Octal = qr{0[0-7]+$Int_type?};
Joe Perchesc0a5c892015-02-13 14:38:21 -0800367our $String = qr{"[X\t]*"};
Joe Perches326b1ff2013-02-04 14:28:51 -0800368our $Float_hex = qr{(?i)0x[0-9a-f]+p-?[0-9]+[fl]?};
369our $Float_dec = qr{(?i)(?:[0-9]+\.[0-9]*|[0-9]*\.[0-9]+)(?:e-?[0-9]+)?[fl]?};
370our $Float_int = qr{(?i)[0-9]+e-?[0-9]+[fl]?};
Joe Perches74349bc2012-12-17 16:02:05 -0800371our $Float = qr{$Float_hex|$Float_dec|$Float_int};
Joe Perches24358802014-04-03 14:49:13 -0700372our $Constant = qr{$Float|$Binary|$Octal|$Hex|$Int};
Joe Perches326b1ff2013-02-04 14:28:51 -0800373our $Assignment = qr{\*\=|/=|%=|\+=|-=|<<=|>>=|&=|\^=|\|=|=};
Joe Perches447432f2014-04-03 14:49:17 -0700374our $Compare = qr{<=|>=|==|!=|<|(?<!-)>};
Joe Perches23f780c2013-07-03 15:05:31 -0700375our $Arithmetic = qr{\+|-|\*|\/|%};
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700376our $Operators = qr{
377 <=|>=|==|!=|
378 =>|->|<<|>>|<|>|!|~|
Joe Perches23f780c2013-07-03 15:05:31 -0700379 &&|\|\||,|\^|\+\+|--|&|\||$Arithmetic
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700380 }x;
381
Joe Perches91cb5192014-04-03 14:49:32 -0700382our $c90_Keywords = qr{do|for|while|if|else|return|goto|continue|switch|default|case|break}x;
383
Joe Perchesab7e23f2015-04-16 12:44:22 -0700384our $BasicType;
Andy Whitcroft8905a672007-11-28 16:21:06 -0800385our $NonptrType;
Joe Perches18130872014-08-06 16:11:22 -0700386our $NonptrTypeMisordered;
Joe Perches8716de32013-09-11 14:24:05 -0700387our $NonptrTypeWithAttr;
Andy Whitcroft8905a672007-11-28 16:21:06 -0800388our $Type;
Joe Perches18130872014-08-06 16:11:22 -0700389our $TypeMisordered;
Andy Whitcroft8905a672007-11-28 16:21:06 -0800390our $Declare;
Joe Perches18130872014-08-06 16:11:22 -0700391our $DeclareMisordered;
Andy Whitcroft8905a672007-11-28 16:21:06 -0800392
Joe Perches15662b32011-10-31 17:13:12 -0700393our $NON_ASCII_UTF8 = qr{
394 [\xC2-\xDF][\x80-\xBF] # non-overlong 2-byte
Andy Whitcroft171ae1a2008-04-29 00:59:32 -0700395 | \xE0[\xA0-\xBF][\x80-\xBF] # excluding overlongs
396 | [\xE1-\xEC\xEE\xEF][\x80-\xBF]{2} # straight 3-byte
397 | \xED[\x80-\x9F][\x80-\xBF] # excluding surrogates
398 | \xF0[\x90-\xBF][\x80-\xBF]{2} # planes 1-3
399 | [\xF1-\xF3][\x80-\xBF]{3} # planes 4-15
400 | \xF4[\x80-\x8F][\x80-\xBF]{2} # plane 16
401}x;
402
Joe Perches15662b32011-10-31 17:13:12 -0700403our $UTF8 = qr{
404 [\x09\x0A\x0D\x20-\x7E] # ASCII
405 | $NON_ASCII_UTF8
406}x;
407
Joe Perchese6176fa2015-06-25 15:02:49 -0700408our $typeC99Typedefs = qr{(?:__)?(?:[us]_?)?int_?(?:8|16|32|64)_t};
Joe Perches021158b2015-02-13 14:38:43 -0800409our $typeOtherOSTypedefs = qr{(?x:
410 u_(?:char|short|int|long) | # bsd
411 u(?:nchar|short|int|long) # sysv
412)};
Joe Perchese6176fa2015-06-25 15:02:49 -0700413our $typeKernelTypedefs = qr{(?x:
Andy Whitcroftfb9e9092009-09-21 17:04:38 -0700414 (?:__)?(?:u|s|be|le)(?:8|16|32|64)|
Andy Whitcroft8ed22ca2008-10-15 22:02:32 -0700415 atomic_t
416)};
Joe Perchese6176fa2015-06-25 15:02:49 -0700417our $typeTypedefs = qr{(?x:
418 $typeC99Typedefs\b|
419 $typeOtherOSTypedefs\b|
420 $typeKernelTypedefs\b
421)};
Andy Whitcroft8ed22ca2008-10-15 22:02:32 -0700422
Joe Perches6d32f7a2015-11-06 16:31:37 -0800423our $zero_initializer = qr{(?:(?:0[xX])?0+$Int_type?|NULL|false)\b};
424
Joe Perches691e6692010-03-05 13:43:51 -0800425our $logFunctions = qr{(?x:
Joe Perches6e60c022011-07-25 17:13:27 -0700426 printk(?:_ratelimited|_once|)|
Jacob Keller7d0b6592013-07-03 15:05:35 -0700427 (?:[a-z0-9]+_){1,2}(?:printk|emerg|alert|crit|err|warning|warn|notice|info|debug|dbg|vdbg|devel|cont|WARN)(?:_ratelimited|_once|)|
Joe Perches6e60c022011-07-25 17:13:27 -0700428 WARN(?:_RATELIMIT|_ONCE|)|
Joe Perchesb0531722011-05-24 17:13:40 -0700429 panic|
Joe Perches06668722013-11-12 15:10:07 -0800430 MODULE_[A-Z_]+|
431 seq_vprintf|seq_printf|seq_puts
Joe Perches691e6692010-03-05 13:43:51 -0800432)};
433
Joe Perches20112472011-07-25 17:13:23 -0700434our $signature_tags = qr{(?xi:
435 Signed-off-by:|
436 Acked-by:|
437 Tested-by:|
438 Reviewed-by:|
439 Reported-by:|
Mugunthan V N8543ae12013-04-29 16:18:17 -0700440 Suggested-by:|
Joe Perches20112472011-07-25 17:13:23 -0700441 To:|
442 Cc:
443)};
444
Joe Perches18130872014-08-06 16:11:22 -0700445our @typeListMisordered = (
446 qr{char\s+(?:un)?signed},
447 qr{int\s+(?:(?:un)?signed\s+)?short\s},
448 qr{int\s+short(?:\s+(?:un)?signed)},
449 qr{short\s+int(?:\s+(?:un)?signed)},
450 qr{(?:un)?signed\s+int\s+short},
451 qr{short\s+(?:un)?signed},
452 qr{long\s+int\s+(?:un)?signed},
453 qr{int\s+long\s+(?:un)?signed},
454 qr{long\s+(?:un)?signed\s+int},
455 qr{int\s+(?:un)?signed\s+long},
456 qr{int\s+(?:un)?signed},
457 qr{int\s+long\s+long\s+(?:un)?signed},
458 qr{long\s+long\s+int\s+(?:un)?signed},
459 qr{long\s+long\s+(?:un)?signed\s+int},
460 qr{long\s+long\s+(?:un)?signed},
461 qr{long\s+(?:un)?signed},
462);
463
Andy Whitcroft8905a672007-11-28 16:21:06 -0800464our @typeList = (
465 qr{void},
Joe Perches0c773d92014-08-06 16:11:20 -0700466 qr{(?:(?:un)?signed\s+)?char},
467 qr{(?:(?:un)?signed\s+)?short\s+int},
468 qr{(?:(?:un)?signed\s+)?short},
469 qr{(?:(?:un)?signed\s+)?int},
470 qr{(?:(?:un)?signed\s+)?long\s+int},
471 qr{(?:(?:un)?signed\s+)?long\s+long\s+int},
472 qr{(?:(?:un)?signed\s+)?long\s+long},
473 qr{(?:(?:un)?signed\s+)?long},
474 qr{(?:un)?signed},
Andy Whitcroft8905a672007-11-28 16:21:06 -0800475 qr{float},
476 qr{double},
477 qr{bool},
Andy Whitcroft8905a672007-11-28 16:21:06 -0800478 qr{struct\s+$Ident},
479 qr{union\s+$Ident},
480 qr{enum\s+$Ident},
481 qr{${Ident}_t},
482 qr{${Ident}_handler},
483 qr{${Ident}_handler_fn},
Joe Perches18130872014-08-06 16:11:22 -0700484 @typeListMisordered,
Andy Whitcroft8905a672007-11-28 16:21:06 -0800485);
Joe Perches938224b2016-01-20 14:59:15 -0800486
487our $C90_int_types = qr{(?x:
488 long\s+long\s+int\s+(?:un)?signed|
489 long\s+long\s+(?:un)?signed\s+int|
490 long\s+long\s+(?:un)?signed|
491 (?:(?:un)?signed\s+)?long\s+long\s+int|
492 (?:(?:un)?signed\s+)?long\s+long|
493 int\s+long\s+long\s+(?:un)?signed|
494 int\s+(?:(?:un)?signed\s+)?long\s+long|
495
496 long\s+int\s+(?:un)?signed|
497 long\s+(?:un)?signed\s+int|
498 long\s+(?:un)?signed|
499 (?:(?:un)?signed\s+)?long\s+int|
500 (?:(?:un)?signed\s+)?long|
501 int\s+long\s+(?:un)?signed|
502 int\s+(?:(?:un)?signed\s+)?long|
503
504 int\s+(?:un)?signed|
505 (?:(?:un)?signed\s+)?int
506)};
507
Alex Dowad485ff232015-06-25 15:02:52 -0700508our @typeListFile = ();
Joe Perches8716de32013-09-11 14:24:05 -0700509our @typeListWithAttr = (
510 @typeList,
511 qr{struct\s+$InitAttribute\s+$Ident},
512 qr{union\s+$InitAttribute\s+$Ident},
513);
514
Andy Whitcroftc45dcab2008-06-05 22:46:01 -0700515our @modifierList = (
516 qr{fastcall},
517);
Alex Dowad485ff232015-06-25 15:02:52 -0700518our @modifierListFile = ();
Andy Whitcroft8905a672007-11-28 16:21:06 -0800519
Joe Perches24358802014-04-03 14:49:13 -0700520our @mode_permission_funcs = (
521 ["module_param", 3],
522 ["module_param_(?:array|named|string)", 4],
523 ["module_param_array_named", 5],
524 ["debugfs_create_(?:file|u8|u16|u32|u64|x8|x16|x32|x64|size_t|atomic_t|bool|blob|regset32|u32_array)", 2],
525 ["proc_create(?:_data|)", 2],
526 ["(?:CLASS|DEVICE|SENSOR)_ATTR", 2],
527);
528
Joe Perches515a2352014-04-03 14:49:24 -0700529#Create a search pattern for all these functions to speed up a loop below
530our $mode_perms_search = "";
531foreach my $entry (@mode_permission_funcs) {
532 $mode_perms_search .= '|' if ($mode_perms_search ne "");
533 $mode_perms_search .= $entry->[0];
534}
535
Joe Perchesb392c642015-04-16 12:44:16 -0700536our $mode_perms_world_writable = qr{
537 S_IWUGO |
538 S_IWOTH |
539 S_IRWXUGO |
540 S_IALLUGO |
541 0[0-7][0-7][2367]
542}x;
543
Wolfram Sang7840a942010-08-09 17:20:57 -0700544our $allowed_asm_includes = qr{(?x:
545 irq|
Sergey Ryazanovcdcee682014-10-13 15:51:44 -0700546 memory|
547 time|
548 reboot
Wolfram Sang7840a942010-08-09 17:20:57 -0700549)};
550# memory.h: ARM has a custom one
551
Kees Cook66b47b42014-10-13 15:51:57 -0700552# Load common spelling mistakes and build regular expression list.
553my $misspellings;
Kees Cook66b47b42014-10-13 15:51:57 -0700554my %spelling_fix;
Kees Cook66b47b42014-10-13 15:51:57 -0700555
Joe Perches36061e32014-12-10 15:51:43 -0800556if (open(my $spelling, '<', $spelling_file)) {
Joe Perches36061e32014-12-10 15:51:43 -0800557 while (<$spelling>) {
558 my $line = $_;
Kees Cook66b47b42014-10-13 15:51:57 -0700559
Joe Perches36061e32014-12-10 15:51:43 -0800560 $line =~ s/\s*\n?$//g;
561 $line =~ s/^\s*//g;
Kees Cook66b47b42014-10-13 15:51:57 -0700562
Joe Perches36061e32014-12-10 15:51:43 -0800563 next if ($line =~ m/^\s*#/);
564 next if ($line =~ m/^\s*$/);
Kees Cook66b47b42014-10-13 15:51:57 -0700565
Joe Perches36061e32014-12-10 15:51:43 -0800566 my ($suspect, $fix) = split(/\|\|/, $line);
567
Joe Perches36061e32014-12-10 15:51:43 -0800568 $spelling_fix{$suspect} = $fix;
569 }
570 close($spelling);
Joe Perches36061e32014-12-10 15:51:43 -0800571} else {
572 warn "No typos will be found - file '$spelling_file': $!\n";
Kees Cook66b47b42014-10-13 15:51:57 -0700573}
Kees Cook66b47b42014-10-13 15:51:57 -0700574
Joe Perchesebfd7d62015-04-16 12:44:14 -0700575if ($codespell) {
576 if (open(my $spelling, '<', $codespellfile)) {
577 while (<$spelling>) {
578 my $line = $_;
579
580 $line =~ s/\s*\n?$//g;
581 $line =~ s/^\s*//g;
582
583 next if ($line =~ m/^\s*#/);
584 next if ($line =~ m/^\s*$/);
585 next if ($line =~ m/, disabled/i);
586
587 $line =~ s/,.*$//;
588
589 my ($suspect, $fix) = split(/->/, $line);
590
591 $spelling_fix{$suspect} = $fix;
592 }
593 close($spelling);
594 } else {
595 warn "No codespell typos will be found - file '$codespellfile': $!\n";
596 }
597}
598
599$misspellings = join("|", sort keys %spelling_fix) if keys %spelling_fix;
600
Andy Whitcroft8905a672007-11-28 16:21:06 -0800601sub build_types {
Alex Dowad485ff232015-06-25 15:02:52 -0700602 my $mods = "(?x: \n" . join("|\n ", (@modifierList, @modifierListFile)) . "\n)";
603 my $all = "(?x: \n" . join("|\n ", (@typeList, @typeListFile)) . "\n)";
Joe Perches18130872014-08-06 16:11:22 -0700604 my $Misordered = "(?x: \n" . join("|\n ", @typeListMisordered) . "\n)";
Joe Perches8716de32013-09-11 14:24:05 -0700605 my $allWithAttr = "(?x: \n" . join("|\n ", @typeListWithAttr) . "\n)";
Andy Whitcroftc8cb2ca2008-07-23 21:28:57 -0700606 $Modifier = qr{(?:$Attribute|$Sparse|$mods)};
Joe Perchesab7e23f2015-04-16 12:44:22 -0700607 $BasicType = qr{
Joe Perchesab7e23f2015-04-16 12:44:22 -0700608 (?:$typeTypedefs\b)|
609 (?:${all}\b)
610 }x;
Andy Whitcroft8905a672007-11-28 16:21:06 -0800611 $NonptrType = qr{
Andy Whitcroftd2172eb2008-07-23 21:29:07 -0700612 (?:$Modifier\s+|const\s+)*
Andy Whitcroftcf655042008-03-04 14:28:20 -0800613 (?:
Andy Whitcroft6b48db22012-01-10 15:10:13 -0800614 (?:typeof|__typeof__)\s*\([^\)]*\)|
Andy Whitcroft8ed22ca2008-10-15 22:02:32 -0700615 (?:$typeTypedefs\b)|
Andy Whitcroftc45dcab2008-06-05 22:46:01 -0700616 (?:${all}\b)
Andy Whitcroftcf655042008-03-04 14:28:20 -0800617 )
Andy Whitcroftc8cb2ca2008-07-23 21:28:57 -0700618 (?:\s+$Modifier|\s+const)*
Andy Whitcroft8905a672007-11-28 16:21:06 -0800619 }x;
Joe Perches18130872014-08-06 16:11:22 -0700620 $NonptrTypeMisordered = qr{
621 (?:$Modifier\s+|const\s+)*
622 (?:
623 (?:${Misordered}\b)
624 )
625 (?:\s+$Modifier|\s+const)*
626 }x;
Joe Perches8716de32013-09-11 14:24:05 -0700627 $NonptrTypeWithAttr = qr{
628 (?:$Modifier\s+|const\s+)*
629 (?:
630 (?:typeof|__typeof__)\s*\([^\)]*\)|
631 (?:$typeTypedefs\b)|
632 (?:${allWithAttr}\b)
633 )
634 (?:\s+$Modifier|\s+const)*
635 }x;
Andy Whitcroft8905a672007-11-28 16:21:06 -0800636 $Type = qr{
Andy Whitcroftc45dcab2008-06-05 22:46:01 -0700637 $NonptrType
Joe Perches1574a292014-08-06 16:10:50 -0700638 (?:(?:\s|\*|\[\])+\s*const|(?:\s|\*\s*(?:const\s*)?|\[\])+|(?:\s*\[\s*\])+)?
Andy Whitcroftc8cb2ca2008-07-23 21:28:57 -0700639 (?:\s+$Inline|\s+$Modifier)*
Andy Whitcroft8905a672007-11-28 16:21:06 -0800640 }x;
Joe Perches18130872014-08-06 16:11:22 -0700641 $TypeMisordered = qr{
642 $NonptrTypeMisordered
643 (?:(?:\s|\*|\[\])+\s*const|(?:\s|\*\s*(?:const\s*)?|\[\])+|(?:\s*\[\s*\])+)?
644 (?:\s+$Inline|\s+$Modifier)*
645 }x;
Joe Perches91cb5192014-04-03 14:49:32 -0700646 $Declare = qr{(?:$Storage\s+(?:$Inline\s+)?)?$Type};
Joe Perches18130872014-08-06 16:11:22 -0700647 $DeclareMisordered = qr{(?:$Storage\s+(?:$Inline\s+)?)?$TypeMisordered};
Andy Whitcroft8905a672007-11-28 16:21:06 -0800648}
649build_types();
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700650
Joe Perches7d2367a2011-07-25 17:13:22 -0700651our $Typecast = qr{\s*(\(\s*$NonptrType\s*\)){0,1}\s*};
Joe Perchesd1fe9c02012-03-23 15:02:16 -0700652
653# Using $balanced_parens, $LvalOrFunc, or $FuncArg
654# requires at least perl version v5.10.0
655# Any use must be runtime checked with $^V
656
657our $balanced_parens = qr/(\((?:[^\(\)]++|(?-1))*\))/;
Joe Perches24358802014-04-03 14:49:13 -0700658our $LvalOrFunc = qr{((?:[\&\*]\s*)?$Lval)\s*($balanced_parens{0,1})\s*};
Joe Perchesc0a5c892015-02-13 14:38:21 -0800659our $FuncArg = qr{$Typecast{0,1}($LvalOrFunc|$Constant|$String)};
Joe Perches7d2367a2011-07-25 17:13:22 -0700660
Joe Perchesf8422302014-08-06 16:11:31 -0700661our $declaration_macros = qr{(?x:
Joe Perches3e838b62015-09-09 15:37:33 -0700662 (?:$Storage\s+)?(?:[A-Z_][A-Z0-9]*_){0,2}(?:DEFINE|DECLARE)(?:_[A-Z0-9]+){1,6}\s*\(|
Joe Perchesf8422302014-08-06 16:11:31 -0700663 (?:$Storage\s+)?LIST_HEAD\s*\(|
664 (?:$Storage\s+)?${Type}\s+uninitialized_var\s*\(
665)};
666
Joe Perches7d2367a2011-07-25 17:13:22 -0700667sub deparenthesize {
668 my ($string) = @_;
669 return "" if (!defined($string));
Joe Perches5b9553a2014-04-03 14:49:21 -0700670
671 while ($string =~ /^\s*\(.*\)\s*$/) {
672 $string =~ s@^\s*\(\s*@@;
673 $string =~ s@\s*\)\s*$@@;
674 }
675
Joe Perches7d2367a2011-07-25 17:13:22 -0700676 $string =~ s@\s+@ @g;
Joe Perches5b9553a2014-04-03 14:49:21 -0700677
Joe Perches7d2367a2011-07-25 17:13:22 -0700678 return $string;
679}
680
Joe Perches34456862013-07-03 15:05:34 -0700681sub seed_camelcase_file {
682 my ($file) = @_;
683
684 return if (!(-f $file));
685
686 local $/;
687
688 open(my $include_file, '<', "$file")
689 or warn "$P: Can't read '$file' $!\n";
690 my $text = <$include_file>;
691 close($include_file);
692
693 my @lines = split('\n', $text);
694
695 foreach my $line (@lines) {
696 next if ($line !~ /(?:[A-Z][a-z]|[a-z][A-Z])/);
697 if ($line =~ /^[ \t]*(?:#[ \t]*define|typedef\s+$Type)\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)/) {
698 $camelcase{$1} = 1;
Joe Perches11ea5162013-11-12 15:10:08 -0800699 } elsif ($line =~ /^\s*$Declare\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)\s*[\(\[,;]/) {
700 $camelcase{$1} = 1;
701 } elsif ($line =~ /^\s*(?:union|struct|enum)\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)\s*[;\{]/) {
Joe Perches34456862013-07-03 15:05:34 -0700702 $camelcase{$1} = 1;
703 }
704 }
705}
706
707my $camelcase_seeded = 0;
708sub seed_camelcase_includes {
709 return if ($camelcase_seeded);
710
711 my $files;
Joe Perchesc707a812013-07-08 16:00:43 -0700712 my $camelcase_cache = "";
713 my @include_files = ();
714
715 $camelcase_seeded = 1;
Joe Perches351b2a12013-07-03 15:05:36 -0700716
Richard Genoud3645e322014-02-10 14:25:32 -0800717 if (-e ".git") {
Joe Perches351b2a12013-07-03 15:05:36 -0700718 my $git_last_include_commit = `git log --no-merges --pretty=format:"%h%n" -1 -- include`;
719 chomp $git_last_include_commit;
Joe Perchesc707a812013-07-08 16:00:43 -0700720 $camelcase_cache = ".checkpatch-camelcase.git.$git_last_include_commit";
Joe Perches34456862013-07-03 15:05:34 -0700721 } else {
Joe Perchesc707a812013-07-08 16:00:43 -0700722 my $last_mod_date = 0;
Joe Perches34456862013-07-03 15:05:34 -0700723 $files = `find $root/include -name "*.h"`;
Joe Perchesc707a812013-07-08 16:00:43 -0700724 @include_files = split('\n', $files);
725 foreach my $file (@include_files) {
726 my $date = POSIX::strftime("%Y%m%d%H%M",
727 localtime((stat $file)[9]));
728 $last_mod_date = $date if ($last_mod_date < $date);
729 }
730 $camelcase_cache = ".checkpatch-camelcase.date.$last_mod_date";
Joe Perches34456862013-07-03 15:05:34 -0700731 }
Joe Perchesc707a812013-07-08 16:00:43 -0700732
733 if ($camelcase_cache ne "" && -f $camelcase_cache) {
734 open(my $camelcase_file, '<', "$camelcase_cache")
735 or warn "$P: Can't read '$camelcase_cache' $!\n";
736 while (<$camelcase_file>) {
737 chomp;
738 $camelcase{$_} = 1;
739 }
740 close($camelcase_file);
741
742 return;
743 }
744
Richard Genoud3645e322014-02-10 14:25:32 -0800745 if (-e ".git") {
Joe Perchesc707a812013-07-08 16:00:43 -0700746 $files = `git ls-files "include/*.h"`;
747 @include_files = split('\n', $files);
748 }
749
Joe Perches34456862013-07-03 15:05:34 -0700750 foreach my $file (@include_files) {
751 seed_camelcase_file($file);
752 }
Joe Perches351b2a12013-07-03 15:05:36 -0700753
Joe Perchesc707a812013-07-08 16:00:43 -0700754 if ($camelcase_cache ne "") {
Joe Perches351b2a12013-07-03 15:05:36 -0700755 unlink glob ".checkpatch-camelcase.*";
Joe Perchesc707a812013-07-08 16:00:43 -0700756 open(my $camelcase_file, '>', "$camelcase_cache")
757 or warn "$P: Can't write '$camelcase_cache' $!\n";
Joe Perches351b2a12013-07-03 15:05:36 -0700758 foreach (sort { lc($a) cmp lc($b) } keys(%camelcase)) {
759 print $camelcase_file ("$_\n");
760 }
761 close($camelcase_file);
762 }
Joe Perches34456862013-07-03 15:05:34 -0700763}
764
Joe Perchesd311cd42014-08-06 16:10:57 -0700765sub git_commit_info {
766 my ($commit, $id, $desc) = @_;
767
768 return ($id, $desc) if ((which("git") eq "") || !(-e ".git"));
769
770 my $output = `git log --no-color --format='%H %s' -1 $commit 2>&1`;
771 $output =~ s/^\s*//gm;
772 my @lines = split("\n", $output);
773
Joe Perches0d7835f2015-02-13 14:38:35 -0800774 return ($id, $desc) if ($#lines < 0);
775
Joe Perchesd311cd42014-08-06 16:10:57 -0700776 if ($lines[0] =~ /^error: short SHA1 $commit is ambiguous\./) {
777# Maybe one day convert this block of bash into something that returns
778# all matching commit ids, but it's very slow...
779#
780# echo "checking commits $1..."
781# git rev-list --remotes | grep -i "^$1" |
782# while read line ; do
783# git log --format='%H %s' -1 $line |
784# echo "commit $(cut -c 1-12,41-)"
785# done
786 } elsif ($lines[0] =~ /^fatal: ambiguous argument '$commit': unknown revision or path not in the working tree\./) {
787 } else {
788 $id = substr($lines[0], 0, 12);
789 $desc = substr($lines[0], 41);
790 }
791
792 return ($id, $desc);
793}
794
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700795$chk_signoff = 0 if ($file);
796
Andy Whitcroft00df3442007-06-08 13:47:06 -0700797my @rawlines = ();
Andy Whitcroftc2fdda02008-02-08 04:20:54 -0800798my @lines = ();
Joe Perches3705ce52013-07-03 15:05:31 -0700799my @fixed = ();
Joe Perchesd752fcc2014-08-06 16:11:05 -0700800my @fixed_inserted = ();
801my @fixed_deleted = ();
Joe Perches194f66f2014-08-06 16:11:03 -0700802my $fixlinenr = -1;
803
Du, Changbin4a593c32016-05-20 17:04:16 -0700804# If input is git commits, extract all commits from the commit expressions.
805# For example, HEAD-3 means we need check 'HEAD, HEAD~1, HEAD~2'.
806die "$P: No git repository found\n" if ($git && !-e ".git");
807
808if ($git) {
809 my @commits = ();
Joe Perches0dea9f12016-05-20 17:04:19 -0700810 foreach my $commit_expr (@ARGV) {
Du, Changbin4a593c32016-05-20 17:04:16 -0700811 my $git_range;
Joe Perches28898fd2016-05-20 17:04:22 -0700812 if ($commit_expr =~ m/^(.*)-(\d+)$/) {
813 $git_range = "-$2 $1";
Du, Changbin4a593c32016-05-20 17:04:16 -0700814 } elsif ($commit_expr =~ m/\.\./) {
815 $git_range = "$commit_expr";
Du, Changbin4a593c32016-05-20 17:04:16 -0700816 } else {
Joe Perches0dea9f12016-05-20 17:04:19 -0700817 $git_range = "-1 $commit_expr";
818 }
819 my $lines = `git log --no-color --no-merges --pretty=format:'%H %s' $git_range`;
820 foreach my $line (split(/\n/, $lines)) {
Joe Perches28898fd2016-05-20 17:04:22 -0700821 $line =~ /^([0-9a-fA-F]{40,40}) (.*)$/;
822 next if (!defined($1) || !defined($2));
Joe Perches0dea9f12016-05-20 17:04:19 -0700823 my $sha1 = $1;
824 my $subject = $2;
825 unshift(@commits, $sha1);
826 $git_commits{$sha1} = $subject;
Du, Changbin4a593c32016-05-20 17:04:16 -0700827 }
828 }
829 die "$P: no git commits after extraction!\n" if (@commits == 0);
830 @ARGV = @commits;
831}
832
Andy Whitcroftc2fdda02008-02-08 04:20:54 -0800833my $vname;
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700834for my $filename (@ARGV) {
Andy Whitcroft21caa132009-01-06 14:41:30 -0800835 my $FILE;
Du, Changbin4a593c32016-05-20 17:04:16 -0700836 if ($git) {
837 open($FILE, '-|', "git format-patch -M --stdout -1 $filename") ||
838 die "$P: $filename: git format-patch failed - $!\n";
839 } elsif ($file) {
Andy Whitcroft21caa132009-01-06 14:41:30 -0800840 open($FILE, '-|', "diff -u /dev/null $filename") ||
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700841 die "$P: $filename: diff failed - $!\n";
Andy Whitcroft21caa132009-01-06 14:41:30 -0800842 } elsif ($filename eq '-') {
843 open($FILE, '<&STDIN');
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700844 } else {
Andy Whitcroft21caa132009-01-06 14:41:30 -0800845 open($FILE, '<', "$filename") ||
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700846 die "$P: $filename: open failed - $!\n";
Andy Whitcroft0a920b52007-06-01 00:46:48 -0700847 }
Andy Whitcroftc2fdda02008-02-08 04:20:54 -0800848 if ($filename eq '-') {
849 $vname = 'Your patch';
Du, Changbin4a593c32016-05-20 17:04:16 -0700850 } elsif ($git) {
Joe Perches0dea9f12016-05-20 17:04:19 -0700851 $vname = "Commit " . substr($filename, 0, 12) . ' ("' . $git_commits{$filename} . '")';
Andy Whitcroftc2fdda02008-02-08 04:20:54 -0800852 } else {
853 $vname = $filename;
854 }
Andy Whitcroft21caa132009-01-06 14:41:30 -0800855 while (<$FILE>) {
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700856 chomp;
857 push(@rawlines, $_);
858 }
Andy Whitcroft21caa132009-01-06 14:41:30 -0800859 close($FILE);
Joe Perchesd8469f12015-06-25 15:03:00 -0700860
861 if ($#ARGV > 0 && $quiet == 0) {
862 print '-' x length($vname) . "\n";
863 print "$vname\n";
864 print '-' x length($vname) . "\n";
865 }
866
Andy Whitcroftc2fdda02008-02-08 04:20:54 -0800867 if (!process($filename)) {
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700868 $exit = 1;
869 }
870 @rawlines = ();
Andy Whitcroft13214ad2008-02-08 04:22:03 -0800871 @lines = ();
Joe Perches3705ce52013-07-03 15:05:31 -0700872 @fixed = ();
Joe Perchesd752fcc2014-08-06 16:11:05 -0700873 @fixed_inserted = ();
874 @fixed_deleted = ();
Joe Perches194f66f2014-08-06 16:11:03 -0700875 $fixlinenr = -1;
Alex Dowad485ff232015-06-25 15:02:52 -0700876 @modifierListFile = ();
877 @typeListFile = ();
878 build_types();
Andy Whitcroft0a920b52007-06-01 00:46:48 -0700879}
880
Joe Perchesd8469f12015-06-25 15:03:00 -0700881if (!$quiet) {
Joe Perches3c816e42015-06-25 15:03:29 -0700882 hash_show_words(\%use_type, "Used");
883 hash_show_words(\%ignore_type, "Ignored");
884
Joe Perchesd8469f12015-06-25 15:03:00 -0700885 if ($^V lt 5.10.0) {
886 print << "EOM"
887
888NOTE: perl $^V is not modern enough to detect all possible issues.
889 An upgrade to at least perl v5.10.0 is suggested.
890EOM
891 }
892 if ($exit) {
893 print << "EOM"
894
895NOTE: If any of the errors are false positives, please report
896 them to the maintainer, see CHECKPATCH in MAINTAINERS.
897EOM
898 }
899}
900
Andy Whitcroft0a920b52007-06-01 00:46:48 -0700901exit($exit);
902
903sub top_of_kernel_tree {
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700904 my ($root) = @_;
905
906 my @tree_check = (
907 "COPYING", "CREDITS", "Kbuild", "MAINTAINERS", "Makefile",
908 "README", "Documentation", "arch", "include", "drivers",
909 "fs", "init", "ipc", "kernel", "lib", "scripts",
910 );
911
912 foreach my $check (@tree_check) {
913 if (! -e $root . '/' . $check) {
914 return 0;
915 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -0700916 }
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700917 return 1;
Joe Perches8f26b832012-10-04 17:13:32 -0700918}
Andy Whitcroft0a920b52007-06-01 00:46:48 -0700919
Joe Perches20112472011-07-25 17:13:23 -0700920sub parse_email {
921 my ($formatted_email) = @_;
922
923 my $name = "";
924 my $address = "";
925 my $comment = "";
926
927 if ($formatted_email =~ /^(.*)<(\S+\@\S+)>(.*)$/) {
928 $name = $1;
929 $address = $2;
930 $comment = $3 if defined $3;
931 } elsif ($formatted_email =~ /^\s*<(\S+\@\S+)>(.*)$/) {
932 $address = $1;
933 $comment = $2 if defined $2;
934 } elsif ($formatted_email =~ /(\S+\@\S+)(.*)$/) {
935 $address = $1;
936 $comment = $2 if defined $2;
937 $formatted_email =~ s/$address.*$//;
938 $name = $formatted_email;
Joe Perches3705ce52013-07-03 15:05:31 -0700939 $name = trim($name);
Joe Perches20112472011-07-25 17:13:23 -0700940 $name =~ s/^\"|\"$//g;
941 # If there's a name left after stripping spaces and
942 # leading quotes, and the address doesn't have both
943 # leading and trailing angle brackets, the address
944 # is invalid. ie:
945 # "joe smith joe@smith.com" bad
946 # "joe smith <joe@smith.com" bad
947 if ($name ne "" && $address !~ /^<[^>]+>$/) {
948 $name = "";
949 $address = "";
950 $comment = "";
951 }
952 }
953
Joe Perches3705ce52013-07-03 15:05:31 -0700954 $name = trim($name);
Joe Perches20112472011-07-25 17:13:23 -0700955 $name =~ s/^\"|\"$//g;
Joe Perches3705ce52013-07-03 15:05:31 -0700956 $address = trim($address);
Joe Perches20112472011-07-25 17:13:23 -0700957 $address =~ s/^\<|\>$//g;
958
959 if ($name =~ /[^\w \-]/i) { ##has "must quote" chars
960 $name =~ s/(?<!\\)"/\\"/g; ##escape quotes
961 $name = "\"$name\"";
962 }
963
964 return ($name, $address, $comment);
965}
966
967sub format_email {
968 my ($name, $address) = @_;
969
970 my $formatted_email;
971
Joe Perches3705ce52013-07-03 15:05:31 -0700972 $name = trim($name);
Joe Perches20112472011-07-25 17:13:23 -0700973 $name =~ s/^\"|\"$//g;
Joe Perches3705ce52013-07-03 15:05:31 -0700974 $address = trim($address);
Joe Perches20112472011-07-25 17:13:23 -0700975
976 if ($name =~ /[^\w \-]/i) { ##has "must quote" chars
977 $name =~ s/(?<!\\)"/\\"/g; ##escape quotes
978 $name = "\"$name\"";
979 }
980
981 if ("$name" eq "") {
982 $formatted_email = "$address";
983 } else {
984 $formatted_email = "$name <$address>";
985 }
986
987 return $formatted_email;
988}
989
Joe Perchesd311cd42014-08-06 16:10:57 -0700990sub which {
Joe Perchesbd474ca2014-08-06 16:11:10 -0700991 my ($bin) = @_;
Joe Perchesd311cd42014-08-06 16:10:57 -0700992
Joe Perchesbd474ca2014-08-06 16:11:10 -0700993 foreach my $path (split(/:/, $ENV{PATH})) {
994 if (-e "$path/$bin") {
995 return "$path/$bin";
996 }
Joe Perchesd311cd42014-08-06 16:10:57 -0700997 }
Joe Perchesd311cd42014-08-06 16:10:57 -0700998
Joe Perchesbd474ca2014-08-06 16:11:10 -0700999 return "";
Joe Perchesd311cd42014-08-06 16:10:57 -07001000}
1001
Joe Perches000d1cc12011-07-25 17:13:25 -07001002sub which_conf {
1003 my ($conf) = @_;
1004
1005 foreach my $path (split(/:/, ".:$ENV{HOME}:.scripts")) {
1006 if (-e "$path/$conf") {
1007 return "$path/$conf";
1008 }
1009 }
1010
1011 return "";
1012}
1013
Andy Whitcroft0a920b52007-06-01 00:46:48 -07001014sub expand_tabs {
1015 my ($str) = @_;
1016
1017 my $res = '';
1018 my $n = 0;
1019 for my $c (split(//, $str)) {
1020 if ($c eq "\t") {
1021 $res .= ' ';
1022 $n++;
1023 for (; ($n % 8) != 0; $n++) {
1024 $res .= ' ';
1025 }
1026 next;
1027 }
1028 $res .= $c;
1029 $n++;
1030 }
1031
1032 return $res;
1033}
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001034sub copy_spacing {
Andy Whitcroft773647a2008-03-28 14:15:58 -07001035 (my $res = shift) =~ tr/\t/ /c;
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001036 return $res;
1037}
Andy Whitcroft0a920b52007-06-01 00:46:48 -07001038
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001039sub line_stats {
1040 my ($line) = @_;
1041
1042 # Drop the diff line leader and expand tabs
1043 $line =~ s/^.//;
1044 $line = expand_tabs($line);
1045
1046 # Pick the indent from the front of the line.
1047 my ($white) = ($line =~ /^(\s*)/);
1048
1049 return (length($line), length($white));
1050}
1051
Andy Whitcroft773647a2008-03-28 14:15:58 -07001052my $sanitise_quote = '';
1053
1054sub sanitise_line_reset {
1055 my ($in_comment) = @_;
1056
1057 if ($in_comment) {
1058 $sanitise_quote = '*/';
1059 } else {
1060 $sanitise_quote = '';
1061 }
1062}
Andy Whitcroft00df3442007-06-08 13:47:06 -07001063sub sanitise_line {
1064 my ($line) = @_;
1065
1066 my $res = '';
1067 my $l = '';
1068
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001069 my $qlen = 0;
Andy Whitcroft773647a2008-03-28 14:15:58 -07001070 my $off = 0;
1071 my $c;
Andy Whitcroft00df3442007-06-08 13:47:06 -07001072
Andy Whitcroft773647a2008-03-28 14:15:58 -07001073 # Always copy over the diff marker.
1074 $res = substr($line, 0, 1);
1075
1076 for ($off = 1; $off < length($line); $off++) {
1077 $c = substr($line, $off, 1);
1078
1079 # Comments we are wacking completly including the begin
1080 # and end, all to $;.
1081 if ($sanitise_quote eq '' && substr($line, $off, 2) eq '/*') {
1082 $sanitise_quote = '*/';
1083
1084 substr($res, $off, 2, "$;$;");
1085 $off++;
1086 next;
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001087 }
Andy Whitcroft81bc0e02008-10-15 22:02:26 -07001088 if ($sanitise_quote eq '*/' && substr($line, $off, 2) eq '*/') {
Andy Whitcroft773647a2008-03-28 14:15:58 -07001089 $sanitise_quote = '';
1090 substr($res, $off, 2, "$;$;");
1091 $off++;
1092 next;
1093 }
Daniel Walker113f04a2009-09-21 17:04:35 -07001094 if ($sanitise_quote eq '' && substr($line, $off, 2) eq '//') {
1095 $sanitise_quote = '//';
1096
1097 substr($res, $off, 2, $sanitise_quote);
1098 $off++;
1099 next;
1100 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07001101
1102 # A \ in a string means ignore the next character.
1103 if (($sanitise_quote eq "'" || $sanitise_quote eq '"') &&
1104 $c eq "\\") {
1105 substr($res, $off, 2, 'XX');
1106 $off++;
1107 next;
1108 }
1109 # Regular quotes.
1110 if ($c eq "'" || $c eq '"') {
1111 if ($sanitise_quote eq '') {
1112 $sanitise_quote = $c;
1113
1114 substr($res, $off, 1, $c);
Andy Whitcroft00df3442007-06-08 13:47:06 -07001115 next;
Andy Whitcroft773647a2008-03-28 14:15:58 -07001116 } elsif ($sanitise_quote eq $c) {
1117 $sanitise_quote = '';
Andy Whitcroft00df3442007-06-08 13:47:06 -07001118 }
1119 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07001120
Andy Whitcroftfae17da2009-01-06 14:41:20 -08001121 #print "c<$c> SQ<$sanitise_quote>\n";
Andy Whitcroft773647a2008-03-28 14:15:58 -07001122 if ($off != 0 && $sanitise_quote eq '*/' && $c ne "\t") {
1123 substr($res, $off, 1, $;);
Daniel Walker113f04a2009-09-21 17:04:35 -07001124 } elsif ($off != 0 && $sanitise_quote eq '//' && $c ne "\t") {
1125 substr($res, $off, 1, $;);
Andy Whitcroft773647a2008-03-28 14:15:58 -07001126 } elsif ($off != 0 && $sanitise_quote && $c ne "\t") {
1127 substr($res, $off, 1, 'X');
Andy Whitcroft00df3442007-06-08 13:47:06 -07001128 } else {
Andy Whitcroft773647a2008-03-28 14:15:58 -07001129 substr($res, $off, 1, $c);
Andy Whitcroft00df3442007-06-08 13:47:06 -07001130 }
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001131 }
1132
Daniel Walker113f04a2009-09-21 17:04:35 -07001133 if ($sanitise_quote eq '//') {
1134 $sanitise_quote = '';
1135 }
1136
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001137 # The pathname on a #include may be surrounded by '<' and '>'.
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07001138 if ($res =~ /^.\s*\#\s*include\s+\<(.*)\>/) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001139 my $clean = 'X' x length($1);
1140 $res =~ s@\<.*\>@<$clean>@;
1141
1142 # The whole of a #error is a string.
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07001143 } elsif ($res =~ /^.\s*\#\s*(?:error|warning)\s+(.*)\b/) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001144 my $clean = 'X' x length($1);
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07001145 $res =~ s@(\#\s*(?:error|warning)\s+).*@$1$clean@;
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001146 }
1147
Joe Perchesdadf6802016-08-02 14:04:33 -07001148 if ($allow_c99_comments && $res =~ m@(//.*$)@) {
1149 my $match = $1;
1150 $res =~ s/\Q$match\E/"$;" x length($match)/e;
1151 }
1152
Andy Whitcroft00df3442007-06-08 13:47:06 -07001153 return $res;
1154}
1155
Joe Perchesa6962d72013-04-29 16:18:13 -07001156sub get_quoted_string {
1157 my ($line, $rawline) = @_;
1158
Joe Perches33acb542015-06-25 15:02:54 -07001159 return "" if ($line !~ m/($String)/g);
Joe Perchesa6962d72013-04-29 16:18:13 -07001160 return substr($rawline, $-[0], $+[0] - $-[0]);
1161}
1162
Andy Whitcroft8905a672007-11-28 16:21:06 -08001163sub ctx_statement_block {
1164 my ($linenr, $remain, $off) = @_;
1165 my $line = $linenr - 1;
1166 my $blk = '';
1167 my $soff = $off;
1168 my $coff = $off - 1;
Andy Whitcroft773647a2008-03-28 14:15:58 -07001169 my $coff_set = 0;
Andy Whitcroft8905a672007-11-28 16:21:06 -08001170
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001171 my $loff = 0;
1172
Andy Whitcroft8905a672007-11-28 16:21:06 -08001173 my $type = '';
1174 my $level = 0;
Andy Whitcrofta2750642009-01-15 13:51:04 -08001175 my @stack = ();
Andy Whitcroftcf655042008-03-04 14:28:20 -08001176 my $p;
Andy Whitcroft8905a672007-11-28 16:21:06 -08001177 my $c;
1178 my $len = 0;
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001179
1180 my $remainder;
Andy Whitcroft8905a672007-11-28 16:21:06 -08001181 while (1) {
Andy Whitcrofta2750642009-01-15 13:51:04 -08001182 @stack = (['', 0]) if ($#stack == -1);
1183
Andy Whitcroft773647a2008-03-28 14:15:58 -07001184 #warn "CSB: blk<$blk> remain<$remain>\n";
Andy Whitcroft8905a672007-11-28 16:21:06 -08001185 # If we are about to drop off the end, pull in more
1186 # context.
1187 if ($off >= $len) {
1188 for (; $remain > 0; $line++) {
Andy Whitcroftdea33492008-10-15 22:02:25 -07001189 last if (!defined $lines[$line]);
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001190 next if ($lines[$line] =~ /^-/);
Andy Whitcroft8905a672007-11-28 16:21:06 -08001191 $remain--;
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001192 $loff = $len;
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001193 $blk .= $lines[$line] . "\n";
Andy Whitcroft8905a672007-11-28 16:21:06 -08001194 $len = length($blk);
1195 $line++;
1196 last;
1197 }
1198 # Bail if there is no further context.
1199 #warn "CSB: blk<$blk> off<$off> len<$len>\n";
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001200 if ($off >= $len) {
Andy Whitcroft8905a672007-11-28 16:21:06 -08001201 last;
1202 }
Andy Whitcroftf74bd192012-01-10 15:09:54 -08001203 if ($level == 0 && substr($blk, $off) =~ /^.\s*#\s*define/) {
1204 $level++;
1205 $type = '#';
1206 }
Andy Whitcroft8905a672007-11-28 16:21:06 -08001207 }
Andy Whitcroftcf655042008-03-04 14:28:20 -08001208 $p = $c;
Andy Whitcroft8905a672007-11-28 16:21:06 -08001209 $c = substr($blk, $off, 1);
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001210 $remainder = substr($blk, $off);
Andy Whitcroft8905a672007-11-28 16:21:06 -08001211
Andy Whitcroft773647a2008-03-28 14:15:58 -07001212 #warn "CSB: c<$c> type<$type> level<$level> remainder<$remainder> coff_set<$coff_set>\n";
Andy Whitcroft4635f4f2009-01-06 14:41:27 -08001213
1214 # Handle nested #if/#else.
1215 if ($remainder =~ /^#\s*(?:ifndef|ifdef|if)\s/) {
1216 push(@stack, [ $type, $level ]);
1217 } elsif ($remainder =~ /^#\s*(?:else|elif)\b/) {
1218 ($type, $level) = @{$stack[$#stack - 1]};
1219 } elsif ($remainder =~ /^#\s*endif\b/) {
1220 ($type, $level) = @{pop(@stack)};
1221 }
1222
Andy Whitcroft8905a672007-11-28 16:21:06 -08001223 # Statement ends at the ';' or a close '}' at the
1224 # outermost level.
1225 if ($level == 0 && $c eq ';') {
1226 last;
1227 }
1228
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001229 # An else is really a conditional as long as its not else if
Andy Whitcroft773647a2008-03-28 14:15:58 -07001230 if ($level == 0 && $coff_set == 0 &&
1231 (!defined($p) || $p =~ /(?:\s|\}|\+)/) &&
1232 $remainder =~ /^(else)(?:\s|{)/ &&
1233 $remainder !~ /^else\s+if\b/) {
1234 $coff = $off + length($1) - 1;
1235 $coff_set = 1;
1236 #warn "CSB: mark coff<$coff> soff<$soff> 1<$1>\n";
1237 #warn "[" . substr($blk, $soff, $coff - $soff + 1) . "]\n";
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001238 }
1239
Andy Whitcroft8905a672007-11-28 16:21:06 -08001240 if (($type eq '' || $type eq '(') && $c eq '(') {
1241 $level++;
1242 $type = '(';
1243 }
1244 if ($type eq '(' && $c eq ')') {
1245 $level--;
1246 $type = ($level != 0)? '(' : '';
1247
1248 if ($level == 0 && $coff < $soff) {
1249 $coff = $off;
Andy Whitcroft773647a2008-03-28 14:15:58 -07001250 $coff_set = 1;
1251 #warn "CSB: mark coff<$coff>\n";
Andy Whitcroft8905a672007-11-28 16:21:06 -08001252 }
1253 }
1254 if (($type eq '' || $type eq '{') && $c eq '{') {
1255 $level++;
1256 $type = '{';
1257 }
1258 if ($type eq '{' && $c eq '}') {
1259 $level--;
1260 $type = ($level != 0)? '{' : '';
1261
1262 if ($level == 0) {
Patrick Pannutob998e002010-08-09 17:21:03 -07001263 if (substr($blk, $off + 1, 1) eq ';') {
1264 $off++;
1265 }
Andy Whitcroft8905a672007-11-28 16:21:06 -08001266 last;
1267 }
1268 }
Andy Whitcroftf74bd192012-01-10 15:09:54 -08001269 # Preprocessor commands end at the newline unless escaped.
1270 if ($type eq '#' && $c eq "\n" && $p ne "\\") {
1271 $level--;
1272 $type = '';
1273 $off++;
1274 last;
1275 }
Andy Whitcroft8905a672007-11-28 16:21:06 -08001276 $off++;
1277 }
Andy Whitcrofta3bb97a2008-07-23 21:29:00 -07001278 # We are truly at the end, so shuffle to the next line.
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001279 if ($off == $len) {
Andy Whitcrofta3bb97a2008-07-23 21:29:00 -07001280 $loff = $len + 1;
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001281 $line++;
1282 $remain--;
1283 }
Andy Whitcroft8905a672007-11-28 16:21:06 -08001284
1285 my $statement = substr($blk, $soff, $off - $soff + 1);
1286 my $condition = substr($blk, $soff, $coff - $soff + 1);
1287
1288 #warn "STATEMENT<$statement>\n";
1289 #warn "CONDITION<$condition>\n";
1290
Andy Whitcroft773647a2008-03-28 14:15:58 -07001291 #print "coff<$coff> soff<$off> loff<$loff>\n";
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001292
1293 return ($statement, $condition,
1294 $line, $remain + 1, $off - $loff + 1, $level);
1295}
1296
Andy Whitcroftcf655042008-03-04 14:28:20 -08001297sub statement_lines {
1298 my ($stmt) = @_;
1299
1300 # Strip the diff line prefixes and rip blank lines at start and end.
1301 $stmt =~ s/(^|\n)./$1/g;
1302 $stmt =~ s/^\s*//;
1303 $stmt =~ s/\s*$//;
1304
1305 my @stmt_lines = ($stmt =~ /\n/g);
1306
1307 return $#stmt_lines + 2;
1308}
1309
1310sub statement_rawlines {
1311 my ($stmt) = @_;
1312
1313 my @stmt_lines = ($stmt =~ /\n/g);
1314
1315 return $#stmt_lines + 2;
1316}
1317
1318sub statement_block_size {
1319 my ($stmt) = @_;
1320
1321 $stmt =~ s/(^|\n)./$1/g;
1322 $stmt =~ s/^\s*{//;
1323 $stmt =~ s/}\s*$//;
1324 $stmt =~ s/^\s*//;
1325 $stmt =~ s/\s*$//;
1326
1327 my @stmt_lines = ($stmt =~ /\n/g);
1328 my @stmt_statements = ($stmt =~ /;/g);
1329
1330 my $stmt_lines = $#stmt_lines + 2;
1331 my $stmt_statements = $#stmt_statements + 1;
1332
1333 if ($stmt_lines > $stmt_statements) {
1334 return $stmt_lines;
1335 } else {
1336 return $stmt_statements;
1337 }
1338}
1339
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001340sub ctx_statement_full {
1341 my ($linenr, $remain, $off) = @_;
1342 my ($statement, $condition, $level);
1343
1344 my (@chunks);
1345
Andy Whitcroftcf655042008-03-04 14:28:20 -08001346 # Grab the first conditional/block pair.
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001347 ($statement, $condition, $linenr, $remain, $off, $level) =
1348 ctx_statement_block($linenr, $remain, $off);
Andy Whitcroft773647a2008-03-28 14:15:58 -07001349 #print "F: c<$condition> s<$statement> remain<$remain>\n";
Andy Whitcroftcf655042008-03-04 14:28:20 -08001350 push(@chunks, [ $condition, $statement ]);
1351 if (!($remain > 0 && $condition =~ /^\s*(?:\n[+-])?\s*(?:if|else|do)\b/s)) {
1352 return ($level, $linenr, @chunks);
1353 }
1354
1355 # Pull in the following conditional/block pairs and see if they
1356 # could continue the statement.
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001357 for (;;) {
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001358 ($statement, $condition, $linenr, $remain, $off, $level) =
1359 ctx_statement_block($linenr, $remain, $off);
Andy Whitcroftcf655042008-03-04 14:28:20 -08001360 #print "C: c<$condition> s<$statement> remain<$remain>\n";
Andy Whitcroft773647a2008-03-28 14:15:58 -07001361 last if (!($remain > 0 && $condition =~ /^(?:\s*\n[+-])*\s*(?:else|do)\b/s));
Andy Whitcroftcf655042008-03-04 14:28:20 -08001362 #print "C: push\n";
1363 push(@chunks, [ $condition, $statement ]);
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001364 }
1365
1366 return ($level, $linenr, @chunks);
Andy Whitcroft8905a672007-11-28 16:21:06 -08001367}
1368
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001369sub ctx_block_get {
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001370 my ($linenr, $remain, $outer, $open, $close, $off) = @_;
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001371 my $line;
1372 my $start = $linenr - 1;
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001373 my $blk = '';
1374 my @o;
1375 my @c;
1376 my @res = ();
1377
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001378 my $level = 0;
Andy Whitcroft4635f4f2009-01-06 14:41:27 -08001379 my @stack = ($level);
Andy Whitcroft00df3442007-06-08 13:47:06 -07001380 for ($line = $start; $remain > 0; $line++) {
1381 next if ($rawlines[$line] =~ /^-/);
1382 $remain--;
1383
1384 $blk .= $rawlines[$line];
Andy Whitcroft4635f4f2009-01-06 14:41:27 -08001385
1386 # Handle nested #if/#else.
Andy Whitcroft01464f32010-10-26 14:23:19 -07001387 if ($lines[$line] =~ /^.\s*#\s*(?:ifndef|ifdef|if)\s/) {
Andy Whitcroft4635f4f2009-01-06 14:41:27 -08001388 push(@stack, $level);
Andy Whitcroft01464f32010-10-26 14:23:19 -07001389 } elsif ($lines[$line] =~ /^.\s*#\s*(?:else|elif)\b/) {
Andy Whitcroft4635f4f2009-01-06 14:41:27 -08001390 $level = $stack[$#stack - 1];
Andy Whitcroft01464f32010-10-26 14:23:19 -07001391 } elsif ($lines[$line] =~ /^.\s*#\s*endif\b/) {
Andy Whitcroft4635f4f2009-01-06 14:41:27 -08001392 $level = pop(@stack);
1393 }
1394
Andy Whitcroft01464f32010-10-26 14:23:19 -07001395 foreach my $c (split(//, $lines[$line])) {
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001396 ##print "C<$c>L<$level><$open$close>O<$off>\n";
1397 if ($off > 0) {
1398 $off--;
1399 next;
1400 }
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001401
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001402 if ($c eq $close && $level > 0) {
1403 $level--;
1404 last if ($level == 0);
1405 } elsif ($c eq $open) {
1406 $level++;
1407 }
1408 }
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001409
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001410 if (!$outer || $level <= 1) {
Andy Whitcroft00df3442007-06-08 13:47:06 -07001411 push(@res, $rawlines[$line]);
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001412 }
1413
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001414 last if ($level == 0);
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001415 }
1416
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001417 return ($level, @res);
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001418}
1419sub ctx_block_outer {
1420 my ($linenr, $remain) = @_;
1421
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001422 my ($level, @r) = ctx_block_get($linenr, $remain, 1, '{', '}', 0);
1423 return @r;
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001424}
1425sub ctx_block {
1426 my ($linenr, $remain) = @_;
1427
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001428 my ($level, @r) = ctx_block_get($linenr, $remain, 0, '{', '}', 0);
1429 return @r;
Andy Whitcroft653d4872007-06-23 17:16:34 -07001430}
1431sub ctx_statement {
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001432 my ($linenr, $remain, $off) = @_;
1433
1434 my ($level, @r) = ctx_block_get($linenr, $remain, 0, '(', ')', $off);
1435 return @r;
1436}
1437sub ctx_block_level {
Andy Whitcroft653d4872007-06-23 17:16:34 -07001438 my ($linenr, $remain) = @_;
1439
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001440 return ctx_block_get($linenr, $remain, 0, '{', '}', 0);
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001441}
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07001442sub ctx_statement_level {
1443 my ($linenr, $remain, $off) = @_;
1444
1445 return ctx_block_get($linenr, $remain, 0, '(', ')', $off);
1446}
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001447
1448sub ctx_locate_comment {
1449 my ($first_line, $end_line) = @_;
1450
1451 # Catch a comment on the end of the line itself.
Andy Whitcroftbeae6332008-07-23 21:28:59 -07001452 my ($current_comment) = ($rawlines[$end_line - 1] =~ m@.*(/\*.*\*/)\s*(?:\\\s*)?$@);
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001453 return $current_comment if (defined $current_comment);
1454
1455 # Look through the context and try and figure out if there is a
1456 # comment.
1457 my $in_comment = 0;
1458 $current_comment = '';
1459 for (my $linenr = $first_line; $linenr < $end_line; $linenr++) {
Andy Whitcroft00df3442007-06-08 13:47:06 -07001460 my $line = $rawlines[$linenr - 1];
1461 #warn " $line\n";
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001462 if ($linenr == $first_line and $line =~ m@^.\s*\*@) {
1463 $in_comment = 1;
1464 }
1465 if ($line =~ m@/\*@) {
1466 $in_comment = 1;
1467 }
1468 if (!$in_comment && $current_comment ne '') {
1469 $current_comment = '';
1470 }
1471 $current_comment .= $line . "\n" if ($in_comment);
1472 if ($line =~ m@\*/@) {
1473 $in_comment = 0;
1474 }
1475 }
1476
1477 chomp($current_comment);
1478 return($current_comment);
1479}
1480sub ctx_has_comment {
1481 my ($first_line, $end_line) = @_;
1482 my $cmt = ctx_locate_comment($first_line, $end_line);
1483
Andy Whitcroft00df3442007-06-08 13:47:06 -07001484 ##print "LINE: $rawlines[$end_line - 1 ]\n";
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001485 ##print "CMMT: $cmt\n";
1486
1487 return ($cmt ne '');
1488}
1489
Andy Whitcroft4d001e42008-10-15 22:02:21 -07001490sub raw_line {
1491 my ($linenr, $cnt) = @_;
1492
1493 my $offset = $linenr - 1;
1494 $cnt++;
1495
1496 my $line;
1497 while ($cnt) {
1498 $line = $rawlines[$offset++];
1499 next if (defined($line) && $line =~ /^-/);
1500 $cnt--;
1501 }
1502
1503 return $line;
1504}
1505
Andy Whitcroft0a920b52007-06-01 00:46:48 -07001506sub cat_vet {
1507 my ($vet) = @_;
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07001508 my ($res, $coded);
Andy Whitcroft0a920b52007-06-01 00:46:48 -07001509
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07001510 $res = '';
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001511 while ($vet =~ /([^[:cntrl:]]*)([[:cntrl:]]|$)/g) {
1512 $res .= $1;
1513 if ($2 ne '') {
1514 $coded = sprintf("^%c", unpack('C', $2) + 64);
1515 $res .= $coded;
1516 }
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07001517 }
1518 $res =~ s/$/\$/;
Andy Whitcroft0a920b52007-06-01 00:46:48 -07001519
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07001520 return $res;
Andy Whitcroft0a920b52007-06-01 00:46:48 -07001521}
1522
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001523my $av_preprocessor = 0;
Andy Whitcroftcf655042008-03-04 14:28:20 -08001524my $av_pending;
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001525my @av_paren_type;
Andy Whitcroft1f65f942008-07-23 21:29:10 -07001526my $av_pend_colon;
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001527
1528sub annotate_reset {
1529 $av_preprocessor = 0;
Andy Whitcroftcf655042008-03-04 14:28:20 -08001530 $av_pending = '_';
1531 @av_paren_type = ('E');
Andy Whitcroft1f65f942008-07-23 21:29:10 -07001532 $av_pend_colon = 'O';
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001533}
1534
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001535sub annotate_values {
1536 my ($stream, $type) = @_;
1537
1538 my $res;
Andy Whitcroft1f65f942008-07-23 21:29:10 -07001539 my $var = '_' x length($stream);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001540 my $cur = $stream;
1541
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001542 print "$stream\n" if ($dbg_values > 1);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001543
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001544 while (length($cur)) {
Andy Whitcroft773647a2008-03-28 14:15:58 -07001545 @av_paren_type = ('E') if ($#av_paren_type < 0);
Andy Whitcroftcf655042008-03-04 14:28:20 -08001546 print " <" . join('', @av_paren_type) .
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07001547 "> <$type> <$av_pending>" if ($dbg_values > 1);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001548 if ($cur =~ /^(\s+)/o) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001549 print "WS($1)\n" if ($dbg_values > 1);
1550 if ($1 =~ /\n/ && $av_preprocessor) {
Andy Whitcroftcf655042008-03-04 14:28:20 -08001551 $type = pop(@av_paren_type);
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001552 $av_preprocessor = 0;
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001553 }
1554
Florian Micklerc023e4732011-01-12 16:59:58 -08001555 } elsif ($cur =~ /^(\(\s*$Type\s*)\)/ && $av_pending eq '_') {
Andy Whitcroft9446ef52010-10-26 14:23:13 -07001556 print "CAST($1)\n" if ($dbg_values > 1);
1557 push(@av_paren_type, $type);
Andy Whitcroftaddcdce2012-01-10 15:10:11 -08001558 $type = 'c';
Andy Whitcroft9446ef52010-10-26 14:23:13 -07001559
Andy Whitcrofte91b6e22010-10-26 14:23:11 -07001560 } elsif ($cur =~ /^($Type)\s*(?:$Ident|,|\)|\(|\s*$)/) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001561 print "DECLARE($1)\n" if ($dbg_values > 1);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001562 $type = 'T';
1563
Andy Whitcroft389a2fe2008-07-23 21:29:05 -07001564 } elsif ($cur =~ /^($Modifier)\s*/) {
1565 print "MODIFIER($1)\n" if ($dbg_values > 1);
1566 $type = 'T';
1567
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07001568 } elsif ($cur =~ /^(\#\s*define\s*$Ident)(\(?)/o) {
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07001569 print "DEFINE($1,$2)\n" if ($dbg_values > 1);
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001570 $av_preprocessor = 1;
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07001571 push(@av_paren_type, $type);
1572 if ($2 ne '') {
1573 $av_pending = 'N';
1574 }
1575 $type = 'E';
1576
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07001577 } elsif ($cur =~ /^(\#\s*(?:undef\s*$Ident|include\b))/o) {
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07001578 print "UNDEF($1)\n" if ($dbg_values > 1);
1579 $av_preprocessor = 1;
1580 push(@av_paren_type, $type);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001581
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07001582 } elsif ($cur =~ /^(\#\s*(?:ifdef|ifndef|if))/o) {
Andy Whitcroftcf655042008-03-04 14:28:20 -08001583 print "PRE_START($1)\n" if ($dbg_values > 1);
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001584 $av_preprocessor = 1;
Andy Whitcroftcf655042008-03-04 14:28:20 -08001585
1586 push(@av_paren_type, $type);
1587 push(@av_paren_type, $type);
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07001588 $type = 'E';
Andy Whitcroftcf655042008-03-04 14:28:20 -08001589
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07001590 } elsif ($cur =~ /^(\#\s*(?:else|elif))/o) {
Andy Whitcroftcf655042008-03-04 14:28:20 -08001591 print "PRE_RESTART($1)\n" if ($dbg_values > 1);
1592 $av_preprocessor = 1;
1593
1594 push(@av_paren_type, $av_paren_type[$#av_paren_type]);
1595
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07001596 $type = 'E';
Andy Whitcroftcf655042008-03-04 14:28:20 -08001597
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07001598 } elsif ($cur =~ /^(\#\s*(?:endif))/o) {
Andy Whitcroftcf655042008-03-04 14:28:20 -08001599 print "PRE_END($1)\n" if ($dbg_values > 1);
1600
1601 $av_preprocessor = 1;
1602
1603 # Assume all arms of the conditional end as this
1604 # one does, and continue as if the #endif was not here.
1605 pop(@av_paren_type);
1606 push(@av_paren_type, $type);
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07001607 $type = 'E';
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001608
1609 } elsif ($cur =~ /^(\\\n)/o) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001610 print "PRECONT($1)\n" if ($dbg_values > 1);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001611
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07001612 } elsif ($cur =~ /^(__attribute__)\s*\(?/o) {
1613 print "ATTR($1)\n" if ($dbg_values > 1);
1614 $av_pending = $type;
1615 $type = 'N';
1616
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001617 } elsif ($cur =~ /^(sizeof)\s*(\()?/o) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001618 print "SIZEOF($1)\n" if ($dbg_values > 1);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001619 if (defined $2) {
Andy Whitcroftcf655042008-03-04 14:28:20 -08001620 $av_pending = 'V';
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001621 }
1622 $type = 'N';
1623
Andy Whitcroft14b111c2008-10-15 22:02:16 -07001624 } elsif ($cur =~ /^(if|while|for)\b/o) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001625 print "COND($1)\n" if ($dbg_values > 1);
Andy Whitcroft14b111c2008-10-15 22:02:16 -07001626 $av_pending = 'E';
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001627 $type = 'N';
1628
Andy Whitcroft1f65f942008-07-23 21:29:10 -07001629 } elsif ($cur =~/^(case)/o) {
1630 print "CASE($1)\n" if ($dbg_values > 1);
1631 $av_pend_colon = 'C';
1632 $type = 'N';
1633
Andy Whitcroft14b111c2008-10-15 22:02:16 -07001634 } elsif ($cur =~/^(return|else|goto|typeof|__typeof__)\b/o) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001635 print "KEYWORD($1)\n" if ($dbg_values > 1);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001636 $type = 'N';
1637
1638 } elsif ($cur =~ /^(\()/o) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001639 print "PAREN('$1')\n" if ($dbg_values > 1);
Andy Whitcroftcf655042008-03-04 14:28:20 -08001640 push(@av_paren_type, $av_pending);
1641 $av_pending = '_';
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001642 $type = 'N';
1643
1644 } elsif ($cur =~ /^(\))/o) {
Andy Whitcroftcf655042008-03-04 14:28:20 -08001645 my $new_type = pop(@av_paren_type);
1646 if ($new_type ne '_') {
1647 $type = $new_type;
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001648 print "PAREN('$1') -> $type\n"
1649 if ($dbg_values > 1);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001650 } else {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001651 print "PAREN('$1')\n" if ($dbg_values > 1);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001652 }
1653
Andy Whitcroftc8cb2ca2008-07-23 21:28:57 -07001654 } elsif ($cur =~ /^($Ident)\s*\(/o) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001655 print "FUNC($1)\n" if ($dbg_values > 1);
Andy Whitcroftc8cb2ca2008-07-23 21:28:57 -07001656 $type = 'V';
Andy Whitcroftcf655042008-03-04 14:28:20 -08001657 $av_pending = 'V';
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001658
Andy Whitcroft8e761b02009-01-06 14:41:19 -08001659 } elsif ($cur =~ /^($Ident\s*):(?:\s*\d+\s*(,|=|;))?/) {
1660 if (defined $2 && $type eq 'C' || $type eq 'T') {
Andy Whitcroft1f65f942008-07-23 21:29:10 -07001661 $av_pend_colon = 'B';
Andy Whitcroft8e761b02009-01-06 14:41:19 -08001662 } elsif ($type eq 'E') {
1663 $av_pend_colon = 'L';
Andy Whitcroft1f65f942008-07-23 21:29:10 -07001664 }
1665 print "IDENT_COLON($1,$type>$av_pend_colon)\n" if ($dbg_values > 1);
1666 $type = 'V';
1667
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001668 } elsif ($cur =~ /^($Ident|$Constant)/o) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001669 print "IDENT($1)\n" if ($dbg_values > 1);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001670 $type = 'V';
1671
1672 } elsif ($cur =~ /^($Assignment)/o) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001673 print "ASSIGN($1)\n" if ($dbg_values > 1);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001674 $type = 'N';
1675
Andy Whitcroftcf655042008-03-04 14:28:20 -08001676 } elsif ($cur =~/^(;|{|})/) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001677 print "END($1)\n" if ($dbg_values > 1);
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001678 $type = 'E';
Andy Whitcroft1f65f942008-07-23 21:29:10 -07001679 $av_pend_colon = 'O';
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001680
Andy Whitcroft8e761b02009-01-06 14:41:19 -08001681 } elsif ($cur =~/^(,)/) {
1682 print "COMMA($1)\n" if ($dbg_values > 1);
1683 $type = 'C';
1684
Andy Whitcroft1f65f942008-07-23 21:29:10 -07001685 } elsif ($cur =~ /^(\?)/o) {
1686 print "QUESTION($1)\n" if ($dbg_values > 1);
1687 $type = 'N';
1688
1689 } elsif ($cur =~ /^(:)/o) {
1690 print "COLON($1,$av_pend_colon)\n" if ($dbg_values > 1);
1691
1692 substr($var, length($res), 1, $av_pend_colon);
1693 if ($av_pend_colon eq 'C' || $av_pend_colon eq 'L') {
1694 $type = 'E';
1695 } else {
1696 $type = 'N';
1697 }
1698 $av_pend_colon = 'O';
1699
Andy Whitcroft8e761b02009-01-06 14:41:19 -08001700 } elsif ($cur =~ /^(\[)/o) {
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001701 print "CLOSE($1)\n" if ($dbg_values > 1);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001702 $type = 'N';
1703
Andy Whitcroft0d413862008-10-15 22:02:16 -07001704 } elsif ($cur =~ /^(-(?![->])|\+(?!\+)|\*|\&\&|\&)/o) {
Andy Whitcroft74048ed2008-07-23 21:29:10 -07001705 my $variant;
1706
1707 print "OPV($1)\n" if ($dbg_values > 1);
1708 if ($type eq 'V') {
1709 $variant = 'B';
1710 } else {
1711 $variant = 'U';
1712 }
1713
1714 substr($var, length($res), 1, $variant);
1715 $type = 'N';
1716
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001717 } elsif ($cur =~ /^($Operators)/o) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001718 print "OP($1)\n" if ($dbg_values > 1);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001719 if ($1 ne '++' && $1 ne '--') {
1720 $type = 'N';
1721 }
1722
1723 } elsif ($cur =~ /(^.)/o) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001724 print "C($1)\n" if ($dbg_values > 1);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001725 }
1726 if (defined $1) {
1727 $cur = substr($cur, length($1));
1728 $res .= $type x length($1);
1729 }
1730 }
1731
Andy Whitcroft1f65f942008-07-23 21:29:10 -07001732 return ($res, $var);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001733}
1734
Andy Whitcroft8905a672007-11-28 16:21:06 -08001735sub possible {
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001736 my ($possible, $line) = @_;
Andy Whitcroft9a974fd2009-10-26 16:50:12 -07001737 my $notPermitted = qr{(?:
Andy Whitcroft0776e592008-10-15 22:02:29 -07001738 ^(?:
1739 $Modifier|
1740 $Storage|
1741 $Type|
Andy Whitcroft9a974fd2009-10-26 16:50:12 -07001742 DEFINE_\S+
1743 )$|
1744 ^(?:
Andy Whitcroft0776e592008-10-15 22:02:29 -07001745 goto|
1746 return|
1747 case|
1748 else|
1749 asm|__asm__|
Andy Whitcroft89a88352012-01-10 15:10:00 -08001750 do|
1751 \#|
1752 \#\#|
Andy Whitcroft9a974fd2009-10-26 16:50:12 -07001753 )(?:\s|$)|
Andy Whitcroft0776e592008-10-15 22:02:29 -07001754 ^(?:typedef|struct|enum)\b
Andy Whitcroft9a974fd2009-10-26 16:50:12 -07001755 )}x;
1756 warn "CHECK<$possible> ($line)\n" if ($dbg_possible > 2);
1757 if ($possible !~ $notPermitted) {
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07001758 # Check for modifiers.
1759 $possible =~ s/\s*$Storage\s*//g;
1760 $possible =~ s/\s*$Sparse\s*//g;
1761 if ($possible =~ /^\s*$/) {
1762
1763 } elsif ($possible =~ /\s/) {
1764 $possible =~ s/\s*$Type\s*//g;
Andy Whitcroftd2506582008-07-23 21:29:09 -07001765 for my $modifier (split(' ', $possible)) {
Andy Whitcroft9a974fd2009-10-26 16:50:12 -07001766 if ($modifier !~ $notPermitted) {
1767 warn "MODIFIER: $modifier ($possible) ($line)\n" if ($dbg_possible);
Alex Dowad485ff232015-06-25 15:02:52 -07001768 push(@modifierListFile, $modifier);
Andy Whitcroft9a974fd2009-10-26 16:50:12 -07001769 }
Andy Whitcroftd2506582008-07-23 21:29:09 -07001770 }
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07001771
1772 } else {
1773 warn "POSSIBLE: $possible ($line)\n" if ($dbg_possible);
Alex Dowad485ff232015-06-25 15:02:52 -07001774 push(@typeListFile, $possible);
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07001775 }
Andy Whitcroft8905a672007-11-28 16:21:06 -08001776 build_types();
Andy Whitcroft0776e592008-10-15 22:02:29 -07001777 } else {
1778 warn "NOTPOSS: $possible ($line)\n" if ($dbg_possible > 1);
Andy Whitcroft8905a672007-11-28 16:21:06 -08001779 }
1780}
1781
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001782my $prefix = '';
1783
Joe Perches000d1cc12011-07-25 17:13:25 -07001784sub show_type {
Joe Perchescbec18a2014-04-03 14:49:19 -07001785 my ($type) = @_;
Joe Perches91bfe482013-09-11 14:23:59 -07001786
Joe Perchescbec18a2014-04-03 14:49:19 -07001787 return defined $use_type{$type} if (scalar keys %use_type > 0);
1788
1789 return !defined $ignore_type{$type};
Joe Perches000d1cc12011-07-25 17:13:25 -07001790}
1791
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001792sub report {
Joe Perchescbec18a2014-04-03 14:49:19 -07001793 my ($level, $type, $msg) = @_;
1794
1795 if (!show_type($type) ||
1796 (defined $tst_only && $msg !~ /\Q$tst_only\E/)) {
Andy Whitcroft773647a2008-03-28 14:15:58 -07001797 return 0;
1798 }
Joe Perches57230292015-06-25 15:03:03 -07001799 my $output = '';
1800 if (-t STDOUT && $color) {
1801 if ($level eq 'ERROR') {
1802 $output .= RED;
1803 } elsif ($level eq 'WARNING') {
1804 $output .= YELLOW;
1805 } else {
1806 $output .= GREEN;
1807 }
Joe Perches000d1cc12011-07-25 17:13:25 -07001808 }
Joe Perches57230292015-06-25 15:03:03 -07001809 $output .= $prefix . $level . ':';
1810 if ($show_types) {
1811 $output .= BLUE if (-t STDOUT && $color);
1812 $output .= "$type:";
1813 }
1814 $output .= RESET if (-t STDOUT && $color);
1815 $output .= ' ' . $msg . "\n";
Joe Perches34d88152015-06-25 15:03:05 -07001816
1817 if ($showfile) {
1818 my @lines = split("\n", $output, -1);
1819 splice(@lines, 1, 1);
1820 $output = join("\n", @lines);
1821 }
Joe Perches57230292015-06-25 15:03:03 -07001822 $output = (split('\n', $output))[0] . "\n" if ($terse);
Andy Whitcroft8905a672007-11-28 16:21:06 -08001823
Joe Perches57230292015-06-25 15:03:03 -07001824 push(our @report, $output);
Andy Whitcroft773647a2008-03-28 14:15:58 -07001825
1826 return 1;
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001827}
Joe Perchescbec18a2014-04-03 14:49:19 -07001828
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001829sub report_dump {
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001830 our @report;
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001831}
Joe Perches000d1cc12011-07-25 17:13:25 -07001832
Joe Perchesd752fcc2014-08-06 16:11:05 -07001833sub fixup_current_range {
1834 my ($lineRef, $offset, $length) = @_;
1835
1836 if ($$lineRef =~ /^\@\@ -\d+,\d+ \+(\d+),(\d+) \@\@/) {
1837 my $o = $1;
1838 my $l = $2;
1839 my $no = $o + $offset;
1840 my $nl = $l + $length;
1841 $$lineRef =~ s/\+$o,$l \@\@/\+$no,$nl \@\@/;
1842 }
1843}
1844
1845sub fix_inserted_deleted_lines {
1846 my ($linesRef, $insertedRef, $deletedRef) = @_;
1847
1848 my $range_last_linenr = 0;
1849 my $delta_offset = 0;
1850
1851 my $old_linenr = 0;
1852 my $new_linenr = 0;
1853
1854 my $next_insert = 0;
1855 my $next_delete = 0;
1856
1857 my @lines = ();
1858
1859 my $inserted = @{$insertedRef}[$next_insert++];
1860 my $deleted = @{$deletedRef}[$next_delete++];
1861
1862 foreach my $old_line (@{$linesRef}) {
1863 my $save_line = 1;
1864 my $line = $old_line; #don't modify the array
Joe Perches323b2672015-04-16 12:44:50 -07001865 if ($line =~ /^(?:\+\+\+|\-\-\-)\s+\S+/) { #new filename
Joe Perchesd752fcc2014-08-06 16:11:05 -07001866 $delta_offset = 0;
1867 } elsif ($line =~ /^\@\@ -\d+,\d+ \+\d+,\d+ \@\@/) { #new hunk
1868 $range_last_linenr = $new_linenr;
1869 fixup_current_range(\$line, $delta_offset, 0);
1870 }
1871
1872 while (defined($deleted) && ${$deleted}{'LINENR'} == $old_linenr) {
1873 $deleted = @{$deletedRef}[$next_delete++];
1874 $save_line = 0;
1875 fixup_current_range(\$lines[$range_last_linenr], $delta_offset--, -1);
1876 }
1877
1878 while (defined($inserted) && ${$inserted}{'LINENR'} == $old_linenr) {
1879 push(@lines, ${$inserted}{'LINE'});
1880 $inserted = @{$insertedRef}[$next_insert++];
1881 $new_linenr++;
1882 fixup_current_range(\$lines[$range_last_linenr], $delta_offset++, 1);
1883 }
1884
1885 if ($save_line) {
1886 push(@lines, $line);
1887 $new_linenr++;
1888 }
1889
1890 $old_linenr++;
1891 }
1892
1893 return @lines;
1894}
1895
Joe Perchesf2d7e4d2014-08-06 16:11:07 -07001896sub fix_insert_line {
1897 my ($linenr, $line) = @_;
1898
1899 my $inserted = {
1900 LINENR => $linenr,
1901 LINE => $line,
1902 };
1903 push(@fixed_inserted, $inserted);
1904}
1905
1906sub fix_delete_line {
1907 my ($linenr, $line) = @_;
1908
1909 my $deleted = {
1910 LINENR => $linenr,
1911 LINE => $line,
1912 };
1913
1914 push(@fixed_deleted, $deleted);
1915}
1916
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07001917sub ERROR {
Joe Perchescbec18a2014-04-03 14:49:19 -07001918 my ($type, $msg) = @_;
1919
1920 if (report("ERROR", $type, $msg)) {
Andy Whitcroft773647a2008-03-28 14:15:58 -07001921 our $clean = 0;
1922 our $cnt_error++;
Joe Perches3705ce52013-07-03 15:05:31 -07001923 return 1;
Andy Whitcroft773647a2008-03-28 14:15:58 -07001924 }
Joe Perches3705ce52013-07-03 15:05:31 -07001925 return 0;
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07001926}
1927sub WARN {
Joe Perchescbec18a2014-04-03 14:49:19 -07001928 my ($type, $msg) = @_;
1929
1930 if (report("WARNING", $type, $msg)) {
Andy Whitcroft773647a2008-03-28 14:15:58 -07001931 our $clean = 0;
1932 our $cnt_warn++;
Joe Perches3705ce52013-07-03 15:05:31 -07001933 return 1;
Andy Whitcroft773647a2008-03-28 14:15:58 -07001934 }
Joe Perches3705ce52013-07-03 15:05:31 -07001935 return 0;
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07001936}
1937sub CHK {
Joe Perchescbec18a2014-04-03 14:49:19 -07001938 my ($type, $msg) = @_;
1939
1940 if ($check && report("CHECK", $type, $msg)) {
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001941 our $clean = 0;
1942 our $cnt_chk++;
Joe Perches3705ce52013-07-03 15:05:31 -07001943 return 1;
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001944 }
Joe Perches3705ce52013-07-03 15:05:31 -07001945 return 0;
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07001946}
1947
Andy Whitcroft6ecd9672008-10-15 22:02:21 -07001948sub check_absolute_file {
1949 my ($absolute, $herecurr) = @_;
1950 my $file = $absolute;
1951
1952 ##print "absolute<$absolute>\n";
1953
1954 # See if any suffix of this path is a path within the tree.
1955 while ($file =~ s@^[^/]*/@@) {
1956 if (-f "$root/$file") {
1957 ##print "file<$file>\n";
1958 last;
1959 }
1960 }
1961 if (! -f _) {
1962 return 0;
1963 }
1964
1965 # It is, so see if the prefix is acceptable.
1966 my $prefix = $absolute;
1967 substr($prefix, -length($file)) = '';
1968
1969 ##print "prefix<$prefix>\n";
1970 if ($prefix ne ".../") {
Joe Perches000d1cc12011-07-25 17:13:25 -07001971 WARN("USE_RELATIVE_PATH",
1972 "use relative pathname instead of absolute in changelog text\n" . $herecurr);
Andy Whitcroft6ecd9672008-10-15 22:02:21 -07001973 }
1974}
1975
Joe Perches3705ce52013-07-03 15:05:31 -07001976sub trim {
1977 my ($string) = @_;
1978
Joe Perchesb34c6482013-09-11 14:24:01 -07001979 $string =~ s/^\s+|\s+$//g;
1980
1981 return $string;
1982}
1983
1984sub ltrim {
1985 my ($string) = @_;
1986
1987 $string =~ s/^\s+//;
1988
1989 return $string;
1990}
1991
1992sub rtrim {
1993 my ($string) = @_;
1994
1995 $string =~ s/\s+$//;
Joe Perches3705ce52013-07-03 15:05:31 -07001996
1997 return $string;
1998}
1999
Joe Perches52ea8502013-11-12 15:10:09 -08002000sub string_find_replace {
2001 my ($string, $find, $replace) = @_;
2002
2003 $string =~ s/$find/$replace/g;
2004
2005 return $string;
2006}
2007
Joe Perches3705ce52013-07-03 15:05:31 -07002008sub tabify {
2009 my ($leading) = @_;
2010
2011 my $source_indent = 8;
2012 my $max_spaces_before_tab = $source_indent - 1;
2013 my $spaces_to_tab = " " x $source_indent;
2014
2015 #convert leading spaces to tabs
2016 1 while $leading =~ s@^([\t]*)$spaces_to_tab@$1\t@g;
2017 #Remove spaces before a tab
2018 1 while $leading =~ s@^([\t]*)( {1,$max_spaces_before_tab})\t@$1\t@g;
2019
2020 return "$leading";
2021}
2022
Joe Perchesd1fe9c02012-03-23 15:02:16 -07002023sub pos_last_openparen {
2024 my ($line) = @_;
2025
2026 my $pos = 0;
2027
2028 my $opens = $line =~ tr/\(/\(/;
2029 my $closes = $line =~ tr/\)/\)/;
2030
2031 my $last_openparen = 0;
2032
2033 if (($opens == 0) || ($closes >= $opens)) {
2034 return -1;
2035 }
2036
2037 my $len = length($line);
2038
2039 for ($pos = 0; $pos < $len; $pos++) {
2040 my $string = substr($line, $pos);
2041 if ($string =~ /^($FuncArg|$balanced_parens)/) {
2042 $pos += length($1) - 1;
2043 } elsif (substr($line, $pos, 1) eq '(') {
2044 $last_openparen = $pos;
2045 } elsif (index($string, '(') == -1) {
2046 last;
2047 }
2048 }
2049
Joe Perches91cb5192014-04-03 14:49:32 -07002050 return length(expand_tabs(substr($line, 0, $last_openparen))) + 1;
Joe Perchesd1fe9c02012-03-23 15:02:16 -07002051}
2052
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002053sub process {
2054 my $filename = shift;
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002055
2056 my $linenr=0;
2057 my $prevline="";
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002058 my $prevrawline="";
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002059 my $stashline="";
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002060 my $stashrawline="";
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002061
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07002062 my $length;
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002063 my $indent;
2064 my $previndent=0;
2065 my $stashindent=0;
2066
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07002067 our $clean = 1;
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002068 my $signoff = 0;
2069 my $is_patch = 0;
Joe Perches29ee1b02014-08-06 16:10:35 -07002070 my $in_header_lines = $file ? 0 : 1;
Joe Perches15662b32011-10-31 17:13:12 -07002071 my $in_commit_log = 0; #Scanning lines before patch
Allen Hubbeed43c4e2016-08-02 14:04:45 -07002072 my $has_commit_log = 0; #Encountered lines before patch
Joe Perchesbf4daf12015-09-09 15:37:50 -07002073 my $commit_log_possible_stack_dump = 0;
Joe Perches2a076f42015-04-16 12:44:28 -07002074 my $commit_log_long_line = 0;
Joe Perchese518e9a2015-06-25 15:03:27 -07002075 my $commit_log_has_diff = 0;
Joe Perches13f19372014-08-06 16:10:59 -07002076 my $reported_maintainer_file = 0;
Pasi Savanainenfa64205d2012-10-04 17:13:29 -07002077 my $non_utf8_charset = 0;
2078
Joe Perches365dd4e2014-08-06 16:10:42 -07002079 my $last_blank_line = 0;
Joe Perches5e4f6ba2014-12-10 15:52:05 -08002080 my $last_coalesced_string_linenr = -1;
Joe Perches365dd4e2014-08-06 16:10:42 -07002081
Andy Whitcroft13214ad2008-02-08 04:22:03 -08002082 our @report = ();
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07002083 our $cnt_lines = 0;
2084 our $cnt_error = 0;
2085 our $cnt_warn = 0;
2086 our $cnt_chk = 0;
2087
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002088 # Trace the real file/line as we go.
2089 my $realfile = '';
2090 my $realline = 0;
2091 my $realcnt = 0;
2092 my $here = '';
2093 my $in_comment = 0;
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002094 my $comment_edge = 0;
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002095 my $first_line = 0;
Wolfram Sang1e855722009-01-06 14:41:24 -08002096 my $p1_prefix = '';
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002097
Andy Whitcroft13214ad2008-02-08 04:22:03 -08002098 my $prev_values = 'E';
2099
2100 # suppression flags
Andy Whitcroft773647a2008-03-28 14:15:58 -07002101 my %suppress_ifbraces;
Andy Whitcroft170d3a22008-10-15 22:02:30 -07002102 my %suppress_whiletrailers;
Andy Whitcroft2b474a12009-10-26 16:50:16 -07002103 my %suppress_export;
Andy Whitcroft3e469cd2012-01-10 15:10:01 -08002104 my $suppress_statement = 0;
Andy Whitcroft653d4872007-06-23 17:16:34 -07002105
Joe Perches7e51f192013-09-11 14:23:57 -07002106 my %signatures = ();
Joe Perches323c1262012-12-17 16:02:07 -08002107
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002108 # Pre-scan the patch sanitizing the lines.
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07002109 # Pre-scan the patch looking for any __setup documentation.
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002110 #
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07002111 my @setup_docs = ();
2112 my $setup_docs = 0;
Andy Whitcroft773647a2008-03-28 14:15:58 -07002113
Joe Perchesd8b07712013-11-12 15:10:06 -08002114 my $camelcase_file_seeded = 0;
2115
Andy Whitcroft773647a2008-03-28 14:15:58 -07002116 sanitise_line_reset();
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002117 my $line;
2118 foreach my $rawline (@rawlines) {
Andy Whitcroft773647a2008-03-28 14:15:58 -07002119 $linenr++;
2120 $line = $rawline;
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002121
Joe Perches3705ce52013-07-03 15:05:31 -07002122 push(@fixed, $rawline) if ($fix);
2123
Andy Whitcroft773647a2008-03-28 14:15:58 -07002124 if ($rawline=~/^\+\+\+\s+(\S+)/) {
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07002125 $setup_docs = 0;
2126 if ($1 =~ m@Documentation/kernel-parameters.txt$@) {
2127 $setup_docs = 1;
2128 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07002129 #next;
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07002130 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07002131 if ($rawline=~/^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@/) {
2132 $realline=$1-1;
2133 if (defined $2) {
2134 $realcnt=$3+1;
2135 } else {
2136 $realcnt=1+1;
2137 }
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07002138 $in_comment = 0;
Andy Whitcroft773647a2008-03-28 14:15:58 -07002139
2140 # Guestimate if this is a continuing comment. Run
2141 # the context looking for a comment "edge". If this
2142 # edge is a close comment then we must be in a comment
2143 # at context start.
2144 my $edge;
Andy Whitcroft01fa9142008-10-15 22:02:19 -07002145 my $cnt = $realcnt;
2146 for (my $ln = $linenr + 1; $cnt > 0; $ln++) {
2147 next if (defined $rawlines[$ln - 1] &&
2148 $rawlines[$ln - 1] =~ /^-/);
2149 $cnt--;
2150 #print "RAW<$rawlines[$ln - 1]>\n";
Andy Whitcroft721c1cb2009-01-06 14:41:16 -08002151 last if (!defined $rawlines[$ln - 1]);
Andy Whitcroftfae17da2009-01-06 14:41:20 -08002152 if ($rawlines[$ln - 1] =~ m@(/\*|\*/)@ &&
2153 $rawlines[$ln - 1] !~ m@"[^"]*(?:/\*|\*/)[^"]*"@) {
2154 ($edge) = $1;
2155 last;
2156 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07002157 }
2158 if (defined $edge && $edge eq '*/') {
2159 $in_comment = 1;
2160 }
2161
2162 # Guestimate if this is a continuing comment. If this
2163 # is the start of a diff block and this line starts
2164 # ' *' then it is very likely a comment.
2165 if (!defined $edge &&
Andy Whitcroft83242e02009-01-06 14:41:17 -08002166 $rawlines[$linenr] =~ m@^.\s*(?:\*\*+| \*)(?:\s|$)@)
Andy Whitcroft773647a2008-03-28 14:15:58 -07002167 {
2168 $in_comment = 1;
2169 }
2170
2171 ##print "COMMENT:$in_comment edge<$edge> $rawline\n";
2172 sanitise_line_reset($in_comment);
2173
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07002174 } elsif ($realcnt && $rawline =~ /^(?:\+| |$)/) {
Andy Whitcroft773647a2008-03-28 14:15:58 -07002175 # Standardise the strings and chars within the input to
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07002176 # simplify matching -- only bother with positive lines.
Andy Whitcroft773647a2008-03-28 14:15:58 -07002177 $line = sanitise_line($rawline);
2178 }
2179 push(@lines, $line);
2180
2181 if ($realcnt > 1) {
2182 $realcnt-- if ($line =~ /^(?:\+| |$)/);
2183 } else {
2184 $realcnt = 0;
2185 }
2186
2187 #print "==>$rawline\n";
2188 #print "-->$line\n";
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07002189
2190 if ($setup_docs && $line =~ /^\+/) {
2191 push(@setup_docs, $line);
2192 }
2193 }
2194
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07002195 $prefix = '';
2196
Andy Whitcroft773647a2008-03-28 14:15:58 -07002197 $realcnt = 0;
2198 $linenr = 0;
Joe Perches194f66f2014-08-06 16:11:03 -07002199 $fixlinenr = -1;
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002200 foreach my $line (@lines) {
2201 $linenr++;
Joe Perches194f66f2014-08-06 16:11:03 -07002202 $fixlinenr++;
Joe Perches1b5539b2013-09-11 14:24:03 -07002203 my $sline = $line; #copy of $line
2204 $sline =~ s/$;/ /g; #with comments as spaces
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002205
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002206 my $rawline = $rawlines[$linenr - 1];
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07002207
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002208#extract the line range in the file after the patch is applied
Joe Perchese518e9a2015-06-25 15:03:27 -07002209 if (!$in_commit_log &&
2210 $line =~ /^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@/) {
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002211 $is_patch = 1;
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07002212 $first_line = $linenr + 1;
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002213 $realline=$1-1;
2214 if (defined $2) {
2215 $realcnt=$3+1;
2216 } else {
2217 $realcnt=1+1;
2218 }
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002219 annotate_reset();
Andy Whitcroft13214ad2008-02-08 04:22:03 -08002220 $prev_values = 'E';
2221
Andy Whitcroft773647a2008-03-28 14:15:58 -07002222 %suppress_ifbraces = ();
Andy Whitcroft170d3a22008-10-15 22:02:30 -07002223 %suppress_whiletrailers = ();
Andy Whitcroft2b474a12009-10-26 16:50:16 -07002224 %suppress_export = ();
Andy Whitcroft3e469cd2012-01-10 15:10:01 -08002225 $suppress_statement = 0;
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002226 next;
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002227
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07002228# track the line number as we move through the hunk, note that
2229# new versions of GNU diff omit the leading space on completely
2230# blank context lines so we need to count that too.
Andy Whitcroft773647a2008-03-28 14:15:58 -07002231 } elsif ($line =~ /^( |\+|$)/) {
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002232 $realline++;
Andy Whitcroftd8aaf122007-06-23 17:16:44 -07002233 $realcnt-- if ($realcnt != 0);
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002234
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07002235 # Measure the line length and indent.
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002236 ($length, $indent) = line_stats($rawline);
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002237
2238 # Track the previous line.
2239 ($prevline, $stashline) = ($stashline, $line);
2240 ($previndent, $stashindent) = ($stashindent, $indent);
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002241 ($prevrawline, $stashrawline) = ($stashrawline, $rawline);
2242
Andy Whitcroft773647a2008-03-28 14:15:58 -07002243 #warn "line<$line>\n";
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07002244
Andy Whitcroftd8aaf122007-06-23 17:16:44 -07002245 } elsif ($realcnt == 1) {
2246 $realcnt--;
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002247 }
2248
Andy Whitcroftcc77cdc2009-10-26 16:50:13 -07002249 my $hunk_line = ($realcnt != 0);
2250
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07002251 $here = "#$linenr: " if (!$file);
2252 $here = "#$realline: " if ($file);
Andy Whitcroft773647a2008-03-28 14:15:58 -07002253
Joe Perches2ac73b4f2014-06-04 16:12:05 -07002254 my $found_file = 0;
Andy Whitcroft773647a2008-03-28 14:15:58 -07002255 # extract the filename as it passes
Rabin Vincent3bf9a002010-10-26 14:23:16 -07002256 if ($line =~ /^diff --git.*?(\S+)$/) {
2257 $realfile = $1;
Joe Perches2b7ab452013-11-12 15:10:14 -08002258 $realfile =~ s@^([^/]*)/@@ if (!$file);
Joe Perches270c49a2012-01-10 15:09:50 -08002259 $in_commit_log = 0;
Joe Perches2ac73b4f2014-06-04 16:12:05 -07002260 $found_file = 1;
Rabin Vincent3bf9a002010-10-26 14:23:16 -07002261 } elsif ($line =~ /^\+\+\+\s+(\S+)/) {
Andy Whitcroft773647a2008-03-28 14:15:58 -07002262 $realfile = $1;
Joe Perches2b7ab452013-11-12 15:10:14 -08002263 $realfile =~ s@^([^/]*)/@@ if (!$file);
Joe Perches270c49a2012-01-10 15:09:50 -08002264 $in_commit_log = 0;
Wolfram Sang1e855722009-01-06 14:41:24 -08002265
2266 $p1_prefix = $1;
Andy Whitcrofte2f7aa42009-02-27 14:03:06 -08002267 if (!$file && $tree && $p1_prefix ne '' &&
2268 -e "$root/$p1_prefix") {
Joe Perches000d1cc12011-07-25 17:13:25 -07002269 WARN("PATCH_PREFIX",
2270 "patch prefix '$p1_prefix' exists, appears to be a -p0 patch\n");
Wolfram Sang1e855722009-01-06 14:41:24 -08002271 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07002272
Andy Whitcroftc1ab3322008-10-15 22:02:20 -07002273 if ($realfile =~ m@^include/asm/@) {
Joe Perches000d1cc12011-07-25 17:13:25 -07002274 ERROR("MODIFIED_INCLUDE_ASM",
2275 "do not modify files in include/asm, change architecture specific files in include/asm-<architecture>\n" . "$here$rawline\n");
Andy Whitcroft773647a2008-03-28 14:15:58 -07002276 }
Joe Perches2ac73b4f2014-06-04 16:12:05 -07002277 $found_file = 1;
2278 }
2279
Joe Perches34d88152015-06-25 15:03:05 -07002280#make up the handle for any error we report on this line
2281 if ($showfile) {
2282 $prefix = "$realfile:$realline: "
2283 } elsif ($emacs) {
Joe Perches7d3a9f62015-09-09 15:37:39 -07002284 if ($file) {
2285 $prefix = "$filename:$realline: ";
2286 } else {
2287 $prefix = "$filename:$linenr: ";
2288 }
Joe Perches34d88152015-06-25 15:03:05 -07002289 }
2290
Joe Perches2ac73b4f2014-06-04 16:12:05 -07002291 if ($found_file) {
Joe Perches7bd7e482015-09-09 15:37:44 -07002292 if ($realfile =~ m@^(?:drivers/net/|net/|drivers/staging/)@) {
Joe Perches2ac73b4f2014-06-04 16:12:05 -07002293 $check = 1;
2294 } else {
2295 $check = $check_orig;
2296 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07002297 next;
2298 }
2299
Randy Dunlap389834b2007-06-08 13:47:03 -07002300 $here .= "FILE: $realfile:$realline:" if ($realcnt != 0);
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002301
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002302 my $hereline = "$here\n$rawline\n";
2303 my $herecurr = "$here\n$rawline\n";
2304 my $hereprev = "$here\n$prevrawline\n$rawline\n";
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002305
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07002306 $cnt_lines++ if ($realcnt != 0);
2307
Joe Perchese518e9a2015-06-25 15:03:27 -07002308# Check if the commit log has what seems like a diff which can confuse patch
2309 if ($in_commit_log && !$commit_log_has_diff &&
2310 (($line =~ m@^\s+diff\b.*a/[\w/]+@ &&
2311 $line =~ m@^\s+diff\b.*a/([\w/]+)\s+b/$1\b@) ||
2312 $line =~ m@^\s*(?:\-\-\-\s+a/|\+\+\+\s+b/)@ ||
2313 $line =~ m/^\s*\@\@ \-\d+,\d+ \+\d+,\d+ \@\@/)) {
2314 ERROR("DIFF_IN_COMMIT_MSG",
2315 "Avoid using diff content in the commit message - patch(1) might not work\n" . $herecurr);
2316 $commit_log_has_diff = 1;
2317 }
2318
Rabin Vincent3bf9a002010-10-26 14:23:16 -07002319# Check for incorrect file permissions
2320 if ($line =~ /^new (file )?mode.*[7531]\d{0,2}$/) {
2321 my $permhere = $here . "FILE: $realfile\n";
Joe Perches04db4d22013-04-29 16:18:14 -07002322 if ($realfile !~ m@scripts/@ &&
2323 $realfile !~ /\.(py|pl|awk|sh)$/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07002324 ERROR("EXECUTE_PERMISSIONS",
2325 "do not set execute permissions for source files\n" . $permhere);
Rabin Vincent3bf9a002010-10-26 14:23:16 -07002326 }
2327 }
2328
Joe Perches20112472011-07-25 17:13:23 -07002329# Check the patch for a signoff:
Andy Whitcroftd8aaf122007-06-23 17:16:44 -07002330 if ($line =~ /^\s*signed-off-by:/i) {
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07002331 $signoff++;
Joe Perches15662b32011-10-31 17:13:12 -07002332 $in_commit_log = 0;
Joe Perches20112472011-07-25 17:13:23 -07002333 }
2334
Joe Perchese0d975b2014-12-10 15:51:49 -08002335# Check if MAINTAINERS is being updated. If so, there's probably no need to
2336# emit the "does MAINTAINERS need updating?" message on file add/move/delete
2337 if ($line =~ /^\s*MAINTAINERS\s*\|/) {
2338 $reported_maintainer_file = 1;
2339 }
2340
Joe Perches20112472011-07-25 17:13:23 -07002341# Check signature styles
Joe Perches270c49a2012-01-10 15:09:50 -08002342 if (!$in_header_lines &&
Joe Perchesce0338df3c2012-07-30 14:41:18 -07002343 $line =~ /^(\s*)([a-z0-9_-]+by:|$signature_tags)(\s*)(.*)/i) {
Joe Perches20112472011-07-25 17:13:23 -07002344 my $space_before = $1;
2345 my $sign_off = $2;
2346 my $space_after = $3;
2347 my $email = $4;
2348 my $ucfirst_sign_off = ucfirst(lc($sign_off));
2349
Joe Perchesce0338df3c2012-07-30 14:41:18 -07002350 if ($sign_off !~ /$signature_tags/) {
2351 WARN("BAD_SIGN_OFF",
2352 "Non-standard signature: $sign_off\n" . $herecurr);
2353 }
Joe Perches20112472011-07-25 17:13:23 -07002354 if (defined $space_before && $space_before ne "") {
Joe Perches3705ce52013-07-03 15:05:31 -07002355 if (WARN("BAD_SIGN_OFF",
2356 "Do not use whitespace before $ucfirst_sign_off\n" . $herecurr) &&
2357 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07002358 $fixed[$fixlinenr] =
Joe Perches3705ce52013-07-03 15:05:31 -07002359 "$ucfirst_sign_off $email";
2360 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002361 }
Joe Perches20112472011-07-25 17:13:23 -07002362 if ($sign_off =~ /-by:$/i && $sign_off ne $ucfirst_sign_off) {
Joe Perches3705ce52013-07-03 15:05:31 -07002363 if (WARN("BAD_SIGN_OFF",
2364 "'$ucfirst_sign_off' is the preferred signature form\n" . $herecurr) &&
2365 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07002366 $fixed[$fixlinenr] =
Joe Perches3705ce52013-07-03 15:05:31 -07002367 "$ucfirst_sign_off $email";
2368 }
2369
Joe Perches20112472011-07-25 17:13:23 -07002370 }
2371 if (!defined $space_after || $space_after ne " ") {
Joe Perches3705ce52013-07-03 15:05:31 -07002372 if (WARN("BAD_SIGN_OFF",
2373 "Use a single space after $ucfirst_sign_off\n" . $herecurr) &&
2374 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07002375 $fixed[$fixlinenr] =
Joe Perches3705ce52013-07-03 15:05:31 -07002376 "$ucfirst_sign_off $email";
2377 }
Joe Perches20112472011-07-25 17:13:23 -07002378 }
2379
2380 my ($email_name, $email_address, $comment) = parse_email($email);
2381 my $suggested_email = format_email(($email_name, $email_address));
2382 if ($suggested_email eq "") {
Joe Perches000d1cc12011-07-25 17:13:25 -07002383 ERROR("BAD_SIGN_OFF",
2384 "Unrecognized email address: '$email'\n" . $herecurr);
Joe Perches20112472011-07-25 17:13:23 -07002385 } else {
2386 my $dequoted = $suggested_email;
2387 $dequoted =~ s/^"//;
2388 $dequoted =~ s/" </ </;
2389 # Don't force email to have quotes
2390 # Allow just an angle bracketed address
2391 if ("$dequoted$comment" ne $email &&
2392 "<$email_address>$comment" ne $email &&
2393 "$suggested_email$comment" ne $email) {
Joe Perches000d1cc12011-07-25 17:13:25 -07002394 WARN("BAD_SIGN_OFF",
2395 "email address '$email' might be better as '$suggested_email$comment'\n" . $herecurr);
Joe Perches20112472011-07-25 17:13:23 -07002396 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002397 }
Joe Perches7e51f192013-09-11 14:23:57 -07002398
2399# Check for duplicate signatures
2400 my $sig_nospace = $line;
2401 $sig_nospace =~ s/\s//g;
2402 $sig_nospace = lc($sig_nospace);
2403 if (defined $signatures{$sig_nospace}) {
2404 WARN("BAD_SIGN_OFF",
2405 "Duplicate signature\n" . $herecurr);
2406 } else {
2407 $signatures{$sig_nospace} = 1;
2408 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002409 }
2410
Joe Perchesa2fe16b2015-02-13 14:39:02 -08002411# Check email subject for common tools that don't need to be mentioned
2412 if ($in_header_lines &&
2413 $line =~ /^Subject:.*\b(?:checkpatch|sparse|smatch)\b[^:]/i) {
2414 WARN("EMAIL_SUBJECT",
2415 "A patch subject line should describe the change not the tool that found it\n" . $herecurr);
2416 }
2417
Joe Perches9b3189e2014-06-04 16:12:10 -07002418# Check for old stable address
2419 if ($line =~ /^\s*cc:\s*.*<?\bstable\@kernel\.org\b>?.*$/i) {
2420 ERROR("STABLE_ADDRESS",
2421 "The 'stable' address should be 'stable\@vger.kernel.org'\n" . $herecurr);
2422 }
2423
Christopher Covington7ebd05e2014-04-03 14:49:31 -07002424# Check for unwanted Gerrit info
2425 if ($in_commit_log && $line =~ /^\s*change-id:/i) {
2426 ERROR("GERRIT_CHANGE_ID",
2427 "Remove Gerrit Change-Id's before submitting upstream.\n" . $herecurr);
2428 }
2429
Joe Perches369c8dd2015-11-06 16:31:34 -08002430# Check if the commit log is in a possible stack dump
2431 if ($in_commit_log && !$commit_log_possible_stack_dump &&
2432 ($line =~ /^\s*(?:WARNING:|BUG:)/ ||
2433 $line =~ /^\s*\[\s*\d+\.\d{6,6}\s*\]/ ||
2434 # timestamp
2435 $line =~ /^\s*\[\<[0-9a-fA-F]{8,}\>\]/)) {
2436 # stack dump address
2437 $commit_log_possible_stack_dump = 1;
2438 }
2439
Joe Perches2a076f42015-04-16 12:44:28 -07002440# Check for line lengths > 75 in commit log, warn once
2441 if ($in_commit_log && !$commit_log_long_line &&
Joe Perches369c8dd2015-11-06 16:31:34 -08002442 length($line) > 75 &&
2443 !($line =~ /^\s*[a-zA-Z0-9_\/\.]+\s+\|\s+\d+/ ||
2444 # file delta changes
2445 $line =~ /^\s*(?:[\w\.\-]+\/)++[\w\.\-]+:/ ||
2446 # filename then :
2447 $line =~ /^\s*(?:Fixes:|Link:)/i ||
2448 # A Fixes: or Link: line
2449 $commit_log_possible_stack_dump)) {
Joe Perches2a076f42015-04-16 12:44:28 -07002450 WARN("COMMIT_LOG_LONG_LINE",
2451 "Possible unwrapped commit description (prefer a maximum 75 chars per line)\n" . $herecurr);
2452 $commit_log_long_line = 1;
2453 }
2454
Joe Perchesbf4daf12015-09-09 15:37:50 -07002455# Reset possible stack dump if a blank line is found
Joe Perches369c8dd2015-11-06 16:31:34 -08002456 if ($in_commit_log && $commit_log_possible_stack_dump &&
2457 $line =~ /^\s*$/) {
2458 $commit_log_possible_stack_dump = 0;
2459 }
Joe Perchesbf4daf12015-09-09 15:37:50 -07002460
Joe Perches0d7835f2015-02-13 14:38:35 -08002461# Check for git id commit length and improperly formed commit descriptions
Joe Perches369c8dd2015-11-06 16:31:34 -08002462 if ($in_commit_log && !$commit_log_possible_stack_dump &&
Joe Perchesaab38f52016-08-02 14:04:36 -07002463 $line !~ /^\s*(?:Link|Patchwork|http|https|BugLink):/i &&
Joe Perchesfe043ea2015-09-09 15:37:25 -07002464 ($line =~ /\bcommit\s+[0-9a-f]{5,}\b/i ||
Joe Perchesaab38f52016-08-02 14:04:36 -07002465 ($line =~ /(?:\s|^)[0-9a-f]{12,40}(?:[\s"'\(\[]|$)/i &&
Joe Perches369c8dd2015-11-06 16:31:34 -08002466 $line !~ /[\<\[][0-9a-f]{12,40}[\>\]]/i &&
2467 $line !~ /\bfixes:\s*[0-9a-f]{12,40}/i))) {
Joe Perchesfe043ea2015-09-09 15:37:25 -07002468 my $init_char = "c";
2469 my $orig_commit = "";
Joe Perches0d7835f2015-02-13 14:38:35 -08002470 my $short = 1;
2471 my $long = 0;
2472 my $case = 1;
2473 my $space = 1;
2474 my $hasdesc = 0;
Joe Perches19c146a2015-02-13 14:39:00 -08002475 my $hasparens = 0;
Joe Perches0d7835f2015-02-13 14:38:35 -08002476 my $id = '0123456789ab';
2477 my $orig_desc = "commit description";
2478 my $description = "";
2479
Joe Perchesfe043ea2015-09-09 15:37:25 -07002480 if ($line =~ /\b(c)ommit\s+([0-9a-f]{5,})\b/i) {
2481 $init_char = $1;
2482 $orig_commit = lc($2);
2483 } elsif ($line =~ /\b([0-9a-f]{12,40})\b/i) {
2484 $orig_commit = lc($1);
2485 }
2486
Joe Perches0d7835f2015-02-13 14:38:35 -08002487 $short = 0 if ($line =~ /\bcommit\s+[0-9a-f]{12,40}/i);
2488 $long = 1 if ($line =~ /\bcommit\s+[0-9a-f]{41,}/i);
2489 $space = 0 if ($line =~ /\bcommit [0-9a-f]/i);
2490 $case = 0 if ($line =~ /\b[Cc]ommit\s+[0-9a-f]{5,40}[^A-F]/);
2491 if ($line =~ /\bcommit\s+[0-9a-f]{5,}\s+\("([^"]+)"\)/i) {
2492 $orig_desc = $1;
Joe Perches19c146a2015-02-13 14:39:00 -08002493 $hasparens = 1;
Joe Perches0d7835f2015-02-13 14:38:35 -08002494 } elsif ($line =~ /\bcommit\s+[0-9a-f]{5,}\s*$/i &&
2495 defined $rawlines[$linenr] &&
2496 $rawlines[$linenr] =~ /^\s*\("([^"]+)"\)/) {
2497 $orig_desc = $1;
Joe Perches19c146a2015-02-13 14:39:00 -08002498 $hasparens = 1;
Joe Perchesb671fde2015-02-13 14:38:41 -08002499 } elsif ($line =~ /\bcommit\s+[0-9a-f]{5,}\s+\("[^"]+$/i &&
2500 defined $rawlines[$linenr] &&
2501 $rawlines[$linenr] =~ /^\s*[^"]+"\)/) {
2502 $line =~ /\bcommit\s+[0-9a-f]{5,}\s+\("([^"]+)$/i;
2503 $orig_desc = $1;
2504 $rawlines[$linenr] =~ /^\s*([^"]+)"\)/;
2505 $orig_desc .= " " . $1;
Joe Perches19c146a2015-02-13 14:39:00 -08002506 $hasparens = 1;
Joe Perches0d7835f2015-02-13 14:38:35 -08002507 }
2508
2509 ($id, $description) = git_commit_info($orig_commit,
2510 $id, $orig_desc);
2511
Joe Perches19c146a2015-02-13 14:39:00 -08002512 if ($short || $long || $space || $case || ($orig_desc ne $description) || !$hasparens) {
Joe Perches0d7835f2015-02-13 14:38:35 -08002513 ERROR("GIT_COMMIT_ID",
2514 "Please use git commit description style 'commit <12+ chars of sha1> (\"<title line>\")' - ie: '${init_char}ommit $id (\"$description\")'\n" . $herecurr);
2515 }
Joe Perchesd311cd42014-08-06 16:10:57 -07002516 }
2517
Joe Perches13f19372014-08-06 16:10:59 -07002518# Check for added, moved or deleted files
2519 if (!$reported_maintainer_file && !$in_commit_log &&
2520 ($line =~ /^(?:new|deleted) file mode\s*\d+\s*$/ ||
2521 $line =~ /^rename (?:from|to) [\w\/\.\-]+\s*$/ ||
2522 ($line =~ /\{\s*([\w\/\.\-]*)\s*\=\>\s*([\w\/\.\-]*)\s*\}/ &&
2523 (defined($1) || defined($2))))) {
2524 $reported_maintainer_file = 1;
2525 WARN("FILE_PATH_CHANGES",
2526 "added, moved or deleted file(s), does MAINTAINERS need updating?\n" . $herecurr);
2527 }
2528
Andy Whitcroft00df3442007-06-08 13:47:06 -07002529# Check for wrappage within a valid hunk of the file
Andy Whitcroft8905a672007-11-28 16:21:06 -08002530 if ($realcnt != 0 && $line !~ m{^(?:\+|-| |\\ No newline|$)}) {
Joe Perches000d1cc12011-07-25 17:13:25 -07002531 ERROR("CORRUPTED_PATCH",
2532 "patch seems to be corrupt (line wrapped?)\n" .
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07002533 $herecurr) if (!$emitted_corrupt++);
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07002534 }
2535
Andy Whitcroft6ecd9672008-10-15 22:02:21 -07002536# Check for absolute kernel paths.
2537 if ($tree) {
2538 while ($line =~ m{(?:^|\s)(/\S*)}g) {
2539 my $file = $1;
2540
2541 if ($file =~ m{^(.*?)(?::\d+)+:?$} &&
2542 check_absolute_file($1, $herecurr)) {
2543 #
2544 } else {
2545 check_absolute_file($file, $herecurr);
2546 }
2547 }
2548 }
2549
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07002550# UTF-8 regex found at http://www.w3.org/International/questions/qa-forms-utf-8.en.php
2551 if (($realfile =~ /^$/ || $line =~ /^\+/) &&
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07002552 $rawline !~ m/^$UTF8*$/) {
2553 my ($utf8_prefix) = ($rawline =~ /^($UTF8*)/);
2554
2555 my $blank = copy_spacing($rawline);
2556 my $ptr = substr($blank, 0, length($utf8_prefix)) . "^";
2557 my $hereptr = "$hereline$ptr\n";
2558
Joe Perches34d99212011-07-25 17:13:26 -07002559 CHK("INVALID_UTF8",
2560 "Invalid UTF-8, patch and commit message should be encoded in UTF-8\n" . $hereptr);
Andy Whitcroft00df3442007-06-08 13:47:06 -07002561 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002562
Joe Perches15662b32011-10-31 17:13:12 -07002563# Check if it's the start of a commit log
2564# (not a header line and we haven't seen the patch filename)
2565 if ($in_header_lines && $realfile =~ /^$/ &&
Joe Perches29ee1b02014-08-06 16:10:35 -07002566 !($rawline =~ /^\s+\S/ ||
2567 $rawline =~ /^(commit\b|from\b|[\w-]+:).*$/i)) {
Joe Perches15662b32011-10-31 17:13:12 -07002568 $in_header_lines = 0;
2569 $in_commit_log = 1;
Allen Hubbeed43c4e2016-08-02 14:04:45 -07002570 $has_commit_log = 1;
Joe Perches15662b32011-10-31 17:13:12 -07002571 }
2572
Pasi Savanainenfa64205d2012-10-04 17:13:29 -07002573# Check if there is UTF-8 in a commit log when a mail header has explicitly
2574# declined it, i.e defined some charset where it is missing.
2575 if ($in_header_lines &&
2576 $rawline =~ /^Content-Type:.+charset="(.+)".*$/ &&
2577 $1 !~ /utf-8/i) {
2578 $non_utf8_charset = 1;
2579 }
2580
2581 if ($in_commit_log && $non_utf8_charset && $realfile =~ /^$/ &&
Joe Perches15662b32011-10-31 17:13:12 -07002582 $rawline =~ /$NON_ASCII_UTF8/) {
Pasi Savanainenfa64205d2012-10-04 17:13:29 -07002583 WARN("UTF8_BEFORE_PATCH",
Joe Perches15662b32011-10-31 17:13:12 -07002584 "8-bit UTF-8 used in possible commit log\n" . $herecurr);
2585 }
2586
Kees Cook66b47b42014-10-13 15:51:57 -07002587# Check for various typo / spelling mistakes
Joe Perches66d7a382015-04-16 12:44:08 -07002588 if (defined($misspellings) &&
2589 ($in_commit_log || $line =~ /^(?:\+|Subject:)/i)) {
Joe Perchesebfd7d62015-04-16 12:44:14 -07002590 while ($rawline =~ /(?:^|[^a-z@])($misspellings)(?:\b|$|[^a-z@])/gi) {
Kees Cook66b47b42014-10-13 15:51:57 -07002591 my $typo = $1;
2592 my $typo_fix = $spelling_fix{lc($typo)};
2593 $typo_fix = ucfirst($typo_fix) if ($typo =~ /^[A-Z]/);
2594 $typo_fix = uc($typo_fix) if ($typo =~ /^[A-Z]+$/);
2595 my $msg_type = \&WARN;
2596 $msg_type = \&CHK if ($file);
2597 if (&{$msg_type}("TYPO_SPELLING",
2598 "'$typo' may be misspelled - perhaps '$typo_fix'?\n" . $herecurr) &&
2599 $fix) {
2600 $fixed[$fixlinenr] =~ s/(^|[^A-Za-z@])($typo)($|[^A-Za-z@])/$1$typo_fix$3/;
2601 }
2602 }
2603 }
2604
Andy Whitcroft306708542008-10-15 22:02:28 -07002605# ignore non-hunk lines and lines being removed
2606 next if (!$hunk_line || $line =~ /^-/);
Andy Whitcroft00df3442007-06-08 13:47:06 -07002607
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002608#trailing whitespace
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07002609 if ($line =~ /^\+.*\015/) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002610 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
Joe Perchesd5e616f2013-09-11 14:23:54 -07002611 if (ERROR("DOS_LINE_ENDINGS",
2612 "DOS line endings\n" . $herevet) &&
2613 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07002614 $fixed[$fixlinenr] =~ s/[\s\015]+$//;
Joe Perchesd5e616f2013-09-11 14:23:54 -07002615 }
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002616 } elsif ($rawline =~ /^\+.*\S\s+$/ || $rawline =~ /^\+\s+$/) {
2617 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
Joe Perches3705ce52013-07-03 15:05:31 -07002618 if (ERROR("TRAILING_WHITESPACE",
2619 "trailing whitespace\n" . $herevet) &&
2620 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07002621 $fixed[$fixlinenr] =~ s/\s+$//;
Joe Perches3705ce52013-07-03 15:05:31 -07002622 }
2623
Andy Whitcroftd2c0a232010-10-26 14:23:12 -07002624 $rpt_cleaners = 1;
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002625 }
Andy Whitcroft5368df22008-10-15 22:02:27 -07002626
Josh Triplett4783f892013-11-12 15:10:12 -08002627# Check for FSF mailing addresses.
Alexander Duyck109d8cb2014-01-23 15:54:50 -08002628 if ($rawline =~ /\bwrite to the Free/i ||
Joe Perches3e2232f2014-01-23 15:54:48 -08002629 $rawline =~ /\b59\s+Temple\s+Pl/i ||
2630 $rawline =~ /\b51\s+Franklin\s+St/i) {
Josh Triplett4783f892013-11-12 15:10:12 -08002631 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2632 my $msg_type = \&ERROR;
2633 $msg_type = \&CHK if ($file);
2634 &{$msg_type}("FSF_MAILING_ADDRESS",
Joe Perches3e2232f2014-01-23 15:54:48 -08002635 "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)
Josh Triplett4783f892013-11-12 15:10:12 -08002636 }
2637
Andi Kleen33549572010-05-24 14:33:29 -07002638# check for Kconfig help text having a real description
Andy Whitcroft9fe287d72010-10-26 14:23:15 -07002639# Only applies when adding the entry originally, after that we do not have
2640# sufficient context to determine whether it is indeed long enough.
Andi Kleen33549572010-05-24 14:33:29 -07002641 if ($realfile =~ /Kconfig/ &&
Joe Perches8d73e0e2014-08-06 16:10:46 -07002642 $line =~ /^\+\s*config\s+/) {
Andi Kleen33549572010-05-24 14:33:29 -07002643 my $length = 0;
Andy Whitcroft9fe287d72010-10-26 14:23:15 -07002644 my $cnt = $realcnt;
2645 my $ln = $linenr + 1;
2646 my $f;
Andy Whitcrofta1385802012-01-10 15:10:03 -08002647 my $is_start = 0;
Andy Whitcroft9fe287d72010-10-26 14:23:15 -07002648 my $is_end = 0;
Andy Whitcrofta1385802012-01-10 15:10:03 -08002649 for (; $cnt > 0 && defined $lines[$ln - 1]; $ln++) {
Andy Whitcroft9fe287d72010-10-26 14:23:15 -07002650 $f = $lines[$ln - 1];
2651 $cnt-- if ($lines[$ln - 1] !~ /^-/);
2652 $is_end = $lines[$ln - 1] =~ /^\+/;
Andy Whitcroft9fe287d72010-10-26 14:23:15 -07002653
2654 next if ($f =~ /^-/);
Joe Perches8d73e0e2014-08-06 16:10:46 -07002655 last if (!$file && $f =~ /^\@\@/);
Andy Whitcrofta1385802012-01-10 15:10:03 -08002656
Joe Perches8d73e0e2014-08-06 16:10:46 -07002657 if ($lines[$ln - 1] =~ /^\+\s*(?:bool|tristate)\s*\"/) {
Andy Whitcrofta1385802012-01-10 15:10:03 -08002658 $is_start = 1;
Joe Perches8d73e0e2014-08-06 16:10:46 -07002659 } elsif ($lines[$ln - 1] =~ /^\+\s*(?:---)?help(?:---)?$/) {
Andy Whitcrofta1385802012-01-10 15:10:03 -08002660 $length = -1;
2661 }
2662
Andy Whitcroft9fe287d72010-10-26 14:23:15 -07002663 $f =~ s/^.//;
Andi Kleen33549572010-05-24 14:33:29 -07002664 $f =~ s/#.*//;
2665 $f =~ s/^\s+//;
2666 next if ($f =~ /^$/);
Andy Whitcroft9fe287d72010-10-26 14:23:15 -07002667 if ($f =~ /^\s*config\s/) {
2668 $is_end = 1;
2669 last;
2670 }
Andi Kleen33549572010-05-24 14:33:29 -07002671 $length++;
2672 }
Vadim Bendebury56193272014-10-13 15:51:48 -07002673 if ($is_start && $is_end && $length < $min_conf_desc_length) {
2674 WARN("CONFIG_DESCRIPTION",
2675 "please write a paragraph that describes the config symbol fully\n" . $herecurr);
2676 }
Andy Whitcrofta1385802012-01-10 15:10:03 -08002677 #print "is_start<$is_start> is_end<$is_end> length<$length>\n";
Andi Kleen33549572010-05-24 14:33:29 -07002678 }
2679
Kees Cook1ba8dfd2012-12-17 16:01:48 -08002680# discourage the addition of CONFIG_EXPERIMENTAL in Kconfig.
2681 if ($realfile =~ /Kconfig/ &&
2682 $line =~ /.\s*depends on\s+.*\bEXPERIMENTAL\b/) {
2683 WARN("CONFIG_EXPERIMENTAL",
2684 "Use of CONFIG_EXPERIMENTAL is deprecated. For alternatives, see https://lkml.org/lkml/2012/10/23/580\n");
2685 }
2686
Christoph Jaeger327953e2015-02-13 14:38:29 -08002687# discourage the use of boolean for type definition attributes of Kconfig options
2688 if ($realfile =~ /Kconfig/ &&
2689 $line =~ /^\+\s*\bboolean\b/) {
2690 WARN("CONFIG_TYPE_BOOLEAN",
2691 "Use of boolean is deprecated, please use bool instead.\n" . $herecurr);
2692 }
2693
Arnaud Lacombec68e5872011-08-15 01:07:14 -04002694 if (($realfile =~ /Makefile.*/ || $realfile =~ /Kbuild.*/) &&
2695 ($line =~ /\+(EXTRA_[A-Z]+FLAGS).*/)) {
2696 my $flag = $1;
2697 my $replacement = {
2698 'EXTRA_AFLAGS' => 'asflags-y',
2699 'EXTRA_CFLAGS' => 'ccflags-y',
2700 'EXTRA_CPPFLAGS' => 'cppflags-y',
2701 'EXTRA_LDFLAGS' => 'ldflags-y',
2702 };
2703
2704 WARN("DEPRECATED_VARIABLE",
2705 "Use of $flag is deprecated, please use \`$replacement->{$flag} instead.\n" . $herecurr) if ($replacement->{$flag});
2706 }
2707
Rob Herringbff5da42014-01-23 15:54:51 -08002708# check for DT compatible documentation
Florian Vaussard7dd05b32014-04-03 14:49:26 -07002709 if (defined $root &&
2710 (($realfile =~ /\.dtsi?$/ && $line =~ /^\+\s*compatible\s*=\s*\"/) ||
2711 ($realfile =~ /\.[ch]$/ && $line =~ /^\+.*\.compatible\s*=\s*\"/))) {
2712
Rob Herringbff5da42014-01-23 15:54:51 -08002713 my @compats = $rawline =~ /\"([a-zA-Z0-9\-\,\.\+_]+)\"/g;
2714
Florian Vaussardcc933192014-04-03 14:49:27 -07002715 my $dt_path = $root . "/Documentation/devicetree/bindings/";
2716 my $vp_file = $dt_path . "vendor-prefixes.txt";
2717
Rob Herringbff5da42014-01-23 15:54:51 -08002718 foreach my $compat (@compats) {
2719 my $compat2 = $compat;
Rob Herring185d5662014-06-04 16:12:03 -07002720 $compat2 =~ s/\,[a-zA-Z0-9]*\-/\,<\.\*>\-/;
2721 my $compat3 = $compat;
2722 $compat3 =~ s/\,([a-z]*)[0-9]*\-/\,$1<\.\*>\-/;
2723 `grep -Erq "$compat|$compat2|$compat3" $dt_path`;
Rob Herringbff5da42014-01-23 15:54:51 -08002724 if ( $? >> 8 ) {
2725 WARN("UNDOCUMENTED_DT_STRING",
2726 "DT compatible string \"$compat\" appears un-documented -- check $dt_path\n" . $herecurr);
2727 }
2728
Florian Vaussard4fbf32a2014-04-03 14:49:25 -07002729 next if $compat !~ /^([a-zA-Z0-9\-]+)\,/;
2730 my $vendor = $1;
Florian Vaussardcc933192014-04-03 14:49:27 -07002731 `grep -Eq "^$vendor\\b" $vp_file`;
Rob Herringbff5da42014-01-23 15:54:51 -08002732 if ( $? >> 8 ) {
2733 WARN("UNDOCUMENTED_DT_STRING",
Florian Vaussardcc933192014-04-03 14:49:27 -07002734 "DT compatible string vendor \"$vendor\" appears un-documented -- check $vp_file\n" . $herecurr);
Rob Herringbff5da42014-01-23 15:54:51 -08002735 }
2736 }
2737 }
2738
Andy Whitcroft5368df22008-10-15 22:02:27 -07002739# check we are in a valid source file if not then ignore this hunk
Geert Uytterhoevende4c9242014-10-13 15:51:46 -07002740 next if ($realfile !~ /\.(h|c|s|S|pl|sh|dtsi|dts)$/);
Andy Whitcroft5368df22008-10-15 22:02:27 -07002741
Joe Perches47e0c882015-06-25 15:02:57 -07002742# line length limit (with some exclusions)
2743#
2744# There are a few types of lines that may extend beyond $max_line_length:
2745# logging functions like pr_info that end in a string
2746# lines with a single string
2747# #defines that are a single string
2748#
2749# There are 3 different line length message types:
2750# LONG_LINE_COMMENT a comment starts before but extends beyond $max_linelength
2751# LONG_LINE_STRING a string starts before but extends beyond $max_line_length
2752# LONG_LINE all other lines longer than $max_line_length
2753#
2754# if LONG_LINE is ignored, the other 2 types are also ignored
2755#
2756
Joe Perchesb4749e92015-07-17 16:24:01 -07002757 if ($line =~ /^\+/ && $length > $max_line_length) {
Joe Perches47e0c882015-06-25 15:02:57 -07002758 my $msg_type = "LONG_LINE";
2759
2760 # Check the allowed long line types first
2761
2762 # logging functions that end in a string that starts
2763 # before $max_line_length
2764 if ($line =~ /^\+\s*$logFunctions\s*\(\s*(?:(?:KERN_\S+\s*|[^"]*))?($String\s*(?:|,|\)\s*;)\s*)$/ &&
2765 length(expand_tabs(substr($line, 1, length($line) - length($1) - 1))) <= $max_line_length) {
2766 $msg_type = "";
2767
2768 # lines with only strings (w/ possible termination)
2769 # #defines with only strings
2770 } elsif ($line =~ /^\+\s*$String\s*(?:\s*|,|\)\s*;)\s*$/ ||
2771 $line =~ /^\+\s*#\s*define\s+\w+\s+$String$/) {
2772 $msg_type = "";
2773
Joe Perchesd560a5f2016-08-02 14:04:31 -07002774 # EFI_GUID is another special case
2775 } elsif ($line =~ /^\+.*\bEFI_GUID\s*\(/) {
2776 $msg_type = "";
2777
Joe Perches47e0c882015-06-25 15:02:57 -07002778 # Otherwise set the alternate message types
2779
2780 # a comment starts before $max_line_length
2781 } elsif ($line =~ /($;[\s$;]*)$/ &&
2782 length(expand_tabs(substr($line, 1, length($line) - length($1) - 1))) <= $max_line_length) {
2783 $msg_type = "LONG_LINE_COMMENT"
2784
2785 # a quoted string starts before $max_line_length
2786 } elsif ($sline =~ /\s*($String(?:\s*(?:\\|,\s*|\)\s*;\s*))?)$/ &&
2787 length(expand_tabs(substr($line, 1, length($line) - length($1) - 1))) <= $max_line_length) {
2788 $msg_type = "LONG_LINE_STRING"
2789 }
2790
2791 if ($msg_type ne "" &&
2792 (show_type("LONG_LINE") || show_type($msg_type))) {
2793 WARN($msg_type,
2794 "line over $max_line_length characters\n" . $herecurr);
2795 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002796 }
2797
Andy Whitcroft8905a672007-11-28 16:21:06 -08002798# check for adding lines without a newline.
2799 if ($line =~ /^\+/ && defined $lines[$linenr] && $lines[$linenr] =~ /^\\ No newline at end of file/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07002800 WARN("MISSING_EOF_NEWLINE",
2801 "adding a line without newline at end of file\n" . $herecurr);
Andy Whitcroft8905a672007-11-28 16:21:06 -08002802 }
2803
Mike Frysinger42e41c52009-09-21 17:04:40 -07002804# Blackfin: use hi/lo macros
2805 if ($realfile =~ m@arch/blackfin/.*\.S$@) {
2806 if ($line =~ /\.[lL][[:space:]]*=.*&[[:space:]]*0x[fF][fF][fF][fF]/) {
2807 my $herevet = "$here\n" . cat_vet($line) . "\n";
Joe Perches000d1cc12011-07-25 17:13:25 -07002808 ERROR("LO_MACRO",
2809 "use the LO() macro, not (... & 0xFFFF)\n" . $herevet);
Mike Frysinger42e41c52009-09-21 17:04:40 -07002810 }
2811 if ($line =~ /\.[hH][[:space:]]*=.*>>[[:space:]]*16/) {
2812 my $herevet = "$here\n" . cat_vet($line) . "\n";
Joe Perches000d1cc12011-07-25 17:13:25 -07002813 ERROR("HI_MACRO",
2814 "use the HI() macro, not (... >> 16)\n" . $herevet);
Mike Frysinger42e41c52009-09-21 17:04:40 -07002815 }
2816 }
2817
Andy Whitcroftb9ea10d2008-10-15 22:02:24 -07002818# check we are in a valid source file C or perl if not then ignore this hunk
Geert Uytterhoevende4c9242014-10-13 15:51:46 -07002819 next if ($realfile !~ /\.(h|c|pl|dtsi|dts)$/);
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002820
2821# at the beginning of a line any tabs must come first and anything
2822# more than 8 must use tabs.
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002823 if ($rawline =~ /^\+\s* \t\s*\S/ ||
2824 $rawline =~ /^\+\s* \s*/) {
2825 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
Andy Whitcroftd2c0a232010-10-26 14:23:12 -07002826 $rpt_cleaners = 1;
Joe Perches3705ce52013-07-03 15:05:31 -07002827 if (ERROR("CODE_INDENT",
2828 "code indent should use tabs where possible\n" . $herevet) &&
2829 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07002830 $fixed[$fixlinenr] =~ s/^\+([ \t]+)/"\+" . tabify($1)/e;
Joe Perches3705ce52013-07-03 15:05:31 -07002831 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002832 }
2833
Alberto Panizzo08e44362010-03-05 13:43:54 -08002834# check for space before tabs.
2835 if ($rawline =~ /^\+/ && $rawline =~ / \t/) {
2836 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
Joe Perches3705ce52013-07-03 15:05:31 -07002837 if (WARN("SPACE_BEFORE_TAB",
2838 "please, no space before tabs\n" . $herevet) &&
2839 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07002840 while ($fixed[$fixlinenr] =~
Joe Perchesd2207cc2014-10-13 15:51:53 -07002841 s/(^\+.*) {8,8}\t/$1\t\t/) {}
Joe Perches194f66f2014-08-06 16:11:03 -07002842 while ($fixed[$fixlinenr] =~
Joe Perchesc76f4cb2014-01-23 15:54:46 -08002843 s/(^\+.*) +\t/$1\t/) {}
Joe Perches3705ce52013-07-03 15:05:31 -07002844 }
Alberto Panizzo08e44362010-03-05 13:43:54 -08002845 }
2846
Joe Perchesd1fe9c02012-03-23 15:02:16 -07002847# check for && or || at the start of a line
2848 if ($rawline =~ /^\+\s*(&&|\|\|)/) {
2849 CHK("LOGICAL_CONTINUATIONS",
2850 "Logical continuations should be on the previous line\n" . $hereprev);
2851 }
2852
Joe Perchesa91e8992016-05-20 17:04:05 -07002853# check indentation starts on a tab stop
2854 if ($^V && $^V ge 5.10.0 &&
2855 $sline =~ /^\+\t+( +)(?:$c90_Keywords\b|\{\s*$|\}\s*(?:else\b|while\b|\s*$))/) {
2856 my $indent = length($1);
2857 if ($indent % 8) {
2858 if (WARN("TABSTOP",
2859 "Statements should start on a tabstop\n" . $herecurr) &&
2860 $fix) {
2861 $fixed[$fixlinenr] =~ s@(^\+\t+) +@$1 . "\t" x ($indent/8)@e;
2862 }
2863 }
2864 }
2865
Joe Perchesd1fe9c02012-03-23 15:02:16 -07002866# check multi-line statement indentation matches previous line
2867 if ($^V && $^V ge 5.10.0 &&
Joe Perches91cb5192014-04-03 14:49:32 -07002868 $prevline =~ /^\+([ \t]*)((?:$c90_Keywords(?:\s+if)\s*)|(?:$Declare\s*)?(?:$Ident|\(\s*\*\s*$Ident\s*\))\s*|$Ident\s*=\s*$Ident\s*)\(.*(\&\&|\|\||,)\s*$/) {
Joe Perchesd1fe9c02012-03-23 15:02:16 -07002869 $prevline =~ /^\+(\t*)(.*)$/;
2870 my $oldindent = $1;
2871 my $rest = $2;
2872
2873 my $pos = pos_last_openparen($rest);
2874 if ($pos >= 0) {
Joe Perchesb34a26f2012-07-30 14:41:16 -07002875 $line =~ /^(\+| )([ \t]*)/;
2876 my $newindent = $2;
Joe Perchesd1fe9c02012-03-23 15:02:16 -07002877
2878 my $goodtabindent = $oldindent .
2879 "\t" x ($pos / 8) .
2880 " " x ($pos % 8);
2881 my $goodspaceindent = $oldindent . " " x $pos;
2882
2883 if ($newindent ne $goodtabindent &&
2884 $newindent ne $goodspaceindent) {
Joe Perches3705ce52013-07-03 15:05:31 -07002885
2886 if (CHK("PARENTHESIS_ALIGNMENT",
2887 "Alignment should match open parenthesis\n" . $hereprev) &&
2888 $fix && $line =~ /^\+/) {
Joe Perches194f66f2014-08-06 16:11:03 -07002889 $fixed[$fixlinenr] =~
Joe Perches3705ce52013-07-03 15:05:31 -07002890 s/^\+[ \t]*/\+$goodtabindent/;
2891 }
Joe Perchesd1fe9c02012-03-23 15:02:16 -07002892 }
2893 }
2894 }
2895
Joe Perches6ab3a972015-04-16 12:44:05 -07002896# check for space after cast like "(int) foo" or "(struct foo) bar"
2897# avoid checking a few false positives:
2898# "sizeof(<type>)" or "__alignof__(<type>)"
2899# function pointer declarations like "(*foo)(int) = bar;"
2900# structure definitions like "(struct foo) { 0 };"
2901# multiline macros that define functions
2902# known attributes or the __attribute__ keyword
2903 if ($line =~ /^\+(.*)\(\s*$Type\s*\)([ \t]++)((?![={]|\\$|$Attribute|__attribute__))/ &&
2904 (!defined($1) || $1 !~ /\b(?:sizeof|__alignof__)\s*$/)) {
Joe Perches3705ce52013-07-03 15:05:31 -07002905 if (CHK("SPACING",
Joe Perchesf27c95d2014-08-06 16:10:52 -07002906 "No space is necessary after a cast\n" . $herecurr) &&
Joe Perches3705ce52013-07-03 15:05:31 -07002907 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07002908 $fixed[$fixlinenr] =~
Joe Perchesf27c95d2014-08-06 16:10:52 -07002909 s/(\(\s*$Type\s*\))[ \t]+/$1/;
Joe Perches3705ce52013-07-03 15:05:31 -07002910 }
Joe Perchesaad4f612012-03-23 15:02:19 -07002911 }
2912
Joe Perches86406b12015-09-09 15:37:41 -07002913# Block comment styles
2914# Networking with an initial /*
Joe Perches05880602012-10-04 17:13:35 -07002915 if ($realfile =~ m@^(drivers/net/|net/)@ &&
Joe Perchesfdb4bcd2013-07-03 15:05:23 -07002916 $prevrawline =~ /^\+[ \t]*\/\*[ \t]*$/ &&
Joe Perches85ad9782014-04-03 14:49:20 -07002917 $rawline =~ /^\+[ \t]*\*/ &&
2918 $realline > 2) {
Joe Perches05880602012-10-04 17:13:35 -07002919 WARN("NETWORKING_BLOCK_COMMENT_STYLE",
2920 "networking block comments don't use an empty /* line, use /* Comment...\n" . $hereprev);
2921 }
2922
Joe Perches86406b12015-09-09 15:37:41 -07002923# Block comments use * on subsequent lines
2924 if ($prevline =~ /$;[ \t]*$/ && #ends in comment
2925 $prevrawline =~ /^\+.*?\/\*/ && #starting /*
Joe Perchesa605e322013-07-03 15:05:24 -07002926 $prevrawline !~ /\*\/[ \t]*$/ && #no trailing */
Joe Perches61135e92013-09-11 14:23:59 -07002927 $rawline =~ /^\+/ && #line is new
Joe Perchesa605e322013-07-03 15:05:24 -07002928 $rawline !~ /^\+[ \t]*\*/) { #no leading *
Joe Perches86406b12015-09-09 15:37:41 -07002929 WARN("BLOCK_COMMENT_STYLE",
2930 "Block comments use * on subsequent lines\n" . $hereprev);
Joe Perchesa605e322013-07-03 15:05:24 -07002931 }
2932
Joe Perches86406b12015-09-09 15:37:41 -07002933# Block comments use */ on trailing lines
2934 if ($rawline !~ m@^\+[ \t]*\*/[ \t]*$@ && #trailing */
Joe Perchesc24f9f12012-11-08 15:53:29 -08002935 $rawline !~ m@^\+.*/\*.*\*/[ \t]*$@ && #inline /*...*/
2936 $rawline !~ m@^\+.*\*{2,}/[ \t]*$@ && #trailing **/
2937 $rawline =~ m@^\+[ \t]*.+\*\/[ \t]*$@) { #non blank */
Joe Perches86406b12015-09-09 15:37:41 -07002938 WARN("BLOCK_COMMENT_STYLE",
2939 "Block comments use a trailing */ on a separate line\n" . $herecurr);
Joe Perches05880602012-10-04 17:13:35 -07002940 }
2941
Joe Perches7f619192014-08-06 16:10:39 -07002942# check for missing blank lines after struct/union declarations
2943# with exceptions for various attributes and macros
2944 if ($prevline =~ /^[\+ ]};?\s*$/ &&
2945 $line =~ /^\+/ &&
2946 !($line =~ /^\+\s*$/ ||
2947 $line =~ /^\+\s*EXPORT_SYMBOL/ ||
2948 $line =~ /^\+\s*MODULE_/i ||
2949 $line =~ /^\+\s*\#\s*(?:end|elif|else)/ ||
2950 $line =~ /^\+[a-z_]*init/ ||
2951 $line =~ /^\+\s*(?:static\s+)?[A-Z_]*ATTR/ ||
2952 $line =~ /^\+\s*DECLARE/ ||
2953 $line =~ /^\+\s*__setup/)) {
Joe Perchesd752fcc2014-08-06 16:11:05 -07002954 if (CHK("LINE_SPACING",
2955 "Please use a blank line after function/struct/union/enum declarations\n" . $hereprev) &&
2956 $fix) {
Joe Perchesf2d7e4d2014-08-06 16:11:07 -07002957 fix_insert_line($fixlinenr, "\+");
Joe Perchesd752fcc2014-08-06 16:11:05 -07002958 }
Joe Perches7f619192014-08-06 16:10:39 -07002959 }
2960
Joe Perches365dd4e2014-08-06 16:10:42 -07002961# check for multiple consecutive blank lines
2962 if ($prevline =~ /^[\+ ]\s*$/ &&
2963 $line =~ /^\+\s*$/ &&
2964 $last_blank_line != ($linenr - 1)) {
Joe Perchesd752fcc2014-08-06 16:11:05 -07002965 if (CHK("LINE_SPACING",
2966 "Please don't use multiple blank lines\n" . $hereprev) &&
2967 $fix) {
Joe Perchesf2d7e4d2014-08-06 16:11:07 -07002968 fix_delete_line($fixlinenr, $rawline);
Joe Perchesd752fcc2014-08-06 16:11:05 -07002969 }
2970
Joe Perches365dd4e2014-08-06 16:10:42 -07002971 $last_blank_line = $linenr;
2972 }
2973
Joe Perches3b617e32014-04-03 14:49:28 -07002974# check for missing blank lines after declarations
Joe Perches3f7bac02014-06-04 16:12:04 -07002975 if ($sline =~ /^\+\s+\S/ && #Not at char 1
2976 # actual declarations
2977 ($prevline =~ /^\+\s+$Declare\s*$Ident\s*[=,;:\[]/ ||
Joe Perches5a4e1fd2014-08-06 16:10:33 -07002978 # function pointer declarations
2979 $prevline =~ /^\+\s+$Declare\s*\(\s*\*\s*$Ident\s*\)\s*[=,;:\[\(]/ ||
Joe Perches3f7bac02014-06-04 16:12:04 -07002980 # foo bar; where foo is some local typedef or #define
2981 $prevline =~ /^\+\s+$Ident(?:\s+|\s*\*\s*)$Ident\s*[=,;\[]/ ||
2982 # known declaration macros
2983 $prevline =~ /^\+\s+$declaration_macros/) &&
2984 # for "else if" which can look like "$Ident $Ident"
2985 !($prevline =~ /^\+\s+$c90_Keywords\b/ ||
2986 # other possible extensions of declaration lines
2987 $prevline =~ /(?:$Compare|$Assignment|$Operators)\s*$/ ||
2988 # not starting a section or a macro "\" extended line
2989 $prevline =~ /(?:\{\s*|\\)$/) &&
2990 # looks like a declaration
2991 !($sline =~ /^\+\s+$Declare\s*$Ident\s*[=,;:\[]/ ||
Joe Perches5a4e1fd2014-08-06 16:10:33 -07002992 # function pointer declarations
2993 $sline =~ /^\+\s+$Declare\s*\(\s*\*\s*$Ident\s*\)\s*[=,;:\[\(]/ ||
Joe Perches3f7bac02014-06-04 16:12:04 -07002994 # foo bar; where foo is some local typedef or #define
2995 $sline =~ /^\+\s+$Ident(?:\s+|\s*\*\s*)$Ident\s*[=,;\[]/ ||
2996 # known declaration macros
2997 $sline =~ /^\+\s+$declaration_macros/ ||
2998 # start of struct or union or enum
Joe Perches3b617e32014-04-03 14:49:28 -07002999 $sline =~ /^\+\s+(?:union|struct|enum|typedef)\b/ ||
Joe Perches3f7bac02014-06-04 16:12:04 -07003000 # start or end of block or continuation of declaration
3001 $sline =~ /^\+\s+(?:$|[\{\}\.\#\"\?\:\(\[])/ ||
3002 # bitfield continuation
3003 $sline =~ /^\+\s+$Ident\s*:\s*\d+\s*[,;]/ ||
3004 # other possible extensions of declaration lines
3005 $sline =~ /^\+\s+\(?\s*(?:$Compare|$Assignment|$Operators)/) &&
3006 # indentation of previous and current line are the same
3007 (($prevline =~ /\+(\s+)\S/) && $sline =~ /^\+$1\S/)) {
Joe Perchesd752fcc2014-08-06 16:11:05 -07003008 if (WARN("LINE_SPACING",
3009 "Missing a blank line after declarations\n" . $hereprev) &&
3010 $fix) {
Joe Perchesf2d7e4d2014-08-06 16:11:07 -07003011 fix_insert_line($fixlinenr, "\+");
Joe Perchesd752fcc2014-08-06 16:11:05 -07003012 }
Joe Perches3b617e32014-04-03 14:49:28 -07003013 }
3014
Raffaele Recalcati5f7ddae2010-08-09 17:20:59 -07003015# check for spaces at the beginning of a line.
Andy Whitcroft6b4c5be2010-10-26 14:23:11 -07003016# Exceptions:
3017# 1) within comments
3018# 2) indented preprocessor commands
3019# 3) hanging labels
Joe Perches3705ce52013-07-03 15:05:31 -07003020 if ($rawline =~ /^\+ / && $line !~ /^\+ *(?:$;|#|$Ident:)/) {
Raffaele Recalcati5f7ddae2010-08-09 17:20:59 -07003021 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
Joe Perches3705ce52013-07-03 15:05:31 -07003022 if (WARN("LEADING_SPACE",
3023 "please, no spaces at the start of a line\n" . $herevet) &&
3024 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07003025 $fixed[$fixlinenr] =~ s/^\+([ \t]+)/"\+" . tabify($1)/e;
Joe Perches3705ce52013-07-03 15:05:31 -07003026 }
Raffaele Recalcati5f7ddae2010-08-09 17:20:59 -07003027 }
3028
Andy Whitcroftb9ea10d2008-10-15 22:02:24 -07003029# check we are in a valid C source file if not then ignore this hunk
3030 next if ($realfile !~ /\.(h|c)$/);
3031
Joe Perches032a4c02014-08-06 16:10:29 -07003032# check indentation of any line with a bare else
Joe Perches840080a2014-10-13 15:51:59 -07003033# (but not if it is a multiple line "if (foo) return bar; else return baz;")
Joe Perches032a4c02014-08-06 16:10:29 -07003034# if the previous line is a break or return and is indented 1 tab more...
3035 if ($sline =~ /^\+([\t]+)(?:}[ \t]*)?else(?:[ \t]*{)?\s*$/) {
3036 my $tabs = length($1) + 1;
Joe Perches840080a2014-10-13 15:51:59 -07003037 if ($prevline =~ /^\+\t{$tabs,$tabs}break\b/ ||
3038 ($prevline =~ /^\+\t{$tabs,$tabs}return\b/ &&
3039 defined $lines[$linenr] &&
3040 $lines[$linenr] !~ /^[ \+]\t{$tabs,$tabs}return/)) {
Joe Perches032a4c02014-08-06 16:10:29 -07003041 WARN("UNNECESSARY_ELSE",
3042 "else is not generally useful after a break or return\n" . $hereprev);
3043 }
3044 }
3045
Joe Perchesc00df192014-08-06 16:11:01 -07003046# check indentation of a line with a break;
3047# if the previous line is a goto or return and is indented the same # of tabs
3048 if ($sline =~ /^\+([\t]+)break\s*;\s*$/) {
3049 my $tabs = $1;
3050 if ($prevline =~ /^\+$tabs(?:goto|return)\b/) {
3051 WARN("UNNECESSARY_BREAK",
3052 "break is not useful after a goto or return\n" . $hereprev);
3053 }
3054 }
3055
Kees Cook1ba8dfd2012-12-17 16:01:48 -08003056# discourage the addition of CONFIG_EXPERIMENTAL in #if(def).
3057 if ($line =~ /^\+\s*\#\s*if.*\bCONFIG_EXPERIMENTAL\b/) {
3058 WARN("CONFIG_EXPERIMENTAL",
3059 "Use of CONFIG_EXPERIMENTAL is deprecated. For alternatives, see https://lkml.org/lkml/2012/10/23/580\n");
3060 }
3061
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08003062# check for RCS/CVS revision markers
Andy Whitcroftcf655042008-03-04 14:28:20 -08003063 if ($rawline =~ /^\+.*\$(Revision|Log|Id)(?:\$|)/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003064 WARN("CVS_KEYWORD",
3065 "CVS style keyword markers, these will _not_ be updated\n". $herecurr);
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08003066 }
Andy Whitcroft22f2a2e2007-08-10 13:01:03 -07003067
Mike Frysinger42e41c52009-09-21 17:04:40 -07003068# Blackfin: don't use __builtin_bfin_[cs]sync
3069 if ($line =~ /__builtin_bfin_csync/) {
3070 my $herevet = "$here\n" . cat_vet($line) . "\n";
Joe Perches000d1cc12011-07-25 17:13:25 -07003071 ERROR("CSYNC",
3072 "use the CSYNC() macro in asm/blackfin.h\n" . $herevet);
Mike Frysinger42e41c52009-09-21 17:04:40 -07003073 }
3074 if ($line =~ /__builtin_bfin_ssync/) {
3075 my $herevet = "$here\n" . cat_vet($line) . "\n";
Joe Perches000d1cc12011-07-25 17:13:25 -07003076 ERROR("SSYNC",
3077 "use the SSYNC() macro in asm/blackfin.h\n" . $herevet);
Mike Frysinger42e41c52009-09-21 17:04:40 -07003078 }
3079
Joe Perches56e77d72013-02-21 16:44:14 -08003080# check for old HOTPLUG __dev<foo> section markings
3081 if ($line =~ /\b(__dev(init|exit)(data|const|))\b/) {
3082 WARN("HOTPLUG_SECTION",
3083 "Using $1 is unnecessary\n" . $herecurr);
3084 }
3085
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07003086# Check for potential 'bare' types
Andy Whitcroft2b474a12009-10-26 16:50:16 -07003087 my ($stat, $cond, $line_nr_next, $remain_next, $off_next,
3088 $realline_next);
Andy Whitcroft3e469cd2012-01-10 15:10:01 -08003089#print "LINE<$line>\n";
3090 if ($linenr >= $suppress_statement &&
Joe Perches1b5539b2013-09-11 14:24:03 -07003091 $realcnt && $sline =~ /.\s*\S/) {
Andy Whitcroft170d3a22008-10-15 22:02:30 -07003092 ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
Andy Whitcroftf5fe35d2008-07-23 21:29:03 -07003093 ctx_statement_block($linenr, $realcnt, 0);
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07003094 $stat =~ s/\n./\n /g;
3095 $cond =~ s/\n./\n /g;
3096
Andy Whitcroft3e469cd2012-01-10 15:10:01 -08003097#print "linenr<$linenr> <$stat>\n";
3098 # If this statement has no statement boundaries within
3099 # it there is no point in retrying a statement scan
3100 # until we hit end of it.
3101 my $frag = $stat; $frag =~ s/;+\s*$//;
3102 if ($frag !~ /(?:{|;)/) {
3103#print "skip<$line_nr_next>\n";
3104 $suppress_statement = $line_nr_next;
3105 }
Andy Whitcroftf74bd192012-01-10 15:09:54 -08003106
Andy Whitcroft2b474a12009-10-26 16:50:16 -07003107 # Find the real next line.
3108 $realline_next = $line_nr_next;
3109 if (defined $realline_next &&
3110 (!defined $lines[$realline_next - 1] ||
3111 substr($lines[$realline_next - 1], $off_next) =~ /^\s*$/)) {
3112 $realline_next++;
3113 }
3114
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07003115 my $s = $stat;
3116 $s =~ s/{.*$//s;
Andy Whitcroftcf655042008-03-04 14:28:20 -08003117
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08003118 # Ignore goto labels.
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07003119 if ($s =~ /$Ident:\*$/s) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08003120
3121 # Ignore functions being called
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07003122 } elsif ($s =~ /^.\s*$Ident\s*\(/s) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08003123
Andy Whitcroft463f2862009-09-21 17:04:34 -07003124 } elsif ($s =~ /^.\s*else\b/s) {
3125
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07003126 # declarations always start with types
Andy Whitcroftd2506582008-07-23 21:29:09 -07003127 } 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) {
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07003128 my $type = $1;
3129 $type =~ s/\s+/ /g;
3130 possible($type, "A:" . $s);
3131
Andy Whitcroft8905a672007-11-28 16:21:06 -08003132 # definitions in global scope can only start with types
Andy Whitcrofta6a840622008-10-15 22:02:30 -07003133 } elsif ($s =~ /^.(?:$Storage\s+)?(?:$Inline\s+)?(?:const\s+)?($Ident)\b\s*(?!:)/s) {
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07003134 possible($1, "B:" . $s);
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08003135 }
Andy Whitcroft8905a672007-11-28 16:21:06 -08003136
3137 # any (foo ... *) is a pointer cast, and foo is a type
Andy Whitcroft65863862009-01-06 14:41:21 -08003138 while ($s =~ /\(($Ident)(?:\s+$Sparse)*[\s\*]+\s*\)/sg) {
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07003139 possible($1, "C:" . $s);
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07003140 }
Andy Whitcroft8905a672007-11-28 16:21:06 -08003141
3142 # Check for any sort of function declaration.
3143 # int foo(something bar, other baz);
3144 # void (*store_gdt)(x86_descr_ptr *);
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07003145 if ($prev_values eq 'E' && $s =~ /^(.(?:typedef\s*)?(?:(?:$Storage|$Inline)\s*)*\s*$Type\s*(?:\b$Ident|\(\*\s*$Ident\))\s*)\(/s) {
Andy Whitcroft8905a672007-11-28 16:21:06 -08003146 my ($name_len) = length($1);
Andy Whitcroft8905a672007-11-28 16:21:06 -08003147
Andy Whitcroftcf655042008-03-04 14:28:20 -08003148 my $ctx = $s;
Andy Whitcroft773647a2008-03-28 14:15:58 -07003149 substr($ctx, 0, $name_len + 1, '');
Andy Whitcroft8905a672007-11-28 16:21:06 -08003150 $ctx =~ s/\)[^\)]*$//;
Andy Whitcroftcf655042008-03-04 14:28:20 -08003151
Andy Whitcroft8905a672007-11-28 16:21:06 -08003152 for my $arg (split(/\s*,\s*/, $ctx)) {
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07003153 if ($arg =~ /^(?:const\s+)?($Ident)(?:\s+$Sparse)*\s*\**\s*(:?\b$Ident)?$/s || $arg =~ /^($Ident)$/s) {
Andy Whitcroft8905a672007-11-28 16:21:06 -08003154
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07003155 possible($1, "D:" . $s);
Andy Whitcroft8905a672007-11-28 16:21:06 -08003156 }
3157 }
3158 }
3159
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07003160 }
3161
Andy Whitcroft653d4872007-06-23 17:16:34 -07003162#
3163# Checks which may be anchored in the context.
3164#
3165
3166# Check for switch () and associated case and default
3167# statements should be at the same indent.
Andy Whitcroft00df3442007-06-08 13:47:06 -07003168 if ($line=~/\bswitch\s*\(.*\)/) {
3169 my $err = '';
3170 my $sep = '';
3171 my @ctx = ctx_block_outer($linenr, $realcnt);
3172 shift(@ctx);
3173 for my $ctx (@ctx) {
3174 my ($clen, $cindent) = line_stats($ctx);
3175 if ($ctx =~ /^\+\s*(case\s+|default:)/ &&
3176 $indent != $cindent) {
3177 $err .= "$sep$ctx\n";
3178 $sep = '';
3179 } else {
3180 $sep = "[...]\n";
3181 }
3182 }
3183 if ($err ne '') {
Joe Perches000d1cc12011-07-25 17:13:25 -07003184 ERROR("SWITCH_CASE_INDENT_LEVEL",
3185 "switch and case should be at the same indent\n$hereline$err");
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07003186 }
3187 }
3188
3189# if/while/etc brace do not go on next line, unless defining a do while loop,
3190# or if that brace on the next line is for something else
Joe Perches0fe3dc22014-08-06 16:11:16 -07003191 if ($line =~ /(.*)\b((?:if|while|for|switch|(?:[a-z_]+|)for_each[a-z_]+)\s*\(|do\b|else\b)/ && $line !~ /^.\s*\#/) {
Andy Whitcroft773647a2008-03-28 14:15:58 -07003192 my $pre_ctx = "$1$2";
3193
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07003194 my ($level, @ctx) = ctx_statement_level($linenr, $realcnt, 0);
Joe Perches8eef05d2012-02-03 15:20:39 -08003195
3196 if ($line =~ /^\+\t{6,}/) {
3197 WARN("DEEP_INDENTATION",
3198 "Too many leading tabs - consider code refactoring\n" . $herecurr);
3199 }
3200
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07003201 my $ctx_cnt = $realcnt - $#ctx - 1;
3202 my $ctx = join("\n", @ctx);
3203
Andy Whitcroft548596d2008-07-23 21:29:01 -07003204 my $ctx_ln = $linenr;
3205 my $ctx_skip = $realcnt;
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07003206
Andy Whitcroft548596d2008-07-23 21:29:01 -07003207 while ($ctx_skip > $ctx_cnt || ($ctx_skip == $ctx_cnt &&
3208 defined $lines[$ctx_ln - 1] &&
3209 $lines[$ctx_ln - 1] =~ /^-/)) {
3210 ##print "SKIP<$ctx_skip> CNT<$ctx_cnt>\n";
3211 $ctx_skip-- if (!defined $lines[$ctx_ln - 1] || $lines[$ctx_ln - 1] !~ /^-/);
Andy Whitcroft773647a2008-03-28 14:15:58 -07003212 $ctx_ln++;
3213 }
Andy Whitcroft548596d2008-07-23 21:29:01 -07003214
Andy Whitcroft53210162008-07-23 21:29:03 -07003215 #print "realcnt<$realcnt> ctx_cnt<$ctx_cnt>\n";
3216 #print "pre<$pre_ctx>\nline<$line>\nctx<$ctx>\nnext<$lines[$ctx_ln - 1]>\n";
Andy Whitcroft773647a2008-03-28 14:15:58 -07003217
Joe Perchesd752fcc2014-08-06 16:11:05 -07003218 if ($ctx !~ /{\s*/ && defined($lines[$ctx_ln - 1]) && $lines[$ctx_ln - 1] =~ /^\+\s*{/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003219 ERROR("OPEN_BRACE",
3220 "that open brace { should be on the previous line\n" .
Andy Whitcroft01464f32010-10-26 14:23:19 -07003221 "$here\n$ctx\n$rawlines[$ctx_ln - 1]\n");
Andy Whitcroft00df3442007-06-08 13:47:06 -07003222 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07003223 if ($level == 0 && $pre_ctx !~ /}\s*while\s*\($/ &&
3224 $ctx =~ /\)\s*\;\s*$/ &&
3225 defined $lines[$ctx_ln - 1])
3226 {
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07003227 my ($nlength, $nindent) = line_stats($lines[$ctx_ln - 1]);
3228 if ($nindent > $indent) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003229 WARN("TRAILING_SEMICOLON",
3230 "trailing semicolon indicates no statements, indent implies otherwise\n" .
Andy Whitcroft01464f32010-10-26 14:23:19 -07003231 "$here\n$ctx\n$rawlines[$ctx_ln - 1]\n");
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07003232 }
3233 }
Andy Whitcroft00df3442007-06-08 13:47:06 -07003234 }
3235
Andy Whitcroft4d001e42008-10-15 22:02:21 -07003236# Check relative indent for conditionals and blocks.
Joe Perches0fe3dc22014-08-06 16:11:16 -07003237 if ($line =~ /\b(?:(?:if|while|for|(?:[a-z_]+|)for_each[a-z_]+)\s*\(|do\b)/ && $line !~ /^.\s*#/ && $line !~ /\}\s*while\s*/) {
Andy Whitcroft3e469cd2012-01-10 15:10:01 -08003238 ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
3239 ctx_statement_block($linenr, $realcnt, 0)
3240 if (!defined $stat);
Andy Whitcroft4d001e42008-10-15 22:02:21 -07003241 my ($s, $c) = ($stat, $cond);
3242
3243 substr($s, 0, length($c), '');
3244
Joe Perches9f5af482015-09-09 15:37:30 -07003245 # remove inline comments
3246 $s =~ s/$;/ /g;
3247 $c =~ s/$;/ /g;
Andy Whitcroft4d001e42008-10-15 22:02:21 -07003248
3249 # Find out how long the conditional actually is.
Andy Whitcroft6f779c12008-10-15 22:02:27 -07003250 my @newlines = ($c =~ /\n/gs);
3251 my $cond_lines = 1 + $#newlines;
Andy Whitcroft4d001e42008-10-15 22:02:21 -07003252
Joe Perches9f5af482015-09-09 15:37:30 -07003253 # Make sure we remove the line prefixes as we have
3254 # none on the first line, and are going to readd them
3255 # where necessary.
3256 $s =~ s/\n./\n/gs;
3257 while ($s =~ /\n\s+\\\n/) {
3258 $cond_lines += $s =~ s/\n\s+\\\n/\n/g;
3259 }
3260
Andy Whitcroft4d001e42008-10-15 22:02:21 -07003261 # We want to check the first line inside the block
3262 # starting at the end of the conditional, so remove:
3263 # 1) any blank line termination
3264 # 2) any opening brace { on end of the line
3265 # 3) any do (...) {
3266 my $continuation = 0;
3267 my $check = 0;
3268 $s =~ s/^.*\bdo\b//;
3269 $s =~ s/^\s*{//;
3270 if ($s =~ s/^\s*\\//) {
3271 $continuation = 1;
3272 }
Andy Whitcroft9bd49ef2008-10-15 22:02:22 -07003273 if ($s =~ s/^\s*?\n//) {
Andy Whitcroft4d001e42008-10-15 22:02:21 -07003274 $check = 1;
3275 $cond_lines++;
3276 }
3277
3278 # Also ignore a loop construct at the end of a
3279 # preprocessor statement.
3280 if (($prevline =~ /^.\s*#\s*define\s/ ||
3281 $prevline =~ /\\\s*$/) && $continuation == 0) {
3282 $check = 0;
3283 }
3284
Andy Whitcroft9bd49ef2008-10-15 22:02:22 -07003285 my $cond_ptr = -1;
Andy Whitcroft740504c2008-10-15 22:02:35 -07003286 $continuation = 0;
Andy Whitcroft9bd49ef2008-10-15 22:02:22 -07003287 while ($cond_ptr != $cond_lines) {
3288 $cond_ptr = $cond_lines;
Andy Whitcroft4d001e42008-10-15 22:02:21 -07003289
Andy Whitcroftf16fa282008-10-15 22:02:32 -07003290 # If we see an #else/#elif then the code
3291 # is not linear.
3292 if ($s =~ /^\s*\#\s*(?:else|elif)/) {
3293 $check = 0;
3294 }
3295
Andy Whitcroft9bd49ef2008-10-15 22:02:22 -07003296 # Ignore:
3297 # 1) blank lines, they should be at 0,
3298 # 2) preprocessor lines, and
3299 # 3) labels.
Andy Whitcroft740504c2008-10-15 22:02:35 -07003300 if ($continuation ||
3301 $s =~ /^\s*?\n/ ||
Andy Whitcroft9bd49ef2008-10-15 22:02:22 -07003302 $s =~ /^\s*#\s*?/ ||
3303 $s =~ /^\s*$Ident\s*:/) {
Andy Whitcroft740504c2008-10-15 22:02:35 -07003304 $continuation = ($s =~ /^.*?\\\n/) ? 1 : 0;
Andy Whitcroft30dad6e2009-09-21 17:04:36 -07003305 if ($s =~ s/^.*?\n//) {
3306 $cond_lines++;
3307 }
Andy Whitcroft9bd49ef2008-10-15 22:02:22 -07003308 }
Andy Whitcroft4d001e42008-10-15 22:02:21 -07003309 }
3310
3311 my (undef, $sindent) = line_stats("+" . $s);
3312 my $stat_real = raw_line($linenr, $cond_lines);
3313
3314 # Check if either of these lines are modified, else
3315 # this is not this patch's fault.
3316 if (!defined($stat_real) ||
3317 $stat !~ /^\+/ && $stat_real !~ /^\+/) {
3318 $check = 0;
3319 }
3320 if (defined($stat_real) && $cond_lines > 1) {
3321 $stat_real = "[...]\n$stat_real";
3322 }
3323
Andy Whitcroft9bd49ef2008-10-15 22:02:22 -07003324 #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";
Andy Whitcroft4d001e42008-10-15 22:02:21 -07003325
Joe Perches9f5af482015-09-09 15:37:30 -07003326 if ($check && $s ne '' &&
3327 (($sindent % 8) != 0 ||
3328 ($sindent < $indent) ||
3329 ($sindent > $indent + 8))) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003330 WARN("SUSPECT_CODE_INDENT",
3331 "suspect code indent for conditional statements ($indent, $sindent)\n" . $herecurr . "$stat_real\n");
Andy Whitcroft4d001e42008-10-15 22:02:21 -07003332 }
3333 }
3334
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07003335 # Track the 'values' across context and added lines.
3336 my $opline = $line; $opline =~ s/^./ /;
Andy Whitcroft1f65f942008-07-23 21:29:10 -07003337 my ($curr_values, $curr_vars) =
3338 annotate_values($opline . "\n", $prev_values);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07003339 $curr_values = $prev_values . $curr_values;
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08003340 if ($dbg_values) {
3341 my $outline = $opline; $outline =~ s/\t/ /g;
Andy Whitcroftcf655042008-03-04 14:28:20 -08003342 print "$linenr > .$outline\n";
3343 print "$linenr > $curr_values\n";
Andy Whitcroft1f65f942008-07-23 21:29:10 -07003344 print "$linenr > $curr_vars\n";
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08003345 }
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07003346 $prev_values = substr($curr_values, -1);
3347
Andy Whitcroft00df3442007-06-08 13:47:06 -07003348#ignore lines not being added
Joe Perches3705ce52013-07-03 15:05:31 -07003349 next if ($line =~ /^[^\+]/);
Andy Whitcroft00df3442007-06-08 13:47:06 -07003350
Joe Perchesa1ce18e2016-03-15 14:58:03 -07003351# check for declarations of signed or unsigned without int
Joe Perchesc8447112016-08-02 14:04:42 -07003352 while ($line =~ m{\b($Declare)\s*(?!char\b|short\b|int\b|long\b)\s*($Ident)?\s*[=,;\[\)\(]}g) {
Joe Perchesa1ce18e2016-03-15 14:58:03 -07003353 my $type = $1;
3354 my $var = $2;
Joe Perches207a8e82016-03-15 14:58:06 -07003355 $var = "" if (!defined $var);
3356 if ($type =~ /^(?:(?:$Storage|$Inline|$Attribute)\s+)*((?:un)?signed)((?:\s*\*)*)\s*$/) {
Joe Perchesa1ce18e2016-03-15 14:58:03 -07003357 my $sign = $1;
3358 my $pointer = $2;
3359
3360 $pointer = "" if (!defined $pointer);
3361
3362 if (WARN("UNSPECIFIED_INT",
3363 "Prefer '" . trim($sign) . " int" . rtrim($pointer) . "' to bare use of '$sign" . rtrim($pointer) . "'\n" . $herecurr) &&
3364 $fix) {
3365 my $decl = trim($sign) . " int ";
Joe Perches207a8e82016-03-15 14:58:06 -07003366 my $comp_pointer = $pointer;
3367 $comp_pointer =~ s/\s//g;
3368 $decl .= $comp_pointer;
3369 $decl = rtrim($decl) if ($var eq "");
3370 $fixed[$fixlinenr] =~ s@\b$sign\s*\Q$pointer\E\s*$var\b@$decl$var@;
Joe Perchesa1ce18e2016-03-15 14:58:03 -07003371 }
3372 }
3373 }
3374
Andy Whitcroft653d4872007-06-23 17:16:34 -07003375# TEST: allow direct testing of the type matcher.
Andy Whitcroft7429c692008-07-23 21:29:06 -07003376 if ($dbg_type) {
3377 if ($line =~ /^.\s*$Declare\s*$/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003378 ERROR("TEST_TYPE",
3379 "TEST: is type\n" . $herecurr);
Andy Whitcroft7429c692008-07-23 21:29:06 -07003380 } elsif ($dbg_type > 1 && $line =~ /^.+($Declare)/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003381 ERROR("TEST_NOT_TYPE",
3382 "TEST: is not type ($1 is)\n". $herecurr);
Andy Whitcroft7429c692008-07-23 21:29:06 -07003383 }
Andy Whitcroft653d4872007-06-23 17:16:34 -07003384 next;
3385 }
Andy Whitcrofta1ef2772008-10-15 22:02:17 -07003386# TEST: allow direct testing of the attribute matcher.
3387 if ($dbg_attr) {
Andy Whitcroft9360b0e2009-02-27 14:03:08 -08003388 if ($line =~ /^.\s*$Modifier\s*$/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003389 ERROR("TEST_ATTR",
3390 "TEST: is attr\n" . $herecurr);
Andy Whitcroft9360b0e2009-02-27 14:03:08 -08003391 } elsif ($dbg_attr > 1 && $line =~ /^.+($Modifier)/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003392 ERROR("TEST_NOT_ATTR",
3393 "TEST: is not attr ($1 is)\n". $herecurr);
Andy Whitcrofta1ef2772008-10-15 22:02:17 -07003394 }
3395 next;
3396 }
Andy Whitcroft653d4872007-06-23 17:16:34 -07003397
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07003398# check for initialisation to aggregates open brace on the next line
Andy Whitcroft99423c22009-10-26 16:50:15 -07003399 if ($line =~ /^.\s*{/ &&
3400 $prevline =~ /(?:^|[^=])=\s*$/) {
Joe Perchesd752fcc2014-08-06 16:11:05 -07003401 if (ERROR("OPEN_BRACE",
3402 "that open brace { should be on the previous line\n" . $hereprev) &&
Joe Perchesf2d7e4d2014-08-06 16:11:07 -07003403 $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
3404 fix_delete_line($fixlinenr - 1, $prevrawline);
3405 fix_delete_line($fixlinenr, $rawline);
Joe Perchesd752fcc2014-08-06 16:11:05 -07003406 my $fixedline = $prevrawline;
3407 $fixedline =~ s/\s*=\s*$/ = {/;
Joe Perchesf2d7e4d2014-08-06 16:11:07 -07003408 fix_insert_line($fixlinenr, $fixedline);
Joe Perchesd752fcc2014-08-06 16:11:05 -07003409 $fixedline = $line;
3410 $fixedline =~ s/^(.\s*){\s*/$1/;
Joe Perchesf2d7e4d2014-08-06 16:11:07 -07003411 fix_insert_line($fixlinenr, $fixedline);
Joe Perchesd752fcc2014-08-06 16:11:05 -07003412 }
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07003413 }
3414
Andy Whitcroft653d4872007-06-23 17:16:34 -07003415#
3416# Checks which are anchored on the added line.
3417#
3418
3419# check for malformed paths in #include statements (uses RAW line)
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07003420 if ($rawline =~ m{^.\s*\#\s*include\s+[<"](.*)[">]}) {
Andy Whitcroft653d4872007-06-23 17:16:34 -07003421 my $path = $1;
3422 if ($path =~ m{//}) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003423 ERROR("MALFORMED_INCLUDE",
Joe Perches495e9d82012-12-20 15:05:37 -08003424 "malformed #include filename\n" . $herecurr);
3425 }
3426 if ($path =~ "^uapi/" && $realfile =~ m@\binclude/uapi/@) {
3427 ERROR("UAPI_INCLUDE",
3428 "No #include in ...include/uapi/... should use a uapi/ path prefix\n" . $herecurr);
Andy Whitcroft653d4872007-06-23 17:16:34 -07003429 }
Andy Whitcroft653d4872007-06-23 17:16:34 -07003430 }
Andy Whitcroft00df3442007-06-08 13:47:06 -07003431
3432# no C99 // comments
3433 if ($line =~ m{//}) {
Joe Perches3705ce52013-07-03 15:05:31 -07003434 if (ERROR("C99_COMMENTS",
3435 "do not use C99 // comments\n" . $herecurr) &&
3436 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07003437 my $line = $fixed[$fixlinenr];
Joe Perches3705ce52013-07-03 15:05:31 -07003438 if ($line =~ /\/\/(.*)$/) {
3439 my $comment = trim($1);
Joe Perches194f66f2014-08-06 16:11:03 -07003440 $fixed[$fixlinenr] =~ s@\/\/(.*)$@/\* $comment \*/@;
Joe Perches3705ce52013-07-03 15:05:31 -07003441 }
3442 }
Andy Whitcroft00df3442007-06-08 13:47:06 -07003443 }
3444 # Remove C99 comments.
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003445 $line =~ s@//.*@@;
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07003446 $opline =~ s@//.*@@;
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003447
Andy Whitcroft2b474a12009-10-26 16:50:16 -07003448# EXPORT_SYMBOL should immediately follow the thing it is exporting, consider
3449# the whole statement.
3450#print "APW <$lines[$realline_next - 1]>\n";
3451 if (defined $realline_next &&
3452 exists $lines[$realline_next - 1] &&
3453 !defined $suppress_export{$realline_next} &&
3454 ($lines[$realline_next - 1] =~ /EXPORT_SYMBOL.*\((.*)\)/ ||
3455 $lines[$realline_next - 1] =~ /EXPORT_UNUSED_SYMBOL.*\((.*)\)/)) {
Andy Whitcroft3cbf62d2010-10-26 14:23:18 -07003456 # Handle definitions which produce identifiers with
3457 # a prefix:
3458 # XXX(foo);
3459 # EXPORT_SYMBOL(something_foo);
Andy Whitcroft653d4872007-06-23 17:16:34 -07003460 my $name = $1;
Andy Whitcroft87a53872012-01-10 15:10:04 -08003461 if ($stat =~ /^(?:.\s*}\s*\n)?.([A-Z_]+)\s*\(\s*($Ident)/ &&
Andy Whitcroft3cbf62d2010-10-26 14:23:18 -07003462 $name =~ /^${Ident}_$2/) {
3463#print "FOO C name<$name>\n";
3464 $suppress_export{$realline_next} = 1;
3465
3466 } elsif ($stat !~ /(?:
Andy Whitcroft2b474a12009-10-26 16:50:16 -07003467 \n.}\s*$|
Andy Whitcroft48012052008-10-15 22:02:34 -07003468 ^.DEFINE_$Ident\(\Q$name\E\)|
3469 ^.DECLARE_$Ident\(\Q$name\E\)|
3470 ^.LIST_HEAD\(\Q$name\E\)|
Andy Whitcroft2b474a12009-10-26 16:50:16 -07003471 ^.(?:$Storage\s+)?$Type\s*\(\s*\*\s*\Q$name\E\s*\)\s*\(|
3472 \b\Q$name\E(?:\s+$Attribute)*\s*(?:;|=|\[|\()
Andy Whitcroft48012052008-10-15 22:02:34 -07003473 )/x) {
Andy Whitcroft2b474a12009-10-26 16:50:16 -07003474#print "FOO A<$lines[$realline_next - 1]> stat<$stat> name<$name>\n";
3475 $suppress_export{$realline_next} = 2;
3476 } else {
3477 $suppress_export{$realline_next} = 1;
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003478 }
3479 }
Andy Whitcroft2b474a12009-10-26 16:50:16 -07003480 if (!defined $suppress_export{$linenr} &&
3481 $prevline =~ /^.\s*$/ &&
3482 ($line =~ /EXPORT_SYMBOL.*\((.*)\)/ ||
3483 $line =~ /EXPORT_UNUSED_SYMBOL.*\((.*)\)/)) {
3484#print "FOO B <$lines[$linenr - 1]>\n";
3485 $suppress_export{$linenr} = 2;
3486 }
3487 if (defined $suppress_export{$linenr} &&
3488 $suppress_export{$linenr} == 2) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003489 WARN("EXPORT_SYMBOL",
3490 "EXPORT_SYMBOL(foo); should immediately follow its function/variable\n" . $herecurr);
Andy Whitcroft2b474a12009-10-26 16:50:16 -07003491 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003492
Joe Eloff5150bda2010-08-09 17:21:00 -07003493# check for global initialisers.
Joe Perches6d32f7a2015-11-06 16:31:37 -08003494 if ($line =~ /^\+$Type\s*$Ident(?:\s+$Modifier)*\s*=\s*($zero_initializer)\s*;/) {
Joe Perchesd5e616f2013-09-11 14:23:54 -07003495 if (ERROR("GLOBAL_INITIALISERS",
Joe Perches6d32f7a2015-11-06 16:31:37 -08003496 "do not initialise globals to $1\n" . $herecurr) &&
Joe Perchesd5e616f2013-09-11 14:23:54 -07003497 $fix) {
Joe Perches6d32f7a2015-11-06 16:31:37 -08003498 $fixed[$fixlinenr] =~ s/(^.$Type\s*$Ident(?:\s+$Modifier)*)\s*=\s*$zero_initializer\s*;/$1;/;
Joe Perchesd5e616f2013-09-11 14:23:54 -07003499 }
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07003500 }
Andy Whitcroft653d4872007-06-23 17:16:34 -07003501# check for static initialisers.
Joe Perches6d32f7a2015-11-06 16:31:37 -08003502 if ($line =~ /^\+.*\bstatic\s.*=\s*($zero_initializer)\s*;/) {
Joe Perchesd5e616f2013-09-11 14:23:54 -07003503 if (ERROR("INITIALISED_STATIC",
Joe Perches6d32f7a2015-11-06 16:31:37 -08003504 "do not initialise statics to $1\n" .
Joe Perchesd5e616f2013-09-11 14:23:54 -07003505 $herecurr) &&
3506 $fix) {
Joe Perches6d32f7a2015-11-06 16:31:37 -08003507 $fixed[$fixlinenr] =~ s/(\bstatic\s.*?)\s*=\s*$zero_initializer\s*;/$1;/;
Joe Perchesd5e616f2013-09-11 14:23:54 -07003508 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003509 }
3510
Joe Perches18130872014-08-06 16:11:22 -07003511# check for misordered declarations of char/short/int/long with signed/unsigned
3512 while ($sline =~ m{(\b$TypeMisordered\b)}g) {
3513 my $tmp = trim($1);
3514 WARN("MISORDERED_TYPE",
3515 "type '$tmp' should be specified in [[un]signed] [short|int|long|long long] order\n" . $herecurr);
3516 }
3517
Joe Perchescb710ec2010-10-26 14:23:20 -07003518# check for static const char * arrays.
3519 if ($line =~ /\bstatic\s+const\s+char\s*\*\s*(\w+)\s*\[\s*\]\s*=\s*/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003520 WARN("STATIC_CONST_CHAR_ARRAY",
3521 "static const char * array should probably be static const char * const\n" .
Joe Perchescb710ec2010-10-26 14:23:20 -07003522 $herecurr);
3523 }
3524
3525# check for static char foo[] = "bar" declarations.
3526 if ($line =~ /\bstatic\s+char\s+(\w+)\s*\[\s*\]\s*=\s*"/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003527 WARN("STATIC_CONST_CHAR_ARRAY",
3528 "static char array declaration should probably be static const char\n" .
Joe Perchescb710ec2010-10-26 14:23:20 -07003529 $herecurr);
3530 }
3531
Joe Perchesab7e23f2015-04-16 12:44:22 -07003532# check for const <foo> const where <foo> is not a pointer or array type
3533 if ($sline =~ /\bconst\s+($BasicType)\s+const\b/) {
3534 my $found = $1;
3535 if ($sline =~ /\bconst\s+\Q$found\E\s+const\b\s*\*/) {
3536 WARN("CONST_CONST",
3537 "'const $found const *' should probably be 'const $found * const'\n" . $herecurr);
3538 } elsif ($sline !~ /\bconst\s+\Q$found\E\s+const\s+\w+\s*\[/) {
3539 WARN("CONST_CONST",
3540 "'const $found const' should probably be 'const $found'\n" . $herecurr);
3541 }
3542 }
3543
Joe Perches9b0fa602014-04-03 14:49:18 -07003544# check for non-global char *foo[] = {"bar", ...} declarations.
3545 if ($line =~ /^.\s+(?:static\s+|const\s+)?char\s+\*\s*\w+\s*\[\s*\]\s*=\s*\{/) {
3546 WARN("STATIC_CONST_CHAR_ARRAY",
3547 "char * array declaration might be better as static const\n" .
3548 $herecurr);
3549 }
3550
Joe Perchesb598b672015-04-16 12:44:36 -07003551# check for sizeof(foo)/sizeof(foo[0]) that could be ARRAY_SIZE(foo)
3552 if ($line =~ m@\bsizeof\s*\(\s*($Lval)\s*\)@) {
3553 my $array = $1;
3554 if ($line =~ m@\b(sizeof\s*\(\s*\Q$array\E\s*\)\s*/\s*sizeof\s*\(\s*\Q$array\E\s*\[\s*0\s*\]\s*\))@) {
3555 my $array_div = $1;
3556 if (WARN("ARRAY_SIZE",
3557 "Prefer ARRAY_SIZE($array)\n" . $herecurr) &&
3558 $fix) {
3559 $fixed[$fixlinenr] =~ s/\Q$array_div\E/ARRAY_SIZE($array)/;
3560 }
3561 }
3562 }
3563
Joe Perchesb36190c2014-01-27 17:07:18 -08003564# check for function declarations without arguments like "int foo()"
3565 if ($line =~ /(\b$Type\s+$Ident)\s*\(\s*\)/) {
3566 if (ERROR("FUNCTION_WITHOUT_ARGS",
3567 "Bad function definition - $1() should probably be $1(void)\n" . $herecurr) &&
3568 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07003569 $fixed[$fixlinenr] =~ s/(\b($Type)\s+($Ident))\s*\(\s*\)/$2 $3(void)/;
Joe Perchesb36190c2014-01-27 17:07:18 -08003570 }
3571 }
3572
Joe Perches92e112f2013-12-13 11:36:22 -07003573# check for uses of DEFINE_PCI_DEVICE_TABLE
3574 if ($line =~ /\bDEFINE_PCI_DEVICE_TABLE\s*\(\s*(\w+)\s*\)\s*=/) {
3575 if (WARN("DEFINE_PCI_DEVICE_TABLE",
3576 "Prefer struct pci_device_id over deprecated DEFINE_PCI_DEVICE_TABLE\n" . $herecurr) &&
3577 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07003578 $fixed[$fixlinenr] =~ s/\b(?:static\s+|)DEFINE_PCI_DEVICE_TABLE\s*\(\s*(\w+)\s*\)\s*=\s*/static const struct pci_device_id $1\[\] = /;
Joe Perches92e112f2013-12-13 11:36:22 -07003579 }
Joe Perches93ed0e22010-10-26 14:23:21 -07003580 }
3581
Andy Whitcroft653d4872007-06-23 17:16:34 -07003582# check for new typedefs, only function parameters and sparse annotations
3583# make sense.
3584 if ($line =~ /\btypedef\s/ &&
Andy Whitcroft80545762009-01-06 14:41:26 -08003585 $line !~ /\btypedef\s+$Type\s*\(\s*\*?$Ident\s*\)\s*\(/ &&
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07003586 $line !~ /\btypedef\s+$Type\s+$Ident\s*\(/ &&
Andy Whitcroft8ed22ca2008-10-15 22:02:32 -07003587 $line !~ /\b$typeTypedefs\b/ &&
Andy Whitcroft653d4872007-06-23 17:16:34 -07003588 $line !~ /\b__bitwise(?:__|)\b/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003589 WARN("NEW_TYPEDEFS",
3590 "do not add new typedefs\n" . $herecurr);
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003591 }
3592
3593# * goes on variable not on type
Andy Whitcroft65863862009-01-06 14:41:21 -08003594 # (char*[ const])
Andy Whitcroftbfcb2cc2012-01-10 15:10:15 -08003595 while ($line =~ m{(\($NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)\))}g) {
3596 #print "AA<$1>\n";
Joe Perches3705ce52013-07-03 15:05:31 -07003597 my ($ident, $from, $to) = ($1, $2, $2);
Andy Whitcroftd8aaf122007-06-23 17:16:44 -07003598
Andy Whitcroft65863862009-01-06 14:41:21 -08003599 # Should start with a space.
3600 $to =~ s/^(\S)/ $1/;
3601 # Should not end with a space.
3602 $to =~ s/\s+$//;
3603 # '*'s should not have spaces between.
Andy Whitcroftf9a0b3d2009-01-15 13:51:05 -08003604 while ($to =~ s/\*\s+\*/\*\*/) {
Andy Whitcroft65863862009-01-06 14:41:21 -08003605 }
Andy Whitcroftd8aaf122007-06-23 17:16:44 -07003606
Joe Perches3705ce52013-07-03 15:05:31 -07003607## print "1: from<$from> to<$to> ident<$ident>\n";
Andy Whitcroft65863862009-01-06 14:41:21 -08003608 if ($from ne $to) {
Joe Perches3705ce52013-07-03 15:05:31 -07003609 if (ERROR("POINTER_LOCATION",
3610 "\"(foo$from)\" should be \"(foo$to)\"\n" . $herecurr) &&
3611 $fix) {
3612 my $sub_from = $ident;
3613 my $sub_to = $ident;
3614 $sub_to =~ s/\Q$from\E/$to/;
Joe Perches194f66f2014-08-06 16:11:03 -07003615 $fixed[$fixlinenr] =~
Joe Perches3705ce52013-07-03 15:05:31 -07003616 s@\Q$sub_from\E@$sub_to@;
3617 }
Andy Whitcroft65863862009-01-06 14:41:21 -08003618 }
Andy Whitcroftbfcb2cc2012-01-10 15:10:15 -08003619 }
3620 while ($line =~ m{(\b$NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)($Ident))}g) {
3621 #print "BB<$1>\n";
Joe Perches3705ce52013-07-03 15:05:31 -07003622 my ($match, $from, $to, $ident) = ($1, $2, $2, $3);
Andy Whitcroftd8aaf122007-06-23 17:16:44 -07003623
Andy Whitcroft65863862009-01-06 14:41:21 -08003624 # Should start with a space.
3625 $to =~ s/^(\S)/ $1/;
3626 # Should not end with a space.
3627 $to =~ s/\s+$//;
3628 # '*'s should not have spaces between.
Andy Whitcroftf9a0b3d2009-01-15 13:51:05 -08003629 while ($to =~ s/\*\s+\*/\*\*/) {
Andy Whitcroft65863862009-01-06 14:41:21 -08003630 }
3631 # Modifiers should have spaces.
3632 $to =~ s/(\b$Modifier$)/$1 /;
3633
Joe Perches3705ce52013-07-03 15:05:31 -07003634## print "2: from<$from> to<$to> ident<$ident>\n";
Andy Whitcroft667026e2009-02-27 14:03:08 -08003635 if ($from ne $to && $ident !~ /^$Modifier$/) {
Joe Perches3705ce52013-07-03 15:05:31 -07003636 if (ERROR("POINTER_LOCATION",
3637 "\"foo${from}bar\" should be \"foo${to}bar\"\n" . $herecurr) &&
3638 $fix) {
3639
3640 my $sub_from = $match;
3641 my $sub_to = $match;
3642 $sub_to =~ s/\Q$from\E/$to/;
Joe Perches194f66f2014-08-06 16:11:03 -07003643 $fixed[$fixlinenr] =~
Joe Perches3705ce52013-07-03 15:05:31 -07003644 s@\Q$sub_from\E@$sub_to@;
3645 }
Andy Whitcroft65863862009-01-06 14:41:21 -08003646 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003647 }
3648
Joe Perches9d3e3c72015-09-09 15:37:27 -07003649# avoid BUG() or BUG_ON()
3650 if ($line =~ /\b(?:BUG|BUG_ON)\b/) {
3651 my $msg_type = \&WARN;
3652 $msg_type = \&CHK if ($file);
3653 &{$msg_type}("AVOID_BUG",
3654 "Avoid crashing the kernel - try using WARN_ON & recovery code rather than BUG() or BUG_ON()\n" . $herecurr);
3655 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003656
Joe Perches9d3e3c72015-09-09 15:37:27 -07003657# avoid LINUX_VERSION_CODE
Andy Whitcroft8905a672007-11-28 16:21:06 -08003658 if ($line =~ /\bLINUX_VERSION_CODE\b/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003659 WARN("LINUX_VERSION_CODE",
3660 "LINUX_VERSION_CODE should be avoided, code should be for the version to which it is merged\n" . $herecurr);
Andy Whitcroft8905a672007-11-28 16:21:06 -08003661 }
3662
Joe Perches17441222011-06-15 15:08:17 -07003663# check for uses of printk_ratelimit
3664 if ($line =~ /\bprintk_ratelimit\s*\(/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003665 WARN("PRINTK_RATELIMITED",
Joe Perches101ee682015-02-13 14:38:54 -08003666 "Prefer printk_ratelimited or pr_<level>_ratelimited to printk_ratelimit\n" . $herecurr);
Joe Perches17441222011-06-15 15:08:17 -07003667 }
3668
Andy Whitcroft00df3442007-06-08 13:47:06 -07003669# printk should use KERN_* levels. Note that follow on printk's on the
3670# same line do not need a level, so we use the current block context
3671# to try and find and validate the current printk. In summary the current
Lucas De Marchi25985ed2011-03-30 22:57:33 -03003672# printk includes all preceding printk's which have no newline on the end.
Andy Whitcroft00df3442007-06-08 13:47:06 -07003673# we assume the first bad printk is the one to report.
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07003674 if ($line =~ /\bprintk\((?!KERN_)\s*"/) {
Andy Whitcroft00df3442007-06-08 13:47:06 -07003675 my $ok = 0;
3676 for (my $ln = $linenr - 1; $ln >= $first_line; $ln--) {
3677 #print "CHECK<$lines[$ln - 1]\n";
Lucas De Marchi25985ed2011-03-30 22:57:33 -03003678 # we have a preceding printk if it ends
Andy Whitcroft00df3442007-06-08 13:47:06 -07003679 # with "\n" ignore it, else it is to blame
3680 if ($lines[$ln - 1] =~ m{\bprintk\(}) {
3681 if ($rawlines[$ln - 1] !~ m{\\n"}) {
3682 $ok = 1;
3683 }
3684 last;
3685 }
3686 }
3687 if ($ok == 0) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003688 WARN("PRINTK_WITHOUT_KERN_LEVEL",
3689 "printk() should include KERN_ facility level\n" . $herecurr);
Andy Whitcroft00df3442007-06-08 13:47:06 -07003690 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003691 }
3692
Joe Perches243f3802012-05-31 16:26:09 -07003693 if ($line =~ /\bprintk\s*\(\s*KERN_([A-Z]+)/) {
3694 my $orig = $1;
3695 my $level = lc($orig);
3696 $level = "warn" if ($level eq "warning");
Joe Perches8f26b832012-10-04 17:13:32 -07003697 my $level2 = $level;
3698 $level2 = "dbg" if ($level eq "debug");
Joe Perches243f3802012-05-31 16:26:09 -07003699 WARN("PREFER_PR_LEVEL",
Yogesh Chaudharidaa8b052014-04-03 14:49:23 -07003700 "Prefer [subsystem eg: netdev]_$level2([subsystem]dev, ... then dev_$level2(dev, ... then pr_$level(... to printk(KERN_$orig ...\n" . $herecurr);
Joe Perches243f3802012-05-31 16:26:09 -07003701 }
3702
3703 if ($line =~ /\bpr_warning\s*\(/) {
Joe Perchesd5e616f2013-09-11 14:23:54 -07003704 if (WARN("PREFER_PR_LEVEL",
3705 "Prefer pr_warn(... to pr_warning(...\n" . $herecurr) &&
3706 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07003707 $fixed[$fixlinenr] =~
Joe Perchesd5e616f2013-09-11 14:23:54 -07003708 s/\bpr_warning\b/pr_warn/;
3709 }
Joe Perches243f3802012-05-31 16:26:09 -07003710 }
3711
Joe Perchesdc139312013-02-21 16:44:13 -08003712 if ($line =~ /\bdev_printk\s*\(\s*KERN_([A-Z]+)/) {
3713 my $orig = $1;
3714 my $level = lc($orig);
3715 $level = "warn" if ($level eq "warning");
3716 $level = "dbg" if ($level eq "debug");
3717 WARN("PREFER_DEV_LEVEL",
3718 "Prefer dev_$level(... to dev_printk(KERN_$orig, ...\n" . $herecurr);
3719 }
3720
Andy Lutomirski91c9afa2015-04-16 12:44:44 -07003721# ENOSYS means "bad syscall nr" and nothing else. This will have a small
3722# number of false positives, but assembly files are not checked, so at
3723# least the arch entry code will not trigger this warning.
3724 if ($line =~ /\bENOSYS\b/) {
3725 WARN("ENOSYS",
3726 "ENOSYS means 'invalid syscall nr' and nothing else\n" . $herecurr);
3727 }
3728
Andy Whitcroft653d4872007-06-23 17:16:34 -07003729# function brace can't be on same line, except for #defines of do while,
3730# or if closed on same line
Joe Perches8d182472014-08-06 16:11:12 -07003731 if (($line=~/$Type\s*$Ident\(.*\).*\s*{/) and
Eddie Kovsky4e5d56b2015-09-09 15:37:52 -07003732 !($line=~/\#\s*define.*do\s\{/) and !($line=~/}/)) {
Joe Perches8d182472014-08-06 16:11:12 -07003733 if (ERROR("OPEN_BRACE",
3734 "open brace '{' following function declarations go on the next line\n" . $herecurr) &&
3735 $fix) {
3736 fix_delete_line($fixlinenr, $rawline);
3737 my $fixed_line = $rawline;
3738 $fixed_line =~ /(^..*$Type\s*$Ident\(.*\)\s*){(.*)$/;
3739 my $line1 = $1;
3740 my $line2 = $2;
3741 fix_insert_line($fixlinenr, ltrim($line1));
3742 fix_insert_line($fixlinenr, "\+{");
3743 if ($line2 !~ /^\s*$/) {
3744 fix_insert_line($fixlinenr, "\+\t" . trim($line2));
3745 }
3746 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003747 }
Andy Whitcroft653d4872007-06-23 17:16:34 -07003748
Andy Whitcroft8905a672007-11-28 16:21:06 -08003749# open braces for enum, union and struct go on the same line.
3750 if ($line =~ /^.\s*{/ &&
3751 $prevline =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident)?\s*$/) {
Joe Perches8d182472014-08-06 16:11:12 -07003752 if (ERROR("OPEN_BRACE",
3753 "open brace '{' following $1 go on the same line\n" . $hereprev) &&
3754 $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
3755 fix_delete_line($fixlinenr - 1, $prevrawline);
3756 fix_delete_line($fixlinenr, $rawline);
3757 my $fixedline = rtrim($prevrawline) . " {";
3758 fix_insert_line($fixlinenr, $fixedline);
3759 $fixedline = $rawline;
3760 $fixedline =~ s/^(.\s*){\s*/$1\t/;
3761 if ($fixedline !~ /^\+\s*$/) {
3762 fix_insert_line($fixlinenr, $fixedline);
3763 }
3764 }
Andy Whitcroft8905a672007-11-28 16:21:06 -08003765 }
3766
Andy Whitcroft0c73b4e2010-10-26 14:23:15 -07003767# missing space after union, struct or enum definition
Joe Perches3705ce52013-07-03 15:05:31 -07003768 if ($line =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident){1,2}[=\{]/) {
3769 if (WARN("SPACING",
3770 "missing space after $1 definition\n" . $herecurr) &&
3771 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07003772 $fixed[$fixlinenr] =~
Joe Perches3705ce52013-07-03 15:05:31 -07003773 s/^(.\s*(?:typedef\s+)?(?:enum|union|struct)(?:\s+$Ident){1,2})([=\{])/$1 $2/;
3774 }
Andy Whitcroft0c73b4e2010-10-26 14:23:15 -07003775 }
3776
Joe Perches31070b52014-01-23 15:54:49 -08003777# Function pointer declarations
3778# check spacing between type, funcptr, and args
3779# canonical declaration is "type (*funcptr)(args...)"
Joe Perches91f72e92014-04-03 14:49:12 -07003780 if ($line =~ /^.\s*($Declare)\((\s*)\*(\s*)($Ident)(\s*)\)(\s*)\(/) {
Joe Perches31070b52014-01-23 15:54:49 -08003781 my $declare = $1;
3782 my $pre_pointer_space = $2;
3783 my $post_pointer_space = $3;
3784 my $funcname = $4;
3785 my $post_funcname_space = $5;
3786 my $pre_args_space = $6;
3787
Joe Perches91f72e92014-04-03 14:49:12 -07003788# the $Declare variable will capture all spaces after the type
3789# so check it for a missing trailing missing space but pointer return types
3790# don't need a space so don't warn for those.
3791 my $post_declare_space = "";
3792 if ($declare =~ /(\s+)$/) {
3793 $post_declare_space = $1;
3794 $declare = rtrim($declare);
3795 }
3796 if ($declare !~ /\*$/ && $post_declare_space =~ /^$/) {
Joe Perches31070b52014-01-23 15:54:49 -08003797 WARN("SPACING",
3798 "missing space after return type\n" . $herecurr);
Joe Perches91f72e92014-04-03 14:49:12 -07003799 $post_declare_space = " ";
Joe Perches31070b52014-01-23 15:54:49 -08003800 }
3801
3802# unnecessary space "type (*funcptr)(args...)"
Joe Perches91f72e92014-04-03 14:49:12 -07003803# This test is not currently implemented because these declarations are
3804# equivalent to
3805# int foo(int bar, ...)
3806# and this is form shouldn't/doesn't generate a checkpatch warning.
3807#
3808# elsif ($declare =~ /\s{2,}$/) {
3809# WARN("SPACING",
3810# "Multiple spaces after return type\n" . $herecurr);
3811# }
Joe Perches31070b52014-01-23 15:54:49 -08003812
3813# unnecessary space "type ( *funcptr)(args...)"
3814 if (defined $pre_pointer_space &&
3815 $pre_pointer_space =~ /^\s/) {
3816 WARN("SPACING",
3817 "Unnecessary space after function pointer open parenthesis\n" . $herecurr);
3818 }
3819
3820# unnecessary space "type (* funcptr)(args...)"
3821 if (defined $post_pointer_space &&
3822 $post_pointer_space =~ /^\s/) {
3823 WARN("SPACING",
3824 "Unnecessary space before function pointer name\n" . $herecurr);
3825 }
3826
3827# unnecessary space "type (*funcptr )(args...)"
3828 if (defined $post_funcname_space &&
3829 $post_funcname_space =~ /^\s/) {
3830 WARN("SPACING",
3831 "Unnecessary space after function pointer name\n" . $herecurr);
3832 }
3833
3834# unnecessary space "type (*funcptr) (args...)"
3835 if (defined $pre_args_space &&
3836 $pre_args_space =~ /^\s/) {
3837 WARN("SPACING",
3838 "Unnecessary space before function pointer arguments\n" . $herecurr);
3839 }
3840
3841 if (show_type("SPACING") && $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07003842 $fixed[$fixlinenr] =~
Joe Perches91f72e92014-04-03 14:49:12 -07003843 s/^(.\s*)$Declare\s*\(\s*\*\s*$Ident\s*\)\s*\(/$1 . $declare . $post_declare_space . '(*' . $funcname . ')('/ex;
Joe Perches31070b52014-01-23 15:54:49 -08003844 }
3845 }
3846
Andy Whitcroft8d31cfc2008-07-23 21:29:02 -07003847# check for spacing round square brackets; allowed:
3848# 1. with a type on the left -- int [] a;
Andy Whitcroftfe2a7db2008-10-15 22:02:15 -07003849# 2. at the beginning of a line for slice initialisers -- [0...10] = 5,
3850# 3. inside a curly brace -- = { [0...10] = 5 }
Andy Whitcroft8d31cfc2008-07-23 21:29:02 -07003851 while ($line =~ /(.*?\s)\[/g) {
3852 my ($where, $prefix) = ($-[1], $1);
3853 if ($prefix !~ /$Type\s+$/ &&
Andy Whitcroftfe2a7db2008-10-15 22:02:15 -07003854 ($where != 0 || $prefix !~ /^.\s+$/) &&
Andy Whitcroftdaebc532012-03-23 15:02:17 -07003855 $prefix !~ /[{,]\s+$/) {
Joe Perches3705ce52013-07-03 15:05:31 -07003856 if (ERROR("BRACKET_SPACE",
3857 "space prohibited before open square bracket '['\n" . $herecurr) &&
3858 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07003859 $fixed[$fixlinenr] =~
Joe Perches3705ce52013-07-03 15:05:31 -07003860 s/^(\+.*?)\s+\[/$1\[/;
3861 }
Andy Whitcroft8d31cfc2008-07-23 21:29:02 -07003862 }
3863 }
3864
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07003865# check for spaces between functions and their parentheses.
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07003866 while ($line =~ /($Ident)\s+\(/g) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08003867 my $name = $1;
Andy Whitcroft773647a2008-03-28 14:15:58 -07003868 my $ctx_before = substr($line, 0, $-[1]);
3869 my $ctx = "$ctx_before$name";
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08003870
3871 # Ignore those directives where spaces _are_ permitted.
Andy Whitcroft773647a2008-03-28 14:15:58 -07003872 if ($name =~ /^(?:
3873 if|for|while|switch|return|case|
3874 volatile|__volatile__|
3875 __attribute__|format|__extension__|
3876 asm|__asm__)$/x)
3877 {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08003878 # cpp #define statements have non-optional spaces, ie
3879 # if there is a space between the name and the open
3880 # parenthesis it is simply not a parameter group.
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07003881 } elsif ($ctx_before =~ /^.\s*\#\s*define\s*$/) {
Andy Whitcroft773647a2008-03-28 14:15:58 -07003882
3883 # cpp #elif statement condition may start with a (
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07003884 } elsif ($ctx =~ /^.\s*\#\s*elif\s*$/) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08003885
3886 # If this whole things ends with a type its most
3887 # likely a typedef for a function.
Andy Whitcroft773647a2008-03-28 14:15:58 -07003888 } elsif ($ctx =~ /$Type$/) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08003889
3890 } else {
Joe Perches3705ce52013-07-03 15:05:31 -07003891 if (WARN("SPACING",
3892 "space prohibited between function name and open parenthesis '('\n" . $herecurr) &&
3893 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07003894 $fixed[$fixlinenr] =~
Joe Perches3705ce52013-07-03 15:05:31 -07003895 s/\b$name\s+\(/$name\(/;
3896 }
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07003897 }
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07003898 }
Eric Nelson9a4cad42012-05-31 16:26:09 -07003899
Andy Whitcroft653d4872007-06-23 17:16:34 -07003900# Check operator spacing.
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003901 if (!($line=~/\#\s*include/)) {
Joe Perches3705ce52013-07-03 15:05:31 -07003902 my $fixed_line = "";
3903 my $line_fixed = 0;
3904
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07003905 my $ops = qr{
3906 <<=|>>=|<=|>=|==|!=|
3907 \+=|-=|\*=|\/=|%=|\^=|\|=|&=|
3908 =>|->|<<|>>|<|>|=|!|~|
Andy Whitcroft1f65f942008-07-23 21:29:10 -07003909 &&|\|\||,|\^|\+\+|--|&|\||\+|-|\*|\/|%|
Joe Perches84731622013-11-12 15:10:05 -08003910 \?:|\?|:
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07003911 }x;
Andy Whitcroftcf655042008-03-04 14:28:20 -08003912 my @elements = split(/($ops|;)/, $opline);
Joe Perches3705ce52013-07-03 15:05:31 -07003913
3914## print("element count: <" . $#elements . ">\n");
3915## foreach my $el (@elements) {
3916## print("el: <$el>\n");
3917## }
3918
3919 my @fix_elements = ();
Andy Whitcroft00df3442007-06-08 13:47:06 -07003920 my $off = 0;
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07003921
Joe Perches3705ce52013-07-03 15:05:31 -07003922 foreach my $el (@elements) {
3923 push(@fix_elements, substr($rawline, $off, length($el)));
3924 $off += length($el);
3925 }
3926
3927 $off = 0;
3928
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07003929 my $blank = copy_spacing($opline);
Joe Perchesb34c6482013-09-11 14:24:01 -07003930 my $last_after = -1;
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07003931
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003932 for (my $n = 0; $n < $#elements; $n += 2) {
Joe Perches3705ce52013-07-03 15:05:31 -07003933
3934 my $good = $fix_elements[$n] . $fix_elements[$n + 1];
3935
3936## print("n: <$n> good: <$good>\n");
3937
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07003938 $off += length($elements[$n]);
3939
Lucas De Marchi25985ed2011-03-30 22:57:33 -03003940 # Pick up the preceding and succeeding characters.
Andy Whitcroft773647a2008-03-28 14:15:58 -07003941 my $ca = substr($opline, 0, $off);
3942 my $cc = '';
3943 if (length($opline) >= ($off + length($elements[$n + 1]))) {
3944 $cc = substr($opline, $off + length($elements[$n + 1]));
3945 }
3946 my $cb = "$ca$;$cc";
3947
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07003948 my $a = '';
3949 $a = 'V' if ($elements[$n] ne '');
3950 $a = 'W' if ($elements[$n] =~ /\s$/);
Andy Whitcroftcf655042008-03-04 14:28:20 -08003951 $a = 'C' if ($elements[$n] =~ /$;$/);
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07003952 $a = 'B' if ($elements[$n] =~ /(\[|\()$/);
3953 $a = 'O' if ($elements[$n] eq '');
Andy Whitcroft773647a2008-03-28 14:15:58 -07003954 $a = 'E' if ($ca =~ /^\s*$/);
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07003955
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003956 my $op = $elements[$n + 1];
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07003957
3958 my $c = '';
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003959 if (defined $elements[$n + 2]) {
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07003960 $c = 'V' if ($elements[$n + 2] ne '');
3961 $c = 'W' if ($elements[$n + 2] =~ /^\s/);
Andy Whitcroftcf655042008-03-04 14:28:20 -08003962 $c = 'C' if ($elements[$n + 2] =~ /^$;/);
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07003963 $c = 'B' if ($elements[$n + 2] =~ /^(\)|\]|;)/);
3964 $c = 'O' if ($elements[$n + 2] eq '');
Andy Whitcroft8b1b3372009-01-06 14:41:27 -08003965 $c = 'E' if ($elements[$n + 2] =~ /^\s*\\$/);
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07003966 } else {
3967 $c = 'E';
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003968 }
3969
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07003970 my $ctx = "${a}x${c}";
3971
3972 my $at = "(ctx:$ctx)";
3973
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07003974 my $ptr = substr($blank, 0, $off) . "^";
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07003975 my $hereptr = "$hereline$ptr\n";
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003976
Andy Whitcroft74048ed2008-07-23 21:29:10 -07003977 # Pull out the value of this operator.
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07003978 my $op_type = substr($curr_values, $off + 1, 1);
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003979
Andy Whitcroft1f65f942008-07-23 21:29:10 -07003980 # Get the full operator variant.
3981 my $opv = $op . substr($curr_vars, $off, 1);
3982
Andy Whitcroft13214ad2008-02-08 04:22:03 -08003983 # Ignore operators passed as parameters.
3984 if ($op_type ne 'V' &&
Sam Bobroffd7fe8062015-04-16 12:44:39 -07003985 $ca =~ /\s$/ && $cc =~ /^\s*[,\)]/) {
Andy Whitcroft13214ad2008-02-08 04:22:03 -08003986
Andy Whitcroftcf655042008-03-04 14:28:20 -08003987# # Ignore comments
3988# } elsif ($op =~ /^$;+$/) {
Andy Whitcroft13214ad2008-02-08 04:22:03 -08003989
Andy Whitcroftd8aaf122007-06-23 17:16:44 -07003990 # ; should have either the end of line or a space or \ after it
Andy Whitcroft13214ad2008-02-08 04:22:03 -08003991 } elsif ($op eq ';') {
Andy Whitcroftcf655042008-03-04 14:28:20 -08003992 if ($ctx !~ /.x[WEBC]/ &&
3993 $cc !~ /^\\/ && $cc !~ /^;/) {
Joe Perches3705ce52013-07-03 15:05:31 -07003994 if (ERROR("SPACING",
3995 "space required after that '$op' $at\n" . $hereptr)) {
Joe Perchesb34c6482013-09-11 14:24:01 -07003996 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";
Joe Perches3705ce52013-07-03 15:05:31 -07003997 $line_fixed = 1;
3998 }
Andy Whitcroftd8aaf122007-06-23 17:16:44 -07003999 }
4000
4001 # // is a comment
4002 } elsif ($op eq '//') {
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004003
Joe Perchesb00e4812014-04-03 14:49:33 -07004004 # : when part of a bitfield
4005 } elsif ($opv eq ':B') {
4006 # skip the bitfield test for now
4007
Andy Whitcroft1f65f942008-07-23 21:29:10 -07004008 # No spaces for:
4009 # ->
Joe Perchesb00e4812014-04-03 14:49:33 -07004010 } elsif ($op eq '->') {
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07004011 if ($ctx =~ /Wx.|.xW/) {
Joe Perches3705ce52013-07-03 15:05:31 -07004012 if (ERROR("SPACING",
4013 "spaces prohibited around that '$op' $at\n" . $hereptr)) {
Joe Perchesb34c6482013-09-11 14:24:01 -07004014 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
Joe Perches3705ce52013-07-03 15:05:31 -07004015 if (defined $fix_elements[$n + 2]) {
4016 $fix_elements[$n + 2] =~ s/^\s+//;
4017 }
Joe Perchesb34c6482013-09-11 14:24:01 -07004018 $line_fixed = 1;
Joe Perches3705ce52013-07-03 15:05:31 -07004019 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004020 }
4021
Joe Perches23810972014-12-10 15:51:32 -08004022 # , must not have a space before and must have a space on the right.
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004023 } elsif ($op eq ',') {
Joe Perches23810972014-12-10 15:51:32 -08004024 my $rtrim_before = 0;
4025 my $space_after = 0;
4026 if ($ctx =~ /Wx./) {
4027 if (ERROR("SPACING",
4028 "space prohibited before that '$op' $at\n" . $hereptr)) {
4029 $line_fixed = 1;
4030 $rtrim_before = 1;
4031 }
4032 }
Andy Whitcroftcf655042008-03-04 14:28:20 -08004033 if ($ctx !~ /.x[WEC]/ && $cc !~ /^}/) {
Joe Perches3705ce52013-07-03 15:05:31 -07004034 if (ERROR("SPACING",
4035 "space required after that '$op' $at\n" . $hereptr)) {
Joe Perches3705ce52013-07-03 15:05:31 -07004036 $line_fixed = 1;
Joe Perchesb34c6482013-09-11 14:24:01 -07004037 $last_after = $n;
Joe Perches23810972014-12-10 15:51:32 -08004038 $space_after = 1;
4039 }
4040 }
4041 if ($rtrim_before || $space_after) {
4042 if ($rtrim_before) {
4043 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
4044 } else {
4045 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]);
4046 }
4047 if ($space_after) {
4048 $good .= " ";
Joe Perches3705ce52013-07-03 15:05:31 -07004049 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004050 }
4051
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07004052 # '*' as part of a type definition -- reported already.
Andy Whitcroft74048ed2008-07-23 21:29:10 -07004053 } elsif ($opv eq '*_') {
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07004054 #warn "'*' is part of type\n";
4055
4056 # unary operators should have a space before and
4057 # none after. May be left adjacent to another
4058 # unary operator, or a cast
4059 } elsif ($op eq '!' || $op eq '~' ||
Andy Whitcroft74048ed2008-07-23 21:29:10 -07004060 $opv eq '*U' || $opv eq '-U' ||
Andy Whitcroft0d413862008-10-15 22:02:16 -07004061 $opv eq '&U' || $opv eq '&&U') {
Andy Whitcroftcf655042008-03-04 14:28:20 -08004062 if ($ctx !~ /[WEBC]x./ && $ca !~ /(?:\)|!|~|\*|-|\&|\||\+\+|\-\-|\{)$/) {
Joe Perches3705ce52013-07-03 15:05:31 -07004063 if (ERROR("SPACING",
4064 "space required before that '$op' $at\n" . $hereptr)) {
Joe Perchesb34c6482013-09-11 14:24:01 -07004065 if ($n != $last_after + 2) {
4066 $good = $fix_elements[$n] . " " . ltrim($fix_elements[$n + 1]);
4067 $line_fixed = 1;
4068 }
Joe Perches3705ce52013-07-03 15:05:31 -07004069 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004070 }
Andy Whitcrofta3340b32009-02-27 14:03:07 -08004071 if ($op eq '*' && $cc =~/\s*$Modifier\b/) {
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07004072 # A unary '*' may be const
4073
4074 } elsif ($ctx =~ /.xW/) {
Joe Perches3705ce52013-07-03 15:05:31 -07004075 if (ERROR("SPACING",
4076 "space prohibited after that '$op' $at\n" . $hereptr)) {
Joe Perchesb34c6482013-09-11 14:24:01 -07004077 $good = $fix_elements[$n] . rtrim($fix_elements[$n + 1]);
Joe Perches3705ce52013-07-03 15:05:31 -07004078 if (defined $fix_elements[$n + 2]) {
4079 $fix_elements[$n + 2] =~ s/^\s+//;
4080 }
Joe Perchesb34c6482013-09-11 14:24:01 -07004081 $line_fixed = 1;
Joe Perches3705ce52013-07-03 15:05:31 -07004082 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004083 }
4084
4085 # unary ++ and unary -- are allowed no space on one side.
4086 } elsif ($op eq '++' or $op eq '--') {
Andy Whitcroft773647a2008-03-28 14:15:58 -07004087 if ($ctx !~ /[WEOBC]x[^W]/ && $ctx !~ /[^W]x[WOBEC]/) {
Joe Perches3705ce52013-07-03 15:05:31 -07004088 if (ERROR("SPACING",
4089 "space required one side of that '$op' $at\n" . $hereptr)) {
Joe Perchesb34c6482013-09-11 14:24:01 -07004090 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";
Joe Perches3705ce52013-07-03 15:05:31 -07004091 $line_fixed = 1;
4092 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004093 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07004094 if ($ctx =~ /Wx[BE]/ ||
4095 ($ctx =~ /Wx./ && $cc =~ /^;/)) {
Joe Perches3705ce52013-07-03 15:05:31 -07004096 if (ERROR("SPACING",
4097 "space prohibited before that '$op' $at\n" . $hereptr)) {
Joe Perchesb34c6482013-09-11 14:24:01 -07004098 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
Joe Perches3705ce52013-07-03 15:05:31 -07004099 $line_fixed = 1;
4100 }
Andy Whitcroft653d4872007-06-23 17:16:34 -07004101 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07004102 if ($ctx =~ /ExW/) {
Joe Perches3705ce52013-07-03 15:05:31 -07004103 if (ERROR("SPACING",
4104 "space prohibited after that '$op' $at\n" . $hereptr)) {
Joe Perchesb34c6482013-09-11 14:24:01 -07004105 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]);
Joe Perches3705ce52013-07-03 15:05:31 -07004106 if (defined $fix_elements[$n + 2]) {
4107 $fix_elements[$n + 2] =~ s/^\s+//;
4108 }
Joe Perchesb34c6482013-09-11 14:24:01 -07004109 $line_fixed = 1;
Joe Perches3705ce52013-07-03 15:05:31 -07004110 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07004111 }
4112
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004113 # << and >> may either have or not have spaces both sides
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07004114 } elsif ($op eq '<<' or $op eq '>>' or
4115 $op eq '&' or $op eq '^' or $op eq '|' or
4116 $op eq '+' or $op eq '-' or
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08004117 $op eq '*' or $op eq '/' or
4118 $op eq '%')
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004119 {
Joe Perchesd2e025f2015-02-13 14:38:57 -08004120 if ($check) {
4121 if (defined $fix_elements[$n + 2] && $ctx !~ /[EW]x[EW]/) {
4122 if (CHK("SPACING",
4123 "spaces preferred around that '$op' $at\n" . $hereptr)) {
4124 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
4125 $fix_elements[$n + 2] =~ s/^\s+//;
4126 $line_fixed = 1;
4127 }
4128 } elsif (!defined $fix_elements[$n + 2] && $ctx !~ /Wx[OE]/) {
4129 if (CHK("SPACING",
4130 "space preferred before that '$op' $at\n" . $hereptr)) {
4131 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]);
4132 $line_fixed = 1;
4133 }
4134 }
4135 } elsif ($ctx =~ /Wx[^WCE]|[^WCE]xW/) {
Joe Perches3705ce52013-07-03 15:05:31 -07004136 if (ERROR("SPACING",
4137 "need consistent spacing around '$op' $at\n" . $hereptr)) {
Joe Perchesb34c6482013-09-11 14:24:01 -07004138 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
4139 if (defined $fix_elements[$n + 2]) {
4140 $fix_elements[$n + 2] =~ s/^\s+//;
4141 }
Joe Perches3705ce52013-07-03 15:05:31 -07004142 $line_fixed = 1;
4143 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004144 }
4145
Andy Whitcroft1f65f942008-07-23 21:29:10 -07004146 # A colon needs no spaces before when it is
4147 # terminating a case value or a label.
4148 } elsif ($opv eq ':C' || $opv eq ':L') {
4149 if ($ctx =~ /Wx./) {
Joe Perches3705ce52013-07-03 15:05:31 -07004150 if (ERROR("SPACING",
4151 "space prohibited before that '$op' $at\n" . $hereptr)) {
Joe Perchesb34c6482013-09-11 14:24:01 -07004152 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
Joe Perches3705ce52013-07-03 15:05:31 -07004153 $line_fixed = 1;
4154 }
Andy Whitcroft1f65f942008-07-23 21:29:10 -07004155 }
4156
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004157 # All the others need spaces both sides.
Andy Whitcroftcf655042008-03-04 14:28:20 -08004158 } elsif ($ctx !~ /[EWC]x[CWE]/) {
Andy Whitcroft1f65f942008-07-23 21:29:10 -07004159 my $ok = 0;
4160
Andy Whitcroft22f2a2e2007-08-10 13:01:03 -07004161 # Ignore email addresses <foo@bar>
Andy Whitcroft1f65f942008-07-23 21:29:10 -07004162 if (($op eq '<' &&
4163 $cc =~ /^\S+\@\S+>/) ||
4164 ($op eq '>' &&
4165 $ca =~ /<\S+\@\S+$/))
4166 {
4167 $ok = 1;
4168 }
4169
Joe Perchese0df7e12015-04-16 12:44:53 -07004170 # for asm volatile statements
4171 # ignore a colon with another
4172 # colon immediately before or after
4173 if (($op eq ':') &&
4174 ($ca =~ /:$/ || $cc =~ /^:/)) {
4175 $ok = 1;
4176 }
4177
Joe Perches84731622013-11-12 15:10:05 -08004178 # messages are ERROR, but ?: are CHK
Andy Whitcroft1f65f942008-07-23 21:29:10 -07004179 if ($ok == 0) {
Joe Perches84731622013-11-12 15:10:05 -08004180 my $msg_type = \&ERROR;
4181 $msg_type = \&CHK if (($op eq '?:' || $op eq '?' || $op eq ':') && $ctx =~ /VxV/);
4182
4183 if (&{$msg_type}("SPACING",
4184 "spaces required around that '$op' $at\n" . $hereptr)) {
Joe Perchesb34c6482013-09-11 14:24:01 -07004185 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
4186 if (defined $fix_elements[$n + 2]) {
4187 $fix_elements[$n + 2] =~ s/^\s+//;
4188 }
Joe Perches3705ce52013-07-03 15:05:31 -07004189 $line_fixed = 1;
4190 }
Andy Whitcroft22f2a2e2007-08-10 13:01:03 -07004191 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004192 }
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07004193 $off += length($elements[$n + 1]);
Joe Perches3705ce52013-07-03 15:05:31 -07004194
4195## print("n: <$n> GOOD: <$good>\n");
4196
4197 $fixed_line = $fixed_line . $good;
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004198 }
Joe Perches3705ce52013-07-03 15:05:31 -07004199
4200 if (($#elements % 2) == 0) {
4201 $fixed_line = $fixed_line . $fix_elements[$#elements];
4202 }
4203
Joe Perches194f66f2014-08-06 16:11:03 -07004204 if ($fix && $line_fixed && $fixed_line ne $fixed[$fixlinenr]) {
4205 $fixed[$fixlinenr] = $fixed_line;
Joe Perches3705ce52013-07-03 15:05:31 -07004206 }
4207
4208
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004209 }
4210
Joe Perches786b6322013-07-03 15:05:32 -07004211# check for whitespace before a non-naked semicolon
Joe Perchesd2e248e2014-01-23 15:54:41 -08004212 if ($line =~ /^\+.*\S\s+;\s*$/) {
Joe Perches786b6322013-07-03 15:05:32 -07004213 if (WARN("SPACING",
4214 "space prohibited before semicolon\n" . $herecurr) &&
4215 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07004216 1 while $fixed[$fixlinenr] =~
Joe Perches786b6322013-07-03 15:05:32 -07004217 s/^(\+.*\S)\s+;/$1;/;
4218 }
4219 }
4220
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07004221# check for multiple assignments
4222 if ($line =~ /^.\s*$Lval\s*=\s*$Lval\s*=(?!=)/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07004223 CHK("MULTIPLE_ASSIGNMENTS",
4224 "multiple assignments should be avoided\n" . $herecurr);
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07004225 }
4226
Andy Whitcroft22f2a2e2007-08-10 13:01:03 -07004227## # check for multiple declarations, allowing for a function declaration
4228## # continuation.
4229## if ($line =~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Ident.*/ &&
4230## $line !~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Type\s*$Ident.*/) {
4231##
4232## # Remove any bracketed sections to ensure we do not
4233## # falsly report the parameters of functions.
4234## my $ln = $line;
4235## while ($ln =~ s/\([^\(\)]*\)//g) {
4236## }
4237## if ($ln =~ /,/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07004238## WARN("MULTIPLE_DECLARATION",
4239## "declaring multiple variables together should be avoided\n" . $herecurr);
Andy Whitcroft22f2a2e2007-08-10 13:01:03 -07004240## }
4241## }
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07004242
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004243#need space before brace following if, while, etc
Geyslan G. Bem6b8c69e2016-03-15 14:58:09 -07004244 if (($line =~ /\(.*\)\{/ && $line !~ /\($Type\)\{/) ||
Eddie Kovsky4e5d56b2015-09-09 15:37:52 -07004245 $line =~ /do\{/) {
Joe Perches3705ce52013-07-03 15:05:31 -07004246 if (ERROR("SPACING",
4247 "space required before the open brace '{'\n" . $herecurr) &&
4248 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07004249 $fixed[$fixlinenr] =~ s/^(\+.*(?:do|\))){/$1 {/;
Joe Perches3705ce52013-07-03 15:05:31 -07004250 }
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07004251 }
4252
Joe Perchesc4a62ef2013-07-03 15:05:28 -07004253## # check for blank lines before declarations
4254## if ($line =~ /^.\t+$Type\s+$Ident(?:\s*=.*)?;/ &&
4255## $prevrawline =~ /^.\s*$/) {
4256## WARN("SPACING",
4257## "No blank lines before declarations\n" . $hereprev);
4258## }
4259##
4260
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07004261# closing brace should have a space following it when it has anything
4262# on the line
4263 if ($line =~ /}(?!(?:,|;|\)))\S/) {
Joe Perchesd5e616f2013-09-11 14:23:54 -07004264 if (ERROR("SPACING",
4265 "space required after that close brace '}'\n" . $herecurr) &&
4266 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07004267 $fixed[$fixlinenr] =~
Joe Perchesd5e616f2013-09-11 14:23:54 -07004268 s/}((?!(?:,|;|\)))\S)/} $1/;
4269 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004270 }
4271
Andy Whitcroft22f2a2e2007-08-10 13:01:03 -07004272# check spacing on square brackets
4273 if ($line =~ /\[\s/ && $line !~ /\[\s*$/) {
Joe Perches3705ce52013-07-03 15:05:31 -07004274 if (ERROR("SPACING",
4275 "space prohibited after that open square bracket '['\n" . $herecurr) &&
4276 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07004277 $fixed[$fixlinenr] =~
Joe Perches3705ce52013-07-03 15:05:31 -07004278 s/\[\s+/\[/;
4279 }
Andy Whitcroft22f2a2e2007-08-10 13:01:03 -07004280 }
4281 if ($line =~ /\s\]/) {
Joe Perches3705ce52013-07-03 15:05:31 -07004282 if (ERROR("SPACING",
4283 "space prohibited before that close square bracket ']'\n" . $herecurr) &&
4284 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07004285 $fixed[$fixlinenr] =~
Joe Perches3705ce52013-07-03 15:05:31 -07004286 s/\s+\]/\]/;
4287 }
Andy Whitcroft22f2a2e2007-08-10 13:01:03 -07004288 }
4289
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004290# check spacing on parentheses
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07004291 if ($line =~ /\(\s/ && $line !~ /\(\s*(?:\\)?$/ &&
4292 $line !~ /for\s*\(\s+;/) {
Joe Perches3705ce52013-07-03 15:05:31 -07004293 if (ERROR("SPACING",
4294 "space prohibited after that open parenthesis '('\n" . $herecurr) &&
4295 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07004296 $fixed[$fixlinenr] =~
Joe Perches3705ce52013-07-03 15:05:31 -07004297 s/\(\s+/\(/;
4298 }
Andy Whitcroft22f2a2e2007-08-10 13:01:03 -07004299 }
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004300 if ($line =~ /(\s+)\)/ && $line !~ /^.\s*\)/ &&
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004301 $line !~ /for\s*\(.*;\s+\)/ &&
4302 $line !~ /:\s+\)/) {
Joe Perches3705ce52013-07-03 15:05:31 -07004303 if (ERROR("SPACING",
4304 "space prohibited before that close parenthesis ')'\n" . $herecurr) &&
4305 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07004306 $fixed[$fixlinenr] =~
Joe Perches3705ce52013-07-03 15:05:31 -07004307 s/\s+\)/\)/;
4308 }
Andy Whitcroft22f2a2e2007-08-10 13:01:03 -07004309 }
4310
Joe Perchese2826fd2014-08-06 16:10:48 -07004311# check unnecessary parentheses around addressof/dereference single $Lvals
4312# ie: &(foo->bar) should be &foo->bar and *(foo->bar) should be *foo->bar
4313
4314 while ($line =~ /(?:[^&]&\s*|\*)\(\s*($Ident\s*(?:$Member\s*)+)\s*\)/g) {
Joe Perchesea4acbb2014-12-10 15:51:51 -08004315 my $var = $1;
4316 if (CHK("UNNECESSARY_PARENTHESES",
4317 "Unnecessary parentheses around $var\n" . $herecurr) &&
4318 $fix) {
4319 $fixed[$fixlinenr] =~ s/\(\s*\Q$var\E\s*\)/$var/;
4320 }
4321 }
4322
4323# check for unnecessary parentheses around function pointer uses
4324# ie: (foo->bar)(); should be foo->bar();
4325# but not "if (foo->bar) (" to avoid some false positives
4326 if ($line =~ /(\bif\s*|)(\(\s*$Ident\s*(?:$Member\s*)+\))[ \t]*\(/ && $1 !~ /^if/) {
4327 my $var = $2;
4328 if (CHK("UNNECESSARY_PARENTHESES",
4329 "Unnecessary parentheses around function pointer $var\n" . $herecurr) &&
4330 $fix) {
4331 my $var2 = deparenthesize($var);
4332 $var2 =~ s/\s//g;
4333 $fixed[$fixlinenr] =~ s/\Q$var\E/$var2/;
4334 }
4335 }
Joe Perchese2826fd2014-08-06 16:10:48 -07004336
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004337#goto labels aren't indented, allow a single space however
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07004338 if ($line=~/^.\s+[A-Za-z\d_]+:(?![0-9]+)/ and
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004339 !($line=~/^. [A-Za-z\d_]+:/) and !($line=~/^.\s+default:/)) {
Joe Perches3705ce52013-07-03 15:05:31 -07004340 if (WARN("INDENTED_LABEL",
4341 "labels should not be indented\n" . $herecurr) &&
4342 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07004343 $fixed[$fixlinenr] =~
Joe Perches3705ce52013-07-03 15:05:31 -07004344 s/^(.)\s+/$1/;
4345 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004346 }
4347
Joe Perches5b9553a2014-04-03 14:49:21 -07004348# return is not a function
Joe Perches507e5142013-11-12 15:10:13 -08004349 if (defined($stat) && $stat =~ /^.\s*return(\s*)\(/s) {
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004350 my $spacing = $1;
Joe Perches507e5142013-11-12 15:10:13 -08004351 if ($^V && $^V ge 5.10.0 &&
Joe Perches5b9553a2014-04-03 14:49:21 -07004352 $stat =~ /^.\s*return\s*($balanced_parens)\s*;\s*$/) {
4353 my $value = $1;
4354 $value = deparenthesize($value);
4355 if ($value =~ m/^\s*$FuncArg\s*(?:\?|$)/) {
4356 ERROR("RETURN_PARENTHESES",
4357 "return is not a function, parentheses are not required\n" . $herecurr);
4358 }
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004359 } elsif ($spacing !~ /\s+/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07004360 ERROR("SPACING",
4361 "space required before the open parenthesis '('\n" . $herecurr);
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004362 }
4363 }
Joe Perches507e5142013-11-12 15:10:13 -08004364
Joe Perchesb43ae212014-06-23 13:22:07 -07004365# unnecessary return in a void function
4366# at end-of-function, with the previous line a single leading tab, then return;
4367# and the line before that not a goto label target like "out:"
4368 if ($sline =~ /^[ \+]}\s*$/ &&
4369 $prevline =~ /^\+\treturn\s*;\s*$/ &&
4370 $linenr >= 3 &&
4371 $lines[$linenr - 3] =~ /^[ +]/ &&
4372 $lines[$linenr - 3] !~ /^[ +]\s*$Ident\s*:/) {
Joe Perches9819cf22014-06-04 16:12:09 -07004373 WARN("RETURN_VOID",
Joe Perchesb43ae212014-06-23 13:22:07 -07004374 "void function return statements are not generally useful\n" . $hereprev);
4375 }
Joe Perches9819cf22014-06-04 16:12:09 -07004376
Joe Perches189248d2014-01-23 15:54:47 -08004377# if statements using unnecessary parentheses - ie: if ((foo == bar))
4378 if ($^V && $^V ge 5.10.0 &&
4379 $line =~ /\bif\s*((?:\(\s*){2,})/) {
4380 my $openparens = $1;
4381 my $count = $openparens =~ tr@\(@\(@;
4382 my $msg = "";
4383 if ($line =~ /\bif\s*(?:\(\s*){$count,$count}$LvalOrFunc\s*($Compare)\s*$LvalOrFunc(?:\s*\)){$count,$count}/) {
4384 my $comp = $4; #Not $1 because of $LvalOrFunc
4385 $msg = " - maybe == should be = ?" if ($comp eq "==");
4386 WARN("UNNECESSARY_PARENTHESES",
4387 "Unnecessary parentheses$msg\n" . $herecurr);
4388 }
4389 }
4390
Joe Perchesc5595fa2015-09-09 15:37:58 -07004391# comparisons with a constant or upper case identifier on the left
4392# avoid cases like "foo + BAR < baz"
4393# only fix matches surrounded by parentheses to avoid incorrect
4394# conversions like "FOO < baz() + 5" being "misfixed" to "baz() > FOO + 5"
4395 if ($^V && $^V ge 5.10.0 &&
4396 $line =~ /^\+(.*)\b($Constant|[A-Z_][A-Z0-9_]*)\s*($Compare)\s*($LvalOrFunc)/) {
4397 my $lead = $1;
4398 my $const = $2;
4399 my $comp = $3;
4400 my $to = $4;
4401 my $newcomp = $comp;
Joe Perchesf39e1762016-05-20 17:04:02 -07004402 if ($lead !~ /(?:$Operators|\.)\s*$/ &&
Joe Perchesc5595fa2015-09-09 15:37:58 -07004403 $to !~ /^(?:Constant|[A-Z_][A-Z0-9_]*)$/ &&
4404 WARN("CONSTANT_COMPARISON",
4405 "Comparisons should place the constant on the right side of the test\n" . $herecurr) &&
4406 $fix) {
4407 if ($comp eq "<") {
4408 $newcomp = ">";
4409 } elsif ($comp eq "<=") {
4410 $newcomp = ">=";
4411 } elsif ($comp eq ">") {
4412 $newcomp = "<";
4413 } elsif ($comp eq ">=") {
4414 $newcomp = "<=";
4415 }
4416 $fixed[$fixlinenr] =~ s/\(\s*\Q$const\E\s*$Compare\s*\Q$to\E\s*\)/($to $newcomp $const)/;
4417 }
4418 }
4419
Joe Perchesf34e4a42015-04-16 12:44:19 -07004420# Return of what appears to be an errno should normally be negative
4421 if ($sline =~ /\breturn(?:\s*\(+\s*|\s+)(E[A-Z]+)(?:\s*\)+\s*|\s*)[;:,]/) {
Andy Whitcroft53a3c442010-10-26 14:23:14 -07004422 my $name = $1;
4423 if ($name ne 'EOF' && $name ne 'ERROR') {
Joe Perches000d1cc12011-07-25 17:13:25 -07004424 WARN("USE_NEGATIVE_ERRNO",
Joe Perchesf34e4a42015-04-16 12:44:19 -07004425 "return of an errno should typically be negative (ie: return -$1)\n" . $herecurr);
Andy Whitcroft53a3c442010-10-26 14:23:14 -07004426 }
4427 }
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004428
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004429# Need a space before open parenthesis after if, while etc
Joe Perches3705ce52013-07-03 15:05:31 -07004430 if ($line =~ /\b(if|while|for|switch)\(/) {
4431 if (ERROR("SPACING",
4432 "space required before the open parenthesis '('\n" . $herecurr) &&
4433 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07004434 $fixed[$fixlinenr] =~
Joe Perches3705ce52013-07-03 15:05:31 -07004435 s/\b(if|while|for|switch)\(/$1 \(/;
4436 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004437 }
4438
Andy Whitcroftf5fe35d2008-07-23 21:29:03 -07004439# Check for illegal assignment in if conditional -- and check for trailing
4440# statements after the conditional.
Andy Whitcroft170d3a22008-10-15 22:02:30 -07004441 if ($line =~ /do\s*(?!{)/) {
Andy Whitcroft3e469cd2012-01-10 15:10:01 -08004442 ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
4443 ctx_statement_block($linenr, $realcnt, 0)
4444 if (!defined $stat);
Andy Whitcroft170d3a22008-10-15 22:02:30 -07004445 my ($stat_next) = ctx_statement_block($line_nr_next,
4446 $remain_next, $off_next);
4447 $stat_next =~ s/\n./\n /g;
4448 ##print "stat<$stat> stat_next<$stat_next>\n";
4449
4450 if ($stat_next =~ /^\s*while\b/) {
4451 # If the statement carries leading newlines,
4452 # then count those as offsets.
4453 my ($whitespace) =
4454 ($stat_next =~ /^((?:\s*\n[+-])*\s*)/s);
4455 my $offset =
4456 statement_rawlines($whitespace) - 1;
4457
4458 $suppress_whiletrailers{$line_nr_next +
4459 $offset} = 1;
4460 }
4461 }
4462 if (!defined $suppress_whiletrailers{$linenr} &&
Joe Perchesc11230f2013-11-21 14:31:57 -08004463 defined($stat) && defined($cond) &&
Andy Whitcroft170d3a22008-10-15 22:02:30 -07004464 $line =~ /\b(?:if|while|for)\s*\(/ && $line !~ /^.\s*#/) {
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07004465 my ($s, $c) = ($stat, $cond);
Andy Whitcroft8905a672007-11-28 16:21:06 -08004466
Andy Whitcroftb53c8e12009-01-06 14:41:29 -08004467 if ($c =~ /\bif\s*\(.*[^<>!=]=[^=].*/s) {
Joe Perches000d1cc12011-07-25 17:13:25 -07004468 ERROR("ASSIGN_IN_IF",
4469 "do not use assignment in if condition\n" . $herecurr);
Andy Whitcroft8905a672007-11-28 16:21:06 -08004470 }
4471
4472 # Find out what is on the end of the line after the
4473 # conditional.
Andy Whitcroft773647a2008-03-28 14:15:58 -07004474 substr($s, 0, length($c), '');
Andy Whitcroft8905a672007-11-28 16:21:06 -08004475 $s =~ s/\n.*//g;
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004476 $s =~ s/$;//g; # Remove any comments
Andy Whitcroft53210162008-07-23 21:29:03 -07004477 if (length($c) && $s !~ /^\s*{?\s*\\*\s*$/ &&
4478 $c !~ /}\s*while\s*/)
Andy Whitcroft773647a2008-03-28 14:15:58 -07004479 {
Andy Whitcroftbb44ad32008-10-15 22:02:34 -07004480 # Find out how long the conditional actually is.
4481 my @newlines = ($c =~ /\n/gs);
4482 my $cond_lines = 1 + $#newlines;
Hidetoshi Seto42bdf742010-03-05 13:43:50 -08004483 my $stat_real = '';
Andy Whitcroftbb44ad32008-10-15 22:02:34 -07004484
Hidetoshi Seto42bdf742010-03-05 13:43:50 -08004485 $stat_real = raw_line($linenr, $cond_lines)
4486 . "\n" if ($cond_lines);
Andy Whitcroftbb44ad32008-10-15 22:02:34 -07004487 if (defined($stat_real) && $cond_lines > 1) {
4488 $stat_real = "[...]\n$stat_real";
4489 }
4490
Joe Perches000d1cc12011-07-25 17:13:25 -07004491 ERROR("TRAILING_STATEMENTS",
4492 "trailing statements should be on next line\n" . $herecurr . $stat_real);
Andy Whitcroft8905a672007-11-28 16:21:06 -08004493 }
4494 }
4495
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004496# Check for bitwise tests written as boolean
4497 if ($line =~ /
4498 (?:
4499 (?:\[|\(|\&\&|\|\|)
4500 \s*0[xX][0-9]+\s*
4501 (?:\&\&|\|\|)
4502 |
4503 (?:\&\&|\|\|)
4504 \s*0[xX][0-9]+\s*
4505 (?:\&\&|\|\||\)|\])
4506 )/x)
4507 {
Joe Perches000d1cc12011-07-25 17:13:25 -07004508 WARN("HEXADECIMAL_BOOLEAN_TEST",
4509 "boolean test with hexadecimal, perhaps just 1 \& or \|?\n" . $herecurr);
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004510 }
4511
Andy Whitcroft8905a672007-11-28 16:21:06 -08004512# if and else should not have general statements after it
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004513 if ($line =~ /^.\s*(?:}\s*)?else\b(.*)/) {
4514 my $s = $1;
4515 $s =~ s/$;//g; # Remove any comments
4516 if ($s !~ /^\s*(?:\sif|(?:{|)\s*\\?\s*$)/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07004517 ERROR("TRAILING_STATEMENTS",
4518 "trailing statements should be on next line\n" . $herecurr);
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004519 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004520 }
Andy Whitcroft39667782009-01-15 13:51:06 -08004521# if should not continue a brace
4522 if ($line =~ /}\s*if\b/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07004523 ERROR("TRAILING_STATEMENTS",
Rasmus Villemoes048b1232014-08-06 16:10:37 -07004524 "trailing statements should be on next line (or did you mean 'else if'?)\n" .
Andy Whitcroft39667782009-01-15 13:51:06 -08004525 $herecurr);
4526 }
Andy Whitcrofta1080bf2008-10-15 22:02:25 -07004527# case and default should not have general statements after them
4528 if ($line =~ /^.\s*(?:case\s*.*|default\s*):/g &&
4529 $line !~ /\G(?:
Andy Whitcroft3fef12d2008-10-15 22:02:36 -07004530 (?:\s*$;*)(?:\s*{)?(?:\s*$;*)(?:\s*\\)?\s*$|
Andy Whitcrofta1080bf2008-10-15 22:02:25 -07004531 \s*return\s+
4532 )/xg)
4533 {
Joe Perches000d1cc12011-07-25 17:13:25 -07004534 ERROR("TRAILING_STATEMENTS",
4535 "trailing statements should be on next line\n" . $herecurr);
Andy Whitcrofta1080bf2008-10-15 22:02:25 -07004536 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004537
4538 # Check for }<nl>else {, these must be at the same
4539 # indent level to be relevant to each other.
Joe Perches8b8856f2014-08-06 16:11:14 -07004540 if ($prevline=~/}\s*$/ and $line=~/^.\s*else\s*/ &&
4541 $previndent == $indent) {
4542 if (ERROR("ELSE_AFTER_BRACE",
4543 "else should follow close brace '}'\n" . $hereprev) &&
4544 $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
4545 fix_delete_line($fixlinenr - 1, $prevrawline);
4546 fix_delete_line($fixlinenr, $rawline);
4547 my $fixedline = $prevrawline;
4548 $fixedline =~ s/}\s*$//;
4549 if ($fixedline !~ /^\+\s*$/) {
4550 fix_insert_line($fixlinenr, $fixedline);
4551 }
4552 $fixedline = $rawline;
4553 $fixedline =~ s/^(.\s*)else/$1} else/;
4554 fix_insert_line($fixlinenr, $fixedline);
4555 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004556 }
4557
Joe Perches8b8856f2014-08-06 16:11:14 -07004558 if ($prevline=~/}\s*$/ and $line=~/^.\s*while\s*/ &&
4559 $previndent == $indent) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08004560 my ($s, $c) = ctx_statement_block($linenr, $realcnt, 0);
4561
4562 # Find out what is on the end of the line after the
4563 # conditional.
Andy Whitcroft773647a2008-03-28 14:15:58 -07004564 substr($s, 0, length($c), '');
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08004565 $s =~ s/\n.*//g;
4566
4567 if ($s =~ /^\s*;/) {
Joe Perches8b8856f2014-08-06 16:11:14 -07004568 if (ERROR("WHILE_AFTER_BRACE",
4569 "while should follow close brace '}'\n" . $hereprev) &&
4570 $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
4571 fix_delete_line($fixlinenr - 1, $prevrawline);
4572 fix_delete_line($fixlinenr, $rawline);
4573 my $fixedline = $prevrawline;
4574 my $trailing = $rawline;
4575 $trailing =~ s/^\+//;
4576 $trailing = trim($trailing);
4577 $fixedline =~ s/}\s*$/} $trailing/;
4578 fix_insert_line($fixlinenr, $fixedline);
4579 }
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08004580 }
4581 }
4582
Joe Perches95e2c602013-07-03 15:05:20 -07004583#Specific variable tests
Joe Perches323c1262012-12-17 16:02:07 -08004584 while ($line =~ m{($Constant|$Lval)}g) {
4585 my $var = $1;
Joe Perches95e2c602013-07-03 15:05:20 -07004586
4587#gcc binary extension
4588 if ($var =~ /^$Binary$/) {
Joe Perchesd5e616f2013-09-11 14:23:54 -07004589 if (WARN("GCC_BINARY_CONSTANT",
4590 "Avoid gcc v4.3+ binary constant extension: <$var>\n" . $herecurr) &&
4591 $fix) {
4592 my $hexval = sprintf("0x%x", oct($var));
Joe Perches194f66f2014-08-06 16:11:03 -07004593 $fixed[$fixlinenr] =~
Joe Perchesd5e616f2013-09-11 14:23:54 -07004594 s/\b$var\b/$hexval/;
4595 }
Joe Perches95e2c602013-07-03 15:05:20 -07004596 }
4597
4598#CamelCase
Joe Perches807bd262013-07-03 15:05:22 -07004599 if ($var !~ /^$Constant$/ &&
Joe Perchesbe797942013-07-03 15:05:20 -07004600 $var =~ /[A-Z][a-z]|[a-z][A-Z]/ &&
Joe Perches22735ce2013-07-03 15:05:33 -07004601#Ignore Page<foo> variants
Joe Perches807bd262013-07-03 15:05:22 -07004602 $var !~ /^(?:Clear|Set|TestClear|TestSet|)Page[A-Z]/ &&
Joe Perches22735ce2013-07-03 15:05:33 -07004603#Ignore SI style variants like nS, mV and dB (ie: max_uV, regulator_min_uA_show)
Julius Wernerf5123572014-12-10 15:51:54 -08004604 $var !~ /^(?:[a-z_]*?)_?[a-z][A-Z](?:_[a-z_]+)?$/ &&
4605#Ignore some three character SI units explicitly, like MiB and KHz
4606 $var !~ /^(?:[a-z_]*?)_?(?:[KMGT]iB|[KMGT]?Hz)(?:_[a-z_]+)?$/) {
Joe Perches7e781f62013-09-11 14:23:55 -07004607 while ($var =~ m{($Ident)}g) {
4608 my $word = $1;
4609 next if ($word !~ /[A-Z][a-z]|[a-z][A-Z]/);
Joe Perchesd8b07712013-11-12 15:10:06 -08004610 if ($check) {
4611 seed_camelcase_includes();
4612 if (!$file && !$camelcase_file_seeded) {
4613 seed_camelcase_file($realfile);
4614 $camelcase_file_seeded = 1;
4615 }
4616 }
Joe Perches7e781f62013-09-11 14:23:55 -07004617 if (!defined $camelcase{$word}) {
4618 $camelcase{$word} = 1;
4619 CHK("CAMELCASE",
4620 "Avoid CamelCase: <$word>\n" . $herecurr);
4621 }
Joe Perches34456862013-07-03 15:05:34 -07004622 }
Joe Perches323c1262012-12-17 16:02:07 -08004623 }
4624 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004625
4626#no spaces allowed after \ in define
Joe Perchesd5e616f2013-09-11 14:23:54 -07004627 if ($line =~ /\#\s*define.*\\\s+$/) {
4628 if (WARN("WHITESPACE_AFTER_LINE_CONTINUATION",
4629 "Whitespace after \\ makes next lines useless\n" . $herecurr) &&
4630 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07004631 $fixed[$fixlinenr] =~ s/\s+$//;
Joe Perchesd5e616f2013-09-11 14:23:54 -07004632 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004633 }
4634
Fabian Frederick0e212e02015-04-16 12:44:25 -07004635# warn if <asm/foo.h> is #included and <linux/foo.h> is available and includes
4636# itself <asm/foo.h> (uses RAW line)
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004637 if ($tree && $rawline =~ m{^.\s*\#\s*include\s*\<asm\/(.*)\.h\>}) {
Andy Whitcrofte09dec42008-10-15 22:02:20 -07004638 my $file = "$1.h";
4639 my $checkfile = "include/linux/$file";
4640 if (-f "$root/$checkfile" &&
4641 $realfile ne $checkfile &&
Wolfram Sang7840a942010-08-09 17:20:57 -07004642 $1 !~ /$allowed_asm_includes/)
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004643 {
Fabian Frederick0e212e02015-04-16 12:44:25 -07004644 my $asminclude = `grep -Ec "#include\\s+<asm/$file>" $root/$checkfile`;
4645 if ($asminclude > 0) {
4646 if ($realfile =~ m{^arch/}) {
4647 CHK("ARCH_INCLUDE_LINUX",
4648 "Consider using #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
4649 } else {
4650 WARN("INCLUDE_LINUX",
4651 "Use #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
4652 }
Andy Whitcrofte09dec42008-10-15 22:02:20 -07004653 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004654 }
4655 }
4656
Andy Whitcroft653d4872007-06-23 17:16:34 -07004657# multi-statement macros should be enclosed in a do while loop, grab the
4658# first statement and ensure its the whole macro if its not enclosed
Andy Whitcroftcf655042008-03-04 14:28:20 -08004659# in a known good container
Andy Whitcroftb8f96a32008-07-23 21:29:07 -07004660 if ($realfile !~ m@/vmlinux.lds.h$@ &&
4661 $line =~ /^.\s*\#\s*define\s*$Ident(\()?/) {
Andy Whitcroftd8aaf122007-06-23 17:16:44 -07004662 my $ln = $linenr;
4663 my $cnt = $realcnt;
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004664 my ($off, $dstat, $dcond, $rest);
4665 my $ctx = '';
Joe Perches08a28432014-10-13 15:51:55 -07004666 my $has_flow_statement = 0;
4667 my $has_arg_concat = 0;
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004668 ($dstat, $dcond, $ln, $cnt, $off) =
Andy Whitcroftf74bd192012-01-10 15:09:54 -08004669 ctx_statement_block($linenr, $realcnt, 0);
4670 $ctx = $dstat;
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004671 #print "dstat<$dstat> dcond<$dcond> cnt<$cnt> off<$off>\n";
Andy Whitcrofta3bb97a2008-07-23 21:29:00 -07004672 #print "LINE<$lines[$ln-1]> len<" . length($lines[$ln-1]) . "\n";
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004673
Joe Perches08a28432014-10-13 15:51:55 -07004674 $has_flow_statement = 1 if ($ctx =~ /\b(goto|return)\b/);
Joe Perches62e15a62016-01-20 14:59:18 -08004675 $has_arg_concat = 1 if ($ctx =~ /\#\#/ && $ctx !~ /\#\#\s*(?:__VA_ARGS__|args)\b/);
Joe Perches08a28432014-10-13 15:51:55 -07004676
Andy Whitcroftf74bd192012-01-10 15:09:54 -08004677 $dstat =~ s/^.\s*\#\s*define\s+$Ident(?:\([^\)]*\))?\s*//;
Andy Whitcroft292f1a92008-07-23 21:29:11 -07004678 $dstat =~ s/$;//g;
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004679 $dstat =~ s/\\\n.//g;
4680 $dstat =~ s/^\s*//s;
4681 $dstat =~ s/\s*$//s;
4682
4683 # Flatten any parentheses and braces
Andy Whitcroftbf30d6e2008-10-15 22:02:33 -07004684 while ($dstat =~ s/\([^\(\)]*\)/1/ ||
4685 $dstat =~ s/\{[^\{\}]*\}/1/ ||
Vladimir Zapolskiy6b10df42016-01-20 14:59:21 -08004686 $dstat =~ s/.\[[^\[\]]*\]/1/)
Andy Whitcroftbf30d6e2008-10-15 22:02:33 -07004687 {
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07004688 }
Andy Whitcroftd8aaf122007-06-23 17:16:44 -07004689
Andy Whitcrofte45bab82012-03-23 15:02:18 -07004690 # Flatten any obvious string concatentation.
Joe Perches33acb542015-06-25 15:02:54 -07004691 while ($dstat =~ s/($String)\s*$Ident/$1/ ||
4692 $dstat =~ s/$Ident\s*($String)/$1/)
Andy Whitcrofte45bab82012-03-23 15:02:18 -07004693 {
4694 }
4695
Joe Perches42e15292016-03-15 14:58:01 -07004696 # Make asm volatile uses seem like a generic function
4697 $dstat =~ s/\b_*asm_*\s+_*volatile_*\b/asm_volatile/g;
4698
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004699 my $exceptions = qr{
4700 $Declare|
4701 module_param_named|
Kees Cooka0a0a7a2012-10-04 17:13:38 -07004702 MODULE_PARM_DESC|
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004703 DECLARE_PER_CPU|
4704 DEFINE_PER_CPU|
Andy Whitcroft383099f2009-01-06 14:41:18 -08004705 __typeof__\(|
Stefani Seibold22fd2d32010-03-05 13:43:52 -08004706 union|
4707 struct|
Andy Whitcroftea71a0a2009-09-21 17:04:38 -07004708 \.$Ident\s*=\s*|
Vladimir Zapolskiy6b10df42016-01-20 14:59:21 -08004709 ^\"|\"$|
4710 ^\[
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004711 }x;
Andy Whitcroft5eaa20b2010-10-26 14:23:18 -07004712 #print "REST<$rest> dstat<$dstat> ctx<$ctx>\n";
Andy Whitcroftf74bd192012-01-10 15:09:54 -08004713 if ($dstat ne '' &&
4714 $dstat !~ /^(?:$Ident|-?$Constant),$/ && # 10, // foo(),
4715 $dstat !~ /^(?:$Ident|-?$Constant);$/ && # foo();
Joe Perches3cc4b1c2013-07-03 15:05:27 -07004716 $dstat !~ /^[!~-]?(?:$Lval|$Constant)$/ && # 10 // foo() // !foo // ~foo // -foo // foo->bar // foo.bar->baz
Joe Perches356fd392014-08-06 16:10:31 -07004717 $dstat !~ /^'X'$/ && $dstat !~ /^'XX'$/ && # character constants
Andy Whitcroftf74bd192012-01-10 15:09:54 -08004718 $dstat !~ /$exceptions/ &&
4719 $dstat !~ /^\.$Ident\s*=/ && # .foo =
Joe Perchese942e2c2013-04-17 15:58:26 -07004720 $dstat !~ /^(?:\#\s*$Ident|\#\s*$Constant)\s*$/ && # stringification #foo
Andy Whitcroft72f115f2012-01-10 15:10:06 -08004721 $dstat !~ /^do\s*$Constant\s*while\s*$Constant;?$/ && # do {...} while (...); // do {...} while (...)
Andy Whitcroftf74bd192012-01-10 15:09:54 -08004722 $dstat !~ /^for\s*$Constant$/ && # for (...)
4723 $dstat !~ /^for\s*$Constant\s+(?:$Ident|-?$Constant)$/ && # for (...) bar()
4724 $dstat !~ /^do\s*{/ && # do {...
Eddie Kovsky4e5d56b2015-09-09 15:37:52 -07004725 $dstat !~ /^\(\{/ && # ({...
Joe Perchesf95a7e62013-09-11 14:24:00 -07004726 $ctx !~ /^.\s*#\s*define\s+TRACE_(?:SYSTEM|INCLUDE_FILE|INCLUDE_PATH)\b/)
Andy Whitcroftf74bd192012-01-10 15:09:54 -08004727 {
4728 $ctx =~ s/\n*$//;
4729 my $herectx = $here . "\n";
4730 my $cnt = statement_rawlines($ctx);
4731
4732 for (my $n = 0; $n < $cnt; $n++) {
4733 $herectx .= raw_line($linenr, $n) . "\n";
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004734 }
4735
Andy Whitcroftf74bd192012-01-10 15:09:54 -08004736 if ($dstat =~ /;/) {
4737 ERROR("MULTISTATEMENT_MACRO_USE_DO_WHILE",
4738 "Macros with multiple statements should be enclosed in a do - while loop\n" . "$herectx");
4739 } else {
Joe Perches000d1cc12011-07-25 17:13:25 -07004740 ERROR("COMPLEX_MACRO",
Andrew Morton388982b2014-10-13 15:51:40 -07004741 "Macros with complex values should be enclosed in parentheses\n" . "$herectx");
Andy Whitcroftd8aaf122007-06-23 17:16:44 -07004742 }
Andy Whitcroft653d4872007-06-23 17:16:34 -07004743 }
Joe Perches5023d342012-12-17 16:01:47 -08004744
Joe Perches08a28432014-10-13 15:51:55 -07004745# check for macros with flow control, but without ## concatenation
4746# ## concatenation is commonly a macro that defines a function so ignore those
4747 if ($has_flow_statement && !$has_arg_concat) {
4748 my $herectx = $here . "\n";
4749 my $cnt = statement_rawlines($ctx);
4750
4751 for (my $n = 0; $n < $cnt; $n++) {
4752 $herectx .= raw_line($linenr, $n) . "\n";
4753 }
4754 WARN("MACRO_WITH_FLOW_CONTROL",
4755 "Macros with flow control statements should be avoided\n" . "$herectx");
4756 }
4757
Joe Perches481eb482012-12-17 16:01:56 -08004758# check for line continuations outside of #defines, preprocessor #, and asm
Joe Perches5023d342012-12-17 16:01:47 -08004759
4760 } else {
4761 if ($prevline !~ /^..*\\$/ &&
Joe Perches481eb482012-12-17 16:01:56 -08004762 $line !~ /^\+\s*\#.*\\$/ && # preprocessor
4763 $line !~ /^\+.*\b(__asm__|asm)\b.*\\$/ && # asm
Joe Perches5023d342012-12-17 16:01:47 -08004764 $line =~ /^\+.*\\$/) {
4765 WARN("LINE_CONTINUATIONS",
4766 "Avoid unnecessary line continuations\n" . $herecurr);
4767 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004768 }
4769
Joe Perchesb13edf72012-07-30 14:41:24 -07004770# do {} while (0) macro tests:
4771# single-statement macros do not need to be enclosed in do while (0) loop,
4772# macro should not end with a semicolon
4773 if ($^V && $^V ge 5.10.0 &&
4774 $realfile !~ m@/vmlinux.lds.h$@ &&
4775 $line =~ /^.\s*\#\s*define\s+$Ident(\()?/) {
4776 my $ln = $linenr;
4777 my $cnt = $realcnt;
4778 my ($off, $dstat, $dcond, $rest);
4779 my $ctx = '';
4780 ($dstat, $dcond, $ln, $cnt, $off) =
4781 ctx_statement_block($linenr, $realcnt, 0);
4782 $ctx = $dstat;
4783
4784 $dstat =~ s/\\\n.//g;
Joe Perches1b36b202015-02-13 14:38:32 -08004785 $dstat =~ s/$;/ /g;
Joe Perchesb13edf72012-07-30 14:41:24 -07004786
4787 if ($dstat =~ /^\+\s*#\s*define\s+$Ident\s*${balanced_parens}\s*do\s*{(.*)\s*}\s*while\s*\(\s*0\s*\)\s*([;\s]*)\s*$/) {
4788 my $stmts = $2;
4789 my $semis = $3;
4790
4791 $ctx =~ s/\n*$//;
4792 my $cnt = statement_rawlines($ctx);
4793 my $herectx = $here . "\n";
4794
4795 for (my $n = 0; $n < $cnt; $n++) {
4796 $herectx .= raw_line($linenr, $n) . "\n";
4797 }
4798
Joe Perchesac8e97f2012-08-21 16:15:53 -07004799 if (($stmts =~ tr/;/;/) == 1 &&
4800 $stmts !~ /^\s*(if|while|for|switch)\b/) {
Joe Perchesb13edf72012-07-30 14:41:24 -07004801 WARN("SINGLE_STATEMENT_DO_WHILE_MACRO",
4802 "Single statement macros should not use a do {} while (0) loop\n" . "$herectx");
4803 }
4804 if (defined $semis && $semis ne "") {
4805 WARN("DO_WHILE_MACRO_WITH_TRAILING_SEMICOLON",
4806 "do {} while (0) macros should not be semicolon terminated\n" . "$herectx");
4807 }
Joe Perchesf5ef95b2014-06-04 16:12:06 -07004808 } elsif ($dstat =~ /^\+\s*#\s*define\s+$Ident.*;\s*$/) {
4809 $ctx =~ s/\n*$//;
4810 my $cnt = statement_rawlines($ctx);
4811 my $herectx = $here . "\n";
4812
4813 for (my $n = 0; $n < $cnt; $n++) {
4814 $herectx .= raw_line($linenr, $n) . "\n";
4815 }
4816
4817 WARN("TRAILING_SEMICOLON",
4818 "macros should not use a trailing semicolon\n" . "$herectx");
Joe Perchesb13edf72012-07-30 14:41:24 -07004819 }
4820 }
4821
Mike Frysinger080ba922009-01-06 14:41:25 -08004822# make sure symbols are always wrapped with VMLINUX_SYMBOL() ...
4823# all assignments may have only one of the following with an assignment:
4824# .
4825# ALIGN(...)
4826# VMLINUX_SYMBOL(...)
4827 if ($realfile eq 'vmlinux.lds.h' && $line =~ /(?:(?:^|\s)$Ident\s*=|=\s*$Ident(?:\s|$))/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07004828 WARN("MISSING_VMLINUX_SYMBOL",
4829 "vmlinux.lds.h needs VMLINUX_SYMBOL() around C-visible symbols\n" . $herecurr);
Mike Frysinger080ba922009-01-06 14:41:25 -08004830 }
4831
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07004832# check for redundant bracing round if etc
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004833 if ($line =~ /(^.*)\bif\b/ && $1 !~ /else\s*$/) {
4834 my ($level, $endln, @chunks) =
Andy Whitcroftcf655042008-03-04 14:28:20 -08004835 ctx_statement_full($linenr, $realcnt, 1);
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004836 #print "chunks<$#chunks> linenr<$linenr> endln<$endln> level<$level>\n";
Andy Whitcroftcf655042008-03-04 14:28:20 -08004837 #print "APW: <<$chunks[1][0]>><<$chunks[1][1]>>\n";
4838 if ($#chunks > 0 && $level == 0) {
Joe Perchesaad4f612012-03-23 15:02:19 -07004839 my @allowed = ();
4840 my $allow = 0;
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004841 my $seen = 0;
Andy Whitcroft773647a2008-03-28 14:15:58 -07004842 my $herectx = $here . "\n";
Andy Whitcroftcf655042008-03-04 14:28:20 -08004843 my $ln = $linenr - 1;
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004844 for my $chunk (@chunks) {
4845 my ($cond, $block) = @{$chunk};
4846
Andy Whitcroft773647a2008-03-28 14:15:58 -07004847 # If the condition carries leading newlines, then count those as offsets.
4848 my ($whitespace) = ($cond =~ /^((?:\s*\n[+-])*\s*)/s);
4849 my $offset = statement_rawlines($whitespace) - 1;
4850
Joe Perchesaad4f612012-03-23 15:02:19 -07004851 $allowed[$allow] = 0;
Andy Whitcroft773647a2008-03-28 14:15:58 -07004852 #print "COND<$cond> whitespace<$whitespace> offset<$offset>\n";
4853
4854 # We have looked at and allowed this specific line.
4855 $suppress_ifbraces{$ln + $offset} = 1;
4856
4857 $herectx .= "$rawlines[$ln + $offset]\n[...]\n";
Andy Whitcroftcf655042008-03-04 14:28:20 -08004858 $ln += statement_rawlines($block) - 1;
4859
Andy Whitcroft773647a2008-03-28 14:15:58 -07004860 substr($block, 0, length($cond), '');
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004861
4862 $seen++ if ($block =~ /^\s*{/);
4863
Joe Perchesaad4f612012-03-23 15:02:19 -07004864 #print "cond<$cond> block<$block> allowed<$allowed[$allow]>\n";
Andy Whitcroftcf655042008-03-04 14:28:20 -08004865 if (statement_lines($cond) > 1) {
4866 #print "APW: ALLOWED: cond<$cond>\n";
Joe Perchesaad4f612012-03-23 15:02:19 -07004867 $allowed[$allow] = 1;
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004868 }
4869 if ($block =~/\b(?:if|for|while)\b/) {
Andy Whitcroftcf655042008-03-04 14:28:20 -08004870 #print "APW: ALLOWED: block<$block>\n";
Joe Perchesaad4f612012-03-23 15:02:19 -07004871 $allowed[$allow] = 1;
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004872 }
Andy Whitcroftcf655042008-03-04 14:28:20 -08004873 if (statement_block_size($block) > 1) {
4874 #print "APW: ALLOWED: lines block<$block>\n";
Joe Perchesaad4f612012-03-23 15:02:19 -07004875 $allowed[$allow] = 1;
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004876 }
Joe Perchesaad4f612012-03-23 15:02:19 -07004877 $allow++;
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004878 }
Joe Perchesaad4f612012-03-23 15:02:19 -07004879 if ($seen) {
4880 my $sum_allowed = 0;
4881 foreach (@allowed) {
4882 $sum_allowed += $_;
4883 }
4884 if ($sum_allowed == 0) {
4885 WARN("BRACES",
4886 "braces {} are not necessary for any arm of this statement\n" . $herectx);
4887 } elsif ($sum_allowed != $allow &&
4888 $seen != $allow) {
4889 CHK("BRACES",
4890 "braces {} should be used on all arms of this statement\n" . $herectx);
4891 }
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004892 }
4893 }
4894 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07004895 if (!defined $suppress_ifbraces{$linenr - 1} &&
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004896 $line =~ /\b(if|while|for|else)\b/) {
Andy Whitcroftcf655042008-03-04 14:28:20 -08004897 my $allowed = 0;
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07004898
Andy Whitcroftcf655042008-03-04 14:28:20 -08004899 # Check the pre-context.
4900 if (substr($line, 0, $-[0]) =~ /(\}\s*)$/) {
4901 #print "APW: ALLOWED: pre<$1>\n";
4902 $allowed = 1;
4903 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07004904
4905 my ($level, $endln, @chunks) =
4906 ctx_statement_full($linenr, $realcnt, $-[0]);
4907
Andy Whitcroftcf655042008-03-04 14:28:20 -08004908 # Check the condition.
4909 my ($cond, $block) = @{$chunks[0]};
Andy Whitcroft773647a2008-03-28 14:15:58 -07004910 #print "CHECKING<$linenr> cond<$cond> block<$block>\n";
Andy Whitcroftcf655042008-03-04 14:28:20 -08004911 if (defined $cond) {
Andy Whitcroft773647a2008-03-28 14:15:58 -07004912 substr($block, 0, length($cond), '');
Andy Whitcroftcf655042008-03-04 14:28:20 -08004913 }
4914 if (statement_lines($cond) > 1) {
4915 #print "APW: ALLOWED: cond<$cond>\n";
4916 $allowed = 1;
4917 }
4918 if ($block =~/\b(?:if|for|while)\b/) {
4919 #print "APW: ALLOWED: block<$block>\n";
4920 $allowed = 1;
4921 }
4922 if (statement_block_size($block) > 1) {
4923 #print "APW: ALLOWED: lines block<$block>\n";
4924 $allowed = 1;
4925 }
4926 # Check the post-context.
4927 if (defined $chunks[1]) {
4928 my ($cond, $block) = @{$chunks[1]};
4929 if (defined $cond) {
Andy Whitcroft773647a2008-03-28 14:15:58 -07004930 substr($block, 0, length($cond), '');
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07004931 }
Andy Whitcroftcf655042008-03-04 14:28:20 -08004932 if ($block =~ /^\s*\{/) {
4933 #print "APW: ALLOWED: chunk-1 block<$block>\n";
4934 $allowed = 1;
4935 }
4936 }
4937 if ($level == 0 && $block =~ /^\s*\{/ && !$allowed) {
Justin P. Mattock69932482011-07-26 23:06:29 -07004938 my $herectx = $here . "\n";
Andy Whitcroftf0556632008-10-15 22:02:23 -07004939 my $cnt = statement_rawlines($block);
Andy Whitcroftcf655042008-03-04 14:28:20 -08004940
Andy Whitcroftf0556632008-10-15 22:02:23 -07004941 for (my $n = 0; $n < $cnt; $n++) {
Justin P. Mattock69932482011-07-26 23:06:29 -07004942 $herectx .= raw_line($linenr, $n) . "\n";
Andy Whitcroftcf655042008-03-04 14:28:20 -08004943 }
4944
Joe Perches000d1cc12011-07-25 17:13:25 -07004945 WARN("BRACES",
4946 "braces {} are not necessary for single statement blocks\n" . $herectx);
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07004947 }
4948 }
4949
Joe Perches0979ae62012-12-17 16:01:59 -08004950# check for unnecessary blank lines around braces
Joe Perches77b9a532013-07-03 15:05:29 -07004951 if (($line =~ /^.\s*}\s*$/ && $prevrawline =~ /^.\s*$/)) {
Joe Perchesf8e58212015-02-13 14:38:46 -08004952 if (CHK("BRACES",
4953 "Blank lines aren't necessary before a close brace '}'\n" . $hereprev) &&
4954 $fix && $prevrawline =~ /^\+/) {
4955 fix_delete_line($fixlinenr - 1, $prevrawline);
4956 }
Joe Perches0979ae62012-12-17 16:01:59 -08004957 }
Joe Perches77b9a532013-07-03 15:05:29 -07004958 if (($rawline =~ /^.\s*$/ && $prevline =~ /^..*{\s*$/)) {
Joe Perchesf8e58212015-02-13 14:38:46 -08004959 if (CHK("BRACES",
4960 "Blank lines aren't necessary after an open brace '{'\n" . $hereprev) &&
4961 $fix) {
4962 fix_delete_line($fixlinenr, $rawline);
4963 }
Joe Perches0979ae62012-12-17 16:01:59 -08004964 }
4965
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07004966# no volatiles please
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07004967 my $asm_volatile = qr{\b(__asm__|asm)\s+(__volatile__|volatile)\b};
4968 if ($line =~ /\bvolatile\b/ && $line !~ /$asm_volatile/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07004969 WARN("VOLATILE",
4970 "Use of volatile is usually wrong: see Documentation/volatile-considered-harmful.txt\n" . $herecurr);
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07004971 }
4972
Joe Perches5e4f6ba2014-12-10 15:52:05 -08004973# Check for user-visible strings broken across lines, which breaks the ability
4974# to grep for the string. Make exceptions when the previous string ends in a
4975# newline (multiple lines in one string constant) or '\t', '\r', ';', or '{'
4976# (common in inline assembly) or is a octal \123 or hexadecimal \xaf value
Joe Perches33acb542015-06-25 15:02:54 -07004977 if ($line =~ /^\+\s*$String/ &&
Joe Perches5e4f6ba2014-12-10 15:52:05 -08004978 $prevline =~ /"\s*$/ &&
4979 $prevrawline !~ /(?:\\(?:[ntr]|[0-7]{1,3}|x[0-9a-fA-F]{1,2})|;\s*|\{\s*)"\s*$/) {
4980 if (WARN("SPLIT_STRING",
4981 "quoted string split across lines\n" . $hereprev) &&
4982 $fix &&
4983 $prevrawline =~ /^\+.*"\s*$/ &&
4984 $last_coalesced_string_linenr != $linenr - 1) {
4985 my $extracted_string = get_quoted_string($line, $rawline);
4986 my $comma_close = "";
4987 if ($rawline =~ /\Q$extracted_string\E(\s*\)\s*;\s*$|\s*,\s*)/) {
4988 $comma_close = $1;
4989 }
4990
4991 fix_delete_line($fixlinenr - 1, $prevrawline);
4992 fix_delete_line($fixlinenr, $rawline);
4993 my $fixedline = $prevrawline;
4994 $fixedline =~ s/"\s*$//;
4995 $fixedline .= substr($extracted_string, 1) . trim($comma_close);
4996 fix_insert_line($fixlinenr - 1, $fixedline);
4997 $fixedline = $rawline;
4998 $fixedline =~ s/\Q$extracted_string\E\Q$comma_close\E//;
4999 if ($fixedline !~ /\+\s*$/) {
5000 fix_insert_line($fixlinenr, $fixedline);
5001 }
5002 $last_coalesced_string_linenr = $linenr;
5003 }
5004 }
5005
5006# check for missing a space in a string concatenation
5007 if ($prevrawline =~ /[^\\]\w"$/ && $rawline =~ /^\+[\t ]+"\w/) {
5008 WARN('MISSING_SPACE',
5009 "break quoted strings at a space character\n" . $hereprev);
5010 }
5011
5012# check for spaces before a quoted newline
5013 if ($rawline =~ /^.*\".*\s\\n/) {
5014 if (WARN("QUOTED_WHITESPACE_BEFORE_NEWLINE",
5015 "unnecessary whitespace before a quoted newline\n" . $herecurr) &&
5016 $fix) {
5017 $fixed[$fixlinenr] =~ s/^(\+.*\".*)\s+\\n/$1\\n/;
5018 }
5019
5020 }
5021
Joe Perchesf17dba42014-10-13 15:51:51 -07005022# concatenated string without spaces between elements
Joe Perches33acb542015-06-25 15:02:54 -07005023 if ($line =~ /$String[A-Z_]/ || $line =~ /[A-Za-z0-9_]$String/) {
Joe Perchesf17dba42014-10-13 15:51:51 -07005024 CHK("CONCATENATED_STRING",
5025 "Concatenated strings should use spaces between elements\n" . $herecurr);
5026 }
5027
Joe Perches90ad30e2014-12-10 15:51:59 -08005028# uncoalesced string fragments
Joe Perches33acb542015-06-25 15:02:54 -07005029 if ($line =~ /$String\s*"/) {
Joe Perches90ad30e2014-12-10 15:51:59 -08005030 WARN("STRING_FRAGMENTS",
5031 "Consecutive strings are generally better as a single string\n" . $herecurr);
5032 }
5033
Joe Perches6e300752015-09-09 15:37:47 -07005034# check for %L{u,d,i} and 0x%[udi] in strings
Joe Perches5e4f6ba2014-12-10 15:52:05 -08005035 my $string;
5036 while ($line =~ /(?:^|")([X\t]*)(?:"|$)/g) {
5037 $string = substr($rawline, $-[1], $+[1] - $-[1]);
5038 $string =~ s/%%/__/g;
Joe Perches6e300752015-09-09 15:37:47 -07005039 if ($string =~ /(?<!%)%[\*\d\.\$]*L[udi]/) {
Joe Perches5e4f6ba2014-12-10 15:52:05 -08005040 WARN("PRINTF_L",
5041 "\%Ld/%Lu are not-standard C, use %lld/%llu\n" . $herecurr);
5042 last;
5043 }
Joe Perches6e300752015-09-09 15:37:47 -07005044 if ($string =~ /0x%[\*\d\.\$\Llzth]*[udi]/) {
5045 ERROR("PRINTF_0xDECIMAL",
5046 "Prefixing 0x with decimal output is defective\n" . $herecurr);
5047 }
Joe Perches5e4f6ba2014-12-10 15:52:05 -08005048 }
5049
5050# check for line continuations in quoted strings with odd counts of "
5051 if ($rawline =~ /\\$/ && $rawline =~ tr/"/"/ % 2) {
5052 WARN("LINE_CONTINUATIONS",
5053 "Avoid line continuations in quoted strings\n" . $herecurr);
5054 }
5055
Andy Whitcroft00df3442007-06-08 13:47:06 -07005056# warn about #if 0
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07005057 if ($line =~ /^.\s*\#\s*if\s+0\b/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005058 CHK("REDUNDANT_CODE",
5059 "if this code is redundant consider removing it\n" .
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07005060 $herecurr);
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07005061 }
5062
Andy Whitcroft03df4b52012-12-17 16:01:52 -08005063# check for needless "if (<foo>) fn(<foo>)" uses
5064 if ($prevline =~ /\bif\s*\(\s*($Lval)\s*\)/) {
Joe Perches100425d2015-09-09 15:37:36 -07005065 my $tested = quotemeta($1);
5066 my $expr = '\s*\(\s*' . $tested . '\s*\)\s*;';
5067 if ($line =~ /\b(kfree|usb_free_urb|debugfs_remove(?:_recursive)?|(?:kmem_cache|mempool|dma_pool)_destroy)$expr/) {
5068 my $func = $1;
5069 if (WARN('NEEDLESS_IF',
5070 "$func(NULL) is safe and this check is probably not required\n" . $hereprev) &&
5071 $fix) {
5072 my $do_fix = 1;
5073 my $leading_tabs = "";
5074 my $new_leading_tabs = "";
5075 if ($lines[$linenr - 2] =~ /^\+(\t*)if\s*\(\s*$tested\s*\)\s*$/) {
5076 $leading_tabs = $1;
5077 } else {
5078 $do_fix = 0;
5079 }
5080 if ($lines[$linenr - 1] =~ /^\+(\t+)$func\s*\(\s*$tested\s*\)\s*;\s*$/) {
5081 $new_leading_tabs = $1;
5082 if (length($leading_tabs) + 1 ne length($new_leading_tabs)) {
5083 $do_fix = 0;
5084 }
5085 } else {
5086 $do_fix = 0;
5087 }
5088 if ($do_fix) {
5089 fix_delete_line($fixlinenr - 1, $prevrawline);
5090 $fixed[$fixlinenr] =~ s/^\+$new_leading_tabs/\+$leading_tabs/;
5091 }
5092 }
Greg Kroah-Hartman4c432a82008-07-23 21:29:04 -07005093 }
5094 }
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07005095
Joe Perchesebfdc402014-08-06 16:10:27 -07005096# check for unnecessary "Out of Memory" messages
5097 if ($line =~ /^\+.*\b$logFunctions\s*\(/ &&
5098 $prevline =~ /^[ \+]\s*if\s*\(\s*(\!\s*|NULL\s*==\s*)?($Lval)(\s*==\s*NULL\s*)?\s*\)/ &&
5099 (defined $1 || defined $3) &&
5100 $linenr > 3) {
5101 my $testval = $2;
5102 my $testline = $lines[$linenr - 3];
5103
5104 my ($s, $c) = ctx_statement_block($linenr - 3, $realcnt, 0);
5105# print("line: <$line>\nprevline: <$prevline>\ns: <$s>\nc: <$c>\n\n\n");
5106
5107 if ($c =~ /(?:^|\n)[ \+]\s*(?:$Type\s*)?\Q$testval\E\s*=\s*(?:\([^\)]*\)\s*)?\s*(?:devm_)?(?:[kv][czm]alloc(?:_node|_array)?\b|kstrdup|(?:dev_)?alloc_skb)/) {
5108 WARN("OOM_MESSAGE",
5109 "Possible unnecessary 'out of memory' message\n" . $hereprev);
5110 }
5111 }
5112
Joe Perchesf78d98f2014-10-13 15:52:01 -07005113# check for logging functions with KERN_<LEVEL>
Paolo Bonzinidcaf1122015-02-13 14:38:26 -08005114 if ($line !~ /printk(?:_ratelimited|_once)?\s*\(/ &&
Joe Perchesf78d98f2014-10-13 15:52:01 -07005115 $line =~ /\b$logFunctions\s*\(.*\b(KERN_[A-Z]+)\b/) {
5116 my $level = $1;
5117 if (WARN("UNNECESSARY_KERN_LEVEL",
5118 "Possible unnecessary $level\n" . $herecurr) &&
5119 $fix) {
5120 $fixed[$fixlinenr] =~ s/\s*$level\s*//;
5121 }
5122 }
5123
Joe Perchesabb08a52014-12-10 15:51:46 -08005124# check for mask then right shift without a parentheses
5125 if ($^V && $^V ge 5.10.0 &&
5126 $line =~ /$LvalOrFunc\s*\&\s*($LvalOrFunc)\s*>>/ &&
5127 $4 !~ /^\&/) { # $LvalOrFunc may be &foo, ignore if so
5128 WARN("MASK_THEN_SHIFT",
5129 "Possible precedence defect with mask then right shift - may need parentheses\n" . $herecurr);
5130 }
5131
Joe Perchesb75ac612014-12-10 15:52:02 -08005132# check for pointer comparisons to NULL
5133 if ($^V && $^V ge 5.10.0) {
5134 while ($line =~ /\b$LvalOrFunc\s*(==|\!=)\s*NULL\b/g) {
5135 my $val = $1;
5136 my $equal = "!";
5137 $equal = "" if ($4 eq "!=");
5138 if (CHK("COMPARISON_TO_NULL",
5139 "Comparison to NULL could be written \"${equal}${val}\"\n" . $herecurr) &&
5140 $fix) {
5141 $fixed[$fixlinenr] =~ s/\b\Q$val\E\s*(?:==|\!=)\s*NULL\b/$equal$val/;
5142 }
5143 }
5144 }
5145
Joe Perches8716de32013-09-11 14:24:05 -07005146# check for bad placement of section $InitAttribute (e.g.: __initdata)
5147 if ($line =~ /(\b$InitAttribute\b)/) {
5148 my $attr = $1;
5149 if ($line =~ /^\+\s*static\s+(?:const\s+)?(?:$attr\s+)?($NonptrTypeWithAttr)\s+(?:$attr\s+)?($Ident(?:\[[^]]*\])?)\s*[=;]/) {
5150 my $ptr = $1;
5151 my $var = $2;
5152 if ((($ptr =~ /\b(union|struct)\s+$attr\b/ &&
5153 ERROR("MISPLACED_INIT",
5154 "$attr should be placed after $var\n" . $herecurr)) ||
5155 ($ptr !~ /\b(union|struct)\s+$attr\b/ &&
5156 WARN("MISPLACED_INIT",
5157 "$attr should be placed after $var\n" . $herecurr))) &&
5158 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07005159 $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;
Joe Perches8716de32013-09-11 14:24:05 -07005160 }
5161 }
5162 }
5163
Joe Perchese970b882013-11-12 15:10:10 -08005164# check for $InitAttributeData (ie: __initdata) with const
5165 if ($line =~ /\bconst\b/ && $line =~ /($InitAttributeData)/) {
5166 my $attr = $1;
5167 $attr =~ /($InitAttributePrefix)(.*)/;
5168 my $attr_prefix = $1;
5169 my $attr_type = $2;
5170 if (ERROR("INIT_ATTRIBUTE",
5171 "Use of const init definition must use ${attr_prefix}initconst\n" . $herecurr) &&
5172 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07005173 $fixed[$fixlinenr] =~
Joe Perchese970b882013-11-12 15:10:10 -08005174 s/$InitAttributeData/${attr_prefix}initconst/;
5175 }
5176 }
5177
5178# check for $InitAttributeConst (ie: __initconst) without const
5179 if ($line !~ /\bconst\b/ && $line =~ /($InitAttributeConst)/) {
5180 my $attr = $1;
5181 if (ERROR("INIT_ATTRIBUTE",
5182 "Use of $attr requires a separate use of const\n" . $herecurr) &&
5183 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07005184 my $lead = $fixed[$fixlinenr] =~
Joe Perchese970b882013-11-12 15:10:10 -08005185 /(^\+\s*(?:static\s+))/;
5186 $lead = rtrim($1);
5187 $lead = "$lead " if ($lead !~ /^\+$/);
5188 $lead = "${lead}const ";
Joe Perches194f66f2014-08-06 16:11:03 -07005189 $fixed[$fixlinenr] =~ s/(^\+\s*(?:static\s+))/$lead/;
Joe Perchese970b882013-11-12 15:10:10 -08005190 }
5191 }
5192
Joe Perchesc17893c2015-04-16 12:44:42 -07005193# check for __read_mostly with const non-pointer (should just be const)
5194 if ($line =~ /\b__read_mostly\b/ &&
5195 $line =~ /($Type)\s*$Ident/ && $1 !~ /\*\s*$/ && $1 =~ /\bconst\b/) {
5196 if (ERROR("CONST_READ_MOSTLY",
5197 "Invalid use of __read_mostly with const type\n" . $herecurr) &&
5198 $fix) {
5199 $fixed[$fixlinenr] =~ s/\s+__read_mostly\b//;
5200 }
5201 }
5202
Joe Perchesfbdb8132014-04-03 14:49:14 -07005203# don't use __constant_<foo> functions outside of include/uapi/
5204 if ($realfile !~ m@^include/uapi/@ &&
5205 $line =~ /(__constant_(?:htons|ntohs|[bl]e(?:16|32|64)_to_cpu|cpu_to_[bl]e(?:16|32|64)))\s*\(/) {
5206 my $constant_func = $1;
5207 my $func = $constant_func;
5208 $func =~ s/^__constant_//;
5209 if (WARN("CONSTANT_CONVERSION",
5210 "$constant_func should be $func\n" . $herecurr) &&
5211 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07005212 $fixed[$fixlinenr] =~ s/\b$constant_func\b/$func/g;
Joe Perchesfbdb8132014-04-03 14:49:14 -07005213 }
5214 }
5215
Patrick Pannuto1a15a252010-08-09 17:21:01 -07005216# prefer usleep_range over udelay
Bruce Allan37581c22013-02-21 16:44:19 -08005217 if ($line =~ /\budelay\s*\(\s*(\d+)\s*\)/) {
Joe Perches43c1d772014-04-03 14:49:11 -07005218 my $delay = $1;
Patrick Pannuto1a15a252010-08-09 17:21:01 -07005219 # ignore udelay's < 10, however
Joe Perches43c1d772014-04-03 14:49:11 -07005220 if (! ($delay < 10) ) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005221 CHK("USLEEP_RANGE",
Joe Perches43c1d772014-04-03 14:49:11 -07005222 "usleep_range is preferred over udelay; see Documentation/timers/timers-howto.txt\n" . $herecurr);
5223 }
5224 if ($delay > 2000) {
5225 WARN("LONG_UDELAY",
5226 "long udelay - prefer mdelay; see arch/arm/include/asm/delay.h\n" . $herecurr);
Patrick Pannuto1a15a252010-08-09 17:21:01 -07005227 }
5228 }
5229
Patrick Pannuto09ef8722010-08-09 17:21:02 -07005230# warn about unexpectedly long msleep's
5231 if ($line =~ /\bmsleep\s*\((\d+)\);/) {
5232 if ($1 < 20) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005233 WARN("MSLEEP",
Joe Perches43c1d772014-04-03 14:49:11 -07005234 "msleep < 20ms can sleep for up to 20ms; see Documentation/timers/timers-howto.txt\n" . $herecurr);
Patrick Pannuto09ef8722010-08-09 17:21:02 -07005235 }
5236 }
5237
Joe Perches36ec1932013-07-03 15:05:25 -07005238# check for comparisons of jiffies
5239 if ($line =~ /\bjiffies\s*$Compare|$Compare\s*jiffies\b/) {
5240 WARN("JIFFIES_COMPARISON",
5241 "Comparing jiffies is almost always wrong; prefer time_after, time_before and friends\n" . $herecurr);
5242 }
5243
Joe Perches9d7a34a2013-07-03 15:05:26 -07005244# check for comparisons of get_jiffies_64()
5245 if ($line =~ /\bget_jiffies_64\s*\(\s*\)\s*$Compare|$Compare\s*get_jiffies_64\s*\(\s*\)/) {
5246 WARN("JIFFIES_COMPARISON",
5247 "Comparing get_jiffies_64() is almost always wrong; prefer time_after64, time_before64 and friends\n" . $herecurr);
5248 }
5249
Andy Whitcroft00df3442007-06-08 13:47:06 -07005250# warn about #ifdefs in C files
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07005251# if ($line =~ /^.\s*\#\s*if(|n)def/ && ($realfile =~ /\.c$/)) {
Andy Whitcroft00df3442007-06-08 13:47:06 -07005252# print "#ifdef in C files should be avoided\n";
5253# print "$herecurr";
5254# $clean = 0;
5255# }
5256
Andy Whitcroft22f2a2e2007-08-10 13:01:03 -07005257# warn about spacing in #ifdefs
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07005258 if ($line =~ /^.\s*\#\s*(ifdef|ifndef|elif)\s\s+/) {
Joe Perches3705ce52013-07-03 15:05:31 -07005259 if (ERROR("SPACING",
5260 "exactly one space required after that #$1\n" . $herecurr) &&
5261 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07005262 $fixed[$fixlinenr] =~
Joe Perches3705ce52013-07-03 15:05:31 -07005263 s/^(.\s*\#\s*(ifdef|ifndef|elif))\s{2,}/$1 /;
5264 }
5265
Andy Whitcroft22f2a2e2007-08-10 13:01:03 -07005266 }
5267
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07005268# check for spinlock_t definitions without a comment.
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07005269 if ($line =~ /^.\s*(struct\s+mutex|spinlock_t)\s+\S+;/ ||
5270 $line =~ /^.\s*(DEFINE_MUTEX)\s*\(/) {
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07005271 my $which = $1;
5272 if (!ctx_has_comment($first_line, $linenr)) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005273 CHK("UNCOMMENTED_DEFINITION",
5274 "$1 definition without comment\n" . $herecurr);
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07005275 }
5276 }
5277# check for memory barriers without a comment.
Michael S. Tsirkin402c2552016-01-04 09:39:01 +02005278
5279 my $barriers = qr{
5280 mb|
5281 rmb|
5282 wmb|
5283 read_barrier_depends
5284 }x;
5285 my $barrier_stems = qr{
5286 mb__before_atomic|
5287 mb__after_atomic|
5288 store_release|
5289 load_acquire|
5290 store_mb|
5291 (?:$barriers)
5292 }x;
5293 my $all_barriers = qr{
5294 (?:$barriers)|
Michael S. Tsirkin43e361f2016-01-04 10:00:10 +02005295 smp_(?:$barrier_stems)|
5296 virt_(?:$barrier_stems)
Michael S. Tsirkin402c2552016-01-04 09:39:01 +02005297 }x;
5298
5299 if ($line =~ /\b(?:$all_barriers)\s*\(/) {
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07005300 if (!ctx_has_comment($first_line, $linenr)) {
Joe Perchesc1fd7bb2013-11-12 15:10:11 -08005301 WARN("MEMORY_BARRIER",
5302 "memory barrier without comment\n" . $herecurr);
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07005303 }
5304 }
Paul E. McKenney3ad81772015-07-02 11:55:40 -07005305
Michael S. Tsirkinf4073b02016-01-04 09:54:51 +02005306 my $underscore_smp_barriers = qr{__smp_(?:$barrier_stems)}x;
5307
5308 if ($realfile !~ m@^include/asm-generic/@ &&
5309 $realfile !~ m@/barrier\.h$@ &&
5310 $line =~ m/\b(?:$underscore_smp_barriers)\s*\(/ &&
5311 $line !~ m/^.\s*\#\s*define\s+(?:$underscore_smp_barriers)\s*\(/) {
5312 WARN("MEMORY_BARRIER",
5313 "__smp memory barriers shouldn't be used outside barrier.h and asm-generic\n" . $herecurr);
5314 }
5315
Joe Perchescb426e92015-06-25 15:02:46 -07005316# check for waitqueue_active without a comment.
5317 if ($line =~ /\bwaitqueue_active\s*\(/) {
5318 if (!ctx_has_comment($first_line, $linenr)) {
5319 WARN("WAITQUEUE_ACTIVE",
5320 "waitqueue_active without comment\n" . $herecurr);
5321 }
5322 }
Paul E. McKenney3ad81772015-07-02 11:55:40 -07005323
5324# Check for expedited grace periods that interrupt non-idle non-nohz
5325# online CPUs. These expedited can therefore degrade real-time response
5326# if used carelessly, and should be avoided where not absolutely
5327# needed. It is always OK to use synchronize_rcu_expedited() and
5328# synchronize_sched_expedited() at boot time (before real-time applications
5329# start) and in error situations where real-time response is compromised in
5330# any case. Note that synchronize_srcu_expedited() does -not- interrupt
5331# other CPUs, so don't warn on uses of synchronize_srcu_expedited().
5332# Of course, nothing comes for free, and srcu_read_lock() and
5333# srcu_read_unlock() do contain full memory barriers in payment for
5334# synchronize_srcu_expedited() non-interruption properties.
5335 if ($line =~ /\b(synchronize_rcu_expedited|synchronize_sched_expedited)\(/) {
5336 WARN("EXPEDITED_RCU_GRACE_PERIOD",
5337 "expedited RCU grace periods should be avoided where they can degrade real-time response\n" . $herecurr);
5338
5339 }
5340
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07005341# check of hardware specific defines
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07005342 if ($line =~ m@^.\s*\#\s*if.*\b(__i386__|__powerpc64__|__sun__|__s390x__)\b@ && $realfile !~ m@include/asm-@) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005343 CHK("ARCH_DEFINES",
5344 "architecture specific defines should be avoided\n" . $herecurr);
Andy Whitcroft0a920b52007-06-01 00:46:48 -07005345 }
Andy Whitcroft653d4872007-06-23 17:16:34 -07005346
Tobias Klauserd4977c72010-05-24 14:33:30 -07005347# Check that the storage class is at the beginning of a declaration
5348 if ($line =~ /\b$Storage\b/ && $line !~ /^.\s*$Storage\b/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005349 WARN("STORAGE_CLASS",
5350 "storage class should be at the beginning of the declaration\n" . $herecurr)
Tobias Klauserd4977c72010-05-24 14:33:30 -07005351 }
5352
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07005353# check the location of the inline attribute, that it is between
5354# storage class and type.
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07005355 if ($line =~ /\b$Type\s+$Inline\b/ ||
5356 $line =~ /\b$Inline\s+$Storage\b/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005357 ERROR("INLINE_LOCATION",
5358 "inline keyword should sit between storage class and type\n" . $herecurr);
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07005359 }
5360
Andy Whitcroft8905a672007-11-28 16:21:06 -08005361# Check for __inline__ and __inline, prefer inline
Joe Perches2b7ab452013-11-12 15:10:14 -08005362 if ($realfile !~ m@\binclude/uapi/@ &&
5363 $line =~ /\b(__inline__|__inline)\b/) {
Joe Perchesd5e616f2013-09-11 14:23:54 -07005364 if (WARN("INLINE",
5365 "plain inline is preferred over $1\n" . $herecurr) &&
5366 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07005367 $fixed[$fixlinenr] =~ s/\b(__inline__|__inline)\b/inline/;
Joe Perchesd5e616f2013-09-11 14:23:54 -07005368
5369 }
Andy Whitcroft8905a672007-11-28 16:21:06 -08005370 }
5371
Joe Perches3d130fd2011-01-12 17:00:00 -08005372# Check for __attribute__ packed, prefer __packed
Joe Perches2b7ab452013-11-12 15:10:14 -08005373 if ($realfile !~ m@\binclude/uapi/@ &&
5374 $line =~ /\b__attribute__\s*\(\s*\(.*\bpacked\b/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005375 WARN("PREFER_PACKED",
5376 "__packed is preferred over __attribute__((packed))\n" . $herecurr);
Joe Perches3d130fd2011-01-12 17:00:00 -08005377 }
5378
Joe Perches39b7e282011-07-25 17:13:24 -07005379# Check for __attribute__ aligned, prefer __aligned
Joe Perches2b7ab452013-11-12 15:10:14 -08005380 if ($realfile !~ m@\binclude/uapi/@ &&
5381 $line =~ /\b__attribute__\s*\(\s*\(.*aligned/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005382 WARN("PREFER_ALIGNED",
5383 "__aligned(size) is preferred over __attribute__((aligned(size)))\n" . $herecurr);
Joe Perches39b7e282011-07-25 17:13:24 -07005384 }
5385
Joe Perches5f14d3b2012-01-10 15:09:52 -08005386# Check for __attribute__ format(printf, prefer __printf
Joe Perches2b7ab452013-11-12 15:10:14 -08005387 if ($realfile !~ m@\binclude/uapi/@ &&
5388 $line =~ /\b__attribute__\s*\(\s*\(\s*format\s*\(\s*printf/) {
Joe Perchesd5e616f2013-09-11 14:23:54 -07005389 if (WARN("PREFER_PRINTF",
5390 "__printf(string-index, first-to-check) is preferred over __attribute__((format(printf, string-index, first-to-check)))\n" . $herecurr) &&
5391 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07005392 $fixed[$fixlinenr] =~ s/\b__attribute__\s*\(\s*\(\s*format\s*\(\s*printf\s*,\s*(.*)\)\s*\)\s*\)/"__printf(" . trim($1) . ")"/ex;
Joe Perchesd5e616f2013-09-11 14:23:54 -07005393
5394 }
Joe Perches5f14d3b2012-01-10 15:09:52 -08005395 }
5396
Joe Perches6061d942012-03-23 15:02:16 -07005397# Check for __attribute__ format(scanf, prefer __scanf
Joe Perches2b7ab452013-11-12 15:10:14 -08005398 if ($realfile !~ m@\binclude/uapi/@ &&
5399 $line =~ /\b__attribute__\s*\(\s*\(\s*format\s*\(\s*scanf\b/) {
Joe Perchesd5e616f2013-09-11 14:23:54 -07005400 if (WARN("PREFER_SCANF",
5401 "__scanf(string-index, first-to-check) is preferred over __attribute__((format(scanf, string-index, first-to-check)))\n" . $herecurr) &&
5402 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07005403 $fixed[$fixlinenr] =~ s/\b__attribute__\s*\(\s*\(\s*format\s*\(\s*scanf\s*,\s*(.*)\)\s*\)\s*\)/"__scanf(" . trim($1) . ")"/ex;
Joe Perchesd5e616f2013-09-11 14:23:54 -07005404 }
Joe Perches6061d942012-03-23 15:02:16 -07005405 }
5406
Joe Perches619a9082014-12-10 15:51:35 -08005407# Check for __attribute__ weak, or __weak declarations (may have link issues)
5408 if ($^V && $^V ge 5.10.0 &&
5409 $line =~ /(?:$Declare|$DeclareMisordered)\s*$Ident\s*$balanced_parens\s*(?:$Attribute)?\s*;/ &&
5410 ($line =~ /\b__attribute__\s*\(\s*\(.*\bweak\b/ ||
5411 $line =~ /\b__weak\b/)) {
5412 ERROR("WEAK_DECLARATION",
5413 "Using weak declarations can have unintended link defects\n" . $herecurr);
5414 }
5415
Joe Perchese6176fa2015-06-25 15:02:49 -07005416# check for c99 types like uint8_t used outside of uapi/
5417 if ($realfile !~ m@\binclude/uapi/@ &&
5418 $line =~ /\b($Declare)\s*$Ident\s*[=;,\[]/) {
5419 my $type = $1;
5420 if ($type =~ /\b($typeC99Typedefs)\b/) {
5421 $type = $1;
5422 my $kernel_type = 'u';
5423 $kernel_type = 's' if ($type =~ /^_*[si]/);
5424 $type =~ /(\d+)/;
5425 $kernel_type .= $1;
5426 if (CHK("PREFER_KERNEL_TYPES",
5427 "Prefer kernel type '$kernel_type' over '$type'\n" . $herecurr) &&
5428 $fix) {
5429 $fixed[$fixlinenr] =~ s/\b$type\b/$kernel_type/;
5430 }
5431 }
5432 }
5433
Joe Perches938224b2016-01-20 14:59:15 -08005434# check for cast of C90 native int or longer types constants
5435 if ($line =~ /(\(\s*$C90_int_types\s*\)\s*)($Constant)\b/) {
5436 my $cast = $1;
5437 my $const = $2;
5438 if (WARN("TYPECAST_INT_CONSTANT",
5439 "Unnecessary typecast of c90 int constant\n" . $herecurr) &&
5440 $fix) {
5441 my $suffix = "";
5442 my $newconst = $const;
5443 $newconst =~ s/${Int_type}$//;
5444 $suffix .= 'U' if ($cast =~ /\bunsigned\b/);
5445 if ($cast =~ /\blong\s+long\b/) {
5446 $suffix .= 'LL';
5447 } elsif ($cast =~ /\blong\b/) {
5448 $suffix .= 'L';
5449 }
5450 $fixed[$fixlinenr] =~ s/\Q$cast\E$const\b/$newconst$suffix/;
5451 }
5452 }
5453
Joe Perches8f53a9b2010-03-05 13:43:48 -08005454# check for sizeof(&)
5455 if ($line =~ /\bsizeof\s*\(\s*\&/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005456 WARN("SIZEOF_ADDRESS",
5457 "sizeof(& should be avoided\n" . $herecurr);
Joe Perches8f53a9b2010-03-05 13:43:48 -08005458 }
5459
Joe Perches66c80b62012-07-30 14:41:22 -07005460# check for sizeof without parenthesis
5461 if ($line =~ /\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/) {
Joe Perchesd5e616f2013-09-11 14:23:54 -07005462 if (WARN("SIZEOF_PARENTHESIS",
5463 "sizeof $1 should be sizeof($1)\n" . $herecurr) &&
5464 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07005465 $fixed[$fixlinenr] =~ s/\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/"sizeof(" . trim($1) . ")"/ex;
Joe Perchesd5e616f2013-09-11 14:23:54 -07005466 }
Joe Perches66c80b62012-07-30 14:41:22 -07005467 }
5468
Joe Perches88982fe2012-12-17 16:02:00 -08005469# check for struct spinlock declarations
5470 if ($line =~ /^.\s*\bstruct\s+spinlock\s+\w+\s*;/) {
5471 WARN("USE_SPINLOCK_T",
5472 "struct spinlock should be spinlock_t\n" . $herecurr);
5473 }
5474
Joe Perchesa6962d72013-04-29 16:18:13 -07005475# check for seq_printf uses that could be seq_puts
Joe Perches06668722013-11-12 15:10:07 -08005476 if ($sline =~ /\bseq_printf\s*\(.*"\s*\)\s*;\s*$/) {
Joe Perchesa6962d72013-04-29 16:18:13 -07005477 my $fmt = get_quoted_string($line, $rawline);
Heba Aamercaac1d52015-02-13 14:38:49 -08005478 $fmt =~ s/%%//g;
5479 if ($fmt !~ /%/) {
Joe Perchesd5e616f2013-09-11 14:23:54 -07005480 if (WARN("PREFER_SEQ_PUTS",
5481 "Prefer seq_puts to seq_printf\n" . $herecurr) &&
5482 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07005483 $fixed[$fixlinenr] =~ s/\bseq_printf\b/seq_puts/;
Joe Perchesd5e616f2013-09-11 14:23:54 -07005484 }
Joe Perchesa6962d72013-04-29 16:18:13 -07005485 }
5486 }
5487
Andy Whitcroft554e1652012-01-10 15:09:57 -08005488# Check for misused memsets
Joe Perchesd1fe9c02012-03-23 15:02:16 -07005489 if ($^V && $^V ge 5.10.0 &&
5490 defined $stat &&
Mateusz Kulikowski9e20a852015-06-25 15:03:16 -07005491 $stat =~ /^\+(?:.*?)\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*$FuncArg\s*\)/) {
Andy Whitcroft554e1652012-01-10 15:09:57 -08005492
Joe Perchesd7c76ba2012-01-10 15:09:58 -08005493 my $ms_addr = $2;
Joe Perchesd1fe9c02012-03-23 15:02:16 -07005494 my $ms_val = $7;
5495 my $ms_size = $12;
Joe Perchesd7c76ba2012-01-10 15:09:58 -08005496
Andy Whitcroft554e1652012-01-10 15:09:57 -08005497 if ($ms_size =~ /^(0x|)0$/i) {
5498 ERROR("MEMSET",
Joe Perchesd7c76ba2012-01-10 15:09:58 -08005499 "memset to 0's uses 0 as the 2nd argument, not the 3rd\n" . "$here\n$stat\n");
Andy Whitcroft554e1652012-01-10 15:09:57 -08005500 } elsif ($ms_size =~ /^(0x|)1$/i) {
5501 WARN("MEMSET",
Joe Perchesd7c76ba2012-01-10 15:09:58 -08005502 "single byte memset is suspicious. Swapped 2nd/3rd argument?\n" . "$here\n$stat\n");
5503 }
5504 }
5505
Joe Perches98a9bba2014-01-23 15:54:52 -08005506# Check for memcpy(foo, bar, ETH_ALEN) that could be ether_addr_copy(foo, bar)
5507 if ($^V && $^V ge 5.10.0 &&
Mateusz Kulikowski10895d22015-06-25 15:03:21 -07005508 defined $stat &&
5509 $stat =~ /^\+(?:.*?)\bmemcpy\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/) {
Joe Perches98a9bba2014-01-23 15:54:52 -08005510 if (WARN("PREFER_ETHER_ADDR_COPY",
Mateusz Kulikowski10895d22015-06-25 15:03:21 -07005511 "Prefer ether_addr_copy() over memcpy() if the Ethernet addresses are __aligned(2)\n" . "$here\n$stat\n") &&
Joe Perches98a9bba2014-01-23 15:54:52 -08005512 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07005513 $fixed[$fixlinenr] =~ s/\bmemcpy\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/ether_addr_copy($2, $7)/;
Joe Perches98a9bba2014-01-23 15:54:52 -08005514 }
5515 }
5516
Mateusz Kulikowskib6117d12015-06-25 15:03:13 -07005517# Check for memcmp(foo, bar, ETH_ALEN) that could be ether_addr_equal*(foo, bar)
5518 if ($^V && $^V ge 5.10.0 &&
5519 defined $stat &&
5520 $stat =~ /^\+(?:.*?)\bmemcmp\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/) {
5521 WARN("PREFER_ETHER_ADDR_EQUAL",
5522 "Prefer ether_addr_equal() or ether_addr_equal_unaligned() over memcmp()\n" . "$here\n$stat\n")
5523 }
5524
Mateusz Kulikowski8617cd02015-06-25 15:03:19 -07005525# check for memset(foo, 0x0, ETH_ALEN) that could be eth_zero_addr
5526# check for memset(foo, 0xFF, ETH_ALEN) that could be eth_broadcast_addr
5527 if ($^V && $^V ge 5.10.0 &&
5528 defined $stat &&
5529 $stat =~ /^\+(?:.*?)\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/) {
5530
5531 my $ms_val = $7;
5532
5533 if ($ms_val =~ /^(?:0x|)0+$/i) {
5534 if (WARN("PREFER_ETH_ZERO_ADDR",
5535 "Prefer eth_zero_addr over memset()\n" . "$here\n$stat\n") &&
5536 $fix) {
5537 $fixed[$fixlinenr] =~ s/\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*,\s*ETH_ALEN\s*\)/eth_zero_addr($2)/;
5538 }
5539 } elsif ($ms_val =~ /^(?:0xff|255)$/i) {
5540 if (WARN("PREFER_ETH_BROADCAST_ADDR",
5541 "Prefer eth_broadcast_addr() over memset()\n" . "$here\n$stat\n") &&
5542 $fix) {
5543 $fixed[$fixlinenr] =~ s/\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*,\s*ETH_ALEN\s*\)/eth_broadcast_addr($2)/;
5544 }
5545 }
5546 }
5547
Joe Perchesd7c76ba2012-01-10 15:09:58 -08005548# typecasts on min/max could be min_t/max_t
Joe Perchesd1fe9c02012-03-23 15:02:16 -07005549 if ($^V && $^V ge 5.10.0 &&
5550 defined $stat &&
Joe Perchesd7c76ba2012-01-10 15:09:58 -08005551 $stat =~ /^\+(?:.*?)\b(min|max)\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\)/) {
Joe Perchesd1fe9c02012-03-23 15:02:16 -07005552 if (defined $2 || defined $7) {
Joe Perchesd7c76ba2012-01-10 15:09:58 -08005553 my $call = $1;
5554 my $cast1 = deparenthesize($2);
5555 my $arg1 = $3;
Joe Perchesd1fe9c02012-03-23 15:02:16 -07005556 my $cast2 = deparenthesize($7);
5557 my $arg2 = $8;
Joe Perchesd7c76ba2012-01-10 15:09:58 -08005558 my $cast;
5559
Joe Perchesd1fe9c02012-03-23 15:02:16 -07005560 if ($cast1 ne "" && $cast2 ne "" && $cast1 ne $cast2) {
Joe Perchesd7c76ba2012-01-10 15:09:58 -08005561 $cast = "$cast1 or $cast2";
5562 } elsif ($cast1 ne "") {
5563 $cast = $cast1;
5564 } else {
5565 $cast = $cast2;
5566 }
5567 WARN("MINMAX",
5568 "$call() should probably be ${call}_t($cast, $arg1, $arg2)\n" . "$here\n$stat\n");
Andy Whitcroft554e1652012-01-10 15:09:57 -08005569 }
5570 }
5571
Joe Perches4a273192012-07-30 14:41:20 -07005572# check usleep_range arguments
5573 if ($^V && $^V ge 5.10.0 &&
5574 defined $stat &&
5575 $stat =~ /^\+(?:.*?)\busleep_range\s*\(\s*($FuncArg)\s*,\s*($FuncArg)\s*\)/) {
5576 my $min = $1;
5577 my $max = $7;
5578 if ($min eq $max) {
5579 WARN("USLEEP_RANGE",
5580 "usleep_range should not use min == max args; see Documentation/timers/timers-howto.txt\n" . "$here\n$stat\n");
5581 } elsif ($min =~ /^\d+$/ && $max =~ /^\d+$/ &&
5582 $min > $max) {
5583 WARN("USLEEP_RANGE",
5584 "usleep_range args reversed, use min then max; see Documentation/timers/timers-howto.txt\n" . "$here\n$stat\n");
5585 }
5586 }
5587
Joe Perches823b7942013-11-12 15:10:15 -08005588# check for naked sscanf
5589 if ($^V && $^V ge 5.10.0 &&
5590 defined $stat &&
Joe Perches6c8bd702014-04-03 14:49:16 -07005591 $line =~ /\bsscanf\b/ &&
Joe Perches823b7942013-11-12 15:10:15 -08005592 ($stat !~ /$Ident\s*=\s*sscanf\s*$balanced_parens/ &&
5593 $stat !~ /\bsscanf\s*$balanced_parens\s*(?:$Compare)/ &&
5594 $stat !~ /(?:$Compare)\s*\bsscanf\s*$balanced_parens/)) {
5595 my $lc = $stat =~ tr@\n@@;
5596 $lc = $lc + $linenr;
5597 my $stat_real = raw_line($linenr, 0);
5598 for (my $count = $linenr + 1; $count <= $lc; $count++) {
5599 $stat_real = $stat_real . "\n" . raw_line($count, 0);
5600 }
5601 WARN("NAKED_SSCANF",
5602 "unchecked sscanf return value\n" . "$here\n$stat_real\n");
5603 }
5604
Joe Perchesafc819a2014-06-04 16:12:08 -07005605# check for simple sscanf that should be kstrto<foo>
5606 if ($^V && $^V ge 5.10.0 &&
5607 defined $stat &&
5608 $line =~ /\bsscanf\b/) {
5609 my $lc = $stat =~ tr@\n@@;
5610 $lc = $lc + $linenr;
5611 my $stat_real = raw_line($linenr, 0);
5612 for (my $count = $linenr + 1; $count <= $lc; $count++) {
5613 $stat_real = $stat_real . "\n" . raw_line($count, 0);
5614 }
5615 if ($stat_real =~ /\bsscanf\b\s*\(\s*$FuncArg\s*,\s*("[^"]+")/) {
5616 my $format = $6;
5617 my $count = $format =~ tr@%@%@;
5618 if ($count == 1 &&
5619 $format =~ /^"\%(?i:ll[udxi]|[udxi]ll|ll|[hl]h?[udxi]|[udxi][hl]h?|[hl]h?|[udxi])"$/) {
5620 WARN("SSCANF_TO_KSTRTO",
5621 "Prefer kstrto<type> to single variable sscanf\n" . "$here\n$stat_real\n");
5622 }
5623 }
5624 }
5625
Joe Perches70dc8a42013-09-11 14:23:58 -07005626# check for new externs in .h files.
5627 if ($realfile =~ /\.h$/ &&
5628 $line =~ /^\+\s*(extern\s+)$Type\s*$Ident\s*\(/s) {
Joe Perchesd1d85782013-09-24 15:27:46 -07005629 if (CHK("AVOID_EXTERNS",
5630 "extern prototypes should be avoided in .h files\n" . $herecurr) &&
Joe Perches70dc8a42013-09-11 14:23:58 -07005631 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07005632 $fixed[$fixlinenr] =~ s/(.*)\bextern\b\s*(.*)/$1$2/;
Joe Perches70dc8a42013-09-11 14:23:58 -07005633 }
5634 }
5635
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07005636# check for new externs in .c files.
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07005637 if ($realfile =~ /\.c$/ && defined $stat &&
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07005638 $stat =~ /^.\s*(?:extern\s+)?$Type\s+($Ident)(\s*)\(/s)
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07005639 {
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07005640 my $function_name = $1;
5641 my $paren_space = $2;
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07005642
5643 my $s = $stat;
5644 if (defined $cond) {
5645 substr($s, 0, length($cond), '');
5646 }
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07005647 if ($s =~ /^\s*;/ &&
5648 $function_name ne 'uninitialized_var')
5649 {
Joe Perches000d1cc12011-07-25 17:13:25 -07005650 WARN("AVOID_EXTERNS",
5651 "externs should be avoided in .c files\n" . $herecurr);
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07005652 }
5653
5654 if ($paren_space =~ /\n/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005655 WARN("FUNCTION_ARGUMENTS",
5656 "arguments for function declarations should follow identifier\n" . $herecurr);
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07005657 }
Andy Whitcroft9c9ba342008-04-29 00:59:33 -07005658
5659 } elsif ($realfile =~ /\.c$/ && defined $stat &&
5660 $stat =~ /^.\s*extern\s+/)
5661 {
Joe Perches000d1cc12011-07-25 17:13:25 -07005662 WARN("AVOID_EXTERNS",
5663 "externs should be avoided in .c files\n" . $herecurr);
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07005664 }
5665
5666# checks for new __setup's
5667 if ($rawline =~ /\b__setup\("([^"]*)"/) {
5668 my $name = $1;
5669
5670 if (!grep(/$name/, @setup_docs)) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005671 CHK("UNDOCUMENTED_SETUP",
5672 "__setup appears un-documented -- check Documentation/kernel-parameters.txt\n" . $herecurr);
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07005673 }
Andy Whitcroft653d4872007-06-23 17:16:34 -07005674 }
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07005675
5676# check for pointless casting of kmalloc return
Joe Perchescaf2a542011-01-12 16:59:56 -08005677 if ($line =~ /\*\s*\)\s*[kv][czm]alloc(_node){0,1}\b/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005678 WARN("UNNECESSARY_CASTS",
5679 "unnecessary cast may hide bugs, see http://c-faq.com/malloc/mallocnocast.html\n" . $herecurr);
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07005680 }
Andy Whitcroft13214ad2008-02-08 04:22:03 -08005681
Joe Perchesa640d252013-07-03 15:05:21 -07005682# alloc style
5683# p = alloc(sizeof(struct foo), ...) should be p = alloc(sizeof(*p), ...)
5684 if ($^V && $^V ge 5.10.0 &&
5685 $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*([kv][mz]alloc(?:_node)?)\s*\(\s*(sizeof\s*\(\s*struct\s+$Lval\s*\))/) {
5686 CHK("ALLOC_SIZEOF_STRUCT",
5687 "Prefer $3(sizeof(*$1)...) over $3($4...)\n" . $herecurr);
5688 }
5689
Joe Perches60a55362014-06-04 16:12:07 -07005690# check for k[mz]alloc with multiplies that could be kmalloc_array/kcalloc
5691 if ($^V && $^V ge 5.10.0 &&
Joe Perchese3674552014-08-06 16:10:55 -07005692 $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*(k[mz]alloc)\s*\(\s*($FuncArg)\s*\*\s*($FuncArg)\s*,/) {
Joe Perches60a55362014-06-04 16:12:07 -07005693 my $oldfunc = $3;
5694 my $a1 = $4;
5695 my $a2 = $10;
5696 my $newfunc = "kmalloc_array";
5697 $newfunc = "kcalloc" if ($oldfunc eq "kzalloc");
Joe Perchese3674552014-08-06 16:10:55 -07005698 my $r1 = $a1;
5699 my $r2 = $a2;
5700 if ($a1 =~ /^sizeof\s*\S/) {
5701 $r1 = $a2;
5702 $r2 = $a1;
5703 }
5704 if ($r1 !~ /^sizeof\b/ && $r2 =~ /^sizeof\s*\S/ &&
5705 !($r1 =~ /^$Constant$/ || $r1 =~ /^[A-Z_][A-Z0-9_]*$/)) {
Joe Perches60a55362014-06-04 16:12:07 -07005706 if (WARN("ALLOC_WITH_MULTIPLY",
5707 "Prefer $newfunc over $oldfunc with multiply\n" . $herecurr) &&
5708 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07005709 $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;
Joe Perches60a55362014-06-04 16:12:07 -07005710
5711 }
5712 }
5713 }
5714
Joe Perches972fdea2013-04-29 16:18:12 -07005715# check for krealloc arg reuse
5716 if ($^V && $^V ge 5.10.0 &&
5717 $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*krealloc\s*\(\s*\1\s*,/) {
5718 WARN("KREALLOC_ARG_REUSE",
5719 "Reusing the krealloc arg is almost always a bug\n" . $herecurr);
5720 }
5721
Joe Perches5ce59ae2013-02-21 16:44:18 -08005722# check for alloc argument mismatch
5723 if ($line =~ /\b(kcalloc|kmalloc_array)\s*\(\s*sizeof\b/) {
5724 WARN("ALLOC_ARRAY_ARGS",
5725 "$1 uses number as first arg, sizeof is generally wrong\n" . $herecurr);
5726 }
5727
Joe Perchescaf2a542011-01-12 16:59:56 -08005728# check for multiple semicolons
5729 if ($line =~ /;\s*;\s*$/) {
Joe Perchesd5e616f2013-09-11 14:23:54 -07005730 if (WARN("ONE_SEMICOLON",
5731 "Statements terminations use 1 semicolon\n" . $herecurr) &&
5732 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07005733 $fixed[$fixlinenr] =~ s/(\s*;\s*){2,}$/;/g;
Joe Perchesd5e616f2013-09-11 14:23:54 -07005734 }
Joe Perchesd1e2ad02012-12-17 16:02:01 -08005735 }
5736
Tomas Winklercec3aaa2016-08-02 14:04:39 -07005737# check for #defines like: 1 << <digit> that could be BIT(digit), it is not exported to uapi
5738 if ($realfile !~ m@^include/uapi/@ &&
5739 $line =~ /#\s*define\s+\w+\s+\(?\s*1\s*([ulUL]*)\s*\<\<\s*(?:\d+|$Ident)\s*\)?/) {
Joe Perches0ab90192014-12-10 15:51:57 -08005740 my $ull = "";
5741 $ull = "_ULL" if (defined($1) && $1 =~ /ll/i);
5742 if (CHK("BIT_MACRO",
5743 "Prefer using the BIT$ull macro\n" . $herecurr) &&
5744 $fix) {
5745 $fixed[$fixlinenr] =~ s/\(?\s*1\s*[ulUL]*\s*<<\s*(\d+|$Ident)\s*\)?/BIT${ull}($1)/;
5746 }
5747 }
5748
Joe Perches2d632742016-05-20 17:04:00 -07005749# check for #if defined CONFIG_<FOO> || defined CONFIG_<FOO>_MODULE
5750 if ($line =~ /^\+\s*#\s*if\s+defined(?:\s*\(?\s*|\s+)(CONFIG_[A-Z_]+)\s*\)?\s*\|\|\s*defined(?:\s*\(?\s*|\s+)\1_MODULE\s*\)?\s*$/) {
5751 my $config = $1;
5752 if (WARN("PREFER_IS_ENABLED",
5753 "Prefer IS_ENABLED(<FOO>) to CONFIG_<FOO> || CONFIG_<FOO>_MODULE\n" . $herecurr) &&
5754 $fix) {
5755 $fixed[$fixlinenr] = "\+#if IS_ENABLED($config)";
5756 }
5757 }
5758
Joe Perchese81f2392014-08-06 16:11:25 -07005759# check for case / default statements not preceded by break/fallthrough/switch
Joe Perchesc34c09a2014-01-23 15:54:43 -08005760 if ($line =~ /^.\s*(?:case\s+(?:$Ident|$Constant)\s*|default):/) {
5761 my $has_break = 0;
5762 my $has_statement = 0;
5763 my $count = 0;
5764 my $prevline = $linenr;
Joe Perchese81f2392014-08-06 16:11:25 -07005765 while ($prevline > 1 && ($file || $count < 3) && !$has_break) {
Joe Perchesc34c09a2014-01-23 15:54:43 -08005766 $prevline--;
5767 my $rline = $rawlines[$prevline - 1];
5768 my $fline = $lines[$prevline - 1];
5769 last if ($fline =~ /^\@\@/);
5770 next if ($fline =~ /^\-/);
5771 next if ($fline =~ /^.(?:\s*(?:case\s+(?:$Ident|$Constant)[\s$;]*|default):[\s$;]*)*$/);
5772 $has_break = 1 if ($rline =~ /fall[\s_-]*(through|thru)/i);
5773 next if ($fline =~ /^.[\s$;]*$/);
5774 $has_statement = 1;
5775 $count++;
5776 $has_break = 1 if ($fline =~ /\bswitch\b|\b(?:break\s*;[\s$;]*$|return\b|goto\b|continue\b)/);
5777 }
5778 if (!$has_break && $has_statement) {
5779 WARN("MISSING_BREAK",
5780 "Possible switch case/default not preceeded by break or fallthrough comment\n" . $herecurr);
5781 }
5782 }
5783
Joe Perchesd1e2ad02012-12-17 16:02:01 -08005784# check for switch/default statements without a break;
5785 if ($^V && $^V ge 5.10.0 &&
5786 defined $stat &&
5787 $stat =~ /^\+[$;\s]*(?:case[$;\s]+\w+[$;\s]*:[$;\s]*|)*[$;\s]*\bdefault[$;\s]*:[$;\s]*;/g) {
5788 my $ctx = '';
5789 my $herectx = $here . "\n";
5790 my $cnt = statement_rawlines($stat);
5791 for (my $n = 0; $n < $cnt; $n++) {
5792 $herectx .= raw_line($linenr, $n) . "\n";
5793 }
5794 WARN("DEFAULT_NO_BREAK",
5795 "switch default: should use break\n" . $herectx);
Joe Perchescaf2a542011-01-12 16:59:56 -08005796 }
5797
Andy Whitcroft13214ad2008-02-08 04:22:03 -08005798# check for gcc specific __FUNCTION__
Joe Perchesd5e616f2013-09-11 14:23:54 -07005799 if ($line =~ /\b__FUNCTION__\b/) {
5800 if (WARN("USE_FUNC",
5801 "__func__ should be used instead of gcc specific __FUNCTION__\n" . $herecurr) &&
5802 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07005803 $fixed[$fixlinenr] =~ s/\b__FUNCTION__\b/__func__/g;
Joe Perchesd5e616f2013-09-11 14:23:54 -07005804 }
Andy Whitcroft13214ad2008-02-08 04:22:03 -08005805 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07005806
Joe Perches62ec8182015-02-13 14:38:18 -08005807# check for uses of __DATE__, __TIME__, __TIMESTAMP__
5808 while ($line =~ /\b(__(?:DATE|TIME|TIMESTAMP)__)\b/g) {
5809 ERROR("DATE_TIME",
5810 "Use of the '$1' macro makes the build non-deterministic\n" . $herecurr);
5811 }
5812
Joe Perches2c924882012-03-23 15:02:20 -07005813# check for use of yield()
5814 if ($line =~ /\byield\s*\(\s*\)/) {
5815 WARN("YIELD",
5816 "Using yield() is generally wrong. See yield() kernel-doc (sched/core.c)\n" . $herecurr);
5817 }
5818
Joe Perches179f8f42013-07-03 15:05:30 -07005819# check for comparisons against true and false
5820 if ($line =~ /\+\s*(.*?)\b(true|false|$Lval)\s*(==|\!=)\s*(true|false|$Lval)\b(.*)$/i) {
5821 my $lead = $1;
5822 my $arg = $2;
5823 my $test = $3;
5824 my $otype = $4;
5825 my $trail = $5;
5826 my $op = "!";
5827
5828 ($arg, $otype) = ($otype, $arg) if ($arg =~ /^(?:true|false)$/i);
5829
5830 my $type = lc($otype);
5831 if ($type =~ /^(?:true|false)$/) {
5832 if (("$test" eq "==" && "$type" eq "true") ||
5833 ("$test" eq "!=" && "$type" eq "false")) {
5834 $op = "";
5835 }
5836
5837 CHK("BOOL_COMPARISON",
5838 "Using comparison to $otype is error prone\n" . $herecurr);
5839
5840## maybe suggesting a correct construct would better
5841## "Using comparison to $otype is error prone. Perhaps use '${lead}${op}${arg}${trail}'\n" . $herecurr);
5842
5843 }
5844 }
5845
Thomas Gleixner4882720b2010-09-07 14:34:01 +00005846# check for semaphores initialized locked
5847 if ($line =~ /^.\s*sema_init.+,\W?0\W?\)/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005848 WARN("CONSIDER_COMPLETION",
5849 "consider using a completion\n" . $herecurr);
Andy Whitcroft773647a2008-03-28 14:15:58 -07005850 }
Joe Perches6712d852012-03-23 15:02:20 -07005851
Joe Perches67d0a072011-10-31 17:13:10 -07005852# recommend kstrto* over simple_strto* and strict_strto*
5853 if ($line =~ /\b((simple|strict)_(strto(l|ll|ul|ull)))\s*\(/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005854 WARN("CONSIDER_KSTRTO",
Joe Perches67d0a072011-10-31 17:13:10 -07005855 "$1 is obsolete, use k$3 instead\n" . $herecurr);
Andy Whitcroft773647a2008-03-28 14:15:58 -07005856 }
Joe Perches6712d852012-03-23 15:02:20 -07005857
Fabian Frederickae3ccc42014-06-04 16:12:10 -07005858# check for __initcall(), use device_initcall() explicitly or more appropriate function please
Michael Ellermanf3db6632008-07-23 21:28:57 -07005859 if ($line =~ /^.\s*__initcall\s*\(/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005860 WARN("USE_DEVICE_INITCALL",
Fabian Frederickae3ccc42014-06-04 16:12:10 -07005861 "please use device_initcall() or more appropriate function instead of __initcall() (see include/linux/init.h)\n" . $herecurr);
Michael Ellermanf3db6632008-07-23 21:28:57 -07005862 }
Joe Perches6712d852012-03-23 15:02:20 -07005863
Joe Perches0f3c5aa2015-02-13 14:39:05 -08005864# check for various structs that are normally const (ops, kgdb, device_tree)
5865 my $const_structs = qr{
5866 acpi_dock_ops|
Emese Revfy79404842010-03-05 13:43:53 -08005867 address_space_operations|
5868 backlight_ops|
5869 block_device_operations|
5870 dentry_operations|
5871 dev_pm_ops|
5872 dma_map_ops|
5873 extent_io_ops|
5874 file_lock_operations|
5875 file_operations|
5876 hv_ops|
5877 ide_dma_ops|
5878 intel_dvo_dev_ops|
5879 item_operations|
5880 iwl_ops|
5881 kgdb_arch|
5882 kgdb_io|
5883 kset_uevent_ops|
5884 lock_manager_operations|
5885 microcode_ops|
5886 mtrr_ops|
5887 neigh_ops|
5888 nlmsvc_binding|
Joe Perches0f3c5aa2015-02-13 14:39:05 -08005889 of_device_id|
Emese Revfy79404842010-03-05 13:43:53 -08005890 pci_raw_ops|
5891 pipe_buf_operations|
5892 platform_hibernation_ops|
5893 platform_suspend_ops|
5894 proto_ops|
5895 rpc_pipe_ops|
5896 seq_operations|
5897 snd_ac97_build_ops|
5898 soc_pcmcia_socket_ops|
5899 stacktrace_ops|
5900 sysfs_ops|
5901 tty_operations|
Joe Perches6d07d01b2015-04-16 12:44:33 -07005902 uart_ops|
Emese Revfy79404842010-03-05 13:43:53 -08005903 usb_mon_operations|
5904 wd_ops}x;
Andy Whitcroft6903ffb2009-01-15 13:51:07 -08005905 if ($line !~ /\bconst\b/ &&
Joe Perches0f3c5aa2015-02-13 14:39:05 -08005906 $line =~ /\bstruct\s+($const_structs)\b/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005907 WARN("CONST_STRUCT",
5908 "struct $1 should normally be const\n" .
Andy Whitcroft6903ffb2009-01-15 13:51:07 -08005909 $herecurr);
Andy Whitcroft2b6db5c2009-01-06 14:41:29 -08005910 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07005911
5912# use of NR_CPUS is usually wrong
5913# ignore definitions of NR_CPUS and usage to define arrays as likely right
5914 if ($line =~ /\bNR_CPUS\b/ &&
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07005915 $line !~ /^.\s*\s*#\s*if\b.*\bNR_CPUS\b/ &&
5916 $line !~ /^.\s*\s*#\s*define\b.*\bNR_CPUS\b/ &&
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07005917 $line !~ /^.\s*$Declare\s.*\[[^\]]*NR_CPUS[^\]]*\]/ &&
5918 $line !~ /\[[^\]]*\.\.\.[^\]]*NR_CPUS[^\]]*\]/ &&
5919 $line !~ /\[[^\]]*NR_CPUS[^\]]*\.\.\.[^\]]*\]/)
Andy Whitcroft773647a2008-03-28 14:15:58 -07005920 {
Joe Perches000d1cc12011-07-25 17:13:25 -07005921 WARN("NR_CPUS",
5922 "usage of NR_CPUS is often wrong - consider using cpu_possible(), num_possible_cpus(), for_each_possible_cpu(), etc\n" . $herecurr);
Andy Whitcroft773647a2008-03-28 14:15:58 -07005923 }
Andy Whitcroft9c9ba342008-04-29 00:59:33 -07005924
Joe Perches52ea8502013-11-12 15:10:09 -08005925# Use of __ARCH_HAS_<FOO> or ARCH_HAVE_<BAR> is wrong.
5926 if ($line =~ /\+\s*#\s*define\s+((?:__)?ARCH_(?:HAS|HAVE)\w*)\b/) {
5927 ERROR("DEFINE_ARCH_HAS",
5928 "#define of '$1' is wrong - use Kconfig variables or standard guards instead\n" . $herecurr);
5929 }
5930
Joe Perchesacd93622015-02-13 14:38:38 -08005931# likely/unlikely comparisons similar to "(likely(foo) > 0)"
5932 if ($^V && $^V ge 5.10.0 &&
5933 $line =~ /\b((?:un)?likely)\s*\(\s*$FuncArg\s*\)\s*$Compare/) {
5934 WARN("LIKELY_MISUSE",
5935 "Using $1 should generally have parentheses around the comparison\n" . $herecurr);
5936 }
5937
Andy Whitcroft691d77b2009-01-06 14:41:16 -08005938# whine mightly about in_atomic
5939 if ($line =~ /\bin_atomic\s*\(/) {
5940 if ($realfile =~ m@^drivers/@) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005941 ERROR("IN_ATOMIC",
5942 "do not use in_atomic in drivers\n" . $herecurr);
Andy Whitcroftf4a87732009-02-27 14:03:05 -08005943 } elsif ($realfile !~ m@^kernel/@) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005944 WARN("IN_ATOMIC",
5945 "use of in_atomic() is incorrect outside core kernel code\n" . $herecurr);
Andy Whitcroft691d77b2009-01-06 14:41:16 -08005946 }
5947 }
Peter Zijlstra1704f472010-03-19 01:37:42 +01005948
Joe Perches481aea52016-05-20 17:04:08 -07005949# whine about ACCESS_ONCE
5950 if ($^V && $^V ge 5.10.0 &&
5951 $line =~ /\bACCESS_ONCE\s*$balanced_parens\s*(=(?!=))?\s*($FuncArg)?/) {
5952 my $par = $1;
5953 my $eq = $2;
5954 my $fun = $3;
5955 $par =~ s/^\(\s*(.*)\s*\)$/$1/;
5956 if (defined($eq)) {
5957 if (WARN("PREFER_WRITE_ONCE",
5958 "Prefer WRITE_ONCE(<FOO>, <BAR>) over ACCESS_ONCE(<FOO>) = <BAR>\n" . $herecurr) &&
5959 $fix) {
5960 $fixed[$fixlinenr] =~ s/\bACCESS_ONCE\s*\(\s*\Q$par\E\s*\)\s*$eq\s*\Q$fun\E/WRITE_ONCE($par, $fun)/;
5961 }
5962 } else {
5963 if (WARN("PREFER_READ_ONCE",
5964 "Prefer READ_ONCE(<FOO>) over ACCESS_ONCE(<FOO>)\n" . $herecurr) &&
5965 $fix) {
5966 $fixed[$fixlinenr] =~ s/\bACCESS_ONCE\s*\(\s*\Q$par\E\s*\)/READ_ONCE($par)/;
5967 }
5968 }
5969 }
5970
Peter Zijlstra1704f472010-03-19 01:37:42 +01005971# check for lockdep_set_novalidate_class
5972 if ($line =~ /^.\s*lockdep_set_novalidate_class\s*\(/ ||
5973 $line =~ /__lockdep_no_validate__\s*\)/ ) {
5974 if ($realfile !~ m@^kernel/lockdep@ &&
5975 $realfile !~ m@^include/linux/lockdep@ &&
5976 $realfile !~ m@^drivers/base/core@) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005977 ERROR("LOCKDEP",
5978 "lockdep_no_validate class is reserved for device->mutex.\n" . $herecurr);
Peter Zijlstra1704f472010-03-19 01:37:42 +01005979 }
5980 }
Dave Jones88f88312011-01-12 16:59:59 -08005981
Joe Perchesb392c642015-04-16 12:44:16 -07005982 if ($line =~ /debugfs_create_\w+.*\b$mode_perms_world_writable\b/ ||
5983 $line =~ /DEVICE_ATTR.*\b$mode_perms_world_writable\b/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005984 WARN("EXPORTED_WORLD_WRITABLE",
5985 "Exporting world writable files is usually an error. Consider more restrictive permissions.\n" . $herecurr);
Dave Jones88f88312011-01-12 16:59:59 -08005986 }
Joe Perches24358802014-04-03 14:49:13 -07005987
Joe Perches515a2352014-04-03 14:49:24 -07005988# Mode permission misuses where it seems decimal should be octal
5989# This uses a shortcut match to avoid unnecessary uses of a slow foreach loop
5990 if ($^V && $^V ge 5.10.0 &&
5991 $line =~ /$mode_perms_search/) {
5992 foreach my $entry (@mode_permission_funcs) {
5993 my $func = $entry->[0];
5994 my $arg_pos = $entry->[1];
Joe Perches24358802014-04-03 14:49:13 -07005995
Joe Perches515a2352014-04-03 14:49:24 -07005996 my $skip_args = "";
5997 if ($arg_pos > 1) {
5998 $arg_pos--;
5999 $skip_args = "(?:\\s*$FuncArg\\s*,\\s*){$arg_pos,$arg_pos}";
6000 }
6001 my $test = "\\b$func\\s*\\(${skip_args}([\\d]+)\\s*[,\\)]";
6002 if ($line =~ /$test/) {
6003 my $val = $1;
6004 $val = $6 if ($skip_args ne "");
Joe Perches24358802014-04-03 14:49:13 -07006005
Joe Perches515a2352014-04-03 14:49:24 -07006006 if ($val !~ /^0$/ &&
6007 (($val =~ /^$Int$/ && $val !~ /^$Octal$/) ||
6008 length($val) ne 4)) {
6009 ERROR("NON_OCTAL_PERMISSIONS",
6010 "Use 4 digit octal (0777) not decimal permissions\n" . $herecurr);
Joe Perchesc0a5c892015-02-13 14:38:21 -08006011 } elsif ($val =~ /^$Octal$/ && (oct($val) & 02)) {
6012 ERROR("EXPORTED_WORLD_WRITABLE",
6013 "Exporting writable files is usually an error. Consider more restrictive permissions.\n" . $herecurr);
Joe Perches515a2352014-04-03 14:49:24 -07006014 }
Joe Perches24358802014-04-03 14:49:13 -07006015 }
6016 }
6017 }
Bjorn Andersson5a6d20c2015-06-25 15:03:24 -07006018
6019# validate content of MODULE_LICENSE against list from include/linux/module.h
6020 if ($line =~ /\bMODULE_LICENSE\s*\(\s*($String)\s*\)/) {
6021 my $extracted_string = get_quoted_string($line, $rawline);
6022 my $valid_licenses = qr{
6023 GPL|
6024 GPL\ v2|
6025 GPL\ and\ additional\ rights|
6026 Dual\ BSD/GPL|
6027 Dual\ MIT/GPL|
6028 Dual\ MPL/GPL|
6029 Proprietary
6030 }x;
6031 if ($extracted_string !~ /^"(?:$valid_licenses)"$/x) {
6032 WARN("MODULE_LICENSE",
6033 "unknown module license " . $extracted_string . "\n" . $herecurr);
6034 }
6035 }
Andy Whitcroft13214ad2008-02-08 04:22:03 -08006036 }
6037
6038 # If we have no input at all, then there is nothing to report on
6039 # so just keep quiet.
6040 if ($#rawlines == -1) {
6041 exit(0);
Andy Whitcroft0a920b52007-06-01 00:46:48 -07006042 }
6043
Andy Whitcroft8905a672007-11-28 16:21:06 -08006044 # In mailback mode only produce a report in the negative, for
6045 # things that appear to be patches.
6046 if ($mailback && ($clean == 1 || !$is_patch)) {
6047 exit(0);
6048 }
6049
6050 # This is not a patch, and we are are in 'no-patch' mode so
6051 # just keep quiet.
6052 if (!$chk_patch && !$is_patch) {
6053 exit(0);
6054 }
6055
Joe Perches06330fc2015-06-25 15:03:11 -07006056 if (!$is_patch && $file !~ /cover-letter\.patch$/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07006057 ERROR("NOT_UNIFIED_DIFF",
6058 "Does not appear to be a unified-diff format patch\n");
Andy Whitcroft0a920b52007-06-01 00:46:48 -07006059 }
Allen Hubbeed43c4e2016-08-02 14:04:45 -07006060 if ($is_patch && $has_commit_log && $chk_signoff && $signoff == 0) {
Joe Perches000d1cc12011-07-25 17:13:25 -07006061 ERROR("MISSING_SIGN_OFF",
6062 "Missing Signed-off-by: line(s)\n");
Andy Whitcroft0a920b52007-06-01 00:46:48 -07006063 }
6064
Andy Whitcroft8905a672007-11-28 16:21:06 -08006065 print report_dump();
Andy Whitcroft13214ad2008-02-08 04:22:03 -08006066 if ($summary && !($clean == 1 && $quiet == 1)) {
6067 print "$filename " if ($summary_file);
Andy Whitcroft8905a672007-11-28 16:21:06 -08006068 print "total: $cnt_error errors, $cnt_warn warnings, " .
6069 (($check)? "$cnt_chk checks, " : "") .
6070 "$cnt_lines lines checked\n";
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07006071 }
Andy Whitcroft8905a672007-11-28 16:21:06 -08006072
Andy Whitcroftd2c0a232010-10-26 14:23:12 -07006073 if ($quiet == 0) {
Joe Perchesef212192016-05-20 17:04:11 -07006074 # If there were any defects found and not already fixing them
6075 if (!$clean and !$fix) {
6076 print << "EOM"
6077
6078NOTE: For some of the reported defects, checkpatch may be able to
6079 mechanically convert to the typical style using --fix or --fix-inplace.
6080EOM
6081 }
Andy Whitcroftd2c0a232010-10-26 14:23:12 -07006082 # If there were whitespace errors which cleanpatch can fix
6083 # then suggest that.
6084 if ($rpt_cleaners) {
Mike Frysingerb0781212011-03-22 16:34:43 -07006085 $rpt_cleaners = 0;
Joe Perchesd8469f12015-06-25 15:03:00 -07006086 print << "EOM"
6087
6088NOTE: Whitespace errors detected.
6089 You may wish to use scripts/cleanpatch or scripts/cleanfile
6090EOM
Andy Whitcroftd2c0a232010-10-26 14:23:12 -07006091 }
6092 }
6093
Joe Perchesd752fcc2014-08-06 16:11:05 -07006094 if ($clean == 0 && $fix &&
6095 ("@rawlines" ne "@fixed" ||
6096 $#fixed_inserted >= 0 || $#fixed_deleted >= 0)) {
Joe Perches9624b8d2014-01-23 15:54:44 -08006097 my $newfile = $filename;
6098 $newfile .= ".EXPERIMENTAL-checkpatch-fixes" if (!$fix_inplace);
Joe Perches3705ce52013-07-03 15:05:31 -07006099 my $linecount = 0;
6100 my $f;
6101
Joe Perchesd752fcc2014-08-06 16:11:05 -07006102 @fixed = fix_inserted_deleted_lines(\@fixed, \@fixed_inserted, \@fixed_deleted);
6103
Joe Perches3705ce52013-07-03 15:05:31 -07006104 open($f, '>', $newfile)
6105 or die "$P: Can't open $newfile for write\n";
6106 foreach my $fixed_line (@fixed) {
6107 $linecount++;
6108 if ($file) {
6109 if ($linecount > 3) {
6110 $fixed_line =~ s/^\+//;
Joe Perchesd752fcc2014-08-06 16:11:05 -07006111 print $f $fixed_line . "\n";
Joe Perches3705ce52013-07-03 15:05:31 -07006112 }
6113 } else {
6114 print $f $fixed_line . "\n";
6115 }
6116 }
6117 close($f);
6118
6119 if (!$quiet) {
6120 print << "EOM";
Joe Perchesd8469f12015-06-25 15:03:00 -07006121
Joe Perches3705ce52013-07-03 15:05:31 -07006122Wrote EXPERIMENTAL --fix correction(s) to '$newfile'
6123
6124Do _NOT_ trust the results written to this file.
6125Do _NOT_ submit these changes without inspecting them for correctness.
6126
6127This EXPERIMENTAL file is simply a convenience to help rewrite patches.
6128No warranties, expressed or implied...
Joe Perches3705ce52013-07-03 15:05:31 -07006129EOM
6130 }
6131 }
6132
Joe Perchesd8469f12015-06-25 15:03:00 -07006133 if ($quiet == 0) {
6134 print "\n";
6135 if ($clean == 1) {
6136 print "$vname has no obvious style problems and is ready for submission.\n";
6137 } else {
6138 print "$vname has style problems, please review.\n";
6139 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07006140 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07006141 return $clean;
6142}