1#!/usr/bin/env perl
2# (c) 2001, Dave Jones. (the file handling bit)
3# (c) 2005, Joel Schopp <jschopp@austin.ibm.com> (the ugly bit)
4# (c) 2007,2008, Andy Whitcroft <apw@uk.ibm.com> (new conditions, test suite)
5# (c) 2008-2010 Andy Whitcroft <apw@canonical.com>
6# Licensed under the terms of the GNU GPL License version 2
7
8use strict;
9use warnings;
10use POSIX;
11use File::Basename;
12use Cwd 'abs_path';
13use Term::ANSIColor qw(:constants);
14
15my $P = $0;
16my $D = dirname(abs_path($P));
17
18my $V = '0.32';
19
20use Getopt::Long qw(:config no_auto_abbrev);
21
22my $quiet = 0;
23my $tree = 1;
24my $chk_signoff = 1;
25my $chk_patch = 1;
26my $tst_only;
27my $emacs = 0;
28my $terse = 0;
29my $showfile = 0;
30my $file = 0;
31my $git = 0;
32my %git_commits = ();
33my $check = 0;
34my $check_orig = 0;
35my $summary = 1;
36my $mailback = 0;
37my $summary_file = 0;
38my $show_types = 0;
39my $list_types = 0;
40my $fix = 0;
41my $fix_inplace = 0;
42my $root;
43my %debug;
44my %camelcase = ();
45my %use_type = ();
46my @use = ();
47my %ignore_type = ();
48my @ignore = ();
49my $help = 0;
50my $configuration_file = ".checkpatch.conf";
51my $max_line_length = 80;
52my $ignore_perl_version = 0;
53my $minimum_perl_version = 5.10.0;
54my $min_conf_desc_length = 4;
55my $spelling_file = "$D/spelling.txt";
56my $codespell = 0;
57my $codespellfile = "/usr/share/codespell/dictionary.txt";
58my $conststructsfile = "$D/const_structs.checkpatch";
59my $typedefsfile = "";
60my $color = "auto";
61my $allow_c99_comments = 1;
62
63sub help {
64	my ($exitcode) = @_;
65
66	print << "EOM";
67Usage: $P [OPTION]... [FILE]...
68Version: $V
69
70Options:
71  -q, --quiet                quiet
72  --no-tree                  run without a kernel tree
73  --no-signoff               do not check for 'Signed-off-by' line
74  --patch                    treat FILE as patchfile (default)
75  --emacs                    emacs compile window format
76  --terse                    one line per report
77  --showfile                 emit diffed file position, not input file position
78  -g, --git                  treat FILE as a single commit or git revision range
79                             single git commit with:
80                               <rev>
81                               <rev>^
82                               <rev>~n
83                             multiple git commits with:
84                               <rev1>..<rev2>
85                               <rev1>...<rev2>
86                               <rev>-<count>
87                             git merges are ignored
88  -f, --file                 treat FILE as regular source file
89  --subjective, --strict     enable more subjective tests
90  --list-types               list the possible message types
91  --types TYPE(,TYPE2...)    show only these comma separated message types
92  --ignore TYPE(,TYPE2...)   ignore various comma separated message types
93  --show-types               show the specific message type in the output
94  --max-line-length=n        set the maximum line length, if exceeded, warn
95  --min-conf-desc-length=n   set the min description length, if shorter, warn
96  --root=PATH                PATH to the kernel tree root
97  --no-summary               suppress the per-file summary
98  --mailback                 only produce a report in case of warnings/errors
99  --summary-file             include the filename in summary
100  --debug KEY=[0|1]          turn on/off debugging of KEY, where KEY is one of
101                             'values', 'possible', 'type', and 'attr' (default
102                             is all off)
103  --test-only=WORD           report only warnings/errors containing WORD
104                             literally
105  --fix                      EXPERIMENTAL - may create horrible results
106                             If correctable single-line errors exist, create
107                             "<inputfile>.EXPERIMENTAL-checkpatch-fixes"
108                             with potential errors corrected to the preferred
109                             checkpatch style
110  --fix-inplace              EXPERIMENTAL - may create horrible results
111                             Is the same as --fix, but overwrites the input
112                             file.  It's your fault if there's no backup or git
113  --ignore-perl-version      override checking of perl version.  expect
114                             runtime errors.
115  --codespell                Use the codespell dictionary for spelling/typos
116                             (default:/usr/share/codespell/dictionary.txt)
117  --codespellfile            Use this codespell dictionary
118  --typedefsfile             Read additional types from this file
119  --color[=WHEN]             Use colors 'always', 'never', or only when output
120                             is a terminal ('auto'). Default is 'auto'.
121  -h, --help, --version      display this help and exit
122
123When FILE is - read standard input.
124EOM
125
126	exit($exitcode);
127}
128
129sub uniq {
130	my %seen;
131	return grep { !$seen{$_}++ } @_;
132}
133
134sub list_types {
135	my ($exitcode) = @_;
136
137	my $count = 0;
138
139	local $/ = undef;
140
141	open(my $script, '<', abs_path($P)) or
142	    die "$P: Can't read '$P' $!\n";
143
144	my $text = <$script>;
145	close($script);
146
147	my @types = ();
148	# Also catch when type or level is passed through a variable
149	for ($text =~ /(?:(?:\bCHK|\bWARN|\bERROR|&\{\$msg_level})\s*\(|\$msg_type\s*=)\s*"([^"]+)"/g) {
150		push (@types, $_);
151	}
152	@types = sort(uniq(@types));
153	print("#\tMessage type\n\n");
154	foreach my $type (@types) {
155		print(++$count . "\t" . $type . "\n");
156	}
157
158	exit($exitcode);
159}
160
161my $conf = which_conf($configuration_file);
162if (-f $conf) {
163	my @conf_args;
164	open(my $conffile, '<', "$conf")
165	    or warn "$P: Can't find a readable $configuration_file file $!\n";
166
167	while (<$conffile>) {
168		my $line = $_;
169
170		$line =~ s/\s*\n?$//g;
171		$line =~ s/^\s*//g;
172		$line =~ s/\s+/ /g;
173
174		next if ($line =~ m/^\s*#/);
175		next if ($line =~ m/^\s*$/);
176
177		my @words = split(" ", $line);
178		foreach my $word (@words) {
179			last if ($word =~ m/^#/);
180			push (@conf_args, $word);
181		}
182	}
183	close($conffile);
184	unshift(@ARGV, @conf_args) if @conf_args;
185}
186
187# Perl's Getopt::Long allows options to take optional arguments after a space.
188# Prevent --color by itself from consuming other arguments
189foreach (@ARGV) {
190	if ($_ eq "--color" || $_ eq "-color") {
191		$_ = "--color=$color";
192	}
193}
194
195GetOptions(
196	'q|quiet+'	=> \$quiet,
197	'tree!'		=> \$tree,
198	'signoff!'	=> \$chk_signoff,
199	'patch!'	=> \$chk_patch,
200	'emacs!'	=> \$emacs,
201	'terse!'	=> \$terse,
202	'showfile!'	=> \$showfile,
203	'f|file!'	=> \$file,
204	'g|git!'	=> \$git,
205	'subjective!'	=> \$check,
206	'strict!'	=> \$check,
207	'ignore=s'	=> \@ignore,
208	'types=s'	=> \@use,
209	'show-types!'	=> \$show_types,
210	'list-types!'	=> \$list_types,
211	'max-line-length=i' => \$max_line_length,
212	'min-conf-desc-length=i' => \$min_conf_desc_length,
213	'root=s'	=> \$root,
214	'summary!'	=> \$summary,
215	'mailback!'	=> \$mailback,
216	'summary-file!'	=> \$summary_file,
217	'fix!'		=> \$fix,
218	'fix-inplace!'	=> \$fix_inplace,
219	'ignore-perl-version!' => \$ignore_perl_version,
220	'debug=s'	=> \%debug,
221	'test-only=s'	=> \$tst_only,
222	'codespell!'	=> \$codespell,
223	'codespellfile=s'	=> \$codespellfile,
224	'typedefsfile=s'	=> \$typedefsfile,
225	'color=s'	=> \$color,
226	'no-color'	=> \$color,	#keep old behaviors of -nocolor
227	'nocolor'	=> \$color,	#keep old behaviors of -nocolor
228	'h|help'	=> \$help,
229	'version'	=> \$help
230) or help(1);
231
232help(0) if ($help);
233
234list_types(0) if ($list_types);
235
236$fix = 1 if ($fix_inplace);
237$check_orig = $check;
238
239my $exit = 0;
240
241if ($^V && $^V lt $minimum_perl_version) {
242	printf "$P: requires at least perl version %vd\n", $minimum_perl_version;
243	if (!$ignore_perl_version) {
244		exit(1);
245	}
246}
247
248#if no filenames are given, push '-' to read patch from stdin
249if ($#ARGV < 0) {
250	push(@ARGV, '-');
251}
252
253if ($color =~ /^[01]$/) {
254	$color = !$color;
255} elsif ($color =~ /^always$/i) {
256	$color = 1;
257} elsif ($color =~ /^never$/i) {
258	$color = 0;
259} elsif ($color =~ /^auto$/i) {
260	$color = (-t STDOUT);
261} else {
262	die "Invalid color mode: $color\n";
263}
264
265sub hash_save_array_words {
266	my ($hashRef, $arrayRef) = @_;
267
268	my @array = split(/,/, join(',', @$arrayRef));
269	foreach my $word (@array) {
270		$word =~ s/\s*\n?$//g;
271		$word =~ s/^\s*//g;
272		$word =~ s/\s+/ /g;
273		$word =~ tr/[a-z]/[A-Z]/;
274
275		next if ($word =~ m/^\s*#/);
276		next if ($word =~ m/^\s*$/);
277
278		$hashRef->{$word}++;
279	}
280}
281
282sub hash_show_words {
283	my ($hashRef, $prefix) = @_;
284
285	if (keys %$hashRef) {
286		print "\nNOTE: $prefix message types:";
287		foreach my $word (sort keys %$hashRef) {
288			print " $word";
289		}
290		print "\n";
291	}
292}
293
294hash_save_array_words(\%ignore_type, \@ignore);
295hash_save_array_words(\%use_type, \@use);
296
297my $dbg_values = 0;
298my $dbg_possible = 0;
299my $dbg_type = 0;
300my $dbg_attr = 0;
301for my $key (keys %debug) {
302	## no critic
303	eval "\${dbg_$key} = '$debug{$key}';";
304	die "$@" if ($@);
305}
306
307my $rpt_cleaners = 0;
308
309if ($terse) {
310	$emacs = 1;
311	$quiet++;
312}
313
314if ($tree) {
315	if (defined $root) {
316		if (!top_of_kernel_tree($root)) {
317			die "$P: $root: --root does not point at a valid tree\n";
318		}
319	} else {
320		if (top_of_kernel_tree('.')) {
321			$root = '.';
322		} elsif ($0 =~ m@(.*)/scripts/[^/]*$@ &&
323						top_of_kernel_tree($1)) {
324			$root = $1;
325		}
326	}
327
328	if (!defined $root) {
329		print "Must be run from the top-level dir. of a kernel tree\n";
330		exit(2);
331	}
332}
333
334my $emitted_corrupt = 0;
335
336our $Ident	= qr{
337			[A-Za-z_][A-Za-z\d_]*
338			(?:\s*\#\#\s*[A-Za-z_][A-Za-z\d_]*)*
339		}x;
340our $Storage	= qr{extern|static|asmlinkage};
341our $Sparse	= qr{
342			__user|
343			__kernel|
344			__force|
345			__iomem|
346			__must_check|
347			__init_refok|
348			__kprobes|
349			__ref|
350			__rcu|
351			__private
352		}x;
353our $InitAttributePrefix = qr{__(?:mem|cpu|dev|net_|)};
354our $InitAttributeData = qr{$InitAttributePrefix(?:initdata\b)};
355our $InitAttributeConst = qr{$InitAttributePrefix(?:initconst\b)};
356our $InitAttributeInit = qr{$InitAttributePrefix(?:init\b)};
357our $InitAttribute = qr{$InitAttributeData|$InitAttributeConst|$InitAttributeInit};
358
359# Notes to $Attribute:
360# We need \b after 'init' otherwise 'initconst' will cause a false positive in a check
361our $Attribute	= qr{
362			const|
363			__percpu|
364			__nocast|
365			__safe|
366			__bitwise|
367			__packed__|
368			__packed2__|
369			__naked|
370			__maybe_unused|
371			__always_unused|
372			__noreturn|
373			__used|
374			__cold|
375			__pure|
376			__noclone|
377			__deprecated|
378			__read_mostly|
379			__kprobes|
380			$InitAttribute|
381			____cacheline_aligned|
382			____cacheline_aligned_in_smp|
383			____cacheline_internodealigned_in_smp|
384			__weak
385		  }x;
386our $Modifier;
387our $Inline	= qr{inline|__always_inline|noinline|__inline|__inline__};
388our $Member	= qr{->$Ident|\.$Ident|\[[^]]*\]};
389our $Lval	= qr{$Ident(?:$Member)*};
390
391our $Int_type	= qr{(?i)llu|ull|ll|lu|ul|l|u};
392our $Binary	= qr{(?i)0b[01]+$Int_type?};
393our $Hex	= qr{(?i)0x[0-9a-f]+$Int_type?};
394our $Int	= qr{[0-9]+$Int_type?};
395our $Octal	= qr{0[0-7]+$Int_type?};
396our $String	= qr{"[X\t]*"};
397our $Float_hex	= qr{(?i)0x[0-9a-f]+p-?[0-9]+[fl]?};
398our $Float_dec	= qr{(?i)(?:[0-9]+\.[0-9]*|[0-9]*\.[0-9]+)(?:e-?[0-9]+)?[fl]?};
399our $Float_int	= qr{(?i)[0-9]+e-?[0-9]+[fl]?};
400our $Float	= qr{$Float_hex|$Float_dec|$Float_int};
401our $Constant	= qr{$Float|$Binary|$Octal|$Hex|$Int};
402our $Assignment	= qr{\*\=|/=|%=|\+=|-=|<<=|>>=|&=|\^=|\|=|=};
403our $Compare    = qr{<=|>=|==|!=|<|(?<!-)>};
404our $Arithmetic = qr{\+|-|\*|\/|%};
405our $Operators	= qr{
406			<=|>=|==|!=|
407			=>|->|<<|>>|<|>|!|~|
408			&&|\|\||,|\^|\+\+|--|&|\||$Arithmetic
409		  }x;
410
411our $c90_Keywords = qr{do|for|while|if|else|return|goto|continue|switch|default|case|break}x;
412
413our $BasicType;
414our $NonptrType;
415our $NonptrTypeMisordered;
416our $NonptrTypeWithAttr;
417our $Type;
418our $TypeMisordered;
419our $Declare;
420our $DeclareMisordered;
421
422our $NON_ASCII_UTF8	= qr{
423	[\xC2-\xDF][\x80-\xBF]               # non-overlong 2-byte
424	|  \xE0[\xA0-\xBF][\x80-\xBF]        # excluding overlongs
425	| [\xE1-\xEC\xEE\xEF][\x80-\xBF]{2}  # straight 3-byte
426	|  \xED[\x80-\x9F][\x80-\xBF]        # excluding surrogates
427	|  \xF0[\x90-\xBF][\x80-\xBF]{2}     # planes 1-3
428	| [\xF1-\xF3][\x80-\xBF]{3}          # planes 4-15
429	|  \xF4[\x80-\x8F][\x80-\xBF]{2}     # plane 16
430}x;
431
432our $UTF8	= qr{
433	[\x09\x0A\x0D\x20-\x7E]              # ASCII
434	| $NON_ASCII_UTF8
435}x;
436
437our $typeC99Typedefs = qr{(?:__)?(?:[us]_?)?int_?(?:8|16|32|64)_t};
438our $typeOtherOSTypedefs = qr{(?x:
439	u_(?:char|short|int|long) |          # bsd
440	u(?:nchar|short|int|long)            # sysv
441)};
442our $typeKernelTypedefs = qr{(?x:
443	(?:__)?(?:u|s|be|le)(?:8|16|32|64)|
444	atomic_t
445)};
446our $typeTypedefs = qr{(?x:
447	$typeC99Typedefs\b|
448	$typeOtherOSTypedefs\b|
449	$typeKernelTypedefs\b
450)};
451
452our $zero_initializer = qr{(?:(?:0[xX])?0+$Int_type?|NULL|false)\b};
453
454our $logFunctions = qr{(?x:
455	printk(?:_ratelimited|_once|_deferred_once|_deferred|)|
456	(?:[a-z0-9]+_){1,2}(?:printk|emerg|alert|crit|err|warning|warn|notice|info|debug|dbg|vdbg|devel|cont|WARN)(?:_ratelimited|_once|)|
457	TP_printk|
458	WARN(?:_RATELIMIT|_ONCE|)|
459	panic|
460	MODULE_[A-Z_]+|
461	seq_vprintf|seq_printf|seq_puts
462)};
463
464our $signature_tags = qr{(?xi:
465	Signed-off-by:|
466	Acked-by:|
467	Tested-by:|
468	Reviewed-by:|
469	Reported-by:|
470	Suggested-by:|
471	To:|
472	Cc:
473)};
474
475our @typeListMisordered = (
476	qr{char\s+(?:un)?signed},
477	qr{int\s+(?:(?:un)?signed\s+)?short\s},
478	qr{int\s+short(?:\s+(?:un)?signed)},
479	qr{short\s+int(?:\s+(?:un)?signed)},
480	qr{(?:un)?signed\s+int\s+short},
481	qr{short\s+(?:un)?signed},
482	qr{long\s+int\s+(?:un)?signed},
483	qr{int\s+long\s+(?:un)?signed},
484	qr{long\s+(?:un)?signed\s+int},
485	qr{int\s+(?:un)?signed\s+long},
486	qr{int\s+(?:un)?signed},
487	qr{int\s+long\s+long\s+(?:un)?signed},
488	qr{long\s+long\s+int\s+(?:un)?signed},
489	qr{long\s+long\s+(?:un)?signed\s+int},
490	qr{long\s+long\s+(?:un)?signed},
491	qr{long\s+(?:un)?signed},
492);
493
494our @typeList = (
495	qr{void},
496	qr{(?:(?:un)?signed\s+)?char},
497	qr{(?:(?:un)?signed\s+)?short\s+int},
498	qr{(?:(?:un)?signed\s+)?short},
499	qr{(?:(?:un)?signed\s+)?int},
500	qr{(?:(?:un)?signed\s+)?long\s+int},
501	qr{(?:(?:un)?signed\s+)?long\s+long\s+int},
502	qr{(?:(?:un)?signed\s+)?long\s+long},
503	qr{(?:(?:un)?signed\s+)?long},
504	qr{(?:un)?signed},
505	qr{float},
506	qr{double},
507	qr{bool},
508	qr{struct\s+$Ident},
509	qr{union\s+$Ident},
510	qr{enum\s+$Ident},
511	qr{${Ident}_t},
512	qr{${Ident}_handler},
513	qr{${Ident}_handler_fn},
514	@typeListMisordered,
515);
516
517our $C90_int_types = qr{(?x:
518	long\s+long\s+int\s+(?:un)?signed|
519	long\s+long\s+(?:un)?signed\s+int|
520	long\s+long\s+(?:un)?signed|
521	(?:(?:un)?signed\s+)?long\s+long\s+int|
522	(?:(?:un)?signed\s+)?long\s+long|
523	int\s+long\s+long\s+(?:un)?signed|
524	int\s+(?:(?:un)?signed\s+)?long\s+long|
525
526	long\s+int\s+(?:un)?signed|
527	long\s+(?:un)?signed\s+int|
528	long\s+(?:un)?signed|
529	(?:(?:un)?signed\s+)?long\s+int|
530	(?:(?:un)?signed\s+)?long|
531	int\s+long\s+(?:un)?signed|
532	int\s+(?:(?:un)?signed\s+)?long|
533
534	int\s+(?:un)?signed|
535	(?:(?:un)?signed\s+)?int
536)};
537
538our @typeListFile = ();
539our @typeListWithAttr = (
540	@typeList,
541	qr{struct\s+$InitAttribute\s+$Ident},
542	qr{union\s+$InitAttribute\s+$Ident},
543);
544
545our @modifierList = (
546	qr{fastcall},
547);
548our @modifierListFile = ();
549
550our @mode_permission_funcs = (
551	["module_param", 3],
552	["module_param_(?:array|named|string)", 4],
553	["module_param_array_named", 5],
554	["debugfs_create_(?:file|u8|u16|u32|u64|x8|x16|x32|x64|size_t|atomic_t|bool|blob|regset32|u32_array)", 2],
555	["proc_create(?:_data|)", 2],
556	["(?:CLASS|DEVICE|SENSOR|SENSOR_DEVICE|IIO_DEVICE)_ATTR", 2],
557	["IIO_DEV_ATTR_[A-Z_]+", 1],
558	["SENSOR_(?:DEVICE_|)ATTR_2", 2],
559	["SENSOR_TEMPLATE(?:_2|)", 3],
560	["__ATTR", 2],
561);
562
563#Create a search pattern for all these functions to speed up a loop below
564our $mode_perms_search = "";
565foreach my $entry (@mode_permission_funcs) {
566	$mode_perms_search .= '|' if ($mode_perms_search ne "");
567	$mode_perms_search .= $entry->[0];
568}
569$mode_perms_search = "(?:${mode_perms_search})";
570
571our $mode_perms_world_writable = qr{
572	S_IWUGO		|
573	S_IWOTH		|
574	S_IRWXUGO	|
575	S_IALLUGO	|
576	0[0-7][0-7][2367]
577}x;
578
579our %mode_permission_string_types = (
580	"S_IRWXU" => 0700,
581	"S_IRUSR" => 0400,
582	"S_IWUSR" => 0200,
583	"S_IXUSR" => 0100,
584	"S_IRWXG" => 0070,
585	"S_IRGRP" => 0040,
586	"S_IWGRP" => 0020,
587	"S_IXGRP" => 0010,
588	"S_IRWXO" => 0007,
589	"S_IROTH" => 0004,
590	"S_IWOTH" => 0002,
591	"S_IXOTH" => 0001,
592	"S_IRWXUGO" => 0777,
593	"S_IRUGO" => 0444,
594	"S_IWUGO" => 0222,
595	"S_IXUGO" => 0111,
596);
597
598#Create a search pattern for all these strings to speed up a loop below
599our $mode_perms_string_search = "";
600foreach my $entry (keys %mode_permission_string_types) {
601	$mode_perms_string_search .= '|' if ($mode_perms_string_search ne "");
602	$mode_perms_string_search .= $entry;
603}
604our $single_mode_perms_string_search = "(?:${mode_perms_string_search})";
605our $multi_mode_perms_string_search = qr{
606	${single_mode_perms_string_search}
607	(?:\s*\|\s*${single_mode_perms_string_search})*
608}x;
609
610sub perms_to_octal {
611	my ($string) = @_;
612
613	return trim($string) if ($string =~ /^\s*0[0-7]{3,3}\s*$/);
614
615	my $val = "";
616	my $oval = "";
617	my $to = 0;
618	my $curpos = 0;
619	my $lastpos = 0;
620	while ($string =~ /\b(($single_mode_perms_string_search)\b(?:\s*\|\s*)?\s*)/g) {
621		$curpos = pos($string);
622		my $match = $2;
623		my $omatch = $1;
624		last if ($lastpos > 0 && ($curpos - length($omatch) != $lastpos));
625		$lastpos = $curpos;
626		$to |= $mode_permission_string_types{$match};
627		$val .= '\s*\|\s*' if ($val ne "");
628		$val .= $match;
629		$oval .= $omatch;
630	}
631	$oval =~ s/^\s*\|\s*//;
632	$oval =~ s/\s*\|\s*$//;
633	return sprintf("%04o", $to);
634}
635
636our $allowed_asm_includes = qr{(?x:
637	irq|
638	memory|
639	time|
640	reboot
641)};
642# memory.h: ARM has a custom one
643
644# Load common spelling mistakes and build regular expression list.
645my $misspellings;
646my %spelling_fix;
647
648if (open(my $spelling, '<', $spelling_file)) {
649	while (<$spelling>) {
650		my $line = $_;
651
652		$line =~ s/\s*\n?$//g;
653		$line =~ s/^\s*//g;
654
655		next if ($line =~ m/^\s*#/);
656		next if ($line =~ m/^\s*$/);
657
658		my ($suspect, $fix) = split(/\|\|/, $line);
659
660		$spelling_fix{$suspect} = $fix;
661	}
662	close($spelling);
663} else {
664	warn "No typos will be found - file '$spelling_file': $!\n";
665}
666
667if ($codespell) {
668	if (open(my $spelling, '<', $codespellfile)) {
669		while (<$spelling>) {
670			my $line = $_;
671
672			$line =~ s/\s*\n?$//g;
673			$line =~ s/^\s*//g;
674
675			next if ($line =~ m/^\s*#/);
676			next if ($line =~ m/^\s*$/);
677			next if ($line =~ m/, disabled/i);
678
679			$line =~ s/,.*$//;
680
681			my ($suspect, $fix) = split(/->/, $line);
682
683			$spelling_fix{$suspect} = $fix;
684		}
685		close($spelling);
686	} else {
687		warn "No codespell typos will be found - file '$codespellfile': $!\n";
688	}
689}
690
691$misspellings = join("|", sort keys %spelling_fix) if keys %spelling_fix;
692
693sub read_words {
694	my ($wordsRef, $file) = @_;
695
696	if (open(my $words, '<', $file)) {
697		while (<$words>) {
698			my $line = $_;
699
700			$line =~ s/\s*\n?$//g;
701			$line =~ s/^\s*//g;
702
703			next if ($line =~ m/^\s*#/);
704			next if ($line =~ m/^\s*$/);
705			if ($line =~ /\s/) {
706				print("$file: '$line' invalid - ignored\n");
707				next;
708			}
709
710			$$wordsRef .= '|' if ($$wordsRef ne "");
711			$$wordsRef .= $line;
712		}
713		close($file);
714		return 1;
715	}
716
717	return 0;
718}
719
720my $const_structs = "";
721read_words(\$const_structs, $conststructsfile)
722    or warn "No structs that should be const will be found - file '$conststructsfile': $!\n";
723
724my $typeOtherTypedefs = "";
725if (length($typedefsfile)) {
726	read_words(\$typeOtherTypedefs, $typedefsfile)
727	    or warn "No additional types will be considered - file '$typedefsfile': $!\n";
728}
729$typeTypedefs .= '|' . $typeOtherTypedefs if ($typeOtherTypedefs ne "");
730
731sub build_types {
732	my $mods = "(?x:  \n" . join("|\n  ", (@modifierList, @modifierListFile)) . "\n)";
733	my $all = "(?x:  \n" . join("|\n  ", (@typeList, @typeListFile)) . "\n)";
734	my $Misordered = "(?x:  \n" . join("|\n  ", @typeListMisordered) . "\n)";
735	my $allWithAttr = "(?x:  \n" . join("|\n  ", @typeListWithAttr) . "\n)";
736	$Modifier	= qr{(?:$Attribute|$Sparse|$mods)};
737	$BasicType	= qr{
738				(?:$typeTypedefs\b)|
739				(?:${all}\b)
740		}x;
741	$NonptrType	= qr{
742			(?:$Modifier\s+|const\s+)*
743			(?:
744				(?:typeof|__typeof__)\s*\([^\)]*\)|
745				(?:$typeTypedefs\b)|
746				(?:${all}\b)
747			)
748			(?:\s+$Modifier|\s+const)*
749		  }x;
750	$NonptrTypeMisordered	= qr{
751			(?:$Modifier\s+|const\s+)*
752			(?:
753				(?:${Misordered}\b)
754			)
755			(?:\s+$Modifier|\s+const)*
756		  }x;
757	$NonptrTypeWithAttr	= qr{
758			(?:$Modifier\s+|const\s+)*
759			(?:
760				(?:typeof|__typeof__)\s*\([^\)]*\)|
761				(?:$typeTypedefs\b)|
762				(?:${allWithAttr}\b)
763			)
764			(?:\s+$Modifier|\s+const)*
765		  }x;
766	$Type	= qr{
767			$NonptrType
768			(?:(?:\s|\*|\[\])+\s*const|(?:\s|\*\s*(?:const\s*)?|\[\])+|(?:\s*\[\s*\])+)?
769			(?:\s+$Inline|\s+$Modifier)*
770		  }x;
771	$TypeMisordered	= qr{
772			$NonptrTypeMisordered
773			(?:(?:\s|\*|\[\])+\s*const|(?:\s|\*\s*(?:const\s*)?|\[\])+|(?:\s*\[\s*\])+)?
774			(?:\s+$Inline|\s+$Modifier)*
775		  }x;
776	$Declare	= qr{(?:$Storage\s+(?:$Inline\s+)?)?$Type};
777	$DeclareMisordered	= qr{(?:$Storage\s+(?:$Inline\s+)?)?$TypeMisordered};
778}
779build_types();
780
781our $Typecast	= qr{\s*(\(\s*$NonptrType\s*\)){0,1}\s*};
782
783# Using $balanced_parens, $LvalOrFunc, or $FuncArg
784# requires at least perl version v5.10.0
785# Any use must be runtime checked with $^V
786
787our $balanced_parens = qr/(\((?:[^\(\)]++|(?-1))*\))/;
788our $LvalOrFunc	= qr{((?:[\&\*]\s*)?$Lval)\s*($balanced_parens{0,1})\s*};
789our $FuncArg = qr{$Typecast{0,1}($LvalOrFunc|$Constant|$String)};
790
791our $declaration_macros = qr{(?x:
792	(?:$Storage\s+)?(?:[A-Z_][A-Z0-9]*_){0,2}(?:DEFINE|DECLARE)(?:_[A-Z0-9]+){1,6}\s*\(|
793	(?:$Storage\s+)?[HLP]?LIST_HEAD\s*\(|
794	(?:$Storage\s+)?${Type}\s+uninitialized_var\s*\(|
795	(?:SKCIPHER_REQUEST|SHASH_DESC|AHASH_REQUEST)_ON_STACK\s*\(
796)};
797
798sub deparenthesize {
799	my ($string) = @_;
800	return "" if (!defined($string));
801
802	while ($string =~ /^\s*\(.*\)\s*$/) {
803		$string =~ s@^\s*\(\s*@@;
804		$string =~ s@\s*\)\s*$@@;
805	}
806
807	$string =~ s@\s+@ @g;
808
809	return $string;
810}
811
812sub seed_camelcase_file {
813	my ($file) = @_;
814
815	return if (!(-f $file));
816
817	local $/;
818
819	open(my $include_file, '<', "$file")
820	    or warn "$P: Can't read '$file' $!\n";
821	my $text = <$include_file>;
822	close($include_file);
823
824	my @lines = split('\n', $text);
825
826	foreach my $line (@lines) {
827		next if ($line !~ /(?:[A-Z][a-z]|[a-z][A-Z])/);
828		if ($line =~ /^[ \t]*(?:#[ \t]*define|typedef\s+$Type)\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)/) {
829			$camelcase{$1} = 1;
830		} elsif ($line =~ /^\s*$Declare\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)\s*[\(\[,;]/) {
831			$camelcase{$1} = 1;
832		} elsif ($line =~ /^\s*(?:union|struct|enum)\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)\s*[;\{]/) {
833			$camelcase{$1} = 1;
834		}
835	}
836}
837
838sub is_maintained_obsolete {
839	my ($filename) = @_;
840
841	return 0 if (!$tree || !(-e "$root/scripts/get_maintainer.pl"));
842
843	my $status = `perl $root/scripts/get_maintainer.pl --status --nom --nol --nogit --nogit-fallback -f $filename 2>&1`;
844
845	return $status =~ /obsolete/i;
846}
847
848my $camelcase_seeded = 0;
849sub seed_camelcase_includes {
850	return if ($camelcase_seeded);
851
852	my $files;
853	my $camelcase_cache = "";
854	my @include_files = ();
855
856	$camelcase_seeded = 1;
857
858	if (-e ".git") {
859		my $git_last_include_commit = `git log --no-merges --pretty=format:"%h%n" -1 -- include`;
860		chomp $git_last_include_commit;
861		$camelcase_cache = ".checkpatch-camelcase.git.$git_last_include_commit";
862	} else {
863		my $last_mod_date = 0;
864		$files = `find $root/include -name "*.h"`;
865		@include_files = split('\n', $files);
866		foreach my $file (@include_files) {
867			my $date = POSIX::strftime("%Y%m%d%H%M",
868						   localtime((stat $file)[9]));
869			$last_mod_date = $date if ($last_mod_date < $date);
870		}
871		$camelcase_cache = ".checkpatch-camelcase.date.$last_mod_date";
872	}
873
874	if ($camelcase_cache ne "" && -f $camelcase_cache) {
875		open(my $camelcase_file, '<', "$camelcase_cache")
876		    or warn "$P: Can't read '$camelcase_cache' $!\n";
877		while (<$camelcase_file>) {
878			chomp;
879			$camelcase{$_} = 1;
880		}
881		close($camelcase_file);
882
883		return;
884	}
885
886	if (-e ".git") {
887		$files = `git ls-files "include/*.h"`;
888		@include_files = split('\n', $files);
889	}
890
891	foreach my $file (@include_files) {
892		seed_camelcase_file($file);
893	}
894
895	if ($camelcase_cache ne "") {
896		unlink glob ".checkpatch-camelcase.*";
897		open(my $camelcase_file, '>', "$camelcase_cache")
898		    or warn "$P: Can't write '$camelcase_cache' $!\n";
899		foreach (sort { lc($a) cmp lc($b) } keys(%camelcase)) {
900			print $camelcase_file ("$_\n");
901		}
902		close($camelcase_file);
903	}
904}
905
906sub git_commit_info {
907	my ($commit, $id, $desc) = @_;
908
909	return ($id, $desc) if ((which("git") eq "") || !(-e ".git"));
910
911	my $output = `git log --no-color --format='%H %s' -1 $commit 2>&1`;
912	$output =~ s/^\s*//gm;
913	my @lines = split("\n", $output);
914
915	return ($id, $desc) if ($#lines < 0);
916
917	if ($lines[0] =~ /^error: short SHA1 $commit is ambiguous\./) {
918# Maybe one day convert this block of bash into something that returns
919# all matching commit ids, but it's very slow...
920#
921#		echo "checking commits $1..."
922#		git rev-list --remotes | grep -i "^$1" |
923#		while read line ; do
924#		    git log --format='%H %s' -1 $line |
925#		    echo "commit $(cut -c 1-12,41-)"
926#		done
927	} elsif ($lines[0] =~ /^fatal: ambiguous argument '$commit': unknown revision or path not in the working tree\./) {
928		$id = undef;
929	} else {
930		$id = substr($lines[0], 0, 12);
931		$desc = substr($lines[0], 41);
932	}
933
934	return ($id, $desc);
935}
936
937$chk_signoff = 0 if ($file);
938
939my @rawlines = ();
940my @lines = ();
941my @fixed = ();
942my @fixed_inserted = ();
943my @fixed_deleted = ();
944my $fixlinenr = -1;
945
946# If input is git commits, extract all commits from the commit expressions.
947# For example, HEAD-3 means we need check 'HEAD, HEAD~1, HEAD~2'.
948die "$P: No git repository found\n" if ($git && !-e ".git");
949
950if ($git) {
951	my @commits = ();
952	foreach my $commit_expr (@ARGV) {
953		my $git_range;
954		if ($commit_expr =~ m/^(.*)-(\d+)$/) {
955			$git_range = "-$2 $1";
956		} elsif ($commit_expr =~ m/\.\./) {
957			$git_range = "$commit_expr";
958		} else {
959			$git_range = "-1 $commit_expr";
960		}
961		my $lines = `git log --no-color --no-merges --pretty=format:'%H %s' $git_range`;
962		foreach my $line (split(/\n/, $lines)) {
963			$line =~ /^([0-9a-fA-F]{40,40}) (.*)$/;
964			next if (!defined($1) || !defined($2));
965			my $sha1 = $1;
966			my $subject = $2;
967			unshift(@commits, $sha1);
968			$git_commits{$sha1} = $subject;
969		}
970	}
971	die "$P: no git commits after extraction!\n" if (@commits == 0);
972	@ARGV = @commits;
973}
974
975my $vname;
976for my $filename (@ARGV) {
977	my $FILE;
978	if ($git) {
979		open($FILE, '-|', "git format-patch -M --stdout -1 $filename") ||
980			die "$P: $filename: git format-patch failed - $!\n";
981	} elsif ($file) {
982		open($FILE, '-|', "diff -u /dev/null $filename") ||
983			die "$P: $filename: diff failed - $!\n";
984	} elsif ($filename eq '-') {
985		open($FILE, '<&STDIN');
986	} else {
987		open($FILE, '<', "$filename") ||
988			die "$P: $filename: open failed - $!\n";
989	}
990	if ($filename eq '-') {
991		$vname = 'Your patch';
992	} elsif ($git) {
993		$vname = "Commit " . substr($filename, 0, 12) . ' ("' . $git_commits{$filename} . '")';
994	} else {
995		$vname = $filename;
996	}
997	while (<$FILE>) {
998		chomp;
999		push(@rawlines, $_);
1000	}
1001	close($FILE);
1002
1003	if ($#ARGV > 0 && $quiet == 0) {
1004		print '-' x length($vname) . "\n";
1005		print "$vname\n";
1006		print '-' x length($vname) . "\n";
1007	}
1008
1009	if (!process($filename)) {
1010		$exit = 1;
1011	}
1012	@rawlines = ();
1013	@lines = ();
1014	@fixed = ();
1015	@fixed_inserted = ();
1016	@fixed_deleted = ();
1017	$fixlinenr = -1;
1018	@modifierListFile = ();
1019	@typeListFile = ();
1020	build_types();
1021}
1022
1023if (!$quiet) {
1024	hash_show_words(\%use_type, "Used");
1025	hash_show_words(\%ignore_type, "Ignored");
1026
1027	if ($^V lt 5.10.0) {
1028		print << "EOM"
1029
1030NOTE: perl $^V is not modern enough to detect all possible issues.
1031      An upgrade to at least perl v5.10.0 is suggested.
1032EOM
1033	}
1034	if ($exit) {
1035		print << "EOM"
1036
1037NOTE: If any of the errors are false positives, please report
1038      them to the maintainer, see CHECKPATCH in MAINTAINERS.
1039EOM
1040	}
1041}
1042
1043exit($exit);
1044
1045sub top_of_kernel_tree {
1046	my ($root) = @_;
1047
1048	my @tree_check = (
1049		"COPYING", "CREDITS", "Kbuild", "MAINTAINERS", "Makefile",
1050		"README", "Documentation", "arch", "include", "drivers",
1051		"fs", "init", "ipc", "kernel", "lib", "scripts",
1052	);
1053
1054	foreach my $check (@tree_check) {
1055		if (! -e $root . '/' . $check) {
1056			return 0;
1057		}
1058	}
1059	return 1;
1060}
1061
1062sub parse_email {
1063	my ($formatted_email) = @_;
1064
1065	my $name = "";
1066	my $address = "";
1067	my $comment = "";
1068
1069	if ($formatted_email =~ /^(.*)<(\S+\@\S+)>(.*)$/) {
1070		$name = $1;
1071		$address = $2;
1072		$comment = $3 if defined $3;
1073	} elsif ($formatted_email =~ /^\s*<(\S+\@\S+)>(.*)$/) {
1074		$address = $1;
1075		$comment = $2 if defined $2;
1076	} elsif ($formatted_email =~ /(\S+\@\S+)(.*)$/) {
1077		$address = $1;
1078		$comment = $2 if defined $2;
1079		$formatted_email =~ s/\Q$address\E.*$//;
1080		$name = $formatted_email;
1081		$name = trim($name);
1082		$name =~ s/^\"|\"$//g;
1083		# If there's a name left after stripping spaces and
1084		# leading quotes, and the address doesn't have both
1085		# leading and trailing angle brackets, the address
1086		# is invalid. ie:
1087		#   "joe smith joe@smith.com" bad
1088		#   "joe smith <joe@smith.com" bad
1089		if ($name ne "" && $address !~ /^<[^>]+>$/) {
1090			$name = "";
1091			$address = "";
1092			$comment = "";
1093		}
1094	}
1095
1096	$name = trim($name);
1097	$name =~ s/^\"|\"$//g;
1098	$address = trim($address);
1099	$address =~ s/^\<|\>$//g;
1100
1101	if ($name =~ /[^\w \-]/i) { ##has "must quote" chars
1102		$name =~ s/(?<!\\)"/\\"/g; ##escape quotes
1103		$name = "\"$name\"";
1104	}
1105
1106	return ($name, $address, $comment);
1107}
1108
1109sub format_email {
1110	my ($name, $address) = @_;
1111
1112	my $formatted_email;
1113
1114	$name = trim($name);
1115	$name =~ s/^\"|\"$//g;
1116	$address = trim($address);
1117
1118	if ($name =~ /[^\w \-]/i) { ##has "must quote" chars
1119		$name =~ s/(?<!\\)"/\\"/g; ##escape quotes
1120		$name = "\"$name\"";
1121	}
1122
1123	if ("$name" eq "") {
1124		$formatted_email = "$address";
1125	} else {
1126		$formatted_email = "$name <$address>";
1127	}
1128
1129	return $formatted_email;
1130}
1131
1132sub which {
1133	my ($bin) = @_;
1134
1135	foreach my $path (split(/:/, $ENV{PATH})) {
1136		if (-e "$path/$bin") {
1137			return "$path/$bin";
1138		}
1139	}
1140
1141	return "";
1142}
1143
1144sub which_conf {
1145	my ($conf) = @_;
1146
1147	foreach my $path (split(/:/, ".:$ENV{HOME}:.scripts")) {
1148		if (-e "$path/$conf") {
1149			return "$path/$conf";
1150		}
1151	}
1152
1153	return "";
1154}
1155
1156sub expand_tabs {
1157	my ($str) = @_;
1158
1159	my $res = '';
1160	my $n = 0;
1161	for my $c (split(//, $str)) {
1162		if ($c eq "\t") {
1163			$res .= ' ';
1164			$n++;
1165			for (; ($n % 8) != 0; $n++) {
1166				$res .= ' ';
1167			}
1168			next;
1169		}
1170		$res .= $c;
1171		$n++;
1172	}
1173
1174	return $res;
1175}
1176sub copy_spacing {
1177	(my $res = shift) =~ tr/\t/ /c;
1178	return $res;
1179}
1180
1181sub line_stats {
1182	my ($line) = @_;
1183
1184	# Drop the diff line leader and expand tabs
1185	$line =~ s/^.//;
1186	$line = expand_tabs($line);
1187
1188	# Pick the indent from the front of the line.
1189	my ($white) = ($line =~ /^(\s*)/);
1190
1191	return (length($line), length($white));
1192}
1193
1194my $sanitise_quote = '';
1195
1196sub sanitise_line_reset {
1197	my ($in_comment) = @_;
1198
1199	if ($in_comment) {
1200		$sanitise_quote = '*/';
1201	} else {
1202		$sanitise_quote = '';
1203	}
1204}
1205sub sanitise_line {
1206	my ($line) = @_;
1207
1208	my $res = '';
1209	my $l = '';
1210
1211	my $qlen = 0;
1212	my $off = 0;
1213	my $c;
1214
1215	# Always copy over the diff marker.
1216	$res = substr($line, 0, 1);
1217
1218	for ($off = 1; $off < length($line); $off++) {
1219		$c = substr($line, $off, 1);
1220
1221		# Comments we are whacking completely including the begin
1222		# and end, all to $;.
1223		if ($sanitise_quote eq '' && substr($line, $off, 2) eq '/*') {
1224			$sanitise_quote = '*/';
1225
1226			substr($res, $off, 2, "$;$;");
1227			$off++;
1228			next;
1229		}
1230		if ($sanitise_quote eq '*/' && substr($line, $off, 2) eq '*/') {
1231			$sanitise_quote = '';
1232			substr($res, $off, 2, "$;$;");
1233			$off++;
1234			next;
1235		}
1236		if ($sanitise_quote eq '' && substr($line, $off, 2) eq '//') {
1237			$sanitise_quote = '//';
1238
1239			substr($res, $off, 2, $sanitise_quote);
1240			$off++;
1241			next;
1242		}
1243
1244		# A \ in a string means ignore the next character.
1245		if (($sanitise_quote eq "'" || $sanitise_quote eq '"') &&
1246		    $c eq "\\") {
1247			substr($res, $off, 2, 'XX');
1248			$off++;
1249			next;
1250		}
1251		# Regular quotes.
1252		if ($c eq "'" || $c eq '"') {
1253			if ($sanitise_quote eq '') {
1254				$sanitise_quote = $c;
1255
1256				substr($res, $off, 1, $c);
1257				next;
1258			} elsif ($sanitise_quote eq $c) {
1259				$sanitise_quote = '';
1260			}
1261		}
1262
1263		#print "c<$c> SQ<$sanitise_quote>\n";
1264		if ($off != 0 && $sanitise_quote eq '*/' && $c ne "\t") {
1265			substr($res, $off, 1, $;);
1266		} elsif ($off != 0 && $sanitise_quote eq '//' && $c ne "\t") {
1267			substr($res, $off, 1, $;);
1268		} elsif ($off != 0 && $sanitise_quote && $c ne "\t") {
1269			substr($res, $off, 1, 'X');
1270		} else {
1271			substr($res, $off, 1, $c);
1272		}
1273	}
1274
1275	if ($sanitise_quote eq '//') {
1276		$sanitise_quote = '';
1277	}
1278
1279	# The pathname on a #include may be surrounded by '<' and '>'.
1280	if ($res =~ /^.\s*\#\s*include\s+\<(.*)\>/) {
1281		my $clean = 'X' x length($1);
1282		$res =~ s@\<.*\>@<$clean>@;
1283
1284	# The whole of a #error is a string.
1285	} elsif ($res =~ /^.\s*\#\s*(?:error|warning)\s+(.*)\b/) {
1286		my $clean = 'X' x length($1);
1287		$res =~ s@(\#\s*(?:error|warning)\s+).*@$1$clean@;
1288	}
1289
1290	if ($allow_c99_comments && $res =~ m@(//.*$)@) {
1291		my $match = $1;
1292		$res =~ s/\Q$match\E/"$;" x length($match)/e;
1293	}
1294
1295	return $res;
1296}
1297
1298sub get_quoted_string {
1299	my ($line, $rawline) = @_;
1300
1301	return "" if (!defined($line) || !defined($rawline));
1302	return "" if ($line !~ m/($String)/g);
1303	return substr($rawline, $-[0], $+[0] - $-[0]);
1304}
1305
1306sub ctx_statement_block {
1307	my ($linenr, $remain, $off) = @_;
1308	my $line = $linenr - 1;
1309	my $blk = '';
1310	my $soff = $off;
1311	my $coff = $off - 1;
1312	my $coff_set = 0;
1313
1314	my $loff = 0;
1315
1316	my $type = '';
1317	my $level = 0;
1318	my @stack = ();
1319	my $p;
1320	my $c;
1321	my $len = 0;
1322
1323	my $remainder;
1324	while (1) {
1325		@stack = (['', 0]) if ($#stack == -1);
1326
1327		#warn "CSB: blk<$blk> remain<$remain>\n";
1328		# If we are about to drop off the end, pull in more
1329		# context.
1330		if ($off >= $len) {
1331			for (; $remain > 0; $line++) {
1332				last if (!defined $lines[$line]);
1333				next if ($lines[$line] =~ /^-/);
1334				$remain--;
1335				$loff = $len;
1336				$blk .= $lines[$line] . "\n";
1337				$len = length($blk);
1338				$line++;
1339				last;
1340			}
1341			# Bail if there is no further context.
1342			#warn "CSB: blk<$blk> off<$off> len<$len>\n";
1343			if ($off >= $len) {
1344				last;
1345			}
1346			if ($level == 0 && substr($blk, $off) =~ /^.\s*#\s*define/) {
1347				$level++;
1348				$type = '#';
1349			}
1350		}
1351		$p = $c;
1352		$c = substr($blk, $off, 1);
1353		$remainder = substr($blk, $off);
1354
1355		#warn "CSB: c<$c> type<$type> level<$level> remainder<$remainder> coff_set<$coff_set>\n";
1356
1357		# Handle nested #if/#else.
1358		if ($remainder =~ /^#\s*(?:ifndef|ifdef|if)\s/) {
1359			push(@stack, [ $type, $level ]);
1360		} elsif ($remainder =~ /^#\s*(?:else|elif)\b/) {
1361			($type, $level) = @{$stack[$#stack - 1]};
1362		} elsif ($remainder =~ /^#\s*endif\b/) {
1363			($type, $level) = @{pop(@stack)};
1364		}
1365
1366		# Statement ends at the ';' or a close '}' at the
1367		# outermost level.
1368		if ($level == 0 && $c eq ';') {
1369			last;
1370		}
1371
1372		# An else is really a conditional as long as its not else if
1373		if ($level == 0 && $coff_set == 0 &&
1374				(!defined($p) || $p =~ /(?:\s|\}|\+)/) &&
1375				$remainder =~ /^(else)(?:\s|{)/ &&
1376				$remainder !~ /^else\s+if\b/) {
1377			$coff = $off + length($1) - 1;
1378			$coff_set = 1;
1379			#warn "CSB: mark coff<$coff> soff<$soff> 1<$1>\n";
1380			#warn "[" . substr($blk, $soff, $coff - $soff + 1) . "]\n";
1381		}
1382
1383		if (($type eq '' || $type eq '(') && $c eq '(') {
1384			$level++;
1385			$type = '(';
1386		}
1387		if ($type eq '(' && $c eq ')') {
1388			$level--;
1389			$type = ($level != 0)? '(' : '';
1390
1391			if ($level == 0 && $coff < $soff) {
1392				$coff = $off;
1393				$coff_set = 1;
1394				#warn "CSB: mark coff<$coff>\n";
1395			}
1396		}
1397		if (($type eq '' || $type eq '{') && $c eq '{') {
1398			$level++;
1399			$type = '{';
1400		}
1401		if ($type eq '{' && $c eq '}') {
1402			$level--;
1403			$type = ($level != 0)? '{' : '';
1404
1405			if ($level == 0) {
1406				if (substr($blk, $off + 1, 1) eq ';') {
1407					$off++;
1408				}
1409				last;
1410			}
1411		}
1412		# Preprocessor commands end at the newline unless escaped.
1413		if ($type eq '#' && $c eq "\n" && $p ne "\\") {
1414			$level--;
1415			$type = '';
1416			$off++;
1417			last;
1418		}
1419		$off++;
1420	}
1421	# We are truly at the end, so shuffle to the next line.
1422	if ($off == $len) {
1423		$loff = $len + 1;
1424		$line++;
1425		$remain--;
1426	}
1427
1428	my $statement = substr($blk, $soff, $off - $soff + 1);
1429	my $condition = substr($blk, $soff, $coff - $soff + 1);
1430
1431	#warn "STATEMENT<$statement>\n";
1432	#warn "CONDITION<$condition>\n";
1433
1434	#print "coff<$coff> soff<$off> loff<$loff>\n";
1435
1436	return ($statement, $condition,
1437			$line, $remain + 1, $off - $loff + 1, $level);
1438}
1439
1440sub statement_lines {
1441	my ($stmt) = @_;
1442
1443	# Strip the diff line prefixes and rip blank lines at start and end.
1444	$stmt =~ s/(^|\n)./$1/g;
1445	$stmt =~ s/^\s*//;
1446	$stmt =~ s/\s*$//;
1447
1448	my @stmt_lines = ($stmt =~ /\n/g);
1449
1450	return $#stmt_lines + 2;
1451}
1452
1453sub statement_rawlines {
1454	my ($stmt) = @_;
1455
1456	my @stmt_lines = ($stmt =~ /\n/g);
1457
1458	return $#stmt_lines + 2;
1459}
1460
1461sub statement_block_size {
1462	my ($stmt) = @_;
1463
1464	$stmt =~ s/(^|\n)./$1/g;
1465	$stmt =~ s/^\s*{//;
1466	$stmt =~ s/}\s*$//;
1467	$stmt =~ s/^\s*//;
1468	$stmt =~ s/\s*$//;
1469
1470	my @stmt_lines = ($stmt =~ /\n/g);
1471	my @stmt_statements = ($stmt =~ /;/g);
1472
1473	my $stmt_lines = $#stmt_lines + 2;
1474	my $stmt_statements = $#stmt_statements + 1;
1475
1476	if ($stmt_lines > $stmt_statements) {
1477		return $stmt_lines;
1478	} else {
1479		return $stmt_statements;
1480	}
1481}
1482
1483sub ctx_statement_full {
1484	my ($linenr, $remain, $off) = @_;
1485	my ($statement, $condition, $level);
1486
1487	my (@chunks);
1488
1489	# Grab the first conditional/block pair.
1490	($statement, $condition, $linenr, $remain, $off, $level) =
1491				ctx_statement_block($linenr, $remain, $off);
1492	#print "F: c<$condition> s<$statement> remain<$remain>\n";
1493	push(@chunks, [ $condition, $statement ]);
1494	if (!($remain > 0 && $condition =~ /^\s*(?:\n[+-])?\s*(?:if|else|do)\b/s)) {
1495		return ($level, $linenr, @chunks);
1496	}
1497
1498	# Pull in the following conditional/block pairs and see if they
1499	# could continue the statement.
1500	for (;;) {
1501		($statement, $condition, $linenr, $remain, $off, $level) =
1502				ctx_statement_block($linenr, $remain, $off);
1503		#print "C: c<$condition> s<$statement> remain<$remain>\n";
1504		last if (!($remain > 0 && $condition =~ /^(?:\s*\n[+-])*\s*(?:else|do)\b/s));
1505		#print "C: push\n";
1506		push(@chunks, [ $condition, $statement ]);
1507	}
1508
1509	return ($level, $linenr, @chunks);
1510}
1511
1512sub ctx_block_get {
1513	my ($linenr, $remain, $outer, $open, $close, $off) = @_;
1514	my $line;
1515	my $start = $linenr - 1;
1516	my $blk = '';
1517	my @o;
1518	my @c;
1519	my @res = ();
1520
1521	my $level = 0;
1522	my @stack = ($level);
1523	for ($line = $start; $remain > 0; $line++) {
1524		next if ($rawlines[$line] =~ /^-/);
1525		$remain--;
1526
1527		$blk .= $rawlines[$line];
1528
1529		# Handle nested #if/#else.
1530		if ($lines[$line] =~ /^.\s*#\s*(?:ifndef|ifdef|if)\s/) {
1531			push(@stack, $level);
1532		} elsif ($lines[$line] =~ /^.\s*#\s*(?:else|elif)\b/) {
1533			$level = $stack[$#stack - 1];
1534		} elsif ($lines[$line] =~ /^.\s*#\s*endif\b/) {
1535			$level = pop(@stack);
1536		}
1537
1538		foreach my $c (split(//, $lines[$line])) {
1539			##print "C<$c>L<$level><$open$close>O<$off>\n";
1540			if ($off > 0) {
1541				$off--;
1542				next;
1543			}
1544
1545			if ($c eq $close && $level > 0) {
1546				$level--;
1547				last if ($level == 0);
1548			} elsif ($c eq $open) {
1549				$level++;
1550			}
1551		}
1552
1553		if (!$outer || $level <= 1) {
1554			push(@res, $rawlines[$line]);
1555		}
1556
1557		last if ($level == 0);
1558	}
1559
1560	return ($level, @res);
1561}
1562sub ctx_block_outer {
1563	my ($linenr, $remain) = @_;
1564
1565	my ($level, @r) = ctx_block_get($linenr, $remain, 1, '{', '}', 0);
1566	return @r;
1567}
1568sub ctx_block {
1569	my ($linenr, $remain) = @_;
1570
1571	my ($level, @r) = ctx_block_get($linenr, $remain, 0, '{', '}', 0);
1572	return @r;
1573}
1574sub ctx_statement {
1575	my ($linenr, $remain, $off) = @_;
1576
1577	my ($level, @r) = ctx_block_get($linenr, $remain, 0, '(', ')', $off);
1578	return @r;
1579}
1580sub ctx_block_level {
1581	my ($linenr, $remain) = @_;
1582
1583	return ctx_block_get($linenr, $remain, 0, '{', '}', 0);
1584}
1585sub ctx_statement_level {
1586	my ($linenr, $remain, $off) = @_;
1587
1588	return ctx_block_get($linenr, $remain, 0, '(', ')', $off);
1589}
1590
1591sub ctx_locate_comment {
1592	my ($first_line, $end_line) = @_;
1593
1594	# Catch a comment on the end of the line itself.
1595	my ($current_comment) = ($rawlines[$end_line - 1] =~ m@.*(/\*.*\*/)\s*(?:\\\s*)?$@);
1596	return $current_comment if (defined $current_comment);
1597
1598	# Look through the context and try and figure out if there is a
1599	# comment.
1600	my $in_comment = 0;
1601	$current_comment = '';
1602	for (my $linenr = $first_line; $linenr < $end_line; $linenr++) {
1603		my $line = $rawlines[$linenr - 1];
1604		#warn "           $line\n";
1605		if ($linenr == $first_line and $line =~ m@^.\s*\*@) {
1606			$in_comment = 1;
1607		}
1608		if ($line =~ m@/\*@) {
1609			$in_comment = 1;
1610		}
1611		if (!$in_comment && $current_comment ne '') {
1612			$current_comment = '';
1613		}
1614		$current_comment .= $line . "\n" if ($in_comment);
1615		if ($line =~ m@\*/@) {
1616			$in_comment = 0;
1617		}
1618	}
1619
1620	chomp($current_comment);
1621	return($current_comment);
1622}
1623sub ctx_has_comment {
1624	my ($first_line, $end_line) = @_;
1625	my $cmt = ctx_locate_comment($first_line, $end_line);
1626
1627	##print "LINE: $rawlines[$end_line - 1 ]\n";
1628	##print "CMMT: $cmt\n";
1629
1630	return ($cmt ne '');
1631}
1632
1633sub raw_line {
1634	my ($linenr, $cnt) = @_;
1635
1636	my $offset = $linenr - 1;
1637	$cnt++;
1638
1639	my $line;
1640	while ($cnt) {
1641		$line = $rawlines[$offset++];
1642		next if (defined($line) && $line =~ /^-/);
1643		$cnt--;
1644	}
1645
1646	return $line;
1647}
1648
1649sub get_stat_real {
1650	my ($linenr, $lc) = @_;
1651
1652	my $stat_real = raw_line($linenr, 0);
1653	for (my $count = $linenr + 1; $count <= $lc; $count++) {
1654		$stat_real = $stat_real . "\n" . raw_line($count, 0);
1655	}
1656
1657	return $stat_real;
1658}
1659
1660sub get_stat_here {
1661	my ($linenr, $cnt, $here) = @_;
1662
1663	my $herectx = $here . "\n";
1664	for (my $n = 0; $n < $cnt; $n++) {
1665		$herectx .= raw_line($linenr, $n) . "\n";
1666	}
1667
1668	return $herectx;
1669}
1670
1671sub cat_vet {
1672	my ($vet) = @_;
1673	my ($res, $coded);
1674
1675	$res = '';
1676	while ($vet =~ /([^[:cntrl:]]*)([[:cntrl:]]|$)/g) {
1677		$res .= $1;
1678		if ($2 ne '') {
1679			$coded = sprintf("^%c", unpack('C', $2) + 64);
1680			$res .= $coded;
1681		}
1682	}
1683	$res =~ s/$/\$/;
1684
1685	return $res;
1686}
1687
1688my $av_preprocessor = 0;
1689my $av_pending;
1690my @av_paren_type;
1691my $av_pend_colon;
1692
1693sub annotate_reset {
1694	$av_preprocessor = 0;
1695	$av_pending = '_';
1696	@av_paren_type = ('E');
1697	$av_pend_colon = 'O';
1698}
1699
1700sub annotate_values {
1701	my ($stream, $type) = @_;
1702
1703	my $res;
1704	my $var = '_' x length($stream);
1705	my $cur = $stream;
1706
1707	print "$stream\n" if ($dbg_values > 1);
1708
1709	while (length($cur)) {
1710		@av_paren_type = ('E') if ($#av_paren_type < 0);
1711		print " <" . join('', @av_paren_type) .
1712				"> <$type> <$av_pending>" if ($dbg_values > 1);
1713		if ($cur =~ /^(\s+)/o) {
1714			print "WS($1)\n" if ($dbg_values > 1);
1715			if ($1 =~ /\n/ && $av_preprocessor) {
1716				$type = pop(@av_paren_type);
1717				$av_preprocessor = 0;
1718			}
1719
1720		} elsif ($cur =~ /^(\(\s*$Type\s*)\)/ && $av_pending eq '_') {
1721			print "CAST($1)\n" if ($dbg_values > 1);
1722			push(@av_paren_type, $type);
1723			$type = 'c';
1724
1725		} elsif ($cur =~ /^($Type)\s*(?:$Ident|,|\)|\(|\s*$)/) {
1726			print "DECLARE($1)\n" if ($dbg_values > 1);
1727			$type = 'T';
1728
1729		} elsif ($cur =~ /^($Modifier)\s*/) {
1730			print "MODIFIER($1)\n" if ($dbg_values > 1);
1731			$type = 'T';
1732
1733		} elsif ($cur =~ /^(\#\s*define\s*$Ident)(\(?)/o) {
1734			print "DEFINE($1,$2)\n" if ($dbg_values > 1);
1735			$av_preprocessor = 1;
1736			push(@av_paren_type, $type);
1737			if ($2 ne '') {
1738				$av_pending = 'N';
1739			}
1740			$type = 'E';
1741
1742		} elsif ($cur =~ /^(\#\s*(?:undef\s*$Ident|include\b))/o) {
1743			print "UNDEF($1)\n" if ($dbg_values > 1);
1744			$av_preprocessor = 1;
1745			push(@av_paren_type, $type);
1746
1747		} elsif ($cur =~ /^(\#\s*(?:ifdef|ifndef|if))/o) {
1748			print "PRE_START($1)\n" if ($dbg_values > 1);
1749			$av_preprocessor = 1;
1750
1751			push(@av_paren_type, $type);
1752			push(@av_paren_type, $type);
1753			$type = 'E';
1754
1755		} elsif ($cur =~ /^(\#\s*(?:else|elif))/o) {
1756			print "PRE_RESTART($1)\n" if ($dbg_values > 1);
1757			$av_preprocessor = 1;
1758
1759			push(@av_paren_type, $av_paren_type[$#av_paren_type]);
1760
1761			$type = 'E';
1762
1763		} elsif ($cur =~ /^(\#\s*(?:endif))/o) {
1764			print "PRE_END($1)\n" if ($dbg_values > 1);
1765
1766			$av_preprocessor = 1;
1767
1768			# Assume all arms of the conditional end as this
1769			# one does, and continue as if the #endif was not here.
1770			pop(@av_paren_type);
1771			push(@av_paren_type, $type);
1772			$type = 'E';
1773
1774		} elsif ($cur =~ /^(\\\n)/o) {
1775			print "PRECONT($1)\n" if ($dbg_values > 1);
1776
1777		} elsif ($cur =~ /^(__attribute__)\s*\(?/o) {
1778			print "ATTR($1)\n" if ($dbg_values > 1);
1779			$av_pending = $type;
1780			$type = 'N';
1781
1782		} elsif ($cur =~ /^(sizeof)\s*(\()?/o) {
1783			print "SIZEOF($1)\n" if ($dbg_values > 1);
1784			if (defined $2) {
1785				$av_pending = 'V';
1786			}
1787			$type = 'N';
1788
1789		} elsif ($cur =~ /^(if|while|for)\b/o) {
1790			print "COND($1)\n" if ($dbg_values > 1);
1791			$av_pending = 'E';
1792			$type = 'N';
1793
1794		} elsif ($cur =~/^(case)/o) {
1795			print "CASE($1)\n" if ($dbg_values > 1);
1796			$av_pend_colon = 'C';
1797			$type = 'N';
1798
1799		} elsif ($cur =~/^(return|else|goto|typeof|__typeof__)\b/o) {
1800			print "KEYWORD($1)\n" if ($dbg_values > 1);
1801			$type = 'N';
1802
1803		} elsif ($cur =~ /^(\()/o) {
1804			print "PAREN('$1')\n" if ($dbg_values > 1);
1805			push(@av_paren_type, $av_pending);
1806			$av_pending = '_';
1807			$type = 'N';
1808
1809		} elsif ($cur =~ /^(\))/o) {
1810			my $new_type = pop(@av_paren_type);
1811			if ($new_type ne '_') {
1812				$type = $new_type;
1813				print "PAREN('$1') -> $type\n"
1814							if ($dbg_values > 1);
1815			} else {
1816				print "PAREN('$1')\n" if ($dbg_values > 1);
1817			}
1818
1819		} elsif ($cur =~ /^($Ident)\s*\(/o) {
1820			print "FUNC($1)\n" if ($dbg_values > 1);
1821			$type = 'V';
1822			$av_pending = 'V';
1823
1824		} elsif ($cur =~ /^($Ident\s*):(?:\s*\d+\s*(,|=|;))?/) {
1825			if (defined $2 && $type eq 'C' || $type eq 'T') {
1826				$av_pend_colon = 'B';
1827			} elsif ($type eq 'E') {
1828				$av_pend_colon = 'L';
1829			}
1830			print "IDENT_COLON($1,$type>$av_pend_colon)\n" if ($dbg_values > 1);
1831			$type = 'V';
1832
1833		} elsif ($cur =~ /^($Ident|$Constant)/o) {
1834			print "IDENT($1)\n" if ($dbg_values > 1);
1835			$type = 'V';
1836
1837		} elsif ($cur =~ /^($Assignment)/o) {
1838			print "ASSIGN($1)\n" if ($dbg_values > 1);
1839			$type = 'N';
1840
1841		} elsif ($cur =~/^(;|{|})/) {
1842			print "END($1)\n" if ($dbg_values > 1);
1843			$type = 'E';
1844			$av_pend_colon = 'O';
1845
1846		} elsif ($cur =~/^(,)/) {
1847			print "COMMA($1)\n" if ($dbg_values > 1);
1848			$type = 'C';
1849
1850		} elsif ($cur =~ /^(\?)/o) {
1851			print "QUESTION($1)\n" if ($dbg_values > 1);
1852			$type = 'N';
1853
1854		} elsif ($cur =~ /^(:)/o) {
1855			print "COLON($1,$av_pend_colon)\n" if ($dbg_values > 1);
1856
1857			substr($var, length($res), 1, $av_pend_colon);
1858			if ($av_pend_colon eq 'C' || $av_pend_colon eq 'L') {
1859				$type = 'E';
1860			} else {
1861				$type = 'N';
1862			}
1863			$av_pend_colon = 'O';
1864
1865		} elsif ($cur =~ /^(\[)/o) {
1866			print "CLOSE($1)\n" if ($dbg_values > 1);
1867			$type = 'N';
1868
1869		} elsif ($cur =~ /^(-(?![->])|\+(?!\+)|\*|\&\&|\&)/o) {
1870			my $variant;
1871
1872			print "OPV($1)\n" if ($dbg_values > 1);
1873			if ($type eq 'V') {
1874				$variant = 'B';
1875			} else {
1876				$variant = 'U';
1877			}
1878
1879			substr($var, length($res), 1, $variant);
1880			$type = 'N';
1881
1882		} elsif ($cur =~ /^($Operators)/o) {
1883			print "OP($1)\n" if ($dbg_values > 1);
1884			if ($1 ne '++' && $1 ne '--') {
1885				$type = 'N';
1886			}
1887
1888		} elsif ($cur =~ /(^.)/o) {
1889			print "C($1)\n" if ($dbg_values > 1);
1890		}
1891		if (defined $1) {
1892			$cur = substr($cur, length($1));
1893			$res .= $type x length($1);
1894		}
1895	}
1896
1897	return ($res, $var);
1898}
1899
1900sub possible {
1901	my ($possible, $line) = @_;
1902	my $notPermitted = qr{(?:
1903		^(?:
1904			$Modifier|
1905			$Storage|
1906			$Type|
1907			DEFINE_\S+
1908		)$|
1909		^(?:
1910			goto|
1911			return|
1912			case|
1913			else|
1914			asm|__asm__|
1915			do|
1916			\#|
1917			\#\#|
1918		)(?:\s|$)|
1919		^(?:typedef|struct|enum)\b
1920	    )}x;
1921	warn "CHECK<$possible> ($line)\n" if ($dbg_possible > 2);
1922	if ($possible !~ $notPermitted) {
1923		# Check for modifiers.
1924		$possible =~ s/\s*$Storage\s*//g;
1925		$possible =~ s/\s*$Sparse\s*//g;
1926		if ($possible =~ /^\s*$/) {
1927
1928		} elsif ($possible =~ /\s/) {
1929			$possible =~ s/\s*$Type\s*//g;
1930			for my $modifier (split(' ', $possible)) {
1931				if ($modifier !~ $notPermitted) {
1932					warn "MODIFIER: $modifier ($possible) ($line)\n" if ($dbg_possible);
1933					push(@modifierListFile, $modifier);
1934				}
1935			}
1936
1937		} else {
1938			warn "POSSIBLE: $possible ($line)\n" if ($dbg_possible);
1939			push(@typeListFile, $possible);
1940		}
1941		build_types();
1942	} else {
1943		warn "NOTPOSS: $possible ($line)\n" if ($dbg_possible > 1);
1944	}
1945}
1946
1947my $prefix = '';
1948
1949sub show_type {
1950	my ($type) = @_;
1951
1952	$type =~ tr/[a-z]/[A-Z]/;
1953
1954	return defined $use_type{$type} if (scalar keys %use_type > 0);
1955
1956	return !defined $ignore_type{$type};
1957}
1958
1959sub report {
1960	my ($level, $type, $msg) = @_;
1961
1962	if (!show_type($type) ||
1963	    (defined $tst_only && $msg !~ /\Q$tst_only\E/)) {
1964		return 0;
1965	}
1966	my $output = '';
1967	if ($color) {
1968		if ($level eq 'ERROR') {
1969			$output .= RED;
1970		} elsif ($level eq 'WARNING') {
1971			$output .= YELLOW;
1972		} else {
1973			$output .= GREEN;
1974		}
1975	}
1976	$output .= $prefix . $level . ':';
1977	if ($show_types) {
1978		$output .= BLUE if ($color);
1979		$output .= "$type:";
1980	}
1981	$output .= RESET if ($color);
1982	$output .= ' ' . $msg . "\n";
1983
1984	if ($showfile) {
1985		my @lines = split("\n", $output, -1);
1986		splice(@lines, 1, 1);
1987		$output = join("\n", @lines);
1988	}
1989	$output = (split('\n', $output))[0] . "\n" if ($terse);
1990
1991	push(our @report, $output);
1992
1993	return 1;
1994}
1995
1996sub report_dump {
1997	our @report;
1998}
1999
2000sub fixup_current_range {
2001	my ($lineRef, $offset, $length) = @_;
2002
2003	if ($$lineRef =~ /^\@\@ -\d+,\d+ \+(\d+),(\d+) \@\@/) {
2004		my $o = $1;
2005		my $l = $2;
2006		my $no = $o + $offset;
2007		my $nl = $l + $length;
2008		$$lineRef =~ s/\+$o,$l \@\@/\+$no,$nl \@\@/;
2009	}
2010}
2011
2012sub fix_inserted_deleted_lines {
2013	my ($linesRef, $insertedRef, $deletedRef) = @_;
2014
2015	my $range_last_linenr = 0;
2016	my $delta_offset = 0;
2017
2018	my $old_linenr = 0;
2019	my $new_linenr = 0;
2020
2021	my $next_insert = 0;
2022	my $next_delete = 0;
2023
2024	my @lines = ();
2025
2026	my $inserted = @{$insertedRef}[$next_insert++];
2027	my $deleted = @{$deletedRef}[$next_delete++];
2028
2029	foreach my $old_line (@{$linesRef}) {
2030		my $save_line = 1;
2031		my $line = $old_line;	#don't modify the array
2032		if ($line =~ /^(?:\+\+\+|\-\-\-)\s+\S+/) {	#new filename
2033			$delta_offset = 0;
2034		} elsif ($line =~ /^\@\@ -\d+,\d+ \+\d+,\d+ \@\@/) {	#new hunk
2035			$range_last_linenr = $new_linenr;
2036			fixup_current_range(\$line, $delta_offset, 0);
2037		}
2038
2039		while (defined($deleted) && ${$deleted}{'LINENR'} == $old_linenr) {
2040			$deleted = @{$deletedRef}[$next_delete++];
2041			$save_line = 0;
2042			fixup_current_range(\$lines[$range_last_linenr], $delta_offset--, -1);
2043		}
2044
2045		while (defined($inserted) && ${$inserted}{'LINENR'} == $old_linenr) {
2046			push(@lines, ${$inserted}{'LINE'});
2047			$inserted = @{$insertedRef}[$next_insert++];
2048			$new_linenr++;
2049			fixup_current_range(\$lines[$range_last_linenr], $delta_offset++, 1);
2050		}
2051
2052		if ($save_line) {
2053			push(@lines, $line);
2054			$new_linenr++;
2055		}
2056
2057		$old_linenr++;
2058	}
2059
2060	return @lines;
2061}
2062
2063sub fix_insert_line {
2064	my ($linenr, $line) = @_;
2065
2066	my $inserted = {
2067		LINENR => $linenr,
2068		LINE => $line,
2069	};
2070	push(@fixed_inserted, $inserted);
2071}
2072
2073sub fix_delete_line {
2074	my ($linenr, $line) = @_;
2075
2076	my $deleted = {
2077		LINENR => $linenr,
2078		LINE => $line,
2079	};
2080
2081	push(@fixed_deleted, $deleted);
2082}
2083
2084sub ERROR {
2085	my ($type, $msg) = @_;
2086
2087	if (report("ERROR", $type, $msg)) {
2088		our $clean = 0;
2089		our $cnt_error++;
2090		return 1;
2091	}
2092	return 0;
2093}
2094sub WARN {
2095	my ($type, $msg) = @_;
2096
2097	if (report("WARNING", $type, $msg)) {
2098		our $clean = 0;
2099		our $cnt_warn++;
2100		return 1;
2101	}
2102	return 0;
2103}
2104sub CHK {
2105	my ($type, $msg) = @_;
2106
2107	if ($check && report("CHECK", $type, $msg)) {
2108		our $clean = 0;
2109		our $cnt_chk++;
2110		return 1;
2111	}
2112	return 0;
2113}
2114
2115sub check_absolute_file {
2116	my ($absolute, $herecurr) = @_;
2117	my $file = $absolute;
2118
2119	##print "absolute<$absolute>\n";
2120
2121	# See if any suffix of this path is a path within the tree.
2122	while ($file =~ s@^[^/]*/@@) {
2123		if (-f "$root/$file") {
2124			##print "file<$file>\n";
2125			last;
2126		}
2127	}
2128	if (! -f _)  {
2129		return 0;
2130	}
2131
2132	# It is, so see if the prefix is acceptable.
2133	my $prefix = $absolute;
2134	substr($prefix, -length($file)) = '';
2135
2136	##print "prefix<$prefix>\n";
2137	if ($prefix ne ".../") {
2138		WARN("USE_RELATIVE_PATH",
2139		     "use relative pathname instead of absolute in changelog text\n" . $herecurr);
2140	}
2141}
2142
2143sub trim {
2144	my ($string) = @_;
2145
2146	$string =~ s/^\s+|\s+$//g;
2147
2148	return $string;
2149}
2150
2151sub ltrim {
2152	my ($string) = @_;
2153
2154	$string =~ s/^\s+//;
2155
2156	return $string;
2157}
2158
2159sub rtrim {
2160	my ($string) = @_;
2161
2162	$string =~ s/\s+$//;
2163
2164	return $string;
2165}
2166
2167sub string_find_replace {
2168	my ($string, $find, $replace) = @_;
2169
2170	$string =~ s/$find/$replace/g;
2171
2172	return $string;
2173}
2174
2175sub tabify {
2176	my ($leading) = @_;
2177
2178	my $source_indent = 8;
2179	my $max_spaces_before_tab = $source_indent - 1;
2180	my $spaces_to_tab = " " x $source_indent;
2181
2182	#convert leading spaces to tabs
2183	1 while $leading =~ s@^([\t]*)$spaces_to_tab@$1\t@g;
2184	#Remove spaces before a tab
2185	1 while $leading =~ s@^([\t]*)( {1,$max_spaces_before_tab})\t@$1\t@g;
2186
2187	return "$leading";
2188}
2189
2190sub pos_last_openparen {
2191	my ($line) = @_;
2192
2193	my $pos = 0;
2194
2195	my $opens = $line =~ tr/\(/\(/;
2196	my $closes = $line =~ tr/\)/\)/;
2197
2198	my $last_openparen = 0;
2199
2200	if (($opens == 0) || ($closes >= $opens)) {
2201		return -1;
2202	}
2203
2204	my $len = length($line);
2205
2206	for ($pos = 0; $pos < $len; $pos++) {
2207		my $string = substr($line, $pos);
2208		if ($string =~ /^($FuncArg|$balanced_parens)/) {
2209			$pos += length($1) - 1;
2210		} elsif (substr($line, $pos, 1) eq '(') {
2211			$last_openparen = $pos;
2212		} elsif (index($string, '(') == -1) {
2213			last;
2214		}
2215	}
2216
2217	return length(expand_tabs(substr($line, 0, $last_openparen))) + 1;
2218}
2219
2220sub process {
2221	my $filename = shift;
2222
2223	my $linenr=0;
2224	my $prevline="";
2225	my $prevrawline="";
2226	my $stashline="";
2227	my $stashrawline="";
2228
2229	my $length;
2230	my $indent;
2231	my $previndent=0;
2232	my $stashindent=0;
2233
2234	our $clean = 1;
2235	my $signoff = 0;
2236	my $is_patch = 0;
2237	my $in_header_lines = $file ? 0 : 1;
2238	my $in_commit_log = 0;		#Scanning lines before patch
2239	my $has_commit_log = 0;		#Encountered lines before patch
2240	my $commit_log_possible_stack_dump = 0;
2241	my $commit_log_long_line = 0;
2242	my $commit_log_has_diff = 0;
2243	my $reported_maintainer_file = 0;
2244	my $non_utf8_charset = 0;
2245
2246	my $last_blank_line = 0;
2247	my $last_coalesced_string_linenr = -1;
2248
2249	our @report = ();
2250	our $cnt_lines = 0;
2251	our $cnt_error = 0;
2252	our $cnt_warn = 0;
2253	our $cnt_chk = 0;
2254
2255	# Trace the real file/line as we go.
2256	my $realfile = '';
2257	my $realline = 0;
2258	my $realcnt = 0;
2259	my $here = '';
2260	my $context_function;		#undef'd unless there's a known function
2261	my $in_comment = 0;
2262	my $comment_edge = 0;
2263	my $first_line = 0;
2264	my $p1_prefix = '';
2265
2266	my $prev_values = 'E';
2267
2268	# suppression flags
2269	my %suppress_ifbraces;
2270	my %suppress_whiletrailers;
2271	my %suppress_export;
2272	my $suppress_statement = 0;
2273
2274	my %signatures = ();
2275
2276	# Pre-scan the patch sanitizing the lines.
2277	# Pre-scan the patch looking for any __setup documentation.
2278	#
2279	my @setup_docs = ();
2280	my $setup_docs = 0;
2281
2282	my $camelcase_file_seeded = 0;
2283
2284	my $checklicenseline = 1;
2285
2286	sanitise_line_reset();
2287	my $line;
2288	foreach my $rawline (@rawlines) {
2289		$linenr++;
2290		$line = $rawline;
2291
2292		push(@fixed, $rawline) if ($fix);
2293
2294		if ($rawline=~/^\+\+\+\s+(\S+)/) {
2295			$setup_docs = 0;
2296			if ($1 =~ m@Documentation/admin-guide/kernel-parameters.rst$@) {
2297				$setup_docs = 1;
2298			}
2299			#next;
2300		}
2301		if ($rawline =~ /^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@/) {
2302			$realline=$1-1;
2303			if (defined $2) {
2304				$realcnt=$3+1;
2305			} else {
2306				$realcnt=1+1;
2307			}
2308			$in_comment = 0;
2309
2310			# Guestimate if this is a continuing comment.  Run
2311			# the context looking for a comment "edge".  If this
2312			# edge is a close comment then we must be in a comment
2313			# at context start.
2314			my $edge;
2315			my $cnt = $realcnt;
2316			for (my $ln = $linenr + 1; $cnt > 0; $ln++) {
2317				next if (defined $rawlines[$ln - 1] &&
2318					 $rawlines[$ln - 1] =~ /^-/);
2319				$cnt--;
2320				#print "RAW<$rawlines[$ln - 1]>\n";
2321				last if (!defined $rawlines[$ln - 1]);
2322				if ($rawlines[$ln - 1] =~ m@(/\*|\*/)@ &&
2323				    $rawlines[$ln - 1] !~ m@"[^"]*(?:/\*|\*/)[^"]*"@) {
2324					($edge) = $1;
2325					last;
2326				}
2327			}
2328			if (defined $edge && $edge eq '*/') {
2329				$in_comment = 1;
2330			}
2331
2332			# Guestimate if this is a continuing comment.  If this
2333			# is the start of a diff block and this line starts
2334			# ' *' then it is very likely a comment.
2335			if (!defined $edge &&
2336			    $rawlines[$linenr] =~ m@^.\s*(?:\*\*+| \*)(?:\s|$)@)
2337			{
2338				$in_comment = 1;
2339			}
2340
2341			##print "COMMENT:$in_comment edge<$edge> $rawline\n";
2342			sanitise_line_reset($in_comment);
2343
2344		} elsif ($realcnt && $rawline =~ /^(?:\+| |$)/) {
2345			# Standardise the strings and chars within the input to
2346			# simplify matching -- only bother with positive lines.
2347			$line = sanitise_line($rawline);
2348		}
2349		push(@lines, $line);
2350
2351		if ($realcnt > 1) {
2352			$realcnt-- if ($line =~ /^(?:\+| |$)/);
2353		} else {
2354			$realcnt = 0;
2355		}
2356
2357		#print "==>$rawline\n";
2358		#print "-->$line\n";
2359
2360		if ($setup_docs && $line =~ /^\+/) {
2361			push(@setup_docs, $line);
2362		}
2363	}
2364
2365	$prefix = '';
2366
2367	$realcnt = 0;
2368	$linenr = 0;
2369	$fixlinenr = -1;
2370	foreach my $line (@lines) {
2371		$linenr++;
2372		$fixlinenr++;
2373		my $sline = $line;	#copy of $line
2374		$sline =~ s/$;/ /g;	#with comments as spaces
2375
2376		my $rawline = $rawlines[$linenr - 1];
2377
2378#extract the line range in the file after the patch is applied
2379		if (!$in_commit_log &&
2380		    $line =~ /^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@(.*)/) {
2381			my $context = $4;
2382			$is_patch = 1;
2383			$first_line = $linenr + 1;
2384			$realline=$1-1;
2385			if (defined $2) {
2386				$realcnt=$3+1;
2387			} else {
2388				$realcnt=1+1;
2389			}
2390			annotate_reset();
2391			$prev_values = 'E';
2392
2393			%suppress_ifbraces = ();
2394			%suppress_whiletrailers = ();
2395			%suppress_export = ();
2396			$suppress_statement = 0;
2397			if ($context =~ /\b(\w+)\s*\(/) {
2398				$context_function = $1;
2399			} else {
2400				undef $context_function;
2401			}
2402			next;
2403
2404# track the line number as we move through the hunk, note that
2405# new versions of GNU diff omit the leading space on completely
2406# blank context lines so we need to count that too.
2407		} elsif ($line =~ /^( |\+|$)/) {
2408			$realline++;
2409			$realcnt-- if ($realcnt != 0);
2410
2411			# Measure the line length and indent.
2412			($length, $indent) = line_stats($rawline);
2413
2414			# Track the previous line.
2415			($prevline, $stashline) = ($stashline, $line);
2416			($previndent, $stashindent) = ($stashindent, $indent);
2417			($prevrawline, $stashrawline) = ($stashrawline, $rawline);
2418
2419			#warn "line<$line>\n";
2420
2421		} elsif ($realcnt == 1) {
2422			$realcnt--;
2423		}
2424
2425		my $hunk_line = ($realcnt != 0);
2426
2427		$here = "#$linenr: " if (!$file);
2428		$here = "#$realline: " if ($file);
2429
2430		my $found_file = 0;
2431		# extract the filename as it passes
2432		if ($line =~ /^diff --git.*?(\S+)$/) {
2433			$realfile = $1;
2434			$realfile =~ s@^([^/]*)/@@ if (!$file);
2435			$in_commit_log = 0;
2436			$found_file = 1;
2437		} elsif ($line =~ /^\+\+\+\s+(\S+)/) {
2438			$realfile = $1;
2439			$realfile =~ s@^([^/]*)/@@ if (!$file);
2440			$in_commit_log = 0;
2441
2442			$p1_prefix = $1;
2443			if (!$file && $tree && $p1_prefix ne '' &&
2444			    -e "$root/$p1_prefix") {
2445				WARN("PATCH_PREFIX",
2446				     "patch prefix '$p1_prefix' exists, appears to be a -p0 patch\n");
2447			}
2448
2449			if ($realfile =~ m@^include/asm/@) {
2450				ERROR("MODIFIED_INCLUDE_ASM",
2451				      "do not modify files in include/asm, change architecture specific files in include/asm-<architecture>\n" . "$here$rawline\n");
2452			}
2453			$found_file = 1;
2454		}
2455
2456#make up the handle for any error we report on this line
2457		if ($showfile) {
2458			$prefix = "$realfile:$realline: "
2459		} elsif ($emacs) {
2460			if ($file) {
2461				$prefix = "$filename:$realline: ";
2462			} else {
2463				$prefix = "$filename:$linenr: ";
2464			}
2465		}
2466
2467		if ($found_file) {
2468			if (is_maintained_obsolete($realfile)) {
2469				WARN("OBSOLETE",
2470				     "$realfile is marked as 'obsolete' in the MAINTAINERS hierarchy.  No unnecessary modifications please.\n");
2471			}
2472			if ($realfile =~ m@^(?:drivers/net/|net/|drivers/staging/)@) {
2473				$check = 1;
2474			} else {
2475				$check = $check_orig;
2476			}
2477			$checklicenseline = 1;
2478			next;
2479		}
2480
2481		$here .= "FILE: $realfile:$realline:" if ($realcnt != 0);
2482
2483		my $hereline = "$here\n$rawline\n";
2484		my $herecurr = "$here\n$rawline\n";
2485		my $hereprev = "$here\n$prevrawline\n$rawline\n";
2486
2487		$cnt_lines++ if ($realcnt != 0);
2488
2489# Check if the commit log has what seems like a diff which can confuse patch
2490		if ($in_commit_log && !$commit_log_has_diff &&
2491		    (($line =~ m@^\s+diff\b.*a/[\w/]+@ &&
2492		      $line =~ m@^\s+diff\b.*a/([\w/]+)\s+b/$1\b@) ||
2493		     $line =~ m@^\s*(?:\-\-\-\s+a/|\+\+\+\s+b/)@ ||
2494		     $line =~ m/^\s*\@\@ \-\d+,\d+ \+\d+,\d+ \@\@/)) {
2495			ERROR("DIFF_IN_COMMIT_MSG",
2496			      "Avoid using diff content in the commit message - patch(1) might not work\n" . $herecurr);
2497			$commit_log_has_diff = 1;
2498		}
2499
2500# Check for incorrect file permissions
2501		if ($line =~ /^new (file )?mode.*[7531]\d{0,2}$/) {
2502			my $permhere = $here . "FILE: $realfile\n";
2503			if ($realfile !~ m@scripts/@ &&
2504			    $realfile !~ /\.(py|pl|awk|sh)$/) {
2505				ERROR("EXECUTE_PERMISSIONS",
2506				      "do not set execute permissions for source files\n" . $permhere);
2507			}
2508		}
2509
2510# Check the patch for a signoff:
2511		if ($line =~ /^\s*signed-off-by:/i) {
2512			$signoff++;
2513			$in_commit_log = 0;
2514		}
2515
2516# Check if MAINTAINERS is being updated.  If so, there's probably no need to
2517# emit the "does MAINTAINERS need updating?" message on file add/move/delete
2518		if ($line =~ /^\s*MAINTAINERS\s*\|/) {
2519			$reported_maintainer_file = 1;
2520		}
2521
2522# Check signature styles
2523		if (!$in_header_lines &&
2524		    $line =~ /^(\s*)([a-z0-9_-]+by:|$signature_tags)(\s*)(.*)/i) {
2525			my $space_before = $1;
2526			my $sign_off = $2;
2527			my $space_after = $3;
2528			my $email = $4;
2529			my $ucfirst_sign_off = ucfirst(lc($sign_off));
2530
2531			if ($sign_off !~ /$signature_tags/) {
2532				WARN("BAD_SIGN_OFF",
2533				     "Non-standard signature: $sign_off\n" . $herecurr);
2534			}
2535			if (defined $space_before && $space_before ne "") {
2536				if (WARN("BAD_SIGN_OFF",
2537					 "Do not use whitespace before $ucfirst_sign_off\n" . $herecurr) &&
2538				    $fix) {
2539					$fixed[$fixlinenr] =
2540					    "$ucfirst_sign_off $email";
2541				}
2542			}
2543			if ($sign_off =~ /-by:$/i && $sign_off ne $ucfirst_sign_off) {
2544				if (WARN("BAD_SIGN_OFF",
2545					 "'$ucfirst_sign_off' is the preferred signature form\n" . $herecurr) &&
2546				    $fix) {
2547					$fixed[$fixlinenr] =
2548					    "$ucfirst_sign_off $email";
2549				}
2550
2551			}
2552			if (!defined $space_after || $space_after ne " ") {
2553				if (WARN("BAD_SIGN_OFF",
2554					 "Use a single space after $ucfirst_sign_off\n" . $herecurr) &&
2555				    $fix) {
2556					$fixed[$fixlinenr] =
2557					    "$ucfirst_sign_off $email";
2558				}
2559			}
2560
2561			my ($email_name, $email_address, $comment) = parse_email($email);
2562			my $suggested_email = format_email(($email_name, $email_address));
2563			if ($suggested_email eq "") {
2564				ERROR("BAD_SIGN_OFF",
2565				      "Unrecognized email address: '$email'\n" . $herecurr);
2566			} else {
2567				my $dequoted = $suggested_email;
2568				$dequoted =~ s/^"//;
2569				$dequoted =~ s/" </ </;
2570				# Don't force email to have quotes
2571				# Allow just an angle bracketed address
2572				if ("$dequoted$comment" ne $email &&
2573				    "<$email_address>$comment" ne $email &&
2574				    "$suggested_email$comment" ne $email) {
2575					WARN("BAD_SIGN_OFF",
2576					     "email address '$email' might be better as '$suggested_email$comment'\n" . $herecurr);
2577				}
2578			}
2579
2580# Check for duplicate signatures
2581			my $sig_nospace = $line;
2582			$sig_nospace =~ s/\s//g;
2583			$sig_nospace = lc($sig_nospace);
2584			if (defined $signatures{$sig_nospace}) {
2585				WARN("BAD_SIGN_OFF",
2586				     "Duplicate signature\n" . $herecurr);
2587			} else {
2588				$signatures{$sig_nospace} = 1;
2589			}
2590		}
2591
2592# Check email subject for common tools that don't need to be mentioned
2593		if ($in_header_lines &&
2594		    $line =~ /^Subject:.*\b(?:checkpatch|sparse|smatch)\b[^:]/i) {
2595			WARN("EMAIL_SUBJECT",
2596			     "A patch subject line should describe the change not the tool that found it\n" . $herecurr);
2597		}
2598
2599# Check for old stable address
2600		if ($line =~ /^\s*cc:\s*.*<?\bstable\@kernel\.org\b>?.*$/i) {
2601			ERROR("STABLE_ADDRESS",
2602			      "The 'stable' address should be 'stable\@vger.kernel.org'\n" . $herecurr);
2603		}
2604
2605# Check for unwanted Gerrit info
2606		if ($in_commit_log && $line =~ /^\s*change-id:/i) {
2607			ERROR("GERRIT_CHANGE_ID",
2608			      "Remove Gerrit Change-Id's before submitting upstream.\n" . $herecurr);
2609		}
2610
2611# Check if the commit log is in a possible stack dump
2612		if ($in_commit_log && !$commit_log_possible_stack_dump &&
2613		    ($line =~ /^\s*(?:WARNING:|BUG:)/ ||
2614		     $line =~ /^\s*\[\s*\d+\.\d{6,6}\s*\]/ ||
2615					# timestamp
2616		     $line =~ /^\s*\[\<[0-9a-fA-F]{8,}\>\]/)) {
2617					# stack dump address
2618			$commit_log_possible_stack_dump = 1;
2619		}
2620
2621# Check for line lengths > 75 in commit log, warn once
2622		if ($in_commit_log && !$commit_log_long_line &&
2623		    length($line) > 75 &&
2624		    !($line =~ /^\s*[a-zA-Z0-9_\/\.]+\s+\|\s+\d+/ ||
2625					# file delta changes
2626		      $line =~ /^\s*(?:[\w\.\-]+\/)++[\w\.\-]+:/ ||
2627					# filename then :
2628		      $line =~ /^\s*(?:Fixes:|Link:)/i ||
2629					# A Fixes: or Link: line
2630		      $commit_log_possible_stack_dump)) {
2631			WARN("COMMIT_LOG_LONG_LINE",
2632			     "Possible unwrapped commit description (prefer a maximum 75 chars per line)\n" . $herecurr);
2633			$commit_log_long_line = 1;
2634		}
2635
2636# Reset possible stack dump if a blank line is found
2637		if ($in_commit_log && $commit_log_possible_stack_dump &&
2638		    $line =~ /^\s*$/) {
2639			$commit_log_possible_stack_dump = 0;
2640		}
2641
2642# Check for git id commit length and improperly formed commit descriptions
2643		if ($in_commit_log && !$commit_log_possible_stack_dump &&
2644		    $line !~ /^\s*(?:Link|Patchwork|http|https|BugLink):/i &&
2645		    $line !~ /^This reverts commit [0-9a-f]{7,40}/ &&
2646		    ($line =~ /\bcommit\s+[0-9a-f]{5,}\b/i ||
2647		     ($line =~ /(?:\s|^)[0-9a-f]{12,40}(?:[\s"'\(\[]|$)/i &&
2648		      $line !~ /[\<\[][0-9a-f]{12,40}[\>\]]/i &&
2649		      $line !~ /\bfixes:\s*[0-9a-f]{12,40}/i))) {
2650			my $init_char = "c";
2651			my $orig_commit = "";
2652			my $short = 1;
2653			my $long = 0;
2654			my $case = 1;
2655			my $space = 1;
2656			my $hasdesc = 0;
2657			my $hasparens = 0;
2658			my $id = '0123456789ab';
2659			my $orig_desc = "commit description";
2660			my $description = "";
2661
2662			if ($line =~ /\b(c)ommit\s+([0-9a-f]{5,})\b/i) {
2663				$init_char = $1;
2664				$orig_commit = lc($2);
2665			} elsif ($line =~ /\b([0-9a-f]{12,40})\b/i) {
2666				$orig_commit = lc($1);
2667			}
2668
2669			$short = 0 if ($line =~ /\bcommit\s+[0-9a-f]{12,40}/i);
2670			$long = 1 if ($line =~ /\bcommit\s+[0-9a-f]{41,}/i);
2671			$space = 0 if ($line =~ /\bcommit [0-9a-f]/i);
2672			$case = 0 if ($line =~ /\b[Cc]ommit\s+[0-9a-f]{5,40}[^A-F]/);
2673			if ($line =~ /\bcommit\s+[0-9a-f]{5,}\s+\("([^"]+)"\)/i) {
2674				$orig_desc = $1;
2675				$hasparens = 1;
2676			} elsif ($line =~ /\bcommit\s+[0-9a-f]{5,}\s*$/i &&
2677				 defined $rawlines[$linenr] &&
2678				 $rawlines[$linenr] =~ /^\s*\("([^"]+)"\)/) {
2679				$orig_desc = $1;
2680				$hasparens = 1;
2681			} elsif ($line =~ /\bcommit\s+[0-9a-f]{5,}\s+\("[^"]+$/i &&
2682				 defined $rawlines[$linenr] &&
2683				 $rawlines[$linenr] =~ /^\s*[^"]+"\)/) {
2684				$line =~ /\bcommit\s+[0-9a-f]{5,}\s+\("([^"]+)$/i;
2685				$orig_desc = $1;
2686				$rawlines[$linenr] =~ /^\s*([^"]+)"\)/;
2687				$orig_desc .= " " . $1;
2688				$hasparens = 1;
2689			}
2690
2691			($id, $description) = git_commit_info($orig_commit,
2692							      $id, $orig_desc);
2693
2694			if (defined($id) &&
2695			   ($short || $long || $space || $case || ($orig_desc ne $description) || !$hasparens)) {
2696				ERROR("GIT_COMMIT_ID",
2697				      "Please use git commit description style 'commit <12+ chars of sha1> (\"<title line>\")' - ie: '${init_char}ommit $id (\"$description\")'\n" . $herecurr);
2698			}
2699		}
2700
2701# Check for added, moved or deleted files
2702		if (!$reported_maintainer_file && !$in_commit_log &&
2703		    ($line =~ /^(?:new|deleted) file mode\s*\d+\s*$/ ||
2704		     $line =~ /^rename (?:from|to) [\w\/\.\-]+\s*$/ ||
2705		     ($line =~ /\{\s*([\w\/\.\-]*)\s*\=\>\s*([\w\/\.\-]*)\s*\}/ &&
2706		      (defined($1) || defined($2))))) {
2707			$is_patch = 1;
2708			$reported_maintainer_file = 1;
2709			WARN("FILE_PATH_CHANGES",
2710			     "added, moved or deleted file(s), does MAINTAINERS need updating?\n" . $herecurr);
2711		}
2712
2713# Check for wrappage within a valid hunk of the file
2714		if ($realcnt != 0 && $line !~ m{^(?:\+|-| |\\ No newline|$)}) {
2715			ERROR("CORRUPTED_PATCH",
2716			      "patch seems to be corrupt (line wrapped?)\n" .
2717				$herecurr) if (!$emitted_corrupt++);
2718		}
2719
2720# UTF-8 regex found at http://www.w3.org/International/questions/qa-forms-utf-8.en.php
2721		if (($realfile =~ /^$/ || $line =~ /^\+/) &&
2722		    $rawline !~ m/^$UTF8*$/) {
2723			my ($utf8_prefix) = ($rawline =~ /^($UTF8*)/);
2724
2725			my $blank = copy_spacing($rawline);
2726			my $ptr = substr($blank, 0, length($utf8_prefix)) . "^";
2727			my $hereptr = "$hereline$ptr\n";
2728
2729			CHK("INVALID_UTF8",
2730			    "Invalid UTF-8, patch and commit message should be encoded in UTF-8\n" . $hereptr);
2731		}
2732
2733# Check if it's the start of a commit log
2734# (not a header line and we haven't seen the patch filename)
2735		if ($in_header_lines && $realfile =~ /^$/ &&
2736		    !($rawline =~ /^\s+(?:\S|$)/ ||
2737		      $rawline =~ /^(?:commit\b|from\b|[\w-]+:)/i)) {
2738			$in_header_lines = 0;
2739			$in_commit_log = 1;
2740			$has_commit_log = 1;
2741		}
2742
2743# Check if there is UTF-8 in a commit log when a mail header has explicitly
2744# declined it, i.e defined some charset where it is missing.
2745		if ($in_header_lines &&
2746		    $rawline =~ /^Content-Type:.+charset="(.+)".*$/ &&
2747		    $1 !~ /utf-8/i) {
2748			$non_utf8_charset = 1;
2749		}
2750
2751		if ($in_commit_log && $non_utf8_charset && $realfile =~ /^$/ &&
2752		    $rawline =~ /$NON_ASCII_UTF8/) {
2753			WARN("UTF8_BEFORE_PATCH",
2754			    "8-bit UTF-8 used in possible commit log\n" . $herecurr);
2755		}
2756
2757# Check for absolute kernel paths in commit message
2758		if ($tree && $in_commit_log) {
2759			while ($line =~ m{(?:^|\s)(/\S*)}g) {
2760				my $file = $1;
2761
2762				if ($file =~ m{^(.*?)(?::\d+)+:?$} &&
2763				    check_absolute_file($1, $herecurr)) {
2764					#
2765				} else {
2766					check_absolute_file($file, $herecurr);
2767				}
2768			}
2769		}
2770
2771# Check for various typo / spelling mistakes
2772		if (defined($misspellings) &&
2773		    ($in_commit_log || $line =~ /^(?:\+|Subject:)/i)) {
2774			while ($rawline =~ /(?:^|[^a-z@])($misspellings)(?:\b|$|[^a-z@])/gi) {
2775				my $typo = $1;
2776				my $typo_fix = $spelling_fix{lc($typo)};
2777				$typo_fix = ucfirst($typo_fix) if ($typo =~ /^[A-Z]/);
2778				$typo_fix = uc($typo_fix) if ($typo =~ /^[A-Z]+$/);
2779				my $msg_level = \&WARN;
2780				$msg_level = \&CHK if ($file);
2781				if (&{$msg_level}("TYPO_SPELLING",
2782						  "'$typo' may be misspelled - perhaps '$typo_fix'?\n" . $herecurr) &&
2783				    $fix) {
2784					$fixed[$fixlinenr] =~ s/(^|[^A-Za-z@])($typo)($|[^A-Za-z@])/$1$typo_fix$3/;
2785				}
2786			}
2787		}
2788
2789# ignore non-hunk lines and lines being removed
2790		next if (!$hunk_line || $line =~ /^-/);
2791
2792#trailing whitespace
2793		if ($line =~ /^\+.*\015/) {
2794			my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2795			if (ERROR("DOS_LINE_ENDINGS",
2796				  "DOS line endings\n" . $herevet) &&
2797			    $fix) {
2798				$fixed[$fixlinenr] =~ s/[\s\015]+$//;
2799			}
2800		} elsif ($rawline =~ /^\+.*\S\s+$/ || $rawline =~ /^\+\s+$/) {
2801			my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2802			if (ERROR("TRAILING_WHITESPACE",
2803				  "trailing whitespace\n" . $herevet) &&
2804			    $fix) {
2805				$fixed[$fixlinenr] =~ s/\s+$//;
2806			}
2807
2808			$rpt_cleaners = 1;
2809		}
2810
2811# Check for FSF mailing addresses.
2812		if ($rawline =~ /\bwrite to the Free/i ||
2813		    $rawline =~ /\b675\s+Mass\s+Ave/i ||
2814		    $rawline =~ /\b59\s+Temple\s+Pl/i ||
2815		    $rawline =~ /\b51\s+Franklin\s+St/i) {
2816			my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2817			my $msg_level = \&ERROR;
2818			$msg_level = \&CHK if ($file);
2819			&{$msg_level}("FSF_MAILING_ADDRESS",
2820				      "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)
2821		}
2822
2823# check for Kconfig help text having a real description
2824# Only applies when adding the entry originally, after that we do not have
2825# sufficient context to determine whether it is indeed long enough.
2826		if ($realfile =~ /Kconfig/ &&
2827		    # 'choice' is usually the last thing on the line (though
2828		    # Kconfig supports named choices), so use a word boundary
2829		    # (\b) rather than a whitespace character (\s)
2830		    $line =~ /^\+\s*(?:config|menuconfig|choice)\b/) {
2831			my $length = 0;
2832			my $cnt = $realcnt;
2833			my $ln = $linenr + 1;
2834			my $f;
2835			my $is_start = 0;
2836			my $is_end = 0;
2837			for (; $cnt > 0 && defined $lines[$ln - 1]; $ln++) {
2838				$f = $lines[$ln - 1];
2839				$cnt-- if ($lines[$ln - 1] !~ /^-/);
2840				$is_end = $lines[$ln - 1] =~ /^\+/;
2841
2842				next if ($f =~ /^-/);
2843				last if (!$file && $f =~ /^\@\@/);
2844
2845				if ($lines[$ln - 1] =~ /^\+\s*(?:bool|tristate|prompt)\s*["']/) {
2846					$is_start = 1;
2847				} elsif ($lines[$ln - 1] =~ /^\+\s*(?:help|---help---)\s*$/) {
2848					if ($lines[$ln - 1] =~ "---help---") {
2849						WARN("CONFIG_DESCRIPTION",
2850						     "prefer 'help' over '---help---' for new help texts\n" . $herecurr);
2851					}
2852					$length = -1;
2853				}
2854
2855				$f =~ s/^.//;
2856				$f =~ s/#.*//;
2857				$f =~ s/^\s+//;
2858				next if ($f =~ /^$/);
2859
2860				# This only checks context lines in the patch
2861				# and so hopefully shouldn't trigger false
2862				# positives, even though some of these are
2863				# common words in help texts
2864				if ($f =~ /^\s*(?:config|menuconfig|choice|endchoice|
2865						  if|endif|menu|endmenu|source)\b/x) {
2866					$is_end = 1;
2867					last;
2868				}
2869				$length++;
2870			}
2871			if ($is_start && $is_end && $length < $min_conf_desc_length) {
2872				WARN("CONFIG_DESCRIPTION",
2873				     "please write a paragraph that describes the config symbol fully\n" . $herecurr);
2874			}
2875			#print "is_start<$is_start> is_end<$is_end> length<$length>\n";
2876		}
2877
2878# check for MAINTAINERS entries that don't have the right form
2879		if ($realfile =~ /^MAINTAINERS$/ &&
2880		    $rawline =~ /^\+[A-Z]:/ &&
2881		    $rawline !~ /^\+[A-Z]:\t\S/) {
2882			if (WARN("MAINTAINERS_STYLE",
2883				 "MAINTAINERS entries use one tab after TYPE:\n" . $herecurr) &&
2884			    $fix) {
2885				$fixed[$fixlinenr] =~ s/^(\+[A-Z]):\s*/$1:\t/;
2886			}
2887		}
2888
2889# discourage the use of boolean for type definition attributes of Kconfig options
2890		if ($realfile =~ /Kconfig/ &&
2891		    $line =~ /^\+\s*\bboolean\b/) {
2892			WARN("CONFIG_TYPE_BOOLEAN",
2893			     "Use of boolean is deprecated, please use bool instead.\n" . $herecurr);
2894		}
2895
2896		if (($realfile =~ /Makefile.*/ || $realfile =~ /Kbuild.*/) &&
2897		    ($line =~ /\+(EXTRA_[A-Z]+FLAGS).*/)) {
2898			my $flag = $1;
2899			my $replacement = {
2900				'EXTRA_AFLAGS' =>   'asflags-y',
2901				'EXTRA_CFLAGS' =>   'ccflags-y',
2902				'EXTRA_CPPFLAGS' => 'cppflags-y',
2903				'EXTRA_LDFLAGS' =>  'ldflags-y',
2904			};
2905
2906			WARN("DEPRECATED_VARIABLE",
2907			     "Use of $flag is deprecated, please use \`$replacement->{$flag} instead.\n" . $herecurr) if ($replacement->{$flag});
2908		}
2909
2910# check for DT compatible documentation
2911		if (defined $root &&
2912			(($realfile =~ /\.dtsi?$/ && $line =~ /^\+\s*compatible\s*=\s*\"/) ||
2913			 ($realfile =~ /\.[ch]$/ && $line =~ /^\+.*\.compatible\s*=\s*\"/))) {
2914
2915			my @compats = $rawline =~ /\"([a-zA-Z0-9\-\,\.\+_]+)\"/g;
2916
2917			my $dt_path = $root . "/Documentation/devicetree/bindings/";
2918			my $vp_file = $dt_path . "vendor-prefixes.txt";
2919
2920			foreach my $compat (@compats) {
2921				my $compat2 = $compat;
2922				$compat2 =~ s/\,[a-zA-Z0-9]*\-/\,<\.\*>\-/;
2923				my $compat3 = $compat;
2924				$compat3 =~ s/\,([a-z]*)[0-9]*\-/\,$1<\.\*>\-/;
2925				`grep -Erq "$compat|$compat2|$compat3" $dt_path`;
2926				if ( $? >> 8 ) {
2927					WARN("UNDOCUMENTED_DT_STRING",
2928					     "DT compatible string \"$compat\" appears un-documented -- check $dt_path\n" . $herecurr);
2929				}
2930
2931				next if $compat !~ /^([a-zA-Z0-9\-]+)\,/;
2932				my $vendor = $1;
2933				`grep -Eq "^$vendor\\b" $vp_file`;
2934				if ( $? >> 8 ) {
2935					WARN("UNDOCUMENTED_DT_STRING",
2936					     "DT compatible string vendor \"$vendor\" appears un-documented -- check $vp_file\n" . $herecurr);
2937				}
2938			}
2939		}
2940
2941# check for using SPDX license tag at beginning of files
2942		if ($realline == $checklicenseline) {
2943			if ($rawline =~ /^[ \+]\s*\#\!\s*\//) {
2944				$checklicenseline = 2;
2945			} elsif ($rawline =~ /^\+/) {
2946				my $comment = "";
2947				if ($realfile =~ /\.(h|s|S)$/) {
2948					$comment = '/*';
2949				} elsif ($realfile =~ /\.(c|dts|dtsi)$/) {
2950					$comment = '//';
2951				} elsif (($checklicenseline == 2) || $realfile =~ /\.(sh|pl|py|awk|tc)$/) {
2952					$comment = '#';
2953				} elsif ($realfile =~ /\.rst$/) {
2954					$comment = '..';
2955				}
2956
2957				if ($comment !~ /^$/ &&
2958				    $rawline !~ /^\+\Q$comment\E SPDX-License-Identifier: /) {
2959					WARN("SPDX_LICENSE_TAG",
2960					     "Missing or malformed SPDX-License-Identifier tag in line $checklicenseline\n" . $herecurr);
2961				}
2962			}
2963		}
2964
2965# check we are in a valid source file if not then ignore this hunk
2966		next if ($realfile !~ /\.(h|c|s|S|sh|dtsi|dts)$/);
2967
2968# line length limit (with some exclusions)
2969#
2970# There are a few types of lines that may extend beyond $max_line_length:
2971#	logging functions like pr_info that end in a string
2972#	lines with a single string
2973#	#defines that are a single string
2974#	lines with an RFC3986 like URL
2975#
2976# There are 3 different line length message types:
2977# LONG_LINE_COMMENT	a comment starts before but extends beyond $max_line_length
2978# LONG_LINE_STRING	a string starts before but extends beyond $max_line_length
2979# LONG_LINE		all other lines longer than $max_line_length
2980#
2981# if LONG_LINE is ignored, the other 2 types are also ignored
2982#
2983
2984		if ($line =~ /^\+/ && $length > $max_line_length) {
2985			my $msg_type = "LONG_LINE";
2986
2987			# Check the allowed long line types first
2988
2989			# logging functions that end in a string that starts
2990			# before $max_line_length
2991			if ($line =~ /^\+\s*$logFunctions\s*\(\s*(?:(?:KERN_\S+\s*|[^"]*))?($String\s*(?:|,|\)\s*;)\s*)$/ &&
2992			    length(expand_tabs(substr($line, 1, length($line) - length($1) - 1))) <= $max_line_length) {
2993				$msg_type = "";
2994
2995			# lines with only strings (w/ possible termination)
2996			# #defines with only strings
2997			} elsif ($line =~ /^\+\s*$String\s*(?:\s*|,|\)\s*;)\s*$/ ||
2998				 $line =~ /^\+\s*#\s*define\s+\w+\s+$String$/) {
2999				$msg_type = "";
3000
3001			# More special cases
3002			} elsif ($line =~ /^\+.*\bEFI_GUID\s*\(/ ||
3003				 $line =~ /^\+\s*(?:\w+)?\s*DEFINE_PER_CPU/) {
3004				$msg_type = "";
3005
3006			# URL ($rawline is used in case the URL is in a comment)
3007			} elsif ($rawline =~ /^\+.*\b[a-z][\w\.\+\-]*:\/\/\S+/i) {
3008				$msg_type = "";
3009
3010			# Otherwise set the alternate message types
3011
3012			# a comment starts before $max_line_length
3013			} elsif ($line =~ /($;[\s$;]*)$/ &&
3014				 length(expand_tabs(substr($line, 1, length($line) - length($1) - 1))) <= $max_line_length) {
3015				$msg_type = "LONG_LINE_COMMENT"
3016
3017			# a quoted string starts before $max_line_length
3018			} elsif ($sline =~ /\s*($String(?:\s*(?:\\|,\s*|\)\s*;\s*))?)$/ &&
3019				 length(expand_tabs(substr($line, 1, length($line) - length($1) - 1))) <= $max_line_length) {
3020				$msg_type = "LONG_LINE_STRING"
3021			}
3022
3023			if ($msg_type ne "" &&
3024			    (show_type("LONG_LINE") || show_type($msg_type))) {
3025				WARN($msg_type,
3026				     "line over $max_line_length characters\n" . $herecurr);
3027			}
3028		}
3029
3030# check for adding lines without a newline.
3031		if ($line =~ /^\+/ && defined $lines[$linenr] && $lines[$linenr] =~ /^\\ No newline at end of file/) {
3032			WARN("MISSING_EOF_NEWLINE",
3033			     "adding a line without newline at end of file\n" . $herecurr);
3034		}
3035
3036# check we are in a valid source file C or perl if not then ignore this hunk
3037		next if ($realfile !~ /\.(h|c|pl|dtsi|dts)$/);
3038
3039# at the beginning of a line any tabs must come first and anything
3040# more than 8 must use tabs.
3041		if ($rawline =~ /^\+\s* \t\s*\S/ ||
3042		    $rawline =~ /^\+\s*        \s*/) {
3043			my $herevet = "$here\n" . cat_vet($rawline) . "\n";
3044			$rpt_cleaners = 1;
3045			if (ERROR("CODE_INDENT",
3046				  "code indent should use tabs where possible\n" . $herevet) &&
3047			    $fix) {
3048				$fixed[$fixlinenr] =~ s/^\+([ \t]+)/"\+" . tabify($1)/e;
3049			}
3050		}
3051
3052# check for space before tabs.
3053		if ($rawline =~ /^\+/ && $rawline =~ / \t/) {
3054			my $herevet = "$here\n" . cat_vet($rawline) . "\n";
3055			if (WARN("SPACE_BEFORE_TAB",
3056				"please, no space before tabs\n" . $herevet) &&
3057			    $fix) {
3058				while ($fixed[$fixlinenr] =~
3059					   s/(^\+.*) {8,8}\t/$1\t\t/) {}
3060				while ($fixed[$fixlinenr] =~
3061					   s/(^\+.*) +\t/$1\t/) {}
3062			}
3063		}
3064
3065# check for && or || at the start of a line
3066		if ($rawline =~ /^\+\s*(&&|\|\|)/) {
3067			CHK("LOGICAL_CONTINUATIONS",
3068			    "Logical continuations should be on the previous line\n" . $hereprev);
3069		}
3070
3071# check indentation starts on a tab stop
3072		if ($^V && $^V ge 5.10.0 &&
3073		    $sline =~ /^\+\t+( +)(?:$c90_Keywords\b|\{\s*$|\}\s*(?:else\b|while\b|\s*$)|$Declare\s*$Ident\s*[;=])/) {
3074			my $indent = length($1);
3075			if ($indent % 8) {
3076				if (WARN("TABSTOP",
3077					 "Statements should start on a tabstop\n" . $herecurr) &&
3078				    $fix) {
3079					$fixed[$fixlinenr] =~ s@(^\+\t+) +@$1 . "\t" x ($indent/8)@e;
3080				}
3081			}
3082		}
3083
3084# check multi-line statement indentation matches previous line
3085		if ($^V && $^V ge 5.10.0 &&
3086		    $prevline =~ /^\+([ \t]*)((?:$c90_Keywords(?:\s+if)\s*)|(?:$Declare\s*)?(?:$Ident|\(\s*\*\s*$Ident\s*\))\s*|(?:\*\s*)*$Lval\s*=\s*$Ident\s*)\(.*(\&\&|\|\||,)\s*$/) {
3087			$prevline =~ /^\+(\t*)(.*)$/;
3088			my $oldindent = $1;
3089			my $rest = $2;
3090
3091			my $pos = pos_last_openparen($rest);
3092			if ($pos >= 0) {
3093				$line =~ /^(\+| )([ \t]*)/;
3094				my $newindent = $2;
3095
3096				my $goodtabindent = $oldindent .
3097					"\t" x ($pos / 8) .
3098					" "  x ($pos % 8);
3099				my $goodspaceindent = $oldindent . " "  x $pos;
3100
3101				if ($newindent ne $goodtabindent &&
3102				    $newindent ne $goodspaceindent) {
3103
3104					if (CHK("PARENTHESIS_ALIGNMENT",
3105						"Alignment should match open parenthesis\n" . $hereprev) &&
3106					    $fix && $line =~ /^\+/) {
3107						$fixed[$fixlinenr] =~
3108						    s/^\+[ \t]*/\+$goodtabindent/;
3109					}
3110				}
3111			}
3112		}
3113
3114# check for space after cast like "(int) foo" or "(struct foo) bar"
3115# avoid checking a few false positives:
3116#   "sizeof(<type>)" or "__alignof__(<type>)"
3117#   function pointer declarations like "(*foo)(int) = bar;"
3118#   structure definitions like "(struct foo) { 0 };"
3119#   multiline macros that define functions
3120#   known attributes or the __attribute__ keyword
3121		if ($line =~ /^\+(.*)\(\s*$Type\s*\)([ \t]++)((?![={]|\\$|$Attribute|__attribute__))/ &&
3122		    (!defined($1) || $1 !~ /\b(?:sizeof|__alignof__)\s*$/)) {
3123			if (CHK("SPACING",
3124				"No space is necessary after a cast\n" . $herecurr) &&
3125			    $fix) {
3126				$fixed[$fixlinenr] =~
3127				    s/(\(\s*$Type\s*\))[ \t]+/$1/;
3128			}
3129		}
3130
3131# Block comment styles
3132# Networking with an initial /*
3133		if ($realfile =~ m@^(drivers/net/|net/)@ &&
3134		    $prevrawline =~ /^\+[ \t]*\/\*[ \t]*$/ &&
3135		    $rawline =~ /^\+[ \t]*\*/ &&
3136		    $realline > 2) {
3137			WARN("NETWORKING_BLOCK_COMMENT_STYLE",
3138			     "networking block comments don't use an empty /* line, use /* Comment...\n" . $hereprev);
3139		}
3140
3141# Block comments use * on subsequent lines
3142		if ($prevline =~ /$;[ \t]*$/ &&			#ends in comment
3143		    $prevrawline =~ /^\+.*?\/\*/ &&		#starting /*
3144		    $prevrawline !~ /\*\/[ \t]*$/ &&		#no trailing */
3145		    $rawline =~ /^\+/ &&			#line is new
3146		    $rawline !~ /^\+[ \t]*\*/) {		#no leading *
3147			WARN("BLOCK_COMMENT_STYLE",
3148			     "Block comments use * on subsequent lines\n" . $hereprev);
3149		}
3150
3151# Block comments use */ on trailing lines
3152		if ($rawline !~ m@^\+[ \t]*\*/[ \t]*$@ &&	#trailing */
3153		    $rawline !~ m@^\+.*/\*.*\*/[ \t]*$@ &&	#inline /*...*/
3154		    $rawline !~ m@^\+.*\*{2,}/[ \t]*$@ &&	#trailing **/
3155		    $rawline =~ m@^\+[ \t]*.+\*\/[ \t]*$@) {	#non blank */
3156			WARN("BLOCK_COMMENT_STYLE",
3157			     "Block comments use a trailing */ on a separate line\n" . $herecurr);
3158		}
3159
3160# Block comment * alignment
3161		if ($prevline =~ /$;[ \t]*$/ &&			#ends in comment
3162		    $line =~ /^\+[ \t]*$;/ &&			#leading comment
3163		    $rawline =~ /^\+[ \t]*\*/ &&		#leading *
3164		    (($prevrawline =~ /^\+.*?\/\*/ &&		#leading /*
3165		      $prevrawline !~ /\*\/[ \t]*$/) ||		#no trailing */
3166		     $prevrawline =~ /^\+[ \t]*\*/)) {		#leading *
3167			my $oldindent;
3168			$prevrawline =~ m@^\+([ \t]*/?)\*@;
3169			if (defined($1)) {
3170				$oldindent = expand_tabs($1);
3171			} else {
3172				$prevrawline =~ m@^\+(.*/?)\*@;
3173				$oldindent = expand_tabs($1);
3174			}
3175			$rawline =~ m@^\+([ \t]*)\*@;
3176			my $newindent = $1;
3177			$newindent = expand_tabs($newindent);
3178			if (length($oldindent) ne length($newindent)) {
3179				WARN("BLOCK_COMMENT_STYLE",
3180				     "Block comments should align the * on each line\n" . $hereprev);
3181			}
3182		}
3183
3184# check for missing blank lines after struct/union declarations
3185# with exceptions for various attributes and macros
3186		if ($prevline =~ /^[\+ ]};?\s*$/ &&
3187		    $line =~ /^\+/ &&
3188		    !($line =~ /^\+\s*$/ ||
3189		      $line =~ /^\+\s*EXPORT_SYMBOL/ ||
3190		      $line =~ /^\+\s*MODULE_/i ||
3191		      $line =~ /^\+\s*\#\s*(?:end|elif|else)/ ||
3192		      $line =~ /^\+[a-z_]*init/ ||
3193		      $line =~ /^\+\s*(?:static\s+)?[A-Z_]*ATTR/ ||
3194		      $line =~ /^\+\s*DECLARE/ ||
3195		      $line =~ /^\+\s*builtin_[\w_]*driver/ ||
3196		      $line =~ /^\+\s*__setup/)) {
3197			if (CHK("LINE_SPACING",
3198				"Please use a blank line after function/struct/union/enum declarations\n" . $hereprev) &&
3199			    $fix) {
3200				fix_insert_line($fixlinenr, "\+");
3201			}
3202		}
3203
3204# check for multiple consecutive blank lines
3205		if ($prevline =~ /^[\+ ]\s*$/ &&
3206		    $line =~ /^\+\s*$/ &&
3207		    $last_blank_line != ($linenr - 1)) {
3208			if (CHK("LINE_SPACING",
3209				"Please don't use multiple blank lines\n" . $hereprev) &&
3210			    $fix) {
3211				fix_delete_line($fixlinenr, $rawline);
3212			}
3213
3214			$last_blank_line = $linenr;
3215		}
3216
3217# check for missing blank lines after declarations
3218		if ($sline =~ /^\+\s+\S/ &&			#Not at char 1
3219			# actual declarations
3220		    ($prevline =~ /^\+\s+$Declare\s*$Ident\s*[=,;:\[]/ ||
3221			# function pointer declarations
3222		     $prevline =~ /^\+\s+$Declare\s*\(\s*\*\s*$Ident\s*\)\s*[=,;:\[\(]/ ||
3223			# foo bar; where foo is some local typedef or #define
3224		     $prevline =~ /^\+\s+$Ident(?:\s+|\s*\*\s*)$Ident\s*[=,;\[]/ ||
3225			# known declaration macros
3226		     $prevline =~ /^\+\s+$declaration_macros/) &&
3227			# for "else if" which can look like "$Ident $Ident"
3228		    !($prevline =~ /^\+\s+$c90_Keywords\b/ ||
3229			# other possible extensions of declaration lines
3230		      $prevline =~ /(?:$Compare|$Assignment|$Operators)\s*$/ ||
3231			# not starting a section or a macro "\" extended line
3232		      $prevline =~ /(?:\{\s*|\\)$/) &&
3233			# looks like a declaration
3234		    !($sline =~ /^\+\s+$Declare\s*$Ident\s*[=,;:\[]/ ||
3235			# function pointer declarations
3236		      $sline =~ /^\+\s+$Declare\s*\(\s*\*\s*$Ident\s*\)\s*[=,;:\[\(]/ ||
3237			# foo bar; where foo is some local typedef or #define
3238		      $sline =~ /^\+\s+$Ident(?:\s+|\s*\*\s*)$Ident\s*[=,;\[]/ ||
3239			# known declaration macros
3240		      $sline =~ /^\+\s+$declaration_macros/ ||
3241			# start of struct or union or enum
3242		      $sline =~ /^\+\s+(?:union|struct|enum|typedef)\b/ ||
3243			# start or end of block or continuation of declaration
3244		      $sline =~ /^\+\s+(?:$|[\{\}\.\#\"\?\:\(\[])/ ||
3245			# bitfield continuation
3246		      $sline =~ /^\+\s+$Ident\s*:\s*\d+\s*[,;]/ ||
3247			# other possible extensions of declaration lines
3248		      $sline =~ /^\+\s+\(?\s*(?:$Compare|$Assignment|$Operators)/) &&
3249			# indentation of previous and current line are the same
3250		    (($prevline =~ /\+(\s+)\S/) && $sline =~ /^\+$1\S/)) {
3251			if (WARN("LINE_SPACING",
3252				 "Missing a blank line after declarations\n" . $hereprev) &&
3253			    $fix) {
3254				fix_insert_line($fixlinenr, "\+");
3255			}
3256		}
3257
3258# check for spaces at the beginning of a line.
3259# Exceptions:
3260#  1) within comments
3261#  2) indented preprocessor commands
3262#  3) hanging labels
3263		if ($rawline =~ /^\+ / && $line !~ /^\+ *(?:$;|#|$Ident:)/)  {
3264			my $herevet = "$here\n" . cat_vet($rawline) . "\n";
3265			if (WARN("LEADING_SPACE",
3266				 "please, no spaces at the start of a line\n" . $herevet) &&
3267			    $fix) {
3268				$fixed[$fixlinenr] =~ s/^\+([ \t]+)/"\+" . tabify($1)/e;
3269			}
3270		}
3271
3272# check we are in a valid C source file if not then ignore this hunk
3273		next if ($realfile !~ /\.(h|c)$/);
3274
3275# check for unusual line ending [ or (
3276		if ($line =~ /^\+.*([\[\(])\s*$/) {
3277			CHK("OPEN_ENDED_LINE",
3278			    "Lines should not end with a '$1'\n" . $herecurr);
3279		}
3280
3281# check if this appears to be the start function declaration, save the name
3282		if ($sline =~ /^\+\{\s*$/ &&
3283		    $prevline =~ /^\+(?:(?:(?:$Storage|$Inline)\s*)*\s*$Type\s*)?($Ident)\(/) {
3284			$context_function = $1;
3285		}
3286
3287# check if this appears to be the end of function declaration
3288		if ($sline =~ /^\+\}\s*$/) {
3289			undef $context_function;
3290		}
3291
3292# check indentation of any line with a bare else
3293# (but not if it is a multiple line "if (foo) return bar; else return baz;")
3294# if the previous line is a break or return and is indented 1 tab more...
3295		if ($sline =~ /^\+([\t]+)(?:}[ \t]*)?else(?:[ \t]*{)?\s*$/) {
3296			my $tabs = length($1) + 1;
3297			if ($prevline =~ /^\+\t{$tabs,$tabs}break\b/ ||
3298			    ($prevline =~ /^\+\t{$tabs,$tabs}return\b/ &&
3299			     defined $lines[$linenr] &&
3300			     $lines[$linenr] !~ /^[ \+]\t{$tabs,$tabs}return/)) {
3301				WARN("UNNECESSARY_ELSE",
3302				     "else is not generally useful after a break or return\n" . $hereprev);
3303			}
3304		}
3305
3306# check indentation of a line with a break;
3307# if the previous line is a goto or return and is indented the same # of tabs
3308		if ($sline =~ /^\+([\t]+)break\s*;\s*$/) {
3309			my $tabs = $1;
3310			if ($prevline =~ /^\+$tabs(?:goto|return)\b/) {
3311				WARN("UNNECESSARY_BREAK",
3312				     "break is not useful after a goto or return\n" . $hereprev);
3313			}
3314		}
3315
3316# check for RCS/CVS revision markers
3317		if ($rawline =~ /^\+.*\$(Revision|Log|Id)(?:\$|)/) {
3318			WARN("CVS_KEYWORD",
3319			     "CVS style keyword markers, these will _not_ be updated\n". $herecurr);
3320		}
3321
3322# check for old HOTPLUG __dev<foo> section markings
3323		if ($line =~ /\b(__dev(init|exit)(data|const|))\b/) {
3324			WARN("HOTPLUG_SECTION",
3325			     "Using $1 is unnecessary\n" . $herecurr);
3326		}
3327
3328# Check for potential 'bare' types
3329		my ($stat, $cond, $line_nr_next, $remain_next, $off_next,
3330		    $realline_next);
3331#print "LINE<$line>\n";
3332		if ($linenr > $suppress_statement &&
3333		    $realcnt && $sline =~ /.\s*\S/) {
3334			($stat, $cond, $line_nr_next, $remain_next, $off_next) =
3335				ctx_statement_block($linenr, $realcnt, 0);
3336			$stat =~ s/\n./\n /g;
3337			$cond =~ s/\n./\n /g;
3338
3339#print "linenr<$linenr> <$stat>\n";
3340			# If this statement has no statement boundaries within
3341			# it there is no point in retrying a statement scan
3342			# until we hit end of it.
3343			my $frag = $stat; $frag =~ s/;+\s*$//;
3344			if ($frag !~ /(?:{|;)/) {
3345#print "skip<$line_nr_next>\n";
3346				$suppress_statement = $line_nr_next;
3347			}
3348
3349			# Find the real next line.
3350			$realline_next = $line_nr_next;
3351			if (defined $realline_next &&
3352			    (!defined $lines[$realline_next - 1] ||
3353			     substr($lines[$realline_next - 1], $off_next) =~ /^\s*$/)) {
3354				$realline_next++;
3355			}
3356
3357			my $s = $stat;
3358			$s =~ s/{.*$//s;
3359
3360			# Ignore goto labels.
3361			if ($s =~ /$Ident:\*$/s) {
3362
3363			# Ignore functions being called
3364			} elsif ($s =~ /^.\s*$Ident\s*\(/s) {
3365
3366			} elsif ($s =~ /^.\s*else\b/s) {
3367
3368			# declarations always start with types
3369			} 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) {
3370				my $type = $1;
3371				$type =~ s/\s+/ /g;
3372				possible($type, "A:" . $s);
3373
3374			# definitions in global scope can only start with types
3375			} elsif ($s =~ /^.(?:$Storage\s+)?(?:$Inline\s+)?(?:const\s+)?($Ident)\b\s*(?!:)/s) {
3376				possible($1, "B:" . $s);
3377			}
3378
3379			# any (foo ... *) is a pointer cast, and foo is a type
3380			while ($s =~ /\(($Ident)(?:\s+$Sparse)*[\s\*]+\s*\)/sg) {
3381				possible($1, "C:" . $s);
3382			}
3383
3384			# Check for any sort of function declaration.
3385			# int foo(something bar, other baz);
3386			# void (*store_gdt)(x86_descr_ptr *);
3387			if ($prev_values eq 'E' && $s =~ /^(.(?:typedef\s*)?(?:(?:$Storage|$Inline)\s*)*\s*$Type\s*(?:\b$Ident|\(\*\s*$Ident\))\s*)\(/s) {
3388				my ($name_len) = length($1);
3389
3390				my $ctx = $s;
3391				substr($ctx, 0, $name_len + 1, '');
3392				$ctx =~ s/\)[^\)]*$//;
3393
3394				for my $arg (split(/\s*,\s*/, $ctx)) {
3395					if ($arg =~ /^(?:const\s+)?($Ident)(?:\s+$Sparse)*\s*\**\s*(:?\b$Ident)?$/s || $arg =~ /^($Ident)$/s) {
3396
3397						possible($1, "D:" . $s);
3398					}
3399				}
3400			}
3401
3402		}
3403
3404#
3405# Checks which may be anchored in the context.
3406#
3407
3408# Check for switch () and associated case and default
3409# statements should be at the same indent.
3410		if ($line=~/\bswitch\s*\(.*\)/) {
3411			my $err = '';
3412			my $sep = '';
3413			my @ctx = ctx_block_outer($linenr, $realcnt);
3414			shift(@ctx);
3415			for my $ctx (@ctx) {
3416				my ($clen, $cindent) = line_stats($ctx);
3417				if ($ctx =~ /^\+\s*(case\s+|default:)/ &&
3418							$indent != $cindent) {
3419					$err .= "$sep$ctx\n";
3420					$sep = '';
3421				} else {
3422					$sep = "[...]\n";
3423				}
3424			}
3425			if ($err ne '') {
3426				ERROR("SWITCH_CASE_INDENT_LEVEL",
3427				      "switch and case should be at the same indent\n$hereline$err");
3428			}
3429		}
3430
3431# if/while/etc brace do not go on next line, unless defining a do while loop,
3432# or if that brace on the next line is for something else
3433		if ($line =~ /(.*)\b((?:if|while|for|switch|(?:[a-z_]+|)for_each[a-z_]+)\s*\(|do\b|else\b)/ && $line !~ /^.\s*\#/) {
3434			my $pre_ctx = "$1$2";
3435
3436			my ($level, @ctx) = ctx_statement_level($linenr, $realcnt, 0);
3437
3438			if ($line =~ /^\+\t{6,}/) {
3439				WARN("DEEP_INDENTATION",
3440				     "Too many leading tabs - consider code refactoring\n" . $herecurr);
3441			}
3442
3443			my $ctx_cnt = $realcnt - $#ctx - 1;
3444			my $ctx = join("\n", @ctx);
3445
3446			my $ctx_ln = $linenr;
3447			my $ctx_skip = $realcnt;
3448
3449			while ($ctx_skip > $ctx_cnt || ($ctx_skip == $ctx_cnt &&
3450					defined $lines[$ctx_ln - 1] &&
3451					$lines[$ctx_ln - 1] =~ /^-/)) {
3452				##print "SKIP<$ctx_skip> CNT<$ctx_cnt>\n";
3453				$ctx_skip-- if (!defined $lines[$ctx_ln - 1] || $lines[$ctx_ln - 1] !~ /^-/);
3454				$ctx_ln++;
3455			}
3456
3457			#print "realcnt<$realcnt> ctx_cnt<$ctx_cnt>\n";
3458			#print "pre<$pre_ctx>\nline<$line>\nctx<$ctx>\nnext<$lines[$ctx_ln - 1]>\n";
3459
3460			if ($ctx !~ /{\s*/ && defined($lines[$ctx_ln - 1]) && $lines[$ctx_ln - 1] =~ /^\+\s*{/) {
3461				ERROR("OPEN_BRACE",
3462				      "that open brace { should be on the previous line\n" .
3463					"$here\n$ctx\n$rawlines[$ctx_ln - 1]\n");
3464			}
3465			if ($level == 0 && $pre_ctx !~ /}\s*while\s*\($/ &&
3466			    $ctx =~ /\)\s*\;\s*$/ &&
3467			    defined $lines[$ctx_ln - 1])
3468			{
3469				my ($nlength, $nindent) = line_stats($lines[$ctx_ln - 1]);
3470				if ($nindent > $indent) {
3471					WARN("TRAILING_SEMICOLON",
3472					     "trailing semicolon indicates no statements, indent implies otherwise\n" .
3473						"$here\n$ctx\n$rawlines[$ctx_ln - 1]\n");
3474				}
3475			}
3476		}
3477
3478# Check relative indent for conditionals and blocks.
3479		if ($line =~ /\b(?:(?:if|while|for|(?:[a-z_]+|)for_each[a-z_]+)\s*\(|(?:do|else)\b)/ && $line !~ /^.\s*#/ && $line !~ /\}\s*while\s*/) {
3480			($stat, $cond, $line_nr_next, $remain_next, $off_next) =
3481				ctx_statement_block($linenr, $realcnt, 0)
3482					if (!defined $stat);
3483			my ($s, $c) = ($stat, $cond);
3484
3485			substr($s, 0, length($c), '');
3486
3487			# remove inline comments
3488			$s =~ s/$;/ /g;
3489			$c =~ s/$;/ /g;
3490
3491			# Find out how long the conditional actually is.
3492			my @newlines = ($c =~ /\n/gs);
3493			my $cond_lines = 1 + $#newlines;
3494
3495			# Make sure we remove the line prefixes as we have
3496			# none on the first line, and are going to readd them
3497			# where necessary.
3498			$s =~ s/\n./\n/gs;
3499			while ($s =~ /\n\s+\\\n/) {
3500				$cond_lines += $s =~ s/\n\s+\\\n/\n/g;
3501			}
3502
3503			# We want to check the first line inside the block
3504			# starting at the end of the conditional, so remove:
3505			#  1) any blank line termination
3506			#  2) any opening brace { on end of the line
3507			#  3) any do (...) {
3508			my $continuation = 0;
3509			my $check = 0;
3510			$s =~ s/^.*\bdo\b//;
3511			$s =~ s/^\s*{//;
3512			if ($s =~ s/^\s*\\//) {
3513				$continuation = 1;
3514			}
3515			if ($s =~ s/^\s*?\n//) {
3516				$check = 1;
3517				$cond_lines++;
3518			}
3519
3520			# Also ignore a loop construct at the end of a
3521			# preprocessor statement.
3522			if (($prevline =~ /^.\s*#\s*define\s/ ||
3523			    $prevline =~ /\\\s*$/) && $continuation == 0) {
3524				$check = 0;
3525			}
3526
3527			my $cond_ptr = -1;
3528			$continuation = 0;
3529			while ($cond_ptr != $cond_lines) {
3530				$cond_ptr = $cond_lines;
3531
3532				# If we see an #else/#elif then the code
3533				# is not linear.
3534				if ($s =~ /^\s*\#\s*(?:else|elif)/) {
3535					$check = 0;
3536				}
3537
3538				# Ignore:
3539				#  1) blank lines, they should be at 0,
3540				#  2) preprocessor lines, and
3541				#  3) labels.
3542				if ($continuation ||
3543				    $s =~ /^\s*?\n/ ||
3544				    $s =~ /^\s*#\s*?/ ||
3545				    $s =~ /^\s*$Ident\s*:/) {
3546					$continuation = ($s =~ /^.*?\\\n/) ? 1 : 0;
3547					if ($s =~ s/^.*?\n//) {
3548						$cond_lines++;
3549					}
3550				}
3551			}
3552
3553			my (undef, $sindent) = line_stats("+" . $s);
3554			my $stat_real = raw_line($linenr, $cond_lines);
3555
3556			# Check if either of these lines are modified, else
3557			# this is not this patch's fault.
3558			if (!defined($stat_real) ||
3559			    $stat !~ /^\+/ && $stat_real !~ /^\+/) {
3560				$check = 0;
3561			}
3562			if (defined($stat_real) && $cond_lines > 1) {
3563				$stat_real = "[...]\n$stat_real";
3564			}
3565
3566			#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";
3567
3568			if ($check && $s ne '' &&
3569			    (($sindent % 8) != 0 ||
3570			     ($sindent < $indent) ||
3571			     ($sindent == $indent &&
3572			      ($s !~ /^\s*(?:\}|\{|else\b)/)) ||
3573			     ($sindent > $indent + 8))) {
3574				WARN("SUSPECT_CODE_INDENT",
3575				     "suspect code indent for conditional statements ($indent, $sindent)\n" . $herecurr . "$stat_real\n");
3576			}
3577		}
3578
3579		# Track the 'values' across context and added lines.
3580		my $opline = $line; $opline =~ s/^./ /;
3581		my ($curr_values, $curr_vars) =
3582				annotate_values($opline . "\n", $prev_values);
3583		$curr_values = $prev_values . $curr_values;
3584		if ($dbg_values) {
3585			my $outline = $opline; $outline =~ s/\t/ /g;
3586			print "$linenr > .$outline\n";
3587			print "$linenr > $curr_values\n";
3588			print "$linenr >  $curr_vars\n";
3589		}
3590		$prev_values = substr($curr_values, -1);
3591
3592#ignore lines not being added
3593		next if ($line =~ /^[^\+]/);
3594
3595# check for dereferences that span multiple lines
3596		if ($prevline =~ /^\+.*$Lval\s*(?:\.|->)\s*$/ &&
3597		    $line =~ /^\+\s*(?!\#\s*(?!define\s+|if))\s*$Lval/) {
3598			$prevline =~ /($Lval\s*(?:\.|->))\s*$/;
3599			my $ref = $1;
3600			$line =~ /^.\s*($Lval)/;
3601			$ref .= $1;
3602			$ref =~ s/\s//g;
3603			WARN("MULTILINE_DEREFERENCE",
3604			     "Avoid multiple line dereference - prefer '$ref'\n" . $hereprev);
3605		}
3606
3607# check for declarations of signed or unsigned without int
3608		while ($line =~ m{\b($Declare)\s*(?!char\b|short\b|int\b|long\b)\s*($Ident)?\s*[=,;\[\)\(]}g) {
3609			my $type = $1;
3610			my $var = $2;
3611			$var = "" if (!defined $var);
3612			if ($type =~ /^(?:(?:$Storage|$Inline|$Attribute)\s+)*((?:un)?signed)((?:\s*\*)*)\s*$/) {
3613				my $sign = $1;
3614				my $pointer = $2;
3615
3616				$pointer = "" if (!defined $pointer);
3617
3618				if (WARN("UNSPECIFIED_INT",
3619					 "Prefer '" . trim($sign) . " int" . rtrim($pointer) . "' to bare use of '$sign" . rtrim($pointer) . "'\n" . $herecurr) &&
3620				    $fix) {
3621					my $decl = trim($sign) . " int ";
3622					my $comp_pointer = $pointer;
3623					$comp_pointer =~ s/\s//g;
3624					$decl .= $comp_pointer;
3625					$decl = rtrim($decl) if ($var eq "");
3626					$fixed[$fixlinenr] =~ s@\b$sign\s*\Q$pointer\E\s*$var\b@$decl$var@;
3627				}
3628			}
3629		}
3630
3631# TEST: allow direct testing of the type matcher.
3632		if ($dbg_type) {
3633			if ($line =~ /^.\s*$Declare\s*$/) {
3634				ERROR("TEST_TYPE",
3635				      "TEST: is type\n" . $herecurr);
3636			} elsif ($dbg_type > 1 && $line =~ /^.+($Declare)/) {
3637				ERROR("TEST_NOT_TYPE",
3638				      "TEST: is not type ($1 is)\n". $herecurr);
3639			}
3640			next;
3641		}
3642# TEST: allow direct testing of the attribute matcher.
3643		if ($dbg_attr) {
3644			if ($line =~ /^.\s*$Modifier\s*$/) {
3645				ERROR("TEST_ATTR",
3646				      "TEST: is attr\n" . $herecurr);
3647			} elsif ($dbg_attr > 1 && $line =~ /^.+($Modifier)/) {
3648				ERROR("TEST_NOT_ATTR",
3649				      "TEST: is not attr ($1 is)\n". $herecurr);
3650			}
3651			next;
3652		}
3653
3654# check for initialisation to aggregates open brace on the next line
3655		if ($line =~ /^.\s*{/ &&
3656		    $prevline =~ /(?:^|[^=])=\s*$/) {
3657			if (ERROR("OPEN_BRACE",
3658				  "that open brace { should be on the previous line\n" . $hereprev) &&
3659			    $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
3660				fix_delete_line($fixlinenr - 1, $prevrawline);
3661				fix_delete_line($fixlinenr, $rawline);
3662				my $fixedline = $prevrawline;
3663				$fixedline =~ s/\s*=\s*$/ = {/;
3664				fix_insert_line($fixlinenr, $fixedline);
3665				$fixedline = $line;
3666				$fixedline =~ s/^(.\s*)\{\s*/$1/;
3667				fix_insert_line($fixlinenr, $fixedline);
3668			}
3669		}
3670
3671#
3672# Checks which are anchored on the added line.
3673#
3674
3675# check for malformed paths in #include statements (uses RAW line)
3676		if ($rawline =~ m{^.\s*\#\s*include\s+[<"](.*)[">]}) {
3677			my $path = $1;
3678			if ($path =~ m{//}) {
3679				ERROR("MALFORMED_INCLUDE",
3680				      "malformed #include filename\n" . $herecurr);
3681			}
3682			if ($path =~ "^uapi/" && $realfile =~ m@\binclude/uapi/@) {
3683				ERROR("UAPI_INCLUDE",
3684				      "No #include in ...include/uapi/... should use a uapi/ path prefix\n" . $herecurr);
3685			}
3686		}
3687
3688# no C99 // comments
3689		if ($line =~ m{//}) {
3690			if (ERROR("C99_COMMENTS",
3691				  "do not use C99 // comments\n" . $herecurr) &&
3692			    $fix) {
3693				my $line = $fixed[$fixlinenr];
3694				if ($line =~ /\/\/(.*)$/) {
3695					my $comment = trim($1);
3696					$fixed[$fixlinenr] =~ s@\/\/(.*)$@/\* $comment \*/@;
3697				}
3698			}
3699		}
3700		# Remove C99 comments.
3701		$line =~ s@//.*@@;
3702		$opline =~ s@//.*@@;
3703
3704# EXPORT_SYMBOL should immediately follow the thing it is exporting, consider
3705# the whole statement.
3706#print "APW <$lines[$realline_next - 1]>\n";
3707		if (defined $realline_next &&
3708		    exists $lines[$realline_next - 1] &&
3709		    !defined $suppress_export{$realline_next} &&
3710		    ($lines[$realline_next - 1] =~ /EXPORT_SYMBOL.*\((.*)\)/ ||
3711		     $lines[$realline_next - 1] =~ /EXPORT_UNUSED_SYMBOL.*\((.*)\)/)) {
3712			# Handle definitions which produce identifiers with
3713			# a prefix:
3714			#   XXX(foo);
3715			#   EXPORT_SYMBOL(something_foo);
3716			my $name = $1;
3717			if ($stat =~ /^(?:.\s*}\s*\n)?.([A-Z_]+)\s*\(\s*($Ident)/ &&
3718			    $name =~ /^${Ident}_$2/) {
3719#print "FOO C name<$name>\n";
3720				$suppress_export{$realline_next} = 1;
3721
3722			} elsif ($stat !~ /(?:
3723				\n.}\s*$|
3724				^.DEFINE_$Ident\(\Q$name\E\)|
3725				^.DECLARE_$Ident\(\Q$name\E\)|
3726				^.LIST_HEAD\(\Q$name\E\)|
3727				^.(?:$Storage\s+)?$Type\s*\(\s*\*\s*\Q$name\E\s*\)\s*\(|
3728				\b\Q$name\E(?:\s+$Attribute)*\s*(?:;|=|\[|\()
3729			    )/x) {
3730#print "FOO A<$lines[$realline_next - 1]> stat<$stat> name<$name>\n";
3731				$suppress_export{$realline_next} = 2;
3732			} else {
3733				$suppress_export{$realline_next} = 1;
3734			}
3735		}
3736		if (!defined $suppress_export{$linenr} &&
3737		    $prevline =~ /^.\s*$/ &&
3738		    ($line =~ /EXPORT_SYMBOL.*\((.*)\)/ ||
3739		     $line =~ /EXPORT_UNUSED_SYMBOL.*\((.*)\)/)) {
3740#print "FOO B <$lines[$linenr - 1]>\n";
3741			$suppress_export{$linenr} = 2;
3742		}
3743		if (defined $suppress_export{$linenr} &&
3744		    $suppress_export{$linenr} == 2) {
3745			WARN("EXPORT_SYMBOL",
3746			     "EXPORT_SYMBOL(foo); should immediately follow its function/variable\n" . $herecurr);
3747		}
3748
3749# check for global initialisers.
3750		if ($line =~ /^\+$Type\s*$Ident(?:\s+$Modifier)*\s*=\s*($zero_initializer)\s*;/) {
3751			if (ERROR("GLOBAL_INITIALISERS",
3752				  "do not initialise globals to $1\n" . $herecurr) &&
3753			    $fix) {
3754				$fixed[$fixlinenr] =~ s/(^.$Type\s*$Ident(?:\s+$Modifier)*)\s*=\s*$zero_initializer\s*;/$1;/;
3755			}
3756		}
3757# check for static initialisers.
3758		if ($line =~ /^\+.*\bstatic\s.*=\s*($zero_initializer)\s*;/) {
3759			if (ERROR("INITIALISED_STATIC",
3760				  "do not initialise statics to $1\n" .
3761				      $herecurr) &&
3762			    $fix) {
3763				$fixed[$fixlinenr] =~ s/(\bstatic\s.*?)\s*=\s*$zero_initializer\s*;/$1;/;
3764			}
3765		}
3766
3767# check for misordered declarations of char/short/int/long with signed/unsigned
3768		while ($sline =~ m{(\b$TypeMisordered\b)}g) {
3769			my $tmp = trim($1);
3770			WARN("MISORDERED_TYPE",
3771			     "type '$tmp' should be specified in [[un]signed] [short|int|long|long long] order\n" . $herecurr);
3772		}
3773
3774# check for static const char * arrays.
3775		if ($line =~ /\bstatic\s+const\s+char\s*\*\s*(\w+)\s*\[\s*\]\s*=\s*/) {
3776			WARN("STATIC_CONST_CHAR_ARRAY",
3777			     "static const char * array should probably be static const char * const\n" .
3778				$herecurr);
3779               }
3780
3781# check for static char foo[] = "bar" declarations.
3782		if ($line =~ /\bstatic\s+char\s+(\w+)\s*\[\s*\]\s*=\s*"/) {
3783			WARN("STATIC_CONST_CHAR_ARRAY",
3784			     "static char array declaration should probably be static const char\n" .
3785				$herecurr);
3786               }
3787
3788# check for const <foo> const where <foo> is not a pointer or array type
3789		if ($sline =~ /\bconst\s+($BasicType)\s+const\b/) {
3790			my $found = $1;
3791			if ($sline =~ /\bconst\s+\Q$found\E\s+const\b\s*\*/) {
3792				WARN("CONST_CONST",
3793				     "'const $found const *' should probably be 'const $found * const'\n" . $herecurr);
3794			} elsif ($sline !~ /\bconst\s+\Q$found\E\s+const\s+\w+\s*\[/) {
3795				WARN("CONST_CONST",
3796				     "'const $found const' should probably be 'const $found'\n" . $herecurr);
3797			}
3798		}
3799
3800# check for non-global char *foo[] = {"bar", ...} declarations.
3801		if ($line =~ /^.\s+(?:static\s+|const\s+)?char\s+\*\s*\w+\s*\[\s*\]\s*=\s*\{/) {
3802			WARN("STATIC_CONST_CHAR_ARRAY",
3803			     "char * array declaration might be better as static const\n" .
3804				$herecurr);
3805               }
3806
3807# check for sizeof(foo)/sizeof(foo[0]) that could be ARRAY_SIZE(foo)
3808		if ($line =~ m@\bsizeof\s*\(\s*($Lval)\s*\)@) {
3809			my $array = $1;
3810			if ($line =~ m@\b(sizeof\s*\(\s*\Q$array\E\s*\)\s*/\s*sizeof\s*\(\s*\Q$array\E\s*\[\s*0\s*\]\s*\))@) {
3811				my $array_div = $1;
3812				if (WARN("ARRAY_SIZE",
3813					 "Prefer ARRAY_SIZE($array)\n" . $herecurr) &&
3814				    $fix) {
3815					$fixed[$fixlinenr] =~ s/\Q$array_div\E/ARRAY_SIZE($array)/;
3816				}
3817			}
3818		}
3819
3820# check for function declarations without arguments like "int foo()"
3821		if ($line =~ /(\b$Type\s+$Ident)\s*\(\s*\)/) {
3822			if (ERROR("FUNCTION_WITHOUT_ARGS",
3823				  "Bad function definition - $1() should probably be $1(void)\n" . $herecurr) &&
3824			    $fix) {
3825				$fixed[$fixlinenr] =~ s/(\b($Type)\s+($Ident))\s*\(\s*\)/$2 $3(void)/;
3826			}
3827		}
3828
3829# check for new typedefs, only function parameters and sparse annotations
3830# make sense.
3831		if ($line =~ /\btypedef\s/ &&
3832		    $line !~ /\btypedef\s+$Type\s*\(\s*\*?$Ident\s*\)\s*\(/ &&
3833		    $line !~ /\btypedef\s+$Type\s+$Ident\s*\(/ &&
3834		    $line !~ /\b$typeTypedefs\b/ &&
3835		    $line !~ /\b__bitwise\b/) {
3836			WARN("NEW_TYPEDEFS",
3837			     "do not add new typedefs\n" . $herecurr);
3838		}
3839
3840# * goes on variable not on type
3841		# (char*[ const])
3842		while ($line =~ m{(\($NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)\))}g) {
3843			#print "AA<$1>\n";
3844			my ($ident, $from, $to) = ($1, $2, $2);
3845
3846			# Should start with a space.
3847			$to =~ s/^(\S)/ $1/;
3848			# Should not end with a space.
3849			$to =~ s/\s+$//;
3850			# '*'s should not have spaces between.
3851			while ($to =~ s/\*\s+\*/\*\*/) {
3852			}
3853
3854##			print "1: from<$from> to<$to> ident<$ident>\n";
3855			if ($from ne $to) {
3856				if (ERROR("POINTER_LOCATION",
3857					  "\"(foo$from)\" should be \"(foo$to)\"\n" .  $herecurr) &&
3858				    $fix) {
3859					my $sub_from = $ident;
3860					my $sub_to = $ident;
3861					$sub_to =~ s/\Q$from\E/$to/;
3862					$fixed[$fixlinenr] =~
3863					    s@\Q$sub_from\E@$sub_to@;
3864				}
3865			}
3866		}
3867		while ($line =~ m{(\b$NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)($Ident))}g) {
3868			#print "BB<$1>\n";
3869			my ($match, $from, $to, $ident) = ($1, $2, $2, $3);
3870
3871			# Should start with a space.
3872			$to =~ s/^(\S)/ $1/;
3873			# Should not end with a space.
3874			$to =~ s/\s+$//;
3875			# '*'s should not have spaces between.
3876			while ($to =~ s/\*\s+\*/\*\*/) {
3877			}
3878			# Modifiers should have spaces.
3879			$to =~ s/(\b$Modifier$)/$1 /;
3880
3881##			print "2: from<$from> to<$to> ident<$ident>\n";
3882			if ($from ne $to && $ident !~ /^$Modifier$/) {
3883				if (ERROR("POINTER_LOCATION",
3884					  "\"foo${from}bar\" should be \"foo${to}bar\"\n" .  $herecurr) &&
3885				    $fix) {
3886
3887					my $sub_from = $match;
3888					my $sub_to = $match;
3889					$sub_to =~ s/\Q$from\E/$to/;
3890					$fixed[$fixlinenr] =~
3891					    s@\Q$sub_from\E@$sub_to@;
3892				}
3893			}
3894		}
3895
3896# avoid BUG() or BUG_ON()
3897		if ($line =~ /\b(?:BUG|BUG_ON)\b/) {
3898			my $msg_level = \&WARN;
3899			$msg_level = \&CHK if ($file);
3900			&{$msg_level}("AVOID_BUG",
3901				      "Avoid crashing the kernel - try using WARN_ON & recovery code rather than BUG() or BUG_ON()\n" . $herecurr);
3902		}
3903
3904# avoid LINUX_VERSION_CODE
3905		if ($line =~ /\bLINUX_VERSION_CODE\b/) {
3906			WARN("LINUX_VERSION_CODE",
3907			     "LINUX_VERSION_CODE should be avoided, code should be for the version to which it is merged\n" . $herecurr);
3908		}
3909
3910# check for uses of printk_ratelimit
3911		if ($line =~ /\bprintk_ratelimit\s*\(/) {
3912			WARN("PRINTK_RATELIMITED",
3913			     "Prefer printk_ratelimited or pr_<level>_ratelimited to printk_ratelimit\n" . $herecurr);
3914		}
3915
3916# printk should use KERN_* levels
3917		if ($line =~ /\bprintk\s*\(\s*(?!KERN_[A-Z]+\b)/) {
3918			WARN("PRINTK_WITHOUT_KERN_LEVEL",
3919			     "printk() should include KERN_<LEVEL> facility level\n" . $herecurr);
3920		}
3921
3922		if ($line =~ /\bprintk\s*\(\s*KERN_([A-Z]+)/) {
3923			my $orig = $1;
3924			my $level = lc($orig);
3925			$level = "warn" if ($level eq "warning");
3926			my $level2 = $level;
3927			$level2 = "dbg" if ($level eq "debug");
3928			WARN("PREFER_PR_LEVEL",
3929			     "Prefer [subsystem eg: netdev]_$level2([subsystem]dev, ... then dev_$level2(dev, ... then pr_$level(...  to printk(KERN_$orig ...\n" . $herecurr);
3930		}
3931
3932		if ($line =~ /\bpr_warning\s*\(/) {
3933			if (WARN("PREFER_PR_LEVEL",
3934				 "Prefer pr_warn(... to pr_warning(...\n" . $herecurr) &&
3935			    $fix) {
3936				$fixed[$fixlinenr] =~
3937				    s/\bpr_warning\b/pr_warn/;
3938			}
3939		}
3940
3941		if ($line =~ /\bdev_printk\s*\(\s*KERN_([A-Z]+)/) {
3942			my $orig = $1;
3943			my $level = lc($orig);
3944			$level = "warn" if ($level eq "warning");
3945			$level = "dbg" if ($level eq "debug");
3946			WARN("PREFER_DEV_LEVEL",
3947			     "Prefer dev_$level(... to dev_printk(KERN_$orig, ...\n" . $herecurr);
3948		}
3949
3950# ENOSYS means "bad syscall nr" and nothing else.  This will have a small
3951# number of false positives, but assembly files are not checked, so at
3952# least the arch entry code will not trigger this warning.
3953		if ($line =~ /\bENOSYS\b/) {
3954			WARN("ENOSYS",
3955			     "ENOSYS means 'invalid syscall nr' and nothing else\n" . $herecurr);
3956		}
3957
3958# function brace can't be on same line, except for #defines of do while,
3959# or if closed on same line
3960		if ($^V && $^V ge 5.10.0 &&
3961		    $sline =~ /$Type\s*$Ident\s*$balanced_parens\s*\{/ &&
3962		    $sline !~ /\#\s*define\b.*do\s*\{/ &&
3963		    $sline !~ /}/) {
3964			if (ERROR("OPEN_BRACE",
3965				  "open brace '{' following function definitions go on the next line\n" . $herecurr) &&
3966			    $fix) {
3967				fix_delete_line($fixlinenr, $rawline);
3968				my $fixed_line = $rawline;
3969				$fixed_line =~ /(^..*$Type\s*$Ident\(.*\)\s*){(.*)$/;
3970				my $line1 = $1;
3971				my $line2 = $2;
3972				fix_insert_line($fixlinenr, ltrim($line1));
3973				fix_insert_line($fixlinenr, "\+{");
3974				if ($line2 !~ /^\s*$/) {
3975					fix_insert_line($fixlinenr, "\+\t" . trim($line2));
3976				}
3977			}
3978		}
3979
3980# open braces for enum, union and struct go on the same line.
3981		if ($line =~ /^.\s*{/ &&
3982		    $prevline =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident)?\s*$/) {
3983			if (ERROR("OPEN_BRACE",
3984				  "open brace '{' following $1 go on the same line\n" . $hereprev) &&
3985			    $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
3986				fix_delete_line($fixlinenr - 1, $prevrawline);
3987				fix_delete_line($fixlinenr, $rawline);
3988				my $fixedline = rtrim($prevrawline) . " {";
3989				fix_insert_line($fixlinenr, $fixedline);
3990				$fixedline = $rawline;
3991				$fixedline =~ s/^(.\s*)\{\s*/$1\t/;
3992				if ($fixedline !~ /^\+\s*$/) {
3993					fix_insert_line($fixlinenr, $fixedline);
3994				}
3995			}
3996		}
3997
3998# missing space after union, struct or enum definition
3999		if ($line =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident){1,2}[=\{]/) {
4000			if (WARN("SPACING",
4001				 "missing space after $1 definition\n" . $herecurr) &&
4002			    $fix) {
4003				$fixed[$fixlinenr] =~
4004				    s/^(.\s*(?:typedef\s+)?(?:enum|union|struct)(?:\s+$Ident){1,2})([=\{])/$1 $2/;
4005			}
4006		}
4007
4008# Function pointer declarations
4009# check spacing between type, funcptr, and args
4010# canonical declaration is "type (*funcptr)(args...)"
4011		if ($line =~ /^.\s*($Declare)\((\s*)\*(\s*)($Ident)(\s*)\)(\s*)\(/) {
4012			my $declare = $1;
4013			my $pre_pointer_space = $2;
4014			my $post_pointer_space = $3;
4015			my $funcname = $4;
4016			my $post_funcname_space = $5;
4017			my $pre_args_space = $6;
4018
4019# the $Declare variable will capture all spaces after the type
4020# so check it for a missing trailing missing space but pointer return types
4021# don't need a space so don't warn for those.
4022			my $post_declare_space = "";
4023			if ($declare =~ /(\s+)$/) {
4024				$post_declare_space = $1;
4025				$declare = rtrim($declare);
4026			}
4027			if ($declare !~ /\*$/ && $post_declare_space =~ /^$/) {
4028				WARN("SPACING",
4029				     "missing space after return type\n" . $herecurr);
4030				$post_declare_space = " ";
4031			}
4032
4033# unnecessary space "type  (*funcptr)(args...)"
4034# This test is not currently implemented because these declarations are
4035# equivalent to
4036#	int  foo(int bar, ...)
4037# and this is form shouldn't/doesn't generate a checkpatch warning.
4038#
4039#			elsif ($declare =~ /\s{2,}$/) {
4040#				WARN("SPACING",
4041#				     "Multiple spaces after return type\n" . $herecurr);
4042#			}
4043
4044# unnecessary space "type ( *funcptr)(args...)"
4045			if (defined $pre_pointer_space &&
4046			    $pre_pointer_space =~ /^\s/) {
4047				WARN("SPACING",
4048				     "Unnecessary space after function pointer open parenthesis\n" . $herecurr);
4049			}
4050
4051# unnecessary space "type (* funcptr)(args...)"
4052			if (defined $post_pointer_space &&
4053			    $post_pointer_space =~ /^\s/) {
4054				WARN("SPACING",
4055				     "Unnecessary space before function pointer name\n" . $herecurr);
4056			}
4057
4058# unnecessary space "type (*funcptr )(args...)"
4059			if (defined $post_funcname_space &&
4060			    $post_funcname_space =~ /^\s/) {
4061				WARN("SPACING",
4062				     "Unnecessary space after function pointer name\n" . $herecurr);
4063			}
4064
4065# unnecessary space "type (*funcptr) (args...)"
4066			if (defined $pre_args_space &&
4067			    $pre_args_space =~ /^\s/) {
4068				WARN("SPACING",
4069				     "Unnecessary space before function pointer arguments\n" . $herecurr);
4070			}
4071
4072			if (show_type("SPACING") && $fix) {
4073				$fixed[$fixlinenr] =~
4074				    s/^(.\s*)$Declare\s*\(\s*\*\s*$Ident\s*\)\s*\(/$1 . $declare . $post_declare_space . '(*' . $funcname . ')('/ex;
4075			}
4076		}
4077
4078# check for spacing round square brackets; allowed:
4079#  1. with a type on the left -- int [] a;
4080#  2. at the beginning of a line for slice initialisers -- [0...10] = 5,
4081#  3. inside a curly brace -- = { [0...10] = 5 }
4082		while ($line =~ /(.*?\s)\[/g) {
4083			my ($where, $prefix) = ($-[1], $1);
4084			if ($prefix !~ /$Type\s+$/ &&
4085			    ($where != 0 || $prefix !~ /^.\s+$/) &&
4086			    $prefix !~ /[{,]\s+$/) {
4087				if (ERROR("BRACKET_SPACE",
4088					  "space prohibited before open square bracket '['\n" . $herecurr) &&
4089				    $fix) {
4090				    $fixed[$fixlinenr] =~
4091					s/^(\+.*?)\s+\[/$1\[/;
4092				}
4093			}
4094		}
4095
4096# check for spaces between functions and their parentheses.
4097		while ($line =~ /($Ident)\s+\(/g) {
4098			my $name = $1;
4099			my $ctx_before = substr($line, 0, $-[1]);
4100			my $ctx = "$ctx_before$name";
4101
4102			# Ignore those directives where spaces _are_ permitted.
4103			if ($name =~ /^(?:
4104				if|for|while|switch|return|case|
4105				volatile|__volatile__|
4106				__attribute__|format|__extension__|
4107				asm|__asm__)$/x)
4108			{
4109			# cpp #define statements have non-optional spaces, ie
4110			# if there is a space between the name and the open
4111			# parenthesis it is simply not a parameter group.
4112			} elsif ($ctx_before =~ /^.\s*\#\s*define\s*$/) {
4113
4114			# cpp #elif statement condition may start with a (
4115			} elsif ($ctx =~ /^.\s*\#\s*elif\s*$/) {
4116
4117			# If this whole things ends with a type its most
4118			# likely a typedef for a function.
4119			} elsif ($ctx =~ /$Type$/) {
4120
4121			} else {
4122				if (WARN("SPACING",
4123					 "space prohibited between function name and open parenthesis '('\n" . $herecurr) &&
4124					     $fix) {
4125					$fixed[$fixlinenr] =~
4126					    s/\b$name\s+\(/$name\(/;
4127				}
4128			}
4129		}
4130
4131# Check operator spacing.
4132		if (!($line=~/\#\s*include/)) {
4133			my $fixed_line = "";
4134			my $line_fixed = 0;
4135
4136			my $ops = qr{
4137				<<=|>>=|<=|>=|==|!=|
4138				\+=|-=|\*=|\/=|%=|\^=|\|=|&=|
4139				=>|->|<<|>>|<|>|=|!|~|
4140				&&|\|\||,|\^|\+\+|--|&|\||\+|-|\*|\/|%|
4141				\?:|\?|:
4142			}x;
4143			my @elements = split(/($ops|;)/, $opline);
4144
4145##			print("element count: <" . $#elements . ">\n");
4146##			foreach my $el (@elements) {
4147##				print("el: <$el>\n");
4148##			}
4149
4150			my @fix_elements = ();
4151			my $off = 0;
4152
4153			foreach my $el (@elements) {
4154				push(@fix_elements, substr($rawline, $off, length($el)));
4155				$off += length($el);
4156			}
4157
4158			$off = 0;
4159
4160			my $blank = copy_spacing($opline);
4161			my $last_after = -1;
4162
4163			for (my $n = 0; $n < $#elements; $n += 2) {
4164
4165				my $good = $fix_elements[$n] . $fix_elements[$n + 1];
4166
4167##				print("n: <$n> good: <$good>\n");
4168
4169				$off += length($elements[$n]);
4170
4171				# Pick up the preceding and succeeding characters.
4172				my $ca = substr($opline, 0, $off);
4173				my $cc = '';
4174				if (length($opline) >= ($off + length($elements[$n + 1]))) {
4175					$cc = substr($opline, $off + length($elements[$n + 1]));
4176				}
4177				my $cb = "$ca$;$cc";
4178
4179				my $a = '';
4180				$a = 'V' if ($elements[$n] ne '');
4181				$a = 'W' if ($elements[$n] =~ /\s$/);
4182				$a = 'C' if ($elements[$n] =~ /$;$/);
4183				$a = 'B' if ($elements[$n] =~ /(\[|\()$/);
4184				$a = 'O' if ($elements[$n] eq '');
4185				$a = 'E' if ($ca =~ /^\s*$/);
4186
4187				my $op = $elements[$n + 1];
4188
4189				my $c = '';
4190				if (defined $elements[$n + 2]) {
4191					$c = 'V' if ($elements[$n + 2] ne '');
4192					$c = 'W' if ($elements[$n + 2] =~ /^\s/);
4193					$c = 'C' if ($elements[$n + 2] =~ /^$;/);
4194					$c = 'B' if ($elements[$n + 2] =~ /^(\)|\]|;)/);
4195					$c = 'O' if ($elements[$n + 2] eq '');
4196					$c = 'E' if ($elements[$n + 2] =~ /^\s*\\$/);
4197				} else {
4198					$c = 'E';
4199				}
4200
4201				my $ctx = "${a}x${c}";
4202
4203				my $at = "(ctx:$ctx)";
4204
4205				my $ptr = substr($blank, 0, $off) . "^";
4206				my $hereptr = "$hereline$ptr\n";
4207
4208				# Pull out the value of this operator.
4209				my $op_type = substr($curr_values, $off + 1, 1);
4210
4211				# Get the full operator variant.
4212				my $opv = $op . substr($curr_vars, $off, 1);
4213
4214				# Ignore operators passed as parameters.
4215				if ($op_type ne 'V' &&
4216				    $ca =~ /\s$/ && $cc =~ /^\s*[,\)]/) {
4217
4218#				# Ignore comments
4219#				} elsif ($op =~ /^$;+$/) {
4220
4221				# ; should have either the end of line or a space or \ after it
4222				} elsif ($op eq ';') {
4223					if ($ctx !~ /.x[WEBC]/ &&
4224					    $cc !~ /^\\/ && $cc !~ /^;/) {
4225						if (ERROR("SPACING",
4226							  "space required after that '$op' $at\n" . $hereptr)) {
4227							$good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";
4228							$line_fixed = 1;
4229						}
4230					}
4231
4232				# // is a comment
4233				} elsif ($op eq '//') {
4234
4235				#   :   when part of a bitfield
4236				} elsif ($opv eq ':B') {
4237					# skip the bitfield test for now
4238
4239				# No spaces for:
4240				#   ->
4241				} elsif ($op eq '->') {
4242					if ($ctx =~ /Wx.|.xW/) {
4243						if (ERROR("SPACING",
4244							  "spaces prohibited around that '$op' $at\n" . $hereptr)) {
4245							$good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
4246							if (defined $fix_elements[$n + 2]) {
4247								$fix_elements[$n + 2] =~ s/^\s+//;
4248							}
4249							$line_fixed = 1;
4250						}
4251					}
4252
4253				# , must not have a space before and must have a space on the right.
4254				} elsif ($op eq ',') {
4255					my $rtrim_before = 0;
4256					my $space_after = 0;
4257					if ($ctx =~ /Wx./) {
4258						if (ERROR("SPACING",
4259							  "space prohibited before that '$op' $at\n" . $hereptr)) {
4260							$line_fixed = 1;
4261							$rtrim_before = 1;
4262						}
4263					}
4264					if ($ctx !~ /.x[WEC]/ && $cc !~ /^}/) {
4265						if (ERROR("SPACING",
4266							  "space required after that '$op' $at\n" . $hereptr)) {
4267							$line_fixed = 1;
4268							$last_after = $n;
4269							$space_after = 1;
4270						}
4271					}
4272					if ($rtrim_before || $space_after) {
4273						if ($rtrim_before) {
4274							$good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
4275						} else {
4276							$good = $fix_elements[$n] . trim($fix_elements[$n + 1]);
4277						}
4278						if ($space_after) {
4279							$good .= " ";
4280						}
4281					}
4282
4283				# '*' as part of a type definition -- reported already.
4284				} elsif ($opv eq '*_') {
4285					#warn "'*' is part of type\n";
4286
4287				# unary operators should have a space before and
4288				# none after.  May be left adjacent to another
4289				# unary operator, or a cast
4290				} elsif ($op eq '!' || $op eq '~' ||
4291					 $opv eq '*U' || $opv eq '-U' ||
4292					 $opv eq '&U' || $opv eq '&&U') {
4293					if ($ctx !~ /[WEBC]x./ && $ca !~ /(?:\)|!|~|\*|-|\&|\||\+\+|\-\-|\{)$/) {
4294						if (ERROR("SPACING",
4295							  "space required before that '$op' $at\n" . $hereptr)) {
4296							if ($n != $last_after + 2) {
4297								$good = $fix_elements[$n] . " " . ltrim($fix_elements[$n + 1]);
4298								$line_fixed = 1;
4299							}
4300						}
4301					}
4302					if ($op eq '*' && $cc =~/\s*$Modifier\b/) {
4303						# A unary '*' may be const
4304
4305					} elsif ($ctx =~ /.xW/) {
4306						if (ERROR("SPACING",
4307							  "space prohibited after that '$op' $at\n" . $hereptr)) {
4308							$good = $fix_elements[$n] . rtrim($fix_elements[$n + 1]);
4309							if (defined $fix_elements[$n + 2]) {
4310								$fix_elements[$n + 2] =~ s/^\s+//;
4311							}
4312							$line_fixed = 1;
4313						}
4314					}
4315
4316				# unary ++ and unary -- are allowed no space on one side.
4317				} elsif ($op eq '++' or $op eq '--') {
4318					if ($ctx !~ /[WEOBC]x[^W]/ && $ctx !~ /[^W]x[WOBEC]/) {
4319						if (ERROR("SPACING",
4320							  "space required one side of that '$op' $at\n" . $hereptr)) {
4321							$good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";
4322							$line_fixed = 1;
4323						}
4324					}
4325					if ($ctx =~ /Wx[BE]/ ||
4326					    ($ctx =~ /Wx./ && $cc =~ /^;/)) {
4327						if (ERROR("SPACING",
4328							  "space prohibited before that '$op' $at\n" . $hereptr)) {
4329							$good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
4330							$line_fixed = 1;
4331						}
4332					}
4333					if ($ctx =~ /ExW/) {
4334						if (ERROR("SPACING",
4335							  "space prohibited after that '$op' $at\n" . $hereptr)) {
4336							$good = $fix_elements[$n] . trim($fix_elements[$n + 1]);
4337							if (defined $fix_elements[$n + 2]) {
4338								$fix_elements[$n + 2] =~ s/^\s+//;
4339							}
4340							$line_fixed = 1;
4341						}
4342					}
4343
4344				# << and >> may either have or not have spaces both sides
4345				} elsif ($op eq '<<' or $op eq '>>' or
4346					 $op eq '&' or $op eq '^' or $op eq '|' or
4347					 $op eq '+' or $op eq '-' or
4348					 $op eq '*' or $op eq '/' or
4349					 $op eq '%')
4350				{
4351					if ($check) {
4352						if (defined $fix_elements[$n + 2] && $ctx !~ /[EW]x[EW]/) {
4353							if (CHK("SPACING",
4354								"spaces preferred around that '$op' $at\n" . $hereptr)) {
4355								$good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
4356								$fix_elements[$n + 2] =~ s/^\s+//;
4357								$line_fixed = 1;
4358							}
4359						} elsif (!defined $fix_elements[$n + 2] && $ctx !~ /Wx[OE]/) {
4360							if (CHK("SPACING",
4361								"space preferred before that '$op' $at\n" . $hereptr)) {
4362								$good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]);
4363								$line_fixed = 1;
4364							}
4365						}
4366					} elsif ($ctx =~ /Wx[^WCE]|[^WCE]xW/) {
4367						if (ERROR("SPACING",
4368							  "need consistent spacing around '$op' $at\n" . $hereptr)) {
4369							$good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
4370							if (defined $fix_elements[$n + 2]) {
4371								$fix_elements[$n + 2] =~ s/^\s+//;
4372							}
4373							$line_fixed = 1;
4374						}
4375					}
4376
4377				# A colon needs no spaces before when it is
4378				# terminating a case value or a label.
4379				} elsif ($opv eq ':C' || $opv eq ':L') {
4380					if ($ctx =~ /Wx./) {
4381						if (ERROR("SPACING",
4382							  "space prohibited before that '$op' $at\n" . $hereptr)) {
4383							$good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
4384							$line_fixed = 1;
4385						}
4386					}
4387
4388				# All the others need spaces both sides.
4389				} elsif ($ctx !~ /[EWC]x[CWE]/) {
4390					my $ok = 0;
4391
4392					# Ignore email addresses <foo@bar>
4393					if (($op eq '<' &&
4394					     $cc =~ /^\S+\@\S+>/) ||
4395					    ($op eq '>' &&
4396					     $ca =~ /<\S+\@\S+$/))
4397					{
4398					    	$ok = 1;
4399					}
4400
4401					# for asm volatile statements
4402					# ignore a colon with another
4403					# colon immediately before or after
4404					if (($op eq ':') &&
4405					    ($ca =~ /:$/ || $cc =~ /^:/)) {
4406						$ok = 1;
4407					}
4408
4409					# messages are ERROR, but ?: are CHK
4410					if ($ok == 0) {
4411						my $msg_level = \&ERROR;
4412						$msg_level = \&CHK if (($op eq '?:' || $op eq '?' || $op eq ':') && $ctx =~ /VxV/);
4413
4414						if (&{$msg_level}("SPACING",
4415								  "spaces required around that '$op' $at\n" . $hereptr)) {
4416							$good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
4417							if (defined $fix_elements[$n + 2]) {
4418								$fix_elements[$n + 2] =~ s/^\s+//;
4419							}
4420							$line_fixed = 1;
4421						}
4422					}
4423				}
4424				$off += length($elements[$n + 1]);
4425
4426##				print("n: <$n> GOOD: <$good>\n");
4427
4428				$fixed_line = $fixed_line . $good;
4429			}
4430
4431			if (($#elements % 2) == 0) {
4432				$fixed_line = $fixed_line . $fix_elements[$#elements];
4433			}
4434
4435			if ($fix && $line_fixed && $fixed_line ne $fixed[$fixlinenr]) {
4436				$fixed[$fixlinenr] = $fixed_line;
4437			}
4438
4439
4440		}
4441
4442# check for whitespace before a non-naked semicolon
4443		if ($line =~ /^\+.*\S\s+;\s*$/) {
4444			if (WARN("SPACING",
4445				 "space prohibited before semicolon\n" . $herecurr) &&
4446			    $fix) {
4447				1 while $fixed[$fixlinenr] =~
4448				    s/^(\+.*\S)\s+;/$1;/;
4449			}
4450		}
4451
4452# check for multiple assignments
4453		if ($line =~ /^.\s*$Lval\s*=\s*$Lval\s*=(?!=)/) {
4454			CHK("MULTIPLE_ASSIGNMENTS",
4455			    "multiple assignments should be avoided\n" . $herecurr);
4456		}
4457
4458## # check for multiple declarations, allowing for a function declaration
4459## # continuation.
4460## 		if ($line =~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Ident.*/ &&
4461## 		    $line !~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Type\s*$Ident.*/) {
4462##
4463## 			# Remove any bracketed sections to ensure we do not
4464## 			# falsly report the parameters of functions.
4465## 			my $ln = $line;
4466## 			while ($ln =~ s/\([^\(\)]*\)//g) {
4467## 			}
4468## 			if ($ln =~ /,/) {
4469## 				WARN("MULTIPLE_DECLARATION",
4470##				     "declaring multiple variables together should be avoided\n" . $herecurr);
4471## 			}
4472## 		}
4473
4474#need space before brace following if, while, etc
4475		if (($line =~ /\(.*\)\{/ && $line !~ /\($Type\)\{/) ||
4476		    $line =~ /do\{/) {
4477			if (ERROR("SPACING",
4478				  "space required before the open brace '{'\n" . $herecurr) &&
4479			    $fix) {
4480				$fixed[$fixlinenr] =~ s/^(\+.*(?:do|\)))\{/$1 {/;
4481			}
4482		}
4483
4484## # check for blank lines before declarations
4485##		if ($line =~ /^.\t+$Type\s+$Ident(?:\s*=.*)?;/ &&
4486##		    $prevrawline =~ /^.\s*$/) {
4487##			WARN("SPACING",
4488##			     "No blank lines before declarations\n" . $hereprev);
4489##		}
4490##
4491
4492# closing brace should have a space following it when it has anything
4493# on the line
4494		if ($line =~ /}(?!(?:,|;|\)))\S/) {
4495			if (ERROR("SPACING",
4496				  "space required after that close brace '}'\n" . $herecurr) &&
4497			    $fix) {
4498				$fixed[$fixlinenr] =~
4499				    s/}((?!(?:,|;|\)))\S)/} $1/;
4500			}
4501		}
4502
4503# check spacing on square brackets
4504		if ($line =~ /\[\s/ && $line !~ /\[\s*$/) {
4505			if (ERROR("SPACING",
4506				  "space prohibited after that open square bracket '['\n" . $herecurr) &&
4507			    $fix) {
4508				$fixed[$fixlinenr] =~
4509				    s/\[\s+/\[/;
4510			}
4511		}
4512		if ($line =~ /\s\]/) {
4513			if (ERROR("SPACING",
4514				  "space prohibited before that close square bracket ']'\n" . $herecurr) &&
4515			    $fix) {
4516				$fixed[$fixlinenr] =~
4517				    s/\s+\]/\]/;
4518			}
4519		}
4520
4521# check spacing on parentheses
4522		if ($line =~ /\(\s/ && $line !~ /\(\s*(?:\\)?$/ &&
4523		    $line !~ /for\s*\(\s+;/) {
4524			if (ERROR("SPACING",
4525				  "space prohibited after that open parenthesis '('\n" . $herecurr) &&
4526			    $fix) {
4527				$fixed[$fixlinenr] =~
4528				    s/\(\s+/\(/;
4529			}
4530		}
4531		if ($line =~ /(\s+)\)/ && $line !~ /^.\s*\)/ &&
4532		    $line !~ /for\s*\(.*;\s+\)/ &&
4533		    $line !~ /:\s+\)/) {
4534			if (ERROR("SPACING",
4535				  "space prohibited before that close parenthesis ')'\n" . $herecurr) &&
4536			    $fix) {
4537				$fixed[$fixlinenr] =~
4538				    s/\s+\)/\)/;
4539			}
4540		}
4541
4542# check unnecessary parentheses around addressof/dereference single $Lvals
4543# ie: &(foo->bar) should be &foo->bar and *(foo->bar) should be *foo->bar
4544
4545		while ($line =~ /(?:[^&]&\s*|\*)\(\s*($Ident\s*(?:$Member\s*)+)\s*\)/g) {
4546			my $var = $1;
4547			if (CHK("UNNECESSARY_PARENTHESES",
4548				"Unnecessary parentheses around $var\n" . $herecurr) &&
4549			    $fix) {
4550				$fixed[$fixlinenr] =~ s/\(\s*\Q$var\E\s*\)/$var/;
4551			}
4552		}
4553
4554# check for unnecessary parentheses around function pointer uses
4555# ie: (foo->bar)(); should be foo->bar();
4556# but not "if (foo->bar) (" to avoid some false positives
4557		if ($line =~ /(\bif\s*|)(\(\s*$Ident\s*(?:$Member\s*)+\))[ \t]*\(/ && $1 !~ /^if/) {
4558			my $var = $2;
4559			if (CHK("UNNECESSARY_PARENTHESES",
4560				"Unnecessary parentheses around function pointer $var\n" . $herecurr) &&
4561			    $fix) {
4562				my $var2 = deparenthesize($var);
4563				$var2 =~ s/\s//g;
4564				$fixed[$fixlinenr] =~ s/\Q$var\E/$var2/;
4565			}
4566		}
4567
4568# check for unnecessary parentheses around comparisons in if uses
4569# when !drivers/staging or command-line uses --strict
4570		if (($realfile !~ m@^(?:drivers/staging/)@ || $check_orig) &&
4571		    $^V && $^V ge 5.10.0 && defined($stat) &&
4572		    $stat =~ /(^.\s*if\s*($balanced_parens))/) {
4573			my $if_stat = $1;
4574			my $test = substr($2, 1, -1);
4575			my $herectx;
4576			while ($test =~ /(?:^|[^\w\&\!\~])+\s*\(\s*([\&\!\~]?\s*$Lval\s*(?:$Compare\s*$FuncArg)?)\s*\)/g) {
4577				my $match = $1;
4578				# avoid parentheses around potential macro args
4579				next if ($match =~ /^\s*\w+\s*$/);
4580				if (!defined($herectx)) {
4581					$herectx = $here . "\n";
4582					my $cnt = statement_rawlines($if_stat);
4583					for (my $n = 0; $n < $cnt; $n++) {
4584						my $rl = raw_line($linenr, $n);
4585						$herectx .=  $rl . "\n";
4586						last if $rl =~ /^[ \+].*\{/;
4587					}
4588				}
4589				CHK("UNNECESSARY_PARENTHESES",
4590				    "Unnecessary parentheses around '$match'\n" . $herectx);
4591			}
4592		}
4593
4594#goto labels aren't indented, allow a single space however
4595		if ($line=~/^.\s+[A-Za-z\d_]+:(?![0-9]+)/ and
4596		   !($line=~/^. [A-Za-z\d_]+:/) and !($line=~/^.\s+default:/)) {
4597			if (WARN("INDENTED_LABEL",
4598				 "labels should not be indented\n" . $herecurr) &&
4599			    $fix) {
4600				$fixed[$fixlinenr] =~
4601				    s/^(.)\s+/$1/;
4602			}
4603		}
4604
4605# return is not a function
4606		if (defined($stat) && $stat =~ /^.\s*return(\s*)\(/s) {
4607			my $spacing = $1;
4608			if ($^V && $^V ge 5.10.0 &&
4609			    $stat =~ /^.\s*return\s*($balanced_parens)\s*;\s*$/) {
4610				my $value = $1;
4611				$value = deparenthesize($value);
4612				if ($value =~ m/^\s*$FuncArg\s*(?:\?|$)/) {
4613					ERROR("RETURN_PARENTHESES",
4614					      "return is not a function, parentheses are not required\n" . $herecurr);
4615				}
4616			} elsif ($spacing !~ /\s+/) {
4617				ERROR("SPACING",
4618				      "space required before the open parenthesis '('\n" . $herecurr);
4619			}
4620		}
4621
4622# unnecessary return in a void function
4623# at end-of-function, with the previous line a single leading tab, then return;
4624# and the line before that not a goto label target like "out:"
4625		if ($sline =~ /^[ \+]}\s*$/ &&
4626		    $prevline =~ /^\+\treturn\s*;\s*$/ &&
4627		    $linenr >= 3 &&
4628		    $lines[$linenr - 3] =~ /^[ +]/ &&
4629		    $lines[$linenr - 3] !~ /^[ +]\s*$Ident\s*:/) {
4630			WARN("RETURN_VOID",
4631			     "void function return statements are not generally useful\n" . $hereprev);
4632               }
4633
4634# if statements using unnecessary parentheses - ie: if ((foo == bar))
4635		if ($^V && $^V ge 5.10.0 &&
4636		    $line =~ /\bif\s*((?:\(\s*){2,})/) {
4637			my $openparens = $1;
4638			my $count = $openparens =~ tr@\(@\(@;
4639			my $msg = "";
4640			if ($line =~ /\bif\s*(?:\(\s*){$count,$count}$LvalOrFunc\s*($Compare)\s*$LvalOrFunc(?:\s*\)){$count,$count}/) {
4641				my $comp = $4;	#Not $1 because of $LvalOrFunc
4642				$msg = " - maybe == should be = ?" if ($comp eq "==");
4643				WARN("UNNECESSARY_PARENTHESES",
4644				     "Unnecessary parentheses$msg\n" . $herecurr);
4645			}
4646		}
4647
4648# comparisons with a constant or upper case identifier on the left
4649#	avoid cases like "foo + BAR < baz"
4650#	only fix matches surrounded by parentheses to avoid incorrect
4651#	conversions like "FOO < baz() + 5" being "misfixed" to "baz() > FOO + 5"
4652		if ($^V && $^V ge 5.10.0 &&
4653		    $line =~ /^\+(.*)\b($Constant|[A-Z_][A-Z0-9_]*)\s*($Compare)\s*($LvalOrFunc)/) {
4654			my $lead = $1;
4655			my $const = $2;
4656			my $comp = $3;
4657			my $to = $4;
4658			my $newcomp = $comp;
4659			if ($lead !~ /(?:$Operators|\.)\s*$/ &&
4660			    $to !~ /^(?:Constant|[A-Z_][A-Z0-9_]*)$/ &&
4661			    WARN("CONSTANT_COMPARISON",
4662				 "Comparisons should place the constant on the right side of the test\n" . $herecurr) &&
4663			    $fix) {
4664				if ($comp eq "<") {
4665					$newcomp = ">";
4666				} elsif ($comp eq "<=") {
4667					$newcomp = ">=";
4668				} elsif ($comp eq ">") {
4669					$newcomp = "<";
4670				} elsif ($comp eq ">=") {
4671					$newcomp = "<=";
4672				}
4673				$fixed[$fixlinenr] =~ s/\(\s*\Q$const\E\s*$Compare\s*\Q$to\E\s*\)/($to $newcomp $const)/;
4674			}
4675		}
4676
4677# Return of what appears to be an errno should normally be negative
4678		if ($sline =~ /\breturn(?:\s*\(+\s*|\s+)(E[A-Z]+)(?:\s*\)+\s*|\s*)[;:,]/) {
4679			my $name = $1;
4680			if ($name ne 'EOF' && $name ne 'ERROR') {
4681				WARN("USE_NEGATIVE_ERRNO",
4682				     "return of an errno should typically be negative (ie: return -$1)\n" . $herecurr);
4683			}
4684		}
4685
4686# Need a space before open parenthesis after if, while etc
4687		if ($line =~ /\b(if|while|for|switch)\(/) {
4688			if (ERROR("SPACING",
4689				  "space required before the open parenthesis '('\n" . $herecurr) &&
4690			    $fix) {
4691				$fixed[$fixlinenr] =~
4692				    s/\b(if|while|for|switch)\(/$1 \(/;
4693			}
4694		}
4695
4696# Check for illegal assignment in if conditional -- and check for trailing
4697# statements after the conditional.
4698		if ($line =~ /do\s*(?!{)/) {
4699			($stat, $cond, $line_nr_next, $remain_next, $off_next) =
4700				ctx_statement_block($linenr, $realcnt, 0)
4701					if (!defined $stat);
4702			my ($stat_next) = ctx_statement_block($line_nr_next,
4703						$remain_next, $off_next);
4704			$stat_next =~ s/\n./\n /g;
4705			##print "stat<$stat> stat_next<$stat_next>\n";
4706
4707			if ($stat_next =~ /^\s*while\b/) {
4708				# If the statement carries leading newlines,
4709				# then count those as offsets.
4710				my ($whitespace) =
4711					($stat_next =~ /^((?:\s*\n[+-])*\s*)/s);
4712				my $offset =
4713					statement_rawlines($whitespace) - 1;
4714
4715				$suppress_whiletrailers{$line_nr_next +
4716								$offset} = 1;
4717			}
4718		}
4719		if (!defined $suppress_whiletrailers{$linenr} &&
4720		    defined($stat) && defined($cond) &&
4721		    $line =~ /\b(?:if|while|for)\s*\(/ && $line !~ /^.\s*#/) {
4722			my ($s, $c) = ($stat, $cond);
4723
4724			if ($c =~ /\bif\s*\(.*[^<>!=]=[^=].*/s) {
4725				ERROR("ASSIGN_IN_IF",
4726				      "do not use assignment in if condition\n" . $herecurr);
4727			}
4728
4729			# Find out what is on the end of the line after the
4730			# conditional.
4731			substr($s, 0, length($c), '');
4732			$s =~ s/\n.*//g;
4733			$s =~ s/$;//g; 	# Remove any comments
4734			if (length($c) && $s !~ /^\s*{?\s*\\*\s*$/ &&
4735			    $c !~ /}\s*while\s*/)
4736			{
4737				# Find out how long the conditional actually is.
4738				my @newlines = ($c =~ /\n/gs);
4739				my $cond_lines = 1 + $#newlines;
4740				my $stat_real = '';
4741
4742				$stat_real = raw_line($linenr, $cond_lines)
4743							. "\n" if ($cond_lines);
4744				if (defined($stat_real) && $cond_lines > 1) {
4745					$stat_real = "[...]\n$stat_real";
4746				}
4747
4748				ERROR("TRAILING_STATEMENTS",
4749				      "trailing statements should be on next line\n" . $herecurr . $stat_real);
4750			}
4751		}
4752
4753# Check for bitwise tests written as boolean
4754		if ($line =~ /
4755			(?:
4756				(?:\[|\(|\&\&|\|\|)
4757				\s*0[xX][0-9]+\s*
4758				(?:\&\&|\|\|)
4759			|
4760				(?:\&\&|\|\|)
4761				\s*0[xX][0-9]+\s*
4762				(?:\&\&|\|\||\)|\])
4763			)/x)
4764		{
4765			WARN("HEXADECIMAL_BOOLEAN_TEST",
4766			     "boolean test with hexadecimal, perhaps just 1 \& or \|?\n" . $herecurr);
4767		}
4768
4769# if and else should not have general statements after it
4770		if ($line =~ /^.\s*(?:}\s*)?else\b(.*)/) {
4771			my $s = $1;
4772			$s =~ s/$;//g; 	# Remove any comments
4773			if ($s !~ /^\s*(?:\sif|(?:{|)\s*\\?\s*$)/) {
4774				ERROR("TRAILING_STATEMENTS",
4775				      "trailing statements should be on next line\n" . $herecurr);
4776			}
4777		}
4778# if should not continue a brace
4779		if ($line =~ /}\s*if\b/) {
4780			ERROR("TRAILING_STATEMENTS",
4781			      "trailing statements should be on next line (or did you mean 'else if'?)\n" .
4782				$herecurr);
4783		}
4784# case and default should not have general statements after them
4785		if ($line =~ /^.\s*(?:case\s*.*|default\s*):/g &&
4786		    $line !~ /\G(?:
4787			(?:\s*$;*)(?:\s*{)?(?:\s*$;*)(?:\s*\\)?\s*$|
4788			\s*return\s+
4789		    )/xg)
4790		{
4791			ERROR("TRAILING_STATEMENTS",
4792			      "trailing statements should be on next line\n" . $herecurr);
4793		}
4794
4795		# Check for }<nl>else {, these must be at the same
4796		# indent level to be relevant to each other.
4797		if ($prevline=~/}\s*$/ and $line=~/^.\s*else\s*/ &&
4798		    $previndent == $indent) {
4799			if (ERROR("ELSE_AFTER_BRACE",
4800				  "else should follow close brace '}'\n" . $hereprev) &&
4801			    $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
4802				fix_delete_line($fixlinenr - 1, $prevrawline);
4803				fix_delete_line($fixlinenr, $rawline);
4804				my $fixedline = $prevrawline;
4805				$fixedline =~ s/}\s*$//;
4806				if ($fixedline !~ /^\+\s*$/) {
4807					fix_insert_line($fixlinenr, $fixedline);
4808				}
4809				$fixedline = $rawline;
4810				$fixedline =~ s/^(.\s*)else/$1} else/;
4811				fix_insert_line($fixlinenr, $fixedline);
4812			}
4813		}
4814
4815		if ($prevline=~/}\s*$/ and $line=~/^.\s*while\s*/ &&
4816		    $previndent == $indent) {
4817			my ($s, $c) = ctx_statement_block($linenr, $realcnt, 0);
4818
4819			# Find out what is on the end of the line after the
4820			# conditional.
4821			substr($s, 0, length($c), '');
4822			$s =~ s/\n.*//g;
4823
4824			if ($s =~ /^\s*;/) {
4825				if (ERROR("WHILE_AFTER_BRACE",
4826					  "while should follow close brace '}'\n" . $hereprev) &&
4827				    $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
4828					fix_delete_line($fixlinenr - 1, $prevrawline);
4829					fix_delete_line($fixlinenr, $rawline);
4830					my $fixedline = $prevrawline;
4831					my $trailing = $rawline;
4832					$trailing =~ s/^\+//;
4833					$trailing = trim($trailing);
4834					$fixedline =~ s/}\s*$/} $trailing/;
4835					fix_insert_line($fixlinenr, $fixedline);
4836				}
4837			}
4838		}
4839
4840#Specific variable tests
4841		while ($line =~ m{($Constant|$Lval)}g) {
4842			my $var = $1;
4843
4844#gcc binary extension
4845			if ($var =~ /^$Binary$/) {
4846				if (WARN("GCC_BINARY_CONSTANT",
4847					 "Avoid gcc v4.3+ binary constant extension: <$var>\n" . $herecurr) &&
4848				    $fix) {
4849					my $hexval = sprintf("0x%x", oct($var));
4850					$fixed[$fixlinenr] =~
4851					    s/\b$var\b/$hexval/;
4852				}
4853			}
4854
4855#CamelCase
4856			if ($var !~ /^$Constant$/ &&
4857			    $var =~ /[A-Z][a-z]|[a-z][A-Z]/ &&
4858#Ignore Page<foo> variants
4859			    $var !~ /^(?:Clear|Set|TestClear|TestSet|)Page[A-Z]/ &&
4860#Ignore SI style variants like nS, mV and dB (ie: max_uV, regulator_min_uA_show)
4861			    $var !~ /^(?:[a-z_]*?)_?[a-z][A-Z](?:_[a-z_]+)?$/ &&
4862#Ignore some three character SI units explicitly, like MiB and KHz
4863			    $var !~ /^(?:[a-z_]*?)_?(?:[KMGT]iB|[KMGT]?Hz)(?:_[a-z_]+)?$/) {
4864				while ($var =~ m{($Ident)}g) {
4865					my $word = $1;
4866					next if ($word !~ /[A-Z][a-z]|[a-z][A-Z]/);
4867					if ($check) {
4868						seed_camelcase_includes();
4869						if (!$file && !$camelcase_file_seeded) {
4870							seed_camelcase_file($realfile);
4871							$camelcase_file_seeded = 1;
4872						}
4873					}
4874					if (!defined $camelcase{$word}) {
4875						$camelcase{$word} = 1;
4876						CHK("CAMELCASE",
4877						    "Avoid CamelCase: <$word>\n" . $herecurr);
4878					}
4879				}
4880			}
4881		}
4882
4883#no spaces allowed after \ in define
4884		if ($line =~ /\#\s*define.*\\\s+$/) {
4885			if (WARN("WHITESPACE_AFTER_LINE_CONTINUATION",
4886				 "Whitespace after \\ makes next lines useless\n" . $herecurr) &&
4887			    $fix) {
4888				$fixed[$fixlinenr] =~ s/\s+$//;
4889			}
4890		}
4891
4892# warn if <asm/foo.h> is #included and <linux/foo.h> is available and includes
4893# itself <asm/foo.h> (uses RAW line)
4894		if ($tree && $rawline =~ m{^.\s*\#\s*include\s*\<asm\/(.*)\.h\>}) {
4895			my $file = "$1.h";
4896			my $checkfile = "include/linux/$file";
4897			if (-f "$root/$checkfile" &&
4898			    $realfile ne $checkfile &&
4899			    $1 !~ /$allowed_asm_includes/)
4900			{
4901				my $asminclude = `grep -Ec "#include\\s+<asm/$file>" $root/$checkfile`;
4902				if ($asminclude > 0) {
4903					if ($realfile =~ m{^arch/}) {
4904						CHK("ARCH_INCLUDE_LINUX",
4905						    "Consider using #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
4906					} else {
4907						WARN("INCLUDE_LINUX",
4908						     "Use #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
4909					}
4910				}
4911			}
4912		}
4913
4914# multi-statement macros should be enclosed in a do while loop, grab the
4915# first statement and ensure its the whole macro if its not enclosed
4916# in a known good container
4917		if ($realfile !~ m@/vmlinux.lds.h$@ &&
4918		    $line =~ /^.\s*\#\s*define\s*$Ident(\()?/) {
4919			my $ln = $linenr;
4920			my $cnt = $realcnt;
4921			my ($off, $dstat, $dcond, $rest);
4922			my $ctx = '';
4923			my $has_flow_statement = 0;
4924			my $has_arg_concat = 0;
4925			($dstat, $dcond, $ln, $cnt, $off) =
4926				ctx_statement_block($linenr, $realcnt, 0);
4927			$ctx = $dstat;
4928			#print "dstat<$dstat> dcond<$dcond> cnt<$cnt> off<$off>\n";
4929			#print "LINE<$lines[$ln-1]> len<" . length($lines[$ln-1]) . "\n";
4930
4931			$has_flow_statement = 1 if ($ctx =~ /\b(goto|return)\b/);
4932			$has_arg_concat = 1 if ($ctx =~ /\#\#/ && $ctx !~ /\#\#\s*(?:__VA_ARGS__|args)\b/);
4933
4934			$dstat =~ s/^.\s*\#\s*define\s+$Ident(\([^\)]*\))?\s*//;
4935			my $define_args = $1;
4936			my $define_stmt = $dstat;
4937			my @def_args = ();
4938
4939			if (defined $define_args && $define_args ne "") {
4940				$define_args = substr($define_args, 1, length($define_args) - 2);
4941				$define_args =~ s/\s*//g;
4942				@def_args = split(",", $define_args);
4943			}
4944
4945			$dstat =~ s/$;//g;
4946			$dstat =~ s/\\\n.//g;
4947			$dstat =~ s/^\s*//s;
4948			$dstat =~ s/\s*$//s;
4949
4950			# Flatten any parentheses and braces
4951			while ($dstat =~ s/\([^\(\)]*\)/1/ ||
4952			       $dstat =~ s/\{[^\{\}]*\}/1/ ||
4953			       $dstat =~ s/.\[[^\[\]]*\]/1/)
4954			{
4955			}
4956
4957			# Flatten any obvious string concatentation.
4958			while ($dstat =~ s/($String)\s*$Ident/$1/ ||
4959			       $dstat =~ s/$Ident\s*($String)/$1/)
4960			{
4961			}
4962
4963			# Make asm volatile uses seem like a generic function
4964			$dstat =~ s/\b_*asm_*\s+_*volatile_*\b/asm_volatile/g;
4965
4966			my $exceptions = qr{
4967				$Declare|
4968				module_param_named|
4969				MODULE_PARM_DESC|
4970				DECLARE_PER_CPU|
4971				DEFINE_PER_CPU|
4972				__typeof__\(|
4973				union|
4974				struct|
4975				\.$Ident\s*=\s*|
4976				^\"|\"$|
4977				^\[
4978			}x;
4979			#print "REST<$rest> dstat<$dstat> ctx<$ctx>\n";
4980
4981			$ctx =~ s/\n*$//;
4982			my $stmt_cnt = statement_rawlines($ctx);
4983			my $herectx = get_stat_here($linenr, $stmt_cnt, $here);
4984
4985			if ($dstat ne '' &&
4986			    $dstat !~ /^(?:$Ident|-?$Constant),$/ &&			# 10, // foo(),
4987			    $dstat !~ /^(?:$Ident|-?$Constant);$/ &&			# foo();
4988			    $dstat !~ /^[!~-]?(?:$Lval|$Constant)$/ &&		# 10 // foo() // !foo // ~foo // -foo // foo->bar // foo.bar->baz
4989			    $dstat !~ /^'X'$/ && $dstat !~ /^'XX'$/ &&			# character constants
4990			    $dstat !~ /$exceptions/ &&
4991			    $dstat !~ /^\.$Ident\s*=/ &&				# .foo =
4992			    $dstat !~ /^(?:\#\s*$Ident|\#\s*$Constant)\s*$/ &&		# stringification #foo
4993			    $dstat !~ /^do\s*$Constant\s*while\s*$Constant;?$/ &&	# do {...} while (...); // do {...} while (...)
4994			    $dstat !~ /^for\s*$Constant$/ &&				# for (...)
4995			    $dstat !~ /^for\s*$Constant\s+(?:$Ident|-?$Constant)$/ &&	# for (...) bar()
4996			    $dstat !~ /^do\s*{/ &&					# do {...
4997			    $dstat !~ /^\(\{/ &&						# ({...
4998			    $ctx !~ /^.\s*#\s*define\s+TRACE_(?:SYSTEM|INCLUDE_FILE|INCLUDE_PATH)\b/)
4999			{
5000				if ($dstat =~ /^\s*if\b/) {
5001					ERROR("MULTISTATEMENT_MACRO_USE_DO_WHILE",
5002					      "Macros starting with if should be enclosed by a do - while loop to avoid possible if/else logic defects\n" . "$herectx");
5003				} elsif ($dstat =~ /;/) {
5004					ERROR("MULTISTATEMENT_MACRO_USE_DO_WHILE",
5005					      "Macros with multiple statements should be enclosed in a do - while loop\n" . "$herectx");
5006				} else {
5007					ERROR("COMPLEX_MACRO",
5008					      "Macros with complex values should be enclosed in parentheses\n" . "$herectx");
5009				}
5010
5011			}
5012
5013			# Make $define_stmt single line, comment-free, etc
5014			my @stmt_array = split('\n', $define_stmt);
5015			my $first = 1;
5016			$define_stmt = "";
5017			foreach my $l (@stmt_array) {
5018				$l =~ s/\\$//;
5019				if ($first) {
5020					$define_stmt = $l;
5021					$first = 0;
5022				} elsif ($l =~ /^[\+ ]/) {
5023					$define_stmt .= substr($l, 1);
5024				}
5025			}
5026			$define_stmt =~ s/$;//g;
5027			$define_stmt =~ s/\s+/ /g;
5028			$define_stmt = trim($define_stmt);
5029
5030# check if any macro arguments are reused (ignore '...' and 'type')
5031			foreach my $arg (@def_args) {
5032			        next if ($arg =~ /\.\.\./);
5033			        next if ($arg =~ /^type$/i);
5034				my $tmp_stmt = $define_stmt;
5035				$tmp_stmt =~ s/\b(typeof|__typeof__|__builtin\w+|typecheck\s*\(\s*$Type\s*,|\#+)\s*\(*\s*$arg\s*\)*\b//g;
5036				$tmp_stmt =~ s/\#+\s*$arg\b//g;
5037				$tmp_stmt =~ s/\b$arg\s*\#\#//g;
5038				my $use_cnt = $tmp_stmt =~ s/\b$arg\b//g;
5039				if ($use_cnt > 1) {
5040					CHK("MACRO_ARG_REUSE",
5041					    "Macro argument reuse '$arg' - possible side-effects?\n" . "$herectx");
5042				    }
5043# check if any macro arguments may have other precedence issues
5044				if ($tmp_stmt =~ m/($Operators)?\s*\b$arg\b\s*($Operators)?/m &&
5045				    ((defined($1) && $1 ne ',') ||
5046				     (defined($2) && $2 ne ','))) {
5047					CHK("MACRO_ARG_PRECEDENCE",
5048					    "Macro argument '$arg' may be better as '($arg)' to avoid precedence issues\n" . "$herectx");
5049				}
5050			}
5051
5052# check for macros with flow control, but without ## concatenation
5053# ## concatenation is commonly a macro that defines a function so ignore those
5054			if ($has_flow_statement && !$has_arg_concat) {
5055				my $cnt = statement_rawlines($ctx);
5056				my $herectx = get_stat_here($linenr, $cnt, $here);
5057
5058				WARN("MACRO_WITH_FLOW_CONTROL",
5059				     "Macros with flow control statements should be avoided\n" . "$herectx");
5060			}
5061
5062# check for line continuations outside of #defines, preprocessor #, and asm
5063
5064		} else {
5065			if ($prevline !~ /^..*\\$/ &&
5066			    $line !~ /^\+\s*\#.*\\$/ &&		# preprocessor
5067			    $line !~ /^\+.*\b(__asm__|asm)\b.*\\$/ &&	# asm
5068			    $line =~ /^\+.*\\$/) {
5069				WARN("LINE_CONTINUATIONS",
5070				     "Avoid unnecessary line continuations\n" . $herecurr);
5071			}
5072		}
5073
5074# do {} while (0) macro tests:
5075# single-statement macros do not need to be enclosed in do while (0) loop,
5076# macro should not end with a semicolon
5077		if ($^V && $^V ge 5.10.0 &&
5078		    $realfile !~ m@/vmlinux.lds.h$@ &&
5079		    $line =~ /^.\s*\#\s*define\s+$Ident(\()?/) {
5080			my $ln = $linenr;
5081			my $cnt = $realcnt;
5082			my ($off, $dstat, $dcond, $rest);
5083			my $ctx = '';
5084			($dstat, $dcond, $ln, $cnt, $off) =
5085				ctx_statement_block($linenr, $realcnt, 0);
5086			$ctx = $dstat;
5087
5088			$dstat =~ s/\\\n.//g;
5089			$dstat =~ s/$;/ /g;
5090
5091			if ($dstat =~ /^\+\s*#\s*define\s+$Ident\s*${balanced_parens}\s*do\s*{(.*)\s*}\s*while\s*\(\s*0\s*\)\s*([;\s]*)\s*$/) {
5092				my $stmts = $2;
5093				my $semis = $3;
5094
5095				$ctx =~ s/\n*$//;
5096				my $cnt = statement_rawlines($ctx);
5097				my $herectx = get_stat_here($linenr, $cnt, $here);
5098
5099				if (($stmts =~ tr/;/;/) == 1 &&
5100				    $stmts !~ /^\s*(if|while|for|switch)\b/) {
5101					WARN("SINGLE_STATEMENT_DO_WHILE_MACRO",
5102					     "Single statement macros should not use a do {} while (0) loop\n" . "$herectx");
5103				}
5104				if (defined $semis && $semis ne "") {
5105					WARN("DO_WHILE_MACRO_WITH_TRAILING_SEMICOLON",
5106					     "do {} while (0) macros should not be semicolon terminated\n" . "$herectx");
5107				}
5108			} elsif ($dstat =~ /^\+\s*#\s*define\s+$Ident.*;\s*$/) {
5109				$ctx =~ s/\n*$//;
5110				my $cnt = statement_rawlines($ctx);
5111				my $herectx = get_stat_here($linenr, $cnt, $here);
5112
5113				WARN("TRAILING_SEMICOLON",
5114				     "macros should not use a trailing semicolon\n" . "$herectx");
5115			}
5116		}
5117
5118# make sure symbols are always wrapped with VMLINUX_SYMBOL() ...
5119# all assignments may have only one of the following with an assignment:
5120#	.
5121#	ALIGN(...)
5122#	VMLINUX_SYMBOL(...)
5123		if ($realfile eq 'vmlinux.lds.h' && $line =~ /(?:(?:^|\s)$Ident\s*=|=\s*$Ident(?:\s|$))/) {
5124			WARN("MISSING_VMLINUX_SYMBOL",
5125			     "vmlinux.lds.h needs VMLINUX_SYMBOL() around C-visible symbols\n" . $herecurr);
5126		}
5127
5128# check for redundant bracing round if etc
5129		if ($line =~ /(^.*)\bif\b/ && $1 !~ /else\s*$/) {
5130			my ($level, $endln, @chunks) =
5131				ctx_statement_full($linenr, $realcnt, 1);
5132			#print "chunks<$#chunks> linenr<$linenr> endln<$endln> level<$level>\n";
5133			#print "APW: <<$chunks[1][0]>><<$chunks[1][1]>>\n";
5134			if ($#chunks > 0 && $level == 0) {
5135				my @allowed = ();
5136				my $allow = 0;
5137				my $seen = 0;
5138				my $herectx = $here . "\n";
5139				my $ln = $linenr - 1;
5140				for my $chunk (@chunks) {
5141					my ($cond, $block) = @{$chunk};
5142
5143					# If the condition carries leading newlines, then count those as offsets.
5144					my ($whitespace) = ($cond =~ /^((?:\s*\n[+-])*\s*)/s);
5145					my $offset = statement_rawlines($whitespace) - 1;
5146
5147					$allowed[$allow] = 0;
5148					#print "COND<$cond> whitespace<$whitespace> offset<$offset>\n";
5149
5150					# We have looked at and allowed this specific line.
5151					$suppress_ifbraces{$ln + $offset} = 1;
5152
5153					$herectx .= "$rawlines[$ln + $offset]\n[...]\n";
5154					$ln += statement_rawlines($block) - 1;
5155
5156					substr($block, 0, length($cond), '');
5157
5158					$seen++ if ($block =~ /^\s*{/);
5159
5160					#print "cond<$cond> block<$block> allowed<$allowed[$allow]>\n";
5161					if (statement_lines($cond) > 1) {
5162						#print "APW: ALLOWED: cond<$cond>\n";
5163						$allowed[$allow] = 1;
5164					}
5165					if ($block =~/\b(?:if|for|while)\b/) {
5166						#print "APW: ALLOWED: block<$block>\n";
5167						$allowed[$allow] = 1;
5168					}
5169					if (statement_block_size($block) > 1) {
5170						#print "APW: ALLOWED: lines block<$block>\n";
5171						$allowed[$allow] = 1;
5172					}
5173					$allow++;
5174				}
5175				if ($seen) {
5176					my $sum_allowed = 0;
5177					foreach (@allowed) {
5178						$sum_allowed += $_;
5179					}
5180					if ($sum_allowed == 0) {
5181						WARN("BRACES",
5182						     "braces {} are not necessary for any arm of this statement\n" . $herectx);
5183					} elsif ($sum_allowed != $allow &&
5184						 $seen != $allow) {
5185						CHK("BRACES",
5186						    "braces {} should be used on all arms of this statement\n" . $herectx);
5187					}
5188				}
5189			}
5190		}
5191		if (!defined $suppress_ifbraces{$linenr - 1} &&
5192					$line =~ /\b(if|while|for|else)\b/) {
5193			my $allowed = 0;
5194
5195			# Check the pre-context.
5196			if (substr($line, 0, $-[0]) =~ /(\}\s*)$/) {
5197				#print "APW: ALLOWED: pre<$1>\n";
5198				$allowed = 1;
5199			}
5200
5201			my ($level, $endln, @chunks) =
5202				ctx_statement_full($linenr, $realcnt, $-[0]);
5203
5204			# Check the condition.
5205			my ($cond, $block) = @{$chunks[0]};
5206			#print "CHECKING<$linenr> cond<$cond> block<$block>\n";
5207			if (defined $cond) {
5208				substr($block, 0, length($cond), '');
5209			}
5210			if (statement_lines($cond) > 1) {
5211				#print "APW: ALLOWED: cond<$cond>\n";
5212				$allowed = 1;
5213			}
5214			if ($block =~/\b(?:if|for|while)\b/) {
5215				#print "APW: ALLOWED: block<$block>\n";
5216				$allowed = 1;
5217			}
5218			if (statement_block_size($block) > 1) {
5219				#print "APW: ALLOWED: lines block<$block>\n";
5220				$allowed = 1;
5221			}
5222			# Check the post-context.
5223			if (defined $chunks[1]) {
5224				my ($cond, $block) = @{$chunks[1]};
5225				if (defined $cond) {
5226					substr($block, 0, length($cond), '');
5227				}
5228				if ($block =~ /^\s*\{/) {
5229					#print "APW: ALLOWED: chunk-1 block<$block>\n";
5230					$allowed = 1;
5231				}
5232			}
5233			if ($level == 0 && $block =~ /^\s*\{/ && !$allowed) {
5234				my $cnt = statement_rawlines($block);
5235				my $herectx = get_stat_here($linenr, $cnt, $here);
5236
5237				WARN("BRACES",
5238				     "braces {} are not necessary for single statement blocks\n" . $herectx);
5239			}
5240		}
5241
5242# check for single line unbalanced braces
5243		if ($sline =~ /^.\s*\}\s*else\s*$/ ||
5244		    $sline =~ /^.\s*else\s*\{\s*$/) {
5245			CHK("BRACES", "Unbalanced braces around else statement\n" . $herecurr);
5246		}
5247
5248# check for unnecessary blank lines around braces
5249		if (($line =~ /^.\s*}\s*$/ && $prevrawline =~ /^.\s*$/)) {
5250			if (CHK("BRACES",
5251				"Blank lines aren't necessary before a close brace '}'\n" . $hereprev) &&
5252			    $fix && $prevrawline =~ /^\+/) {
5253				fix_delete_line($fixlinenr - 1, $prevrawline);
5254			}
5255		}
5256		if (($rawline =~ /^.\s*$/ && $prevline =~ /^..*{\s*$/)) {
5257			if (CHK("BRACES",
5258				"Blank lines aren't necessary after an open brace '{'\n" . $hereprev) &&
5259			    $fix) {
5260				fix_delete_line($fixlinenr, $rawline);
5261			}
5262		}
5263
5264# no volatiles please
5265		my $asm_volatile = qr{\b(__asm__|asm)\s+(__volatile__|volatile)\b};
5266		if ($line =~ /\bvolatile\b/ && $line !~ /$asm_volatile/) {
5267			WARN("VOLATILE",
5268			     "Use of volatile is usually wrong: see Documentation/process/volatile-considered-harmful.rst\n" . $herecurr);
5269		}
5270
5271# Check for user-visible strings broken across lines, which breaks the ability
5272# to grep for the string.  Make exceptions when the previous string ends in a
5273# newline (multiple lines in one string constant) or '\t', '\r', ';', or '{'
5274# (common in inline assembly) or is a octal \123 or hexadecimal \xaf value
5275		if ($line =~ /^\+\s*$String/ &&
5276		    $prevline =~ /"\s*$/ &&
5277		    $prevrawline !~ /(?:\\(?:[ntr]|[0-7]{1,3}|x[0-9a-fA-F]{1,2})|;\s*|\{\s*)"\s*$/) {
5278			if (WARN("SPLIT_STRING",
5279				 "quoted string split across lines\n" . $hereprev) &&
5280				     $fix &&
5281				     $prevrawline =~ /^\+.*"\s*$/ &&
5282				     $last_coalesced_string_linenr != $linenr - 1) {
5283				my $extracted_string = get_quoted_string($line, $rawline);
5284				my $comma_close = "";
5285				if ($rawline =~ /\Q$extracted_string\E(\s*\)\s*;\s*$|\s*,\s*)/) {
5286					$comma_close = $1;
5287				}
5288
5289				fix_delete_line($fixlinenr - 1, $prevrawline);
5290				fix_delete_line($fixlinenr, $rawline);
5291				my $fixedline = $prevrawline;
5292				$fixedline =~ s/"\s*$//;
5293				$fixedline .= substr($extracted_string, 1) . trim($comma_close);
5294				fix_insert_line($fixlinenr - 1, $fixedline);
5295				$fixedline = $rawline;
5296				$fixedline =~ s/\Q$extracted_string\E\Q$comma_close\E//;
5297				if ($fixedline !~ /\+\s*$/) {
5298					fix_insert_line($fixlinenr, $fixedline);
5299				}
5300				$last_coalesced_string_linenr = $linenr;
5301			}
5302		}
5303
5304# check for missing a space in a string concatenation
5305		if ($prevrawline =~ /[^\\]\w"$/ && $rawline =~ /^\+[\t ]+"\w/) {
5306			WARN('MISSING_SPACE',
5307			     "break quoted strings at a space character\n" . $hereprev);
5308		}
5309
5310# check for an embedded function name in a string when the function is known
5311# This does not work very well for -f --file checking as it depends on patch
5312# context providing the function name or a single line form for in-file
5313# function declarations
5314		if ($line =~ /^\+.*$String/ &&
5315		    defined($context_function) &&
5316		    get_quoted_string($line, $rawline) =~ /\b$context_function\b/ &&
5317		    length(get_quoted_string($line, $rawline)) != (length($context_function) + 2)) {
5318			WARN("EMBEDDED_FUNCTION_NAME",
5319			     "Prefer using '\"%s...\", __func__' to using '$context_function', this function's name, in a string\n" . $herecurr);
5320		}
5321
5322# check for spaces before a quoted newline
5323		if ($rawline =~ /^.*\".*\s\\n/) {
5324			if (WARN("QUOTED_WHITESPACE_BEFORE_NEWLINE",
5325				 "unnecessary whitespace before a quoted newline\n" . $herecurr) &&
5326			    $fix) {
5327				$fixed[$fixlinenr] =~ s/^(\+.*\".*)\s+\\n/$1\\n/;
5328			}
5329
5330		}
5331
5332# concatenated string without spaces between elements
5333		if ($line =~ /$String[A-Z_]/ || $line =~ /[A-Za-z0-9_]$String/) {
5334			CHK("CONCATENATED_STRING",
5335			    "Concatenated strings should use spaces between elements\n" . $herecurr);
5336		}
5337
5338# uncoalesced string fragments
5339		if ($line =~ /$String\s*"/) {
5340			WARN("STRING_FRAGMENTS",
5341			     "Consecutive strings are generally better as a single string\n" . $herecurr);
5342		}
5343
5344# check for non-standard and hex prefixed decimal printf formats
5345		my $show_L = 1;	#don't show the same defect twice
5346		my $show_Z = 1;
5347		while ($line =~ /(?:^|")([X\t]*)(?:"|$)/g) {
5348			my $string = substr($rawline, $-[1], $+[1] - $-[1]);
5349			$string =~ s/%%/__/g;
5350			# check for %L
5351			if ($show_L && $string =~ /%[\*\d\.\$]*L([diouxX])/) {
5352				WARN("PRINTF_L",
5353				     "\%L$1 is non-standard C, use %ll$1\n" . $herecurr);
5354				$show_L = 0;
5355			}
5356			# check for %Z
5357			if ($show_Z && $string =~ /%[\*\d\.\$]*Z([diouxX])/) {
5358				WARN("PRINTF_Z",
5359				     "%Z$1 is non-standard C, use %z$1\n" . $herecurr);
5360				$show_Z = 0;
5361			}
5362			# check for 0x<decimal>
5363			if ($string =~ /0x%[\*\d\.\$\Llzth]*[diou]/) {
5364				ERROR("PRINTF_0XDECIMAL",
5365				      "Prefixing 0x with decimal output is defective\n" . $herecurr);
5366			}
5367		}
5368
5369# check for line continuations in quoted strings with odd counts of "
5370		if ($rawline =~ /\\$/ && $sline =~ tr/"/"/ % 2) {
5371			WARN("LINE_CONTINUATIONS",
5372			     "Avoid line continuations in quoted strings\n" . $herecurr);
5373		}
5374
5375# warn about #if 0
5376		if ($line =~ /^.\s*\#\s*if\s+0\b/) {
5377			CHK("REDUNDANT_CODE",
5378			    "if this code is redundant consider removing it\n" .
5379				$herecurr);
5380		}
5381
5382# check for needless "if (<foo>) fn(<foo>)" uses
5383		if ($prevline =~ /\bif\s*\(\s*($Lval)\s*\)/) {
5384			my $tested = quotemeta($1);
5385			my $expr = '\s*\(\s*' . $tested . '\s*\)\s*;';
5386			if ($line =~ /\b(kfree|usb_free_urb|debugfs_remove(?:_recursive)?|(?:kmem_cache|mempool|dma_pool)_destroy)$expr/) {
5387				my $func = $1;
5388				if (WARN('NEEDLESS_IF',
5389					 "$func(NULL) is safe and this check is probably not required\n" . $hereprev) &&
5390				    $fix) {
5391					my $do_fix = 1;
5392					my $leading_tabs = "";
5393					my $new_leading_tabs = "";
5394					if ($lines[$linenr - 2] =~ /^\+(\t*)if\s*\(\s*$tested\s*\)\s*$/) {
5395						$leading_tabs = $1;
5396					} else {
5397						$do_fix = 0;
5398					}
5399					if ($lines[$linenr - 1] =~ /^\+(\t+)$func\s*\(\s*$tested\s*\)\s*;\s*$/) {
5400						$new_leading_tabs = $1;
5401						if (length($leading_tabs) + 1 ne length($new_leading_tabs)) {
5402							$do_fix = 0;
5403						}
5404					} else {
5405						$do_fix = 0;
5406					}
5407					if ($do_fix) {
5408						fix_delete_line($fixlinenr - 1, $prevrawline);
5409						$fixed[$fixlinenr] =~ s/^\+$new_leading_tabs/\+$leading_tabs/;
5410					}
5411				}
5412			}
5413		}
5414
5415# check for unnecessary "Out of Memory" messages
5416		if ($line =~ /^\+.*\b$logFunctions\s*\(/ &&
5417		    $prevline =~ /^[ \+]\s*if\s*\(\s*(\!\s*|NULL\s*==\s*)?($Lval)(\s*==\s*NULL\s*)?\s*\)/ &&
5418		    (defined $1 || defined $3) &&
5419		    $linenr > 3) {
5420			my $testval = $2;
5421			my $testline = $lines[$linenr - 3];
5422
5423			my ($s, $c) = ctx_statement_block($linenr - 3, $realcnt, 0);
5424#			print("line: <$line>\nprevline: <$prevline>\ns: <$s>\nc: <$c>\n\n\n");
5425
5426			if ($s =~ /(?:^|\n)[ \+]\s*(?:$Type\s*)?\Q$testval\E\s*=\s*(?:\([^\)]*\)\s*)?\s*(?:devm_)?(?:[kv][czm]alloc(?:_node|_array)?\b|kstrdup|kmemdup|(?:dev_)?alloc_skb)/) {
5427				WARN("OOM_MESSAGE",
5428				     "Possible unnecessary 'out of memory' message\n" . $hereprev);
5429			}
5430		}
5431
5432# check for logging functions with KERN_<LEVEL>
5433		if ($line !~ /printk(?:_ratelimited|_once)?\s*\(/ &&
5434		    $line =~ /\b$logFunctions\s*\(.*\b(KERN_[A-Z]+)\b/) {
5435			my $level = $1;
5436			if (WARN("UNNECESSARY_KERN_LEVEL",
5437				 "Possible unnecessary $level\n" . $herecurr) &&
5438			    $fix) {
5439				$fixed[$fixlinenr] =~ s/\s*$level\s*//;
5440			}
5441		}
5442
5443# check for logging continuations
5444		if ($line =~ /\bprintk\s*\(\s*KERN_CONT\b|\bpr_cont\s*\(/) {
5445			WARN("LOGGING_CONTINUATION",
5446			     "Avoid logging continuation uses where feasible\n" . $herecurr);
5447		}
5448
5449# check for mask then right shift without a parentheses
5450		if ($^V && $^V ge 5.10.0 &&
5451		    $line =~ /$LvalOrFunc\s*\&\s*($LvalOrFunc)\s*>>/ &&
5452		    $4 !~ /^\&/) { # $LvalOrFunc may be &foo, ignore if so
5453			WARN("MASK_THEN_SHIFT",
5454			     "Possible precedence defect with mask then right shift - may need parentheses\n" . $herecurr);
5455		}
5456
5457# check for pointer comparisons to NULL
5458		if ($^V && $^V ge 5.10.0) {
5459			while ($line =~ /\b$LvalOrFunc\s*(==|\!=)\s*NULL\b/g) {
5460				my $val = $1;
5461				my $equal = "!";
5462				$equal = "" if ($4 eq "!=");
5463				if (CHK("COMPARISON_TO_NULL",
5464					"Comparison to NULL could be written \"${equal}${val}\"\n" . $herecurr) &&
5465					    $fix) {
5466					$fixed[$fixlinenr] =~ s/\b\Q$val\E\s*(?:==|\!=)\s*NULL\b/$equal$val/;
5467				}
5468			}
5469		}
5470
5471# check for bad placement of section $InitAttribute (e.g.: __initdata)
5472		if ($line =~ /(\b$InitAttribute\b)/) {
5473			my $attr = $1;
5474			if ($line =~ /^\+\s*static\s+(?:const\s+)?(?:$attr\s+)?($NonptrTypeWithAttr)\s+(?:$attr\s+)?($Ident(?:\[[^]]*\])?)\s*[=;]/) {
5475				my $ptr = $1;
5476				my $var = $2;
5477				if ((($ptr =~ /\b(union|struct)\s+$attr\b/ &&
5478				      ERROR("MISPLACED_INIT",
5479					    "$attr should be placed after $var\n" . $herecurr)) ||
5480				     ($ptr !~ /\b(union|struct)\s+$attr\b/ &&
5481				      WARN("MISPLACED_INIT",
5482					   "$attr should be placed after $var\n" . $herecurr))) &&
5483				    $fix) {
5484					$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;
5485				}
5486			}
5487		}
5488
5489# check for $InitAttributeData (ie: __initdata) with const
5490		if ($line =~ /\bconst\b/ && $line =~ /($InitAttributeData)/) {
5491			my $attr = $1;
5492			$attr =~ /($InitAttributePrefix)(.*)/;
5493			my $attr_prefix = $1;
5494			my $attr_type = $2;
5495			if (ERROR("INIT_ATTRIBUTE",
5496				  "Use of const init definition must use ${attr_prefix}initconst\n" . $herecurr) &&
5497			    $fix) {
5498				$fixed[$fixlinenr] =~
5499				    s/$InitAttributeData/${attr_prefix}initconst/;
5500			}
5501		}
5502
5503# check for $InitAttributeConst (ie: __initconst) without const
5504		if ($line !~ /\bconst\b/ && $line =~ /($InitAttributeConst)/) {
5505			my $attr = $1;
5506			if (ERROR("INIT_ATTRIBUTE",
5507				  "Use of $attr requires a separate use of const\n" . $herecurr) &&
5508			    $fix) {
5509				my $lead = $fixed[$fixlinenr] =~
5510				    /(^\+\s*(?:static\s+))/;
5511				$lead = rtrim($1);
5512				$lead = "$lead " if ($lead !~ /^\+$/);
5513				$lead = "${lead}const ";
5514				$fixed[$fixlinenr] =~ s/(^\+\s*(?:static\s+))/$lead/;
5515			}
5516		}
5517
5518# check for __read_mostly with const non-pointer (should just be const)
5519		if ($line =~ /\b__read_mostly\b/ &&
5520		    $line =~ /($Type)\s*$Ident/ && $1 !~ /\*\s*$/ && $1 =~ /\bconst\b/) {
5521			if (ERROR("CONST_READ_MOSTLY",
5522				  "Invalid use of __read_mostly with const type\n" . $herecurr) &&
5523			    $fix) {
5524				$fixed[$fixlinenr] =~ s/\s+__read_mostly\b//;
5525			}
5526		}
5527
5528# don't use __constant_<foo> functions outside of include/uapi/
5529		if ($realfile !~ m@^include/uapi/@ &&
5530		    $line =~ /(__constant_(?:htons|ntohs|[bl]e(?:16|32|64)_to_cpu|cpu_to_[bl]e(?:16|32|64)))\s*\(/) {
5531			my $constant_func = $1;
5532			my $func = $constant_func;
5533			$func =~ s/^__constant_//;
5534			if (WARN("CONSTANT_CONVERSION",
5535				 "$constant_func should be $func\n" . $herecurr) &&
5536			    $fix) {
5537				$fixed[$fixlinenr] =~ s/\b$constant_func\b/$func/g;
5538			}
5539		}
5540
5541# prefer usleep_range over udelay
5542		if ($line =~ /\budelay\s*\(\s*(\d+)\s*\)/) {
5543			my $delay = $1;
5544			# ignore udelay's < 10, however
5545			if (! ($delay < 10) ) {
5546				CHK("USLEEP_RANGE",
5547				    "usleep_range is preferred over udelay; see Documentation/timers/timers-howto.txt\n" . $herecurr);
5548			}
5549			if ($delay > 2000) {
5550				WARN("LONG_UDELAY",
5551				     "long udelay - prefer mdelay; see arch/arm/include/asm/delay.h\n" . $herecurr);
5552			}
5553		}
5554
5555# warn about unexpectedly long msleep's
5556		if ($line =~ /\bmsleep\s*\((\d+)\);/) {
5557			if ($1 < 20) {
5558				WARN("MSLEEP",
5559				     "msleep < 20ms can sleep for up to 20ms; see Documentation/timers/timers-howto.txt\n" . $herecurr);
5560			}
5561		}
5562
5563# check for comparisons of jiffies
5564		if ($line =~ /\bjiffies\s*$Compare|$Compare\s*jiffies\b/) {
5565			WARN("JIFFIES_COMPARISON",
5566			     "Comparing jiffies is almost always wrong; prefer time_after, time_before and friends\n" . $herecurr);
5567		}
5568
5569# check for comparisons of get_jiffies_64()
5570		if ($line =~ /\bget_jiffies_64\s*\(\s*\)\s*$Compare|$Compare\s*get_jiffies_64\s*\(\s*\)/) {
5571			WARN("JIFFIES_COMPARISON",
5572			     "Comparing get_jiffies_64() is almost always wrong; prefer time_after64, time_before64 and friends\n" . $herecurr);
5573		}
5574
5575# warn about #ifdefs in C files
5576#		if ($line =~ /^.\s*\#\s*if(|n)def/ && ($realfile =~ /\.c$/)) {
5577#			print "#ifdef in C files should be avoided\n";
5578#			print "$herecurr";
5579#			$clean = 0;
5580#		}
5581
5582# warn about spacing in #ifdefs
5583		if ($line =~ /^.\s*\#\s*(ifdef|ifndef|elif)\s\s+/) {
5584			if (ERROR("SPACING",
5585				  "exactly one space required after that #$1\n" . $herecurr) &&
5586			    $fix) {
5587				$fixed[$fixlinenr] =~
5588				    s/^(.\s*\#\s*(ifdef|ifndef|elif))\s{2,}/$1 /;
5589			}
5590
5591		}
5592
5593# check for spinlock_t definitions without a comment.
5594		if ($line =~ /^.\s*(struct\s+mutex|spinlock_t)\s+\S+;/ ||
5595		    $line =~ /^.\s*(DEFINE_MUTEX)\s*\(/) {
5596			my $which = $1;
5597			if (!ctx_has_comment($first_line, $linenr)) {
5598				CHK("UNCOMMENTED_DEFINITION",
5599				    "$1 definition without comment\n" . $herecurr);
5600			}
5601		}
5602# check for memory barriers without a comment.
5603
5604		my $barriers = qr{
5605			mb|
5606			rmb|
5607			wmb|
5608			read_barrier_depends
5609		}x;
5610		my $barrier_stems = qr{
5611			mb__before_atomic|
5612			mb__after_atomic|
5613			store_release|
5614			load_acquire|
5615			store_mb|
5616			(?:$barriers)
5617		}x;
5618		my $all_barriers = qr{
5619			(?:$barriers)|
5620			smp_(?:$barrier_stems)|
5621			virt_(?:$barrier_stems)
5622		}x;
5623
5624		if ($line =~ /\b(?:$all_barriers)\s*\(/) {
5625			if (!ctx_has_comment($first_line, $linenr)) {
5626				WARN("MEMORY_BARRIER",
5627				     "memory barrier without comment\n" . $herecurr);
5628			}
5629		}
5630
5631		my $underscore_smp_barriers = qr{__smp_(?:$barrier_stems)}x;
5632
5633		if ($realfile !~ m@^include/asm-generic/@ &&
5634		    $realfile !~ m@/barrier\.h$@ &&
5635		    $line =~ m/\b(?:$underscore_smp_barriers)\s*\(/ &&
5636		    $line !~ m/^.\s*\#\s*define\s+(?:$underscore_smp_barriers)\s*\(/) {
5637			WARN("MEMORY_BARRIER",
5638			     "__smp memory barriers shouldn't be used outside barrier.h and asm-generic\n" . $herecurr);
5639		}
5640
5641# check for waitqueue_active without a comment.
5642		if ($line =~ /\bwaitqueue_active\s*\(/) {
5643			if (!ctx_has_comment($first_line, $linenr)) {
5644				WARN("WAITQUEUE_ACTIVE",
5645				     "waitqueue_active without comment\n" . $herecurr);
5646			}
5647		}
5648
5649# check for smp_read_barrier_depends and read_barrier_depends
5650		if (!$file && $line =~ /\b(smp_|)read_barrier_depends\s*\(/) {
5651			WARN("READ_BARRIER_DEPENDS",
5652			     "$1read_barrier_depends should only be used in READ_ONCE or DEC Alpha code\n" . $herecurr);
5653		}
5654
5655# check of hardware specific defines
5656		if ($line =~ m@^.\s*\#\s*if.*\b(__i386__|__powerpc64__|__sun__|__s390x__)\b@ && $realfile !~ m@include/asm-@) {
5657			CHK("ARCH_DEFINES",
5658			    "architecture specific defines should be avoided\n" .  $herecurr);
5659		}
5660
5661# check that the storage class is not after a type
5662		if ($line =~ /\b($Type)\s+($Storage)\b/) {
5663			WARN("STORAGE_CLASS",
5664			     "storage class '$2' should be located before type '$1'\n" . $herecurr);
5665		}
5666# Check that the storage class is at the beginning of a declaration
5667		if ($line =~ /\b$Storage\b/ &&
5668		    $line !~ /^.\s*$Storage/ &&
5669		    $line =~ /^.\s*(.+?)\$Storage\s/ &&
5670		    $1 !~ /[\,\)]\s*$/) {
5671			WARN("STORAGE_CLASS",
5672			     "storage class should be at the beginning of the declaration\n" . $herecurr);
5673		}
5674
5675# check the location of the inline attribute, that it is between
5676# storage class and type.
5677		if ($line =~ /\b$Type\s+$Inline\b/ ||
5678		    $line =~ /\b$Inline\s+$Storage\b/) {
5679			ERROR("INLINE_LOCATION",
5680			      "inline keyword should sit between storage class and type\n" . $herecurr);
5681		}
5682
5683# Check for __inline__ and __inline, prefer inline
5684		if ($realfile !~ m@\binclude/uapi/@ &&
5685		    $line =~ /\b(__inline__|__inline)\b/) {
5686			if (WARN("INLINE",
5687				 "plain inline is preferred over $1\n" . $herecurr) &&
5688			    $fix) {
5689				$fixed[$fixlinenr] =~ s/\b(__inline__|__inline)\b/inline/;
5690
5691			}
5692		}
5693
5694# Check for __attribute__ packed, prefer __packed
5695		if ($realfile !~ m@\binclude/uapi/@ &&
5696		    $line =~ /\b__attribute__\s*\(\s*\(.*\bpacked\b/) {
5697			WARN("PREFER_PACKED",
5698			     "__packed is preferred over __attribute__((packed))\n" . $herecurr);
5699		}
5700
5701# Check for new packed members, warn to use care
5702		if ($realfile !~ m@\binclude/uapi/@ &&
5703		    $line =~ /\b(__attribute__\s*\(\s*\(.*\bpacked|__packed)\b/) {
5704			WARN("NEW_PACKED",
5705			     "Adding new packed members is to be done with care\n" . $herecurr);
5706		}
5707
5708# Check for __attribute__ aligned, prefer __aligned
5709		if ($realfile !~ m@\binclude/uapi/@ &&
5710		    $line =~ /\b__attribute__\s*\(\s*\(.*aligned/) {
5711			WARN("PREFER_ALIGNED",
5712			     "__aligned(size) is preferred over __attribute__((aligned(size)))\n" . $herecurr);
5713		}
5714
5715# Check for __attribute__ format(printf, prefer __printf
5716		if ($realfile !~ m@\binclude/uapi/@ &&
5717		    $line =~ /\b__attribute__\s*\(\s*\(\s*format\s*\(\s*printf/) {
5718			if (WARN("PREFER_PRINTF",
5719				 "__printf(string-index, first-to-check) is preferred over __attribute__((format(printf, string-index, first-to-check)))\n" . $herecurr) &&
5720			    $fix) {
5721				$fixed[$fixlinenr] =~ s/\b__attribute__\s*\(\s*\(\s*format\s*\(\s*printf\s*,\s*(.*)\)\s*\)\s*\)/"__printf(" . trim($1) . ")"/ex;
5722
5723			}
5724		}
5725
5726# Check for __attribute__ format(scanf, prefer __scanf
5727		if ($realfile !~ m@\binclude/uapi/@ &&
5728		    $line =~ /\b__attribute__\s*\(\s*\(\s*format\s*\(\s*scanf\b/) {
5729			if (WARN("PREFER_SCANF",
5730				 "__scanf(string-index, first-to-check) is preferred over __attribute__((format(scanf, string-index, first-to-check)))\n" . $herecurr) &&
5731			    $fix) {
5732				$fixed[$fixlinenr] =~ s/\b__attribute__\s*\(\s*\(\s*format\s*\(\s*scanf\s*,\s*(.*)\)\s*\)\s*\)/"__scanf(" . trim($1) . ")"/ex;
5733			}
5734		}
5735
5736# Check for __attribute__ weak, or __weak declarations (may have link issues)
5737		if ($^V && $^V ge 5.10.0 &&
5738		    $line =~ /(?:$Declare|$DeclareMisordered)\s*$Ident\s*$balanced_parens\s*(?:$Attribute)?\s*;/ &&
5739		    ($line =~ /\b__attribute__\s*\(\s*\(.*\bweak\b/ ||
5740		     $line =~ /\b__weak\b/)) {
5741			ERROR("WEAK_DECLARATION",
5742			      "Using weak declarations can have unintended link defects\n" . $herecurr);
5743		}
5744
5745# check for c99 types like uint8_t used outside of uapi/ and tools/
5746		if ($realfile !~ m@\binclude/uapi/@ &&
5747		    $realfile !~ m@\btools/@ &&
5748		    $line =~ /\b($Declare)\s*$Ident\s*[=;,\[]/) {
5749			my $type = $1;
5750			if ($type =~ /\b($typeC99Typedefs)\b/) {
5751				$type = $1;
5752				my $kernel_type = 'u';
5753				$kernel_type = 's' if ($type =~ /^_*[si]/);
5754				$type =~ /(\d+)/;
5755				$kernel_type .= $1;
5756				if (CHK("PREFER_KERNEL_TYPES",
5757					"Prefer kernel type '$kernel_type' over '$type'\n" . $herecurr) &&
5758				    $fix) {
5759					$fixed[$fixlinenr] =~ s/\b$type\b/$kernel_type/;
5760				}
5761			}
5762		}
5763
5764# check for cast of C90 native int or longer types constants
5765		if ($line =~ /(\(\s*$C90_int_types\s*\)\s*)($Constant)\b/) {
5766			my $cast = $1;
5767			my $const = $2;
5768			if (WARN("TYPECAST_INT_CONSTANT",
5769				 "Unnecessary typecast of c90 int constant\n" . $herecurr) &&
5770			    $fix) {
5771				my $suffix = "";
5772				my $newconst = $const;
5773				$newconst =~ s/${Int_type}$//;
5774				$suffix .= 'U' if ($cast =~ /\bunsigned\b/);
5775				if ($cast =~ /\blong\s+long\b/) {
5776					$suffix .= 'LL';
5777				} elsif ($cast =~ /\blong\b/) {
5778					$suffix .= 'L';
5779				}
5780				$fixed[$fixlinenr] =~ s/\Q$cast\E$const\b/$newconst$suffix/;
5781			}
5782		}
5783
5784# check for sizeof(&)
5785		if ($line =~ /\bsizeof\s*\(\s*\&/) {
5786			WARN("SIZEOF_ADDRESS",
5787			     "sizeof(& should be avoided\n" . $herecurr);
5788		}
5789
5790# check for sizeof without parenthesis
5791		if ($line =~ /\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/) {
5792			if (WARN("SIZEOF_PARENTHESIS",
5793				 "sizeof $1 should be sizeof($1)\n" . $herecurr) &&
5794			    $fix) {
5795				$fixed[$fixlinenr] =~ s/\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/"sizeof(" . trim($1) . ")"/ex;
5796			}
5797		}
5798
5799# check for struct spinlock declarations
5800		if ($line =~ /^.\s*\bstruct\s+spinlock\s+\w+\s*;/) {
5801			WARN("USE_SPINLOCK_T",
5802			     "struct spinlock should be spinlock_t\n" . $herecurr);
5803		}
5804
5805# check for seq_printf uses that could be seq_puts
5806		if ($sline =~ /\bseq_printf\s*\(.*"\s*\)\s*;\s*$/) {
5807			my $fmt = get_quoted_string($line, $rawline);
5808			$fmt =~ s/%%//g;
5809			if ($fmt !~ /%/) {
5810				if (WARN("PREFER_SEQ_PUTS",
5811					 "Prefer seq_puts to seq_printf\n" . $herecurr) &&
5812				    $fix) {
5813					$fixed[$fixlinenr] =~ s/\bseq_printf\b/seq_puts/;
5814				}
5815			}
5816		}
5817
5818# check for vsprintf extension %p<foo> misuses
5819		if ($^V && $^V ge 5.10.0 &&
5820		    defined $stat &&
5821		    $stat =~ /^\+(?![^\{]*\{\s*).*\b(\w+)\s*\(.*$String\s*,/s &&
5822		    $1 !~ /^_*volatile_*$/) {
5823			my $specifier;
5824			my $extension;
5825			my $bad_specifier = "";
5826			my $stat_real;
5827
5828			my $lc = $stat =~ tr@\n@@;
5829			$lc = $lc + $linenr;
5830		        for (my $count = $linenr; $count <= $lc; $count++) {
5831				my $fmt = get_quoted_string($lines[$count - 1], raw_line($count, 0));
5832				$fmt =~ s/%%//g;
5833
5834				while ($fmt =~ /(\%[\*\d\.]*p(\w))/g) {
5835					$specifier = $1;
5836					$extension = $2;
5837					if ($extension !~ /[SsBKRraEhMmIiUDdgVCbGNOx]/) {
5838						$bad_specifier = $specifier;
5839						last;
5840					}
5841					if ($extension eq "x" && !defined($stat_real)) {
5842						if (!defined($stat_real)) {
5843							$stat_real = get_stat_real($linenr, $lc);
5844						}
5845						WARN("VSPRINTF_SPECIFIER_PX",
5846						     "Using vsprintf specifier '\%px' potentially exposes the kernel memory layout, if you don't really need the address please consider using '\%p'.\n" . "$here\n$stat_real\n");
5847					}
5848				}
5849				if ($bad_specifier ne "") {
5850					my $stat_real = get_stat_real($linenr, $lc);
5851					my $ext_type = "Invalid";
5852					my $use = "";
5853					if ($bad_specifier =~ /p[Ff]/) {
5854						$ext_type = "Deprecated";
5855						$use = " - use %pS instead";
5856						$use =~ s/pS/ps/ if ($bad_specifier =~ /pf/);
5857					}
5858
5859					WARN("VSPRINTF_POINTER_EXTENSION",
5860					     "$ext_type vsprintf pointer extension '$bad_specifier'$use\n" . "$here\n$stat_real\n");
5861				}
5862			}
5863		}
5864
5865# Check for misused memsets
5866		if ($^V && $^V ge 5.10.0 &&
5867		    defined $stat &&
5868		    $stat =~ /^\+(?:.*?)\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*$FuncArg\s*\)/) {
5869
5870			my $ms_addr = $2;
5871			my $ms_val = $7;
5872			my $ms_size = $12;
5873
5874			if ($ms_size =~ /^(0x|)0$/i) {
5875				ERROR("MEMSET",
5876				      "memset to 0's uses 0 as the 2nd argument, not the 3rd\n" . "$here\n$stat\n");
5877			} elsif ($ms_size =~ /^(0x|)1$/i) {
5878				WARN("MEMSET",
5879				     "single byte memset is suspicious. Swapped 2nd/3rd argument?\n" . "$here\n$stat\n");
5880			}
5881		}
5882
5883# Check for memcpy(foo, bar, ETH_ALEN) that could be ether_addr_copy(foo, bar)
5884#		if ($^V && $^V ge 5.10.0 &&
5885#		    defined $stat &&
5886#		    $stat =~ /^\+(?:.*?)\bmemcpy\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/) {
5887#			if (WARN("PREFER_ETHER_ADDR_COPY",
5888#				 "Prefer ether_addr_copy() over memcpy() if the Ethernet addresses are __aligned(2)\n" . "$here\n$stat\n") &&
5889#			    $fix) {
5890#				$fixed[$fixlinenr] =~ s/\bmemcpy\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/ether_addr_copy($2, $7)/;
5891#			}
5892#		}
5893
5894# Check for memcmp(foo, bar, ETH_ALEN) that could be ether_addr_equal*(foo, bar)
5895#		if ($^V && $^V ge 5.10.0 &&
5896#		    defined $stat &&
5897#		    $stat =~ /^\+(?:.*?)\bmemcmp\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/) {
5898#			WARN("PREFER_ETHER_ADDR_EQUAL",
5899#			     "Prefer ether_addr_equal() or ether_addr_equal_unaligned() over memcmp()\n" . "$here\n$stat\n")
5900#		}
5901
5902# check for memset(foo, 0x0, ETH_ALEN) that could be eth_zero_addr
5903# check for memset(foo, 0xFF, ETH_ALEN) that could be eth_broadcast_addr
5904#		if ($^V && $^V ge 5.10.0 &&
5905#		    defined $stat &&
5906#		    $stat =~ /^\+(?:.*?)\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/) {
5907#
5908#			my $ms_val = $7;
5909#
5910#			if ($ms_val =~ /^(?:0x|)0+$/i) {
5911#				if (WARN("PREFER_ETH_ZERO_ADDR",
5912#					 "Prefer eth_zero_addr over memset()\n" . "$here\n$stat\n") &&
5913#				    $fix) {
5914#					$fixed[$fixlinenr] =~ s/\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*,\s*ETH_ALEN\s*\)/eth_zero_addr($2)/;
5915#				}
5916#			} elsif ($ms_val =~ /^(?:0xff|255)$/i) {
5917#				if (WARN("PREFER_ETH_BROADCAST_ADDR",
5918#					 "Prefer eth_broadcast_addr() over memset()\n" . "$here\n$stat\n") &&
5919#				    $fix) {
5920#					$fixed[$fixlinenr] =~ s/\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*,\s*ETH_ALEN\s*\)/eth_broadcast_addr($2)/;
5921#				}
5922#			}
5923#		}
5924
5925# typecasts on min/max could be min_t/max_t
5926		if ($^V && $^V ge 5.10.0 &&
5927		    defined $stat &&
5928		    $stat =~ /^\+(?:.*?)\b(min|max)\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\)/) {
5929			if (defined $2 || defined $7) {
5930				my $call = $1;
5931				my $cast1 = deparenthesize($2);
5932				my $arg1 = $3;
5933				my $cast2 = deparenthesize($7);
5934				my $arg2 = $8;
5935				my $cast;
5936
5937				if ($cast1 ne "" && $cast2 ne "" && $cast1 ne $cast2) {
5938					$cast = "$cast1 or $cast2";
5939				} elsif ($cast1 ne "") {
5940					$cast = $cast1;
5941				} else {
5942					$cast = $cast2;
5943				}
5944				WARN("MINMAX",
5945				     "$call() should probably be ${call}_t($cast, $arg1, $arg2)\n" . "$here\n$stat\n");
5946			}
5947		}
5948
5949# check usleep_range arguments
5950		if ($^V && $^V ge 5.10.0 &&
5951		    defined $stat &&
5952		    $stat =~ /^\+(?:.*?)\busleep_range\s*\(\s*($FuncArg)\s*,\s*($FuncArg)\s*\)/) {
5953			my $min = $1;
5954			my $max = $7;
5955			if ($min eq $max) {
5956				WARN("USLEEP_RANGE",
5957				     "usleep_range should not use min == max args; see Documentation/timers/timers-howto.txt\n" . "$here\n$stat\n");
5958			} elsif ($min =~ /^\d+$/ && $max =~ /^\d+$/ &&
5959				 $min > $max) {
5960				WARN("USLEEP_RANGE",
5961				     "usleep_range args reversed, use min then max; see Documentation/timers/timers-howto.txt\n" . "$here\n$stat\n");
5962			}
5963		}
5964
5965# check for naked sscanf
5966		if ($^V && $^V ge 5.10.0 &&
5967		    defined $stat &&
5968		    $line =~ /\bsscanf\b/ &&
5969		    ($stat !~ /$Ident\s*=\s*sscanf\s*$balanced_parens/ &&
5970		     $stat !~ /\bsscanf\s*$balanced_parens\s*(?:$Compare)/ &&
5971		     $stat !~ /(?:$Compare)\s*\bsscanf\s*$balanced_parens/)) {
5972			my $lc = $stat =~ tr@\n@@;
5973			$lc = $lc + $linenr;
5974			my $stat_real = get_stat_real($linenr, $lc);
5975			WARN("NAKED_SSCANF",
5976			     "unchecked sscanf return value\n" . "$here\n$stat_real\n");
5977		}
5978
5979# check for simple sscanf that should be kstrto<foo>
5980		if ($^V && $^V ge 5.10.0 &&
5981		    defined $stat &&
5982		    $line =~ /\bsscanf\b/) {
5983			my $lc = $stat =~ tr@\n@@;
5984			$lc = $lc + $linenr;
5985			my $stat_real = get_stat_real($linenr, $lc);
5986			if ($stat_real =~ /\bsscanf\b\s*\(\s*$FuncArg\s*,\s*("[^"]+")/) {
5987				my $format = $6;
5988				my $count = $format =~ tr@%@%@;
5989				if ($count == 1 &&
5990				    $format =~ /^"\%(?i:ll[udxi]|[udxi]ll|ll|[hl]h?[udxi]|[udxi][hl]h?|[hl]h?|[udxi])"$/) {
5991					WARN("SSCANF_TO_KSTRTO",
5992					     "Prefer kstrto<type> to single variable sscanf\n" . "$here\n$stat_real\n");
5993				}
5994			}
5995		}
5996
5997# check for new externs in .h files.
5998		if ($realfile =~ /\.h$/ &&
5999		    $line =~ /^\+\s*(extern\s+)$Type\s*$Ident\s*\(/s) {
6000			if (CHK("AVOID_EXTERNS",
6001				"extern prototypes should be avoided in .h files\n" . $herecurr) &&
6002			    $fix) {
6003				$fixed[$fixlinenr] =~ s/(.*)\bextern\b\s*(.*)/$1$2/;
6004			}
6005		}
6006
6007# check for new externs in .c files.
6008		if ($realfile =~ /\.c$/ && defined $stat &&
6009		    $stat =~ /^.\s*(?:extern\s+)?$Type\s+($Ident)(\s*)\(/s)
6010		{
6011			my $function_name = $1;
6012			my $paren_space = $2;
6013
6014			my $s = $stat;
6015			if (defined $cond) {
6016				substr($s, 0, length($cond), '');
6017			}
6018			if ($s =~ /^\s*;/ &&
6019			    $function_name ne 'uninitialized_var')
6020			{
6021				WARN("AVOID_EXTERNS",
6022				     "externs should be avoided in .c files\n" .  $herecurr);
6023			}
6024
6025			if ($paren_space =~ /\n/) {
6026				WARN("FUNCTION_ARGUMENTS",
6027				     "arguments for function declarations should follow identifier\n" . $herecurr);
6028			}
6029
6030		} elsif ($realfile =~ /\.c$/ && defined $stat &&
6031		    $stat =~ /^.\s*extern\s+/)
6032		{
6033			WARN("AVOID_EXTERNS",
6034			     "externs should be avoided in .c files\n" .  $herecurr);
6035		}
6036
6037# check for function declarations that have arguments without identifier names
6038		if (defined $stat &&
6039		    $stat =~ /^.\s*(?:extern\s+)?$Type\s*(?:$Ident|\(\s*\*\s*$Ident\s*\))\s*\(\s*([^{]+)\s*\)\s*;/s &&
6040		    $1 ne "void") {
6041			my $args = trim($1);
6042			while ($args =~ m/\s*($Type\s*(?:$Ident|\(\s*\*\s*$Ident?\s*\)\s*$balanced_parens)?)/g) {
6043				my $arg = trim($1);
6044				if ($arg =~ /^$Type$/ && $arg !~ /enum\s+$Ident$/) {
6045					WARN("FUNCTION_ARGUMENTS",
6046					     "function definition argument '$arg' should also have an identifier name\n" . $herecurr);
6047				}
6048			}
6049		}
6050
6051# check for function definitions
6052		if ($^V && $^V ge 5.10.0 &&
6053		    defined $stat &&
6054		    $stat =~ /^.\s*(?:$Storage\s+)?$Type\s*($Ident)\s*$balanced_parens\s*{/s) {
6055			$context_function = $1;
6056
6057# check for multiline function definition with misplaced open brace
6058			my $ok = 0;
6059			my $cnt = statement_rawlines($stat);
6060			my $herectx = $here . "\n";
6061			for (my $n = 0; $n < $cnt; $n++) {
6062				my $rl = raw_line($linenr, $n);
6063				$herectx .=  $rl . "\n";
6064				$ok = 1 if ($rl =~ /^[ \+]\{/);
6065				$ok = 1 if ($rl =~ /\{/ && $n == 0);
6066				last if $rl =~ /^[ \+].*\{/;
6067			}
6068			if (!$ok) {
6069				ERROR("OPEN_BRACE",
6070				      "open brace '{' following function definitions go on the next line\n" . $herectx);
6071			}
6072		}
6073
6074# checks for new __setup's
6075		if ($rawline =~ /\b__setup\("([^"]*)"/) {
6076			my $name = $1;
6077
6078			if (!grep(/$name/, @setup_docs)) {
6079				CHK("UNDOCUMENTED_SETUP",
6080				    "__setup appears un-documented -- check Documentation/admin-guide/kernel-parameters.rst\n" . $herecurr);
6081			}
6082		}
6083
6084# check for pointless casting of kmalloc return
6085		if ($line =~ /\*\s*\)\s*[kv][czm]alloc(_node){0,1}\b/) {
6086			WARN("UNNECESSARY_CASTS",
6087			     "unnecessary cast may hide bugs, see http://c-faq.com/malloc/mallocnocast.html\n" . $herecurr);
6088		}
6089
6090# alloc style
6091# p = alloc(sizeof(struct foo), ...) should be p = alloc(sizeof(*p), ...)
6092		if ($^V && $^V ge 5.10.0 &&
6093		    $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*([kv][mz]alloc(?:_node)?)\s*\(\s*(sizeof\s*\(\s*struct\s+$Lval\s*\))/) {
6094			CHK("ALLOC_SIZEOF_STRUCT",
6095			    "Prefer $3(sizeof(*$1)...) over $3($4...)\n" . $herecurr);
6096		}
6097
6098# check for k[mz]alloc with multiplies that could be kmalloc_array/kcalloc
6099		if ($^V && $^V ge 5.10.0 &&
6100		    defined $stat &&
6101		    $stat =~ /^\+\s*($Lval)\s*\=\s*(?:$balanced_parens)?\s*(k[mz]alloc)\s*\(\s*($FuncArg)\s*\*\s*($FuncArg)\s*,/) {
6102			my $oldfunc = $3;
6103			my $a1 = $4;
6104			my $a2 = $10;
6105			my $newfunc = "kmalloc_array";
6106			$newfunc = "kcalloc" if ($oldfunc eq "kzalloc");
6107			my $r1 = $a1;
6108			my $r2 = $a2;
6109			if ($a1 =~ /^sizeof\s*\S/) {
6110				$r1 = $a2;
6111				$r2 = $a1;
6112			}
6113			if ($r1 !~ /^sizeof\b/ && $r2 =~ /^sizeof\s*\S/ &&
6114			    !($r1 =~ /^$Constant$/ || $r1 =~ /^[A-Z_][A-Z0-9_]*$/)) {
6115				my $cnt = statement_rawlines($stat);
6116				my $herectx = get_stat_here($linenr, $cnt, $here);
6117
6118				if (WARN("ALLOC_WITH_MULTIPLY",
6119					 "Prefer $newfunc over $oldfunc with multiply\n" . $herectx) &&
6120				    $cnt == 1 &&
6121				    $fix) {
6122					$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;
6123				}
6124			}
6125		}
6126
6127# check for krealloc arg reuse
6128		if ($^V && $^V ge 5.10.0 &&
6129		    $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*krealloc\s*\(\s*\1\s*,/) {
6130			WARN("KREALLOC_ARG_REUSE",
6131			     "Reusing the krealloc arg is almost always a bug\n" . $herecurr);
6132		}
6133
6134# check for alloc argument mismatch
6135		if ($line =~ /\b(kcalloc|kmalloc_array)\s*\(\s*sizeof\b/) {
6136			WARN("ALLOC_ARRAY_ARGS",
6137			     "$1 uses number as first arg, sizeof is generally wrong\n" . $herecurr);
6138		}
6139
6140# check for multiple semicolons
6141		if ($line =~ /;\s*;\s*$/) {
6142			if (WARN("ONE_SEMICOLON",
6143				 "Statements terminations use 1 semicolon\n" . $herecurr) &&
6144			    $fix) {
6145				$fixed[$fixlinenr] =~ s/(\s*;\s*){2,}$/;/g;
6146			}
6147		}
6148
6149# check for #defines like: 1 << <digit> that could be BIT(digit), it is not exported to uapi
6150		if ($realfile !~ m@^include/uapi/@ &&
6151		    $line =~ /#\s*define\s+\w+\s+\(?\s*1\s*([ulUL]*)\s*\<\<\s*(?:\d+|$Ident)\s*\)?/) {
6152			my $ull = "";
6153			$ull = "_ULL" if (defined($1) && $1 =~ /ll/i);
6154			if (CHK("BIT_MACRO",
6155				"Prefer using the BIT$ull macro\n" . $herecurr) &&
6156			    $fix) {
6157				$fixed[$fixlinenr] =~ s/\(?\s*1\s*[ulUL]*\s*<<\s*(\d+|$Ident)\s*\)?/BIT${ull}($1)/;
6158			}
6159		}
6160
6161# check for #if defined CONFIG_<FOO> || defined CONFIG_<FOO>_MODULE
6162		if ($line =~ /^\+\s*#\s*if\s+defined(?:\s*\(?\s*|\s+)(CONFIG_[A-Z_]+)\s*\)?\s*\|\|\s*defined(?:\s*\(?\s*|\s+)\1_MODULE\s*\)?\s*$/) {
6163			my $config = $1;
6164			if (WARN("PREFER_IS_ENABLED",
6165				 "Prefer IS_ENABLED(<FOO>) to CONFIG_<FOO> || CONFIG_<FOO>_MODULE\n" . $herecurr) &&
6166			    $fix) {
6167				$fixed[$fixlinenr] = "\+#if IS_ENABLED($config)";
6168			}
6169		}
6170
6171# check for case / default statements not preceded by break/fallthrough/switch
6172		if ($line =~ /^.\s*(?:case\s+(?:$Ident|$Constant)\s*|default):/) {
6173			my $has_break = 0;
6174			my $has_statement = 0;
6175			my $count = 0;
6176			my $prevline = $linenr;
6177			while ($prevline > 1 && ($file || $count < 3) && !$has_break) {
6178				$prevline--;
6179				my $rline = $rawlines[$prevline - 1];
6180				my $fline = $lines[$prevline - 1];
6181				last if ($fline =~ /^\@\@/);
6182				next if ($fline =~ /^\-/);
6183				next if ($fline =~ /^.(?:\s*(?:case\s+(?:$Ident|$Constant)[\s$;]*|default):[\s$;]*)*$/);
6184				$has_break = 1 if ($rline =~ /fall[\s_-]*(through|thru)/i);
6185				next if ($fline =~ /^.[\s$;]*$/);
6186				$has_statement = 1;
6187				$count++;
6188				$has_break = 1 if ($fline =~ /\bswitch\b|\b(?:break\s*;[\s$;]*$|exit\s*\(\b|return\b|goto\b|continue\b)/);
6189			}
6190			if (!$has_break && $has_statement) {
6191				WARN("MISSING_BREAK",
6192				     "Possible switch case/default not preceded by break or fallthrough comment\n" . $herecurr);
6193			}
6194		}
6195
6196# check for switch/default statements without a break;
6197		if ($^V && $^V ge 5.10.0 &&
6198		    defined $stat &&
6199		    $stat =~ /^\+[$;\s]*(?:case[$;\s]+\w+[$;\s]*:[$;\s]*|)*[$;\s]*\bdefault[$;\s]*:[$;\s]*;/g) {
6200			my $cnt = statement_rawlines($stat);
6201			my $herectx = get_stat_here($linenr, $cnt, $here);
6202
6203			WARN("DEFAULT_NO_BREAK",
6204			     "switch default: should use break\n" . $herectx);
6205		}
6206
6207# check for gcc specific __FUNCTION__
6208		if ($line =~ /\b__FUNCTION__\b/) {
6209			if (WARN("USE_FUNC",
6210				 "__func__ should be used instead of gcc specific __FUNCTION__\n"  . $herecurr) &&
6211			    $fix) {
6212				$fixed[$fixlinenr] =~ s/\b__FUNCTION__\b/__func__/g;
6213			}
6214		}
6215
6216# check for uses of __DATE__, __TIME__, __TIMESTAMP__
6217		while ($line =~ /\b(__(?:DATE|TIME|TIMESTAMP)__)\b/g) {
6218			ERROR("DATE_TIME",
6219			      "Use of the '$1' macro makes the build non-deterministic\n" . $herecurr);
6220		}
6221
6222# check for use of yield()
6223		if ($line =~ /\byield\s*\(\s*\)/) {
6224			WARN("YIELD",
6225			     "Using yield() is generally wrong. See yield() kernel-doc (sched/core.c)\n"  . $herecurr);
6226		}
6227
6228# check for comparisons against true and false
6229		if ($line =~ /\+\s*(.*?)\b(true|false|$Lval)\s*(==|\!=)\s*(true|false|$Lval)\b(.*)$/i) {
6230			my $lead = $1;
6231			my $arg = $2;
6232			my $test = $3;
6233			my $otype = $4;
6234			my $trail = $5;
6235			my $op = "!";
6236
6237			($arg, $otype) = ($otype, $arg) if ($arg =~ /^(?:true|false)$/i);
6238
6239			my $type = lc($otype);
6240			if ($type =~ /^(?:true|false)$/) {
6241				if (("$test" eq "==" && "$type" eq "true") ||
6242				    ("$test" eq "!=" && "$type" eq "false")) {
6243					$op = "";
6244				}
6245
6246				CHK("BOOL_COMPARISON",
6247				    "Using comparison to $otype is error prone\n" . $herecurr);
6248
6249## maybe suggesting a correct construct would better
6250##				    "Using comparison to $otype is error prone.  Perhaps use '${lead}${op}${arg}${trail}'\n" . $herecurr);
6251
6252			}
6253		}
6254
6255# check for semaphores initialized locked
6256		if ($line =~ /^.\s*sema_init.+,\W?0\W?\)/) {
6257			WARN("CONSIDER_COMPLETION",
6258			     "consider using a completion\n" . $herecurr);
6259		}
6260
6261# recommend kstrto* over simple_strto* and strict_strto*
6262		if ($line =~ /\b((simple|strict)_(strto(l|ll|ul|ull)))\s*\(/) {
6263			WARN("CONSIDER_KSTRTO",
6264			     "$1 is obsolete, use k$3 instead\n" . $herecurr);
6265		}
6266
6267# check for __initcall(), use device_initcall() explicitly or more appropriate function please
6268		if ($line =~ /^.\s*__initcall\s*\(/) {
6269			WARN("USE_DEVICE_INITCALL",
6270			     "please use device_initcall() or more appropriate function instead of __initcall() (see include/linux/init.h)\n" . $herecurr);
6271		}
6272
6273# check for various structs that are normally const (ops, kgdb, device_tree)
6274# and avoid what seem like struct definitions 'struct foo {'
6275		if ($line !~ /\bconst\b/ &&
6276		    $line =~ /\bstruct\s+($const_structs)\b(?!\s*\{)/) {
6277			WARN("CONST_STRUCT",
6278			     "struct $1 should normally be const\n" . $herecurr);
6279		}
6280
6281# use of NR_CPUS is usually wrong
6282# ignore definitions of NR_CPUS and usage to define arrays as likely right
6283		if ($line =~ /\bNR_CPUS\b/ &&
6284		    $line !~ /^.\s*\s*#\s*if\b.*\bNR_CPUS\b/ &&
6285		    $line !~ /^.\s*\s*#\s*define\b.*\bNR_CPUS\b/ &&
6286		    $line !~ /^.\s*$Declare\s.*\[[^\]]*NR_CPUS[^\]]*\]/ &&
6287		    $line !~ /\[[^\]]*\.\.\.[^\]]*NR_CPUS[^\]]*\]/ &&
6288		    $line !~ /\[[^\]]*NR_CPUS[^\]]*\.\.\.[^\]]*\]/)
6289		{
6290			WARN("NR_CPUS",
6291			     "usage of NR_CPUS is often wrong - consider using cpu_possible(), num_possible_cpus(), for_each_possible_cpu(), etc\n" . $herecurr);
6292		}
6293
6294# Use of __ARCH_HAS_<FOO> or ARCH_HAVE_<BAR> is wrong.
6295		if ($line =~ /\+\s*#\s*define\s+((?:__)?ARCH_(?:HAS|HAVE)\w*)\b/) {
6296			ERROR("DEFINE_ARCH_HAS",
6297			      "#define of '$1' is wrong - use Kconfig variables or standard guards instead\n" . $herecurr);
6298		}
6299
6300# likely/unlikely comparisons similar to "(likely(foo) > 0)"
6301		if ($^V && $^V ge 5.10.0 &&
6302		    $line =~ /\b((?:un)?likely)\s*\(\s*$FuncArg\s*\)\s*$Compare/) {
6303			WARN("LIKELY_MISUSE",
6304			     "Using $1 should generally have parentheses around the comparison\n" . $herecurr);
6305		}
6306
6307# whine mightly about in_atomic
6308		if ($line =~ /\bin_atomic\s*\(/) {
6309			if ($realfile =~ m@^drivers/@) {
6310				ERROR("IN_ATOMIC",
6311				      "do not use in_atomic in drivers\n" . $herecurr);
6312			} elsif ($realfile !~ m@^kernel/@) {
6313				WARN("IN_ATOMIC",
6314				     "use of in_atomic() is incorrect outside core kernel code\n" . $herecurr);
6315			}
6316		}
6317
6318# check for mutex_trylock_recursive usage
6319		if ($line =~ /mutex_trylock_recursive/) {
6320			ERROR("LOCKING",
6321			      "recursive locking is bad, do not use this ever.\n" . $herecurr);
6322		}
6323
6324# check for lockdep_set_novalidate_class
6325		if ($line =~ /^.\s*lockdep_set_novalidate_class\s*\(/ ||
6326		    $line =~ /__lockdep_no_validate__\s*\)/ ) {
6327			if ($realfile !~ m@^kernel/lockdep@ &&
6328			    $realfile !~ m@^include/linux/lockdep@ &&
6329			    $realfile !~ m@^drivers/base/core@) {
6330				ERROR("LOCKDEP",
6331				      "lockdep_no_validate class is reserved for device->mutex.\n" . $herecurr);
6332			}
6333		}
6334
6335		if ($line =~ /debugfs_create_\w+.*\b$mode_perms_world_writable\b/ ||
6336		    $line =~ /DEVICE_ATTR.*\b$mode_perms_world_writable\b/) {
6337			WARN("EXPORTED_WORLD_WRITABLE",
6338			     "Exporting world writable files is usually an error. Consider more restrictive permissions.\n" . $herecurr);
6339		}
6340
6341# check for DEVICE_ATTR uses that could be DEVICE_ATTR_<FOO>
6342# and whether or not function naming is typical and if
6343# DEVICE_ATTR permissions uses are unusual too
6344		if ($^V && $^V ge 5.10.0 &&
6345		    defined $stat &&
6346		    $stat =~ /\bDEVICE_ATTR\s*\(\s*(\w+)\s*,\s*\(?\s*(\s*(?:${multi_mode_perms_string_search}|0[0-7]{3,3})\s*)\s*\)?\s*,\s*(\w+)\s*,\s*(\w+)\s*\)/) {
6347			my $var = $1;
6348			my $perms = $2;
6349			my $show = $3;
6350			my $store = $4;
6351			my $octal_perms = perms_to_octal($perms);
6352			if ($show =~ /^${var}_show$/ &&
6353			    $store =~ /^${var}_store$/ &&
6354			    $octal_perms eq "0644") {
6355				if (WARN("DEVICE_ATTR_RW",
6356					 "Use DEVICE_ATTR_RW\n" . $herecurr) &&
6357				    $fix) {
6358					$fixed[$fixlinenr] =~ s/\bDEVICE_ATTR\s*\(\s*$var\s*,\s*\Q$perms\E\s*,\s*$show\s*,\s*$store\s*\)/DEVICE_ATTR_RW(${var})/;
6359				}
6360			} elsif ($show =~ /^${var}_show$/ &&
6361				 $store =~ /^NULL$/ &&
6362				 $octal_perms eq "0444") {
6363				if (WARN("DEVICE_ATTR_RO",
6364					 "Use DEVICE_ATTR_RO\n" . $herecurr) &&
6365				    $fix) {
6366					$fixed[$fixlinenr] =~ s/\bDEVICE_ATTR\s*\(\s*$var\s*,\s*\Q$perms\E\s*,\s*$show\s*,\s*NULL\s*\)/DEVICE_ATTR_RO(${var})/;
6367				}
6368			} elsif ($show =~ /^NULL$/ &&
6369				 $store =~ /^${var}_store$/ &&
6370				 $octal_perms eq "0200") {
6371				if (WARN("DEVICE_ATTR_WO",
6372					 "Use DEVICE_ATTR_WO\n" . $herecurr) &&
6373				    $fix) {
6374					$fixed[$fixlinenr] =~ s/\bDEVICE_ATTR\s*\(\s*$var\s*,\s*\Q$perms\E\s*,\s*NULL\s*,\s*$store\s*\)/DEVICE_ATTR_WO(${var})/;
6375				}
6376			} elsif ($octal_perms eq "0644" ||
6377				 $octal_perms eq "0444" ||
6378				 $octal_perms eq "0200") {
6379				my $newshow = "$show";
6380				$newshow = "${var}_show" if ($show ne "NULL" && $show ne "${var}_show");
6381				my $newstore = $store;
6382				$newstore = "${var}_store" if ($store ne "NULL" && $store ne "${var}_store");
6383				my $rename = "";
6384				if ($show ne $newshow) {
6385					$rename .= " '$show' to '$newshow'";
6386				}
6387				if ($store ne $newstore) {
6388					$rename .= " '$store' to '$newstore'";
6389				}
6390				WARN("DEVICE_ATTR_FUNCTIONS",
6391				     "Consider renaming function(s)$rename\n" . $herecurr);
6392			} else {
6393				WARN("DEVICE_ATTR_PERMS",
6394				     "DEVICE_ATTR unusual permissions '$perms' used\n" . $herecurr);
6395			}
6396		}
6397
6398# Mode permission misuses where it seems decimal should be octal
6399# This uses a shortcut match to avoid unnecessary uses of a slow foreach loop
6400# o Ignore module_param*(...) uses with a decimal 0 permission as that has a
6401#   specific definition of not visible in sysfs.
6402# o Ignore proc_create*(...) uses with a decimal 0 permission as that means
6403#   use the default permissions
6404		if ($^V && $^V ge 5.10.0 &&
6405		    defined $stat &&
6406		    $line =~ /$mode_perms_search/) {
6407			foreach my $entry (@mode_permission_funcs) {
6408				my $func = $entry->[0];
6409				my $arg_pos = $entry->[1];
6410
6411				my $lc = $stat =~ tr@\n@@;
6412				$lc = $lc + $linenr;
6413				my $stat_real = get_stat_real($linenr, $lc);
6414
6415				my $skip_args = "";
6416				if ($arg_pos > 1) {
6417					$arg_pos--;
6418					$skip_args = "(?:\\s*$FuncArg\\s*,\\s*){$arg_pos,$arg_pos}";
6419				}
6420				my $test = "\\b$func\\s*\\(${skip_args}($FuncArg(?:\\|\\s*$FuncArg)*)\\s*[,\\)]";
6421				if ($stat =~ /$test/) {
6422					my $val = $1;
6423					$val = $6 if ($skip_args ne "");
6424					if (!($func =~ /^(?:module_param|proc_create)/ && $val eq "0") &&
6425					    (($val =~ /^$Int$/ && $val !~ /^$Octal$/) ||
6426					     ($val =~ /^$Octal$/ && length($val) ne 4))) {
6427						ERROR("NON_OCTAL_PERMISSIONS",
6428						      "Use 4 digit octal (0777) not decimal permissions\n" . "$here\n" . $stat_real);
6429					}
6430					if ($val =~ /^$Octal$/ && (oct($val) & 02)) {
6431						ERROR("EXPORTED_WORLD_WRITABLE",
6432						      "Exporting writable files is usually an error. Consider more restrictive permissions.\n" . "$here\n" . $stat_real);
6433					}
6434				}
6435			}
6436		}
6437
6438# check for uses of S_<PERMS> that could be octal for readability
6439		while ($line =~ m{\b($multi_mode_perms_string_search)\b}g) {
6440			my $oval = $1;
6441			my $octal = perms_to_octal($oval);
6442			if (WARN("SYMBOLIC_PERMS",
6443				 "Symbolic permissions '$oval' are not preferred. Consider using octal permissions '$octal'.\n" . $herecurr) &&
6444			    $fix) {
6445				$fixed[$fixlinenr] =~ s/\Q$oval\E/$octal/;
6446			}
6447		}
6448
6449# validate content of MODULE_LICENSE against list from include/linux/module.h
6450		if ($line =~ /\bMODULE_LICENSE\s*\(\s*($String)\s*\)/) {
6451			my $extracted_string = get_quoted_string($line, $rawline);
6452			my $valid_licenses = qr{
6453						GPL|
6454						GPL\ v2|
6455						GPL\ and\ additional\ rights|
6456						Dual\ BSD/GPL|
6457						Dual\ MIT/GPL|
6458						Dual\ MPL/GPL|
6459						Proprietary
6460					}x;
6461			if ($extracted_string !~ /^"(?:$valid_licenses)"$/x) {
6462				WARN("MODULE_LICENSE",
6463				     "unknown module license " . $extracted_string . "\n" . $herecurr);
6464			}
6465		}
6466	}
6467
6468	# If we have no input at all, then there is nothing to report on
6469	# so just keep quiet.
6470	if ($#rawlines == -1) {
6471		exit(0);
6472	}
6473
6474	# In mailback mode only produce a report in the negative, for
6475	# things that appear to be patches.
6476	if ($mailback && ($clean == 1 || !$is_patch)) {
6477		exit(0);
6478	}
6479
6480	# This is not a patch, and we are are in 'no-patch' mode so
6481	# just keep quiet.
6482	if (!$chk_patch && !$is_patch) {
6483		exit(0);
6484	}
6485
6486	if (!$is_patch && $filename !~ /cover-letter\.patch$/) {
6487		ERROR("NOT_UNIFIED_DIFF",
6488		      "Does not appear to be a unified-diff format patch\n");
6489	}
6490	if ($is_patch && $has_commit_log && $chk_signoff && $signoff == 0) {
6491		ERROR("MISSING_SIGN_OFF",
6492		      "Missing Signed-off-by: line(s)\n");
6493	}
6494
6495	print report_dump();
6496	if ($summary && !($clean == 1 && $quiet == 1)) {
6497		print "$filename " if ($summary_file);
6498		print "total: $cnt_error errors, $cnt_warn warnings, " .
6499			(($check)? "$cnt_chk checks, " : "") .
6500			"$cnt_lines lines checked\n";
6501	}
6502
6503	if ($quiet == 0) {
6504		# If there were any defects found and not already fixing them
6505		if (!$clean and !$fix) {
6506			print << "EOM"
6507
6508NOTE: For some of the reported defects, checkpatch may be able to
6509      mechanically convert to the typical style using --fix or --fix-inplace.
6510EOM
6511		}
6512		# If there were whitespace errors which cleanpatch can fix
6513		# then suggest that.
6514		if ($rpt_cleaners) {
6515			$rpt_cleaners = 0;
6516			print << "EOM"
6517
6518NOTE: Whitespace errors detected.
6519      You may wish to use scripts/cleanpatch or scripts/cleanfile
6520EOM
6521		}
6522	}
6523
6524	if ($clean == 0 && $fix &&
6525	    ("@rawlines" ne "@fixed" ||
6526	     $#fixed_inserted >= 0 || $#fixed_deleted >= 0)) {
6527		my $newfile = $filename;
6528		$newfile .= ".EXPERIMENTAL-checkpatch-fixes" if (!$fix_inplace);
6529		my $linecount = 0;
6530		my $f;
6531
6532		@fixed = fix_inserted_deleted_lines(\@fixed, \@fixed_inserted, \@fixed_deleted);
6533
6534		open($f, '>', $newfile)
6535		    or die "$P: Can't open $newfile for write\n";
6536		foreach my $fixed_line (@fixed) {
6537			$linecount++;
6538			if ($file) {
6539				if ($linecount > 3) {
6540					$fixed_line =~ s/^\+//;
6541					print $f $fixed_line . "\n";
6542				}
6543			} else {
6544				print $f $fixed_line . "\n";
6545			}
6546		}
6547		close($f);
6548
6549		if (!$quiet) {
6550			print << "EOM";
6551
6552Wrote EXPERIMENTAL --fix correction(s) to '$newfile'
6553
6554Do _NOT_ trust the results written to this file.
6555Do _NOT_ submit these changes without inspecting them for correctness.
6556
6557This EXPERIMENTAL file is simply a convenience to help rewrite patches.
6558No warranties, expressed or implied...
6559EOM
6560		}
6561	}
6562
6563	if ($quiet == 0) {
6564		print "\n";
6565		if ($clean == 1) {
6566			print "$vname has no obvious style problems and is ready for submission.\n";
6567		} else {
6568			print "$vname has style problems, please review.\n";
6569		}
6570	}
6571	return $clean;
6572}
6573