blob: 0147c91fa549e6ab46b68c47b46425b272c37571 [file] [log] [blame]
Andy Whitcroft0a920b52007-06-01 00:46:48 -07001#!/usr/bin/perl -w
Dave Jonesdbf004d2010-01-12 16:59:52 -05002# (c) 2001, Dave Jones. (the file handling bit)
Andy Whitcroft00df3442007-06-08 13:47:06 -07003# (c) 2005, Joel Schopp <jschopp@austin.ibm.com> (the ugly bit)
Andy Whitcroft2a5a2c22009-01-06 14:41:23 -08004# (c) 2007,2008, Andy Whitcroft <apw@uk.ibm.com> (new conditions, test suite)
Andy Whitcroft015830b2010-10-26 14:23:17 -07005# (c) 2008-2010 Andy Whitcroft <apw@canonical.com>
Andy Whitcroft0a920b52007-06-01 00:46:48 -07006# Licensed under the terms of the GNU GPL License version 2
7
8use strict;
Joe Perchesc707a812013-07-08 16:00:43 -07009use POSIX;
Joe Perches36061e32014-12-10 15:51:43 -080010use File::Basename;
11use Cwd 'abs_path';
Joe Perches57230292015-06-25 15:03:03 -070012use Term::ANSIColor qw(:constants);
Andy Whitcroft0a920b52007-06-01 00:46:48 -070013
14my $P = $0;
Joe Perches36061e32014-12-10 15:51:43 -080015my $D = dirname(abs_path($P));
Andy Whitcroft0a920b52007-06-01 00:46:48 -070016
Joe Perches000d1cc12011-07-25 17:13:25 -070017my $V = '0.32';
Andy Whitcroft0a920b52007-06-01 00:46:48 -070018
19use Getopt::Long qw(:config no_auto_abbrev);
20
21my $quiet = 0;
22my $tree = 1;
23my $chk_signoff = 1;
24my $chk_patch = 1;
Andy Whitcroft773647a2008-03-28 14:15:58 -070025my $tst_only;
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -070026my $emacs = 0;
Andy Whitcroft8905a672007-11-28 16:21:06 -080027my $terse = 0;
Joe Perches34d88152015-06-25 15:03:05 -070028my $showfile = 0;
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -070029my $file = 0;
30my $check = 0;
Joe Perches2ac73b42014-06-04 16:12:05 -070031my $check_orig = 0;
Andy Whitcroft8905a672007-11-28 16:21:06 -080032my $summary = 1;
33my $mailback = 0;
Andy Whitcroft13214ad2008-02-08 04:22:03 -080034my $summary_file = 0;
Joe Perches000d1cc12011-07-25 17:13:25 -070035my $show_types = 0;
Joe Perches3705ce52013-07-03 15:05:31 -070036my $fix = 0;
Joe Perches9624b8d2014-01-23 15:54:44 -080037my $fix_inplace = 0;
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -070038my $root;
Andy Whitcroftc2fdda02008-02-08 04:20:54 -080039my %debug;
Joe Perches34456862013-07-03 15:05:34 -070040my %camelcase = ();
Joe Perches91bfe482013-09-11 14:23:59 -070041my %use_type = ();
42my @use = ();
43my %ignore_type = ();
Joe Perches000d1cc12011-07-25 17:13:25 -070044my @ignore = ();
Hannes Eder77f5b102009-09-21 17:04:37 -070045my $help = 0;
Joe Perches000d1cc12011-07-25 17:13:25 -070046my $configuration_file = ".checkpatch.conf";
Joe Perches6cd7f382012-12-17 16:01:54 -080047my $max_line_length = 80;
Dave Hansend62a2012013-09-11 14:23:56 -070048my $ignore_perl_version = 0;
49my $minimum_perl_version = 5.10.0;
Vadim Bendebury56193272014-10-13 15:51:48 -070050my $min_conf_desc_length = 4;
Kees Cook66b47b42014-10-13 15:51:57 -070051my $spelling_file = "$D/spelling.txt";
Joe Perchesebfd7d62015-04-16 12:44:14 -070052my $codespell = 0;
Maxim Uvarovf1a63672015-06-25 15:03:08 -070053my $codespellfile = "/usr/share/codespell/dictionary.txt";
Joe Perches57230292015-06-25 15:03:03 -070054my $color = 1;
Hannes Eder77f5b102009-09-21 17:04:37 -070055
56sub help {
57 my ($exitcode) = @_;
58
59 print << "EOM";
60Usage: $P [OPTION]... [FILE]...
61Version: $V
62
63Options:
64 -q, --quiet quiet
65 --no-tree run without a kernel tree
66 --no-signoff do not check for 'Signed-off-by' line
67 --patch treat FILE as patchfile (default)
68 --emacs emacs compile window format
69 --terse one line per report
Joe Perches34d88152015-06-25 15:03:05 -070070 --showfile emit diffed file position, not input file position
Hannes Eder77f5b102009-09-21 17:04:37 -070071 -f, --file treat FILE as regular source file
72 --subjective, --strict enable more subjective tests
Joe Perches91bfe482013-09-11 14:23:59 -070073 --types TYPE(,TYPE2...) show only these comma separated message types
Joe Perches000d1cc12011-07-25 17:13:25 -070074 --ignore TYPE(,TYPE2...) ignore various comma separated message types
Joe Perches6cd7f382012-12-17 16:01:54 -080075 --max-line-length=n set the maximum line length, if exceeded, warn
Vadim Bendebury56193272014-10-13 15:51:48 -070076 --min-conf-desc-length=n set the min description length, if shorter, warn
Joe Perches000d1cc12011-07-25 17:13:25 -070077 --show-types show the message "types" in the output
Hannes Eder77f5b102009-09-21 17:04:37 -070078 --root=PATH PATH to the kernel tree root
79 --no-summary suppress the per-file summary
80 --mailback only produce a report in case of warnings/errors
81 --summary-file include the filename in summary
82 --debug KEY=[0|1] turn on/off debugging of KEY, where KEY is one of
83 'values', 'possible', 'type', and 'attr' (default
84 is all off)
85 --test-only=WORD report only warnings/errors containing WORD
86 literally
Joe Perches3705ce52013-07-03 15:05:31 -070087 --fix EXPERIMENTAL - may create horrible results
88 If correctable single-line errors exist, create
89 "<inputfile>.EXPERIMENTAL-checkpatch-fixes"
90 with potential errors corrected to the preferred
91 checkpatch style
Joe Perches9624b8d2014-01-23 15:54:44 -080092 --fix-inplace EXPERIMENTAL - may create horrible results
93 Is the same as --fix, but overwrites the input
94 file. It's your fault if there's no backup or git
Dave Hansend62a2012013-09-11 14:23:56 -070095 --ignore-perl-version override checking of perl version. expect
96 runtime errors.
Joe Perchesebfd7d62015-04-16 12:44:14 -070097 --codespell Use the codespell dictionary for spelling/typos
Maxim Uvarovf1a63672015-06-25 15:03:08 -070098 (default:/usr/share/codespell/dictionary.txt)
Joe Perchesebfd7d62015-04-16 12:44:14 -070099 --codespellfile Use this codespell dictionary
Joe Perches57230292015-06-25 15:03:03 -0700100 --color Use colors when output is STDOUT (default: on)
Hannes Eder77f5b102009-09-21 17:04:37 -0700101 -h, --help, --version display this help and exit
102
103When FILE is - read standard input.
104EOM
105
106 exit($exitcode);
107}
108
Joe Perches000d1cc12011-07-25 17:13:25 -0700109my $conf = which_conf($configuration_file);
110if (-f $conf) {
111 my @conf_args;
112 open(my $conffile, '<', "$conf")
113 or warn "$P: Can't find a readable $configuration_file file $!\n";
114
115 while (<$conffile>) {
116 my $line = $_;
117
118 $line =~ s/\s*\n?$//g;
119 $line =~ s/^\s*//g;
120 $line =~ s/\s+/ /g;
121
122 next if ($line =~ m/^\s*#/);
123 next if ($line =~ m/^\s*$/);
124
125 my @words = split(" ", $line);
126 foreach my $word (@words) {
127 last if ($word =~ m/^#/);
128 push (@conf_args, $word);
129 }
130 }
131 close($conffile);
132 unshift(@ARGV, @conf_args) if @conf_args;
133}
134
Andy Whitcroft0a920b52007-06-01 00:46:48 -0700135GetOptions(
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700136 'q|quiet+' => \$quiet,
Andy Whitcroft0a920b52007-06-01 00:46:48 -0700137 'tree!' => \$tree,
138 'signoff!' => \$chk_signoff,
139 'patch!' => \$chk_patch,
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700140 'emacs!' => \$emacs,
Andy Whitcroft8905a672007-11-28 16:21:06 -0800141 'terse!' => \$terse,
Joe Perches34d88152015-06-25 15:03:05 -0700142 'showfile!' => \$showfile,
Hannes Eder77f5b102009-09-21 17:04:37 -0700143 'f|file!' => \$file,
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700144 'subjective!' => \$check,
145 'strict!' => \$check,
Joe Perches000d1cc12011-07-25 17:13:25 -0700146 'ignore=s' => \@ignore,
Joe Perches91bfe482013-09-11 14:23:59 -0700147 'types=s' => \@use,
Joe Perches000d1cc12011-07-25 17:13:25 -0700148 'show-types!' => \$show_types,
Joe Perches6cd7f382012-12-17 16:01:54 -0800149 'max-line-length=i' => \$max_line_length,
Vadim Bendebury56193272014-10-13 15:51:48 -0700150 'min-conf-desc-length=i' => \$min_conf_desc_length,
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700151 'root=s' => \$root,
Andy Whitcroft8905a672007-11-28 16:21:06 -0800152 'summary!' => \$summary,
153 'mailback!' => \$mailback,
Andy Whitcroft13214ad2008-02-08 04:22:03 -0800154 'summary-file!' => \$summary_file,
Joe Perches3705ce52013-07-03 15:05:31 -0700155 'fix!' => \$fix,
Joe Perches9624b8d2014-01-23 15:54:44 -0800156 'fix-inplace!' => \$fix_inplace,
Dave Hansend62a2012013-09-11 14:23:56 -0700157 'ignore-perl-version!' => \$ignore_perl_version,
Andy Whitcroftc2fdda02008-02-08 04:20:54 -0800158 'debug=s' => \%debug,
Andy Whitcroft773647a2008-03-28 14:15:58 -0700159 'test-only=s' => \$tst_only,
Joe Perchesebfd7d62015-04-16 12:44:14 -0700160 'codespell!' => \$codespell,
161 'codespellfile=s' => \$codespellfile,
Joe Perches57230292015-06-25 15:03:03 -0700162 'color!' => \$color,
Hannes Eder77f5b102009-09-21 17:04:37 -0700163 'h|help' => \$help,
164 'version' => \$help
165) or help(1);
166
167help(0) if ($help);
Andy Whitcroft0a920b52007-06-01 00:46:48 -0700168
Joe Perches9624b8d2014-01-23 15:54:44 -0800169$fix = 1 if ($fix_inplace);
Joe Perches2ac73b42014-06-04 16:12:05 -0700170$check_orig = $check;
Joe Perches9624b8d2014-01-23 15:54:44 -0800171
Andy Whitcroft0a920b52007-06-01 00:46:48 -0700172my $exit = 0;
173
Dave Hansend62a2012013-09-11 14:23:56 -0700174if ($^V && $^V lt $minimum_perl_version) {
175 printf "$P: requires at least perl version %vd\n", $minimum_perl_version;
176 if (!$ignore_perl_version) {
177 exit(1);
178 }
179}
180
Andy Whitcroft0a920b52007-06-01 00:46:48 -0700181if ($#ARGV < 0) {
Hannes Eder77f5b102009-09-21 17:04:37 -0700182 print "$P: no input files\n";
Andy Whitcroft0a920b52007-06-01 00:46:48 -0700183 exit(1);
184}
185
Joe Perches91bfe482013-09-11 14:23:59 -0700186sub hash_save_array_words {
187 my ($hashRef, $arrayRef) = @_;
Joe Perches000d1cc12011-07-25 17:13:25 -0700188
Joe Perches91bfe482013-09-11 14:23:59 -0700189 my @array = split(/,/, join(',', @$arrayRef));
190 foreach my $word (@array) {
191 $word =~ s/\s*\n?$//g;
192 $word =~ s/^\s*//g;
193 $word =~ s/\s+/ /g;
194 $word =~ tr/[a-z]/[A-Z]/;
Joe Perches000d1cc12011-07-25 17:13:25 -0700195
Joe Perches91bfe482013-09-11 14:23:59 -0700196 next if ($word =~ m/^\s*#/);
197 next if ($word =~ m/^\s*$/);
198
199 $hashRef->{$word}++;
200 }
Joe Perches000d1cc12011-07-25 17:13:25 -0700201}
202
Joe Perches91bfe482013-09-11 14:23:59 -0700203sub hash_show_words {
204 my ($hashRef, $prefix) = @_;
205
Joe Perches3c816e42015-06-25 15:03:29 -0700206 if (keys %$hashRef) {
Joe Perchesd8469f12015-06-25 15:03:00 -0700207 print "\nNOTE: $prefix message types:";
Joe Perches58cb3cf2013-09-11 14:24:04 -0700208 foreach my $word (sort keys %$hashRef) {
Joe Perches91bfe482013-09-11 14:23:59 -0700209 print " $word";
210 }
Joe Perchesd8469f12015-06-25 15:03:00 -0700211 print "\n";
Joe Perches91bfe482013-09-11 14:23:59 -0700212 }
213}
214
215hash_save_array_words(\%ignore_type, \@ignore);
216hash_save_array_words(\%use_type, \@use);
217
Andy Whitcroftc2fdda02008-02-08 04:20:54 -0800218my $dbg_values = 0;
219my $dbg_possible = 0;
Andy Whitcroft7429c692008-07-23 21:29:06 -0700220my $dbg_type = 0;
Andy Whitcrofta1ef2772008-10-15 22:02:17 -0700221my $dbg_attr = 0;
Andy Whitcroftc2fdda02008-02-08 04:20:54 -0800222for my $key (keys %debug) {
Andy Whitcroft21caa132009-01-06 14:41:30 -0800223 ## no critic
224 eval "\${dbg_$key} = '$debug{$key}';";
225 die "$@" if ($@);
Andy Whitcroftc2fdda02008-02-08 04:20:54 -0800226}
227
Andy Whitcroftd2c0a232010-10-26 14:23:12 -0700228my $rpt_cleaners = 0;
229
Andy Whitcroft8905a672007-11-28 16:21:06 -0800230if ($terse) {
231 $emacs = 1;
232 $quiet++;
233}
234
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700235if ($tree) {
236 if (defined $root) {
237 if (!top_of_kernel_tree($root)) {
238 die "$P: $root: --root does not point at a valid tree\n";
239 }
240 } else {
241 if (top_of_kernel_tree('.')) {
242 $root = '.';
243 } elsif ($0 =~ m@(.*)/scripts/[^/]*$@ &&
244 top_of_kernel_tree($1)) {
245 $root = $1;
246 }
247 }
248
249 if (!defined $root) {
250 print "Must be run from the top-level dir. of a kernel tree\n";
251 exit(2);
252 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -0700253}
254
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700255my $emitted_corrupt = 0;
256
Andy Whitcroft2ceb5322009-10-26 16:50:14 -0700257our $Ident = qr{
258 [A-Za-z_][A-Za-z\d_]*
259 (?:\s*\#\#\s*[A-Za-z_][A-Za-z\d_]*)*
260 }x;
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700261our $Storage = qr{extern|static|asmlinkage};
262our $Sparse = qr{
263 __user|
264 __kernel|
265 __force|
266 __iomem|
Joe Perches54507b52015-09-09 15:37:55 -0700267 __pmem|
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700268 __must_check|
269 __init_refok|
Andy Whitcroft417495e2009-02-27 14:03:08 -0800270 __kprobes|
Sven Eckelmann165e72a2011-07-25 17:13:23 -0700271 __ref|
272 __rcu
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700273 }x;
Joe Perchese970b8842013-11-12 15:10:10 -0800274our $InitAttributePrefix = qr{__(?:mem|cpu|dev|net_|)};
275our $InitAttributeData = qr{$InitAttributePrefix(?:initdata\b)};
276our $InitAttributeConst = qr{$InitAttributePrefix(?:initconst\b)};
277our $InitAttributeInit = qr{$InitAttributePrefix(?:init\b)};
278our $InitAttribute = qr{$InitAttributeData|$InitAttributeConst|$InitAttributeInit};
Joe Perches8716de32013-09-11 14:24:05 -0700279
Wolfram Sang52131292010-03-05 13:43:51 -0800280# Notes to $Attribute:
281# We need \b after 'init' otherwise 'initconst' will cause a false positive in a check
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700282our $Attribute = qr{
283 const|
Joe Perches03f1df72010-10-26 14:23:16 -0700284 __percpu|
285 __nocast|
286 __safe|
287 __bitwise__|
288 __packed__|
289 __packed2__|
290 __naked|
291 __maybe_unused|
292 __always_unused|
293 __noreturn|
294 __used|
295 __cold|
Joe Perchese23ef1f2015-02-13 14:38:24 -0800296 __pure|
Joe Perches03f1df72010-10-26 14:23:16 -0700297 __noclone|
298 __deprecated|
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700299 __read_mostly|
300 __kprobes|
Joe Perches8716de32013-09-11 14:24:05 -0700301 $InitAttribute|
Andy Whitcroft24e1d812008-10-15 22:02:18 -0700302 ____cacheline_aligned|
303 ____cacheline_aligned_in_smp|
Andy Whitcroft5fe3af12009-01-06 14:41:18 -0800304 ____cacheline_internodealigned_in_smp|
305 __weak
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700306 }x;
Andy Whitcroftc45dcab2008-06-05 22:46:01 -0700307our $Modifier;
Joe Perches91cb5192014-04-03 14:49:32 -0700308our $Inline = qr{inline|__always_inline|noinline|__inline|__inline__};
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700309our $Member = qr{->$Ident|\.$Ident|\[[^]]*\]};
310our $Lval = qr{$Ident(?:$Member)*};
311
Joe Perches95e2c602013-07-03 15:05:20 -0700312our $Int_type = qr{(?i)llu|ull|ll|lu|ul|l|u};
313our $Binary = qr{(?i)0b[01]+$Int_type?};
314our $Hex = qr{(?i)0x[0-9a-f]+$Int_type?};
315our $Int = qr{[0-9]+$Int_type?};
Joe Perches24358802014-04-03 14:49:13 -0700316our $Octal = qr{0[0-7]+$Int_type?};
Joe Perchesc0a5c892015-02-13 14:38:21 -0800317our $String = qr{"[X\t]*"};
Joe Perches326b1ff2013-02-04 14:28:51 -0800318our $Float_hex = qr{(?i)0x[0-9a-f]+p-?[0-9]+[fl]?};
319our $Float_dec = qr{(?i)(?:[0-9]+\.[0-9]*|[0-9]*\.[0-9]+)(?:e-?[0-9]+)?[fl]?};
320our $Float_int = qr{(?i)[0-9]+e-?[0-9]+[fl]?};
Joe Perches74349bc2012-12-17 16:02:05 -0800321our $Float = qr{$Float_hex|$Float_dec|$Float_int};
Joe Perches24358802014-04-03 14:49:13 -0700322our $Constant = qr{$Float|$Binary|$Octal|$Hex|$Int};
Joe Perches326b1ff2013-02-04 14:28:51 -0800323our $Assignment = qr{\*\=|/=|%=|\+=|-=|<<=|>>=|&=|\^=|\|=|=};
Joe Perches447432f2014-04-03 14:49:17 -0700324our $Compare = qr{<=|>=|==|!=|<|(?<!-)>};
Joe Perches23f780c2013-07-03 15:05:31 -0700325our $Arithmetic = qr{\+|-|\*|\/|%};
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700326our $Operators = qr{
327 <=|>=|==|!=|
328 =>|->|<<|>>|<|>|!|~|
Joe Perches23f780c2013-07-03 15:05:31 -0700329 &&|\|\||,|\^|\+\+|--|&|\||$Arithmetic
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700330 }x;
331
Joe Perches91cb5192014-04-03 14:49:32 -0700332our $c90_Keywords = qr{do|for|while|if|else|return|goto|continue|switch|default|case|break}x;
333
Joe Perchesab7e23f2015-04-16 12:44:22 -0700334our $BasicType;
Andy Whitcroft8905a672007-11-28 16:21:06 -0800335our $NonptrType;
Joe Perches18130872014-08-06 16:11:22 -0700336our $NonptrTypeMisordered;
Joe Perches8716de32013-09-11 14:24:05 -0700337our $NonptrTypeWithAttr;
Andy Whitcroft8905a672007-11-28 16:21:06 -0800338our $Type;
Joe Perches18130872014-08-06 16:11:22 -0700339our $TypeMisordered;
Andy Whitcroft8905a672007-11-28 16:21:06 -0800340our $Declare;
Joe Perches18130872014-08-06 16:11:22 -0700341our $DeclareMisordered;
Andy Whitcroft8905a672007-11-28 16:21:06 -0800342
Joe Perches15662b32011-10-31 17:13:12 -0700343our $NON_ASCII_UTF8 = qr{
344 [\xC2-\xDF][\x80-\xBF] # non-overlong 2-byte
Andy Whitcroft171ae1a2008-04-29 00:59:32 -0700345 | \xE0[\xA0-\xBF][\x80-\xBF] # excluding overlongs
346 | [\xE1-\xEC\xEE\xEF][\x80-\xBF]{2} # straight 3-byte
347 | \xED[\x80-\x9F][\x80-\xBF] # excluding surrogates
348 | \xF0[\x90-\xBF][\x80-\xBF]{2} # planes 1-3
349 | [\xF1-\xF3][\x80-\xBF]{3} # planes 4-15
350 | \xF4[\x80-\x8F][\x80-\xBF]{2} # plane 16
351}x;
352
Joe Perches15662b32011-10-31 17:13:12 -0700353our $UTF8 = qr{
354 [\x09\x0A\x0D\x20-\x7E] # ASCII
355 | $NON_ASCII_UTF8
356}x;
357
Joe Perchese6176fa2015-06-25 15:02:49 -0700358our $typeC99Typedefs = qr{(?:__)?(?:[us]_?)?int_?(?:8|16|32|64)_t};
Joe Perches021158b2015-02-13 14:38:43 -0800359our $typeOtherOSTypedefs = qr{(?x:
360 u_(?:char|short|int|long) | # bsd
361 u(?:nchar|short|int|long) # sysv
362)};
Joe Perchese6176fa2015-06-25 15:02:49 -0700363our $typeKernelTypedefs = qr{(?x:
Andy Whitcroftfb9e9092009-09-21 17:04:38 -0700364 (?:__)?(?:u|s|be|le)(?:8|16|32|64)|
Andy Whitcroft8ed22ca2008-10-15 22:02:32 -0700365 atomic_t
366)};
Joe Perchese6176fa2015-06-25 15:02:49 -0700367our $typeTypedefs = qr{(?x:
368 $typeC99Typedefs\b|
369 $typeOtherOSTypedefs\b|
370 $typeKernelTypedefs\b
371)};
Andy Whitcroft8ed22ca2008-10-15 22:02:32 -0700372
Joe Perches6d32f7a2015-11-06 16:31:37 -0800373our $zero_initializer = qr{(?:(?:0[xX])?0+$Int_type?|NULL|false)\b};
374
Joe Perches691e6692010-03-05 13:43:51 -0800375our $logFunctions = qr{(?x:
Joe Perches6e60c022011-07-25 17:13:27 -0700376 printk(?:_ratelimited|_once|)|
Jacob Keller7d0b6592013-07-03 15:05:35 -0700377 (?:[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 -0700378 WARN(?:_RATELIMIT|_ONCE|)|
Joe Perchesb0531722011-05-24 17:13:40 -0700379 panic|
Joe Perches06668722013-11-12 15:10:07 -0800380 MODULE_[A-Z_]+|
381 seq_vprintf|seq_printf|seq_puts
Joe Perches691e6692010-03-05 13:43:51 -0800382)};
383
Joe Perches20112472011-07-25 17:13:23 -0700384our $signature_tags = qr{(?xi:
385 Signed-off-by:|
386 Acked-by:|
387 Tested-by:|
388 Reviewed-by:|
389 Reported-by:|
Mugunthan V N8543ae12013-04-29 16:18:17 -0700390 Suggested-by:|
Joe Perches20112472011-07-25 17:13:23 -0700391 To:|
392 Cc:
393)};
394
Joe Perches18130872014-08-06 16:11:22 -0700395our @typeListMisordered = (
396 qr{char\s+(?:un)?signed},
397 qr{int\s+(?:(?:un)?signed\s+)?short\s},
398 qr{int\s+short(?:\s+(?:un)?signed)},
399 qr{short\s+int(?:\s+(?:un)?signed)},
400 qr{(?:un)?signed\s+int\s+short},
401 qr{short\s+(?:un)?signed},
402 qr{long\s+int\s+(?:un)?signed},
403 qr{int\s+long\s+(?:un)?signed},
404 qr{long\s+(?:un)?signed\s+int},
405 qr{int\s+(?:un)?signed\s+long},
406 qr{int\s+(?:un)?signed},
407 qr{int\s+long\s+long\s+(?:un)?signed},
408 qr{long\s+long\s+int\s+(?:un)?signed},
409 qr{long\s+long\s+(?:un)?signed\s+int},
410 qr{long\s+long\s+(?:un)?signed},
411 qr{long\s+(?:un)?signed},
412);
413
Andy Whitcroft8905a672007-11-28 16:21:06 -0800414our @typeList = (
415 qr{void},
Joe Perches0c773d92014-08-06 16:11:20 -0700416 qr{(?:(?:un)?signed\s+)?char},
417 qr{(?:(?:un)?signed\s+)?short\s+int},
418 qr{(?:(?:un)?signed\s+)?short},
419 qr{(?:(?:un)?signed\s+)?int},
420 qr{(?:(?:un)?signed\s+)?long\s+int},
421 qr{(?:(?:un)?signed\s+)?long\s+long\s+int},
422 qr{(?:(?:un)?signed\s+)?long\s+long},
423 qr{(?:(?:un)?signed\s+)?long},
424 qr{(?:un)?signed},
Andy Whitcroft8905a672007-11-28 16:21:06 -0800425 qr{float},
426 qr{double},
427 qr{bool},
Andy Whitcroft8905a672007-11-28 16:21:06 -0800428 qr{struct\s+$Ident},
429 qr{union\s+$Ident},
430 qr{enum\s+$Ident},
431 qr{${Ident}_t},
432 qr{${Ident}_handler},
433 qr{${Ident}_handler_fn},
Joe Perches18130872014-08-06 16:11:22 -0700434 @typeListMisordered,
Andy Whitcroft8905a672007-11-28 16:21:06 -0800435);
Joe Perches938224b2016-01-20 14:59:15 -0800436
437our $C90_int_types = qr{(?x:
438 long\s+long\s+int\s+(?:un)?signed|
439 long\s+long\s+(?:un)?signed\s+int|
440 long\s+long\s+(?:un)?signed|
441 (?:(?:un)?signed\s+)?long\s+long\s+int|
442 (?:(?:un)?signed\s+)?long\s+long|
443 int\s+long\s+long\s+(?:un)?signed|
444 int\s+(?:(?:un)?signed\s+)?long\s+long|
445
446 long\s+int\s+(?:un)?signed|
447 long\s+(?:un)?signed\s+int|
448 long\s+(?:un)?signed|
449 (?:(?:un)?signed\s+)?long\s+int|
450 (?:(?:un)?signed\s+)?long|
451 int\s+long\s+(?:un)?signed|
452 int\s+(?:(?:un)?signed\s+)?long|
453
454 int\s+(?:un)?signed|
455 (?:(?:un)?signed\s+)?int
456)};
457
Alex Dowad485ff232015-06-25 15:02:52 -0700458our @typeListFile = ();
Joe Perches8716de32013-09-11 14:24:05 -0700459our @typeListWithAttr = (
460 @typeList,
461 qr{struct\s+$InitAttribute\s+$Ident},
462 qr{union\s+$InitAttribute\s+$Ident},
463);
464
Andy Whitcroftc45dcab2008-06-05 22:46:01 -0700465our @modifierList = (
466 qr{fastcall},
467);
Alex Dowad485ff232015-06-25 15:02:52 -0700468our @modifierListFile = ();
Andy Whitcroft8905a672007-11-28 16:21:06 -0800469
Joe Perches24358802014-04-03 14:49:13 -0700470our @mode_permission_funcs = (
471 ["module_param", 3],
472 ["module_param_(?:array|named|string)", 4],
473 ["module_param_array_named", 5],
474 ["debugfs_create_(?:file|u8|u16|u32|u64|x8|x16|x32|x64|size_t|atomic_t|bool|blob|regset32|u32_array)", 2],
475 ["proc_create(?:_data|)", 2],
476 ["(?:CLASS|DEVICE|SENSOR)_ATTR", 2],
477);
478
Joe Perches515a2352014-04-03 14:49:24 -0700479#Create a search pattern for all these functions to speed up a loop below
480our $mode_perms_search = "";
481foreach my $entry (@mode_permission_funcs) {
482 $mode_perms_search .= '|' if ($mode_perms_search ne "");
483 $mode_perms_search .= $entry->[0];
484}
485
Joe Perchesb392c642015-04-16 12:44:16 -0700486our $mode_perms_world_writable = qr{
487 S_IWUGO |
488 S_IWOTH |
489 S_IRWXUGO |
490 S_IALLUGO |
491 0[0-7][0-7][2367]
492}x;
493
Wolfram Sang7840a942010-08-09 17:20:57 -0700494our $allowed_asm_includes = qr{(?x:
495 irq|
Sergey Ryazanovcdcee682014-10-13 15:51:44 -0700496 memory|
497 time|
498 reboot
Wolfram Sang7840a942010-08-09 17:20:57 -0700499)};
500# memory.h: ARM has a custom one
501
Kees Cook66b47b42014-10-13 15:51:57 -0700502# Load common spelling mistakes and build regular expression list.
503my $misspellings;
Kees Cook66b47b42014-10-13 15:51:57 -0700504my %spelling_fix;
Kees Cook66b47b42014-10-13 15:51:57 -0700505
Joe Perches36061e32014-12-10 15:51:43 -0800506if (open(my $spelling, '<', $spelling_file)) {
Joe Perches36061e32014-12-10 15:51:43 -0800507 while (<$spelling>) {
508 my $line = $_;
Kees Cook66b47b42014-10-13 15:51:57 -0700509
Joe Perches36061e32014-12-10 15:51:43 -0800510 $line =~ s/\s*\n?$//g;
511 $line =~ s/^\s*//g;
Kees Cook66b47b42014-10-13 15:51:57 -0700512
Joe Perches36061e32014-12-10 15:51:43 -0800513 next if ($line =~ m/^\s*#/);
514 next if ($line =~ m/^\s*$/);
Kees Cook66b47b42014-10-13 15:51:57 -0700515
Joe Perches36061e32014-12-10 15:51:43 -0800516 my ($suspect, $fix) = split(/\|\|/, $line);
517
Joe Perches36061e32014-12-10 15:51:43 -0800518 $spelling_fix{$suspect} = $fix;
519 }
520 close($spelling);
Joe Perches36061e32014-12-10 15:51:43 -0800521} else {
522 warn "No typos will be found - file '$spelling_file': $!\n";
Kees Cook66b47b42014-10-13 15:51:57 -0700523}
Kees Cook66b47b42014-10-13 15:51:57 -0700524
Joe Perchesebfd7d62015-04-16 12:44:14 -0700525if ($codespell) {
526 if (open(my $spelling, '<', $codespellfile)) {
527 while (<$spelling>) {
528 my $line = $_;
529
530 $line =~ s/\s*\n?$//g;
531 $line =~ s/^\s*//g;
532
533 next if ($line =~ m/^\s*#/);
534 next if ($line =~ m/^\s*$/);
535 next if ($line =~ m/, disabled/i);
536
537 $line =~ s/,.*$//;
538
539 my ($suspect, $fix) = split(/->/, $line);
540
541 $spelling_fix{$suspect} = $fix;
542 }
543 close($spelling);
544 } else {
545 warn "No codespell typos will be found - file '$codespellfile': $!\n";
546 }
547}
548
549$misspellings = join("|", sort keys %spelling_fix) if keys %spelling_fix;
550
Andy Whitcroft8905a672007-11-28 16:21:06 -0800551sub build_types {
Alex Dowad485ff232015-06-25 15:02:52 -0700552 my $mods = "(?x: \n" . join("|\n ", (@modifierList, @modifierListFile)) . "\n)";
553 my $all = "(?x: \n" . join("|\n ", (@typeList, @typeListFile)) . "\n)";
Joe Perches18130872014-08-06 16:11:22 -0700554 my $Misordered = "(?x: \n" . join("|\n ", @typeListMisordered) . "\n)";
Joe Perches8716de32013-09-11 14:24:05 -0700555 my $allWithAttr = "(?x: \n" . join("|\n ", @typeListWithAttr) . "\n)";
Andy Whitcroftc8cb2ca2008-07-23 21:28:57 -0700556 $Modifier = qr{(?:$Attribute|$Sparse|$mods)};
Joe Perchesab7e23f2015-04-16 12:44:22 -0700557 $BasicType = qr{
Joe Perchesab7e23f2015-04-16 12:44:22 -0700558 (?:$typeTypedefs\b)|
559 (?:${all}\b)
560 }x;
Andy Whitcroft8905a672007-11-28 16:21:06 -0800561 $NonptrType = qr{
Andy Whitcroftd2172eb2008-07-23 21:29:07 -0700562 (?:$Modifier\s+|const\s+)*
Andy Whitcroftcf655042008-03-04 14:28:20 -0800563 (?:
Andy Whitcroft6b48db22012-01-10 15:10:13 -0800564 (?:typeof|__typeof__)\s*\([^\)]*\)|
Andy Whitcroft8ed22ca2008-10-15 22:02:32 -0700565 (?:$typeTypedefs\b)|
Andy Whitcroftc45dcab2008-06-05 22:46:01 -0700566 (?:${all}\b)
Andy Whitcroftcf655042008-03-04 14:28:20 -0800567 )
Andy Whitcroftc8cb2ca2008-07-23 21:28:57 -0700568 (?:\s+$Modifier|\s+const)*
Andy Whitcroft8905a672007-11-28 16:21:06 -0800569 }x;
Joe Perches18130872014-08-06 16:11:22 -0700570 $NonptrTypeMisordered = qr{
571 (?:$Modifier\s+|const\s+)*
572 (?:
573 (?:${Misordered}\b)
574 )
575 (?:\s+$Modifier|\s+const)*
576 }x;
Joe Perches8716de32013-09-11 14:24:05 -0700577 $NonptrTypeWithAttr = qr{
578 (?:$Modifier\s+|const\s+)*
579 (?:
580 (?:typeof|__typeof__)\s*\([^\)]*\)|
581 (?:$typeTypedefs\b)|
582 (?:${allWithAttr}\b)
583 )
584 (?:\s+$Modifier|\s+const)*
585 }x;
Andy Whitcroft8905a672007-11-28 16:21:06 -0800586 $Type = qr{
Andy Whitcroftc45dcab2008-06-05 22:46:01 -0700587 $NonptrType
Joe Perches1574a292014-08-06 16:10:50 -0700588 (?:(?:\s|\*|\[\])+\s*const|(?:\s|\*\s*(?:const\s*)?|\[\])+|(?:\s*\[\s*\])+)?
Andy Whitcroftc8cb2ca2008-07-23 21:28:57 -0700589 (?:\s+$Inline|\s+$Modifier)*
Andy Whitcroft8905a672007-11-28 16:21:06 -0800590 }x;
Joe Perches18130872014-08-06 16:11:22 -0700591 $TypeMisordered = qr{
592 $NonptrTypeMisordered
593 (?:(?:\s|\*|\[\])+\s*const|(?:\s|\*\s*(?:const\s*)?|\[\])+|(?:\s*\[\s*\])+)?
594 (?:\s+$Inline|\s+$Modifier)*
595 }x;
Joe Perches91cb5192014-04-03 14:49:32 -0700596 $Declare = qr{(?:$Storage\s+(?:$Inline\s+)?)?$Type};
Joe Perches18130872014-08-06 16:11:22 -0700597 $DeclareMisordered = qr{(?:$Storage\s+(?:$Inline\s+)?)?$TypeMisordered};
Andy Whitcroft8905a672007-11-28 16:21:06 -0800598}
599build_types();
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700600
Joe Perches7d2367a2011-07-25 17:13:22 -0700601our $Typecast = qr{\s*(\(\s*$NonptrType\s*\)){0,1}\s*};
Joe Perchesd1fe9c02012-03-23 15:02:16 -0700602
603# Using $balanced_parens, $LvalOrFunc, or $FuncArg
604# requires at least perl version v5.10.0
605# Any use must be runtime checked with $^V
606
607our $balanced_parens = qr/(\((?:[^\(\)]++|(?-1))*\))/;
Joe Perches24358802014-04-03 14:49:13 -0700608our $LvalOrFunc = qr{((?:[\&\*]\s*)?$Lval)\s*($balanced_parens{0,1})\s*};
Joe Perchesc0a5c892015-02-13 14:38:21 -0800609our $FuncArg = qr{$Typecast{0,1}($LvalOrFunc|$Constant|$String)};
Joe Perches7d2367a2011-07-25 17:13:22 -0700610
Joe Perchesf8422302014-08-06 16:11:31 -0700611our $declaration_macros = qr{(?x:
Joe Perches3e838b62015-09-09 15:37:33 -0700612 (?:$Storage\s+)?(?:[A-Z_][A-Z0-9]*_){0,2}(?:DEFINE|DECLARE)(?:_[A-Z0-9]+){1,6}\s*\(|
Joe Perchesf8422302014-08-06 16:11:31 -0700613 (?:$Storage\s+)?LIST_HEAD\s*\(|
614 (?:$Storage\s+)?${Type}\s+uninitialized_var\s*\(
615)};
616
Joe Perches7d2367a2011-07-25 17:13:22 -0700617sub deparenthesize {
618 my ($string) = @_;
619 return "" if (!defined($string));
Joe Perches5b9553a2014-04-03 14:49:21 -0700620
621 while ($string =~ /^\s*\(.*\)\s*$/) {
622 $string =~ s@^\s*\(\s*@@;
623 $string =~ s@\s*\)\s*$@@;
624 }
625
Joe Perches7d2367a2011-07-25 17:13:22 -0700626 $string =~ s@\s+@ @g;
Joe Perches5b9553a2014-04-03 14:49:21 -0700627
Joe Perches7d2367a2011-07-25 17:13:22 -0700628 return $string;
629}
630
Joe Perches34456862013-07-03 15:05:34 -0700631sub seed_camelcase_file {
632 my ($file) = @_;
633
634 return if (!(-f $file));
635
636 local $/;
637
638 open(my $include_file, '<', "$file")
639 or warn "$P: Can't read '$file' $!\n";
640 my $text = <$include_file>;
641 close($include_file);
642
643 my @lines = split('\n', $text);
644
645 foreach my $line (@lines) {
646 next if ($line !~ /(?:[A-Z][a-z]|[a-z][A-Z])/);
647 if ($line =~ /^[ \t]*(?:#[ \t]*define|typedef\s+$Type)\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)/) {
648 $camelcase{$1} = 1;
Joe Perches11ea5162013-11-12 15:10:08 -0800649 } elsif ($line =~ /^\s*$Declare\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)\s*[\(\[,;]/) {
650 $camelcase{$1} = 1;
651 } 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 -0700652 $camelcase{$1} = 1;
653 }
654 }
655}
656
657my $camelcase_seeded = 0;
658sub seed_camelcase_includes {
659 return if ($camelcase_seeded);
660
661 my $files;
Joe Perchesc707a812013-07-08 16:00:43 -0700662 my $camelcase_cache = "";
663 my @include_files = ();
664
665 $camelcase_seeded = 1;
Joe Perches351b2a12013-07-03 15:05:36 -0700666
Richard Genoud3645e322014-02-10 14:25:32 -0800667 if (-e ".git") {
Joe Perches351b2a12013-07-03 15:05:36 -0700668 my $git_last_include_commit = `git log --no-merges --pretty=format:"%h%n" -1 -- include`;
669 chomp $git_last_include_commit;
Joe Perchesc707a812013-07-08 16:00:43 -0700670 $camelcase_cache = ".checkpatch-camelcase.git.$git_last_include_commit";
Joe Perches34456862013-07-03 15:05:34 -0700671 } else {
Joe Perchesc707a812013-07-08 16:00:43 -0700672 my $last_mod_date = 0;
Joe Perches34456862013-07-03 15:05:34 -0700673 $files = `find $root/include -name "*.h"`;
Joe Perchesc707a812013-07-08 16:00:43 -0700674 @include_files = split('\n', $files);
675 foreach my $file (@include_files) {
676 my $date = POSIX::strftime("%Y%m%d%H%M",
677 localtime((stat $file)[9]));
678 $last_mod_date = $date if ($last_mod_date < $date);
679 }
680 $camelcase_cache = ".checkpatch-camelcase.date.$last_mod_date";
Joe Perches34456862013-07-03 15:05:34 -0700681 }
Joe Perchesc707a812013-07-08 16:00:43 -0700682
683 if ($camelcase_cache ne "" && -f $camelcase_cache) {
684 open(my $camelcase_file, '<', "$camelcase_cache")
685 or warn "$P: Can't read '$camelcase_cache' $!\n";
686 while (<$camelcase_file>) {
687 chomp;
688 $camelcase{$_} = 1;
689 }
690 close($camelcase_file);
691
692 return;
693 }
694
Richard Genoud3645e322014-02-10 14:25:32 -0800695 if (-e ".git") {
Joe Perchesc707a812013-07-08 16:00:43 -0700696 $files = `git ls-files "include/*.h"`;
697 @include_files = split('\n', $files);
698 }
699
Joe Perches34456862013-07-03 15:05:34 -0700700 foreach my $file (@include_files) {
701 seed_camelcase_file($file);
702 }
Joe Perches351b2a12013-07-03 15:05:36 -0700703
Joe Perchesc707a812013-07-08 16:00:43 -0700704 if ($camelcase_cache ne "") {
Joe Perches351b2a12013-07-03 15:05:36 -0700705 unlink glob ".checkpatch-camelcase.*";
Joe Perchesc707a812013-07-08 16:00:43 -0700706 open(my $camelcase_file, '>', "$camelcase_cache")
707 or warn "$P: Can't write '$camelcase_cache' $!\n";
Joe Perches351b2a12013-07-03 15:05:36 -0700708 foreach (sort { lc($a) cmp lc($b) } keys(%camelcase)) {
709 print $camelcase_file ("$_\n");
710 }
711 close($camelcase_file);
712 }
Joe Perches34456862013-07-03 15:05:34 -0700713}
714
Joe Perchesd311cd42014-08-06 16:10:57 -0700715sub git_commit_info {
716 my ($commit, $id, $desc) = @_;
717
718 return ($id, $desc) if ((which("git") eq "") || !(-e ".git"));
719
720 my $output = `git log --no-color --format='%H %s' -1 $commit 2>&1`;
721 $output =~ s/^\s*//gm;
722 my @lines = split("\n", $output);
723
Joe Perches0d7835f2015-02-13 14:38:35 -0800724 return ($id, $desc) if ($#lines < 0);
725
Joe Perchesd311cd42014-08-06 16:10:57 -0700726 if ($lines[0] =~ /^error: short SHA1 $commit is ambiguous\./) {
727# Maybe one day convert this block of bash into something that returns
728# all matching commit ids, but it's very slow...
729#
730# echo "checking commits $1..."
731# git rev-list --remotes | grep -i "^$1" |
732# while read line ; do
733# git log --format='%H %s' -1 $line |
734# echo "commit $(cut -c 1-12,41-)"
735# done
736 } elsif ($lines[0] =~ /^fatal: ambiguous argument '$commit': unknown revision or path not in the working tree\./) {
737 } else {
738 $id = substr($lines[0], 0, 12);
739 $desc = substr($lines[0], 41);
740 }
741
742 return ($id, $desc);
743}
744
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700745$chk_signoff = 0 if ($file);
746
Andy Whitcroft00df3442007-06-08 13:47:06 -0700747my @rawlines = ();
Andy Whitcroftc2fdda02008-02-08 04:20:54 -0800748my @lines = ();
Joe Perches3705ce52013-07-03 15:05:31 -0700749my @fixed = ();
Joe Perchesd752fcc2014-08-06 16:11:05 -0700750my @fixed_inserted = ();
751my @fixed_deleted = ();
Joe Perches194f66f2014-08-06 16:11:03 -0700752my $fixlinenr = -1;
753
Andy Whitcroftc2fdda02008-02-08 04:20:54 -0800754my $vname;
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700755for my $filename (@ARGV) {
Andy Whitcroft21caa132009-01-06 14:41:30 -0800756 my $FILE;
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700757 if ($file) {
Andy Whitcroft21caa132009-01-06 14:41:30 -0800758 open($FILE, '-|', "diff -u /dev/null $filename") ||
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700759 die "$P: $filename: diff failed - $!\n";
Andy Whitcroft21caa132009-01-06 14:41:30 -0800760 } elsif ($filename eq '-') {
761 open($FILE, '<&STDIN');
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700762 } else {
Andy Whitcroft21caa132009-01-06 14:41:30 -0800763 open($FILE, '<', "$filename") ||
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700764 die "$P: $filename: open failed - $!\n";
Andy Whitcroft0a920b52007-06-01 00:46:48 -0700765 }
Andy Whitcroftc2fdda02008-02-08 04:20:54 -0800766 if ($filename eq '-') {
767 $vname = 'Your patch';
768 } else {
769 $vname = $filename;
770 }
Andy Whitcroft21caa132009-01-06 14:41:30 -0800771 while (<$FILE>) {
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700772 chomp;
773 push(@rawlines, $_);
774 }
Andy Whitcroft21caa132009-01-06 14:41:30 -0800775 close($FILE);
Joe Perchesd8469f12015-06-25 15:03:00 -0700776
777 if ($#ARGV > 0 && $quiet == 0) {
778 print '-' x length($vname) . "\n";
779 print "$vname\n";
780 print '-' x length($vname) . "\n";
781 }
782
Andy Whitcroftc2fdda02008-02-08 04:20:54 -0800783 if (!process($filename)) {
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700784 $exit = 1;
785 }
786 @rawlines = ();
Andy Whitcroft13214ad2008-02-08 04:22:03 -0800787 @lines = ();
Joe Perches3705ce52013-07-03 15:05:31 -0700788 @fixed = ();
Joe Perchesd752fcc2014-08-06 16:11:05 -0700789 @fixed_inserted = ();
790 @fixed_deleted = ();
Joe Perches194f66f2014-08-06 16:11:03 -0700791 $fixlinenr = -1;
Alex Dowad485ff232015-06-25 15:02:52 -0700792 @modifierListFile = ();
793 @typeListFile = ();
794 build_types();
Andy Whitcroft0a920b52007-06-01 00:46:48 -0700795}
796
Joe Perchesd8469f12015-06-25 15:03:00 -0700797if (!$quiet) {
Joe Perches3c816e42015-06-25 15:03:29 -0700798 hash_show_words(\%use_type, "Used");
799 hash_show_words(\%ignore_type, "Ignored");
800
Joe Perchesd8469f12015-06-25 15:03:00 -0700801 if ($^V lt 5.10.0) {
802 print << "EOM"
803
804NOTE: perl $^V is not modern enough to detect all possible issues.
805 An upgrade to at least perl v5.10.0 is suggested.
806EOM
807 }
808 if ($exit) {
809 print << "EOM"
810
811NOTE: If any of the errors are false positives, please report
812 them to the maintainer, see CHECKPATCH in MAINTAINERS.
813EOM
814 }
815}
816
Andy Whitcroft0a920b52007-06-01 00:46:48 -0700817exit($exit);
818
819sub top_of_kernel_tree {
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700820 my ($root) = @_;
821
822 my @tree_check = (
823 "COPYING", "CREDITS", "Kbuild", "MAINTAINERS", "Makefile",
824 "README", "Documentation", "arch", "include", "drivers",
825 "fs", "init", "ipc", "kernel", "lib", "scripts",
826 );
827
828 foreach my $check (@tree_check) {
829 if (! -e $root . '/' . $check) {
830 return 0;
831 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -0700832 }
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700833 return 1;
Joe Perches8f26b832012-10-04 17:13:32 -0700834}
Andy Whitcroft0a920b52007-06-01 00:46:48 -0700835
Joe Perches20112472011-07-25 17:13:23 -0700836sub parse_email {
837 my ($formatted_email) = @_;
838
839 my $name = "";
840 my $address = "";
841 my $comment = "";
842
843 if ($formatted_email =~ /^(.*)<(\S+\@\S+)>(.*)$/) {
844 $name = $1;
845 $address = $2;
846 $comment = $3 if defined $3;
847 } elsif ($formatted_email =~ /^\s*<(\S+\@\S+)>(.*)$/) {
848 $address = $1;
849 $comment = $2 if defined $2;
850 } elsif ($formatted_email =~ /(\S+\@\S+)(.*)$/) {
851 $address = $1;
852 $comment = $2 if defined $2;
853 $formatted_email =~ s/$address.*$//;
854 $name = $formatted_email;
Joe Perches3705ce52013-07-03 15:05:31 -0700855 $name = trim($name);
Joe Perches20112472011-07-25 17:13:23 -0700856 $name =~ s/^\"|\"$//g;
857 # If there's a name left after stripping spaces and
858 # leading quotes, and the address doesn't have both
859 # leading and trailing angle brackets, the address
860 # is invalid. ie:
861 # "joe smith joe@smith.com" bad
862 # "joe smith <joe@smith.com" bad
863 if ($name ne "" && $address !~ /^<[^>]+>$/) {
864 $name = "";
865 $address = "";
866 $comment = "";
867 }
868 }
869
Joe Perches3705ce52013-07-03 15:05:31 -0700870 $name = trim($name);
Joe Perches20112472011-07-25 17:13:23 -0700871 $name =~ s/^\"|\"$//g;
Joe Perches3705ce52013-07-03 15:05:31 -0700872 $address = trim($address);
Joe Perches20112472011-07-25 17:13:23 -0700873 $address =~ s/^\<|\>$//g;
874
875 if ($name =~ /[^\w \-]/i) { ##has "must quote" chars
876 $name =~ s/(?<!\\)"/\\"/g; ##escape quotes
877 $name = "\"$name\"";
878 }
879
880 return ($name, $address, $comment);
881}
882
883sub format_email {
884 my ($name, $address) = @_;
885
886 my $formatted_email;
887
Joe Perches3705ce52013-07-03 15:05:31 -0700888 $name = trim($name);
Joe Perches20112472011-07-25 17:13:23 -0700889 $name =~ s/^\"|\"$//g;
Joe Perches3705ce52013-07-03 15:05:31 -0700890 $address = trim($address);
Joe Perches20112472011-07-25 17:13:23 -0700891
892 if ($name =~ /[^\w \-]/i) { ##has "must quote" chars
893 $name =~ s/(?<!\\)"/\\"/g; ##escape quotes
894 $name = "\"$name\"";
895 }
896
897 if ("$name" eq "") {
898 $formatted_email = "$address";
899 } else {
900 $formatted_email = "$name <$address>";
901 }
902
903 return $formatted_email;
904}
905
Joe Perchesd311cd42014-08-06 16:10:57 -0700906sub which {
Joe Perchesbd474ca2014-08-06 16:11:10 -0700907 my ($bin) = @_;
Joe Perchesd311cd42014-08-06 16:10:57 -0700908
Joe Perchesbd474ca2014-08-06 16:11:10 -0700909 foreach my $path (split(/:/, $ENV{PATH})) {
910 if (-e "$path/$bin") {
911 return "$path/$bin";
912 }
Joe Perchesd311cd42014-08-06 16:10:57 -0700913 }
Joe Perchesd311cd42014-08-06 16:10:57 -0700914
Joe Perchesbd474ca2014-08-06 16:11:10 -0700915 return "";
Joe Perchesd311cd42014-08-06 16:10:57 -0700916}
917
Joe Perches000d1cc12011-07-25 17:13:25 -0700918sub which_conf {
919 my ($conf) = @_;
920
921 foreach my $path (split(/:/, ".:$ENV{HOME}:.scripts")) {
922 if (-e "$path/$conf") {
923 return "$path/$conf";
924 }
925 }
926
927 return "";
928}
929
Andy Whitcroft0a920b52007-06-01 00:46:48 -0700930sub expand_tabs {
931 my ($str) = @_;
932
933 my $res = '';
934 my $n = 0;
935 for my $c (split(//, $str)) {
936 if ($c eq "\t") {
937 $res .= ' ';
938 $n++;
939 for (; ($n % 8) != 0; $n++) {
940 $res .= ' ';
941 }
942 next;
943 }
944 $res .= $c;
945 $n++;
946 }
947
948 return $res;
949}
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700950sub copy_spacing {
Andy Whitcroft773647a2008-03-28 14:15:58 -0700951 (my $res = shift) =~ tr/\t/ /c;
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700952 return $res;
953}
Andy Whitcroft0a920b52007-06-01 00:46:48 -0700954
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -0700955sub line_stats {
956 my ($line) = @_;
957
958 # Drop the diff line leader and expand tabs
959 $line =~ s/^.//;
960 $line = expand_tabs($line);
961
962 # Pick the indent from the front of the line.
963 my ($white) = ($line =~ /^(\s*)/);
964
965 return (length($line), length($white));
966}
967
Andy Whitcroft773647a2008-03-28 14:15:58 -0700968my $sanitise_quote = '';
969
970sub sanitise_line_reset {
971 my ($in_comment) = @_;
972
973 if ($in_comment) {
974 $sanitise_quote = '*/';
975 } else {
976 $sanitise_quote = '';
977 }
978}
Andy Whitcroft00df3442007-06-08 13:47:06 -0700979sub sanitise_line {
980 my ($line) = @_;
981
982 my $res = '';
983 my $l = '';
984
Andy Whitcroftc2fdda02008-02-08 04:20:54 -0800985 my $qlen = 0;
Andy Whitcroft773647a2008-03-28 14:15:58 -0700986 my $off = 0;
987 my $c;
Andy Whitcroft00df3442007-06-08 13:47:06 -0700988
Andy Whitcroft773647a2008-03-28 14:15:58 -0700989 # Always copy over the diff marker.
990 $res = substr($line, 0, 1);
991
992 for ($off = 1; $off < length($line); $off++) {
993 $c = substr($line, $off, 1);
994
995 # Comments we are wacking completly including the begin
996 # and end, all to $;.
997 if ($sanitise_quote eq '' && substr($line, $off, 2) eq '/*') {
998 $sanitise_quote = '*/';
999
1000 substr($res, $off, 2, "$;$;");
1001 $off++;
1002 next;
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001003 }
Andy Whitcroft81bc0e02008-10-15 22:02:26 -07001004 if ($sanitise_quote eq '*/' && substr($line, $off, 2) eq '*/') {
Andy Whitcroft773647a2008-03-28 14:15:58 -07001005 $sanitise_quote = '';
1006 substr($res, $off, 2, "$;$;");
1007 $off++;
1008 next;
1009 }
Daniel Walker113f04a2009-09-21 17:04:35 -07001010 if ($sanitise_quote eq '' && substr($line, $off, 2) eq '//') {
1011 $sanitise_quote = '//';
1012
1013 substr($res, $off, 2, $sanitise_quote);
1014 $off++;
1015 next;
1016 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07001017
1018 # A \ in a string means ignore the next character.
1019 if (($sanitise_quote eq "'" || $sanitise_quote eq '"') &&
1020 $c eq "\\") {
1021 substr($res, $off, 2, 'XX');
1022 $off++;
1023 next;
1024 }
1025 # Regular quotes.
1026 if ($c eq "'" || $c eq '"') {
1027 if ($sanitise_quote eq '') {
1028 $sanitise_quote = $c;
1029
1030 substr($res, $off, 1, $c);
Andy Whitcroft00df3442007-06-08 13:47:06 -07001031 next;
Andy Whitcroft773647a2008-03-28 14:15:58 -07001032 } elsif ($sanitise_quote eq $c) {
1033 $sanitise_quote = '';
Andy Whitcroft00df3442007-06-08 13:47:06 -07001034 }
1035 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07001036
Andy Whitcroftfae17da2009-01-06 14:41:20 -08001037 #print "c<$c> SQ<$sanitise_quote>\n";
Andy Whitcroft773647a2008-03-28 14:15:58 -07001038 if ($off != 0 && $sanitise_quote eq '*/' && $c ne "\t") {
1039 substr($res, $off, 1, $;);
Daniel Walker113f04a2009-09-21 17:04:35 -07001040 } elsif ($off != 0 && $sanitise_quote eq '//' && $c ne "\t") {
1041 substr($res, $off, 1, $;);
Andy Whitcroft773647a2008-03-28 14:15:58 -07001042 } elsif ($off != 0 && $sanitise_quote && $c ne "\t") {
1043 substr($res, $off, 1, 'X');
Andy Whitcroft00df3442007-06-08 13:47:06 -07001044 } else {
Andy Whitcroft773647a2008-03-28 14:15:58 -07001045 substr($res, $off, 1, $c);
Andy Whitcroft00df3442007-06-08 13:47:06 -07001046 }
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001047 }
1048
Daniel Walker113f04a2009-09-21 17:04:35 -07001049 if ($sanitise_quote eq '//') {
1050 $sanitise_quote = '';
1051 }
1052
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001053 # The pathname on a #include may be surrounded by '<' and '>'.
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07001054 if ($res =~ /^.\s*\#\s*include\s+\<(.*)\>/) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001055 my $clean = 'X' x length($1);
1056 $res =~ s@\<.*\>@<$clean>@;
1057
1058 # The whole of a #error is a string.
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07001059 } elsif ($res =~ /^.\s*\#\s*(?:error|warning)\s+(.*)\b/) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001060 my $clean = 'X' x length($1);
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07001061 $res =~ s@(\#\s*(?:error|warning)\s+).*@$1$clean@;
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001062 }
1063
Andy Whitcroft00df3442007-06-08 13:47:06 -07001064 return $res;
1065}
1066
Joe Perchesa6962d72013-04-29 16:18:13 -07001067sub get_quoted_string {
1068 my ($line, $rawline) = @_;
1069
Joe Perches33acb542015-06-25 15:02:54 -07001070 return "" if ($line !~ m/($String)/g);
Joe Perchesa6962d72013-04-29 16:18:13 -07001071 return substr($rawline, $-[0], $+[0] - $-[0]);
1072}
1073
Andy Whitcroft8905a672007-11-28 16:21:06 -08001074sub ctx_statement_block {
1075 my ($linenr, $remain, $off) = @_;
1076 my $line = $linenr - 1;
1077 my $blk = '';
1078 my $soff = $off;
1079 my $coff = $off - 1;
Andy Whitcroft773647a2008-03-28 14:15:58 -07001080 my $coff_set = 0;
Andy Whitcroft8905a672007-11-28 16:21:06 -08001081
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001082 my $loff = 0;
1083
Andy Whitcroft8905a672007-11-28 16:21:06 -08001084 my $type = '';
1085 my $level = 0;
Andy Whitcrofta2750642009-01-15 13:51:04 -08001086 my @stack = ();
Andy Whitcroftcf655042008-03-04 14:28:20 -08001087 my $p;
Andy Whitcroft8905a672007-11-28 16:21:06 -08001088 my $c;
1089 my $len = 0;
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001090
1091 my $remainder;
Andy Whitcroft8905a672007-11-28 16:21:06 -08001092 while (1) {
Andy Whitcrofta2750642009-01-15 13:51:04 -08001093 @stack = (['', 0]) if ($#stack == -1);
1094
Andy Whitcroft773647a2008-03-28 14:15:58 -07001095 #warn "CSB: blk<$blk> remain<$remain>\n";
Andy Whitcroft8905a672007-11-28 16:21:06 -08001096 # If we are about to drop off the end, pull in more
1097 # context.
1098 if ($off >= $len) {
1099 for (; $remain > 0; $line++) {
Andy Whitcroftdea33492008-10-15 22:02:25 -07001100 last if (!defined $lines[$line]);
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001101 next if ($lines[$line] =~ /^-/);
Andy Whitcroft8905a672007-11-28 16:21:06 -08001102 $remain--;
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001103 $loff = $len;
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001104 $blk .= $lines[$line] . "\n";
Andy Whitcroft8905a672007-11-28 16:21:06 -08001105 $len = length($blk);
1106 $line++;
1107 last;
1108 }
1109 # Bail if there is no further context.
1110 #warn "CSB: blk<$blk> off<$off> len<$len>\n";
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001111 if ($off >= $len) {
Andy Whitcroft8905a672007-11-28 16:21:06 -08001112 last;
1113 }
Andy Whitcroftf74bd192012-01-10 15:09:54 -08001114 if ($level == 0 && substr($blk, $off) =~ /^.\s*#\s*define/) {
1115 $level++;
1116 $type = '#';
1117 }
Andy Whitcroft8905a672007-11-28 16:21:06 -08001118 }
Andy Whitcroftcf655042008-03-04 14:28:20 -08001119 $p = $c;
Andy Whitcroft8905a672007-11-28 16:21:06 -08001120 $c = substr($blk, $off, 1);
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001121 $remainder = substr($blk, $off);
Andy Whitcroft8905a672007-11-28 16:21:06 -08001122
Andy Whitcroft773647a2008-03-28 14:15:58 -07001123 #warn "CSB: c<$c> type<$type> level<$level> remainder<$remainder> coff_set<$coff_set>\n";
Andy Whitcroft4635f4f2009-01-06 14:41:27 -08001124
1125 # Handle nested #if/#else.
1126 if ($remainder =~ /^#\s*(?:ifndef|ifdef|if)\s/) {
1127 push(@stack, [ $type, $level ]);
1128 } elsif ($remainder =~ /^#\s*(?:else|elif)\b/) {
1129 ($type, $level) = @{$stack[$#stack - 1]};
1130 } elsif ($remainder =~ /^#\s*endif\b/) {
1131 ($type, $level) = @{pop(@stack)};
1132 }
1133
Andy Whitcroft8905a672007-11-28 16:21:06 -08001134 # Statement ends at the ';' or a close '}' at the
1135 # outermost level.
1136 if ($level == 0 && $c eq ';') {
1137 last;
1138 }
1139
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001140 # An else is really a conditional as long as its not else if
Andy Whitcroft773647a2008-03-28 14:15:58 -07001141 if ($level == 0 && $coff_set == 0 &&
1142 (!defined($p) || $p =~ /(?:\s|\}|\+)/) &&
1143 $remainder =~ /^(else)(?:\s|{)/ &&
1144 $remainder !~ /^else\s+if\b/) {
1145 $coff = $off + length($1) - 1;
1146 $coff_set = 1;
1147 #warn "CSB: mark coff<$coff> soff<$soff> 1<$1>\n";
1148 #warn "[" . substr($blk, $soff, $coff - $soff + 1) . "]\n";
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001149 }
1150
Andy Whitcroft8905a672007-11-28 16:21:06 -08001151 if (($type eq '' || $type eq '(') && $c eq '(') {
1152 $level++;
1153 $type = '(';
1154 }
1155 if ($type eq '(' && $c eq ')') {
1156 $level--;
1157 $type = ($level != 0)? '(' : '';
1158
1159 if ($level == 0 && $coff < $soff) {
1160 $coff = $off;
Andy Whitcroft773647a2008-03-28 14:15:58 -07001161 $coff_set = 1;
1162 #warn "CSB: mark coff<$coff>\n";
Andy Whitcroft8905a672007-11-28 16:21:06 -08001163 }
1164 }
1165 if (($type eq '' || $type eq '{') && $c eq '{') {
1166 $level++;
1167 $type = '{';
1168 }
1169 if ($type eq '{' && $c eq '}') {
1170 $level--;
1171 $type = ($level != 0)? '{' : '';
1172
1173 if ($level == 0) {
Patrick Pannutob998e002010-08-09 17:21:03 -07001174 if (substr($blk, $off + 1, 1) eq ';') {
1175 $off++;
1176 }
Andy Whitcroft8905a672007-11-28 16:21:06 -08001177 last;
1178 }
1179 }
Andy Whitcroftf74bd192012-01-10 15:09:54 -08001180 # Preprocessor commands end at the newline unless escaped.
1181 if ($type eq '#' && $c eq "\n" && $p ne "\\") {
1182 $level--;
1183 $type = '';
1184 $off++;
1185 last;
1186 }
Andy Whitcroft8905a672007-11-28 16:21:06 -08001187 $off++;
1188 }
Andy Whitcrofta3bb97a2008-07-23 21:29:00 -07001189 # We are truly at the end, so shuffle to the next line.
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001190 if ($off == $len) {
Andy Whitcrofta3bb97a2008-07-23 21:29:00 -07001191 $loff = $len + 1;
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001192 $line++;
1193 $remain--;
1194 }
Andy Whitcroft8905a672007-11-28 16:21:06 -08001195
1196 my $statement = substr($blk, $soff, $off - $soff + 1);
1197 my $condition = substr($blk, $soff, $coff - $soff + 1);
1198
1199 #warn "STATEMENT<$statement>\n";
1200 #warn "CONDITION<$condition>\n";
1201
Andy Whitcroft773647a2008-03-28 14:15:58 -07001202 #print "coff<$coff> soff<$off> loff<$loff>\n";
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001203
1204 return ($statement, $condition,
1205 $line, $remain + 1, $off - $loff + 1, $level);
1206}
1207
Andy Whitcroftcf655042008-03-04 14:28:20 -08001208sub statement_lines {
1209 my ($stmt) = @_;
1210
1211 # Strip the diff line prefixes and rip blank lines at start and end.
1212 $stmt =~ s/(^|\n)./$1/g;
1213 $stmt =~ s/^\s*//;
1214 $stmt =~ s/\s*$//;
1215
1216 my @stmt_lines = ($stmt =~ /\n/g);
1217
1218 return $#stmt_lines + 2;
1219}
1220
1221sub statement_rawlines {
1222 my ($stmt) = @_;
1223
1224 my @stmt_lines = ($stmt =~ /\n/g);
1225
1226 return $#stmt_lines + 2;
1227}
1228
1229sub statement_block_size {
1230 my ($stmt) = @_;
1231
1232 $stmt =~ s/(^|\n)./$1/g;
1233 $stmt =~ s/^\s*{//;
1234 $stmt =~ s/}\s*$//;
1235 $stmt =~ s/^\s*//;
1236 $stmt =~ s/\s*$//;
1237
1238 my @stmt_lines = ($stmt =~ /\n/g);
1239 my @stmt_statements = ($stmt =~ /;/g);
1240
1241 my $stmt_lines = $#stmt_lines + 2;
1242 my $stmt_statements = $#stmt_statements + 1;
1243
1244 if ($stmt_lines > $stmt_statements) {
1245 return $stmt_lines;
1246 } else {
1247 return $stmt_statements;
1248 }
1249}
1250
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001251sub ctx_statement_full {
1252 my ($linenr, $remain, $off) = @_;
1253 my ($statement, $condition, $level);
1254
1255 my (@chunks);
1256
Andy Whitcroftcf655042008-03-04 14:28:20 -08001257 # Grab the first conditional/block pair.
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001258 ($statement, $condition, $linenr, $remain, $off, $level) =
1259 ctx_statement_block($linenr, $remain, $off);
Andy Whitcroft773647a2008-03-28 14:15:58 -07001260 #print "F: c<$condition> s<$statement> remain<$remain>\n";
Andy Whitcroftcf655042008-03-04 14:28:20 -08001261 push(@chunks, [ $condition, $statement ]);
1262 if (!($remain > 0 && $condition =~ /^\s*(?:\n[+-])?\s*(?:if|else|do)\b/s)) {
1263 return ($level, $linenr, @chunks);
1264 }
1265
1266 # Pull in the following conditional/block pairs and see if they
1267 # could continue the statement.
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001268 for (;;) {
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001269 ($statement, $condition, $linenr, $remain, $off, $level) =
1270 ctx_statement_block($linenr, $remain, $off);
Andy Whitcroftcf655042008-03-04 14:28:20 -08001271 #print "C: c<$condition> s<$statement> remain<$remain>\n";
Andy Whitcroft773647a2008-03-28 14:15:58 -07001272 last if (!($remain > 0 && $condition =~ /^(?:\s*\n[+-])*\s*(?:else|do)\b/s));
Andy Whitcroftcf655042008-03-04 14:28:20 -08001273 #print "C: push\n";
1274 push(@chunks, [ $condition, $statement ]);
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001275 }
1276
1277 return ($level, $linenr, @chunks);
Andy Whitcroft8905a672007-11-28 16:21:06 -08001278}
1279
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001280sub ctx_block_get {
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001281 my ($linenr, $remain, $outer, $open, $close, $off) = @_;
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001282 my $line;
1283 my $start = $linenr - 1;
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001284 my $blk = '';
1285 my @o;
1286 my @c;
1287 my @res = ();
1288
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001289 my $level = 0;
Andy Whitcroft4635f4f2009-01-06 14:41:27 -08001290 my @stack = ($level);
Andy Whitcroft00df3442007-06-08 13:47:06 -07001291 for ($line = $start; $remain > 0; $line++) {
1292 next if ($rawlines[$line] =~ /^-/);
1293 $remain--;
1294
1295 $blk .= $rawlines[$line];
Andy Whitcroft4635f4f2009-01-06 14:41:27 -08001296
1297 # Handle nested #if/#else.
Andy Whitcroft01464f32010-10-26 14:23:19 -07001298 if ($lines[$line] =~ /^.\s*#\s*(?:ifndef|ifdef|if)\s/) {
Andy Whitcroft4635f4f2009-01-06 14:41:27 -08001299 push(@stack, $level);
Andy Whitcroft01464f32010-10-26 14:23:19 -07001300 } elsif ($lines[$line] =~ /^.\s*#\s*(?:else|elif)\b/) {
Andy Whitcroft4635f4f2009-01-06 14:41:27 -08001301 $level = $stack[$#stack - 1];
Andy Whitcroft01464f32010-10-26 14:23:19 -07001302 } elsif ($lines[$line] =~ /^.\s*#\s*endif\b/) {
Andy Whitcroft4635f4f2009-01-06 14:41:27 -08001303 $level = pop(@stack);
1304 }
1305
Andy Whitcroft01464f32010-10-26 14:23:19 -07001306 foreach my $c (split(//, $lines[$line])) {
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001307 ##print "C<$c>L<$level><$open$close>O<$off>\n";
1308 if ($off > 0) {
1309 $off--;
1310 next;
1311 }
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001312
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001313 if ($c eq $close && $level > 0) {
1314 $level--;
1315 last if ($level == 0);
1316 } elsif ($c eq $open) {
1317 $level++;
1318 }
1319 }
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001320
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001321 if (!$outer || $level <= 1) {
Andy Whitcroft00df3442007-06-08 13:47:06 -07001322 push(@res, $rawlines[$line]);
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001323 }
1324
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001325 last if ($level == 0);
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001326 }
1327
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001328 return ($level, @res);
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001329}
1330sub ctx_block_outer {
1331 my ($linenr, $remain) = @_;
1332
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001333 my ($level, @r) = ctx_block_get($linenr, $remain, 1, '{', '}', 0);
1334 return @r;
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001335}
1336sub ctx_block {
1337 my ($linenr, $remain) = @_;
1338
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001339 my ($level, @r) = ctx_block_get($linenr, $remain, 0, '{', '}', 0);
1340 return @r;
Andy Whitcroft653d4872007-06-23 17:16:34 -07001341}
1342sub ctx_statement {
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001343 my ($linenr, $remain, $off) = @_;
1344
1345 my ($level, @r) = ctx_block_get($linenr, $remain, 0, '(', ')', $off);
1346 return @r;
1347}
1348sub ctx_block_level {
Andy Whitcroft653d4872007-06-23 17:16:34 -07001349 my ($linenr, $remain) = @_;
1350
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001351 return ctx_block_get($linenr, $remain, 0, '{', '}', 0);
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001352}
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07001353sub ctx_statement_level {
1354 my ($linenr, $remain, $off) = @_;
1355
1356 return ctx_block_get($linenr, $remain, 0, '(', ')', $off);
1357}
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001358
1359sub ctx_locate_comment {
1360 my ($first_line, $end_line) = @_;
1361
1362 # Catch a comment on the end of the line itself.
Andy Whitcroftbeae6332008-07-23 21:28:59 -07001363 my ($current_comment) = ($rawlines[$end_line - 1] =~ m@.*(/\*.*\*/)\s*(?:\\\s*)?$@);
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001364 return $current_comment if (defined $current_comment);
1365
1366 # Look through the context and try and figure out if there is a
1367 # comment.
1368 my $in_comment = 0;
1369 $current_comment = '';
1370 for (my $linenr = $first_line; $linenr < $end_line; $linenr++) {
Andy Whitcroft00df3442007-06-08 13:47:06 -07001371 my $line = $rawlines[$linenr - 1];
1372 #warn " $line\n";
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001373 if ($linenr == $first_line and $line =~ m@^.\s*\*@) {
1374 $in_comment = 1;
1375 }
1376 if ($line =~ m@/\*@) {
1377 $in_comment = 1;
1378 }
1379 if (!$in_comment && $current_comment ne '') {
1380 $current_comment = '';
1381 }
1382 $current_comment .= $line . "\n" if ($in_comment);
1383 if ($line =~ m@\*/@) {
1384 $in_comment = 0;
1385 }
1386 }
1387
1388 chomp($current_comment);
1389 return($current_comment);
1390}
1391sub ctx_has_comment {
1392 my ($first_line, $end_line) = @_;
1393 my $cmt = ctx_locate_comment($first_line, $end_line);
1394
Andy Whitcroft00df3442007-06-08 13:47:06 -07001395 ##print "LINE: $rawlines[$end_line - 1 ]\n";
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001396 ##print "CMMT: $cmt\n";
1397
1398 return ($cmt ne '');
1399}
1400
Andy Whitcroft4d001e42008-10-15 22:02:21 -07001401sub raw_line {
1402 my ($linenr, $cnt) = @_;
1403
1404 my $offset = $linenr - 1;
1405 $cnt++;
1406
1407 my $line;
1408 while ($cnt) {
1409 $line = $rawlines[$offset++];
1410 next if (defined($line) && $line =~ /^-/);
1411 $cnt--;
1412 }
1413
1414 return $line;
1415}
1416
Andy Whitcroft0a920b52007-06-01 00:46:48 -07001417sub cat_vet {
1418 my ($vet) = @_;
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07001419 my ($res, $coded);
Andy Whitcroft0a920b52007-06-01 00:46:48 -07001420
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07001421 $res = '';
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001422 while ($vet =~ /([^[:cntrl:]]*)([[:cntrl:]]|$)/g) {
1423 $res .= $1;
1424 if ($2 ne '') {
1425 $coded = sprintf("^%c", unpack('C', $2) + 64);
1426 $res .= $coded;
1427 }
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07001428 }
1429 $res =~ s/$/\$/;
Andy Whitcroft0a920b52007-06-01 00:46:48 -07001430
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07001431 return $res;
Andy Whitcroft0a920b52007-06-01 00:46:48 -07001432}
1433
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001434my $av_preprocessor = 0;
Andy Whitcroftcf655042008-03-04 14:28:20 -08001435my $av_pending;
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001436my @av_paren_type;
Andy Whitcroft1f65f942008-07-23 21:29:10 -07001437my $av_pend_colon;
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001438
1439sub annotate_reset {
1440 $av_preprocessor = 0;
Andy Whitcroftcf655042008-03-04 14:28:20 -08001441 $av_pending = '_';
1442 @av_paren_type = ('E');
Andy Whitcroft1f65f942008-07-23 21:29:10 -07001443 $av_pend_colon = 'O';
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001444}
1445
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001446sub annotate_values {
1447 my ($stream, $type) = @_;
1448
1449 my $res;
Andy Whitcroft1f65f942008-07-23 21:29:10 -07001450 my $var = '_' x length($stream);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001451 my $cur = $stream;
1452
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001453 print "$stream\n" if ($dbg_values > 1);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001454
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001455 while (length($cur)) {
Andy Whitcroft773647a2008-03-28 14:15:58 -07001456 @av_paren_type = ('E') if ($#av_paren_type < 0);
Andy Whitcroftcf655042008-03-04 14:28:20 -08001457 print " <" . join('', @av_paren_type) .
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07001458 "> <$type> <$av_pending>" if ($dbg_values > 1);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001459 if ($cur =~ /^(\s+)/o) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001460 print "WS($1)\n" if ($dbg_values > 1);
1461 if ($1 =~ /\n/ && $av_preprocessor) {
Andy Whitcroftcf655042008-03-04 14:28:20 -08001462 $type = pop(@av_paren_type);
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001463 $av_preprocessor = 0;
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001464 }
1465
Florian Micklerc023e4732011-01-12 16:59:58 -08001466 } elsif ($cur =~ /^(\(\s*$Type\s*)\)/ && $av_pending eq '_') {
Andy Whitcroft9446ef52010-10-26 14:23:13 -07001467 print "CAST($1)\n" if ($dbg_values > 1);
1468 push(@av_paren_type, $type);
Andy Whitcroftaddcdce2012-01-10 15:10:11 -08001469 $type = 'c';
Andy Whitcroft9446ef52010-10-26 14:23:13 -07001470
Andy Whitcrofte91b6e22010-10-26 14:23:11 -07001471 } elsif ($cur =~ /^($Type)\s*(?:$Ident|,|\)|\(|\s*$)/) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001472 print "DECLARE($1)\n" if ($dbg_values > 1);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001473 $type = 'T';
1474
Andy Whitcroft389a2fe2008-07-23 21:29:05 -07001475 } elsif ($cur =~ /^($Modifier)\s*/) {
1476 print "MODIFIER($1)\n" if ($dbg_values > 1);
1477 $type = 'T';
1478
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07001479 } elsif ($cur =~ /^(\#\s*define\s*$Ident)(\(?)/o) {
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07001480 print "DEFINE($1,$2)\n" if ($dbg_values > 1);
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001481 $av_preprocessor = 1;
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07001482 push(@av_paren_type, $type);
1483 if ($2 ne '') {
1484 $av_pending = 'N';
1485 }
1486 $type = 'E';
1487
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07001488 } elsif ($cur =~ /^(\#\s*(?:undef\s*$Ident|include\b))/o) {
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07001489 print "UNDEF($1)\n" if ($dbg_values > 1);
1490 $av_preprocessor = 1;
1491 push(@av_paren_type, $type);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001492
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07001493 } elsif ($cur =~ /^(\#\s*(?:ifdef|ifndef|if))/o) {
Andy Whitcroftcf655042008-03-04 14:28:20 -08001494 print "PRE_START($1)\n" if ($dbg_values > 1);
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001495 $av_preprocessor = 1;
Andy Whitcroftcf655042008-03-04 14:28:20 -08001496
1497 push(@av_paren_type, $type);
1498 push(@av_paren_type, $type);
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07001499 $type = 'E';
Andy Whitcroftcf655042008-03-04 14:28:20 -08001500
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07001501 } elsif ($cur =~ /^(\#\s*(?:else|elif))/o) {
Andy Whitcroftcf655042008-03-04 14:28:20 -08001502 print "PRE_RESTART($1)\n" if ($dbg_values > 1);
1503 $av_preprocessor = 1;
1504
1505 push(@av_paren_type, $av_paren_type[$#av_paren_type]);
1506
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07001507 $type = 'E';
Andy Whitcroftcf655042008-03-04 14:28:20 -08001508
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07001509 } elsif ($cur =~ /^(\#\s*(?:endif))/o) {
Andy Whitcroftcf655042008-03-04 14:28:20 -08001510 print "PRE_END($1)\n" if ($dbg_values > 1);
1511
1512 $av_preprocessor = 1;
1513
1514 # Assume all arms of the conditional end as this
1515 # one does, and continue as if the #endif was not here.
1516 pop(@av_paren_type);
1517 push(@av_paren_type, $type);
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07001518 $type = 'E';
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001519
1520 } elsif ($cur =~ /^(\\\n)/o) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001521 print "PRECONT($1)\n" if ($dbg_values > 1);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001522
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07001523 } elsif ($cur =~ /^(__attribute__)\s*\(?/o) {
1524 print "ATTR($1)\n" if ($dbg_values > 1);
1525 $av_pending = $type;
1526 $type = 'N';
1527
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001528 } elsif ($cur =~ /^(sizeof)\s*(\()?/o) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001529 print "SIZEOF($1)\n" if ($dbg_values > 1);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001530 if (defined $2) {
Andy Whitcroftcf655042008-03-04 14:28:20 -08001531 $av_pending = 'V';
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001532 }
1533 $type = 'N';
1534
Andy Whitcroft14b111c2008-10-15 22:02:16 -07001535 } elsif ($cur =~ /^(if|while|for)\b/o) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001536 print "COND($1)\n" if ($dbg_values > 1);
Andy Whitcroft14b111c2008-10-15 22:02:16 -07001537 $av_pending = 'E';
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001538 $type = 'N';
1539
Andy Whitcroft1f65f942008-07-23 21:29:10 -07001540 } elsif ($cur =~/^(case)/o) {
1541 print "CASE($1)\n" if ($dbg_values > 1);
1542 $av_pend_colon = 'C';
1543 $type = 'N';
1544
Andy Whitcroft14b111c2008-10-15 22:02:16 -07001545 } elsif ($cur =~/^(return|else|goto|typeof|__typeof__)\b/o) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001546 print "KEYWORD($1)\n" if ($dbg_values > 1);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001547 $type = 'N';
1548
1549 } elsif ($cur =~ /^(\()/o) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001550 print "PAREN('$1')\n" if ($dbg_values > 1);
Andy Whitcroftcf655042008-03-04 14:28:20 -08001551 push(@av_paren_type, $av_pending);
1552 $av_pending = '_';
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001553 $type = 'N';
1554
1555 } elsif ($cur =~ /^(\))/o) {
Andy Whitcroftcf655042008-03-04 14:28:20 -08001556 my $new_type = pop(@av_paren_type);
1557 if ($new_type ne '_') {
1558 $type = $new_type;
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001559 print "PAREN('$1') -> $type\n"
1560 if ($dbg_values > 1);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001561 } else {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001562 print "PAREN('$1')\n" if ($dbg_values > 1);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001563 }
1564
Andy Whitcroftc8cb2ca2008-07-23 21:28:57 -07001565 } elsif ($cur =~ /^($Ident)\s*\(/o) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001566 print "FUNC($1)\n" if ($dbg_values > 1);
Andy Whitcroftc8cb2ca2008-07-23 21:28:57 -07001567 $type = 'V';
Andy Whitcroftcf655042008-03-04 14:28:20 -08001568 $av_pending = 'V';
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001569
Andy Whitcroft8e761b02009-01-06 14:41:19 -08001570 } elsif ($cur =~ /^($Ident\s*):(?:\s*\d+\s*(,|=|;))?/) {
1571 if (defined $2 && $type eq 'C' || $type eq 'T') {
Andy Whitcroft1f65f942008-07-23 21:29:10 -07001572 $av_pend_colon = 'B';
Andy Whitcroft8e761b02009-01-06 14:41:19 -08001573 } elsif ($type eq 'E') {
1574 $av_pend_colon = 'L';
Andy Whitcroft1f65f942008-07-23 21:29:10 -07001575 }
1576 print "IDENT_COLON($1,$type>$av_pend_colon)\n" if ($dbg_values > 1);
1577 $type = 'V';
1578
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001579 } elsif ($cur =~ /^($Ident|$Constant)/o) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001580 print "IDENT($1)\n" if ($dbg_values > 1);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001581 $type = 'V';
1582
1583 } elsif ($cur =~ /^($Assignment)/o) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001584 print "ASSIGN($1)\n" if ($dbg_values > 1);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001585 $type = 'N';
1586
Andy Whitcroftcf655042008-03-04 14:28:20 -08001587 } elsif ($cur =~/^(;|{|})/) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001588 print "END($1)\n" if ($dbg_values > 1);
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001589 $type = 'E';
Andy Whitcroft1f65f942008-07-23 21:29:10 -07001590 $av_pend_colon = 'O';
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001591
Andy Whitcroft8e761b02009-01-06 14:41:19 -08001592 } elsif ($cur =~/^(,)/) {
1593 print "COMMA($1)\n" if ($dbg_values > 1);
1594 $type = 'C';
1595
Andy Whitcroft1f65f942008-07-23 21:29:10 -07001596 } elsif ($cur =~ /^(\?)/o) {
1597 print "QUESTION($1)\n" if ($dbg_values > 1);
1598 $type = 'N';
1599
1600 } elsif ($cur =~ /^(:)/o) {
1601 print "COLON($1,$av_pend_colon)\n" if ($dbg_values > 1);
1602
1603 substr($var, length($res), 1, $av_pend_colon);
1604 if ($av_pend_colon eq 'C' || $av_pend_colon eq 'L') {
1605 $type = 'E';
1606 } else {
1607 $type = 'N';
1608 }
1609 $av_pend_colon = 'O';
1610
Andy Whitcroft8e761b02009-01-06 14:41:19 -08001611 } elsif ($cur =~ /^(\[)/o) {
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001612 print "CLOSE($1)\n" if ($dbg_values > 1);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001613 $type = 'N';
1614
Andy Whitcroft0d413862008-10-15 22:02:16 -07001615 } elsif ($cur =~ /^(-(?![->])|\+(?!\+)|\*|\&\&|\&)/o) {
Andy Whitcroft74048ed2008-07-23 21:29:10 -07001616 my $variant;
1617
1618 print "OPV($1)\n" if ($dbg_values > 1);
1619 if ($type eq 'V') {
1620 $variant = 'B';
1621 } else {
1622 $variant = 'U';
1623 }
1624
1625 substr($var, length($res), 1, $variant);
1626 $type = 'N';
1627
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001628 } elsif ($cur =~ /^($Operators)/o) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001629 print "OP($1)\n" if ($dbg_values > 1);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001630 if ($1 ne '++' && $1 ne '--') {
1631 $type = 'N';
1632 }
1633
1634 } elsif ($cur =~ /(^.)/o) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001635 print "C($1)\n" if ($dbg_values > 1);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001636 }
1637 if (defined $1) {
1638 $cur = substr($cur, length($1));
1639 $res .= $type x length($1);
1640 }
1641 }
1642
Andy Whitcroft1f65f942008-07-23 21:29:10 -07001643 return ($res, $var);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001644}
1645
Andy Whitcroft8905a672007-11-28 16:21:06 -08001646sub possible {
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001647 my ($possible, $line) = @_;
Andy Whitcroft9a974fd2009-10-26 16:50:12 -07001648 my $notPermitted = qr{(?:
Andy Whitcroft0776e592008-10-15 22:02:29 -07001649 ^(?:
1650 $Modifier|
1651 $Storage|
1652 $Type|
Andy Whitcroft9a974fd2009-10-26 16:50:12 -07001653 DEFINE_\S+
1654 )$|
1655 ^(?:
Andy Whitcroft0776e592008-10-15 22:02:29 -07001656 goto|
1657 return|
1658 case|
1659 else|
1660 asm|__asm__|
Andy Whitcroft89a88352012-01-10 15:10:00 -08001661 do|
1662 \#|
1663 \#\#|
Andy Whitcroft9a974fd2009-10-26 16:50:12 -07001664 )(?:\s|$)|
Andy Whitcroft0776e592008-10-15 22:02:29 -07001665 ^(?:typedef|struct|enum)\b
Andy Whitcroft9a974fd2009-10-26 16:50:12 -07001666 )}x;
1667 warn "CHECK<$possible> ($line)\n" if ($dbg_possible > 2);
1668 if ($possible !~ $notPermitted) {
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07001669 # Check for modifiers.
1670 $possible =~ s/\s*$Storage\s*//g;
1671 $possible =~ s/\s*$Sparse\s*//g;
1672 if ($possible =~ /^\s*$/) {
1673
1674 } elsif ($possible =~ /\s/) {
1675 $possible =~ s/\s*$Type\s*//g;
Andy Whitcroftd2506582008-07-23 21:29:09 -07001676 for my $modifier (split(' ', $possible)) {
Andy Whitcroft9a974fd2009-10-26 16:50:12 -07001677 if ($modifier !~ $notPermitted) {
1678 warn "MODIFIER: $modifier ($possible) ($line)\n" if ($dbg_possible);
Alex Dowad485ff232015-06-25 15:02:52 -07001679 push(@modifierListFile, $modifier);
Andy Whitcroft9a974fd2009-10-26 16:50:12 -07001680 }
Andy Whitcroftd2506582008-07-23 21:29:09 -07001681 }
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07001682
1683 } else {
1684 warn "POSSIBLE: $possible ($line)\n" if ($dbg_possible);
Alex Dowad485ff232015-06-25 15:02:52 -07001685 push(@typeListFile, $possible);
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07001686 }
Andy Whitcroft8905a672007-11-28 16:21:06 -08001687 build_types();
Andy Whitcroft0776e592008-10-15 22:02:29 -07001688 } else {
1689 warn "NOTPOSS: $possible ($line)\n" if ($dbg_possible > 1);
Andy Whitcroft8905a672007-11-28 16:21:06 -08001690 }
1691}
1692
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001693my $prefix = '';
1694
Joe Perches000d1cc12011-07-25 17:13:25 -07001695sub show_type {
Joe Perchescbec18a2014-04-03 14:49:19 -07001696 my ($type) = @_;
Joe Perches91bfe482013-09-11 14:23:59 -07001697
Joe Perchescbec18a2014-04-03 14:49:19 -07001698 return defined $use_type{$type} if (scalar keys %use_type > 0);
1699
1700 return !defined $ignore_type{$type};
Joe Perches000d1cc12011-07-25 17:13:25 -07001701}
1702
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001703sub report {
Joe Perchescbec18a2014-04-03 14:49:19 -07001704 my ($level, $type, $msg) = @_;
1705
1706 if (!show_type($type) ||
1707 (defined $tst_only && $msg !~ /\Q$tst_only\E/)) {
Andy Whitcroft773647a2008-03-28 14:15:58 -07001708 return 0;
1709 }
Joe Perches57230292015-06-25 15:03:03 -07001710 my $output = '';
1711 if (-t STDOUT && $color) {
1712 if ($level eq 'ERROR') {
1713 $output .= RED;
1714 } elsif ($level eq 'WARNING') {
1715 $output .= YELLOW;
1716 } else {
1717 $output .= GREEN;
1718 }
Joe Perches000d1cc12011-07-25 17:13:25 -07001719 }
Joe Perches57230292015-06-25 15:03:03 -07001720 $output .= $prefix . $level . ':';
1721 if ($show_types) {
1722 $output .= BLUE if (-t STDOUT && $color);
1723 $output .= "$type:";
1724 }
1725 $output .= RESET if (-t STDOUT && $color);
1726 $output .= ' ' . $msg . "\n";
Joe Perches34d88152015-06-25 15:03:05 -07001727
1728 if ($showfile) {
1729 my @lines = split("\n", $output, -1);
1730 splice(@lines, 1, 1);
1731 $output = join("\n", @lines);
1732 }
Joe Perches57230292015-06-25 15:03:03 -07001733 $output = (split('\n', $output))[0] . "\n" if ($terse);
Andy Whitcroft8905a672007-11-28 16:21:06 -08001734
Joe Perches57230292015-06-25 15:03:03 -07001735 push(our @report, $output);
Andy Whitcroft773647a2008-03-28 14:15:58 -07001736
1737 return 1;
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001738}
Joe Perchescbec18a2014-04-03 14:49:19 -07001739
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001740sub report_dump {
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001741 our @report;
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001742}
Joe Perches000d1cc12011-07-25 17:13:25 -07001743
Joe Perchesd752fcc2014-08-06 16:11:05 -07001744sub fixup_current_range {
1745 my ($lineRef, $offset, $length) = @_;
1746
1747 if ($$lineRef =~ /^\@\@ -\d+,\d+ \+(\d+),(\d+) \@\@/) {
1748 my $o = $1;
1749 my $l = $2;
1750 my $no = $o + $offset;
1751 my $nl = $l + $length;
1752 $$lineRef =~ s/\+$o,$l \@\@/\+$no,$nl \@\@/;
1753 }
1754}
1755
1756sub fix_inserted_deleted_lines {
1757 my ($linesRef, $insertedRef, $deletedRef) = @_;
1758
1759 my $range_last_linenr = 0;
1760 my $delta_offset = 0;
1761
1762 my $old_linenr = 0;
1763 my $new_linenr = 0;
1764
1765 my $next_insert = 0;
1766 my $next_delete = 0;
1767
1768 my @lines = ();
1769
1770 my $inserted = @{$insertedRef}[$next_insert++];
1771 my $deleted = @{$deletedRef}[$next_delete++];
1772
1773 foreach my $old_line (@{$linesRef}) {
1774 my $save_line = 1;
1775 my $line = $old_line; #don't modify the array
Joe Perches323b2672015-04-16 12:44:50 -07001776 if ($line =~ /^(?:\+\+\+|\-\-\-)\s+\S+/) { #new filename
Joe Perchesd752fcc2014-08-06 16:11:05 -07001777 $delta_offset = 0;
1778 } elsif ($line =~ /^\@\@ -\d+,\d+ \+\d+,\d+ \@\@/) { #new hunk
1779 $range_last_linenr = $new_linenr;
1780 fixup_current_range(\$line, $delta_offset, 0);
1781 }
1782
1783 while (defined($deleted) && ${$deleted}{'LINENR'} == $old_linenr) {
1784 $deleted = @{$deletedRef}[$next_delete++];
1785 $save_line = 0;
1786 fixup_current_range(\$lines[$range_last_linenr], $delta_offset--, -1);
1787 }
1788
1789 while (defined($inserted) && ${$inserted}{'LINENR'} == $old_linenr) {
1790 push(@lines, ${$inserted}{'LINE'});
1791 $inserted = @{$insertedRef}[$next_insert++];
1792 $new_linenr++;
1793 fixup_current_range(\$lines[$range_last_linenr], $delta_offset++, 1);
1794 }
1795
1796 if ($save_line) {
1797 push(@lines, $line);
1798 $new_linenr++;
1799 }
1800
1801 $old_linenr++;
1802 }
1803
1804 return @lines;
1805}
1806
Joe Perchesf2d7e4d2014-08-06 16:11:07 -07001807sub fix_insert_line {
1808 my ($linenr, $line) = @_;
1809
1810 my $inserted = {
1811 LINENR => $linenr,
1812 LINE => $line,
1813 };
1814 push(@fixed_inserted, $inserted);
1815}
1816
1817sub fix_delete_line {
1818 my ($linenr, $line) = @_;
1819
1820 my $deleted = {
1821 LINENR => $linenr,
1822 LINE => $line,
1823 };
1824
1825 push(@fixed_deleted, $deleted);
1826}
1827
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07001828sub ERROR {
Joe Perchescbec18a2014-04-03 14:49:19 -07001829 my ($type, $msg) = @_;
1830
1831 if (report("ERROR", $type, $msg)) {
Andy Whitcroft773647a2008-03-28 14:15:58 -07001832 our $clean = 0;
1833 our $cnt_error++;
Joe Perches3705ce52013-07-03 15:05:31 -07001834 return 1;
Andy Whitcroft773647a2008-03-28 14:15:58 -07001835 }
Joe Perches3705ce52013-07-03 15:05:31 -07001836 return 0;
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07001837}
1838sub WARN {
Joe Perchescbec18a2014-04-03 14:49:19 -07001839 my ($type, $msg) = @_;
1840
1841 if (report("WARNING", $type, $msg)) {
Andy Whitcroft773647a2008-03-28 14:15:58 -07001842 our $clean = 0;
1843 our $cnt_warn++;
Joe Perches3705ce52013-07-03 15:05:31 -07001844 return 1;
Andy Whitcroft773647a2008-03-28 14:15:58 -07001845 }
Joe Perches3705ce52013-07-03 15:05:31 -07001846 return 0;
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07001847}
1848sub CHK {
Joe Perchescbec18a2014-04-03 14:49:19 -07001849 my ($type, $msg) = @_;
1850
1851 if ($check && report("CHECK", $type, $msg)) {
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001852 our $clean = 0;
1853 our $cnt_chk++;
Joe Perches3705ce52013-07-03 15:05:31 -07001854 return 1;
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001855 }
Joe Perches3705ce52013-07-03 15:05:31 -07001856 return 0;
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07001857}
1858
Andy Whitcroft6ecd9672008-10-15 22:02:21 -07001859sub check_absolute_file {
1860 my ($absolute, $herecurr) = @_;
1861 my $file = $absolute;
1862
1863 ##print "absolute<$absolute>\n";
1864
1865 # See if any suffix of this path is a path within the tree.
1866 while ($file =~ s@^[^/]*/@@) {
1867 if (-f "$root/$file") {
1868 ##print "file<$file>\n";
1869 last;
1870 }
1871 }
1872 if (! -f _) {
1873 return 0;
1874 }
1875
1876 # It is, so see if the prefix is acceptable.
1877 my $prefix = $absolute;
1878 substr($prefix, -length($file)) = '';
1879
1880 ##print "prefix<$prefix>\n";
1881 if ($prefix ne ".../") {
Joe Perches000d1cc12011-07-25 17:13:25 -07001882 WARN("USE_RELATIVE_PATH",
1883 "use relative pathname instead of absolute in changelog text\n" . $herecurr);
Andy Whitcroft6ecd9672008-10-15 22:02:21 -07001884 }
1885}
1886
Joe Perches3705ce52013-07-03 15:05:31 -07001887sub trim {
1888 my ($string) = @_;
1889
Joe Perchesb34c6482013-09-11 14:24:01 -07001890 $string =~ s/^\s+|\s+$//g;
1891
1892 return $string;
1893}
1894
1895sub ltrim {
1896 my ($string) = @_;
1897
1898 $string =~ s/^\s+//;
1899
1900 return $string;
1901}
1902
1903sub rtrim {
1904 my ($string) = @_;
1905
1906 $string =~ s/\s+$//;
Joe Perches3705ce52013-07-03 15:05:31 -07001907
1908 return $string;
1909}
1910
Joe Perches52ea8502013-11-12 15:10:09 -08001911sub string_find_replace {
1912 my ($string, $find, $replace) = @_;
1913
1914 $string =~ s/$find/$replace/g;
1915
1916 return $string;
1917}
1918
Joe Perches3705ce52013-07-03 15:05:31 -07001919sub tabify {
1920 my ($leading) = @_;
1921
1922 my $source_indent = 8;
1923 my $max_spaces_before_tab = $source_indent - 1;
1924 my $spaces_to_tab = " " x $source_indent;
1925
1926 #convert leading spaces to tabs
1927 1 while $leading =~ s@^([\t]*)$spaces_to_tab@$1\t@g;
1928 #Remove spaces before a tab
1929 1 while $leading =~ s@^([\t]*)( {1,$max_spaces_before_tab})\t@$1\t@g;
1930
1931 return "$leading";
1932}
1933
Joe Perchesd1fe9c02012-03-23 15:02:16 -07001934sub pos_last_openparen {
1935 my ($line) = @_;
1936
1937 my $pos = 0;
1938
1939 my $opens = $line =~ tr/\(/\(/;
1940 my $closes = $line =~ tr/\)/\)/;
1941
1942 my $last_openparen = 0;
1943
1944 if (($opens == 0) || ($closes >= $opens)) {
1945 return -1;
1946 }
1947
1948 my $len = length($line);
1949
1950 for ($pos = 0; $pos < $len; $pos++) {
1951 my $string = substr($line, $pos);
1952 if ($string =~ /^($FuncArg|$balanced_parens)/) {
1953 $pos += length($1) - 1;
1954 } elsif (substr($line, $pos, 1) eq '(') {
1955 $last_openparen = $pos;
1956 } elsif (index($string, '(') == -1) {
1957 last;
1958 }
1959 }
1960
Joe Perches91cb5192014-04-03 14:49:32 -07001961 return length(expand_tabs(substr($line, 0, $last_openparen))) + 1;
Joe Perchesd1fe9c02012-03-23 15:02:16 -07001962}
1963
Andy Whitcroft0a920b52007-06-01 00:46:48 -07001964sub process {
1965 my $filename = shift;
Andy Whitcroft0a920b52007-06-01 00:46:48 -07001966
1967 my $linenr=0;
1968 my $prevline="";
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001969 my $prevrawline="";
Andy Whitcroft0a920b52007-06-01 00:46:48 -07001970 my $stashline="";
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001971 my $stashrawline="";
Andy Whitcroft0a920b52007-06-01 00:46:48 -07001972
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001973 my $length;
Andy Whitcroft0a920b52007-06-01 00:46:48 -07001974 my $indent;
1975 my $previndent=0;
1976 my $stashindent=0;
1977
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07001978 our $clean = 1;
Andy Whitcroft0a920b52007-06-01 00:46:48 -07001979 my $signoff = 0;
1980 my $is_patch = 0;
Joe Perches29ee1b02014-08-06 16:10:35 -07001981 my $in_header_lines = $file ? 0 : 1;
Joe Perches15662b32011-10-31 17:13:12 -07001982 my $in_commit_log = 0; #Scanning lines before patch
Joe Perchesbf4daf12015-09-09 15:37:50 -07001983 my $commit_log_possible_stack_dump = 0;
Joe Perches2a076f42015-04-16 12:44:28 -07001984 my $commit_log_long_line = 0;
Joe Perchese518e9a2015-06-25 15:03:27 -07001985 my $commit_log_has_diff = 0;
Joe Perches13f19372014-08-06 16:10:59 -07001986 my $reported_maintainer_file = 0;
Pasi Savanainenfa64205d2012-10-04 17:13:29 -07001987 my $non_utf8_charset = 0;
1988
Joe Perches365dd4e2014-08-06 16:10:42 -07001989 my $last_blank_line = 0;
Joe Perches5e4f6ba2014-12-10 15:52:05 -08001990 my $last_coalesced_string_linenr = -1;
Joe Perches365dd4e2014-08-06 16:10:42 -07001991
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001992 our @report = ();
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001993 our $cnt_lines = 0;
1994 our $cnt_error = 0;
1995 our $cnt_warn = 0;
1996 our $cnt_chk = 0;
1997
Andy Whitcroft0a920b52007-06-01 00:46:48 -07001998 # Trace the real file/line as we go.
1999 my $realfile = '';
2000 my $realline = 0;
2001 my $realcnt = 0;
2002 my $here = '';
2003 my $in_comment = 0;
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002004 my $comment_edge = 0;
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002005 my $first_line = 0;
Wolfram Sang1e855722009-01-06 14:41:24 -08002006 my $p1_prefix = '';
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002007
Andy Whitcroft13214ad2008-02-08 04:22:03 -08002008 my $prev_values = 'E';
2009
2010 # suppression flags
Andy Whitcroft773647a2008-03-28 14:15:58 -07002011 my %suppress_ifbraces;
Andy Whitcroft170d3a22008-10-15 22:02:30 -07002012 my %suppress_whiletrailers;
Andy Whitcroft2b474a12009-10-26 16:50:16 -07002013 my %suppress_export;
Andy Whitcroft3e469cd2012-01-10 15:10:01 -08002014 my $suppress_statement = 0;
Andy Whitcroft653d4872007-06-23 17:16:34 -07002015
Joe Perches7e51f192013-09-11 14:23:57 -07002016 my %signatures = ();
Joe Perches323c1262012-12-17 16:02:07 -08002017
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002018 # Pre-scan the patch sanitizing the lines.
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07002019 # Pre-scan the patch looking for any __setup documentation.
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002020 #
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07002021 my @setup_docs = ();
2022 my $setup_docs = 0;
Andy Whitcroft773647a2008-03-28 14:15:58 -07002023
Joe Perchesd8b07712013-11-12 15:10:06 -08002024 my $camelcase_file_seeded = 0;
2025
Andy Whitcroft773647a2008-03-28 14:15:58 -07002026 sanitise_line_reset();
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002027 my $line;
2028 foreach my $rawline (@rawlines) {
Andy Whitcroft773647a2008-03-28 14:15:58 -07002029 $linenr++;
2030 $line = $rawline;
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002031
Joe Perches3705ce52013-07-03 15:05:31 -07002032 push(@fixed, $rawline) if ($fix);
2033
Andy Whitcroft773647a2008-03-28 14:15:58 -07002034 if ($rawline=~/^\+\+\+\s+(\S+)/) {
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07002035 $setup_docs = 0;
2036 if ($1 =~ m@Documentation/kernel-parameters.txt$@) {
2037 $setup_docs = 1;
2038 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07002039 #next;
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07002040 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07002041 if ($rawline=~/^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@/) {
2042 $realline=$1-1;
2043 if (defined $2) {
2044 $realcnt=$3+1;
2045 } else {
2046 $realcnt=1+1;
2047 }
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07002048 $in_comment = 0;
Andy Whitcroft773647a2008-03-28 14:15:58 -07002049
2050 # Guestimate if this is a continuing comment. Run
2051 # the context looking for a comment "edge". If this
2052 # edge is a close comment then we must be in a comment
2053 # at context start.
2054 my $edge;
Andy Whitcroft01fa9142008-10-15 22:02:19 -07002055 my $cnt = $realcnt;
2056 for (my $ln = $linenr + 1; $cnt > 0; $ln++) {
2057 next if (defined $rawlines[$ln - 1] &&
2058 $rawlines[$ln - 1] =~ /^-/);
2059 $cnt--;
2060 #print "RAW<$rawlines[$ln - 1]>\n";
Andy Whitcroft721c1cb2009-01-06 14:41:16 -08002061 last if (!defined $rawlines[$ln - 1]);
Andy Whitcroftfae17da2009-01-06 14:41:20 -08002062 if ($rawlines[$ln - 1] =~ m@(/\*|\*/)@ &&
2063 $rawlines[$ln - 1] !~ m@"[^"]*(?:/\*|\*/)[^"]*"@) {
2064 ($edge) = $1;
2065 last;
2066 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07002067 }
2068 if (defined $edge && $edge eq '*/') {
2069 $in_comment = 1;
2070 }
2071
2072 # Guestimate if this is a continuing comment. If this
2073 # is the start of a diff block and this line starts
2074 # ' *' then it is very likely a comment.
2075 if (!defined $edge &&
Andy Whitcroft83242e02009-01-06 14:41:17 -08002076 $rawlines[$linenr] =~ m@^.\s*(?:\*\*+| \*)(?:\s|$)@)
Andy Whitcroft773647a2008-03-28 14:15:58 -07002077 {
2078 $in_comment = 1;
2079 }
2080
2081 ##print "COMMENT:$in_comment edge<$edge> $rawline\n";
2082 sanitise_line_reset($in_comment);
2083
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07002084 } elsif ($realcnt && $rawline =~ /^(?:\+| |$)/) {
Andy Whitcroft773647a2008-03-28 14:15:58 -07002085 # Standardise the strings and chars within the input to
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07002086 # simplify matching -- only bother with positive lines.
Andy Whitcroft773647a2008-03-28 14:15:58 -07002087 $line = sanitise_line($rawline);
2088 }
2089 push(@lines, $line);
2090
2091 if ($realcnt > 1) {
2092 $realcnt-- if ($line =~ /^(?:\+| |$)/);
2093 } else {
2094 $realcnt = 0;
2095 }
2096
2097 #print "==>$rawline\n";
2098 #print "-->$line\n";
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07002099
2100 if ($setup_docs && $line =~ /^\+/) {
2101 push(@setup_docs, $line);
2102 }
2103 }
2104
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07002105 $prefix = '';
2106
Andy Whitcroft773647a2008-03-28 14:15:58 -07002107 $realcnt = 0;
2108 $linenr = 0;
Joe Perches194f66f2014-08-06 16:11:03 -07002109 $fixlinenr = -1;
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002110 foreach my $line (@lines) {
2111 $linenr++;
Joe Perches194f66f2014-08-06 16:11:03 -07002112 $fixlinenr++;
Joe Perches1b5539b2013-09-11 14:24:03 -07002113 my $sline = $line; #copy of $line
2114 $sline =~ s/$;/ /g; #with comments as spaces
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002115
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002116 my $rawline = $rawlines[$linenr - 1];
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07002117
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002118#extract the line range in the file after the patch is applied
Joe Perchese518e9a2015-06-25 15:03:27 -07002119 if (!$in_commit_log &&
2120 $line =~ /^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@/) {
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002121 $is_patch = 1;
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07002122 $first_line = $linenr + 1;
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002123 $realline=$1-1;
2124 if (defined $2) {
2125 $realcnt=$3+1;
2126 } else {
2127 $realcnt=1+1;
2128 }
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002129 annotate_reset();
Andy Whitcroft13214ad2008-02-08 04:22:03 -08002130 $prev_values = 'E';
2131
Andy Whitcroft773647a2008-03-28 14:15:58 -07002132 %suppress_ifbraces = ();
Andy Whitcroft170d3a22008-10-15 22:02:30 -07002133 %suppress_whiletrailers = ();
Andy Whitcroft2b474a12009-10-26 16:50:16 -07002134 %suppress_export = ();
Andy Whitcroft3e469cd2012-01-10 15:10:01 -08002135 $suppress_statement = 0;
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002136 next;
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002137
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07002138# track the line number as we move through the hunk, note that
2139# new versions of GNU diff omit the leading space on completely
2140# blank context lines so we need to count that too.
Andy Whitcroft773647a2008-03-28 14:15:58 -07002141 } elsif ($line =~ /^( |\+|$)/) {
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002142 $realline++;
Andy Whitcroftd8aaf122007-06-23 17:16:44 -07002143 $realcnt-- if ($realcnt != 0);
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002144
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07002145 # Measure the line length and indent.
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002146 ($length, $indent) = line_stats($rawline);
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002147
2148 # Track the previous line.
2149 ($prevline, $stashline) = ($stashline, $line);
2150 ($previndent, $stashindent) = ($stashindent, $indent);
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002151 ($prevrawline, $stashrawline) = ($stashrawline, $rawline);
2152
Andy Whitcroft773647a2008-03-28 14:15:58 -07002153 #warn "line<$line>\n";
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07002154
Andy Whitcroftd8aaf122007-06-23 17:16:44 -07002155 } elsif ($realcnt == 1) {
2156 $realcnt--;
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002157 }
2158
Andy Whitcroftcc77cdc2009-10-26 16:50:13 -07002159 my $hunk_line = ($realcnt != 0);
2160
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07002161 $here = "#$linenr: " if (!$file);
2162 $here = "#$realline: " if ($file);
Andy Whitcroft773647a2008-03-28 14:15:58 -07002163
Joe Perches2ac73b42014-06-04 16:12:05 -07002164 my $found_file = 0;
Andy Whitcroft773647a2008-03-28 14:15:58 -07002165 # extract the filename as it passes
Rabin Vincent3bf9a002010-10-26 14:23:16 -07002166 if ($line =~ /^diff --git.*?(\S+)$/) {
2167 $realfile = $1;
Joe Perches2b7ab452013-11-12 15:10:14 -08002168 $realfile =~ s@^([^/]*)/@@ if (!$file);
Joe Perches270c49a2012-01-10 15:09:50 -08002169 $in_commit_log = 0;
Joe Perches2ac73b42014-06-04 16:12:05 -07002170 $found_file = 1;
Rabin Vincent3bf9a002010-10-26 14:23:16 -07002171 } elsif ($line =~ /^\+\+\+\s+(\S+)/) {
Andy Whitcroft773647a2008-03-28 14:15:58 -07002172 $realfile = $1;
Joe Perches2b7ab452013-11-12 15:10:14 -08002173 $realfile =~ s@^([^/]*)/@@ if (!$file);
Joe Perches270c49a2012-01-10 15:09:50 -08002174 $in_commit_log = 0;
Wolfram Sang1e855722009-01-06 14:41:24 -08002175
2176 $p1_prefix = $1;
Andy Whitcrofte2f7aa42009-02-27 14:03:06 -08002177 if (!$file && $tree && $p1_prefix ne '' &&
2178 -e "$root/$p1_prefix") {
Joe Perches000d1cc12011-07-25 17:13:25 -07002179 WARN("PATCH_PREFIX",
2180 "patch prefix '$p1_prefix' exists, appears to be a -p0 patch\n");
Wolfram Sang1e855722009-01-06 14:41:24 -08002181 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07002182
Andy Whitcroftc1ab3322008-10-15 22:02:20 -07002183 if ($realfile =~ m@^include/asm/@) {
Joe Perches000d1cc12011-07-25 17:13:25 -07002184 ERROR("MODIFIED_INCLUDE_ASM",
2185 "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 -07002186 }
Joe Perches2ac73b42014-06-04 16:12:05 -07002187 $found_file = 1;
2188 }
2189
Joe Perches34d88152015-06-25 15:03:05 -07002190#make up the handle for any error we report on this line
2191 if ($showfile) {
2192 $prefix = "$realfile:$realline: "
2193 } elsif ($emacs) {
Joe Perches7d3a9f62015-09-09 15:37:39 -07002194 if ($file) {
2195 $prefix = "$filename:$realline: ";
2196 } else {
2197 $prefix = "$filename:$linenr: ";
2198 }
Joe Perches34d88152015-06-25 15:03:05 -07002199 }
2200
Joe Perches2ac73b42014-06-04 16:12:05 -07002201 if ($found_file) {
Joe Perches7bd7e482015-09-09 15:37:44 -07002202 if ($realfile =~ m@^(?:drivers/net/|net/|drivers/staging/)@) {
Joe Perches2ac73b42014-06-04 16:12:05 -07002203 $check = 1;
2204 } else {
2205 $check = $check_orig;
2206 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07002207 next;
2208 }
2209
Randy Dunlap389834b2007-06-08 13:47:03 -07002210 $here .= "FILE: $realfile:$realline:" if ($realcnt != 0);
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002211
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002212 my $hereline = "$here\n$rawline\n";
2213 my $herecurr = "$here\n$rawline\n";
2214 my $hereprev = "$here\n$prevrawline\n$rawline\n";
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002215
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07002216 $cnt_lines++ if ($realcnt != 0);
2217
Joe Perchese518e9a2015-06-25 15:03:27 -07002218# Check if the commit log has what seems like a diff which can confuse patch
2219 if ($in_commit_log && !$commit_log_has_diff &&
2220 (($line =~ m@^\s+diff\b.*a/[\w/]+@ &&
2221 $line =~ m@^\s+diff\b.*a/([\w/]+)\s+b/$1\b@) ||
2222 $line =~ m@^\s*(?:\-\-\-\s+a/|\+\+\+\s+b/)@ ||
2223 $line =~ m/^\s*\@\@ \-\d+,\d+ \+\d+,\d+ \@\@/)) {
2224 ERROR("DIFF_IN_COMMIT_MSG",
2225 "Avoid using diff content in the commit message - patch(1) might not work\n" . $herecurr);
2226 $commit_log_has_diff = 1;
2227 }
2228
Rabin Vincent3bf9a002010-10-26 14:23:16 -07002229# Check for incorrect file permissions
2230 if ($line =~ /^new (file )?mode.*[7531]\d{0,2}$/) {
2231 my $permhere = $here . "FILE: $realfile\n";
Joe Perches04db4d22013-04-29 16:18:14 -07002232 if ($realfile !~ m@scripts/@ &&
2233 $realfile !~ /\.(py|pl|awk|sh)$/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07002234 ERROR("EXECUTE_PERMISSIONS",
2235 "do not set execute permissions for source files\n" . $permhere);
Rabin Vincent3bf9a002010-10-26 14:23:16 -07002236 }
2237 }
2238
Joe Perches20112472011-07-25 17:13:23 -07002239# Check the patch for a signoff:
Andy Whitcroftd8aaf122007-06-23 17:16:44 -07002240 if ($line =~ /^\s*signed-off-by:/i) {
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07002241 $signoff++;
Joe Perches15662b32011-10-31 17:13:12 -07002242 $in_commit_log = 0;
Joe Perches20112472011-07-25 17:13:23 -07002243 }
2244
Joe Perchese0d975b2014-12-10 15:51:49 -08002245# Check if MAINTAINERS is being updated. If so, there's probably no need to
2246# emit the "does MAINTAINERS need updating?" message on file add/move/delete
2247 if ($line =~ /^\s*MAINTAINERS\s*\|/) {
2248 $reported_maintainer_file = 1;
2249 }
2250
Joe Perches20112472011-07-25 17:13:23 -07002251# Check signature styles
Joe Perches270c49a2012-01-10 15:09:50 -08002252 if (!$in_header_lines &&
Joe Perchesce0338df3c2012-07-30 14:41:18 -07002253 $line =~ /^(\s*)([a-z0-9_-]+by:|$signature_tags)(\s*)(.*)/i) {
Joe Perches20112472011-07-25 17:13:23 -07002254 my $space_before = $1;
2255 my $sign_off = $2;
2256 my $space_after = $3;
2257 my $email = $4;
2258 my $ucfirst_sign_off = ucfirst(lc($sign_off));
2259
Joe Perchesce0338df3c2012-07-30 14:41:18 -07002260 if ($sign_off !~ /$signature_tags/) {
2261 WARN("BAD_SIGN_OFF",
2262 "Non-standard signature: $sign_off\n" . $herecurr);
2263 }
Joe Perches20112472011-07-25 17:13:23 -07002264 if (defined $space_before && $space_before ne "") {
Joe Perches3705ce52013-07-03 15:05:31 -07002265 if (WARN("BAD_SIGN_OFF",
2266 "Do not use whitespace before $ucfirst_sign_off\n" . $herecurr) &&
2267 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07002268 $fixed[$fixlinenr] =
Joe Perches3705ce52013-07-03 15:05:31 -07002269 "$ucfirst_sign_off $email";
2270 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002271 }
Joe Perches20112472011-07-25 17:13:23 -07002272 if ($sign_off =~ /-by:$/i && $sign_off ne $ucfirst_sign_off) {
Joe Perches3705ce52013-07-03 15:05:31 -07002273 if (WARN("BAD_SIGN_OFF",
2274 "'$ucfirst_sign_off' is the preferred signature form\n" . $herecurr) &&
2275 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07002276 $fixed[$fixlinenr] =
Joe Perches3705ce52013-07-03 15:05:31 -07002277 "$ucfirst_sign_off $email";
2278 }
2279
Joe Perches20112472011-07-25 17:13:23 -07002280 }
2281 if (!defined $space_after || $space_after ne " ") {
Joe Perches3705ce52013-07-03 15:05:31 -07002282 if (WARN("BAD_SIGN_OFF",
2283 "Use a single space after $ucfirst_sign_off\n" . $herecurr) &&
2284 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07002285 $fixed[$fixlinenr] =
Joe Perches3705ce52013-07-03 15:05:31 -07002286 "$ucfirst_sign_off $email";
2287 }
Joe Perches20112472011-07-25 17:13:23 -07002288 }
2289
2290 my ($email_name, $email_address, $comment) = parse_email($email);
2291 my $suggested_email = format_email(($email_name, $email_address));
2292 if ($suggested_email eq "") {
Joe Perches000d1cc12011-07-25 17:13:25 -07002293 ERROR("BAD_SIGN_OFF",
2294 "Unrecognized email address: '$email'\n" . $herecurr);
Joe Perches20112472011-07-25 17:13:23 -07002295 } else {
2296 my $dequoted = $suggested_email;
2297 $dequoted =~ s/^"//;
2298 $dequoted =~ s/" </ </;
2299 # Don't force email to have quotes
2300 # Allow just an angle bracketed address
2301 if ("$dequoted$comment" ne $email &&
2302 "<$email_address>$comment" ne $email &&
2303 "$suggested_email$comment" ne $email) {
Joe Perches000d1cc12011-07-25 17:13:25 -07002304 WARN("BAD_SIGN_OFF",
2305 "email address '$email' might be better as '$suggested_email$comment'\n" . $herecurr);
Joe Perches20112472011-07-25 17:13:23 -07002306 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002307 }
Joe Perches7e51f192013-09-11 14:23:57 -07002308
2309# Check for duplicate signatures
2310 my $sig_nospace = $line;
2311 $sig_nospace =~ s/\s//g;
2312 $sig_nospace = lc($sig_nospace);
2313 if (defined $signatures{$sig_nospace}) {
2314 WARN("BAD_SIGN_OFF",
2315 "Duplicate signature\n" . $herecurr);
2316 } else {
2317 $signatures{$sig_nospace} = 1;
2318 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002319 }
2320
Joe Perchesa2fe16b2015-02-13 14:39:02 -08002321# Check email subject for common tools that don't need to be mentioned
2322 if ($in_header_lines &&
2323 $line =~ /^Subject:.*\b(?:checkpatch|sparse|smatch)\b[^:]/i) {
2324 WARN("EMAIL_SUBJECT",
2325 "A patch subject line should describe the change not the tool that found it\n" . $herecurr);
2326 }
2327
Joe Perches9b3189e2014-06-04 16:12:10 -07002328# Check for old stable address
2329 if ($line =~ /^\s*cc:\s*.*<?\bstable\@kernel\.org\b>?.*$/i) {
2330 ERROR("STABLE_ADDRESS",
2331 "The 'stable' address should be 'stable\@vger.kernel.org'\n" . $herecurr);
2332 }
2333
Christopher Covington7ebd05e2014-04-03 14:49:31 -07002334# Check for unwanted Gerrit info
2335 if ($in_commit_log && $line =~ /^\s*change-id:/i) {
2336 ERROR("GERRIT_CHANGE_ID",
2337 "Remove Gerrit Change-Id's before submitting upstream.\n" . $herecurr);
2338 }
2339
Joe Perches369c8dd2015-11-06 16:31:34 -08002340# Check if the commit log is in a possible stack dump
2341 if ($in_commit_log && !$commit_log_possible_stack_dump &&
2342 ($line =~ /^\s*(?:WARNING:|BUG:)/ ||
2343 $line =~ /^\s*\[\s*\d+\.\d{6,6}\s*\]/ ||
2344 # timestamp
2345 $line =~ /^\s*\[\<[0-9a-fA-F]{8,}\>\]/)) {
2346 # stack dump address
2347 $commit_log_possible_stack_dump = 1;
2348 }
2349
Joe Perches2a076f42015-04-16 12:44:28 -07002350# Check for line lengths > 75 in commit log, warn once
2351 if ($in_commit_log && !$commit_log_long_line &&
Joe Perches369c8dd2015-11-06 16:31:34 -08002352 length($line) > 75 &&
2353 !($line =~ /^\s*[a-zA-Z0-9_\/\.]+\s+\|\s+\d+/ ||
2354 # file delta changes
2355 $line =~ /^\s*(?:[\w\.\-]+\/)++[\w\.\-]+:/ ||
2356 # filename then :
2357 $line =~ /^\s*(?:Fixes:|Link:)/i ||
2358 # A Fixes: or Link: line
2359 $commit_log_possible_stack_dump)) {
Joe Perches2a076f42015-04-16 12:44:28 -07002360 WARN("COMMIT_LOG_LONG_LINE",
2361 "Possible unwrapped commit description (prefer a maximum 75 chars per line)\n" . $herecurr);
2362 $commit_log_long_line = 1;
2363 }
2364
Joe Perchesbf4daf12015-09-09 15:37:50 -07002365# Reset possible stack dump if a blank line is found
Joe Perches369c8dd2015-11-06 16:31:34 -08002366 if ($in_commit_log && $commit_log_possible_stack_dump &&
2367 $line =~ /^\s*$/) {
2368 $commit_log_possible_stack_dump = 0;
2369 }
Joe Perchesbf4daf12015-09-09 15:37:50 -07002370
Joe Perches0d7835f2015-02-13 14:38:35 -08002371# Check for git id commit length and improperly formed commit descriptions
Joe Perches369c8dd2015-11-06 16:31:34 -08002372 if ($in_commit_log && !$commit_log_possible_stack_dump &&
Joe Perchesfe043ea2015-09-09 15:37:25 -07002373 ($line =~ /\bcommit\s+[0-9a-f]{5,}\b/i ||
Joe Perches369c8dd2015-11-06 16:31:34 -08002374 ($line =~ /\b[0-9a-f]{12,40}\b/i &&
2375 $line !~ /[\<\[][0-9a-f]{12,40}[\>\]]/i &&
2376 $line !~ /\bfixes:\s*[0-9a-f]{12,40}/i))) {
Joe Perchesfe043ea2015-09-09 15:37:25 -07002377 my $init_char = "c";
2378 my $orig_commit = "";
Joe Perches0d7835f2015-02-13 14:38:35 -08002379 my $short = 1;
2380 my $long = 0;
2381 my $case = 1;
2382 my $space = 1;
2383 my $hasdesc = 0;
Joe Perches19c146a2015-02-13 14:39:00 -08002384 my $hasparens = 0;
Joe Perches0d7835f2015-02-13 14:38:35 -08002385 my $id = '0123456789ab';
2386 my $orig_desc = "commit description";
2387 my $description = "";
2388
Joe Perchesfe043ea2015-09-09 15:37:25 -07002389 if ($line =~ /\b(c)ommit\s+([0-9a-f]{5,})\b/i) {
2390 $init_char = $1;
2391 $orig_commit = lc($2);
2392 } elsif ($line =~ /\b([0-9a-f]{12,40})\b/i) {
2393 $orig_commit = lc($1);
2394 }
2395
Joe Perches0d7835f2015-02-13 14:38:35 -08002396 $short = 0 if ($line =~ /\bcommit\s+[0-9a-f]{12,40}/i);
2397 $long = 1 if ($line =~ /\bcommit\s+[0-9a-f]{41,}/i);
2398 $space = 0 if ($line =~ /\bcommit [0-9a-f]/i);
2399 $case = 0 if ($line =~ /\b[Cc]ommit\s+[0-9a-f]{5,40}[^A-F]/);
2400 if ($line =~ /\bcommit\s+[0-9a-f]{5,}\s+\("([^"]+)"\)/i) {
2401 $orig_desc = $1;
Joe Perches19c146a2015-02-13 14:39:00 -08002402 $hasparens = 1;
Joe Perches0d7835f2015-02-13 14:38:35 -08002403 } elsif ($line =~ /\bcommit\s+[0-9a-f]{5,}\s*$/i &&
2404 defined $rawlines[$linenr] &&
2405 $rawlines[$linenr] =~ /^\s*\("([^"]+)"\)/) {
2406 $orig_desc = $1;
Joe Perches19c146a2015-02-13 14:39:00 -08002407 $hasparens = 1;
Joe Perchesb671fde2015-02-13 14:38:41 -08002408 } elsif ($line =~ /\bcommit\s+[0-9a-f]{5,}\s+\("[^"]+$/i &&
2409 defined $rawlines[$linenr] &&
2410 $rawlines[$linenr] =~ /^\s*[^"]+"\)/) {
2411 $line =~ /\bcommit\s+[0-9a-f]{5,}\s+\("([^"]+)$/i;
2412 $orig_desc = $1;
2413 $rawlines[$linenr] =~ /^\s*([^"]+)"\)/;
2414 $orig_desc .= " " . $1;
Joe Perches19c146a2015-02-13 14:39:00 -08002415 $hasparens = 1;
Joe Perches0d7835f2015-02-13 14:38:35 -08002416 }
2417
2418 ($id, $description) = git_commit_info($orig_commit,
2419 $id, $orig_desc);
2420
Joe Perches19c146a2015-02-13 14:39:00 -08002421 if ($short || $long || $space || $case || ($orig_desc ne $description) || !$hasparens) {
Joe Perches0d7835f2015-02-13 14:38:35 -08002422 ERROR("GIT_COMMIT_ID",
2423 "Please use git commit description style 'commit <12+ chars of sha1> (\"<title line>\")' - ie: '${init_char}ommit $id (\"$description\")'\n" . $herecurr);
2424 }
Joe Perchesd311cd42014-08-06 16:10:57 -07002425 }
2426
Joe Perches13f19372014-08-06 16:10:59 -07002427# Check for added, moved or deleted files
2428 if (!$reported_maintainer_file && !$in_commit_log &&
2429 ($line =~ /^(?:new|deleted) file mode\s*\d+\s*$/ ||
2430 $line =~ /^rename (?:from|to) [\w\/\.\-]+\s*$/ ||
2431 ($line =~ /\{\s*([\w\/\.\-]*)\s*\=\>\s*([\w\/\.\-]*)\s*\}/ &&
2432 (defined($1) || defined($2))))) {
2433 $reported_maintainer_file = 1;
2434 WARN("FILE_PATH_CHANGES",
2435 "added, moved or deleted file(s), does MAINTAINERS need updating?\n" . $herecurr);
2436 }
2437
Andy Whitcroft00df3442007-06-08 13:47:06 -07002438# Check for wrappage within a valid hunk of the file
Andy Whitcroft8905a672007-11-28 16:21:06 -08002439 if ($realcnt != 0 && $line !~ m{^(?:\+|-| |\\ No newline|$)}) {
Joe Perches000d1cc12011-07-25 17:13:25 -07002440 ERROR("CORRUPTED_PATCH",
2441 "patch seems to be corrupt (line wrapped?)\n" .
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07002442 $herecurr) if (!$emitted_corrupt++);
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07002443 }
2444
Andy Whitcroft6ecd9672008-10-15 22:02:21 -07002445# Check for absolute kernel paths.
2446 if ($tree) {
2447 while ($line =~ m{(?:^|\s)(/\S*)}g) {
2448 my $file = $1;
2449
2450 if ($file =~ m{^(.*?)(?::\d+)+:?$} &&
2451 check_absolute_file($1, $herecurr)) {
2452 #
2453 } else {
2454 check_absolute_file($file, $herecurr);
2455 }
2456 }
2457 }
2458
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07002459# UTF-8 regex found at http://www.w3.org/International/questions/qa-forms-utf-8.en.php
2460 if (($realfile =~ /^$/ || $line =~ /^\+/) &&
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07002461 $rawline !~ m/^$UTF8*$/) {
2462 my ($utf8_prefix) = ($rawline =~ /^($UTF8*)/);
2463
2464 my $blank = copy_spacing($rawline);
2465 my $ptr = substr($blank, 0, length($utf8_prefix)) . "^";
2466 my $hereptr = "$hereline$ptr\n";
2467
Joe Perches34d99212011-07-25 17:13:26 -07002468 CHK("INVALID_UTF8",
2469 "Invalid UTF-8, patch and commit message should be encoded in UTF-8\n" . $hereptr);
Andy Whitcroft00df3442007-06-08 13:47:06 -07002470 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002471
Joe Perches15662b32011-10-31 17:13:12 -07002472# Check if it's the start of a commit log
2473# (not a header line and we haven't seen the patch filename)
2474 if ($in_header_lines && $realfile =~ /^$/ &&
Joe Perches29ee1b02014-08-06 16:10:35 -07002475 !($rawline =~ /^\s+\S/ ||
2476 $rawline =~ /^(commit\b|from\b|[\w-]+:).*$/i)) {
Joe Perches15662b32011-10-31 17:13:12 -07002477 $in_header_lines = 0;
2478 $in_commit_log = 1;
2479 }
2480
Pasi Savanainenfa64205d2012-10-04 17:13:29 -07002481# Check if there is UTF-8 in a commit log when a mail header has explicitly
2482# declined it, i.e defined some charset where it is missing.
2483 if ($in_header_lines &&
2484 $rawline =~ /^Content-Type:.+charset="(.+)".*$/ &&
2485 $1 !~ /utf-8/i) {
2486 $non_utf8_charset = 1;
2487 }
2488
2489 if ($in_commit_log && $non_utf8_charset && $realfile =~ /^$/ &&
Joe Perches15662b32011-10-31 17:13:12 -07002490 $rawline =~ /$NON_ASCII_UTF8/) {
Pasi Savanainenfa64205d2012-10-04 17:13:29 -07002491 WARN("UTF8_BEFORE_PATCH",
Joe Perches15662b32011-10-31 17:13:12 -07002492 "8-bit UTF-8 used in possible commit log\n" . $herecurr);
2493 }
2494
Kees Cook66b47b42014-10-13 15:51:57 -07002495# Check for various typo / spelling mistakes
Joe Perches66d7a382015-04-16 12:44:08 -07002496 if (defined($misspellings) &&
2497 ($in_commit_log || $line =~ /^(?:\+|Subject:)/i)) {
Joe Perchesebfd7d62015-04-16 12:44:14 -07002498 while ($rawline =~ /(?:^|[^a-z@])($misspellings)(?:\b|$|[^a-z@])/gi) {
Kees Cook66b47b42014-10-13 15:51:57 -07002499 my $typo = $1;
2500 my $typo_fix = $spelling_fix{lc($typo)};
2501 $typo_fix = ucfirst($typo_fix) if ($typo =~ /^[A-Z]/);
2502 $typo_fix = uc($typo_fix) if ($typo =~ /^[A-Z]+$/);
2503 my $msg_type = \&WARN;
2504 $msg_type = \&CHK if ($file);
2505 if (&{$msg_type}("TYPO_SPELLING",
2506 "'$typo' may be misspelled - perhaps '$typo_fix'?\n" . $herecurr) &&
2507 $fix) {
2508 $fixed[$fixlinenr] =~ s/(^|[^A-Za-z@])($typo)($|[^A-Za-z@])/$1$typo_fix$3/;
2509 }
2510 }
2511 }
2512
Andy Whitcroft306708542008-10-15 22:02:28 -07002513# ignore non-hunk lines and lines being removed
2514 next if (!$hunk_line || $line =~ /^-/);
Andy Whitcroft00df3442007-06-08 13:47:06 -07002515
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002516#trailing whitespace
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07002517 if ($line =~ /^\+.*\015/) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002518 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
Joe Perchesd5e616f2013-09-11 14:23:54 -07002519 if (ERROR("DOS_LINE_ENDINGS",
2520 "DOS line endings\n" . $herevet) &&
2521 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07002522 $fixed[$fixlinenr] =~ s/[\s\015]+$//;
Joe Perchesd5e616f2013-09-11 14:23:54 -07002523 }
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002524 } elsif ($rawline =~ /^\+.*\S\s+$/ || $rawline =~ /^\+\s+$/) {
2525 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
Joe Perches3705ce52013-07-03 15:05:31 -07002526 if (ERROR("TRAILING_WHITESPACE",
2527 "trailing whitespace\n" . $herevet) &&
2528 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07002529 $fixed[$fixlinenr] =~ s/\s+$//;
Joe Perches3705ce52013-07-03 15:05:31 -07002530 }
2531
Andy Whitcroftd2c0a232010-10-26 14:23:12 -07002532 $rpt_cleaners = 1;
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002533 }
Andy Whitcroft5368df22008-10-15 22:02:27 -07002534
Josh Triplett4783f892013-11-12 15:10:12 -08002535# Check for FSF mailing addresses.
Alexander Duyck109d8cb2014-01-23 15:54:50 -08002536 if ($rawline =~ /\bwrite to the Free/i ||
Joe Perches3e2232f2014-01-23 15:54:48 -08002537 $rawline =~ /\b59\s+Temple\s+Pl/i ||
2538 $rawline =~ /\b51\s+Franklin\s+St/i) {
Josh Triplett4783f892013-11-12 15:10:12 -08002539 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2540 my $msg_type = \&ERROR;
2541 $msg_type = \&CHK if ($file);
2542 &{$msg_type}("FSF_MAILING_ADDRESS",
Joe Perches3e2232f2014-01-23 15:54:48 -08002543 "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 -08002544 }
2545
Andi Kleen33549572010-05-24 14:33:29 -07002546# check for Kconfig help text having a real description
Andy Whitcroft9fe287d72010-10-26 14:23:15 -07002547# Only applies when adding the entry originally, after that we do not have
2548# sufficient context to determine whether it is indeed long enough.
Andi Kleen33549572010-05-24 14:33:29 -07002549 if ($realfile =~ /Kconfig/ &&
Joe Perches8d73e0e2014-08-06 16:10:46 -07002550 $line =~ /^\+\s*config\s+/) {
Andi Kleen33549572010-05-24 14:33:29 -07002551 my $length = 0;
Andy Whitcroft9fe287d72010-10-26 14:23:15 -07002552 my $cnt = $realcnt;
2553 my $ln = $linenr + 1;
2554 my $f;
Andy Whitcrofta1385802012-01-10 15:10:03 -08002555 my $is_start = 0;
Andy Whitcroft9fe287d72010-10-26 14:23:15 -07002556 my $is_end = 0;
Andy Whitcrofta1385802012-01-10 15:10:03 -08002557 for (; $cnt > 0 && defined $lines[$ln - 1]; $ln++) {
Andy Whitcroft9fe287d72010-10-26 14:23:15 -07002558 $f = $lines[$ln - 1];
2559 $cnt-- if ($lines[$ln - 1] !~ /^-/);
2560 $is_end = $lines[$ln - 1] =~ /^\+/;
Andy Whitcroft9fe287d72010-10-26 14:23:15 -07002561
2562 next if ($f =~ /^-/);
Joe Perches8d73e0e2014-08-06 16:10:46 -07002563 last if (!$file && $f =~ /^\@\@/);
Andy Whitcrofta1385802012-01-10 15:10:03 -08002564
Joe Perches8d73e0e2014-08-06 16:10:46 -07002565 if ($lines[$ln - 1] =~ /^\+\s*(?:bool|tristate)\s*\"/) {
Andy Whitcrofta1385802012-01-10 15:10:03 -08002566 $is_start = 1;
Joe Perches8d73e0e2014-08-06 16:10:46 -07002567 } elsif ($lines[$ln - 1] =~ /^\+\s*(?:---)?help(?:---)?$/) {
Andy Whitcrofta1385802012-01-10 15:10:03 -08002568 $length = -1;
2569 }
2570
Andy Whitcroft9fe287d72010-10-26 14:23:15 -07002571 $f =~ s/^.//;
Andi Kleen33549572010-05-24 14:33:29 -07002572 $f =~ s/#.*//;
2573 $f =~ s/^\s+//;
2574 next if ($f =~ /^$/);
Andy Whitcroft9fe287d72010-10-26 14:23:15 -07002575 if ($f =~ /^\s*config\s/) {
2576 $is_end = 1;
2577 last;
2578 }
Andi Kleen33549572010-05-24 14:33:29 -07002579 $length++;
2580 }
Vadim Bendebury56193272014-10-13 15:51:48 -07002581 if ($is_start && $is_end && $length < $min_conf_desc_length) {
2582 WARN("CONFIG_DESCRIPTION",
2583 "please write a paragraph that describes the config symbol fully\n" . $herecurr);
2584 }
Andy Whitcrofta1385802012-01-10 15:10:03 -08002585 #print "is_start<$is_start> is_end<$is_end> length<$length>\n";
Andi Kleen33549572010-05-24 14:33:29 -07002586 }
2587
Kees Cook1ba8dfd2012-12-17 16:01:48 -08002588# discourage the addition of CONFIG_EXPERIMENTAL in Kconfig.
2589 if ($realfile =~ /Kconfig/ &&
2590 $line =~ /.\s*depends on\s+.*\bEXPERIMENTAL\b/) {
2591 WARN("CONFIG_EXPERIMENTAL",
2592 "Use of CONFIG_EXPERIMENTAL is deprecated. For alternatives, see https://lkml.org/lkml/2012/10/23/580\n");
2593 }
2594
Christoph Jaeger327953e2015-02-13 14:38:29 -08002595# discourage the use of boolean for type definition attributes of Kconfig options
2596 if ($realfile =~ /Kconfig/ &&
2597 $line =~ /^\+\s*\bboolean\b/) {
2598 WARN("CONFIG_TYPE_BOOLEAN",
2599 "Use of boolean is deprecated, please use bool instead.\n" . $herecurr);
2600 }
2601
Arnaud Lacombec68e5872011-08-15 01:07:14 -04002602 if (($realfile =~ /Makefile.*/ || $realfile =~ /Kbuild.*/) &&
2603 ($line =~ /\+(EXTRA_[A-Z]+FLAGS).*/)) {
2604 my $flag = $1;
2605 my $replacement = {
2606 'EXTRA_AFLAGS' => 'asflags-y',
2607 'EXTRA_CFLAGS' => 'ccflags-y',
2608 'EXTRA_CPPFLAGS' => 'cppflags-y',
2609 'EXTRA_LDFLAGS' => 'ldflags-y',
2610 };
2611
2612 WARN("DEPRECATED_VARIABLE",
2613 "Use of $flag is deprecated, please use \`$replacement->{$flag} instead.\n" . $herecurr) if ($replacement->{$flag});
2614 }
2615
Rob Herringbff5da42014-01-23 15:54:51 -08002616# check for DT compatible documentation
Florian Vaussard7dd05b32014-04-03 14:49:26 -07002617 if (defined $root &&
2618 (($realfile =~ /\.dtsi?$/ && $line =~ /^\+\s*compatible\s*=\s*\"/) ||
2619 ($realfile =~ /\.[ch]$/ && $line =~ /^\+.*\.compatible\s*=\s*\"/))) {
2620
Rob Herringbff5da42014-01-23 15:54:51 -08002621 my @compats = $rawline =~ /\"([a-zA-Z0-9\-\,\.\+_]+)\"/g;
2622
Florian Vaussardcc933192014-04-03 14:49:27 -07002623 my $dt_path = $root . "/Documentation/devicetree/bindings/";
2624 my $vp_file = $dt_path . "vendor-prefixes.txt";
2625
Rob Herringbff5da42014-01-23 15:54:51 -08002626 foreach my $compat (@compats) {
2627 my $compat2 = $compat;
Rob Herring185d5662014-06-04 16:12:03 -07002628 $compat2 =~ s/\,[a-zA-Z0-9]*\-/\,<\.\*>\-/;
2629 my $compat3 = $compat;
2630 $compat3 =~ s/\,([a-z]*)[0-9]*\-/\,$1<\.\*>\-/;
2631 `grep -Erq "$compat|$compat2|$compat3" $dt_path`;
Rob Herringbff5da42014-01-23 15:54:51 -08002632 if ( $? >> 8 ) {
2633 WARN("UNDOCUMENTED_DT_STRING",
2634 "DT compatible string \"$compat\" appears un-documented -- check $dt_path\n" . $herecurr);
2635 }
2636
Florian Vaussard4fbf32a2014-04-03 14:49:25 -07002637 next if $compat !~ /^([a-zA-Z0-9\-]+)\,/;
2638 my $vendor = $1;
Florian Vaussardcc933192014-04-03 14:49:27 -07002639 `grep -Eq "^$vendor\\b" $vp_file`;
Rob Herringbff5da42014-01-23 15:54:51 -08002640 if ( $? >> 8 ) {
2641 WARN("UNDOCUMENTED_DT_STRING",
Florian Vaussardcc933192014-04-03 14:49:27 -07002642 "DT compatible string vendor \"$vendor\" appears un-documented -- check $vp_file\n" . $herecurr);
Rob Herringbff5da42014-01-23 15:54:51 -08002643 }
2644 }
2645 }
2646
Andy Whitcroft5368df22008-10-15 22:02:27 -07002647# check we are in a valid source file if not then ignore this hunk
Geert Uytterhoevende4c9242014-10-13 15:51:46 -07002648 next if ($realfile !~ /\.(h|c|s|S|pl|sh|dtsi|dts)$/);
Andy Whitcroft5368df22008-10-15 22:02:27 -07002649
Joe Perches47e0c882015-06-25 15:02:57 -07002650# line length limit (with some exclusions)
2651#
2652# There are a few types of lines that may extend beyond $max_line_length:
2653# logging functions like pr_info that end in a string
2654# lines with a single string
2655# #defines that are a single string
2656#
2657# There are 3 different line length message types:
2658# LONG_LINE_COMMENT a comment starts before but extends beyond $max_linelength
2659# LONG_LINE_STRING a string starts before but extends beyond $max_line_length
2660# LONG_LINE all other lines longer than $max_line_length
2661#
2662# if LONG_LINE is ignored, the other 2 types are also ignored
2663#
2664
Joe Perchesb4749e92015-07-17 16:24:01 -07002665 if ($line =~ /^\+/ && $length > $max_line_length) {
Joe Perches47e0c882015-06-25 15:02:57 -07002666 my $msg_type = "LONG_LINE";
2667
2668 # Check the allowed long line types first
2669
2670 # logging functions that end in a string that starts
2671 # before $max_line_length
2672 if ($line =~ /^\+\s*$logFunctions\s*\(\s*(?:(?:KERN_\S+\s*|[^"]*))?($String\s*(?:|,|\)\s*;)\s*)$/ &&
2673 length(expand_tabs(substr($line, 1, length($line) - length($1) - 1))) <= $max_line_length) {
2674 $msg_type = "";
2675
2676 # lines with only strings (w/ possible termination)
2677 # #defines with only strings
2678 } elsif ($line =~ /^\+\s*$String\s*(?:\s*|,|\)\s*;)\s*$/ ||
2679 $line =~ /^\+\s*#\s*define\s+\w+\s+$String$/) {
2680 $msg_type = "";
2681
2682 # Otherwise set the alternate message types
2683
2684 # a comment starts before $max_line_length
2685 } elsif ($line =~ /($;[\s$;]*)$/ &&
2686 length(expand_tabs(substr($line, 1, length($line) - length($1) - 1))) <= $max_line_length) {
2687 $msg_type = "LONG_LINE_COMMENT"
2688
2689 # a quoted string starts before $max_line_length
2690 } elsif ($sline =~ /\s*($String(?:\s*(?:\\|,\s*|\)\s*;\s*))?)$/ &&
2691 length(expand_tabs(substr($line, 1, length($line) - length($1) - 1))) <= $max_line_length) {
2692 $msg_type = "LONG_LINE_STRING"
2693 }
2694
2695 if ($msg_type ne "" &&
2696 (show_type("LONG_LINE") || show_type($msg_type))) {
2697 WARN($msg_type,
2698 "line over $max_line_length characters\n" . $herecurr);
2699 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002700 }
2701
Andy Whitcroft8905a672007-11-28 16:21:06 -08002702# check for adding lines without a newline.
2703 if ($line =~ /^\+/ && defined $lines[$linenr] && $lines[$linenr] =~ /^\\ No newline at end of file/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07002704 WARN("MISSING_EOF_NEWLINE",
2705 "adding a line without newline at end of file\n" . $herecurr);
Andy Whitcroft8905a672007-11-28 16:21:06 -08002706 }
2707
Mike Frysinger42e41c52009-09-21 17:04:40 -07002708# Blackfin: use hi/lo macros
2709 if ($realfile =~ m@arch/blackfin/.*\.S$@) {
2710 if ($line =~ /\.[lL][[:space:]]*=.*&[[:space:]]*0x[fF][fF][fF][fF]/) {
2711 my $herevet = "$here\n" . cat_vet($line) . "\n";
Joe Perches000d1cc12011-07-25 17:13:25 -07002712 ERROR("LO_MACRO",
2713 "use the LO() macro, not (... & 0xFFFF)\n" . $herevet);
Mike Frysinger42e41c52009-09-21 17:04:40 -07002714 }
2715 if ($line =~ /\.[hH][[:space:]]*=.*>>[[:space:]]*16/) {
2716 my $herevet = "$here\n" . cat_vet($line) . "\n";
Joe Perches000d1cc12011-07-25 17:13:25 -07002717 ERROR("HI_MACRO",
2718 "use the HI() macro, not (... >> 16)\n" . $herevet);
Mike Frysinger42e41c52009-09-21 17:04:40 -07002719 }
2720 }
2721
Andy Whitcroftb9ea10d2008-10-15 22:02:24 -07002722# check we are in a valid source file C or perl if not then ignore this hunk
Geert Uytterhoevende4c9242014-10-13 15:51:46 -07002723 next if ($realfile !~ /\.(h|c|pl|dtsi|dts)$/);
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002724
2725# at the beginning of a line any tabs must come first and anything
2726# more than 8 must use tabs.
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002727 if ($rawline =~ /^\+\s* \t\s*\S/ ||
2728 $rawline =~ /^\+\s* \s*/) {
2729 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
Andy Whitcroftd2c0a232010-10-26 14:23:12 -07002730 $rpt_cleaners = 1;
Joe Perches3705ce52013-07-03 15:05:31 -07002731 if (ERROR("CODE_INDENT",
2732 "code indent should use tabs where possible\n" . $herevet) &&
2733 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07002734 $fixed[$fixlinenr] =~ s/^\+([ \t]+)/"\+" . tabify($1)/e;
Joe Perches3705ce52013-07-03 15:05:31 -07002735 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002736 }
2737
Alberto Panizzo08e44362010-03-05 13:43:54 -08002738# check for space before tabs.
2739 if ($rawline =~ /^\+/ && $rawline =~ / \t/) {
2740 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
Joe Perches3705ce52013-07-03 15:05:31 -07002741 if (WARN("SPACE_BEFORE_TAB",
2742 "please, no space before tabs\n" . $herevet) &&
2743 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07002744 while ($fixed[$fixlinenr] =~
Joe Perchesd2207cc2014-10-13 15:51:53 -07002745 s/(^\+.*) {8,8}\t/$1\t\t/) {}
Joe Perches194f66f2014-08-06 16:11:03 -07002746 while ($fixed[$fixlinenr] =~
Joe Perchesc76f4cb2014-01-23 15:54:46 -08002747 s/(^\+.*) +\t/$1\t/) {}
Joe Perches3705ce52013-07-03 15:05:31 -07002748 }
Alberto Panizzo08e44362010-03-05 13:43:54 -08002749 }
2750
Joe Perchesd1fe9c02012-03-23 15:02:16 -07002751# check for && or || at the start of a line
2752 if ($rawline =~ /^\+\s*(&&|\|\|)/) {
2753 CHK("LOGICAL_CONTINUATIONS",
2754 "Logical continuations should be on the previous line\n" . $hereprev);
2755 }
2756
2757# check multi-line statement indentation matches previous line
2758 if ($^V && $^V ge 5.10.0 &&
Joe Perches91cb5192014-04-03 14:49:32 -07002759 $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 -07002760 $prevline =~ /^\+(\t*)(.*)$/;
2761 my $oldindent = $1;
2762 my $rest = $2;
2763
2764 my $pos = pos_last_openparen($rest);
2765 if ($pos >= 0) {
Joe Perchesb34a26f2012-07-30 14:41:16 -07002766 $line =~ /^(\+| )([ \t]*)/;
2767 my $newindent = $2;
Joe Perchesd1fe9c02012-03-23 15:02:16 -07002768
2769 my $goodtabindent = $oldindent .
2770 "\t" x ($pos / 8) .
2771 " " x ($pos % 8);
2772 my $goodspaceindent = $oldindent . " " x $pos;
2773
2774 if ($newindent ne $goodtabindent &&
2775 $newindent ne $goodspaceindent) {
Joe Perches3705ce52013-07-03 15:05:31 -07002776
2777 if (CHK("PARENTHESIS_ALIGNMENT",
2778 "Alignment should match open parenthesis\n" . $hereprev) &&
2779 $fix && $line =~ /^\+/) {
Joe Perches194f66f2014-08-06 16:11:03 -07002780 $fixed[$fixlinenr] =~
Joe Perches3705ce52013-07-03 15:05:31 -07002781 s/^\+[ \t]*/\+$goodtabindent/;
2782 }
Joe Perchesd1fe9c02012-03-23 15:02:16 -07002783 }
2784 }
2785 }
2786
Joe Perches6ab3a972015-04-16 12:44:05 -07002787# check for space after cast like "(int) foo" or "(struct foo) bar"
2788# avoid checking a few false positives:
2789# "sizeof(<type>)" or "__alignof__(<type>)"
2790# function pointer declarations like "(*foo)(int) = bar;"
2791# structure definitions like "(struct foo) { 0 };"
2792# multiline macros that define functions
2793# known attributes or the __attribute__ keyword
2794 if ($line =~ /^\+(.*)\(\s*$Type\s*\)([ \t]++)((?![={]|\\$|$Attribute|__attribute__))/ &&
2795 (!defined($1) || $1 !~ /\b(?:sizeof|__alignof__)\s*$/)) {
Joe Perches3705ce52013-07-03 15:05:31 -07002796 if (CHK("SPACING",
Joe Perchesf27c95d2014-08-06 16:10:52 -07002797 "No space is necessary after a cast\n" . $herecurr) &&
Joe Perches3705ce52013-07-03 15:05:31 -07002798 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07002799 $fixed[$fixlinenr] =~
Joe Perchesf27c95d2014-08-06 16:10:52 -07002800 s/(\(\s*$Type\s*\))[ \t]+/$1/;
Joe Perches3705ce52013-07-03 15:05:31 -07002801 }
Joe Perchesaad4f612012-03-23 15:02:19 -07002802 }
2803
Joe Perches86406b12015-09-09 15:37:41 -07002804# Block comment styles
2805# Networking with an initial /*
Joe Perches05880602012-10-04 17:13:35 -07002806 if ($realfile =~ m@^(drivers/net/|net/)@ &&
Joe Perchesfdb4bcd2013-07-03 15:05:23 -07002807 $prevrawline =~ /^\+[ \t]*\/\*[ \t]*$/ &&
Joe Perches85ad9782014-04-03 14:49:20 -07002808 $rawline =~ /^\+[ \t]*\*/ &&
2809 $realline > 2) {
Joe Perches05880602012-10-04 17:13:35 -07002810 WARN("NETWORKING_BLOCK_COMMENT_STYLE",
2811 "networking block comments don't use an empty /* line, use /* Comment...\n" . $hereprev);
2812 }
2813
Joe Perches86406b12015-09-09 15:37:41 -07002814# Block comments use * on subsequent lines
2815 if ($prevline =~ /$;[ \t]*$/ && #ends in comment
2816 $prevrawline =~ /^\+.*?\/\*/ && #starting /*
Joe Perchesa605e322013-07-03 15:05:24 -07002817 $prevrawline !~ /\*\/[ \t]*$/ && #no trailing */
Joe Perches61135e92013-09-11 14:23:59 -07002818 $rawline =~ /^\+/ && #line is new
Joe Perchesa605e322013-07-03 15:05:24 -07002819 $rawline !~ /^\+[ \t]*\*/) { #no leading *
Joe Perches86406b12015-09-09 15:37:41 -07002820 WARN("BLOCK_COMMENT_STYLE",
2821 "Block comments use * on subsequent lines\n" . $hereprev);
Joe Perchesa605e322013-07-03 15:05:24 -07002822 }
2823
Joe Perches86406b12015-09-09 15:37:41 -07002824# Block comments use */ on trailing lines
2825 if ($rawline !~ m@^\+[ \t]*\*/[ \t]*$@ && #trailing */
Joe Perchesc24f9f12012-11-08 15:53:29 -08002826 $rawline !~ m@^\+.*/\*.*\*/[ \t]*$@ && #inline /*...*/
2827 $rawline !~ m@^\+.*\*{2,}/[ \t]*$@ && #trailing **/
2828 $rawline =~ m@^\+[ \t]*.+\*\/[ \t]*$@) { #non blank */
Joe Perches86406b12015-09-09 15:37:41 -07002829 WARN("BLOCK_COMMENT_STYLE",
2830 "Block comments use a trailing */ on a separate line\n" . $herecurr);
Joe Perches05880602012-10-04 17:13:35 -07002831 }
2832
Joe Perches7f619192014-08-06 16:10:39 -07002833# check for missing blank lines after struct/union declarations
2834# with exceptions for various attributes and macros
2835 if ($prevline =~ /^[\+ ]};?\s*$/ &&
2836 $line =~ /^\+/ &&
2837 !($line =~ /^\+\s*$/ ||
2838 $line =~ /^\+\s*EXPORT_SYMBOL/ ||
2839 $line =~ /^\+\s*MODULE_/i ||
2840 $line =~ /^\+\s*\#\s*(?:end|elif|else)/ ||
2841 $line =~ /^\+[a-z_]*init/ ||
2842 $line =~ /^\+\s*(?:static\s+)?[A-Z_]*ATTR/ ||
2843 $line =~ /^\+\s*DECLARE/ ||
2844 $line =~ /^\+\s*__setup/)) {
Joe Perchesd752fcc2014-08-06 16:11:05 -07002845 if (CHK("LINE_SPACING",
2846 "Please use a blank line after function/struct/union/enum declarations\n" . $hereprev) &&
2847 $fix) {
Joe Perchesf2d7e4d2014-08-06 16:11:07 -07002848 fix_insert_line($fixlinenr, "\+");
Joe Perchesd752fcc2014-08-06 16:11:05 -07002849 }
Joe Perches7f619192014-08-06 16:10:39 -07002850 }
2851
Joe Perches365dd4e2014-08-06 16:10:42 -07002852# check for multiple consecutive blank lines
2853 if ($prevline =~ /^[\+ ]\s*$/ &&
2854 $line =~ /^\+\s*$/ &&
2855 $last_blank_line != ($linenr - 1)) {
Joe Perchesd752fcc2014-08-06 16:11:05 -07002856 if (CHK("LINE_SPACING",
2857 "Please don't use multiple blank lines\n" . $hereprev) &&
2858 $fix) {
Joe Perchesf2d7e4d2014-08-06 16:11:07 -07002859 fix_delete_line($fixlinenr, $rawline);
Joe Perchesd752fcc2014-08-06 16:11:05 -07002860 }
2861
Joe Perches365dd4e2014-08-06 16:10:42 -07002862 $last_blank_line = $linenr;
2863 }
2864
Joe Perches3b617e32014-04-03 14:49:28 -07002865# check for missing blank lines after declarations
Joe Perches3f7bac02014-06-04 16:12:04 -07002866 if ($sline =~ /^\+\s+\S/ && #Not at char 1
2867 # actual declarations
2868 ($prevline =~ /^\+\s+$Declare\s*$Ident\s*[=,;:\[]/ ||
Joe Perches5a4e1fd2014-08-06 16:10:33 -07002869 # function pointer declarations
2870 $prevline =~ /^\+\s+$Declare\s*\(\s*\*\s*$Ident\s*\)\s*[=,;:\[\(]/ ||
Joe Perches3f7bac02014-06-04 16:12:04 -07002871 # foo bar; where foo is some local typedef or #define
2872 $prevline =~ /^\+\s+$Ident(?:\s+|\s*\*\s*)$Ident\s*[=,;\[]/ ||
2873 # known declaration macros
2874 $prevline =~ /^\+\s+$declaration_macros/) &&
2875 # for "else if" which can look like "$Ident $Ident"
2876 !($prevline =~ /^\+\s+$c90_Keywords\b/ ||
2877 # other possible extensions of declaration lines
2878 $prevline =~ /(?:$Compare|$Assignment|$Operators)\s*$/ ||
2879 # not starting a section or a macro "\" extended line
2880 $prevline =~ /(?:\{\s*|\\)$/) &&
2881 # looks like a declaration
2882 !($sline =~ /^\+\s+$Declare\s*$Ident\s*[=,;:\[]/ ||
Joe Perches5a4e1fd2014-08-06 16:10:33 -07002883 # function pointer declarations
2884 $sline =~ /^\+\s+$Declare\s*\(\s*\*\s*$Ident\s*\)\s*[=,;:\[\(]/ ||
Joe Perches3f7bac02014-06-04 16:12:04 -07002885 # foo bar; where foo is some local typedef or #define
2886 $sline =~ /^\+\s+$Ident(?:\s+|\s*\*\s*)$Ident\s*[=,;\[]/ ||
2887 # known declaration macros
2888 $sline =~ /^\+\s+$declaration_macros/ ||
2889 # start of struct or union or enum
Joe Perches3b617e32014-04-03 14:49:28 -07002890 $sline =~ /^\+\s+(?:union|struct|enum|typedef)\b/ ||
Joe Perches3f7bac02014-06-04 16:12:04 -07002891 # start or end of block or continuation of declaration
2892 $sline =~ /^\+\s+(?:$|[\{\}\.\#\"\?\:\(\[])/ ||
2893 # bitfield continuation
2894 $sline =~ /^\+\s+$Ident\s*:\s*\d+\s*[,;]/ ||
2895 # other possible extensions of declaration lines
2896 $sline =~ /^\+\s+\(?\s*(?:$Compare|$Assignment|$Operators)/) &&
2897 # indentation of previous and current line are the same
2898 (($prevline =~ /\+(\s+)\S/) && $sline =~ /^\+$1\S/)) {
Joe Perchesd752fcc2014-08-06 16:11:05 -07002899 if (WARN("LINE_SPACING",
2900 "Missing a blank line after declarations\n" . $hereprev) &&
2901 $fix) {
Joe Perchesf2d7e4d2014-08-06 16:11:07 -07002902 fix_insert_line($fixlinenr, "\+");
Joe Perchesd752fcc2014-08-06 16:11:05 -07002903 }
Joe Perches3b617e32014-04-03 14:49:28 -07002904 }
2905
Raffaele Recalcati5f7ddae2010-08-09 17:20:59 -07002906# check for spaces at the beginning of a line.
Andy Whitcroft6b4c5be2010-10-26 14:23:11 -07002907# Exceptions:
2908# 1) within comments
2909# 2) indented preprocessor commands
2910# 3) hanging labels
Joe Perches3705ce52013-07-03 15:05:31 -07002911 if ($rawline =~ /^\+ / && $line !~ /^\+ *(?:$;|#|$Ident:)/) {
Raffaele Recalcati5f7ddae2010-08-09 17:20:59 -07002912 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
Joe Perches3705ce52013-07-03 15:05:31 -07002913 if (WARN("LEADING_SPACE",
2914 "please, no spaces at the start of a line\n" . $herevet) &&
2915 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07002916 $fixed[$fixlinenr] =~ s/^\+([ \t]+)/"\+" . tabify($1)/e;
Joe Perches3705ce52013-07-03 15:05:31 -07002917 }
Raffaele Recalcati5f7ddae2010-08-09 17:20:59 -07002918 }
2919
Andy Whitcroftb9ea10d2008-10-15 22:02:24 -07002920# check we are in a valid C source file if not then ignore this hunk
2921 next if ($realfile !~ /\.(h|c)$/);
2922
Joe Perches032a4c02014-08-06 16:10:29 -07002923# check indentation of any line with a bare else
Joe Perches840080a2014-10-13 15:51:59 -07002924# (but not if it is a multiple line "if (foo) return bar; else return baz;")
Joe Perches032a4c02014-08-06 16:10:29 -07002925# if the previous line is a break or return and is indented 1 tab more...
2926 if ($sline =~ /^\+([\t]+)(?:}[ \t]*)?else(?:[ \t]*{)?\s*$/) {
2927 my $tabs = length($1) + 1;
Joe Perches840080a2014-10-13 15:51:59 -07002928 if ($prevline =~ /^\+\t{$tabs,$tabs}break\b/ ||
2929 ($prevline =~ /^\+\t{$tabs,$tabs}return\b/ &&
2930 defined $lines[$linenr] &&
2931 $lines[$linenr] !~ /^[ \+]\t{$tabs,$tabs}return/)) {
Joe Perches032a4c02014-08-06 16:10:29 -07002932 WARN("UNNECESSARY_ELSE",
2933 "else is not generally useful after a break or return\n" . $hereprev);
2934 }
2935 }
2936
Joe Perchesc00df192014-08-06 16:11:01 -07002937# check indentation of a line with a break;
2938# if the previous line is a goto or return and is indented the same # of tabs
2939 if ($sline =~ /^\+([\t]+)break\s*;\s*$/) {
2940 my $tabs = $1;
2941 if ($prevline =~ /^\+$tabs(?:goto|return)\b/) {
2942 WARN("UNNECESSARY_BREAK",
2943 "break is not useful after a goto or return\n" . $hereprev);
2944 }
2945 }
2946
Kees Cook1ba8dfd2012-12-17 16:01:48 -08002947# discourage the addition of CONFIG_EXPERIMENTAL in #if(def).
2948 if ($line =~ /^\+\s*\#\s*if.*\bCONFIG_EXPERIMENTAL\b/) {
2949 WARN("CONFIG_EXPERIMENTAL",
2950 "Use of CONFIG_EXPERIMENTAL is deprecated. For alternatives, see https://lkml.org/lkml/2012/10/23/580\n");
2951 }
2952
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002953# check for RCS/CVS revision markers
Andy Whitcroftcf655042008-03-04 14:28:20 -08002954 if ($rawline =~ /^\+.*\$(Revision|Log|Id)(?:\$|)/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07002955 WARN("CVS_KEYWORD",
2956 "CVS style keyword markers, these will _not_ be updated\n". $herecurr);
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002957 }
Andy Whitcroft22f2a2e2007-08-10 13:01:03 -07002958
Mike Frysinger42e41c52009-09-21 17:04:40 -07002959# Blackfin: don't use __builtin_bfin_[cs]sync
2960 if ($line =~ /__builtin_bfin_csync/) {
2961 my $herevet = "$here\n" . cat_vet($line) . "\n";
Joe Perches000d1cc12011-07-25 17:13:25 -07002962 ERROR("CSYNC",
2963 "use the CSYNC() macro in asm/blackfin.h\n" . $herevet);
Mike Frysinger42e41c52009-09-21 17:04:40 -07002964 }
2965 if ($line =~ /__builtin_bfin_ssync/) {
2966 my $herevet = "$here\n" . cat_vet($line) . "\n";
Joe Perches000d1cc12011-07-25 17:13:25 -07002967 ERROR("SSYNC",
2968 "use the SSYNC() macro in asm/blackfin.h\n" . $herevet);
Mike Frysinger42e41c52009-09-21 17:04:40 -07002969 }
2970
Joe Perches56e77d72013-02-21 16:44:14 -08002971# check for old HOTPLUG __dev<foo> section markings
2972 if ($line =~ /\b(__dev(init|exit)(data|const|))\b/) {
2973 WARN("HOTPLUG_SECTION",
2974 "Using $1 is unnecessary\n" . $herecurr);
2975 }
2976
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07002977# Check for potential 'bare' types
Andy Whitcroft2b474a12009-10-26 16:50:16 -07002978 my ($stat, $cond, $line_nr_next, $remain_next, $off_next,
2979 $realline_next);
Andy Whitcroft3e469cd2012-01-10 15:10:01 -08002980#print "LINE<$line>\n";
2981 if ($linenr >= $suppress_statement &&
Joe Perches1b5539b2013-09-11 14:24:03 -07002982 $realcnt && $sline =~ /.\s*\S/) {
Andy Whitcroft170d3a22008-10-15 22:02:30 -07002983 ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
Andy Whitcroftf5fe35d2008-07-23 21:29:03 -07002984 ctx_statement_block($linenr, $realcnt, 0);
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07002985 $stat =~ s/\n./\n /g;
2986 $cond =~ s/\n./\n /g;
2987
Andy Whitcroft3e469cd2012-01-10 15:10:01 -08002988#print "linenr<$linenr> <$stat>\n";
2989 # If this statement has no statement boundaries within
2990 # it there is no point in retrying a statement scan
2991 # until we hit end of it.
2992 my $frag = $stat; $frag =~ s/;+\s*$//;
2993 if ($frag !~ /(?:{|;)/) {
2994#print "skip<$line_nr_next>\n";
2995 $suppress_statement = $line_nr_next;
2996 }
Andy Whitcroftf74bd192012-01-10 15:09:54 -08002997
Andy Whitcroft2b474a12009-10-26 16:50:16 -07002998 # Find the real next line.
2999 $realline_next = $line_nr_next;
3000 if (defined $realline_next &&
3001 (!defined $lines[$realline_next - 1] ||
3002 substr($lines[$realline_next - 1], $off_next) =~ /^\s*$/)) {
3003 $realline_next++;
3004 }
3005
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07003006 my $s = $stat;
3007 $s =~ s/{.*$//s;
Andy Whitcroftcf655042008-03-04 14:28:20 -08003008
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08003009 # Ignore goto labels.
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07003010 if ($s =~ /$Ident:\*$/s) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08003011
3012 # Ignore functions being called
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07003013 } elsif ($s =~ /^.\s*$Ident\s*\(/s) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08003014
Andy Whitcroft463f2862009-09-21 17:04:34 -07003015 } elsif ($s =~ /^.\s*else\b/s) {
3016
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07003017 # declarations always start with types
Andy Whitcroftd2506582008-07-23 21:29:09 -07003018 } 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 -07003019 my $type = $1;
3020 $type =~ s/\s+/ /g;
3021 possible($type, "A:" . $s);
3022
Andy Whitcroft8905a672007-11-28 16:21:06 -08003023 # definitions in global scope can only start with types
Andy Whitcrofta6a840622008-10-15 22:02:30 -07003024 } elsif ($s =~ /^.(?:$Storage\s+)?(?:$Inline\s+)?(?:const\s+)?($Ident)\b\s*(?!:)/s) {
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07003025 possible($1, "B:" . $s);
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08003026 }
Andy Whitcroft8905a672007-11-28 16:21:06 -08003027
3028 # any (foo ... *) is a pointer cast, and foo is a type
Andy Whitcroft65863862009-01-06 14:41:21 -08003029 while ($s =~ /\(($Ident)(?:\s+$Sparse)*[\s\*]+\s*\)/sg) {
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07003030 possible($1, "C:" . $s);
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07003031 }
Andy Whitcroft8905a672007-11-28 16:21:06 -08003032
3033 # Check for any sort of function declaration.
3034 # int foo(something bar, other baz);
3035 # void (*store_gdt)(x86_descr_ptr *);
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07003036 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 -08003037 my ($name_len) = length($1);
Andy Whitcroft8905a672007-11-28 16:21:06 -08003038
Andy Whitcroftcf655042008-03-04 14:28:20 -08003039 my $ctx = $s;
Andy Whitcroft773647a2008-03-28 14:15:58 -07003040 substr($ctx, 0, $name_len + 1, '');
Andy Whitcroft8905a672007-11-28 16:21:06 -08003041 $ctx =~ s/\)[^\)]*$//;
Andy Whitcroftcf655042008-03-04 14:28:20 -08003042
Andy Whitcroft8905a672007-11-28 16:21:06 -08003043 for my $arg (split(/\s*,\s*/, $ctx)) {
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07003044 if ($arg =~ /^(?:const\s+)?($Ident)(?:\s+$Sparse)*\s*\**\s*(:?\b$Ident)?$/s || $arg =~ /^($Ident)$/s) {
Andy Whitcroft8905a672007-11-28 16:21:06 -08003045
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07003046 possible($1, "D:" . $s);
Andy Whitcroft8905a672007-11-28 16:21:06 -08003047 }
3048 }
3049 }
3050
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07003051 }
3052
Andy Whitcroft653d4872007-06-23 17:16:34 -07003053#
3054# Checks which may be anchored in the context.
3055#
3056
3057# Check for switch () and associated case and default
3058# statements should be at the same indent.
Andy Whitcroft00df3442007-06-08 13:47:06 -07003059 if ($line=~/\bswitch\s*\(.*\)/) {
3060 my $err = '';
3061 my $sep = '';
3062 my @ctx = ctx_block_outer($linenr, $realcnt);
3063 shift(@ctx);
3064 for my $ctx (@ctx) {
3065 my ($clen, $cindent) = line_stats($ctx);
3066 if ($ctx =~ /^\+\s*(case\s+|default:)/ &&
3067 $indent != $cindent) {
3068 $err .= "$sep$ctx\n";
3069 $sep = '';
3070 } else {
3071 $sep = "[...]\n";
3072 }
3073 }
3074 if ($err ne '') {
Joe Perches000d1cc12011-07-25 17:13:25 -07003075 ERROR("SWITCH_CASE_INDENT_LEVEL",
3076 "switch and case should be at the same indent\n$hereline$err");
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07003077 }
3078 }
3079
3080# if/while/etc brace do not go on next line, unless defining a do while loop,
3081# or if that brace on the next line is for something else
Joe Perches0fe3dc22014-08-06 16:11:16 -07003082 if ($line =~ /(.*)\b((?:if|while|for|switch|(?:[a-z_]+|)for_each[a-z_]+)\s*\(|do\b|else\b)/ && $line !~ /^.\s*\#/) {
Andy Whitcroft773647a2008-03-28 14:15:58 -07003083 my $pre_ctx = "$1$2";
3084
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07003085 my ($level, @ctx) = ctx_statement_level($linenr, $realcnt, 0);
Joe Perches8eef05d2012-02-03 15:20:39 -08003086
3087 if ($line =~ /^\+\t{6,}/) {
3088 WARN("DEEP_INDENTATION",
3089 "Too many leading tabs - consider code refactoring\n" . $herecurr);
3090 }
3091
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07003092 my $ctx_cnt = $realcnt - $#ctx - 1;
3093 my $ctx = join("\n", @ctx);
3094
Andy Whitcroft548596d2008-07-23 21:29:01 -07003095 my $ctx_ln = $linenr;
3096 my $ctx_skip = $realcnt;
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07003097
Andy Whitcroft548596d2008-07-23 21:29:01 -07003098 while ($ctx_skip > $ctx_cnt || ($ctx_skip == $ctx_cnt &&
3099 defined $lines[$ctx_ln - 1] &&
3100 $lines[$ctx_ln - 1] =~ /^-/)) {
3101 ##print "SKIP<$ctx_skip> CNT<$ctx_cnt>\n";
3102 $ctx_skip-- if (!defined $lines[$ctx_ln - 1] || $lines[$ctx_ln - 1] !~ /^-/);
Andy Whitcroft773647a2008-03-28 14:15:58 -07003103 $ctx_ln++;
3104 }
Andy Whitcroft548596d2008-07-23 21:29:01 -07003105
Andy Whitcroft53210162008-07-23 21:29:03 -07003106 #print "realcnt<$realcnt> ctx_cnt<$ctx_cnt>\n";
3107 #print "pre<$pre_ctx>\nline<$line>\nctx<$ctx>\nnext<$lines[$ctx_ln - 1]>\n";
Andy Whitcroft773647a2008-03-28 14:15:58 -07003108
Joe Perchesd752fcc2014-08-06 16:11:05 -07003109 if ($ctx !~ /{\s*/ && defined($lines[$ctx_ln - 1]) && $lines[$ctx_ln - 1] =~ /^\+\s*{/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003110 ERROR("OPEN_BRACE",
3111 "that open brace { should be on the previous line\n" .
Andy Whitcroft01464f32010-10-26 14:23:19 -07003112 "$here\n$ctx\n$rawlines[$ctx_ln - 1]\n");
Andy Whitcroft00df3442007-06-08 13:47:06 -07003113 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07003114 if ($level == 0 && $pre_ctx !~ /}\s*while\s*\($/ &&
3115 $ctx =~ /\)\s*\;\s*$/ &&
3116 defined $lines[$ctx_ln - 1])
3117 {
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07003118 my ($nlength, $nindent) = line_stats($lines[$ctx_ln - 1]);
3119 if ($nindent > $indent) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003120 WARN("TRAILING_SEMICOLON",
3121 "trailing semicolon indicates no statements, indent implies otherwise\n" .
Andy Whitcroft01464f32010-10-26 14:23:19 -07003122 "$here\n$ctx\n$rawlines[$ctx_ln - 1]\n");
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07003123 }
3124 }
Andy Whitcroft00df3442007-06-08 13:47:06 -07003125 }
3126
Andy Whitcroft4d001e42008-10-15 22:02:21 -07003127# Check relative indent for conditionals and blocks.
Joe Perches0fe3dc22014-08-06 16:11:16 -07003128 if ($line =~ /\b(?:(?:if|while|for|(?:[a-z_]+|)for_each[a-z_]+)\s*\(|do\b)/ && $line !~ /^.\s*#/ && $line !~ /\}\s*while\s*/) {
Andy Whitcroft3e469cd2012-01-10 15:10:01 -08003129 ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
3130 ctx_statement_block($linenr, $realcnt, 0)
3131 if (!defined $stat);
Andy Whitcroft4d001e42008-10-15 22:02:21 -07003132 my ($s, $c) = ($stat, $cond);
3133
3134 substr($s, 0, length($c), '');
3135
Joe Perches9f5af482015-09-09 15:37:30 -07003136 # remove inline comments
3137 $s =~ s/$;/ /g;
3138 $c =~ s/$;/ /g;
Andy Whitcroft4d001e42008-10-15 22:02:21 -07003139
3140 # Find out how long the conditional actually is.
Andy Whitcroft6f779c12008-10-15 22:02:27 -07003141 my @newlines = ($c =~ /\n/gs);
3142 my $cond_lines = 1 + $#newlines;
Andy Whitcroft4d001e42008-10-15 22:02:21 -07003143
Joe Perches9f5af482015-09-09 15:37:30 -07003144 # Make sure we remove the line prefixes as we have
3145 # none on the first line, and are going to readd them
3146 # where necessary.
3147 $s =~ s/\n./\n/gs;
3148 while ($s =~ /\n\s+\\\n/) {
3149 $cond_lines += $s =~ s/\n\s+\\\n/\n/g;
3150 }
3151
Andy Whitcroft4d001e42008-10-15 22:02:21 -07003152 # We want to check the first line inside the block
3153 # starting at the end of the conditional, so remove:
3154 # 1) any blank line termination
3155 # 2) any opening brace { on end of the line
3156 # 3) any do (...) {
3157 my $continuation = 0;
3158 my $check = 0;
3159 $s =~ s/^.*\bdo\b//;
3160 $s =~ s/^\s*{//;
3161 if ($s =~ s/^\s*\\//) {
3162 $continuation = 1;
3163 }
Andy Whitcroft9bd49ef2008-10-15 22:02:22 -07003164 if ($s =~ s/^\s*?\n//) {
Andy Whitcroft4d001e42008-10-15 22:02:21 -07003165 $check = 1;
3166 $cond_lines++;
3167 }
3168
3169 # Also ignore a loop construct at the end of a
3170 # preprocessor statement.
3171 if (($prevline =~ /^.\s*#\s*define\s/ ||
3172 $prevline =~ /\\\s*$/) && $continuation == 0) {
3173 $check = 0;
3174 }
3175
Andy Whitcroft9bd49ef2008-10-15 22:02:22 -07003176 my $cond_ptr = -1;
Andy Whitcroft740504c2008-10-15 22:02:35 -07003177 $continuation = 0;
Andy Whitcroft9bd49ef2008-10-15 22:02:22 -07003178 while ($cond_ptr != $cond_lines) {
3179 $cond_ptr = $cond_lines;
Andy Whitcroft4d001e42008-10-15 22:02:21 -07003180
Andy Whitcroftf16fa282008-10-15 22:02:32 -07003181 # If we see an #else/#elif then the code
3182 # is not linear.
3183 if ($s =~ /^\s*\#\s*(?:else|elif)/) {
3184 $check = 0;
3185 }
3186
Andy Whitcroft9bd49ef2008-10-15 22:02:22 -07003187 # Ignore:
3188 # 1) blank lines, they should be at 0,
3189 # 2) preprocessor lines, and
3190 # 3) labels.
Andy Whitcroft740504c2008-10-15 22:02:35 -07003191 if ($continuation ||
3192 $s =~ /^\s*?\n/ ||
Andy Whitcroft9bd49ef2008-10-15 22:02:22 -07003193 $s =~ /^\s*#\s*?/ ||
3194 $s =~ /^\s*$Ident\s*:/) {
Andy Whitcroft740504c2008-10-15 22:02:35 -07003195 $continuation = ($s =~ /^.*?\\\n/) ? 1 : 0;
Andy Whitcroft30dad6e2009-09-21 17:04:36 -07003196 if ($s =~ s/^.*?\n//) {
3197 $cond_lines++;
3198 }
Andy Whitcroft9bd49ef2008-10-15 22:02:22 -07003199 }
Andy Whitcroft4d001e42008-10-15 22:02:21 -07003200 }
3201
3202 my (undef, $sindent) = line_stats("+" . $s);
3203 my $stat_real = raw_line($linenr, $cond_lines);
3204
3205 # Check if either of these lines are modified, else
3206 # this is not this patch's fault.
3207 if (!defined($stat_real) ||
3208 $stat !~ /^\+/ && $stat_real !~ /^\+/) {
3209 $check = 0;
3210 }
3211 if (defined($stat_real) && $cond_lines > 1) {
3212 $stat_real = "[...]\n$stat_real";
3213 }
3214
Andy Whitcroft9bd49ef2008-10-15 22:02:22 -07003215 #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 -07003216
Joe Perches9f5af482015-09-09 15:37:30 -07003217 if ($check && $s ne '' &&
3218 (($sindent % 8) != 0 ||
3219 ($sindent < $indent) ||
3220 ($sindent > $indent + 8))) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003221 WARN("SUSPECT_CODE_INDENT",
3222 "suspect code indent for conditional statements ($indent, $sindent)\n" . $herecurr . "$stat_real\n");
Andy Whitcroft4d001e42008-10-15 22:02:21 -07003223 }
3224 }
3225
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07003226 # Track the 'values' across context and added lines.
3227 my $opline = $line; $opline =~ s/^./ /;
Andy Whitcroft1f65f942008-07-23 21:29:10 -07003228 my ($curr_values, $curr_vars) =
3229 annotate_values($opline . "\n", $prev_values);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07003230 $curr_values = $prev_values . $curr_values;
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08003231 if ($dbg_values) {
3232 my $outline = $opline; $outline =~ s/\t/ /g;
Andy Whitcroftcf655042008-03-04 14:28:20 -08003233 print "$linenr > .$outline\n";
3234 print "$linenr > $curr_values\n";
Andy Whitcroft1f65f942008-07-23 21:29:10 -07003235 print "$linenr > $curr_vars\n";
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08003236 }
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07003237 $prev_values = substr($curr_values, -1);
3238
Andy Whitcroft00df3442007-06-08 13:47:06 -07003239#ignore lines not being added
Joe Perches3705ce52013-07-03 15:05:31 -07003240 next if ($line =~ /^[^\+]/);
Andy Whitcroft00df3442007-06-08 13:47:06 -07003241
Andy Whitcroft653d4872007-06-23 17:16:34 -07003242# TEST: allow direct testing of the type matcher.
Andy Whitcroft7429c692008-07-23 21:29:06 -07003243 if ($dbg_type) {
3244 if ($line =~ /^.\s*$Declare\s*$/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003245 ERROR("TEST_TYPE",
3246 "TEST: is type\n" . $herecurr);
Andy Whitcroft7429c692008-07-23 21:29:06 -07003247 } elsif ($dbg_type > 1 && $line =~ /^.+($Declare)/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003248 ERROR("TEST_NOT_TYPE",
3249 "TEST: is not type ($1 is)\n". $herecurr);
Andy Whitcroft7429c692008-07-23 21:29:06 -07003250 }
Andy Whitcroft653d4872007-06-23 17:16:34 -07003251 next;
3252 }
Andy Whitcrofta1ef2772008-10-15 22:02:17 -07003253# TEST: allow direct testing of the attribute matcher.
3254 if ($dbg_attr) {
Andy Whitcroft9360b0e2009-02-27 14:03:08 -08003255 if ($line =~ /^.\s*$Modifier\s*$/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003256 ERROR("TEST_ATTR",
3257 "TEST: is attr\n" . $herecurr);
Andy Whitcroft9360b0e2009-02-27 14:03:08 -08003258 } elsif ($dbg_attr > 1 && $line =~ /^.+($Modifier)/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003259 ERROR("TEST_NOT_ATTR",
3260 "TEST: is not attr ($1 is)\n". $herecurr);
Andy Whitcrofta1ef2772008-10-15 22:02:17 -07003261 }
3262 next;
3263 }
Andy Whitcroft653d4872007-06-23 17:16:34 -07003264
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07003265# check for initialisation to aggregates open brace on the next line
Andy Whitcroft99423c22009-10-26 16:50:15 -07003266 if ($line =~ /^.\s*{/ &&
3267 $prevline =~ /(?:^|[^=])=\s*$/) {
Joe Perchesd752fcc2014-08-06 16:11:05 -07003268 if (ERROR("OPEN_BRACE",
3269 "that open brace { should be on the previous line\n" . $hereprev) &&
Joe Perchesf2d7e4d2014-08-06 16:11:07 -07003270 $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
3271 fix_delete_line($fixlinenr - 1, $prevrawline);
3272 fix_delete_line($fixlinenr, $rawline);
Joe Perchesd752fcc2014-08-06 16:11:05 -07003273 my $fixedline = $prevrawline;
3274 $fixedline =~ s/\s*=\s*$/ = {/;
Joe Perchesf2d7e4d2014-08-06 16:11:07 -07003275 fix_insert_line($fixlinenr, $fixedline);
Joe Perchesd752fcc2014-08-06 16:11:05 -07003276 $fixedline = $line;
3277 $fixedline =~ s/^(.\s*){\s*/$1/;
Joe Perchesf2d7e4d2014-08-06 16:11:07 -07003278 fix_insert_line($fixlinenr, $fixedline);
Joe Perchesd752fcc2014-08-06 16:11:05 -07003279 }
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07003280 }
3281
Andy Whitcroft653d4872007-06-23 17:16:34 -07003282#
3283# Checks which are anchored on the added line.
3284#
3285
3286# check for malformed paths in #include statements (uses RAW line)
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07003287 if ($rawline =~ m{^.\s*\#\s*include\s+[<"](.*)[">]}) {
Andy Whitcroft653d4872007-06-23 17:16:34 -07003288 my $path = $1;
3289 if ($path =~ m{//}) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003290 ERROR("MALFORMED_INCLUDE",
Joe Perches495e9d82012-12-20 15:05:37 -08003291 "malformed #include filename\n" . $herecurr);
3292 }
3293 if ($path =~ "^uapi/" && $realfile =~ m@\binclude/uapi/@) {
3294 ERROR("UAPI_INCLUDE",
3295 "No #include in ...include/uapi/... should use a uapi/ path prefix\n" . $herecurr);
Andy Whitcroft653d4872007-06-23 17:16:34 -07003296 }
Andy Whitcroft653d4872007-06-23 17:16:34 -07003297 }
Andy Whitcroft00df3442007-06-08 13:47:06 -07003298
3299# no C99 // comments
3300 if ($line =~ m{//}) {
Joe Perches3705ce52013-07-03 15:05:31 -07003301 if (ERROR("C99_COMMENTS",
3302 "do not use C99 // comments\n" . $herecurr) &&
3303 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07003304 my $line = $fixed[$fixlinenr];
Joe Perches3705ce52013-07-03 15:05:31 -07003305 if ($line =~ /\/\/(.*)$/) {
3306 my $comment = trim($1);
Joe Perches194f66f2014-08-06 16:11:03 -07003307 $fixed[$fixlinenr] =~ s@\/\/(.*)$@/\* $comment \*/@;
Joe Perches3705ce52013-07-03 15:05:31 -07003308 }
3309 }
Andy Whitcroft00df3442007-06-08 13:47:06 -07003310 }
3311 # Remove C99 comments.
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003312 $line =~ s@//.*@@;
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07003313 $opline =~ s@//.*@@;
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003314
Andy Whitcroft2b474a12009-10-26 16:50:16 -07003315# EXPORT_SYMBOL should immediately follow the thing it is exporting, consider
3316# the whole statement.
3317#print "APW <$lines[$realline_next - 1]>\n";
3318 if (defined $realline_next &&
3319 exists $lines[$realline_next - 1] &&
3320 !defined $suppress_export{$realline_next} &&
3321 ($lines[$realline_next - 1] =~ /EXPORT_SYMBOL.*\((.*)\)/ ||
3322 $lines[$realline_next - 1] =~ /EXPORT_UNUSED_SYMBOL.*\((.*)\)/)) {
Andy Whitcroft3cbf62d2010-10-26 14:23:18 -07003323 # Handle definitions which produce identifiers with
3324 # a prefix:
3325 # XXX(foo);
3326 # EXPORT_SYMBOL(something_foo);
Andy Whitcroft653d4872007-06-23 17:16:34 -07003327 my $name = $1;
Andy Whitcroft87a53872012-01-10 15:10:04 -08003328 if ($stat =~ /^(?:.\s*}\s*\n)?.([A-Z_]+)\s*\(\s*($Ident)/ &&
Andy Whitcroft3cbf62d2010-10-26 14:23:18 -07003329 $name =~ /^${Ident}_$2/) {
3330#print "FOO C name<$name>\n";
3331 $suppress_export{$realline_next} = 1;
3332
3333 } elsif ($stat !~ /(?:
Andy Whitcroft2b474a12009-10-26 16:50:16 -07003334 \n.}\s*$|
Andy Whitcroft48012052008-10-15 22:02:34 -07003335 ^.DEFINE_$Ident\(\Q$name\E\)|
3336 ^.DECLARE_$Ident\(\Q$name\E\)|
3337 ^.LIST_HEAD\(\Q$name\E\)|
Andy Whitcroft2b474a12009-10-26 16:50:16 -07003338 ^.(?:$Storage\s+)?$Type\s*\(\s*\*\s*\Q$name\E\s*\)\s*\(|
3339 \b\Q$name\E(?:\s+$Attribute)*\s*(?:;|=|\[|\()
Andy Whitcroft48012052008-10-15 22:02:34 -07003340 )/x) {
Andy Whitcroft2b474a12009-10-26 16:50:16 -07003341#print "FOO A<$lines[$realline_next - 1]> stat<$stat> name<$name>\n";
3342 $suppress_export{$realline_next} = 2;
3343 } else {
3344 $suppress_export{$realline_next} = 1;
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003345 }
3346 }
Andy Whitcroft2b474a12009-10-26 16:50:16 -07003347 if (!defined $suppress_export{$linenr} &&
3348 $prevline =~ /^.\s*$/ &&
3349 ($line =~ /EXPORT_SYMBOL.*\((.*)\)/ ||
3350 $line =~ /EXPORT_UNUSED_SYMBOL.*\((.*)\)/)) {
3351#print "FOO B <$lines[$linenr - 1]>\n";
3352 $suppress_export{$linenr} = 2;
3353 }
3354 if (defined $suppress_export{$linenr} &&
3355 $suppress_export{$linenr} == 2) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003356 WARN("EXPORT_SYMBOL",
3357 "EXPORT_SYMBOL(foo); should immediately follow its function/variable\n" . $herecurr);
Andy Whitcroft2b474a12009-10-26 16:50:16 -07003358 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003359
Joe Eloff5150bda2010-08-09 17:21:00 -07003360# check for global initialisers.
Joe Perches6d32f7a2015-11-06 16:31:37 -08003361 if ($line =~ /^\+$Type\s*$Ident(?:\s+$Modifier)*\s*=\s*($zero_initializer)\s*;/) {
Joe Perchesd5e616f2013-09-11 14:23:54 -07003362 if (ERROR("GLOBAL_INITIALISERS",
Joe Perches6d32f7a2015-11-06 16:31:37 -08003363 "do not initialise globals to $1\n" . $herecurr) &&
Joe Perchesd5e616f2013-09-11 14:23:54 -07003364 $fix) {
Joe Perches6d32f7a2015-11-06 16:31:37 -08003365 $fixed[$fixlinenr] =~ s/(^.$Type\s*$Ident(?:\s+$Modifier)*)\s*=\s*$zero_initializer\s*;/$1;/;
Joe Perchesd5e616f2013-09-11 14:23:54 -07003366 }
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07003367 }
Andy Whitcroft653d4872007-06-23 17:16:34 -07003368# check for static initialisers.
Joe Perches6d32f7a2015-11-06 16:31:37 -08003369 if ($line =~ /^\+.*\bstatic\s.*=\s*($zero_initializer)\s*;/) {
Joe Perchesd5e616f2013-09-11 14:23:54 -07003370 if (ERROR("INITIALISED_STATIC",
Joe Perches6d32f7a2015-11-06 16:31:37 -08003371 "do not initialise statics to $1\n" .
Joe Perchesd5e616f2013-09-11 14:23:54 -07003372 $herecurr) &&
3373 $fix) {
Joe Perches6d32f7a2015-11-06 16:31:37 -08003374 $fixed[$fixlinenr] =~ s/(\bstatic\s.*?)\s*=\s*$zero_initializer\s*;/$1;/;
Joe Perchesd5e616f2013-09-11 14:23:54 -07003375 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003376 }
3377
Joe Perches18130872014-08-06 16:11:22 -07003378# check for misordered declarations of char/short/int/long with signed/unsigned
3379 while ($sline =~ m{(\b$TypeMisordered\b)}g) {
3380 my $tmp = trim($1);
3381 WARN("MISORDERED_TYPE",
3382 "type '$tmp' should be specified in [[un]signed] [short|int|long|long long] order\n" . $herecurr);
3383 }
3384
Joe Perchescb710ec2010-10-26 14:23:20 -07003385# check for static const char * arrays.
3386 if ($line =~ /\bstatic\s+const\s+char\s*\*\s*(\w+)\s*\[\s*\]\s*=\s*/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003387 WARN("STATIC_CONST_CHAR_ARRAY",
3388 "static const char * array should probably be static const char * const\n" .
Joe Perchescb710ec2010-10-26 14:23:20 -07003389 $herecurr);
3390 }
3391
3392# check for static char foo[] = "bar" declarations.
3393 if ($line =~ /\bstatic\s+char\s+(\w+)\s*\[\s*\]\s*=\s*"/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003394 WARN("STATIC_CONST_CHAR_ARRAY",
3395 "static char array declaration should probably be static const char\n" .
Joe Perchescb710ec2010-10-26 14:23:20 -07003396 $herecurr);
3397 }
3398
Joe Perchesab7e23f2015-04-16 12:44:22 -07003399# check for const <foo> const where <foo> is not a pointer or array type
3400 if ($sline =~ /\bconst\s+($BasicType)\s+const\b/) {
3401 my $found = $1;
3402 if ($sline =~ /\bconst\s+\Q$found\E\s+const\b\s*\*/) {
3403 WARN("CONST_CONST",
3404 "'const $found const *' should probably be 'const $found * const'\n" . $herecurr);
3405 } elsif ($sline !~ /\bconst\s+\Q$found\E\s+const\s+\w+\s*\[/) {
3406 WARN("CONST_CONST",
3407 "'const $found const' should probably be 'const $found'\n" . $herecurr);
3408 }
3409 }
3410
Joe Perches9b0fa602014-04-03 14:49:18 -07003411# check for non-global char *foo[] = {"bar", ...} declarations.
3412 if ($line =~ /^.\s+(?:static\s+|const\s+)?char\s+\*\s*\w+\s*\[\s*\]\s*=\s*\{/) {
3413 WARN("STATIC_CONST_CHAR_ARRAY",
3414 "char * array declaration might be better as static const\n" .
3415 $herecurr);
3416 }
3417
Joe Perchesb598b672015-04-16 12:44:36 -07003418# check for sizeof(foo)/sizeof(foo[0]) that could be ARRAY_SIZE(foo)
3419 if ($line =~ m@\bsizeof\s*\(\s*($Lval)\s*\)@) {
3420 my $array = $1;
3421 if ($line =~ m@\b(sizeof\s*\(\s*\Q$array\E\s*\)\s*/\s*sizeof\s*\(\s*\Q$array\E\s*\[\s*0\s*\]\s*\))@) {
3422 my $array_div = $1;
3423 if (WARN("ARRAY_SIZE",
3424 "Prefer ARRAY_SIZE($array)\n" . $herecurr) &&
3425 $fix) {
3426 $fixed[$fixlinenr] =~ s/\Q$array_div\E/ARRAY_SIZE($array)/;
3427 }
3428 }
3429 }
3430
Joe Perchesb36190c2014-01-27 17:07:18 -08003431# check for function declarations without arguments like "int foo()"
3432 if ($line =~ /(\b$Type\s+$Ident)\s*\(\s*\)/) {
3433 if (ERROR("FUNCTION_WITHOUT_ARGS",
3434 "Bad function definition - $1() should probably be $1(void)\n" . $herecurr) &&
3435 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07003436 $fixed[$fixlinenr] =~ s/(\b($Type)\s+($Ident))\s*\(\s*\)/$2 $3(void)/;
Joe Perchesb36190c2014-01-27 17:07:18 -08003437 }
3438 }
3439
Joe Perches92e112f2013-12-13 11:36:22 -07003440# check for uses of DEFINE_PCI_DEVICE_TABLE
3441 if ($line =~ /\bDEFINE_PCI_DEVICE_TABLE\s*\(\s*(\w+)\s*\)\s*=/) {
3442 if (WARN("DEFINE_PCI_DEVICE_TABLE",
3443 "Prefer struct pci_device_id over deprecated DEFINE_PCI_DEVICE_TABLE\n" . $herecurr) &&
3444 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07003445 $fixed[$fixlinenr] =~ s/\b(?:static\s+|)DEFINE_PCI_DEVICE_TABLE\s*\(\s*(\w+)\s*\)\s*=\s*/static const struct pci_device_id $1\[\] = /;
Joe Perches92e112f2013-12-13 11:36:22 -07003446 }
Joe Perches93ed0e22010-10-26 14:23:21 -07003447 }
3448
Andy Whitcroft653d4872007-06-23 17:16:34 -07003449# check for new typedefs, only function parameters and sparse annotations
3450# make sense.
3451 if ($line =~ /\btypedef\s/ &&
Andy Whitcroft80545762009-01-06 14:41:26 -08003452 $line !~ /\btypedef\s+$Type\s*\(\s*\*?$Ident\s*\)\s*\(/ &&
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07003453 $line !~ /\btypedef\s+$Type\s+$Ident\s*\(/ &&
Andy Whitcroft8ed22ca2008-10-15 22:02:32 -07003454 $line !~ /\b$typeTypedefs\b/ &&
Andy Whitcroft653d4872007-06-23 17:16:34 -07003455 $line !~ /\b__bitwise(?:__|)\b/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003456 WARN("NEW_TYPEDEFS",
3457 "do not add new typedefs\n" . $herecurr);
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003458 }
3459
3460# * goes on variable not on type
Andy Whitcroft65863862009-01-06 14:41:21 -08003461 # (char*[ const])
Andy Whitcroftbfcb2cc2012-01-10 15:10:15 -08003462 while ($line =~ m{(\($NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)\))}g) {
3463 #print "AA<$1>\n";
Joe Perches3705ce52013-07-03 15:05:31 -07003464 my ($ident, $from, $to) = ($1, $2, $2);
Andy Whitcroftd8aaf122007-06-23 17:16:44 -07003465
Andy Whitcroft65863862009-01-06 14:41:21 -08003466 # Should start with a space.
3467 $to =~ s/^(\S)/ $1/;
3468 # Should not end with a space.
3469 $to =~ s/\s+$//;
3470 # '*'s should not have spaces between.
Andy Whitcroftf9a0b3d2009-01-15 13:51:05 -08003471 while ($to =~ s/\*\s+\*/\*\*/) {
Andy Whitcroft65863862009-01-06 14:41:21 -08003472 }
Andy Whitcroftd8aaf122007-06-23 17:16:44 -07003473
Joe Perches3705ce52013-07-03 15:05:31 -07003474## print "1: from<$from> to<$to> ident<$ident>\n";
Andy Whitcroft65863862009-01-06 14:41:21 -08003475 if ($from ne $to) {
Joe Perches3705ce52013-07-03 15:05:31 -07003476 if (ERROR("POINTER_LOCATION",
3477 "\"(foo$from)\" should be \"(foo$to)\"\n" . $herecurr) &&
3478 $fix) {
3479 my $sub_from = $ident;
3480 my $sub_to = $ident;
3481 $sub_to =~ s/\Q$from\E/$to/;
Joe Perches194f66f2014-08-06 16:11:03 -07003482 $fixed[$fixlinenr] =~
Joe Perches3705ce52013-07-03 15:05:31 -07003483 s@\Q$sub_from\E@$sub_to@;
3484 }
Andy Whitcroft65863862009-01-06 14:41:21 -08003485 }
Andy Whitcroftbfcb2cc2012-01-10 15:10:15 -08003486 }
3487 while ($line =~ m{(\b$NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)($Ident))}g) {
3488 #print "BB<$1>\n";
Joe Perches3705ce52013-07-03 15:05:31 -07003489 my ($match, $from, $to, $ident) = ($1, $2, $2, $3);
Andy Whitcroftd8aaf122007-06-23 17:16:44 -07003490
Andy Whitcroft65863862009-01-06 14:41:21 -08003491 # Should start with a space.
3492 $to =~ s/^(\S)/ $1/;
3493 # Should not end with a space.
3494 $to =~ s/\s+$//;
3495 # '*'s should not have spaces between.
Andy Whitcroftf9a0b3d2009-01-15 13:51:05 -08003496 while ($to =~ s/\*\s+\*/\*\*/) {
Andy Whitcroft65863862009-01-06 14:41:21 -08003497 }
3498 # Modifiers should have spaces.
3499 $to =~ s/(\b$Modifier$)/$1 /;
3500
Joe Perches3705ce52013-07-03 15:05:31 -07003501## print "2: from<$from> to<$to> ident<$ident>\n";
Andy Whitcroft667026e2009-02-27 14:03:08 -08003502 if ($from ne $to && $ident !~ /^$Modifier$/) {
Joe Perches3705ce52013-07-03 15:05:31 -07003503 if (ERROR("POINTER_LOCATION",
3504 "\"foo${from}bar\" should be \"foo${to}bar\"\n" . $herecurr) &&
3505 $fix) {
3506
3507 my $sub_from = $match;
3508 my $sub_to = $match;
3509 $sub_to =~ s/\Q$from\E/$to/;
Joe Perches194f66f2014-08-06 16:11:03 -07003510 $fixed[$fixlinenr] =~
Joe Perches3705ce52013-07-03 15:05:31 -07003511 s@\Q$sub_from\E@$sub_to@;
3512 }
Andy Whitcroft65863862009-01-06 14:41:21 -08003513 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003514 }
3515
Joe Perches9d3e3c72015-09-09 15:37:27 -07003516# avoid BUG() or BUG_ON()
3517 if ($line =~ /\b(?:BUG|BUG_ON)\b/) {
3518 my $msg_type = \&WARN;
3519 $msg_type = \&CHK if ($file);
3520 &{$msg_type}("AVOID_BUG",
3521 "Avoid crashing the kernel - try using WARN_ON & recovery code rather than BUG() or BUG_ON()\n" . $herecurr);
3522 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003523
Joe Perches9d3e3c72015-09-09 15:37:27 -07003524# avoid LINUX_VERSION_CODE
Andy Whitcroft8905a672007-11-28 16:21:06 -08003525 if ($line =~ /\bLINUX_VERSION_CODE\b/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003526 WARN("LINUX_VERSION_CODE",
3527 "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 -08003528 }
3529
Joe Perches17441222011-06-15 15:08:17 -07003530# check for uses of printk_ratelimit
3531 if ($line =~ /\bprintk_ratelimit\s*\(/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003532 WARN("PRINTK_RATELIMITED",
Joe Perches101ee682015-02-13 14:38:54 -08003533 "Prefer printk_ratelimited or pr_<level>_ratelimited to printk_ratelimit\n" . $herecurr);
Joe Perches17441222011-06-15 15:08:17 -07003534 }
3535
Andy Whitcroft00df3442007-06-08 13:47:06 -07003536# printk should use KERN_* levels. Note that follow on printk's on the
3537# same line do not need a level, so we use the current block context
3538# to try and find and validate the current printk. In summary the current
Lucas De Marchi25985ed2011-03-30 22:57:33 -03003539# printk includes all preceding printk's which have no newline on the end.
Andy Whitcroft00df3442007-06-08 13:47:06 -07003540# we assume the first bad printk is the one to report.
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07003541 if ($line =~ /\bprintk\((?!KERN_)\s*"/) {
Andy Whitcroft00df3442007-06-08 13:47:06 -07003542 my $ok = 0;
3543 for (my $ln = $linenr - 1; $ln >= $first_line; $ln--) {
3544 #print "CHECK<$lines[$ln - 1]\n";
Lucas De Marchi25985ed2011-03-30 22:57:33 -03003545 # we have a preceding printk if it ends
Andy Whitcroft00df3442007-06-08 13:47:06 -07003546 # with "\n" ignore it, else it is to blame
3547 if ($lines[$ln - 1] =~ m{\bprintk\(}) {
3548 if ($rawlines[$ln - 1] !~ m{\\n"}) {
3549 $ok = 1;
3550 }
3551 last;
3552 }
3553 }
3554 if ($ok == 0) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003555 WARN("PRINTK_WITHOUT_KERN_LEVEL",
3556 "printk() should include KERN_ facility level\n" . $herecurr);
Andy Whitcroft00df3442007-06-08 13:47:06 -07003557 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003558 }
3559
Joe Perches243f3802012-05-31 16:26:09 -07003560 if ($line =~ /\bprintk\s*\(\s*KERN_([A-Z]+)/) {
3561 my $orig = $1;
3562 my $level = lc($orig);
3563 $level = "warn" if ($level eq "warning");
Joe Perches8f26b832012-10-04 17:13:32 -07003564 my $level2 = $level;
3565 $level2 = "dbg" if ($level eq "debug");
Joe Perches243f3802012-05-31 16:26:09 -07003566 WARN("PREFER_PR_LEVEL",
Yogesh Chaudharidaa8b052014-04-03 14:49:23 -07003567 "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 -07003568 }
3569
3570 if ($line =~ /\bpr_warning\s*\(/) {
Joe Perchesd5e616f2013-09-11 14:23:54 -07003571 if (WARN("PREFER_PR_LEVEL",
3572 "Prefer pr_warn(... to pr_warning(...\n" . $herecurr) &&
3573 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07003574 $fixed[$fixlinenr] =~
Joe Perchesd5e616f2013-09-11 14:23:54 -07003575 s/\bpr_warning\b/pr_warn/;
3576 }
Joe Perches243f3802012-05-31 16:26:09 -07003577 }
3578
Joe Perchesdc139312013-02-21 16:44:13 -08003579 if ($line =~ /\bdev_printk\s*\(\s*KERN_([A-Z]+)/) {
3580 my $orig = $1;
3581 my $level = lc($orig);
3582 $level = "warn" if ($level eq "warning");
3583 $level = "dbg" if ($level eq "debug");
3584 WARN("PREFER_DEV_LEVEL",
3585 "Prefer dev_$level(... to dev_printk(KERN_$orig, ...\n" . $herecurr);
3586 }
3587
Andy Lutomirski91c9afa2015-04-16 12:44:44 -07003588# ENOSYS means "bad syscall nr" and nothing else. This will have a small
3589# number of false positives, but assembly files are not checked, so at
3590# least the arch entry code will not trigger this warning.
3591 if ($line =~ /\bENOSYS\b/) {
3592 WARN("ENOSYS",
3593 "ENOSYS means 'invalid syscall nr' and nothing else\n" . $herecurr);
3594 }
3595
Andy Whitcroft653d4872007-06-23 17:16:34 -07003596# function brace can't be on same line, except for #defines of do while,
3597# or if closed on same line
Joe Perches8d182472014-08-06 16:11:12 -07003598 if (($line=~/$Type\s*$Ident\(.*\).*\s*{/) and
Eddie Kovsky4e5d56b2015-09-09 15:37:52 -07003599 !($line=~/\#\s*define.*do\s\{/) and !($line=~/}/)) {
Joe Perches8d182472014-08-06 16:11:12 -07003600 if (ERROR("OPEN_BRACE",
3601 "open brace '{' following function declarations go on the next line\n" . $herecurr) &&
3602 $fix) {
3603 fix_delete_line($fixlinenr, $rawline);
3604 my $fixed_line = $rawline;
3605 $fixed_line =~ /(^..*$Type\s*$Ident\(.*\)\s*){(.*)$/;
3606 my $line1 = $1;
3607 my $line2 = $2;
3608 fix_insert_line($fixlinenr, ltrim($line1));
3609 fix_insert_line($fixlinenr, "\+{");
3610 if ($line2 !~ /^\s*$/) {
3611 fix_insert_line($fixlinenr, "\+\t" . trim($line2));
3612 }
3613 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003614 }
Andy Whitcroft653d4872007-06-23 17:16:34 -07003615
Andy Whitcroft8905a672007-11-28 16:21:06 -08003616# open braces for enum, union and struct go on the same line.
3617 if ($line =~ /^.\s*{/ &&
3618 $prevline =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident)?\s*$/) {
Joe Perches8d182472014-08-06 16:11:12 -07003619 if (ERROR("OPEN_BRACE",
3620 "open brace '{' following $1 go on the same line\n" . $hereprev) &&
3621 $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
3622 fix_delete_line($fixlinenr - 1, $prevrawline);
3623 fix_delete_line($fixlinenr, $rawline);
3624 my $fixedline = rtrim($prevrawline) . " {";
3625 fix_insert_line($fixlinenr, $fixedline);
3626 $fixedline = $rawline;
3627 $fixedline =~ s/^(.\s*){\s*/$1\t/;
3628 if ($fixedline !~ /^\+\s*$/) {
3629 fix_insert_line($fixlinenr, $fixedline);
3630 }
3631 }
Andy Whitcroft8905a672007-11-28 16:21:06 -08003632 }
3633
Andy Whitcroft0c73b4e2010-10-26 14:23:15 -07003634# missing space after union, struct or enum definition
Joe Perches3705ce52013-07-03 15:05:31 -07003635 if ($line =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident){1,2}[=\{]/) {
3636 if (WARN("SPACING",
3637 "missing space after $1 definition\n" . $herecurr) &&
3638 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07003639 $fixed[$fixlinenr] =~
Joe Perches3705ce52013-07-03 15:05:31 -07003640 s/^(.\s*(?:typedef\s+)?(?:enum|union|struct)(?:\s+$Ident){1,2})([=\{])/$1 $2/;
3641 }
Andy Whitcroft0c73b4e2010-10-26 14:23:15 -07003642 }
3643
Joe Perches31070b52014-01-23 15:54:49 -08003644# Function pointer declarations
3645# check spacing between type, funcptr, and args
3646# canonical declaration is "type (*funcptr)(args...)"
Joe Perches91f72e92014-04-03 14:49:12 -07003647 if ($line =~ /^.\s*($Declare)\((\s*)\*(\s*)($Ident)(\s*)\)(\s*)\(/) {
Joe Perches31070b52014-01-23 15:54:49 -08003648 my $declare = $1;
3649 my $pre_pointer_space = $2;
3650 my $post_pointer_space = $3;
3651 my $funcname = $4;
3652 my $post_funcname_space = $5;
3653 my $pre_args_space = $6;
3654
Joe Perches91f72e92014-04-03 14:49:12 -07003655# the $Declare variable will capture all spaces after the type
3656# so check it for a missing trailing missing space but pointer return types
3657# don't need a space so don't warn for those.
3658 my $post_declare_space = "";
3659 if ($declare =~ /(\s+)$/) {
3660 $post_declare_space = $1;
3661 $declare = rtrim($declare);
3662 }
3663 if ($declare !~ /\*$/ && $post_declare_space =~ /^$/) {
Joe Perches31070b52014-01-23 15:54:49 -08003664 WARN("SPACING",
3665 "missing space after return type\n" . $herecurr);
Joe Perches91f72e92014-04-03 14:49:12 -07003666 $post_declare_space = " ";
Joe Perches31070b52014-01-23 15:54:49 -08003667 }
3668
3669# unnecessary space "type (*funcptr)(args...)"
Joe Perches91f72e92014-04-03 14:49:12 -07003670# This test is not currently implemented because these declarations are
3671# equivalent to
3672# int foo(int bar, ...)
3673# and this is form shouldn't/doesn't generate a checkpatch warning.
3674#
3675# elsif ($declare =~ /\s{2,}$/) {
3676# WARN("SPACING",
3677# "Multiple spaces after return type\n" . $herecurr);
3678# }
Joe Perches31070b52014-01-23 15:54:49 -08003679
3680# unnecessary space "type ( *funcptr)(args...)"
3681 if (defined $pre_pointer_space &&
3682 $pre_pointer_space =~ /^\s/) {
3683 WARN("SPACING",
3684 "Unnecessary space after function pointer open parenthesis\n" . $herecurr);
3685 }
3686
3687# unnecessary space "type (* funcptr)(args...)"
3688 if (defined $post_pointer_space &&
3689 $post_pointer_space =~ /^\s/) {
3690 WARN("SPACING",
3691 "Unnecessary space before function pointer name\n" . $herecurr);
3692 }
3693
3694# unnecessary space "type (*funcptr )(args...)"
3695 if (defined $post_funcname_space &&
3696 $post_funcname_space =~ /^\s/) {
3697 WARN("SPACING",
3698 "Unnecessary space after function pointer name\n" . $herecurr);
3699 }
3700
3701# unnecessary space "type (*funcptr) (args...)"
3702 if (defined $pre_args_space &&
3703 $pre_args_space =~ /^\s/) {
3704 WARN("SPACING",
3705 "Unnecessary space before function pointer arguments\n" . $herecurr);
3706 }
3707
3708 if (show_type("SPACING") && $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07003709 $fixed[$fixlinenr] =~
Joe Perches91f72e92014-04-03 14:49:12 -07003710 s/^(.\s*)$Declare\s*\(\s*\*\s*$Ident\s*\)\s*\(/$1 . $declare . $post_declare_space . '(*' . $funcname . ')('/ex;
Joe Perches31070b52014-01-23 15:54:49 -08003711 }
3712 }
3713
Andy Whitcroft8d31cfc2008-07-23 21:29:02 -07003714# check for spacing round square brackets; allowed:
3715# 1. with a type on the left -- int [] a;
Andy Whitcroftfe2a7db2008-10-15 22:02:15 -07003716# 2. at the beginning of a line for slice initialisers -- [0...10] = 5,
3717# 3. inside a curly brace -- = { [0...10] = 5 }
Andy Whitcroft8d31cfc2008-07-23 21:29:02 -07003718 while ($line =~ /(.*?\s)\[/g) {
3719 my ($where, $prefix) = ($-[1], $1);
3720 if ($prefix !~ /$Type\s+$/ &&
Andy Whitcroftfe2a7db2008-10-15 22:02:15 -07003721 ($where != 0 || $prefix !~ /^.\s+$/) &&
Andy Whitcroftdaebc532012-03-23 15:02:17 -07003722 $prefix !~ /[{,]\s+$/) {
Joe Perches3705ce52013-07-03 15:05:31 -07003723 if (ERROR("BRACKET_SPACE",
3724 "space prohibited before open square bracket '['\n" . $herecurr) &&
3725 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07003726 $fixed[$fixlinenr] =~
Joe Perches3705ce52013-07-03 15:05:31 -07003727 s/^(\+.*?)\s+\[/$1\[/;
3728 }
Andy Whitcroft8d31cfc2008-07-23 21:29:02 -07003729 }
3730 }
3731
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07003732# check for spaces between functions and their parentheses.
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07003733 while ($line =~ /($Ident)\s+\(/g) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08003734 my $name = $1;
Andy Whitcroft773647a2008-03-28 14:15:58 -07003735 my $ctx_before = substr($line, 0, $-[1]);
3736 my $ctx = "$ctx_before$name";
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08003737
3738 # Ignore those directives where spaces _are_ permitted.
Andy Whitcroft773647a2008-03-28 14:15:58 -07003739 if ($name =~ /^(?:
3740 if|for|while|switch|return|case|
3741 volatile|__volatile__|
3742 __attribute__|format|__extension__|
3743 asm|__asm__)$/x)
3744 {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08003745 # cpp #define statements have non-optional spaces, ie
3746 # if there is a space between the name and the open
3747 # parenthesis it is simply not a parameter group.
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07003748 } elsif ($ctx_before =~ /^.\s*\#\s*define\s*$/) {
Andy Whitcroft773647a2008-03-28 14:15:58 -07003749
3750 # cpp #elif statement condition may start with a (
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07003751 } elsif ($ctx =~ /^.\s*\#\s*elif\s*$/) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08003752
3753 # If this whole things ends with a type its most
3754 # likely a typedef for a function.
Andy Whitcroft773647a2008-03-28 14:15:58 -07003755 } elsif ($ctx =~ /$Type$/) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08003756
3757 } else {
Joe Perches3705ce52013-07-03 15:05:31 -07003758 if (WARN("SPACING",
3759 "space prohibited between function name and open parenthesis '('\n" . $herecurr) &&
3760 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07003761 $fixed[$fixlinenr] =~
Joe Perches3705ce52013-07-03 15:05:31 -07003762 s/\b$name\s+\(/$name\(/;
3763 }
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07003764 }
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07003765 }
Eric Nelson9a4cad42012-05-31 16:26:09 -07003766
Andy Whitcroft653d4872007-06-23 17:16:34 -07003767# Check operator spacing.
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003768 if (!($line=~/\#\s*include/)) {
Joe Perches3705ce52013-07-03 15:05:31 -07003769 my $fixed_line = "";
3770 my $line_fixed = 0;
3771
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07003772 my $ops = qr{
3773 <<=|>>=|<=|>=|==|!=|
3774 \+=|-=|\*=|\/=|%=|\^=|\|=|&=|
3775 =>|->|<<|>>|<|>|=|!|~|
Andy Whitcroft1f65f942008-07-23 21:29:10 -07003776 &&|\|\||,|\^|\+\+|--|&|\||\+|-|\*|\/|%|
Joe Perches84731622013-11-12 15:10:05 -08003777 \?:|\?|:
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07003778 }x;
Andy Whitcroftcf655042008-03-04 14:28:20 -08003779 my @elements = split(/($ops|;)/, $opline);
Joe Perches3705ce52013-07-03 15:05:31 -07003780
3781## print("element count: <" . $#elements . ">\n");
3782## foreach my $el (@elements) {
3783## print("el: <$el>\n");
3784## }
3785
3786 my @fix_elements = ();
Andy Whitcroft00df3442007-06-08 13:47:06 -07003787 my $off = 0;
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07003788
Joe Perches3705ce52013-07-03 15:05:31 -07003789 foreach my $el (@elements) {
3790 push(@fix_elements, substr($rawline, $off, length($el)));
3791 $off += length($el);
3792 }
3793
3794 $off = 0;
3795
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07003796 my $blank = copy_spacing($opline);
Joe Perchesb34c6482013-09-11 14:24:01 -07003797 my $last_after = -1;
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07003798
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003799 for (my $n = 0; $n < $#elements; $n += 2) {
Joe Perches3705ce52013-07-03 15:05:31 -07003800
3801 my $good = $fix_elements[$n] . $fix_elements[$n + 1];
3802
3803## print("n: <$n> good: <$good>\n");
3804
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07003805 $off += length($elements[$n]);
3806
Lucas De Marchi25985ed2011-03-30 22:57:33 -03003807 # Pick up the preceding and succeeding characters.
Andy Whitcroft773647a2008-03-28 14:15:58 -07003808 my $ca = substr($opline, 0, $off);
3809 my $cc = '';
3810 if (length($opline) >= ($off + length($elements[$n + 1]))) {
3811 $cc = substr($opline, $off + length($elements[$n + 1]));
3812 }
3813 my $cb = "$ca$;$cc";
3814
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07003815 my $a = '';
3816 $a = 'V' if ($elements[$n] ne '');
3817 $a = 'W' if ($elements[$n] =~ /\s$/);
Andy Whitcroftcf655042008-03-04 14:28:20 -08003818 $a = 'C' if ($elements[$n] =~ /$;$/);
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07003819 $a = 'B' if ($elements[$n] =~ /(\[|\()$/);
3820 $a = 'O' if ($elements[$n] eq '');
Andy Whitcroft773647a2008-03-28 14:15:58 -07003821 $a = 'E' if ($ca =~ /^\s*$/);
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07003822
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003823 my $op = $elements[$n + 1];
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07003824
3825 my $c = '';
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003826 if (defined $elements[$n + 2]) {
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07003827 $c = 'V' if ($elements[$n + 2] ne '');
3828 $c = 'W' if ($elements[$n + 2] =~ /^\s/);
Andy Whitcroftcf655042008-03-04 14:28:20 -08003829 $c = 'C' if ($elements[$n + 2] =~ /^$;/);
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07003830 $c = 'B' if ($elements[$n + 2] =~ /^(\)|\]|;)/);
3831 $c = 'O' if ($elements[$n + 2] eq '');
Andy Whitcroft8b1b3372009-01-06 14:41:27 -08003832 $c = 'E' if ($elements[$n + 2] =~ /^\s*\\$/);
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07003833 } else {
3834 $c = 'E';
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003835 }
3836
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07003837 my $ctx = "${a}x${c}";
3838
3839 my $at = "(ctx:$ctx)";
3840
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07003841 my $ptr = substr($blank, 0, $off) . "^";
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07003842 my $hereptr = "$hereline$ptr\n";
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003843
Andy Whitcroft74048ed2008-07-23 21:29:10 -07003844 # Pull out the value of this operator.
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07003845 my $op_type = substr($curr_values, $off + 1, 1);
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003846
Andy Whitcroft1f65f942008-07-23 21:29:10 -07003847 # Get the full operator variant.
3848 my $opv = $op . substr($curr_vars, $off, 1);
3849
Andy Whitcroft13214ad2008-02-08 04:22:03 -08003850 # Ignore operators passed as parameters.
3851 if ($op_type ne 'V' &&
Sam Bobroffd7fe8062015-04-16 12:44:39 -07003852 $ca =~ /\s$/ && $cc =~ /^\s*[,\)]/) {
Andy Whitcroft13214ad2008-02-08 04:22:03 -08003853
Andy Whitcroftcf655042008-03-04 14:28:20 -08003854# # Ignore comments
3855# } elsif ($op =~ /^$;+$/) {
Andy Whitcroft13214ad2008-02-08 04:22:03 -08003856
Andy Whitcroftd8aaf122007-06-23 17:16:44 -07003857 # ; should have either the end of line or a space or \ after it
Andy Whitcroft13214ad2008-02-08 04:22:03 -08003858 } elsif ($op eq ';') {
Andy Whitcroftcf655042008-03-04 14:28:20 -08003859 if ($ctx !~ /.x[WEBC]/ &&
3860 $cc !~ /^\\/ && $cc !~ /^;/) {
Joe Perches3705ce52013-07-03 15:05:31 -07003861 if (ERROR("SPACING",
3862 "space required after that '$op' $at\n" . $hereptr)) {
Joe Perchesb34c6482013-09-11 14:24:01 -07003863 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";
Joe Perches3705ce52013-07-03 15:05:31 -07003864 $line_fixed = 1;
3865 }
Andy Whitcroftd8aaf122007-06-23 17:16:44 -07003866 }
3867
3868 # // is a comment
3869 } elsif ($op eq '//') {
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003870
Joe Perchesb00e4812014-04-03 14:49:33 -07003871 # : when part of a bitfield
3872 } elsif ($opv eq ':B') {
3873 # skip the bitfield test for now
3874
Andy Whitcroft1f65f942008-07-23 21:29:10 -07003875 # No spaces for:
3876 # ->
Joe Perchesb00e4812014-04-03 14:49:33 -07003877 } elsif ($op eq '->') {
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07003878 if ($ctx =~ /Wx.|.xW/) {
Joe Perches3705ce52013-07-03 15:05:31 -07003879 if (ERROR("SPACING",
3880 "spaces prohibited around that '$op' $at\n" . $hereptr)) {
Joe Perchesb34c6482013-09-11 14:24:01 -07003881 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
Joe Perches3705ce52013-07-03 15:05:31 -07003882 if (defined $fix_elements[$n + 2]) {
3883 $fix_elements[$n + 2] =~ s/^\s+//;
3884 }
Joe Perchesb34c6482013-09-11 14:24:01 -07003885 $line_fixed = 1;
Joe Perches3705ce52013-07-03 15:05:31 -07003886 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003887 }
3888
Joe Perches23810972014-12-10 15:51:32 -08003889 # , must not have a space before and must have a space on the right.
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003890 } elsif ($op eq ',') {
Joe Perches23810972014-12-10 15:51:32 -08003891 my $rtrim_before = 0;
3892 my $space_after = 0;
3893 if ($ctx =~ /Wx./) {
3894 if (ERROR("SPACING",
3895 "space prohibited before that '$op' $at\n" . $hereptr)) {
3896 $line_fixed = 1;
3897 $rtrim_before = 1;
3898 }
3899 }
Andy Whitcroftcf655042008-03-04 14:28:20 -08003900 if ($ctx !~ /.x[WEC]/ && $cc !~ /^}/) {
Joe Perches3705ce52013-07-03 15:05:31 -07003901 if (ERROR("SPACING",
3902 "space required after that '$op' $at\n" . $hereptr)) {
Joe Perches3705ce52013-07-03 15:05:31 -07003903 $line_fixed = 1;
Joe Perchesb34c6482013-09-11 14:24:01 -07003904 $last_after = $n;
Joe Perches23810972014-12-10 15:51:32 -08003905 $space_after = 1;
3906 }
3907 }
3908 if ($rtrim_before || $space_after) {
3909 if ($rtrim_before) {
3910 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
3911 } else {
3912 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]);
3913 }
3914 if ($space_after) {
3915 $good .= " ";
Joe Perches3705ce52013-07-03 15:05:31 -07003916 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003917 }
3918
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07003919 # '*' as part of a type definition -- reported already.
Andy Whitcroft74048ed2008-07-23 21:29:10 -07003920 } elsif ($opv eq '*_') {
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07003921 #warn "'*' is part of type\n";
3922
3923 # unary operators should have a space before and
3924 # none after. May be left adjacent to another
3925 # unary operator, or a cast
3926 } elsif ($op eq '!' || $op eq '~' ||
Andy Whitcroft74048ed2008-07-23 21:29:10 -07003927 $opv eq '*U' || $opv eq '-U' ||
Andy Whitcroft0d413862008-10-15 22:02:16 -07003928 $opv eq '&U' || $opv eq '&&U') {
Andy Whitcroftcf655042008-03-04 14:28:20 -08003929 if ($ctx !~ /[WEBC]x./ && $ca !~ /(?:\)|!|~|\*|-|\&|\||\+\+|\-\-|\{)$/) {
Joe Perches3705ce52013-07-03 15:05:31 -07003930 if (ERROR("SPACING",
3931 "space required before that '$op' $at\n" . $hereptr)) {
Joe Perchesb34c6482013-09-11 14:24:01 -07003932 if ($n != $last_after + 2) {
3933 $good = $fix_elements[$n] . " " . ltrim($fix_elements[$n + 1]);
3934 $line_fixed = 1;
3935 }
Joe Perches3705ce52013-07-03 15:05:31 -07003936 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003937 }
Andy Whitcrofta3340b32009-02-27 14:03:07 -08003938 if ($op eq '*' && $cc =~/\s*$Modifier\b/) {
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07003939 # A unary '*' may be const
3940
3941 } elsif ($ctx =~ /.xW/) {
Joe Perches3705ce52013-07-03 15:05:31 -07003942 if (ERROR("SPACING",
3943 "space prohibited after that '$op' $at\n" . $hereptr)) {
Joe Perchesb34c6482013-09-11 14:24:01 -07003944 $good = $fix_elements[$n] . rtrim($fix_elements[$n + 1]);
Joe Perches3705ce52013-07-03 15:05:31 -07003945 if (defined $fix_elements[$n + 2]) {
3946 $fix_elements[$n + 2] =~ s/^\s+//;
3947 }
Joe Perchesb34c6482013-09-11 14:24:01 -07003948 $line_fixed = 1;
Joe Perches3705ce52013-07-03 15:05:31 -07003949 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003950 }
3951
3952 # unary ++ and unary -- are allowed no space on one side.
3953 } elsif ($op eq '++' or $op eq '--') {
Andy Whitcroft773647a2008-03-28 14:15:58 -07003954 if ($ctx !~ /[WEOBC]x[^W]/ && $ctx !~ /[^W]x[WOBEC]/) {
Joe Perches3705ce52013-07-03 15:05:31 -07003955 if (ERROR("SPACING",
3956 "space required one side of that '$op' $at\n" . $hereptr)) {
Joe Perchesb34c6482013-09-11 14:24:01 -07003957 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";
Joe Perches3705ce52013-07-03 15:05:31 -07003958 $line_fixed = 1;
3959 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003960 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07003961 if ($ctx =~ /Wx[BE]/ ||
3962 ($ctx =~ /Wx./ && $cc =~ /^;/)) {
Joe Perches3705ce52013-07-03 15:05:31 -07003963 if (ERROR("SPACING",
3964 "space prohibited before that '$op' $at\n" . $hereptr)) {
Joe Perchesb34c6482013-09-11 14:24:01 -07003965 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
Joe Perches3705ce52013-07-03 15:05:31 -07003966 $line_fixed = 1;
3967 }
Andy Whitcroft653d4872007-06-23 17:16:34 -07003968 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07003969 if ($ctx =~ /ExW/) {
Joe Perches3705ce52013-07-03 15:05:31 -07003970 if (ERROR("SPACING",
3971 "space prohibited after that '$op' $at\n" . $hereptr)) {
Joe Perchesb34c6482013-09-11 14:24:01 -07003972 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]);
Joe Perches3705ce52013-07-03 15:05:31 -07003973 if (defined $fix_elements[$n + 2]) {
3974 $fix_elements[$n + 2] =~ s/^\s+//;
3975 }
Joe Perchesb34c6482013-09-11 14:24:01 -07003976 $line_fixed = 1;
Joe Perches3705ce52013-07-03 15:05:31 -07003977 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07003978 }
3979
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003980 # << and >> may either have or not have spaces both sides
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07003981 } elsif ($op eq '<<' or $op eq '>>' or
3982 $op eq '&' or $op eq '^' or $op eq '|' or
3983 $op eq '+' or $op eq '-' or
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08003984 $op eq '*' or $op eq '/' or
3985 $op eq '%')
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003986 {
Joe Perchesd2e025f2015-02-13 14:38:57 -08003987 if ($check) {
3988 if (defined $fix_elements[$n + 2] && $ctx !~ /[EW]x[EW]/) {
3989 if (CHK("SPACING",
3990 "spaces preferred around that '$op' $at\n" . $hereptr)) {
3991 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
3992 $fix_elements[$n + 2] =~ s/^\s+//;
3993 $line_fixed = 1;
3994 }
3995 } elsif (!defined $fix_elements[$n + 2] && $ctx !~ /Wx[OE]/) {
3996 if (CHK("SPACING",
3997 "space preferred before that '$op' $at\n" . $hereptr)) {
3998 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]);
3999 $line_fixed = 1;
4000 }
4001 }
4002 } elsif ($ctx =~ /Wx[^WCE]|[^WCE]xW/) {
Joe Perches3705ce52013-07-03 15:05:31 -07004003 if (ERROR("SPACING",
4004 "need consistent spacing around '$op' $at\n" . $hereptr)) {
Joe Perchesb34c6482013-09-11 14:24:01 -07004005 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
4006 if (defined $fix_elements[$n + 2]) {
4007 $fix_elements[$n + 2] =~ s/^\s+//;
4008 }
Joe Perches3705ce52013-07-03 15:05:31 -07004009 $line_fixed = 1;
4010 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004011 }
4012
Andy Whitcroft1f65f942008-07-23 21:29:10 -07004013 # A colon needs no spaces before when it is
4014 # terminating a case value or a label.
4015 } elsif ($opv eq ':C' || $opv eq ':L') {
4016 if ($ctx =~ /Wx./) {
Joe Perches3705ce52013-07-03 15:05:31 -07004017 if (ERROR("SPACING",
4018 "space prohibited before that '$op' $at\n" . $hereptr)) {
Joe Perchesb34c6482013-09-11 14:24:01 -07004019 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
Joe Perches3705ce52013-07-03 15:05:31 -07004020 $line_fixed = 1;
4021 }
Andy Whitcroft1f65f942008-07-23 21:29:10 -07004022 }
4023
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004024 # All the others need spaces both sides.
Andy Whitcroftcf655042008-03-04 14:28:20 -08004025 } elsif ($ctx !~ /[EWC]x[CWE]/) {
Andy Whitcroft1f65f942008-07-23 21:29:10 -07004026 my $ok = 0;
4027
Andy Whitcroft22f2a2e2007-08-10 13:01:03 -07004028 # Ignore email addresses <foo@bar>
Andy Whitcroft1f65f942008-07-23 21:29:10 -07004029 if (($op eq '<' &&
4030 $cc =~ /^\S+\@\S+>/) ||
4031 ($op eq '>' &&
4032 $ca =~ /<\S+\@\S+$/))
4033 {
4034 $ok = 1;
4035 }
4036
Joe Perchese0df7e12015-04-16 12:44:53 -07004037 # for asm volatile statements
4038 # ignore a colon with another
4039 # colon immediately before or after
4040 if (($op eq ':') &&
4041 ($ca =~ /:$/ || $cc =~ /^:/)) {
4042 $ok = 1;
4043 }
4044
Joe Perches84731622013-11-12 15:10:05 -08004045 # messages are ERROR, but ?: are CHK
Andy Whitcroft1f65f942008-07-23 21:29:10 -07004046 if ($ok == 0) {
Joe Perches84731622013-11-12 15:10:05 -08004047 my $msg_type = \&ERROR;
4048 $msg_type = \&CHK if (($op eq '?:' || $op eq '?' || $op eq ':') && $ctx =~ /VxV/);
4049
4050 if (&{$msg_type}("SPACING",
4051 "spaces required around that '$op' $at\n" . $hereptr)) {
Joe Perchesb34c6482013-09-11 14:24:01 -07004052 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
4053 if (defined $fix_elements[$n + 2]) {
4054 $fix_elements[$n + 2] =~ s/^\s+//;
4055 }
Joe Perches3705ce52013-07-03 15:05:31 -07004056 $line_fixed = 1;
4057 }
Andy Whitcroft22f2a2e2007-08-10 13:01:03 -07004058 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004059 }
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07004060 $off += length($elements[$n + 1]);
Joe Perches3705ce52013-07-03 15:05:31 -07004061
4062## print("n: <$n> GOOD: <$good>\n");
4063
4064 $fixed_line = $fixed_line . $good;
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004065 }
Joe Perches3705ce52013-07-03 15:05:31 -07004066
4067 if (($#elements % 2) == 0) {
4068 $fixed_line = $fixed_line . $fix_elements[$#elements];
4069 }
4070
Joe Perches194f66f2014-08-06 16:11:03 -07004071 if ($fix && $line_fixed && $fixed_line ne $fixed[$fixlinenr]) {
4072 $fixed[$fixlinenr] = $fixed_line;
Joe Perches3705ce52013-07-03 15:05:31 -07004073 }
4074
4075
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004076 }
4077
Joe Perches786b6322013-07-03 15:05:32 -07004078# check for whitespace before a non-naked semicolon
Joe Perchesd2e248e2014-01-23 15:54:41 -08004079 if ($line =~ /^\+.*\S\s+;\s*$/) {
Joe Perches786b6322013-07-03 15:05:32 -07004080 if (WARN("SPACING",
4081 "space prohibited before semicolon\n" . $herecurr) &&
4082 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07004083 1 while $fixed[$fixlinenr] =~
Joe Perches786b6322013-07-03 15:05:32 -07004084 s/^(\+.*\S)\s+;/$1;/;
4085 }
4086 }
4087
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07004088# check for multiple assignments
4089 if ($line =~ /^.\s*$Lval\s*=\s*$Lval\s*=(?!=)/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07004090 CHK("MULTIPLE_ASSIGNMENTS",
4091 "multiple assignments should be avoided\n" . $herecurr);
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07004092 }
4093
Andy Whitcroft22f2a2e2007-08-10 13:01:03 -07004094## # check for multiple declarations, allowing for a function declaration
4095## # continuation.
4096## if ($line =~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Ident.*/ &&
4097## $line !~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Type\s*$Ident.*/) {
4098##
4099## # Remove any bracketed sections to ensure we do not
4100## # falsly report the parameters of functions.
4101## my $ln = $line;
4102## while ($ln =~ s/\([^\(\)]*\)//g) {
4103## }
4104## if ($ln =~ /,/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07004105## WARN("MULTIPLE_DECLARATION",
4106## "declaring multiple variables together should be avoided\n" . $herecurr);
Andy Whitcroft22f2a2e2007-08-10 13:01:03 -07004107## }
4108## }
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07004109
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004110#need space before brace following if, while, etc
Eddie Kovsky4e5d56b2015-09-09 15:37:52 -07004111 if (($line =~ /\(.*\)\{/ && $line !~ /\($Type\){/) ||
4112 $line =~ /do\{/) {
Joe Perches3705ce52013-07-03 15:05:31 -07004113 if (ERROR("SPACING",
4114 "space required before the open brace '{'\n" . $herecurr) &&
4115 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07004116 $fixed[$fixlinenr] =~ s/^(\+.*(?:do|\))){/$1 {/;
Joe Perches3705ce52013-07-03 15:05:31 -07004117 }
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07004118 }
4119
Joe Perchesc4a62ef2013-07-03 15:05:28 -07004120## # check for blank lines before declarations
4121## if ($line =~ /^.\t+$Type\s+$Ident(?:\s*=.*)?;/ &&
4122## $prevrawline =~ /^.\s*$/) {
4123## WARN("SPACING",
4124## "No blank lines before declarations\n" . $hereprev);
4125## }
4126##
4127
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07004128# closing brace should have a space following it when it has anything
4129# on the line
4130 if ($line =~ /}(?!(?:,|;|\)))\S/) {
Joe Perchesd5e616f2013-09-11 14:23:54 -07004131 if (ERROR("SPACING",
4132 "space required after that close brace '}'\n" . $herecurr) &&
4133 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07004134 $fixed[$fixlinenr] =~
Joe Perchesd5e616f2013-09-11 14:23:54 -07004135 s/}((?!(?:,|;|\)))\S)/} $1/;
4136 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004137 }
4138
Andy Whitcroft22f2a2e2007-08-10 13:01:03 -07004139# check spacing on square brackets
4140 if ($line =~ /\[\s/ && $line !~ /\[\s*$/) {
Joe Perches3705ce52013-07-03 15:05:31 -07004141 if (ERROR("SPACING",
4142 "space prohibited after that open square bracket '['\n" . $herecurr) &&
4143 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07004144 $fixed[$fixlinenr] =~
Joe Perches3705ce52013-07-03 15:05:31 -07004145 s/\[\s+/\[/;
4146 }
Andy Whitcroft22f2a2e2007-08-10 13:01:03 -07004147 }
4148 if ($line =~ /\s\]/) {
Joe Perches3705ce52013-07-03 15:05:31 -07004149 if (ERROR("SPACING",
4150 "space prohibited before that close square bracket ']'\n" . $herecurr) &&
4151 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07004152 $fixed[$fixlinenr] =~
Joe Perches3705ce52013-07-03 15:05:31 -07004153 s/\s+\]/\]/;
4154 }
Andy Whitcroft22f2a2e2007-08-10 13:01:03 -07004155 }
4156
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004157# check spacing on parentheses
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07004158 if ($line =~ /\(\s/ && $line !~ /\(\s*(?:\\)?$/ &&
4159 $line !~ /for\s*\(\s+;/) {
Joe Perches3705ce52013-07-03 15:05:31 -07004160 if (ERROR("SPACING",
4161 "space prohibited after that open parenthesis '('\n" . $herecurr) &&
4162 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07004163 $fixed[$fixlinenr] =~
Joe Perches3705ce52013-07-03 15:05:31 -07004164 s/\(\s+/\(/;
4165 }
Andy Whitcroft22f2a2e2007-08-10 13:01:03 -07004166 }
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004167 if ($line =~ /(\s+)\)/ && $line !~ /^.\s*\)/ &&
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004168 $line !~ /for\s*\(.*;\s+\)/ &&
4169 $line !~ /:\s+\)/) {
Joe Perches3705ce52013-07-03 15:05:31 -07004170 if (ERROR("SPACING",
4171 "space prohibited before that close parenthesis ')'\n" . $herecurr) &&
4172 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07004173 $fixed[$fixlinenr] =~
Joe Perches3705ce52013-07-03 15:05:31 -07004174 s/\s+\)/\)/;
4175 }
Andy Whitcroft22f2a2e2007-08-10 13:01:03 -07004176 }
4177
Joe Perchese2826fd2014-08-06 16:10:48 -07004178# check unnecessary parentheses around addressof/dereference single $Lvals
4179# ie: &(foo->bar) should be &foo->bar and *(foo->bar) should be *foo->bar
4180
4181 while ($line =~ /(?:[^&]&\s*|\*)\(\s*($Ident\s*(?:$Member\s*)+)\s*\)/g) {
Joe Perchesea4acbb2014-12-10 15:51:51 -08004182 my $var = $1;
4183 if (CHK("UNNECESSARY_PARENTHESES",
4184 "Unnecessary parentheses around $var\n" . $herecurr) &&
4185 $fix) {
4186 $fixed[$fixlinenr] =~ s/\(\s*\Q$var\E\s*\)/$var/;
4187 }
4188 }
4189
4190# check for unnecessary parentheses around function pointer uses
4191# ie: (foo->bar)(); should be foo->bar();
4192# but not "if (foo->bar) (" to avoid some false positives
4193 if ($line =~ /(\bif\s*|)(\(\s*$Ident\s*(?:$Member\s*)+\))[ \t]*\(/ && $1 !~ /^if/) {
4194 my $var = $2;
4195 if (CHK("UNNECESSARY_PARENTHESES",
4196 "Unnecessary parentheses around function pointer $var\n" . $herecurr) &&
4197 $fix) {
4198 my $var2 = deparenthesize($var);
4199 $var2 =~ s/\s//g;
4200 $fixed[$fixlinenr] =~ s/\Q$var\E/$var2/;
4201 }
4202 }
Joe Perchese2826fd2014-08-06 16:10:48 -07004203
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004204#goto labels aren't indented, allow a single space however
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07004205 if ($line=~/^.\s+[A-Za-z\d_]+:(?![0-9]+)/ and
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004206 !($line=~/^. [A-Za-z\d_]+:/) and !($line=~/^.\s+default:/)) {
Joe Perches3705ce52013-07-03 15:05:31 -07004207 if (WARN("INDENTED_LABEL",
4208 "labels should not be indented\n" . $herecurr) &&
4209 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07004210 $fixed[$fixlinenr] =~
Joe Perches3705ce52013-07-03 15:05:31 -07004211 s/^(.)\s+/$1/;
4212 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004213 }
4214
Joe Perches5b9553a2014-04-03 14:49:21 -07004215# return is not a function
Joe Perches507e5142013-11-12 15:10:13 -08004216 if (defined($stat) && $stat =~ /^.\s*return(\s*)\(/s) {
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004217 my $spacing = $1;
Joe Perches507e5142013-11-12 15:10:13 -08004218 if ($^V && $^V ge 5.10.0 &&
Joe Perches5b9553a2014-04-03 14:49:21 -07004219 $stat =~ /^.\s*return\s*($balanced_parens)\s*;\s*$/) {
4220 my $value = $1;
4221 $value = deparenthesize($value);
4222 if ($value =~ m/^\s*$FuncArg\s*(?:\?|$)/) {
4223 ERROR("RETURN_PARENTHESES",
4224 "return is not a function, parentheses are not required\n" . $herecurr);
4225 }
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004226 } elsif ($spacing !~ /\s+/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07004227 ERROR("SPACING",
4228 "space required before the open parenthesis '('\n" . $herecurr);
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004229 }
4230 }
Joe Perches507e5142013-11-12 15:10:13 -08004231
Joe Perchesb43ae212014-06-23 13:22:07 -07004232# unnecessary return in a void function
4233# at end-of-function, with the previous line a single leading tab, then return;
4234# and the line before that not a goto label target like "out:"
4235 if ($sline =~ /^[ \+]}\s*$/ &&
4236 $prevline =~ /^\+\treturn\s*;\s*$/ &&
4237 $linenr >= 3 &&
4238 $lines[$linenr - 3] =~ /^[ +]/ &&
4239 $lines[$linenr - 3] !~ /^[ +]\s*$Ident\s*:/) {
Joe Perches9819cf22014-06-04 16:12:09 -07004240 WARN("RETURN_VOID",
Joe Perchesb43ae212014-06-23 13:22:07 -07004241 "void function return statements are not generally useful\n" . $hereprev);
4242 }
Joe Perches9819cf22014-06-04 16:12:09 -07004243
Joe Perches189248d2014-01-23 15:54:47 -08004244# if statements using unnecessary parentheses - ie: if ((foo == bar))
4245 if ($^V && $^V ge 5.10.0 &&
4246 $line =~ /\bif\s*((?:\(\s*){2,})/) {
4247 my $openparens = $1;
4248 my $count = $openparens =~ tr@\(@\(@;
4249 my $msg = "";
4250 if ($line =~ /\bif\s*(?:\(\s*){$count,$count}$LvalOrFunc\s*($Compare)\s*$LvalOrFunc(?:\s*\)){$count,$count}/) {
4251 my $comp = $4; #Not $1 because of $LvalOrFunc
4252 $msg = " - maybe == should be = ?" if ($comp eq "==");
4253 WARN("UNNECESSARY_PARENTHESES",
4254 "Unnecessary parentheses$msg\n" . $herecurr);
4255 }
4256 }
4257
Joe Perchesc5595fa2015-09-09 15:37:58 -07004258# comparisons with a constant or upper case identifier on the left
4259# avoid cases like "foo + BAR < baz"
4260# only fix matches surrounded by parentheses to avoid incorrect
4261# conversions like "FOO < baz() + 5" being "misfixed" to "baz() > FOO + 5"
4262 if ($^V && $^V ge 5.10.0 &&
4263 $line =~ /^\+(.*)\b($Constant|[A-Z_][A-Z0-9_]*)\s*($Compare)\s*($LvalOrFunc)/) {
4264 my $lead = $1;
4265 my $const = $2;
4266 my $comp = $3;
4267 my $to = $4;
4268 my $newcomp = $comp;
4269 if ($lead !~ /$Operators\s*$/ &&
4270 $to !~ /^(?:Constant|[A-Z_][A-Z0-9_]*)$/ &&
4271 WARN("CONSTANT_COMPARISON",
4272 "Comparisons should place the constant on the right side of the test\n" . $herecurr) &&
4273 $fix) {
4274 if ($comp eq "<") {
4275 $newcomp = ">";
4276 } elsif ($comp eq "<=") {
4277 $newcomp = ">=";
4278 } elsif ($comp eq ">") {
4279 $newcomp = "<";
4280 } elsif ($comp eq ">=") {
4281 $newcomp = "<=";
4282 }
4283 $fixed[$fixlinenr] =~ s/\(\s*\Q$const\E\s*$Compare\s*\Q$to\E\s*\)/($to $newcomp $const)/;
4284 }
4285 }
4286
Joe Perchesf34e4a42015-04-16 12:44:19 -07004287# Return of what appears to be an errno should normally be negative
4288 if ($sline =~ /\breturn(?:\s*\(+\s*|\s+)(E[A-Z]+)(?:\s*\)+\s*|\s*)[;:,]/) {
Andy Whitcroft53a3c442010-10-26 14:23:14 -07004289 my $name = $1;
4290 if ($name ne 'EOF' && $name ne 'ERROR') {
Joe Perches000d1cc12011-07-25 17:13:25 -07004291 WARN("USE_NEGATIVE_ERRNO",
Joe Perchesf34e4a42015-04-16 12:44:19 -07004292 "return of an errno should typically be negative (ie: return -$1)\n" . $herecurr);
Andy Whitcroft53a3c442010-10-26 14:23:14 -07004293 }
4294 }
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004295
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004296# Need a space before open parenthesis after if, while etc
Joe Perches3705ce52013-07-03 15:05:31 -07004297 if ($line =~ /\b(if|while|for|switch)\(/) {
4298 if (ERROR("SPACING",
4299 "space required before the open parenthesis '('\n" . $herecurr) &&
4300 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07004301 $fixed[$fixlinenr] =~
Joe Perches3705ce52013-07-03 15:05:31 -07004302 s/\b(if|while|for|switch)\(/$1 \(/;
4303 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004304 }
4305
Andy Whitcroftf5fe35d2008-07-23 21:29:03 -07004306# Check for illegal assignment in if conditional -- and check for trailing
4307# statements after the conditional.
Andy Whitcroft170d3a22008-10-15 22:02:30 -07004308 if ($line =~ /do\s*(?!{)/) {
Andy Whitcroft3e469cd2012-01-10 15:10:01 -08004309 ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
4310 ctx_statement_block($linenr, $realcnt, 0)
4311 if (!defined $stat);
Andy Whitcroft170d3a22008-10-15 22:02:30 -07004312 my ($stat_next) = ctx_statement_block($line_nr_next,
4313 $remain_next, $off_next);
4314 $stat_next =~ s/\n./\n /g;
4315 ##print "stat<$stat> stat_next<$stat_next>\n";
4316
4317 if ($stat_next =~ /^\s*while\b/) {
4318 # If the statement carries leading newlines,
4319 # then count those as offsets.
4320 my ($whitespace) =
4321 ($stat_next =~ /^((?:\s*\n[+-])*\s*)/s);
4322 my $offset =
4323 statement_rawlines($whitespace) - 1;
4324
4325 $suppress_whiletrailers{$line_nr_next +
4326 $offset} = 1;
4327 }
4328 }
4329 if (!defined $suppress_whiletrailers{$linenr} &&
Joe Perchesc11230f2013-11-21 14:31:57 -08004330 defined($stat) && defined($cond) &&
Andy Whitcroft170d3a22008-10-15 22:02:30 -07004331 $line =~ /\b(?:if|while|for)\s*\(/ && $line !~ /^.\s*#/) {
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07004332 my ($s, $c) = ($stat, $cond);
Andy Whitcroft8905a672007-11-28 16:21:06 -08004333
Andy Whitcroftb53c8e12009-01-06 14:41:29 -08004334 if ($c =~ /\bif\s*\(.*[^<>!=]=[^=].*/s) {
Joe Perches000d1cc12011-07-25 17:13:25 -07004335 ERROR("ASSIGN_IN_IF",
4336 "do not use assignment in if condition\n" . $herecurr);
Andy Whitcroft8905a672007-11-28 16:21:06 -08004337 }
4338
4339 # Find out what is on the end of the line after the
4340 # conditional.
Andy Whitcroft773647a2008-03-28 14:15:58 -07004341 substr($s, 0, length($c), '');
Andy Whitcroft8905a672007-11-28 16:21:06 -08004342 $s =~ s/\n.*//g;
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004343 $s =~ s/$;//g; # Remove any comments
Andy Whitcroft53210162008-07-23 21:29:03 -07004344 if (length($c) && $s !~ /^\s*{?\s*\\*\s*$/ &&
4345 $c !~ /}\s*while\s*/)
Andy Whitcroft773647a2008-03-28 14:15:58 -07004346 {
Andy Whitcroftbb44ad32008-10-15 22:02:34 -07004347 # Find out how long the conditional actually is.
4348 my @newlines = ($c =~ /\n/gs);
4349 my $cond_lines = 1 + $#newlines;
Hidetoshi Seto42bdf742010-03-05 13:43:50 -08004350 my $stat_real = '';
Andy Whitcroftbb44ad32008-10-15 22:02:34 -07004351
Hidetoshi Seto42bdf742010-03-05 13:43:50 -08004352 $stat_real = raw_line($linenr, $cond_lines)
4353 . "\n" if ($cond_lines);
Andy Whitcroftbb44ad32008-10-15 22:02:34 -07004354 if (defined($stat_real) && $cond_lines > 1) {
4355 $stat_real = "[...]\n$stat_real";
4356 }
4357
Joe Perches000d1cc12011-07-25 17:13:25 -07004358 ERROR("TRAILING_STATEMENTS",
4359 "trailing statements should be on next line\n" . $herecurr . $stat_real);
Andy Whitcroft8905a672007-11-28 16:21:06 -08004360 }
4361 }
4362
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004363# Check for bitwise tests written as boolean
4364 if ($line =~ /
4365 (?:
4366 (?:\[|\(|\&\&|\|\|)
4367 \s*0[xX][0-9]+\s*
4368 (?:\&\&|\|\|)
4369 |
4370 (?:\&\&|\|\|)
4371 \s*0[xX][0-9]+\s*
4372 (?:\&\&|\|\||\)|\])
4373 )/x)
4374 {
Joe Perches000d1cc12011-07-25 17:13:25 -07004375 WARN("HEXADECIMAL_BOOLEAN_TEST",
4376 "boolean test with hexadecimal, perhaps just 1 \& or \|?\n" . $herecurr);
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004377 }
4378
Andy Whitcroft8905a672007-11-28 16:21:06 -08004379# if and else should not have general statements after it
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004380 if ($line =~ /^.\s*(?:}\s*)?else\b(.*)/) {
4381 my $s = $1;
4382 $s =~ s/$;//g; # Remove any comments
4383 if ($s !~ /^\s*(?:\sif|(?:{|)\s*\\?\s*$)/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07004384 ERROR("TRAILING_STATEMENTS",
4385 "trailing statements should be on next line\n" . $herecurr);
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004386 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004387 }
Andy Whitcroft39667782009-01-15 13:51:06 -08004388# if should not continue a brace
4389 if ($line =~ /}\s*if\b/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07004390 ERROR("TRAILING_STATEMENTS",
Rasmus Villemoes048b1232014-08-06 16:10:37 -07004391 "trailing statements should be on next line (or did you mean 'else if'?)\n" .
Andy Whitcroft39667782009-01-15 13:51:06 -08004392 $herecurr);
4393 }
Andy Whitcrofta1080bf2008-10-15 22:02:25 -07004394# case and default should not have general statements after them
4395 if ($line =~ /^.\s*(?:case\s*.*|default\s*):/g &&
4396 $line !~ /\G(?:
Andy Whitcroft3fef12d2008-10-15 22:02:36 -07004397 (?:\s*$;*)(?:\s*{)?(?:\s*$;*)(?:\s*\\)?\s*$|
Andy Whitcrofta1080bf2008-10-15 22:02:25 -07004398 \s*return\s+
4399 )/xg)
4400 {
Joe Perches000d1cc12011-07-25 17:13:25 -07004401 ERROR("TRAILING_STATEMENTS",
4402 "trailing statements should be on next line\n" . $herecurr);
Andy Whitcrofta1080bf2008-10-15 22:02:25 -07004403 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004404
4405 # Check for }<nl>else {, these must be at the same
4406 # indent level to be relevant to each other.
Joe Perches8b8856f2014-08-06 16:11:14 -07004407 if ($prevline=~/}\s*$/ and $line=~/^.\s*else\s*/ &&
4408 $previndent == $indent) {
4409 if (ERROR("ELSE_AFTER_BRACE",
4410 "else should follow close brace '}'\n" . $hereprev) &&
4411 $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
4412 fix_delete_line($fixlinenr - 1, $prevrawline);
4413 fix_delete_line($fixlinenr, $rawline);
4414 my $fixedline = $prevrawline;
4415 $fixedline =~ s/}\s*$//;
4416 if ($fixedline !~ /^\+\s*$/) {
4417 fix_insert_line($fixlinenr, $fixedline);
4418 }
4419 $fixedline = $rawline;
4420 $fixedline =~ s/^(.\s*)else/$1} else/;
4421 fix_insert_line($fixlinenr, $fixedline);
4422 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004423 }
4424
Joe Perches8b8856f2014-08-06 16:11:14 -07004425 if ($prevline=~/}\s*$/ and $line=~/^.\s*while\s*/ &&
4426 $previndent == $indent) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08004427 my ($s, $c) = ctx_statement_block($linenr, $realcnt, 0);
4428
4429 # Find out what is on the end of the line after the
4430 # conditional.
Andy Whitcroft773647a2008-03-28 14:15:58 -07004431 substr($s, 0, length($c), '');
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08004432 $s =~ s/\n.*//g;
4433
4434 if ($s =~ /^\s*;/) {
Joe Perches8b8856f2014-08-06 16:11:14 -07004435 if (ERROR("WHILE_AFTER_BRACE",
4436 "while should follow close brace '}'\n" . $hereprev) &&
4437 $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
4438 fix_delete_line($fixlinenr - 1, $prevrawline);
4439 fix_delete_line($fixlinenr, $rawline);
4440 my $fixedline = $prevrawline;
4441 my $trailing = $rawline;
4442 $trailing =~ s/^\+//;
4443 $trailing = trim($trailing);
4444 $fixedline =~ s/}\s*$/} $trailing/;
4445 fix_insert_line($fixlinenr, $fixedline);
4446 }
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08004447 }
4448 }
4449
Joe Perches95e2c602013-07-03 15:05:20 -07004450#Specific variable tests
Joe Perches323c1262012-12-17 16:02:07 -08004451 while ($line =~ m{($Constant|$Lval)}g) {
4452 my $var = $1;
Joe Perches95e2c602013-07-03 15:05:20 -07004453
4454#gcc binary extension
4455 if ($var =~ /^$Binary$/) {
Joe Perchesd5e616f2013-09-11 14:23:54 -07004456 if (WARN("GCC_BINARY_CONSTANT",
4457 "Avoid gcc v4.3+ binary constant extension: <$var>\n" . $herecurr) &&
4458 $fix) {
4459 my $hexval = sprintf("0x%x", oct($var));
Joe Perches194f66f2014-08-06 16:11:03 -07004460 $fixed[$fixlinenr] =~
Joe Perchesd5e616f2013-09-11 14:23:54 -07004461 s/\b$var\b/$hexval/;
4462 }
Joe Perches95e2c602013-07-03 15:05:20 -07004463 }
4464
4465#CamelCase
Joe Perches807bd262013-07-03 15:05:22 -07004466 if ($var !~ /^$Constant$/ &&
Joe Perchesbe797942013-07-03 15:05:20 -07004467 $var =~ /[A-Z][a-z]|[a-z][A-Z]/ &&
Joe Perches22735ce2013-07-03 15:05:33 -07004468#Ignore Page<foo> variants
Joe Perches807bd262013-07-03 15:05:22 -07004469 $var !~ /^(?:Clear|Set|TestClear|TestSet|)Page[A-Z]/ &&
Joe Perches22735ce2013-07-03 15:05:33 -07004470#Ignore SI style variants like nS, mV and dB (ie: max_uV, regulator_min_uA_show)
Julius Wernerf5123572014-12-10 15:51:54 -08004471 $var !~ /^(?:[a-z_]*?)_?[a-z][A-Z](?:_[a-z_]+)?$/ &&
4472#Ignore some three character SI units explicitly, like MiB and KHz
4473 $var !~ /^(?:[a-z_]*?)_?(?:[KMGT]iB|[KMGT]?Hz)(?:_[a-z_]+)?$/) {
Joe Perches7e781f62013-09-11 14:23:55 -07004474 while ($var =~ m{($Ident)}g) {
4475 my $word = $1;
4476 next if ($word !~ /[A-Z][a-z]|[a-z][A-Z]/);
Joe Perchesd8b07712013-11-12 15:10:06 -08004477 if ($check) {
4478 seed_camelcase_includes();
4479 if (!$file && !$camelcase_file_seeded) {
4480 seed_camelcase_file($realfile);
4481 $camelcase_file_seeded = 1;
4482 }
4483 }
Joe Perches7e781f62013-09-11 14:23:55 -07004484 if (!defined $camelcase{$word}) {
4485 $camelcase{$word} = 1;
4486 CHK("CAMELCASE",
4487 "Avoid CamelCase: <$word>\n" . $herecurr);
4488 }
Joe Perches34456862013-07-03 15:05:34 -07004489 }
Joe Perches323c1262012-12-17 16:02:07 -08004490 }
4491 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004492
4493#no spaces allowed after \ in define
Joe Perchesd5e616f2013-09-11 14:23:54 -07004494 if ($line =~ /\#\s*define.*\\\s+$/) {
4495 if (WARN("WHITESPACE_AFTER_LINE_CONTINUATION",
4496 "Whitespace after \\ makes next lines useless\n" . $herecurr) &&
4497 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07004498 $fixed[$fixlinenr] =~ s/\s+$//;
Joe Perchesd5e616f2013-09-11 14:23:54 -07004499 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004500 }
4501
Fabian Frederick0e212e02015-04-16 12:44:25 -07004502# warn if <asm/foo.h> is #included and <linux/foo.h> is available and includes
4503# itself <asm/foo.h> (uses RAW line)
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004504 if ($tree && $rawline =~ m{^.\s*\#\s*include\s*\<asm\/(.*)\.h\>}) {
Andy Whitcrofte09dec42008-10-15 22:02:20 -07004505 my $file = "$1.h";
4506 my $checkfile = "include/linux/$file";
4507 if (-f "$root/$checkfile" &&
4508 $realfile ne $checkfile &&
Wolfram Sang7840a942010-08-09 17:20:57 -07004509 $1 !~ /$allowed_asm_includes/)
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004510 {
Fabian Frederick0e212e02015-04-16 12:44:25 -07004511 my $asminclude = `grep -Ec "#include\\s+<asm/$file>" $root/$checkfile`;
4512 if ($asminclude > 0) {
4513 if ($realfile =~ m{^arch/}) {
4514 CHK("ARCH_INCLUDE_LINUX",
4515 "Consider using #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
4516 } else {
4517 WARN("INCLUDE_LINUX",
4518 "Use #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
4519 }
Andy Whitcrofte09dec42008-10-15 22:02:20 -07004520 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004521 }
4522 }
4523
Andy Whitcroft653d4872007-06-23 17:16:34 -07004524# multi-statement macros should be enclosed in a do while loop, grab the
4525# first statement and ensure its the whole macro if its not enclosed
Andy Whitcroftcf655042008-03-04 14:28:20 -08004526# in a known good container
Andy Whitcroftb8f96a32008-07-23 21:29:07 -07004527 if ($realfile !~ m@/vmlinux.lds.h$@ &&
4528 $line =~ /^.\s*\#\s*define\s*$Ident(\()?/) {
Andy Whitcroftd8aaf122007-06-23 17:16:44 -07004529 my $ln = $linenr;
4530 my $cnt = $realcnt;
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004531 my ($off, $dstat, $dcond, $rest);
4532 my $ctx = '';
Joe Perches08a28432014-10-13 15:51:55 -07004533 my $has_flow_statement = 0;
4534 my $has_arg_concat = 0;
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004535 ($dstat, $dcond, $ln, $cnt, $off) =
Andy Whitcroftf74bd192012-01-10 15:09:54 -08004536 ctx_statement_block($linenr, $realcnt, 0);
4537 $ctx = $dstat;
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004538 #print "dstat<$dstat> dcond<$dcond> cnt<$cnt> off<$off>\n";
Andy Whitcrofta3bb97a2008-07-23 21:29:00 -07004539 #print "LINE<$lines[$ln-1]> len<" . length($lines[$ln-1]) . "\n";
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004540
Joe Perches08a28432014-10-13 15:51:55 -07004541 $has_flow_statement = 1 if ($ctx =~ /\b(goto|return)\b/);
Joe Perches62e15a62016-01-20 14:59:18 -08004542 $has_arg_concat = 1 if ($ctx =~ /\#\#/ && $ctx !~ /\#\#\s*(?:__VA_ARGS__|args)\b/);
Joe Perches08a28432014-10-13 15:51:55 -07004543
Andy Whitcroftf74bd192012-01-10 15:09:54 -08004544 $dstat =~ s/^.\s*\#\s*define\s+$Ident(?:\([^\)]*\))?\s*//;
Andy Whitcroft292f1a92008-07-23 21:29:11 -07004545 $dstat =~ s/$;//g;
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004546 $dstat =~ s/\\\n.//g;
4547 $dstat =~ s/^\s*//s;
4548 $dstat =~ s/\s*$//s;
4549
4550 # Flatten any parentheses and braces
Andy Whitcroftbf30d6e2008-10-15 22:02:33 -07004551 while ($dstat =~ s/\([^\(\)]*\)/1/ ||
4552 $dstat =~ s/\{[^\{\}]*\}/1/ ||
Vladimir Zapolskiy6b10df42016-01-20 14:59:21 -08004553 $dstat =~ s/.\[[^\[\]]*\]/1/)
Andy Whitcroftbf30d6e2008-10-15 22:02:33 -07004554 {
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07004555 }
Andy Whitcroftd8aaf122007-06-23 17:16:44 -07004556
Andy Whitcrofte45bab82012-03-23 15:02:18 -07004557 # Flatten any obvious string concatentation.
Joe Perches33acb542015-06-25 15:02:54 -07004558 while ($dstat =~ s/($String)\s*$Ident/$1/ ||
4559 $dstat =~ s/$Ident\s*($String)/$1/)
Andy Whitcrofte45bab82012-03-23 15:02:18 -07004560 {
4561 }
4562
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004563 my $exceptions = qr{
4564 $Declare|
4565 module_param_named|
Kees Cooka0a0a7a2012-10-04 17:13:38 -07004566 MODULE_PARM_DESC|
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004567 DECLARE_PER_CPU|
4568 DEFINE_PER_CPU|
Andy Whitcroft383099f2009-01-06 14:41:18 -08004569 __typeof__\(|
Stefani Seibold22fd2d32010-03-05 13:43:52 -08004570 union|
4571 struct|
Andy Whitcroftea71a0a2009-09-21 17:04:38 -07004572 \.$Ident\s*=\s*|
Vladimir Zapolskiy6b10df42016-01-20 14:59:21 -08004573 ^\"|\"$|
4574 ^\[
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004575 }x;
Andy Whitcroft5eaa20b2010-10-26 14:23:18 -07004576 #print "REST<$rest> dstat<$dstat> ctx<$ctx>\n";
Andy Whitcroftf74bd192012-01-10 15:09:54 -08004577 if ($dstat ne '' &&
4578 $dstat !~ /^(?:$Ident|-?$Constant),$/ && # 10, // foo(),
4579 $dstat !~ /^(?:$Ident|-?$Constant);$/ && # foo();
Joe Perches3cc4b1c2013-07-03 15:05:27 -07004580 $dstat !~ /^[!~-]?(?:$Lval|$Constant)$/ && # 10 // foo() // !foo // ~foo // -foo // foo->bar // foo.bar->baz
Joe Perches356fd392014-08-06 16:10:31 -07004581 $dstat !~ /^'X'$/ && $dstat !~ /^'XX'$/ && # character constants
Andy Whitcroftf74bd192012-01-10 15:09:54 -08004582 $dstat !~ /$exceptions/ &&
4583 $dstat !~ /^\.$Ident\s*=/ && # .foo =
Joe Perchese942e2c2013-04-17 15:58:26 -07004584 $dstat !~ /^(?:\#\s*$Ident|\#\s*$Constant)\s*$/ && # stringification #foo
Andy Whitcroft72f115f2012-01-10 15:10:06 -08004585 $dstat !~ /^do\s*$Constant\s*while\s*$Constant;?$/ && # do {...} while (...); // do {...} while (...)
Andy Whitcroftf74bd192012-01-10 15:09:54 -08004586 $dstat !~ /^for\s*$Constant$/ && # for (...)
4587 $dstat !~ /^for\s*$Constant\s+(?:$Ident|-?$Constant)$/ && # for (...) bar()
4588 $dstat !~ /^do\s*{/ && # do {...
Eddie Kovsky4e5d56b2015-09-09 15:37:52 -07004589 $dstat !~ /^\(\{/ && # ({...
Joe Perchesf95a7e62013-09-11 14:24:00 -07004590 $ctx !~ /^.\s*#\s*define\s+TRACE_(?:SYSTEM|INCLUDE_FILE|INCLUDE_PATH)\b/)
Andy Whitcroftf74bd192012-01-10 15:09:54 -08004591 {
4592 $ctx =~ s/\n*$//;
4593 my $herectx = $here . "\n";
4594 my $cnt = statement_rawlines($ctx);
4595
4596 for (my $n = 0; $n < $cnt; $n++) {
4597 $herectx .= raw_line($linenr, $n) . "\n";
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004598 }
4599
Andy Whitcroftf74bd192012-01-10 15:09:54 -08004600 if ($dstat =~ /;/) {
4601 ERROR("MULTISTATEMENT_MACRO_USE_DO_WHILE",
4602 "Macros with multiple statements should be enclosed in a do - while loop\n" . "$herectx");
4603 } else {
Joe Perches000d1cc12011-07-25 17:13:25 -07004604 ERROR("COMPLEX_MACRO",
Andrew Morton388982b2014-10-13 15:51:40 -07004605 "Macros with complex values should be enclosed in parentheses\n" . "$herectx");
Andy Whitcroftd8aaf122007-06-23 17:16:44 -07004606 }
Andy Whitcroft653d4872007-06-23 17:16:34 -07004607 }
Joe Perches5023d342012-12-17 16:01:47 -08004608
Joe Perches08a28432014-10-13 15:51:55 -07004609# check for macros with flow control, but without ## concatenation
4610# ## concatenation is commonly a macro that defines a function so ignore those
4611 if ($has_flow_statement && !$has_arg_concat) {
4612 my $herectx = $here . "\n";
4613 my $cnt = statement_rawlines($ctx);
4614
4615 for (my $n = 0; $n < $cnt; $n++) {
4616 $herectx .= raw_line($linenr, $n) . "\n";
4617 }
4618 WARN("MACRO_WITH_FLOW_CONTROL",
4619 "Macros with flow control statements should be avoided\n" . "$herectx");
4620 }
4621
Joe Perches481eb482012-12-17 16:01:56 -08004622# check for line continuations outside of #defines, preprocessor #, and asm
Joe Perches5023d342012-12-17 16:01:47 -08004623
4624 } else {
4625 if ($prevline !~ /^..*\\$/ &&
Joe Perches481eb482012-12-17 16:01:56 -08004626 $line !~ /^\+\s*\#.*\\$/ && # preprocessor
4627 $line !~ /^\+.*\b(__asm__|asm)\b.*\\$/ && # asm
Joe Perches5023d342012-12-17 16:01:47 -08004628 $line =~ /^\+.*\\$/) {
4629 WARN("LINE_CONTINUATIONS",
4630 "Avoid unnecessary line continuations\n" . $herecurr);
4631 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004632 }
4633
Joe Perchesb13edf72012-07-30 14:41:24 -07004634# do {} while (0) macro tests:
4635# single-statement macros do not need to be enclosed in do while (0) loop,
4636# macro should not end with a semicolon
4637 if ($^V && $^V ge 5.10.0 &&
4638 $realfile !~ m@/vmlinux.lds.h$@ &&
4639 $line =~ /^.\s*\#\s*define\s+$Ident(\()?/) {
4640 my $ln = $linenr;
4641 my $cnt = $realcnt;
4642 my ($off, $dstat, $dcond, $rest);
4643 my $ctx = '';
4644 ($dstat, $dcond, $ln, $cnt, $off) =
4645 ctx_statement_block($linenr, $realcnt, 0);
4646 $ctx = $dstat;
4647
4648 $dstat =~ s/\\\n.//g;
Joe Perches1b36b202015-02-13 14:38:32 -08004649 $dstat =~ s/$;/ /g;
Joe Perchesb13edf72012-07-30 14:41:24 -07004650
4651 if ($dstat =~ /^\+\s*#\s*define\s+$Ident\s*${balanced_parens}\s*do\s*{(.*)\s*}\s*while\s*\(\s*0\s*\)\s*([;\s]*)\s*$/) {
4652 my $stmts = $2;
4653 my $semis = $3;
4654
4655 $ctx =~ s/\n*$//;
4656 my $cnt = statement_rawlines($ctx);
4657 my $herectx = $here . "\n";
4658
4659 for (my $n = 0; $n < $cnt; $n++) {
4660 $herectx .= raw_line($linenr, $n) . "\n";
4661 }
4662
Joe Perchesac8e97f2012-08-21 16:15:53 -07004663 if (($stmts =~ tr/;/;/) == 1 &&
4664 $stmts !~ /^\s*(if|while|for|switch)\b/) {
Joe Perchesb13edf72012-07-30 14:41:24 -07004665 WARN("SINGLE_STATEMENT_DO_WHILE_MACRO",
4666 "Single statement macros should not use a do {} while (0) loop\n" . "$herectx");
4667 }
4668 if (defined $semis && $semis ne "") {
4669 WARN("DO_WHILE_MACRO_WITH_TRAILING_SEMICOLON",
4670 "do {} while (0) macros should not be semicolon terminated\n" . "$herectx");
4671 }
Joe Perchesf5ef95b2014-06-04 16:12:06 -07004672 } elsif ($dstat =~ /^\+\s*#\s*define\s+$Ident.*;\s*$/) {
4673 $ctx =~ s/\n*$//;
4674 my $cnt = statement_rawlines($ctx);
4675 my $herectx = $here . "\n";
4676
4677 for (my $n = 0; $n < $cnt; $n++) {
4678 $herectx .= raw_line($linenr, $n) . "\n";
4679 }
4680
4681 WARN("TRAILING_SEMICOLON",
4682 "macros should not use a trailing semicolon\n" . "$herectx");
Joe Perchesb13edf72012-07-30 14:41:24 -07004683 }
4684 }
4685
Mike Frysinger080ba922009-01-06 14:41:25 -08004686# make sure symbols are always wrapped with VMLINUX_SYMBOL() ...
4687# all assignments may have only one of the following with an assignment:
4688# .
4689# ALIGN(...)
4690# VMLINUX_SYMBOL(...)
4691 if ($realfile eq 'vmlinux.lds.h' && $line =~ /(?:(?:^|\s)$Ident\s*=|=\s*$Ident(?:\s|$))/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07004692 WARN("MISSING_VMLINUX_SYMBOL",
4693 "vmlinux.lds.h needs VMLINUX_SYMBOL() around C-visible symbols\n" . $herecurr);
Mike Frysinger080ba922009-01-06 14:41:25 -08004694 }
4695
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07004696# check for redundant bracing round if etc
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004697 if ($line =~ /(^.*)\bif\b/ && $1 !~ /else\s*$/) {
4698 my ($level, $endln, @chunks) =
Andy Whitcroftcf655042008-03-04 14:28:20 -08004699 ctx_statement_full($linenr, $realcnt, 1);
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004700 #print "chunks<$#chunks> linenr<$linenr> endln<$endln> level<$level>\n";
Andy Whitcroftcf655042008-03-04 14:28:20 -08004701 #print "APW: <<$chunks[1][0]>><<$chunks[1][1]>>\n";
4702 if ($#chunks > 0 && $level == 0) {
Joe Perchesaad4f612012-03-23 15:02:19 -07004703 my @allowed = ();
4704 my $allow = 0;
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004705 my $seen = 0;
Andy Whitcroft773647a2008-03-28 14:15:58 -07004706 my $herectx = $here . "\n";
Andy Whitcroftcf655042008-03-04 14:28:20 -08004707 my $ln = $linenr - 1;
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004708 for my $chunk (@chunks) {
4709 my ($cond, $block) = @{$chunk};
4710
Andy Whitcroft773647a2008-03-28 14:15:58 -07004711 # If the condition carries leading newlines, then count those as offsets.
4712 my ($whitespace) = ($cond =~ /^((?:\s*\n[+-])*\s*)/s);
4713 my $offset = statement_rawlines($whitespace) - 1;
4714
Joe Perchesaad4f612012-03-23 15:02:19 -07004715 $allowed[$allow] = 0;
Andy Whitcroft773647a2008-03-28 14:15:58 -07004716 #print "COND<$cond> whitespace<$whitespace> offset<$offset>\n";
4717
4718 # We have looked at and allowed this specific line.
4719 $suppress_ifbraces{$ln + $offset} = 1;
4720
4721 $herectx .= "$rawlines[$ln + $offset]\n[...]\n";
Andy Whitcroftcf655042008-03-04 14:28:20 -08004722 $ln += statement_rawlines($block) - 1;
4723
Andy Whitcroft773647a2008-03-28 14:15:58 -07004724 substr($block, 0, length($cond), '');
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004725
4726 $seen++ if ($block =~ /^\s*{/);
4727
Joe Perchesaad4f612012-03-23 15:02:19 -07004728 #print "cond<$cond> block<$block> allowed<$allowed[$allow]>\n";
Andy Whitcroftcf655042008-03-04 14:28:20 -08004729 if (statement_lines($cond) > 1) {
4730 #print "APW: ALLOWED: cond<$cond>\n";
Joe Perchesaad4f612012-03-23 15:02:19 -07004731 $allowed[$allow] = 1;
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004732 }
4733 if ($block =~/\b(?:if|for|while)\b/) {
Andy Whitcroftcf655042008-03-04 14:28:20 -08004734 #print "APW: ALLOWED: block<$block>\n";
Joe Perchesaad4f612012-03-23 15:02:19 -07004735 $allowed[$allow] = 1;
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004736 }
Andy Whitcroftcf655042008-03-04 14:28:20 -08004737 if (statement_block_size($block) > 1) {
4738 #print "APW: ALLOWED: lines block<$block>\n";
Joe Perchesaad4f612012-03-23 15:02:19 -07004739 $allowed[$allow] = 1;
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004740 }
Joe Perchesaad4f612012-03-23 15:02:19 -07004741 $allow++;
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004742 }
Joe Perchesaad4f612012-03-23 15:02:19 -07004743 if ($seen) {
4744 my $sum_allowed = 0;
4745 foreach (@allowed) {
4746 $sum_allowed += $_;
4747 }
4748 if ($sum_allowed == 0) {
4749 WARN("BRACES",
4750 "braces {} are not necessary for any arm of this statement\n" . $herectx);
4751 } elsif ($sum_allowed != $allow &&
4752 $seen != $allow) {
4753 CHK("BRACES",
4754 "braces {} should be used on all arms of this statement\n" . $herectx);
4755 }
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004756 }
4757 }
4758 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07004759 if (!defined $suppress_ifbraces{$linenr - 1} &&
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004760 $line =~ /\b(if|while|for|else)\b/) {
Andy Whitcroftcf655042008-03-04 14:28:20 -08004761 my $allowed = 0;
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07004762
Andy Whitcroftcf655042008-03-04 14:28:20 -08004763 # Check the pre-context.
4764 if (substr($line, 0, $-[0]) =~ /(\}\s*)$/) {
4765 #print "APW: ALLOWED: pre<$1>\n";
4766 $allowed = 1;
4767 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07004768
4769 my ($level, $endln, @chunks) =
4770 ctx_statement_full($linenr, $realcnt, $-[0]);
4771
Andy Whitcroftcf655042008-03-04 14:28:20 -08004772 # Check the condition.
4773 my ($cond, $block) = @{$chunks[0]};
Andy Whitcroft773647a2008-03-28 14:15:58 -07004774 #print "CHECKING<$linenr> cond<$cond> block<$block>\n";
Andy Whitcroftcf655042008-03-04 14:28:20 -08004775 if (defined $cond) {
Andy Whitcroft773647a2008-03-28 14:15:58 -07004776 substr($block, 0, length($cond), '');
Andy Whitcroftcf655042008-03-04 14:28:20 -08004777 }
4778 if (statement_lines($cond) > 1) {
4779 #print "APW: ALLOWED: cond<$cond>\n";
4780 $allowed = 1;
4781 }
4782 if ($block =~/\b(?:if|for|while)\b/) {
4783 #print "APW: ALLOWED: block<$block>\n";
4784 $allowed = 1;
4785 }
4786 if (statement_block_size($block) > 1) {
4787 #print "APW: ALLOWED: lines block<$block>\n";
4788 $allowed = 1;
4789 }
4790 # Check the post-context.
4791 if (defined $chunks[1]) {
4792 my ($cond, $block) = @{$chunks[1]};
4793 if (defined $cond) {
Andy Whitcroft773647a2008-03-28 14:15:58 -07004794 substr($block, 0, length($cond), '');
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07004795 }
Andy Whitcroftcf655042008-03-04 14:28:20 -08004796 if ($block =~ /^\s*\{/) {
4797 #print "APW: ALLOWED: chunk-1 block<$block>\n";
4798 $allowed = 1;
4799 }
4800 }
4801 if ($level == 0 && $block =~ /^\s*\{/ && !$allowed) {
Justin P. Mattock69932482011-07-26 23:06:29 -07004802 my $herectx = $here . "\n";
Andy Whitcroftf0556632008-10-15 22:02:23 -07004803 my $cnt = statement_rawlines($block);
Andy Whitcroftcf655042008-03-04 14:28:20 -08004804
Andy Whitcroftf0556632008-10-15 22:02:23 -07004805 for (my $n = 0; $n < $cnt; $n++) {
Justin P. Mattock69932482011-07-26 23:06:29 -07004806 $herectx .= raw_line($linenr, $n) . "\n";
Andy Whitcroftcf655042008-03-04 14:28:20 -08004807 }
4808
Joe Perches000d1cc12011-07-25 17:13:25 -07004809 WARN("BRACES",
4810 "braces {} are not necessary for single statement blocks\n" . $herectx);
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07004811 }
4812 }
4813
Joe Perches0979ae62012-12-17 16:01:59 -08004814# check for unnecessary blank lines around braces
Joe Perches77b9a532013-07-03 15:05:29 -07004815 if (($line =~ /^.\s*}\s*$/ && $prevrawline =~ /^.\s*$/)) {
Joe Perchesf8e58212015-02-13 14:38:46 -08004816 if (CHK("BRACES",
4817 "Blank lines aren't necessary before a close brace '}'\n" . $hereprev) &&
4818 $fix && $prevrawline =~ /^\+/) {
4819 fix_delete_line($fixlinenr - 1, $prevrawline);
4820 }
Joe Perches0979ae62012-12-17 16:01:59 -08004821 }
Joe Perches77b9a532013-07-03 15:05:29 -07004822 if (($rawline =~ /^.\s*$/ && $prevline =~ /^..*{\s*$/)) {
Joe Perchesf8e58212015-02-13 14:38:46 -08004823 if (CHK("BRACES",
4824 "Blank lines aren't necessary after an open brace '{'\n" . $hereprev) &&
4825 $fix) {
4826 fix_delete_line($fixlinenr, $rawline);
4827 }
Joe Perches0979ae62012-12-17 16:01:59 -08004828 }
4829
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07004830# no volatiles please
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07004831 my $asm_volatile = qr{\b(__asm__|asm)\s+(__volatile__|volatile)\b};
4832 if ($line =~ /\bvolatile\b/ && $line !~ /$asm_volatile/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07004833 WARN("VOLATILE",
4834 "Use of volatile is usually wrong: see Documentation/volatile-considered-harmful.txt\n" . $herecurr);
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07004835 }
4836
Joe Perches5e4f6ba2014-12-10 15:52:05 -08004837# Check for user-visible strings broken across lines, which breaks the ability
4838# to grep for the string. Make exceptions when the previous string ends in a
4839# newline (multiple lines in one string constant) or '\t', '\r', ';', or '{'
4840# (common in inline assembly) or is a octal \123 or hexadecimal \xaf value
Joe Perches33acb542015-06-25 15:02:54 -07004841 if ($line =~ /^\+\s*$String/ &&
Joe Perches5e4f6ba2014-12-10 15:52:05 -08004842 $prevline =~ /"\s*$/ &&
4843 $prevrawline !~ /(?:\\(?:[ntr]|[0-7]{1,3}|x[0-9a-fA-F]{1,2})|;\s*|\{\s*)"\s*$/) {
4844 if (WARN("SPLIT_STRING",
4845 "quoted string split across lines\n" . $hereprev) &&
4846 $fix &&
4847 $prevrawline =~ /^\+.*"\s*$/ &&
4848 $last_coalesced_string_linenr != $linenr - 1) {
4849 my $extracted_string = get_quoted_string($line, $rawline);
4850 my $comma_close = "";
4851 if ($rawline =~ /\Q$extracted_string\E(\s*\)\s*;\s*$|\s*,\s*)/) {
4852 $comma_close = $1;
4853 }
4854
4855 fix_delete_line($fixlinenr - 1, $prevrawline);
4856 fix_delete_line($fixlinenr, $rawline);
4857 my $fixedline = $prevrawline;
4858 $fixedline =~ s/"\s*$//;
4859 $fixedline .= substr($extracted_string, 1) . trim($comma_close);
4860 fix_insert_line($fixlinenr - 1, $fixedline);
4861 $fixedline = $rawline;
4862 $fixedline =~ s/\Q$extracted_string\E\Q$comma_close\E//;
4863 if ($fixedline !~ /\+\s*$/) {
4864 fix_insert_line($fixlinenr, $fixedline);
4865 }
4866 $last_coalesced_string_linenr = $linenr;
4867 }
4868 }
4869
4870# check for missing a space in a string concatenation
4871 if ($prevrawline =~ /[^\\]\w"$/ && $rawline =~ /^\+[\t ]+"\w/) {
4872 WARN('MISSING_SPACE',
4873 "break quoted strings at a space character\n" . $hereprev);
4874 }
4875
4876# check for spaces before a quoted newline
4877 if ($rawline =~ /^.*\".*\s\\n/) {
4878 if (WARN("QUOTED_WHITESPACE_BEFORE_NEWLINE",
4879 "unnecessary whitespace before a quoted newline\n" . $herecurr) &&
4880 $fix) {
4881 $fixed[$fixlinenr] =~ s/^(\+.*\".*)\s+\\n/$1\\n/;
4882 }
4883
4884 }
4885
Joe Perchesf17dba42014-10-13 15:51:51 -07004886# concatenated string without spaces between elements
Joe Perches33acb542015-06-25 15:02:54 -07004887 if ($line =~ /$String[A-Z_]/ || $line =~ /[A-Za-z0-9_]$String/) {
Joe Perchesf17dba42014-10-13 15:51:51 -07004888 CHK("CONCATENATED_STRING",
4889 "Concatenated strings should use spaces between elements\n" . $herecurr);
4890 }
4891
Joe Perches90ad30e2014-12-10 15:51:59 -08004892# uncoalesced string fragments
Joe Perches33acb542015-06-25 15:02:54 -07004893 if ($line =~ /$String\s*"/) {
Joe Perches90ad30e2014-12-10 15:51:59 -08004894 WARN("STRING_FRAGMENTS",
4895 "Consecutive strings are generally better as a single string\n" . $herecurr);
4896 }
4897
Joe Perches6e300752015-09-09 15:37:47 -07004898# check for %L{u,d,i} and 0x%[udi] in strings
Joe Perches5e4f6ba2014-12-10 15:52:05 -08004899 my $string;
4900 while ($line =~ /(?:^|")([X\t]*)(?:"|$)/g) {
4901 $string = substr($rawline, $-[1], $+[1] - $-[1]);
4902 $string =~ s/%%/__/g;
Joe Perches6e300752015-09-09 15:37:47 -07004903 if ($string =~ /(?<!%)%[\*\d\.\$]*L[udi]/) {
Joe Perches5e4f6ba2014-12-10 15:52:05 -08004904 WARN("PRINTF_L",
4905 "\%Ld/%Lu are not-standard C, use %lld/%llu\n" . $herecurr);
4906 last;
4907 }
Joe Perches6e300752015-09-09 15:37:47 -07004908 if ($string =~ /0x%[\*\d\.\$\Llzth]*[udi]/) {
4909 ERROR("PRINTF_0xDECIMAL",
4910 "Prefixing 0x with decimal output is defective\n" . $herecurr);
4911 }
Joe Perches5e4f6ba2014-12-10 15:52:05 -08004912 }
4913
4914# check for line continuations in quoted strings with odd counts of "
4915 if ($rawline =~ /\\$/ && $rawline =~ tr/"/"/ % 2) {
4916 WARN("LINE_CONTINUATIONS",
4917 "Avoid line continuations in quoted strings\n" . $herecurr);
4918 }
4919
Andy Whitcroft00df3442007-06-08 13:47:06 -07004920# warn about #if 0
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004921 if ($line =~ /^.\s*\#\s*if\s+0\b/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07004922 CHK("REDUNDANT_CODE",
4923 "if this code is redundant consider removing it\n" .
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07004924 $herecurr);
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07004925 }
4926
Andy Whitcroft03df4b52012-12-17 16:01:52 -08004927# check for needless "if (<foo>) fn(<foo>)" uses
4928 if ($prevline =~ /\bif\s*\(\s*($Lval)\s*\)/) {
Joe Perches100425d2015-09-09 15:37:36 -07004929 my $tested = quotemeta($1);
4930 my $expr = '\s*\(\s*' . $tested . '\s*\)\s*;';
4931 if ($line =~ /\b(kfree|usb_free_urb|debugfs_remove(?:_recursive)?|(?:kmem_cache|mempool|dma_pool)_destroy)$expr/) {
4932 my $func = $1;
4933 if (WARN('NEEDLESS_IF',
4934 "$func(NULL) is safe and this check is probably not required\n" . $hereprev) &&
4935 $fix) {
4936 my $do_fix = 1;
4937 my $leading_tabs = "";
4938 my $new_leading_tabs = "";
4939 if ($lines[$linenr - 2] =~ /^\+(\t*)if\s*\(\s*$tested\s*\)\s*$/) {
4940 $leading_tabs = $1;
4941 } else {
4942 $do_fix = 0;
4943 }
4944 if ($lines[$linenr - 1] =~ /^\+(\t+)$func\s*\(\s*$tested\s*\)\s*;\s*$/) {
4945 $new_leading_tabs = $1;
4946 if (length($leading_tabs) + 1 ne length($new_leading_tabs)) {
4947 $do_fix = 0;
4948 }
4949 } else {
4950 $do_fix = 0;
4951 }
4952 if ($do_fix) {
4953 fix_delete_line($fixlinenr - 1, $prevrawline);
4954 $fixed[$fixlinenr] =~ s/^\+$new_leading_tabs/\+$leading_tabs/;
4955 }
4956 }
Greg Kroah-Hartman4c432a82008-07-23 21:29:04 -07004957 }
4958 }
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07004959
Joe Perchesebfdc402014-08-06 16:10:27 -07004960# check for unnecessary "Out of Memory" messages
4961 if ($line =~ /^\+.*\b$logFunctions\s*\(/ &&
4962 $prevline =~ /^[ \+]\s*if\s*\(\s*(\!\s*|NULL\s*==\s*)?($Lval)(\s*==\s*NULL\s*)?\s*\)/ &&
4963 (defined $1 || defined $3) &&
4964 $linenr > 3) {
4965 my $testval = $2;
4966 my $testline = $lines[$linenr - 3];
4967
4968 my ($s, $c) = ctx_statement_block($linenr - 3, $realcnt, 0);
4969# print("line: <$line>\nprevline: <$prevline>\ns: <$s>\nc: <$c>\n\n\n");
4970
4971 if ($c =~ /(?:^|\n)[ \+]\s*(?:$Type\s*)?\Q$testval\E\s*=\s*(?:\([^\)]*\)\s*)?\s*(?:devm_)?(?:[kv][czm]alloc(?:_node|_array)?\b|kstrdup|(?:dev_)?alloc_skb)/) {
4972 WARN("OOM_MESSAGE",
4973 "Possible unnecessary 'out of memory' message\n" . $hereprev);
4974 }
4975 }
4976
Joe Perchesf78d98f2014-10-13 15:52:01 -07004977# check for logging functions with KERN_<LEVEL>
Paolo Bonzinidcaf1122015-02-13 14:38:26 -08004978 if ($line !~ /printk(?:_ratelimited|_once)?\s*\(/ &&
Joe Perchesf78d98f2014-10-13 15:52:01 -07004979 $line =~ /\b$logFunctions\s*\(.*\b(KERN_[A-Z]+)\b/) {
4980 my $level = $1;
4981 if (WARN("UNNECESSARY_KERN_LEVEL",
4982 "Possible unnecessary $level\n" . $herecurr) &&
4983 $fix) {
4984 $fixed[$fixlinenr] =~ s/\s*$level\s*//;
4985 }
4986 }
4987
Joe Perchesabb08a52014-12-10 15:51:46 -08004988# check for mask then right shift without a parentheses
4989 if ($^V && $^V ge 5.10.0 &&
4990 $line =~ /$LvalOrFunc\s*\&\s*($LvalOrFunc)\s*>>/ &&
4991 $4 !~ /^\&/) { # $LvalOrFunc may be &foo, ignore if so
4992 WARN("MASK_THEN_SHIFT",
4993 "Possible precedence defect with mask then right shift - may need parentheses\n" . $herecurr);
4994 }
4995
Joe Perchesb75ac612014-12-10 15:52:02 -08004996# check for pointer comparisons to NULL
4997 if ($^V && $^V ge 5.10.0) {
4998 while ($line =~ /\b$LvalOrFunc\s*(==|\!=)\s*NULL\b/g) {
4999 my $val = $1;
5000 my $equal = "!";
5001 $equal = "" if ($4 eq "!=");
5002 if (CHK("COMPARISON_TO_NULL",
5003 "Comparison to NULL could be written \"${equal}${val}\"\n" . $herecurr) &&
5004 $fix) {
5005 $fixed[$fixlinenr] =~ s/\b\Q$val\E\s*(?:==|\!=)\s*NULL\b/$equal$val/;
5006 }
5007 }
5008 }
5009
Joe Perches8716de32013-09-11 14:24:05 -07005010# check for bad placement of section $InitAttribute (e.g.: __initdata)
5011 if ($line =~ /(\b$InitAttribute\b)/) {
5012 my $attr = $1;
5013 if ($line =~ /^\+\s*static\s+(?:const\s+)?(?:$attr\s+)?($NonptrTypeWithAttr)\s+(?:$attr\s+)?($Ident(?:\[[^]]*\])?)\s*[=;]/) {
5014 my $ptr = $1;
5015 my $var = $2;
5016 if ((($ptr =~ /\b(union|struct)\s+$attr\b/ &&
5017 ERROR("MISPLACED_INIT",
5018 "$attr should be placed after $var\n" . $herecurr)) ||
5019 ($ptr !~ /\b(union|struct)\s+$attr\b/ &&
5020 WARN("MISPLACED_INIT",
5021 "$attr should be placed after $var\n" . $herecurr))) &&
5022 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07005023 $fixed[$fixlinenr] =~ s/(\bstatic\s+(?:const\s+)?)(?:$attr\s+)?($NonptrTypeWithAttr)\s+(?:$attr\s+)?($Ident(?:\[[^]]*\])?)\s*([=;])\s*/"$1" . trim(string_find_replace($2, "\\s*$attr\\s*", " ")) . " " . trim(string_find_replace($3, "\\s*$attr\\s*", "")) . " $attr" . ("$4" eq ";" ? ";" : " = ")/e;
Joe Perches8716de32013-09-11 14:24:05 -07005024 }
5025 }
5026 }
5027
Joe Perchese970b8842013-11-12 15:10:10 -08005028# check for $InitAttributeData (ie: __initdata) with const
5029 if ($line =~ /\bconst\b/ && $line =~ /($InitAttributeData)/) {
5030 my $attr = $1;
5031 $attr =~ /($InitAttributePrefix)(.*)/;
5032 my $attr_prefix = $1;
5033 my $attr_type = $2;
5034 if (ERROR("INIT_ATTRIBUTE",
5035 "Use of const init definition must use ${attr_prefix}initconst\n" . $herecurr) &&
5036 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07005037 $fixed[$fixlinenr] =~
Joe Perchese970b8842013-11-12 15:10:10 -08005038 s/$InitAttributeData/${attr_prefix}initconst/;
5039 }
5040 }
5041
5042# check for $InitAttributeConst (ie: __initconst) without const
5043 if ($line !~ /\bconst\b/ && $line =~ /($InitAttributeConst)/) {
5044 my $attr = $1;
5045 if (ERROR("INIT_ATTRIBUTE",
5046 "Use of $attr requires a separate use of const\n" . $herecurr) &&
5047 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07005048 my $lead = $fixed[$fixlinenr] =~
Joe Perchese970b8842013-11-12 15:10:10 -08005049 /(^\+\s*(?:static\s+))/;
5050 $lead = rtrim($1);
5051 $lead = "$lead " if ($lead !~ /^\+$/);
5052 $lead = "${lead}const ";
Joe Perches194f66f2014-08-06 16:11:03 -07005053 $fixed[$fixlinenr] =~ s/(^\+\s*(?:static\s+))/$lead/;
Joe Perchese970b8842013-11-12 15:10:10 -08005054 }
5055 }
5056
Joe Perchesc17893c2015-04-16 12:44:42 -07005057# check for __read_mostly with const non-pointer (should just be const)
5058 if ($line =~ /\b__read_mostly\b/ &&
5059 $line =~ /($Type)\s*$Ident/ && $1 !~ /\*\s*$/ && $1 =~ /\bconst\b/) {
5060 if (ERROR("CONST_READ_MOSTLY",
5061 "Invalid use of __read_mostly with const type\n" . $herecurr) &&
5062 $fix) {
5063 $fixed[$fixlinenr] =~ s/\s+__read_mostly\b//;
5064 }
5065 }
5066
Joe Perchesfbdb8132014-04-03 14:49:14 -07005067# don't use __constant_<foo> functions outside of include/uapi/
5068 if ($realfile !~ m@^include/uapi/@ &&
5069 $line =~ /(__constant_(?:htons|ntohs|[bl]e(?:16|32|64)_to_cpu|cpu_to_[bl]e(?:16|32|64)))\s*\(/) {
5070 my $constant_func = $1;
5071 my $func = $constant_func;
5072 $func =~ s/^__constant_//;
5073 if (WARN("CONSTANT_CONVERSION",
5074 "$constant_func should be $func\n" . $herecurr) &&
5075 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07005076 $fixed[$fixlinenr] =~ s/\b$constant_func\b/$func/g;
Joe Perchesfbdb8132014-04-03 14:49:14 -07005077 }
5078 }
5079
Patrick Pannuto1a15a252010-08-09 17:21:01 -07005080# prefer usleep_range over udelay
Bruce Allan37581c22013-02-21 16:44:19 -08005081 if ($line =~ /\budelay\s*\(\s*(\d+)\s*\)/) {
Joe Perches43c1d772014-04-03 14:49:11 -07005082 my $delay = $1;
Patrick Pannuto1a15a252010-08-09 17:21:01 -07005083 # ignore udelay's < 10, however
Joe Perches43c1d772014-04-03 14:49:11 -07005084 if (! ($delay < 10) ) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005085 CHK("USLEEP_RANGE",
Joe Perches43c1d772014-04-03 14:49:11 -07005086 "usleep_range is preferred over udelay; see Documentation/timers/timers-howto.txt\n" . $herecurr);
5087 }
5088 if ($delay > 2000) {
5089 WARN("LONG_UDELAY",
5090 "long udelay - prefer mdelay; see arch/arm/include/asm/delay.h\n" . $herecurr);
Patrick Pannuto1a15a252010-08-09 17:21:01 -07005091 }
5092 }
5093
Patrick Pannuto09ef8722010-08-09 17:21:02 -07005094# warn about unexpectedly long msleep's
5095 if ($line =~ /\bmsleep\s*\((\d+)\);/) {
5096 if ($1 < 20) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005097 WARN("MSLEEP",
Joe Perches43c1d772014-04-03 14:49:11 -07005098 "msleep < 20ms can sleep for up to 20ms; see Documentation/timers/timers-howto.txt\n" . $herecurr);
Patrick Pannuto09ef8722010-08-09 17:21:02 -07005099 }
5100 }
5101
Joe Perches36ec1932013-07-03 15:05:25 -07005102# check for comparisons of jiffies
5103 if ($line =~ /\bjiffies\s*$Compare|$Compare\s*jiffies\b/) {
5104 WARN("JIFFIES_COMPARISON",
5105 "Comparing jiffies is almost always wrong; prefer time_after, time_before and friends\n" . $herecurr);
5106 }
5107
Joe Perches9d7a34a2013-07-03 15:05:26 -07005108# check for comparisons of get_jiffies_64()
5109 if ($line =~ /\bget_jiffies_64\s*\(\s*\)\s*$Compare|$Compare\s*get_jiffies_64\s*\(\s*\)/) {
5110 WARN("JIFFIES_COMPARISON",
5111 "Comparing get_jiffies_64() is almost always wrong; prefer time_after64, time_before64 and friends\n" . $herecurr);
5112 }
5113
Andy Whitcroft00df3442007-06-08 13:47:06 -07005114# warn about #ifdefs in C files
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07005115# if ($line =~ /^.\s*\#\s*if(|n)def/ && ($realfile =~ /\.c$/)) {
Andy Whitcroft00df3442007-06-08 13:47:06 -07005116# print "#ifdef in C files should be avoided\n";
5117# print "$herecurr";
5118# $clean = 0;
5119# }
5120
Andy Whitcroft22f2a2e2007-08-10 13:01:03 -07005121# warn about spacing in #ifdefs
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07005122 if ($line =~ /^.\s*\#\s*(ifdef|ifndef|elif)\s\s+/) {
Joe Perches3705ce52013-07-03 15:05:31 -07005123 if (ERROR("SPACING",
5124 "exactly one space required after that #$1\n" . $herecurr) &&
5125 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07005126 $fixed[$fixlinenr] =~
Joe Perches3705ce52013-07-03 15:05:31 -07005127 s/^(.\s*\#\s*(ifdef|ifndef|elif))\s{2,}/$1 /;
5128 }
5129
Andy Whitcroft22f2a2e2007-08-10 13:01:03 -07005130 }
5131
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07005132# check for spinlock_t definitions without a comment.
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07005133 if ($line =~ /^.\s*(struct\s+mutex|spinlock_t)\s+\S+;/ ||
5134 $line =~ /^.\s*(DEFINE_MUTEX)\s*\(/) {
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07005135 my $which = $1;
5136 if (!ctx_has_comment($first_line, $linenr)) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005137 CHK("UNCOMMENTED_DEFINITION",
5138 "$1 definition without comment\n" . $herecurr);
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07005139 }
5140 }
5141# check for memory barriers without a comment.
Michael S. Tsirkin402c2552016-01-04 09:39:01 +02005142
5143 my $barriers = qr{
5144 mb|
5145 rmb|
5146 wmb|
5147 read_barrier_depends
5148 }x;
5149 my $barrier_stems = qr{
5150 mb__before_atomic|
5151 mb__after_atomic|
5152 store_release|
5153 load_acquire|
5154 store_mb|
5155 (?:$barriers)
5156 }x;
5157 my $all_barriers = qr{
5158 (?:$barriers)|
Michael S. Tsirkin43e361f2016-01-04 10:00:10 +02005159 smp_(?:$barrier_stems)|
5160 virt_(?:$barrier_stems)
Michael S. Tsirkin402c2552016-01-04 09:39:01 +02005161 }x;
5162
5163 if ($line =~ /\b(?:$all_barriers)\s*\(/) {
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07005164 if (!ctx_has_comment($first_line, $linenr)) {
Joe Perchesc1fd7bb2013-11-12 15:10:11 -08005165 WARN("MEMORY_BARRIER",
5166 "memory barrier without comment\n" . $herecurr);
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07005167 }
5168 }
Paul E. McKenney3ad81772015-07-02 11:55:40 -07005169
Michael S. Tsirkinf4073b02016-01-04 09:54:51 +02005170 my $underscore_smp_barriers = qr{__smp_(?:$barrier_stems)}x;
5171
5172 if ($realfile !~ m@^include/asm-generic/@ &&
5173 $realfile !~ m@/barrier\.h$@ &&
5174 $line =~ m/\b(?:$underscore_smp_barriers)\s*\(/ &&
5175 $line !~ m/^.\s*\#\s*define\s+(?:$underscore_smp_barriers)\s*\(/) {
5176 WARN("MEMORY_BARRIER",
5177 "__smp memory barriers shouldn't be used outside barrier.h and asm-generic\n" . $herecurr);
5178 }
5179
Joe Perchescb426e92015-06-25 15:02:46 -07005180# check for waitqueue_active without a comment.
5181 if ($line =~ /\bwaitqueue_active\s*\(/) {
5182 if (!ctx_has_comment($first_line, $linenr)) {
5183 WARN("WAITQUEUE_ACTIVE",
5184 "waitqueue_active without comment\n" . $herecurr);
5185 }
5186 }
Paul E. McKenney3ad81772015-07-02 11:55:40 -07005187
5188# Check for expedited grace periods that interrupt non-idle non-nohz
5189# online CPUs. These expedited can therefore degrade real-time response
5190# if used carelessly, and should be avoided where not absolutely
5191# needed. It is always OK to use synchronize_rcu_expedited() and
5192# synchronize_sched_expedited() at boot time (before real-time applications
5193# start) and in error situations where real-time response is compromised in
5194# any case. Note that synchronize_srcu_expedited() does -not- interrupt
5195# other CPUs, so don't warn on uses of synchronize_srcu_expedited().
5196# Of course, nothing comes for free, and srcu_read_lock() and
5197# srcu_read_unlock() do contain full memory barriers in payment for
5198# synchronize_srcu_expedited() non-interruption properties.
5199 if ($line =~ /\b(synchronize_rcu_expedited|synchronize_sched_expedited)\(/) {
5200 WARN("EXPEDITED_RCU_GRACE_PERIOD",
5201 "expedited RCU grace periods should be avoided where they can degrade real-time response\n" . $herecurr);
5202
5203 }
5204
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07005205# check of hardware specific defines
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07005206 if ($line =~ m@^.\s*\#\s*if.*\b(__i386__|__powerpc64__|__sun__|__s390x__)\b@ && $realfile !~ m@include/asm-@) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005207 CHK("ARCH_DEFINES",
5208 "architecture specific defines should be avoided\n" . $herecurr);
Andy Whitcroft0a920b52007-06-01 00:46:48 -07005209 }
Andy Whitcroft653d4872007-06-23 17:16:34 -07005210
Tobias Klauserd4977c72010-05-24 14:33:30 -07005211# Check that the storage class is at the beginning of a declaration
5212 if ($line =~ /\b$Storage\b/ && $line !~ /^.\s*$Storage\b/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005213 WARN("STORAGE_CLASS",
5214 "storage class should be at the beginning of the declaration\n" . $herecurr)
Tobias Klauserd4977c72010-05-24 14:33:30 -07005215 }
5216
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07005217# check the location of the inline attribute, that it is between
5218# storage class and type.
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07005219 if ($line =~ /\b$Type\s+$Inline\b/ ||
5220 $line =~ /\b$Inline\s+$Storage\b/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005221 ERROR("INLINE_LOCATION",
5222 "inline keyword should sit between storage class and type\n" . $herecurr);
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07005223 }
5224
Andy Whitcroft8905a672007-11-28 16:21:06 -08005225# Check for __inline__ and __inline, prefer inline
Joe Perches2b7ab452013-11-12 15:10:14 -08005226 if ($realfile !~ m@\binclude/uapi/@ &&
5227 $line =~ /\b(__inline__|__inline)\b/) {
Joe Perchesd5e616f2013-09-11 14:23:54 -07005228 if (WARN("INLINE",
5229 "plain inline is preferred over $1\n" . $herecurr) &&
5230 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07005231 $fixed[$fixlinenr] =~ s/\b(__inline__|__inline)\b/inline/;
Joe Perchesd5e616f2013-09-11 14:23:54 -07005232
5233 }
Andy Whitcroft8905a672007-11-28 16:21:06 -08005234 }
5235
Joe Perches3d130fd2011-01-12 17:00:00 -08005236# Check for __attribute__ packed, prefer __packed
Joe Perches2b7ab452013-11-12 15:10:14 -08005237 if ($realfile !~ m@\binclude/uapi/@ &&
5238 $line =~ /\b__attribute__\s*\(\s*\(.*\bpacked\b/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005239 WARN("PREFER_PACKED",
5240 "__packed is preferred over __attribute__((packed))\n" . $herecurr);
Joe Perches3d130fd2011-01-12 17:00:00 -08005241 }
5242
Joe Perches39b7e282011-07-25 17:13:24 -07005243# Check for __attribute__ aligned, prefer __aligned
Joe Perches2b7ab452013-11-12 15:10:14 -08005244 if ($realfile !~ m@\binclude/uapi/@ &&
5245 $line =~ /\b__attribute__\s*\(\s*\(.*aligned/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005246 WARN("PREFER_ALIGNED",
5247 "__aligned(size) is preferred over __attribute__((aligned(size)))\n" . $herecurr);
Joe Perches39b7e282011-07-25 17:13:24 -07005248 }
5249
Joe Perches5f14d3b2012-01-10 15:09:52 -08005250# Check for __attribute__ format(printf, prefer __printf
Joe Perches2b7ab452013-11-12 15:10:14 -08005251 if ($realfile !~ m@\binclude/uapi/@ &&
5252 $line =~ /\b__attribute__\s*\(\s*\(\s*format\s*\(\s*printf/) {
Joe Perchesd5e616f2013-09-11 14:23:54 -07005253 if (WARN("PREFER_PRINTF",
5254 "__printf(string-index, first-to-check) is preferred over __attribute__((format(printf, string-index, first-to-check)))\n" . $herecurr) &&
5255 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07005256 $fixed[$fixlinenr] =~ s/\b__attribute__\s*\(\s*\(\s*format\s*\(\s*printf\s*,\s*(.*)\)\s*\)\s*\)/"__printf(" . trim($1) . ")"/ex;
Joe Perchesd5e616f2013-09-11 14:23:54 -07005257
5258 }
Joe Perches5f14d3b2012-01-10 15:09:52 -08005259 }
5260
Joe Perches6061d942012-03-23 15:02:16 -07005261# Check for __attribute__ format(scanf, prefer __scanf
Joe Perches2b7ab452013-11-12 15:10:14 -08005262 if ($realfile !~ m@\binclude/uapi/@ &&
5263 $line =~ /\b__attribute__\s*\(\s*\(\s*format\s*\(\s*scanf\b/) {
Joe Perchesd5e616f2013-09-11 14:23:54 -07005264 if (WARN("PREFER_SCANF",
5265 "__scanf(string-index, first-to-check) is preferred over __attribute__((format(scanf, string-index, first-to-check)))\n" . $herecurr) &&
5266 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07005267 $fixed[$fixlinenr] =~ s/\b__attribute__\s*\(\s*\(\s*format\s*\(\s*scanf\s*,\s*(.*)\)\s*\)\s*\)/"__scanf(" . trim($1) . ")"/ex;
Joe Perchesd5e616f2013-09-11 14:23:54 -07005268 }
Joe Perches6061d942012-03-23 15:02:16 -07005269 }
5270
Joe Perches619a9082014-12-10 15:51:35 -08005271# Check for __attribute__ weak, or __weak declarations (may have link issues)
5272 if ($^V && $^V ge 5.10.0 &&
5273 $line =~ /(?:$Declare|$DeclareMisordered)\s*$Ident\s*$balanced_parens\s*(?:$Attribute)?\s*;/ &&
5274 ($line =~ /\b__attribute__\s*\(\s*\(.*\bweak\b/ ||
5275 $line =~ /\b__weak\b/)) {
5276 ERROR("WEAK_DECLARATION",
5277 "Using weak declarations can have unintended link defects\n" . $herecurr);
5278 }
5279
Joe Perchese6176fa2015-06-25 15:02:49 -07005280# check for c99 types like uint8_t used outside of uapi/
5281 if ($realfile !~ m@\binclude/uapi/@ &&
5282 $line =~ /\b($Declare)\s*$Ident\s*[=;,\[]/) {
5283 my $type = $1;
5284 if ($type =~ /\b($typeC99Typedefs)\b/) {
5285 $type = $1;
5286 my $kernel_type = 'u';
5287 $kernel_type = 's' if ($type =~ /^_*[si]/);
5288 $type =~ /(\d+)/;
5289 $kernel_type .= $1;
5290 if (CHK("PREFER_KERNEL_TYPES",
5291 "Prefer kernel type '$kernel_type' over '$type'\n" . $herecurr) &&
5292 $fix) {
5293 $fixed[$fixlinenr] =~ s/\b$type\b/$kernel_type/;
5294 }
5295 }
5296 }
5297
Joe Perches938224b2016-01-20 14:59:15 -08005298# check for cast of C90 native int or longer types constants
5299 if ($line =~ /(\(\s*$C90_int_types\s*\)\s*)($Constant)\b/) {
5300 my $cast = $1;
5301 my $const = $2;
5302 if (WARN("TYPECAST_INT_CONSTANT",
5303 "Unnecessary typecast of c90 int constant\n" . $herecurr) &&
5304 $fix) {
5305 my $suffix = "";
5306 my $newconst = $const;
5307 $newconst =~ s/${Int_type}$//;
5308 $suffix .= 'U' if ($cast =~ /\bunsigned\b/);
5309 if ($cast =~ /\blong\s+long\b/) {
5310 $suffix .= 'LL';
5311 } elsif ($cast =~ /\blong\b/) {
5312 $suffix .= 'L';
5313 }
5314 $fixed[$fixlinenr] =~ s/\Q$cast\E$const\b/$newconst$suffix/;
5315 }
5316 }
5317
Joe Perches8f53a9b2010-03-05 13:43:48 -08005318# check for sizeof(&)
5319 if ($line =~ /\bsizeof\s*\(\s*\&/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005320 WARN("SIZEOF_ADDRESS",
5321 "sizeof(& should be avoided\n" . $herecurr);
Joe Perches8f53a9b2010-03-05 13:43:48 -08005322 }
5323
Joe Perches66c80b62012-07-30 14:41:22 -07005324# check for sizeof without parenthesis
5325 if ($line =~ /\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/) {
Joe Perchesd5e616f2013-09-11 14:23:54 -07005326 if (WARN("SIZEOF_PARENTHESIS",
5327 "sizeof $1 should be sizeof($1)\n" . $herecurr) &&
5328 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07005329 $fixed[$fixlinenr] =~ s/\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/"sizeof(" . trim($1) . ")"/ex;
Joe Perchesd5e616f2013-09-11 14:23:54 -07005330 }
Joe Perches66c80b62012-07-30 14:41:22 -07005331 }
5332
Joe Perches88982fe2012-12-17 16:02:00 -08005333# check for struct spinlock declarations
5334 if ($line =~ /^.\s*\bstruct\s+spinlock\s+\w+\s*;/) {
5335 WARN("USE_SPINLOCK_T",
5336 "struct spinlock should be spinlock_t\n" . $herecurr);
5337 }
5338
Joe Perchesa6962d72013-04-29 16:18:13 -07005339# check for seq_printf uses that could be seq_puts
Joe Perches06668722013-11-12 15:10:07 -08005340 if ($sline =~ /\bseq_printf\s*\(.*"\s*\)\s*;\s*$/) {
Joe Perchesa6962d72013-04-29 16:18:13 -07005341 my $fmt = get_quoted_string($line, $rawline);
Heba Aamercaac1d52015-02-13 14:38:49 -08005342 $fmt =~ s/%%//g;
5343 if ($fmt !~ /%/) {
Joe Perchesd5e616f2013-09-11 14:23:54 -07005344 if (WARN("PREFER_SEQ_PUTS",
5345 "Prefer seq_puts to seq_printf\n" . $herecurr) &&
5346 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07005347 $fixed[$fixlinenr] =~ s/\bseq_printf\b/seq_puts/;
Joe Perchesd5e616f2013-09-11 14:23:54 -07005348 }
Joe Perchesa6962d72013-04-29 16:18:13 -07005349 }
5350 }
5351
Andy Whitcroft554e1652012-01-10 15:09:57 -08005352# Check for misused memsets
Joe Perchesd1fe9c02012-03-23 15:02:16 -07005353 if ($^V && $^V ge 5.10.0 &&
5354 defined $stat &&
Mateusz Kulikowski9e20a852015-06-25 15:03:16 -07005355 $stat =~ /^\+(?:.*?)\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*$FuncArg\s*\)/) {
Andy Whitcroft554e1652012-01-10 15:09:57 -08005356
Joe Perchesd7c76ba2012-01-10 15:09:58 -08005357 my $ms_addr = $2;
Joe Perchesd1fe9c02012-03-23 15:02:16 -07005358 my $ms_val = $7;
5359 my $ms_size = $12;
Joe Perchesd7c76ba2012-01-10 15:09:58 -08005360
Andy Whitcroft554e1652012-01-10 15:09:57 -08005361 if ($ms_size =~ /^(0x|)0$/i) {
5362 ERROR("MEMSET",
Joe Perchesd7c76ba2012-01-10 15:09:58 -08005363 "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 -08005364 } elsif ($ms_size =~ /^(0x|)1$/i) {
5365 WARN("MEMSET",
Joe Perchesd7c76ba2012-01-10 15:09:58 -08005366 "single byte memset is suspicious. Swapped 2nd/3rd argument?\n" . "$here\n$stat\n");
5367 }
5368 }
5369
Joe Perches98a9bba2014-01-23 15:54:52 -08005370# Check for memcpy(foo, bar, ETH_ALEN) that could be ether_addr_copy(foo, bar)
5371 if ($^V && $^V ge 5.10.0 &&
Mateusz Kulikowski10895d22015-06-25 15:03:21 -07005372 defined $stat &&
5373 $stat =~ /^\+(?:.*?)\bmemcpy\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/) {
Joe Perches98a9bba2014-01-23 15:54:52 -08005374 if (WARN("PREFER_ETHER_ADDR_COPY",
Mateusz Kulikowski10895d22015-06-25 15:03:21 -07005375 "Prefer ether_addr_copy() over memcpy() if the Ethernet addresses are __aligned(2)\n" . "$here\n$stat\n") &&
Joe Perches98a9bba2014-01-23 15:54:52 -08005376 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07005377 $fixed[$fixlinenr] =~ s/\bmemcpy\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/ether_addr_copy($2, $7)/;
Joe Perches98a9bba2014-01-23 15:54:52 -08005378 }
5379 }
5380
Mateusz Kulikowskib6117d12015-06-25 15:03:13 -07005381# Check for memcmp(foo, bar, ETH_ALEN) that could be ether_addr_equal*(foo, bar)
5382 if ($^V && $^V ge 5.10.0 &&
5383 defined $stat &&
5384 $stat =~ /^\+(?:.*?)\bmemcmp\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/) {
5385 WARN("PREFER_ETHER_ADDR_EQUAL",
5386 "Prefer ether_addr_equal() or ether_addr_equal_unaligned() over memcmp()\n" . "$here\n$stat\n")
5387 }
5388
Mateusz Kulikowski8617cd02015-06-25 15:03:19 -07005389# check for memset(foo, 0x0, ETH_ALEN) that could be eth_zero_addr
5390# check for memset(foo, 0xFF, ETH_ALEN) that could be eth_broadcast_addr
5391 if ($^V && $^V ge 5.10.0 &&
5392 defined $stat &&
5393 $stat =~ /^\+(?:.*?)\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/) {
5394
5395 my $ms_val = $7;
5396
5397 if ($ms_val =~ /^(?:0x|)0+$/i) {
5398 if (WARN("PREFER_ETH_ZERO_ADDR",
5399 "Prefer eth_zero_addr over memset()\n" . "$here\n$stat\n") &&
5400 $fix) {
5401 $fixed[$fixlinenr] =~ s/\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*,\s*ETH_ALEN\s*\)/eth_zero_addr($2)/;
5402 }
5403 } elsif ($ms_val =~ /^(?:0xff|255)$/i) {
5404 if (WARN("PREFER_ETH_BROADCAST_ADDR",
5405 "Prefer eth_broadcast_addr() over memset()\n" . "$here\n$stat\n") &&
5406 $fix) {
5407 $fixed[$fixlinenr] =~ s/\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*,\s*ETH_ALEN\s*\)/eth_broadcast_addr($2)/;
5408 }
5409 }
5410 }
5411
Joe Perchesd7c76ba2012-01-10 15:09:58 -08005412# typecasts on min/max could be min_t/max_t
Joe Perchesd1fe9c02012-03-23 15:02:16 -07005413 if ($^V && $^V ge 5.10.0 &&
5414 defined $stat &&
Joe Perchesd7c76ba2012-01-10 15:09:58 -08005415 $stat =~ /^\+(?:.*?)\b(min|max)\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\)/) {
Joe Perchesd1fe9c02012-03-23 15:02:16 -07005416 if (defined $2 || defined $7) {
Joe Perchesd7c76ba2012-01-10 15:09:58 -08005417 my $call = $1;
5418 my $cast1 = deparenthesize($2);
5419 my $arg1 = $3;
Joe Perchesd1fe9c02012-03-23 15:02:16 -07005420 my $cast2 = deparenthesize($7);
5421 my $arg2 = $8;
Joe Perchesd7c76ba2012-01-10 15:09:58 -08005422 my $cast;
5423
Joe Perchesd1fe9c02012-03-23 15:02:16 -07005424 if ($cast1 ne "" && $cast2 ne "" && $cast1 ne $cast2) {
Joe Perchesd7c76ba2012-01-10 15:09:58 -08005425 $cast = "$cast1 or $cast2";
5426 } elsif ($cast1 ne "") {
5427 $cast = $cast1;
5428 } else {
5429 $cast = $cast2;
5430 }
5431 WARN("MINMAX",
5432 "$call() should probably be ${call}_t($cast, $arg1, $arg2)\n" . "$here\n$stat\n");
Andy Whitcroft554e1652012-01-10 15:09:57 -08005433 }
5434 }
5435
Joe Perches4a273192012-07-30 14:41:20 -07005436# check usleep_range arguments
5437 if ($^V && $^V ge 5.10.0 &&
5438 defined $stat &&
5439 $stat =~ /^\+(?:.*?)\busleep_range\s*\(\s*($FuncArg)\s*,\s*($FuncArg)\s*\)/) {
5440 my $min = $1;
5441 my $max = $7;
5442 if ($min eq $max) {
5443 WARN("USLEEP_RANGE",
5444 "usleep_range should not use min == max args; see Documentation/timers/timers-howto.txt\n" . "$here\n$stat\n");
5445 } elsif ($min =~ /^\d+$/ && $max =~ /^\d+$/ &&
5446 $min > $max) {
5447 WARN("USLEEP_RANGE",
5448 "usleep_range args reversed, use min then max; see Documentation/timers/timers-howto.txt\n" . "$here\n$stat\n");
5449 }
5450 }
5451
Joe Perches823b7942013-11-12 15:10:15 -08005452# check for naked sscanf
5453 if ($^V && $^V ge 5.10.0 &&
5454 defined $stat &&
Joe Perches6c8bd702014-04-03 14:49:16 -07005455 $line =~ /\bsscanf\b/ &&
Joe Perches823b7942013-11-12 15:10:15 -08005456 ($stat !~ /$Ident\s*=\s*sscanf\s*$balanced_parens/ &&
5457 $stat !~ /\bsscanf\s*$balanced_parens\s*(?:$Compare)/ &&
5458 $stat !~ /(?:$Compare)\s*\bsscanf\s*$balanced_parens/)) {
5459 my $lc = $stat =~ tr@\n@@;
5460 $lc = $lc + $linenr;
5461 my $stat_real = raw_line($linenr, 0);
5462 for (my $count = $linenr + 1; $count <= $lc; $count++) {
5463 $stat_real = $stat_real . "\n" . raw_line($count, 0);
5464 }
5465 WARN("NAKED_SSCANF",
5466 "unchecked sscanf return value\n" . "$here\n$stat_real\n");
5467 }
5468
Joe Perchesafc819a2014-06-04 16:12:08 -07005469# check for simple sscanf that should be kstrto<foo>
5470 if ($^V && $^V ge 5.10.0 &&
5471 defined $stat &&
5472 $line =~ /\bsscanf\b/) {
5473 my $lc = $stat =~ tr@\n@@;
5474 $lc = $lc + $linenr;
5475 my $stat_real = raw_line($linenr, 0);
5476 for (my $count = $linenr + 1; $count <= $lc; $count++) {
5477 $stat_real = $stat_real . "\n" . raw_line($count, 0);
5478 }
5479 if ($stat_real =~ /\bsscanf\b\s*\(\s*$FuncArg\s*,\s*("[^"]+")/) {
5480 my $format = $6;
5481 my $count = $format =~ tr@%@%@;
5482 if ($count == 1 &&
5483 $format =~ /^"\%(?i:ll[udxi]|[udxi]ll|ll|[hl]h?[udxi]|[udxi][hl]h?|[hl]h?|[udxi])"$/) {
5484 WARN("SSCANF_TO_KSTRTO",
5485 "Prefer kstrto<type> to single variable sscanf\n" . "$here\n$stat_real\n");
5486 }
5487 }
5488 }
5489
Joe Perches70dc8a42013-09-11 14:23:58 -07005490# check for new externs in .h files.
5491 if ($realfile =~ /\.h$/ &&
5492 $line =~ /^\+\s*(extern\s+)$Type\s*$Ident\s*\(/s) {
Joe Perchesd1d85782013-09-24 15:27:46 -07005493 if (CHK("AVOID_EXTERNS",
5494 "extern prototypes should be avoided in .h files\n" . $herecurr) &&
Joe Perches70dc8a42013-09-11 14:23:58 -07005495 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07005496 $fixed[$fixlinenr] =~ s/(.*)\bextern\b\s*(.*)/$1$2/;
Joe Perches70dc8a42013-09-11 14:23:58 -07005497 }
5498 }
5499
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07005500# check for new externs in .c files.
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07005501 if ($realfile =~ /\.c$/ && defined $stat &&
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07005502 $stat =~ /^.\s*(?:extern\s+)?$Type\s+($Ident)(\s*)\(/s)
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07005503 {
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07005504 my $function_name = $1;
5505 my $paren_space = $2;
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07005506
5507 my $s = $stat;
5508 if (defined $cond) {
5509 substr($s, 0, length($cond), '');
5510 }
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07005511 if ($s =~ /^\s*;/ &&
5512 $function_name ne 'uninitialized_var')
5513 {
Joe Perches000d1cc12011-07-25 17:13:25 -07005514 WARN("AVOID_EXTERNS",
5515 "externs should be avoided in .c files\n" . $herecurr);
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07005516 }
5517
5518 if ($paren_space =~ /\n/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005519 WARN("FUNCTION_ARGUMENTS",
5520 "arguments for function declarations should follow identifier\n" . $herecurr);
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07005521 }
Andy Whitcroft9c9ba342008-04-29 00:59:33 -07005522
5523 } elsif ($realfile =~ /\.c$/ && defined $stat &&
5524 $stat =~ /^.\s*extern\s+/)
5525 {
Joe Perches000d1cc12011-07-25 17:13:25 -07005526 WARN("AVOID_EXTERNS",
5527 "externs should be avoided in .c files\n" . $herecurr);
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07005528 }
5529
5530# checks for new __setup's
5531 if ($rawline =~ /\b__setup\("([^"]*)"/) {
5532 my $name = $1;
5533
5534 if (!grep(/$name/, @setup_docs)) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005535 CHK("UNDOCUMENTED_SETUP",
5536 "__setup appears un-documented -- check Documentation/kernel-parameters.txt\n" . $herecurr);
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07005537 }
Andy Whitcroft653d4872007-06-23 17:16:34 -07005538 }
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07005539
5540# check for pointless casting of kmalloc return
Joe Perchescaf2a542011-01-12 16:59:56 -08005541 if ($line =~ /\*\s*\)\s*[kv][czm]alloc(_node){0,1}\b/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005542 WARN("UNNECESSARY_CASTS",
5543 "unnecessary cast may hide bugs, see http://c-faq.com/malloc/mallocnocast.html\n" . $herecurr);
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07005544 }
Andy Whitcroft13214ad2008-02-08 04:22:03 -08005545
Joe Perchesa640d252013-07-03 15:05:21 -07005546# alloc style
5547# p = alloc(sizeof(struct foo), ...) should be p = alloc(sizeof(*p), ...)
5548 if ($^V && $^V ge 5.10.0 &&
5549 $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*([kv][mz]alloc(?:_node)?)\s*\(\s*(sizeof\s*\(\s*struct\s+$Lval\s*\))/) {
5550 CHK("ALLOC_SIZEOF_STRUCT",
5551 "Prefer $3(sizeof(*$1)...) over $3($4...)\n" . $herecurr);
5552 }
5553
Joe Perches60a55362014-06-04 16:12:07 -07005554# check for k[mz]alloc with multiplies that could be kmalloc_array/kcalloc
5555 if ($^V && $^V ge 5.10.0 &&
Joe Perchese3674552014-08-06 16:10:55 -07005556 $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*(k[mz]alloc)\s*\(\s*($FuncArg)\s*\*\s*($FuncArg)\s*,/) {
Joe Perches60a55362014-06-04 16:12:07 -07005557 my $oldfunc = $3;
5558 my $a1 = $4;
5559 my $a2 = $10;
5560 my $newfunc = "kmalloc_array";
5561 $newfunc = "kcalloc" if ($oldfunc eq "kzalloc");
Joe Perchese3674552014-08-06 16:10:55 -07005562 my $r1 = $a1;
5563 my $r2 = $a2;
5564 if ($a1 =~ /^sizeof\s*\S/) {
5565 $r1 = $a2;
5566 $r2 = $a1;
5567 }
5568 if ($r1 !~ /^sizeof\b/ && $r2 =~ /^sizeof\s*\S/ &&
5569 !($r1 =~ /^$Constant$/ || $r1 =~ /^[A-Z_][A-Z0-9_]*$/)) {
Joe Perches60a55362014-06-04 16:12:07 -07005570 if (WARN("ALLOC_WITH_MULTIPLY",
5571 "Prefer $newfunc over $oldfunc with multiply\n" . $herecurr) &&
5572 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07005573 $fixed[$fixlinenr] =~ s/\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*(k[mz]alloc)\s*\(\s*($FuncArg)\s*\*\s*($FuncArg)/$1 . ' = ' . "$newfunc(" . trim($r1) . ', ' . trim($r2)/e;
Joe Perches60a55362014-06-04 16:12:07 -07005574
5575 }
5576 }
5577 }
5578
Joe Perches972fdea2013-04-29 16:18:12 -07005579# check for krealloc arg reuse
5580 if ($^V && $^V ge 5.10.0 &&
5581 $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*krealloc\s*\(\s*\1\s*,/) {
5582 WARN("KREALLOC_ARG_REUSE",
5583 "Reusing the krealloc arg is almost always a bug\n" . $herecurr);
5584 }
5585
Joe Perches5ce59ae2013-02-21 16:44:18 -08005586# check for alloc argument mismatch
5587 if ($line =~ /\b(kcalloc|kmalloc_array)\s*\(\s*sizeof\b/) {
5588 WARN("ALLOC_ARRAY_ARGS",
5589 "$1 uses number as first arg, sizeof is generally wrong\n" . $herecurr);
5590 }
5591
Joe Perchescaf2a542011-01-12 16:59:56 -08005592# check for multiple semicolons
5593 if ($line =~ /;\s*;\s*$/) {
Joe Perchesd5e616f2013-09-11 14:23:54 -07005594 if (WARN("ONE_SEMICOLON",
5595 "Statements terminations use 1 semicolon\n" . $herecurr) &&
5596 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07005597 $fixed[$fixlinenr] =~ s/(\s*;\s*){2,}$/;/g;
Joe Perchesd5e616f2013-09-11 14:23:54 -07005598 }
Joe Perchesd1e2ad02012-12-17 16:02:01 -08005599 }
5600
Joe Perches0ab90192014-12-10 15:51:57 -08005601# check for #defines like: 1 << <digit> that could be BIT(digit)
5602 if ($line =~ /#\s*define\s+\w+\s+\(?\s*1\s*([ulUL]*)\s*\<\<\s*(?:\d+|$Ident)\s*\)?/) {
5603 my $ull = "";
5604 $ull = "_ULL" if (defined($1) && $1 =~ /ll/i);
5605 if (CHK("BIT_MACRO",
5606 "Prefer using the BIT$ull macro\n" . $herecurr) &&
5607 $fix) {
5608 $fixed[$fixlinenr] =~ s/\(?\s*1\s*[ulUL]*\s*<<\s*(\d+|$Ident)\s*\)?/BIT${ull}($1)/;
5609 }
5610 }
5611
Joe Perchese81f2392014-08-06 16:11:25 -07005612# check for case / default statements not preceded by break/fallthrough/switch
Joe Perchesc34c09a2014-01-23 15:54:43 -08005613 if ($line =~ /^.\s*(?:case\s+(?:$Ident|$Constant)\s*|default):/) {
5614 my $has_break = 0;
5615 my $has_statement = 0;
5616 my $count = 0;
5617 my $prevline = $linenr;
Joe Perchese81f2392014-08-06 16:11:25 -07005618 while ($prevline > 1 && ($file || $count < 3) && !$has_break) {
Joe Perchesc34c09a2014-01-23 15:54:43 -08005619 $prevline--;
5620 my $rline = $rawlines[$prevline - 1];
5621 my $fline = $lines[$prevline - 1];
5622 last if ($fline =~ /^\@\@/);
5623 next if ($fline =~ /^\-/);
5624 next if ($fline =~ /^.(?:\s*(?:case\s+(?:$Ident|$Constant)[\s$;]*|default):[\s$;]*)*$/);
5625 $has_break = 1 if ($rline =~ /fall[\s_-]*(through|thru)/i);
5626 next if ($fline =~ /^.[\s$;]*$/);
5627 $has_statement = 1;
5628 $count++;
5629 $has_break = 1 if ($fline =~ /\bswitch\b|\b(?:break\s*;[\s$;]*$|return\b|goto\b|continue\b)/);
5630 }
5631 if (!$has_break && $has_statement) {
5632 WARN("MISSING_BREAK",
5633 "Possible switch case/default not preceeded by break or fallthrough comment\n" . $herecurr);
5634 }
5635 }
5636
Joe Perchesd1e2ad02012-12-17 16:02:01 -08005637# check for switch/default statements without a break;
5638 if ($^V && $^V ge 5.10.0 &&
5639 defined $stat &&
5640 $stat =~ /^\+[$;\s]*(?:case[$;\s]+\w+[$;\s]*:[$;\s]*|)*[$;\s]*\bdefault[$;\s]*:[$;\s]*;/g) {
5641 my $ctx = '';
5642 my $herectx = $here . "\n";
5643 my $cnt = statement_rawlines($stat);
5644 for (my $n = 0; $n < $cnt; $n++) {
5645 $herectx .= raw_line($linenr, $n) . "\n";
5646 }
5647 WARN("DEFAULT_NO_BREAK",
5648 "switch default: should use break\n" . $herectx);
Joe Perchescaf2a542011-01-12 16:59:56 -08005649 }
5650
Andy Whitcroft13214ad2008-02-08 04:22:03 -08005651# check for gcc specific __FUNCTION__
Joe Perchesd5e616f2013-09-11 14:23:54 -07005652 if ($line =~ /\b__FUNCTION__\b/) {
5653 if (WARN("USE_FUNC",
5654 "__func__ should be used instead of gcc specific __FUNCTION__\n" . $herecurr) &&
5655 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07005656 $fixed[$fixlinenr] =~ s/\b__FUNCTION__\b/__func__/g;
Joe Perchesd5e616f2013-09-11 14:23:54 -07005657 }
Andy Whitcroft13214ad2008-02-08 04:22:03 -08005658 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07005659
Joe Perches62ec8182015-02-13 14:38:18 -08005660# check for uses of __DATE__, __TIME__, __TIMESTAMP__
5661 while ($line =~ /\b(__(?:DATE|TIME|TIMESTAMP)__)\b/g) {
5662 ERROR("DATE_TIME",
5663 "Use of the '$1' macro makes the build non-deterministic\n" . $herecurr);
5664 }
5665
Joe Perches2c924882012-03-23 15:02:20 -07005666# check for use of yield()
5667 if ($line =~ /\byield\s*\(\s*\)/) {
5668 WARN("YIELD",
5669 "Using yield() is generally wrong. See yield() kernel-doc (sched/core.c)\n" . $herecurr);
5670 }
5671
Joe Perches179f8f42013-07-03 15:05:30 -07005672# check for comparisons against true and false
5673 if ($line =~ /\+\s*(.*?)\b(true|false|$Lval)\s*(==|\!=)\s*(true|false|$Lval)\b(.*)$/i) {
5674 my $lead = $1;
5675 my $arg = $2;
5676 my $test = $3;
5677 my $otype = $4;
5678 my $trail = $5;
5679 my $op = "!";
5680
5681 ($arg, $otype) = ($otype, $arg) if ($arg =~ /^(?:true|false)$/i);
5682
5683 my $type = lc($otype);
5684 if ($type =~ /^(?:true|false)$/) {
5685 if (("$test" eq "==" && "$type" eq "true") ||
5686 ("$test" eq "!=" && "$type" eq "false")) {
5687 $op = "";
5688 }
5689
5690 CHK("BOOL_COMPARISON",
5691 "Using comparison to $otype is error prone\n" . $herecurr);
5692
5693## maybe suggesting a correct construct would better
5694## "Using comparison to $otype is error prone. Perhaps use '${lead}${op}${arg}${trail}'\n" . $herecurr);
5695
5696 }
5697 }
5698
Thomas Gleixner4882720b2010-09-07 14:34:01 +00005699# check for semaphores initialized locked
5700 if ($line =~ /^.\s*sema_init.+,\W?0\W?\)/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005701 WARN("CONSIDER_COMPLETION",
5702 "consider using a completion\n" . $herecurr);
Andy Whitcroft773647a2008-03-28 14:15:58 -07005703 }
Joe Perches6712d852012-03-23 15:02:20 -07005704
Joe Perches67d0a072011-10-31 17:13:10 -07005705# recommend kstrto* over simple_strto* and strict_strto*
5706 if ($line =~ /\b((simple|strict)_(strto(l|ll|ul|ull)))\s*\(/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005707 WARN("CONSIDER_KSTRTO",
Joe Perches67d0a072011-10-31 17:13:10 -07005708 "$1 is obsolete, use k$3 instead\n" . $herecurr);
Andy Whitcroft773647a2008-03-28 14:15:58 -07005709 }
Joe Perches6712d852012-03-23 15:02:20 -07005710
Fabian Frederickae3ccc42014-06-04 16:12:10 -07005711# check for __initcall(), use device_initcall() explicitly or more appropriate function please
Michael Ellermanf3db6632008-07-23 21:28:57 -07005712 if ($line =~ /^.\s*__initcall\s*\(/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005713 WARN("USE_DEVICE_INITCALL",
Fabian Frederickae3ccc42014-06-04 16:12:10 -07005714 "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 -07005715 }
Joe Perches6712d852012-03-23 15:02:20 -07005716
Joe Perches0f3c5aa2015-02-13 14:39:05 -08005717# check for various structs that are normally const (ops, kgdb, device_tree)
5718 my $const_structs = qr{
5719 acpi_dock_ops|
Emese Revfy79404842010-03-05 13:43:53 -08005720 address_space_operations|
5721 backlight_ops|
5722 block_device_operations|
5723 dentry_operations|
5724 dev_pm_ops|
5725 dma_map_ops|
5726 extent_io_ops|
5727 file_lock_operations|
5728 file_operations|
5729 hv_ops|
5730 ide_dma_ops|
5731 intel_dvo_dev_ops|
5732 item_operations|
5733 iwl_ops|
5734 kgdb_arch|
5735 kgdb_io|
5736 kset_uevent_ops|
5737 lock_manager_operations|
5738 microcode_ops|
5739 mtrr_ops|
5740 neigh_ops|
5741 nlmsvc_binding|
Joe Perches0f3c5aa2015-02-13 14:39:05 -08005742 of_device_id|
Emese Revfy79404842010-03-05 13:43:53 -08005743 pci_raw_ops|
5744 pipe_buf_operations|
5745 platform_hibernation_ops|
5746 platform_suspend_ops|
5747 proto_ops|
5748 rpc_pipe_ops|
5749 seq_operations|
5750 snd_ac97_build_ops|
5751 soc_pcmcia_socket_ops|
5752 stacktrace_ops|
5753 sysfs_ops|
5754 tty_operations|
Joe Perches6d07d01b2015-04-16 12:44:33 -07005755 uart_ops|
Emese Revfy79404842010-03-05 13:43:53 -08005756 usb_mon_operations|
5757 wd_ops}x;
Andy Whitcroft6903ffb2009-01-15 13:51:07 -08005758 if ($line !~ /\bconst\b/ &&
Joe Perches0f3c5aa2015-02-13 14:39:05 -08005759 $line =~ /\bstruct\s+($const_structs)\b/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005760 WARN("CONST_STRUCT",
5761 "struct $1 should normally be const\n" .
Andy Whitcroft6903ffb2009-01-15 13:51:07 -08005762 $herecurr);
Andy Whitcroft2b6db5c2009-01-06 14:41:29 -08005763 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07005764
5765# use of NR_CPUS is usually wrong
5766# ignore definitions of NR_CPUS and usage to define arrays as likely right
5767 if ($line =~ /\bNR_CPUS\b/ &&
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07005768 $line !~ /^.\s*\s*#\s*if\b.*\bNR_CPUS\b/ &&
5769 $line !~ /^.\s*\s*#\s*define\b.*\bNR_CPUS\b/ &&
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07005770 $line !~ /^.\s*$Declare\s.*\[[^\]]*NR_CPUS[^\]]*\]/ &&
5771 $line !~ /\[[^\]]*\.\.\.[^\]]*NR_CPUS[^\]]*\]/ &&
5772 $line !~ /\[[^\]]*NR_CPUS[^\]]*\.\.\.[^\]]*\]/)
Andy Whitcroft773647a2008-03-28 14:15:58 -07005773 {
Joe Perches000d1cc12011-07-25 17:13:25 -07005774 WARN("NR_CPUS",
5775 "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 -07005776 }
Andy Whitcroft9c9ba342008-04-29 00:59:33 -07005777
Joe Perches52ea8502013-11-12 15:10:09 -08005778# Use of __ARCH_HAS_<FOO> or ARCH_HAVE_<BAR> is wrong.
5779 if ($line =~ /\+\s*#\s*define\s+((?:__)?ARCH_(?:HAS|HAVE)\w*)\b/) {
5780 ERROR("DEFINE_ARCH_HAS",
5781 "#define of '$1' is wrong - use Kconfig variables or standard guards instead\n" . $herecurr);
5782 }
5783
Joe Perchesacd93622015-02-13 14:38:38 -08005784# likely/unlikely comparisons similar to "(likely(foo) > 0)"
5785 if ($^V && $^V ge 5.10.0 &&
5786 $line =~ /\b((?:un)?likely)\s*\(\s*$FuncArg\s*\)\s*$Compare/) {
5787 WARN("LIKELY_MISUSE",
5788 "Using $1 should generally have parentheses around the comparison\n" . $herecurr);
5789 }
5790
Andy Whitcroft691d77b2009-01-06 14:41:16 -08005791# whine mightly about in_atomic
5792 if ($line =~ /\bin_atomic\s*\(/) {
5793 if ($realfile =~ m@^drivers/@) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005794 ERROR("IN_ATOMIC",
5795 "do not use in_atomic in drivers\n" . $herecurr);
Andy Whitcroftf4a87732009-02-27 14:03:05 -08005796 } elsif ($realfile !~ m@^kernel/@) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005797 WARN("IN_ATOMIC",
5798 "use of in_atomic() is incorrect outside core kernel code\n" . $herecurr);
Andy Whitcroft691d77b2009-01-06 14:41:16 -08005799 }
5800 }
Peter Zijlstra1704f472010-03-19 01:37:42 +01005801
5802# check for lockdep_set_novalidate_class
5803 if ($line =~ /^.\s*lockdep_set_novalidate_class\s*\(/ ||
5804 $line =~ /__lockdep_no_validate__\s*\)/ ) {
5805 if ($realfile !~ m@^kernel/lockdep@ &&
5806 $realfile !~ m@^include/linux/lockdep@ &&
5807 $realfile !~ m@^drivers/base/core@) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005808 ERROR("LOCKDEP",
5809 "lockdep_no_validate class is reserved for device->mutex.\n" . $herecurr);
Peter Zijlstra1704f472010-03-19 01:37:42 +01005810 }
5811 }
Dave Jones88f88312011-01-12 16:59:59 -08005812
Joe Perchesb392c642015-04-16 12:44:16 -07005813 if ($line =~ /debugfs_create_\w+.*\b$mode_perms_world_writable\b/ ||
5814 $line =~ /DEVICE_ATTR.*\b$mode_perms_world_writable\b/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005815 WARN("EXPORTED_WORLD_WRITABLE",
5816 "Exporting world writable files is usually an error. Consider more restrictive permissions.\n" . $herecurr);
Dave Jones88f88312011-01-12 16:59:59 -08005817 }
Joe Perches24358802014-04-03 14:49:13 -07005818
Joe Perches515a2352014-04-03 14:49:24 -07005819# Mode permission misuses where it seems decimal should be octal
5820# This uses a shortcut match to avoid unnecessary uses of a slow foreach loop
5821 if ($^V && $^V ge 5.10.0 &&
5822 $line =~ /$mode_perms_search/) {
5823 foreach my $entry (@mode_permission_funcs) {
5824 my $func = $entry->[0];
5825 my $arg_pos = $entry->[1];
Joe Perches24358802014-04-03 14:49:13 -07005826
Joe Perches515a2352014-04-03 14:49:24 -07005827 my $skip_args = "";
5828 if ($arg_pos > 1) {
5829 $arg_pos--;
5830 $skip_args = "(?:\\s*$FuncArg\\s*,\\s*){$arg_pos,$arg_pos}";
5831 }
5832 my $test = "\\b$func\\s*\\(${skip_args}([\\d]+)\\s*[,\\)]";
5833 if ($line =~ /$test/) {
5834 my $val = $1;
5835 $val = $6 if ($skip_args ne "");
Joe Perches24358802014-04-03 14:49:13 -07005836
Joe Perches515a2352014-04-03 14:49:24 -07005837 if ($val !~ /^0$/ &&
5838 (($val =~ /^$Int$/ && $val !~ /^$Octal$/) ||
5839 length($val) ne 4)) {
5840 ERROR("NON_OCTAL_PERMISSIONS",
5841 "Use 4 digit octal (0777) not decimal permissions\n" . $herecurr);
Joe Perchesc0a5c892015-02-13 14:38:21 -08005842 } elsif ($val =~ /^$Octal$/ && (oct($val) & 02)) {
5843 ERROR("EXPORTED_WORLD_WRITABLE",
5844 "Exporting writable files is usually an error. Consider more restrictive permissions.\n" . $herecurr);
Joe Perches515a2352014-04-03 14:49:24 -07005845 }
Joe Perches24358802014-04-03 14:49:13 -07005846 }
5847 }
5848 }
Bjorn Andersson5a6d20c2015-06-25 15:03:24 -07005849
5850# validate content of MODULE_LICENSE against list from include/linux/module.h
5851 if ($line =~ /\bMODULE_LICENSE\s*\(\s*($String)\s*\)/) {
5852 my $extracted_string = get_quoted_string($line, $rawline);
5853 my $valid_licenses = qr{
5854 GPL|
5855 GPL\ v2|
5856 GPL\ and\ additional\ rights|
5857 Dual\ BSD/GPL|
5858 Dual\ MIT/GPL|
5859 Dual\ MPL/GPL|
5860 Proprietary
5861 }x;
5862 if ($extracted_string !~ /^"(?:$valid_licenses)"$/x) {
5863 WARN("MODULE_LICENSE",
5864 "unknown module license " . $extracted_string . "\n" . $herecurr);
5865 }
5866 }
Andy Whitcroft13214ad2008-02-08 04:22:03 -08005867 }
5868
5869 # If we have no input at all, then there is nothing to report on
5870 # so just keep quiet.
5871 if ($#rawlines == -1) {
5872 exit(0);
Andy Whitcroft0a920b52007-06-01 00:46:48 -07005873 }
5874
Andy Whitcroft8905a672007-11-28 16:21:06 -08005875 # In mailback mode only produce a report in the negative, for
5876 # things that appear to be patches.
5877 if ($mailback && ($clean == 1 || !$is_patch)) {
5878 exit(0);
5879 }
5880
5881 # This is not a patch, and we are are in 'no-patch' mode so
5882 # just keep quiet.
5883 if (!$chk_patch && !$is_patch) {
5884 exit(0);
5885 }
5886
Joe Perches06330fc2015-06-25 15:03:11 -07005887 if (!$is_patch && $file !~ /cover-letter\.patch$/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005888 ERROR("NOT_UNIFIED_DIFF",
5889 "Does not appear to be a unified-diff format patch\n");
Andy Whitcroft0a920b52007-06-01 00:46:48 -07005890 }
Joe Perches34d88152015-06-25 15:03:05 -07005891 if ($is_patch && $filename ne '-' && $chk_signoff && $signoff == 0) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005892 ERROR("MISSING_SIGN_OFF",
5893 "Missing Signed-off-by: line(s)\n");
Andy Whitcroft0a920b52007-06-01 00:46:48 -07005894 }
5895
Andy Whitcroft8905a672007-11-28 16:21:06 -08005896 print report_dump();
Andy Whitcroft13214ad2008-02-08 04:22:03 -08005897 if ($summary && !($clean == 1 && $quiet == 1)) {
5898 print "$filename " if ($summary_file);
Andy Whitcroft8905a672007-11-28 16:21:06 -08005899 print "total: $cnt_error errors, $cnt_warn warnings, " .
5900 (($check)? "$cnt_chk checks, " : "") .
5901 "$cnt_lines lines checked\n";
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07005902 }
Andy Whitcroft8905a672007-11-28 16:21:06 -08005903
Andy Whitcroftd2c0a232010-10-26 14:23:12 -07005904 if ($quiet == 0) {
5905 # If there were whitespace errors which cleanpatch can fix
5906 # then suggest that.
5907 if ($rpt_cleaners) {
Mike Frysingerb0781212011-03-22 16:34:43 -07005908 $rpt_cleaners = 0;
Joe Perchesd8469f12015-06-25 15:03:00 -07005909 print << "EOM"
5910
5911NOTE: Whitespace errors detected.
5912 You may wish to use scripts/cleanpatch or scripts/cleanfile
5913EOM
Andy Whitcroftd2c0a232010-10-26 14:23:12 -07005914 }
5915 }
5916
Joe Perchesd752fcc2014-08-06 16:11:05 -07005917 if ($clean == 0 && $fix &&
5918 ("@rawlines" ne "@fixed" ||
5919 $#fixed_inserted >= 0 || $#fixed_deleted >= 0)) {
Joe Perches9624b8d2014-01-23 15:54:44 -08005920 my $newfile = $filename;
5921 $newfile .= ".EXPERIMENTAL-checkpatch-fixes" if (!$fix_inplace);
Joe Perches3705ce52013-07-03 15:05:31 -07005922 my $linecount = 0;
5923 my $f;
5924
Joe Perchesd752fcc2014-08-06 16:11:05 -07005925 @fixed = fix_inserted_deleted_lines(\@fixed, \@fixed_inserted, \@fixed_deleted);
5926
Joe Perches3705ce52013-07-03 15:05:31 -07005927 open($f, '>', $newfile)
5928 or die "$P: Can't open $newfile for write\n";
5929 foreach my $fixed_line (@fixed) {
5930 $linecount++;
5931 if ($file) {
5932 if ($linecount > 3) {
5933 $fixed_line =~ s/^\+//;
Joe Perchesd752fcc2014-08-06 16:11:05 -07005934 print $f $fixed_line . "\n";
Joe Perches3705ce52013-07-03 15:05:31 -07005935 }
5936 } else {
5937 print $f $fixed_line . "\n";
5938 }
5939 }
5940 close($f);
5941
5942 if (!$quiet) {
5943 print << "EOM";
Joe Perchesd8469f12015-06-25 15:03:00 -07005944
Joe Perches3705ce52013-07-03 15:05:31 -07005945Wrote EXPERIMENTAL --fix correction(s) to '$newfile'
5946
5947Do _NOT_ trust the results written to this file.
5948Do _NOT_ submit these changes without inspecting them for correctness.
5949
5950This EXPERIMENTAL file is simply a convenience to help rewrite patches.
5951No warranties, expressed or implied...
Joe Perches3705ce52013-07-03 15:05:31 -07005952EOM
5953 }
5954 }
5955
Joe Perchesd8469f12015-06-25 15:03:00 -07005956 if ($quiet == 0) {
5957 print "\n";
5958 if ($clean == 1) {
5959 print "$vname has no obvious style problems and is ready for submission.\n";
5960 } else {
5961 print "$vname has style problems, please review.\n";
5962 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07005963 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07005964 return $clean;
5965}