blob: 182be0f124074c6d508d8a97e498ea7925665a1f [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;
Andy Whitcroft0a920b52007-06-01 00:46:48 -070010
11my $P = $0;
Andy Whitcroft00df3442007-06-08 13:47:06 -070012$P =~ s@.*/@@g;
Andy Whitcroft0a920b52007-06-01 00:46:48 -070013
Joe Perches000d1cc12011-07-25 17:13:25 -070014my $V = '0.32';
Andy Whitcroft0a920b52007-06-01 00:46:48 -070015
16use Getopt::Long qw(:config no_auto_abbrev);
17
18my $quiet = 0;
19my $tree = 1;
20my $chk_signoff = 1;
21my $chk_patch = 1;
Andy Whitcroft773647a2008-03-28 14:15:58 -070022my $tst_only;
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -070023my $emacs = 0;
Andy Whitcroft8905a672007-11-28 16:21:06 -080024my $terse = 0;
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -070025my $file = 0;
26my $check = 0;
Joe Perches2ac73b4f2014-06-04 16:12:05 -070027my $check_orig = 0;
Andy Whitcroft8905a672007-11-28 16:21:06 -080028my $summary = 1;
29my $mailback = 0;
Andy Whitcroft13214ad2008-02-08 04:22:03 -080030my $summary_file = 0;
Joe Perches000d1cc12011-07-25 17:13:25 -070031my $show_types = 0;
Joe Perches3705ce52013-07-03 15:05:31 -070032my $fix = 0;
Joe Perches9624b8d2014-01-23 15:54:44 -080033my $fix_inplace = 0;
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -070034my $root;
Andy Whitcroftc2fdda02008-02-08 04:20:54 -080035my %debug;
Joe Perches34456862013-07-03 15:05:34 -070036my %camelcase = ();
Joe Perches91bfe482013-09-11 14:23:59 -070037my %use_type = ();
38my @use = ();
39my %ignore_type = ();
Joe Perches000d1cc12011-07-25 17:13:25 -070040my @ignore = ();
Hannes Eder77f5b102009-09-21 17:04:37 -070041my $help = 0;
Joe Perches000d1cc12011-07-25 17:13:25 -070042my $configuration_file = ".checkpatch.conf";
Joe Perches6cd7f382012-12-17 16:01:54 -080043my $max_line_length = 80;
Dave Hansend62a2012013-09-11 14:23:56 -070044my $ignore_perl_version = 0;
45my $minimum_perl_version = 5.10.0;
Hannes Eder77f5b102009-09-21 17:04:37 -070046
47sub help {
48 my ($exitcode) = @_;
49
50 print << "EOM";
51Usage: $P [OPTION]... [FILE]...
52Version: $V
53
54Options:
55 -q, --quiet quiet
56 --no-tree run without a kernel tree
57 --no-signoff do not check for 'Signed-off-by' line
58 --patch treat FILE as patchfile (default)
59 --emacs emacs compile window format
60 --terse one line per report
61 -f, --file treat FILE as regular source file
62 --subjective, --strict enable more subjective tests
Joe Perches91bfe482013-09-11 14:23:59 -070063 --types TYPE(,TYPE2...) show only these comma separated message types
Joe Perches000d1cc12011-07-25 17:13:25 -070064 --ignore TYPE(,TYPE2...) ignore various comma separated message types
Joe Perches6cd7f382012-12-17 16:01:54 -080065 --max-line-length=n set the maximum line length, if exceeded, warn
Joe Perches000d1cc12011-07-25 17:13:25 -070066 --show-types show the message "types" in the output
Hannes Eder77f5b102009-09-21 17:04:37 -070067 --root=PATH PATH to the kernel tree root
68 --no-summary suppress the per-file summary
69 --mailback only produce a report in case of warnings/errors
70 --summary-file include the filename in summary
71 --debug KEY=[0|1] turn on/off debugging of KEY, where KEY is one of
72 'values', 'possible', 'type', and 'attr' (default
73 is all off)
74 --test-only=WORD report only warnings/errors containing WORD
75 literally
Joe Perches3705ce52013-07-03 15:05:31 -070076 --fix EXPERIMENTAL - may create horrible results
77 If correctable single-line errors exist, create
78 "<inputfile>.EXPERIMENTAL-checkpatch-fixes"
79 with potential errors corrected to the preferred
80 checkpatch style
Joe Perches9624b8d2014-01-23 15:54:44 -080081 --fix-inplace EXPERIMENTAL - may create horrible results
82 Is the same as --fix, but overwrites the input
83 file. It's your fault if there's no backup or git
Dave Hansend62a2012013-09-11 14:23:56 -070084 --ignore-perl-version override checking of perl version. expect
85 runtime errors.
Hannes Eder77f5b102009-09-21 17:04:37 -070086 -h, --help, --version display this help and exit
87
88When FILE is - read standard input.
89EOM
90
91 exit($exitcode);
92}
93
Joe Perches000d1cc12011-07-25 17:13:25 -070094my $conf = which_conf($configuration_file);
95if (-f $conf) {
96 my @conf_args;
97 open(my $conffile, '<', "$conf")
98 or warn "$P: Can't find a readable $configuration_file file $!\n";
99
100 while (<$conffile>) {
101 my $line = $_;
102
103 $line =~ s/\s*\n?$//g;
104 $line =~ s/^\s*//g;
105 $line =~ s/\s+/ /g;
106
107 next if ($line =~ m/^\s*#/);
108 next if ($line =~ m/^\s*$/);
109
110 my @words = split(" ", $line);
111 foreach my $word (@words) {
112 last if ($word =~ m/^#/);
113 push (@conf_args, $word);
114 }
115 }
116 close($conffile);
117 unshift(@ARGV, @conf_args) if @conf_args;
118}
119
Andy Whitcroft0a920b52007-06-01 00:46:48 -0700120GetOptions(
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700121 'q|quiet+' => \$quiet,
Andy Whitcroft0a920b52007-06-01 00:46:48 -0700122 'tree!' => \$tree,
123 'signoff!' => \$chk_signoff,
124 'patch!' => \$chk_patch,
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700125 'emacs!' => \$emacs,
Andy Whitcroft8905a672007-11-28 16:21:06 -0800126 'terse!' => \$terse,
Hannes Eder77f5b102009-09-21 17:04:37 -0700127 'f|file!' => \$file,
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700128 'subjective!' => \$check,
129 'strict!' => \$check,
Joe Perches000d1cc12011-07-25 17:13:25 -0700130 'ignore=s' => \@ignore,
Joe Perches91bfe482013-09-11 14:23:59 -0700131 'types=s' => \@use,
Joe Perches000d1cc12011-07-25 17:13:25 -0700132 'show-types!' => \$show_types,
Joe Perches6cd7f382012-12-17 16:01:54 -0800133 'max-line-length=i' => \$max_line_length,
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700134 'root=s' => \$root,
Andy Whitcroft8905a672007-11-28 16:21:06 -0800135 'summary!' => \$summary,
136 'mailback!' => \$mailback,
Andy Whitcroft13214ad2008-02-08 04:22:03 -0800137 'summary-file!' => \$summary_file,
Joe Perches3705ce52013-07-03 15:05:31 -0700138 'fix!' => \$fix,
Joe Perches9624b8d2014-01-23 15:54:44 -0800139 'fix-inplace!' => \$fix_inplace,
Dave Hansend62a2012013-09-11 14:23:56 -0700140 'ignore-perl-version!' => \$ignore_perl_version,
Andy Whitcroftc2fdda02008-02-08 04:20:54 -0800141 'debug=s' => \%debug,
Andy Whitcroft773647a2008-03-28 14:15:58 -0700142 'test-only=s' => \$tst_only,
Hannes Eder77f5b102009-09-21 17:04:37 -0700143 'h|help' => \$help,
144 'version' => \$help
145) or help(1);
146
147help(0) if ($help);
Andy Whitcroft0a920b52007-06-01 00:46:48 -0700148
Joe Perches9624b8d2014-01-23 15:54:44 -0800149$fix = 1 if ($fix_inplace);
Joe Perches2ac73b4f2014-06-04 16:12:05 -0700150$check_orig = $check;
Joe Perches9624b8d2014-01-23 15:54:44 -0800151
Andy Whitcroft0a920b52007-06-01 00:46:48 -0700152my $exit = 0;
153
Dave Hansend62a2012013-09-11 14:23:56 -0700154if ($^V && $^V lt $minimum_perl_version) {
155 printf "$P: requires at least perl version %vd\n", $minimum_perl_version;
156 if (!$ignore_perl_version) {
157 exit(1);
158 }
159}
160
Andy Whitcroft0a920b52007-06-01 00:46:48 -0700161if ($#ARGV < 0) {
Hannes Eder77f5b102009-09-21 17:04:37 -0700162 print "$P: no input files\n";
Andy Whitcroft0a920b52007-06-01 00:46:48 -0700163 exit(1);
164}
165
Joe Perches91bfe482013-09-11 14:23:59 -0700166sub hash_save_array_words {
167 my ($hashRef, $arrayRef) = @_;
Joe Perches000d1cc12011-07-25 17:13:25 -0700168
Joe Perches91bfe482013-09-11 14:23:59 -0700169 my @array = split(/,/, join(',', @$arrayRef));
170 foreach my $word (@array) {
171 $word =~ s/\s*\n?$//g;
172 $word =~ s/^\s*//g;
173 $word =~ s/\s+/ /g;
174 $word =~ tr/[a-z]/[A-Z]/;
Joe Perches000d1cc12011-07-25 17:13:25 -0700175
Joe Perches91bfe482013-09-11 14:23:59 -0700176 next if ($word =~ m/^\s*#/);
177 next if ($word =~ m/^\s*$/);
178
179 $hashRef->{$word}++;
180 }
Joe Perches000d1cc12011-07-25 17:13:25 -0700181}
182
Joe Perches91bfe482013-09-11 14:23:59 -0700183sub hash_show_words {
184 my ($hashRef, $prefix) = @_;
185
Joe Perches58cb3cf2013-09-11 14:24:04 -0700186 if ($quiet == 0 && keys %$hashRef) {
Joe Perches91bfe482013-09-11 14:23:59 -0700187 print "NOTE: $prefix message types:";
Joe Perches58cb3cf2013-09-11 14:24:04 -0700188 foreach my $word (sort keys %$hashRef) {
Joe Perches91bfe482013-09-11 14:23:59 -0700189 print " $word";
190 }
191 print "\n\n";
192 }
193}
194
195hash_save_array_words(\%ignore_type, \@ignore);
196hash_save_array_words(\%use_type, \@use);
197
Andy Whitcroftc2fdda02008-02-08 04:20:54 -0800198my $dbg_values = 0;
199my $dbg_possible = 0;
Andy Whitcroft7429c692008-07-23 21:29:06 -0700200my $dbg_type = 0;
Andy Whitcrofta1ef2772008-10-15 22:02:17 -0700201my $dbg_attr = 0;
Andy Whitcroftc2fdda02008-02-08 04:20:54 -0800202for my $key (keys %debug) {
Andy Whitcroft21caa132009-01-06 14:41:30 -0800203 ## no critic
204 eval "\${dbg_$key} = '$debug{$key}';";
205 die "$@" if ($@);
Andy Whitcroftc2fdda02008-02-08 04:20:54 -0800206}
207
Andy Whitcroftd2c0a232010-10-26 14:23:12 -0700208my $rpt_cleaners = 0;
209
Andy Whitcroft8905a672007-11-28 16:21:06 -0800210if ($terse) {
211 $emacs = 1;
212 $quiet++;
213}
214
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700215if ($tree) {
216 if (defined $root) {
217 if (!top_of_kernel_tree($root)) {
218 die "$P: $root: --root does not point at a valid tree\n";
219 }
220 } else {
221 if (top_of_kernel_tree('.')) {
222 $root = '.';
223 } elsif ($0 =~ m@(.*)/scripts/[^/]*$@ &&
224 top_of_kernel_tree($1)) {
225 $root = $1;
226 }
227 }
228
229 if (!defined $root) {
230 print "Must be run from the top-level dir. of a kernel tree\n";
231 exit(2);
232 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -0700233}
234
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700235my $emitted_corrupt = 0;
236
Andy Whitcroft2ceb5322009-10-26 16:50:14 -0700237our $Ident = qr{
238 [A-Za-z_][A-Za-z\d_]*
239 (?:\s*\#\#\s*[A-Za-z_][A-Za-z\d_]*)*
240 }x;
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700241our $Storage = qr{extern|static|asmlinkage};
242our $Sparse = qr{
243 __user|
244 __kernel|
245 __force|
246 __iomem|
247 __must_check|
248 __init_refok|
Andy Whitcroft417495e2009-02-27 14:03:08 -0800249 __kprobes|
Sven Eckelmann165e72a2011-07-25 17:13:23 -0700250 __ref|
251 __rcu
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700252 }x;
Joe Perchese970b882013-11-12 15:10:10 -0800253our $InitAttributePrefix = qr{__(?:mem|cpu|dev|net_|)};
254our $InitAttributeData = qr{$InitAttributePrefix(?:initdata\b)};
255our $InitAttributeConst = qr{$InitAttributePrefix(?:initconst\b)};
256our $InitAttributeInit = qr{$InitAttributePrefix(?:init\b)};
257our $InitAttribute = qr{$InitAttributeData|$InitAttributeConst|$InitAttributeInit};
Joe Perches8716de32013-09-11 14:24:05 -0700258
Wolfram Sang52131292010-03-05 13:43:51 -0800259# Notes to $Attribute:
260# We need \b after 'init' otherwise 'initconst' will cause a false positive in a check
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700261our $Attribute = qr{
262 const|
Joe Perches03f1df72010-10-26 14:23:16 -0700263 __percpu|
264 __nocast|
265 __safe|
266 __bitwise__|
267 __packed__|
268 __packed2__|
269 __naked|
270 __maybe_unused|
271 __always_unused|
272 __noreturn|
273 __used|
274 __cold|
275 __noclone|
276 __deprecated|
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700277 __read_mostly|
278 __kprobes|
Joe Perches8716de32013-09-11 14:24:05 -0700279 $InitAttribute|
Andy Whitcroft24e1d812008-10-15 22:02:18 -0700280 ____cacheline_aligned|
281 ____cacheline_aligned_in_smp|
Andy Whitcroft5fe3af12009-01-06 14:41:18 -0800282 ____cacheline_internodealigned_in_smp|
283 __weak
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700284 }x;
Andy Whitcroftc45dcab2008-06-05 22:46:01 -0700285our $Modifier;
Joe Perches91cb5192014-04-03 14:49:32 -0700286our $Inline = qr{inline|__always_inline|noinline|__inline|__inline__};
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700287our $Member = qr{->$Ident|\.$Ident|\[[^]]*\]};
288our $Lval = qr{$Ident(?:$Member)*};
289
Joe Perches95e2c602013-07-03 15:05:20 -0700290our $Int_type = qr{(?i)llu|ull|ll|lu|ul|l|u};
291our $Binary = qr{(?i)0b[01]+$Int_type?};
292our $Hex = qr{(?i)0x[0-9a-f]+$Int_type?};
293our $Int = qr{[0-9]+$Int_type?};
Joe Perches24358802014-04-03 14:49:13 -0700294our $Octal = qr{0[0-7]+$Int_type?};
Joe Perches326b1ff2013-02-04 14:28:51 -0800295our $Float_hex = qr{(?i)0x[0-9a-f]+p-?[0-9]+[fl]?};
296our $Float_dec = qr{(?i)(?:[0-9]+\.[0-9]*|[0-9]*\.[0-9]+)(?:e-?[0-9]+)?[fl]?};
297our $Float_int = qr{(?i)[0-9]+e-?[0-9]+[fl]?};
Joe Perches74349bc2012-12-17 16:02:05 -0800298our $Float = qr{$Float_hex|$Float_dec|$Float_int};
Joe Perches24358802014-04-03 14:49:13 -0700299our $Constant = qr{$Float|$Binary|$Octal|$Hex|$Int};
Joe Perches326b1ff2013-02-04 14:28:51 -0800300our $Assignment = qr{\*\=|/=|%=|\+=|-=|<<=|>>=|&=|\^=|\|=|=};
Joe Perches447432f2014-04-03 14:49:17 -0700301our $Compare = qr{<=|>=|==|!=|<|(?<!-)>};
Joe Perches23f780c2013-07-03 15:05:31 -0700302our $Arithmetic = qr{\+|-|\*|\/|%};
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700303our $Operators = qr{
304 <=|>=|==|!=|
305 =>|->|<<|>>|<|>|!|~|
Joe Perches23f780c2013-07-03 15:05:31 -0700306 &&|\|\||,|\^|\+\+|--|&|\||$Arithmetic
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700307 }x;
308
Joe Perches91cb5192014-04-03 14:49:32 -0700309our $c90_Keywords = qr{do|for|while|if|else|return|goto|continue|switch|default|case|break}x;
310
Andy Whitcroft8905a672007-11-28 16:21:06 -0800311our $NonptrType;
Joe Perches8716de32013-09-11 14:24:05 -0700312our $NonptrTypeWithAttr;
Andy Whitcroft8905a672007-11-28 16:21:06 -0800313our $Type;
314our $Declare;
315
Joe Perches15662b32011-10-31 17:13:12 -0700316our $NON_ASCII_UTF8 = qr{
317 [\xC2-\xDF][\x80-\xBF] # non-overlong 2-byte
Andy Whitcroft171ae1a2008-04-29 00:59:32 -0700318 | \xE0[\xA0-\xBF][\x80-\xBF] # excluding overlongs
319 | [\xE1-\xEC\xEE\xEF][\x80-\xBF]{2} # straight 3-byte
320 | \xED[\x80-\x9F][\x80-\xBF] # excluding surrogates
321 | \xF0[\x90-\xBF][\x80-\xBF]{2} # planes 1-3
322 | [\xF1-\xF3][\x80-\xBF]{3} # planes 4-15
323 | \xF4[\x80-\x8F][\x80-\xBF]{2} # plane 16
324}x;
325
Joe Perches15662b32011-10-31 17:13:12 -0700326our $UTF8 = qr{
327 [\x09\x0A\x0D\x20-\x7E] # ASCII
328 | $NON_ASCII_UTF8
329}x;
330
Andy Whitcroft8ed22ca2008-10-15 22:02:32 -0700331our $typeTypedefs = qr{(?x:
Andy Whitcroftfb9e9092009-09-21 17:04:38 -0700332 (?:__)?(?:u|s|be|le)(?:8|16|32|64)|
Andy Whitcroft8ed22ca2008-10-15 22:02:32 -0700333 atomic_t
334)};
335
Joe Perches691e6692010-03-05 13:43:51 -0800336our $logFunctions = qr{(?x:
Joe Perches6e60c022011-07-25 17:13:27 -0700337 printk(?:_ratelimited|_once|)|
Jacob Keller7d0b6592013-07-03 15:05:35 -0700338 (?:[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 -0700339 WARN(?:_RATELIMIT|_ONCE|)|
Joe Perchesb0531722011-05-24 17:13:40 -0700340 panic|
Joe Perches06668722013-11-12 15:10:07 -0800341 MODULE_[A-Z_]+|
342 seq_vprintf|seq_printf|seq_puts
Joe Perches691e6692010-03-05 13:43:51 -0800343)};
344
Joe Perches20112472011-07-25 17:13:23 -0700345our $signature_tags = qr{(?xi:
346 Signed-off-by:|
347 Acked-by:|
348 Tested-by:|
349 Reviewed-by:|
350 Reported-by:|
Mugunthan V N8543ae12013-04-29 16:18:17 -0700351 Suggested-by:|
Joe Perches20112472011-07-25 17:13:23 -0700352 To:|
353 Cc:
354)};
355
Andy Whitcroft8905a672007-11-28 16:21:06 -0800356our @typeList = (
357 qr{void},
Andy Whitcroftc45dcab2008-06-05 22:46:01 -0700358 qr{(?:unsigned\s+)?char},
359 qr{(?:unsigned\s+)?short},
360 qr{(?:unsigned\s+)?int},
361 qr{(?:unsigned\s+)?long},
362 qr{(?:unsigned\s+)?long\s+int},
363 qr{(?:unsigned\s+)?long\s+long},
364 qr{(?:unsigned\s+)?long\s+long\s+int},
Andy Whitcroft8905a672007-11-28 16:21:06 -0800365 qr{unsigned},
366 qr{float},
367 qr{double},
368 qr{bool},
Andy Whitcroft8905a672007-11-28 16:21:06 -0800369 qr{struct\s+$Ident},
370 qr{union\s+$Ident},
371 qr{enum\s+$Ident},
372 qr{${Ident}_t},
373 qr{${Ident}_handler},
374 qr{${Ident}_handler_fn},
375);
Joe Perches8716de32013-09-11 14:24:05 -0700376our @typeListWithAttr = (
377 @typeList,
378 qr{struct\s+$InitAttribute\s+$Ident},
379 qr{union\s+$InitAttribute\s+$Ident},
380);
381
Andy Whitcroftc45dcab2008-06-05 22:46:01 -0700382our @modifierList = (
383 qr{fastcall},
384);
Andy Whitcroft8905a672007-11-28 16:21:06 -0800385
Joe Perches24358802014-04-03 14:49:13 -0700386our @mode_permission_funcs = (
387 ["module_param", 3],
388 ["module_param_(?:array|named|string)", 4],
389 ["module_param_array_named", 5],
390 ["debugfs_create_(?:file|u8|u16|u32|u64|x8|x16|x32|x64|size_t|atomic_t|bool|blob|regset32|u32_array)", 2],
391 ["proc_create(?:_data|)", 2],
392 ["(?:CLASS|DEVICE|SENSOR)_ATTR", 2],
393);
394
Joe Perches515a2352014-04-03 14:49:24 -0700395#Create a search pattern for all these functions to speed up a loop below
396our $mode_perms_search = "";
397foreach my $entry (@mode_permission_funcs) {
398 $mode_perms_search .= '|' if ($mode_perms_search ne "");
399 $mode_perms_search .= $entry->[0];
400}
401
Joe Perches3f7bac02014-06-04 16:12:04 -0700402our $declaration_macros = qr{(?x:
403 (?:$Storage\s+)?(?:DECLARE|DEFINE)_[A-Z]+\s*\(|
404 (?:$Storage\s+)?LIST_HEAD\s*\(
405)};
406
Wolfram Sang7840a942010-08-09 17:20:57 -0700407our $allowed_asm_includes = qr{(?x:
408 irq|
409 memory
410)};
411# memory.h: ARM has a custom one
412
Andy Whitcroft8905a672007-11-28 16:21:06 -0800413sub build_types {
Andy Whitcroftd2172eb2008-07-23 21:29:07 -0700414 my $mods = "(?x: \n" . join("|\n ", @modifierList) . "\n)";
415 my $all = "(?x: \n" . join("|\n ", @typeList) . "\n)";
Joe Perches8716de32013-09-11 14:24:05 -0700416 my $allWithAttr = "(?x: \n" . join("|\n ", @typeListWithAttr) . "\n)";
Andy Whitcroftc8cb2ca2008-07-23 21:28:57 -0700417 $Modifier = qr{(?:$Attribute|$Sparse|$mods)};
Andy Whitcroft8905a672007-11-28 16:21:06 -0800418 $NonptrType = qr{
Andy Whitcroftd2172eb2008-07-23 21:29:07 -0700419 (?:$Modifier\s+|const\s+)*
Andy Whitcroftcf655042008-03-04 14:28:20 -0800420 (?:
Andy Whitcroft6b48db22012-01-10 15:10:13 -0800421 (?:typeof|__typeof__)\s*\([^\)]*\)|
Andy Whitcroft8ed22ca2008-10-15 22:02:32 -0700422 (?:$typeTypedefs\b)|
Andy Whitcroftc45dcab2008-06-05 22:46:01 -0700423 (?:${all}\b)
Andy Whitcroftcf655042008-03-04 14:28:20 -0800424 )
Andy Whitcroftc8cb2ca2008-07-23 21:28:57 -0700425 (?:\s+$Modifier|\s+const)*
Andy Whitcroft8905a672007-11-28 16:21:06 -0800426 }x;
Joe Perches8716de32013-09-11 14:24:05 -0700427 $NonptrTypeWithAttr = qr{
428 (?:$Modifier\s+|const\s+)*
429 (?:
430 (?:typeof|__typeof__)\s*\([^\)]*\)|
431 (?:$typeTypedefs\b)|
432 (?:${allWithAttr}\b)
433 )
434 (?:\s+$Modifier|\s+const)*
435 }x;
Andy Whitcroft8905a672007-11-28 16:21:06 -0800436 $Type = qr{
Andy Whitcroftc45dcab2008-06-05 22:46:01 -0700437 $NonptrType
Andy Whitcroftb337d8b2012-03-23 15:02:18 -0700438 (?:(?:\s|\*|\[\])+\s*const|(?:\s|\*|\[\])+|(?:\s*\[\s*\])+)?
Andy Whitcroftc8cb2ca2008-07-23 21:28:57 -0700439 (?:\s+$Inline|\s+$Modifier)*
Andy Whitcroft8905a672007-11-28 16:21:06 -0800440 }x;
Joe Perches91cb5192014-04-03 14:49:32 -0700441 $Declare = qr{(?:$Storage\s+(?:$Inline\s+)?)?$Type};
Andy Whitcroft8905a672007-11-28 16:21:06 -0800442}
443build_types();
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700444
Joe Perches7d2367a2011-07-25 17:13:22 -0700445our $Typecast = qr{\s*(\(\s*$NonptrType\s*\)){0,1}\s*};
Joe Perchesd1fe9c02012-03-23 15:02:16 -0700446
447# Using $balanced_parens, $LvalOrFunc, or $FuncArg
448# requires at least perl version v5.10.0
449# Any use must be runtime checked with $^V
450
451our $balanced_parens = qr/(\((?:[^\(\)]++|(?-1))*\))/;
Joe Perches24358802014-04-03 14:49:13 -0700452our $LvalOrFunc = qr{((?:[\&\*]\s*)?$Lval)\s*($balanced_parens{0,1})\s*};
Joe Perchesd7c76ba2012-01-10 15:09:58 -0800453our $FuncArg = qr{$Typecast{0,1}($LvalOrFunc|$Constant)};
Joe Perches7d2367a2011-07-25 17:13:22 -0700454
455sub deparenthesize {
456 my ($string) = @_;
457 return "" if (!defined($string));
Joe Perches5b9553a2014-04-03 14:49:21 -0700458
459 while ($string =~ /^\s*\(.*\)\s*$/) {
460 $string =~ s@^\s*\(\s*@@;
461 $string =~ s@\s*\)\s*$@@;
462 }
463
Joe Perches7d2367a2011-07-25 17:13:22 -0700464 $string =~ s@\s+@ @g;
Joe Perches5b9553a2014-04-03 14:49:21 -0700465
Joe Perches7d2367a2011-07-25 17:13:22 -0700466 return $string;
467}
468
Joe Perches34456862013-07-03 15:05:34 -0700469sub seed_camelcase_file {
470 my ($file) = @_;
471
472 return if (!(-f $file));
473
474 local $/;
475
476 open(my $include_file, '<', "$file")
477 or warn "$P: Can't read '$file' $!\n";
478 my $text = <$include_file>;
479 close($include_file);
480
481 my @lines = split('\n', $text);
482
483 foreach my $line (@lines) {
484 next if ($line !~ /(?:[A-Z][a-z]|[a-z][A-Z])/);
485 if ($line =~ /^[ \t]*(?:#[ \t]*define|typedef\s+$Type)\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)/) {
486 $camelcase{$1} = 1;
Joe Perches11ea5162013-11-12 15:10:08 -0800487 } elsif ($line =~ /^\s*$Declare\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)\s*[\(\[,;]/) {
488 $camelcase{$1} = 1;
489 } elsif ($line =~ /^\s*(?:union|struct|enum)\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)\s*[;\{]/) {
Joe Perches34456862013-07-03 15:05:34 -0700490 $camelcase{$1} = 1;
491 }
492 }
493}
494
495my $camelcase_seeded = 0;
496sub seed_camelcase_includes {
497 return if ($camelcase_seeded);
498
499 my $files;
Joe Perchesc707a812013-07-08 16:00:43 -0700500 my $camelcase_cache = "";
501 my @include_files = ();
502
503 $camelcase_seeded = 1;
Joe Perches351b2a12013-07-03 15:05:36 -0700504
Richard Genoud3645e322014-02-10 14:25:32 -0800505 if (-e ".git") {
Joe Perches351b2a12013-07-03 15:05:36 -0700506 my $git_last_include_commit = `git log --no-merges --pretty=format:"%h%n" -1 -- include`;
507 chomp $git_last_include_commit;
Joe Perchesc707a812013-07-08 16:00:43 -0700508 $camelcase_cache = ".checkpatch-camelcase.git.$git_last_include_commit";
Joe Perches34456862013-07-03 15:05:34 -0700509 } else {
Joe Perchesc707a812013-07-08 16:00:43 -0700510 my $last_mod_date = 0;
Joe Perches34456862013-07-03 15:05:34 -0700511 $files = `find $root/include -name "*.h"`;
Joe Perchesc707a812013-07-08 16:00:43 -0700512 @include_files = split('\n', $files);
513 foreach my $file (@include_files) {
514 my $date = POSIX::strftime("%Y%m%d%H%M",
515 localtime((stat $file)[9]));
516 $last_mod_date = $date if ($last_mod_date < $date);
517 }
518 $camelcase_cache = ".checkpatch-camelcase.date.$last_mod_date";
Joe Perches34456862013-07-03 15:05:34 -0700519 }
Joe Perchesc707a812013-07-08 16:00:43 -0700520
521 if ($camelcase_cache ne "" && -f $camelcase_cache) {
522 open(my $camelcase_file, '<', "$camelcase_cache")
523 or warn "$P: Can't read '$camelcase_cache' $!\n";
524 while (<$camelcase_file>) {
525 chomp;
526 $camelcase{$_} = 1;
527 }
528 close($camelcase_file);
529
530 return;
531 }
532
Richard Genoud3645e322014-02-10 14:25:32 -0800533 if (-e ".git") {
Joe Perchesc707a812013-07-08 16:00:43 -0700534 $files = `git ls-files "include/*.h"`;
535 @include_files = split('\n', $files);
536 }
537
Joe Perches34456862013-07-03 15:05:34 -0700538 foreach my $file (@include_files) {
539 seed_camelcase_file($file);
540 }
Joe Perches351b2a12013-07-03 15:05:36 -0700541
Joe Perchesc707a812013-07-08 16:00:43 -0700542 if ($camelcase_cache ne "") {
Joe Perches351b2a12013-07-03 15:05:36 -0700543 unlink glob ".checkpatch-camelcase.*";
Joe Perchesc707a812013-07-08 16:00:43 -0700544 open(my $camelcase_file, '>', "$camelcase_cache")
545 or warn "$P: Can't write '$camelcase_cache' $!\n";
Joe Perches351b2a12013-07-03 15:05:36 -0700546 foreach (sort { lc($a) cmp lc($b) } keys(%camelcase)) {
547 print $camelcase_file ("$_\n");
548 }
549 close($camelcase_file);
550 }
Joe Perches34456862013-07-03 15:05:34 -0700551}
552
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700553$chk_signoff = 0 if ($file);
554
Andy Whitcroft00df3442007-06-08 13:47:06 -0700555my @rawlines = ();
Andy Whitcroftc2fdda02008-02-08 04:20:54 -0800556my @lines = ();
Joe Perches3705ce52013-07-03 15:05:31 -0700557my @fixed = ();
Andy Whitcroftc2fdda02008-02-08 04:20:54 -0800558my $vname;
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700559for my $filename (@ARGV) {
Andy Whitcroft21caa132009-01-06 14:41:30 -0800560 my $FILE;
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700561 if ($file) {
Andy Whitcroft21caa132009-01-06 14:41:30 -0800562 open($FILE, '-|', "diff -u /dev/null $filename") ||
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700563 die "$P: $filename: diff failed - $!\n";
Andy Whitcroft21caa132009-01-06 14:41:30 -0800564 } elsif ($filename eq '-') {
565 open($FILE, '<&STDIN');
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700566 } else {
Andy Whitcroft21caa132009-01-06 14:41:30 -0800567 open($FILE, '<', "$filename") ||
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700568 die "$P: $filename: open failed - $!\n";
Andy Whitcroft0a920b52007-06-01 00:46:48 -0700569 }
Andy Whitcroftc2fdda02008-02-08 04:20:54 -0800570 if ($filename eq '-') {
571 $vname = 'Your patch';
572 } else {
573 $vname = $filename;
574 }
Andy Whitcroft21caa132009-01-06 14:41:30 -0800575 while (<$FILE>) {
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700576 chomp;
577 push(@rawlines, $_);
578 }
Andy Whitcroft21caa132009-01-06 14:41:30 -0800579 close($FILE);
Andy Whitcroftc2fdda02008-02-08 04:20:54 -0800580 if (!process($filename)) {
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700581 $exit = 1;
582 }
583 @rawlines = ();
Andy Whitcroft13214ad2008-02-08 04:22:03 -0800584 @lines = ();
Joe Perches3705ce52013-07-03 15:05:31 -0700585 @fixed = ();
Andy Whitcroft0a920b52007-06-01 00:46:48 -0700586}
587
588exit($exit);
589
590sub top_of_kernel_tree {
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700591 my ($root) = @_;
592
593 my @tree_check = (
594 "COPYING", "CREDITS", "Kbuild", "MAINTAINERS", "Makefile",
595 "README", "Documentation", "arch", "include", "drivers",
596 "fs", "init", "ipc", "kernel", "lib", "scripts",
597 );
598
599 foreach my $check (@tree_check) {
600 if (! -e $root . '/' . $check) {
601 return 0;
602 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -0700603 }
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700604 return 1;
Joe Perches8f26b832012-10-04 17:13:32 -0700605}
Andy Whitcroft0a920b52007-06-01 00:46:48 -0700606
Joe Perches20112472011-07-25 17:13:23 -0700607sub parse_email {
608 my ($formatted_email) = @_;
609
610 my $name = "";
611 my $address = "";
612 my $comment = "";
613
614 if ($formatted_email =~ /^(.*)<(\S+\@\S+)>(.*)$/) {
615 $name = $1;
616 $address = $2;
617 $comment = $3 if defined $3;
618 } elsif ($formatted_email =~ /^\s*<(\S+\@\S+)>(.*)$/) {
619 $address = $1;
620 $comment = $2 if defined $2;
621 } elsif ($formatted_email =~ /(\S+\@\S+)(.*)$/) {
622 $address = $1;
623 $comment = $2 if defined $2;
624 $formatted_email =~ s/$address.*$//;
625 $name = $formatted_email;
Joe Perches3705ce52013-07-03 15:05:31 -0700626 $name = trim($name);
Joe Perches20112472011-07-25 17:13:23 -0700627 $name =~ s/^\"|\"$//g;
628 # If there's a name left after stripping spaces and
629 # leading quotes, and the address doesn't have both
630 # leading and trailing angle brackets, the address
631 # is invalid. ie:
632 # "joe smith joe@smith.com" bad
633 # "joe smith <joe@smith.com" bad
634 if ($name ne "" && $address !~ /^<[^>]+>$/) {
635 $name = "";
636 $address = "";
637 $comment = "";
638 }
639 }
640
Joe Perches3705ce52013-07-03 15:05:31 -0700641 $name = trim($name);
Joe Perches20112472011-07-25 17:13:23 -0700642 $name =~ s/^\"|\"$//g;
Joe Perches3705ce52013-07-03 15:05:31 -0700643 $address = trim($address);
Joe Perches20112472011-07-25 17:13:23 -0700644 $address =~ s/^\<|\>$//g;
645
646 if ($name =~ /[^\w \-]/i) { ##has "must quote" chars
647 $name =~ s/(?<!\\)"/\\"/g; ##escape quotes
648 $name = "\"$name\"";
649 }
650
651 return ($name, $address, $comment);
652}
653
654sub format_email {
655 my ($name, $address) = @_;
656
657 my $formatted_email;
658
Joe Perches3705ce52013-07-03 15:05:31 -0700659 $name = trim($name);
Joe Perches20112472011-07-25 17:13:23 -0700660 $name =~ s/^\"|\"$//g;
Joe Perches3705ce52013-07-03 15:05:31 -0700661 $address = trim($address);
Joe Perches20112472011-07-25 17:13:23 -0700662
663 if ($name =~ /[^\w \-]/i) { ##has "must quote" chars
664 $name =~ s/(?<!\\)"/\\"/g; ##escape quotes
665 $name = "\"$name\"";
666 }
667
668 if ("$name" eq "") {
669 $formatted_email = "$address";
670 } else {
671 $formatted_email = "$name <$address>";
672 }
673
674 return $formatted_email;
675}
676
Joe Perches000d1cc12011-07-25 17:13:25 -0700677sub which_conf {
678 my ($conf) = @_;
679
680 foreach my $path (split(/:/, ".:$ENV{HOME}:.scripts")) {
681 if (-e "$path/$conf") {
682 return "$path/$conf";
683 }
684 }
685
686 return "";
687}
688
Andy Whitcroft0a920b52007-06-01 00:46:48 -0700689sub expand_tabs {
690 my ($str) = @_;
691
692 my $res = '';
693 my $n = 0;
694 for my $c (split(//, $str)) {
695 if ($c eq "\t") {
696 $res .= ' ';
697 $n++;
698 for (; ($n % 8) != 0; $n++) {
699 $res .= ' ';
700 }
701 next;
702 }
703 $res .= $c;
704 $n++;
705 }
706
707 return $res;
708}
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700709sub copy_spacing {
Andy Whitcroft773647a2008-03-28 14:15:58 -0700710 (my $res = shift) =~ tr/\t/ /c;
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700711 return $res;
712}
Andy Whitcroft0a920b52007-06-01 00:46:48 -0700713
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -0700714sub line_stats {
715 my ($line) = @_;
716
717 # Drop the diff line leader and expand tabs
718 $line =~ s/^.//;
719 $line = expand_tabs($line);
720
721 # Pick the indent from the front of the line.
722 my ($white) = ($line =~ /^(\s*)/);
723
724 return (length($line), length($white));
725}
726
Andy Whitcroft773647a2008-03-28 14:15:58 -0700727my $sanitise_quote = '';
728
729sub sanitise_line_reset {
730 my ($in_comment) = @_;
731
732 if ($in_comment) {
733 $sanitise_quote = '*/';
734 } else {
735 $sanitise_quote = '';
736 }
737}
Andy Whitcroft00df3442007-06-08 13:47:06 -0700738sub sanitise_line {
739 my ($line) = @_;
740
741 my $res = '';
742 my $l = '';
743
Andy Whitcroftc2fdda02008-02-08 04:20:54 -0800744 my $qlen = 0;
Andy Whitcroft773647a2008-03-28 14:15:58 -0700745 my $off = 0;
746 my $c;
Andy Whitcroft00df3442007-06-08 13:47:06 -0700747
Andy Whitcroft773647a2008-03-28 14:15:58 -0700748 # Always copy over the diff marker.
749 $res = substr($line, 0, 1);
750
751 for ($off = 1; $off < length($line); $off++) {
752 $c = substr($line, $off, 1);
753
754 # Comments we are wacking completly including the begin
755 # and end, all to $;.
756 if ($sanitise_quote eq '' && substr($line, $off, 2) eq '/*') {
757 $sanitise_quote = '*/';
758
759 substr($res, $off, 2, "$;$;");
760 $off++;
761 next;
Andy Whitcroftc2fdda02008-02-08 04:20:54 -0800762 }
Andy Whitcroft81bc0e02008-10-15 22:02:26 -0700763 if ($sanitise_quote eq '*/' && substr($line, $off, 2) eq '*/') {
Andy Whitcroft773647a2008-03-28 14:15:58 -0700764 $sanitise_quote = '';
765 substr($res, $off, 2, "$;$;");
766 $off++;
767 next;
768 }
Daniel Walker113f04a2009-09-21 17:04:35 -0700769 if ($sanitise_quote eq '' && substr($line, $off, 2) eq '//') {
770 $sanitise_quote = '//';
771
772 substr($res, $off, 2, $sanitise_quote);
773 $off++;
774 next;
775 }
Andy Whitcroft773647a2008-03-28 14:15:58 -0700776
777 # A \ in a string means ignore the next character.
778 if (($sanitise_quote eq "'" || $sanitise_quote eq '"') &&
779 $c eq "\\") {
780 substr($res, $off, 2, 'XX');
781 $off++;
782 next;
783 }
784 # Regular quotes.
785 if ($c eq "'" || $c eq '"') {
786 if ($sanitise_quote eq '') {
787 $sanitise_quote = $c;
788
789 substr($res, $off, 1, $c);
Andy Whitcroft00df3442007-06-08 13:47:06 -0700790 next;
Andy Whitcroft773647a2008-03-28 14:15:58 -0700791 } elsif ($sanitise_quote eq $c) {
792 $sanitise_quote = '';
Andy Whitcroft00df3442007-06-08 13:47:06 -0700793 }
794 }
Andy Whitcroft773647a2008-03-28 14:15:58 -0700795
Andy Whitcroftfae17da2009-01-06 14:41:20 -0800796 #print "c<$c> SQ<$sanitise_quote>\n";
Andy Whitcroft773647a2008-03-28 14:15:58 -0700797 if ($off != 0 && $sanitise_quote eq '*/' && $c ne "\t") {
798 substr($res, $off, 1, $;);
Daniel Walker113f04a2009-09-21 17:04:35 -0700799 } elsif ($off != 0 && $sanitise_quote eq '//' && $c ne "\t") {
800 substr($res, $off, 1, $;);
Andy Whitcroft773647a2008-03-28 14:15:58 -0700801 } elsif ($off != 0 && $sanitise_quote && $c ne "\t") {
802 substr($res, $off, 1, 'X');
Andy Whitcroft00df3442007-06-08 13:47:06 -0700803 } else {
Andy Whitcroft773647a2008-03-28 14:15:58 -0700804 substr($res, $off, 1, $c);
Andy Whitcroft00df3442007-06-08 13:47:06 -0700805 }
Andy Whitcroftc2fdda02008-02-08 04:20:54 -0800806 }
807
Daniel Walker113f04a2009-09-21 17:04:35 -0700808 if ($sanitise_quote eq '//') {
809 $sanitise_quote = '';
810 }
811
Andy Whitcroftc2fdda02008-02-08 04:20:54 -0800812 # The pathname on a #include may be surrounded by '<' and '>'.
Andy Whitcroftc45dcab2008-06-05 22:46:01 -0700813 if ($res =~ /^.\s*\#\s*include\s+\<(.*)\>/) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -0800814 my $clean = 'X' x length($1);
815 $res =~ s@\<.*\>@<$clean>@;
816
817 # The whole of a #error is a string.
Andy Whitcroftc45dcab2008-06-05 22:46:01 -0700818 } elsif ($res =~ /^.\s*\#\s*(?:error|warning)\s+(.*)\b/) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -0800819 my $clean = 'X' x length($1);
Andy Whitcroftc45dcab2008-06-05 22:46:01 -0700820 $res =~ s@(\#\s*(?:error|warning)\s+).*@$1$clean@;
Andy Whitcroftc2fdda02008-02-08 04:20:54 -0800821 }
822
Andy Whitcroft00df3442007-06-08 13:47:06 -0700823 return $res;
824}
825
Joe Perchesa6962d72013-04-29 16:18:13 -0700826sub get_quoted_string {
827 my ($line, $rawline) = @_;
828
829 return "" if ($line !~ m/(\"[X]+\")/g);
830 return substr($rawline, $-[0], $+[0] - $-[0]);
831}
832
Andy Whitcroft8905a672007-11-28 16:21:06 -0800833sub ctx_statement_block {
834 my ($linenr, $remain, $off) = @_;
835 my $line = $linenr - 1;
836 my $blk = '';
837 my $soff = $off;
838 my $coff = $off - 1;
Andy Whitcroft773647a2008-03-28 14:15:58 -0700839 my $coff_set = 0;
Andy Whitcroft8905a672007-11-28 16:21:06 -0800840
Andy Whitcroft13214ad2008-02-08 04:22:03 -0800841 my $loff = 0;
842
Andy Whitcroft8905a672007-11-28 16:21:06 -0800843 my $type = '';
844 my $level = 0;
Andy Whitcrofta2750642009-01-15 13:51:04 -0800845 my @stack = ();
Andy Whitcroftcf655042008-03-04 14:28:20 -0800846 my $p;
Andy Whitcroft8905a672007-11-28 16:21:06 -0800847 my $c;
848 my $len = 0;
Andy Whitcroft13214ad2008-02-08 04:22:03 -0800849
850 my $remainder;
Andy Whitcroft8905a672007-11-28 16:21:06 -0800851 while (1) {
Andy Whitcrofta2750642009-01-15 13:51:04 -0800852 @stack = (['', 0]) if ($#stack == -1);
853
Andy Whitcroft773647a2008-03-28 14:15:58 -0700854 #warn "CSB: blk<$blk> remain<$remain>\n";
Andy Whitcroft8905a672007-11-28 16:21:06 -0800855 # If we are about to drop off the end, pull in more
856 # context.
857 if ($off >= $len) {
858 for (; $remain > 0; $line++) {
Andy Whitcroftdea33492008-10-15 22:02:25 -0700859 last if (!defined $lines[$line]);
Andy Whitcroftc2fdda02008-02-08 04:20:54 -0800860 next if ($lines[$line] =~ /^-/);
Andy Whitcroft8905a672007-11-28 16:21:06 -0800861 $remain--;
Andy Whitcroft13214ad2008-02-08 04:22:03 -0800862 $loff = $len;
Andy Whitcroftc2fdda02008-02-08 04:20:54 -0800863 $blk .= $lines[$line] . "\n";
Andy Whitcroft8905a672007-11-28 16:21:06 -0800864 $len = length($blk);
865 $line++;
866 last;
867 }
868 # Bail if there is no further context.
869 #warn "CSB: blk<$blk> off<$off> len<$len>\n";
Andy Whitcroft13214ad2008-02-08 04:22:03 -0800870 if ($off >= $len) {
Andy Whitcroft8905a672007-11-28 16:21:06 -0800871 last;
872 }
Andy Whitcroftf74bd192012-01-10 15:09:54 -0800873 if ($level == 0 && substr($blk, $off) =~ /^.\s*#\s*define/) {
874 $level++;
875 $type = '#';
876 }
Andy Whitcroft8905a672007-11-28 16:21:06 -0800877 }
Andy Whitcroftcf655042008-03-04 14:28:20 -0800878 $p = $c;
Andy Whitcroft8905a672007-11-28 16:21:06 -0800879 $c = substr($blk, $off, 1);
Andy Whitcroft13214ad2008-02-08 04:22:03 -0800880 $remainder = substr($blk, $off);
Andy Whitcroft8905a672007-11-28 16:21:06 -0800881
Andy Whitcroft773647a2008-03-28 14:15:58 -0700882 #warn "CSB: c<$c> type<$type> level<$level> remainder<$remainder> coff_set<$coff_set>\n";
Andy Whitcroft4635f4f2009-01-06 14:41:27 -0800883
884 # Handle nested #if/#else.
885 if ($remainder =~ /^#\s*(?:ifndef|ifdef|if)\s/) {
886 push(@stack, [ $type, $level ]);
887 } elsif ($remainder =~ /^#\s*(?:else|elif)\b/) {
888 ($type, $level) = @{$stack[$#stack - 1]};
889 } elsif ($remainder =~ /^#\s*endif\b/) {
890 ($type, $level) = @{pop(@stack)};
891 }
892
Andy Whitcroft8905a672007-11-28 16:21:06 -0800893 # Statement ends at the ';' or a close '}' at the
894 # outermost level.
895 if ($level == 0 && $c eq ';') {
896 last;
897 }
898
Andy Whitcroft13214ad2008-02-08 04:22:03 -0800899 # An else is really a conditional as long as its not else if
Andy Whitcroft773647a2008-03-28 14:15:58 -0700900 if ($level == 0 && $coff_set == 0 &&
901 (!defined($p) || $p =~ /(?:\s|\}|\+)/) &&
902 $remainder =~ /^(else)(?:\s|{)/ &&
903 $remainder !~ /^else\s+if\b/) {
904 $coff = $off + length($1) - 1;
905 $coff_set = 1;
906 #warn "CSB: mark coff<$coff> soff<$soff> 1<$1>\n";
907 #warn "[" . substr($blk, $soff, $coff - $soff + 1) . "]\n";
Andy Whitcroft13214ad2008-02-08 04:22:03 -0800908 }
909
Andy Whitcroft8905a672007-11-28 16:21:06 -0800910 if (($type eq '' || $type eq '(') && $c eq '(') {
911 $level++;
912 $type = '(';
913 }
914 if ($type eq '(' && $c eq ')') {
915 $level--;
916 $type = ($level != 0)? '(' : '';
917
918 if ($level == 0 && $coff < $soff) {
919 $coff = $off;
Andy Whitcroft773647a2008-03-28 14:15:58 -0700920 $coff_set = 1;
921 #warn "CSB: mark coff<$coff>\n";
Andy Whitcroft8905a672007-11-28 16:21:06 -0800922 }
923 }
924 if (($type eq '' || $type eq '{') && $c eq '{') {
925 $level++;
926 $type = '{';
927 }
928 if ($type eq '{' && $c eq '}') {
929 $level--;
930 $type = ($level != 0)? '{' : '';
931
932 if ($level == 0) {
Patrick Pannutob998e002010-08-09 17:21:03 -0700933 if (substr($blk, $off + 1, 1) eq ';') {
934 $off++;
935 }
Andy Whitcroft8905a672007-11-28 16:21:06 -0800936 last;
937 }
938 }
Andy Whitcroftf74bd192012-01-10 15:09:54 -0800939 # Preprocessor commands end at the newline unless escaped.
940 if ($type eq '#' && $c eq "\n" && $p ne "\\") {
941 $level--;
942 $type = '';
943 $off++;
944 last;
945 }
Andy Whitcroft8905a672007-11-28 16:21:06 -0800946 $off++;
947 }
Andy Whitcrofta3bb97a2008-07-23 21:29:00 -0700948 # We are truly at the end, so shuffle to the next line.
Andy Whitcroft13214ad2008-02-08 04:22:03 -0800949 if ($off == $len) {
Andy Whitcrofta3bb97a2008-07-23 21:29:00 -0700950 $loff = $len + 1;
Andy Whitcroft13214ad2008-02-08 04:22:03 -0800951 $line++;
952 $remain--;
953 }
Andy Whitcroft8905a672007-11-28 16:21:06 -0800954
955 my $statement = substr($blk, $soff, $off - $soff + 1);
956 my $condition = substr($blk, $soff, $coff - $soff + 1);
957
958 #warn "STATEMENT<$statement>\n";
959 #warn "CONDITION<$condition>\n";
960
Andy Whitcroft773647a2008-03-28 14:15:58 -0700961 #print "coff<$coff> soff<$off> loff<$loff>\n";
Andy Whitcroft13214ad2008-02-08 04:22:03 -0800962
963 return ($statement, $condition,
964 $line, $remain + 1, $off - $loff + 1, $level);
965}
966
Andy Whitcroftcf655042008-03-04 14:28:20 -0800967sub statement_lines {
968 my ($stmt) = @_;
969
970 # Strip the diff line prefixes and rip blank lines at start and end.
971 $stmt =~ s/(^|\n)./$1/g;
972 $stmt =~ s/^\s*//;
973 $stmt =~ s/\s*$//;
974
975 my @stmt_lines = ($stmt =~ /\n/g);
976
977 return $#stmt_lines + 2;
978}
979
980sub statement_rawlines {
981 my ($stmt) = @_;
982
983 my @stmt_lines = ($stmt =~ /\n/g);
984
985 return $#stmt_lines + 2;
986}
987
988sub statement_block_size {
989 my ($stmt) = @_;
990
991 $stmt =~ s/(^|\n)./$1/g;
992 $stmt =~ s/^\s*{//;
993 $stmt =~ s/}\s*$//;
994 $stmt =~ s/^\s*//;
995 $stmt =~ s/\s*$//;
996
997 my @stmt_lines = ($stmt =~ /\n/g);
998 my @stmt_statements = ($stmt =~ /;/g);
999
1000 my $stmt_lines = $#stmt_lines + 2;
1001 my $stmt_statements = $#stmt_statements + 1;
1002
1003 if ($stmt_lines > $stmt_statements) {
1004 return $stmt_lines;
1005 } else {
1006 return $stmt_statements;
1007 }
1008}
1009
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001010sub ctx_statement_full {
1011 my ($linenr, $remain, $off) = @_;
1012 my ($statement, $condition, $level);
1013
1014 my (@chunks);
1015
Andy Whitcroftcf655042008-03-04 14:28:20 -08001016 # Grab the first conditional/block pair.
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001017 ($statement, $condition, $linenr, $remain, $off, $level) =
1018 ctx_statement_block($linenr, $remain, $off);
Andy Whitcroft773647a2008-03-28 14:15:58 -07001019 #print "F: c<$condition> s<$statement> remain<$remain>\n";
Andy Whitcroftcf655042008-03-04 14:28:20 -08001020 push(@chunks, [ $condition, $statement ]);
1021 if (!($remain > 0 && $condition =~ /^\s*(?:\n[+-])?\s*(?:if|else|do)\b/s)) {
1022 return ($level, $linenr, @chunks);
1023 }
1024
1025 # Pull in the following conditional/block pairs and see if they
1026 # could continue the statement.
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001027 for (;;) {
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001028 ($statement, $condition, $linenr, $remain, $off, $level) =
1029 ctx_statement_block($linenr, $remain, $off);
Andy Whitcroftcf655042008-03-04 14:28:20 -08001030 #print "C: c<$condition> s<$statement> remain<$remain>\n";
Andy Whitcroft773647a2008-03-28 14:15:58 -07001031 last if (!($remain > 0 && $condition =~ /^(?:\s*\n[+-])*\s*(?:else|do)\b/s));
Andy Whitcroftcf655042008-03-04 14:28:20 -08001032 #print "C: push\n";
1033 push(@chunks, [ $condition, $statement ]);
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001034 }
1035
1036 return ($level, $linenr, @chunks);
Andy Whitcroft8905a672007-11-28 16:21:06 -08001037}
1038
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001039sub ctx_block_get {
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001040 my ($linenr, $remain, $outer, $open, $close, $off) = @_;
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001041 my $line;
1042 my $start = $linenr - 1;
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001043 my $blk = '';
1044 my @o;
1045 my @c;
1046 my @res = ();
1047
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001048 my $level = 0;
Andy Whitcroft4635f4f2009-01-06 14:41:27 -08001049 my @stack = ($level);
Andy Whitcroft00df3442007-06-08 13:47:06 -07001050 for ($line = $start; $remain > 0; $line++) {
1051 next if ($rawlines[$line] =~ /^-/);
1052 $remain--;
1053
1054 $blk .= $rawlines[$line];
Andy Whitcroft4635f4f2009-01-06 14:41:27 -08001055
1056 # Handle nested #if/#else.
Andy Whitcroft01464f32010-10-26 14:23:19 -07001057 if ($lines[$line] =~ /^.\s*#\s*(?:ifndef|ifdef|if)\s/) {
Andy Whitcroft4635f4f2009-01-06 14:41:27 -08001058 push(@stack, $level);
Andy Whitcroft01464f32010-10-26 14:23:19 -07001059 } elsif ($lines[$line] =~ /^.\s*#\s*(?:else|elif)\b/) {
Andy Whitcroft4635f4f2009-01-06 14:41:27 -08001060 $level = $stack[$#stack - 1];
Andy Whitcroft01464f32010-10-26 14:23:19 -07001061 } elsif ($lines[$line] =~ /^.\s*#\s*endif\b/) {
Andy Whitcroft4635f4f2009-01-06 14:41:27 -08001062 $level = pop(@stack);
1063 }
1064
Andy Whitcroft01464f32010-10-26 14:23:19 -07001065 foreach my $c (split(//, $lines[$line])) {
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001066 ##print "C<$c>L<$level><$open$close>O<$off>\n";
1067 if ($off > 0) {
1068 $off--;
1069 next;
1070 }
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001071
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001072 if ($c eq $close && $level > 0) {
1073 $level--;
1074 last if ($level == 0);
1075 } elsif ($c eq $open) {
1076 $level++;
1077 }
1078 }
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001079
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001080 if (!$outer || $level <= 1) {
Andy Whitcroft00df3442007-06-08 13:47:06 -07001081 push(@res, $rawlines[$line]);
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001082 }
1083
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001084 last if ($level == 0);
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001085 }
1086
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001087 return ($level, @res);
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001088}
1089sub ctx_block_outer {
1090 my ($linenr, $remain) = @_;
1091
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001092 my ($level, @r) = ctx_block_get($linenr, $remain, 1, '{', '}', 0);
1093 return @r;
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001094}
1095sub ctx_block {
1096 my ($linenr, $remain) = @_;
1097
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001098 my ($level, @r) = ctx_block_get($linenr, $remain, 0, '{', '}', 0);
1099 return @r;
Andy Whitcroft653d4872007-06-23 17:16:34 -07001100}
1101sub ctx_statement {
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001102 my ($linenr, $remain, $off) = @_;
1103
1104 my ($level, @r) = ctx_block_get($linenr, $remain, 0, '(', ')', $off);
1105 return @r;
1106}
1107sub ctx_block_level {
Andy Whitcroft653d4872007-06-23 17:16:34 -07001108 my ($linenr, $remain) = @_;
1109
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001110 return ctx_block_get($linenr, $remain, 0, '{', '}', 0);
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001111}
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07001112sub ctx_statement_level {
1113 my ($linenr, $remain, $off) = @_;
1114
1115 return ctx_block_get($linenr, $remain, 0, '(', ')', $off);
1116}
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001117
1118sub ctx_locate_comment {
1119 my ($first_line, $end_line) = @_;
1120
1121 # Catch a comment on the end of the line itself.
Andy Whitcroftbeae6332008-07-23 21:28:59 -07001122 my ($current_comment) = ($rawlines[$end_line - 1] =~ m@.*(/\*.*\*/)\s*(?:\\\s*)?$@);
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001123 return $current_comment if (defined $current_comment);
1124
1125 # Look through the context and try and figure out if there is a
1126 # comment.
1127 my $in_comment = 0;
1128 $current_comment = '';
1129 for (my $linenr = $first_line; $linenr < $end_line; $linenr++) {
Andy Whitcroft00df3442007-06-08 13:47:06 -07001130 my $line = $rawlines[$linenr - 1];
1131 #warn " $line\n";
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001132 if ($linenr == $first_line and $line =~ m@^.\s*\*@) {
1133 $in_comment = 1;
1134 }
1135 if ($line =~ m@/\*@) {
1136 $in_comment = 1;
1137 }
1138 if (!$in_comment && $current_comment ne '') {
1139 $current_comment = '';
1140 }
1141 $current_comment .= $line . "\n" if ($in_comment);
1142 if ($line =~ m@\*/@) {
1143 $in_comment = 0;
1144 }
1145 }
1146
1147 chomp($current_comment);
1148 return($current_comment);
1149}
1150sub ctx_has_comment {
1151 my ($first_line, $end_line) = @_;
1152 my $cmt = ctx_locate_comment($first_line, $end_line);
1153
Andy Whitcroft00df3442007-06-08 13:47:06 -07001154 ##print "LINE: $rawlines[$end_line - 1 ]\n";
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001155 ##print "CMMT: $cmt\n";
1156
1157 return ($cmt ne '');
1158}
1159
Andy Whitcroft4d001e42008-10-15 22:02:21 -07001160sub raw_line {
1161 my ($linenr, $cnt) = @_;
1162
1163 my $offset = $linenr - 1;
1164 $cnt++;
1165
1166 my $line;
1167 while ($cnt) {
1168 $line = $rawlines[$offset++];
1169 next if (defined($line) && $line =~ /^-/);
1170 $cnt--;
1171 }
1172
1173 return $line;
1174}
1175
Andy Whitcroft0a920b52007-06-01 00:46:48 -07001176sub cat_vet {
1177 my ($vet) = @_;
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07001178 my ($res, $coded);
Andy Whitcroft0a920b52007-06-01 00:46:48 -07001179
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07001180 $res = '';
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001181 while ($vet =~ /([^[:cntrl:]]*)([[:cntrl:]]|$)/g) {
1182 $res .= $1;
1183 if ($2 ne '') {
1184 $coded = sprintf("^%c", unpack('C', $2) + 64);
1185 $res .= $coded;
1186 }
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07001187 }
1188 $res =~ s/$/\$/;
Andy Whitcroft0a920b52007-06-01 00:46:48 -07001189
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07001190 return $res;
Andy Whitcroft0a920b52007-06-01 00:46:48 -07001191}
1192
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001193my $av_preprocessor = 0;
Andy Whitcroftcf655042008-03-04 14:28:20 -08001194my $av_pending;
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001195my @av_paren_type;
Andy Whitcroft1f65f942008-07-23 21:29:10 -07001196my $av_pend_colon;
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001197
1198sub annotate_reset {
1199 $av_preprocessor = 0;
Andy Whitcroftcf655042008-03-04 14:28:20 -08001200 $av_pending = '_';
1201 @av_paren_type = ('E');
Andy Whitcroft1f65f942008-07-23 21:29:10 -07001202 $av_pend_colon = 'O';
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001203}
1204
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001205sub annotate_values {
1206 my ($stream, $type) = @_;
1207
1208 my $res;
Andy Whitcroft1f65f942008-07-23 21:29:10 -07001209 my $var = '_' x length($stream);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001210 my $cur = $stream;
1211
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001212 print "$stream\n" if ($dbg_values > 1);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001213
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001214 while (length($cur)) {
Andy Whitcroft773647a2008-03-28 14:15:58 -07001215 @av_paren_type = ('E') if ($#av_paren_type < 0);
Andy Whitcroftcf655042008-03-04 14:28:20 -08001216 print " <" . join('', @av_paren_type) .
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07001217 "> <$type> <$av_pending>" if ($dbg_values > 1);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001218 if ($cur =~ /^(\s+)/o) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001219 print "WS($1)\n" if ($dbg_values > 1);
1220 if ($1 =~ /\n/ && $av_preprocessor) {
Andy Whitcroftcf655042008-03-04 14:28:20 -08001221 $type = pop(@av_paren_type);
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001222 $av_preprocessor = 0;
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001223 }
1224
Florian Micklerc023e4732011-01-12 16:59:58 -08001225 } elsif ($cur =~ /^(\(\s*$Type\s*)\)/ && $av_pending eq '_') {
Andy Whitcroft9446ef52010-10-26 14:23:13 -07001226 print "CAST($1)\n" if ($dbg_values > 1);
1227 push(@av_paren_type, $type);
Andy Whitcroftaddcdce2012-01-10 15:10:11 -08001228 $type = 'c';
Andy Whitcroft9446ef52010-10-26 14:23:13 -07001229
Andy Whitcrofte91b6e22010-10-26 14:23:11 -07001230 } elsif ($cur =~ /^($Type)\s*(?:$Ident|,|\)|\(|\s*$)/) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001231 print "DECLARE($1)\n" if ($dbg_values > 1);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001232 $type = 'T';
1233
Andy Whitcroft389a2fe2008-07-23 21:29:05 -07001234 } elsif ($cur =~ /^($Modifier)\s*/) {
1235 print "MODIFIER($1)\n" if ($dbg_values > 1);
1236 $type = 'T';
1237
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07001238 } elsif ($cur =~ /^(\#\s*define\s*$Ident)(\(?)/o) {
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07001239 print "DEFINE($1,$2)\n" if ($dbg_values > 1);
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001240 $av_preprocessor = 1;
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07001241 push(@av_paren_type, $type);
1242 if ($2 ne '') {
1243 $av_pending = 'N';
1244 }
1245 $type = 'E';
1246
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07001247 } elsif ($cur =~ /^(\#\s*(?:undef\s*$Ident|include\b))/o) {
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07001248 print "UNDEF($1)\n" if ($dbg_values > 1);
1249 $av_preprocessor = 1;
1250 push(@av_paren_type, $type);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001251
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07001252 } elsif ($cur =~ /^(\#\s*(?:ifdef|ifndef|if))/o) {
Andy Whitcroftcf655042008-03-04 14:28:20 -08001253 print "PRE_START($1)\n" if ($dbg_values > 1);
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001254 $av_preprocessor = 1;
Andy Whitcroftcf655042008-03-04 14:28:20 -08001255
1256 push(@av_paren_type, $type);
1257 push(@av_paren_type, $type);
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07001258 $type = 'E';
Andy Whitcroftcf655042008-03-04 14:28:20 -08001259
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07001260 } elsif ($cur =~ /^(\#\s*(?:else|elif))/o) {
Andy Whitcroftcf655042008-03-04 14:28:20 -08001261 print "PRE_RESTART($1)\n" if ($dbg_values > 1);
1262 $av_preprocessor = 1;
1263
1264 push(@av_paren_type, $av_paren_type[$#av_paren_type]);
1265
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07001266 $type = 'E';
Andy Whitcroftcf655042008-03-04 14:28:20 -08001267
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07001268 } elsif ($cur =~ /^(\#\s*(?:endif))/o) {
Andy Whitcroftcf655042008-03-04 14:28:20 -08001269 print "PRE_END($1)\n" if ($dbg_values > 1);
1270
1271 $av_preprocessor = 1;
1272
1273 # Assume all arms of the conditional end as this
1274 # one does, and continue as if the #endif was not here.
1275 pop(@av_paren_type);
1276 push(@av_paren_type, $type);
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07001277 $type = 'E';
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001278
1279 } elsif ($cur =~ /^(\\\n)/o) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001280 print "PRECONT($1)\n" if ($dbg_values > 1);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001281
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07001282 } elsif ($cur =~ /^(__attribute__)\s*\(?/o) {
1283 print "ATTR($1)\n" if ($dbg_values > 1);
1284 $av_pending = $type;
1285 $type = 'N';
1286
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001287 } elsif ($cur =~ /^(sizeof)\s*(\()?/o) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001288 print "SIZEOF($1)\n" if ($dbg_values > 1);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001289 if (defined $2) {
Andy Whitcroftcf655042008-03-04 14:28:20 -08001290 $av_pending = 'V';
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001291 }
1292 $type = 'N';
1293
Andy Whitcroft14b111c2008-10-15 22:02:16 -07001294 } elsif ($cur =~ /^(if|while|for)\b/o) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001295 print "COND($1)\n" if ($dbg_values > 1);
Andy Whitcroft14b111c2008-10-15 22:02:16 -07001296 $av_pending = 'E';
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001297 $type = 'N';
1298
Andy Whitcroft1f65f942008-07-23 21:29:10 -07001299 } elsif ($cur =~/^(case)/o) {
1300 print "CASE($1)\n" if ($dbg_values > 1);
1301 $av_pend_colon = 'C';
1302 $type = 'N';
1303
Andy Whitcroft14b111c2008-10-15 22:02:16 -07001304 } elsif ($cur =~/^(return|else|goto|typeof|__typeof__)\b/o) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001305 print "KEYWORD($1)\n" if ($dbg_values > 1);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001306 $type = 'N';
1307
1308 } elsif ($cur =~ /^(\()/o) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001309 print "PAREN('$1')\n" if ($dbg_values > 1);
Andy Whitcroftcf655042008-03-04 14:28:20 -08001310 push(@av_paren_type, $av_pending);
1311 $av_pending = '_';
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001312 $type = 'N';
1313
1314 } elsif ($cur =~ /^(\))/o) {
Andy Whitcroftcf655042008-03-04 14:28:20 -08001315 my $new_type = pop(@av_paren_type);
1316 if ($new_type ne '_') {
1317 $type = $new_type;
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001318 print "PAREN('$1') -> $type\n"
1319 if ($dbg_values > 1);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001320 } else {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001321 print "PAREN('$1')\n" if ($dbg_values > 1);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001322 }
1323
Andy Whitcroftc8cb2ca2008-07-23 21:28:57 -07001324 } elsif ($cur =~ /^($Ident)\s*\(/o) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001325 print "FUNC($1)\n" if ($dbg_values > 1);
Andy Whitcroftc8cb2ca2008-07-23 21:28:57 -07001326 $type = 'V';
Andy Whitcroftcf655042008-03-04 14:28:20 -08001327 $av_pending = 'V';
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001328
Andy Whitcroft8e761b02009-01-06 14:41:19 -08001329 } elsif ($cur =~ /^($Ident\s*):(?:\s*\d+\s*(,|=|;))?/) {
1330 if (defined $2 && $type eq 'C' || $type eq 'T') {
Andy Whitcroft1f65f942008-07-23 21:29:10 -07001331 $av_pend_colon = 'B';
Andy Whitcroft8e761b02009-01-06 14:41:19 -08001332 } elsif ($type eq 'E') {
1333 $av_pend_colon = 'L';
Andy Whitcroft1f65f942008-07-23 21:29:10 -07001334 }
1335 print "IDENT_COLON($1,$type>$av_pend_colon)\n" if ($dbg_values > 1);
1336 $type = 'V';
1337
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001338 } elsif ($cur =~ /^($Ident|$Constant)/o) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001339 print "IDENT($1)\n" if ($dbg_values > 1);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001340 $type = 'V';
1341
1342 } elsif ($cur =~ /^($Assignment)/o) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001343 print "ASSIGN($1)\n" if ($dbg_values > 1);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001344 $type = 'N';
1345
Andy Whitcroftcf655042008-03-04 14:28:20 -08001346 } elsif ($cur =~/^(;|{|})/) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001347 print "END($1)\n" if ($dbg_values > 1);
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001348 $type = 'E';
Andy Whitcroft1f65f942008-07-23 21:29:10 -07001349 $av_pend_colon = 'O';
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001350
Andy Whitcroft8e761b02009-01-06 14:41:19 -08001351 } elsif ($cur =~/^(,)/) {
1352 print "COMMA($1)\n" if ($dbg_values > 1);
1353 $type = 'C';
1354
Andy Whitcroft1f65f942008-07-23 21:29:10 -07001355 } elsif ($cur =~ /^(\?)/o) {
1356 print "QUESTION($1)\n" if ($dbg_values > 1);
1357 $type = 'N';
1358
1359 } elsif ($cur =~ /^(:)/o) {
1360 print "COLON($1,$av_pend_colon)\n" if ($dbg_values > 1);
1361
1362 substr($var, length($res), 1, $av_pend_colon);
1363 if ($av_pend_colon eq 'C' || $av_pend_colon eq 'L') {
1364 $type = 'E';
1365 } else {
1366 $type = 'N';
1367 }
1368 $av_pend_colon = 'O';
1369
Andy Whitcroft8e761b02009-01-06 14:41:19 -08001370 } elsif ($cur =~ /^(\[)/o) {
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001371 print "CLOSE($1)\n" if ($dbg_values > 1);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001372 $type = 'N';
1373
Andy Whitcroft0d413862008-10-15 22:02:16 -07001374 } elsif ($cur =~ /^(-(?![->])|\+(?!\+)|\*|\&\&|\&)/o) {
Andy Whitcroft74048ed2008-07-23 21:29:10 -07001375 my $variant;
1376
1377 print "OPV($1)\n" if ($dbg_values > 1);
1378 if ($type eq 'V') {
1379 $variant = 'B';
1380 } else {
1381 $variant = 'U';
1382 }
1383
1384 substr($var, length($res), 1, $variant);
1385 $type = 'N';
1386
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001387 } elsif ($cur =~ /^($Operators)/o) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001388 print "OP($1)\n" if ($dbg_values > 1);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001389 if ($1 ne '++' && $1 ne '--') {
1390 $type = 'N';
1391 }
1392
1393 } elsif ($cur =~ /(^.)/o) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001394 print "C($1)\n" if ($dbg_values > 1);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001395 }
1396 if (defined $1) {
1397 $cur = substr($cur, length($1));
1398 $res .= $type x length($1);
1399 }
1400 }
1401
Andy Whitcroft1f65f942008-07-23 21:29:10 -07001402 return ($res, $var);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001403}
1404
Andy Whitcroft8905a672007-11-28 16:21:06 -08001405sub possible {
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001406 my ($possible, $line) = @_;
Andy Whitcroft9a974fd2009-10-26 16:50:12 -07001407 my $notPermitted = qr{(?:
Andy Whitcroft0776e592008-10-15 22:02:29 -07001408 ^(?:
1409 $Modifier|
1410 $Storage|
1411 $Type|
Andy Whitcroft9a974fd2009-10-26 16:50:12 -07001412 DEFINE_\S+
1413 )$|
1414 ^(?:
Andy Whitcroft0776e592008-10-15 22:02:29 -07001415 goto|
1416 return|
1417 case|
1418 else|
1419 asm|__asm__|
Andy Whitcroft89a88352012-01-10 15:10:00 -08001420 do|
1421 \#|
1422 \#\#|
Andy Whitcroft9a974fd2009-10-26 16:50:12 -07001423 )(?:\s|$)|
Andy Whitcroft0776e592008-10-15 22:02:29 -07001424 ^(?:typedef|struct|enum)\b
Andy Whitcroft9a974fd2009-10-26 16:50:12 -07001425 )}x;
1426 warn "CHECK<$possible> ($line)\n" if ($dbg_possible > 2);
1427 if ($possible !~ $notPermitted) {
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07001428 # Check for modifiers.
1429 $possible =~ s/\s*$Storage\s*//g;
1430 $possible =~ s/\s*$Sparse\s*//g;
1431 if ($possible =~ /^\s*$/) {
1432
1433 } elsif ($possible =~ /\s/) {
1434 $possible =~ s/\s*$Type\s*//g;
Andy Whitcroftd2506582008-07-23 21:29:09 -07001435 for my $modifier (split(' ', $possible)) {
Andy Whitcroft9a974fd2009-10-26 16:50:12 -07001436 if ($modifier !~ $notPermitted) {
1437 warn "MODIFIER: $modifier ($possible) ($line)\n" if ($dbg_possible);
1438 push(@modifierList, $modifier);
1439 }
Andy Whitcroftd2506582008-07-23 21:29:09 -07001440 }
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07001441
1442 } else {
1443 warn "POSSIBLE: $possible ($line)\n" if ($dbg_possible);
1444 push(@typeList, $possible);
1445 }
Andy Whitcroft8905a672007-11-28 16:21:06 -08001446 build_types();
Andy Whitcroft0776e592008-10-15 22:02:29 -07001447 } else {
1448 warn "NOTPOSS: $possible ($line)\n" if ($dbg_possible > 1);
Andy Whitcroft8905a672007-11-28 16:21:06 -08001449 }
1450}
1451
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001452my $prefix = '';
1453
Joe Perches000d1cc12011-07-25 17:13:25 -07001454sub show_type {
Joe Perchescbec18a2014-04-03 14:49:19 -07001455 my ($type) = @_;
Joe Perches91bfe482013-09-11 14:23:59 -07001456
Joe Perchescbec18a2014-04-03 14:49:19 -07001457 return defined $use_type{$type} if (scalar keys %use_type > 0);
1458
1459 return !defined $ignore_type{$type};
Joe Perches000d1cc12011-07-25 17:13:25 -07001460}
1461
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001462sub report {
Joe Perchescbec18a2014-04-03 14:49:19 -07001463 my ($level, $type, $msg) = @_;
1464
1465 if (!show_type($type) ||
1466 (defined $tst_only && $msg !~ /\Q$tst_only\E/)) {
Andy Whitcroft773647a2008-03-28 14:15:58 -07001467 return 0;
1468 }
Joe Perches000d1cc12011-07-25 17:13:25 -07001469 my $line;
1470 if ($show_types) {
Joe Perchescbec18a2014-04-03 14:49:19 -07001471 $line = "$prefix$level:$type: $msg\n";
Joe Perches000d1cc12011-07-25 17:13:25 -07001472 } else {
Joe Perchescbec18a2014-04-03 14:49:19 -07001473 $line = "$prefix$level: $msg\n";
Joe Perches000d1cc12011-07-25 17:13:25 -07001474 }
Andy Whitcroft8905a672007-11-28 16:21:06 -08001475 $line = (split('\n', $line))[0] . "\n" if ($terse);
1476
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001477 push(our @report, $line);
Andy Whitcroft773647a2008-03-28 14:15:58 -07001478
1479 return 1;
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001480}
Joe Perchescbec18a2014-04-03 14:49:19 -07001481
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001482sub report_dump {
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001483 our @report;
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001484}
Joe Perches000d1cc12011-07-25 17:13:25 -07001485
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07001486sub ERROR {
Joe Perchescbec18a2014-04-03 14:49:19 -07001487 my ($type, $msg) = @_;
1488
1489 if (report("ERROR", $type, $msg)) {
Andy Whitcroft773647a2008-03-28 14:15:58 -07001490 our $clean = 0;
1491 our $cnt_error++;
Joe Perches3705ce52013-07-03 15:05:31 -07001492 return 1;
Andy Whitcroft773647a2008-03-28 14:15:58 -07001493 }
Joe Perches3705ce52013-07-03 15:05:31 -07001494 return 0;
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07001495}
1496sub WARN {
Joe Perchescbec18a2014-04-03 14:49:19 -07001497 my ($type, $msg) = @_;
1498
1499 if (report("WARNING", $type, $msg)) {
Andy Whitcroft773647a2008-03-28 14:15:58 -07001500 our $clean = 0;
1501 our $cnt_warn++;
Joe Perches3705ce52013-07-03 15:05:31 -07001502 return 1;
Andy Whitcroft773647a2008-03-28 14:15:58 -07001503 }
Joe Perches3705ce52013-07-03 15:05:31 -07001504 return 0;
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07001505}
1506sub CHK {
Joe Perchescbec18a2014-04-03 14:49:19 -07001507 my ($type, $msg) = @_;
1508
1509 if ($check && report("CHECK", $type, $msg)) {
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001510 our $clean = 0;
1511 our $cnt_chk++;
Joe Perches3705ce52013-07-03 15:05:31 -07001512 return 1;
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001513 }
Joe Perches3705ce52013-07-03 15:05:31 -07001514 return 0;
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07001515}
1516
Andy Whitcroft6ecd9672008-10-15 22:02:21 -07001517sub check_absolute_file {
1518 my ($absolute, $herecurr) = @_;
1519 my $file = $absolute;
1520
1521 ##print "absolute<$absolute>\n";
1522
1523 # See if any suffix of this path is a path within the tree.
1524 while ($file =~ s@^[^/]*/@@) {
1525 if (-f "$root/$file") {
1526 ##print "file<$file>\n";
1527 last;
1528 }
1529 }
1530 if (! -f _) {
1531 return 0;
1532 }
1533
1534 # It is, so see if the prefix is acceptable.
1535 my $prefix = $absolute;
1536 substr($prefix, -length($file)) = '';
1537
1538 ##print "prefix<$prefix>\n";
1539 if ($prefix ne ".../") {
Joe Perches000d1cc12011-07-25 17:13:25 -07001540 WARN("USE_RELATIVE_PATH",
1541 "use relative pathname instead of absolute in changelog text\n" . $herecurr);
Andy Whitcroft6ecd9672008-10-15 22:02:21 -07001542 }
1543}
1544
Joe Perches3705ce52013-07-03 15:05:31 -07001545sub trim {
1546 my ($string) = @_;
1547
Joe Perchesb34c6482013-09-11 14:24:01 -07001548 $string =~ s/^\s+|\s+$//g;
1549
1550 return $string;
1551}
1552
1553sub ltrim {
1554 my ($string) = @_;
1555
1556 $string =~ s/^\s+//;
1557
1558 return $string;
1559}
1560
1561sub rtrim {
1562 my ($string) = @_;
1563
1564 $string =~ s/\s+$//;
Joe Perches3705ce52013-07-03 15:05:31 -07001565
1566 return $string;
1567}
1568
Joe Perches52ea8502013-11-12 15:10:09 -08001569sub string_find_replace {
1570 my ($string, $find, $replace) = @_;
1571
1572 $string =~ s/$find/$replace/g;
1573
1574 return $string;
1575}
1576
Joe Perches3705ce52013-07-03 15:05:31 -07001577sub tabify {
1578 my ($leading) = @_;
1579
1580 my $source_indent = 8;
1581 my $max_spaces_before_tab = $source_indent - 1;
1582 my $spaces_to_tab = " " x $source_indent;
1583
1584 #convert leading spaces to tabs
1585 1 while $leading =~ s@^([\t]*)$spaces_to_tab@$1\t@g;
1586 #Remove spaces before a tab
1587 1 while $leading =~ s@^([\t]*)( {1,$max_spaces_before_tab})\t@$1\t@g;
1588
1589 return "$leading";
1590}
1591
Joe Perchesd1fe9c02012-03-23 15:02:16 -07001592sub pos_last_openparen {
1593 my ($line) = @_;
1594
1595 my $pos = 0;
1596
1597 my $opens = $line =~ tr/\(/\(/;
1598 my $closes = $line =~ tr/\)/\)/;
1599
1600 my $last_openparen = 0;
1601
1602 if (($opens == 0) || ($closes >= $opens)) {
1603 return -1;
1604 }
1605
1606 my $len = length($line);
1607
1608 for ($pos = 0; $pos < $len; $pos++) {
1609 my $string = substr($line, $pos);
1610 if ($string =~ /^($FuncArg|$balanced_parens)/) {
1611 $pos += length($1) - 1;
1612 } elsif (substr($line, $pos, 1) eq '(') {
1613 $last_openparen = $pos;
1614 } elsif (index($string, '(') == -1) {
1615 last;
1616 }
1617 }
1618
Joe Perches91cb5192014-04-03 14:49:32 -07001619 return length(expand_tabs(substr($line, 0, $last_openparen))) + 1;
Joe Perchesd1fe9c02012-03-23 15:02:16 -07001620}
1621
Andy Whitcroft0a920b52007-06-01 00:46:48 -07001622sub process {
1623 my $filename = shift;
Andy Whitcroft0a920b52007-06-01 00:46:48 -07001624
1625 my $linenr=0;
1626 my $prevline="";
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001627 my $prevrawline="";
Andy Whitcroft0a920b52007-06-01 00:46:48 -07001628 my $stashline="";
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001629 my $stashrawline="";
Andy Whitcroft0a920b52007-06-01 00:46:48 -07001630
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001631 my $length;
Andy Whitcroft0a920b52007-06-01 00:46:48 -07001632 my $indent;
1633 my $previndent=0;
1634 my $stashindent=0;
1635
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07001636 our $clean = 1;
Andy Whitcroft0a920b52007-06-01 00:46:48 -07001637 my $signoff = 0;
1638 my $is_patch = 0;
1639
Joe Perches15662b32011-10-31 17:13:12 -07001640 my $in_header_lines = 1;
1641 my $in_commit_log = 0; #Scanning lines before patch
1642
Pasi Savanainenfa64205d2012-10-04 17:13:29 -07001643 my $non_utf8_charset = 0;
1644
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001645 our @report = ();
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001646 our $cnt_lines = 0;
1647 our $cnt_error = 0;
1648 our $cnt_warn = 0;
1649 our $cnt_chk = 0;
1650
Andy Whitcroft0a920b52007-06-01 00:46:48 -07001651 # Trace the real file/line as we go.
1652 my $realfile = '';
1653 my $realline = 0;
1654 my $realcnt = 0;
1655 my $here = '';
1656 my $in_comment = 0;
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001657 my $comment_edge = 0;
Andy Whitcroft0a920b52007-06-01 00:46:48 -07001658 my $first_line = 0;
Wolfram Sang1e855722009-01-06 14:41:24 -08001659 my $p1_prefix = '';
Andy Whitcroft0a920b52007-06-01 00:46:48 -07001660
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001661 my $prev_values = 'E';
1662
1663 # suppression flags
Andy Whitcroft773647a2008-03-28 14:15:58 -07001664 my %suppress_ifbraces;
Andy Whitcroft170d3a22008-10-15 22:02:30 -07001665 my %suppress_whiletrailers;
Andy Whitcroft2b474a12009-10-26 16:50:16 -07001666 my %suppress_export;
Andy Whitcroft3e469cd2012-01-10 15:10:01 -08001667 my $suppress_statement = 0;
Andy Whitcroft653d4872007-06-23 17:16:34 -07001668
Joe Perches7e51f192013-09-11 14:23:57 -07001669 my %signatures = ();
Joe Perches323c1262012-12-17 16:02:07 -08001670
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001671 # Pre-scan the patch sanitizing the lines.
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07001672 # Pre-scan the patch looking for any __setup documentation.
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001673 #
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07001674 my @setup_docs = ();
1675 my $setup_docs = 0;
Andy Whitcroft773647a2008-03-28 14:15:58 -07001676
Joe Perchesd8b07712013-11-12 15:10:06 -08001677 my $camelcase_file_seeded = 0;
1678
Andy Whitcroft773647a2008-03-28 14:15:58 -07001679 sanitise_line_reset();
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001680 my $line;
1681 foreach my $rawline (@rawlines) {
Andy Whitcroft773647a2008-03-28 14:15:58 -07001682 $linenr++;
1683 $line = $rawline;
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001684
Joe Perches3705ce52013-07-03 15:05:31 -07001685 push(@fixed, $rawline) if ($fix);
1686
Andy Whitcroft773647a2008-03-28 14:15:58 -07001687 if ($rawline=~/^\+\+\+\s+(\S+)/) {
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07001688 $setup_docs = 0;
1689 if ($1 =~ m@Documentation/kernel-parameters.txt$@) {
1690 $setup_docs = 1;
1691 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07001692 #next;
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07001693 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07001694 if ($rawline=~/^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@/) {
1695 $realline=$1-1;
1696 if (defined $2) {
1697 $realcnt=$3+1;
1698 } else {
1699 $realcnt=1+1;
1700 }
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07001701 $in_comment = 0;
Andy Whitcroft773647a2008-03-28 14:15:58 -07001702
1703 # Guestimate if this is a continuing comment. Run
1704 # the context looking for a comment "edge". If this
1705 # edge is a close comment then we must be in a comment
1706 # at context start.
1707 my $edge;
Andy Whitcroft01fa9142008-10-15 22:02:19 -07001708 my $cnt = $realcnt;
1709 for (my $ln = $linenr + 1; $cnt > 0; $ln++) {
1710 next if (defined $rawlines[$ln - 1] &&
1711 $rawlines[$ln - 1] =~ /^-/);
1712 $cnt--;
1713 #print "RAW<$rawlines[$ln - 1]>\n";
Andy Whitcroft721c1cb2009-01-06 14:41:16 -08001714 last if (!defined $rawlines[$ln - 1]);
Andy Whitcroftfae17da2009-01-06 14:41:20 -08001715 if ($rawlines[$ln - 1] =~ m@(/\*|\*/)@ &&
1716 $rawlines[$ln - 1] !~ m@"[^"]*(?:/\*|\*/)[^"]*"@) {
1717 ($edge) = $1;
1718 last;
1719 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07001720 }
1721 if (defined $edge && $edge eq '*/') {
1722 $in_comment = 1;
1723 }
1724
1725 # Guestimate if this is a continuing comment. If this
1726 # is the start of a diff block and this line starts
1727 # ' *' then it is very likely a comment.
1728 if (!defined $edge &&
Andy Whitcroft83242e02009-01-06 14:41:17 -08001729 $rawlines[$linenr] =~ m@^.\s*(?:\*\*+| \*)(?:\s|$)@)
Andy Whitcroft773647a2008-03-28 14:15:58 -07001730 {
1731 $in_comment = 1;
1732 }
1733
1734 ##print "COMMENT:$in_comment edge<$edge> $rawline\n";
1735 sanitise_line_reset($in_comment);
1736
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07001737 } elsif ($realcnt && $rawline =~ /^(?:\+| |$)/) {
Andy Whitcroft773647a2008-03-28 14:15:58 -07001738 # Standardise the strings and chars within the input to
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07001739 # simplify matching -- only bother with positive lines.
Andy Whitcroft773647a2008-03-28 14:15:58 -07001740 $line = sanitise_line($rawline);
1741 }
1742 push(@lines, $line);
1743
1744 if ($realcnt > 1) {
1745 $realcnt-- if ($line =~ /^(?:\+| |$)/);
1746 } else {
1747 $realcnt = 0;
1748 }
1749
1750 #print "==>$rawline\n";
1751 #print "-->$line\n";
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07001752
1753 if ($setup_docs && $line =~ /^\+/) {
1754 push(@setup_docs, $line);
1755 }
1756 }
1757
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001758 $prefix = '';
1759
Andy Whitcroft773647a2008-03-28 14:15:58 -07001760 $realcnt = 0;
1761 $linenr = 0;
Andy Whitcroft0a920b52007-06-01 00:46:48 -07001762 foreach my $line (@lines) {
1763 $linenr++;
Joe Perches1b5539b2013-09-11 14:24:03 -07001764 my $sline = $line; #copy of $line
1765 $sline =~ s/$;/ /g; #with comments as spaces
Andy Whitcroft0a920b52007-06-01 00:46:48 -07001766
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001767 my $rawline = $rawlines[$linenr - 1];
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001768
Andy Whitcroft0a920b52007-06-01 00:46:48 -07001769#extract the line range in the file after the patch is applied
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001770 if ($line=~/^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@/) {
Andy Whitcroft0a920b52007-06-01 00:46:48 -07001771 $is_patch = 1;
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001772 $first_line = $linenr + 1;
Andy Whitcroft0a920b52007-06-01 00:46:48 -07001773 $realline=$1-1;
1774 if (defined $2) {
1775 $realcnt=$3+1;
1776 } else {
1777 $realcnt=1+1;
1778 }
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001779 annotate_reset();
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001780 $prev_values = 'E';
1781
Andy Whitcroft773647a2008-03-28 14:15:58 -07001782 %suppress_ifbraces = ();
Andy Whitcroft170d3a22008-10-15 22:02:30 -07001783 %suppress_whiletrailers = ();
Andy Whitcroft2b474a12009-10-26 16:50:16 -07001784 %suppress_export = ();
Andy Whitcroft3e469cd2012-01-10 15:10:01 -08001785 $suppress_statement = 0;
Andy Whitcroft0a920b52007-06-01 00:46:48 -07001786 next;
Andy Whitcroft0a920b52007-06-01 00:46:48 -07001787
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001788# track the line number as we move through the hunk, note that
1789# new versions of GNU diff omit the leading space on completely
1790# blank context lines so we need to count that too.
Andy Whitcroft773647a2008-03-28 14:15:58 -07001791 } elsif ($line =~ /^( |\+|$)/) {
Andy Whitcroft0a920b52007-06-01 00:46:48 -07001792 $realline++;
Andy Whitcroftd8aaf122007-06-23 17:16:44 -07001793 $realcnt-- if ($realcnt != 0);
Andy Whitcroft0a920b52007-06-01 00:46:48 -07001794
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001795 # Measure the line length and indent.
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001796 ($length, $indent) = line_stats($rawline);
Andy Whitcroft0a920b52007-06-01 00:46:48 -07001797
1798 # Track the previous line.
1799 ($prevline, $stashline) = ($stashline, $line);
1800 ($previndent, $stashindent) = ($stashindent, $indent);
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001801 ($prevrawline, $stashrawline) = ($stashrawline, $rawline);
1802
Andy Whitcroft773647a2008-03-28 14:15:58 -07001803 #warn "line<$line>\n";
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001804
Andy Whitcroftd8aaf122007-06-23 17:16:44 -07001805 } elsif ($realcnt == 1) {
1806 $realcnt--;
Andy Whitcroft0a920b52007-06-01 00:46:48 -07001807 }
1808
Andy Whitcroftcc77cdc2009-10-26 16:50:13 -07001809 my $hunk_line = ($realcnt != 0);
1810
Andy Whitcroft0a920b52007-06-01 00:46:48 -07001811#make up the handle for any error we report on this line
Andy Whitcroft773647a2008-03-28 14:15:58 -07001812 $prefix = "$filename:$realline: " if ($emacs && $file);
1813 $prefix = "$filename:$linenr: " if ($emacs && !$file);
1814
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001815 $here = "#$linenr: " if (!$file);
1816 $here = "#$realline: " if ($file);
Andy Whitcroft773647a2008-03-28 14:15:58 -07001817
Joe Perches2ac73b4f2014-06-04 16:12:05 -07001818 my $found_file = 0;
Andy Whitcroft773647a2008-03-28 14:15:58 -07001819 # extract the filename as it passes
Rabin Vincent3bf9a002010-10-26 14:23:16 -07001820 if ($line =~ /^diff --git.*?(\S+)$/) {
1821 $realfile = $1;
Joe Perches2b7ab452013-11-12 15:10:14 -08001822 $realfile =~ s@^([^/]*)/@@ if (!$file);
Joe Perches270c49a2012-01-10 15:09:50 -08001823 $in_commit_log = 0;
Joe Perches2ac73b4f2014-06-04 16:12:05 -07001824 $found_file = 1;
Rabin Vincent3bf9a002010-10-26 14:23:16 -07001825 } elsif ($line =~ /^\+\+\+\s+(\S+)/) {
Andy Whitcroft773647a2008-03-28 14:15:58 -07001826 $realfile = $1;
Joe Perches2b7ab452013-11-12 15:10:14 -08001827 $realfile =~ s@^([^/]*)/@@ if (!$file);
Joe Perches270c49a2012-01-10 15:09:50 -08001828 $in_commit_log = 0;
Wolfram Sang1e855722009-01-06 14:41:24 -08001829
1830 $p1_prefix = $1;
Andy Whitcrofte2f7aa42009-02-27 14:03:06 -08001831 if (!$file && $tree && $p1_prefix ne '' &&
1832 -e "$root/$p1_prefix") {
Joe Perches000d1cc12011-07-25 17:13:25 -07001833 WARN("PATCH_PREFIX",
1834 "patch prefix '$p1_prefix' exists, appears to be a -p0 patch\n");
Wolfram Sang1e855722009-01-06 14:41:24 -08001835 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07001836
Andy Whitcroftc1ab3322008-10-15 22:02:20 -07001837 if ($realfile =~ m@^include/asm/@) {
Joe Perches000d1cc12011-07-25 17:13:25 -07001838 ERROR("MODIFIED_INCLUDE_ASM",
1839 "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 -07001840 }
Joe Perches2ac73b4f2014-06-04 16:12:05 -07001841 $found_file = 1;
1842 }
1843
1844 if ($found_file) {
1845 if ($realfile =~ m@^(drivers/net/|net/)@) {
1846 $check = 1;
1847 } else {
1848 $check = $check_orig;
1849 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07001850 next;
1851 }
1852
Randy Dunlap389834b2007-06-08 13:47:03 -07001853 $here .= "FILE: $realfile:$realline:" if ($realcnt != 0);
Andy Whitcroft0a920b52007-06-01 00:46:48 -07001854
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001855 my $hereline = "$here\n$rawline\n";
1856 my $herecurr = "$here\n$rawline\n";
1857 my $hereprev = "$here\n$prevrawline\n$rawline\n";
Andy Whitcroft0a920b52007-06-01 00:46:48 -07001858
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001859 $cnt_lines++ if ($realcnt != 0);
1860
Rabin Vincent3bf9a002010-10-26 14:23:16 -07001861# Check for incorrect file permissions
1862 if ($line =~ /^new (file )?mode.*[7531]\d{0,2}$/) {
1863 my $permhere = $here . "FILE: $realfile\n";
Joe Perches04db4d22013-04-29 16:18:14 -07001864 if ($realfile !~ m@scripts/@ &&
1865 $realfile !~ /\.(py|pl|awk|sh)$/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07001866 ERROR("EXECUTE_PERMISSIONS",
1867 "do not set execute permissions for source files\n" . $permhere);
Rabin Vincent3bf9a002010-10-26 14:23:16 -07001868 }
1869 }
1870
Joe Perches20112472011-07-25 17:13:23 -07001871# Check the patch for a signoff:
Andy Whitcroftd8aaf122007-06-23 17:16:44 -07001872 if ($line =~ /^\s*signed-off-by:/i) {
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001873 $signoff++;
Joe Perches15662b32011-10-31 17:13:12 -07001874 $in_commit_log = 0;
Joe Perches20112472011-07-25 17:13:23 -07001875 }
1876
1877# Check signature styles
Joe Perches270c49a2012-01-10 15:09:50 -08001878 if (!$in_header_lines &&
Joe Perchesce0338df3c2012-07-30 14:41:18 -07001879 $line =~ /^(\s*)([a-z0-9_-]+by:|$signature_tags)(\s*)(.*)/i) {
Joe Perches20112472011-07-25 17:13:23 -07001880 my $space_before = $1;
1881 my $sign_off = $2;
1882 my $space_after = $3;
1883 my $email = $4;
1884 my $ucfirst_sign_off = ucfirst(lc($sign_off));
1885
Joe Perchesce0338df3c2012-07-30 14:41:18 -07001886 if ($sign_off !~ /$signature_tags/) {
1887 WARN("BAD_SIGN_OFF",
1888 "Non-standard signature: $sign_off\n" . $herecurr);
1889 }
Joe Perches20112472011-07-25 17:13:23 -07001890 if (defined $space_before && $space_before ne "") {
Joe Perches3705ce52013-07-03 15:05:31 -07001891 if (WARN("BAD_SIGN_OFF",
1892 "Do not use whitespace before $ucfirst_sign_off\n" . $herecurr) &&
1893 $fix) {
1894 $fixed[$linenr - 1] =
1895 "$ucfirst_sign_off $email";
1896 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07001897 }
Joe Perches20112472011-07-25 17:13:23 -07001898 if ($sign_off =~ /-by:$/i && $sign_off ne $ucfirst_sign_off) {
Joe Perches3705ce52013-07-03 15:05:31 -07001899 if (WARN("BAD_SIGN_OFF",
1900 "'$ucfirst_sign_off' is the preferred signature form\n" . $herecurr) &&
1901 $fix) {
1902 $fixed[$linenr - 1] =
1903 "$ucfirst_sign_off $email";
1904 }
1905
Joe Perches20112472011-07-25 17:13:23 -07001906 }
1907 if (!defined $space_after || $space_after ne " ") {
Joe Perches3705ce52013-07-03 15:05:31 -07001908 if (WARN("BAD_SIGN_OFF",
1909 "Use a single space after $ucfirst_sign_off\n" . $herecurr) &&
1910 $fix) {
1911 $fixed[$linenr - 1] =
1912 "$ucfirst_sign_off $email";
1913 }
Joe Perches20112472011-07-25 17:13:23 -07001914 }
1915
1916 my ($email_name, $email_address, $comment) = parse_email($email);
1917 my $suggested_email = format_email(($email_name, $email_address));
1918 if ($suggested_email eq "") {
Joe Perches000d1cc12011-07-25 17:13:25 -07001919 ERROR("BAD_SIGN_OFF",
1920 "Unrecognized email address: '$email'\n" . $herecurr);
Joe Perches20112472011-07-25 17:13:23 -07001921 } else {
1922 my $dequoted = $suggested_email;
1923 $dequoted =~ s/^"//;
1924 $dequoted =~ s/" </ </;
1925 # Don't force email to have quotes
1926 # Allow just an angle bracketed address
1927 if ("$dequoted$comment" ne $email &&
1928 "<$email_address>$comment" ne $email &&
1929 "$suggested_email$comment" ne $email) {
Joe Perches000d1cc12011-07-25 17:13:25 -07001930 WARN("BAD_SIGN_OFF",
1931 "email address '$email' might be better as '$suggested_email$comment'\n" . $herecurr);
Joe Perches20112472011-07-25 17:13:23 -07001932 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07001933 }
Joe Perches7e51f192013-09-11 14:23:57 -07001934
1935# Check for duplicate signatures
1936 my $sig_nospace = $line;
1937 $sig_nospace =~ s/\s//g;
1938 $sig_nospace = lc($sig_nospace);
1939 if (defined $signatures{$sig_nospace}) {
1940 WARN("BAD_SIGN_OFF",
1941 "Duplicate signature\n" . $herecurr);
1942 } else {
1943 $signatures{$sig_nospace} = 1;
1944 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07001945 }
1946
Joe Perches9b3189e2014-06-04 16:12:10 -07001947# Check for old stable address
1948 if ($line =~ /^\s*cc:\s*.*<?\bstable\@kernel\.org\b>?.*$/i) {
1949 ERROR("STABLE_ADDRESS",
1950 "The 'stable' address should be 'stable\@vger.kernel.org'\n" . $herecurr);
1951 }
1952
Christopher Covington7ebd05e2014-04-03 14:49:31 -07001953# Check for unwanted Gerrit info
1954 if ($in_commit_log && $line =~ /^\s*change-id:/i) {
1955 ERROR("GERRIT_CHANGE_ID",
1956 "Remove Gerrit Change-Id's before submitting upstream.\n" . $herecurr);
1957 }
1958
Andy Whitcroft00df3442007-06-08 13:47:06 -07001959# Check for wrappage within a valid hunk of the file
Andy Whitcroft8905a672007-11-28 16:21:06 -08001960 if ($realcnt != 0 && $line !~ m{^(?:\+|-| |\\ No newline|$)}) {
Joe Perches000d1cc12011-07-25 17:13:25 -07001961 ERROR("CORRUPTED_PATCH",
1962 "patch seems to be corrupt (line wrapped?)\n" .
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001963 $herecurr) if (!$emitted_corrupt++);
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07001964 }
1965
Andy Whitcroft6ecd9672008-10-15 22:02:21 -07001966# Check for absolute kernel paths.
1967 if ($tree) {
1968 while ($line =~ m{(?:^|\s)(/\S*)}g) {
1969 my $file = $1;
1970
1971 if ($file =~ m{^(.*?)(?::\d+)+:?$} &&
1972 check_absolute_file($1, $herecurr)) {
1973 #
1974 } else {
1975 check_absolute_file($file, $herecurr);
1976 }
1977 }
1978 }
1979
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07001980# UTF-8 regex found at http://www.w3.org/International/questions/qa-forms-utf-8.en.php
1981 if (($realfile =~ /^$/ || $line =~ /^\+/) &&
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07001982 $rawline !~ m/^$UTF8*$/) {
1983 my ($utf8_prefix) = ($rawline =~ /^($UTF8*)/);
1984
1985 my $blank = copy_spacing($rawline);
1986 my $ptr = substr($blank, 0, length($utf8_prefix)) . "^";
1987 my $hereptr = "$hereline$ptr\n";
1988
Joe Perches34d99212011-07-25 17:13:26 -07001989 CHK("INVALID_UTF8",
1990 "Invalid UTF-8, patch and commit message should be encoded in UTF-8\n" . $hereptr);
Andy Whitcroft00df3442007-06-08 13:47:06 -07001991 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07001992
Joe Perches15662b32011-10-31 17:13:12 -07001993# Check if it's the start of a commit log
1994# (not a header line and we haven't seen the patch filename)
1995 if ($in_header_lines && $realfile =~ /^$/ &&
Joe Perches270c49a2012-01-10 15:09:50 -08001996 $rawline !~ /^(commit\b|from\b|[\w-]+:).+$/i) {
Joe Perches15662b32011-10-31 17:13:12 -07001997 $in_header_lines = 0;
1998 $in_commit_log = 1;
1999 }
2000
Pasi Savanainenfa64205d2012-10-04 17:13:29 -07002001# Check if there is UTF-8 in a commit log when a mail header has explicitly
2002# declined it, i.e defined some charset where it is missing.
2003 if ($in_header_lines &&
2004 $rawline =~ /^Content-Type:.+charset="(.+)".*$/ &&
2005 $1 !~ /utf-8/i) {
2006 $non_utf8_charset = 1;
2007 }
2008
2009 if ($in_commit_log && $non_utf8_charset && $realfile =~ /^$/ &&
Joe Perches15662b32011-10-31 17:13:12 -07002010 $rawline =~ /$NON_ASCII_UTF8/) {
Pasi Savanainenfa64205d2012-10-04 17:13:29 -07002011 WARN("UTF8_BEFORE_PATCH",
Joe Perches15662b32011-10-31 17:13:12 -07002012 "8-bit UTF-8 used in possible commit log\n" . $herecurr);
2013 }
2014
Andy Whitcroft306708542008-10-15 22:02:28 -07002015# ignore non-hunk lines and lines being removed
2016 next if (!$hunk_line || $line =~ /^-/);
Andy Whitcroft00df3442007-06-08 13:47:06 -07002017
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002018#trailing whitespace
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07002019 if ($line =~ /^\+.*\015/) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002020 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
Joe Perchesd5e616f2013-09-11 14:23:54 -07002021 if (ERROR("DOS_LINE_ENDINGS",
2022 "DOS line endings\n" . $herevet) &&
2023 $fix) {
2024 $fixed[$linenr - 1] =~ s/[\s\015]+$//;
2025 }
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002026 } elsif ($rawline =~ /^\+.*\S\s+$/ || $rawline =~ /^\+\s+$/) {
2027 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
Joe Perches3705ce52013-07-03 15:05:31 -07002028 if (ERROR("TRAILING_WHITESPACE",
2029 "trailing whitespace\n" . $herevet) &&
2030 $fix) {
Joe Perchesd5e616f2013-09-11 14:23:54 -07002031 $fixed[$linenr - 1] =~ s/\s+$//;
Joe Perches3705ce52013-07-03 15:05:31 -07002032 }
2033
Andy Whitcroftd2c0a232010-10-26 14:23:12 -07002034 $rpt_cleaners = 1;
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002035 }
Andy Whitcroft5368df22008-10-15 22:02:27 -07002036
Josh Triplett4783f892013-11-12 15:10:12 -08002037# Check for FSF mailing addresses.
Alexander Duyck109d8cb2014-01-23 15:54:50 -08002038 if ($rawline =~ /\bwrite to the Free/i ||
Joe Perches3e2232f2014-01-23 15:54:48 -08002039 $rawline =~ /\b59\s+Temple\s+Pl/i ||
2040 $rawline =~ /\b51\s+Franklin\s+St/i) {
Josh Triplett4783f892013-11-12 15:10:12 -08002041 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2042 my $msg_type = \&ERROR;
2043 $msg_type = \&CHK if ($file);
2044 &{$msg_type}("FSF_MAILING_ADDRESS",
Joe Perches3e2232f2014-01-23 15:54:48 -08002045 "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 -08002046 }
2047
Andi Kleen33549572010-05-24 14:33:29 -07002048# check for Kconfig help text having a real description
Andy Whitcroft9fe287d72010-10-26 14:23:15 -07002049# Only applies when adding the entry originally, after that we do not have
2050# sufficient context to determine whether it is indeed long enough.
Andi Kleen33549572010-05-24 14:33:29 -07002051 if ($realfile =~ /Kconfig/ &&
Andy Whitcrofta1385802012-01-10 15:10:03 -08002052 $line =~ /.\s*config\s+/) {
Andi Kleen33549572010-05-24 14:33:29 -07002053 my $length = 0;
Andy Whitcroft9fe287d72010-10-26 14:23:15 -07002054 my $cnt = $realcnt;
2055 my $ln = $linenr + 1;
2056 my $f;
Andy Whitcrofta1385802012-01-10 15:10:03 -08002057 my $is_start = 0;
Andy Whitcroft9fe287d72010-10-26 14:23:15 -07002058 my $is_end = 0;
Andy Whitcrofta1385802012-01-10 15:10:03 -08002059 for (; $cnt > 0 && defined $lines[$ln - 1]; $ln++) {
Andy Whitcroft9fe287d72010-10-26 14:23:15 -07002060 $f = $lines[$ln - 1];
2061 $cnt-- if ($lines[$ln - 1] !~ /^-/);
2062 $is_end = $lines[$ln - 1] =~ /^\+/;
Andy Whitcroft9fe287d72010-10-26 14:23:15 -07002063
2064 next if ($f =~ /^-/);
Andy Whitcrofta1385802012-01-10 15:10:03 -08002065
2066 if ($lines[$ln - 1] =~ /.\s*(?:bool|tristate)\s*\"/) {
2067 $is_start = 1;
2068 } elsif ($lines[$ln - 1] =~ /.\s*(?:---)?help(?:---)?$/) {
2069 $length = -1;
2070 }
2071
Andy Whitcroft9fe287d72010-10-26 14:23:15 -07002072 $f =~ s/^.//;
Andi Kleen33549572010-05-24 14:33:29 -07002073 $f =~ s/#.*//;
2074 $f =~ s/^\s+//;
2075 next if ($f =~ /^$/);
Andy Whitcroft9fe287d72010-10-26 14:23:15 -07002076 if ($f =~ /^\s*config\s/) {
2077 $is_end = 1;
2078 last;
2079 }
Andi Kleen33549572010-05-24 14:33:29 -07002080 $length++;
2081 }
Joe Perches000d1cc12011-07-25 17:13:25 -07002082 WARN("CONFIG_DESCRIPTION",
Andy Whitcrofta1385802012-01-10 15:10:03 -08002083 "please write a paragraph that describes the config symbol fully\n" . $herecurr) if ($is_start && $is_end && $length < 4);
2084 #print "is_start<$is_start> is_end<$is_end> length<$length>\n";
Andi Kleen33549572010-05-24 14:33:29 -07002085 }
2086
Kees Cook1ba8dfd2012-12-17 16:01:48 -08002087# discourage the addition of CONFIG_EXPERIMENTAL in Kconfig.
2088 if ($realfile =~ /Kconfig/ &&
2089 $line =~ /.\s*depends on\s+.*\bEXPERIMENTAL\b/) {
2090 WARN("CONFIG_EXPERIMENTAL",
2091 "Use of CONFIG_EXPERIMENTAL is deprecated. For alternatives, see https://lkml.org/lkml/2012/10/23/580\n");
2092 }
2093
Arnaud Lacombec68e5872011-08-15 01:07:14 -04002094 if (($realfile =~ /Makefile.*/ || $realfile =~ /Kbuild.*/) &&
2095 ($line =~ /\+(EXTRA_[A-Z]+FLAGS).*/)) {
2096 my $flag = $1;
2097 my $replacement = {
2098 'EXTRA_AFLAGS' => 'asflags-y',
2099 'EXTRA_CFLAGS' => 'ccflags-y',
2100 'EXTRA_CPPFLAGS' => 'cppflags-y',
2101 'EXTRA_LDFLAGS' => 'ldflags-y',
2102 };
2103
2104 WARN("DEPRECATED_VARIABLE",
2105 "Use of $flag is deprecated, please use \`$replacement->{$flag} instead.\n" . $herecurr) if ($replacement->{$flag});
2106 }
2107
Rob Herringbff5da42014-01-23 15:54:51 -08002108# check for DT compatible documentation
Florian Vaussard7dd05b32014-04-03 14:49:26 -07002109 if (defined $root &&
2110 (($realfile =~ /\.dtsi?$/ && $line =~ /^\+\s*compatible\s*=\s*\"/) ||
2111 ($realfile =~ /\.[ch]$/ && $line =~ /^\+.*\.compatible\s*=\s*\"/))) {
2112
Rob Herringbff5da42014-01-23 15:54:51 -08002113 my @compats = $rawline =~ /\"([a-zA-Z0-9\-\,\.\+_]+)\"/g;
2114
Florian Vaussardcc933192014-04-03 14:49:27 -07002115 my $dt_path = $root . "/Documentation/devicetree/bindings/";
2116 my $vp_file = $dt_path . "vendor-prefixes.txt";
2117
Rob Herringbff5da42014-01-23 15:54:51 -08002118 foreach my $compat (@compats) {
2119 my $compat2 = $compat;
Rob Herring185d5662014-06-04 16:12:03 -07002120 $compat2 =~ s/\,[a-zA-Z0-9]*\-/\,<\.\*>\-/;
2121 my $compat3 = $compat;
2122 $compat3 =~ s/\,([a-z]*)[0-9]*\-/\,$1<\.\*>\-/;
2123 `grep -Erq "$compat|$compat2|$compat3" $dt_path`;
Rob Herringbff5da42014-01-23 15:54:51 -08002124 if ( $? >> 8 ) {
2125 WARN("UNDOCUMENTED_DT_STRING",
2126 "DT compatible string \"$compat\" appears un-documented -- check $dt_path\n" . $herecurr);
2127 }
2128
Florian Vaussard4fbf32a2014-04-03 14:49:25 -07002129 next if $compat !~ /^([a-zA-Z0-9\-]+)\,/;
2130 my $vendor = $1;
Florian Vaussardcc933192014-04-03 14:49:27 -07002131 `grep -Eq "^$vendor\\b" $vp_file`;
Rob Herringbff5da42014-01-23 15:54:51 -08002132 if ( $? >> 8 ) {
2133 WARN("UNDOCUMENTED_DT_STRING",
Florian Vaussardcc933192014-04-03 14:49:27 -07002134 "DT compatible string vendor \"$vendor\" appears un-documented -- check $vp_file\n" . $herecurr);
Rob Herringbff5da42014-01-23 15:54:51 -08002135 }
2136 }
2137 }
2138
Andy Whitcroft5368df22008-10-15 22:02:27 -07002139# check we are in a valid source file if not then ignore this hunk
2140 next if ($realfile !~ /\.(h|c|s|S|pl|sh)$/);
2141
Joe Perches6cd7f382012-12-17 16:01:54 -08002142#line length limit
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07002143 if ($line =~ /^\+/ && $prevrawline !~ /\/\*\*/ &&
Andy Whitcroftf4c014c2008-07-23 21:29:01 -07002144 $rawline !~ /^.\s*\*\s*\@$Ident\s/ &&
Joe Perches0fccc622011-05-24 17:13:41 -07002145 !($line =~ /^\+\s*$logFunctions\s*\(\s*(?:(KERN_\S+\s*|[^"]*))?"[X\t]*"\s*(?:|,|\)\s*;)\s*$/ ||
Joe Perches8bbea962010-08-09 17:21:01 -07002146 $line =~ /^\+\s*"[^"]*"\s*(?:\s*|,|\)\s*;)\s*$/) &&
Joe Perches6cd7f382012-12-17 16:01:54 -08002147 $length > $max_line_length)
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07002148 {
Joe Perches000d1cc12011-07-25 17:13:25 -07002149 WARN("LONG_LINE",
Joe Perches6cd7f382012-12-17 16:01:54 -08002150 "line over $max_line_length characters\n" . $herecurr);
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002151 }
2152
Josh Triplettca56dc02012-03-23 15:02:21 -07002153# Check for user-visible strings broken across lines, which breaks the ability
Joe Perches8c5fcd22014-01-23 15:54:40 -08002154# to grep for the string. Make exceptions when the previous string ends in a
2155# newline (multiple lines in one string constant) or '\t', '\r', ';', or '{'
2156# (common in inline assembly) or is a octal \123 or hexadecimal \xaf value
Josh Triplettca56dc02012-03-23 15:02:21 -07002157 if ($line =~ /^\+\s*"/ &&
2158 $prevline =~ /"\s*$/ &&
Joe Perches8c5fcd22014-01-23 15:54:40 -08002159 $prevrawline !~ /(?:\\(?:[ntr]|[0-7]{1,3}|x[0-9a-fA-F]{1,2})|;\s*|\{\s*)"\s*$/) {
Josh Triplettca56dc02012-03-23 15:02:21 -07002160 WARN("SPLIT_STRING",
2161 "quoted string split across lines\n" . $hereprev);
2162 }
2163
Joe Perches5e79d962010-03-05 13:43:55 -08002164# check for spaces before a quoted newline
2165 if ($rawline =~ /^.*\".*\s\\n/) {
Joe Perches3705ce52013-07-03 15:05:31 -07002166 if (WARN("QUOTED_WHITESPACE_BEFORE_NEWLINE",
2167 "unnecessary whitespace before a quoted newline\n" . $herecurr) &&
2168 $fix) {
2169 $fixed[$linenr - 1] =~ s/^(\+.*\".*)\s+\\n/$1\\n/;
2170 }
2171
Joe Perches5e79d962010-03-05 13:43:55 -08002172 }
2173
Andy Whitcroft8905a672007-11-28 16:21:06 -08002174# check for adding lines without a newline.
2175 if ($line =~ /^\+/ && defined $lines[$linenr] && $lines[$linenr] =~ /^\\ No newline at end of file/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07002176 WARN("MISSING_EOF_NEWLINE",
2177 "adding a line without newline at end of file\n" . $herecurr);
Andy Whitcroft8905a672007-11-28 16:21:06 -08002178 }
2179
Mike Frysinger42e41c52009-09-21 17:04:40 -07002180# Blackfin: use hi/lo macros
2181 if ($realfile =~ m@arch/blackfin/.*\.S$@) {
2182 if ($line =~ /\.[lL][[:space:]]*=.*&[[:space:]]*0x[fF][fF][fF][fF]/) {
2183 my $herevet = "$here\n" . cat_vet($line) . "\n";
Joe Perches000d1cc12011-07-25 17:13:25 -07002184 ERROR("LO_MACRO",
2185 "use the LO() macro, not (... & 0xFFFF)\n" . $herevet);
Mike Frysinger42e41c52009-09-21 17:04:40 -07002186 }
2187 if ($line =~ /\.[hH][[:space:]]*=.*>>[[:space:]]*16/) {
2188 my $herevet = "$here\n" . cat_vet($line) . "\n";
Joe Perches000d1cc12011-07-25 17:13:25 -07002189 ERROR("HI_MACRO",
2190 "use the HI() macro, not (... >> 16)\n" . $herevet);
Mike Frysinger42e41c52009-09-21 17:04:40 -07002191 }
2192 }
2193
Andy Whitcroftb9ea10d2008-10-15 22:02:24 -07002194# check we are in a valid source file C or perl if not then ignore this hunk
2195 next if ($realfile !~ /\.(h|c|pl)$/);
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002196
2197# at the beginning of a line any tabs must come first and anything
2198# more than 8 must use tabs.
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002199 if ($rawline =~ /^\+\s* \t\s*\S/ ||
2200 $rawline =~ /^\+\s* \s*/) {
2201 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
Andy Whitcroftd2c0a232010-10-26 14:23:12 -07002202 $rpt_cleaners = 1;
Joe Perches3705ce52013-07-03 15:05:31 -07002203 if (ERROR("CODE_INDENT",
2204 "code indent should use tabs where possible\n" . $herevet) &&
2205 $fix) {
2206 $fixed[$linenr - 1] =~ s/^\+([ \t]+)/"\+" . tabify($1)/e;
2207 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002208 }
2209
Alberto Panizzo08e44362010-03-05 13:43:54 -08002210# check for space before tabs.
2211 if ($rawline =~ /^\+/ && $rawline =~ / \t/) {
2212 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
Joe Perches3705ce52013-07-03 15:05:31 -07002213 if (WARN("SPACE_BEFORE_TAB",
2214 "please, no space before tabs\n" . $herevet) &&
2215 $fix) {
Joe Perchesc76f4cb2014-01-23 15:54:46 -08002216 while ($fixed[$linenr - 1] =~
2217 s/(^\+.*) {8,8}+\t/$1\t\t/) {}
2218 while ($fixed[$linenr - 1] =~
2219 s/(^\+.*) +\t/$1\t/) {}
Joe Perches3705ce52013-07-03 15:05:31 -07002220 }
Alberto Panizzo08e44362010-03-05 13:43:54 -08002221 }
2222
Joe Perchesd1fe9c02012-03-23 15:02:16 -07002223# check for && or || at the start of a line
2224 if ($rawline =~ /^\+\s*(&&|\|\|)/) {
2225 CHK("LOGICAL_CONTINUATIONS",
2226 "Logical continuations should be on the previous line\n" . $hereprev);
2227 }
2228
2229# check multi-line statement indentation matches previous line
2230 if ($^V && $^V ge 5.10.0 &&
Joe Perches91cb5192014-04-03 14:49:32 -07002231 $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 -07002232 $prevline =~ /^\+(\t*)(.*)$/;
2233 my $oldindent = $1;
2234 my $rest = $2;
2235
2236 my $pos = pos_last_openparen($rest);
2237 if ($pos >= 0) {
Joe Perchesb34a26f2012-07-30 14:41:16 -07002238 $line =~ /^(\+| )([ \t]*)/;
2239 my $newindent = $2;
Joe Perchesd1fe9c02012-03-23 15:02:16 -07002240
2241 my $goodtabindent = $oldindent .
2242 "\t" x ($pos / 8) .
2243 " " x ($pos % 8);
2244 my $goodspaceindent = $oldindent . " " x $pos;
2245
2246 if ($newindent ne $goodtabindent &&
2247 $newindent ne $goodspaceindent) {
Joe Perches3705ce52013-07-03 15:05:31 -07002248
2249 if (CHK("PARENTHESIS_ALIGNMENT",
2250 "Alignment should match open parenthesis\n" . $hereprev) &&
2251 $fix && $line =~ /^\+/) {
2252 $fixed[$linenr - 1] =~
2253 s/^\+[ \t]*/\+$goodtabindent/;
2254 }
Joe Perchesd1fe9c02012-03-23 15:02:16 -07002255 }
2256 }
2257 }
2258
Joe Perches23f780c2013-07-03 15:05:31 -07002259 if ($line =~ /^\+.*\*[ \t]*\)[ \t]+(?!$Assignment|$Arithmetic)/) {
Joe Perches3705ce52013-07-03 15:05:31 -07002260 if (CHK("SPACING",
2261 "No space is necessary after a cast\n" . $hereprev) &&
2262 $fix) {
2263 $fixed[$linenr - 1] =~
2264 s/^(\+.*\*[ \t]*\))[ \t]+/$1/;
2265 }
Joe Perchesaad4f612012-03-23 15:02:19 -07002266 }
2267
Joe Perches05880602012-10-04 17:13:35 -07002268 if ($realfile =~ m@^(drivers/net/|net/)@ &&
Joe Perchesfdb4bcd2013-07-03 15:05:23 -07002269 $prevrawline =~ /^\+[ \t]*\/\*[ \t]*$/ &&
Joe Perches85ad9782014-04-03 14:49:20 -07002270 $rawline =~ /^\+[ \t]*\*/ &&
2271 $realline > 2) {
Joe Perches05880602012-10-04 17:13:35 -07002272 WARN("NETWORKING_BLOCK_COMMENT_STYLE",
2273 "networking block comments don't use an empty /* line, use /* Comment...\n" . $hereprev);
2274 }
2275
2276 if ($realfile =~ m@^(drivers/net/|net/)@ &&
Joe Perchesa605e322013-07-03 15:05:24 -07002277 $prevrawline =~ /^\+[ \t]*\/\*/ && #starting /*
2278 $prevrawline !~ /\*\/[ \t]*$/ && #no trailing */
Joe Perches61135e92013-09-11 14:23:59 -07002279 $rawline =~ /^\+/ && #line is new
Joe Perchesa605e322013-07-03 15:05:24 -07002280 $rawline !~ /^\+[ \t]*\*/) { #no leading *
2281 WARN("NETWORKING_BLOCK_COMMENT_STYLE",
2282 "networking block comments start with * on subsequent lines\n" . $hereprev);
2283 }
2284
2285 if ($realfile =~ m@^(drivers/net/|net/)@ &&
Joe Perchesc24f9f12012-11-08 15:53:29 -08002286 $rawline !~ m@^\+[ \t]*\*/[ \t]*$@ && #trailing */
2287 $rawline !~ m@^\+.*/\*.*\*/[ \t]*$@ && #inline /*...*/
2288 $rawline !~ m@^\+.*\*{2,}/[ \t]*$@ && #trailing **/
2289 $rawline =~ m@^\+[ \t]*.+\*\/[ \t]*$@) { #non blank */
Joe Perches05880602012-10-04 17:13:35 -07002290 WARN("NETWORKING_BLOCK_COMMENT_STYLE",
2291 "networking block comments put the trailing */ on a separate line\n" . $herecurr);
2292 }
2293
Joe Perches3b617e32014-04-03 14:49:28 -07002294# check for missing blank lines after declarations
Joe Perches3f7bac02014-06-04 16:12:04 -07002295 if ($sline =~ /^\+\s+\S/ && #Not at char 1
2296 # actual declarations
2297 ($prevline =~ /^\+\s+$Declare\s*$Ident\s*[=,;:\[]/ ||
2298 # foo bar; where foo is some local typedef or #define
2299 $prevline =~ /^\+\s+$Ident(?:\s+|\s*\*\s*)$Ident\s*[=,;\[]/ ||
2300 # known declaration macros
2301 $prevline =~ /^\+\s+$declaration_macros/) &&
2302 # for "else if" which can look like "$Ident $Ident"
2303 !($prevline =~ /^\+\s+$c90_Keywords\b/ ||
2304 # other possible extensions of declaration lines
2305 $prevline =~ /(?:$Compare|$Assignment|$Operators)\s*$/ ||
2306 # not starting a section or a macro "\" extended line
2307 $prevline =~ /(?:\{\s*|\\)$/) &&
2308 # looks like a declaration
2309 !($sline =~ /^\+\s+$Declare\s*$Ident\s*[=,;:\[]/ ||
2310 # foo bar; where foo is some local typedef or #define
2311 $sline =~ /^\+\s+$Ident(?:\s+|\s*\*\s*)$Ident\s*[=,;\[]/ ||
2312 # known declaration macros
2313 $sline =~ /^\+\s+$declaration_macros/ ||
2314 # start of struct or union or enum
Joe Perches3b617e32014-04-03 14:49:28 -07002315 $sline =~ /^\+\s+(?:union|struct|enum|typedef)\b/ ||
Joe Perches3f7bac02014-06-04 16:12:04 -07002316 # start or end of block or continuation of declaration
2317 $sline =~ /^\+\s+(?:$|[\{\}\.\#\"\?\:\(\[])/ ||
2318 # bitfield continuation
2319 $sline =~ /^\+\s+$Ident\s*:\s*\d+\s*[,;]/ ||
2320 # other possible extensions of declaration lines
2321 $sline =~ /^\+\s+\(?\s*(?:$Compare|$Assignment|$Operators)/) &&
2322 # indentation of previous and current line are the same
2323 (($prevline =~ /\+(\s+)\S/) && $sline =~ /^\+$1\S/)) {
Joe Perches3b617e32014-04-03 14:49:28 -07002324 WARN("SPACING",
Joe Perches3f7bac02014-06-04 16:12:04 -07002325 "Missing a blank line after declarations\n" . $hereprev);
Joe Perches3b617e32014-04-03 14:49:28 -07002326 }
2327
Raffaele Recalcati5f7ddae2010-08-09 17:20:59 -07002328# check for spaces at the beginning of a line.
Andy Whitcroft6b4c5be2010-10-26 14:23:11 -07002329# Exceptions:
2330# 1) within comments
2331# 2) indented preprocessor commands
2332# 3) hanging labels
Joe Perches3705ce52013-07-03 15:05:31 -07002333 if ($rawline =~ /^\+ / && $line !~ /^\+ *(?:$;|#|$Ident:)/) {
Raffaele Recalcati5f7ddae2010-08-09 17:20:59 -07002334 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
Joe Perches3705ce52013-07-03 15:05:31 -07002335 if (WARN("LEADING_SPACE",
2336 "please, no spaces at the start of a line\n" . $herevet) &&
2337 $fix) {
2338 $fixed[$linenr - 1] =~ s/^\+([ \t]+)/"\+" . tabify($1)/e;
2339 }
Raffaele Recalcati5f7ddae2010-08-09 17:20:59 -07002340 }
2341
Andy Whitcroftb9ea10d2008-10-15 22:02:24 -07002342# check we are in a valid C source file if not then ignore this hunk
2343 next if ($realfile !~ /\.(h|c)$/);
2344
Kees Cook1ba8dfd2012-12-17 16:01:48 -08002345# discourage the addition of CONFIG_EXPERIMENTAL in #if(def).
2346 if ($line =~ /^\+\s*\#\s*if.*\bCONFIG_EXPERIMENTAL\b/) {
2347 WARN("CONFIG_EXPERIMENTAL",
2348 "Use of CONFIG_EXPERIMENTAL is deprecated. For alternatives, see https://lkml.org/lkml/2012/10/23/580\n");
2349 }
2350
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002351# check for RCS/CVS revision markers
Andy Whitcroftcf655042008-03-04 14:28:20 -08002352 if ($rawline =~ /^\+.*\$(Revision|Log|Id)(?:\$|)/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07002353 WARN("CVS_KEYWORD",
2354 "CVS style keyword markers, these will _not_ be updated\n". $herecurr);
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002355 }
Andy Whitcroft22f2a2e2007-08-10 13:01:03 -07002356
Mike Frysinger42e41c52009-09-21 17:04:40 -07002357# Blackfin: don't use __builtin_bfin_[cs]sync
2358 if ($line =~ /__builtin_bfin_csync/) {
2359 my $herevet = "$here\n" . cat_vet($line) . "\n";
Joe Perches000d1cc12011-07-25 17:13:25 -07002360 ERROR("CSYNC",
2361 "use the CSYNC() macro in asm/blackfin.h\n" . $herevet);
Mike Frysinger42e41c52009-09-21 17:04:40 -07002362 }
2363 if ($line =~ /__builtin_bfin_ssync/) {
2364 my $herevet = "$here\n" . cat_vet($line) . "\n";
Joe Perches000d1cc12011-07-25 17:13:25 -07002365 ERROR("SSYNC",
2366 "use the SSYNC() macro in asm/blackfin.h\n" . $herevet);
Mike Frysinger42e41c52009-09-21 17:04:40 -07002367 }
2368
Joe Perches56e77d72013-02-21 16:44:14 -08002369# check for old HOTPLUG __dev<foo> section markings
2370 if ($line =~ /\b(__dev(init|exit)(data|const|))\b/) {
2371 WARN("HOTPLUG_SECTION",
2372 "Using $1 is unnecessary\n" . $herecurr);
2373 }
2374
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07002375# Check for potential 'bare' types
Andy Whitcroft2b474a12009-10-26 16:50:16 -07002376 my ($stat, $cond, $line_nr_next, $remain_next, $off_next,
2377 $realline_next);
Andy Whitcroft3e469cd2012-01-10 15:10:01 -08002378#print "LINE<$line>\n";
2379 if ($linenr >= $suppress_statement &&
Joe Perches1b5539b2013-09-11 14:24:03 -07002380 $realcnt && $sline =~ /.\s*\S/) {
Andy Whitcroft170d3a22008-10-15 22:02:30 -07002381 ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
Andy Whitcroftf5fe35d2008-07-23 21:29:03 -07002382 ctx_statement_block($linenr, $realcnt, 0);
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07002383 $stat =~ s/\n./\n /g;
2384 $cond =~ s/\n./\n /g;
2385
Andy Whitcroft3e469cd2012-01-10 15:10:01 -08002386#print "linenr<$linenr> <$stat>\n";
2387 # If this statement has no statement boundaries within
2388 # it there is no point in retrying a statement scan
2389 # until we hit end of it.
2390 my $frag = $stat; $frag =~ s/;+\s*$//;
2391 if ($frag !~ /(?:{|;)/) {
2392#print "skip<$line_nr_next>\n";
2393 $suppress_statement = $line_nr_next;
2394 }
Andy Whitcroftf74bd192012-01-10 15:09:54 -08002395
Andy Whitcroft2b474a12009-10-26 16:50:16 -07002396 # Find the real next line.
2397 $realline_next = $line_nr_next;
2398 if (defined $realline_next &&
2399 (!defined $lines[$realline_next - 1] ||
2400 substr($lines[$realline_next - 1], $off_next) =~ /^\s*$/)) {
2401 $realline_next++;
2402 }
2403
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07002404 my $s = $stat;
2405 $s =~ s/{.*$//s;
Andy Whitcroftcf655042008-03-04 14:28:20 -08002406
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002407 # Ignore goto labels.
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07002408 if ($s =~ /$Ident:\*$/s) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002409
2410 # Ignore functions being called
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07002411 } elsif ($s =~ /^.\s*$Ident\s*\(/s) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002412
Andy Whitcroft463f2862009-09-21 17:04:34 -07002413 } elsif ($s =~ /^.\s*else\b/s) {
2414
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07002415 # declarations always start with types
Andy Whitcroftd2506582008-07-23 21:29:09 -07002416 } 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 -07002417 my $type = $1;
2418 $type =~ s/\s+/ /g;
2419 possible($type, "A:" . $s);
2420
Andy Whitcroft8905a672007-11-28 16:21:06 -08002421 # definitions in global scope can only start with types
Andy Whitcrofta6a840622008-10-15 22:02:30 -07002422 } elsif ($s =~ /^.(?:$Storage\s+)?(?:$Inline\s+)?(?:const\s+)?($Ident)\b\s*(?!:)/s) {
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07002423 possible($1, "B:" . $s);
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002424 }
Andy Whitcroft8905a672007-11-28 16:21:06 -08002425
2426 # any (foo ... *) is a pointer cast, and foo is a type
Andy Whitcroft65863862009-01-06 14:41:21 -08002427 while ($s =~ /\(($Ident)(?:\s+$Sparse)*[\s\*]+\s*\)/sg) {
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07002428 possible($1, "C:" . $s);
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07002429 }
Andy Whitcroft8905a672007-11-28 16:21:06 -08002430
2431 # Check for any sort of function declaration.
2432 # int foo(something bar, other baz);
2433 # void (*store_gdt)(x86_descr_ptr *);
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07002434 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 -08002435 my ($name_len) = length($1);
Andy Whitcroft8905a672007-11-28 16:21:06 -08002436
Andy Whitcroftcf655042008-03-04 14:28:20 -08002437 my $ctx = $s;
Andy Whitcroft773647a2008-03-28 14:15:58 -07002438 substr($ctx, 0, $name_len + 1, '');
Andy Whitcroft8905a672007-11-28 16:21:06 -08002439 $ctx =~ s/\)[^\)]*$//;
Andy Whitcroftcf655042008-03-04 14:28:20 -08002440
Andy Whitcroft8905a672007-11-28 16:21:06 -08002441 for my $arg (split(/\s*,\s*/, $ctx)) {
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07002442 if ($arg =~ /^(?:const\s+)?($Ident)(?:\s+$Sparse)*\s*\**\s*(:?\b$Ident)?$/s || $arg =~ /^($Ident)$/s) {
Andy Whitcroft8905a672007-11-28 16:21:06 -08002443
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07002444 possible($1, "D:" . $s);
Andy Whitcroft8905a672007-11-28 16:21:06 -08002445 }
2446 }
2447 }
2448
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07002449 }
2450
Andy Whitcroft653d4872007-06-23 17:16:34 -07002451#
2452# Checks which may be anchored in the context.
2453#
2454
2455# Check for switch () and associated case and default
2456# statements should be at the same indent.
Andy Whitcroft00df3442007-06-08 13:47:06 -07002457 if ($line=~/\bswitch\s*\(.*\)/) {
2458 my $err = '';
2459 my $sep = '';
2460 my @ctx = ctx_block_outer($linenr, $realcnt);
2461 shift(@ctx);
2462 for my $ctx (@ctx) {
2463 my ($clen, $cindent) = line_stats($ctx);
2464 if ($ctx =~ /^\+\s*(case\s+|default:)/ &&
2465 $indent != $cindent) {
2466 $err .= "$sep$ctx\n";
2467 $sep = '';
2468 } else {
2469 $sep = "[...]\n";
2470 }
2471 }
2472 if ($err ne '') {
Joe Perches000d1cc12011-07-25 17:13:25 -07002473 ERROR("SWITCH_CASE_INDENT_LEVEL",
2474 "switch and case should be at the same indent\n$hereline$err");
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07002475 }
2476 }
2477
2478# if/while/etc brace do not go on next line, unless defining a do while loop,
2479# or if that brace on the next line is for something else
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07002480 if ($line =~ /(.*)\b((?:if|while|for|switch)\s*\(|do\b|else\b)/ && $line !~ /^.\s*\#/) {
Andy Whitcroft773647a2008-03-28 14:15:58 -07002481 my $pre_ctx = "$1$2";
2482
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07002483 my ($level, @ctx) = ctx_statement_level($linenr, $realcnt, 0);
Joe Perches8eef05d2012-02-03 15:20:39 -08002484
2485 if ($line =~ /^\+\t{6,}/) {
2486 WARN("DEEP_INDENTATION",
2487 "Too many leading tabs - consider code refactoring\n" . $herecurr);
2488 }
2489
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07002490 my $ctx_cnt = $realcnt - $#ctx - 1;
2491 my $ctx = join("\n", @ctx);
2492
Andy Whitcroft548596d2008-07-23 21:29:01 -07002493 my $ctx_ln = $linenr;
2494 my $ctx_skip = $realcnt;
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07002495
Andy Whitcroft548596d2008-07-23 21:29:01 -07002496 while ($ctx_skip > $ctx_cnt || ($ctx_skip == $ctx_cnt &&
2497 defined $lines[$ctx_ln - 1] &&
2498 $lines[$ctx_ln - 1] =~ /^-/)) {
2499 ##print "SKIP<$ctx_skip> CNT<$ctx_cnt>\n";
2500 $ctx_skip-- if (!defined $lines[$ctx_ln - 1] || $lines[$ctx_ln - 1] !~ /^-/);
Andy Whitcroft773647a2008-03-28 14:15:58 -07002501 $ctx_ln++;
2502 }
Andy Whitcroft548596d2008-07-23 21:29:01 -07002503
Andy Whitcroft53210162008-07-23 21:29:03 -07002504 #print "realcnt<$realcnt> ctx_cnt<$ctx_cnt>\n";
2505 #print "pre<$pre_ctx>\nline<$line>\nctx<$ctx>\nnext<$lines[$ctx_ln - 1]>\n";
Andy Whitcroft773647a2008-03-28 14:15:58 -07002506
2507 if ($ctx !~ /{\s*/ && defined($lines[$ctx_ln -1]) && $lines[$ctx_ln - 1] =~ /^\+\s*{/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07002508 ERROR("OPEN_BRACE",
2509 "that open brace { should be on the previous line\n" .
Andy Whitcroft01464f32010-10-26 14:23:19 -07002510 "$here\n$ctx\n$rawlines[$ctx_ln - 1]\n");
Andy Whitcroft00df3442007-06-08 13:47:06 -07002511 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07002512 if ($level == 0 && $pre_ctx !~ /}\s*while\s*\($/ &&
2513 $ctx =~ /\)\s*\;\s*$/ &&
2514 defined $lines[$ctx_ln - 1])
2515 {
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07002516 my ($nlength, $nindent) = line_stats($lines[$ctx_ln - 1]);
2517 if ($nindent > $indent) {
Joe Perches000d1cc12011-07-25 17:13:25 -07002518 WARN("TRAILING_SEMICOLON",
2519 "trailing semicolon indicates no statements, indent implies otherwise\n" .
Andy Whitcroft01464f32010-10-26 14:23:19 -07002520 "$here\n$ctx\n$rawlines[$ctx_ln - 1]\n");
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07002521 }
2522 }
Andy Whitcroft00df3442007-06-08 13:47:06 -07002523 }
2524
Andy Whitcroft4d001e42008-10-15 22:02:21 -07002525# Check relative indent for conditionals and blocks.
2526 if ($line =~ /\b(?:(?:if|while|for)\s*\(|do\b)/ && $line !~ /^.\s*#/ && $line !~ /\}\s*while\s*/) {
Andy Whitcroft3e469cd2012-01-10 15:10:01 -08002527 ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
2528 ctx_statement_block($linenr, $realcnt, 0)
2529 if (!defined $stat);
Andy Whitcroft4d001e42008-10-15 22:02:21 -07002530 my ($s, $c) = ($stat, $cond);
2531
2532 substr($s, 0, length($c), '');
2533
2534 # Make sure we remove the line prefixes as we have
2535 # none on the first line, and are going to readd them
2536 # where necessary.
2537 $s =~ s/\n./\n/gs;
2538
2539 # Find out how long the conditional actually is.
Andy Whitcroft6f779c12008-10-15 22:02:27 -07002540 my @newlines = ($c =~ /\n/gs);
2541 my $cond_lines = 1 + $#newlines;
Andy Whitcroft4d001e42008-10-15 22:02:21 -07002542
2543 # We want to check the first line inside the block
2544 # starting at the end of the conditional, so remove:
2545 # 1) any blank line termination
2546 # 2) any opening brace { on end of the line
2547 # 3) any do (...) {
2548 my $continuation = 0;
2549 my $check = 0;
2550 $s =~ s/^.*\bdo\b//;
2551 $s =~ s/^\s*{//;
2552 if ($s =~ s/^\s*\\//) {
2553 $continuation = 1;
2554 }
Andy Whitcroft9bd49ef2008-10-15 22:02:22 -07002555 if ($s =~ s/^\s*?\n//) {
Andy Whitcroft4d001e42008-10-15 22:02:21 -07002556 $check = 1;
2557 $cond_lines++;
2558 }
2559
2560 # Also ignore a loop construct at the end of a
2561 # preprocessor statement.
2562 if (($prevline =~ /^.\s*#\s*define\s/ ||
2563 $prevline =~ /\\\s*$/) && $continuation == 0) {
2564 $check = 0;
2565 }
2566
Andy Whitcroft9bd49ef2008-10-15 22:02:22 -07002567 my $cond_ptr = -1;
Andy Whitcroft740504c2008-10-15 22:02:35 -07002568 $continuation = 0;
Andy Whitcroft9bd49ef2008-10-15 22:02:22 -07002569 while ($cond_ptr != $cond_lines) {
2570 $cond_ptr = $cond_lines;
Andy Whitcroft4d001e42008-10-15 22:02:21 -07002571
Andy Whitcroftf16fa282008-10-15 22:02:32 -07002572 # If we see an #else/#elif then the code
2573 # is not linear.
2574 if ($s =~ /^\s*\#\s*(?:else|elif)/) {
2575 $check = 0;
2576 }
2577
Andy Whitcroft9bd49ef2008-10-15 22:02:22 -07002578 # Ignore:
2579 # 1) blank lines, they should be at 0,
2580 # 2) preprocessor lines, and
2581 # 3) labels.
Andy Whitcroft740504c2008-10-15 22:02:35 -07002582 if ($continuation ||
2583 $s =~ /^\s*?\n/ ||
Andy Whitcroft9bd49ef2008-10-15 22:02:22 -07002584 $s =~ /^\s*#\s*?/ ||
2585 $s =~ /^\s*$Ident\s*:/) {
Andy Whitcroft740504c2008-10-15 22:02:35 -07002586 $continuation = ($s =~ /^.*?\\\n/) ? 1 : 0;
Andy Whitcroft30dad6e2009-09-21 17:04:36 -07002587 if ($s =~ s/^.*?\n//) {
2588 $cond_lines++;
2589 }
Andy Whitcroft9bd49ef2008-10-15 22:02:22 -07002590 }
Andy Whitcroft4d001e42008-10-15 22:02:21 -07002591 }
2592
2593 my (undef, $sindent) = line_stats("+" . $s);
2594 my $stat_real = raw_line($linenr, $cond_lines);
2595
2596 # Check if either of these lines are modified, else
2597 # this is not this patch's fault.
2598 if (!defined($stat_real) ||
2599 $stat !~ /^\+/ && $stat_real !~ /^\+/) {
2600 $check = 0;
2601 }
2602 if (defined($stat_real) && $cond_lines > 1) {
2603 $stat_real = "[...]\n$stat_real";
2604 }
2605
Andy Whitcroft9bd49ef2008-10-15 22:02:22 -07002606 #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 -07002607
2608 if ($check && (($sindent % 8) != 0 ||
2609 ($sindent <= $indent && $s ne ''))) {
Joe Perches000d1cc12011-07-25 17:13:25 -07002610 WARN("SUSPECT_CODE_INDENT",
2611 "suspect code indent for conditional statements ($indent, $sindent)\n" . $herecurr . "$stat_real\n");
Andy Whitcroft4d001e42008-10-15 22:02:21 -07002612 }
2613 }
2614
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07002615 # Track the 'values' across context and added lines.
2616 my $opline = $line; $opline =~ s/^./ /;
Andy Whitcroft1f65f942008-07-23 21:29:10 -07002617 my ($curr_values, $curr_vars) =
2618 annotate_values($opline . "\n", $prev_values);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07002619 $curr_values = $prev_values . $curr_values;
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002620 if ($dbg_values) {
2621 my $outline = $opline; $outline =~ s/\t/ /g;
Andy Whitcroftcf655042008-03-04 14:28:20 -08002622 print "$linenr > .$outline\n";
2623 print "$linenr > $curr_values\n";
Andy Whitcroft1f65f942008-07-23 21:29:10 -07002624 print "$linenr > $curr_vars\n";
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002625 }
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07002626 $prev_values = substr($curr_values, -1);
2627
Andy Whitcroft00df3442007-06-08 13:47:06 -07002628#ignore lines not being added
Joe Perches3705ce52013-07-03 15:05:31 -07002629 next if ($line =~ /^[^\+]/);
Andy Whitcroft00df3442007-06-08 13:47:06 -07002630
Andy Whitcroft653d4872007-06-23 17:16:34 -07002631# TEST: allow direct testing of the type matcher.
Andy Whitcroft7429c692008-07-23 21:29:06 -07002632 if ($dbg_type) {
2633 if ($line =~ /^.\s*$Declare\s*$/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07002634 ERROR("TEST_TYPE",
2635 "TEST: is type\n" . $herecurr);
Andy Whitcroft7429c692008-07-23 21:29:06 -07002636 } elsif ($dbg_type > 1 && $line =~ /^.+($Declare)/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07002637 ERROR("TEST_NOT_TYPE",
2638 "TEST: is not type ($1 is)\n". $herecurr);
Andy Whitcroft7429c692008-07-23 21:29:06 -07002639 }
Andy Whitcroft653d4872007-06-23 17:16:34 -07002640 next;
2641 }
Andy Whitcrofta1ef2772008-10-15 22:02:17 -07002642# TEST: allow direct testing of the attribute matcher.
2643 if ($dbg_attr) {
Andy Whitcroft9360b0e2009-02-27 14:03:08 -08002644 if ($line =~ /^.\s*$Modifier\s*$/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07002645 ERROR("TEST_ATTR",
2646 "TEST: is attr\n" . $herecurr);
Andy Whitcroft9360b0e2009-02-27 14:03:08 -08002647 } elsif ($dbg_attr > 1 && $line =~ /^.+($Modifier)/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07002648 ERROR("TEST_NOT_ATTR",
2649 "TEST: is not attr ($1 is)\n". $herecurr);
Andy Whitcrofta1ef2772008-10-15 22:02:17 -07002650 }
2651 next;
2652 }
Andy Whitcroft653d4872007-06-23 17:16:34 -07002653
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07002654# check for initialisation to aggregates open brace on the next line
Andy Whitcroft99423c22009-10-26 16:50:15 -07002655 if ($line =~ /^.\s*{/ &&
2656 $prevline =~ /(?:^|[^=])=\s*$/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07002657 ERROR("OPEN_BRACE",
2658 "that open brace { should be on the previous line\n" . $hereprev);
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07002659 }
2660
Andy Whitcroft653d4872007-06-23 17:16:34 -07002661#
2662# Checks which are anchored on the added line.
2663#
2664
2665# check for malformed paths in #include statements (uses RAW line)
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07002666 if ($rawline =~ m{^.\s*\#\s*include\s+[<"](.*)[">]}) {
Andy Whitcroft653d4872007-06-23 17:16:34 -07002667 my $path = $1;
2668 if ($path =~ m{//}) {
Joe Perches000d1cc12011-07-25 17:13:25 -07002669 ERROR("MALFORMED_INCLUDE",
Joe Perches495e9d82012-12-20 15:05:37 -08002670 "malformed #include filename\n" . $herecurr);
2671 }
2672 if ($path =~ "^uapi/" && $realfile =~ m@\binclude/uapi/@) {
2673 ERROR("UAPI_INCLUDE",
2674 "No #include in ...include/uapi/... should use a uapi/ path prefix\n" . $herecurr);
Andy Whitcroft653d4872007-06-23 17:16:34 -07002675 }
Andy Whitcroft653d4872007-06-23 17:16:34 -07002676 }
Andy Whitcroft00df3442007-06-08 13:47:06 -07002677
2678# no C99 // comments
2679 if ($line =~ m{//}) {
Joe Perches3705ce52013-07-03 15:05:31 -07002680 if (ERROR("C99_COMMENTS",
2681 "do not use C99 // comments\n" . $herecurr) &&
2682 $fix) {
2683 my $line = $fixed[$linenr - 1];
2684 if ($line =~ /\/\/(.*)$/) {
2685 my $comment = trim($1);
2686 $fixed[$linenr - 1] =~ s@\/\/(.*)$@/\* $comment \*/@;
2687 }
2688 }
Andy Whitcroft00df3442007-06-08 13:47:06 -07002689 }
2690 # Remove C99 comments.
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002691 $line =~ s@//.*@@;
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07002692 $opline =~ s@//.*@@;
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002693
Andy Whitcroft2b474a12009-10-26 16:50:16 -07002694# EXPORT_SYMBOL should immediately follow the thing it is exporting, consider
2695# the whole statement.
2696#print "APW <$lines[$realline_next - 1]>\n";
2697 if (defined $realline_next &&
2698 exists $lines[$realline_next - 1] &&
2699 !defined $suppress_export{$realline_next} &&
2700 ($lines[$realline_next - 1] =~ /EXPORT_SYMBOL.*\((.*)\)/ ||
2701 $lines[$realline_next - 1] =~ /EXPORT_UNUSED_SYMBOL.*\((.*)\)/)) {
Andy Whitcroft3cbf62d2010-10-26 14:23:18 -07002702 # Handle definitions which produce identifiers with
2703 # a prefix:
2704 # XXX(foo);
2705 # EXPORT_SYMBOL(something_foo);
Andy Whitcroft653d4872007-06-23 17:16:34 -07002706 my $name = $1;
Andy Whitcroft87a53872012-01-10 15:10:04 -08002707 if ($stat =~ /^(?:.\s*}\s*\n)?.([A-Z_]+)\s*\(\s*($Ident)/ &&
Andy Whitcroft3cbf62d2010-10-26 14:23:18 -07002708 $name =~ /^${Ident}_$2/) {
2709#print "FOO C name<$name>\n";
2710 $suppress_export{$realline_next} = 1;
2711
2712 } elsif ($stat !~ /(?:
Andy Whitcroft2b474a12009-10-26 16:50:16 -07002713 \n.}\s*$|
Andy Whitcroft48012052008-10-15 22:02:34 -07002714 ^.DEFINE_$Ident\(\Q$name\E\)|
2715 ^.DECLARE_$Ident\(\Q$name\E\)|
2716 ^.LIST_HEAD\(\Q$name\E\)|
Andy Whitcroft2b474a12009-10-26 16:50:16 -07002717 ^.(?:$Storage\s+)?$Type\s*\(\s*\*\s*\Q$name\E\s*\)\s*\(|
2718 \b\Q$name\E(?:\s+$Attribute)*\s*(?:;|=|\[|\()
Andy Whitcroft48012052008-10-15 22:02:34 -07002719 )/x) {
Andy Whitcroft2b474a12009-10-26 16:50:16 -07002720#print "FOO A<$lines[$realline_next - 1]> stat<$stat> name<$name>\n";
2721 $suppress_export{$realline_next} = 2;
2722 } else {
2723 $suppress_export{$realline_next} = 1;
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002724 }
2725 }
Andy Whitcroft2b474a12009-10-26 16:50:16 -07002726 if (!defined $suppress_export{$linenr} &&
2727 $prevline =~ /^.\s*$/ &&
2728 ($line =~ /EXPORT_SYMBOL.*\((.*)\)/ ||
2729 $line =~ /EXPORT_UNUSED_SYMBOL.*\((.*)\)/)) {
2730#print "FOO B <$lines[$linenr - 1]>\n";
2731 $suppress_export{$linenr} = 2;
2732 }
2733 if (defined $suppress_export{$linenr} &&
2734 $suppress_export{$linenr} == 2) {
Joe Perches000d1cc12011-07-25 17:13:25 -07002735 WARN("EXPORT_SYMBOL",
2736 "EXPORT_SYMBOL(foo); should immediately follow its function/variable\n" . $herecurr);
Andy Whitcroft2b474a12009-10-26 16:50:16 -07002737 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002738
Joe Eloff5150bda2010-08-09 17:21:00 -07002739# check for global initialisers.
Joe Perchesd5e616f2013-09-11 14:23:54 -07002740 if ($line =~ /^\+(\s*$Type\s*$Ident\s*(?:\s+$Modifier))*\s*=\s*(0|NULL|false)\s*;/) {
2741 if (ERROR("GLOBAL_INITIALISERS",
2742 "do not initialise globals to 0 or NULL\n" .
2743 $herecurr) &&
2744 $fix) {
2745 $fixed[$linenr - 1] =~ s/($Type\s*$Ident\s*(?:\s+$Modifier))*\s*=\s*(0|NULL|false)\s*;/$1;/;
2746 }
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07002747 }
Andy Whitcroft653d4872007-06-23 17:16:34 -07002748# check for static initialisers.
Joe Perchesd5e616f2013-09-11 14:23:54 -07002749 if ($line =~ /^\+.*\bstatic\s.*=\s*(0|NULL|false)\s*;/) {
2750 if (ERROR("INITIALISED_STATIC",
2751 "do not initialise statics to 0 or NULL\n" .
2752 $herecurr) &&
2753 $fix) {
2754 $fixed[$linenr - 1] =~ s/(\bstatic\s.*?)\s*=\s*(0|NULL|false)\s*;/$1;/;
2755 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002756 }
2757
Joe Perchescb710ec2010-10-26 14:23:20 -07002758# check for static const char * arrays.
2759 if ($line =~ /\bstatic\s+const\s+char\s*\*\s*(\w+)\s*\[\s*\]\s*=\s*/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07002760 WARN("STATIC_CONST_CHAR_ARRAY",
2761 "static const char * array should probably be static const char * const\n" .
Joe Perchescb710ec2010-10-26 14:23:20 -07002762 $herecurr);
2763 }
2764
2765# check for static char foo[] = "bar" declarations.
2766 if ($line =~ /\bstatic\s+char\s+(\w+)\s*\[\s*\]\s*=\s*"/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07002767 WARN("STATIC_CONST_CHAR_ARRAY",
2768 "static char array declaration should probably be static const char\n" .
Joe Perchescb710ec2010-10-26 14:23:20 -07002769 $herecurr);
2770 }
2771
Joe Perches9b0fa602014-04-03 14:49:18 -07002772# check for non-global char *foo[] = {"bar", ...} declarations.
2773 if ($line =~ /^.\s+(?:static\s+|const\s+)?char\s+\*\s*\w+\s*\[\s*\]\s*=\s*\{/) {
2774 WARN("STATIC_CONST_CHAR_ARRAY",
2775 "char * array declaration might be better as static const\n" .
2776 $herecurr);
2777 }
2778
Joe Perchesb36190c2014-01-27 17:07:18 -08002779# check for function declarations without arguments like "int foo()"
2780 if ($line =~ /(\b$Type\s+$Ident)\s*\(\s*\)/) {
2781 if (ERROR("FUNCTION_WITHOUT_ARGS",
2782 "Bad function definition - $1() should probably be $1(void)\n" . $herecurr) &&
2783 $fix) {
2784 $fixed[$linenr - 1] =~ s/(\b($Type)\s+($Ident))\s*\(\s*\)/$2 $3(void)/;
2785 }
2786 }
2787
Joe Perches92e112f2013-12-13 11:36:22 -07002788# check for uses of DEFINE_PCI_DEVICE_TABLE
2789 if ($line =~ /\bDEFINE_PCI_DEVICE_TABLE\s*\(\s*(\w+)\s*\)\s*=/) {
2790 if (WARN("DEFINE_PCI_DEVICE_TABLE",
2791 "Prefer struct pci_device_id over deprecated DEFINE_PCI_DEVICE_TABLE\n" . $herecurr) &&
2792 $fix) {
2793 $fixed[$linenr - 1] =~ s/\b(?:static\s+|)DEFINE_PCI_DEVICE_TABLE\s*\(\s*(\w+)\s*\)\s*=\s*/static const struct pci_device_id $1\[\] = /;
2794 }
Joe Perches93ed0e22010-10-26 14:23:21 -07002795 }
2796
Andy Whitcroft653d4872007-06-23 17:16:34 -07002797# check for new typedefs, only function parameters and sparse annotations
2798# make sense.
2799 if ($line =~ /\btypedef\s/ &&
Andy Whitcroft80545762009-01-06 14:41:26 -08002800 $line !~ /\btypedef\s+$Type\s*\(\s*\*?$Ident\s*\)\s*\(/ &&
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07002801 $line !~ /\btypedef\s+$Type\s+$Ident\s*\(/ &&
Andy Whitcroft8ed22ca2008-10-15 22:02:32 -07002802 $line !~ /\b$typeTypedefs\b/ &&
Andy Whitcroft653d4872007-06-23 17:16:34 -07002803 $line !~ /\b__bitwise(?:__|)\b/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07002804 WARN("NEW_TYPEDEFS",
2805 "do not add new typedefs\n" . $herecurr);
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002806 }
2807
2808# * goes on variable not on type
Andy Whitcroft65863862009-01-06 14:41:21 -08002809 # (char*[ const])
Andy Whitcroftbfcb2cc2012-01-10 15:10:15 -08002810 while ($line =~ m{(\($NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)\))}g) {
2811 #print "AA<$1>\n";
Joe Perches3705ce52013-07-03 15:05:31 -07002812 my ($ident, $from, $to) = ($1, $2, $2);
Andy Whitcroftd8aaf122007-06-23 17:16:44 -07002813
Andy Whitcroft65863862009-01-06 14:41:21 -08002814 # Should start with a space.
2815 $to =~ s/^(\S)/ $1/;
2816 # Should not end with a space.
2817 $to =~ s/\s+$//;
2818 # '*'s should not have spaces between.
Andy Whitcroftf9a0b3d2009-01-15 13:51:05 -08002819 while ($to =~ s/\*\s+\*/\*\*/) {
Andy Whitcroft65863862009-01-06 14:41:21 -08002820 }
Andy Whitcroftd8aaf122007-06-23 17:16:44 -07002821
Joe Perches3705ce52013-07-03 15:05:31 -07002822## print "1: from<$from> to<$to> ident<$ident>\n";
Andy Whitcroft65863862009-01-06 14:41:21 -08002823 if ($from ne $to) {
Joe Perches3705ce52013-07-03 15:05:31 -07002824 if (ERROR("POINTER_LOCATION",
2825 "\"(foo$from)\" should be \"(foo$to)\"\n" . $herecurr) &&
2826 $fix) {
2827 my $sub_from = $ident;
2828 my $sub_to = $ident;
2829 $sub_to =~ s/\Q$from\E/$to/;
2830 $fixed[$linenr - 1] =~
2831 s@\Q$sub_from\E@$sub_to@;
2832 }
Andy Whitcroft65863862009-01-06 14:41:21 -08002833 }
Andy Whitcroftbfcb2cc2012-01-10 15:10:15 -08002834 }
2835 while ($line =~ m{(\b$NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)($Ident))}g) {
2836 #print "BB<$1>\n";
Joe Perches3705ce52013-07-03 15:05:31 -07002837 my ($match, $from, $to, $ident) = ($1, $2, $2, $3);
Andy Whitcroftd8aaf122007-06-23 17:16:44 -07002838
Andy Whitcroft65863862009-01-06 14:41:21 -08002839 # Should start with a space.
2840 $to =~ s/^(\S)/ $1/;
2841 # Should not end with a space.
2842 $to =~ s/\s+$//;
2843 # '*'s should not have spaces between.
Andy Whitcroftf9a0b3d2009-01-15 13:51:05 -08002844 while ($to =~ s/\*\s+\*/\*\*/) {
Andy Whitcroft65863862009-01-06 14:41:21 -08002845 }
2846 # Modifiers should have spaces.
2847 $to =~ s/(\b$Modifier$)/$1 /;
2848
Joe Perches3705ce52013-07-03 15:05:31 -07002849## print "2: from<$from> to<$to> ident<$ident>\n";
Andy Whitcroft667026e2009-02-27 14:03:08 -08002850 if ($from ne $to && $ident !~ /^$Modifier$/) {
Joe Perches3705ce52013-07-03 15:05:31 -07002851 if (ERROR("POINTER_LOCATION",
2852 "\"foo${from}bar\" should be \"foo${to}bar\"\n" . $herecurr) &&
2853 $fix) {
2854
2855 my $sub_from = $match;
2856 my $sub_to = $match;
2857 $sub_to =~ s/\Q$from\E/$to/;
2858 $fixed[$linenr - 1] =~
2859 s@\Q$sub_from\E@$sub_to@;
2860 }
Andy Whitcroft65863862009-01-06 14:41:21 -08002861 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002862 }
2863
2864# # no BUG() or BUG_ON()
2865# if ($line =~ /\b(BUG|BUG_ON)\b/) {
2866# print "Try to use WARN_ON & Recovery code rather than BUG() or BUG_ON()\n";
2867# print "$herecurr";
2868# $clean = 0;
2869# }
2870
Andy Whitcroft8905a672007-11-28 16:21:06 -08002871 if ($line =~ /\bLINUX_VERSION_CODE\b/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07002872 WARN("LINUX_VERSION_CODE",
2873 "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 -08002874 }
2875
Joe Perches17441222011-06-15 15:08:17 -07002876# check for uses of printk_ratelimit
2877 if ($line =~ /\bprintk_ratelimit\s*\(/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07002878 WARN("PRINTK_RATELIMITED",
2879"Prefer printk_ratelimited or pr_<level>_ratelimited to printk_ratelimit\n" . $herecurr);
Joe Perches17441222011-06-15 15:08:17 -07002880 }
2881
Andy Whitcroft00df3442007-06-08 13:47:06 -07002882# printk should use KERN_* levels. Note that follow on printk's on the
2883# same line do not need a level, so we use the current block context
2884# to try and find and validate the current printk. In summary the current
Lucas De Marchi25985ed2011-03-30 22:57:33 -03002885# printk includes all preceding printk's which have no newline on the end.
Andy Whitcroft00df3442007-06-08 13:47:06 -07002886# we assume the first bad printk is the one to report.
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07002887 if ($line =~ /\bprintk\((?!KERN_)\s*"/) {
Andy Whitcroft00df3442007-06-08 13:47:06 -07002888 my $ok = 0;
2889 for (my $ln = $linenr - 1; $ln >= $first_line; $ln--) {
2890 #print "CHECK<$lines[$ln - 1]\n";
Lucas De Marchi25985ed2011-03-30 22:57:33 -03002891 # we have a preceding printk if it ends
Andy Whitcroft00df3442007-06-08 13:47:06 -07002892 # with "\n" ignore it, else it is to blame
2893 if ($lines[$ln - 1] =~ m{\bprintk\(}) {
2894 if ($rawlines[$ln - 1] !~ m{\\n"}) {
2895 $ok = 1;
2896 }
2897 last;
2898 }
2899 }
2900 if ($ok == 0) {
Joe Perches000d1cc12011-07-25 17:13:25 -07002901 WARN("PRINTK_WITHOUT_KERN_LEVEL",
2902 "printk() should include KERN_ facility level\n" . $herecurr);
Andy Whitcroft00df3442007-06-08 13:47:06 -07002903 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002904 }
2905
Joe Perches243f3802012-05-31 16:26:09 -07002906 if ($line =~ /\bprintk\s*\(\s*KERN_([A-Z]+)/) {
2907 my $orig = $1;
2908 my $level = lc($orig);
2909 $level = "warn" if ($level eq "warning");
Joe Perches8f26b832012-10-04 17:13:32 -07002910 my $level2 = $level;
2911 $level2 = "dbg" if ($level eq "debug");
Joe Perches243f3802012-05-31 16:26:09 -07002912 WARN("PREFER_PR_LEVEL",
Yogesh Chaudharidaa8b052014-04-03 14:49:23 -07002913 "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 -07002914 }
2915
2916 if ($line =~ /\bpr_warning\s*\(/) {
Joe Perchesd5e616f2013-09-11 14:23:54 -07002917 if (WARN("PREFER_PR_LEVEL",
2918 "Prefer pr_warn(... to pr_warning(...\n" . $herecurr) &&
2919 $fix) {
2920 $fixed[$linenr - 1] =~
2921 s/\bpr_warning\b/pr_warn/;
2922 }
Joe Perches243f3802012-05-31 16:26:09 -07002923 }
2924
Joe Perchesdc139312013-02-21 16:44:13 -08002925 if ($line =~ /\bdev_printk\s*\(\s*KERN_([A-Z]+)/) {
2926 my $orig = $1;
2927 my $level = lc($orig);
2928 $level = "warn" if ($level eq "warning");
2929 $level = "dbg" if ($level eq "debug");
2930 WARN("PREFER_DEV_LEVEL",
2931 "Prefer dev_$level(... to dev_printk(KERN_$orig, ...\n" . $herecurr);
2932 }
2933
Andy Whitcroft653d4872007-06-23 17:16:34 -07002934# function brace can't be on same line, except for #defines of do while,
2935# or if closed on same line
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07002936 if (($line=~/$Type\s*$Ident\(.*\).*\s{/) and
2937 !($line=~/\#\s*define.*do\s{/) and !($line=~/}/)) {
Joe Perches000d1cc12011-07-25 17:13:25 -07002938 ERROR("OPEN_BRACE",
2939 "open brace '{' following function declarations go on the next line\n" . $herecurr);
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002940 }
Andy Whitcroft653d4872007-06-23 17:16:34 -07002941
Andy Whitcroft8905a672007-11-28 16:21:06 -08002942# open braces for enum, union and struct go on the same line.
2943 if ($line =~ /^.\s*{/ &&
2944 $prevline =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident)?\s*$/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07002945 ERROR("OPEN_BRACE",
2946 "open brace '{' following $1 go on the same line\n" . $hereprev);
Andy Whitcroft8905a672007-11-28 16:21:06 -08002947 }
2948
Andy Whitcroft0c73b4e2010-10-26 14:23:15 -07002949# missing space after union, struct or enum definition
Joe Perches3705ce52013-07-03 15:05:31 -07002950 if ($line =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident){1,2}[=\{]/) {
2951 if (WARN("SPACING",
2952 "missing space after $1 definition\n" . $herecurr) &&
2953 $fix) {
2954 $fixed[$linenr - 1] =~
2955 s/^(.\s*(?:typedef\s+)?(?:enum|union|struct)(?:\s+$Ident){1,2})([=\{])/$1 $2/;
2956 }
Andy Whitcroft0c73b4e2010-10-26 14:23:15 -07002957 }
2958
Joe Perches31070b52014-01-23 15:54:49 -08002959# Function pointer declarations
2960# check spacing between type, funcptr, and args
2961# canonical declaration is "type (*funcptr)(args...)"
Joe Perches91f72e92014-04-03 14:49:12 -07002962 if ($line =~ /^.\s*($Declare)\((\s*)\*(\s*)($Ident)(\s*)\)(\s*)\(/) {
Joe Perches31070b52014-01-23 15:54:49 -08002963 my $declare = $1;
2964 my $pre_pointer_space = $2;
2965 my $post_pointer_space = $3;
2966 my $funcname = $4;
2967 my $post_funcname_space = $5;
2968 my $pre_args_space = $6;
2969
Joe Perches91f72e92014-04-03 14:49:12 -07002970# the $Declare variable will capture all spaces after the type
2971# so check it for a missing trailing missing space but pointer return types
2972# don't need a space so don't warn for those.
2973 my $post_declare_space = "";
2974 if ($declare =~ /(\s+)$/) {
2975 $post_declare_space = $1;
2976 $declare = rtrim($declare);
2977 }
2978 if ($declare !~ /\*$/ && $post_declare_space =~ /^$/) {
Joe Perches31070b52014-01-23 15:54:49 -08002979 WARN("SPACING",
2980 "missing space after return type\n" . $herecurr);
Joe Perches91f72e92014-04-03 14:49:12 -07002981 $post_declare_space = " ";
Joe Perches31070b52014-01-23 15:54:49 -08002982 }
2983
2984# unnecessary space "type (*funcptr)(args...)"
Joe Perches91f72e92014-04-03 14:49:12 -07002985# This test is not currently implemented because these declarations are
2986# equivalent to
2987# int foo(int bar, ...)
2988# and this is form shouldn't/doesn't generate a checkpatch warning.
2989#
2990# elsif ($declare =~ /\s{2,}$/) {
2991# WARN("SPACING",
2992# "Multiple spaces after return type\n" . $herecurr);
2993# }
Joe Perches31070b52014-01-23 15:54:49 -08002994
2995# unnecessary space "type ( *funcptr)(args...)"
2996 if (defined $pre_pointer_space &&
2997 $pre_pointer_space =~ /^\s/) {
2998 WARN("SPACING",
2999 "Unnecessary space after function pointer open parenthesis\n" . $herecurr);
3000 }
3001
3002# unnecessary space "type (* funcptr)(args...)"
3003 if (defined $post_pointer_space &&
3004 $post_pointer_space =~ /^\s/) {
3005 WARN("SPACING",
3006 "Unnecessary space before function pointer name\n" . $herecurr);
3007 }
3008
3009# unnecessary space "type (*funcptr )(args...)"
3010 if (defined $post_funcname_space &&
3011 $post_funcname_space =~ /^\s/) {
3012 WARN("SPACING",
3013 "Unnecessary space after function pointer name\n" . $herecurr);
3014 }
3015
3016# unnecessary space "type (*funcptr) (args...)"
3017 if (defined $pre_args_space &&
3018 $pre_args_space =~ /^\s/) {
3019 WARN("SPACING",
3020 "Unnecessary space before function pointer arguments\n" . $herecurr);
3021 }
3022
3023 if (show_type("SPACING") && $fix) {
3024 $fixed[$linenr - 1] =~
Joe Perches91f72e92014-04-03 14:49:12 -07003025 s/^(.\s*)$Declare\s*\(\s*\*\s*$Ident\s*\)\s*\(/$1 . $declare . $post_declare_space . '(*' . $funcname . ')('/ex;
Joe Perches31070b52014-01-23 15:54:49 -08003026 }
3027 }
3028
Andy Whitcroft8d31cfc2008-07-23 21:29:02 -07003029# check for spacing round square brackets; allowed:
3030# 1. with a type on the left -- int [] a;
Andy Whitcroftfe2a7db2008-10-15 22:02:15 -07003031# 2. at the beginning of a line for slice initialisers -- [0...10] = 5,
3032# 3. inside a curly brace -- = { [0...10] = 5 }
Andy Whitcroft8d31cfc2008-07-23 21:29:02 -07003033 while ($line =~ /(.*?\s)\[/g) {
3034 my ($where, $prefix) = ($-[1], $1);
3035 if ($prefix !~ /$Type\s+$/ &&
Andy Whitcroftfe2a7db2008-10-15 22:02:15 -07003036 ($where != 0 || $prefix !~ /^.\s+$/) &&
Andy Whitcroftdaebc532012-03-23 15:02:17 -07003037 $prefix !~ /[{,]\s+$/) {
Joe Perches3705ce52013-07-03 15:05:31 -07003038 if (ERROR("BRACKET_SPACE",
3039 "space prohibited before open square bracket '['\n" . $herecurr) &&
3040 $fix) {
3041 $fixed[$linenr - 1] =~
3042 s/^(\+.*?)\s+\[/$1\[/;
3043 }
Andy Whitcroft8d31cfc2008-07-23 21:29:02 -07003044 }
3045 }
3046
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07003047# check for spaces between functions and their parentheses.
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07003048 while ($line =~ /($Ident)\s+\(/g) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08003049 my $name = $1;
Andy Whitcroft773647a2008-03-28 14:15:58 -07003050 my $ctx_before = substr($line, 0, $-[1]);
3051 my $ctx = "$ctx_before$name";
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08003052
3053 # Ignore those directives where spaces _are_ permitted.
Andy Whitcroft773647a2008-03-28 14:15:58 -07003054 if ($name =~ /^(?:
3055 if|for|while|switch|return|case|
3056 volatile|__volatile__|
3057 __attribute__|format|__extension__|
3058 asm|__asm__)$/x)
3059 {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08003060 # cpp #define statements have non-optional spaces, ie
3061 # if there is a space between the name and the open
3062 # parenthesis it is simply not a parameter group.
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07003063 } elsif ($ctx_before =~ /^.\s*\#\s*define\s*$/) {
Andy Whitcroft773647a2008-03-28 14:15:58 -07003064
3065 # cpp #elif statement condition may start with a (
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07003066 } elsif ($ctx =~ /^.\s*\#\s*elif\s*$/) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08003067
3068 # If this whole things ends with a type its most
3069 # likely a typedef for a function.
Andy Whitcroft773647a2008-03-28 14:15:58 -07003070 } elsif ($ctx =~ /$Type$/) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08003071
3072 } else {
Joe Perches3705ce52013-07-03 15:05:31 -07003073 if (WARN("SPACING",
3074 "space prohibited between function name and open parenthesis '('\n" . $herecurr) &&
3075 $fix) {
3076 $fixed[$linenr - 1] =~
3077 s/\b$name\s+\(/$name\(/;
3078 }
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07003079 }
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07003080 }
Eric Nelson9a4cad42012-05-31 16:26:09 -07003081
Andy Whitcroft653d4872007-06-23 17:16:34 -07003082# Check operator spacing.
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003083 if (!($line=~/\#\s*include/)) {
Joe Perches3705ce52013-07-03 15:05:31 -07003084 my $fixed_line = "";
3085 my $line_fixed = 0;
3086
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07003087 my $ops = qr{
3088 <<=|>>=|<=|>=|==|!=|
3089 \+=|-=|\*=|\/=|%=|\^=|\|=|&=|
3090 =>|->|<<|>>|<|>|=|!|~|
Andy Whitcroft1f65f942008-07-23 21:29:10 -07003091 &&|\|\||,|\^|\+\+|--|&|\||\+|-|\*|\/|%|
Joe Perches84731622013-11-12 15:10:05 -08003092 \?:|\?|:
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07003093 }x;
Andy Whitcroftcf655042008-03-04 14:28:20 -08003094 my @elements = split(/($ops|;)/, $opline);
Joe Perches3705ce52013-07-03 15:05:31 -07003095
3096## print("element count: <" . $#elements . ">\n");
3097## foreach my $el (@elements) {
3098## print("el: <$el>\n");
3099## }
3100
3101 my @fix_elements = ();
Andy Whitcroft00df3442007-06-08 13:47:06 -07003102 my $off = 0;
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07003103
Joe Perches3705ce52013-07-03 15:05:31 -07003104 foreach my $el (@elements) {
3105 push(@fix_elements, substr($rawline, $off, length($el)));
3106 $off += length($el);
3107 }
3108
3109 $off = 0;
3110
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07003111 my $blank = copy_spacing($opline);
Joe Perchesb34c6482013-09-11 14:24:01 -07003112 my $last_after = -1;
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07003113
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003114 for (my $n = 0; $n < $#elements; $n += 2) {
Joe Perches3705ce52013-07-03 15:05:31 -07003115
3116 my $good = $fix_elements[$n] . $fix_elements[$n + 1];
3117
3118## print("n: <$n> good: <$good>\n");
3119
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07003120 $off += length($elements[$n]);
3121
Lucas De Marchi25985ed2011-03-30 22:57:33 -03003122 # Pick up the preceding and succeeding characters.
Andy Whitcroft773647a2008-03-28 14:15:58 -07003123 my $ca = substr($opline, 0, $off);
3124 my $cc = '';
3125 if (length($opline) >= ($off + length($elements[$n + 1]))) {
3126 $cc = substr($opline, $off + length($elements[$n + 1]));
3127 }
3128 my $cb = "$ca$;$cc";
3129
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07003130 my $a = '';
3131 $a = 'V' if ($elements[$n] ne '');
3132 $a = 'W' if ($elements[$n] =~ /\s$/);
Andy Whitcroftcf655042008-03-04 14:28:20 -08003133 $a = 'C' if ($elements[$n] =~ /$;$/);
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07003134 $a = 'B' if ($elements[$n] =~ /(\[|\()$/);
3135 $a = 'O' if ($elements[$n] eq '');
Andy Whitcroft773647a2008-03-28 14:15:58 -07003136 $a = 'E' if ($ca =~ /^\s*$/);
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07003137
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003138 my $op = $elements[$n + 1];
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07003139
3140 my $c = '';
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003141 if (defined $elements[$n + 2]) {
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07003142 $c = 'V' if ($elements[$n + 2] ne '');
3143 $c = 'W' if ($elements[$n + 2] =~ /^\s/);
Andy Whitcroftcf655042008-03-04 14:28:20 -08003144 $c = 'C' if ($elements[$n + 2] =~ /^$;/);
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07003145 $c = 'B' if ($elements[$n + 2] =~ /^(\)|\]|;)/);
3146 $c = 'O' if ($elements[$n + 2] eq '');
Andy Whitcroft8b1b3372009-01-06 14:41:27 -08003147 $c = 'E' if ($elements[$n + 2] =~ /^\s*\\$/);
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07003148 } else {
3149 $c = 'E';
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003150 }
3151
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07003152 my $ctx = "${a}x${c}";
3153
3154 my $at = "(ctx:$ctx)";
3155
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07003156 my $ptr = substr($blank, 0, $off) . "^";
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07003157 my $hereptr = "$hereline$ptr\n";
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003158
Andy Whitcroft74048ed2008-07-23 21:29:10 -07003159 # Pull out the value of this operator.
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07003160 my $op_type = substr($curr_values, $off + 1, 1);
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003161
Andy Whitcroft1f65f942008-07-23 21:29:10 -07003162 # Get the full operator variant.
3163 my $opv = $op . substr($curr_vars, $off, 1);
3164
Andy Whitcroft13214ad2008-02-08 04:22:03 -08003165 # Ignore operators passed as parameters.
3166 if ($op_type ne 'V' &&
3167 $ca =~ /\s$/ && $cc =~ /^\s*,/) {
3168
Andy Whitcroftcf655042008-03-04 14:28:20 -08003169# # Ignore comments
3170# } elsif ($op =~ /^$;+$/) {
Andy Whitcroft13214ad2008-02-08 04:22:03 -08003171
Andy Whitcroftd8aaf122007-06-23 17:16:44 -07003172 # ; should have either the end of line or a space or \ after it
Andy Whitcroft13214ad2008-02-08 04:22:03 -08003173 } elsif ($op eq ';') {
Andy Whitcroftcf655042008-03-04 14:28:20 -08003174 if ($ctx !~ /.x[WEBC]/ &&
3175 $cc !~ /^\\/ && $cc !~ /^;/) {
Joe Perches3705ce52013-07-03 15:05:31 -07003176 if (ERROR("SPACING",
3177 "space required after that '$op' $at\n" . $hereptr)) {
Joe Perchesb34c6482013-09-11 14:24:01 -07003178 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";
Joe Perches3705ce52013-07-03 15:05:31 -07003179 $line_fixed = 1;
3180 }
Andy Whitcroftd8aaf122007-06-23 17:16:44 -07003181 }
3182
3183 # // is a comment
3184 } elsif ($op eq '//') {
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003185
Joe Perchesb00e4812014-04-03 14:49:33 -07003186 # : when part of a bitfield
3187 } elsif ($opv eq ':B') {
3188 # skip the bitfield test for now
3189
Andy Whitcroft1f65f942008-07-23 21:29:10 -07003190 # No spaces for:
3191 # ->
Joe Perchesb00e4812014-04-03 14:49:33 -07003192 } elsif ($op eq '->') {
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07003193 if ($ctx =~ /Wx.|.xW/) {
Joe Perches3705ce52013-07-03 15:05:31 -07003194 if (ERROR("SPACING",
3195 "spaces prohibited around that '$op' $at\n" . $hereptr)) {
Joe Perchesb34c6482013-09-11 14:24:01 -07003196 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
Joe Perches3705ce52013-07-03 15:05:31 -07003197 if (defined $fix_elements[$n + 2]) {
3198 $fix_elements[$n + 2] =~ s/^\s+//;
3199 }
Joe Perchesb34c6482013-09-11 14:24:01 -07003200 $line_fixed = 1;
Joe Perches3705ce52013-07-03 15:05:31 -07003201 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003202 }
3203
3204 # , must have a space on the right.
3205 } elsif ($op eq ',') {
Andy Whitcroftcf655042008-03-04 14:28:20 -08003206 if ($ctx !~ /.x[WEC]/ && $cc !~ /^}/) {
Joe Perches3705ce52013-07-03 15:05:31 -07003207 if (ERROR("SPACING",
3208 "space required after that '$op' $at\n" . $hereptr)) {
Joe Perchesb34c6482013-09-11 14:24:01 -07003209 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";
Joe Perches3705ce52013-07-03 15:05:31 -07003210 $line_fixed = 1;
Joe Perchesb34c6482013-09-11 14:24:01 -07003211 $last_after = $n;
Joe Perches3705ce52013-07-03 15:05:31 -07003212 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003213 }
3214
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07003215 # '*' as part of a type definition -- reported already.
Andy Whitcroft74048ed2008-07-23 21:29:10 -07003216 } elsif ($opv eq '*_') {
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07003217 #warn "'*' is part of type\n";
3218
3219 # unary operators should have a space before and
3220 # none after. May be left adjacent to another
3221 # unary operator, or a cast
3222 } elsif ($op eq '!' || $op eq '~' ||
Andy Whitcroft74048ed2008-07-23 21:29:10 -07003223 $opv eq '*U' || $opv eq '-U' ||
Andy Whitcroft0d413862008-10-15 22:02:16 -07003224 $opv eq '&U' || $opv eq '&&U') {
Andy Whitcroftcf655042008-03-04 14:28:20 -08003225 if ($ctx !~ /[WEBC]x./ && $ca !~ /(?:\)|!|~|\*|-|\&|\||\+\+|\-\-|\{)$/) {
Joe Perches3705ce52013-07-03 15:05:31 -07003226 if (ERROR("SPACING",
3227 "space required before that '$op' $at\n" . $hereptr)) {
Joe Perchesb34c6482013-09-11 14:24:01 -07003228 if ($n != $last_after + 2) {
3229 $good = $fix_elements[$n] . " " . ltrim($fix_elements[$n + 1]);
3230 $line_fixed = 1;
3231 }
Joe Perches3705ce52013-07-03 15:05:31 -07003232 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003233 }
Andy Whitcrofta3340b32009-02-27 14:03:07 -08003234 if ($op eq '*' && $cc =~/\s*$Modifier\b/) {
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07003235 # A unary '*' may be const
3236
3237 } elsif ($ctx =~ /.xW/) {
Joe Perches3705ce52013-07-03 15:05:31 -07003238 if (ERROR("SPACING",
3239 "space prohibited after that '$op' $at\n" . $hereptr)) {
Joe Perchesb34c6482013-09-11 14:24:01 -07003240 $good = $fix_elements[$n] . rtrim($fix_elements[$n + 1]);
Joe Perches3705ce52013-07-03 15:05:31 -07003241 if (defined $fix_elements[$n + 2]) {
3242 $fix_elements[$n + 2] =~ s/^\s+//;
3243 }
Joe Perchesb34c6482013-09-11 14:24:01 -07003244 $line_fixed = 1;
Joe Perches3705ce52013-07-03 15:05:31 -07003245 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003246 }
3247
3248 # unary ++ and unary -- are allowed no space on one side.
3249 } elsif ($op eq '++' or $op eq '--') {
Andy Whitcroft773647a2008-03-28 14:15:58 -07003250 if ($ctx !~ /[WEOBC]x[^W]/ && $ctx !~ /[^W]x[WOBEC]/) {
Joe Perches3705ce52013-07-03 15:05:31 -07003251 if (ERROR("SPACING",
3252 "space required one side of that '$op' $at\n" . $hereptr)) {
Joe Perchesb34c6482013-09-11 14:24:01 -07003253 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";
Joe Perches3705ce52013-07-03 15:05:31 -07003254 $line_fixed = 1;
3255 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003256 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07003257 if ($ctx =~ /Wx[BE]/ ||
3258 ($ctx =~ /Wx./ && $cc =~ /^;/)) {
Joe Perches3705ce52013-07-03 15:05:31 -07003259 if (ERROR("SPACING",
3260 "space prohibited before that '$op' $at\n" . $hereptr)) {
Joe Perchesb34c6482013-09-11 14:24:01 -07003261 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
Joe Perches3705ce52013-07-03 15:05:31 -07003262 $line_fixed = 1;
3263 }
Andy Whitcroft653d4872007-06-23 17:16:34 -07003264 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07003265 if ($ctx =~ /ExW/) {
Joe Perches3705ce52013-07-03 15:05:31 -07003266 if (ERROR("SPACING",
3267 "space prohibited after that '$op' $at\n" . $hereptr)) {
Joe Perchesb34c6482013-09-11 14:24:01 -07003268 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]);
Joe Perches3705ce52013-07-03 15:05:31 -07003269 if (defined $fix_elements[$n + 2]) {
3270 $fix_elements[$n + 2] =~ s/^\s+//;
3271 }
Joe Perchesb34c6482013-09-11 14:24:01 -07003272 $line_fixed = 1;
Joe Perches3705ce52013-07-03 15:05:31 -07003273 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07003274 }
3275
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003276 # << and >> may either have or not have spaces both sides
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07003277 } elsif ($op eq '<<' or $op eq '>>' or
3278 $op eq '&' or $op eq '^' or $op eq '|' or
3279 $op eq '+' or $op eq '-' or
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08003280 $op eq '*' or $op eq '/' or
3281 $op eq '%')
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003282 {
Andy Whitcroft773647a2008-03-28 14:15:58 -07003283 if ($ctx =~ /Wx[^WCE]|[^WCE]xW/) {
Joe Perches3705ce52013-07-03 15:05:31 -07003284 if (ERROR("SPACING",
3285 "need consistent spacing around '$op' $at\n" . $hereptr)) {
Joe Perchesb34c6482013-09-11 14:24:01 -07003286 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
3287 if (defined $fix_elements[$n + 2]) {
3288 $fix_elements[$n + 2] =~ s/^\s+//;
3289 }
Joe Perches3705ce52013-07-03 15:05:31 -07003290 $line_fixed = 1;
3291 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003292 }
3293
Andy Whitcroft1f65f942008-07-23 21:29:10 -07003294 # A colon needs no spaces before when it is
3295 # terminating a case value or a label.
3296 } elsif ($opv eq ':C' || $opv eq ':L') {
3297 if ($ctx =~ /Wx./) {
Joe Perches3705ce52013-07-03 15:05:31 -07003298 if (ERROR("SPACING",
3299 "space prohibited before that '$op' $at\n" . $hereptr)) {
Joe Perchesb34c6482013-09-11 14:24:01 -07003300 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
Joe Perches3705ce52013-07-03 15:05:31 -07003301 $line_fixed = 1;
3302 }
Andy Whitcroft1f65f942008-07-23 21:29:10 -07003303 }
3304
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003305 # All the others need spaces both sides.
Andy Whitcroftcf655042008-03-04 14:28:20 -08003306 } elsif ($ctx !~ /[EWC]x[CWE]/) {
Andy Whitcroft1f65f942008-07-23 21:29:10 -07003307 my $ok = 0;
3308
Andy Whitcroft22f2a2e2007-08-10 13:01:03 -07003309 # Ignore email addresses <foo@bar>
Andy Whitcroft1f65f942008-07-23 21:29:10 -07003310 if (($op eq '<' &&
3311 $cc =~ /^\S+\@\S+>/) ||
3312 ($op eq '>' &&
3313 $ca =~ /<\S+\@\S+$/))
3314 {
3315 $ok = 1;
3316 }
3317
Joe Perches84731622013-11-12 15:10:05 -08003318 # messages are ERROR, but ?: are CHK
Andy Whitcroft1f65f942008-07-23 21:29:10 -07003319 if ($ok == 0) {
Joe Perches84731622013-11-12 15:10:05 -08003320 my $msg_type = \&ERROR;
3321 $msg_type = \&CHK if (($op eq '?:' || $op eq '?' || $op eq ':') && $ctx =~ /VxV/);
3322
3323 if (&{$msg_type}("SPACING",
3324 "spaces required around that '$op' $at\n" . $hereptr)) {
Joe Perchesb34c6482013-09-11 14:24:01 -07003325 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
3326 if (defined $fix_elements[$n + 2]) {
3327 $fix_elements[$n + 2] =~ s/^\s+//;
3328 }
Joe Perches3705ce52013-07-03 15:05:31 -07003329 $line_fixed = 1;
3330 }
Andy Whitcroft22f2a2e2007-08-10 13:01:03 -07003331 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003332 }
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07003333 $off += length($elements[$n + 1]);
Joe Perches3705ce52013-07-03 15:05:31 -07003334
3335## print("n: <$n> GOOD: <$good>\n");
3336
3337 $fixed_line = $fixed_line . $good;
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003338 }
Joe Perches3705ce52013-07-03 15:05:31 -07003339
3340 if (($#elements % 2) == 0) {
3341 $fixed_line = $fixed_line . $fix_elements[$#elements];
3342 }
3343
3344 if ($fix && $line_fixed && $fixed_line ne $fixed[$linenr - 1]) {
3345 $fixed[$linenr - 1] = $fixed_line;
3346 }
3347
3348
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003349 }
3350
Joe Perches786b6322013-07-03 15:05:32 -07003351# check for whitespace before a non-naked semicolon
Joe Perchesd2e248e2014-01-23 15:54:41 -08003352 if ($line =~ /^\+.*\S\s+;\s*$/) {
Joe Perches786b6322013-07-03 15:05:32 -07003353 if (WARN("SPACING",
3354 "space prohibited before semicolon\n" . $herecurr) &&
3355 $fix) {
3356 1 while $fixed[$linenr - 1] =~
3357 s/^(\+.*\S)\s+;/$1;/;
3358 }
3359 }
3360
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07003361# check for multiple assignments
3362 if ($line =~ /^.\s*$Lval\s*=\s*$Lval\s*=(?!=)/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003363 CHK("MULTIPLE_ASSIGNMENTS",
3364 "multiple assignments should be avoided\n" . $herecurr);
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07003365 }
3366
Andy Whitcroft22f2a2e2007-08-10 13:01:03 -07003367## # check for multiple declarations, allowing for a function declaration
3368## # continuation.
3369## if ($line =~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Ident.*/ &&
3370## $line !~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Type\s*$Ident.*/) {
3371##
3372## # Remove any bracketed sections to ensure we do not
3373## # falsly report the parameters of functions.
3374## my $ln = $line;
3375## while ($ln =~ s/\([^\(\)]*\)//g) {
3376## }
3377## if ($ln =~ /,/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003378## WARN("MULTIPLE_DECLARATION",
3379## "declaring multiple variables together should be avoided\n" . $herecurr);
Andy Whitcroft22f2a2e2007-08-10 13:01:03 -07003380## }
3381## }
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07003382
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003383#need space before brace following if, while, etc
Andy Whitcroft22f2a2e2007-08-10 13:01:03 -07003384 if (($line =~ /\(.*\){/ && $line !~ /\($Type\){/) ||
3385 $line =~ /do{/) {
Joe Perches3705ce52013-07-03 15:05:31 -07003386 if (ERROR("SPACING",
3387 "space required before the open brace '{'\n" . $herecurr) &&
3388 $fix) {
Joe Perchesd5e616f2013-09-11 14:23:54 -07003389 $fixed[$linenr - 1] =~ s/^(\+.*(?:do|\))){/$1 {/;
Joe Perches3705ce52013-07-03 15:05:31 -07003390 }
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07003391 }
3392
Joe Perchesc4a62ef2013-07-03 15:05:28 -07003393## # check for blank lines before declarations
3394## if ($line =~ /^.\t+$Type\s+$Ident(?:\s*=.*)?;/ &&
3395## $prevrawline =~ /^.\s*$/) {
3396## WARN("SPACING",
3397## "No blank lines before declarations\n" . $hereprev);
3398## }
3399##
3400
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07003401# closing brace should have a space following it when it has anything
3402# on the line
3403 if ($line =~ /}(?!(?:,|;|\)))\S/) {
Joe Perchesd5e616f2013-09-11 14:23:54 -07003404 if (ERROR("SPACING",
3405 "space required after that close brace '}'\n" . $herecurr) &&
3406 $fix) {
3407 $fixed[$linenr - 1] =~
3408 s/}((?!(?:,|;|\)))\S)/} $1/;
3409 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003410 }
3411
Andy Whitcroft22f2a2e2007-08-10 13:01:03 -07003412# check spacing on square brackets
3413 if ($line =~ /\[\s/ && $line !~ /\[\s*$/) {
Joe Perches3705ce52013-07-03 15:05:31 -07003414 if (ERROR("SPACING",
3415 "space prohibited after that open square bracket '['\n" . $herecurr) &&
3416 $fix) {
3417 $fixed[$linenr - 1] =~
3418 s/\[\s+/\[/;
3419 }
Andy Whitcroft22f2a2e2007-08-10 13:01:03 -07003420 }
3421 if ($line =~ /\s\]/) {
Joe Perches3705ce52013-07-03 15:05:31 -07003422 if (ERROR("SPACING",
3423 "space prohibited before that close square bracket ']'\n" . $herecurr) &&
3424 $fix) {
3425 $fixed[$linenr - 1] =~
3426 s/\s+\]/\]/;
3427 }
Andy Whitcroft22f2a2e2007-08-10 13:01:03 -07003428 }
3429
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07003430# check spacing on parentheses
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07003431 if ($line =~ /\(\s/ && $line !~ /\(\s*(?:\\)?$/ &&
3432 $line !~ /for\s*\(\s+;/) {
Joe Perches3705ce52013-07-03 15:05:31 -07003433 if (ERROR("SPACING",
3434 "space prohibited after that open parenthesis '('\n" . $herecurr) &&
3435 $fix) {
3436 $fixed[$linenr - 1] =~
3437 s/\(\s+/\(/;
3438 }
Andy Whitcroft22f2a2e2007-08-10 13:01:03 -07003439 }
Andy Whitcroft13214ad2008-02-08 04:22:03 -08003440 if ($line =~ /(\s+)\)/ && $line !~ /^.\s*\)/ &&
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07003441 $line !~ /for\s*\(.*;\s+\)/ &&
3442 $line !~ /:\s+\)/) {
Joe Perches3705ce52013-07-03 15:05:31 -07003443 if (ERROR("SPACING",
3444 "space prohibited before that close parenthesis ')'\n" . $herecurr) &&
3445 $fix) {
3446 $fixed[$linenr - 1] =~
3447 s/\s+\)/\)/;
3448 }
Andy Whitcroft22f2a2e2007-08-10 13:01:03 -07003449 }
3450
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003451#goto labels aren't indented, allow a single space however
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07003452 if ($line=~/^.\s+[A-Za-z\d_]+:(?![0-9]+)/ and
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003453 !($line=~/^. [A-Za-z\d_]+:/) and !($line=~/^.\s+default:/)) {
Joe Perches3705ce52013-07-03 15:05:31 -07003454 if (WARN("INDENTED_LABEL",
3455 "labels should not be indented\n" . $herecurr) &&
3456 $fix) {
3457 $fixed[$linenr - 1] =~
3458 s/^(.)\s+/$1/;
3459 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003460 }
3461
Joe Perches5b9553a2014-04-03 14:49:21 -07003462# return is not a function
Joe Perches507e5142013-11-12 15:10:13 -08003463 if (defined($stat) && $stat =~ /^.\s*return(\s*)\(/s) {
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07003464 my $spacing = $1;
Joe Perches507e5142013-11-12 15:10:13 -08003465 if ($^V && $^V ge 5.10.0 &&
Joe Perches5b9553a2014-04-03 14:49:21 -07003466 $stat =~ /^.\s*return\s*($balanced_parens)\s*;\s*$/) {
3467 my $value = $1;
3468 $value = deparenthesize($value);
3469 if ($value =~ m/^\s*$FuncArg\s*(?:\?|$)/) {
3470 ERROR("RETURN_PARENTHESES",
3471 "return is not a function, parentheses are not required\n" . $herecurr);
3472 }
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07003473 } elsif ($spacing !~ /\s+/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003474 ERROR("SPACING",
3475 "space required before the open parenthesis '('\n" . $herecurr);
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07003476 }
3477 }
Joe Perches507e5142013-11-12 15:10:13 -08003478
Joe Perchesb43ae212014-06-23 13:22:07 -07003479# unnecessary return in a void function
3480# at end-of-function, with the previous line a single leading tab, then return;
3481# and the line before that not a goto label target like "out:"
3482 if ($sline =~ /^[ \+]}\s*$/ &&
3483 $prevline =~ /^\+\treturn\s*;\s*$/ &&
3484 $linenr >= 3 &&
3485 $lines[$linenr - 3] =~ /^[ +]/ &&
3486 $lines[$linenr - 3] !~ /^[ +]\s*$Ident\s*:/) {
Joe Perches9819cf22014-06-04 16:12:09 -07003487 WARN("RETURN_VOID",
Joe Perchesb43ae212014-06-23 13:22:07 -07003488 "void function return statements are not generally useful\n" . $hereprev);
3489 }
Joe Perches9819cf22014-06-04 16:12:09 -07003490
Joe Perches189248d2014-01-23 15:54:47 -08003491# if statements using unnecessary parentheses - ie: if ((foo == bar))
3492 if ($^V && $^V ge 5.10.0 &&
3493 $line =~ /\bif\s*((?:\(\s*){2,})/) {
3494 my $openparens = $1;
3495 my $count = $openparens =~ tr@\(@\(@;
3496 my $msg = "";
3497 if ($line =~ /\bif\s*(?:\(\s*){$count,$count}$LvalOrFunc\s*($Compare)\s*$LvalOrFunc(?:\s*\)){$count,$count}/) {
3498 my $comp = $4; #Not $1 because of $LvalOrFunc
3499 $msg = " - maybe == should be = ?" if ($comp eq "==");
3500 WARN("UNNECESSARY_PARENTHESES",
3501 "Unnecessary parentheses$msg\n" . $herecurr);
3502 }
3503 }
3504
Andy Whitcroft53a3c442010-10-26 14:23:14 -07003505# Return of what appears to be an errno should normally be -'ve
3506 if ($line =~ /^.\s*return\s*(E[A-Z]*)\s*;/) {
3507 my $name = $1;
3508 if ($name ne 'EOF' && $name ne 'ERROR') {
Joe Perches000d1cc12011-07-25 17:13:25 -07003509 WARN("USE_NEGATIVE_ERRNO",
3510 "return of an errno should typically be -ve (return -$1)\n" . $herecurr);
Andy Whitcroft53a3c442010-10-26 14:23:14 -07003511 }
3512 }
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07003513
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003514# Need a space before open parenthesis after if, while etc
Joe Perches3705ce52013-07-03 15:05:31 -07003515 if ($line =~ /\b(if|while|for|switch)\(/) {
3516 if (ERROR("SPACING",
3517 "space required before the open parenthesis '('\n" . $herecurr) &&
3518 $fix) {
3519 $fixed[$linenr - 1] =~
3520 s/\b(if|while|for|switch)\(/$1 \(/;
3521 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003522 }
3523
Andy Whitcroftf5fe35d2008-07-23 21:29:03 -07003524# Check for illegal assignment in if conditional -- and check for trailing
3525# statements after the conditional.
Andy Whitcroft170d3a22008-10-15 22:02:30 -07003526 if ($line =~ /do\s*(?!{)/) {
Andy Whitcroft3e469cd2012-01-10 15:10:01 -08003527 ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
3528 ctx_statement_block($linenr, $realcnt, 0)
3529 if (!defined $stat);
Andy Whitcroft170d3a22008-10-15 22:02:30 -07003530 my ($stat_next) = ctx_statement_block($line_nr_next,
3531 $remain_next, $off_next);
3532 $stat_next =~ s/\n./\n /g;
3533 ##print "stat<$stat> stat_next<$stat_next>\n";
3534
3535 if ($stat_next =~ /^\s*while\b/) {
3536 # If the statement carries leading newlines,
3537 # then count those as offsets.
3538 my ($whitespace) =
3539 ($stat_next =~ /^((?:\s*\n[+-])*\s*)/s);
3540 my $offset =
3541 statement_rawlines($whitespace) - 1;
3542
3543 $suppress_whiletrailers{$line_nr_next +
3544 $offset} = 1;
3545 }
3546 }
3547 if (!defined $suppress_whiletrailers{$linenr} &&
Joe Perchesc11230f2013-11-21 14:31:57 -08003548 defined($stat) && defined($cond) &&
Andy Whitcroft170d3a22008-10-15 22:02:30 -07003549 $line =~ /\b(?:if|while|for)\s*\(/ && $line !~ /^.\s*#/) {
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07003550 my ($s, $c) = ($stat, $cond);
Andy Whitcroft8905a672007-11-28 16:21:06 -08003551
Andy Whitcroftb53c8e12009-01-06 14:41:29 -08003552 if ($c =~ /\bif\s*\(.*[^<>!=]=[^=].*/s) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003553 ERROR("ASSIGN_IN_IF",
3554 "do not use assignment in if condition\n" . $herecurr);
Andy Whitcroft8905a672007-11-28 16:21:06 -08003555 }
3556
3557 # Find out what is on the end of the line after the
3558 # conditional.
Andy Whitcroft773647a2008-03-28 14:15:58 -07003559 substr($s, 0, length($c), '');
Andy Whitcroft8905a672007-11-28 16:21:06 -08003560 $s =~ s/\n.*//g;
Andy Whitcroft13214ad2008-02-08 04:22:03 -08003561 $s =~ s/$;//g; # Remove any comments
Andy Whitcroft53210162008-07-23 21:29:03 -07003562 if (length($c) && $s !~ /^\s*{?\s*\\*\s*$/ &&
3563 $c !~ /}\s*while\s*/)
Andy Whitcroft773647a2008-03-28 14:15:58 -07003564 {
Andy Whitcroftbb44ad32008-10-15 22:02:34 -07003565 # Find out how long the conditional actually is.
3566 my @newlines = ($c =~ /\n/gs);
3567 my $cond_lines = 1 + $#newlines;
Hidetoshi Seto42bdf742010-03-05 13:43:50 -08003568 my $stat_real = '';
Andy Whitcroftbb44ad32008-10-15 22:02:34 -07003569
Hidetoshi Seto42bdf742010-03-05 13:43:50 -08003570 $stat_real = raw_line($linenr, $cond_lines)
3571 . "\n" if ($cond_lines);
Andy Whitcroftbb44ad32008-10-15 22:02:34 -07003572 if (defined($stat_real) && $cond_lines > 1) {
3573 $stat_real = "[...]\n$stat_real";
3574 }
3575
Joe Perches000d1cc12011-07-25 17:13:25 -07003576 ERROR("TRAILING_STATEMENTS",
3577 "trailing statements should be on next line\n" . $herecurr . $stat_real);
Andy Whitcroft8905a672007-11-28 16:21:06 -08003578 }
3579 }
3580
Andy Whitcroft13214ad2008-02-08 04:22:03 -08003581# Check for bitwise tests written as boolean
3582 if ($line =~ /
3583 (?:
3584 (?:\[|\(|\&\&|\|\|)
3585 \s*0[xX][0-9]+\s*
3586 (?:\&\&|\|\|)
3587 |
3588 (?:\&\&|\|\|)
3589 \s*0[xX][0-9]+\s*
3590 (?:\&\&|\|\||\)|\])
3591 )/x)
3592 {
Joe Perches000d1cc12011-07-25 17:13:25 -07003593 WARN("HEXADECIMAL_BOOLEAN_TEST",
3594 "boolean test with hexadecimal, perhaps just 1 \& or \|?\n" . $herecurr);
Andy Whitcroft13214ad2008-02-08 04:22:03 -08003595 }
3596
Andy Whitcroft8905a672007-11-28 16:21:06 -08003597# if and else should not have general statements after it
Andy Whitcroft13214ad2008-02-08 04:22:03 -08003598 if ($line =~ /^.\s*(?:}\s*)?else\b(.*)/) {
3599 my $s = $1;
3600 $s =~ s/$;//g; # Remove any comments
3601 if ($s !~ /^\s*(?:\sif|(?:{|)\s*\\?\s*$)/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003602 ERROR("TRAILING_STATEMENTS",
3603 "trailing statements should be on next line\n" . $herecurr);
Andy Whitcroft13214ad2008-02-08 04:22:03 -08003604 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003605 }
Andy Whitcroft39667782009-01-15 13:51:06 -08003606# if should not continue a brace
3607 if ($line =~ /}\s*if\b/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003608 ERROR("TRAILING_STATEMENTS",
3609 "trailing statements should be on next line\n" .
Andy Whitcroft39667782009-01-15 13:51:06 -08003610 $herecurr);
3611 }
Andy Whitcrofta1080bf2008-10-15 22:02:25 -07003612# case and default should not have general statements after them
3613 if ($line =~ /^.\s*(?:case\s*.*|default\s*):/g &&
3614 $line !~ /\G(?:
Andy Whitcroft3fef12d2008-10-15 22:02:36 -07003615 (?:\s*$;*)(?:\s*{)?(?:\s*$;*)(?:\s*\\)?\s*$|
Andy Whitcrofta1080bf2008-10-15 22:02:25 -07003616 \s*return\s+
3617 )/xg)
3618 {
Joe Perches000d1cc12011-07-25 17:13:25 -07003619 ERROR("TRAILING_STATEMENTS",
3620 "trailing statements should be on next line\n" . $herecurr);
Andy Whitcrofta1080bf2008-10-15 22:02:25 -07003621 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003622
3623 # Check for }<nl>else {, these must be at the same
3624 # indent level to be relevant to each other.
3625 if ($prevline=~/}\s*$/ and $line=~/^.\s*else\s*/ and
3626 $previndent == $indent) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003627 ERROR("ELSE_AFTER_BRACE",
3628 "else should follow close brace '}'\n" . $hereprev);
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003629 }
3630
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08003631 if ($prevline=~/}\s*$/ and $line=~/^.\s*while\s*/ and
3632 $previndent == $indent) {
3633 my ($s, $c) = ctx_statement_block($linenr, $realcnt, 0);
3634
3635 # Find out what is on the end of the line after the
3636 # conditional.
Andy Whitcroft773647a2008-03-28 14:15:58 -07003637 substr($s, 0, length($c), '');
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08003638 $s =~ s/\n.*//g;
3639
3640 if ($s =~ /^\s*;/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003641 ERROR("WHILE_AFTER_BRACE",
3642 "while should follow close brace '}'\n" . $hereprev);
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08003643 }
3644 }
3645
Joe Perches95e2c602013-07-03 15:05:20 -07003646#Specific variable tests
Joe Perches323c1262012-12-17 16:02:07 -08003647 while ($line =~ m{($Constant|$Lval)}g) {
3648 my $var = $1;
Joe Perches95e2c602013-07-03 15:05:20 -07003649
3650#gcc binary extension
3651 if ($var =~ /^$Binary$/) {
Joe Perchesd5e616f2013-09-11 14:23:54 -07003652 if (WARN("GCC_BINARY_CONSTANT",
3653 "Avoid gcc v4.3+ binary constant extension: <$var>\n" . $herecurr) &&
3654 $fix) {
3655 my $hexval = sprintf("0x%x", oct($var));
3656 $fixed[$linenr - 1] =~
3657 s/\b$var\b/$hexval/;
3658 }
Joe Perches95e2c602013-07-03 15:05:20 -07003659 }
3660
3661#CamelCase
Joe Perches807bd262013-07-03 15:05:22 -07003662 if ($var !~ /^$Constant$/ &&
Joe Perchesbe797942013-07-03 15:05:20 -07003663 $var =~ /[A-Z][a-z]|[a-z][A-Z]/ &&
Joe Perches22735ce2013-07-03 15:05:33 -07003664#Ignore Page<foo> variants
Joe Perches807bd262013-07-03 15:05:22 -07003665 $var !~ /^(?:Clear|Set|TestClear|TestSet|)Page[A-Z]/ &&
Joe Perches22735ce2013-07-03 15:05:33 -07003666#Ignore SI style variants like nS, mV and dB (ie: max_uV, regulator_min_uA_show)
Joe Perches34456862013-07-03 15:05:34 -07003667 $var !~ /^(?:[a-z_]*?)_?[a-z][A-Z](?:_[a-z_]+)?$/) {
Joe Perches7e781f62013-09-11 14:23:55 -07003668 while ($var =~ m{($Ident)}g) {
3669 my $word = $1;
3670 next if ($word !~ /[A-Z][a-z]|[a-z][A-Z]/);
Joe Perchesd8b07712013-11-12 15:10:06 -08003671 if ($check) {
3672 seed_camelcase_includes();
3673 if (!$file && !$camelcase_file_seeded) {
3674 seed_camelcase_file($realfile);
3675 $camelcase_file_seeded = 1;
3676 }
3677 }
Joe Perches7e781f62013-09-11 14:23:55 -07003678 if (!defined $camelcase{$word}) {
3679 $camelcase{$word} = 1;
3680 CHK("CAMELCASE",
3681 "Avoid CamelCase: <$word>\n" . $herecurr);
3682 }
Joe Perches34456862013-07-03 15:05:34 -07003683 }
Joe Perches323c1262012-12-17 16:02:07 -08003684 }
3685 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003686
3687#no spaces allowed after \ in define
Joe Perchesd5e616f2013-09-11 14:23:54 -07003688 if ($line =~ /\#\s*define.*\\\s+$/) {
3689 if (WARN("WHITESPACE_AFTER_LINE_CONTINUATION",
3690 "Whitespace after \\ makes next lines useless\n" . $herecurr) &&
3691 $fix) {
3692 $fixed[$linenr - 1] =~ s/\s+$//;
3693 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003694 }
3695
Andy Whitcroft653d4872007-06-23 17:16:34 -07003696#warn if <asm/foo.h> is #included and <linux/foo.h> is available (uses RAW line)
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07003697 if ($tree && $rawline =~ m{^.\s*\#\s*include\s*\<asm\/(.*)\.h\>}) {
Andy Whitcrofte09dec42008-10-15 22:02:20 -07003698 my $file = "$1.h";
3699 my $checkfile = "include/linux/$file";
3700 if (-f "$root/$checkfile" &&
3701 $realfile ne $checkfile &&
Wolfram Sang7840a942010-08-09 17:20:57 -07003702 $1 !~ /$allowed_asm_includes/)
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07003703 {
Andy Whitcrofte09dec42008-10-15 22:02:20 -07003704 if ($realfile =~ m{^arch/}) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003705 CHK("ARCH_INCLUDE_LINUX",
3706 "Consider using #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
Andy Whitcrofte09dec42008-10-15 22:02:20 -07003707 } else {
Joe Perches000d1cc12011-07-25 17:13:25 -07003708 WARN("INCLUDE_LINUX",
3709 "Use #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
Andy Whitcrofte09dec42008-10-15 22:02:20 -07003710 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003711 }
3712 }
3713
Andy Whitcroft653d4872007-06-23 17:16:34 -07003714# multi-statement macros should be enclosed in a do while loop, grab the
3715# first statement and ensure its the whole macro if its not enclosed
Andy Whitcroftcf655042008-03-04 14:28:20 -08003716# in a known good container
Andy Whitcroftb8f96a32008-07-23 21:29:07 -07003717 if ($realfile !~ m@/vmlinux.lds.h$@ &&
3718 $line =~ /^.\s*\#\s*define\s*$Ident(\()?/) {
Andy Whitcroftd8aaf122007-06-23 17:16:44 -07003719 my $ln = $linenr;
3720 my $cnt = $realcnt;
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07003721 my ($off, $dstat, $dcond, $rest);
3722 my $ctx = '';
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07003723 ($dstat, $dcond, $ln, $cnt, $off) =
Andy Whitcroftf74bd192012-01-10 15:09:54 -08003724 ctx_statement_block($linenr, $realcnt, 0);
3725 $ctx = $dstat;
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07003726 #print "dstat<$dstat> dcond<$dcond> cnt<$cnt> off<$off>\n";
Andy Whitcrofta3bb97a2008-07-23 21:29:00 -07003727 #print "LINE<$lines[$ln-1]> len<" . length($lines[$ln-1]) . "\n";
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07003728
Andy Whitcroftf74bd192012-01-10 15:09:54 -08003729 $dstat =~ s/^.\s*\#\s*define\s+$Ident(?:\([^\)]*\))?\s*//;
Andy Whitcroft292f1a92008-07-23 21:29:11 -07003730 $dstat =~ s/$;//g;
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07003731 $dstat =~ s/\\\n.//g;
3732 $dstat =~ s/^\s*//s;
3733 $dstat =~ s/\s*$//s;
3734
3735 # Flatten any parentheses and braces
Andy Whitcroftbf30d6e2008-10-15 22:02:33 -07003736 while ($dstat =~ s/\([^\(\)]*\)/1/ ||
3737 $dstat =~ s/\{[^\{\}]*\}/1/ ||
Andy Whitcroftc81769f2012-01-10 15:10:10 -08003738 $dstat =~ s/\[[^\[\]]*\]/1/)
Andy Whitcroftbf30d6e2008-10-15 22:02:33 -07003739 {
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07003740 }
Andy Whitcroftd8aaf122007-06-23 17:16:44 -07003741
Andy Whitcrofte45bab82012-03-23 15:02:18 -07003742 # Flatten any obvious string concatentation.
3743 while ($dstat =~ s/("X*")\s*$Ident/$1/ ||
3744 $dstat =~ s/$Ident\s*("X*")/$1/)
3745 {
3746 }
3747
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07003748 my $exceptions = qr{
3749 $Declare|
3750 module_param_named|
Kees Cooka0a0a7a2012-10-04 17:13:38 -07003751 MODULE_PARM_DESC|
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07003752 DECLARE_PER_CPU|
3753 DEFINE_PER_CPU|
Andy Whitcroft383099f2009-01-06 14:41:18 -08003754 __typeof__\(|
Stefani Seibold22fd2d32010-03-05 13:43:52 -08003755 union|
3756 struct|
Andy Whitcroftea71a0a2009-09-21 17:04:38 -07003757 \.$Ident\s*=\s*|
3758 ^\"|\"$
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07003759 }x;
Andy Whitcroft5eaa20b2010-10-26 14:23:18 -07003760 #print "REST<$rest> dstat<$dstat> ctx<$ctx>\n";
Andy Whitcroftf74bd192012-01-10 15:09:54 -08003761 if ($dstat ne '' &&
3762 $dstat !~ /^(?:$Ident|-?$Constant),$/ && # 10, // foo(),
3763 $dstat !~ /^(?:$Ident|-?$Constant);$/ && # foo();
Joe Perches3cc4b1c2013-07-03 15:05:27 -07003764 $dstat !~ /^[!~-]?(?:$Lval|$Constant)$/ && # 10 // foo() // !foo // ~foo // -foo // foo->bar // foo.bar->baz
Andy Whitcroftb9df76a2012-03-23 15:02:17 -07003765 $dstat !~ /^'X'$/ && # character constants
Andy Whitcroftf74bd192012-01-10 15:09:54 -08003766 $dstat !~ /$exceptions/ &&
3767 $dstat !~ /^\.$Ident\s*=/ && # .foo =
Joe Perchese942e2c2013-04-17 15:58:26 -07003768 $dstat !~ /^(?:\#\s*$Ident|\#\s*$Constant)\s*$/ && # stringification #foo
Andy Whitcroft72f115f2012-01-10 15:10:06 -08003769 $dstat !~ /^do\s*$Constant\s*while\s*$Constant;?$/ && # do {...} while (...); // do {...} while (...)
Andy Whitcroftf74bd192012-01-10 15:09:54 -08003770 $dstat !~ /^for\s*$Constant$/ && # for (...)
3771 $dstat !~ /^for\s*$Constant\s+(?:$Ident|-?$Constant)$/ && # for (...) bar()
3772 $dstat !~ /^do\s*{/ && # do {...
Joe Perchesf95a7e62013-09-11 14:24:00 -07003773 $dstat !~ /^\({/ && # ({...
3774 $ctx !~ /^.\s*#\s*define\s+TRACE_(?:SYSTEM|INCLUDE_FILE|INCLUDE_PATH)\b/)
Andy Whitcroftf74bd192012-01-10 15:09:54 -08003775 {
3776 $ctx =~ s/\n*$//;
3777 my $herectx = $here . "\n";
3778 my $cnt = statement_rawlines($ctx);
3779
3780 for (my $n = 0; $n < $cnt; $n++) {
3781 $herectx .= raw_line($linenr, $n) . "\n";
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07003782 }
3783
Andy Whitcroftf74bd192012-01-10 15:09:54 -08003784 if ($dstat =~ /;/) {
3785 ERROR("MULTISTATEMENT_MACRO_USE_DO_WHILE",
3786 "Macros with multiple statements should be enclosed in a do - while loop\n" . "$herectx");
3787 } else {
Joe Perches000d1cc12011-07-25 17:13:25 -07003788 ERROR("COMPLEX_MACRO",
Andy Whitcroftf74bd192012-01-10 15:09:54 -08003789 "Macros with complex values should be enclosed in parenthesis\n" . "$herectx");
Andy Whitcroftd8aaf122007-06-23 17:16:44 -07003790 }
Andy Whitcroft653d4872007-06-23 17:16:34 -07003791 }
Joe Perches5023d342012-12-17 16:01:47 -08003792
Joe Perches481eb482012-12-17 16:01:56 -08003793# check for line continuations outside of #defines, preprocessor #, and asm
Joe Perches5023d342012-12-17 16:01:47 -08003794
3795 } else {
3796 if ($prevline !~ /^..*\\$/ &&
Joe Perches481eb482012-12-17 16:01:56 -08003797 $line !~ /^\+\s*\#.*\\$/ && # preprocessor
3798 $line !~ /^\+.*\b(__asm__|asm)\b.*\\$/ && # asm
Joe Perches5023d342012-12-17 16:01:47 -08003799 $line =~ /^\+.*\\$/) {
3800 WARN("LINE_CONTINUATIONS",
3801 "Avoid unnecessary line continuations\n" . $herecurr);
3802 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003803 }
3804
Joe Perchesb13edf72012-07-30 14:41:24 -07003805# do {} while (0) macro tests:
3806# single-statement macros do not need to be enclosed in do while (0) loop,
3807# macro should not end with a semicolon
3808 if ($^V && $^V ge 5.10.0 &&
3809 $realfile !~ m@/vmlinux.lds.h$@ &&
3810 $line =~ /^.\s*\#\s*define\s+$Ident(\()?/) {
3811 my $ln = $linenr;
3812 my $cnt = $realcnt;
3813 my ($off, $dstat, $dcond, $rest);
3814 my $ctx = '';
3815 ($dstat, $dcond, $ln, $cnt, $off) =
3816 ctx_statement_block($linenr, $realcnt, 0);
3817 $ctx = $dstat;
3818
3819 $dstat =~ s/\\\n.//g;
3820
3821 if ($dstat =~ /^\+\s*#\s*define\s+$Ident\s*${balanced_parens}\s*do\s*{(.*)\s*}\s*while\s*\(\s*0\s*\)\s*([;\s]*)\s*$/) {
3822 my $stmts = $2;
3823 my $semis = $3;
3824
3825 $ctx =~ s/\n*$//;
3826 my $cnt = statement_rawlines($ctx);
3827 my $herectx = $here . "\n";
3828
3829 for (my $n = 0; $n < $cnt; $n++) {
3830 $herectx .= raw_line($linenr, $n) . "\n";
3831 }
3832
Joe Perchesac8e97f2012-08-21 16:15:53 -07003833 if (($stmts =~ tr/;/;/) == 1 &&
3834 $stmts !~ /^\s*(if|while|for|switch)\b/) {
Joe Perchesb13edf72012-07-30 14:41:24 -07003835 WARN("SINGLE_STATEMENT_DO_WHILE_MACRO",
3836 "Single statement macros should not use a do {} while (0) loop\n" . "$herectx");
3837 }
3838 if (defined $semis && $semis ne "") {
3839 WARN("DO_WHILE_MACRO_WITH_TRAILING_SEMICOLON",
3840 "do {} while (0) macros should not be semicolon terminated\n" . "$herectx");
3841 }
Joe Perchesf5ef95b2014-06-04 16:12:06 -07003842 } elsif ($dstat =~ /^\+\s*#\s*define\s+$Ident.*;\s*$/) {
3843 $ctx =~ s/\n*$//;
3844 my $cnt = statement_rawlines($ctx);
3845 my $herectx = $here . "\n";
3846
3847 for (my $n = 0; $n < $cnt; $n++) {
3848 $herectx .= raw_line($linenr, $n) . "\n";
3849 }
3850
3851 WARN("TRAILING_SEMICOLON",
3852 "macros should not use a trailing semicolon\n" . "$herectx");
Joe Perchesb13edf72012-07-30 14:41:24 -07003853 }
3854 }
3855
Mike Frysinger080ba922009-01-06 14:41:25 -08003856# make sure symbols are always wrapped with VMLINUX_SYMBOL() ...
3857# all assignments may have only one of the following with an assignment:
3858# .
3859# ALIGN(...)
3860# VMLINUX_SYMBOL(...)
3861 if ($realfile eq 'vmlinux.lds.h' && $line =~ /(?:(?:^|\s)$Ident\s*=|=\s*$Ident(?:\s|$))/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003862 WARN("MISSING_VMLINUX_SYMBOL",
3863 "vmlinux.lds.h needs VMLINUX_SYMBOL() around C-visible symbols\n" . $herecurr);
Mike Frysinger080ba922009-01-06 14:41:25 -08003864 }
3865
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07003866# check for redundant bracing round if etc
Andy Whitcroft13214ad2008-02-08 04:22:03 -08003867 if ($line =~ /(^.*)\bif\b/ && $1 !~ /else\s*$/) {
3868 my ($level, $endln, @chunks) =
Andy Whitcroftcf655042008-03-04 14:28:20 -08003869 ctx_statement_full($linenr, $realcnt, 1);
Andy Whitcroft13214ad2008-02-08 04:22:03 -08003870 #print "chunks<$#chunks> linenr<$linenr> endln<$endln> level<$level>\n";
Andy Whitcroftcf655042008-03-04 14:28:20 -08003871 #print "APW: <<$chunks[1][0]>><<$chunks[1][1]>>\n";
3872 if ($#chunks > 0 && $level == 0) {
Joe Perchesaad4f612012-03-23 15:02:19 -07003873 my @allowed = ();
3874 my $allow = 0;
Andy Whitcroft13214ad2008-02-08 04:22:03 -08003875 my $seen = 0;
Andy Whitcroft773647a2008-03-28 14:15:58 -07003876 my $herectx = $here . "\n";
Andy Whitcroftcf655042008-03-04 14:28:20 -08003877 my $ln = $linenr - 1;
Andy Whitcroft13214ad2008-02-08 04:22:03 -08003878 for my $chunk (@chunks) {
3879 my ($cond, $block) = @{$chunk};
3880
Andy Whitcroft773647a2008-03-28 14:15:58 -07003881 # If the condition carries leading newlines, then count those as offsets.
3882 my ($whitespace) = ($cond =~ /^((?:\s*\n[+-])*\s*)/s);
3883 my $offset = statement_rawlines($whitespace) - 1;
3884
Joe Perchesaad4f612012-03-23 15:02:19 -07003885 $allowed[$allow] = 0;
Andy Whitcroft773647a2008-03-28 14:15:58 -07003886 #print "COND<$cond> whitespace<$whitespace> offset<$offset>\n";
3887
3888 # We have looked at and allowed this specific line.
3889 $suppress_ifbraces{$ln + $offset} = 1;
3890
3891 $herectx .= "$rawlines[$ln + $offset]\n[...]\n";
Andy Whitcroftcf655042008-03-04 14:28:20 -08003892 $ln += statement_rawlines($block) - 1;
3893
Andy Whitcroft773647a2008-03-28 14:15:58 -07003894 substr($block, 0, length($cond), '');
Andy Whitcroft13214ad2008-02-08 04:22:03 -08003895
3896 $seen++ if ($block =~ /^\s*{/);
3897
Joe Perchesaad4f612012-03-23 15:02:19 -07003898 #print "cond<$cond> block<$block> allowed<$allowed[$allow]>\n";
Andy Whitcroftcf655042008-03-04 14:28:20 -08003899 if (statement_lines($cond) > 1) {
3900 #print "APW: ALLOWED: cond<$cond>\n";
Joe Perchesaad4f612012-03-23 15:02:19 -07003901 $allowed[$allow] = 1;
Andy Whitcroft13214ad2008-02-08 04:22:03 -08003902 }
3903 if ($block =~/\b(?:if|for|while)\b/) {
Andy Whitcroftcf655042008-03-04 14:28:20 -08003904 #print "APW: ALLOWED: block<$block>\n";
Joe Perchesaad4f612012-03-23 15:02:19 -07003905 $allowed[$allow] = 1;
Andy Whitcroft13214ad2008-02-08 04:22:03 -08003906 }
Andy Whitcroftcf655042008-03-04 14:28:20 -08003907 if (statement_block_size($block) > 1) {
3908 #print "APW: ALLOWED: lines block<$block>\n";
Joe Perchesaad4f612012-03-23 15:02:19 -07003909 $allowed[$allow] = 1;
Andy Whitcroft13214ad2008-02-08 04:22:03 -08003910 }
Joe Perchesaad4f612012-03-23 15:02:19 -07003911 $allow++;
Andy Whitcroft13214ad2008-02-08 04:22:03 -08003912 }
Joe Perchesaad4f612012-03-23 15:02:19 -07003913 if ($seen) {
3914 my $sum_allowed = 0;
3915 foreach (@allowed) {
3916 $sum_allowed += $_;
3917 }
3918 if ($sum_allowed == 0) {
3919 WARN("BRACES",
3920 "braces {} are not necessary for any arm of this statement\n" . $herectx);
3921 } elsif ($sum_allowed != $allow &&
3922 $seen != $allow) {
3923 CHK("BRACES",
3924 "braces {} should be used on all arms of this statement\n" . $herectx);
3925 }
Andy Whitcroft13214ad2008-02-08 04:22:03 -08003926 }
3927 }
3928 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07003929 if (!defined $suppress_ifbraces{$linenr - 1} &&
Andy Whitcroft13214ad2008-02-08 04:22:03 -08003930 $line =~ /\b(if|while|for|else)\b/) {
Andy Whitcroftcf655042008-03-04 14:28:20 -08003931 my $allowed = 0;
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07003932
Andy Whitcroftcf655042008-03-04 14:28:20 -08003933 # Check the pre-context.
3934 if (substr($line, 0, $-[0]) =~ /(\}\s*)$/) {
3935 #print "APW: ALLOWED: pre<$1>\n";
3936 $allowed = 1;
3937 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07003938
3939 my ($level, $endln, @chunks) =
3940 ctx_statement_full($linenr, $realcnt, $-[0]);
3941
Andy Whitcroftcf655042008-03-04 14:28:20 -08003942 # Check the condition.
3943 my ($cond, $block) = @{$chunks[0]};
Andy Whitcroft773647a2008-03-28 14:15:58 -07003944 #print "CHECKING<$linenr> cond<$cond> block<$block>\n";
Andy Whitcroftcf655042008-03-04 14:28:20 -08003945 if (defined $cond) {
Andy Whitcroft773647a2008-03-28 14:15:58 -07003946 substr($block, 0, length($cond), '');
Andy Whitcroftcf655042008-03-04 14:28:20 -08003947 }
3948 if (statement_lines($cond) > 1) {
3949 #print "APW: ALLOWED: cond<$cond>\n";
3950 $allowed = 1;
3951 }
3952 if ($block =~/\b(?:if|for|while)\b/) {
3953 #print "APW: ALLOWED: block<$block>\n";
3954 $allowed = 1;
3955 }
3956 if (statement_block_size($block) > 1) {
3957 #print "APW: ALLOWED: lines block<$block>\n";
3958 $allowed = 1;
3959 }
3960 # Check the post-context.
3961 if (defined $chunks[1]) {
3962 my ($cond, $block) = @{$chunks[1]};
3963 if (defined $cond) {
Andy Whitcroft773647a2008-03-28 14:15:58 -07003964 substr($block, 0, length($cond), '');
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07003965 }
Andy Whitcroftcf655042008-03-04 14:28:20 -08003966 if ($block =~ /^\s*\{/) {
3967 #print "APW: ALLOWED: chunk-1 block<$block>\n";
3968 $allowed = 1;
3969 }
3970 }
3971 if ($level == 0 && $block =~ /^\s*\{/ && !$allowed) {
Justin P. Mattock69932482011-07-26 23:06:29 -07003972 my $herectx = $here . "\n";
Andy Whitcroftf0556632008-10-15 22:02:23 -07003973 my $cnt = statement_rawlines($block);
Andy Whitcroftcf655042008-03-04 14:28:20 -08003974
Andy Whitcroftf0556632008-10-15 22:02:23 -07003975 for (my $n = 0; $n < $cnt; $n++) {
Justin P. Mattock69932482011-07-26 23:06:29 -07003976 $herectx .= raw_line($linenr, $n) . "\n";
Andy Whitcroftcf655042008-03-04 14:28:20 -08003977 }
3978
Joe Perches000d1cc12011-07-25 17:13:25 -07003979 WARN("BRACES",
3980 "braces {} are not necessary for single statement blocks\n" . $herectx);
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07003981 }
3982 }
3983
Joe Perches0979ae62012-12-17 16:01:59 -08003984# check for unnecessary blank lines around braces
Joe Perches77b9a532013-07-03 15:05:29 -07003985 if (($line =~ /^.\s*}\s*$/ && $prevrawline =~ /^.\s*$/)) {
Joe Perches0979ae62012-12-17 16:01:59 -08003986 CHK("BRACES",
3987 "Blank lines aren't necessary before a close brace '}'\n" . $hereprev);
3988 }
Joe Perches77b9a532013-07-03 15:05:29 -07003989 if (($rawline =~ /^.\s*$/ && $prevline =~ /^..*{\s*$/)) {
Joe Perches0979ae62012-12-17 16:01:59 -08003990 CHK("BRACES",
3991 "Blank lines aren't necessary after an open brace '{'\n" . $hereprev);
3992 }
3993
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07003994# no volatiles please
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07003995 my $asm_volatile = qr{\b(__asm__|asm)\s+(__volatile__|volatile)\b};
3996 if ($line =~ /\bvolatile\b/ && $line !~ /$asm_volatile/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003997 WARN("VOLATILE",
3998 "Use of volatile is usually wrong: see Documentation/volatile-considered-harmful.txt\n" . $herecurr);
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07003999 }
4000
Andy Whitcroft00df3442007-06-08 13:47:06 -07004001# warn about #if 0
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004002 if ($line =~ /^.\s*\#\s*if\s+0\b/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07004003 CHK("REDUNDANT_CODE",
4004 "if this code is redundant consider removing it\n" .
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07004005 $herecurr);
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07004006 }
4007
Andy Whitcroft03df4b52012-12-17 16:01:52 -08004008# check for needless "if (<foo>) fn(<foo>)" uses
4009 if ($prevline =~ /\bif\s*\(\s*($Lval)\s*\)/) {
4010 my $expr = '\s*\(\s*' . quotemeta($1) . '\s*\)\s*;';
4011 if ($line =~ /\b(kfree|usb_free_urb|debugfs_remove(?:_recursive)?)$expr/) {
4012 WARN('NEEDLESS_IF',
4013 "$1(NULL) is safe this check is probably not required\n" . $hereprev);
Greg Kroah-Hartman4c432a82008-07-23 21:29:04 -07004014 }
4015 }
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07004016
Joe Perches8716de32013-09-11 14:24:05 -07004017# check for bad placement of section $InitAttribute (e.g.: __initdata)
4018 if ($line =~ /(\b$InitAttribute\b)/) {
4019 my $attr = $1;
4020 if ($line =~ /^\+\s*static\s+(?:const\s+)?(?:$attr\s+)?($NonptrTypeWithAttr)\s+(?:$attr\s+)?($Ident(?:\[[^]]*\])?)\s*[=;]/) {
4021 my $ptr = $1;
4022 my $var = $2;
4023 if ((($ptr =~ /\b(union|struct)\s+$attr\b/ &&
4024 ERROR("MISPLACED_INIT",
4025 "$attr should be placed after $var\n" . $herecurr)) ||
4026 ($ptr !~ /\b(union|struct)\s+$attr\b/ &&
4027 WARN("MISPLACED_INIT",
4028 "$attr should be placed after $var\n" . $herecurr))) &&
4029 $fix) {
4030 $fixed[$linenr - 1] =~ s/(\bstatic\s+(?:const\s+)?)(?:$attr\s+)?($NonptrTypeWithAttr)\s+(?:$attr\s+)?($Ident(?:\[[^]]*\])?)\s*([=;])\s*/"$1" . trim(string_find_replace($2, "\\s*$attr\\s*", " ")) . " " . trim(string_find_replace($3, "\\s*$attr\\s*", "")) . " $attr" . ("$4" eq ";" ? ";" : " = ")/e;
4031 }
4032 }
4033 }
4034
Joe Perchese970b882013-11-12 15:10:10 -08004035# check for $InitAttributeData (ie: __initdata) with const
4036 if ($line =~ /\bconst\b/ && $line =~ /($InitAttributeData)/) {
4037 my $attr = $1;
4038 $attr =~ /($InitAttributePrefix)(.*)/;
4039 my $attr_prefix = $1;
4040 my $attr_type = $2;
4041 if (ERROR("INIT_ATTRIBUTE",
4042 "Use of const init definition must use ${attr_prefix}initconst\n" . $herecurr) &&
4043 $fix) {
4044 $fixed[$linenr - 1] =~
4045 s/$InitAttributeData/${attr_prefix}initconst/;
4046 }
4047 }
4048
4049# check for $InitAttributeConst (ie: __initconst) without const
4050 if ($line !~ /\bconst\b/ && $line =~ /($InitAttributeConst)/) {
4051 my $attr = $1;
4052 if (ERROR("INIT_ATTRIBUTE",
4053 "Use of $attr requires a separate use of const\n" . $herecurr) &&
4054 $fix) {
4055 my $lead = $fixed[$linenr - 1] =~
4056 /(^\+\s*(?:static\s+))/;
4057 $lead = rtrim($1);
4058 $lead = "$lead " if ($lead !~ /^\+$/);
4059 $lead = "${lead}const ";
4060 $fixed[$linenr - 1] =~ s/(^\+\s*(?:static\s+))/$lead/;
4061 }
4062 }
4063
Joe Perchesfbdb8132014-04-03 14:49:14 -07004064# don't use __constant_<foo> functions outside of include/uapi/
4065 if ($realfile !~ m@^include/uapi/@ &&
4066 $line =~ /(__constant_(?:htons|ntohs|[bl]e(?:16|32|64)_to_cpu|cpu_to_[bl]e(?:16|32|64)))\s*\(/) {
4067 my $constant_func = $1;
4068 my $func = $constant_func;
4069 $func =~ s/^__constant_//;
4070 if (WARN("CONSTANT_CONVERSION",
4071 "$constant_func should be $func\n" . $herecurr) &&
4072 $fix) {
4073 $fixed[$linenr - 1] =~ s/\b$constant_func\b/$func/g;
4074 }
4075 }
4076
Patrick Pannuto1a15a252010-08-09 17:21:01 -07004077# prefer usleep_range over udelay
Bruce Allan37581c22013-02-21 16:44:19 -08004078 if ($line =~ /\budelay\s*\(\s*(\d+)\s*\)/) {
Joe Perches43c1d772014-04-03 14:49:11 -07004079 my $delay = $1;
Patrick Pannuto1a15a252010-08-09 17:21:01 -07004080 # ignore udelay's < 10, however
Joe Perches43c1d772014-04-03 14:49:11 -07004081 if (! ($delay < 10) ) {
Joe Perches000d1cc12011-07-25 17:13:25 -07004082 CHK("USLEEP_RANGE",
Joe Perches43c1d772014-04-03 14:49:11 -07004083 "usleep_range is preferred over udelay; see Documentation/timers/timers-howto.txt\n" . $herecurr);
4084 }
4085 if ($delay > 2000) {
4086 WARN("LONG_UDELAY",
4087 "long udelay - prefer mdelay; see arch/arm/include/asm/delay.h\n" . $herecurr);
Patrick Pannuto1a15a252010-08-09 17:21:01 -07004088 }
4089 }
4090
Patrick Pannuto09ef8722010-08-09 17:21:02 -07004091# warn about unexpectedly long msleep's
4092 if ($line =~ /\bmsleep\s*\((\d+)\);/) {
4093 if ($1 < 20) {
Joe Perches000d1cc12011-07-25 17:13:25 -07004094 WARN("MSLEEP",
Joe Perches43c1d772014-04-03 14:49:11 -07004095 "msleep < 20ms can sleep for up to 20ms; see Documentation/timers/timers-howto.txt\n" . $herecurr);
Patrick Pannuto09ef8722010-08-09 17:21:02 -07004096 }
4097 }
4098
Joe Perches36ec1932013-07-03 15:05:25 -07004099# check for comparisons of jiffies
4100 if ($line =~ /\bjiffies\s*$Compare|$Compare\s*jiffies\b/) {
4101 WARN("JIFFIES_COMPARISON",
4102 "Comparing jiffies is almost always wrong; prefer time_after, time_before and friends\n" . $herecurr);
4103 }
4104
Joe Perches9d7a34a2013-07-03 15:05:26 -07004105# check for comparisons of get_jiffies_64()
4106 if ($line =~ /\bget_jiffies_64\s*\(\s*\)\s*$Compare|$Compare\s*get_jiffies_64\s*\(\s*\)/) {
4107 WARN("JIFFIES_COMPARISON",
4108 "Comparing get_jiffies_64() is almost always wrong; prefer time_after64, time_before64 and friends\n" . $herecurr);
4109 }
4110
Andy Whitcroft00df3442007-06-08 13:47:06 -07004111# warn about #ifdefs in C files
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004112# if ($line =~ /^.\s*\#\s*if(|n)def/ && ($realfile =~ /\.c$/)) {
Andy Whitcroft00df3442007-06-08 13:47:06 -07004113# print "#ifdef in C files should be avoided\n";
4114# print "$herecurr";
4115# $clean = 0;
4116# }
4117
Andy Whitcroft22f2a2e2007-08-10 13:01:03 -07004118# warn about spacing in #ifdefs
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004119 if ($line =~ /^.\s*\#\s*(ifdef|ifndef|elif)\s\s+/) {
Joe Perches3705ce52013-07-03 15:05:31 -07004120 if (ERROR("SPACING",
4121 "exactly one space required after that #$1\n" . $herecurr) &&
4122 $fix) {
4123 $fixed[$linenr - 1] =~
4124 s/^(.\s*\#\s*(ifdef|ifndef|elif))\s{2,}/$1 /;
4125 }
4126
Andy Whitcroft22f2a2e2007-08-10 13:01:03 -07004127 }
4128
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07004129# check for spinlock_t definitions without a comment.
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07004130 if ($line =~ /^.\s*(struct\s+mutex|spinlock_t)\s+\S+;/ ||
4131 $line =~ /^.\s*(DEFINE_MUTEX)\s*\(/) {
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07004132 my $which = $1;
4133 if (!ctx_has_comment($first_line, $linenr)) {
Joe Perches000d1cc12011-07-25 17:13:25 -07004134 CHK("UNCOMMENTED_DEFINITION",
4135 "$1 definition without comment\n" . $herecurr);
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07004136 }
4137 }
4138# check for memory barriers without a comment.
4139 if ($line =~ /\b(mb|rmb|wmb|read_barrier_depends|smp_mb|smp_rmb|smp_wmb|smp_read_barrier_depends)\(/) {
4140 if (!ctx_has_comment($first_line, $linenr)) {
Joe Perchesc1fd7bb2013-11-12 15:10:11 -08004141 WARN("MEMORY_BARRIER",
4142 "memory barrier without comment\n" . $herecurr);
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07004143 }
4144 }
4145# check of hardware specific defines
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004146 if ($line =~ m@^.\s*\#\s*if.*\b(__i386__|__powerpc64__|__sun__|__s390x__)\b@ && $realfile !~ m@include/asm-@) {
Joe Perches000d1cc12011-07-25 17:13:25 -07004147 CHK("ARCH_DEFINES",
4148 "architecture specific defines should be avoided\n" . $herecurr);
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004149 }
Andy Whitcroft653d4872007-06-23 17:16:34 -07004150
Tobias Klauserd4977c72010-05-24 14:33:30 -07004151# Check that the storage class is at the beginning of a declaration
4152 if ($line =~ /\b$Storage\b/ && $line !~ /^.\s*$Storage\b/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07004153 WARN("STORAGE_CLASS",
4154 "storage class should be at the beginning of the declaration\n" . $herecurr)
Tobias Klauserd4977c72010-05-24 14:33:30 -07004155 }
4156
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07004157# check the location of the inline attribute, that it is between
4158# storage class and type.
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07004159 if ($line =~ /\b$Type\s+$Inline\b/ ||
4160 $line =~ /\b$Inline\s+$Storage\b/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07004161 ERROR("INLINE_LOCATION",
4162 "inline keyword should sit between storage class and type\n" . $herecurr);
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07004163 }
4164
Andy Whitcroft8905a672007-11-28 16:21:06 -08004165# Check for __inline__ and __inline, prefer inline
Joe Perches2b7ab452013-11-12 15:10:14 -08004166 if ($realfile !~ m@\binclude/uapi/@ &&
4167 $line =~ /\b(__inline__|__inline)\b/) {
Joe Perchesd5e616f2013-09-11 14:23:54 -07004168 if (WARN("INLINE",
4169 "plain inline is preferred over $1\n" . $herecurr) &&
4170 $fix) {
4171 $fixed[$linenr - 1] =~ s/\b(__inline__|__inline)\b/inline/;
4172
4173 }
Andy Whitcroft8905a672007-11-28 16:21:06 -08004174 }
4175
Joe Perches3d130fd2011-01-12 17:00:00 -08004176# Check for __attribute__ packed, prefer __packed
Joe Perches2b7ab452013-11-12 15:10:14 -08004177 if ($realfile !~ m@\binclude/uapi/@ &&
4178 $line =~ /\b__attribute__\s*\(\s*\(.*\bpacked\b/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07004179 WARN("PREFER_PACKED",
4180 "__packed is preferred over __attribute__((packed))\n" . $herecurr);
Joe Perches3d130fd2011-01-12 17:00:00 -08004181 }
4182
Joe Perches39b7e282011-07-25 17:13:24 -07004183# Check for __attribute__ aligned, prefer __aligned
Joe Perches2b7ab452013-11-12 15:10:14 -08004184 if ($realfile !~ m@\binclude/uapi/@ &&
4185 $line =~ /\b__attribute__\s*\(\s*\(.*aligned/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07004186 WARN("PREFER_ALIGNED",
4187 "__aligned(size) is preferred over __attribute__((aligned(size)))\n" . $herecurr);
Joe Perches39b7e282011-07-25 17:13:24 -07004188 }
4189
Joe Perches5f14d3b2012-01-10 15:09:52 -08004190# Check for __attribute__ format(printf, prefer __printf
Joe Perches2b7ab452013-11-12 15:10:14 -08004191 if ($realfile !~ m@\binclude/uapi/@ &&
4192 $line =~ /\b__attribute__\s*\(\s*\(\s*format\s*\(\s*printf/) {
Joe Perchesd5e616f2013-09-11 14:23:54 -07004193 if (WARN("PREFER_PRINTF",
4194 "__printf(string-index, first-to-check) is preferred over __attribute__((format(printf, string-index, first-to-check)))\n" . $herecurr) &&
4195 $fix) {
4196 $fixed[$linenr - 1] =~ s/\b__attribute__\s*\(\s*\(\s*format\s*\(\s*printf\s*,\s*(.*)\)\s*\)\s*\)/"__printf(" . trim($1) . ")"/ex;
4197
4198 }
Joe Perches5f14d3b2012-01-10 15:09:52 -08004199 }
4200
Joe Perches6061d942012-03-23 15:02:16 -07004201# Check for __attribute__ format(scanf, prefer __scanf
Joe Perches2b7ab452013-11-12 15:10:14 -08004202 if ($realfile !~ m@\binclude/uapi/@ &&
4203 $line =~ /\b__attribute__\s*\(\s*\(\s*format\s*\(\s*scanf\b/) {
Joe Perchesd5e616f2013-09-11 14:23:54 -07004204 if (WARN("PREFER_SCANF",
4205 "__scanf(string-index, first-to-check) is preferred over __attribute__((format(scanf, string-index, first-to-check)))\n" . $herecurr) &&
4206 $fix) {
4207 $fixed[$linenr - 1] =~ s/\b__attribute__\s*\(\s*\(\s*format\s*\(\s*scanf\s*,\s*(.*)\)\s*\)\s*\)/"__scanf(" . trim($1) . ")"/ex;
4208 }
Joe Perches6061d942012-03-23 15:02:16 -07004209 }
4210
Joe Perches8f53a9b2010-03-05 13:43:48 -08004211# check for sizeof(&)
4212 if ($line =~ /\bsizeof\s*\(\s*\&/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07004213 WARN("SIZEOF_ADDRESS",
4214 "sizeof(& should be avoided\n" . $herecurr);
Joe Perches8f53a9b2010-03-05 13:43:48 -08004215 }
4216
Joe Perches66c80b62012-07-30 14:41:22 -07004217# check for sizeof without parenthesis
4218 if ($line =~ /\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/) {
Joe Perchesd5e616f2013-09-11 14:23:54 -07004219 if (WARN("SIZEOF_PARENTHESIS",
4220 "sizeof $1 should be sizeof($1)\n" . $herecurr) &&
4221 $fix) {
4222 $fixed[$linenr - 1] =~ s/\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/"sizeof(" . trim($1) . ")"/ex;
4223 }
Joe Perches66c80b62012-07-30 14:41:22 -07004224 }
4225
Joe Perches428e2fd2011-05-24 17:13:39 -07004226# check for line continuations in quoted strings with odd counts of "
4227 if ($rawline =~ /\\$/ && $rawline =~ tr/"/"/ % 2) {
Joe Perches000d1cc12011-07-25 17:13:25 -07004228 WARN("LINE_CONTINUATIONS",
4229 "Avoid line continuations in quoted strings\n" . $herecurr);
Joe Perches428e2fd2011-05-24 17:13:39 -07004230 }
4231
Joe Perches88982fe2012-12-17 16:02:00 -08004232# check for struct spinlock declarations
4233 if ($line =~ /^.\s*\bstruct\s+spinlock\s+\w+\s*;/) {
4234 WARN("USE_SPINLOCK_T",
4235 "struct spinlock should be spinlock_t\n" . $herecurr);
4236 }
4237
Joe Perchesa6962d72013-04-29 16:18:13 -07004238# check for seq_printf uses that could be seq_puts
Joe Perches06668722013-11-12 15:10:07 -08004239 if ($sline =~ /\bseq_printf\s*\(.*"\s*\)\s*;\s*$/) {
Joe Perchesa6962d72013-04-29 16:18:13 -07004240 my $fmt = get_quoted_string($line, $rawline);
Joe Perches06668722013-11-12 15:10:07 -08004241 if ($fmt ne "" && $fmt !~ /[^\\]\%/) {
Joe Perchesd5e616f2013-09-11 14:23:54 -07004242 if (WARN("PREFER_SEQ_PUTS",
4243 "Prefer seq_puts to seq_printf\n" . $herecurr) &&
4244 $fix) {
4245 $fixed[$linenr - 1] =~ s/\bseq_printf\b/seq_puts/;
4246 }
Joe Perchesa6962d72013-04-29 16:18:13 -07004247 }
4248 }
4249
Andy Whitcroft554e1652012-01-10 15:09:57 -08004250# Check for misused memsets
Joe Perchesd1fe9c02012-03-23 15:02:16 -07004251 if ($^V && $^V ge 5.10.0 &&
4252 defined $stat &&
Joe Perchesd7c76ba2012-01-10 15:09:58 -08004253 $stat =~ /^\+(?:.*?)\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*$FuncArg\s*\)/s) {
Andy Whitcroft554e1652012-01-10 15:09:57 -08004254
Joe Perchesd7c76ba2012-01-10 15:09:58 -08004255 my $ms_addr = $2;
Joe Perchesd1fe9c02012-03-23 15:02:16 -07004256 my $ms_val = $7;
4257 my $ms_size = $12;
Joe Perchesd7c76ba2012-01-10 15:09:58 -08004258
Andy Whitcroft554e1652012-01-10 15:09:57 -08004259 if ($ms_size =~ /^(0x|)0$/i) {
4260 ERROR("MEMSET",
Joe Perchesd7c76ba2012-01-10 15:09:58 -08004261 "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 -08004262 } elsif ($ms_size =~ /^(0x|)1$/i) {
4263 WARN("MEMSET",
Joe Perchesd7c76ba2012-01-10 15:09:58 -08004264 "single byte memset is suspicious. Swapped 2nd/3rd argument?\n" . "$here\n$stat\n");
4265 }
4266 }
4267
Joe Perches98a9bba2014-01-23 15:54:52 -08004268# Check for memcpy(foo, bar, ETH_ALEN) that could be ether_addr_copy(foo, bar)
4269 if ($^V && $^V ge 5.10.0 &&
4270 $line =~ /^\+(?:.*?)\bmemcpy\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/s) {
4271 if (WARN("PREFER_ETHER_ADDR_COPY",
4272 "Prefer ether_addr_copy() over memcpy() if the Ethernet addresses are __aligned(2)\n" . $herecurr) &&
4273 $fix) {
4274 $fixed[$linenr - 1] =~ s/\bmemcpy\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/ether_addr_copy($2, $7)/;
4275 }
4276 }
4277
Joe Perchesd7c76ba2012-01-10 15:09:58 -08004278# typecasts on min/max could be min_t/max_t
Joe Perchesd1fe9c02012-03-23 15:02:16 -07004279 if ($^V && $^V ge 5.10.0 &&
4280 defined $stat &&
Joe Perchesd7c76ba2012-01-10 15:09:58 -08004281 $stat =~ /^\+(?:.*?)\b(min|max)\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\)/) {
Joe Perchesd1fe9c02012-03-23 15:02:16 -07004282 if (defined $2 || defined $7) {
Joe Perchesd7c76ba2012-01-10 15:09:58 -08004283 my $call = $1;
4284 my $cast1 = deparenthesize($2);
4285 my $arg1 = $3;
Joe Perchesd1fe9c02012-03-23 15:02:16 -07004286 my $cast2 = deparenthesize($7);
4287 my $arg2 = $8;
Joe Perchesd7c76ba2012-01-10 15:09:58 -08004288 my $cast;
4289
Joe Perchesd1fe9c02012-03-23 15:02:16 -07004290 if ($cast1 ne "" && $cast2 ne "" && $cast1 ne $cast2) {
Joe Perchesd7c76ba2012-01-10 15:09:58 -08004291 $cast = "$cast1 or $cast2";
4292 } elsif ($cast1 ne "") {
4293 $cast = $cast1;
4294 } else {
4295 $cast = $cast2;
4296 }
4297 WARN("MINMAX",
4298 "$call() should probably be ${call}_t($cast, $arg1, $arg2)\n" . "$here\n$stat\n");
Andy Whitcroft554e1652012-01-10 15:09:57 -08004299 }
4300 }
4301
Joe Perches4a273192012-07-30 14:41:20 -07004302# check usleep_range arguments
4303 if ($^V && $^V ge 5.10.0 &&
4304 defined $stat &&
4305 $stat =~ /^\+(?:.*?)\busleep_range\s*\(\s*($FuncArg)\s*,\s*($FuncArg)\s*\)/) {
4306 my $min = $1;
4307 my $max = $7;
4308 if ($min eq $max) {
4309 WARN("USLEEP_RANGE",
4310 "usleep_range should not use min == max args; see Documentation/timers/timers-howto.txt\n" . "$here\n$stat\n");
4311 } elsif ($min =~ /^\d+$/ && $max =~ /^\d+$/ &&
4312 $min > $max) {
4313 WARN("USLEEP_RANGE",
4314 "usleep_range args reversed, use min then max; see Documentation/timers/timers-howto.txt\n" . "$here\n$stat\n");
4315 }
4316 }
4317
Joe Perches823b7942013-11-12 15:10:15 -08004318# check for naked sscanf
4319 if ($^V && $^V ge 5.10.0 &&
4320 defined $stat &&
Joe Perches6c8bd702014-04-03 14:49:16 -07004321 $line =~ /\bsscanf\b/ &&
Joe Perches823b7942013-11-12 15:10:15 -08004322 ($stat !~ /$Ident\s*=\s*sscanf\s*$balanced_parens/ &&
4323 $stat !~ /\bsscanf\s*$balanced_parens\s*(?:$Compare)/ &&
4324 $stat !~ /(?:$Compare)\s*\bsscanf\s*$balanced_parens/)) {
4325 my $lc = $stat =~ tr@\n@@;
4326 $lc = $lc + $linenr;
4327 my $stat_real = raw_line($linenr, 0);
4328 for (my $count = $linenr + 1; $count <= $lc; $count++) {
4329 $stat_real = $stat_real . "\n" . raw_line($count, 0);
4330 }
4331 WARN("NAKED_SSCANF",
4332 "unchecked sscanf return value\n" . "$here\n$stat_real\n");
4333 }
4334
Joe Perchesafc819a2014-06-04 16:12:08 -07004335# check for simple sscanf that should be kstrto<foo>
4336 if ($^V && $^V ge 5.10.0 &&
4337 defined $stat &&
4338 $line =~ /\bsscanf\b/) {
4339 my $lc = $stat =~ tr@\n@@;
4340 $lc = $lc + $linenr;
4341 my $stat_real = raw_line($linenr, 0);
4342 for (my $count = $linenr + 1; $count <= $lc; $count++) {
4343 $stat_real = $stat_real . "\n" . raw_line($count, 0);
4344 }
4345 if ($stat_real =~ /\bsscanf\b\s*\(\s*$FuncArg\s*,\s*("[^"]+")/) {
4346 my $format = $6;
4347 my $count = $format =~ tr@%@%@;
4348 if ($count == 1 &&
4349 $format =~ /^"\%(?i:ll[udxi]|[udxi]ll|ll|[hl]h?[udxi]|[udxi][hl]h?|[hl]h?|[udxi])"$/) {
4350 WARN("SSCANF_TO_KSTRTO",
4351 "Prefer kstrto<type> to single variable sscanf\n" . "$here\n$stat_real\n");
4352 }
4353 }
4354 }
4355
Joe Perches70dc8a42013-09-11 14:23:58 -07004356# check for new externs in .h files.
4357 if ($realfile =~ /\.h$/ &&
4358 $line =~ /^\+\s*(extern\s+)$Type\s*$Ident\s*\(/s) {
Joe Perchesd1d85782013-09-24 15:27:46 -07004359 if (CHK("AVOID_EXTERNS",
4360 "extern prototypes should be avoided in .h files\n" . $herecurr) &&
Joe Perches70dc8a42013-09-11 14:23:58 -07004361 $fix) {
4362 $fixed[$linenr - 1] =~ s/(.*)\bextern\b\s*(.*)/$1$2/;
4363 }
4364 }
4365
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07004366# check for new externs in .c files.
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07004367 if ($realfile =~ /\.c$/ && defined $stat &&
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004368 $stat =~ /^.\s*(?:extern\s+)?$Type\s+($Ident)(\s*)\(/s)
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07004369 {
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004370 my $function_name = $1;
4371 my $paren_space = $2;
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07004372
4373 my $s = $stat;
4374 if (defined $cond) {
4375 substr($s, 0, length($cond), '');
4376 }
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004377 if ($s =~ /^\s*;/ &&
4378 $function_name ne 'uninitialized_var')
4379 {
Joe Perches000d1cc12011-07-25 17:13:25 -07004380 WARN("AVOID_EXTERNS",
4381 "externs should be avoided in .c files\n" . $herecurr);
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07004382 }
4383
4384 if ($paren_space =~ /\n/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07004385 WARN("FUNCTION_ARGUMENTS",
4386 "arguments for function declarations should follow identifier\n" . $herecurr);
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07004387 }
Andy Whitcroft9c9ba342008-04-29 00:59:33 -07004388
4389 } elsif ($realfile =~ /\.c$/ && defined $stat &&
4390 $stat =~ /^.\s*extern\s+/)
4391 {
Joe Perches000d1cc12011-07-25 17:13:25 -07004392 WARN("AVOID_EXTERNS",
4393 "externs should be avoided in .c files\n" . $herecurr);
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07004394 }
4395
4396# checks for new __setup's
4397 if ($rawline =~ /\b__setup\("([^"]*)"/) {
4398 my $name = $1;
4399
4400 if (!grep(/$name/, @setup_docs)) {
Joe Perches000d1cc12011-07-25 17:13:25 -07004401 CHK("UNDOCUMENTED_SETUP",
4402 "__setup appears un-documented -- check Documentation/kernel-parameters.txt\n" . $herecurr);
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07004403 }
Andy Whitcroft653d4872007-06-23 17:16:34 -07004404 }
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07004405
4406# check for pointless casting of kmalloc return
Joe Perchescaf2a542011-01-12 16:59:56 -08004407 if ($line =~ /\*\s*\)\s*[kv][czm]alloc(_node){0,1}\b/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07004408 WARN("UNNECESSARY_CASTS",
4409 "unnecessary cast may hide bugs, see http://c-faq.com/malloc/mallocnocast.html\n" . $herecurr);
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07004410 }
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004411
Joe Perchesa640d252013-07-03 15:05:21 -07004412# alloc style
4413# p = alloc(sizeof(struct foo), ...) should be p = alloc(sizeof(*p), ...)
4414 if ($^V && $^V ge 5.10.0 &&
4415 $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*([kv][mz]alloc(?:_node)?)\s*\(\s*(sizeof\s*\(\s*struct\s+$Lval\s*\))/) {
4416 CHK("ALLOC_SIZEOF_STRUCT",
4417 "Prefer $3(sizeof(*$1)...) over $3($4...)\n" . $herecurr);
4418 }
4419
Joe Perches60a55362014-06-04 16:12:07 -07004420# check for k[mz]alloc with multiplies that could be kmalloc_array/kcalloc
4421 if ($^V && $^V ge 5.10.0 &&
4422 $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*(k[mz]alloc)\s*\(\s*($FuncArg)\s*\*\s*($FuncArg)/) {
4423 my $oldfunc = $3;
4424 my $a1 = $4;
4425 my $a2 = $10;
4426 my $newfunc = "kmalloc_array";
4427 $newfunc = "kcalloc" if ($oldfunc eq "kzalloc");
4428 if ($a1 =~ /^sizeof\s*\S/ || $a2 =~ /^sizeof\s*\S/) {
4429 if (WARN("ALLOC_WITH_MULTIPLY",
4430 "Prefer $newfunc over $oldfunc with multiply\n" . $herecurr) &&
4431 $fix) {
4432 my $r1 = $a1;
4433 my $r2 = $a2;
4434 if ($a1 =~ /^sizeof\s*\S/) {
4435 $r1 = $a2;
4436 $r2 = $a1;
4437 }
4438 $fixed[$linenr - 1] =~ s/\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*(k[mz]alloc)\s*\(\s*($FuncArg)\s*\*\s*($FuncArg)/$1 . ' = ' . "$newfunc(" . trim($r1) . ', ' . trim($r2)/e;
4439
4440 }
4441 }
4442 }
4443
Joe Perches972fdea2013-04-29 16:18:12 -07004444# check for krealloc arg reuse
4445 if ($^V && $^V ge 5.10.0 &&
4446 $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*krealloc\s*\(\s*\1\s*,/) {
4447 WARN("KREALLOC_ARG_REUSE",
4448 "Reusing the krealloc arg is almost always a bug\n" . $herecurr);
4449 }
4450
Joe Perches5ce59ae2013-02-21 16:44:18 -08004451# check for alloc argument mismatch
4452 if ($line =~ /\b(kcalloc|kmalloc_array)\s*\(\s*sizeof\b/) {
4453 WARN("ALLOC_ARRAY_ARGS",
4454 "$1 uses number as first arg, sizeof is generally wrong\n" . $herecurr);
4455 }
4456
Joe Perchescaf2a542011-01-12 16:59:56 -08004457# check for multiple semicolons
4458 if ($line =~ /;\s*;\s*$/) {
Joe Perchesd5e616f2013-09-11 14:23:54 -07004459 if (WARN("ONE_SEMICOLON",
4460 "Statements terminations use 1 semicolon\n" . $herecurr) &&
4461 $fix) {
4462 $fixed[$linenr - 1] =~ s/(\s*;\s*){2,}$/;/g;
4463 }
Joe Perchesd1e2ad02012-12-17 16:02:01 -08004464 }
4465
Joe Perchesc34c09a2014-01-23 15:54:43 -08004466# check for case / default statements not preceeded by break/fallthrough/switch
4467 if ($line =~ /^.\s*(?:case\s+(?:$Ident|$Constant)\s*|default):/) {
4468 my $has_break = 0;
4469 my $has_statement = 0;
4470 my $count = 0;
4471 my $prevline = $linenr;
4472 while ($prevline > 1 && $count < 3 && !$has_break) {
4473 $prevline--;
4474 my $rline = $rawlines[$prevline - 1];
4475 my $fline = $lines[$prevline - 1];
4476 last if ($fline =~ /^\@\@/);
4477 next if ($fline =~ /^\-/);
4478 next if ($fline =~ /^.(?:\s*(?:case\s+(?:$Ident|$Constant)[\s$;]*|default):[\s$;]*)*$/);
4479 $has_break = 1 if ($rline =~ /fall[\s_-]*(through|thru)/i);
4480 next if ($fline =~ /^.[\s$;]*$/);
4481 $has_statement = 1;
4482 $count++;
4483 $has_break = 1 if ($fline =~ /\bswitch\b|\b(?:break\s*;[\s$;]*$|return\b|goto\b|continue\b)/);
4484 }
4485 if (!$has_break && $has_statement) {
4486 WARN("MISSING_BREAK",
4487 "Possible switch case/default not preceeded by break or fallthrough comment\n" . $herecurr);
4488 }
4489 }
4490
Joe Perchesd1e2ad02012-12-17 16:02:01 -08004491# check for switch/default statements without a break;
4492 if ($^V && $^V ge 5.10.0 &&
4493 defined $stat &&
4494 $stat =~ /^\+[$;\s]*(?:case[$;\s]+\w+[$;\s]*:[$;\s]*|)*[$;\s]*\bdefault[$;\s]*:[$;\s]*;/g) {
4495 my $ctx = '';
4496 my $herectx = $here . "\n";
4497 my $cnt = statement_rawlines($stat);
4498 for (my $n = 0; $n < $cnt; $n++) {
4499 $herectx .= raw_line($linenr, $n) . "\n";
4500 }
4501 WARN("DEFAULT_NO_BREAK",
4502 "switch default: should use break\n" . $herectx);
Joe Perchescaf2a542011-01-12 16:59:56 -08004503 }
4504
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004505# check for gcc specific __FUNCTION__
Joe Perchesd5e616f2013-09-11 14:23:54 -07004506 if ($line =~ /\b__FUNCTION__\b/) {
4507 if (WARN("USE_FUNC",
4508 "__func__ should be used instead of gcc specific __FUNCTION__\n" . $herecurr) &&
4509 $fix) {
4510 $fixed[$linenr - 1] =~ s/\b__FUNCTION__\b/__func__/g;
4511 }
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004512 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07004513
Joe Perches2c924882012-03-23 15:02:20 -07004514# check for use of yield()
4515 if ($line =~ /\byield\s*\(\s*\)/) {
4516 WARN("YIELD",
4517 "Using yield() is generally wrong. See yield() kernel-doc (sched/core.c)\n" . $herecurr);
4518 }
4519
Joe Perches179f8f42013-07-03 15:05:30 -07004520# check for comparisons against true and false
4521 if ($line =~ /\+\s*(.*?)\b(true|false|$Lval)\s*(==|\!=)\s*(true|false|$Lval)\b(.*)$/i) {
4522 my $lead = $1;
4523 my $arg = $2;
4524 my $test = $3;
4525 my $otype = $4;
4526 my $trail = $5;
4527 my $op = "!";
4528
4529 ($arg, $otype) = ($otype, $arg) if ($arg =~ /^(?:true|false)$/i);
4530
4531 my $type = lc($otype);
4532 if ($type =~ /^(?:true|false)$/) {
4533 if (("$test" eq "==" && "$type" eq "true") ||
4534 ("$test" eq "!=" && "$type" eq "false")) {
4535 $op = "";
4536 }
4537
4538 CHK("BOOL_COMPARISON",
4539 "Using comparison to $otype is error prone\n" . $herecurr);
4540
4541## maybe suggesting a correct construct would better
4542## "Using comparison to $otype is error prone. Perhaps use '${lead}${op}${arg}${trail}'\n" . $herecurr);
4543
4544 }
4545 }
4546
Thomas Gleixner4882720b2010-09-07 14:34:01 +00004547# check for semaphores initialized locked
4548 if ($line =~ /^.\s*sema_init.+,\W?0\W?\)/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07004549 WARN("CONSIDER_COMPLETION",
4550 "consider using a completion\n" . $herecurr);
Andy Whitcroft773647a2008-03-28 14:15:58 -07004551 }
Joe Perches6712d852012-03-23 15:02:20 -07004552
Joe Perches67d0a072011-10-31 17:13:10 -07004553# recommend kstrto* over simple_strto* and strict_strto*
4554 if ($line =~ /\b((simple|strict)_(strto(l|ll|ul|ull)))\s*\(/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07004555 WARN("CONSIDER_KSTRTO",
Joe Perches67d0a072011-10-31 17:13:10 -07004556 "$1 is obsolete, use k$3 instead\n" . $herecurr);
Andy Whitcroft773647a2008-03-28 14:15:58 -07004557 }
Joe Perches6712d852012-03-23 15:02:20 -07004558
Fabian Frederickae3ccc42014-06-04 16:12:10 -07004559# check for __initcall(), use device_initcall() explicitly or more appropriate function please
Michael Ellermanf3db6632008-07-23 21:28:57 -07004560 if ($line =~ /^.\s*__initcall\s*\(/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07004561 WARN("USE_DEVICE_INITCALL",
Fabian Frederickae3ccc42014-06-04 16:12:10 -07004562 "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 -07004563 }
Joe Perches6712d852012-03-23 15:02:20 -07004564
Emese Revfy79404842010-03-05 13:43:53 -08004565# check for various ops structs, ensure they are const.
4566 my $struct_ops = qr{acpi_dock_ops|
4567 address_space_operations|
4568 backlight_ops|
4569 block_device_operations|
4570 dentry_operations|
4571 dev_pm_ops|
4572 dma_map_ops|
4573 extent_io_ops|
4574 file_lock_operations|
4575 file_operations|
4576 hv_ops|
4577 ide_dma_ops|
4578 intel_dvo_dev_ops|
4579 item_operations|
4580 iwl_ops|
4581 kgdb_arch|
4582 kgdb_io|
4583 kset_uevent_ops|
4584 lock_manager_operations|
4585 microcode_ops|
4586 mtrr_ops|
4587 neigh_ops|
4588 nlmsvc_binding|
4589 pci_raw_ops|
4590 pipe_buf_operations|
4591 platform_hibernation_ops|
4592 platform_suspend_ops|
4593 proto_ops|
4594 rpc_pipe_ops|
4595 seq_operations|
4596 snd_ac97_build_ops|
4597 soc_pcmcia_socket_ops|
4598 stacktrace_ops|
4599 sysfs_ops|
4600 tty_operations|
4601 usb_mon_operations|
4602 wd_ops}x;
Andy Whitcroft6903ffb2009-01-15 13:51:07 -08004603 if ($line !~ /\bconst\b/ &&
Emese Revfy79404842010-03-05 13:43:53 -08004604 $line =~ /\bstruct\s+($struct_ops)\b/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07004605 WARN("CONST_STRUCT",
4606 "struct $1 should normally be const\n" .
Andy Whitcroft6903ffb2009-01-15 13:51:07 -08004607 $herecurr);
Andy Whitcroft2b6db5c2009-01-06 14:41:29 -08004608 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07004609
4610# use of NR_CPUS is usually wrong
4611# ignore definitions of NR_CPUS and usage to define arrays as likely right
4612 if ($line =~ /\bNR_CPUS\b/ &&
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004613 $line !~ /^.\s*\s*#\s*if\b.*\bNR_CPUS\b/ &&
4614 $line !~ /^.\s*\s*#\s*define\b.*\bNR_CPUS\b/ &&
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07004615 $line !~ /^.\s*$Declare\s.*\[[^\]]*NR_CPUS[^\]]*\]/ &&
4616 $line !~ /\[[^\]]*\.\.\.[^\]]*NR_CPUS[^\]]*\]/ &&
4617 $line !~ /\[[^\]]*NR_CPUS[^\]]*\.\.\.[^\]]*\]/)
Andy Whitcroft773647a2008-03-28 14:15:58 -07004618 {
Joe Perches000d1cc12011-07-25 17:13:25 -07004619 WARN("NR_CPUS",
4620 "usage of NR_CPUS is often wrong - consider using cpu_possible(), num_possible_cpus(), for_each_possible_cpu(), etc\n" . $herecurr);
Andy Whitcroft773647a2008-03-28 14:15:58 -07004621 }
Andy Whitcroft9c9ba342008-04-29 00:59:33 -07004622
Joe Perches52ea8502013-11-12 15:10:09 -08004623# Use of __ARCH_HAS_<FOO> or ARCH_HAVE_<BAR> is wrong.
4624 if ($line =~ /\+\s*#\s*define\s+((?:__)?ARCH_(?:HAS|HAVE)\w*)\b/) {
4625 ERROR("DEFINE_ARCH_HAS",
4626 "#define of '$1' is wrong - use Kconfig variables or standard guards instead\n" . $herecurr);
4627 }
4628
Andy Whitcroft9c9ba342008-04-29 00:59:33 -07004629# check for %L{u,d,i} in strings
4630 my $string;
4631 while ($line =~ /(?:^|")([X\t]*)(?:"|$)/g) {
4632 $string = substr($rawline, $-[1], $+[1] - $-[1]);
Andy Whitcroft2a1bc5d2008-10-15 22:02:23 -07004633 $string =~ s/%%/__/g;
Andy Whitcroft9c9ba342008-04-29 00:59:33 -07004634 if ($string =~ /(?<!%)%L[udi]/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07004635 WARN("PRINTF_L",
4636 "\%Ld/%Lu are not-standard C, use %lld/%llu\n" . $herecurr);
Andy Whitcroft9c9ba342008-04-29 00:59:33 -07004637 last;
4638 }
4639 }
Andy Whitcroft691d77b2009-01-06 14:41:16 -08004640
4641# whine mightly about in_atomic
4642 if ($line =~ /\bin_atomic\s*\(/) {
4643 if ($realfile =~ m@^drivers/@) {
Joe Perches000d1cc12011-07-25 17:13:25 -07004644 ERROR("IN_ATOMIC",
4645 "do not use in_atomic in drivers\n" . $herecurr);
Andy Whitcroftf4a87732009-02-27 14:03:05 -08004646 } elsif ($realfile !~ m@^kernel/@) {
Joe Perches000d1cc12011-07-25 17:13:25 -07004647 WARN("IN_ATOMIC",
4648 "use of in_atomic() is incorrect outside core kernel code\n" . $herecurr);
Andy Whitcroft691d77b2009-01-06 14:41:16 -08004649 }
4650 }
Peter Zijlstra1704f472010-03-19 01:37:42 +01004651
4652# check for lockdep_set_novalidate_class
4653 if ($line =~ /^.\s*lockdep_set_novalidate_class\s*\(/ ||
4654 $line =~ /__lockdep_no_validate__\s*\)/ ) {
4655 if ($realfile !~ m@^kernel/lockdep@ &&
4656 $realfile !~ m@^include/linux/lockdep@ &&
4657 $realfile !~ m@^drivers/base/core@) {
Joe Perches000d1cc12011-07-25 17:13:25 -07004658 ERROR("LOCKDEP",
4659 "lockdep_no_validate class is reserved for device->mutex.\n" . $herecurr);
Peter Zijlstra1704f472010-03-19 01:37:42 +01004660 }
4661 }
Dave Jones88f88312011-01-12 16:59:59 -08004662
4663 if ($line =~ /debugfs_create_file.*S_IWUGO/ ||
4664 $line =~ /DEVICE_ATTR.*S_IWUGO/ ) {
Joe Perches000d1cc12011-07-25 17:13:25 -07004665 WARN("EXPORTED_WORLD_WRITABLE",
4666 "Exporting world writable files is usually an error. Consider more restrictive permissions.\n" . $herecurr);
Dave Jones88f88312011-01-12 16:59:59 -08004667 }
Joe Perches24358802014-04-03 14:49:13 -07004668
Joe Perches515a2352014-04-03 14:49:24 -07004669# Mode permission misuses where it seems decimal should be octal
4670# This uses a shortcut match to avoid unnecessary uses of a slow foreach loop
4671 if ($^V && $^V ge 5.10.0 &&
4672 $line =~ /$mode_perms_search/) {
4673 foreach my $entry (@mode_permission_funcs) {
4674 my $func = $entry->[0];
4675 my $arg_pos = $entry->[1];
Joe Perches24358802014-04-03 14:49:13 -07004676
Joe Perches515a2352014-04-03 14:49:24 -07004677 my $skip_args = "";
4678 if ($arg_pos > 1) {
4679 $arg_pos--;
4680 $skip_args = "(?:\\s*$FuncArg\\s*,\\s*){$arg_pos,$arg_pos}";
4681 }
4682 my $test = "\\b$func\\s*\\(${skip_args}([\\d]+)\\s*[,\\)]";
4683 if ($line =~ /$test/) {
4684 my $val = $1;
4685 $val = $6 if ($skip_args ne "");
Joe Perches24358802014-04-03 14:49:13 -07004686
Joe Perches515a2352014-04-03 14:49:24 -07004687 if ($val !~ /^0$/ &&
4688 (($val =~ /^$Int$/ && $val !~ /^$Octal$/) ||
4689 length($val) ne 4)) {
4690 ERROR("NON_OCTAL_PERMISSIONS",
4691 "Use 4 digit octal (0777) not decimal permissions\n" . $herecurr);
4692 }
Joe Perches24358802014-04-03 14:49:13 -07004693 }
4694 }
4695 }
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004696 }
4697
4698 # If we have no input at all, then there is nothing to report on
4699 # so just keep quiet.
4700 if ($#rawlines == -1) {
4701 exit(0);
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004702 }
4703
Andy Whitcroft8905a672007-11-28 16:21:06 -08004704 # In mailback mode only produce a report in the negative, for
4705 # things that appear to be patches.
4706 if ($mailback && ($clean == 1 || !$is_patch)) {
4707 exit(0);
4708 }
4709
4710 # This is not a patch, and we are are in 'no-patch' mode so
4711 # just keep quiet.
4712 if (!$chk_patch && !$is_patch) {
4713 exit(0);
4714 }
4715
4716 if (!$is_patch) {
Joe Perches000d1cc12011-07-25 17:13:25 -07004717 ERROR("NOT_UNIFIED_DIFF",
4718 "Does not appear to be a unified-diff format patch\n");
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004719 }
4720 if ($is_patch && $chk_signoff && $signoff == 0) {
Joe Perches000d1cc12011-07-25 17:13:25 -07004721 ERROR("MISSING_SIGN_OFF",
4722 "Missing Signed-off-by: line(s)\n");
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004723 }
4724
Andy Whitcroft8905a672007-11-28 16:21:06 -08004725 print report_dump();
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004726 if ($summary && !($clean == 1 && $quiet == 1)) {
4727 print "$filename " if ($summary_file);
Andy Whitcroft8905a672007-11-28 16:21:06 -08004728 print "total: $cnt_error errors, $cnt_warn warnings, " .
4729 (($check)? "$cnt_chk checks, " : "") .
4730 "$cnt_lines lines checked\n";
4731 print "\n" if ($quiet == 0);
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07004732 }
Andy Whitcroft8905a672007-11-28 16:21:06 -08004733
Andy Whitcroftd2c0a232010-10-26 14:23:12 -07004734 if ($quiet == 0) {
Joe Perchesd1fe9c02012-03-23 15:02:16 -07004735
4736 if ($^V lt 5.10.0) {
4737 print("NOTE: perl $^V is not modern enough to detect all possible issues.\n");
4738 print("An upgrade to at least perl v5.10.0 is suggested.\n\n");
4739 }
4740
Andy Whitcroftd2c0a232010-10-26 14:23:12 -07004741 # If there were whitespace errors which cleanpatch can fix
4742 # then suggest that.
4743 if ($rpt_cleaners) {
4744 print "NOTE: whitespace errors detected, you may wish to use scripts/cleanpatch or\n";
4745 print " scripts/cleanfile\n\n";
Mike Frysingerb0781212011-03-22 16:34:43 -07004746 $rpt_cleaners = 0;
Andy Whitcroftd2c0a232010-10-26 14:23:12 -07004747 }
4748 }
4749
Joe Perches91bfe482013-09-11 14:23:59 -07004750 hash_show_words(\%use_type, "Used");
4751 hash_show_words(\%ignore_type, "Ignored");
Joe Perches000d1cc12011-07-25 17:13:25 -07004752
Joe Perches3705ce52013-07-03 15:05:31 -07004753 if ($clean == 0 && $fix && "@rawlines" ne "@fixed") {
Joe Perches9624b8d2014-01-23 15:54:44 -08004754 my $newfile = $filename;
4755 $newfile .= ".EXPERIMENTAL-checkpatch-fixes" if (!$fix_inplace);
Joe Perches3705ce52013-07-03 15:05:31 -07004756 my $linecount = 0;
4757 my $f;
4758
4759 open($f, '>', $newfile)
4760 or die "$P: Can't open $newfile for write\n";
4761 foreach my $fixed_line (@fixed) {
4762 $linecount++;
4763 if ($file) {
4764 if ($linecount > 3) {
4765 $fixed_line =~ s/^\+//;
4766 print $f $fixed_line. "\n";
4767 }
4768 } else {
4769 print $f $fixed_line . "\n";
4770 }
4771 }
4772 close($f);
4773
4774 if (!$quiet) {
4775 print << "EOM";
4776Wrote EXPERIMENTAL --fix correction(s) to '$newfile'
4777
4778Do _NOT_ trust the results written to this file.
4779Do _NOT_ submit these changes without inspecting them for correctness.
4780
4781This EXPERIMENTAL file is simply a convenience to help rewrite patches.
4782No warranties, expressed or implied...
4783
4784EOM
4785 }
4786 }
4787
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004788 if ($clean == 1 && $quiet == 0) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08004789 print "$vname has no obvious style problems and is ready for submission.\n"
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004790 }
4791 if ($clean == 0 && $quiet == 0) {
Joe Perches000d1cc12011-07-25 17:13:25 -07004792 print << "EOM";
4793$vname has style problems, please review.
4794
4795If any of these errors are false positives, please report
4796them to the maintainer, see CHECKPATCH in MAINTAINERS.
4797EOM
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004798 }
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004799
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004800 return $clean;
4801}