linux - scripts/checkpatch.pl

3685 lines · 99.8 KiB

1	#!/usr/bin/perl -w
2	# (c) 2001, Dave Jones. (the file handling bit)
3	# (c) 2005, Joel Schopp <[email protected]> (the ugly bit)
4	# (c) 2007,2008, Andy Whitcroft <[email protected]> (new conditions, test suite)
5	# (c) 2008-2010 Andy Whitcroft <[email protected]>
6	# Licensed under the terms of the GNU GPL License version 2
7
8	use strict;
9
10	my $P = $0;
11	$P =~ s@.*/@@g;
12
13	my $V = '0.32';
14
15	use Getopt::Long qw(:config no_auto_abbrev);
16
17	my $quiet = 0;
18	my $tree = 1;
19	my $chk_signoff = 1;
20	my $chk_patch = 1;
21	my $tst_only;
22	my $emacs = 0;
23	my $terse = 0;
24	my $file = 0;
25	my $check = 0;
26	my $summary = 1;
27	my $mailback = 0;
28	my $summary_file = 0;
29	my $show_types = 0;
30	my $root;
31	my %debug;
32	my %ignore_type = ();
33	my @ignore = ();
34	my $help = 0;
35	my $configuration_file = ".checkpatch.conf";
36	my $max_line_length = 80;
37
38	sub help {
39	my ($exitcode) = @_;
40
41	print << "EOM";
42	Usage: $P [OPTION]... [FILE]...
43	Version: $V
44
45	Options:
46	-q, --quiet quiet
47	--no-tree run without a kernel tree
48	--no-signoff do not check for 'Signed-off-by' line
49	--patch treat FILE as patchfile (default)
50	--emacs emacs compile window format
51	--terse one line per report
52	-f, --file treat FILE as regular source file
53	--subjective, --strict enable more subjective tests
54	--ignore TYPE(,TYPE2...) ignore various comma separated message types
55	--max-line-length=n set the maximum line length, if exceeded, warn
56	--show-types show the message "types" in the output
57	--root=PATH PATH to the kernel tree root
58	--no-summary suppress the per-file summary
59	--mailback only produce a report in case of warnings/errors
60	--summary-file include the filename in summary
61	--debug KEY=[0\|1] turn on/off debugging of KEY, where KEY is one of
62	'values', 'possible', 'type', and 'attr' (default
63	is all off)
64	--test-only=WORD report only warnings/errors containing WORD
65	literally
66	-h, --help, --version display this help and exit
67
68	When FILE is - read standard input.
69	EOM
70
71	exit($exitcode);
72	}
73
74	my $conf = which_conf($configuration_file);
75	if (-f $conf) {
76	my @conf_args;
77	open(my $conffile, '<', "$conf")
78	or warn "$P: Can't find a readable $configuration_file file $!\n";
79
80	while (<$conffile>) {
81	my $line = $_;
82
83	$line =~ s/\s*\n?$//g;
84	$line =~ s/^\s*//g;
85	$line =~ s/\s+/ /g;
86
87	next if ($line =~ m/^\s*#/);
88	next if ($line =~ m/^\s*$/);
89
90	my @words = split(" ", $line);
91	foreach my $word (@words) {
92	last if ($word =~ m/^#/);
93	push (@conf_args, $word);
94	}
95	}
96	close($conffile);
97	unshift(@ARGV, @conf_args) if @conf_args;
98	}
99
100	GetOptions(
101	'q\|quiet+' => \$quiet,
102	'tree!' => \$tree,
103	'signoff!' => \$chk_signoff,
104	'patch!' => \$chk_patch,
105	'emacs!' => \$emacs,
106	'terse!' => \$terse,
107	'f\|file!' => \$file,
108	'subjective!' => \$check,
109	'strict!' => \$check,
110	'ignore=s' => \@ignore,
111	'show-types!' => \$show_types,
112	'max-line-length=i' => \$max_line_length,
113	'root=s' => \$root,
114	'summary!' => \$summary,
115	'mailback!' => \$mailback,
116	'summary-file!' => \$summary_file,
117
118	'debug=s' => \%debug,
119	'test-only=s' => \$tst_only,
120	'h\|help' => \$help,
121	'version' => \$help
122	) or help(1);
123
124	help(0) if ($help);
125
126	my $exit = 0;
127
128	if ($#ARGV < 0) {
129	print "$P: no input files\n";
130	exit(1);
131	}
132
133	@ignore = split(/,/, join(',',@ignore));
134	foreach my $word (@ignore) {
135	$word =~ s/\s*\n?$//g;
136	$word =~ s/^\s*//g;
137	$word =~ s/\s+/ /g;
138	$word =~ tr/[a-z]/[A-Z]/;
139
140	next if ($word =~ m/^\s*#/);
141	next if ($word =~ m/^\s*$/);
142
143	$ignore_type{$word}++;
144	}
145
146	my $dbg_values = 0;
147	my $dbg_possible = 0;
148	my $dbg_type = 0;
149	my $dbg_attr = 0;
150	for my $key (keys %debug) {
151	## no critic
152	eval "\${dbg_$key} = '$debug{$key}';";
153	die "$@" if ($@);
154	}
155
156	my $rpt_cleaners = 0;
157
158	if ($terse) {
159	$emacs = 1;
160	$quiet++;
161	}
162
163	if ($tree) {
164	if (defined $root) {
165	if (!top_of_kernel_tree($root)) {
166	die "$P: $root: --root does not point at a valid tree\n";
167	}
168	} else {
169	if (top_of_kernel_tree('.')) {
170	$root = '.';
171	} elsif ($0 =~ m@(.)/scripts/[^/]$@ &&
172	top_of_kernel_tree($1)) {
173	$root = $1;
174	}
175	}
176
177	if (!defined $root) {
178	print "Must be run from the top-level dir. of a kernel tree\n";
179	exit(2);
180	}
181	}
182
183	my $emitted_corrupt = 0;
184
185	our $Ident = qr{
186	[A-Za-z_][A-Za-z\d_]*
187	(?:\s\#\#\s[A-Za-z_][A-Za-z\d_])
188	}x;
189	our $Storage = qr{extern\|static\|asmlinkage};
190	our $Sparse = qr{
191	__user\|
192	__kernel\|
193	__force\|
194	__iomem\|
195	__must_check\|
196	__init_refok\|
197	__kprobes\|
198	__ref\|
199	__rcu
200	}x;
201
202	# Notes to $Attribute:
203	# We need \b after 'init' otherwise 'initconst' will cause a false positive in a check
204	our $Attribute = qr{
205	const\|
206	__percpu\|
207	__nocast\|
208	__safe\|
209	__bitwise__\|
210	__packed__\|
211	__packed2__\|
212	__naked\|
213	__maybe_unused\|
214	__always_unused\|
215	__noreturn\|
216	__used\|
217	__cold\|
218	__noclone\|
219	__deprecated\|
220	__read_mostly\|
221	__kprobes\|
222	__(?:mem\|cpu\|dev\|)(?:initdata\|initconst\|init\b)\|
223	____cacheline_aligned\|
224	____cacheline_aligned_in_smp\|
225	____cacheline_internodealigned_in_smp\|
226	__weak
227	}x;
228	our $Modifier;
229	our $Inline = qr{inline\|__always_inline\|noinline};
230	our $Member = qr{->$Ident\|\.$Ident\|\[[^]]*\]};
231	our $Lval = qr{$Ident(?:$Member)*};
232
233	our $Float_hex = qr{(?i)0x[0-9a-f]+p-?[0-9]+[fl]?};
234	our $Float_dec = qr{(?i)(?:[0-9]+\.[0-9]\|[0-9]\.[0-9]+)(?:e-?[0-9]+)?[fl]?};
235	our $Float_int = qr{(?i)[0-9]+e-?[0-9]+[fl]?};
236	our $Float = qr{$Float_hex\|$Float_dec\|$Float_int};
237	our $Constant = qr{$Float\|(?i)(?:0x[0-9a-f]+\|[0-9]+)[ul]*};
238	our $Assignment = qr{\*\=\|/=\|%=\|\+=\|-=\|<<=\|>>=\|&=\|\^=\|\\|=\|=};
239	our $Compare = qr{<=\|>=\|==\|!=\|<\|>};
240	our $Operators = qr{
241	<=\|>=\|==\|!=\|
242	=>\|->\|<<\|>>\|<\|>\|!\|~\|
243	&&\|\\|\\|\|,\|\^\|\+\+\|--\|&\|\\|\|\+\|-\|\*\|\/\|%
244	}x;
245
246	our $NonptrType;
247	our $Type;
248	our $Declare;
249
250	our $NON_ASCII_UTF8 = qr{
251	[\xC2-\xDF][\x80-\xBF] # non-overlong 2-byte
252	\| \xE0[\xA0-\xBF][\x80-\xBF] # excluding overlongs
253	\| [\xE1-\xEC\xEE\xEF][\x80-\xBF]{2} # straight 3-byte
254	\| \xED[\x80-\x9F][\x80-\xBF] # excluding surrogates
255	\| \xF0[\x90-\xBF][\x80-\xBF]{2} # planes 1-3
256	\| [\xF1-\xF3][\x80-\xBF]{3} # planes 4-15
257	\| \xF4[\x80-\x8F][\x80-\xBF]{2} # plane 16
258	}x;
259
260	our $UTF8 = qr{
261	[\x09\x0A\x0D\x20-\x7E] # ASCII
262	\| $NON_ASCII_UTF8
263	}x;
264
265	our $typeTypedefs = qr{(?x:
266	(?:__)?(?:u\|s\|be\|le)(?:8\|16\|32\|64)\|
267	atomic_t
268	)};
269
270	our $logFunctions = qr{(?x:
271	printk(?:_ratelimited\|_once\|)\|
272	[a-z0-9]+_(?:printk\|emerg\|alert\|crit\|err\|warning\|warn\|notice\|info\|debug\|dbg\|vdbg\|devel\|cont\|WARN)(?:_ratelimited\|_once\|)\|
273	WARN(?:_RATELIMIT\|_ONCE\|)\|
274	panic\|
275	MODULE_[A-Z_]+
276	)};
277
278	our $signature_tags = qr{(?xi:
279	Signed-off-by:\|
280	Acked-by:\|
281	Tested-by:\|
282	Reviewed-by:\|
283	Reported-by:\|
284	To:\|
285	Cc:
286	)};
287
288	our @typeList = (
289	qr{void},
290	qr{(?:unsigned\s+)?char},
291	qr{(?:unsigned\s+)?short},
292	qr{(?:unsigned\s+)?int},
293	qr{(?:unsigned\s+)?long},
294	qr{(?:unsigned\s+)?long\s+int},
295	qr{(?:unsigned\s+)?long\s+long},
296	qr{(?:unsigned\s+)?long\s+long\s+int},
297	qr{unsigned},
298	qr{float},
299	qr{double},
300	qr{bool},
301	qr{struct\s+$Ident},
302	qr{union\s+$Ident},
303	qr{enum\s+$Ident},
304	qr{${Ident}_t},
305	qr{${Ident}_handler},
306	qr{${Ident}_handler_fn},
307	);
308	our @modifierList = (
309	qr{fastcall},
310	);
311
312	our $allowed_asm_includes = qr{(?x:
313	irq\|
314	memory
315	)};
316	# memory.h: ARM has a custom one
317
318	sub build_types {
319	my $mods = "(?x: \n" . join("\|\n ", @modifierList) . "\n)";
320	my $all = "(?x: \n" . join("\|\n ", @typeList) . "\n)";
321	$Modifier = qr{(?:$Attribute\|$Sparse\|$mods)};
322	$NonptrType = qr{
323	(?:$Modifier\s+\|const\s+)*
324	(?:
325	(?:typeof\|__typeof__)\s$[^$]\)\|
326	(?:$typeTypedefs\b)\|
327	(?:${all}\b)
328	)
329	(?:\s+$Modifier\|\s+const)*
330	}x;
331	$Type = qr{
332	$NonptrType
333	(?:(?:\s\|\\|\[\])+\sconst\|(?:\s\|\\|\[\])+\|(?:\s\[\s*\])+)?
334	(?:\s+$Inline\|\s+$Modifier)*
335	}x;
336	$Declare = qr{(?:$Storage\s+)?$Type};
337	}
338	build_types();
339
340
341	our $Typecast = qr{\s($\s$NonptrType\s$){0,1}\s};
342
343	# Using $balanced_parens, $LvalOrFunc, or $FuncArg
344	# requires at least perl version v5.10.0
345	# Any use must be runtime checked with $^V
346
347	our $balanced_parens = qr/($(?:[^\($]++\|(?-1))*\))/;
348	our $LvalOrFunc = qr{($Lval)\s($balanced_parens{0,1})\s};
349	our $FuncArg = qr{$Typecast{0,1}($LvalOrFunc\|$Constant)};
350
351	sub deparenthesize {
352	my ($string) = @_;
353	return "" if (!defined($string));
354	$string =~ s@^\s\(\s@@g;
355	$string =~ s@\s\)\s$@@g;
356	$string =~ s@\s+@ @g;
357	return $string;
358	}
359
360	$chk_signoff = 0 if ($file);
361
362	my @rawlines = ();
363	my @lines = ();
364	my $vname;
365	for my $filename (@ARGV) {
366	my $FILE;
367	if ($file) {
368	open($FILE, '-\|', "diff -u /dev/null $filename") \|\|
369	die "$P: $filename: diff failed - $!\n";
370	} elsif ($filename eq '-') {
371	open($FILE, '<&STDIN');
372	} else {
373	open($FILE, '<', "$filename") \|\|
374	die "$P: $filename: open failed - $!\n";
375	}
376	if ($filename eq '-') {
377	$vname = 'Your patch';
378	} else {
379	$vname = $filename;
380	}
381	while (<$FILE>) {
382	chomp;
383	push(@rawlines, $_);
384	}
385	close($FILE);
386	if (!process($filename)) {
387	$exit = 1;
388	}
389	@rawlines = ();
390	@lines = ();
391	}
392
393	exit($exit);
394
395	sub top_of_kernel_tree {
396	my ($root) = @_;
397
398	my @tree_check = (
399	"COPYING", "CREDITS", "Kbuild", "MAINTAINERS", "Makefile",
400	"README", "Documentation", "arch", "include", "drivers",
401	"fs", "init", "ipc", "kernel", "lib", "scripts",
402	);
403
404	foreach my $check (@tree_check) {
405	if (! -e $root . '/' . $check) {
406	return 0;
407	}
408	}
409	return 1;
410	}
411
412	sub parse_email {
413	my ($formatted_email) = @_;
414
415	my $name = "";
416	my $address = "";
417	my $comment = "";
418
419	if ($formatted_email =~ /^(.)<(\S+\@\S+)>(.)$/) {
420	$name = $1;
421	$address = $2;
422	$comment = $3 if defined $3;
423	} elsif ($formatted_email =~ /^\s<(\S+\@\S+)>(.)$/) {
424	$address = $1;
425	$comment = $2 if defined $2;
426	} elsif ($formatted_email =~ /(\S+\@\S+)(.*)$/) {
427	$address = $1;
428	$comment = $2 if defined $2;
429	$formatted_email =~ s/$address.*$//;
430	$name = $formatted_email;
431	$name =~ s/^\s+\|\s+$//g;
432	$name =~ s/^\"\|\"$//g;
433	# If there's a name left after stripping spaces and
434	# leading quotes, and the address doesn't have both
435	# leading and trailing angle brackets, the address
436	# is invalid. ie:
437	# "joe smith [email protected]" bad
438	# "joe smith <[email protected]" bad
439	if ($name ne "" && $address !~ /^<[^>]+>$/) {
440	$name = "";
441	$address = "";
442	$comment = "";
443	}
444	}
445
446	$name =~ s/^\s+\|\s+$//g;
447	$name =~ s/^\"\|\"$//g;
448	$address =~ s/^\s+\|\s+$//g;
449	$address =~ s/^\<\|\>$//g;
450
451	if ($name =~ /[^\w \-]/i) { ##has "must quote" chars
452	$name =~ s/(?<!\\)"/\\"/g; ##escape quotes
453	$name = "\"$name\"";
454	}
455
456	return ($name, $address, $comment);
457	}
458
459	sub format_email {
460	my ($name, $address) = @_;
461
462	my $formatted_email;
463
464	$name =~ s/^\s+\|\s+$//g;
465	$name =~ s/^\"\|\"$//g;
466	$address =~ s/^\s+\|\s+$//g;
467
468	if ($name =~ /[^\w \-]/i) { ##has "must quote" chars
469	$name =~ s/(?<!\\)"/\\"/g; ##escape quotes
470	$name = "\"$name\"";
471	}
472
473	if ("$name" eq "") {
474	$formatted_email = "$address";
475	} else {
476	$formatted_email = "$name <$address>";
477	}
478
479	return $formatted_email;
480	}
481
482	sub which_conf {
483	my ($conf) = @_;
484
485	foreach my $path (split(/:/, ".:$ENV{HOME}:.scripts")) {
486	if (-e "$path/$conf") {
487	return "$path/$conf";
488	}
489	}
490
491	return "";
492	}
493
494	sub expand_tabs {
495	my ($str) = @_;
496
497	my $res = '';
498	my $n = 0;
499	for my $c (split(//, $str)) {
500	if ($c eq "\t") {
501	$res .= ' ';
502	$n++;
503	for (; ($n % 8) != 0; $n++) {
504	$res .= ' ';
505	}
506	next;
507	}
508	$res .= $c;
509	$n++;
510	}
511
512	return $res;
513	}
514	sub copy_spacing {
515	(my $res = shift) =~ tr/\t/ /c;
516	return $res;
517	}
518
519	sub line_stats {
520	my ($line) = @_;
521
522	# Drop the diff line leader and expand tabs
523	$line =~ s/^.//;
524	$line = expand_tabs($line);
525
526	# Pick the indent from the front of the line.
527	my ($white) = ($line =~ /^(\s*)/);
528
529	return (length($line), length($white));
530	}
531
532	my $sanitise_quote = '';
533
534	sub sanitise_line_reset {
535	my ($in_comment) = @_;
536
537	if ($in_comment) {
538	$sanitise_quote = '*/';
539	} else {
540	$sanitise_quote = '';
541	}
542	}
543	sub sanitise_line {
544	my ($line) = @_;
545
546	my $res = '';
547	my $l = '';
548
549	my $qlen = 0;
550	my $off = 0;
551	my $c;
552
553	# Always copy over the diff marker.
554	$res = substr($line, 0, 1);
555
556	for ($off = 1; $off < length($line); $off++) {
557	$c = substr($line, $off, 1);
558
559	# Comments we are wacking completly including the begin
560	# and end, all to $;.
561	if ($sanitise_quote eq '' && substr($line, $off, 2) eq '/*') {
562	$sanitise_quote = '*/';
563
564	substr($res, $off, 2, "$;$;");
565	$off++;
566	next;
567	}
568	if ($sanitise_quote eq '/' && substr($line, $off, 2) eq '/') {
569	$sanitise_quote = '';
570	substr($res, $off, 2, "$;$;");
571	$off++;
572	next;
573	}
574	if ($sanitise_quote eq '' && substr($line, $off, 2) eq '//') {
575	$sanitise_quote = '//';
576
577	substr($res, $off, 2, $sanitise_quote);
578	$off++;
579	next;
580	}
581
582	# A \ in a string means ignore the next character.
583	if (($sanitise_quote eq "'" \|\| $sanitise_quote eq '"') &&
584	$c eq "\\") {
585	substr($res, $off, 2, 'XX');
586	$off++;
587	next;
588	}
589	# Regular quotes.
590	if ($c eq "'" \|\| $c eq '"') {
591	if ($sanitise_quote eq '') {
592	$sanitise_quote = $c;
593
594	substr($res, $off, 1, $c);
595	next;
596	} elsif ($sanitise_quote eq $c) {
597	$sanitise_quote = '';
598	}
599	}
600
601	#print "c<$c> SQ<$sanitise_quote>\n";
602	if ($off != 0 && $sanitise_quote eq '*/' && $c ne "\t") {
603	substr($res, $off, 1, $;);
604	} elsif ($off != 0 && $sanitise_quote eq '//' && $c ne "\t") {
605	substr($res, $off, 1, $;);
606	} elsif ($off != 0 && $sanitise_quote && $c ne "\t") {
607	substr($res, $off, 1, 'X');
608	} else {
609	substr($res, $off, 1, $c);
610	}
611	}
612
613	if ($sanitise_quote eq '//') {
614	$sanitise_quote = '';
615	}
616
617	# The pathname on a #include may be surrounded by '<' and '>'.
618	if ($res =~ /^.\s\#\sinclude\s+\<(.*)\>/) {
619	my $clean = 'X' x length($1);
620	$res =~ s@\<.*\>@<$clean>@;
621
622	# The whole of a #error is a string.
623	} elsif ($res =~ /^.\s\#\s(?:error\|warning)\s+(.*)\b/) {
624	my $clean = 'X' x length($1);
625	$res =~ s@(\#\s(?:error\|warning)\s+).@$1$clean@;
626	}
627
628	return $res;
629	}
630
631	sub ctx_statement_block {
632	my ($linenr, $remain, $off) = @_;
633	my $line = $linenr - 1;
634	my $blk = '';
635	my $soff = $off;
636	my $coff = $off - 1;
637	my $coff_set = 0;
638
639	my $loff = 0;
640
641	my $type = '';
642	my $level = 0;
643	my @stack = ();
644	my $p;
645	my $c;
646	my $len = 0;
647
648	my $remainder;
649	while (1) {
650	@stack = (['', 0]) if ($#stack == -1);
651
652	#warn "CSB: blk<$blk> remain<$remain>\n";
653	# If we are about to drop off the end, pull in more
654	# context.
655	if ($off >= $len) {
656	for (; $remain > 0; $line++) {
657	last if (!defined $lines[$line]);
658	next if ($lines[$line] =~ /^-/);
659	$remain--;
660	$loff = $len;
661	$blk .= $lines[$line] . "\n";
662	$len = length($blk);
663	$line++;
664	last;
665	}
666	# Bail if there is no further context.
667	#warn "CSB: blk<$blk> off<$off> len<$len>\n";
668	if ($off >= $len) {
669	last;
670	}
671	if ($level == 0 && substr($blk, $off) =~ /^.\s#\sdefine/) {
672	$level++;
673	$type = '#';
674	}
675	}
676	$p = $c;
677	$c = substr($blk, $off, 1);
678	$remainder = substr($blk, $off);
679
680	#warn "CSB: c<$c> type<$type> level<$level> remainder<$remainder> coff_set<$coff_set>\n";
681
682	# Handle nested #if/#else.
683	if ($remainder =~ /^#\s*(?:ifndef\|ifdef\|if)\s/) {
684	push(@stack, [ $type, $level ]);
685	} elsif ($remainder =~ /^#\s*(?:else\|elif)\b/) {
686	($type, $level) = @{$stack[$#stack - 1]};
687	} elsif ($remainder =~ /^#\s*endif\b/) {
688	($type, $level) = @{pop(@stack)};
689	}
690
691	# Statement ends at the ';' or a close '}' at the
692	# outermost level.
693	if ($level == 0 && $c eq ';') {
694	last;
695	}
696
697	# An else is really a conditional as long as its not else if
698	if ($level == 0 && $coff_set == 0 &&
699	(!defined($p) \|\| $p =~ /(?:\s\|\}\|\+)/) &&
700	$remainder =~ /^(else)(?:\s\|{)/ &&
701	$remainder !~ /^else\s+if\b/) {
702	$coff = $off + length($1) - 1;
703	$coff_set = 1;
704	#warn "CSB: mark coff<$coff> soff<$soff> 1<$1>\n";
705	#warn "[" . substr($blk, $soff, $coff - $soff + 1) . "]\n";
706	}
707
708	if (($type eq '' \|\| $type eq '(') && $c eq '(') {
709	$level++;
710	$type = '(';
711	}
712	if ($type eq '(' && $c eq ')') {
713	$level--;
714	$type = ($level != 0)? '(' : '';
715
716	if ($level == 0 && $coff < $soff) {
717	$coff = $off;
718	$coff_set = 1;
719	#warn "CSB: mark coff<$coff>\n";
720	}
721	}
722	if (($type eq '' \|\| $type eq '{') && $c eq '{') {
723	$level++;
724	$type = '{';
725	}
726	if ($type eq '{' && $c eq '}') {
727	$level--;
728	$type = ($level != 0)? '{' : '';
729
730	if ($level == 0) {
731	if (substr($blk, $off + 1, 1) eq ';') {
732	$off++;
733	}
734	last;
735	}
736	}
737	# Preprocessor commands end at the newline unless escaped.
738	if ($type eq '#' && $c eq "\n" && $p ne "\\") {
739	$level--;
740	$type = '';
741	$off++;
742	last;
743	}
744	$off++;
745	}
746	# We are truly at the end, so shuffle to the next line.
747	if ($off == $len) {
748	$loff = $len + 1;
749	$line++;
750	$remain--;
751	}
752
753	my $statement = substr($blk, $soff, $off - $soff + 1);
754	my $condition = substr($blk, $soff, $coff - $soff + 1);
755
756	#warn "STATEMENT<$statement>\n";
757	#warn "CONDITION<$condition>\n";
758
759	#print "coff<$coff> soff<$off> loff<$loff>\n";
760
761	return ($statement, $condition,
762	$line, $remain + 1, $off - $loff + 1, $level);
763	}
764
765	sub statement_lines {
766	my ($stmt) = @_;
767
768	# Strip the diff line prefixes and rip blank lines at start and end.
769	$stmt =~ s/(^\|\n)./$1/g;
770	$stmt =~ s/^\s*//;
771	$stmt =~ s/\s*$//;
772
773	my @stmt_lines = ($stmt =~ /\n/g);
774
775	return $#stmt_lines + 2;
776	}
777
778	sub statement_rawlines {
779	my ($stmt) = @_;
780
781	my @stmt_lines = ($stmt =~ /\n/g);
782
783	return $#stmt_lines + 2;
784	}
785
786	sub statement_block_size {
787	my ($stmt) = @_;
788
789	$stmt =~ s/(^\|\n)./$1/g;
790	$stmt =~ s/^\s*{//;
791	$stmt =~ s/}\s*$//;
792	$stmt =~ s/^\s*//;
793	$stmt =~ s/\s*$//;
794
795	my @stmt_lines = ($stmt =~ /\n/g);
796	my @stmt_statements = ($stmt =~ /;/g);
797
798	my $stmt_lines = $#stmt_lines + 2;
799	my $stmt_statements = $#stmt_statements + 1;
800
801	if ($stmt_lines > $stmt_statements) {
802	return $stmt_lines;
803	} else {
804	return $stmt_statements;
805	}
806	}
807
808	sub ctx_statement_full {
809	my ($linenr, $remain, $off) = @_;
810	my ($statement, $condition, $level);
811
812	my (@chunks);
813
814	# Grab the first conditional/block pair.
815	($statement, $condition, $linenr, $remain, $off, $level) =
816	ctx_statement_block($linenr, $remain, $off);
817	#print "F: c<$condition> s<$statement> remain<$remain>\n";
818	push(@chunks, [ $condition, $statement ]);
819	if (!($remain > 0 && $condition =~ /^\s(?:\n[+-])?\s(?:if\|else\|do)\b/s)) {
820	return ($level, $linenr, @chunks);
821	}
822
823	# Pull in the following conditional/block pairs and see if they
824	# could continue the statement.
825	for (;;) {
826	($statement, $condition, $linenr, $remain, $off, $level) =
827	ctx_statement_block($linenr, $remain, $off);
828	#print "C: c<$condition> s<$statement> remain<$remain>\n";
829	last if (!($remain > 0 && $condition =~ /^(?:\s\n[+-])\s*(?:else\|do)\b/s));
830	#print "C: push\n";
831	push(@chunks, [ $condition, $statement ]);
832	}
833
834	return ($level, $linenr, @chunks);
835	}
836
837	sub ctx_block_get {
838	my ($linenr, $remain, $outer, $open, $close, $off) = @_;
839	my $line;
840	my $start = $linenr - 1;
841	my $blk = '';
842	my @o;
843	my @c;
844	my @res = ();
845
846	my $level = 0;
847	my @stack = ($level);
848	for ($line = $start; $remain > 0; $line++) {
849	next if ($rawlines[$line] =~ /^-/);
850	$remain--;
851
852	$blk .= $rawlines[$line];
853
854	# Handle nested #if/#else.
855	if ($lines[$line] =~ /^.\s#\s(?:ifndef\|ifdef\|if)\s/) {
856	push(@stack, $level);
857	} elsif ($lines[$line] =~ /^.\s#\s(?:else\|elif)\b/) {
858	$level = $stack[$#stack - 1];
859	} elsif ($lines[$line] =~ /^.\s#\sendif\b/) {
860	$level = pop(@stack);
861	}
862
863	foreach my $c (split(//, $lines[$line])) {
864	##print "C<$c>L<$level><$open$close>O<$off>\n";
865	if ($off > 0) {
866	$off--;
867	next;
868	}
869
870	if ($c eq $close && $level > 0) {
871	$level--;
872	last if ($level == 0);
873	} elsif ($c eq $open) {
874	$level++;
875	}
876	}
877
878	if (!$outer \|\| $level <= 1) {
879	push(@res, $rawlines[$line]);
880	}
881
882	last if ($level == 0);
883	}
884
885	return ($level, @res);
886	}
887	sub ctx_block_outer {
888	my ($linenr, $remain) = @_;
889
890	my ($level, @r) = ctx_block_get($linenr, $remain, 1, '{', '}', 0);
891	return @r;
892	}
893	sub ctx_block {
894	my ($linenr, $remain) = @_;
895
896	my ($level, @r) = ctx_block_get($linenr, $remain, 0, '{', '}', 0);
897	return @r;
898	}
899	sub ctx_statement {
900	my ($linenr, $remain, $off) = @_;
901
902	my ($level, @r) = ctx_block_get($linenr, $remain, 0, '(', ')', $off);
903	return @r;
904	}
905	sub ctx_block_level {
906	my ($linenr, $remain) = @_;
907
908	return ctx_block_get($linenr, $remain, 0, '{', '}', 0);
909	}
910	sub ctx_statement_level {
911	my ($linenr, $remain, $off) = @_;
912
913	return ctx_block_get($linenr, $remain, 0, '(', ')', $off);
914	}
915
916	sub ctx_locate_comment {
917	my ($first_line, $end_line) = @_;
918
919	# Catch a comment on the end of the line itself.
920	my ($current_comment) = ($rawlines[$end_line - 1] =~ m@.(/\.\/)\s(?:\\\s)?$@);
921	return $current_comment if (defined $current_comment);
922
923	# Look through the context and try and figure out if there is a
924	# comment.
925	my $in_comment = 0;
926	$current_comment = '';
927	for (my $linenr = $first_line; $linenr < $end_line; $linenr++) {
928	my $line = $rawlines[$linenr - 1];
929	#warn " $line\n";
930	if ($linenr == $first_line and $line =~ m@^.\s\@) {
931	$in_comment = 1;
932	}
933	if ($line =~ m@/\*@) {
934	$in_comment = 1;
935	}
936	if (!$in_comment && $current_comment ne '') {
937	$current_comment = '';
938	}
939	$current_comment .= $line . "\n" if ($in_comment);
940	if ($line =~ m@\*/@) {
941	$in_comment = 0;
942	}
943	}
944
945	chomp($current_comment);
946	return($current_comment);
947	}
948	sub ctx_has_comment {
949	my ($first_line, $end_line) = @_;
950	my $cmt = ctx_locate_comment($first_line, $end_line);
951
952	##print "LINE: $rawlines[$end_line - 1 ]\n";
953	##print "CMMT: $cmt\n";
954
955	return ($cmt ne '');
956	}
957
958	sub raw_line {
959	my ($linenr, $cnt) = @_;
960
961	my $offset = $linenr - 1;
962	$cnt++;
963
964	my $line;
965	while ($cnt) {
966	$line = $rawlines[$offset++];
967	next if (defined($line) && $line =~ /^-/);
968	$cnt--;
969	}
970
971	return $line;
972	}
973
974	sub cat_vet {
975	my ($vet) = @_;
976	my ($res, $coded);
977
978	$res = '';
979	while ($vet =~ /([^[:cntrl:]]*)([[:cntrl:]]\|$)/g) {
980	$res .= $1;
981	if ($2 ne '') {
982	$coded = sprintf("^%c", unpack('C', $2) + 64);
983	$res .= $coded;
984	}
985	}
986	$res =~ s/$/\$/;
987
988	return $res;
989	}
990
991	my $av_preprocessor = 0;
992	my $av_pending;
993	my @av_paren_type;
994	my $av_pend_colon;
995
996	sub annotate_reset {
997	$av_preprocessor = 0;
998	$av_pending = '_';
999	@av_paren_type = ('E');
1000	$av_pend_colon = 'O';
1001	}
1002
1003	sub annotate_values {
1004	my ($stream, $type) = @_;
1005
1006	my $res;
1007	my $var = '_' x length($stream);
1008	my $cur = $stream;
1009
1010	print "$stream\n" if ($dbg_values > 1);
1011
1012	while (length($cur)) {
1013	@av_paren_type = ('E') if ($#av_paren_type < 0);
1014	print " <" . join('', @av_paren_type) .
1015	"> <$type> <$av_pending>" if ($dbg_values > 1);
1016	if ($cur =~ /^(\s+)/o) {
1017	print "WS($1)\n" if ($dbg_values > 1);
1018	if ($1 =~ /\n/ && $av_preprocessor) {
1019	$type = pop(@av_paren_type);
1020	$av_preprocessor = 0;
1021	}
1022
1023	} elsif ($cur =~ /^($\s$Type\s)$/ && $av_pending eq '_') {
1024	print "CAST($1)\n" if ($dbg_values > 1);
1025	push(@av_paren_type, $type);
1026	$type = 'c';
1027
1028	} elsif ($cur =~ /^($Type)\s(?:$Ident\|,\|\)\|\(\|\s$)/) {
1029	print "DECLARE($1)\n" if ($dbg_values > 1);
1030	$type = 'T';
1031
1032	} elsif ($cur =~ /^($Modifier)\s*/) {
1033	print "MODIFIER($1)\n" if ($dbg_values > 1);
1034	$type = 'T';
1035
1036	} elsif ($cur =~ /^(\#\sdefine\s$Ident)(\(?)/o) {
1037	print "DEFINE($1,$2)\n" if ($dbg_values > 1);
1038	$av_preprocessor = 1;
1039	push(@av_paren_type, $type);
1040	if ($2 ne '') {
1041	$av_pending = 'N';
1042	}
1043	$type = 'E';
1044
1045	} elsif ($cur =~ /^(\#\s(?:undef\s$Ident\|include\b))/o) {
1046	print "UNDEF($1)\n" if ($dbg_values > 1);
1047	$av_preprocessor = 1;
1048	push(@av_paren_type, $type);
1049
1050	} elsif ($cur =~ /^(\#\s*(?:ifdef\|ifndef\|if))/o) {
1051	print "PRE_START($1)\n" if ($dbg_values > 1);
1052	$av_preprocessor = 1;
1053
1054	push(@av_paren_type, $type);
1055	push(@av_paren_type, $type);
1056	$type = 'E';
1057
1058	} elsif ($cur =~ /^(\#\s*(?:else\|elif))/o) {
1059	print "PRE_RESTART($1)\n" if ($dbg_values > 1);
1060	$av_preprocessor = 1;
1061
1062	push(@av_paren_type, $av_paren_type[$#av_paren_type]);
1063
1064	$type = 'E';
1065
1066	} elsif ($cur =~ /^(\#\s*(?:endif))/o) {
1067	print "PRE_END($1)\n" if ($dbg_values > 1);
1068
1069	$av_preprocessor = 1;
1070
1071	# Assume all arms of the conditional end as this
1072	# one does, and continue as if the #endif was not here.
1073	pop(@av_paren_type);
1074	push(@av_paren_type, $type);
1075	$type = 'E';
1076
1077	} elsif ($cur =~ /^(\\\n)/o) {
1078	print "PRECONT($1)\n" if ($dbg_values > 1);
1079
1080	} elsif ($cur =~ /^(__attribute__)\s*\(?/o) {
1081	print "ATTR($1)\n" if ($dbg_values > 1);
1082	$av_pending = $type;
1083	$type = 'N';
1084
1085	} elsif ($cur =~ /^(sizeof)\s*(\()?/o) {
1086	print "SIZEOF($1)\n" if ($dbg_values > 1);
1087	if (defined $2) {
1088	$av_pending = 'V';
1089	}
1090	$type = 'N';
1091
1092	} elsif ($cur =~ /^(if\|while\|for)\b/o) {
1093	print "COND($1)\n" if ($dbg_values > 1);
1094	$av_pending = 'E';
1095	$type = 'N';
1096
1097	} elsif ($cur =~/^(case)/o) {
1098	print "CASE($1)\n" if ($dbg_values > 1);
1099	$av_pend_colon = 'C';
1100	$type = 'N';
1101
1102	} elsif ($cur =~/^(return\|else\|goto\|typeof\|__typeof__)\b/o) {
1103	print "KEYWORD($1)\n" if ($dbg_values > 1);
1104	$type = 'N';
1105
1106	} elsif ($cur =~ /^(\()/o) {
1107	print "PAREN('$1')\n" if ($dbg_values > 1);
1108	push(@av_paren_type, $av_pending);
1109	$av_pending = '_';
1110	$type = 'N';
1111
1112	} elsif ($cur =~ /^(\))/o) {
1113	my $new_type = pop(@av_paren_type);
1114	if ($new_type ne '_') {
1115	$type = $new_type;
1116	print "PAREN('$1') -> $type\n"
1117	if ($dbg_values > 1);
1118	} else {
1119	print "PAREN('$1')\n" if ($dbg_values > 1);
1120	}
1121
1122	} elsif ($cur =~ /^($Ident)\s*\(/o) {
1123	print "FUNC($1)\n" if ($dbg_values > 1);
1124	$type = 'V';
1125	$av_pending = 'V';
1126
1127	} elsif ($cur =~ /^($Ident\s):(?:\s\d+\s*(,\|=\|;))?/) {
1128	if (defined $2 && $type eq 'C' \|\| $type eq 'T') {
1129	$av_pend_colon = 'B';
1130	} elsif ($type eq 'E') {
1131	$av_pend_colon = 'L';
1132	}
1133	print "IDENT_COLON($1,$type>$av_pend_colon)\n" if ($dbg_values > 1);
1134	$type = 'V';
1135
1136	} elsif ($cur =~ /^($Ident\|$Constant)/o) {
1137	print "IDENT($1)\n" if ($dbg_values > 1);
1138	$type = 'V';
1139
1140	} elsif ($cur =~ /^($Assignment)/o) {
1141	print "ASSIGN($1)\n" if ($dbg_values > 1);
1142	$type = 'N';
1143
1144	} elsif ($cur =~/^(;\|{\|})/) {
1145	print "END($1)\n" if ($dbg_values > 1);
1146	$type = 'E';
1147	$av_pend_colon = 'O';
1148
1149	} elsif ($cur =~/^(,)/) {
1150	print "COMMA($1)\n" if ($dbg_values > 1);
1151	$type = 'C';
1152
1153	} elsif ($cur =~ /^(\?)/o) {
1154	print "QUESTION($1)\n" if ($dbg_values > 1);
1155	$type = 'N';
1156
1157	} elsif ($cur =~ /^(:)/o) {
1158	print "COLON($1,$av_pend_colon)\n" if ($dbg_values > 1);
1159
1160	substr($var, length($res), 1, $av_pend_colon);
1161	if ($av_pend_colon eq 'C' \|\| $av_pend_colon eq 'L') {
1162	$type = 'E';
1163	} else {
1164	$type = 'N';
1165	}
1166	$av_pend_colon = 'O';
1167
1168	} elsif ($cur =~ /^(\[)/o) {
1169	print "CLOSE($1)\n" if ($dbg_values > 1);
1170	$type = 'N';
1171
1172	} elsif ($cur =~ /^(-(?![->])\|\+(?!\+)\|\*\|\&\&\|\&)/o) {
1173	my $variant;
1174
1175	print "OPV($1)\n" if ($dbg_values > 1);
1176	if ($type eq 'V') {
1177	$variant = 'B';
1178	} else {
1179	$variant = 'U';
1180	}
1181
1182	substr($var, length($res), 1, $variant);
1183	$type = 'N';
1184
1185	} elsif ($cur =~ /^($Operators)/o) {
1186	print "OP($1)\n" if ($dbg_values > 1);
1187	if ($1 ne '++' && $1 ne '--') {
1188	$type = 'N';
1189	}
1190
1191	} elsif ($cur =~ /(^.)/o) {
1192	print "C($1)\n" if ($dbg_values > 1);
1193	}
1194	if (defined $1) {
1195	$cur = substr($cur, length($1));
1196	$res .= $type x length($1);
1197	}
1198	}
1199
1200	return ($res, $var);
1201	}
1202
1203	sub possible {
1204	my ($possible, $line) = @_;
1205	my $notPermitted = qr{(?:
1206	^(?:
1207	$Modifier\|
1208	$Storage\|
1209	$Type\|
1210	DEFINE_\S+
1211	)$\|
1212	^(?:
1213	goto\|
1214	return\|
1215	case\|
1216	else\|
1217	asm\|__asm__\|
1218	do\|
1219	\#\|
1220	\#\#\|
1221	)(?:\s\|$)\|
1222	^(?:typedef\|struct\|enum)\b
1223	)}x;
1224	warn "CHECK<$possible> ($line)\n" if ($dbg_possible > 2);
1225	if ($possible !~ $notPermitted) {
1226	# Check for modifiers.
1227	$possible =~ s/\s$Storage\s//g;
1228	$possible =~ s/\s$Sparse\s//g;
1229	if ($possible =~ /^\s*$/) {
1230
1231	} elsif ($possible =~ /\s/) {
1232	$possible =~ s/\s$Type\s//g;
1233	for my $modifier (split(' ', $possible)) {
1234	if ($modifier !~ $notPermitted) {
1235	warn "MODIFIER: $modifier ($possible) ($line)\n" if ($dbg_possible);
1236	push(@modifierList, $modifier);
1237	}
1238	}
1239
1240	} else {
1241	warn "POSSIBLE: $possible ($line)\n" if ($dbg_possible);
1242	push(@typeList, $possible);
1243	}
1244	build_types();
1245	} else {
1246	warn "NOTPOSS: $possible ($line)\n" if ($dbg_possible > 1);
1247	}
1248	}
1249
1250	my $prefix = '';
1251
1252	sub show_type {
1253	return !defined $ignore_type{$_[0]};
1254	}
1255
1256	sub report {
1257	if (!show_type($_[1]) \|\|
1258	(defined $tst_only && $_[2] !~ /\Q$tst_only\E/)) {
1259	return 0;
1260	}
1261	my $line;
1262	if ($show_types) {
1263	$line = "$prefix$_[0]:$_[1]: $_[2]\n";
1264	} else {
1265	$line = "$prefix$_[0]: $_[2]\n";
1266	}
1267	$line = (split('\n', $line))[0] . "\n" if ($terse);
1268
1269	push(our @report, $line);
1270
1271	return 1;
1272	}
1273	sub report_dump {
1274	our @report;
1275	}
1276
1277	sub ERROR {
1278	if (report("ERROR", $_[0], $_[1])) {
1279	our $clean = 0;
1280	our $cnt_error++;
1281	}
1282	}
1283	sub WARN {
1284	if (report("WARNING", $_[0], $_[1])) {
1285	our $clean = 0;
1286	our $cnt_warn++;
1287	}
1288	}
1289	sub CHK {
1290	if ($check && report("CHECK", $_[0], $_[1])) {
1291	our $clean = 0;
1292	our $cnt_chk++;
1293	}
1294	}
1295
1296	sub check_absolute_file {
1297	my ($absolute, $herecurr) = @_;
1298	my $file = $absolute;
1299
1300	##print "absolute<$absolute>\n";
1301
1302	# See if any suffix of this path is a path within the tree.
1303	while ($file =~ s@^[^/]*/@@) {
1304	if (-f "$root/$file") {
1305	##print "file<$file>\n";
1306	last;
1307	}
1308	}
1309	if (! -f _) {
1310	return 0;
1311	}
1312
1313	# It is, so see if the prefix is acceptable.
1314	my $prefix = $absolute;
1315	substr($prefix, -length($file)) = '';
1316
1317	##print "prefix<$prefix>\n";
1318	if ($prefix ne ".../") {
1319	WARN("USE_RELATIVE_PATH",
1320	"use relative pathname instead of absolute in changelog text\n" . $herecurr);
1321	}
1322	}
1323
1324	sub pos_last_openparen {
1325	my ($line) = @_;
1326
1327	my $pos = 0;
1328
1329	my $opens = $line =~ tr/\(/\(/;
1330	my $closes = $line =~ tr/\)/\)/;
1331
1332	my $last_openparen = 0;
1333
1334	if (($opens == 0) \|\| ($closes >= $opens)) {
1335	return -1;
1336	}
1337
1338	my $len = length($line);
1339
1340	for ($pos = 0; $pos < $len; $pos++) {
1341	my $string = substr($line, $pos);
1342	if ($string =~ /^($FuncArg\|$balanced_parens)/) {
1343	$pos += length($1) - 1;
1344	} elsif (substr($line, $pos, 1) eq '(') {
1345	$last_openparen = $pos;
1346	} elsif (index($string, '(') == -1) {
1347	last;
1348	}
1349	}
1350
1351	return $last_openparen + 1;
1352	}
1353
1354	sub process {
1355	my $filename = shift;
1356
1357	my $linenr=0;
1358	my $prevline="";
1359	my $prevrawline="";
1360	my $stashline="";
1361	my $stashrawline="";
1362
1363	my $length;
1364	my $indent;
1365	my $previndent=0;
1366	my $stashindent=0;
1367
1368	our $clean = 1;
1369	my $signoff = 0;
1370	my $is_patch = 0;
1371
1372	my $in_header_lines = 1;
1373	my $in_commit_log = 0; #Scanning lines before patch
1374
1375	my $non_utf8_charset = 0;
1376
1377	our @report = ();
1378	our $cnt_lines = 0;
1379	our $cnt_error = 0;
1380	our $cnt_warn = 0;
1381	our $cnt_chk = 0;
1382
1383	# Trace the real file/line as we go.
1384	my $realfile = '';
1385	my $realline = 0;
1386	my $realcnt = 0;
1387	my $here = '';
1388	my $in_comment = 0;
1389	my $comment_edge = 0;
1390	my $first_line = 0;
1391	my $p1_prefix = '';
1392
1393	my $prev_values = 'E';
1394
1395	# suppression flags
1396	my %suppress_ifbraces;
1397	my %suppress_whiletrailers;
1398	my %suppress_export;
1399	my $suppress_statement = 0;
1400
1401	my %camelcase = ();
1402
1403	# Pre-scan the patch sanitizing the lines.
1404	# Pre-scan the patch looking for any __setup documentation.
1405	#
1406	my @setup_docs = ();
1407	my $setup_docs = 0;
1408
1409	sanitise_line_reset();
1410	my $line;
1411	foreach my $rawline (@rawlines) {
1412	$linenr++;
1413	$line = $rawline;
1414
1415	if ($rawline=~/^\+\+\+\s+(\S+)/) {
1416	$setup_docs = 0;
1417	if ($1 =~ m@Documentation/kernel-parameters.txt$@) {
1418	$setup_docs = 1;
1419	}
1420	#next;
1421	}
1422	if ($rawline=~/^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@/) {
1423	$realline=$1-1;
1424	if (defined $2) {
1425	$realcnt=$3+1;
1426	} else {
1427	$realcnt=1+1;
1428	}
1429	$in_comment = 0;
1430
1431	# Guestimate if this is a continuing comment. Run
1432	# the context looking for a comment "edge". If this
1433	# edge is a close comment then we must be in a comment
1434	# at context start.
1435	my $edge;
1436	my $cnt = $realcnt;
1437	for (my $ln = $linenr + 1; $cnt > 0; $ln++) {
1438	next if (defined $rawlines[$ln - 1] &&
1439	$rawlines[$ln - 1] =~ /^-/);
1440	$cnt--;
1441	#print "RAW<$rawlines[$ln - 1]>\n";
1442	last if (!defined $rawlines[$ln - 1]);
1443	if ($rawlines[$ln - 1] =~ m@(/\\|\/)@ &&
1444	$rawlines[$ln - 1] !~ m@"[^"](?:/\\|\/)[^"]"@) {
1445	($edge) = $1;
1446	last;
1447	}
1448	}
1449	if (defined $edge && $edge eq '*/') {
1450	$in_comment = 1;
1451	}
1452
1453	# Guestimate if this is a continuing comment. If this
1454	# is the start of a diff block and this line starts
1455	# ' *' then it is very likely a comment.
1456	if (!defined $edge &&
1457	$rawlines[$linenr] =~ m@^.\s(?:\\+\| \)(?:\s\|$)@)
1458	{
1459	$in_comment = 1;
1460	}
1461
1462	##print "COMMENT:$in_comment edge<$edge> $rawline\n";
1463	sanitise_line_reset($in_comment);
1464
1465	} elsif ($realcnt && $rawline =~ /^(?:\+\| \|$)/) {
1466	# Standardise the strings and chars within the input to
1467	# simplify matching -- only bother with positive lines.
1468	$line = sanitise_line($rawline);
1469	}
1470	push(@lines, $line);
1471
1472	if ($realcnt > 1) {
1473	$realcnt-- if ($line =~ /^(?:\+\| \|$)/);
1474	} else {
1475	$realcnt = 0;
1476	}
1477
1478	#print "==>$rawline\n";
1479	#print "-->$line\n";
1480
1481	if ($setup_docs && $line =~ /^\+/) {
1482	push(@setup_docs, $line);
1483	}
1484	}
1485
1486	$prefix = '';
1487
1488	$realcnt = 0;
1489	$linenr = 0;
1490	foreach my $line (@lines) {
1491	$linenr++;
1492
1493	my $rawline = $rawlines[$linenr - 1];
1494
1495	#extract the line range in the file after the patch is applied
1496	if ($line=~/^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@/) {
1497	$is_patch = 1;
1498	$first_line = $linenr + 1;
1499	$realline=$1-1;
1500	if (defined $2) {
1501	$realcnt=$3+1;
1502	} else {
1503	$realcnt=1+1;
1504	}
1505	annotate_reset();
1506	$prev_values = 'E';
1507
1508	%suppress_ifbraces = ();
1509	%suppress_whiletrailers = ();
1510	%suppress_export = ();
1511	$suppress_statement = 0;
1512	next;
1513
1514	# track the line number as we move through the hunk, note that
1515	# new versions of GNU diff omit the leading space on completely
1516	# blank context lines so we need to count that too.
1517	} elsif ($line =~ /^( \|\+\|$)/) {
1518	$realline++;
1519	$realcnt-- if ($realcnt != 0);
1520
1521	# Measure the line length and indent.
1522	($length, $indent) = line_stats($rawline);
1523
1524	# Track the previous line.
1525	($prevline, $stashline) = ($stashline, $line);
1526	($previndent, $stashindent) = ($stashindent, $indent);
1527	($prevrawline, $stashrawline) = ($stashrawline, $rawline);
1528
1529	#warn "line<$line>\n";
1530
1531	} elsif ($realcnt == 1) {
1532	$realcnt--;
1533	}
1534
1535	my $hunk_line = ($realcnt != 0);
1536
1537	#make up the handle for any error we report on this line
1538	$prefix = "$filename:$realline: " if ($emacs && $file);
1539	$prefix = "$filename:$linenr: " if ($emacs && !$file);
1540
1541	$here = "#$linenr: " if (!$file);
1542	$here = "#$realline: " if ($file);
1543
1544	# extract the filename as it passes
1545	if ($line =~ /^diff --git.*?(\S+)$/) {
1546	$realfile = $1;
1547	$realfile =~ s@^([^/]*)/@@;
1548	$in_commit_log = 0;
1549	} elsif ($line =~ /^\+\+\+\s+(\S+)/) {
1550	$realfile = $1;
1551	$realfile =~ s@^([^/]*)/@@;
1552	$in_commit_log = 0;
1553
1554	$p1_prefix = $1;
1555	if (!$file && $tree && $p1_prefix ne '' &&
1556	-e "$root/$p1_prefix") {
1557	WARN("PATCH_PREFIX",
1558	"patch prefix '$p1_prefix' exists, appears to be a -p0 patch\n");
1559	}
1560
1561	if ($realfile =~ m@^include/asm/@) {
1562	ERROR("MODIFIED_INCLUDE_ASM",
1563	"do not modify files in include/asm, change architecture specific files in include/asm-<architecture>\n" . "$here$rawline\n");
1564	}
1565	next;
1566	}
1567
1568	$here .= "FILE: $realfile:$realline:" if ($realcnt != 0);
1569
1570	my $hereline = "$here\n$rawline\n";
1571	my $herecurr = "$here\n$rawline\n";
1572	my $hereprev = "$here\n$prevrawline\n$rawline\n";
1573
1574	$cnt_lines++ if ($realcnt != 0);
1575
1576	# Check for incorrect file permissions
1577	if ($line =~ /^new (file )?mode.*[7531]\d{0,2}$/) {
1578	my $permhere = $here . "FILE: $realfile\n";
1579	if ($realfile =~ /(Makefile\|Kconfig\|\.c\|\.h\|\.S\|\.tmpl)$/) {
1580	ERROR("EXECUTE_PERMISSIONS",
1581	"do not set execute permissions for source files\n" . $permhere);
1582	}
1583	}
1584
1585	# Check the patch for a signoff:
1586	if ($line =~ /^\s*signed-off-by:/i) {
1587	$signoff++;
1588	$in_commit_log = 0;
1589	}
1590
1591	# Check signature styles
1592	if (!$in_header_lines &&
1593	$line =~ /^(\s)([a-z0-9_-]+by:\|$signature_tags)(\s)(.*)/i) {
1594	my $space_before = $1;
1595	my $sign_off = $2;
1596	my $space_after = $3;
1597	my $email = $4;
1598	my $ucfirst_sign_off = ucfirst(lc($sign_off));
1599
1600	if ($sign_off !~ /$signature_tags/) {
1601	WARN("BAD_SIGN_OFF",
1602	"Non-standard signature: $sign_off\n" . $herecurr);
1603	}
1604	if (defined $space_before && $space_before ne "") {
1605	WARN("BAD_SIGN_OFF",
1606	"Do not use whitespace before $ucfirst_sign_off\n" . $herecurr);
1607	}
1608	if ($sign_off =~ /-by:$/i && $sign_off ne $ucfirst_sign_off) {
1609	WARN("BAD_SIGN_OFF",
1610	"'$ucfirst_sign_off' is the preferred signature form\n" . $herecurr);
1611	}
1612	if (!defined $space_after \|\| $space_after ne " ") {
1613	WARN("BAD_SIGN_OFF",
1614	"Use a single space after $ucfirst_sign_off\n" . $herecurr);
1615	}
1616
1617	my ($email_name, $email_address, $comment) = parse_email($email);
1618	my $suggested_email = format_email(($email_name, $email_address));
1619	if ($suggested_email eq "") {
1620	ERROR("BAD_SIGN_OFF",
1621	"Unrecognized email address: '$email'\n" . $herecurr);
1622	} else {
1623	my $dequoted = $suggested_email;
1624	$dequoted =~ s/^"//;
1625	$dequoted =~ s/" </ </;
1626	# Don't force email to have quotes
1627	# Allow just an angle bracketed address
1628	if ("$dequoted$comment" ne $email &&
1629	"<$email_address>$comment" ne $email &&
1630	"$suggested_email$comment" ne $email) {
1631	WARN("BAD_SIGN_OFF",
1632	"email address '$email' might be better as '$suggested_email$comment'\n" . $herecurr);
1633	}
1634	}
1635	}
1636
1637	# Check for wrappage within a valid hunk of the file
1638	if ($realcnt != 0 && $line !~ m{^(?:\+\|-\| \|\\ No newline\|$)}) {
1639	ERROR("CORRUPTED_PATCH",
1640	"patch seems to be corrupt (line wrapped?)\n" .
1641	$herecurr) if (!$emitted_corrupt++);
1642	}
1643
1644	# Check for absolute kernel paths.
1645	if ($tree) {
1646	while ($line =~ m{(?:^\|\s)(/\S*)}g) {
1647	my $file = $1;
1648
1649	if ($file =~ m{^(.*?)(?::\d+)+:?$} &&
1650	check_absolute_file($1, $herecurr)) {
1651	#
1652	} else {
1653	check_absolute_file($file, $herecurr);
1654	}
1655	}
1656	}
1657
1658	# UTF-8 regex found at http://www.w3.org/International/questions/qa-forms-utf-8.en.php
1659	if (($realfile =~ /^$/ \|\| $line =~ /^\+/) &&
1660	$rawline !~ m/^$UTF8*$/) {
1661	my ($utf8_prefix) = ($rawline =~ /^($UTF8*)/);
1662
1663	my $blank = copy_spacing($rawline);
1664	my $ptr = substr($blank, 0, length($utf8_prefix)) . "^";
1665	my $hereptr = "$hereline$ptr\n";
1666
1667	CHK("INVALID_UTF8",
1668	"Invalid UTF-8, patch and commit message should be encoded in UTF-8\n" . $hereptr);
1669	}
1670
1671	# Check if it's the start of a commit log
1672	# (not a header line and we haven't seen the patch filename)
1673	if ($in_header_lines && $realfile =~ /^$/ &&
1674	$rawline !~ /^(commit\b\|from\b\|[\w-]+:).+$/i) {
1675	$in_header_lines = 0;
1676	$in_commit_log = 1;
1677	}
1678
1679	# Check if there is UTF-8 in a commit log when a mail header has explicitly
1680	# declined it, i.e defined some charset where it is missing.
1681	if ($in_header_lines &&
1682	$rawline =~ /^Content-Type:.+charset="(.+)".*$/ &&
1683	$1 !~ /utf-8/i) {
1684	$non_utf8_charset = 1;
1685	}
1686
1687	if ($in_commit_log && $non_utf8_charset && $realfile =~ /^$/ &&
1688	$rawline =~ /$NON_ASCII_UTF8/) {
1689	WARN("UTF8_BEFORE_PATCH",
1690	"8-bit UTF-8 used in possible commit log\n" . $herecurr);
1691	}
1692
1693	# ignore non-hunk lines and lines being removed
1694	next if (!$hunk_line \|\| $line =~ /^-/);
1695
1696	#trailing whitespace
1697	if ($line =~ /^\+.*\015/) {
1698	my $herevet = "$here\n" . cat_vet($rawline) . "\n";
1699	ERROR("DOS_LINE_ENDINGS",
1700	"DOS line endings\n" . $herevet);
1701
1702	} elsif ($rawline =~ /^\+.*\S\s+$/ \|\| $rawline =~ /^\+\s+$/) {
1703	my $herevet = "$here\n" . cat_vet($rawline) . "\n";
1704	ERROR("TRAILING_WHITESPACE",
1705	"trailing whitespace\n" . $herevet);
1706	$rpt_cleaners = 1;
1707	}
1708
1709	# check for Kconfig help text having a real description
1710	# Only applies when adding the entry originally, after that we do not have
1711	# sufficient context to determine whether it is indeed long enough.
1712	if ($realfile =~ /Kconfig/ &&
1713	$line =~ /.\s*config\s+/) {
1714	my $length = 0;
1715	my $cnt = $realcnt;
1716	my $ln = $linenr + 1;
1717	my $f;
1718	my $is_start = 0;
1719	my $is_end = 0;
1720	for (; $cnt > 0 && defined $lines[$ln - 1]; $ln++) {
1721	$f = $lines[$ln - 1];
1722	$cnt-- if ($lines[$ln - 1] !~ /^-/);
1723	$is_end = $lines[$ln - 1] =~ /^\+/;
1724
1725	next if ($f =~ /^-/);
1726
1727	if ($lines[$ln - 1] =~ /.\s(?:bool\|tristate)\s\"/) {
1728	$is_start = 1;
1729	} elsif ($lines[$ln - 1] =~ /.\s*(?:---)?help(?:---)?$/) {
1730	$length = -1;
1731	}
1732
1733	$f =~ s/^.//;
1734	$f =~ s/#.*//;
1735	$f =~ s/^\s+//;
1736	next if ($f =~ /^$/);
1737	if ($f =~ /^\s*config\s/) {
1738	$is_end = 1;
1739	last;
1740	}
1741	$length++;
1742	}
1743	WARN("CONFIG_DESCRIPTION",
1744	"please write a paragraph that describes the config symbol fully\n" . $herecurr) if ($is_start && $is_end && $length < 4);
1745	#print "is_start<$is_start> is_end<$is_end> length<$length>\n";
1746	}
1747
1748	# discourage the addition of CONFIG_EXPERIMENTAL in Kconfig.
1749	if ($realfile =~ /Kconfig/ &&
1750	$line =~ /.\sdepends on\s+.\bEXPERIMENTAL\b/) {
1751	WARN("CONFIG_EXPERIMENTAL",
1752	"Use of CONFIG_EXPERIMENTAL is deprecated. For alternatives, see https://lkml.org/lkml/2012/10/23/580\n");
1753	}
1754
1755	if (($realfile =~ /Makefile./ \|\| $realfile =~ /Kbuild./) &&
1756	($line =~ /\+(EXTRA_[A-Z]+FLAGS).*/)) {
1757	my $flag = $1;
1758	my $replacement = {
1759	'EXTRA_AFLAGS' => 'asflags-y',
1760	'EXTRA_CFLAGS' => 'ccflags-y',
1761	'EXTRA_CPPFLAGS' => 'cppflags-y',
1762	'EXTRA_LDFLAGS' => 'ldflags-y',
1763	};
1764
1765	WARN("DEPRECATED_VARIABLE",
1766	"Use of $flag is deprecated, please use \`$replacement->{$flag} instead.\n" . $herecurr) if ($replacement->{$flag});
1767	}
1768
1769	# check we are in a valid source file if not then ignore this hunk
1770	next if ($realfile !~ /\.(h\|c\|s\|S\|pl\|sh)$/);
1771
1772	#line length limit
1773	if ($line =~ /^\+/ && $prevrawline !~ /\/\\/ &&
1774	$rawline !~ /^.\s\\s*\@$Ident\s/ &&
1775	!($line =~ /^\+\s$logFunctions\s$\s(?:(KERN_\S+\s\|[^"]))?"[X\t]"\s(?:\|,\|$\s;)\s*$/ \|\|
1776	$line =~ /^\+\s"[^"]"\s(?:\s\|,\|\)\s;)\s$/) &&
1777	$length > $max_line_length)
1778	{
1779	WARN("LONG_LINE",
1780	"line over $max_line_length characters\n" . $herecurr);
1781	}
1782
1783	# Check for user-visible strings broken across lines, which breaks the ability
1784	# to grep for the string. Limited to strings used as parameters (those
1785	# following an open parenthesis), which almost completely eliminates false
1786	# positives, as well as warning only once per parameter rather than once per
1787	# line of the string. Make an exception when the previous string ends in a
1788	# newline (multiple lines in one string constant) or \n\t (common in inline
1789	# assembly to indent the instruction on the following line).
1790	if ($line =~ /^\+\s*"/ &&
1791	$prevline =~ /"\s*$/ &&
1792	$prevline =~ /\(/ &&
1793	$prevrawline !~ /\\n(?:\\t)"\s$/) {
1794	WARN("SPLIT_STRING",
1795	"quoted string split across lines\n" . $hereprev);
1796	}
1797
1798	# check for spaces before a quoted newline
1799	if ($rawline =~ /^.\".\s\\n/) {
1800	WARN("QUOTED_WHITESPACE_BEFORE_NEWLINE",
1801	"unnecessary whitespace before a quoted newline\n" . $herecurr);
1802	}
1803
1804	# check for adding lines without a newline.
1805	if ($line =~ /^\+/ && defined $lines[$linenr] && $lines[$linenr] =~ /^\\ No newline at end of file/) {
1806	WARN("MISSING_EOF_NEWLINE",
1807	"adding a line without newline at end of file\n" . $herecurr);
1808	}
1809
1810	# Blackfin: use hi/lo macros
1811	if ($realfile =~ m@arch/blackfin/.*\.S$@) {
1812	if ($line =~ /\.[lL][[:space:]]=.&[[:space:]]*0x[fF][fF][fF][fF]/) {
1813	my $herevet = "$here\n" . cat_vet($line) . "\n";
1814	ERROR("LO_MACRO",
1815	"use the LO() macro, not (... & 0xFFFF)\n" . $herevet);
1816	}
1817	if ($line =~ /\.[hH][[:space:]]=.>>[[:space:]]*16/) {
1818	my $herevet = "$here\n" . cat_vet($line) . "\n";
1819	ERROR("HI_MACRO",
1820	"use the HI() macro, not (... >> 16)\n" . $herevet);
1821	}
1822	}
1823
1824	# check we are in a valid source file C or perl if not then ignore this hunk
1825	next if ($realfile !~ /\.(h\|c\|pl)$/);
1826
1827	# at the beginning of a line any tabs must come first and anything
1828	# more than 8 must use tabs.
1829	if ($rawline =~ /^\+\s* \t\s*\S/ \|\|
1830	$rawline =~ /^\+\s* \s*/) {
1831	my $herevet = "$here\n" . cat_vet($rawline) . "\n";
1832	ERROR("CODE_INDENT",
1833	"code indent should use tabs where possible\n" . $herevet);
1834	$rpt_cleaners = 1;
1835	}
1836
1837	# check for space before tabs.
1838	if ($rawline =~ /^\+/ && $rawline =~ / \t/) {
1839	my $herevet = "$here\n" . cat_vet($rawline) . "\n";
1840	WARN("SPACE_BEFORE_TAB",
1841	"please, no space before tabs\n" . $herevet);
1842	}
1843
1844	# check for && or \|\| at the start of a line
1845	if ($rawline =~ /^\+\s*(&&\|\\|\\|)/) {
1846	CHK("LOGICAL_CONTINUATIONS",
1847	"Logical continuations should be on the previous line\n" . $hereprev);
1848	}
1849
1850	# check multi-line statement indentation matches previous line
1851	if ($^V && $^V ge 5.10.0 &&
1852	$prevline =~ /^\+(\t)(if \(\|$Ident\().(\&\&\|\\|\\|\|,)\s*$/) {
1853	$prevline =~ /^\+(\t)(.)$/;
1854	my $oldindent = $1;
1855	my $rest = $2;
1856
1857	my $pos = pos_last_openparen($rest);
1858	if ($pos >= 0) {
1859	$line =~ /^(\+\| )([ \t]*)/;
1860	my $newindent = $2;
1861
1862	my $goodtabindent = $oldindent .
1863	"\t" x ($pos / 8) .
1864	" " x ($pos % 8);
1865	my $goodspaceindent = $oldindent . " " x $pos;
1866
1867	if ($newindent ne $goodtabindent &&
1868	$newindent ne $goodspaceindent) {
1869	CHK("PARENTHESIS_ALIGNMENT",
1870	"Alignment should match open parenthesis\n" . $hereprev);
1871	}
1872	}
1873	}
1874
1875	if ($line =~ /^\+.\[ \t]*\)[ \t]+/) {
1876	CHK("SPACING",
1877	"No space is necessary after a cast\n" . $hereprev);
1878	}
1879
1880	if ($realfile =~ m@^(drivers/net/\|net/)@ &&
1881	$rawline =~ /^\+[ \t]\/\[ \t]*$/ &&
1882	$prevrawline =~ /^\+[ \t]*$/) {
1883	WARN("NETWORKING_BLOCK_COMMENT_STYLE",
1884	"networking block comments don't use an empty /* line, use /* Comment...\n" . $hereprev);
1885	}
1886
1887	if ($realfile =~ m@^(drivers/net/\|net/)@ &&
1888	$rawline !~ m@^\+[ \t]\/[ \t]$@ && #trailing /
1889	$rawline !~ m@^\+./\.\/[ \t]$@ && #inline /...*/
1890	$rawline !~ m@^\+.\{2,}/[ \t]$@ && #trailing */
1891	$rawline =~ m@^\+[ \t].+\\/[ \t]$@) { #non blank /
1892	WARN("NETWORKING_BLOCK_COMMENT_STYLE",
1893	"networking block comments put the trailing */ on a separate line\n" . $herecurr);
1894	}
1895
1896	# check for spaces at the beginning of a line.
1897	# Exceptions:
1898	# 1) within comments
1899	# 2) indented preprocessor commands
1900	# 3) hanging labels
1901	if ($rawline =~ /^\+ / && $line !~ /\+ *(?:$;\|#\|$Ident:)/) {
1902	my $herevet = "$here\n" . cat_vet($rawline) . "\n";
1903	WARN("LEADING_SPACE",
1904	"please, no spaces at the start of a line\n" . $herevet);
1905	}
1906
1907	# check we are in a valid C source file if not then ignore this hunk
1908	next if ($realfile !~ /\.(h\|c)$/);
1909
1910	# discourage the addition of CONFIG_EXPERIMENTAL in #if(def).
1911	if ($line =~ /^\+\s\#\sif.*\bCONFIG_EXPERIMENTAL\b/) {
1912	WARN("CONFIG_EXPERIMENTAL",
1913	"Use of CONFIG_EXPERIMENTAL is deprecated. For alternatives, see https://lkml.org/lkml/2012/10/23/580\n");
1914	}
1915
1916	# check for RCS/CVS revision markers
1917	if ($rawline =~ /^\+.*\$(Revision\|Log\|Id)(?:\$\|)/) {
1918	WARN("CVS_KEYWORD",
1919	"CVS style keyword markers, these will _not_ be updated\n". $herecurr);
1920	}
1921
1922	# Blackfin: don't use __builtin_bfin_[cs]sync
1923	if ($line =~ /__builtin_bfin_csync/) {
1924	my $herevet = "$here\n" . cat_vet($line) . "\n";
1925	ERROR("CSYNC",
1926	"use the CSYNC() macro in asm/blackfin.h\n" . $herevet);
1927	}
1928	if ($line =~ /__builtin_bfin_ssync/) {
1929	my $herevet = "$here\n" . cat_vet($line) . "\n";
1930	ERROR("SSYNC",
1931	"use the SSYNC() macro in asm/blackfin.h\n" . $herevet);
1932	}
1933
1934	# Check for potential 'bare' types
1935	my ($stat, $cond, $line_nr_next, $remain_next, $off_next,
1936	$realline_next);
1937	#print "LINE<$line>\n";
1938	if ($linenr >= $suppress_statement &&
1939	$realcnt && $line =~ /.\s*\S/) {
1940	($stat, $cond, $line_nr_next, $remain_next, $off_next) =
1941	ctx_statement_block($linenr, $realcnt, 0);
1942	$stat =~ s/\n./\n /g;
1943	$cond =~ s/\n./\n /g;
1944
1945	#print "linenr<$linenr> <$stat>\n";
1946	# If this statement has no statement boundaries within
1947	# it there is no point in retrying a statement scan
1948	# until we hit end of it.
1949	my $frag = $stat; $frag =~ s/;+\s*$//;
1950	if ($frag !~ /(?:{\|;)/) {
1951	#print "skip<$line_nr_next>\n";
1952	$suppress_statement = $line_nr_next;
1953	}
1954
1955	# Find the real next line.
1956	$realline_next = $line_nr_next;
1957	if (defined $realline_next &&
1958	(!defined $lines[$realline_next - 1] \|\|
1959	substr($lines[$realline_next - 1], $off_next) =~ /^\s*$/)) {
1960	$realline_next++;
1961	}
1962
1963	my $s = $stat;
1964	$s =~ s/{.*$//s;
1965
1966	# Ignore goto labels.
1967	if ($s =~ /$Ident:\*$/s) {
1968
1969	# Ignore functions being called
1970	} elsif ($s =~ /^.\s$Ident\s\(/s) {
1971
1972	} elsif ($s =~ /^.\s*else\b/s) {
1973
1974	# declarations always start with types
1975	} 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) {
1976	my $type = $1;
1977	$type =~ s/\s+/ /g;
1978	possible($type, "A:" . $s);
1979
1980	# definitions in global scope can only start with types
1981	} elsif ($s =~ /^.(?:$Storage\s+)?(?:$Inline\s+)?(?:const\s+)?($Ident)\b\s*(?!:)/s) {
1982	possible($1, "B:" . $s);
1983	}
1984
1985	# any (foo ... *) is a pointer cast, and foo is a type
1986	while ($s =~ /$($Ident)(?:\s+$Sparse)[\s\]+\s*$/sg) {
1987	possible($1, "C:" . $s);
1988	}
1989
1990	# Check for any sort of function declaration.
1991	# int foo(something bar, other baz);
1992	# void (store_gdt)(x86_descr_ptr );
1993	if ($prev_values eq 'E' && $s =~ /^(.(?:typedef\s)?(?:(?:$Storage\|$Inline)\s)\s$Type\s(?:\b$Ident\|$\\s$Ident$)\s)\(/s) {
1994	my ($name_len) = length($1);
1995
1996	my $ctx = $s;
1997	substr($ctx, 0, $name_len + 1, '');
1998	$ctx =~ s/\)[^\)]*$//;
1999
2000	for my $arg (split(/\s,\s/, $ctx)) {
2001	if ($arg =~ /^(?:const\s+)?($Ident)(?:\s+$Sparse)\s\*\s(:?\b$Ident)?$/s \|\| $arg =~ /^($Ident)$/s) {
2002
2003	possible($1, "D:" . $s);
2004	}
2005	}
2006	}
2007
2008	}
2009
2010	#
2011	# Checks which may be anchored in the context.
2012	#
2013
2014	# Check for switch () and associated case and default
2015	# statements should be at the same indent.
2016	if ($line=~/\bswitch\s$.$/) {
2017	my $err = '';
2018	my $sep = '';
2019	my @ctx = ctx_block_outer($linenr, $realcnt);
2020	shift(@ctx);
2021	for my $ctx (@ctx) {
2022	my ($clen, $cindent) = line_stats($ctx);
2023	if ($ctx =~ /^\+\s*(case\s+\|default:)/ &&
2024	$indent != $cindent) {
2025	$err .= "$sep$ctx\n";
2026	$sep = '';
2027	} else {
2028	$sep = "[...]\n";
2029	}
2030	}
2031	if ($err ne '') {
2032	ERROR("SWITCH_CASE_INDENT_LEVEL",
2033	"switch and case should be at the same indent\n$hereline$err");
2034	}
2035	}
2036
2037	# if/while/etc brace do not go on next line, unless defining a do while loop,
2038	# or if that brace on the next line is for something else
2039	if ($line =~ /(.)\b((?:if\|while\|for\|switch)\s\(\|do\b\|else\b)/ && $line !~ /^.\s*\#/) {
2040	my $pre_ctx = "$1$2";
2041
2042	my ($level, @ctx) = ctx_statement_level($linenr, $realcnt, 0);
2043
2044	if ($line =~ /^\+\t{6,}/) {
2045	WARN("DEEP_INDENTATION",
2046	"Too many leading tabs - consider code refactoring\n" . $herecurr);
2047	}
2048
2049	my $ctx_cnt = $realcnt - $#ctx - 1;
2050	my $ctx = join("\n", @ctx);
2051
2052	my $ctx_ln = $linenr;
2053	my $ctx_skip = $realcnt;
2054
2055	while ($ctx_skip > $ctx_cnt \|\| ($ctx_skip == $ctx_cnt &&
2056	defined $lines[$ctx_ln - 1] &&
2057	$lines[$ctx_ln - 1] =~ /^-/)) {
2058	##print "SKIP<$ctx_skip> CNT<$ctx_cnt>\n";
2059	$ctx_skip-- if (!defined $lines[$ctx_ln - 1] \|\| $lines[$ctx_ln - 1] !~ /^-/);
2060	$ctx_ln++;
2061	}
2062
2063	#print "realcnt<$realcnt> ctx_cnt<$ctx_cnt>\n";
2064	#print "pre<$pre_ctx>\nline<$line>\nctx<$ctx>\nnext<$lines[$ctx_ln - 1]>\n";
2065
2066	if ($ctx !~ /{\s/ && defined($lines[$ctx_ln -1]) && $lines[$ctx_ln - 1] =~ /^\+\s{/) {
2067	ERROR("OPEN_BRACE",
2068	"that open brace { should be on the previous line\n" .
2069	"$here\n$ctx\n$rawlines[$ctx_ln - 1]\n");
2070	}
2071	if ($level == 0 && $pre_ctx !~ /}\swhile\s\($/ &&
2072	$ctx =~ /\)\s\;\s$/ &&
2073	defined $lines[$ctx_ln - 1])
2074	{
2075	my ($nlength, $nindent) = line_stats($lines[$ctx_ln - 1]);
2076	if ($nindent > $indent) {
2077	WARN("TRAILING_SEMICOLON",
2078	"trailing semicolon indicates no statements, indent implies otherwise\n" .
2079	"$here\n$ctx\n$rawlines[$ctx_ln - 1]\n");
2080	}
2081	}
2082	}
2083
2084	# Check relative indent for conditionals and blocks.
2085	if ($line =~ /\b(?:(?:if\|while\|for)\s\(\|do\b)/ && $line !~ /^.\s#/ && $line !~ /\}\swhile\s/) {
2086	($stat, $cond, $line_nr_next, $remain_next, $off_next) =
2087	ctx_statement_block($linenr, $realcnt, 0)
2088	if (!defined $stat);
2089	my ($s, $c) = ($stat, $cond);
2090
2091	substr($s, 0, length($c), '');
2092
2093	# Make sure we remove the line prefixes as we have
2094	# none on the first line, and are going to readd them
2095	# where necessary.
2096	$s =~ s/\n./\n/gs;
2097
2098	# Find out how long the conditional actually is.
2099	my @newlines = ($c =~ /\n/gs);
2100	my $cond_lines = 1 + $#newlines;
2101
2102	# We want to check the first line inside the block
2103	# starting at the end of the conditional, so remove:
2104	# 1) any blank line termination
2105	# 2) any opening brace { on end of the line
2106	# 3) any do (...) {
2107	my $continuation = 0;
2108	my $check = 0;
2109	$s =~ s/^.*\bdo\b//;
2110	$s =~ s/^\s*{//;
2111	if ($s =~ s/^\s*\\//) {
2112	$continuation = 1;
2113	}
2114	if ($s =~ s/^\s*?\n//) {
2115	$check = 1;
2116	$cond_lines++;
2117	}
2118
2119	# Also ignore a loop construct at the end of a
2120	# preprocessor statement.
2121	if (($prevline =~ /^.\s#\sdefine\s/ \|\|
2122	$prevline =~ /\\\s*$/) && $continuation == 0) {
2123	$check = 0;
2124	}
2125
2126	my $cond_ptr = -1;
2127	$continuation = 0;
2128	while ($cond_ptr != $cond_lines) {
2129	$cond_ptr = $cond_lines;
2130
2131	# If we see an #else/#elif then the code
2132	# is not linear.
2133	if ($s =~ /^\s\#\s(?:else\|elif)/) {
2134	$check = 0;
2135	}
2136
2137	# Ignore:
2138	# 1) blank lines, they should be at 0,
2139	# 2) preprocessor lines, and
2140	# 3) labels.
2141	if ($continuation \|\|
2142	$s =~ /^\s*?\n/ \|\|
2143	$s =~ /^\s#\s?/ \|\|
2144	$s =~ /^\s$Ident\s:/) {
2145	$continuation = ($s =~ /^.*?\\\n/) ? 1 : 0;
2146	if ($s =~ s/^.*?\n//) {
2147	$cond_lines++;
2148	}
2149	}
2150	}
2151
2152	my (undef, $sindent) = line_stats("+" . $s);
2153	my $stat_real = raw_line($linenr, $cond_lines);
2154
2155	# Check if either of these lines are modified, else
2156	# this is not this patch's fault.
2157	if (!defined($stat_real) \|\|
2158	$stat !~ /^\+/ && $stat_real !~ /^\+/) {
2159	$check = 0;
2160	}
2161	if (defined($stat_real) && $cond_lines > 1) {
2162	$stat_real = "[...]\n$stat_real";
2163	}
2164
2165	#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";
2166
2167	if ($check && (($sindent % 8) != 0 \|\|
2168	($sindent <= $indent && $s ne ''))) {
2169	WARN("SUSPECT_CODE_INDENT",
2170	"suspect code indent for conditional statements ($indent, $sindent)\n" . $herecurr . "$stat_real\n");
2171	}
2172	}
2173
2174	# Track the 'values' across context and added lines.
2175	my $opline = $line; $opline =~ s/^./ /;
2176	my ($curr_values, $curr_vars) =
2177	annotate_values($opline . "\n", $prev_values);
2178	$curr_values = $prev_values . $curr_values;
2179	if ($dbg_values) {
2180	my $outline = $opline; $outline =~ s/\t/ /g;
2181	print "$linenr > .$outline\n";
2182	print "$linenr > $curr_values\n";
2183	print "$linenr > $curr_vars\n";
2184	}
2185	$prev_values = substr($curr_values, -1);
2186
2187	#ignore lines not being added
2188	if ($line=~/^[^\+]/) {next;}
2189
2190	# TEST: allow direct testing of the type matcher.
2191	if ($dbg_type) {
2192	if ($line =~ /^.\s$Declare\s$/) {
2193	ERROR("TEST_TYPE",
2194	"TEST: is type\n" . $herecurr);
2195	} elsif ($dbg_type > 1 && $line =~ /^.+($Declare)/) {
2196	ERROR("TEST_NOT_TYPE",
2197	"TEST: is not type ($1 is)\n". $herecurr);
2198	}
2199	next;
2200	}
2201	# TEST: allow direct testing of the attribute matcher.
2202	if ($dbg_attr) {
2203	if ($line =~ /^.\s$Modifier\s$/) {
2204	ERROR("TEST_ATTR",
2205	"TEST: is attr\n" . $herecurr);
2206	} elsif ($dbg_attr > 1 && $line =~ /^.+($Modifier)/) {
2207	ERROR("TEST_NOT_ATTR",
2208	"TEST: is not attr ($1 is)\n". $herecurr);
2209	}
2210	next;
2211	}
2212
2213	# check for initialisation to aggregates open brace on the next line
2214	if ($line =~ /^.\s*{/ &&
2215	$prevline =~ /(?:^\|[^=])=\s*$/) {
2216	ERROR("OPEN_BRACE",
2217	"that open brace { should be on the previous line\n" . $hereprev);
2218	}
2219
2220	#
2221	# Checks which are anchored on the added line.
2222	#
2223
2224	# check for malformed paths in #include statements (uses RAW line)
2225	if ($rawline =~ m{^.\s\#\sinclude\s+[<"](.*)[">]}) {
2226	my $path = $1;
2227	if ($path =~ m{//}) {
2228	ERROR("MALFORMED_INCLUDE",
2229	"malformed #include filename\n" . $herecurr);
2230	}
2231	if ($path =~ "^uapi/" && $realfile =~ m@\binclude/uapi/@) {
2232	ERROR("UAPI_INCLUDE",
2233	"No #include in ...include/uapi/... should use a uapi/ path prefix\n" . $herecurr);
2234	}
2235	}
2236
2237	# no C99 // comments
2238	if ($line =~ m{//}) {
2239	ERROR("C99_COMMENTS",
2240	"do not use C99 // comments\n" . $herecurr);
2241	}
2242	# Remove C99 comments.
2243	$line =~ s@//.*@@;
2244	$opline =~ s@//.*@@;
2245
2246	# EXPORT_SYMBOL should immediately follow the thing it is exporting, consider
2247	# the whole statement.
2248	#print "APW <$lines[$realline_next - 1]>\n";
2249	if (defined $realline_next &&
2250	exists $lines[$realline_next - 1] &&
2251	!defined $suppress_export{$realline_next} &&
2252	($lines[$realline_next - 1] =~ /EXPORT_SYMBOL.$(.)$/ \|\|
2253	$lines[$realline_next - 1] =~ /EXPORT_UNUSED_SYMBOL.$(.)$/)) {
2254	# Handle definitions which produce identifiers with
2255	# a prefix:
2256	# XXX(foo);
2257	# EXPORT_SYMBOL(something_foo);
2258	my $name = $1;
2259	if ($stat =~ /^(?:.\s}\s\n)?.([A-Z_]+)\s\(\s($Ident)/ &&
2260	$name =~ /^${Ident}_$2/) {
2261	#print "FOO C name<$name>\n";
2262	$suppress_export{$realline_next} = 1;
2263
2264	} elsif ($stat !~ /(?:
2265	\n.}\s*$\|
2266	^.DEFINE_$Ident$\Q$name\E$\|
2267	^.DECLARE_$Ident$\Q$name\E$\|
2268	^.LIST_HEAD$\Q$name\E$\|
2269	^.(?:$Storage\s+)?$Type\s$\s\\s\Q$name\E\s$\s\(\|
2270	\b\Q$name\E(?:\s+$Attribute)\s(?:;\|=\|\[\|\()
2271	)/x) {
2272	#print "FOO A<$lines[$realline_next - 1]> stat<$stat> name<$name>\n";
2273	$suppress_export{$realline_next} = 2;
2274	} else {
2275	$suppress_export{$realline_next} = 1;
2276	}
2277	}
2278	if (!defined $suppress_export{$linenr} &&
2279	$prevline =~ /^.\s*$/ &&
2280	($line =~ /EXPORT_SYMBOL.$(.)$/ \|\|
2281	$line =~ /EXPORT_UNUSED_SYMBOL.$(.)$/)) {
2282	#print "FOO B <$lines[$linenr - 1]>\n";
2283	$suppress_export{$linenr} = 2;
2284	}
2285	if (defined $suppress_export{$linenr} &&
2286	$suppress_export{$linenr} == 2) {
2287	WARN("EXPORT_SYMBOL",
2288	"EXPORT_SYMBOL(foo); should immediately follow its function/variable\n" . $herecurr);
2289	}
2290
2291	# check for global initialisers.
2292	if ($line =~ /^.$Type\s$Ident\s(?:\s+$Modifier)\s=\s(0\|NULL\|false)\s;/) {
2293	ERROR("GLOBAL_INITIALISERS",
2294	"do not initialise globals to 0 or NULL\n" .
2295	$herecurr);
2296	}
2297	# check for static initialisers.
2298	if ($line =~ /\bstatic\s.=\s(0\|NULL\|false)\s*;/) {
2299	ERROR("INITIALISED_STATIC",
2300	"do not initialise statics to 0 or NULL\n" .
2301	$herecurr);
2302	}
2303
2304	# check for static const char * arrays.
2305	if ($line =~ /\bstatic\s+const\s+char\s\\s(\w+)\s\[\s\]\s=\s*/) {
2306	WARN("STATIC_CONST_CHAR_ARRAY",
2307	"static const char * array should probably be static const char * const\n" .
2308	$herecurr);
2309	}
2310
2311	# check for static char foo[] = "bar" declarations.
2312	if ($line =~ /\bstatic\s+char\s+(\w+)\s\[\s\]\s=\s"/) {
2313	WARN("STATIC_CONST_CHAR_ARRAY",
2314	"static char array declaration should probably be static const char\n" .
2315	$herecurr);
2316	}
2317
2318	# check for declarations of struct pci_device_id
2319	if ($line =~ /\bstruct\s+pci_device_id\s+\w+\s\[\s\]\s\=\s\{/) {
2320	WARN("DEFINE_PCI_DEVICE_TABLE",
2321	"Use DEFINE_PCI_DEVICE_TABLE for struct pci_device_id\n" . $herecurr);
2322	}
2323
2324	# check for new typedefs, only function parameters and sparse annotations
2325	# make sense.
2326	if ($line =~ /\btypedef\s/ &&
2327	$line !~ /\btypedef\s+$Type\s$\s\?$Ident\s$\s*\(/ &&
2328	$line !~ /\btypedef\s+$Type\s+$Ident\s*\(/ &&
2329	$line !~ /\b$typeTypedefs\b/ &&
2330	$line !~ /\b__bitwise(?:__\|)\b/) {
2331	WARN("NEW_TYPEDEFS",
2332	"do not add new typedefs\n" . $herecurr);
2333	}
2334
2335	# * goes on variable not on type
2336	# (char*[ const])
2337	while ($line =~ m{($$NonptrType(\s(?:$Modifier\b\s\|\\s)+)$)}g) {
2338	#print "AA<$1>\n";
2339	my ($from, $to) = ($2, $2);
2340
2341	# Should start with a space.
2342	$to =~ s/^(\S)/ $1/;
2343	# Should not end with a space.
2344	$to =~ s/\s+$//;
2345	# '*'s should not have spaces between.
2346	while ($to =~ s/\\s+\/\\/) {
2347	}
2348
2349	#print "from<$from> to<$to>\n";
2350	if ($from ne $to) {
2351	ERROR("POINTER_LOCATION",
2352	"\"(foo$from)\" should be \"(foo$to)\"\n" . $herecurr);
2353	}
2354	}
2355	while ($line =~ m{(\b$NonptrType(\s(?:$Modifier\b\s\|\\s)+)($Ident))}g) {
2356	#print "BB<$1>\n";
2357	my ($from, $to, $ident) = ($2, $2, $3);
2358
2359	# Should start with a space.
2360	$to =~ s/^(\S)/ $1/;
2361	# Should not end with a space.
2362	$to =~ s/\s+$//;
2363	# '*'s should not have spaces between.
2364	while ($to =~ s/\\s+\/\\/) {
2365	}
2366	# Modifiers should have spaces.
2367	$to =~ s/(\b$Modifier$)/$1 /;
2368
2369	#print "from<$from> to<$to> ident<$ident>\n";
2370	if ($from ne $to && $ident !~ /^$Modifier$/) {
2371	ERROR("POINTER_LOCATION",
2372	"\"foo${from}bar\" should be \"foo${to}bar\"\n" . $herecurr);
2373	}
2374	}
2375
2376	# # no BUG() or BUG_ON()
2377	# if ($line =~ /\b(BUG\|BUG_ON)\b/) {
2378	# print "Try to use WARN_ON & Recovery code rather than BUG() or BUG_ON()\n";
2379	# print "$herecurr";
2380	# $clean = 0;
2381	# }
2382
2383	if ($line =~ /\bLINUX_VERSION_CODE\b/) {
2384	WARN("LINUX_VERSION_CODE",
2385	"LINUX_VERSION_CODE should be avoided, code should be for the version to which it is merged\n" . $herecurr);
2386	}
2387
2388	# check for uses of printk_ratelimit
2389	if ($line =~ /\bprintk_ratelimit\s*\(/) {
2390	WARN("PRINTK_RATELIMITED",
2391	"Prefer printk_ratelimited or pr_<level>_ratelimited to printk_ratelimit\n" . $herecurr);
2392	}
2393
2394	# printk should use KERN_* levels. Note that follow on printk's on the
2395	# same line do not need a level, so we use the current block context
2396	# to try and find and validate the current printk. In summary the current
2397	# printk includes all preceding printk's which have no newline on the end.
2398	# we assume the first bad printk is the one to report.
2399	if ($line =~ /\bprintk\((?!KERN_)\s*"/) {
2400	my $ok = 0;
2401	for (my $ln = $linenr - 1; $ln >= $first_line; $ln--) {
2402	#print "CHECK<$lines[$ln - 1]\n";
2403	# we have a preceding printk if it ends
2404	# with "\n" ignore it, else it is to blame
2405	if ($lines[$ln - 1] =~ m{\bprintk\(}) {
2406	if ($rawlines[$ln - 1] !~ m{\\n"}) {
2407	$ok = 1;
2408	}
2409	last;
2410	}
2411	}
2412	if ($ok == 0) {
2413	WARN("PRINTK_WITHOUT_KERN_LEVEL",
2414	"printk() should include KERN_ facility level\n" . $herecurr);
2415	}
2416	}
2417
2418	if ($line =~ /\bprintk\s\(\sKERN_([A-Z]+)/) {
2419	my $orig = $1;
2420	my $level = lc($orig);
2421	$level = "warn" if ($level eq "warning");
2422	my $level2 = $level;
2423	$level2 = "dbg" if ($level eq "debug");
2424	WARN("PREFER_PR_LEVEL",
2425	"Prefer netdev_$level2(netdev, ... then dev_$level2(dev, ... then pr_$level(... to printk(KERN_$orig ...\n" . $herecurr);
2426	}
2427
2428	if ($line =~ /\bpr_warning\s*\(/) {
2429	WARN("PREFER_PR_LEVEL",
2430	"Prefer pr_warn(... to pr_warning(...\n" . $herecurr);
2431	}
2432
2433	# function brace can't be on same line, except for #defines of do while,
2434	# or if closed on same line
2435	if (($line=~/$Type\s$Ident$.$.*\s{/) and
2436	!($line=~/\#\sdefine.do\s{/) and !($line=~/}/)) {
2437	ERROR("OPEN_BRACE",
2438	"open brace '{' following function declarations go on the next line\n" . $herecurr);
2439	}
2440
2441	# open braces for enum, union and struct go on the same line.
2442	if ($line =~ /^.\s*{/ &&
2443	$prevline =~ /^.\s(?:typedef\s+)?(enum\|union\|struct)(?:\s+$Ident)?\s$/) {
2444	ERROR("OPEN_BRACE",
2445	"open brace '{' following $1 go on the same line\n" . $hereprev);
2446	}
2447
2448	# missing space after union, struct or enum definition
2449	if ($line =~ /^.\s*(?:typedef\s+)?(enum\|union\|struct)(?:\s+$Ident)?(?:\s+$Ident)?[=\{]/) {
2450	WARN("SPACING",
2451	"missing space after $1 definition\n" . $herecurr);
2452	}
2453
2454	# check for spacing round square brackets; allowed:
2455	# 1. with a type on the left -- int [] a;
2456	# 2. at the beginning of a line for slice initialisers -- [0...10] = 5,
2457	# 3. inside a curly brace -- = { [0...10] = 5 }
2458	while ($line =~ /(.*?\s)\[/g) {
2459	my ($where, $prefix) = ($-[1], $1);
2460	if ($prefix !~ /$Type\s+$/ &&
2461	($where != 0 \|\| $prefix !~ /^.\s+$/) &&
2462	$prefix !~ /[{,]\s+$/) {
2463	ERROR("BRACKET_SPACE",
2464	"space prohibited before open square bracket '['\n" . $herecurr);
2465	}
2466	}
2467
2468	# check for spaces between functions and their parentheses.
2469	while ($line =~ /($Ident)\s+\(/g) {
2470	my $name = $1;
2471	my $ctx_before = substr($line, 0, $-[1]);
2472	my $ctx = "$ctx_before$name";
2473
2474	# Ignore those directives where spaces _are_ permitted.
2475	if ($name =~ /^(?:
2476	if\|for\|while\|switch\|return\|case\|
2477	volatile\|__volatile__\|
2478	__attribute__\|format\|__extension__\|
2479	asm\|__asm__)$/x)
2480	{
2481
2482	# cpp #define statements have non-optional spaces, ie
2483	# if there is a space between the name and the open
2484	# parenthesis it is simply not a parameter group.
2485	} elsif ($ctx_before =~ /^.\s\#\sdefine\s*$/) {
2486
2487	# cpp #elif statement condition may start with a (
2488	} elsif ($ctx =~ /^.\s\#\selif\s*$/) {
2489
2490	# If this whole things ends with a type its most
2491	# likely a typedef for a function.
2492	} elsif ($ctx =~ /$Type$/) {
2493
2494	} else {
2495	WARN("SPACING",
2496	"space prohibited between function name and open parenthesis '('\n" . $herecurr);
2497	}
2498	}
2499
2500	# check for whitespace before a non-naked semicolon
2501	if ($line =~ /^\+.*\S\s+;/) {
2502	CHK("SPACING",
2503	"space prohibited before semicolon\n" . $herecurr);
2504	}
2505
2506	# Check operator spacing.
2507	if (!($line=~/\#\s*include/)) {
2508	my $ops = qr{
2509	<<=\|>>=\|<=\|>=\|==\|!=\|
2510	\+=\|-=\|\*=\|\/=\|%=\|\^=\|\\|=\|&=\|
2511	=>\|->\|<<\|>>\|<\|>\|=\|!\|~\|
2512	&&\|\\|\\|\|,\|\^\|\+\+\|--\|&\|\\|\|\+\|-\|\*\|\/\|%\|
2513	\?\|:
2514	}x;
2515	my @elements = split(/($ops\|;)/, $opline);
2516	my $off = 0;
2517
2518	my $blank = copy_spacing($opline);
2519
2520	for (my $n = 0; $n < $#elements; $n += 2) {
2521	$off += length($elements[$n]);
2522
2523	# Pick up the preceding and succeeding characters.
2524	my $ca = substr($opline, 0, $off);
2525	my $cc = '';
2526	if (length($opline) >= ($off + length($elements[$n + 1]))) {
2527	$cc = substr($opline, $off + length($elements[$n + 1]));
2528	}
2529	my $cb = "$ca$;$cc";
2530
2531	my $a = '';
2532	$a = 'V' if ($elements[$n] ne '');
2533	$a = 'W' if ($elements[$n] =~ /\s$/);
2534	$a = 'C' if ($elements[$n] =~ /$;$/);
2535	$a = 'B' if ($elements[$n] =~ /(\[\|\()$/);
2536	$a = 'O' if ($elements[$n] eq '');
2537	$a = 'E' if ($ca =~ /^\s*$/);
2538
2539	my $op = $elements[$n + 1];
2540
2541	my $c = '';
2542	if (defined $elements[$n + 2]) {
2543	$c = 'V' if ($elements[$n + 2] ne '');
2544	$c = 'W' if ($elements[$n + 2] =~ /^\s/);
2545	$c = 'C' if ($elements[$n + 2] =~ /^$;/);
2546	$c = 'B' if ($elements[$n + 2] =~ /^(\)\|\]\|;)/);
2547	$c = 'O' if ($elements[$n + 2] eq '');
2548	$c = 'E' if ($elements[$n + 2] =~ /^\s*\\$/);
2549	} else {
2550	$c = 'E';
2551	}
2552
2553	my $ctx = "${a}x${c}";
2554
2555	my $at = "(ctx:$ctx)";
2556
2557	my $ptr = substr($blank, 0, $off) . "^";
2558	my $hereptr = "$hereline$ptr\n";
2559
2560	# Pull out the value of this operator.
2561	my $op_type = substr($curr_values, $off + 1, 1);
2562
2563	# Get the full operator variant.
2564	my $opv = $op . substr($curr_vars, $off, 1);
2565
2566	# Ignore operators passed as parameters.
2567	if ($op_type ne 'V' &&
2568	$ca =~ /\s$/ && $cc =~ /^\s*,/) {
2569
2570	# # Ignore comments
2571	# } elsif ($op =~ /^$;+$/) {
2572
2573	# ; should have either the end of line or a space or \ after it
2574	} elsif ($op eq ';') {
2575	if ($ctx !~ /.x[WEBC]/ &&
2576	$cc !~ /^\\/ && $cc !~ /^;/) {
2577	ERROR("SPACING",
2578	"space required after that '$op' $at\n" . $hereptr);
2579	}
2580
2581	# // is a comment
2582	} elsif ($op eq '//') {
2583
2584	# No spaces for:
2585	# ->
2586	# : when part of a bitfield
2587	} elsif ($op eq '->' \|\| $opv eq ':B') {
2588	if ($ctx =~ /Wx.\|.xW/) {
2589	ERROR("SPACING",
2590	"spaces prohibited around that '$op' $at\n" . $hereptr);
2591	}
2592
2593	# , must have a space on the right.
2594	} elsif ($op eq ',') {
2595	if ($ctx !~ /.x[WEC]/ && $cc !~ /^}/) {
2596	ERROR("SPACING",
2597	"space required after that '$op' $at\n" . $hereptr);
2598	}
2599
2600	# '*' as part of a type definition -- reported already.
2601	} elsif ($opv eq '*_') {
2602	#warn "'*' is part of type\n";
2603
2604	# unary operators should have a space before and
2605	# none after. May be left adjacent to another
2606	# unary operator, or a cast
2607	} elsif ($op eq '!' \|\| $op eq '~' \|\|
2608	$opv eq '*U' \|\| $opv eq '-U' \|\|
2609	$opv eq '&U' \|\| $opv eq '&&U') {
2610	if ($ctx !~ /[WEBC]x./ && $ca !~ /(?:\)\|!\|~\|\*\|-\|\&\|\\|\|\+\+\|\-\-\|\{)$/) {
2611	ERROR("SPACING",
2612	"space required before that '$op' $at\n" . $hereptr);
2613	}
2614	if ($op eq '' && $cc =~/\s$Modifier\b/) {
2615	# A unary '*' may be const
2616
2617	} elsif ($ctx =~ /.xW/) {
2618	ERROR("SPACING",
2619	"space prohibited after that '$op' $at\n" . $hereptr);
2620	}
2621
2622	# unary ++ and unary -- are allowed no space on one side.
2623	} elsif ($op eq '++' or $op eq '--') {
2624	if ($ctx !~ /[WEOBC]x[^W]/ && $ctx !~ /[^W]x[WOBEC]/) {
2625	ERROR("SPACING",
2626	"space required one side of that '$op' $at\n" . $hereptr);
2627	}
2628	if ($ctx =~ /Wx[BE]/ \|\|
2629	($ctx =~ /Wx./ && $cc =~ /^;/)) {
2630	ERROR("SPACING",
2631	"space prohibited before that '$op' $at\n" . $hereptr);
2632	}
2633	if ($ctx =~ /ExW/) {
2634	ERROR("SPACING",
2635	"space prohibited after that '$op' $at\n" . $hereptr);
2636	}
2637
2638
2639	# << and >> may either have or not have spaces both sides
2640	} elsif ($op eq '<<' or $op eq '>>' or
2641	$op eq '&' or $op eq '^' or $op eq '\|' or
2642	$op eq '+' or $op eq '-' or
2643	$op eq '*' or $op eq '/' or
2644	$op eq '%')
2645	{
2646	if ($ctx =~ /Wx[^WCE]\|[^WCE]xW/) {
2647	ERROR("SPACING",
2648	"need consistent spacing around '$op' $at\n" .
2649	$hereptr);
2650	}
2651
2652	# A colon needs no spaces before when it is
2653	# terminating a case value or a label.
2654	} elsif ($opv eq ':C' \|\| $opv eq ':L') {
2655	if ($ctx =~ /Wx./) {
2656	ERROR("SPACING",
2657	"space prohibited before that '$op' $at\n" . $hereptr);
2658	}
2659
2660	# All the others need spaces both sides.
2661	} elsif ($ctx !~ /[EWC]x[CWE]/) {
2662	my $ok = 0;
2663
2664	# Ignore email addresses <foo@bar>
2665	if (($op eq '<' &&
2666	$cc =~ /^\S+\@\S+>/) \|\|
2667	($op eq '>' &&
2668	$ca =~ /<\S+\@\S+$/))
2669	{
2670	$ok = 1;
2671	}
2672
2673	# Ignore ?:
2674	if (($opv eq ':O' && $ca =~ /\?$/) \|\|
2675	($op eq '?' && $cc =~ /^:/)) {
2676	$ok = 1;
2677	}
2678
2679	if ($ok == 0) {
2680	ERROR("SPACING",
2681	"spaces required around that '$op' $at\n" . $hereptr);
2682	}
2683	}
2684	$off += length($elements[$n + 1]);
2685	}
2686	}
2687
2688	# check for multiple assignments
2689	if ($line =~ /^.\s$Lval\s=\s$Lval\s=(?!=)/) {
2690	CHK("MULTIPLE_ASSIGNMENTS",
2691	"multiple assignments should be avoided\n" . $herecurr);
2692	}
2693
2694	## # check for multiple declarations, allowing for a function declaration
2695	## # continuation.
2696	## if ($line =~ /^.\s$Type\s+$Ident(?:\s=[^,{])?\s,\s$Ident./ &&
2697	## $line !~ /^.\s$Type\s+$Ident(?:\s=[^,{])?\s,\s$Type\s$Ident.*/) {
2698	##
2699	## # Remove any bracketed sections to ensure we do not
2700	## # falsly report the parameters of functions.
2701	## my $ln = $line;
2702	## while ($ln =~ s/$[^\($]*\)//g) {
2703	## }
2704	## if ($ln =~ /,/) {
2705	## WARN("MULTIPLE_DECLARATION",
2706	## "declaring multiple variables together should be avoided\n" . $herecurr);
2707	## }
2708	## }
2709
2710	#need space before brace following if, while, etc
2711	if (($line =~ /$.*${/ && $line !~ /$$Type${/) \|\|
2712	$line =~ /do{/) {
2713	ERROR("SPACING",
2714	"space required before the open brace '{'\n" . $herecurr);
2715	}
2716
2717	# closing brace should have a space following it when it has anything
2718	# on the line
2719	if ($line =~ /}(?!(?:,\|;\|\)))\S/) {
2720	ERROR("SPACING",
2721	"space required after that close brace '}'\n" . $herecurr);
2722	}
2723
2724	# check spacing on square brackets
2725	if ($line =~ /\[\s/ && $line !~ /\[\s*$/) {
2726	ERROR("SPACING",
2727	"space prohibited after that open square bracket '['\n" . $herecurr);
2728	}
2729	if ($line =~ /\s\]/) {
2730	ERROR("SPACING",
2731	"space prohibited before that close square bracket ']'\n" . $herecurr);
2732	}
2733
2734	# check spacing on parentheses
2735	if ($line =~ /$\s/ && $line !~ /\(\s*(?:\$?$/ &&
2736	$line !~ /for\s*\(\s+;/) {
2737	ERROR("SPACING",
2738	"space prohibited after that open parenthesis '('\n" . $herecurr);
2739	}
2740	if ($line =~ /(\s+)\)/ && $line !~ /^.\s*\)/ &&
2741	$line !~ /for\s$.;\s+$/ &&
2742	$line !~ /:\s+\)/) {
2743	ERROR("SPACING",
2744	"space prohibited before that close parenthesis ')'\n" . $herecurr);
2745	}
2746
2747	#goto labels aren't indented, allow a single space however
2748	if ($line=~/^.\s+[A-Za-z\d_]+:(?![0-9]+)/ and
2749	!($line=~/^. [A-Za-z\d_]+:/) and !($line=~/^.\s+default:/)) {
2750	WARN("INDENTED_LABEL",
2751	"labels should not be indented\n" . $herecurr);
2752	}
2753
2754	# Return is not a function.
2755	if (defined($stat) && $stat =~ /^.\sreturn(\s)(\(.*);/s) {
2756	my $spacing = $1;
2757	my $value = $2;
2758
2759	# Flatten any parentheses
2760	$value =~ s/\(/ \(/g;
2761	$value =~ s/\)/\) /g;
2762	while ($value =~ s/\[[^\[\]]*\]/1/ \|\|
2763	$value !~ /(?:$Ident\|-?$Constant)\s*
2764	$Compare\s*
2765	(?:$Ident\|-?$Constant)/x &&
2766	$value =~ s/$[^\($]*\)/1/) {
2767	}
2768	#print "value<$value>\n";
2769	if ($value =~ /^\s(?:$Ident\|-?$Constant)\s$/) {
2770	ERROR("RETURN_PARENTHESES",
2771	"return is not a function, parentheses are not required\n" . $herecurr);
2772
2773	} elsif ($spacing !~ /\s+/) {
2774	ERROR("SPACING",
2775	"space required before the open parenthesis '('\n" . $herecurr);
2776	}
2777	}
2778	# Return of what appears to be an errno should normally be -'ve
2779	if ($line =~ /^.\sreturn\s(E[A-Z])\s;/) {
2780	my $name = $1;
2781	if ($name ne 'EOF' && $name ne 'ERROR') {
2782	WARN("USE_NEGATIVE_ERRNO",
2783	"return of an errno should typically be -ve (return -$1)\n" . $herecurr);
2784	}
2785	}
2786
2787	# Need a space before open parenthesis after if, while etc
2788	if ($line=~/\b(if\|while\|for\|switch)\(/) {
2789	ERROR("SPACING", "space required before the open parenthesis '('\n" . $herecurr);
2790	}
2791
2792	# Check for illegal assignment in if conditional -- and check for trailing
2793	# statements after the conditional.
2794	if ($line =~ /do\s*(?!{)/) {
2795	($stat, $cond, $line_nr_next, $remain_next, $off_next) =
2796	ctx_statement_block($linenr, $realcnt, 0)
2797	if (!defined $stat);
2798	my ($stat_next) = ctx_statement_block($line_nr_next,
2799	$remain_next, $off_next);
2800	$stat_next =~ s/\n./\n /g;
2801	##print "stat<$stat> stat_next<$stat_next>\n";
2802
2803	if ($stat_next =~ /^\s*while\b/) {
2804	# If the statement carries leading newlines,
2805	# then count those as offsets.
2806	my ($whitespace) =
2807	($stat_next =~ /^((?:\s\n[+-])\s*)/s);
2808	my $offset =
2809	statement_rawlines($whitespace) - 1;
2810
2811	$suppress_whiletrailers{$line_nr_next +
2812	$offset} = 1;
2813	}
2814	}
2815	if (!defined $suppress_whiletrailers{$linenr} &&
2816	$line =~ /\b(?:if\|while\|for)\s\(/ && $line !~ /^.\s#/) {
2817	my ($s, $c) = ($stat, $cond);
2818
2819	if ($c =~ /\bif\s\(.[^<>!=]=[^=].*/s) {
2820	ERROR("ASSIGN_IN_IF",
2821	"do not use assignment in if condition\n" . $herecurr);
2822	}
2823
2824	# Find out what is on the end of the line after the
2825	# conditional.
2826	substr($s, 0, length($c), '');
2827	$s =~ s/\n.*//g;
2828	$s =~ s/$;//g; # Remove any comments
2829	if (length($c) && $s !~ /^\s{?\s\\\s$/ &&
2830	$c !~ /}\swhile\s/)
2831	{
2832	# Find out how long the conditional actually is.
2833	my @newlines = ($c =~ /\n/gs);
2834	my $cond_lines = 1 + $#newlines;
2835	my $stat_real = '';
2836
2837	$stat_real = raw_line($linenr, $cond_lines)
2838	. "\n" if ($cond_lines);
2839	if (defined($stat_real) && $cond_lines > 1) {
2840	$stat_real = "[...]\n$stat_real";
2841	}
2842
2843	ERROR("TRAILING_STATEMENTS",
2844	"trailing statements should be on next line\n" . $herecurr . $stat_real);
2845	}
2846	}
2847
2848	# Check for bitwise tests written as boolean
2849	if ($line =~ /
2850	(?:
2851	(?:\[\|\(\|\&\&\|\\|\\|)
2852	\s0[xX][0-9]+\s
2853	(?:\&\&\|\\|\\|)
2854	\|
2855	(?:\&\&\|\\|\\|)
2856	\s0[xX][0-9]+\s
2857	(?:\&\&\|\\|\\|\|\)\|\])
2858	)/x)
2859	{
2860	WARN("HEXADECIMAL_BOOLEAN_TEST",
2861	"boolean test with hexadecimal, perhaps just 1 \& or \\|?\n" . $herecurr);
2862	}
2863
2864	# if and else should not have general statements after it
2865	if ($line =~ /^.\s(?:}\s)?else\b(.*)/) {
2866	my $s = $1;
2867	$s =~ s/$;//g; # Remove any comments
2868	if ($s !~ /^\s(?:\sif\|(?:{\|)\s\\?\s*$)/) {
2869	ERROR("TRAILING_STATEMENTS",
2870	"trailing statements should be on next line\n" . $herecurr);
2871	}
2872	}
2873	# if should not continue a brace
2874	if ($line =~ /}\s*if\b/) {
2875	ERROR("TRAILING_STATEMENTS",
2876	"trailing statements should be on next line\n" .
2877	$herecurr);
2878	}
2879	# case and default should not have general statements after them
2880	if ($line =~ /^.\s(?:case\s.\|default\s):/g &&
2881	$line !~ /\G(?:
2882	(?:\s$;)(?:\s{)?(?:\s$;)(?:\s\\)?\s*$\|
2883	\s*return\s+
2884	)/xg)
2885	{
2886	ERROR("TRAILING_STATEMENTS",
2887	"trailing statements should be on next line\n" . $herecurr);
2888	}
2889
2890	# Check for }<nl>else {, these must be at the same
2891	# indent level to be relevant to each other.
2892	if ($prevline=~/}\s$/ and $line=~/^.\selse\s*/ and
2893	$previndent == $indent) {
2894	ERROR("ELSE_AFTER_BRACE",
2895	"else should follow close brace '}'\n" . $hereprev);
2896	}
2897
2898	if ($prevline=~/}\s$/ and $line=~/^.\swhile\s*/ and
2899	$previndent == $indent) {
2900	my ($s, $c) = ctx_statement_block($linenr, $realcnt, 0);
2901
2902	# Find out what is on the end of the line after the
2903	# conditional.
2904	substr($s, 0, length($c), '');
2905	$s =~ s/\n.*//g;
2906
2907	if ($s =~ /^\s*;/) {
2908	ERROR("WHILE_AFTER_BRACE",
2909	"while should follow close brace '}'\n" . $hereprev);
2910	}
2911	}
2912
2913	#CamelCase
2914	while ($line =~ m{($Constant\|$Lval)}g) {
2915	my $var = $1;
2916	if ($var !~ /$Constant/ &&
2917	$var =~ /[A-Z]\w[a-z]\|[a-z]\w[A-Z]/ &&
2918	!defined $camelcase{$var}) {
2919	$camelcase{$var} = 1;
2920	WARN("CAMELCASE",
2921	"Avoid CamelCase: <$var>\n" . $herecurr);
2922	}
2923	}
2924
2925	#no spaces allowed after \ in define
2926	if ($line=~/\#\sdefine.\\\s$/) {
2927	WARN("WHITESPACE_AFTER_LINE_CONTINUATION",
2928	"Whitepspace after \\ makes next lines useless\n" . $herecurr);
2929	}
2930
2931	#warn if <asm/foo.h> is #included and <linux/foo.h> is available (uses RAW line)
2932	if ($tree && $rawline =~ m{^.\s\#\sinclude\s\<asm\/(.)\.h\>}) {
2933	my $file = "$1.h";
2934	my $checkfile = "include/linux/$file";
2935	if (-f "$root/$checkfile" &&
2936	$realfile ne $checkfile &&
2937	$1 !~ /$allowed_asm_includes/)
2938	{
2939	if ($realfile =~ m{^arch/}) {
2940	CHK("ARCH_INCLUDE_LINUX",
2941	"Consider using #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
2942	} else {
2943	WARN("INCLUDE_LINUX",
2944	"Use #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
2945	}
2946	}
2947	}
2948
2949	# multi-statement macros should be enclosed in a do while loop, grab the
2950	# first statement and ensure its the whole macro if its not enclosed
2951	# in a known good container
2952	if ($realfile !~ m@/vmlinux.lds.h$@ &&
2953	$line =~ /^.\s\#\sdefine\s*$Ident(\()?/) {
2954	my $ln = $linenr;
2955	my $cnt = $realcnt;
2956	my ($off, $dstat, $dcond, $rest);
2957	my $ctx = '';
2958	($dstat, $dcond, $ln, $cnt, $off) =
2959	ctx_statement_block($linenr, $realcnt, 0);
2960	$ctx = $dstat;
2961	#print "dstat<$dstat> dcond<$dcond> cnt<$cnt> off<$off>\n";
2962	#print "LINE<$lines[$ln-1]> len<" . length($lines[$ln-1]) . "\n";
2963
2964	$dstat =~ s/^.\s\#\sdefine\s+$Ident(?:$[^$]\))?\s//;
2965	$dstat =~ s/$;//g;
2966	$dstat =~ s/\\\n.//g;
2967	$dstat =~ s/^\s*//s;
2968	$dstat =~ s/\s*$//s;
2969
2970	# Flatten any parentheses and braces
2971	while ($dstat =~ s/$[^\($]*\)/1/ \|\|
2972	$dstat =~ s/\{[^\{\}]*\}/1/ \|\|
2973	$dstat =~ s/\[[^\[\]]*\]/1/)
2974	{
2975	}
2976
2977	# Flatten any obvious string concatentation.
2978	while ($dstat =~ s/("X")\s$Ident/$1/ \|\|
2979	$dstat =~ s/$Ident\s("X")/$1/)
2980	{
2981	}
2982
2983	my $exceptions = qr{
2984	$Declare\|
2985	module_param_named\|
2986	MODULE_PARM_DESC\|
2987	DECLARE_PER_CPU\|
2988	DEFINE_PER_CPU\|
2989	__typeof__\(\|
2990	union\|
2991	struct\|
2992	\.$Ident\s=\s\|
2993	^\"\|\"$
2994	}x;
2995	#print "REST<$rest> dstat<$dstat> ctx<$ctx>\n";
2996	if ($dstat ne '' &&
2997	$dstat !~ /^(?:$Ident\|-?$Constant),$/ && # 10, // foo(),
2998	$dstat !~ /^(?:$Ident\|-?$Constant);$/ && # foo();
2999	$dstat !~ /^[!~-]?(?:$Ident\|$Constant)$/ && # 10 // foo() // !foo // ~foo // -foo
3000	$dstat !~ /^'X'$/ && # character constants
3001	$dstat !~ /$exceptions/ &&
3002	$dstat !~ /^\.$Ident\s*=/ && # .foo =
3003	$dstat !~ /^do\s$Constant\swhile\s*$Constant;?$/ && # do {...} while (...); // do {...} while (...)
3004	$dstat !~ /^for\s*$Constant$/ && # for (...)
3005	$dstat !~ /^for\s*$Constant\s+(?:$Ident\|-?$Constant)$/ && # for (...) bar()
3006	$dstat !~ /^do\s*{/ && # do {...
3007	$dstat !~ /^\({/) # ({...
3008	{
3009	$ctx =~ s/\n*$//;
3010	my $herectx = $here . "\n";
3011	my $cnt = statement_rawlines($ctx);
3012
3013	for (my $n = 0; $n < $cnt; $n++) {
3014	$herectx .= raw_line($linenr, $n) . "\n";
3015	}
3016
3017	if ($dstat =~ /;/) {
3018	ERROR("MULTISTATEMENT_MACRO_USE_DO_WHILE",
3019	"Macros with multiple statements should be enclosed in a do - while loop\n" . "$herectx");
3020	} else {
3021	ERROR("COMPLEX_MACRO",
3022	"Macros with complex values should be enclosed in parenthesis\n" . "$herectx");
3023	}
3024	}
3025
3026	# check for line continuations outside of #defines, preprocessor #, and asm
3027
3028	} else {
3029	if ($prevline !~ /^..*\\$/ &&
3030	$line !~ /^\+\s\#.\\$/ && # preprocessor
3031	$line !~ /^\+.\b(__asm__\|asm)\b.\\$/ && # asm
3032	$line =~ /^\+.*\\$/) {
3033	WARN("LINE_CONTINUATIONS",
3034	"Avoid unnecessary line continuations\n" . $herecurr);
3035	}
3036	}
3037
3038	# do {} while (0) macro tests:
3039	# single-statement macros do not need to be enclosed in do while (0) loop,
3040	# macro should not end with a semicolon
3041	if ($^V && $^V ge 5.10.0 &&
3042	$realfile !~ m@/vmlinux.lds.h$@ &&
3043	$line =~ /^.\s\#\sdefine\s+$Ident(\()?/) {
3044	my $ln = $linenr;
3045	my $cnt = $realcnt;
3046	my ($off, $dstat, $dcond, $rest);
3047	my $ctx = '';
3048	($dstat, $dcond, $ln, $cnt, $off) =
3049	ctx_statement_block($linenr, $realcnt, 0);
3050	$ctx = $dstat;
3051
3052	$dstat =~ s/\\\n.//g;
3053
3054	if ($dstat =~ /^\+\s#\sdefine\s+$Ident\s${balanced_parens}\sdo\s{(.)\s}\swhile\s$\s0\s$\s([;\s])\s$/) {
3055	my $stmts = $2;
3056	my $semis = $3;
3057
3058	$ctx =~ s/\n*$//;
3059	my $cnt = statement_rawlines($ctx);
3060	my $herectx = $here . "\n";
3061
3062	for (my $n = 0; $n < $cnt; $n++) {
3063	$herectx .= raw_line($linenr, $n) . "\n";
3064	}
3065
3066	if (($stmts =~ tr/;/;/) == 1 &&
3067	$stmts !~ /^\s*(if\|while\|for\|switch)\b/) {
3068	WARN("SINGLE_STATEMENT_DO_WHILE_MACRO",
3069	"Single statement macros should not use a do {} while (0) loop\n" . "$herectx");
3070	}
3071	if (defined $semis && $semis ne "") {
3072	WARN("DO_WHILE_MACRO_WITH_TRAILING_SEMICOLON",
3073	"do {} while (0) macros should not be semicolon terminated\n" . "$herectx");
3074	}
3075	}
3076	}
3077
3078	# make sure symbols are always wrapped with VMLINUX_SYMBOL() ...
3079	# all assignments may have only one of the following with an assignment:
3080	# .
3081	# ALIGN(...)
3082	# VMLINUX_SYMBOL(...)
3083	if ($realfile eq 'vmlinux.lds.h' && $line =~ /(?:(?:^\|\s)$Ident\s=\|=\s$Ident(?:\s\|$))/) {
3084	WARN("MISSING_VMLINUX_SYMBOL",
3085	"vmlinux.lds.h needs VMLINUX_SYMBOL() around C-visible symbols\n" . $herecurr);
3086	}
3087
3088	# check for redundant bracing round if etc
3089	if ($line =~ /(^.)\bif\b/ && $1 !~ /else\s$/) {
3090	my ($level, $endln, @chunks) =
3091	ctx_statement_full($linenr, $realcnt, 1);
3092	#print "chunks<$#chunks> linenr<$linenr> endln<$endln> level<$level>\n";
3093	#print "APW: <<$chunks[1][0]>><<$chunks[1][1]>>\n";
3094	if ($#chunks > 0 && $level == 0) {
3095	my @allowed = ();
3096	my $allow = 0;
3097	my $seen = 0;
3098	my $herectx = $here . "\n";
3099	my $ln = $linenr - 1;
3100	for my $chunk (@chunks) {
3101	my ($cond, $block) = @{$chunk};
3102
3103	# If the condition carries leading newlines, then count those as offsets.
3104	my ($whitespace) = ($cond =~ /^((?:\s\n[+-])\s*)/s);
3105	my $offset = statement_rawlines($whitespace) - 1;
3106
3107	$allowed[$allow] = 0;
3108	#print "COND<$cond> whitespace<$whitespace> offset<$offset>\n";
3109
3110	# We have looked at and allowed this specific line.
3111	$suppress_ifbraces{$ln + $offset} = 1;
3112
3113	$herectx .= "$rawlines[$ln + $offset]\n[...]\n";
3114	$ln += statement_rawlines($block) - 1;
3115
3116	substr($block, 0, length($cond), '');
3117
3118	$seen++ if ($block =~ /^\s*{/);
3119
3120	#print "cond<$cond> block<$block> allowed<$allowed[$allow]>\n";
3121	if (statement_lines($cond) > 1) {
3122	#print "APW: ALLOWED: cond<$cond>\n";
3123	$allowed[$allow] = 1;
3124	}
3125	if ($block =~/\b(?:if\|for\|while)\b/) {
3126	#print "APW: ALLOWED: block<$block>\n";
3127	$allowed[$allow] = 1;
3128	}
3129	if (statement_block_size($block) > 1) {
3130	#print "APW: ALLOWED: lines block<$block>\n";
3131	$allowed[$allow] = 1;
3132	}
3133	$allow++;
3134	}
3135	if ($seen) {
3136	my $sum_allowed = 0;
3137	foreach (@allowed) {
3138	$sum_allowed += $_;
3139	}
3140	if ($sum_allowed == 0) {
3141	WARN("BRACES",
3142	"braces {} are not necessary for any arm of this statement\n" . $herectx);
3143	} elsif ($sum_allowed != $allow &&
3144	$seen != $allow) {
3145	CHK("BRACES",
3146	"braces {} should be used on all arms of this statement\n" . $herectx);
3147	}
3148	}
3149	}
3150	}
3151	if (!defined $suppress_ifbraces{$linenr - 1} &&
3152	$line =~ /\b(if\|while\|for\|else)\b/) {
3153	my $allowed = 0;
3154
3155	# Check the pre-context.
3156	if (substr($line, 0, $-[0]) =~ /(\}\s*)$/) {
3157	#print "APW: ALLOWED: pre<$1>\n";
3158	$allowed = 1;
3159	}
3160
3161	my ($level, $endln, @chunks) =
3162	ctx_statement_full($linenr, $realcnt, $-[0]);
3163
3164	# Check the condition.
3165	my ($cond, $block) = @{$chunks[0]};
3166	#print "CHECKING<$linenr> cond<$cond> block<$block>\n";
3167	if (defined $cond) {
3168	substr($block, 0, length($cond), '');
3169	}
3170	if (statement_lines($cond) > 1) {
3171	#print "APW: ALLOWED: cond<$cond>\n";
3172	$allowed = 1;
3173	}
3174	if ($block =~/\b(?:if\|for\|while)\b/) {
3175	#print "APW: ALLOWED: block<$block>\n";
3176	$allowed = 1;
3177	}
3178	if (statement_block_size($block) > 1) {
3179	#print "APW: ALLOWED: lines block<$block>\n";
3180	$allowed = 1;
3181	}
3182	# Check the post-context.
3183	if (defined $chunks[1]) {
3184	my ($cond, $block) = @{$chunks[1]};
3185	if (defined $cond) {
3186	substr($block, 0, length($cond), '');
3187	}
3188	if ($block =~ /^\s*\{/) {
3189	#print "APW: ALLOWED: chunk-1 block<$block>\n";
3190	$allowed = 1;
3191	}
3192	}
3193	if ($level == 0 && $block =~ /^\s*\{/ && !$allowed) {
3194	my $herectx = $here . "\n";
3195	my $cnt = statement_rawlines($block);
3196
3197	for (my $n = 0; $n < $cnt; $n++) {
3198	$herectx .= raw_line($linenr, $n) . "\n";
3199	}
3200
3201	WARN("BRACES",
3202	"braces {} are not necessary for single statement blocks\n" . $herectx);
3203	}
3204	}
3205
3206	# check for unnecessary blank lines around braces
3207	if (($line =~ /^..}\s$/ && $prevline =~ /^.\s*$/)) {
3208	CHK("BRACES",
3209	"Blank lines aren't necessary before a close brace '}'\n" . $hereprev);
3210	}
3211	if (($line =~ /^.\s$/ && $prevline =~ /^..{\s*$/)) {
3212	CHK("BRACES",
3213	"Blank lines aren't necessary after an open brace '{'\n" . $hereprev);
3214	}
3215
3216	# no volatiles please
3217	my $asm_volatile = qr{\b(__asm__\|asm)\s+(__volatile__\|volatile)\b};
3218	if ($line =~ /\bvolatile\b/ && $line !~ /$asm_volatile/) {
3219	WARN("VOLATILE",
3220	"Use of volatile is usually wrong: see Documentation/volatile-considered-harmful.txt\n" . $herecurr);
3221	}
3222
3223	# warn about #if 0
3224	if ($line =~ /^.\s\#\sif\s+0\b/) {
3225	CHK("REDUNDANT_CODE",
3226	"if this code is redundant consider removing it\n" .
3227	$herecurr);
3228	}
3229
3230	# check for needless "if (<foo>) fn(<foo>)" uses
3231	if ($prevline =~ /\bif\s$\s($Lval)\s*$/) {
3232	my $expr = '\s$\s' . quotemeta($1) . '\s$\s;';
3233	if ($line =~ /\b(kfree\|usb_free_urb\|debugfs_remove(?:_recursive)?)$expr/) {
3234	WARN('NEEDLESS_IF',
3235	"$1(NULL) is safe this check is probably not required\n" . $hereprev);
3236	}
3237	}
3238
3239	# prefer usleep_range over udelay
3240	if ($line =~ /\budelay\s$\s(\w+)\s*$/) {
3241	# ignore udelay's < 10, however
3242	if (! (($1 =~ /(\d+)/) && ($1 < 10)) ) {
3243	CHK("USLEEP_RANGE",
3244	"usleep_range is preferred over udelay; see Documentation/timers/timers-howto.txt\n" . $line);
3245	}
3246	}
3247
3248	# warn about unexpectedly long msleep's
3249	if ($line =~ /\bmsleep\s*$(\d+)$;/) {
3250	if ($1 < 20) {
3251	WARN("MSLEEP",
3252	"msleep < 20ms can sleep for up to 20ms; see Documentation/timers/timers-howto.txt\n" . $line);
3253	}
3254	}
3255
3256	# warn about #ifdefs in C files
3257	# if ($line =~ /^.\s\#\sif(\|n)def/ && ($realfile =~ /\.c$/)) {
3258	# print "#ifdef in C files should be avoided\n";
3259	# print "$herecurr";
3260	# $clean = 0;
3261	# }
3262
3263	# warn about spacing in #ifdefs
3264	if ($line =~ /^.\s\#\s(ifdef\|ifndef\|elif)\s\s+/) {
3265	ERROR("SPACING",
3266	"exactly one space required after that #$1\n" . $herecurr);
3267	}
3268
3269	# check for spinlock_t definitions without a comment.
3270	if ($line =~ /^.\s*(struct\s+mutex\|spinlock_t)\s+\S+;/ \|\|
3271	$line =~ /^.\s(DEFINE_MUTEX)\s\(/) {
3272	my $which = $1;
3273	if (!ctx_has_comment($first_line, $linenr)) {
3274	CHK("UNCOMMENTED_DEFINITION",
3275	"$1 definition without comment\n" . $herecurr);
3276	}
3277	}
3278	# check for memory barriers without a comment.
3279	if ($line =~ /\b(mb\|rmb\|wmb\|read_barrier_depends\|smp_mb\|smp_rmb\|smp_wmb\|smp_read_barrier_depends)\(/) {
3280	if (!ctx_has_comment($first_line, $linenr)) {
3281	CHK("MEMORY_BARRIER",
3282	"memory barrier without comment\n" . $herecurr);
3283	}
3284	}
3285	# check of hardware specific defines
3286	if ($line =~ m@^.\s\#\sif.*\b(__i386__\|__powerpc64__\|__sun__\|__s390x__)\b@ && $realfile !~ m@include/asm-@) {
3287	CHK("ARCH_DEFINES",
3288	"architecture specific defines should be avoided\n" . $herecurr);
3289	}
3290
3291	# Check that the storage class is at the beginning of a declaration
3292	if ($line =~ /\b$Storage\b/ && $line !~ /^.\s*$Storage\b/) {
3293	WARN("STORAGE_CLASS",
3294	"storage class should be at the beginning of the declaration\n" . $herecurr)
3295	}
3296
3297	# check the location of the inline attribute, that it is between
3298	# storage class and type.
3299	if ($line =~ /\b$Type\s+$Inline\b/ \|\|
3300	$line =~ /\b$Inline\s+$Storage\b/) {
3301	ERROR("INLINE_LOCATION",
3302	"inline keyword should sit between storage class and type\n" . $herecurr);
3303	}
3304
3305	# Check for __inline__ and __inline, prefer inline
3306	if ($line =~ /\b(__inline__\|__inline)\b/) {
3307	WARN("INLINE",
3308	"plain inline is preferred over $1\n" . $herecurr);
3309	}
3310
3311	# Check for __attribute__ packed, prefer __packed
3312	if ($line =~ /\b__attribute__\s\(\s\(.*\bpacked\b/) {
3313	WARN("PREFER_PACKED",
3314	"__packed is preferred over __attribute__((packed))\n" . $herecurr);
3315	}
3316
3317	# Check for __attribute__ aligned, prefer __aligned
3318	if ($line =~ /\b__attribute__\s\(\s\(.*aligned/) {
3319	WARN("PREFER_ALIGNED",
3320	"__aligned(size) is preferred over __attribute__((aligned(size)))\n" . $herecurr);
3321	}
3322
3323	# Check for __attribute__ format(printf, prefer __printf
3324	if ($line =~ /\b__attribute__\s\(\s\(\sformat\s\(\s*printf/) {
3325	WARN("PREFER_PRINTF",
3326	"__printf(string-index, first-to-check) is preferred over __attribute__((format(printf, string-index, first-to-check)))\n" . $herecurr);
3327	}
3328
3329	# Check for __attribute__ format(scanf, prefer __scanf
3330	if ($line =~ /\b__attribute__\s\(\s\(\sformat\s\(\s*scanf\b/) {
3331	WARN("PREFER_SCANF",
3332	"__scanf(string-index, first-to-check) is preferred over __attribute__((format(scanf, string-index, first-to-check)))\n" . $herecurr);
3333	}
3334
3335	# check for sizeof(&)
3336	if ($line =~ /\bsizeof\s\(\s\&/) {
3337	WARN("SIZEOF_ADDRESS",
3338	"sizeof(& should be avoided\n" . $herecurr);
3339	}
3340
3341	# check for sizeof without parenthesis
3342	if ($line =~ /\bsizeof\s+((?:\\s\|)$Lval\|$Type(?:\s+$Lval\|))/) {
3343	WARN("SIZEOF_PARENTHESIS",
3344	"sizeof $1 should be sizeof($1)\n" . $herecurr);
3345	}
3346
3347	# check for line continuations in quoted strings with odd counts of "
3348	if ($rawline =~ /\\$/ && $rawline =~ tr/"/"/ % 2) {
3349	WARN("LINE_CONTINUATIONS",
3350	"Avoid line continuations in quoted strings\n" . $herecurr);
3351	}
3352
3353	# check for struct spinlock declarations
3354	if ($line =~ /^.\s\bstruct\s+spinlock\s+\w+\s;/) {
3355	WARN("USE_SPINLOCK_T",
3356	"struct spinlock should be spinlock_t\n" . $herecurr);
3357	}
3358
3359	# Check for misused memsets
3360	if ($^V && $^V ge 5.10.0 &&
3361	defined $stat &&
3362	$stat =~ /^\+(?:.?)\bmemset\s$\s$FuncArg\s,\s$FuncArg\s\,\s$FuncArg\s$/s) {
3363
3364	my $ms_addr = $2;
3365	my $ms_val = $7;
3366	my $ms_size = $12;
3367
3368	if ($ms_size =~ /^(0x\|)0$/i) {
3369	ERROR("MEMSET",
3370	"memset to 0's uses 0 as the 2nd argument, not the 3rd\n" . "$here\n$stat\n");
3371	} elsif ($ms_size =~ /^(0x\|)1$/i) {
3372	WARN("MEMSET",
3373	"single byte memset is suspicious. Swapped 2nd/3rd argument?\n" . "$here\n$stat\n");
3374	}
3375	}
3376
3377	# typecasts on min/max could be min_t/max_t
3378	if ($^V && $^V ge 5.10.0 &&
3379	defined $stat &&
3380	$stat =~ /^\+(?:.?)\b(min\|max)\s$\s$FuncArg\s,\s$FuncArg\s$/) {
3381	if (defined $2 \|\| defined $7) {
3382	my $call = $1;
3383	my $cast1 = deparenthesize($2);
3384	my $arg1 = $3;
3385	my $cast2 = deparenthesize($7);
3386	my $arg2 = $8;
3387	my $cast;
3388
3389	if ($cast1 ne "" && $cast2 ne "" && $cast1 ne $cast2) {
3390	$cast = "$cast1 or $cast2";
3391	} elsif ($cast1 ne "") {
3392	$cast = $cast1;
3393	} else {
3394	$cast = $cast2;
3395	}
3396	WARN("MINMAX",
3397	"$call() should probably be ${call}_t($cast, $arg1, $arg2)\n" . "$here\n$stat\n");
3398	}
3399	}
3400
3401	# check usleep_range arguments
3402	if ($^V && $^V ge 5.10.0 &&
3403	defined $stat &&
3404	$stat =~ /^\+(?:.?)\busleep_range\s$\s($FuncArg)\s,\s($FuncArg)\s$/) {
3405	my $min = $1;
3406	my $max = $7;
3407	if ($min eq $max) {
3408	WARN("USLEEP_RANGE",
3409	"usleep_range should not use min == max args; see Documentation/timers/timers-howto.txt\n" . "$here\n$stat\n");
3410	} elsif ($min =~ /^\d+$/ && $max =~ /^\d+$/ &&
3411	$min > $max) {
3412	WARN("USLEEP_RANGE",
3413	"usleep_range args reversed, use min then max; see Documentation/timers/timers-howto.txt\n" . "$here\n$stat\n");
3414	}
3415	}
3416
3417	# check for new externs in .c files.
3418	if ($realfile =~ /\.c$/ && defined $stat &&
3419	$stat =~ /^.\s(?:extern\s+)?$Type\s+($Ident)(\s)\(/s)
3420	{
3421	my $function_name = $1;
3422	my $paren_space = $2;
3423
3424	my $s = $stat;
3425	if (defined $cond) {
3426	substr($s, 0, length($cond), '');
3427	}
3428	if ($s =~ /^\s*;/ &&
3429	$function_name ne 'uninitialized_var')
3430	{
3431	WARN("AVOID_EXTERNS",
3432	"externs should be avoided in .c files\n" . $herecurr);
3433	}
3434
3435	if ($paren_space =~ /\n/) {
3436	WARN("FUNCTION_ARGUMENTS",
3437	"arguments for function declarations should follow identifier\n" . $herecurr);
3438	}
3439
3440	} elsif ($realfile =~ /\.c$/ && defined $stat &&
3441	$stat =~ /^.\s*extern\s+/)
3442	{
3443	WARN("AVOID_EXTERNS",
3444	"externs should be avoided in .c files\n" . $herecurr);
3445	}
3446
3447	# checks for new __setup's
3448	if ($rawline =~ /\b__setup\("([^"]*)"/) {
3449	my $name = $1;
3450
3451	if (!grep(/$name/, @setup_docs)) {
3452	CHK("UNDOCUMENTED_SETUP",
3453	"__setup appears un-documented -- check Documentation/kernel-parameters.txt\n" . $herecurr);
3454	}
3455	}
3456
3457	# check for pointless casting of kmalloc return
3458	if ($line =~ /\\s\)\s*[kv][czm]alloc(_node){0,1}\b/) {
3459	WARN("UNNECESSARY_CASTS",
3460	"unnecessary cast may hide bugs, see http://c-faq.com/malloc/mallocnocast.html\n" . $herecurr);
3461	}
3462
3463	# check for multiple semicolons
3464	if ($line =~ /;\s;\s$/) {
3465	WARN("ONE_SEMICOLON",
3466	"Statements terminations use 1 semicolon\n" . $herecurr);
3467	}
3468
3469	# check for switch/default statements without a break;
3470	if ($^V && $^V ge 5.10.0 &&
3471	defined $stat &&
3472	$stat =~ /^\+[$;\s](?:case[$;\s]+\w+[$;\s]:[$;\s]\|)[$;\s]\bdefault[$;\s]:[$;\s]*;/g) {
3473	my $ctx = '';
3474	my $herectx = $here . "\n";
3475	my $cnt = statement_rawlines($stat);
3476	for (my $n = 0; $n < $cnt; $n++) {
3477	$herectx .= raw_line($linenr, $n) . "\n";
3478	}
3479	WARN("DEFAULT_NO_BREAK",
3480	"switch default: should use break\n" . $herectx);
3481	}
3482
3483	# check for gcc specific __FUNCTION__
3484	if ($line =~ /__FUNCTION__/) {
3485	WARN("USE_FUNC",
3486	"__func__ should be used instead of gcc specific __FUNCTION__\n" . $herecurr);
3487	}
3488
3489	# check for use of yield()
3490	if ($line =~ /\byield\s$\s$/) {
3491	WARN("YIELD",
3492	"Using yield() is generally wrong. See yield() kernel-doc (sched/core.c)\n" . $herecurr);
3493	}
3494
3495	# check for semaphores initialized locked
3496	if ($line =~ /^.\s*sema_init.+,\W?0\W?\)/) {
3497	WARN("CONSIDER_COMPLETION",
3498	"consider using a completion\n" . $herecurr);
3499	}
3500
3501	# recommend kstrto* over simple_strto* and strict_strto*
3502	if ($line =~ /\b((simple\|strict)_(strto(l\|ll\|ul\|ull)))\s*\(/) {
3503	WARN("CONSIDER_KSTRTO",
3504	"$1 is obsolete, use k$3 instead\n" . $herecurr);
3505	}
3506
3507	# check for __initcall(), use device_initcall() explicitly please
3508	if ($line =~ /^.\s__initcall\s\(/) {
3509	WARN("USE_DEVICE_INITCALL",
3510	"please use device_initcall() instead of __initcall()\n" . $herecurr);
3511	}
3512
3513	# check for various ops structs, ensure they are const.
3514	my $struct_ops = qr{acpi_dock_ops\|
3515	address_space_operations\|
3516	backlight_ops\|
3517	block_device_operations\|
3518	dentry_operations\|
3519	dev_pm_ops\|
3520	dma_map_ops\|
3521	extent_io_ops\|
3522	file_lock_operations\|
3523	file_operations\|
3524	hv_ops\|
3525	ide_dma_ops\|
3526	intel_dvo_dev_ops\|
3527	item_operations\|
3528	iwl_ops\|
3529	kgdb_arch\|
3530	kgdb_io\|
3531	kset_uevent_ops\|
3532	lock_manager_operations\|
3533	microcode_ops\|
3534	mtrr_ops\|
3535	neigh_ops\|
3536	nlmsvc_binding\|
3537	pci_raw_ops\|
3538	pipe_buf_operations\|
3539	platform_hibernation_ops\|
3540	platform_suspend_ops\|
3541	proto_ops\|
3542	rpc_pipe_ops\|
3543	seq_operations\|
3544	snd_ac97_build_ops\|
3545	soc_pcmcia_socket_ops\|
3546	stacktrace_ops\|
3547	sysfs_ops\|
3548	tty_operations\|
3549	usb_mon_operations\|
3550	wd_ops}x;
3551	if ($line !~ /\bconst\b/ &&
3552	$line =~ /\bstruct\s+($struct_ops)\b/) {
3553	WARN("CONST_STRUCT",
3554	"struct $1 should normally be const\n" .
3555	$herecurr);
3556	}
3557
3558	# use of NR_CPUS is usually wrong
3559	# ignore definitions of NR_CPUS and usage to define arrays as likely right
3560	if ($line =~ /\bNR_CPUS\b/ &&
3561	$line !~ /^.\s\s#\sif\b.\bNR_CPUS\b/ &&
3562	$line !~ /^.\s\s#\sdefine\b.\bNR_CPUS\b/ &&
3563	$line !~ /^.\s$Declare\s.\[[^\]]NR_CPUS[^\]]\]/ &&
3564	$line !~ /\[[^\]]\.\.\.[^\]]NR_CPUS[^\]]*\]/ &&
3565	$line !~ /\[[^\]]NR_CPUS[^\]]\.\.\.[^\]]*\]/)
3566	{
3567	WARN("NR_CPUS",
3568	"usage of NR_CPUS is often wrong - consider using cpu_possible(), num_possible_cpus(), for_each_possible_cpu(), etc\n" . $herecurr);
3569	}
3570
3571	# check for %L{u,d,i} in strings
3572	my $string;
3573	while ($line =~ /(?:^\|")([X\t]*)(?:"\|$)/g) {
3574	$string = substr($rawline, $-[1], $+[1] - $-[1]);
3575	$string =~ s/%%/__/g;
3576	if ($string =~ /(?<!%)%L[udi]/) {
3577	WARN("PRINTF_L",
3578	"\%Ld/%Lu are not-standard C, use %lld/%llu\n" . $herecurr);
3579	last;
3580	}
3581	}
3582
3583	# whine mightly about in_atomic
3584	if ($line =~ /\bin_atomic\s*\(/) {
3585	if ($realfile =~ m@^drivers/@) {
3586	ERROR("IN_ATOMIC",
3587	"do not use in_atomic in drivers\n" . $herecurr);
3588	} elsif ($realfile !~ m@^kernel/@) {
3589	WARN("IN_ATOMIC",
3590	"use of in_atomic() is incorrect outside core kernel code\n" . $herecurr);
3591	}
3592	}
3593
3594	# check for lockdep_set_novalidate_class
3595	if ($line =~ /^.\slockdep_set_novalidate_class\s\(/ \|\|
3596	$line =~ /__lockdep_no_validate__\s*\)/ ) {
3597	if ($realfile !~ m@^kernel/lockdep@ &&
3598	$realfile !~ m@^include/linux/lockdep@ &&
3599	$realfile !~ m@^drivers/base/core@) {
3600	ERROR("LOCKDEP",
3601	"lockdep_no_validate class is reserved for device->mutex.\n" . $herecurr);
3602	}
3603	}
3604
3605	if ($line =~ /debugfs_create_file.*S_IWUGO/ \|\|
3606	$line =~ /DEVICE_ATTR.*S_IWUGO/ ) {
3607	WARN("EXPORTED_WORLD_WRITABLE",
3608	"Exporting world writable files is usually an error. Consider more restrictive permissions.\n" . $herecurr);
3609	}
3610	}
3611
3612	# If we have no input at all, then there is nothing to report on
3613	# so just keep quiet.
3614	if ($#rawlines == -1) {
3615	exit(0);
3616	}
3617
3618	# In mailback mode only produce a report in the negative, for
3619	# things that appear to be patches.
3620	if ($mailback && ($clean == 1 \|\| !$is_patch)) {
3621	exit(0);
3622	}
3623
3624	# This is not a patch, and we are are in 'no-patch' mode so
3625	# just keep quiet.
3626	if (!$chk_patch && !$is_patch) {
3627	exit(0);
3628	}
3629
3630	if (!$is_patch) {
3631	ERROR("NOT_UNIFIED_DIFF",
3632	"Does not appear to be a unified-diff format patch\n");
3633	}
3634	if ($is_patch && $chk_signoff && $signoff == 0) {
3635	ERROR("MISSING_SIGN_OFF",
3636	"Missing Signed-off-by: line(s)\n");
3637	}
3638
3639	print report_dump();
3640	if ($summary && !($clean == 1 && $quiet == 1)) {
3641	print "$filename " if ($summary_file);
3642	print "total: $cnt_error errors, $cnt_warn warnings, " .
3643	(($check)? "$cnt_chk checks, " : "") .
3644	"$cnt_lines lines checked\n";
3645	print "\n" if ($quiet == 0);
3646	}
3647
3648	if ($quiet == 0) {
3649
3650	if ($^V lt 5.10.0) {
3651	print("NOTE: perl $^V is not modern enough to detect all possible issues.\n");
3652	print("An upgrade to at least perl v5.10.0 is suggested.\n\n");
3653	}
3654
3655	# If there were whitespace errors which cleanpatch can fix
3656	# then suggest that.
3657	if ($rpt_cleaners) {
3658	print "NOTE: whitespace errors detected, you may wish to use scripts/cleanpatch or\n";
3659	print " scripts/cleanfile\n\n";
3660	$rpt_cleaners = 0;
3661	}
3662	}
3663
3664	if ($quiet == 0 && keys %ignore_type) {
3665	print "NOTE: Ignored message types:";
3666	foreach my $ignore (sort keys %ignore_type) {
3667	print " $ignore";
3668	}
3669	print "\n\n";
3670	}
3671
3672	if ($clean == 1 && $quiet == 0) {
3673	print "$vname has no obvious style problems and is ready for submission.\n"
3674	}
3675	if ($clean == 0 && $quiet == 0) {
3676	print << "EOM";
3677	$vname has style problems, please review.
3678
3679	If any of these errors are false positives, please report
3680	them to the maintainer, see CHECKPATCH in MAINTAINERS.
3681	EOM
3682	}
3683
3684	return $clean;
3685	}