blob: 2b3c22808c3bfcd761ee6b7522354b77d31f3c9c [file] [log] [blame]
Andy Whitcroft0a920b52007-06-01 00:46:48 -07001#!/usr/bin/perl -w
Dave Jonesdbf004d2010-01-12 16:59:52 -05002# (c) 2001, Dave Jones. (the file handling bit)
Andy Whitcroft00df3442007-06-08 13:47:06 -07003# (c) 2005, Joel Schopp <jschopp@austin.ibm.com> (the ugly bit)
Andy Whitcroft2a5a2c22009-01-06 14:41:23 -08004# (c) 2007,2008, Andy Whitcroft <apw@uk.ibm.com> (new conditions, test suite)
Andy Whitcroft015830b2010-10-26 14:23:17 -07005# (c) 2008-2010 Andy Whitcroft <apw@canonical.com>
Andy Whitcroft0a920b52007-06-01 00:46:48 -07006# Licensed under the terms of the GNU GPL License version 2
7
8use strict;
Joe Perchesc707a812013-07-08 16:00:43 -07009use POSIX;
Joe Perches36061e32014-12-10 15:51:43 -080010use File::Basename;
11use Cwd 'abs_path';
Joe Perches57230292015-06-25 15:03:03 -070012use Term::ANSIColor qw(:constants);
Andy Whitcroft0a920b52007-06-01 00:46:48 -070013
14my $P = $0;
Joe Perches36061e32014-12-10 15:51:43 -080015my $D = dirname(abs_path($P));
Andy Whitcroft0a920b52007-06-01 00:46:48 -070016
Joe Perches000d1cc12011-07-25 17:13:25 -070017my $V = '0.32';
Andy Whitcroft0a920b52007-06-01 00:46:48 -070018
19use Getopt::Long qw(:config no_auto_abbrev);
20
21my $quiet = 0;
22my $tree = 1;
23my $chk_signoff = 1;
24my $chk_patch = 1;
Andy Whitcroft773647a2008-03-28 14:15:58 -070025my $tst_only;
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -070026my $emacs = 0;
Andy Whitcroft8905a672007-11-28 16:21:06 -080027my $terse = 0;
Joe Perches34d88152015-06-25 15:03:05 -070028my $showfile = 0;
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -070029my $file = 0;
30my $check = 0;
Joe Perches2ac73b42014-06-04 16:12:05 -070031my $check_orig = 0;
Andy Whitcroft8905a672007-11-28 16:21:06 -080032my $summary = 1;
33my $mailback = 0;
Andy Whitcroft13214ad2008-02-08 04:22:03 -080034my $summary_file = 0;
Joe Perches000d1cc12011-07-25 17:13:25 -070035my $show_types = 0;
Joe Perches3705ce52013-07-03 15:05:31 -070036my $fix = 0;
Joe Perches9624b8d2014-01-23 15:54:44 -080037my $fix_inplace = 0;
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -070038my $root;
Andy Whitcroftc2fdda02008-02-08 04:20:54 -080039my %debug;
Joe Perches34456862013-07-03 15:05:34 -070040my %camelcase = ();
Joe Perches91bfe482013-09-11 14:23:59 -070041my %use_type = ();
42my @use = ();
43my %ignore_type = ();
Joe Perches000d1cc12011-07-25 17:13:25 -070044my @ignore = ();
Hannes Eder77f5b102009-09-21 17:04:37 -070045my $help = 0;
Joe Perches000d1cc12011-07-25 17:13:25 -070046my $configuration_file = ".checkpatch.conf";
Joe Perches6cd7f382012-12-17 16:01:54 -080047my $max_line_length = 80;
Dave Hansend62a2012013-09-11 14:23:56 -070048my $ignore_perl_version = 0;
49my $minimum_perl_version = 5.10.0;
Vadim Bendebury56193272014-10-13 15:51:48 -070050my $min_conf_desc_length = 4;
Kees Cook66b47b42014-10-13 15:51:57 -070051my $spelling_file = "$D/spelling.txt";
Joe Perchesebfd7d62015-04-16 12:44:14 -070052my $codespell = 0;
Maxim Uvarovf1a63672015-06-25 15:03:08 -070053my $codespellfile = "/usr/share/codespell/dictionary.txt";
Joe Perches57230292015-06-25 15:03:03 -070054my $color = 1;
Hannes Eder77f5b102009-09-21 17:04:37 -070055
56sub help {
57 my ($exitcode) = @_;
58
59 print << "EOM";
60Usage: $P [OPTION]... [FILE]...
61Version: $V
62
63Options:
64 -q, --quiet quiet
65 --no-tree run without a kernel tree
66 --no-signoff do not check for 'Signed-off-by' line
67 --patch treat FILE as patchfile (default)
68 --emacs emacs compile window format
69 --terse one line per report
Joe Perches34d88152015-06-25 15:03:05 -070070 --showfile emit diffed file position, not input file position
Hannes Eder77f5b102009-09-21 17:04:37 -070071 -f, --file treat FILE as regular source file
72 --subjective, --strict enable more subjective tests
Joe Perches91bfe482013-09-11 14:23:59 -070073 --types TYPE(,TYPE2...) show only these comma separated message types
Joe Perches000d1cc12011-07-25 17:13:25 -070074 --ignore TYPE(,TYPE2...) ignore various comma separated message types
Joe Perches6cd7f382012-12-17 16:01:54 -080075 --max-line-length=n set the maximum line length, if exceeded, warn
Vadim Bendebury56193272014-10-13 15:51:48 -070076 --min-conf-desc-length=n set the min description length, if shorter, warn
Joe Perches000d1cc12011-07-25 17:13:25 -070077 --show-types show the message "types" in the output
Hannes Eder77f5b102009-09-21 17:04:37 -070078 --root=PATH PATH to the kernel tree root
79 --no-summary suppress the per-file summary
80 --mailback only produce a report in case of warnings/errors
81 --summary-file include the filename in summary
82 --debug KEY=[0|1] turn on/off debugging of KEY, where KEY is one of
83 'values', 'possible', 'type', and 'attr' (default
84 is all off)
85 --test-only=WORD report only warnings/errors containing WORD
86 literally
Joe Perches3705ce52013-07-03 15:05:31 -070087 --fix EXPERIMENTAL - may create horrible results
88 If correctable single-line errors exist, create
89 "<inputfile>.EXPERIMENTAL-checkpatch-fixes"
90 with potential errors corrected to the preferred
91 checkpatch style
Joe Perches9624b8d2014-01-23 15:54:44 -080092 --fix-inplace EXPERIMENTAL - may create horrible results
93 Is the same as --fix, but overwrites the input
94 file. It's your fault if there's no backup or git
Dave Hansend62a2012013-09-11 14:23:56 -070095 --ignore-perl-version override checking of perl version. expect
96 runtime errors.
Joe Perchesebfd7d62015-04-16 12:44:14 -070097 --codespell Use the codespell dictionary for spelling/typos
Maxim Uvarovf1a63672015-06-25 15:03:08 -070098 (default:/usr/share/codespell/dictionary.txt)
Joe Perchesebfd7d62015-04-16 12:44:14 -070099 --codespellfile Use this codespell dictionary
Joe Perches57230292015-06-25 15:03:03 -0700100 --color Use colors when output is STDOUT (default: on)
Hannes Eder77f5b102009-09-21 17:04:37 -0700101 -h, --help, --version display this help and exit
102
103When FILE is - read standard input.
104EOM
105
106 exit($exitcode);
107}
108
Joe Perches000d1cc12011-07-25 17:13:25 -0700109my $conf = which_conf($configuration_file);
110if (-f $conf) {
111 my @conf_args;
112 open(my $conffile, '<', "$conf")
113 or warn "$P: Can't find a readable $configuration_file file $!\n";
114
115 while (<$conffile>) {
116 my $line = $_;
117
118 $line =~ s/\s*\n?$//g;
119 $line =~ s/^\s*//g;
120 $line =~ s/\s+/ /g;
121
122 next if ($line =~ m/^\s*#/);
123 next if ($line =~ m/^\s*$/);
124
125 my @words = split(" ", $line);
126 foreach my $word (@words) {
127 last if ($word =~ m/^#/);
128 push (@conf_args, $word);
129 }
130 }
131 close($conffile);
132 unshift(@ARGV, @conf_args) if @conf_args;
133}
134
Andy Whitcroft0a920b52007-06-01 00:46:48 -0700135GetOptions(
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700136 'q|quiet+' => \$quiet,
Andy Whitcroft0a920b52007-06-01 00:46:48 -0700137 'tree!' => \$tree,
138 'signoff!' => \$chk_signoff,
139 'patch!' => \$chk_patch,
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700140 'emacs!' => \$emacs,
Andy Whitcroft8905a672007-11-28 16:21:06 -0800141 'terse!' => \$terse,
Joe Perches34d88152015-06-25 15:03:05 -0700142 'showfile!' => \$showfile,
Hannes Eder77f5b102009-09-21 17:04:37 -0700143 'f|file!' => \$file,
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700144 'subjective!' => \$check,
145 'strict!' => \$check,
Joe Perches000d1cc12011-07-25 17:13:25 -0700146 'ignore=s' => \@ignore,
Joe Perches91bfe482013-09-11 14:23:59 -0700147 'types=s' => \@use,
Joe Perches000d1cc12011-07-25 17:13:25 -0700148 'show-types!' => \$show_types,
Joe Perches6cd7f382012-12-17 16:01:54 -0800149 'max-line-length=i' => \$max_line_length,
Vadim Bendebury56193272014-10-13 15:51:48 -0700150 'min-conf-desc-length=i' => \$min_conf_desc_length,
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700151 'root=s' => \$root,
Andy Whitcroft8905a672007-11-28 16:21:06 -0800152 'summary!' => \$summary,
153 'mailback!' => \$mailback,
Andy Whitcroft13214ad2008-02-08 04:22:03 -0800154 'summary-file!' => \$summary_file,
Joe Perches3705ce52013-07-03 15:05:31 -0700155 'fix!' => \$fix,
Joe Perches9624b8d2014-01-23 15:54:44 -0800156 'fix-inplace!' => \$fix_inplace,
Dave Hansend62a2012013-09-11 14:23:56 -0700157 'ignore-perl-version!' => \$ignore_perl_version,
Andy Whitcroftc2fdda02008-02-08 04:20:54 -0800158 'debug=s' => \%debug,
Andy Whitcroft773647a2008-03-28 14:15:58 -0700159 'test-only=s' => \$tst_only,
Joe Perchesebfd7d62015-04-16 12:44:14 -0700160 'codespell!' => \$codespell,
161 'codespellfile=s' => \$codespellfile,
Joe Perches57230292015-06-25 15:03:03 -0700162 'color!' => \$color,
Hannes Eder77f5b102009-09-21 17:04:37 -0700163 'h|help' => \$help,
164 'version' => \$help
165) or help(1);
166
167help(0) if ($help);
Andy Whitcroft0a920b52007-06-01 00:46:48 -0700168
Joe Perches9624b8d2014-01-23 15:54:44 -0800169$fix = 1 if ($fix_inplace);
Joe Perches2ac73b42014-06-04 16:12:05 -0700170$check_orig = $check;
Joe Perches9624b8d2014-01-23 15:54:44 -0800171
Andy Whitcroft0a920b52007-06-01 00:46:48 -0700172my $exit = 0;
173
Dave Hansend62a2012013-09-11 14:23:56 -0700174if ($^V && $^V lt $minimum_perl_version) {
175 printf "$P: requires at least perl version %vd\n", $minimum_perl_version;
176 if (!$ignore_perl_version) {
177 exit(1);
178 }
179}
180
Andy Whitcroft0a920b52007-06-01 00:46:48 -0700181if ($#ARGV < 0) {
Hannes Eder77f5b102009-09-21 17:04:37 -0700182 print "$P: no input files\n";
Andy Whitcroft0a920b52007-06-01 00:46:48 -0700183 exit(1);
184}
185
Joe Perches91bfe482013-09-11 14:23:59 -0700186sub hash_save_array_words {
187 my ($hashRef, $arrayRef) = @_;
Joe Perches000d1cc12011-07-25 17:13:25 -0700188
Joe Perches91bfe482013-09-11 14:23:59 -0700189 my @array = split(/,/, join(',', @$arrayRef));
190 foreach my $word (@array) {
191 $word =~ s/\s*\n?$//g;
192 $word =~ s/^\s*//g;
193 $word =~ s/\s+/ /g;
194 $word =~ tr/[a-z]/[A-Z]/;
Joe Perches000d1cc12011-07-25 17:13:25 -0700195
Joe Perches91bfe482013-09-11 14:23:59 -0700196 next if ($word =~ m/^\s*#/);
197 next if ($word =~ m/^\s*$/);
198
199 $hashRef->{$word}++;
200 }
Joe Perches000d1cc12011-07-25 17:13:25 -0700201}
202
Joe Perches91bfe482013-09-11 14:23:59 -0700203sub hash_show_words {
204 my ($hashRef, $prefix) = @_;
205
Joe Perches3c816e42015-06-25 15:03:29 -0700206 if (keys %$hashRef) {
Joe Perchesd8469f12015-06-25 15:03:00 -0700207 print "\nNOTE: $prefix message types:";
Joe Perches58cb3cf2013-09-11 14:24:04 -0700208 foreach my $word (sort keys %$hashRef) {
Joe Perches91bfe482013-09-11 14:23:59 -0700209 print " $word";
210 }
Joe Perchesd8469f12015-06-25 15:03:00 -0700211 print "\n";
Joe Perches91bfe482013-09-11 14:23:59 -0700212 }
213}
214
215hash_save_array_words(\%ignore_type, \@ignore);
216hash_save_array_words(\%use_type, \@use);
217
Andy Whitcroftc2fdda02008-02-08 04:20:54 -0800218my $dbg_values = 0;
219my $dbg_possible = 0;
Andy Whitcroft7429c692008-07-23 21:29:06 -0700220my $dbg_type = 0;
Andy Whitcrofta1ef2772008-10-15 22:02:17 -0700221my $dbg_attr = 0;
Andy Whitcroftc2fdda02008-02-08 04:20:54 -0800222for my $key (keys %debug) {
Andy Whitcroft21caa132009-01-06 14:41:30 -0800223 ## no critic
224 eval "\${dbg_$key} = '$debug{$key}';";
225 die "$@" if ($@);
Andy Whitcroftc2fdda02008-02-08 04:20:54 -0800226}
227
Andy Whitcroftd2c0a232010-10-26 14:23:12 -0700228my $rpt_cleaners = 0;
229
Andy Whitcroft8905a672007-11-28 16:21:06 -0800230if ($terse) {
231 $emacs = 1;
232 $quiet++;
233}
234
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700235if ($tree) {
236 if (defined $root) {
237 if (!top_of_kernel_tree($root)) {
238 die "$P: $root: --root does not point at a valid tree\n";
239 }
240 } else {
241 if (top_of_kernel_tree('.')) {
242 $root = '.';
243 } elsif ($0 =~ m@(.*)/scripts/[^/]*$@ &&
244 top_of_kernel_tree($1)) {
245 $root = $1;
246 }
247 }
248
249 if (!defined $root) {
250 print "Must be run from the top-level dir. of a kernel tree\n";
251 exit(2);
252 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -0700253}
254
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700255my $emitted_corrupt = 0;
256
Andy Whitcroft2ceb5322009-10-26 16:50:14 -0700257our $Ident = qr{
258 [A-Za-z_][A-Za-z\d_]*
259 (?:\s*\#\#\s*[A-Za-z_][A-Za-z\d_]*)*
260 }x;
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700261our $Storage = qr{extern|static|asmlinkage};
262our $Sparse = qr{
263 __user|
264 __kernel|
265 __force|
266 __iomem|
Joe Perches54507b52015-09-09 15:37:55 -0700267 __pmem|
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700268 __must_check|
269 __init_refok|
Andy Whitcroft417495e2009-02-27 14:03:08 -0800270 __kprobes|
Sven Eckelmann165e72a2011-07-25 17:13:23 -0700271 __ref|
272 __rcu
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700273 }x;
Joe Perchese970b8842013-11-12 15:10:10 -0800274our $InitAttributePrefix = qr{__(?:mem|cpu|dev|net_|)};
275our $InitAttributeData = qr{$InitAttributePrefix(?:initdata\b)};
276our $InitAttributeConst = qr{$InitAttributePrefix(?:initconst\b)};
277our $InitAttributeInit = qr{$InitAttributePrefix(?:init\b)};
278our $InitAttribute = qr{$InitAttributeData|$InitAttributeConst|$InitAttributeInit};
Joe Perches8716de32013-09-11 14:24:05 -0700279
Wolfram Sang52131292010-03-05 13:43:51 -0800280# Notes to $Attribute:
281# We need \b after 'init' otherwise 'initconst' will cause a false positive in a check
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700282our $Attribute = qr{
283 const|
Joe Perches03f1df72010-10-26 14:23:16 -0700284 __percpu|
285 __nocast|
286 __safe|
287 __bitwise__|
288 __packed__|
289 __packed2__|
290 __naked|
291 __maybe_unused|
292 __always_unused|
293 __noreturn|
294 __used|
295 __cold|
Joe Perchese23ef1f2015-02-13 14:38:24 -0800296 __pure|
Joe Perches03f1df72010-10-26 14:23:16 -0700297 __noclone|
298 __deprecated|
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700299 __read_mostly|
300 __kprobes|
Joe Perches8716de32013-09-11 14:24:05 -0700301 $InitAttribute|
Andy Whitcroft24e1d812008-10-15 22:02:18 -0700302 ____cacheline_aligned|
303 ____cacheline_aligned_in_smp|
Andy Whitcroft5fe3af12009-01-06 14:41:18 -0800304 ____cacheline_internodealigned_in_smp|
305 __weak
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700306 }x;
Andy Whitcroftc45dcab2008-06-05 22:46:01 -0700307our $Modifier;
Joe Perches91cb5192014-04-03 14:49:32 -0700308our $Inline = qr{inline|__always_inline|noinline|__inline|__inline__};
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700309our $Member = qr{->$Ident|\.$Ident|\[[^]]*\]};
310our $Lval = qr{$Ident(?:$Member)*};
311
Joe Perches95e2c602013-07-03 15:05:20 -0700312our $Int_type = qr{(?i)llu|ull|ll|lu|ul|l|u};
313our $Binary = qr{(?i)0b[01]+$Int_type?};
314our $Hex = qr{(?i)0x[0-9a-f]+$Int_type?};
315our $Int = qr{[0-9]+$Int_type?};
Joe Perches24358802014-04-03 14:49:13 -0700316our $Octal = qr{0[0-7]+$Int_type?};
Joe Perchesc0a5c892015-02-13 14:38:21 -0800317our $String = qr{"[X\t]*"};
Joe Perches326b1ff2013-02-04 14:28:51 -0800318our $Float_hex = qr{(?i)0x[0-9a-f]+p-?[0-9]+[fl]?};
319our $Float_dec = qr{(?i)(?:[0-9]+\.[0-9]*|[0-9]*\.[0-9]+)(?:e-?[0-9]+)?[fl]?};
320our $Float_int = qr{(?i)[0-9]+e-?[0-9]+[fl]?};
Joe Perches74349bc2012-12-17 16:02:05 -0800321our $Float = qr{$Float_hex|$Float_dec|$Float_int};
Joe Perches24358802014-04-03 14:49:13 -0700322our $Constant = qr{$Float|$Binary|$Octal|$Hex|$Int};
Joe Perches326b1ff2013-02-04 14:28:51 -0800323our $Assignment = qr{\*\=|/=|%=|\+=|-=|<<=|>>=|&=|\^=|\|=|=};
Joe Perches447432f2014-04-03 14:49:17 -0700324our $Compare = qr{<=|>=|==|!=|<|(?<!-)>};
Joe Perches23f780c2013-07-03 15:05:31 -0700325our $Arithmetic = qr{\+|-|\*|\/|%};
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700326our $Operators = qr{
327 <=|>=|==|!=|
328 =>|->|<<|>>|<|>|!|~|
Joe Perches23f780c2013-07-03 15:05:31 -0700329 &&|\|\||,|\^|\+\+|--|&|\||$Arithmetic
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700330 }x;
331
Joe Perches91cb5192014-04-03 14:49:32 -0700332our $c90_Keywords = qr{do|for|while|if|else|return|goto|continue|switch|default|case|break}x;
333
Joe Perchesab7e23f2015-04-16 12:44:22 -0700334our $BasicType;
Andy Whitcroft8905a672007-11-28 16:21:06 -0800335our $NonptrType;
Joe Perches18130872014-08-06 16:11:22 -0700336our $NonptrTypeMisordered;
Joe Perches8716de32013-09-11 14:24:05 -0700337our $NonptrTypeWithAttr;
Andy Whitcroft8905a672007-11-28 16:21:06 -0800338our $Type;
Joe Perches18130872014-08-06 16:11:22 -0700339our $TypeMisordered;
Andy Whitcroft8905a672007-11-28 16:21:06 -0800340our $Declare;
Joe Perches18130872014-08-06 16:11:22 -0700341our $DeclareMisordered;
Andy Whitcroft8905a672007-11-28 16:21:06 -0800342
Joe Perches15662b32011-10-31 17:13:12 -0700343our $NON_ASCII_UTF8 = qr{
344 [\xC2-\xDF][\x80-\xBF] # non-overlong 2-byte
Andy Whitcroft171ae1a2008-04-29 00:59:32 -0700345 | \xE0[\xA0-\xBF][\x80-\xBF] # excluding overlongs
346 | [\xE1-\xEC\xEE\xEF][\x80-\xBF]{2} # straight 3-byte
347 | \xED[\x80-\x9F][\x80-\xBF] # excluding surrogates
348 | \xF0[\x90-\xBF][\x80-\xBF]{2} # planes 1-3
349 | [\xF1-\xF3][\x80-\xBF]{3} # planes 4-15
350 | \xF4[\x80-\x8F][\x80-\xBF]{2} # plane 16
351}x;
352
Joe Perches15662b32011-10-31 17:13:12 -0700353our $UTF8 = qr{
354 [\x09\x0A\x0D\x20-\x7E] # ASCII
355 | $NON_ASCII_UTF8
356}x;
357
Joe Perchese6176fa2015-06-25 15:02:49 -0700358our $typeC99Typedefs = qr{(?:__)?(?:[us]_?)?int_?(?:8|16|32|64)_t};
Joe Perches021158b2015-02-13 14:38:43 -0800359our $typeOtherOSTypedefs = qr{(?x:
360 u_(?:char|short|int|long) | # bsd
361 u(?:nchar|short|int|long) # sysv
362)};
Joe Perchese6176fa2015-06-25 15:02:49 -0700363our $typeKernelTypedefs = qr{(?x:
Andy Whitcroftfb9e9092009-09-21 17:04:38 -0700364 (?:__)?(?:u|s|be|le)(?:8|16|32|64)|
Andy Whitcroft8ed22ca2008-10-15 22:02:32 -0700365 atomic_t
366)};
Joe Perchese6176fa2015-06-25 15:02:49 -0700367our $typeTypedefs = qr{(?x:
368 $typeC99Typedefs\b|
369 $typeOtherOSTypedefs\b|
370 $typeKernelTypedefs\b
371)};
Andy Whitcroft8ed22ca2008-10-15 22:02:32 -0700372
Joe Perches6d32f7a2015-11-06 16:31:37 -0800373our $zero_initializer = qr{(?:(?:0[xX])?0+$Int_type?|NULL|false)\b};
374
Joe Perches691e6692010-03-05 13:43:51 -0800375our $logFunctions = qr{(?x:
Joe Perches6e60c022011-07-25 17:13:27 -0700376 printk(?:_ratelimited|_once|)|
Jacob Keller7d0b6592013-07-03 15:05:35 -0700377 (?:[a-z0-9]+_){1,2}(?:printk|emerg|alert|crit|err|warning|warn|notice|info|debug|dbg|vdbg|devel|cont|WARN)(?:_ratelimited|_once|)|
Joe Perches6e60c022011-07-25 17:13:27 -0700378 WARN(?:_RATELIMIT|_ONCE|)|
Joe Perchesb0531722011-05-24 17:13:40 -0700379 panic|
Joe Perches06668722013-11-12 15:10:07 -0800380 MODULE_[A-Z_]+|
381 seq_vprintf|seq_printf|seq_puts
Joe Perches691e6692010-03-05 13:43:51 -0800382)};
383
Joe Perches20112472011-07-25 17:13:23 -0700384our $signature_tags = qr{(?xi:
385 Signed-off-by:|
386 Acked-by:|
387 Tested-by:|
388 Reviewed-by:|
389 Reported-by:|
Mugunthan V N8543ae12013-04-29 16:18:17 -0700390 Suggested-by:|
Joe Perches20112472011-07-25 17:13:23 -0700391 To:|
392 Cc:
393)};
394
Joe Perches18130872014-08-06 16:11:22 -0700395our @typeListMisordered = (
396 qr{char\s+(?:un)?signed},
397 qr{int\s+(?:(?:un)?signed\s+)?short\s},
398 qr{int\s+short(?:\s+(?:un)?signed)},
399 qr{short\s+int(?:\s+(?:un)?signed)},
400 qr{(?:un)?signed\s+int\s+short},
401 qr{short\s+(?:un)?signed},
402 qr{long\s+int\s+(?:un)?signed},
403 qr{int\s+long\s+(?:un)?signed},
404 qr{long\s+(?:un)?signed\s+int},
405 qr{int\s+(?:un)?signed\s+long},
406 qr{int\s+(?:un)?signed},
407 qr{int\s+long\s+long\s+(?:un)?signed},
408 qr{long\s+long\s+int\s+(?:un)?signed},
409 qr{long\s+long\s+(?:un)?signed\s+int},
410 qr{long\s+long\s+(?:un)?signed},
411 qr{long\s+(?:un)?signed},
412);
413
Andy Whitcroft8905a672007-11-28 16:21:06 -0800414our @typeList = (
415 qr{void},
Joe Perches0c773d92014-08-06 16:11:20 -0700416 qr{(?:(?:un)?signed\s+)?char},
417 qr{(?:(?:un)?signed\s+)?short\s+int},
418 qr{(?:(?:un)?signed\s+)?short},
419 qr{(?:(?:un)?signed\s+)?int},
420 qr{(?:(?:un)?signed\s+)?long\s+int},
421 qr{(?:(?:un)?signed\s+)?long\s+long\s+int},
422 qr{(?:(?:un)?signed\s+)?long\s+long},
423 qr{(?:(?:un)?signed\s+)?long},
424 qr{(?:un)?signed},
Andy Whitcroft8905a672007-11-28 16:21:06 -0800425 qr{float},
426 qr{double},
427 qr{bool},
Andy Whitcroft8905a672007-11-28 16:21:06 -0800428 qr{struct\s+$Ident},
429 qr{union\s+$Ident},
430 qr{enum\s+$Ident},
431 qr{${Ident}_t},
432 qr{${Ident}_handler},
433 qr{${Ident}_handler_fn},
Joe Perches18130872014-08-06 16:11:22 -0700434 @typeListMisordered,
Andy Whitcroft8905a672007-11-28 16:21:06 -0800435);
Alex Dowad485ff232015-06-25 15:02:52 -0700436our @typeListFile = ();
Joe Perches8716de32013-09-11 14:24:05 -0700437our @typeListWithAttr = (
438 @typeList,
439 qr{struct\s+$InitAttribute\s+$Ident},
440 qr{union\s+$InitAttribute\s+$Ident},
441);
442
Andy Whitcroftc45dcab2008-06-05 22:46:01 -0700443our @modifierList = (
444 qr{fastcall},
445);
Alex Dowad485ff232015-06-25 15:02:52 -0700446our @modifierListFile = ();
Andy Whitcroft8905a672007-11-28 16:21:06 -0800447
Joe Perches24358802014-04-03 14:49:13 -0700448our @mode_permission_funcs = (
449 ["module_param", 3],
450 ["module_param_(?:array|named|string)", 4],
451 ["module_param_array_named", 5],
452 ["debugfs_create_(?:file|u8|u16|u32|u64|x8|x16|x32|x64|size_t|atomic_t|bool|blob|regset32|u32_array)", 2],
453 ["proc_create(?:_data|)", 2],
454 ["(?:CLASS|DEVICE|SENSOR)_ATTR", 2],
455);
456
Joe Perches515a2352014-04-03 14:49:24 -0700457#Create a search pattern for all these functions to speed up a loop below
458our $mode_perms_search = "";
459foreach my $entry (@mode_permission_funcs) {
460 $mode_perms_search .= '|' if ($mode_perms_search ne "");
461 $mode_perms_search .= $entry->[0];
462}
463
Joe Perchesb392c642015-04-16 12:44:16 -0700464our $mode_perms_world_writable = qr{
465 S_IWUGO |
466 S_IWOTH |
467 S_IRWXUGO |
468 S_IALLUGO |
469 0[0-7][0-7][2367]
470}x;
471
Wolfram Sang7840a942010-08-09 17:20:57 -0700472our $allowed_asm_includes = qr{(?x:
473 irq|
Sergey Ryazanovcdcee682014-10-13 15:51:44 -0700474 memory|
475 time|
476 reboot
Wolfram Sang7840a942010-08-09 17:20:57 -0700477)};
478# memory.h: ARM has a custom one
479
Kees Cook66b47b42014-10-13 15:51:57 -0700480# Load common spelling mistakes and build regular expression list.
481my $misspellings;
Kees Cook66b47b42014-10-13 15:51:57 -0700482my %spelling_fix;
Kees Cook66b47b42014-10-13 15:51:57 -0700483
Joe Perches36061e32014-12-10 15:51:43 -0800484if (open(my $spelling, '<', $spelling_file)) {
Joe Perches36061e32014-12-10 15:51:43 -0800485 while (<$spelling>) {
486 my $line = $_;
Kees Cook66b47b42014-10-13 15:51:57 -0700487
Joe Perches36061e32014-12-10 15:51:43 -0800488 $line =~ s/\s*\n?$//g;
489 $line =~ s/^\s*//g;
Kees Cook66b47b42014-10-13 15:51:57 -0700490
Joe Perches36061e32014-12-10 15:51:43 -0800491 next if ($line =~ m/^\s*#/);
492 next if ($line =~ m/^\s*$/);
Kees Cook66b47b42014-10-13 15:51:57 -0700493
Joe Perches36061e32014-12-10 15:51:43 -0800494 my ($suspect, $fix) = split(/\|\|/, $line);
495
Joe Perches36061e32014-12-10 15:51:43 -0800496 $spelling_fix{$suspect} = $fix;
497 }
498 close($spelling);
Joe Perches36061e32014-12-10 15:51:43 -0800499} else {
500 warn "No typos will be found - file '$spelling_file': $!\n";
Kees Cook66b47b42014-10-13 15:51:57 -0700501}
Kees Cook66b47b42014-10-13 15:51:57 -0700502
Joe Perchesebfd7d62015-04-16 12:44:14 -0700503if ($codespell) {
504 if (open(my $spelling, '<', $codespellfile)) {
505 while (<$spelling>) {
506 my $line = $_;
507
508 $line =~ s/\s*\n?$//g;
509 $line =~ s/^\s*//g;
510
511 next if ($line =~ m/^\s*#/);
512 next if ($line =~ m/^\s*$/);
513 next if ($line =~ m/, disabled/i);
514
515 $line =~ s/,.*$//;
516
517 my ($suspect, $fix) = split(/->/, $line);
518
519 $spelling_fix{$suspect} = $fix;
520 }
521 close($spelling);
522 } else {
523 warn "No codespell typos will be found - file '$codespellfile': $!\n";
524 }
525}
526
527$misspellings = join("|", sort keys %spelling_fix) if keys %spelling_fix;
528
Andy Whitcroft8905a672007-11-28 16:21:06 -0800529sub build_types {
Alex Dowad485ff232015-06-25 15:02:52 -0700530 my $mods = "(?x: \n" . join("|\n ", (@modifierList, @modifierListFile)) . "\n)";
531 my $all = "(?x: \n" . join("|\n ", (@typeList, @typeListFile)) . "\n)";
Joe Perches18130872014-08-06 16:11:22 -0700532 my $Misordered = "(?x: \n" . join("|\n ", @typeListMisordered) . "\n)";
Joe Perches8716de32013-09-11 14:24:05 -0700533 my $allWithAttr = "(?x: \n" . join("|\n ", @typeListWithAttr) . "\n)";
Andy Whitcroftc8cb2ca2008-07-23 21:28:57 -0700534 $Modifier = qr{(?:$Attribute|$Sparse|$mods)};
Joe Perchesab7e23f2015-04-16 12:44:22 -0700535 $BasicType = qr{
Joe Perchesab7e23f2015-04-16 12:44:22 -0700536 (?:$typeTypedefs\b)|
537 (?:${all}\b)
538 }x;
Andy Whitcroft8905a672007-11-28 16:21:06 -0800539 $NonptrType = qr{
Andy Whitcroftd2172eb2008-07-23 21:29:07 -0700540 (?:$Modifier\s+|const\s+)*
Andy Whitcroftcf655042008-03-04 14:28:20 -0800541 (?:
Andy Whitcroft6b48db22012-01-10 15:10:13 -0800542 (?:typeof|__typeof__)\s*\([^\)]*\)|
Andy Whitcroft8ed22ca2008-10-15 22:02:32 -0700543 (?:$typeTypedefs\b)|
Andy Whitcroftc45dcab2008-06-05 22:46:01 -0700544 (?:${all}\b)
Andy Whitcroftcf655042008-03-04 14:28:20 -0800545 )
Andy Whitcroftc8cb2ca2008-07-23 21:28:57 -0700546 (?:\s+$Modifier|\s+const)*
Andy Whitcroft8905a672007-11-28 16:21:06 -0800547 }x;
Joe Perches18130872014-08-06 16:11:22 -0700548 $NonptrTypeMisordered = qr{
549 (?:$Modifier\s+|const\s+)*
550 (?:
551 (?:${Misordered}\b)
552 )
553 (?:\s+$Modifier|\s+const)*
554 }x;
Joe Perches8716de32013-09-11 14:24:05 -0700555 $NonptrTypeWithAttr = qr{
556 (?:$Modifier\s+|const\s+)*
557 (?:
558 (?:typeof|__typeof__)\s*\([^\)]*\)|
559 (?:$typeTypedefs\b)|
560 (?:${allWithAttr}\b)
561 )
562 (?:\s+$Modifier|\s+const)*
563 }x;
Andy Whitcroft8905a672007-11-28 16:21:06 -0800564 $Type = qr{
Andy Whitcroftc45dcab2008-06-05 22:46:01 -0700565 $NonptrType
Joe Perches1574a292014-08-06 16:10:50 -0700566 (?:(?:\s|\*|\[\])+\s*const|(?:\s|\*\s*(?:const\s*)?|\[\])+|(?:\s*\[\s*\])+)?
Andy Whitcroftc8cb2ca2008-07-23 21:28:57 -0700567 (?:\s+$Inline|\s+$Modifier)*
Andy Whitcroft8905a672007-11-28 16:21:06 -0800568 }x;
Joe Perches18130872014-08-06 16:11:22 -0700569 $TypeMisordered = qr{
570 $NonptrTypeMisordered
571 (?:(?:\s|\*|\[\])+\s*const|(?:\s|\*\s*(?:const\s*)?|\[\])+|(?:\s*\[\s*\])+)?
572 (?:\s+$Inline|\s+$Modifier)*
573 }x;
Joe Perches91cb5192014-04-03 14:49:32 -0700574 $Declare = qr{(?:$Storage\s+(?:$Inline\s+)?)?$Type};
Joe Perches18130872014-08-06 16:11:22 -0700575 $DeclareMisordered = qr{(?:$Storage\s+(?:$Inline\s+)?)?$TypeMisordered};
Andy Whitcroft8905a672007-11-28 16:21:06 -0800576}
577build_types();
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700578
Joe Perches7d2367a2011-07-25 17:13:22 -0700579our $Typecast = qr{\s*(\(\s*$NonptrType\s*\)){0,1}\s*};
Joe Perchesd1fe9c02012-03-23 15:02:16 -0700580
581# Using $balanced_parens, $LvalOrFunc, or $FuncArg
582# requires at least perl version v5.10.0
583# Any use must be runtime checked with $^V
584
585our $balanced_parens = qr/(\((?:[^\(\)]++|(?-1))*\))/;
Joe Perches24358802014-04-03 14:49:13 -0700586our $LvalOrFunc = qr{((?:[\&\*]\s*)?$Lval)\s*($balanced_parens{0,1})\s*};
Joe Perchesc0a5c892015-02-13 14:38:21 -0800587our $FuncArg = qr{$Typecast{0,1}($LvalOrFunc|$Constant|$String)};
Joe Perches7d2367a2011-07-25 17:13:22 -0700588
Joe Perchesf8422302014-08-06 16:11:31 -0700589our $declaration_macros = qr{(?x:
Joe Perches3e838b62015-09-09 15:37:33 -0700590 (?:$Storage\s+)?(?:[A-Z_][A-Z0-9]*_){0,2}(?:DEFINE|DECLARE)(?:_[A-Z0-9]+){1,6}\s*\(|
Joe Perchesf8422302014-08-06 16:11:31 -0700591 (?:$Storage\s+)?LIST_HEAD\s*\(|
592 (?:$Storage\s+)?${Type}\s+uninitialized_var\s*\(
593)};
594
Joe Perches7d2367a2011-07-25 17:13:22 -0700595sub deparenthesize {
596 my ($string) = @_;
597 return "" if (!defined($string));
Joe Perches5b9553a2014-04-03 14:49:21 -0700598
599 while ($string =~ /^\s*\(.*\)\s*$/) {
600 $string =~ s@^\s*\(\s*@@;
601 $string =~ s@\s*\)\s*$@@;
602 }
603
Joe Perches7d2367a2011-07-25 17:13:22 -0700604 $string =~ s@\s+@ @g;
Joe Perches5b9553a2014-04-03 14:49:21 -0700605
Joe Perches7d2367a2011-07-25 17:13:22 -0700606 return $string;
607}
608
Joe Perches34456862013-07-03 15:05:34 -0700609sub seed_camelcase_file {
610 my ($file) = @_;
611
612 return if (!(-f $file));
613
614 local $/;
615
616 open(my $include_file, '<', "$file")
617 or warn "$P: Can't read '$file' $!\n";
618 my $text = <$include_file>;
619 close($include_file);
620
621 my @lines = split('\n', $text);
622
623 foreach my $line (@lines) {
624 next if ($line !~ /(?:[A-Z][a-z]|[a-z][A-Z])/);
625 if ($line =~ /^[ \t]*(?:#[ \t]*define|typedef\s+$Type)\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)/) {
626 $camelcase{$1} = 1;
Joe Perches11ea5162013-11-12 15:10:08 -0800627 } elsif ($line =~ /^\s*$Declare\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)\s*[\(\[,;]/) {
628 $camelcase{$1} = 1;
629 } 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 -0700630 $camelcase{$1} = 1;
631 }
632 }
633}
634
635my $camelcase_seeded = 0;
636sub seed_camelcase_includes {
637 return if ($camelcase_seeded);
638
639 my $files;
Joe Perchesc707a812013-07-08 16:00:43 -0700640 my $camelcase_cache = "";
641 my @include_files = ();
642
643 $camelcase_seeded = 1;
Joe Perches351b2a12013-07-03 15:05:36 -0700644
Richard Genoud3645e322014-02-10 14:25:32 -0800645 if (-e ".git") {
Joe Perches351b2a12013-07-03 15:05:36 -0700646 my $git_last_include_commit = `git log --no-merges --pretty=format:"%h%n" -1 -- include`;
647 chomp $git_last_include_commit;
Joe Perchesc707a812013-07-08 16:00:43 -0700648 $camelcase_cache = ".checkpatch-camelcase.git.$git_last_include_commit";
Joe Perches34456862013-07-03 15:05:34 -0700649 } else {
Joe Perchesc707a812013-07-08 16:00:43 -0700650 my $last_mod_date = 0;
Joe Perches34456862013-07-03 15:05:34 -0700651 $files = `find $root/include -name "*.h"`;
Joe Perchesc707a812013-07-08 16:00:43 -0700652 @include_files = split('\n', $files);
653 foreach my $file (@include_files) {
654 my $date = POSIX::strftime("%Y%m%d%H%M",
655 localtime((stat $file)[9]));
656 $last_mod_date = $date if ($last_mod_date < $date);
657 }
658 $camelcase_cache = ".checkpatch-camelcase.date.$last_mod_date";
Joe Perches34456862013-07-03 15:05:34 -0700659 }
Joe Perchesc707a812013-07-08 16:00:43 -0700660
661 if ($camelcase_cache ne "" && -f $camelcase_cache) {
662 open(my $camelcase_file, '<', "$camelcase_cache")
663 or warn "$P: Can't read '$camelcase_cache' $!\n";
664 while (<$camelcase_file>) {
665 chomp;
666 $camelcase{$_} = 1;
667 }
668 close($camelcase_file);
669
670 return;
671 }
672
Richard Genoud3645e322014-02-10 14:25:32 -0800673 if (-e ".git") {
Joe Perchesc707a812013-07-08 16:00:43 -0700674 $files = `git ls-files "include/*.h"`;
675 @include_files = split('\n', $files);
676 }
677
Joe Perches34456862013-07-03 15:05:34 -0700678 foreach my $file (@include_files) {
679 seed_camelcase_file($file);
680 }
Joe Perches351b2a12013-07-03 15:05:36 -0700681
Joe Perchesc707a812013-07-08 16:00:43 -0700682 if ($camelcase_cache ne "") {
Joe Perches351b2a12013-07-03 15:05:36 -0700683 unlink glob ".checkpatch-camelcase.*";
Joe Perchesc707a812013-07-08 16:00:43 -0700684 open(my $camelcase_file, '>', "$camelcase_cache")
685 or warn "$P: Can't write '$camelcase_cache' $!\n";
Joe Perches351b2a12013-07-03 15:05:36 -0700686 foreach (sort { lc($a) cmp lc($b) } keys(%camelcase)) {
687 print $camelcase_file ("$_\n");
688 }
689 close($camelcase_file);
690 }
Joe Perches34456862013-07-03 15:05:34 -0700691}
692
Joe Perchesd311cd42014-08-06 16:10:57 -0700693sub git_commit_info {
694 my ($commit, $id, $desc) = @_;
695
696 return ($id, $desc) if ((which("git") eq "") || !(-e ".git"));
697
698 my $output = `git log --no-color --format='%H %s' -1 $commit 2>&1`;
699 $output =~ s/^\s*//gm;
700 my @lines = split("\n", $output);
701
Joe Perches0d7835f2015-02-13 14:38:35 -0800702 return ($id, $desc) if ($#lines < 0);
703
Joe Perchesd311cd42014-08-06 16:10:57 -0700704 if ($lines[0] =~ /^error: short SHA1 $commit is ambiguous\./) {
705# Maybe one day convert this block of bash into something that returns
706# all matching commit ids, but it's very slow...
707#
708# echo "checking commits $1..."
709# git rev-list --remotes | grep -i "^$1" |
710# while read line ; do
711# git log --format='%H %s' -1 $line |
712# echo "commit $(cut -c 1-12,41-)"
713# done
714 } elsif ($lines[0] =~ /^fatal: ambiguous argument '$commit': unknown revision or path not in the working tree\./) {
715 } else {
716 $id = substr($lines[0], 0, 12);
717 $desc = substr($lines[0], 41);
718 }
719
720 return ($id, $desc);
721}
722
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700723$chk_signoff = 0 if ($file);
724
Andy Whitcroft00df3442007-06-08 13:47:06 -0700725my @rawlines = ();
Andy Whitcroftc2fdda02008-02-08 04:20:54 -0800726my @lines = ();
Joe Perches3705ce52013-07-03 15:05:31 -0700727my @fixed = ();
Joe Perchesd752fcc2014-08-06 16:11:05 -0700728my @fixed_inserted = ();
729my @fixed_deleted = ();
Joe Perches194f66f2014-08-06 16:11:03 -0700730my $fixlinenr = -1;
731
Andy Whitcroftc2fdda02008-02-08 04:20:54 -0800732my $vname;
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700733for my $filename (@ARGV) {
Andy Whitcroft21caa132009-01-06 14:41:30 -0800734 my $FILE;
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700735 if ($file) {
Andy Whitcroft21caa132009-01-06 14:41:30 -0800736 open($FILE, '-|', "diff -u /dev/null $filename") ||
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700737 die "$P: $filename: diff failed - $!\n";
Andy Whitcroft21caa132009-01-06 14:41:30 -0800738 } elsif ($filename eq '-') {
739 open($FILE, '<&STDIN');
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700740 } else {
Andy Whitcroft21caa132009-01-06 14:41:30 -0800741 open($FILE, '<', "$filename") ||
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700742 die "$P: $filename: open failed - $!\n";
Andy Whitcroft0a920b52007-06-01 00:46:48 -0700743 }
Andy Whitcroftc2fdda02008-02-08 04:20:54 -0800744 if ($filename eq '-') {
745 $vname = 'Your patch';
746 } else {
747 $vname = $filename;
748 }
Andy Whitcroft21caa132009-01-06 14:41:30 -0800749 while (<$FILE>) {
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700750 chomp;
751 push(@rawlines, $_);
752 }
Andy Whitcroft21caa132009-01-06 14:41:30 -0800753 close($FILE);
Joe Perchesd8469f12015-06-25 15:03:00 -0700754
755 if ($#ARGV > 0 && $quiet == 0) {
756 print '-' x length($vname) . "\n";
757 print "$vname\n";
758 print '-' x length($vname) . "\n";
759 }
760
Andy Whitcroftc2fdda02008-02-08 04:20:54 -0800761 if (!process($filename)) {
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700762 $exit = 1;
763 }
764 @rawlines = ();
Andy Whitcroft13214ad2008-02-08 04:22:03 -0800765 @lines = ();
Joe Perches3705ce52013-07-03 15:05:31 -0700766 @fixed = ();
Joe Perchesd752fcc2014-08-06 16:11:05 -0700767 @fixed_inserted = ();
768 @fixed_deleted = ();
Joe Perches194f66f2014-08-06 16:11:03 -0700769 $fixlinenr = -1;
Alex Dowad485ff232015-06-25 15:02:52 -0700770 @modifierListFile = ();
771 @typeListFile = ();
772 build_types();
Andy Whitcroft0a920b52007-06-01 00:46:48 -0700773}
774
Joe Perchesd8469f12015-06-25 15:03:00 -0700775if (!$quiet) {
Joe Perches3c816e42015-06-25 15:03:29 -0700776 hash_show_words(\%use_type, "Used");
777 hash_show_words(\%ignore_type, "Ignored");
778
Joe Perchesd8469f12015-06-25 15:03:00 -0700779 if ($^V lt 5.10.0) {
780 print << "EOM"
781
782NOTE: perl $^V is not modern enough to detect all possible issues.
783 An upgrade to at least perl v5.10.0 is suggested.
784EOM
785 }
786 if ($exit) {
787 print << "EOM"
788
789NOTE: If any of the errors are false positives, please report
790 them to the maintainer, see CHECKPATCH in MAINTAINERS.
791EOM
792 }
793}
794
Andy Whitcroft0a920b52007-06-01 00:46:48 -0700795exit($exit);
796
797sub top_of_kernel_tree {
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700798 my ($root) = @_;
799
800 my @tree_check = (
801 "COPYING", "CREDITS", "Kbuild", "MAINTAINERS", "Makefile",
802 "README", "Documentation", "arch", "include", "drivers",
803 "fs", "init", "ipc", "kernel", "lib", "scripts",
804 );
805
806 foreach my $check (@tree_check) {
807 if (! -e $root . '/' . $check) {
808 return 0;
809 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -0700810 }
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700811 return 1;
Joe Perches8f26b832012-10-04 17:13:32 -0700812}
Andy Whitcroft0a920b52007-06-01 00:46:48 -0700813
Joe Perches20112472011-07-25 17:13:23 -0700814sub parse_email {
815 my ($formatted_email) = @_;
816
817 my $name = "";
818 my $address = "";
819 my $comment = "";
820
821 if ($formatted_email =~ /^(.*)<(\S+\@\S+)>(.*)$/) {
822 $name = $1;
823 $address = $2;
824 $comment = $3 if defined $3;
825 } elsif ($formatted_email =~ /^\s*<(\S+\@\S+)>(.*)$/) {
826 $address = $1;
827 $comment = $2 if defined $2;
828 } elsif ($formatted_email =~ /(\S+\@\S+)(.*)$/) {
829 $address = $1;
830 $comment = $2 if defined $2;
831 $formatted_email =~ s/$address.*$//;
832 $name = $formatted_email;
Joe Perches3705ce52013-07-03 15:05:31 -0700833 $name = trim($name);
Joe Perches20112472011-07-25 17:13:23 -0700834 $name =~ s/^\"|\"$//g;
835 # If there's a name left after stripping spaces and
836 # leading quotes, and the address doesn't have both
837 # leading and trailing angle brackets, the address
838 # is invalid. ie:
839 # "joe smith joe@smith.com" bad
840 # "joe smith <joe@smith.com" bad
841 if ($name ne "" && $address !~ /^<[^>]+>$/) {
842 $name = "";
843 $address = "";
844 $comment = "";
845 }
846 }
847
Joe Perches3705ce52013-07-03 15:05:31 -0700848 $name = trim($name);
Joe Perches20112472011-07-25 17:13:23 -0700849 $name =~ s/^\"|\"$//g;
Joe Perches3705ce52013-07-03 15:05:31 -0700850 $address = trim($address);
Joe Perches20112472011-07-25 17:13:23 -0700851 $address =~ s/^\<|\>$//g;
852
853 if ($name =~ /[^\w \-]/i) { ##has "must quote" chars
854 $name =~ s/(?<!\\)"/\\"/g; ##escape quotes
855 $name = "\"$name\"";
856 }
857
858 return ($name, $address, $comment);
859}
860
861sub format_email {
862 my ($name, $address) = @_;
863
864 my $formatted_email;
865
Joe Perches3705ce52013-07-03 15:05:31 -0700866 $name = trim($name);
Joe Perches20112472011-07-25 17:13:23 -0700867 $name =~ s/^\"|\"$//g;
Joe Perches3705ce52013-07-03 15:05:31 -0700868 $address = trim($address);
Joe Perches20112472011-07-25 17:13:23 -0700869
870 if ($name =~ /[^\w \-]/i) { ##has "must quote" chars
871 $name =~ s/(?<!\\)"/\\"/g; ##escape quotes
872 $name = "\"$name\"";
873 }
874
875 if ("$name" eq "") {
876 $formatted_email = "$address";
877 } else {
878 $formatted_email = "$name <$address>";
879 }
880
881 return $formatted_email;
882}
883
Joe Perchesd311cd42014-08-06 16:10:57 -0700884sub which {
Joe Perchesbd474ca2014-08-06 16:11:10 -0700885 my ($bin) = @_;
Joe Perchesd311cd42014-08-06 16:10:57 -0700886
Joe Perchesbd474ca2014-08-06 16:11:10 -0700887 foreach my $path (split(/:/, $ENV{PATH})) {
888 if (-e "$path/$bin") {
889 return "$path/$bin";
890 }
Joe Perchesd311cd42014-08-06 16:10:57 -0700891 }
Joe Perchesd311cd42014-08-06 16:10:57 -0700892
Joe Perchesbd474ca2014-08-06 16:11:10 -0700893 return "";
Joe Perchesd311cd42014-08-06 16:10:57 -0700894}
895
Joe Perches000d1cc12011-07-25 17:13:25 -0700896sub which_conf {
897 my ($conf) = @_;
898
899 foreach my $path (split(/:/, ".:$ENV{HOME}:.scripts")) {
900 if (-e "$path/$conf") {
901 return "$path/$conf";
902 }
903 }
904
905 return "";
906}
907
Andy Whitcroft0a920b52007-06-01 00:46:48 -0700908sub expand_tabs {
909 my ($str) = @_;
910
911 my $res = '';
912 my $n = 0;
913 for my $c (split(//, $str)) {
914 if ($c eq "\t") {
915 $res .= ' ';
916 $n++;
917 for (; ($n % 8) != 0; $n++) {
918 $res .= ' ';
919 }
920 next;
921 }
922 $res .= $c;
923 $n++;
924 }
925
926 return $res;
927}
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700928sub copy_spacing {
Andy Whitcroft773647a2008-03-28 14:15:58 -0700929 (my $res = shift) =~ tr/\t/ /c;
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700930 return $res;
931}
Andy Whitcroft0a920b52007-06-01 00:46:48 -0700932
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -0700933sub line_stats {
934 my ($line) = @_;
935
936 # Drop the diff line leader and expand tabs
937 $line =~ s/^.//;
938 $line = expand_tabs($line);
939
940 # Pick the indent from the front of the line.
941 my ($white) = ($line =~ /^(\s*)/);
942
943 return (length($line), length($white));
944}
945
Andy Whitcroft773647a2008-03-28 14:15:58 -0700946my $sanitise_quote = '';
947
948sub sanitise_line_reset {
949 my ($in_comment) = @_;
950
951 if ($in_comment) {
952 $sanitise_quote = '*/';
953 } else {
954 $sanitise_quote = '';
955 }
956}
Andy Whitcroft00df3442007-06-08 13:47:06 -0700957sub sanitise_line {
958 my ($line) = @_;
959
960 my $res = '';
961 my $l = '';
962
Andy Whitcroftc2fdda02008-02-08 04:20:54 -0800963 my $qlen = 0;
Andy Whitcroft773647a2008-03-28 14:15:58 -0700964 my $off = 0;
965 my $c;
Andy Whitcroft00df3442007-06-08 13:47:06 -0700966
Andy Whitcroft773647a2008-03-28 14:15:58 -0700967 # Always copy over the diff marker.
968 $res = substr($line, 0, 1);
969
970 for ($off = 1; $off < length($line); $off++) {
971 $c = substr($line, $off, 1);
972
973 # Comments we are wacking completly including the begin
974 # and end, all to $;.
975 if ($sanitise_quote eq '' && substr($line, $off, 2) eq '/*') {
976 $sanitise_quote = '*/';
977
978 substr($res, $off, 2, "$;$;");
979 $off++;
980 next;
Andy Whitcroftc2fdda02008-02-08 04:20:54 -0800981 }
Andy Whitcroft81bc0e02008-10-15 22:02:26 -0700982 if ($sanitise_quote eq '*/' && substr($line, $off, 2) eq '*/') {
Andy Whitcroft773647a2008-03-28 14:15:58 -0700983 $sanitise_quote = '';
984 substr($res, $off, 2, "$;$;");
985 $off++;
986 next;
987 }
Daniel Walker113f04a2009-09-21 17:04:35 -0700988 if ($sanitise_quote eq '' && substr($line, $off, 2) eq '//') {
989 $sanitise_quote = '//';
990
991 substr($res, $off, 2, $sanitise_quote);
992 $off++;
993 next;
994 }
Andy Whitcroft773647a2008-03-28 14:15:58 -0700995
996 # A \ in a string means ignore the next character.
997 if (($sanitise_quote eq "'" || $sanitise_quote eq '"') &&
998 $c eq "\\") {
999 substr($res, $off, 2, 'XX');
1000 $off++;
1001 next;
1002 }
1003 # Regular quotes.
1004 if ($c eq "'" || $c eq '"') {
1005 if ($sanitise_quote eq '') {
1006 $sanitise_quote = $c;
1007
1008 substr($res, $off, 1, $c);
Andy Whitcroft00df3442007-06-08 13:47:06 -07001009 next;
Andy Whitcroft773647a2008-03-28 14:15:58 -07001010 } elsif ($sanitise_quote eq $c) {
1011 $sanitise_quote = '';
Andy Whitcroft00df3442007-06-08 13:47:06 -07001012 }
1013 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07001014
Andy Whitcroftfae17da2009-01-06 14:41:20 -08001015 #print "c<$c> SQ<$sanitise_quote>\n";
Andy Whitcroft773647a2008-03-28 14:15:58 -07001016 if ($off != 0 && $sanitise_quote eq '*/' && $c ne "\t") {
1017 substr($res, $off, 1, $;);
Daniel Walker113f04a2009-09-21 17:04:35 -07001018 } elsif ($off != 0 && $sanitise_quote eq '//' && $c ne "\t") {
1019 substr($res, $off, 1, $;);
Andy Whitcroft773647a2008-03-28 14:15:58 -07001020 } elsif ($off != 0 && $sanitise_quote && $c ne "\t") {
1021 substr($res, $off, 1, 'X');
Andy Whitcroft00df3442007-06-08 13:47:06 -07001022 } else {
Andy Whitcroft773647a2008-03-28 14:15:58 -07001023 substr($res, $off, 1, $c);
Andy Whitcroft00df3442007-06-08 13:47:06 -07001024 }
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001025 }
1026
Daniel Walker113f04a2009-09-21 17:04:35 -07001027 if ($sanitise_quote eq '//') {
1028 $sanitise_quote = '';
1029 }
1030
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001031 # The pathname on a #include may be surrounded by '<' and '>'.
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07001032 if ($res =~ /^.\s*\#\s*include\s+\<(.*)\>/) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001033 my $clean = 'X' x length($1);
1034 $res =~ s@\<.*\>@<$clean>@;
1035
1036 # The whole of a #error is a string.
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07001037 } elsif ($res =~ /^.\s*\#\s*(?:error|warning)\s+(.*)\b/) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001038 my $clean = 'X' x length($1);
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07001039 $res =~ s@(\#\s*(?:error|warning)\s+).*@$1$clean@;
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001040 }
1041
Andy Whitcroft00df3442007-06-08 13:47:06 -07001042 return $res;
1043}
1044
Joe Perchesa6962d72013-04-29 16:18:13 -07001045sub get_quoted_string {
1046 my ($line, $rawline) = @_;
1047
Joe Perches33acb542015-06-25 15:02:54 -07001048 return "" if ($line !~ m/($String)/g);
Joe Perchesa6962d72013-04-29 16:18:13 -07001049 return substr($rawline, $-[0], $+[0] - $-[0]);
1050}
1051
Andy Whitcroft8905a672007-11-28 16:21:06 -08001052sub ctx_statement_block {
1053 my ($linenr, $remain, $off) = @_;
1054 my $line = $linenr - 1;
1055 my $blk = '';
1056 my $soff = $off;
1057 my $coff = $off - 1;
Andy Whitcroft773647a2008-03-28 14:15:58 -07001058 my $coff_set = 0;
Andy Whitcroft8905a672007-11-28 16:21:06 -08001059
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001060 my $loff = 0;
1061
Andy Whitcroft8905a672007-11-28 16:21:06 -08001062 my $type = '';
1063 my $level = 0;
Andy Whitcrofta2750642009-01-15 13:51:04 -08001064 my @stack = ();
Andy Whitcroftcf655042008-03-04 14:28:20 -08001065 my $p;
Andy Whitcroft8905a672007-11-28 16:21:06 -08001066 my $c;
1067 my $len = 0;
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001068
1069 my $remainder;
Andy Whitcroft8905a672007-11-28 16:21:06 -08001070 while (1) {
Andy Whitcrofta2750642009-01-15 13:51:04 -08001071 @stack = (['', 0]) if ($#stack == -1);
1072
Andy Whitcroft773647a2008-03-28 14:15:58 -07001073 #warn "CSB: blk<$blk> remain<$remain>\n";
Andy Whitcroft8905a672007-11-28 16:21:06 -08001074 # If we are about to drop off the end, pull in more
1075 # context.
1076 if ($off >= $len) {
1077 for (; $remain > 0; $line++) {
Andy Whitcroftdea33492008-10-15 22:02:25 -07001078 last if (!defined $lines[$line]);
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001079 next if ($lines[$line] =~ /^-/);
Andy Whitcroft8905a672007-11-28 16:21:06 -08001080 $remain--;
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001081 $loff = $len;
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001082 $blk .= $lines[$line] . "\n";
Andy Whitcroft8905a672007-11-28 16:21:06 -08001083 $len = length($blk);
1084 $line++;
1085 last;
1086 }
1087 # Bail if there is no further context.
1088 #warn "CSB: blk<$blk> off<$off> len<$len>\n";
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001089 if ($off >= $len) {
Andy Whitcroft8905a672007-11-28 16:21:06 -08001090 last;
1091 }
Andy Whitcroftf74bd192012-01-10 15:09:54 -08001092 if ($level == 0 && substr($blk, $off) =~ /^.\s*#\s*define/) {
1093 $level++;
1094 $type = '#';
1095 }
Andy Whitcroft8905a672007-11-28 16:21:06 -08001096 }
Andy Whitcroftcf655042008-03-04 14:28:20 -08001097 $p = $c;
Andy Whitcroft8905a672007-11-28 16:21:06 -08001098 $c = substr($blk, $off, 1);
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001099 $remainder = substr($blk, $off);
Andy Whitcroft8905a672007-11-28 16:21:06 -08001100
Andy Whitcroft773647a2008-03-28 14:15:58 -07001101 #warn "CSB: c<$c> type<$type> level<$level> remainder<$remainder> coff_set<$coff_set>\n";
Andy Whitcroft4635f4f2009-01-06 14:41:27 -08001102
1103 # Handle nested #if/#else.
1104 if ($remainder =~ /^#\s*(?:ifndef|ifdef|if)\s/) {
1105 push(@stack, [ $type, $level ]);
1106 } elsif ($remainder =~ /^#\s*(?:else|elif)\b/) {
1107 ($type, $level) = @{$stack[$#stack - 1]};
1108 } elsif ($remainder =~ /^#\s*endif\b/) {
1109 ($type, $level) = @{pop(@stack)};
1110 }
1111
Andy Whitcroft8905a672007-11-28 16:21:06 -08001112 # Statement ends at the ';' or a close '}' at the
1113 # outermost level.
1114 if ($level == 0 && $c eq ';') {
1115 last;
1116 }
1117
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001118 # An else is really a conditional as long as its not else if
Andy Whitcroft773647a2008-03-28 14:15:58 -07001119 if ($level == 0 && $coff_set == 0 &&
1120 (!defined($p) || $p =~ /(?:\s|\}|\+)/) &&
1121 $remainder =~ /^(else)(?:\s|{)/ &&
1122 $remainder !~ /^else\s+if\b/) {
1123 $coff = $off + length($1) - 1;
1124 $coff_set = 1;
1125 #warn "CSB: mark coff<$coff> soff<$soff> 1<$1>\n";
1126 #warn "[" . substr($blk, $soff, $coff - $soff + 1) . "]\n";
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001127 }
1128
Andy Whitcroft8905a672007-11-28 16:21:06 -08001129 if (($type eq '' || $type eq '(') && $c eq '(') {
1130 $level++;
1131 $type = '(';
1132 }
1133 if ($type eq '(' && $c eq ')') {
1134 $level--;
1135 $type = ($level != 0)? '(' : '';
1136
1137 if ($level == 0 && $coff < $soff) {
1138 $coff = $off;
Andy Whitcroft773647a2008-03-28 14:15:58 -07001139 $coff_set = 1;
1140 #warn "CSB: mark coff<$coff>\n";
Andy Whitcroft8905a672007-11-28 16:21:06 -08001141 }
1142 }
1143 if (($type eq '' || $type eq '{') && $c eq '{') {
1144 $level++;
1145 $type = '{';
1146 }
1147 if ($type eq '{' && $c eq '}') {
1148 $level--;
1149 $type = ($level != 0)? '{' : '';
1150
1151 if ($level == 0) {
Patrick Pannutob998e002010-08-09 17:21:03 -07001152 if (substr($blk, $off + 1, 1) eq ';') {
1153 $off++;
1154 }
Andy Whitcroft8905a672007-11-28 16:21:06 -08001155 last;
1156 }
1157 }
Andy Whitcroftf74bd192012-01-10 15:09:54 -08001158 # Preprocessor commands end at the newline unless escaped.
1159 if ($type eq '#' && $c eq "\n" && $p ne "\\") {
1160 $level--;
1161 $type = '';
1162 $off++;
1163 last;
1164 }
Andy Whitcroft8905a672007-11-28 16:21:06 -08001165 $off++;
1166 }
Andy Whitcrofta3bb97a2008-07-23 21:29:00 -07001167 # We are truly at the end, so shuffle to the next line.
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001168 if ($off == $len) {
Andy Whitcrofta3bb97a2008-07-23 21:29:00 -07001169 $loff = $len + 1;
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001170 $line++;
1171 $remain--;
1172 }
Andy Whitcroft8905a672007-11-28 16:21:06 -08001173
1174 my $statement = substr($blk, $soff, $off - $soff + 1);
1175 my $condition = substr($blk, $soff, $coff - $soff + 1);
1176
1177 #warn "STATEMENT<$statement>\n";
1178 #warn "CONDITION<$condition>\n";
1179
Andy Whitcroft773647a2008-03-28 14:15:58 -07001180 #print "coff<$coff> soff<$off> loff<$loff>\n";
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001181
1182 return ($statement, $condition,
1183 $line, $remain + 1, $off - $loff + 1, $level);
1184}
1185
Andy Whitcroftcf655042008-03-04 14:28:20 -08001186sub statement_lines {
1187 my ($stmt) = @_;
1188
1189 # Strip the diff line prefixes and rip blank lines at start and end.
1190 $stmt =~ s/(^|\n)./$1/g;
1191 $stmt =~ s/^\s*//;
1192 $stmt =~ s/\s*$//;
1193
1194 my @stmt_lines = ($stmt =~ /\n/g);
1195
1196 return $#stmt_lines + 2;
1197}
1198
1199sub statement_rawlines {
1200 my ($stmt) = @_;
1201
1202 my @stmt_lines = ($stmt =~ /\n/g);
1203
1204 return $#stmt_lines + 2;
1205}
1206
1207sub statement_block_size {
1208 my ($stmt) = @_;
1209
1210 $stmt =~ s/(^|\n)./$1/g;
1211 $stmt =~ s/^\s*{//;
1212 $stmt =~ s/}\s*$//;
1213 $stmt =~ s/^\s*//;
1214 $stmt =~ s/\s*$//;
1215
1216 my @stmt_lines = ($stmt =~ /\n/g);
1217 my @stmt_statements = ($stmt =~ /;/g);
1218
1219 my $stmt_lines = $#stmt_lines + 2;
1220 my $stmt_statements = $#stmt_statements + 1;
1221
1222 if ($stmt_lines > $stmt_statements) {
1223 return $stmt_lines;
1224 } else {
1225 return $stmt_statements;
1226 }
1227}
1228
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001229sub ctx_statement_full {
1230 my ($linenr, $remain, $off) = @_;
1231 my ($statement, $condition, $level);
1232
1233 my (@chunks);
1234
Andy Whitcroftcf655042008-03-04 14:28:20 -08001235 # Grab the first conditional/block pair.
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001236 ($statement, $condition, $linenr, $remain, $off, $level) =
1237 ctx_statement_block($linenr, $remain, $off);
Andy Whitcroft773647a2008-03-28 14:15:58 -07001238 #print "F: c<$condition> s<$statement> remain<$remain>\n";
Andy Whitcroftcf655042008-03-04 14:28:20 -08001239 push(@chunks, [ $condition, $statement ]);
1240 if (!($remain > 0 && $condition =~ /^\s*(?:\n[+-])?\s*(?:if|else|do)\b/s)) {
1241 return ($level, $linenr, @chunks);
1242 }
1243
1244 # Pull in the following conditional/block pairs and see if they
1245 # could continue the statement.
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001246 for (;;) {
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001247 ($statement, $condition, $linenr, $remain, $off, $level) =
1248 ctx_statement_block($linenr, $remain, $off);
Andy Whitcroftcf655042008-03-04 14:28:20 -08001249 #print "C: c<$condition> s<$statement> remain<$remain>\n";
Andy Whitcroft773647a2008-03-28 14:15:58 -07001250 last if (!($remain > 0 && $condition =~ /^(?:\s*\n[+-])*\s*(?:else|do)\b/s));
Andy Whitcroftcf655042008-03-04 14:28:20 -08001251 #print "C: push\n";
1252 push(@chunks, [ $condition, $statement ]);
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001253 }
1254
1255 return ($level, $linenr, @chunks);
Andy Whitcroft8905a672007-11-28 16:21:06 -08001256}
1257
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001258sub ctx_block_get {
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001259 my ($linenr, $remain, $outer, $open, $close, $off) = @_;
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001260 my $line;
1261 my $start = $linenr - 1;
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001262 my $blk = '';
1263 my @o;
1264 my @c;
1265 my @res = ();
1266
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001267 my $level = 0;
Andy Whitcroft4635f4f2009-01-06 14:41:27 -08001268 my @stack = ($level);
Andy Whitcroft00df3442007-06-08 13:47:06 -07001269 for ($line = $start; $remain > 0; $line++) {
1270 next if ($rawlines[$line] =~ /^-/);
1271 $remain--;
1272
1273 $blk .= $rawlines[$line];
Andy Whitcroft4635f4f2009-01-06 14:41:27 -08001274
1275 # Handle nested #if/#else.
Andy Whitcroft01464f32010-10-26 14:23:19 -07001276 if ($lines[$line] =~ /^.\s*#\s*(?:ifndef|ifdef|if)\s/) {
Andy Whitcroft4635f4f2009-01-06 14:41:27 -08001277 push(@stack, $level);
Andy Whitcroft01464f32010-10-26 14:23:19 -07001278 } elsif ($lines[$line] =~ /^.\s*#\s*(?:else|elif)\b/) {
Andy Whitcroft4635f4f2009-01-06 14:41:27 -08001279 $level = $stack[$#stack - 1];
Andy Whitcroft01464f32010-10-26 14:23:19 -07001280 } elsif ($lines[$line] =~ /^.\s*#\s*endif\b/) {
Andy Whitcroft4635f4f2009-01-06 14:41:27 -08001281 $level = pop(@stack);
1282 }
1283
Andy Whitcroft01464f32010-10-26 14:23:19 -07001284 foreach my $c (split(//, $lines[$line])) {
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001285 ##print "C<$c>L<$level><$open$close>O<$off>\n";
1286 if ($off > 0) {
1287 $off--;
1288 next;
1289 }
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001290
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001291 if ($c eq $close && $level > 0) {
1292 $level--;
1293 last if ($level == 0);
1294 } elsif ($c eq $open) {
1295 $level++;
1296 }
1297 }
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001298
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001299 if (!$outer || $level <= 1) {
Andy Whitcroft00df3442007-06-08 13:47:06 -07001300 push(@res, $rawlines[$line]);
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001301 }
1302
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001303 last if ($level == 0);
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001304 }
1305
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001306 return ($level, @res);
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001307}
1308sub ctx_block_outer {
1309 my ($linenr, $remain) = @_;
1310
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001311 my ($level, @r) = ctx_block_get($linenr, $remain, 1, '{', '}', 0);
1312 return @r;
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001313}
1314sub ctx_block {
1315 my ($linenr, $remain) = @_;
1316
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001317 my ($level, @r) = ctx_block_get($linenr, $remain, 0, '{', '}', 0);
1318 return @r;
Andy Whitcroft653d4872007-06-23 17:16:34 -07001319}
1320sub ctx_statement {
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001321 my ($linenr, $remain, $off) = @_;
1322
1323 my ($level, @r) = ctx_block_get($linenr, $remain, 0, '(', ')', $off);
1324 return @r;
1325}
1326sub ctx_block_level {
Andy Whitcroft653d4872007-06-23 17:16:34 -07001327 my ($linenr, $remain) = @_;
1328
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001329 return ctx_block_get($linenr, $remain, 0, '{', '}', 0);
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001330}
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07001331sub ctx_statement_level {
1332 my ($linenr, $remain, $off) = @_;
1333
1334 return ctx_block_get($linenr, $remain, 0, '(', ')', $off);
1335}
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001336
1337sub ctx_locate_comment {
1338 my ($first_line, $end_line) = @_;
1339
1340 # Catch a comment on the end of the line itself.
Andy Whitcroftbeae6332008-07-23 21:28:59 -07001341 my ($current_comment) = ($rawlines[$end_line - 1] =~ m@.*(/\*.*\*/)\s*(?:\\\s*)?$@);
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001342 return $current_comment if (defined $current_comment);
1343
1344 # Look through the context and try and figure out if there is a
1345 # comment.
1346 my $in_comment = 0;
1347 $current_comment = '';
1348 for (my $linenr = $first_line; $linenr < $end_line; $linenr++) {
Andy Whitcroft00df3442007-06-08 13:47:06 -07001349 my $line = $rawlines[$linenr - 1];
1350 #warn " $line\n";
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001351 if ($linenr == $first_line and $line =~ m@^.\s*\*@) {
1352 $in_comment = 1;
1353 }
1354 if ($line =~ m@/\*@) {
1355 $in_comment = 1;
1356 }
1357 if (!$in_comment && $current_comment ne '') {
1358 $current_comment = '';
1359 }
1360 $current_comment .= $line . "\n" if ($in_comment);
1361 if ($line =~ m@\*/@) {
1362 $in_comment = 0;
1363 }
1364 }
1365
1366 chomp($current_comment);
1367 return($current_comment);
1368}
1369sub ctx_has_comment {
1370 my ($first_line, $end_line) = @_;
1371 my $cmt = ctx_locate_comment($first_line, $end_line);
1372
Andy Whitcroft00df3442007-06-08 13:47:06 -07001373 ##print "LINE: $rawlines[$end_line - 1 ]\n";
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001374 ##print "CMMT: $cmt\n";
1375
1376 return ($cmt ne '');
1377}
1378
Andy Whitcroft4d001e42008-10-15 22:02:21 -07001379sub raw_line {
1380 my ($linenr, $cnt) = @_;
1381
1382 my $offset = $linenr - 1;
1383 $cnt++;
1384
1385 my $line;
1386 while ($cnt) {
1387 $line = $rawlines[$offset++];
1388 next if (defined($line) && $line =~ /^-/);
1389 $cnt--;
1390 }
1391
1392 return $line;
1393}
1394
Andy Whitcroft0a920b52007-06-01 00:46:48 -07001395sub cat_vet {
1396 my ($vet) = @_;
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07001397 my ($res, $coded);
Andy Whitcroft0a920b52007-06-01 00:46:48 -07001398
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07001399 $res = '';
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001400 while ($vet =~ /([^[:cntrl:]]*)([[:cntrl:]]|$)/g) {
1401 $res .= $1;
1402 if ($2 ne '') {
1403 $coded = sprintf("^%c", unpack('C', $2) + 64);
1404 $res .= $coded;
1405 }
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07001406 }
1407 $res =~ s/$/\$/;
Andy Whitcroft0a920b52007-06-01 00:46:48 -07001408
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07001409 return $res;
Andy Whitcroft0a920b52007-06-01 00:46:48 -07001410}
1411
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001412my $av_preprocessor = 0;
Andy Whitcroftcf655042008-03-04 14:28:20 -08001413my $av_pending;
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001414my @av_paren_type;
Andy Whitcroft1f65f942008-07-23 21:29:10 -07001415my $av_pend_colon;
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001416
1417sub annotate_reset {
1418 $av_preprocessor = 0;
Andy Whitcroftcf655042008-03-04 14:28:20 -08001419 $av_pending = '_';
1420 @av_paren_type = ('E');
Andy Whitcroft1f65f942008-07-23 21:29:10 -07001421 $av_pend_colon = 'O';
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001422}
1423
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001424sub annotate_values {
1425 my ($stream, $type) = @_;
1426
1427 my $res;
Andy Whitcroft1f65f942008-07-23 21:29:10 -07001428 my $var = '_' x length($stream);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001429 my $cur = $stream;
1430
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001431 print "$stream\n" if ($dbg_values > 1);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001432
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001433 while (length($cur)) {
Andy Whitcroft773647a2008-03-28 14:15:58 -07001434 @av_paren_type = ('E') if ($#av_paren_type < 0);
Andy Whitcroftcf655042008-03-04 14:28:20 -08001435 print " <" . join('', @av_paren_type) .
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07001436 "> <$type> <$av_pending>" if ($dbg_values > 1);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001437 if ($cur =~ /^(\s+)/o) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001438 print "WS($1)\n" if ($dbg_values > 1);
1439 if ($1 =~ /\n/ && $av_preprocessor) {
Andy Whitcroftcf655042008-03-04 14:28:20 -08001440 $type = pop(@av_paren_type);
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001441 $av_preprocessor = 0;
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001442 }
1443
Florian Micklerc023e4732011-01-12 16:59:58 -08001444 } elsif ($cur =~ /^(\(\s*$Type\s*)\)/ && $av_pending eq '_') {
Andy Whitcroft9446ef52010-10-26 14:23:13 -07001445 print "CAST($1)\n" if ($dbg_values > 1);
1446 push(@av_paren_type, $type);
Andy Whitcroftaddcdce2012-01-10 15:10:11 -08001447 $type = 'c';
Andy Whitcroft9446ef52010-10-26 14:23:13 -07001448
Andy Whitcrofte91b6e22010-10-26 14:23:11 -07001449 } elsif ($cur =~ /^($Type)\s*(?:$Ident|,|\)|\(|\s*$)/) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001450 print "DECLARE($1)\n" if ($dbg_values > 1);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001451 $type = 'T';
1452
Andy Whitcroft389a2fe2008-07-23 21:29:05 -07001453 } elsif ($cur =~ /^($Modifier)\s*/) {
1454 print "MODIFIER($1)\n" if ($dbg_values > 1);
1455 $type = 'T';
1456
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07001457 } elsif ($cur =~ /^(\#\s*define\s*$Ident)(\(?)/o) {
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07001458 print "DEFINE($1,$2)\n" if ($dbg_values > 1);
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001459 $av_preprocessor = 1;
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07001460 push(@av_paren_type, $type);
1461 if ($2 ne '') {
1462 $av_pending = 'N';
1463 }
1464 $type = 'E';
1465
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07001466 } elsif ($cur =~ /^(\#\s*(?:undef\s*$Ident|include\b))/o) {
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07001467 print "UNDEF($1)\n" if ($dbg_values > 1);
1468 $av_preprocessor = 1;
1469 push(@av_paren_type, $type);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001470
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07001471 } elsif ($cur =~ /^(\#\s*(?:ifdef|ifndef|if))/o) {
Andy Whitcroftcf655042008-03-04 14:28:20 -08001472 print "PRE_START($1)\n" if ($dbg_values > 1);
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001473 $av_preprocessor = 1;
Andy Whitcroftcf655042008-03-04 14:28:20 -08001474
1475 push(@av_paren_type, $type);
1476 push(@av_paren_type, $type);
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07001477 $type = 'E';
Andy Whitcroftcf655042008-03-04 14:28:20 -08001478
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07001479 } elsif ($cur =~ /^(\#\s*(?:else|elif))/o) {
Andy Whitcroftcf655042008-03-04 14:28:20 -08001480 print "PRE_RESTART($1)\n" if ($dbg_values > 1);
1481 $av_preprocessor = 1;
1482
1483 push(@av_paren_type, $av_paren_type[$#av_paren_type]);
1484
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07001485 $type = 'E';
Andy Whitcroftcf655042008-03-04 14:28:20 -08001486
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07001487 } elsif ($cur =~ /^(\#\s*(?:endif))/o) {
Andy Whitcroftcf655042008-03-04 14:28:20 -08001488 print "PRE_END($1)\n" if ($dbg_values > 1);
1489
1490 $av_preprocessor = 1;
1491
1492 # Assume all arms of the conditional end as this
1493 # one does, and continue as if the #endif was not here.
1494 pop(@av_paren_type);
1495 push(@av_paren_type, $type);
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07001496 $type = 'E';
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001497
1498 } elsif ($cur =~ /^(\\\n)/o) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001499 print "PRECONT($1)\n" if ($dbg_values > 1);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001500
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07001501 } elsif ($cur =~ /^(__attribute__)\s*\(?/o) {
1502 print "ATTR($1)\n" if ($dbg_values > 1);
1503 $av_pending = $type;
1504 $type = 'N';
1505
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001506 } elsif ($cur =~ /^(sizeof)\s*(\()?/o) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001507 print "SIZEOF($1)\n" if ($dbg_values > 1);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001508 if (defined $2) {
Andy Whitcroftcf655042008-03-04 14:28:20 -08001509 $av_pending = 'V';
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001510 }
1511 $type = 'N';
1512
Andy Whitcroft14b111c2008-10-15 22:02:16 -07001513 } elsif ($cur =~ /^(if|while|for)\b/o) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001514 print "COND($1)\n" if ($dbg_values > 1);
Andy Whitcroft14b111c2008-10-15 22:02:16 -07001515 $av_pending = 'E';
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001516 $type = 'N';
1517
Andy Whitcroft1f65f942008-07-23 21:29:10 -07001518 } elsif ($cur =~/^(case)/o) {
1519 print "CASE($1)\n" if ($dbg_values > 1);
1520 $av_pend_colon = 'C';
1521 $type = 'N';
1522
Andy Whitcroft14b111c2008-10-15 22:02:16 -07001523 } elsif ($cur =~/^(return|else|goto|typeof|__typeof__)\b/o) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001524 print "KEYWORD($1)\n" if ($dbg_values > 1);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001525 $type = 'N';
1526
1527 } elsif ($cur =~ /^(\()/o) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001528 print "PAREN('$1')\n" if ($dbg_values > 1);
Andy Whitcroftcf655042008-03-04 14:28:20 -08001529 push(@av_paren_type, $av_pending);
1530 $av_pending = '_';
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001531 $type = 'N';
1532
1533 } elsif ($cur =~ /^(\))/o) {
Andy Whitcroftcf655042008-03-04 14:28:20 -08001534 my $new_type = pop(@av_paren_type);
1535 if ($new_type ne '_') {
1536 $type = $new_type;
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001537 print "PAREN('$1') -> $type\n"
1538 if ($dbg_values > 1);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001539 } else {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001540 print "PAREN('$1')\n" if ($dbg_values > 1);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001541 }
1542
Andy Whitcroftc8cb2ca2008-07-23 21:28:57 -07001543 } elsif ($cur =~ /^($Ident)\s*\(/o) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001544 print "FUNC($1)\n" if ($dbg_values > 1);
Andy Whitcroftc8cb2ca2008-07-23 21:28:57 -07001545 $type = 'V';
Andy Whitcroftcf655042008-03-04 14:28:20 -08001546 $av_pending = 'V';
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001547
Andy Whitcroft8e761b02009-01-06 14:41:19 -08001548 } elsif ($cur =~ /^($Ident\s*):(?:\s*\d+\s*(,|=|;))?/) {
1549 if (defined $2 && $type eq 'C' || $type eq 'T') {
Andy Whitcroft1f65f942008-07-23 21:29:10 -07001550 $av_pend_colon = 'B';
Andy Whitcroft8e761b02009-01-06 14:41:19 -08001551 } elsif ($type eq 'E') {
1552 $av_pend_colon = 'L';
Andy Whitcroft1f65f942008-07-23 21:29:10 -07001553 }
1554 print "IDENT_COLON($1,$type>$av_pend_colon)\n" if ($dbg_values > 1);
1555 $type = 'V';
1556
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001557 } elsif ($cur =~ /^($Ident|$Constant)/o) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001558 print "IDENT($1)\n" if ($dbg_values > 1);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001559 $type = 'V';
1560
1561 } elsif ($cur =~ /^($Assignment)/o) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001562 print "ASSIGN($1)\n" if ($dbg_values > 1);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001563 $type = 'N';
1564
Andy Whitcroftcf655042008-03-04 14:28:20 -08001565 } elsif ($cur =~/^(;|{|})/) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001566 print "END($1)\n" if ($dbg_values > 1);
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001567 $type = 'E';
Andy Whitcroft1f65f942008-07-23 21:29:10 -07001568 $av_pend_colon = 'O';
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001569
Andy Whitcroft8e761b02009-01-06 14:41:19 -08001570 } elsif ($cur =~/^(,)/) {
1571 print "COMMA($1)\n" if ($dbg_values > 1);
1572 $type = 'C';
1573
Andy Whitcroft1f65f942008-07-23 21:29:10 -07001574 } elsif ($cur =~ /^(\?)/o) {
1575 print "QUESTION($1)\n" if ($dbg_values > 1);
1576 $type = 'N';
1577
1578 } elsif ($cur =~ /^(:)/o) {
1579 print "COLON($1,$av_pend_colon)\n" if ($dbg_values > 1);
1580
1581 substr($var, length($res), 1, $av_pend_colon);
1582 if ($av_pend_colon eq 'C' || $av_pend_colon eq 'L') {
1583 $type = 'E';
1584 } else {
1585 $type = 'N';
1586 }
1587 $av_pend_colon = 'O';
1588
Andy Whitcroft8e761b02009-01-06 14:41:19 -08001589 } elsif ($cur =~ /^(\[)/o) {
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001590 print "CLOSE($1)\n" if ($dbg_values > 1);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001591 $type = 'N';
1592
Andy Whitcroft0d413862008-10-15 22:02:16 -07001593 } elsif ($cur =~ /^(-(?![->])|\+(?!\+)|\*|\&\&|\&)/o) {
Andy Whitcroft74048ed2008-07-23 21:29:10 -07001594 my $variant;
1595
1596 print "OPV($1)\n" if ($dbg_values > 1);
1597 if ($type eq 'V') {
1598 $variant = 'B';
1599 } else {
1600 $variant = 'U';
1601 }
1602
1603 substr($var, length($res), 1, $variant);
1604 $type = 'N';
1605
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001606 } elsif ($cur =~ /^($Operators)/o) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001607 print "OP($1)\n" if ($dbg_values > 1);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001608 if ($1 ne '++' && $1 ne '--') {
1609 $type = 'N';
1610 }
1611
1612 } elsif ($cur =~ /(^.)/o) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001613 print "C($1)\n" if ($dbg_values > 1);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001614 }
1615 if (defined $1) {
1616 $cur = substr($cur, length($1));
1617 $res .= $type x length($1);
1618 }
1619 }
1620
Andy Whitcroft1f65f942008-07-23 21:29:10 -07001621 return ($res, $var);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001622}
1623
Andy Whitcroft8905a672007-11-28 16:21:06 -08001624sub possible {
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001625 my ($possible, $line) = @_;
Andy Whitcroft9a974fd2009-10-26 16:50:12 -07001626 my $notPermitted = qr{(?:
Andy Whitcroft0776e592008-10-15 22:02:29 -07001627 ^(?:
1628 $Modifier|
1629 $Storage|
1630 $Type|
Andy Whitcroft9a974fd2009-10-26 16:50:12 -07001631 DEFINE_\S+
1632 )$|
1633 ^(?:
Andy Whitcroft0776e592008-10-15 22:02:29 -07001634 goto|
1635 return|
1636 case|
1637 else|
1638 asm|__asm__|
Andy Whitcroft89a88352012-01-10 15:10:00 -08001639 do|
1640 \#|
1641 \#\#|
Andy Whitcroft9a974fd2009-10-26 16:50:12 -07001642 )(?:\s|$)|
Andy Whitcroft0776e592008-10-15 22:02:29 -07001643 ^(?:typedef|struct|enum)\b
Andy Whitcroft9a974fd2009-10-26 16:50:12 -07001644 )}x;
1645 warn "CHECK<$possible> ($line)\n" if ($dbg_possible > 2);
1646 if ($possible !~ $notPermitted) {
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07001647 # Check for modifiers.
1648 $possible =~ s/\s*$Storage\s*//g;
1649 $possible =~ s/\s*$Sparse\s*//g;
1650 if ($possible =~ /^\s*$/) {
1651
1652 } elsif ($possible =~ /\s/) {
1653 $possible =~ s/\s*$Type\s*//g;
Andy Whitcroftd2506582008-07-23 21:29:09 -07001654 for my $modifier (split(' ', $possible)) {
Andy Whitcroft9a974fd2009-10-26 16:50:12 -07001655 if ($modifier !~ $notPermitted) {
1656 warn "MODIFIER: $modifier ($possible) ($line)\n" if ($dbg_possible);
Alex Dowad485ff232015-06-25 15:02:52 -07001657 push(@modifierListFile, $modifier);
Andy Whitcroft9a974fd2009-10-26 16:50:12 -07001658 }
Andy Whitcroftd2506582008-07-23 21:29:09 -07001659 }
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07001660
1661 } else {
1662 warn "POSSIBLE: $possible ($line)\n" if ($dbg_possible);
Alex Dowad485ff232015-06-25 15:02:52 -07001663 push(@typeListFile, $possible);
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07001664 }
Andy Whitcroft8905a672007-11-28 16:21:06 -08001665 build_types();
Andy Whitcroft0776e592008-10-15 22:02:29 -07001666 } else {
1667 warn "NOTPOSS: $possible ($line)\n" if ($dbg_possible > 1);
Andy Whitcroft8905a672007-11-28 16:21:06 -08001668 }
1669}
1670
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001671my $prefix = '';
1672
Joe Perches000d1cc12011-07-25 17:13:25 -07001673sub show_type {
Joe Perchescbec18a2014-04-03 14:49:19 -07001674 my ($type) = @_;
Joe Perches91bfe482013-09-11 14:23:59 -07001675
Joe Perchescbec18a2014-04-03 14:49:19 -07001676 return defined $use_type{$type} if (scalar keys %use_type > 0);
1677
1678 return !defined $ignore_type{$type};
Joe Perches000d1cc12011-07-25 17:13:25 -07001679}
1680
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001681sub report {
Joe Perchescbec18a2014-04-03 14:49:19 -07001682 my ($level, $type, $msg) = @_;
1683
1684 if (!show_type($type) ||
1685 (defined $tst_only && $msg !~ /\Q$tst_only\E/)) {
Andy Whitcroft773647a2008-03-28 14:15:58 -07001686 return 0;
1687 }
Joe Perches57230292015-06-25 15:03:03 -07001688 my $output = '';
1689 if (-t STDOUT && $color) {
1690 if ($level eq 'ERROR') {
1691 $output .= RED;
1692 } elsif ($level eq 'WARNING') {
1693 $output .= YELLOW;
1694 } else {
1695 $output .= GREEN;
1696 }
Joe Perches000d1cc12011-07-25 17:13:25 -07001697 }
Joe Perches57230292015-06-25 15:03:03 -07001698 $output .= $prefix . $level . ':';
1699 if ($show_types) {
1700 $output .= BLUE if (-t STDOUT && $color);
1701 $output .= "$type:";
1702 }
1703 $output .= RESET if (-t STDOUT && $color);
1704 $output .= ' ' . $msg . "\n";
Joe Perches34d88152015-06-25 15:03:05 -07001705
1706 if ($showfile) {
1707 my @lines = split("\n", $output, -1);
1708 splice(@lines, 1, 1);
1709 $output = join("\n", @lines);
1710 }
Joe Perches57230292015-06-25 15:03:03 -07001711 $output = (split('\n', $output))[0] . "\n" if ($terse);
Andy Whitcroft8905a672007-11-28 16:21:06 -08001712
Joe Perches57230292015-06-25 15:03:03 -07001713 push(our @report, $output);
Andy Whitcroft773647a2008-03-28 14:15:58 -07001714
1715 return 1;
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001716}
Joe Perchescbec18a2014-04-03 14:49:19 -07001717
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001718sub report_dump {
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001719 our @report;
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001720}
Joe Perches000d1cc12011-07-25 17:13:25 -07001721
Joe Perchesd752fcc2014-08-06 16:11:05 -07001722sub fixup_current_range {
1723 my ($lineRef, $offset, $length) = @_;
1724
1725 if ($$lineRef =~ /^\@\@ -\d+,\d+ \+(\d+),(\d+) \@\@/) {
1726 my $o = $1;
1727 my $l = $2;
1728 my $no = $o + $offset;
1729 my $nl = $l + $length;
1730 $$lineRef =~ s/\+$o,$l \@\@/\+$no,$nl \@\@/;
1731 }
1732}
1733
1734sub fix_inserted_deleted_lines {
1735 my ($linesRef, $insertedRef, $deletedRef) = @_;
1736
1737 my $range_last_linenr = 0;
1738 my $delta_offset = 0;
1739
1740 my $old_linenr = 0;
1741 my $new_linenr = 0;
1742
1743 my $next_insert = 0;
1744 my $next_delete = 0;
1745
1746 my @lines = ();
1747
1748 my $inserted = @{$insertedRef}[$next_insert++];
1749 my $deleted = @{$deletedRef}[$next_delete++];
1750
1751 foreach my $old_line (@{$linesRef}) {
1752 my $save_line = 1;
1753 my $line = $old_line; #don't modify the array
Joe Perches323b2672015-04-16 12:44:50 -07001754 if ($line =~ /^(?:\+\+\+|\-\-\-)\s+\S+/) { #new filename
Joe Perchesd752fcc2014-08-06 16:11:05 -07001755 $delta_offset = 0;
1756 } elsif ($line =~ /^\@\@ -\d+,\d+ \+\d+,\d+ \@\@/) { #new hunk
1757 $range_last_linenr = $new_linenr;
1758 fixup_current_range(\$line, $delta_offset, 0);
1759 }
1760
1761 while (defined($deleted) && ${$deleted}{'LINENR'} == $old_linenr) {
1762 $deleted = @{$deletedRef}[$next_delete++];
1763 $save_line = 0;
1764 fixup_current_range(\$lines[$range_last_linenr], $delta_offset--, -1);
1765 }
1766
1767 while (defined($inserted) && ${$inserted}{'LINENR'} == $old_linenr) {
1768 push(@lines, ${$inserted}{'LINE'});
1769 $inserted = @{$insertedRef}[$next_insert++];
1770 $new_linenr++;
1771 fixup_current_range(\$lines[$range_last_linenr], $delta_offset++, 1);
1772 }
1773
1774 if ($save_line) {
1775 push(@lines, $line);
1776 $new_linenr++;
1777 }
1778
1779 $old_linenr++;
1780 }
1781
1782 return @lines;
1783}
1784
Joe Perchesf2d7e4d2014-08-06 16:11:07 -07001785sub fix_insert_line {
1786 my ($linenr, $line) = @_;
1787
1788 my $inserted = {
1789 LINENR => $linenr,
1790 LINE => $line,
1791 };
1792 push(@fixed_inserted, $inserted);
1793}
1794
1795sub fix_delete_line {
1796 my ($linenr, $line) = @_;
1797
1798 my $deleted = {
1799 LINENR => $linenr,
1800 LINE => $line,
1801 };
1802
1803 push(@fixed_deleted, $deleted);
1804}
1805
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07001806sub ERROR {
Joe Perchescbec18a2014-04-03 14:49:19 -07001807 my ($type, $msg) = @_;
1808
1809 if (report("ERROR", $type, $msg)) {
Andy Whitcroft773647a2008-03-28 14:15:58 -07001810 our $clean = 0;
1811 our $cnt_error++;
Joe Perches3705ce52013-07-03 15:05:31 -07001812 return 1;
Andy Whitcroft773647a2008-03-28 14:15:58 -07001813 }
Joe Perches3705ce52013-07-03 15:05:31 -07001814 return 0;
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07001815}
1816sub WARN {
Joe Perchescbec18a2014-04-03 14:49:19 -07001817 my ($type, $msg) = @_;
1818
1819 if (report("WARNING", $type, $msg)) {
Andy Whitcroft773647a2008-03-28 14:15:58 -07001820 our $clean = 0;
1821 our $cnt_warn++;
Joe Perches3705ce52013-07-03 15:05:31 -07001822 return 1;
Andy Whitcroft773647a2008-03-28 14:15:58 -07001823 }
Joe Perches3705ce52013-07-03 15:05:31 -07001824 return 0;
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07001825}
1826sub CHK {
Joe Perchescbec18a2014-04-03 14:49:19 -07001827 my ($type, $msg) = @_;
1828
1829 if ($check && report("CHECK", $type, $msg)) {
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001830 our $clean = 0;
1831 our $cnt_chk++;
Joe Perches3705ce52013-07-03 15:05:31 -07001832 return 1;
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001833 }
Joe Perches3705ce52013-07-03 15:05:31 -07001834 return 0;
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07001835}
1836
Andy Whitcroft6ecd9672008-10-15 22:02:21 -07001837sub check_absolute_file {
1838 my ($absolute, $herecurr) = @_;
1839 my $file = $absolute;
1840
1841 ##print "absolute<$absolute>\n";
1842
1843 # See if any suffix of this path is a path within the tree.
1844 while ($file =~ s@^[^/]*/@@) {
1845 if (-f "$root/$file") {
1846 ##print "file<$file>\n";
1847 last;
1848 }
1849 }
1850 if (! -f _) {
1851 return 0;
1852 }
1853
1854 # It is, so see if the prefix is acceptable.
1855 my $prefix = $absolute;
1856 substr($prefix, -length($file)) = '';
1857
1858 ##print "prefix<$prefix>\n";
1859 if ($prefix ne ".../") {
Joe Perches000d1cc12011-07-25 17:13:25 -07001860 WARN("USE_RELATIVE_PATH",
1861 "use relative pathname instead of absolute in changelog text\n" . $herecurr);
Andy Whitcroft6ecd9672008-10-15 22:02:21 -07001862 }
1863}
1864
Joe Perches3705ce52013-07-03 15:05:31 -07001865sub trim {
1866 my ($string) = @_;
1867
Joe Perchesb34c6482013-09-11 14:24:01 -07001868 $string =~ s/^\s+|\s+$//g;
1869
1870 return $string;
1871}
1872
1873sub ltrim {
1874 my ($string) = @_;
1875
1876 $string =~ s/^\s+//;
1877
1878 return $string;
1879}
1880
1881sub rtrim {
1882 my ($string) = @_;
1883
1884 $string =~ s/\s+$//;
Joe Perches3705ce52013-07-03 15:05:31 -07001885
1886 return $string;
1887}
1888
Joe Perches52ea8502013-11-12 15:10:09 -08001889sub string_find_replace {
1890 my ($string, $find, $replace) = @_;
1891
1892 $string =~ s/$find/$replace/g;
1893
1894 return $string;
1895}
1896
Joe Perches3705ce52013-07-03 15:05:31 -07001897sub tabify {
1898 my ($leading) = @_;
1899
1900 my $source_indent = 8;
1901 my $max_spaces_before_tab = $source_indent - 1;
1902 my $spaces_to_tab = " " x $source_indent;
1903
1904 #convert leading spaces to tabs
1905 1 while $leading =~ s@^([\t]*)$spaces_to_tab@$1\t@g;
1906 #Remove spaces before a tab
1907 1 while $leading =~ s@^([\t]*)( {1,$max_spaces_before_tab})\t@$1\t@g;
1908
1909 return "$leading";
1910}
1911
Joe Perchesd1fe9c02012-03-23 15:02:16 -07001912sub pos_last_openparen {
1913 my ($line) = @_;
1914
1915 my $pos = 0;
1916
1917 my $opens = $line =~ tr/\(/\(/;
1918 my $closes = $line =~ tr/\)/\)/;
1919
1920 my $last_openparen = 0;
1921
1922 if (($opens == 0) || ($closes >= $opens)) {
1923 return -1;
1924 }
1925
1926 my $len = length($line);
1927
1928 for ($pos = 0; $pos < $len; $pos++) {
1929 my $string = substr($line, $pos);
1930 if ($string =~ /^($FuncArg|$balanced_parens)/) {
1931 $pos += length($1) - 1;
1932 } elsif (substr($line, $pos, 1) eq '(') {
1933 $last_openparen = $pos;
1934 } elsif (index($string, '(') == -1) {
1935 last;
1936 }
1937 }
1938
Joe Perches91cb5192014-04-03 14:49:32 -07001939 return length(expand_tabs(substr($line, 0, $last_openparen))) + 1;
Joe Perchesd1fe9c02012-03-23 15:02:16 -07001940}
1941
Andy Whitcroft0a920b52007-06-01 00:46:48 -07001942sub process {
1943 my $filename = shift;
Andy Whitcroft0a920b52007-06-01 00:46:48 -07001944
1945 my $linenr=0;
1946 my $prevline="";
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001947 my $prevrawline="";
Andy Whitcroft0a920b52007-06-01 00:46:48 -07001948 my $stashline="";
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001949 my $stashrawline="";
Andy Whitcroft0a920b52007-06-01 00:46:48 -07001950
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001951 my $length;
Andy Whitcroft0a920b52007-06-01 00:46:48 -07001952 my $indent;
1953 my $previndent=0;
1954 my $stashindent=0;
1955
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07001956 our $clean = 1;
Andy Whitcroft0a920b52007-06-01 00:46:48 -07001957 my $signoff = 0;
1958 my $is_patch = 0;
Joe Perches29ee1b02014-08-06 16:10:35 -07001959 my $in_header_lines = $file ? 0 : 1;
Joe Perches15662b32011-10-31 17:13:12 -07001960 my $in_commit_log = 0; #Scanning lines before patch
Joe Perchesbf4daf12015-09-09 15:37:50 -07001961 my $commit_log_possible_stack_dump = 0;
Joe Perches2a076f42015-04-16 12:44:28 -07001962 my $commit_log_long_line = 0;
Joe Perchese518e9a2015-06-25 15:03:27 -07001963 my $commit_log_has_diff = 0;
Joe Perches13f19372014-08-06 16:10:59 -07001964 my $reported_maintainer_file = 0;
Pasi Savanainenfa64205d2012-10-04 17:13:29 -07001965 my $non_utf8_charset = 0;
1966
Joe Perches365dd4e2014-08-06 16:10:42 -07001967 my $last_blank_line = 0;
Joe Perches5e4f6ba2014-12-10 15:52:05 -08001968 my $last_coalesced_string_linenr = -1;
Joe Perches365dd4e2014-08-06 16:10:42 -07001969
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001970 our @report = ();
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001971 our $cnt_lines = 0;
1972 our $cnt_error = 0;
1973 our $cnt_warn = 0;
1974 our $cnt_chk = 0;
1975
Andy Whitcroft0a920b52007-06-01 00:46:48 -07001976 # Trace the real file/line as we go.
1977 my $realfile = '';
1978 my $realline = 0;
1979 my $realcnt = 0;
1980 my $here = '';
1981 my $in_comment = 0;
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001982 my $comment_edge = 0;
Andy Whitcroft0a920b52007-06-01 00:46:48 -07001983 my $first_line = 0;
Wolfram Sang1e855722009-01-06 14:41:24 -08001984 my $p1_prefix = '';
Andy Whitcroft0a920b52007-06-01 00:46:48 -07001985
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001986 my $prev_values = 'E';
1987
1988 # suppression flags
Andy Whitcroft773647a2008-03-28 14:15:58 -07001989 my %suppress_ifbraces;
Andy Whitcroft170d3a22008-10-15 22:02:30 -07001990 my %suppress_whiletrailers;
Andy Whitcroft2b474a12009-10-26 16:50:16 -07001991 my %suppress_export;
Andy Whitcroft3e469cd2012-01-10 15:10:01 -08001992 my $suppress_statement = 0;
Andy Whitcroft653d4872007-06-23 17:16:34 -07001993
Joe Perches7e51f192013-09-11 14:23:57 -07001994 my %signatures = ();
Joe Perches323c1262012-12-17 16:02:07 -08001995
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001996 # Pre-scan the patch sanitizing the lines.
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07001997 # Pre-scan the patch looking for any __setup documentation.
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001998 #
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07001999 my @setup_docs = ();
2000 my $setup_docs = 0;
Andy Whitcroft773647a2008-03-28 14:15:58 -07002001
Joe Perchesd8b07712013-11-12 15:10:06 -08002002 my $camelcase_file_seeded = 0;
2003
Andy Whitcroft773647a2008-03-28 14:15:58 -07002004 sanitise_line_reset();
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002005 my $line;
2006 foreach my $rawline (@rawlines) {
Andy Whitcroft773647a2008-03-28 14:15:58 -07002007 $linenr++;
2008 $line = $rawline;
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002009
Joe Perches3705ce52013-07-03 15:05:31 -07002010 push(@fixed, $rawline) if ($fix);
2011
Andy Whitcroft773647a2008-03-28 14:15:58 -07002012 if ($rawline=~/^\+\+\+\s+(\S+)/) {
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07002013 $setup_docs = 0;
2014 if ($1 =~ m@Documentation/kernel-parameters.txt$@) {
2015 $setup_docs = 1;
2016 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07002017 #next;
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07002018 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07002019 if ($rawline=~/^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@/) {
2020 $realline=$1-1;
2021 if (defined $2) {
2022 $realcnt=$3+1;
2023 } else {
2024 $realcnt=1+1;
2025 }
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07002026 $in_comment = 0;
Andy Whitcroft773647a2008-03-28 14:15:58 -07002027
2028 # Guestimate if this is a continuing comment. Run
2029 # the context looking for a comment "edge". If this
2030 # edge is a close comment then we must be in a comment
2031 # at context start.
2032 my $edge;
Andy Whitcroft01fa9142008-10-15 22:02:19 -07002033 my $cnt = $realcnt;
2034 for (my $ln = $linenr + 1; $cnt > 0; $ln++) {
2035 next if (defined $rawlines[$ln - 1] &&
2036 $rawlines[$ln - 1] =~ /^-/);
2037 $cnt--;
2038 #print "RAW<$rawlines[$ln - 1]>\n";
Andy Whitcroft721c1cb2009-01-06 14:41:16 -08002039 last if (!defined $rawlines[$ln - 1]);
Andy Whitcroftfae17da2009-01-06 14:41:20 -08002040 if ($rawlines[$ln - 1] =~ m@(/\*|\*/)@ &&
2041 $rawlines[$ln - 1] !~ m@"[^"]*(?:/\*|\*/)[^"]*"@) {
2042 ($edge) = $1;
2043 last;
2044 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07002045 }
2046 if (defined $edge && $edge eq '*/') {
2047 $in_comment = 1;
2048 }
2049
2050 # Guestimate if this is a continuing comment. If this
2051 # is the start of a diff block and this line starts
2052 # ' *' then it is very likely a comment.
2053 if (!defined $edge &&
Andy Whitcroft83242e02009-01-06 14:41:17 -08002054 $rawlines[$linenr] =~ m@^.\s*(?:\*\*+| \*)(?:\s|$)@)
Andy Whitcroft773647a2008-03-28 14:15:58 -07002055 {
2056 $in_comment = 1;
2057 }
2058
2059 ##print "COMMENT:$in_comment edge<$edge> $rawline\n";
2060 sanitise_line_reset($in_comment);
2061
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07002062 } elsif ($realcnt && $rawline =~ /^(?:\+| |$)/) {
Andy Whitcroft773647a2008-03-28 14:15:58 -07002063 # Standardise the strings and chars within the input to
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07002064 # simplify matching -- only bother with positive lines.
Andy Whitcroft773647a2008-03-28 14:15:58 -07002065 $line = sanitise_line($rawline);
2066 }
2067 push(@lines, $line);
2068
2069 if ($realcnt > 1) {
2070 $realcnt-- if ($line =~ /^(?:\+| |$)/);
2071 } else {
2072 $realcnt = 0;
2073 }
2074
2075 #print "==>$rawline\n";
2076 #print "-->$line\n";
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07002077
2078 if ($setup_docs && $line =~ /^\+/) {
2079 push(@setup_docs, $line);
2080 }
2081 }
2082
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07002083 $prefix = '';
2084
Andy Whitcroft773647a2008-03-28 14:15:58 -07002085 $realcnt = 0;
2086 $linenr = 0;
Joe Perches194f66f2014-08-06 16:11:03 -07002087 $fixlinenr = -1;
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002088 foreach my $line (@lines) {
2089 $linenr++;
Joe Perches194f66f2014-08-06 16:11:03 -07002090 $fixlinenr++;
Joe Perches1b5539b2013-09-11 14:24:03 -07002091 my $sline = $line; #copy of $line
2092 $sline =~ s/$;/ /g; #with comments as spaces
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002093
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002094 my $rawline = $rawlines[$linenr - 1];
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07002095
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002096#extract the line range in the file after the patch is applied
Joe Perchese518e9a2015-06-25 15:03:27 -07002097 if (!$in_commit_log &&
2098 $line =~ /^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@/) {
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002099 $is_patch = 1;
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07002100 $first_line = $linenr + 1;
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002101 $realline=$1-1;
2102 if (defined $2) {
2103 $realcnt=$3+1;
2104 } else {
2105 $realcnt=1+1;
2106 }
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002107 annotate_reset();
Andy Whitcroft13214ad2008-02-08 04:22:03 -08002108 $prev_values = 'E';
2109
Andy Whitcroft773647a2008-03-28 14:15:58 -07002110 %suppress_ifbraces = ();
Andy Whitcroft170d3a22008-10-15 22:02:30 -07002111 %suppress_whiletrailers = ();
Andy Whitcroft2b474a12009-10-26 16:50:16 -07002112 %suppress_export = ();
Andy Whitcroft3e469cd2012-01-10 15:10:01 -08002113 $suppress_statement = 0;
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002114 next;
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002115
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07002116# track the line number as we move through the hunk, note that
2117# new versions of GNU diff omit the leading space on completely
2118# blank context lines so we need to count that too.
Andy Whitcroft773647a2008-03-28 14:15:58 -07002119 } elsif ($line =~ /^( |\+|$)/) {
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002120 $realline++;
Andy Whitcroftd8aaf122007-06-23 17:16:44 -07002121 $realcnt-- if ($realcnt != 0);
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002122
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07002123 # Measure the line length and indent.
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002124 ($length, $indent) = line_stats($rawline);
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002125
2126 # Track the previous line.
2127 ($prevline, $stashline) = ($stashline, $line);
2128 ($previndent, $stashindent) = ($stashindent, $indent);
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002129 ($prevrawline, $stashrawline) = ($stashrawline, $rawline);
2130
Andy Whitcroft773647a2008-03-28 14:15:58 -07002131 #warn "line<$line>\n";
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07002132
Andy Whitcroftd8aaf122007-06-23 17:16:44 -07002133 } elsif ($realcnt == 1) {
2134 $realcnt--;
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002135 }
2136
Andy Whitcroftcc77cdc2009-10-26 16:50:13 -07002137 my $hunk_line = ($realcnt != 0);
2138
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07002139 $here = "#$linenr: " if (!$file);
2140 $here = "#$realline: " if ($file);
Andy Whitcroft773647a2008-03-28 14:15:58 -07002141
Joe Perches2ac73b42014-06-04 16:12:05 -07002142 my $found_file = 0;
Andy Whitcroft773647a2008-03-28 14:15:58 -07002143 # extract the filename as it passes
Rabin Vincent3bf9a002010-10-26 14:23:16 -07002144 if ($line =~ /^diff --git.*?(\S+)$/) {
2145 $realfile = $1;
Joe Perches2b7ab452013-11-12 15:10:14 -08002146 $realfile =~ s@^([^/]*)/@@ if (!$file);
Joe Perches270c49a2012-01-10 15:09:50 -08002147 $in_commit_log = 0;
Joe Perches2ac73b42014-06-04 16:12:05 -07002148 $found_file = 1;
Rabin Vincent3bf9a002010-10-26 14:23:16 -07002149 } elsif ($line =~ /^\+\+\+\s+(\S+)/) {
Andy Whitcroft773647a2008-03-28 14:15:58 -07002150 $realfile = $1;
Joe Perches2b7ab452013-11-12 15:10:14 -08002151 $realfile =~ s@^([^/]*)/@@ if (!$file);
Joe Perches270c49a2012-01-10 15:09:50 -08002152 $in_commit_log = 0;
Wolfram Sang1e855722009-01-06 14:41:24 -08002153
2154 $p1_prefix = $1;
Andy Whitcrofte2f7aa42009-02-27 14:03:06 -08002155 if (!$file && $tree && $p1_prefix ne '' &&
2156 -e "$root/$p1_prefix") {
Joe Perches000d1cc12011-07-25 17:13:25 -07002157 WARN("PATCH_PREFIX",
2158 "patch prefix '$p1_prefix' exists, appears to be a -p0 patch\n");
Wolfram Sang1e855722009-01-06 14:41:24 -08002159 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07002160
Andy Whitcroftc1ab3322008-10-15 22:02:20 -07002161 if ($realfile =~ m@^include/asm/@) {
Joe Perches000d1cc12011-07-25 17:13:25 -07002162 ERROR("MODIFIED_INCLUDE_ASM",
2163 "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 -07002164 }
Joe Perches2ac73b42014-06-04 16:12:05 -07002165 $found_file = 1;
2166 }
2167
Joe Perches34d88152015-06-25 15:03:05 -07002168#make up the handle for any error we report on this line
2169 if ($showfile) {
2170 $prefix = "$realfile:$realline: "
2171 } elsif ($emacs) {
Joe Perches7d3a9f62015-09-09 15:37:39 -07002172 if ($file) {
2173 $prefix = "$filename:$realline: ";
2174 } else {
2175 $prefix = "$filename:$linenr: ";
2176 }
Joe Perches34d88152015-06-25 15:03:05 -07002177 }
2178
Joe Perches2ac73b42014-06-04 16:12:05 -07002179 if ($found_file) {
Joe Perches7bd7e482015-09-09 15:37:44 -07002180 if ($realfile =~ m@^(?:drivers/net/|net/|drivers/staging/)@) {
Joe Perches2ac73b42014-06-04 16:12:05 -07002181 $check = 1;
2182 } else {
2183 $check = $check_orig;
2184 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07002185 next;
2186 }
2187
Randy Dunlap389834b2007-06-08 13:47:03 -07002188 $here .= "FILE: $realfile:$realline:" if ($realcnt != 0);
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002189
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002190 my $hereline = "$here\n$rawline\n";
2191 my $herecurr = "$here\n$rawline\n";
2192 my $hereprev = "$here\n$prevrawline\n$rawline\n";
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002193
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07002194 $cnt_lines++ if ($realcnt != 0);
2195
Joe Perchese518e9a2015-06-25 15:03:27 -07002196# Check if the commit log has what seems like a diff which can confuse patch
2197 if ($in_commit_log && !$commit_log_has_diff &&
2198 (($line =~ m@^\s+diff\b.*a/[\w/]+@ &&
2199 $line =~ m@^\s+diff\b.*a/([\w/]+)\s+b/$1\b@) ||
2200 $line =~ m@^\s*(?:\-\-\-\s+a/|\+\+\+\s+b/)@ ||
2201 $line =~ m/^\s*\@\@ \-\d+,\d+ \+\d+,\d+ \@\@/)) {
2202 ERROR("DIFF_IN_COMMIT_MSG",
2203 "Avoid using diff content in the commit message - patch(1) might not work\n" . $herecurr);
2204 $commit_log_has_diff = 1;
2205 }
2206
Rabin Vincent3bf9a002010-10-26 14:23:16 -07002207# Check for incorrect file permissions
2208 if ($line =~ /^new (file )?mode.*[7531]\d{0,2}$/) {
2209 my $permhere = $here . "FILE: $realfile\n";
Joe Perches04db4d22013-04-29 16:18:14 -07002210 if ($realfile !~ m@scripts/@ &&
2211 $realfile !~ /\.(py|pl|awk|sh)$/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07002212 ERROR("EXECUTE_PERMISSIONS",
2213 "do not set execute permissions for source files\n" . $permhere);
Rabin Vincent3bf9a002010-10-26 14:23:16 -07002214 }
2215 }
2216
Joe Perches20112472011-07-25 17:13:23 -07002217# Check the patch for a signoff:
Andy Whitcroftd8aaf122007-06-23 17:16:44 -07002218 if ($line =~ /^\s*signed-off-by:/i) {
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07002219 $signoff++;
Joe Perches15662b32011-10-31 17:13:12 -07002220 $in_commit_log = 0;
Joe Perches20112472011-07-25 17:13:23 -07002221 }
2222
Joe Perchese0d975b2014-12-10 15:51:49 -08002223# Check if MAINTAINERS is being updated. If so, there's probably no need to
2224# emit the "does MAINTAINERS need updating?" message on file add/move/delete
2225 if ($line =~ /^\s*MAINTAINERS\s*\|/) {
2226 $reported_maintainer_file = 1;
2227 }
2228
Joe Perches20112472011-07-25 17:13:23 -07002229# Check signature styles
Joe Perches270c49a2012-01-10 15:09:50 -08002230 if (!$in_header_lines &&
Joe Perchesce0338df3c2012-07-30 14:41:18 -07002231 $line =~ /^(\s*)([a-z0-9_-]+by:|$signature_tags)(\s*)(.*)/i) {
Joe Perches20112472011-07-25 17:13:23 -07002232 my $space_before = $1;
2233 my $sign_off = $2;
2234 my $space_after = $3;
2235 my $email = $4;
2236 my $ucfirst_sign_off = ucfirst(lc($sign_off));
2237
Joe Perchesce0338df3c2012-07-30 14:41:18 -07002238 if ($sign_off !~ /$signature_tags/) {
2239 WARN("BAD_SIGN_OFF",
2240 "Non-standard signature: $sign_off\n" . $herecurr);
2241 }
Joe Perches20112472011-07-25 17:13:23 -07002242 if (defined $space_before && $space_before ne "") {
Joe Perches3705ce52013-07-03 15:05:31 -07002243 if (WARN("BAD_SIGN_OFF",
2244 "Do not use whitespace before $ucfirst_sign_off\n" . $herecurr) &&
2245 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07002246 $fixed[$fixlinenr] =
Joe Perches3705ce52013-07-03 15:05:31 -07002247 "$ucfirst_sign_off $email";
2248 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002249 }
Joe Perches20112472011-07-25 17:13:23 -07002250 if ($sign_off =~ /-by:$/i && $sign_off ne $ucfirst_sign_off) {
Joe Perches3705ce52013-07-03 15:05:31 -07002251 if (WARN("BAD_SIGN_OFF",
2252 "'$ucfirst_sign_off' is the preferred signature form\n" . $herecurr) &&
2253 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07002254 $fixed[$fixlinenr] =
Joe Perches3705ce52013-07-03 15:05:31 -07002255 "$ucfirst_sign_off $email";
2256 }
2257
Joe Perches20112472011-07-25 17:13:23 -07002258 }
2259 if (!defined $space_after || $space_after ne " ") {
Joe Perches3705ce52013-07-03 15:05:31 -07002260 if (WARN("BAD_SIGN_OFF",
2261 "Use a single space after $ucfirst_sign_off\n" . $herecurr) &&
2262 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07002263 $fixed[$fixlinenr] =
Joe Perches3705ce52013-07-03 15:05:31 -07002264 "$ucfirst_sign_off $email";
2265 }
Joe Perches20112472011-07-25 17:13:23 -07002266 }
2267
2268 my ($email_name, $email_address, $comment) = parse_email($email);
2269 my $suggested_email = format_email(($email_name, $email_address));
2270 if ($suggested_email eq "") {
Joe Perches000d1cc12011-07-25 17:13:25 -07002271 ERROR("BAD_SIGN_OFF",
2272 "Unrecognized email address: '$email'\n" . $herecurr);
Joe Perches20112472011-07-25 17:13:23 -07002273 } else {
2274 my $dequoted = $suggested_email;
2275 $dequoted =~ s/^"//;
2276 $dequoted =~ s/" </ </;
2277 # Don't force email to have quotes
2278 # Allow just an angle bracketed address
2279 if ("$dequoted$comment" ne $email &&
2280 "<$email_address>$comment" ne $email &&
2281 "$suggested_email$comment" ne $email) {
Joe Perches000d1cc12011-07-25 17:13:25 -07002282 WARN("BAD_SIGN_OFF",
2283 "email address '$email' might be better as '$suggested_email$comment'\n" . $herecurr);
Joe Perches20112472011-07-25 17:13:23 -07002284 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002285 }
Joe Perches7e51f192013-09-11 14:23:57 -07002286
2287# Check for duplicate signatures
2288 my $sig_nospace = $line;
2289 $sig_nospace =~ s/\s//g;
2290 $sig_nospace = lc($sig_nospace);
2291 if (defined $signatures{$sig_nospace}) {
2292 WARN("BAD_SIGN_OFF",
2293 "Duplicate signature\n" . $herecurr);
2294 } else {
2295 $signatures{$sig_nospace} = 1;
2296 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002297 }
2298
Joe Perchesa2fe16b2015-02-13 14:39:02 -08002299# Check email subject for common tools that don't need to be mentioned
2300 if ($in_header_lines &&
2301 $line =~ /^Subject:.*\b(?:checkpatch|sparse|smatch)\b[^:]/i) {
2302 WARN("EMAIL_SUBJECT",
2303 "A patch subject line should describe the change not the tool that found it\n" . $herecurr);
2304 }
2305
Joe Perches9b3189e2014-06-04 16:12:10 -07002306# Check for old stable address
2307 if ($line =~ /^\s*cc:\s*.*<?\bstable\@kernel\.org\b>?.*$/i) {
2308 ERROR("STABLE_ADDRESS",
2309 "The 'stable' address should be 'stable\@vger.kernel.org'\n" . $herecurr);
2310 }
2311
Christopher Covington7ebd05e2014-04-03 14:49:31 -07002312# Check for unwanted Gerrit info
2313 if ($in_commit_log && $line =~ /^\s*change-id:/i) {
2314 ERROR("GERRIT_CHANGE_ID",
2315 "Remove Gerrit Change-Id's before submitting upstream.\n" . $herecurr);
2316 }
2317
Joe Perches369c8dd2015-11-06 16:31:34 -08002318# Check if the commit log is in a possible stack dump
2319 if ($in_commit_log && !$commit_log_possible_stack_dump &&
2320 ($line =~ /^\s*(?:WARNING:|BUG:)/ ||
2321 $line =~ /^\s*\[\s*\d+\.\d{6,6}\s*\]/ ||
2322 # timestamp
2323 $line =~ /^\s*\[\<[0-9a-fA-F]{8,}\>\]/)) {
2324 # stack dump address
2325 $commit_log_possible_stack_dump = 1;
2326 }
2327
Joe Perches2a076f42015-04-16 12:44:28 -07002328# Check for line lengths > 75 in commit log, warn once
2329 if ($in_commit_log && !$commit_log_long_line &&
Joe Perches369c8dd2015-11-06 16:31:34 -08002330 length($line) > 75 &&
2331 !($line =~ /^\s*[a-zA-Z0-9_\/\.]+\s+\|\s+\d+/ ||
2332 # file delta changes
2333 $line =~ /^\s*(?:[\w\.\-]+\/)++[\w\.\-]+:/ ||
2334 # filename then :
2335 $line =~ /^\s*(?:Fixes:|Link:)/i ||
2336 # A Fixes: or Link: line
2337 $commit_log_possible_stack_dump)) {
Joe Perches2a076f42015-04-16 12:44:28 -07002338 WARN("COMMIT_LOG_LONG_LINE",
2339 "Possible unwrapped commit description (prefer a maximum 75 chars per line)\n" . $herecurr);
2340 $commit_log_long_line = 1;
2341 }
2342
Joe Perchesbf4daf12015-09-09 15:37:50 -07002343# Reset possible stack dump if a blank line is found
Joe Perches369c8dd2015-11-06 16:31:34 -08002344 if ($in_commit_log && $commit_log_possible_stack_dump &&
2345 $line =~ /^\s*$/) {
2346 $commit_log_possible_stack_dump = 0;
2347 }
Joe Perchesbf4daf12015-09-09 15:37:50 -07002348
Joe Perches0d7835f2015-02-13 14:38:35 -08002349# Check for git id commit length and improperly formed commit descriptions
Joe Perches369c8dd2015-11-06 16:31:34 -08002350 if ($in_commit_log && !$commit_log_possible_stack_dump &&
Joe Perchesfe043ea2015-09-09 15:37:25 -07002351 ($line =~ /\bcommit\s+[0-9a-f]{5,}\b/i ||
Joe Perches369c8dd2015-11-06 16:31:34 -08002352 ($line =~ /\b[0-9a-f]{12,40}\b/i &&
2353 $line !~ /[\<\[][0-9a-f]{12,40}[\>\]]/i &&
2354 $line !~ /\bfixes:\s*[0-9a-f]{12,40}/i))) {
Joe Perchesfe043ea2015-09-09 15:37:25 -07002355 my $init_char = "c";
2356 my $orig_commit = "";
Joe Perches0d7835f2015-02-13 14:38:35 -08002357 my $short = 1;
2358 my $long = 0;
2359 my $case = 1;
2360 my $space = 1;
2361 my $hasdesc = 0;
Joe Perches19c146a2015-02-13 14:39:00 -08002362 my $hasparens = 0;
Joe Perches0d7835f2015-02-13 14:38:35 -08002363 my $id = '0123456789ab';
2364 my $orig_desc = "commit description";
2365 my $description = "";
2366
Joe Perchesfe043ea2015-09-09 15:37:25 -07002367 if ($line =~ /\b(c)ommit\s+([0-9a-f]{5,})\b/i) {
2368 $init_char = $1;
2369 $orig_commit = lc($2);
2370 } elsif ($line =~ /\b([0-9a-f]{12,40})\b/i) {
2371 $orig_commit = lc($1);
2372 }
2373
Joe Perches0d7835f2015-02-13 14:38:35 -08002374 $short = 0 if ($line =~ /\bcommit\s+[0-9a-f]{12,40}/i);
2375 $long = 1 if ($line =~ /\bcommit\s+[0-9a-f]{41,}/i);
2376 $space = 0 if ($line =~ /\bcommit [0-9a-f]/i);
2377 $case = 0 if ($line =~ /\b[Cc]ommit\s+[0-9a-f]{5,40}[^A-F]/);
2378 if ($line =~ /\bcommit\s+[0-9a-f]{5,}\s+\("([^"]+)"\)/i) {
2379 $orig_desc = $1;
Joe Perches19c146a2015-02-13 14:39:00 -08002380 $hasparens = 1;
Joe Perches0d7835f2015-02-13 14:38:35 -08002381 } elsif ($line =~ /\bcommit\s+[0-9a-f]{5,}\s*$/i &&
2382 defined $rawlines[$linenr] &&
2383 $rawlines[$linenr] =~ /^\s*\("([^"]+)"\)/) {
2384 $orig_desc = $1;
Joe Perches19c146a2015-02-13 14:39:00 -08002385 $hasparens = 1;
Joe Perchesb671fde2015-02-13 14:38:41 -08002386 } elsif ($line =~ /\bcommit\s+[0-9a-f]{5,}\s+\("[^"]+$/i &&
2387 defined $rawlines[$linenr] &&
2388 $rawlines[$linenr] =~ /^\s*[^"]+"\)/) {
2389 $line =~ /\bcommit\s+[0-9a-f]{5,}\s+\("([^"]+)$/i;
2390 $orig_desc = $1;
2391 $rawlines[$linenr] =~ /^\s*([^"]+)"\)/;
2392 $orig_desc .= " " . $1;
Joe Perches19c146a2015-02-13 14:39:00 -08002393 $hasparens = 1;
Joe Perches0d7835f2015-02-13 14:38:35 -08002394 }
2395
2396 ($id, $description) = git_commit_info($orig_commit,
2397 $id, $orig_desc);
2398
Joe Perches19c146a2015-02-13 14:39:00 -08002399 if ($short || $long || $space || $case || ($orig_desc ne $description) || !$hasparens) {
Joe Perches0d7835f2015-02-13 14:38:35 -08002400 ERROR("GIT_COMMIT_ID",
2401 "Please use git commit description style 'commit <12+ chars of sha1> (\"<title line>\")' - ie: '${init_char}ommit $id (\"$description\")'\n" . $herecurr);
2402 }
Joe Perchesd311cd42014-08-06 16:10:57 -07002403 }
2404
Joe Perches13f19372014-08-06 16:10:59 -07002405# Check for added, moved or deleted files
2406 if (!$reported_maintainer_file && !$in_commit_log &&
2407 ($line =~ /^(?:new|deleted) file mode\s*\d+\s*$/ ||
2408 $line =~ /^rename (?:from|to) [\w\/\.\-]+\s*$/ ||
2409 ($line =~ /\{\s*([\w\/\.\-]*)\s*\=\>\s*([\w\/\.\-]*)\s*\}/ &&
2410 (defined($1) || defined($2))))) {
2411 $reported_maintainer_file = 1;
2412 WARN("FILE_PATH_CHANGES",
2413 "added, moved or deleted file(s), does MAINTAINERS need updating?\n" . $herecurr);
2414 }
2415
Andy Whitcroft00df3442007-06-08 13:47:06 -07002416# Check for wrappage within a valid hunk of the file
Andy Whitcroft8905a672007-11-28 16:21:06 -08002417 if ($realcnt != 0 && $line !~ m{^(?:\+|-| |\\ No newline|$)}) {
Joe Perches000d1cc12011-07-25 17:13:25 -07002418 ERROR("CORRUPTED_PATCH",
2419 "patch seems to be corrupt (line wrapped?)\n" .
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07002420 $herecurr) if (!$emitted_corrupt++);
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07002421 }
2422
Andy Whitcroft6ecd9672008-10-15 22:02:21 -07002423# Check for absolute kernel paths.
2424 if ($tree) {
2425 while ($line =~ m{(?:^|\s)(/\S*)}g) {
2426 my $file = $1;
2427
2428 if ($file =~ m{^(.*?)(?::\d+)+:?$} &&
2429 check_absolute_file($1, $herecurr)) {
2430 #
2431 } else {
2432 check_absolute_file($file, $herecurr);
2433 }
2434 }
2435 }
2436
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07002437# UTF-8 regex found at http://www.w3.org/International/questions/qa-forms-utf-8.en.php
2438 if (($realfile =~ /^$/ || $line =~ /^\+/) &&
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07002439 $rawline !~ m/^$UTF8*$/) {
2440 my ($utf8_prefix) = ($rawline =~ /^($UTF8*)/);
2441
2442 my $blank = copy_spacing($rawline);
2443 my $ptr = substr($blank, 0, length($utf8_prefix)) . "^";
2444 my $hereptr = "$hereline$ptr\n";
2445
Joe Perches34d99212011-07-25 17:13:26 -07002446 CHK("INVALID_UTF8",
2447 "Invalid UTF-8, patch and commit message should be encoded in UTF-8\n" . $hereptr);
Andy Whitcroft00df3442007-06-08 13:47:06 -07002448 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002449
Joe Perches15662b32011-10-31 17:13:12 -07002450# Check if it's the start of a commit log
2451# (not a header line and we haven't seen the patch filename)
2452 if ($in_header_lines && $realfile =~ /^$/ &&
Joe Perches29ee1b02014-08-06 16:10:35 -07002453 !($rawline =~ /^\s+\S/ ||
2454 $rawline =~ /^(commit\b|from\b|[\w-]+:).*$/i)) {
Joe Perches15662b32011-10-31 17:13:12 -07002455 $in_header_lines = 0;
2456 $in_commit_log = 1;
2457 }
2458
Pasi Savanainenfa64205d2012-10-04 17:13:29 -07002459# Check if there is UTF-8 in a commit log when a mail header has explicitly
2460# declined it, i.e defined some charset where it is missing.
2461 if ($in_header_lines &&
2462 $rawline =~ /^Content-Type:.+charset="(.+)".*$/ &&
2463 $1 !~ /utf-8/i) {
2464 $non_utf8_charset = 1;
2465 }
2466
2467 if ($in_commit_log && $non_utf8_charset && $realfile =~ /^$/ &&
Joe Perches15662b32011-10-31 17:13:12 -07002468 $rawline =~ /$NON_ASCII_UTF8/) {
Pasi Savanainenfa64205d2012-10-04 17:13:29 -07002469 WARN("UTF8_BEFORE_PATCH",
Joe Perches15662b32011-10-31 17:13:12 -07002470 "8-bit UTF-8 used in possible commit log\n" . $herecurr);
2471 }
2472
Kees Cook66b47b42014-10-13 15:51:57 -07002473# Check for various typo / spelling mistakes
Joe Perches66d7a382015-04-16 12:44:08 -07002474 if (defined($misspellings) &&
2475 ($in_commit_log || $line =~ /^(?:\+|Subject:)/i)) {
Joe Perchesebfd7d62015-04-16 12:44:14 -07002476 while ($rawline =~ /(?:^|[^a-z@])($misspellings)(?:\b|$|[^a-z@])/gi) {
Kees Cook66b47b42014-10-13 15:51:57 -07002477 my $typo = $1;
2478 my $typo_fix = $spelling_fix{lc($typo)};
2479 $typo_fix = ucfirst($typo_fix) if ($typo =~ /^[A-Z]/);
2480 $typo_fix = uc($typo_fix) if ($typo =~ /^[A-Z]+$/);
2481 my $msg_type = \&WARN;
2482 $msg_type = \&CHK if ($file);
2483 if (&{$msg_type}("TYPO_SPELLING",
2484 "'$typo' may be misspelled - perhaps '$typo_fix'?\n" . $herecurr) &&
2485 $fix) {
2486 $fixed[$fixlinenr] =~ s/(^|[^A-Za-z@])($typo)($|[^A-Za-z@])/$1$typo_fix$3/;
2487 }
2488 }
2489 }
2490
Andy Whitcroft306708542008-10-15 22:02:28 -07002491# ignore non-hunk lines and lines being removed
2492 next if (!$hunk_line || $line =~ /^-/);
Andy Whitcroft00df3442007-06-08 13:47:06 -07002493
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002494#trailing whitespace
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07002495 if ($line =~ /^\+.*\015/) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002496 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
Joe Perchesd5e616f2013-09-11 14:23:54 -07002497 if (ERROR("DOS_LINE_ENDINGS",
2498 "DOS line endings\n" . $herevet) &&
2499 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07002500 $fixed[$fixlinenr] =~ s/[\s\015]+$//;
Joe Perchesd5e616f2013-09-11 14:23:54 -07002501 }
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002502 } elsif ($rawline =~ /^\+.*\S\s+$/ || $rawline =~ /^\+\s+$/) {
2503 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
Joe Perches3705ce52013-07-03 15:05:31 -07002504 if (ERROR("TRAILING_WHITESPACE",
2505 "trailing whitespace\n" . $herevet) &&
2506 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07002507 $fixed[$fixlinenr] =~ s/\s+$//;
Joe Perches3705ce52013-07-03 15:05:31 -07002508 }
2509
Andy Whitcroftd2c0a232010-10-26 14:23:12 -07002510 $rpt_cleaners = 1;
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002511 }
Andy Whitcroft5368df22008-10-15 22:02:27 -07002512
Josh Triplett4783f892013-11-12 15:10:12 -08002513# Check for FSF mailing addresses.
Alexander Duyck109d8cb2014-01-23 15:54:50 -08002514 if ($rawline =~ /\bwrite to the Free/i ||
Joe Perches3e2232f2014-01-23 15:54:48 -08002515 $rawline =~ /\b59\s+Temple\s+Pl/i ||
2516 $rawline =~ /\b51\s+Franklin\s+St/i) {
Josh Triplett4783f892013-11-12 15:10:12 -08002517 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2518 my $msg_type = \&ERROR;
2519 $msg_type = \&CHK if ($file);
2520 &{$msg_type}("FSF_MAILING_ADDRESS",
Joe Perches3e2232f2014-01-23 15:54:48 -08002521 "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 -08002522 }
2523
Andi Kleen33549572010-05-24 14:33:29 -07002524# check for Kconfig help text having a real description
Andy Whitcroft9fe287d72010-10-26 14:23:15 -07002525# Only applies when adding the entry originally, after that we do not have
2526# sufficient context to determine whether it is indeed long enough.
Andi Kleen33549572010-05-24 14:33:29 -07002527 if ($realfile =~ /Kconfig/ &&
Joe Perches8d73e0e2014-08-06 16:10:46 -07002528 $line =~ /^\+\s*config\s+/) {
Andi Kleen33549572010-05-24 14:33:29 -07002529 my $length = 0;
Andy Whitcroft9fe287d72010-10-26 14:23:15 -07002530 my $cnt = $realcnt;
2531 my $ln = $linenr + 1;
2532 my $f;
Andy Whitcrofta1385802012-01-10 15:10:03 -08002533 my $is_start = 0;
Andy Whitcroft9fe287d72010-10-26 14:23:15 -07002534 my $is_end = 0;
Andy Whitcrofta1385802012-01-10 15:10:03 -08002535 for (; $cnt > 0 && defined $lines[$ln - 1]; $ln++) {
Andy Whitcroft9fe287d72010-10-26 14:23:15 -07002536 $f = $lines[$ln - 1];
2537 $cnt-- if ($lines[$ln - 1] !~ /^-/);
2538 $is_end = $lines[$ln - 1] =~ /^\+/;
Andy Whitcroft9fe287d72010-10-26 14:23:15 -07002539
2540 next if ($f =~ /^-/);
Joe Perches8d73e0e2014-08-06 16:10:46 -07002541 last if (!$file && $f =~ /^\@\@/);
Andy Whitcrofta1385802012-01-10 15:10:03 -08002542
Joe Perches8d73e0e2014-08-06 16:10:46 -07002543 if ($lines[$ln - 1] =~ /^\+\s*(?:bool|tristate)\s*\"/) {
Andy Whitcrofta1385802012-01-10 15:10:03 -08002544 $is_start = 1;
Joe Perches8d73e0e2014-08-06 16:10:46 -07002545 } elsif ($lines[$ln - 1] =~ /^\+\s*(?:---)?help(?:---)?$/) {
Andy Whitcrofta1385802012-01-10 15:10:03 -08002546 $length = -1;
2547 }
2548
Andy Whitcroft9fe287d72010-10-26 14:23:15 -07002549 $f =~ s/^.//;
Andi Kleen33549572010-05-24 14:33:29 -07002550 $f =~ s/#.*//;
2551 $f =~ s/^\s+//;
2552 next if ($f =~ /^$/);
Andy Whitcroft9fe287d72010-10-26 14:23:15 -07002553 if ($f =~ /^\s*config\s/) {
2554 $is_end = 1;
2555 last;
2556 }
Andi Kleen33549572010-05-24 14:33:29 -07002557 $length++;
2558 }
Vadim Bendebury56193272014-10-13 15:51:48 -07002559 if ($is_start && $is_end && $length < $min_conf_desc_length) {
2560 WARN("CONFIG_DESCRIPTION",
2561 "please write a paragraph that describes the config symbol fully\n" . $herecurr);
2562 }
Andy Whitcrofta1385802012-01-10 15:10:03 -08002563 #print "is_start<$is_start> is_end<$is_end> length<$length>\n";
Andi Kleen33549572010-05-24 14:33:29 -07002564 }
2565
Kees Cook1ba8dfd2012-12-17 16:01:48 -08002566# discourage the addition of CONFIG_EXPERIMENTAL in Kconfig.
2567 if ($realfile =~ /Kconfig/ &&
2568 $line =~ /.\s*depends on\s+.*\bEXPERIMENTAL\b/) {
2569 WARN("CONFIG_EXPERIMENTAL",
2570 "Use of CONFIG_EXPERIMENTAL is deprecated. For alternatives, see https://lkml.org/lkml/2012/10/23/580\n");
2571 }
2572
Christoph Jaeger327953e2015-02-13 14:38:29 -08002573# discourage the use of boolean for type definition attributes of Kconfig options
2574 if ($realfile =~ /Kconfig/ &&
2575 $line =~ /^\+\s*\bboolean\b/) {
2576 WARN("CONFIG_TYPE_BOOLEAN",
2577 "Use of boolean is deprecated, please use bool instead.\n" . $herecurr);
2578 }
2579
Arnaud Lacombec68e5872011-08-15 01:07:14 -04002580 if (($realfile =~ /Makefile.*/ || $realfile =~ /Kbuild.*/) &&
2581 ($line =~ /\+(EXTRA_[A-Z]+FLAGS).*/)) {
2582 my $flag = $1;
2583 my $replacement = {
2584 'EXTRA_AFLAGS' => 'asflags-y',
2585 'EXTRA_CFLAGS' => 'ccflags-y',
2586 'EXTRA_CPPFLAGS' => 'cppflags-y',
2587 'EXTRA_LDFLAGS' => 'ldflags-y',
2588 };
2589
2590 WARN("DEPRECATED_VARIABLE",
2591 "Use of $flag is deprecated, please use \`$replacement->{$flag} instead.\n" . $herecurr) if ($replacement->{$flag});
2592 }
2593
Rob Herringbff5da42014-01-23 15:54:51 -08002594# check for DT compatible documentation
Florian Vaussard7dd05b32014-04-03 14:49:26 -07002595 if (defined $root &&
2596 (($realfile =~ /\.dtsi?$/ && $line =~ /^\+\s*compatible\s*=\s*\"/) ||
2597 ($realfile =~ /\.[ch]$/ && $line =~ /^\+.*\.compatible\s*=\s*\"/))) {
2598
Rob Herringbff5da42014-01-23 15:54:51 -08002599 my @compats = $rawline =~ /\"([a-zA-Z0-9\-\,\.\+_]+)\"/g;
2600
Florian Vaussardcc933192014-04-03 14:49:27 -07002601 my $dt_path = $root . "/Documentation/devicetree/bindings/";
2602 my $vp_file = $dt_path . "vendor-prefixes.txt";
2603
Rob Herringbff5da42014-01-23 15:54:51 -08002604 foreach my $compat (@compats) {
2605 my $compat2 = $compat;
Rob Herring185d5662014-06-04 16:12:03 -07002606 $compat2 =~ s/\,[a-zA-Z0-9]*\-/\,<\.\*>\-/;
2607 my $compat3 = $compat;
2608 $compat3 =~ s/\,([a-z]*)[0-9]*\-/\,$1<\.\*>\-/;
2609 `grep -Erq "$compat|$compat2|$compat3" $dt_path`;
Rob Herringbff5da42014-01-23 15:54:51 -08002610 if ( $? >> 8 ) {
2611 WARN("UNDOCUMENTED_DT_STRING",
2612 "DT compatible string \"$compat\" appears un-documented -- check $dt_path\n" . $herecurr);
2613 }
2614
Florian Vaussard4fbf32a2014-04-03 14:49:25 -07002615 next if $compat !~ /^([a-zA-Z0-9\-]+)\,/;
2616 my $vendor = $1;
Florian Vaussardcc933192014-04-03 14:49:27 -07002617 `grep -Eq "^$vendor\\b" $vp_file`;
Rob Herringbff5da42014-01-23 15:54:51 -08002618 if ( $? >> 8 ) {
2619 WARN("UNDOCUMENTED_DT_STRING",
Florian Vaussardcc933192014-04-03 14:49:27 -07002620 "DT compatible string vendor \"$vendor\" appears un-documented -- check $vp_file\n" . $herecurr);
Rob Herringbff5da42014-01-23 15:54:51 -08002621 }
2622 }
2623 }
2624
Andy Whitcroft5368df22008-10-15 22:02:27 -07002625# check we are in a valid source file if not then ignore this hunk
Geert Uytterhoevende4c9242014-10-13 15:51:46 -07002626 next if ($realfile !~ /\.(h|c|s|S|pl|sh|dtsi|dts)$/);
Andy Whitcroft5368df22008-10-15 22:02:27 -07002627
Joe Perches47e0c882015-06-25 15:02:57 -07002628# line length limit (with some exclusions)
2629#
2630# There are a few types of lines that may extend beyond $max_line_length:
2631# logging functions like pr_info that end in a string
2632# lines with a single string
2633# #defines that are a single string
2634#
2635# There are 3 different line length message types:
2636# LONG_LINE_COMMENT a comment starts before but extends beyond $max_linelength
2637# LONG_LINE_STRING a string starts before but extends beyond $max_line_length
2638# LONG_LINE all other lines longer than $max_line_length
2639#
2640# if LONG_LINE is ignored, the other 2 types are also ignored
2641#
2642
Joe Perchesb4749e92015-07-17 16:24:01 -07002643 if ($line =~ /^\+/ && $length > $max_line_length) {
Joe Perches47e0c882015-06-25 15:02:57 -07002644 my $msg_type = "LONG_LINE";
2645
2646 # Check the allowed long line types first
2647
2648 # logging functions that end in a string that starts
2649 # before $max_line_length
2650 if ($line =~ /^\+\s*$logFunctions\s*\(\s*(?:(?:KERN_\S+\s*|[^"]*))?($String\s*(?:|,|\)\s*;)\s*)$/ &&
2651 length(expand_tabs(substr($line, 1, length($line) - length($1) - 1))) <= $max_line_length) {
2652 $msg_type = "";
2653
2654 # lines with only strings (w/ possible termination)
2655 # #defines with only strings
2656 } elsif ($line =~ /^\+\s*$String\s*(?:\s*|,|\)\s*;)\s*$/ ||
2657 $line =~ /^\+\s*#\s*define\s+\w+\s+$String$/) {
2658 $msg_type = "";
2659
2660 # Otherwise set the alternate message types
2661
2662 # a comment starts before $max_line_length
2663 } elsif ($line =~ /($;[\s$;]*)$/ &&
2664 length(expand_tabs(substr($line, 1, length($line) - length($1) - 1))) <= $max_line_length) {
2665 $msg_type = "LONG_LINE_COMMENT"
2666
2667 # a quoted string starts before $max_line_length
2668 } elsif ($sline =~ /\s*($String(?:\s*(?:\\|,\s*|\)\s*;\s*))?)$/ &&
2669 length(expand_tabs(substr($line, 1, length($line) - length($1) - 1))) <= $max_line_length) {
2670 $msg_type = "LONG_LINE_STRING"
2671 }
2672
2673 if ($msg_type ne "" &&
2674 (show_type("LONG_LINE") || show_type($msg_type))) {
2675 WARN($msg_type,
2676 "line over $max_line_length characters\n" . $herecurr);
2677 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002678 }
2679
Andy Whitcroft8905a672007-11-28 16:21:06 -08002680# check for adding lines without a newline.
2681 if ($line =~ /^\+/ && defined $lines[$linenr] && $lines[$linenr] =~ /^\\ No newline at end of file/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07002682 WARN("MISSING_EOF_NEWLINE",
2683 "adding a line without newline at end of file\n" . $herecurr);
Andy Whitcroft8905a672007-11-28 16:21:06 -08002684 }
2685
Mike Frysinger42e41c52009-09-21 17:04:40 -07002686# Blackfin: use hi/lo macros
2687 if ($realfile =~ m@arch/blackfin/.*\.S$@) {
2688 if ($line =~ /\.[lL][[:space:]]*=.*&[[:space:]]*0x[fF][fF][fF][fF]/) {
2689 my $herevet = "$here\n" . cat_vet($line) . "\n";
Joe Perches000d1cc12011-07-25 17:13:25 -07002690 ERROR("LO_MACRO",
2691 "use the LO() macro, not (... & 0xFFFF)\n" . $herevet);
Mike Frysinger42e41c52009-09-21 17:04:40 -07002692 }
2693 if ($line =~ /\.[hH][[:space:]]*=.*>>[[:space:]]*16/) {
2694 my $herevet = "$here\n" . cat_vet($line) . "\n";
Joe Perches000d1cc12011-07-25 17:13:25 -07002695 ERROR("HI_MACRO",
2696 "use the HI() macro, not (... >> 16)\n" . $herevet);
Mike Frysinger42e41c52009-09-21 17:04:40 -07002697 }
2698 }
2699
Andy Whitcroftb9ea10d2008-10-15 22:02:24 -07002700# check we are in a valid source file C or perl if not then ignore this hunk
Geert Uytterhoevende4c9242014-10-13 15:51:46 -07002701 next if ($realfile !~ /\.(h|c|pl|dtsi|dts)$/);
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002702
2703# at the beginning of a line any tabs must come first and anything
2704# more than 8 must use tabs.
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002705 if ($rawline =~ /^\+\s* \t\s*\S/ ||
2706 $rawline =~ /^\+\s* \s*/) {
2707 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
Andy Whitcroftd2c0a232010-10-26 14:23:12 -07002708 $rpt_cleaners = 1;
Joe Perches3705ce52013-07-03 15:05:31 -07002709 if (ERROR("CODE_INDENT",
2710 "code indent should use tabs where possible\n" . $herevet) &&
2711 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07002712 $fixed[$fixlinenr] =~ s/^\+([ \t]+)/"\+" . tabify($1)/e;
Joe Perches3705ce52013-07-03 15:05:31 -07002713 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002714 }
2715
Alberto Panizzo08e44362010-03-05 13:43:54 -08002716# check for space before tabs.
2717 if ($rawline =~ /^\+/ && $rawline =~ / \t/) {
2718 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
Joe Perches3705ce52013-07-03 15:05:31 -07002719 if (WARN("SPACE_BEFORE_TAB",
2720 "please, no space before tabs\n" . $herevet) &&
2721 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07002722 while ($fixed[$fixlinenr] =~
Joe Perchesd2207cc2014-10-13 15:51:53 -07002723 s/(^\+.*) {8,8}\t/$1\t\t/) {}
Joe Perches194f66f2014-08-06 16:11:03 -07002724 while ($fixed[$fixlinenr] =~
Joe Perchesc76f4cb2014-01-23 15:54:46 -08002725 s/(^\+.*) +\t/$1\t/) {}
Joe Perches3705ce52013-07-03 15:05:31 -07002726 }
Alberto Panizzo08e44362010-03-05 13:43:54 -08002727 }
2728
Joe Perchesd1fe9c02012-03-23 15:02:16 -07002729# check for && or || at the start of a line
2730 if ($rawline =~ /^\+\s*(&&|\|\|)/) {
2731 CHK("LOGICAL_CONTINUATIONS",
2732 "Logical continuations should be on the previous line\n" . $hereprev);
2733 }
2734
2735# check multi-line statement indentation matches previous line
2736 if ($^V && $^V ge 5.10.0 &&
Joe Perches91cb5192014-04-03 14:49:32 -07002737 $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 -07002738 $prevline =~ /^\+(\t*)(.*)$/;
2739 my $oldindent = $1;
2740 my $rest = $2;
2741
2742 my $pos = pos_last_openparen($rest);
2743 if ($pos >= 0) {
Joe Perchesb34a26f2012-07-30 14:41:16 -07002744 $line =~ /^(\+| )([ \t]*)/;
2745 my $newindent = $2;
Joe Perchesd1fe9c02012-03-23 15:02:16 -07002746
2747 my $goodtabindent = $oldindent .
2748 "\t" x ($pos / 8) .
2749 " " x ($pos % 8);
2750 my $goodspaceindent = $oldindent . " " x $pos;
2751
2752 if ($newindent ne $goodtabindent &&
2753 $newindent ne $goodspaceindent) {
Joe Perches3705ce52013-07-03 15:05:31 -07002754
2755 if (CHK("PARENTHESIS_ALIGNMENT",
2756 "Alignment should match open parenthesis\n" . $hereprev) &&
2757 $fix && $line =~ /^\+/) {
Joe Perches194f66f2014-08-06 16:11:03 -07002758 $fixed[$fixlinenr] =~
Joe Perches3705ce52013-07-03 15:05:31 -07002759 s/^\+[ \t]*/\+$goodtabindent/;
2760 }
Joe Perchesd1fe9c02012-03-23 15:02:16 -07002761 }
2762 }
2763 }
2764
Joe Perches6ab3a972015-04-16 12:44:05 -07002765# check for space after cast like "(int) foo" or "(struct foo) bar"
2766# avoid checking a few false positives:
2767# "sizeof(<type>)" or "__alignof__(<type>)"
2768# function pointer declarations like "(*foo)(int) = bar;"
2769# structure definitions like "(struct foo) { 0 };"
2770# multiline macros that define functions
2771# known attributes or the __attribute__ keyword
2772 if ($line =~ /^\+(.*)\(\s*$Type\s*\)([ \t]++)((?![={]|\\$|$Attribute|__attribute__))/ &&
2773 (!defined($1) || $1 !~ /\b(?:sizeof|__alignof__)\s*$/)) {
Joe Perches3705ce52013-07-03 15:05:31 -07002774 if (CHK("SPACING",
Joe Perchesf27c95d2014-08-06 16:10:52 -07002775 "No space is necessary after a cast\n" . $herecurr) &&
Joe Perches3705ce52013-07-03 15:05:31 -07002776 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07002777 $fixed[$fixlinenr] =~
Joe Perchesf27c95d2014-08-06 16:10:52 -07002778 s/(\(\s*$Type\s*\))[ \t]+/$1/;
Joe Perches3705ce52013-07-03 15:05:31 -07002779 }
Joe Perchesaad4f612012-03-23 15:02:19 -07002780 }
2781
Joe Perches86406b12015-09-09 15:37:41 -07002782# Block comment styles
2783# Networking with an initial /*
Joe Perches05880602012-10-04 17:13:35 -07002784 if ($realfile =~ m@^(drivers/net/|net/)@ &&
Joe Perchesfdb4bcd2013-07-03 15:05:23 -07002785 $prevrawline =~ /^\+[ \t]*\/\*[ \t]*$/ &&
Joe Perches85ad9782014-04-03 14:49:20 -07002786 $rawline =~ /^\+[ \t]*\*/ &&
2787 $realline > 2) {
Joe Perches05880602012-10-04 17:13:35 -07002788 WARN("NETWORKING_BLOCK_COMMENT_STYLE",
2789 "networking block comments don't use an empty /* line, use /* Comment...\n" . $hereprev);
2790 }
2791
Joe Perches86406b12015-09-09 15:37:41 -07002792# Block comments use * on subsequent lines
2793 if ($prevline =~ /$;[ \t]*$/ && #ends in comment
2794 $prevrawline =~ /^\+.*?\/\*/ && #starting /*
Joe Perchesa605e322013-07-03 15:05:24 -07002795 $prevrawline !~ /\*\/[ \t]*$/ && #no trailing */
Joe Perches61135e92013-09-11 14:23:59 -07002796 $rawline =~ /^\+/ && #line is new
Joe Perchesa605e322013-07-03 15:05:24 -07002797 $rawline !~ /^\+[ \t]*\*/) { #no leading *
Joe Perches86406b12015-09-09 15:37:41 -07002798 WARN("BLOCK_COMMENT_STYLE",
2799 "Block comments use * on subsequent lines\n" . $hereprev);
Joe Perchesa605e322013-07-03 15:05:24 -07002800 }
2801
Joe Perches86406b12015-09-09 15:37:41 -07002802# Block comments use */ on trailing lines
2803 if ($rawline !~ m@^\+[ \t]*\*/[ \t]*$@ && #trailing */
Joe Perchesc24f9f12012-11-08 15:53:29 -08002804 $rawline !~ m@^\+.*/\*.*\*/[ \t]*$@ && #inline /*...*/
2805 $rawline !~ m@^\+.*\*{2,}/[ \t]*$@ && #trailing **/
2806 $rawline =~ m@^\+[ \t]*.+\*\/[ \t]*$@) { #non blank */
Joe Perches86406b12015-09-09 15:37:41 -07002807 WARN("BLOCK_COMMENT_STYLE",
2808 "Block comments use a trailing */ on a separate line\n" . $herecurr);
Joe Perches05880602012-10-04 17:13:35 -07002809 }
2810
Joe Perches7f619192014-08-06 16:10:39 -07002811# check for missing blank lines after struct/union declarations
2812# with exceptions for various attributes and macros
2813 if ($prevline =~ /^[\+ ]};?\s*$/ &&
2814 $line =~ /^\+/ &&
2815 !($line =~ /^\+\s*$/ ||
2816 $line =~ /^\+\s*EXPORT_SYMBOL/ ||
2817 $line =~ /^\+\s*MODULE_/i ||
2818 $line =~ /^\+\s*\#\s*(?:end|elif|else)/ ||
2819 $line =~ /^\+[a-z_]*init/ ||
2820 $line =~ /^\+\s*(?:static\s+)?[A-Z_]*ATTR/ ||
2821 $line =~ /^\+\s*DECLARE/ ||
2822 $line =~ /^\+\s*__setup/)) {
Joe Perchesd752fcc2014-08-06 16:11:05 -07002823 if (CHK("LINE_SPACING",
2824 "Please use a blank line after function/struct/union/enum declarations\n" . $hereprev) &&
2825 $fix) {
Joe Perchesf2d7e4d2014-08-06 16:11:07 -07002826 fix_insert_line($fixlinenr, "\+");
Joe Perchesd752fcc2014-08-06 16:11:05 -07002827 }
Joe Perches7f619192014-08-06 16:10:39 -07002828 }
2829
Joe Perches365dd4e2014-08-06 16:10:42 -07002830# check for multiple consecutive blank lines
2831 if ($prevline =~ /^[\+ ]\s*$/ &&
2832 $line =~ /^\+\s*$/ &&
2833 $last_blank_line != ($linenr - 1)) {
Joe Perchesd752fcc2014-08-06 16:11:05 -07002834 if (CHK("LINE_SPACING",
2835 "Please don't use multiple blank lines\n" . $hereprev) &&
2836 $fix) {
Joe Perchesf2d7e4d2014-08-06 16:11:07 -07002837 fix_delete_line($fixlinenr, $rawline);
Joe Perchesd752fcc2014-08-06 16:11:05 -07002838 }
2839
Joe Perches365dd4e2014-08-06 16:10:42 -07002840 $last_blank_line = $linenr;
2841 }
2842
Joe Perches3b617e32014-04-03 14:49:28 -07002843# check for missing blank lines after declarations
Joe Perches3f7bac02014-06-04 16:12:04 -07002844 if ($sline =~ /^\+\s+\S/ && #Not at char 1
2845 # actual declarations
2846 ($prevline =~ /^\+\s+$Declare\s*$Ident\s*[=,;:\[]/ ||
Joe Perches5a4e1fd2014-08-06 16:10:33 -07002847 # function pointer declarations
2848 $prevline =~ /^\+\s+$Declare\s*\(\s*\*\s*$Ident\s*\)\s*[=,;:\[\(]/ ||
Joe Perches3f7bac02014-06-04 16:12:04 -07002849 # foo bar; where foo is some local typedef or #define
2850 $prevline =~ /^\+\s+$Ident(?:\s+|\s*\*\s*)$Ident\s*[=,;\[]/ ||
2851 # known declaration macros
2852 $prevline =~ /^\+\s+$declaration_macros/) &&
2853 # for "else if" which can look like "$Ident $Ident"
2854 !($prevline =~ /^\+\s+$c90_Keywords\b/ ||
2855 # other possible extensions of declaration lines
2856 $prevline =~ /(?:$Compare|$Assignment|$Operators)\s*$/ ||
2857 # not starting a section or a macro "\" extended line
2858 $prevline =~ /(?:\{\s*|\\)$/) &&
2859 # looks like a declaration
2860 !($sline =~ /^\+\s+$Declare\s*$Ident\s*[=,;:\[]/ ||
Joe Perches5a4e1fd2014-08-06 16:10:33 -07002861 # function pointer declarations
2862 $sline =~ /^\+\s+$Declare\s*\(\s*\*\s*$Ident\s*\)\s*[=,;:\[\(]/ ||
Joe Perches3f7bac02014-06-04 16:12:04 -07002863 # foo bar; where foo is some local typedef or #define
2864 $sline =~ /^\+\s+$Ident(?:\s+|\s*\*\s*)$Ident\s*[=,;\[]/ ||
2865 # known declaration macros
2866 $sline =~ /^\+\s+$declaration_macros/ ||
2867 # start of struct or union or enum
Joe Perches3b617e32014-04-03 14:49:28 -07002868 $sline =~ /^\+\s+(?:union|struct|enum|typedef)\b/ ||
Joe Perches3f7bac02014-06-04 16:12:04 -07002869 # start or end of block or continuation of declaration
2870 $sline =~ /^\+\s+(?:$|[\{\}\.\#\"\?\:\(\[])/ ||
2871 # bitfield continuation
2872 $sline =~ /^\+\s+$Ident\s*:\s*\d+\s*[,;]/ ||
2873 # other possible extensions of declaration lines
2874 $sline =~ /^\+\s+\(?\s*(?:$Compare|$Assignment|$Operators)/) &&
2875 # indentation of previous and current line are the same
2876 (($prevline =~ /\+(\s+)\S/) && $sline =~ /^\+$1\S/)) {
Joe Perchesd752fcc2014-08-06 16:11:05 -07002877 if (WARN("LINE_SPACING",
2878 "Missing a blank line after declarations\n" . $hereprev) &&
2879 $fix) {
Joe Perchesf2d7e4d2014-08-06 16:11:07 -07002880 fix_insert_line($fixlinenr, "\+");
Joe Perchesd752fcc2014-08-06 16:11:05 -07002881 }
Joe Perches3b617e32014-04-03 14:49:28 -07002882 }
2883
Raffaele Recalcati5f7ddae2010-08-09 17:20:59 -07002884# check for spaces at the beginning of a line.
Andy Whitcroft6b4c5be2010-10-26 14:23:11 -07002885# Exceptions:
2886# 1) within comments
2887# 2) indented preprocessor commands
2888# 3) hanging labels
Joe Perches3705ce52013-07-03 15:05:31 -07002889 if ($rawline =~ /^\+ / && $line !~ /^\+ *(?:$;|#|$Ident:)/) {
Raffaele Recalcati5f7ddae2010-08-09 17:20:59 -07002890 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
Joe Perches3705ce52013-07-03 15:05:31 -07002891 if (WARN("LEADING_SPACE",
2892 "please, no spaces at the start of a line\n" . $herevet) &&
2893 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07002894 $fixed[$fixlinenr] =~ s/^\+([ \t]+)/"\+" . tabify($1)/e;
Joe Perches3705ce52013-07-03 15:05:31 -07002895 }
Raffaele Recalcati5f7ddae2010-08-09 17:20:59 -07002896 }
2897
Andy Whitcroftb9ea10d2008-10-15 22:02:24 -07002898# check we are in a valid C source file if not then ignore this hunk
2899 next if ($realfile !~ /\.(h|c)$/);
2900
Joe Perches032a4c02014-08-06 16:10:29 -07002901# check indentation of any line with a bare else
Joe Perches840080a2014-10-13 15:51:59 -07002902# (but not if it is a multiple line "if (foo) return bar; else return baz;")
Joe Perches032a4c02014-08-06 16:10:29 -07002903# if the previous line is a break or return and is indented 1 tab more...
2904 if ($sline =~ /^\+([\t]+)(?:}[ \t]*)?else(?:[ \t]*{)?\s*$/) {
2905 my $tabs = length($1) + 1;
Joe Perches840080a2014-10-13 15:51:59 -07002906 if ($prevline =~ /^\+\t{$tabs,$tabs}break\b/ ||
2907 ($prevline =~ /^\+\t{$tabs,$tabs}return\b/ &&
2908 defined $lines[$linenr] &&
2909 $lines[$linenr] !~ /^[ \+]\t{$tabs,$tabs}return/)) {
Joe Perches032a4c02014-08-06 16:10:29 -07002910 WARN("UNNECESSARY_ELSE",
2911 "else is not generally useful after a break or return\n" . $hereprev);
2912 }
2913 }
2914
Joe Perchesc00df192014-08-06 16:11:01 -07002915# check indentation of a line with a break;
2916# if the previous line is a goto or return and is indented the same # of tabs
2917 if ($sline =~ /^\+([\t]+)break\s*;\s*$/) {
2918 my $tabs = $1;
2919 if ($prevline =~ /^\+$tabs(?:goto|return)\b/) {
2920 WARN("UNNECESSARY_BREAK",
2921 "break is not useful after a goto or return\n" . $hereprev);
2922 }
2923 }
2924
Kees Cook1ba8dfd2012-12-17 16:01:48 -08002925# discourage the addition of CONFIG_EXPERIMENTAL in #if(def).
2926 if ($line =~ /^\+\s*\#\s*if.*\bCONFIG_EXPERIMENTAL\b/) {
2927 WARN("CONFIG_EXPERIMENTAL",
2928 "Use of CONFIG_EXPERIMENTAL is deprecated. For alternatives, see https://lkml.org/lkml/2012/10/23/580\n");
2929 }
2930
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002931# check for RCS/CVS revision markers
Andy Whitcroftcf655042008-03-04 14:28:20 -08002932 if ($rawline =~ /^\+.*\$(Revision|Log|Id)(?:\$|)/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07002933 WARN("CVS_KEYWORD",
2934 "CVS style keyword markers, these will _not_ be updated\n". $herecurr);
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002935 }
Andy Whitcroft22f2a2e2007-08-10 13:01:03 -07002936
Mike Frysinger42e41c52009-09-21 17:04:40 -07002937# Blackfin: don't use __builtin_bfin_[cs]sync
2938 if ($line =~ /__builtin_bfin_csync/) {
2939 my $herevet = "$here\n" . cat_vet($line) . "\n";
Joe Perches000d1cc12011-07-25 17:13:25 -07002940 ERROR("CSYNC",
2941 "use the CSYNC() macro in asm/blackfin.h\n" . $herevet);
Mike Frysinger42e41c52009-09-21 17:04:40 -07002942 }
2943 if ($line =~ /__builtin_bfin_ssync/) {
2944 my $herevet = "$here\n" . cat_vet($line) . "\n";
Joe Perches000d1cc12011-07-25 17:13:25 -07002945 ERROR("SSYNC",
2946 "use the SSYNC() macro in asm/blackfin.h\n" . $herevet);
Mike Frysinger42e41c52009-09-21 17:04:40 -07002947 }
2948
Joe Perches56e77d72013-02-21 16:44:14 -08002949# check for old HOTPLUG __dev<foo> section markings
2950 if ($line =~ /\b(__dev(init|exit)(data|const|))\b/) {
2951 WARN("HOTPLUG_SECTION",
2952 "Using $1 is unnecessary\n" . $herecurr);
2953 }
2954
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07002955# Check for potential 'bare' types
Andy Whitcroft2b474a12009-10-26 16:50:16 -07002956 my ($stat, $cond, $line_nr_next, $remain_next, $off_next,
2957 $realline_next);
Andy Whitcroft3e469cd2012-01-10 15:10:01 -08002958#print "LINE<$line>\n";
2959 if ($linenr >= $suppress_statement &&
Joe Perches1b5539b2013-09-11 14:24:03 -07002960 $realcnt && $sline =~ /.\s*\S/) {
Andy Whitcroft170d3a22008-10-15 22:02:30 -07002961 ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
Andy Whitcroftf5fe35d2008-07-23 21:29:03 -07002962 ctx_statement_block($linenr, $realcnt, 0);
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07002963 $stat =~ s/\n./\n /g;
2964 $cond =~ s/\n./\n /g;
2965
Andy Whitcroft3e469cd2012-01-10 15:10:01 -08002966#print "linenr<$linenr> <$stat>\n";
2967 # If this statement has no statement boundaries within
2968 # it there is no point in retrying a statement scan
2969 # until we hit end of it.
2970 my $frag = $stat; $frag =~ s/;+\s*$//;
2971 if ($frag !~ /(?:{|;)/) {
2972#print "skip<$line_nr_next>\n";
2973 $suppress_statement = $line_nr_next;
2974 }
Andy Whitcroftf74bd192012-01-10 15:09:54 -08002975
Andy Whitcroft2b474a12009-10-26 16:50:16 -07002976 # Find the real next line.
2977 $realline_next = $line_nr_next;
2978 if (defined $realline_next &&
2979 (!defined $lines[$realline_next - 1] ||
2980 substr($lines[$realline_next - 1], $off_next) =~ /^\s*$/)) {
2981 $realline_next++;
2982 }
2983
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07002984 my $s = $stat;
2985 $s =~ s/{.*$//s;
Andy Whitcroftcf655042008-03-04 14:28:20 -08002986
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002987 # Ignore goto labels.
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07002988 if ($s =~ /$Ident:\*$/s) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002989
2990 # Ignore functions being called
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07002991 } elsif ($s =~ /^.\s*$Ident\s*\(/s) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002992
Andy Whitcroft463f2862009-09-21 17:04:34 -07002993 } elsif ($s =~ /^.\s*else\b/s) {
2994
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07002995 # declarations always start with types
Andy Whitcroftd2506582008-07-23 21:29:09 -07002996 } 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 -07002997 my $type = $1;
2998 $type =~ s/\s+/ /g;
2999 possible($type, "A:" . $s);
3000
Andy Whitcroft8905a672007-11-28 16:21:06 -08003001 # definitions in global scope can only start with types
Andy Whitcrofta6a840622008-10-15 22:02:30 -07003002 } elsif ($s =~ /^.(?:$Storage\s+)?(?:$Inline\s+)?(?:const\s+)?($Ident)\b\s*(?!:)/s) {
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07003003 possible($1, "B:" . $s);
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08003004 }
Andy Whitcroft8905a672007-11-28 16:21:06 -08003005
3006 # any (foo ... *) is a pointer cast, and foo is a type
Andy Whitcroft65863862009-01-06 14:41:21 -08003007 while ($s =~ /\(($Ident)(?:\s+$Sparse)*[\s\*]+\s*\)/sg) {
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07003008 possible($1, "C:" . $s);
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07003009 }
Andy Whitcroft8905a672007-11-28 16:21:06 -08003010
3011 # Check for any sort of function declaration.
3012 # int foo(something bar, other baz);
3013 # void (*store_gdt)(x86_descr_ptr *);
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07003014 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 -08003015 my ($name_len) = length($1);
Andy Whitcroft8905a672007-11-28 16:21:06 -08003016
Andy Whitcroftcf655042008-03-04 14:28:20 -08003017 my $ctx = $s;
Andy Whitcroft773647a2008-03-28 14:15:58 -07003018 substr($ctx, 0, $name_len + 1, '');
Andy Whitcroft8905a672007-11-28 16:21:06 -08003019 $ctx =~ s/\)[^\)]*$//;
Andy Whitcroftcf655042008-03-04 14:28:20 -08003020
Andy Whitcroft8905a672007-11-28 16:21:06 -08003021 for my $arg (split(/\s*,\s*/, $ctx)) {
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07003022 if ($arg =~ /^(?:const\s+)?($Ident)(?:\s+$Sparse)*\s*\**\s*(:?\b$Ident)?$/s || $arg =~ /^($Ident)$/s) {
Andy Whitcroft8905a672007-11-28 16:21:06 -08003023
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07003024 possible($1, "D:" . $s);
Andy Whitcroft8905a672007-11-28 16:21:06 -08003025 }
3026 }
3027 }
3028
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07003029 }
3030
Andy Whitcroft653d4872007-06-23 17:16:34 -07003031#
3032# Checks which may be anchored in the context.
3033#
3034
3035# Check for switch () and associated case and default
3036# statements should be at the same indent.
Andy Whitcroft00df3442007-06-08 13:47:06 -07003037 if ($line=~/\bswitch\s*\(.*\)/) {
3038 my $err = '';
3039 my $sep = '';
3040 my @ctx = ctx_block_outer($linenr, $realcnt);
3041 shift(@ctx);
3042 for my $ctx (@ctx) {
3043 my ($clen, $cindent) = line_stats($ctx);
3044 if ($ctx =~ /^\+\s*(case\s+|default:)/ &&
3045 $indent != $cindent) {
3046 $err .= "$sep$ctx\n";
3047 $sep = '';
3048 } else {
3049 $sep = "[...]\n";
3050 }
3051 }
3052 if ($err ne '') {
Joe Perches000d1cc12011-07-25 17:13:25 -07003053 ERROR("SWITCH_CASE_INDENT_LEVEL",
3054 "switch and case should be at the same indent\n$hereline$err");
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07003055 }
3056 }
3057
3058# if/while/etc brace do not go on next line, unless defining a do while loop,
3059# or if that brace on the next line is for something else
Joe Perches0fe3dc22014-08-06 16:11:16 -07003060 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 -07003061 my $pre_ctx = "$1$2";
3062
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07003063 my ($level, @ctx) = ctx_statement_level($linenr, $realcnt, 0);
Joe Perches8eef05d2012-02-03 15:20:39 -08003064
3065 if ($line =~ /^\+\t{6,}/) {
3066 WARN("DEEP_INDENTATION",
3067 "Too many leading tabs - consider code refactoring\n" . $herecurr);
3068 }
3069
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07003070 my $ctx_cnt = $realcnt - $#ctx - 1;
3071 my $ctx = join("\n", @ctx);
3072
Andy Whitcroft548596d2008-07-23 21:29:01 -07003073 my $ctx_ln = $linenr;
3074 my $ctx_skip = $realcnt;
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07003075
Andy Whitcroft548596d2008-07-23 21:29:01 -07003076 while ($ctx_skip > $ctx_cnt || ($ctx_skip == $ctx_cnt &&
3077 defined $lines[$ctx_ln - 1] &&
3078 $lines[$ctx_ln - 1] =~ /^-/)) {
3079 ##print "SKIP<$ctx_skip> CNT<$ctx_cnt>\n";
3080 $ctx_skip-- if (!defined $lines[$ctx_ln - 1] || $lines[$ctx_ln - 1] !~ /^-/);
Andy Whitcroft773647a2008-03-28 14:15:58 -07003081 $ctx_ln++;
3082 }
Andy Whitcroft548596d2008-07-23 21:29:01 -07003083
Andy Whitcroft53210162008-07-23 21:29:03 -07003084 #print "realcnt<$realcnt> ctx_cnt<$ctx_cnt>\n";
3085 #print "pre<$pre_ctx>\nline<$line>\nctx<$ctx>\nnext<$lines[$ctx_ln - 1]>\n";
Andy Whitcroft773647a2008-03-28 14:15:58 -07003086
Joe Perchesd752fcc2014-08-06 16:11:05 -07003087 if ($ctx !~ /{\s*/ && defined($lines[$ctx_ln - 1]) && $lines[$ctx_ln - 1] =~ /^\+\s*{/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003088 ERROR("OPEN_BRACE",
3089 "that open brace { should be on the previous line\n" .
Andy Whitcroft01464f32010-10-26 14:23:19 -07003090 "$here\n$ctx\n$rawlines[$ctx_ln - 1]\n");
Andy Whitcroft00df3442007-06-08 13:47:06 -07003091 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07003092 if ($level == 0 && $pre_ctx !~ /}\s*while\s*\($/ &&
3093 $ctx =~ /\)\s*\;\s*$/ &&
3094 defined $lines[$ctx_ln - 1])
3095 {
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07003096 my ($nlength, $nindent) = line_stats($lines[$ctx_ln - 1]);
3097 if ($nindent > $indent) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003098 WARN("TRAILING_SEMICOLON",
3099 "trailing semicolon indicates no statements, indent implies otherwise\n" .
Andy Whitcroft01464f32010-10-26 14:23:19 -07003100 "$here\n$ctx\n$rawlines[$ctx_ln - 1]\n");
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07003101 }
3102 }
Andy Whitcroft00df3442007-06-08 13:47:06 -07003103 }
3104
Andy Whitcroft4d001e42008-10-15 22:02:21 -07003105# Check relative indent for conditionals and blocks.
Joe Perches0fe3dc22014-08-06 16:11:16 -07003106 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 -08003107 ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
3108 ctx_statement_block($linenr, $realcnt, 0)
3109 if (!defined $stat);
Andy Whitcroft4d001e42008-10-15 22:02:21 -07003110 my ($s, $c) = ($stat, $cond);
3111
3112 substr($s, 0, length($c), '');
3113
Joe Perches9f5af482015-09-09 15:37:30 -07003114 # remove inline comments
3115 $s =~ s/$;/ /g;
3116 $c =~ s/$;/ /g;
Andy Whitcroft4d001e42008-10-15 22:02:21 -07003117
3118 # Find out how long the conditional actually is.
Andy Whitcroft6f779c12008-10-15 22:02:27 -07003119 my @newlines = ($c =~ /\n/gs);
3120 my $cond_lines = 1 + $#newlines;
Andy Whitcroft4d001e42008-10-15 22:02:21 -07003121
Joe Perches9f5af482015-09-09 15:37:30 -07003122 # Make sure we remove the line prefixes as we have
3123 # none on the first line, and are going to readd them
3124 # where necessary.
3125 $s =~ s/\n./\n/gs;
3126 while ($s =~ /\n\s+\\\n/) {
3127 $cond_lines += $s =~ s/\n\s+\\\n/\n/g;
3128 }
3129
Andy Whitcroft4d001e42008-10-15 22:02:21 -07003130 # We want to check the first line inside the block
3131 # starting at the end of the conditional, so remove:
3132 # 1) any blank line termination
3133 # 2) any opening brace { on end of the line
3134 # 3) any do (...) {
3135 my $continuation = 0;
3136 my $check = 0;
3137 $s =~ s/^.*\bdo\b//;
3138 $s =~ s/^\s*{//;
3139 if ($s =~ s/^\s*\\//) {
3140 $continuation = 1;
3141 }
Andy Whitcroft9bd49ef2008-10-15 22:02:22 -07003142 if ($s =~ s/^\s*?\n//) {
Andy Whitcroft4d001e42008-10-15 22:02:21 -07003143 $check = 1;
3144 $cond_lines++;
3145 }
3146
3147 # Also ignore a loop construct at the end of a
3148 # preprocessor statement.
3149 if (($prevline =~ /^.\s*#\s*define\s/ ||
3150 $prevline =~ /\\\s*$/) && $continuation == 0) {
3151 $check = 0;
3152 }
3153
Andy Whitcroft9bd49ef2008-10-15 22:02:22 -07003154 my $cond_ptr = -1;
Andy Whitcroft740504c2008-10-15 22:02:35 -07003155 $continuation = 0;
Andy Whitcroft9bd49ef2008-10-15 22:02:22 -07003156 while ($cond_ptr != $cond_lines) {
3157 $cond_ptr = $cond_lines;
Andy Whitcroft4d001e42008-10-15 22:02:21 -07003158
Andy Whitcroftf16fa282008-10-15 22:02:32 -07003159 # If we see an #else/#elif then the code
3160 # is not linear.
3161 if ($s =~ /^\s*\#\s*(?:else|elif)/) {
3162 $check = 0;
3163 }
3164
Andy Whitcroft9bd49ef2008-10-15 22:02:22 -07003165 # Ignore:
3166 # 1) blank lines, they should be at 0,
3167 # 2) preprocessor lines, and
3168 # 3) labels.
Andy Whitcroft740504c2008-10-15 22:02:35 -07003169 if ($continuation ||
3170 $s =~ /^\s*?\n/ ||
Andy Whitcroft9bd49ef2008-10-15 22:02:22 -07003171 $s =~ /^\s*#\s*?/ ||
3172 $s =~ /^\s*$Ident\s*:/) {
Andy Whitcroft740504c2008-10-15 22:02:35 -07003173 $continuation = ($s =~ /^.*?\\\n/) ? 1 : 0;
Andy Whitcroft30dad6e2009-09-21 17:04:36 -07003174 if ($s =~ s/^.*?\n//) {
3175 $cond_lines++;
3176 }
Andy Whitcroft9bd49ef2008-10-15 22:02:22 -07003177 }
Andy Whitcroft4d001e42008-10-15 22:02:21 -07003178 }
3179
3180 my (undef, $sindent) = line_stats("+" . $s);
3181 my $stat_real = raw_line($linenr, $cond_lines);
3182
3183 # Check if either of these lines are modified, else
3184 # this is not this patch's fault.
3185 if (!defined($stat_real) ||
3186 $stat !~ /^\+/ && $stat_real !~ /^\+/) {
3187 $check = 0;
3188 }
3189 if (defined($stat_real) && $cond_lines > 1) {
3190 $stat_real = "[...]\n$stat_real";
3191 }
3192
Andy Whitcroft9bd49ef2008-10-15 22:02:22 -07003193 #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 -07003194
Joe Perches9f5af482015-09-09 15:37:30 -07003195 if ($check && $s ne '' &&
3196 (($sindent % 8) != 0 ||
3197 ($sindent < $indent) ||
3198 ($sindent > $indent + 8))) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003199 WARN("SUSPECT_CODE_INDENT",
3200 "suspect code indent for conditional statements ($indent, $sindent)\n" . $herecurr . "$stat_real\n");
Andy Whitcroft4d001e42008-10-15 22:02:21 -07003201 }
3202 }
3203
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07003204 # Track the 'values' across context and added lines.
3205 my $opline = $line; $opline =~ s/^./ /;
Andy Whitcroft1f65f942008-07-23 21:29:10 -07003206 my ($curr_values, $curr_vars) =
3207 annotate_values($opline . "\n", $prev_values);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07003208 $curr_values = $prev_values . $curr_values;
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08003209 if ($dbg_values) {
3210 my $outline = $opline; $outline =~ s/\t/ /g;
Andy Whitcroftcf655042008-03-04 14:28:20 -08003211 print "$linenr > .$outline\n";
3212 print "$linenr > $curr_values\n";
Andy Whitcroft1f65f942008-07-23 21:29:10 -07003213 print "$linenr > $curr_vars\n";
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08003214 }
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07003215 $prev_values = substr($curr_values, -1);
3216
Andy Whitcroft00df3442007-06-08 13:47:06 -07003217#ignore lines not being added
Joe Perches3705ce52013-07-03 15:05:31 -07003218 next if ($line =~ /^[^\+]/);
Andy Whitcroft00df3442007-06-08 13:47:06 -07003219
Andy Whitcroft653d4872007-06-23 17:16:34 -07003220# TEST: allow direct testing of the type matcher.
Andy Whitcroft7429c692008-07-23 21:29:06 -07003221 if ($dbg_type) {
3222 if ($line =~ /^.\s*$Declare\s*$/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003223 ERROR("TEST_TYPE",
3224 "TEST: is type\n" . $herecurr);
Andy Whitcroft7429c692008-07-23 21:29:06 -07003225 } elsif ($dbg_type > 1 && $line =~ /^.+($Declare)/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003226 ERROR("TEST_NOT_TYPE",
3227 "TEST: is not type ($1 is)\n". $herecurr);
Andy Whitcroft7429c692008-07-23 21:29:06 -07003228 }
Andy Whitcroft653d4872007-06-23 17:16:34 -07003229 next;
3230 }
Andy Whitcrofta1ef2772008-10-15 22:02:17 -07003231# TEST: allow direct testing of the attribute matcher.
3232 if ($dbg_attr) {
Andy Whitcroft9360b0e2009-02-27 14:03:08 -08003233 if ($line =~ /^.\s*$Modifier\s*$/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003234 ERROR("TEST_ATTR",
3235 "TEST: is attr\n" . $herecurr);
Andy Whitcroft9360b0e2009-02-27 14:03:08 -08003236 } elsif ($dbg_attr > 1 && $line =~ /^.+($Modifier)/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003237 ERROR("TEST_NOT_ATTR",
3238 "TEST: is not attr ($1 is)\n". $herecurr);
Andy Whitcrofta1ef2772008-10-15 22:02:17 -07003239 }
3240 next;
3241 }
Andy Whitcroft653d4872007-06-23 17:16:34 -07003242
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07003243# check for initialisation to aggregates open brace on the next line
Andy Whitcroft99423c22009-10-26 16:50:15 -07003244 if ($line =~ /^.\s*{/ &&
3245 $prevline =~ /(?:^|[^=])=\s*$/) {
Joe Perchesd752fcc2014-08-06 16:11:05 -07003246 if (ERROR("OPEN_BRACE",
3247 "that open brace { should be on the previous line\n" . $hereprev) &&
Joe Perchesf2d7e4d2014-08-06 16:11:07 -07003248 $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
3249 fix_delete_line($fixlinenr - 1, $prevrawline);
3250 fix_delete_line($fixlinenr, $rawline);
Joe Perchesd752fcc2014-08-06 16:11:05 -07003251 my $fixedline = $prevrawline;
3252 $fixedline =~ s/\s*=\s*$/ = {/;
Joe Perchesf2d7e4d2014-08-06 16:11:07 -07003253 fix_insert_line($fixlinenr, $fixedline);
Joe Perchesd752fcc2014-08-06 16:11:05 -07003254 $fixedline = $line;
3255 $fixedline =~ s/^(.\s*){\s*/$1/;
Joe Perchesf2d7e4d2014-08-06 16:11:07 -07003256 fix_insert_line($fixlinenr, $fixedline);
Joe Perchesd752fcc2014-08-06 16:11:05 -07003257 }
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07003258 }
3259
Andy Whitcroft653d4872007-06-23 17:16:34 -07003260#
3261# Checks which are anchored on the added line.
3262#
3263
3264# check for malformed paths in #include statements (uses RAW line)
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07003265 if ($rawline =~ m{^.\s*\#\s*include\s+[<"](.*)[">]}) {
Andy Whitcroft653d4872007-06-23 17:16:34 -07003266 my $path = $1;
3267 if ($path =~ m{//}) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003268 ERROR("MALFORMED_INCLUDE",
Joe Perches495e9d82012-12-20 15:05:37 -08003269 "malformed #include filename\n" . $herecurr);
3270 }
3271 if ($path =~ "^uapi/" && $realfile =~ m@\binclude/uapi/@) {
3272 ERROR("UAPI_INCLUDE",
3273 "No #include in ...include/uapi/... should use a uapi/ path prefix\n" . $herecurr);
Andy Whitcroft653d4872007-06-23 17:16:34 -07003274 }
Andy Whitcroft653d4872007-06-23 17:16:34 -07003275 }
Andy Whitcroft00df3442007-06-08 13:47:06 -07003276
3277# no C99 // comments
3278 if ($line =~ m{//}) {
Joe Perches3705ce52013-07-03 15:05:31 -07003279 if (ERROR("C99_COMMENTS",
3280 "do not use C99 // comments\n" . $herecurr) &&
3281 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07003282 my $line = $fixed[$fixlinenr];
Joe Perches3705ce52013-07-03 15:05:31 -07003283 if ($line =~ /\/\/(.*)$/) {
3284 my $comment = trim($1);
Joe Perches194f66f2014-08-06 16:11:03 -07003285 $fixed[$fixlinenr] =~ s@\/\/(.*)$@/\* $comment \*/@;
Joe Perches3705ce52013-07-03 15:05:31 -07003286 }
3287 }
Andy Whitcroft00df3442007-06-08 13:47:06 -07003288 }
3289 # Remove C99 comments.
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003290 $line =~ s@//.*@@;
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07003291 $opline =~ s@//.*@@;
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003292
Andy Whitcroft2b474a12009-10-26 16:50:16 -07003293# EXPORT_SYMBOL should immediately follow the thing it is exporting, consider
3294# the whole statement.
3295#print "APW <$lines[$realline_next - 1]>\n";
3296 if (defined $realline_next &&
3297 exists $lines[$realline_next - 1] &&
3298 !defined $suppress_export{$realline_next} &&
3299 ($lines[$realline_next - 1] =~ /EXPORT_SYMBOL.*\((.*)\)/ ||
3300 $lines[$realline_next - 1] =~ /EXPORT_UNUSED_SYMBOL.*\((.*)\)/)) {
Andy Whitcroft3cbf62d2010-10-26 14:23:18 -07003301 # Handle definitions which produce identifiers with
3302 # a prefix:
3303 # XXX(foo);
3304 # EXPORT_SYMBOL(something_foo);
Andy Whitcroft653d4872007-06-23 17:16:34 -07003305 my $name = $1;
Andy Whitcroft87a53872012-01-10 15:10:04 -08003306 if ($stat =~ /^(?:.\s*}\s*\n)?.([A-Z_]+)\s*\(\s*($Ident)/ &&
Andy Whitcroft3cbf62d2010-10-26 14:23:18 -07003307 $name =~ /^${Ident}_$2/) {
3308#print "FOO C name<$name>\n";
3309 $suppress_export{$realline_next} = 1;
3310
3311 } elsif ($stat !~ /(?:
Andy Whitcroft2b474a12009-10-26 16:50:16 -07003312 \n.}\s*$|
Andy Whitcroft48012052008-10-15 22:02:34 -07003313 ^.DEFINE_$Ident\(\Q$name\E\)|
3314 ^.DECLARE_$Ident\(\Q$name\E\)|
3315 ^.LIST_HEAD\(\Q$name\E\)|
Andy Whitcroft2b474a12009-10-26 16:50:16 -07003316 ^.(?:$Storage\s+)?$Type\s*\(\s*\*\s*\Q$name\E\s*\)\s*\(|
3317 \b\Q$name\E(?:\s+$Attribute)*\s*(?:;|=|\[|\()
Andy Whitcroft48012052008-10-15 22:02:34 -07003318 )/x) {
Andy Whitcroft2b474a12009-10-26 16:50:16 -07003319#print "FOO A<$lines[$realline_next - 1]> stat<$stat> name<$name>\n";
3320 $suppress_export{$realline_next} = 2;
3321 } else {
3322 $suppress_export{$realline_next} = 1;
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003323 }
3324 }
Andy Whitcroft2b474a12009-10-26 16:50:16 -07003325 if (!defined $suppress_export{$linenr} &&
3326 $prevline =~ /^.\s*$/ &&
3327 ($line =~ /EXPORT_SYMBOL.*\((.*)\)/ ||
3328 $line =~ /EXPORT_UNUSED_SYMBOL.*\((.*)\)/)) {
3329#print "FOO B <$lines[$linenr - 1]>\n";
3330 $suppress_export{$linenr} = 2;
3331 }
3332 if (defined $suppress_export{$linenr} &&
3333 $suppress_export{$linenr} == 2) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003334 WARN("EXPORT_SYMBOL",
3335 "EXPORT_SYMBOL(foo); should immediately follow its function/variable\n" . $herecurr);
Andy Whitcroft2b474a12009-10-26 16:50:16 -07003336 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003337
Joe Eloff5150bda2010-08-09 17:21:00 -07003338# check for global initialisers.
Joe Perches6d32f7a2015-11-06 16:31:37 -08003339 if ($line =~ /^\+$Type\s*$Ident(?:\s+$Modifier)*\s*=\s*($zero_initializer)\s*;/) {
Joe Perchesd5e616f2013-09-11 14:23:54 -07003340 if (ERROR("GLOBAL_INITIALISERS",
Joe Perches6d32f7a2015-11-06 16:31:37 -08003341 "do not initialise globals to $1\n" . $herecurr) &&
Joe Perchesd5e616f2013-09-11 14:23:54 -07003342 $fix) {
Joe Perches6d32f7a2015-11-06 16:31:37 -08003343 $fixed[$fixlinenr] =~ s/(^.$Type\s*$Ident(?:\s+$Modifier)*)\s*=\s*$zero_initializer\s*;/$1;/;
Joe Perchesd5e616f2013-09-11 14:23:54 -07003344 }
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07003345 }
Andy Whitcroft653d4872007-06-23 17:16:34 -07003346# check for static initialisers.
Joe Perches6d32f7a2015-11-06 16:31:37 -08003347 if ($line =~ /^\+.*\bstatic\s.*=\s*($zero_initializer)\s*;/) {
Joe Perchesd5e616f2013-09-11 14:23:54 -07003348 if (ERROR("INITIALISED_STATIC",
Joe Perches6d32f7a2015-11-06 16:31:37 -08003349 "do not initialise statics to $1\n" .
Joe Perchesd5e616f2013-09-11 14:23:54 -07003350 $herecurr) &&
3351 $fix) {
Joe Perches6d32f7a2015-11-06 16:31:37 -08003352 $fixed[$fixlinenr] =~ s/(\bstatic\s.*?)\s*=\s*$zero_initializer\s*;/$1;/;
Joe Perchesd5e616f2013-09-11 14:23:54 -07003353 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003354 }
3355
Joe Perches18130872014-08-06 16:11:22 -07003356# check for misordered declarations of char/short/int/long with signed/unsigned
3357 while ($sline =~ m{(\b$TypeMisordered\b)}g) {
3358 my $tmp = trim($1);
3359 WARN("MISORDERED_TYPE",
3360 "type '$tmp' should be specified in [[un]signed] [short|int|long|long long] order\n" . $herecurr);
3361 }
3362
Joe Perchescb710ec2010-10-26 14:23:20 -07003363# check for static const char * arrays.
3364 if ($line =~ /\bstatic\s+const\s+char\s*\*\s*(\w+)\s*\[\s*\]\s*=\s*/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003365 WARN("STATIC_CONST_CHAR_ARRAY",
3366 "static const char * array should probably be static const char * const\n" .
Joe Perchescb710ec2010-10-26 14:23:20 -07003367 $herecurr);
3368 }
3369
3370# check for static char foo[] = "bar" declarations.
3371 if ($line =~ /\bstatic\s+char\s+(\w+)\s*\[\s*\]\s*=\s*"/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003372 WARN("STATIC_CONST_CHAR_ARRAY",
3373 "static char array declaration should probably be static const char\n" .
Joe Perchescb710ec2010-10-26 14:23:20 -07003374 $herecurr);
3375 }
3376
Joe Perchesab7e23f2015-04-16 12:44:22 -07003377# check for const <foo> const where <foo> is not a pointer or array type
3378 if ($sline =~ /\bconst\s+($BasicType)\s+const\b/) {
3379 my $found = $1;
3380 if ($sline =~ /\bconst\s+\Q$found\E\s+const\b\s*\*/) {
3381 WARN("CONST_CONST",
3382 "'const $found const *' should probably be 'const $found * const'\n" . $herecurr);
3383 } elsif ($sline !~ /\bconst\s+\Q$found\E\s+const\s+\w+\s*\[/) {
3384 WARN("CONST_CONST",
3385 "'const $found const' should probably be 'const $found'\n" . $herecurr);
3386 }
3387 }
3388
Joe Perches9b0fa602014-04-03 14:49:18 -07003389# check for non-global char *foo[] = {"bar", ...} declarations.
3390 if ($line =~ /^.\s+(?:static\s+|const\s+)?char\s+\*\s*\w+\s*\[\s*\]\s*=\s*\{/) {
3391 WARN("STATIC_CONST_CHAR_ARRAY",
3392 "char * array declaration might be better as static const\n" .
3393 $herecurr);
3394 }
3395
Joe Perchesb598b672015-04-16 12:44:36 -07003396# check for sizeof(foo)/sizeof(foo[0]) that could be ARRAY_SIZE(foo)
3397 if ($line =~ m@\bsizeof\s*\(\s*($Lval)\s*\)@) {
3398 my $array = $1;
3399 if ($line =~ m@\b(sizeof\s*\(\s*\Q$array\E\s*\)\s*/\s*sizeof\s*\(\s*\Q$array\E\s*\[\s*0\s*\]\s*\))@) {
3400 my $array_div = $1;
3401 if (WARN("ARRAY_SIZE",
3402 "Prefer ARRAY_SIZE($array)\n" . $herecurr) &&
3403 $fix) {
3404 $fixed[$fixlinenr] =~ s/\Q$array_div\E/ARRAY_SIZE($array)/;
3405 }
3406 }
3407 }
3408
Joe Perchesb36190c2014-01-27 17:07:18 -08003409# check for function declarations without arguments like "int foo()"
3410 if ($line =~ /(\b$Type\s+$Ident)\s*\(\s*\)/) {
3411 if (ERROR("FUNCTION_WITHOUT_ARGS",
3412 "Bad function definition - $1() should probably be $1(void)\n" . $herecurr) &&
3413 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07003414 $fixed[$fixlinenr] =~ s/(\b($Type)\s+($Ident))\s*\(\s*\)/$2 $3(void)/;
Joe Perchesb36190c2014-01-27 17:07:18 -08003415 }
3416 }
3417
Joe Perches92e112f2013-12-13 11:36:22 -07003418# check for uses of DEFINE_PCI_DEVICE_TABLE
3419 if ($line =~ /\bDEFINE_PCI_DEVICE_TABLE\s*\(\s*(\w+)\s*\)\s*=/) {
3420 if (WARN("DEFINE_PCI_DEVICE_TABLE",
3421 "Prefer struct pci_device_id over deprecated DEFINE_PCI_DEVICE_TABLE\n" . $herecurr) &&
3422 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07003423 $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 -07003424 }
Joe Perches93ed0e22010-10-26 14:23:21 -07003425 }
3426
Andy Whitcroft653d4872007-06-23 17:16:34 -07003427# check for new typedefs, only function parameters and sparse annotations
3428# make sense.
3429 if ($line =~ /\btypedef\s/ &&
Andy Whitcroft80545762009-01-06 14:41:26 -08003430 $line !~ /\btypedef\s+$Type\s*\(\s*\*?$Ident\s*\)\s*\(/ &&
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07003431 $line !~ /\btypedef\s+$Type\s+$Ident\s*\(/ &&
Andy Whitcroft8ed22ca2008-10-15 22:02:32 -07003432 $line !~ /\b$typeTypedefs\b/ &&
Andy Whitcroft653d4872007-06-23 17:16:34 -07003433 $line !~ /\b__bitwise(?:__|)\b/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003434 WARN("NEW_TYPEDEFS",
3435 "do not add new typedefs\n" . $herecurr);
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003436 }
3437
3438# * goes on variable not on type
Andy Whitcroft65863862009-01-06 14:41:21 -08003439 # (char*[ const])
Andy Whitcroftbfcb2cc2012-01-10 15:10:15 -08003440 while ($line =~ m{(\($NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)\))}g) {
3441 #print "AA<$1>\n";
Joe Perches3705ce52013-07-03 15:05:31 -07003442 my ($ident, $from, $to) = ($1, $2, $2);
Andy Whitcroftd8aaf122007-06-23 17:16:44 -07003443
Andy Whitcroft65863862009-01-06 14:41:21 -08003444 # Should start with a space.
3445 $to =~ s/^(\S)/ $1/;
3446 # Should not end with a space.
3447 $to =~ s/\s+$//;
3448 # '*'s should not have spaces between.
Andy Whitcroftf9a0b3d2009-01-15 13:51:05 -08003449 while ($to =~ s/\*\s+\*/\*\*/) {
Andy Whitcroft65863862009-01-06 14:41:21 -08003450 }
Andy Whitcroftd8aaf122007-06-23 17:16:44 -07003451
Joe Perches3705ce52013-07-03 15:05:31 -07003452## print "1: from<$from> to<$to> ident<$ident>\n";
Andy Whitcroft65863862009-01-06 14:41:21 -08003453 if ($from ne $to) {
Joe Perches3705ce52013-07-03 15:05:31 -07003454 if (ERROR("POINTER_LOCATION",
3455 "\"(foo$from)\" should be \"(foo$to)\"\n" . $herecurr) &&
3456 $fix) {
3457 my $sub_from = $ident;
3458 my $sub_to = $ident;
3459 $sub_to =~ s/\Q$from\E/$to/;
Joe Perches194f66f2014-08-06 16:11:03 -07003460 $fixed[$fixlinenr] =~
Joe Perches3705ce52013-07-03 15:05:31 -07003461 s@\Q$sub_from\E@$sub_to@;
3462 }
Andy Whitcroft65863862009-01-06 14:41:21 -08003463 }
Andy Whitcroftbfcb2cc2012-01-10 15:10:15 -08003464 }
3465 while ($line =~ m{(\b$NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)($Ident))}g) {
3466 #print "BB<$1>\n";
Joe Perches3705ce52013-07-03 15:05:31 -07003467 my ($match, $from, $to, $ident) = ($1, $2, $2, $3);
Andy Whitcroftd8aaf122007-06-23 17:16:44 -07003468
Andy Whitcroft65863862009-01-06 14:41:21 -08003469 # Should start with a space.
3470 $to =~ s/^(\S)/ $1/;
3471 # Should not end with a space.
3472 $to =~ s/\s+$//;
3473 # '*'s should not have spaces between.
Andy Whitcroftf9a0b3d2009-01-15 13:51:05 -08003474 while ($to =~ s/\*\s+\*/\*\*/) {
Andy Whitcroft65863862009-01-06 14:41:21 -08003475 }
3476 # Modifiers should have spaces.
3477 $to =~ s/(\b$Modifier$)/$1 /;
3478
Joe Perches3705ce52013-07-03 15:05:31 -07003479## print "2: from<$from> to<$to> ident<$ident>\n";
Andy Whitcroft667026e2009-02-27 14:03:08 -08003480 if ($from ne $to && $ident !~ /^$Modifier$/) {
Joe Perches3705ce52013-07-03 15:05:31 -07003481 if (ERROR("POINTER_LOCATION",
3482 "\"foo${from}bar\" should be \"foo${to}bar\"\n" . $herecurr) &&
3483 $fix) {
3484
3485 my $sub_from = $match;
3486 my $sub_to = $match;
3487 $sub_to =~ s/\Q$from\E/$to/;
Joe Perches194f66f2014-08-06 16:11:03 -07003488 $fixed[$fixlinenr] =~
Joe Perches3705ce52013-07-03 15:05:31 -07003489 s@\Q$sub_from\E@$sub_to@;
3490 }
Andy Whitcroft65863862009-01-06 14:41:21 -08003491 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003492 }
3493
Joe Perches9d3e3c72015-09-09 15:37:27 -07003494# avoid BUG() or BUG_ON()
3495 if ($line =~ /\b(?:BUG|BUG_ON)\b/) {
3496 my $msg_type = \&WARN;
3497 $msg_type = \&CHK if ($file);
3498 &{$msg_type}("AVOID_BUG",
3499 "Avoid crashing the kernel - try using WARN_ON & recovery code rather than BUG() or BUG_ON()\n" . $herecurr);
3500 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003501
Joe Perches9d3e3c72015-09-09 15:37:27 -07003502# avoid LINUX_VERSION_CODE
Andy Whitcroft8905a672007-11-28 16:21:06 -08003503 if ($line =~ /\bLINUX_VERSION_CODE\b/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003504 WARN("LINUX_VERSION_CODE",
3505 "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 -08003506 }
3507
Joe Perches17441222011-06-15 15:08:17 -07003508# check for uses of printk_ratelimit
3509 if ($line =~ /\bprintk_ratelimit\s*\(/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003510 WARN("PRINTK_RATELIMITED",
Joe Perches101ee682015-02-13 14:38:54 -08003511 "Prefer printk_ratelimited or pr_<level>_ratelimited to printk_ratelimit\n" . $herecurr);
Joe Perches17441222011-06-15 15:08:17 -07003512 }
3513
Andy Whitcroft00df3442007-06-08 13:47:06 -07003514# printk should use KERN_* levels. Note that follow on printk's on the
3515# same line do not need a level, so we use the current block context
3516# to try and find and validate the current printk. In summary the current
Lucas De Marchi25985ed2011-03-30 22:57:33 -03003517# printk includes all preceding printk's which have no newline on the end.
Andy Whitcroft00df3442007-06-08 13:47:06 -07003518# we assume the first bad printk is the one to report.
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07003519 if ($line =~ /\bprintk\((?!KERN_)\s*"/) {
Andy Whitcroft00df3442007-06-08 13:47:06 -07003520 my $ok = 0;
3521 for (my $ln = $linenr - 1; $ln >= $first_line; $ln--) {
3522 #print "CHECK<$lines[$ln - 1]\n";
Lucas De Marchi25985ed2011-03-30 22:57:33 -03003523 # we have a preceding printk if it ends
Andy Whitcroft00df3442007-06-08 13:47:06 -07003524 # with "\n" ignore it, else it is to blame
3525 if ($lines[$ln - 1] =~ m{\bprintk\(}) {
3526 if ($rawlines[$ln - 1] !~ m{\\n"}) {
3527 $ok = 1;
3528 }
3529 last;
3530 }
3531 }
3532 if ($ok == 0) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003533 WARN("PRINTK_WITHOUT_KERN_LEVEL",
3534 "printk() should include KERN_ facility level\n" . $herecurr);
Andy Whitcroft00df3442007-06-08 13:47:06 -07003535 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003536 }
3537
Joe Perches243f3802012-05-31 16:26:09 -07003538 if ($line =~ /\bprintk\s*\(\s*KERN_([A-Z]+)/) {
3539 my $orig = $1;
3540 my $level = lc($orig);
3541 $level = "warn" if ($level eq "warning");
Joe Perches8f26b832012-10-04 17:13:32 -07003542 my $level2 = $level;
3543 $level2 = "dbg" if ($level eq "debug");
Joe Perches243f3802012-05-31 16:26:09 -07003544 WARN("PREFER_PR_LEVEL",
Yogesh Chaudharidaa8b052014-04-03 14:49:23 -07003545 "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 -07003546 }
3547
3548 if ($line =~ /\bpr_warning\s*\(/) {
Joe Perchesd5e616f2013-09-11 14:23:54 -07003549 if (WARN("PREFER_PR_LEVEL",
3550 "Prefer pr_warn(... to pr_warning(...\n" . $herecurr) &&
3551 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07003552 $fixed[$fixlinenr] =~
Joe Perchesd5e616f2013-09-11 14:23:54 -07003553 s/\bpr_warning\b/pr_warn/;
3554 }
Joe Perches243f3802012-05-31 16:26:09 -07003555 }
3556
Joe Perchesdc139312013-02-21 16:44:13 -08003557 if ($line =~ /\bdev_printk\s*\(\s*KERN_([A-Z]+)/) {
3558 my $orig = $1;
3559 my $level = lc($orig);
3560 $level = "warn" if ($level eq "warning");
3561 $level = "dbg" if ($level eq "debug");
3562 WARN("PREFER_DEV_LEVEL",
3563 "Prefer dev_$level(... to dev_printk(KERN_$orig, ...\n" . $herecurr);
3564 }
3565
Andy Lutomirski91c9afa2015-04-16 12:44:44 -07003566# ENOSYS means "bad syscall nr" and nothing else. This will have a small
3567# number of false positives, but assembly files are not checked, so at
3568# least the arch entry code will not trigger this warning.
3569 if ($line =~ /\bENOSYS\b/) {
3570 WARN("ENOSYS",
3571 "ENOSYS means 'invalid syscall nr' and nothing else\n" . $herecurr);
3572 }
3573
Andy Whitcroft653d4872007-06-23 17:16:34 -07003574# function brace can't be on same line, except for #defines of do while,
3575# or if closed on same line
Joe Perches8d182472014-08-06 16:11:12 -07003576 if (($line=~/$Type\s*$Ident\(.*\).*\s*{/) and
Eddie Kovsky4e5d56b2015-09-09 15:37:52 -07003577 !($line=~/\#\s*define.*do\s\{/) and !($line=~/}/)) {
Joe Perches8d182472014-08-06 16:11:12 -07003578 if (ERROR("OPEN_BRACE",
3579 "open brace '{' following function declarations go on the next line\n" . $herecurr) &&
3580 $fix) {
3581 fix_delete_line($fixlinenr, $rawline);
3582 my $fixed_line = $rawline;
3583 $fixed_line =~ /(^..*$Type\s*$Ident\(.*\)\s*){(.*)$/;
3584 my $line1 = $1;
3585 my $line2 = $2;
3586 fix_insert_line($fixlinenr, ltrim($line1));
3587 fix_insert_line($fixlinenr, "\+{");
3588 if ($line2 !~ /^\s*$/) {
3589 fix_insert_line($fixlinenr, "\+\t" . trim($line2));
3590 }
3591 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003592 }
Andy Whitcroft653d4872007-06-23 17:16:34 -07003593
Andy Whitcroft8905a672007-11-28 16:21:06 -08003594# open braces for enum, union and struct go on the same line.
3595 if ($line =~ /^.\s*{/ &&
3596 $prevline =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident)?\s*$/) {
Joe Perches8d182472014-08-06 16:11:12 -07003597 if (ERROR("OPEN_BRACE",
3598 "open brace '{' following $1 go on the same line\n" . $hereprev) &&
3599 $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
3600 fix_delete_line($fixlinenr - 1, $prevrawline);
3601 fix_delete_line($fixlinenr, $rawline);
3602 my $fixedline = rtrim($prevrawline) . " {";
3603 fix_insert_line($fixlinenr, $fixedline);
3604 $fixedline = $rawline;
3605 $fixedline =~ s/^(.\s*){\s*/$1\t/;
3606 if ($fixedline !~ /^\+\s*$/) {
3607 fix_insert_line($fixlinenr, $fixedline);
3608 }
3609 }
Andy Whitcroft8905a672007-11-28 16:21:06 -08003610 }
3611
Andy Whitcroft0c73b4e2010-10-26 14:23:15 -07003612# missing space after union, struct or enum definition
Joe Perches3705ce52013-07-03 15:05:31 -07003613 if ($line =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident){1,2}[=\{]/) {
3614 if (WARN("SPACING",
3615 "missing space after $1 definition\n" . $herecurr) &&
3616 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07003617 $fixed[$fixlinenr] =~
Joe Perches3705ce52013-07-03 15:05:31 -07003618 s/^(.\s*(?:typedef\s+)?(?:enum|union|struct)(?:\s+$Ident){1,2})([=\{])/$1 $2/;
3619 }
Andy Whitcroft0c73b4e2010-10-26 14:23:15 -07003620 }
3621
Joe Perches31070b52014-01-23 15:54:49 -08003622# Function pointer declarations
3623# check spacing between type, funcptr, and args
3624# canonical declaration is "type (*funcptr)(args...)"
Joe Perches91f72e92014-04-03 14:49:12 -07003625 if ($line =~ /^.\s*($Declare)\((\s*)\*(\s*)($Ident)(\s*)\)(\s*)\(/) {
Joe Perches31070b52014-01-23 15:54:49 -08003626 my $declare = $1;
3627 my $pre_pointer_space = $2;
3628 my $post_pointer_space = $3;
3629 my $funcname = $4;
3630 my $post_funcname_space = $5;
3631 my $pre_args_space = $6;
3632
Joe Perches91f72e92014-04-03 14:49:12 -07003633# the $Declare variable will capture all spaces after the type
3634# so check it for a missing trailing missing space but pointer return types
3635# don't need a space so don't warn for those.
3636 my $post_declare_space = "";
3637 if ($declare =~ /(\s+)$/) {
3638 $post_declare_space = $1;
3639 $declare = rtrim($declare);
3640 }
3641 if ($declare !~ /\*$/ && $post_declare_space =~ /^$/) {
Joe Perches31070b52014-01-23 15:54:49 -08003642 WARN("SPACING",
3643 "missing space after return type\n" . $herecurr);
Joe Perches91f72e92014-04-03 14:49:12 -07003644 $post_declare_space = " ";
Joe Perches31070b52014-01-23 15:54:49 -08003645 }
3646
3647# unnecessary space "type (*funcptr)(args...)"
Joe Perches91f72e92014-04-03 14:49:12 -07003648# This test is not currently implemented because these declarations are
3649# equivalent to
3650# int foo(int bar, ...)
3651# and this is form shouldn't/doesn't generate a checkpatch warning.
3652#
3653# elsif ($declare =~ /\s{2,}$/) {
3654# WARN("SPACING",
3655# "Multiple spaces after return type\n" . $herecurr);
3656# }
Joe Perches31070b52014-01-23 15:54:49 -08003657
3658# unnecessary space "type ( *funcptr)(args...)"
3659 if (defined $pre_pointer_space &&
3660 $pre_pointer_space =~ /^\s/) {
3661 WARN("SPACING",
3662 "Unnecessary space after function pointer open parenthesis\n" . $herecurr);
3663 }
3664
3665# unnecessary space "type (* funcptr)(args...)"
3666 if (defined $post_pointer_space &&
3667 $post_pointer_space =~ /^\s/) {
3668 WARN("SPACING",
3669 "Unnecessary space before function pointer name\n" . $herecurr);
3670 }
3671
3672# unnecessary space "type (*funcptr )(args...)"
3673 if (defined $post_funcname_space &&
3674 $post_funcname_space =~ /^\s/) {
3675 WARN("SPACING",
3676 "Unnecessary space after function pointer name\n" . $herecurr);
3677 }
3678
3679# unnecessary space "type (*funcptr) (args...)"
3680 if (defined $pre_args_space &&
3681 $pre_args_space =~ /^\s/) {
3682 WARN("SPACING",
3683 "Unnecessary space before function pointer arguments\n" . $herecurr);
3684 }
3685
3686 if (show_type("SPACING") && $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07003687 $fixed[$fixlinenr] =~
Joe Perches91f72e92014-04-03 14:49:12 -07003688 s/^(.\s*)$Declare\s*\(\s*\*\s*$Ident\s*\)\s*\(/$1 . $declare . $post_declare_space . '(*' . $funcname . ')('/ex;
Joe Perches31070b52014-01-23 15:54:49 -08003689 }
3690 }
3691
Andy Whitcroft8d31cfc2008-07-23 21:29:02 -07003692# check for spacing round square brackets; allowed:
3693# 1. with a type on the left -- int [] a;
Andy Whitcroftfe2a7db2008-10-15 22:02:15 -07003694# 2. at the beginning of a line for slice initialisers -- [0...10] = 5,
3695# 3. inside a curly brace -- = { [0...10] = 5 }
Andy Whitcroft8d31cfc2008-07-23 21:29:02 -07003696 while ($line =~ /(.*?\s)\[/g) {
3697 my ($where, $prefix) = ($-[1], $1);
3698 if ($prefix !~ /$Type\s+$/ &&
Andy Whitcroftfe2a7db2008-10-15 22:02:15 -07003699 ($where != 0 || $prefix !~ /^.\s+$/) &&
Andy Whitcroftdaebc532012-03-23 15:02:17 -07003700 $prefix !~ /[{,]\s+$/) {
Joe Perches3705ce52013-07-03 15:05:31 -07003701 if (ERROR("BRACKET_SPACE",
3702 "space prohibited before open square bracket '['\n" . $herecurr) &&
3703 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07003704 $fixed[$fixlinenr] =~
Joe Perches3705ce52013-07-03 15:05:31 -07003705 s/^(\+.*?)\s+\[/$1\[/;
3706 }
Andy Whitcroft8d31cfc2008-07-23 21:29:02 -07003707 }
3708 }
3709
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07003710# check for spaces between functions and their parentheses.
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07003711 while ($line =~ /($Ident)\s+\(/g) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08003712 my $name = $1;
Andy Whitcroft773647a2008-03-28 14:15:58 -07003713 my $ctx_before = substr($line, 0, $-[1]);
3714 my $ctx = "$ctx_before$name";
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08003715
3716 # Ignore those directives where spaces _are_ permitted.
Andy Whitcroft773647a2008-03-28 14:15:58 -07003717 if ($name =~ /^(?:
3718 if|for|while|switch|return|case|
3719 volatile|__volatile__|
3720 __attribute__|format|__extension__|
3721 asm|__asm__)$/x)
3722 {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08003723 # cpp #define statements have non-optional spaces, ie
3724 # if there is a space between the name and the open
3725 # parenthesis it is simply not a parameter group.
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07003726 } elsif ($ctx_before =~ /^.\s*\#\s*define\s*$/) {
Andy Whitcroft773647a2008-03-28 14:15:58 -07003727
3728 # cpp #elif statement condition may start with a (
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07003729 } elsif ($ctx =~ /^.\s*\#\s*elif\s*$/) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08003730
3731 # If this whole things ends with a type its most
3732 # likely a typedef for a function.
Andy Whitcroft773647a2008-03-28 14:15:58 -07003733 } elsif ($ctx =~ /$Type$/) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08003734
3735 } else {
Joe Perches3705ce52013-07-03 15:05:31 -07003736 if (WARN("SPACING",
3737 "space prohibited between function name and open parenthesis '('\n" . $herecurr) &&
3738 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07003739 $fixed[$fixlinenr] =~
Joe Perches3705ce52013-07-03 15:05:31 -07003740 s/\b$name\s+\(/$name\(/;
3741 }
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07003742 }
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07003743 }
Eric Nelson9a4cad42012-05-31 16:26:09 -07003744
Andy Whitcroft653d4872007-06-23 17:16:34 -07003745# Check operator spacing.
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003746 if (!($line=~/\#\s*include/)) {
Joe Perches3705ce52013-07-03 15:05:31 -07003747 my $fixed_line = "";
3748 my $line_fixed = 0;
3749
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07003750 my $ops = qr{
3751 <<=|>>=|<=|>=|==|!=|
3752 \+=|-=|\*=|\/=|%=|\^=|\|=|&=|
3753 =>|->|<<|>>|<|>|=|!|~|
Andy Whitcroft1f65f942008-07-23 21:29:10 -07003754 &&|\|\||,|\^|\+\+|--|&|\||\+|-|\*|\/|%|
Joe Perches84731622013-11-12 15:10:05 -08003755 \?:|\?|:
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07003756 }x;
Andy Whitcroftcf655042008-03-04 14:28:20 -08003757 my @elements = split(/($ops|;)/, $opline);
Joe Perches3705ce52013-07-03 15:05:31 -07003758
3759## print("element count: <" . $#elements . ">\n");
3760## foreach my $el (@elements) {
3761## print("el: <$el>\n");
3762## }
3763
3764 my @fix_elements = ();
Andy Whitcroft00df3442007-06-08 13:47:06 -07003765 my $off = 0;
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07003766
Joe Perches3705ce52013-07-03 15:05:31 -07003767 foreach my $el (@elements) {
3768 push(@fix_elements, substr($rawline, $off, length($el)));
3769 $off += length($el);
3770 }
3771
3772 $off = 0;
3773
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07003774 my $blank = copy_spacing($opline);
Joe Perchesb34c6482013-09-11 14:24:01 -07003775 my $last_after = -1;
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07003776
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003777 for (my $n = 0; $n < $#elements; $n += 2) {
Joe Perches3705ce52013-07-03 15:05:31 -07003778
3779 my $good = $fix_elements[$n] . $fix_elements[$n + 1];
3780
3781## print("n: <$n> good: <$good>\n");
3782
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07003783 $off += length($elements[$n]);
3784
Lucas De Marchi25985ed2011-03-30 22:57:33 -03003785 # Pick up the preceding and succeeding characters.
Andy Whitcroft773647a2008-03-28 14:15:58 -07003786 my $ca = substr($opline, 0, $off);
3787 my $cc = '';
3788 if (length($opline) >= ($off + length($elements[$n + 1]))) {
3789 $cc = substr($opline, $off + length($elements[$n + 1]));
3790 }
3791 my $cb = "$ca$;$cc";
3792
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07003793 my $a = '';
3794 $a = 'V' if ($elements[$n] ne '');
3795 $a = 'W' if ($elements[$n] =~ /\s$/);
Andy Whitcroftcf655042008-03-04 14:28:20 -08003796 $a = 'C' if ($elements[$n] =~ /$;$/);
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07003797 $a = 'B' if ($elements[$n] =~ /(\[|\()$/);
3798 $a = 'O' if ($elements[$n] eq '');
Andy Whitcroft773647a2008-03-28 14:15:58 -07003799 $a = 'E' if ($ca =~ /^\s*$/);
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07003800
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003801 my $op = $elements[$n + 1];
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07003802
3803 my $c = '';
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003804 if (defined $elements[$n + 2]) {
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07003805 $c = 'V' if ($elements[$n + 2] ne '');
3806 $c = 'W' if ($elements[$n + 2] =~ /^\s/);
Andy Whitcroftcf655042008-03-04 14:28:20 -08003807 $c = 'C' if ($elements[$n + 2] =~ /^$;/);
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07003808 $c = 'B' if ($elements[$n + 2] =~ /^(\)|\]|;)/);
3809 $c = 'O' if ($elements[$n + 2] eq '');
Andy Whitcroft8b1b3372009-01-06 14:41:27 -08003810 $c = 'E' if ($elements[$n + 2] =~ /^\s*\\$/);
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07003811 } else {
3812 $c = 'E';
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003813 }
3814
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07003815 my $ctx = "${a}x${c}";
3816
3817 my $at = "(ctx:$ctx)";
3818
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07003819 my $ptr = substr($blank, 0, $off) . "^";
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07003820 my $hereptr = "$hereline$ptr\n";
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003821
Andy Whitcroft74048ed2008-07-23 21:29:10 -07003822 # Pull out the value of this operator.
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07003823 my $op_type = substr($curr_values, $off + 1, 1);
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003824
Andy Whitcroft1f65f942008-07-23 21:29:10 -07003825 # Get the full operator variant.
3826 my $opv = $op . substr($curr_vars, $off, 1);
3827
Andy Whitcroft13214ad2008-02-08 04:22:03 -08003828 # Ignore operators passed as parameters.
3829 if ($op_type ne 'V' &&
Sam Bobroffd7fe8062015-04-16 12:44:39 -07003830 $ca =~ /\s$/ && $cc =~ /^\s*[,\)]/) {
Andy Whitcroft13214ad2008-02-08 04:22:03 -08003831
Andy Whitcroftcf655042008-03-04 14:28:20 -08003832# # Ignore comments
3833# } elsif ($op =~ /^$;+$/) {
Andy Whitcroft13214ad2008-02-08 04:22:03 -08003834
Andy Whitcroftd8aaf122007-06-23 17:16:44 -07003835 # ; should have either the end of line or a space or \ after it
Andy Whitcroft13214ad2008-02-08 04:22:03 -08003836 } elsif ($op eq ';') {
Andy Whitcroftcf655042008-03-04 14:28:20 -08003837 if ($ctx !~ /.x[WEBC]/ &&
3838 $cc !~ /^\\/ && $cc !~ /^;/) {
Joe Perches3705ce52013-07-03 15:05:31 -07003839 if (ERROR("SPACING",
3840 "space required after that '$op' $at\n" . $hereptr)) {
Joe Perchesb34c6482013-09-11 14:24:01 -07003841 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";
Joe Perches3705ce52013-07-03 15:05:31 -07003842 $line_fixed = 1;
3843 }
Andy Whitcroftd8aaf122007-06-23 17:16:44 -07003844 }
3845
3846 # // is a comment
3847 } elsif ($op eq '//') {
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003848
Joe Perchesb00e4812014-04-03 14:49:33 -07003849 # : when part of a bitfield
3850 } elsif ($opv eq ':B') {
3851 # skip the bitfield test for now
3852
Andy Whitcroft1f65f942008-07-23 21:29:10 -07003853 # No spaces for:
3854 # ->
Joe Perchesb00e4812014-04-03 14:49:33 -07003855 } elsif ($op eq '->') {
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07003856 if ($ctx =~ /Wx.|.xW/) {
Joe Perches3705ce52013-07-03 15:05:31 -07003857 if (ERROR("SPACING",
3858 "spaces prohibited around that '$op' $at\n" . $hereptr)) {
Joe Perchesb34c6482013-09-11 14:24:01 -07003859 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
Joe Perches3705ce52013-07-03 15:05:31 -07003860 if (defined $fix_elements[$n + 2]) {
3861 $fix_elements[$n + 2] =~ s/^\s+//;
3862 }
Joe Perchesb34c6482013-09-11 14:24:01 -07003863 $line_fixed = 1;
Joe Perches3705ce52013-07-03 15:05:31 -07003864 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003865 }
3866
Joe Perches23810972014-12-10 15:51:32 -08003867 # , must not have a space before and must have a space on the right.
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003868 } elsif ($op eq ',') {
Joe Perches23810972014-12-10 15:51:32 -08003869 my $rtrim_before = 0;
3870 my $space_after = 0;
3871 if ($ctx =~ /Wx./) {
3872 if (ERROR("SPACING",
3873 "space prohibited before that '$op' $at\n" . $hereptr)) {
3874 $line_fixed = 1;
3875 $rtrim_before = 1;
3876 }
3877 }
Andy Whitcroftcf655042008-03-04 14:28:20 -08003878 if ($ctx !~ /.x[WEC]/ && $cc !~ /^}/) {
Joe Perches3705ce52013-07-03 15:05:31 -07003879 if (ERROR("SPACING",
3880 "space required after that '$op' $at\n" . $hereptr)) {
Joe Perches3705ce52013-07-03 15:05:31 -07003881 $line_fixed = 1;
Joe Perchesb34c6482013-09-11 14:24:01 -07003882 $last_after = $n;
Joe Perches23810972014-12-10 15:51:32 -08003883 $space_after = 1;
3884 }
3885 }
3886 if ($rtrim_before || $space_after) {
3887 if ($rtrim_before) {
3888 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
3889 } else {
3890 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]);
3891 }
3892 if ($space_after) {
3893 $good .= " ";
Joe Perches3705ce52013-07-03 15:05:31 -07003894 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003895 }
3896
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07003897 # '*' as part of a type definition -- reported already.
Andy Whitcroft74048ed2008-07-23 21:29:10 -07003898 } elsif ($opv eq '*_') {
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07003899 #warn "'*' is part of type\n";
3900
3901 # unary operators should have a space before and
3902 # none after. May be left adjacent to another
3903 # unary operator, or a cast
3904 } elsif ($op eq '!' || $op eq '~' ||
Andy Whitcroft74048ed2008-07-23 21:29:10 -07003905 $opv eq '*U' || $opv eq '-U' ||
Andy Whitcroft0d413862008-10-15 22:02:16 -07003906 $opv eq '&U' || $opv eq '&&U') {
Andy Whitcroftcf655042008-03-04 14:28:20 -08003907 if ($ctx !~ /[WEBC]x./ && $ca !~ /(?:\)|!|~|\*|-|\&|\||\+\+|\-\-|\{)$/) {
Joe Perches3705ce52013-07-03 15:05:31 -07003908 if (ERROR("SPACING",
3909 "space required before that '$op' $at\n" . $hereptr)) {
Joe Perchesb34c6482013-09-11 14:24:01 -07003910 if ($n != $last_after + 2) {
3911 $good = $fix_elements[$n] . " " . ltrim($fix_elements[$n + 1]);
3912 $line_fixed = 1;
3913 }
Joe Perches3705ce52013-07-03 15:05:31 -07003914 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003915 }
Andy Whitcrofta3340b32009-02-27 14:03:07 -08003916 if ($op eq '*' && $cc =~/\s*$Modifier\b/) {
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07003917 # A unary '*' may be const
3918
3919 } elsif ($ctx =~ /.xW/) {
Joe Perches3705ce52013-07-03 15:05:31 -07003920 if (ERROR("SPACING",
3921 "space prohibited after that '$op' $at\n" . $hereptr)) {
Joe Perchesb34c6482013-09-11 14:24:01 -07003922 $good = $fix_elements[$n] . rtrim($fix_elements[$n + 1]);
Joe Perches3705ce52013-07-03 15:05:31 -07003923 if (defined $fix_elements[$n + 2]) {
3924 $fix_elements[$n + 2] =~ s/^\s+//;
3925 }
Joe Perchesb34c6482013-09-11 14:24:01 -07003926 $line_fixed = 1;
Joe Perches3705ce52013-07-03 15:05:31 -07003927 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003928 }
3929
3930 # unary ++ and unary -- are allowed no space on one side.
3931 } elsif ($op eq '++' or $op eq '--') {
Andy Whitcroft773647a2008-03-28 14:15:58 -07003932 if ($ctx !~ /[WEOBC]x[^W]/ && $ctx !~ /[^W]x[WOBEC]/) {
Joe Perches3705ce52013-07-03 15:05:31 -07003933 if (ERROR("SPACING",
3934 "space required one side of that '$op' $at\n" . $hereptr)) {
Joe Perchesb34c6482013-09-11 14:24:01 -07003935 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";
Joe Perches3705ce52013-07-03 15:05:31 -07003936 $line_fixed = 1;
3937 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003938 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07003939 if ($ctx =~ /Wx[BE]/ ||
3940 ($ctx =~ /Wx./ && $cc =~ /^;/)) {
Joe Perches3705ce52013-07-03 15:05:31 -07003941 if (ERROR("SPACING",
3942 "space prohibited before that '$op' $at\n" . $hereptr)) {
Joe Perchesb34c6482013-09-11 14:24:01 -07003943 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
Joe Perches3705ce52013-07-03 15:05:31 -07003944 $line_fixed = 1;
3945 }
Andy Whitcroft653d4872007-06-23 17:16:34 -07003946 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07003947 if ($ctx =~ /ExW/) {
Joe Perches3705ce52013-07-03 15:05:31 -07003948 if (ERROR("SPACING",
3949 "space prohibited after that '$op' $at\n" . $hereptr)) {
Joe Perchesb34c6482013-09-11 14:24:01 -07003950 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]);
Joe Perches3705ce52013-07-03 15:05:31 -07003951 if (defined $fix_elements[$n + 2]) {
3952 $fix_elements[$n + 2] =~ s/^\s+//;
3953 }
Joe Perchesb34c6482013-09-11 14:24:01 -07003954 $line_fixed = 1;
Joe Perches3705ce52013-07-03 15:05:31 -07003955 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07003956 }
3957
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003958 # << and >> may either have or not have spaces both sides
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07003959 } elsif ($op eq '<<' or $op eq '>>' or
3960 $op eq '&' or $op eq '^' or $op eq '|' or
3961 $op eq '+' or $op eq '-' or
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08003962 $op eq '*' or $op eq '/' or
3963 $op eq '%')
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003964 {
Joe Perchesd2e025f2015-02-13 14:38:57 -08003965 if ($check) {
3966 if (defined $fix_elements[$n + 2] && $ctx !~ /[EW]x[EW]/) {
3967 if (CHK("SPACING",
3968 "spaces preferred around that '$op' $at\n" . $hereptr)) {
3969 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
3970 $fix_elements[$n + 2] =~ s/^\s+//;
3971 $line_fixed = 1;
3972 }
3973 } elsif (!defined $fix_elements[$n + 2] && $ctx !~ /Wx[OE]/) {
3974 if (CHK("SPACING",
3975 "space preferred before that '$op' $at\n" . $hereptr)) {
3976 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]);
3977 $line_fixed = 1;
3978 }
3979 }
3980 } elsif ($ctx =~ /Wx[^WCE]|[^WCE]xW/) {
Joe Perches3705ce52013-07-03 15:05:31 -07003981 if (ERROR("SPACING",
3982 "need consistent spacing around '$op' $at\n" . $hereptr)) {
Joe Perchesb34c6482013-09-11 14:24:01 -07003983 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
3984 if (defined $fix_elements[$n + 2]) {
3985 $fix_elements[$n + 2] =~ s/^\s+//;
3986 }
Joe Perches3705ce52013-07-03 15:05:31 -07003987 $line_fixed = 1;
3988 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003989 }
3990
Andy Whitcroft1f65f942008-07-23 21:29:10 -07003991 # A colon needs no spaces before when it is
3992 # terminating a case value or a label.
3993 } elsif ($opv eq ':C' || $opv eq ':L') {
3994 if ($ctx =~ /Wx./) {
Joe Perches3705ce52013-07-03 15:05:31 -07003995 if (ERROR("SPACING",
3996 "space prohibited before that '$op' $at\n" . $hereptr)) {
Joe Perchesb34c6482013-09-11 14:24:01 -07003997 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
Joe Perches3705ce52013-07-03 15:05:31 -07003998 $line_fixed = 1;
3999 }
Andy Whitcroft1f65f942008-07-23 21:29:10 -07004000 }
4001
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004002 # All the others need spaces both sides.
Andy Whitcroftcf655042008-03-04 14:28:20 -08004003 } elsif ($ctx !~ /[EWC]x[CWE]/) {
Andy Whitcroft1f65f942008-07-23 21:29:10 -07004004 my $ok = 0;
4005
Andy Whitcroft22f2a2e2007-08-10 13:01:03 -07004006 # Ignore email addresses <foo@bar>
Andy Whitcroft1f65f942008-07-23 21:29:10 -07004007 if (($op eq '<' &&
4008 $cc =~ /^\S+\@\S+>/) ||
4009 ($op eq '>' &&
4010 $ca =~ /<\S+\@\S+$/))
4011 {
4012 $ok = 1;
4013 }
4014
Joe Perchese0df7e12015-04-16 12:44:53 -07004015 # for asm volatile statements
4016 # ignore a colon with another
4017 # colon immediately before or after
4018 if (($op eq ':') &&
4019 ($ca =~ /:$/ || $cc =~ /^:/)) {
4020 $ok = 1;
4021 }
4022
Joe Perches84731622013-11-12 15:10:05 -08004023 # messages are ERROR, but ?: are CHK
Andy Whitcroft1f65f942008-07-23 21:29:10 -07004024 if ($ok == 0) {
Joe Perches84731622013-11-12 15:10:05 -08004025 my $msg_type = \&ERROR;
4026 $msg_type = \&CHK if (($op eq '?:' || $op eq '?' || $op eq ':') && $ctx =~ /VxV/);
4027
4028 if (&{$msg_type}("SPACING",
4029 "spaces required around that '$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 Whitcroft22f2a2e2007-08-10 13:01:03 -07004036 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004037 }
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07004038 $off += length($elements[$n + 1]);
Joe Perches3705ce52013-07-03 15:05:31 -07004039
4040## print("n: <$n> GOOD: <$good>\n");
4041
4042 $fixed_line = $fixed_line . $good;
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004043 }
Joe Perches3705ce52013-07-03 15:05:31 -07004044
4045 if (($#elements % 2) == 0) {
4046 $fixed_line = $fixed_line . $fix_elements[$#elements];
4047 }
4048
Joe Perches194f66f2014-08-06 16:11:03 -07004049 if ($fix && $line_fixed && $fixed_line ne $fixed[$fixlinenr]) {
4050 $fixed[$fixlinenr] = $fixed_line;
Joe Perches3705ce52013-07-03 15:05:31 -07004051 }
4052
4053
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004054 }
4055
Joe Perches786b6322013-07-03 15:05:32 -07004056# check for whitespace before a non-naked semicolon
Joe Perchesd2e248e2014-01-23 15:54:41 -08004057 if ($line =~ /^\+.*\S\s+;\s*$/) {
Joe Perches786b6322013-07-03 15:05:32 -07004058 if (WARN("SPACING",
4059 "space prohibited before semicolon\n" . $herecurr) &&
4060 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07004061 1 while $fixed[$fixlinenr] =~
Joe Perches786b6322013-07-03 15:05:32 -07004062 s/^(\+.*\S)\s+;/$1;/;
4063 }
4064 }
4065
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07004066# check for multiple assignments
4067 if ($line =~ /^.\s*$Lval\s*=\s*$Lval\s*=(?!=)/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07004068 CHK("MULTIPLE_ASSIGNMENTS",
4069 "multiple assignments should be avoided\n" . $herecurr);
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07004070 }
4071
Andy Whitcroft22f2a2e2007-08-10 13:01:03 -07004072## # check for multiple declarations, allowing for a function declaration
4073## # continuation.
4074## if ($line =~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Ident.*/ &&
4075## $line !~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Type\s*$Ident.*/) {
4076##
4077## # Remove any bracketed sections to ensure we do not
4078## # falsly report the parameters of functions.
4079## my $ln = $line;
4080## while ($ln =~ s/\([^\(\)]*\)//g) {
4081## }
4082## if ($ln =~ /,/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07004083## WARN("MULTIPLE_DECLARATION",
4084## "declaring multiple variables together should be avoided\n" . $herecurr);
Andy Whitcroft22f2a2e2007-08-10 13:01:03 -07004085## }
4086## }
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07004087
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004088#need space before brace following if, while, etc
Eddie Kovsky4e5d56b2015-09-09 15:37:52 -07004089 if (($line =~ /\(.*\)\{/ && $line !~ /\($Type\){/) ||
4090 $line =~ /do\{/) {
Joe Perches3705ce52013-07-03 15:05:31 -07004091 if (ERROR("SPACING",
4092 "space required before the open brace '{'\n" . $herecurr) &&
4093 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07004094 $fixed[$fixlinenr] =~ s/^(\+.*(?:do|\))){/$1 {/;
Joe Perches3705ce52013-07-03 15:05:31 -07004095 }
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07004096 }
4097
Joe Perchesc4a62ef2013-07-03 15:05:28 -07004098## # check for blank lines before declarations
4099## if ($line =~ /^.\t+$Type\s+$Ident(?:\s*=.*)?;/ &&
4100## $prevrawline =~ /^.\s*$/) {
4101## WARN("SPACING",
4102## "No blank lines before declarations\n" . $hereprev);
4103## }
4104##
4105
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07004106# closing brace should have a space following it when it has anything
4107# on the line
4108 if ($line =~ /}(?!(?:,|;|\)))\S/) {
Joe Perchesd5e616f2013-09-11 14:23:54 -07004109 if (ERROR("SPACING",
4110 "space required after that close brace '}'\n" . $herecurr) &&
4111 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07004112 $fixed[$fixlinenr] =~
Joe Perchesd5e616f2013-09-11 14:23:54 -07004113 s/}((?!(?:,|;|\)))\S)/} $1/;
4114 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004115 }
4116
Andy Whitcroft22f2a2e2007-08-10 13:01:03 -07004117# check spacing on square brackets
4118 if ($line =~ /\[\s/ && $line !~ /\[\s*$/) {
Joe Perches3705ce52013-07-03 15:05:31 -07004119 if (ERROR("SPACING",
4120 "space prohibited after that open square bracket '['\n" . $herecurr) &&
4121 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07004122 $fixed[$fixlinenr] =~
Joe Perches3705ce52013-07-03 15:05:31 -07004123 s/\[\s+/\[/;
4124 }
Andy Whitcroft22f2a2e2007-08-10 13:01:03 -07004125 }
4126 if ($line =~ /\s\]/) {
Joe Perches3705ce52013-07-03 15:05:31 -07004127 if (ERROR("SPACING",
4128 "space prohibited before that close square bracket ']'\n" . $herecurr) &&
4129 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07004130 $fixed[$fixlinenr] =~
Joe Perches3705ce52013-07-03 15:05:31 -07004131 s/\s+\]/\]/;
4132 }
Andy Whitcroft22f2a2e2007-08-10 13:01:03 -07004133 }
4134
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004135# check spacing on parentheses
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07004136 if ($line =~ /\(\s/ && $line !~ /\(\s*(?:\\)?$/ &&
4137 $line !~ /for\s*\(\s+;/) {
Joe Perches3705ce52013-07-03 15:05:31 -07004138 if (ERROR("SPACING",
4139 "space prohibited after that open parenthesis '('\n" . $herecurr) &&
4140 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07004141 $fixed[$fixlinenr] =~
Joe Perches3705ce52013-07-03 15:05:31 -07004142 s/\(\s+/\(/;
4143 }
Andy Whitcroft22f2a2e2007-08-10 13:01:03 -07004144 }
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004145 if ($line =~ /(\s+)\)/ && $line !~ /^.\s*\)/ &&
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004146 $line !~ /for\s*\(.*;\s+\)/ &&
4147 $line !~ /:\s+\)/) {
Joe Perches3705ce52013-07-03 15:05:31 -07004148 if (ERROR("SPACING",
4149 "space prohibited before that close parenthesis ')'\n" . $herecurr) &&
4150 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07004151 $fixed[$fixlinenr] =~
Joe Perches3705ce52013-07-03 15:05:31 -07004152 s/\s+\)/\)/;
4153 }
Andy Whitcroft22f2a2e2007-08-10 13:01:03 -07004154 }
4155
Joe Perchese2826fd2014-08-06 16:10:48 -07004156# check unnecessary parentheses around addressof/dereference single $Lvals
4157# ie: &(foo->bar) should be &foo->bar and *(foo->bar) should be *foo->bar
4158
4159 while ($line =~ /(?:[^&]&\s*|\*)\(\s*($Ident\s*(?:$Member\s*)+)\s*\)/g) {
Joe Perchesea4acbb2014-12-10 15:51:51 -08004160 my $var = $1;
4161 if (CHK("UNNECESSARY_PARENTHESES",
4162 "Unnecessary parentheses around $var\n" . $herecurr) &&
4163 $fix) {
4164 $fixed[$fixlinenr] =~ s/\(\s*\Q$var\E\s*\)/$var/;
4165 }
4166 }
4167
4168# check for unnecessary parentheses around function pointer uses
4169# ie: (foo->bar)(); should be foo->bar();
4170# but not "if (foo->bar) (" to avoid some false positives
4171 if ($line =~ /(\bif\s*|)(\(\s*$Ident\s*(?:$Member\s*)+\))[ \t]*\(/ && $1 !~ /^if/) {
4172 my $var = $2;
4173 if (CHK("UNNECESSARY_PARENTHESES",
4174 "Unnecessary parentheses around function pointer $var\n" . $herecurr) &&
4175 $fix) {
4176 my $var2 = deparenthesize($var);
4177 $var2 =~ s/\s//g;
4178 $fixed[$fixlinenr] =~ s/\Q$var\E/$var2/;
4179 }
4180 }
Joe Perchese2826fd2014-08-06 16:10:48 -07004181
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004182#goto labels aren't indented, allow a single space however
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07004183 if ($line=~/^.\s+[A-Za-z\d_]+:(?![0-9]+)/ and
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004184 !($line=~/^. [A-Za-z\d_]+:/) and !($line=~/^.\s+default:/)) {
Joe Perches3705ce52013-07-03 15:05:31 -07004185 if (WARN("INDENTED_LABEL",
4186 "labels should not be indented\n" . $herecurr) &&
4187 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07004188 $fixed[$fixlinenr] =~
Joe Perches3705ce52013-07-03 15:05:31 -07004189 s/^(.)\s+/$1/;
4190 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004191 }
4192
Joe Perches5b9553a2014-04-03 14:49:21 -07004193# return is not a function
Joe Perches507e5142013-11-12 15:10:13 -08004194 if (defined($stat) && $stat =~ /^.\s*return(\s*)\(/s) {
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004195 my $spacing = $1;
Joe Perches507e5142013-11-12 15:10:13 -08004196 if ($^V && $^V ge 5.10.0 &&
Joe Perches5b9553a2014-04-03 14:49:21 -07004197 $stat =~ /^.\s*return\s*($balanced_parens)\s*;\s*$/) {
4198 my $value = $1;
4199 $value = deparenthesize($value);
4200 if ($value =~ m/^\s*$FuncArg\s*(?:\?|$)/) {
4201 ERROR("RETURN_PARENTHESES",
4202 "return is not a function, parentheses are not required\n" . $herecurr);
4203 }
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004204 } elsif ($spacing !~ /\s+/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07004205 ERROR("SPACING",
4206 "space required before the open parenthesis '('\n" . $herecurr);
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004207 }
4208 }
Joe Perches507e5142013-11-12 15:10:13 -08004209
Joe Perchesb43ae212014-06-23 13:22:07 -07004210# unnecessary return in a void function
4211# at end-of-function, with the previous line a single leading tab, then return;
4212# and the line before that not a goto label target like "out:"
4213 if ($sline =~ /^[ \+]}\s*$/ &&
4214 $prevline =~ /^\+\treturn\s*;\s*$/ &&
4215 $linenr >= 3 &&
4216 $lines[$linenr - 3] =~ /^[ +]/ &&
4217 $lines[$linenr - 3] !~ /^[ +]\s*$Ident\s*:/) {
Joe Perches9819cf22014-06-04 16:12:09 -07004218 WARN("RETURN_VOID",
Joe Perchesb43ae212014-06-23 13:22:07 -07004219 "void function return statements are not generally useful\n" . $hereprev);
4220 }
Joe Perches9819cf22014-06-04 16:12:09 -07004221
Joe Perches189248d2014-01-23 15:54:47 -08004222# if statements using unnecessary parentheses - ie: if ((foo == bar))
4223 if ($^V && $^V ge 5.10.0 &&
4224 $line =~ /\bif\s*((?:\(\s*){2,})/) {
4225 my $openparens = $1;
4226 my $count = $openparens =~ tr@\(@\(@;
4227 my $msg = "";
4228 if ($line =~ /\bif\s*(?:\(\s*){$count,$count}$LvalOrFunc\s*($Compare)\s*$LvalOrFunc(?:\s*\)){$count,$count}/) {
4229 my $comp = $4; #Not $1 because of $LvalOrFunc
4230 $msg = " - maybe == should be = ?" if ($comp eq "==");
4231 WARN("UNNECESSARY_PARENTHESES",
4232 "Unnecessary parentheses$msg\n" . $herecurr);
4233 }
4234 }
4235
Joe Perchesc5595fa2015-09-09 15:37:58 -07004236# comparisons with a constant or upper case identifier on the left
4237# avoid cases like "foo + BAR < baz"
4238# only fix matches surrounded by parentheses to avoid incorrect
4239# conversions like "FOO < baz() + 5" being "misfixed" to "baz() > FOO + 5"
4240 if ($^V && $^V ge 5.10.0 &&
4241 $line =~ /^\+(.*)\b($Constant|[A-Z_][A-Z0-9_]*)\s*($Compare)\s*($LvalOrFunc)/) {
4242 my $lead = $1;
4243 my $const = $2;
4244 my $comp = $3;
4245 my $to = $4;
4246 my $newcomp = $comp;
4247 if ($lead !~ /$Operators\s*$/ &&
4248 $to !~ /^(?:Constant|[A-Z_][A-Z0-9_]*)$/ &&
4249 WARN("CONSTANT_COMPARISON",
4250 "Comparisons should place the constant on the right side of the test\n" . $herecurr) &&
4251 $fix) {
4252 if ($comp eq "<") {
4253 $newcomp = ">";
4254 } elsif ($comp eq "<=") {
4255 $newcomp = ">=";
4256 } elsif ($comp eq ">") {
4257 $newcomp = "<";
4258 } elsif ($comp eq ">=") {
4259 $newcomp = "<=";
4260 }
4261 $fixed[$fixlinenr] =~ s/\(\s*\Q$const\E\s*$Compare\s*\Q$to\E\s*\)/($to $newcomp $const)/;
4262 }
4263 }
4264
Joe Perchesf34e4a42015-04-16 12:44:19 -07004265# Return of what appears to be an errno should normally be negative
4266 if ($sline =~ /\breturn(?:\s*\(+\s*|\s+)(E[A-Z]+)(?:\s*\)+\s*|\s*)[;:,]/) {
Andy Whitcroft53a3c442010-10-26 14:23:14 -07004267 my $name = $1;
4268 if ($name ne 'EOF' && $name ne 'ERROR') {
Joe Perches000d1cc12011-07-25 17:13:25 -07004269 WARN("USE_NEGATIVE_ERRNO",
Joe Perchesf34e4a42015-04-16 12:44:19 -07004270 "return of an errno should typically be negative (ie: return -$1)\n" . $herecurr);
Andy Whitcroft53a3c442010-10-26 14:23:14 -07004271 }
4272 }
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004273
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004274# Need a space before open parenthesis after if, while etc
Joe Perches3705ce52013-07-03 15:05:31 -07004275 if ($line =~ /\b(if|while|for|switch)\(/) {
4276 if (ERROR("SPACING",
4277 "space required before the open parenthesis '('\n" . $herecurr) &&
4278 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07004279 $fixed[$fixlinenr] =~
Joe Perches3705ce52013-07-03 15:05:31 -07004280 s/\b(if|while|for|switch)\(/$1 \(/;
4281 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004282 }
4283
Andy Whitcroftf5fe35d2008-07-23 21:29:03 -07004284# Check for illegal assignment in if conditional -- and check for trailing
4285# statements after the conditional.
Andy Whitcroft170d3a22008-10-15 22:02:30 -07004286 if ($line =~ /do\s*(?!{)/) {
Andy Whitcroft3e469cd2012-01-10 15:10:01 -08004287 ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
4288 ctx_statement_block($linenr, $realcnt, 0)
4289 if (!defined $stat);
Andy Whitcroft170d3a22008-10-15 22:02:30 -07004290 my ($stat_next) = ctx_statement_block($line_nr_next,
4291 $remain_next, $off_next);
4292 $stat_next =~ s/\n./\n /g;
4293 ##print "stat<$stat> stat_next<$stat_next>\n";
4294
4295 if ($stat_next =~ /^\s*while\b/) {
4296 # If the statement carries leading newlines,
4297 # then count those as offsets.
4298 my ($whitespace) =
4299 ($stat_next =~ /^((?:\s*\n[+-])*\s*)/s);
4300 my $offset =
4301 statement_rawlines($whitespace) - 1;
4302
4303 $suppress_whiletrailers{$line_nr_next +
4304 $offset} = 1;
4305 }
4306 }
4307 if (!defined $suppress_whiletrailers{$linenr} &&
Joe Perchesc11230f2013-11-21 14:31:57 -08004308 defined($stat) && defined($cond) &&
Andy Whitcroft170d3a22008-10-15 22:02:30 -07004309 $line =~ /\b(?:if|while|for)\s*\(/ && $line !~ /^.\s*#/) {
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07004310 my ($s, $c) = ($stat, $cond);
Andy Whitcroft8905a672007-11-28 16:21:06 -08004311
Andy Whitcroftb53c8e12009-01-06 14:41:29 -08004312 if ($c =~ /\bif\s*\(.*[^<>!=]=[^=].*/s) {
Joe Perches000d1cc12011-07-25 17:13:25 -07004313 ERROR("ASSIGN_IN_IF",
4314 "do not use assignment in if condition\n" . $herecurr);
Andy Whitcroft8905a672007-11-28 16:21:06 -08004315 }
4316
4317 # Find out what is on the end of the line after the
4318 # conditional.
Andy Whitcroft773647a2008-03-28 14:15:58 -07004319 substr($s, 0, length($c), '');
Andy Whitcroft8905a672007-11-28 16:21:06 -08004320 $s =~ s/\n.*//g;
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004321 $s =~ s/$;//g; # Remove any comments
Andy Whitcroft53210162008-07-23 21:29:03 -07004322 if (length($c) && $s !~ /^\s*{?\s*\\*\s*$/ &&
4323 $c !~ /}\s*while\s*/)
Andy Whitcroft773647a2008-03-28 14:15:58 -07004324 {
Andy Whitcroftbb44ad32008-10-15 22:02:34 -07004325 # Find out how long the conditional actually is.
4326 my @newlines = ($c =~ /\n/gs);
4327 my $cond_lines = 1 + $#newlines;
Hidetoshi Seto42bdf742010-03-05 13:43:50 -08004328 my $stat_real = '';
Andy Whitcroftbb44ad32008-10-15 22:02:34 -07004329
Hidetoshi Seto42bdf742010-03-05 13:43:50 -08004330 $stat_real = raw_line($linenr, $cond_lines)
4331 . "\n" if ($cond_lines);
Andy Whitcroftbb44ad32008-10-15 22:02:34 -07004332 if (defined($stat_real) && $cond_lines > 1) {
4333 $stat_real = "[...]\n$stat_real";
4334 }
4335
Joe Perches000d1cc12011-07-25 17:13:25 -07004336 ERROR("TRAILING_STATEMENTS",
4337 "trailing statements should be on next line\n" . $herecurr . $stat_real);
Andy Whitcroft8905a672007-11-28 16:21:06 -08004338 }
4339 }
4340
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004341# Check for bitwise tests written as boolean
4342 if ($line =~ /
4343 (?:
4344 (?:\[|\(|\&\&|\|\|)
4345 \s*0[xX][0-9]+\s*
4346 (?:\&\&|\|\|)
4347 |
4348 (?:\&\&|\|\|)
4349 \s*0[xX][0-9]+\s*
4350 (?:\&\&|\|\||\)|\])
4351 )/x)
4352 {
Joe Perches000d1cc12011-07-25 17:13:25 -07004353 WARN("HEXADECIMAL_BOOLEAN_TEST",
4354 "boolean test with hexadecimal, perhaps just 1 \& or \|?\n" . $herecurr);
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004355 }
4356
Andy Whitcroft8905a672007-11-28 16:21:06 -08004357# if and else should not have general statements after it
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004358 if ($line =~ /^.\s*(?:}\s*)?else\b(.*)/) {
4359 my $s = $1;
4360 $s =~ s/$;//g; # Remove any comments
4361 if ($s !~ /^\s*(?:\sif|(?:{|)\s*\\?\s*$)/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07004362 ERROR("TRAILING_STATEMENTS",
4363 "trailing statements should be on next line\n" . $herecurr);
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004364 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004365 }
Andy Whitcroft39667782009-01-15 13:51:06 -08004366# if should not continue a brace
4367 if ($line =~ /}\s*if\b/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07004368 ERROR("TRAILING_STATEMENTS",
Rasmus Villemoes048b1232014-08-06 16:10:37 -07004369 "trailing statements should be on next line (or did you mean 'else if'?)\n" .
Andy Whitcroft39667782009-01-15 13:51:06 -08004370 $herecurr);
4371 }
Andy Whitcrofta1080bf2008-10-15 22:02:25 -07004372# case and default should not have general statements after them
4373 if ($line =~ /^.\s*(?:case\s*.*|default\s*):/g &&
4374 $line !~ /\G(?:
Andy Whitcroft3fef12d2008-10-15 22:02:36 -07004375 (?:\s*$;*)(?:\s*{)?(?:\s*$;*)(?:\s*\\)?\s*$|
Andy Whitcrofta1080bf2008-10-15 22:02:25 -07004376 \s*return\s+
4377 )/xg)
4378 {
Joe Perches000d1cc12011-07-25 17:13:25 -07004379 ERROR("TRAILING_STATEMENTS",
4380 "trailing statements should be on next line\n" . $herecurr);
Andy Whitcrofta1080bf2008-10-15 22:02:25 -07004381 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004382
4383 # Check for }<nl>else {, these must be at the same
4384 # indent level to be relevant to each other.
Joe Perches8b8856f2014-08-06 16:11:14 -07004385 if ($prevline=~/}\s*$/ and $line=~/^.\s*else\s*/ &&
4386 $previndent == $indent) {
4387 if (ERROR("ELSE_AFTER_BRACE",
4388 "else should follow close brace '}'\n" . $hereprev) &&
4389 $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
4390 fix_delete_line($fixlinenr - 1, $prevrawline);
4391 fix_delete_line($fixlinenr, $rawline);
4392 my $fixedline = $prevrawline;
4393 $fixedline =~ s/}\s*$//;
4394 if ($fixedline !~ /^\+\s*$/) {
4395 fix_insert_line($fixlinenr, $fixedline);
4396 }
4397 $fixedline = $rawline;
4398 $fixedline =~ s/^(.\s*)else/$1} else/;
4399 fix_insert_line($fixlinenr, $fixedline);
4400 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004401 }
4402
Joe Perches8b8856f2014-08-06 16:11:14 -07004403 if ($prevline=~/}\s*$/ and $line=~/^.\s*while\s*/ &&
4404 $previndent == $indent) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08004405 my ($s, $c) = ctx_statement_block($linenr, $realcnt, 0);
4406
4407 # Find out what is on the end of the line after the
4408 # conditional.
Andy Whitcroft773647a2008-03-28 14:15:58 -07004409 substr($s, 0, length($c), '');
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08004410 $s =~ s/\n.*//g;
4411
4412 if ($s =~ /^\s*;/) {
Joe Perches8b8856f2014-08-06 16:11:14 -07004413 if (ERROR("WHILE_AFTER_BRACE",
4414 "while should follow close brace '}'\n" . $hereprev) &&
4415 $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
4416 fix_delete_line($fixlinenr - 1, $prevrawline);
4417 fix_delete_line($fixlinenr, $rawline);
4418 my $fixedline = $prevrawline;
4419 my $trailing = $rawline;
4420 $trailing =~ s/^\+//;
4421 $trailing = trim($trailing);
4422 $fixedline =~ s/}\s*$/} $trailing/;
4423 fix_insert_line($fixlinenr, $fixedline);
4424 }
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08004425 }
4426 }
4427
Joe Perches95e2c602013-07-03 15:05:20 -07004428#Specific variable tests
Joe Perches323c1262012-12-17 16:02:07 -08004429 while ($line =~ m{($Constant|$Lval)}g) {
4430 my $var = $1;
Joe Perches95e2c602013-07-03 15:05:20 -07004431
4432#gcc binary extension
4433 if ($var =~ /^$Binary$/) {
Joe Perchesd5e616f2013-09-11 14:23:54 -07004434 if (WARN("GCC_BINARY_CONSTANT",
4435 "Avoid gcc v4.3+ binary constant extension: <$var>\n" . $herecurr) &&
4436 $fix) {
4437 my $hexval = sprintf("0x%x", oct($var));
Joe Perches194f66f2014-08-06 16:11:03 -07004438 $fixed[$fixlinenr] =~
Joe Perchesd5e616f2013-09-11 14:23:54 -07004439 s/\b$var\b/$hexval/;
4440 }
Joe Perches95e2c602013-07-03 15:05:20 -07004441 }
4442
4443#CamelCase
Joe Perches807bd262013-07-03 15:05:22 -07004444 if ($var !~ /^$Constant$/ &&
Joe Perchesbe797942013-07-03 15:05:20 -07004445 $var =~ /[A-Z][a-z]|[a-z][A-Z]/ &&
Joe Perches22735ce2013-07-03 15:05:33 -07004446#Ignore Page<foo> variants
Joe Perches807bd262013-07-03 15:05:22 -07004447 $var !~ /^(?:Clear|Set|TestClear|TestSet|)Page[A-Z]/ &&
Joe Perches22735ce2013-07-03 15:05:33 -07004448#Ignore SI style variants like nS, mV and dB (ie: max_uV, regulator_min_uA_show)
Julius Wernerf5123572014-12-10 15:51:54 -08004449 $var !~ /^(?:[a-z_]*?)_?[a-z][A-Z](?:_[a-z_]+)?$/ &&
4450#Ignore some three character SI units explicitly, like MiB and KHz
4451 $var !~ /^(?:[a-z_]*?)_?(?:[KMGT]iB|[KMGT]?Hz)(?:_[a-z_]+)?$/) {
Joe Perches7e781f62013-09-11 14:23:55 -07004452 while ($var =~ m{($Ident)}g) {
4453 my $word = $1;
4454 next if ($word !~ /[A-Z][a-z]|[a-z][A-Z]/);
Joe Perchesd8b07712013-11-12 15:10:06 -08004455 if ($check) {
4456 seed_camelcase_includes();
4457 if (!$file && !$camelcase_file_seeded) {
4458 seed_camelcase_file($realfile);
4459 $camelcase_file_seeded = 1;
4460 }
4461 }
Joe Perches7e781f62013-09-11 14:23:55 -07004462 if (!defined $camelcase{$word}) {
4463 $camelcase{$word} = 1;
4464 CHK("CAMELCASE",
4465 "Avoid CamelCase: <$word>\n" . $herecurr);
4466 }
Joe Perches34456862013-07-03 15:05:34 -07004467 }
Joe Perches323c1262012-12-17 16:02:07 -08004468 }
4469 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004470
4471#no spaces allowed after \ in define
Joe Perchesd5e616f2013-09-11 14:23:54 -07004472 if ($line =~ /\#\s*define.*\\\s+$/) {
4473 if (WARN("WHITESPACE_AFTER_LINE_CONTINUATION",
4474 "Whitespace after \\ makes next lines useless\n" . $herecurr) &&
4475 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07004476 $fixed[$fixlinenr] =~ s/\s+$//;
Joe Perchesd5e616f2013-09-11 14:23:54 -07004477 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004478 }
4479
Fabian Frederick0e212e02015-04-16 12:44:25 -07004480# warn if <asm/foo.h> is #included and <linux/foo.h> is available and includes
4481# itself <asm/foo.h> (uses RAW line)
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004482 if ($tree && $rawline =~ m{^.\s*\#\s*include\s*\<asm\/(.*)\.h\>}) {
Andy Whitcrofte09dec42008-10-15 22:02:20 -07004483 my $file = "$1.h";
4484 my $checkfile = "include/linux/$file";
4485 if (-f "$root/$checkfile" &&
4486 $realfile ne $checkfile &&
Wolfram Sang7840a942010-08-09 17:20:57 -07004487 $1 !~ /$allowed_asm_includes/)
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004488 {
Fabian Frederick0e212e02015-04-16 12:44:25 -07004489 my $asminclude = `grep -Ec "#include\\s+<asm/$file>" $root/$checkfile`;
4490 if ($asminclude > 0) {
4491 if ($realfile =~ m{^arch/}) {
4492 CHK("ARCH_INCLUDE_LINUX",
4493 "Consider using #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
4494 } else {
4495 WARN("INCLUDE_LINUX",
4496 "Use #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
4497 }
Andy Whitcrofte09dec42008-10-15 22:02:20 -07004498 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004499 }
4500 }
4501
Andy Whitcroft653d4872007-06-23 17:16:34 -07004502# multi-statement macros should be enclosed in a do while loop, grab the
4503# first statement and ensure its the whole macro if its not enclosed
Andy Whitcroftcf655042008-03-04 14:28:20 -08004504# in a known good container
Andy Whitcroftb8f96a32008-07-23 21:29:07 -07004505 if ($realfile !~ m@/vmlinux.lds.h$@ &&
4506 $line =~ /^.\s*\#\s*define\s*$Ident(\()?/) {
Andy Whitcroftd8aaf122007-06-23 17:16:44 -07004507 my $ln = $linenr;
4508 my $cnt = $realcnt;
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004509 my ($off, $dstat, $dcond, $rest);
4510 my $ctx = '';
Joe Perches08a28432014-10-13 15:51:55 -07004511 my $has_flow_statement = 0;
4512 my $has_arg_concat = 0;
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004513 ($dstat, $dcond, $ln, $cnt, $off) =
Andy Whitcroftf74bd192012-01-10 15:09:54 -08004514 ctx_statement_block($linenr, $realcnt, 0);
4515 $ctx = $dstat;
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004516 #print "dstat<$dstat> dcond<$dcond> cnt<$cnt> off<$off>\n";
Andy Whitcrofta3bb97a2008-07-23 21:29:00 -07004517 #print "LINE<$lines[$ln-1]> len<" . length($lines[$ln-1]) . "\n";
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004518
Joe Perches08a28432014-10-13 15:51:55 -07004519 $has_flow_statement = 1 if ($ctx =~ /\b(goto|return)\b/);
4520 $has_arg_concat = 1 if ($ctx =~ /\#\#/);
4521
Andy Whitcroftf74bd192012-01-10 15:09:54 -08004522 $dstat =~ s/^.\s*\#\s*define\s+$Ident(?:\([^\)]*\))?\s*//;
Andy Whitcroft292f1a92008-07-23 21:29:11 -07004523 $dstat =~ s/$;//g;
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004524 $dstat =~ s/\\\n.//g;
4525 $dstat =~ s/^\s*//s;
4526 $dstat =~ s/\s*$//s;
4527
4528 # Flatten any parentheses and braces
Andy Whitcroftbf30d6e2008-10-15 22:02:33 -07004529 while ($dstat =~ s/\([^\(\)]*\)/1/ ||
4530 $dstat =~ s/\{[^\{\}]*\}/1/ ||
Andy Whitcroftc81769f2012-01-10 15:10:10 -08004531 $dstat =~ s/\[[^\[\]]*\]/1/)
Andy Whitcroftbf30d6e2008-10-15 22:02:33 -07004532 {
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07004533 }
Andy Whitcroftd8aaf122007-06-23 17:16:44 -07004534
Andy Whitcrofte45bab82012-03-23 15:02:18 -07004535 # Flatten any obvious string concatentation.
Joe Perches33acb542015-06-25 15:02:54 -07004536 while ($dstat =~ s/($String)\s*$Ident/$1/ ||
4537 $dstat =~ s/$Ident\s*($String)/$1/)
Andy Whitcrofte45bab82012-03-23 15:02:18 -07004538 {
4539 }
4540
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004541 my $exceptions = qr{
4542 $Declare|
4543 module_param_named|
Kees Cooka0a0a7a2012-10-04 17:13:38 -07004544 MODULE_PARM_DESC|
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004545 DECLARE_PER_CPU|
4546 DEFINE_PER_CPU|
Andy Whitcroft383099f2009-01-06 14:41:18 -08004547 __typeof__\(|
Stefani Seibold22fd2d32010-03-05 13:43:52 -08004548 union|
4549 struct|
Andy Whitcroftea71a0a2009-09-21 17:04:38 -07004550 \.$Ident\s*=\s*|
4551 ^\"|\"$
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004552 }x;
Andy Whitcroft5eaa20b2010-10-26 14:23:18 -07004553 #print "REST<$rest> dstat<$dstat> ctx<$ctx>\n";
Andy Whitcroftf74bd192012-01-10 15:09:54 -08004554 if ($dstat ne '' &&
4555 $dstat !~ /^(?:$Ident|-?$Constant),$/ && # 10, // foo(),
4556 $dstat !~ /^(?:$Ident|-?$Constant);$/ && # foo();
Joe Perches3cc4b1c2013-07-03 15:05:27 -07004557 $dstat !~ /^[!~-]?(?:$Lval|$Constant)$/ && # 10 // foo() // !foo // ~foo // -foo // foo->bar // foo.bar->baz
Joe Perches356fd392014-08-06 16:10:31 -07004558 $dstat !~ /^'X'$/ && $dstat !~ /^'XX'$/ && # character constants
Andy Whitcroftf74bd192012-01-10 15:09:54 -08004559 $dstat !~ /$exceptions/ &&
4560 $dstat !~ /^\.$Ident\s*=/ && # .foo =
Joe Perchese942e2c2013-04-17 15:58:26 -07004561 $dstat !~ /^(?:\#\s*$Ident|\#\s*$Constant)\s*$/ && # stringification #foo
Andy Whitcroft72f115f2012-01-10 15:10:06 -08004562 $dstat !~ /^do\s*$Constant\s*while\s*$Constant;?$/ && # do {...} while (...); // do {...} while (...)
Andy Whitcroftf74bd192012-01-10 15:09:54 -08004563 $dstat !~ /^for\s*$Constant$/ && # for (...)
4564 $dstat !~ /^for\s*$Constant\s+(?:$Ident|-?$Constant)$/ && # for (...) bar()
4565 $dstat !~ /^do\s*{/ && # do {...
Eddie Kovsky4e5d56b2015-09-09 15:37:52 -07004566 $dstat !~ /^\(\{/ && # ({...
Joe Perchesf95a7e62013-09-11 14:24:00 -07004567 $ctx !~ /^.\s*#\s*define\s+TRACE_(?:SYSTEM|INCLUDE_FILE|INCLUDE_PATH)\b/)
Andy Whitcroftf74bd192012-01-10 15:09:54 -08004568 {
4569 $ctx =~ s/\n*$//;
4570 my $herectx = $here . "\n";
4571 my $cnt = statement_rawlines($ctx);
4572
4573 for (my $n = 0; $n < $cnt; $n++) {
4574 $herectx .= raw_line($linenr, $n) . "\n";
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004575 }
4576
Andy Whitcroftf74bd192012-01-10 15:09:54 -08004577 if ($dstat =~ /;/) {
4578 ERROR("MULTISTATEMENT_MACRO_USE_DO_WHILE",
4579 "Macros with multiple statements should be enclosed in a do - while loop\n" . "$herectx");
4580 } else {
Joe Perches000d1cc12011-07-25 17:13:25 -07004581 ERROR("COMPLEX_MACRO",
Andrew Morton388982b2014-10-13 15:51:40 -07004582 "Macros with complex values should be enclosed in parentheses\n" . "$herectx");
Andy Whitcroftd8aaf122007-06-23 17:16:44 -07004583 }
Andy Whitcroft653d4872007-06-23 17:16:34 -07004584 }
Joe Perches5023d342012-12-17 16:01:47 -08004585
Joe Perches08a28432014-10-13 15:51:55 -07004586# check for macros with flow control, but without ## concatenation
4587# ## concatenation is commonly a macro that defines a function so ignore those
4588 if ($has_flow_statement && !$has_arg_concat) {
4589 my $herectx = $here . "\n";
4590 my $cnt = statement_rawlines($ctx);
4591
4592 for (my $n = 0; $n < $cnt; $n++) {
4593 $herectx .= raw_line($linenr, $n) . "\n";
4594 }
4595 WARN("MACRO_WITH_FLOW_CONTROL",
4596 "Macros with flow control statements should be avoided\n" . "$herectx");
4597 }
4598
Joe Perches481eb482012-12-17 16:01:56 -08004599# check for line continuations outside of #defines, preprocessor #, and asm
Joe Perches5023d342012-12-17 16:01:47 -08004600
4601 } else {
4602 if ($prevline !~ /^..*\\$/ &&
Joe Perches481eb482012-12-17 16:01:56 -08004603 $line !~ /^\+\s*\#.*\\$/ && # preprocessor
4604 $line !~ /^\+.*\b(__asm__|asm)\b.*\\$/ && # asm
Joe Perches5023d342012-12-17 16:01:47 -08004605 $line =~ /^\+.*\\$/) {
4606 WARN("LINE_CONTINUATIONS",
4607 "Avoid unnecessary line continuations\n" . $herecurr);
4608 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004609 }
4610
Joe Perchesb13edf72012-07-30 14:41:24 -07004611# do {} while (0) macro tests:
4612# single-statement macros do not need to be enclosed in do while (0) loop,
4613# macro should not end with a semicolon
4614 if ($^V && $^V ge 5.10.0 &&
4615 $realfile !~ m@/vmlinux.lds.h$@ &&
4616 $line =~ /^.\s*\#\s*define\s+$Ident(\()?/) {
4617 my $ln = $linenr;
4618 my $cnt = $realcnt;
4619 my ($off, $dstat, $dcond, $rest);
4620 my $ctx = '';
4621 ($dstat, $dcond, $ln, $cnt, $off) =
4622 ctx_statement_block($linenr, $realcnt, 0);
4623 $ctx = $dstat;
4624
4625 $dstat =~ s/\\\n.//g;
Joe Perches1b36b202015-02-13 14:38:32 -08004626 $dstat =~ s/$;/ /g;
Joe Perchesb13edf72012-07-30 14:41:24 -07004627
4628 if ($dstat =~ /^\+\s*#\s*define\s+$Ident\s*${balanced_parens}\s*do\s*{(.*)\s*}\s*while\s*\(\s*0\s*\)\s*([;\s]*)\s*$/) {
4629 my $stmts = $2;
4630 my $semis = $3;
4631
4632 $ctx =~ s/\n*$//;
4633 my $cnt = statement_rawlines($ctx);
4634 my $herectx = $here . "\n";
4635
4636 for (my $n = 0; $n < $cnt; $n++) {
4637 $herectx .= raw_line($linenr, $n) . "\n";
4638 }
4639
Joe Perchesac8e97f2012-08-21 16:15:53 -07004640 if (($stmts =~ tr/;/;/) == 1 &&
4641 $stmts !~ /^\s*(if|while|for|switch)\b/) {
Joe Perchesb13edf72012-07-30 14:41:24 -07004642 WARN("SINGLE_STATEMENT_DO_WHILE_MACRO",
4643 "Single statement macros should not use a do {} while (0) loop\n" . "$herectx");
4644 }
4645 if (defined $semis && $semis ne "") {
4646 WARN("DO_WHILE_MACRO_WITH_TRAILING_SEMICOLON",
4647 "do {} while (0) macros should not be semicolon terminated\n" . "$herectx");
4648 }
Joe Perchesf5ef95b2014-06-04 16:12:06 -07004649 } elsif ($dstat =~ /^\+\s*#\s*define\s+$Ident.*;\s*$/) {
4650 $ctx =~ s/\n*$//;
4651 my $cnt = statement_rawlines($ctx);
4652 my $herectx = $here . "\n";
4653
4654 for (my $n = 0; $n < $cnt; $n++) {
4655 $herectx .= raw_line($linenr, $n) . "\n";
4656 }
4657
4658 WARN("TRAILING_SEMICOLON",
4659 "macros should not use a trailing semicolon\n" . "$herectx");
Joe Perchesb13edf72012-07-30 14:41:24 -07004660 }
4661 }
4662
Mike Frysinger080ba922009-01-06 14:41:25 -08004663# make sure symbols are always wrapped with VMLINUX_SYMBOL() ...
4664# all assignments may have only one of the following with an assignment:
4665# .
4666# ALIGN(...)
4667# VMLINUX_SYMBOL(...)
4668 if ($realfile eq 'vmlinux.lds.h' && $line =~ /(?:(?:^|\s)$Ident\s*=|=\s*$Ident(?:\s|$))/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07004669 WARN("MISSING_VMLINUX_SYMBOL",
4670 "vmlinux.lds.h needs VMLINUX_SYMBOL() around C-visible symbols\n" . $herecurr);
Mike Frysinger080ba922009-01-06 14:41:25 -08004671 }
4672
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07004673# check for redundant bracing round if etc
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004674 if ($line =~ /(^.*)\bif\b/ && $1 !~ /else\s*$/) {
4675 my ($level, $endln, @chunks) =
Andy Whitcroftcf655042008-03-04 14:28:20 -08004676 ctx_statement_full($linenr, $realcnt, 1);
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004677 #print "chunks<$#chunks> linenr<$linenr> endln<$endln> level<$level>\n";
Andy Whitcroftcf655042008-03-04 14:28:20 -08004678 #print "APW: <<$chunks[1][0]>><<$chunks[1][1]>>\n";
4679 if ($#chunks > 0 && $level == 0) {
Joe Perchesaad4f612012-03-23 15:02:19 -07004680 my @allowed = ();
4681 my $allow = 0;
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004682 my $seen = 0;
Andy Whitcroft773647a2008-03-28 14:15:58 -07004683 my $herectx = $here . "\n";
Andy Whitcroftcf655042008-03-04 14:28:20 -08004684 my $ln = $linenr - 1;
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004685 for my $chunk (@chunks) {
4686 my ($cond, $block) = @{$chunk};
4687
Andy Whitcroft773647a2008-03-28 14:15:58 -07004688 # If the condition carries leading newlines, then count those as offsets.
4689 my ($whitespace) = ($cond =~ /^((?:\s*\n[+-])*\s*)/s);
4690 my $offset = statement_rawlines($whitespace) - 1;
4691
Joe Perchesaad4f612012-03-23 15:02:19 -07004692 $allowed[$allow] = 0;
Andy Whitcroft773647a2008-03-28 14:15:58 -07004693 #print "COND<$cond> whitespace<$whitespace> offset<$offset>\n";
4694
4695 # We have looked at and allowed this specific line.
4696 $suppress_ifbraces{$ln + $offset} = 1;
4697
4698 $herectx .= "$rawlines[$ln + $offset]\n[...]\n";
Andy Whitcroftcf655042008-03-04 14:28:20 -08004699 $ln += statement_rawlines($block) - 1;
4700
Andy Whitcroft773647a2008-03-28 14:15:58 -07004701 substr($block, 0, length($cond), '');
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004702
4703 $seen++ if ($block =~ /^\s*{/);
4704
Joe Perchesaad4f612012-03-23 15:02:19 -07004705 #print "cond<$cond> block<$block> allowed<$allowed[$allow]>\n";
Andy Whitcroftcf655042008-03-04 14:28:20 -08004706 if (statement_lines($cond) > 1) {
4707 #print "APW: ALLOWED: cond<$cond>\n";
Joe Perchesaad4f612012-03-23 15:02:19 -07004708 $allowed[$allow] = 1;
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004709 }
4710 if ($block =~/\b(?:if|for|while)\b/) {
Andy Whitcroftcf655042008-03-04 14:28:20 -08004711 #print "APW: ALLOWED: block<$block>\n";
Joe Perchesaad4f612012-03-23 15:02:19 -07004712 $allowed[$allow] = 1;
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004713 }
Andy Whitcroftcf655042008-03-04 14:28:20 -08004714 if (statement_block_size($block) > 1) {
4715 #print "APW: ALLOWED: lines block<$block>\n";
Joe Perchesaad4f612012-03-23 15:02:19 -07004716 $allowed[$allow] = 1;
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004717 }
Joe Perchesaad4f612012-03-23 15:02:19 -07004718 $allow++;
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004719 }
Joe Perchesaad4f612012-03-23 15:02:19 -07004720 if ($seen) {
4721 my $sum_allowed = 0;
4722 foreach (@allowed) {
4723 $sum_allowed += $_;
4724 }
4725 if ($sum_allowed == 0) {
4726 WARN("BRACES",
4727 "braces {} are not necessary for any arm of this statement\n" . $herectx);
4728 } elsif ($sum_allowed != $allow &&
4729 $seen != $allow) {
4730 CHK("BRACES",
4731 "braces {} should be used on all arms of this statement\n" . $herectx);
4732 }
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004733 }
4734 }
4735 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07004736 if (!defined $suppress_ifbraces{$linenr - 1} &&
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004737 $line =~ /\b(if|while|for|else)\b/) {
Andy Whitcroftcf655042008-03-04 14:28:20 -08004738 my $allowed = 0;
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07004739
Andy Whitcroftcf655042008-03-04 14:28:20 -08004740 # Check the pre-context.
4741 if (substr($line, 0, $-[0]) =~ /(\}\s*)$/) {
4742 #print "APW: ALLOWED: pre<$1>\n";
4743 $allowed = 1;
4744 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07004745
4746 my ($level, $endln, @chunks) =
4747 ctx_statement_full($linenr, $realcnt, $-[0]);
4748
Andy Whitcroftcf655042008-03-04 14:28:20 -08004749 # Check the condition.
4750 my ($cond, $block) = @{$chunks[0]};
Andy Whitcroft773647a2008-03-28 14:15:58 -07004751 #print "CHECKING<$linenr> cond<$cond> block<$block>\n";
Andy Whitcroftcf655042008-03-04 14:28:20 -08004752 if (defined $cond) {
Andy Whitcroft773647a2008-03-28 14:15:58 -07004753 substr($block, 0, length($cond), '');
Andy Whitcroftcf655042008-03-04 14:28:20 -08004754 }
4755 if (statement_lines($cond) > 1) {
4756 #print "APW: ALLOWED: cond<$cond>\n";
4757 $allowed = 1;
4758 }
4759 if ($block =~/\b(?:if|for|while)\b/) {
4760 #print "APW: ALLOWED: block<$block>\n";
4761 $allowed = 1;
4762 }
4763 if (statement_block_size($block) > 1) {
4764 #print "APW: ALLOWED: lines block<$block>\n";
4765 $allowed = 1;
4766 }
4767 # Check the post-context.
4768 if (defined $chunks[1]) {
4769 my ($cond, $block) = @{$chunks[1]};
4770 if (defined $cond) {
Andy Whitcroft773647a2008-03-28 14:15:58 -07004771 substr($block, 0, length($cond), '');
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07004772 }
Andy Whitcroftcf655042008-03-04 14:28:20 -08004773 if ($block =~ /^\s*\{/) {
4774 #print "APW: ALLOWED: chunk-1 block<$block>\n";
4775 $allowed = 1;
4776 }
4777 }
4778 if ($level == 0 && $block =~ /^\s*\{/ && !$allowed) {
Justin P. Mattock69932482011-07-26 23:06:29 -07004779 my $herectx = $here . "\n";
Andy Whitcroftf0556632008-10-15 22:02:23 -07004780 my $cnt = statement_rawlines($block);
Andy Whitcroftcf655042008-03-04 14:28:20 -08004781
Andy Whitcroftf0556632008-10-15 22:02:23 -07004782 for (my $n = 0; $n < $cnt; $n++) {
Justin P. Mattock69932482011-07-26 23:06:29 -07004783 $herectx .= raw_line($linenr, $n) . "\n";
Andy Whitcroftcf655042008-03-04 14:28:20 -08004784 }
4785
Joe Perches000d1cc12011-07-25 17:13:25 -07004786 WARN("BRACES",
4787 "braces {} are not necessary for single statement blocks\n" . $herectx);
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07004788 }
4789 }
4790
Joe Perches0979ae62012-12-17 16:01:59 -08004791# check for unnecessary blank lines around braces
Joe Perches77b9a532013-07-03 15:05:29 -07004792 if (($line =~ /^.\s*}\s*$/ && $prevrawline =~ /^.\s*$/)) {
Joe Perchesf8e58212015-02-13 14:38:46 -08004793 if (CHK("BRACES",
4794 "Blank lines aren't necessary before a close brace '}'\n" . $hereprev) &&
4795 $fix && $prevrawline =~ /^\+/) {
4796 fix_delete_line($fixlinenr - 1, $prevrawline);
4797 }
Joe Perches0979ae62012-12-17 16:01:59 -08004798 }
Joe Perches77b9a532013-07-03 15:05:29 -07004799 if (($rawline =~ /^.\s*$/ && $prevline =~ /^..*{\s*$/)) {
Joe Perchesf8e58212015-02-13 14:38:46 -08004800 if (CHK("BRACES",
4801 "Blank lines aren't necessary after an open brace '{'\n" . $hereprev) &&
4802 $fix) {
4803 fix_delete_line($fixlinenr, $rawline);
4804 }
Joe Perches0979ae62012-12-17 16:01:59 -08004805 }
4806
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07004807# no volatiles please
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07004808 my $asm_volatile = qr{\b(__asm__|asm)\s+(__volatile__|volatile)\b};
4809 if ($line =~ /\bvolatile\b/ && $line !~ /$asm_volatile/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07004810 WARN("VOLATILE",
4811 "Use of volatile is usually wrong: see Documentation/volatile-considered-harmful.txt\n" . $herecurr);
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07004812 }
4813
Joe Perches5e4f6ba2014-12-10 15:52:05 -08004814# Check for user-visible strings broken across lines, which breaks the ability
4815# to grep for the string. Make exceptions when the previous string ends in a
4816# newline (multiple lines in one string constant) or '\t', '\r', ';', or '{'
4817# (common in inline assembly) or is a octal \123 or hexadecimal \xaf value
Joe Perches33acb542015-06-25 15:02:54 -07004818 if ($line =~ /^\+\s*$String/ &&
Joe Perches5e4f6ba2014-12-10 15:52:05 -08004819 $prevline =~ /"\s*$/ &&
4820 $prevrawline !~ /(?:\\(?:[ntr]|[0-7]{1,3}|x[0-9a-fA-F]{1,2})|;\s*|\{\s*)"\s*$/) {
4821 if (WARN("SPLIT_STRING",
4822 "quoted string split across lines\n" . $hereprev) &&
4823 $fix &&
4824 $prevrawline =~ /^\+.*"\s*$/ &&
4825 $last_coalesced_string_linenr != $linenr - 1) {
4826 my $extracted_string = get_quoted_string($line, $rawline);
4827 my $comma_close = "";
4828 if ($rawline =~ /\Q$extracted_string\E(\s*\)\s*;\s*$|\s*,\s*)/) {
4829 $comma_close = $1;
4830 }
4831
4832 fix_delete_line($fixlinenr - 1, $prevrawline);
4833 fix_delete_line($fixlinenr, $rawline);
4834 my $fixedline = $prevrawline;
4835 $fixedline =~ s/"\s*$//;
4836 $fixedline .= substr($extracted_string, 1) . trim($comma_close);
4837 fix_insert_line($fixlinenr - 1, $fixedline);
4838 $fixedline = $rawline;
4839 $fixedline =~ s/\Q$extracted_string\E\Q$comma_close\E//;
4840 if ($fixedline !~ /\+\s*$/) {
4841 fix_insert_line($fixlinenr, $fixedline);
4842 }
4843 $last_coalesced_string_linenr = $linenr;
4844 }
4845 }
4846
4847# check for missing a space in a string concatenation
4848 if ($prevrawline =~ /[^\\]\w"$/ && $rawline =~ /^\+[\t ]+"\w/) {
4849 WARN('MISSING_SPACE',
4850 "break quoted strings at a space character\n" . $hereprev);
4851 }
4852
4853# check for spaces before a quoted newline
4854 if ($rawline =~ /^.*\".*\s\\n/) {
4855 if (WARN("QUOTED_WHITESPACE_BEFORE_NEWLINE",
4856 "unnecessary whitespace before a quoted newline\n" . $herecurr) &&
4857 $fix) {
4858 $fixed[$fixlinenr] =~ s/^(\+.*\".*)\s+\\n/$1\\n/;
4859 }
4860
4861 }
4862
Joe Perchesf17dba42014-10-13 15:51:51 -07004863# concatenated string without spaces between elements
Joe Perches33acb542015-06-25 15:02:54 -07004864 if ($line =~ /$String[A-Z_]/ || $line =~ /[A-Za-z0-9_]$String/) {
Joe Perchesf17dba42014-10-13 15:51:51 -07004865 CHK("CONCATENATED_STRING",
4866 "Concatenated strings should use spaces between elements\n" . $herecurr);
4867 }
4868
Joe Perches90ad30e2014-12-10 15:51:59 -08004869# uncoalesced string fragments
Joe Perches33acb542015-06-25 15:02:54 -07004870 if ($line =~ /$String\s*"/) {
Joe Perches90ad30e2014-12-10 15:51:59 -08004871 WARN("STRING_FRAGMENTS",
4872 "Consecutive strings are generally better as a single string\n" . $herecurr);
4873 }
4874
Joe Perches6e300752015-09-09 15:37:47 -07004875# check for %L{u,d,i} and 0x%[udi] in strings
Joe Perches5e4f6ba2014-12-10 15:52:05 -08004876 my $string;
4877 while ($line =~ /(?:^|")([X\t]*)(?:"|$)/g) {
4878 $string = substr($rawline, $-[1], $+[1] - $-[1]);
4879 $string =~ s/%%/__/g;
Joe Perches6e300752015-09-09 15:37:47 -07004880 if ($string =~ /(?<!%)%[\*\d\.\$]*L[udi]/) {
Joe Perches5e4f6ba2014-12-10 15:52:05 -08004881 WARN("PRINTF_L",
4882 "\%Ld/%Lu are not-standard C, use %lld/%llu\n" . $herecurr);
4883 last;
4884 }
Joe Perches6e300752015-09-09 15:37:47 -07004885 if ($string =~ /0x%[\*\d\.\$\Llzth]*[udi]/) {
4886 ERROR("PRINTF_0xDECIMAL",
4887 "Prefixing 0x with decimal output is defective\n" . $herecurr);
4888 }
Joe Perches5e4f6ba2014-12-10 15:52:05 -08004889 }
4890
4891# check for line continuations in quoted strings with odd counts of "
4892 if ($rawline =~ /\\$/ && $rawline =~ tr/"/"/ % 2) {
4893 WARN("LINE_CONTINUATIONS",
4894 "Avoid line continuations in quoted strings\n" . $herecurr);
4895 }
4896
Andy Whitcroft00df3442007-06-08 13:47:06 -07004897# warn about #if 0
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004898 if ($line =~ /^.\s*\#\s*if\s+0\b/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07004899 CHK("REDUNDANT_CODE",
4900 "if this code is redundant consider removing it\n" .
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07004901 $herecurr);
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07004902 }
4903
Andy Whitcroft03df4b52012-12-17 16:01:52 -08004904# check for needless "if (<foo>) fn(<foo>)" uses
4905 if ($prevline =~ /\bif\s*\(\s*($Lval)\s*\)/) {
Joe Perches100425d2015-09-09 15:37:36 -07004906 my $tested = quotemeta($1);
4907 my $expr = '\s*\(\s*' . $tested . '\s*\)\s*;';
4908 if ($line =~ /\b(kfree|usb_free_urb|debugfs_remove(?:_recursive)?|(?:kmem_cache|mempool|dma_pool)_destroy)$expr/) {
4909 my $func = $1;
4910 if (WARN('NEEDLESS_IF',
4911 "$func(NULL) is safe and this check is probably not required\n" . $hereprev) &&
4912 $fix) {
4913 my $do_fix = 1;
4914 my $leading_tabs = "";
4915 my $new_leading_tabs = "";
4916 if ($lines[$linenr - 2] =~ /^\+(\t*)if\s*\(\s*$tested\s*\)\s*$/) {
4917 $leading_tabs = $1;
4918 } else {
4919 $do_fix = 0;
4920 }
4921 if ($lines[$linenr - 1] =~ /^\+(\t+)$func\s*\(\s*$tested\s*\)\s*;\s*$/) {
4922 $new_leading_tabs = $1;
4923 if (length($leading_tabs) + 1 ne length($new_leading_tabs)) {
4924 $do_fix = 0;
4925 }
4926 } else {
4927 $do_fix = 0;
4928 }
4929 if ($do_fix) {
4930 fix_delete_line($fixlinenr - 1, $prevrawline);
4931 $fixed[$fixlinenr] =~ s/^\+$new_leading_tabs/\+$leading_tabs/;
4932 }
4933 }
Greg Kroah-Hartman4c432a82008-07-23 21:29:04 -07004934 }
4935 }
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07004936
Joe Perchesebfdc402014-08-06 16:10:27 -07004937# check for unnecessary "Out of Memory" messages
4938 if ($line =~ /^\+.*\b$logFunctions\s*\(/ &&
4939 $prevline =~ /^[ \+]\s*if\s*\(\s*(\!\s*|NULL\s*==\s*)?($Lval)(\s*==\s*NULL\s*)?\s*\)/ &&
4940 (defined $1 || defined $3) &&
4941 $linenr > 3) {
4942 my $testval = $2;
4943 my $testline = $lines[$linenr - 3];
4944
4945 my ($s, $c) = ctx_statement_block($linenr - 3, $realcnt, 0);
4946# print("line: <$line>\nprevline: <$prevline>\ns: <$s>\nc: <$c>\n\n\n");
4947
4948 if ($c =~ /(?:^|\n)[ \+]\s*(?:$Type\s*)?\Q$testval\E\s*=\s*(?:\([^\)]*\)\s*)?\s*(?:devm_)?(?:[kv][czm]alloc(?:_node|_array)?\b|kstrdup|(?:dev_)?alloc_skb)/) {
4949 WARN("OOM_MESSAGE",
4950 "Possible unnecessary 'out of memory' message\n" . $hereprev);
4951 }
4952 }
4953
Joe Perchesf78d98f2014-10-13 15:52:01 -07004954# check for logging functions with KERN_<LEVEL>
Paolo Bonzinidcaf1122015-02-13 14:38:26 -08004955 if ($line !~ /printk(?:_ratelimited|_once)?\s*\(/ &&
Joe Perchesf78d98f2014-10-13 15:52:01 -07004956 $line =~ /\b$logFunctions\s*\(.*\b(KERN_[A-Z]+)\b/) {
4957 my $level = $1;
4958 if (WARN("UNNECESSARY_KERN_LEVEL",
4959 "Possible unnecessary $level\n" . $herecurr) &&
4960 $fix) {
4961 $fixed[$fixlinenr] =~ s/\s*$level\s*//;
4962 }
4963 }
4964
Joe Perchesabb08a52014-12-10 15:51:46 -08004965# check for mask then right shift without a parentheses
4966 if ($^V && $^V ge 5.10.0 &&
4967 $line =~ /$LvalOrFunc\s*\&\s*($LvalOrFunc)\s*>>/ &&
4968 $4 !~ /^\&/) { # $LvalOrFunc may be &foo, ignore if so
4969 WARN("MASK_THEN_SHIFT",
4970 "Possible precedence defect with mask then right shift - may need parentheses\n" . $herecurr);
4971 }
4972
Joe Perchesb75ac612014-12-10 15:52:02 -08004973# check for pointer comparisons to NULL
4974 if ($^V && $^V ge 5.10.0) {
4975 while ($line =~ /\b$LvalOrFunc\s*(==|\!=)\s*NULL\b/g) {
4976 my $val = $1;
4977 my $equal = "!";
4978 $equal = "" if ($4 eq "!=");
4979 if (CHK("COMPARISON_TO_NULL",
4980 "Comparison to NULL could be written \"${equal}${val}\"\n" . $herecurr) &&
4981 $fix) {
4982 $fixed[$fixlinenr] =~ s/\b\Q$val\E\s*(?:==|\!=)\s*NULL\b/$equal$val/;
4983 }
4984 }
4985 }
4986
Joe Perches8716de32013-09-11 14:24:05 -07004987# check for bad placement of section $InitAttribute (e.g.: __initdata)
4988 if ($line =~ /(\b$InitAttribute\b)/) {
4989 my $attr = $1;
4990 if ($line =~ /^\+\s*static\s+(?:const\s+)?(?:$attr\s+)?($NonptrTypeWithAttr)\s+(?:$attr\s+)?($Ident(?:\[[^]]*\])?)\s*[=;]/) {
4991 my $ptr = $1;
4992 my $var = $2;
4993 if ((($ptr =~ /\b(union|struct)\s+$attr\b/ &&
4994 ERROR("MISPLACED_INIT",
4995 "$attr should be placed after $var\n" . $herecurr)) ||
4996 ($ptr !~ /\b(union|struct)\s+$attr\b/ &&
4997 WARN("MISPLACED_INIT",
4998 "$attr should be placed after $var\n" . $herecurr))) &&
4999 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07005000 $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 -07005001 }
5002 }
5003 }
5004
Joe Perchese970b8842013-11-12 15:10:10 -08005005# check for $InitAttributeData (ie: __initdata) with const
5006 if ($line =~ /\bconst\b/ && $line =~ /($InitAttributeData)/) {
5007 my $attr = $1;
5008 $attr =~ /($InitAttributePrefix)(.*)/;
5009 my $attr_prefix = $1;
5010 my $attr_type = $2;
5011 if (ERROR("INIT_ATTRIBUTE",
5012 "Use of const init definition must use ${attr_prefix}initconst\n" . $herecurr) &&
5013 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07005014 $fixed[$fixlinenr] =~
Joe Perchese970b8842013-11-12 15:10:10 -08005015 s/$InitAttributeData/${attr_prefix}initconst/;
5016 }
5017 }
5018
5019# check for $InitAttributeConst (ie: __initconst) without const
5020 if ($line !~ /\bconst\b/ && $line =~ /($InitAttributeConst)/) {
5021 my $attr = $1;
5022 if (ERROR("INIT_ATTRIBUTE",
5023 "Use of $attr requires a separate use of const\n" . $herecurr) &&
5024 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07005025 my $lead = $fixed[$fixlinenr] =~
Joe Perchese970b8842013-11-12 15:10:10 -08005026 /(^\+\s*(?:static\s+))/;
5027 $lead = rtrim($1);
5028 $lead = "$lead " if ($lead !~ /^\+$/);
5029 $lead = "${lead}const ";
Joe Perches194f66f2014-08-06 16:11:03 -07005030 $fixed[$fixlinenr] =~ s/(^\+\s*(?:static\s+))/$lead/;
Joe Perchese970b8842013-11-12 15:10:10 -08005031 }
5032 }
5033
Joe Perchesc17893c2015-04-16 12:44:42 -07005034# check for __read_mostly with const non-pointer (should just be const)
5035 if ($line =~ /\b__read_mostly\b/ &&
5036 $line =~ /($Type)\s*$Ident/ && $1 !~ /\*\s*$/ && $1 =~ /\bconst\b/) {
5037 if (ERROR("CONST_READ_MOSTLY",
5038 "Invalid use of __read_mostly with const type\n" . $herecurr) &&
5039 $fix) {
5040 $fixed[$fixlinenr] =~ s/\s+__read_mostly\b//;
5041 }
5042 }
5043
Joe Perchesfbdb8132014-04-03 14:49:14 -07005044# don't use __constant_<foo> functions outside of include/uapi/
5045 if ($realfile !~ m@^include/uapi/@ &&
5046 $line =~ /(__constant_(?:htons|ntohs|[bl]e(?:16|32|64)_to_cpu|cpu_to_[bl]e(?:16|32|64)))\s*\(/) {
5047 my $constant_func = $1;
5048 my $func = $constant_func;
5049 $func =~ s/^__constant_//;
5050 if (WARN("CONSTANT_CONVERSION",
5051 "$constant_func should be $func\n" . $herecurr) &&
5052 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07005053 $fixed[$fixlinenr] =~ s/\b$constant_func\b/$func/g;
Joe Perchesfbdb8132014-04-03 14:49:14 -07005054 }
5055 }
5056
Patrick Pannuto1a15a252010-08-09 17:21:01 -07005057# prefer usleep_range over udelay
Bruce Allan37581c22013-02-21 16:44:19 -08005058 if ($line =~ /\budelay\s*\(\s*(\d+)\s*\)/) {
Joe Perches43c1d772014-04-03 14:49:11 -07005059 my $delay = $1;
Patrick Pannuto1a15a252010-08-09 17:21:01 -07005060 # ignore udelay's < 10, however
Joe Perches43c1d772014-04-03 14:49:11 -07005061 if (! ($delay < 10) ) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005062 CHK("USLEEP_RANGE",
Joe Perches43c1d772014-04-03 14:49:11 -07005063 "usleep_range is preferred over udelay; see Documentation/timers/timers-howto.txt\n" . $herecurr);
5064 }
5065 if ($delay > 2000) {
5066 WARN("LONG_UDELAY",
5067 "long udelay - prefer mdelay; see arch/arm/include/asm/delay.h\n" . $herecurr);
Patrick Pannuto1a15a252010-08-09 17:21:01 -07005068 }
5069 }
5070
Patrick Pannuto09ef8722010-08-09 17:21:02 -07005071# warn about unexpectedly long msleep's
5072 if ($line =~ /\bmsleep\s*\((\d+)\);/) {
5073 if ($1 < 20) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005074 WARN("MSLEEP",
Joe Perches43c1d772014-04-03 14:49:11 -07005075 "msleep < 20ms can sleep for up to 20ms; see Documentation/timers/timers-howto.txt\n" . $herecurr);
Patrick Pannuto09ef8722010-08-09 17:21:02 -07005076 }
5077 }
5078
Joe Perches36ec1932013-07-03 15:05:25 -07005079# check for comparisons of jiffies
5080 if ($line =~ /\bjiffies\s*$Compare|$Compare\s*jiffies\b/) {
5081 WARN("JIFFIES_COMPARISON",
5082 "Comparing jiffies is almost always wrong; prefer time_after, time_before and friends\n" . $herecurr);
5083 }
5084
Joe Perches9d7a34a2013-07-03 15:05:26 -07005085# check for comparisons of get_jiffies_64()
5086 if ($line =~ /\bget_jiffies_64\s*\(\s*\)\s*$Compare|$Compare\s*get_jiffies_64\s*\(\s*\)/) {
5087 WARN("JIFFIES_COMPARISON",
5088 "Comparing get_jiffies_64() is almost always wrong; prefer time_after64, time_before64 and friends\n" . $herecurr);
5089 }
5090
Andy Whitcroft00df3442007-06-08 13:47:06 -07005091# warn about #ifdefs in C files
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07005092# if ($line =~ /^.\s*\#\s*if(|n)def/ && ($realfile =~ /\.c$/)) {
Andy Whitcroft00df3442007-06-08 13:47:06 -07005093# print "#ifdef in C files should be avoided\n";
5094# print "$herecurr";
5095# $clean = 0;
5096# }
5097
Andy Whitcroft22f2a2e2007-08-10 13:01:03 -07005098# warn about spacing in #ifdefs
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07005099 if ($line =~ /^.\s*\#\s*(ifdef|ifndef|elif)\s\s+/) {
Joe Perches3705ce52013-07-03 15:05:31 -07005100 if (ERROR("SPACING",
5101 "exactly one space required after that #$1\n" . $herecurr) &&
5102 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07005103 $fixed[$fixlinenr] =~
Joe Perches3705ce52013-07-03 15:05:31 -07005104 s/^(.\s*\#\s*(ifdef|ifndef|elif))\s{2,}/$1 /;
5105 }
5106
Andy Whitcroft22f2a2e2007-08-10 13:01:03 -07005107 }
5108
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07005109# check for spinlock_t definitions without a comment.
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07005110 if ($line =~ /^.\s*(struct\s+mutex|spinlock_t)\s+\S+;/ ||
5111 $line =~ /^.\s*(DEFINE_MUTEX)\s*\(/) {
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07005112 my $which = $1;
5113 if (!ctx_has_comment($first_line, $linenr)) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005114 CHK("UNCOMMENTED_DEFINITION",
5115 "$1 definition without comment\n" . $herecurr);
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07005116 }
5117 }
5118# check for memory barriers without a comment.
5119 if ($line =~ /\b(mb|rmb|wmb|read_barrier_depends|smp_mb|smp_rmb|smp_wmb|smp_read_barrier_depends)\(/) {
5120 if (!ctx_has_comment($first_line, $linenr)) {
Joe Perchesc1fd7bb2013-11-12 15:10:11 -08005121 WARN("MEMORY_BARRIER",
5122 "memory barrier without comment\n" . $herecurr);
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07005123 }
5124 }
Paul E. McKenney3ad81772015-07-02 11:55:40 -07005125
Joe Perchescb426e92015-06-25 15:02:46 -07005126# check for waitqueue_active without a comment.
5127 if ($line =~ /\bwaitqueue_active\s*\(/) {
5128 if (!ctx_has_comment($first_line, $linenr)) {
5129 WARN("WAITQUEUE_ACTIVE",
5130 "waitqueue_active without comment\n" . $herecurr);
5131 }
5132 }
Paul E. McKenney3ad81772015-07-02 11:55:40 -07005133
5134# Check for expedited grace periods that interrupt non-idle non-nohz
5135# online CPUs. These expedited can therefore degrade real-time response
5136# if used carelessly, and should be avoided where not absolutely
5137# needed. It is always OK to use synchronize_rcu_expedited() and
5138# synchronize_sched_expedited() at boot time (before real-time applications
5139# start) and in error situations where real-time response is compromised in
5140# any case. Note that synchronize_srcu_expedited() does -not- interrupt
5141# other CPUs, so don't warn on uses of synchronize_srcu_expedited().
5142# Of course, nothing comes for free, and srcu_read_lock() and
5143# srcu_read_unlock() do contain full memory barriers in payment for
5144# synchronize_srcu_expedited() non-interruption properties.
5145 if ($line =~ /\b(synchronize_rcu_expedited|synchronize_sched_expedited)\(/) {
5146 WARN("EXPEDITED_RCU_GRACE_PERIOD",
5147 "expedited RCU grace periods should be avoided where they can degrade real-time response\n" . $herecurr);
5148
5149 }
5150
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07005151# check of hardware specific defines
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07005152 if ($line =~ m@^.\s*\#\s*if.*\b(__i386__|__powerpc64__|__sun__|__s390x__)\b@ && $realfile !~ m@include/asm-@) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005153 CHK("ARCH_DEFINES",
5154 "architecture specific defines should be avoided\n" . $herecurr);
Andy Whitcroft0a920b52007-06-01 00:46:48 -07005155 }
Andy Whitcroft653d4872007-06-23 17:16:34 -07005156
Tobias Klauserd4977c72010-05-24 14:33:30 -07005157# Check that the storage class is at the beginning of a declaration
5158 if ($line =~ /\b$Storage\b/ && $line !~ /^.\s*$Storage\b/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005159 WARN("STORAGE_CLASS",
5160 "storage class should be at the beginning of the declaration\n" . $herecurr)
Tobias Klauserd4977c72010-05-24 14:33:30 -07005161 }
5162
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07005163# check the location of the inline attribute, that it is between
5164# storage class and type.
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07005165 if ($line =~ /\b$Type\s+$Inline\b/ ||
5166 $line =~ /\b$Inline\s+$Storage\b/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005167 ERROR("INLINE_LOCATION",
5168 "inline keyword should sit between storage class and type\n" . $herecurr);
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07005169 }
5170
Andy Whitcroft8905a672007-11-28 16:21:06 -08005171# Check for __inline__ and __inline, prefer inline
Joe Perches2b7ab452013-11-12 15:10:14 -08005172 if ($realfile !~ m@\binclude/uapi/@ &&
5173 $line =~ /\b(__inline__|__inline)\b/) {
Joe Perchesd5e616f2013-09-11 14:23:54 -07005174 if (WARN("INLINE",
5175 "plain inline is preferred over $1\n" . $herecurr) &&
5176 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07005177 $fixed[$fixlinenr] =~ s/\b(__inline__|__inline)\b/inline/;
Joe Perchesd5e616f2013-09-11 14:23:54 -07005178
5179 }
Andy Whitcroft8905a672007-11-28 16:21:06 -08005180 }
5181
Joe Perches3d130fd2011-01-12 17:00:00 -08005182# Check for __attribute__ packed, prefer __packed
Joe Perches2b7ab452013-11-12 15:10:14 -08005183 if ($realfile !~ m@\binclude/uapi/@ &&
5184 $line =~ /\b__attribute__\s*\(\s*\(.*\bpacked\b/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005185 WARN("PREFER_PACKED",
5186 "__packed is preferred over __attribute__((packed))\n" . $herecurr);
Joe Perches3d130fd2011-01-12 17:00:00 -08005187 }
5188
Joe Perches39b7e282011-07-25 17:13:24 -07005189# Check for __attribute__ aligned, prefer __aligned
Joe Perches2b7ab452013-11-12 15:10:14 -08005190 if ($realfile !~ m@\binclude/uapi/@ &&
5191 $line =~ /\b__attribute__\s*\(\s*\(.*aligned/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005192 WARN("PREFER_ALIGNED",
5193 "__aligned(size) is preferred over __attribute__((aligned(size)))\n" . $herecurr);
Joe Perches39b7e282011-07-25 17:13:24 -07005194 }
5195
Joe Perches5f14d3b2012-01-10 15:09:52 -08005196# Check for __attribute__ format(printf, prefer __printf
Joe Perches2b7ab452013-11-12 15:10:14 -08005197 if ($realfile !~ m@\binclude/uapi/@ &&
5198 $line =~ /\b__attribute__\s*\(\s*\(\s*format\s*\(\s*printf/) {
Joe Perchesd5e616f2013-09-11 14:23:54 -07005199 if (WARN("PREFER_PRINTF",
5200 "__printf(string-index, first-to-check) is preferred over __attribute__((format(printf, string-index, first-to-check)))\n" . $herecurr) &&
5201 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07005202 $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 -07005203
5204 }
Joe Perches5f14d3b2012-01-10 15:09:52 -08005205 }
5206
Joe Perches6061d942012-03-23 15:02:16 -07005207# Check for __attribute__ format(scanf, prefer __scanf
Joe Perches2b7ab452013-11-12 15:10:14 -08005208 if ($realfile !~ m@\binclude/uapi/@ &&
5209 $line =~ /\b__attribute__\s*\(\s*\(\s*format\s*\(\s*scanf\b/) {
Joe Perchesd5e616f2013-09-11 14:23:54 -07005210 if (WARN("PREFER_SCANF",
5211 "__scanf(string-index, first-to-check) is preferred over __attribute__((format(scanf, string-index, first-to-check)))\n" . $herecurr) &&
5212 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07005213 $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 -07005214 }
Joe Perches6061d942012-03-23 15:02:16 -07005215 }
5216
Joe Perches619a9082014-12-10 15:51:35 -08005217# Check for __attribute__ weak, or __weak declarations (may have link issues)
5218 if ($^V && $^V ge 5.10.0 &&
5219 $line =~ /(?:$Declare|$DeclareMisordered)\s*$Ident\s*$balanced_parens\s*(?:$Attribute)?\s*;/ &&
5220 ($line =~ /\b__attribute__\s*\(\s*\(.*\bweak\b/ ||
5221 $line =~ /\b__weak\b/)) {
5222 ERROR("WEAK_DECLARATION",
5223 "Using weak declarations can have unintended link defects\n" . $herecurr);
5224 }
5225
Joe Perchese6176fa2015-06-25 15:02:49 -07005226# check for c99 types like uint8_t used outside of uapi/
5227 if ($realfile !~ m@\binclude/uapi/@ &&
5228 $line =~ /\b($Declare)\s*$Ident\s*[=;,\[]/) {
5229 my $type = $1;
5230 if ($type =~ /\b($typeC99Typedefs)\b/) {
5231 $type = $1;
5232 my $kernel_type = 'u';
5233 $kernel_type = 's' if ($type =~ /^_*[si]/);
5234 $type =~ /(\d+)/;
5235 $kernel_type .= $1;
5236 if (CHK("PREFER_KERNEL_TYPES",
5237 "Prefer kernel type '$kernel_type' over '$type'\n" . $herecurr) &&
5238 $fix) {
5239 $fixed[$fixlinenr] =~ s/\b$type\b/$kernel_type/;
5240 }
5241 }
5242 }
5243
Joe Perches8f53a9b2010-03-05 13:43:48 -08005244# check for sizeof(&)
5245 if ($line =~ /\bsizeof\s*\(\s*\&/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005246 WARN("SIZEOF_ADDRESS",
5247 "sizeof(& should be avoided\n" . $herecurr);
Joe Perches8f53a9b2010-03-05 13:43:48 -08005248 }
5249
Joe Perches66c80b62012-07-30 14:41:22 -07005250# check for sizeof without parenthesis
5251 if ($line =~ /\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/) {
Joe Perchesd5e616f2013-09-11 14:23:54 -07005252 if (WARN("SIZEOF_PARENTHESIS",
5253 "sizeof $1 should be sizeof($1)\n" . $herecurr) &&
5254 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07005255 $fixed[$fixlinenr] =~ s/\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/"sizeof(" . trim($1) . ")"/ex;
Joe Perchesd5e616f2013-09-11 14:23:54 -07005256 }
Joe Perches66c80b62012-07-30 14:41:22 -07005257 }
5258
Joe Perches88982fe2012-12-17 16:02:00 -08005259# check for struct spinlock declarations
5260 if ($line =~ /^.\s*\bstruct\s+spinlock\s+\w+\s*;/) {
5261 WARN("USE_SPINLOCK_T",
5262 "struct spinlock should be spinlock_t\n" . $herecurr);
5263 }
5264
Joe Perchesa6962d72013-04-29 16:18:13 -07005265# check for seq_printf uses that could be seq_puts
Joe Perches06668722013-11-12 15:10:07 -08005266 if ($sline =~ /\bseq_printf\s*\(.*"\s*\)\s*;\s*$/) {
Joe Perchesa6962d72013-04-29 16:18:13 -07005267 my $fmt = get_quoted_string($line, $rawline);
Heba Aamercaac1d52015-02-13 14:38:49 -08005268 $fmt =~ s/%%//g;
5269 if ($fmt !~ /%/) {
Joe Perchesd5e616f2013-09-11 14:23:54 -07005270 if (WARN("PREFER_SEQ_PUTS",
5271 "Prefer seq_puts to seq_printf\n" . $herecurr) &&
5272 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07005273 $fixed[$fixlinenr] =~ s/\bseq_printf\b/seq_puts/;
Joe Perchesd5e616f2013-09-11 14:23:54 -07005274 }
Joe Perchesa6962d72013-04-29 16:18:13 -07005275 }
5276 }
5277
Andy Whitcroft554e1652012-01-10 15:09:57 -08005278# Check for misused memsets
Joe Perchesd1fe9c02012-03-23 15:02:16 -07005279 if ($^V && $^V ge 5.10.0 &&
5280 defined $stat &&
Mateusz Kulikowski9e20a852015-06-25 15:03:16 -07005281 $stat =~ /^\+(?:.*?)\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*$FuncArg\s*\)/) {
Andy Whitcroft554e1652012-01-10 15:09:57 -08005282
Joe Perchesd7c76ba2012-01-10 15:09:58 -08005283 my $ms_addr = $2;
Joe Perchesd1fe9c02012-03-23 15:02:16 -07005284 my $ms_val = $7;
5285 my $ms_size = $12;
Joe Perchesd7c76ba2012-01-10 15:09:58 -08005286
Andy Whitcroft554e1652012-01-10 15:09:57 -08005287 if ($ms_size =~ /^(0x|)0$/i) {
5288 ERROR("MEMSET",
Joe Perchesd7c76ba2012-01-10 15:09:58 -08005289 "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 -08005290 } elsif ($ms_size =~ /^(0x|)1$/i) {
5291 WARN("MEMSET",
Joe Perchesd7c76ba2012-01-10 15:09:58 -08005292 "single byte memset is suspicious. Swapped 2nd/3rd argument?\n" . "$here\n$stat\n");
5293 }
5294 }
5295
Joe Perches98a9bba2014-01-23 15:54:52 -08005296# Check for memcpy(foo, bar, ETH_ALEN) that could be ether_addr_copy(foo, bar)
5297 if ($^V && $^V ge 5.10.0 &&
Mateusz Kulikowski10895d22015-06-25 15:03:21 -07005298 defined $stat &&
5299 $stat =~ /^\+(?:.*?)\bmemcpy\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/) {
Joe Perches98a9bba2014-01-23 15:54:52 -08005300 if (WARN("PREFER_ETHER_ADDR_COPY",
Mateusz Kulikowski10895d22015-06-25 15:03:21 -07005301 "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 -08005302 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07005303 $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 -08005304 }
5305 }
5306
Mateusz Kulikowskib6117d12015-06-25 15:03:13 -07005307# Check for memcmp(foo, bar, ETH_ALEN) that could be ether_addr_equal*(foo, bar)
5308 if ($^V && $^V ge 5.10.0 &&
5309 defined $stat &&
5310 $stat =~ /^\+(?:.*?)\bmemcmp\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/) {
5311 WARN("PREFER_ETHER_ADDR_EQUAL",
5312 "Prefer ether_addr_equal() or ether_addr_equal_unaligned() over memcmp()\n" . "$here\n$stat\n")
5313 }
5314
Mateusz Kulikowski8617cd02015-06-25 15:03:19 -07005315# check for memset(foo, 0x0, ETH_ALEN) that could be eth_zero_addr
5316# check for memset(foo, 0xFF, ETH_ALEN) that could be eth_broadcast_addr
5317 if ($^V && $^V ge 5.10.0 &&
5318 defined $stat &&
5319 $stat =~ /^\+(?:.*?)\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/) {
5320
5321 my $ms_val = $7;
5322
5323 if ($ms_val =~ /^(?:0x|)0+$/i) {
5324 if (WARN("PREFER_ETH_ZERO_ADDR",
5325 "Prefer eth_zero_addr over memset()\n" . "$here\n$stat\n") &&
5326 $fix) {
5327 $fixed[$fixlinenr] =~ s/\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*,\s*ETH_ALEN\s*\)/eth_zero_addr($2)/;
5328 }
5329 } elsif ($ms_val =~ /^(?:0xff|255)$/i) {
5330 if (WARN("PREFER_ETH_BROADCAST_ADDR",
5331 "Prefer eth_broadcast_addr() over memset()\n" . "$here\n$stat\n") &&
5332 $fix) {
5333 $fixed[$fixlinenr] =~ s/\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*,\s*ETH_ALEN\s*\)/eth_broadcast_addr($2)/;
5334 }
5335 }
5336 }
5337
Joe Perchesd7c76ba2012-01-10 15:09:58 -08005338# typecasts on min/max could be min_t/max_t
Joe Perchesd1fe9c02012-03-23 15:02:16 -07005339 if ($^V && $^V ge 5.10.0 &&
5340 defined $stat &&
Joe Perchesd7c76ba2012-01-10 15:09:58 -08005341 $stat =~ /^\+(?:.*?)\b(min|max)\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\)/) {
Joe Perchesd1fe9c02012-03-23 15:02:16 -07005342 if (defined $2 || defined $7) {
Joe Perchesd7c76ba2012-01-10 15:09:58 -08005343 my $call = $1;
5344 my $cast1 = deparenthesize($2);
5345 my $arg1 = $3;
Joe Perchesd1fe9c02012-03-23 15:02:16 -07005346 my $cast2 = deparenthesize($7);
5347 my $arg2 = $8;
Joe Perchesd7c76ba2012-01-10 15:09:58 -08005348 my $cast;
5349
Joe Perchesd1fe9c02012-03-23 15:02:16 -07005350 if ($cast1 ne "" && $cast2 ne "" && $cast1 ne $cast2) {
Joe Perchesd7c76ba2012-01-10 15:09:58 -08005351 $cast = "$cast1 or $cast2";
5352 } elsif ($cast1 ne "") {
5353 $cast = $cast1;
5354 } else {
5355 $cast = $cast2;
5356 }
5357 WARN("MINMAX",
5358 "$call() should probably be ${call}_t($cast, $arg1, $arg2)\n" . "$here\n$stat\n");
Andy Whitcroft554e1652012-01-10 15:09:57 -08005359 }
5360 }
5361
Joe Perches4a273192012-07-30 14:41:20 -07005362# check usleep_range arguments
5363 if ($^V && $^V ge 5.10.0 &&
5364 defined $stat &&
5365 $stat =~ /^\+(?:.*?)\busleep_range\s*\(\s*($FuncArg)\s*,\s*($FuncArg)\s*\)/) {
5366 my $min = $1;
5367 my $max = $7;
5368 if ($min eq $max) {
5369 WARN("USLEEP_RANGE",
5370 "usleep_range should not use min == max args; see Documentation/timers/timers-howto.txt\n" . "$here\n$stat\n");
5371 } elsif ($min =~ /^\d+$/ && $max =~ /^\d+$/ &&
5372 $min > $max) {
5373 WARN("USLEEP_RANGE",
5374 "usleep_range args reversed, use min then max; see Documentation/timers/timers-howto.txt\n" . "$here\n$stat\n");
5375 }
5376 }
5377
Joe Perches823b7942013-11-12 15:10:15 -08005378# check for naked sscanf
5379 if ($^V && $^V ge 5.10.0 &&
5380 defined $stat &&
Joe Perches6c8bd702014-04-03 14:49:16 -07005381 $line =~ /\bsscanf\b/ &&
Joe Perches823b7942013-11-12 15:10:15 -08005382 ($stat !~ /$Ident\s*=\s*sscanf\s*$balanced_parens/ &&
5383 $stat !~ /\bsscanf\s*$balanced_parens\s*(?:$Compare)/ &&
5384 $stat !~ /(?:$Compare)\s*\bsscanf\s*$balanced_parens/)) {
5385 my $lc = $stat =~ tr@\n@@;
5386 $lc = $lc + $linenr;
5387 my $stat_real = raw_line($linenr, 0);
5388 for (my $count = $linenr + 1; $count <= $lc; $count++) {
5389 $stat_real = $stat_real . "\n" . raw_line($count, 0);
5390 }
5391 WARN("NAKED_SSCANF",
5392 "unchecked sscanf return value\n" . "$here\n$stat_real\n");
5393 }
5394
Joe Perchesafc819a2014-06-04 16:12:08 -07005395# check for simple sscanf that should be kstrto<foo>
5396 if ($^V && $^V ge 5.10.0 &&
5397 defined $stat &&
5398 $line =~ /\bsscanf\b/) {
5399 my $lc = $stat =~ tr@\n@@;
5400 $lc = $lc + $linenr;
5401 my $stat_real = raw_line($linenr, 0);
5402 for (my $count = $linenr + 1; $count <= $lc; $count++) {
5403 $stat_real = $stat_real . "\n" . raw_line($count, 0);
5404 }
5405 if ($stat_real =~ /\bsscanf\b\s*\(\s*$FuncArg\s*,\s*("[^"]+")/) {
5406 my $format = $6;
5407 my $count = $format =~ tr@%@%@;
5408 if ($count == 1 &&
5409 $format =~ /^"\%(?i:ll[udxi]|[udxi]ll|ll|[hl]h?[udxi]|[udxi][hl]h?|[hl]h?|[udxi])"$/) {
5410 WARN("SSCANF_TO_KSTRTO",
5411 "Prefer kstrto<type> to single variable sscanf\n" . "$here\n$stat_real\n");
5412 }
5413 }
5414 }
5415
Joe Perches70dc8a42013-09-11 14:23:58 -07005416# check for new externs in .h files.
5417 if ($realfile =~ /\.h$/ &&
5418 $line =~ /^\+\s*(extern\s+)$Type\s*$Ident\s*\(/s) {
Joe Perchesd1d85782013-09-24 15:27:46 -07005419 if (CHK("AVOID_EXTERNS",
5420 "extern prototypes should be avoided in .h files\n" . $herecurr) &&
Joe Perches70dc8a42013-09-11 14:23:58 -07005421 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07005422 $fixed[$fixlinenr] =~ s/(.*)\bextern\b\s*(.*)/$1$2/;
Joe Perches70dc8a42013-09-11 14:23:58 -07005423 }
5424 }
5425
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07005426# check for new externs in .c files.
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07005427 if ($realfile =~ /\.c$/ && defined $stat &&
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07005428 $stat =~ /^.\s*(?:extern\s+)?$Type\s+($Ident)(\s*)\(/s)
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07005429 {
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07005430 my $function_name = $1;
5431 my $paren_space = $2;
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07005432
5433 my $s = $stat;
5434 if (defined $cond) {
5435 substr($s, 0, length($cond), '');
5436 }
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07005437 if ($s =~ /^\s*;/ &&
5438 $function_name ne 'uninitialized_var')
5439 {
Joe Perches000d1cc12011-07-25 17:13:25 -07005440 WARN("AVOID_EXTERNS",
5441 "externs should be avoided in .c files\n" . $herecurr);
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07005442 }
5443
5444 if ($paren_space =~ /\n/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005445 WARN("FUNCTION_ARGUMENTS",
5446 "arguments for function declarations should follow identifier\n" . $herecurr);
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07005447 }
Andy Whitcroft9c9ba342008-04-29 00:59:33 -07005448
5449 } elsif ($realfile =~ /\.c$/ && defined $stat &&
5450 $stat =~ /^.\s*extern\s+/)
5451 {
Joe Perches000d1cc12011-07-25 17:13:25 -07005452 WARN("AVOID_EXTERNS",
5453 "externs should be avoided in .c files\n" . $herecurr);
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07005454 }
5455
5456# checks for new __setup's
5457 if ($rawline =~ /\b__setup\("([^"]*)"/) {
5458 my $name = $1;
5459
5460 if (!grep(/$name/, @setup_docs)) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005461 CHK("UNDOCUMENTED_SETUP",
5462 "__setup appears un-documented -- check Documentation/kernel-parameters.txt\n" . $herecurr);
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07005463 }
Andy Whitcroft653d4872007-06-23 17:16:34 -07005464 }
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07005465
5466# check for pointless casting of kmalloc return
Joe Perchescaf2a542011-01-12 16:59:56 -08005467 if ($line =~ /\*\s*\)\s*[kv][czm]alloc(_node){0,1}\b/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005468 WARN("UNNECESSARY_CASTS",
5469 "unnecessary cast may hide bugs, see http://c-faq.com/malloc/mallocnocast.html\n" . $herecurr);
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07005470 }
Andy Whitcroft13214ad2008-02-08 04:22:03 -08005471
Joe Perchesa640d252013-07-03 15:05:21 -07005472# alloc style
5473# p = alloc(sizeof(struct foo), ...) should be p = alloc(sizeof(*p), ...)
5474 if ($^V && $^V ge 5.10.0 &&
5475 $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*([kv][mz]alloc(?:_node)?)\s*\(\s*(sizeof\s*\(\s*struct\s+$Lval\s*\))/) {
5476 CHK("ALLOC_SIZEOF_STRUCT",
5477 "Prefer $3(sizeof(*$1)...) over $3($4...)\n" . $herecurr);
5478 }
5479
Joe Perches60a55362014-06-04 16:12:07 -07005480# check for k[mz]alloc with multiplies that could be kmalloc_array/kcalloc
5481 if ($^V && $^V ge 5.10.0 &&
Joe Perchese3674552014-08-06 16:10:55 -07005482 $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 -07005483 my $oldfunc = $3;
5484 my $a1 = $4;
5485 my $a2 = $10;
5486 my $newfunc = "kmalloc_array";
5487 $newfunc = "kcalloc" if ($oldfunc eq "kzalloc");
Joe Perchese3674552014-08-06 16:10:55 -07005488 my $r1 = $a1;
5489 my $r2 = $a2;
5490 if ($a1 =~ /^sizeof\s*\S/) {
5491 $r1 = $a2;
5492 $r2 = $a1;
5493 }
5494 if ($r1 !~ /^sizeof\b/ && $r2 =~ /^sizeof\s*\S/ &&
5495 !($r1 =~ /^$Constant$/ || $r1 =~ /^[A-Z_][A-Z0-9_]*$/)) {
Joe Perches60a55362014-06-04 16:12:07 -07005496 if (WARN("ALLOC_WITH_MULTIPLY",
5497 "Prefer $newfunc over $oldfunc with multiply\n" . $herecurr) &&
5498 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07005499 $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 -07005500
5501 }
5502 }
5503 }
5504
Joe Perches972fdea2013-04-29 16:18:12 -07005505# check for krealloc arg reuse
5506 if ($^V && $^V ge 5.10.0 &&
5507 $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*krealloc\s*\(\s*\1\s*,/) {
5508 WARN("KREALLOC_ARG_REUSE",
5509 "Reusing the krealloc arg is almost always a bug\n" . $herecurr);
5510 }
5511
Joe Perches5ce59ae2013-02-21 16:44:18 -08005512# check for alloc argument mismatch
5513 if ($line =~ /\b(kcalloc|kmalloc_array)\s*\(\s*sizeof\b/) {
5514 WARN("ALLOC_ARRAY_ARGS",
5515 "$1 uses number as first arg, sizeof is generally wrong\n" . $herecurr);
5516 }
5517
Joe Perchescaf2a542011-01-12 16:59:56 -08005518# check for multiple semicolons
5519 if ($line =~ /;\s*;\s*$/) {
Joe Perchesd5e616f2013-09-11 14:23:54 -07005520 if (WARN("ONE_SEMICOLON",
5521 "Statements terminations use 1 semicolon\n" . $herecurr) &&
5522 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07005523 $fixed[$fixlinenr] =~ s/(\s*;\s*){2,}$/;/g;
Joe Perchesd5e616f2013-09-11 14:23:54 -07005524 }
Joe Perchesd1e2ad02012-12-17 16:02:01 -08005525 }
5526
Joe Perches0ab90192014-12-10 15:51:57 -08005527# check for #defines like: 1 << <digit> that could be BIT(digit)
5528 if ($line =~ /#\s*define\s+\w+\s+\(?\s*1\s*([ulUL]*)\s*\<\<\s*(?:\d+|$Ident)\s*\)?/) {
5529 my $ull = "";
5530 $ull = "_ULL" if (defined($1) && $1 =~ /ll/i);
5531 if (CHK("BIT_MACRO",
5532 "Prefer using the BIT$ull macro\n" . $herecurr) &&
5533 $fix) {
5534 $fixed[$fixlinenr] =~ s/\(?\s*1\s*[ulUL]*\s*<<\s*(\d+|$Ident)\s*\)?/BIT${ull}($1)/;
5535 }
5536 }
5537
Joe Perchese81f2392014-08-06 16:11:25 -07005538# check for case / default statements not preceded by break/fallthrough/switch
Joe Perchesc34c09a2014-01-23 15:54:43 -08005539 if ($line =~ /^.\s*(?:case\s+(?:$Ident|$Constant)\s*|default):/) {
5540 my $has_break = 0;
5541 my $has_statement = 0;
5542 my $count = 0;
5543 my $prevline = $linenr;
Joe Perchese81f2392014-08-06 16:11:25 -07005544 while ($prevline > 1 && ($file || $count < 3) && !$has_break) {
Joe Perchesc34c09a2014-01-23 15:54:43 -08005545 $prevline--;
5546 my $rline = $rawlines[$prevline - 1];
5547 my $fline = $lines[$prevline - 1];
5548 last if ($fline =~ /^\@\@/);
5549 next if ($fline =~ /^\-/);
5550 next if ($fline =~ /^.(?:\s*(?:case\s+(?:$Ident|$Constant)[\s$;]*|default):[\s$;]*)*$/);
5551 $has_break = 1 if ($rline =~ /fall[\s_-]*(through|thru)/i);
5552 next if ($fline =~ /^.[\s$;]*$/);
5553 $has_statement = 1;
5554 $count++;
5555 $has_break = 1 if ($fline =~ /\bswitch\b|\b(?:break\s*;[\s$;]*$|return\b|goto\b|continue\b)/);
5556 }
5557 if (!$has_break && $has_statement) {
5558 WARN("MISSING_BREAK",
5559 "Possible switch case/default not preceeded by break or fallthrough comment\n" . $herecurr);
5560 }
5561 }
5562
Joe Perchesd1e2ad02012-12-17 16:02:01 -08005563# check for switch/default statements without a break;
5564 if ($^V && $^V ge 5.10.0 &&
5565 defined $stat &&
5566 $stat =~ /^\+[$;\s]*(?:case[$;\s]+\w+[$;\s]*:[$;\s]*|)*[$;\s]*\bdefault[$;\s]*:[$;\s]*;/g) {
5567 my $ctx = '';
5568 my $herectx = $here . "\n";
5569 my $cnt = statement_rawlines($stat);
5570 for (my $n = 0; $n < $cnt; $n++) {
5571 $herectx .= raw_line($linenr, $n) . "\n";
5572 }
5573 WARN("DEFAULT_NO_BREAK",
5574 "switch default: should use break\n" . $herectx);
Joe Perchescaf2a542011-01-12 16:59:56 -08005575 }
5576
Andy Whitcroft13214ad2008-02-08 04:22:03 -08005577# check for gcc specific __FUNCTION__
Joe Perchesd5e616f2013-09-11 14:23:54 -07005578 if ($line =~ /\b__FUNCTION__\b/) {
5579 if (WARN("USE_FUNC",
5580 "__func__ should be used instead of gcc specific __FUNCTION__\n" . $herecurr) &&
5581 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07005582 $fixed[$fixlinenr] =~ s/\b__FUNCTION__\b/__func__/g;
Joe Perchesd5e616f2013-09-11 14:23:54 -07005583 }
Andy Whitcroft13214ad2008-02-08 04:22:03 -08005584 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07005585
Joe Perches62ec8182015-02-13 14:38:18 -08005586# check for uses of __DATE__, __TIME__, __TIMESTAMP__
5587 while ($line =~ /\b(__(?:DATE|TIME|TIMESTAMP)__)\b/g) {
5588 ERROR("DATE_TIME",
5589 "Use of the '$1' macro makes the build non-deterministic\n" . $herecurr);
5590 }
5591
Joe Perches2c924882012-03-23 15:02:20 -07005592# check for use of yield()
5593 if ($line =~ /\byield\s*\(\s*\)/) {
5594 WARN("YIELD",
5595 "Using yield() is generally wrong. See yield() kernel-doc (sched/core.c)\n" . $herecurr);
5596 }
5597
Joe Perches179f8f42013-07-03 15:05:30 -07005598# check for comparisons against true and false
5599 if ($line =~ /\+\s*(.*?)\b(true|false|$Lval)\s*(==|\!=)\s*(true|false|$Lval)\b(.*)$/i) {
5600 my $lead = $1;
5601 my $arg = $2;
5602 my $test = $3;
5603 my $otype = $4;
5604 my $trail = $5;
5605 my $op = "!";
5606
5607 ($arg, $otype) = ($otype, $arg) if ($arg =~ /^(?:true|false)$/i);
5608
5609 my $type = lc($otype);
5610 if ($type =~ /^(?:true|false)$/) {
5611 if (("$test" eq "==" && "$type" eq "true") ||
5612 ("$test" eq "!=" && "$type" eq "false")) {
5613 $op = "";
5614 }
5615
5616 CHK("BOOL_COMPARISON",
5617 "Using comparison to $otype is error prone\n" . $herecurr);
5618
5619## maybe suggesting a correct construct would better
5620## "Using comparison to $otype is error prone. Perhaps use '${lead}${op}${arg}${trail}'\n" . $herecurr);
5621
5622 }
5623 }
5624
Thomas Gleixner4882720b2010-09-07 14:34:01 +00005625# check for semaphores initialized locked
5626 if ($line =~ /^.\s*sema_init.+,\W?0\W?\)/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005627 WARN("CONSIDER_COMPLETION",
5628 "consider using a completion\n" . $herecurr);
Andy Whitcroft773647a2008-03-28 14:15:58 -07005629 }
Joe Perches6712d852012-03-23 15:02:20 -07005630
Joe Perches67d0a072011-10-31 17:13:10 -07005631# recommend kstrto* over simple_strto* and strict_strto*
5632 if ($line =~ /\b((simple|strict)_(strto(l|ll|ul|ull)))\s*\(/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005633 WARN("CONSIDER_KSTRTO",
Joe Perches67d0a072011-10-31 17:13:10 -07005634 "$1 is obsolete, use k$3 instead\n" . $herecurr);
Andy Whitcroft773647a2008-03-28 14:15:58 -07005635 }
Joe Perches6712d852012-03-23 15:02:20 -07005636
Fabian Frederickae3ccc42014-06-04 16:12:10 -07005637# check for __initcall(), use device_initcall() explicitly or more appropriate function please
Michael Ellermanf3db6632008-07-23 21:28:57 -07005638 if ($line =~ /^.\s*__initcall\s*\(/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005639 WARN("USE_DEVICE_INITCALL",
Fabian Frederickae3ccc42014-06-04 16:12:10 -07005640 "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 -07005641 }
Joe Perches6712d852012-03-23 15:02:20 -07005642
Joe Perches0f3c5aa2015-02-13 14:39:05 -08005643# check for various structs that are normally const (ops, kgdb, device_tree)
5644 my $const_structs = qr{
5645 acpi_dock_ops|
Emese Revfy79404842010-03-05 13:43:53 -08005646 address_space_operations|
5647 backlight_ops|
5648 block_device_operations|
5649 dentry_operations|
5650 dev_pm_ops|
5651 dma_map_ops|
5652 extent_io_ops|
5653 file_lock_operations|
5654 file_operations|
5655 hv_ops|
5656 ide_dma_ops|
5657 intel_dvo_dev_ops|
5658 item_operations|
5659 iwl_ops|
5660 kgdb_arch|
5661 kgdb_io|
5662 kset_uevent_ops|
5663 lock_manager_operations|
5664 microcode_ops|
5665 mtrr_ops|
5666 neigh_ops|
5667 nlmsvc_binding|
Joe Perches0f3c5aa2015-02-13 14:39:05 -08005668 of_device_id|
Emese Revfy79404842010-03-05 13:43:53 -08005669 pci_raw_ops|
5670 pipe_buf_operations|
5671 platform_hibernation_ops|
5672 platform_suspend_ops|
5673 proto_ops|
5674 rpc_pipe_ops|
5675 seq_operations|
5676 snd_ac97_build_ops|
5677 soc_pcmcia_socket_ops|
5678 stacktrace_ops|
5679 sysfs_ops|
5680 tty_operations|
Joe Perches6d07d01b2015-04-16 12:44:33 -07005681 uart_ops|
Emese Revfy79404842010-03-05 13:43:53 -08005682 usb_mon_operations|
5683 wd_ops}x;
Andy Whitcroft6903ffb2009-01-15 13:51:07 -08005684 if ($line !~ /\bconst\b/ &&
Joe Perches0f3c5aa2015-02-13 14:39:05 -08005685 $line =~ /\bstruct\s+($const_structs)\b/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005686 WARN("CONST_STRUCT",
5687 "struct $1 should normally be const\n" .
Andy Whitcroft6903ffb2009-01-15 13:51:07 -08005688 $herecurr);
Andy Whitcroft2b6db5c2009-01-06 14:41:29 -08005689 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07005690
5691# use of NR_CPUS is usually wrong
5692# ignore definitions of NR_CPUS and usage to define arrays as likely right
5693 if ($line =~ /\bNR_CPUS\b/ &&
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07005694 $line !~ /^.\s*\s*#\s*if\b.*\bNR_CPUS\b/ &&
5695 $line !~ /^.\s*\s*#\s*define\b.*\bNR_CPUS\b/ &&
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07005696 $line !~ /^.\s*$Declare\s.*\[[^\]]*NR_CPUS[^\]]*\]/ &&
5697 $line !~ /\[[^\]]*\.\.\.[^\]]*NR_CPUS[^\]]*\]/ &&
5698 $line !~ /\[[^\]]*NR_CPUS[^\]]*\.\.\.[^\]]*\]/)
Andy Whitcroft773647a2008-03-28 14:15:58 -07005699 {
Joe Perches000d1cc12011-07-25 17:13:25 -07005700 WARN("NR_CPUS",
5701 "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 -07005702 }
Andy Whitcroft9c9ba342008-04-29 00:59:33 -07005703
Joe Perches52ea8502013-11-12 15:10:09 -08005704# Use of __ARCH_HAS_<FOO> or ARCH_HAVE_<BAR> is wrong.
5705 if ($line =~ /\+\s*#\s*define\s+((?:__)?ARCH_(?:HAS|HAVE)\w*)\b/) {
5706 ERROR("DEFINE_ARCH_HAS",
5707 "#define of '$1' is wrong - use Kconfig variables or standard guards instead\n" . $herecurr);
5708 }
5709
Joe Perchesacd93622015-02-13 14:38:38 -08005710# likely/unlikely comparisons similar to "(likely(foo) > 0)"
5711 if ($^V && $^V ge 5.10.0 &&
5712 $line =~ /\b((?:un)?likely)\s*\(\s*$FuncArg\s*\)\s*$Compare/) {
5713 WARN("LIKELY_MISUSE",
5714 "Using $1 should generally have parentheses around the comparison\n" . $herecurr);
5715 }
5716
Andy Whitcroft691d77b2009-01-06 14:41:16 -08005717# whine mightly about in_atomic
5718 if ($line =~ /\bin_atomic\s*\(/) {
5719 if ($realfile =~ m@^drivers/@) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005720 ERROR("IN_ATOMIC",
5721 "do not use in_atomic in drivers\n" . $herecurr);
Andy Whitcroftf4a87732009-02-27 14:03:05 -08005722 } elsif ($realfile !~ m@^kernel/@) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005723 WARN("IN_ATOMIC",
5724 "use of in_atomic() is incorrect outside core kernel code\n" . $herecurr);
Andy Whitcroft691d77b2009-01-06 14:41:16 -08005725 }
5726 }
Peter Zijlstra1704f472010-03-19 01:37:42 +01005727
5728# check for lockdep_set_novalidate_class
5729 if ($line =~ /^.\s*lockdep_set_novalidate_class\s*\(/ ||
5730 $line =~ /__lockdep_no_validate__\s*\)/ ) {
5731 if ($realfile !~ m@^kernel/lockdep@ &&
5732 $realfile !~ m@^include/linux/lockdep@ &&
5733 $realfile !~ m@^drivers/base/core@) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005734 ERROR("LOCKDEP",
5735 "lockdep_no_validate class is reserved for device->mutex.\n" . $herecurr);
Peter Zijlstra1704f472010-03-19 01:37:42 +01005736 }
5737 }
Dave Jones88f88312011-01-12 16:59:59 -08005738
Joe Perchesb392c642015-04-16 12:44:16 -07005739 if ($line =~ /debugfs_create_\w+.*\b$mode_perms_world_writable\b/ ||
5740 $line =~ /DEVICE_ATTR.*\b$mode_perms_world_writable\b/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005741 WARN("EXPORTED_WORLD_WRITABLE",
5742 "Exporting world writable files is usually an error. Consider more restrictive permissions.\n" . $herecurr);
Dave Jones88f88312011-01-12 16:59:59 -08005743 }
Joe Perches24358802014-04-03 14:49:13 -07005744
Joe Perches515a2352014-04-03 14:49:24 -07005745# Mode permission misuses where it seems decimal should be octal
5746# This uses a shortcut match to avoid unnecessary uses of a slow foreach loop
5747 if ($^V && $^V ge 5.10.0 &&
5748 $line =~ /$mode_perms_search/) {
5749 foreach my $entry (@mode_permission_funcs) {
5750 my $func = $entry->[0];
5751 my $arg_pos = $entry->[1];
Joe Perches24358802014-04-03 14:49:13 -07005752
Joe Perches515a2352014-04-03 14:49:24 -07005753 my $skip_args = "";
5754 if ($arg_pos > 1) {
5755 $arg_pos--;
5756 $skip_args = "(?:\\s*$FuncArg\\s*,\\s*){$arg_pos,$arg_pos}";
5757 }
5758 my $test = "\\b$func\\s*\\(${skip_args}([\\d]+)\\s*[,\\)]";
5759 if ($line =~ /$test/) {
5760 my $val = $1;
5761 $val = $6 if ($skip_args ne "");
Joe Perches24358802014-04-03 14:49:13 -07005762
Joe Perches515a2352014-04-03 14:49:24 -07005763 if ($val !~ /^0$/ &&
5764 (($val =~ /^$Int$/ && $val !~ /^$Octal$/) ||
5765 length($val) ne 4)) {
5766 ERROR("NON_OCTAL_PERMISSIONS",
5767 "Use 4 digit octal (0777) not decimal permissions\n" . $herecurr);
Joe Perchesc0a5c892015-02-13 14:38:21 -08005768 } elsif ($val =~ /^$Octal$/ && (oct($val) & 02)) {
5769 ERROR("EXPORTED_WORLD_WRITABLE",
5770 "Exporting writable files is usually an error. Consider more restrictive permissions.\n" . $herecurr);
Joe Perches515a2352014-04-03 14:49:24 -07005771 }
Joe Perches24358802014-04-03 14:49:13 -07005772 }
5773 }
5774 }
Bjorn Andersson5a6d20c2015-06-25 15:03:24 -07005775
5776# validate content of MODULE_LICENSE against list from include/linux/module.h
5777 if ($line =~ /\bMODULE_LICENSE\s*\(\s*($String)\s*\)/) {
5778 my $extracted_string = get_quoted_string($line, $rawline);
5779 my $valid_licenses = qr{
5780 GPL|
5781 GPL\ v2|
5782 GPL\ and\ additional\ rights|
5783 Dual\ BSD/GPL|
5784 Dual\ MIT/GPL|
5785 Dual\ MPL/GPL|
5786 Proprietary
5787 }x;
5788 if ($extracted_string !~ /^"(?:$valid_licenses)"$/x) {
5789 WARN("MODULE_LICENSE",
5790 "unknown module license " . $extracted_string . "\n" . $herecurr);
5791 }
5792 }
Andy Whitcroft13214ad2008-02-08 04:22:03 -08005793 }
5794
5795 # If we have no input at all, then there is nothing to report on
5796 # so just keep quiet.
5797 if ($#rawlines == -1) {
5798 exit(0);
Andy Whitcroft0a920b52007-06-01 00:46:48 -07005799 }
5800
Andy Whitcroft8905a672007-11-28 16:21:06 -08005801 # In mailback mode only produce a report in the negative, for
5802 # things that appear to be patches.
5803 if ($mailback && ($clean == 1 || !$is_patch)) {
5804 exit(0);
5805 }
5806
5807 # This is not a patch, and we are are in 'no-patch' mode so
5808 # just keep quiet.
5809 if (!$chk_patch && !$is_patch) {
5810 exit(0);
5811 }
5812
Joe Perches06330fc2015-06-25 15:03:11 -07005813 if (!$is_patch && $file !~ /cover-letter\.patch$/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005814 ERROR("NOT_UNIFIED_DIFF",
5815 "Does not appear to be a unified-diff format patch\n");
Andy Whitcroft0a920b52007-06-01 00:46:48 -07005816 }
Joe Perches34d88152015-06-25 15:03:05 -07005817 if ($is_patch && $filename ne '-' && $chk_signoff && $signoff == 0) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005818 ERROR("MISSING_SIGN_OFF",
5819 "Missing Signed-off-by: line(s)\n");
Andy Whitcroft0a920b52007-06-01 00:46:48 -07005820 }
5821
Andy Whitcroft8905a672007-11-28 16:21:06 -08005822 print report_dump();
Andy Whitcroft13214ad2008-02-08 04:22:03 -08005823 if ($summary && !($clean == 1 && $quiet == 1)) {
5824 print "$filename " if ($summary_file);
Andy Whitcroft8905a672007-11-28 16:21:06 -08005825 print "total: $cnt_error errors, $cnt_warn warnings, " .
5826 (($check)? "$cnt_chk checks, " : "") .
5827 "$cnt_lines lines checked\n";
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07005828 }
Andy Whitcroft8905a672007-11-28 16:21:06 -08005829
Andy Whitcroftd2c0a232010-10-26 14:23:12 -07005830 if ($quiet == 0) {
5831 # If there were whitespace errors which cleanpatch can fix
5832 # then suggest that.
5833 if ($rpt_cleaners) {
Mike Frysingerb0781212011-03-22 16:34:43 -07005834 $rpt_cleaners = 0;
Joe Perchesd8469f12015-06-25 15:03:00 -07005835 print << "EOM"
5836
5837NOTE: Whitespace errors detected.
5838 You may wish to use scripts/cleanpatch or scripts/cleanfile
5839EOM
Andy Whitcroftd2c0a232010-10-26 14:23:12 -07005840 }
5841 }
5842
Joe Perchesd752fcc2014-08-06 16:11:05 -07005843 if ($clean == 0 && $fix &&
5844 ("@rawlines" ne "@fixed" ||
5845 $#fixed_inserted >= 0 || $#fixed_deleted >= 0)) {
Joe Perches9624b8d2014-01-23 15:54:44 -08005846 my $newfile = $filename;
5847 $newfile .= ".EXPERIMENTAL-checkpatch-fixes" if (!$fix_inplace);
Joe Perches3705ce52013-07-03 15:05:31 -07005848 my $linecount = 0;
5849 my $f;
5850
Joe Perchesd752fcc2014-08-06 16:11:05 -07005851 @fixed = fix_inserted_deleted_lines(\@fixed, \@fixed_inserted, \@fixed_deleted);
5852
Joe Perches3705ce52013-07-03 15:05:31 -07005853 open($f, '>', $newfile)
5854 or die "$P: Can't open $newfile for write\n";
5855 foreach my $fixed_line (@fixed) {
5856 $linecount++;
5857 if ($file) {
5858 if ($linecount > 3) {
5859 $fixed_line =~ s/^\+//;
Joe Perchesd752fcc2014-08-06 16:11:05 -07005860 print $f $fixed_line . "\n";
Joe Perches3705ce52013-07-03 15:05:31 -07005861 }
5862 } else {
5863 print $f $fixed_line . "\n";
5864 }
5865 }
5866 close($f);
5867
5868 if (!$quiet) {
5869 print << "EOM";
Joe Perchesd8469f12015-06-25 15:03:00 -07005870
Joe Perches3705ce52013-07-03 15:05:31 -07005871Wrote EXPERIMENTAL --fix correction(s) to '$newfile'
5872
5873Do _NOT_ trust the results written to this file.
5874Do _NOT_ submit these changes without inspecting them for correctness.
5875
5876This EXPERIMENTAL file is simply a convenience to help rewrite patches.
5877No warranties, expressed or implied...
Joe Perches3705ce52013-07-03 15:05:31 -07005878EOM
5879 }
5880 }
5881
Joe Perchesd8469f12015-06-25 15:03:00 -07005882 if ($quiet == 0) {
5883 print "\n";
5884 if ($clean == 1) {
5885 print "$vname has no obvious style problems and is ready for submission.\n";
5886 } else {
5887 print "$vname has style problems, please review.\n";
5888 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07005889 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07005890 return $clean;
5891}