blob: d574d13ba96395ffa0c3a73b9ce669ba42e6a5a3 [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 Perches2ac73b4f2014-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 Perches2ac73b4f2014-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|
Boqun Fengad315452015-12-29 12:18:46 +0800272 __rcu|
273 __private
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700274 }x;
Joe Perchese970b882013-11-12 15:10:10 -0800275our $InitAttributePrefix = qr{__(?:mem|cpu|dev|net_|)};
276our $InitAttributeData = qr{$InitAttributePrefix(?:initdata\b)};
277our $InitAttributeConst = qr{$InitAttributePrefix(?:initconst\b)};
278our $InitAttributeInit = qr{$InitAttributePrefix(?:init\b)};
279our $InitAttribute = qr{$InitAttributeData|$InitAttributeConst|$InitAttributeInit};
Joe Perches8716de32013-09-11 14:24:05 -0700280
Wolfram Sang52131292010-03-05 13:43:51 -0800281# Notes to $Attribute:
282# We need \b after 'init' otherwise 'initconst' will cause a false positive in a check
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700283our $Attribute = qr{
284 const|
Joe Perches03f1df72010-10-26 14:23:16 -0700285 __percpu|
286 __nocast|
287 __safe|
288 __bitwise__|
289 __packed__|
290 __packed2__|
291 __naked|
292 __maybe_unused|
293 __always_unused|
294 __noreturn|
295 __used|
296 __cold|
Joe Perchese23ef1f2015-02-13 14:38:24 -0800297 __pure|
Joe Perches03f1df72010-10-26 14:23:16 -0700298 __noclone|
299 __deprecated|
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700300 __read_mostly|
301 __kprobes|
Joe Perches8716de32013-09-11 14:24:05 -0700302 $InitAttribute|
Andy Whitcroft24e1d812008-10-15 22:02:18 -0700303 ____cacheline_aligned|
304 ____cacheline_aligned_in_smp|
Andy Whitcroft5fe3af12009-01-06 14:41:18 -0800305 ____cacheline_internodealigned_in_smp|
306 __weak
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700307 }x;
Andy Whitcroftc45dcab2008-06-05 22:46:01 -0700308our $Modifier;
Joe Perches91cb5192014-04-03 14:49:32 -0700309our $Inline = qr{inline|__always_inline|noinline|__inline|__inline__};
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700310our $Member = qr{->$Ident|\.$Ident|\[[^]]*\]};
311our $Lval = qr{$Ident(?:$Member)*};
312
Joe Perches95e2c602013-07-03 15:05:20 -0700313our $Int_type = qr{(?i)llu|ull|ll|lu|ul|l|u};
314our $Binary = qr{(?i)0b[01]+$Int_type?};
315our $Hex = qr{(?i)0x[0-9a-f]+$Int_type?};
316our $Int = qr{[0-9]+$Int_type?};
Joe Perches24358802014-04-03 14:49:13 -0700317our $Octal = qr{0[0-7]+$Int_type?};
Joe Perchesc0a5c892015-02-13 14:38:21 -0800318our $String = qr{"[X\t]*"};
Joe Perches326b1ff2013-02-04 14:28:51 -0800319our $Float_hex = qr{(?i)0x[0-9a-f]+p-?[0-9]+[fl]?};
320our $Float_dec = qr{(?i)(?:[0-9]+\.[0-9]*|[0-9]*\.[0-9]+)(?:e-?[0-9]+)?[fl]?};
321our $Float_int = qr{(?i)[0-9]+e-?[0-9]+[fl]?};
Joe Perches74349bc2012-12-17 16:02:05 -0800322our $Float = qr{$Float_hex|$Float_dec|$Float_int};
Joe Perches24358802014-04-03 14:49:13 -0700323our $Constant = qr{$Float|$Binary|$Octal|$Hex|$Int};
Joe Perches326b1ff2013-02-04 14:28:51 -0800324our $Assignment = qr{\*\=|/=|%=|\+=|-=|<<=|>>=|&=|\^=|\|=|=};
Joe Perches447432f2014-04-03 14:49:17 -0700325our $Compare = qr{<=|>=|==|!=|<|(?<!-)>};
Joe Perches23f780c2013-07-03 15:05:31 -0700326our $Arithmetic = qr{\+|-|\*|\/|%};
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700327our $Operators = qr{
328 <=|>=|==|!=|
329 =>|->|<<|>>|<|>|!|~|
Joe Perches23f780c2013-07-03 15:05:31 -0700330 &&|\|\||,|\^|\+\+|--|&|\||$Arithmetic
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700331 }x;
332
Joe Perches91cb5192014-04-03 14:49:32 -0700333our $c90_Keywords = qr{do|for|while|if|else|return|goto|continue|switch|default|case|break}x;
334
Joe Perchesab7e23f2015-04-16 12:44:22 -0700335our $BasicType;
Andy Whitcroft8905a672007-11-28 16:21:06 -0800336our $NonptrType;
Joe Perches18130872014-08-06 16:11:22 -0700337our $NonptrTypeMisordered;
Joe Perches8716de32013-09-11 14:24:05 -0700338our $NonptrTypeWithAttr;
Andy Whitcroft8905a672007-11-28 16:21:06 -0800339our $Type;
Joe Perches18130872014-08-06 16:11:22 -0700340our $TypeMisordered;
Andy Whitcroft8905a672007-11-28 16:21:06 -0800341our $Declare;
Joe Perches18130872014-08-06 16:11:22 -0700342our $DeclareMisordered;
Andy Whitcroft8905a672007-11-28 16:21:06 -0800343
Joe Perches15662b32011-10-31 17:13:12 -0700344our $NON_ASCII_UTF8 = qr{
345 [\xC2-\xDF][\x80-\xBF] # non-overlong 2-byte
Andy Whitcroft171ae1a2008-04-29 00:59:32 -0700346 | \xE0[\xA0-\xBF][\x80-\xBF] # excluding overlongs
347 | [\xE1-\xEC\xEE\xEF][\x80-\xBF]{2} # straight 3-byte
348 | \xED[\x80-\x9F][\x80-\xBF] # excluding surrogates
349 | \xF0[\x90-\xBF][\x80-\xBF]{2} # planes 1-3
350 | [\xF1-\xF3][\x80-\xBF]{3} # planes 4-15
351 | \xF4[\x80-\x8F][\x80-\xBF]{2} # plane 16
352}x;
353
Joe Perches15662b32011-10-31 17:13:12 -0700354our $UTF8 = qr{
355 [\x09\x0A\x0D\x20-\x7E] # ASCII
356 | $NON_ASCII_UTF8
357}x;
358
Joe Perchese6176fa2015-06-25 15:02:49 -0700359our $typeC99Typedefs = qr{(?:__)?(?:[us]_?)?int_?(?:8|16|32|64)_t};
Joe Perches021158b2015-02-13 14:38:43 -0800360our $typeOtherOSTypedefs = qr{(?x:
361 u_(?:char|short|int|long) | # bsd
362 u(?:nchar|short|int|long) # sysv
363)};
Joe Perchese6176fa2015-06-25 15:02:49 -0700364our $typeKernelTypedefs = qr{(?x:
Andy Whitcroftfb9e9092009-09-21 17:04:38 -0700365 (?:__)?(?:u|s|be|le)(?:8|16|32|64)|
Andy Whitcroft8ed22ca2008-10-15 22:02:32 -0700366 atomic_t
367)};
Joe Perchese6176fa2015-06-25 15:02:49 -0700368our $typeTypedefs = qr{(?x:
369 $typeC99Typedefs\b|
370 $typeOtherOSTypedefs\b|
371 $typeKernelTypedefs\b
372)};
Andy Whitcroft8ed22ca2008-10-15 22:02:32 -0700373
Joe Perches6d32f7a2015-11-06 16:31:37 -0800374our $zero_initializer = qr{(?:(?:0[xX])?0+$Int_type?|NULL|false)\b};
375
Joe Perches691e6692010-03-05 13:43:51 -0800376our $logFunctions = qr{(?x:
Joe Perches6e60c022011-07-25 17:13:27 -0700377 printk(?:_ratelimited|_once|)|
Jacob Keller7d0b6592013-07-03 15:05:35 -0700378 (?:[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 -0700379 WARN(?:_RATELIMIT|_ONCE|)|
Joe Perchesb0531722011-05-24 17:13:40 -0700380 panic|
Joe Perches06668722013-11-12 15:10:07 -0800381 MODULE_[A-Z_]+|
382 seq_vprintf|seq_printf|seq_puts
Joe Perches691e6692010-03-05 13:43:51 -0800383)};
384
Joe Perches20112472011-07-25 17:13:23 -0700385our $signature_tags = qr{(?xi:
386 Signed-off-by:|
387 Acked-by:|
388 Tested-by:|
389 Reviewed-by:|
390 Reported-by:|
Mugunthan V N8543ae12013-04-29 16:18:17 -0700391 Suggested-by:|
Joe Perches20112472011-07-25 17:13:23 -0700392 To:|
393 Cc:
394)};
395
Joe Perches18130872014-08-06 16:11:22 -0700396our @typeListMisordered = (
397 qr{char\s+(?:un)?signed},
398 qr{int\s+(?:(?:un)?signed\s+)?short\s},
399 qr{int\s+short(?:\s+(?:un)?signed)},
400 qr{short\s+int(?:\s+(?:un)?signed)},
401 qr{(?:un)?signed\s+int\s+short},
402 qr{short\s+(?:un)?signed},
403 qr{long\s+int\s+(?:un)?signed},
404 qr{int\s+long\s+(?:un)?signed},
405 qr{long\s+(?:un)?signed\s+int},
406 qr{int\s+(?:un)?signed\s+long},
407 qr{int\s+(?:un)?signed},
408 qr{int\s+long\s+long\s+(?:un)?signed},
409 qr{long\s+long\s+int\s+(?:un)?signed},
410 qr{long\s+long\s+(?:un)?signed\s+int},
411 qr{long\s+long\s+(?:un)?signed},
412 qr{long\s+(?:un)?signed},
413);
414
Andy Whitcroft8905a672007-11-28 16:21:06 -0800415our @typeList = (
416 qr{void},
Joe Perches0c773d92014-08-06 16:11:20 -0700417 qr{(?:(?:un)?signed\s+)?char},
418 qr{(?:(?:un)?signed\s+)?short\s+int},
419 qr{(?:(?:un)?signed\s+)?short},
420 qr{(?:(?:un)?signed\s+)?int},
421 qr{(?:(?:un)?signed\s+)?long\s+int},
422 qr{(?:(?:un)?signed\s+)?long\s+long\s+int},
423 qr{(?:(?:un)?signed\s+)?long\s+long},
424 qr{(?:(?:un)?signed\s+)?long},
425 qr{(?:un)?signed},
Andy Whitcroft8905a672007-11-28 16:21:06 -0800426 qr{float},
427 qr{double},
428 qr{bool},
Andy Whitcroft8905a672007-11-28 16:21:06 -0800429 qr{struct\s+$Ident},
430 qr{union\s+$Ident},
431 qr{enum\s+$Ident},
432 qr{${Ident}_t},
433 qr{${Ident}_handler},
434 qr{${Ident}_handler_fn},
Joe Perches18130872014-08-06 16:11:22 -0700435 @typeListMisordered,
Andy Whitcroft8905a672007-11-28 16:21:06 -0800436);
Joe Perches938224b2016-01-20 14:59:15 -0800437
438our $C90_int_types = qr{(?x:
439 long\s+long\s+int\s+(?:un)?signed|
440 long\s+long\s+(?:un)?signed\s+int|
441 long\s+long\s+(?:un)?signed|
442 (?:(?:un)?signed\s+)?long\s+long\s+int|
443 (?:(?:un)?signed\s+)?long\s+long|
444 int\s+long\s+long\s+(?:un)?signed|
445 int\s+(?:(?:un)?signed\s+)?long\s+long|
446
447 long\s+int\s+(?:un)?signed|
448 long\s+(?:un)?signed\s+int|
449 long\s+(?:un)?signed|
450 (?:(?:un)?signed\s+)?long\s+int|
451 (?:(?:un)?signed\s+)?long|
452 int\s+long\s+(?:un)?signed|
453 int\s+(?:(?:un)?signed\s+)?long|
454
455 int\s+(?:un)?signed|
456 (?:(?:un)?signed\s+)?int
457)};
458
Alex Dowad485ff232015-06-25 15:02:52 -0700459our @typeListFile = ();
Joe Perches8716de32013-09-11 14:24:05 -0700460our @typeListWithAttr = (
461 @typeList,
462 qr{struct\s+$InitAttribute\s+$Ident},
463 qr{union\s+$InitAttribute\s+$Ident},
464);
465
Andy Whitcroftc45dcab2008-06-05 22:46:01 -0700466our @modifierList = (
467 qr{fastcall},
468);
Alex Dowad485ff232015-06-25 15:02:52 -0700469our @modifierListFile = ();
Andy Whitcroft8905a672007-11-28 16:21:06 -0800470
Joe Perches24358802014-04-03 14:49:13 -0700471our @mode_permission_funcs = (
472 ["module_param", 3],
473 ["module_param_(?:array|named|string)", 4],
474 ["module_param_array_named", 5],
475 ["debugfs_create_(?:file|u8|u16|u32|u64|x8|x16|x32|x64|size_t|atomic_t|bool|blob|regset32|u32_array)", 2],
476 ["proc_create(?:_data|)", 2],
477 ["(?:CLASS|DEVICE|SENSOR)_ATTR", 2],
478);
479
Joe Perches515a2352014-04-03 14:49:24 -0700480#Create a search pattern for all these functions to speed up a loop below
481our $mode_perms_search = "";
482foreach my $entry (@mode_permission_funcs) {
483 $mode_perms_search .= '|' if ($mode_perms_search ne "");
484 $mode_perms_search .= $entry->[0];
485}
486
Joe Perchesb392c642015-04-16 12:44:16 -0700487our $mode_perms_world_writable = qr{
488 S_IWUGO |
489 S_IWOTH |
490 S_IRWXUGO |
491 S_IALLUGO |
492 0[0-7][0-7][2367]
493}x;
494
Wolfram Sang7840a942010-08-09 17:20:57 -0700495our $allowed_asm_includes = qr{(?x:
496 irq|
Sergey Ryazanovcdcee682014-10-13 15:51:44 -0700497 memory|
498 time|
499 reboot
Wolfram Sang7840a942010-08-09 17:20:57 -0700500)};
501# memory.h: ARM has a custom one
502
Kees Cook66b47b42014-10-13 15:51:57 -0700503# Load common spelling mistakes and build regular expression list.
504my $misspellings;
Kees Cook66b47b42014-10-13 15:51:57 -0700505my %spelling_fix;
Kees Cook66b47b42014-10-13 15:51:57 -0700506
Joe Perches36061e32014-12-10 15:51:43 -0800507if (open(my $spelling, '<', $spelling_file)) {
Joe Perches36061e32014-12-10 15:51:43 -0800508 while (<$spelling>) {
509 my $line = $_;
Kees Cook66b47b42014-10-13 15:51:57 -0700510
Joe Perches36061e32014-12-10 15:51:43 -0800511 $line =~ s/\s*\n?$//g;
512 $line =~ s/^\s*//g;
Kees Cook66b47b42014-10-13 15:51:57 -0700513
Joe Perches36061e32014-12-10 15:51:43 -0800514 next if ($line =~ m/^\s*#/);
515 next if ($line =~ m/^\s*$/);
Kees Cook66b47b42014-10-13 15:51:57 -0700516
Joe Perches36061e32014-12-10 15:51:43 -0800517 my ($suspect, $fix) = split(/\|\|/, $line);
518
Joe Perches36061e32014-12-10 15:51:43 -0800519 $spelling_fix{$suspect} = $fix;
520 }
521 close($spelling);
Joe Perches36061e32014-12-10 15:51:43 -0800522} else {
523 warn "No typos will be found - file '$spelling_file': $!\n";
Kees Cook66b47b42014-10-13 15:51:57 -0700524}
Kees Cook66b47b42014-10-13 15:51:57 -0700525
Joe Perchesebfd7d62015-04-16 12:44:14 -0700526if ($codespell) {
527 if (open(my $spelling, '<', $codespellfile)) {
528 while (<$spelling>) {
529 my $line = $_;
530
531 $line =~ s/\s*\n?$//g;
532 $line =~ s/^\s*//g;
533
534 next if ($line =~ m/^\s*#/);
535 next if ($line =~ m/^\s*$/);
536 next if ($line =~ m/, disabled/i);
537
538 $line =~ s/,.*$//;
539
540 my ($suspect, $fix) = split(/->/, $line);
541
542 $spelling_fix{$suspect} = $fix;
543 }
544 close($spelling);
545 } else {
546 warn "No codespell typos will be found - file '$codespellfile': $!\n";
547 }
548}
549
550$misspellings = join("|", sort keys %spelling_fix) if keys %spelling_fix;
551
Andy Whitcroft8905a672007-11-28 16:21:06 -0800552sub build_types {
Alex Dowad485ff232015-06-25 15:02:52 -0700553 my $mods = "(?x: \n" . join("|\n ", (@modifierList, @modifierListFile)) . "\n)";
554 my $all = "(?x: \n" . join("|\n ", (@typeList, @typeListFile)) . "\n)";
Joe Perches18130872014-08-06 16:11:22 -0700555 my $Misordered = "(?x: \n" . join("|\n ", @typeListMisordered) . "\n)";
Joe Perches8716de32013-09-11 14:24:05 -0700556 my $allWithAttr = "(?x: \n" . join("|\n ", @typeListWithAttr) . "\n)";
Andy Whitcroftc8cb2ca2008-07-23 21:28:57 -0700557 $Modifier = qr{(?:$Attribute|$Sparse|$mods)};
Joe Perchesab7e23f2015-04-16 12:44:22 -0700558 $BasicType = qr{
Joe Perchesab7e23f2015-04-16 12:44:22 -0700559 (?:$typeTypedefs\b)|
560 (?:${all}\b)
561 }x;
Andy Whitcroft8905a672007-11-28 16:21:06 -0800562 $NonptrType = qr{
Andy Whitcroftd2172eb2008-07-23 21:29:07 -0700563 (?:$Modifier\s+|const\s+)*
Andy Whitcroftcf655042008-03-04 14:28:20 -0800564 (?:
Andy Whitcroft6b48db22012-01-10 15:10:13 -0800565 (?:typeof|__typeof__)\s*\([^\)]*\)|
Andy Whitcroft8ed22ca2008-10-15 22:02:32 -0700566 (?:$typeTypedefs\b)|
Andy Whitcroftc45dcab2008-06-05 22:46:01 -0700567 (?:${all}\b)
Andy Whitcroftcf655042008-03-04 14:28:20 -0800568 )
Andy Whitcroftc8cb2ca2008-07-23 21:28:57 -0700569 (?:\s+$Modifier|\s+const)*
Andy Whitcroft8905a672007-11-28 16:21:06 -0800570 }x;
Joe Perches18130872014-08-06 16:11:22 -0700571 $NonptrTypeMisordered = qr{
572 (?:$Modifier\s+|const\s+)*
573 (?:
574 (?:${Misordered}\b)
575 )
576 (?:\s+$Modifier|\s+const)*
577 }x;
Joe Perches8716de32013-09-11 14:24:05 -0700578 $NonptrTypeWithAttr = qr{
579 (?:$Modifier\s+|const\s+)*
580 (?:
581 (?:typeof|__typeof__)\s*\([^\)]*\)|
582 (?:$typeTypedefs\b)|
583 (?:${allWithAttr}\b)
584 )
585 (?:\s+$Modifier|\s+const)*
586 }x;
Andy Whitcroft8905a672007-11-28 16:21:06 -0800587 $Type = qr{
Andy Whitcroftc45dcab2008-06-05 22:46:01 -0700588 $NonptrType
Joe Perches1574a292014-08-06 16:10:50 -0700589 (?:(?:\s|\*|\[\])+\s*const|(?:\s|\*\s*(?:const\s*)?|\[\])+|(?:\s*\[\s*\])+)?
Andy Whitcroftc8cb2ca2008-07-23 21:28:57 -0700590 (?:\s+$Inline|\s+$Modifier)*
Andy Whitcroft8905a672007-11-28 16:21:06 -0800591 }x;
Joe Perches18130872014-08-06 16:11:22 -0700592 $TypeMisordered = qr{
593 $NonptrTypeMisordered
594 (?:(?:\s|\*|\[\])+\s*const|(?:\s|\*\s*(?:const\s*)?|\[\])+|(?:\s*\[\s*\])+)?
595 (?:\s+$Inline|\s+$Modifier)*
596 }x;
Joe Perches91cb5192014-04-03 14:49:32 -0700597 $Declare = qr{(?:$Storage\s+(?:$Inline\s+)?)?$Type};
Joe Perches18130872014-08-06 16:11:22 -0700598 $DeclareMisordered = qr{(?:$Storage\s+(?:$Inline\s+)?)?$TypeMisordered};
Andy Whitcroft8905a672007-11-28 16:21:06 -0800599}
600build_types();
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700601
Joe Perches7d2367a2011-07-25 17:13:22 -0700602our $Typecast = qr{\s*(\(\s*$NonptrType\s*\)){0,1}\s*};
Joe Perchesd1fe9c02012-03-23 15:02:16 -0700603
604# Using $balanced_parens, $LvalOrFunc, or $FuncArg
605# requires at least perl version v5.10.0
606# Any use must be runtime checked with $^V
607
608our $balanced_parens = qr/(\((?:[^\(\)]++|(?-1))*\))/;
Joe Perches24358802014-04-03 14:49:13 -0700609our $LvalOrFunc = qr{((?:[\&\*]\s*)?$Lval)\s*($balanced_parens{0,1})\s*};
Joe Perchesc0a5c892015-02-13 14:38:21 -0800610our $FuncArg = qr{$Typecast{0,1}($LvalOrFunc|$Constant|$String)};
Joe Perches7d2367a2011-07-25 17:13:22 -0700611
Joe Perchesf8422302014-08-06 16:11:31 -0700612our $declaration_macros = qr{(?x:
Joe Perches3e838b62015-09-09 15:37:33 -0700613 (?:$Storage\s+)?(?:[A-Z_][A-Z0-9]*_){0,2}(?:DEFINE|DECLARE)(?:_[A-Z0-9]+){1,6}\s*\(|
Joe Perchesf8422302014-08-06 16:11:31 -0700614 (?:$Storage\s+)?LIST_HEAD\s*\(|
615 (?:$Storage\s+)?${Type}\s+uninitialized_var\s*\(
616)};
617
Joe Perches7d2367a2011-07-25 17:13:22 -0700618sub deparenthesize {
619 my ($string) = @_;
620 return "" if (!defined($string));
Joe Perches5b9553a2014-04-03 14:49:21 -0700621
622 while ($string =~ /^\s*\(.*\)\s*$/) {
623 $string =~ s@^\s*\(\s*@@;
624 $string =~ s@\s*\)\s*$@@;
625 }
626
Joe Perches7d2367a2011-07-25 17:13:22 -0700627 $string =~ s@\s+@ @g;
Joe Perches5b9553a2014-04-03 14:49:21 -0700628
Joe Perches7d2367a2011-07-25 17:13:22 -0700629 return $string;
630}
631
Joe Perches34456862013-07-03 15:05:34 -0700632sub seed_camelcase_file {
633 my ($file) = @_;
634
635 return if (!(-f $file));
636
637 local $/;
638
639 open(my $include_file, '<', "$file")
640 or warn "$P: Can't read '$file' $!\n";
641 my $text = <$include_file>;
642 close($include_file);
643
644 my @lines = split('\n', $text);
645
646 foreach my $line (@lines) {
647 next if ($line !~ /(?:[A-Z][a-z]|[a-z][A-Z])/);
648 if ($line =~ /^[ \t]*(?:#[ \t]*define|typedef\s+$Type)\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)/) {
649 $camelcase{$1} = 1;
Joe Perches11ea5162013-11-12 15:10:08 -0800650 } elsif ($line =~ /^\s*$Declare\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)\s*[\(\[,;]/) {
651 $camelcase{$1} = 1;
652 } 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 -0700653 $camelcase{$1} = 1;
654 }
655 }
656}
657
658my $camelcase_seeded = 0;
659sub seed_camelcase_includes {
660 return if ($camelcase_seeded);
661
662 my $files;
Joe Perchesc707a812013-07-08 16:00:43 -0700663 my $camelcase_cache = "";
664 my @include_files = ();
665
666 $camelcase_seeded = 1;
Joe Perches351b2a12013-07-03 15:05:36 -0700667
Richard Genoud3645e322014-02-10 14:25:32 -0800668 if (-e ".git") {
Joe Perches351b2a12013-07-03 15:05:36 -0700669 my $git_last_include_commit = `git log --no-merges --pretty=format:"%h%n" -1 -- include`;
670 chomp $git_last_include_commit;
Joe Perchesc707a812013-07-08 16:00:43 -0700671 $camelcase_cache = ".checkpatch-camelcase.git.$git_last_include_commit";
Joe Perches34456862013-07-03 15:05:34 -0700672 } else {
Joe Perchesc707a812013-07-08 16:00:43 -0700673 my $last_mod_date = 0;
Joe Perches34456862013-07-03 15:05:34 -0700674 $files = `find $root/include -name "*.h"`;
Joe Perchesc707a812013-07-08 16:00:43 -0700675 @include_files = split('\n', $files);
676 foreach my $file (@include_files) {
677 my $date = POSIX::strftime("%Y%m%d%H%M",
678 localtime((stat $file)[9]));
679 $last_mod_date = $date if ($last_mod_date < $date);
680 }
681 $camelcase_cache = ".checkpatch-camelcase.date.$last_mod_date";
Joe Perches34456862013-07-03 15:05:34 -0700682 }
Joe Perchesc707a812013-07-08 16:00:43 -0700683
684 if ($camelcase_cache ne "" && -f $camelcase_cache) {
685 open(my $camelcase_file, '<', "$camelcase_cache")
686 or warn "$P: Can't read '$camelcase_cache' $!\n";
687 while (<$camelcase_file>) {
688 chomp;
689 $camelcase{$_} = 1;
690 }
691 close($camelcase_file);
692
693 return;
694 }
695
Richard Genoud3645e322014-02-10 14:25:32 -0800696 if (-e ".git") {
Joe Perchesc707a812013-07-08 16:00:43 -0700697 $files = `git ls-files "include/*.h"`;
698 @include_files = split('\n', $files);
699 }
700
Joe Perches34456862013-07-03 15:05:34 -0700701 foreach my $file (@include_files) {
702 seed_camelcase_file($file);
703 }
Joe Perches351b2a12013-07-03 15:05:36 -0700704
Joe Perchesc707a812013-07-08 16:00:43 -0700705 if ($camelcase_cache ne "") {
Joe Perches351b2a12013-07-03 15:05:36 -0700706 unlink glob ".checkpatch-camelcase.*";
Joe Perchesc707a812013-07-08 16:00:43 -0700707 open(my $camelcase_file, '>', "$camelcase_cache")
708 or warn "$P: Can't write '$camelcase_cache' $!\n";
Joe Perches351b2a12013-07-03 15:05:36 -0700709 foreach (sort { lc($a) cmp lc($b) } keys(%camelcase)) {
710 print $camelcase_file ("$_\n");
711 }
712 close($camelcase_file);
713 }
Joe Perches34456862013-07-03 15:05:34 -0700714}
715
Joe Perchesd311cd42014-08-06 16:10:57 -0700716sub git_commit_info {
717 my ($commit, $id, $desc) = @_;
718
719 return ($id, $desc) if ((which("git") eq "") || !(-e ".git"));
720
721 my $output = `git log --no-color --format='%H %s' -1 $commit 2>&1`;
722 $output =~ s/^\s*//gm;
723 my @lines = split("\n", $output);
724
Joe Perches0d7835f2015-02-13 14:38:35 -0800725 return ($id, $desc) if ($#lines < 0);
726
Joe Perchesd311cd42014-08-06 16:10:57 -0700727 if ($lines[0] =~ /^error: short SHA1 $commit is ambiguous\./) {
728# Maybe one day convert this block of bash into something that returns
729# all matching commit ids, but it's very slow...
730#
731# echo "checking commits $1..."
732# git rev-list --remotes | grep -i "^$1" |
733# while read line ; do
734# git log --format='%H %s' -1 $line |
735# echo "commit $(cut -c 1-12,41-)"
736# done
737 } elsif ($lines[0] =~ /^fatal: ambiguous argument '$commit': unknown revision or path not in the working tree\./) {
738 } else {
739 $id = substr($lines[0], 0, 12);
740 $desc = substr($lines[0], 41);
741 }
742
743 return ($id, $desc);
744}
745
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700746$chk_signoff = 0 if ($file);
747
Andy Whitcroft00df3442007-06-08 13:47:06 -0700748my @rawlines = ();
Andy Whitcroftc2fdda02008-02-08 04:20:54 -0800749my @lines = ();
Joe Perches3705ce52013-07-03 15:05:31 -0700750my @fixed = ();
Joe Perchesd752fcc2014-08-06 16:11:05 -0700751my @fixed_inserted = ();
752my @fixed_deleted = ();
Joe Perches194f66f2014-08-06 16:11:03 -0700753my $fixlinenr = -1;
754
Andy Whitcroftc2fdda02008-02-08 04:20:54 -0800755my $vname;
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700756for my $filename (@ARGV) {
Andy Whitcroft21caa132009-01-06 14:41:30 -0800757 my $FILE;
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700758 if ($file) {
Andy Whitcroft21caa132009-01-06 14:41:30 -0800759 open($FILE, '-|', "diff -u /dev/null $filename") ||
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700760 die "$P: $filename: diff failed - $!\n";
Andy Whitcroft21caa132009-01-06 14:41:30 -0800761 } elsif ($filename eq '-') {
762 open($FILE, '<&STDIN');
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700763 } else {
Andy Whitcroft21caa132009-01-06 14:41:30 -0800764 open($FILE, '<', "$filename") ||
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700765 die "$P: $filename: open failed - $!\n";
Andy Whitcroft0a920b52007-06-01 00:46:48 -0700766 }
Andy Whitcroftc2fdda02008-02-08 04:20:54 -0800767 if ($filename eq '-') {
768 $vname = 'Your patch';
769 } else {
770 $vname = $filename;
771 }
Andy Whitcroft21caa132009-01-06 14:41:30 -0800772 while (<$FILE>) {
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700773 chomp;
774 push(@rawlines, $_);
775 }
Andy Whitcroft21caa132009-01-06 14:41:30 -0800776 close($FILE);
Joe Perchesd8469f12015-06-25 15:03:00 -0700777
778 if ($#ARGV > 0 && $quiet == 0) {
779 print '-' x length($vname) . "\n";
780 print "$vname\n";
781 print '-' x length($vname) . "\n";
782 }
783
Andy Whitcroftc2fdda02008-02-08 04:20:54 -0800784 if (!process($filename)) {
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700785 $exit = 1;
786 }
787 @rawlines = ();
Andy Whitcroft13214ad2008-02-08 04:22:03 -0800788 @lines = ();
Joe Perches3705ce52013-07-03 15:05:31 -0700789 @fixed = ();
Joe Perchesd752fcc2014-08-06 16:11:05 -0700790 @fixed_inserted = ();
791 @fixed_deleted = ();
Joe Perches194f66f2014-08-06 16:11:03 -0700792 $fixlinenr = -1;
Alex Dowad485ff232015-06-25 15:02:52 -0700793 @modifierListFile = ();
794 @typeListFile = ();
795 build_types();
Andy Whitcroft0a920b52007-06-01 00:46:48 -0700796}
797
Joe Perchesd8469f12015-06-25 15:03:00 -0700798if (!$quiet) {
Joe Perches3c816e42015-06-25 15:03:29 -0700799 hash_show_words(\%use_type, "Used");
800 hash_show_words(\%ignore_type, "Ignored");
801
Joe Perchesd8469f12015-06-25 15:03:00 -0700802 if ($^V lt 5.10.0) {
803 print << "EOM"
804
805NOTE: perl $^V is not modern enough to detect all possible issues.
806 An upgrade to at least perl v5.10.0 is suggested.
807EOM
808 }
809 if ($exit) {
810 print << "EOM"
811
812NOTE: If any of the errors are false positives, please report
813 them to the maintainer, see CHECKPATCH in MAINTAINERS.
814EOM
815 }
816}
817
Andy Whitcroft0a920b52007-06-01 00:46:48 -0700818exit($exit);
819
820sub top_of_kernel_tree {
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700821 my ($root) = @_;
822
823 my @tree_check = (
824 "COPYING", "CREDITS", "Kbuild", "MAINTAINERS", "Makefile",
825 "README", "Documentation", "arch", "include", "drivers",
826 "fs", "init", "ipc", "kernel", "lib", "scripts",
827 );
828
829 foreach my $check (@tree_check) {
830 if (! -e $root . '/' . $check) {
831 return 0;
832 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -0700833 }
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700834 return 1;
Joe Perches8f26b832012-10-04 17:13:32 -0700835}
Andy Whitcroft0a920b52007-06-01 00:46:48 -0700836
Joe Perches20112472011-07-25 17:13:23 -0700837sub parse_email {
838 my ($formatted_email) = @_;
839
840 my $name = "";
841 my $address = "";
842 my $comment = "";
843
844 if ($formatted_email =~ /^(.*)<(\S+\@\S+)>(.*)$/) {
845 $name = $1;
846 $address = $2;
847 $comment = $3 if defined $3;
848 } elsif ($formatted_email =~ /^\s*<(\S+\@\S+)>(.*)$/) {
849 $address = $1;
850 $comment = $2 if defined $2;
851 } elsif ($formatted_email =~ /(\S+\@\S+)(.*)$/) {
852 $address = $1;
853 $comment = $2 if defined $2;
854 $formatted_email =~ s/$address.*$//;
855 $name = $formatted_email;
Joe Perches3705ce52013-07-03 15:05:31 -0700856 $name = trim($name);
Joe Perches20112472011-07-25 17:13:23 -0700857 $name =~ s/^\"|\"$//g;
858 # If there's a name left after stripping spaces and
859 # leading quotes, and the address doesn't have both
860 # leading and trailing angle brackets, the address
861 # is invalid. ie:
862 # "joe smith joe@smith.com" bad
863 # "joe smith <joe@smith.com" bad
864 if ($name ne "" && $address !~ /^<[^>]+>$/) {
865 $name = "";
866 $address = "";
867 $comment = "";
868 }
869 }
870
Joe Perches3705ce52013-07-03 15:05:31 -0700871 $name = trim($name);
Joe Perches20112472011-07-25 17:13:23 -0700872 $name =~ s/^\"|\"$//g;
Joe Perches3705ce52013-07-03 15:05:31 -0700873 $address = trim($address);
Joe Perches20112472011-07-25 17:13:23 -0700874 $address =~ s/^\<|\>$//g;
875
876 if ($name =~ /[^\w \-]/i) { ##has "must quote" chars
877 $name =~ s/(?<!\\)"/\\"/g; ##escape quotes
878 $name = "\"$name\"";
879 }
880
881 return ($name, $address, $comment);
882}
883
884sub format_email {
885 my ($name, $address) = @_;
886
887 my $formatted_email;
888
Joe Perches3705ce52013-07-03 15:05:31 -0700889 $name = trim($name);
Joe Perches20112472011-07-25 17:13:23 -0700890 $name =~ s/^\"|\"$//g;
Joe Perches3705ce52013-07-03 15:05:31 -0700891 $address = trim($address);
Joe Perches20112472011-07-25 17:13:23 -0700892
893 if ($name =~ /[^\w \-]/i) { ##has "must quote" chars
894 $name =~ s/(?<!\\)"/\\"/g; ##escape quotes
895 $name = "\"$name\"";
896 }
897
898 if ("$name" eq "") {
899 $formatted_email = "$address";
900 } else {
901 $formatted_email = "$name <$address>";
902 }
903
904 return $formatted_email;
905}
906
Joe Perchesd311cd42014-08-06 16:10:57 -0700907sub which {
Joe Perchesbd474ca2014-08-06 16:11:10 -0700908 my ($bin) = @_;
Joe Perchesd311cd42014-08-06 16:10:57 -0700909
Joe Perchesbd474ca2014-08-06 16:11:10 -0700910 foreach my $path (split(/:/, $ENV{PATH})) {
911 if (-e "$path/$bin") {
912 return "$path/$bin";
913 }
Joe Perchesd311cd42014-08-06 16:10:57 -0700914 }
Joe Perchesd311cd42014-08-06 16:10:57 -0700915
Joe Perchesbd474ca2014-08-06 16:11:10 -0700916 return "";
Joe Perchesd311cd42014-08-06 16:10:57 -0700917}
918
Joe Perches000d1cc12011-07-25 17:13:25 -0700919sub which_conf {
920 my ($conf) = @_;
921
922 foreach my $path (split(/:/, ".:$ENV{HOME}:.scripts")) {
923 if (-e "$path/$conf") {
924 return "$path/$conf";
925 }
926 }
927
928 return "";
929}
930
Andy Whitcroft0a920b52007-06-01 00:46:48 -0700931sub expand_tabs {
932 my ($str) = @_;
933
934 my $res = '';
935 my $n = 0;
936 for my $c (split(//, $str)) {
937 if ($c eq "\t") {
938 $res .= ' ';
939 $n++;
940 for (; ($n % 8) != 0; $n++) {
941 $res .= ' ';
942 }
943 next;
944 }
945 $res .= $c;
946 $n++;
947 }
948
949 return $res;
950}
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700951sub copy_spacing {
Andy Whitcroft773647a2008-03-28 14:15:58 -0700952 (my $res = shift) =~ tr/\t/ /c;
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700953 return $res;
954}
Andy Whitcroft0a920b52007-06-01 00:46:48 -0700955
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -0700956sub line_stats {
957 my ($line) = @_;
958
959 # Drop the diff line leader and expand tabs
960 $line =~ s/^.//;
961 $line = expand_tabs($line);
962
963 # Pick the indent from the front of the line.
964 my ($white) = ($line =~ /^(\s*)/);
965
966 return (length($line), length($white));
967}
968
Andy Whitcroft773647a2008-03-28 14:15:58 -0700969my $sanitise_quote = '';
970
971sub sanitise_line_reset {
972 my ($in_comment) = @_;
973
974 if ($in_comment) {
975 $sanitise_quote = '*/';
976 } else {
977 $sanitise_quote = '';
978 }
979}
Andy Whitcroft00df3442007-06-08 13:47:06 -0700980sub sanitise_line {
981 my ($line) = @_;
982
983 my $res = '';
984 my $l = '';
985
Andy Whitcroftc2fdda02008-02-08 04:20:54 -0800986 my $qlen = 0;
Andy Whitcroft773647a2008-03-28 14:15:58 -0700987 my $off = 0;
988 my $c;
Andy Whitcroft00df3442007-06-08 13:47:06 -0700989
Andy Whitcroft773647a2008-03-28 14:15:58 -0700990 # Always copy over the diff marker.
991 $res = substr($line, 0, 1);
992
993 for ($off = 1; $off < length($line); $off++) {
994 $c = substr($line, $off, 1);
995
996 # Comments we are wacking completly including the begin
997 # and end, all to $;.
998 if ($sanitise_quote eq '' && substr($line, $off, 2) eq '/*') {
999 $sanitise_quote = '*/';
1000
1001 substr($res, $off, 2, "$;$;");
1002 $off++;
1003 next;
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001004 }
Andy Whitcroft81bc0e02008-10-15 22:02:26 -07001005 if ($sanitise_quote eq '*/' && substr($line, $off, 2) eq '*/') {
Andy Whitcroft773647a2008-03-28 14:15:58 -07001006 $sanitise_quote = '';
1007 substr($res, $off, 2, "$;$;");
1008 $off++;
1009 next;
1010 }
Daniel Walker113f04a2009-09-21 17:04:35 -07001011 if ($sanitise_quote eq '' && substr($line, $off, 2) eq '//') {
1012 $sanitise_quote = '//';
1013
1014 substr($res, $off, 2, $sanitise_quote);
1015 $off++;
1016 next;
1017 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07001018
1019 # A \ in a string means ignore the next character.
1020 if (($sanitise_quote eq "'" || $sanitise_quote eq '"') &&
1021 $c eq "\\") {
1022 substr($res, $off, 2, 'XX');
1023 $off++;
1024 next;
1025 }
1026 # Regular quotes.
1027 if ($c eq "'" || $c eq '"') {
1028 if ($sanitise_quote eq '') {
1029 $sanitise_quote = $c;
1030
1031 substr($res, $off, 1, $c);
Andy Whitcroft00df3442007-06-08 13:47:06 -07001032 next;
Andy Whitcroft773647a2008-03-28 14:15:58 -07001033 } elsif ($sanitise_quote eq $c) {
1034 $sanitise_quote = '';
Andy Whitcroft00df3442007-06-08 13:47:06 -07001035 }
1036 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07001037
Andy Whitcroftfae17da2009-01-06 14:41:20 -08001038 #print "c<$c> SQ<$sanitise_quote>\n";
Andy Whitcroft773647a2008-03-28 14:15:58 -07001039 if ($off != 0 && $sanitise_quote eq '*/' && $c ne "\t") {
1040 substr($res, $off, 1, $;);
Daniel Walker113f04a2009-09-21 17:04:35 -07001041 } elsif ($off != 0 && $sanitise_quote eq '//' && $c ne "\t") {
1042 substr($res, $off, 1, $;);
Andy Whitcroft773647a2008-03-28 14:15:58 -07001043 } elsif ($off != 0 && $sanitise_quote && $c ne "\t") {
1044 substr($res, $off, 1, 'X');
Andy Whitcroft00df3442007-06-08 13:47:06 -07001045 } else {
Andy Whitcroft773647a2008-03-28 14:15:58 -07001046 substr($res, $off, 1, $c);
Andy Whitcroft00df3442007-06-08 13:47:06 -07001047 }
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001048 }
1049
Daniel Walker113f04a2009-09-21 17:04:35 -07001050 if ($sanitise_quote eq '//') {
1051 $sanitise_quote = '';
1052 }
1053
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001054 # The pathname on a #include may be surrounded by '<' and '>'.
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07001055 if ($res =~ /^.\s*\#\s*include\s+\<(.*)\>/) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001056 my $clean = 'X' x length($1);
1057 $res =~ s@\<.*\>@<$clean>@;
1058
1059 # The whole of a #error is a string.
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07001060 } elsif ($res =~ /^.\s*\#\s*(?:error|warning)\s+(.*)\b/) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001061 my $clean = 'X' x length($1);
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07001062 $res =~ s@(\#\s*(?:error|warning)\s+).*@$1$clean@;
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001063 }
1064
Andy Whitcroft00df3442007-06-08 13:47:06 -07001065 return $res;
1066}
1067
Joe Perchesa6962d72013-04-29 16:18:13 -07001068sub get_quoted_string {
1069 my ($line, $rawline) = @_;
1070
Joe Perches33acb542015-06-25 15:02:54 -07001071 return "" if ($line !~ m/($String)/g);
Joe Perchesa6962d72013-04-29 16:18:13 -07001072 return substr($rawline, $-[0], $+[0] - $-[0]);
1073}
1074
Andy Whitcroft8905a672007-11-28 16:21:06 -08001075sub ctx_statement_block {
1076 my ($linenr, $remain, $off) = @_;
1077 my $line = $linenr - 1;
1078 my $blk = '';
1079 my $soff = $off;
1080 my $coff = $off - 1;
Andy Whitcroft773647a2008-03-28 14:15:58 -07001081 my $coff_set = 0;
Andy Whitcroft8905a672007-11-28 16:21:06 -08001082
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001083 my $loff = 0;
1084
Andy Whitcroft8905a672007-11-28 16:21:06 -08001085 my $type = '';
1086 my $level = 0;
Andy Whitcrofta2750642009-01-15 13:51:04 -08001087 my @stack = ();
Andy Whitcroftcf655042008-03-04 14:28:20 -08001088 my $p;
Andy Whitcroft8905a672007-11-28 16:21:06 -08001089 my $c;
1090 my $len = 0;
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001091
1092 my $remainder;
Andy Whitcroft8905a672007-11-28 16:21:06 -08001093 while (1) {
Andy Whitcrofta2750642009-01-15 13:51:04 -08001094 @stack = (['', 0]) if ($#stack == -1);
1095
Andy Whitcroft773647a2008-03-28 14:15:58 -07001096 #warn "CSB: blk<$blk> remain<$remain>\n";
Andy Whitcroft8905a672007-11-28 16:21:06 -08001097 # If we are about to drop off the end, pull in more
1098 # context.
1099 if ($off >= $len) {
1100 for (; $remain > 0; $line++) {
Andy Whitcroftdea33492008-10-15 22:02:25 -07001101 last if (!defined $lines[$line]);
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001102 next if ($lines[$line] =~ /^-/);
Andy Whitcroft8905a672007-11-28 16:21:06 -08001103 $remain--;
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001104 $loff = $len;
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001105 $blk .= $lines[$line] . "\n";
Andy Whitcroft8905a672007-11-28 16:21:06 -08001106 $len = length($blk);
1107 $line++;
1108 last;
1109 }
1110 # Bail if there is no further context.
1111 #warn "CSB: blk<$blk> off<$off> len<$len>\n";
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001112 if ($off >= $len) {
Andy Whitcroft8905a672007-11-28 16:21:06 -08001113 last;
1114 }
Andy Whitcroftf74bd192012-01-10 15:09:54 -08001115 if ($level == 0 && substr($blk, $off) =~ /^.\s*#\s*define/) {
1116 $level++;
1117 $type = '#';
1118 }
Andy Whitcroft8905a672007-11-28 16:21:06 -08001119 }
Andy Whitcroftcf655042008-03-04 14:28:20 -08001120 $p = $c;
Andy Whitcroft8905a672007-11-28 16:21:06 -08001121 $c = substr($blk, $off, 1);
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001122 $remainder = substr($blk, $off);
Andy Whitcroft8905a672007-11-28 16:21:06 -08001123
Andy Whitcroft773647a2008-03-28 14:15:58 -07001124 #warn "CSB: c<$c> type<$type> level<$level> remainder<$remainder> coff_set<$coff_set>\n";
Andy Whitcroft4635f4f2009-01-06 14:41:27 -08001125
1126 # Handle nested #if/#else.
1127 if ($remainder =~ /^#\s*(?:ifndef|ifdef|if)\s/) {
1128 push(@stack, [ $type, $level ]);
1129 } elsif ($remainder =~ /^#\s*(?:else|elif)\b/) {
1130 ($type, $level) = @{$stack[$#stack - 1]};
1131 } elsif ($remainder =~ /^#\s*endif\b/) {
1132 ($type, $level) = @{pop(@stack)};
1133 }
1134
Andy Whitcroft8905a672007-11-28 16:21:06 -08001135 # Statement ends at the ';' or a close '}' at the
1136 # outermost level.
1137 if ($level == 0 && $c eq ';') {
1138 last;
1139 }
1140
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001141 # An else is really a conditional as long as its not else if
Andy Whitcroft773647a2008-03-28 14:15:58 -07001142 if ($level == 0 && $coff_set == 0 &&
1143 (!defined($p) || $p =~ /(?:\s|\}|\+)/) &&
1144 $remainder =~ /^(else)(?:\s|{)/ &&
1145 $remainder !~ /^else\s+if\b/) {
1146 $coff = $off + length($1) - 1;
1147 $coff_set = 1;
1148 #warn "CSB: mark coff<$coff> soff<$soff> 1<$1>\n";
1149 #warn "[" . substr($blk, $soff, $coff - $soff + 1) . "]\n";
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001150 }
1151
Andy Whitcroft8905a672007-11-28 16:21:06 -08001152 if (($type eq '' || $type eq '(') && $c eq '(') {
1153 $level++;
1154 $type = '(';
1155 }
1156 if ($type eq '(' && $c eq ')') {
1157 $level--;
1158 $type = ($level != 0)? '(' : '';
1159
1160 if ($level == 0 && $coff < $soff) {
1161 $coff = $off;
Andy Whitcroft773647a2008-03-28 14:15:58 -07001162 $coff_set = 1;
1163 #warn "CSB: mark coff<$coff>\n";
Andy Whitcroft8905a672007-11-28 16:21:06 -08001164 }
1165 }
1166 if (($type eq '' || $type eq '{') && $c eq '{') {
1167 $level++;
1168 $type = '{';
1169 }
1170 if ($type eq '{' && $c eq '}') {
1171 $level--;
1172 $type = ($level != 0)? '{' : '';
1173
1174 if ($level == 0) {
Patrick Pannutob998e002010-08-09 17:21:03 -07001175 if (substr($blk, $off + 1, 1) eq ';') {
1176 $off++;
1177 }
Andy Whitcroft8905a672007-11-28 16:21:06 -08001178 last;
1179 }
1180 }
Andy Whitcroftf74bd192012-01-10 15:09:54 -08001181 # Preprocessor commands end at the newline unless escaped.
1182 if ($type eq '#' && $c eq "\n" && $p ne "\\") {
1183 $level--;
1184 $type = '';
1185 $off++;
1186 last;
1187 }
Andy Whitcroft8905a672007-11-28 16:21:06 -08001188 $off++;
1189 }
Andy Whitcrofta3bb97a2008-07-23 21:29:00 -07001190 # We are truly at the end, so shuffle to the next line.
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001191 if ($off == $len) {
Andy Whitcrofta3bb97a2008-07-23 21:29:00 -07001192 $loff = $len + 1;
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001193 $line++;
1194 $remain--;
1195 }
Andy Whitcroft8905a672007-11-28 16:21:06 -08001196
1197 my $statement = substr($blk, $soff, $off - $soff + 1);
1198 my $condition = substr($blk, $soff, $coff - $soff + 1);
1199
1200 #warn "STATEMENT<$statement>\n";
1201 #warn "CONDITION<$condition>\n";
1202
Andy Whitcroft773647a2008-03-28 14:15:58 -07001203 #print "coff<$coff> soff<$off> loff<$loff>\n";
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001204
1205 return ($statement, $condition,
1206 $line, $remain + 1, $off - $loff + 1, $level);
1207}
1208
Andy Whitcroftcf655042008-03-04 14:28:20 -08001209sub statement_lines {
1210 my ($stmt) = @_;
1211
1212 # Strip the diff line prefixes and rip blank lines at start and end.
1213 $stmt =~ s/(^|\n)./$1/g;
1214 $stmt =~ s/^\s*//;
1215 $stmt =~ s/\s*$//;
1216
1217 my @stmt_lines = ($stmt =~ /\n/g);
1218
1219 return $#stmt_lines + 2;
1220}
1221
1222sub statement_rawlines {
1223 my ($stmt) = @_;
1224
1225 my @stmt_lines = ($stmt =~ /\n/g);
1226
1227 return $#stmt_lines + 2;
1228}
1229
1230sub statement_block_size {
1231 my ($stmt) = @_;
1232
1233 $stmt =~ s/(^|\n)./$1/g;
1234 $stmt =~ s/^\s*{//;
1235 $stmt =~ s/}\s*$//;
1236 $stmt =~ s/^\s*//;
1237 $stmt =~ s/\s*$//;
1238
1239 my @stmt_lines = ($stmt =~ /\n/g);
1240 my @stmt_statements = ($stmt =~ /;/g);
1241
1242 my $stmt_lines = $#stmt_lines + 2;
1243 my $stmt_statements = $#stmt_statements + 1;
1244
1245 if ($stmt_lines > $stmt_statements) {
1246 return $stmt_lines;
1247 } else {
1248 return $stmt_statements;
1249 }
1250}
1251
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001252sub ctx_statement_full {
1253 my ($linenr, $remain, $off) = @_;
1254 my ($statement, $condition, $level);
1255
1256 my (@chunks);
1257
Andy Whitcroftcf655042008-03-04 14:28:20 -08001258 # Grab the first conditional/block pair.
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001259 ($statement, $condition, $linenr, $remain, $off, $level) =
1260 ctx_statement_block($linenr, $remain, $off);
Andy Whitcroft773647a2008-03-28 14:15:58 -07001261 #print "F: c<$condition> s<$statement> remain<$remain>\n";
Andy Whitcroftcf655042008-03-04 14:28:20 -08001262 push(@chunks, [ $condition, $statement ]);
1263 if (!($remain > 0 && $condition =~ /^\s*(?:\n[+-])?\s*(?:if|else|do)\b/s)) {
1264 return ($level, $linenr, @chunks);
1265 }
1266
1267 # Pull in the following conditional/block pairs and see if they
1268 # could continue the statement.
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001269 for (;;) {
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001270 ($statement, $condition, $linenr, $remain, $off, $level) =
1271 ctx_statement_block($linenr, $remain, $off);
Andy Whitcroftcf655042008-03-04 14:28:20 -08001272 #print "C: c<$condition> s<$statement> remain<$remain>\n";
Andy Whitcroft773647a2008-03-28 14:15:58 -07001273 last if (!($remain > 0 && $condition =~ /^(?:\s*\n[+-])*\s*(?:else|do)\b/s));
Andy Whitcroftcf655042008-03-04 14:28:20 -08001274 #print "C: push\n";
1275 push(@chunks, [ $condition, $statement ]);
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001276 }
1277
1278 return ($level, $linenr, @chunks);
Andy Whitcroft8905a672007-11-28 16:21:06 -08001279}
1280
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001281sub ctx_block_get {
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001282 my ($linenr, $remain, $outer, $open, $close, $off) = @_;
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001283 my $line;
1284 my $start = $linenr - 1;
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001285 my $blk = '';
1286 my @o;
1287 my @c;
1288 my @res = ();
1289
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001290 my $level = 0;
Andy Whitcroft4635f4f2009-01-06 14:41:27 -08001291 my @stack = ($level);
Andy Whitcroft00df3442007-06-08 13:47:06 -07001292 for ($line = $start; $remain > 0; $line++) {
1293 next if ($rawlines[$line] =~ /^-/);
1294 $remain--;
1295
1296 $blk .= $rawlines[$line];
Andy Whitcroft4635f4f2009-01-06 14:41:27 -08001297
1298 # Handle nested #if/#else.
Andy Whitcroft01464f32010-10-26 14:23:19 -07001299 if ($lines[$line] =~ /^.\s*#\s*(?:ifndef|ifdef|if)\s/) {
Andy Whitcroft4635f4f2009-01-06 14:41:27 -08001300 push(@stack, $level);
Andy Whitcroft01464f32010-10-26 14:23:19 -07001301 } elsif ($lines[$line] =~ /^.\s*#\s*(?:else|elif)\b/) {
Andy Whitcroft4635f4f2009-01-06 14:41:27 -08001302 $level = $stack[$#stack - 1];
Andy Whitcroft01464f32010-10-26 14:23:19 -07001303 } elsif ($lines[$line] =~ /^.\s*#\s*endif\b/) {
Andy Whitcroft4635f4f2009-01-06 14:41:27 -08001304 $level = pop(@stack);
1305 }
1306
Andy Whitcroft01464f32010-10-26 14:23:19 -07001307 foreach my $c (split(//, $lines[$line])) {
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001308 ##print "C<$c>L<$level><$open$close>O<$off>\n";
1309 if ($off > 0) {
1310 $off--;
1311 next;
1312 }
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001313
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001314 if ($c eq $close && $level > 0) {
1315 $level--;
1316 last if ($level == 0);
1317 } elsif ($c eq $open) {
1318 $level++;
1319 }
1320 }
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001321
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001322 if (!$outer || $level <= 1) {
Andy Whitcroft00df3442007-06-08 13:47:06 -07001323 push(@res, $rawlines[$line]);
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001324 }
1325
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001326 last if ($level == 0);
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001327 }
1328
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001329 return ($level, @res);
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001330}
1331sub ctx_block_outer {
1332 my ($linenr, $remain) = @_;
1333
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001334 my ($level, @r) = ctx_block_get($linenr, $remain, 1, '{', '}', 0);
1335 return @r;
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001336}
1337sub ctx_block {
1338 my ($linenr, $remain) = @_;
1339
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001340 my ($level, @r) = ctx_block_get($linenr, $remain, 0, '{', '}', 0);
1341 return @r;
Andy Whitcroft653d4872007-06-23 17:16:34 -07001342}
1343sub ctx_statement {
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001344 my ($linenr, $remain, $off) = @_;
1345
1346 my ($level, @r) = ctx_block_get($linenr, $remain, 0, '(', ')', $off);
1347 return @r;
1348}
1349sub ctx_block_level {
Andy Whitcroft653d4872007-06-23 17:16:34 -07001350 my ($linenr, $remain) = @_;
1351
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001352 return ctx_block_get($linenr, $remain, 0, '{', '}', 0);
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001353}
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07001354sub ctx_statement_level {
1355 my ($linenr, $remain, $off) = @_;
1356
1357 return ctx_block_get($linenr, $remain, 0, '(', ')', $off);
1358}
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001359
1360sub ctx_locate_comment {
1361 my ($first_line, $end_line) = @_;
1362
1363 # Catch a comment on the end of the line itself.
Andy Whitcroftbeae6332008-07-23 21:28:59 -07001364 my ($current_comment) = ($rawlines[$end_line - 1] =~ m@.*(/\*.*\*/)\s*(?:\\\s*)?$@);
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001365 return $current_comment if (defined $current_comment);
1366
1367 # Look through the context and try and figure out if there is a
1368 # comment.
1369 my $in_comment = 0;
1370 $current_comment = '';
1371 for (my $linenr = $first_line; $linenr < $end_line; $linenr++) {
Andy Whitcroft00df3442007-06-08 13:47:06 -07001372 my $line = $rawlines[$linenr - 1];
1373 #warn " $line\n";
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001374 if ($linenr == $first_line and $line =~ m@^.\s*\*@) {
1375 $in_comment = 1;
1376 }
1377 if ($line =~ m@/\*@) {
1378 $in_comment = 1;
1379 }
1380 if (!$in_comment && $current_comment ne '') {
1381 $current_comment = '';
1382 }
1383 $current_comment .= $line . "\n" if ($in_comment);
1384 if ($line =~ m@\*/@) {
1385 $in_comment = 0;
1386 }
1387 }
1388
1389 chomp($current_comment);
1390 return($current_comment);
1391}
1392sub ctx_has_comment {
1393 my ($first_line, $end_line) = @_;
1394 my $cmt = ctx_locate_comment($first_line, $end_line);
1395
Andy Whitcroft00df3442007-06-08 13:47:06 -07001396 ##print "LINE: $rawlines[$end_line - 1 ]\n";
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001397 ##print "CMMT: $cmt\n";
1398
1399 return ($cmt ne '');
1400}
1401
Andy Whitcroft4d001e42008-10-15 22:02:21 -07001402sub raw_line {
1403 my ($linenr, $cnt) = @_;
1404
1405 my $offset = $linenr - 1;
1406 $cnt++;
1407
1408 my $line;
1409 while ($cnt) {
1410 $line = $rawlines[$offset++];
1411 next if (defined($line) && $line =~ /^-/);
1412 $cnt--;
1413 }
1414
1415 return $line;
1416}
1417
Andy Whitcroft0a920b52007-06-01 00:46:48 -07001418sub cat_vet {
1419 my ($vet) = @_;
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07001420 my ($res, $coded);
Andy Whitcroft0a920b52007-06-01 00:46:48 -07001421
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07001422 $res = '';
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001423 while ($vet =~ /([^[:cntrl:]]*)([[:cntrl:]]|$)/g) {
1424 $res .= $1;
1425 if ($2 ne '') {
1426 $coded = sprintf("^%c", unpack('C', $2) + 64);
1427 $res .= $coded;
1428 }
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07001429 }
1430 $res =~ s/$/\$/;
Andy Whitcroft0a920b52007-06-01 00:46:48 -07001431
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07001432 return $res;
Andy Whitcroft0a920b52007-06-01 00:46:48 -07001433}
1434
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001435my $av_preprocessor = 0;
Andy Whitcroftcf655042008-03-04 14:28:20 -08001436my $av_pending;
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001437my @av_paren_type;
Andy Whitcroft1f65f942008-07-23 21:29:10 -07001438my $av_pend_colon;
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001439
1440sub annotate_reset {
1441 $av_preprocessor = 0;
Andy Whitcroftcf655042008-03-04 14:28:20 -08001442 $av_pending = '_';
1443 @av_paren_type = ('E');
Andy Whitcroft1f65f942008-07-23 21:29:10 -07001444 $av_pend_colon = 'O';
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001445}
1446
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001447sub annotate_values {
1448 my ($stream, $type) = @_;
1449
1450 my $res;
Andy Whitcroft1f65f942008-07-23 21:29:10 -07001451 my $var = '_' x length($stream);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001452 my $cur = $stream;
1453
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001454 print "$stream\n" if ($dbg_values > 1);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001455
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001456 while (length($cur)) {
Andy Whitcroft773647a2008-03-28 14:15:58 -07001457 @av_paren_type = ('E') if ($#av_paren_type < 0);
Andy Whitcroftcf655042008-03-04 14:28:20 -08001458 print " <" . join('', @av_paren_type) .
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07001459 "> <$type> <$av_pending>" if ($dbg_values > 1);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001460 if ($cur =~ /^(\s+)/o) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001461 print "WS($1)\n" if ($dbg_values > 1);
1462 if ($1 =~ /\n/ && $av_preprocessor) {
Andy Whitcroftcf655042008-03-04 14:28:20 -08001463 $type = pop(@av_paren_type);
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001464 $av_preprocessor = 0;
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001465 }
1466
Florian Micklerc023e4732011-01-12 16:59:58 -08001467 } elsif ($cur =~ /^(\(\s*$Type\s*)\)/ && $av_pending eq '_') {
Andy Whitcroft9446ef52010-10-26 14:23:13 -07001468 print "CAST($1)\n" if ($dbg_values > 1);
1469 push(@av_paren_type, $type);
Andy Whitcroftaddcdce2012-01-10 15:10:11 -08001470 $type = 'c';
Andy Whitcroft9446ef52010-10-26 14:23:13 -07001471
Andy Whitcrofte91b6e22010-10-26 14:23:11 -07001472 } elsif ($cur =~ /^($Type)\s*(?:$Ident|,|\)|\(|\s*$)/) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001473 print "DECLARE($1)\n" if ($dbg_values > 1);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001474 $type = 'T';
1475
Andy Whitcroft389a2fe2008-07-23 21:29:05 -07001476 } elsif ($cur =~ /^($Modifier)\s*/) {
1477 print "MODIFIER($1)\n" if ($dbg_values > 1);
1478 $type = 'T';
1479
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07001480 } elsif ($cur =~ /^(\#\s*define\s*$Ident)(\(?)/o) {
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07001481 print "DEFINE($1,$2)\n" if ($dbg_values > 1);
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001482 $av_preprocessor = 1;
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07001483 push(@av_paren_type, $type);
1484 if ($2 ne '') {
1485 $av_pending = 'N';
1486 }
1487 $type = 'E';
1488
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07001489 } elsif ($cur =~ /^(\#\s*(?:undef\s*$Ident|include\b))/o) {
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07001490 print "UNDEF($1)\n" if ($dbg_values > 1);
1491 $av_preprocessor = 1;
1492 push(@av_paren_type, $type);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001493
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07001494 } elsif ($cur =~ /^(\#\s*(?:ifdef|ifndef|if))/o) {
Andy Whitcroftcf655042008-03-04 14:28:20 -08001495 print "PRE_START($1)\n" if ($dbg_values > 1);
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001496 $av_preprocessor = 1;
Andy Whitcroftcf655042008-03-04 14:28:20 -08001497
1498 push(@av_paren_type, $type);
1499 push(@av_paren_type, $type);
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07001500 $type = 'E';
Andy Whitcroftcf655042008-03-04 14:28:20 -08001501
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07001502 } elsif ($cur =~ /^(\#\s*(?:else|elif))/o) {
Andy Whitcroftcf655042008-03-04 14:28:20 -08001503 print "PRE_RESTART($1)\n" if ($dbg_values > 1);
1504 $av_preprocessor = 1;
1505
1506 push(@av_paren_type, $av_paren_type[$#av_paren_type]);
1507
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07001508 $type = 'E';
Andy Whitcroftcf655042008-03-04 14:28:20 -08001509
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07001510 } elsif ($cur =~ /^(\#\s*(?:endif))/o) {
Andy Whitcroftcf655042008-03-04 14:28:20 -08001511 print "PRE_END($1)\n" if ($dbg_values > 1);
1512
1513 $av_preprocessor = 1;
1514
1515 # Assume all arms of the conditional end as this
1516 # one does, and continue as if the #endif was not here.
1517 pop(@av_paren_type);
1518 push(@av_paren_type, $type);
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07001519 $type = 'E';
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001520
1521 } elsif ($cur =~ /^(\\\n)/o) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001522 print "PRECONT($1)\n" if ($dbg_values > 1);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001523
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07001524 } elsif ($cur =~ /^(__attribute__)\s*\(?/o) {
1525 print "ATTR($1)\n" if ($dbg_values > 1);
1526 $av_pending = $type;
1527 $type = 'N';
1528
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001529 } elsif ($cur =~ /^(sizeof)\s*(\()?/o) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001530 print "SIZEOF($1)\n" if ($dbg_values > 1);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001531 if (defined $2) {
Andy Whitcroftcf655042008-03-04 14:28:20 -08001532 $av_pending = 'V';
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001533 }
1534 $type = 'N';
1535
Andy Whitcroft14b111c2008-10-15 22:02:16 -07001536 } elsif ($cur =~ /^(if|while|for)\b/o) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001537 print "COND($1)\n" if ($dbg_values > 1);
Andy Whitcroft14b111c2008-10-15 22:02:16 -07001538 $av_pending = 'E';
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001539 $type = 'N';
1540
Andy Whitcroft1f65f942008-07-23 21:29:10 -07001541 } elsif ($cur =~/^(case)/o) {
1542 print "CASE($1)\n" if ($dbg_values > 1);
1543 $av_pend_colon = 'C';
1544 $type = 'N';
1545
Andy Whitcroft14b111c2008-10-15 22:02:16 -07001546 } elsif ($cur =~/^(return|else|goto|typeof|__typeof__)\b/o) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001547 print "KEYWORD($1)\n" if ($dbg_values > 1);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001548 $type = 'N';
1549
1550 } elsif ($cur =~ /^(\()/o) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001551 print "PAREN('$1')\n" if ($dbg_values > 1);
Andy Whitcroftcf655042008-03-04 14:28:20 -08001552 push(@av_paren_type, $av_pending);
1553 $av_pending = '_';
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001554 $type = 'N';
1555
1556 } elsif ($cur =~ /^(\))/o) {
Andy Whitcroftcf655042008-03-04 14:28:20 -08001557 my $new_type = pop(@av_paren_type);
1558 if ($new_type ne '_') {
1559 $type = $new_type;
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001560 print "PAREN('$1') -> $type\n"
1561 if ($dbg_values > 1);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001562 } else {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001563 print "PAREN('$1')\n" if ($dbg_values > 1);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001564 }
1565
Andy Whitcroftc8cb2ca2008-07-23 21:28:57 -07001566 } elsif ($cur =~ /^($Ident)\s*\(/o) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001567 print "FUNC($1)\n" if ($dbg_values > 1);
Andy Whitcroftc8cb2ca2008-07-23 21:28:57 -07001568 $type = 'V';
Andy Whitcroftcf655042008-03-04 14:28:20 -08001569 $av_pending = 'V';
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001570
Andy Whitcroft8e761b02009-01-06 14:41:19 -08001571 } elsif ($cur =~ /^($Ident\s*):(?:\s*\d+\s*(,|=|;))?/) {
1572 if (defined $2 && $type eq 'C' || $type eq 'T') {
Andy Whitcroft1f65f942008-07-23 21:29:10 -07001573 $av_pend_colon = 'B';
Andy Whitcroft8e761b02009-01-06 14:41:19 -08001574 } elsif ($type eq 'E') {
1575 $av_pend_colon = 'L';
Andy Whitcroft1f65f942008-07-23 21:29:10 -07001576 }
1577 print "IDENT_COLON($1,$type>$av_pend_colon)\n" if ($dbg_values > 1);
1578 $type = 'V';
1579
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001580 } elsif ($cur =~ /^($Ident|$Constant)/o) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001581 print "IDENT($1)\n" if ($dbg_values > 1);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001582 $type = 'V';
1583
1584 } elsif ($cur =~ /^($Assignment)/o) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001585 print "ASSIGN($1)\n" if ($dbg_values > 1);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001586 $type = 'N';
1587
Andy Whitcroftcf655042008-03-04 14:28:20 -08001588 } elsif ($cur =~/^(;|{|})/) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001589 print "END($1)\n" if ($dbg_values > 1);
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001590 $type = 'E';
Andy Whitcroft1f65f942008-07-23 21:29:10 -07001591 $av_pend_colon = 'O';
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001592
Andy Whitcroft8e761b02009-01-06 14:41:19 -08001593 } elsif ($cur =~/^(,)/) {
1594 print "COMMA($1)\n" if ($dbg_values > 1);
1595 $type = 'C';
1596
Andy Whitcroft1f65f942008-07-23 21:29:10 -07001597 } elsif ($cur =~ /^(\?)/o) {
1598 print "QUESTION($1)\n" if ($dbg_values > 1);
1599 $type = 'N';
1600
1601 } elsif ($cur =~ /^(:)/o) {
1602 print "COLON($1,$av_pend_colon)\n" if ($dbg_values > 1);
1603
1604 substr($var, length($res), 1, $av_pend_colon);
1605 if ($av_pend_colon eq 'C' || $av_pend_colon eq 'L') {
1606 $type = 'E';
1607 } else {
1608 $type = 'N';
1609 }
1610 $av_pend_colon = 'O';
1611
Andy Whitcroft8e761b02009-01-06 14:41:19 -08001612 } elsif ($cur =~ /^(\[)/o) {
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001613 print "CLOSE($1)\n" if ($dbg_values > 1);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001614 $type = 'N';
1615
Andy Whitcroft0d413862008-10-15 22:02:16 -07001616 } elsif ($cur =~ /^(-(?![->])|\+(?!\+)|\*|\&\&|\&)/o) {
Andy Whitcroft74048ed2008-07-23 21:29:10 -07001617 my $variant;
1618
1619 print "OPV($1)\n" if ($dbg_values > 1);
1620 if ($type eq 'V') {
1621 $variant = 'B';
1622 } else {
1623 $variant = 'U';
1624 }
1625
1626 substr($var, length($res), 1, $variant);
1627 $type = 'N';
1628
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001629 } elsif ($cur =~ /^($Operators)/o) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001630 print "OP($1)\n" if ($dbg_values > 1);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001631 if ($1 ne '++' && $1 ne '--') {
1632 $type = 'N';
1633 }
1634
1635 } elsif ($cur =~ /(^.)/o) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001636 print "C($1)\n" if ($dbg_values > 1);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001637 }
1638 if (defined $1) {
1639 $cur = substr($cur, length($1));
1640 $res .= $type x length($1);
1641 }
1642 }
1643
Andy Whitcroft1f65f942008-07-23 21:29:10 -07001644 return ($res, $var);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001645}
1646
Andy Whitcroft8905a672007-11-28 16:21:06 -08001647sub possible {
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001648 my ($possible, $line) = @_;
Andy Whitcroft9a974fd2009-10-26 16:50:12 -07001649 my $notPermitted = qr{(?:
Andy Whitcroft0776e592008-10-15 22:02:29 -07001650 ^(?:
1651 $Modifier|
1652 $Storage|
1653 $Type|
Andy Whitcroft9a974fd2009-10-26 16:50:12 -07001654 DEFINE_\S+
1655 )$|
1656 ^(?:
Andy Whitcroft0776e592008-10-15 22:02:29 -07001657 goto|
1658 return|
1659 case|
1660 else|
1661 asm|__asm__|
Andy Whitcroft89a88352012-01-10 15:10:00 -08001662 do|
1663 \#|
1664 \#\#|
Andy Whitcroft9a974fd2009-10-26 16:50:12 -07001665 )(?:\s|$)|
Andy Whitcroft0776e592008-10-15 22:02:29 -07001666 ^(?:typedef|struct|enum)\b
Andy Whitcroft9a974fd2009-10-26 16:50:12 -07001667 )}x;
1668 warn "CHECK<$possible> ($line)\n" if ($dbg_possible > 2);
1669 if ($possible !~ $notPermitted) {
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07001670 # Check for modifiers.
1671 $possible =~ s/\s*$Storage\s*//g;
1672 $possible =~ s/\s*$Sparse\s*//g;
1673 if ($possible =~ /^\s*$/) {
1674
1675 } elsif ($possible =~ /\s/) {
1676 $possible =~ s/\s*$Type\s*//g;
Andy Whitcroftd2506582008-07-23 21:29:09 -07001677 for my $modifier (split(' ', $possible)) {
Andy Whitcroft9a974fd2009-10-26 16:50:12 -07001678 if ($modifier !~ $notPermitted) {
1679 warn "MODIFIER: $modifier ($possible) ($line)\n" if ($dbg_possible);
Alex Dowad485ff232015-06-25 15:02:52 -07001680 push(@modifierListFile, $modifier);
Andy Whitcroft9a974fd2009-10-26 16:50:12 -07001681 }
Andy Whitcroftd2506582008-07-23 21:29:09 -07001682 }
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07001683
1684 } else {
1685 warn "POSSIBLE: $possible ($line)\n" if ($dbg_possible);
Alex Dowad485ff232015-06-25 15:02:52 -07001686 push(@typeListFile, $possible);
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07001687 }
Andy Whitcroft8905a672007-11-28 16:21:06 -08001688 build_types();
Andy Whitcroft0776e592008-10-15 22:02:29 -07001689 } else {
1690 warn "NOTPOSS: $possible ($line)\n" if ($dbg_possible > 1);
Andy Whitcroft8905a672007-11-28 16:21:06 -08001691 }
1692}
1693
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001694my $prefix = '';
1695
Joe Perches000d1cc12011-07-25 17:13:25 -07001696sub show_type {
Joe Perchescbec18a2014-04-03 14:49:19 -07001697 my ($type) = @_;
Joe Perches91bfe482013-09-11 14:23:59 -07001698
Joe Perchescbec18a2014-04-03 14:49:19 -07001699 return defined $use_type{$type} if (scalar keys %use_type > 0);
1700
1701 return !defined $ignore_type{$type};
Joe Perches000d1cc12011-07-25 17:13:25 -07001702}
1703
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001704sub report {
Joe Perchescbec18a2014-04-03 14:49:19 -07001705 my ($level, $type, $msg) = @_;
1706
1707 if (!show_type($type) ||
1708 (defined $tst_only && $msg !~ /\Q$tst_only\E/)) {
Andy Whitcroft773647a2008-03-28 14:15:58 -07001709 return 0;
1710 }
Joe Perches57230292015-06-25 15:03:03 -07001711 my $output = '';
1712 if (-t STDOUT && $color) {
1713 if ($level eq 'ERROR') {
1714 $output .= RED;
1715 } elsif ($level eq 'WARNING') {
1716 $output .= YELLOW;
1717 } else {
1718 $output .= GREEN;
1719 }
Joe Perches000d1cc12011-07-25 17:13:25 -07001720 }
Joe Perches57230292015-06-25 15:03:03 -07001721 $output .= $prefix . $level . ':';
1722 if ($show_types) {
1723 $output .= BLUE if (-t STDOUT && $color);
1724 $output .= "$type:";
1725 }
1726 $output .= RESET if (-t STDOUT && $color);
1727 $output .= ' ' . $msg . "\n";
Joe Perches34d88152015-06-25 15:03:05 -07001728
1729 if ($showfile) {
1730 my @lines = split("\n", $output, -1);
1731 splice(@lines, 1, 1);
1732 $output = join("\n", @lines);
1733 }
Joe Perches57230292015-06-25 15:03:03 -07001734 $output = (split('\n', $output))[0] . "\n" if ($terse);
Andy Whitcroft8905a672007-11-28 16:21:06 -08001735
Joe Perches57230292015-06-25 15:03:03 -07001736 push(our @report, $output);
Andy Whitcroft773647a2008-03-28 14:15:58 -07001737
1738 return 1;
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001739}
Joe Perchescbec18a2014-04-03 14:49:19 -07001740
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001741sub report_dump {
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001742 our @report;
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001743}
Joe Perches000d1cc12011-07-25 17:13:25 -07001744
Joe Perchesd752fcc2014-08-06 16:11:05 -07001745sub fixup_current_range {
1746 my ($lineRef, $offset, $length) = @_;
1747
1748 if ($$lineRef =~ /^\@\@ -\d+,\d+ \+(\d+),(\d+) \@\@/) {
1749 my $o = $1;
1750 my $l = $2;
1751 my $no = $o + $offset;
1752 my $nl = $l + $length;
1753 $$lineRef =~ s/\+$o,$l \@\@/\+$no,$nl \@\@/;
1754 }
1755}
1756
1757sub fix_inserted_deleted_lines {
1758 my ($linesRef, $insertedRef, $deletedRef) = @_;
1759
1760 my $range_last_linenr = 0;
1761 my $delta_offset = 0;
1762
1763 my $old_linenr = 0;
1764 my $new_linenr = 0;
1765
1766 my $next_insert = 0;
1767 my $next_delete = 0;
1768
1769 my @lines = ();
1770
1771 my $inserted = @{$insertedRef}[$next_insert++];
1772 my $deleted = @{$deletedRef}[$next_delete++];
1773
1774 foreach my $old_line (@{$linesRef}) {
1775 my $save_line = 1;
1776 my $line = $old_line; #don't modify the array
Joe Perches323b2672015-04-16 12:44:50 -07001777 if ($line =~ /^(?:\+\+\+|\-\-\-)\s+\S+/) { #new filename
Joe Perchesd752fcc2014-08-06 16:11:05 -07001778 $delta_offset = 0;
1779 } elsif ($line =~ /^\@\@ -\d+,\d+ \+\d+,\d+ \@\@/) { #new hunk
1780 $range_last_linenr = $new_linenr;
1781 fixup_current_range(\$line, $delta_offset, 0);
1782 }
1783
1784 while (defined($deleted) && ${$deleted}{'LINENR'} == $old_linenr) {
1785 $deleted = @{$deletedRef}[$next_delete++];
1786 $save_line = 0;
1787 fixup_current_range(\$lines[$range_last_linenr], $delta_offset--, -1);
1788 }
1789
1790 while (defined($inserted) && ${$inserted}{'LINENR'} == $old_linenr) {
1791 push(@lines, ${$inserted}{'LINE'});
1792 $inserted = @{$insertedRef}[$next_insert++];
1793 $new_linenr++;
1794 fixup_current_range(\$lines[$range_last_linenr], $delta_offset++, 1);
1795 }
1796
1797 if ($save_line) {
1798 push(@lines, $line);
1799 $new_linenr++;
1800 }
1801
1802 $old_linenr++;
1803 }
1804
1805 return @lines;
1806}
1807
Joe Perchesf2d7e4d2014-08-06 16:11:07 -07001808sub fix_insert_line {
1809 my ($linenr, $line) = @_;
1810
1811 my $inserted = {
1812 LINENR => $linenr,
1813 LINE => $line,
1814 };
1815 push(@fixed_inserted, $inserted);
1816}
1817
1818sub fix_delete_line {
1819 my ($linenr, $line) = @_;
1820
1821 my $deleted = {
1822 LINENR => $linenr,
1823 LINE => $line,
1824 };
1825
1826 push(@fixed_deleted, $deleted);
1827}
1828
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07001829sub ERROR {
Joe Perchescbec18a2014-04-03 14:49:19 -07001830 my ($type, $msg) = @_;
1831
1832 if (report("ERROR", $type, $msg)) {
Andy Whitcroft773647a2008-03-28 14:15:58 -07001833 our $clean = 0;
1834 our $cnt_error++;
Joe Perches3705ce52013-07-03 15:05:31 -07001835 return 1;
Andy Whitcroft773647a2008-03-28 14:15:58 -07001836 }
Joe Perches3705ce52013-07-03 15:05:31 -07001837 return 0;
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07001838}
1839sub WARN {
Joe Perchescbec18a2014-04-03 14:49:19 -07001840 my ($type, $msg) = @_;
1841
1842 if (report("WARNING", $type, $msg)) {
Andy Whitcroft773647a2008-03-28 14:15:58 -07001843 our $clean = 0;
1844 our $cnt_warn++;
Joe Perches3705ce52013-07-03 15:05:31 -07001845 return 1;
Andy Whitcroft773647a2008-03-28 14:15:58 -07001846 }
Joe Perches3705ce52013-07-03 15:05:31 -07001847 return 0;
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07001848}
1849sub CHK {
Joe Perchescbec18a2014-04-03 14:49:19 -07001850 my ($type, $msg) = @_;
1851
1852 if ($check && report("CHECK", $type, $msg)) {
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001853 our $clean = 0;
1854 our $cnt_chk++;
Joe Perches3705ce52013-07-03 15:05:31 -07001855 return 1;
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001856 }
Joe Perches3705ce52013-07-03 15:05:31 -07001857 return 0;
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07001858}
1859
Andy Whitcroft6ecd9672008-10-15 22:02:21 -07001860sub check_absolute_file {
1861 my ($absolute, $herecurr) = @_;
1862 my $file = $absolute;
1863
1864 ##print "absolute<$absolute>\n";
1865
1866 # See if any suffix of this path is a path within the tree.
1867 while ($file =~ s@^[^/]*/@@) {
1868 if (-f "$root/$file") {
1869 ##print "file<$file>\n";
1870 last;
1871 }
1872 }
1873 if (! -f _) {
1874 return 0;
1875 }
1876
1877 # It is, so see if the prefix is acceptable.
1878 my $prefix = $absolute;
1879 substr($prefix, -length($file)) = '';
1880
1881 ##print "prefix<$prefix>\n";
1882 if ($prefix ne ".../") {
Joe Perches000d1cc12011-07-25 17:13:25 -07001883 WARN("USE_RELATIVE_PATH",
1884 "use relative pathname instead of absolute in changelog text\n" . $herecurr);
Andy Whitcroft6ecd9672008-10-15 22:02:21 -07001885 }
1886}
1887
Joe Perches3705ce52013-07-03 15:05:31 -07001888sub trim {
1889 my ($string) = @_;
1890
Joe Perchesb34c6482013-09-11 14:24:01 -07001891 $string =~ s/^\s+|\s+$//g;
1892
1893 return $string;
1894}
1895
1896sub ltrim {
1897 my ($string) = @_;
1898
1899 $string =~ s/^\s+//;
1900
1901 return $string;
1902}
1903
1904sub rtrim {
1905 my ($string) = @_;
1906
1907 $string =~ s/\s+$//;
Joe Perches3705ce52013-07-03 15:05:31 -07001908
1909 return $string;
1910}
1911
Joe Perches52ea8502013-11-12 15:10:09 -08001912sub string_find_replace {
1913 my ($string, $find, $replace) = @_;
1914
1915 $string =~ s/$find/$replace/g;
1916
1917 return $string;
1918}
1919
Joe Perches3705ce52013-07-03 15:05:31 -07001920sub tabify {
1921 my ($leading) = @_;
1922
1923 my $source_indent = 8;
1924 my $max_spaces_before_tab = $source_indent - 1;
1925 my $spaces_to_tab = " " x $source_indent;
1926
1927 #convert leading spaces to tabs
1928 1 while $leading =~ s@^([\t]*)$spaces_to_tab@$1\t@g;
1929 #Remove spaces before a tab
1930 1 while $leading =~ s@^([\t]*)( {1,$max_spaces_before_tab})\t@$1\t@g;
1931
1932 return "$leading";
1933}
1934
Joe Perchesd1fe9c02012-03-23 15:02:16 -07001935sub pos_last_openparen {
1936 my ($line) = @_;
1937
1938 my $pos = 0;
1939
1940 my $opens = $line =~ tr/\(/\(/;
1941 my $closes = $line =~ tr/\)/\)/;
1942
1943 my $last_openparen = 0;
1944
1945 if (($opens == 0) || ($closes >= $opens)) {
1946 return -1;
1947 }
1948
1949 my $len = length($line);
1950
1951 for ($pos = 0; $pos < $len; $pos++) {
1952 my $string = substr($line, $pos);
1953 if ($string =~ /^($FuncArg|$balanced_parens)/) {
1954 $pos += length($1) - 1;
1955 } elsif (substr($line, $pos, 1) eq '(') {
1956 $last_openparen = $pos;
1957 } elsif (index($string, '(') == -1) {
1958 last;
1959 }
1960 }
1961
Joe Perches91cb5192014-04-03 14:49:32 -07001962 return length(expand_tabs(substr($line, 0, $last_openparen))) + 1;
Joe Perchesd1fe9c02012-03-23 15:02:16 -07001963}
1964
Andy Whitcroft0a920b52007-06-01 00:46:48 -07001965sub process {
1966 my $filename = shift;
Andy Whitcroft0a920b52007-06-01 00:46:48 -07001967
1968 my $linenr=0;
1969 my $prevline="";
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001970 my $prevrawline="";
Andy Whitcroft0a920b52007-06-01 00:46:48 -07001971 my $stashline="";
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001972 my $stashrawline="";
Andy Whitcroft0a920b52007-06-01 00:46:48 -07001973
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001974 my $length;
Andy Whitcroft0a920b52007-06-01 00:46:48 -07001975 my $indent;
1976 my $previndent=0;
1977 my $stashindent=0;
1978
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07001979 our $clean = 1;
Andy Whitcroft0a920b52007-06-01 00:46:48 -07001980 my $signoff = 0;
1981 my $is_patch = 0;
Joe Perches29ee1b02014-08-06 16:10:35 -07001982 my $in_header_lines = $file ? 0 : 1;
Joe Perches15662b32011-10-31 17:13:12 -07001983 my $in_commit_log = 0; #Scanning lines before patch
Joe Perchesbf4daf12015-09-09 15:37:50 -07001984 my $commit_log_possible_stack_dump = 0;
Joe Perches2a076f42015-04-16 12:44:28 -07001985 my $commit_log_long_line = 0;
Joe Perchese518e9a2015-06-25 15:03:27 -07001986 my $commit_log_has_diff = 0;
Joe Perches13f19372014-08-06 16:10:59 -07001987 my $reported_maintainer_file = 0;
Pasi Savanainenfa64205d2012-10-04 17:13:29 -07001988 my $non_utf8_charset = 0;
1989
Joe Perches365dd4e2014-08-06 16:10:42 -07001990 my $last_blank_line = 0;
Joe Perches5e4f6ba2014-12-10 15:52:05 -08001991 my $last_coalesced_string_linenr = -1;
Joe Perches365dd4e2014-08-06 16:10:42 -07001992
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001993 our @report = ();
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001994 our $cnt_lines = 0;
1995 our $cnt_error = 0;
1996 our $cnt_warn = 0;
1997 our $cnt_chk = 0;
1998
Andy Whitcroft0a920b52007-06-01 00:46:48 -07001999 # Trace the real file/line as we go.
2000 my $realfile = '';
2001 my $realline = 0;
2002 my $realcnt = 0;
2003 my $here = '';
2004 my $in_comment = 0;
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002005 my $comment_edge = 0;
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002006 my $first_line = 0;
Wolfram Sang1e855722009-01-06 14:41:24 -08002007 my $p1_prefix = '';
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002008
Andy Whitcroft13214ad2008-02-08 04:22:03 -08002009 my $prev_values = 'E';
2010
2011 # suppression flags
Andy Whitcroft773647a2008-03-28 14:15:58 -07002012 my %suppress_ifbraces;
Andy Whitcroft170d3a22008-10-15 22:02:30 -07002013 my %suppress_whiletrailers;
Andy Whitcroft2b474a12009-10-26 16:50:16 -07002014 my %suppress_export;
Andy Whitcroft3e469cd2012-01-10 15:10:01 -08002015 my $suppress_statement = 0;
Andy Whitcroft653d4872007-06-23 17:16:34 -07002016
Joe Perches7e51f192013-09-11 14:23:57 -07002017 my %signatures = ();
Joe Perches323c1262012-12-17 16:02:07 -08002018
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002019 # Pre-scan the patch sanitizing the lines.
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07002020 # Pre-scan the patch looking for any __setup documentation.
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002021 #
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07002022 my @setup_docs = ();
2023 my $setup_docs = 0;
Andy Whitcroft773647a2008-03-28 14:15:58 -07002024
Joe Perchesd8b07712013-11-12 15:10:06 -08002025 my $camelcase_file_seeded = 0;
2026
Andy Whitcroft773647a2008-03-28 14:15:58 -07002027 sanitise_line_reset();
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002028 my $line;
2029 foreach my $rawline (@rawlines) {
Andy Whitcroft773647a2008-03-28 14:15:58 -07002030 $linenr++;
2031 $line = $rawline;
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002032
Joe Perches3705ce52013-07-03 15:05:31 -07002033 push(@fixed, $rawline) if ($fix);
2034
Andy Whitcroft773647a2008-03-28 14:15:58 -07002035 if ($rawline=~/^\+\+\+\s+(\S+)/) {
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07002036 $setup_docs = 0;
2037 if ($1 =~ m@Documentation/kernel-parameters.txt$@) {
2038 $setup_docs = 1;
2039 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07002040 #next;
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07002041 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07002042 if ($rawline=~/^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@/) {
2043 $realline=$1-1;
2044 if (defined $2) {
2045 $realcnt=$3+1;
2046 } else {
2047 $realcnt=1+1;
2048 }
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07002049 $in_comment = 0;
Andy Whitcroft773647a2008-03-28 14:15:58 -07002050
2051 # Guestimate if this is a continuing comment. Run
2052 # the context looking for a comment "edge". If this
2053 # edge is a close comment then we must be in a comment
2054 # at context start.
2055 my $edge;
Andy Whitcroft01fa9142008-10-15 22:02:19 -07002056 my $cnt = $realcnt;
2057 for (my $ln = $linenr + 1; $cnt > 0; $ln++) {
2058 next if (defined $rawlines[$ln - 1] &&
2059 $rawlines[$ln - 1] =~ /^-/);
2060 $cnt--;
2061 #print "RAW<$rawlines[$ln - 1]>\n";
Andy Whitcroft721c1cb2009-01-06 14:41:16 -08002062 last if (!defined $rawlines[$ln - 1]);
Andy Whitcroftfae17da2009-01-06 14:41:20 -08002063 if ($rawlines[$ln - 1] =~ m@(/\*|\*/)@ &&
2064 $rawlines[$ln - 1] !~ m@"[^"]*(?:/\*|\*/)[^"]*"@) {
2065 ($edge) = $1;
2066 last;
2067 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07002068 }
2069 if (defined $edge && $edge eq '*/') {
2070 $in_comment = 1;
2071 }
2072
2073 # Guestimate if this is a continuing comment. If this
2074 # is the start of a diff block and this line starts
2075 # ' *' then it is very likely a comment.
2076 if (!defined $edge &&
Andy Whitcroft83242e02009-01-06 14:41:17 -08002077 $rawlines[$linenr] =~ m@^.\s*(?:\*\*+| \*)(?:\s|$)@)
Andy Whitcroft773647a2008-03-28 14:15:58 -07002078 {
2079 $in_comment = 1;
2080 }
2081
2082 ##print "COMMENT:$in_comment edge<$edge> $rawline\n";
2083 sanitise_line_reset($in_comment);
2084
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07002085 } elsif ($realcnt && $rawline =~ /^(?:\+| |$)/) {
Andy Whitcroft773647a2008-03-28 14:15:58 -07002086 # Standardise the strings and chars within the input to
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07002087 # simplify matching -- only bother with positive lines.
Andy Whitcroft773647a2008-03-28 14:15:58 -07002088 $line = sanitise_line($rawline);
2089 }
2090 push(@lines, $line);
2091
2092 if ($realcnt > 1) {
2093 $realcnt-- if ($line =~ /^(?:\+| |$)/);
2094 } else {
2095 $realcnt = 0;
2096 }
2097
2098 #print "==>$rawline\n";
2099 #print "-->$line\n";
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07002100
2101 if ($setup_docs && $line =~ /^\+/) {
2102 push(@setup_docs, $line);
2103 }
2104 }
2105
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07002106 $prefix = '';
2107
Andy Whitcroft773647a2008-03-28 14:15:58 -07002108 $realcnt = 0;
2109 $linenr = 0;
Joe Perches194f66f2014-08-06 16:11:03 -07002110 $fixlinenr = -1;
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002111 foreach my $line (@lines) {
2112 $linenr++;
Joe Perches194f66f2014-08-06 16:11:03 -07002113 $fixlinenr++;
Joe Perches1b5539b2013-09-11 14:24:03 -07002114 my $sline = $line; #copy of $line
2115 $sline =~ s/$;/ /g; #with comments as spaces
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002116
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002117 my $rawline = $rawlines[$linenr - 1];
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07002118
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002119#extract the line range in the file after the patch is applied
Joe Perchese518e9a2015-06-25 15:03:27 -07002120 if (!$in_commit_log &&
2121 $line =~ /^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@/) {
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002122 $is_patch = 1;
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07002123 $first_line = $linenr + 1;
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002124 $realline=$1-1;
2125 if (defined $2) {
2126 $realcnt=$3+1;
2127 } else {
2128 $realcnt=1+1;
2129 }
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002130 annotate_reset();
Andy Whitcroft13214ad2008-02-08 04:22:03 -08002131 $prev_values = 'E';
2132
Andy Whitcroft773647a2008-03-28 14:15:58 -07002133 %suppress_ifbraces = ();
Andy Whitcroft170d3a22008-10-15 22:02:30 -07002134 %suppress_whiletrailers = ();
Andy Whitcroft2b474a12009-10-26 16:50:16 -07002135 %suppress_export = ();
Andy Whitcroft3e469cd2012-01-10 15:10:01 -08002136 $suppress_statement = 0;
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002137 next;
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002138
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07002139# track the line number as we move through the hunk, note that
2140# new versions of GNU diff omit the leading space on completely
2141# blank context lines so we need to count that too.
Andy Whitcroft773647a2008-03-28 14:15:58 -07002142 } elsif ($line =~ /^( |\+|$)/) {
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002143 $realline++;
Andy Whitcroftd8aaf122007-06-23 17:16:44 -07002144 $realcnt-- if ($realcnt != 0);
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002145
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07002146 # Measure the line length and indent.
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002147 ($length, $indent) = line_stats($rawline);
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002148
2149 # Track the previous line.
2150 ($prevline, $stashline) = ($stashline, $line);
2151 ($previndent, $stashindent) = ($stashindent, $indent);
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002152 ($prevrawline, $stashrawline) = ($stashrawline, $rawline);
2153
Andy Whitcroft773647a2008-03-28 14:15:58 -07002154 #warn "line<$line>\n";
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07002155
Andy Whitcroftd8aaf122007-06-23 17:16:44 -07002156 } elsif ($realcnt == 1) {
2157 $realcnt--;
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002158 }
2159
Andy Whitcroftcc77cdc2009-10-26 16:50:13 -07002160 my $hunk_line = ($realcnt != 0);
2161
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07002162 $here = "#$linenr: " if (!$file);
2163 $here = "#$realline: " if ($file);
Andy Whitcroft773647a2008-03-28 14:15:58 -07002164
Joe Perches2ac73b4f2014-06-04 16:12:05 -07002165 my $found_file = 0;
Andy Whitcroft773647a2008-03-28 14:15:58 -07002166 # extract the filename as it passes
Rabin Vincent3bf9a002010-10-26 14:23:16 -07002167 if ($line =~ /^diff --git.*?(\S+)$/) {
2168 $realfile = $1;
Joe Perches2b7ab452013-11-12 15:10:14 -08002169 $realfile =~ s@^([^/]*)/@@ if (!$file);
Joe Perches270c49a2012-01-10 15:09:50 -08002170 $in_commit_log = 0;
Joe Perches2ac73b4f2014-06-04 16:12:05 -07002171 $found_file = 1;
Rabin Vincent3bf9a002010-10-26 14:23:16 -07002172 } elsif ($line =~ /^\+\+\+\s+(\S+)/) {
Andy Whitcroft773647a2008-03-28 14:15:58 -07002173 $realfile = $1;
Joe Perches2b7ab452013-11-12 15:10:14 -08002174 $realfile =~ s@^([^/]*)/@@ if (!$file);
Joe Perches270c49a2012-01-10 15:09:50 -08002175 $in_commit_log = 0;
Wolfram Sang1e855722009-01-06 14:41:24 -08002176
2177 $p1_prefix = $1;
Andy Whitcrofte2f7aa42009-02-27 14:03:06 -08002178 if (!$file && $tree && $p1_prefix ne '' &&
2179 -e "$root/$p1_prefix") {
Joe Perches000d1cc12011-07-25 17:13:25 -07002180 WARN("PATCH_PREFIX",
2181 "patch prefix '$p1_prefix' exists, appears to be a -p0 patch\n");
Wolfram Sang1e855722009-01-06 14:41:24 -08002182 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07002183
Andy Whitcroftc1ab3322008-10-15 22:02:20 -07002184 if ($realfile =~ m@^include/asm/@) {
Joe Perches000d1cc12011-07-25 17:13:25 -07002185 ERROR("MODIFIED_INCLUDE_ASM",
2186 "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 -07002187 }
Joe Perches2ac73b4f2014-06-04 16:12:05 -07002188 $found_file = 1;
2189 }
2190
Joe Perches34d88152015-06-25 15:03:05 -07002191#make up the handle for any error we report on this line
2192 if ($showfile) {
2193 $prefix = "$realfile:$realline: "
2194 } elsif ($emacs) {
Joe Perches7d3a9f62015-09-09 15:37:39 -07002195 if ($file) {
2196 $prefix = "$filename:$realline: ";
2197 } else {
2198 $prefix = "$filename:$linenr: ";
2199 }
Joe Perches34d88152015-06-25 15:03:05 -07002200 }
2201
Joe Perches2ac73b4f2014-06-04 16:12:05 -07002202 if ($found_file) {
Joe Perches7bd7e482015-09-09 15:37:44 -07002203 if ($realfile =~ m@^(?:drivers/net/|net/|drivers/staging/)@) {
Joe Perches2ac73b4f2014-06-04 16:12:05 -07002204 $check = 1;
2205 } else {
2206 $check = $check_orig;
2207 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07002208 next;
2209 }
2210
Randy Dunlap389834b2007-06-08 13:47:03 -07002211 $here .= "FILE: $realfile:$realline:" if ($realcnt != 0);
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002212
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002213 my $hereline = "$here\n$rawline\n";
2214 my $herecurr = "$here\n$rawline\n";
2215 my $hereprev = "$here\n$prevrawline\n$rawline\n";
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002216
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07002217 $cnt_lines++ if ($realcnt != 0);
2218
Joe Perchese518e9a2015-06-25 15:03:27 -07002219# Check if the commit log has what seems like a diff which can confuse patch
2220 if ($in_commit_log && !$commit_log_has_diff &&
2221 (($line =~ m@^\s+diff\b.*a/[\w/]+@ &&
2222 $line =~ m@^\s+diff\b.*a/([\w/]+)\s+b/$1\b@) ||
2223 $line =~ m@^\s*(?:\-\-\-\s+a/|\+\+\+\s+b/)@ ||
2224 $line =~ m/^\s*\@\@ \-\d+,\d+ \+\d+,\d+ \@\@/)) {
2225 ERROR("DIFF_IN_COMMIT_MSG",
2226 "Avoid using diff content in the commit message - patch(1) might not work\n" . $herecurr);
2227 $commit_log_has_diff = 1;
2228 }
2229
Rabin Vincent3bf9a002010-10-26 14:23:16 -07002230# Check for incorrect file permissions
2231 if ($line =~ /^new (file )?mode.*[7531]\d{0,2}$/) {
2232 my $permhere = $here . "FILE: $realfile\n";
Joe Perches04db4d22013-04-29 16:18:14 -07002233 if ($realfile !~ m@scripts/@ &&
2234 $realfile !~ /\.(py|pl|awk|sh)$/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07002235 ERROR("EXECUTE_PERMISSIONS",
2236 "do not set execute permissions for source files\n" . $permhere);
Rabin Vincent3bf9a002010-10-26 14:23:16 -07002237 }
2238 }
2239
Joe Perches20112472011-07-25 17:13:23 -07002240# Check the patch for a signoff:
Andy Whitcroftd8aaf122007-06-23 17:16:44 -07002241 if ($line =~ /^\s*signed-off-by:/i) {
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07002242 $signoff++;
Joe Perches15662b32011-10-31 17:13:12 -07002243 $in_commit_log = 0;
Joe Perches20112472011-07-25 17:13:23 -07002244 }
2245
Joe Perchese0d975b2014-12-10 15:51:49 -08002246# Check if MAINTAINERS is being updated. If so, there's probably no need to
2247# emit the "does MAINTAINERS need updating?" message on file add/move/delete
2248 if ($line =~ /^\s*MAINTAINERS\s*\|/) {
2249 $reported_maintainer_file = 1;
2250 }
2251
Joe Perches20112472011-07-25 17:13:23 -07002252# Check signature styles
Joe Perches270c49a2012-01-10 15:09:50 -08002253 if (!$in_header_lines &&
Joe Perchesce0338df3c2012-07-30 14:41:18 -07002254 $line =~ /^(\s*)([a-z0-9_-]+by:|$signature_tags)(\s*)(.*)/i) {
Joe Perches20112472011-07-25 17:13:23 -07002255 my $space_before = $1;
2256 my $sign_off = $2;
2257 my $space_after = $3;
2258 my $email = $4;
2259 my $ucfirst_sign_off = ucfirst(lc($sign_off));
2260
Joe Perchesce0338df3c2012-07-30 14:41:18 -07002261 if ($sign_off !~ /$signature_tags/) {
2262 WARN("BAD_SIGN_OFF",
2263 "Non-standard signature: $sign_off\n" . $herecurr);
2264 }
Joe Perches20112472011-07-25 17:13:23 -07002265 if (defined $space_before && $space_before ne "") {
Joe Perches3705ce52013-07-03 15:05:31 -07002266 if (WARN("BAD_SIGN_OFF",
2267 "Do not use whitespace before $ucfirst_sign_off\n" . $herecurr) &&
2268 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07002269 $fixed[$fixlinenr] =
Joe Perches3705ce52013-07-03 15:05:31 -07002270 "$ucfirst_sign_off $email";
2271 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002272 }
Joe Perches20112472011-07-25 17:13:23 -07002273 if ($sign_off =~ /-by:$/i && $sign_off ne $ucfirst_sign_off) {
Joe Perches3705ce52013-07-03 15:05:31 -07002274 if (WARN("BAD_SIGN_OFF",
2275 "'$ucfirst_sign_off' is the preferred signature form\n" . $herecurr) &&
2276 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07002277 $fixed[$fixlinenr] =
Joe Perches3705ce52013-07-03 15:05:31 -07002278 "$ucfirst_sign_off $email";
2279 }
2280
Joe Perches20112472011-07-25 17:13:23 -07002281 }
2282 if (!defined $space_after || $space_after ne " ") {
Joe Perches3705ce52013-07-03 15:05:31 -07002283 if (WARN("BAD_SIGN_OFF",
2284 "Use a single space after $ucfirst_sign_off\n" . $herecurr) &&
2285 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07002286 $fixed[$fixlinenr] =
Joe Perches3705ce52013-07-03 15:05:31 -07002287 "$ucfirst_sign_off $email";
2288 }
Joe Perches20112472011-07-25 17:13:23 -07002289 }
2290
2291 my ($email_name, $email_address, $comment) = parse_email($email);
2292 my $suggested_email = format_email(($email_name, $email_address));
2293 if ($suggested_email eq "") {
Joe Perches000d1cc12011-07-25 17:13:25 -07002294 ERROR("BAD_SIGN_OFF",
2295 "Unrecognized email address: '$email'\n" . $herecurr);
Joe Perches20112472011-07-25 17:13:23 -07002296 } else {
2297 my $dequoted = $suggested_email;
2298 $dequoted =~ s/^"//;
2299 $dequoted =~ s/" </ </;
2300 # Don't force email to have quotes
2301 # Allow just an angle bracketed address
2302 if ("$dequoted$comment" ne $email &&
2303 "<$email_address>$comment" ne $email &&
2304 "$suggested_email$comment" ne $email) {
Joe Perches000d1cc12011-07-25 17:13:25 -07002305 WARN("BAD_SIGN_OFF",
2306 "email address '$email' might be better as '$suggested_email$comment'\n" . $herecurr);
Joe Perches20112472011-07-25 17:13:23 -07002307 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002308 }
Joe Perches7e51f192013-09-11 14:23:57 -07002309
2310# Check for duplicate signatures
2311 my $sig_nospace = $line;
2312 $sig_nospace =~ s/\s//g;
2313 $sig_nospace = lc($sig_nospace);
2314 if (defined $signatures{$sig_nospace}) {
2315 WARN("BAD_SIGN_OFF",
2316 "Duplicate signature\n" . $herecurr);
2317 } else {
2318 $signatures{$sig_nospace} = 1;
2319 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002320 }
2321
Joe Perchesa2fe16b2015-02-13 14:39:02 -08002322# Check email subject for common tools that don't need to be mentioned
2323 if ($in_header_lines &&
2324 $line =~ /^Subject:.*\b(?:checkpatch|sparse|smatch)\b[^:]/i) {
2325 WARN("EMAIL_SUBJECT",
2326 "A patch subject line should describe the change not the tool that found it\n" . $herecurr);
2327 }
2328
Joe Perches9b3189e2014-06-04 16:12:10 -07002329# Check for old stable address
2330 if ($line =~ /^\s*cc:\s*.*<?\bstable\@kernel\.org\b>?.*$/i) {
2331 ERROR("STABLE_ADDRESS",
2332 "The 'stable' address should be 'stable\@vger.kernel.org'\n" . $herecurr);
2333 }
2334
Christopher Covington7ebd05e2014-04-03 14:49:31 -07002335# Check for unwanted Gerrit info
2336 if ($in_commit_log && $line =~ /^\s*change-id:/i) {
2337 ERROR("GERRIT_CHANGE_ID",
2338 "Remove Gerrit Change-Id's before submitting upstream.\n" . $herecurr);
2339 }
2340
Joe Perches369c8dd2015-11-06 16:31:34 -08002341# Check if the commit log is in a possible stack dump
2342 if ($in_commit_log && !$commit_log_possible_stack_dump &&
2343 ($line =~ /^\s*(?:WARNING:|BUG:)/ ||
2344 $line =~ /^\s*\[\s*\d+\.\d{6,6}\s*\]/ ||
2345 # timestamp
2346 $line =~ /^\s*\[\<[0-9a-fA-F]{8,}\>\]/)) {
2347 # stack dump address
2348 $commit_log_possible_stack_dump = 1;
2349 }
2350
Joe Perches2a076f42015-04-16 12:44:28 -07002351# Check for line lengths > 75 in commit log, warn once
2352 if ($in_commit_log && !$commit_log_long_line &&
Joe Perches369c8dd2015-11-06 16:31:34 -08002353 length($line) > 75 &&
2354 !($line =~ /^\s*[a-zA-Z0-9_\/\.]+\s+\|\s+\d+/ ||
2355 # file delta changes
2356 $line =~ /^\s*(?:[\w\.\-]+\/)++[\w\.\-]+:/ ||
2357 # filename then :
2358 $line =~ /^\s*(?:Fixes:|Link:)/i ||
2359 # A Fixes: or Link: line
2360 $commit_log_possible_stack_dump)) {
Joe Perches2a076f42015-04-16 12:44:28 -07002361 WARN("COMMIT_LOG_LONG_LINE",
2362 "Possible unwrapped commit description (prefer a maximum 75 chars per line)\n" . $herecurr);
2363 $commit_log_long_line = 1;
2364 }
2365
Joe Perchesbf4daf12015-09-09 15:37:50 -07002366# Reset possible stack dump if a blank line is found
Joe Perches369c8dd2015-11-06 16:31:34 -08002367 if ($in_commit_log && $commit_log_possible_stack_dump &&
2368 $line =~ /^\s*$/) {
2369 $commit_log_possible_stack_dump = 0;
2370 }
Joe Perchesbf4daf12015-09-09 15:37:50 -07002371
Joe Perches0d7835f2015-02-13 14:38:35 -08002372# Check for git id commit length and improperly formed commit descriptions
Joe Perches369c8dd2015-11-06 16:31:34 -08002373 if ($in_commit_log && !$commit_log_possible_stack_dump &&
Joe Perchesfe043ea2015-09-09 15:37:25 -07002374 ($line =~ /\bcommit\s+[0-9a-f]{5,}\b/i ||
Joe Perches369c8dd2015-11-06 16:31:34 -08002375 ($line =~ /\b[0-9a-f]{12,40}\b/i &&
2376 $line !~ /[\<\[][0-9a-f]{12,40}[\>\]]/i &&
2377 $line !~ /\bfixes:\s*[0-9a-f]{12,40}/i))) {
Joe Perchesfe043ea2015-09-09 15:37:25 -07002378 my $init_char = "c";
2379 my $orig_commit = "";
Joe Perches0d7835f2015-02-13 14:38:35 -08002380 my $short = 1;
2381 my $long = 0;
2382 my $case = 1;
2383 my $space = 1;
2384 my $hasdesc = 0;
Joe Perches19c146a2015-02-13 14:39:00 -08002385 my $hasparens = 0;
Joe Perches0d7835f2015-02-13 14:38:35 -08002386 my $id = '0123456789ab';
2387 my $orig_desc = "commit description";
2388 my $description = "";
2389
Joe Perchesfe043ea2015-09-09 15:37:25 -07002390 if ($line =~ /\b(c)ommit\s+([0-9a-f]{5,})\b/i) {
2391 $init_char = $1;
2392 $orig_commit = lc($2);
2393 } elsif ($line =~ /\b([0-9a-f]{12,40})\b/i) {
2394 $orig_commit = lc($1);
2395 }
2396
Joe Perches0d7835f2015-02-13 14:38:35 -08002397 $short = 0 if ($line =~ /\bcommit\s+[0-9a-f]{12,40}/i);
2398 $long = 1 if ($line =~ /\bcommit\s+[0-9a-f]{41,}/i);
2399 $space = 0 if ($line =~ /\bcommit [0-9a-f]/i);
2400 $case = 0 if ($line =~ /\b[Cc]ommit\s+[0-9a-f]{5,40}[^A-F]/);
2401 if ($line =~ /\bcommit\s+[0-9a-f]{5,}\s+\("([^"]+)"\)/i) {
2402 $orig_desc = $1;
Joe Perches19c146a2015-02-13 14:39:00 -08002403 $hasparens = 1;
Joe Perches0d7835f2015-02-13 14:38:35 -08002404 } elsif ($line =~ /\bcommit\s+[0-9a-f]{5,}\s*$/i &&
2405 defined $rawlines[$linenr] &&
2406 $rawlines[$linenr] =~ /^\s*\("([^"]+)"\)/) {
2407 $orig_desc = $1;
Joe Perches19c146a2015-02-13 14:39:00 -08002408 $hasparens = 1;
Joe Perchesb671fde2015-02-13 14:38:41 -08002409 } elsif ($line =~ /\bcommit\s+[0-9a-f]{5,}\s+\("[^"]+$/i &&
2410 defined $rawlines[$linenr] &&
2411 $rawlines[$linenr] =~ /^\s*[^"]+"\)/) {
2412 $line =~ /\bcommit\s+[0-9a-f]{5,}\s+\("([^"]+)$/i;
2413 $orig_desc = $1;
2414 $rawlines[$linenr] =~ /^\s*([^"]+)"\)/;
2415 $orig_desc .= " " . $1;
Joe Perches19c146a2015-02-13 14:39:00 -08002416 $hasparens = 1;
Joe Perches0d7835f2015-02-13 14:38:35 -08002417 }
2418
2419 ($id, $description) = git_commit_info($orig_commit,
2420 $id, $orig_desc);
2421
Joe Perches19c146a2015-02-13 14:39:00 -08002422 if ($short || $long || $space || $case || ($orig_desc ne $description) || !$hasparens) {
Joe Perches0d7835f2015-02-13 14:38:35 -08002423 ERROR("GIT_COMMIT_ID",
2424 "Please use git commit description style 'commit <12+ chars of sha1> (\"<title line>\")' - ie: '${init_char}ommit $id (\"$description\")'\n" . $herecurr);
2425 }
Joe Perchesd311cd42014-08-06 16:10:57 -07002426 }
2427
Joe Perches13f19372014-08-06 16:10:59 -07002428# Check for added, moved or deleted files
2429 if (!$reported_maintainer_file && !$in_commit_log &&
2430 ($line =~ /^(?:new|deleted) file mode\s*\d+\s*$/ ||
2431 $line =~ /^rename (?:from|to) [\w\/\.\-]+\s*$/ ||
2432 ($line =~ /\{\s*([\w\/\.\-]*)\s*\=\>\s*([\w\/\.\-]*)\s*\}/ &&
2433 (defined($1) || defined($2))))) {
2434 $reported_maintainer_file = 1;
2435 WARN("FILE_PATH_CHANGES",
2436 "added, moved or deleted file(s), does MAINTAINERS need updating?\n" . $herecurr);
2437 }
2438
Andy Whitcroft00df3442007-06-08 13:47:06 -07002439# Check for wrappage within a valid hunk of the file
Andy Whitcroft8905a672007-11-28 16:21:06 -08002440 if ($realcnt != 0 && $line !~ m{^(?:\+|-| |\\ No newline|$)}) {
Joe Perches000d1cc12011-07-25 17:13:25 -07002441 ERROR("CORRUPTED_PATCH",
2442 "patch seems to be corrupt (line wrapped?)\n" .
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07002443 $herecurr) if (!$emitted_corrupt++);
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07002444 }
2445
Andy Whitcroft6ecd9672008-10-15 22:02:21 -07002446# Check for absolute kernel paths.
2447 if ($tree) {
2448 while ($line =~ m{(?:^|\s)(/\S*)}g) {
2449 my $file = $1;
2450
2451 if ($file =~ m{^(.*?)(?::\d+)+:?$} &&
2452 check_absolute_file($1, $herecurr)) {
2453 #
2454 } else {
2455 check_absolute_file($file, $herecurr);
2456 }
2457 }
2458 }
2459
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07002460# UTF-8 regex found at http://www.w3.org/International/questions/qa-forms-utf-8.en.php
2461 if (($realfile =~ /^$/ || $line =~ /^\+/) &&
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07002462 $rawline !~ m/^$UTF8*$/) {
2463 my ($utf8_prefix) = ($rawline =~ /^($UTF8*)/);
2464
2465 my $blank = copy_spacing($rawline);
2466 my $ptr = substr($blank, 0, length($utf8_prefix)) . "^";
2467 my $hereptr = "$hereline$ptr\n";
2468
Joe Perches34d99212011-07-25 17:13:26 -07002469 CHK("INVALID_UTF8",
2470 "Invalid UTF-8, patch and commit message should be encoded in UTF-8\n" . $hereptr);
Andy Whitcroft00df3442007-06-08 13:47:06 -07002471 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002472
Joe Perches15662b32011-10-31 17:13:12 -07002473# Check if it's the start of a commit log
2474# (not a header line and we haven't seen the patch filename)
2475 if ($in_header_lines && $realfile =~ /^$/ &&
Joe Perches29ee1b02014-08-06 16:10:35 -07002476 !($rawline =~ /^\s+\S/ ||
2477 $rawline =~ /^(commit\b|from\b|[\w-]+:).*$/i)) {
Joe Perches15662b32011-10-31 17:13:12 -07002478 $in_header_lines = 0;
2479 $in_commit_log = 1;
2480 }
2481
Pasi Savanainenfa64205d2012-10-04 17:13:29 -07002482# Check if there is UTF-8 in a commit log when a mail header has explicitly
2483# declined it, i.e defined some charset where it is missing.
2484 if ($in_header_lines &&
2485 $rawline =~ /^Content-Type:.+charset="(.+)".*$/ &&
2486 $1 !~ /utf-8/i) {
2487 $non_utf8_charset = 1;
2488 }
2489
2490 if ($in_commit_log && $non_utf8_charset && $realfile =~ /^$/ &&
Joe Perches15662b32011-10-31 17:13:12 -07002491 $rawline =~ /$NON_ASCII_UTF8/) {
Pasi Savanainenfa64205d2012-10-04 17:13:29 -07002492 WARN("UTF8_BEFORE_PATCH",
Joe Perches15662b32011-10-31 17:13:12 -07002493 "8-bit UTF-8 used in possible commit log\n" . $herecurr);
2494 }
2495
Kees Cook66b47b42014-10-13 15:51:57 -07002496# Check for various typo / spelling mistakes
Joe Perches66d7a382015-04-16 12:44:08 -07002497 if (defined($misspellings) &&
2498 ($in_commit_log || $line =~ /^(?:\+|Subject:)/i)) {
Joe Perchesebfd7d62015-04-16 12:44:14 -07002499 while ($rawline =~ /(?:^|[^a-z@])($misspellings)(?:\b|$|[^a-z@])/gi) {
Kees Cook66b47b42014-10-13 15:51:57 -07002500 my $typo = $1;
2501 my $typo_fix = $spelling_fix{lc($typo)};
2502 $typo_fix = ucfirst($typo_fix) if ($typo =~ /^[A-Z]/);
2503 $typo_fix = uc($typo_fix) if ($typo =~ /^[A-Z]+$/);
2504 my $msg_type = \&WARN;
2505 $msg_type = \&CHK if ($file);
2506 if (&{$msg_type}("TYPO_SPELLING",
2507 "'$typo' may be misspelled - perhaps '$typo_fix'?\n" . $herecurr) &&
2508 $fix) {
2509 $fixed[$fixlinenr] =~ s/(^|[^A-Za-z@])($typo)($|[^A-Za-z@])/$1$typo_fix$3/;
2510 }
2511 }
2512 }
2513
Andy Whitcroft306708542008-10-15 22:02:28 -07002514# ignore non-hunk lines and lines being removed
2515 next if (!$hunk_line || $line =~ /^-/);
Andy Whitcroft00df3442007-06-08 13:47:06 -07002516
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002517#trailing whitespace
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07002518 if ($line =~ /^\+.*\015/) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002519 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
Joe Perchesd5e616f2013-09-11 14:23:54 -07002520 if (ERROR("DOS_LINE_ENDINGS",
2521 "DOS line endings\n" . $herevet) &&
2522 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07002523 $fixed[$fixlinenr] =~ s/[\s\015]+$//;
Joe Perchesd5e616f2013-09-11 14:23:54 -07002524 }
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002525 } elsif ($rawline =~ /^\+.*\S\s+$/ || $rawline =~ /^\+\s+$/) {
2526 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
Joe Perches3705ce52013-07-03 15:05:31 -07002527 if (ERROR("TRAILING_WHITESPACE",
2528 "trailing whitespace\n" . $herevet) &&
2529 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07002530 $fixed[$fixlinenr] =~ s/\s+$//;
Joe Perches3705ce52013-07-03 15:05:31 -07002531 }
2532
Andy Whitcroftd2c0a232010-10-26 14:23:12 -07002533 $rpt_cleaners = 1;
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002534 }
Andy Whitcroft5368df22008-10-15 22:02:27 -07002535
Josh Triplett4783f892013-11-12 15:10:12 -08002536# Check for FSF mailing addresses.
Alexander Duyck109d8cb2014-01-23 15:54:50 -08002537 if ($rawline =~ /\bwrite to the Free/i ||
Joe Perches3e2232f2014-01-23 15:54:48 -08002538 $rawline =~ /\b59\s+Temple\s+Pl/i ||
2539 $rawline =~ /\b51\s+Franklin\s+St/i) {
Josh Triplett4783f892013-11-12 15:10:12 -08002540 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2541 my $msg_type = \&ERROR;
2542 $msg_type = \&CHK if ($file);
2543 &{$msg_type}("FSF_MAILING_ADDRESS",
Joe Perches3e2232f2014-01-23 15:54:48 -08002544 "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 -08002545 }
2546
Andi Kleen33549572010-05-24 14:33:29 -07002547# check for Kconfig help text having a real description
Andy Whitcroft9fe287d72010-10-26 14:23:15 -07002548# Only applies when adding the entry originally, after that we do not have
2549# sufficient context to determine whether it is indeed long enough.
Andi Kleen33549572010-05-24 14:33:29 -07002550 if ($realfile =~ /Kconfig/ &&
Joe Perches8d73e0e2014-08-06 16:10:46 -07002551 $line =~ /^\+\s*config\s+/) {
Andi Kleen33549572010-05-24 14:33:29 -07002552 my $length = 0;
Andy Whitcroft9fe287d72010-10-26 14:23:15 -07002553 my $cnt = $realcnt;
2554 my $ln = $linenr + 1;
2555 my $f;
Andy Whitcrofta1385802012-01-10 15:10:03 -08002556 my $is_start = 0;
Andy Whitcroft9fe287d72010-10-26 14:23:15 -07002557 my $is_end = 0;
Andy Whitcrofta1385802012-01-10 15:10:03 -08002558 for (; $cnt > 0 && defined $lines[$ln - 1]; $ln++) {
Andy Whitcroft9fe287d72010-10-26 14:23:15 -07002559 $f = $lines[$ln - 1];
2560 $cnt-- if ($lines[$ln - 1] !~ /^-/);
2561 $is_end = $lines[$ln - 1] =~ /^\+/;
Andy Whitcroft9fe287d72010-10-26 14:23:15 -07002562
2563 next if ($f =~ /^-/);
Joe Perches8d73e0e2014-08-06 16:10:46 -07002564 last if (!$file && $f =~ /^\@\@/);
Andy Whitcrofta1385802012-01-10 15:10:03 -08002565
Joe Perches8d73e0e2014-08-06 16:10:46 -07002566 if ($lines[$ln - 1] =~ /^\+\s*(?:bool|tristate)\s*\"/) {
Andy Whitcrofta1385802012-01-10 15:10:03 -08002567 $is_start = 1;
Joe Perches8d73e0e2014-08-06 16:10:46 -07002568 } elsif ($lines[$ln - 1] =~ /^\+\s*(?:---)?help(?:---)?$/) {
Andy Whitcrofta1385802012-01-10 15:10:03 -08002569 $length = -1;
2570 }
2571
Andy Whitcroft9fe287d72010-10-26 14:23:15 -07002572 $f =~ s/^.//;
Andi Kleen33549572010-05-24 14:33:29 -07002573 $f =~ s/#.*//;
2574 $f =~ s/^\s+//;
2575 next if ($f =~ /^$/);
Andy Whitcroft9fe287d72010-10-26 14:23:15 -07002576 if ($f =~ /^\s*config\s/) {
2577 $is_end = 1;
2578 last;
2579 }
Andi Kleen33549572010-05-24 14:33:29 -07002580 $length++;
2581 }
Vadim Bendebury56193272014-10-13 15:51:48 -07002582 if ($is_start && $is_end && $length < $min_conf_desc_length) {
2583 WARN("CONFIG_DESCRIPTION",
2584 "please write a paragraph that describes the config symbol fully\n" . $herecurr);
2585 }
Andy Whitcrofta1385802012-01-10 15:10:03 -08002586 #print "is_start<$is_start> is_end<$is_end> length<$length>\n";
Andi Kleen33549572010-05-24 14:33:29 -07002587 }
2588
Kees Cook1ba8dfd2012-12-17 16:01:48 -08002589# discourage the addition of CONFIG_EXPERIMENTAL in Kconfig.
2590 if ($realfile =~ /Kconfig/ &&
2591 $line =~ /.\s*depends on\s+.*\bEXPERIMENTAL\b/) {
2592 WARN("CONFIG_EXPERIMENTAL",
2593 "Use of CONFIG_EXPERIMENTAL is deprecated. For alternatives, see https://lkml.org/lkml/2012/10/23/580\n");
2594 }
2595
Christoph Jaeger327953e2015-02-13 14:38:29 -08002596# discourage the use of boolean for type definition attributes of Kconfig options
2597 if ($realfile =~ /Kconfig/ &&
2598 $line =~ /^\+\s*\bboolean\b/) {
2599 WARN("CONFIG_TYPE_BOOLEAN",
2600 "Use of boolean is deprecated, please use bool instead.\n" . $herecurr);
2601 }
2602
Arnaud Lacombec68e5872011-08-15 01:07:14 -04002603 if (($realfile =~ /Makefile.*/ || $realfile =~ /Kbuild.*/) &&
2604 ($line =~ /\+(EXTRA_[A-Z]+FLAGS).*/)) {
2605 my $flag = $1;
2606 my $replacement = {
2607 'EXTRA_AFLAGS' => 'asflags-y',
2608 'EXTRA_CFLAGS' => 'ccflags-y',
2609 'EXTRA_CPPFLAGS' => 'cppflags-y',
2610 'EXTRA_LDFLAGS' => 'ldflags-y',
2611 };
2612
2613 WARN("DEPRECATED_VARIABLE",
2614 "Use of $flag is deprecated, please use \`$replacement->{$flag} instead.\n" . $herecurr) if ($replacement->{$flag});
2615 }
2616
Rob Herringbff5da42014-01-23 15:54:51 -08002617# check for DT compatible documentation
Florian Vaussard7dd05b32014-04-03 14:49:26 -07002618 if (defined $root &&
2619 (($realfile =~ /\.dtsi?$/ && $line =~ /^\+\s*compatible\s*=\s*\"/) ||
2620 ($realfile =~ /\.[ch]$/ && $line =~ /^\+.*\.compatible\s*=\s*\"/))) {
2621
Rob Herringbff5da42014-01-23 15:54:51 -08002622 my @compats = $rawline =~ /\"([a-zA-Z0-9\-\,\.\+_]+)\"/g;
2623
Florian Vaussardcc933192014-04-03 14:49:27 -07002624 my $dt_path = $root . "/Documentation/devicetree/bindings/";
2625 my $vp_file = $dt_path . "vendor-prefixes.txt";
2626
Rob Herringbff5da42014-01-23 15:54:51 -08002627 foreach my $compat (@compats) {
2628 my $compat2 = $compat;
Rob Herring185d5662014-06-04 16:12:03 -07002629 $compat2 =~ s/\,[a-zA-Z0-9]*\-/\,<\.\*>\-/;
2630 my $compat3 = $compat;
2631 $compat3 =~ s/\,([a-z]*)[0-9]*\-/\,$1<\.\*>\-/;
2632 `grep -Erq "$compat|$compat2|$compat3" $dt_path`;
Rob Herringbff5da42014-01-23 15:54:51 -08002633 if ( $? >> 8 ) {
2634 WARN("UNDOCUMENTED_DT_STRING",
2635 "DT compatible string \"$compat\" appears un-documented -- check $dt_path\n" . $herecurr);
2636 }
2637
Florian Vaussard4fbf32a2014-04-03 14:49:25 -07002638 next if $compat !~ /^([a-zA-Z0-9\-]+)\,/;
2639 my $vendor = $1;
Florian Vaussardcc933192014-04-03 14:49:27 -07002640 `grep -Eq "^$vendor\\b" $vp_file`;
Rob Herringbff5da42014-01-23 15:54:51 -08002641 if ( $? >> 8 ) {
2642 WARN("UNDOCUMENTED_DT_STRING",
Florian Vaussardcc933192014-04-03 14:49:27 -07002643 "DT compatible string vendor \"$vendor\" appears un-documented -- check $vp_file\n" . $herecurr);
Rob Herringbff5da42014-01-23 15:54:51 -08002644 }
2645 }
2646 }
2647
Andy Whitcroft5368df22008-10-15 22:02:27 -07002648# check we are in a valid source file if not then ignore this hunk
Geert Uytterhoevende4c9242014-10-13 15:51:46 -07002649 next if ($realfile !~ /\.(h|c|s|S|pl|sh|dtsi|dts)$/);
Andy Whitcroft5368df22008-10-15 22:02:27 -07002650
Joe Perches47e0c882015-06-25 15:02:57 -07002651# line length limit (with some exclusions)
2652#
2653# There are a few types of lines that may extend beyond $max_line_length:
2654# logging functions like pr_info that end in a string
2655# lines with a single string
2656# #defines that are a single string
2657#
2658# There are 3 different line length message types:
2659# LONG_LINE_COMMENT a comment starts before but extends beyond $max_linelength
2660# LONG_LINE_STRING a string starts before but extends beyond $max_line_length
2661# LONG_LINE all other lines longer than $max_line_length
2662#
2663# if LONG_LINE is ignored, the other 2 types are also ignored
2664#
2665
Joe Perchesb4749e92015-07-17 16:24:01 -07002666 if ($line =~ /^\+/ && $length > $max_line_length) {
Joe Perches47e0c882015-06-25 15:02:57 -07002667 my $msg_type = "LONG_LINE";
2668
2669 # Check the allowed long line types first
2670
2671 # logging functions that end in a string that starts
2672 # before $max_line_length
2673 if ($line =~ /^\+\s*$logFunctions\s*\(\s*(?:(?:KERN_\S+\s*|[^"]*))?($String\s*(?:|,|\)\s*;)\s*)$/ &&
2674 length(expand_tabs(substr($line, 1, length($line) - length($1) - 1))) <= $max_line_length) {
2675 $msg_type = "";
2676
2677 # lines with only strings (w/ possible termination)
2678 # #defines with only strings
2679 } elsif ($line =~ /^\+\s*$String\s*(?:\s*|,|\)\s*;)\s*$/ ||
2680 $line =~ /^\+\s*#\s*define\s+\w+\s+$String$/) {
2681 $msg_type = "";
2682
2683 # Otherwise set the alternate message types
2684
2685 # a comment starts before $max_line_length
2686 } elsif ($line =~ /($;[\s$;]*)$/ &&
2687 length(expand_tabs(substr($line, 1, length($line) - length($1) - 1))) <= $max_line_length) {
2688 $msg_type = "LONG_LINE_COMMENT"
2689
2690 # a quoted string starts before $max_line_length
2691 } elsif ($sline =~ /\s*($String(?:\s*(?:\\|,\s*|\)\s*;\s*))?)$/ &&
2692 length(expand_tabs(substr($line, 1, length($line) - length($1) - 1))) <= $max_line_length) {
2693 $msg_type = "LONG_LINE_STRING"
2694 }
2695
2696 if ($msg_type ne "" &&
2697 (show_type("LONG_LINE") || show_type($msg_type))) {
2698 WARN($msg_type,
2699 "line over $max_line_length characters\n" . $herecurr);
2700 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002701 }
2702
Andy Whitcroft8905a672007-11-28 16:21:06 -08002703# check for adding lines without a newline.
2704 if ($line =~ /^\+/ && defined $lines[$linenr] && $lines[$linenr] =~ /^\\ No newline at end of file/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07002705 WARN("MISSING_EOF_NEWLINE",
2706 "adding a line without newline at end of file\n" . $herecurr);
Andy Whitcroft8905a672007-11-28 16:21:06 -08002707 }
2708
Mike Frysinger42e41c52009-09-21 17:04:40 -07002709# Blackfin: use hi/lo macros
2710 if ($realfile =~ m@arch/blackfin/.*\.S$@) {
2711 if ($line =~ /\.[lL][[:space:]]*=.*&[[:space:]]*0x[fF][fF][fF][fF]/) {
2712 my $herevet = "$here\n" . cat_vet($line) . "\n";
Joe Perches000d1cc12011-07-25 17:13:25 -07002713 ERROR("LO_MACRO",
2714 "use the LO() macro, not (... & 0xFFFF)\n" . $herevet);
Mike Frysinger42e41c52009-09-21 17:04:40 -07002715 }
2716 if ($line =~ /\.[hH][[:space:]]*=.*>>[[:space:]]*16/) {
2717 my $herevet = "$here\n" . cat_vet($line) . "\n";
Joe Perches000d1cc12011-07-25 17:13:25 -07002718 ERROR("HI_MACRO",
2719 "use the HI() macro, not (... >> 16)\n" . $herevet);
Mike Frysinger42e41c52009-09-21 17:04:40 -07002720 }
2721 }
2722
Andy Whitcroftb9ea10d2008-10-15 22:02:24 -07002723# check we are in a valid source file C or perl if not then ignore this hunk
Geert Uytterhoevende4c9242014-10-13 15:51:46 -07002724 next if ($realfile !~ /\.(h|c|pl|dtsi|dts)$/);
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002725
2726# at the beginning of a line any tabs must come first and anything
2727# more than 8 must use tabs.
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002728 if ($rawline =~ /^\+\s* \t\s*\S/ ||
2729 $rawline =~ /^\+\s* \s*/) {
2730 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
Andy Whitcroftd2c0a232010-10-26 14:23:12 -07002731 $rpt_cleaners = 1;
Joe Perches3705ce52013-07-03 15:05:31 -07002732 if (ERROR("CODE_INDENT",
2733 "code indent should use tabs where possible\n" . $herevet) &&
2734 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07002735 $fixed[$fixlinenr] =~ s/^\+([ \t]+)/"\+" . tabify($1)/e;
Joe Perches3705ce52013-07-03 15:05:31 -07002736 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002737 }
2738
Alberto Panizzo08e44362010-03-05 13:43:54 -08002739# check for space before tabs.
2740 if ($rawline =~ /^\+/ && $rawline =~ / \t/) {
2741 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
Joe Perches3705ce52013-07-03 15:05:31 -07002742 if (WARN("SPACE_BEFORE_TAB",
2743 "please, no space before tabs\n" . $herevet) &&
2744 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07002745 while ($fixed[$fixlinenr] =~
Joe Perchesd2207cc2014-10-13 15:51:53 -07002746 s/(^\+.*) {8,8}\t/$1\t\t/) {}
Joe Perches194f66f2014-08-06 16:11:03 -07002747 while ($fixed[$fixlinenr] =~
Joe Perchesc76f4cb2014-01-23 15:54:46 -08002748 s/(^\+.*) +\t/$1\t/) {}
Joe Perches3705ce52013-07-03 15:05:31 -07002749 }
Alberto Panizzo08e44362010-03-05 13:43:54 -08002750 }
2751
Joe Perchesd1fe9c02012-03-23 15:02:16 -07002752# check for && or || at the start of a line
2753 if ($rawline =~ /^\+\s*(&&|\|\|)/) {
2754 CHK("LOGICAL_CONTINUATIONS",
2755 "Logical continuations should be on the previous line\n" . $hereprev);
2756 }
2757
2758# check multi-line statement indentation matches previous line
2759 if ($^V && $^V ge 5.10.0 &&
Joe Perches91cb5192014-04-03 14:49:32 -07002760 $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 -07002761 $prevline =~ /^\+(\t*)(.*)$/;
2762 my $oldindent = $1;
2763 my $rest = $2;
2764
2765 my $pos = pos_last_openparen($rest);
2766 if ($pos >= 0) {
Joe Perchesb34a26f2012-07-30 14:41:16 -07002767 $line =~ /^(\+| )([ \t]*)/;
2768 my $newindent = $2;
Joe Perchesd1fe9c02012-03-23 15:02:16 -07002769
2770 my $goodtabindent = $oldindent .
2771 "\t" x ($pos / 8) .
2772 " " x ($pos % 8);
2773 my $goodspaceindent = $oldindent . " " x $pos;
2774
2775 if ($newindent ne $goodtabindent &&
2776 $newindent ne $goodspaceindent) {
Joe Perches3705ce52013-07-03 15:05:31 -07002777
2778 if (CHK("PARENTHESIS_ALIGNMENT",
2779 "Alignment should match open parenthesis\n" . $hereprev) &&
2780 $fix && $line =~ /^\+/) {
Joe Perches194f66f2014-08-06 16:11:03 -07002781 $fixed[$fixlinenr] =~
Joe Perches3705ce52013-07-03 15:05:31 -07002782 s/^\+[ \t]*/\+$goodtabindent/;
2783 }
Joe Perchesd1fe9c02012-03-23 15:02:16 -07002784 }
2785 }
2786 }
2787
Joe Perches6ab3a972015-04-16 12:44:05 -07002788# check for space after cast like "(int) foo" or "(struct foo) bar"
2789# avoid checking a few false positives:
2790# "sizeof(<type>)" or "__alignof__(<type>)"
2791# function pointer declarations like "(*foo)(int) = bar;"
2792# structure definitions like "(struct foo) { 0 };"
2793# multiline macros that define functions
2794# known attributes or the __attribute__ keyword
2795 if ($line =~ /^\+(.*)\(\s*$Type\s*\)([ \t]++)((?![={]|\\$|$Attribute|__attribute__))/ &&
2796 (!defined($1) || $1 !~ /\b(?:sizeof|__alignof__)\s*$/)) {
Joe Perches3705ce52013-07-03 15:05:31 -07002797 if (CHK("SPACING",
Joe Perchesf27c95d2014-08-06 16:10:52 -07002798 "No space is necessary after a cast\n" . $herecurr) &&
Joe Perches3705ce52013-07-03 15:05:31 -07002799 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07002800 $fixed[$fixlinenr] =~
Joe Perchesf27c95d2014-08-06 16:10:52 -07002801 s/(\(\s*$Type\s*\))[ \t]+/$1/;
Joe Perches3705ce52013-07-03 15:05:31 -07002802 }
Joe Perchesaad4f612012-03-23 15:02:19 -07002803 }
2804
Joe Perches86406b12015-09-09 15:37:41 -07002805# Block comment styles
2806# Networking with an initial /*
Joe Perches05880602012-10-04 17:13:35 -07002807 if ($realfile =~ m@^(drivers/net/|net/)@ &&
Joe Perchesfdb4bcd2013-07-03 15:05:23 -07002808 $prevrawline =~ /^\+[ \t]*\/\*[ \t]*$/ &&
Joe Perches85ad9782014-04-03 14:49:20 -07002809 $rawline =~ /^\+[ \t]*\*/ &&
2810 $realline > 2) {
Joe Perches05880602012-10-04 17:13:35 -07002811 WARN("NETWORKING_BLOCK_COMMENT_STYLE",
2812 "networking block comments don't use an empty /* line, use /* Comment...\n" . $hereprev);
2813 }
2814
Joe Perches86406b12015-09-09 15:37:41 -07002815# Block comments use * on subsequent lines
2816 if ($prevline =~ /$;[ \t]*$/ && #ends in comment
2817 $prevrawline =~ /^\+.*?\/\*/ && #starting /*
Joe Perchesa605e322013-07-03 15:05:24 -07002818 $prevrawline !~ /\*\/[ \t]*$/ && #no trailing */
Joe Perches61135e92013-09-11 14:23:59 -07002819 $rawline =~ /^\+/ && #line is new
Joe Perchesa605e322013-07-03 15:05:24 -07002820 $rawline !~ /^\+[ \t]*\*/) { #no leading *
Joe Perches86406b12015-09-09 15:37:41 -07002821 WARN("BLOCK_COMMENT_STYLE",
2822 "Block comments use * on subsequent lines\n" . $hereprev);
Joe Perchesa605e322013-07-03 15:05:24 -07002823 }
2824
Joe Perches86406b12015-09-09 15:37:41 -07002825# Block comments use */ on trailing lines
2826 if ($rawline !~ m@^\+[ \t]*\*/[ \t]*$@ && #trailing */
Joe Perchesc24f9f12012-11-08 15:53:29 -08002827 $rawline !~ m@^\+.*/\*.*\*/[ \t]*$@ && #inline /*...*/
2828 $rawline !~ m@^\+.*\*{2,}/[ \t]*$@ && #trailing **/
2829 $rawline =~ m@^\+[ \t]*.+\*\/[ \t]*$@) { #non blank */
Joe Perches86406b12015-09-09 15:37:41 -07002830 WARN("BLOCK_COMMENT_STYLE",
2831 "Block comments use a trailing */ on a separate line\n" . $herecurr);
Joe Perches05880602012-10-04 17:13:35 -07002832 }
2833
Joe Perches7f619192014-08-06 16:10:39 -07002834# check for missing blank lines after struct/union declarations
2835# with exceptions for various attributes and macros
2836 if ($prevline =~ /^[\+ ]};?\s*$/ &&
2837 $line =~ /^\+/ &&
2838 !($line =~ /^\+\s*$/ ||
2839 $line =~ /^\+\s*EXPORT_SYMBOL/ ||
2840 $line =~ /^\+\s*MODULE_/i ||
2841 $line =~ /^\+\s*\#\s*(?:end|elif|else)/ ||
2842 $line =~ /^\+[a-z_]*init/ ||
2843 $line =~ /^\+\s*(?:static\s+)?[A-Z_]*ATTR/ ||
2844 $line =~ /^\+\s*DECLARE/ ||
2845 $line =~ /^\+\s*__setup/)) {
Joe Perchesd752fcc2014-08-06 16:11:05 -07002846 if (CHK("LINE_SPACING",
2847 "Please use a blank line after function/struct/union/enum declarations\n" . $hereprev) &&
2848 $fix) {
Joe Perchesf2d7e4d2014-08-06 16:11:07 -07002849 fix_insert_line($fixlinenr, "\+");
Joe Perchesd752fcc2014-08-06 16:11:05 -07002850 }
Joe Perches7f619192014-08-06 16:10:39 -07002851 }
2852
Joe Perches365dd4e2014-08-06 16:10:42 -07002853# check for multiple consecutive blank lines
2854 if ($prevline =~ /^[\+ ]\s*$/ &&
2855 $line =~ /^\+\s*$/ &&
2856 $last_blank_line != ($linenr - 1)) {
Joe Perchesd752fcc2014-08-06 16:11:05 -07002857 if (CHK("LINE_SPACING",
2858 "Please don't use multiple blank lines\n" . $hereprev) &&
2859 $fix) {
Joe Perchesf2d7e4d2014-08-06 16:11:07 -07002860 fix_delete_line($fixlinenr, $rawline);
Joe Perchesd752fcc2014-08-06 16:11:05 -07002861 }
2862
Joe Perches365dd4e2014-08-06 16:10:42 -07002863 $last_blank_line = $linenr;
2864 }
2865
Joe Perches3b617e32014-04-03 14:49:28 -07002866# check for missing blank lines after declarations
Joe Perches3f7bac02014-06-04 16:12:04 -07002867 if ($sline =~ /^\+\s+\S/ && #Not at char 1
2868 # actual declarations
2869 ($prevline =~ /^\+\s+$Declare\s*$Ident\s*[=,;:\[]/ ||
Joe Perches5a4e1fd2014-08-06 16:10:33 -07002870 # function pointer declarations
2871 $prevline =~ /^\+\s+$Declare\s*\(\s*\*\s*$Ident\s*\)\s*[=,;:\[\(]/ ||
Joe Perches3f7bac02014-06-04 16:12:04 -07002872 # foo bar; where foo is some local typedef or #define
2873 $prevline =~ /^\+\s+$Ident(?:\s+|\s*\*\s*)$Ident\s*[=,;\[]/ ||
2874 # known declaration macros
2875 $prevline =~ /^\+\s+$declaration_macros/) &&
2876 # for "else if" which can look like "$Ident $Ident"
2877 !($prevline =~ /^\+\s+$c90_Keywords\b/ ||
2878 # other possible extensions of declaration lines
2879 $prevline =~ /(?:$Compare|$Assignment|$Operators)\s*$/ ||
2880 # not starting a section or a macro "\" extended line
2881 $prevline =~ /(?:\{\s*|\\)$/) &&
2882 # looks like a declaration
2883 !($sline =~ /^\+\s+$Declare\s*$Ident\s*[=,;:\[]/ ||
Joe Perches5a4e1fd2014-08-06 16:10:33 -07002884 # function pointer declarations
2885 $sline =~ /^\+\s+$Declare\s*\(\s*\*\s*$Ident\s*\)\s*[=,;:\[\(]/ ||
Joe Perches3f7bac02014-06-04 16:12:04 -07002886 # foo bar; where foo is some local typedef or #define
2887 $sline =~ /^\+\s+$Ident(?:\s+|\s*\*\s*)$Ident\s*[=,;\[]/ ||
2888 # known declaration macros
2889 $sline =~ /^\+\s+$declaration_macros/ ||
2890 # start of struct or union or enum
Joe Perches3b617e32014-04-03 14:49:28 -07002891 $sline =~ /^\+\s+(?:union|struct|enum|typedef)\b/ ||
Joe Perches3f7bac02014-06-04 16:12:04 -07002892 # start or end of block or continuation of declaration
2893 $sline =~ /^\+\s+(?:$|[\{\}\.\#\"\?\:\(\[])/ ||
2894 # bitfield continuation
2895 $sline =~ /^\+\s+$Ident\s*:\s*\d+\s*[,;]/ ||
2896 # other possible extensions of declaration lines
2897 $sline =~ /^\+\s+\(?\s*(?:$Compare|$Assignment|$Operators)/) &&
2898 # indentation of previous and current line are the same
2899 (($prevline =~ /\+(\s+)\S/) && $sline =~ /^\+$1\S/)) {
Joe Perchesd752fcc2014-08-06 16:11:05 -07002900 if (WARN("LINE_SPACING",
2901 "Missing a blank line after declarations\n" . $hereprev) &&
2902 $fix) {
Joe Perchesf2d7e4d2014-08-06 16:11:07 -07002903 fix_insert_line($fixlinenr, "\+");
Joe Perchesd752fcc2014-08-06 16:11:05 -07002904 }
Joe Perches3b617e32014-04-03 14:49:28 -07002905 }
2906
Raffaele Recalcati5f7ddae2010-08-09 17:20:59 -07002907# check for spaces at the beginning of a line.
Andy Whitcroft6b4c5be2010-10-26 14:23:11 -07002908# Exceptions:
2909# 1) within comments
2910# 2) indented preprocessor commands
2911# 3) hanging labels
Joe Perches3705ce52013-07-03 15:05:31 -07002912 if ($rawline =~ /^\+ / && $line !~ /^\+ *(?:$;|#|$Ident:)/) {
Raffaele Recalcati5f7ddae2010-08-09 17:20:59 -07002913 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
Joe Perches3705ce52013-07-03 15:05:31 -07002914 if (WARN("LEADING_SPACE",
2915 "please, no spaces at the start of a line\n" . $herevet) &&
2916 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07002917 $fixed[$fixlinenr] =~ s/^\+([ \t]+)/"\+" . tabify($1)/e;
Joe Perches3705ce52013-07-03 15:05:31 -07002918 }
Raffaele Recalcati5f7ddae2010-08-09 17:20:59 -07002919 }
2920
Andy Whitcroftb9ea10d2008-10-15 22:02:24 -07002921# check we are in a valid C source file if not then ignore this hunk
2922 next if ($realfile !~ /\.(h|c)$/);
2923
Joe Perches032a4c02014-08-06 16:10:29 -07002924# check indentation of any line with a bare else
Joe Perches840080a2014-10-13 15:51:59 -07002925# (but not if it is a multiple line "if (foo) return bar; else return baz;")
Joe Perches032a4c02014-08-06 16:10:29 -07002926# if the previous line is a break or return and is indented 1 tab more...
2927 if ($sline =~ /^\+([\t]+)(?:}[ \t]*)?else(?:[ \t]*{)?\s*$/) {
2928 my $tabs = length($1) + 1;
Joe Perches840080a2014-10-13 15:51:59 -07002929 if ($prevline =~ /^\+\t{$tabs,$tabs}break\b/ ||
2930 ($prevline =~ /^\+\t{$tabs,$tabs}return\b/ &&
2931 defined $lines[$linenr] &&
2932 $lines[$linenr] !~ /^[ \+]\t{$tabs,$tabs}return/)) {
Joe Perches032a4c02014-08-06 16:10:29 -07002933 WARN("UNNECESSARY_ELSE",
2934 "else is not generally useful after a break or return\n" . $hereprev);
2935 }
2936 }
2937
Joe Perchesc00df192014-08-06 16:11:01 -07002938# check indentation of a line with a break;
2939# if the previous line is a goto or return and is indented the same # of tabs
2940 if ($sline =~ /^\+([\t]+)break\s*;\s*$/) {
2941 my $tabs = $1;
2942 if ($prevline =~ /^\+$tabs(?:goto|return)\b/) {
2943 WARN("UNNECESSARY_BREAK",
2944 "break is not useful after a goto or return\n" . $hereprev);
2945 }
2946 }
2947
Kees Cook1ba8dfd2012-12-17 16:01:48 -08002948# discourage the addition of CONFIG_EXPERIMENTAL in #if(def).
2949 if ($line =~ /^\+\s*\#\s*if.*\bCONFIG_EXPERIMENTAL\b/) {
2950 WARN("CONFIG_EXPERIMENTAL",
2951 "Use of CONFIG_EXPERIMENTAL is deprecated. For alternatives, see https://lkml.org/lkml/2012/10/23/580\n");
2952 }
2953
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002954# check for RCS/CVS revision markers
Andy Whitcroftcf655042008-03-04 14:28:20 -08002955 if ($rawline =~ /^\+.*\$(Revision|Log|Id)(?:\$|)/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07002956 WARN("CVS_KEYWORD",
2957 "CVS style keyword markers, these will _not_ be updated\n". $herecurr);
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002958 }
Andy Whitcroft22f2a2e2007-08-10 13:01:03 -07002959
Mike Frysinger42e41c52009-09-21 17:04:40 -07002960# Blackfin: don't use __builtin_bfin_[cs]sync
2961 if ($line =~ /__builtin_bfin_csync/) {
2962 my $herevet = "$here\n" . cat_vet($line) . "\n";
Joe Perches000d1cc12011-07-25 17:13:25 -07002963 ERROR("CSYNC",
2964 "use the CSYNC() macro in asm/blackfin.h\n" . $herevet);
Mike Frysinger42e41c52009-09-21 17:04:40 -07002965 }
2966 if ($line =~ /__builtin_bfin_ssync/) {
2967 my $herevet = "$here\n" . cat_vet($line) . "\n";
Joe Perches000d1cc12011-07-25 17:13:25 -07002968 ERROR("SSYNC",
2969 "use the SSYNC() macro in asm/blackfin.h\n" . $herevet);
Mike Frysinger42e41c52009-09-21 17:04:40 -07002970 }
2971
Joe Perches56e77d72013-02-21 16:44:14 -08002972# check for old HOTPLUG __dev<foo> section markings
2973 if ($line =~ /\b(__dev(init|exit)(data|const|))\b/) {
2974 WARN("HOTPLUG_SECTION",
2975 "Using $1 is unnecessary\n" . $herecurr);
2976 }
2977
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07002978# Check for potential 'bare' types
Andy Whitcroft2b474a12009-10-26 16:50:16 -07002979 my ($stat, $cond, $line_nr_next, $remain_next, $off_next,
2980 $realline_next);
Andy Whitcroft3e469cd2012-01-10 15:10:01 -08002981#print "LINE<$line>\n";
2982 if ($linenr >= $suppress_statement &&
Joe Perches1b5539b2013-09-11 14:24:03 -07002983 $realcnt && $sline =~ /.\s*\S/) {
Andy Whitcroft170d3a22008-10-15 22:02:30 -07002984 ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
Andy Whitcroftf5fe35d2008-07-23 21:29:03 -07002985 ctx_statement_block($linenr, $realcnt, 0);
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07002986 $stat =~ s/\n./\n /g;
2987 $cond =~ s/\n./\n /g;
2988
Andy Whitcroft3e469cd2012-01-10 15:10:01 -08002989#print "linenr<$linenr> <$stat>\n";
2990 # If this statement has no statement boundaries within
2991 # it there is no point in retrying a statement scan
2992 # until we hit end of it.
2993 my $frag = $stat; $frag =~ s/;+\s*$//;
2994 if ($frag !~ /(?:{|;)/) {
2995#print "skip<$line_nr_next>\n";
2996 $suppress_statement = $line_nr_next;
2997 }
Andy Whitcroftf74bd192012-01-10 15:09:54 -08002998
Andy Whitcroft2b474a12009-10-26 16:50:16 -07002999 # Find the real next line.
3000 $realline_next = $line_nr_next;
3001 if (defined $realline_next &&
3002 (!defined $lines[$realline_next - 1] ||
3003 substr($lines[$realline_next - 1], $off_next) =~ /^\s*$/)) {
3004 $realline_next++;
3005 }
3006
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07003007 my $s = $stat;
3008 $s =~ s/{.*$//s;
Andy Whitcroftcf655042008-03-04 14:28:20 -08003009
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08003010 # Ignore goto labels.
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07003011 if ($s =~ /$Ident:\*$/s) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08003012
3013 # Ignore functions being called
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07003014 } elsif ($s =~ /^.\s*$Ident\s*\(/s) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08003015
Andy Whitcroft463f2862009-09-21 17:04:34 -07003016 } elsif ($s =~ /^.\s*else\b/s) {
3017
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07003018 # declarations always start with types
Andy Whitcroftd2506582008-07-23 21:29:09 -07003019 } 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 -07003020 my $type = $1;
3021 $type =~ s/\s+/ /g;
3022 possible($type, "A:" . $s);
3023
Andy Whitcroft8905a672007-11-28 16:21:06 -08003024 # definitions in global scope can only start with types
Andy Whitcrofta6a840622008-10-15 22:02:30 -07003025 } elsif ($s =~ /^.(?:$Storage\s+)?(?:$Inline\s+)?(?:const\s+)?($Ident)\b\s*(?!:)/s) {
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07003026 possible($1, "B:" . $s);
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08003027 }
Andy Whitcroft8905a672007-11-28 16:21:06 -08003028
3029 # any (foo ... *) is a pointer cast, and foo is a type
Andy Whitcroft65863862009-01-06 14:41:21 -08003030 while ($s =~ /\(($Ident)(?:\s+$Sparse)*[\s\*]+\s*\)/sg) {
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07003031 possible($1, "C:" . $s);
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07003032 }
Andy Whitcroft8905a672007-11-28 16:21:06 -08003033
3034 # Check for any sort of function declaration.
3035 # int foo(something bar, other baz);
3036 # void (*store_gdt)(x86_descr_ptr *);
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07003037 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 -08003038 my ($name_len) = length($1);
Andy Whitcroft8905a672007-11-28 16:21:06 -08003039
Andy Whitcroftcf655042008-03-04 14:28:20 -08003040 my $ctx = $s;
Andy Whitcroft773647a2008-03-28 14:15:58 -07003041 substr($ctx, 0, $name_len + 1, '');
Andy Whitcroft8905a672007-11-28 16:21:06 -08003042 $ctx =~ s/\)[^\)]*$//;
Andy Whitcroftcf655042008-03-04 14:28:20 -08003043
Andy Whitcroft8905a672007-11-28 16:21:06 -08003044 for my $arg (split(/\s*,\s*/, $ctx)) {
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07003045 if ($arg =~ /^(?:const\s+)?($Ident)(?:\s+$Sparse)*\s*\**\s*(:?\b$Ident)?$/s || $arg =~ /^($Ident)$/s) {
Andy Whitcroft8905a672007-11-28 16:21:06 -08003046
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07003047 possible($1, "D:" . $s);
Andy Whitcroft8905a672007-11-28 16:21:06 -08003048 }
3049 }
3050 }
3051
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07003052 }
3053
Andy Whitcroft653d4872007-06-23 17:16:34 -07003054#
3055# Checks which may be anchored in the context.
3056#
3057
3058# Check for switch () and associated case and default
3059# statements should be at the same indent.
Andy Whitcroft00df3442007-06-08 13:47:06 -07003060 if ($line=~/\bswitch\s*\(.*\)/) {
3061 my $err = '';
3062 my $sep = '';
3063 my @ctx = ctx_block_outer($linenr, $realcnt);
3064 shift(@ctx);
3065 for my $ctx (@ctx) {
3066 my ($clen, $cindent) = line_stats($ctx);
3067 if ($ctx =~ /^\+\s*(case\s+|default:)/ &&
3068 $indent != $cindent) {
3069 $err .= "$sep$ctx\n";
3070 $sep = '';
3071 } else {
3072 $sep = "[...]\n";
3073 }
3074 }
3075 if ($err ne '') {
Joe Perches000d1cc12011-07-25 17:13:25 -07003076 ERROR("SWITCH_CASE_INDENT_LEVEL",
3077 "switch and case should be at the same indent\n$hereline$err");
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07003078 }
3079 }
3080
3081# if/while/etc brace do not go on next line, unless defining a do while loop,
3082# or if that brace on the next line is for something else
Joe Perches0fe3dc22014-08-06 16:11:16 -07003083 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 -07003084 my $pre_ctx = "$1$2";
3085
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07003086 my ($level, @ctx) = ctx_statement_level($linenr, $realcnt, 0);
Joe Perches8eef05d2012-02-03 15:20:39 -08003087
3088 if ($line =~ /^\+\t{6,}/) {
3089 WARN("DEEP_INDENTATION",
3090 "Too many leading tabs - consider code refactoring\n" . $herecurr);
3091 }
3092
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07003093 my $ctx_cnt = $realcnt - $#ctx - 1;
3094 my $ctx = join("\n", @ctx);
3095
Andy Whitcroft548596d2008-07-23 21:29:01 -07003096 my $ctx_ln = $linenr;
3097 my $ctx_skip = $realcnt;
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07003098
Andy Whitcroft548596d2008-07-23 21:29:01 -07003099 while ($ctx_skip > $ctx_cnt || ($ctx_skip == $ctx_cnt &&
3100 defined $lines[$ctx_ln - 1] &&
3101 $lines[$ctx_ln - 1] =~ /^-/)) {
3102 ##print "SKIP<$ctx_skip> CNT<$ctx_cnt>\n";
3103 $ctx_skip-- if (!defined $lines[$ctx_ln - 1] || $lines[$ctx_ln - 1] !~ /^-/);
Andy Whitcroft773647a2008-03-28 14:15:58 -07003104 $ctx_ln++;
3105 }
Andy Whitcroft548596d2008-07-23 21:29:01 -07003106
Andy Whitcroft53210162008-07-23 21:29:03 -07003107 #print "realcnt<$realcnt> ctx_cnt<$ctx_cnt>\n";
3108 #print "pre<$pre_ctx>\nline<$line>\nctx<$ctx>\nnext<$lines[$ctx_ln - 1]>\n";
Andy Whitcroft773647a2008-03-28 14:15:58 -07003109
Joe Perchesd752fcc2014-08-06 16:11:05 -07003110 if ($ctx !~ /{\s*/ && defined($lines[$ctx_ln - 1]) && $lines[$ctx_ln - 1] =~ /^\+\s*{/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003111 ERROR("OPEN_BRACE",
3112 "that open brace { should be on the previous line\n" .
Andy Whitcroft01464f32010-10-26 14:23:19 -07003113 "$here\n$ctx\n$rawlines[$ctx_ln - 1]\n");
Andy Whitcroft00df3442007-06-08 13:47:06 -07003114 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07003115 if ($level == 0 && $pre_ctx !~ /}\s*while\s*\($/ &&
3116 $ctx =~ /\)\s*\;\s*$/ &&
3117 defined $lines[$ctx_ln - 1])
3118 {
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07003119 my ($nlength, $nindent) = line_stats($lines[$ctx_ln - 1]);
3120 if ($nindent > $indent) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003121 WARN("TRAILING_SEMICOLON",
3122 "trailing semicolon indicates no statements, indent implies otherwise\n" .
Andy Whitcroft01464f32010-10-26 14:23:19 -07003123 "$here\n$ctx\n$rawlines[$ctx_ln - 1]\n");
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07003124 }
3125 }
Andy Whitcroft00df3442007-06-08 13:47:06 -07003126 }
3127
Andy Whitcroft4d001e42008-10-15 22:02:21 -07003128# Check relative indent for conditionals and blocks.
Joe Perches0fe3dc22014-08-06 16:11:16 -07003129 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 -08003130 ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
3131 ctx_statement_block($linenr, $realcnt, 0)
3132 if (!defined $stat);
Andy Whitcroft4d001e42008-10-15 22:02:21 -07003133 my ($s, $c) = ($stat, $cond);
3134
3135 substr($s, 0, length($c), '');
3136
Joe Perches9f5af482015-09-09 15:37:30 -07003137 # remove inline comments
3138 $s =~ s/$;/ /g;
3139 $c =~ s/$;/ /g;
Andy Whitcroft4d001e42008-10-15 22:02:21 -07003140
3141 # Find out how long the conditional actually is.
Andy Whitcroft6f779c12008-10-15 22:02:27 -07003142 my @newlines = ($c =~ /\n/gs);
3143 my $cond_lines = 1 + $#newlines;
Andy Whitcroft4d001e42008-10-15 22:02:21 -07003144
Joe Perches9f5af482015-09-09 15:37:30 -07003145 # Make sure we remove the line prefixes as we have
3146 # none on the first line, and are going to readd them
3147 # where necessary.
3148 $s =~ s/\n./\n/gs;
3149 while ($s =~ /\n\s+\\\n/) {
3150 $cond_lines += $s =~ s/\n\s+\\\n/\n/g;
3151 }
3152
Andy Whitcroft4d001e42008-10-15 22:02:21 -07003153 # We want to check the first line inside the block
3154 # starting at the end of the conditional, so remove:
3155 # 1) any blank line termination
3156 # 2) any opening brace { on end of the line
3157 # 3) any do (...) {
3158 my $continuation = 0;
3159 my $check = 0;
3160 $s =~ s/^.*\bdo\b//;
3161 $s =~ s/^\s*{//;
3162 if ($s =~ s/^\s*\\//) {
3163 $continuation = 1;
3164 }
Andy Whitcroft9bd49ef2008-10-15 22:02:22 -07003165 if ($s =~ s/^\s*?\n//) {
Andy Whitcroft4d001e42008-10-15 22:02:21 -07003166 $check = 1;
3167 $cond_lines++;
3168 }
3169
3170 # Also ignore a loop construct at the end of a
3171 # preprocessor statement.
3172 if (($prevline =~ /^.\s*#\s*define\s/ ||
3173 $prevline =~ /\\\s*$/) && $continuation == 0) {
3174 $check = 0;
3175 }
3176
Andy Whitcroft9bd49ef2008-10-15 22:02:22 -07003177 my $cond_ptr = -1;
Andy Whitcroft740504c2008-10-15 22:02:35 -07003178 $continuation = 0;
Andy Whitcroft9bd49ef2008-10-15 22:02:22 -07003179 while ($cond_ptr != $cond_lines) {
3180 $cond_ptr = $cond_lines;
Andy Whitcroft4d001e42008-10-15 22:02:21 -07003181
Andy Whitcroftf16fa282008-10-15 22:02:32 -07003182 # If we see an #else/#elif then the code
3183 # is not linear.
3184 if ($s =~ /^\s*\#\s*(?:else|elif)/) {
3185 $check = 0;
3186 }
3187
Andy Whitcroft9bd49ef2008-10-15 22:02:22 -07003188 # Ignore:
3189 # 1) blank lines, they should be at 0,
3190 # 2) preprocessor lines, and
3191 # 3) labels.
Andy Whitcroft740504c2008-10-15 22:02:35 -07003192 if ($continuation ||
3193 $s =~ /^\s*?\n/ ||
Andy Whitcroft9bd49ef2008-10-15 22:02:22 -07003194 $s =~ /^\s*#\s*?/ ||
3195 $s =~ /^\s*$Ident\s*:/) {
Andy Whitcroft740504c2008-10-15 22:02:35 -07003196 $continuation = ($s =~ /^.*?\\\n/) ? 1 : 0;
Andy Whitcroft30dad6e2009-09-21 17:04:36 -07003197 if ($s =~ s/^.*?\n//) {
3198 $cond_lines++;
3199 }
Andy Whitcroft9bd49ef2008-10-15 22:02:22 -07003200 }
Andy Whitcroft4d001e42008-10-15 22:02:21 -07003201 }
3202
3203 my (undef, $sindent) = line_stats("+" . $s);
3204 my $stat_real = raw_line($linenr, $cond_lines);
3205
3206 # Check if either of these lines are modified, else
3207 # this is not this patch's fault.
3208 if (!defined($stat_real) ||
3209 $stat !~ /^\+/ && $stat_real !~ /^\+/) {
3210 $check = 0;
3211 }
3212 if (defined($stat_real) && $cond_lines > 1) {
3213 $stat_real = "[...]\n$stat_real";
3214 }
3215
Andy Whitcroft9bd49ef2008-10-15 22:02:22 -07003216 #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 -07003217
Joe Perches9f5af482015-09-09 15:37:30 -07003218 if ($check && $s ne '' &&
3219 (($sindent % 8) != 0 ||
3220 ($sindent < $indent) ||
3221 ($sindent > $indent + 8))) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003222 WARN("SUSPECT_CODE_INDENT",
3223 "suspect code indent for conditional statements ($indent, $sindent)\n" . $herecurr . "$stat_real\n");
Andy Whitcroft4d001e42008-10-15 22:02:21 -07003224 }
3225 }
3226
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07003227 # Track the 'values' across context and added lines.
3228 my $opline = $line; $opline =~ s/^./ /;
Andy Whitcroft1f65f942008-07-23 21:29:10 -07003229 my ($curr_values, $curr_vars) =
3230 annotate_values($opline . "\n", $prev_values);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07003231 $curr_values = $prev_values . $curr_values;
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08003232 if ($dbg_values) {
3233 my $outline = $opline; $outline =~ s/\t/ /g;
Andy Whitcroftcf655042008-03-04 14:28:20 -08003234 print "$linenr > .$outline\n";
3235 print "$linenr > $curr_values\n";
Andy Whitcroft1f65f942008-07-23 21:29:10 -07003236 print "$linenr > $curr_vars\n";
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08003237 }
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07003238 $prev_values = substr($curr_values, -1);
3239
Andy Whitcroft00df3442007-06-08 13:47:06 -07003240#ignore lines not being added
Joe Perches3705ce52013-07-03 15:05:31 -07003241 next if ($line =~ /^[^\+]/);
Andy Whitcroft00df3442007-06-08 13:47:06 -07003242
Joe Perchesa1ce18e2016-03-15 14:58:03 -07003243# check for declarations of signed or unsigned without int
Joe Perches207a8e82016-03-15 14:58:06 -07003244 while ($line =~ m{($Declare)\s*(?!char\b|short\b|int\b|long\b)\s*($Ident)?\s*[=,;\[\)\(]}g) {
Joe Perchesa1ce18e2016-03-15 14:58:03 -07003245 my $type = $1;
3246 my $var = $2;
Joe Perches207a8e82016-03-15 14:58:06 -07003247 $var = "" if (!defined $var);
3248 if ($type =~ /^(?:(?:$Storage|$Inline|$Attribute)\s+)*((?:un)?signed)((?:\s*\*)*)\s*$/) {
Joe Perchesa1ce18e2016-03-15 14:58:03 -07003249 my $sign = $1;
3250 my $pointer = $2;
3251
3252 $pointer = "" if (!defined $pointer);
3253
3254 if (WARN("UNSPECIFIED_INT",
3255 "Prefer '" . trim($sign) . " int" . rtrim($pointer) . "' to bare use of '$sign" . rtrim($pointer) . "'\n" . $herecurr) &&
3256 $fix) {
3257 my $decl = trim($sign) . " int ";
Joe Perches207a8e82016-03-15 14:58:06 -07003258 my $comp_pointer = $pointer;
3259 $comp_pointer =~ s/\s//g;
3260 $decl .= $comp_pointer;
3261 $decl = rtrim($decl) if ($var eq "");
3262 $fixed[$fixlinenr] =~ s@\b$sign\s*\Q$pointer\E\s*$var\b@$decl$var@;
Joe Perchesa1ce18e2016-03-15 14:58:03 -07003263 }
3264 }
3265 }
3266
Andy Whitcroft653d4872007-06-23 17:16:34 -07003267# TEST: allow direct testing of the type matcher.
Andy Whitcroft7429c692008-07-23 21:29:06 -07003268 if ($dbg_type) {
3269 if ($line =~ /^.\s*$Declare\s*$/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003270 ERROR("TEST_TYPE",
3271 "TEST: is type\n" . $herecurr);
Andy Whitcroft7429c692008-07-23 21:29:06 -07003272 } elsif ($dbg_type > 1 && $line =~ /^.+($Declare)/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003273 ERROR("TEST_NOT_TYPE",
3274 "TEST: is not type ($1 is)\n". $herecurr);
Andy Whitcroft7429c692008-07-23 21:29:06 -07003275 }
Andy Whitcroft653d4872007-06-23 17:16:34 -07003276 next;
3277 }
Andy Whitcrofta1ef2772008-10-15 22:02:17 -07003278# TEST: allow direct testing of the attribute matcher.
3279 if ($dbg_attr) {
Andy Whitcroft9360b0e2009-02-27 14:03:08 -08003280 if ($line =~ /^.\s*$Modifier\s*$/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003281 ERROR("TEST_ATTR",
3282 "TEST: is attr\n" . $herecurr);
Andy Whitcroft9360b0e2009-02-27 14:03:08 -08003283 } elsif ($dbg_attr > 1 && $line =~ /^.+($Modifier)/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003284 ERROR("TEST_NOT_ATTR",
3285 "TEST: is not attr ($1 is)\n". $herecurr);
Andy Whitcrofta1ef2772008-10-15 22:02:17 -07003286 }
3287 next;
3288 }
Andy Whitcroft653d4872007-06-23 17:16:34 -07003289
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07003290# check for initialisation to aggregates open brace on the next line
Andy Whitcroft99423c22009-10-26 16:50:15 -07003291 if ($line =~ /^.\s*{/ &&
3292 $prevline =~ /(?:^|[^=])=\s*$/) {
Joe Perchesd752fcc2014-08-06 16:11:05 -07003293 if (ERROR("OPEN_BRACE",
3294 "that open brace { should be on the previous line\n" . $hereprev) &&
Joe Perchesf2d7e4d2014-08-06 16:11:07 -07003295 $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
3296 fix_delete_line($fixlinenr - 1, $prevrawline);
3297 fix_delete_line($fixlinenr, $rawline);
Joe Perchesd752fcc2014-08-06 16:11:05 -07003298 my $fixedline = $prevrawline;
3299 $fixedline =~ s/\s*=\s*$/ = {/;
Joe Perchesf2d7e4d2014-08-06 16:11:07 -07003300 fix_insert_line($fixlinenr, $fixedline);
Joe Perchesd752fcc2014-08-06 16:11:05 -07003301 $fixedline = $line;
3302 $fixedline =~ s/^(.\s*){\s*/$1/;
Joe Perchesf2d7e4d2014-08-06 16:11:07 -07003303 fix_insert_line($fixlinenr, $fixedline);
Joe Perchesd752fcc2014-08-06 16:11:05 -07003304 }
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07003305 }
3306
Andy Whitcroft653d4872007-06-23 17:16:34 -07003307#
3308# Checks which are anchored on the added line.
3309#
3310
3311# check for malformed paths in #include statements (uses RAW line)
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07003312 if ($rawline =~ m{^.\s*\#\s*include\s+[<"](.*)[">]}) {
Andy Whitcroft653d4872007-06-23 17:16:34 -07003313 my $path = $1;
3314 if ($path =~ m{//}) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003315 ERROR("MALFORMED_INCLUDE",
Joe Perches495e9d82012-12-20 15:05:37 -08003316 "malformed #include filename\n" . $herecurr);
3317 }
3318 if ($path =~ "^uapi/" && $realfile =~ m@\binclude/uapi/@) {
3319 ERROR("UAPI_INCLUDE",
3320 "No #include in ...include/uapi/... should use a uapi/ path prefix\n" . $herecurr);
Andy Whitcroft653d4872007-06-23 17:16:34 -07003321 }
Andy Whitcroft653d4872007-06-23 17:16:34 -07003322 }
Andy Whitcroft00df3442007-06-08 13:47:06 -07003323
3324# no C99 // comments
3325 if ($line =~ m{//}) {
Joe Perches3705ce52013-07-03 15:05:31 -07003326 if (ERROR("C99_COMMENTS",
3327 "do not use C99 // comments\n" . $herecurr) &&
3328 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07003329 my $line = $fixed[$fixlinenr];
Joe Perches3705ce52013-07-03 15:05:31 -07003330 if ($line =~ /\/\/(.*)$/) {
3331 my $comment = trim($1);
Joe Perches194f66f2014-08-06 16:11:03 -07003332 $fixed[$fixlinenr] =~ s@\/\/(.*)$@/\* $comment \*/@;
Joe Perches3705ce52013-07-03 15:05:31 -07003333 }
3334 }
Andy Whitcroft00df3442007-06-08 13:47:06 -07003335 }
3336 # Remove C99 comments.
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003337 $line =~ s@//.*@@;
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07003338 $opline =~ s@//.*@@;
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003339
Andy Whitcroft2b474a12009-10-26 16:50:16 -07003340# EXPORT_SYMBOL should immediately follow the thing it is exporting, consider
3341# the whole statement.
3342#print "APW <$lines[$realline_next - 1]>\n";
3343 if (defined $realline_next &&
3344 exists $lines[$realline_next - 1] &&
3345 !defined $suppress_export{$realline_next} &&
3346 ($lines[$realline_next - 1] =~ /EXPORT_SYMBOL.*\((.*)\)/ ||
3347 $lines[$realline_next - 1] =~ /EXPORT_UNUSED_SYMBOL.*\((.*)\)/)) {
Andy Whitcroft3cbf62d2010-10-26 14:23:18 -07003348 # Handle definitions which produce identifiers with
3349 # a prefix:
3350 # XXX(foo);
3351 # EXPORT_SYMBOL(something_foo);
Andy Whitcroft653d4872007-06-23 17:16:34 -07003352 my $name = $1;
Andy Whitcroft87a53872012-01-10 15:10:04 -08003353 if ($stat =~ /^(?:.\s*}\s*\n)?.([A-Z_]+)\s*\(\s*($Ident)/ &&
Andy Whitcroft3cbf62d2010-10-26 14:23:18 -07003354 $name =~ /^${Ident}_$2/) {
3355#print "FOO C name<$name>\n";
3356 $suppress_export{$realline_next} = 1;
3357
3358 } elsif ($stat !~ /(?:
Andy Whitcroft2b474a12009-10-26 16:50:16 -07003359 \n.}\s*$|
Andy Whitcroft48012052008-10-15 22:02:34 -07003360 ^.DEFINE_$Ident\(\Q$name\E\)|
3361 ^.DECLARE_$Ident\(\Q$name\E\)|
3362 ^.LIST_HEAD\(\Q$name\E\)|
Andy Whitcroft2b474a12009-10-26 16:50:16 -07003363 ^.(?:$Storage\s+)?$Type\s*\(\s*\*\s*\Q$name\E\s*\)\s*\(|
3364 \b\Q$name\E(?:\s+$Attribute)*\s*(?:;|=|\[|\()
Andy Whitcroft48012052008-10-15 22:02:34 -07003365 )/x) {
Andy Whitcroft2b474a12009-10-26 16:50:16 -07003366#print "FOO A<$lines[$realline_next - 1]> stat<$stat> name<$name>\n";
3367 $suppress_export{$realline_next} = 2;
3368 } else {
3369 $suppress_export{$realline_next} = 1;
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003370 }
3371 }
Andy Whitcroft2b474a12009-10-26 16:50:16 -07003372 if (!defined $suppress_export{$linenr} &&
3373 $prevline =~ /^.\s*$/ &&
3374 ($line =~ /EXPORT_SYMBOL.*\((.*)\)/ ||
3375 $line =~ /EXPORT_UNUSED_SYMBOL.*\((.*)\)/)) {
3376#print "FOO B <$lines[$linenr - 1]>\n";
3377 $suppress_export{$linenr} = 2;
3378 }
3379 if (defined $suppress_export{$linenr} &&
3380 $suppress_export{$linenr} == 2) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003381 WARN("EXPORT_SYMBOL",
3382 "EXPORT_SYMBOL(foo); should immediately follow its function/variable\n" . $herecurr);
Andy Whitcroft2b474a12009-10-26 16:50:16 -07003383 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003384
Joe Eloff5150bda2010-08-09 17:21:00 -07003385# check for global initialisers.
Joe Perches6d32f7a2015-11-06 16:31:37 -08003386 if ($line =~ /^\+$Type\s*$Ident(?:\s+$Modifier)*\s*=\s*($zero_initializer)\s*;/) {
Joe Perchesd5e616f2013-09-11 14:23:54 -07003387 if (ERROR("GLOBAL_INITIALISERS",
Joe Perches6d32f7a2015-11-06 16:31:37 -08003388 "do not initialise globals to $1\n" . $herecurr) &&
Joe Perchesd5e616f2013-09-11 14:23:54 -07003389 $fix) {
Joe Perches6d32f7a2015-11-06 16:31:37 -08003390 $fixed[$fixlinenr] =~ s/(^.$Type\s*$Ident(?:\s+$Modifier)*)\s*=\s*$zero_initializer\s*;/$1;/;
Joe Perchesd5e616f2013-09-11 14:23:54 -07003391 }
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07003392 }
Andy Whitcroft653d4872007-06-23 17:16:34 -07003393# check for static initialisers.
Joe Perches6d32f7a2015-11-06 16:31:37 -08003394 if ($line =~ /^\+.*\bstatic\s.*=\s*($zero_initializer)\s*;/) {
Joe Perchesd5e616f2013-09-11 14:23:54 -07003395 if (ERROR("INITIALISED_STATIC",
Joe Perches6d32f7a2015-11-06 16:31:37 -08003396 "do not initialise statics to $1\n" .
Joe Perchesd5e616f2013-09-11 14:23:54 -07003397 $herecurr) &&
3398 $fix) {
Joe Perches6d32f7a2015-11-06 16:31:37 -08003399 $fixed[$fixlinenr] =~ s/(\bstatic\s.*?)\s*=\s*$zero_initializer\s*;/$1;/;
Joe Perchesd5e616f2013-09-11 14:23:54 -07003400 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003401 }
3402
Joe Perches18130872014-08-06 16:11:22 -07003403# check for misordered declarations of char/short/int/long with signed/unsigned
3404 while ($sline =~ m{(\b$TypeMisordered\b)}g) {
3405 my $tmp = trim($1);
3406 WARN("MISORDERED_TYPE",
3407 "type '$tmp' should be specified in [[un]signed] [short|int|long|long long] order\n" . $herecurr);
3408 }
3409
Joe Perchescb710ec2010-10-26 14:23:20 -07003410# check for static const char * arrays.
3411 if ($line =~ /\bstatic\s+const\s+char\s*\*\s*(\w+)\s*\[\s*\]\s*=\s*/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003412 WARN("STATIC_CONST_CHAR_ARRAY",
3413 "static const char * array should probably be static const char * const\n" .
Joe Perchescb710ec2010-10-26 14:23:20 -07003414 $herecurr);
3415 }
3416
3417# check for static char foo[] = "bar" declarations.
3418 if ($line =~ /\bstatic\s+char\s+(\w+)\s*\[\s*\]\s*=\s*"/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003419 WARN("STATIC_CONST_CHAR_ARRAY",
3420 "static char array declaration should probably be static const char\n" .
Joe Perchescb710ec2010-10-26 14:23:20 -07003421 $herecurr);
3422 }
3423
Joe Perchesab7e23f2015-04-16 12:44:22 -07003424# check for const <foo> const where <foo> is not a pointer or array type
3425 if ($sline =~ /\bconst\s+($BasicType)\s+const\b/) {
3426 my $found = $1;
3427 if ($sline =~ /\bconst\s+\Q$found\E\s+const\b\s*\*/) {
3428 WARN("CONST_CONST",
3429 "'const $found const *' should probably be 'const $found * const'\n" . $herecurr);
3430 } elsif ($sline !~ /\bconst\s+\Q$found\E\s+const\s+\w+\s*\[/) {
3431 WARN("CONST_CONST",
3432 "'const $found const' should probably be 'const $found'\n" . $herecurr);
3433 }
3434 }
3435
Joe Perches9b0fa602014-04-03 14:49:18 -07003436# check for non-global char *foo[] = {"bar", ...} declarations.
3437 if ($line =~ /^.\s+(?:static\s+|const\s+)?char\s+\*\s*\w+\s*\[\s*\]\s*=\s*\{/) {
3438 WARN("STATIC_CONST_CHAR_ARRAY",
3439 "char * array declaration might be better as static const\n" .
3440 $herecurr);
3441 }
3442
Joe Perchesb598b672015-04-16 12:44:36 -07003443# check for sizeof(foo)/sizeof(foo[0]) that could be ARRAY_SIZE(foo)
3444 if ($line =~ m@\bsizeof\s*\(\s*($Lval)\s*\)@) {
3445 my $array = $1;
3446 if ($line =~ m@\b(sizeof\s*\(\s*\Q$array\E\s*\)\s*/\s*sizeof\s*\(\s*\Q$array\E\s*\[\s*0\s*\]\s*\))@) {
3447 my $array_div = $1;
3448 if (WARN("ARRAY_SIZE",
3449 "Prefer ARRAY_SIZE($array)\n" . $herecurr) &&
3450 $fix) {
3451 $fixed[$fixlinenr] =~ s/\Q$array_div\E/ARRAY_SIZE($array)/;
3452 }
3453 }
3454 }
3455
Joe Perchesb36190c2014-01-27 17:07:18 -08003456# check for function declarations without arguments like "int foo()"
3457 if ($line =~ /(\b$Type\s+$Ident)\s*\(\s*\)/) {
3458 if (ERROR("FUNCTION_WITHOUT_ARGS",
3459 "Bad function definition - $1() should probably be $1(void)\n" . $herecurr) &&
3460 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07003461 $fixed[$fixlinenr] =~ s/(\b($Type)\s+($Ident))\s*\(\s*\)/$2 $3(void)/;
Joe Perchesb36190c2014-01-27 17:07:18 -08003462 }
3463 }
3464
Joe Perches92e112f2013-12-13 11:36:22 -07003465# check for uses of DEFINE_PCI_DEVICE_TABLE
3466 if ($line =~ /\bDEFINE_PCI_DEVICE_TABLE\s*\(\s*(\w+)\s*\)\s*=/) {
3467 if (WARN("DEFINE_PCI_DEVICE_TABLE",
3468 "Prefer struct pci_device_id over deprecated DEFINE_PCI_DEVICE_TABLE\n" . $herecurr) &&
3469 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07003470 $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 -07003471 }
Joe Perches93ed0e22010-10-26 14:23:21 -07003472 }
3473
Andy Whitcroft653d4872007-06-23 17:16:34 -07003474# check for new typedefs, only function parameters and sparse annotations
3475# make sense.
3476 if ($line =~ /\btypedef\s/ &&
Andy Whitcroft80545762009-01-06 14:41:26 -08003477 $line !~ /\btypedef\s+$Type\s*\(\s*\*?$Ident\s*\)\s*\(/ &&
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07003478 $line !~ /\btypedef\s+$Type\s+$Ident\s*\(/ &&
Andy Whitcroft8ed22ca2008-10-15 22:02:32 -07003479 $line !~ /\b$typeTypedefs\b/ &&
Andy Whitcroft653d4872007-06-23 17:16:34 -07003480 $line !~ /\b__bitwise(?:__|)\b/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003481 WARN("NEW_TYPEDEFS",
3482 "do not add new typedefs\n" . $herecurr);
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003483 }
3484
3485# * goes on variable not on type
Andy Whitcroft65863862009-01-06 14:41:21 -08003486 # (char*[ const])
Andy Whitcroftbfcb2cc2012-01-10 15:10:15 -08003487 while ($line =~ m{(\($NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)\))}g) {
3488 #print "AA<$1>\n";
Joe Perches3705ce52013-07-03 15:05:31 -07003489 my ($ident, $from, $to) = ($1, $2, $2);
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 }
Andy Whitcroftd8aaf122007-06-23 17:16:44 -07003498
Joe Perches3705ce52013-07-03 15:05:31 -07003499## print "1: from<$from> to<$to> ident<$ident>\n";
Andy Whitcroft65863862009-01-06 14:41:21 -08003500 if ($from ne $to) {
Joe Perches3705ce52013-07-03 15:05:31 -07003501 if (ERROR("POINTER_LOCATION",
3502 "\"(foo$from)\" should be \"(foo$to)\"\n" . $herecurr) &&
3503 $fix) {
3504 my $sub_from = $ident;
3505 my $sub_to = $ident;
3506 $sub_to =~ s/\Q$from\E/$to/;
Joe Perches194f66f2014-08-06 16:11:03 -07003507 $fixed[$fixlinenr] =~
Joe Perches3705ce52013-07-03 15:05:31 -07003508 s@\Q$sub_from\E@$sub_to@;
3509 }
Andy Whitcroft65863862009-01-06 14:41:21 -08003510 }
Andy Whitcroftbfcb2cc2012-01-10 15:10:15 -08003511 }
3512 while ($line =~ m{(\b$NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)($Ident))}g) {
3513 #print "BB<$1>\n";
Joe Perches3705ce52013-07-03 15:05:31 -07003514 my ($match, $from, $to, $ident) = ($1, $2, $2, $3);
Andy Whitcroftd8aaf122007-06-23 17:16:44 -07003515
Andy Whitcroft65863862009-01-06 14:41:21 -08003516 # Should start with a space.
3517 $to =~ s/^(\S)/ $1/;
3518 # Should not end with a space.
3519 $to =~ s/\s+$//;
3520 # '*'s should not have spaces between.
Andy Whitcroftf9a0b3d2009-01-15 13:51:05 -08003521 while ($to =~ s/\*\s+\*/\*\*/) {
Andy Whitcroft65863862009-01-06 14:41:21 -08003522 }
3523 # Modifiers should have spaces.
3524 $to =~ s/(\b$Modifier$)/$1 /;
3525
Joe Perches3705ce52013-07-03 15:05:31 -07003526## print "2: from<$from> to<$to> ident<$ident>\n";
Andy Whitcroft667026e2009-02-27 14:03:08 -08003527 if ($from ne $to && $ident !~ /^$Modifier$/) {
Joe Perches3705ce52013-07-03 15:05:31 -07003528 if (ERROR("POINTER_LOCATION",
3529 "\"foo${from}bar\" should be \"foo${to}bar\"\n" . $herecurr) &&
3530 $fix) {
3531
3532 my $sub_from = $match;
3533 my $sub_to = $match;
3534 $sub_to =~ s/\Q$from\E/$to/;
Joe Perches194f66f2014-08-06 16:11:03 -07003535 $fixed[$fixlinenr] =~
Joe Perches3705ce52013-07-03 15:05:31 -07003536 s@\Q$sub_from\E@$sub_to@;
3537 }
Andy Whitcroft65863862009-01-06 14:41:21 -08003538 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003539 }
3540
Joe Perches9d3e3c72015-09-09 15:37:27 -07003541# avoid BUG() or BUG_ON()
3542 if ($line =~ /\b(?:BUG|BUG_ON)\b/) {
3543 my $msg_type = \&WARN;
3544 $msg_type = \&CHK if ($file);
3545 &{$msg_type}("AVOID_BUG",
3546 "Avoid crashing the kernel - try using WARN_ON & recovery code rather than BUG() or BUG_ON()\n" . $herecurr);
3547 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003548
Joe Perches9d3e3c72015-09-09 15:37:27 -07003549# avoid LINUX_VERSION_CODE
Andy Whitcroft8905a672007-11-28 16:21:06 -08003550 if ($line =~ /\bLINUX_VERSION_CODE\b/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003551 WARN("LINUX_VERSION_CODE",
3552 "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 -08003553 }
3554
Joe Perches17441222011-06-15 15:08:17 -07003555# check for uses of printk_ratelimit
3556 if ($line =~ /\bprintk_ratelimit\s*\(/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003557 WARN("PRINTK_RATELIMITED",
Joe Perches101ee682015-02-13 14:38:54 -08003558 "Prefer printk_ratelimited or pr_<level>_ratelimited to printk_ratelimit\n" . $herecurr);
Joe Perches17441222011-06-15 15:08:17 -07003559 }
3560
Andy Whitcroft00df3442007-06-08 13:47:06 -07003561# printk should use KERN_* levels. Note that follow on printk's on the
3562# same line do not need a level, so we use the current block context
3563# to try and find and validate the current printk. In summary the current
Lucas De Marchi25985ed2011-03-30 22:57:33 -03003564# printk includes all preceding printk's which have no newline on the end.
Andy Whitcroft00df3442007-06-08 13:47:06 -07003565# we assume the first bad printk is the one to report.
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07003566 if ($line =~ /\bprintk\((?!KERN_)\s*"/) {
Andy Whitcroft00df3442007-06-08 13:47:06 -07003567 my $ok = 0;
3568 for (my $ln = $linenr - 1; $ln >= $first_line; $ln--) {
3569 #print "CHECK<$lines[$ln - 1]\n";
Lucas De Marchi25985ed2011-03-30 22:57:33 -03003570 # we have a preceding printk if it ends
Andy Whitcroft00df3442007-06-08 13:47:06 -07003571 # with "\n" ignore it, else it is to blame
3572 if ($lines[$ln - 1] =~ m{\bprintk\(}) {
3573 if ($rawlines[$ln - 1] !~ m{\\n"}) {
3574 $ok = 1;
3575 }
3576 last;
3577 }
3578 }
3579 if ($ok == 0) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003580 WARN("PRINTK_WITHOUT_KERN_LEVEL",
3581 "printk() should include KERN_ facility level\n" . $herecurr);
Andy Whitcroft00df3442007-06-08 13:47:06 -07003582 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003583 }
3584
Joe Perches243f3802012-05-31 16:26:09 -07003585 if ($line =~ /\bprintk\s*\(\s*KERN_([A-Z]+)/) {
3586 my $orig = $1;
3587 my $level = lc($orig);
3588 $level = "warn" if ($level eq "warning");
Joe Perches8f26b832012-10-04 17:13:32 -07003589 my $level2 = $level;
3590 $level2 = "dbg" if ($level eq "debug");
Joe Perches243f3802012-05-31 16:26:09 -07003591 WARN("PREFER_PR_LEVEL",
Yogesh Chaudharidaa8b052014-04-03 14:49:23 -07003592 "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 -07003593 }
3594
3595 if ($line =~ /\bpr_warning\s*\(/) {
Joe Perchesd5e616f2013-09-11 14:23:54 -07003596 if (WARN("PREFER_PR_LEVEL",
3597 "Prefer pr_warn(... to pr_warning(...\n" . $herecurr) &&
3598 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07003599 $fixed[$fixlinenr] =~
Joe Perchesd5e616f2013-09-11 14:23:54 -07003600 s/\bpr_warning\b/pr_warn/;
3601 }
Joe Perches243f3802012-05-31 16:26:09 -07003602 }
3603
Joe Perchesdc139312013-02-21 16:44:13 -08003604 if ($line =~ /\bdev_printk\s*\(\s*KERN_([A-Z]+)/) {
3605 my $orig = $1;
3606 my $level = lc($orig);
3607 $level = "warn" if ($level eq "warning");
3608 $level = "dbg" if ($level eq "debug");
3609 WARN("PREFER_DEV_LEVEL",
3610 "Prefer dev_$level(... to dev_printk(KERN_$orig, ...\n" . $herecurr);
3611 }
3612
Andy Lutomirski91c9afa2015-04-16 12:44:44 -07003613# ENOSYS means "bad syscall nr" and nothing else. This will have a small
3614# number of false positives, but assembly files are not checked, so at
3615# least the arch entry code will not trigger this warning.
3616 if ($line =~ /\bENOSYS\b/) {
3617 WARN("ENOSYS",
3618 "ENOSYS means 'invalid syscall nr' and nothing else\n" . $herecurr);
3619 }
3620
Andy Whitcroft653d4872007-06-23 17:16:34 -07003621# function brace can't be on same line, except for #defines of do while,
3622# or if closed on same line
Joe Perches8d182472014-08-06 16:11:12 -07003623 if (($line=~/$Type\s*$Ident\(.*\).*\s*{/) and
Eddie Kovsky4e5d56b2015-09-09 15:37:52 -07003624 !($line=~/\#\s*define.*do\s\{/) and !($line=~/}/)) {
Joe Perches8d182472014-08-06 16:11:12 -07003625 if (ERROR("OPEN_BRACE",
3626 "open brace '{' following function declarations go on the next line\n" . $herecurr) &&
3627 $fix) {
3628 fix_delete_line($fixlinenr, $rawline);
3629 my $fixed_line = $rawline;
3630 $fixed_line =~ /(^..*$Type\s*$Ident\(.*\)\s*){(.*)$/;
3631 my $line1 = $1;
3632 my $line2 = $2;
3633 fix_insert_line($fixlinenr, ltrim($line1));
3634 fix_insert_line($fixlinenr, "\+{");
3635 if ($line2 !~ /^\s*$/) {
3636 fix_insert_line($fixlinenr, "\+\t" . trim($line2));
3637 }
3638 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003639 }
Andy Whitcroft653d4872007-06-23 17:16:34 -07003640
Andy Whitcroft8905a672007-11-28 16:21:06 -08003641# open braces for enum, union and struct go on the same line.
3642 if ($line =~ /^.\s*{/ &&
3643 $prevline =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident)?\s*$/) {
Joe Perches8d182472014-08-06 16:11:12 -07003644 if (ERROR("OPEN_BRACE",
3645 "open brace '{' following $1 go on the same line\n" . $hereprev) &&
3646 $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
3647 fix_delete_line($fixlinenr - 1, $prevrawline);
3648 fix_delete_line($fixlinenr, $rawline);
3649 my $fixedline = rtrim($prevrawline) . " {";
3650 fix_insert_line($fixlinenr, $fixedline);
3651 $fixedline = $rawline;
3652 $fixedline =~ s/^(.\s*){\s*/$1\t/;
3653 if ($fixedline !~ /^\+\s*$/) {
3654 fix_insert_line($fixlinenr, $fixedline);
3655 }
3656 }
Andy Whitcroft8905a672007-11-28 16:21:06 -08003657 }
3658
Andy Whitcroft0c73b4e2010-10-26 14:23:15 -07003659# missing space after union, struct or enum definition
Joe Perches3705ce52013-07-03 15:05:31 -07003660 if ($line =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident){1,2}[=\{]/) {
3661 if (WARN("SPACING",
3662 "missing space after $1 definition\n" . $herecurr) &&
3663 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07003664 $fixed[$fixlinenr] =~
Joe Perches3705ce52013-07-03 15:05:31 -07003665 s/^(.\s*(?:typedef\s+)?(?:enum|union|struct)(?:\s+$Ident){1,2})([=\{])/$1 $2/;
3666 }
Andy Whitcroft0c73b4e2010-10-26 14:23:15 -07003667 }
3668
Joe Perches31070b52014-01-23 15:54:49 -08003669# Function pointer declarations
3670# check spacing between type, funcptr, and args
3671# canonical declaration is "type (*funcptr)(args...)"
Joe Perches91f72e92014-04-03 14:49:12 -07003672 if ($line =~ /^.\s*($Declare)\((\s*)\*(\s*)($Ident)(\s*)\)(\s*)\(/) {
Joe Perches31070b52014-01-23 15:54:49 -08003673 my $declare = $1;
3674 my $pre_pointer_space = $2;
3675 my $post_pointer_space = $3;
3676 my $funcname = $4;
3677 my $post_funcname_space = $5;
3678 my $pre_args_space = $6;
3679
Joe Perches91f72e92014-04-03 14:49:12 -07003680# the $Declare variable will capture all spaces after the type
3681# so check it for a missing trailing missing space but pointer return types
3682# don't need a space so don't warn for those.
3683 my $post_declare_space = "";
3684 if ($declare =~ /(\s+)$/) {
3685 $post_declare_space = $1;
3686 $declare = rtrim($declare);
3687 }
3688 if ($declare !~ /\*$/ && $post_declare_space =~ /^$/) {
Joe Perches31070b52014-01-23 15:54:49 -08003689 WARN("SPACING",
3690 "missing space after return type\n" . $herecurr);
Joe Perches91f72e92014-04-03 14:49:12 -07003691 $post_declare_space = " ";
Joe Perches31070b52014-01-23 15:54:49 -08003692 }
3693
3694# unnecessary space "type (*funcptr)(args...)"
Joe Perches91f72e92014-04-03 14:49:12 -07003695# This test is not currently implemented because these declarations are
3696# equivalent to
3697# int foo(int bar, ...)
3698# and this is form shouldn't/doesn't generate a checkpatch warning.
3699#
3700# elsif ($declare =~ /\s{2,}$/) {
3701# WARN("SPACING",
3702# "Multiple spaces after return type\n" . $herecurr);
3703# }
Joe Perches31070b52014-01-23 15:54:49 -08003704
3705# unnecessary space "type ( *funcptr)(args...)"
3706 if (defined $pre_pointer_space &&
3707 $pre_pointer_space =~ /^\s/) {
3708 WARN("SPACING",
3709 "Unnecessary space after function pointer open parenthesis\n" . $herecurr);
3710 }
3711
3712# unnecessary space "type (* funcptr)(args...)"
3713 if (defined $post_pointer_space &&
3714 $post_pointer_space =~ /^\s/) {
3715 WARN("SPACING",
3716 "Unnecessary space before function pointer name\n" . $herecurr);
3717 }
3718
3719# unnecessary space "type (*funcptr )(args...)"
3720 if (defined $post_funcname_space &&
3721 $post_funcname_space =~ /^\s/) {
3722 WARN("SPACING",
3723 "Unnecessary space after function pointer name\n" . $herecurr);
3724 }
3725
3726# unnecessary space "type (*funcptr) (args...)"
3727 if (defined $pre_args_space &&
3728 $pre_args_space =~ /^\s/) {
3729 WARN("SPACING",
3730 "Unnecessary space before function pointer arguments\n" . $herecurr);
3731 }
3732
3733 if (show_type("SPACING") && $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07003734 $fixed[$fixlinenr] =~
Joe Perches91f72e92014-04-03 14:49:12 -07003735 s/^(.\s*)$Declare\s*\(\s*\*\s*$Ident\s*\)\s*\(/$1 . $declare . $post_declare_space . '(*' . $funcname . ')('/ex;
Joe Perches31070b52014-01-23 15:54:49 -08003736 }
3737 }
3738
Andy Whitcroft8d31cfc2008-07-23 21:29:02 -07003739# check for spacing round square brackets; allowed:
3740# 1. with a type on the left -- int [] a;
Andy Whitcroftfe2a7db2008-10-15 22:02:15 -07003741# 2. at the beginning of a line for slice initialisers -- [0...10] = 5,
3742# 3. inside a curly brace -- = { [0...10] = 5 }
Andy Whitcroft8d31cfc2008-07-23 21:29:02 -07003743 while ($line =~ /(.*?\s)\[/g) {
3744 my ($where, $prefix) = ($-[1], $1);
3745 if ($prefix !~ /$Type\s+$/ &&
Andy Whitcroftfe2a7db2008-10-15 22:02:15 -07003746 ($where != 0 || $prefix !~ /^.\s+$/) &&
Andy Whitcroftdaebc532012-03-23 15:02:17 -07003747 $prefix !~ /[{,]\s+$/) {
Joe Perches3705ce52013-07-03 15:05:31 -07003748 if (ERROR("BRACKET_SPACE",
3749 "space prohibited before open square bracket '['\n" . $herecurr) &&
3750 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07003751 $fixed[$fixlinenr] =~
Joe Perches3705ce52013-07-03 15:05:31 -07003752 s/^(\+.*?)\s+\[/$1\[/;
3753 }
Andy Whitcroft8d31cfc2008-07-23 21:29:02 -07003754 }
3755 }
3756
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07003757# check for spaces between functions and their parentheses.
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07003758 while ($line =~ /($Ident)\s+\(/g) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08003759 my $name = $1;
Andy Whitcroft773647a2008-03-28 14:15:58 -07003760 my $ctx_before = substr($line, 0, $-[1]);
3761 my $ctx = "$ctx_before$name";
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08003762
3763 # Ignore those directives where spaces _are_ permitted.
Andy Whitcroft773647a2008-03-28 14:15:58 -07003764 if ($name =~ /^(?:
3765 if|for|while|switch|return|case|
3766 volatile|__volatile__|
3767 __attribute__|format|__extension__|
3768 asm|__asm__)$/x)
3769 {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08003770 # cpp #define statements have non-optional spaces, ie
3771 # if there is a space between the name and the open
3772 # parenthesis it is simply not a parameter group.
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07003773 } elsif ($ctx_before =~ /^.\s*\#\s*define\s*$/) {
Andy Whitcroft773647a2008-03-28 14:15:58 -07003774
3775 # cpp #elif statement condition may start with a (
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07003776 } elsif ($ctx =~ /^.\s*\#\s*elif\s*$/) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08003777
3778 # If this whole things ends with a type its most
3779 # likely a typedef for a function.
Andy Whitcroft773647a2008-03-28 14:15:58 -07003780 } elsif ($ctx =~ /$Type$/) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08003781
3782 } else {
Joe Perches3705ce52013-07-03 15:05:31 -07003783 if (WARN("SPACING",
3784 "space prohibited between function name and open parenthesis '('\n" . $herecurr) &&
3785 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07003786 $fixed[$fixlinenr] =~
Joe Perches3705ce52013-07-03 15:05:31 -07003787 s/\b$name\s+\(/$name\(/;
3788 }
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07003789 }
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07003790 }
Eric Nelson9a4cad42012-05-31 16:26:09 -07003791
Andy Whitcroft653d4872007-06-23 17:16:34 -07003792# Check operator spacing.
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003793 if (!($line=~/\#\s*include/)) {
Joe Perches3705ce52013-07-03 15:05:31 -07003794 my $fixed_line = "";
3795 my $line_fixed = 0;
3796
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07003797 my $ops = qr{
3798 <<=|>>=|<=|>=|==|!=|
3799 \+=|-=|\*=|\/=|%=|\^=|\|=|&=|
3800 =>|->|<<|>>|<|>|=|!|~|
Andy Whitcroft1f65f942008-07-23 21:29:10 -07003801 &&|\|\||,|\^|\+\+|--|&|\||\+|-|\*|\/|%|
Joe Perches84731622013-11-12 15:10:05 -08003802 \?:|\?|:
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07003803 }x;
Andy Whitcroftcf655042008-03-04 14:28:20 -08003804 my @elements = split(/($ops|;)/, $opline);
Joe Perches3705ce52013-07-03 15:05:31 -07003805
3806## print("element count: <" . $#elements . ">\n");
3807## foreach my $el (@elements) {
3808## print("el: <$el>\n");
3809## }
3810
3811 my @fix_elements = ();
Andy Whitcroft00df3442007-06-08 13:47:06 -07003812 my $off = 0;
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07003813
Joe Perches3705ce52013-07-03 15:05:31 -07003814 foreach my $el (@elements) {
3815 push(@fix_elements, substr($rawline, $off, length($el)));
3816 $off += length($el);
3817 }
3818
3819 $off = 0;
3820
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07003821 my $blank = copy_spacing($opline);
Joe Perchesb34c6482013-09-11 14:24:01 -07003822 my $last_after = -1;
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07003823
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003824 for (my $n = 0; $n < $#elements; $n += 2) {
Joe Perches3705ce52013-07-03 15:05:31 -07003825
3826 my $good = $fix_elements[$n] . $fix_elements[$n + 1];
3827
3828## print("n: <$n> good: <$good>\n");
3829
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07003830 $off += length($elements[$n]);
3831
Lucas De Marchi25985ed2011-03-30 22:57:33 -03003832 # Pick up the preceding and succeeding characters.
Andy Whitcroft773647a2008-03-28 14:15:58 -07003833 my $ca = substr($opline, 0, $off);
3834 my $cc = '';
3835 if (length($opline) >= ($off + length($elements[$n + 1]))) {
3836 $cc = substr($opline, $off + length($elements[$n + 1]));
3837 }
3838 my $cb = "$ca$;$cc";
3839
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07003840 my $a = '';
3841 $a = 'V' if ($elements[$n] ne '');
3842 $a = 'W' if ($elements[$n] =~ /\s$/);
Andy Whitcroftcf655042008-03-04 14:28:20 -08003843 $a = 'C' if ($elements[$n] =~ /$;$/);
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07003844 $a = 'B' if ($elements[$n] =~ /(\[|\()$/);
3845 $a = 'O' if ($elements[$n] eq '');
Andy Whitcroft773647a2008-03-28 14:15:58 -07003846 $a = 'E' if ($ca =~ /^\s*$/);
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07003847
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003848 my $op = $elements[$n + 1];
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07003849
3850 my $c = '';
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003851 if (defined $elements[$n + 2]) {
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07003852 $c = 'V' if ($elements[$n + 2] ne '');
3853 $c = 'W' if ($elements[$n + 2] =~ /^\s/);
Andy Whitcroftcf655042008-03-04 14:28:20 -08003854 $c = 'C' if ($elements[$n + 2] =~ /^$;/);
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07003855 $c = 'B' if ($elements[$n + 2] =~ /^(\)|\]|;)/);
3856 $c = 'O' if ($elements[$n + 2] eq '');
Andy Whitcroft8b1b3372009-01-06 14:41:27 -08003857 $c = 'E' if ($elements[$n + 2] =~ /^\s*\\$/);
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07003858 } else {
3859 $c = 'E';
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003860 }
3861
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07003862 my $ctx = "${a}x${c}";
3863
3864 my $at = "(ctx:$ctx)";
3865
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07003866 my $ptr = substr($blank, 0, $off) . "^";
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07003867 my $hereptr = "$hereline$ptr\n";
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003868
Andy Whitcroft74048ed2008-07-23 21:29:10 -07003869 # Pull out the value of this operator.
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07003870 my $op_type = substr($curr_values, $off + 1, 1);
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003871
Andy Whitcroft1f65f942008-07-23 21:29:10 -07003872 # Get the full operator variant.
3873 my $opv = $op . substr($curr_vars, $off, 1);
3874
Andy Whitcroft13214ad2008-02-08 04:22:03 -08003875 # Ignore operators passed as parameters.
3876 if ($op_type ne 'V' &&
Sam Bobroffd7fe8062015-04-16 12:44:39 -07003877 $ca =~ /\s$/ && $cc =~ /^\s*[,\)]/) {
Andy Whitcroft13214ad2008-02-08 04:22:03 -08003878
Andy Whitcroftcf655042008-03-04 14:28:20 -08003879# # Ignore comments
3880# } elsif ($op =~ /^$;+$/) {
Andy Whitcroft13214ad2008-02-08 04:22:03 -08003881
Andy Whitcroftd8aaf122007-06-23 17:16:44 -07003882 # ; should have either the end of line or a space or \ after it
Andy Whitcroft13214ad2008-02-08 04:22:03 -08003883 } elsif ($op eq ';') {
Andy Whitcroftcf655042008-03-04 14:28:20 -08003884 if ($ctx !~ /.x[WEBC]/ &&
3885 $cc !~ /^\\/ && $cc !~ /^;/) {
Joe Perches3705ce52013-07-03 15:05:31 -07003886 if (ERROR("SPACING",
3887 "space required after that '$op' $at\n" . $hereptr)) {
Joe Perchesb34c6482013-09-11 14:24:01 -07003888 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";
Joe Perches3705ce52013-07-03 15:05:31 -07003889 $line_fixed = 1;
3890 }
Andy Whitcroftd8aaf122007-06-23 17:16:44 -07003891 }
3892
3893 # // is a comment
3894 } elsif ($op eq '//') {
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003895
Joe Perchesb00e4812014-04-03 14:49:33 -07003896 # : when part of a bitfield
3897 } elsif ($opv eq ':B') {
3898 # skip the bitfield test for now
3899
Andy Whitcroft1f65f942008-07-23 21:29:10 -07003900 # No spaces for:
3901 # ->
Joe Perchesb00e4812014-04-03 14:49:33 -07003902 } elsif ($op eq '->') {
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07003903 if ($ctx =~ /Wx.|.xW/) {
Joe Perches3705ce52013-07-03 15:05:31 -07003904 if (ERROR("SPACING",
3905 "spaces prohibited around that '$op' $at\n" . $hereptr)) {
Joe Perchesb34c6482013-09-11 14:24:01 -07003906 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
Joe Perches3705ce52013-07-03 15:05:31 -07003907 if (defined $fix_elements[$n + 2]) {
3908 $fix_elements[$n + 2] =~ s/^\s+//;
3909 }
Joe Perchesb34c6482013-09-11 14:24:01 -07003910 $line_fixed = 1;
Joe Perches3705ce52013-07-03 15:05:31 -07003911 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003912 }
3913
Joe Perches23810972014-12-10 15:51:32 -08003914 # , must not have a space before and must have a space on the right.
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003915 } elsif ($op eq ',') {
Joe Perches23810972014-12-10 15:51:32 -08003916 my $rtrim_before = 0;
3917 my $space_after = 0;
3918 if ($ctx =~ /Wx./) {
3919 if (ERROR("SPACING",
3920 "space prohibited before that '$op' $at\n" . $hereptr)) {
3921 $line_fixed = 1;
3922 $rtrim_before = 1;
3923 }
3924 }
Andy Whitcroftcf655042008-03-04 14:28:20 -08003925 if ($ctx !~ /.x[WEC]/ && $cc !~ /^}/) {
Joe Perches3705ce52013-07-03 15:05:31 -07003926 if (ERROR("SPACING",
3927 "space required after that '$op' $at\n" . $hereptr)) {
Joe Perches3705ce52013-07-03 15:05:31 -07003928 $line_fixed = 1;
Joe Perchesb34c6482013-09-11 14:24:01 -07003929 $last_after = $n;
Joe Perches23810972014-12-10 15:51:32 -08003930 $space_after = 1;
3931 }
3932 }
3933 if ($rtrim_before || $space_after) {
3934 if ($rtrim_before) {
3935 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
3936 } else {
3937 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]);
3938 }
3939 if ($space_after) {
3940 $good .= " ";
Joe Perches3705ce52013-07-03 15:05:31 -07003941 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003942 }
3943
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07003944 # '*' as part of a type definition -- reported already.
Andy Whitcroft74048ed2008-07-23 21:29:10 -07003945 } elsif ($opv eq '*_') {
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07003946 #warn "'*' is part of type\n";
3947
3948 # unary operators should have a space before and
3949 # none after. May be left adjacent to another
3950 # unary operator, or a cast
3951 } elsif ($op eq '!' || $op eq '~' ||
Andy Whitcroft74048ed2008-07-23 21:29:10 -07003952 $opv eq '*U' || $opv eq '-U' ||
Andy Whitcroft0d413862008-10-15 22:02:16 -07003953 $opv eq '&U' || $opv eq '&&U') {
Andy Whitcroftcf655042008-03-04 14:28:20 -08003954 if ($ctx !~ /[WEBC]x./ && $ca !~ /(?:\)|!|~|\*|-|\&|\||\+\+|\-\-|\{)$/) {
Joe Perches3705ce52013-07-03 15:05:31 -07003955 if (ERROR("SPACING",
3956 "space required before that '$op' $at\n" . $hereptr)) {
Joe Perchesb34c6482013-09-11 14:24:01 -07003957 if ($n != $last_after + 2) {
3958 $good = $fix_elements[$n] . " " . ltrim($fix_elements[$n + 1]);
3959 $line_fixed = 1;
3960 }
Joe Perches3705ce52013-07-03 15:05:31 -07003961 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003962 }
Andy Whitcrofta3340b32009-02-27 14:03:07 -08003963 if ($op eq '*' && $cc =~/\s*$Modifier\b/) {
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07003964 # A unary '*' may be const
3965
3966 } elsif ($ctx =~ /.xW/) {
Joe Perches3705ce52013-07-03 15:05:31 -07003967 if (ERROR("SPACING",
3968 "space prohibited after that '$op' $at\n" . $hereptr)) {
Joe Perchesb34c6482013-09-11 14:24:01 -07003969 $good = $fix_elements[$n] . rtrim($fix_elements[$n + 1]);
Joe Perches3705ce52013-07-03 15:05:31 -07003970 if (defined $fix_elements[$n + 2]) {
3971 $fix_elements[$n + 2] =~ s/^\s+//;
3972 }
Joe Perchesb34c6482013-09-11 14:24:01 -07003973 $line_fixed = 1;
Joe Perches3705ce52013-07-03 15:05:31 -07003974 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003975 }
3976
3977 # unary ++ and unary -- are allowed no space on one side.
3978 } elsif ($op eq '++' or $op eq '--') {
Andy Whitcroft773647a2008-03-28 14:15:58 -07003979 if ($ctx !~ /[WEOBC]x[^W]/ && $ctx !~ /[^W]x[WOBEC]/) {
Joe Perches3705ce52013-07-03 15:05:31 -07003980 if (ERROR("SPACING",
3981 "space required one side of that '$op' $at\n" . $hereptr)) {
Joe Perchesb34c6482013-09-11 14:24:01 -07003982 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";
Joe Perches3705ce52013-07-03 15:05:31 -07003983 $line_fixed = 1;
3984 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003985 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07003986 if ($ctx =~ /Wx[BE]/ ||
3987 ($ctx =~ /Wx./ && $cc =~ /^;/)) {
Joe Perches3705ce52013-07-03 15:05:31 -07003988 if (ERROR("SPACING",
3989 "space prohibited before that '$op' $at\n" . $hereptr)) {
Joe Perchesb34c6482013-09-11 14:24:01 -07003990 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
Joe Perches3705ce52013-07-03 15:05:31 -07003991 $line_fixed = 1;
3992 }
Andy Whitcroft653d4872007-06-23 17:16:34 -07003993 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07003994 if ($ctx =~ /ExW/) {
Joe Perches3705ce52013-07-03 15:05:31 -07003995 if (ERROR("SPACING",
3996 "space prohibited after that '$op' $at\n" . $hereptr)) {
Joe Perchesb34c6482013-09-11 14:24:01 -07003997 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]);
Joe Perches3705ce52013-07-03 15:05:31 -07003998 if (defined $fix_elements[$n + 2]) {
3999 $fix_elements[$n + 2] =~ s/^\s+//;
4000 }
Joe Perchesb34c6482013-09-11 14:24:01 -07004001 $line_fixed = 1;
Joe Perches3705ce52013-07-03 15:05:31 -07004002 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07004003 }
4004
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004005 # << and >> may either have or not have spaces both sides
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07004006 } elsif ($op eq '<<' or $op eq '>>' or
4007 $op eq '&' or $op eq '^' or $op eq '|' or
4008 $op eq '+' or $op eq '-' or
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08004009 $op eq '*' or $op eq '/' or
4010 $op eq '%')
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004011 {
Joe Perchesd2e025f2015-02-13 14:38:57 -08004012 if ($check) {
4013 if (defined $fix_elements[$n + 2] && $ctx !~ /[EW]x[EW]/) {
4014 if (CHK("SPACING",
4015 "spaces preferred around that '$op' $at\n" . $hereptr)) {
4016 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
4017 $fix_elements[$n + 2] =~ s/^\s+//;
4018 $line_fixed = 1;
4019 }
4020 } elsif (!defined $fix_elements[$n + 2] && $ctx !~ /Wx[OE]/) {
4021 if (CHK("SPACING",
4022 "space preferred before that '$op' $at\n" . $hereptr)) {
4023 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]);
4024 $line_fixed = 1;
4025 }
4026 }
4027 } elsif ($ctx =~ /Wx[^WCE]|[^WCE]xW/) {
Joe Perches3705ce52013-07-03 15:05:31 -07004028 if (ERROR("SPACING",
4029 "need consistent spacing around '$op' $at\n" . $hereptr)) {
Joe Perchesb34c6482013-09-11 14:24:01 -07004030 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
4031 if (defined $fix_elements[$n + 2]) {
4032 $fix_elements[$n + 2] =~ s/^\s+//;
4033 }
Joe Perches3705ce52013-07-03 15:05:31 -07004034 $line_fixed = 1;
4035 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004036 }
4037
Andy Whitcroft1f65f942008-07-23 21:29:10 -07004038 # A colon needs no spaces before when it is
4039 # terminating a case value or a label.
4040 } elsif ($opv eq ':C' || $opv eq ':L') {
4041 if ($ctx =~ /Wx./) {
Joe Perches3705ce52013-07-03 15:05:31 -07004042 if (ERROR("SPACING",
4043 "space prohibited before that '$op' $at\n" . $hereptr)) {
Joe Perchesb34c6482013-09-11 14:24:01 -07004044 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
Joe Perches3705ce52013-07-03 15:05:31 -07004045 $line_fixed = 1;
4046 }
Andy Whitcroft1f65f942008-07-23 21:29:10 -07004047 }
4048
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004049 # All the others need spaces both sides.
Andy Whitcroftcf655042008-03-04 14:28:20 -08004050 } elsif ($ctx !~ /[EWC]x[CWE]/) {
Andy Whitcroft1f65f942008-07-23 21:29:10 -07004051 my $ok = 0;
4052
Andy Whitcroft22f2a2e2007-08-10 13:01:03 -07004053 # Ignore email addresses <foo@bar>
Andy Whitcroft1f65f942008-07-23 21:29:10 -07004054 if (($op eq '<' &&
4055 $cc =~ /^\S+\@\S+>/) ||
4056 ($op eq '>' &&
4057 $ca =~ /<\S+\@\S+$/))
4058 {
4059 $ok = 1;
4060 }
4061
Joe Perchese0df7e12015-04-16 12:44:53 -07004062 # for asm volatile statements
4063 # ignore a colon with another
4064 # colon immediately before or after
4065 if (($op eq ':') &&
4066 ($ca =~ /:$/ || $cc =~ /^:/)) {
4067 $ok = 1;
4068 }
4069
Joe Perches84731622013-11-12 15:10:05 -08004070 # messages are ERROR, but ?: are CHK
Andy Whitcroft1f65f942008-07-23 21:29:10 -07004071 if ($ok == 0) {
Joe Perches84731622013-11-12 15:10:05 -08004072 my $msg_type = \&ERROR;
4073 $msg_type = \&CHK if (($op eq '?:' || $op eq '?' || $op eq ':') && $ctx =~ /VxV/);
4074
4075 if (&{$msg_type}("SPACING",
4076 "spaces required around that '$op' $at\n" . $hereptr)) {
Joe Perchesb34c6482013-09-11 14:24:01 -07004077 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
4078 if (defined $fix_elements[$n + 2]) {
4079 $fix_elements[$n + 2] =~ s/^\s+//;
4080 }
Joe Perches3705ce52013-07-03 15:05:31 -07004081 $line_fixed = 1;
4082 }
Andy Whitcroft22f2a2e2007-08-10 13:01:03 -07004083 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004084 }
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07004085 $off += length($elements[$n + 1]);
Joe Perches3705ce52013-07-03 15:05:31 -07004086
4087## print("n: <$n> GOOD: <$good>\n");
4088
4089 $fixed_line = $fixed_line . $good;
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004090 }
Joe Perches3705ce52013-07-03 15:05:31 -07004091
4092 if (($#elements % 2) == 0) {
4093 $fixed_line = $fixed_line . $fix_elements[$#elements];
4094 }
4095
Joe Perches194f66f2014-08-06 16:11:03 -07004096 if ($fix && $line_fixed && $fixed_line ne $fixed[$fixlinenr]) {
4097 $fixed[$fixlinenr] = $fixed_line;
Joe Perches3705ce52013-07-03 15:05:31 -07004098 }
4099
4100
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004101 }
4102
Joe Perches786b6322013-07-03 15:05:32 -07004103# check for whitespace before a non-naked semicolon
Joe Perchesd2e248e2014-01-23 15:54:41 -08004104 if ($line =~ /^\+.*\S\s+;\s*$/) {
Joe Perches786b6322013-07-03 15:05:32 -07004105 if (WARN("SPACING",
4106 "space prohibited before semicolon\n" . $herecurr) &&
4107 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07004108 1 while $fixed[$fixlinenr] =~
Joe Perches786b6322013-07-03 15:05:32 -07004109 s/^(\+.*\S)\s+;/$1;/;
4110 }
4111 }
4112
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07004113# check for multiple assignments
4114 if ($line =~ /^.\s*$Lval\s*=\s*$Lval\s*=(?!=)/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07004115 CHK("MULTIPLE_ASSIGNMENTS",
4116 "multiple assignments should be avoided\n" . $herecurr);
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07004117 }
4118
Andy Whitcroft22f2a2e2007-08-10 13:01:03 -07004119## # check for multiple declarations, allowing for a function declaration
4120## # continuation.
4121## if ($line =~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Ident.*/ &&
4122## $line !~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Type\s*$Ident.*/) {
4123##
4124## # Remove any bracketed sections to ensure we do not
4125## # falsly report the parameters of functions.
4126## my $ln = $line;
4127## while ($ln =~ s/\([^\(\)]*\)//g) {
4128## }
4129## if ($ln =~ /,/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07004130## WARN("MULTIPLE_DECLARATION",
4131## "declaring multiple variables together should be avoided\n" . $herecurr);
Andy Whitcroft22f2a2e2007-08-10 13:01:03 -07004132## }
4133## }
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07004134
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004135#need space before brace following if, while, etc
Geyslan G. Bem6b8c69e2016-03-15 14:58:09 -07004136 if (($line =~ /\(.*\)\{/ && $line !~ /\($Type\)\{/) ||
Eddie Kovsky4e5d56b2015-09-09 15:37:52 -07004137 $line =~ /do\{/) {
Joe Perches3705ce52013-07-03 15:05:31 -07004138 if (ERROR("SPACING",
4139 "space required before the open brace '{'\n" . $herecurr) &&
4140 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07004141 $fixed[$fixlinenr] =~ s/^(\+.*(?:do|\))){/$1 {/;
Joe Perches3705ce52013-07-03 15:05:31 -07004142 }
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07004143 }
4144
Joe Perchesc4a62ef2013-07-03 15:05:28 -07004145## # check for blank lines before declarations
4146## if ($line =~ /^.\t+$Type\s+$Ident(?:\s*=.*)?;/ &&
4147## $prevrawline =~ /^.\s*$/) {
4148## WARN("SPACING",
4149## "No blank lines before declarations\n" . $hereprev);
4150## }
4151##
4152
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07004153# closing brace should have a space following it when it has anything
4154# on the line
4155 if ($line =~ /}(?!(?:,|;|\)))\S/) {
Joe Perchesd5e616f2013-09-11 14:23:54 -07004156 if (ERROR("SPACING",
4157 "space required after that close brace '}'\n" . $herecurr) &&
4158 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07004159 $fixed[$fixlinenr] =~
Joe Perchesd5e616f2013-09-11 14:23:54 -07004160 s/}((?!(?:,|;|\)))\S)/} $1/;
4161 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004162 }
4163
Andy Whitcroft22f2a2e2007-08-10 13:01:03 -07004164# check spacing on square brackets
4165 if ($line =~ /\[\s/ && $line !~ /\[\s*$/) {
Joe Perches3705ce52013-07-03 15:05:31 -07004166 if (ERROR("SPACING",
4167 "space prohibited after that open square bracket '['\n" . $herecurr) &&
4168 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07004169 $fixed[$fixlinenr] =~
Joe Perches3705ce52013-07-03 15:05:31 -07004170 s/\[\s+/\[/;
4171 }
Andy Whitcroft22f2a2e2007-08-10 13:01:03 -07004172 }
4173 if ($line =~ /\s\]/) {
Joe Perches3705ce52013-07-03 15:05:31 -07004174 if (ERROR("SPACING",
4175 "space prohibited before that close square bracket ']'\n" . $herecurr) &&
4176 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07004177 $fixed[$fixlinenr] =~
Joe Perches3705ce52013-07-03 15:05:31 -07004178 s/\s+\]/\]/;
4179 }
Andy Whitcroft22f2a2e2007-08-10 13:01:03 -07004180 }
4181
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004182# check spacing on parentheses
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07004183 if ($line =~ /\(\s/ && $line !~ /\(\s*(?:\\)?$/ &&
4184 $line !~ /for\s*\(\s+;/) {
Joe Perches3705ce52013-07-03 15:05:31 -07004185 if (ERROR("SPACING",
4186 "space prohibited after that open parenthesis '('\n" . $herecurr) &&
4187 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07004188 $fixed[$fixlinenr] =~
Joe Perches3705ce52013-07-03 15:05:31 -07004189 s/\(\s+/\(/;
4190 }
Andy Whitcroft22f2a2e2007-08-10 13:01:03 -07004191 }
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004192 if ($line =~ /(\s+)\)/ && $line !~ /^.\s*\)/ &&
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004193 $line !~ /for\s*\(.*;\s+\)/ &&
4194 $line !~ /:\s+\)/) {
Joe Perches3705ce52013-07-03 15:05:31 -07004195 if (ERROR("SPACING",
4196 "space prohibited before that close parenthesis ')'\n" . $herecurr) &&
4197 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07004198 $fixed[$fixlinenr] =~
Joe Perches3705ce52013-07-03 15:05:31 -07004199 s/\s+\)/\)/;
4200 }
Andy Whitcroft22f2a2e2007-08-10 13:01:03 -07004201 }
4202
Joe Perchese2826fd2014-08-06 16:10:48 -07004203# check unnecessary parentheses around addressof/dereference single $Lvals
4204# ie: &(foo->bar) should be &foo->bar and *(foo->bar) should be *foo->bar
4205
4206 while ($line =~ /(?:[^&]&\s*|\*)\(\s*($Ident\s*(?:$Member\s*)+)\s*\)/g) {
Joe Perchesea4acbb2014-12-10 15:51:51 -08004207 my $var = $1;
4208 if (CHK("UNNECESSARY_PARENTHESES",
4209 "Unnecessary parentheses around $var\n" . $herecurr) &&
4210 $fix) {
4211 $fixed[$fixlinenr] =~ s/\(\s*\Q$var\E\s*\)/$var/;
4212 }
4213 }
4214
4215# check for unnecessary parentheses around function pointer uses
4216# ie: (foo->bar)(); should be foo->bar();
4217# but not "if (foo->bar) (" to avoid some false positives
4218 if ($line =~ /(\bif\s*|)(\(\s*$Ident\s*(?:$Member\s*)+\))[ \t]*\(/ && $1 !~ /^if/) {
4219 my $var = $2;
4220 if (CHK("UNNECESSARY_PARENTHESES",
4221 "Unnecessary parentheses around function pointer $var\n" . $herecurr) &&
4222 $fix) {
4223 my $var2 = deparenthesize($var);
4224 $var2 =~ s/\s//g;
4225 $fixed[$fixlinenr] =~ s/\Q$var\E/$var2/;
4226 }
4227 }
Joe Perchese2826fd2014-08-06 16:10:48 -07004228
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004229#goto labels aren't indented, allow a single space however
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07004230 if ($line=~/^.\s+[A-Za-z\d_]+:(?![0-9]+)/ and
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004231 !($line=~/^. [A-Za-z\d_]+:/) and !($line=~/^.\s+default:/)) {
Joe Perches3705ce52013-07-03 15:05:31 -07004232 if (WARN("INDENTED_LABEL",
4233 "labels should not be indented\n" . $herecurr) &&
4234 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07004235 $fixed[$fixlinenr] =~
Joe Perches3705ce52013-07-03 15:05:31 -07004236 s/^(.)\s+/$1/;
4237 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004238 }
4239
Joe Perches5b9553a2014-04-03 14:49:21 -07004240# return is not a function
Joe Perches507e5142013-11-12 15:10:13 -08004241 if (defined($stat) && $stat =~ /^.\s*return(\s*)\(/s) {
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004242 my $spacing = $1;
Joe Perches507e5142013-11-12 15:10:13 -08004243 if ($^V && $^V ge 5.10.0 &&
Joe Perches5b9553a2014-04-03 14:49:21 -07004244 $stat =~ /^.\s*return\s*($balanced_parens)\s*;\s*$/) {
4245 my $value = $1;
4246 $value = deparenthesize($value);
4247 if ($value =~ m/^\s*$FuncArg\s*(?:\?|$)/) {
4248 ERROR("RETURN_PARENTHESES",
4249 "return is not a function, parentheses are not required\n" . $herecurr);
4250 }
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004251 } elsif ($spacing !~ /\s+/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07004252 ERROR("SPACING",
4253 "space required before the open parenthesis '('\n" . $herecurr);
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004254 }
4255 }
Joe Perches507e5142013-11-12 15:10:13 -08004256
Joe Perchesb43ae212014-06-23 13:22:07 -07004257# unnecessary return in a void function
4258# at end-of-function, with the previous line a single leading tab, then return;
4259# and the line before that not a goto label target like "out:"
4260 if ($sline =~ /^[ \+]}\s*$/ &&
4261 $prevline =~ /^\+\treturn\s*;\s*$/ &&
4262 $linenr >= 3 &&
4263 $lines[$linenr - 3] =~ /^[ +]/ &&
4264 $lines[$linenr - 3] !~ /^[ +]\s*$Ident\s*:/) {
Joe Perches9819cf22014-06-04 16:12:09 -07004265 WARN("RETURN_VOID",
Joe Perchesb43ae212014-06-23 13:22:07 -07004266 "void function return statements are not generally useful\n" . $hereprev);
4267 }
Joe Perches9819cf22014-06-04 16:12:09 -07004268
Joe Perches189248d2014-01-23 15:54:47 -08004269# if statements using unnecessary parentheses - ie: if ((foo == bar))
4270 if ($^V && $^V ge 5.10.0 &&
4271 $line =~ /\bif\s*((?:\(\s*){2,})/) {
4272 my $openparens = $1;
4273 my $count = $openparens =~ tr@\(@\(@;
4274 my $msg = "";
4275 if ($line =~ /\bif\s*(?:\(\s*){$count,$count}$LvalOrFunc\s*($Compare)\s*$LvalOrFunc(?:\s*\)){$count,$count}/) {
4276 my $comp = $4; #Not $1 because of $LvalOrFunc
4277 $msg = " - maybe == should be = ?" if ($comp eq "==");
4278 WARN("UNNECESSARY_PARENTHESES",
4279 "Unnecessary parentheses$msg\n" . $herecurr);
4280 }
4281 }
4282
Joe Perchesc5595fa2015-09-09 15:37:58 -07004283# comparisons with a constant or upper case identifier on the left
4284# avoid cases like "foo + BAR < baz"
4285# only fix matches surrounded by parentheses to avoid incorrect
4286# conversions like "FOO < baz() + 5" being "misfixed" to "baz() > FOO + 5"
4287 if ($^V && $^V ge 5.10.0 &&
4288 $line =~ /^\+(.*)\b($Constant|[A-Z_][A-Z0-9_]*)\s*($Compare)\s*($LvalOrFunc)/) {
4289 my $lead = $1;
4290 my $const = $2;
4291 my $comp = $3;
4292 my $to = $4;
4293 my $newcomp = $comp;
4294 if ($lead !~ /$Operators\s*$/ &&
4295 $to !~ /^(?:Constant|[A-Z_][A-Z0-9_]*)$/ &&
4296 WARN("CONSTANT_COMPARISON",
4297 "Comparisons should place the constant on the right side of the test\n" . $herecurr) &&
4298 $fix) {
4299 if ($comp eq "<") {
4300 $newcomp = ">";
4301 } elsif ($comp eq "<=") {
4302 $newcomp = ">=";
4303 } elsif ($comp eq ">") {
4304 $newcomp = "<";
4305 } elsif ($comp eq ">=") {
4306 $newcomp = "<=";
4307 }
4308 $fixed[$fixlinenr] =~ s/\(\s*\Q$const\E\s*$Compare\s*\Q$to\E\s*\)/($to $newcomp $const)/;
4309 }
4310 }
4311
Joe Perchesf34e4a42015-04-16 12:44:19 -07004312# Return of what appears to be an errno should normally be negative
4313 if ($sline =~ /\breturn(?:\s*\(+\s*|\s+)(E[A-Z]+)(?:\s*\)+\s*|\s*)[;:,]/) {
Andy Whitcroft53a3c442010-10-26 14:23:14 -07004314 my $name = $1;
4315 if ($name ne 'EOF' && $name ne 'ERROR') {
Joe Perches000d1cc12011-07-25 17:13:25 -07004316 WARN("USE_NEGATIVE_ERRNO",
Joe Perchesf34e4a42015-04-16 12:44:19 -07004317 "return of an errno should typically be negative (ie: return -$1)\n" . $herecurr);
Andy Whitcroft53a3c442010-10-26 14:23:14 -07004318 }
4319 }
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004320
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004321# Need a space before open parenthesis after if, while etc
Joe Perches3705ce52013-07-03 15:05:31 -07004322 if ($line =~ /\b(if|while|for|switch)\(/) {
4323 if (ERROR("SPACING",
4324 "space required before the open parenthesis '('\n" . $herecurr) &&
4325 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07004326 $fixed[$fixlinenr] =~
Joe Perches3705ce52013-07-03 15:05:31 -07004327 s/\b(if|while|for|switch)\(/$1 \(/;
4328 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004329 }
4330
Andy Whitcroftf5fe35d2008-07-23 21:29:03 -07004331# Check for illegal assignment in if conditional -- and check for trailing
4332# statements after the conditional.
Andy Whitcroft170d3a22008-10-15 22:02:30 -07004333 if ($line =~ /do\s*(?!{)/) {
Andy Whitcroft3e469cd2012-01-10 15:10:01 -08004334 ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
4335 ctx_statement_block($linenr, $realcnt, 0)
4336 if (!defined $stat);
Andy Whitcroft170d3a22008-10-15 22:02:30 -07004337 my ($stat_next) = ctx_statement_block($line_nr_next,
4338 $remain_next, $off_next);
4339 $stat_next =~ s/\n./\n /g;
4340 ##print "stat<$stat> stat_next<$stat_next>\n";
4341
4342 if ($stat_next =~ /^\s*while\b/) {
4343 # If the statement carries leading newlines,
4344 # then count those as offsets.
4345 my ($whitespace) =
4346 ($stat_next =~ /^((?:\s*\n[+-])*\s*)/s);
4347 my $offset =
4348 statement_rawlines($whitespace) - 1;
4349
4350 $suppress_whiletrailers{$line_nr_next +
4351 $offset} = 1;
4352 }
4353 }
4354 if (!defined $suppress_whiletrailers{$linenr} &&
Joe Perchesc11230f2013-11-21 14:31:57 -08004355 defined($stat) && defined($cond) &&
Andy Whitcroft170d3a22008-10-15 22:02:30 -07004356 $line =~ /\b(?:if|while|for)\s*\(/ && $line !~ /^.\s*#/) {
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07004357 my ($s, $c) = ($stat, $cond);
Andy Whitcroft8905a672007-11-28 16:21:06 -08004358
Andy Whitcroftb53c8e12009-01-06 14:41:29 -08004359 if ($c =~ /\bif\s*\(.*[^<>!=]=[^=].*/s) {
Joe Perches000d1cc12011-07-25 17:13:25 -07004360 ERROR("ASSIGN_IN_IF",
4361 "do not use assignment in if condition\n" . $herecurr);
Andy Whitcroft8905a672007-11-28 16:21:06 -08004362 }
4363
4364 # Find out what is on the end of the line after the
4365 # conditional.
Andy Whitcroft773647a2008-03-28 14:15:58 -07004366 substr($s, 0, length($c), '');
Andy Whitcroft8905a672007-11-28 16:21:06 -08004367 $s =~ s/\n.*//g;
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004368 $s =~ s/$;//g; # Remove any comments
Andy Whitcroft53210162008-07-23 21:29:03 -07004369 if (length($c) && $s !~ /^\s*{?\s*\\*\s*$/ &&
4370 $c !~ /}\s*while\s*/)
Andy Whitcroft773647a2008-03-28 14:15:58 -07004371 {
Andy Whitcroftbb44ad32008-10-15 22:02:34 -07004372 # Find out how long the conditional actually is.
4373 my @newlines = ($c =~ /\n/gs);
4374 my $cond_lines = 1 + $#newlines;
Hidetoshi Seto42bdf742010-03-05 13:43:50 -08004375 my $stat_real = '';
Andy Whitcroftbb44ad32008-10-15 22:02:34 -07004376
Hidetoshi Seto42bdf742010-03-05 13:43:50 -08004377 $stat_real = raw_line($linenr, $cond_lines)
4378 . "\n" if ($cond_lines);
Andy Whitcroftbb44ad32008-10-15 22:02:34 -07004379 if (defined($stat_real) && $cond_lines > 1) {
4380 $stat_real = "[...]\n$stat_real";
4381 }
4382
Joe Perches000d1cc12011-07-25 17:13:25 -07004383 ERROR("TRAILING_STATEMENTS",
4384 "trailing statements should be on next line\n" . $herecurr . $stat_real);
Andy Whitcroft8905a672007-11-28 16:21:06 -08004385 }
4386 }
4387
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004388# Check for bitwise tests written as boolean
4389 if ($line =~ /
4390 (?:
4391 (?:\[|\(|\&\&|\|\|)
4392 \s*0[xX][0-9]+\s*
4393 (?:\&\&|\|\|)
4394 |
4395 (?:\&\&|\|\|)
4396 \s*0[xX][0-9]+\s*
4397 (?:\&\&|\|\||\)|\])
4398 )/x)
4399 {
Joe Perches000d1cc12011-07-25 17:13:25 -07004400 WARN("HEXADECIMAL_BOOLEAN_TEST",
4401 "boolean test with hexadecimal, perhaps just 1 \& or \|?\n" . $herecurr);
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004402 }
4403
Andy Whitcroft8905a672007-11-28 16:21:06 -08004404# if and else should not have general statements after it
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004405 if ($line =~ /^.\s*(?:}\s*)?else\b(.*)/) {
4406 my $s = $1;
4407 $s =~ s/$;//g; # Remove any comments
4408 if ($s !~ /^\s*(?:\sif|(?:{|)\s*\\?\s*$)/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07004409 ERROR("TRAILING_STATEMENTS",
4410 "trailing statements should be on next line\n" . $herecurr);
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004411 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004412 }
Andy Whitcroft39667782009-01-15 13:51:06 -08004413# if should not continue a brace
4414 if ($line =~ /}\s*if\b/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07004415 ERROR("TRAILING_STATEMENTS",
Rasmus Villemoes048b1232014-08-06 16:10:37 -07004416 "trailing statements should be on next line (or did you mean 'else if'?)\n" .
Andy Whitcroft39667782009-01-15 13:51:06 -08004417 $herecurr);
4418 }
Andy Whitcrofta1080bf2008-10-15 22:02:25 -07004419# case and default should not have general statements after them
4420 if ($line =~ /^.\s*(?:case\s*.*|default\s*):/g &&
4421 $line !~ /\G(?:
Andy Whitcroft3fef12d2008-10-15 22:02:36 -07004422 (?:\s*$;*)(?:\s*{)?(?:\s*$;*)(?:\s*\\)?\s*$|
Andy Whitcrofta1080bf2008-10-15 22:02:25 -07004423 \s*return\s+
4424 )/xg)
4425 {
Joe Perches000d1cc12011-07-25 17:13:25 -07004426 ERROR("TRAILING_STATEMENTS",
4427 "trailing statements should be on next line\n" . $herecurr);
Andy Whitcrofta1080bf2008-10-15 22:02:25 -07004428 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004429
4430 # Check for }<nl>else {, these must be at the same
4431 # indent level to be relevant to each other.
Joe Perches8b8856f2014-08-06 16:11:14 -07004432 if ($prevline=~/}\s*$/ and $line=~/^.\s*else\s*/ &&
4433 $previndent == $indent) {
4434 if (ERROR("ELSE_AFTER_BRACE",
4435 "else should follow close brace '}'\n" . $hereprev) &&
4436 $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
4437 fix_delete_line($fixlinenr - 1, $prevrawline);
4438 fix_delete_line($fixlinenr, $rawline);
4439 my $fixedline = $prevrawline;
4440 $fixedline =~ s/}\s*$//;
4441 if ($fixedline !~ /^\+\s*$/) {
4442 fix_insert_line($fixlinenr, $fixedline);
4443 }
4444 $fixedline = $rawline;
4445 $fixedline =~ s/^(.\s*)else/$1} else/;
4446 fix_insert_line($fixlinenr, $fixedline);
4447 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004448 }
4449
Joe Perches8b8856f2014-08-06 16:11:14 -07004450 if ($prevline=~/}\s*$/ and $line=~/^.\s*while\s*/ &&
4451 $previndent == $indent) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08004452 my ($s, $c) = ctx_statement_block($linenr, $realcnt, 0);
4453
4454 # Find out what is on the end of the line after the
4455 # conditional.
Andy Whitcroft773647a2008-03-28 14:15:58 -07004456 substr($s, 0, length($c), '');
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08004457 $s =~ s/\n.*//g;
4458
4459 if ($s =~ /^\s*;/) {
Joe Perches8b8856f2014-08-06 16:11:14 -07004460 if (ERROR("WHILE_AFTER_BRACE",
4461 "while should follow close brace '}'\n" . $hereprev) &&
4462 $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
4463 fix_delete_line($fixlinenr - 1, $prevrawline);
4464 fix_delete_line($fixlinenr, $rawline);
4465 my $fixedline = $prevrawline;
4466 my $trailing = $rawline;
4467 $trailing =~ s/^\+//;
4468 $trailing = trim($trailing);
4469 $fixedline =~ s/}\s*$/} $trailing/;
4470 fix_insert_line($fixlinenr, $fixedline);
4471 }
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08004472 }
4473 }
4474
Joe Perches95e2c602013-07-03 15:05:20 -07004475#Specific variable tests
Joe Perches323c1262012-12-17 16:02:07 -08004476 while ($line =~ m{($Constant|$Lval)}g) {
4477 my $var = $1;
Joe Perches95e2c602013-07-03 15:05:20 -07004478
4479#gcc binary extension
4480 if ($var =~ /^$Binary$/) {
Joe Perchesd5e616f2013-09-11 14:23:54 -07004481 if (WARN("GCC_BINARY_CONSTANT",
4482 "Avoid gcc v4.3+ binary constant extension: <$var>\n" . $herecurr) &&
4483 $fix) {
4484 my $hexval = sprintf("0x%x", oct($var));
Joe Perches194f66f2014-08-06 16:11:03 -07004485 $fixed[$fixlinenr] =~
Joe Perchesd5e616f2013-09-11 14:23:54 -07004486 s/\b$var\b/$hexval/;
4487 }
Joe Perches95e2c602013-07-03 15:05:20 -07004488 }
4489
4490#CamelCase
Joe Perches807bd262013-07-03 15:05:22 -07004491 if ($var !~ /^$Constant$/ &&
Joe Perchesbe797942013-07-03 15:05:20 -07004492 $var =~ /[A-Z][a-z]|[a-z][A-Z]/ &&
Joe Perches22735ce2013-07-03 15:05:33 -07004493#Ignore Page<foo> variants
Joe Perches807bd262013-07-03 15:05:22 -07004494 $var !~ /^(?:Clear|Set|TestClear|TestSet|)Page[A-Z]/ &&
Joe Perches22735ce2013-07-03 15:05:33 -07004495#Ignore SI style variants like nS, mV and dB (ie: max_uV, regulator_min_uA_show)
Julius Wernerf5123572014-12-10 15:51:54 -08004496 $var !~ /^(?:[a-z_]*?)_?[a-z][A-Z](?:_[a-z_]+)?$/ &&
4497#Ignore some three character SI units explicitly, like MiB and KHz
4498 $var !~ /^(?:[a-z_]*?)_?(?:[KMGT]iB|[KMGT]?Hz)(?:_[a-z_]+)?$/) {
Joe Perches7e781f62013-09-11 14:23:55 -07004499 while ($var =~ m{($Ident)}g) {
4500 my $word = $1;
4501 next if ($word !~ /[A-Z][a-z]|[a-z][A-Z]/);
Joe Perchesd8b07712013-11-12 15:10:06 -08004502 if ($check) {
4503 seed_camelcase_includes();
4504 if (!$file && !$camelcase_file_seeded) {
4505 seed_camelcase_file($realfile);
4506 $camelcase_file_seeded = 1;
4507 }
4508 }
Joe Perches7e781f62013-09-11 14:23:55 -07004509 if (!defined $camelcase{$word}) {
4510 $camelcase{$word} = 1;
4511 CHK("CAMELCASE",
4512 "Avoid CamelCase: <$word>\n" . $herecurr);
4513 }
Joe Perches34456862013-07-03 15:05:34 -07004514 }
Joe Perches323c1262012-12-17 16:02:07 -08004515 }
4516 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004517
4518#no spaces allowed after \ in define
Joe Perchesd5e616f2013-09-11 14:23:54 -07004519 if ($line =~ /\#\s*define.*\\\s+$/) {
4520 if (WARN("WHITESPACE_AFTER_LINE_CONTINUATION",
4521 "Whitespace after \\ makes next lines useless\n" . $herecurr) &&
4522 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07004523 $fixed[$fixlinenr] =~ s/\s+$//;
Joe Perchesd5e616f2013-09-11 14:23:54 -07004524 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004525 }
4526
Fabian Frederick0e212e02015-04-16 12:44:25 -07004527# warn if <asm/foo.h> is #included and <linux/foo.h> is available and includes
4528# itself <asm/foo.h> (uses RAW line)
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004529 if ($tree && $rawline =~ m{^.\s*\#\s*include\s*\<asm\/(.*)\.h\>}) {
Andy Whitcrofte09dec42008-10-15 22:02:20 -07004530 my $file = "$1.h";
4531 my $checkfile = "include/linux/$file";
4532 if (-f "$root/$checkfile" &&
4533 $realfile ne $checkfile &&
Wolfram Sang7840a942010-08-09 17:20:57 -07004534 $1 !~ /$allowed_asm_includes/)
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004535 {
Fabian Frederick0e212e02015-04-16 12:44:25 -07004536 my $asminclude = `grep -Ec "#include\\s+<asm/$file>" $root/$checkfile`;
4537 if ($asminclude > 0) {
4538 if ($realfile =~ m{^arch/}) {
4539 CHK("ARCH_INCLUDE_LINUX",
4540 "Consider using #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
4541 } else {
4542 WARN("INCLUDE_LINUX",
4543 "Use #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
4544 }
Andy Whitcrofte09dec42008-10-15 22:02:20 -07004545 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004546 }
4547 }
4548
Andy Whitcroft653d4872007-06-23 17:16:34 -07004549# multi-statement macros should be enclosed in a do while loop, grab the
4550# first statement and ensure its the whole macro if its not enclosed
Andy Whitcroftcf655042008-03-04 14:28:20 -08004551# in a known good container
Andy Whitcroftb8f96a32008-07-23 21:29:07 -07004552 if ($realfile !~ m@/vmlinux.lds.h$@ &&
4553 $line =~ /^.\s*\#\s*define\s*$Ident(\()?/) {
Andy Whitcroftd8aaf122007-06-23 17:16:44 -07004554 my $ln = $linenr;
4555 my $cnt = $realcnt;
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004556 my ($off, $dstat, $dcond, $rest);
4557 my $ctx = '';
Joe Perches08a28432014-10-13 15:51:55 -07004558 my $has_flow_statement = 0;
4559 my $has_arg_concat = 0;
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004560 ($dstat, $dcond, $ln, $cnt, $off) =
Andy Whitcroftf74bd192012-01-10 15:09:54 -08004561 ctx_statement_block($linenr, $realcnt, 0);
4562 $ctx = $dstat;
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004563 #print "dstat<$dstat> dcond<$dcond> cnt<$cnt> off<$off>\n";
Andy Whitcrofta3bb97a2008-07-23 21:29:00 -07004564 #print "LINE<$lines[$ln-1]> len<" . length($lines[$ln-1]) . "\n";
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004565
Joe Perches08a28432014-10-13 15:51:55 -07004566 $has_flow_statement = 1 if ($ctx =~ /\b(goto|return)\b/);
Joe Perches62e15a62016-01-20 14:59:18 -08004567 $has_arg_concat = 1 if ($ctx =~ /\#\#/ && $ctx !~ /\#\#\s*(?:__VA_ARGS__|args)\b/);
Joe Perches08a28432014-10-13 15:51:55 -07004568
Andy Whitcroftf74bd192012-01-10 15:09:54 -08004569 $dstat =~ s/^.\s*\#\s*define\s+$Ident(?:\([^\)]*\))?\s*//;
Andy Whitcroft292f1a92008-07-23 21:29:11 -07004570 $dstat =~ s/$;//g;
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004571 $dstat =~ s/\\\n.//g;
4572 $dstat =~ s/^\s*//s;
4573 $dstat =~ s/\s*$//s;
4574
4575 # Flatten any parentheses and braces
Andy Whitcroftbf30d6e2008-10-15 22:02:33 -07004576 while ($dstat =~ s/\([^\(\)]*\)/1/ ||
4577 $dstat =~ s/\{[^\{\}]*\}/1/ ||
Vladimir Zapolskiy6b10df42016-01-20 14:59:21 -08004578 $dstat =~ s/.\[[^\[\]]*\]/1/)
Andy Whitcroftbf30d6e2008-10-15 22:02:33 -07004579 {
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07004580 }
Andy Whitcroftd8aaf122007-06-23 17:16:44 -07004581
Andy Whitcrofte45bab82012-03-23 15:02:18 -07004582 # Flatten any obvious string concatentation.
Joe Perches33acb542015-06-25 15:02:54 -07004583 while ($dstat =~ s/($String)\s*$Ident/$1/ ||
4584 $dstat =~ s/$Ident\s*($String)/$1/)
Andy Whitcrofte45bab82012-03-23 15:02:18 -07004585 {
4586 }
4587
Joe Perches42e15292016-03-15 14:58:01 -07004588 # Make asm volatile uses seem like a generic function
4589 $dstat =~ s/\b_*asm_*\s+_*volatile_*\b/asm_volatile/g;
4590
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004591 my $exceptions = qr{
4592 $Declare|
4593 module_param_named|
Kees Cooka0a0a7a2012-10-04 17:13:38 -07004594 MODULE_PARM_DESC|
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004595 DECLARE_PER_CPU|
4596 DEFINE_PER_CPU|
Andy Whitcroft383099f2009-01-06 14:41:18 -08004597 __typeof__\(|
Stefani Seibold22fd2d32010-03-05 13:43:52 -08004598 union|
4599 struct|
Andy Whitcroftea71a0a2009-09-21 17:04:38 -07004600 \.$Ident\s*=\s*|
Vladimir Zapolskiy6b10df42016-01-20 14:59:21 -08004601 ^\"|\"$|
4602 ^\[
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004603 }x;
Andy Whitcroft5eaa20b2010-10-26 14:23:18 -07004604 #print "REST<$rest> dstat<$dstat> ctx<$ctx>\n";
Andy Whitcroftf74bd192012-01-10 15:09:54 -08004605 if ($dstat ne '' &&
4606 $dstat !~ /^(?:$Ident|-?$Constant),$/ && # 10, // foo(),
4607 $dstat !~ /^(?:$Ident|-?$Constant);$/ && # foo();
Joe Perches3cc4b1c2013-07-03 15:05:27 -07004608 $dstat !~ /^[!~-]?(?:$Lval|$Constant)$/ && # 10 // foo() // !foo // ~foo // -foo // foo->bar // foo.bar->baz
Joe Perches356fd392014-08-06 16:10:31 -07004609 $dstat !~ /^'X'$/ && $dstat !~ /^'XX'$/ && # character constants
Andy Whitcroftf74bd192012-01-10 15:09:54 -08004610 $dstat !~ /$exceptions/ &&
4611 $dstat !~ /^\.$Ident\s*=/ && # .foo =
Joe Perchese942e2c2013-04-17 15:58:26 -07004612 $dstat !~ /^(?:\#\s*$Ident|\#\s*$Constant)\s*$/ && # stringification #foo
Andy Whitcroft72f115f2012-01-10 15:10:06 -08004613 $dstat !~ /^do\s*$Constant\s*while\s*$Constant;?$/ && # do {...} while (...); // do {...} while (...)
Andy Whitcroftf74bd192012-01-10 15:09:54 -08004614 $dstat !~ /^for\s*$Constant$/ && # for (...)
4615 $dstat !~ /^for\s*$Constant\s+(?:$Ident|-?$Constant)$/ && # for (...) bar()
4616 $dstat !~ /^do\s*{/ && # do {...
Eddie Kovsky4e5d56b2015-09-09 15:37:52 -07004617 $dstat !~ /^\(\{/ && # ({...
Joe Perchesf95a7e62013-09-11 14:24:00 -07004618 $ctx !~ /^.\s*#\s*define\s+TRACE_(?:SYSTEM|INCLUDE_FILE|INCLUDE_PATH)\b/)
Andy Whitcroftf74bd192012-01-10 15:09:54 -08004619 {
4620 $ctx =~ s/\n*$//;
4621 my $herectx = $here . "\n";
4622 my $cnt = statement_rawlines($ctx);
4623
4624 for (my $n = 0; $n < $cnt; $n++) {
4625 $herectx .= raw_line($linenr, $n) . "\n";
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004626 }
4627
Andy Whitcroftf74bd192012-01-10 15:09:54 -08004628 if ($dstat =~ /;/) {
4629 ERROR("MULTISTATEMENT_MACRO_USE_DO_WHILE",
4630 "Macros with multiple statements should be enclosed in a do - while loop\n" . "$herectx");
4631 } else {
Joe Perches000d1cc12011-07-25 17:13:25 -07004632 ERROR("COMPLEX_MACRO",
Andrew Morton388982b2014-10-13 15:51:40 -07004633 "Macros with complex values should be enclosed in parentheses\n" . "$herectx");
Andy Whitcroftd8aaf122007-06-23 17:16:44 -07004634 }
Andy Whitcroft653d4872007-06-23 17:16:34 -07004635 }
Joe Perches5023d342012-12-17 16:01:47 -08004636
Joe Perches08a28432014-10-13 15:51:55 -07004637# check for macros with flow control, but without ## concatenation
4638# ## concatenation is commonly a macro that defines a function so ignore those
4639 if ($has_flow_statement && !$has_arg_concat) {
4640 my $herectx = $here . "\n";
4641 my $cnt = statement_rawlines($ctx);
4642
4643 for (my $n = 0; $n < $cnt; $n++) {
4644 $herectx .= raw_line($linenr, $n) . "\n";
4645 }
4646 WARN("MACRO_WITH_FLOW_CONTROL",
4647 "Macros with flow control statements should be avoided\n" . "$herectx");
4648 }
4649
Joe Perches481eb482012-12-17 16:01:56 -08004650# check for line continuations outside of #defines, preprocessor #, and asm
Joe Perches5023d342012-12-17 16:01:47 -08004651
4652 } else {
4653 if ($prevline !~ /^..*\\$/ &&
Joe Perches481eb482012-12-17 16:01:56 -08004654 $line !~ /^\+\s*\#.*\\$/ && # preprocessor
4655 $line !~ /^\+.*\b(__asm__|asm)\b.*\\$/ && # asm
Joe Perches5023d342012-12-17 16:01:47 -08004656 $line =~ /^\+.*\\$/) {
4657 WARN("LINE_CONTINUATIONS",
4658 "Avoid unnecessary line continuations\n" . $herecurr);
4659 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004660 }
4661
Joe Perchesb13edf72012-07-30 14:41:24 -07004662# do {} while (0) macro tests:
4663# single-statement macros do not need to be enclosed in do while (0) loop,
4664# macro should not end with a semicolon
4665 if ($^V && $^V ge 5.10.0 &&
4666 $realfile !~ m@/vmlinux.lds.h$@ &&
4667 $line =~ /^.\s*\#\s*define\s+$Ident(\()?/) {
4668 my $ln = $linenr;
4669 my $cnt = $realcnt;
4670 my ($off, $dstat, $dcond, $rest);
4671 my $ctx = '';
4672 ($dstat, $dcond, $ln, $cnt, $off) =
4673 ctx_statement_block($linenr, $realcnt, 0);
4674 $ctx = $dstat;
4675
4676 $dstat =~ s/\\\n.//g;
Joe Perches1b36b202015-02-13 14:38:32 -08004677 $dstat =~ s/$;/ /g;
Joe Perchesb13edf72012-07-30 14:41:24 -07004678
4679 if ($dstat =~ /^\+\s*#\s*define\s+$Ident\s*${balanced_parens}\s*do\s*{(.*)\s*}\s*while\s*\(\s*0\s*\)\s*([;\s]*)\s*$/) {
4680 my $stmts = $2;
4681 my $semis = $3;
4682
4683 $ctx =~ s/\n*$//;
4684 my $cnt = statement_rawlines($ctx);
4685 my $herectx = $here . "\n";
4686
4687 for (my $n = 0; $n < $cnt; $n++) {
4688 $herectx .= raw_line($linenr, $n) . "\n";
4689 }
4690
Joe Perchesac8e97f2012-08-21 16:15:53 -07004691 if (($stmts =~ tr/;/;/) == 1 &&
4692 $stmts !~ /^\s*(if|while|for|switch)\b/) {
Joe Perchesb13edf72012-07-30 14:41:24 -07004693 WARN("SINGLE_STATEMENT_DO_WHILE_MACRO",
4694 "Single statement macros should not use a do {} while (0) loop\n" . "$herectx");
4695 }
4696 if (defined $semis && $semis ne "") {
4697 WARN("DO_WHILE_MACRO_WITH_TRAILING_SEMICOLON",
4698 "do {} while (0) macros should not be semicolon terminated\n" . "$herectx");
4699 }
Joe Perchesf5ef95b2014-06-04 16:12:06 -07004700 } elsif ($dstat =~ /^\+\s*#\s*define\s+$Ident.*;\s*$/) {
4701 $ctx =~ s/\n*$//;
4702 my $cnt = statement_rawlines($ctx);
4703 my $herectx = $here . "\n";
4704
4705 for (my $n = 0; $n < $cnt; $n++) {
4706 $herectx .= raw_line($linenr, $n) . "\n";
4707 }
4708
4709 WARN("TRAILING_SEMICOLON",
4710 "macros should not use a trailing semicolon\n" . "$herectx");
Joe Perchesb13edf72012-07-30 14:41:24 -07004711 }
4712 }
4713
Mike Frysinger080ba922009-01-06 14:41:25 -08004714# make sure symbols are always wrapped with VMLINUX_SYMBOL() ...
4715# all assignments may have only one of the following with an assignment:
4716# .
4717# ALIGN(...)
4718# VMLINUX_SYMBOL(...)
4719 if ($realfile eq 'vmlinux.lds.h' && $line =~ /(?:(?:^|\s)$Ident\s*=|=\s*$Ident(?:\s|$))/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07004720 WARN("MISSING_VMLINUX_SYMBOL",
4721 "vmlinux.lds.h needs VMLINUX_SYMBOL() around C-visible symbols\n" . $herecurr);
Mike Frysinger080ba922009-01-06 14:41:25 -08004722 }
4723
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07004724# check for redundant bracing round if etc
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004725 if ($line =~ /(^.*)\bif\b/ && $1 !~ /else\s*$/) {
4726 my ($level, $endln, @chunks) =
Andy Whitcroftcf655042008-03-04 14:28:20 -08004727 ctx_statement_full($linenr, $realcnt, 1);
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004728 #print "chunks<$#chunks> linenr<$linenr> endln<$endln> level<$level>\n";
Andy Whitcroftcf655042008-03-04 14:28:20 -08004729 #print "APW: <<$chunks[1][0]>><<$chunks[1][1]>>\n";
4730 if ($#chunks > 0 && $level == 0) {
Joe Perchesaad4f612012-03-23 15:02:19 -07004731 my @allowed = ();
4732 my $allow = 0;
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004733 my $seen = 0;
Andy Whitcroft773647a2008-03-28 14:15:58 -07004734 my $herectx = $here . "\n";
Andy Whitcroftcf655042008-03-04 14:28:20 -08004735 my $ln = $linenr - 1;
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004736 for my $chunk (@chunks) {
4737 my ($cond, $block) = @{$chunk};
4738
Andy Whitcroft773647a2008-03-28 14:15:58 -07004739 # If the condition carries leading newlines, then count those as offsets.
4740 my ($whitespace) = ($cond =~ /^((?:\s*\n[+-])*\s*)/s);
4741 my $offset = statement_rawlines($whitespace) - 1;
4742
Joe Perchesaad4f612012-03-23 15:02:19 -07004743 $allowed[$allow] = 0;
Andy Whitcroft773647a2008-03-28 14:15:58 -07004744 #print "COND<$cond> whitespace<$whitespace> offset<$offset>\n";
4745
4746 # We have looked at and allowed this specific line.
4747 $suppress_ifbraces{$ln + $offset} = 1;
4748
4749 $herectx .= "$rawlines[$ln + $offset]\n[...]\n";
Andy Whitcroftcf655042008-03-04 14:28:20 -08004750 $ln += statement_rawlines($block) - 1;
4751
Andy Whitcroft773647a2008-03-28 14:15:58 -07004752 substr($block, 0, length($cond), '');
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004753
4754 $seen++ if ($block =~ /^\s*{/);
4755
Joe Perchesaad4f612012-03-23 15:02:19 -07004756 #print "cond<$cond> block<$block> allowed<$allowed[$allow]>\n";
Andy Whitcroftcf655042008-03-04 14:28:20 -08004757 if (statement_lines($cond) > 1) {
4758 #print "APW: ALLOWED: cond<$cond>\n";
Joe Perchesaad4f612012-03-23 15:02:19 -07004759 $allowed[$allow] = 1;
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004760 }
4761 if ($block =~/\b(?:if|for|while)\b/) {
Andy Whitcroftcf655042008-03-04 14:28:20 -08004762 #print "APW: ALLOWED: block<$block>\n";
Joe Perchesaad4f612012-03-23 15:02:19 -07004763 $allowed[$allow] = 1;
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004764 }
Andy Whitcroftcf655042008-03-04 14:28:20 -08004765 if (statement_block_size($block) > 1) {
4766 #print "APW: ALLOWED: lines block<$block>\n";
Joe Perchesaad4f612012-03-23 15:02:19 -07004767 $allowed[$allow] = 1;
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004768 }
Joe Perchesaad4f612012-03-23 15:02:19 -07004769 $allow++;
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004770 }
Joe Perchesaad4f612012-03-23 15:02:19 -07004771 if ($seen) {
4772 my $sum_allowed = 0;
4773 foreach (@allowed) {
4774 $sum_allowed += $_;
4775 }
4776 if ($sum_allowed == 0) {
4777 WARN("BRACES",
4778 "braces {} are not necessary for any arm of this statement\n" . $herectx);
4779 } elsif ($sum_allowed != $allow &&
4780 $seen != $allow) {
4781 CHK("BRACES",
4782 "braces {} should be used on all arms of this statement\n" . $herectx);
4783 }
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004784 }
4785 }
4786 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07004787 if (!defined $suppress_ifbraces{$linenr - 1} &&
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004788 $line =~ /\b(if|while|for|else)\b/) {
Andy Whitcroftcf655042008-03-04 14:28:20 -08004789 my $allowed = 0;
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07004790
Andy Whitcroftcf655042008-03-04 14:28:20 -08004791 # Check the pre-context.
4792 if (substr($line, 0, $-[0]) =~ /(\}\s*)$/) {
4793 #print "APW: ALLOWED: pre<$1>\n";
4794 $allowed = 1;
4795 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07004796
4797 my ($level, $endln, @chunks) =
4798 ctx_statement_full($linenr, $realcnt, $-[0]);
4799
Andy Whitcroftcf655042008-03-04 14:28:20 -08004800 # Check the condition.
4801 my ($cond, $block) = @{$chunks[0]};
Andy Whitcroft773647a2008-03-28 14:15:58 -07004802 #print "CHECKING<$linenr> cond<$cond> block<$block>\n";
Andy Whitcroftcf655042008-03-04 14:28:20 -08004803 if (defined $cond) {
Andy Whitcroft773647a2008-03-28 14:15:58 -07004804 substr($block, 0, length($cond), '');
Andy Whitcroftcf655042008-03-04 14:28:20 -08004805 }
4806 if (statement_lines($cond) > 1) {
4807 #print "APW: ALLOWED: cond<$cond>\n";
4808 $allowed = 1;
4809 }
4810 if ($block =~/\b(?:if|for|while)\b/) {
4811 #print "APW: ALLOWED: block<$block>\n";
4812 $allowed = 1;
4813 }
4814 if (statement_block_size($block) > 1) {
4815 #print "APW: ALLOWED: lines block<$block>\n";
4816 $allowed = 1;
4817 }
4818 # Check the post-context.
4819 if (defined $chunks[1]) {
4820 my ($cond, $block) = @{$chunks[1]};
4821 if (defined $cond) {
Andy Whitcroft773647a2008-03-28 14:15:58 -07004822 substr($block, 0, length($cond), '');
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07004823 }
Andy Whitcroftcf655042008-03-04 14:28:20 -08004824 if ($block =~ /^\s*\{/) {
4825 #print "APW: ALLOWED: chunk-1 block<$block>\n";
4826 $allowed = 1;
4827 }
4828 }
4829 if ($level == 0 && $block =~ /^\s*\{/ && !$allowed) {
Justin P. Mattock69932482011-07-26 23:06:29 -07004830 my $herectx = $here . "\n";
Andy Whitcroftf0556632008-10-15 22:02:23 -07004831 my $cnt = statement_rawlines($block);
Andy Whitcroftcf655042008-03-04 14:28:20 -08004832
Andy Whitcroftf0556632008-10-15 22:02:23 -07004833 for (my $n = 0; $n < $cnt; $n++) {
Justin P. Mattock69932482011-07-26 23:06:29 -07004834 $herectx .= raw_line($linenr, $n) . "\n";
Andy Whitcroftcf655042008-03-04 14:28:20 -08004835 }
4836
Joe Perches000d1cc12011-07-25 17:13:25 -07004837 WARN("BRACES",
4838 "braces {} are not necessary for single statement blocks\n" . $herectx);
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07004839 }
4840 }
4841
Joe Perches0979ae62012-12-17 16:01:59 -08004842# check for unnecessary blank lines around braces
Joe Perches77b9a532013-07-03 15:05:29 -07004843 if (($line =~ /^.\s*}\s*$/ && $prevrawline =~ /^.\s*$/)) {
Joe Perchesf8e58212015-02-13 14:38:46 -08004844 if (CHK("BRACES",
4845 "Blank lines aren't necessary before a close brace '}'\n" . $hereprev) &&
4846 $fix && $prevrawline =~ /^\+/) {
4847 fix_delete_line($fixlinenr - 1, $prevrawline);
4848 }
Joe Perches0979ae62012-12-17 16:01:59 -08004849 }
Joe Perches77b9a532013-07-03 15:05:29 -07004850 if (($rawline =~ /^.\s*$/ && $prevline =~ /^..*{\s*$/)) {
Joe Perchesf8e58212015-02-13 14:38:46 -08004851 if (CHK("BRACES",
4852 "Blank lines aren't necessary after an open brace '{'\n" . $hereprev) &&
4853 $fix) {
4854 fix_delete_line($fixlinenr, $rawline);
4855 }
Joe Perches0979ae62012-12-17 16:01:59 -08004856 }
4857
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07004858# no volatiles please
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07004859 my $asm_volatile = qr{\b(__asm__|asm)\s+(__volatile__|volatile)\b};
4860 if ($line =~ /\bvolatile\b/ && $line !~ /$asm_volatile/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07004861 WARN("VOLATILE",
4862 "Use of volatile is usually wrong: see Documentation/volatile-considered-harmful.txt\n" . $herecurr);
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07004863 }
4864
Joe Perches5e4f6ba2014-12-10 15:52:05 -08004865# Check for user-visible strings broken across lines, which breaks the ability
4866# to grep for the string. Make exceptions when the previous string ends in a
4867# newline (multiple lines in one string constant) or '\t', '\r', ';', or '{'
4868# (common in inline assembly) or is a octal \123 or hexadecimal \xaf value
Joe Perches33acb542015-06-25 15:02:54 -07004869 if ($line =~ /^\+\s*$String/ &&
Joe Perches5e4f6ba2014-12-10 15:52:05 -08004870 $prevline =~ /"\s*$/ &&
4871 $prevrawline !~ /(?:\\(?:[ntr]|[0-7]{1,3}|x[0-9a-fA-F]{1,2})|;\s*|\{\s*)"\s*$/) {
4872 if (WARN("SPLIT_STRING",
4873 "quoted string split across lines\n" . $hereprev) &&
4874 $fix &&
4875 $prevrawline =~ /^\+.*"\s*$/ &&
4876 $last_coalesced_string_linenr != $linenr - 1) {
4877 my $extracted_string = get_quoted_string($line, $rawline);
4878 my $comma_close = "";
4879 if ($rawline =~ /\Q$extracted_string\E(\s*\)\s*;\s*$|\s*,\s*)/) {
4880 $comma_close = $1;
4881 }
4882
4883 fix_delete_line($fixlinenr - 1, $prevrawline);
4884 fix_delete_line($fixlinenr, $rawline);
4885 my $fixedline = $prevrawline;
4886 $fixedline =~ s/"\s*$//;
4887 $fixedline .= substr($extracted_string, 1) . trim($comma_close);
4888 fix_insert_line($fixlinenr - 1, $fixedline);
4889 $fixedline = $rawline;
4890 $fixedline =~ s/\Q$extracted_string\E\Q$comma_close\E//;
4891 if ($fixedline !~ /\+\s*$/) {
4892 fix_insert_line($fixlinenr, $fixedline);
4893 }
4894 $last_coalesced_string_linenr = $linenr;
4895 }
4896 }
4897
4898# check for missing a space in a string concatenation
4899 if ($prevrawline =~ /[^\\]\w"$/ && $rawline =~ /^\+[\t ]+"\w/) {
4900 WARN('MISSING_SPACE',
4901 "break quoted strings at a space character\n" . $hereprev);
4902 }
4903
4904# check for spaces before a quoted newline
4905 if ($rawline =~ /^.*\".*\s\\n/) {
4906 if (WARN("QUOTED_WHITESPACE_BEFORE_NEWLINE",
4907 "unnecessary whitespace before a quoted newline\n" . $herecurr) &&
4908 $fix) {
4909 $fixed[$fixlinenr] =~ s/^(\+.*\".*)\s+\\n/$1\\n/;
4910 }
4911
4912 }
4913
Joe Perchesf17dba42014-10-13 15:51:51 -07004914# concatenated string without spaces between elements
Joe Perches33acb542015-06-25 15:02:54 -07004915 if ($line =~ /$String[A-Z_]/ || $line =~ /[A-Za-z0-9_]$String/) {
Joe Perchesf17dba42014-10-13 15:51:51 -07004916 CHK("CONCATENATED_STRING",
4917 "Concatenated strings should use spaces between elements\n" . $herecurr);
4918 }
4919
Joe Perches90ad30e2014-12-10 15:51:59 -08004920# uncoalesced string fragments
Joe Perches33acb542015-06-25 15:02:54 -07004921 if ($line =~ /$String\s*"/) {
Joe Perches90ad30e2014-12-10 15:51:59 -08004922 WARN("STRING_FRAGMENTS",
4923 "Consecutive strings are generally better as a single string\n" . $herecurr);
4924 }
4925
Joe Perches6e300752015-09-09 15:37:47 -07004926# check for %L{u,d,i} and 0x%[udi] in strings
Joe Perches5e4f6ba2014-12-10 15:52:05 -08004927 my $string;
4928 while ($line =~ /(?:^|")([X\t]*)(?:"|$)/g) {
4929 $string = substr($rawline, $-[1], $+[1] - $-[1]);
4930 $string =~ s/%%/__/g;
Joe Perches6e300752015-09-09 15:37:47 -07004931 if ($string =~ /(?<!%)%[\*\d\.\$]*L[udi]/) {
Joe Perches5e4f6ba2014-12-10 15:52:05 -08004932 WARN("PRINTF_L",
4933 "\%Ld/%Lu are not-standard C, use %lld/%llu\n" . $herecurr);
4934 last;
4935 }
Joe Perches6e300752015-09-09 15:37:47 -07004936 if ($string =~ /0x%[\*\d\.\$\Llzth]*[udi]/) {
4937 ERROR("PRINTF_0xDECIMAL",
4938 "Prefixing 0x with decimal output is defective\n" . $herecurr);
4939 }
Joe Perches5e4f6ba2014-12-10 15:52:05 -08004940 }
4941
4942# check for line continuations in quoted strings with odd counts of "
4943 if ($rawline =~ /\\$/ && $rawline =~ tr/"/"/ % 2) {
4944 WARN("LINE_CONTINUATIONS",
4945 "Avoid line continuations in quoted strings\n" . $herecurr);
4946 }
4947
Andy Whitcroft00df3442007-06-08 13:47:06 -07004948# warn about #if 0
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004949 if ($line =~ /^.\s*\#\s*if\s+0\b/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07004950 CHK("REDUNDANT_CODE",
4951 "if this code is redundant consider removing it\n" .
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07004952 $herecurr);
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07004953 }
4954
Andy Whitcroft03df4b52012-12-17 16:01:52 -08004955# check for needless "if (<foo>) fn(<foo>)" uses
4956 if ($prevline =~ /\bif\s*\(\s*($Lval)\s*\)/) {
Joe Perches100425d2015-09-09 15:37:36 -07004957 my $tested = quotemeta($1);
4958 my $expr = '\s*\(\s*' . $tested . '\s*\)\s*;';
4959 if ($line =~ /\b(kfree|usb_free_urb|debugfs_remove(?:_recursive)?|(?:kmem_cache|mempool|dma_pool)_destroy)$expr/) {
4960 my $func = $1;
4961 if (WARN('NEEDLESS_IF',
4962 "$func(NULL) is safe and this check is probably not required\n" . $hereprev) &&
4963 $fix) {
4964 my $do_fix = 1;
4965 my $leading_tabs = "";
4966 my $new_leading_tabs = "";
4967 if ($lines[$linenr - 2] =~ /^\+(\t*)if\s*\(\s*$tested\s*\)\s*$/) {
4968 $leading_tabs = $1;
4969 } else {
4970 $do_fix = 0;
4971 }
4972 if ($lines[$linenr - 1] =~ /^\+(\t+)$func\s*\(\s*$tested\s*\)\s*;\s*$/) {
4973 $new_leading_tabs = $1;
4974 if (length($leading_tabs) + 1 ne length($new_leading_tabs)) {
4975 $do_fix = 0;
4976 }
4977 } else {
4978 $do_fix = 0;
4979 }
4980 if ($do_fix) {
4981 fix_delete_line($fixlinenr - 1, $prevrawline);
4982 $fixed[$fixlinenr] =~ s/^\+$new_leading_tabs/\+$leading_tabs/;
4983 }
4984 }
Greg Kroah-Hartman4c432a82008-07-23 21:29:04 -07004985 }
4986 }
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07004987
Joe Perchesebfdc402014-08-06 16:10:27 -07004988# check for unnecessary "Out of Memory" messages
4989 if ($line =~ /^\+.*\b$logFunctions\s*\(/ &&
4990 $prevline =~ /^[ \+]\s*if\s*\(\s*(\!\s*|NULL\s*==\s*)?($Lval)(\s*==\s*NULL\s*)?\s*\)/ &&
4991 (defined $1 || defined $3) &&
4992 $linenr > 3) {
4993 my $testval = $2;
4994 my $testline = $lines[$linenr - 3];
4995
4996 my ($s, $c) = ctx_statement_block($linenr - 3, $realcnt, 0);
4997# print("line: <$line>\nprevline: <$prevline>\ns: <$s>\nc: <$c>\n\n\n");
4998
4999 if ($c =~ /(?:^|\n)[ \+]\s*(?:$Type\s*)?\Q$testval\E\s*=\s*(?:\([^\)]*\)\s*)?\s*(?:devm_)?(?:[kv][czm]alloc(?:_node|_array)?\b|kstrdup|(?:dev_)?alloc_skb)/) {
5000 WARN("OOM_MESSAGE",
5001 "Possible unnecessary 'out of memory' message\n" . $hereprev);
5002 }
5003 }
5004
Joe Perchesf78d98f2014-10-13 15:52:01 -07005005# check for logging functions with KERN_<LEVEL>
Paolo Bonzinidcaf1122015-02-13 14:38:26 -08005006 if ($line !~ /printk(?:_ratelimited|_once)?\s*\(/ &&
Joe Perchesf78d98f2014-10-13 15:52:01 -07005007 $line =~ /\b$logFunctions\s*\(.*\b(KERN_[A-Z]+)\b/) {
5008 my $level = $1;
5009 if (WARN("UNNECESSARY_KERN_LEVEL",
5010 "Possible unnecessary $level\n" . $herecurr) &&
5011 $fix) {
5012 $fixed[$fixlinenr] =~ s/\s*$level\s*//;
5013 }
5014 }
5015
Joe Perchesabb08a52014-12-10 15:51:46 -08005016# check for mask then right shift without a parentheses
5017 if ($^V && $^V ge 5.10.0 &&
5018 $line =~ /$LvalOrFunc\s*\&\s*($LvalOrFunc)\s*>>/ &&
5019 $4 !~ /^\&/) { # $LvalOrFunc may be &foo, ignore if so
5020 WARN("MASK_THEN_SHIFT",
5021 "Possible precedence defect with mask then right shift - may need parentheses\n" . $herecurr);
5022 }
5023
Joe Perchesb75ac612014-12-10 15:52:02 -08005024# check for pointer comparisons to NULL
5025 if ($^V && $^V ge 5.10.0) {
5026 while ($line =~ /\b$LvalOrFunc\s*(==|\!=)\s*NULL\b/g) {
5027 my $val = $1;
5028 my $equal = "!";
5029 $equal = "" if ($4 eq "!=");
5030 if (CHK("COMPARISON_TO_NULL",
5031 "Comparison to NULL could be written \"${equal}${val}\"\n" . $herecurr) &&
5032 $fix) {
5033 $fixed[$fixlinenr] =~ s/\b\Q$val\E\s*(?:==|\!=)\s*NULL\b/$equal$val/;
5034 }
5035 }
5036 }
5037
Joe Perches8716de32013-09-11 14:24:05 -07005038# check for bad placement of section $InitAttribute (e.g.: __initdata)
5039 if ($line =~ /(\b$InitAttribute\b)/) {
5040 my $attr = $1;
5041 if ($line =~ /^\+\s*static\s+(?:const\s+)?(?:$attr\s+)?($NonptrTypeWithAttr)\s+(?:$attr\s+)?($Ident(?:\[[^]]*\])?)\s*[=;]/) {
5042 my $ptr = $1;
5043 my $var = $2;
5044 if ((($ptr =~ /\b(union|struct)\s+$attr\b/ &&
5045 ERROR("MISPLACED_INIT",
5046 "$attr should be placed after $var\n" . $herecurr)) ||
5047 ($ptr !~ /\b(union|struct)\s+$attr\b/ &&
5048 WARN("MISPLACED_INIT",
5049 "$attr should be placed after $var\n" . $herecurr))) &&
5050 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07005051 $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 -07005052 }
5053 }
5054 }
5055
Joe Perchese970b882013-11-12 15:10:10 -08005056# check for $InitAttributeData (ie: __initdata) with const
5057 if ($line =~ /\bconst\b/ && $line =~ /($InitAttributeData)/) {
5058 my $attr = $1;
5059 $attr =~ /($InitAttributePrefix)(.*)/;
5060 my $attr_prefix = $1;
5061 my $attr_type = $2;
5062 if (ERROR("INIT_ATTRIBUTE",
5063 "Use of const init definition must use ${attr_prefix}initconst\n" . $herecurr) &&
5064 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07005065 $fixed[$fixlinenr] =~
Joe Perchese970b882013-11-12 15:10:10 -08005066 s/$InitAttributeData/${attr_prefix}initconst/;
5067 }
5068 }
5069
5070# check for $InitAttributeConst (ie: __initconst) without const
5071 if ($line !~ /\bconst\b/ && $line =~ /($InitAttributeConst)/) {
5072 my $attr = $1;
5073 if (ERROR("INIT_ATTRIBUTE",
5074 "Use of $attr requires a separate use of const\n" . $herecurr) &&
5075 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07005076 my $lead = $fixed[$fixlinenr] =~
Joe Perchese970b882013-11-12 15:10:10 -08005077 /(^\+\s*(?:static\s+))/;
5078 $lead = rtrim($1);
5079 $lead = "$lead " if ($lead !~ /^\+$/);
5080 $lead = "${lead}const ";
Joe Perches194f66f2014-08-06 16:11:03 -07005081 $fixed[$fixlinenr] =~ s/(^\+\s*(?:static\s+))/$lead/;
Joe Perchese970b882013-11-12 15:10:10 -08005082 }
5083 }
5084
Joe Perchesc17893c2015-04-16 12:44:42 -07005085# check for __read_mostly with const non-pointer (should just be const)
5086 if ($line =~ /\b__read_mostly\b/ &&
5087 $line =~ /($Type)\s*$Ident/ && $1 !~ /\*\s*$/ && $1 =~ /\bconst\b/) {
5088 if (ERROR("CONST_READ_MOSTLY",
5089 "Invalid use of __read_mostly with const type\n" . $herecurr) &&
5090 $fix) {
5091 $fixed[$fixlinenr] =~ s/\s+__read_mostly\b//;
5092 }
5093 }
5094
Joe Perchesfbdb8132014-04-03 14:49:14 -07005095# don't use __constant_<foo> functions outside of include/uapi/
5096 if ($realfile !~ m@^include/uapi/@ &&
5097 $line =~ /(__constant_(?:htons|ntohs|[bl]e(?:16|32|64)_to_cpu|cpu_to_[bl]e(?:16|32|64)))\s*\(/) {
5098 my $constant_func = $1;
5099 my $func = $constant_func;
5100 $func =~ s/^__constant_//;
5101 if (WARN("CONSTANT_CONVERSION",
5102 "$constant_func should be $func\n" . $herecurr) &&
5103 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07005104 $fixed[$fixlinenr] =~ s/\b$constant_func\b/$func/g;
Joe Perchesfbdb8132014-04-03 14:49:14 -07005105 }
5106 }
5107
Patrick Pannuto1a15a252010-08-09 17:21:01 -07005108# prefer usleep_range over udelay
Bruce Allan37581c22013-02-21 16:44:19 -08005109 if ($line =~ /\budelay\s*\(\s*(\d+)\s*\)/) {
Joe Perches43c1d772014-04-03 14:49:11 -07005110 my $delay = $1;
Patrick Pannuto1a15a252010-08-09 17:21:01 -07005111 # ignore udelay's < 10, however
Joe Perches43c1d772014-04-03 14:49:11 -07005112 if (! ($delay < 10) ) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005113 CHK("USLEEP_RANGE",
Joe Perches43c1d772014-04-03 14:49:11 -07005114 "usleep_range is preferred over udelay; see Documentation/timers/timers-howto.txt\n" . $herecurr);
5115 }
5116 if ($delay > 2000) {
5117 WARN("LONG_UDELAY",
5118 "long udelay - prefer mdelay; see arch/arm/include/asm/delay.h\n" . $herecurr);
Patrick Pannuto1a15a252010-08-09 17:21:01 -07005119 }
5120 }
5121
Patrick Pannuto09ef8722010-08-09 17:21:02 -07005122# warn about unexpectedly long msleep's
5123 if ($line =~ /\bmsleep\s*\((\d+)\);/) {
5124 if ($1 < 20) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005125 WARN("MSLEEP",
Joe Perches43c1d772014-04-03 14:49:11 -07005126 "msleep < 20ms can sleep for up to 20ms; see Documentation/timers/timers-howto.txt\n" . $herecurr);
Patrick Pannuto09ef8722010-08-09 17:21:02 -07005127 }
5128 }
5129
Joe Perches36ec1932013-07-03 15:05:25 -07005130# check for comparisons of jiffies
5131 if ($line =~ /\bjiffies\s*$Compare|$Compare\s*jiffies\b/) {
5132 WARN("JIFFIES_COMPARISON",
5133 "Comparing jiffies is almost always wrong; prefer time_after, time_before and friends\n" . $herecurr);
5134 }
5135
Joe Perches9d7a34a2013-07-03 15:05:26 -07005136# check for comparisons of get_jiffies_64()
5137 if ($line =~ /\bget_jiffies_64\s*\(\s*\)\s*$Compare|$Compare\s*get_jiffies_64\s*\(\s*\)/) {
5138 WARN("JIFFIES_COMPARISON",
5139 "Comparing get_jiffies_64() is almost always wrong; prefer time_after64, time_before64 and friends\n" . $herecurr);
5140 }
5141
Andy Whitcroft00df3442007-06-08 13:47:06 -07005142# warn about #ifdefs in C files
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07005143# if ($line =~ /^.\s*\#\s*if(|n)def/ && ($realfile =~ /\.c$/)) {
Andy Whitcroft00df3442007-06-08 13:47:06 -07005144# print "#ifdef in C files should be avoided\n";
5145# print "$herecurr";
5146# $clean = 0;
5147# }
5148
Andy Whitcroft22f2a2e2007-08-10 13:01:03 -07005149# warn about spacing in #ifdefs
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07005150 if ($line =~ /^.\s*\#\s*(ifdef|ifndef|elif)\s\s+/) {
Joe Perches3705ce52013-07-03 15:05:31 -07005151 if (ERROR("SPACING",
5152 "exactly one space required after that #$1\n" . $herecurr) &&
5153 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07005154 $fixed[$fixlinenr] =~
Joe Perches3705ce52013-07-03 15:05:31 -07005155 s/^(.\s*\#\s*(ifdef|ifndef|elif))\s{2,}/$1 /;
5156 }
5157
Andy Whitcroft22f2a2e2007-08-10 13:01:03 -07005158 }
5159
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07005160# check for spinlock_t definitions without a comment.
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07005161 if ($line =~ /^.\s*(struct\s+mutex|spinlock_t)\s+\S+;/ ||
5162 $line =~ /^.\s*(DEFINE_MUTEX)\s*\(/) {
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07005163 my $which = $1;
5164 if (!ctx_has_comment($first_line, $linenr)) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005165 CHK("UNCOMMENTED_DEFINITION",
5166 "$1 definition without comment\n" . $herecurr);
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07005167 }
5168 }
5169# check for memory barriers without a comment.
Michael S. Tsirkin402c2552016-01-04 09:39:01 +02005170
5171 my $barriers = qr{
5172 mb|
5173 rmb|
5174 wmb|
5175 read_barrier_depends
5176 }x;
5177 my $barrier_stems = qr{
5178 mb__before_atomic|
5179 mb__after_atomic|
5180 store_release|
5181 load_acquire|
5182 store_mb|
5183 (?:$barriers)
5184 }x;
5185 my $all_barriers = qr{
5186 (?:$barriers)|
Michael S. Tsirkin43e361f2016-01-04 10:00:10 +02005187 smp_(?:$barrier_stems)|
5188 virt_(?:$barrier_stems)
Michael S. Tsirkin402c2552016-01-04 09:39:01 +02005189 }x;
5190
5191 if ($line =~ /\b(?:$all_barriers)\s*\(/) {
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07005192 if (!ctx_has_comment($first_line, $linenr)) {
Joe Perchesc1fd7bb2013-11-12 15:10:11 -08005193 WARN("MEMORY_BARRIER",
5194 "memory barrier without comment\n" . $herecurr);
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07005195 }
5196 }
Paul E. McKenney3ad81772015-07-02 11:55:40 -07005197
Michael S. Tsirkinf4073b02016-01-04 09:54:51 +02005198 my $underscore_smp_barriers = qr{__smp_(?:$barrier_stems)}x;
5199
5200 if ($realfile !~ m@^include/asm-generic/@ &&
5201 $realfile !~ m@/barrier\.h$@ &&
5202 $line =~ m/\b(?:$underscore_smp_barriers)\s*\(/ &&
5203 $line !~ m/^.\s*\#\s*define\s+(?:$underscore_smp_barriers)\s*\(/) {
5204 WARN("MEMORY_BARRIER",
5205 "__smp memory barriers shouldn't be used outside barrier.h and asm-generic\n" . $herecurr);
5206 }
5207
Joe Perchescb426e92015-06-25 15:02:46 -07005208# check for waitqueue_active without a comment.
5209 if ($line =~ /\bwaitqueue_active\s*\(/) {
5210 if (!ctx_has_comment($first_line, $linenr)) {
5211 WARN("WAITQUEUE_ACTIVE",
5212 "waitqueue_active without comment\n" . $herecurr);
5213 }
5214 }
Paul E. McKenney3ad81772015-07-02 11:55:40 -07005215
5216# Check for expedited grace periods that interrupt non-idle non-nohz
5217# online CPUs. These expedited can therefore degrade real-time response
5218# if used carelessly, and should be avoided where not absolutely
5219# needed. It is always OK to use synchronize_rcu_expedited() and
5220# synchronize_sched_expedited() at boot time (before real-time applications
5221# start) and in error situations where real-time response is compromised in
5222# any case. Note that synchronize_srcu_expedited() does -not- interrupt
5223# other CPUs, so don't warn on uses of synchronize_srcu_expedited().
5224# Of course, nothing comes for free, and srcu_read_lock() and
5225# srcu_read_unlock() do contain full memory barriers in payment for
5226# synchronize_srcu_expedited() non-interruption properties.
5227 if ($line =~ /\b(synchronize_rcu_expedited|synchronize_sched_expedited)\(/) {
5228 WARN("EXPEDITED_RCU_GRACE_PERIOD",
5229 "expedited RCU grace periods should be avoided where they can degrade real-time response\n" . $herecurr);
5230
5231 }
5232
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07005233# check of hardware specific defines
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07005234 if ($line =~ m@^.\s*\#\s*if.*\b(__i386__|__powerpc64__|__sun__|__s390x__)\b@ && $realfile !~ m@include/asm-@) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005235 CHK("ARCH_DEFINES",
5236 "architecture specific defines should be avoided\n" . $herecurr);
Andy Whitcroft0a920b52007-06-01 00:46:48 -07005237 }
Andy Whitcroft653d4872007-06-23 17:16:34 -07005238
Tobias Klauserd4977c72010-05-24 14:33:30 -07005239# Check that the storage class is at the beginning of a declaration
5240 if ($line =~ /\b$Storage\b/ && $line !~ /^.\s*$Storage\b/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005241 WARN("STORAGE_CLASS",
5242 "storage class should be at the beginning of the declaration\n" . $herecurr)
Tobias Klauserd4977c72010-05-24 14:33:30 -07005243 }
5244
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07005245# check the location of the inline attribute, that it is between
5246# storage class and type.
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07005247 if ($line =~ /\b$Type\s+$Inline\b/ ||
5248 $line =~ /\b$Inline\s+$Storage\b/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005249 ERROR("INLINE_LOCATION",
5250 "inline keyword should sit between storage class and type\n" . $herecurr);
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07005251 }
5252
Andy Whitcroft8905a672007-11-28 16:21:06 -08005253# Check for __inline__ and __inline, prefer inline
Joe Perches2b7ab452013-11-12 15:10:14 -08005254 if ($realfile !~ m@\binclude/uapi/@ &&
5255 $line =~ /\b(__inline__|__inline)\b/) {
Joe Perchesd5e616f2013-09-11 14:23:54 -07005256 if (WARN("INLINE",
5257 "plain inline is preferred over $1\n" . $herecurr) &&
5258 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07005259 $fixed[$fixlinenr] =~ s/\b(__inline__|__inline)\b/inline/;
Joe Perchesd5e616f2013-09-11 14:23:54 -07005260
5261 }
Andy Whitcroft8905a672007-11-28 16:21:06 -08005262 }
5263
Joe Perches3d130fd2011-01-12 17:00:00 -08005264# Check for __attribute__ packed, prefer __packed
Joe Perches2b7ab452013-11-12 15:10:14 -08005265 if ($realfile !~ m@\binclude/uapi/@ &&
5266 $line =~ /\b__attribute__\s*\(\s*\(.*\bpacked\b/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005267 WARN("PREFER_PACKED",
5268 "__packed is preferred over __attribute__((packed))\n" . $herecurr);
Joe Perches3d130fd2011-01-12 17:00:00 -08005269 }
5270
Joe Perches39b7e282011-07-25 17:13:24 -07005271# Check for __attribute__ aligned, prefer __aligned
Joe Perches2b7ab452013-11-12 15:10:14 -08005272 if ($realfile !~ m@\binclude/uapi/@ &&
5273 $line =~ /\b__attribute__\s*\(\s*\(.*aligned/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005274 WARN("PREFER_ALIGNED",
5275 "__aligned(size) is preferred over __attribute__((aligned(size)))\n" . $herecurr);
Joe Perches39b7e282011-07-25 17:13:24 -07005276 }
5277
Joe Perches5f14d3b2012-01-10 15:09:52 -08005278# Check for __attribute__ format(printf, prefer __printf
Joe Perches2b7ab452013-11-12 15:10:14 -08005279 if ($realfile !~ m@\binclude/uapi/@ &&
5280 $line =~ /\b__attribute__\s*\(\s*\(\s*format\s*\(\s*printf/) {
Joe Perchesd5e616f2013-09-11 14:23:54 -07005281 if (WARN("PREFER_PRINTF",
5282 "__printf(string-index, first-to-check) is preferred over __attribute__((format(printf, string-index, first-to-check)))\n" . $herecurr) &&
5283 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07005284 $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 -07005285
5286 }
Joe Perches5f14d3b2012-01-10 15:09:52 -08005287 }
5288
Joe Perches6061d942012-03-23 15:02:16 -07005289# Check for __attribute__ format(scanf, prefer __scanf
Joe Perches2b7ab452013-11-12 15:10:14 -08005290 if ($realfile !~ m@\binclude/uapi/@ &&
5291 $line =~ /\b__attribute__\s*\(\s*\(\s*format\s*\(\s*scanf\b/) {
Joe Perchesd5e616f2013-09-11 14:23:54 -07005292 if (WARN("PREFER_SCANF",
5293 "__scanf(string-index, first-to-check) is preferred over __attribute__((format(scanf, string-index, first-to-check)))\n" . $herecurr) &&
5294 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07005295 $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 -07005296 }
Joe Perches6061d942012-03-23 15:02:16 -07005297 }
5298
Joe Perches619a9082014-12-10 15:51:35 -08005299# Check for __attribute__ weak, or __weak declarations (may have link issues)
5300 if ($^V && $^V ge 5.10.0 &&
5301 $line =~ /(?:$Declare|$DeclareMisordered)\s*$Ident\s*$balanced_parens\s*(?:$Attribute)?\s*;/ &&
5302 ($line =~ /\b__attribute__\s*\(\s*\(.*\bweak\b/ ||
5303 $line =~ /\b__weak\b/)) {
5304 ERROR("WEAK_DECLARATION",
5305 "Using weak declarations can have unintended link defects\n" . $herecurr);
5306 }
5307
Joe Perchese6176fa2015-06-25 15:02:49 -07005308# check for c99 types like uint8_t used outside of uapi/
5309 if ($realfile !~ m@\binclude/uapi/@ &&
5310 $line =~ /\b($Declare)\s*$Ident\s*[=;,\[]/) {
5311 my $type = $1;
5312 if ($type =~ /\b($typeC99Typedefs)\b/) {
5313 $type = $1;
5314 my $kernel_type = 'u';
5315 $kernel_type = 's' if ($type =~ /^_*[si]/);
5316 $type =~ /(\d+)/;
5317 $kernel_type .= $1;
5318 if (CHK("PREFER_KERNEL_TYPES",
5319 "Prefer kernel type '$kernel_type' over '$type'\n" . $herecurr) &&
5320 $fix) {
5321 $fixed[$fixlinenr] =~ s/\b$type\b/$kernel_type/;
5322 }
5323 }
5324 }
5325
Joe Perches938224b2016-01-20 14:59:15 -08005326# check for cast of C90 native int or longer types constants
5327 if ($line =~ /(\(\s*$C90_int_types\s*\)\s*)($Constant)\b/) {
5328 my $cast = $1;
5329 my $const = $2;
5330 if (WARN("TYPECAST_INT_CONSTANT",
5331 "Unnecessary typecast of c90 int constant\n" . $herecurr) &&
5332 $fix) {
5333 my $suffix = "";
5334 my $newconst = $const;
5335 $newconst =~ s/${Int_type}$//;
5336 $suffix .= 'U' if ($cast =~ /\bunsigned\b/);
5337 if ($cast =~ /\blong\s+long\b/) {
5338 $suffix .= 'LL';
5339 } elsif ($cast =~ /\blong\b/) {
5340 $suffix .= 'L';
5341 }
5342 $fixed[$fixlinenr] =~ s/\Q$cast\E$const\b/$newconst$suffix/;
5343 }
5344 }
5345
Joe Perches8f53a9b2010-03-05 13:43:48 -08005346# check for sizeof(&)
5347 if ($line =~ /\bsizeof\s*\(\s*\&/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005348 WARN("SIZEOF_ADDRESS",
5349 "sizeof(& should be avoided\n" . $herecurr);
Joe Perches8f53a9b2010-03-05 13:43:48 -08005350 }
5351
Joe Perches66c80b62012-07-30 14:41:22 -07005352# check for sizeof without parenthesis
5353 if ($line =~ /\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/) {
Joe Perchesd5e616f2013-09-11 14:23:54 -07005354 if (WARN("SIZEOF_PARENTHESIS",
5355 "sizeof $1 should be sizeof($1)\n" . $herecurr) &&
5356 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07005357 $fixed[$fixlinenr] =~ s/\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/"sizeof(" . trim($1) . ")"/ex;
Joe Perchesd5e616f2013-09-11 14:23:54 -07005358 }
Joe Perches66c80b62012-07-30 14:41:22 -07005359 }
5360
Joe Perches88982fe2012-12-17 16:02:00 -08005361# check for struct spinlock declarations
5362 if ($line =~ /^.\s*\bstruct\s+spinlock\s+\w+\s*;/) {
5363 WARN("USE_SPINLOCK_T",
5364 "struct spinlock should be spinlock_t\n" . $herecurr);
5365 }
5366
Joe Perchesa6962d72013-04-29 16:18:13 -07005367# check for seq_printf uses that could be seq_puts
Joe Perches06668722013-11-12 15:10:07 -08005368 if ($sline =~ /\bseq_printf\s*\(.*"\s*\)\s*;\s*$/) {
Joe Perchesa6962d72013-04-29 16:18:13 -07005369 my $fmt = get_quoted_string($line, $rawline);
Heba Aamercaac1d52015-02-13 14:38:49 -08005370 $fmt =~ s/%%//g;
5371 if ($fmt !~ /%/) {
Joe Perchesd5e616f2013-09-11 14:23:54 -07005372 if (WARN("PREFER_SEQ_PUTS",
5373 "Prefer seq_puts to seq_printf\n" . $herecurr) &&
5374 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07005375 $fixed[$fixlinenr] =~ s/\bseq_printf\b/seq_puts/;
Joe Perchesd5e616f2013-09-11 14:23:54 -07005376 }
Joe Perchesa6962d72013-04-29 16:18:13 -07005377 }
5378 }
5379
Andy Whitcroft554e1652012-01-10 15:09:57 -08005380# Check for misused memsets
Joe Perchesd1fe9c02012-03-23 15:02:16 -07005381 if ($^V && $^V ge 5.10.0 &&
5382 defined $stat &&
Mateusz Kulikowski9e20a852015-06-25 15:03:16 -07005383 $stat =~ /^\+(?:.*?)\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*$FuncArg\s*\)/) {
Andy Whitcroft554e1652012-01-10 15:09:57 -08005384
Joe Perchesd7c76ba2012-01-10 15:09:58 -08005385 my $ms_addr = $2;
Joe Perchesd1fe9c02012-03-23 15:02:16 -07005386 my $ms_val = $7;
5387 my $ms_size = $12;
Joe Perchesd7c76ba2012-01-10 15:09:58 -08005388
Andy Whitcroft554e1652012-01-10 15:09:57 -08005389 if ($ms_size =~ /^(0x|)0$/i) {
5390 ERROR("MEMSET",
Joe Perchesd7c76ba2012-01-10 15:09:58 -08005391 "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 -08005392 } elsif ($ms_size =~ /^(0x|)1$/i) {
5393 WARN("MEMSET",
Joe Perchesd7c76ba2012-01-10 15:09:58 -08005394 "single byte memset is suspicious. Swapped 2nd/3rd argument?\n" . "$here\n$stat\n");
5395 }
5396 }
5397
Joe Perches98a9bba2014-01-23 15:54:52 -08005398# Check for memcpy(foo, bar, ETH_ALEN) that could be ether_addr_copy(foo, bar)
5399 if ($^V && $^V ge 5.10.0 &&
Mateusz Kulikowski10895d22015-06-25 15:03:21 -07005400 defined $stat &&
5401 $stat =~ /^\+(?:.*?)\bmemcpy\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/) {
Joe Perches98a9bba2014-01-23 15:54:52 -08005402 if (WARN("PREFER_ETHER_ADDR_COPY",
Mateusz Kulikowski10895d22015-06-25 15:03:21 -07005403 "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 -08005404 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07005405 $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 -08005406 }
5407 }
5408
Mateusz Kulikowskib6117d12015-06-25 15:03:13 -07005409# Check for memcmp(foo, bar, ETH_ALEN) that could be ether_addr_equal*(foo, bar)
5410 if ($^V && $^V ge 5.10.0 &&
5411 defined $stat &&
5412 $stat =~ /^\+(?:.*?)\bmemcmp\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/) {
5413 WARN("PREFER_ETHER_ADDR_EQUAL",
5414 "Prefer ether_addr_equal() or ether_addr_equal_unaligned() over memcmp()\n" . "$here\n$stat\n")
5415 }
5416
Mateusz Kulikowski8617cd02015-06-25 15:03:19 -07005417# check for memset(foo, 0x0, ETH_ALEN) that could be eth_zero_addr
5418# check for memset(foo, 0xFF, ETH_ALEN) that could be eth_broadcast_addr
5419 if ($^V && $^V ge 5.10.0 &&
5420 defined $stat &&
5421 $stat =~ /^\+(?:.*?)\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/) {
5422
5423 my $ms_val = $7;
5424
5425 if ($ms_val =~ /^(?:0x|)0+$/i) {
5426 if (WARN("PREFER_ETH_ZERO_ADDR",
5427 "Prefer eth_zero_addr over memset()\n" . "$here\n$stat\n") &&
5428 $fix) {
5429 $fixed[$fixlinenr] =~ s/\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*,\s*ETH_ALEN\s*\)/eth_zero_addr($2)/;
5430 }
5431 } elsif ($ms_val =~ /^(?:0xff|255)$/i) {
5432 if (WARN("PREFER_ETH_BROADCAST_ADDR",
5433 "Prefer eth_broadcast_addr() over memset()\n" . "$here\n$stat\n") &&
5434 $fix) {
5435 $fixed[$fixlinenr] =~ s/\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*,\s*ETH_ALEN\s*\)/eth_broadcast_addr($2)/;
5436 }
5437 }
5438 }
5439
Joe Perchesd7c76ba2012-01-10 15:09:58 -08005440# typecasts on min/max could be min_t/max_t
Joe Perchesd1fe9c02012-03-23 15:02:16 -07005441 if ($^V && $^V ge 5.10.0 &&
5442 defined $stat &&
Joe Perchesd7c76ba2012-01-10 15:09:58 -08005443 $stat =~ /^\+(?:.*?)\b(min|max)\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\)/) {
Joe Perchesd1fe9c02012-03-23 15:02:16 -07005444 if (defined $2 || defined $7) {
Joe Perchesd7c76ba2012-01-10 15:09:58 -08005445 my $call = $1;
5446 my $cast1 = deparenthesize($2);
5447 my $arg1 = $3;
Joe Perchesd1fe9c02012-03-23 15:02:16 -07005448 my $cast2 = deparenthesize($7);
5449 my $arg2 = $8;
Joe Perchesd7c76ba2012-01-10 15:09:58 -08005450 my $cast;
5451
Joe Perchesd1fe9c02012-03-23 15:02:16 -07005452 if ($cast1 ne "" && $cast2 ne "" && $cast1 ne $cast2) {
Joe Perchesd7c76ba2012-01-10 15:09:58 -08005453 $cast = "$cast1 or $cast2";
5454 } elsif ($cast1 ne "") {
5455 $cast = $cast1;
5456 } else {
5457 $cast = $cast2;
5458 }
5459 WARN("MINMAX",
5460 "$call() should probably be ${call}_t($cast, $arg1, $arg2)\n" . "$here\n$stat\n");
Andy Whitcroft554e1652012-01-10 15:09:57 -08005461 }
5462 }
5463
Joe Perches4a273192012-07-30 14:41:20 -07005464# check usleep_range arguments
5465 if ($^V && $^V ge 5.10.0 &&
5466 defined $stat &&
5467 $stat =~ /^\+(?:.*?)\busleep_range\s*\(\s*($FuncArg)\s*,\s*($FuncArg)\s*\)/) {
5468 my $min = $1;
5469 my $max = $7;
5470 if ($min eq $max) {
5471 WARN("USLEEP_RANGE",
5472 "usleep_range should not use min == max args; see Documentation/timers/timers-howto.txt\n" . "$here\n$stat\n");
5473 } elsif ($min =~ /^\d+$/ && $max =~ /^\d+$/ &&
5474 $min > $max) {
5475 WARN("USLEEP_RANGE",
5476 "usleep_range args reversed, use min then max; see Documentation/timers/timers-howto.txt\n" . "$here\n$stat\n");
5477 }
5478 }
5479
Joe Perches823b7942013-11-12 15:10:15 -08005480# check for naked sscanf
5481 if ($^V && $^V ge 5.10.0 &&
5482 defined $stat &&
Joe Perches6c8bd702014-04-03 14:49:16 -07005483 $line =~ /\bsscanf\b/ &&
Joe Perches823b7942013-11-12 15:10:15 -08005484 ($stat !~ /$Ident\s*=\s*sscanf\s*$balanced_parens/ &&
5485 $stat !~ /\bsscanf\s*$balanced_parens\s*(?:$Compare)/ &&
5486 $stat !~ /(?:$Compare)\s*\bsscanf\s*$balanced_parens/)) {
5487 my $lc = $stat =~ tr@\n@@;
5488 $lc = $lc + $linenr;
5489 my $stat_real = raw_line($linenr, 0);
5490 for (my $count = $linenr + 1; $count <= $lc; $count++) {
5491 $stat_real = $stat_real . "\n" . raw_line($count, 0);
5492 }
5493 WARN("NAKED_SSCANF",
5494 "unchecked sscanf return value\n" . "$here\n$stat_real\n");
5495 }
5496
Joe Perchesafc819a2014-06-04 16:12:08 -07005497# check for simple sscanf that should be kstrto<foo>
5498 if ($^V && $^V ge 5.10.0 &&
5499 defined $stat &&
5500 $line =~ /\bsscanf\b/) {
5501 my $lc = $stat =~ tr@\n@@;
5502 $lc = $lc + $linenr;
5503 my $stat_real = raw_line($linenr, 0);
5504 for (my $count = $linenr + 1; $count <= $lc; $count++) {
5505 $stat_real = $stat_real . "\n" . raw_line($count, 0);
5506 }
5507 if ($stat_real =~ /\bsscanf\b\s*\(\s*$FuncArg\s*,\s*("[^"]+")/) {
5508 my $format = $6;
5509 my $count = $format =~ tr@%@%@;
5510 if ($count == 1 &&
5511 $format =~ /^"\%(?i:ll[udxi]|[udxi]ll|ll|[hl]h?[udxi]|[udxi][hl]h?|[hl]h?|[udxi])"$/) {
5512 WARN("SSCANF_TO_KSTRTO",
5513 "Prefer kstrto<type> to single variable sscanf\n" . "$here\n$stat_real\n");
5514 }
5515 }
5516 }
5517
Joe Perches70dc8a42013-09-11 14:23:58 -07005518# check for new externs in .h files.
5519 if ($realfile =~ /\.h$/ &&
5520 $line =~ /^\+\s*(extern\s+)$Type\s*$Ident\s*\(/s) {
Joe Perchesd1d85782013-09-24 15:27:46 -07005521 if (CHK("AVOID_EXTERNS",
5522 "extern prototypes should be avoided in .h files\n" . $herecurr) &&
Joe Perches70dc8a42013-09-11 14:23:58 -07005523 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07005524 $fixed[$fixlinenr] =~ s/(.*)\bextern\b\s*(.*)/$1$2/;
Joe Perches70dc8a42013-09-11 14:23:58 -07005525 }
5526 }
5527
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07005528# check for new externs in .c files.
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07005529 if ($realfile =~ /\.c$/ && defined $stat &&
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07005530 $stat =~ /^.\s*(?:extern\s+)?$Type\s+($Ident)(\s*)\(/s)
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07005531 {
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07005532 my $function_name = $1;
5533 my $paren_space = $2;
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07005534
5535 my $s = $stat;
5536 if (defined $cond) {
5537 substr($s, 0, length($cond), '');
5538 }
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07005539 if ($s =~ /^\s*;/ &&
5540 $function_name ne 'uninitialized_var')
5541 {
Joe Perches000d1cc12011-07-25 17:13:25 -07005542 WARN("AVOID_EXTERNS",
5543 "externs should be avoided in .c files\n" . $herecurr);
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07005544 }
5545
5546 if ($paren_space =~ /\n/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005547 WARN("FUNCTION_ARGUMENTS",
5548 "arguments for function declarations should follow identifier\n" . $herecurr);
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07005549 }
Andy Whitcroft9c9ba342008-04-29 00:59:33 -07005550
5551 } elsif ($realfile =~ /\.c$/ && defined $stat &&
5552 $stat =~ /^.\s*extern\s+/)
5553 {
Joe Perches000d1cc12011-07-25 17:13:25 -07005554 WARN("AVOID_EXTERNS",
5555 "externs should be avoided in .c files\n" . $herecurr);
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07005556 }
5557
5558# checks for new __setup's
5559 if ($rawline =~ /\b__setup\("([^"]*)"/) {
5560 my $name = $1;
5561
5562 if (!grep(/$name/, @setup_docs)) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005563 CHK("UNDOCUMENTED_SETUP",
5564 "__setup appears un-documented -- check Documentation/kernel-parameters.txt\n" . $herecurr);
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07005565 }
Andy Whitcroft653d4872007-06-23 17:16:34 -07005566 }
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07005567
5568# check for pointless casting of kmalloc return
Joe Perchescaf2a542011-01-12 16:59:56 -08005569 if ($line =~ /\*\s*\)\s*[kv][czm]alloc(_node){0,1}\b/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005570 WARN("UNNECESSARY_CASTS",
5571 "unnecessary cast may hide bugs, see http://c-faq.com/malloc/mallocnocast.html\n" . $herecurr);
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07005572 }
Andy Whitcroft13214ad2008-02-08 04:22:03 -08005573
Joe Perchesa640d252013-07-03 15:05:21 -07005574# alloc style
5575# p = alloc(sizeof(struct foo), ...) should be p = alloc(sizeof(*p), ...)
5576 if ($^V && $^V ge 5.10.0 &&
5577 $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*([kv][mz]alloc(?:_node)?)\s*\(\s*(sizeof\s*\(\s*struct\s+$Lval\s*\))/) {
5578 CHK("ALLOC_SIZEOF_STRUCT",
5579 "Prefer $3(sizeof(*$1)...) over $3($4...)\n" . $herecurr);
5580 }
5581
Joe Perches60a55362014-06-04 16:12:07 -07005582# check for k[mz]alloc with multiplies that could be kmalloc_array/kcalloc
5583 if ($^V && $^V ge 5.10.0 &&
Joe Perchese3674552014-08-06 16:10:55 -07005584 $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 -07005585 my $oldfunc = $3;
5586 my $a1 = $4;
5587 my $a2 = $10;
5588 my $newfunc = "kmalloc_array";
5589 $newfunc = "kcalloc" if ($oldfunc eq "kzalloc");
Joe Perchese3674552014-08-06 16:10:55 -07005590 my $r1 = $a1;
5591 my $r2 = $a2;
5592 if ($a1 =~ /^sizeof\s*\S/) {
5593 $r1 = $a2;
5594 $r2 = $a1;
5595 }
5596 if ($r1 !~ /^sizeof\b/ && $r2 =~ /^sizeof\s*\S/ &&
5597 !($r1 =~ /^$Constant$/ || $r1 =~ /^[A-Z_][A-Z0-9_]*$/)) {
Joe Perches60a55362014-06-04 16:12:07 -07005598 if (WARN("ALLOC_WITH_MULTIPLY",
5599 "Prefer $newfunc over $oldfunc with multiply\n" . $herecurr) &&
5600 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07005601 $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 -07005602
5603 }
5604 }
5605 }
5606
Joe Perches972fdea2013-04-29 16:18:12 -07005607# check for krealloc arg reuse
5608 if ($^V && $^V ge 5.10.0 &&
5609 $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*krealloc\s*\(\s*\1\s*,/) {
5610 WARN("KREALLOC_ARG_REUSE",
5611 "Reusing the krealloc arg is almost always a bug\n" . $herecurr);
5612 }
5613
Joe Perches5ce59ae2013-02-21 16:44:18 -08005614# check for alloc argument mismatch
5615 if ($line =~ /\b(kcalloc|kmalloc_array)\s*\(\s*sizeof\b/) {
5616 WARN("ALLOC_ARRAY_ARGS",
5617 "$1 uses number as first arg, sizeof is generally wrong\n" . $herecurr);
5618 }
5619
Joe Perchescaf2a542011-01-12 16:59:56 -08005620# check for multiple semicolons
5621 if ($line =~ /;\s*;\s*$/) {
Joe Perchesd5e616f2013-09-11 14:23:54 -07005622 if (WARN("ONE_SEMICOLON",
5623 "Statements terminations use 1 semicolon\n" . $herecurr) &&
5624 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07005625 $fixed[$fixlinenr] =~ s/(\s*;\s*){2,}$/;/g;
Joe Perchesd5e616f2013-09-11 14:23:54 -07005626 }
Joe Perchesd1e2ad02012-12-17 16:02:01 -08005627 }
5628
Joe Perches0ab90192014-12-10 15:51:57 -08005629# check for #defines like: 1 << <digit> that could be BIT(digit)
5630 if ($line =~ /#\s*define\s+\w+\s+\(?\s*1\s*([ulUL]*)\s*\<\<\s*(?:\d+|$Ident)\s*\)?/) {
5631 my $ull = "";
5632 $ull = "_ULL" if (defined($1) && $1 =~ /ll/i);
5633 if (CHK("BIT_MACRO",
5634 "Prefer using the BIT$ull macro\n" . $herecurr) &&
5635 $fix) {
5636 $fixed[$fixlinenr] =~ s/\(?\s*1\s*[ulUL]*\s*<<\s*(\d+|$Ident)\s*\)?/BIT${ull}($1)/;
5637 }
5638 }
5639
Joe Perchese81f2392014-08-06 16:11:25 -07005640# check for case / default statements not preceded by break/fallthrough/switch
Joe Perchesc34c09a2014-01-23 15:54:43 -08005641 if ($line =~ /^.\s*(?:case\s+(?:$Ident|$Constant)\s*|default):/) {
5642 my $has_break = 0;
5643 my $has_statement = 0;
5644 my $count = 0;
5645 my $prevline = $linenr;
Joe Perchese81f2392014-08-06 16:11:25 -07005646 while ($prevline > 1 && ($file || $count < 3) && !$has_break) {
Joe Perchesc34c09a2014-01-23 15:54:43 -08005647 $prevline--;
5648 my $rline = $rawlines[$prevline - 1];
5649 my $fline = $lines[$prevline - 1];
5650 last if ($fline =~ /^\@\@/);
5651 next if ($fline =~ /^\-/);
5652 next if ($fline =~ /^.(?:\s*(?:case\s+(?:$Ident|$Constant)[\s$;]*|default):[\s$;]*)*$/);
5653 $has_break = 1 if ($rline =~ /fall[\s_-]*(through|thru)/i);
5654 next if ($fline =~ /^.[\s$;]*$/);
5655 $has_statement = 1;
5656 $count++;
5657 $has_break = 1 if ($fline =~ /\bswitch\b|\b(?:break\s*;[\s$;]*$|return\b|goto\b|continue\b)/);
5658 }
5659 if (!$has_break && $has_statement) {
5660 WARN("MISSING_BREAK",
5661 "Possible switch case/default not preceeded by break or fallthrough comment\n" . $herecurr);
5662 }
5663 }
5664
Joe Perchesd1e2ad02012-12-17 16:02:01 -08005665# check for switch/default statements without a break;
5666 if ($^V && $^V ge 5.10.0 &&
5667 defined $stat &&
5668 $stat =~ /^\+[$;\s]*(?:case[$;\s]+\w+[$;\s]*:[$;\s]*|)*[$;\s]*\bdefault[$;\s]*:[$;\s]*;/g) {
5669 my $ctx = '';
5670 my $herectx = $here . "\n";
5671 my $cnt = statement_rawlines($stat);
5672 for (my $n = 0; $n < $cnt; $n++) {
5673 $herectx .= raw_line($linenr, $n) . "\n";
5674 }
5675 WARN("DEFAULT_NO_BREAK",
5676 "switch default: should use break\n" . $herectx);
Joe Perchescaf2a542011-01-12 16:59:56 -08005677 }
5678
Andy Whitcroft13214ad2008-02-08 04:22:03 -08005679# check for gcc specific __FUNCTION__
Joe Perchesd5e616f2013-09-11 14:23:54 -07005680 if ($line =~ /\b__FUNCTION__\b/) {
5681 if (WARN("USE_FUNC",
5682 "__func__ should be used instead of gcc specific __FUNCTION__\n" . $herecurr) &&
5683 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07005684 $fixed[$fixlinenr] =~ s/\b__FUNCTION__\b/__func__/g;
Joe Perchesd5e616f2013-09-11 14:23:54 -07005685 }
Andy Whitcroft13214ad2008-02-08 04:22:03 -08005686 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07005687
Joe Perches62ec8182015-02-13 14:38:18 -08005688# check for uses of __DATE__, __TIME__, __TIMESTAMP__
5689 while ($line =~ /\b(__(?:DATE|TIME|TIMESTAMP)__)\b/g) {
5690 ERROR("DATE_TIME",
5691 "Use of the '$1' macro makes the build non-deterministic\n" . $herecurr);
5692 }
5693
Joe Perches2c924882012-03-23 15:02:20 -07005694# check for use of yield()
5695 if ($line =~ /\byield\s*\(\s*\)/) {
5696 WARN("YIELD",
5697 "Using yield() is generally wrong. See yield() kernel-doc (sched/core.c)\n" . $herecurr);
5698 }
5699
Joe Perches179f8f42013-07-03 15:05:30 -07005700# check for comparisons against true and false
5701 if ($line =~ /\+\s*(.*?)\b(true|false|$Lval)\s*(==|\!=)\s*(true|false|$Lval)\b(.*)$/i) {
5702 my $lead = $1;
5703 my $arg = $2;
5704 my $test = $3;
5705 my $otype = $4;
5706 my $trail = $5;
5707 my $op = "!";
5708
5709 ($arg, $otype) = ($otype, $arg) if ($arg =~ /^(?:true|false)$/i);
5710
5711 my $type = lc($otype);
5712 if ($type =~ /^(?:true|false)$/) {
5713 if (("$test" eq "==" && "$type" eq "true") ||
5714 ("$test" eq "!=" && "$type" eq "false")) {
5715 $op = "";
5716 }
5717
5718 CHK("BOOL_COMPARISON",
5719 "Using comparison to $otype is error prone\n" . $herecurr);
5720
5721## maybe suggesting a correct construct would better
5722## "Using comparison to $otype is error prone. Perhaps use '${lead}${op}${arg}${trail}'\n" . $herecurr);
5723
5724 }
5725 }
5726
Thomas Gleixner4882720b2010-09-07 14:34:01 +00005727# check for semaphores initialized locked
5728 if ($line =~ /^.\s*sema_init.+,\W?0\W?\)/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005729 WARN("CONSIDER_COMPLETION",
5730 "consider using a completion\n" . $herecurr);
Andy Whitcroft773647a2008-03-28 14:15:58 -07005731 }
Joe Perches6712d852012-03-23 15:02:20 -07005732
Joe Perches67d0a072011-10-31 17:13:10 -07005733# recommend kstrto* over simple_strto* and strict_strto*
5734 if ($line =~ /\b((simple|strict)_(strto(l|ll|ul|ull)))\s*\(/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005735 WARN("CONSIDER_KSTRTO",
Joe Perches67d0a072011-10-31 17:13:10 -07005736 "$1 is obsolete, use k$3 instead\n" . $herecurr);
Andy Whitcroft773647a2008-03-28 14:15:58 -07005737 }
Joe Perches6712d852012-03-23 15:02:20 -07005738
Fabian Frederickae3ccc42014-06-04 16:12:10 -07005739# check for __initcall(), use device_initcall() explicitly or more appropriate function please
Michael Ellermanf3db6632008-07-23 21:28:57 -07005740 if ($line =~ /^.\s*__initcall\s*\(/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005741 WARN("USE_DEVICE_INITCALL",
Fabian Frederickae3ccc42014-06-04 16:12:10 -07005742 "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 -07005743 }
Joe Perches6712d852012-03-23 15:02:20 -07005744
Joe Perches0f3c5aa2015-02-13 14:39:05 -08005745# check for various structs that are normally const (ops, kgdb, device_tree)
5746 my $const_structs = qr{
5747 acpi_dock_ops|
Emese Revfy79404842010-03-05 13:43:53 -08005748 address_space_operations|
5749 backlight_ops|
5750 block_device_operations|
5751 dentry_operations|
5752 dev_pm_ops|
5753 dma_map_ops|
5754 extent_io_ops|
5755 file_lock_operations|
5756 file_operations|
5757 hv_ops|
5758 ide_dma_ops|
5759 intel_dvo_dev_ops|
5760 item_operations|
5761 iwl_ops|
5762 kgdb_arch|
5763 kgdb_io|
5764 kset_uevent_ops|
5765 lock_manager_operations|
5766 microcode_ops|
5767 mtrr_ops|
5768 neigh_ops|
5769 nlmsvc_binding|
Joe Perches0f3c5aa2015-02-13 14:39:05 -08005770 of_device_id|
Emese Revfy79404842010-03-05 13:43:53 -08005771 pci_raw_ops|
5772 pipe_buf_operations|
5773 platform_hibernation_ops|
5774 platform_suspend_ops|
5775 proto_ops|
5776 rpc_pipe_ops|
5777 seq_operations|
5778 snd_ac97_build_ops|
5779 soc_pcmcia_socket_ops|
5780 stacktrace_ops|
5781 sysfs_ops|
5782 tty_operations|
Joe Perches6d07d01b2015-04-16 12:44:33 -07005783 uart_ops|
Emese Revfy79404842010-03-05 13:43:53 -08005784 usb_mon_operations|
5785 wd_ops}x;
Andy Whitcroft6903ffb2009-01-15 13:51:07 -08005786 if ($line !~ /\bconst\b/ &&
Joe Perches0f3c5aa2015-02-13 14:39:05 -08005787 $line =~ /\bstruct\s+($const_structs)\b/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005788 WARN("CONST_STRUCT",
5789 "struct $1 should normally be const\n" .
Andy Whitcroft6903ffb2009-01-15 13:51:07 -08005790 $herecurr);
Andy Whitcroft2b6db5c2009-01-06 14:41:29 -08005791 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07005792
5793# use of NR_CPUS is usually wrong
5794# ignore definitions of NR_CPUS and usage to define arrays as likely right
5795 if ($line =~ /\bNR_CPUS\b/ &&
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07005796 $line !~ /^.\s*\s*#\s*if\b.*\bNR_CPUS\b/ &&
5797 $line !~ /^.\s*\s*#\s*define\b.*\bNR_CPUS\b/ &&
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07005798 $line !~ /^.\s*$Declare\s.*\[[^\]]*NR_CPUS[^\]]*\]/ &&
5799 $line !~ /\[[^\]]*\.\.\.[^\]]*NR_CPUS[^\]]*\]/ &&
5800 $line !~ /\[[^\]]*NR_CPUS[^\]]*\.\.\.[^\]]*\]/)
Andy Whitcroft773647a2008-03-28 14:15:58 -07005801 {
Joe Perches000d1cc12011-07-25 17:13:25 -07005802 WARN("NR_CPUS",
5803 "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 -07005804 }
Andy Whitcroft9c9ba342008-04-29 00:59:33 -07005805
Joe Perches52ea8502013-11-12 15:10:09 -08005806# Use of __ARCH_HAS_<FOO> or ARCH_HAVE_<BAR> is wrong.
5807 if ($line =~ /\+\s*#\s*define\s+((?:__)?ARCH_(?:HAS|HAVE)\w*)\b/) {
5808 ERROR("DEFINE_ARCH_HAS",
5809 "#define of '$1' is wrong - use Kconfig variables or standard guards instead\n" . $herecurr);
5810 }
5811
Joe Perchesacd93622015-02-13 14:38:38 -08005812# likely/unlikely comparisons similar to "(likely(foo) > 0)"
5813 if ($^V && $^V ge 5.10.0 &&
5814 $line =~ /\b((?:un)?likely)\s*\(\s*$FuncArg\s*\)\s*$Compare/) {
5815 WARN("LIKELY_MISUSE",
5816 "Using $1 should generally have parentheses around the comparison\n" . $herecurr);
5817 }
5818
Andy Whitcroft691d77b2009-01-06 14:41:16 -08005819# whine mightly about in_atomic
5820 if ($line =~ /\bin_atomic\s*\(/) {
5821 if ($realfile =~ m@^drivers/@) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005822 ERROR("IN_ATOMIC",
5823 "do not use in_atomic in drivers\n" . $herecurr);
Andy Whitcroftf4a87732009-02-27 14:03:05 -08005824 } elsif ($realfile !~ m@^kernel/@) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005825 WARN("IN_ATOMIC",
5826 "use of in_atomic() is incorrect outside core kernel code\n" . $herecurr);
Andy Whitcroft691d77b2009-01-06 14:41:16 -08005827 }
5828 }
Peter Zijlstra1704f472010-03-19 01:37:42 +01005829
5830# check for lockdep_set_novalidate_class
5831 if ($line =~ /^.\s*lockdep_set_novalidate_class\s*\(/ ||
5832 $line =~ /__lockdep_no_validate__\s*\)/ ) {
5833 if ($realfile !~ m@^kernel/lockdep@ &&
5834 $realfile !~ m@^include/linux/lockdep@ &&
5835 $realfile !~ m@^drivers/base/core@) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005836 ERROR("LOCKDEP",
5837 "lockdep_no_validate class is reserved for device->mutex.\n" . $herecurr);
Peter Zijlstra1704f472010-03-19 01:37:42 +01005838 }
5839 }
Dave Jones88f88312011-01-12 16:59:59 -08005840
Joe Perchesb392c642015-04-16 12:44:16 -07005841 if ($line =~ /debugfs_create_\w+.*\b$mode_perms_world_writable\b/ ||
5842 $line =~ /DEVICE_ATTR.*\b$mode_perms_world_writable\b/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005843 WARN("EXPORTED_WORLD_WRITABLE",
5844 "Exporting world writable files is usually an error. Consider more restrictive permissions.\n" . $herecurr);
Dave Jones88f88312011-01-12 16:59:59 -08005845 }
Joe Perches24358802014-04-03 14:49:13 -07005846
Joe Perches515a2352014-04-03 14:49:24 -07005847# Mode permission misuses where it seems decimal should be octal
5848# This uses a shortcut match to avoid unnecessary uses of a slow foreach loop
5849 if ($^V && $^V ge 5.10.0 &&
5850 $line =~ /$mode_perms_search/) {
5851 foreach my $entry (@mode_permission_funcs) {
5852 my $func = $entry->[0];
5853 my $arg_pos = $entry->[1];
Joe Perches24358802014-04-03 14:49:13 -07005854
Joe Perches515a2352014-04-03 14:49:24 -07005855 my $skip_args = "";
5856 if ($arg_pos > 1) {
5857 $arg_pos--;
5858 $skip_args = "(?:\\s*$FuncArg\\s*,\\s*){$arg_pos,$arg_pos}";
5859 }
5860 my $test = "\\b$func\\s*\\(${skip_args}([\\d]+)\\s*[,\\)]";
5861 if ($line =~ /$test/) {
5862 my $val = $1;
5863 $val = $6 if ($skip_args ne "");
Joe Perches24358802014-04-03 14:49:13 -07005864
Joe Perches515a2352014-04-03 14:49:24 -07005865 if ($val !~ /^0$/ &&
5866 (($val =~ /^$Int$/ && $val !~ /^$Octal$/) ||
5867 length($val) ne 4)) {
5868 ERROR("NON_OCTAL_PERMISSIONS",
5869 "Use 4 digit octal (0777) not decimal permissions\n" . $herecurr);
Joe Perchesc0a5c892015-02-13 14:38:21 -08005870 } elsif ($val =~ /^$Octal$/ && (oct($val) & 02)) {
5871 ERROR("EXPORTED_WORLD_WRITABLE",
5872 "Exporting writable files is usually an error. Consider more restrictive permissions.\n" . $herecurr);
Joe Perches515a2352014-04-03 14:49:24 -07005873 }
Joe Perches24358802014-04-03 14:49:13 -07005874 }
5875 }
5876 }
Bjorn Andersson5a6d20c2015-06-25 15:03:24 -07005877
5878# validate content of MODULE_LICENSE against list from include/linux/module.h
5879 if ($line =~ /\bMODULE_LICENSE\s*\(\s*($String)\s*\)/) {
5880 my $extracted_string = get_quoted_string($line, $rawline);
5881 my $valid_licenses = qr{
5882 GPL|
5883 GPL\ v2|
5884 GPL\ and\ additional\ rights|
5885 Dual\ BSD/GPL|
5886 Dual\ MIT/GPL|
5887 Dual\ MPL/GPL|
5888 Proprietary
5889 }x;
5890 if ($extracted_string !~ /^"(?:$valid_licenses)"$/x) {
5891 WARN("MODULE_LICENSE",
5892 "unknown module license " . $extracted_string . "\n" . $herecurr);
5893 }
5894 }
Andy Whitcroft13214ad2008-02-08 04:22:03 -08005895 }
5896
5897 # If we have no input at all, then there is nothing to report on
5898 # so just keep quiet.
5899 if ($#rawlines == -1) {
5900 exit(0);
Andy Whitcroft0a920b52007-06-01 00:46:48 -07005901 }
5902
Andy Whitcroft8905a672007-11-28 16:21:06 -08005903 # In mailback mode only produce a report in the negative, for
5904 # things that appear to be patches.
5905 if ($mailback && ($clean == 1 || !$is_patch)) {
5906 exit(0);
5907 }
5908
5909 # This is not a patch, and we are are in 'no-patch' mode so
5910 # just keep quiet.
5911 if (!$chk_patch && !$is_patch) {
5912 exit(0);
5913 }
5914
Joe Perches06330fc2015-06-25 15:03:11 -07005915 if (!$is_patch && $file !~ /cover-letter\.patch$/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005916 ERROR("NOT_UNIFIED_DIFF",
5917 "Does not appear to be a unified-diff format patch\n");
Andy Whitcroft0a920b52007-06-01 00:46:48 -07005918 }
Joe Perches34d88152015-06-25 15:03:05 -07005919 if ($is_patch && $filename ne '-' && $chk_signoff && $signoff == 0) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005920 ERROR("MISSING_SIGN_OFF",
5921 "Missing Signed-off-by: line(s)\n");
Andy Whitcroft0a920b52007-06-01 00:46:48 -07005922 }
5923
Andy Whitcroft8905a672007-11-28 16:21:06 -08005924 print report_dump();
Andy Whitcroft13214ad2008-02-08 04:22:03 -08005925 if ($summary && !($clean == 1 && $quiet == 1)) {
5926 print "$filename " if ($summary_file);
Andy Whitcroft8905a672007-11-28 16:21:06 -08005927 print "total: $cnt_error errors, $cnt_warn warnings, " .
5928 (($check)? "$cnt_chk checks, " : "") .
5929 "$cnt_lines lines checked\n";
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07005930 }
Andy Whitcroft8905a672007-11-28 16:21:06 -08005931
Andy Whitcroftd2c0a232010-10-26 14:23:12 -07005932 if ($quiet == 0) {
5933 # If there were whitespace errors which cleanpatch can fix
5934 # then suggest that.
5935 if ($rpt_cleaners) {
Mike Frysingerb0781212011-03-22 16:34:43 -07005936 $rpt_cleaners = 0;
Joe Perchesd8469f12015-06-25 15:03:00 -07005937 print << "EOM"
5938
5939NOTE: Whitespace errors detected.
5940 You may wish to use scripts/cleanpatch or scripts/cleanfile
5941EOM
Andy Whitcroftd2c0a232010-10-26 14:23:12 -07005942 }
5943 }
5944
Joe Perchesd752fcc2014-08-06 16:11:05 -07005945 if ($clean == 0 && $fix &&
5946 ("@rawlines" ne "@fixed" ||
5947 $#fixed_inserted >= 0 || $#fixed_deleted >= 0)) {
Joe Perches9624b8d2014-01-23 15:54:44 -08005948 my $newfile = $filename;
5949 $newfile .= ".EXPERIMENTAL-checkpatch-fixes" if (!$fix_inplace);
Joe Perches3705ce52013-07-03 15:05:31 -07005950 my $linecount = 0;
5951 my $f;
5952
Joe Perchesd752fcc2014-08-06 16:11:05 -07005953 @fixed = fix_inserted_deleted_lines(\@fixed, \@fixed_inserted, \@fixed_deleted);
5954
Joe Perches3705ce52013-07-03 15:05:31 -07005955 open($f, '>', $newfile)
5956 or die "$P: Can't open $newfile for write\n";
5957 foreach my $fixed_line (@fixed) {
5958 $linecount++;
5959 if ($file) {
5960 if ($linecount > 3) {
5961 $fixed_line =~ s/^\+//;
Joe Perchesd752fcc2014-08-06 16:11:05 -07005962 print $f $fixed_line . "\n";
Joe Perches3705ce52013-07-03 15:05:31 -07005963 }
5964 } else {
5965 print $f $fixed_line . "\n";
5966 }
5967 }
5968 close($f);
5969
5970 if (!$quiet) {
5971 print << "EOM";
Joe Perchesd8469f12015-06-25 15:03:00 -07005972
Joe Perches3705ce52013-07-03 15:05:31 -07005973Wrote EXPERIMENTAL --fix correction(s) to '$newfile'
5974
5975Do _NOT_ trust the results written to this file.
5976Do _NOT_ submit these changes without inspecting them for correctness.
5977
5978This EXPERIMENTAL file is simply a convenience to help rewrite patches.
5979No warranties, expressed or implied...
Joe Perches3705ce52013-07-03 15:05:31 -07005980EOM
5981 }
5982 }
5983
Joe Perchesd8469f12015-06-25 15:03:00 -07005984 if ($quiet == 0) {
5985 print "\n";
5986 if ($clean == 1) {
5987 print "$vname has no obvious style problems and is ready for submission.\n";
5988 } else {
5989 print "$vname has style problems, please review.\n";
5990 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07005991 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07005992 return $clean;
5993}