blob: 90e1edc8dd42fbfba3c31d03214f99d4e3c361b4 [file] [log] [blame]
Andy Whitcroft0a920b52007-06-01 00:46:48 -07001#!/usr/bin/perl -w
Dave Jonesdbf004d2010-01-12 16:59:52 -05002# (c) 2001, Dave Jones. (the file handling bit)
Andy Whitcroft00df3442007-06-08 13:47:06 -07003# (c) 2005, Joel Schopp <jschopp@austin.ibm.com> (the ugly bit)
Andy Whitcroft2a5a2c22009-01-06 14:41:23 -08004# (c) 2007,2008, Andy Whitcroft <apw@uk.ibm.com> (new conditions, test suite)
Andy Whitcroft015830b2010-10-26 14:23:17 -07005# (c) 2008-2010 Andy Whitcroft <apw@canonical.com>
Andy Whitcroft0a920b52007-06-01 00:46:48 -07006# Licensed under the terms of the GNU GPL License version 2
7
8use strict;
Joe Perchesc707a812013-07-08 16:00:43 -07009use POSIX;
Joe Perches36061e32014-12-10 15:51:43 -080010use File::Basename;
11use Cwd 'abs_path';
Joe Perches57230292015-06-25 15:03:03 -070012use Term::ANSIColor qw(:constants);
Andy Whitcroft0a920b52007-06-01 00:46:48 -070013
14my $P = $0;
Joe Perches36061e32014-12-10 15:51:43 -080015my $D = dirname(abs_path($P));
Andy Whitcroft0a920b52007-06-01 00:46:48 -070016
Joe Perches000d1cc12011-07-25 17:13:25 -070017my $V = '0.32';
Andy Whitcroft0a920b52007-06-01 00:46:48 -070018
19use Getopt::Long qw(:config no_auto_abbrev);
20
21my $quiet = 0;
22my $tree = 1;
23my $chk_signoff = 1;
24my $chk_patch = 1;
Andy Whitcroft773647a2008-03-28 14:15:58 -070025my $tst_only;
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -070026my $emacs = 0;
Andy Whitcroft8905a672007-11-28 16:21:06 -080027my $terse = 0;
Joe Perches34d88152015-06-25 15:03:05 -070028my $showfile = 0;
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -070029my $file = 0;
30my $check = 0;
Joe Perches2ac73b4f2014-06-04 16:12:05 -070031my $check_orig = 0;
Andy Whitcroft8905a672007-11-28 16:21:06 -080032my $summary = 1;
33my $mailback = 0;
Andy Whitcroft13214ad2008-02-08 04:22:03 -080034my $summary_file = 0;
Joe Perches000d1cc12011-07-25 17:13:25 -070035my $show_types = 0;
Joe Perches3705ce52013-07-03 15:05:31 -070036my $fix = 0;
Joe Perches9624b8d2014-01-23 15:54:44 -080037my $fix_inplace = 0;
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -070038my $root;
Andy Whitcroftc2fdda02008-02-08 04:20:54 -080039my %debug;
Joe Perches34456862013-07-03 15:05:34 -070040my %camelcase = ();
Joe Perches91bfe482013-09-11 14:23:59 -070041my %use_type = ();
42my @use = ();
43my %ignore_type = ();
Joe Perches000d1cc12011-07-25 17:13:25 -070044my @ignore = ();
Hannes Eder77f5b102009-09-21 17:04:37 -070045my $help = 0;
Joe Perches000d1cc12011-07-25 17:13:25 -070046my $configuration_file = ".checkpatch.conf";
Joe Perches6cd7f382012-12-17 16:01:54 -080047my $max_line_length = 80;
Dave Hansend62a2012013-09-11 14:23:56 -070048my $ignore_perl_version = 0;
49my $minimum_perl_version = 5.10.0;
Vadim Bendebury56193272014-10-13 15:51:48 -070050my $min_conf_desc_length = 4;
Kees Cook66b47b42014-10-13 15:51:57 -070051my $spelling_file = "$D/spelling.txt";
Joe Perchesebfd7d62015-04-16 12:44:14 -070052my $codespell = 0;
Maxim Uvarovf1a63672015-06-25 15:03:08 -070053my $codespellfile = "/usr/share/codespell/dictionary.txt";
Joe Perches57230292015-06-25 15:03:03 -070054my $color = 1;
Hannes Eder77f5b102009-09-21 17:04:37 -070055
56sub help {
57 my ($exitcode) = @_;
58
59 print << "EOM";
60Usage: $P [OPTION]... [FILE]...
61Version: $V
62
63Options:
64 -q, --quiet quiet
65 --no-tree run without a kernel tree
66 --no-signoff do not check for 'Signed-off-by' line
67 --patch treat FILE as patchfile (default)
68 --emacs emacs compile window format
69 --terse one line per report
Joe Perches34d88152015-06-25 15:03:05 -070070 --showfile emit diffed file position, not input file position
Hannes Eder77f5b102009-09-21 17:04:37 -070071 -f, --file treat FILE as regular source file
72 --subjective, --strict enable more subjective tests
Joe Perches91bfe482013-09-11 14:23:59 -070073 --types TYPE(,TYPE2...) show only these comma separated message types
Joe Perches000d1cc12011-07-25 17:13:25 -070074 --ignore TYPE(,TYPE2...) ignore various comma separated message types
Joe Perches6cd7f382012-12-17 16:01:54 -080075 --max-line-length=n set the maximum line length, if exceeded, warn
Vadim Bendebury56193272014-10-13 15:51:48 -070076 --min-conf-desc-length=n set the min description length, if shorter, warn
Joe Perches000d1cc12011-07-25 17:13:25 -070077 --show-types show the message "types" in the output
Hannes Eder77f5b102009-09-21 17:04:37 -070078 --root=PATH PATH to the kernel tree root
79 --no-summary suppress the per-file summary
80 --mailback only produce a report in case of warnings/errors
81 --summary-file include the filename in summary
82 --debug KEY=[0|1] turn on/off debugging of KEY, where KEY is one of
83 'values', 'possible', 'type', and 'attr' (default
84 is all off)
85 --test-only=WORD report only warnings/errors containing WORD
86 literally
Joe Perches3705ce52013-07-03 15:05:31 -070087 --fix EXPERIMENTAL - may create horrible results
88 If correctable single-line errors exist, create
89 "<inputfile>.EXPERIMENTAL-checkpatch-fixes"
90 with potential errors corrected to the preferred
91 checkpatch style
Joe Perches9624b8d2014-01-23 15:54:44 -080092 --fix-inplace EXPERIMENTAL - may create horrible results
93 Is the same as --fix, but overwrites the input
94 file. It's your fault if there's no backup or git
Dave Hansend62a2012013-09-11 14:23:56 -070095 --ignore-perl-version override checking of perl version. expect
96 runtime errors.
Joe Perchesebfd7d62015-04-16 12:44:14 -070097 --codespell Use the codespell dictionary for spelling/typos
Maxim Uvarovf1a63672015-06-25 15:03:08 -070098 (default:/usr/share/codespell/dictionary.txt)
Joe Perchesebfd7d62015-04-16 12:44:14 -070099 --codespellfile Use this codespell dictionary
Joe Perches57230292015-06-25 15:03:03 -0700100 --color Use colors when output is STDOUT (default: on)
Hannes Eder77f5b102009-09-21 17:04:37 -0700101 -h, --help, --version display this help and exit
102
103When FILE is - read standard input.
104EOM
105
106 exit($exitcode);
107}
108
Joe Perches000d1cc12011-07-25 17:13:25 -0700109my $conf = which_conf($configuration_file);
110if (-f $conf) {
111 my @conf_args;
112 open(my $conffile, '<', "$conf")
113 or warn "$P: Can't find a readable $configuration_file file $!\n";
114
115 while (<$conffile>) {
116 my $line = $_;
117
118 $line =~ s/\s*\n?$//g;
119 $line =~ s/^\s*//g;
120 $line =~ s/\s+/ /g;
121
122 next if ($line =~ m/^\s*#/);
123 next if ($line =~ m/^\s*$/);
124
125 my @words = split(" ", $line);
126 foreach my $word (@words) {
127 last if ($word =~ m/^#/);
128 push (@conf_args, $word);
129 }
130 }
131 close($conffile);
132 unshift(@ARGV, @conf_args) if @conf_args;
133}
134
Andy Whitcroft0a920b52007-06-01 00:46:48 -0700135GetOptions(
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700136 'q|quiet+' => \$quiet,
Andy Whitcroft0a920b52007-06-01 00:46:48 -0700137 'tree!' => \$tree,
138 'signoff!' => \$chk_signoff,
139 'patch!' => \$chk_patch,
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700140 'emacs!' => \$emacs,
Andy Whitcroft8905a672007-11-28 16:21:06 -0800141 'terse!' => \$terse,
Joe Perches34d88152015-06-25 15:03:05 -0700142 'showfile!' => \$showfile,
Hannes Eder77f5b102009-09-21 17:04:37 -0700143 'f|file!' => \$file,
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700144 'subjective!' => \$check,
145 'strict!' => \$check,
Joe Perches000d1cc12011-07-25 17:13:25 -0700146 'ignore=s' => \@ignore,
Joe Perches91bfe482013-09-11 14:23:59 -0700147 'types=s' => \@use,
Joe Perches000d1cc12011-07-25 17:13:25 -0700148 'show-types!' => \$show_types,
Joe Perches6cd7f382012-12-17 16:01:54 -0800149 'max-line-length=i' => \$max_line_length,
Vadim Bendebury56193272014-10-13 15:51:48 -0700150 'min-conf-desc-length=i' => \$min_conf_desc_length,
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700151 'root=s' => \$root,
Andy Whitcroft8905a672007-11-28 16:21:06 -0800152 'summary!' => \$summary,
153 'mailback!' => \$mailback,
Andy Whitcroft13214ad2008-02-08 04:22:03 -0800154 'summary-file!' => \$summary_file,
Joe Perches3705ce52013-07-03 15:05:31 -0700155 'fix!' => \$fix,
Joe Perches9624b8d2014-01-23 15:54:44 -0800156 'fix-inplace!' => \$fix_inplace,
Dave Hansend62a2012013-09-11 14:23:56 -0700157 'ignore-perl-version!' => \$ignore_perl_version,
Andy Whitcroftc2fdda02008-02-08 04:20:54 -0800158 'debug=s' => \%debug,
Andy Whitcroft773647a2008-03-28 14:15:58 -0700159 'test-only=s' => \$tst_only,
Joe Perchesebfd7d62015-04-16 12:44:14 -0700160 'codespell!' => \$codespell,
161 'codespellfile=s' => \$codespellfile,
Joe Perches57230292015-06-25 15:03:03 -0700162 'color!' => \$color,
Hannes Eder77f5b102009-09-21 17:04:37 -0700163 'h|help' => \$help,
164 'version' => \$help
165) or help(1);
166
167help(0) if ($help);
Andy Whitcroft0a920b52007-06-01 00:46:48 -0700168
Joe Perches9624b8d2014-01-23 15:54:44 -0800169$fix = 1 if ($fix_inplace);
Joe Perches2ac73b4f2014-06-04 16:12:05 -0700170$check_orig = $check;
Joe Perches9624b8d2014-01-23 15:54:44 -0800171
Andy Whitcroft0a920b52007-06-01 00:46:48 -0700172my $exit = 0;
173
Dave Hansend62a2012013-09-11 14:23:56 -0700174if ($^V && $^V lt $minimum_perl_version) {
175 printf "$P: requires at least perl version %vd\n", $minimum_perl_version;
176 if (!$ignore_perl_version) {
177 exit(1);
178 }
179}
180
Andy Whitcroft0a920b52007-06-01 00:46:48 -0700181if ($#ARGV < 0) {
Hannes Eder77f5b102009-09-21 17:04:37 -0700182 print "$P: no input files\n";
Andy Whitcroft0a920b52007-06-01 00:46:48 -0700183 exit(1);
184}
185
Joe Perches91bfe482013-09-11 14:23:59 -0700186sub hash_save_array_words {
187 my ($hashRef, $arrayRef) = @_;
Joe Perches000d1cc12011-07-25 17:13:25 -0700188
Joe Perches91bfe482013-09-11 14:23:59 -0700189 my @array = split(/,/, join(',', @$arrayRef));
190 foreach my $word (@array) {
191 $word =~ s/\s*\n?$//g;
192 $word =~ s/^\s*//g;
193 $word =~ s/\s+/ /g;
194 $word =~ tr/[a-z]/[A-Z]/;
Joe Perches000d1cc12011-07-25 17:13:25 -0700195
Joe Perches91bfe482013-09-11 14:23:59 -0700196 next if ($word =~ m/^\s*#/);
197 next if ($word =~ m/^\s*$/);
198
199 $hashRef->{$word}++;
200 }
Joe Perches000d1cc12011-07-25 17:13:25 -0700201}
202
Joe Perches91bfe482013-09-11 14:23:59 -0700203sub hash_show_words {
204 my ($hashRef, $prefix) = @_;
205
Joe Perches3c816e42015-06-25 15:03:29 -0700206 if (keys %$hashRef) {
Joe Perchesd8469f12015-06-25 15:03:00 -0700207 print "\nNOTE: $prefix message types:";
Joe Perches58cb3cf2013-09-11 14:24:04 -0700208 foreach my $word (sort keys %$hashRef) {
Joe Perches91bfe482013-09-11 14:23:59 -0700209 print " $word";
210 }
Joe Perchesd8469f12015-06-25 15:03:00 -0700211 print "\n";
Joe Perches91bfe482013-09-11 14:23:59 -0700212 }
213}
214
215hash_save_array_words(\%ignore_type, \@ignore);
216hash_save_array_words(\%use_type, \@use);
217
Andy Whitcroftc2fdda02008-02-08 04:20:54 -0800218my $dbg_values = 0;
219my $dbg_possible = 0;
Andy Whitcroft7429c692008-07-23 21:29:06 -0700220my $dbg_type = 0;
Andy Whitcrofta1ef2772008-10-15 22:02:17 -0700221my $dbg_attr = 0;
Andy Whitcroftc2fdda02008-02-08 04:20:54 -0800222for my $key (keys %debug) {
Andy Whitcroft21caa132009-01-06 14:41:30 -0800223 ## no critic
224 eval "\${dbg_$key} = '$debug{$key}';";
225 die "$@" if ($@);
Andy Whitcroftc2fdda02008-02-08 04:20:54 -0800226}
227
Andy Whitcroftd2c0a232010-10-26 14:23:12 -0700228my $rpt_cleaners = 0;
229
Andy Whitcroft8905a672007-11-28 16:21:06 -0800230if ($terse) {
231 $emacs = 1;
232 $quiet++;
233}
234
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700235if ($tree) {
236 if (defined $root) {
237 if (!top_of_kernel_tree($root)) {
238 die "$P: $root: --root does not point at a valid tree\n";
239 }
240 } else {
241 if (top_of_kernel_tree('.')) {
242 $root = '.';
243 } elsif ($0 =~ m@(.*)/scripts/[^/]*$@ &&
244 top_of_kernel_tree($1)) {
245 $root = $1;
246 }
247 }
248
249 if (!defined $root) {
250 print "Must be run from the top-level dir. of a kernel tree\n";
251 exit(2);
252 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -0700253}
254
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700255my $emitted_corrupt = 0;
256
Andy Whitcroft2ceb5322009-10-26 16:50:14 -0700257our $Ident = qr{
258 [A-Za-z_][A-Za-z\d_]*
259 (?:\s*\#\#\s*[A-Za-z_][A-Za-z\d_]*)*
260 }x;
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700261our $Storage = qr{extern|static|asmlinkage};
262our $Sparse = qr{
263 __user|
264 __kernel|
265 __force|
266 __iomem|
267 __must_check|
268 __init_refok|
Andy Whitcroft417495e2009-02-27 14:03:08 -0800269 __kprobes|
Sven Eckelmann165e72a2011-07-25 17:13:23 -0700270 __ref|
271 __rcu
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700272 }x;
Joe Perchese970b882013-11-12 15:10:10 -0800273our $InitAttributePrefix = qr{__(?:mem|cpu|dev|net_|)};
274our $InitAttributeData = qr{$InitAttributePrefix(?:initdata\b)};
275our $InitAttributeConst = qr{$InitAttributePrefix(?:initconst\b)};
276our $InitAttributeInit = qr{$InitAttributePrefix(?:init\b)};
277our $InitAttribute = qr{$InitAttributeData|$InitAttributeConst|$InitAttributeInit};
Joe Perches8716de32013-09-11 14:24:05 -0700278
Wolfram Sang52131292010-03-05 13:43:51 -0800279# Notes to $Attribute:
280# We need \b after 'init' otherwise 'initconst' will cause a false positive in a check
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700281our $Attribute = qr{
282 const|
Joe Perches03f1df72010-10-26 14:23:16 -0700283 __percpu|
284 __nocast|
285 __safe|
286 __bitwise__|
287 __packed__|
288 __packed2__|
289 __naked|
290 __maybe_unused|
291 __always_unused|
292 __noreturn|
293 __used|
294 __cold|
Joe Perchese23ef1f2015-02-13 14:38:24 -0800295 __pure|
Joe Perches03f1df72010-10-26 14:23:16 -0700296 __noclone|
297 __deprecated|
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700298 __read_mostly|
299 __kprobes|
Joe Perches8716de32013-09-11 14:24:05 -0700300 $InitAttribute|
Andy Whitcroft24e1d812008-10-15 22:02:18 -0700301 ____cacheline_aligned|
302 ____cacheline_aligned_in_smp|
Andy Whitcroft5fe3af12009-01-06 14:41:18 -0800303 ____cacheline_internodealigned_in_smp|
304 __weak
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700305 }x;
Andy Whitcroftc45dcab2008-06-05 22:46:01 -0700306our $Modifier;
Joe Perches91cb5192014-04-03 14:49:32 -0700307our $Inline = qr{inline|__always_inline|noinline|__inline|__inline__};
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700308our $Member = qr{->$Ident|\.$Ident|\[[^]]*\]};
309our $Lval = qr{$Ident(?:$Member)*};
310
Joe Perches95e2c602013-07-03 15:05:20 -0700311our $Int_type = qr{(?i)llu|ull|ll|lu|ul|l|u};
312our $Binary = qr{(?i)0b[01]+$Int_type?};
313our $Hex = qr{(?i)0x[0-9a-f]+$Int_type?};
314our $Int = qr{[0-9]+$Int_type?};
Joe Perches24358802014-04-03 14:49:13 -0700315our $Octal = qr{0[0-7]+$Int_type?};
Joe Perchesc0a5c892015-02-13 14:38:21 -0800316our $String = qr{"[X\t]*"};
Joe Perches326b1ff2013-02-04 14:28:51 -0800317our $Float_hex = qr{(?i)0x[0-9a-f]+p-?[0-9]+[fl]?};
318our $Float_dec = qr{(?i)(?:[0-9]+\.[0-9]*|[0-9]*\.[0-9]+)(?:e-?[0-9]+)?[fl]?};
319our $Float_int = qr{(?i)[0-9]+e-?[0-9]+[fl]?};
Joe Perches74349bc2012-12-17 16:02:05 -0800320our $Float = qr{$Float_hex|$Float_dec|$Float_int};
Joe Perches24358802014-04-03 14:49:13 -0700321our $Constant = qr{$Float|$Binary|$Octal|$Hex|$Int};
Joe Perches326b1ff2013-02-04 14:28:51 -0800322our $Assignment = qr{\*\=|/=|%=|\+=|-=|<<=|>>=|&=|\^=|\|=|=};
Joe Perches447432f2014-04-03 14:49:17 -0700323our $Compare = qr{<=|>=|==|!=|<|(?<!-)>};
Joe Perches23f780c2013-07-03 15:05:31 -0700324our $Arithmetic = qr{\+|-|\*|\/|%};
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700325our $Operators = qr{
326 <=|>=|==|!=|
327 =>|->|<<|>>|<|>|!|~|
Joe Perches23f780c2013-07-03 15:05:31 -0700328 &&|\|\||,|\^|\+\+|--|&|\||$Arithmetic
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700329 }x;
330
Joe Perches91cb5192014-04-03 14:49:32 -0700331our $c90_Keywords = qr{do|for|while|if|else|return|goto|continue|switch|default|case|break}x;
332
Joe Perchesab7e23f2015-04-16 12:44:22 -0700333our $BasicType;
Andy Whitcroft8905a672007-11-28 16:21:06 -0800334our $NonptrType;
Joe Perches18130872014-08-06 16:11:22 -0700335our $NonptrTypeMisordered;
Joe Perches8716de32013-09-11 14:24:05 -0700336our $NonptrTypeWithAttr;
Andy Whitcroft8905a672007-11-28 16:21:06 -0800337our $Type;
Joe Perches18130872014-08-06 16:11:22 -0700338our $TypeMisordered;
Andy Whitcroft8905a672007-11-28 16:21:06 -0800339our $Declare;
Joe Perches18130872014-08-06 16:11:22 -0700340our $DeclareMisordered;
Andy Whitcroft8905a672007-11-28 16:21:06 -0800341
Joe Perches15662b32011-10-31 17:13:12 -0700342our $NON_ASCII_UTF8 = qr{
343 [\xC2-\xDF][\x80-\xBF] # non-overlong 2-byte
Andy Whitcroft171ae1a2008-04-29 00:59:32 -0700344 | \xE0[\xA0-\xBF][\x80-\xBF] # excluding overlongs
345 | [\xE1-\xEC\xEE\xEF][\x80-\xBF]{2} # straight 3-byte
346 | \xED[\x80-\x9F][\x80-\xBF] # excluding surrogates
347 | \xF0[\x90-\xBF][\x80-\xBF]{2} # planes 1-3
348 | [\xF1-\xF3][\x80-\xBF]{3} # planes 4-15
349 | \xF4[\x80-\x8F][\x80-\xBF]{2} # plane 16
350}x;
351
Joe Perches15662b32011-10-31 17:13:12 -0700352our $UTF8 = qr{
353 [\x09\x0A\x0D\x20-\x7E] # ASCII
354 | $NON_ASCII_UTF8
355}x;
356
Joe Perchese6176fa2015-06-25 15:02:49 -0700357our $typeC99Typedefs = qr{(?:__)?(?:[us]_?)?int_?(?:8|16|32|64)_t};
Joe Perches021158b2015-02-13 14:38:43 -0800358our $typeOtherOSTypedefs = qr{(?x:
359 u_(?:char|short|int|long) | # bsd
360 u(?:nchar|short|int|long) # sysv
361)};
Joe Perchese6176fa2015-06-25 15:02:49 -0700362our $typeKernelTypedefs = qr{(?x:
Andy Whitcroftfb9e9092009-09-21 17:04:38 -0700363 (?:__)?(?:u|s|be|le)(?:8|16|32|64)|
Andy Whitcroft8ed22ca2008-10-15 22:02:32 -0700364 atomic_t
365)};
Joe Perchese6176fa2015-06-25 15:02:49 -0700366our $typeTypedefs = qr{(?x:
367 $typeC99Typedefs\b|
368 $typeOtherOSTypedefs\b|
369 $typeKernelTypedefs\b
370)};
Andy Whitcroft8ed22ca2008-10-15 22:02:32 -0700371
Joe Perches691e6692010-03-05 13:43:51 -0800372our $logFunctions = qr{(?x:
Joe Perches6e60c022011-07-25 17:13:27 -0700373 printk(?:_ratelimited|_once|)|
Jacob Keller7d0b6592013-07-03 15:05:35 -0700374 (?:[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 -0700375 WARN(?:_RATELIMIT|_ONCE|)|
Joe Perchesb0531722011-05-24 17:13:40 -0700376 panic|
Joe Perches06668722013-11-12 15:10:07 -0800377 MODULE_[A-Z_]+|
378 seq_vprintf|seq_printf|seq_puts
Joe Perches691e6692010-03-05 13:43:51 -0800379)};
380
Joe Perches20112472011-07-25 17:13:23 -0700381our $signature_tags = qr{(?xi:
382 Signed-off-by:|
383 Acked-by:|
384 Tested-by:|
385 Reviewed-by:|
386 Reported-by:|
Mugunthan V N8543ae12013-04-29 16:18:17 -0700387 Suggested-by:|
Joe Perches20112472011-07-25 17:13:23 -0700388 To:|
389 Cc:
390)};
391
Joe Perches18130872014-08-06 16:11:22 -0700392our @typeListMisordered = (
393 qr{char\s+(?:un)?signed},
394 qr{int\s+(?:(?:un)?signed\s+)?short\s},
395 qr{int\s+short(?:\s+(?:un)?signed)},
396 qr{short\s+int(?:\s+(?:un)?signed)},
397 qr{(?:un)?signed\s+int\s+short},
398 qr{short\s+(?:un)?signed},
399 qr{long\s+int\s+(?:un)?signed},
400 qr{int\s+long\s+(?:un)?signed},
401 qr{long\s+(?:un)?signed\s+int},
402 qr{int\s+(?:un)?signed\s+long},
403 qr{int\s+(?:un)?signed},
404 qr{int\s+long\s+long\s+(?:un)?signed},
405 qr{long\s+long\s+int\s+(?:un)?signed},
406 qr{long\s+long\s+(?:un)?signed\s+int},
407 qr{long\s+long\s+(?:un)?signed},
408 qr{long\s+(?:un)?signed},
409);
410
Andy Whitcroft8905a672007-11-28 16:21:06 -0800411our @typeList = (
412 qr{void},
Joe Perches0c773d92014-08-06 16:11:20 -0700413 qr{(?:(?:un)?signed\s+)?char},
414 qr{(?:(?:un)?signed\s+)?short\s+int},
415 qr{(?:(?:un)?signed\s+)?short},
416 qr{(?:(?:un)?signed\s+)?int},
417 qr{(?:(?:un)?signed\s+)?long\s+int},
418 qr{(?:(?:un)?signed\s+)?long\s+long\s+int},
419 qr{(?:(?:un)?signed\s+)?long\s+long},
420 qr{(?:(?:un)?signed\s+)?long},
421 qr{(?:un)?signed},
Andy Whitcroft8905a672007-11-28 16:21:06 -0800422 qr{float},
423 qr{double},
424 qr{bool},
Andy Whitcroft8905a672007-11-28 16:21:06 -0800425 qr{struct\s+$Ident},
426 qr{union\s+$Ident},
427 qr{enum\s+$Ident},
428 qr{${Ident}_t},
429 qr{${Ident}_handler},
430 qr{${Ident}_handler_fn},
Joe Perches18130872014-08-06 16:11:22 -0700431 @typeListMisordered,
Andy Whitcroft8905a672007-11-28 16:21:06 -0800432);
Alex Dowad485ff232015-06-25 15:02:52 -0700433our @typeListFile = ();
Joe Perches8716de32013-09-11 14:24:05 -0700434our @typeListWithAttr = (
435 @typeList,
436 qr{struct\s+$InitAttribute\s+$Ident},
437 qr{union\s+$InitAttribute\s+$Ident},
438);
439
Andy Whitcroftc45dcab2008-06-05 22:46:01 -0700440our @modifierList = (
441 qr{fastcall},
442);
Alex Dowad485ff232015-06-25 15:02:52 -0700443our @modifierListFile = ();
Andy Whitcroft8905a672007-11-28 16:21:06 -0800444
Joe Perches24358802014-04-03 14:49:13 -0700445our @mode_permission_funcs = (
446 ["module_param", 3],
447 ["module_param_(?:array|named|string)", 4],
448 ["module_param_array_named", 5],
449 ["debugfs_create_(?:file|u8|u16|u32|u64|x8|x16|x32|x64|size_t|atomic_t|bool|blob|regset32|u32_array)", 2],
450 ["proc_create(?:_data|)", 2],
451 ["(?:CLASS|DEVICE|SENSOR)_ATTR", 2],
452);
453
Joe Perches515a2352014-04-03 14:49:24 -0700454#Create a search pattern for all these functions to speed up a loop below
455our $mode_perms_search = "";
456foreach my $entry (@mode_permission_funcs) {
457 $mode_perms_search .= '|' if ($mode_perms_search ne "");
458 $mode_perms_search .= $entry->[0];
459}
460
Joe Perchesb392c642015-04-16 12:44:16 -0700461our $mode_perms_world_writable = qr{
462 S_IWUGO |
463 S_IWOTH |
464 S_IRWXUGO |
465 S_IALLUGO |
466 0[0-7][0-7][2367]
467}x;
468
Wolfram Sang7840a942010-08-09 17:20:57 -0700469our $allowed_asm_includes = qr{(?x:
470 irq|
Sergey Ryazanovcdcee682014-10-13 15:51:44 -0700471 memory|
472 time|
473 reboot
Wolfram Sang7840a942010-08-09 17:20:57 -0700474)};
475# memory.h: ARM has a custom one
476
Kees Cook66b47b42014-10-13 15:51:57 -0700477# Load common spelling mistakes and build regular expression list.
478my $misspellings;
Kees Cook66b47b42014-10-13 15:51:57 -0700479my %spelling_fix;
Kees Cook66b47b42014-10-13 15:51:57 -0700480
Joe Perches36061e32014-12-10 15:51:43 -0800481if (open(my $spelling, '<', $spelling_file)) {
Joe Perches36061e32014-12-10 15:51:43 -0800482 while (<$spelling>) {
483 my $line = $_;
Kees Cook66b47b42014-10-13 15:51:57 -0700484
Joe Perches36061e32014-12-10 15:51:43 -0800485 $line =~ s/\s*\n?$//g;
486 $line =~ s/^\s*//g;
Kees Cook66b47b42014-10-13 15:51:57 -0700487
Joe Perches36061e32014-12-10 15:51:43 -0800488 next if ($line =~ m/^\s*#/);
489 next if ($line =~ m/^\s*$/);
Kees Cook66b47b42014-10-13 15:51:57 -0700490
Joe Perches36061e32014-12-10 15:51:43 -0800491 my ($suspect, $fix) = split(/\|\|/, $line);
492
Joe Perches36061e32014-12-10 15:51:43 -0800493 $spelling_fix{$suspect} = $fix;
494 }
495 close($spelling);
Joe Perches36061e32014-12-10 15:51:43 -0800496} else {
497 warn "No typos will be found - file '$spelling_file': $!\n";
Kees Cook66b47b42014-10-13 15:51:57 -0700498}
Kees Cook66b47b42014-10-13 15:51:57 -0700499
Joe Perchesebfd7d62015-04-16 12:44:14 -0700500if ($codespell) {
501 if (open(my $spelling, '<', $codespellfile)) {
502 while (<$spelling>) {
503 my $line = $_;
504
505 $line =~ s/\s*\n?$//g;
506 $line =~ s/^\s*//g;
507
508 next if ($line =~ m/^\s*#/);
509 next if ($line =~ m/^\s*$/);
510 next if ($line =~ m/, disabled/i);
511
512 $line =~ s/,.*$//;
513
514 my ($suspect, $fix) = split(/->/, $line);
515
516 $spelling_fix{$suspect} = $fix;
517 }
518 close($spelling);
519 } else {
520 warn "No codespell typos will be found - file '$codespellfile': $!\n";
521 }
522}
523
524$misspellings = join("|", sort keys %spelling_fix) if keys %spelling_fix;
525
Andy Whitcroft8905a672007-11-28 16:21:06 -0800526sub build_types {
Alex Dowad485ff232015-06-25 15:02:52 -0700527 my $mods = "(?x: \n" . join("|\n ", (@modifierList, @modifierListFile)) . "\n)";
528 my $all = "(?x: \n" . join("|\n ", (@typeList, @typeListFile)) . "\n)";
Joe Perches18130872014-08-06 16:11:22 -0700529 my $Misordered = "(?x: \n" . join("|\n ", @typeListMisordered) . "\n)";
Joe Perches8716de32013-09-11 14:24:05 -0700530 my $allWithAttr = "(?x: \n" . join("|\n ", @typeListWithAttr) . "\n)";
Andy Whitcroftc8cb2ca2008-07-23 21:28:57 -0700531 $Modifier = qr{(?:$Attribute|$Sparse|$mods)};
Joe Perchesab7e23f2015-04-16 12:44:22 -0700532 $BasicType = qr{
Joe Perchesab7e23f2015-04-16 12:44:22 -0700533 (?:$typeTypedefs\b)|
534 (?:${all}\b)
535 }x;
Andy Whitcroft8905a672007-11-28 16:21:06 -0800536 $NonptrType = qr{
Andy Whitcroftd2172eb2008-07-23 21:29:07 -0700537 (?:$Modifier\s+|const\s+)*
Andy Whitcroftcf655042008-03-04 14:28:20 -0800538 (?:
Andy Whitcroft6b48db22012-01-10 15:10:13 -0800539 (?:typeof|__typeof__)\s*\([^\)]*\)|
Andy Whitcroft8ed22ca2008-10-15 22:02:32 -0700540 (?:$typeTypedefs\b)|
Andy Whitcroftc45dcab2008-06-05 22:46:01 -0700541 (?:${all}\b)
Andy Whitcroftcf655042008-03-04 14:28:20 -0800542 )
Andy Whitcroftc8cb2ca2008-07-23 21:28:57 -0700543 (?:\s+$Modifier|\s+const)*
Andy Whitcroft8905a672007-11-28 16:21:06 -0800544 }x;
Joe Perches18130872014-08-06 16:11:22 -0700545 $NonptrTypeMisordered = qr{
546 (?:$Modifier\s+|const\s+)*
547 (?:
548 (?:${Misordered}\b)
549 )
550 (?:\s+$Modifier|\s+const)*
551 }x;
Joe Perches8716de32013-09-11 14:24:05 -0700552 $NonptrTypeWithAttr = qr{
553 (?:$Modifier\s+|const\s+)*
554 (?:
555 (?:typeof|__typeof__)\s*\([^\)]*\)|
556 (?:$typeTypedefs\b)|
557 (?:${allWithAttr}\b)
558 )
559 (?:\s+$Modifier|\s+const)*
560 }x;
Andy Whitcroft8905a672007-11-28 16:21:06 -0800561 $Type = qr{
Andy Whitcroftc45dcab2008-06-05 22:46:01 -0700562 $NonptrType
Joe Perches1574a292014-08-06 16:10:50 -0700563 (?:(?:\s|\*|\[\])+\s*const|(?:\s|\*\s*(?:const\s*)?|\[\])+|(?:\s*\[\s*\])+)?
Andy Whitcroftc8cb2ca2008-07-23 21:28:57 -0700564 (?:\s+$Inline|\s+$Modifier)*
Andy Whitcroft8905a672007-11-28 16:21:06 -0800565 }x;
Joe Perches18130872014-08-06 16:11:22 -0700566 $TypeMisordered = qr{
567 $NonptrTypeMisordered
568 (?:(?:\s|\*|\[\])+\s*const|(?:\s|\*\s*(?:const\s*)?|\[\])+|(?:\s*\[\s*\])+)?
569 (?:\s+$Inline|\s+$Modifier)*
570 }x;
Joe Perches91cb5192014-04-03 14:49:32 -0700571 $Declare = qr{(?:$Storage\s+(?:$Inline\s+)?)?$Type};
Joe Perches18130872014-08-06 16:11:22 -0700572 $DeclareMisordered = qr{(?:$Storage\s+(?:$Inline\s+)?)?$TypeMisordered};
Andy Whitcroft8905a672007-11-28 16:21:06 -0800573}
574build_types();
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700575
Joe Perches7d2367a2011-07-25 17:13:22 -0700576our $Typecast = qr{\s*(\(\s*$NonptrType\s*\)){0,1}\s*};
Joe Perchesd1fe9c02012-03-23 15:02:16 -0700577
578# Using $balanced_parens, $LvalOrFunc, or $FuncArg
579# requires at least perl version v5.10.0
580# Any use must be runtime checked with $^V
581
582our $balanced_parens = qr/(\((?:[^\(\)]++|(?-1))*\))/;
Joe Perches24358802014-04-03 14:49:13 -0700583our $LvalOrFunc = qr{((?:[\&\*]\s*)?$Lval)\s*($balanced_parens{0,1})\s*};
Joe Perchesc0a5c892015-02-13 14:38:21 -0800584our $FuncArg = qr{$Typecast{0,1}($LvalOrFunc|$Constant|$String)};
Joe Perches7d2367a2011-07-25 17:13:22 -0700585
Joe Perchesf8422302014-08-06 16:11:31 -0700586our $declaration_macros = qr{(?x:
587 (?:$Storage\s+)?(?:[A-Z_][A-Z0-9]*_){0,2}(?:DEFINE|DECLARE)(?:_[A-Z0-9]+){1,2}\s*\(|
588 (?:$Storage\s+)?LIST_HEAD\s*\(|
589 (?:$Storage\s+)?${Type}\s+uninitialized_var\s*\(
590)};
591
Joe Perches7d2367a2011-07-25 17:13:22 -0700592sub deparenthesize {
593 my ($string) = @_;
594 return "" if (!defined($string));
Joe Perches5b9553a2014-04-03 14:49:21 -0700595
596 while ($string =~ /^\s*\(.*\)\s*$/) {
597 $string =~ s@^\s*\(\s*@@;
598 $string =~ s@\s*\)\s*$@@;
599 }
600
Joe Perches7d2367a2011-07-25 17:13:22 -0700601 $string =~ s@\s+@ @g;
Joe Perches5b9553a2014-04-03 14:49:21 -0700602
Joe Perches7d2367a2011-07-25 17:13:22 -0700603 return $string;
604}
605
Joe Perches34456862013-07-03 15:05:34 -0700606sub seed_camelcase_file {
607 my ($file) = @_;
608
609 return if (!(-f $file));
610
611 local $/;
612
613 open(my $include_file, '<', "$file")
614 or warn "$P: Can't read '$file' $!\n";
615 my $text = <$include_file>;
616 close($include_file);
617
618 my @lines = split('\n', $text);
619
620 foreach my $line (@lines) {
621 next if ($line !~ /(?:[A-Z][a-z]|[a-z][A-Z])/);
622 if ($line =~ /^[ \t]*(?:#[ \t]*define|typedef\s+$Type)\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)/) {
623 $camelcase{$1} = 1;
Joe Perches11ea5162013-11-12 15:10:08 -0800624 } elsif ($line =~ /^\s*$Declare\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)\s*[\(\[,;]/) {
625 $camelcase{$1} = 1;
626 } 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 -0700627 $camelcase{$1} = 1;
628 }
629 }
630}
631
632my $camelcase_seeded = 0;
633sub seed_camelcase_includes {
634 return if ($camelcase_seeded);
635
636 my $files;
Joe Perchesc707a812013-07-08 16:00:43 -0700637 my $camelcase_cache = "";
638 my @include_files = ();
639
640 $camelcase_seeded = 1;
Joe Perches351b2a12013-07-03 15:05:36 -0700641
Richard Genoud3645e322014-02-10 14:25:32 -0800642 if (-e ".git") {
Joe Perches351b2a12013-07-03 15:05:36 -0700643 my $git_last_include_commit = `git log --no-merges --pretty=format:"%h%n" -1 -- include`;
644 chomp $git_last_include_commit;
Joe Perchesc707a812013-07-08 16:00:43 -0700645 $camelcase_cache = ".checkpatch-camelcase.git.$git_last_include_commit";
Joe Perches34456862013-07-03 15:05:34 -0700646 } else {
Joe Perchesc707a812013-07-08 16:00:43 -0700647 my $last_mod_date = 0;
Joe Perches34456862013-07-03 15:05:34 -0700648 $files = `find $root/include -name "*.h"`;
Joe Perchesc707a812013-07-08 16:00:43 -0700649 @include_files = split('\n', $files);
650 foreach my $file (@include_files) {
651 my $date = POSIX::strftime("%Y%m%d%H%M",
652 localtime((stat $file)[9]));
653 $last_mod_date = $date if ($last_mod_date < $date);
654 }
655 $camelcase_cache = ".checkpatch-camelcase.date.$last_mod_date";
Joe Perches34456862013-07-03 15:05:34 -0700656 }
Joe Perchesc707a812013-07-08 16:00:43 -0700657
658 if ($camelcase_cache ne "" && -f $camelcase_cache) {
659 open(my $camelcase_file, '<', "$camelcase_cache")
660 or warn "$P: Can't read '$camelcase_cache' $!\n";
661 while (<$camelcase_file>) {
662 chomp;
663 $camelcase{$_} = 1;
664 }
665 close($camelcase_file);
666
667 return;
668 }
669
Richard Genoud3645e322014-02-10 14:25:32 -0800670 if (-e ".git") {
Joe Perchesc707a812013-07-08 16:00:43 -0700671 $files = `git ls-files "include/*.h"`;
672 @include_files = split('\n', $files);
673 }
674
Joe Perches34456862013-07-03 15:05:34 -0700675 foreach my $file (@include_files) {
676 seed_camelcase_file($file);
677 }
Joe Perches351b2a12013-07-03 15:05:36 -0700678
Joe Perchesc707a812013-07-08 16:00:43 -0700679 if ($camelcase_cache ne "") {
Joe Perches351b2a12013-07-03 15:05:36 -0700680 unlink glob ".checkpatch-camelcase.*";
Joe Perchesc707a812013-07-08 16:00:43 -0700681 open(my $camelcase_file, '>', "$camelcase_cache")
682 or warn "$P: Can't write '$camelcase_cache' $!\n";
Joe Perches351b2a12013-07-03 15:05:36 -0700683 foreach (sort { lc($a) cmp lc($b) } keys(%camelcase)) {
684 print $camelcase_file ("$_\n");
685 }
686 close($camelcase_file);
687 }
Joe Perches34456862013-07-03 15:05:34 -0700688}
689
Joe Perchesd311cd42014-08-06 16:10:57 -0700690sub git_commit_info {
691 my ($commit, $id, $desc) = @_;
692
693 return ($id, $desc) if ((which("git") eq "") || !(-e ".git"));
694
695 my $output = `git log --no-color --format='%H %s' -1 $commit 2>&1`;
696 $output =~ s/^\s*//gm;
697 my @lines = split("\n", $output);
698
Joe Perches0d7835f2015-02-13 14:38:35 -0800699 return ($id, $desc) if ($#lines < 0);
700
Joe Perchesd311cd42014-08-06 16:10:57 -0700701 if ($lines[0] =~ /^error: short SHA1 $commit is ambiguous\./) {
702# Maybe one day convert this block of bash into something that returns
703# all matching commit ids, but it's very slow...
704#
705# echo "checking commits $1..."
706# git rev-list --remotes | grep -i "^$1" |
707# while read line ; do
708# git log --format='%H %s' -1 $line |
709# echo "commit $(cut -c 1-12,41-)"
710# done
711 } elsif ($lines[0] =~ /^fatal: ambiguous argument '$commit': unknown revision or path not in the working tree\./) {
712 } else {
713 $id = substr($lines[0], 0, 12);
714 $desc = substr($lines[0], 41);
715 }
716
717 return ($id, $desc);
718}
719
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700720$chk_signoff = 0 if ($file);
721
Andy Whitcroft00df3442007-06-08 13:47:06 -0700722my @rawlines = ();
Andy Whitcroftc2fdda02008-02-08 04:20:54 -0800723my @lines = ();
Joe Perches3705ce52013-07-03 15:05:31 -0700724my @fixed = ();
Joe Perchesd752fcc2014-08-06 16:11:05 -0700725my @fixed_inserted = ();
726my @fixed_deleted = ();
Joe Perches194f66f2014-08-06 16:11:03 -0700727my $fixlinenr = -1;
728
Andy Whitcroftc2fdda02008-02-08 04:20:54 -0800729my $vname;
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700730for my $filename (@ARGV) {
Andy Whitcroft21caa132009-01-06 14:41:30 -0800731 my $FILE;
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700732 if ($file) {
Andy Whitcroft21caa132009-01-06 14:41:30 -0800733 open($FILE, '-|', "diff -u /dev/null $filename") ||
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700734 die "$P: $filename: diff failed - $!\n";
Andy Whitcroft21caa132009-01-06 14:41:30 -0800735 } elsif ($filename eq '-') {
736 open($FILE, '<&STDIN');
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700737 } else {
Andy Whitcroft21caa132009-01-06 14:41:30 -0800738 open($FILE, '<', "$filename") ||
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700739 die "$P: $filename: open failed - $!\n";
Andy Whitcroft0a920b52007-06-01 00:46:48 -0700740 }
Andy Whitcroftc2fdda02008-02-08 04:20:54 -0800741 if ($filename eq '-') {
742 $vname = 'Your patch';
743 } else {
744 $vname = $filename;
745 }
Andy Whitcroft21caa132009-01-06 14:41:30 -0800746 while (<$FILE>) {
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700747 chomp;
748 push(@rawlines, $_);
749 }
Andy Whitcroft21caa132009-01-06 14:41:30 -0800750 close($FILE);
Joe Perchesd8469f12015-06-25 15:03:00 -0700751
752 if ($#ARGV > 0 && $quiet == 0) {
753 print '-' x length($vname) . "\n";
754 print "$vname\n";
755 print '-' x length($vname) . "\n";
756 }
757
Andy Whitcroftc2fdda02008-02-08 04:20:54 -0800758 if (!process($filename)) {
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700759 $exit = 1;
760 }
761 @rawlines = ();
Andy Whitcroft13214ad2008-02-08 04:22:03 -0800762 @lines = ();
Joe Perches3705ce52013-07-03 15:05:31 -0700763 @fixed = ();
Joe Perchesd752fcc2014-08-06 16:11:05 -0700764 @fixed_inserted = ();
765 @fixed_deleted = ();
Joe Perches194f66f2014-08-06 16:11:03 -0700766 $fixlinenr = -1;
Alex Dowad485ff232015-06-25 15:02:52 -0700767 @modifierListFile = ();
768 @typeListFile = ();
769 build_types();
Andy Whitcroft0a920b52007-06-01 00:46:48 -0700770}
771
Joe Perchesd8469f12015-06-25 15:03:00 -0700772if (!$quiet) {
Joe Perches3c816e42015-06-25 15:03:29 -0700773 hash_show_words(\%use_type, "Used");
774 hash_show_words(\%ignore_type, "Ignored");
775
Joe Perchesd8469f12015-06-25 15:03:00 -0700776 if ($^V lt 5.10.0) {
777 print << "EOM"
778
779NOTE: perl $^V is not modern enough to detect all possible issues.
780 An upgrade to at least perl v5.10.0 is suggested.
781EOM
782 }
783 if ($exit) {
784 print << "EOM"
785
786NOTE: If any of the errors are false positives, please report
787 them to the maintainer, see CHECKPATCH in MAINTAINERS.
788EOM
789 }
790}
791
Andy Whitcroft0a920b52007-06-01 00:46:48 -0700792exit($exit);
793
794sub top_of_kernel_tree {
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700795 my ($root) = @_;
796
797 my @tree_check = (
798 "COPYING", "CREDITS", "Kbuild", "MAINTAINERS", "Makefile",
799 "README", "Documentation", "arch", "include", "drivers",
800 "fs", "init", "ipc", "kernel", "lib", "scripts",
801 );
802
803 foreach my $check (@tree_check) {
804 if (! -e $root . '/' . $check) {
805 return 0;
806 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -0700807 }
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700808 return 1;
Joe Perches8f26b832012-10-04 17:13:32 -0700809}
Andy Whitcroft0a920b52007-06-01 00:46:48 -0700810
Joe Perches20112472011-07-25 17:13:23 -0700811sub parse_email {
812 my ($formatted_email) = @_;
813
814 my $name = "";
815 my $address = "";
816 my $comment = "";
817
818 if ($formatted_email =~ /^(.*)<(\S+\@\S+)>(.*)$/) {
819 $name = $1;
820 $address = $2;
821 $comment = $3 if defined $3;
822 } elsif ($formatted_email =~ /^\s*<(\S+\@\S+)>(.*)$/) {
823 $address = $1;
824 $comment = $2 if defined $2;
825 } elsif ($formatted_email =~ /(\S+\@\S+)(.*)$/) {
826 $address = $1;
827 $comment = $2 if defined $2;
828 $formatted_email =~ s/$address.*$//;
829 $name = $formatted_email;
Joe Perches3705ce52013-07-03 15:05:31 -0700830 $name = trim($name);
Joe Perches20112472011-07-25 17:13:23 -0700831 $name =~ s/^\"|\"$//g;
832 # If there's a name left after stripping spaces and
833 # leading quotes, and the address doesn't have both
834 # leading and trailing angle brackets, the address
835 # is invalid. ie:
836 # "joe smith joe@smith.com" bad
837 # "joe smith <joe@smith.com" bad
838 if ($name ne "" && $address !~ /^<[^>]+>$/) {
839 $name = "";
840 $address = "";
841 $comment = "";
842 }
843 }
844
Joe Perches3705ce52013-07-03 15:05:31 -0700845 $name = trim($name);
Joe Perches20112472011-07-25 17:13:23 -0700846 $name =~ s/^\"|\"$//g;
Joe Perches3705ce52013-07-03 15:05:31 -0700847 $address = trim($address);
Joe Perches20112472011-07-25 17:13:23 -0700848 $address =~ s/^\<|\>$//g;
849
850 if ($name =~ /[^\w \-]/i) { ##has "must quote" chars
851 $name =~ s/(?<!\\)"/\\"/g; ##escape quotes
852 $name = "\"$name\"";
853 }
854
855 return ($name, $address, $comment);
856}
857
858sub format_email {
859 my ($name, $address) = @_;
860
861 my $formatted_email;
862
Joe Perches3705ce52013-07-03 15:05:31 -0700863 $name = trim($name);
Joe Perches20112472011-07-25 17:13:23 -0700864 $name =~ s/^\"|\"$//g;
Joe Perches3705ce52013-07-03 15:05:31 -0700865 $address = trim($address);
Joe Perches20112472011-07-25 17:13:23 -0700866
867 if ($name =~ /[^\w \-]/i) { ##has "must quote" chars
868 $name =~ s/(?<!\\)"/\\"/g; ##escape quotes
869 $name = "\"$name\"";
870 }
871
872 if ("$name" eq "") {
873 $formatted_email = "$address";
874 } else {
875 $formatted_email = "$name <$address>";
876 }
877
878 return $formatted_email;
879}
880
Joe Perchesd311cd42014-08-06 16:10:57 -0700881sub which {
Joe Perchesbd474ca2014-08-06 16:11:10 -0700882 my ($bin) = @_;
Joe Perchesd311cd42014-08-06 16:10:57 -0700883
Joe Perchesbd474ca2014-08-06 16:11:10 -0700884 foreach my $path (split(/:/, $ENV{PATH})) {
885 if (-e "$path/$bin") {
886 return "$path/$bin";
887 }
Joe Perchesd311cd42014-08-06 16:10:57 -0700888 }
Joe Perchesd311cd42014-08-06 16:10:57 -0700889
Joe Perchesbd474ca2014-08-06 16:11:10 -0700890 return "";
Joe Perchesd311cd42014-08-06 16:10:57 -0700891}
892
Joe Perches000d1cc12011-07-25 17:13:25 -0700893sub which_conf {
894 my ($conf) = @_;
895
896 foreach my $path (split(/:/, ".:$ENV{HOME}:.scripts")) {
897 if (-e "$path/$conf") {
898 return "$path/$conf";
899 }
900 }
901
902 return "";
903}
904
Andy Whitcroft0a920b52007-06-01 00:46:48 -0700905sub expand_tabs {
906 my ($str) = @_;
907
908 my $res = '';
909 my $n = 0;
910 for my $c (split(//, $str)) {
911 if ($c eq "\t") {
912 $res .= ' ';
913 $n++;
914 for (; ($n % 8) != 0; $n++) {
915 $res .= ' ';
916 }
917 next;
918 }
919 $res .= $c;
920 $n++;
921 }
922
923 return $res;
924}
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700925sub copy_spacing {
Andy Whitcroft773647a2008-03-28 14:15:58 -0700926 (my $res = shift) =~ tr/\t/ /c;
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700927 return $res;
928}
Andy Whitcroft0a920b52007-06-01 00:46:48 -0700929
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -0700930sub line_stats {
931 my ($line) = @_;
932
933 # Drop the diff line leader and expand tabs
934 $line =~ s/^.//;
935 $line = expand_tabs($line);
936
937 # Pick the indent from the front of the line.
938 my ($white) = ($line =~ /^(\s*)/);
939
940 return (length($line), length($white));
941}
942
Andy Whitcroft773647a2008-03-28 14:15:58 -0700943my $sanitise_quote = '';
944
945sub sanitise_line_reset {
946 my ($in_comment) = @_;
947
948 if ($in_comment) {
949 $sanitise_quote = '*/';
950 } else {
951 $sanitise_quote = '';
952 }
953}
Andy Whitcroft00df3442007-06-08 13:47:06 -0700954sub sanitise_line {
955 my ($line) = @_;
956
957 my $res = '';
958 my $l = '';
959
Andy Whitcroftc2fdda02008-02-08 04:20:54 -0800960 my $qlen = 0;
Andy Whitcroft773647a2008-03-28 14:15:58 -0700961 my $off = 0;
962 my $c;
Andy Whitcroft00df3442007-06-08 13:47:06 -0700963
Andy Whitcroft773647a2008-03-28 14:15:58 -0700964 # Always copy over the diff marker.
965 $res = substr($line, 0, 1);
966
967 for ($off = 1; $off < length($line); $off++) {
968 $c = substr($line, $off, 1);
969
970 # Comments we are wacking completly including the begin
971 # and end, all to $;.
972 if ($sanitise_quote eq '' && substr($line, $off, 2) eq '/*') {
973 $sanitise_quote = '*/';
974
975 substr($res, $off, 2, "$;$;");
976 $off++;
977 next;
Andy Whitcroftc2fdda02008-02-08 04:20:54 -0800978 }
Andy Whitcroft81bc0e02008-10-15 22:02:26 -0700979 if ($sanitise_quote eq '*/' && substr($line, $off, 2) eq '*/') {
Andy Whitcroft773647a2008-03-28 14:15:58 -0700980 $sanitise_quote = '';
981 substr($res, $off, 2, "$;$;");
982 $off++;
983 next;
984 }
Daniel Walker113f04a2009-09-21 17:04:35 -0700985 if ($sanitise_quote eq '' && substr($line, $off, 2) eq '//') {
986 $sanitise_quote = '//';
987
988 substr($res, $off, 2, $sanitise_quote);
989 $off++;
990 next;
991 }
Andy Whitcroft773647a2008-03-28 14:15:58 -0700992
993 # A \ in a string means ignore the next character.
994 if (($sanitise_quote eq "'" || $sanitise_quote eq '"') &&
995 $c eq "\\") {
996 substr($res, $off, 2, 'XX');
997 $off++;
998 next;
999 }
1000 # Regular quotes.
1001 if ($c eq "'" || $c eq '"') {
1002 if ($sanitise_quote eq '') {
1003 $sanitise_quote = $c;
1004
1005 substr($res, $off, 1, $c);
Andy Whitcroft00df3442007-06-08 13:47:06 -07001006 next;
Andy Whitcroft773647a2008-03-28 14:15:58 -07001007 } elsif ($sanitise_quote eq $c) {
1008 $sanitise_quote = '';
Andy Whitcroft00df3442007-06-08 13:47:06 -07001009 }
1010 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07001011
Andy Whitcroftfae17da2009-01-06 14:41:20 -08001012 #print "c<$c> SQ<$sanitise_quote>\n";
Andy Whitcroft773647a2008-03-28 14:15:58 -07001013 if ($off != 0 && $sanitise_quote eq '*/' && $c ne "\t") {
1014 substr($res, $off, 1, $;);
Daniel Walker113f04a2009-09-21 17:04:35 -07001015 } elsif ($off != 0 && $sanitise_quote eq '//' && $c ne "\t") {
1016 substr($res, $off, 1, $;);
Andy Whitcroft773647a2008-03-28 14:15:58 -07001017 } elsif ($off != 0 && $sanitise_quote && $c ne "\t") {
1018 substr($res, $off, 1, 'X');
Andy Whitcroft00df3442007-06-08 13:47:06 -07001019 } else {
Andy Whitcroft773647a2008-03-28 14:15:58 -07001020 substr($res, $off, 1, $c);
Andy Whitcroft00df3442007-06-08 13:47:06 -07001021 }
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001022 }
1023
Daniel Walker113f04a2009-09-21 17:04:35 -07001024 if ($sanitise_quote eq '//') {
1025 $sanitise_quote = '';
1026 }
1027
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001028 # The pathname on a #include may be surrounded by '<' and '>'.
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07001029 if ($res =~ /^.\s*\#\s*include\s+\<(.*)\>/) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001030 my $clean = 'X' x length($1);
1031 $res =~ s@\<.*\>@<$clean>@;
1032
1033 # The whole of a #error is a string.
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07001034 } elsif ($res =~ /^.\s*\#\s*(?:error|warning)\s+(.*)\b/) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001035 my $clean = 'X' x length($1);
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07001036 $res =~ s@(\#\s*(?:error|warning)\s+).*@$1$clean@;
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001037 }
1038
Andy Whitcroft00df3442007-06-08 13:47:06 -07001039 return $res;
1040}
1041
Joe Perchesa6962d72013-04-29 16:18:13 -07001042sub get_quoted_string {
1043 my ($line, $rawline) = @_;
1044
Joe Perches33acb542015-06-25 15:02:54 -07001045 return "" if ($line !~ m/($String)/g);
Joe Perchesa6962d72013-04-29 16:18:13 -07001046 return substr($rawline, $-[0], $+[0] - $-[0]);
1047}
1048
Andy Whitcroft8905a672007-11-28 16:21:06 -08001049sub ctx_statement_block {
1050 my ($linenr, $remain, $off) = @_;
1051 my $line = $linenr - 1;
1052 my $blk = '';
1053 my $soff = $off;
1054 my $coff = $off - 1;
Andy Whitcroft773647a2008-03-28 14:15:58 -07001055 my $coff_set = 0;
Andy Whitcroft8905a672007-11-28 16:21:06 -08001056
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001057 my $loff = 0;
1058
Andy Whitcroft8905a672007-11-28 16:21:06 -08001059 my $type = '';
1060 my $level = 0;
Andy Whitcrofta2750642009-01-15 13:51:04 -08001061 my @stack = ();
Andy Whitcroftcf655042008-03-04 14:28:20 -08001062 my $p;
Andy Whitcroft8905a672007-11-28 16:21:06 -08001063 my $c;
1064 my $len = 0;
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001065
1066 my $remainder;
Andy Whitcroft8905a672007-11-28 16:21:06 -08001067 while (1) {
Andy Whitcrofta2750642009-01-15 13:51:04 -08001068 @stack = (['', 0]) if ($#stack == -1);
1069
Andy Whitcroft773647a2008-03-28 14:15:58 -07001070 #warn "CSB: blk<$blk> remain<$remain>\n";
Andy Whitcroft8905a672007-11-28 16:21:06 -08001071 # If we are about to drop off the end, pull in more
1072 # context.
1073 if ($off >= $len) {
1074 for (; $remain > 0; $line++) {
Andy Whitcroftdea33492008-10-15 22:02:25 -07001075 last if (!defined $lines[$line]);
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001076 next if ($lines[$line] =~ /^-/);
Andy Whitcroft8905a672007-11-28 16:21:06 -08001077 $remain--;
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001078 $loff = $len;
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001079 $blk .= $lines[$line] . "\n";
Andy Whitcroft8905a672007-11-28 16:21:06 -08001080 $len = length($blk);
1081 $line++;
1082 last;
1083 }
1084 # Bail if there is no further context.
1085 #warn "CSB: blk<$blk> off<$off> len<$len>\n";
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001086 if ($off >= $len) {
Andy Whitcroft8905a672007-11-28 16:21:06 -08001087 last;
1088 }
Andy Whitcroftf74bd192012-01-10 15:09:54 -08001089 if ($level == 0 && substr($blk, $off) =~ /^.\s*#\s*define/) {
1090 $level++;
1091 $type = '#';
1092 }
Andy Whitcroft8905a672007-11-28 16:21:06 -08001093 }
Andy Whitcroftcf655042008-03-04 14:28:20 -08001094 $p = $c;
Andy Whitcroft8905a672007-11-28 16:21:06 -08001095 $c = substr($blk, $off, 1);
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001096 $remainder = substr($blk, $off);
Andy Whitcroft8905a672007-11-28 16:21:06 -08001097
Andy Whitcroft773647a2008-03-28 14:15:58 -07001098 #warn "CSB: c<$c> type<$type> level<$level> remainder<$remainder> coff_set<$coff_set>\n";
Andy Whitcroft4635f4f2009-01-06 14:41:27 -08001099
1100 # Handle nested #if/#else.
1101 if ($remainder =~ /^#\s*(?:ifndef|ifdef|if)\s/) {
1102 push(@stack, [ $type, $level ]);
1103 } elsif ($remainder =~ /^#\s*(?:else|elif)\b/) {
1104 ($type, $level) = @{$stack[$#stack - 1]};
1105 } elsif ($remainder =~ /^#\s*endif\b/) {
1106 ($type, $level) = @{pop(@stack)};
1107 }
1108
Andy Whitcroft8905a672007-11-28 16:21:06 -08001109 # Statement ends at the ';' or a close '}' at the
1110 # outermost level.
1111 if ($level == 0 && $c eq ';') {
1112 last;
1113 }
1114
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001115 # An else is really a conditional as long as its not else if
Andy Whitcroft773647a2008-03-28 14:15:58 -07001116 if ($level == 0 && $coff_set == 0 &&
1117 (!defined($p) || $p =~ /(?:\s|\}|\+)/) &&
1118 $remainder =~ /^(else)(?:\s|{)/ &&
1119 $remainder !~ /^else\s+if\b/) {
1120 $coff = $off + length($1) - 1;
1121 $coff_set = 1;
1122 #warn "CSB: mark coff<$coff> soff<$soff> 1<$1>\n";
1123 #warn "[" . substr($blk, $soff, $coff - $soff + 1) . "]\n";
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001124 }
1125
Andy Whitcroft8905a672007-11-28 16:21:06 -08001126 if (($type eq '' || $type eq '(') && $c eq '(') {
1127 $level++;
1128 $type = '(';
1129 }
1130 if ($type eq '(' && $c eq ')') {
1131 $level--;
1132 $type = ($level != 0)? '(' : '';
1133
1134 if ($level == 0 && $coff < $soff) {
1135 $coff = $off;
Andy Whitcroft773647a2008-03-28 14:15:58 -07001136 $coff_set = 1;
1137 #warn "CSB: mark coff<$coff>\n";
Andy Whitcroft8905a672007-11-28 16:21:06 -08001138 }
1139 }
1140 if (($type eq '' || $type eq '{') && $c eq '{') {
1141 $level++;
1142 $type = '{';
1143 }
1144 if ($type eq '{' && $c eq '}') {
1145 $level--;
1146 $type = ($level != 0)? '{' : '';
1147
1148 if ($level == 0) {
Patrick Pannutob998e002010-08-09 17:21:03 -07001149 if (substr($blk, $off + 1, 1) eq ';') {
1150 $off++;
1151 }
Andy Whitcroft8905a672007-11-28 16:21:06 -08001152 last;
1153 }
1154 }
Andy Whitcroftf74bd192012-01-10 15:09:54 -08001155 # Preprocessor commands end at the newline unless escaped.
1156 if ($type eq '#' && $c eq "\n" && $p ne "\\") {
1157 $level--;
1158 $type = '';
1159 $off++;
1160 last;
1161 }
Andy Whitcroft8905a672007-11-28 16:21:06 -08001162 $off++;
1163 }
Andy Whitcrofta3bb97a2008-07-23 21:29:00 -07001164 # We are truly at the end, so shuffle to the next line.
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001165 if ($off == $len) {
Andy Whitcrofta3bb97a2008-07-23 21:29:00 -07001166 $loff = $len + 1;
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001167 $line++;
1168 $remain--;
1169 }
Andy Whitcroft8905a672007-11-28 16:21:06 -08001170
1171 my $statement = substr($blk, $soff, $off - $soff + 1);
1172 my $condition = substr($blk, $soff, $coff - $soff + 1);
1173
1174 #warn "STATEMENT<$statement>\n";
1175 #warn "CONDITION<$condition>\n";
1176
Andy Whitcroft773647a2008-03-28 14:15:58 -07001177 #print "coff<$coff> soff<$off> loff<$loff>\n";
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001178
1179 return ($statement, $condition,
1180 $line, $remain + 1, $off - $loff + 1, $level);
1181}
1182
Andy Whitcroftcf655042008-03-04 14:28:20 -08001183sub statement_lines {
1184 my ($stmt) = @_;
1185
1186 # Strip the diff line prefixes and rip blank lines at start and end.
1187 $stmt =~ s/(^|\n)./$1/g;
1188 $stmt =~ s/^\s*//;
1189 $stmt =~ s/\s*$//;
1190
1191 my @stmt_lines = ($stmt =~ /\n/g);
1192
1193 return $#stmt_lines + 2;
1194}
1195
1196sub statement_rawlines {
1197 my ($stmt) = @_;
1198
1199 my @stmt_lines = ($stmt =~ /\n/g);
1200
1201 return $#stmt_lines + 2;
1202}
1203
1204sub statement_block_size {
1205 my ($stmt) = @_;
1206
1207 $stmt =~ s/(^|\n)./$1/g;
1208 $stmt =~ s/^\s*{//;
1209 $stmt =~ s/}\s*$//;
1210 $stmt =~ s/^\s*//;
1211 $stmt =~ s/\s*$//;
1212
1213 my @stmt_lines = ($stmt =~ /\n/g);
1214 my @stmt_statements = ($stmt =~ /;/g);
1215
1216 my $stmt_lines = $#stmt_lines + 2;
1217 my $stmt_statements = $#stmt_statements + 1;
1218
1219 if ($stmt_lines > $stmt_statements) {
1220 return $stmt_lines;
1221 } else {
1222 return $stmt_statements;
1223 }
1224}
1225
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001226sub ctx_statement_full {
1227 my ($linenr, $remain, $off) = @_;
1228 my ($statement, $condition, $level);
1229
1230 my (@chunks);
1231
Andy Whitcroftcf655042008-03-04 14:28:20 -08001232 # Grab the first conditional/block pair.
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001233 ($statement, $condition, $linenr, $remain, $off, $level) =
1234 ctx_statement_block($linenr, $remain, $off);
Andy Whitcroft773647a2008-03-28 14:15:58 -07001235 #print "F: c<$condition> s<$statement> remain<$remain>\n";
Andy Whitcroftcf655042008-03-04 14:28:20 -08001236 push(@chunks, [ $condition, $statement ]);
1237 if (!($remain > 0 && $condition =~ /^\s*(?:\n[+-])?\s*(?:if|else|do)\b/s)) {
1238 return ($level, $linenr, @chunks);
1239 }
1240
1241 # Pull in the following conditional/block pairs and see if they
1242 # could continue the statement.
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001243 for (;;) {
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001244 ($statement, $condition, $linenr, $remain, $off, $level) =
1245 ctx_statement_block($linenr, $remain, $off);
Andy Whitcroftcf655042008-03-04 14:28:20 -08001246 #print "C: c<$condition> s<$statement> remain<$remain>\n";
Andy Whitcroft773647a2008-03-28 14:15:58 -07001247 last if (!($remain > 0 && $condition =~ /^(?:\s*\n[+-])*\s*(?:else|do)\b/s));
Andy Whitcroftcf655042008-03-04 14:28:20 -08001248 #print "C: push\n";
1249 push(@chunks, [ $condition, $statement ]);
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001250 }
1251
1252 return ($level, $linenr, @chunks);
Andy Whitcroft8905a672007-11-28 16:21:06 -08001253}
1254
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001255sub ctx_block_get {
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001256 my ($linenr, $remain, $outer, $open, $close, $off) = @_;
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001257 my $line;
1258 my $start = $linenr - 1;
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001259 my $blk = '';
1260 my @o;
1261 my @c;
1262 my @res = ();
1263
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001264 my $level = 0;
Andy Whitcroft4635f4f2009-01-06 14:41:27 -08001265 my @stack = ($level);
Andy Whitcroft00df3442007-06-08 13:47:06 -07001266 for ($line = $start; $remain > 0; $line++) {
1267 next if ($rawlines[$line] =~ /^-/);
1268 $remain--;
1269
1270 $blk .= $rawlines[$line];
Andy Whitcroft4635f4f2009-01-06 14:41:27 -08001271
1272 # Handle nested #if/#else.
Andy Whitcroft01464f32010-10-26 14:23:19 -07001273 if ($lines[$line] =~ /^.\s*#\s*(?:ifndef|ifdef|if)\s/) {
Andy Whitcroft4635f4f2009-01-06 14:41:27 -08001274 push(@stack, $level);
Andy Whitcroft01464f32010-10-26 14:23:19 -07001275 } elsif ($lines[$line] =~ /^.\s*#\s*(?:else|elif)\b/) {
Andy Whitcroft4635f4f2009-01-06 14:41:27 -08001276 $level = $stack[$#stack - 1];
Andy Whitcroft01464f32010-10-26 14:23:19 -07001277 } elsif ($lines[$line] =~ /^.\s*#\s*endif\b/) {
Andy Whitcroft4635f4f2009-01-06 14:41:27 -08001278 $level = pop(@stack);
1279 }
1280
Andy Whitcroft01464f32010-10-26 14:23:19 -07001281 foreach my $c (split(//, $lines[$line])) {
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001282 ##print "C<$c>L<$level><$open$close>O<$off>\n";
1283 if ($off > 0) {
1284 $off--;
1285 next;
1286 }
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001287
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001288 if ($c eq $close && $level > 0) {
1289 $level--;
1290 last if ($level == 0);
1291 } elsif ($c eq $open) {
1292 $level++;
1293 }
1294 }
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001295
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001296 if (!$outer || $level <= 1) {
Andy Whitcroft00df3442007-06-08 13:47:06 -07001297 push(@res, $rawlines[$line]);
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001298 }
1299
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001300 last if ($level == 0);
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001301 }
1302
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001303 return ($level, @res);
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001304}
1305sub ctx_block_outer {
1306 my ($linenr, $remain) = @_;
1307
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001308 my ($level, @r) = ctx_block_get($linenr, $remain, 1, '{', '}', 0);
1309 return @r;
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001310}
1311sub ctx_block {
1312 my ($linenr, $remain) = @_;
1313
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001314 my ($level, @r) = ctx_block_get($linenr, $remain, 0, '{', '}', 0);
1315 return @r;
Andy Whitcroft653d4872007-06-23 17:16:34 -07001316}
1317sub ctx_statement {
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001318 my ($linenr, $remain, $off) = @_;
1319
1320 my ($level, @r) = ctx_block_get($linenr, $remain, 0, '(', ')', $off);
1321 return @r;
1322}
1323sub ctx_block_level {
Andy Whitcroft653d4872007-06-23 17:16:34 -07001324 my ($linenr, $remain) = @_;
1325
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001326 return ctx_block_get($linenr, $remain, 0, '{', '}', 0);
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001327}
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07001328sub ctx_statement_level {
1329 my ($linenr, $remain, $off) = @_;
1330
1331 return ctx_block_get($linenr, $remain, 0, '(', ')', $off);
1332}
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001333
1334sub ctx_locate_comment {
1335 my ($first_line, $end_line) = @_;
1336
1337 # Catch a comment on the end of the line itself.
Andy Whitcroftbeae6332008-07-23 21:28:59 -07001338 my ($current_comment) = ($rawlines[$end_line - 1] =~ m@.*(/\*.*\*/)\s*(?:\\\s*)?$@);
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001339 return $current_comment if (defined $current_comment);
1340
1341 # Look through the context and try and figure out if there is a
1342 # comment.
1343 my $in_comment = 0;
1344 $current_comment = '';
1345 for (my $linenr = $first_line; $linenr < $end_line; $linenr++) {
Andy Whitcroft00df3442007-06-08 13:47:06 -07001346 my $line = $rawlines[$linenr - 1];
1347 #warn " $line\n";
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001348 if ($linenr == $first_line and $line =~ m@^.\s*\*@) {
1349 $in_comment = 1;
1350 }
1351 if ($line =~ m@/\*@) {
1352 $in_comment = 1;
1353 }
1354 if (!$in_comment && $current_comment ne '') {
1355 $current_comment = '';
1356 }
1357 $current_comment .= $line . "\n" if ($in_comment);
1358 if ($line =~ m@\*/@) {
1359 $in_comment = 0;
1360 }
1361 }
1362
1363 chomp($current_comment);
1364 return($current_comment);
1365}
1366sub ctx_has_comment {
1367 my ($first_line, $end_line) = @_;
1368 my $cmt = ctx_locate_comment($first_line, $end_line);
1369
Andy Whitcroft00df3442007-06-08 13:47:06 -07001370 ##print "LINE: $rawlines[$end_line - 1 ]\n";
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001371 ##print "CMMT: $cmt\n";
1372
1373 return ($cmt ne '');
1374}
1375
Andy Whitcroft4d001e42008-10-15 22:02:21 -07001376sub raw_line {
1377 my ($linenr, $cnt) = @_;
1378
1379 my $offset = $linenr - 1;
1380 $cnt++;
1381
1382 my $line;
1383 while ($cnt) {
1384 $line = $rawlines[$offset++];
1385 next if (defined($line) && $line =~ /^-/);
1386 $cnt--;
1387 }
1388
1389 return $line;
1390}
1391
Andy Whitcroft0a920b52007-06-01 00:46:48 -07001392sub cat_vet {
1393 my ($vet) = @_;
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07001394 my ($res, $coded);
Andy Whitcroft0a920b52007-06-01 00:46:48 -07001395
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07001396 $res = '';
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001397 while ($vet =~ /([^[:cntrl:]]*)([[:cntrl:]]|$)/g) {
1398 $res .= $1;
1399 if ($2 ne '') {
1400 $coded = sprintf("^%c", unpack('C', $2) + 64);
1401 $res .= $coded;
1402 }
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07001403 }
1404 $res =~ s/$/\$/;
Andy Whitcroft0a920b52007-06-01 00:46:48 -07001405
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07001406 return $res;
Andy Whitcroft0a920b52007-06-01 00:46:48 -07001407}
1408
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001409my $av_preprocessor = 0;
Andy Whitcroftcf655042008-03-04 14:28:20 -08001410my $av_pending;
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001411my @av_paren_type;
Andy Whitcroft1f65f942008-07-23 21:29:10 -07001412my $av_pend_colon;
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001413
1414sub annotate_reset {
1415 $av_preprocessor = 0;
Andy Whitcroftcf655042008-03-04 14:28:20 -08001416 $av_pending = '_';
1417 @av_paren_type = ('E');
Andy Whitcroft1f65f942008-07-23 21:29:10 -07001418 $av_pend_colon = 'O';
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001419}
1420
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001421sub annotate_values {
1422 my ($stream, $type) = @_;
1423
1424 my $res;
Andy Whitcroft1f65f942008-07-23 21:29:10 -07001425 my $var = '_' x length($stream);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001426 my $cur = $stream;
1427
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001428 print "$stream\n" if ($dbg_values > 1);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001429
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001430 while (length($cur)) {
Andy Whitcroft773647a2008-03-28 14:15:58 -07001431 @av_paren_type = ('E') if ($#av_paren_type < 0);
Andy Whitcroftcf655042008-03-04 14:28:20 -08001432 print " <" . join('', @av_paren_type) .
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07001433 "> <$type> <$av_pending>" if ($dbg_values > 1);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001434 if ($cur =~ /^(\s+)/o) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001435 print "WS($1)\n" if ($dbg_values > 1);
1436 if ($1 =~ /\n/ && $av_preprocessor) {
Andy Whitcroftcf655042008-03-04 14:28:20 -08001437 $type = pop(@av_paren_type);
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001438 $av_preprocessor = 0;
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001439 }
1440
Florian Micklerc023e4732011-01-12 16:59:58 -08001441 } elsif ($cur =~ /^(\(\s*$Type\s*)\)/ && $av_pending eq '_') {
Andy Whitcroft9446ef52010-10-26 14:23:13 -07001442 print "CAST($1)\n" if ($dbg_values > 1);
1443 push(@av_paren_type, $type);
Andy Whitcroftaddcdce2012-01-10 15:10:11 -08001444 $type = 'c';
Andy Whitcroft9446ef52010-10-26 14:23:13 -07001445
Andy Whitcrofte91b6e22010-10-26 14:23:11 -07001446 } elsif ($cur =~ /^($Type)\s*(?:$Ident|,|\)|\(|\s*$)/) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001447 print "DECLARE($1)\n" if ($dbg_values > 1);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001448 $type = 'T';
1449
Andy Whitcroft389a2fe2008-07-23 21:29:05 -07001450 } elsif ($cur =~ /^($Modifier)\s*/) {
1451 print "MODIFIER($1)\n" if ($dbg_values > 1);
1452 $type = 'T';
1453
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07001454 } elsif ($cur =~ /^(\#\s*define\s*$Ident)(\(?)/o) {
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07001455 print "DEFINE($1,$2)\n" if ($dbg_values > 1);
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001456 $av_preprocessor = 1;
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07001457 push(@av_paren_type, $type);
1458 if ($2 ne '') {
1459 $av_pending = 'N';
1460 }
1461 $type = 'E';
1462
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07001463 } elsif ($cur =~ /^(\#\s*(?:undef\s*$Ident|include\b))/o) {
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07001464 print "UNDEF($1)\n" if ($dbg_values > 1);
1465 $av_preprocessor = 1;
1466 push(@av_paren_type, $type);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001467
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07001468 } elsif ($cur =~ /^(\#\s*(?:ifdef|ifndef|if))/o) {
Andy Whitcroftcf655042008-03-04 14:28:20 -08001469 print "PRE_START($1)\n" if ($dbg_values > 1);
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001470 $av_preprocessor = 1;
Andy Whitcroftcf655042008-03-04 14:28:20 -08001471
1472 push(@av_paren_type, $type);
1473 push(@av_paren_type, $type);
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07001474 $type = 'E';
Andy Whitcroftcf655042008-03-04 14:28:20 -08001475
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07001476 } elsif ($cur =~ /^(\#\s*(?:else|elif))/o) {
Andy Whitcroftcf655042008-03-04 14:28:20 -08001477 print "PRE_RESTART($1)\n" if ($dbg_values > 1);
1478 $av_preprocessor = 1;
1479
1480 push(@av_paren_type, $av_paren_type[$#av_paren_type]);
1481
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07001482 $type = 'E';
Andy Whitcroftcf655042008-03-04 14:28:20 -08001483
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07001484 } elsif ($cur =~ /^(\#\s*(?:endif))/o) {
Andy Whitcroftcf655042008-03-04 14:28:20 -08001485 print "PRE_END($1)\n" if ($dbg_values > 1);
1486
1487 $av_preprocessor = 1;
1488
1489 # Assume all arms of the conditional end as this
1490 # one does, and continue as if the #endif was not here.
1491 pop(@av_paren_type);
1492 push(@av_paren_type, $type);
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07001493 $type = 'E';
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001494
1495 } elsif ($cur =~ /^(\\\n)/o) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001496 print "PRECONT($1)\n" if ($dbg_values > 1);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001497
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07001498 } elsif ($cur =~ /^(__attribute__)\s*\(?/o) {
1499 print "ATTR($1)\n" if ($dbg_values > 1);
1500 $av_pending = $type;
1501 $type = 'N';
1502
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001503 } elsif ($cur =~ /^(sizeof)\s*(\()?/o) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001504 print "SIZEOF($1)\n" if ($dbg_values > 1);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001505 if (defined $2) {
Andy Whitcroftcf655042008-03-04 14:28:20 -08001506 $av_pending = 'V';
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001507 }
1508 $type = 'N';
1509
Andy Whitcroft14b111c2008-10-15 22:02:16 -07001510 } elsif ($cur =~ /^(if|while|for)\b/o) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001511 print "COND($1)\n" if ($dbg_values > 1);
Andy Whitcroft14b111c2008-10-15 22:02:16 -07001512 $av_pending = 'E';
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001513 $type = 'N';
1514
Andy Whitcroft1f65f942008-07-23 21:29:10 -07001515 } elsif ($cur =~/^(case)/o) {
1516 print "CASE($1)\n" if ($dbg_values > 1);
1517 $av_pend_colon = 'C';
1518 $type = 'N';
1519
Andy Whitcroft14b111c2008-10-15 22:02:16 -07001520 } elsif ($cur =~/^(return|else|goto|typeof|__typeof__)\b/o) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001521 print "KEYWORD($1)\n" if ($dbg_values > 1);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001522 $type = 'N';
1523
1524 } elsif ($cur =~ /^(\()/o) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001525 print "PAREN('$1')\n" if ($dbg_values > 1);
Andy Whitcroftcf655042008-03-04 14:28:20 -08001526 push(@av_paren_type, $av_pending);
1527 $av_pending = '_';
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001528 $type = 'N';
1529
1530 } elsif ($cur =~ /^(\))/o) {
Andy Whitcroftcf655042008-03-04 14:28:20 -08001531 my $new_type = pop(@av_paren_type);
1532 if ($new_type ne '_') {
1533 $type = $new_type;
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001534 print "PAREN('$1') -> $type\n"
1535 if ($dbg_values > 1);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001536 } else {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001537 print "PAREN('$1')\n" if ($dbg_values > 1);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001538 }
1539
Andy Whitcroftc8cb2ca2008-07-23 21:28:57 -07001540 } elsif ($cur =~ /^($Ident)\s*\(/o) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001541 print "FUNC($1)\n" if ($dbg_values > 1);
Andy Whitcroftc8cb2ca2008-07-23 21:28:57 -07001542 $type = 'V';
Andy Whitcroftcf655042008-03-04 14:28:20 -08001543 $av_pending = 'V';
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001544
Andy Whitcroft8e761b02009-01-06 14:41:19 -08001545 } elsif ($cur =~ /^($Ident\s*):(?:\s*\d+\s*(,|=|;))?/) {
1546 if (defined $2 && $type eq 'C' || $type eq 'T') {
Andy Whitcroft1f65f942008-07-23 21:29:10 -07001547 $av_pend_colon = 'B';
Andy Whitcroft8e761b02009-01-06 14:41:19 -08001548 } elsif ($type eq 'E') {
1549 $av_pend_colon = 'L';
Andy Whitcroft1f65f942008-07-23 21:29:10 -07001550 }
1551 print "IDENT_COLON($1,$type>$av_pend_colon)\n" if ($dbg_values > 1);
1552 $type = 'V';
1553
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001554 } elsif ($cur =~ /^($Ident|$Constant)/o) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001555 print "IDENT($1)\n" if ($dbg_values > 1);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001556 $type = 'V';
1557
1558 } elsif ($cur =~ /^($Assignment)/o) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001559 print "ASSIGN($1)\n" if ($dbg_values > 1);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001560 $type = 'N';
1561
Andy Whitcroftcf655042008-03-04 14:28:20 -08001562 } elsif ($cur =~/^(;|{|})/) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001563 print "END($1)\n" if ($dbg_values > 1);
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001564 $type = 'E';
Andy Whitcroft1f65f942008-07-23 21:29:10 -07001565 $av_pend_colon = 'O';
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001566
Andy Whitcroft8e761b02009-01-06 14:41:19 -08001567 } elsif ($cur =~/^(,)/) {
1568 print "COMMA($1)\n" if ($dbg_values > 1);
1569 $type = 'C';
1570
Andy Whitcroft1f65f942008-07-23 21:29:10 -07001571 } elsif ($cur =~ /^(\?)/o) {
1572 print "QUESTION($1)\n" if ($dbg_values > 1);
1573 $type = 'N';
1574
1575 } elsif ($cur =~ /^(:)/o) {
1576 print "COLON($1,$av_pend_colon)\n" if ($dbg_values > 1);
1577
1578 substr($var, length($res), 1, $av_pend_colon);
1579 if ($av_pend_colon eq 'C' || $av_pend_colon eq 'L') {
1580 $type = 'E';
1581 } else {
1582 $type = 'N';
1583 }
1584 $av_pend_colon = 'O';
1585
Andy Whitcroft8e761b02009-01-06 14:41:19 -08001586 } elsif ($cur =~ /^(\[)/o) {
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001587 print "CLOSE($1)\n" if ($dbg_values > 1);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001588 $type = 'N';
1589
Andy Whitcroft0d413862008-10-15 22:02:16 -07001590 } elsif ($cur =~ /^(-(?![->])|\+(?!\+)|\*|\&\&|\&)/o) {
Andy Whitcroft74048ed2008-07-23 21:29:10 -07001591 my $variant;
1592
1593 print "OPV($1)\n" if ($dbg_values > 1);
1594 if ($type eq 'V') {
1595 $variant = 'B';
1596 } else {
1597 $variant = 'U';
1598 }
1599
1600 substr($var, length($res), 1, $variant);
1601 $type = 'N';
1602
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001603 } elsif ($cur =~ /^($Operators)/o) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001604 print "OP($1)\n" if ($dbg_values > 1);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001605 if ($1 ne '++' && $1 ne '--') {
1606 $type = 'N';
1607 }
1608
1609 } elsif ($cur =~ /(^.)/o) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001610 print "C($1)\n" if ($dbg_values > 1);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001611 }
1612 if (defined $1) {
1613 $cur = substr($cur, length($1));
1614 $res .= $type x length($1);
1615 }
1616 }
1617
Andy Whitcroft1f65f942008-07-23 21:29:10 -07001618 return ($res, $var);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001619}
1620
Andy Whitcroft8905a672007-11-28 16:21:06 -08001621sub possible {
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001622 my ($possible, $line) = @_;
Andy Whitcroft9a974fd2009-10-26 16:50:12 -07001623 my $notPermitted = qr{(?:
Andy Whitcroft0776e592008-10-15 22:02:29 -07001624 ^(?:
1625 $Modifier|
1626 $Storage|
1627 $Type|
Andy Whitcroft9a974fd2009-10-26 16:50:12 -07001628 DEFINE_\S+
1629 )$|
1630 ^(?:
Andy Whitcroft0776e592008-10-15 22:02:29 -07001631 goto|
1632 return|
1633 case|
1634 else|
1635 asm|__asm__|
Andy Whitcroft89a88352012-01-10 15:10:00 -08001636 do|
1637 \#|
1638 \#\#|
Andy Whitcroft9a974fd2009-10-26 16:50:12 -07001639 )(?:\s|$)|
Andy Whitcroft0776e592008-10-15 22:02:29 -07001640 ^(?:typedef|struct|enum)\b
Andy Whitcroft9a974fd2009-10-26 16:50:12 -07001641 )}x;
1642 warn "CHECK<$possible> ($line)\n" if ($dbg_possible > 2);
1643 if ($possible !~ $notPermitted) {
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07001644 # Check for modifiers.
1645 $possible =~ s/\s*$Storage\s*//g;
1646 $possible =~ s/\s*$Sparse\s*//g;
1647 if ($possible =~ /^\s*$/) {
1648
1649 } elsif ($possible =~ /\s/) {
1650 $possible =~ s/\s*$Type\s*//g;
Andy Whitcroftd2506582008-07-23 21:29:09 -07001651 for my $modifier (split(' ', $possible)) {
Andy Whitcroft9a974fd2009-10-26 16:50:12 -07001652 if ($modifier !~ $notPermitted) {
1653 warn "MODIFIER: $modifier ($possible) ($line)\n" if ($dbg_possible);
Alex Dowad485ff232015-06-25 15:02:52 -07001654 push(@modifierListFile, $modifier);
Andy Whitcroft9a974fd2009-10-26 16:50:12 -07001655 }
Andy Whitcroftd2506582008-07-23 21:29:09 -07001656 }
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07001657
1658 } else {
1659 warn "POSSIBLE: $possible ($line)\n" if ($dbg_possible);
Alex Dowad485ff232015-06-25 15:02:52 -07001660 push(@typeListFile, $possible);
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07001661 }
Andy Whitcroft8905a672007-11-28 16:21:06 -08001662 build_types();
Andy Whitcroft0776e592008-10-15 22:02:29 -07001663 } else {
1664 warn "NOTPOSS: $possible ($line)\n" if ($dbg_possible > 1);
Andy Whitcroft8905a672007-11-28 16:21:06 -08001665 }
1666}
1667
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001668my $prefix = '';
1669
Joe Perches000d1cc12011-07-25 17:13:25 -07001670sub show_type {
Joe Perchescbec18a2014-04-03 14:49:19 -07001671 my ($type) = @_;
Joe Perches91bfe482013-09-11 14:23:59 -07001672
Joe Perchescbec18a2014-04-03 14:49:19 -07001673 return defined $use_type{$type} if (scalar keys %use_type > 0);
1674
1675 return !defined $ignore_type{$type};
Joe Perches000d1cc12011-07-25 17:13:25 -07001676}
1677
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001678sub report {
Joe Perchescbec18a2014-04-03 14:49:19 -07001679 my ($level, $type, $msg) = @_;
1680
1681 if (!show_type($type) ||
1682 (defined $tst_only && $msg !~ /\Q$tst_only\E/)) {
Andy Whitcroft773647a2008-03-28 14:15:58 -07001683 return 0;
1684 }
Joe Perches57230292015-06-25 15:03:03 -07001685 my $output = '';
1686 if (-t STDOUT && $color) {
1687 if ($level eq 'ERROR') {
1688 $output .= RED;
1689 } elsif ($level eq 'WARNING') {
1690 $output .= YELLOW;
1691 } else {
1692 $output .= GREEN;
1693 }
Joe Perches000d1cc12011-07-25 17:13:25 -07001694 }
Joe Perches57230292015-06-25 15:03:03 -07001695 $output .= $prefix . $level . ':';
1696 if ($show_types) {
1697 $output .= BLUE if (-t STDOUT && $color);
1698 $output .= "$type:";
1699 }
1700 $output .= RESET if (-t STDOUT && $color);
1701 $output .= ' ' . $msg . "\n";
Joe Perches34d88152015-06-25 15:03:05 -07001702
1703 if ($showfile) {
1704 my @lines = split("\n", $output, -1);
1705 splice(@lines, 1, 1);
1706 $output = join("\n", @lines);
1707 }
Joe Perches57230292015-06-25 15:03:03 -07001708 $output = (split('\n', $output))[0] . "\n" if ($terse);
Andy Whitcroft8905a672007-11-28 16:21:06 -08001709
Joe Perches57230292015-06-25 15:03:03 -07001710 push(our @report, $output);
Andy Whitcroft773647a2008-03-28 14:15:58 -07001711
1712 return 1;
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001713}
Joe Perchescbec18a2014-04-03 14:49:19 -07001714
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001715sub report_dump {
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001716 our @report;
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001717}
Joe Perches000d1cc12011-07-25 17:13:25 -07001718
Joe Perchesd752fcc2014-08-06 16:11:05 -07001719sub fixup_current_range {
1720 my ($lineRef, $offset, $length) = @_;
1721
1722 if ($$lineRef =~ /^\@\@ -\d+,\d+ \+(\d+),(\d+) \@\@/) {
1723 my $o = $1;
1724 my $l = $2;
1725 my $no = $o + $offset;
1726 my $nl = $l + $length;
1727 $$lineRef =~ s/\+$o,$l \@\@/\+$no,$nl \@\@/;
1728 }
1729}
1730
1731sub fix_inserted_deleted_lines {
1732 my ($linesRef, $insertedRef, $deletedRef) = @_;
1733
1734 my $range_last_linenr = 0;
1735 my $delta_offset = 0;
1736
1737 my $old_linenr = 0;
1738 my $new_linenr = 0;
1739
1740 my $next_insert = 0;
1741 my $next_delete = 0;
1742
1743 my @lines = ();
1744
1745 my $inserted = @{$insertedRef}[$next_insert++];
1746 my $deleted = @{$deletedRef}[$next_delete++];
1747
1748 foreach my $old_line (@{$linesRef}) {
1749 my $save_line = 1;
1750 my $line = $old_line; #don't modify the array
Joe Perches323b2672015-04-16 12:44:50 -07001751 if ($line =~ /^(?:\+\+\+|\-\-\-)\s+\S+/) { #new filename
Joe Perchesd752fcc2014-08-06 16:11:05 -07001752 $delta_offset = 0;
1753 } elsif ($line =~ /^\@\@ -\d+,\d+ \+\d+,\d+ \@\@/) { #new hunk
1754 $range_last_linenr = $new_linenr;
1755 fixup_current_range(\$line, $delta_offset, 0);
1756 }
1757
1758 while (defined($deleted) && ${$deleted}{'LINENR'} == $old_linenr) {
1759 $deleted = @{$deletedRef}[$next_delete++];
1760 $save_line = 0;
1761 fixup_current_range(\$lines[$range_last_linenr], $delta_offset--, -1);
1762 }
1763
1764 while (defined($inserted) && ${$inserted}{'LINENR'} == $old_linenr) {
1765 push(@lines, ${$inserted}{'LINE'});
1766 $inserted = @{$insertedRef}[$next_insert++];
1767 $new_linenr++;
1768 fixup_current_range(\$lines[$range_last_linenr], $delta_offset++, 1);
1769 }
1770
1771 if ($save_line) {
1772 push(@lines, $line);
1773 $new_linenr++;
1774 }
1775
1776 $old_linenr++;
1777 }
1778
1779 return @lines;
1780}
1781
Joe Perchesf2d7e4d2014-08-06 16:11:07 -07001782sub fix_insert_line {
1783 my ($linenr, $line) = @_;
1784
1785 my $inserted = {
1786 LINENR => $linenr,
1787 LINE => $line,
1788 };
1789 push(@fixed_inserted, $inserted);
1790}
1791
1792sub fix_delete_line {
1793 my ($linenr, $line) = @_;
1794
1795 my $deleted = {
1796 LINENR => $linenr,
1797 LINE => $line,
1798 };
1799
1800 push(@fixed_deleted, $deleted);
1801}
1802
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07001803sub ERROR {
Joe Perchescbec18a2014-04-03 14:49:19 -07001804 my ($type, $msg) = @_;
1805
1806 if (report("ERROR", $type, $msg)) {
Andy Whitcroft773647a2008-03-28 14:15:58 -07001807 our $clean = 0;
1808 our $cnt_error++;
Joe Perches3705ce52013-07-03 15:05:31 -07001809 return 1;
Andy Whitcroft773647a2008-03-28 14:15:58 -07001810 }
Joe Perches3705ce52013-07-03 15:05:31 -07001811 return 0;
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07001812}
1813sub WARN {
Joe Perchescbec18a2014-04-03 14:49:19 -07001814 my ($type, $msg) = @_;
1815
1816 if (report("WARNING", $type, $msg)) {
Andy Whitcroft773647a2008-03-28 14:15:58 -07001817 our $clean = 0;
1818 our $cnt_warn++;
Joe Perches3705ce52013-07-03 15:05:31 -07001819 return 1;
Andy Whitcroft773647a2008-03-28 14:15:58 -07001820 }
Joe Perches3705ce52013-07-03 15:05:31 -07001821 return 0;
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07001822}
1823sub CHK {
Joe Perchescbec18a2014-04-03 14:49:19 -07001824 my ($type, $msg) = @_;
1825
1826 if ($check && report("CHECK", $type, $msg)) {
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001827 our $clean = 0;
1828 our $cnt_chk++;
Joe Perches3705ce52013-07-03 15:05:31 -07001829 return 1;
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001830 }
Joe Perches3705ce52013-07-03 15:05:31 -07001831 return 0;
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07001832}
1833
Andy Whitcroft6ecd9672008-10-15 22:02:21 -07001834sub check_absolute_file {
1835 my ($absolute, $herecurr) = @_;
1836 my $file = $absolute;
1837
1838 ##print "absolute<$absolute>\n";
1839
1840 # See if any suffix of this path is a path within the tree.
1841 while ($file =~ s@^[^/]*/@@) {
1842 if (-f "$root/$file") {
1843 ##print "file<$file>\n";
1844 last;
1845 }
1846 }
1847 if (! -f _) {
1848 return 0;
1849 }
1850
1851 # It is, so see if the prefix is acceptable.
1852 my $prefix = $absolute;
1853 substr($prefix, -length($file)) = '';
1854
1855 ##print "prefix<$prefix>\n";
1856 if ($prefix ne ".../") {
Joe Perches000d1cc12011-07-25 17:13:25 -07001857 WARN("USE_RELATIVE_PATH",
1858 "use relative pathname instead of absolute in changelog text\n" . $herecurr);
Andy Whitcroft6ecd9672008-10-15 22:02:21 -07001859 }
1860}
1861
Joe Perches3705ce52013-07-03 15:05:31 -07001862sub trim {
1863 my ($string) = @_;
1864
Joe Perchesb34c6482013-09-11 14:24:01 -07001865 $string =~ s/^\s+|\s+$//g;
1866
1867 return $string;
1868}
1869
1870sub ltrim {
1871 my ($string) = @_;
1872
1873 $string =~ s/^\s+//;
1874
1875 return $string;
1876}
1877
1878sub rtrim {
1879 my ($string) = @_;
1880
1881 $string =~ s/\s+$//;
Joe Perches3705ce52013-07-03 15:05:31 -07001882
1883 return $string;
1884}
1885
Joe Perches52ea8502013-11-12 15:10:09 -08001886sub string_find_replace {
1887 my ($string, $find, $replace) = @_;
1888
1889 $string =~ s/$find/$replace/g;
1890
1891 return $string;
1892}
1893
Joe Perches3705ce52013-07-03 15:05:31 -07001894sub tabify {
1895 my ($leading) = @_;
1896
1897 my $source_indent = 8;
1898 my $max_spaces_before_tab = $source_indent - 1;
1899 my $spaces_to_tab = " " x $source_indent;
1900
1901 #convert leading spaces to tabs
1902 1 while $leading =~ s@^([\t]*)$spaces_to_tab@$1\t@g;
1903 #Remove spaces before a tab
1904 1 while $leading =~ s@^([\t]*)( {1,$max_spaces_before_tab})\t@$1\t@g;
1905
1906 return "$leading";
1907}
1908
Joe Perchesd1fe9c02012-03-23 15:02:16 -07001909sub pos_last_openparen {
1910 my ($line) = @_;
1911
1912 my $pos = 0;
1913
1914 my $opens = $line =~ tr/\(/\(/;
1915 my $closes = $line =~ tr/\)/\)/;
1916
1917 my $last_openparen = 0;
1918
1919 if (($opens == 0) || ($closes >= $opens)) {
1920 return -1;
1921 }
1922
1923 my $len = length($line);
1924
1925 for ($pos = 0; $pos < $len; $pos++) {
1926 my $string = substr($line, $pos);
1927 if ($string =~ /^($FuncArg|$balanced_parens)/) {
1928 $pos += length($1) - 1;
1929 } elsif (substr($line, $pos, 1) eq '(') {
1930 $last_openparen = $pos;
1931 } elsif (index($string, '(') == -1) {
1932 last;
1933 }
1934 }
1935
Joe Perches91cb5192014-04-03 14:49:32 -07001936 return length(expand_tabs(substr($line, 0, $last_openparen))) + 1;
Joe Perchesd1fe9c02012-03-23 15:02:16 -07001937}
1938
Andy Whitcroft0a920b52007-06-01 00:46:48 -07001939sub process {
1940 my $filename = shift;
Andy Whitcroft0a920b52007-06-01 00:46:48 -07001941
1942 my $linenr=0;
1943 my $prevline="";
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001944 my $prevrawline="";
Andy Whitcroft0a920b52007-06-01 00:46:48 -07001945 my $stashline="";
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001946 my $stashrawline="";
Andy Whitcroft0a920b52007-06-01 00:46:48 -07001947
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001948 my $length;
Andy Whitcroft0a920b52007-06-01 00:46:48 -07001949 my $indent;
1950 my $previndent=0;
1951 my $stashindent=0;
1952
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07001953 our $clean = 1;
Andy Whitcroft0a920b52007-06-01 00:46:48 -07001954 my $signoff = 0;
1955 my $is_patch = 0;
1956
Joe Perches29ee1b02014-08-06 16:10:35 -07001957 my $in_header_lines = $file ? 0 : 1;
Joe Perches15662b32011-10-31 17:13:12 -07001958 my $in_commit_log = 0; #Scanning lines before patch
Joe Perches2a076f42015-04-16 12:44:28 -07001959 my $commit_log_long_line = 0;
Joe Perchese518e9a2015-06-25 15:03:27 -07001960 my $commit_log_has_diff = 0;
Joe Perches13f19372014-08-06 16:10:59 -07001961 my $reported_maintainer_file = 0;
Pasi Savanainenfa64205d2012-10-04 17:13:29 -07001962 my $non_utf8_charset = 0;
1963
Joe Perches365dd4e2014-08-06 16:10:42 -07001964 my $last_blank_line = 0;
Joe Perches5e4f6ba2014-12-10 15:52:05 -08001965 my $last_coalesced_string_linenr = -1;
Joe Perches365dd4e2014-08-06 16:10:42 -07001966
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001967 our @report = ();
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001968 our $cnt_lines = 0;
1969 our $cnt_error = 0;
1970 our $cnt_warn = 0;
1971 our $cnt_chk = 0;
1972
Andy Whitcroft0a920b52007-06-01 00:46:48 -07001973 # Trace the real file/line as we go.
1974 my $realfile = '';
1975 my $realline = 0;
1976 my $realcnt = 0;
1977 my $here = '';
1978 my $in_comment = 0;
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001979 my $comment_edge = 0;
Andy Whitcroft0a920b52007-06-01 00:46:48 -07001980 my $first_line = 0;
Wolfram Sang1e855722009-01-06 14:41:24 -08001981 my $p1_prefix = '';
Andy Whitcroft0a920b52007-06-01 00:46:48 -07001982
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001983 my $prev_values = 'E';
1984
1985 # suppression flags
Andy Whitcroft773647a2008-03-28 14:15:58 -07001986 my %suppress_ifbraces;
Andy Whitcroft170d3a22008-10-15 22:02:30 -07001987 my %suppress_whiletrailers;
Andy Whitcroft2b474a12009-10-26 16:50:16 -07001988 my %suppress_export;
Andy Whitcroft3e469cd2012-01-10 15:10:01 -08001989 my $suppress_statement = 0;
Andy Whitcroft653d4872007-06-23 17:16:34 -07001990
Joe Perches7e51f192013-09-11 14:23:57 -07001991 my %signatures = ();
Joe Perches323c1262012-12-17 16:02:07 -08001992
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001993 # Pre-scan the patch sanitizing the lines.
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07001994 # Pre-scan the patch looking for any __setup documentation.
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001995 #
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07001996 my @setup_docs = ();
1997 my $setup_docs = 0;
Andy Whitcroft773647a2008-03-28 14:15:58 -07001998
Joe Perchesd8b07712013-11-12 15:10:06 -08001999 my $camelcase_file_seeded = 0;
2000
Andy Whitcroft773647a2008-03-28 14:15:58 -07002001 sanitise_line_reset();
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002002 my $line;
2003 foreach my $rawline (@rawlines) {
Andy Whitcroft773647a2008-03-28 14:15:58 -07002004 $linenr++;
2005 $line = $rawline;
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002006
Joe Perches3705ce52013-07-03 15:05:31 -07002007 push(@fixed, $rawline) if ($fix);
2008
Andy Whitcroft773647a2008-03-28 14:15:58 -07002009 if ($rawline=~/^\+\+\+\s+(\S+)/) {
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07002010 $setup_docs = 0;
2011 if ($1 =~ m@Documentation/kernel-parameters.txt$@) {
2012 $setup_docs = 1;
2013 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07002014 #next;
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07002015 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07002016 if ($rawline=~/^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@/) {
2017 $realline=$1-1;
2018 if (defined $2) {
2019 $realcnt=$3+1;
2020 } else {
2021 $realcnt=1+1;
2022 }
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07002023 $in_comment = 0;
Andy Whitcroft773647a2008-03-28 14:15:58 -07002024
2025 # Guestimate if this is a continuing comment. Run
2026 # the context looking for a comment "edge". If this
2027 # edge is a close comment then we must be in a comment
2028 # at context start.
2029 my $edge;
Andy Whitcroft01fa9142008-10-15 22:02:19 -07002030 my $cnt = $realcnt;
2031 for (my $ln = $linenr + 1; $cnt > 0; $ln++) {
2032 next if (defined $rawlines[$ln - 1] &&
2033 $rawlines[$ln - 1] =~ /^-/);
2034 $cnt--;
2035 #print "RAW<$rawlines[$ln - 1]>\n";
Andy Whitcroft721c1cb2009-01-06 14:41:16 -08002036 last if (!defined $rawlines[$ln - 1]);
Andy Whitcroftfae17da2009-01-06 14:41:20 -08002037 if ($rawlines[$ln - 1] =~ m@(/\*|\*/)@ &&
2038 $rawlines[$ln - 1] !~ m@"[^"]*(?:/\*|\*/)[^"]*"@) {
2039 ($edge) = $1;
2040 last;
2041 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07002042 }
2043 if (defined $edge && $edge eq '*/') {
2044 $in_comment = 1;
2045 }
2046
2047 # Guestimate if this is a continuing comment. If this
2048 # is the start of a diff block and this line starts
2049 # ' *' then it is very likely a comment.
2050 if (!defined $edge &&
Andy Whitcroft83242e02009-01-06 14:41:17 -08002051 $rawlines[$linenr] =~ m@^.\s*(?:\*\*+| \*)(?:\s|$)@)
Andy Whitcroft773647a2008-03-28 14:15:58 -07002052 {
2053 $in_comment = 1;
2054 }
2055
2056 ##print "COMMENT:$in_comment edge<$edge> $rawline\n";
2057 sanitise_line_reset($in_comment);
2058
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07002059 } elsif ($realcnt && $rawline =~ /^(?:\+| |$)/) {
Andy Whitcroft773647a2008-03-28 14:15:58 -07002060 # Standardise the strings and chars within the input to
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07002061 # simplify matching -- only bother with positive lines.
Andy Whitcroft773647a2008-03-28 14:15:58 -07002062 $line = sanitise_line($rawline);
2063 }
2064 push(@lines, $line);
2065
2066 if ($realcnt > 1) {
2067 $realcnt-- if ($line =~ /^(?:\+| |$)/);
2068 } else {
2069 $realcnt = 0;
2070 }
2071
2072 #print "==>$rawline\n";
2073 #print "-->$line\n";
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07002074
2075 if ($setup_docs && $line =~ /^\+/) {
2076 push(@setup_docs, $line);
2077 }
2078 }
2079
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07002080 $prefix = '';
2081
Andy Whitcroft773647a2008-03-28 14:15:58 -07002082 $realcnt = 0;
2083 $linenr = 0;
Joe Perches194f66f2014-08-06 16:11:03 -07002084 $fixlinenr = -1;
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002085 foreach my $line (@lines) {
2086 $linenr++;
Joe Perches194f66f2014-08-06 16:11:03 -07002087 $fixlinenr++;
Joe Perches1b5539b2013-09-11 14:24:03 -07002088 my $sline = $line; #copy of $line
2089 $sline =~ s/$;/ /g; #with comments as spaces
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002090
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002091 my $rawline = $rawlines[$linenr - 1];
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07002092
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002093#extract the line range in the file after the patch is applied
Joe Perchese518e9a2015-06-25 15:03:27 -07002094 if (!$in_commit_log &&
2095 $line =~ /^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@/) {
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002096 $is_patch = 1;
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07002097 $first_line = $linenr + 1;
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002098 $realline=$1-1;
2099 if (defined $2) {
2100 $realcnt=$3+1;
2101 } else {
2102 $realcnt=1+1;
2103 }
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002104 annotate_reset();
Andy Whitcroft13214ad2008-02-08 04:22:03 -08002105 $prev_values = 'E';
2106
Andy Whitcroft773647a2008-03-28 14:15:58 -07002107 %suppress_ifbraces = ();
Andy Whitcroft170d3a22008-10-15 22:02:30 -07002108 %suppress_whiletrailers = ();
Andy Whitcroft2b474a12009-10-26 16:50:16 -07002109 %suppress_export = ();
Andy Whitcroft3e469cd2012-01-10 15:10:01 -08002110 $suppress_statement = 0;
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002111 next;
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002112
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07002113# track the line number as we move through the hunk, note that
2114# new versions of GNU diff omit the leading space on completely
2115# blank context lines so we need to count that too.
Andy Whitcroft773647a2008-03-28 14:15:58 -07002116 } elsif ($line =~ /^( |\+|$)/) {
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002117 $realline++;
Andy Whitcroftd8aaf122007-06-23 17:16:44 -07002118 $realcnt-- if ($realcnt != 0);
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002119
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07002120 # Measure the line length and indent.
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002121 ($length, $indent) = line_stats($rawline);
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002122
2123 # Track the previous line.
2124 ($prevline, $stashline) = ($stashline, $line);
2125 ($previndent, $stashindent) = ($stashindent, $indent);
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002126 ($prevrawline, $stashrawline) = ($stashrawline, $rawline);
2127
Andy Whitcroft773647a2008-03-28 14:15:58 -07002128 #warn "line<$line>\n";
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07002129
Andy Whitcroftd8aaf122007-06-23 17:16:44 -07002130 } elsif ($realcnt == 1) {
2131 $realcnt--;
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002132 }
2133
Andy Whitcroftcc77cdc2009-10-26 16:50:13 -07002134 my $hunk_line = ($realcnt != 0);
2135
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07002136 $here = "#$linenr: " if (!$file);
2137 $here = "#$realline: " if ($file);
Andy Whitcroft773647a2008-03-28 14:15:58 -07002138
Joe Perches2ac73b4f2014-06-04 16:12:05 -07002139 my $found_file = 0;
Andy Whitcroft773647a2008-03-28 14:15:58 -07002140 # extract the filename as it passes
Rabin Vincent3bf9a002010-10-26 14:23:16 -07002141 if ($line =~ /^diff --git.*?(\S+)$/) {
2142 $realfile = $1;
Joe Perches2b7ab452013-11-12 15:10:14 -08002143 $realfile =~ s@^([^/]*)/@@ if (!$file);
Joe Perches270c49a2012-01-10 15:09:50 -08002144 $in_commit_log = 0;
Joe Perches2ac73b4f2014-06-04 16:12:05 -07002145 $found_file = 1;
Rabin Vincent3bf9a002010-10-26 14:23:16 -07002146 } elsif ($line =~ /^\+\+\+\s+(\S+)/) {
Andy Whitcroft773647a2008-03-28 14:15:58 -07002147 $realfile = $1;
Joe Perches2b7ab452013-11-12 15:10:14 -08002148 $realfile =~ s@^([^/]*)/@@ if (!$file);
Joe Perches270c49a2012-01-10 15:09:50 -08002149 $in_commit_log = 0;
Wolfram Sang1e855722009-01-06 14:41:24 -08002150
2151 $p1_prefix = $1;
Andy Whitcrofte2f7aa42009-02-27 14:03:06 -08002152 if (!$file && $tree && $p1_prefix ne '' &&
2153 -e "$root/$p1_prefix") {
Joe Perches000d1cc12011-07-25 17:13:25 -07002154 WARN("PATCH_PREFIX",
2155 "patch prefix '$p1_prefix' exists, appears to be a -p0 patch\n");
Wolfram Sang1e855722009-01-06 14:41:24 -08002156 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07002157
Andy Whitcroftc1ab3322008-10-15 22:02:20 -07002158 if ($realfile =~ m@^include/asm/@) {
Joe Perches000d1cc12011-07-25 17:13:25 -07002159 ERROR("MODIFIED_INCLUDE_ASM",
2160 "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 -07002161 }
Joe Perches2ac73b4f2014-06-04 16:12:05 -07002162 $found_file = 1;
2163 }
2164
Joe Perches34d88152015-06-25 15:03:05 -07002165#make up the handle for any error we report on this line
2166 if ($showfile) {
2167 $prefix = "$realfile:$realline: "
2168 } elsif ($emacs) {
2169 $prefix = "$filename:$linenr: ";
2170 }
2171
Joe Perches2ac73b4f2014-06-04 16:12:05 -07002172 if ($found_file) {
2173 if ($realfile =~ m@^(drivers/net/|net/)@) {
2174 $check = 1;
2175 } else {
2176 $check = $check_orig;
2177 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07002178 next;
2179 }
2180
Randy Dunlap389834b2007-06-08 13:47:03 -07002181 $here .= "FILE: $realfile:$realline:" if ($realcnt != 0);
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002182
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002183 my $hereline = "$here\n$rawline\n";
2184 my $herecurr = "$here\n$rawline\n";
2185 my $hereprev = "$here\n$prevrawline\n$rawline\n";
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002186
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07002187 $cnt_lines++ if ($realcnt != 0);
2188
Joe Perchese518e9a2015-06-25 15:03:27 -07002189# Check if the commit log has what seems like a diff which can confuse patch
2190 if ($in_commit_log && !$commit_log_has_diff &&
2191 (($line =~ m@^\s+diff\b.*a/[\w/]+@ &&
2192 $line =~ m@^\s+diff\b.*a/([\w/]+)\s+b/$1\b@) ||
2193 $line =~ m@^\s*(?:\-\-\-\s+a/|\+\+\+\s+b/)@ ||
2194 $line =~ m/^\s*\@\@ \-\d+,\d+ \+\d+,\d+ \@\@/)) {
2195 ERROR("DIFF_IN_COMMIT_MSG",
2196 "Avoid using diff content in the commit message - patch(1) might not work\n" . $herecurr);
2197 $commit_log_has_diff = 1;
2198 }
2199
Rabin Vincent3bf9a002010-10-26 14:23:16 -07002200# Check for incorrect file permissions
2201 if ($line =~ /^new (file )?mode.*[7531]\d{0,2}$/) {
2202 my $permhere = $here . "FILE: $realfile\n";
Joe Perches04db4d22013-04-29 16:18:14 -07002203 if ($realfile !~ m@scripts/@ &&
2204 $realfile !~ /\.(py|pl|awk|sh)$/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07002205 ERROR("EXECUTE_PERMISSIONS",
2206 "do not set execute permissions for source files\n" . $permhere);
Rabin Vincent3bf9a002010-10-26 14:23:16 -07002207 }
2208 }
2209
Joe Perches20112472011-07-25 17:13:23 -07002210# Check the patch for a signoff:
Andy Whitcroftd8aaf122007-06-23 17:16:44 -07002211 if ($line =~ /^\s*signed-off-by:/i) {
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07002212 $signoff++;
Joe Perches15662b32011-10-31 17:13:12 -07002213 $in_commit_log = 0;
Joe Perches20112472011-07-25 17:13:23 -07002214 }
2215
Joe Perchese0d975b2014-12-10 15:51:49 -08002216# Check if MAINTAINERS is being updated. If so, there's probably no need to
2217# emit the "does MAINTAINERS need updating?" message on file add/move/delete
2218 if ($line =~ /^\s*MAINTAINERS\s*\|/) {
2219 $reported_maintainer_file = 1;
2220 }
2221
Joe Perches20112472011-07-25 17:13:23 -07002222# Check signature styles
Joe Perches270c49a2012-01-10 15:09:50 -08002223 if (!$in_header_lines &&
Joe Perchesce0338df3c2012-07-30 14:41:18 -07002224 $line =~ /^(\s*)([a-z0-9_-]+by:|$signature_tags)(\s*)(.*)/i) {
Joe Perches20112472011-07-25 17:13:23 -07002225 my $space_before = $1;
2226 my $sign_off = $2;
2227 my $space_after = $3;
2228 my $email = $4;
2229 my $ucfirst_sign_off = ucfirst(lc($sign_off));
2230
Joe Perchesce0338df3c2012-07-30 14:41:18 -07002231 if ($sign_off !~ /$signature_tags/) {
2232 WARN("BAD_SIGN_OFF",
2233 "Non-standard signature: $sign_off\n" . $herecurr);
2234 }
Joe Perches20112472011-07-25 17:13:23 -07002235 if (defined $space_before && $space_before ne "") {
Joe Perches3705ce52013-07-03 15:05:31 -07002236 if (WARN("BAD_SIGN_OFF",
2237 "Do not use whitespace before $ucfirst_sign_off\n" . $herecurr) &&
2238 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07002239 $fixed[$fixlinenr] =
Joe Perches3705ce52013-07-03 15:05:31 -07002240 "$ucfirst_sign_off $email";
2241 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002242 }
Joe Perches20112472011-07-25 17:13:23 -07002243 if ($sign_off =~ /-by:$/i && $sign_off ne $ucfirst_sign_off) {
Joe Perches3705ce52013-07-03 15:05:31 -07002244 if (WARN("BAD_SIGN_OFF",
2245 "'$ucfirst_sign_off' is the preferred signature form\n" . $herecurr) &&
2246 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07002247 $fixed[$fixlinenr] =
Joe Perches3705ce52013-07-03 15:05:31 -07002248 "$ucfirst_sign_off $email";
2249 }
2250
Joe Perches20112472011-07-25 17:13:23 -07002251 }
2252 if (!defined $space_after || $space_after ne " ") {
Joe Perches3705ce52013-07-03 15:05:31 -07002253 if (WARN("BAD_SIGN_OFF",
2254 "Use a single space after $ucfirst_sign_off\n" . $herecurr) &&
2255 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07002256 $fixed[$fixlinenr] =
Joe Perches3705ce52013-07-03 15:05:31 -07002257 "$ucfirst_sign_off $email";
2258 }
Joe Perches20112472011-07-25 17:13:23 -07002259 }
2260
2261 my ($email_name, $email_address, $comment) = parse_email($email);
2262 my $suggested_email = format_email(($email_name, $email_address));
2263 if ($suggested_email eq "") {
Joe Perches000d1cc12011-07-25 17:13:25 -07002264 ERROR("BAD_SIGN_OFF",
2265 "Unrecognized email address: '$email'\n" . $herecurr);
Joe Perches20112472011-07-25 17:13:23 -07002266 } else {
2267 my $dequoted = $suggested_email;
2268 $dequoted =~ s/^"//;
2269 $dequoted =~ s/" </ </;
2270 # Don't force email to have quotes
2271 # Allow just an angle bracketed address
2272 if ("$dequoted$comment" ne $email &&
2273 "<$email_address>$comment" ne $email &&
2274 "$suggested_email$comment" ne $email) {
Joe Perches000d1cc12011-07-25 17:13:25 -07002275 WARN("BAD_SIGN_OFF",
2276 "email address '$email' might be better as '$suggested_email$comment'\n" . $herecurr);
Joe Perches20112472011-07-25 17:13:23 -07002277 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002278 }
Joe Perches7e51f192013-09-11 14:23:57 -07002279
2280# Check for duplicate signatures
2281 my $sig_nospace = $line;
2282 $sig_nospace =~ s/\s//g;
2283 $sig_nospace = lc($sig_nospace);
2284 if (defined $signatures{$sig_nospace}) {
2285 WARN("BAD_SIGN_OFF",
2286 "Duplicate signature\n" . $herecurr);
2287 } else {
2288 $signatures{$sig_nospace} = 1;
2289 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002290 }
2291
Joe Perchesa2fe16b2015-02-13 14:39:02 -08002292# Check email subject for common tools that don't need to be mentioned
2293 if ($in_header_lines &&
2294 $line =~ /^Subject:.*\b(?:checkpatch|sparse|smatch)\b[^:]/i) {
2295 WARN("EMAIL_SUBJECT",
2296 "A patch subject line should describe the change not the tool that found it\n" . $herecurr);
2297 }
2298
Joe Perches9b3189e2014-06-04 16:12:10 -07002299# Check for old stable address
2300 if ($line =~ /^\s*cc:\s*.*<?\bstable\@kernel\.org\b>?.*$/i) {
2301 ERROR("STABLE_ADDRESS",
2302 "The 'stable' address should be 'stable\@vger.kernel.org'\n" . $herecurr);
2303 }
2304
Christopher Covington7ebd05e2014-04-03 14:49:31 -07002305# Check for unwanted Gerrit info
2306 if ($in_commit_log && $line =~ /^\s*change-id:/i) {
2307 ERROR("GERRIT_CHANGE_ID",
2308 "Remove Gerrit Change-Id's before submitting upstream.\n" . $herecurr);
2309 }
2310
Joe Perches2a076f42015-04-16 12:44:28 -07002311# Check for line lengths > 75 in commit log, warn once
2312 if ($in_commit_log && !$commit_log_long_line &&
2313 length($line) > 75) {
2314 WARN("COMMIT_LOG_LONG_LINE",
2315 "Possible unwrapped commit description (prefer a maximum 75 chars per line)\n" . $herecurr);
2316 $commit_log_long_line = 1;
2317 }
2318
Joe Perches0d7835f2015-02-13 14:38:35 -08002319# Check for git id commit length and improperly formed commit descriptions
2320 if ($in_commit_log && $line =~ /\b(c)ommit\s+([0-9a-f]{5,})/i) {
Joe Perchesd311cd42014-08-06 16:10:57 -07002321 my $init_char = $1;
2322 my $orig_commit = lc($2);
Joe Perches0d7835f2015-02-13 14:38:35 -08002323 my $short = 1;
2324 my $long = 0;
2325 my $case = 1;
2326 my $space = 1;
2327 my $hasdesc = 0;
Joe Perches19c146a2015-02-13 14:39:00 -08002328 my $hasparens = 0;
Joe Perches0d7835f2015-02-13 14:38:35 -08002329 my $id = '0123456789ab';
2330 my $orig_desc = "commit description";
2331 my $description = "";
2332
2333 $short = 0 if ($line =~ /\bcommit\s+[0-9a-f]{12,40}/i);
2334 $long = 1 if ($line =~ /\bcommit\s+[0-9a-f]{41,}/i);
2335 $space = 0 if ($line =~ /\bcommit [0-9a-f]/i);
2336 $case = 0 if ($line =~ /\b[Cc]ommit\s+[0-9a-f]{5,40}[^A-F]/);
2337 if ($line =~ /\bcommit\s+[0-9a-f]{5,}\s+\("([^"]+)"\)/i) {
2338 $orig_desc = $1;
Joe Perches19c146a2015-02-13 14:39:00 -08002339 $hasparens = 1;
Joe Perches0d7835f2015-02-13 14:38:35 -08002340 } elsif ($line =~ /\bcommit\s+[0-9a-f]{5,}\s*$/i &&
2341 defined $rawlines[$linenr] &&
2342 $rawlines[$linenr] =~ /^\s*\("([^"]+)"\)/) {
2343 $orig_desc = $1;
Joe Perches19c146a2015-02-13 14:39:00 -08002344 $hasparens = 1;
Joe Perchesb671fde2015-02-13 14:38:41 -08002345 } elsif ($line =~ /\bcommit\s+[0-9a-f]{5,}\s+\("[^"]+$/i &&
2346 defined $rawlines[$linenr] &&
2347 $rawlines[$linenr] =~ /^\s*[^"]+"\)/) {
2348 $line =~ /\bcommit\s+[0-9a-f]{5,}\s+\("([^"]+)$/i;
2349 $orig_desc = $1;
2350 $rawlines[$linenr] =~ /^\s*([^"]+)"\)/;
2351 $orig_desc .= " " . $1;
Joe Perches19c146a2015-02-13 14:39:00 -08002352 $hasparens = 1;
Joe Perches0d7835f2015-02-13 14:38:35 -08002353 }
2354
2355 ($id, $description) = git_commit_info($orig_commit,
2356 $id, $orig_desc);
2357
Joe Perches19c146a2015-02-13 14:39:00 -08002358 if ($short || $long || $space || $case || ($orig_desc ne $description) || !$hasparens) {
Joe Perches0d7835f2015-02-13 14:38:35 -08002359 ERROR("GIT_COMMIT_ID",
2360 "Please use git commit description style 'commit <12+ chars of sha1> (\"<title line>\")' - ie: '${init_char}ommit $id (\"$description\")'\n" . $herecurr);
2361 }
Joe Perchesd311cd42014-08-06 16:10:57 -07002362 }
2363
Joe Perches13f19372014-08-06 16:10:59 -07002364# Check for added, moved or deleted files
2365 if (!$reported_maintainer_file && !$in_commit_log &&
2366 ($line =~ /^(?:new|deleted) file mode\s*\d+\s*$/ ||
2367 $line =~ /^rename (?:from|to) [\w\/\.\-]+\s*$/ ||
2368 ($line =~ /\{\s*([\w\/\.\-]*)\s*\=\>\s*([\w\/\.\-]*)\s*\}/ &&
2369 (defined($1) || defined($2))))) {
2370 $reported_maintainer_file = 1;
2371 WARN("FILE_PATH_CHANGES",
2372 "added, moved or deleted file(s), does MAINTAINERS need updating?\n" . $herecurr);
2373 }
2374
Andy Whitcroft00df3442007-06-08 13:47:06 -07002375# Check for wrappage within a valid hunk of the file
Andy Whitcroft8905a672007-11-28 16:21:06 -08002376 if ($realcnt != 0 && $line !~ m{^(?:\+|-| |\\ No newline|$)}) {
Joe Perches000d1cc12011-07-25 17:13:25 -07002377 ERROR("CORRUPTED_PATCH",
2378 "patch seems to be corrupt (line wrapped?)\n" .
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07002379 $herecurr) if (!$emitted_corrupt++);
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07002380 }
2381
Andy Whitcroft6ecd9672008-10-15 22:02:21 -07002382# Check for absolute kernel paths.
2383 if ($tree) {
2384 while ($line =~ m{(?:^|\s)(/\S*)}g) {
2385 my $file = $1;
2386
2387 if ($file =~ m{^(.*?)(?::\d+)+:?$} &&
2388 check_absolute_file($1, $herecurr)) {
2389 #
2390 } else {
2391 check_absolute_file($file, $herecurr);
2392 }
2393 }
2394 }
2395
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07002396# UTF-8 regex found at http://www.w3.org/International/questions/qa-forms-utf-8.en.php
2397 if (($realfile =~ /^$/ || $line =~ /^\+/) &&
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07002398 $rawline !~ m/^$UTF8*$/) {
2399 my ($utf8_prefix) = ($rawline =~ /^($UTF8*)/);
2400
2401 my $blank = copy_spacing($rawline);
2402 my $ptr = substr($blank, 0, length($utf8_prefix)) . "^";
2403 my $hereptr = "$hereline$ptr\n";
2404
Joe Perches34d99212011-07-25 17:13:26 -07002405 CHK("INVALID_UTF8",
2406 "Invalid UTF-8, patch and commit message should be encoded in UTF-8\n" . $hereptr);
Andy Whitcroft00df3442007-06-08 13:47:06 -07002407 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002408
Joe Perches15662b32011-10-31 17:13:12 -07002409# Check if it's the start of a commit log
2410# (not a header line and we haven't seen the patch filename)
2411 if ($in_header_lines && $realfile =~ /^$/ &&
Joe Perches29ee1b02014-08-06 16:10:35 -07002412 !($rawline =~ /^\s+\S/ ||
2413 $rawline =~ /^(commit\b|from\b|[\w-]+:).*$/i)) {
Joe Perches15662b32011-10-31 17:13:12 -07002414 $in_header_lines = 0;
2415 $in_commit_log = 1;
2416 }
2417
Pasi Savanainenfa64205d2012-10-04 17:13:29 -07002418# Check if there is UTF-8 in a commit log when a mail header has explicitly
2419# declined it, i.e defined some charset where it is missing.
2420 if ($in_header_lines &&
2421 $rawline =~ /^Content-Type:.+charset="(.+)".*$/ &&
2422 $1 !~ /utf-8/i) {
2423 $non_utf8_charset = 1;
2424 }
2425
2426 if ($in_commit_log && $non_utf8_charset && $realfile =~ /^$/ &&
Joe Perches15662b32011-10-31 17:13:12 -07002427 $rawline =~ /$NON_ASCII_UTF8/) {
Pasi Savanainenfa64205d2012-10-04 17:13:29 -07002428 WARN("UTF8_BEFORE_PATCH",
Joe Perches15662b32011-10-31 17:13:12 -07002429 "8-bit UTF-8 used in possible commit log\n" . $herecurr);
2430 }
2431
Kees Cook66b47b42014-10-13 15:51:57 -07002432# Check for various typo / spelling mistakes
Joe Perches66d7a382015-04-16 12:44:08 -07002433 if (defined($misspellings) &&
2434 ($in_commit_log || $line =~ /^(?:\+|Subject:)/i)) {
Joe Perchesebfd7d62015-04-16 12:44:14 -07002435 while ($rawline =~ /(?:^|[^a-z@])($misspellings)(?:\b|$|[^a-z@])/gi) {
Kees Cook66b47b42014-10-13 15:51:57 -07002436 my $typo = $1;
2437 my $typo_fix = $spelling_fix{lc($typo)};
2438 $typo_fix = ucfirst($typo_fix) if ($typo =~ /^[A-Z]/);
2439 $typo_fix = uc($typo_fix) if ($typo =~ /^[A-Z]+$/);
2440 my $msg_type = \&WARN;
2441 $msg_type = \&CHK if ($file);
2442 if (&{$msg_type}("TYPO_SPELLING",
2443 "'$typo' may be misspelled - perhaps '$typo_fix'?\n" . $herecurr) &&
2444 $fix) {
2445 $fixed[$fixlinenr] =~ s/(^|[^A-Za-z@])($typo)($|[^A-Za-z@])/$1$typo_fix$3/;
2446 }
2447 }
2448 }
2449
Andy Whitcroft306708542008-10-15 22:02:28 -07002450# ignore non-hunk lines and lines being removed
2451 next if (!$hunk_line || $line =~ /^-/);
Andy Whitcroft00df3442007-06-08 13:47:06 -07002452
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002453#trailing whitespace
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07002454 if ($line =~ /^\+.*\015/) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002455 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
Joe Perchesd5e616f2013-09-11 14:23:54 -07002456 if (ERROR("DOS_LINE_ENDINGS",
2457 "DOS line endings\n" . $herevet) &&
2458 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07002459 $fixed[$fixlinenr] =~ s/[\s\015]+$//;
Joe Perchesd5e616f2013-09-11 14:23:54 -07002460 }
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002461 } elsif ($rawline =~ /^\+.*\S\s+$/ || $rawline =~ /^\+\s+$/) {
2462 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
Joe Perches3705ce52013-07-03 15:05:31 -07002463 if (ERROR("TRAILING_WHITESPACE",
2464 "trailing whitespace\n" . $herevet) &&
2465 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07002466 $fixed[$fixlinenr] =~ s/\s+$//;
Joe Perches3705ce52013-07-03 15:05:31 -07002467 }
2468
Andy Whitcroftd2c0a232010-10-26 14:23:12 -07002469 $rpt_cleaners = 1;
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002470 }
Andy Whitcroft5368df22008-10-15 22:02:27 -07002471
Josh Triplett4783f892013-11-12 15:10:12 -08002472# Check for FSF mailing addresses.
Alexander Duyck109d8cb2014-01-23 15:54:50 -08002473 if ($rawline =~ /\bwrite to the Free/i ||
Joe Perches3e2232f2014-01-23 15:54:48 -08002474 $rawline =~ /\b59\s+Temple\s+Pl/i ||
2475 $rawline =~ /\b51\s+Franklin\s+St/i) {
Josh Triplett4783f892013-11-12 15:10:12 -08002476 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2477 my $msg_type = \&ERROR;
2478 $msg_type = \&CHK if ($file);
2479 &{$msg_type}("FSF_MAILING_ADDRESS",
Joe Perches3e2232f2014-01-23 15:54:48 -08002480 "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 -08002481 }
2482
Andi Kleen33549572010-05-24 14:33:29 -07002483# check for Kconfig help text having a real description
Andy Whitcroft9fe287d72010-10-26 14:23:15 -07002484# Only applies when adding the entry originally, after that we do not have
2485# sufficient context to determine whether it is indeed long enough.
Andi Kleen33549572010-05-24 14:33:29 -07002486 if ($realfile =~ /Kconfig/ &&
Joe Perches8d73e0e2014-08-06 16:10:46 -07002487 $line =~ /^\+\s*config\s+/) {
Andi Kleen33549572010-05-24 14:33:29 -07002488 my $length = 0;
Andy Whitcroft9fe287d72010-10-26 14:23:15 -07002489 my $cnt = $realcnt;
2490 my $ln = $linenr + 1;
2491 my $f;
Andy Whitcrofta1385802012-01-10 15:10:03 -08002492 my $is_start = 0;
Andy Whitcroft9fe287d72010-10-26 14:23:15 -07002493 my $is_end = 0;
Andy Whitcrofta1385802012-01-10 15:10:03 -08002494 for (; $cnt > 0 && defined $lines[$ln - 1]; $ln++) {
Andy Whitcroft9fe287d72010-10-26 14:23:15 -07002495 $f = $lines[$ln - 1];
2496 $cnt-- if ($lines[$ln - 1] !~ /^-/);
2497 $is_end = $lines[$ln - 1] =~ /^\+/;
Andy Whitcroft9fe287d72010-10-26 14:23:15 -07002498
2499 next if ($f =~ /^-/);
Joe Perches8d73e0e2014-08-06 16:10:46 -07002500 last if (!$file && $f =~ /^\@\@/);
Andy Whitcrofta1385802012-01-10 15:10:03 -08002501
Joe Perches8d73e0e2014-08-06 16:10:46 -07002502 if ($lines[$ln - 1] =~ /^\+\s*(?:bool|tristate)\s*\"/) {
Andy Whitcrofta1385802012-01-10 15:10:03 -08002503 $is_start = 1;
Joe Perches8d73e0e2014-08-06 16:10:46 -07002504 } elsif ($lines[$ln - 1] =~ /^\+\s*(?:---)?help(?:---)?$/) {
Andy Whitcrofta1385802012-01-10 15:10:03 -08002505 $length = -1;
2506 }
2507
Andy Whitcroft9fe287d72010-10-26 14:23:15 -07002508 $f =~ s/^.//;
Andi Kleen33549572010-05-24 14:33:29 -07002509 $f =~ s/#.*//;
2510 $f =~ s/^\s+//;
2511 next if ($f =~ /^$/);
Andy Whitcroft9fe287d72010-10-26 14:23:15 -07002512 if ($f =~ /^\s*config\s/) {
2513 $is_end = 1;
2514 last;
2515 }
Andi Kleen33549572010-05-24 14:33:29 -07002516 $length++;
2517 }
Vadim Bendebury56193272014-10-13 15:51:48 -07002518 if ($is_start && $is_end && $length < $min_conf_desc_length) {
2519 WARN("CONFIG_DESCRIPTION",
2520 "please write a paragraph that describes the config symbol fully\n" . $herecurr);
2521 }
Andy Whitcrofta1385802012-01-10 15:10:03 -08002522 #print "is_start<$is_start> is_end<$is_end> length<$length>\n";
Andi Kleen33549572010-05-24 14:33:29 -07002523 }
2524
Kees Cook1ba8dfd2012-12-17 16:01:48 -08002525# discourage the addition of CONFIG_EXPERIMENTAL in Kconfig.
2526 if ($realfile =~ /Kconfig/ &&
2527 $line =~ /.\s*depends on\s+.*\bEXPERIMENTAL\b/) {
2528 WARN("CONFIG_EXPERIMENTAL",
2529 "Use of CONFIG_EXPERIMENTAL is deprecated. For alternatives, see https://lkml.org/lkml/2012/10/23/580\n");
2530 }
2531
Christoph Jaeger327953e2015-02-13 14:38:29 -08002532# discourage the use of boolean for type definition attributes of Kconfig options
2533 if ($realfile =~ /Kconfig/ &&
2534 $line =~ /^\+\s*\bboolean\b/) {
2535 WARN("CONFIG_TYPE_BOOLEAN",
2536 "Use of boolean is deprecated, please use bool instead.\n" . $herecurr);
2537 }
2538
Arnaud Lacombec68e5872011-08-15 01:07:14 -04002539 if (($realfile =~ /Makefile.*/ || $realfile =~ /Kbuild.*/) &&
2540 ($line =~ /\+(EXTRA_[A-Z]+FLAGS).*/)) {
2541 my $flag = $1;
2542 my $replacement = {
2543 'EXTRA_AFLAGS' => 'asflags-y',
2544 'EXTRA_CFLAGS' => 'ccflags-y',
2545 'EXTRA_CPPFLAGS' => 'cppflags-y',
2546 'EXTRA_LDFLAGS' => 'ldflags-y',
2547 };
2548
2549 WARN("DEPRECATED_VARIABLE",
2550 "Use of $flag is deprecated, please use \`$replacement->{$flag} instead.\n" . $herecurr) if ($replacement->{$flag});
2551 }
2552
Rob Herringbff5da42014-01-23 15:54:51 -08002553# check for DT compatible documentation
Florian Vaussard7dd05b32014-04-03 14:49:26 -07002554 if (defined $root &&
2555 (($realfile =~ /\.dtsi?$/ && $line =~ /^\+\s*compatible\s*=\s*\"/) ||
2556 ($realfile =~ /\.[ch]$/ && $line =~ /^\+.*\.compatible\s*=\s*\"/))) {
2557
Rob Herringbff5da42014-01-23 15:54:51 -08002558 my @compats = $rawline =~ /\"([a-zA-Z0-9\-\,\.\+_]+)\"/g;
2559
Florian Vaussardcc933192014-04-03 14:49:27 -07002560 my $dt_path = $root . "/Documentation/devicetree/bindings/";
2561 my $vp_file = $dt_path . "vendor-prefixes.txt";
2562
Rob Herringbff5da42014-01-23 15:54:51 -08002563 foreach my $compat (@compats) {
2564 my $compat2 = $compat;
Rob Herring185d5662014-06-04 16:12:03 -07002565 $compat2 =~ s/\,[a-zA-Z0-9]*\-/\,<\.\*>\-/;
2566 my $compat3 = $compat;
2567 $compat3 =~ s/\,([a-z]*)[0-9]*\-/\,$1<\.\*>\-/;
2568 `grep -Erq "$compat|$compat2|$compat3" $dt_path`;
Rob Herringbff5da42014-01-23 15:54:51 -08002569 if ( $? >> 8 ) {
2570 WARN("UNDOCUMENTED_DT_STRING",
2571 "DT compatible string \"$compat\" appears un-documented -- check $dt_path\n" . $herecurr);
2572 }
2573
Florian Vaussard4fbf32a2014-04-03 14:49:25 -07002574 next if $compat !~ /^([a-zA-Z0-9\-]+)\,/;
2575 my $vendor = $1;
Florian Vaussardcc933192014-04-03 14:49:27 -07002576 `grep -Eq "^$vendor\\b" $vp_file`;
Rob Herringbff5da42014-01-23 15:54:51 -08002577 if ( $? >> 8 ) {
2578 WARN("UNDOCUMENTED_DT_STRING",
Florian Vaussardcc933192014-04-03 14:49:27 -07002579 "DT compatible string vendor \"$vendor\" appears un-documented -- check $vp_file\n" . $herecurr);
Rob Herringbff5da42014-01-23 15:54:51 -08002580 }
2581 }
2582 }
2583
Andy Whitcroft5368df22008-10-15 22:02:27 -07002584# check we are in a valid source file if not then ignore this hunk
Geert Uytterhoevende4c9242014-10-13 15:51:46 -07002585 next if ($realfile !~ /\.(h|c|s|S|pl|sh|dtsi|dts)$/);
Andy Whitcroft5368df22008-10-15 22:02:27 -07002586
Joe Perches47e0c882015-06-25 15:02:57 -07002587# line length limit (with some exclusions)
2588#
2589# There are a few types of lines that may extend beyond $max_line_length:
2590# logging functions like pr_info that end in a string
2591# lines with a single string
2592# #defines that are a single string
2593#
2594# There are 3 different line length message types:
2595# LONG_LINE_COMMENT a comment starts before but extends beyond $max_linelength
2596# LONG_LINE_STRING a string starts before but extends beyond $max_line_length
2597# LONG_LINE all other lines longer than $max_line_length
2598#
2599# if LONG_LINE is ignored, the other 2 types are also ignored
2600#
2601
2602 if ($length > $max_line_length) {
2603 my $msg_type = "LONG_LINE";
2604
2605 # Check the allowed long line types first
2606
2607 # logging functions that end in a string that starts
2608 # before $max_line_length
2609 if ($line =~ /^\+\s*$logFunctions\s*\(\s*(?:(?:KERN_\S+\s*|[^"]*))?($String\s*(?:|,|\)\s*;)\s*)$/ &&
2610 length(expand_tabs(substr($line, 1, length($line) - length($1) - 1))) <= $max_line_length) {
2611 $msg_type = "";
2612
2613 # lines with only strings (w/ possible termination)
2614 # #defines with only strings
2615 } elsif ($line =~ /^\+\s*$String\s*(?:\s*|,|\)\s*;)\s*$/ ||
2616 $line =~ /^\+\s*#\s*define\s+\w+\s+$String$/) {
2617 $msg_type = "";
2618
2619 # Otherwise set the alternate message types
2620
2621 # a comment starts before $max_line_length
2622 } elsif ($line =~ /($;[\s$;]*)$/ &&
2623 length(expand_tabs(substr($line, 1, length($line) - length($1) - 1))) <= $max_line_length) {
2624 $msg_type = "LONG_LINE_COMMENT"
2625
2626 # a quoted string starts before $max_line_length
2627 } elsif ($sline =~ /\s*($String(?:\s*(?:\\|,\s*|\)\s*;\s*))?)$/ &&
2628 length(expand_tabs(substr($line, 1, length($line) - length($1) - 1))) <= $max_line_length) {
2629 $msg_type = "LONG_LINE_STRING"
2630 }
2631
2632 if ($msg_type ne "" &&
2633 (show_type("LONG_LINE") || show_type($msg_type))) {
2634 WARN($msg_type,
2635 "line over $max_line_length characters\n" . $herecurr);
2636 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002637 }
2638
Andy Whitcroft8905a672007-11-28 16:21:06 -08002639# check for adding lines without a newline.
2640 if ($line =~ /^\+/ && defined $lines[$linenr] && $lines[$linenr] =~ /^\\ No newline at end of file/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07002641 WARN("MISSING_EOF_NEWLINE",
2642 "adding a line without newline at end of file\n" . $herecurr);
Andy Whitcroft8905a672007-11-28 16:21:06 -08002643 }
2644
Mike Frysinger42e41c52009-09-21 17:04:40 -07002645# Blackfin: use hi/lo macros
2646 if ($realfile =~ m@arch/blackfin/.*\.S$@) {
2647 if ($line =~ /\.[lL][[:space:]]*=.*&[[:space:]]*0x[fF][fF][fF][fF]/) {
2648 my $herevet = "$here\n" . cat_vet($line) . "\n";
Joe Perches000d1cc12011-07-25 17:13:25 -07002649 ERROR("LO_MACRO",
2650 "use the LO() macro, not (... & 0xFFFF)\n" . $herevet);
Mike Frysinger42e41c52009-09-21 17:04:40 -07002651 }
2652 if ($line =~ /\.[hH][[:space:]]*=.*>>[[:space:]]*16/) {
2653 my $herevet = "$here\n" . cat_vet($line) . "\n";
Joe Perches000d1cc12011-07-25 17:13:25 -07002654 ERROR("HI_MACRO",
2655 "use the HI() macro, not (... >> 16)\n" . $herevet);
Mike Frysinger42e41c52009-09-21 17:04:40 -07002656 }
2657 }
2658
Andy Whitcroftb9ea10d2008-10-15 22:02:24 -07002659# check we are in a valid source file C or perl if not then ignore this hunk
Geert Uytterhoevende4c9242014-10-13 15:51:46 -07002660 next if ($realfile !~ /\.(h|c|pl|dtsi|dts)$/);
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002661
2662# at the beginning of a line any tabs must come first and anything
2663# more than 8 must use tabs.
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002664 if ($rawline =~ /^\+\s* \t\s*\S/ ||
2665 $rawline =~ /^\+\s* \s*/) {
2666 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
Andy Whitcroftd2c0a232010-10-26 14:23:12 -07002667 $rpt_cleaners = 1;
Joe Perches3705ce52013-07-03 15:05:31 -07002668 if (ERROR("CODE_INDENT",
2669 "code indent should use tabs where possible\n" . $herevet) &&
2670 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07002671 $fixed[$fixlinenr] =~ s/^\+([ \t]+)/"\+" . tabify($1)/e;
Joe Perches3705ce52013-07-03 15:05:31 -07002672 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07002673 }
2674
Alberto Panizzo08e44362010-03-05 13:43:54 -08002675# check for space before tabs.
2676 if ($rawline =~ /^\+/ && $rawline =~ / \t/) {
2677 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
Joe Perches3705ce52013-07-03 15:05:31 -07002678 if (WARN("SPACE_BEFORE_TAB",
2679 "please, no space before tabs\n" . $herevet) &&
2680 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07002681 while ($fixed[$fixlinenr] =~
Joe Perchesd2207cc2014-10-13 15:51:53 -07002682 s/(^\+.*) {8,8}\t/$1\t\t/) {}
Joe Perches194f66f2014-08-06 16:11:03 -07002683 while ($fixed[$fixlinenr] =~
Joe Perchesc76f4cb2014-01-23 15:54:46 -08002684 s/(^\+.*) +\t/$1\t/) {}
Joe Perches3705ce52013-07-03 15:05:31 -07002685 }
Alberto Panizzo08e44362010-03-05 13:43:54 -08002686 }
2687
Joe Perchesd1fe9c02012-03-23 15:02:16 -07002688# check for && or || at the start of a line
2689 if ($rawline =~ /^\+\s*(&&|\|\|)/) {
2690 CHK("LOGICAL_CONTINUATIONS",
2691 "Logical continuations should be on the previous line\n" . $hereprev);
2692 }
2693
2694# check multi-line statement indentation matches previous line
2695 if ($^V && $^V ge 5.10.0 &&
Joe Perches91cb5192014-04-03 14:49:32 -07002696 $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 -07002697 $prevline =~ /^\+(\t*)(.*)$/;
2698 my $oldindent = $1;
2699 my $rest = $2;
2700
2701 my $pos = pos_last_openparen($rest);
2702 if ($pos >= 0) {
Joe Perchesb34a26f2012-07-30 14:41:16 -07002703 $line =~ /^(\+| )([ \t]*)/;
2704 my $newindent = $2;
Joe Perchesd1fe9c02012-03-23 15:02:16 -07002705
2706 my $goodtabindent = $oldindent .
2707 "\t" x ($pos / 8) .
2708 " " x ($pos % 8);
2709 my $goodspaceindent = $oldindent . " " x $pos;
2710
2711 if ($newindent ne $goodtabindent &&
2712 $newindent ne $goodspaceindent) {
Joe Perches3705ce52013-07-03 15:05:31 -07002713
2714 if (CHK("PARENTHESIS_ALIGNMENT",
2715 "Alignment should match open parenthesis\n" . $hereprev) &&
2716 $fix && $line =~ /^\+/) {
Joe Perches194f66f2014-08-06 16:11:03 -07002717 $fixed[$fixlinenr] =~
Joe Perches3705ce52013-07-03 15:05:31 -07002718 s/^\+[ \t]*/\+$goodtabindent/;
2719 }
Joe Perchesd1fe9c02012-03-23 15:02:16 -07002720 }
2721 }
2722 }
2723
Joe Perches6ab3a972015-04-16 12:44:05 -07002724# check for space after cast like "(int) foo" or "(struct foo) bar"
2725# avoid checking a few false positives:
2726# "sizeof(<type>)" or "__alignof__(<type>)"
2727# function pointer declarations like "(*foo)(int) = bar;"
2728# structure definitions like "(struct foo) { 0 };"
2729# multiline macros that define functions
2730# known attributes or the __attribute__ keyword
2731 if ($line =~ /^\+(.*)\(\s*$Type\s*\)([ \t]++)((?![={]|\\$|$Attribute|__attribute__))/ &&
2732 (!defined($1) || $1 !~ /\b(?:sizeof|__alignof__)\s*$/)) {
Joe Perches3705ce52013-07-03 15:05:31 -07002733 if (CHK("SPACING",
Joe Perchesf27c95d2014-08-06 16:10:52 -07002734 "No space is necessary after a cast\n" . $herecurr) &&
Joe Perches3705ce52013-07-03 15:05:31 -07002735 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07002736 $fixed[$fixlinenr] =~
Joe Perchesf27c95d2014-08-06 16:10:52 -07002737 s/(\(\s*$Type\s*\))[ \t]+/$1/;
Joe Perches3705ce52013-07-03 15:05:31 -07002738 }
Joe Perchesaad4f612012-03-23 15:02:19 -07002739 }
2740
Joe Perches05880602012-10-04 17:13:35 -07002741 if ($realfile =~ m@^(drivers/net/|net/)@ &&
Joe Perchesfdb4bcd2013-07-03 15:05:23 -07002742 $prevrawline =~ /^\+[ \t]*\/\*[ \t]*$/ &&
Joe Perches85ad9782014-04-03 14:49:20 -07002743 $rawline =~ /^\+[ \t]*\*/ &&
2744 $realline > 2) {
Joe Perches05880602012-10-04 17:13:35 -07002745 WARN("NETWORKING_BLOCK_COMMENT_STYLE",
2746 "networking block comments don't use an empty /* line, use /* Comment...\n" . $hereprev);
2747 }
2748
2749 if ($realfile =~ m@^(drivers/net/|net/)@ &&
Joe Perchesa605e322013-07-03 15:05:24 -07002750 $prevrawline =~ /^\+[ \t]*\/\*/ && #starting /*
2751 $prevrawline !~ /\*\/[ \t]*$/ && #no trailing */
Joe Perches61135e92013-09-11 14:23:59 -07002752 $rawline =~ /^\+/ && #line is new
Joe Perchesa605e322013-07-03 15:05:24 -07002753 $rawline !~ /^\+[ \t]*\*/) { #no leading *
2754 WARN("NETWORKING_BLOCK_COMMENT_STYLE",
2755 "networking block comments start with * on subsequent lines\n" . $hereprev);
2756 }
2757
2758 if ($realfile =~ m@^(drivers/net/|net/)@ &&
Joe Perchesc24f9f12012-11-08 15:53:29 -08002759 $rawline !~ m@^\+[ \t]*\*/[ \t]*$@ && #trailing */
2760 $rawline !~ m@^\+.*/\*.*\*/[ \t]*$@ && #inline /*...*/
2761 $rawline !~ m@^\+.*\*{2,}/[ \t]*$@ && #trailing **/
2762 $rawline =~ m@^\+[ \t]*.+\*\/[ \t]*$@) { #non blank */
Joe Perches05880602012-10-04 17:13:35 -07002763 WARN("NETWORKING_BLOCK_COMMENT_STYLE",
2764 "networking block comments put the trailing */ on a separate line\n" . $herecurr);
2765 }
2766
Joe Perches7f619192014-08-06 16:10:39 -07002767# check for missing blank lines after struct/union declarations
2768# with exceptions for various attributes and macros
2769 if ($prevline =~ /^[\+ ]};?\s*$/ &&
2770 $line =~ /^\+/ &&
2771 !($line =~ /^\+\s*$/ ||
2772 $line =~ /^\+\s*EXPORT_SYMBOL/ ||
2773 $line =~ /^\+\s*MODULE_/i ||
2774 $line =~ /^\+\s*\#\s*(?:end|elif|else)/ ||
2775 $line =~ /^\+[a-z_]*init/ ||
2776 $line =~ /^\+\s*(?:static\s+)?[A-Z_]*ATTR/ ||
2777 $line =~ /^\+\s*DECLARE/ ||
2778 $line =~ /^\+\s*__setup/)) {
Joe Perchesd752fcc2014-08-06 16:11:05 -07002779 if (CHK("LINE_SPACING",
2780 "Please use a blank line after function/struct/union/enum declarations\n" . $hereprev) &&
2781 $fix) {
Joe Perchesf2d7e4d2014-08-06 16:11:07 -07002782 fix_insert_line($fixlinenr, "\+");
Joe Perchesd752fcc2014-08-06 16:11:05 -07002783 }
Joe Perches7f619192014-08-06 16:10:39 -07002784 }
2785
Joe Perches365dd4e2014-08-06 16:10:42 -07002786# check for multiple consecutive blank lines
2787 if ($prevline =~ /^[\+ ]\s*$/ &&
2788 $line =~ /^\+\s*$/ &&
2789 $last_blank_line != ($linenr - 1)) {
Joe Perchesd752fcc2014-08-06 16:11:05 -07002790 if (CHK("LINE_SPACING",
2791 "Please don't use multiple blank lines\n" . $hereprev) &&
2792 $fix) {
Joe Perchesf2d7e4d2014-08-06 16:11:07 -07002793 fix_delete_line($fixlinenr, $rawline);
Joe Perchesd752fcc2014-08-06 16:11:05 -07002794 }
2795
Joe Perches365dd4e2014-08-06 16:10:42 -07002796 $last_blank_line = $linenr;
2797 }
2798
Joe Perches3b617e32014-04-03 14:49:28 -07002799# check for missing blank lines after declarations
Joe Perches3f7bac02014-06-04 16:12:04 -07002800 if ($sline =~ /^\+\s+\S/ && #Not at char 1
2801 # actual declarations
2802 ($prevline =~ /^\+\s+$Declare\s*$Ident\s*[=,;:\[]/ ||
Joe Perches5a4e1fd2014-08-06 16:10:33 -07002803 # function pointer declarations
2804 $prevline =~ /^\+\s+$Declare\s*\(\s*\*\s*$Ident\s*\)\s*[=,;:\[\(]/ ||
Joe Perches3f7bac02014-06-04 16:12:04 -07002805 # foo bar; where foo is some local typedef or #define
2806 $prevline =~ /^\+\s+$Ident(?:\s+|\s*\*\s*)$Ident\s*[=,;\[]/ ||
2807 # known declaration macros
2808 $prevline =~ /^\+\s+$declaration_macros/) &&
2809 # for "else if" which can look like "$Ident $Ident"
2810 !($prevline =~ /^\+\s+$c90_Keywords\b/ ||
2811 # other possible extensions of declaration lines
2812 $prevline =~ /(?:$Compare|$Assignment|$Operators)\s*$/ ||
2813 # not starting a section or a macro "\" extended line
2814 $prevline =~ /(?:\{\s*|\\)$/) &&
2815 # looks like a declaration
2816 !($sline =~ /^\+\s+$Declare\s*$Ident\s*[=,;:\[]/ ||
Joe Perches5a4e1fd2014-08-06 16:10:33 -07002817 # function pointer declarations
2818 $sline =~ /^\+\s+$Declare\s*\(\s*\*\s*$Ident\s*\)\s*[=,;:\[\(]/ ||
Joe Perches3f7bac02014-06-04 16:12:04 -07002819 # foo bar; where foo is some local typedef or #define
2820 $sline =~ /^\+\s+$Ident(?:\s+|\s*\*\s*)$Ident\s*[=,;\[]/ ||
2821 # known declaration macros
2822 $sline =~ /^\+\s+$declaration_macros/ ||
2823 # start of struct or union or enum
Joe Perches3b617e32014-04-03 14:49:28 -07002824 $sline =~ /^\+\s+(?:union|struct|enum|typedef)\b/ ||
Joe Perches3f7bac02014-06-04 16:12:04 -07002825 # start or end of block or continuation of declaration
2826 $sline =~ /^\+\s+(?:$|[\{\}\.\#\"\?\:\(\[])/ ||
2827 # bitfield continuation
2828 $sline =~ /^\+\s+$Ident\s*:\s*\d+\s*[,;]/ ||
2829 # other possible extensions of declaration lines
2830 $sline =~ /^\+\s+\(?\s*(?:$Compare|$Assignment|$Operators)/) &&
2831 # indentation of previous and current line are the same
2832 (($prevline =~ /\+(\s+)\S/) && $sline =~ /^\+$1\S/)) {
Joe Perchesd752fcc2014-08-06 16:11:05 -07002833 if (WARN("LINE_SPACING",
2834 "Missing a blank line after declarations\n" . $hereprev) &&
2835 $fix) {
Joe Perchesf2d7e4d2014-08-06 16:11:07 -07002836 fix_insert_line($fixlinenr, "\+");
Joe Perchesd752fcc2014-08-06 16:11:05 -07002837 }
Joe Perches3b617e32014-04-03 14:49:28 -07002838 }
2839
Raffaele Recalcati5f7ddae2010-08-09 17:20:59 -07002840# check for spaces at the beginning of a line.
Andy Whitcroft6b4c5be2010-10-26 14:23:11 -07002841# Exceptions:
2842# 1) within comments
2843# 2) indented preprocessor commands
2844# 3) hanging labels
Joe Perches3705ce52013-07-03 15:05:31 -07002845 if ($rawline =~ /^\+ / && $line !~ /^\+ *(?:$;|#|$Ident:)/) {
Raffaele Recalcati5f7ddae2010-08-09 17:20:59 -07002846 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
Joe Perches3705ce52013-07-03 15:05:31 -07002847 if (WARN("LEADING_SPACE",
2848 "please, no spaces at the start of a line\n" . $herevet) &&
2849 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07002850 $fixed[$fixlinenr] =~ s/^\+([ \t]+)/"\+" . tabify($1)/e;
Joe Perches3705ce52013-07-03 15:05:31 -07002851 }
Raffaele Recalcati5f7ddae2010-08-09 17:20:59 -07002852 }
2853
Andy Whitcroftb9ea10d2008-10-15 22:02:24 -07002854# check we are in a valid C source file if not then ignore this hunk
2855 next if ($realfile !~ /\.(h|c)$/);
2856
Joe Perches032a4c02014-08-06 16:10:29 -07002857# check indentation of any line with a bare else
Joe Perches840080a2014-10-13 15:51:59 -07002858# (but not if it is a multiple line "if (foo) return bar; else return baz;")
Joe Perches032a4c02014-08-06 16:10:29 -07002859# if the previous line is a break or return and is indented 1 tab more...
2860 if ($sline =~ /^\+([\t]+)(?:}[ \t]*)?else(?:[ \t]*{)?\s*$/) {
2861 my $tabs = length($1) + 1;
Joe Perches840080a2014-10-13 15:51:59 -07002862 if ($prevline =~ /^\+\t{$tabs,$tabs}break\b/ ||
2863 ($prevline =~ /^\+\t{$tabs,$tabs}return\b/ &&
2864 defined $lines[$linenr] &&
2865 $lines[$linenr] !~ /^[ \+]\t{$tabs,$tabs}return/)) {
Joe Perches032a4c02014-08-06 16:10:29 -07002866 WARN("UNNECESSARY_ELSE",
2867 "else is not generally useful after a break or return\n" . $hereprev);
2868 }
2869 }
2870
Joe Perchesc00df192014-08-06 16:11:01 -07002871# check indentation of a line with a break;
2872# if the previous line is a goto or return and is indented the same # of tabs
2873 if ($sline =~ /^\+([\t]+)break\s*;\s*$/) {
2874 my $tabs = $1;
2875 if ($prevline =~ /^\+$tabs(?:goto|return)\b/) {
2876 WARN("UNNECESSARY_BREAK",
2877 "break is not useful after a goto or return\n" . $hereprev);
2878 }
2879 }
2880
Kees Cook1ba8dfd2012-12-17 16:01:48 -08002881# discourage the addition of CONFIG_EXPERIMENTAL in #if(def).
2882 if ($line =~ /^\+\s*\#\s*if.*\bCONFIG_EXPERIMENTAL\b/) {
2883 WARN("CONFIG_EXPERIMENTAL",
2884 "Use of CONFIG_EXPERIMENTAL is deprecated. For alternatives, see https://lkml.org/lkml/2012/10/23/580\n");
2885 }
2886
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002887# check for RCS/CVS revision markers
Andy Whitcroftcf655042008-03-04 14:28:20 -08002888 if ($rawline =~ /^\+.*\$(Revision|Log|Id)(?:\$|)/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07002889 WARN("CVS_KEYWORD",
2890 "CVS style keyword markers, these will _not_ be updated\n". $herecurr);
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002891 }
Andy Whitcroft22f2a2e2007-08-10 13:01:03 -07002892
Mike Frysinger42e41c52009-09-21 17:04:40 -07002893# Blackfin: don't use __builtin_bfin_[cs]sync
2894 if ($line =~ /__builtin_bfin_csync/) {
2895 my $herevet = "$here\n" . cat_vet($line) . "\n";
Joe Perches000d1cc12011-07-25 17:13:25 -07002896 ERROR("CSYNC",
2897 "use the CSYNC() macro in asm/blackfin.h\n" . $herevet);
Mike Frysinger42e41c52009-09-21 17:04:40 -07002898 }
2899 if ($line =~ /__builtin_bfin_ssync/) {
2900 my $herevet = "$here\n" . cat_vet($line) . "\n";
Joe Perches000d1cc12011-07-25 17:13:25 -07002901 ERROR("SSYNC",
2902 "use the SSYNC() macro in asm/blackfin.h\n" . $herevet);
Mike Frysinger42e41c52009-09-21 17:04:40 -07002903 }
2904
Joe Perches56e77d72013-02-21 16:44:14 -08002905# check for old HOTPLUG __dev<foo> section markings
2906 if ($line =~ /\b(__dev(init|exit)(data|const|))\b/) {
2907 WARN("HOTPLUG_SECTION",
2908 "Using $1 is unnecessary\n" . $herecurr);
2909 }
2910
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07002911# Check for potential 'bare' types
Andy Whitcroft2b474a12009-10-26 16:50:16 -07002912 my ($stat, $cond, $line_nr_next, $remain_next, $off_next,
2913 $realline_next);
Andy Whitcroft3e469cd2012-01-10 15:10:01 -08002914#print "LINE<$line>\n";
2915 if ($linenr >= $suppress_statement &&
Joe Perches1b5539b2013-09-11 14:24:03 -07002916 $realcnt && $sline =~ /.\s*\S/) {
Andy Whitcroft170d3a22008-10-15 22:02:30 -07002917 ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
Andy Whitcroftf5fe35d2008-07-23 21:29:03 -07002918 ctx_statement_block($linenr, $realcnt, 0);
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07002919 $stat =~ s/\n./\n /g;
2920 $cond =~ s/\n./\n /g;
2921
Andy Whitcroft3e469cd2012-01-10 15:10:01 -08002922#print "linenr<$linenr> <$stat>\n";
2923 # If this statement has no statement boundaries within
2924 # it there is no point in retrying a statement scan
2925 # until we hit end of it.
2926 my $frag = $stat; $frag =~ s/;+\s*$//;
2927 if ($frag !~ /(?:{|;)/) {
2928#print "skip<$line_nr_next>\n";
2929 $suppress_statement = $line_nr_next;
2930 }
Andy Whitcroftf74bd192012-01-10 15:09:54 -08002931
Andy Whitcroft2b474a12009-10-26 16:50:16 -07002932 # Find the real next line.
2933 $realline_next = $line_nr_next;
2934 if (defined $realline_next &&
2935 (!defined $lines[$realline_next - 1] ||
2936 substr($lines[$realline_next - 1], $off_next) =~ /^\s*$/)) {
2937 $realline_next++;
2938 }
2939
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07002940 my $s = $stat;
2941 $s =~ s/{.*$//s;
Andy Whitcroftcf655042008-03-04 14:28:20 -08002942
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002943 # Ignore goto labels.
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07002944 if ($s =~ /$Ident:\*$/s) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002945
2946 # Ignore functions being called
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07002947 } elsif ($s =~ /^.\s*$Ident\s*\(/s) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002948
Andy Whitcroft463f2862009-09-21 17:04:34 -07002949 } elsif ($s =~ /^.\s*else\b/s) {
2950
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07002951 # declarations always start with types
Andy Whitcroftd2506582008-07-23 21:29:09 -07002952 } 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 -07002953 my $type = $1;
2954 $type =~ s/\s+/ /g;
2955 possible($type, "A:" . $s);
2956
Andy Whitcroft8905a672007-11-28 16:21:06 -08002957 # definitions in global scope can only start with types
Andy Whitcrofta6a840622008-10-15 22:02:30 -07002958 } elsif ($s =~ /^.(?:$Storage\s+)?(?:$Inline\s+)?(?:const\s+)?($Ident)\b\s*(?!:)/s) {
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07002959 possible($1, "B:" . $s);
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002960 }
Andy Whitcroft8905a672007-11-28 16:21:06 -08002961
2962 # any (foo ... *) is a pointer cast, and foo is a type
Andy Whitcroft65863862009-01-06 14:41:21 -08002963 while ($s =~ /\(($Ident)(?:\s+$Sparse)*[\s\*]+\s*\)/sg) {
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07002964 possible($1, "C:" . $s);
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07002965 }
Andy Whitcroft8905a672007-11-28 16:21:06 -08002966
2967 # Check for any sort of function declaration.
2968 # int foo(something bar, other baz);
2969 # void (*store_gdt)(x86_descr_ptr *);
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07002970 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 -08002971 my ($name_len) = length($1);
Andy Whitcroft8905a672007-11-28 16:21:06 -08002972
Andy Whitcroftcf655042008-03-04 14:28:20 -08002973 my $ctx = $s;
Andy Whitcroft773647a2008-03-28 14:15:58 -07002974 substr($ctx, 0, $name_len + 1, '');
Andy Whitcroft8905a672007-11-28 16:21:06 -08002975 $ctx =~ s/\)[^\)]*$//;
Andy Whitcroftcf655042008-03-04 14:28:20 -08002976
Andy Whitcroft8905a672007-11-28 16:21:06 -08002977 for my $arg (split(/\s*,\s*/, $ctx)) {
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07002978 if ($arg =~ /^(?:const\s+)?($Ident)(?:\s+$Sparse)*\s*\**\s*(:?\b$Ident)?$/s || $arg =~ /^($Ident)$/s) {
Andy Whitcroft8905a672007-11-28 16:21:06 -08002979
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07002980 possible($1, "D:" . $s);
Andy Whitcroft8905a672007-11-28 16:21:06 -08002981 }
2982 }
2983 }
2984
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07002985 }
2986
Andy Whitcroft653d4872007-06-23 17:16:34 -07002987#
2988# Checks which may be anchored in the context.
2989#
2990
2991# Check for switch () and associated case and default
2992# statements should be at the same indent.
Andy Whitcroft00df3442007-06-08 13:47:06 -07002993 if ($line=~/\bswitch\s*\(.*\)/) {
2994 my $err = '';
2995 my $sep = '';
2996 my @ctx = ctx_block_outer($linenr, $realcnt);
2997 shift(@ctx);
2998 for my $ctx (@ctx) {
2999 my ($clen, $cindent) = line_stats($ctx);
3000 if ($ctx =~ /^\+\s*(case\s+|default:)/ &&
3001 $indent != $cindent) {
3002 $err .= "$sep$ctx\n";
3003 $sep = '';
3004 } else {
3005 $sep = "[...]\n";
3006 }
3007 }
3008 if ($err ne '') {
Joe Perches000d1cc12011-07-25 17:13:25 -07003009 ERROR("SWITCH_CASE_INDENT_LEVEL",
3010 "switch and case should be at the same indent\n$hereline$err");
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07003011 }
3012 }
3013
3014# if/while/etc brace do not go on next line, unless defining a do while loop,
3015# or if that brace on the next line is for something else
Joe Perches0fe3dc22014-08-06 16:11:16 -07003016 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 -07003017 my $pre_ctx = "$1$2";
3018
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07003019 my ($level, @ctx) = ctx_statement_level($linenr, $realcnt, 0);
Joe Perches8eef05d2012-02-03 15:20:39 -08003020
3021 if ($line =~ /^\+\t{6,}/) {
3022 WARN("DEEP_INDENTATION",
3023 "Too many leading tabs - consider code refactoring\n" . $herecurr);
3024 }
3025
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07003026 my $ctx_cnt = $realcnt - $#ctx - 1;
3027 my $ctx = join("\n", @ctx);
3028
Andy Whitcroft548596d2008-07-23 21:29:01 -07003029 my $ctx_ln = $linenr;
3030 my $ctx_skip = $realcnt;
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07003031
Andy Whitcroft548596d2008-07-23 21:29:01 -07003032 while ($ctx_skip > $ctx_cnt || ($ctx_skip == $ctx_cnt &&
3033 defined $lines[$ctx_ln - 1] &&
3034 $lines[$ctx_ln - 1] =~ /^-/)) {
3035 ##print "SKIP<$ctx_skip> CNT<$ctx_cnt>\n";
3036 $ctx_skip-- if (!defined $lines[$ctx_ln - 1] || $lines[$ctx_ln - 1] !~ /^-/);
Andy Whitcroft773647a2008-03-28 14:15:58 -07003037 $ctx_ln++;
3038 }
Andy Whitcroft548596d2008-07-23 21:29:01 -07003039
Andy Whitcroft53210162008-07-23 21:29:03 -07003040 #print "realcnt<$realcnt> ctx_cnt<$ctx_cnt>\n";
3041 #print "pre<$pre_ctx>\nline<$line>\nctx<$ctx>\nnext<$lines[$ctx_ln - 1]>\n";
Andy Whitcroft773647a2008-03-28 14:15:58 -07003042
Joe Perchesd752fcc2014-08-06 16:11:05 -07003043 if ($ctx !~ /{\s*/ && defined($lines[$ctx_ln - 1]) && $lines[$ctx_ln - 1] =~ /^\+\s*{/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003044 ERROR("OPEN_BRACE",
3045 "that open brace { should be on the previous line\n" .
Andy Whitcroft01464f32010-10-26 14:23:19 -07003046 "$here\n$ctx\n$rawlines[$ctx_ln - 1]\n");
Andy Whitcroft00df3442007-06-08 13:47:06 -07003047 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07003048 if ($level == 0 && $pre_ctx !~ /}\s*while\s*\($/ &&
3049 $ctx =~ /\)\s*\;\s*$/ &&
3050 defined $lines[$ctx_ln - 1])
3051 {
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07003052 my ($nlength, $nindent) = line_stats($lines[$ctx_ln - 1]);
3053 if ($nindent > $indent) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003054 WARN("TRAILING_SEMICOLON",
3055 "trailing semicolon indicates no statements, indent implies otherwise\n" .
Andy Whitcroft01464f32010-10-26 14:23:19 -07003056 "$here\n$ctx\n$rawlines[$ctx_ln - 1]\n");
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07003057 }
3058 }
Andy Whitcroft00df3442007-06-08 13:47:06 -07003059 }
3060
Andy Whitcroft4d001e42008-10-15 22:02:21 -07003061# Check relative indent for conditionals and blocks.
Joe Perches0fe3dc22014-08-06 16:11:16 -07003062 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 -08003063 ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
3064 ctx_statement_block($linenr, $realcnt, 0)
3065 if (!defined $stat);
Andy Whitcroft4d001e42008-10-15 22:02:21 -07003066 my ($s, $c) = ($stat, $cond);
3067
3068 substr($s, 0, length($c), '');
3069
3070 # Make sure we remove the line prefixes as we have
3071 # none on the first line, and are going to readd them
3072 # where necessary.
3073 $s =~ s/\n./\n/gs;
3074
3075 # Find out how long the conditional actually is.
Andy Whitcroft6f779c12008-10-15 22:02:27 -07003076 my @newlines = ($c =~ /\n/gs);
3077 my $cond_lines = 1 + $#newlines;
Andy Whitcroft4d001e42008-10-15 22:02:21 -07003078
3079 # We want to check the first line inside the block
3080 # starting at the end of the conditional, so remove:
3081 # 1) any blank line termination
3082 # 2) any opening brace { on end of the line
3083 # 3) any do (...) {
3084 my $continuation = 0;
3085 my $check = 0;
3086 $s =~ s/^.*\bdo\b//;
3087 $s =~ s/^\s*{//;
3088 if ($s =~ s/^\s*\\//) {
3089 $continuation = 1;
3090 }
Andy Whitcroft9bd49ef2008-10-15 22:02:22 -07003091 if ($s =~ s/^\s*?\n//) {
Andy Whitcroft4d001e42008-10-15 22:02:21 -07003092 $check = 1;
3093 $cond_lines++;
3094 }
3095
3096 # Also ignore a loop construct at the end of a
3097 # preprocessor statement.
3098 if (($prevline =~ /^.\s*#\s*define\s/ ||
3099 $prevline =~ /\\\s*$/) && $continuation == 0) {
3100 $check = 0;
3101 }
3102
Andy Whitcroft9bd49ef2008-10-15 22:02:22 -07003103 my $cond_ptr = -1;
Andy Whitcroft740504c2008-10-15 22:02:35 -07003104 $continuation = 0;
Andy Whitcroft9bd49ef2008-10-15 22:02:22 -07003105 while ($cond_ptr != $cond_lines) {
3106 $cond_ptr = $cond_lines;
Andy Whitcroft4d001e42008-10-15 22:02:21 -07003107
Andy Whitcroftf16fa282008-10-15 22:02:32 -07003108 # If we see an #else/#elif then the code
3109 # is not linear.
3110 if ($s =~ /^\s*\#\s*(?:else|elif)/) {
3111 $check = 0;
3112 }
3113
Andy Whitcroft9bd49ef2008-10-15 22:02:22 -07003114 # Ignore:
3115 # 1) blank lines, they should be at 0,
3116 # 2) preprocessor lines, and
3117 # 3) labels.
Andy Whitcroft740504c2008-10-15 22:02:35 -07003118 if ($continuation ||
3119 $s =~ /^\s*?\n/ ||
Andy Whitcroft9bd49ef2008-10-15 22:02:22 -07003120 $s =~ /^\s*#\s*?/ ||
3121 $s =~ /^\s*$Ident\s*:/) {
Andy Whitcroft740504c2008-10-15 22:02:35 -07003122 $continuation = ($s =~ /^.*?\\\n/) ? 1 : 0;
Andy Whitcroft30dad6e2009-09-21 17:04:36 -07003123 if ($s =~ s/^.*?\n//) {
3124 $cond_lines++;
3125 }
Andy Whitcroft9bd49ef2008-10-15 22:02:22 -07003126 }
Andy Whitcroft4d001e42008-10-15 22:02:21 -07003127 }
3128
3129 my (undef, $sindent) = line_stats("+" . $s);
3130 my $stat_real = raw_line($linenr, $cond_lines);
3131
3132 # Check if either of these lines are modified, else
3133 # this is not this patch's fault.
3134 if (!defined($stat_real) ||
3135 $stat !~ /^\+/ && $stat_real !~ /^\+/) {
3136 $check = 0;
3137 }
3138 if (defined($stat_real) && $cond_lines > 1) {
3139 $stat_real = "[...]\n$stat_real";
3140 }
3141
Andy Whitcroft9bd49ef2008-10-15 22:02:22 -07003142 #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 -07003143
3144 if ($check && (($sindent % 8) != 0 ||
3145 ($sindent <= $indent && $s ne ''))) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003146 WARN("SUSPECT_CODE_INDENT",
3147 "suspect code indent for conditional statements ($indent, $sindent)\n" . $herecurr . "$stat_real\n");
Andy Whitcroft4d001e42008-10-15 22:02:21 -07003148 }
3149 }
3150
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07003151 # Track the 'values' across context and added lines.
3152 my $opline = $line; $opline =~ s/^./ /;
Andy Whitcroft1f65f942008-07-23 21:29:10 -07003153 my ($curr_values, $curr_vars) =
3154 annotate_values($opline . "\n", $prev_values);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07003155 $curr_values = $prev_values . $curr_values;
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08003156 if ($dbg_values) {
3157 my $outline = $opline; $outline =~ s/\t/ /g;
Andy Whitcroftcf655042008-03-04 14:28:20 -08003158 print "$linenr > .$outline\n";
3159 print "$linenr > $curr_values\n";
Andy Whitcroft1f65f942008-07-23 21:29:10 -07003160 print "$linenr > $curr_vars\n";
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08003161 }
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07003162 $prev_values = substr($curr_values, -1);
3163
Andy Whitcroft00df3442007-06-08 13:47:06 -07003164#ignore lines not being added
Joe Perches3705ce52013-07-03 15:05:31 -07003165 next if ($line =~ /^[^\+]/);
Andy Whitcroft00df3442007-06-08 13:47:06 -07003166
Andy Whitcroft653d4872007-06-23 17:16:34 -07003167# TEST: allow direct testing of the type matcher.
Andy Whitcroft7429c692008-07-23 21:29:06 -07003168 if ($dbg_type) {
3169 if ($line =~ /^.\s*$Declare\s*$/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003170 ERROR("TEST_TYPE",
3171 "TEST: is type\n" . $herecurr);
Andy Whitcroft7429c692008-07-23 21:29:06 -07003172 } elsif ($dbg_type > 1 && $line =~ /^.+($Declare)/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003173 ERROR("TEST_NOT_TYPE",
3174 "TEST: is not type ($1 is)\n". $herecurr);
Andy Whitcroft7429c692008-07-23 21:29:06 -07003175 }
Andy Whitcroft653d4872007-06-23 17:16:34 -07003176 next;
3177 }
Andy Whitcrofta1ef2772008-10-15 22:02:17 -07003178# TEST: allow direct testing of the attribute matcher.
3179 if ($dbg_attr) {
Andy Whitcroft9360b0e2009-02-27 14:03:08 -08003180 if ($line =~ /^.\s*$Modifier\s*$/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003181 ERROR("TEST_ATTR",
3182 "TEST: is attr\n" . $herecurr);
Andy Whitcroft9360b0e2009-02-27 14:03:08 -08003183 } elsif ($dbg_attr > 1 && $line =~ /^.+($Modifier)/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003184 ERROR("TEST_NOT_ATTR",
3185 "TEST: is not attr ($1 is)\n". $herecurr);
Andy Whitcrofta1ef2772008-10-15 22:02:17 -07003186 }
3187 next;
3188 }
Andy Whitcroft653d4872007-06-23 17:16:34 -07003189
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07003190# check for initialisation to aggregates open brace on the next line
Andy Whitcroft99423c22009-10-26 16:50:15 -07003191 if ($line =~ /^.\s*{/ &&
3192 $prevline =~ /(?:^|[^=])=\s*$/) {
Joe Perchesd752fcc2014-08-06 16:11:05 -07003193 if (ERROR("OPEN_BRACE",
3194 "that open brace { should be on the previous line\n" . $hereprev) &&
Joe Perchesf2d7e4d2014-08-06 16:11:07 -07003195 $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
3196 fix_delete_line($fixlinenr - 1, $prevrawline);
3197 fix_delete_line($fixlinenr, $rawline);
Joe Perchesd752fcc2014-08-06 16:11:05 -07003198 my $fixedline = $prevrawline;
3199 $fixedline =~ s/\s*=\s*$/ = {/;
Joe Perchesf2d7e4d2014-08-06 16:11:07 -07003200 fix_insert_line($fixlinenr, $fixedline);
Joe Perchesd752fcc2014-08-06 16:11:05 -07003201 $fixedline = $line;
3202 $fixedline =~ s/^(.\s*){\s*/$1/;
Joe Perchesf2d7e4d2014-08-06 16:11:07 -07003203 fix_insert_line($fixlinenr, $fixedline);
Joe Perchesd752fcc2014-08-06 16:11:05 -07003204 }
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07003205 }
3206
Andy Whitcroft653d4872007-06-23 17:16:34 -07003207#
3208# Checks which are anchored on the added line.
3209#
3210
3211# check for malformed paths in #include statements (uses RAW line)
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07003212 if ($rawline =~ m{^.\s*\#\s*include\s+[<"](.*)[">]}) {
Andy Whitcroft653d4872007-06-23 17:16:34 -07003213 my $path = $1;
3214 if ($path =~ m{//}) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003215 ERROR("MALFORMED_INCLUDE",
Joe Perches495e9d82012-12-20 15:05:37 -08003216 "malformed #include filename\n" . $herecurr);
3217 }
3218 if ($path =~ "^uapi/" && $realfile =~ m@\binclude/uapi/@) {
3219 ERROR("UAPI_INCLUDE",
3220 "No #include in ...include/uapi/... should use a uapi/ path prefix\n" . $herecurr);
Andy Whitcroft653d4872007-06-23 17:16:34 -07003221 }
Andy Whitcroft653d4872007-06-23 17:16:34 -07003222 }
Andy Whitcroft00df3442007-06-08 13:47:06 -07003223
3224# no C99 // comments
3225 if ($line =~ m{//}) {
Joe Perches3705ce52013-07-03 15:05:31 -07003226 if (ERROR("C99_COMMENTS",
3227 "do not use C99 // comments\n" . $herecurr) &&
3228 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07003229 my $line = $fixed[$fixlinenr];
Joe Perches3705ce52013-07-03 15:05:31 -07003230 if ($line =~ /\/\/(.*)$/) {
3231 my $comment = trim($1);
Joe Perches194f66f2014-08-06 16:11:03 -07003232 $fixed[$fixlinenr] =~ s@\/\/(.*)$@/\* $comment \*/@;
Joe Perches3705ce52013-07-03 15:05:31 -07003233 }
3234 }
Andy Whitcroft00df3442007-06-08 13:47:06 -07003235 }
3236 # Remove C99 comments.
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003237 $line =~ s@//.*@@;
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07003238 $opline =~ s@//.*@@;
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003239
Andy Whitcroft2b474a12009-10-26 16:50:16 -07003240# EXPORT_SYMBOL should immediately follow the thing it is exporting, consider
3241# the whole statement.
3242#print "APW <$lines[$realline_next - 1]>\n";
3243 if (defined $realline_next &&
3244 exists $lines[$realline_next - 1] &&
3245 !defined $suppress_export{$realline_next} &&
3246 ($lines[$realline_next - 1] =~ /EXPORT_SYMBOL.*\((.*)\)/ ||
3247 $lines[$realline_next - 1] =~ /EXPORT_UNUSED_SYMBOL.*\((.*)\)/)) {
Andy Whitcroft3cbf62d2010-10-26 14:23:18 -07003248 # Handle definitions which produce identifiers with
3249 # a prefix:
3250 # XXX(foo);
3251 # EXPORT_SYMBOL(something_foo);
Andy Whitcroft653d4872007-06-23 17:16:34 -07003252 my $name = $1;
Andy Whitcroft87a53872012-01-10 15:10:04 -08003253 if ($stat =~ /^(?:.\s*}\s*\n)?.([A-Z_]+)\s*\(\s*($Ident)/ &&
Andy Whitcroft3cbf62d2010-10-26 14:23:18 -07003254 $name =~ /^${Ident}_$2/) {
3255#print "FOO C name<$name>\n";
3256 $suppress_export{$realline_next} = 1;
3257
3258 } elsif ($stat !~ /(?:
Andy Whitcroft2b474a12009-10-26 16:50:16 -07003259 \n.}\s*$|
Andy Whitcroft48012052008-10-15 22:02:34 -07003260 ^.DEFINE_$Ident\(\Q$name\E\)|
3261 ^.DECLARE_$Ident\(\Q$name\E\)|
3262 ^.LIST_HEAD\(\Q$name\E\)|
Andy Whitcroft2b474a12009-10-26 16:50:16 -07003263 ^.(?:$Storage\s+)?$Type\s*\(\s*\*\s*\Q$name\E\s*\)\s*\(|
3264 \b\Q$name\E(?:\s+$Attribute)*\s*(?:;|=|\[|\()
Andy Whitcroft48012052008-10-15 22:02:34 -07003265 )/x) {
Andy Whitcroft2b474a12009-10-26 16:50:16 -07003266#print "FOO A<$lines[$realline_next - 1]> stat<$stat> name<$name>\n";
3267 $suppress_export{$realline_next} = 2;
3268 } else {
3269 $suppress_export{$realline_next} = 1;
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003270 }
3271 }
Andy Whitcroft2b474a12009-10-26 16:50:16 -07003272 if (!defined $suppress_export{$linenr} &&
3273 $prevline =~ /^.\s*$/ &&
3274 ($line =~ /EXPORT_SYMBOL.*\((.*)\)/ ||
3275 $line =~ /EXPORT_UNUSED_SYMBOL.*\((.*)\)/)) {
3276#print "FOO B <$lines[$linenr - 1]>\n";
3277 $suppress_export{$linenr} = 2;
3278 }
3279 if (defined $suppress_export{$linenr} &&
3280 $suppress_export{$linenr} == 2) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003281 WARN("EXPORT_SYMBOL",
3282 "EXPORT_SYMBOL(foo); should immediately follow its function/variable\n" . $herecurr);
Andy Whitcroft2b474a12009-10-26 16:50:16 -07003283 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003284
Joe Eloff5150bda2010-08-09 17:21:00 -07003285# check for global initialisers.
Joe Perches5129e872015-06-10 11:14:52 -07003286 if ($line =~ /^\+$Type\s*$Ident(?:\s+$Modifier)*\s*=\s*(?:0|NULL|false)\s*;/) {
Joe Perchesd5e616f2013-09-11 14:23:54 -07003287 if (ERROR("GLOBAL_INITIALISERS",
3288 "do not initialise globals to 0 or NULL\n" .
3289 $herecurr) &&
3290 $fix) {
Joe Perches5129e872015-06-10 11:14:52 -07003291 $fixed[$fixlinenr] =~ s/(^.$Type\s*$Ident(?:\s+$Modifier)*)\s*=\s*(0|NULL|false)\s*;/$1;/;
Joe Perchesd5e616f2013-09-11 14:23:54 -07003292 }
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07003293 }
Andy Whitcroft653d4872007-06-23 17:16:34 -07003294# check for static initialisers.
Joe Perchesd5e616f2013-09-11 14:23:54 -07003295 if ($line =~ /^\+.*\bstatic\s.*=\s*(0|NULL|false)\s*;/) {
3296 if (ERROR("INITIALISED_STATIC",
3297 "do not initialise statics to 0 or NULL\n" .
3298 $herecurr) &&
3299 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07003300 $fixed[$fixlinenr] =~ s/(\bstatic\s.*?)\s*=\s*(0|NULL|false)\s*;/$1;/;
Joe Perchesd5e616f2013-09-11 14:23:54 -07003301 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003302 }
3303
Joe Perches18130872014-08-06 16:11:22 -07003304# check for misordered declarations of char/short/int/long with signed/unsigned
3305 while ($sline =~ m{(\b$TypeMisordered\b)}g) {
3306 my $tmp = trim($1);
3307 WARN("MISORDERED_TYPE",
3308 "type '$tmp' should be specified in [[un]signed] [short|int|long|long long] order\n" . $herecurr);
3309 }
3310
Joe Perchescb710ec2010-10-26 14:23:20 -07003311# check for static const char * arrays.
3312 if ($line =~ /\bstatic\s+const\s+char\s*\*\s*(\w+)\s*\[\s*\]\s*=\s*/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003313 WARN("STATIC_CONST_CHAR_ARRAY",
3314 "static const char * array should probably be static const char * const\n" .
Joe Perchescb710ec2010-10-26 14:23:20 -07003315 $herecurr);
3316 }
3317
3318# check for static char foo[] = "bar" declarations.
3319 if ($line =~ /\bstatic\s+char\s+(\w+)\s*\[\s*\]\s*=\s*"/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003320 WARN("STATIC_CONST_CHAR_ARRAY",
3321 "static char array declaration should probably be static const char\n" .
Joe Perchescb710ec2010-10-26 14:23:20 -07003322 $herecurr);
3323 }
3324
Joe Perchesab7e23f2015-04-16 12:44:22 -07003325# check for const <foo> const where <foo> is not a pointer or array type
3326 if ($sline =~ /\bconst\s+($BasicType)\s+const\b/) {
3327 my $found = $1;
3328 if ($sline =~ /\bconst\s+\Q$found\E\s+const\b\s*\*/) {
3329 WARN("CONST_CONST",
3330 "'const $found const *' should probably be 'const $found * const'\n" . $herecurr);
3331 } elsif ($sline !~ /\bconst\s+\Q$found\E\s+const\s+\w+\s*\[/) {
3332 WARN("CONST_CONST",
3333 "'const $found const' should probably be 'const $found'\n" . $herecurr);
3334 }
3335 }
3336
Joe Perches9b0fa602014-04-03 14:49:18 -07003337# check for non-global char *foo[] = {"bar", ...} declarations.
3338 if ($line =~ /^.\s+(?:static\s+|const\s+)?char\s+\*\s*\w+\s*\[\s*\]\s*=\s*\{/) {
3339 WARN("STATIC_CONST_CHAR_ARRAY",
3340 "char * array declaration might be better as static const\n" .
3341 $herecurr);
3342 }
3343
Joe Perchesb598b672015-04-16 12:44:36 -07003344# check for sizeof(foo)/sizeof(foo[0]) that could be ARRAY_SIZE(foo)
3345 if ($line =~ m@\bsizeof\s*\(\s*($Lval)\s*\)@) {
3346 my $array = $1;
3347 if ($line =~ m@\b(sizeof\s*\(\s*\Q$array\E\s*\)\s*/\s*sizeof\s*\(\s*\Q$array\E\s*\[\s*0\s*\]\s*\))@) {
3348 my $array_div = $1;
3349 if (WARN("ARRAY_SIZE",
3350 "Prefer ARRAY_SIZE($array)\n" . $herecurr) &&
3351 $fix) {
3352 $fixed[$fixlinenr] =~ s/\Q$array_div\E/ARRAY_SIZE($array)/;
3353 }
3354 }
3355 }
3356
Joe Perchesb36190c2014-01-27 17:07:18 -08003357# check for function declarations without arguments like "int foo()"
3358 if ($line =~ /(\b$Type\s+$Ident)\s*\(\s*\)/) {
3359 if (ERROR("FUNCTION_WITHOUT_ARGS",
3360 "Bad function definition - $1() should probably be $1(void)\n" . $herecurr) &&
3361 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07003362 $fixed[$fixlinenr] =~ s/(\b($Type)\s+($Ident))\s*\(\s*\)/$2 $3(void)/;
Joe Perchesb36190c2014-01-27 17:07:18 -08003363 }
3364 }
3365
Joe Perches92e112f2013-12-13 11:36:22 -07003366# check for uses of DEFINE_PCI_DEVICE_TABLE
3367 if ($line =~ /\bDEFINE_PCI_DEVICE_TABLE\s*\(\s*(\w+)\s*\)\s*=/) {
3368 if (WARN("DEFINE_PCI_DEVICE_TABLE",
3369 "Prefer struct pci_device_id over deprecated DEFINE_PCI_DEVICE_TABLE\n" . $herecurr) &&
3370 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07003371 $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 -07003372 }
Joe Perches93ed0e22010-10-26 14:23:21 -07003373 }
3374
Andy Whitcroft653d4872007-06-23 17:16:34 -07003375# check for new typedefs, only function parameters and sparse annotations
3376# make sense.
3377 if ($line =~ /\btypedef\s/ &&
Andy Whitcroft80545762009-01-06 14:41:26 -08003378 $line !~ /\btypedef\s+$Type\s*\(\s*\*?$Ident\s*\)\s*\(/ &&
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07003379 $line !~ /\btypedef\s+$Type\s+$Ident\s*\(/ &&
Andy Whitcroft8ed22ca2008-10-15 22:02:32 -07003380 $line !~ /\b$typeTypedefs\b/ &&
Andy Whitcroft653d4872007-06-23 17:16:34 -07003381 $line !~ /\b__bitwise(?:__|)\b/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003382 WARN("NEW_TYPEDEFS",
3383 "do not add new typedefs\n" . $herecurr);
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003384 }
3385
3386# * goes on variable not on type
Andy Whitcroft65863862009-01-06 14:41:21 -08003387 # (char*[ const])
Andy Whitcroftbfcb2cc2012-01-10 15:10:15 -08003388 while ($line =~ m{(\($NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)\))}g) {
3389 #print "AA<$1>\n";
Joe Perches3705ce52013-07-03 15:05:31 -07003390 my ($ident, $from, $to) = ($1, $2, $2);
Andy Whitcroftd8aaf122007-06-23 17:16:44 -07003391
Andy Whitcroft65863862009-01-06 14:41:21 -08003392 # Should start with a space.
3393 $to =~ s/^(\S)/ $1/;
3394 # Should not end with a space.
3395 $to =~ s/\s+$//;
3396 # '*'s should not have spaces between.
Andy Whitcroftf9a0b3d2009-01-15 13:51:05 -08003397 while ($to =~ s/\*\s+\*/\*\*/) {
Andy Whitcroft65863862009-01-06 14:41:21 -08003398 }
Andy Whitcroftd8aaf122007-06-23 17:16:44 -07003399
Joe Perches3705ce52013-07-03 15:05:31 -07003400## print "1: from<$from> to<$to> ident<$ident>\n";
Andy Whitcroft65863862009-01-06 14:41:21 -08003401 if ($from ne $to) {
Joe Perches3705ce52013-07-03 15:05:31 -07003402 if (ERROR("POINTER_LOCATION",
3403 "\"(foo$from)\" should be \"(foo$to)\"\n" . $herecurr) &&
3404 $fix) {
3405 my $sub_from = $ident;
3406 my $sub_to = $ident;
3407 $sub_to =~ s/\Q$from\E/$to/;
Joe Perches194f66f2014-08-06 16:11:03 -07003408 $fixed[$fixlinenr] =~
Joe Perches3705ce52013-07-03 15:05:31 -07003409 s@\Q$sub_from\E@$sub_to@;
3410 }
Andy Whitcroft65863862009-01-06 14:41:21 -08003411 }
Andy Whitcroftbfcb2cc2012-01-10 15:10:15 -08003412 }
3413 while ($line =~ m{(\b$NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)($Ident))}g) {
3414 #print "BB<$1>\n";
Joe Perches3705ce52013-07-03 15:05:31 -07003415 my ($match, $from, $to, $ident) = ($1, $2, $2, $3);
Andy Whitcroftd8aaf122007-06-23 17:16:44 -07003416
Andy Whitcroft65863862009-01-06 14:41:21 -08003417 # Should start with a space.
3418 $to =~ s/^(\S)/ $1/;
3419 # Should not end with a space.
3420 $to =~ s/\s+$//;
3421 # '*'s should not have spaces between.
Andy Whitcroftf9a0b3d2009-01-15 13:51:05 -08003422 while ($to =~ s/\*\s+\*/\*\*/) {
Andy Whitcroft65863862009-01-06 14:41:21 -08003423 }
3424 # Modifiers should have spaces.
3425 $to =~ s/(\b$Modifier$)/$1 /;
3426
Joe Perches3705ce52013-07-03 15:05:31 -07003427## print "2: from<$from> to<$to> ident<$ident>\n";
Andy Whitcroft667026e2009-02-27 14:03:08 -08003428 if ($from ne $to && $ident !~ /^$Modifier$/) {
Joe Perches3705ce52013-07-03 15:05:31 -07003429 if (ERROR("POINTER_LOCATION",
3430 "\"foo${from}bar\" should be \"foo${to}bar\"\n" . $herecurr) &&
3431 $fix) {
3432
3433 my $sub_from = $match;
3434 my $sub_to = $match;
3435 $sub_to =~ s/\Q$from\E/$to/;
Joe Perches194f66f2014-08-06 16:11:03 -07003436 $fixed[$fixlinenr] =~
Joe Perches3705ce52013-07-03 15:05:31 -07003437 s@\Q$sub_from\E@$sub_to@;
3438 }
Andy Whitcroft65863862009-01-06 14:41:21 -08003439 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003440 }
3441
3442# # no BUG() or BUG_ON()
3443# if ($line =~ /\b(BUG|BUG_ON)\b/) {
3444# print "Try to use WARN_ON & Recovery code rather than BUG() or BUG_ON()\n";
3445# print "$herecurr";
3446# $clean = 0;
3447# }
3448
Andy Whitcroft8905a672007-11-28 16:21:06 -08003449 if ($line =~ /\bLINUX_VERSION_CODE\b/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003450 WARN("LINUX_VERSION_CODE",
3451 "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 -08003452 }
3453
Joe Perches17441222011-06-15 15:08:17 -07003454# check for uses of printk_ratelimit
3455 if ($line =~ /\bprintk_ratelimit\s*\(/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003456 WARN("PRINTK_RATELIMITED",
Joe Perches101ee682015-02-13 14:38:54 -08003457 "Prefer printk_ratelimited or pr_<level>_ratelimited to printk_ratelimit\n" . $herecurr);
Joe Perches17441222011-06-15 15:08:17 -07003458 }
3459
Andy Whitcroft00df3442007-06-08 13:47:06 -07003460# printk should use KERN_* levels. Note that follow on printk's on the
3461# same line do not need a level, so we use the current block context
3462# to try and find and validate the current printk. In summary the current
Lucas De Marchi25985ed2011-03-30 22:57:33 -03003463# printk includes all preceding printk's which have no newline on the end.
Andy Whitcroft00df3442007-06-08 13:47:06 -07003464# we assume the first bad printk is the one to report.
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07003465 if ($line =~ /\bprintk\((?!KERN_)\s*"/) {
Andy Whitcroft00df3442007-06-08 13:47:06 -07003466 my $ok = 0;
3467 for (my $ln = $linenr - 1; $ln >= $first_line; $ln--) {
3468 #print "CHECK<$lines[$ln - 1]\n";
Lucas De Marchi25985ed2011-03-30 22:57:33 -03003469 # we have a preceding printk if it ends
Andy Whitcroft00df3442007-06-08 13:47:06 -07003470 # with "\n" ignore it, else it is to blame
3471 if ($lines[$ln - 1] =~ m{\bprintk\(}) {
3472 if ($rawlines[$ln - 1] !~ m{\\n"}) {
3473 $ok = 1;
3474 }
3475 last;
3476 }
3477 }
3478 if ($ok == 0) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003479 WARN("PRINTK_WITHOUT_KERN_LEVEL",
3480 "printk() should include KERN_ facility level\n" . $herecurr);
Andy Whitcroft00df3442007-06-08 13:47:06 -07003481 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003482 }
3483
Joe Perches243f3802012-05-31 16:26:09 -07003484 if ($line =~ /\bprintk\s*\(\s*KERN_([A-Z]+)/) {
3485 my $orig = $1;
3486 my $level = lc($orig);
3487 $level = "warn" if ($level eq "warning");
Joe Perches8f26b832012-10-04 17:13:32 -07003488 my $level2 = $level;
3489 $level2 = "dbg" if ($level eq "debug");
Joe Perches243f3802012-05-31 16:26:09 -07003490 WARN("PREFER_PR_LEVEL",
Yogesh Chaudharidaa8b052014-04-03 14:49:23 -07003491 "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 -07003492 }
3493
3494 if ($line =~ /\bpr_warning\s*\(/) {
Joe Perchesd5e616f2013-09-11 14:23:54 -07003495 if (WARN("PREFER_PR_LEVEL",
3496 "Prefer pr_warn(... to pr_warning(...\n" . $herecurr) &&
3497 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07003498 $fixed[$fixlinenr] =~
Joe Perchesd5e616f2013-09-11 14:23:54 -07003499 s/\bpr_warning\b/pr_warn/;
3500 }
Joe Perches243f3802012-05-31 16:26:09 -07003501 }
3502
Joe Perchesdc139312013-02-21 16:44:13 -08003503 if ($line =~ /\bdev_printk\s*\(\s*KERN_([A-Z]+)/) {
3504 my $orig = $1;
3505 my $level = lc($orig);
3506 $level = "warn" if ($level eq "warning");
3507 $level = "dbg" if ($level eq "debug");
3508 WARN("PREFER_DEV_LEVEL",
3509 "Prefer dev_$level(... to dev_printk(KERN_$orig, ...\n" . $herecurr);
3510 }
3511
Andy Lutomirski91c9afa2015-04-16 12:44:44 -07003512# ENOSYS means "bad syscall nr" and nothing else. This will have a small
3513# number of false positives, but assembly files are not checked, so at
3514# least the arch entry code will not trigger this warning.
3515 if ($line =~ /\bENOSYS\b/) {
3516 WARN("ENOSYS",
3517 "ENOSYS means 'invalid syscall nr' and nothing else\n" . $herecurr);
3518 }
3519
Andy Whitcroft653d4872007-06-23 17:16:34 -07003520# function brace can't be on same line, except for #defines of do while,
3521# or if closed on same line
Joe Perches8d182472014-08-06 16:11:12 -07003522 if (($line=~/$Type\s*$Ident\(.*\).*\s*{/) and
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07003523 !($line=~/\#\s*define.*do\s{/) and !($line=~/}/)) {
Joe Perches8d182472014-08-06 16:11:12 -07003524 if (ERROR("OPEN_BRACE",
3525 "open brace '{' following function declarations go on the next line\n" . $herecurr) &&
3526 $fix) {
3527 fix_delete_line($fixlinenr, $rawline);
3528 my $fixed_line = $rawline;
3529 $fixed_line =~ /(^..*$Type\s*$Ident\(.*\)\s*){(.*)$/;
3530 my $line1 = $1;
3531 my $line2 = $2;
3532 fix_insert_line($fixlinenr, ltrim($line1));
3533 fix_insert_line($fixlinenr, "\+{");
3534 if ($line2 !~ /^\s*$/) {
3535 fix_insert_line($fixlinenr, "\+\t" . trim($line2));
3536 }
3537 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003538 }
Andy Whitcroft653d4872007-06-23 17:16:34 -07003539
Andy Whitcroft8905a672007-11-28 16:21:06 -08003540# open braces for enum, union and struct go on the same line.
3541 if ($line =~ /^.\s*{/ &&
3542 $prevline =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident)?\s*$/) {
Joe Perches8d182472014-08-06 16:11:12 -07003543 if (ERROR("OPEN_BRACE",
3544 "open brace '{' following $1 go on the same line\n" . $hereprev) &&
3545 $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
3546 fix_delete_line($fixlinenr - 1, $prevrawline);
3547 fix_delete_line($fixlinenr, $rawline);
3548 my $fixedline = rtrim($prevrawline) . " {";
3549 fix_insert_line($fixlinenr, $fixedline);
3550 $fixedline = $rawline;
3551 $fixedline =~ s/^(.\s*){\s*/$1\t/;
3552 if ($fixedline !~ /^\+\s*$/) {
3553 fix_insert_line($fixlinenr, $fixedline);
3554 }
3555 }
Andy Whitcroft8905a672007-11-28 16:21:06 -08003556 }
3557
Andy Whitcroft0c73b4e2010-10-26 14:23:15 -07003558# missing space after union, struct or enum definition
Joe Perches3705ce52013-07-03 15:05:31 -07003559 if ($line =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident){1,2}[=\{]/) {
3560 if (WARN("SPACING",
3561 "missing space after $1 definition\n" . $herecurr) &&
3562 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07003563 $fixed[$fixlinenr] =~
Joe Perches3705ce52013-07-03 15:05:31 -07003564 s/^(.\s*(?:typedef\s+)?(?:enum|union|struct)(?:\s+$Ident){1,2})([=\{])/$1 $2/;
3565 }
Andy Whitcroft0c73b4e2010-10-26 14:23:15 -07003566 }
3567
Joe Perches31070b52014-01-23 15:54:49 -08003568# Function pointer declarations
3569# check spacing between type, funcptr, and args
3570# canonical declaration is "type (*funcptr)(args...)"
Joe Perches91f72e92014-04-03 14:49:12 -07003571 if ($line =~ /^.\s*($Declare)\((\s*)\*(\s*)($Ident)(\s*)\)(\s*)\(/) {
Joe Perches31070b52014-01-23 15:54:49 -08003572 my $declare = $1;
3573 my $pre_pointer_space = $2;
3574 my $post_pointer_space = $3;
3575 my $funcname = $4;
3576 my $post_funcname_space = $5;
3577 my $pre_args_space = $6;
3578
Joe Perches91f72e92014-04-03 14:49:12 -07003579# the $Declare variable will capture all spaces after the type
3580# so check it for a missing trailing missing space but pointer return types
3581# don't need a space so don't warn for those.
3582 my $post_declare_space = "";
3583 if ($declare =~ /(\s+)$/) {
3584 $post_declare_space = $1;
3585 $declare = rtrim($declare);
3586 }
3587 if ($declare !~ /\*$/ && $post_declare_space =~ /^$/) {
Joe Perches31070b52014-01-23 15:54:49 -08003588 WARN("SPACING",
3589 "missing space after return type\n" . $herecurr);
Joe Perches91f72e92014-04-03 14:49:12 -07003590 $post_declare_space = " ";
Joe Perches31070b52014-01-23 15:54:49 -08003591 }
3592
3593# unnecessary space "type (*funcptr)(args...)"
Joe Perches91f72e92014-04-03 14:49:12 -07003594# This test is not currently implemented because these declarations are
3595# equivalent to
3596# int foo(int bar, ...)
3597# and this is form shouldn't/doesn't generate a checkpatch warning.
3598#
3599# elsif ($declare =~ /\s{2,}$/) {
3600# WARN("SPACING",
3601# "Multiple spaces after return type\n" . $herecurr);
3602# }
Joe Perches31070b52014-01-23 15:54:49 -08003603
3604# unnecessary space "type ( *funcptr)(args...)"
3605 if (defined $pre_pointer_space &&
3606 $pre_pointer_space =~ /^\s/) {
3607 WARN("SPACING",
3608 "Unnecessary space after function pointer open parenthesis\n" . $herecurr);
3609 }
3610
3611# unnecessary space "type (* funcptr)(args...)"
3612 if (defined $post_pointer_space &&
3613 $post_pointer_space =~ /^\s/) {
3614 WARN("SPACING",
3615 "Unnecessary space before function pointer name\n" . $herecurr);
3616 }
3617
3618# unnecessary space "type (*funcptr )(args...)"
3619 if (defined $post_funcname_space &&
3620 $post_funcname_space =~ /^\s/) {
3621 WARN("SPACING",
3622 "Unnecessary space after function pointer name\n" . $herecurr);
3623 }
3624
3625# unnecessary space "type (*funcptr) (args...)"
3626 if (defined $pre_args_space &&
3627 $pre_args_space =~ /^\s/) {
3628 WARN("SPACING",
3629 "Unnecessary space before function pointer arguments\n" . $herecurr);
3630 }
3631
3632 if (show_type("SPACING") && $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07003633 $fixed[$fixlinenr] =~
Joe Perches91f72e92014-04-03 14:49:12 -07003634 s/^(.\s*)$Declare\s*\(\s*\*\s*$Ident\s*\)\s*\(/$1 . $declare . $post_declare_space . '(*' . $funcname . ')('/ex;
Joe Perches31070b52014-01-23 15:54:49 -08003635 }
3636 }
3637
Andy Whitcroft8d31cfc2008-07-23 21:29:02 -07003638# check for spacing round square brackets; allowed:
3639# 1. with a type on the left -- int [] a;
Andy Whitcroftfe2a7db2008-10-15 22:02:15 -07003640# 2. at the beginning of a line for slice initialisers -- [0...10] = 5,
3641# 3. inside a curly brace -- = { [0...10] = 5 }
Andy Whitcroft8d31cfc2008-07-23 21:29:02 -07003642 while ($line =~ /(.*?\s)\[/g) {
3643 my ($where, $prefix) = ($-[1], $1);
3644 if ($prefix !~ /$Type\s+$/ &&
Andy Whitcroftfe2a7db2008-10-15 22:02:15 -07003645 ($where != 0 || $prefix !~ /^.\s+$/) &&
Andy Whitcroftdaebc532012-03-23 15:02:17 -07003646 $prefix !~ /[{,]\s+$/) {
Joe Perches3705ce52013-07-03 15:05:31 -07003647 if (ERROR("BRACKET_SPACE",
3648 "space prohibited before open square bracket '['\n" . $herecurr) &&
3649 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07003650 $fixed[$fixlinenr] =~
Joe Perches3705ce52013-07-03 15:05:31 -07003651 s/^(\+.*?)\s+\[/$1\[/;
3652 }
Andy Whitcroft8d31cfc2008-07-23 21:29:02 -07003653 }
3654 }
3655
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07003656# check for spaces between functions and their parentheses.
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07003657 while ($line =~ /($Ident)\s+\(/g) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08003658 my $name = $1;
Andy Whitcroft773647a2008-03-28 14:15:58 -07003659 my $ctx_before = substr($line, 0, $-[1]);
3660 my $ctx = "$ctx_before$name";
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08003661
3662 # Ignore those directives where spaces _are_ permitted.
Andy Whitcroft773647a2008-03-28 14:15:58 -07003663 if ($name =~ /^(?:
3664 if|for|while|switch|return|case|
3665 volatile|__volatile__|
3666 __attribute__|format|__extension__|
3667 asm|__asm__)$/x)
3668 {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08003669 # cpp #define statements have non-optional spaces, ie
3670 # if there is a space between the name and the open
3671 # parenthesis it is simply not a parameter group.
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07003672 } elsif ($ctx_before =~ /^.\s*\#\s*define\s*$/) {
Andy Whitcroft773647a2008-03-28 14:15:58 -07003673
3674 # cpp #elif statement condition may start with a (
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07003675 } elsif ($ctx =~ /^.\s*\#\s*elif\s*$/) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08003676
3677 # If this whole things ends with a type its most
3678 # likely a typedef for a function.
Andy Whitcroft773647a2008-03-28 14:15:58 -07003679 } elsif ($ctx =~ /$Type$/) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08003680
3681 } else {
Joe Perches3705ce52013-07-03 15:05:31 -07003682 if (WARN("SPACING",
3683 "space prohibited between function name and open parenthesis '('\n" . $herecurr) &&
3684 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07003685 $fixed[$fixlinenr] =~
Joe Perches3705ce52013-07-03 15:05:31 -07003686 s/\b$name\s+\(/$name\(/;
3687 }
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07003688 }
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07003689 }
Eric Nelson9a4cad42012-05-31 16:26:09 -07003690
Andy Whitcroft653d4872007-06-23 17:16:34 -07003691# Check operator spacing.
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003692 if (!($line=~/\#\s*include/)) {
Joe Perches3705ce52013-07-03 15:05:31 -07003693 my $fixed_line = "";
3694 my $line_fixed = 0;
3695
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07003696 my $ops = qr{
3697 <<=|>>=|<=|>=|==|!=|
3698 \+=|-=|\*=|\/=|%=|\^=|\|=|&=|
3699 =>|->|<<|>>|<|>|=|!|~|
Andy Whitcroft1f65f942008-07-23 21:29:10 -07003700 &&|\|\||,|\^|\+\+|--|&|\||\+|-|\*|\/|%|
Joe Perches84731622013-11-12 15:10:05 -08003701 \?:|\?|:
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07003702 }x;
Andy Whitcroftcf655042008-03-04 14:28:20 -08003703 my @elements = split(/($ops|;)/, $opline);
Joe Perches3705ce52013-07-03 15:05:31 -07003704
3705## print("element count: <" . $#elements . ">\n");
3706## foreach my $el (@elements) {
3707## print("el: <$el>\n");
3708## }
3709
3710 my @fix_elements = ();
Andy Whitcroft00df3442007-06-08 13:47:06 -07003711 my $off = 0;
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07003712
Joe Perches3705ce52013-07-03 15:05:31 -07003713 foreach my $el (@elements) {
3714 push(@fix_elements, substr($rawline, $off, length($el)));
3715 $off += length($el);
3716 }
3717
3718 $off = 0;
3719
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07003720 my $blank = copy_spacing($opline);
Joe Perchesb34c6482013-09-11 14:24:01 -07003721 my $last_after = -1;
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07003722
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003723 for (my $n = 0; $n < $#elements; $n += 2) {
Joe Perches3705ce52013-07-03 15:05:31 -07003724
3725 my $good = $fix_elements[$n] . $fix_elements[$n + 1];
3726
3727## print("n: <$n> good: <$good>\n");
3728
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07003729 $off += length($elements[$n]);
3730
Lucas De Marchi25985ed2011-03-30 22:57:33 -03003731 # Pick up the preceding and succeeding characters.
Andy Whitcroft773647a2008-03-28 14:15:58 -07003732 my $ca = substr($opline, 0, $off);
3733 my $cc = '';
3734 if (length($opline) >= ($off + length($elements[$n + 1]))) {
3735 $cc = substr($opline, $off + length($elements[$n + 1]));
3736 }
3737 my $cb = "$ca$;$cc";
3738
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07003739 my $a = '';
3740 $a = 'V' if ($elements[$n] ne '');
3741 $a = 'W' if ($elements[$n] =~ /\s$/);
Andy Whitcroftcf655042008-03-04 14:28:20 -08003742 $a = 'C' if ($elements[$n] =~ /$;$/);
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07003743 $a = 'B' if ($elements[$n] =~ /(\[|\()$/);
3744 $a = 'O' if ($elements[$n] eq '');
Andy Whitcroft773647a2008-03-28 14:15:58 -07003745 $a = 'E' if ($ca =~ /^\s*$/);
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07003746
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003747 my $op = $elements[$n + 1];
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07003748
3749 my $c = '';
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003750 if (defined $elements[$n + 2]) {
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07003751 $c = 'V' if ($elements[$n + 2] ne '');
3752 $c = 'W' if ($elements[$n + 2] =~ /^\s/);
Andy Whitcroftcf655042008-03-04 14:28:20 -08003753 $c = 'C' if ($elements[$n + 2] =~ /^$;/);
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07003754 $c = 'B' if ($elements[$n + 2] =~ /^(\)|\]|;)/);
3755 $c = 'O' if ($elements[$n + 2] eq '');
Andy Whitcroft8b1b3372009-01-06 14:41:27 -08003756 $c = 'E' if ($elements[$n + 2] =~ /^\s*\\$/);
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07003757 } else {
3758 $c = 'E';
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003759 }
3760
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07003761 my $ctx = "${a}x${c}";
3762
3763 my $at = "(ctx:$ctx)";
3764
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07003765 my $ptr = substr($blank, 0, $off) . "^";
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07003766 my $hereptr = "$hereline$ptr\n";
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003767
Andy Whitcroft74048ed2008-07-23 21:29:10 -07003768 # Pull out the value of this operator.
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07003769 my $op_type = substr($curr_values, $off + 1, 1);
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003770
Andy Whitcroft1f65f942008-07-23 21:29:10 -07003771 # Get the full operator variant.
3772 my $opv = $op . substr($curr_vars, $off, 1);
3773
Andy Whitcroft13214ad2008-02-08 04:22:03 -08003774 # Ignore operators passed as parameters.
3775 if ($op_type ne 'V' &&
Sam Bobroffd7fe8062015-04-16 12:44:39 -07003776 $ca =~ /\s$/ && $cc =~ /^\s*[,\)]/) {
Andy Whitcroft13214ad2008-02-08 04:22:03 -08003777
Andy Whitcroftcf655042008-03-04 14:28:20 -08003778# # Ignore comments
3779# } elsif ($op =~ /^$;+$/) {
Andy Whitcroft13214ad2008-02-08 04:22:03 -08003780
Andy Whitcroftd8aaf122007-06-23 17:16:44 -07003781 # ; should have either the end of line or a space or \ after it
Andy Whitcroft13214ad2008-02-08 04:22:03 -08003782 } elsif ($op eq ';') {
Andy Whitcroftcf655042008-03-04 14:28:20 -08003783 if ($ctx !~ /.x[WEBC]/ &&
3784 $cc !~ /^\\/ && $cc !~ /^;/) {
Joe Perches3705ce52013-07-03 15:05:31 -07003785 if (ERROR("SPACING",
3786 "space required after that '$op' $at\n" . $hereptr)) {
Joe Perchesb34c6482013-09-11 14:24:01 -07003787 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";
Joe Perches3705ce52013-07-03 15:05:31 -07003788 $line_fixed = 1;
3789 }
Andy Whitcroftd8aaf122007-06-23 17:16:44 -07003790 }
3791
3792 # // is a comment
3793 } elsif ($op eq '//') {
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003794
Joe Perchesb00e4812014-04-03 14:49:33 -07003795 # : when part of a bitfield
3796 } elsif ($opv eq ':B') {
3797 # skip the bitfield test for now
3798
Andy Whitcroft1f65f942008-07-23 21:29:10 -07003799 # No spaces for:
3800 # ->
Joe Perchesb00e4812014-04-03 14:49:33 -07003801 } elsif ($op eq '->') {
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07003802 if ($ctx =~ /Wx.|.xW/) {
Joe Perches3705ce52013-07-03 15:05:31 -07003803 if (ERROR("SPACING",
3804 "spaces prohibited around that '$op' $at\n" . $hereptr)) {
Joe Perchesb34c6482013-09-11 14:24:01 -07003805 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
Joe Perches3705ce52013-07-03 15:05:31 -07003806 if (defined $fix_elements[$n + 2]) {
3807 $fix_elements[$n + 2] =~ s/^\s+//;
3808 }
Joe Perchesb34c6482013-09-11 14:24:01 -07003809 $line_fixed = 1;
Joe Perches3705ce52013-07-03 15:05:31 -07003810 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003811 }
3812
Joe Perches23810972014-12-10 15:51:32 -08003813 # , must not have a space before and must have a space on the right.
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003814 } elsif ($op eq ',') {
Joe Perches23810972014-12-10 15:51:32 -08003815 my $rtrim_before = 0;
3816 my $space_after = 0;
3817 if ($ctx =~ /Wx./) {
3818 if (ERROR("SPACING",
3819 "space prohibited before that '$op' $at\n" . $hereptr)) {
3820 $line_fixed = 1;
3821 $rtrim_before = 1;
3822 }
3823 }
Andy Whitcroftcf655042008-03-04 14:28:20 -08003824 if ($ctx !~ /.x[WEC]/ && $cc !~ /^}/) {
Joe Perches3705ce52013-07-03 15:05:31 -07003825 if (ERROR("SPACING",
3826 "space required after that '$op' $at\n" . $hereptr)) {
Joe Perches3705ce52013-07-03 15:05:31 -07003827 $line_fixed = 1;
Joe Perchesb34c6482013-09-11 14:24:01 -07003828 $last_after = $n;
Joe Perches23810972014-12-10 15:51:32 -08003829 $space_after = 1;
3830 }
3831 }
3832 if ($rtrim_before || $space_after) {
3833 if ($rtrim_before) {
3834 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
3835 } else {
3836 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]);
3837 }
3838 if ($space_after) {
3839 $good .= " ";
Joe Perches3705ce52013-07-03 15:05:31 -07003840 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003841 }
3842
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07003843 # '*' as part of a type definition -- reported already.
Andy Whitcroft74048ed2008-07-23 21:29:10 -07003844 } elsif ($opv eq '*_') {
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07003845 #warn "'*' is part of type\n";
3846
3847 # unary operators should have a space before and
3848 # none after. May be left adjacent to another
3849 # unary operator, or a cast
3850 } elsif ($op eq '!' || $op eq '~' ||
Andy Whitcroft74048ed2008-07-23 21:29:10 -07003851 $opv eq '*U' || $opv eq '-U' ||
Andy Whitcroft0d413862008-10-15 22:02:16 -07003852 $opv eq '&U' || $opv eq '&&U') {
Andy Whitcroftcf655042008-03-04 14:28:20 -08003853 if ($ctx !~ /[WEBC]x./ && $ca !~ /(?:\)|!|~|\*|-|\&|\||\+\+|\-\-|\{)$/) {
Joe Perches3705ce52013-07-03 15:05:31 -07003854 if (ERROR("SPACING",
3855 "space required before that '$op' $at\n" . $hereptr)) {
Joe Perchesb34c6482013-09-11 14:24:01 -07003856 if ($n != $last_after + 2) {
3857 $good = $fix_elements[$n] . " " . ltrim($fix_elements[$n + 1]);
3858 $line_fixed = 1;
3859 }
Joe Perches3705ce52013-07-03 15:05:31 -07003860 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003861 }
Andy Whitcrofta3340b32009-02-27 14:03:07 -08003862 if ($op eq '*' && $cc =~/\s*$Modifier\b/) {
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07003863 # A unary '*' may be const
3864
3865 } elsif ($ctx =~ /.xW/) {
Joe Perches3705ce52013-07-03 15:05:31 -07003866 if (ERROR("SPACING",
3867 "space prohibited after that '$op' $at\n" . $hereptr)) {
Joe Perchesb34c6482013-09-11 14:24:01 -07003868 $good = $fix_elements[$n] . rtrim($fix_elements[$n + 1]);
Joe Perches3705ce52013-07-03 15:05:31 -07003869 if (defined $fix_elements[$n + 2]) {
3870 $fix_elements[$n + 2] =~ s/^\s+//;
3871 }
Joe Perchesb34c6482013-09-11 14:24:01 -07003872 $line_fixed = 1;
Joe Perches3705ce52013-07-03 15:05:31 -07003873 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003874 }
3875
3876 # unary ++ and unary -- are allowed no space on one side.
3877 } elsif ($op eq '++' or $op eq '--') {
Andy Whitcroft773647a2008-03-28 14:15:58 -07003878 if ($ctx !~ /[WEOBC]x[^W]/ && $ctx !~ /[^W]x[WOBEC]/) {
Joe Perches3705ce52013-07-03 15:05:31 -07003879 if (ERROR("SPACING",
3880 "space required one side of that '$op' $at\n" . $hereptr)) {
Joe Perchesb34c6482013-09-11 14:24:01 -07003881 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";
Joe Perches3705ce52013-07-03 15:05:31 -07003882 $line_fixed = 1;
3883 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003884 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07003885 if ($ctx =~ /Wx[BE]/ ||
3886 ($ctx =~ /Wx./ && $cc =~ /^;/)) {
Joe Perches3705ce52013-07-03 15:05:31 -07003887 if (ERROR("SPACING",
3888 "space prohibited before that '$op' $at\n" . $hereptr)) {
Joe Perchesb34c6482013-09-11 14:24:01 -07003889 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
Joe Perches3705ce52013-07-03 15:05:31 -07003890 $line_fixed = 1;
3891 }
Andy Whitcroft653d4872007-06-23 17:16:34 -07003892 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07003893 if ($ctx =~ /ExW/) {
Joe Perches3705ce52013-07-03 15:05:31 -07003894 if (ERROR("SPACING",
3895 "space prohibited after that '$op' $at\n" . $hereptr)) {
Joe Perchesb34c6482013-09-11 14:24:01 -07003896 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]);
Joe Perches3705ce52013-07-03 15:05:31 -07003897 if (defined $fix_elements[$n + 2]) {
3898 $fix_elements[$n + 2] =~ s/^\s+//;
3899 }
Joe Perchesb34c6482013-09-11 14:24:01 -07003900 $line_fixed = 1;
Joe Perches3705ce52013-07-03 15:05:31 -07003901 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07003902 }
3903
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003904 # << and >> may either have or not have spaces both sides
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07003905 } elsif ($op eq '<<' or $op eq '>>' or
3906 $op eq '&' or $op eq '^' or $op eq '|' or
3907 $op eq '+' or $op eq '-' or
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08003908 $op eq '*' or $op eq '/' or
3909 $op eq '%')
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003910 {
Joe Perchesd2e025f2015-02-13 14:38:57 -08003911 if ($check) {
3912 if (defined $fix_elements[$n + 2] && $ctx !~ /[EW]x[EW]/) {
3913 if (CHK("SPACING",
3914 "spaces preferred around that '$op' $at\n" . $hereptr)) {
3915 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
3916 $fix_elements[$n + 2] =~ s/^\s+//;
3917 $line_fixed = 1;
3918 }
3919 } elsif (!defined $fix_elements[$n + 2] && $ctx !~ /Wx[OE]/) {
3920 if (CHK("SPACING",
3921 "space preferred before that '$op' $at\n" . $hereptr)) {
3922 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]);
3923 $line_fixed = 1;
3924 }
3925 }
3926 } elsif ($ctx =~ /Wx[^WCE]|[^WCE]xW/) {
Joe Perches3705ce52013-07-03 15:05:31 -07003927 if (ERROR("SPACING",
3928 "need consistent spacing around '$op' $at\n" . $hereptr)) {
Joe Perchesb34c6482013-09-11 14:24:01 -07003929 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
3930 if (defined $fix_elements[$n + 2]) {
3931 $fix_elements[$n + 2] =~ s/^\s+//;
3932 }
Joe Perches3705ce52013-07-03 15:05:31 -07003933 $line_fixed = 1;
3934 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003935 }
3936
Andy Whitcroft1f65f942008-07-23 21:29:10 -07003937 # A colon needs no spaces before when it is
3938 # terminating a case value or a label.
3939 } elsif ($opv eq ':C' || $opv eq ':L') {
3940 if ($ctx =~ /Wx./) {
Joe Perches3705ce52013-07-03 15:05:31 -07003941 if (ERROR("SPACING",
3942 "space prohibited before that '$op' $at\n" . $hereptr)) {
Joe Perchesb34c6482013-09-11 14:24:01 -07003943 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
Joe Perches3705ce52013-07-03 15:05:31 -07003944 $line_fixed = 1;
3945 }
Andy Whitcroft1f65f942008-07-23 21:29:10 -07003946 }
3947
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003948 # All the others need spaces both sides.
Andy Whitcroftcf655042008-03-04 14:28:20 -08003949 } elsif ($ctx !~ /[EWC]x[CWE]/) {
Andy Whitcroft1f65f942008-07-23 21:29:10 -07003950 my $ok = 0;
3951
Andy Whitcroft22f2a2e2007-08-10 13:01:03 -07003952 # Ignore email addresses <foo@bar>
Andy Whitcroft1f65f942008-07-23 21:29:10 -07003953 if (($op eq '<' &&
3954 $cc =~ /^\S+\@\S+>/) ||
3955 ($op eq '>' &&
3956 $ca =~ /<\S+\@\S+$/))
3957 {
3958 $ok = 1;
3959 }
3960
Joe Perchese0df7e12015-04-16 12:44:53 -07003961 # for asm volatile statements
3962 # ignore a colon with another
3963 # colon immediately before or after
3964 if (($op eq ':') &&
3965 ($ca =~ /:$/ || $cc =~ /^:/)) {
3966 $ok = 1;
3967 }
3968
Joe Perches84731622013-11-12 15:10:05 -08003969 # messages are ERROR, but ?: are CHK
Andy Whitcroft1f65f942008-07-23 21:29:10 -07003970 if ($ok == 0) {
Joe Perches84731622013-11-12 15:10:05 -08003971 my $msg_type = \&ERROR;
3972 $msg_type = \&CHK if (($op eq '?:' || $op eq '?' || $op eq ':') && $ctx =~ /VxV/);
3973
3974 if (&{$msg_type}("SPACING",
3975 "spaces required around that '$op' $at\n" . $hereptr)) {
Joe Perchesb34c6482013-09-11 14:24:01 -07003976 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
3977 if (defined $fix_elements[$n + 2]) {
3978 $fix_elements[$n + 2] =~ s/^\s+//;
3979 }
Joe Perches3705ce52013-07-03 15:05:31 -07003980 $line_fixed = 1;
3981 }
Andy Whitcroft22f2a2e2007-08-10 13:01:03 -07003982 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003983 }
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07003984 $off += length($elements[$n + 1]);
Joe Perches3705ce52013-07-03 15:05:31 -07003985
3986## print("n: <$n> GOOD: <$good>\n");
3987
3988 $fixed_line = $fixed_line . $good;
Andy Whitcroft0a920b52007-06-01 00:46:48 -07003989 }
Joe Perches3705ce52013-07-03 15:05:31 -07003990
3991 if (($#elements % 2) == 0) {
3992 $fixed_line = $fixed_line . $fix_elements[$#elements];
3993 }
3994
Joe Perches194f66f2014-08-06 16:11:03 -07003995 if ($fix && $line_fixed && $fixed_line ne $fixed[$fixlinenr]) {
3996 $fixed[$fixlinenr] = $fixed_line;
Joe Perches3705ce52013-07-03 15:05:31 -07003997 }
3998
3999
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004000 }
4001
Joe Perches786b6322013-07-03 15:05:32 -07004002# check for whitespace before a non-naked semicolon
Joe Perchesd2e248e2014-01-23 15:54:41 -08004003 if ($line =~ /^\+.*\S\s+;\s*$/) {
Joe Perches786b6322013-07-03 15:05:32 -07004004 if (WARN("SPACING",
4005 "space prohibited before semicolon\n" . $herecurr) &&
4006 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07004007 1 while $fixed[$fixlinenr] =~
Joe Perches786b6322013-07-03 15:05:32 -07004008 s/^(\+.*\S)\s+;/$1;/;
4009 }
4010 }
4011
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07004012# check for multiple assignments
4013 if ($line =~ /^.\s*$Lval\s*=\s*$Lval\s*=(?!=)/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07004014 CHK("MULTIPLE_ASSIGNMENTS",
4015 "multiple assignments should be avoided\n" . $herecurr);
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07004016 }
4017
Andy Whitcroft22f2a2e2007-08-10 13:01:03 -07004018## # check for multiple declarations, allowing for a function declaration
4019## # continuation.
4020## if ($line =~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Ident.*/ &&
4021## $line !~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Type\s*$Ident.*/) {
4022##
4023## # Remove any bracketed sections to ensure we do not
4024## # falsly report the parameters of functions.
4025## my $ln = $line;
4026## while ($ln =~ s/\([^\(\)]*\)//g) {
4027## }
4028## if ($ln =~ /,/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07004029## WARN("MULTIPLE_DECLARATION",
4030## "declaring multiple variables together should be avoided\n" . $herecurr);
Andy Whitcroft22f2a2e2007-08-10 13:01:03 -07004031## }
4032## }
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07004033
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004034#need space before brace following if, while, etc
Andy Whitcroft22f2a2e2007-08-10 13:01:03 -07004035 if (($line =~ /\(.*\){/ && $line !~ /\($Type\){/) ||
4036 $line =~ /do{/) {
Joe Perches3705ce52013-07-03 15:05:31 -07004037 if (ERROR("SPACING",
4038 "space required before the open brace '{'\n" . $herecurr) &&
4039 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07004040 $fixed[$fixlinenr] =~ s/^(\+.*(?:do|\))){/$1 {/;
Joe Perches3705ce52013-07-03 15:05:31 -07004041 }
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07004042 }
4043
Joe Perchesc4a62ef2013-07-03 15:05:28 -07004044## # check for blank lines before declarations
4045## if ($line =~ /^.\t+$Type\s+$Ident(?:\s*=.*)?;/ &&
4046## $prevrawline =~ /^.\s*$/) {
4047## WARN("SPACING",
4048## "No blank lines before declarations\n" . $hereprev);
4049## }
4050##
4051
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07004052# closing brace should have a space following it when it has anything
4053# on the line
4054 if ($line =~ /}(?!(?:,|;|\)))\S/) {
Joe Perchesd5e616f2013-09-11 14:23:54 -07004055 if (ERROR("SPACING",
4056 "space required after that close brace '}'\n" . $herecurr) &&
4057 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07004058 $fixed[$fixlinenr] =~
Joe Perchesd5e616f2013-09-11 14:23:54 -07004059 s/}((?!(?:,|;|\)))\S)/} $1/;
4060 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004061 }
4062
Andy Whitcroft22f2a2e2007-08-10 13:01:03 -07004063# check spacing on square brackets
4064 if ($line =~ /\[\s/ && $line !~ /\[\s*$/) {
Joe Perches3705ce52013-07-03 15:05:31 -07004065 if (ERROR("SPACING",
4066 "space prohibited after that open square bracket '['\n" . $herecurr) &&
4067 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07004068 $fixed[$fixlinenr] =~
Joe Perches3705ce52013-07-03 15:05:31 -07004069 s/\[\s+/\[/;
4070 }
Andy Whitcroft22f2a2e2007-08-10 13:01:03 -07004071 }
4072 if ($line =~ /\s\]/) {
Joe Perches3705ce52013-07-03 15:05:31 -07004073 if (ERROR("SPACING",
4074 "space prohibited before that close square bracket ']'\n" . $herecurr) &&
4075 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07004076 $fixed[$fixlinenr] =~
Joe Perches3705ce52013-07-03 15:05:31 -07004077 s/\s+\]/\]/;
4078 }
Andy Whitcroft22f2a2e2007-08-10 13:01:03 -07004079 }
4080
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004081# check spacing on parentheses
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07004082 if ($line =~ /\(\s/ && $line !~ /\(\s*(?:\\)?$/ &&
4083 $line !~ /for\s*\(\s+;/) {
Joe Perches3705ce52013-07-03 15:05:31 -07004084 if (ERROR("SPACING",
4085 "space prohibited after that open parenthesis '('\n" . $herecurr) &&
4086 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07004087 $fixed[$fixlinenr] =~
Joe Perches3705ce52013-07-03 15:05:31 -07004088 s/\(\s+/\(/;
4089 }
Andy Whitcroft22f2a2e2007-08-10 13:01:03 -07004090 }
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004091 if ($line =~ /(\s+)\)/ && $line !~ /^.\s*\)/ &&
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004092 $line !~ /for\s*\(.*;\s+\)/ &&
4093 $line !~ /:\s+\)/) {
Joe Perches3705ce52013-07-03 15:05:31 -07004094 if (ERROR("SPACING",
4095 "space prohibited before that close parenthesis ')'\n" . $herecurr) &&
4096 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07004097 $fixed[$fixlinenr] =~
Joe Perches3705ce52013-07-03 15:05:31 -07004098 s/\s+\)/\)/;
4099 }
Andy Whitcroft22f2a2e2007-08-10 13:01:03 -07004100 }
4101
Joe Perchese2826fd2014-08-06 16:10:48 -07004102# check unnecessary parentheses around addressof/dereference single $Lvals
4103# ie: &(foo->bar) should be &foo->bar and *(foo->bar) should be *foo->bar
4104
4105 while ($line =~ /(?:[^&]&\s*|\*)\(\s*($Ident\s*(?:$Member\s*)+)\s*\)/g) {
Joe Perchesea4acbb2014-12-10 15:51:51 -08004106 my $var = $1;
4107 if (CHK("UNNECESSARY_PARENTHESES",
4108 "Unnecessary parentheses around $var\n" . $herecurr) &&
4109 $fix) {
4110 $fixed[$fixlinenr] =~ s/\(\s*\Q$var\E\s*\)/$var/;
4111 }
4112 }
4113
4114# check for unnecessary parentheses around function pointer uses
4115# ie: (foo->bar)(); should be foo->bar();
4116# but not "if (foo->bar) (" to avoid some false positives
4117 if ($line =~ /(\bif\s*|)(\(\s*$Ident\s*(?:$Member\s*)+\))[ \t]*\(/ && $1 !~ /^if/) {
4118 my $var = $2;
4119 if (CHK("UNNECESSARY_PARENTHESES",
4120 "Unnecessary parentheses around function pointer $var\n" . $herecurr) &&
4121 $fix) {
4122 my $var2 = deparenthesize($var);
4123 $var2 =~ s/\s//g;
4124 $fixed[$fixlinenr] =~ s/\Q$var\E/$var2/;
4125 }
4126 }
Joe Perchese2826fd2014-08-06 16:10:48 -07004127
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004128#goto labels aren't indented, allow a single space however
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07004129 if ($line=~/^.\s+[A-Za-z\d_]+:(?![0-9]+)/ and
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004130 !($line=~/^. [A-Za-z\d_]+:/) and !($line=~/^.\s+default:/)) {
Joe Perches3705ce52013-07-03 15:05:31 -07004131 if (WARN("INDENTED_LABEL",
4132 "labels should not be indented\n" . $herecurr) &&
4133 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07004134 $fixed[$fixlinenr] =~
Joe Perches3705ce52013-07-03 15:05:31 -07004135 s/^(.)\s+/$1/;
4136 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004137 }
4138
Joe Perches5b9553a2014-04-03 14:49:21 -07004139# return is not a function
Joe Perches507e5142013-11-12 15:10:13 -08004140 if (defined($stat) && $stat =~ /^.\s*return(\s*)\(/s) {
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004141 my $spacing = $1;
Joe Perches507e5142013-11-12 15:10:13 -08004142 if ($^V && $^V ge 5.10.0 &&
Joe Perches5b9553a2014-04-03 14:49:21 -07004143 $stat =~ /^.\s*return\s*($balanced_parens)\s*;\s*$/) {
4144 my $value = $1;
4145 $value = deparenthesize($value);
4146 if ($value =~ m/^\s*$FuncArg\s*(?:\?|$)/) {
4147 ERROR("RETURN_PARENTHESES",
4148 "return is not a function, parentheses are not required\n" . $herecurr);
4149 }
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004150 } elsif ($spacing !~ /\s+/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07004151 ERROR("SPACING",
4152 "space required before the open parenthesis '('\n" . $herecurr);
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004153 }
4154 }
Joe Perches507e5142013-11-12 15:10:13 -08004155
Joe Perchesb43ae212014-06-23 13:22:07 -07004156# unnecessary return in a void function
4157# at end-of-function, with the previous line a single leading tab, then return;
4158# and the line before that not a goto label target like "out:"
4159 if ($sline =~ /^[ \+]}\s*$/ &&
4160 $prevline =~ /^\+\treturn\s*;\s*$/ &&
4161 $linenr >= 3 &&
4162 $lines[$linenr - 3] =~ /^[ +]/ &&
4163 $lines[$linenr - 3] !~ /^[ +]\s*$Ident\s*:/) {
Joe Perches9819cf22014-06-04 16:12:09 -07004164 WARN("RETURN_VOID",
Joe Perchesb43ae212014-06-23 13:22:07 -07004165 "void function return statements are not generally useful\n" . $hereprev);
4166 }
Joe Perches9819cf22014-06-04 16:12:09 -07004167
Joe Perches189248d2014-01-23 15:54:47 -08004168# if statements using unnecessary parentheses - ie: if ((foo == bar))
4169 if ($^V && $^V ge 5.10.0 &&
4170 $line =~ /\bif\s*((?:\(\s*){2,})/) {
4171 my $openparens = $1;
4172 my $count = $openparens =~ tr@\(@\(@;
4173 my $msg = "";
4174 if ($line =~ /\bif\s*(?:\(\s*){$count,$count}$LvalOrFunc\s*($Compare)\s*$LvalOrFunc(?:\s*\)){$count,$count}/) {
4175 my $comp = $4; #Not $1 because of $LvalOrFunc
4176 $msg = " - maybe == should be = ?" if ($comp eq "==");
4177 WARN("UNNECESSARY_PARENTHESES",
4178 "Unnecessary parentheses$msg\n" . $herecurr);
4179 }
4180 }
4181
Joe Perchesf34e4a42015-04-16 12:44:19 -07004182# Return of what appears to be an errno should normally be negative
4183 if ($sline =~ /\breturn(?:\s*\(+\s*|\s+)(E[A-Z]+)(?:\s*\)+\s*|\s*)[;:,]/) {
Andy Whitcroft53a3c442010-10-26 14:23:14 -07004184 my $name = $1;
4185 if ($name ne 'EOF' && $name ne 'ERROR') {
Joe Perches000d1cc12011-07-25 17:13:25 -07004186 WARN("USE_NEGATIVE_ERRNO",
Joe Perchesf34e4a42015-04-16 12:44:19 -07004187 "return of an errno should typically be negative (ie: return -$1)\n" . $herecurr);
Andy Whitcroft53a3c442010-10-26 14:23:14 -07004188 }
4189 }
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004190
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004191# Need a space before open parenthesis after if, while etc
Joe Perches3705ce52013-07-03 15:05:31 -07004192 if ($line =~ /\b(if|while|for|switch)\(/) {
4193 if (ERROR("SPACING",
4194 "space required before the open parenthesis '('\n" . $herecurr) &&
4195 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07004196 $fixed[$fixlinenr] =~
Joe Perches3705ce52013-07-03 15:05:31 -07004197 s/\b(if|while|for|switch)\(/$1 \(/;
4198 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004199 }
4200
Andy Whitcroftf5fe35d2008-07-23 21:29:03 -07004201# Check for illegal assignment in if conditional -- and check for trailing
4202# statements after the conditional.
Andy Whitcroft170d3a22008-10-15 22:02:30 -07004203 if ($line =~ /do\s*(?!{)/) {
Andy Whitcroft3e469cd2012-01-10 15:10:01 -08004204 ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
4205 ctx_statement_block($linenr, $realcnt, 0)
4206 if (!defined $stat);
Andy Whitcroft170d3a22008-10-15 22:02:30 -07004207 my ($stat_next) = ctx_statement_block($line_nr_next,
4208 $remain_next, $off_next);
4209 $stat_next =~ s/\n./\n /g;
4210 ##print "stat<$stat> stat_next<$stat_next>\n";
4211
4212 if ($stat_next =~ /^\s*while\b/) {
4213 # If the statement carries leading newlines,
4214 # then count those as offsets.
4215 my ($whitespace) =
4216 ($stat_next =~ /^((?:\s*\n[+-])*\s*)/s);
4217 my $offset =
4218 statement_rawlines($whitespace) - 1;
4219
4220 $suppress_whiletrailers{$line_nr_next +
4221 $offset} = 1;
4222 }
4223 }
4224 if (!defined $suppress_whiletrailers{$linenr} &&
Joe Perchesc11230f2013-11-21 14:31:57 -08004225 defined($stat) && defined($cond) &&
Andy Whitcroft170d3a22008-10-15 22:02:30 -07004226 $line =~ /\b(?:if|while|for)\s*\(/ && $line !~ /^.\s*#/) {
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07004227 my ($s, $c) = ($stat, $cond);
Andy Whitcroft8905a672007-11-28 16:21:06 -08004228
Andy Whitcroftb53c8e12009-01-06 14:41:29 -08004229 if ($c =~ /\bif\s*\(.*[^<>!=]=[^=].*/s) {
Joe Perches000d1cc12011-07-25 17:13:25 -07004230 ERROR("ASSIGN_IN_IF",
4231 "do not use assignment in if condition\n" . $herecurr);
Andy Whitcroft8905a672007-11-28 16:21:06 -08004232 }
4233
4234 # Find out what is on the end of the line after the
4235 # conditional.
Andy Whitcroft773647a2008-03-28 14:15:58 -07004236 substr($s, 0, length($c), '');
Andy Whitcroft8905a672007-11-28 16:21:06 -08004237 $s =~ s/\n.*//g;
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004238 $s =~ s/$;//g; # Remove any comments
Andy Whitcroft53210162008-07-23 21:29:03 -07004239 if (length($c) && $s !~ /^\s*{?\s*\\*\s*$/ &&
4240 $c !~ /}\s*while\s*/)
Andy Whitcroft773647a2008-03-28 14:15:58 -07004241 {
Andy Whitcroftbb44ad32008-10-15 22:02:34 -07004242 # Find out how long the conditional actually is.
4243 my @newlines = ($c =~ /\n/gs);
4244 my $cond_lines = 1 + $#newlines;
Hidetoshi Seto42bdf742010-03-05 13:43:50 -08004245 my $stat_real = '';
Andy Whitcroftbb44ad32008-10-15 22:02:34 -07004246
Hidetoshi Seto42bdf742010-03-05 13:43:50 -08004247 $stat_real = raw_line($linenr, $cond_lines)
4248 . "\n" if ($cond_lines);
Andy Whitcroftbb44ad32008-10-15 22:02:34 -07004249 if (defined($stat_real) && $cond_lines > 1) {
4250 $stat_real = "[...]\n$stat_real";
4251 }
4252
Joe Perches000d1cc12011-07-25 17:13:25 -07004253 ERROR("TRAILING_STATEMENTS",
4254 "trailing statements should be on next line\n" . $herecurr . $stat_real);
Andy Whitcroft8905a672007-11-28 16:21:06 -08004255 }
4256 }
4257
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004258# Check for bitwise tests written as boolean
4259 if ($line =~ /
4260 (?:
4261 (?:\[|\(|\&\&|\|\|)
4262 \s*0[xX][0-9]+\s*
4263 (?:\&\&|\|\|)
4264 |
4265 (?:\&\&|\|\|)
4266 \s*0[xX][0-9]+\s*
4267 (?:\&\&|\|\||\)|\])
4268 )/x)
4269 {
Joe Perches000d1cc12011-07-25 17:13:25 -07004270 WARN("HEXADECIMAL_BOOLEAN_TEST",
4271 "boolean test with hexadecimal, perhaps just 1 \& or \|?\n" . $herecurr);
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004272 }
4273
Andy Whitcroft8905a672007-11-28 16:21:06 -08004274# if and else should not have general statements after it
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004275 if ($line =~ /^.\s*(?:}\s*)?else\b(.*)/) {
4276 my $s = $1;
4277 $s =~ s/$;//g; # Remove any comments
4278 if ($s !~ /^\s*(?:\sif|(?:{|)\s*\\?\s*$)/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07004279 ERROR("TRAILING_STATEMENTS",
4280 "trailing statements should be on next line\n" . $herecurr);
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004281 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004282 }
Andy Whitcroft39667782009-01-15 13:51:06 -08004283# if should not continue a brace
4284 if ($line =~ /}\s*if\b/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07004285 ERROR("TRAILING_STATEMENTS",
Rasmus Villemoes048b1232014-08-06 16:10:37 -07004286 "trailing statements should be on next line (or did you mean 'else if'?)\n" .
Andy Whitcroft39667782009-01-15 13:51:06 -08004287 $herecurr);
4288 }
Andy Whitcrofta1080bf2008-10-15 22:02:25 -07004289# case and default should not have general statements after them
4290 if ($line =~ /^.\s*(?:case\s*.*|default\s*):/g &&
4291 $line !~ /\G(?:
Andy Whitcroft3fef12d2008-10-15 22:02:36 -07004292 (?:\s*$;*)(?:\s*{)?(?:\s*$;*)(?:\s*\\)?\s*$|
Andy Whitcrofta1080bf2008-10-15 22:02:25 -07004293 \s*return\s+
4294 )/xg)
4295 {
Joe Perches000d1cc12011-07-25 17:13:25 -07004296 ERROR("TRAILING_STATEMENTS",
4297 "trailing statements should be on next line\n" . $herecurr);
Andy Whitcrofta1080bf2008-10-15 22:02:25 -07004298 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004299
4300 # Check for }<nl>else {, these must be at the same
4301 # indent level to be relevant to each other.
Joe Perches8b8856f2014-08-06 16:11:14 -07004302 if ($prevline=~/}\s*$/ and $line=~/^.\s*else\s*/ &&
4303 $previndent == $indent) {
4304 if (ERROR("ELSE_AFTER_BRACE",
4305 "else should follow close brace '}'\n" . $hereprev) &&
4306 $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
4307 fix_delete_line($fixlinenr - 1, $prevrawline);
4308 fix_delete_line($fixlinenr, $rawline);
4309 my $fixedline = $prevrawline;
4310 $fixedline =~ s/}\s*$//;
4311 if ($fixedline !~ /^\+\s*$/) {
4312 fix_insert_line($fixlinenr, $fixedline);
4313 }
4314 $fixedline = $rawline;
4315 $fixedline =~ s/^(.\s*)else/$1} else/;
4316 fix_insert_line($fixlinenr, $fixedline);
4317 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004318 }
4319
Joe Perches8b8856f2014-08-06 16:11:14 -07004320 if ($prevline=~/}\s*$/ and $line=~/^.\s*while\s*/ &&
4321 $previndent == $indent) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08004322 my ($s, $c) = ctx_statement_block($linenr, $realcnt, 0);
4323
4324 # Find out what is on the end of the line after the
4325 # conditional.
Andy Whitcroft773647a2008-03-28 14:15:58 -07004326 substr($s, 0, length($c), '');
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08004327 $s =~ s/\n.*//g;
4328
4329 if ($s =~ /^\s*;/) {
Joe Perches8b8856f2014-08-06 16:11:14 -07004330 if (ERROR("WHILE_AFTER_BRACE",
4331 "while should follow close brace '}'\n" . $hereprev) &&
4332 $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
4333 fix_delete_line($fixlinenr - 1, $prevrawline);
4334 fix_delete_line($fixlinenr, $rawline);
4335 my $fixedline = $prevrawline;
4336 my $trailing = $rawline;
4337 $trailing =~ s/^\+//;
4338 $trailing = trim($trailing);
4339 $fixedline =~ s/}\s*$/} $trailing/;
4340 fix_insert_line($fixlinenr, $fixedline);
4341 }
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08004342 }
4343 }
4344
Joe Perches95e2c602013-07-03 15:05:20 -07004345#Specific variable tests
Joe Perches323c1262012-12-17 16:02:07 -08004346 while ($line =~ m{($Constant|$Lval)}g) {
4347 my $var = $1;
Joe Perches95e2c602013-07-03 15:05:20 -07004348
4349#gcc binary extension
4350 if ($var =~ /^$Binary$/) {
Joe Perchesd5e616f2013-09-11 14:23:54 -07004351 if (WARN("GCC_BINARY_CONSTANT",
4352 "Avoid gcc v4.3+ binary constant extension: <$var>\n" . $herecurr) &&
4353 $fix) {
4354 my $hexval = sprintf("0x%x", oct($var));
Joe Perches194f66f2014-08-06 16:11:03 -07004355 $fixed[$fixlinenr] =~
Joe Perchesd5e616f2013-09-11 14:23:54 -07004356 s/\b$var\b/$hexval/;
4357 }
Joe Perches95e2c602013-07-03 15:05:20 -07004358 }
4359
4360#CamelCase
Joe Perches807bd262013-07-03 15:05:22 -07004361 if ($var !~ /^$Constant$/ &&
Joe Perchesbe797942013-07-03 15:05:20 -07004362 $var =~ /[A-Z][a-z]|[a-z][A-Z]/ &&
Joe Perches22735ce2013-07-03 15:05:33 -07004363#Ignore Page<foo> variants
Joe Perches807bd262013-07-03 15:05:22 -07004364 $var !~ /^(?:Clear|Set|TestClear|TestSet|)Page[A-Z]/ &&
Joe Perches22735ce2013-07-03 15:05:33 -07004365#Ignore SI style variants like nS, mV and dB (ie: max_uV, regulator_min_uA_show)
Julius Wernerf5123572014-12-10 15:51:54 -08004366 $var !~ /^(?:[a-z_]*?)_?[a-z][A-Z](?:_[a-z_]+)?$/ &&
4367#Ignore some three character SI units explicitly, like MiB and KHz
4368 $var !~ /^(?:[a-z_]*?)_?(?:[KMGT]iB|[KMGT]?Hz)(?:_[a-z_]+)?$/) {
Joe Perches7e781f62013-09-11 14:23:55 -07004369 while ($var =~ m{($Ident)}g) {
4370 my $word = $1;
4371 next if ($word !~ /[A-Z][a-z]|[a-z][A-Z]/);
Joe Perchesd8b07712013-11-12 15:10:06 -08004372 if ($check) {
4373 seed_camelcase_includes();
4374 if (!$file && !$camelcase_file_seeded) {
4375 seed_camelcase_file($realfile);
4376 $camelcase_file_seeded = 1;
4377 }
4378 }
Joe Perches7e781f62013-09-11 14:23:55 -07004379 if (!defined $camelcase{$word}) {
4380 $camelcase{$word} = 1;
4381 CHK("CAMELCASE",
4382 "Avoid CamelCase: <$word>\n" . $herecurr);
4383 }
Joe Perches34456862013-07-03 15:05:34 -07004384 }
Joe Perches323c1262012-12-17 16:02:07 -08004385 }
4386 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004387
4388#no spaces allowed after \ in define
Joe Perchesd5e616f2013-09-11 14:23:54 -07004389 if ($line =~ /\#\s*define.*\\\s+$/) {
4390 if (WARN("WHITESPACE_AFTER_LINE_CONTINUATION",
4391 "Whitespace after \\ makes next lines useless\n" . $herecurr) &&
4392 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07004393 $fixed[$fixlinenr] =~ s/\s+$//;
Joe Perchesd5e616f2013-09-11 14:23:54 -07004394 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004395 }
4396
Fabian Frederick0e212e02015-04-16 12:44:25 -07004397# warn if <asm/foo.h> is #included and <linux/foo.h> is available and includes
4398# itself <asm/foo.h> (uses RAW line)
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004399 if ($tree && $rawline =~ m{^.\s*\#\s*include\s*\<asm\/(.*)\.h\>}) {
Andy Whitcrofte09dec42008-10-15 22:02:20 -07004400 my $file = "$1.h";
4401 my $checkfile = "include/linux/$file";
4402 if (-f "$root/$checkfile" &&
4403 $realfile ne $checkfile &&
Wolfram Sang7840a942010-08-09 17:20:57 -07004404 $1 !~ /$allowed_asm_includes/)
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004405 {
Fabian Frederick0e212e02015-04-16 12:44:25 -07004406 my $asminclude = `grep -Ec "#include\\s+<asm/$file>" $root/$checkfile`;
4407 if ($asminclude > 0) {
4408 if ($realfile =~ m{^arch/}) {
4409 CHK("ARCH_INCLUDE_LINUX",
4410 "Consider using #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
4411 } else {
4412 WARN("INCLUDE_LINUX",
4413 "Use #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
4414 }
Andy Whitcrofte09dec42008-10-15 22:02:20 -07004415 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004416 }
4417 }
4418
Andy Whitcroft653d4872007-06-23 17:16:34 -07004419# multi-statement macros should be enclosed in a do while loop, grab the
4420# first statement and ensure its the whole macro if its not enclosed
Andy Whitcroftcf655042008-03-04 14:28:20 -08004421# in a known good container
Andy Whitcroftb8f96a32008-07-23 21:29:07 -07004422 if ($realfile !~ m@/vmlinux.lds.h$@ &&
4423 $line =~ /^.\s*\#\s*define\s*$Ident(\()?/) {
Andy Whitcroftd8aaf122007-06-23 17:16:44 -07004424 my $ln = $linenr;
4425 my $cnt = $realcnt;
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004426 my ($off, $dstat, $dcond, $rest);
4427 my $ctx = '';
Joe Perches08a28432014-10-13 15:51:55 -07004428 my $has_flow_statement = 0;
4429 my $has_arg_concat = 0;
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004430 ($dstat, $dcond, $ln, $cnt, $off) =
Andy Whitcroftf74bd192012-01-10 15:09:54 -08004431 ctx_statement_block($linenr, $realcnt, 0);
4432 $ctx = $dstat;
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004433 #print "dstat<$dstat> dcond<$dcond> cnt<$cnt> off<$off>\n";
Andy Whitcrofta3bb97a2008-07-23 21:29:00 -07004434 #print "LINE<$lines[$ln-1]> len<" . length($lines[$ln-1]) . "\n";
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004435
Joe Perches08a28432014-10-13 15:51:55 -07004436 $has_flow_statement = 1 if ($ctx =~ /\b(goto|return)\b/);
4437 $has_arg_concat = 1 if ($ctx =~ /\#\#/);
4438
Andy Whitcroftf74bd192012-01-10 15:09:54 -08004439 $dstat =~ s/^.\s*\#\s*define\s+$Ident(?:\([^\)]*\))?\s*//;
Andy Whitcroft292f1a92008-07-23 21:29:11 -07004440 $dstat =~ s/$;//g;
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004441 $dstat =~ s/\\\n.//g;
4442 $dstat =~ s/^\s*//s;
4443 $dstat =~ s/\s*$//s;
4444
4445 # Flatten any parentheses and braces
Andy Whitcroftbf30d6e2008-10-15 22:02:33 -07004446 while ($dstat =~ s/\([^\(\)]*\)/1/ ||
4447 $dstat =~ s/\{[^\{\}]*\}/1/ ||
Andy Whitcroftc81769f2012-01-10 15:10:10 -08004448 $dstat =~ s/\[[^\[\]]*\]/1/)
Andy Whitcroftbf30d6e2008-10-15 22:02:33 -07004449 {
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07004450 }
Andy Whitcroftd8aaf122007-06-23 17:16:44 -07004451
Andy Whitcrofte45bab82012-03-23 15:02:18 -07004452 # Flatten any obvious string concatentation.
Joe Perches33acb542015-06-25 15:02:54 -07004453 while ($dstat =~ s/($String)\s*$Ident/$1/ ||
4454 $dstat =~ s/$Ident\s*($String)/$1/)
Andy Whitcrofte45bab82012-03-23 15:02:18 -07004455 {
4456 }
4457
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004458 my $exceptions = qr{
4459 $Declare|
4460 module_param_named|
Kees Cooka0a0a7a2012-10-04 17:13:38 -07004461 MODULE_PARM_DESC|
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004462 DECLARE_PER_CPU|
4463 DEFINE_PER_CPU|
Andy Whitcroft383099f2009-01-06 14:41:18 -08004464 __typeof__\(|
Stefani Seibold22fd2d32010-03-05 13:43:52 -08004465 union|
4466 struct|
Andy Whitcroftea71a0a2009-09-21 17:04:38 -07004467 \.$Ident\s*=\s*|
4468 ^\"|\"$
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004469 }x;
Andy Whitcroft5eaa20b2010-10-26 14:23:18 -07004470 #print "REST<$rest> dstat<$dstat> ctx<$ctx>\n";
Andy Whitcroftf74bd192012-01-10 15:09:54 -08004471 if ($dstat ne '' &&
4472 $dstat !~ /^(?:$Ident|-?$Constant),$/ && # 10, // foo(),
4473 $dstat !~ /^(?:$Ident|-?$Constant);$/ && # foo();
Joe Perches3cc4b1c2013-07-03 15:05:27 -07004474 $dstat !~ /^[!~-]?(?:$Lval|$Constant)$/ && # 10 // foo() // !foo // ~foo // -foo // foo->bar // foo.bar->baz
Joe Perches356fd392014-08-06 16:10:31 -07004475 $dstat !~ /^'X'$/ && $dstat !~ /^'XX'$/ && # character constants
Andy Whitcroftf74bd192012-01-10 15:09:54 -08004476 $dstat !~ /$exceptions/ &&
4477 $dstat !~ /^\.$Ident\s*=/ && # .foo =
Joe Perchese942e2c2013-04-17 15:58:26 -07004478 $dstat !~ /^(?:\#\s*$Ident|\#\s*$Constant)\s*$/ && # stringification #foo
Andy Whitcroft72f115f2012-01-10 15:10:06 -08004479 $dstat !~ /^do\s*$Constant\s*while\s*$Constant;?$/ && # do {...} while (...); // do {...} while (...)
Andy Whitcroftf74bd192012-01-10 15:09:54 -08004480 $dstat !~ /^for\s*$Constant$/ && # for (...)
4481 $dstat !~ /^for\s*$Constant\s+(?:$Ident|-?$Constant)$/ && # for (...) bar()
4482 $dstat !~ /^do\s*{/ && # do {...
Joe Perchesf95a7e62013-09-11 14:24:00 -07004483 $dstat !~ /^\({/ && # ({...
4484 $ctx !~ /^.\s*#\s*define\s+TRACE_(?:SYSTEM|INCLUDE_FILE|INCLUDE_PATH)\b/)
Andy Whitcroftf74bd192012-01-10 15:09:54 -08004485 {
4486 $ctx =~ s/\n*$//;
4487 my $herectx = $here . "\n";
4488 my $cnt = statement_rawlines($ctx);
4489
4490 for (my $n = 0; $n < $cnt; $n++) {
4491 $herectx .= raw_line($linenr, $n) . "\n";
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004492 }
4493
Andy Whitcroftf74bd192012-01-10 15:09:54 -08004494 if ($dstat =~ /;/) {
4495 ERROR("MULTISTATEMENT_MACRO_USE_DO_WHILE",
4496 "Macros with multiple statements should be enclosed in a do - while loop\n" . "$herectx");
4497 } else {
Joe Perches000d1cc12011-07-25 17:13:25 -07004498 ERROR("COMPLEX_MACRO",
Andrew Morton388982b2014-10-13 15:51:40 -07004499 "Macros with complex values should be enclosed in parentheses\n" . "$herectx");
Andy Whitcroftd8aaf122007-06-23 17:16:44 -07004500 }
Andy Whitcroft653d4872007-06-23 17:16:34 -07004501 }
Joe Perches5023d342012-12-17 16:01:47 -08004502
Joe Perches08a28432014-10-13 15:51:55 -07004503# check for macros with flow control, but without ## concatenation
4504# ## concatenation is commonly a macro that defines a function so ignore those
4505 if ($has_flow_statement && !$has_arg_concat) {
4506 my $herectx = $here . "\n";
4507 my $cnt = statement_rawlines($ctx);
4508
4509 for (my $n = 0; $n < $cnt; $n++) {
4510 $herectx .= raw_line($linenr, $n) . "\n";
4511 }
4512 WARN("MACRO_WITH_FLOW_CONTROL",
4513 "Macros with flow control statements should be avoided\n" . "$herectx");
4514 }
4515
Joe Perches481eb482012-12-17 16:01:56 -08004516# check for line continuations outside of #defines, preprocessor #, and asm
Joe Perches5023d342012-12-17 16:01:47 -08004517
4518 } else {
4519 if ($prevline !~ /^..*\\$/ &&
Joe Perches481eb482012-12-17 16:01:56 -08004520 $line !~ /^\+\s*\#.*\\$/ && # preprocessor
4521 $line !~ /^\+.*\b(__asm__|asm)\b.*\\$/ && # asm
Joe Perches5023d342012-12-17 16:01:47 -08004522 $line =~ /^\+.*\\$/) {
4523 WARN("LINE_CONTINUATIONS",
4524 "Avoid unnecessary line continuations\n" . $herecurr);
4525 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07004526 }
4527
Joe Perchesb13edf72012-07-30 14:41:24 -07004528# do {} while (0) macro tests:
4529# single-statement macros do not need to be enclosed in do while (0) loop,
4530# macro should not end with a semicolon
4531 if ($^V && $^V ge 5.10.0 &&
4532 $realfile !~ m@/vmlinux.lds.h$@ &&
4533 $line =~ /^.\s*\#\s*define\s+$Ident(\()?/) {
4534 my $ln = $linenr;
4535 my $cnt = $realcnt;
4536 my ($off, $dstat, $dcond, $rest);
4537 my $ctx = '';
4538 ($dstat, $dcond, $ln, $cnt, $off) =
4539 ctx_statement_block($linenr, $realcnt, 0);
4540 $ctx = $dstat;
4541
4542 $dstat =~ s/\\\n.//g;
Joe Perches1b36b202015-02-13 14:38:32 -08004543 $dstat =~ s/$;/ /g;
Joe Perchesb13edf72012-07-30 14:41:24 -07004544
4545 if ($dstat =~ /^\+\s*#\s*define\s+$Ident\s*${balanced_parens}\s*do\s*{(.*)\s*}\s*while\s*\(\s*0\s*\)\s*([;\s]*)\s*$/) {
4546 my $stmts = $2;
4547 my $semis = $3;
4548
4549 $ctx =~ s/\n*$//;
4550 my $cnt = statement_rawlines($ctx);
4551 my $herectx = $here . "\n";
4552
4553 for (my $n = 0; $n < $cnt; $n++) {
4554 $herectx .= raw_line($linenr, $n) . "\n";
4555 }
4556
Joe Perchesac8e97f2012-08-21 16:15:53 -07004557 if (($stmts =~ tr/;/;/) == 1 &&
4558 $stmts !~ /^\s*(if|while|for|switch)\b/) {
Joe Perchesb13edf72012-07-30 14:41:24 -07004559 WARN("SINGLE_STATEMENT_DO_WHILE_MACRO",
4560 "Single statement macros should not use a do {} while (0) loop\n" . "$herectx");
4561 }
4562 if (defined $semis && $semis ne "") {
4563 WARN("DO_WHILE_MACRO_WITH_TRAILING_SEMICOLON",
4564 "do {} while (0) macros should not be semicolon terminated\n" . "$herectx");
4565 }
Joe Perchesf5ef95b2014-06-04 16:12:06 -07004566 } elsif ($dstat =~ /^\+\s*#\s*define\s+$Ident.*;\s*$/) {
4567 $ctx =~ s/\n*$//;
4568 my $cnt = statement_rawlines($ctx);
4569 my $herectx = $here . "\n";
4570
4571 for (my $n = 0; $n < $cnt; $n++) {
4572 $herectx .= raw_line($linenr, $n) . "\n";
4573 }
4574
4575 WARN("TRAILING_SEMICOLON",
4576 "macros should not use a trailing semicolon\n" . "$herectx");
Joe Perchesb13edf72012-07-30 14:41:24 -07004577 }
4578 }
4579
Mike Frysinger080ba922009-01-06 14:41:25 -08004580# make sure symbols are always wrapped with VMLINUX_SYMBOL() ...
4581# all assignments may have only one of the following with an assignment:
4582# .
4583# ALIGN(...)
4584# VMLINUX_SYMBOL(...)
4585 if ($realfile eq 'vmlinux.lds.h' && $line =~ /(?:(?:^|\s)$Ident\s*=|=\s*$Ident(?:\s|$))/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07004586 WARN("MISSING_VMLINUX_SYMBOL",
4587 "vmlinux.lds.h needs VMLINUX_SYMBOL() around C-visible symbols\n" . $herecurr);
Mike Frysinger080ba922009-01-06 14:41:25 -08004588 }
4589
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07004590# check for redundant bracing round if etc
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004591 if ($line =~ /(^.*)\bif\b/ && $1 !~ /else\s*$/) {
4592 my ($level, $endln, @chunks) =
Andy Whitcroftcf655042008-03-04 14:28:20 -08004593 ctx_statement_full($linenr, $realcnt, 1);
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004594 #print "chunks<$#chunks> linenr<$linenr> endln<$endln> level<$level>\n";
Andy Whitcroftcf655042008-03-04 14:28:20 -08004595 #print "APW: <<$chunks[1][0]>><<$chunks[1][1]>>\n";
4596 if ($#chunks > 0 && $level == 0) {
Joe Perchesaad4f612012-03-23 15:02:19 -07004597 my @allowed = ();
4598 my $allow = 0;
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004599 my $seen = 0;
Andy Whitcroft773647a2008-03-28 14:15:58 -07004600 my $herectx = $here . "\n";
Andy Whitcroftcf655042008-03-04 14:28:20 -08004601 my $ln = $linenr - 1;
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004602 for my $chunk (@chunks) {
4603 my ($cond, $block) = @{$chunk};
4604
Andy Whitcroft773647a2008-03-28 14:15:58 -07004605 # If the condition carries leading newlines, then count those as offsets.
4606 my ($whitespace) = ($cond =~ /^((?:\s*\n[+-])*\s*)/s);
4607 my $offset = statement_rawlines($whitespace) - 1;
4608
Joe Perchesaad4f612012-03-23 15:02:19 -07004609 $allowed[$allow] = 0;
Andy Whitcroft773647a2008-03-28 14:15:58 -07004610 #print "COND<$cond> whitespace<$whitespace> offset<$offset>\n";
4611
4612 # We have looked at and allowed this specific line.
4613 $suppress_ifbraces{$ln + $offset} = 1;
4614
4615 $herectx .= "$rawlines[$ln + $offset]\n[...]\n";
Andy Whitcroftcf655042008-03-04 14:28:20 -08004616 $ln += statement_rawlines($block) - 1;
4617
Andy Whitcroft773647a2008-03-28 14:15:58 -07004618 substr($block, 0, length($cond), '');
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004619
4620 $seen++ if ($block =~ /^\s*{/);
4621
Joe Perchesaad4f612012-03-23 15:02:19 -07004622 #print "cond<$cond> block<$block> allowed<$allowed[$allow]>\n";
Andy Whitcroftcf655042008-03-04 14:28:20 -08004623 if (statement_lines($cond) > 1) {
4624 #print "APW: ALLOWED: cond<$cond>\n";
Joe Perchesaad4f612012-03-23 15:02:19 -07004625 $allowed[$allow] = 1;
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004626 }
4627 if ($block =~/\b(?:if|for|while)\b/) {
Andy Whitcroftcf655042008-03-04 14:28:20 -08004628 #print "APW: ALLOWED: block<$block>\n";
Joe Perchesaad4f612012-03-23 15:02:19 -07004629 $allowed[$allow] = 1;
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004630 }
Andy Whitcroftcf655042008-03-04 14:28:20 -08004631 if (statement_block_size($block) > 1) {
4632 #print "APW: ALLOWED: lines block<$block>\n";
Joe Perchesaad4f612012-03-23 15:02:19 -07004633 $allowed[$allow] = 1;
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004634 }
Joe Perchesaad4f612012-03-23 15:02:19 -07004635 $allow++;
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004636 }
Joe Perchesaad4f612012-03-23 15:02:19 -07004637 if ($seen) {
4638 my $sum_allowed = 0;
4639 foreach (@allowed) {
4640 $sum_allowed += $_;
4641 }
4642 if ($sum_allowed == 0) {
4643 WARN("BRACES",
4644 "braces {} are not necessary for any arm of this statement\n" . $herectx);
4645 } elsif ($sum_allowed != $allow &&
4646 $seen != $allow) {
4647 CHK("BRACES",
4648 "braces {} should be used on all arms of this statement\n" . $herectx);
4649 }
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004650 }
4651 }
4652 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07004653 if (!defined $suppress_ifbraces{$linenr - 1} &&
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004654 $line =~ /\b(if|while|for|else)\b/) {
Andy Whitcroftcf655042008-03-04 14:28:20 -08004655 my $allowed = 0;
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07004656
Andy Whitcroftcf655042008-03-04 14:28:20 -08004657 # Check the pre-context.
4658 if (substr($line, 0, $-[0]) =~ /(\}\s*)$/) {
4659 #print "APW: ALLOWED: pre<$1>\n";
4660 $allowed = 1;
4661 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07004662
4663 my ($level, $endln, @chunks) =
4664 ctx_statement_full($linenr, $realcnt, $-[0]);
4665
Andy Whitcroftcf655042008-03-04 14:28:20 -08004666 # Check the condition.
4667 my ($cond, $block) = @{$chunks[0]};
Andy Whitcroft773647a2008-03-28 14:15:58 -07004668 #print "CHECKING<$linenr> cond<$cond> block<$block>\n";
Andy Whitcroftcf655042008-03-04 14:28:20 -08004669 if (defined $cond) {
Andy Whitcroft773647a2008-03-28 14:15:58 -07004670 substr($block, 0, length($cond), '');
Andy Whitcroftcf655042008-03-04 14:28:20 -08004671 }
4672 if (statement_lines($cond) > 1) {
4673 #print "APW: ALLOWED: cond<$cond>\n";
4674 $allowed = 1;
4675 }
4676 if ($block =~/\b(?:if|for|while)\b/) {
4677 #print "APW: ALLOWED: block<$block>\n";
4678 $allowed = 1;
4679 }
4680 if (statement_block_size($block) > 1) {
4681 #print "APW: ALLOWED: lines block<$block>\n";
4682 $allowed = 1;
4683 }
4684 # Check the post-context.
4685 if (defined $chunks[1]) {
4686 my ($cond, $block) = @{$chunks[1]};
4687 if (defined $cond) {
Andy Whitcroft773647a2008-03-28 14:15:58 -07004688 substr($block, 0, length($cond), '');
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07004689 }
Andy Whitcroftcf655042008-03-04 14:28:20 -08004690 if ($block =~ /^\s*\{/) {
4691 #print "APW: ALLOWED: chunk-1 block<$block>\n";
4692 $allowed = 1;
4693 }
4694 }
4695 if ($level == 0 && $block =~ /^\s*\{/ && !$allowed) {
Justin P. Mattock69932482011-07-26 23:06:29 -07004696 my $herectx = $here . "\n";
Andy Whitcroftf0556632008-10-15 22:02:23 -07004697 my $cnt = statement_rawlines($block);
Andy Whitcroftcf655042008-03-04 14:28:20 -08004698
Andy Whitcroftf0556632008-10-15 22:02:23 -07004699 for (my $n = 0; $n < $cnt; $n++) {
Justin P. Mattock69932482011-07-26 23:06:29 -07004700 $herectx .= raw_line($linenr, $n) . "\n";
Andy Whitcroftcf655042008-03-04 14:28:20 -08004701 }
4702
Joe Perches000d1cc12011-07-25 17:13:25 -07004703 WARN("BRACES",
4704 "braces {} are not necessary for single statement blocks\n" . $herectx);
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07004705 }
4706 }
4707
Joe Perches0979ae62012-12-17 16:01:59 -08004708# check for unnecessary blank lines around braces
Joe Perches77b9a532013-07-03 15:05:29 -07004709 if (($line =~ /^.\s*}\s*$/ && $prevrawline =~ /^.\s*$/)) {
Joe Perchesf8e58212015-02-13 14:38:46 -08004710 if (CHK("BRACES",
4711 "Blank lines aren't necessary before a close brace '}'\n" . $hereprev) &&
4712 $fix && $prevrawline =~ /^\+/) {
4713 fix_delete_line($fixlinenr - 1, $prevrawline);
4714 }
Joe Perches0979ae62012-12-17 16:01:59 -08004715 }
Joe Perches77b9a532013-07-03 15:05:29 -07004716 if (($rawline =~ /^.\s*$/ && $prevline =~ /^..*{\s*$/)) {
Joe Perchesf8e58212015-02-13 14:38:46 -08004717 if (CHK("BRACES",
4718 "Blank lines aren't necessary after an open brace '{'\n" . $hereprev) &&
4719 $fix) {
4720 fix_delete_line($fixlinenr, $rawline);
4721 }
Joe Perches0979ae62012-12-17 16:01:59 -08004722 }
4723
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07004724# no volatiles please
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07004725 my $asm_volatile = qr{\b(__asm__|asm)\s+(__volatile__|volatile)\b};
4726 if ($line =~ /\bvolatile\b/ && $line !~ /$asm_volatile/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07004727 WARN("VOLATILE",
4728 "Use of volatile is usually wrong: see Documentation/volatile-considered-harmful.txt\n" . $herecurr);
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07004729 }
4730
Joe Perches5e4f6ba2014-12-10 15:52:05 -08004731# Check for user-visible strings broken across lines, which breaks the ability
4732# to grep for the string. Make exceptions when the previous string ends in a
4733# newline (multiple lines in one string constant) or '\t', '\r', ';', or '{'
4734# (common in inline assembly) or is a octal \123 or hexadecimal \xaf value
Joe Perches33acb542015-06-25 15:02:54 -07004735 if ($line =~ /^\+\s*$String/ &&
Joe Perches5e4f6ba2014-12-10 15:52:05 -08004736 $prevline =~ /"\s*$/ &&
4737 $prevrawline !~ /(?:\\(?:[ntr]|[0-7]{1,3}|x[0-9a-fA-F]{1,2})|;\s*|\{\s*)"\s*$/) {
4738 if (WARN("SPLIT_STRING",
4739 "quoted string split across lines\n" . $hereprev) &&
4740 $fix &&
4741 $prevrawline =~ /^\+.*"\s*$/ &&
4742 $last_coalesced_string_linenr != $linenr - 1) {
4743 my $extracted_string = get_quoted_string($line, $rawline);
4744 my $comma_close = "";
4745 if ($rawline =~ /\Q$extracted_string\E(\s*\)\s*;\s*$|\s*,\s*)/) {
4746 $comma_close = $1;
4747 }
4748
4749 fix_delete_line($fixlinenr - 1, $prevrawline);
4750 fix_delete_line($fixlinenr, $rawline);
4751 my $fixedline = $prevrawline;
4752 $fixedline =~ s/"\s*$//;
4753 $fixedline .= substr($extracted_string, 1) . trim($comma_close);
4754 fix_insert_line($fixlinenr - 1, $fixedline);
4755 $fixedline = $rawline;
4756 $fixedline =~ s/\Q$extracted_string\E\Q$comma_close\E//;
4757 if ($fixedline !~ /\+\s*$/) {
4758 fix_insert_line($fixlinenr, $fixedline);
4759 }
4760 $last_coalesced_string_linenr = $linenr;
4761 }
4762 }
4763
4764# check for missing a space in a string concatenation
4765 if ($prevrawline =~ /[^\\]\w"$/ && $rawline =~ /^\+[\t ]+"\w/) {
4766 WARN('MISSING_SPACE',
4767 "break quoted strings at a space character\n" . $hereprev);
4768 }
4769
4770# check for spaces before a quoted newline
4771 if ($rawline =~ /^.*\".*\s\\n/) {
4772 if (WARN("QUOTED_WHITESPACE_BEFORE_NEWLINE",
4773 "unnecessary whitespace before a quoted newline\n" . $herecurr) &&
4774 $fix) {
4775 $fixed[$fixlinenr] =~ s/^(\+.*\".*)\s+\\n/$1\\n/;
4776 }
4777
4778 }
4779
Joe Perchesf17dba42014-10-13 15:51:51 -07004780# concatenated string without spaces between elements
Joe Perches33acb542015-06-25 15:02:54 -07004781 if ($line =~ /$String[A-Z_]/ || $line =~ /[A-Za-z0-9_]$String/) {
Joe Perchesf17dba42014-10-13 15:51:51 -07004782 CHK("CONCATENATED_STRING",
4783 "Concatenated strings should use spaces between elements\n" . $herecurr);
4784 }
4785
Joe Perches90ad30e2014-12-10 15:51:59 -08004786# uncoalesced string fragments
Joe Perches33acb542015-06-25 15:02:54 -07004787 if ($line =~ /$String\s*"/) {
Joe Perches90ad30e2014-12-10 15:51:59 -08004788 WARN("STRING_FRAGMENTS",
4789 "Consecutive strings are generally better as a single string\n" . $herecurr);
4790 }
4791
Joe Perches5e4f6ba2014-12-10 15:52:05 -08004792# check for %L{u,d,i} in strings
4793 my $string;
4794 while ($line =~ /(?:^|")([X\t]*)(?:"|$)/g) {
4795 $string = substr($rawline, $-[1], $+[1] - $-[1]);
4796 $string =~ s/%%/__/g;
4797 if ($string =~ /(?<!%)%L[udi]/) {
4798 WARN("PRINTF_L",
4799 "\%Ld/%Lu are not-standard C, use %lld/%llu\n" . $herecurr);
4800 last;
4801 }
4802 }
4803
4804# check for line continuations in quoted strings with odd counts of "
4805 if ($rawline =~ /\\$/ && $rawline =~ tr/"/"/ % 2) {
4806 WARN("LINE_CONTINUATIONS",
4807 "Avoid line continuations in quoted strings\n" . $herecurr);
4808 }
4809
Andy Whitcroft00df3442007-06-08 13:47:06 -07004810# warn about #if 0
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004811 if ($line =~ /^.\s*\#\s*if\s+0\b/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07004812 CHK("REDUNDANT_CODE",
4813 "if this code is redundant consider removing it\n" .
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07004814 $herecurr);
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07004815 }
4816
Andy Whitcroft03df4b52012-12-17 16:01:52 -08004817# check for needless "if (<foo>) fn(<foo>)" uses
4818 if ($prevline =~ /\bif\s*\(\s*($Lval)\s*\)/) {
4819 my $expr = '\s*\(\s*' . quotemeta($1) . '\s*\)\s*;';
4820 if ($line =~ /\b(kfree|usb_free_urb|debugfs_remove(?:_recursive)?)$expr/) {
4821 WARN('NEEDLESS_IF',
Fabio Estevam15160f92014-12-10 15:51:40 -08004822 "$1(NULL) is safe and this check is probably not required\n" . $hereprev);
Greg Kroah-Hartman4c432a82008-07-23 21:29:04 -07004823 }
4824 }
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07004825
Joe Perchesebfdc402014-08-06 16:10:27 -07004826# check for unnecessary "Out of Memory" messages
4827 if ($line =~ /^\+.*\b$logFunctions\s*\(/ &&
4828 $prevline =~ /^[ \+]\s*if\s*\(\s*(\!\s*|NULL\s*==\s*)?($Lval)(\s*==\s*NULL\s*)?\s*\)/ &&
4829 (defined $1 || defined $3) &&
4830 $linenr > 3) {
4831 my $testval = $2;
4832 my $testline = $lines[$linenr - 3];
4833
4834 my ($s, $c) = ctx_statement_block($linenr - 3, $realcnt, 0);
4835# print("line: <$line>\nprevline: <$prevline>\ns: <$s>\nc: <$c>\n\n\n");
4836
4837 if ($c =~ /(?:^|\n)[ \+]\s*(?:$Type\s*)?\Q$testval\E\s*=\s*(?:\([^\)]*\)\s*)?\s*(?:devm_)?(?:[kv][czm]alloc(?:_node|_array)?\b|kstrdup|(?:dev_)?alloc_skb)/) {
4838 WARN("OOM_MESSAGE",
4839 "Possible unnecessary 'out of memory' message\n" . $hereprev);
4840 }
4841 }
4842
Joe Perchesf78d98f2014-10-13 15:52:01 -07004843# check for logging functions with KERN_<LEVEL>
Paolo Bonzinidcaf1122015-02-13 14:38:26 -08004844 if ($line !~ /printk(?:_ratelimited|_once)?\s*\(/ &&
Joe Perchesf78d98f2014-10-13 15:52:01 -07004845 $line =~ /\b$logFunctions\s*\(.*\b(KERN_[A-Z]+)\b/) {
4846 my $level = $1;
4847 if (WARN("UNNECESSARY_KERN_LEVEL",
4848 "Possible unnecessary $level\n" . $herecurr) &&
4849 $fix) {
4850 $fixed[$fixlinenr] =~ s/\s*$level\s*//;
4851 }
4852 }
4853
Joe Perchesabb08a52014-12-10 15:51:46 -08004854# check for mask then right shift without a parentheses
4855 if ($^V && $^V ge 5.10.0 &&
4856 $line =~ /$LvalOrFunc\s*\&\s*($LvalOrFunc)\s*>>/ &&
4857 $4 !~ /^\&/) { # $LvalOrFunc may be &foo, ignore if so
4858 WARN("MASK_THEN_SHIFT",
4859 "Possible precedence defect with mask then right shift - may need parentheses\n" . $herecurr);
4860 }
4861
Joe Perchesb75ac612014-12-10 15:52:02 -08004862# check for pointer comparisons to NULL
4863 if ($^V && $^V ge 5.10.0) {
4864 while ($line =~ /\b$LvalOrFunc\s*(==|\!=)\s*NULL\b/g) {
4865 my $val = $1;
4866 my $equal = "!";
4867 $equal = "" if ($4 eq "!=");
4868 if (CHK("COMPARISON_TO_NULL",
4869 "Comparison to NULL could be written \"${equal}${val}\"\n" . $herecurr) &&
4870 $fix) {
4871 $fixed[$fixlinenr] =~ s/\b\Q$val\E\s*(?:==|\!=)\s*NULL\b/$equal$val/;
4872 }
4873 }
4874 }
4875
Joe Perches8716de32013-09-11 14:24:05 -07004876# check for bad placement of section $InitAttribute (e.g.: __initdata)
4877 if ($line =~ /(\b$InitAttribute\b)/) {
4878 my $attr = $1;
4879 if ($line =~ /^\+\s*static\s+(?:const\s+)?(?:$attr\s+)?($NonptrTypeWithAttr)\s+(?:$attr\s+)?($Ident(?:\[[^]]*\])?)\s*[=;]/) {
4880 my $ptr = $1;
4881 my $var = $2;
4882 if ((($ptr =~ /\b(union|struct)\s+$attr\b/ &&
4883 ERROR("MISPLACED_INIT",
4884 "$attr should be placed after $var\n" . $herecurr)) ||
4885 ($ptr !~ /\b(union|struct)\s+$attr\b/ &&
4886 WARN("MISPLACED_INIT",
4887 "$attr should be placed after $var\n" . $herecurr))) &&
4888 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07004889 $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 -07004890 }
4891 }
4892 }
4893
Joe Perchese970b882013-11-12 15:10:10 -08004894# check for $InitAttributeData (ie: __initdata) with const
4895 if ($line =~ /\bconst\b/ && $line =~ /($InitAttributeData)/) {
4896 my $attr = $1;
4897 $attr =~ /($InitAttributePrefix)(.*)/;
4898 my $attr_prefix = $1;
4899 my $attr_type = $2;
4900 if (ERROR("INIT_ATTRIBUTE",
4901 "Use of const init definition must use ${attr_prefix}initconst\n" . $herecurr) &&
4902 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07004903 $fixed[$fixlinenr] =~
Joe Perchese970b882013-11-12 15:10:10 -08004904 s/$InitAttributeData/${attr_prefix}initconst/;
4905 }
4906 }
4907
4908# check for $InitAttributeConst (ie: __initconst) without const
4909 if ($line !~ /\bconst\b/ && $line =~ /($InitAttributeConst)/) {
4910 my $attr = $1;
4911 if (ERROR("INIT_ATTRIBUTE",
4912 "Use of $attr requires a separate use of const\n" . $herecurr) &&
4913 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07004914 my $lead = $fixed[$fixlinenr] =~
Joe Perchese970b882013-11-12 15:10:10 -08004915 /(^\+\s*(?:static\s+))/;
4916 $lead = rtrim($1);
4917 $lead = "$lead " if ($lead !~ /^\+$/);
4918 $lead = "${lead}const ";
Joe Perches194f66f2014-08-06 16:11:03 -07004919 $fixed[$fixlinenr] =~ s/(^\+\s*(?:static\s+))/$lead/;
Joe Perchese970b882013-11-12 15:10:10 -08004920 }
4921 }
4922
Joe Perchesc17893c2015-04-16 12:44:42 -07004923# check for __read_mostly with const non-pointer (should just be const)
4924 if ($line =~ /\b__read_mostly\b/ &&
4925 $line =~ /($Type)\s*$Ident/ && $1 !~ /\*\s*$/ && $1 =~ /\bconst\b/) {
4926 if (ERROR("CONST_READ_MOSTLY",
4927 "Invalid use of __read_mostly with const type\n" . $herecurr) &&
4928 $fix) {
4929 $fixed[$fixlinenr] =~ s/\s+__read_mostly\b//;
4930 }
4931 }
4932
Joe Perchesfbdb8132014-04-03 14:49:14 -07004933# don't use __constant_<foo> functions outside of include/uapi/
4934 if ($realfile !~ m@^include/uapi/@ &&
4935 $line =~ /(__constant_(?:htons|ntohs|[bl]e(?:16|32|64)_to_cpu|cpu_to_[bl]e(?:16|32|64)))\s*\(/) {
4936 my $constant_func = $1;
4937 my $func = $constant_func;
4938 $func =~ s/^__constant_//;
4939 if (WARN("CONSTANT_CONVERSION",
4940 "$constant_func should be $func\n" . $herecurr) &&
4941 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07004942 $fixed[$fixlinenr] =~ s/\b$constant_func\b/$func/g;
Joe Perchesfbdb8132014-04-03 14:49:14 -07004943 }
4944 }
4945
Patrick Pannuto1a15a252010-08-09 17:21:01 -07004946# prefer usleep_range over udelay
Bruce Allan37581c22013-02-21 16:44:19 -08004947 if ($line =~ /\budelay\s*\(\s*(\d+)\s*\)/) {
Joe Perches43c1d772014-04-03 14:49:11 -07004948 my $delay = $1;
Patrick Pannuto1a15a252010-08-09 17:21:01 -07004949 # ignore udelay's < 10, however
Joe Perches43c1d772014-04-03 14:49:11 -07004950 if (! ($delay < 10) ) {
Joe Perches000d1cc12011-07-25 17:13:25 -07004951 CHK("USLEEP_RANGE",
Joe Perches43c1d772014-04-03 14:49:11 -07004952 "usleep_range is preferred over udelay; see Documentation/timers/timers-howto.txt\n" . $herecurr);
4953 }
4954 if ($delay > 2000) {
4955 WARN("LONG_UDELAY",
4956 "long udelay - prefer mdelay; see arch/arm/include/asm/delay.h\n" . $herecurr);
Patrick Pannuto1a15a252010-08-09 17:21:01 -07004957 }
4958 }
4959
Patrick Pannuto09ef8722010-08-09 17:21:02 -07004960# warn about unexpectedly long msleep's
4961 if ($line =~ /\bmsleep\s*\((\d+)\);/) {
4962 if ($1 < 20) {
Joe Perches000d1cc12011-07-25 17:13:25 -07004963 WARN("MSLEEP",
Joe Perches43c1d772014-04-03 14:49:11 -07004964 "msleep < 20ms can sleep for up to 20ms; see Documentation/timers/timers-howto.txt\n" . $herecurr);
Patrick Pannuto09ef8722010-08-09 17:21:02 -07004965 }
4966 }
4967
Joe Perches36ec1932013-07-03 15:05:25 -07004968# check for comparisons of jiffies
4969 if ($line =~ /\bjiffies\s*$Compare|$Compare\s*jiffies\b/) {
4970 WARN("JIFFIES_COMPARISON",
4971 "Comparing jiffies is almost always wrong; prefer time_after, time_before and friends\n" . $herecurr);
4972 }
4973
Joe Perches9d7a34a2013-07-03 15:05:26 -07004974# check for comparisons of get_jiffies_64()
4975 if ($line =~ /\bget_jiffies_64\s*\(\s*\)\s*$Compare|$Compare\s*get_jiffies_64\s*\(\s*\)/) {
4976 WARN("JIFFIES_COMPARISON",
4977 "Comparing get_jiffies_64() is almost always wrong; prefer time_after64, time_before64 and friends\n" . $herecurr);
4978 }
4979
Andy Whitcroft00df3442007-06-08 13:47:06 -07004980# warn about #ifdefs in C files
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004981# if ($line =~ /^.\s*\#\s*if(|n)def/ && ($realfile =~ /\.c$/)) {
Andy Whitcroft00df3442007-06-08 13:47:06 -07004982# print "#ifdef in C files should be avoided\n";
4983# print "$herecurr";
4984# $clean = 0;
4985# }
4986
Andy Whitcroft22f2a2e2007-08-10 13:01:03 -07004987# warn about spacing in #ifdefs
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004988 if ($line =~ /^.\s*\#\s*(ifdef|ifndef|elif)\s\s+/) {
Joe Perches3705ce52013-07-03 15:05:31 -07004989 if (ERROR("SPACING",
4990 "exactly one space required after that #$1\n" . $herecurr) &&
4991 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07004992 $fixed[$fixlinenr] =~
Joe Perches3705ce52013-07-03 15:05:31 -07004993 s/^(.\s*\#\s*(ifdef|ifndef|elif))\s{2,}/$1 /;
4994 }
4995
Andy Whitcroft22f2a2e2007-08-10 13:01:03 -07004996 }
4997
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07004998# check for spinlock_t definitions without a comment.
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07004999 if ($line =~ /^.\s*(struct\s+mutex|spinlock_t)\s+\S+;/ ||
5000 $line =~ /^.\s*(DEFINE_MUTEX)\s*\(/) {
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07005001 my $which = $1;
5002 if (!ctx_has_comment($first_line, $linenr)) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005003 CHK("UNCOMMENTED_DEFINITION",
5004 "$1 definition without comment\n" . $herecurr);
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07005005 }
5006 }
5007# check for memory barriers without a comment.
5008 if ($line =~ /\b(mb|rmb|wmb|read_barrier_depends|smp_mb|smp_rmb|smp_wmb|smp_read_barrier_depends)\(/) {
5009 if (!ctx_has_comment($first_line, $linenr)) {
Joe Perchesc1fd7bb2013-11-12 15:10:11 -08005010 WARN("MEMORY_BARRIER",
5011 "memory barrier without comment\n" . $herecurr);
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07005012 }
5013 }
Joe Perchescb426e92015-06-25 15:02:46 -07005014# check for waitqueue_active without a comment.
5015 if ($line =~ /\bwaitqueue_active\s*\(/) {
5016 if (!ctx_has_comment($first_line, $linenr)) {
5017 WARN("WAITQUEUE_ACTIVE",
5018 "waitqueue_active without comment\n" . $herecurr);
5019 }
5020 }
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07005021# check of hardware specific defines
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07005022 if ($line =~ m@^.\s*\#\s*if.*\b(__i386__|__powerpc64__|__sun__|__s390x__)\b@ && $realfile !~ m@include/asm-@) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005023 CHK("ARCH_DEFINES",
5024 "architecture specific defines should be avoided\n" . $herecurr);
Andy Whitcroft0a920b52007-06-01 00:46:48 -07005025 }
Andy Whitcroft653d4872007-06-23 17:16:34 -07005026
Tobias Klauserd4977c72010-05-24 14:33:30 -07005027# Check that the storage class is at the beginning of a declaration
5028 if ($line =~ /\b$Storage\b/ && $line !~ /^.\s*$Storage\b/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005029 WARN("STORAGE_CLASS",
5030 "storage class should be at the beginning of the declaration\n" . $herecurr)
Tobias Klauserd4977c72010-05-24 14:33:30 -07005031 }
5032
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07005033# check the location of the inline attribute, that it is between
5034# storage class and type.
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07005035 if ($line =~ /\b$Type\s+$Inline\b/ ||
5036 $line =~ /\b$Inline\s+$Storage\b/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005037 ERROR("INLINE_LOCATION",
5038 "inline keyword should sit between storage class and type\n" . $herecurr);
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07005039 }
5040
Andy Whitcroft8905a672007-11-28 16:21:06 -08005041# Check for __inline__ and __inline, prefer inline
Joe Perches2b7ab452013-11-12 15:10:14 -08005042 if ($realfile !~ m@\binclude/uapi/@ &&
5043 $line =~ /\b(__inline__|__inline)\b/) {
Joe Perchesd5e616f2013-09-11 14:23:54 -07005044 if (WARN("INLINE",
5045 "plain inline is preferred over $1\n" . $herecurr) &&
5046 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07005047 $fixed[$fixlinenr] =~ s/\b(__inline__|__inline)\b/inline/;
Joe Perchesd5e616f2013-09-11 14:23:54 -07005048
5049 }
Andy Whitcroft8905a672007-11-28 16:21:06 -08005050 }
5051
Joe Perches3d130fd2011-01-12 17:00:00 -08005052# Check for __attribute__ packed, prefer __packed
Joe Perches2b7ab452013-11-12 15:10:14 -08005053 if ($realfile !~ m@\binclude/uapi/@ &&
5054 $line =~ /\b__attribute__\s*\(\s*\(.*\bpacked\b/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005055 WARN("PREFER_PACKED",
5056 "__packed is preferred over __attribute__((packed))\n" . $herecurr);
Joe Perches3d130fd2011-01-12 17:00:00 -08005057 }
5058
Joe Perches39b7e282011-07-25 17:13:24 -07005059# Check for __attribute__ aligned, prefer __aligned
Joe Perches2b7ab452013-11-12 15:10:14 -08005060 if ($realfile !~ m@\binclude/uapi/@ &&
5061 $line =~ /\b__attribute__\s*\(\s*\(.*aligned/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005062 WARN("PREFER_ALIGNED",
5063 "__aligned(size) is preferred over __attribute__((aligned(size)))\n" . $herecurr);
Joe Perches39b7e282011-07-25 17:13:24 -07005064 }
5065
Joe Perches5f14d3b2012-01-10 15:09:52 -08005066# Check for __attribute__ format(printf, prefer __printf
Joe Perches2b7ab452013-11-12 15:10:14 -08005067 if ($realfile !~ m@\binclude/uapi/@ &&
5068 $line =~ /\b__attribute__\s*\(\s*\(\s*format\s*\(\s*printf/) {
Joe Perchesd5e616f2013-09-11 14:23:54 -07005069 if (WARN("PREFER_PRINTF",
5070 "__printf(string-index, first-to-check) is preferred over __attribute__((format(printf, string-index, first-to-check)))\n" . $herecurr) &&
5071 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07005072 $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 -07005073
5074 }
Joe Perches5f14d3b2012-01-10 15:09:52 -08005075 }
5076
Joe Perches6061d942012-03-23 15:02:16 -07005077# Check for __attribute__ format(scanf, prefer __scanf
Joe Perches2b7ab452013-11-12 15:10:14 -08005078 if ($realfile !~ m@\binclude/uapi/@ &&
5079 $line =~ /\b__attribute__\s*\(\s*\(\s*format\s*\(\s*scanf\b/) {
Joe Perchesd5e616f2013-09-11 14:23:54 -07005080 if (WARN("PREFER_SCANF",
5081 "__scanf(string-index, first-to-check) is preferred over __attribute__((format(scanf, string-index, first-to-check)))\n" . $herecurr) &&
5082 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07005083 $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 -07005084 }
Joe Perches6061d942012-03-23 15:02:16 -07005085 }
5086
Joe Perches619a9082014-12-10 15:51:35 -08005087# Check for __attribute__ weak, or __weak declarations (may have link issues)
5088 if ($^V && $^V ge 5.10.0 &&
5089 $line =~ /(?:$Declare|$DeclareMisordered)\s*$Ident\s*$balanced_parens\s*(?:$Attribute)?\s*;/ &&
5090 ($line =~ /\b__attribute__\s*\(\s*\(.*\bweak\b/ ||
5091 $line =~ /\b__weak\b/)) {
5092 ERROR("WEAK_DECLARATION",
5093 "Using weak declarations can have unintended link defects\n" . $herecurr);
5094 }
5095
Joe Perchese6176fa2015-06-25 15:02:49 -07005096# check for c99 types like uint8_t used outside of uapi/
5097 if ($realfile !~ m@\binclude/uapi/@ &&
5098 $line =~ /\b($Declare)\s*$Ident\s*[=;,\[]/) {
5099 my $type = $1;
5100 if ($type =~ /\b($typeC99Typedefs)\b/) {
5101 $type = $1;
5102 my $kernel_type = 'u';
5103 $kernel_type = 's' if ($type =~ /^_*[si]/);
5104 $type =~ /(\d+)/;
5105 $kernel_type .= $1;
5106 if (CHK("PREFER_KERNEL_TYPES",
5107 "Prefer kernel type '$kernel_type' over '$type'\n" . $herecurr) &&
5108 $fix) {
5109 $fixed[$fixlinenr] =~ s/\b$type\b/$kernel_type/;
5110 }
5111 }
5112 }
5113
Joe Perches8f53a9b2010-03-05 13:43:48 -08005114# check for sizeof(&)
5115 if ($line =~ /\bsizeof\s*\(\s*\&/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005116 WARN("SIZEOF_ADDRESS",
5117 "sizeof(& should be avoided\n" . $herecurr);
Joe Perches8f53a9b2010-03-05 13:43:48 -08005118 }
5119
Joe Perches66c80b62012-07-30 14:41:22 -07005120# check for sizeof without parenthesis
5121 if ($line =~ /\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/) {
Joe Perchesd5e616f2013-09-11 14:23:54 -07005122 if (WARN("SIZEOF_PARENTHESIS",
5123 "sizeof $1 should be sizeof($1)\n" . $herecurr) &&
5124 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07005125 $fixed[$fixlinenr] =~ s/\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/"sizeof(" . trim($1) . ")"/ex;
Joe Perchesd5e616f2013-09-11 14:23:54 -07005126 }
Joe Perches66c80b62012-07-30 14:41:22 -07005127 }
5128
Joe Perches88982fe2012-12-17 16:02:00 -08005129# check for struct spinlock declarations
5130 if ($line =~ /^.\s*\bstruct\s+spinlock\s+\w+\s*;/) {
5131 WARN("USE_SPINLOCK_T",
5132 "struct spinlock should be spinlock_t\n" . $herecurr);
5133 }
5134
Joe Perchesa6962d72013-04-29 16:18:13 -07005135# check for seq_printf uses that could be seq_puts
Joe Perches06668722013-11-12 15:10:07 -08005136 if ($sline =~ /\bseq_printf\s*\(.*"\s*\)\s*;\s*$/) {
Joe Perchesa6962d72013-04-29 16:18:13 -07005137 my $fmt = get_quoted_string($line, $rawline);
Heba Aamercaac1d52015-02-13 14:38:49 -08005138 $fmt =~ s/%%//g;
5139 if ($fmt !~ /%/) {
Joe Perchesd5e616f2013-09-11 14:23:54 -07005140 if (WARN("PREFER_SEQ_PUTS",
5141 "Prefer seq_puts to seq_printf\n" . $herecurr) &&
5142 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07005143 $fixed[$fixlinenr] =~ s/\bseq_printf\b/seq_puts/;
Joe Perchesd5e616f2013-09-11 14:23:54 -07005144 }
Joe Perchesa6962d72013-04-29 16:18:13 -07005145 }
5146 }
5147
Andy Whitcroft554e1652012-01-10 15:09:57 -08005148# Check for misused memsets
Joe Perchesd1fe9c02012-03-23 15:02:16 -07005149 if ($^V && $^V ge 5.10.0 &&
5150 defined $stat &&
Mateusz Kulikowski9e20a852015-06-25 15:03:16 -07005151 $stat =~ /^\+(?:.*?)\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*$FuncArg\s*\)/) {
Andy Whitcroft554e1652012-01-10 15:09:57 -08005152
Joe Perchesd7c76ba2012-01-10 15:09:58 -08005153 my $ms_addr = $2;
Joe Perchesd1fe9c02012-03-23 15:02:16 -07005154 my $ms_val = $7;
5155 my $ms_size = $12;
Joe Perchesd7c76ba2012-01-10 15:09:58 -08005156
Andy Whitcroft554e1652012-01-10 15:09:57 -08005157 if ($ms_size =~ /^(0x|)0$/i) {
5158 ERROR("MEMSET",
Joe Perchesd7c76ba2012-01-10 15:09:58 -08005159 "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 -08005160 } elsif ($ms_size =~ /^(0x|)1$/i) {
5161 WARN("MEMSET",
Joe Perchesd7c76ba2012-01-10 15:09:58 -08005162 "single byte memset is suspicious. Swapped 2nd/3rd argument?\n" . "$here\n$stat\n");
5163 }
5164 }
5165
Joe Perches98a9bba2014-01-23 15:54:52 -08005166# Check for memcpy(foo, bar, ETH_ALEN) that could be ether_addr_copy(foo, bar)
5167 if ($^V && $^V ge 5.10.0 &&
Mateusz Kulikowski10895d22015-06-25 15:03:21 -07005168 defined $stat &&
5169 $stat =~ /^\+(?:.*?)\bmemcpy\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/) {
Joe Perches98a9bba2014-01-23 15:54:52 -08005170 if (WARN("PREFER_ETHER_ADDR_COPY",
Mateusz Kulikowski10895d22015-06-25 15:03:21 -07005171 "Prefer ether_addr_copy() over memcpy() if the Ethernet addresses are __aligned(2)\n" . "$here\n$stat\n") &&
Joe Perches98a9bba2014-01-23 15:54:52 -08005172 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07005173 $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 -08005174 }
5175 }
5176
Mateusz Kulikowskib6117d12015-06-25 15:03:13 -07005177# Check for memcmp(foo, bar, ETH_ALEN) that could be ether_addr_equal*(foo, bar)
5178 if ($^V && $^V ge 5.10.0 &&
5179 defined $stat &&
5180 $stat =~ /^\+(?:.*?)\bmemcmp\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/) {
5181 WARN("PREFER_ETHER_ADDR_EQUAL",
5182 "Prefer ether_addr_equal() or ether_addr_equal_unaligned() over memcmp()\n" . "$here\n$stat\n")
5183 }
5184
Mateusz Kulikowski8617cd02015-06-25 15:03:19 -07005185# check for memset(foo, 0x0, ETH_ALEN) that could be eth_zero_addr
5186# check for memset(foo, 0xFF, ETH_ALEN) that could be eth_broadcast_addr
5187 if ($^V && $^V ge 5.10.0 &&
5188 defined $stat &&
5189 $stat =~ /^\+(?:.*?)\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/) {
5190
5191 my $ms_val = $7;
5192
5193 if ($ms_val =~ /^(?:0x|)0+$/i) {
5194 if (WARN("PREFER_ETH_ZERO_ADDR",
5195 "Prefer eth_zero_addr over memset()\n" . "$here\n$stat\n") &&
5196 $fix) {
5197 $fixed[$fixlinenr] =~ s/\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*,\s*ETH_ALEN\s*\)/eth_zero_addr($2)/;
5198 }
5199 } elsif ($ms_val =~ /^(?:0xff|255)$/i) {
5200 if (WARN("PREFER_ETH_BROADCAST_ADDR",
5201 "Prefer eth_broadcast_addr() over memset()\n" . "$here\n$stat\n") &&
5202 $fix) {
5203 $fixed[$fixlinenr] =~ s/\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*,\s*ETH_ALEN\s*\)/eth_broadcast_addr($2)/;
5204 }
5205 }
5206 }
5207
Joe Perchesd7c76ba2012-01-10 15:09:58 -08005208# typecasts on min/max could be min_t/max_t
Joe Perchesd1fe9c02012-03-23 15:02:16 -07005209 if ($^V && $^V ge 5.10.0 &&
5210 defined $stat &&
Joe Perchesd7c76ba2012-01-10 15:09:58 -08005211 $stat =~ /^\+(?:.*?)\b(min|max)\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\)/) {
Joe Perchesd1fe9c02012-03-23 15:02:16 -07005212 if (defined $2 || defined $7) {
Joe Perchesd7c76ba2012-01-10 15:09:58 -08005213 my $call = $1;
5214 my $cast1 = deparenthesize($2);
5215 my $arg1 = $3;
Joe Perchesd1fe9c02012-03-23 15:02:16 -07005216 my $cast2 = deparenthesize($7);
5217 my $arg2 = $8;
Joe Perchesd7c76ba2012-01-10 15:09:58 -08005218 my $cast;
5219
Joe Perchesd1fe9c02012-03-23 15:02:16 -07005220 if ($cast1 ne "" && $cast2 ne "" && $cast1 ne $cast2) {
Joe Perchesd7c76ba2012-01-10 15:09:58 -08005221 $cast = "$cast1 or $cast2";
5222 } elsif ($cast1 ne "") {
5223 $cast = $cast1;
5224 } else {
5225 $cast = $cast2;
5226 }
5227 WARN("MINMAX",
5228 "$call() should probably be ${call}_t($cast, $arg1, $arg2)\n" . "$here\n$stat\n");
Andy Whitcroft554e1652012-01-10 15:09:57 -08005229 }
5230 }
5231
Joe Perches4a273192012-07-30 14:41:20 -07005232# check usleep_range arguments
5233 if ($^V && $^V ge 5.10.0 &&
5234 defined $stat &&
5235 $stat =~ /^\+(?:.*?)\busleep_range\s*\(\s*($FuncArg)\s*,\s*($FuncArg)\s*\)/) {
5236 my $min = $1;
5237 my $max = $7;
5238 if ($min eq $max) {
5239 WARN("USLEEP_RANGE",
5240 "usleep_range should not use min == max args; see Documentation/timers/timers-howto.txt\n" . "$here\n$stat\n");
5241 } elsif ($min =~ /^\d+$/ && $max =~ /^\d+$/ &&
5242 $min > $max) {
5243 WARN("USLEEP_RANGE",
5244 "usleep_range args reversed, use min then max; see Documentation/timers/timers-howto.txt\n" . "$here\n$stat\n");
5245 }
5246 }
5247
Joe Perches823b7942013-11-12 15:10:15 -08005248# check for naked sscanf
5249 if ($^V && $^V ge 5.10.0 &&
5250 defined $stat &&
Joe Perches6c8bd702014-04-03 14:49:16 -07005251 $line =~ /\bsscanf\b/ &&
Joe Perches823b7942013-11-12 15:10:15 -08005252 ($stat !~ /$Ident\s*=\s*sscanf\s*$balanced_parens/ &&
5253 $stat !~ /\bsscanf\s*$balanced_parens\s*(?:$Compare)/ &&
5254 $stat !~ /(?:$Compare)\s*\bsscanf\s*$balanced_parens/)) {
5255 my $lc = $stat =~ tr@\n@@;
5256 $lc = $lc + $linenr;
5257 my $stat_real = raw_line($linenr, 0);
5258 for (my $count = $linenr + 1; $count <= $lc; $count++) {
5259 $stat_real = $stat_real . "\n" . raw_line($count, 0);
5260 }
5261 WARN("NAKED_SSCANF",
5262 "unchecked sscanf return value\n" . "$here\n$stat_real\n");
5263 }
5264
Joe Perchesafc819a2014-06-04 16:12:08 -07005265# check for simple sscanf that should be kstrto<foo>
5266 if ($^V && $^V ge 5.10.0 &&
5267 defined $stat &&
5268 $line =~ /\bsscanf\b/) {
5269 my $lc = $stat =~ tr@\n@@;
5270 $lc = $lc + $linenr;
5271 my $stat_real = raw_line($linenr, 0);
5272 for (my $count = $linenr + 1; $count <= $lc; $count++) {
5273 $stat_real = $stat_real . "\n" . raw_line($count, 0);
5274 }
5275 if ($stat_real =~ /\bsscanf\b\s*\(\s*$FuncArg\s*,\s*("[^"]+")/) {
5276 my $format = $6;
5277 my $count = $format =~ tr@%@%@;
5278 if ($count == 1 &&
5279 $format =~ /^"\%(?i:ll[udxi]|[udxi]ll|ll|[hl]h?[udxi]|[udxi][hl]h?|[hl]h?|[udxi])"$/) {
5280 WARN("SSCANF_TO_KSTRTO",
5281 "Prefer kstrto<type> to single variable sscanf\n" . "$here\n$stat_real\n");
5282 }
5283 }
5284 }
5285
Joe Perches70dc8a42013-09-11 14:23:58 -07005286# check for new externs in .h files.
5287 if ($realfile =~ /\.h$/ &&
5288 $line =~ /^\+\s*(extern\s+)$Type\s*$Ident\s*\(/s) {
Joe Perchesd1d85782013-09-24 15:27:46 -07005289 if (CHK("AVOID_EXTERNS",
5290 "extern prototypes should be avoided in .h files\n" . $herecurr) &&
Joe Perches70dc8a42013-09-11 14:23:58 -07005291 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07005292 $fixed[$fixlinenr] =~ s/(.*)\bextern\b\s*(.*)/$1$2/;
Joe Perches70dc8a42013-09-11 14:23:58 -07005293 }
5294 }
5295
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07005296# check for new externs in .c files.
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07005297 if ($realfile =~ /\.c$/ && defined $stat &&
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07005298 $stat =~ /^.\s*(?:extern\s+)?$Type\s+($Ident)(\s*)\(/s)
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07005299 {
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07005300 my $function_name = $1;
5301 my $paren_space = $2;
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07005302
5303 my $s = $stat;
5304 if (defined $cond) {
5305 substr($s, 0, length($cond), '');
5306 }
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07005307 if ($s =~ /^\s*;/ &&
5308 $function_name ne 'uninitialized_var')
5309 {
Joe Perches000d1cc12011-07-25 17:13:25 -07005310 WARN("AVOID_EXTERNS",
5311 "externs should be avoided in .c files\n" . $herecurr);
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07005312 }
5313
5314 if ($paren_space =~ /\n/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005315 WARN("FUNCTION_ARGUMENTS",
5316 "arguments for function declarations should follow identifier\n" . $herecurr);
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07005317 }
Andy Whitcroft9c9ba342008-04-29 00:59:33 -07005318
5319 } elsif ($realfile =~ /\.c$/ && defined $stat &&
5320 $stat =~ /^.\s*extern\s+/)
5321 {
Joe Perches000d1cc12011-07-25 17:13:25 -07005322 WARN("AVOID_EXTERNS",
5323 "externs should be avoided in .c files\n" . $herecurr);
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07005324 }
5325
5326# checks for new __setup's
5327 if ($rawline =~ /\b__setup\("([^"]*)"/) {
5328 my $name = $1;
5329
5330 if (!grep(/$name/, @setup_docs)) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005331 CHK("UNDOCUMENTED_SETUP",
5332 "__setup appears un-documented -- check Documentation/kernel-parameters.txt\n" . $herecurr);
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07005333 }
Andy Whitcroft653d4872007-06-23 17:16:34 -07005334 }
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07005335
5336# check for pointless casting of kmalloc return
Joe Perchescaf2a542011-01-12 16:59:56 -08005337 if ($line =~ /\*\s*\)\s*[kv][czm]alloc(_node){0,1}\b/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005338 WARN("UNNECESSARY_CASTS",
5339 "unnecessary cast may hide bugs, see http://c-faq.com/malloc/mallocnocast.html\n" . $herecurr);
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07005340 }
Andy Whitcroft13214ad2008-02-08 04:22:03 -08005341
Joe Perchesa640d252013-07-03 15:05:21 -07005342# alloc style
5343# p = alloc(sizeof(struct foo), ...) should be p = alloc(sizeof(*p), ...)
5344 if ($^V && $^V ge 5.10.0 &&
5345 $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*([kv][mz]alloc(?:_node)?)\s*\(\s*(sizeof\s*\(\s*struct\s+$Lval\s*\))/) {
5346 CHK("ALLOC_SIZEOF_STRUCT",
5347 "Prefer $3(sizeof(*$1)...) over $3($4...)\n" . $herecurr);
5348 }
5349
Joe Perches60a55362014-06-04 16:12:07 -07005350# check for k[mz]alloc with multiplies that could be kmalloc_array/kcalloc
5351 if ($^V && $^V ge 5.10.0 &&
Joe Perchese3674552014-08-06 16:10:55 -07005352 $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 -07005353 my $oldfunc = $3;
5354 my $a1 = $4;
5355 my $a2 = $10;
5356 my $newfunc = "kmalloc_array";
5357 $newfunc = "kcalloc" if ($oldfunc eq "kzalloc");
Joe Perchese3674552014-08-06 16:10:55 -07005358 my $r1 = $a1;
5359 my $r2 = $a2;
5360 if ($a1 =~ /^sizeof\s*\S/) {
5361 $r1 = $a2;
5362 $r2 = $a1;
5363 }
5364 if ($r1 !~ /^sizeof\b/ && $r2 =~ /^sizeof\s*\S/ &&
5365 !($r1 =~ /^$Constant$/ || $r1 =~ /^[A-Z_][A-Z0-9_]*$/)) {
Joe Perches60a55362014-06-04 16:12:07 -07005366 if (WARN("ALLOC_WITH_MULTIPLY",
5367 "Prefer $newfunc over $oldfunc with multiply\n" . $herecurr) &&
5368 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07005369 $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 -07005370
5371 }
5372 }
5373 }
5374
Joe Perches972fdea2013-04-29 16:18:12 -07005375# check for krealloc arg reuse
5376 if ($^V && $^V ge 5.10.0 &&
5377 $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*krealloc\s*\(\s*\1\s*,/) {
5378 WARN("KREALLOC_ARG_REUSE",
5379 "Reusing the krealloc arg is almost always a bug\n" . $herecurr);
5380 }
5381
Joe Perches5ce59ae2013-02-21 16:44:18 -08005382# check for alloc argument mismatch
5383 if ($line =~ /\b(kcalloc|kmalloc_array)\s*\(\s*sizeof\b/) {
5384 WARN("ALLOC_ARRAY_ARGS",
5385 "$1 uses number as first arg, sizeof is generally wrong\n" . $herecurr);
5386 }
5387
Joe Perchescaf2a542011-01-12 16:59:56 -08005388# check for multiple semicolons
5389 if ($line =~ /;\s*;\s*$/) {
Joe Perchesd5e616f2013-09-11 14:23:54 -07005390 if (WARN("ONE_SEMICOLON",
5391 "Statements terminations use 1 semicolon\n" . $herecurr) &&
5392 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07005393 $fixed[$fixlinenr] =~ s/(\s*;\s*){2,}$/;/g;
Joe Perchesd5e616f2013-09-11 14:23:54 -07005394 }
Joe Perchesd1e2ad02012-12-17 16:02:01 -08005395 }
5396
Joe Perches0ab90192014-12-10 15:51:57 -08005397# check for #defines like: 1 << <digit> that could be BIT(digit)
5398 if ($line =~ /#\s*define\s+\w+\s+\(?\s*1\s*([ulUL]*)\s*\<\<\s*(?:\d+|$Ident)\s*\)?/) {
5399 my $ull = "";
5400 $ull = "_ULL" if (defined($1) && $1 =~ /ll/i);
5401 if (CHK("BIT_MACRO",
5402 "Prefer using the BIT$ull macro\n" . $herecurr) &&
5403 $fix) {
5404 $fixed[$fixlinenr] =~ s/\(?\s*1\s*[ulUL]*\s*<<\s*(\d+|$Ident)\s*\)?/BIT${ull}($1)/;
5405 }
5406 }
5407
Joe Perchese81f2392014-08-06 16:11:25 -07005408# check for case / default statements not preceded by break/fallthrough/switch
Joe Perchesc34c09a2014-01-23 15:54:43 -08005409 if ($line =~ /^.\s*(?:case\s+(?:$Ident|$Constant)\s*|default):/) {
5410 my $has_break = 0;
5411 my $has_statement = 0;
5412 my $count = 0;
5413 my $prevline = $linenr;
Joe Perchese81f2392014-08-06 16:11:25 -07005414 while ($prevline > 1 && ($file || $count < 3) && !$has_break) {
Joe Perchesc34c09a2014-01-23 15:54:43 -08005415 $prevline--;
5416 my $rline = $rawlines[$prevline - 1];
5417 my $fline = $lines[$prevline - 1];
5418 last if ($fline =~ /^\@\@/);
5419 next if ($fline =~ /^\-/);
5420 next if ($fline =~ /^.(?:\s*(?:case\s+(?:$Ident|$Constant)[\s$;]*|default):[\s$;]*)*$/);
5421 $has_break = 1 if ($rline =~ /fall[\s_-]*(through|thru)/i);
5422 next if ($fline =~ /^.[\s$;]*$/);
5423 $has_statement = 1;
5424 $count++;
5425 $has_break = 1 if ($fline =~ /\bswitch\b|\b(?:break\s*;[\s$;]*$|return\b|goto\b|continue\b)/);
5426 }
5427 if (!$has_break && $has_statement) {
5428 WARN("MISSING_BREAK",
5429 "Possible switch case/default not preceeded by break or fallthrough comment\n" . $herecurr);
5430 }
5431 }
5432
Joe Perchesd1e2ad02012-12-17 16:02:01 -08005433# check for switch/default statements without a break;
5434 if ($^V && $^V ge 5.10.0 &&
5435 defined $stat &&
5436 $stat =~ /^\+[$;\s]*(?:case[$;\s]+\w+[$;\s]*:[$;\s]*|)*[$;\s]*\bdefault[$;\s]*:[$;\s]*;/g) {
5437 my $ctx = '';
5438 my $herectx = $here . "\n";
5439 my $cnt = statement_rawlines($stat);
5440 for (my $n = 0; $n < $cnt; $n++) {
5441 $herectx .= raw_line($linenr, $n) . "\n";
5442 }
5443 WARN("DEFAULT_NO_BREAK",
5444 "switch default: should use break\n" . $herectx);
Joe Perchescaf2a542011-01-12 16:59:56 -08005445 }
5446
Andy Whitcroft13214ad2008-02-08 04:22:03 -08005447# check for gcc specific __FUNCTION__
Joe Perchesd5e616f2013-09-11 14:23:54 -07005448 if ($line =~ /\b__FUNCTION__\b/) {
5449 if (WARN("USE_FUNC",
5450 "__func__ should be used instead of gcc specific __FUNCTION__\n" . $herecurr) &&
5451 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07005452 $fixed[$fixlinenr] =~ s/\b__FUNCTION__\b/__func__/g;
Joe Perchesd5e616f2013-09-11 14:23:54 -07005453 }
Andy Whitcroft13214ad2008-02-08 04:22:03 -08005454 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07005455
Joe Perches62ec8182015-02-13 14:38:18 -08005456# check for uses of __DATE__, __TIME__, __TIMESTAMP__
5457 while ($line =~ /\b(__(?:DATE|TIME|TIMESTAMP)__)\b/g) {
5458 ERROR("DATE_TIME",
5459 "Use of the '$1' macro makes the build non-deterministic\n" . $herecurr);
5460 }
5461
Joe Perches2c924882012-03-23 15:02:20 -07005462# check for use of yield()
5463 if ($line =~ /\byield\s*\(\s*\)/) {
5464 WARN("YIELD",
5465 "Using yield() is generally wrong. See yield() kernel-doc (sched/core.c)\n" . $herecurr);
5466 }
5467
Joe Perches179f8f42013-07-03 15:05:30 -07005468# check for comparisons against true and false
5469 if ($line =~ /\+\s*(.*?)\b(true|false|$Lval)\s*(==|\!=)\s*(true|false|$Lval)\b(.*)$/i) {
5470 my $lead = $1;
5471 my $arg = $2;
5472 my $test = $3;
5473 my $otype = $4;
5474 my $trail = $5;
5475 my $op = "!";
5476
5477 ($arg, $otype) = ($otype, $arg) if ($arg =~ /^(?:true|false)$/i);
5478
5479 my $type = lc($otype);
5480 if ($type =~ /^(?:true|false)$/) {
5481 if (("$test" eq "==" && "$type" eq "true") ||
5482 ("$test" eq "!=" && "$type" eq "false")) {
5483 $op = "";
5484 }
5485
5486 CHK("BOOL_COMPARISON",
5487 "Using comparison to $otype is error prone\n" . $herecurr);
5488
5489## maybe suggesting a correct construct would better
5490## "Using comparison to $otype is error prone. Perhaps use '${lead}${op}${arg}${trail}'\n" . $herecurr);
5491
5492 }
5493 }
5494
Thomas Gleixner4882720b2010-09-07 14:34:01 +00005495# check for semaphores initialized locked
5496 if ($line =~ /^.\s*sema_init.+,\W?0\W?\)/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005497 WARN("CONSIDER_COMPLETION",
5498 "consider using a completion\n" . $herecurr);
Andy Whitcroft773647a2008-03-28 14:15:58 -07005499 }
Joe Perches6712d852012-03-23 15:02:20 -07005500
Joe Perches67d0a072011-10-31 17:13:10 -07005501# recommend kstrto* over simple_strto* and strict_strto*
5502 if ($line =~ /\b((simple|strict)_(strto(l|ll|ul|ull)))\s*\(/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005503 WARN("CONSIDER_KSTRTO",
Joe Perches67d0a072011-10-31 17:13:10 -07005504 "$1 is obsolete, use k$3 instead\n" . $herecurr);
Andy Whitcroft773647a2008-03-28 14:15:58 -07005505 }
Joe Perches6712d852012-03-23 15:02:20 -07005506
Fabian Frederickae3ccc42014-06-04 16:12:10 -07005507# check for __initcall(), use device_initcall() explicitly or more appropriate function please
Michael Ellermanf3db6632008-07-23 21:28:57 -07005508 if ($line =~ /^.\s*__initcall\s*\(/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005509 WARN("USE_DEVICE_INITCALL",
Fabian Frederickae3ccc42014-06-04 16:12:10 -07005510 "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 -07005511 }
Joe Perches6712d852012-03-23 15:02:20 -07005512
Joe Perches0f3c5aa2015-02-13 14:39:05 -08005513# check for various structs that are normally const (ops, kgdb, device_tree)
5514 my $const_structs = qr{
5515 acpi_dock_ops|
Emese Revfy79404842010-03-05 13:43:53 -08005516 address_space_operations|
5517 backlight_ops|
5518 block_device_operations|
5519 dentry_operations|
5520 dev_pm_ops|
5521 dma_map_ops|
5522 extent_io_ops|
5523 file_lock_operations|
5524 file_operations|
5525 hv_ops|
5526 ide_dma_ops|
5527 intel_dvo_dev_ops|
5528 item_operations|
5529 iwl_ops|
5530 kgdb_arch|
5531 kgdb_io|
5532 kset_uevent_ops|
5533 lock_manager_operations|
5534 microcode_ops|
5535 mtrr_ops|
5536 neigh_ops|
5537 nlmsvc_binding|
Joe Perches0f3c5aa2015-02-13 14:39:05 -08005538 of_device_id|
Emese Revfy79404842010-03-05 13:43:53 -08005539 pci_raw_ops|
5540 pipe_buf_operations|
5541 platform_hibernation_ops|
5542 platform_suspend_ops|
5543 proto_ops|
5544 rpc_pipe_ops|
5545 seq_operations|
5546 snd_ac97_build_ops|
5547 soc_pcmcia_socket_ops|
5548 stacktrace_ops|
5549 sysfs_ops|
5550 tty_operations|
Joe Perches6d07d01b2015-04-16 12:44:33 -07005551 uart_ops|
Emese Revfy79404842010-03-05 13:43:53 -08005552 usb_mon_operations|
5553 wd_ops}x;
Andy Whitcroft6903ffb2009-01-15 13:51:07 -08005554 if ($line !~ /\bconst\b/ &&
Joe Perches0f3c5aa2015-02-13 14:39:05 -08005555 $line =~ /\bstruct\s+($const_structs)\b/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005556 WARN("CONST_STRUCT",
5557 "struct $1 should normally be const\n" .
Andy Whitcroft6903ffb2009-01-15 13:51:07 -08005558 $herecurr);
Andy Whitcroft2b6db5c2009-01-06 14:41:29 -08005559 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07005560
5561# use of NR_CPUS is usually wrong
5562# ignore definitions of NR_CPUS and usage to define arrays as likely right
5563 if ($line =~ /\bNR_CPUS\b/ &&
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07005564 $line !~ /^.\s*\s*#\s*if\b.*\bNR_CPUS\b/ &&
5565 $line !~ /^.\s*\s*#\s*define\b.*\bNR_CPUS\b/ &&
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07005566 $line !~ /^.\s*$Declare\s.*\[[^\]]*NR_CPUS[^\]]*\]/ &&
5567 $line !~ /\[[^\]]*\.\.\.[^\]]*NR_CPUS[^\]]*\]/ &&
5568 $line !~ /\[[^\]]*NR_CPUS[^\]]*\.\.\.[^\]]*\]/)
Andy Whitcroft773647a2008-03-28 14:15:58 -07005569 {
Joe Perches000d1cc12011-07-25 17:13:25 -07005570 WARN("NR_CPUS",
5571 "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 -07005572 }
Andy Whitcroft9c9ba342008-04-29 00:59:33 -07005573
Joe Perches52ea8502013-11-12 15:10:09 -08005574# Use of __ARCH_HAS_<FOO> or ARCH_HAVE_<BAR> is wrong.
5575 if ($line =~ /\+\s*#\s*define\s+((?:__)?ARCH_(?:HAS|HAVE)\w*)\b/) {
5576 ERROR("DEFINE_ARCH_HAS",
5577 "#define of '$1' is wrong - use Kconfig variables or standard guards instead\n" . $herecurr);
5578 }
5579
Joe Perchesacd93622015-02-13 14:38:38 -08005580# likely/unlikely comparisons similar to "(likely(foo) > 0)"
5581 if ($^V && $^V ge 5.10.0 &&
5582 $line =~ /\b((?:un)?likely)\s*\(\s*$FuncArg\s*\)\s*$Compare/) {
5583 WARN("LIKELY_MISUSE",
5584 "Using $1 should generally have parentheses around the comparison\n" . $herecurr);
5585 }
5586
Andy Whitcroft691d77b2009-01-06 14:41:16 -08005587# whine mightly about in_atomic
5588 if ($line =~ /\bin_atomic\s*\(/) {
5589 if ($realfile =~ m@^drivers/@) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005590 ERROR("IN_ATOMIC",
5591 "do not use in_atomic in drivers\n" . $herecurr);
Andy Whitcroftf4a87732009-02-27 14:03:05 -08005592 } elsif ($realfile !~ m@^kernel/@) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005593 WARN("IN_ATOMIC",
5594 "use of in_atomic() is incorrect outside core kernel code\n" . $herecurr);
Andy Whitcroft691d77b2009-01-06 14:41:16 -08005595 }
5596 }
Peter Zijlstra1704f472010-03-19 01:37:42 +01005597
5598# check for lockdep_set_novalidate_class
5599 if ($line =~ /^.\s*lockdep_set_novalidate_class\s*\(/ ||
5600 $line =~ /__lockdep_no_validate__\s*\)/ ) {
5601 if ($realfile !~ m@^kernel/lockdep@ &&
5602 $realfile !~ m@^include/linux/lockdep@ &&
5603 $realfile !~ m@^drivers/base/core@) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005604 ERROR("LOCKDEP",
5605 "lockdep_no_validate class is reserved for device->mutex.\n" . $herecurr);
Peter Zijlstra1704f472010-03-19 01:37:42 +01005606 }
5607 }
Dave Jones88f88312011-01-12 16:59:59 -08005608
Joe Perchesb392c642015-04-16 12:44:16 -07005609 if ($line =~ /debugfs_create_\w+.*\b$mode_perms_world_writable\b/ ||
5610 $line =~ /DEVICE_ATTR.*\b$mode_perms_world_writable\b/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005611 WARN("EXPORTED_WORLD_WRITABLE",
5612 "Exporting world writable files is usually an error. Consider more restrictive permissions.\n" . $herecurr);
Dave Jones88f88312011-01-12 16:59:59 -08005613 }
Joe Perches24358802014-04-03 14:49:13 -07005614
Joe Perches515a2352014-04-03 14:49:24 -07005615# Mode permission misuses where it seems decimal should be octal
5616# This uses a shortcut match to avoid unnecessary uses of a slow foreach loop
5617 if ($^V && $^V ge 5.10.0 &&
5618 $line =~ /$mode_perms_search/) {
5619 foreach my $entry (@mode_permission_funcs) {
5620 my $func = $entry->[0];
5621 my $arg_pos = $entry->[1];
Joe Perches24358802014-04-03 14:49:13 -07005622
Joe Perches515a2352014-04-03 14:49:24 -07005623 my $skip_args = "";
5624 if ($arg_pos > 1) {
5625 $arg_pos--;
5626 $skip_args = "(?:\\s*$FuncArg\\s*,\\s*){$arg_pos,$arg_pos}";
5627 }
5628 my $test = "\\b$func\\s*\\(${skip_args}([\\d]+)\\s*[,\\)]";
5629 if ($line =~ /$test/) {
5630 my $val = $1;
5631 $val = $6 if ($skip_args ne "");
Joe Perches24358802014-04-03 14:49:13 -07005632
Joe Perches515a2352014-04-03 14:49:24 -07005633 if ($val !~ /^0$/ &&
5634 (($val =~ /^$Int$/ && $val !~ /^$Octal$/) ||
5635 length($val) ne 4)) {
5636 ERROR("NON_OCTAL_PERMISSIONS",
5637 "Use 4 digit octal (0777) not decimal permissions\n" . $herecurr);
Joe Perchesc0a5c892015-02-13 14:38:21 -08005638 } elsif ($val =~ /^$Octal$/ && (oct($val) & 02)) {
5639 ERROR("EXPORTED_WORLD_WRITABLE",
5640 "Exporting writable files is usually an error. Consider more restrictive permissions.\n" . $herecurr);
Joe Perches515a2352014-04-03 14:49:24 -07005641 }
Joe Perches24358802014-04-03 14:49:13 -07005642 }
5643 }
5644 }
Bjorn Andersson5a6d20c2015-06-25 15:03:24 -07005645
5646# validate content of MODULE_LICENSE against list from include/linux/module.h
5647 if ($line =~ /\bMODULE_LICENSE\s*\(\s*($String)\s*\)/) {
5648 my $extracted_string = get_quoted_string($line, $rawline);
5649 my $valid_licenses = qr{
5650 GPL|
5651 GPL\ v2|
5652 GPL\ and\ additional\ rights|
5653 Dual\ BSD/GPL|
5654 Dual\ MIT/GPL|
5655 Dual\ MPL/GPL|
5656 Proprietary
5657 }x;
5658 if ($extracted_string !~ /^"(?:$valid_licenses)"$/x) {
5659 WARN("MODULE_LICENSE",
5660 "unknown module license " . $extracted_string . "\n" . $herecurr);
5661 }
5662 }
Andy Whitcroft13214ad2008-02-08 04:22:03 -08005663 }
5664
5665 # If we have no input at all, then there is nothing to report on
5666 # so just keep quiet.
5667 if ($#rawlines == -1) {
5668 exit(0);
Andy Whitcroft0a920b52007-06-01 00:46:48 -07005669 }
5670
Andy Whitcroft8905a672007-11-28 16:21:06 -08005671 # In mailback mode only produce a report in the negative, for
5672 # things that appear to be patches.
5673 if ($mailback && ($clean == 1 || !$is_patch)) {
5674 exit(0);
5675 }
5676
5677 # This is not a patch, and we are are in 'no-patch' mode so
5678 # just keep quiet.
5679 if (!$chk_patch && !$is_patch) {
5680 exit(0);
5681 }
5682
Joe Perches06330fc2015-06-25 15:03:11 -07005683 if (!$is_patch && $file !~ /cover-letter\.patch$/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005684 ERROR("NOT_UNIFIED_DIFF",
5685 "Does not appear to be a unified-diff format patch\n");
Andy Whitcroft0a920b52007-06-01 00:46:48 -07005686 }
Joe Perches34d88152015-06-25 15:03:05 -07005687 if ($is_patch && $filename ne '-' && $chk_signoff && $signoff == 0) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005688 ERROR("MISSING_SIGN_OFF",
5689 "Missing Signed-off-by: line(s)\n");
Andy Whitcroft0a920b52007-06-01 00:46:48 -07005690 }
5691
Andy Whitcroft8905a672007-11-28 16:21:06 -08005692 print report_dump();
Andy Whitcroft13214ad2008-02-08 04:22:03 -08005693 if ($summary && !($clean == 1 && $quiet == 1)) {
5694 print "$filename " if ($summary_file);
Andy Whitcroft8905a672007-11-28 16:21:06 -08005695 print "total: $cnt_error errors, $cnt_warn warnings, " .
5696 (($check)? "$cnt_chk checks, " : "") .
5697 "$cnt_lines lines checked\n";
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07005698 }
Andy Whitcroft8905a672007-11-28 16:21:06 -08005699
Andy Whitcroftd2c0a232010-10-26 14:23:12 -07005700 if ($quiet == 0) {
5701 # If there were whitespace errors which cleanpatch can fix
5702 # then suggest that.
5703 if ($rpt_cleaners) {
Mike Frysingerb0781212011-03-22 16:34:43 -07005704 $rpt_cleaners = 0;
Joe Perchesd8469f12015-06-25 15:03:00 -07005705 print << "EOM"
5706
5707NOTE: Whitespace errors detected.
5708 You may wish to use scripts/cleanpatch or scripts/cleanfile
5709EOM
Andy Whitcroftd2c0a232010-10-26 14:23:12 -07005710 }
5711 }
5712
Joe Perchesd752fcc2014-08-06 16:11:05 -07005713 if ($clean == 0 && $fix &&
5714 ("@rawlines" ne "@fixed" ||
5715 $#fixed_inserted >= 0 || $#fixed_deleted >= 0)) {
Joe Perches9624b8d2014-01-23 15:54:44 -08005716 my $newfile = $filename;
5717 $newfile .= ".EXPERIMENTAL-checkpatch-fixes" if (!$fix_inplace);
Joe Perches3705ce52013-07-03 15:05:31 -07005718 my $linecount = 0;
5719 my $f;
5720
Joe Perchesd752fcc2014-08-06 16:11:05 -07005721 @fixed = fix_inserted_deleted_lines(\@fixed, \@fixed_inserted, \@fixed_deleted);
5722
Joe Perches3705ce52013-07-03 15:05:31 -07005723 open($f, '>', $newfile)
5724 or die "$P: Can't open $newfile for write\n";
5725 foreach my $fixed_line (@fixed) {
5726 $linecount++;
5727 if ($file) {
5728 if ($linecount > 3) {
5729 $fixed_line =~ s/^\+//;
Joe Perchesd752fcc2014-08-06 16:11:05 -07005730 print $f $fixed_line . "\n";
Joe Perches3705ce52013-07-03 15:05:31 -07005731 }
5732 } else {
5733 print $f $fixed_line . "\n";
5734 }
5735 }
5736 close($f);
5737
5738 if (!$quiet) {
5739 print << "EOM";
Joe Perchesd8469f12015-06-25 15:03:00 -07005740
Joe Perches3705ce52013-07-03 15:05:31 -07005741Wrote EXPERIMENTAL --fix correction(s) to '$newfile'
5742
5743Do _NOT_ trust the results written to this file.
5744Do _NOT_ submit these changes without inspecting them for correctness.
5745
5746This EXPERIMENTAL file is simply a convenience to help rewrite patches.
5747No warranties, expressed or implied...
Joe Perches3705ce52013-07-03 15:05:31 -07005748EOM
5749 }
5750 }
5751
Joe Perchesd8469f12015-06-25 15:03:00 -07005752 if ($quiet == 0) {
5753 print "\n";
5754 if ($clean == 1) {
5755 print "$vname has no obvious style problems and is ready for submission.\n";
5756 } else {
5757 print "$vname has style problems, please review.\n";
5758 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07005759 }
Andy Whitcroft0a920b52007-06-01 00:46:48 -07005760 return $clean;
5761}