blob: c5ec977b9c3786097b214e1c835efd8fa337c173 [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';
Andy Whitcroft0a920b52007-06-01 00:46:48 -070012
13my $P = $0;
Joe Perches36061e32014-12-10 15:51:43 -080014my $D = dirname(abs_path($P));
Andy Whitcroft0a920b52007-06-01 00:46:48 -070015
Joe Perches000d1cc12011-07-25 17:13:25 -070016my $V = '0.32';
Andy Whitcroft0a920b52007-06-01 00:46:48 -070017
18use Getopt::Long qw(:config no_auto_abbrev);
19
20my $quiet = 0;
21my $tree = 1;
22my $chk_signoff = 1;
23my $chk_patch = 1;
Andy Whitcroft773647a2008-03-28 14:15:58 -070024my $tst_only;
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -070025my $emacs = 0;
Andy Whitcroft8905a672007-11-28 16:21:06 -080026my $terse = 0;
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -070027my $file = 0;
28my $check = 0;
Joe Perches2ac73b4f2014-06-04 16:12:05 -070029my $check_orig = 0;
Andy Whitcroft8905a672007-11-28 16:21:06 -080030my $summary = 1;
31my $mailback = 0;
Andy Whitcroft13214ad2008-02-08 04:22:03 -080032my $summary_file = 0;
Joe Perches000d1cc12011-07-25 17:13:25 -070033my $show_types = 0;
Joe Perches3705ce52013-07-03 15:05:31 -070034my $fix = 0;
Joe Perches9624b8d2014-01-23 15:54:44 -080035my $fix_inplace = 0;
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -070036my $root;
Andy Whitcroftc2fdda02008-02-08 04:20:54 -080037my %debug;
Joe Perches34456862013-07-03 15:05:34 -070038my %camelcase = ();
Joe Perches91bfe482013-09-11 14:23:59 -070039my %use_type = ();
40my @use = ();
41my %ignore_type = ();
Joe Perches000d1cc12011-07-25 17:13:25 -070042my @ignore = ();
Hannes Eder77f5b102009-09-21 17:04:37 -070043my $help = 0;
Joe Perches000d1cc12011-07-25 17:13:25 -070044my $configuration_file = ".checkpatch.conf";
Joe Perches6cd7f382012-12-17 16:01:54 -080045my $max_line_length = 80;
Dave Hansend62a2012013-09-11 14:23:56 -070046my $ignore_perl_version = 0;
47my $minimum_perl_version = 5.10.0;
Vadim Bendebury56193272014-10-13 15:51:48 -070048my $min_conf_desc_length = 4;
Kees Cook66b47b42014-10-13 15:51:57 -070049my $spelling_file = "$D/spelling.txt";
Joe Perchesebfd7d62015-04-16 12:44:14 -070050my $codespell = 0;
51my $codespellfile = "/usr/local/share/codespell/dictionary.txt";
Hannes Eder77f5b102009-09-21 17:04:37 -070052
53sub help {
54 my ($exitcode) = @_;
55
56 print << "EOM";
57Usage: $P [OPTION]... [FILE]...
58Version: $V
59
60Options:
61 -q, --quiet quiet
62 --no-tree run without a kernel tree
63 --no-signoff do not check for 'Signed-off-by' line
64 --patch treat FILE as patchfile (default)
65 --emacs emacs compile window format
66 --terse one line per report
67 -f, --file treat FILE as regular source file
68 --subjective, --strict enable more subjective tests
Joe Perches91bfe482013-09-11 14:23:59 -070069 --types TYPE(,TYPE2...) show only these comma separated message types
Joe Perches000d1cc12011-07-25 17:13:25 -070070 --ignore TYPE(,TYPE2...) ignore various comma separated message types
Joe Perches6cd7f382012-12-17 16:01:54 -080071 --max-line-length=n set the maximum line length, if exceeded, warn
Vadim Bendebury56193272014-10-13 15:51:48 -070072 --min-conf-desc-length=n set the min description length, if shorter, warn
Joe Perches000d1cc12011-07-25 17:13:25 -070073 --show-types show the message "types" in the output
Hannes Eder77f5b102009-09-21 17:04:37 -070074 --root=PATH PATH to the kernel tree root
75 --no-summary suppress the per-file summary
76 --mailback only produce a report in case of warnings/errors
77 --summary-file include the filename in summary
78 --debug KEY=[0|1] turn on/off debugging of KEY, where KEY is one of
79 'values', 'possible', 'type', and 'attr' (default
80 is all off)
81 --test-only=WORD report only warnings/errors containing WORD
82 literally
Joe Perches3705ce52013-07-03 15:05:31 -070083 --fix EXPERIMENTAL - may create horrible results
84 If correctable single-line errors exist, create
85 "<inputfile>.EXPERIMENTAL-checkpatch-fixes"
86 with potential errors corrected to the preferred
87 checkpatch style
Joe Perches9624b8d2014-01-23 15:54:44 -080088 --fix-inplace EXPERIMENTAL - may create horrible results
89 Is the same as --fix, but overwrites the input
90 file. It's your fault if there's no backup or git
Dave Hansend62a2012013-09-11 14:23:56 -070091 --ignore-perl-version override checking of perl version. expect
92 runtime errors.
Joe Perchesebfd7d62015-04-16 12:44:14 -070093 --codespell Use the codespell dictionary for spelling/typos
94 (default:/usr/local/share/codespell/dictionary.txt)
95 --codespellfile Use this codespell dictionary
Hannes Eder77f5b102009-09-21 17:04:37 -070096 -h, --help, --version display this help and exit
97
98When FILE is - read standard input.
99EOM
100
101 exit($exitcode);
102}
103
Joe Perches000d1cc12011-07-25 17:13:25 -0700104my $conf = which_conf($configuration_file);
105if (-f $conf) {
106 my @conf_args;
107 open(my $conffile, '<', "$conf")
108 or warn "$P: Can't find a readable $configuration_file file $!\n";
109
110 while (<$conffile>) {
111 my $line = $_;
112
113 $line =~ s/\s*\n?$//g;
114 $line =~ s/^\s*//g;
115 $line =~ s/\s+/ /g;
116
117 next if ($line =~ m/^\s*#/);
118 next if ($line =~ m/^\s*$/);
119
120 my @words = split(" ", $line);
121 foreach my $word (@words) {
122 last if ($word =~ m/^#/);
123 push (@conf_args, $word);
124 }
125 }
126 close($conffile);
127 unshift(@ARGV, @conf_args) if @conf_args;
128}
129
Andy Whitcroft0a920b52007-06-01 00:46:48 -0700130GetOptions(
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700131 'q|quiet+' => \$quiet,
Andy Whitcroft0a920b52007-06-01 00:46:48 -0700132 'tree!' => \$tree,
133 'signoff!' => \$chk_signoff,
134 'patch!' => \$chk_patch,
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700135 'emacs!' => \$emacs,
Andy Whitcroft8905a672007-11-28 16:21:06 -0800136 'terse!' => \$terse,
Hannes Eder77f5b102009-09-21 17:04:37 -0700137 'f|file!' => \$file,
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700138 'subjective!' => \$check,
139 'strict!' => \$check,
Joe Perches000d1cc12011-07-25 17:13:25 -0700140 'ignore=s' => \@ignore,
Joe Perches91bfe482013-09-11 14:23:59 -0700141 'types=s' => \@use,
Joe Perches000d1cc12011-07-25 17:13:25 -0700142 'show-types!' => \$show_types,
Joe Perches6cd7f382012-12-17 16:01:54 -0800143 'max-line-length=i' => \$max_line_length,
Vadim Bendebury56193272014-10-13 15:51:48 -0700144 'min-conf-desc-length=i' => \$min_conf_desc_length,
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700145 'root=s' => \$root,
Andy Whitcroft8905a672007-11-28 16:21:06 -0800146 'summary!' => \$summary,
147 'mailback!' => \$mailback,
Andy Whitcroft13214ad2008-02-08 04:22:03 -0800148 'summary-file!' => \$summary_file,
Joe Perches3705ce52013-07-03 15:05:31 -0700149 'fix!' => \$fix,
Joe Perches9624b8d2014-01-23 15:54:44 -0800150 'fix-inplace!' => \$fix_inplace,
Dave Hansend62a2012013-09-11 14:23:56 -0700151 'ignore-perl-version!' => \$ignore_perl_version,
Andy Whitcroftc2fdda02008-02-08 04:20:54 -0800152 'debug=s' => \%debug,
Andy Whitcroft773647a2008-03-28 14:15:58 -0700153 'test-only=s' => \$tst_only,
Joe Perchesebfd7d62015-04-16 12:44:14 -0700154 'codespell!' => \$codespell,
155 'codespellfile=s' => \$codespellfile,
Hannes Eder77f5b102009-09-21 17:04:37 -0700156 'h|help' => \$help,
157 'version' => \$help
158) or help(1);
159
160help(0) if ($help);
Andy Whitcroft0a920b52007-06-01 00:46:48 -0700161
Joe Perches9624b8d2014-01-23 15:54:44 -0800162$fix = 1 if ($fix_inplace);
Joe Perches2ac73b4f2014-06-04 16:12:05 -0700163$check_orig = $check;
Joe Perches9624b8d2014-01-23 15:54:44 -0800164
Andy Whitcroft0a920b52007-06-01 00:46:48 -0700165my $exit = 0;
166
Dave Hansend62a2012013-09-11 14:23:56 -0700167if ($^V && $^V lt $minimum_perl_version) {
168 printf "$P: requires at least perl version %vd\n", $minimum_perl_version;
169 if (!$ignore_perl_version) {
170 exit(1);
171 }
172}
173
Andy Whitcroft0a920b52007-06-01 00:46:48 -0700174if ($#ARGV < 0) {
Hannes Eder77f5b102009-09-21 17:04:37 -0700175 print "$P: no input files\n";
Andy Whitcroft0a920b52007-06-01 00:46:48 -0700176 exit(1);
177}
178
Joe Perches91bfe482013-09-11 14:23:59 -0700179sub hash_save_array_words {
180 my ($hashRef, $arrayRef) = @_;
Joe Perches000d1cc12011-07-25 17:13:25 -0700181
Joe Perches91bfe482013-09-11 14:23:59 -0700182 my @array = split(/,/, join(',', @$arrayRef));
183 foreach my $word (@array) {
184 $word =~ s/\s*\n?$//g;
185 $word =~ s/^\s*//g;
186 $word =~ s/\s+/ /g;
187 $word =~ tr/[a-z]/[A-Z]/;
Joe Perches000d1cc12011-07-25 17:13:25 -0700188
Joe Perches91bfe482013-09-11 14:23:59 -0700189 next if ($word =~ m/^\s*#/);
190 next if ($word =~ m/^\s*$/);
191
192 $hashRef->{$word}++;
193 }
Joe Perches000d1cc12011-07-25 17:13:25 -0700194}
195
Joe Perches91bfe482013-09-11 14:23:59 -0700196sub hash_show_words {
197 my ($hashRef, $prefix) = @_;
198
Joe Perches58cb3cf2013-09-11 14:24:04 -0700199 if ($quiet == 0 && keys %$hashRef) {
Joe Perches91bfe482013-09-11 14:23:59 -0700200 print "NOTE: $prefix message types:";
Joe Perches58cb3cf2013-09-11 14:24:04 -0700201 foreach my $word (sort keys %$hashRef) {
Joe Perches91bfe482013-09-11 14:23:59 -0700202 print " $word";
203 }
204 print "\n\n";
205 }
206}
207
208hash_save_array_words(\%ignore_type, \@ignore);
209hash_save_array_words(\%use_type, \@use);
210
Andy Whitcroftc2fdda02008-02-08 04:20:54 -0800211my $dbg_values = 0;
212my $dbg_possible = 0;
Andy Whitcroft7429c692008-07-23 21:29:06 -0700213my $dbg_type = 0;
Andy Whitcrofta1ef2772008-10-15 22:02:17 -0700214my $dbg_attr = 0;
Andy Whitcroftc2fdda02008-02-08 04:20:54 -0800215for my $key (keys %debug) {
Andy Whitcroft21caa132009-01-06 14:41:30 -0800216 ## no critic
217 eval "\${dbg_$key} = '$debug{$key}';";
218 die "$@" if ($@);
Andy Whitcroftc2fdda02008-02-08 04:20:54 -0800219}
220
Andy Whitcroftd2c0a232010-10-26 14:23:12 -0700221my $rpt_cleaners = 0;
222
Andy Whitcroft8905a672007-11-28 16:21:06 -0800223if ($terse) {
224 $emacs = 1;
225 $quiet++;
226}
227
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700228if ($tree) {
229 if (defined $root) {
230 if (!top_of_kernel_tree($root)) {
231 die "$P: $root: --root does not point at a valid tree\n";
232 }
233 } else {
234 if (top_of_kernel_tree('.')) {
235 $root = '.';
236 } elsif ($0 =~ m@(.*)/scripts/[^/]*$@ &&
237 top_of_kernel_tree($1)) {
238 $root = $1;
239 }
240 }
241
242 if (!defined $root) {
243 print "Must be run from the top-level dir. of a kernel tree\n";
244 exit(2);
245 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -0700246}
247
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700248my $emitted_corrupt = 0;
249
Andy Whitcroft2ceb5322009-10-26 16:50:14 -0700250our $Ident = qr{
251 [A-Za-z_][A-Za-z\d_]*
252 (?:\s*\#\#\s*[A-Za-z_][A-Za-z\d_]*)*
253 }x;
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700254our $Storage = qr{extern|static|asmlinkage};
255our $Sparse = qr{
256 __user|
257 __kernel|
258 __force|
259 __iomem|
260 __must_check|
261 __init_refok|
Andy Whitcroft417495e2009-02-27 14:03:08 -0800262 __kprobes|
Sven Eckelmann165e72a2011-07-25 17:13:23 -0700263 __ref|
264 __rcu
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700265 }x;
Joe Perchese970b882013-11-12 15:10:10 -0800266our $InitAttributePrefix = qr{__(?:mem|cpu|dev|net_|)};
267our $InitAttributeData = qr{$InitAttributePrefix(?:initdata\b)};
268our $InitAttributeConst = qr{$InitAttributePrefix(?:initconst\b)};
269our $InitAttributeInit = qr{$InitAttributePrefix(?:init\b)};
270our $InitAttribute = qr{$InitAttributeData|$InitAttributeConst|$InitAttributeInit};
Joe Perches8716de32013-09-11 14:24:05 -0700271
Wolfram Sang52131292010-03-05 13:43:51 -0800272# Notes to $Attribute:
273# We need \b after 'init' otherwise 'initconst' will cause a false positive in a check
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700274our $Attribute = qr{
275 const|
Joe Perches03f1df72010-10-26 14:23:16 -0700276 __percpu|
277 __nocast|
278 __safe|
279 __bitwise__|
280 __packed__|
281 __packed2__|
282 __naked|
283 __maybe_unused|
284 __always_unused|
285 __noreturn|
286 __used|
287 __cold|
Joe Perchese23ef1f2015-02-13 14:38:24 -0800288 __pure|
Joe Perches03f1df72010-10-26 14:23:16 -0700289 __noclone|
290 __deprecated|
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700291 __read_mostly|
292 __kprobes|
Joe Perches8716de32013-09-11 14:24:05 -0700293 $InitAttribute|
Andy Whitcroft24e1d812008-10-15 22:02:18 -0700294 ____cacheline_aligned|
295 ____cacheline_aligned_in_smp|
Andy Whitcroft5fe3af12009-01-06 14:41:18 -0800296 ____cacheline_internodealigned_in_smp|
297 __weak
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700298 }x;
Andy Whitcroftc45dcab2008-06-05 22:46:01 -0700299our $Modifier;
Joe Perches91cb5192014-04-03 14:49:32 -0700300our $Inline = qr{inline|__always_inline|noinline|__inline|__inline__};
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700301our $Member = qr{->$Ident|\.$Ident|\[[^]]*\]};
302our $Lval = qr{$Ident(?:$Member)*};
303
Joe Perches95e2c602013-07-03 15:05:20 -0700304our $Int_type = qr{(?i)llu|ull|ll|lu|ul|l|u};
305our $Binary = qr{(?i)0b[01]+$Int_type?};
306our $Hex = qr{(?i)0x[0-9a-f]+$Int_type?};
307our $Int = qr{[0-9]+$Int_type?};
Joe Perches24358802014-04-03 14:49:13 -0700308our $Octal = qr{0[0-7]+$Int_type?};
Joe Perchesc0a5c892015-02-13 14:38:21 -0800309our $String = qr{"[X\t]*"};
Joe Perches326b1ff2013-02-04 14:28:51 -0800310our $Float_hex = qr{(?i)0x[0-9a-f]+p-?[0-9]+[fl]?};
311our $Float_dec = qr{(?i)(?:[0-9]+\.[0-9]*|[0-9]*\.[0-9]+)(?:e-?[0-9]+)?[fl]?};
312our $Float_int = qr{(?i)[0-9]+e-?[0-9]+[fl]?};
Joe Perches74349bc2012-12-17 16:02:05 -0800313our $Float = qr{$Float_hex|$Float_dec|$Float_int};
Joe Perches24358802014-04-03 14:49:13 -0700314our $Constant = qr{$Float|$Binary|$Octal|$Hex|$Int};
Joe Perches326b1ff2013-02-04 14:28:51 -0800315our $Assignment = qr{\*\=|/=|%=|\+=|-=|<<=|>>=|&=|\^=|\|=|=};
Joe Perches447432f2014-04-03 14:49:17 -0700316our $Compare = qr{<=|>=|==|!=|<|(?<!-)>};
Joe Perches23f780c2013-07-03 15:05:31 -0700317our $Arithmetic = qr{\+|-|\*|\/|%};
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700318our $Operators = qr{
319 <=|>=|==|!=|
320 =>|->|<<|>>|<|>|!|~|
Joe Perches23f780c2013-07-03 15:05:31 -0700321 &&|\|\||,|\^|\+\+|--|&|\||$Arithmetic
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700322 }x;
323
Joe Perches91cb5192014-04-03 14:49:32 -0700324our $c90_Keywords = qr{do|for|while|if|else|return|goto|continue|switch|default|case|break}x;
325
Joe Perchesab7e23f2015-04-16 12:44:22 -0700326our $BasicType;
Andy Whitcroft8905a672007-11-28 16:21:06 -0800327our $NonptrType;
Joe Perches18130872014-08-06 16:11:22 -0700328our $NonptrTypeMisordered;
Joe Perches8716de32013-09-11 14:24:05 -0700329our $NonptrTypeWithAttr;
Andy Whitcroft8905a672007-11-28 16:21:06 -0800330our $Type;
Joe Perches18130872014-08-06 16:11:22 -0700331our $TypeMisordered;
Andy Whitcroft8905a672007-11-28 16:21:06 -0800332our $Declare;
Joe Perches18130872014-08-06 16:11:22 -0700333our $DeclareMisordered;
Andy Whitcroft8905a672007-11-28 16:21:06 -0800334
Joe Perches15662b32011-10-31 17:13:12 -0700335our $NON_ASCII_UTF8 = qr{
336 [\xC2-\xDF][\x80-\xBF] # non-overlong 2-byte
Andy Whitcroft171ae1a2008-04-29 00:59:32 -0700337 | \xE0[\xA0-\xBF][\x80-\xBF] # excluding overlongs
338 | [\xE1-\xEC\xEE\xEF][\x80-\xBF]{2} # straight 3-byte
339 | \xED[\x80-\x9F][\x80-\xBF] # excluding surrogates
340 | \xF0[\x90-\xBF][\x80-\xBF]{2} # planes 1-3
341 | [\xF1-\xF3][\x80-\xBF]{3} # planes 4-15
342 | \xF4[\x80-\x8F][\x80-\xBF]{2} # plane 16
343}x;
344
Joe Perches15662b32011-10-31 17:13:12 -0700345our $UTF8 = qr{
346 [\x09\x0A\x0D\x20-\x7E] # ASCII
347 | $NON_ASCII_UTF8
348}x;
349
Joe Perches021158b2015-02-13 14:38:43 -0800350our $typeOtherOSTypedefs = qr{(?x:
351 u_(?:char|short|int|long) | # bsd
352 u(?:nchar|short|int|long) # sysv
353)};
354
Andy Whitcroft8ed22ca2008-10-15 22:02:32 -0700355our $typeTypedefs = qr{(?x:
Andy Whitcroftfb9e9092009-09-21 17:04:38 -0700356 (?:__)?(?:u|s|be|le)(?:8|16|32|64)|
Andy Whitcroft8ed22ca2008-10-15 22:02:32 -0700357 atomic_t
358)};
359
Joe Perches691e6692010-03-05 13:43:51 -0800360our $logFunctions = qr{(?x:
Joe Perches6e60c022011-07-25 17:13:27 -0700361 printk(?:_ratelimited|_once|)|
Jacob Keller7d0b6592013-07-03 15:05:35 -0700362 (?:[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 -0700363 WARN(?:_RATELIMIT|_ONCE|)|
Joe Perchesb0531722011-05-24 17:13:40 -0700364 panic|
Joe Perches06668722013-11-12 15:10:07 -0800365 MODULE_[A-Z_]+|
366 seq_vprintf|seq_printf|seq_puts
Joe Perches691e6692010-03-05 13:43:51 -0800367)};
368
Joe Perches20112472011-07-25 17:13:23 -0700369our $signature_tags = qr{(?xi:
370 Signed-off-by:|
371 Acked-by:|
372 Tested-by:|
373 Reviewed-by:|
374 Reported-by:|
Mugunthan V N8543ae12013-04-29 16:18:17 -0700375 Suggested-by:|
Joe Perches20112472011-07-25 17:13:23 -0700376 To:|
377 Cc:
378)};
379
Joe Perches18130872014-08-06 16:11:22 -0700380our @typeListMisordered = (
381 qr{char\s+(?:un)?signed},
382 qr{int\s+(?:(?:un)?signed\s+)?short\s},
383 qr{int\s+short(?:\s+(?:un)?signed)},
384 qr{short\s+int(?:\s+(?:un)?signed)},
385 qr{(?:un)?signed\s+int\s+short},
386 qr{short\s+(?:un)?signed},
387 qr{long\s+int\s+(?:un)?signed},
388 qr{int\s+long\s+(?:un)?signed},
389 qr{long\s+(?:un)?signed\s+int},
390 qr{int\s+(?:un)?signed\s+long},
391 qr{int\s+(?:un)?signed},
392 qr{int\s+long\s+long\s+(?:un)?signed},
393 qr{long\s+long\s+int\s+(?:un)?signed},
394 qr{long\s+long\s+(?:un)?signed\s+int},
395 qr{long\s+long\s+(?:un)?signed},
396 qr{long\s+(?:un)?signed},
397);
398
Andy Whitcroft8905a672007-11-28 16:21:06 -0800399our @typeList = (
400 qr{void},
Joe Perches0c773d92014-08-06 16:11:20 -0700401 qr{(?:(?:un)?signed\s+)?char},
402 qr{(?:(?:un)?signed\s+)?short\s+int},
403 qr{(?:(?:un)?signed\s+)?short},
404 qr{(?:(?:un)?signed\s+)?int},
405 qr{(?:(?:un)?signed\s+)?long\s+int},
406 qr{(?:(?:un)?signed\s+)?long\s+long\s+int},
407 qr{(?:(?:un)?signed\s+)?long\s+long},
408 qr{(?:(?:un)?signed\s+)?long},
409 qr{(?:un)?signed},
Andy Whitcroft8905a672007-11-28 16:21:06 -0800410 qr{float},
411 qr{double},
412 qr{bool},
Andy Whitcroft8905a672007-11-28 16:21:06 -0800413 qr{struct\s+$Ident},
414 qr{union\s+$Ident},
415 qr{enum\s+$Ident},
416 qr{${Ident}_t},
417 qr{${Ident}_handler},
418 qr{${Ident}_handler_fn},
Joe Perches18130872014-08-06 16:11:22 -0700419 @typeListMisordered,
Andy Whitcroft8905a672007-11-28 16:21:06 -0800420);
Joe Perches8716de32013-09-11 14:24:05 -0700421our @typeListWithAttr = (
422 @typeList,
423 qr{struct\s+$InitAttribute\s+$Ident},
424 qr{union\s+$InitAttribute\s+$Ident},
425);
426
Andy Whitcroftc45dcab2008-06-05 22:46:01 -0700427our @modifierList = (
428 qr{fastcall},
429);
Andy Whitcroft8905a672007-11-28 16:21:06 -0800430
Joe Perches24358802014-04-03 14:49:13 -0700431our @mode_permission_funcs = (
432 ["module_param", 3],
433 ["module_param_(?:array|named|string)", 4],
434 ["module_param_array_named", 5],
435 ["debugfs_create_(?:file|u8|u16|u32|u64|x8|x16|x32|x64|size_t|atomic_t|bool|blob|regset32|u32_array)", 2],
436 ["proc_create(?:_data|)", 2],
437 ["(?:CLASS|DEVICE|SENSOR)_ATTR", 2],
438);
439
Joe Perches515a2352014-04-03 14:49:24 -0700440#Create a search pattern for all these functions to speed up a loop below
441our $mode_perms_search = "";
442foreach my $entry (@mode_permission_funcs) {
443 $mode_perms_search .= '|' if ($mode_perms_search ne "");
444 $mode_perms_search .= $entry->[0];
445}
446
Joe Perchesb392c642015-04-16 12:44:16 -0700447our $mode_perms_world_writable = qr{
448 S_IWUGO |
449 S_IWOTH |
450 S_IRWXUGO |
451 S_IALLUGO |
452 0[0-7][0-7][2367]
453}x;
454
Wolfram Sang7840a942010-08-09 17:20:57 -0700455our $allowed_asm_includes = qr{(?x:
456 irq|
Sergey Ryazanovcdcee682014-10-13 15:51:44 -0700457 memory|
458 time|
459 reboot
Wolfram Sang7840a942010-08-09 17:20:57 -0700460)};
461# memory.h: ARM has a custom one
462
Kees Cook66b47b42014-10-13 15:51:57 -0700463# Load common spelling mistakes and build regular expression list.
464my $misspellings;
Kees Cook66b47b42014-10-13 15:51:57 -0700465my %spelling_fix;
Kees Cook66b47b42014-10-13 15:51:57 -0700466
Joe Perches36061e32014-12-10 15:51:43 -0800467if (open(my $spelling, '<', $spelling_file)) {
Joe Perches36061e32014-12-10 15:51:43 -0800468 while (<$spelling>) {
469 my $line = $_;
Kees Cook66b47b42014-10-13 15:51:57 -0700470
Joe Perches36061e32014-12-10 15:51:43 -0800471 $line =~ s/\s*\n?$//g;
472 $line =~ s/^\s*//g;
Kees Cook66b47b42014-10-13 15:51:57 -0700473
Joe Perches36061e32014-12-10 15:51:43 -0800474 next if ($line =~ m/^\s*#/);
475 next if ($line =~ m/^\s*$/);
Kees Cook66b47b42014-10-13 15:51:57 -0700476
Joe Perches36061e32014-12-10 15:51:43 -0800477 my ($suspect, $fix) = split(/\|\|/, $line);
478
Joe Perches36061e32014-12-10 15:51:43 -0800479 $spelling_fix{$suspect} = $fix;
480 }
481 close($spelling);
Joe Perches36061e32014-12-10 15:51:43 -0800482} else {
483 warn "No typos will be found - file '$spelling_file': $!\n";
Kees Cook66b47b42014-10-13 15:51:57 -0700484}
Kees Cook66b47b42014-10-13 15:51:57 -0700485
Joe Perchesebfd7d62015-04-16 12:44:14 -0700486if ($codespell) {
487 if (open(my $spelling, '<', $codespellfile)) {
488 while (<$spelling>) {
489 my $line = $_;
490
491 $line =~ s/\s*\n?$//g;
492 $line =~ s/^\s*//g;
493
494 next if ($line =~ m/^\s*#/);
495 next if ($line =~ m/^\s*$/);
496 next if ($line =~ m/, disabled/i);
497
498 $line =~ s/,.*$//;
499
500 my ($suspect, $fix) = split(/->/, $line);
501
502 $spelling_fix{$suspect} = $fix;
503 }
504 close($spelling);
505 } else {
506 warn "No codespell typos will be found - file '$codespellfile': $!\n";
507 }
508}
509
510$misspellings = join("|", sort keys %spelling_fix) if keys %spelling_fix;
511
Andy Whitcroft8905a672007-11-28 16:21:06 -0800512sub build_types {
Andy Whitcroftd2172eb2008-07-23 21:29:07 -0700513 my $mods = "(?x: \n" . join("|\n ", @modifierList) . "\n)";
514 my $all = "(?x: \n" . join("|\n ", @typeList) . "\n)";
Joe Perches18130872014-08-06 16:11:22 -0700515 my $Misordered = "(?x: \n" . join("|\n ", @typeListMisordered) . "\n)";
Joe Perches8716de32013-09-11 14:24:05 -0700516 my $allWithAttr = "(?x: \n" . join("|\n ", @typeListWithAttr) . "\n)";
Andy Whitcroftc8cb2ca2008-07-23 21:28:57 -0700517 $Modifier = qr{(?:$Attribute|$Sparse|$mods)};
Joe Perchesab7e23f2015-04-16 12:44:22 -0700518 $BasicType = qr{
519 (?:$typeOtherOSTypedefs\b)|
520 (?:$typeTypedefs\b)|
521 (?:${all}\b)
522 }x;
Andy Whitcroft8905a672007-11-28 16:21:06 -0800523 $NonptrType = qr{
Andy Whitcroftd2172eb2008-07-23 21:29:07 -0700524 (?:$Modifier\s+|const\s+)*
Andy Whitcroftcf655042008-03-04 14:28:20 -0800525 (?:
Andy Whitcroft6b48db22012-01-10 15:10:13 -0800526 (?:typeof|__typeof__)\s*\([^\)]*\)|
Joe Perches021158b2015-02-13 14:38:43 -0800527 (?:$typeOtherOSTypedefs\b)|
Andy Whitcroft8ed22ca2008-10-15 22:02:32 -0700528 (?:$typeTypedefs\b)|
Andy Whitcroftc45dcab2008-06-05 22:46:01 -0700529 (?:${all}\b)
Andy Whitcroftcf655042008-03-04 14:28:20 -0800530 )
Andy Whitcroftc8cb2ca2008-07-23 21:28:57 -0700531 (?:\s+$Modifier|\s+const)*
Andy Whitcroft8905a672007-11-28 16:21:06 -0800532 }x;
Joe Perches18130872014-08-06 16:11:22 -0700533 $NonptrTypeMisordered = qr{
534 (?:$Modifier\s+|const\s+)*
535 (?:
536 (?:${Misordered}\b)
537 )
538 (?:\s+$Modifier|\s+const)*
539 }x;
Joe Perches8716de32013-09-11 14:24:05 -0700540 $NonptrTypeWithAttr = qr{
541 (?:$Modifier\s+|const\s+)*
542 (?:
543 (?:typeof|__typeof__)\s*\([^\)]*\)|
544 (?:$typeTypedefs\b)|
Joe Perches021158b2015-02-13 14:38:43 -0800545 (?:$typeOtherOSTypedefs\b)|
Joe Perches8716de32013-09-11 14:24:05 -0700546 (?:${allWithAttr}\b)
547 )
548 (?:\s+$Modifier|\s+const)*
549 }x;
Andy Whitcroft8905a672007-11-28 16:21:06 -0800550 $Type = qr{
Andy Whitcroftc45dcab2008-06-05 22:46:01 -0700551 $NonptrType
Joe Perches1574a292014-08-06 16:10:50 -0700552 (?:(?:\s|\*|\[\])+\s*const|(?:\s|\*\s*(?:const\s*)?|\[\])+|(?:\s*\[\s*\])+)?
Andy Whitcroftc8cb2ca2008-07-23 21:28:57 -0700553 (?:\s+$Inline|\s+$Modifier)*
Andy Whitcroft8905a672007-11-28 16:21:06 -0800554 }x;
Joe Perches18130872014-08-06 16:11:22 -0700555 $TypeMisordered = qr{
556 $NonptrTypeMisordered
557 (?:(?:\s|\*|\[\])+\s*const|(?:\s|\*\s*(?:const\s*)?|\[\])+|(?:\s*\[\s*\])+)?
558 (?:\s+$Inline|\s+$Modifier)*
559 }x;
Joe Perches91cb5192014-04-03 14:49:32 -0700560 $Declare = qr{(?:$Storage\s+(?:$Inline\s+)?)?$Type};
Joe Perches18130872014-08-06 16:11:22 -0700561 $DeclareMisordered = qr{(?:$Storage\s+(?:$Inline\s+)?)?$TypeMisordered};
Andy Whitcroft8905a672007-11-28 16:21:06 -0800562}
563build_types();
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700564
Joe Perches7d2367a2011-07-25 17:13:22 -0700565our $Typecast = qr{\s*(\(\s*$NonptrType\s*\)){0,1}\s*};
Joe Perchesd1fe9c02012-03-23 15:02:16 -0700566
567# Using $balanced_parens, $LvalOrFunc, or $FuncArg
568# requires at least perl version v5.10.0
569# Any use must be runtime checked with $^V
570
571our $balanced_parens = qr/(\((?:[^\(\)]++|(?-1))*\))/;
Joe Perches24358802014-04-03 14:49:13 -0700572our $LvalOrFunc = qr{((?:[\&\*]\s*)?$Lval)\s*($balanced_parens{0,1})\s*};
Joe Perchesc0a5c892015-02-13 14:38:21 -0800573our $FuncArg = qr{$Typecast{0,1}($LvalOrFunc|$Constant|$String)};
Joe Perches7d2367a2011-07-25 17:13:22 -0700574
Joe Perchesf8422302014-08-06 16:11:31 -0700575our $declaration_macros = qr{(?x:
576 (?:$Storage\s+)?(?:[A-Z_][A-Z0-9]*_){0,2}(?:DEFINE|DECLARE)(?:_[A-Z0-9]+){1,2}\s*\(|
577 (?:$Storage\s+)?LIST_HEAD\s*\(|
578 (?:$Storage\s+)?${Type}\s+uninitialized_var\s*\(
579)};
580
Joe Perches7d2367a2011-07-25 17:13:22 -0700581sub deparenthesize {
582 my ($string) = @_;
583 return "" if (!defined($string));
Joe Perches5b9553a2014-04-03 14:49:21 -0700584
585 while ($string =~ /^\s*\(.*\)\s*$/) {
586 $string =~ s@^\s*\(\s*@@;
587 $string =~ s@\s*\)\s*$@@;
588 }
589
Joe Perches7d2367a2011-07-25 17:13:22 -0700590 $string =~ s@\s+@ @g;
Joe Perches5b9553a2014-04-03 14:49:21 -0700591
Joe Perches7d2367a2011-07-25 17:13:22 -0700592 return $string;
593}
594
Joe Perches34456862013-07-03 15:05:34 -0700595sub seed_camelcase_file {
596 my ($file) = @_;
597
598 return if (!(-f $file));
599
600 local $/;
601
602 open(my $include_file, '<', "$file")
603 or warn "$P: Can't read '$file' $!\n";
604 my $text = <$include_file>;
605 close($include_file);
606
607 my @lines = split('\n', $text);
608
609 foreach my $line (@lines) {
610 next if ($line !~ /(?:[A-Z][a-z]|[a-z][A-Z])/);
611 if ($line =~ /^[ \t]*(?:#[ \t]*define|typedef\s+$Type)\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)/) {
612 $camelcase{$1} = 1;
Joe Perches11ea5162013-11-12 15:10:08 -0800613 } elsif ($line =~ /^\s*$Declare\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)\s*[\(\[,;]/) {
614 $camelcase{$1} = 1;
615 } 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 -0700616 $camelcase{$1} = 1;
617 }
618 }
619}
620
621my $camelcase_seeded = 0;
622sub seed_camelcase_includes {
623 return if ($camelcase_seeded);
624
625 my $files;
Joe Perchesc707a812013-07-08 16:00:43 -0700626 my $camelcase_cache = "";
627 my @include_files = ();
628
629 $camelcase_seeded = 1;
Joe Perches351b2a12013-07-03 15:05:36 -0700630
Richard Genoud3645e322014-02-10 14:25:32 -0800631 if (-e ".git") {
Joe Perches351b2a12013-07-03 15:05:36 -0700632 my $git_last_include_commit = `git log --no-merges --pretty=format:"%h%n" -1 -- include`;
633 chomp $git_last_include_commit;
Joe Perchesc707a812013-07-08 16:00:43 -0700634 $camelcase_cache = ".checkpatch-camelcase.git.$git_last_include_commit";
Joe Perches34456862013-07-03 15:05:34 -0700635 } else {
Joe Perchesc707a812013-07-08 16:00:43 -0700636 my $last_mod_date = 0;
Joe Perches34456862013-07-03 15:05:34 -0700637 $files = `find $root/include -name "*.h"`;
Joe Perchesc707a812013-07-08 16:00:43 -0700638 @include_files = split('\n', $files);
639 foreach my $file (@include_files) {
640 my $date = POSIX::strftime("%Y%m%d%H%M",
641 localtime((stat $file)[9]));
642 $last_mod_date = $date if ($last_mod_date < $date);
643 }
644 $camelcase_cache = ".checkpatch-camelcase.date.$last_mod_date";
Joe Perches34456862013-07-03 15:05:34 -0700645 }
Joe Perchesc707a812013-07-08 16:00:43 -0700646
647 if ($camelcase_cache ne "" && -f $camelcase_cache) {
648 open(my $camelcase_file, '<', "$camelcase_cache")
649 or warn "$P: Can't read '$camelcase_cache' $!\n";
650 while (<$camelcase_file>) {
651 chomp;
652 $camelcase{$_} = 1;
653 }
654 close($camelcase_file);
655
656 return;
657 }
658
Richard Genoud3645e322014-02-10 14:25:32 -0800659 if (-e ".git") {
Joe Perchesc707a812013-07-08 16:00:43 -0700660 $files = `git ls-files "include/*.h"`;
661 @include_files = split('\n', $files);
662 }
663
Joe Perches34456862013-07-03 15:05:34 -0700664 foreach my $file (@include_files) {
665 seed_camelcase_file($file);
666 }
Joe Perches351b2a12013-07-03 15:05:36 -0700667
Joe Perchesc707a812013-07-08 16:00:43 -0700668 if ($camelcase_cache ne "") {
Joe Perches351b2a12013-07-03 15:05:36 -0700669 unlink glob ".checkpatch-camelcase.*";
Joe Perchesc707a812013-07-08 16:00:43 -0700670 open(my $camelcase_file, '>', "$camelcase_cache")
671 or warn "$P: Can't write '$camelcase_cache' $!\n";
Joe Perches351b2a12013-07-03 15:05:36 -0700672 foreach (sort { lc($a) cmp lc($b) } keys(%camelcase)) {
673 print $camelcase_file ("$_\n");
674 }
675 close($camelcase_file);
676 }
Joe Perches34456862013-07-03 15:05:34 -0700677}
678
Joe Perchesd311cd42014-08-06 16:10:57 -0700679sub git_commit_info {
680 my ($commit, $id, $desc) = @_;
681
682 return ($id, $desc) if ((which("git") eq "") || !(-e ".git"));
683
684 my $output = `git log --no-color --format='%H %s' -1 $commit 2>&1`;
685 $output =~ s/^\s*//gm;
686 my @lines = split("\n", $output);
687
Joe Perches0d7835f2015-02-13 14:38:35 -0800688 return ($id, $desc) if ($#lines < 0);
689
Joe Perchesd311cd42014-08-06 16:10:57 -0700690 if ($lines[0] =~ /^error: short SHA1 $commit is ambiguous\./) {
691# Maybe one day convert this block of bash into something that returns
692# all matching commit ids, but it's very slow...
693#
694# echo "checking commits $1..."
695# git rev-list --remotes | grep -i "^$1" |
696# while read line ; do
697# git log --format='%H %s' -1 $line |
698# echo "commit $(cut -c 1-12,41-)"
699# done
700 } elsif ($lines[0] =~ /^fatal: ambiguous argument '$commit': unknown revision or path not in the working tree\./) {
701 } else {
702 $id = substr($lines[0], 0, 12);
703 $desc = substr($lines[0], 41);
704 }
705
706 return ($id, $desc);
707}
708
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700709$chk_signoff = 0 if ($file);
710
Andy Whitcroft00df3442007-06-08 13:47:06 -0700711my @rawlines = ();
Andy Whitcroftc2fdda02008-02-08 04:20:54 -0800712my @lines = ();
Joe Perches3705ce52013-07-03 15:05:31 -0700713my @fixed = ();
Joe Perchesd752fcc2014-08-06 16:11:05 -0700714my @fixed_inserted = ();
715my @fixed_deleted = ();
Joe Perches194f66f2014-08-06 16:11:03 -0700716my $fixlinenr = -1;
717
Andy Whitcroftc2fdda02008-02-08 04:20:54 -0800718my $vname;
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700719for my $filename (@ARGV) {
Andy Whitcroft21caa132009-01-06 14:41:30 -0800720 my $FILE;
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700721 if ($file) {
Andy Whitcroft21caa132009-01-06 14:41:30 -0800722 open($FILE, '-|', "diff -u /dev/null $filename") ||
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700723 die "$P: $filename: diff failed - $!\n";
Andy Whitcroft21caa132009-01-06 14:41:30 -0800724 } elsif ($filename eq '-') {
725 open($FILE, '<&STDIN');
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700726 } else {
Andy Whitcroft21caa132009-01-06 14:41:30 -0800727 open($FILE, '<', "$filename") ||
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700728 die "$P: $filename: open failed - $!\n";
Andy Whitcroft0a920b52007-06-01 00:46:48 -0700729 }
Andy Whitcroftc2fdda02008-02-08 04:20:54 -0800730 if ($filename eq '-') {
731 $vname = 'Your patch';
732 } else {
733 $vname = $filename;
734 }
Andy Whitcroft21caa132009-01-06 14:41:30 -0800735 while (<$FILE>) {
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700736 chomp;
737 push(@rawlines, $_);
738 }
Andy Whitcroft21caa132009-01-06 14:41:30 -0800739 close($FILE);
Andy Whitcroftc2fdda02008-02-08 04:20:54 -0800740 if (!process($filename)) {
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700741 $exit = 1;
742 }
743 @rawlines = ();
Andy Whitcroft13214ad2008-02-08 04:22:03 -0800744 @lines = ();
Joe Perches3705ce52013-07-03 15:05:31 -0700745 @fixed = ();
Joe Perchesd752fcc2014-08-06 16:11:05 -0700746 @fixed_inserted = ();
747 @fixed_deleted = ();
Joe Perches194f66f2014-08-06 16:11:03 -0700748 $fixlinenr = -1;
Andy Whitcroft0a920b52007-06-01 00:46:48 -0700749}
750
751exit($exit);
752
753sub top_of_kernel_tree {
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700754 my ($root) = @_;
755
756 my @tree_check = (
757 "COPYING", "CREDITS", "Kbuild", "MAINTAINERS", "Makefile",
758 "README", "Documentation", "arch", "include", "drivers",
759 "fs", "init", "ipc", "kernel", "lib", "scripts",
760 );
761
762 foreach my $check (@tree_check) {
763 if (! -e $root . '/' . $check) {
764 return 0;
765 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -0700766 }
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700767 return 1;
Joe Perches8f26b832012-10-04 17:13:32 -0700768}
Andy Whitcroft0a920b52007-06-01 00:46:48 -0700769
Joe Perches20112472011-07-25 17:13:23 -0700770sub parse_email {
771 my ($formatted_email) = @_;
772
773 my $name = "";
774 my $address = "";
775 my $comment = "";
776
777 if ($formatted_email =~ /^(.*)<(\S+\@\S+)>(.*)$/) {
778 $name = $1;
779 $address = $2;
780 $comment = $3 if defined $3;
781 } elsif ($formatted_email =~ /^\s*<(\S+\@\S+)>(.*)$/) {
782 $address = $1;
783 $comment = $2 if defined $2;
784 } elsif ($formatted_email =~ /(\S+\@\S+)(.*)$/) {
785 $address = $1;
786 $comment = $2 if defined $2;
787 $formatted_email =~ s/$address.*$//;
788 $name = $formatted_email;
Joe Perches3705ce52013-07-03 15:05:31 -0700789 $name = trim($name);
Joe Perches20112472011-07-25 17:13:23 -0700790 $name =~ s/^\"|\"$//g;
791 # If there's a name left after stripping spaces and
792 # leading quotes, and the address doesn't have both
793 # leading and trailing angle brackets, the address
794 # is invalid. ie:
795 # "joe smith joe@smith.com" bad
796 # "joe smith <joe@smith.com" bad
797 if ($name ne "" && $address !~ /^<[^>]+>$/) {
798 $name = "";
799 $address = "";
800 $comment = "";
801 }
802 }
803
Joe Perches3705ce52013-07-03 15:05:31 -0700804 $name = trim($name);
Joe Perches20112472011-07-25 17:13:23 -0700805 $name =~ s/^\"|\"$//g;
Joe Perches3705ce52013-07-03 15:05:31 -0700806 $address = trim($address);
Joe Perches20112472011-07-25 17:13:23 -0700807 $address =~ s/^\<|\>$//g;
808
809 if ($name =~ /[^\w \-]/i) { ##has "must quote" chars
810 $name =~ s/(?<!\\)"/\\"/g; ##escape quotes
811 $name = "\"$name\"";
812 }
813
814 return ($name, $address, $comment);
815}
816
817sub format_email {
818 my ($name, $address) = @_;
819
820 my $formatted_email;
821
Joe Perches3705ce52013-07-03 15:05:31 -0700822 $name = trim($name);
Joe Perches20112472011-07-25 17:13:23 -0700823 $name =~ s/^\"|\"$//g;
Joe Perches3705ce52013-07-03 15:05:31 -0700824 $address = trim($address);
Joe Perches20112472011-07-25 17:13:23 -0700825
826 if ($name =~ /[^\w \-]/i) { ##has "must quote" chars
827 $name =~ s/(?<!\\)"/\\"/g; ##escape quotes
828 $name = "\"$name\"";
829 }
830
831 if ("$name" eq "") {
832 $formatted_email = "$address";
833 } else {
834 $formatted_email = "$name <$address>";
835 }
836
837 return $formatted_email;
838}
839
Joe Perchesd311cd42014-08-06 16:10:57 -0700840sub which {
Joe Perchesbd474ca2014-08-06 16:11:10 -0700841 my ($bin) = @_;
Joe Perchesd311cd42014-08-06 16:10:57 -0700842
Joe Perchesbd474ca2014-08-06 16:11:10 -0700843 foreach my $path (split(/:/, $ENV{PATH})) {
844 if (-e "$path/$bin") {
845 return "$path/$bin";
846 }
Joe Perchesd311cd42014-08-06 16:10:57 -0700847 }
Joe Perchesd311cd42014-08-06 16:10:57 -0700848
Joe Perchesbd474ca2014-08-06 16:11:10 -0700849 return "";
Joe Perchesd311cd42014-08-06 16:10:57 -0700850}
851
Joe Perches000d1cc12011-07-25 17:13:25 -0700852sub which_conf {
853 my ($conf) = @_;
854
855 foreach my $path (split(/:/, ".:$ENV{HOME}:.scripts")) {
856 if (-e "$path/$conf") {
857 return "$path/$conf";
858 }
859 }
860
861 return "";
862}
863
Andy Whitcroft0a920b52007-06-01 00:46:48 -0700864sub expand_tabs {
865 my ($str) = @_;
866
867 my $res = '';
868 my $n = 0;
869 for my $c (split(//, $str)) {
870 if ($c eq "\t") {
871 $res .= ' ';
872 $n++;
873 for (; ($n % 8) != 0; $n++) {
874 $res .= ' ';
875 }
876 next;
877 }
878 $res .= $c;
879 $n++;
880 }
881
882 return $res;
883}
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700884sub copy_spacing {
Andy Whitcroft773647a2008-03-28 14:15:58 -0700885 (my $res = shift) =~ tr/\t/ /c;
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700886 return $res;
887}
Andy Whitcroft0a920b52007-06-01 00:46:48 -0700888
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -0700889sub line_stats {
890 my ($line) = @_;
891
892 # Drop the diff line leader and expand tabs
893 $line =~ s/^.//;
894 $line = expand_tabs($line);
895
896 # Pick the indent from the front of the line.
897 my ($white) = ($line =~ /^(\s*)/);
898
899 return (length($line), length($white));
900}
901
Andy Whitcroft773647a2008-03-28 14:15:58 -0700902my $sanitise_quote = '';
903
904sub sanitise_line_reset {
905 my ($in_comment) = @_;
906
907 if ($in_comment) {
908 $sanitise_quote = '*/';
909 } else {
910 $sanitise_quote = '';
911 }
912}
Andy Whitcroft00df3442007-06-08 13:47:06 -0700913sub sanitise_line {
914 my ($line) = @_;
915
916 my $res = '';
917 my $l = '';
918
Andy Whitcroftc2fdda02008-02-08 04:20:54 -0800919 my $qlen = 0;
Andy Whitcroft773647a2008-03-28 14:15:58 -0700920 my $off = 0;
921 my $c;
Andy Whitcroft00df3442007-06-08 13:47:06 -0700922
Andy Whitcroft773647a2008-03-28 14:15:58 -0700923 # Always copy over the diff marker.
924 $res = substr($line, 0, 1);
925
926 for ($off = 1; $off < length($line); $off++) {
927 $c = substr($line, $off, 1);
928
929 # Comments we are wacking completly including the begin
930 # and end, all to $;.
931 if ($sanitise_quote eq '' && substr($line, $off, 2) eq '/*') {
932 $sanitise_quote = '*/';
933
934 substr($res, $off, 2, "$;$;");
935 $off++;
936 next;
Andy Whitcroftc2fdda02008-02-08 04:20:54 -0800937 }
Andy Whitcroft81bc0e02008-10-15 22:02:26 -0700938 if ($sanitise_quote eq '*/' && substr($line, $off, 2) eq '*/') {
Andy Whitcroft773647a2008-03-28 14:15:58 -0700939 $sanitise_quote = '';
940 substr($res, $off, 2, "$;$;");
941 $off++;
942 next;
943 }
Daniel Walker113f04a2009-09-21 17:04:35 -0700944 if ($sanitise_quote eq '' && substr($line, $off, 2) eq '//') {
945 $sanitise_quote = '//';
946
947 substr($res, $off, 2, $sanitise_quote);
948 $off++;
949 next;
950 }
Andy Whitcroft773647a2008-03-28 14:15:58 -0700951
952 # A \ in a string means ignore the next character.
953 if (($sanitise_quote eq "'" || $sanitise_quote eq '"') &&
954 $c eq "\\") {
955 substr($res, $off, 2, 'XX');
956 $off++;
957 next;
958 }
959 # Regular quotes.
960 if ($c eq "'" || $c eq '"') {
961 if ($sanitise_quote eq '') {
962 $sanitise_quote = $c;
963
964 substr($res, $off, 1, $c);
Andy Whitcroft00df3442007-06-08 13:47:06 -0700965 next;
Andy Whitcroft773647a2008-03-28 14:15:58 -0700966 } elsif ($sanitise_quote eq $c) {
967 $sanitise_quote = '';
Andy Whitcroft00df3442007-06-08 13:47:06 -0700968 }
969 }
Andy Whitcroft773647a2008-03-28 14:15:58 -0700970
Andy Whitcroftfae17da2009-01-06 14:41:20 -0800971 #print "c<$c> SQ<$sanitise_quote>\n";
Andy Whitcroft773647a2008-03-28 14:15:58 -0700972 if ($off != 0 && $sanitise_quote eq '*/' && $c ne "\t") {
973 substr($res, $off, 1, $;);
Daniel Walker113f04a2009-09-21 17:04:35 -0700974 } elsif ($off != 0 && $sanitise_quote eq '//' && $c ne "\t") {
975 substr($res, $off, 1, $;);
Andy Whitcroft773647a2008-03-28 14:15:58 -0700976 } elsif ($off != 0 && $sanitise_quote && $c ne "\t") {
977 substr($res, $off, 1, 'X');
Andy Whitcroft00df3442007-06-08 13:47:06 -0700978 } else {
Andy Whitcroft773647a2008-03-28 14:15:58 -0700979 substr($res, $off, 1, $c);
Andy Whitcroft00df3442007-06-08 13:47:06 -0700980 }
Andy Whitcroftc2fdda02008-02-08 04:20:54 -0800981 }
982
Daniel Walker113f04a2009-09-21 17:04:35 -0700983 if ($sanitise_quote eq '//') {
984 $sanitise_quote = '';
985 }
986
Andy Whitcroftc2fdda02008-02-08 04:20:54 -0800987 # The pathname on a #include may be surrounded by '<' and '>'.
Andy Whitcroftc45dcab2008-06-05 22:46:01 -0700988 if ($res =~ /^.\s*\#\s*include\s+\<(.*)\>/) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -0800989 my $clean = 'X' x length($1);
990 $res =~ s@\<.*\>@<$clean>@;
991
992 # The whole of a #error is a string.
Andy Whitcroftc45dcab2008-06-05 22:46:01 -0700993 } elsif ($res =~ /^.\s*\#\s*(?:error|warning)\s+(.*)\b/) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -0800994 my $clean = 'X' x length($1);
Andy Whitcroftc45dcab2008-06-05 22:46:01 -0700995 $res =~ s@(\#\s*(?:error|warning)\s+).*@$1$clean@;
Andy Whitcroftc2fdda02008-02-08 04:20:54 -0800996 }
997
Andy Whitcroft00df3442007-06-08 13:47:06 -0700998 return $res;
999}
1000
Joe Perchesa6962d72013-04-29 16:18:13 -07001001sub get_quoted_string {
1002 my ($line, $rawline) = @_;
1003
Joe Perches5e4f6ba2014-12-10 15:52:05 -08001004 return "" if ($line !~ m/(\"[X\t]+\")/g);
Joe Perchesa6962d72013-04-29 16:18:13 -07001005 return substr($rawline, $-[0], $+[0] - $-[0]);
1006}
1007
Andy Whitcroft8905a672007-11-28 16:21:06 -08001008sub ctx_statement_block {
1009 my ($linenr, $remain, $off) = @_;
1010 my $line = $linenr - 1;
1011 my $blk = '';
1012 my $soff = $off;
1013 my $coff = $off - 1;
Andy Whitcroft773647a2008-03-28 14:15:58 -07001014 my $coff_set = 0;
Andy Whitcroft8905a672007-11-28 16:21:06 -08001015
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001016 my $loff = 0;
1017
Andy Whitcroft8905a672007-11-28 16:21:06 -08001018 my $type = '';
1019 my $level = 0;
Andy Whitcrofta2750642009-01-15 13:51:04 -08001020 my @stack = ();
Andy Whitcroftcf655042008-03-04 14:28:20 -08001021 my $p;
Andy Whitcroft8905a672007-11-28 16:21:06 -08001022 my $c;
1023 my $len = 0;
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001024
1025 my $remainder;
Andy Whitcroft8905a672007-11-28 16:21:06 -08001026 while (1) {
Andy Whitcrofta2750642009-01-15 13:51:04 -08001027 @stack = (['', 0]) if ($#stack == -1);
1028
Andy Whitcroft773647a2008-03-28 14:15:58 -07001029 #warn "CSB: blk<$blk> remain<$remain>\n";
Andy Whitcroft8905a672007-11-28 16:21:06 -08001030 # If we are about to drop off the end, pull in more
1031 # context.
1032 if ($off >= $len) {
1033 for (; $remain > 0; $line++) {
Andy Whitcroftdea33492008-10-15 22:02:25 -07001034 last if (!defined $lines[$line]);
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001035 next if ($lines[$line] =~ /^-/);
Andy Whitcroft8905a672007-11-28 16:21:06 -08001036 $remain--;
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001037 $loff = $len;
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001038 $blk .= $lines[$line] . "\n";
Andy Whitcroft8905a672007-11-28 16:21:06 -08001039 $len = length($blk);
1040 $line++;
1041 last;
1042 }
1043 # Bail if there is no further context.
1044 #warn "CSB: blk<$blk> off<$off> len<$len>\n";
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001045 if ($off >= $len) {
Andy Whitcroft8905a672007-11-28 16:21:06 -08001046 last;
1047 }
Andy Whitcroftf74bd192012-01-10 15:09:54 -08001048 if ($level == 0 && substr($blk, $off) =~ /^.\s*#\s*define/) {
1049 $level++;
1050 $type = '#';
1051 }
Andy Whitcroft8905a672007-11-28 16:21:06 -08001052 }
Andy Whitcroftcf655042008-03-04 14:28:20 -08001053 $p = $c;
Andy Whitcroft8905a672007-11-28 16:21:06 -08001054 $c = substr($blk, $off, 1);
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001055 $remainder = substr($blk, $off);
Andy Whitcroft8905a672007-11-28 16:21:06 -08001056
Andy Whitcroft773647a2008-03-28 14:15:58 -07001057 #warn "CSB: c<$c> type<$type> level<$level> remainder<$remainder> coff_set<$coff_set>\n";
Andy Whitcroft4635f4f2009-01-06 14:41:27 -08001058
1059 # Handle nested #if/#else.
1060 if ($remainder =~ /^#\s*(?:ifndef|ifdef|if)\s/) {
1061 push(@stack, [ $type, $level ]);
1062 } elsif ($remainder =~ /^#\s*(?:else|elif)\b/) {
1063 ($type, $level) = @{$stack[$#stack - 1]};
1064 } elsif ($remainder =~ /^#\s*endif\b/) {
1065 ($type, $level) = @{pop(@stack)};
1066 }
1067
Andy Whitcroft8905a672007-11-28 16:21:06 -08001068 # Statement ends at the ';' or a close '}' at the
1069 # outermost level.
1070 if ($level == 0 && $c eq ';') {
1071 last;
1072 }
1073
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001074 # An else is really a conditional as long as its not else if
Andy Whitcroft773647a2008-03-28 14:15:58 -07001075 if ($level == 0 && $coff_set == 0 &&
1076 (!defined($p) || $p =~ /(?:\s|\}|\+)/) &&
1077 $remainder =~ /^(else)(?:\s|{)/ &&
1078 $remainder !~ /^else\s+if\b/) {
1079 $coff = $off + length($1) - 1;
1080 $coff_set = 1;
1081 #warn "CSB: mark coff<$coff> soff<$soff> 1<$1>\n";
1082 #warn "[" . substr($blk, $soff, $coff - $soff + 1) . "]\n";
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001083 }
1084
Andy Whitcroft8905a672007-11-28 16:21:06 -08001085 if (($type eq '' || $type eq '(') && $c eq '(') {
1086 $level++;
1087 $type = '(';
1088 }
1089 if ($type eq '(' && $c eq ')') {
1090 $level--;
1091 $type = ($level != 0)? '(' : '';
1092
1093 if ($level == 0 && $coff < $soff) {
1094 $coff = $off;
Andy Whitcroft773647a2008-03-28 14:15:58 -07001095 $coff_set = 1;
1096 #warn "CSB: mark coff<$coff>\n";
Andy Whitcroft8905a672007-11-28 16:21:06 -08001097 }
1098 }
1099 if (($type eq '' || $type eq '{') && $c eq '{') {
1100 $level++;
1101 $type = '{';
1102 }
1103 if ($type eq '{' && $c eq '}') {
1104 $level--;
1105 $type = ($level != 0)? '{' : '';
1106
1107 if ($level == 0) {
Patrick Pannutob998e002010-08-09 17:21:03 -07001108 if (substr($blk, $off + 1, 1) eq ';') {
1109 $off++;
1110 }
Andy Whitcroft8905a672007-11-28 16:21:06 -08001111 last;
1112 }
1113 }
Andy Whitcroftf74bd192012-01-10 15:09:54 -08001114 # Preprocessor commands end at the newline unless escaped.
1115 if ($type eq '#' && $c eq "\n" && $p ne "\\") {
1116 $level--;
1117 $type = '';
1118 $off++;
1119 last;
1120 }
Andy Whitcroft8905a672007-11-28 16:21:06 -08001121 $off++;
1122 }
Andy Whitcrofta3bb97a2008-07-23 21:29:00 -07001123 # We are truly at the end, so shuffle to the next line.
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001124 if ($off == $len) {
Andy Whitcrofta3bb97a2008-07-23 21:29:00 -07001125 $loff = $len + 1;
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001126 $line++;
1127 $remain--;
1128 }
Andy Whitcroft8905a672007-11-28 16:21:06 -08001129
1130 my $statement = substr($blk, $soff, $off - $soff + 1);
1131 my $condition = substr($blk, $soff, $coff - $soff + 1);
1132
1133 #warn "STATEMENT<$statement>\n";
1134 #warn "CONDITION<$condition>\n";
1135
Andy Whitcroft773647a2008-03-28 14:15:58 -07001136 #print "coff<$coff> soff<$off> loff<$loff>\n";
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001137
1138 return ($statement, $condition,
1139 $line, $remain + 1, $off - $loff + 1, $level);
1140}
1141
Andy Whitcroftcf655042008-03-04 14:28:20 -08001142sub statement_lines {
1143 my ($stmt) = @_;
1144
1145 # Strip the diff line prefixes and rip blank lines at start and end.
1146 $stmt =~ s/(^|\n)./$1/g;
1147 $stmt =~ s/^\s*//;
1148 $stmt =~ s/\s*$//;
1149
1150 my @stmt_lines = ($stmt =~ /\n/g);
1151
1152 return $#stmt_lines + 2;
1153}
1154
1155sub statement_rawlines {
1156 my ($stmt) = @_;
1157
1158 my @stmt_lines = ($stmt =~ /\n/g);
1159
1160 return $#stmt_lines + 2;
1161}
1162
1163sub statement_block_size {
1164 my ($stmt) = @_;
1165
1166 $stmt =~ s/(^|\n)./$1/g;
1167 $stmt =~ s/^\s*{//;
1168 $stmt =~ s/}\s*$//;
1169 $stmt =~ s/^\s*//;
1170 $stmt =~ s/\s*$//;
1171
1172 my @stmt_lines = ($stmt =~ /\n/g);
1173 my @stmt_statements = ($stmt =~ /;/g);
1174
1175 my $stmt_lines = $#stmt_lines + 2;
1176 my $stmt_statements = $#stmt_statements + 1;
1177
1178 if ($stmt_lines > $stmt_statements) {
1179 return $stmt_lines;
1180 } else {
1181 return $stmt_statements;
1182 }
1183}
1184
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001185sub ctx_statement_full {
1186 my ($linenr, $remain, $off) = @_;
1187 my ($statement, $condition, $level);
1188
1189 my (@chunks);
1190
Andy Whitcroftcf655042008-03-04 14:28:20 -08001191 # Grab the first conditional/block pair.
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001192 ($statement, $condition, $linenr, $remain, $off, $level) =
1193 ctx_statement_block($linenr, $remain, $off);
Andy Whitcroft773647a2008-03-28 14:15:58 -07001194 #print "F: c<$condition> s<$statement> remain<$remain>\n";
Andy Whitcroftcf655042008-03-04 14:28:20 -08001195 push(@chunks, [ $condition, $statement ]);
1196 if (!($remain > 0 && $condition =~ /^\s*(?:\n[+-])?\s*(?:if|else|do)\b/s)) {
1197 return ($level, $linenr, @chunks);
1198 }
1199
1200 # Pull in the following conditional/block pairs and see if they
1201 # could continue the statement.
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001202 for (;;) {
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001203 ($statement, $condition, $linenr, $remain, $off, $level) =
1204 ctx_statement_block($linenr, $remain, $off);
Andy Whitcroftcf655042008-03-04 14:28:20 -08001205 #print "C: c<$condition> s<$statement> remain<$remain>\n";
Andy Whitcroft773647a2008-03-28 14:15:58 -07001206 last if (!($remain > 0 && $condition =~ /^(?:\s*\n[+-])*\s*(?:else|do)\b/s));
Andy Whitcroftcf655042008-03-04 14:28:20 -08001207 #print "C: push\n";
1208 push(@chunks, [ $condition, $statement ]);
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001209 }
1210
1211 return ($level, $linenr, @chunks);
Andy Whitcroft8905a672007-11-28 16:21:06 -08001212}
1213
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001214sub ctx_block_get {
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001215 my ($linenr, $remain, $outer, $open, $close, $off) = @_;
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001216 my $line;
1217 my $start = $linenr - 1;
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001218 my $blk = '';
1219 my @o;
1220 my @c;
1221 my @res = ();
1222
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001223 my $level = 0;
Andy Whitcroft4635f4f2009-01-06 14:41:27 -08001224 my @stack = ($level);
Andy Whitcroft00df3442007-06-08 13:47:06 -07001225 for ($line = $start; $remain > 0; $line++) {
1226 next if ($rawlines[$line] =~ /^-/);
1227 $remain--;
1228
1229 $blk .= $rawlines[$line];
Andy Whitcroft4635f4f2009-01-06 14:41:27 -08001230
1231 # Handle nested #if/#else.
Andy Whitcroft01464f32010-10-26 14:23:19 -07001232 if ($lines[$line] =~ /^.\s*#\s*(?:ifndef|ifdef|if)\s/) {
Andy Whitcroft4635f4f2009-01-06 14:41:27 -08001233 push(@stack, $level);
Andy Whitcroft01464f32010-10-26 14:23:19 -07001234 } elsif ($lines[$line] =~ /^.\s*#\s*(?:else|elif)\b/) {
Andy Whitcroft4635f4f2009-01-06 14:41:27 -08001235 $level = $stack[$#stack - 1];
Andy Whitcroft01464f32010-10-26 14:23:19 -07001236 } elsif ($lines[$line] =~ /^.\s*#\s*endif\b/) {
Andy Whitcroft4635f4f2009-01-06 14:41:27 -08001237 $level = pop(@stack);
1238 }
1239
Andy Whitcroft01464f32010-10-26 14:23:19 -07001240 foreach my $c (split(//, $lines[$line])) {
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001241 ##print "C<$c>L<$level><$open$close>O<$off>\n";
1242 if ($off > 0) {
1243 $off--;
1244 next;
1245 }
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001246
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001247 if ($c eq $close && $level > 0) {
1248 $level--;
1249 last if ($level == 0);
1250 } elsif ($c eq $open) {
1251 $level++;
1252 }
1253 }
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001254
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001255 if (!$outer || $level <= 1) {
Andy Whitcroft00df3442007-06-08 13:47:06 -07001256 push(@res, $rawlines[$line]);
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001257 }
1258
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001259 last if ($level == 0);
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001260 }
1261
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001262 return ($level, @res);
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001263}
1264sub ctx_block_outer {
1265 my ($linenr, $remain) = @_;
1266
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001267 my ($level, @r) = ctx_block_get($linenr, $remain, 1, '{', '}', 0);
1268 return @r;
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001269}
1270sub ctx_block {
1271 my ($linenr, $remain) = @_;
1272
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001273 my ($level, @r) = ctx_block_get($linenr, $remain, 0, '{', '}', 0);
1274 return @r;
Andy Whitcroft653d4872007-06-23 17:16:34 -07001275}
1276sub ctx_statement {
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001277 my ($linenr, $remain, $off) = @_;
1278
1279 my ($level, @r) = ctx_block_get($linenr, $remain, 0, '(', ')', $off);
1280 return @r;
1281}
1282sub ctx_block_level {
Andy Whitcroft653d4872007-06-23 17:16:34 -07001283 my ($linenr, $remain) = @_;
1284
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001285 return ctx_block_get($linenr, $remain, 0, '{', '}', 0);
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001286}
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07001287sub ctx_statement_level {
1288 my ($linenr, $remain, $off) = @_;
1289
1290 return ctx_block_get($linenr, $remain, 0, '(', ')', $off);
1291}
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001292
1293sub ctx_locate_comment {
1294 my ($first_line, $end_line) = @_;
1295
1296 # Catch a comment on the end of the line itself.
Andy Whitcroftbeae6332008-07-23 21:28:59 -07001297 my ($current_comment) = ($rawlines[$end_line - 1] =~ m@.*(/\*.*\*/)\s*(?:\\\s*)?$@);
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001298 return $current_comment if (defined $current_comment);
1299
1300 # Look through the context and try and figure out if there is a
1301 # comment.
1302 my $in_comment = 0;
1303 $current_comment = '';
1304 for (my $linenr = $first_line; $linenr < $end_line; $linenr++) {
Andy Whitcroft00df3442007-06-08 13:47:06 -07001305 my $line = $rawlines[$linenr - 1];
1306 #warn " $line\n";
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001307 if ($linenr == $first_line and $line =~ m@^.\s*\*@) {
1308 $in_comment = 1;
1309 }
1310 if ($line =~ m@/\*@) {
1311 $in_comment = 1;
1312 }
1313 if (!$in_comment && $current_comment ne '') {
1314 $current_comment = '';
1315 }
1316 $current_comment .= $line . "\n" if ($in_comment);
1317 if ($line =~ m@\*/@) {
1318 $in_comment = 0;
1319 }
1320 }
1321
1322 chomp($current_comment);
1323 return($current_comment);
1324}
1325sub ctx_has_comment {
1326 my ($first_line, $end_line) = @_;
1327 my $cmt = ctx_locate_comment($first_line, $end_line);
1328
Andy Whitcroft00df3442007-06-08 13:47:06 -07001329 ##print "LINE: $rawlines[$end_line - 1 ]\n";
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001330 ##print "CMMT: $cmt\n";
1331
1332 return ($cmt ne '');
1333}
1334
Andy Whitcroft4d001e42008-10-15 22:02:21 -07001335sub raw_line {
1336 my ($linenr, $cnt) = @_;
1337
1338 my $offset = $linenr - 1;
1339 $cnt++;
1340
1341 my $line;
1342 while ($cnt) {
1343 $line = $rawlines[$offset++];
1344 next if (defined($line) && $line =~ /^-/);
1345 $cnt--;
1346 }
1347
1348 return $line;
1349}
1350
Andy Whitcroft0a920b52007-06-01 00:46:48 -07001351sub cat_vet {
1352 my ($vet) = @_;
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07001353 my ($res, $coded);
Andy Whitcroft0a920b52007-06-01 00:46:48 -07001354
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07001355 $res = '';
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001356 while ($vet =~ /([^[:cntrl:]]*)([[:cntrl:]]|$)/g) {
1357 $res .= $1;
1358 if ($2 ne '') {
1359 $coded = sprintf("^%c", unpack('C', $2) + 64);
1360 $res .= $coded;
1361 }
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07001362 }
1363 $res =~ s/$/\$/;
Andy Whitcroft0a920b52007-06-01 00:46:48 -07001364
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07001365 return $res;
Andy Whitcroft0a920b52007-06-01 00:46:48 -07001366}
1367
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001368my $av_preprocessor = 0;
Andy Whitcroftcf655042008-03-04 14:28:20 -08001369my $av_pending;
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001370my @av_paren_type;
Andy Whitcroft1f65f942008-07-23 21:29:10 -07001371my $av_pend_colon;
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001372
1373sub annotate_reset {
1374 $av_preprocessor = 0;
Andy Whitcroftcf655042008-03-04 14:28:20 -08001375 $av_pending = '_';
1376 @av_paren_type = ('E');
Andy Whitcroft1f65f942008-07-23 21:29:10 -07001377 $av_pend_colon = 'O';
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001378}
1379
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001380sub annotate_values {
1381 my ($stream, $type) = @_;
1382
1383 my $res;
Andy Whitcroft1f65f942008-07-23 21:29:10 -07001384 my $var = '_' x length($stream);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001385 my $cur = $stream;
1386
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001387 print "$stream\n" if ($dbg_values > 1);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001388
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001389 while (length($cur)) {
Andy Whitcroft773647a2008-03-28 14:15:58 -07001390 @av_paren_type = ('E') if ($#av_paren_type < 0);
Andy Whitcroftcf655042008-03-04 14:28:20 -08001391 print " <" . join('', @av_paren_type) .
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07001392 "> <$type> <$av_pending>" if ($dbg_values > 1);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001393 if ($cur =~ /^(\s+)/o) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001394 print "WS($1)\n" if ($dbg_values > 1);
1395 if ($1 =~ /\n/ && $av_preprocessor) {
Andy Whitcroftcf655042008-03-04 14:28:20 -08001396 $type = pop(@av_paren_type);
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001397 $av_preprocessor = 0;
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001398 }
1399
Florian Micklerc023e4732011-01-12 16:59:58 -08001400 } elsif ($cur =~ /^(\(\s*$Type\s*)\)/ && $av_pending eq '_') {
Andy Whitcroft9446ef52010-10-26 14:23:13 -07001401 print "CAST($1)\n" if ($dbg_values > 1);
1402 push(@av_paren_type, $type);
Andy Whitcroftaddcdce2012-01-10 15:10:11 -08001403 $type = 'c';
Andy Whitcroft9446ef52010-10-26 14:23:13 -07001404
Andy Whitcrofte91b6e22010-10-26 14:23:11 -07001405 } elsif ($cur =~ /^($Type)\s*(?:$Ident|,|\)|\(|\s*$)/) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001406 print "DECLARE($1)\n" if ($dbg_values > 1);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001407 $type = 'T';
1408
Andy Whitcroft389a2fe2008-07-23 21:29:05 -07001409 } elsif ($cur =~ /^($Modifier)\s*/) {
1410 print "MODIFIER($1)\n" if ($dbg_values > 1);
1411 $type = 'T';
1412
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07001413 } elsif ($cur =~ /^(\#\s*define\s*$Ident)(\(?)/o) {
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07001414 print "DEFINE($1,$2)\n" if ($dbg_values > 1);
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001415 $av_preprocessor = 1;
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07001416 push(@av_paren_type, $type);
1417 if ($2 ne '') {
1418 $av_pending = 'N';
1419 }
1420 $type = 'E';
1421
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07001422 } elsif ($cur =~ /^(\#\s*(?:undef\s*$Ident|include\b))/o) {
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07001423 print "UNDEF($1)\n" if ($dbg_values > 1);
1424 $av_preprocessor = 1;
1425 push(@av_paren_type, $type);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001426
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07001427 } elsif ($cur =~ /^(\#\s*(?:ifdef|ifndef|if))/o) {
Andy Whitcroftcf655042008-03-04 14:28:20 -08001428 print "PRE_START($1)\n" if ($dbg_values > 1);
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001429 $av_preprocessor = 1;
Andy Whitcroftcf655042008-03-04 14:28:20 -08001430
1431 push(@av_paren_type, $type);
1432 push(@av_paren_type, $type);
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07001433 $type = 'E';
Andy Whitcroftcf655042008-03-04 14:28:20 -08001434
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07001435 } elsif ($cur =~ /^(\#\s*(?:else|elif))/o) {
Andy Whitcroftcf655042008-03-04 14:28:20 -08001436 print "PRE_RESTART($1)\n" if ($dbg_values > 1);
1437 $av_preprocessor = 1;
1438
1439 push(@av_paren_type, $av_paren_type[$#av_paren_type]);
1440
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07001441 $type = 'E';
Andy Whitcroftcf655042008-03-04 14:28:20 -08001442
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07001443 } elsif ($cur =~ /^(\#\s*(?:endif))/o) {
Andy Whitcroftcf655042008-03-04 14:28:20 -08001444 print "PRE_END($1)\n" if ($dbg_values > 1);
1445
1446 $av_preprocessor = 1;
1447
1448 # Assume all arms of the conditional end as this
1449 # one does, and continue as if the #endif was not here.
1450 pop(@av_paren_type);
1451 push(@av_paren_type, $type);
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07001452 $type = 'E';
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001453
1454 } elsif ($cur =~ /^(\\\n)/o) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001455 print "PRECONT($1)\n" if ($dbg_values > 1);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001456
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07001457 } elsif ($cur =~ /^(__attribute__)\s*\(?/o) {
1458 print "ATTR($1)\n" if ($dbg_values > 1);
1459 $av_pending = $type;
1460 $type = 'N';
1461
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001462 } elsif ($cur =~ /^(sizeof)\s*(\()?/o) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001463 print "SIZEOF($1)\n" if ($dbg_values > 1);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001464 if (defined $2) {
Andy Whitcroftcf655042008-03-04 14:28:20 -08001465 $av_pending = 'V';
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001466 }
1467 $type = 'N';
1468
Andy Whitcroft14b111c2008-10-15 22:02:16 -07001469 } elsif ($cur =~ /^(if|while|for)\b/o) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001470 print "COND($1)\n" if ($dbg_values > 1);
Andy Whitcroft14b111c2008-10-15 22:02:16 -07001471 $av_pending = 'E';
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001472 $type = 'N';
1473
Andy Whitcroft1f65f942008-07-23 21:29:10 -07001474 } elsif ($cur =~/^(case)/o) {
1475 print "CASE($1)\n" if ($dbg_values > 1);
1476 $av_pend_colon = 'C';
1477 $type = 'N';
1478
Andy Whitcroft14b111c2008-10-15 22:02:16 -07001479 } elsif ($cur =~/^(return|else|goto|typeof|__typeof__)\b/o) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001480 print "KEYWORD($1)\n" if ($dbg_values > 1);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001481 $type = 'N';
1482
1483 } elsif ($cur =~ /^(\()/o) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001484 print "PAREN('$1')\n" if ($dbg_values > 1);
Andy Whitcroftcf655042008-03-04 14:28:20 -08001485 push(@av_paren_type, $av_pending);
1486 $av_pending = '_';
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001487 $type = 'N';
1488
1489 } elsif ($cur =~ /^(\))/o) {
Andy Whitcroftcf655042008-03-04 14:28:20 -08001490 my $new_type = pop(@av_paren_type);
1491 if ($new_type ne '_') {
1492 $type = $new_type;
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001493 print "PAREN('$1') -> $type\n"
1494 if ($dbg_values > 1);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001495 } else {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001496 print "PAREN('$1')\n" if ($dbg_values > 1);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001497 }
1498
Andy Whitcroftc8cb2ca2008-07-23 21:28:57 -07001499 } elsif ($cur =~ /^($Ident)\s*\(/o) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001500 print "FUNC($1)\n" if ($dbg_values > 1);
Andy Whitcroftc8cb2ca2008-07-23 21:28:57 -07001501 $type = 'V';
Andy Whitcroftcf655042008-03-04 14:28:20 -08001502 $av_pending = 'V';
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001503
Andy Whitcroft8e761b02009-01-06 14:41:19 -08001504 } elsif ($cur =~ /^($Ident\s*):(?:\s*\d+\s*(,|=|;))?/) {
1505 if (defined $2 && $type eq 'C' || $type eq 'T') {
Andy Whitcroft1f65f942008-07-23 21:29:10 -07001506 $av_pend_colon = 'B';
Andy Whitcroft8e761b02009-01-06 14:41:19 -08001507 } elsif ($type eq 'E') {
1508 $av_pend_colon = 'L';
Andy Whitcroft1f65f942008-07-23 21:29:10 -07001509 }
1510 print "IDENT_COLON($1,$type>$av_pend_colon)\n" if ($dbg_values > 1);
1511 $type = 'V';
1512
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001513 } elsif ($cur =~ /^($Ident|$Constant)/o) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001514 print "IDENT($1)\n" if ($dbg_values > 1);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001515 $type = 'V';
1516
1517 } elsif ($cur =~ /^($Assignment)/o) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001518 print "ASSIGN($1)\n" if ($dbg_values > 1);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001519 $type = 'N';
1520
Andy Whitcroftcf655042008-03-04 14:28:20 -08001521 } elsif ($cur =~/^(;|{|})/) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001522 print "END($1)\n" if ($dbg_values > 1);
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001523 $type = 'E';
Andy Whitcroft1f65f942008-07-23 21:29:10 -07001524 $av_pend_colon = 'O';
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001525
Andy Whitcroft8e761b02009-01-06 14:41:19 -08001526 } elsif ($cur =~/^(,)/) {
1527 print "COMMA($1)\n" if ($dbg_values > 1);
1528 $type = 'C';
1529
Andy Whitcroft1f65f942008-07-23 21:29:10 -07001530 } elsif ($cur =~ /^(\?)/o) {
1531 print "QUESTION($1)\n" if ($dbg_values > 1);
1532 $type = 'N';
1533
1534 } elsif ($cur =~ /^(:)/o) {
1535 print "COLON($1,$av_pend_colon)\n" if ($dbg_values > 1);
1536
1537 substr($var, length($res), 1, $av_pend_colon);
1538 if ($av_pend_colon eq 'C' || $av_pend_colon eq 'L') {
1539 $type = 'E';
1540 } else {
1541 $type = 'N';
1542 }
1543 $av_pend_colon = 'O';
1544
Andy Whitcroft8e761b02009-01-06 14:41:19 -08001545 } elsif ($cur =~ /^(\[)/o) {
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001546 print "CLOSE($1)\n" if ($dbg_values > 1);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001547 $type = 'N';
1548
Andy Whitcroft0d413862008-10-15 22:02:16 -07001549 } elsif ($cur =~ /^(-(?![->])|\+(?!\+)|\*|\&\&|\&)/o) {
Andy Whitcroft74048ed2008-07-23 21:29:10 -07001550 my $variant;
1551
1552 print "OPV($1)\n" if ($dbg_values > 1);
1553 if ($type eq 'V') {
1554 $variant = 'B';
1555 } else {
1556 $variant = 'U';
1557 }
1558
1559 substr($var, length($res), 1, $variant);
1560 $type = 'N';
1561
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001562 } elsif ($cur =~ /^($Operators)/o) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001563 print "OP($1)\n" if ($dbg_values > 1);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001564 if ($1 ne '++' && $1 ne '--') {
1565 $type = 'N';
1566 }
1567
1568 } elsif ($cur =~ /(^.)/o) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001569 print "C($1)\n" if ($dbg_values > 1);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001570 }
1571 if (defined $1) {
1572 $cur = substr($cur, length($1));
1573 $res .= $type x length($1);
1574 }
1575 }
1576
Andy Whitcroft1f65f942008-07-23 21:29:10 -07001577 return ($res, $var);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001578}
1579
Andy Whitcroft8905a672007-11-28 16:21:06 -08001580sub possible {
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001581 my ($possible, $line) = @_;
Andy Whitcroft9a974fd2009-10-26 16:50:12 -07001582 my $notPermitted = qr{(?:
Andy Whitcroft0776e592008-10-15 22:02:29 -07001583 ^(?:
1584 $Modifier|
1585 $Storage|
1586 $Type|
Andy Whitcroft9a974fd2009-10-26 16:50:12 -07001587 DEFINE_\S+
1588 )$|
1589 ^(?:
Andy Whitcroft0776e592008-10-15 22:02:29 -07001590 goto|
1591 return|
1592 case|
1593 else|
1594 asm|__asm__|
Andy Whitcroft89a88352012-01-10 15:10:00 -08001595 do|
1596 \#|
1597 \#\#|
Andy Whitcroft9a974fd2009-10-26 16:50:12 -07001598 )(?:\s|$)|
Andy Whitcroft0776e592008-10-15 22:02:29 -07001599 ^(?:typedef|struct|enum)\b
Andy Whitcroft9a974fd2009-10-26 16:50:12 -07001600 )}x;
1601 warn "CHECK<$possible> ($line)\n" if ($dbg_possible > 2);
1602 if ($possible !~ $notPermitted) {
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07001603 # Check for modifiers.
1604 $possible =~ s/\s*$Storage\s*//g;
1605 $possible =~ s/\s*$Sparse\s*//g;
1606 if ($possible =~ /^\s*$/) {
1607
1608 } elsif ($possible =~ /\s/) {
1609 $possible =~ s/\s*$Type\s*//g;
Andy Whitcroftd2506582008-07-23 21:29:09 -07001610 for my $modifier (split(' ', $possible)) {
Andy Whitcroft9a974fd2009-10-26 16:50:12 -07001611 if ($modifier !~ $notPermitted) {
1612 warn "MODIFIER: $modifier ($possible) ($line)\n" if ($dbg_possible);
1613 push(@modifierList, $modifier);
1614 }
Andy Whitcroftd2506582008-07-23 21:29:09 -07001615 }
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07001616
1617 } else {
1618 warn "POSSIBLE: $possible ($line)\n" if ($dbg_possible);
1619 push(@typeList, $possible);
1620 }
Andy Whitcroft8905a672007-11-28 16:21:06 -08001621 build_types();
Andy Whitcroft0776e592008-10-15 22:02:29 -07001622 } else {
1623 warn "NOTPOSS: $possible ($line)\n" if ($dbg_possible > 1);
Andy Whitcroft8905a672007-11-28 16:21:06 -08001624 }
1625}
1626
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001627my $prefix = '';
1628
Joe Perches000d1cc12011-07-25 17:13:25 -07001629sub show_type {
Joe Perchescbec18a2014-04-03 14:49:19 -07001630 my ($type) = @_;
Joe Perches91bfe482013-09-11 14:23:59 -07001631
Joe Perchescbec18a2014-04-03 14:49:19 -07001632 return defined $use_type{$type} if (scalar keys %use_type > 0);
1633
1634 return !defined $ignore_type{$type};
Joe Perches000d1cc12011-07-25 17:13:25 -07001635}
1636
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001637sub report {
Joe Perchescbec18a2014-04-03 14:49:19 -07001638 my ($level, $type, $msg) = @_;
1639
1640 if (!show_type($type) ||
1641 (defined $tst_only && $msg !~ /\Q$tst_only\E/)) {
Andy Whitcroft773647a2008-03-28 14:15:58 -07001642 return 0;
1643 }
Joe Perches000d1cc12011-07-25 17:13:25 -07001644 my $line;
1645 if ($show_types) {
Joe Perchescbec18a2014-04-03 14:49:19 -07001646 $line = "$prefix$level:$type: $msg\n";
Joe Perches000d1cc12011-07-25 17:13:25 -07001647 } else {
Joe Perchescbec18a2014-04-03 14:49:19 -07001648 $line = "$prefix$level: $msg\n";
Joe Perches000d1cc12011-07-25 17:13:25 -07001649 }
Andy Whitcroft8905a672007-11-28 16:21:06 -08001650 $line = (split('\n', $line))[0] . "\n" if ($terse);
1651
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001652 push(our @report, $line);
Andy Whitcroft773647a2008-03-28 14:15:58 -07001653
1654 return 1;
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001655}
Joe Perchescbec18a2014-04-03 14:49:19 -07001656
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001657sub report_dump {
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001658 our @report;
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001659}
Joe Perches000d1cc12011-07-25 17:13:25 -07001660
Joe Perchesd752fcc2014-08-06 16:11:05 -07001661sub fixup_current_range {
1662 my ($lineRef, $offset, $length) = @_;
1663
1664 if ($$lineRef =~ /^\@\@ -\d+,\d+ \+(\d+),(\d+) \@\@/) {
1665 my $o = $1;
1666 my $l = $2;
1667 my $no = $o + $offset;
1668 my $nl = $l + $length;
1669 $$lineRef =~ s/\+$o,$l \@\@/\+$no,$nl \@\@/;
1670 }
1671}
1672
1673sub fix_inserted_deleted_lines {
1674 my ($linesRef, $insertedRef, $deletedRef) = @_;
1675
1676 my $range_last_linenr = 0;
1677 my $delta_offset = 0;
1678
1679 my $old_linenr = 0;
1680 my $new_linenr = 0;
1681
1682 my $next_insert = 0;
1683 my $next_delete = 0;
1684
1685 my @lines = ();
1686
1687 my $inserted = @{$insertedRef}[$next_insert++];
1688 my $deleted = @{$deletedRef}[$next_delete++];
1689
1690 foreach my $old_line (@{$linesRef}) {
1691 my $save_line = 1;
1692 my $line = $old_line; #don't modify the array
Joe Perches323b2672015-04-16 12:44:50 -07001693 if ($line =~ /^(?:\+\+\+|\-\-\-)\s+\S+/) { #new filename
Joe Perchesd752fcc2014-08-06 16:11:05 -07001694 $delta_offset = 0;
1695 } elsif ($line =~ /^\@\@ -\d+,\d+ \+\d+,\d+ \@\@/) { #new hunk
1696 $range_last_linenr = $new_linenr;
1697 fixup_current_range(\$line, $delta_offset, 0);
1698 }
1699
1700 while (defined($deleted) && ${$deleted}{'LINENR'} == $old_linenr) {
1701 $deleted = @{$deletedRef}[$next_delete++];
1702 $save_line = 0;
1703 fixup_current_range(\$lines[$range_last_linenr], $delta_offset--, -1);
1704 }
1705
1706 while (defined($inserted) && ${$inserted}{'LINENR'} == $old_linenr) {
1707 push(@lines, ${$inserted}{'LINE'});
1708 $inserted = @{$insertedRef}[$next_insert++];
1709 $new_linenr++;
1710 fixup_current_range(\$lines[$range_last_linenr], $delta_offset++, 1);
1711 }
1712
1713 if ($save_line) {
1714 push(@lines, $line);
1715 $new_linenr++;
1716 }
1717
1718 $old_linenr++;
1719 }
1720
1721 return @lines;
1722}
1723
Joe Perchesf2d7e4d2014-08-06 16:11:07 -07001724sub fix_insert_line {
1725 my ($linenr, $line) = @_;
1726
1727 my $inserted = {
1728 LINENR => $linenr,
1729 LINE => $line,
1730 };
1731 push(@fixed_inserted, $inserted);
1732}
1733
1734sub fix_delete_line {
1735 my ($linenr, $line) = @_;
1736
1737 my $deleted = {
1738 LINENR => $linenr,
1739 LINE => $line,
1740 };
1741
1742 push(@fixed_deleted, $deleted);
1743}
1744
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07001745sub ERROR {
Joe Perchescbec18a2014-04-03 14:49:19 -07001746 my ($type, $msg) = @_;
1747
1748 if (report("ERROR", $type, $msg)) {
Andy Whitcroft773647a2008-03-28 14:15:58 -07001749 our $clean = 0;
1750 our $cnt_error++;
Joe Perches3705ce52013-07-03 15:05:31 -07001751 return 1;
Andy Whitcroft773647a2008-03-28 14:15:58 -07001752 }
Joe Perches3705ce52013-07-03 15:05:31 -07001753 return 0;
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07001754}
1755sub WARN {
Joe Perchescbec18a2014-04-03 14:49:19 -07001756 my ($type, $msg) = @_;
1757
1758 if (report("WARNING", $type, $msg)) {
Andy Whitcroft773647a2008-03-28 14:15:58 -07001759 our $clean = 0;
1760 our $cnt_warn++;
Joe Perches3705ce52013-07-03 15:05:31 -07001761 return 1;
Andy Whitcroft773647a2008-03-28 14:15:58 -07001762 }
Joe Perches3705ce52013-07-03 15:05:31 -07001763 return 0;
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07001764}
1765sub CHK {
Joe Perchescbec18a2014-04-03 14:49:19 -07001766 my ($type, $msg) = @_;
1767
1768 if ($check && report("CHECK", $type, $msg)) {
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001769 our $clean = 0;
1770 our $cnt_chk++;
Joe Perches3705ce52013-07-03 15:05:31 -07001771 return 1;
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001772 }
Joe Perches3705ce52013-07-03 15:05:31 -07001773 return 0;
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07001774}
1775
Andy Whitcroft6ecd9672008-10-15 22:02:21 -07001776sub check_absolute_file {
1777 my ($absolute, $herecurr) = @_;
1778 my $file = $absolute;
1779
1780 ##print "absolute<$absolute>\n";
1781
1782 # See if any suffix of this path is a path within the tree.
1783 while ($file =~ s@^[^/]*/@@) {
1784 if (-f "$root/$file") {
1785 ##print "file<$file>\n";
1786 last;
1787 }
1788 }
1789 if (! -f _) {
1790 return 0;
1791 }
1792
1793 # It is, so see if the prefix is acceptable.
1794 my $prefix = $absolute;
1795 substr($prefix, -length($file)) = '';
1796
1797 ##print "prefix<$prefix>\n";
1798 if ($prefix ne ".../") {
Joe Perches000d1cc12011-07-25 17:13:25 -07001799 WARN("USE_RELATIVE_PATH",
1800 "use relative pathname instead of absolute in changelog text\n" . $herecurr);
Andy Whitcroft6ecd9672008-10-15 22:02:21 -07001801 }
1802}
1803
Joe Perches3705ce52013-07-03 15:05:31 -07001804sub trim {
1805 my ($string) = @_;
1806
Joe Perchesb34c6482013-09-11 14:24:01 -07001807 $string =~ s/^\s+|\s+$//g;
1808
1809 return $string;
1810}
1811
1812sub ltrim {
1813 my ($string) = @_;
1814
1815 $string =~ s/^\s+//;
1816
1817 return $string;
1818}
1819
1820sub rtrim {
1821 my ($string) = @_;
1822
1823 $string =~ s/\s+$//;
Joe Perches3705ce52013-07-03 15:05:31 -07001824
1825 return $string;
1826}
1827
Joe Perches52ea8502013-11-12 15:10:09 -08001828sub string_find_replace {
1829 my ($string, $find, $replace) = @_;
1830
1831 $string =~ s/$find/$replace/g;
1832
1833 return $string;
1834}
1835
Joe Perches3705ce52013-07-03 15:05:31 -07001836sub tabify {
1837 my ($leading) = @_;
1838
1839 my $source_indent = 8;
1840 my $max_spaces_before_tab = $source_indent - 1;
1841 my $spaces_to_tab = " " x $source_indent;
1842
1843 #convert leading spaces to tabs
1844 1 while $leading =~ s@^([\t]*)$spaces_to_tab@$1\t@g;
1845 #Remove spaces before a tab
1846 1 while $leading =~ s@^([\t]*)( {1,$max_spaces_before_tab})\t@$1\t@g;
1847
1848 return "$leading";
1849}
1850
Joe Perchesd1fe9c02012-03-23 15:02:16 -07001851sub pos_last_openparen {
1852 my ($line) = @_;
1853
1854 my $pos = 0;
1855
1856 my $opens = $line =~ tr/\(/\(/;
1857 my $closes = $line =~ tr/\)/\)/;
1858
1859 my $last_openparen = 0;
1860
1861 if (($opens == 0) || ($closes >= $opens)) {
1862 return -1;
1863 }
1864
1865 my $len = length($line);
1866
1867 for ($pos = 0; $pos < $len; $pos++) {
1868 my $string = substr($line, $pos);
1869 if ($string =~ /^($FuncArg|$balanced_parens)/) {
1870 $pos += length($1) - 1;
1871 } elsif (substr($line, $pos, 1) eq '(') {
1872 $last_openparen = $pos;
1873 } elsif (index($string, '(') == -1) {
1874 last;
1875 }
1876 }
1877
Joe Perches91cb5192014-04-03 14:49:32 -07001878 return length(expand_tabs(substr($line, 0, $last_openparen))) + 1;
Joe Perchesd1fe9c02012-03-23 15:02:16 -07001879}
1880
Andy Whitcroft0a920b52007-06-01 00:46:48 -07001881sub process {
1882 my $filename = shift;
Andy Whitcroft0a920b52007-06-01 00:46:48 -07001883
1884 my $linenr=0;
1885 my $prevline="";
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001886 my $prevrawline="";
Andy Whitcroft0a920b52007-06-01 00:46:48 -07001887 my $stashline="";
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001888 my $stashrawline="";
Andy Whitcroft0a920b52007-06-01 00:46:48 -07001889
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001890 my $length;
Andy Whitcroft0a920b52007-06-01 00:46:48 -07001891 my $indent;
1892 my $previndent=0;
1893 my $stashindent=0;
1894
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07001895 our $clean = 1;
Andy Whitcroft0a920b52007-06-01 00:46:48 -07001896 my $signoff = 0;
1897 my $is_patch = 0;
1898
Joe Perches29ee1b02014-08-06 16:10:35 -07001899 my $in_header_lines = $file ? 0 : 1;
Joe Perches15662b32011-10-31 17:13:12 -07001900 my $in_commit_log = 0; #Scanning lines before patch
Joe Perches2a076f42015-04-16 12:44:28 -07001901 my $commit_log_long_line = 0;
Joe Perches13f19372014-08-06 16:10:59 -07001902 my $reported_maintainer_file = 0;
Pasi Savanainenfa64205d2012-10-04 17:13:29 -07001903 my $non_utf8_charset = 0;
1904
Joe Perches365dd4e2014-08-06 16:10:42 -07001905 my $last_blank_line = 0;
Joe Perches5e4f6ba2014-12-10 15:52:05 -08001906 my $last_coalesced_string_linenr = -1;
Joe Perches365dd4e2014-08-06 16:10:42 -07001907
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001908 our @report = ();
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001909 our $cnt_lines = 0;
1910 our $cnt_error = 0;
1911 our $cnt_warn = 0;
1912 our $cnt_chk = 0;
1913
Andy Whitcroft0a920b52007-06-01 00:46:48 -07001914 # Trace the real file/line as we go.
1915 my $realfile = '';
1916 my $realline = 0;
1917 my $realcnt = 0;
1918 my $here = '';
1919 my $in_comment = 0;
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001920 my $comment_edge = 0;
Andy Whitcroft0a920b52007-06-01 00:46:48 -07001921 my $first_line = 0;
Wolfram Sang1e855722009-01-06 14:41:24 -08001922 my $p1_prefix = '';
Andy Whitcroft0a920b52007-06-01 00:46:48 -07001923
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001924 my $prev_values = 'E';
1925
1926 # suppression flags
Andy Whitcroft773647a2008-03-28 14:15:58 -07001927 my %suppress_ifbraces;
Andy Whitcroft170d3a22008-10-15 22:02:30 -07001928 my %suppress_whiletrailers;
Andy Whitcroft2b474a12009-10-26 16:50:16 -07001929 my %suppress_export;
Andy Whitcroft3e469cd2012-01-10 15:10:01 -08001930 my $suppress_statement = 0;
Andy Whitcroft653d4872007-06-23 17:16:34 -07001931
Joe Perches7e51f192013-09-11 14:23:57 -07001932 my %signatures = ();
Joe Perches323c1262012-12-17 16:02:07 -08001933
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001934 # Pre-scan the patch sanitizing the lines.
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07001935 # Pre-scan the patch looking for any __setup documentation.
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001936 #
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07001937 my @setup_docs = ();
1938 my $setup_docs = 0;
Andy Whitcroft773647a2008-03-28 14:15:58 -07001939
Joe Perchesd8b07712013-11-12 15:10:06 -08001940 my $camelcase_file_seeded = 0;
1941
Andy Whitcroft773647a2008-03-28 14:15:58 -07001942 sanitise_line_reset();
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001943 my $line;
1944 foreach my $rawline (@rawlines) {
Andy Whitcroft773647a2008-03-28 14:15:58 -07001945 $linenr++;
1946 $line = $rawline;
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001947
Joe Perches3705ce52013-07-03 15:05:31 -07001948 push(@fixed, $rawline) if ($fix);
1949
Andy Whitcroft773647a2008-03-28 14:15:58 -07001950 if ($rawline=~/^\+\+\+\s+(\S+)/) {
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07001951 $setup_docs = 0;
1952 if ($1 =~ m@Documentation/kernel-parameters.txt$@) {
1953 $setup_docs = 1;
1954 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07001955 #next;
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07001956 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07001957 if ($rawline=~/^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@/) {
1958 $realline=$1-1;
1959 if (defined $2) {
1960 $realcnt=$3+1;
1961 } else {
1962 $realcnt=1+1;
1963 }
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07001964 $in_comment = 0;
Andy Whitcroft773647a2008-03-28 14:15:58 -07001965
1966 # Guestimate if this is a continuing comment. Run
1967 # the context looking for a comment "edge". If this
1968 # edge is a close comment then we must be in a comment
1969 # at context start.
1970 my $edge;
Andy Whitcroft01fa9142008-10-15 22:02:19 -07001971 my $cnt = $realcnt;
1972 for (my $ln = $linenr + 1; $cnt > 0; $ln++) {
1973 next if (defined $rawlines[$ln - 1] &&
1974 $rawlines[$ln - 1] =~ /^-/);
1975 $cnt--;
1976 #print "RAW<$rawlines[$ln - 1]>\n";
Andy Whitcroft721c1cb2009-01-06 14:41:16 -08001977 last if (!defined $rawlines[$ln - 1]);
Andy Whitcroftfae17da2009-01-06 14:41:20 -08001978 if ($rawlines[$ln - 1] =~ m@(/\*|\*/)@ &&
1979 $rawlines[$ln - 1] !~ m@"[^"]*(?:/\*|\*/)[^"]*"@) {
1980 ($edge) = $1;
1981 last;
1982 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07001983 }
1984 if (defined $edge && $edge eq '*/') {
1985 $in_comment = 1;
1986 }
1987
1988 # Guestimate if this is a continuing comment. If this
1989 # is the start of a diff block and this line starts
1990 # ' *' then it is very likely a comment.
1991 if (!defined $edge &&
Andy Whitcroft83242e02009-01-06 14:41:17 -08001992 $rawlines[$linenr] =~ m@^.\s*(?:\*\*+| \*)(?:\s|$)@)
Andy Whitcroft773647a2008-03-28 14:15:58 -07001993 {
1994 $in_comment = 1;
1995 }
1996
1997 ##print "COMMENT:$in_comment edge<$edge> $rawline\n";
1998 sanitise_line_reset($in_comment);
1999
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07002000 } elsif ($realcnt && $rawline =~ /^(?:\+| |$)/) {
Andy Whitcroft773647a2008-03-28 14:15:58 -07002001 # Standardise the strings and chars within the input to
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07002002 # simplify matching -- only bother with positive lines.
Andy Whitcroft773647a2008-03-28 14:15:58 -07002003 $line = sanitise_line($rawline);
2004 }
2005 push(@lines, $line);
2006
2007 if ($realcnt > 1) {
2008 $realcnt-- if ($line =~ /^(?:\+| |$)/);
2009 } else {
2010 $realcnt = 0;
2011 }
2012
2013 #print "==>$rawline\n";
2014 #print "-->$line\n";
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07002015
2016 if ($setup_docs && $line =~ /^\+/) {
2017 push(@setup_docs, $line);
2018 }
2019 }
2020
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07002021 $prefix = '';
2022
Andy Whitcroft773647a2008-03-28 14:15:58 -07002023 $realcnt = 0;
2024 $linenr = 0;
Joe Perches194f66f2014-08-06 16:11:03 -07002025 $fixlinenr = -1;
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002026 foreach my $line (@lines) {
2027 $linenr++;
Joe Perches194f66f2014-08-06 16:11:03 -07002028 $fixlinenr++;
Joe Perches1b5539b2013-09-11 14:24:03 -07002029 my $sline = $line; #copy of $line
2030 $sline =~ s/$;/ /g; #with comments as spaces
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002031
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002032 my $rawline = $rawlines[$linenr - 1];
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07002033
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002034#extract the line range in the file after the patch is applied
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07002035 if ($line=~/^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@/) {
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002036 $is_patch = 1;
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07002037 $first_line = $linenr + 1;
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002038 $realline=$1-1;
2039 if (defined $2) {
2040 $realcnt=$3+1;
2041 } else {
2042 $realcnt=1+1;
2043 }
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002044 annotate_reset();
Andy Whitcroft13214ad2008-02-08 04:22:03 -08002045 $prev_values = 'E';
2046
Andy Whitcroft773647a2008-03-28 14:15:58 -07002047 %suppress_ifbraces = ();
Andy Whitcroft170d3a22008-10-15 22:02:30 -07002048 %suppress_whiletrailers = ();
Andy Whitcroft2b474a12009-10-26 16:50:16 -07002049 %suppress_export = ();
Andy Whitcroft3e469cd2012-01-10 15:10:01 -08002050 $suppress_statement = 0;
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002051 next;
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002052
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07002053# track the line number as we move through the hunk, note that
2054# new versions of GNU diff omit the leading space on completely
2055# blank context lines so we need to count that too.
Andy Whitcroft773647a2008-03-28 14:15:58 -07002056 } elsif ($line =~ /^( |\+|$)/) {
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002057 $realline++;
Andy Whitcroftd8aaf122007-06-23 17:16:44 -07002058 $realcnt-- if ($realcnt != 0);
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002059
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07002060 # Measure the line length and indent.
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002061 ($length, $indent) = line_stats($rawline);
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002062
2063 # Track the previous line.
2064 ($prevline, $stashline) = ($stashline, $line);
2065 ($previndent, $stashindent) = ($stashindent, $indent);
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002066 ($prevrawline, $stashrawline) = ($stashrawline, $rawline);
2067
Andy Whitcroft773647a2008-03-28 14:15:58 -07002068 #warn "line<$line>\n";
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07002069
Andy Whitcroftd8aaf122007-06-23 17:16:44 -07002070 } elsif ($realcnt == 1) {
2071 $realcnt--;
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002072 }
2073
Andy Whitcroftcc77cdc2009-10-26 16:50:13 -07002074 my $hunk_line = ($realcnt != 0);
2075
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002076#make up the handle for any error we report on this line
Andy Whitcroft773647a2008-03-28 14:15:58 -07002077 $prefix = "$filename:$realline: " if ($emacs && $file);
2078 $prefix = "$filename:$linenr: " if ($emacs && !$file);
2079
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07002080 $here = "#$linenr: " if (!$file);
2081 $here = "#$realline: " if ($file);
Andy Whitcroft773647a2008-03-28 14:15:58 -07002082
Joe Perches2ac73b4f2014-06-04 16:12:05 -07002083 my $found_file = 0;
Andy Whitcroft773647a2008-03-28 14:15:58 -07002084 # extract the filename as it passes
Rabin Vincent3bf9a002010-10-26 14:23:16 -07002085 if ($line =~ /^diff --git.*?(\S+)$/) {
2086 $realfile = $1;
Joe Perches2b7ab452013-11-12 15:10:14 -08002087 $realfile =~ s@^([^/]*)/@@ if (!$file);
Joe Perches270c49a2012-01-10 15:09:50 -08002088 $in_commit_log = 0;
Joe Perches2ac73b4f2014-06-04 16:12:05 -07002089 $found_file = 1;
Rabin Vincent3bf9a002010-10-26 14:23:16 -07002090 } elsif ($line =~ /^\+\+\+\s+(\S+)/) {
Andy Whitcroft773647a2008-03-28 14:15:58 -07002091 $realfile = $1;
Joe Perches2b7ab452013-11-12 15:10:14 -08002092 $realfile =~ s@^([^/]*)/@@ if (!$file);
Joe Perches270c49a2012-01-10 15:09:50 -08002093 $in_commit_log = 0;
Wolfram Sang1e855722009-01-06 14:41:24 -08002094
2095 $p1_prefix = $1;
Andy Whitcrofte2f7aa42009-02-27 14:03:06 -08002096 if (!$file && $tree && $p1_prefix ne '' &&
2097 -e "$root/$p1_prefix") {
Joe Perches000d1cc12011-07-25 17:13:25 -07002098 WARN("PATCH_PREFIX",
2099 "patch prefix '$p1_prefix' exists, appears to be a -p0 patch\n");
Wolfram Sang1e855722009-01-06 14:41:24 -08002100 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07002101
Andy Whitcroftc1ab3322008-10-15 22:02:20 -07002102 if ($realfile =~ m@^include/asm/@) {
Joe Perches000d1cc12011-07-25 17:13:25 -07002103 ERROR("MODIFIED_INCLUDE_ASM",
2104 "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 -07002105 }
Joe Perches2ac73b4f2014-06-04 16:12:05 -07002106 $found_file = 1;
2107 }
2108
2109 if ($found_file) {
2110 if ($realfile =~ m@^(drivers/net/|net/)@) {
2111 $check = 1;
2112 } else {
2113 $check = $check_orig;
2114 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07002115 next;
2116 }
2117
Randy Dunlap389834b2007-06-08 13:47:03 -07002118 $here .= "FILE: $realfile:$realline:" if ($realcnt != 0);
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002119
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002120 my $hereline = "$here\n$rawline\n";
2121 my $herecurr = "$here\n$rawline\n";
2122 my $hereprev = "$here\n$prevrawline\n$rawline\n";
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002123
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07002124 $cnt_lines++ if ($realcnt != 0);
2125
Rabin Vincent3bf9a002010-10-26 14:23:16 -07002126# Check for incorrect file permissions
2127 if ($line =~ /^new (file )?mode.*[7531]\d{0,2}$/) {
2128 my $permhere = $here . "FILE: $realfile\n";
Joe Perches04db4d22013-04-29 16:18:14 -07002129 if ($realfile !~ m@scripts/@ &&
2130 $realfile !~ /\.(py|pl|awk|sh)$/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07002131 ERROR("EXECUTE_PERMISSIONS",
2132 "do not set execute permissions for source files\n" . $permhere);
Rabin Vincent3bf9a002010-10-26 14:23:16 -07002133 }
2134 }
2135
Joe Perches20112472011-07-25 17:13:23 -07002136# Check the patch for a signoff:
Andy Whitcroftd8aaf122007-06-23 17:16:44 -07002137 if ($line =~ /^\s*signed-off-by:/i) {
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07002138 $signoff++;
Joe Perches15662b32011-10-31 17:13:12 -07002139 $in_commit_log = 0;
Joe Perches20112472011-07-25 17:13:23 -07002140 }
2141
Joe Perchese0d975b2014-12-10 15:51:49 -08002142# Check if MAINTAINERS is being updated. If so, there's probably no need to
2143# emit the "does MAINTAINERS need updating?" message on file add/move/delete
2144 if ($line =~ /^\s*MAINTAINERS\s*\|/) {
2145 $reported_maintainer_file = 1;
2146 }
2147
Joe Perches20112472011-07-25 17:13:23 -07002148# Check signature styles
Joe Perches270c49a2012-01-10 15:09:50 -08002149 if (!$in_header_lines &&
Joe Perchesce0338df3c2012-07-30 14:41:18 -07002150 $line =~ /^(\s*)([a-z0-9_-]+by:|$signature_tags)(\s*)(.*)/i) {
Joe Perches20112472011-07-25 17:13:23 -07002151 my $space_before = $1;
2152 my $sign_off = $2;
2153 my $space_after = $3;
2154 my $email = $4;
2155 my $ucfirst_sign_off = ucfirst(lc($sign_off));
2156
Joe Perchesce0338df3c2012-07-30 14:41:18 -07002157 if ($sign_off !~ /$signature_tags/) {
2158 WARN("BAD_SIGN_OFF",
2159 "Non-standard signature: $sign_off\n" . $herecurr);
2160 }
Joe Perches20112472011-07-25 17:13:23 -07002161 if (defined $space_before && $space_before ne "") {
Joe Perches3705ce52013-07-03 15:05:31 -07002162 if (WARN("BAD_SIGN_OFF",
2163 "Do not use whitespace before $ucfirst_sign_off\n" . $herecurr) &&
2164 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07002165 $fixed[$fixlinenr] =
Joe Perches3705ce52013-07-03 15:05:31 -07002166 "$ucfirst_sign_off $email";
2167 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002168 }
Joe Perches20112472011-07-25 17:13:23 -07002169 if ($sign_off =~ /-by:$/i && $sign_off ne $ucfirst_sign_off) {
Joe Perches3705ce52013-07-03 15:05:31 -07002170 if (WARN("BAD_SIGN_OFF",
2171 "'$ucfirst_sign_off' is the preferred signature form\n" . $herecurr) &&
2172 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07002173 $fixed[$fixlinenr] =
Joe Perches3705ce52013-07-03 15:05:31 -07002174 "$ucfirst_sign_off $email";
2175 }
2176
Joe Perches20112472011-07-25 17:13:23 -07002177 }
2178 if (!defined $space_after || $space_after ne " ") {
Joe Perches3705ce52013-07-03 15:05:31 -07002179 if (WARN("BAD_SIGN_OFF",
2180 "Use a single space after $ucfirst_sign_off\n" . $herecurr) &&
2181 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07002182 $fixed[$fixlinenr] =
Joe Perches3705ce52013-07-03 15:05:31 -07002183 "$ucfirst_sign_off $email";
2184 }
Joe Perches20112472011-07-25 17:13:23 -07002185 }
2186
2187 my ($email_name, $email_address, $comment) = parse_email($email);
2188 my $suggested_email = format_email(($email_name, $email_address));
2189 if ($suggested_email eq "") {
Joe Perches000d1cc12011-07-25 17:13:25 -07002190 ERROR("BAD_SIGN_OFF",
2191 "Unrecognized email address: '$email'\n" . $herecurr);
Joe Perches20112472011-07-25 17:13:23 -07002192 } else {
2193 my $dequoted = $suggested_email;
2194 $dequoted =~ s/^"//;
2195 $dequoted =~ s/" </ </;
2196 # Don't force email to have quotes
2197 # Allow just an angle bracketed address
2198 if ("$dequoted$comment" ne $email &&
2199 "<$email_address>$comment" ne $email &&
2200 "$suggested_email$comment" ne $email) {
Joe Perches000d1cc12011-07-25 17:13:25 -07002201 WARN("BAD_SIGN_OFF",
2202 "email address '$email' might be better as '$suggested_email$comment'\n" . $herecurr);
Joe Perches20112472011-07-25 17:13:23 -07002203 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002204 }
Joe Perches7e51f192013-09-11 14:23:57 -07002205
2206# Check for duplicate signatures
2207 my $sig_nospace = $line;
2208 $sig_nospace =~ s/\s//g;
2209 $sig_nospace = lc($sig_nospace);
2210 if (defined $signatures{$sig_nospace}) {
2211 WARN("BAD_SIGN_OFF",
2212 "Duplicate signature\n" . $herecurr);
2213 } else {
2214 $signatures{$sig_nospace} = 1;
2215 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002216 }
2217
Joe Perchesa2fe16b2015-02-13 14:39:02 -08002218# Check email subject for common tools that don't need to be mentioned
2219 if ($in_header_lines &&
2220 $line =~ /^Subject:.*\b(?:checkpatch|sparse|smatch)\b[^:]/i) {
2221 WARN("EMAIL_SUBJECT",
2222 "A patch subject line should describe the change not the tool that found it\n" . $herecurr);
2223 }
2224
Joe Perches9b3189e2014-06-04 16:12:10 -07002225# Check for old stable address
2226 if ($line =~ /^\s*cc:\s*.*<?\bstable\@kernel\.org\b>?.*$/i) {
2227 ERROR("STABLE_ADDRESS",
2228 "The 'stable' address should be 'stable\@vger.kernel.org'\n" . $herecurr);
2229 }
2230
Christopher Covington7ebd05e2014-04-03 14:49:31 -07002231# Check for unwanted Gerrit info
2232 if ($in_commit_log && $line =~ /^\s*change-id:/i) {
2233 ERROR("GERRIT_CHANGE_ID",
2234 "Remove Gerrit Change-Id's before submitting upstream.\n" . $herecurr);
2235 }
2236
Joe Perches2a076f42015-04-16 12:44:28 -07002237# Check for line lengths > 75 in commit log, warn once
2238 if ($in_commit_log && !$commit_log_long_line &&
2239 length($line) > 75) {
2240 WARN("COMMIT_LOG_LONG_LINE",
2241 "Possible unwrapped commit description (prefer a maximum 75 chars per line)\n" . $herecurr);
2242 $commit_log_long_line = 1;
2243 }
2244
Joe Perches0d7835f2015-02-13 14:38:35 -08002245# Check for git id commit length and improperly formed commit descriptions
2246 if ($in_commit_log && $line =~ /\b(c)ommit\s+([0-9a-f]{5,})/i) {
Joe Perchesd311cd42014-08-06 16:10:57 -07002247 my $init_char = $1;
2248 my $orig_commit = lc($2);
Joe Perches0d7835f2015-02-13 14:38:35 -08002249 my $short = 1;
2250 my $long = 0;
2251 my $case = 1;
2252 my $space = 1;
2253 my $hasdesc = 0;
Joe Perches19c146a2015-02-13 14:39:00 -08002254 my $hasparens = 0;
Joe Perches0d7835f2015-02-13 14:38:35 -08002255 my $id = '0123456789ab';
2256 my $orig_desc = "commit description";
2257 my $description = "";
2258
2259 $short = 0 if ($line =~ /\bcommit\s+[0-9a-f]{12,40}/i);
2260 $long = 1 if ($line =~ /\bcommit\s+[0-9a-f]{41,}/i);
2261 $space = 0 if ($line =~ /\bcommit [0-9a-f]/i);
2262 $case = 0 if ($line =~ /\b[Cc]ommit\s+[0-9a-f]{5,40}[^A-F]/);
2263 if ($line =~ /\bcommit\s+[0-9a-f]{5,}\s+\("([^"]+)"\)/i) {
2264 $orig_desc = $1;
Joe Perches19c146a2015-02-13 14:39:00 -08002265 $hasparens = 1;
Joe Perches0d7835f2015-02-13 14:38:35 -08002266 } elsif ($line =~ /\bcommit\s+[0-9a-f]{5,}\s*$/i &&
2267 defined $rawlines[$linenr] &&
2268 $rawlines[$linenr] =~ /^\s*\("([^"]+)"\)/) {
2269 $orig_desc = $1;
Joe Perches19c146a2015-02-13 14:39:00 -08002270 $hasparens = 1;
Joe Perchesb671fde2015-02-13 14:38:41 -08002271 } elsif ($line =~ /\bcommit\s+[0-9a-f]{5,}\s+\("[^"]+$/i &&
2272 defined $rawlines[$linenr] &&
2273 $rawlines[$linenr] =~ /^\s*[^"]+"\)/) {
2274 $line =~ /\bcommit\s+[0-9a-f]{5,}\s+\("([^"]+)$/i;
2275 $orig_desc = $1;
2276 $rawlines[$linenr] =~ /^\s*([^"]+)"\)/;
2277 $orig_desc .= " " . $1;
Joe Perches19c146a2015-02-13 14:39:00 -08002278 $hasparens = 1;
Joe Perches0d7835f2015-02-13 14:38:35 -08002279 }
2280
2281 ($id, $description) = git_commit_info($orig_commit,
2282 $id, $orig_desc);
2283
Joe Perches19c146a2015-02-13 14:39:00 -08002284 if ($short || $long || $space || $case || ($orig_desc ne $description) || !$hasparens) {
Joe Perches0d7835f2015-02-13 14:38:35 -08002285 ERROR("GIT_COMMIT_ID",
2286 "Please use git commit description style 'commit <12+ chars of sha1> (\"<title line>\")' - ie: '${init_char}ommit $id (\"$description\")'\n" . $herecurr);
2287 }
Joe Perchesd311cd42014-08-06 16:10:57 -07002288 }
2289
Joe Perches13f19372014-08-06 16:10:59 -07002290# Check for added, moved or deleted files
2291 if (!$reported_maintainer_file && !$in_commit_log &&
2292 ($line =~ /^(?:new|deleted) file mode\s*\d+\s*$/ ||
2293 $line =~ /^rename (?:from|to) [\w\/\.\-]+\s*$/ ||
2294 ($line =~ /\{\s*([\w\/\.\-]*)\s*\=\>\s*([\w\/\.\-]*)\s*\}/ &&
2295 (defined($1) || defined($2))))) {
2296 $reported_maintainer_file = 1;
2297 WARN("FILE_PATH_CHANGES",
2298 "added, moved or deleted file(s), does MAINTAINERS need updating?\n" . $herecurr);
2299 }
2300
Andy Whitcroft00df3442007-06-08 13:47:06 -07002301# Check for wrappage within a valid hunk of the file
Andy Whitcroft8905a672007-11-28 16:21:06 -08002302 if ($realcnt != 0 && $line !~ m{^(?:\+|-| |\\ No newline|$)}) {
Joe Perches000d1cc12011-07-25 17:13:25 -07002303 ERROR("CORRUPTED_PATCH",
2304 "patch seems to be corrupt (line wrapped?)\n" .
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07002305 $herecurr) if (!$emitted_corrupt++);
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07002306 }
2307
Andy Whitcroft6ecd9672008-10-15 22:02:21 -07002308# Check for absolute kernel paths.
2309 if ($tree) {
2310 while ($line =~ m{(?:^|\s)(/\S*)}g) {
2311 my $file = $1;
2312
2313 if ($file =~ m{^(.*?)(?::\d+)+:?$} &&
2314 check_absolute_file($1, $herecurr)) {
2315 #
2316 } else {
2317 check_absolute_file($file, $herecurr);
2318 }
2319 }
2320 }
2321
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07002322# UTF-8 regex found at http://www.w3.org/International/questions/qa-forms-utf-8.en.php
2323 if (($realfile =~ /^$/ || $line =~ /^\+/) &&
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07002324 $rawline !~ m/^$UTF8*$/) {
2325 my ($utf8_prefix) = ($rawline =~ /^($UTF8*)/);
2326
2327 my $blank = copy_spacing($rawline);
2328 my $ptr = substr($blank, 0, length($utf8_prefix)) . "^";
2329 my $hereptr = "$hereline$ptr\n";
2330
Joe Perches34d99212011-07-25 17:13:26 -07002331 CHK("INVALID_UTF8",
2332 "Invalid UTF-8, patch and commit message should be encoded in UTF-8\n" . $hereptr);
Andy Whitcroft00df3442007-06-08 13:47:06 -07002333 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002334
Joe Perches15662b32011-10-31 17:13:12 -07002335# Check if it's the start of a commit log
2336# (not a header line and we haven't seen the patch filename)
2337 if ($in_header_lines && $realfile =~ /^$/ &&
Joe Perches29ee1b02014-08-06 16:10:35 -07002338 !($rawline =~ /^\s+\S/ ||
2339 $rawline =~ /^(commit\b|from\b|[\w-]+:).*$/i)) {
Joe Perches15662b32011-10-31 17:13:12 -07002340 $in_header_lines = 0;
2341 $in_commit_log = 1;
2342 }
2343
Pasi Savanainenfa64205d2012-10-04 17:13:29 -07002344# Check if there is UTF-8 in a commit log when a mail header has explicitly
2345# declined it, i.e defined some charset where it is missing.
2346 if ($in_header_lines &&
2347 $rawline =~ /^Content-Type:.+charset="(.+)".*$/ &&
2348 $1 !~ /utf-8/i) {
2349 $non_utf8_charset = 1;
2350 }
2351
2352 if ($in_commit_log && $non_utf8_charset && $realfile =~ /^$/ &&
Joe Perches15662b32011-10-31 17:13:12 -07002353 $rawline =~ /$NON_ASCII_UTF8/) {
Pasi Savanainenfa64205d2012-10-04 17:13:29 -07002354 WARN("UTF8_BEFORE_PATCH",
Joe Perches15662b32011-10-31 17:13:12 -07002355 "8-bit UTF-8 used in possible commit log\n" . $herecurr);
2356 }
2357
Kees Cook66b47b42014-10-13 15:51:57 -07002358# Check for various typo / spelling mistakes
Joe Perches66d7a382015-04-16 12:44:08 -07002359 if (defined($misspellings) &&
2360 ($in_commit_log || $line =~ /^(?:\+|Subject:)/i)) {
Joe Perchesebfd7d62015-04-16 12:44:14 -07002361 while ($rawline =~ /(?:^|[^a-z@])($misspellings)(?:\b|$|[^a-z@])/gi) {
Kees Cook66b47b42014-10-13 15:51:57 -07002362 my $typo = $1;
2363 my $typo_fix = $spelling_fix{lc($typo)};
2364 $typo_fix = ucfirst($typo_fix) if ($typo =~ /^[A-Z]/);
2365 $typo_fix = uc($typo_fix) if ($typo =~ /^[A-Z]+$/);
2366 my $msg_type = \&WARN;
2367 $msg_type = \&CHK if ($file);
2368 if (&{$msg_type}("TYPO_SPELLING",
2369 "'$typo' may be misspelled - perhaps '$typo_fix'?\n" . $herecurr) &&
2370 $fix) {
2371 $fixed[$fixlinenr] =~ s/(^|[^A-Za-z@])($typo)($|[^A-Za-z@])/$1$typo_fix$3/;
2372 }
2373 }
2374 }
2375
Andy Whitcroft306708542008-10-15 22:02:28 -07002376# ignore non-hunk lines and lines being removed
2377 next if (!$hunk_line || $line =~ /^-/);
Andy Whitcroft00df3442007-06-08 13:47:06 -07002378
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002379#trailing whitespace
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07002380 if ($line =~ /^\+.*\015/) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002381 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
Joe Perchesd5e616f2013-09-11 14:23:54 -07002382 if (ERROR("DOS_LINE_ENDINGS",
2383 "DOS line endings\n" . $herevet) &&
2384 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07002385 $fixed[$fixlinenr] =~ s/[\s\015]+$//;
Joe Perchesd5e616f2013-09-11 14:23:54 -07002386 }
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002387 } elsif ($rawline =~ /^\+.*\S\s+$/ || $rawline =~ /^\+\s+$/) {
2388 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
Joe Perches3705ce52013-07-03 15:05:31 -07002389 if (ERROR("TRAILING_WHITESPACE",
2390 "trailing whitespace\n" . $herevet) &&
2391 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07002392 $fixed[$fixlinenr] =~ s/\s+$//;
Joe Perches3705ce52013-07-03 15:05:31 -07002393 }
2394
Andy Whitcroftd2c0a232010-10-26 14:23:12 -07002395 $rpt_cleaners = 1;
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002396 }
Andy Whitcroft5368df22008-10-15 22:02:27 -07002397
Josh Triplett4783f892013-11-12 15:10:12 -08002398# Check for FSF mailing addresses.
Alexander Duyck109d8cb2014-01-23 15:54:50 -08002399 if ($rawline =~ /\bwrite to the Free/i ||
Joe Perches3e2232f2014-01-23 15:54:48 -08002400 $rawline =~ /\b59\s+Temple\s+Pl/i ||
2401 $rawline =~ /\b51\s+Franklin\s+St/i) {
Josh Triplett4783f892013-11-12 15:10:12 -08002402 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2403 my $msg_type = \&ERROR;
2404 $msg_type = \&CHK if ($file);
2405 &{$msg_type}("FSF_MAILING_ADDRESS",
Joe Perches3e2232f2014-01-23 15:54:48 -08002406 "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 -08002407 }
2408
Andi Kleen33549572010-05-24 14:33:29 -07002409# check for Kconfig help text having a real description
Andy Whitcroft9fe287d72010-10-26 14:23:15 -07002410# Only applies when adding the entry originally, after that we do not have
2411# sufficient context to determine whether it is indeed long enough.
Andi Kleen33549572010-05-24 14:33:29 -07002412 if ($realfile =~ /Kconfig/ &&
Joe Perches8d73e0e2014-08-06 16:10:46 -07002413 $line =~ /^\+\s*config\s+/) {
Andi Kleen33549572010-05-24 14:33:29 -07002414 my $length = 0;
Andy Whitcroft9fe287d72010-10-26 14:23:15 -07002415 my $cnt = $realcnt;
2416 my $ln = $linenr + 1;
2417 my $f;
Andy Whitcrofta1385802012-01-10 15:10:03 -08002418 my $is_start = 0;
Andy Whitcroft9fe287d72010-10-26 14:23:15 -07002419 my $is_end = 0;
Andy Whitcrofta1385802012-01-10 15:10:03 -08002420 for (; $cnt > 0 && defined $lines[$ln - 1]; $ln++) {
Andy Whitcroft9fe287d72010-10-26 14:23:15 -07002421 $f = $lines[$ln - 1];
2422 $cnt-- if ($lines[$ln - 1] !~ /^-/);
2423 $is_end = $lines[$ln - 1] =~ /^\+/;
Andy Whitcroft9fe287d72010-10-26 14:23:15 -07002424
2425 next if ($f =~ /^-/);
Joe Perches8d73e0e2014-08-06 16:10:46 -07002426 last if (!$file && $f =~ /^\@\@/);
Andy Whitcrofta1385802012-01-10 15:10:03 -08002427
Joe Perches8d73e0e2014-08-06 16:10:46 -07002428 if ($lines[$ln - 1] =~ /^\+\s*(?:bool|tristate)\s*\"/) {
Andy Whitcrofta1385802012-01-10 15:10:03 -08002429 $is_start = 1;
Joe Perches8d73e0e2014-08-06 16:10:46 -07002430 } elsif ($lines[$ln - 1] =~ /^\+\s*(?:---)?help(?:---)?$/) {
Andy Whitcrofta1385802012-01-10 15:10:03 -08002431 $length = -1;
2432 }
2433
Andy Whitcroft9fe287d72010-10-26 14:23:15 -07002434 $f =~ s/^.//;
Andi Kleen33549572010-05-24 14:33:29 -07002435 $f =~ s/#.*//;
2436 $f =~ s/^\s+//;
2437 next if ($f =~ /^$/);
Andy Whitcroft9fe287d72010-10-26 14:23:15 -07002438 if ($f =~ /^\s*config\s/) {
2439 $is_end = 1;
2440 last;
2441 }
Andi Kleen33549572010-05-24 14:33:29 -07002442 $length++;
2443 }
Vadim Bendebury56193272014-10-13 15:51:48 -07002444 if ($is_start && $is_end && $length < $min_conf_desc_length) {
2445 WARN("CONFIG_DESCRIPTION",
2446 "please write a paragraph that describes the config symbol fully\n" . $herecurr);
2447 }
Andy Whitcrofta1385802012-01-10 15:10:03 -08002448 #print "is_start<$is_start> is_end<$is_end> length<$length>\n";
Andi Kleen33549572010-05-24 14:33:29 -07002449 }
2450
Kees Cook1ba8dfd2012-12-17 16:01:48 -08002451# discourage the addition of CONFIG_EXPERIMENTAL in Kconfig.
2452 if ($realfile =~ /Kconfig/ &&
2453 $line =~ /.\s*depends on\s+.*\bEXPERIMENTAL\b/) {
2454 WARN("CONFIG_EXPERIMENTAL",
2455 "Use of CONFIG_EXPERIMENTAL is deprecated. For alternatives, see https://lkml.org/lkml/2012/10/23/580\n");
2456 }
2457
Christoph Jaeger327953e2015-02-13 14:38:29 -08002458# discourage the use of boolean for type definition attributes of Kconfig options
2459 if ($realfile =~ /Kconfig/ &&
2460 $line =~ /^\+\s*\bboolean\b/) {
2461 WARN("CONFIG_TYPE_BOOLEAN",
2462 "Use of boolean is deprecated, please use bool instead.\n" . $herecurr);
2463 }
2464
Arnaud Lacombec68e5872011-08-15 01:07:14 -04002465 if (($realfile =~ /Makefile.*/ || $realfile =~ /Kbuild.*/) &&
2466 ($line =~ /\+(EXTRA_[A-Z]+FLAGS).*/)) {
2467 my $flag = $1;
2468 my $replacement = {
2469 'EXTRA_AFLAGS' => 'asflags-y',
2470 'EXTRA_CFLAGS' => 'ccflags-y',
2471 'EXTRA_CPPFLAGS' => 'cppflags-y',
2472 'EXTRA_LDFLAGS' => 'ldflags-y',
2473 };
2474
2475 WARN("DEPRECATED_VARIABLE",
2476 "Use of $flag is deprecated, please use \`$replacement->{$flag} instead.\n" . $herecurr) if ($replacement->{$flag});
2477 }
2478
Rob Herringbff5da42014-01-23 15:54:51 -08002479# check for DT compatible documentation
Florian Vaussard7dd05b32014-04-03 14:49:26 -07002480 if (defined $root &&
2481 (($realfile =~ /\.dtsi?$/ && $line =~ /^\+\s*compatible\s*=\s*\"/) ||
2482 ($realfile =~ /\.[ch]$/ && $line =~ /^\+.*\.compatible\s*=\s*\"/))) {
2483
Rob Herringbff5da42014-01-23 15:54:51 -08002484 my @compats = $rawline =~ /\"([a-zA-Z0-9\-\,\.\+_]+)\"/g;
2485
Florian Vaussardcc933192014-04-03 14:49:27 -07002486 my $dt_path = $root . "/Documentation/devicetree/bindings/";
2487 my $vp_file = $dt_path . "vendor-prefixes.txt";
2488
Rob Herringbff5da42014-01-23 15:54:51 -08002489 foreach my $compat (@compats) {
2490 my $compat2 = $compat;
Rob Herring185d5662014-06-04 16:12:03 -07002491 $compat2 =~ s/\,[a-zA-Z0-9]*\-/\,<\.\*>\-/;
2492 my $compat3 = $compat;
2493 $compat3 =~ s/\,([a-z]*)[0-9]*\-/\,$1<\.\*>\-/;
2494 `grep -Erq "$compat|$compat2|$compat3" $dt_path`;
Rob Herringbff5da42014-01-23 15:54:51 -08002495 if ( $? >> 8 ) {
2496 WARN("UNDOCUMENTED_DT_STRING",
2497 "DT compatible string \"$compat\" appears un-documented -- check $dt_path\n" . $herecurr);
2498 }
2499
Florian Vaussard4fbf32a2014-04-03 14:49:25 -07002500 next if $compat !~ /^([a-zA-Z0-9\-]+)\,/;
2501 my $vendor = $1;
Florian Vaussardcc933192014-04-03 14:49:27 -07002502 `grep -Eq "^$vendor\\b" $vp_file`;
Rob Herringbff5da42014-01-23 15:54:51 -08002503 if ( $? >> 8 ) {
2504 WARN("UNDOCUMENTED_DT_STRING",
Florian Vaussardcc933192014-04-03 14:49:27 -07002505 "DT compatible string vendor \"$vendor\" appears un-documented -- check $vp_file\n" . $herecurr);
Rob Herringbff5da42014-01-23 15:54:51 -08002506 }
2507 }
2508 }
2509
Andy Whitcroft5368df22008-10-15 22:02:27 -07002510# check we are in a valid source file if not then ignore this hunk
Geert Uytterhoevende4c9242014-10-13 15:51:46 -07002511 next if ($realfile !~ /\.(h|c|s|S|pl|sh|dtsi|dts)$/);
Andy Whitcroft5368df22008-10-15 22:02:27 -07002512
Joe Perches6cd7f382012-12-17 16:01:54 -08002513#line length limit
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07002514 if ($line =~ /^\+/ && $prevrawline !~ /\/\*\*/ &&
Andy Whitcroftf4c014c2008-07-23 21:29:01 -07002515 $rawline !~ /^.\s*\*\s*\@$Ident\s/ &&
Joe Perches29a3c462015-04-16 12:44:30 -07002516 !($line =~ /^\+\s*$logFunctions\s*\(\s*(?:(KERN_\S+\s*|[^"]*))?$String\s*(?:|,|\)\s*;)\s*$/ ||
2517 $line =~ /^\+\s*$String\s*(?:\s*|,|\)\s*;)\s*$/ ||
2518 $line =~ /^\+\s*#\s*define\s+\w+\s+$String$/) &&
Joe Perches6cd7f382012-12-17 16:01:54 -08002519 $length > $max_line_length)
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07002520 {
Joe Perches000d1cc12011-07-25 17:13:25 -07002521 WARN("LONG_LINE",
Joe Perches6cd7f382012-12-17 16:01:54 -08002522 "line over $max_line_length characters\n" . $herecurr);
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002523 }
2524
Andy Whitcroft8905a672007-11-28 16:21:06 -08002525# check for adding lines without a newline.
2526 if ($line =~ /^\+/ && defined $lines[$linenr] && $lines[$linenr] =~ /^\\ No newline at end of file/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07002527 WARN("MISSING_EOF_NEWLINE",
2528 "adding a line without newline at end of file\n" . $herecurr);
Andy Whitcroft8905a672007-11-28 16:21:06 -08002529 }
2530
Mike Frysinger42e41c52009-09-21 17:04:40 -07002531# Blackfin: use hi/lo macros
2532 if ($realfile =~ m@arch/blackfin/.*\.S$@) {
2533 if ($line =~ /\.[lL][[:space:]]*=.*&[[:space:]]*0x[fF][fF][fF][fF]/) {
2534 my $herevet = "$here\n" . cat_vet($line) . "\n";
Joe Perches000d1cc12011-07-25 17:13:25 -07002535 ERROR("LO_MACRO",
2536 "use the LO() macro, not (... & 0xFFFF)\n" . $herevet);
Mike Frysinger42e41c52009-09-21 17:04:40 -07002537 }
2538 if ($line =~ /\.[hH][[:space:]]*=.*>>[[:space:]]*16/) {
2539 my $herevet = "$here\n" . cat_vet($line) . "\n";
Joe Perches000d1cc12011-07-25 17:13:25 -07002540 ERROR("HI_MACRO",
2541 "use the HI() macro, not (... >> 16)\n" . $herevet);
Mike Frysinger42e41c52009-09-21 17:04:40 -07002542 }
2543 }
2544
Andy Whitcroftb9ea10d2008-10-15 22:02:24 -07002545# check we are in a valid source file C or perl if not then ignore this hunk
Geert Uytterhoevende4c9242014-10-13 15:51:46 -07002546 next if ($realfile !~ /\.(h|c|pl|dtsi|dts)$/);
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002547
2548# at the beginning of a line any tabs must come first and anything
2549# more than 8 must use tabs.
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002550 if ($rawline =~ /^\+\s* \t\s*\S/ ||
2551 $rawline =~ /^\+\s* \s*/) {
2552 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
Andy Whitcroftd2c0a232010-10-26 14:23:12 -07002553 $rpt_cleaners = 1;
Joe Perches3705ce52013-07-03 15:05:31 -07002554 if (ERROR("CODE_INDENT",
2555 "code indent should use tabs where possible\n" . $herevet) &&
2556 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07002557 $fixed[$fixlinenr] =~ s/^\+([ \t]+)/"\+" . tabify($1)/e;
Joe Perches3705ce52013-07-03 15:05:31 -07002558 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002559 }
2560
Alberto Panizzo08e44362010-03-05 13:43:54 -08002561# check for space before tabs.
2562 if ($rawline =~ /^\+/ && $rawline =~ / \t/) {
2563 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
Joe Perches3705ce52013-07-03 15:05:31 -07002564 if (WARN("SPACE_BEFORE_TAB",
2565 "please, no space before tabs\n" . $herevet) &&
2566 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07002567 while ($fixed[$fixlinenr] =~
Joe Perchesd2207cc2014-10-13 15:51:53 -07002568 s/(^\+.*) {8,8}\t/$1\t\t/) {}
Joe Perches194f66f2014-08-06 16:11:03 -07002569 while ($fixed[$fixlinenr] =~
Joe Perchesc76f4cb2014-01-23 15:54:46 -08002570 s/(^\+.*) +\t/$1\t/) {}
Joe Perches3705ce52013-07-03 15:05:31 -07002571 }
Alberto Panizzo08e44362010-03-05 13:43:54 -08002572 }
2573
Joe Perchesd1fe9c02012-03-23 15:02:16 -07002574# check for && or || at the start of a line
2575 if ($rawline =~ /^\+\s*(&&|\|\|)/) {
2576 CHK("LOGICAL_CONTINUATIONS",
2577 "Logical continuations should be on the previous line\n" . $hereprev);
2578 }
2579
2580# check multi-line statement indentation matches previous line
2581 if ($^V && $^V ge 5.10.0 &&
Joe Perches91cb5192014-04-03 14:49:32 -07002582 $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 -07002583 $prevline =~ /^\+(\t*)(.*)$/;
2584 my $oldindent = $1;
2585 my $rest = $2;
2586
2587 my $pos = pos_last_openparen($rest);
2588 if ($pos >= 0) {
Joe Perchesb34a26f2012-07-30 14:41:16 -07002589 $line =~ /^(\+| )([ \t]*)/;
2590 my $newindent = $2;
Joe Perchesd1fe9c02012-03-23 15:02:16 -07002591
2592 my $goodtabindent = $oldindent .
2593 "\t" x ($pos / 8) .
2594 " " x ($pos % 8);
2595 my $goodspaceindent = $oldindent . " " x $pos;
2596
2597 if ($newindent ne $goodtabindent &&
2598 $newindent ne $goodspaceindent) {
Joe Perches3705ce52013-07-03 15:05:31 -07002599
2600 if (CHK("PARENTHESIS_ALIGNMENT",
2601 "Alignment should match open parenthesis\n" . $hereprev) &&
2602 $fix && $line =~ /^\+/) {
Joe Perches194f66f2014-08-06 16:11:03 -07002603 $fixed[$fixlinenr] =~
Joe Perches3705ce52013-07-03 15:05:31 -07002604 s/^\+[ \t]*/\+$goodtabindent/;
2605 }
Joe Perchesd1fe9c02012-03-23 15:02:16 -07002606 }
2607 }
2608 }
2609
Joe Perches6ab3a972015-04-16 12:44:05 -07002610# check for space after cast like "(int) foo" or "(struct foo) bar"
2611# avoid checking a few false positives:
2612# "sizeof(<type>)" or "__alignof__(<type>)"
2613# function pointer declarations like "(*foo)(int) = bar;"
2614# structure definitions like "(struct foo) { 0 };"
2615# multiline macros that define functions
2616# known attributes or the __attribute__ keyword
2617 if ($line =~ /^\+(.*)\(\s*$Type\s*\)([ \t]++)((?![={]|\\$|$Attribute|__attribute__))/ &&
2618 (!defined($1) || $1 !~ /\b(?:sizeof|__alignof__)\s*$/)) {
Joe Perches3705ce52013-07-03 15:05:31 -07002619 if (CHK("SPACING",
Joe Perchesf27c95d2014-08-06 16:10:52 -07002620 "No space is necessary after a cast\n" . $herecurr) &&
Joe Perches3705ce52013-07-03 15:05:31 -07002621 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07002622 $fixed[$fixlinenr] =~
Joe Perchesf27c95d2014-08-06 16:10:52 -07002623 s/(\(\s*$Type\s*\))[ \t]+/$1/;
Joe Perches3705ce52013-07-03 15:05:31 -07002624 }
Joe Perchesaad4f612012-03-23 15:02:19 -07002625 }
2626
Joe Perches05880602012-10-04 17:13:35 -07002627 if ($realfile =~ m@^(drivers/net/|net/)@ &&
Joe Perchesfdb4bcd2013-07-03 15:05:23 -07002628 $prevrawline =~ /^\+[ \t]*\/\*[ \t]*$/ &&
Joe Perches85ad9782014-04-03 14:49:20 -07002629 $rawline =~ /^\+[ \t]*\*/ &&
2630 $realline > 2) {
Joe Perches05880602012-10-04 17:13:35 -07002631 WARN("NETWORKING_BLOCK_COMMENT_STYLE",
2632 "networking block comments don't use an empty /* line, use /* Comment...\n" . $hereprev);
2633 }
2634
2635 if ($realfile =~ m@^(drivers/net/|net/)@ &&
Joe Perchesa605e322013-07-03 15:05:24 -07002636 $prevrawline =~ /^\+[ \t]*\/\*/ && #starting /*
2637 $prevrawline !~ /\*\/[ \t]*$/ && #no trailing */
Joe Perches61135e92013-09-11 14:23:59 -07002638 $rawline =~ /^\+/ && #line is new
Joe Perchesa605e322013-07-03 15:05:24 -07002639 $rawline !~ /^\+[ \t]*\*/) { #no leading *
2640 WARN("NETWORKING_BLOCK_COMMENT_STYLE",
2641 "networking block comments start with * on subsequent lines\n" . $hereprev);
2642 }
2643
2644 if ($realfile =~ m@^(drivers/net/|net/)@ &&
Joe Perchesc24f9f12012-11-08 15:53:29 -08002645 $rawline !~ m@^\+[ \t]*\*/[ \t]*$@ && #trailing */
2646 $rawline !~ m@^\+.*/\*.*\*/[ \t]*$@ && #inline /*...*/
2647 $rawline !~ m@^\+.*\*{2,}/[ \t]*$@ && #trailing **/
2648 $rawline =~ m@^\+[ \t]*.+\*\/[ \t]*$@) { #non blank */
Joe Perches05880602012-10-04 17:13:35 -07002649 WARN("NETWORKING_BLOCK_COMMENT_STYLE",
2650 "networking block comments put the trailing */ on a separate line\n" . $herecurr);
2651 }
2652
Joe Perches7f619192014-08-06 16:10:39 -07002653# check for missing blank lines after struct/union declarations
2654# with exceptions for various attributes and macros
2655 if ($prevline =~ /^[\+ ]};?\s*$/ &&
2656 $line =~ /^\+/ &&
2657 !($line =~ /^\+\s*$/ ||
2658 $line =~ /^\+\s*EXPORT_SYMBOL/ ||
2659 $line =~ /^\+\s*MODULE_/i ||
2660 $line =~ /^\+\s*\#\s*(?:end|elif|else)/ ||
2661 $line =~ /^\+[a-z_]*init/ ||
2662 $line =~ /^\+\s*(?:static\s+)?[A-Z_]*ATTR/ ||
2663 $line =~ /^\+\s*DECLARE/ ||
2664 $line =~ /^\+\s*__setup/)) {
Joe Perchesd752fcc2014-08-06 16:11:05 -07002665 if (CHK("LINE_SPACING",
2666 "Please use a blank line after function/struct/union/enum declarations\n" . $hereprev) &&
2667 $fix) {
Joe Perchesf2d7e4d2014-08-06 16:11:07 -07002668 fix_insert_line($fixlinenr, "\+");
Joe Perchesd752fcc2014-08-06 16:11:05 -07002669 }
Joe Perches7f619192014-08-06 16:10:39 -07002670 }
2671
Joe Perches365dd4e2014-08-06 16:10:42 -07002672# check for multiple consecutive blank lines
2673 if ($prevline =~ /^[\+ ]\s*$/ &&
2674 $line =~ /^\+\s*$/ &&
2675 $last_blank_line != ($linenr - 1)) {
Joe Perchesd752fcc2014-08-06 16:11:05 -07002676 if (CHK("LINE_SPACING",
2677 "Please don't use multiple blank lines\n" . $hereprev) &&
2678 $fix) {
Joe Perchesf2d7e4d2014-08-06 16:11:07 -07002679 fix_delete_line($fixlinenr, $rawline);
Joe Perchesd752fcc2014-08-06 16:11:05 -07002680 }
2681
Joe Perches365dd4e2014-08-06 16:10:42 -07002682 $last_blank_line = $linenr;
2683 }
2684
Joe Perches3b617e32014-04-03 14:49:28 -07002685# check for missing blank lines after declarations
Joe Perches3f7bac02014-06-04 16:12:04 -07002686 if ($sline =~ /^\+\s+\S/ && #Not at char 1
2687 # actual declarations
2688 ($prevline =~ /^\+\s+$Declare\s*$Ident\s*[=,;:\[]/ ||
Joe Perches5a4e1fd2014-08-06 16:10:33 -07002689 # function pointer declarations
2690 $prevline =~ /^\+\s+$Declare\s*\(\s*\*\s*$Ident\s*\)\s*[=,;:\[\(]/ ||
Joe Perches3f7bac02014-06-04 16:12:04 -07002691 # foo bar; where foo is some local typedef or #define
2692 $prevline =~ /^\+\s+$Ident(?:\s+|\s*\*\s*)$Ident\s*[=,;\[]/ ||
2693 # known declaration macros
2694 $prevline =~ /^\+\s+$declaration_macros/) &&
2695 # for "else if" which can look like "$Ident $Ident"
2696 !($prevline =~ /^\+\s+$c90_Keywords\b/ ||
2697 # other possible extensions of declaration lines
2698 $prevline =~ /(?:$Compare|$Assignment|$Operators)\s*$/ ||
2699 # not starting a section or a macro "\" extended line
2700 $prevline =~ /(?:\{\s*|\\)$/) &&
2701 # looks like a declaration
2702 !($sline =~ /^\+\s+$Declare\s*$Ident\s*[=,;:\[]/ ||
Joe Perches5a4e1fd2014-08-06 16:10:33 -07002703 # function pointer declarations
2704 $sline =~ /^\+\s+$Declare\s*\(\s*\*\s*$Ident\s*\)\s*[=,;:\[\(]/ ||
Joe Perches3f7bac02014-06-04 16:12:04 -07002705 # foo bar; where foo is some local typedef or #define
2706 $sline =~ /^\+\s+$Ident(?:\s+|\s*\*\s*)$Ident\s*[=,;\[]/ ||
2707 # known declaration macros
2708 $sline =~ /^\+\s+$declaration_macros/ ||
2709 # start of struct or union or enum
Joe Perches3b617e32014-04-03 14:49:28 -07002710 $sline =~ /^\+\s+(?:union|struct|enum|typedef)\b/ ||
Joe Perches3f7bac02014-06-04 16:12:04 -07002711 # start or end of block or continuation of declaration
2712 $sline =~ /^\+\s+(?:$|[\{\}\.\#\"\?\:\(\[])/ ||
2713 # bitfield continuation
2714 $sline =~ /^\+\s+$Ident\s*:\s*\d+\s*[,;]/ ||
2715 # other possible extensions of declaration lines
2716 $sline =~ /^\+\s+\(?\s*(?:$Compare|$Assignment|$Operators)/) &&
2717 # indentation of previous and current line are the same
2718 (($prevline =~ /\+(\s+)\S/) && $sline =~ /^\+$1\S/)) {
Joe Perchesd752fcc2014-08-06 16:11:05 -07002719 if (WARN("LINE_SPACING",
2720 "Missing a blank line after declarations\n" . $hereprev) &&
2721 $fix) {
Joe Perchesf2d7e4d2014-08-06 16:11:07 -07002722 fix_insert_line($fixlinenr, "\+");
Joe Perchesd752fcc2014-08-06 16:11:05 -07002723 }
Joe Perches3b617e32014-04-03 14:49:28 -07002724 }
2725
Raffaele Recalcati5f7ddae2010-08-09 17:20:59 -07002726# check for spaces at the beginning of a line.
Andy Whitcroft6b4c5be2010-10-26 14:23:11 -07002727# Exceptions:
2728# 1) within comments
2729# 2) indented preprocessor commands
2730# 3) hanging labels
Joe Perches3705ce52013-07-03 15:05:31 -07002731 if ($rawline =~ /^\+ / && $line !~ /^\+ *(?:$;|#|$Ident:)/) {
Raffaele Recalcati5f7ddae2010-08-09 17:20:59 -07002732 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
Joe Perches3705ce52013-07-03 15:05:31 -07002733 if (WARN("LEADING_SPACE",
2734 "please, no spaces at the start of a line\n" . $herevet) &&
2735 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07002736 $fixed[$fixlinenr] =~ s/^\+([ \t]+)/"\+" . tabify($1)/e;
Joe Perches3705ce52013-07-03 15:05:31 -07002737 }
Raffaele Recalcati5f7ddae2010-08-09 17:20:59 -07002738 }
2739
Andy Whitcroftb9ea10d2008-10-15 22:02:24 -07002740# check we are in a valid C source file if not then ignore this hunk
2741 next if ($realfile !~ /\.(h|c)$/);
2742
Joe Perches032a4c02014-08-06 16:10:29 -07002743# check indentation of any line with a bare else
Joe Perches840080a2014-10-13 15:51:59 -07002744# (but not if it is a multiple line "if (foo) return bar; else return baz;")
Joe Perches032a4c02014-08-06 16:10:29 -07002745# if the previous line is a break or return and is indented 1 tab more...
2746 if ($sline =~ /^\+([\t]+)(?:}[ \t]*)?else(?:[ \t]*{)?\s*$/) {
2747 my $tabs = length($1) + 1;
Joe Perches840080a2014-10-13 15:51:59 -07002748 if ($prevline =~ /^\+\t{$tabs,$tabs}break\b/ ||
2749 ($prevline =~ /^\+\t{$tabs,$tabs}return\b/ &&
2750 defined $lines[$linenr] &&
2751 $lines[$linenr] !~ /^[ \+]\t{$tabs,$tabs}return/)) {
Joe Perches032a4c02014-08-06 16:10:29 -07002752 WARN("UNNECESSARY_ELSE",
2753 "else is not generally useful after a break or return\n" . $hereprev);
2754 }
2755 }
2756
Joe Perchesc00df192014-08-06 16:11:01 -07002757# check indentation of a line with a break;
2758# if the previous line is a goto or return and is indented the same # of tabs
2759 if ($sline =~ /^\+([\t]+)break\s*;\s*$/) {
2760 my $tabs = $1;
2761 if ($prevline =~ /^\+$tabs(?:goto|return)\b/) {
2762 WARN("UNNECESSARY_BREAK",
2763 "break is not useful after a goto or return\n" . $hereprev);
2764 }
2765 }
2766
Kees Cook1ba8dfd2012-12-17 16:01:48 -08002767# discourage the addition of CONFIG_EXPERIMENTAL in #if(def).
2768 if ($line =~ /^\+\s*\#\s*if.*\bCONFIG_EXPERIMENTAL\b/) {
2769 WARN("CONFIG_EXPERIMENTAL",
2770 "Use of CONFIG_EXPERIMENTAL is deprecated. For alternatives, see https://lkml.org/lkml/2012/10/23/580\n");
2771 }
2772
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002773# check for RCS/CVS revision markers
Andy Whitcroftcf655042008-03-04 14:28:20 -08002774 if ($rawline =~ /^\+.*\$(Revision|Log|Id)(?:\$|)/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07002775 WARN("CVS_KEYWORD",
2776 "CVS style keyword markers, these will _not_ be updated\n". $herecurr);
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002777 }
Andy Whitcroft22f2a2e2007-08-10 13:01:03 -07002778
Mike Frysinger42e41c52009-09-21 17:04:40 -07002779# Blackfin: don't use __builtin_bfin_[cs]sync
2780 if ($line =~ /__builtin_bfin_csync/) {
2781 my $herevet = "$here\n" . cat_vet($line) . "\n";
Joe Perches000d1cc12011-07-25 17:13:25 -07002782 ERROR("CSYNC",
2783 "use the CSYNC() macro in asm/blackfin.h\n" . $herevet);
Mike Frysinger42e41c52009-09-21 17:04:40 -07002784 }
2785 if ($line =~ /__builtin_bfin_ssync/) {
2786 my $herevet = "$here\n" . cat_vet($line) . "\n";
Joe Perches000d1cc12011-07-25 17:13:25 -07002787 ERROR("SSYNC",
2788 "use the SSYNC() macro in asm/blackfin.h\n" . $herevet);
Mike Frysinger42e41c52009-09-21 17:04:40 -07002789 }
2790
Joe Perches56e77d72013-02-21 16:44:14 -08002791# check for old HOTPLUG __dev<foo> section markings
2792 if ($line =~ /\b(__dev(init|exit)(data|const|))\b/) {
2793 WARN("HOTPLUG_SECTION",
2794 "Using $1 is unnecessary\n" . $herecurr);
2795 }
2796
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07002797# Check for potential 'bare' types
Andy Whitcroft2b474a12009-10-26 16:50:16 -07002798 my ($stat, $cond, $line_nr_next, $remain_next, $off_next,
2799 $realline_next);
Andy Whitcroft3e469cd2012-01-10 15:10:01 -08002800#print "LINE<$line>\n";
2801 if ($linenr >= $suppress_statement &&
Joe Perches1b5539b2013-09-11 14:24:03 -07002802 $realcnt && $sline =~ /.\s*\S/) {
Andy Whitcroft170d3a22008-10-15 22:02:30 -07002803 ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
Andy Whitcroftf5fe35d2008-07-23 21:29:03 -07002804 ctx_statement_block($linenr, $realcnt, 0);
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07002805 $stat =~ s/\n./\n /g;
2806 $cond =~ s/\n./\n /g;
2807
Andy Whitcroft3e469cd2012-01-10 15:10:01 -08002808#print "linenr<$linenr> <$stat>\n";
2809 # If this statement has no statement boundaries within
2810 # it there is no point in retrying a statement scan
2811 # until we hit end of it.
2812 my $frag = $stat; $frag =~ s/;+\s*$//;
2813 if ($frag !~ /(?:{|;)/) {
2814#print "skip<$line_nr_next>\n";
2815 $suppress_statement = $line_nr_next;
2816 }
Andy Whitcroftf74bd192012-01-10 15:09:54 -08002817
Andy Whitcroft2b474a12009-10-26 16:50:16 -07002818 # Find the real next line.
2819 $realline_next = $line_nr_next;
2820 if (defined $realline_next &&
2821 (!defined $lines[$realline_next - 1] ||
2822 substr($lines[$realline_next - 1], $off_next) =~ /^\s*$/)) {
2823 $realline_next++;
2824 }
2825
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07002826 my $s = $stat;
2827 $s =~ s/{.*$//s;
Andy Whitcroftcf655042008-03-04 14:28:20 -08002828
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002829 # Ignore goto labels.
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07002830 if ($s =~ /$Ident:\*$/s) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002831
2832 # Ignore functions being called
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07002833 } elsif ($s =~ /^.\s*$Ident\s*\(/s) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002834
Andy Whitcroft463f2862009-09-21 17:04:34 -07002835 } elsif ($s =~ /^.\s*else\b/s) {
2836
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07002837 # declarations always start with types
Andy Whitcroftd2506582008-07-23 21:29:09 -07002838 } 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 -07002839 my $type = $1;
2840 $type =~ s/\s+/ /g;
2841 possible($type, "A:" . $s);
2842
Andy Whitcroft8905a672007-11-28 16:21:06 -08002843 # definitions in global scope can only start with types
Andy Whitcrofta6a840622008-10-15 22:02:30 -07002844 } elsif ($s =~ /^.(?:$Storage\s+)?(?:$Inline\s+)?(?:const\s+)?($Ident)\b\s*(?!:)/s) {
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07002845 possible($1, "B:" . $s);
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002846 }
Andy Whitcroft8905a672007-11-28 16:21:06 -08002847
2848 # any (foo ... *) is a pointer cast, and foo is a type
Andy Whitcroft65863862009-01-06 14:41:21 -08002849 while ($s =~ /\(($Ident)(?:\s+$Sparse)*[\s\*]+\s*\)/sg) {
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07002850 possible($1, "C:" . $s);
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07002851 }
Andy Whitcroft8905a672007-11-28 16:21:06 -08002852
2853 # Check for any sort of function declaration.
2854 # int foo(something bar, other baz);
2855 # void (*store_gdt)(x86_descr_ptr *);
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07002856 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 -08002857 my ($name_len) = length($1);
Andy Whitcroft8905a672007-11-28 16:21:06 -08002858
Andy Whitcroftcf655042008-03-04 14:28:20 -08002859 my $ctx = $s;
Andy Whitcroft773647a2008-03-28 14:15:58 -07002860 substr($ctx, 0, $name_len + 1, '');
Andy Whitcroft8905a672007-11-28 16:21:06 -08002861 $ctx =~ s/\)[^\)]*$//;
Andy Whitcroftcf655042008-03-04 14:28:20 -08002862
Andy Whitcroft8905a672007-11-28 16:21:06 -08002863 for my $arg (split(/\s*,\s*/, $ctx)) {
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07002864 if ($arg =~ /^(?:const\s+)?($Ident)(?:\s+$Sparse)*\s*\**\s*(:?\b$Ident)?$/s || $arg =~ /^($Ident)$/s) {
Andy Whitcroft8905a672007-11-28 16:21:06 -08002865
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07002866 possible($1, "D:" . $s);
Andy Whitcroft8905a672007-11-28 16:21:06 -08002867 }
2868 }
2869 }
2870
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07002871 }
2872
Andy Whitcroft653d4872007-06-23 17:16:34 -07002873#
2874# Checks which may be anchored in the context.
2875#
2876
2877# Check for switch () and associated case and default
2878# statements should be at the same indent.
Andy Whitcroft00df3442007-06-08 13:47:06 -07002879 if ($line=~/\bswitch\s*\(.*\)/) {
2880 my $err = '';
2881 my $sep = '';
2882 my @ctx = ctx_block_outer($linenr, $realcnt);
2883 shift(@ctx);
2884 for my $ctx (@ctx) {
2885 my ($clen, $cindent) = line_stats($ctx);
2886 if ($ctx =~ /^\+\s*(case\s+|default:)/ &&
2887 $indent != $cindent) {
2888 $err .= "$sep$ctx\n";
2889 $sep = '';
2890 } else {
2891 $sep = "[...]\n";
2892 }
2893 }
2894 if ($err ne '') {
Joe Perches000d1cc12011-07-25 17:13:25 -07002895 ERROR("SWITCH_CASE_INDENT_LEVEL",
2896 "switch and case should be at the same indent\n$hereline$err");
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07002897 }
2898 }
2899
2900# if/while/etc brace do not go on next line, unless defining a do while loop,
2901# or if that brace on the next line is for something else
Joe Perches0fe3dc22014-08-06 16:11:16 -07002902 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 -07002903 my $pre_ctx = "$1$2";
2904
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07002905 my ($level, @ctx) = ctx_statement_level($linenr, $realcnt, 0);
Joe Perches8eef05d2012-02-03 15:20:39 -08002906
2907 if ($line =~ /^\+\t{6,}/) {
2908 WARN("DEEP_INDENTATION",
2909 "Too many leading tabs - consider code refactoring\n" . $herecurr);
2910 }
2911
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07002912 my $ctx_cnt = $realcnt - $#ctx - 1;
2913 my $ctx = join("\n", @ctx);
2914
Andy Whitcroft548596d2008-07-23 21:29:01 -07002915 my $ctx_ln = $linenr;
2916 my $ctx_skip = $realcnt;
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07002917
Andy Whitcroft548596d2008-07-23 21:29:01 -07002918 while ($ctx_skip > $ctx_cnt || ($ctx_skip == $ctx_cnt &&
2919 defined $lines[$ctx_ln - 1] &&
2920 $lines[$ctx_ln - 1] =~ /^-/)) {
2921 ##print "SKIP<$ctx_skip> CNT<$ctx_cnt>\n";
2922 $ctx_skip-- if (!defined $lines[$ctx_ln - 1] || $lines[$ctx_ln - 1] !~ /^-/);
Andy Whitcroft773647a2008-03-28 14:15:58 -07002923 $ctx_ln++;
2924 }
Andy Whitcroft548596d2008-07-23 21:29:01 -07002925
Andy Whitcroft53210162008-07-23 21:29:03 -07002926 #print "realcnt<$realcnt> ctx_cnt<$ctx_cnt>\n";
2927 #print "pre<$pre_ctx>\nline<$line>\nctx<$ctx>\nnext<$lines[$ctx_ln - 1]>\n";
Andy Whitcroft773647a2008-03-28 14:15:58 -07002928
Joe Perchesd752fcc2014-08-06 16:11:05 -07002929 if ($ctx !~ /{\s*/ && defined($lines[$ctx_ln - 1]) && $lines[$ctx_ln - 1] =~ /^\+\s*{/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07002930 ERROR("OPEN_BRACE",
2931 "that open brace { should be on the previous line\n" .
Andy Whitcroft01464f32010-10-26 14:23:19 -07002932 "$here\n$ctx\n$rawlines[$ctx_ln - 1]\n");
Andy Whitcroft00df3442007-06-08 13:47:06 -07002933 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07002934 if ($level == 0 && $pre_ctx !~ /}\s*while\s*\($/ &&
2935 $ctx =~ /\)\s*\;\s*$/ &&
2936 defined $lines[$ctx_ln - 1])
2937 {
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07002938 my ($nlength, $nindent) = line_stats($lines[$ctx_ln - 1]);
2939 if ($nindent > $indent) {
Joe Perches000d1cc12011-07-25 17:13:25 -07002940 WARN("TRAILING_SEMICOLON",
2941 "trailing semicolon indicates no statements, indent implies otherwise\n" .
Andy Whitcroft01464f32010-10-26 14:23:19 -07002942 "$here\n$ctx\n$rawlines[$ctx_ln - 1]\n");
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07002943 }
2944 }
Andy Whitcroft00df3442007-06-08 13:47:06 -07002945 }
2946
Andy Whitcroft4d001e42008-10-15 22:02:21 -07002947# Check relative indent for conditionals and blocks.
Joe Perches0fe3dc22014-08-06 16:11:16 -07002948 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 -08002949 ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
2950 ctx_statement_block($linenr, $realcnt, 0)
2951 if (!defined $stat);
Andy Whitcroft4d001e42008-10-15 22:02:21 -07002952 my ($s, $c) = ($stat, $cond);
2953
2954 substr($s, 0, length($c), '');
2955
2956 # Make sure we remove the line prefixes as we have
2957 # none on the first line, and are going to readd them
2958 # where necessary.
2959 $s =~ s/\n./\n/gs;
2960
2961 # Find out how long the conditional actually is.
Andy Whitcroft6f779c12008-10-15 22:02:27 -07002962 my @newlines = ($c =~ /\n/gs);
2963 my $cond_lines = 1 + $#newlines;
Andy Whitcroft4d001e42008-10-15 22:02:21 -07002964
2965 # We want to check the first line inside the block
2966 # starting at the end of the conditional, so remove:
2967 # 1) any blank line termination
2968 # 2) any opening brace { on end of the line
2969 # 3) any do (...) {
2970 my $continuation = 0;
2971 my $check = 0;
2972 $s =~ s/^.*\bdo\b//;
2973 $s =~ s/^\s*{//;
2974 if ($s =~ s/^\s*\\//) {
2975 $continuation = 1;
2976 }
Andy Whitcroft9bd49ef2008-10-15 22:02:22 -07002977 if ($s =~ s/^\s*?\n//) {
Andy Whitcroft4d001e42008-10-15 22:02:21 -07002978 $check = 1;
2979 $cond_lines++;
2980 }
2981
2982 # Also ignore a loop construct at the end of a
2983 # preprocessor statement.
2984 if (($prevline =~ /^.\s*#\s*define\s/ ||
2985 $prevline =~ /\\\s*$/) && $continuation == 0) {
2986 $check = 0;
2987 }
2988
Andy Whitcroft9bd49ef2008-10-15 22:02:22 -07002989 my $cond_ptr = -1;
Andy Whitcroft740504c2008-10-15 22:02:35 -07002990 $continuation = 0;
Andy Whitcroft9bd49ef2008-10-15 22:02:22 -07002991 while ($cond_ptr != $cond_lines) {
2992 $cond_ptr = $cond_lines;
Andy Whitcroft4d001e42008-10-15 22:02:21 -07002993
Andy Whitcroftf16fa282008-10-15 22:02:32 -07002994 # If we see an #else/#elif then the code
2995 # is not linear.
2996 if ($s =~ /^\s*\#\s*(?:else|elif)/) {
2997 $check = 0;
2998 }
2999
Andy Whitcroft9bd49ef2008-10-15 22:02:22 -07003000 # Ignore:
3001 # 1) blank lines, they should be at 0,
3002 # 2) preprocessor lines, and
3003 # 3) labels.
Andy Whitcroft740504c2008-10-15 22:02:35 -07003004 if ($continuation ||
3005 $s =~ /^\s*?\n/ ||
Andy Whitcroft9bd49ef2008-10-15 22:02:22 -07003006 $s =~ /^\s*#\s*?/ ||
3007 $s =~ /^\s*$Ident\s*:/) {
Andy Whitcroft740504c2008-10-15 22:02:35 -07003008 $continuation = ($s =~ /^.*?\\\n/) ? 1 : 0;
Andy Whitcroft30dad6e2009-09-21 17:04:36 -07003009 if ($s =~ s/^.*?\n//) {
3010 $cond_lines++;
3011 }
Andy Whitcroft9bd49ef2008-10-15 22:02:22 -07003012 }
Andy Whitcroft4d001e42008-10-15 22:02:21 -07003013 }
3014
3015 my (undef, $sindent) = line_stats("+" . $s);
3016 my $stat_real = raw_line($linenr, $cond_lines);
3017
3018 # Check if either of these lines are modified, else
3019 # this is not this patch's fault.
3020 if (!defined($stat_real) ||
3021 $stat !~ /^\+/ && $stat_real !~ /^\+/) {
3022 $check = 0;
3023 }
3024 if (defined($stat_real) && $cond_lines > 1) {
3025 $stat_real = "[...]\n$stat_real";
3026 }
3027
Andy Whitcroft9bd49ef2008-10-15 22:02:22 -07003028 #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 -07003029
3030 if ($check && (($sindent % 8) != 0 ||
3031 ($sindent <= $indent && $s ne ''))) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003032 WARN("SUSPECT_CODE_INDENT",
3033 "suspect code indent for conditional statements ($indent, $sindent)\n" . $herecurr . "$stat_real\n");
Andy Whitcroft4d001e42008-10-15 22:02:21 -07003034 }
3035 }
3036
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07003037 # Track the 'values' across context and added lines.
3038 my $opline = $line; $opline =~ s/^./ /;
Andy Whitcroft1f65f942008-07-23 21:29:10 -07003039 my ($curr_values, $curr_vars) =
3040 annotate_values($opline . "\n", $prev_values);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07003041 $curr_values = $prev_values . $curr_values;
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08003042 if ($dbg_values) {
3043 my $outline = $opline; $outline =~ s/\t/ /g;
Andy Whitcroftcf655042008-03-04 14:28:20 -08003044 print "$linenr > .$outline\n";
3045 print "$linenr > $curr_values\n";
Andy Whitcroft1f65f942008-07-23 21:29:10 -07003046 print "$linenr > $curr_vars\n";
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08003047 }
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07003048 $prev_values = substr($curr_values, -1);
3049
Andy Whitcroft00df3442007-06-08 13:47:06 -07003050#ignore lines not being added
Joe Perches3705ce52013-07-03 15:05:31 -07003051 next if ($line =~ /^[^\+]/);
Andy Whitcroft00df3442007-06-08 13:47:06 -07003052
Andy Whitcroft653d4872007-06-23 17:16:34 -07003053# TEST: allow direct testing of the type matcher.
Andy Whitcroft7429c692008-07-23 21:29:06 -07003054 if ($dbg_type) {
3055 if ($line =~ /^.\s*$Declare\s*$/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003056 ERROR("TEST_TYPE",
3057 "TEST: is type\n" . $herecurr);
Andy Whitcroft7429c692008-07-23 21:29:06 -07003058 } elsif ($dbg_type > 1 && $line =~ /^.+($Declare)/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003059 ERROR("TEST_NOT_TYPE",
3060 "TEST: is not type ($1 is)\n". $herecurr);
Andy Whitcroft7429c692008-07-23 21:29:06 -07003061 }
Andy Whitcroft653d4872007-06-23 17:16:34 -07003062 next;
3063 }
Andy Whitcrofta1ef2772008-10-15 22:02:17 -07003064# TEST: allow direct testing of the attribute matcher.
3065 if ($dbg_attr) {
Andy Whitcroft9360b0e2009-02-27 14:03:08 -08003066 if ($line =~ /^.\s*$Modifier\s*$/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003067 ERROR("TEST_ATTR",
3068 "TEST: is attr\n" . $herecurr);
Andy Whitcroft9360b0e2009-02-27 14:03:08 -08003069 } elsif ($dbg_attr > 1 && $line =~ /^.+($Modifier)/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003070 ERROR("TEST_NOT_ATTR",
3071 "TEST: is not attr ($1 is)\n". $herecurr);
Andy Whitcrofta1ef2772008-10-15 22:02:17 -07003072 }
3073 next;
3074 }
Andy Whitcroft653d4872007-06-23 17:16:34 -07003075
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07003076# check for initialisation to aggregates open brace on the next line
Andy Whitcroft99423c22009-10-26 16:50:15 -07003077 if ($line =~ /^.\s*{/ &&
3078 $prevline =~ /(?:^|[^=])=\s*$/) {
Joe Perchesd752fcc2014-08-06 16:11:05 -07003079 if (ERROR("OPEN_BRACE",
3080 "that open brace { should be on the previous line\n" . $hereprev) &&
Joe Perchesf2d7e4d2014-08-06 16:11:07 -07003081 $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
3082 fix_delete_line($fixlinenr - 1, $prevrawline);
3083 fix_delete_line($fixlinenr, $rawline);
Joe Perchesd752fcc2014-08-06 16:11:05 -07003084 my $fixedline = $prevrawline;
3085 $fixedline =~ s/\s*=\s*$/ = {/;
Joe Perchesf2d7e4d2014-08-06 16:11:07 -07003086 fix_insert_line($fixlinenr, $fixedline);
Joe Perchesd752fcc2014-08-06 16:11:05 -07003087 $fixedline = $line;
3088 $fixedline =~ s/^(.\s*){\s*/$1/;
Joe Perchesf2d7e4d2014-08-06 16:11:07 -07003089 fix_insert_line($fixlinenr, $fixedline);
Joe Perchesd752fcc2014-08-06 16:11:05 -07003090 }
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07003091 }
3092
Andy Whitcroft653d4872007-06-23 17:16:34 -07003093#
3094# Checks which are anchored on the added line.
3095#
3096
3097# check for malformed paths in #include statements (uses RAW line)
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07003098 if ($rawline =~ m{^.\s*\#\s*include\s+[<"](.*)[">]}) {
Andy Whitcroft653d4872007-06-23 17:16:34 -07003099 my $path = $1;
3100 if ($path =~ m{//}) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003101 ERROR("MALFORMED_INCLUDE",
Joe Perches495e9d82012-12-20 15:05:37 -08003102 "malformed #include filename\n" . $herecurr);
3103 }
3104 if ($path =~ "^uapi/" && $realfile =~ m@\binclude/uapi/@) {
3105 ERROR("UAPI_INCLUDE",
3106 "No #include in ...include/uapi/... should use a uapi/ path prefix\n" . $herecurr);
Andy Whitcroft653d4872007-06-23 17:16:34 -07003107 }
Andy Whitcroft653d4872007-06-23 17:16:34 -07003108 }
Andy Whitcroft00df3442007-06-08 13:47:06 -07003109
3110# no C99 // comments
3111 if ($line =~ m{//}) {
Joe Perches3705ce52013-07-03 15:05:31 -07003112 if (ERROR("C99_COMMENTS",
3113 "do not use C99 // comments\n" . $herecurr) &&
3114 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07003115 my $line = $fixed[$fixlinenr];
Joe Perches3705ce52013-07-03 15:05:31 -07003116 if ($line =~ /\/\/(.*)$/) {
3117 my $comment = trim($1);
Joe Perches194f66f2014-08-06 16:11:03 -07003118 $fixed[$fixlinenr] =~ s@\/\/(.*)$@/\* $comment \*/@;
Joe Perches3705ce52013-07-03 15:05:31 -07003119 }
3120 }
Andy Whitcroft00df3442007-06-08 13:47:06 -07003121 }
3122 # Remove C99 comments.
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003123 $line =~ s@//.*@@;
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07003124 $opline =~ s@//.*@@;
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003125
Andy Whitcroft2b474a12009-10-26 16:50:16 -07003126# EXPORT_SYMBOL should immediately follow the thing it is exporting, consider
3127# the whole statement.
3128#print "APW <$lines[$realline_next - 1]>\n";
3129 if (defined $realline_next &&
3130 exists $lines[$realline_next - 1] &&
3131 !defined $suppress_export{$realline_next} &&
3132 ($lines[$realline_next - 1] =~ /EXPORT_SYMBOL.*\((.*)\)/ ||
3133 $lines[$realline_next - 1] =~ /EXPORT_UNUSED_SYMBOL.*\((.*)\)/)) {
Andy Whitcroft3cbf62d2010-10-26 14:23:18 -07003134 # Handle definitions which produce identifiers with
3135 # a prefix:
3136 # XXX(foo);
3137 # EXPORT_SYMBOL(something_foo);
Andy Whitcroft653d4872007-06-23 17:16:34 -07003138 my $name = $1;
Andy Whitcroft87a53872012-01-10 15:10:04 -08003139 if ($stat =~ /^(?:.\s*}\s*\n)?.([A-Z_]+)\s*\(\s*($Ident)/ &&
Andy Whitcroft3cbf62d2010-10-26 14:23:18 -07003140 $name =~ /^${Ident}_$2/) {
3141#print "FOO C name<$name>\n";
3142 $suppress_export{$realline_next} = 1;
3143
3144 } elsif ($stat !~ /(?:
Andy Whitcroft2b474a12009-10-26 16:50:16 -07003145 \n.}\s*$|
Andy Whitcroft48012052008-10-15 22:02:34 -07003146 ^.DEFINE_$Ident\(\Q$name\E\)|
3147 ^.DECLARE_$Ident\(\Q$name\E\)|
3148 ^.LIST_HEAD\(\Q$name\E\)|
Andy Whitcroft2b474a12009-10-26 16:50:16 -07003149 ^.(?:$Storage\s+)?$Type\s*\(\s*\*\s*\Q$name\E\s*\)\s*\(|
3150 \b\Q$name\E(?:\s+$Attribute)*\s*(?:;|=|\[|\()
Andy Whitcroft48012052008-10-15 22:02:34 -07003151 )/x) {
Andy Whitcroft2b474a12009-10-26 16:50:16 -07003152#print "FOO A<$lines[$realline_next - 1]> stat<$stat> name<$name>\n";
3153 $suppress_export{$realline_next} = 2;
3154 } else {
3155 $suppress_export{$realline_next} = 1;
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003156 }
3157 }
Andy Whitcroft2b474a12009-10-26 16:50:16 -07003158 if (!defined $suppress_export{$linenr} &&
3159 $prevline =~ /^.\s*$/ &&
3160 ($line =~ /EXPORT_SYMBOL.*\((.*)\)/ ||
3161 $line =~ /EXPORT_UNUSED_SYMBOL.*\((.*)\)/)) {
3162#print "FOO B <$lines[$linenr - 1]>\n";
3163 $suppress_export{$linenr} = 2;
3164 }
3165 if (defined $suppress_export{$linenr} &&
3166 $suppress_export{$linenr} == 2) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003167 WARN("EXPORT_SYMBOL",
3168 "EXPORT_SYMBOL(foo); should immediately follow its function/variable\n" . $herecurr);
Andy Whitcroft2b474a12009-10-26 16:50:16 -07003169 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003170
Joe Eloff5150bda2010-08-09 17:21:00 -07003171# check for global initialisers.
Joe Perches5129e872015-06-10 11:14:52 -07003172 if ($line =~ /^\+$Type\s*$Ident(?:\s+$Modifier)*\s*=\s*(?:0|NULL|false)\s*;/) {
Joe Perchesd5e616f2013-09-11 14:23:54 -07003173 if (ERROR("GLOBAL_INITIALISERS",
3174 "do not initialise globals to 0 or NULL\n" .
3175 $herecurr) &&
3176 $fix) {
Joe Perches5129e872015-06-10 11:14:52 -07003177 $fixed[$fixlinenr] =~ s/(^.$Type\s*$Ident(?:\s+$Modifier)*)\s*=\s*(0|NULL|false)\s*;/$1;/;
Joe Perchesd5e616f2013-09-11 14:23:54 -07003178 }
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07003179 }
Andy Whitcroft653d4872007-06-23 17:16:34 -07003180# check for static initialisers.
Joe Perchesd5e616f2013-09-11 14:23:54 -07003181 if ($line =~ /^\+.*\bstatic\s.*=\s*(0|NULL|false)\s*;/) {
3182 if (ERROR("INITIALISED_STATIC",
3183 "do not initialise statics to 0 or NULL\n" .
3184 $herecurr) &&
3185 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07003186 $fixed[$fixlinenr] =~ s/(\bstatic\s.*?)\s*=\s*(0|NULL|false)\s*;/$1;/;
Joe Perchesd5e616f2013-09-11 14:23:54 -07003187 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003188 }
3189
Joe Perches18130872014-08-06 16:11:22 -07003190# check for misordered declarations of char/short/int/long with signed/unsigned
3191 while ($sline =~ m{(\b$TypeMisordered\b)}g) {
3192 my $tmp = trim($1);
3193 WARN("MISORDERED_TYPE",
3194 "type '$tmp' should be specified in [[un]signed] [short|int|long|long long] order\n" . $herecurr);
3195 }
3196
Joe Perchescb710ec2010-10-26 14:23:20 -07003197# check for static const char * arrays.
3198 if ($line =~ /\bstatic\s+const\s+char\s*\*\s*(\w+)\s*\[\s*\]\s*=\s*/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003199 WARN("STATIC_CONST_CHAR_ARRAY",
3200 "static const char * array should probably be static const char * const\n" .
Joe Perchescb710ec2010-10-26 14:23:20 -07003201 $herecurr);
3202 }
3203
3204# check for static char foo[] = "bar" declarations.
3205 if ($line =~ /\bstatic\s+char\s+(\w+)\s*\[\s*\]\s*=\s*"/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003206 WARN("STATIC_CONST_CHAR_ARRAY",
3207 "static char array declaration should probably be static const char\n" .
Joe Perchescb710ec2010-10-26 14:23:20 -07003208 $herecurr);
3209 }
3210
Joe Perchesab7e23f2015-04-16 12:44:22 -07003211# check for const <foo> const where <foo> is not a pointer or array type
3212 if ($sline =~ /\bconst\s+($BasicType)\s+const\b/) {
3213 my $found = $1;
3214 if ($sline =~ /\bconst\s+\Q$found\E\s+const\b\s*\*/) {
3215 WARN("CONST_CONST",
3216 "'const $found const *' should probably be 'const $found * const'\n" . $herecurr);
3217 } elsif ($sline !~ /\bconst\s+\Q$found\E\s+const\s+\w+\s*\[/) {
3218 WARN("CONST_CONST",
3219 "'const $found const' should probably be 'const $found'\n" . $herecurr);
3220 }
3221 }
3222
Joe Perches9b0fa602014-04-03 14:49:18 -07003223# check for non-global char *foo[] = {"bar", ...} declarations.
3224 if ($line =~ /^.\s+(?:static\s+|const\s+)?char\s+\*\s*\w+\s*\[\s*\]\s*=\s*\{/) {
3225 WARN("STATIC_CONST_CHAR_ARRAY",
3226 "char * array declaration might be better as static const\n" .
3227 $herecurr);
3228 }
3229
Joe Perchesb598b672015-04-16 12:44:36 -07003230# check for sizeof(foo)/sizeof(foo[0]) that could be ARRAY_SIZE(foo)
3231 if ($line =~ m@\bsizeof\s*\(\s*($Lval)\s*\)@) {
3232 my $array = $1;
3233 if ($line =~ m@\b(sizeof\s*\(\s*\Q$array\E\s*\)\s*/\s*sizeof\s*\(\s*\Q$array\E\s*\[\s*0\s*\]\s*\))@) {
3234 my $array_div = $1;
3235 if (WARN("ARRAY_SIZE",
3236 "Prefer ARRAY_SIZE($array)\n" . $herecurr) &&
3237 $fix) {
3238 $fixed[$fixlinenr] =~ s/\Q$array_div\E/ARRAY_SIZE($array)/;
3239 }
3240 }
3241 }
3242
Joe Perchesb36190c2014-01-27 17:07:18 -08003243# check for function declarations without arguments like "int foo()"
3244 if ($line =~ /(\b$Type\s+$Ident)\s*\(\s*\)/) {
3245 if (ERROR("FUNCTION_WITHOUT_ARGS",
3246 "Bad function definition - $1() should probably be $1(void)\n" . $herecurr) &&
3247 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07003248 $fixed[$fixlinenr] =~ s/(\b($Type)\s+($Ident))\s*\(\s*\)/$2 $3(void)/;
Joe Perchesb36190c2014-01-27 17:07:18 -08003249 }
3250 }
3251
Joe Perches92e112f2013-12-13 11:36:22 -07003252# check for uses of DEFINE_PCI_DEVICE_TABLE
3253 if ($line =~ /\bDEFINE_PCI_DEVICE_TABLE\s*\(\s*(\w+)\s*\)\s*=/) {
3254 if (WARN("DEFINE_PCI_DEVICE_TABLE",
3255 "Prefer struct pci_device_id over deprecated DEFINE_PCI_DEVICE_TABLE\n" . $herecurr) &&
3256 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07003257 $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 -07003258 }
Joe Perches93ed0e22010-10-26 14:23:21 -07003259 }
3260
Andy Whitcroft653d4872007-06-23 17:16:34 -07003261# check for new typedefs, only function parameters and sparse annotations
3262# make sense.
3263 if ($line =~ /\btypedef\s/ &&
Andy Whitcroft80545762009-01-06 14:41:26 -08003264 $line !~ /\btypedef\s+$Type\s*\(\s*\*?$Ident\s*\)\s*\(/ &&
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07003265 $line !~ /\btypedef\s+$Type\s+$Ident\s*\(/ &&
Andy Whitcroft8ed22ca2008-10-15 22:02:32 -07003266 $line !~ /\b$typeTypedefs\b/ &&
Joe Perches021158b2015-02-13 14:38:43 -08003267 $line !~ /\b$typeOtherOSTypedefs\b/ &&
Andy Whitcroft653d4872007-06-23 17:16:34 -07003268 $line !~ /\b__bitwise(?:__|)\b/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003269 WARN("NEW_TYPEDEFS",
3270 "do not add new typedefs\n" . $herecurr);
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003271 }
3272
3273# * goes on variable not on type
Andy Whitcroft65863862009-01-06 14:41:21 -08003274 # (char*[ const])
Andy Whitcroftbfcb2cc2012-01-10 15:10:15 -08003275 while ($line =~ m{(\($NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)\))}g) {
3276 #print "AA<$1>\n";
Joe Perches3705ce52013-07-03 15:05:31 -07003277 my ($ident, $from, $to) = ($1, $2, $2);
Andy Whitcroftd8aaf122007-06-23 17:16:44 -07003278
Andy Whitcroft65863862009-01-06 14:41:21 -08003279 # Should start with a space.
3280 $to =~ s/^(\S)/ $1/;
3281 # Should not end with a space.
3282 $to =~ s/\s+$//;
3283 # '*'s should not have spaces between.
Andy Whitcroftf9a0b3d2009-01-15 13:51:05 -08003284 while ($to =~ s/\*\s+\*/\*\*/) {
Andy Whitcroft65863862009-01-06 14:41:21 -08003285 }
Andy Whitcroftd8aaf122007-06-23 17:16:44 -07003286
Joe Perches3705ce52013-07-03 15:05:31 -07003287## print "1: from<$from> to<$to> ident<$ident>\n";
Andy Whitcroft65863862009-01-06 14:41:21 -08003288 if ($from ne $to) {
Joe Perches3705ce52013-07-03 15:05:31 -07003289 if (ERROR("POINTER_LOCATION",
3290 "\"(foo$from)\" should be \"(foo$to)\"\n" . $herecurr) &&
3291 $fix) {
3292 my $sub_from = $ident;
3293 my $sub_to = $ident;
3294 $sub_to =~ s/\Q$from\E/$to/;
Joe Perches194f66f2014-08-06 16:11:03 -07003295 $fixed[$fixlinenr] =~
Joe Perches3705ce52013-07-03 15:05:31 -07003296 s@\Q$sub_from\E@$sub_to@;
3297 }
Andy Whitcroft65863862009-01-06 14:41:21 -08003298 }
Andy Whitcroftbfcb2cc2012-01-10 15:10:15 -08003299 }
3300 while ($line =~ m{(\b$NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)($Ident))}g) {
3301 #print "BB<$1>\n";
Joe Perches3705ce52013-07-03 15:05:31 -07003302 my ($match, $from, $to, $ident) = ($1, $2, $2, $3);
Andy Whitcroftd8aaf122007-06-23 17:16:44 -07003303
Andy Whitcroft65863862009-01-06 14:41:21 -08003304 # Should start with a space.
3305 $to =~ s/^(\S)/ $1/;
3306 # Should not end with a space.
3307 $to =~ s/\s+$//;
3308 # '*'s should not have spaces between.
Andy Whitcroftf9a0b3d2009-01-15 13:51:05 -08003309 while ($to =~ s/\*\s+\*/\*\*/) {
Andy Whitcroft65863862009-01-06 14:41:21 -08003310 }
3311 # Modifiers should have spaces.
3312 $to =~ s/(\b$Modifier$)/$1 /;
3313
Joe Perches3705ce52013-07-03 15:05:31 -07003314## print "2: from<$from> to<$to> ident<$ident>\n";
Andy Whitcroft667026e2009-02-27 14:03:08 -08003315 if ($from ne $to && $ident !~ /^$Modifier$/) {
Joe Perches3705ce52013-07-03 15:05:31 -07003316 if (ERROR("POINTER_LOCATION",
3317 "\"foo${from}bar\" should be \"foo${to}bar\"\n" . $herecurr) &&
3318 $fix) {
3319
3320 my $sub_from = $match;
3321 my $sub_to = $match;
3322 $sub_to =~ s/\Q$from\E/$to/;
Joe Perches194f66f2014-08-06 16:11:03 -07003323 $fixed[$fixlinenr] =~
Joe Perches3705ce52013-07-03 15:05:31 -07003324 s@\Q$sub_from\E@$sub_to@;
3325 }
Andy Whitcroft65863862009-01-06 14:41:21 -08003326 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003327 }
3328
3329# # no BUG() or BUG_ON()
3330# if ($line =~ /\b(BUG|BUG_ON)\b/) {
3331# print "Try to use WARN_ON & Recovery code rather than BUG() or BUG_ON()\n";
3332# print "$herecurr";
3333# $clean = 0;
3334# }
3335
Andy Whitcroft8905a672007-11-28 16:21:06 -08003336 if ($line =~ /\bLINUX_VERSION_CODE\b/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003337 WARN("LINUX_VERSION_CODE",
3338 "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 -08003339 }
3340
Joe Perches17441222011-06-15 15:08:17 -07003341# check for uses of printk_ratelimit
3342 if ($line =~ /\bprintk_ratelimit\s*\(/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003343 WARN("PRINTK_RATELIMITED",
Joe Perches101ee682015-02-13 14:38:54 -08003344 "Prefer printk_ratelimited or pr_<level>_ratelimited to printk_ratelimit\n" . $herecurr);
Joe Perches17441222011-06-15 15:08:17 -07003345 }
3346
Andy Whitcroft00df3442007-06-08 13:47:06 -07003347# printk should use KERN_* levels. Note that follow on printk's on the
3348# same line do not need a level, so we use the current block context
3349# to try and find and validate the current printk. In summary the current
Lucas De Marchi25985ed2011-03-30 22:57:33 -03003350# printk includes all preceding printk's which have no newline on the end.
Andy Whitcroft00df3442007-06-08 13:47:06 -07003351# we assume the first bad printk is the one to report.
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07003352 if ($line =~ /\bprintk\((?!KERN_)\s*"/) {
Andy Whitcroft00df3442007-06-08 13:47:06 -07003353 my $ok = 0;
3354 for (my $ln = $linenr - 1; $ln >= $first_line; $ln--) {
3355 #print "CHECK<$lines[$ln - 1]\n";
Lucas De Marchi25985ed2011-03-30 22:57:33 -03003356 # we have a preceding printk if it ends
Andy Whitcroft00df3442007-06-08 13:47:06 -07003357 # with "\n" ignore it, else it is to blame
3358 if ($lines[$ln - 1] =~ m{\bprintk\(}) {
3359 if ($rawlines[$ln - 1] !~ m{\\n"}) {
3360 $ok = 1;
3361 }
3362 last;
3363 }
3364 }
3365 if ($ok == 0) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003366 WARN("PRINTK_WITHOUT_KERN_LEVEL",
3367 "printk() should include KERN_ facility level\n" . $herecurr);
Andy Whitcroft00df3442007-06-08 13:47:06 -07003368 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003369 }
3370
Joe Perches243f3802012-05-31 16:26:09 -07003371 if ($line =~ /\bprintk\s*\(\s*KERN_([A-Z]+)/) {
3372 my $orig = $1;
3373 my $level = lc($orig);
3374 $level = "warn" if ($level eq "warning");
Joe Perches8f26b832012-10-04 17:13:32 -07003375 my $level2 = $level;
3376 $level2 = "dbg" if ($level eq "debug");
Joe Perches243f3802012-05-31 16:26:09 -07003377 WARN("PREFER_PR_LEVEL",
Yogesh Chaudharidaa8b052014-04-03 14:49:23 -07003378 "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 -07003379 }
3380
3381 if ($line =~ /\bpr_warning\s*\(/) {
Joe Perchesd5e616f2013-09-11 14:23:54 -07003382 if (WARN("PREFER_PR_LEVEL",
3383 "Prefer pr_warn(... to pr_warning(...\n" . $herecurr) &&
3384 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07003385 $fixed[$fixlinenr] =~
Joe Perchesd5e616f2013-09-11 14:23:54 -07003386 s/\bpr_warning\b/pr_warn/;
3387 }
Joe Perches243f3802012-05-31 16:26:09 -07003388 }
3389
Joe Perchesdc139312013-02-21 16:44:13 -08003390 if ($line =~ /\bdev_printk\s*\(\s*KERN_([A-Z]+)/) {
3391 my $orig = $1;
3392 my $level = lc($orig);
3393 $level = "warn" if ($level eq "warning");
3394 $level = "dbg" if ($level eq "debug");
3395 WARN("PREFER_DEV_LEVEL",
3396 "Prefer dev_$level(... to dev_printk(KERN_$orig, ...\n" . $herecurr);
3397 }
3398
Andy Lutomirski91c9afa2015-04-16 12:44:44 -07003399# ENOSYS means "bad syscall nr" and nothing else. This will have a small
3400# number of false positives, but assembly files are not checked, so at
3401# least the arch entry code will not trigger this warning.
3402 if ($line =~ /\bENOSYS\b/) {
3403 WARN("ENOSYS",
3404 "ENOSYS means 'invalid syscall nr' and nothing else\n" . $herecurr);
3405 }
3406
Andy Whitcroft653d4872007-06-23 17:16:34 -07003407# function brace can't be on same line, except for #defines of do while,
3408# or if closed on same line
Joe Perches8d182472014-08-06 16:11:12 -07003409 if (($line=~/$Type\s*$Ident\(.*\).*\s*{/) and
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07003410 !($line=~/\#\s*define.*do\s{/) and !($line=~/}/)) {
Joe Perches8d182472014-08-06 16:11:12 -07003411 if (ERROR("OPEN_BRACE",
3412 "open brace '{' following function declarations go on the next line\n" . $herecurr) &&
3413 $fix) {
3414 fix_delete_line($fixlinenr, $rawline);
3415 my $fixed_line = $rawline;
3416 $fixed_line =~ /(^..*$Type\s*$Ident\(.*\)\s*){(.*)$/;
3417 my $line1 = $1;
3418 my $line2 = $2;
3419 fix_insert_line($fixlinenr, ltrim($line1));
3420 fix_insert_line($fixlinenr, "\+{");
3421 if ($line2 !~ /^\s*$/) {
3422 fix_insert_line($fixlinenr, "\+\t" . trim($line2));
3423 }
3424 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003425 }
Andy Whitcroft653d4872007-06-23 17:16:34 -07003426
Andy Whitcroft8905a672007-11-28 16:21:06 -08003427# open braces for enum, union and struct go on the same line.
3428 if ($line =~ /^.\s*{/ &&
3429 $prevline =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident)?\s*$/) {
Joe Perches8d182472014-08-06 16:11:12 -07003430 if (ERROR("OPEN_BRACE",
3431 "open brace '{' following $1 go on the same line\n" . $hereprev) &&
3432 $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
3433 fix_delete_line($fixlinenr - 1, $prevrawline);
3434 fix_delete_line($fixlinenr, $rawline);
3435 my $fixedline = rtrim($prevrawline) . " {";
3436 fix_insert_line($fixlinenr, $fixedline);
3437 $fixedline = $rawline;
3438 $fixedline =~ s/^(.\s*){\s*/$1\t/;
3439 if ($fixedline !~ /^\+\s*$/) {
3440 fix_insert_line($fixlinenr, $fixedline);
3441 }
3442 }
Andy Whitcroft8905a672007-11-28 16:21:06 -08003443 }
3444
Andy Whitcroft0c73b4e2010-10-26 14:23:15 -07003445# missing space after union, struct or enum definition
Joe Perches3705ce52013-07-03 15:05:31 -07003446 if ($line =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident){1,2}[=\{]/) {
3447 if (WARN("SPACING",
3448 "missing space after $1 definition\n" . $herecurr) &&
3449 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07003450 $fixed[$fixlinenr] =~
Joe Perches3705ce52013-07-03 15:05:31 -07003451 s/^(.\s*(?:typedef\s+)?(?:enum|union|struct)(?:\s+$Ident){1,2})([=\{])/$1 $2/;
3452 }
Andy Whitcroft0c73b4e2010-10-26 14:23:15 -07003453 }
3454
Joe Perches31070b52014-01-23 15:54:49 -08003455# Function pointer declarations
3456# check spacing between type, funcptr, and args
3457# canonical declaration is "type (*funcptr)(args...)"
Joe Perches91f72e92014-04-03 14:49:12 -07003458 if ($line =~ /^.\s*($Declare)\((\s*)\*(\s*)($Ident)(\s*)\)(\s*)\(/) {
Joe Perches31070b52014-01-23 15:54:49 -08003459 my $declare = $1;
3460 my $pre_pointer_space = $2;
3461 my $post_pointer_space = $3;
3462 my $funcname = $4;
3463 my $post_funcname_space = $5;
3464 my $pre_args_space = $6;
3465
Joe Perches91f72e92014-04-03 14:49:12 -07003466# the $Declare variable will capture all spaces after the type
3467# so check it for a missing trailing missing space but pointer return types
3468# don't need a space so don't warn for those.
3469 my $post_declare_space = "";
3470 if ($declare =~ /(\s+)$/) {
3471 $post_declare_space = $1;
3472 $declare = rtrim($declare);
3473 }
3474 if ($declare !~ /\*$/ && $post_declare_space =~ /^$/) {
Joe Perches31070b52014-01-23 15:54:49 -08003475 WARN("SPACING",
3476 "missing space after return type\n" . $herecurr);
Joe Perches91f72e92014-04-03 14:49:12 -07003477 $post_declare_space = " ";
Joe Perches31070b52014-01-23 15:54:49 -08003478 }
3479
3480# unnecessary space "type (*funcptr)(args...)"
Joe Perches91f72e92014-04-03 14:49:12 -07003481# This test is not currently implemented because these declarations are
3482# equivalent to
3483# int foo(int bar, ...)
3484# and this is form shouldn't/doesn't generate a checkpatch warning.
3485#
3486# elsif ($declare =~ /\s{2,}$/) {
3487# WARN("SPACING",
3488# "Multiple spaces after return type\n" . $herecurr);
3489# }
Joe Perches31070b52014-01-23 15:54:49 -08003490
3491# unnecessary space "type ( *funcptr)(args...)"
3492 if (defined $pre_pointer_space &&
3493 $pre_pointer_space =~ /^\s/) {
3494 WARN("SPACING",
3495 "Unnecessary space after function pointer open parenthesis\n" . $herecurr);
3496 }
3497
3498# unnecessary space "type (* funcptr)(args...)"
3499 if (defined $post_pointer_space &&
3500 $post_pointer_space =~ /^\s/) {
3501 WARN("SPACING",
3502 "Unnecessary space before function pointer name\n" . $herecurr);
3503 }
3504
3505# unnecessary space "type (*funcptr )(args...)"
3506 if (defined $post_funcname_space &&
3507 $post_funcname_space =~ /^\s/) {
3508 WARN("SPACING",
3509 "Unnecessary space after function pointer name\n" . $herecurr);
3510 }
3511
3512# unnecessary space "type (*funcptr) (args...)"
3513 if (defined $pre_args_space &&
3514 $pre_args_space =~ /^\s/) {
3515 WARN("SPACING",
3516 "Unnecessary space before function pointer arguments\n" . $herecurr);
3517 }
3518
3519 if (show_type("SPACING") && $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07003520 $fixed[$fixlinenr] =~
Joe Perches91f72e92014-04-03 14:49:12 -07003521 s/^(.\s*)$Declare\s*\(\s*\*\s*$Ident\s*\)\s*\(/$1 . $declare . $post_declare_space . '(*' . $funcname . ')('/ex;
Joe Perches31070b52014-01-23 15:54:49 -08003522 }
3523 }
3524
Andy Whitcroft8d31cfc2008-07-23 21:29:02 -07003525# check for spacing round square brackets; allowed:
3526# 1. with a type on the left -- int [] a;
Andy Whitcroftfe2a7db2008-10-15 22:02:15 -07003527# 2. at the beginning of a line for slice initialisers -- [0...10] = 5,
3528# 3. inside a curly brace -- = { [0...10] = 5 }
Andy Whitcroft8d31cfc2008-07-23 21:29:02 -07003529 while ($line =~ /(.*?\s)\[/g) {
3530 my ($where, $prefix) = ($-[1], $1);
3531 if ($prefix !~ /$Type\s+$/ &&
Andy Whitcroftfe2a7db2008-10-15 22:02:15 -07003532 ($where != 0 || $prefix !~ /^.\s+$/) &&
Andy Whitcroftdaebc532012-03-23 15:02:17 -07003533 $prefix !~ /[{,]\s+$/) {
Joe Perches3705ce52013-07-03 15:05:31 -07003534 if (ERROR("BRACKET_SPACE",
3535 "space prohibited before open square bracket '['\n" . $herecurr) &&
3536 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07003537 $fixed[$fixlinenr] =~
Joe Perches3705ce52013-07-03 15:05:31 -07003538 s/^(\+.*?)\s+\[/$1\[/;
3539 }
Andy Whitcroft8d31cfc2008-07-23 21:29:02 -07003540 }
3541 }
3542
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07003543# check for spaces between functions and their parentheses.
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07003544 while ($line =~ /($Ident)\s+\(/g) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08003545 my $name = $1;
Andy Whitcroft773647a2008-03-28 14:15:58 -07003546 my $ctx_before = substr($line, 0, $-[1]);
3547 my $ctx = "$ctx_before$name";
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08003548
3549 # Ignore those directives where spaces _are_ permitted.
Andy Whitcroft773647a2008-03-28 14:15:58 -07003550 if ($name =~ /^(?:
3551 if|for|while|switch|return|case|
3552 volatile|__volatile__|
3553 __attribute__|format|__extension__|
3554 asm|__asm__)$/x)
3555 {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08003556 # cpp #define statements have non-optional spaces, ie
3557 # if there is a space between the name and the open
3558 # parenthesis it is simply not a parameter group.
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07003559 } elsif ($ctx_before =~ /^.\s*\#\s*define\s*$/) {
Andy Whitcroft773647a2008-03-28 14:15:58 -07003560
3561 # cpp #elif statement condition may start with a (
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07003562 } elsif ($ctx =~ /^.\s*\#\s*elif\s*$/) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08003563
3564 # If this whole things ends with a type its most
3565 # likely a typedef for a function.
Andy Whitcroft773647a2008-03-28 14:15:58 -07003566 } elsif ($ctx =~ /$Type$/) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08003567
3568 } else {
Joe Perches3705ce52013-07-03 15:05:31 -07003569 if (WARN("SPACING",
3570 "space prohibited between function name and open parenthesis '('\n" . $herecurr) &&
3571 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07003572 $fixed[$fixlinenr] =~
Joe Perches3705ce52013-07-03 15:05:31 -07003573 s/\b$name\s+\(/$name\(/;
3574 }
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07003575 }
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07003576 }
Eric Nelson9a4cad42012-05-31 16:26:09 -07003577
Andy Whitcroft653d4872007-06-23 17:16:34 -07003578# Check operator spacing.
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003579 if (!($line=~/\#\s*include/)) {
Joe Perches3705ce52013-07-03 15:05:31 -07003580 my $fixed_line = "";
3581 my $line_fixed = 0;
3582
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07003583 my $ops = qr{
3584 <<=|>>=|<=|>=|==|!=|
3585 \+=|-=|\*=|\/=|%=|\^=|\|=|&=|
3586 =>|->|<<|>>|<|>|=|!|~|
Andy Whitcroft1f65f942008-07-23 21:29:10 -07003587 &&|\|\||,|\^|\+\+|--|&|\||\+|-|\*|\/|%|
Joe Perches84731622013-11-12 15:10:05 -08003588 \?:|\?|:
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07003589 }x;
Andy Whitcroftcf655042008-03-04 14:28:20 -08003590 my @elements = split(/($ops|;)/, $opline);
Joe Perches3705ce52013-07-03 15:05:31 -07003591
3592## print("element count: <" . $#elements . ">\n");
3593## foreach my $el (@elements) {
3594## print("el: <$el>\n");
3595## }
3596
3597 my @fix_elements = ();
Andy Whitcroft00df3442007-06-08 13:47:06 -07003598 my $off = 0;
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07003599
Joe Perches3705ce52013-07-03 15:05:31 -07003600 foreach my $el (@elements) {
3601 push(@fix_elements, substr($rawline, $off, length($el)));
3602 $off += length($el);
3603 }
3604
3605 $off = 0;
3606
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07003607 my $blank = copy_spacing($opline);
Joe Perchesb34c6482013-09-11 14:24:01 -07003608 my $last_after = -1;
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07003609
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003610 for (my $n = 0; $n < $#elements; $n += 2) {
Joe Perches3705ce52013-07-03 15:05:31 -07003611
3612 my $good = $fix_elements[$n] . $fix_elements[$n + 1];
3613
3614## print("n: <$n> good: <$good>\n");
3615
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07003616 $off += length($elements[$n]);
3617
Lucas De Marchi25985ed2011-03-30 22:57:33 -03003618 # Pick up the preceding and succeeding characters.
Andy Whitcroft773647a2008-03-28 14:15:58 -07003619 my $ca = substr($opline, 0, $off);
3620 my $cc = '';
3621 if (length($opline) >= ($off + length($elements[$n + 1]))) {
3622 $cc = substr($opline, $off + length($elements[$n + 1]));
3623 }
3624 my $cb = "$ca$;$cc";
3625
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07003626 my $a = '';
3627 $a = 'V' if ($elements[$n] ne '');
3628 $a = 'W' if ($elements[$n] =~ /\s$/);
Andy Whitcroftcf655042008-03-04 14:28:20 -08003629 $a = 'C' if ($elements[$n] =~ /$;$/);
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07003630 $a = 'B' if ($elements[$n] =~ /(\[|\()$/);
3631 $a = 'O' if ($elements[$n] eq '');
Andy Whitcroft773647a2008-03-28 14:15:58 -07003632 $a = 'E' if ($ca =~ /^\s*$/);
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07003633
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003634 my $op = $elements[$n + 1];
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07003635
3636 my $c = '';
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003637 if (defined $elements[$n + 2]) {
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07003638 $c = 'V' if ($elements[$n + 2] ne '');
3639 $c = 'W' if ($elements[$n + 2] =~ /^\s/);
Andy Whitcroftcf655042008-03-04 14:28:20 -08003640 $c = 'C' if ($elements[$n + 2] =~ /^$;/);
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07003641 $c = 'B' if ($elements[$n + 2] =~ /^(\)|\]|;)/);
3642 $c = 'O' if ($elements[$n + 2] eq '');
Andy Whitcroft8b1b3372009-01-06 14:41:27 -08003643 $c = 'E' if ($elements[$n + 2] =~ /^\s*\\$/);
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07003644 } else {
3645 $c = 'E';
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003646 }
3647
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07003648 my $ctx = "${a}x${c}";
3649
3650 my $at = "(ctx:$ctx)";
3651
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07003652 my $ptr = substr($blank, 0, $off) . "^";
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07003653 my $hereptr = "$hereline$ptr\n";
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003654
Andy Whitcroft74048ed2008-07-23 21:29:10 -07003655 # Pull out the value of this operator.
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07003656 my $op_type = substr($curr_values, $off + 1, 1);
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003657
Andy Whitcroft1f65f942008-07-23 21:29:10 -07003658 # Get the full operator variant.
3659 my $opv = $op . substr($curr_vars, $off, 1);
3660
Andy Whitcroft13214ad2008-02-08 04:22:03 -08003661 # Ignore operators passed as parameters.
3662 if ($op_type ne 'V' &&
Sam Bobroffd7fe8062015-04-16 12:44:39 -07003663 $ca =~ /\s$/ && $cc =~ /^\s*[,\)]/) {
Andy Whitcroft13214ad2008-02-08 04:22:03 -08003664
Andy Whitcroftcf655042008-03-04 14:28:20 -08003665# # Ignore comments
3666# } elsif ($op =~ /^$;+$/) {
Andy Whitcroft13214ad2008-02-08 04:22:03 -08003667
Andy Whitcroftd8aaf122007-06-23 17:16:44 -07003668 # ; should have either the end of line or a space or \ after it
Andy Whitcroft13214ad2008-02-08 04:22:03 -08003669 } elsif ($op eq ';') {
Andy Whitcroftcf655042008-03-04 14:28:20 -08003670 if ($ctx !~ /.x[WEBC]/ &&
3671 $cc !~ /^\\/ && $cc !~ /^;/) {
Joe Perches3705ce52013-07-03 15:05:31 -07003672 if (ERROR("SPACING",
3673 "space required after that '$op' $at\n" . $hereptr)) {
Joe Perchesb34c6482013-09-11 14:24:01 -07003674 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";
Joe Perches3705ce52013-07-03 15:05:31 -07003675 $line_fixed = 1;
3676 }
Andy Whitcroftd8aaf122007-06-23 17:16:44 -07003677 }
3678
3679 # // is a comment
3680 } elsif ($op eq '//') {
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003681
Joe Perchesb00e4812014-04-03 14:49:33 -07003682 # : when part of a bitfield
3683 } elsif ($opv eq ':B') {
3684 # skip the bitfield test for now
3685
Andy Whitcroft1f65f942008-07-23 21:29:10 -07003686 # No spaces for:
3687 # ->
Joe Perchesb00e4812014-04-03 14:49:33 -07003688 } elsif ($op eq '->') {
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07003689 if ($ctx =~ /Wx.|.xW/) {
Joe Perches3705ce52013-07-03 15:05:31 -07003690 if (ERROR("SPACING",
3691 "spaces prohibited around that '$op' $at\n" . $hereptr)) {
Joe Perchesb34c6482013-09-11 14:24:01 -07003692 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
Joe Perches3705ce52013-07-03 15:05:31 -07003693 if (defined $fix_elements[$n + 2]) {
3694 $fix_elements[$n + 2] =~ s/^\s+//;
3695 }
Joe Perchesb34c6482013-09-11 14:24:01 -07003696 $line_fixed = 1;
Joe Perches3705ce52013-07-03 15:05:31 -07003697 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003698 }
3699
Joe Perches23810972014-12-10 15:51:32 -08003700 # , must not have a space before and must have a space on the right.
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003701 } elsif ($op eq ',') {
Joe Perches23810972014-12-10 15:51:32 -08003702 my $rtrim_before = 0;
3703 my $space_after = 0;
3704 if ($ctx =~ /Wx./) {
3705 if (ERROR("SPACING",
3706 "space prohibited before that '$op' $at\n" . $hereptr)) {
3707 $line_fixed = 1;
3708 $rtrim_before = 1;
3709 }
3710 }
Andy Whitcroftcf655042008-03-04 14:28:20 -08003711 if ($ctx !~ /.x[WEC]/ && $cc !~ /^}/) {
Joe Perches3705ce52013-07-03 15:05:31 -07003712 if (ERROR("SPACING",
3713 "space required after that '$op' $at\n" . $hereptr)) {
Joe Perches3705ce52013-07-03 15:05:31 -07003714 $line_fixed = 1;
Joe Perchesb34c6482013-09-11 14:24:01 -07003715 $last_after = $n;
Joe Perches23810972014-12-10 15:51:32 -08003716 $space_after = 1;
3717 }
3718 }
3719 if ($rtrim_before || $space_after) {
3720 if ($rtrim_before) {
3721 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
3722 } else {
3723 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]);
3724 }
3725 if ($space_after) {
3726 $good .= " ";
Joe Perches3705ce52013-07-03 15:05:31 -07003727 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003728 }
3729
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07003730 # '*' as part of a type definition -- reported already.
Andy Whitcroft74048ed2008-07-23 21:29:10 -07003731 } elsif ($opv eq '*_') {
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07003732 #warn "'*' is part of type\n";
3733
3734 # unary operators should have a space before and
3735 # none after. May be left adjacent to another
3736 # unary operator, or a cast
3737 } elsif ($op eq '!' || $op eq '~' ||
Andy Whitcroft74048ed2008-07-23 21:29:10 -07003738 $opv eq '*U' || $opv eq '-U' ||
Andy Whitcroft0d413862008-10-15 22:02:16 -07003739 $opv eq '&U' || $opv eq '&&U') {
Andy Whitcroftcf655042008-03-04 14:28:20 -08003740 if ($ctx !~ /[WEBC]x./ && $ca !~ /(?:\)|!|~|\*|-|\&|\||\+\+|\-\-|\{)$/) {
Joe Perches3705ce52013-07-03 15:05:31 -07003741 if (ERROR("SPACING",
3742 "space required before that '$op' $at\n" . $hereptr)) {
Joe Perchesb34c6482013-09-11 14:24:01 -07003743 if ($n != $last_after + 2) {
3744 $good = $fix_elements[$n] . " " . ltrim($fix_elements[$n + 1]);
3745 $line_fixed = 1;
3746 }
Joe Perches3705ce52013-07-03 15:05:31 -07003747 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003748 }
Andy Whitcrofta3340b32009-02-27 14:03:07 -08003749 if ($op eq '*' && $cc =~/\s*$Modifier\b/) {
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07003750 # A unary '*' may be const
3751
3752 } elsif ($ctx =~ /.xW/) {
Joe Perches3705ce52013-07-03 15:05:31 -07003753 if (ERROR("SPACING",
3754 "space prohibited after that '$op' $at\n" . $hereptr)) {
Joe Perchesb34c6482013-09-11 14:24:01 -07003755 $good = $fix_elements[$n] . rtrim($fix_elements[$n + 1]);
Joe Perches3705ce52013-07-03 15:05:31 -07003756 if (defined $fix_elements[$n + 2]) {
3757 $fix_elements[$n + 2] =~ s/^\s+//;
3758 }
Joe Perchesb34c6482013-09-11 14:24:01 -07003759 $line_fixed = 1;
Joe Perches3705ce52013-07-03 15:05:31 -07003760 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003761 }
3762
3763 # unary ++ and unary -- are allowed no space on one side.
3764 } elsif ($op eq '++' or $op eq '--') {
Andy Whitcroft773647a2008-03-28 14:15:58 -07003765 if ($ctx !~ /[WEOBC]x[^W]/ && $ctx !~ /[^W]x[WOBEC]/) {
Joe Perches3705ce52013-07-03 15:05:31 -07003766 if (ERROR("SPACING",
3767 "space required one side of that '$op' $at\n" . $hereptr)) {
Joe Perchesb34c6482013-09-11 14:24:01 -07003768 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";
Joe Perches3705ce52013-07-03 15:05:31 -07003769 $line_fixed = 1;
3770 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003771 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07003772 if ($ctx =~ /Wx[BE]/ ||
3773 ($ctx =~ /Wx./ && $cc =~ /^;/)) {
Joe Perches3705ce52013-07-03 15:05:31 -07003774 if (ERROR("SPACING",
3775 "space prohibited before that '$op' $at\n" . $hereptr)) {
Joe Perchesb34c6482013-09-11 14:24:01 -07003776 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
Joe Perches3705ce52013-07-03 15:05:31 -07003777 $line_fixed = 1;
3778 }
Andy Whitcroft653d4872007-06-23 17:16:34 -07003779 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07003780 if ($ctx =~ /ExW/) {
Joe Perches3705ce52013-07-03 15:05:31 -07003781 if (ERROR("SPACING",
3782 "space prohibited after that '$op' $at\n" . $hereptr)) {
Joe Perchesb34c6482013-09-11 14:24:01 -07003783 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]);
Joe Perches3705ce52013-07-03 15:05:31 -07003784 if (defined $fix_elements[$n + 2]) {
3785 $fix_elements[$n + 2] =~ s/^\s+//;
3786 }
Joe Perchesb34c6482013-09-11 14:24:01 -07003787 $line_fixed = 1;
Joe Perches3705ce52013-07-03 15:05:31 -07003788 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07003789 }
3790
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003791 # << and >> may either have or not have spaces both sides
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07003792 } elsif ($op eq '<<' or $op eq '>>' or
3793 $op eq '&' or $op eq '^' or $op eq '|' or
3794 $op eq '+' or $op eq '-' or
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08003795 $op eq '*' or $op eq '/' or
3796 $op eq '%')
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003797 {
Joe Perchesd2e025f2015-02-13 14:38:57 -08003798 if ($check) {
3799 if (defined $fix_elements[$n + 2] && $ctx !~ /[EW]x[EW]/) {
3800 if (CHK("SPACING",
3801 "spaces preferred around that '$op' $at\n" . $hereptr)) {
3802 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
3803 $fix_elements[$n + 2] =~ s/^\s+//;
3804 $line_fixed = 1;
3805 }
3806 } elsif (!defined $fix_elements[$n + 2] && $ctx !~ /Wx[OE]/) {
3807 if (CHK("SPACING",
3808 "space preferred before that '$op' $at\n" . $hereptr)) {
3809 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]);
3810 $line_fixed = 1;
3811 }
3812 }
3813 } elsif ($ctx =~ /Wx[^WCE]|[^WCE]xW/) {
Joe Perches3705ce52013-07-03 15:05:31 -07003814 if (ERROR("SPACING",
3815 "need consistent spacing around '$op' $at\n" . $hereptr)) {
Joe Perchesb34c6482013-09-11 14:24:01 -07003816 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
3817 if (defined $fix_elements[$n + 2]) {
3818 $fix_elements[$n + 2] =~ s/^\s+//;
3819 }
Joe Perches3705ce52013-07-03 15:05:31 -07003820 $line_fixed = 1;
3821 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003822 }
3823
Andy Whitcroft1f65f942008-07-23 21:29:10 -07003824 # A colon needs no spaces before when it is
3825 # terminating a case value or a label.
3826 } elsif ($opv eq ':C' || $opv eq ':L') {
3827 if ($ctx =~ /Wx./) {
Joe Perches3705ce52013-07-03 15:05:31 -07003828 if (ERROR("SPACING",
3829 "space prohibited before that '$op' $at\n" . $hereptr)) {
Joe Perchesb34c6482013-09-11 14:24:01 -07003830 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
Joe Perches3705ce52013-07-03 15:05:31 -07003831 $line_fixed = 1;
3832 }
Andy Whitcroft1f65f942008-07-23 21:29:10 -07003833 }
3834
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003835 # All the others need spaces both sides.
Andy Whitcroftcf655042008-03-04 14:28:20 -08003836 } elsif ($ctx !~ /[EWC]x[CWE]/) {
Andy Whitcroft1f65f942008-07-23 21:29:10 -07003837 my $ok = 0;
3838
Andy Whitcroft22f2a2e2007-08-10 13:01:03 -07003839 # Ignore email addresses <foo@bar>
Andy Whitcroft1f65f942008-07-23 21:29:10 -07003840 if (($op eq '<' &&
3841 $cc =~ /^\S+\@\S+>/) ||
3842 ($op eq '>' &&
3843 $ca =~ /<\S+\@\S+$/))
3844 {
3845 $ok = 1;
3846 }
3847
Joe Perchese0df7e12015-04-16 12:44:53 -07003848 # for asm volatile statements
3849 # ignore a colon with another
3850 # colon immediately before or after
3851 if (($op eq ':') &&
3852 ($ca =~ /:$/ || $cc =~ /^:/)) {
3853 $ok = 1;
3854 }
3855
Joe Perches84731622013-11-12 15:10:05 -08003856 # messages are ERROR, but ?: are CHK
Andy Whitcroft1f65f942008-07-23 21:29:10 -07003857 if ($ok == 0) {
Joe Perches84731622013-11-12 15:10:05 -08003858 my $msg_type = \&ERROR;
3859 $msg_type = \&CHK if (($op eq '?:' || $op eq '?' || $op eq ':') && $ctx =~ /VxV/);
3860
3861 if (&{$msg_type}("SPACING",
3862 "spaces required around that '$op' $at\n" . $hereptr)) {
Joe Perchesb34c6482013-09-11 14:24:01 -07003863 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
3864 if (defined $fix_elements[$n + 2]) {
3865 $fix_elements[$n + 2] =~ s/^\s+//;
3866 }
Joe Perches3705ce52013-07-03 15:05:31 -07003867 $line_fixed = 1;
3868 }
Andy Whitcroft22f2a2e2007-08-10 13:01:03 -07003869 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003870 }
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07003871 $off += length($elements[$n + 1]);
Joe Perches3705ce52013-07-03 15:05:31 -07003872
3873## print("n: <$n> GOOD: <$good>\n");
3874
3875 $fixed_line = $fixed_line . $good;
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003876 }
Joe Perches3705ce52013-07-03 15:05:31 -07003877
3878 if (($#elements % 2) == 0) {
3879 $fixed_line = $fixed_line . $fix_elements[$#elements];
3880 }
3881
Joe Perches194f66f2014-08-06 16:11:03 -07003882 if ($fix && $line_fixed && $fixed_line ne $fixed[$fixlinenr]) {
3883 $fixed[$fixlinenr] = $fixed_line;
Joe Perches3705ce52013-07-03 15:05:31 -07003884 }
3885
3886
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003887 }
3888
Joe Perches786b6322013-07-03 15:05:32 -07003889# check for whitespace before a non-naked semicolon
Joe Perchesd2e248e2014-01-23 15:54:41 -08003890 if ($line =~ /^\+.*\S\s+;\s*$/) {
Joe Perches786b6322013-07-03 15:05:32 -07003891 if (WARN("SPACING",
3892 "space prohibited before semicolon\n" . $herecurr) &&
3893 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07003894 1 while $fixed[$fixlinenr] =~
Joe Perches786b6322013-07-03 15:05:32 -07003895 s/^(\+.*\S)\s+;/$1;/;
3896 }
3897 }
3898
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07003899# check for multiple assignments
3900 if ($line =~ /^.\s*$Lval\s*=\s*$Lval\s*=(?!=)/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003901 CHK("MULTIPLE_ASSIGNMENTS",
3902 "multiple assignments should be avoided\n" . $herecurr);
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07003903 }
3904
Andy Whitcroft22f2a2e2007-08-10 13:01:03 -07003905## # check for multiple declarations, allowing for a function declaration
3906## # continuation.
3907## if ($line =~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Ident.*/ &&
3908## $line !~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Type\s*$Ident.*/) {
3909##
3910## # Remove any bracketed sections to ensure we do not
3911## # falsly report the parameters of functions.
3912## my $ln = $line;
3913## while ($ln =~ s/\([^\(\)]*\)//g) {
3914## }
3915## if ($ln =~ /,/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003916## WARN("MULTIPLE_DECLARATION",
3917## "declaring multiple variables together should be avoided\n" . $herecurr);
Andy Whitcroft22f2a2e2007-08-10 13:01:03 -07003918## }
3919## }
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07003920
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003921#need space before brace following if, while, etc
Andy Whitcroft22f2a2e2007-08-10 13:01:03 -07003922 if (($line =~ /\(.*\){/ && $line !~ /\($Type\){/) ||
3923 $line =~ /do{/) {
Joe Perches3705ce52013-07-03 15:05:31 -07003924 if (ERROR("SPACING",
3925 "space required before the open brace '{'\n" . $herecurr) &&
3926 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07003927 $fixed[$fixlinenr] =~ s/^(\+.*(?:do|\))){/$1 {/;
Joe Perches3705ce52013-07-03 15:05:31 -07003928 }
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07003929 }
3930
Joe Perchesc4a62ef2013-07-03 15:05:28 -07003931## # check for blank lines before declarations
3932## if ($line =~ /^.\t+$Type\s+$Ident(?:\s*=.*)?;/ &&
3933## $prevrawline =~ /^.\s*$/) {
3934## WARN("SPACING",
3935## "No blank lines before declarations\n" . $hereprev);
3936## }
3937##
3938
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07003939# closing brace should have a space following it when it has anything
3940# on the line
3941 if ($line =~ /}(?!(?:,|;|\)))\S/) {
Joe Perchesd5e616f2013-09-11 14:23:54 -07003942 if (ERROR("SPACING",
3943 "space required after that close brace '}'\n" . $herecurr) &&
3944 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07003945 $fixed[$fixlinenr] =~
Joe Perchesd5e616f2013-09-11 14:23:54 -07003946 s/}((?!(?:,|;|\)))\S)/} $1/;
3947 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003948 }
3949
Andy Whitcroft22f2a2e2007-08-10 13:01:03 -07003950# check spacing on square brackets
3951 if ($line =~ /\[\s/ && $line !~ /\[\s*$/) {
Joe Perches3705ce52013-07-03 15:05:31 -07003952 if (ERROR("SPACING",
3953 "space prohibited after that open square bracket '['\n" . $herecurr) &&
3954 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07003955 $fixed[$fixlinenr] =~
Joe Perches3705ce52013-07-03 15:05:31 -07003956 s/\[\s+/\[/;
3957 }
Andy Whitcroft22f2a2e2007-08-10 13:01:03 -07003958 }
3959 if ($line =~ /\s\]/) {
Joe Perches3705ce52013-07-03 15:05:31 -07003960 if (ERROR("SPACING",
3961 "space prohibited before that close square bracket ']'\n" . $herecurr) &&
3962 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07003963 $fixed[$fixlinenr] =~
Joe Perches3705ce52013-07-03 15:05:31 -07003964 s/\s+\]/\]/;
3965 }
Andy Whitcroft22f2a2e2007-08-10 13:01:03 -07003966 }
3967
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07003968# check spacing on parentheses
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07003969 if ($line =~ /\(\s/ && $line !~ /\(\s*(?:\\)?$/ &&
3970 $line !~ /for\s*\(\s+;/) {
Joe Perches3705ce52013-07-03 15:05:31 -07003971 if (ERROR("SPACING",
3972 "space prohibited after that open parenthesis '('\n" . $herecurr) &&
3973 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07003974 $fixed[$fixlinenr] =~
Joe Perches3705ce52013-07-03 15:05:31 -07003975 s/\(\s+/\(/;
3976 }
Andy Whitcroft22f2a2e2007-08-10 13:01:03 -07003977 }
Andy Whitcroft13214ad2008-02-08 04:22:03 -08003978 if ($line =~ /(\s+)\)/ && $line !~ /^.\s*\)/ &&
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07003979 $line !~ /for\s*\(.*;\s+\)/ &&
3980 $line !~ /:\s+\)/) {
Joe Perches3705ce52013-07-03 15:05:31 -07003981 if (ERROR("SPACING",
3982 "space prohibited before that close parenthesis ')'\n" . $herecurr) &&
3983 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07003984 $fixed[$fixlinenr] =~
Joe Perches3705ce52013-07-03 15:05:31 -07003985 s/\s+\)/\)/;
3986 }
Andy Whitcroft22f2a2e2007-08-10 13:01:03 -07003987 }
3988
Joe Perchese2826fd2014-08-06 16:10:48 -07003989# check unnecessary parentheses around addressof/dereference single $Lvals
3990# ie: &(foo->bar) should be &foo->bar and *(foo->bar) should be *foo->bar
3991
3992 while ($line =~ /(?:[^&]&\s*|\*)\(\s*($Ident\s*(?:$Member\s*)+)\s*\)/g) {
Joe Perchesea4acbb2014-12-10 15:51:51 -08003993 my $var = $1;
3994 if (CHK("UNNECESSARY_PARENTHESES",
3995 "Unnecessary parentheses around $var\n" . $herecurr) &&
3996 $fix) {
3997 $fixed[$fixlinenr] =~ s/\(\s*\Q$var\E\s*\)/$var/;
3998 }
3999 }
4000
4001# check for unnecessary parentheses around function pointer uses
4002# ie: (foo->bar)(); should be foo->bar();
4003# but not "if (foo->bar) (" to avoid some false positives
4004 if ($line =~ /(\bif\s*|)(\(\s*$Ident\s*(?:$Member\s*)+\))[ \t]*\(/ && $1 !~ /^if/) {
4005 my $var = $2;
4006 if (CHK("UNNECESSARY_PARENTHESES",
4007 "Unnecessary parentheses around function pointer $var\n" . $herecurr) &&
4008 $fix) {
4009 my $var2 = deparenthesize($var);
4010 $var2 =~ s/\s//g;
4011 $fixed[$fixlinenr] =~ s/\Q$var\E/$var2/;
4012 }
4013 }
Joe Perchese2826fd2014-08-06 16:10:48 -07004014
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004015#goto labels aren't indented, allow a single space however
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07004016 if ($line=~/^.\s+[A-Za-z\d_]+:(?![0-9]+)/ and
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004017 !($line=~/^. [A-Za-z\d_]+:/) and !($line=~/^.\s+default:/)) {
Joe Perches3705ce52013-07-03 15:05:31 -07004018 if (WARN("INDENTED_LABEL",
4019 "labels should not be indented\n" . $herecurr) &&
4020 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07004021 $fixed[$fixlinenr] =~
Joe Perches3705ce52013-07-03 15:05:31 -07004022 s/^(.)\s+/$1/;
4023 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004024 }
4025
Joe Perches5b9553a2014-04-03 14:49:21 -07004026# return is not a function
Joe Perches507e5142013-11-12 15:10:13 -08004027 if (defined($stat) && $stat =~ /^.\s*return(\s*)\(/s) {
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004028 my $spacing = $1;
Joe Perches507e5142013-11-12 15:10:13 -08004029 if ($^V && $^V ge 5.10.0 &&
Joe Perches5b9553a2014-04-03 14:49:21 -07004030 $stat =~ /^.\s*return\s*($balanced_parens)\s*;\s*$/) {
4031 my $value = $1;
4032 $value = deparenthesize($value);
4033 if ($value =~ m/^\s*$FuncArg\s*(?:\?|$)/) {
4034 ERROR("RETURN_PARENTHESES",
4035 "return is not a function, parentheses are not required\n" . $herecurr);
4036 }
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004037 } elsif ($spacing !~ /\s+/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07004038 ERROR("SPACING",
4039 "space required before the open parenthesis '('\n" . $herecurr);
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004040 }
4041 }
Joe Perches507e5142013-11-12 15:10:13 -08004042
Joe Perchesb43ae212014-06-23 13:22:07 -07004043# unnecessary return in a void function
4044# at end-of-function, with the previous line a single leading tab, then return;
4045# and the line before that not a goto label target like "out:"
4046 if ($sline =~ /^[ \+]}\s*$/ &&
4047 $prevline =~ /^\+\treturn\s*;\s*$/ &&
4048 $linenr >= 3 &&
4049 $lines[$linenr - 3] =~ /^[ +]/ &&
4050 $lines[$linenr - 3] !~ /^[ +]\s*$Ident\s*:/) {
Joe Perches9819cf22014-06-04 16:12:09 -07004051 WARN("RETURN_VOID",
Joe Perchesb43ae212014-06-23 13:22:07 -07004052 "void function return statements are not generally useful\n" . $hereprev);
4053 }
Joe Perches9819cf22014-06-04 16:12:09 -07004054
Joe Perches189248d2014-01-23 15:54:47 -08004055# if statements using unnecessary parentheses - ie: if ((foo == bar))
4056 if ($^V && $^V ge 5.10.0 &&
4057 $line =~ /\bif\s*((?:\(\s*){2,})/) {
4058 my $openparens = $1;
4059 my $count = $openparens =~ tr@\(@\(@;
4060 my $msg = "";
4061 if ($line =~ /\bif\s*(?:\(\s*){$count,$count}$LvalOrFunc\s*($Compare)\s*$LvalOrFunc(?:\s*\)){$count,$count}/) {
4062 my $comp = $4; #Not $1 because of $LvalOrFunc
4063 $msg = " - maybe == should be = ?" if ($comp eq "==");
4064 WARN("UNNECESSARY_PARENTHESES",
4065 "Unnecessary parentheses$msg\n" . $herecurr);
4066 }
4067 }
4068
Joe Perchesf34e4a42015-04-16 12:44:19 -07004069# Return of what appears to be an errno should normally be negative
4070 if ($sline =~ /\breturn(?:\s*\(+\s*|\s+)(E[A-Z]+)(?:\s*\)+\s*|\s*)[;:,]/) {
Andy Whitcroft53a3c442010-10-26 14:23:14 -07004071 my $name = $1;
4072 if ($name ne 'EOF' && $name ne 'ERROR') {
Joe Perches000d1cc12011-07-25 17:13:25 -07004073 WARN("USE_NEGATIVE_ERRNO",
Joe Perchesf34e4a42015-04-16 12:44:19 -07004074 "return of an errno should typically be negative (ie: return -$1)\n" . $herecurr);
Andy Whitcroft53a3c442010-10-26 14:23:14 -07004075 }
4076 }
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004077
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004078# Need a space before open parenthesis after if, while etc
Joe Perches3705ce52013-07-03 15:05:31 -07004079 if ($line =~ /\b(if|while|for|switch)\(/) {
4080 if (ERROR("SPACING",
4081 "space required before the open parenthesis '('\n" . $herecurr) &&
4082 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07004083 $fixed[$fixlinenr] =~
Joe Perches3705ce52013-07-03 15:05:31 -07004084 s/\b(if|while|for|switch)\(/$1 \(/;
4085 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004086 }
4087
Andy Whitcroftf5fe35d2008-07-23 21:29:03 -07004088# Check for illegal assignment in if conditional -- and check for trailing
4089# statements after the conditional.
Andy Whitcroft170d3a22008-10-15 22:02:30 -07004090 if ($line =~ /do\s*(?!{)/) {
Andy Whitcroft3e469cd2012-01-10 15:10:01 -08004091 ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
4092 ctx_statement_block($linenr, $realcnt, 0)
4093 if (!defined $stat);
Andy Whitcroft170d3a22008-10-15 22:02:30 -07004094 my ($stat_next) = ctx_statement_block($line_nr_next,
4095 $remain_next, $off_next);
4096 $stat_next =~ s/\n./\n /g;
4097 ##print "stat<$stat> stat_next<$stat_next>\n";
4098
4099 if ($stat_next =~ /^\s*while\b/) {
4100 # If the statement carries leading newlines,
4101 # then count those as offsets.
4102 my ($whitespace) =
4103 ($stat_next =~ /^((?:\s*\n[+-])*\s*)/s);
4104 my $offset =
4105 statement_rawlines($whitespace) - 1;
4106
4107 $suppress_whiletrailers{$line_nr_next +
4108 $offset} = 1;
4109 }
4110 }
4111 if (!defined $suppress_whiletrailers{$linenr} &&
Joe Perchesc11230f2013-11-21 14:31:57 -08004112 defined($stat) && defined($cond) &&
Andy Whitcroft170d3a22008-10-15 22:02:30 -07004113 $line =~ /\b(?:if|while|for)\s*\(/ && $line !~ /^.\s*#/) {
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07004114 my ($s, $c) = ($stat, $cond);
Andy Whitcroft8905a672007-11-28 16:21:06 -08004115
Andy Whitcroftb53c8e12009-01-06 14:41:29 -08004116 if ($c =~ /\bif\s*\(.*[^<>!=]=[^=].*/s) {
Joe Perches000d1cc12011-07-25 17:13:25 -07004117 ERROR("ASSIGN_IN_IF",
4118 "do not use assignment in if condition\n" . $herecurr);
Andy Whitcroft8905a672007-11-28 16:21:06 -08004119 }
4120
4121 # Find out what is on the end of the line after the
4122 # conditional.
Andy Whitcroft773647a2008-03-28 14:15:58 -07004123 substr($s, 0, length($c), '');
Andy Whitcroft8905a672007-11-28 16:21:06 -08004124 $s =~ s/\n.*//g;
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004125 $s =~ s/$;//g; # Remove any comments
Andy Whitcroft53210162008-07-23 21:29:03 -07004126 if (length($c) && $s !~ /^\s*{?\s*\\*\s*$/ &&
4127 $c !~ /}\s*while\s*/)
Andy Whitcroft773647a2008-03-28 14:15:58 -07004128 {
Andy Whitcroftbb44ad32008-10-15 22:02:34 -07004129 # Find out how long the conditional actually is.
4130 my @newlines = ($c =~ /\n/gs);
4131 my $cond_lines = 1 + $#newlines;
Hidetoshi Seto42bdf742010-03-05 13:43:50 -08004132 my $stat_real = '';
Andy Whitcroftbb44ad32008-10-15 22:02:34 -07004133
Hidetoshi Seto42bdf742010-03-05 13:43:50 -08004134 $stat_real = raw_line($linenr, $cond_lines)
4135 . "\n" if ($cond_lines);
Andy Whitcroftbb44ad32008-10-15 22:02:34 -07004136 if (defined($stat_real) && $cond_lines > 1) {
4137 $stat_real = "[...]\n$stat_real";
4138 }
4139
Joe Perches000d1cc12011-07-25 17:13:25 -07004140 ERROR("TRAILING_STATEMENTS",
4141 "trailing statements should be on next line\n" . $herecurr . $stat_real);
Andy Whitcroft8905a672007-11-28 16:21:06 -08004142 }
4143 }
4144
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004145# Check for bitwise tests written as boolean
4146 if ($line =~ /
4147 (?:
4148 (?:\[|\(|\&\&|\|\|)
4149 \s*0[xX][0-9]+\s*
4150 (?:\&\&|\|\|)
4151 |
4152 (?:\&\&|\|\|)
4153 \s*0[xX][0-9]+\s*
4154 (?:\&\&|\|\||\)|\])
4155 )/x)
4156 {
Joe Perches000d1cc12011-07-25 17:13:25 -07004157 WARN("HEXADECIMAL_BOOLEAN_TEST",
4158 "boolean test with hexadecimal, perhaps just 1 \& or \|?\n" . $herecurr);
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004159 }
4160
Andy Whitcroft8905a672007-11-28 16:21:06 -08004161# if and else should not have general statements after it
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004162 if ($line =~ /^.\s*(?:}\s*)?else\b(.*)/) {
4163 my $s = $1;
4164 $s =~ s/$;//g; # Remove any comments
4165 if ($s !~ /^\s*(?:\sif|(?:{|)\s*\\?\s*$)/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07004166 ERROR("TRAILING_STATEMENTS",
4167 "trailing statements should be on next line\n" . $herecurr);
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004168 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004169 }
Andy Whitcroft39667782009-01-15 13:51:06 -08004170# if should not continue a brace
4171 if ($line =~ /}\s*if\b/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07004172 ERROR("TRAILING_STATEMENTS",
Rasmus Villemoes048b1232014-08-06 16:10:37 -07004173 "trailing statements should be on next line (or did you mean 'else if'?)\n" .
Andy Whitcroft39667782009-01-15 13:51:06 -08004174 $herecurr);
4175 }
Andy Whitcrofta1080bf2008-10-15 22:02:25 -07004176# case and default should not have general statements after them
4177 if ($line =~ /^.\s*(?:case\s*.*|default\s*):/g &&
4178 $line !~ /\G(?:
Andy Whitcroft3fef12d2008-10-15 22:02:36 -07004179 (?:\s*$;*)(?:\s*{)?(?:\s*$;*)(?:\s*\\)?\s*$|
Andy Whitcrofta1080bf2008-10-15 22:02:25 -07004180 \s*return\s+
4181 )/xg)
4182 {
Joe Perches000d1cc12011-07-25 17:13:25 -07004183 ERROR("TRAILING_STATEMENTS",
4184 "trailing statements should be on next line\n" . $herecurr);
Andy Whitcrofta1080bf2008-10-15 22:02:25 -07004185 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004186
4187 # Check for }<nl>else {, these must be at the same
4188 # indent level to be relevant to each other.
Joe Perches8b8856f2014-08-06 16:11:14 -07004189 if ($prevline=~/}\s*$/ and $line=~/^.\s*else\s*/ &&
4190 $previndent == $indent) {
4191 if (ERROR("ELSE_AFTER_BRACE",
4192 "else should follow close brace '}'\n" . $hereprev) &&
4193 $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
4194 fix_delete_line($fixlinenr - 1, $prevrawline);
4195 fix_delete_line($fixlinenr, $rawline);
4196 my $fixedline = $prevrawline;
4197 $fixedline =~ s/}\s*$//;
4198 if ($fixedline !~ /^\+\s*$/) {
4199 fix_insert_line($fixlinenr, $fixedline);
4200 }
4201 $fixedline = $rawline;
4202 $fixedline =~ s/^(.\s*)else/$1} else/;
4203 fix_insert_line($fixlinenr, $fixedline);
4204 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004205 }
4206
Joe Perches8b8856f2014-08-06 16:11:14 -07004207 if ($prevline=~/}\s*$/ and $line=~/^.\s*while\s*/ &&
4208 $previndent == $indent) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08004209 my ($s, $c) = ctx_statement_block($linenr, $realcnt, 0);
4210
4211 # Find out what is on the end of the line after the
4212 # conditional.
Andy Whitcroft773647a2008-03-28 14:15:58 -07004213 substr($s, 0, length($c), '');
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08004214 $s =~ s/\n.*//g;
4215
4216 if ($s =~ /^\s*;/) {
Joe Perches8b8856f2014-08-06 16:11:14 -07004217 if (ERROR("WHILE_AFTER_BRACE",
4218 "while should follow close brace '}'\n" . $hereprev) &&
4219 $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
4220 fix_delete_line($fixlinenr - 1, $prevrawline);
4221 fix_delete_line($fixlinenr, $rawline);
4222 my $fixedline = $prevrawline;
4223 my $trailing = $rawline;
4224 $trailing =~ s/^\+//;
4225 $trailing = trim($trailing);
4226 $fixedline =~ s/}\s*$/} $trailing/;
4227 fix_insert_line($fixlinenr, $fixedline);
4228 }
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08004229 }
4230 }
4231
Joe Perches95e2c602013-07-03 15:05:20 -07004232#Specific variable tests
Joe Perches323c1262012-12-17 16:02:07 -08004233 while ($line =~ m{($Constant|$Lval)}g) {
4234 my $var = $1;
Joe Perches95e2c602013-07-03 15:05:20 -07004235
4236#gcc binary extension
4237 if ($var =~ /^$Binary$/) {
Joe Perchesd5e616f2013-09-11 14:23:54 -07004238 if (WARN("GCC_BINARY_CONSTANT",
4239 "Avoid gcc v4.3+ binary constant extension: <$var>\n" . $herecurr) &&
4240 $fix) {
4241 my $hexval = sprintf("0x%x", oct($var));
Joe Perches194f66f2014-08-06 16:11:03 -07004242 $fixed[$fixlinenr] =~
Joe Perchesd5e616f2013-09-11 14:23:54 -07004243 s/\b$var\b/$hexval/;
4244 }
Joe Perches95e2c602013-07-03 15:05:20 -07004245 }
4246
4247#CamelCase
Joe Perches807bd262013-07-03 15:05:22 -07004248 if ($var !~ /^$Constant$/ &&
Joe Perchesbe797942013-07-03 15:05:20 -07004249 $var =~ /[A-Z][a-z]|[a-z][A-Z]/ &&
Joe Perches22735ce2013-07-03 15:05:33 -07004250#Ignore Page<foo> variants
Joe Perches807bd262013-07-03 15:05:22 -07004251 $var !~ /^(?:Clear|Set|TestClear|TestSet|)Page[A-Z]/ &&
Joe Perches22735ce2013-07-03 15:05:33 -07004252#Ignore SI style variants like nS, mV and dB (ie: max_uV, regulator_min_uA_show)
Julius Wernerf5123572014-12-10 15:51:54 -08004253 $var !~ /^(?:[a-z_]*?)_?[a-z][A-Z](?:_[a-z_]+)?$/ &&
4254#Ignore some three character SI units explicitly, like MiB and KHz
4255 $var !~ /^(?:[a-z_]*?)_?(?:[KMGT]iB|[KMGT]?Hz)(?:_[a-z_]+)?$/) {
Joe Perches7e781f62013-09-11 14:23:55 -07004256 while ($var =~ m{($Ident)}g) {
4257 my $word = $1;
4258 next if ($word !~ /[A-Z][a-z]|[a-z][A-Z]/);
Joe Perchesd8b07712013-11-12 15:10:06 -08004259 if ($check) {
4260 seed_camelcase_includes();
4261 if (!$file && !$camelcase_file_seeded) {
4262 seed_camelcase_file($realfile);
4263 $camelcase_file_seeded = 1;
4264 }
4265 }
Joe Perches7e781f62013-09-11 14:23:55 -07004266 if (!defined $camelcase{$word}) {
4267 $camelcase{$word} = 1;
4268 CHK("CAMELCASE",
4269 "Avoid CamelCase: <$word>\n" . $herecurr);
4270 }
Joe Perches34456862013-07-03 15:05:34 -07004271 }
Joe Perches323c1262012-12-17 16:02:07 -08004272 }
4273 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004274
4275#no spaces allowed after \ in define
Joe Perchesd5e616f2013-09-11 14:23:54 -07004276 if ($line =~ /\#\s*define.*\\\s+$/) {
4277 if (WARN("WHITESPACE_AFTER_LINE_CONTINUATION",
4278 "Whitespace after \\ makes next lines useless\n" . $herecurr) &&
4279 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07004280 $fixed[$fixlinenr] =~ s/\s+$//;
Joe Perchesd5e616f2013-09-11 14:23:54 -07004281 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004282 }
4283
Fabian Frederick0e212e02015-04-16 12:44:25 -07004284# warn if <asm/foo.h> is #included and <linux/foo.h> is available and includes
4285# itself <asm/foo.h> (uses RAW line)
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004286 if ($tree && $rawline =~ m{^.\s*\#\s*include\s*\<asm\/(.*)\.h\>}) {
Andy Whitcrofte09dec42008-10-15 22:02:20 -07004287 my $file = "$1.h";
4288 my $checkfile = "include/linux/$file";
4289 if (-f "$root/$checkfile" &&
4290 $realfile ne $checkfile &&
Wolfram Sang7840a942010-08-09 17:20:57 -07004291 $1 !~ /$allowed_asm_includes/)
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004292 {
Fabian Frederick0e212e02015-04-16 12:44:25 -07004293 my $asminclude = `grep -Ec "#include\\s+<asm/$file>" $root/$checkfile`;
4294 if ($asminclude > 0) {
4295 if ($realfile =~ m{^arch/}) {
4296 CHK("ARCH_INCLUDE_LINUX",
4297 "Consider using #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
4298 } else {
4299 WARN("INCLUDE_LINUX",
4300 "Use #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
4301 }
Andy Whitcrofte09dec42008-10-15 22:02:20 -07004302 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004303 }
4304 }
4305
Andy Whitcroft653d4872007-06-23 17:16:34 -07004306# multi-statement macros should be enclosed in a do while loop, grab the
4307# first statement and ensure its the whole macro if its not enclosed
Andy Whitcroftcf655042008-03-04 14:28:20 -08004308# in a known good container
Andy Whitcroftb8f96a32008-07-23 21:29:07 -07004309 if ($realfile !~ m@/vmlinux.lds.h$@ &&
4310 $line =~ /^.\s*\#\s*define\s*$Ident(\()?/) {
Andy Whitcroftd8aaf122007-06-23 17:16:44 -07004311 my $ln = $linenr;
4312 my $cnt = $realcnt;
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004313 my ($off, $dstat, $dcond, $rest);
4314 my $ctx = '';
Joe Perches08a28432014-10-13 15:51:55 -07004315 my $has_flow_statement = 0;
4316 my $has_arg_concat = 0;
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004317 ($dstat, $dcond, $ln, $cnt, $off) =
Andy Whitcroftf74bd192012-01-10 15:09:54 -08004318 ctx_statement_block($linenr, $realcnt, 0);
4319 $ctx = $dstat;
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004320 #print "dstat<$dstat> dcond<$dcond> cnt<$cnt> off<$off>\n";
Andy Whitcrofta3bb97a2008-07-23 21:29:00 -07004321 #print "LINE<$lines[$ln-1]> len<" . length($lines[$ln-1]) . "\n";
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004322
Joe Perches08a28432014-10-13 15:51:55 -07004323 $has_flow_statement = 1 if ($ctx =~ /\b(goto|return)\b/);
4324 $has_arg_concat = 1 if ($ctx =~ /\#\#/);
4325
Andy Whitcroftf74bd192012-01-10 15:09:54 -08004326 $dstat =~ s/^.\s*\#\s*define\s+$Ident(?:\([^\)]*\))?\s*//;
Andy Whitcroft292f1a92008-07-23 21:29:11 -07004327 $dstat =~ s/$;//g;
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004328 $dstat =~ s/\\\n.//g;
4329 $dstat =~ s/^\s*//s;
4330 $dstat =~ s/\s*$//s;
4331
4332 # Flatten any parentheses and braces
Andy Whitcroftbf30d6e2008-10-15 22:02:33 -07004333 while ($dstat =~ s/\([^\(\)]*\)/1/ ||
4334 $dstat =~ s/\{[^\{\}]*\}/1/ ||
Andy Whitcroftc81769f2012-01-10 15:10:10 -08004335 $dstat =~ s/\[[^\[\]]*\]/1/)
Andy Whitcroftbf30d6e2008-10-15 22:02:33 -07004336 {
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07004337 }
Andy Whitcroftd8aaf122007-06-23 17:16:44 -07004338
Andy Whitcrofte45bab82012-03-23 15:02:18 -07004339 # Flatten any obvious string concatentation.
4340 while ($dstat =~ s/("X*")\s*$Ident/$1/ ||
4341 $dstat =~ s/$Ident\s*("X*")/$1/)
4342 {
4343 }
4344
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004345 my $exceptions = qr{
4346 $Declare|
4347 module_param_named|
Kees Cooka0a0a7a2012-10-04 17:13:38 -07004348 MODULE_PARM_DESC|
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004349 DECLARE_PER_CPU|
4350 DEFINE_PER_CPU|
Andy Whitcroft383099f2009-01-06 14:41:18 -08004351 __typeof__\(|
Stefani Seibold22fd2d32010-03-05 13:43:52 -08004352 union|
4353 struct|
Andy Whitcroftea71a0a2009-09-21 17:04:38 -07004354 \.$Ident\s*=\s*|
4355 ^\"|\"$
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004356 }x;
Andy Whitcroft5eaa20b2010-10-26 14:23:18 -07004357 #print "REST<$rest> dstat<$dstat> ctx<$ctx>\n";
Andy Whitcroftf74bd192012-01-10 15:09:54 -08004358 if ($dstat ne '' &&
4359 $dstat !~ /^(?:$Ident|-?$Constant),$/ && # 10, // foo(),
4360 $dstat !~ /^(?:$Ident|-?$Constant);$/ && # foo();
Joe Perches3cc4b1c2013-07-03 15:05:27 -07004361 $dstat !~ /^[!~-]?(?:$Lval|$Constant)$/ && # 10 // foo() // !foo // ~foo // -foo // foo->bar // foo.bar->baz
Joe Perches356fd392014-08-06 16:10:31 -07004362 $dstat !~ /^'X'$/ && $dstat !~ /^'XX'$/ && # character constants
Andy Whitcroftf74bd192012-01-10 15:09:54 -08004363 $dstat !~ /$exceptions/ &&
4364 $dstat !~ /^\.$Ident\s*=/ && # .foo =
Joe Perchese942e2c2013-04-17 15:58:26 -07004365 $dstat !~ /^(?:\#\s*$Ident|\#\s*$Constant)\s*$/ && # stringification #foo
Andy Whitcroft72f115f2012-01-10 15:10:06 -08004366 $dstat !~ /^do\s*$Constant\s*while\s*$Constant;?$/ && # do {...} while (...); // do {...} while (...)
Andy Whitcroftf74bd192012-01-10 15:09:54 -08004367 $dstat !~ /^for\s*$Constant$/ && # for (...)
4368 $dstat !~ /^for\s*$Constant\s+(?:$Ident|-?$Constant)$/ && # for (...) bar()
4369 $dstat !~ /^do\s*{/ && # do {...
Joe Perchesf95a7e62013-09-11 14:24:00 -07004370 $dstat !~ /^\({/ && # ({...
4371 $ctx !~ /^.\s*#\s*define\s+TRACE_(?:SYSTEM|INCLUDE_FILE|INCLUDE_PATH)\b/)
Andy Whitcroftf74bd192012-01-10 15:09:54 -08004372 {
4373 $ctx =~ s/\n*$//;
4374 my $herectx = $here . "\n";
4375 my $cnt = statement_rawlines($ctx);
4376
4377 for (my $n = 0; $n < $cnt; $n++) {
4378 $herectx .= raw_line($linenr, $n) . "\n";
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004379 }
4380
Andy Whitcroftf74bd192012-01-10 15:09:54 -08004381 if ($dstat =~ /;/) {
4382 ERROR("MULTISTATEMENT_MACRO_USE_DO_WHILE",
4383 "Macros with multiple statements should be enclosed in a do - while loop\n" . "$herectx");
4384 } else {
Joe Perches000d1cc12011-07-25 17:13:25 -07004385 ERROR("COMPLEX_MACRO",
Andrew Morton388982b2014-10-13 15:51:40 -07004386 "Macros with complex values should be enclosed in parentheses\n" . "$herectx");
Andy Whitcroftd8aaf122007-06-23 17:16:44 -07004387 }
Andy Whitcroft653d4872007-06-23 17:16:34 -07004388 }
Joe Perches5023d342012-12-17 16:01:47 -08004389
Joe Perches08a28432014-10-13 15:51:55 -07004390# check for macros with flow control, but without ## concatenation
4391# ## concatenation is commonly a macro that defines a function so ignore those
4392 if ($has_flow_statement && !$has_arg_concat) {
4393 my $herectx = $here . "\n";
4394 my $cnt = statement_rawlines($ctx);
4395
4396 for (my $n = 0; $n < $cnt; $n++) {
4397 $herectx .= raw_line($linenr, $n) . "\n";
4398 }
4399 WARN("MACRO_WITH_FLOW_CONTROL",
4400 "Macros with flow control statements should be avoided\n" . "$herectx");
4401 }
4402
Joe Perches481eb482012-12-17 16:01:56 -08004403# check for line continuations outside of #defines, preprocessor #, and asm
Joe Perches5023d342012-12-17 16:01:47 -08004404
4405 } else {
4406 if ($prevline !~ /^..*\\$/ &&
Joe Perches481eb482012-12-17 16:01:56 -08004407 $line !~ /^\+\s*\#.*\\$/ && # preprocessor
4408 $line !~ /^\+.*\b(__asm__|asm)\b.*\\$/ && # asm
Joe Perches5023d342012-12-17 16:01:47 -08004409 $line =~ /^\+.*\\$/) {
4410 WARN("LINE_CONTINUATIONS",
4411 "Avoid unnecessary line continuations\n" . $herecurr);
4412 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004413 }
4414
Joe Perchesb13edf72012-07-30 14:41:24 -07004415# do {} while (0) macro tests:
4416# single-statement macros do not need to be enclosed in do while (0) loop,
4417# macro should not end with a semicolon
4418 if ($^V && $^V ge 5.10.0 &&
4419 $realfile !~ m@/vmlinux.lds.h$@ &&
4420 $line =~ /^.\s*\#\s*define\s+$Ident(\()?/) {
4421 my $ln = $linenr;
4422 my $cnt = $realcnt;
4423 my ($off, $dstat, $dcond, $rest);
4424 my $ctx = '';
4425 ($dstat, $dcond, $ln, $cnt, $off) =
4426 ctx_statement_block($linenr, $realcnt, 0);
4427 $ctx = $dstat;
4428
4429 $dstat =~ s/\\\n.//g;
Joe Perches1b36b202015-02-13 14:38:32 -08004430 $dstat =~ s/$;/ /g;
Joe Perchesb13edf72012-07-30 14:41:24 -07004431
4432 if ($dstat =~ /^\+\s*#\s*define\s+$Ident\s*${balanced_parens}\s*do\s*{(.*)\s*}\s*while\s*\(\s*0\s*\)\s*([;\s]*)\s*$/) {
4433 my $stmts = $2;
4434 my $semis = $3;
4435
4436 $ctx =~ s/\n*$//;
4437 my $cnt = statement_rawlines($ctx);
4438 my $herectx = $here . "\n";
4439
4440 for (my $n = 0; $n < $cnt; $n++) {
4441 $herectx .= raw_line($linenr, $n) . "\n";
4442 }
4443
Joe Perchesac8e97f2012-08-21 16:15:53 -07004444 if (($stmts =~ tr/;/;/) == 1 &&
4445 $stmts !~ /^\s*(if|while|for|switch)\b/) {
Joe Perchesb13edf72012-07-30 14:41:24 -07004446 WARN("SINGLE_STATEMENT_DO_WHILE_MACRO",
4447 "Single statement macros should not use a do {} while (0) loop\n" . "$herectx");
4448 }
4449 if (defined $semis && $semis ne "") {
4450 WARN("DO_WHILE_MACRO_WITH_TRAILING_SEMICOLON",
4451 "do {} while (0) macros should not be semicolon terminated\n" . "$herectx");
4452 }
Joe Perchesf5ef95b2014-06-04 16:12:06 -07004453 } elsif ($dstat =~ /^\+\s*#\s*define\s+$Ident.*;\s*$/) {
4454 $ctx =~ s/\n*$//;
4455 my $cnt = statement_rawlines($ctx);
4456 my $herectx = $here . "\n";
4457
4458 for (my $n = 0; $n < $cnt; $n++) {
4459 $herectx .= raw_line($linenr, $n) . "\n";
4460 }
4461
4462 WARN("TRAILING_SEMICOLON",
4463 "macros should not use a trailing semicolon\n" . "$herectx");
Joe Perchesb13edf72012-07-30 14:41:24 -07004464 }
4465 }
4466
Mike Frysinger080ba922009-01-06 14:41:25 -08004467# make sure symbols are always wrapped with VMLINUX_SYMBOL() ...
4468# all assignments may have only one of the following with an assignment:
4469# .
4470# ALIGN(...)
4471# VMLINUX_SYMBOL(...)
4472 if ($realfile eq 'vmlinux.lds.h' && $line =~ /(?:(?:^|\s)$Ident\s*=|=\s*$Ident(?:\s|$))/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07004473 WARN("MISSING_VMLINUX_SYMBOL",
4474 "vmlinux.lds.h needs VMLINUX_SYMBOL() around C-visible symbols\n" . $herecurr);
Mike Frysinger080ba922009-01-06 14:41:25 -08004475 }
4476
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07004477# check for redundant bracing round if etc
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004478 if ($line =~ /(^.*)\bif\b/ && $1 !~ /else\s*$/) {
4479 my ($level, $endln, @chunks) =
Andy Whitcroftcf655042008-03-04 14:28:20 -08004480 ctx_statement_full($linenr, $realcnt, 1);
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004481 #print "chunks<$#chunks> linenr<$linenr> endln<$endln> level<$level>\n";
Andy Whitcroftcf655042008-03-04 14:28:20 -08004482 #print "APW: <<$chunks[1][0]>><<$chunks[1][1]>>\n";
4483 if ($#chunks > 0 && $level == 0) {
Joe Perchesaad4f612012-03-23 15:02:19 -07004484 my @allowed = ();
4485 my $allow = 0;
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004486 my $seen = 0;
Andy Whitcroft773647a2008-03-28 14:15:58 -07004487 my $herectx = $here . "\n";
Andy Whitcroftcf655042008-03-04 14:28:20 -08004488 my $ln = $linenr - 1;
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004489 for my $chunk (@chunks) {
4490 my ($cond, $block) = @{$chunk};
4491
Andy Whitcroft773647a2008-03-28 14:15:58 -07004492 # If the condition carries leading newlines, then count those as offsets.
4493 my ($whitespace) = ($cond =~ /^((?:\s*\n[+-])*\s*)/s);
4494 my $offset = statement_rawlines($whitespace) - 1;
4495
Joe Perchesaad4f612012-03-23 15:02:19 -07004496 $allowed[$allow] = 0;
Andy Whitcroft773647a2008-03-28 14:15:58 -07004497 #print "COND<$cond> whitespace<$whitespace> offset<$offset>\n";
4498
4499 # We have looked at and allowed this specific line.
4500 $suppress_ifbraces{$ln + $offset} = 1;
4501
4502 $herectx .= "$rawlines[$ln + $offset]\n[...]\n";
Andy Whitcroftcf655042008-03-04 14:28:20 -08004503 $ln += statement_rawlines($block) - 1;
4504
Andy Whitcroft773647a2008-03-28 14:15:58 -07004505 substr($block, 0, length($cond), '');
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004506
4507 $seen++ if ($block =~ /^\s*{/);
4508
Joe Perchesaad4f612012-03-23 15:02:19 -07004509 #print "cond<$cond> block<$block> allowed<$allowed[$allow]>\n";
Andy Whitcroftcf655042008-03-04 14:28:20 -08004510 if (statement_lines($cond) > 1) {
4511 #print "APW: ALLOWED: cond<$cond>\n";
Joe Perchesaad4f612012-03-23 15:02:19 -07004512 $allowed[$allow] = 1;
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004513 }
4514 if ($block =~/\b(?:if|for|while)\b/) {
Andy Whitcroftcf655042008-03-04 14:28:20 -08004515 #print "APW: ALLOWED: block<$block>\n";
Joe Perchesaad4f612012-03-23 15:02:19 -07004516 $allowed[$allow] = 1;
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004517 }
Andy Whitcroftcf655042008-03-04 14:28:20 -08004518 if (statement_block_size($block) > 1) {
4519 #print "APW: ALLOWED: lines block<$block>\n";
Joe Perchesaad4f612012-03-23 15:02:19 -07004520 $allowed[$allow] = 1;
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004521 }
Joe Perchesaad4f612012-03-23 15:02:19 -07004522 $allow++;
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004523 }
Joe Perchesaad4f612012-03-23 15:02:19 -07004524 if ($seen) {
4525 my $sum_allowed = 0;
4526 foreach (@allowed) {
4527 $sum_allowed += $_;
4528 }
4529 if ($sum_allowed == 0) {
4530 WARN("BRACES",
4531 "braces {} are not necessary for any arm of this statement\n" . $herectx);
4532 } elsif ($sum_allowed != $allow &&
4533 $seen != $allow) {
4534 CHK("BRACES",
4535 "braces {} should be used on all arms of this statement\n" . $herectx);
4536 }
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004537 }
4538 }
4539 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07004540 if (!defined $suppress_ifbraces{$linenr - 1} &&
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004541 $line =~ /\b(if|while|for|else)\b/) {
Andy Whitcroftcf655042008-03-04 14:28:20 -08004542 my $allowed = 0;
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07004543
Andy Whitcroftcf655042008-03-04 14:28:20 -08004544 # Check the pre-context.
4545 if (substr($line, 0, $-[0]) =~ /(\}\s*)$/) {
4546 #print "APW: ALLOWED: pre<$1>\n";
4547 $allowed = 1;
4548 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07004549
4550 my ($level, $endln, @chunks) =
4551 ctx_statement_full($linenr, $realcnt, $-[0]);
4552
Andy Whitcroftcf655042008-03-04 14:28:20 -08004553 # Check the condition.
4554 my ($cond, $block) = @{$chunks[0]};
Andy Whitcroft773647a2008-03-28 14:15:58 -07004555 #print "CHECKING<$linenr> cond<$cond> block<$block>\n";
Andy Whitcroftcf655042008-03-04 14:28:20 -08004556 if (defined $cond) {
Andy Whitcroft773647a2008-03-28 14:15:58 -07004557 substr($block, 0, length($cond), '');
Andy Whitcroftcf655042008-03-04 14:28:20 -08004558 }
4559 if (statement_lines($cond) > 1) {
4560 #print "APW: ALLOWED: cond<$cond>\n";
4561 $allowed = 1;
4562 }
4563 if ($block =~/\b(?:if|for|while)\b/) {
4564 #print "APW: ALLOWED: block<$block>\n";
4565 $allowed = 1;
4566 }
4567 if (statement_block_size($block) > 1) {
4568 #print "APW: ALLOWED: lines block<$block>\n";
4569 $allowed = 1;
4570 }
4571 # Check the post-context.
4572 if (defined $chunks[1]) {
4573 my ($cond, $block) = @{$chunks[1]};
4574 if (defined $cond) {
Andy Whitcroft773647a2008-03-28 14:15:58 -07004575 substr($block, 0, length($cond), '');
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07004576 }
Andy Whitcroftcf655042008-03-04 14:28:20 -08004577 if ($block =~ /^\s*\{/) {
4578 #print "APW: ALLOWED: chunk-1 block<$block>\n";
4579 $allowed = 1;
4580 }
4581 }
4582 if ($level == 0 && $block =~ /^\s*\{/ && !$allowed) {
Justin P. Mattock69932482011-07-26 23:06:29 -07004583 my $herectx = $here . "\n";
Andy Whitcroftf0556632008-10-15 22:02:23 -07004584 my $cnt = statement_rawlines($block);
Andy Whitcroftcf655042008-03-04 14:28:20 -08004585
Andy Whitcroftf0556632008-10-15 22:02:23 -07004586 for (my $n = 0; $n < $cnt; $n++) {
Justin P. Mattock69932482011-07-26 23:06:29 -07004587 $herectx .= raw_line($linenr, $n) . "\n";
Andy Whitcroftcf655042008-03-04 14:28:20 -08004588 }
4589
Joe Perches000d1cc12011-07-25 17:13:25 -07004590 WARN("BRACES",
4591 "braces {} are not necessary for single statement blocks\n" . $herectx);
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07004592 }
4593 }
4594
Joe Perches0979ae62012-12-17 16:01:59 -08004595# check for unnecessary blank lines around braces
Joe Perches77b9a532013-07-03 15:05:29 -07004596 if (($line =~ /^.\s*}\s*$/ && $prevrawline =~ /^.\s*$/)) {
Joe Perchesf8e58212015-02-13 14:38:46 -08004597 if (CHK("BRACES",
4598 "Blank lines aren't necessary before a close brace '}'\n" . $hereprev) &&
4599 $fix && $prevrawline =~ /^\+/) {
4600 fix_delete_line($fixlinenr - 1, $prevrawline);
4601 }
Joe Perches0979ae62012-12-17 16:01:59 -08004602 }
Joe Perches77b9a532013-07-03 15:05:29 -07004603 if (($rawline =~ /^.\s*$/ && $prevline =~ /^..*{\s*$/)) {
Joe Perchesf8e58212015-02-13 14:38:46 -08004604 if (CHK("BRACES",
4605 "Blank lines aren't necessary after an open brace '{'\n" . $hereprev) &&
4606 $fix) {
4607 fix_delete_line($fixlinenr, $rawline);
4608 }
Joe Perches0979ae62012-12-17 16:01:59 -08004609 }
4610
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07004611# no volatiles please
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07004612 my $asm_volatile = qr{\b(__asm__|asm)\s+(__volatile__|volatile)\b};
4613 if ($line =~ /\bvolatile\b/ && $line !~ /$asm_volatile/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07004614 WARN("VOLATILE",
4615 "Use of volatile is usually wrong: see Documentation/volatile-considered-harmful.txt\n" . $herecurr);
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07004616 }
4617
Joe Perches5e4f6ba2014-12-10 15:52:05 -08004618# Check for user-visible strings broken across lines, which breaks the ability
4619# to grep for the string. Make exceptions when the previous string ends in a
4620# newline (multiple lines in one string constant) or '\t', '\r', ';', or '{'
4621# (common in inline assembly) or is a octal \123 or hexadecimal \xaf value
4622 if ($line =~ /^\+\s*"[X\t]*"/ &&
4623 $prevline =~ /"\s*$/ &&
4624 $prevrawline !~ /(?:\\(?:[ntr]|[0-7]{1,3}|x[0-9a-fA-F]{1,2})|;\s*|\{\s*)"\s*$/) {
4625 if (WARN("SPLIT_STRING",
4626 "quoted string split across lines\n" . $hereprev) &&
4627 $fix &&
4628 $prevrawline =~ /^\+.*"\s*$/ &&
4629 $last_coalesced_string_linenr != $linenr - 1) {
4630 my $extracted_string = get_quoted_string($line, $rawline);
4631 my $comma_close = "";
4632 if ($rawline =~ /\Q$extracted_string\E(\s*\)\s*;\s*$|\s*,\s*)/) {
4633 $comma_close = $1;
4634 }
4635
4636 fix_delete_line($fixlinenr - 1, $prevrawline);
4637 fix_delete_line($fixlinenr, $rawline);
4638 my $fixedline = $prevrawline;
4639 $fixedline =~ s/"\s*$//;
4640 $fixedline .= substr($extracted_string, 1) . trim($comma_close);
4641 fix_insert_line($fixlinenr - 1, $fixedline);
4642 $fixedline = $rawline;
4643 $fixedline =~ s/\Q$extracted_string\E\Q$comma_close\E//;
4644 if ($fixedline !~ /\+\s*$/) {
4645 fix_insert_line($fixlinenr, $fixedline);
4646 }
4647 $last_coalesced_string_linenr = $linenr;
4648 }
4649 }
4650
4651# check for missing a space in a string concatenation
4652 if ($prevrawline =~ /[^\\]\w"$/ && $rawline =~ /^\+[\t ]+"\w/) {
4653 WARN('MISSING_SPACE',
4654 "break quoted strings at a space character\n" . $hereprev);
4655 }
4656
4657# check for spaces before a quoted newline
4658 if ($rawline =~ /^.*\".*\s\\n/) {
4659 if (WARN("QUOTED_WHITESPACE_BEFORE_NEWLINE",
4660 "unnecessary whitespace before a quoted newline\n" . $herecurr) &&
4661 $fix) {
4662 $fixed[$fixlinenr] =~ s/^(\+.*\".*)\s+\\n/$1\\n/;
4663 }
4664
4665 }
4666
Joe Perchesf17dba42014-10-13 15:51:51 -07004667# concatenated string without spaces between elements
4668 if ($line =~ /"X+"[A-Z_]+/ || $line =~ /[A-Z_]+"X+"/) {
4669 CHK("CONCATENATED_STRING",
4670 "Concatenated strings should use spaces between elements\n" . $herecurr);
4671 }
4672
Joe Perches90ad30e2014-12-10 15:51:59 -08004673# uncoalesced string fragments
4674 if ($line =~ /"X*"\s*"/) {
4675 WARN("STRING_FRAGMENTS",
4676 "Consecutive strings are generally better as a single string\n" . $herecurr);
4677 }
4678
Joe Perches5e4f6ba2014-12-10 15:52:05 -08004679# check for %L{u,d,i} in strings
4680 my $string;
4681 while ($line =~ /(?:^|")([X\t]*)(?:"|$)/g) {
4682 $string = substr($rawline, $-[1], $+[1] - $-[1]);
4683 $string =~ s/%%/__/g;
4684 if ($string =~ /(?<!%)%L[udi]/) {
4685 WARN("PRINTF_L",
4686 "\%Ld/%Lu are not-standard C, use %lld/%llu\n" . $herecurr);
4687 last;
4688 }
4689 }
4690
4691# check for line continuations in quoted strings with odd counts of "
4692 if ($rawline =~ /\\$/ && $rawline =~ tr/"/"/ % 2) {
4693 WARN("LINE_CONTINUATIONS",
4694 "Avoid line continuations in quoted strings\n" . $herecurr);
4695 }
4696
Andy Whitcroft00df3442007-06-08 13:47:06 -07004697# warn about #if 0
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004698 if ($line =~ /^.\s*\#\s*if\s+0\b/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07004699 CHK("REDUNDANT_CODE",
4700 "if this code is redundant consider removing it\n" .
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07004701 $herecurr);
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07004702 }
4703
Andy Whitcroft03df4b52012-12-17 16:01:52 -08004704# check for needless "if (<foo>) fn(<foo>)" uses
4705 if ($prevline =~ /\bif\s*\(\s*($Lval)\s*\)/) {
4706 my $expr = '\s*\(\s*' . quotemeta($1) . '\s*\)\s*;';
4707 if ($line =~ /\b(kfree|usb_free_urb|debugfs_remove(?:_recursive)?)$expr/) {
4708 WARN('NEEDLESS_IF',
Fabio Estevam15160f92014-12-10 15:51:40 -08004709 "$1(NULL) is safe and this check is probably not required\n" . $hereprev);
Greg Kroah-Hartman4c432a82008-07-23 21:29:04 -07004710 }
4711 }
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07004712
Joe Perchesebfdc402014-08-06 16:10:27 -07004713# check for unnecessary "Out of Memory" messages
4714 if ($line =~ /^\+.*\b$logFunctions\s*\(/ &&
4715 $prevline =~ /^[ \+]\s*if\s*\(\s*(\!\s*|NULL\s*==\s*)?($Lval)(\s*==\s*NULL\s*)?\s*\)/ &&
4716 (defined $1 || defined $3) &&
4717 $linenr > 3) {
4718 my $testval = $2;
4719 my $testline = $lines[$linenr - 3];
4720
4721 my ($s, $c) = ctx_statement_block($linenr - 3, $realcnt, 0);
4722# print("line: <$line>\nprevline: <$prevline>\ns: <$s>\nc: <$c>\n\n\n");
4723
4724 if ($c =~ /(?:^|\n)[ \+]\s*(?:$Type\s*)?\Q$testval\E\s*=\s*(?:\([^\)]*\)\s*)?\s*(?:devm_)?(?:[kv][czm]alloc(?:_node|_array)?\b|kstrdup|(?:dev_)?alloc_skb)/) {
4725 WARN("OOM_MESSAGE",
4726 "Possible unnecessary 'out of memory' message\n" . $hereprev);
4727 }
4728 }
4729
Joe Perchesf78d98f2014-10-13 15:52:01 -07004730# check for logging functions with KERN_<LEVEL>
Paolo Bonzinidcaf1122015-02-13 14:38:26 -08004731 if ($line !~ /printk(?:_ratelimited|_once)?\s*\(/ &&
Joe Perchesf78d98f2014-10-13 15:52:01 -07004732 $line =~ /\b$logFunctions\s*\(.*\b(KERN_[A-Z]+)\b/) {
4733 my $level = $1;
4734 if (WARN("UNNECESSARY_KERN_LEVEL",
4735 "Possible unnecessary $level\n" . $herecurr) &&
4736 $fix) {
4737 $fixed[$fixlinenr] =~ s/\s*$level\s*//;
4738 }
4739 }
4740
Joe Perchesabb08a52014-12-10 15:51:46 -08004741# check for mask then right shift without a parentheses
4742 if ($^V && $^V ge 5.10.0 &&
4743 $line =~ /$LvalOrFunc\s*\&\s*($LvalOrFunc)\s*>>/ &&
4744 $4 !~ /^\&/) { # $LvalOrFunc may be &foo, ignore if so
4745 WARN("MASK_THEN_SHIFT",
4746 "Possible precedence defect with mask then right shift - may need parentheses\n" . $herecurr);
4747 }
4748
Joe Perchesb75ac612014-12-10 15:52:02 -08004749# check for pointer comparisons to NULL
4750 if ($^V && $^V ge 5.10.0) {
4751 while ($line =~ /\b$LvalOrFunc\s*(==|\!=)\s*NULL\b/g) {
4752 my $val = $1;
4753 my $equal = "!";
4754 $equal = "" if ($4 eq "!=");
4755 if (CHK("COMPARISON_TO_NULL",
4756 "Comparison to NULL could be written \"${equal}${val}\"\n" . $herecurr) &&
4757 $fix) {
4758 $fixed[$fixlinenr] =~ s/\b\Q$val\E\s*(?:==|\!=)\s*NULL\b/$equal$val/;
4759 }
4760 }
4761 }
4762
Joe Perches8716de32013-09-11 14:24:05 -07004763# check for bad placement of section $InitAttribute (e.g.: __initdata)
4764 if ($line =~ /(\b$InitAttribute\b)/) {
4765 my $attr = $1;
4766 if ($line =~ /^\+\s*static\s+(?:const\s+)?(?:$attr\s+)?($NonptrTypeWithAttr)\s+(?:$attr\s+)?($Ident(?:\[[^]]*\])?)\s*[=;]/) {
4767 my $ptr = $1;
4768 my $var = $2;
4769 if ((($ptr =~ /\b(union|struct)\s+$attr\b/ &&
4770 ERROR("MISPLACED_INIT",
4771 "$attr should be placed after $var\n" . $herecurr)) ||
4772 ($ptr !~ /\b(union|struct)\s+$attr\b/ &&
4773 WARN("MISPLACED_INIT",
4774 "$attr should be placed after $var\n" . $herecurr))) &&
4775 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07004776 $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 -07004777 }
4778 }
4779 }
4780
Joe Perchese970b882013-11-12 15:10:10 -08004781# check for $InitAttributeData (ie: __initdata) with const
4782 if ($line =~ /\bconst\b/ && $line =~ /($InitAttributeData)/) {
4783 my $attr = $1;
4784 $attr =~ /($InitAttributePrefix)(.*)/;
4785 my $attr_prefix = $1;
4786 my $attr_type = $2;
4787 if (ERROR("INIT_ATTRIBUTE",
4788 "Use of const init definition must use ${attr_prefix}initconst\n" . $herecurr) &&
4789 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07004790 $fixed[$fixlinenr] =~
Joe Perchese970b882013-11-12 15:10:10 -08004791 s/$InitAttributeData/${attr_prefix}initconst/;
4792 }
4793 }
4794
4795# check for $InitAttributeConst (ie: __initconst) without const
4796 if ($line !~ /\bconst\b/ && $line =~ /($InitAttributeConst)/) {
4797 my $attr = $1;
4798 if (ERROR("INIT_ATTRIBUTE",
4799 "Use of $attr requires a separate use of const\n" . $herecurr) &&
4800 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07004801 my $lead = $fixed[$fixlinenr] =~
Joe Perchese970b882013-11-12 15:10:10 -08004802 /(^\+\s*(?:static\s+))/;
4803 $lead = rtrim($1);
4804 $lead = "$lead " if ($lead !~ /^\+$/);
4805 $lead = "${lead}const ";
Joe Perches194f66f2014-08-06 16:11:03 -07004806 $fixed[$fixlinenr] =~ s/(^\+\s*(?:static\s+))/$lead/;
Joe Perchese970b882013-11-12 15:10:10 -08004807 }
4808 }
4809
Joe Perchesc17893c2015-04-16 12:44:42 -07004810# check for __read_mostly with const non-pointer (should just be const)
4811 if ($line =~ /\b__read_mostly\b/ &&
4812 $line =~ /($Type)\s*$Ident/ && $1 !~ /\*\s*$/ && $1 =~ /\bconst\b/) {
4813 if (ERROR("CONST_READ_MOSTLY",
4814 "Invalid use of __read_mostly with const type\n" . $herecurr) &&
4815 $fix) {
4816 $fixed[$fixlinenr] =~ s/\s+__read_mostly\b//;
4817 }
4818 }
4819
Joe Perchesfbdb8132014-04-03 14:49:14 -07004820# don't use __constant_<foo> functions outside of include/uapi/
4821 if ($realfile !~ m@^include/uapi/@ &&
4822 $line =~ /(__constant_(?:htons|ntohs|[bl]e(?:16|32|64)_to_cpu|cpu_to_[bl]e(?:16|32|64)))\s*\(/) {
4823 my $constant_func = $1;
4824 my $func = $constant_func;
4825 $func =~ s/^__constant_//;
4826 if (WARN("CONSTANT_CONVERSION",
4827 "$constant_func should be $func\n" . $herecurr) &&
4828 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07004829 $fixed[$fixlinenr] =~ s/\b$constant_func\b/$func/g;
Joe Perchesfbdb8132014-04-03 14:49:14 -07004830 }
4831 }
4832
Patrick Pannuto1a15a252010-08-09 17:21:01 -07004833# prefer usleep_range over udelay
Bruce Allan37581c22013-02-21 16:44:19 -08004834 if ($line =~ /\budelay\s*\(\s*(\d+)\s*\)/) {
Joe Perches43c1d772014-04-03 14:49:11 -07004835 my $delay = $1;
Patrick Pannuto1a15a252010-08-09 17:21:01 -07004836 # ignore udelay's < 10, however
Joe Perches43c1d772014-04-03 14:49:11 -07004837 if (! ($delay < 10) ) {
Joe Perches000d1cc12011-07-25 17:13:25 -07004838 CHK("USLEEP_RANGE",
Joe Perches43c1d772014-04-03 14:49:11 -07004839 "usleep_range is preferred over udelay; see Documentation/timers/timers-howto.txt\n" . $herecurr);
4840 }
4841 if ($delay > 2000) {
4842 WARN("LONG_UDELAY",
4843 "long udelay - prefer mdelay; see arch/arm/include/asm/delay.h\n" . $herecurr);
Patrick Pannuto1a15a252010-08-09 17:21:01 -07004844 }
4845 }
4846
Patrick Pannuto09ef8722010-08-09 17:21:02 -07004847# warn about unexpectedly long msleep's
4848 if ($line =~ /\bmsleep\s*\((\d+)\);/) {
4849 if ($1 < 20) {
Joe Perches000d1cc12011-07-25 17:13:25 -07004850 WARN("MSLEEP",
Joe Perches43c1d772014-04-03 14:49:11 -07004851 "msleep < 20ms can sleep for up to 20ms; see Documentation/timers/timers-howto.txt\n" . $herecurr);
Patrick Pannuto09ef8722010-08-09 17:21:02 -07004852 }
4853 }
4854
Joe Perches36ec1932013-07-03 15:05:25 -07004855# check for comparisons of jiffies
4856 if ($line =~ /\bjiffies\s*$Compare|$Compare\s*jiffies\b/) {
4857 WARN("JIFFIES_COMPARISON",
4858 "Comparing jiffies is almost always wrong; prefer time_after, time_before and friends\n" . $herecurr);
4859 }
4860
Joe Perches9d7a34a2013-07-03 15:05:26 -07004861# check for comparisons of get_jiffies_64()
4862 if ($line =~ /\bget_jiffies_64\s*\(\s*\)\s*$Compare|$Compare\s*get_jiffies_64\s*\(\s*\)/) {
4863 WARN("JIFFIES_COMPARISON",
4864 "Comparing get_jiffies_64() is almost always wrong; prefer time_after64, time_before64 and friends\n" . $herecurr);
4865 }
4866
Andy Whitcroft00df3442007-06-08 13:47:06 -07004867# warn about #ifdefs in C files
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004868# if ($line =~ /^.\s*\#\s*if(|n)def/ && ($realfile =~ /\.c$/)) {
Andy Whitcroft00df3442007-06-08 13:47:06 -07004869# print "#ifdef in C files should be avoided\n";
4870# print "$herecurr";
4871# $clean = 0;
4872# }
4873
Andy Whitcroft22f2a2e2007-08-10 13:01:03 -07004874# warn about spacing in #ifdefs
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004875 if ($line =~ /^.\s*\#\s*(ifdef|ifndef|elif)\s\s+/) {
Joe Perches3705ce52013-07-03 15:05:31 -07004876 if (ERROR("SPACING",
4877 "exactly one space required after that #$1\n" . $herecurr) &&
4878 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07004879 $fixed[$fixlinenr] =~
Joe Perches3705ce52013-07-03 15:05:31 -07004880 s/^(.\s*\#\s*(ifdef|ifndef|elif))\s{2,}/$1 /;
4881 }
4882
Andy Whitcroft22f2a2e2007-08-10 13:01:03 -07004883 }
4884
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07004885# check for spinlock_t definitions without a comment.
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07004886 if ($line =~ /^.\s*(struct\s+mutex|spinlock_t)\s+\S+;/ ||
4887 $line =~ /^.\s*(DEFINE_MUTEX)\s*\(/) {
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07004888 my $which = $1;
4889 if (!ctx_has_comment($first_line, $linenr)) {
Joe Perches000d1cc12011-07-25 17:13:25 -07004890 CHK("UNCOMMENTED_DEFINITION",
4891 "$1 definition without comment\n" . $herecurr);
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07004892 }
4893 }
4894# check for memory barriers without a comment.
4895 if ($line =~ /\b(mb|rmb|wmb|read_barrier_depends|smp_mb|smp_rmb|smp_wmb|smp_read_barrier_depends)\(/) {
4896 if (!ctx_has_comment($first_line, $linenr)) {
Joe Perchesc1fd7bb2013-11-12 15:10:11 -08004897 WARN("MEMORY_BARRIER",
4898 "memory barrier without comment\n" . $herecurr);
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07004899 }
4900 }
4901# check of hardware specific defines
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004902 if ($line =~ m@^.\s*\#\s*if.*\b(__i386__|__powerpc64__|__sun__|__s390x__)\b@ && $realfile !~ m@include/asm-@) {
Joe Perches000d1cc12011-07-25 17:13:25 -07004903 CHK("ARCH_DEFINES",
4904 "architecture specific defines should be avoided\n" . $herecurr);
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004905 }
Andy Whitcroft653d4872007-06-23 17:16:34 -07004906
Tobias Klauserd4977c72010-05-24 14:33:30 -07004907# Check that the storage class is at the beginning of a declaration
4908 if ($line =~ /\b$Storage\b/ && $line !~ /^.\s*$Storage\b/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07004909 WARN("STORAGE_CLASS",
4910 "storage class should be at the beginning of the declaration\n" . $herecurr)
Tobias Klauserd4977c72010-05-24 14:33:30 -07004911 }
4912
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07004913# check the location of the inline attribute, that it is between
4914# storage class and type.
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07004915 if ($line =~ /\b$Type\s+$Inline\b/ ||
4916 $line =~ /\b$Inline\s+$Storage\b/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07004917 ERROR("INLINE_LOCATION",
4918 "inline keyword should sit between storage class and type\n" . $herecurr);
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07004919 }
4920
Andy Whitcroft8905a672007-11-28 16:21:06 -08004921# Check for __inline__ and __inline, prefer inline
Joe Perches2b7ab452013-11-12 15:10:14 -08004922 if ($realfile !~ m@\binclude/uapi/@ &&
4923 $line =~ /\b(__inline__|__inline)\b/) {
Joe Perchesd5e616f2013-09-11 14:23:54 -07004924 if (WARN("INLINE",
4925 "plain inline is preferred over $1\n" . $herecurr) &&
4926 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07004927 $fixed[$fixlinenr] =~ s/\b(__inline__|__inline)\b/inline/;
Joe Perchesd5e616f2013-09-11 14:23:54 -07004928
4929 }
Andy Whitcroft8905a672007-11-28 16:21:06 -08004930 }
4931
Joe Perches3d130fd2011-01-12 17:00:00 -08004932# Check for __attribute__ packed, prefer __packed
Joe Perches2b7ab452013-11-12 15:10:14 -08004933 if ($realfile !~ m@\binclude/uapi/@ &&
4934 $line =~ /\b__attribute__\s*\(\s*\(.*\bpacked\b/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07004935 WARN("PREFER_PACKED",
4936 "__packed is preferred over __attribute__((packed))\n" . $herecurr);
Joe Perches3d130fd2011-01-12 17:00:00 -08004937 }
4938
Joe Perches39b7e282011-07-25 17:13:24 -07004939# Check for __attribute__ aligned, prefer __aligned
Joe Perches2b7ab452013-11-12 15:10:14 -08004940 if ($realfile !~ m@\binclude/uapi/@ &&
4941 $line =~ /\b__attribute__\s*\(\s*\(.*aligned/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07004942 WARN("PREFER_ALIGNED",
4943 "__aligned(size) is preferred over __attribute__((aligned(size)))\n" . $herecurr);
Joe Perches39b7e282011-07-25 17:13:24 -07004944 }
4945
Joe Perches5f14d3b2012-01-10 15:09:52 -08004946# Check for __attribute__ format(printf, prefer __printf
Joe Perches2b7ab452013-11-12 15:10:14 -08004947 if ($realfile !~ m@\binclude/uapi/@ &&
4948 $line =~ /\b__attribute__\s*\(\s*\(\s*format\s*\(\s*printf/) {
Joe Perchesd5e616f2013-09-11 14:23:54 -07004949 if (WARN("PREFER_PRINTF",
4950 "__printf(string-index, first-to-check) is preferred over __attribute__((format(printf, string-index, first-to-check)))\n" . $herecurr) &&
4951 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07004952 $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 -07004953
4954 }
Joe Perches5f14d3b2012-01-10 15:09:52 -08004955 }
4956
Joe Perches6061d942012-03-23 15:02:16 -07004957# Check for __attribute__ format(scanf, prefer __scanf
Joe Perches2b7ab452013-11-12 15:10:14 -08004958 if ($realfile !~ m@\binclude/uapi/@ &&
4959 $line =~ /\b__attribute__\s*\(\s*\(\s*format\s*\(\s*scanf\b/) {
Joe Perchesd5e616f2013-09-11 14:23:54 -07004960 if (WARN("PREFER_SCANF",
4961 "__scanf(string-index, first-to-check) is preferred over __attribute__((format(scanf, string-index, first-to-check)))\n" . $herecurr) &&
4962 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07004963 $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 -07004964 }
Joe Perches6061d942012-03-23 15:02:16 -07004965 }
4966
Joe Perches619a9082014-12-10 15:51:35 -08004967# Check for __attribute__ weak, or __weak declarations (may have link issues)
4968 if ($^V && $^V ge 5.10.0 &&
4969 $line =~ /(?:$Declare|$DeclareMisordered)\s*$Ident\s*$balanced_parens\s*(?:$Attribute)?\s*;/ &&
4970 ($line =~ /\b__attribute__\s*\(\s*\(.*\bweak\b/ ||
4971 $line =~ /\b__weak\b/)) {
4972 ERROR("WEAK_DECLARATION",
4973 "Using weak declarations can have unintended link defects\n" . $herecurr);
4974 }
4975
Joe Perches8f53a9b2010-03-05 13:43:48 -08004976# check for sizeof(&)
4977 if ($line =~ /\bsizeof\s*\(\s*\&/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07004978 WARN("SIZEOF_ADDRESS",
4979 "sizeof(& should be avoided\n" . $herecurr);
Joe Perches8f53a9b2010-03-05 13:43:48 -08004980 }
4981
Joe Perches66c80b62012-07-30 14:41:22 -07004982# check for sizeof without parenthesis
4983 if ($line =~ /\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/) {
Joe Perchesd5e616f2013-09-11 14:23:54 -07004984 if (WARN("SIZEOF_PARENTHESIS",
4985 "sizeof $1 should be sizeof($1)\n" . $herecurr) &&
4986 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07004987 $fixed[$fixlinenr] =~ s/\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/"sizeof(" . trim($1) . ")"/ex;
Joe Perchesd5e616f2013-09-11 14:23:54 -07004988 }
Joe Perches66c80b62012-07-30 14:41:22 -07004989 }
4990
Joe Perches88982fe2012-12-17 16:02:00 -08004991# check for struct spinlock declarations
4992 if ($line =~ /^.\s*\bstruct\s+spinlock\s+\w+\s*;/) {
4993 WARN("USE_SPINLOCK_T",
4994 "struct spinlock should be spinlock_t\n" . $herecurr);
4995 }
4996
Joe Perchesa6962d72013-04-29 16:18:13 -07004997# check for seq_printf uses that could be seq_puts
Joe Perches06668722013-11-12 15:10:07 -08004998 if ($sline =~ /\bseq_printf\s*\(.*"\s*\)\s*;\s*$/) {
Joe Perchesa6962d72013-04-29 16:18:13 -07004999 my $fmt = get_quoted_string($line, $rawline);
Heba Aamercaac1d52015-02-13 14:38:49 -08005000 $fmt =~ s/%%//g;
5001 if ($fmt !~ /%/) {
Joe Perchesd5e616f2013-09-11 14:23:54 -07005002 if (WARN("PREFER_SEQ_PUTS",
5003 "Prefer seq_puts to seq_printf\n" . $herecurr) &&
5004 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07005005 $fixed[$fixlinenr] =~ s/\bseq_printf\b/seq_puts/;
Joe Perchesd5e616f2013-09-11 14:23:54 -07005006 }
Joe Perchesa6962d72013-04-29 16:18:13 -07005007 }
5008 }
5009
Andy Whitcroft554e1652012-01-10 15:09:57 -08005010# Check for misused memsets
Joe Perchesd1fe9c02012-03-23 15:02:16 -07005011 if ($^V && $^V ge 5.10.0 &&
5012 defined $stat &&
Joe Perchesd7c76ba2012-01-10 15:09:58 -08005013 $stat =~ /^\+(?:.*?)\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*$FuncArg\s*\)/s) {
Andy Whitcroft554e1652012-01-10 15:09:57 -08005014
Joe Perchesd7c76ba2012-01-10 15:09:58 -08005015 my $ms_addr = $2;
Joe Perchesd1fe9c02012-03-23 15:02:16 -07005016 my $ms_val = $7;
5017 my $ms_size = $12;
Joe Perchesd7c76ba2012-01-10 15:09:58 -08005018
Andy Whitcroft554e1652012-01-10 15:09:57 -08005019 if ($ms_size =~ /^(0x|)0$/i) {
5020 ERROR("MEMSET",
Joe Perchesd7c76ba2012-01-10 15:09:58 -08005021 "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 -08005022 } elsif ($ms_size =~ /^(0x|)1$/i) {
5023 WARN("MEMSET",
Joe Perchesd7c76ba2012-01-10 15:09:58 -08005024 "single byte memset is suspicious. Swapped 2nd/3rd argument?\n" . "$here\n$stat\n");
5025 }
5026 }
5027
Joe Perches98a9bba2014-01-23 15:54:52 -08005028# Check for memcpy(foo, bar, ETH_ALEN) that could be ether_addr_copy(foo, bar)
5029 if ($^V && $^V ge 5.10.0 &&
5030 $line =~ /^\+(?:.*?)\bmemcpy\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/s) {
5031 if (WARN("PREFER_ETHER_ADDR_COPY",
5032 "Prefer ether_addr_copy() over memcpy() if the Ethernet addresses are __aligned(2)\n" . $herecurr) &&
5033 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07005034 $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 -08005035 }
5036 }
5037
Joe Perchesd7c76ba2012-01-10 15:09:58 -08005038# typecasts on min/max could be min_t/max_t
Joe Perchesd1fe9c02012-03-23 15:02:16 -07005039 if ($^V && $^V ge 5.10.0 &&
5040 defined $stat &&
Joe Perchesd7c76ba2012-01-10 15:09:58 -08005041 $stat =~ /^\+(?:.*?)\b(min|max)\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\)/) {
Joe Perchesd1fe9c02012-03-23 15:02:16 -07005042 if (defined $2 || defined $7) {
Joe Perchesd7c76ba2012-01-10 15:09:58 -08005043 my $call = $1;
5044 my $cast1 = deparenthesize($2);
5045 my $arg1 = $3;
Joe Perchesd1fe9c02012-03-23 15:02:16 -07005046 my $cast2 = deparenthesize($7);
5047 my $arg2 = $8;
Joe Perchesd7c76ba2012-01-10 15:09:58 -08005048 my $cast;
5049
Joe Perchesd1fe9c02012-03-23 15:02:16 -07005050 if ($cast1 ne "" && $cast2 ne "" && $cast1 ne $cast2) {
Joe Perchesd7c76ba2012-01-10 15:09:58 -08005051 $cast = "$cast1 or $cast2";
5052 } elsif ($cast1 ne "") {
5053 $cast = $cast1;
5054 } else {
5055 $cast = $cast2;
5056 }
5057 WARN("MINMAX",
5058 "$call() should probably be ${call}_t($cast, $arg1, $arg2)\n" . "$here\n$stat\n");
Andy Whitcroft554e1652012-01-10 15:09:57 -08005059 }
5060 }
5061
Joe Perches4a273192012-07-30 14:41:20 -07005062# check usleep_range arguments
5063 if ($^V && $^V ge 5.10.0 &&
5064 defined $stat &&
5065 $stat =~ /^\+(?:.*?)\busleep_range\s*\(\s*($FuncArg)\s*,\s*($FuncArg)\s*\)/) {
5066 my $min = $1;
5067 my $max = $7;
5068 if ($min eq $max) {
5069 WARN("USLEEP_RANGE",
5070 "usleep_range should not use min == max args; see Documentation/timers/timers-howto.txt\n" . "$here\n$stat\n");
5071 } elsif ($min =~ /^\d+$/ && $max =~ /^\d+$/ &&
5072 $min > $max) {
5073 WARN("USLEEP_RANGE",
5074 "usleep_range args reversed, use min then max; see Documentation/timers/timers-howto.txt\n" . "$here\n$stat\n");
5075 }
5076 }
5077
Joe Perches823b7942013-11-12 15:10:15 -08005078# check for naked sscanf
5079 if ($^V && $^V ge 5.10.0 &&
5080 defined $stat &&
Joe Perches6c8bd702014-04-03 14:49:16 -07005081 $line =~ /\bsscanf\b/ &&
Joe Perches823b7942013-11-12 15:10:15 -08005082 ($stat !~ /$Ident\s*=\s*sscanf\s*$balanced_parens/ &&
5083 $stat !~ /\bsscanf\s*$balanced_parens\s*(?:$Compare)/ &&
5084 $stat !~ /(?:$Compare)\s*\bsscanf\s*$balanced_parens/)) {
5085 my $lc = $stat =~ tr@\n@@;
5086 $lc = $lc + $linenr;
5087 my $stat_real = raw_line($linenr, 0);
5088 for (my $count = $linenr + 1; $count <= $lc; $count++) {
5089 $stat_real = $stat_real . "\n" . raw_line($count, 0);
5090 }
5091 WARN("NAKED_SSCANF",
5092 "unchecked sscanf return value\n" . "$here\n$stat_real\n");
5093 }
5094
Joe Perchesafc819a2014-06-04 16:12:08 -07005095# check for simple sscanf that should be kstrto<foo>
5096 if ($^V && $^V ge 5.10.0 &&
5097 defined $stat &&
5098 $line =~ /\bsscanf\b/) {
5099 my $lc = $stat =~ tr@\n@@;
5100 $lc = $lc + $linenr;
5101 my $stat_real = raw_line($linenr, 0);
5102 for (my $count = $linenr + 1; $count <= $lc; $count++) {
5103 $stat_real = $stat_real . "\n" . raw_line($count, 0);
5104 }
5105 if ($stat_real =~ /\bsscanf\b\s*\(\s*$FuncArg\s*,\s*("[^"]+")/) {
5106 my $format = $6;
5107 my $count = $format =~ tr@%@%@;
5108 if ($count == 1 &&
5109 $format =~ /^"\%(?i:ll[udxi]|[udxi]ll|ll|[hl]h?[udxi]|[udxi][hl]h?|[hl]h?|[udxi])"$/) {
5110 WARN("SSCANF_TO_KSTRTO",
5111 "Prefer kstrto<type> to single variable sscanf\n" . "$here\n$stat_real\n");
5112 }
5113 }
5114 }
5115
Joe Perches70dc8a42013-09-11 14:23:58 -07005116# check for new externs in .h files.
5117 if ($realfile =~ /\.h$/ &&
5118 $line =~ /^\+\s*(extern\s+)$Type\s*$Ident\s*\(/s) {
Joe Perchesd1d85782013-09-24 15:27:46 -07005119 if (CHK("AVOID_EXTERNS",
5120 "extern prototypes should be avoided in .h files\n" . $herecurr) &&
Joe Perches70dc8a42013-09-11 14:23:58 -07005121 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07005122 $fixed[$fixlinenr] =~ s/(.*)\bextern\b\s*(.*)/$1$2/;
Joe Perches70dc8a42013-09-11 14:23:58 -07005123 }
5124 }
5125
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07005126# check for new externs in .c files.
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07005127 if ($realfile =~ /\.c$/ && defined $stat &&
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07005128 $stat =~ /^.\s*(?:extern\s+)?$Type\s+($Ident)(\s*)\(/s)
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07005129 {
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07005130 my $function_name = $1;
5131 my $paren_space = $2;
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07005132
5133 my $s = $stat;
5134 if (defined $cond) {
5135 substr($s, 0, length($cond), '');
5136 }
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07005137 if ($s =~ /^\s*;/ &&
5138 $function_name ne 'uninitialized_var')
5139 {
Joe Perches000d1cc12011-07-25 17:13:25 -07005140 WARN("AVOID_EXTERNS",
5141 "externs should be avoided in .c files\n" . $herecurr);
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07005142 }
5143
5144 if ($paren_space =~ /\n/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005145 WARN("FUNCTION_ARGUMENTS",
5146 "arguments for function declarations should follow identifier\n" . $herecurr);
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07005147 }
Andy Whitcroft9c9ba342008-04-29 00:59:33 -07005148
5149 } elsif ($realfile =~ /\.c$/ && defined $stat &&
5150 $stat =~ /^.\s*extern\s+/)
5151 {
Joe Perches000d1cc12011-07-25 17:13:25 -07005152 WARN("AVOID_EXTERNS",
5153 "externs should be avoided in .c files\n" . $herecurr);
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07005154 }
5155
5156# checks for new __setup's
5157 if ($rawline =~ /\b__setup\("([^"]*)"/) {
5158 my $name = $1;
5159
5160 if (!grep(/$name/, @setup_docs)) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005161 CHK("UNDOCUMENTED_SETUP",
5162 "__setup appears un-documented -- check Documentation/kernel-parameters.txt\n" . $herecurr);
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07005163 }
Andy Whitcroft653d4872007-06-23 17:16:34 -07005164 }
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07005165
5166# check for pointless casting of kmalloc return
Joe Perchescaf2a542011-01-12 16:59:56 -08005167 if ($line =~ /\*\s*\)\s*[kv][czm]alloc(_node){0,1}\b/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005168 WARN("UNNECESSARY_CASTS",
5169 "unnecessary cast may hide bugs, see http://c-faq.com/malloc/mallocnocast.html\n" . $herecurr);
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07005170 }
Andy Whitcroft13214ad2008-02-08 04:22:03 -08005171
Joe Perchesa640d252013-07-03 15:05:21 -07005172# alloc style
5173# p = alloc(sizeof(struct foo), ...) should be p = alloc(sizeof(*p), ...)
5174 if ($^V && $^V ge 5.10.0 &&
5175 $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*([kv][mz]alloc(?:_node)?)\s*\(\s*(sizeof\s*\(\s*struct\s+$Lval\s*\))/) {
5176 CHK("ALLOC_SIZEOF_STRUCT",
5177 "Prefer $3(sizeof(*$1)...) over $3($4...)\n" . $herecurr);
5178 }
5179
Joe Perches60a55362014-06-04 16:12:07 -07005180# check for k[mz]alloc with multiplies that could be kmalloc_array/kcalloc
5181 if ($^V && $^V ge 5.10.0 &&
Joe Perchese3674552014-08-06 16:10:55 -07005182 $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 -07005183 my $oldfunc = $3;
5184 my $a1 = $4;
5185 my $a2 = $10;
5186 my $newfunc = "kmalloc_array";
5187 $newfunc = "kcalloc" if ($oldfunc eq "kzalloc");
Joe Perchese3674552014-08-06 16:10:55 -07005188 my $r1 = $a1;
5189 my $r2 = $a2;
5190 if ($a1 =~ /^sizeof\s*\S/) {
5191 $r1 = $a2;
5192 $r2 = $a1;
5193 }
5194 if ($r1 !~ /^sizeof\b/ && $r2 =~ /^sizeof\s*\S/ &&
5195 !($r1 =~ /^$Constant$/ || $r1 =~ /^[A-Z_][A-Z0-9_]*$/)) {
Joe Perches60a55362014-06-04 16:12:07 -07005196 if (WARN("ALLOC_WITH_MULTIPLY",
5197 "Prefer $newfunc over $oldfunc with multiply\n" . $herecurr) &&
5198 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07005199 $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 -07005200
5201 }
5202 }
5203 }
5204
Joe Perches972fdea2013-04-29 16:18:12 -07005205# check for krealloc arg reuse
5206 if ($^V && $^V ge 5.10.0 &&
5207 $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*krealloc\s*\(\s*\1\s*,/) {
5208 WARN("KREALLOC_ARG_REUSE",
5209 "Reusing the krealloc arg is almost always a bug\n" . $herecurr);
5210 }
5211
Joe Perches5ce59ae2013-02-21 16:44:18 -08005212# check for alloc argument mismatch
5213 if ($line =~ /\b(kcalloc|kmalloc_array)\s*\(\s*sizeof\b/) {
5214 WARN("ALLOC_ARRAY_ARGS",
5215 "$1 uses number as first arg, sizeof is generally wrong\n" . $herecurr);
5216 }
5217
Joe Perchescaf2a542011-01-12 16:59:56 -08005218# check for multiple semicolons
5219 if ($line =~ /;\s*;\s*$/) {
Joe Perchesd5e616f2013-09-11 14:23:54 -07005220 if (WARN("ONE_SEMICOLON",
5221 "Statements terminations use 1 semicolon\n" . $herecurr) &&
5222 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07005223 $fixed[$fixlinenr] =~ s/(\s*;\s*){2,}$/;/g;
Joe Perchesd5e616f2013-09-11 14:23:54 -07005224 }
Joe Perchesd1e2ad02012-12-17 16:02:01 -08005225 }
5226
Joe Perches0ab90192014-12-10 15:51:57 -08005227# check for #defines like: 1 << <digit> that could be BIT(digit)
5228 if ($line =~ /#\s*define\s+\w+\s+\(?\s*1\s*([ulUL]*)\s*\<\<\s*(?:\d+|$Ident)\s*\)?/) {
5229 my $ull = "";
5230 $ull = "_ULL" if (defined($1) && $1 =~ /ll/i);
5231 if (CHK("BIT_MACRO",
5232 "Prefer using the BIT$ull macro\n" . $herecurr) &&
5233 $fix) {
5234 $fixed[$fixlinenr] =~ s/\(?\s*1\s*[ulUL]*\s*<<\s*(\d+|$Ident)\s*\)?/BIT${ull}($1)/;
5235 }
5236 }
5237
Joe Perchese81f2392014-08-06 16:11:25 -07005238# check for case / default statements not preceded by break/fallthrough/switch
Joe Perchesc34c09a2014-01-23 15:54:43 -08005239 if ($line =~ /^.\s*(?:case\s+(?:$Ident|$Constant)\s*|default):/) {
5240 my $has_break = 0;
5241 my $has_statement = 0;
5242 my $count = 0;
5243 my $prevline = $linenr;
Joe Perchese81f2392014-08-06 16:11:25 -07005244 while ($prevline > 1 && ($file || $count < 3) && !$has_break) {
Joe Perchesc34c09a2014-01-23 15:54:43 -08005245 $prevline--;
5246 my $rline = $rawlines[$prevline - 1];
5247 my $fline = $lines[$prevline - 1];
5248 last if ($fline =~ /^\@\@/);
5249 next if ($fline =~ /^\-/);
5250 next if ($fline =~ /^.(?:\s*(?:case\s+(?:$Ident|$Constant)[\s$;]*|default):[\s$;]*)*$/);
5251 $has_break = 1 if ($rline =~ /fall[\s_-]*(through|thru)/i);
5252 next if ($fline =~ /^.[\s$;]*$/);
5253 $has_statement = 1;
5254 $count++;
5255 $has_break = 1 if ($fline =~ /\bswitch\b|\b(?:break\s*;[\s$;]*$|return\b|goto\b|continue\b)/);
5256 }
5257 if (!$has_break && $has_statement) {
5258 WARN("MISSING_BREAK",
5259 "Possible switch case/default not preceeded by break or fallthrough comment\n" . $herecurr);
5260 }
5261 }
5262
Joe Perchesd1e2ad02012-12-17 16:02:01 -08005263# check for switch/default statements without a break;
5264 if ($^V && $^V ge 5.10.0 &&
5265 defined $stat &&
5266 $stat =~ /^\+[$;\s]*(?:case[$;\s]+\w+[$;\s]*:[$;\s]*|)*[$;\s]*\bdefault[$;\s]*:[$;\s]*;/g) {
5267 my $ctx = '';
5268 my $herectx = $here . "\n";
5269 my $cnt = statement_rawlines($stat);
5270 for (my $n = 0; $n < $cnt; $n++) {
5271 $herectx .= raw_line($linenr, $n) . "\n";
5272 }
5273 WARN("DEFAULT_NO_BREAK",
5274 "switch default: should use break\n" . $herectx);
Joe Perchescaf2a542011-01-12 16:59:56 -08005275 }
5276
Andy Whitcroft13214ad2008-02-08 04:22:03 -08005277# check for gcc specific __FUNCTION__
Joe Perchesd5e616f2013-09-11 14:23:54 -07005278 if ($line =~ /\b__FUNCTION__\b/) {
5279 if (WARN("USE_FUNC",
5280 "__func__ should be used instead of gcc specific __FUNCTION__\n" . $herecurr) &&
5281 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07005282 $fixed[$fixlinenr] =~ s/\b__FUNCTION__\b/__func__/g;
Joe Perchesd5e616f2013-09-11 14:23:54 -07005283 }
Andy Whitcroft13214ad2008-02-08 04:22:03 -08005284 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07005285
Joe Perches62ec8182015-02-13 14:38:18 -08005286# check for uses of __DATE__, __TIME__, __TIMESTAMP__
5287 while ($line =~ /\b(__(?:DATE|TIME|TIMESTAMP)__)\b/g) {
5288 ERROR("DATE_TIME",
5289 "Use of the '$1' macro makes the build non-deterministic\n" . $herecurr);
5290 }
5291
Joe Perches2c924882012-03-23 15:02:20 -07005292# check for use of yield()
5293 if ($line =~ /\byield\s*\(\s*\)/) {
5294 WARN("YIELD",
5295 "Using yield() is generally wrong. See yield() kernel-doc (sched/core.c)\n" . $herecurr);
5296 }
5297
Joe Perches179f8f42013-07-03 15:05:30 -07005298# check for comparisons against true and false
5299 if ($line =~ /\+\s*(.*?)\b(true|false|$Lval)\s*(==|\!=)\s*(true|false|$Lval)\b(.*)$/i) {
5300 my $lead = $1;
5301 my $arg = $2;
5302 my $test = $3;
5303 my $otype = $4;
5304 my $trail = $5;
5305 my $op = "!";
5306
5307 ($arg, $otype) = ($otype, $arg) if ($arg =~ /^(?:true|false)$/i);
5308
5309 my $type = lc($otype);
5310 if ($type =~ /^(?:true|false)$/) {
5311 if (("$test" eq "==" && "$type" eq "true") ||
5312 ("$test" eq "!=" && "$type" eq "false")) {
5313 $op = "";
5314 }
5315
5316 CHK("BOOL_COMPARISON",
5317 "Using comparison to $otype is error prone\n" . $herecurr);
5318
5319## maybe suggesting a correct construct would better
5320## "Using comparison to $otype is error prone. Perhaps use '${lead}${op}${arg}${trail}'\n" . $herecurr);
5321
5322 }
5323 }
5324
Thomas Gleixner4882720b2010-09-07 14:34:01 +00005325# check for semaphores initialized locked
5326 if ($line =~ /^.\s*sema_init.+,\W?0\W?\)/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005327 WARN("CONSIDER_COMPLETION",
5328 "consider using a completion\n" . $herecurr);
Andy Whitcroft773647a2008-03-28 14:15:58 -07005329 }
Joe Perches6712d852012-03-23 15:02:20 -07005330
Joe Perches67d0a072011-10-31 17:13:10 -07005331# recommend kstrto* over simple_strto* and strict_strto*
5332 if ($line =~ /\b((simple|strict)_(strto(l|ll|ul|ull)))\s*\(/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005333 WARN("CONSIDER_KSTRTO",
Joe Perches67d0a072011-10-31 17:13:10 -07005334 "$1 is obsolete, use k$3 instead\n" . $herecurr);
Andy Whitcroft773647a2008-03-28 14:15:58 -07005335 }
Joe Perches6712d852012-03-23 15:02:20 -07005336
Fabian Frederickae3ccc42014-06-04 16:12:10 -07005337# check for __initcall(), use device_initcall() explicitly or more appropriate function please
Michael Ellermanf3db6632008-07-23 21:28:57 -07005338 if ($line =~ /^.\s*__initcall\s*\(/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005339 WARN("USE_DEVICE_INITCALL",
Fabian Frederickae3ccc42014-06-04 16:12:10 -07005340 "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 -07005341 }
Joe Perches6712d852012-03-23 15:02:20 -07005342
Joe Perches0f3c5aa2015-02-13 14:39:05 -08005343# check for various structs that are normally const (ops, kgdb, device_tree)
5344 my $const_structs = qr{
5345 acpi_dock_ops|
Emese Revfy79404842010-03-05 13:43:53 -08005346 address_space_operations|
5347 backlight_ops|
5348 block_device_operations|
5349 dentry_operations|
5350 dev_pm_ops|
5351 dma_map_ops|
5352 extent_io_ops|
5353 file_lock_operations|
5354 file_operations|
5355 hv_ops|
5356 ide_dma_ops|
5357 intel_dvo_dev_ops|
5358 item_operations|
5359 iwl_ops|
5360 kgdb_arch|
5361 kgdb_io|
5362 kset_uevent_ops|
5363 lock_manager_operations|
5364 microcode_ops|
5365 mtrr_ops|
5366 neigh_ops|
5367 nlmsvc_binding|
Joe Perches0f3c5aa2015-02-13 14:39:05 -08005368 of_device_id|
Emese Revfy79404842010-03-05 13:43:53 -08005369 pci_raw_ops|
5370 pipe_buf_operations|
5371 platform_hibernation_ops|
5372 platform_suspend_ops|
5373 proto_ops|
5374 rpc_pipe_ops|
5375 seq_operations|
5376 snd_ac97_build_ops|
5377 soc_pcmcia_socket_ops|
5378 stacktrace_ops|
5379 sysfs_ops|
5380 tty_operations|
Joe Perches6d07d01b2015-04-16 12:44:33 -07005381 uart_ops|
Emese Revfy79404842010-03-05 13:43:53 -08005382 usb_mon_operations|
5383 wd_ops}x;
Andy Whitcroft6903ffb2009-01-15 13:51:07 -08005384 if ($line !~ /\bconst\b/ &&
Joe Perches0f3c5aa2015-02-13 14:39:05 -08005385 $line =~ /\bstruct\s+($const_structs)\b/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005386 WARN("CONST_STRUCT",
5387 "struct $1 should normally be const\n" .
Andy Whitcroft6903ffb2009-01-15 13:51:07 -08005388 $herecurr);
Andy Whitcroft2b6db5c2009-01-06 14:41:29 -08005389 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07005390
5391# use of NR_CPUS is usually wrong
5392# ignore definitions of NR_CPUS and usage to define arrays as likely right
5393 if ($line =~ /\bNR_CPUS\b/ &&
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07005394 $line !~ /^.\s*\s*#\s*if\b.*\bNR_CPUS\b/ &&
5395 $line !~ /^.\s*\s*#\s*define\b.*\bNR_CPUS\b/ &&
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07005396 $line !~ /^.\s*$Declare\s.*\[[^\]]*NR_CPUS[^\]]*\]/ &&
5397 $line !~ /\[[^\]]*\.\.\.[^\]]*NR_CPUS[^\]]*\]/ &&
5398 $line !~ /\[[^\]]*NR_CPUS[^\]]*\.\.\.[^\]]*\]/)
Andy Whitcroft773647a2008-03-28 14:15:58 -07005399 {
Joe Perches000d1cc12011-07-25 17:13:25 -07005400 WARN("NR_CPUS",
5401 "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 -07005402 }
Andy Whitcroft9c9ba342008-04-29 00:59:33 -07005403
Joe Perches52ea8502013-11-12 15:10:09 -08005404# Use of __ARCH_HAS_<FOO> or ARCH_HAVE_<BAR> is wrong.
5405 if ($line =~ /\+\s*#\s*define\s+((?:__)?ARCH_(?:HAS|HAVE)\w*)\b/) {
5406 ERROR("DEFINE_ARCH_HAS",
5407 "#define of '$1' is wrong - use Kconfig variables or standard guards instead\n" . $herecurr);
5408 }
5409
Joe Perchesacd93622015-02-13 14:38:38 -08005410# likely/unlikely comparisons similar to "(likely(foo) > 0)"
5411 if ($^V && $^V ge 5.10.0 &&
5412 $line =~ /\b((?:un)?likely)\s*\(\s*$FuncArg\s*\)\s*$Compare/) {
5413 WARN("LIKELY_MISUSE",
5414 "Using $1 should generally have parentheses around the comparison\n" . $herecurr);
5415 }
5416
Andy Whitcroft691d77b2009-01-06 14:41:16 -08005417# whine mightly about in_atomic
5418 if ($line =~ /\bin_atomic\s*\(/) {
5419 if ($realfile =~ m@^drivers/@) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005420 ERROR("IN_ATOMIC",
5421 "do not use in_atomic in drivers\n" . $herecurr);
Andy Whitcroftf4a87732009-02-27 14:03:05 -08005422 } elsif ($realfile !~ m@^kernel/@) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005423 WARN("IN_ATOMIC",
5424 "use of in_atomic() is incorrect outside core kernel code\n" . $herecurr);
Andy Whitcroft691d77b2009-01-06 14:41:16 -08005425 }
5426 }
Peter Zijlstra1704f472010-03-19 01:37:42 +01005427
5428# check for lockdep_set_novalidate_class
5429 if ($line =~ /^.\s*lockdep_set_novalidate_class\s*\(/ ||
5430 $line =~ /__lockdep_no_validate__\s*\)/ ) {
5431 if ($realfile !~ m@^kernel/lockdep@ &&
5432 $realfile !~ m@^include/linux/lockdep@ &&
5433 $realfile !~ m@^drivers/base/core@) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005434 ERROR("LOCKDEP",
5435 "lockdep_no_validate class is reserved for device->mutex.\n" . $herecurr);
Peter Zijlstra1704f472010-03-19 01:37:42 +01005436 }
5437 }
Dave Jones88f88312011-01-12 16:59:59 -08005438
Joe Perchesb392c642015-04-16 12:44:16 -07005439 if ($line =~ /debugfs_create_\w+.*\b$mode_perms_world_writable\b/ ||
5440 $line =~ /DEVICE_ATTR.*\b$mode_perms_world_writable\b/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005441 WARN("EXPORTED_WORLD_WRITABLE",
5442 "Exporting world writable files is usually an error. Consider more restrictive permissions.\n" . $herecurr);
Dave Jones88f88312011-01-12 16:59:59 -08005443 }
Joe Perches24358802014-04-03 14:49:13 -07005444
Joe Perches515a2352014-04-03 14:49:24 -07005445# Mode permission misuses where it seems decimal should be octal
5446# This uses a shortcut match to avoid unnecessary uses of a slow foreach loop
5447 if ($^V && $^V ge 5.10.0 &&
5448 $line =~ /$mode_perms_search/) {
5449 foreach my $entry (@mode_permission_funcs) {
5450 my $func = $entry->[0];
5451 my $arg_pos = $entry->[1];
Joe Perches24358802014-04-03 14:49:13 -07005452
Joe Perches515a2352014-04-03 14:49:24 -07005453 my $skip_args = "";
5454 if ($arg_pos > 1) {
5455 $arg_pos--;
5456 $skip_args = "(?:\\s*$FuncArg\\s*,\\s*){$arg_pos,$arg_pos}";
5457 }
5458 my $test = "\\b$func\\s*\\(${skip_args}([\\d]+)\\s*[,\\)]";
5459 if ($line =~ /$test/) {
5460 my $val = $1;
5461 $val = $6 if ($skip_args ne "");
Joe Perches24358802014-04-03 14:49:13 -07005462
Joe Perches515a2352014-04-03 14:49:24 -07005463 if ($val !~ /^0$/ &&
5464 (($val =~ /^$Int$/ && $val !~ /^$Octal$/) ||
5465 length($val) ne 4)) {
5466 ERROR("NON_OCTAL_PERMISSIONS",
5467 "Use 4 digit octal (0777) not decimal permissions\n" . $herecurr);
Joe Perchesc0a5c892015-02-13 14:38:21 -08005468 } elsif ($val =~ /^$Octal$/ && (oct($val) & 02)) {
5469 ERROR("EXPORTED_WORLD_WRITABLE",
5470 "Exporting writable files is usually an error. Consider more restrictive permissions.\n" . $herecurr);
Joe Perches515a2352014-04-03 14:49:24 -07005471 }
Joe Perches24358802014-04-03 14:49:13 -07005472 }
5473 }
5474 }
Andy Whitcroft13214ad2008-02-08 04:22:03 -08005475 }
5476
5477 # If we have no input at all, then there is nothing to report on
5478 # so just keep quiet.
5479 if ($#rawlines == -1) {
5480 exit(0);
Andy Whitcroft0a920b52007-06-01 00:46:48 -07005481 }
5482
Andy Whitcroft8905a672007-11-28 16:21:06 -08005483 # In mailback mode only produce a report in the negative, for
5484 # things that appear to be patches.
5485 if ($mailback && ($clean == 1 || !$is_patch)) {
5486 exit(0);
5487 }
5488
5489 # This is not a patch, and we are are in 'no-patch' mode so
5490 # just keep quiet.
5491 if (!$chk_patch && !$is_patch) {
5492 exit(0);
5493 }
5494
5495 if (!$is_patch) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005496 ERROR("NOT_UNIFIED_DIFF",
5497 "Does not appear to be a unified-diff format patch\n");
Andy Whitcroft0a920b52007-06-01 00:46:48 -07005498 }
5499 if ($is_patch && $chk_signoff && $signoff == 0) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005500 ERROR("MISSING_SIGN_OFF",
5501 "Missing Signed-off-by: line(s)\n");
Andy Whitcroft0a920b52007-06-01 00:46:48 -07005502 }
5503
Andy Whitcroft8905a672007-11-28 16:21:06 -08005504 print report_dump();
Andy Whitcroft13214ad2008-02-08 04:22:03 -08005505 if ($summary && !($clean == 1 && $quiet == 1)) {
5506 print "$filename " if ($summary_file);
Andy Whitcroft8905a672007-11-28 16:21:06 -08005507 print "total: $cnt_error errors, $cnt_warn warnings, " .
5508 (($check)? "$cnt_chk checks, " : "") .
5509 "$cnt_lines lines checked\n";
5510 print "\n" if ($quiet == 0);
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07005511 }
Andy Whitcroft8905a672007-11-28 16:21:06 -08005512
Andy Whitcroftd2c0a232010-10-26 14:23:12 -07005513 if ($quiet == 0) {
Joe Perchesd1fe9c02012-03-23 15:02:16 -07005514
5515 if ($^V lt 5.10.0) {
5516 print("NOTE: perl $^V is not modern enough to detect all possible issues.\n");
5517 print("An upgrade to at least perl v5.10.0 is suggested.\n\n");
5518 }
5519
Andy Whitcroftd2c0a232010-10-26 14:23:12 -07005520 # If there were whitespace errors which cleanpatch can fix
5521 # then suggest that.
5522 if ($rpt_cleaners) {
5523 print "NOTE: whitespace errors detected, you may wish to use scripts/cleanpatch or\n";
5524 print " scripts/cleanfile\n\n";
Mike Frysingerb0781212011-03-22 16:34:43 -07005525 $rpt_cleaners = 0;
Andy Whitcroftd2c0a232010-10-26 14:23:12 -07005526 }
5527 }
5528
Joe Perches91bfe482013-09-11 14:23:59 -07005529 hash_show_words(\%use_type, "Used");
5530 hash_show_words(\%ignore_type, "Ignored");
Joe Perches000d1cc12011-07-25 17:13:25 -07005531
Joe Perchesd752fcc2014-08-06 16:11:05 -07005532 if ($clean == 0 && $fix &&
5533 ("@rawlines" ne "@fixed" ||
5534 $#fixed_inserted >= 0 || $#fixed_deleted >= 0)) {
Joe Perches9624b8d2014-01-23 15:54:44 -08005535 my $newfile = $filename;
5536 $newfile .= ".EXPERIMENTAL-checkpatch-fixes" if (!$fix_inplace);
Joe Perches3705ce52013-07-03 15:05:31 -07005537 my $linecount = 0;
5538 my $f;
5539
Joe Perchesd752fcc2014-08-06 16:11:05 -07005540 @fixed = fix_inserted_deleted_lines(\@fixed, \@fixed_inserted, \@fixed_deleted);
5541
Joe Perches3705ce52013-07-03 15:05:31 -07005542 open($f, '>', $newfile)
5543 or die "$P: Can't open $newfile for write\n";
5544 foreach my $fixed_line (@fixed) {
5545 $linecount++;
5546 if ($file) {
5547 if ($linecount > 3) {
5548 $fixed_line =~ s/^\+//;
Joe Perchesd752fcc2014-08-06 16:11:05 -07005549 print $f $fixed_line . "\n";
Joe Perches3705ce52013-07-03 15:05:31 -07005550 }
5551 } else {
5552 print $f $fixed_line . "\n";
5553 }
5554 }
5555 close($f);
5556
5557 if (!$quiet) {
5558 print << "EOM";
5559Wrote EXPERIMENTAL --fix correction(s) to '$newfile'
5560
5561Do _NOT_ trust the results written to this file.
5562Do _NOT_ submit these changes without inspecting them for correctness.
5563
5564This EXPERIMENTAL file is simply a convenience to help rewrite patches.
5565No warranties, expressed or implied...
5566
5567EOM
5568 }
5569 }
5570
Andy Whitcroft0a920b52007-06-01 00:46:48 -07005571 if ($clean == 1 && $quiet == 0) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08005572 print "$vname has no obvious style problems and is ready for submission.\n"
Andy Whitcroft0a920b52007-06-01 00:46:48 -07005573 }
5574 if ($clean == 0 && $quiet == 0) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005575 print << "EOM";
5576$vname has style problems, please review.
5577
5578If any of these errors are false positives, please report
5579them to the maintainer, see CHECKPATCH in MAINTAINERS.
5580EOM
Andy Whitcroft0a920b52007-06-01 00:46:48 -07005581 }
Andy Whitcroft13214ad2008-02-08 04:22:03 -08005582
Andy Whitcroft0a920b52007-06-01 00:46:48 -07005583 return $clean;
5584}