linux - scripts/checkpatch.pl

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