linux - scripts/checkpatch.pl

6720 lines · 196.4 KiB

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