linux - scripts/checkpatch.pl

5163 lines · 145.6 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	use POSIX;
10
11	my $P = $0;
12	$P =~ s@.*/@@g;
13
14	my $V = '0.32';
15
16	use Getopt::Long qw(:config no_auto_abbrev);
17
18	my $quiet = 0;
19	my $tree = 1;
20	my $chk_signoff = 1;
21	my $chk_patch = 1;
22	my $tst_only;
23	my $emacs = 0;
24	my $terse = 0;
25	my $file = 0;
26	my $check = 0;
27	my $check_orig = 0;
28	my $summary = 1;
29	my $mailback = 0;
30	my $summary_file = 0;
31	my $show_types = 0;
32	my $fix = 0;
33	my $fix_inplace = 0;
34	my $root;
35	my %debug;
36	my %camelcase = ();
37	my %use_type = ();
38	my @use = ();
39	my %ignore_type = ();
40	my @ignore = ();
41	my $help = 0;
42	my $configuration_file = ".checkpatch.conf";
43	my $max_line_length = 80;
44	my $ignore_perl_version = 0;
45	my $minimum_perl_version = 5.10.0;
46
47	sub help {
48	my ($exitcode) = @_;
49
50	print << "EOM";
51	Usage: $P [OPTION]... [FILE]...
52	Version: $V
53
54	Options:
55	-q, --quiet quiet
56	--no-tree run without a kernel tree
57	--no-signoff do not check for 'Signed-off-by' line
58	--patch treat FILE as patchfile (default)
59	--emacs emacs compile window format
60	--terse one line per report
61	-f, --file treat FILE as regular source file
62	--subjective, --strict enable more subjective tests
63	--types TYPE(,TYPE2...) show only these comma separated message types
64	--ignore TYPE(,TYPE2...) ignore various comma separated message types
65	--max-line-length=n set the maximum line length, if exceeded, warn
66	--show-types show the message "types" in the output
67	--root=PATH PATH to the kernel tree root
68	--no-summary suppress the per-file summary
69	--mailback only produce a report in case of warnings/errors
70	--summary-file include the filename in summary
71	--debug KEY=[0\|1] turn on/off debugging of KEY, where KEY is one of
72	'values', 'possible', 'type', and 'attr' (default
73	is all off)
74	--test-only=WORD report only warnings/errors containing WORD
75	literally
76	--fix EXPERIMENTAL - may create horrible results
77	If correctable single-line errors exist, create
78	"<inputfile>.EXPERIMENTAL-checkpatch-fixes"
79	with potential errors corrected to the preferred
80	checkpatch style
81	--fix-inplace EXPERIMENTAL - may create horrible results
82	Is the same as --fix, but overwrites the input
83	file. It's your fault if there's no backup or git
84	--ignore-perl-version override checking of perl version. expect
85	runtime errors.
86	-h, --help, --version display this help and exit
87
88	When FILE is - read standard input.
89	EOM
90
91	exit($exitcode);
92	}
93
94	my $conf = which_conf($configuration_file);
95	if (-f $conf) {
96	my @conf_args;
97	open(my $conffile, '<', "$conf")
98	or warn "$P: Can't find a readable $configuration_file file $!\n";
99
100	while (<$conffile>) {
101	my $line = $_;
102
103	$line =~ s/\s*\n?$//g;
104	$line =~ s/^\s*//g;
105	$line =~ s/\s+/ /g;
106
107	next if ($line =~ m/^\s*#/);
108	next if ($line =~ m/^\s*$/);
109
110	my @words = split(" ", $line);
111	foreach my $word (@words) {
112	last if ($word =~ m/^#/);
113	push (@conf_args, $word);
114	}
115	}
116	close($conffile);
117	unshift(@ARGV, @conf_args) if @conf_args;
118	}
119
120	GetOptions(
121	'q\|quiet+' => \$quiet,
122	'tree!' => \$tree,
123	'signoff!' => \$chk_signoff,
124	'patch!' => \$chk_patch,
125	'emacs!' => \$emacs,
126	'terse!' => \$terse,
127	'f\|file!' => \$file,
128	'subjective!' => \$check,
129	'strict!' => \$check,
130	'ignore=s' => \@ignore,
131	'types=s' => \@use,
132	'show-types!' => \$show_types,
133	'max-line-length=i' => \$max_line_length,
134	'root=s' => \$root,
135	'summary!' => \$summary,
136	'mailback!' => \$mailback,
137	'summary-file!' => \$summary_file,
138	'fix!' => \$fix,
139	'fix-inplace!' => \$fix_inplace,
140	'ignore-perl-version!' => \$ignore_perl_version,
141	'debug=s' => \%debug,
142	'test-only=s' => \$tst_only,
143	'h\|help' => \$help,
144	'version' => \$help
145	) or help(1);
146
147	help(0) if ($help);
148
149	$fix = 1 if ($fix_inplace);
150	$check_orig = $check;
151
152	my $exit = 0;
153
154	if ($^V && $^V lt $minimum_perl_version) {
155	printf "$P: requires at least perl version %vd\n", $minimum_perl_version;
156	if (!$ignore_perl_version) {
157	exit(1);
158	}
159	}
160
161	if ($#ARGV < 0) {
162	print "$P: no input files\n";
163	exit(1);
164	}
165
166	sub hash_save_array_words {
167	my ($hashRef, $arrayRef) = @_;
168
169	my @array = split(/,/, join(',', @$arrayRef));
170	foreach my $word (@array) {
171	$word =~ s/\s*\n?$//g;
172	$word =~ s/^\s*//g;
173	$word =~ s/\s+/ /g;
174	$word =~ tr/[a-z]/[A-Z]/;
175
176	next if ($word =~ m/^\s*#/);
177	next if ($word =~ m/^\s*$/);
178
179	$hashRef->{$word}++;
180	}
181	}
182
183	sub hash_show_words {
184	my ($hashRef, $prefix) = @_;
185
186	if ($quiet == 0 && keys %$hashRef) {
187	print "NOTE: $prefix message types:";
188	foreach my $word (sort keys %$hashRef) {
189	print " $word";
190	}
191	print "\n\n";
192	}
193	}
194
195	hash_save_array_words(\%ignore_type, \@ignore);
196	hash_save_array_words(\%use_type, \@use);
197
198	my $dbg_values = 0;
199	my $dbg_possible = 0;
200	my $dbg_type = 0;
201	my $dbg_attr = 0;
202	for my $key (keys %debug) {
203	## no critic
204	eval "\${dbg_$key} = '$debug{$key}';";
205	die "$@" if ($@);
206	}
207
208	my $rpt_cleaners = 0;
209
210	if ($terse) {
211	$emacs = 1;
212	$quiet++;
213	}
214
215	if ($tree) {
216	if (defined $root) {
217	if (!top_of_kernel_tree($root)) {
218	die "$P: $root: --root does not point at a valid tree\n";
219	}
220	} else {
221	if (top_of_kernel_tree('.')) {
222	$root = '.';
223	} elsif ($0 =~ m@(.)/scripts/[^/]$@ &&
224	top_of_kernel_tree($1)) {
225	$root = $1;
226	}
227	}
228
229	if (!defined $root) {
230	print "Must be run from the top-level dir. of a kernel tree\n";
231	exit(2);
232	}
233	}
234
235	my $emitted_corrupt = 0;
236
237	our $Ident = qr{
238	[A-Za-z_][A-Za-z\d_]*
239	(?:\s\#\#\s[A-Za-z_][A-Za-z\d_])
240	}x;
241	our $Storage = qr{extern\|static\|asmlinkage};
242	our $Sparse = qr{
243	__user\|
244	__kernel\|
245	__force\|
246	__iomem\|
247	__must_check\|
248	__init_refok\|
249	__kprobes\|
250	__ref\|
251	__rcu
252	}x;
253	our $InitAttributePrefix = qr{__(?:mem\|cpu\|dev\|net_\|)};
254	our $InitAttributeData = qr{$InitAttributePrefix(?:initdata\b)};
255	our $InitAttributeConst = qr{$InitAttributePrefix(?:initconst\b)};
256	our $InitAttributeInit = qr{$InitAttributePrefix(?:init\b)};
257	our $InitAttribute = qr{$InitAttributeData\|$InitAttributeConst\|$InitAttributeInit};
258
259	# Notes to $Attribute:
260	# We need \b after 'init' otherwise 'initconst' will cause a false positive in a check
261	our $Attribute = qr{
262	const\|
263	__percpu\|
264	__nocast\|
265	__safe\|
266	__bitwise__\|
267	__packed__\|
268	__packed2__\|
269	__naked\|
270	__maybe_unused\|
271	__always_unused\|
272	__noreturn\|
273	__used\|
274	__cold\|
275	__noclone\|
276	__deprecated\|
277	__read_mostly\|
278	__kprobes\|
279	$InitAttribute\|
280	____cacheline_aligned\|
281	____cacheline_aligned_in_smp\|
282	____cacheline_internodealigned_in_smp\|
283	__weak
284	}x;
285	our $Modifier;
286	our $Inline = qr{inline\|__always_inline\|noinline\|__inline\|__inline__};
287	our $Member = qr{->$Ident\|\.$Ident\|\[[^]]*\]};
288	our $Lval = qr{$Ident(?:$Member)*};
289
290	our $Int_type = qr{(?i)llu\|ull\|ll\|lu\|ul\|l\|u};
291	our $Binary = qr{(?i)0b[01]+$Int_type?};
292	our $Hex = qr{(?i)0x[0-9a-f]+$Int_type?};
293	our $Int = qr{[0-9]+$Int_type?};
294	our $Octal = qr{0[0-7]+$Int_type?};
295	our $Float_hex = qr{(?i)0x[0-9a-f]+p-?[0-9]+[fl]?};
296	our $Float_dec = qr{(?i)(?:[0-9]+\.[0-9]\|[0-9]\.[0-9]+)(?:e-?[0-9]+)?[fl]?};
297	our $Float_int = qr{(?i)[0-9]+e-?[0-9]+[fl]?};
298	our $Float = qr{$Float_hex\|$Float_dec\|$Float_int};
299	our $Constant = qr{$Float\|$Binary\|$Octal\|$Hex\|$Int};
300	our $Assignment = qr{\*\=\|/=\|%=\|\+=\|-=\|<<=\|>>=\|&=\|\^=\|\\|=\|=};
301	our $Compare = qr{<=\|>=\|==\|!=\|<\|(?<!-)>};
302	our $Arithmetic = qr{\+\|-\|\*\|\/\|%};
303	our $Operators = qr{
304	<=\|>=\|==\|!=\|
305	=>\|->\|<<\|>>\|<\|>\|!\|~\|
306	&&\|\\|\\|\|,\|\^\|\+\+\|--\|&\|\\|\|$Arithmetic
307	}x;
308
309	our $c90_Keywords = qr{do\|for\|while\|if\|else\|return\|goto\|continue\|switch\|default\|case\|break}x;
310
311	our $NonptrType;
312	our $NonptrTypeMisordered;
313	our $NonptrTypeWithAttr;
314	our $Type;
315	our $TypeMisordered;
316	our $Declare;
317	our $DeclareMisordered;
318
319	our $NON_ASCII_UTF8 = qr{
320	[\xC2-\xDF][\x80-\xBF] # non-overlong 2-byte
321	\| \xE0[\xA0-\xBF][\x80-\xBF] # excluding overlongs
322	\| [\xE1-\xEC\xEE\xEF][\x80-\xBF]{2} # straight 3-byte
323	\| \xED[\x80-\x9F][\x80-\xBF] # excluding surrogates
324	\| \xF0[\x90-\xBF][\x80-\xBF]{2} # planes 1-3
325	\| [\xF1-\xF3][\x80-\xBF]{3} # planes 4-15
326	\| \xF4[\x80-\x8F][\x80-\xBF]{2} # plane 16
327	}x;
328
329	our $UTF8 = qr{
330	[\x09\x0A\x0D\x20-\x7E] # ASCII
331	\| $NON_ASCII_UTF8
332	}x;
333
334	our $typeTypedefs = qr{(?x:
335	(?:__)?(?:u\|s\|be\|le)(?:8\|16\|32\|64)\|
336	atomic_t
337	)};
338
339	our $logFunctions = qr{(?x:
340	printk(?:_ratelimited\|_once\|)\|
341	(?:[a-z0-9]+_){1,2}(?:printk\|emerg\|alert\|crit\|err\|warning\|warn\|notice\|info\|debug\|dbg\|vdbg\|devel\|cont\|WARN)(?:_ratelimited\|_once\|)\|
342	WARN(?:_RATELIMIT\|_ONCE\|)\|
343	panic\|
344	MODULE_[A-Z_]+\|
345	seq_vprintf\|seq_printf\|seq_puts
346	)};
347
348	our $signature_tags = qr{(?xi:
349	Signed-off-by:\|
350	Acked-by:\|
351	Tested-by:\|
352	Reviewed-by:\|
353	Reported-by:\|
354	Suggested-by:\|
355	To:\|
356	Cc:
357	)};
358
359	our @typeListMisordered = (
360	qr{char\s+(?:un)?signed},
361	qr{int\s+(?:(?:un)?signed\s+)?short\s},
362	qr{int\s+short(?:\s+(?:un)?signed)},
363	qr{short\s+int(?:\s+(?:un)?signed)},
364	qr{(?:un)?signed\s+int\s+short},
365	qr{short\s+(?:un)?signed},
366	qr{long\s+int\s+(?:un)?signed},
367	qr{int\s+long\s+(?:un)?signed},
368	qr{long\s+(?:un)?signed\s+int},
369	qr{int\s+(?:un)?signed\s+long},
370	qr{int\s+(?:un)?signed},
371	qr{int\s+long\s+long\s+(?:un)?signed},
372	qr{long\s+long\s+int\s+(?:un)?signed},
373	qr{long\s+long\s+(?:un)?signed\s+int},
374	qr{long\s+long\s+(?:un)?signed},
375	qr{long\s+(?:un)?signed},
376	);
377
378	our @typeList = (
379	qr{void},
380	qr{(?:(?:un)?signed\s+)?char},
381	qr{(?:(?:un)?signed\s+)?short\s+int},
382	qr{(?:(?:un)?signed\s+)?short},
383	qr{(?:(?:un)?signed\s+)?int},
384	qr{(?:(?:un)?signed\s+)?long\s+int},
385	qr{(?:(?:un)?signed\s+)?long\s+long\s+int},
386	qr{(?:(?:un)?signed\s+)?long\s+long},
387	qr{(?:(?:un)?signed\s+)?long},
388	qr{(?:un)?signed},
389	qr{float},
390	qr{double},
391	qr{bool},
392	qr{struct\s+$Ident},
393	qr{union\s+$Ident},
394	qr{enum\s+$Ident},
395	qr{${Ident}_t},
396	qr{${Ident}_handler},
397	qr{${Ident}_handler_fn},
398	@typeListMisordered,
399	);
400	our @typeListWithAttr = (
401	@typeList,
402	qr{struct\s+$InitAttribute\s+$Ident},
403	qr{union\s+$InitAttribute\s+$Ident},
404	);
405
406	our @modifierList = (
407	qr{fastcall},
408	);
409
410	our @mode_permission_funcs = (
411	["module_param", 3],
412	["module_param_(?:array\|named\|string)", 4],
413	["module_param_array_named", 5],
414	["debugfs_create_(?:file\|u8\|u16\|u32\|u64\|x8\|x16\|x32\|x64\|size_t\|atomic_t\|bool\|blob\|regset32\|u32_array)", 2],
415	["proc_create(?:_data\|)", 2],
416	["(?:CLASS\|DEVICE\|SENSOR)_ATTR", 2],
417	);
418
419	#Create a search pattern for all these functions to speed up a loop below
420	our $mode_perms_search = "";
421	foreach my $entry (@mode_permission_funcs) {
422	$mode_perms_search .= '\|' if ($mode_perms_search ne "");
423	$mode_perms_search .= $entry->[0];
424	}
425
426	our $allowed_asm_includes = qr{(?x:
427	irq\|
428	memory
429	)};
430	# memory.h: ARM has a custom one
431
432	sub build_types {
433	my $mods = "(?x: \n" . join("\|\n ", @modifierList) . "\n)";
434	my $all = "(?x: \n" . join("\|\n ", @typeList) . "\n)";
435	my $Misordered = "(?x: \n" . join("\|\n ", @typeListMisordered) . "\n)";
436	my $allWithAttr = "(?x: \n" . join("\|\n ", @typeListWithAttr) . "\n)";
437	$Modifier = qr{(?:$Attribute\|$Sparse\|$mods)};
438	$NonptrType = qr{
439	(?:$Modifier\s+\|const\s+)*
440	(?:
441	(?:typeof\|__typeof__)\s$[^$]\)\|
442	(?:$typeTypedefs\b)\|
443	(?:${all}\b)
444	)
445	(?:\s+$Modifier\|\s+const)*
446	}x;
447	$NonptrTypeMisordered = qr{
448	(?:$Modifier\s+\|const\s+)*
449	(?:
450	(?:${Misordered}\b)
451	)
452	(?:\s+$Modifier\|\s+const)*
453	}x;
454	$NonptrTypeWithAttr = qr{
455	(?:$Modifier\s+\|const\s+)*
456	(?:
457	(?:typeof\|__typeof__)\s$[^$]\)\|
458	(?:$typeTypedefs\b)\|
459	(?:${allWithAttr}\b)
460	)
461	(?:\s+$Modifier\|\s+const)*
462	}x;
463	$Type = qr{
464	$NonptrType
465	(?:(?:\s\|\\|\[\])+\sconst\|(?:\s\|\\s(?:const\s)?\|\[\])+\|(?:\s\[\s*\])+)?
466	(?:\s+$Inline\|\s+$Modifier)*
467	}x;
468	$TypeMisordered = qr{
469	$NonptrTypeMisordered
470	(?:(?:\s\|\\|\[\])+\sconst\|(?:\s\|\\s(?:const\s)?\|\[\])+\|(?:\s\[\s*\])+)?
471	(?:\s+$Inline\|\s+$Modifier)*
472	}x;
473	$Declare = qr{(?:$Storage\s+(?:$Inline\s+)?)?$Type};
474	$DeclareMisordered = qr{(?:$Storage\s+(?:$Inline\s+)?)?$TypeMisordered};
475	}
476	build_types();
477
478	our $Typecast = qr{\s($\s$NonptrType\s$){0,1}\s};
479
480	# Using $balanced_parens, $LvalOrFunc, or $FuncArg
481	# requires at least perl version v5.10.0
482	# Any use must be runtime checked with $^V
483
484	our $balanced_parens = qr/($(?:[^\($]++\|(?-1))*\))/;
485	our $LvalOrFunc = qr{((?:[\&\]\s)?$Lval)\s($balanced_parens{0,1})\s};
486	our $FuncArg = qr{$Typecast{0,1}($LvalOrFunc\|$Constant)};
487
488	our $declaration_macros = qr{(?x:
489	(?:$Storage\s+)?(?:[A-Z_][A-Z0-9]_){0,2}(?:DEFINE\|DECLARE)(?:_[A-Z0-9]+){1,2}\s\(\|
490	(?:$Storage\s+)?LIST_HEAD\s*\(\|
491	(?:$Storage\s+)?${Type}\s+uninitialized_var\s*\(
492	)};
493
494	sub deparenthesize {
495	my ($string) = @_;
496	return "" if (!defined($string));
497
498	while ($string =~ /^\s$.$\s*$/) {
499	$string =~ s@^\s\(\s@@;
500	$string =~ s@\s\)\s$@@;
501	}
502
503	$string =~ s@\s+@ @g;
504
505	return $string;
506	}
507
508	sub seed_camelcase_file {
509	my ($file) = @_;
510
511	return if (!(-f $file));
512
513	local $/;
514
515	open(my $include_file, '<', "$file")
516	or warn "$P: Can't read '$file' $!\n";
517	my $text = <$include_file>;
518	close($include_file);
519
520	my @lines = split('\n', $text);
521
522	foreach my $line (@lines) {
523	next if ($line !~ /(?:[A-Z][a-z]\|[a-z][A-Z])/);
524	if ($line =~ /^[ \t](?:#[ \t]define\|typedef\s+$Type)\s+(\w(?:[A-Z][a-z]\|[a-z][A-Z])\w)/) {
525	$camelcase{$1} = 1;
526	} elsif ($line =~ /^\s$Declare\s+(\w(?:[A-Z][a-z]\|[a-z][A-Z])\w)\s[\(\[,;]/) {
527	$camelcase{$1} = 1;
528	} elsif ($line =~ /^\s(?:union\|struct\|enum)\s+(\w(?:[A-Z][a-z]\|[a-z][A-Z])\w)\s[;\{]/) {
529	$camelcase{$1} = 1;
530	}
531	}
532	}
533
534	my $camelcase_seeded = 0;
535	sub seed_camelcase_includes {
536	return if ($camelcase_seeded);
537
538	my $files;
539	my $camelcase_cache = "";
540	my @include_files = ();
541
542	$camelcase_seeded = 1;
543
544	if (-e ".git") {
545	my $git_last_include_commit = `git log --no-merges --pretty=format:"%h%n" -1 -- include`;
546	chomp $git_last_include_commit;
547	$camelcase_cache = ".checkpatch-camelcase.git.$git_last_include_commit";
548	} else {
549	my $last_mod_date = 0;
550	$files = `find $root/include -name "*.h"`;
551	@include_files = split('\n', $files);
552	foreach my $file (@include_files) {
553	my $date = POSIX::strftime("%Y%m%d%H%M",
554	localtime((stat $file)[9]));
555	$last_mod_date = $date if ($last_mod_date < $date);
556	}
557	$camelcase_cache = ".checkpatch-camelcase.date.$last_mod_date";
558	}
559
560	if ($camelcase_cache ne "" && -f $camelcase_cache) {
561	open(my $camelcase_file, '<', "$camelcase_cache")
562	or warn "$P: Can't read '$camelcase_cache' $!\n";
563	while (<$camelcase_file>) {
564	chomp;
565	$camelcase{$_} = 1;
566	}
567	close($camelcase_file);
568
569	return;
570	}
571
572	if (-e ".git") {
573	$files = `git ls-files "include/*.h"`;
574	@include_files = split('\n', $files);
575	}
576
577	foreach my $file (@include_files) {
578	seed_camelcase_file($file);
579	}
580
581	if ($camelcase_cache ne "") {
582	unlink glob ".checkpatch-camelcase.*";
583	open(my $camelcase_file, '>', "$camelcase_cache")
584	or warn "$P: Can't write '$camelcase_cache' $!\n";
585	foreach (sort { lc($a) cmp lc($b) } keys(%camelcase)) {
586	print $camelcase_file ("$_\n");
587	}
588	close($camelcase_file);
589	}
590	}
591
592	sub git_commit_info {
593	my ($commit, $id, $desc) = @_;
594
595	return ($id, $desc) if ((which("git") eq "") \|\| !(-e ".git"));
596
597	my $output = `git log --no-color --format='%H %s' -1 $commit 2>&1`;
598	$output =~ s/^\s*//gm;
599	my @lines = split("\n", $output);
600
601	if ($lines[0] =~ /^error: short SHA1 $commit is ambiguous\./) {
602	# Maybe one day convert this block of bash into something that returns
603	# all matching commit ids, but it's very slow...
604	#
605	# echo "checking commits $1..."
606	# git rev-list --remotes \| grep -i "^$1" \|
607	# while read line ; do
608	# git log --format='%H %s' -1 $line \|
609	# echo "commit $(cut -c 1-12,41-)"
610	# done
611	} elsif ($lines[0] =~ /^fatal: ambiguous argument '$commit': unknown revision or path not in the working tree\./) {
612	} else {
613	$id = substr($lines[0], 0, 12);
614	$desc = substr($lines[0], 41);
615	}
616
617	return ($id, $desc);
618	}
619
620	$chk_signoff = 0 if ($file);
621
622	my @rawlines = ();
623	my @lines = ();
624	my @fixed = ();
625	my @fixed_inserted = ();
626	my @fixed_deleted = ();
627	my $fixlinenr = -1;
628
629	my $vname;
630	for my $filename (@ARGV) {
631	my $FILE;
632	if ($file) {
633	open($FILE, '-\|', "diff -u /dev/null $filename") \|\|
634	die "$P: $filename: diff failed - $!\n";
635	} elsif ($filename eq '-') {
636	open($FILE, '<&STDIN');
637	} else {
638	open($FILE, '<', "$filename") \|\|
639	die "$P: $filename: open failed - $!\n";
640	}
641	if ($filename eq '-') {
642	$vname = 'Your patch';
643	} else {
644	$vname = $filename;
645	}
646	while (<$FILE>) {
647	chomp;
648	push(@rawlines, $_);
649	}
650	close($FILE);
651	if (!process($filename)) {
652	$exit = 1;
653	}
654	@rawlines = ();
655	@lines = ();
656	@fixed = ();
657	@fixed_inserted = ();
658	@fixed_deleted = ();
659	$fixlinenr = -1;
660	}
661
662	exit($exit);
663
664	sub top_of_kernel_tree {
665	my ($root) = @_;
666
667	my @tree_check = (
668	"COPYING", "CREDITS", "Kbuild", "MAINTAINERS", "Makefile",
669	"README", "Documentation", "arch", "include", "drivers",
670	"fs", "init", "ipc", "kernel", "lib", "scripts",
671	);
672
673	foreach my $check (@tree_check) {
674	if (! -e $root . '/' . $check) {
675	return 0;
676	}
677	}
678	return 1;
679	}
680
681	sub parse_email {
682	my ($formatted_email) = @_;
683
684	my $name = "";
685	my $address = "";
686	my $comment = "";
687
688	if ($formatted_email =~ /^(.)<(\S+\@\S+)>(.)$/) {
689	$name = $1;
690	$address = $2;
691	$comment = $3 if defined $3;
692	} elsif ($formatted_email =~ /^\s<(\S+\@\S+)>(.)$/) {
693	$address = $1;
694	$comment = $2 if defined $2;
695	} elsif ($formatted_email =~ /(\S+\@\S+)(.*)$/) {
696	$address = $1;
697	$comment = $2 if defined $2;
698	$formatted_email =~ s/$address.*$//;
699	$name = $formatted_email;
700	$name = trim($name);
701	$name =~ s/^\"\|\"$//g;
702	# If there's a name left after stripping spaces and
703	# leading quotes, and the address doesn't have both
704	# leading and trailing angle brackets, the address
705	# is invalid. ie:
706	# "joe smith [email protected]" bad
707	# "joe smith <[email protected]" bad
708	if ($name ne "" && $address !~ /^<[^>]+>$/) {
709	$name = "";
710	$address = "";
711	$comment = "";
712	}
713	}
714
715	$name = trim($name);
716	$name =~ s/^\"\|\"$//g;
717	$address = trim($address);
718	$address =~ s/^\<\|\>$//g;
719
720	if ($name =~ /[^\w \-]/i) { ##has "must quote" chars
721	$name =~ s/(?<!\\)"/\\"/g; ##escape quotes
722	$name = "\"$name\"";
723	}
724
725	return ($name, $address, $comment);
726	}
727
728	sub format_email {
729	my ($name, $address) = @_;
730
731	my $formatted_email;
732
733	$name = trim($name);
734	$name =~ s/^\"\|\"$//g;
735	$address = trim($address);
736
737	if ($name =~ /[^\w \-]/i) { ##has "must quote" chars
738	$name =~ s/(?<!\\)"/\\"/g; ##escape quotes
739	$name = "\"$name\"";
740	}
741
742	if ("$name" eq "") {
743	$formatted_email = "$address";
744	} else {
745	$formatted_email = "$name <$address>";
746	}
747
748	return $formatted_email;
749	}
750
751	sub which {
752	my ($bin) = @_;
753
754	foreach my $path (split(/:/, $ENV{PATH})) {
755	if (-e "$path/$bin") {
756	return "$path/$bin";
757	}
758	}
759
760	return "";
761	}
762
763	sub which_conf {
764	my ($conf) = @_;
765
766	foreach my $path (split(/:/, ".:$ENV{HOME}:.scripts")) {
767	if (-e "$path/$conf") {
768	return "$path/$conf";
769	}
770	}
771
772	return "";
773	}
774
775	sub expand_tabs {
776	my ($str) = @_;
777
778	my $res = '';
779	my $n = 0;
780	for my $c (split(//, $str)) {
781	if ($c eq "\t") {
782	$res .= ' ';
783	$n++;
784	for (; ($n % 8) != 0; $n++) {
785	$res .= ' ';
786	}
787	next;
788	}
789	$res .= $c;
790	$n++;
791	}
792
793	return $res;
794	}
795	sub copy_spacing {
796	(my $res = shift) =~ tr/\t/ /c;
797	return $res;
798	}
799
800	sub line_stats {
801	my ($line) = @_;
802
803	# Drop the diff line leader and expand tabs
804	$line =~ s/^.//;
805	$line = expand_tabs($line);
806
807	# Pick the indent from the front of the line.
808	my ($white) = ($line =~ /^(\s*)/);
809
810	return (length($line), length($white));
811	}
812
813	my $sanitise_quote = '';
814
815	sub sanitise_line_reset {
816	my ($in_comment) = @_;
817
818	if ($in_comment) {
819	$sanitise_quote = '*/';
820	} else {
821	$sanitise_quote = '';
822	}
823	}
824	sub sanitise_line {
825	my ($line) = @_;
826
827	my $res = '';
828	my $l = '';
829
830	my $qlen = 0;
831	my $off = 0;
832	my $c;
833
834	# Always copy over the diff marker.
835	$res = substr($line, 0, 1);
836
837	for ($off = 1; $off < length($line); $off++) {
838	$c = substr($line, $off, 1);
839
840	# Comments we are wacking completly including the begin
841	# and end, all to $;.
842	if ($sanitise_quote eq '' && substr($line, $off, 2) eq '/*') {
843	$sanitise_quote = '*/';
844
845	substr($res, $off, 2, "$;$;");
846	$off++;
847	next;
848	}
849	if ($sanitise_quote eq '/' && substr($line, $off, 2) eq '/') {
850	$sanitise_quote = '';
851	substr($res, $off, 2, "$;$;");
852	$off++;
853	next;
854	}
855	if ($sanitise_quote eq '' && substr($line, $off, 2) eq '//') {
856	$sanitise_quote = '//';
857
858	substr($res, $off, 2, $sanitise_quote);
859	$off++;
860	next;
861	}
862
863	# A \ in a string means ignore the next character.
864	if (($sanitise_quote eq "'" \|\| $sanitise_quote eq '"') &&
865	$c eq "\\") {
866	substr($res, $off, 2, 'XX');
867	$off++;
868	next;
869	}
870	# Regular quotes.
871	if ($c eq "'" \|\| $c eq '"') {
872	if ($sanitise_quote eq '') {
873	$sanitise_quote = $c;
874
875	substr($res, $off, 1, $c);
876	next;
877	} elsif ($sanitise_quote eq $c) {
878	$sanitise_quote = '';
879	}
880	}
881
882	#print "c<$c> SQ<$sanitise_quote>\n";
883	if ($off != 0 && $sanitise_quote eq '*/' && $c ne "\t") {
884	substr($res, $off, 1, $;);
885	} elsif ($off != 0 && $sanitise_quote eq '//' && $c ne "\t") {
886	substr($res, $off, 1, $;);
887	} elsif ($off != 0 && $sanitise_quote && $c ne "\t") {
888	substr($res, $off, 1, 'X');
889	} else {
890	substr($res, $off, 1, $c);
891	}
892	}
893
894	if ($sanitise_quote eq '//') {
895	$sanitise_quote = '';
896	}
897
898	# The pathname on a #include may be surrounded by '<' and '>'.
899	if ($res =~ /^.\s\#\sinclude\s+\<(.*)\>/) {
900	my $clean = 'X' x length($1);
901	$res =~ s@\<.*\>@<$clean>@;
902
903	# The whole of a #error is a string.
904	} elsif ($res =~ /^.\s\#\s(?:error\|warning)\s+(.*)\b/) {
905	my $clean = 'X' x length($1);
906	$res =~ s@(\#\s(?:error\|warning)\s+).@$1$clean@;
907	}
908
909	return $res;
910	}
911
912	sub get_quoted_string {
913	my ($line, $rawline) = @_;
914
915	return "" if ($line !~ m/(\"[X]+\")/g);
916	return substr($rawline, $-[0], $+[0] - $-[0]);
917	}
918
919	sub ctx_statement_block {
920	my ($linenr, $remain, $off) = @_;
921	my $line = $linenr - 1;
922	my $blk = '';
923	my $soff = $off;
924	my $coff = $off - 1;
925	my $coff_set = 0;
926
927	my $loff = 0;
928
929	my $type = '';
930	my $level = 0;
931	my @stack = ();
932	my $p;
933	my $c;
934	my $len = 0;
935
936	my $remainder;
937	while (1) {
938	@stack = (['', 0]) if ($#stack == -1);
939
940	#warn "CSB: blk<$blk> remain<$remain>\n";
941	# If we are about to drop off the end, pull in more
942	# context.
943	if ($off >= $len) {
944	for (; $remain > 0; $line++) {
945	last if (!defined $lines[$line]);
946	next if ($lines[$line] =~ /^-/);
947	$remain--;
948	$loff = $len;
949	$blk .= $lines[$line] . "\n";
950	$len = length($blk);
951	$line++;
952	last;
953	}
954	# Bail if there is no further context.
955	#warn "CSB: blk<$blk> off<$off> len<$len>\n";
956	if ($off >= $len) {
957	last;
958	}
959	if ($level == 0 && substr($blk, $off) =~ /^.\s#\sdefine/) {
960	$level++;
961	$type = '#';
962	}
963	}
964	$p = $c;
965	$c = substr($blk, $off, 1);
966	$remainder = substr($blk, $off);
967
968	#warn "CSB: c<$c> type<$type> level<$level> remainder<$remainder> coff_set<$coff_set>\n";
969
970	# Handle nested #if/#else.
971	if ($remainder =~ /^#\s*(?:ifndef\|ifdef\|if)\s/) {
972	push(@stack, [ $type, $level ]);
973	} elsif ($remainder =~ /^#\s*(?:else\|elif)\b/) {
974	($type, $level) = @{$stack[$#stack - 1]};
975	} elsif ($remainder =~ /^#\s*endif\b/) {
976	($type, $level) = @{pop(@stack)};
977	}
978
979	# Statement ends at the ';' or a close '}' at the
980	# outermost level.
981	if ($level == 0 && $c eq ';') {
982	last;
983	}
984
985	# An else is really a conditional as long as its not else if
986	if ($level == 0 && $coff_set == 0 &&
987	(!defined($p) \|\| $p =~ /(?:\s\|\}\|\+)/) &&
988	$remainder =~ /^(else)(?:\s\|{)/ &&
989	$remainder !~ /^else\s+if\b/) {
990	$coff = $off + length($1) - 1;
991	$coff_set = 1;
992	#warn "CSB: mark coff<$coff> soff<$soff> 1<$1>\n";
993	#warn "[" . substr($blk, $soff, $coff - $soff + 1) . "]\n";
994	}
995
996	if (($type eq '' \|\| $type eq '(') && $c eq '(') {
997	$level++;
998	$type = '(';
999	}
1000	if ($type eq '(' && $c eq ')') {
1001	$level--;
1002	$type = ($level != 0)? '(' : '';
1003
1004	if ($level == 0 && $coff < $soff) {
1005	$coff = $off;
1006	$coff_set = 1;
1007	#warn "CSB: mark coff<$coff>\n";
1008	}
1009	}
1010	if (($type eq '' \|\| $type eq '{') && $c eq '{') {
1011	$level++;
1012	$type = '{';
1013	}
1014	if ($type eq '{' && $c eq '}') {
1015	$level--;
1016	$type = ($level != 0)? '{' : '';
1017
1018	if ($level == 0) {
1019	if (substr($blk, $off + 1, 1) eq ';') {
1020	$off++;
1021	}
1022	last;
1023	}
1024	}
1025	# Preprocessor commands end at the newline unless escaped.
1026	if ($type eq '#' && $c eq "\n" && $p ne "\\") {
1027	$level--;
1028	$type = '';
1029	$off++;
1030	last;
1031	}
1032	$off++;
1033	}
1034	# We are truly at the end, so shuffle to the next line.
1035	if ($off == $len) {
1036	$loff = $len + 1;
1037	$line++;
1038	$remain--;
1039	}
1040
1041	my $statement = substr($blk, $soff, $off - $soff + 1);
1042	my $condition = substr($blk, $soff, $coff - $soff + 1);
1043
1044	#warn "STATEMENT<$statement>\n";
1045	#warn "CONDITION<$condition>\n";
1046
1047	#print "coff<$coff> soff<$off> loff<$loff>\n";
1048
1049	return ($statement, $condition,
1050	$line, $remain + 1, $off - $loff + 1, $level);
1051	}
1052
1053	sub statement_lines {
1054	my ($stmt) = @_;
1055
1056	# Strip the diff line prefixes and rip blank lines at start and end.
1057	$stmt =~ s/(^\|\n)./$1/g;
1058	$stmt =~ s/^\s*//;
1059	$stmt =~ s/\s*$//;
1060
1061	my @stmt_lines = ($stmt =~ /\n/g);
1062
1063	return $#stmt_lines + 2;
1064	}
1065
1066	sub statement_rawlines {
1067	my ($stmt) = @_;
1068
1069	my @stmt_lines = ($stmt =~ /\n/g);
1070
1071	return $#stmt_lines + 2;
1072	}
1073
1074	sub statement_block_size {
1075	my ($stmt) = @_;
1076
1077	$stmt =~ s/(^\|\n)./$1/g;
1078	$stmt =~ s/^\s*{//;
1079	$stmt =~ s/}\s*$//;
1080	$stmt =~ s/^\s*//;
1081	$stmt =~ s/\s*$//;
1082
1083	my @stmt_lines = ($stmt =~ /\n/g);
1084	my @stmt_statements = ($stmt =~ /;/g);
1085
1086	my $stmt_lines = $#stmt_lines + 2;
1087	my $stmt_statements = $#stmt_statements + 1;
1088
1089	if ($stmt_lines > $stmt_statements) {
1090	return $stmt_lines;
1091	} else {
1092	return $stmt_statements;
1093	}
1094	}
1095
1096	sub ctx_statement_full {
1097	my ($linenr, $remain, $off) = @_;
1098	my ($statement, $condition, $level);
1099
1100	my (@chunks);
1101
1102	# Grab the first conditional/block pair.
1103	($statement, $condition, $linenr, $remain, $off, $level) =
1104	ctx_statement_block($linenr, $remain, $off);
1105	#print "F: c<$condition> s<$statement> remain<$remain>\n";
1106	push(@chunks, [ $condition, $statement ]);
1107	if (!($remain > 0 && $condition =~ /^\s(?:\n[+-])?\s(?:if\|else\|do)\b/s)) {
1108	return ($level, $linenr, @chunks);
1109	}
1110
1111	# Pull in the following conditional/block pairs and see if they
1112	# could continue the statement.
1113	for (;;) {
1114	($statement, $condition, $linenr, $remain, $off, $level) =
1115	ctx_statement_block($linenr, $remain, $off);
1116	#print "C: c<$condition> s<$statement> remain<$remain>\n";
1117	last if (!($remain > 0 && $condition =~ /^(?:\s\n[+-])\s*(?:else\|do)\b/s));
1118	#print "C: push\n";
1119	push(@chunks, [ $condition, $statement ]);
1120	}
1121
1122	return ($level, $linenr, @chunks);
1123	}
1124
1125	sub ctx_block_get {
1126	my ($linenr, $remain, $outer, $open, $close, $off) = @_;
1127	my $line;
1128	my $start = $linenr - 1;
1129	my $blk = '';
1130	my @o;
1131	my @c;
1132	my @res = ();
1133
1134	my $level = 0;
1135	my @stack = ($level);
1136	for ($line = $start; $remain > 0; $line++) {
1137	next if ($rawlines[$line] =~ /^-/);
1138	$remain--;
1139
1140	$blk .= $rawlines[$line];
1141
1142	# Handle nested #if/#else.
1143	if ($lines[$line] =~ /^.\s#\s(?:ifndef\|ifdef\|if)\s/) {
1144	push(@stack, $level);
1145	} elsif ($lines[$line] =~ /^.\s#\s(?:else\|elif)\b/) {
1146	$level = $stack[$#stack - 1];
1147	} elsif ($lines[$line] =~ /^.\s#\sendif\b/) {
1148	$level = pop(@stack);
1149	}
1150
1151	foreach my $c (split(//, $lines[$line])) {
1152	##print "C<$c>L<$level><$open$close>O<$off>\n";
1153	if ($off > 0) {
1154	$off--;
1155	next;
1156	}
1157
1158	if ($c eq $close && $level > 0) {
1159	$level--;
1160	last if ($level == 0);
1161	} elsif ($c eq $open) {
1162	$level++;
1163	}
1164	}
1165
1166	if (!$outer \|\| $level <= 1) {
1167	push(@res, $rawlines[$line]);
1168	}
1169
1170	last if ($level == 0);
1171	}
1172
1173	return ($level, @res);
1174	}
1175	sub ctx_block_outer {
1176	my ($linenr, $remain) = @_;
1177
1178	my ($level, @r) = ctx_block_get($linenr, $remain, 1, '{', '}', 0);
1179	return @r;
1180	}
1181	sub ctx_block {
1182	my ($linenr, $remain) = @_;
1183
1184	my ($level, @r) = ctx_block_get($linenr, $remain, 0, '{', '}', 0);
1185	return @r;
1186	}
1187	sub ctx_statement {
1188	my ($linenr, $remain, $off) = @_;
1189
1190	my ($level, @r) = ctx_block_get($linenr, $remain, 0, '(', ')', $off);
1191	return @r;
1192	}
1193	sub ctx_block_level {
1194	my ($linenr, $remain) = @_;
1195
1196	return ctx_block_get($linenr, $remain, 0, '{', '}', 0);
1197	}
1198	sub ctx_statement_level {
1199	my ($linenr, $remain, $off) = @_;
1200
1201	return ctx_block_get($linenr, $remain, 0, '(', ')', $off);
1202	}
1203
1204	sub ctx_locate_comment {
1205	my ($first_line, $end_line) = @_;
1206
1207	# Catch a comment on the end of the line itself.
1208	my ($current_comment) = ($rawlines[$end_line - 1] =~ m@.(/\.\/)\s(?:\\\s)?$@);
1209	return $current_comment if (defined $current_comment);
1210
1211	# Look through the context and try and figure out if there is a
1212	# comment.
1213	my $in_comment = 0;
1214	$current_comment = '';
1215	for (my $linenr = $first_line; $linenr < $end_line; $linenr++) {
1216	my $line = $rawlines[$linenr - 1];
1217	#warn " $line\n";
1218	if ($linenr == $first_line and $line =~ m@^.\s\@) {
1219	$in_comment = 1;
1220	}
1221	if ($line =~ m@/\*@) {
1222	$in_comment = 1;
1223	}
1224	if (!$in_comment && $current_comment ne '') {
1225	$current_comment = '';
1226	}
1227	$current_comment .= $line . "\n" if ($in_comment);
1228	if ($line =~ m@\*/@) {
1229	$in_comment = 0;
1230	}
1231	}
1232
1233	chomp($current_comment);
1234	return($current_comment);
1235	}
1236	sub ctx_has_comment {
1237	my ($first_line, $end_line) = @_;
1238	my $cmt = ctx_locate_comment($first_line, $end_line);
1239
1240	##print "LINE: $rawlines[$end_line - 1 ]\n";
1241	##print "CMMT: $cmt\n";
1242
1243	return ($cmt ne '');
1244	}
1245
1246	sub raw_line {
1247	my ($linenr, $cnt) = @_;
1248
1249	my $offset = $linenr - 1;
1250	$cnt++;
1251
1252	my $line;
1253	while ($cnt) {
1254	$line = $rawlines[$offset++];
1255	next if (defined($line) && $line =~ /^-/);
1256	$cnt--;
1257	}
1258
1259	return $line;
1260	}
1261
1262	sub cat_vet {
1263	my ($vet) = @_;
1264	my ($res, $coded);
1265
1266	$res = '';
1267	while ($vet =~ /([^[:cntrl:]]*)([[:cntrl:]]\|$)/g) {
1268	$res .= $1;
1269	if ($2 ne '') {
1270	$coded = sprintf("^%c", unpack('C', $2) + 64);
1271	$res .= $coded;
1272	}
1273	}
1274	$res =~ s/$/\$/;
1275
1276	return $res;
1277	}
1278
1279	my $av_preprocessor = 0;
1280	my $av_pending;
1281	my @av_paren_type;
1282	my $av_pend_colon;
1283
1284	sub annotate_reset {
1285	$av_preprocessor = 0;
1286	$av_pending = '_';
1287	@av_paren_type = ('E');
1288	$av_pend_colon = 'O';
1289	}
1290
1291	sub annotate_values {
1292	my ($stream, $type) = @_;
1293
1294	my $res;
1295	my $var = '_' x length($stream);
1296	my $cur = $stream;
1297
1298	print "$stream\n" if ($dbg_values > 1);
1299
1300	while (length($cur)) {
1301	@av_paren_type = ('E') if ($#av_paren_type < 0);
1302	print " <" . join('', @av_paren_type) .
1303	"> <$type> <$av_pending>" if ($dbg_values > 1);
1304	if ($cur =~ /^(\s+)/o) {
1305	print "WS($1)\n" if ($dbg_values > 1);
1306	if ($1 =~ /\n/ && $av_preprocessor) {
1307	$type = pop(@av_paren_type);
1308	$av_preprocessor = 0;
1309	}
1310
1311	} elsif ($cur =~ /^($\s$Type\s)$/ && $av_pending eq '_') {
1312	print "CAST($1)\n" if ($dbg_values > 1);
1313	push(@av_paren_type, $type);
1314	$type = 'c';
1315
1316	} elsif ($cur =~ /^($Type)\s(?:$Ident\|,\|\)\|\(\|\s$)/) {
1317	print "DECLARE($1)\n" if ($dbg_values > 1);
1318	$type = 'T';
1319
1320	} elsif ($cur =~ /^($Modifier)\s*/) {
1321	print "MODIFIER($1)\n" if ($dbg_values > 1);
1322	$type = 'T';
1323
1324	} elsif ($cur =~ /^(\#\sdefine\s$Ident)(\(?)/o) {
1325	print "DEFINE($1,$2)\n" if ($dbg_values > 1);
1326	$av_preprocessor = 1;
1327	push(@av_paren_type, $type);
1328	if ($2 ne '') {
1329	$av_pending = 'N';
1330	}
1331	$type = 'E';
1332
1333	} elsif ($cur =~ /^(\#\s(?:undef\s$Ident\|include\b))/o) {
1334	print "UNDEF($1)\n" if ($dbg_values > 1);
1335	$av_preprocessor = 1;
1336	push(@av_paren_type, $type);
1337
1338	} elsif ($cur =~ /^(\#\s*(?:ifdef\|ifndef\|if))/o) {
1339	print "PRE_START($1)\n" if ($dbg_values > 1);
1340	$av_preprocessor = 1;
1341
1342	push(@av_paren_type, $type);
1343	push(@av_paren_type, $type);
1344	$type = 'E';
1345
1346	} elsif ($cur =~ /^(\#\s*(?:else\|elif))/o) {
1347	print "PRE_RESTART($1)\n" if ($dbg_values > 1);
1348	$av_preprocessor = 1;
1349
1350	push(@av_paren_type, $av_paren_type[$#av_paren_type]);
1351
1352	$type = 'E';
1353
1354	} elsif ($cur =~ /^(\#\s*(?:endif))/o) {
1355	print "PRE_END($1)\n" if ($dbg_values > 1);
1356
1357	$av_preprocessor = 1;
1358
1359	# Assume all arms of the conditional end as this
1360	# one does, and continue as if the #endif was not here.
1361	pop(@av_paren_type);
1362	push(@av_paren_type, $type);
1363	$type = 'E';
1364
1365	} elsif ($cur =~ /^(\\\n)/o) {
1366	print "PRECONT($1)\n" if ($dbg_values > 1);
1367
1368	} elsif ($cur =~ /^(__attribute__)\s*\(?/o) {
1369	print "ATTR($1)\n" if ($dbg_values > 1);
1370	$av_pending = $type;
1371	$type = 'N';
1372
1373	} elsif ($cur =~ /^(sizeof)\s*(\()?/o) {
1374	print "SIZEOF($1)\n" if ($dbg_values > 1);
1375	if (defined $2) {
1376	$av_pending = 'V';
1377	}
1378	$type = 'N';
1379
1380	} elsif ($cur =~ /^(if\|while\|for)\b/o) {
1381	print "COND($1)\n" if ($dbg_values > 1);
1382	$av_pending = 'E';
1383	$type = 'N';
1384
1385	} elsif ($cur =~/^(case)/o) {
1386	print "CASE($1)\n" if ($dbg_values > 1);
1387	$av_pend_colon = 'C';
1388	$type = 'N';
1389
1390	} elsif ($cur =~/^(return\|else\|goto\|typeof\|__typeof__)\b/o) {
1391	print "KEYWORD($1)\n" if ($dbg_values > 1);
1392	$type = 'N';
1393
1394	} elsif ($cur =~ /^(\()/o) {
1395	print "PAREN('$1')\n" if ($dbg_values > 1);
1396	push(@av_paren_type, $av_pending);
1397	$av_pending = '_';
1398	$type = 'N';
1399
1400	} elsif ($cur =~ /^(\))/o) {
1401	my $new_type = pop(@av_paren_type);
1402	if ($new_type ne '_') {
1403	$type = $new_type;
1404	print "PAREN('$1') -> $type\n"
1405	if ($dbg_values > 1);
1406	} else {
1407	print "PAREN('$1')\n" if ($dbg_values > 1);
1408	}
1409
1410	} elsif ($cur =~ /^($Ident)\s*\(/o) {
1411	print "FUNC($1)\n" if ($dbg_values > 1);
1412	$type = 'V';
1413	$av_pending = 'V';
1414
1415	} elsif ($cur =~ /^($Ident\s):(?:\s\d+\s*(,\|=\|;))?/) {
1416	if (defined $2 && $type eq 'C' \|\| $type eq 'T') {
1417	$av_pend_colon = 'B';
1418	} elsif ($type eq 'E') {
1419	$av_pend_colon = 'L';
1420	}
1421	print "IDENT_COLON($1,$type>$av_pend_colon)\n" if ($dbg_values > 1);
1422	$type = 'V';
1423
1424	} elsif ($cur =~ /^($Ident\|$Constant)/o) {
1425	print "IDENT($1)\n" if ($dbg_values > 1);
1426	$type = 'V';
1427
1428	} elsif ($cur =~ /^($Assignment)/o) {
1429	print "ASSIGN($1)\n" if ($dbg_values > 1);
1430	$type = 'N';
1431
1432	} elsif ($cur =~/^(;\|{\|})/) {
1433	print "END($1)\n" if ($dbg_values > 1);
1434	$type = 'E';
1435	$av_pend_colon = 'O';
1436
1437	} elsif ($cur =~/^(,)/) {
1438	print "COMMA($1)\n" if ($dbg_values > 1);
1439	$type = 'C';
1440
1441	} elsif ($cur =~ /^(\?)/o) {
1442	print "QUESTION($1)\n" if ($dbg_values > 1);
1443	$type = 'N';
1444
1445	} elsif ($cur =~ /^(:)/o) {
1446	print "COLON($1,$av_pend_colon)\n" if ($dbg_values > 1);
1447
1448	substr($var, length($res), 1, $av_pend_colon);
1449	if ($av_pend_colon eq 'C' \|\| $av_pend_colon eq 'L') {
1450	$type = 'E';
1451	} else {
1452	$type = 'N';
1453	}
1454	$av_pend_colon = 'O';
1455
1456	} elsif ($cur =~ /^(\[)/o) {
1457	print "CLOSE($1)\n" if ($dbg_values > 1);
1458	$type = 'N';
1459
1460	} elsif ($cur =~ /^(-(?![->])\|\+(?!\+)\|\*\|\&\&\|\&)/o) {
1461	my $variant;
1462
1463	print "OPV($1)\n" if ($dbg_values > 1);
1464	if ($type eq 'V') {
1465	$variant = 'B';
1466	} else {
1467	$variant = 'U';
1468	}
1469
1470	substr($var, length($res), 1, $variant);
1471	$type = 'N';
1472
1473	} elsif ($cur =~ /^($Operators)/o) {
1474	print "OP($1)\n" if ($dbg_values > 1);
1475	if ($1 ne '++' && $1 ne '--') {
1476	$type = 'N';
1477	}
1478
1479	} elsif ($cur =~ /(^.)/o) {
1480	print "C($1)\n" if ($dbg_values > 1);
1481	}
1482	if (defined $1) {
1483	$cur = substr($cur, length($1));
1484	$res .= $type x length($1);
1485	}
1486	}
1487
1488	return ($res, $var);
1489	}
1490
1491	sub possible {
1492	my ($possible, $line) = @_;
1493	my $notPermitted = qr{(?:
1494	^(?:
1495	$Modifier\|
1496	$Storage\|
1497	$Type\|
1498	DEFINE_\S+
1499	)$\|
1500	^(?:
1501	goto\|
1502	return\|
1503	case\|
1504	else\|
1505	asm\|__asm__\|
1506	do\|
1507	\#\|
1508	\#\#\|
1509	)(?:\s\|$)\|
1510	^(?:typedef\|struct\|enum)\b
1511	)}x;
1512	warn "CHECK<$possible> ($line)\n" if ($dbg_possible > 2);
1513	if ($possible !~ $notPermitted) {
1514	# Check for modifiers.
1515	$possible =~ s/\s$Storage\s//g;
1516	$possible =~ s/\s$Sparse\s//g;
1517	if ($possible =~ /^\s*$/) {
1518
1519	} elsif ($possible =~ /\s/) {
1520	$possible =~ s/\s$Type\s//g;
1521	for my $modifier (split(' ', $possible)) {
1522	if ($modifier !~ $notPermitted) {
1523	warn "MODIFIER: $modifier ($possible) ($line)\n" if ($dbg_possible);
1524	push(@modifierList, $modifier);
1525	}
1526	}
1527
1528	} else {
1529	warn "POSSIBLE: $possible ($line)\n" if ($dbg_possible);
1530	push(@typeList, $possible);
1531	}
1532	build_types();
1533	} else {
1534	warn "NOTPOSS: $possible ($line)\n" if ($dbg_possible > 1);
1535	}
1536	}
1537
1538	my $prefix = '';
1539
1540	sub show_type {
1541	my ($type) = @_;
1542
1543	return defined $use_type{$type} if (scalar keys %use_type > 0);
1544
1545	return !defined $ignore_type{$type};
1546	}
1547
1548	sub report {
1549	my ($level, $type, $msg) = @_;
1550
1551	if (!show_type($type) \|\|
1552	(defined $tst_only && $msg !~ /\Q$tst_only\E/)) {
1553	return 0;
1554	}
1555	my $line;
1556	if ($show_types) {
1557	$line = "$prefix$level:$type: $msg\n";
1558	} else {
1559	$line = "$prefix$level: $msg\n";
1560	}
1561	$line = (split('\n', $line))[0] . "\n" if ($terse);
1562
1563	push(our @report, $line);
1564
1565	return 1;
1566	}
1567
1568	sub report_dump {
1569	our @report;
1570	}
1571
1572	sub fixup_current_range {
1573	my ($lineRef, $offset, $length) = @_;
1574
1575	if ($$lineRef =~ /^\@\@ -\d+,\d+ \+(\d+),(\d+) \@\@/) {
1576	my $o = $1;
1577	my $l = $2;
1578	my $no = $o + $offset;
1579	my $nl = $l + $length;
1580	$$lineRef =~ s/\+$o,$l \@\@/\+$no,$nl \@\@/;
1581	}
1582	}
1583
1584	sub fix_inserted_deleted_lines {
1585	my ($linesRef, $insertedRef, $deletedRef) = @_;
1586
1587	my $range_last_linenr = 0;
1588	my $delta_offset = 0;
1589
1590	my $old_linenr = 0;
1591	my $new_linenr = 0;
1592
1593	my $next_insert = 0;
1594	my $next_delete = 0;
1595
1596	my @lines = ();
1597
1598	my $inserted = @{$insertedRef}[$next_insert++];
1599	my $deleted = @{$deletedRef}[$next_delete++];
1600
1601	foreach my $old_line (@{$linesRef}) {
1602	my $save_line = 1;
1603	my $line = $old_line; #don't modify the array
1604	if ($line =~ /^(?:\+\+\+\\|\-\-\-)\s+\S+/) { #new filename
1605	$delta_offset = 0;
1606	} elsif ($line =~ /^\@\@ -\d+,\d+ \+\d+,\d+ \@\@/) { #new hunk
1607	$range_last_linenr = $new_linenr;
1608	fixup_current_range(\$line, $delta_offset, 0);
1609	}
1610
1611	while (defined($deleted) && ${$deleted}{'LINENR'} == $old_linenr) {
1612	$deleted = @{$deletedRef}[$next_delete++];
1613	$save_line = 0;
1614	fixup_current_range(\$lines[$range_last_linenr], $delta_offset--, -1);
1615	}
1616
1617	while (defined($inserted) && ${$inserted}{'LINENR'} == $old_linenr) {
1618	push(@lines, ${$inserted}{'LINE'});
1619	$inserted = @{$insertedRef}[$next_insert++];
1620	$new_linenr++;
1621	fixup_current_range(\$lines[$range_last_linenr], $delta_offset++, 1);
1622	}
1623
1624	if ($save_line) {
1625	push(@lines, $line);
1626	$new_linenr++;
1627	}
1628
1629	$old_linenr++;
1630	}
1631
1632	return @lines;
1633	}
1634
1635	sub fix_insert_line {
1636	my ($linenr, $line) = @_;
1637
1638	my $inserted = {
1639	LINENR => $linenr,
1640	LINE => $line,
1641	};
1642	push(@fixed_inserted, $inserted);
1643	}
1644
1645	sub fix_delete_line {
1646	my ($linenr, $line) = @_;
1647
1648	my $deleted = {
1649	LINENR => $linenr,
1650	LINE => $line,
1651	};
1652
1653	push(@fixed_deleted, $deleted);
1654	}
1655
1656	sub ERROR {
1657	my ($type, $msg) = @_;
1658
1659	if (report("ERROR", $type, $msg)) {
1660	our $clean = 0;
1661	our $cnt_error++;
1662	return 1;
1663	}
1664	return 0;
1665	}
1666	sub WARN {
1667	my ($type, $msg) = @_;
1668
1669	if (report("WARNING", $type, $msg)) {
1670	our $clean = 0;
1671	our $cnt_warn++;
1672	return 1;
1673	}
1674	return 0;
1675	}
1676	sub CHK {
1677	my ($type, $msg) = @_;
1678
1679	if ($check && report("CHECK", $type, $msg)) {
1680	our $clean = 0;
1681	our $cnt_chk++;
1682	return 1;
1683	}
1684	return 0;
1685	}
1686
1687	sub check_absolute_file {
1688	my ($absolute, $herecurr) = @_;
1689	my $file = $absolute;
1690
1691	##print "absolute<$absolute>\n";
1692
1693	# See if any suffix of this path is a path within the tree.
1694	while ($file =~ s@^[^/]*/@@) {
1695	if (-f "$root/$file") {
1696	##print "file<$file>\n";
1697	last;
1698	}
1699	}
1700	if (! -f _) {
1701	return 0;
1702	}
1703
1704	# It is, so see if the prefix is acceptable.
1705	my $prefix = $absolute;
1706	substr($prefix, -length($file)) = '';
1707
1708	##print "prefix<$prefix>\n";
1709	if ($prefix ne ".../") {
1710	WARN("USE_RELATIVE_PATH",
1711	"use relative pathname instead of absolute in changelog text\n" . $herecurr);
1712	}
1713	}
1714
1715	sub trim {
1716	my ($string) = @_;
1717
1718	$string =~ s/^\s+\|\s+$//g;
1719
1720	return $string;
1721	}
1722
1723	sub ltrim {
1724	my ($string) = @_;
1725
1726	$string =~ s/^\s+//;
1727
1728	return $string;
1729	}
1730
1731	sub rtrim {
1732	my ($string) = @_;
1733
1734	$string =~ s/\s+$//;
1735
1736	return $string;
1737	}
1738
1739	sub string_find_replace {
1740	my ($string, $find, $replace) = @_;
1741
1742	$string =~ s/$find/$replace/g;
1743
1744	return $string;
1745	}
1746
1747	sub tabify {
1748	my ($leading) = @_;
1749
1750	my $source_indent = 8;
1751	my $max_spaces_before_tab = $source_indent - 1;
1752	my $spaces_to_tab = " " x $source_indent;
1753
1754	#convert leading spaces to tabs
1755	1 while $leading =~ s@^([\t]*)$spaces_to_tab@$1\t@g;
1756	#Remove spaces before a tab
1757	1 while $leading =~ s@^([\t]*)( {1,$max_spaces_before_tab})\t@$1\t@g;
1758
1759	return "$leading";
1760	}
1761
1762	sub pos_last_openparen {
1763	my ($line) = @_;
1764
1765	my $pos = 0;
1766
1767	my $opens = $line =~ tr/\(/\(/;
1768	my $closes = $line =~ tr/\)/\)/;
1769
1770	my $last_openparen = 0;
1771
1772	if (($opens == 0) \|\| ($closes >= $opens)) {
1773	return -1;
1774	}
1775
1776	my $len = length($line);
1777
1778	for ($pos = 0; $pos < $len; $pos++) {
1779	my $string = substr($line, $pos);
1780	if ($string =~ /^($FuncArg\|$balanced_parens)/) {
1781	$pos += length($1) - 1;
1782	} elsif (substr($line, $pos, 1) eq '(') {
1783	$last_openparen = $pos;
1784	} elsif (index($string, '(') == -1) {
1785	last;
1786	}
1787	}
1788
1789	return length(expand_tabs(substr($line, 0, $last_openparen))) + 1;
1790	}
1791
1792	sub process {
1793	my $filename = shift;
1794
1795	my $linenr=0;
1796	my $prevline="";
1797	my $prevrawline="";
1798	my $stashline="";
1799	my $stashrawline="";
1800
1801	my $length;
1802	my $indent;
1803	my $previndent=0;
1804	my $stashindent=0;
1805
1806	our $clean = 1;
1807	my $signoff = 0;
1808	my $is_patch = 0;
1809
1810	my $in_header_lines = $file ? 0 : 1;
1811	my $in_commit_log = 0; #Scanning lines before patch
1812	my $reported_maintainer_file = 0;
1813	my $non_utf8_charset = 0;
1814
1815	my $last_blank_line = 0;
1816
1817	our @report = ();
1818	our $cnt_lines = 0;
1819	our $cnt_error = 0;
1820	our $cnt_warn = 0;
1821	our $cnt_chk = 0;
1822
1823	# Trace the real file/line as we go.
1824	my $realfile = '';
1825	my $realline = 0;
1826	my $realcnt = 0;
1827	my $here = '';
1828	my $in_comment = 0;
1829	my $comment_edge = 0;
1830	my $first_line = 0;
1831	my $p1_prefix = '';
1832
1833	my $prev_values = 'E';
1834
1835	# suppression flags
1836	my %suppress_ifbraces;
1837	my %suppress_whiletrailers;
1838	my %suppress_export;
1839	my $suppress_statement = 0;
1840
1841	my %signatures = ();
1842
1843	# Pre-scan the patch sanitizing the lines.
1844	# Pre-scan the patch looking for any __setup documentation.
1845	#
1846	my @setup_docs = ();
1847	my $setup_docs = 0;
1848
1849	my $camelcase_file_seeded = 0;
1850
1851	sanitise_line_reset();
1852	my $line;
1853	foreach my $rawline (@rawlines) {
1854	$linenr++;
1855	$line = $rawline;
1856
1857	push(@fixed, $rawline) if ($fix);
1858
1859	if ($rawline=~/^\+\+\+\s+(\S+)/) {
1860	$setup_docs = 0;
1861	if ($1 =~ m@Documentation/kernel-parameters.txt$@) {
1862	$setup_docs = 1;
1863	}
1864	#next;
1865	}
1866	if ($rawline=~/^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@/) {
1867	$realline=$1-1;
1868	if (defined $2) {
1869	$realcnt=$3+1;
1870	} else {
1871	$realcnt=1+1;
1872	}
1873	$in_comment = 0;
1874
1875	# Guestimate if this is a continuing comment. Run
1876	# the context looking for a comment "edge". If this
1877	# edge is a close comment then we must be in a comment
1878	# at context start.
1879	my $edge;
1880	my $cnt = $realcnt;
1881	for (my $ln = $linenr + 1; $cnt > 0; $ln++) {
1882	next if (defined $rawlines[$ln - 1] &&
1883	$rawlines[$ln - 1] =~ /^-/);
1884	$cnt--;
1885	#print "RAW<$rawlines[$ln - 1]>\n";
1886	last if (!defined $rawlines[$ln - 1]);
1887	if ($rawlines[$ln - 1] =~ m@(/\\|\/)@ &&
1888	$rawlines[$ln - 1] !~ m@"[^"](?:/\\|\/)[^"]"@) {
1889	($edge) = $1;
1890	last;
1891	}
1892	}
1893	if (defined $edge && $edge eq '*/') {
1894	$in_comment = 1;
1895	}
1896
1897	# Guestimate if this is a continuing comment. If this
1898	# is the start of a diff block and this line starts
1899	# ' *' then it is very likely a comment.
1900	if (!defined $edge &&
1901	$rawlines[$linenr] =~ m@^.\s(?:\\+\| \)(?:\s\|$)@)
1902	{
1903	$in_comment = 1;
1904	}
1905
1906	##print "COMMENT:$in_comment edge<$edge> $rawline\n";
1907	sanitise_line_reset($in_comment);
1908
1909	} elsif ($realcnt && $rawline =~ /^(?:\+\| \|$)/) {
1910	# Standardise the strings and chars within the input to
1911	# simplify matching -- only bother with positive lines.
1912	$line = sanitise_line($rawline);
1913	}
1914	push(@lines, $line);
1915
1916	if ($realcnt > 1) {
1917	$realcnt-- if ($line =~ /^(?:\+\| \|$)/);
1918	} else {
1919	$realcnt = 0;
1920	}
1921
1922	#print "==>$rawline\n";
1923	#print "-->$line\n";
1924
1925	if ($setup_docs && $line =~ /^\+/) {
1926	push(@setup_docs, $line);
1927	}
1928	}
1929
1930	$prefix = '';
1931
1932	$realcnt = 0;
1933	$linenr = 0;
1934	$fixlinenr = -1;
1935	foreach my $line (@lines) {
1936	$linenr++;
1937	$fixlinenr++;
1938	my $sline = $line; #copy of $line
1939	$sline =~ s/$;/ /g; #with comments as spaces
1940
1941	my $rawline = $rawlines[$linenr - 1];
1942
1943	#extract the line range in the file after the patch is applied
1944	if ($line=~/^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@/) {
1945	$is_patch = 1;
1946	$first_line = $linenr + 1;
1947	$realline=$1-1;
1948	if (defined $2) {
1949	$realcnt=$3+1;
1950	} else {
1951	$realcnt=1+1;
1952	}
1953	annotate_reset();
1954	$prev_values = 'E';
1955
1956	%suppress_ifbraces = ();
1957	%suppress_whiletrailers = ();
1958	%suppress_export = ();
1959	$suppress_statement = 0;
1960	next;
1961
1962	# track the line number as we move through the hunk, note that
1963	# new versions of GNU diff omit the leading space on completely
1964	# blank context lines so we need to count that too.
1965	} elsif ($line =~ /^( \|\+\|$)/) {
1966	$realline++;
1967	$realcnt-- if ($realcnt != 0);
1968
1969	# Measure the line length and indent.
1970	($length, $indent) = line_stats($rawline);
1971
1972	# Track the previous line.
1973	($prevline, $stashline) = ($stashline, $line);
1974	($previndent, $stashindent) = ($stashindent, $indent);
1975	($prevrawline, $stashrawline) = ($stashrawline, $rawline);
1976
1977	#warn "line<$line>\n";
1978
1979	} elsif ($realcnt == 1) {
1980	$realcnt--;
1981	}
1982
1983	my $hunk_line = ($realcnt != 0);
1984
1985	#make up the handle for any error we report on this line
1986	$prefix = "$filename:$realline: " if ($emacs && $file);
1987	$prefix = "$filename:$linenr: " if ($emacs && !$file);
1988
1989	$here = "#$linenr: " if (!$file);
1990	$here = "#$realline: " if ($file);
1991
1992	my $found_file = 0;
1993	# extract the filename as it passes
1994	if ($line =~ /^diff --git.*?(\S+)$/) {
1995	$realfile = $1;
1996	$realfile =~ s@^([^/]*)/@@ if (!$file);
1997	$in_commit_log = 0;
1998	$found_file = 1;
1999	} elsif ($line =~ /^\+\+\+\s+(\S+)/) {
2000	$realfile = $1;
2001	$realfile =~ s@^([^/]*)/@@ if (!$file);
2002	$in_commit_log = 0;
2003
2004	$p1_prefix = $1;
2005	if (!$file && $tree && $p1_prefix ne '' &&
2006	-e "$root/$p1_prefix") {
2007	WARN("PATCH_PREFIX",
2008	"patch prefix '$p1_prefix' exists, appears to be a -p0 patch\n");
2009	}
2010
2011	if ($realfile =~ m@^include/asm/@) {
2012	ERROR("MODIFIED_INCLUDE_ASM",
2013	"do not modify files in include/asm, change architecture specific files in include/asm-<architecture>\n" . "$here$rawline\n");
2014	}
2015	$found_file = 1;
2016	}
2017
2018	if ($found_file) {
2019	if ($realfile =~ m@^(drivers/net/\|net/)@) {
2020	$check = 1;
2021	} else {
2022	$check = $check_orig;
2023	}
2024	next;
2025	}
2026
2027	$here .= "FILE: $realfile:$realline:" if ($realcnt != 0);
2028
2029	my $hereline = "$here\n$rawline\n";
2030	my $herecurr = "$here\n$rawline\n";
2031	my $hereprev = "$here\n$prevrawline\n$rawline\n";
2032
2033	$cnt_lines++ if ($realcnt != 0);
2034
2035	# Check for incorrect file permissions
2036	if ($line =~ /^new (file )?mode.*[7531]\d{0,2}$/) {
2037	my $permhere = $here . "FILE: $realfile\n";
2038	if ($realfile !~ m@scripts/@ &&
2039	$realfile !~ /\.(py\|pl\|awk\|sh)$/) {
2040	ERROR("EXECUTE_PERMISSIONS",
2041	"do not set execute permissions for source files\n" . $permhere);
2042	}
2043	}
2044
2045	# Check the patch for a signoff:
2046	if ($line =~ /^\s*signed-off-by:/i) {
2047	$signoff++;
2048	$in_commit_log = 0;
2049	}
2050
2051	# Check signature styles
2052	if (!$in_header_lines &&
2053	$line =~ /^(\s)([a-z0-9_-]+by:\|$signature_tags)(\s)(.*)/i) {
2054	my $space_before = $1;
2055	my $sign_off = $2;
2056	my $space_after = $3;
2057	my $email = $4;
2058	my $ucfirst_sign_off = ucfirst(lc($sign_off));
2059
2060	if ($sign_off !~ /$signature_tags/) {
2061	WARN("BAD_SIGN_OFF",
2062	"Non-standard signature: $sign_off\n" . $herecurr);
2063	}
2064	if (defined $space_before && $space_before ne "") {
2065	if (WARN("BAD_SIGN_OFF",
2066	"Do not use whitespace before $ucfirst_sign_off\n" . $herecurr) &&
2067	$fix) {
2068	$fixed[$fixlinenr] =
2069	"$ucfirst_sign_off $email";
2070	}
2071	}
2072	if ($sign_off =~ /-by:$/i && $sign_off ne $ucfirst_sign_off) {
2073	if (WARN("BAD_SIGN_OFF",
2074	"'$ucfirst_sign_off' is the preferred signature form\n" . $herecurr) &&
2075	$fix) {
2076	$fixed[$fixlinenr] =
2077	"$ucfirst_sign_off $email";
2078	}
2079
2080	}
2081	if (!defined $space_after \|\| $space_after ne " ") {
2082	if (WARN("BAD_SIGN_OFF",
2083	"Use a single space after $ucfirst_sign_off\n" . $herecurr) &&
2084	$fix) {
2085	$fixed[$fixlinenr] =
2086	"$ucfirst_sign_off $email";
2087	}
2088	}
2089
2090	my ($email_name, $email_address, $comment) = parse_email($email);
2091	my $suggested_email = format_email(($email_name, $email_address));
2092	if ($suggested_email eq "") {
2093	ERROR("BAD_SIGN_OFF",
2094	"Unrecognized email address: '$email'\n" . $herecurr);
2095	} else {
2096	my $dequoted = $suggested_email;
2097	$dequoted =~ s/^"//;
2098	$dequoted =~ s/" </ </;
2099	# Don't force email to have quotes
2100	# Allow just an angle bracketed address
2101	if ("$dequoted$comment" ne $email &&
2102	"<$email_address>$comment" ne $email &&
2103	"$suggested_email$comment" ne $email) {
2104	WARN("BAD_SIGN_OFF",
2105	"email address '$email' might be better as '$suggested_email$comment'\n" . $herecurr);
2106	}
2107	}
2108
2109	# Check for duplicate signatures
2110	my $sig_nospace = $line;
2111	$sig_nospace =~ s/\s//g;
2112	$sig_nospace = lc($sig_nospace);
2113	if (defined $signatures{$sig_nospace}) {
2114	WARN("BAD_SIGN_OFF",
2115	"Duplicate signature\n" . $herecurr);
2116	} else {
2117	$signatures{$sig_nospace} = 1;
2118	}
2119	}
2120
2121	# Check for old stable address
2122	if ($line =~ /^\scc:\s.<?\bstable\@kernel\.org\b>?.$/i) {
2123	ERROR("STABLE_ADDRESS",
2124	"The 'stable' address should be 'stable\@vger.kernel.org'\n" . $herecurr);
2125	}
2126
2127	# Check for unwanted Gerrit info
2128	if ($in_commit_log && $line =~ /^\s*change-id:/i) {
2129	ERROR("GERRIT_CHANGE_ID",
2130	"Remove Gerrit Change-Id's before submitting upstream.\n" . $herecurr);
2131	}
2132
2133	# Check for improperly formed commit descriptions
2134	if ($in_commit_log &&
2135	$line =~ /\bcommit\s+[0-9a-f]{5,}/i &&
2136	!($line =~ /\b[Cc]ommit [0-9a-f]{12,40} \("/ \|\|
2137	($line =~ /\b[Cc]ommit [0-9a-f]{12,40}\s*$/ &&
2138	defined $rawlines[$linenr] &&
2139	$rawlines[$linenr] =~ /^\s*\("/))) {
2140	$line =~ /\b(c)ommit\s+([0-9a-f]{5,})/i;
2141	my $init_char = $1;
2142	my $orig_commit = lc($2);
2143	my $id = '01234567890ab';
2144	my $desc = 'commit description';
2145	($id, $desc) = git_commit_info($orig_commit, $id, $desc);
2146	ERROR("GIT_COMMIT_ID",
2147	"Please use 12 or more chars for the git commit ID like: '${init_char}ommit $id (\"$desc\")'\n" . $herecurr);
2148	}
2149
2150	# Check for added, moved or deleted files
2151	if (!$reported_maintainer_file && !$in_commit_log &&
2152	($line =~ /^(?:new\|deleted) file mode\s\d+\s$/ \|\|
2153	$line =~ /^rename (?:from\|to) [\w\/\.\-]+\s*$/ \|\|
2154	($line =~ /\{\s([\w\/\.\-])\s\=\>\s([\w\/\.\-])\s\}/ &&
2155	(defined($1) \|\| defined($2))))) {
2156	$reported_maintainer_file = 1;
2157	WARN("FILE_PATH_CHANGES",
2158	"added, moved or deleted file(s), does MAINTAINERS need updating?\n" . $herecurr);
2159	}
2160
2161	# Check for wrappage within a valid hunk of the file
2162	if ($realcnt != 0 && $line !~ m{^(?:\+\|-\| \|\\ No newline\|$)}) {
2163	ERROR("CORRUPTED_PATCH",
2164	"patch seems to be corrupt (line wrapped?)\n" .
2165	$herecurr) if (!$emitted_corrupt++);
2166	}
2167
2168	# Check for absolute kernel paths.
2169	if ($tree) {
2170	while ($line =~ m{(?:^\|\s)(/\S*)}g) {
2171	my $file = $1;
2172
2173	if ($file =~ m{^(.*?)(?::\d+)+:?$} &&
2174	check_absolute_file($1, $herecurr)) {
2175	#
2176	} else {
2177	check_absolute_file($file, $herecurr);
2178	}
2179	}
2180	}
2181
2182	# UTF-8 regex found at http://www.w3.org/International/questions/qa-forms-utf-8.en.php
2183	if (($realfile =~ /^$/ \|\| $line =~ /^\+/) &&
2184	$rawline !~ m/^$UTF8*$/) {
2185	my ($utf8_prefix) = ($rawline =~ /^($UTF8*)/);
2186
2187	my $blank = copy_spacing($rawline);
2188	my $ptr = substr($blank, 0, length($utf8_prefix)) . "^";
2189	my $hereptr = "$hereline$ptr\n";
2190
2191	CHK("INVALID_UTF8",
2192	"Invalid UTF-8, patch and commit message should be encoded in UTF-8\n" . $hereptr);
2193	}
2194
2195	# Check if it's the start of a commit log
2196	# (not a header line and we haven't seen the patch filename)
2197	if ($in_header_lines && $realfile =~ /^$/ &&
2198	!($rawline =~ /^\s+\S/ \|\|
2199	$rawline =~ /^(commit\b\|from\b\|[\w-]+:).*$/i)) {
2200	$in_header_lines = 0;
2201	$in_commit_log = 1;
2202	}
2203
2204	# Check if there is UTF-8 in a commit log when a mail header has explicitly
2205	# declined it, i.e defined some charset where it is missing.
2206	if ($in_header_lines &&
2207	$rawline =~ /^Content-Type:.+charset="(.+)".*$/ &&
2208	$1 !~ /utf-8/i) {
2209	$non_utf8_charset = 1;
2210	}
2211
2212	if ($in_commit_log && $non_utf8_charset && $realfile =~ /^$/ &&
2213	$rawline =~ /$NON_ASCII_UTF8/) {
2214	WARN("UTF8_BEFORE_PATCH",
2215	"8-bit UTF-8 used in possible commit log\n" . $herecurr);
2216	}
2217
2218	# ignore non-hunk lines and lines being removed
2219	next if (!$hunk_line \|\| $line =~ /^-/);
2220
2221	#trailing whitespace
2222	if ($line =~ /^\+.*\015/) {
2223	my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2224	if (ERROR("DOS_LINE_ENDINGS",
2225	"DOS line endings\n" . $herevet) &&
2226	$fix) {
2227	$fixed[$fixlinenr] =~ s/[\s\015]+$//;
2228	}
2229	} elsif ($rawline =~ /^\+.*\S\s+$/ \|\| $rawline =~ /^\+\s+$/) {
2230	my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2231	if (ERROR("TRAILING_WHITESPACE",
2232	"trailing whitespace\n" . $herevet) &&
2233	$fix) {
2234	$fixed[$fixlinenr] =~ s/\s+$//;
2235	}
2236
2237	$rpt_cleaners = 1;
2238	}
2239
2240	# Check for FSF mailing addresses.
2241	if ($rawline =~ /\bwrite to the Free/i \|\|
2242	$rawline =~ /\b59\s+Temple\s+Pl/i \|\|
2243	$rawline =~ /\b51\s+Franklin\s+St/i) {
2244	my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2245	my $msg_type = \&ERROR;
2246	$msg_type = \&CHK if ($file);
2247	&{$msg_type}("FSF_MAILING_ADDRESS",
2248	"Do not include the paragraph about writing to the Free Software Foundation's mailing address from the sample GPL notice. The FSF has changed addresses in the past, and may do so again. Linux already includes a copy of the GPL.\n" . $herevet)
2249	}
2250
2251	# check for Kconfig help text having a real description
2252	# Only applies when adding the entry originally, after that we do not have
2253	# sufficient context to determine whether it is indeed long enough.
2254	if ($realfile =~ /Kconfig/ &&
2255	$line =~ /^\+\s*config\s+/) {
2256	my $length = 0;
2257	my $cnt = $realcnt;
2258	my $ln = $linenr + 1;
2259	my $f;
2260	my $is_start = 0;
2261	my $is_end = 0;
2262	for (; $cnt > 0 && defined $lines[$ln - 1]; $ln++) {
2263	$f = $lines[$ln - 1];
2264	$cnt-- if ($lines[$ln - 1] !~ /^-/);
2265	$is_end = $lines[$ln - 1] =~ /^\+/;
2266
2267	next if ($f =~ /^-/);
2268	last if (!$file && $f =~ /^\@\@/);
2269
2270	if ($lines[$ln - 1] =~ /^\+\s(?:bool\|tristate)\s\"/) {
2271	$is_start = 1;
2272	} elsif ($lines[$ln - 1] =~ /^\+\s*(?:---)?help(?:---)?$/) {
2273	$length = -1;
2274	}
2275
2276	$f =~ s/^.//;
2277	$f =~ s/#.*//;
2278	$f =~ s/^\s+//;
2279	next if ($f =~ /^$/);
2280	if ($f =~ /^\s*config\s/) {
2281	$is_end = 1;
2282	last;
2283	}
2284	$length++;
2285	}
2286	WARN("CONFIG_DESCRIPTION",
2287	"please write a paragraph that describes the config symbol fully\n" . $herecurr) if ($is_start && $is_end && $length < 4);
2288	#print "is_start<$is_start> is_end<$is_end> length<$length>\n";
2289	}
2290
2291	# discourage the addition of CONFIG_EXPERIMENTAL in Kconfig.
2292	if ($realfile =~ /Kconfig/ &&
2293	$line =~ /.\sdepends on\s+.\bEXPERIMENTAL\b/) {
2294	WARN("CONFIG_EXPERIMENTAL",
2295	"Use of CONFIG_EXPERIMENTAL is deprecated. For alternatives, see https://lkml.org/lkml/2012/10/23/580\n");
2296	}
2297
2298	if (($realfile =~ /Makefile./ \|\| $realfile =~ /Kbuild./) &&
2299	($line =~ /\+(EXTRA_[A-Z]+FLAGS).*/)) {
2300	my $flag = $1;
2301	my $replacement = {
2302	'EXTRA_AFLAGS' => 'asflags-y',
2303	'EXTRA_CFLAGS' => 'ccflags-y',
2304	'EXTRA_CPPFLAGS' => 'cppflags-y',
2305	'EXTRA_LDFLAGS' => 'ldflags-y',
2306	};
2307
2308	WARN("DEPRECATED_VARIABLE",
2309	"Use of $flag is deprecated, please use \`$replacement->{$flag} instead.\n" . $herecurr) if ($replacement->{$flag});
2310	}
2311
2312	# check for DT compatible documentation
2313	if (defined $root &&
2314	(($realfile =~ /\.dtsi?$/ && $line =~ /^\+\scompatible\s=\s*\"/) \|\|
2315	($realfile =~ /\.[ch]$/ && $line =~ /^\+.\.compatible\s=\s*\"/))) {
2316
2317	my @compats = $rawline =~ /\"([a-zA-Z0-9\-\,\.\+_]+)\"/g;
2318
2319	my $dt_path = $root . "/Documentation/devicetree/bindings/";
2320	my $vp_file = $dt_path . "vendor-prefixes.txt";
2321
2322	foreach my $compat (@compats) {
2323	my $compat2 = $compat;
2324	$compat2 =~ s/\,[a-zA-Z0-9]\-/\,<\.\>\-/;
2325	my $compat3 = $compat;
2326	$compat3 =~ s/\,([a-z])[0-9]\-/\,$1<\.\*>\-/;
2327	`grep -Erq "$compat\|$compat2\|$compat3" $dt_path`;
2328	if ( $? >> 8 ) {
2329	WARN("UNDOCUMENTED_DT_STRING",
2330	"DT compatible string \"$compat\" appears un-documented -- check $dt_path\n" . $herecurr);
2331	}
2332
2333	next if $compat !~ /^([a-zA-Z0-9\-]+)\,/;
2334	my $vendor = $1;
2335	`grep -Eq "^$vendor\\b" $vp_file`;
2336	if ( $? >> 8 ) {
2337	WARN("UNDOCUMENTED_DT_STRING",
2338	"DT compatible string vendor \"$vendor\" appears un-documented -- check $vp_file\n" . $herecurr);
2339	}
2340	}
2341	}
2342
2343	# check we are in a valid source file if not then ignore this hunk
2344	next if ($realfile !~ /\.(h\|c\|s\|S\|pl\|sh)$/);
2345
2346	#line length limit
2347	if ($line =~ /^\+/ && $prevrawline !~ /\/\\/ &&
2348	$rawline !~ /^.\s\\s*\@$Ident\s/ &&
2349	!($line =~ /^\+\s$logFunctions\s$\s(?:(KERN_\S+\s\|[^"]))?"[X\t]"\s(?:\|,\|$\s;)\s*$/ \|\|
2350	$line =~ /^\+\s"[^"]"\s(?:\s\|,\|\)\s;)\s$/) &&
2351	$length > $max_line_length)
2352	{
2353	WARN("LONG_LINE",
2354	"line over $max_line_length characters\n" . $herecurr);
2355	}
2356
2357	# Check for user-visible strings broken across lines, which breaks the ability
2358	# to grep for the string. Make exceptions when the previous string ends in a
2359	# newline (multiple lines in one string constant) or '\t', '\r', ';', or '{'
2360	# (common in inline assembly) or is a octal \123 or hexadecimal \xaf value
2361	if ($line =~ /^\+\s*"/ &&
2362	$prevline =~ /"\s*$/ &&
2363	$prevrawline !~ /(?:\\(?:[ntr]\|[0-7]{1,3}\|x[0-9a-fA-F]{1,2})\|;\s\|\{\s)"\s*$/) {
2364	WARN("SPLIT_STRING",
2365	"quoted string split across lines\n" . $hereprev);
2366	}
2367
2368	# check for missing a space in a string concatination
2369	if ($prevrawline =~ /[^\\]\w"$/ && $rawline =~ /^\+[\t ]+"\w/) {
2370	WARN('MISSING_SPACE',
2371	"break quoted strings at a space character\n" . $hereprev);
2372	}
2373
2374	# check for spaces before a quoted newline
2375	if ($rawline =~ /^.\".\s\\n/) {
2376	if (WARN("QUOTED_WHITESPACE_BEFORE_NEWLINE",
2377	"unnecessary whitespace before a quoted newline\n" . $herecurr) &&
2378	$fix) {
2379	$fixed[$fixlinenr] =~ s/^(\+.\".)\s+\\n/$1\\n/;
2380	}
2381
2382	}
2383
2384	# check for adding lines without a newline.
2385	if ($line =~ /^\+/ && defined $lines[$linenr] && $lines[$linenr] =~ /^\\ No newline at end of file/) {
2386	WARN("MISSING_EOF_NEWLINE",
2387	"adding a line without newline at end of file\n" . $herecurr);
2388	}
2389
2390	# Blackfin: use hi/lo macros
2391	if ($realfile =~ m@arch/blackfin/.*\.S$@) {
2392	if ($line =~ /\.[lL][[:space:]]=.&[[:space:]]*0x[fF][fF][fF][fF]/) {
2393	my $herevet = "$here\n" . cat_vet($line) . "\n";
2394	ERROR("LO_MACRO",
2395	"use the LO() macro, not (... & 0xFFFF)\n" . $herevet);
2396	}
2397	if ($line =~ /\.[hH][[:space:]]=.>>[[:space:]]*16/) {
2398	my $herevet = "$here\n" . cat_vet($line) . "\n";
2399	ERROR("HI_MACRO",
2400	"use the HI() macro, not (... >> 16)\n" . $herevet);
2401	}
2402	}
2403
2404	# check we are in a valid source file C or perl if not then ignore this hunk
2405	next if ($realfile !~ /\.(h\|c\|pl)$/);
2406
2407	# at the beginning of a line any tabs must come first and anything
2408	# more than 8 must use tabs.
2409	if ($rawline =~ /^\+\s* \t\s*\S/ \|\|
2410	$rawline =~ /^\+\s* \s*/) {
2411	my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2412	$rpt_cleaners = 1;
2413	if (ERROR("CODE_INDENT",
2414	"code indent should use tabs where possible\n" . $herevet) &&
2415	$fix) {
2416	$fixed[$fixlinenr] =~ s/^\+([ \t]+)/"\+" . tabify($1)/e;
2417	}
2418	}
2419
2420	# check for space before tabs.
2421	if ($rawline =~ /^\+/ && $rawline =~ / \t/) {
2422	my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2423	if (WARN("SPACE_BEFORE_TAB",
2424	"please, no space before tabs\n" . $herevet) &&
2425	$fix) {
2426	while ($fixed[$fixlinenr] =~
2427	s/(^\+.*) {8,8}+\t/$1\t\t/) {}
2428	while ($fixed[$fixlinenr] =~
2429	s/(^\+.*) +\t/$1\t/) {}
2430	}
2431	}
2432
2433	# check for && or \|\| at the start of a line
2434	if ($rawline =~ /^\+\s*(&&\|\\|\\|)/) {
2435	CHK("LOGICAL_CONTINUATIONS",
2436	"Logical continuations should be on the previous line\n" . $hereprev);
2437	}
2438
2439	# check multi-line statement indentation matches previous line
2440	if ($^V && $^V ge 5.10.0 &&
2441	$prevline =~ /^\+([ \t])((?:$c90_Keywords(?:\s+if)\s)\|(?:$Declare\s)?(?:$Ident\|$\s\\s$Ident\s$)\s\|$Ident\s=\s$Ident\s)\(.(\&\&\|\\|\\|\|,)\s*$/) {
2442	$prevline =~ /^\+(\t)(.)$/;
2443	my $oldindent = $1;
2444	my $rest = $2;
2445
2446	my $pos = pos_last_openparen($rest);
2447	if ($pos >= 0) {
2448	$line =~ /^(\+\| )([ \t]*)/;
2449	my $newindent = $2;
2450
2451	my $goodtabindent = $oldindent .
2452	"\t" x ($pos / 8) .
2453	" " x ($pos % 8);
2454	my $goodspaceindent = $oldindent . " " x $pos;
2455
2456	if ($newindent ne $goodtabindent &&
2457	$newindent ne $goodspaceindent) {
2458
2459	if (CHK("PARENTHESIS_ALIGNMENT",
2460	"Alignment should match open parenthesis\n" . $hereprev) &&
2461	$fix && $line =~ /^\+/) {
2462	$fixed[$fixlinenr] =~
2463	s/^\+[ \t]*/\+$goodtabindent/;
2464	}
2465	}
2466	}
2467	}
2468
2469	if ($line =~ /^\+.$\s$Type\s*$[ \t]+(?!$Assignment\|$Arithmetic\|{)/) {
2470	if (CHK("SPACING",
2471	"No space is necessary after a cast\n" . $herecurr) &&
2472	$fix) {
2473	$fixed[$fixlinenr] =~
2474	s/($\s$Type\s$)[ \t]+/$1/;
2475	}
2476	}
2477
2478	if ($realfile =~ m@^(drivers/net/\|net/)@ &&
2479	$prevrawline =~ /^\+[ \t]\/\[ \t]*$/ &&
2480	$rawline =~ /^\+[ \t]\/ &&
2481	$realline > 2) {
2482	WARN("NETWORKING_BLOCK_COMMENT_STYLE",
2483	"networking block comments don't use an empty /* line, use /* Comment...\n" . $hereprev);
2484	}
2485
2486	if ($realfile =~ m@^(drivers/net/\|net/)@ &&
2487	$prevrawline =~ /^\+[ \t]\/\/ && #starting /*
2488	$prevrawline !~ /\\/[ \t]$/ && #no trailing */
2489	$rawline =~ /^\+/ && #line is new
2490	$rawline !~ /^\+[ \t]\/) { #no leading *
2491	WARN("NETWORKING_BLOCK_COMMENT_STYLE",
2492	"networking block comments start with * on subsequent lines\n" . $hereprev);
2493	}
2494
2495	if ($realfile =~ m@^(drivers/net/\|net/)@ &&
2496	$rawline !~ m@^\+[ \t]\/[ \t]$@ && #trailing /
2497	$rawline !~ m@^\+./\.\/[ \t]$@ && #inline /...*/
2498	$rawline !~ m@^\+.\{2,}/[ \t]$@ && #trailing */
2499	$rawline =~ m@^\+[ \t].+\\/[ \t]$@) { #non blank /
2500	WARN("NETWORKING_BLOCK_COMMENT_STYLE",
2501	"networking block comments put the trailing */ on a separate line\n" . $herecurr);
2502	}
2503
2504	# check for missing blank lines after struct/union declarations
2505	# with exceptions for various attributes and macros
2506	if ($prevline =~ /^[\+ ]};?\s*$/ &&
2507	$line =~ /^\+/ &&
2508	!($line =~ /^\+\s*$/ \|\|
2509	$line =~ /^\+\s*EXPORT_SYMBOL/ \|\|
2510	$line =~ /^\+\s*MODULE_/i \|\|
2511	$line =~ /^\+\s\#\s(?:end\|elif\|else)/ \|\|
2512	$line =~ /^\+[a-z_]*init/ \|\|
2513	$line =~ /^\+\s(?:static\s+)?[A-Z_]ATTR/ \|\|
2514	$line =~ /^\+\s*DECLARE/ \|\|
2515	$line =~ /^\+\s*__setup/)) {
2516	if (CHK("LINE_SPACING",
2517	"Please use a blank line after function/struct/union/enum declarations\n" . $hereprev) &&
2518	$fix) {
2519	fix_insert_line($fixlinenr, "\+");
2520	}
2521	}
2522
2523	# check for multiple consecutive blank lines
2524	if ($prevline =~ /^[\+ ]\s*$/ &&
2525	$line =~ /^\+\s*$/ &&
2526	$last_blank_line != ($linenr - 1)) {
2527	if (CHK("LINE_SPACING",
2528	"Please don't use multiple blank lines\n" . $hereprev) &&
2529	$fix) {
2530	fix_delete_line($fixlinenr, $rawline);
2531	}
2532
2533	$last_blank_line = $linenr;
2534	}
2535
2536	# check for missing blank lines after declarations
2537	if ($sline =~ /^\+\s+\S/ && #Not at char 1
2538	# actual declarations
2539	($prevline =~ /^\+\s+$Declare\s$Ident\s[=,;:\[]/ \|\|
2540	# function pointer declarations
2541	$prevline =~ /^\+\s+$Declare\s$\s\\s$Ident\s$\s[=,;:\[\(]/ \|\|
2542	# foo bar; where foo is some local typedef or #define
2543	$prevline =~ /^\+\s+$Ident(?:\s+\|\s\\s)$Ident\s[=,;\[]/ \|\|
2544	# known declaration macros
2545	$prevline =~ /^\+\s+$declaration_macros/) &&
2546	# for "else if" which can look like "$Ident $Ident"
2547	!($prevline =~ /^\+\s+$c90_Keywords\b/ \|\|
2548	# other possible extensions of declaration lines
2549	$prevline =~ /(?:$Compare\|$Assignment\|$Operators)\s*$/ \|\|
2550	# not starting a section or a macro "\" extended line
2551	$prevline =~ /(?:\{\s*\|\\)$/) &&
2552	# looks like a declaration
2553	!($sline =~ /^\+\s+$Declare\s$Ident\s[=,;:\[]/ \|\|
2554	# function pointer declarations
2555	$sline =~ /^\+\s+$Declare\s$\s\\s$Ident\s$\s[=,;:\[\(]/ \|\|
2556	# foo bar; where foo is some local typedef or #define
2557	$sline =~ /^\+\s+$Ident(?:\s+\|\s\\s)$Ident\s[=,;\[]/ \|\|
2558	# known declaration macros
2559	$sline =~ /^\+\s+$declaration_macros/ \|\|
2560	# start of struct or union or enum
2561	$sline =~ /^\+\s+(?:union\|struct\|enum\|typedef)\b/ \|\|
2562	# start or end of block or continuation of declaration
2563	$sline =~ /^\+\s+(?:$\|[\{\}\.\#\"\?\:\(\[])/ \|\|
2564	# bitfield continuation
2565	$sline =~ /^\+\s+$Ident\s:\s\d+\s*[,;]/ \|\|
2566	# other possible extensions of declaration lines
2567	$sline =~ /^\+\s+\(?\s*(?:$Compare\|$Assignment\|$Operators)/) &&
2568	# indentation of previous and current line are the same
2569	(($prevline =~ /\+(\s+)\S/) && $sline =~ /^\+$1\S/)) {
2570	if (WARN("LINE_SPACING",
2571	"Missing a blank line after declarations\n" . $hereprev) &&
2572	$fix) {
2573	fix_insert_line($fixlinenr, "\+");
2574	}
2575	}
2576
2577	# check for spaces at the beginning of a line.
2578	# Exceptions:
2579	# 1) within comments
2580	# 2) indented preprocessor commands
2581	# 3) hanging labels
2582	if ($rawline =~ /^\+ / && $line !~ /^\+ *(?:$;\|#\|$Ident:)/) {
2583	my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2584	if (WARN("LEADING_SPACE",
2585	"please, no spaces at the start of a line\n" . $herevet) &&
2586	$fix) {
2587	$fixed[$fixlinenr] =~ s/^\+([ \t]+)/"\+" . tabify($1)/e;
2588	}
2589	}
2590
2591	# check we are in a valid C source file if not then ignore this hunk
2592	next if ($realfile !~ /\.(h\|c)$/);
2593
2594	# check indentation of any line with a bare else
2595	# if the previous line is a break or return and is indented 1 tab more...
2596	if ($sline =~ /^\+([\t]+)(?:}[ \t])?else(?:[ \t]{)?\s*$/) {
2597	my $tabs = length($1) + 1;
2598	if ($prevline =~ /^\+\t{$tabs,$tabs}(?:break\|return)\b/) {
2599	WARN("UNNECESSARY_ELSE",
2600	"else is not generally useful after a break or return\n" . $hereprev);
2601	}
2602	}
2603
2604	# check indentation of a line with a break;
2605	# if the previous line is a goto or return and is indented the same # of tabs
2606	if ($sline =~ /^\+([\t]+)break\s;\s$/) {
2607	my $tabs = $1;
2608	if ($prevline =~ /^\+$tabs(?:goto\|return)\b/) {
2609	WARN("UNNECESSARY_BREAK",
2610	"break is not useful after a goto or return\n" . $hereprev);
2611	}
2612	}
2613
2614	# discourage the addition of CONFIG_EXPERIMENTAL in #if(def).
2615	if ($line =~ /^\+\s\#\sif.*\bCONFIG_EXPERIMENTAL\b/) {
2616	WARN("CONFIG_EXPERIMENTAL",
2617	"Use of CONFIG_EXPERIMENTAL is deprecated. For alternatives, see https://lkml.org/lkml/2012/10/23/580\n");
2618	}
2619
2620	# check for RCS/CVS revision markers
2621	if ($rawline =~ /^\+.*\$(Revision\|Log\|Id)(?:\$\|)/) {
2622	WARN("CVS_KEYWORD",
2623	"CVS style keyword markers, these will _not_ be updated\n". $herecurr);
2624	}
2625
2626	# Blackfin: don't use __builtin_bfin_[cs]sync
2627	if ($line =~ /__builtin_bfin_csync/) {
2628	my $herevet = "$here\n" . cat_vet($line) . "\n";
2629	ERROR("CSYNC",
2630	"use the CSYNC() macro in asm/blackfin.h\n" . $herevet);
2631	}
2632	if ($line =~ /__builtin_bfin_ssync/) {
2633	my $herevet = "$here\n" . cat_vet($line) . "\n";
2634	ERROR("SSYNC",
2635	"use the SSYNC() macro in asm/blackfin.h\n" . $herevet);
2636	}
2637
2638	# check for old HOTPLUG __dev<foo> section markings
2639	if ($line =~ /\b(__dev(init\|exit)(data\|const\|))\b/) {
2640	WARN("HOTPLUG_SECTION",
2641	"Using $1 is unnecessary\n" . $herecurr);
2642	}
2643
2644	# Check for potential 'bare' types
2645	my ($stat, $cond, $line_nr_next, $remain_next, $off_next,
2646	$realline_next);
2647	#print "LINE<$line>\n";
2648	if ($linenr >= $suppress_statement &&
2649	$realcnt && $sline =~ /.\s*\S/) {
2650	($stat, $cond, $line_nr_next, $remain_next, $off_next) =
2651	ctx_statement_block($linenr, $realcnt, 0);
2652	$stat =~ s/\n./\n /g;
2653	$cond =~ s/\n./\n /g;
2654
2655	#print "linenr<$linenr> <$stat>\n";
2656	# If this statement has no statement boundaries within
2657	# it there is no point in retrying a statement scan
2658	# until we hit end of it.
2659	my $frag = $stat; $frag =~ s/;+\s*$//;
2660	if ($frag !~ /(?:{\|;)/) {
2661	#print "skip<$line_nr_next>\n";
2662	$suppress_statement = $line_nr_next;
2663	}
2664
2665	# Find the real next line.
2666	$realline_next = $line_nr_next;
2667	if (defined $realline_next &&
2668	(!defined $lines[$realline_next - 1] \|\|
2669	substr($lines[$realline_next - 1], $off_next) =~ /^\s*$/)) {
2670	$realline_next++;
2671	}
2672
2673	my $s = $stat;
2674	$s =~ s/{.*$//s;
2675
2676	# Ignore goto labels.
2677	if ($s =~ /$Ident:\*$/s) {
2678
2679	# Ignore functions being called
2680	} elsif ($s =~ /^.\s$Ident\s\(/s) {
2681
2682	} elsif ($s =~ /^.\s*else\b/s) {
2683
2684	# declarations always start with types
2685	} 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) {
2686	my $type = $1;
2687	$type =~ s/\s+/ /g;
2688	possible($type, "A:" . $s);
2689
2690	# definitions in global scope can only start with types
2691	} elsif ($s =~ /^.(?:$Storage\s+)?(?:$Inline\s+)?(?:const\s+)?($Ident)\b\s*(?!:)/s) {
2692	possible($1, "B:" . $s);
2693	}
2694
2695	# any (foo ... *) is a pointer cast, and foo is a type
2696	while ($s =~ /$($Ident)(?:\s+$Sparse)[\s\]+\s*$/sg) {
2697	possible($1, "C:" . $s);
2698	}
2699
2700	# Check for any sort of function declaration.
2701	# int foo(something bar, other baz);
2702	# void (store_gdt)(x86_descr_ptr );
2703	if ($prev_values eq 'E' && $s =~ /^(.(?:typedef\s)?(?:(?:$Storage\|$Inline)\s)\s$Type\s(?:\b$Ident\|$\\s$Ident$)\s)\(/s) {
2704	my ($name_len) = length($1);
2705
2706	my $ctx = $s;
2707	substr($ctx, 0, $name_len + 1, '');
2708	$ctx =~ s/\)[^\)]*$//;
2709
2710	for my $arg (split(/\s,\s/, $ctx)) {
2711	if ($arg =~ /^(?:const\s+)?($Ident)(?:\s+$Sparse)\s\*\s(:?\b$Ident)?$/s \|\| $arg =~ /^($Ident)$/s) {
2712
2713	possible($1, "D:" . $s);
2714	}
2715	}
2716	}
2717
2718	}
2719
2720	#
2721	# Checks which may be anchored in the context.
2722	#
2723
2724	# Check for switch () and associated case and default
2725	# statements should be at the same indent.
2726	if ($line=~/\bswitch\s$.$/) {
2727	my $err = '';
2728	my $sep = '';
2729	my @ctx = ctx_block_outer($linenr, $realcnt);
2730	shift(@ctx);
2731	for my $ctx (@ctx) {
2732	my ($clen, $cindent) = line_stats($ctx);
2733	if ($ctx =~ /^\+\s*(case\s+\|default:)/ &&
2734	$indent != $cindent) {
2735	$err .= "$sep$ctx\n";
2736	$sep = '';
2737	} else {
2738	$sep = "[...]\n";
2739	}
2740	}
2741	if ($err ne '') {
2742	ERROR("SWITCH_CASE_INDENT_LEVEL",
2743	"switch and case should be at the same indent\n$hereline$err");
2744	}
2745	}
2746
2747	# if/while/etc brace do not go on next line, unless defining a do while loop,
2748	# or if that brace on the next line is for something else
2749	if ($line =~ /(.)\b((?:if\|while\|for\|switch\|(?:[a-z_]+\|)for_each[a-z_]+)\s\(\|do\b\|else\b)/ && $line !~ /^.\s*\#/) {
2750	my $pre_ctx = "$1$2";
2751
2752	my ($level, @ctx) = ctx_statement_level($linenr, $realcnt, 0);
2753
2754	if ($line =~ /^\+\t{6,}/) {
2755	WARN("DEEP_INDENTATION",
2756	"Too many leading tabs - consider code refactoring\n" . $herecurr);
2757	}
2758
2759	my $ctx_cnt = $realcnt - $#ctx - 1;
2760	my $ctx = join("\n", @ctx);
2761
2762	my $ctx_ln = $linenr;
2763	my $ctx_skip = $realcnt;
2764
2765	while ($ctx_skip > $ctx_cnt \|\| ($ctx_skip == $ctx_cnt &&
2766	defined $lines[$ctx_ln - 1] &&
2767	$lines[$ctx_ln - 1] =~ /^-/)) {
2768	##print "SKIP<$ctx_skip> CNT<$ctx_cnt>\n";
2769	$ctx_skip-- if (!defined $lines[$ctx_ln - 1] \|\| $lines[$ctx_ln - 1] !~ /^-/);
2770	$ctx_ln++;
2771	}
2772
2773	#print "realcnt<$realcnt> ctx_cnt<$ctx_cnt>\n";
2774	#print "pre<$pre_ctx>\nline<$line>\nctx<$ctx>\nnext<$lines[$ctx_ln - 1]>\n";
2775
2776	if ($ctx !~ /{\s/ && defined($lines[$ctx_ln - 1]) && $lines[$ctx_ln - 1] =~ /^\+\s{/) {
2777	ERROR("OPEN_BRACE",
2778	"that open brace { should be on the previous line\n" .
2779	"$here\n$ctx\n$rawlines[$ctx_ln - 1]\n");
2780	}
2781	if ($level == 0 && $pre_ctx !~ /}\swhile\s\($/ &&
2782	$ctx =~ /\)\s\;\s$/ &&
2783	defined $lines[$ctx_ln - 1])
2784	{
2785	my ($nlength, $nindent) = line_stats($lines[$ctx_ln - 1]);
2786	if ($nindent > $indent) {
2787	WARN("TRAILING_SEMICOLON",
2788	"trailing semicolon indicates no statements, indent implies otherwise\n" .
2789	"$here\n$ctx\n$rawlines[$ctx_ln - 1]\n");
2790	}
2791	}
2792	}
2793
2794	# Check relative indent for conditionals and blocks.
2795	if ($line =~ /\b(?:(?:if\|while\|for\|(?:[a-z_]+\|)for_each[a-z_]+)\s\(\|do\b)/ && $line !~ /^.\s#/ && $line !~ /\}\swhile\s/) {
2796	($stat, $cond, $line_nr_next, $remain_next, $off_next) =
2797	ctx_statement_block($linenr, $realcnt, 0)
2798	if (!defined $stat);
2799	my ($s, $c) = ($stat, $cond);
2800
2801	substr($s, 0, length($c), '');
2802
2803	# Make sure we remove the line prefixes as we have
2804	# none on the first line, and are going to readd them
2805	# where necessary.
2806	$s =~ s/\n./\n/gs;
2807
2808	# Find out how long the conditional actually is.
2809	my @newlines = ($c =~ /\n/gs);
2810	my $cond_lines = 1 + $#newlines;
2811
2812	# We want to check the first line inside the block
2813	# starting at the end of the conditional, so remove:
2814	# 1) any blank line termination
2815	# 2) any opening brace { on end of the line
2816	# 3) any do (...) {
2817	my $continuation = 0;
2818	my $check = 0;
2819	$s =~ s/^.*\bdo\b//;
2820	$s =~ s/^\s*{//;
2821	if ($s =~ s/^\s*\\//) {
2822	$continuation = 1;
2823	}
2824	if ($s =~ s/^\s*?\n//) {
2825	$check = 1;
2826	$cond_lines++;
2827	}
2828
2829	# Also ignore a loop construct at the end of a
2830	# preprocessor statement.
2831	if (($prevline =~ /^.\s#\sdefine\s/ \|\|
2832	$prevline =~ /\\\s*$/) && $continuation == 0) {
2833	$check = 0;
2834	}
2835
2836	my $cond_ptr = -1;
2837	$continuation = 0;
2838	while ($cond_ptr != $cond_lines) {
2839	$cond_ptr = $cond_lines;
2840
2841	# If we see an #else/#elif then the code
2842	# is not linear.
2843	if ($s =~ /^\s\#\s(?:else\|elif)/) {
2844	$check = 0;
2845	}
2846
2847	# Ignore:
2848	# 1) blank lines, they should be at 0,
2849	# 2) preprocessor lines, and
2850	# 3) labels.
2851	if ($continuation \|\|
2852	$s =~ /^\s*?\n/ \|\|
2853	$s =~ /^\s#\s?/ \|\|
2854	$s =~ /^\s$Ident\s:/) {
2855	$continuation = ($s =~ /^.*?\\\n/) ? 1 : 0;
2856	if ($s =~ s/^.*?\n//) {
2857	$cond_lines++;
2858	}
2859	}
2860	}
2861
2862	my (undef, $sindent) = line_stats("+" . $s);
2863	my $stat_real = raw_line($linenr, $cond_lines);
2864
2865	# Check if either of these lines are modified, else
2866	# this is not this patch's fault.
2867	if (!defined($stat_real) \|\|
2868	$stat !~ /^\+/ && $stat_real !~ /^\+/) {
2869	$check = 0;
2870	}
2871	if (defined($stat_real) && $cond_lines > 1) {
2872	$stat_real = "[...]\n$stat_real";
2873	}
2874
2875	#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";
2876
2877	if ($check && (($sindent % 8) != 0 \|\|
2878	($sindent <= $indent && $s ne ''))) {
2879	WARN("SUSPECT_CODE_INDENT",
2880	"suspect code indent for conditional statements ($indent, $sindent)\n" . $herecurr . "$stat_real\n");
2881	}
2882	}
2883
2884	# Track the 'values' across context and added lines.
2885	my $opline = $line; $opline =~ s/^./ /;
2886	my ($curr_values, $curr_vars) =
2887	annotate_values($opline . "\n", $prev_values);
2888	$curr_values = $prev_values . $curr_values;
2889	if ($dbg_values) {
2890	my $outline = $opline; $outline =~ s/\t/ /g;
2891	print "$linenr > .$outline\n";
2892	print "$linenr > $curr_values\n";
2893	print "$linenr > $curr_vars\n";
2894	}
2895	$prev_values = substr($curr_values, -1);
2896
2897	#ignore lines not being added
2898	next if ($line =~ /^[^\+]/);
2899
2900	# TEST: allow direct testing of the type matcher.
2901	if ($dbg_type) {
2902	if ($line =~ /^.\s$Declare\s$/) {
2903	ERROR("TEST_TYPE",
2904	"TEST: is type\n" . $herecurr);
2905	} elsif ($dbg_type > 1 && $line =~ /^.+($Declare)/) {
2906	ERROR("TEST_NOT_TYPE",
2907	"TEST: is not type ($1 is)\n". $herecurr);
2908	}
2909	next;
2910	}
2911	# TEST: allow direct testing of the attribute matcher.
2912	if ($dbg_attr) {
2913	if ($line =~ /^.\s$Modifier\s$/) {
2914	ERROR("TEST_ATTR",
2915	"TEST: is attr\n" . $herecurr);
2916	} elsif ($dbg_attr > 1 && $line =~ /^.+($Modifier)/) {
2917	ERROR("TEST_NOT_ATTR",
2918	"TEST: is not attr ($1 is)\n". $herecurr);
2919	}
2920	next;
2921	}
2922
2923	# check for initialisation to aggregates open brace on the next line
2924	if ($line =~ /^.\s*{/ &&
2925	$prevline =~ /(?:^\|[^=])=\s*$/) {
2926	if (ERROR("OPEN_BRACE",
2927	"that open brace { should be on the previous line\n" . $hereprev) &&
2928	$fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
2929	fix_delete_line($fixlinenr - 1, $prevrawline);
2930	fix_delete_line($fixlinenr, $rawline);
2931	my $fixedline = $prevrawline;
2932	$fixedline =~ s/\s=\s$/ = {/;
2933	fix_insert_line($fixlinenr, $fixedline);
2934	$fixedline = $line;
2935	$fixedline =~ s/^(.\s){\s/$1/;
2936	fix_insert_line($fixlinenr, $fixedline);
2937	}
2938	}
2939
2940	#
2941	# Checks which are anchored on the added line.
2942	#
2943
2944	# check for malformed paths in #include statements (uses RAW line)
2945	if ($rawline =~ m{^.\s\#\sinclude\s+[<"](.*)[">]}) {
2946	my $path = $1;
2947	if ($path =~ m{//}) {
2948	ERROR("MALFORMED_INCLUDE",
2949	"malformed #include filename\n" . $herecurr);
2950	}
2951	if ($path =~ "^uapi/" && $realfile =~ m@\binclude/uapi/@) {
2952	ERROR("UAPI_INCLUDE",
2953	"No #include in ...include/uapi/... should use a uapi/ path prefix\n" . $herecurr);
2954	}
2955	}
2956
2957	# no C99 // comments
2958	if ($line =~ m{//}) {
2959	if (ERROR("C99_COMMENTS",
2960	"do not use C99 // comments\n" . $herecurr) &&
2961	$fix) {
2962	my $line = $fixed[$fixlinenr];
2963	if ($line =~ /\/\/(.*)$/) {
2964	my $comment = trim($1);
2965	$fixed[$fixlinenr] =~ s@\/\/(.)$@/\ $comment \*/@;
2966	}
2967	}
2968	}
2969	# Remove C99 comments.
2970	$line =~ s@//.*@@;
2971	$opline =~ s@//.*@@;
2972
2973	# EXPORT_SYMBOL should immediately follow the thing it is exporting, consider
2974	# the whole statement.
2975	#print "APW <$lines[$realline_next - 1]>\n";
2976	if (defined $realline_next &&
2977	exists $lines[$realline_next - 1] &&
2978	!defined $suppress_export{$realline_next} &&
2979	($lines[$realline_next - 1] =~ /EXPORT_SYMBOL.$(.)$/ \|\|
2980	$lines[$realline_next - 1] =~ /EXPORT_UNUSED_SYMBOL.$(.)$/)) {
2981	# Handle definitions which produce identifiers with
2982	# a prefix:
2983	# XXX(foo);
2984	# EXPORT_SYMBOL(something_foo);
2985	my $name = $1;
2986	if ($stat =~ /^(?:.\s}\s\n)?.([A-Z_]+)\s\(\s($Ident)/ &&
2987	$name =~ /^${Ident}_$2/) {
2988	#print "FOO C name<$name>\n";
2989	$suppress_export{$realline_next} = 1;
2990
2991	} elsif ($stat !~ /(?:
2992	\n.}\s*$\|
2993	^.DEFINE_$Ident$\Q$name\E$\|
2994	^.DECLARE_$Ident$\Q$name\E$\|
2995	^.LIST_HEAD$\Q$name\E$\|
2996	^.(?:$Storage\s+)?$Type\s$\s\\s\Q$name\E\s$\s\(\|
2997	\b\Q$name\E(?:\s+$Attribute)\s(?:;\|=\|\[\|\()
2998	)/x) {
2999	#print "FOO A<$lines[$realline_next - 1]> stat<$stat> name<$name>\n";
3000	$suppress_export{$realline_next} = 2;
3001	} else {
3002	$suppress_export{$realline_next} = 1;
3003	}
3004	}
3005	if (!defined $suppress_export{$linenr} &&
3006	$prevline =~ /^.\s*$/ &&
3007	($line =~ /EXPORT_SYMBOL.$(.)$/ \|\|
3008	$line =~ /EXPORT_UNUSED_SYMBOL.$(.)$/)) {
3009	#print "FOO B <$lines[$linenr - 1]>\n";
3010	$suppress_export{$linenr} = 2;
3011	}
3012	if (defined $suppress_export{$linenr} &&
3013	$suppress_export{$linenr} == 2) {
3014	WARN("EXPORT_SYMBOL",
3015	"EXPORT_SYMBOL(foo); should immediately follow its function/variable\n" . $herecurr);
3016	}
3017
3018	# check for global initialisers.
3019	if ($line =~ /^\+(\s$Type\s$Ident\s(?:\s+$Modifier))\s=\s(0\|NULL\|false)\s*;/) {
3020	if (ERROR("GLOBAL_INITIALISERS",
3021	"do not initialise globals to 0 or NULL\n" .
3022	$herecurr) &&
3023	$fix) {
3024	$fixed[$fixlinenr] =~ s/($Type\s$Ident\s(?:\s+$Modifier))\s=\s(0\|NULL\|false)\s;/$1;/;
3025	}
3026	}
3027	# check for static initialisers.
3028	if ($line =~ /^\+.\bstatic\s.=\s(0\|NULL\|false)\s;/) {
3029	if (ERROR("INITIALISED_STATIC",
3030	"do not initialise statics to 0 or NULL\n" .
3031	$herecurr) &&
3032	$fix) {
3033	$fixed[$fixlinenr] =~ s/(\bstatic\s.?)\s=\s(0\|NULL\|false)\s;/$1;/;
3034	}
3035	}
3036
3037	# check for misordered declarations of char/short/int/long with signed/unsigned
3038	while ($sline =~ m{(\b$TypeMisordered\b)}g) {
3039	my $tmp = trim($1);
3040	WARN("MISORDERED_TYPE",
3041	"type '$tmp' should be specified in [[un]signed] [short\|int\|long\|long long] order\n" . $herecurr);
3042	}
3043
3044	# check for static const char * arrays.
3045	if ($line =~ /\bstatic\s+const\s+char\s\\s(\w+)\s\[\s\]\s=\s*/) {
3046	WARN("STATIC_CONST_CHAR_ARRAY",
3047	"static const char * array should probably be static const char * const\n" .
3048	$herecurr);
3049	}
3050
3051	# check for static char foo[] = "bar" declarations.
3052	if ($line =~ /\bstatic\s+char\s+(\w+)\s\[\s\]\s=\s"/) {
3053	WARN("STATIC_CONST_CHAR_ARRAY",
3054	"static char array declaration should probably be static const char\n" .
3055	$herecurr);
3056	}
3057
3058	# check for non-global char *foo[] = {"bar", ...} declarations.
3059	if ($line =~ /^.\s+(?:static\s+\|const\s+)?char\s+\\s\w+\s\[\s\]\s=\s\{/) {
3060	WARN("STATIC_CONST_CHAR_ARRAY",
3061	"char * array declaration might be better as static const\n" .
3062	$herecurr);
3063	}
3064
3065	# check for function declarations without arguments like "int foo()"
3066	if ($line =~ /(\b$Type\s+$Ident)\s$\s$/) {
3067	if (ERROR("FUNCTION_WITHOUT_ARGS",
3068	"Bad function definition - $1() should probably be $1(void)\n" . $herecurr) &&
3069	$fix) {
3070	$fixed[$fixlinenr] =~ s/(\b($Type)\s+($Ident))\s$\s$/$2 $3(void)/;
3071	}
3072	}
3073
3074	# check for uses of DEFINE_PCI_DEVICE_TABLE
3075	if ($line =~ /\bDEFINE_PCI_DEVICE_TABLE\s$\s(\w+)\s$\s=/) {
3076	if (WARN("DEFINE_PCI_DEVICE_TABLE",
3077	"Prefer struct pci_device_id over deprecated DEFINE_PCI_DEVICE_TABLE\n" . $herecurr) &&
3078	$fix) {
3079	$fixed[$fixlinenr] =~ s/\b(?:static\s+\|)DEFINE_PCI_DEVICE_TABLE\s$\s(\w+)\s$\s=\s*/static const struct pci_device_id $1\[\] = /;
3080	}
3081	}
3082
3083	# check for new typedefs, only function parameters and sparse annotations
3084	# make sense.
3085	if ($line =~ /\btypedef\s/ &&
3086	$line !~ /\btypedef\s+$Type\s$\s\?$Ident\s$\s*\(/ &&
3087	$line !~ /\btypedef\s+$Type\s+$Ident\s*\(/ &&
3088	$line !~ /\b$typeTypedefs\b/ &&
3089	$line !~ /\b__bitwise(?:__\|)\b/) {
3090	WARN("NEW_TYPEDEFS",
3091	"do not add new typedefs\n" . $herecurr);
3092	}
3093
3094	# * goes on variable not on type
3095	# (char*[ const])
3096	while ($line =~ m{($$NonptrType(\s(?:$Modifier\b\s\|\\s)+)$)}g) {
3097	#print "AA<$1>\n";
3098	my ($ident, $from, $to) = ($1, $2, $2);
3099
3100	# Should start with a space.
3101	$to =~ s/^(\S)/ $1/;
3102	# Should not end with a space.
3103	$to =~ s/\s+$//;
3104	# '*'s should not have spaces between.
3105	while ($to =~ s/\\s+\/\\/) {
3106	}
3107
3108	## print "1: from<$from> to<$to> ident<$ident>\n";
3109	if ($from ne $to) {
3110	if (ERROR("POINTER_LOCATION",
3111	"\"(foo$from)\" should be \"(foo$to)\"\n" . $herecurr) &&
3112	$fix) {
3113	my $sub_from = $ident;
3114	my $sub_to = $ident;
3115	$sub_to =~ s/\Q$from\E/$to/;
3116	$fixed[$fixlinenr] =~
3117	s@\Q$sub_from\E@$sub_to@;
3118	}
3119	}
3120	}
3121	while ($line =~ m{(\b$NonptrType(\s(?:$Modifier\b\s\|\\s)+)($Ident))}g) {
3122	#print "BB<$1>\n";
3123	my ($match, $from, $to, $ident) = ($1, $2, $2, $3);
3124
3125	# Should start with a space.
3126	$to =~ s/^(\S)/ $1/;
3127	# Should not end with a space.
3128	$to =~ s/\s+$//;
3129	# '*'s should not have spaces between.
3130	while ($to =~ s/\\s+\/\\/) {
3131	}
3132	# Modifiers should have spaces.
3133	$to =~ s/(\b$Modifier$)/$1 /;
3134
3135	## print "2: from<$from> to<$to> ident<$ident>\n";
3136	if ($from ne $to && $ident !~ /^$Modifier$/) {
3137	if (ERROR("POINTER_LOCATION",
3138	"\"foo${from}bar\" should be \"foo${to}bar\"\n" . $herecurr) &&
3139	$fix) {
3140
3141	my $sub_from = $match;
3142	my $sub_to = $match;
3143	$sub_to =~ s/\Q$from\E/$to/;
3144	$fixed[$fixlinenr] =~
3145	s@\Q$sub_from\E@$sub_to@;
3146	}
3147	}
3148	}
3149
3150	# # no BUG() or BUG_ON()
3151	# if ($line =~ /\b(BUG\|BUG_ON)\b/) {
3152	# print "Try to use WARN_ON & Recovery code rather than BUG() or BUG_ON()\n";
3153	# print "$herecurr";
3154	# $clean = 0;
3155	# }
3156
3157	if ($line =~ /\bLINUX_VERSION_CODE\b/) {
3158	WARN("LINUX_VERSION_CODE",
3159	"LINUX_VERSION_CODE should be avoided, code should be for the version to which it is merged\n" . $herecurr);
3160	}
3161
3162	# check for uses of printk_ratelimit
3163	if ($line =~ /\bprintk_ratelimit\s*\(/) {
3164	WARN("PRINTK_RATELIMITED",
3165	"Prefer printk_ratelimited or pr_<level>_ratelimited to printk_ratelimit\n" . $herecurr);
3166	}
3167
3168	# printk should use KERN_* levels. Note that follow on printk's on the
3169	# same line do not need a level, so we use the current block context
3170	# to try and find and validate the current printk. In summary the current
3171	# printk includes all preceding printk's which have no newline on the end.
3172	# we assume the first bad printk is the one to report.
3173	if ($line =~ /\bprintk\((?!KERN_)\s*"/) {
3174	my $ok = 0;
3175	for (my $ln = $linenr - 1; $ln >= $first_line; $ln--) {
3176	#print "CHECK<$lines[$ln - 1]\n";
3177	# we have a preceding printk if it ends
3178	# with "\n" ignore it, else it is to blame
3179	if ($lines[$ln - 1] =~ m{\bprintk\(}) {
3180	if ($rawlines[$ln - 1] !~ m{\\n"}) {
3181	$ok = 1;
3182	}
3183	last;
3184	}
3185	}
3186	if ($ok == 0) {
3187	WARN("PRINTK_WITHOUT_KERN_LEVEL",
3188	"printk() should include KERN_ facility level\n" . $herecurr);
3189	}
3190	}
3191
3192	if ($line =~ /\bprintk\s\(\sKERN_([A-Z]+)/) {
3193	my $orig = $1;
3194	my $level = lc($orig);
3195	$level = "warn" if ($level eq "warning");
3196	my $level2 = $level;
3197	$level2 = "dbg" if ($level eq "debug");
3198	WARN("PREFER_PR_LEVEL",
3199	"Prefer [subsystem eg: netdev]_$level2([subsystem]dev, ... then dev_$level2(dev, ... then pr_$level(... to printk(KERN_$orig ...\n" . $herecurr);
3200	}
3201
3202	if ($line =~ /\bpr_warning\s*\(/) {
3203	if (WARN("PREFER_PR_LEVEL",
3204	"Prefer pr_warn(... to pr_warning(...\n" . $herecurr) &&
3205	$fix) {
3206	$fixed[$fixlinenr] =~
3207	s/\bpr_warning\b/pr_warn/;
3208	}
3209	}
3210
3211	if ($line =~ /\bdev_printk\s\(\sKERN_([A-Z]+)/) {
3212	my $orig = $1;
3213	my $level = lc($orig);
3214	$level = "warn" if ($level eq "warning");
3215	$level = "dbg" if ($level eq "debug");
3216	WARN("PREFER_DEV_LEVEL",
3217	"Prefer dev_$level(... to dev_printk(KERN_$orig, ...\n" . $herecurr);
3218	}
3219
3220	# function brace can't be on same line, except for #defines of do while,
3221	# or if closed on same line
3222	if (($line=~/$Type\s$Ident$.$.\s{/) and
3223	!($line=~/\#\sdefine.do\s{/) and !($line=~/}/)) {
3224	if (ERROR("OPEN_BRACE",
3225	"open brace '{' following function declarations go on the next line\n" . $herecurr) &&
3226	$fix) {
3227	fix_delete_line($fixlinenr, $rawline);
3228	my $fixed_line = $rawline;
3229	$fixed_line =~ /(^..$Type\s$Ident$.$\s){(.*)$/;
3230	my $line1 = $1;
3231	my $line2 = $2;
3232	fix_insert_line($fixlinenr, ltrim($line1));
3233	fix_insert_line($fixlinenr, "\+{");
3234	if ($line2 !~ /^\s*$/) {
3235	fix_insert_line($fixlinenr, "\+\t" . trim($line2));
3236	}
3237	}
3238	}
3239
3240	# open braces for enum, union and struct go on the same line.
3241	if ($line =~ /^.\s*{/ &&
3242	$prevline =~ /^.\s(?:typedef\s+)?(enum\|union\|struct)(?:\s+$Ident)?\s$/) {
3243	if (ERROR("OPEN_BRACE",
3244	"open brace '{' following $1 go on the same line\n" . $hereprev) &&
3245	$fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
3246	fix_delete_line($fixlinenr - 1, $prevrawline);
3247	fix_delete_line($fixlinenr, $rawline);
3248	my $fixedline = rtrim($prevrawline) . " {";
3249	fix_insert_line($fixlinenr, $fixedline);
3250	$fixedline = $rawline;
3251	$fixedline =~ s/^(.\s){\s/$1\t/;
3252	if ($fixedline !~ /^\+\s*$/) {
3253	fix_insert_line($fixlinenr, $fixedline);
3254	}
3255	}
3256	}
3257
3258	# missing space after union, struct or enum definition
3259	if ($line =~ /^.\s*(?:typedef\s+)?(enum\|union\|struct)(?:\s+$Ident){1,2}[=\{]/) {
3260	if (WARN("SPACING",
3261	"missing space after $1 definition\n" . $herecurr) &&
3262	$fix) {
3263	$fixed[$fixlinenr] =~
3264	s/^(.\s*(?:typedef\s+)?(?:enum\|union\|struct)(?:\s+$Ident){1,2})([=\{])/$1 $2/;
3265	}
3266	}
3267
3268	# Function pointer declarations
3269	# check spacing between type, funcptr, and args
3270	# canonical declaration is "type (*funcptr)(args...)"
3271	if ($line =~ /^.\s($Declare)$(\s)\(\s)($Ident)(\s)$(\s)\(/) {
3272	my $declare = $1;
3273	my $pre_pointer_space = $2;
3274	my $post_pointer_space = $3;
3275	my $funcname = $4;
3276	my $post_funcname_space = $5;
3277	my $pre_args_space = $6;
3278
3279	# the $Declare variable will capture all spaces after the type
3280	# so check it for a missing trailing missing space but pointer return types
3281	# don't need a space so don't warn for those.
3282	my $post_declare_space = "";
3283	if ($declare =~ /(\s+)$/) {
3284	$post_declare_space = $1;
3285	$declare = rtrim($declare);
3286	}
3287	if ($declare !~ /\*$/ && $post_declare_space =~ /^$/) {
3288	WARN("SPACING",
3289	"missing space after return type\n" . $herecurr);
3290	$post_declare_space = " ";
3291	}
3292
3293	# unnecessary space "type (*funcptr)(args...)"
3294	# This test is not currently implemented because these declarations are
3295	# equivalent to
3296	# int foo(int bar, ...)
3297	# and this is form shouldn't/doesn't generate a checkpatch warning.
3298	#
3299	# elsif ($declare =~ /\s{2,}$/) {
3300	# WARN("SPACING",
3301	# "Multiple spaces after return type\n" . $herecurr);
3302	# }
3303
3304	# unnecessary space "type ( *funcptr)(args...)"
3305	if (defined $pre_pointer_space &&
3306	$pre_pointer_space =~ /^\s/) {
3307	WARN("SPACING",
3308	"Unnecessary space after function pointer open parenthesis\n" . $herecurr);
3309	}
3310
3311	# unnecessary space "type (* funcptr)(args...)"
3312	if (defined $post_pointer_space &&
3313	$post_pointer_space =~ /^\s/) {
3314	WARN("SPACING",
3315	"Unnecessary space before function pointer name\n" . $herecurr);
3316	}
3317
3318	# unnecessary space "type (*funcptr )(args...)"
3319	if (defined $post_funcname_space &&
3320	$post_funcname_space =~ /^\s/) {
3321	WARN("SPACING",
3322	"Unnecessary space after function pointer name\n" . $herecurr);
3323	}
3324
3325	# unnecessary space "type (*funcptr) (args...)"
3326	if (defined $pre_args_space &&
3327	$pre_args_space =~ /^\s/) {
3328	WARN("SPACING",
3329	"Unnecessary space before function pointer arguments\n" . $herecurr);
3330	}
3331
3332	if (show_type("SPACING") && $fix) {
3333	$fixed[$fixlinenr] =~
3334	s/^(.\s)$Declare\s$\s\\s$Ident\s$\s\(/$1 . $declare . $post_declare_space . '(' . $funcname . ')('/ex;
3335	}
3336	}
3337
3338	# check for spacing round square brackets; allowed:
3339	# 1. with a type on the left -- int [] a;
3340	# 2. at the beginning of a line for slice initialisers -- [0...10] = 5,
3341	# 3. inside a curly brace -- = { [0...10] = 5 }
3342	while ($line =~ /(.*?\s)\[/g) {
3343	my ($where, $prefix) = ($-[1], $1);
3344	if ($prefix !~ /$Type\s+$/ &&
3345	($where != 0 \|\| $prefix !~ /^.\s+$/) &&
3346	$prefix !~ /[{,]\s+$/) {
3347	if (ERROR("BRACKET_SPACE",
3348	"space prohibited before open square bracket '['\n" . $herecurr) &&
3349	$fix) {
3350	$fixed[$fixlinenr] =~
3351	s/^(\+.*?)\s+\[/$1\[/;
3352	}
3353	}
3354	}
3355
3356	# check for spaces between functions and their parentheses.
3357	while ($line =~ /($Ident)\s+\(/g) {
3358	my $name = $1;
3359	my $ctx_before = substr($line, 0, $-[1]);
3360	my $ctx = "$ctx_before$name";
3361
3362	# Ignore those directives where spaces _are_ permitted.
3363	if ($name =~ /^(?:
3364	if\|for\|while\|switch\|return\|case\|
3365	volatile\|__volatile__\|
3366	__attribute__\|format\|__extension__\|
3367	asm\|__asm__)$/x)
3368	{
3369	# cpp #define statements have non-optional spaces, ie
3370	# if there is a space between the name and the open
3371	# parenthesis it is simply not a parameter group.
3372	} elsif ($ctx_before =~ /^.\s\#\sdefine\s*$/) {
3373
3374	# cpp #elif statement condition may start with a (
3375	} elsif ($ctx =~ /^.\s\#\selif\s*$/) {
3376
3377	# If this whole things ends with a type its most
3378	# likely a typedef for a function.
3379	} elsif ($ctx =~ /$Type$/) {
3380
3381	} else {
3382	if (WARN("SPACING",
3383	"space prohibited between function name and open parenthesis '('\n" . $herecurr) &&
3384	$fix) {
3385	$fixed[$fixlinenr] =~
3386	s/\b$name\s+\(/$name\(/;
3387	}
3388	}
3389	}
3390
3391	# Check operator spacing.
3392	if (!($line=~/\#\s*include/)) {
3393	my $fixed_line = "";
3394	my $line_fixed = 0;
3395
3396	my $ops = qr{
3397	<<=\|>>=\|<=\|>=\|==\|!=\|
3398	\+=\|-=\|\*=\|\/=\|%=\|\^=\|\\|=\|&=\|
3399	=>\|->\|<<\|>>\|<\|>\|=\|!\|~\|
3400	&&\|\\|\\|\|,\|\^\|\+\+\|--\|&\|\\|\|\+\|-\|\*\|\/\|%\|
3401	\?:\|\?\|:
3402	}x;
3403	my @elements = split(/($ops\|;)/, $opline);
3404
3405	## print("element count: <" . $#elements . ">\n");
3406	## foreach my $el (@elements) {
3407	## print("el: <$el>\n");
3408	## }
3409
3410	my @fix_elements = ();
3411	my $off = 0;
3412
3413	foreach my $el (@elements) {
3414	push(@fix_elements, substr($rawline, $off, length($el)));
3415	$off += length($el);
3416	}
3417
3418	$off = 0;
3419
3420	my $blank = copy_spacing($opline);
3421	my $last_after = -1;
3422
3423	for (my $n = 0; $n < $#elements; $n += 2) {
3424
3425	my $good = $fix_elements[$n] . $fix_elements[$n + 1];
3426
3427	## print("n: <$n> good: <$good>\n");
3428
3429	$off += length($elements[$n]);
3430
3431	# Pick up the preceding and succeeding characters.
3432	my $ca = substr($opline, 0, $off);
3433	my $cc = '';
3434	if (length($opline) >= ($off + length($elements[$n + 1]))) {
3435	$cc = substr($opline, $off + length($elements[$n + 1]));
3436	}
3437	my $cb = "$ca$;$cc";
3438
3439	my $a = '';
3440	$a = 'V' if ($elements[$n] ne '');
3441	$a = 'W' if ($elements[$n] =~ /\s$/);
3442	$a = 'C' if ($elements[$n] =~ /$;$/);
3443	$a = 'B' if ($elements[$n] =~ /(\[\|\()$/);
3444	$a = 'O' if ($elements[$n] eq '');
3445	$a = 'E' if ($ca =~ /^\s*$/);
3446
3447	my $op = $elements[$n + 1];
3448
3449	my $c = '';
3450	if (defined $elements[$n + 2]) {
3451	$c = 'V' if ($elements[$n + 2] ne '');
3452	$c = 'W' if ($elements[$n + 2] =~ /^\s/);
3453	$c = 'C' if ($elements[$n + 2] =~ /^$;/);
3454	$c = 'B' if ($elements[$n + 2] =~ /^(\)\|\]\|;)/);
3455	$c = 'O' if ($elements[$n + 2] eq '');
3456	$c = 'E' if ($elements[$n + 2] =~ /^\s*\\$/);
3457	} else {
3458	$c = 'E';
3459	}
3460
3461	my $ctx = "${a}x${c}";
3462
3463	my $at = "(ctx:$ctx)";
3464
3465	my $ptr = substr($blank, 0, $off) . "^";
3466	my $hereptr = "$hereline$ptr\n";
3467
3468	# Pull out the value of this operator.
3469	my $op_type = substr($curr_values, $off + 1, 1);
3470
3471	# Get the full operator variant.
3472	my $opv = $op . substr($curr_vars, $off, 1);
3473
3474	# Ignore operators passed as parameters.
3475	if ($op_type ne 'V' &&
3476	$ca =~ /\s$/ && $cc =~ /^\s*,/) {
3477
3478	# # Ignore comments
3479	# } elsif ($op =~ /^$;+$/) {
3480
3481	# ; should have either the end of line or a space or \ after it
3482	} elsif ($op eq ';') {
3483	if ($ctx !~ /.x[WEBC]/ &&
3484	$cc !~ /^\\/ && $cc !~ /^;/) {
3485	if (ERROR("SPACING",
3486	"space required after that '$op' $at\n" . $hereptr)) {
3487	$good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";
3488	$line_fixed = 1;
3489	}
3490	}
3491
3492	# // is a comment
3493	} elsif ($op eq '//') {
3494
3495	# : when part of a bitfield
3496	} elsif ($opv eq ':B') {
3497	# skip the bitfield test for now
3498
3499	# No spaces for:
3500	# ->
3501	} elsif ($op eq '->') {
3502	if ($ctx =~ /Wx.\|.xW/) {
3503	if (ERROR("SPACING",
3504	"spaces prohibited around that '$op' $at\n" . $hereptr)) {
3505	$good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
3506	if (defined $fix_elements[$n + 2]) {
3507	$fix_elements[$n + 2] =~ s/^\s+//;
3508	}
3509	$line_fixed = 1;
3510	}
3511	}
3512
3513	# , must have a space on the right.
3514	} elsif ($op eq ',') {
3515	if ($ctx !~ /.x[WEC]/ && $cc !~ /^}/) {
3516	if (ERROR("SPACING",
3517	"space required after that '$op' $at\n" . $hereptr)) {
3518	$good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";
3519	$line_fixed = 1;
3520	$last_after = $n;
3521	}
3522	}
3523
3524	# '*' as part of a type definition -- reported already.
3525	} elsif ($opv eq '*_') {
3526	#warn "'*' is part of type\n";
3527
3528	# unary operators should have a space before and
3529	# none after. May be left adjacent to another
3530	# unary operator, or a cast
3531	} elsif ($op eq '!' \|\| $op eq '~' \|\|
3532	$opv eq '*U' \|\| $opv eq '-U' \|\|
3533	$opv eq '&U' \|\| $opv eq '&&U') {
3534	if ($ctx !~ /[WEBC]x./ && $ca !~ /(?:\)\|!\|~\|\*\|-\|\&\|\\|\|\+\+\|\-\-\|\{)$/) {
3535	if (ERROR("SPACING",
3536	"space required before that '$op' $at\n" . $hereptr)) {
3537	if ($n != $last_after + 2) {
3538	$good = $fix_elements[$n] . " " . ltrim($fix_elements[$n + 1]);
3539	$line_fixed = 1;
3540	}
3541	}
3542	}
3543	if ($op eq '' && $cc =~/\s$Modifier\b/) {
3544	# A unary '*' may be const
3545
3546	} elsif ($ctx =~ /.xW/) {
3547	if (ERROR("SPACING",
3548	"space prohibited after that '$op' $at\n" . $hereptr)) {
3549	$good = $fix_elements[$n] . rtrim($fix_elements[$n + 1]);
3550	if (defined $fix_elements[$n + 2]) {
3551	$fix_elements[$n + 2] =~ s/^\s+//;
3552	}
3553	$line_fixed = 1;
3554	}
3555	}
3556
3557	# unary ++ and unary -- are allowed no space on one side.
3558	} elsif ($op eq '++' or $op eq '--') {
3559	if ($ctx !~ /[WEOBC]x[^W]/ && $ctx !~ /[^W]x[WOBEC]/) {
3560	if (ERROR("SPACING",
3561	"space required one side of that '$op' $at\n" . $hereptr)) {
3562	$good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";
3563	$line_fixed = 1;
3564	}
3565	}
3566	if ($ctx =~ /Wx[BE]/ \|\|
3567	($ctx =~ /Wx./ && $cc =~ /^;/)) {
3568	if (ERROR("SPACING",
3569	"space prohibited before that '$op' $at\n" . $hereptr)) {
3570	$good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
3571	$line_fixed = 1;
3572	}
3573	}
3574	if ($ctx =~ /ExW/) {
3575	if (ERROR("SPACING",
3576	"space prohibited after that '$op' $at\n" . $hereptr)) {
3577	$good = $fix_elements[$n] . trim($fix_elements[$n + 1]);
3578	if (defined $fix_elements[$n + 2]) {
3579	$fix_elements[$n + 2] =~ s/^\s+//;
3580	}
3581	$line_fixed = 1;
3582	}
3583	}
3584
3585	# << and >> may either have or not have spaces both sides
3586	} elsif ($op eq '<<' or $op eq '>>' or
3587	$op eq '&' or $op eq '^' or $op eq '\|' or
3588	$op eq '+' or $op eq '-' or
3589	$op eq '*' or $op eq '/' or
3590	$op eq '%')
3591	{
3592	if ($ctx =~ /Wx[^WCE]\|[^WCE]xW/) {
3593	if (ERROR("SPACING",
3594	"need consistent spacing around '$op' $at\n" . $hereptr)) {
3595	$good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
3596	if (defined $fix_elements[$n + 2]) {
3597	$fix_elements[$n + 2] =~ s/^\s+//;
3598	}
3599	$line_fixed = 1;
3600	}
3601	}
3602
3603	# A colon needs no spaces before when it is
3604	# terminating a case value or a label.
3605	} elsif ($opv eq ':C' \|\| $opv eq ':L') {
3606	if ($ctx =~ /Wx./) {
3607	if (ERROR("SPACING",
3608	"space prohibited before that '$op' $at\n" . $hereptr)) {
3609	$good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
3610	$line_fixed = 1;
3611	}
3612	}
3613
3614	# All the others need spaces both sides.
3615	} elsif ($ctx !~ /[EWC]x[CWE]/) {
3616	my $ok = 0;
3617
3618	# Ignore email addresses <foo@bar>
3619	if (($op eq '<' &&
3620	$cc =~ /^\S+\@\S+>/) \|\|
3621	($op eq '>' &&
3622	$ca =~ /<\S+\@\S+$/))
3623	{
3624	$ok = 1;
3625	}
3626
3627	# messages are ERROR, but ?: are CHK
3628	if ($ok == 0) {
3629	my $msg_type = \&ERROR;
3630	$msg_type = \&CHK if (($op eq '?:' \|\| $op eq '?' \|\| $op eq ':') && $ctx =~ /VxV/);
3631
3632	if (&{$msg_type}("SPACING",
3633	"spaces required around that '$op' $at\n" . $hereptr)) {
3634	$good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
3635	if (defined $fix_elements[$n + 2]) {
3636	$fix_elements[$n + 2] =~ s/^\s+//;
3637	}
3638	$line_fixed = 1;
3639	}
3640	}
3641	}
3642	$off += length($elements[$n + 1]);
3643
3644	## print("n: <$n> GOOD: <$good>\n");
3645
3646	$fixed_line = $fixed_line . $good;
3647	}
3648
3649	if (($#elements % 2) == 0) {
3650	$fixed_line = $fixed_line . $fix_elements[$#elements];
3651	}
3652
3653	if ($fix && $line_fixed && $fixed_line ne $fixed[$fixlinenr]) {
3654	$fixed[$fixlinenr] = $fixed_line;
3655	}
3656
3657
3658	}
3659
3660	# check for whitespace before a non-naked semicolon
3661	if ($line =~ /^\+.\S\s+;\s$/) {
3662	if (WARN("SPACING",
3663	"space prohibited before semicolon\n" . $herecurr) &&
3664	$fix) {
3665	1 while $fixed[$fixlinenr] =~
3666	s/^(\+.*\S)\s+;/$1;/;
3667	}
3668	}
3669
3670	# check for multiple assignments
3671	if ($line =~ /^.\s$Lval\s=\s$Lval\s=(?!=)/) {
3672	CHK("MULTIPLE_ASSIGNMENTS",
3673	"multiple assignments should be avoided\n" . $herecurr);
3674	}
3675
3676	## # check for multiple declarations, allowing for a function declaration
3677	## # continuation.
3678	## if ($line =~ /^.\s$Type\s+$Ident(?:\s=[^,{])?\s,\s$Ident./ &&
3679	## $line !~ /^.\s$Type\s+$Ident(?:\s=[^,{])?\s,\s$Type\s$Ident.*/) {
3680	##
3681	## # Remove any bracketed sections to ensure we do not
3682	## # falsly report the parameters of functions.
3683	## my $ln = $line;
3684	## while ($ln =~ s/$[^\($]*\)//g) {
3685	## }
3686	## if ($ln =~ /,/) {
3687	## WARN("MULTIPLE_DECLARATION",
3688	## "declaring multiple variables together should be avoided\n" . $herecurr);
3689	## }
3690	## }
3691
3692	#need space before brace following if, while, etc
3693	if (($line =~ /$.*${/ && $line !~ /$$Type${/) \|\|
3694	$line =~ /do{/) {
3695	if (ERROR("SPACING",
3696	"space required before the open brace '{'\n" . $herecurr) &&
3697	$fix) {
3698	$fixed[$fixlinenr] =~ s/^(\+.*(?:do\|\))){/$1 {/;
3699	}
3700	}
3701
3702	## # check for blank lines before declarations
3703	## if ($line =~ /^.\t+$Type\s+$Ident(?:\s=.)?;/ &&
3704	## $prevrawline =~ /^.\s*$/) {
3705	## WARN("SPACING",
3706	## "No blank lines before declarations\n" . $hereprev);
3707	## }
3708	##
3709
3710	# closing brace should have a space following it when it has anything
3711	# on the line
3712	if ($line =~ /}(?!(?:,\|;\|\)))\S/) {
3713	if (ERROR("SPACING",
3714	"space required after that close brace '}'\n" . $herecurr) &&
3715	$fix) {
3716	$fixed[$fixlinenr] =~
3717	s/}((?!(?:,\|;\|\)))\S)/} $1/;
3718	}
3719	}
3720
3721	# check spacing on square brackets
3722	if ($line =~ /\[\s/ && $line !~ /\[\s*$/) {
3723	if (ERROR("SPACING",
3724	"space prohibited after that open square bracket '['\n" . $herecurr) &&
3725	$fix) {
3726	$fixed[$fixlinenr] =~
3727	s/\[\s+/\[/;
3728	}
3729	}
3730	if ($line =~ /\s\]/) {
3731	if (ERROR("SPACING",
3732	"space prohibited before that close square bracket ']'\n" . $herecurr) &&
3733	$fix) {
3734	$fixed[$fixlinenr] =~
3735	s/\s+\]/\]/;
3736	}
3737	}
3738
3739	# check spacing on parentheses
3740	if ($line =~ /$\s/ && $line !~ /\(\s*(?:\$?$/ &&
3741	$line !~ /for\s*\(\s+;/) {
3742	if (ERROR("SPACING",
3743	"space prohibited after that open parenthesis '('\n" . $herecurr) &&
3744	$fix) {
3745	$fixed[$fixlinenr] =~
3746	s/\(\s+/\(/;
3747	}
3748	}
3749	if ($line =~ /(\s+)\)/ && $line !~ /^.\s*\)/ &&
3750	$line !~ /for\s$.;\s+$/ &&
3751	$line !~ /:\s+\)/) {
3752	if (ERROR("SPACING",
3753	"space prohibited before that close parenthesis ')'\n" . $herecurr) &&
3754	$fix) {
3755	print("fixlinenr: <$fixlinenr> fixed[fixlinenr]: <$fixed[$fixlinenr]>\n");
3756	$fixed[$fixlinenr] =~
3757	s/\s+\)/\)/;
3758	}
3759	}
3760
3761	# check unnecessary parentheses around addressof/dereference single $Lvals
3762	# ie: &(foo->bar) should be &foo->bar and (foo->bar) should be foo->bar
3763
3764	while ($line =~ /(?:[^&]&\s\|\)$\s($Ident\s(?:$Member\s)+)\s$/g) {
3765	CHK("UNNECESSARY_PARENTHESES",
3766	"Unnecessary parentheses around $1\n" . $herecurr);
3767	}
3768
3769	#goto labels aren't indented, allow a single space however
3770	if ($line=~/^.\s+[A-Za-z\d_]+:(?![0-9]+)/ and
3771	!($line=~/^. [A-Za-z\d_]+:/) and !($line=~/^.\s+default:/)) {
3772	if (WARN("INDENTED_LABEL",
3773	"labels should not be indented\n" . $herecurr) &&
3774	$fix) {
3775	$fixed[$fixlinenr] =~
3776	s/^(.)\s+/$1/;
3777	}
3778	}
3779
3780	# return is not a function
3781	if (defined($stat) && $stat =~ /^.\sreturn(\s)\(/s) {
3782	my $spacing = $1;
3783	if ($^V && $^V ge 5.10.0 &&
3784	$stat =~ /^.\sreturn\s($balanced_parens)\s;\s$/) {
3785	my $value = $1;
3786	$value = deparenthesize($value);
3787	if ($value =~ m/^\s$FuncArg\s(?:\?\|$)/) {
3788	ERROR("RETURN_PARENTHESES",
3789	"return is not a function, parentheses are not required\n" . $herecurr);
3790	}
3791	} elsif ($spacing !~ /\s+/) {
3792	ERROR("SPACING",
3793	"space required before the open parenthesis '('\n" . $herecurr);
3794	}
3795	}
3796
3797	# unnecessary return in a void function
3798	# at end-of-function, with the previous line a single leading tab, then return;
3799	# and the line before that not a goto label target like "out:"
3800	if ($sline =~ /^[ \+]}\s*$/ &&
3801	$prevline =~ /^\+\treturn\s;\s$/ &&
3802	$linenr >= 3 &&
3803	$lines[$linenr - 3] =~ /^[ +]/ &&
3804	$lines[$linenr - 3] !~ /^[ +]\s$Ident\s:/) {
3805	WARN("RETURN_VOID",
3806	"void function return statements are not generally useful\n" . $hereprev);
3807	}
3808
3809	# if statements using unnecessary parentheses - ie: if ((foo == bar))
3810	if ($^V && $^V ge 5.10.0 &&
3811	$line =~ /\bif\s((?:\(\s){2,})/) {
3812	my $openparens = $1;
3813	my $count = $openparens =~ tr@\(@\(@;
3814	my $msg = "";
3815	if ($line =~ /\bif\s(?:$\s){$count,$count}$LvalOrFunc\s($Compare)\s$LvalOrFunc(?:\s*$){$count,$count}/) {
3816	my $comp = $4; #Not $1 because of $LvalOrFunc
3817	$msg = " - maybe == should be = ?" if ($comp eq "==");
3818	WARN("UNNECESSARY_PARENTHESES",
3819	"Unnecessary parentheses$msg\n" . $herecurr);
3820	}
3821	}
3822
3823	# Return of what appears to be an errno should normally be -'ve
3824	if ($line =~ /^.\sreturn\s(E[A-Z])\s;/) {
3825	my $name = $1;
3826	if ($name ne 'EOF' && $name ne 'ERROR') {
3827	WARN("USE_NEGATIVE_ERRNO",
3828	"return of an errno should typically be -ve (return -$1)\n" . $herecurr);
3829	}
3830	}
3831
3832	# Need a space before open parenthesis after if, while etc
3833	if ($line =~ /\b(if\|while\|for\|switch)\(/) {
3834	if (ERROR("SPACING",
3835	"space required before the open parenthesis '('\n" . $herecurr) &&
3836	$fix) {
3837	$fixed[$fixlinenr] =~
3838	s/\b(if\|while\|for\|switch)\(/$1 \(/;
3839	}
3840	}
3841
3842	# Check for illegal assignment in if conditional -- and check for trailing
3843	# statements after the conditional.
3844	if ($line =~ /do\s*(?!{)/) {
3845	($stat, $cond, $line_nr_next, $remain_next, $off_next) =
3846	ctx_statement_block($linenr, $realcnt, 0)
3847	if (!defined $stat);
3848	my ($stat_next) = ctx_statement_block($line_nr_next,
3849	$remain_next, $off_next);
3850	$stat_next =~ s/\n./\n /g;
3851	##print "stat<$stat> stat_next<$stat_next>\n";
3852
3853	if ($stat_next =~ /^\s*while\b/) {
3854	# If the statement carries leading newlines,
3855	# then count those as offsets.
3856	my ($whitespace) =
3857	($stat_next =~ /^((?:\s\n[+-])\s*)/s);
3858	my $offset =
3859	statement_rawlines($whitespace) - 1;
3860
3861	$suppress_whiletrailers{$line_nr_next +
3862	$offset} = 1;
3863	}
3864	}
3865	if (!defined $suppress_whiletrailers{$linenr} &&
3866	defined($stat) && defined($cond) &&
3867	$line =~ /\b(?:if\|while\|for)\s\(/ && $line !~ /^.\s#/) {
3868	my ($s, $c) = ($stat, $cond);
3869
3870	if ($c =~ /\bif\s\(.[^<>!=]=[^=].*/s) {
3871	ERROR("ASSIGN_IN_IF",
3872	"do not use assignment in if condition\n" . $herecurr);
3873	}
3874
3875	# Find out what is on the end of the line after the
3876	# conditional.
3877	substr($s, 0, length($c), '');
3878	$s =~ s/\n.*//g;
3879	$s =~ s/$;//g; # Remove any comments
3880	if (length($c) && $s !~ /^\s{?\s\\\s$/ &&
3881	$c !~ /}\swhile\s/)
3882	{
3883	# Find out how long the conditional actually is.
3884	my @newlines = ($c =~ /\n/gs);
3885	my $cond_lines = 1 + $#newlines;
3886	my $stat_real = '';
3887
3888	$stat_real = raw_line($linenr, $cond_lines)
3889	. "\n" if ($cond_lines);
3890	if (defined($stat_real) && $cond_lines > 1) {
3891	$stat_real = "[...]\n$stat_real";
3892	}
3893
3894	ERROR("TRAILING_STATEMENTS",
3895	"trailing statements should be on next line\n" . $herecurr . $stat_real);
3896	}
3897	}
3898
3899	# Check for bitwise tests written as boolean
3900	if ($line =~ /
3901	(?:
3902	(?:\[\|\(\|\&\&\|\\|\\|)
3903	\s0[xX][0-9]+\s
3904	(?:\&\&\|\\|\\|)
3905	\|
3906	(?:\&\&\|\\|\\|)
3907	\s0[xX][0-9]+\s
3908	(?:\&\&\|\\|\\|\|\)\|\])
3909	)/x)
3910	{
3911	WARN("HEXADECIMAL_BOOLEAN_TEST",
3912	"boolean test with hexadecimal, perhaps just 1 \& or \\|?\n" . $herecurr);
3913	}
3914
3915	# if and else should not have general statements after it
3916	if ($line =~ /^.\s(?:}\s)?else\b(.*)/) {
3917	my $s = $1;
3918	$s =~ s/$;//g; # Remove any comments
3919	if ($s !~ /^\s(?:\sif\|(?:{\|)\s\\?\s*$)/) {
3920	ERROR("TRAILING_STATEMENTS",
3921	"trailing statements should be on next line\n" . $herecurr);
3922	}
3923	}
3924	# if should not continue a brace
3925	if ($line =~ /}\s*if\b/) {
3926	ERROR("TRAILING_STATEMENTS",
3927	"trailing statements should be on next line (or did you mean 'else if'?)\n" .
3928	$herecurr);
3929	}
3930	# case and default should not have general statements after them
3931	if ($line =~ /^.\s(?:case\s.\|default\s):/g &&
3932	$line !~ /\G(?:
3933	(?:\s$;)(?:\s{)?(?:\s$;)(?:\s\\)?\s*$\|
3934	\s*return\s+
3935	)/xg)
3936	{
3937	ERROR("TRAILING_STATEMENTS",
3938	"trailing statements should be on next line\n" . $herecurr);
3939	}
3940
3941	# Check for }<nl>else {, these must be at the same
3942	# indent level to be relevant to each other.
3943	if ($prevline=~/}\s$/ and $line=~/^.\selse\s*/ &&
3944	$previndent == $indent) {
3945	if (ERROR("ELSE_AFTER_BRACE",
3946	"else should follow close brace '}'\n" . $hereprev) &&
3947	$fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
3948	fix_delete_line($fixlinenr - 1, $prevrawline);
3949	fix_delete_line($fixlinenr, $rawline);
3950	my $fixedline = $prevrawline;
3951	$fixedline =~ s/}\s*$//;
3952	if ($fixedline !~ /^\+\s*$/) {
3953	fix_insert_line($fixlinenr, $fixedline);
3954	}
3955	$fixedline = $rawline;
3956	$fixedline =~ s/^(.\s*)else/$1} else/;
3957	fix_insert_line($fixlinenr, $fixedline);
3958	}
3959	}
3960
3961	if ($prevline=~/}\s$/ and $line=~/^.\swhile\s*/ &&
3962	$previndent == $indent) {
3963	my ($s, $c) = ctx_statement_block($linenr, $realcnt, 0);
3964
3965	# Find out what is on the end of the line after the
3966	# conditional.
3967	substr($s, 0, length($c), '');
3968	$s =~ s/\n.*//g;
3969
3970	if ($s =~ /^\s*;/) {
3971	if (ERROR("WHILE_AFTER_BRACE",
3972	"while should follow close brace '}'\n" . $hereprev) &&
3973	$fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
3974	fix_delete_line($fixlinenr - 1, $prevrawline);
3975	fix_delete_line($fixlinenr, $rawline);
3976	my $fixedline = $prevrawline;
3977	my $trailing = $rawline;
3978	$trailing =~ s/^\+//;
3979	$trailing = trim($trailing);
3980	$fixedline =~ s/}\s*$/} $trailing/;
3981	fix_insert_line($fixlinenr, $fixedline);
3982	}
3983	}
3984	}
3985
3986	#Specific variable tests
3987	while ($line =~ m{($Constant\|$Lval)}g) {
3988	my $var = $1;
3989
3990	#gcc binary extension
3991	if ($var =~ /^$Binary$/) {
3992	if (WARN("GCC_BINARY_CONSTANT",
3993	"Avoid gcc v4.3+ binary constant extension: <$var>\n" . $herecurr) &&
3994	$fix) {
3995	my $hexval = sprintf("0x%x", oct($var));
3996	$fixed[$fixlinenr] =~
3997	s/\b$var\b/$hexval/;
3998	}
3999	}
4000
4001	#CamelCase
4002	if ($var !~ /^$Constant$/ &&
4003	$var =~ /[A-Z][a-z]\|[a-z][A-Z]/ &&
4004	#Ignore Page<foo> variants
4005	$var !~ /^(?:Clear\|Set\|TestClear\|TestSet\|)Page[A-Z]/ &&
4006	#Ignore SI style variants like nS, mV and dB (ie: max_uV, regulator_min_uA_show)
4007	$var !~ /^(?:[a-z_]*?)_?[a-z][A-Z](?:_[a-z_]+)?$/) {
4008	while ($var =~ m{($Ident)}g) {
4009	my $word = $1;
4010	next if ($word !~ /[A-Z][a-z]\|[a-z][A-Z]/);
4011	if ($check) {
4012	seed_camelcase_includes();
4013	if (!$file && !$camelcase_file_seeded) {
4014	seed_camelcase_file($realfile);
4015	$camelcase_file_seeded = 1;
4016	}
4017	}
4018	if (!defined $camelcase{$word}) {
4019	$camelcase{$word} = 1;
4020	CHK("CAMELCASE",
4021	"Avoid CamelCase: <$word>\n" . $herecurr);
4022	}
4023	}
4024	}
4025	}
4026
4027	#no spaces allowed after \ in define
4028	if ($line =~ /\#\sdefine.\\\s+$/) {
4029	if (WARN("WHITESPACE_AFTER_LINE_CONTINUATION",
4030	"Whitespace after \\ makes next lines useless\n" . $herecurr) &&
4031	$fix) {
4032	$fixed[$fixlinenr] =~ s/\s+$//;
4033	}
4034	}
4035
4036	#warn if <asm/foo.h> is #included and <linux/foo.h> is available (uses RAW line)
4037	if ($tree && $rawline =~ m{^.\s\#\sinclude\s\<asm\/(.)\.h\>}) {
4038	my $file = "$1.h";
4039	my $checkfile = "include/linux/$file";
4040	if (-f "$root/$checkfile" &&
4041	$realfile ne $checkfile &&
4042	$1 !~ /$allowed_asm_includes/)
4043	{
4044	if ($realfile =~ m{^arch/}) {
4045	CHK("ARCH_INCLUDE_LINUX",
4046	"Consider using #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
4047	} else {
4048	WARN("INCLUDE_LINUX",
4049	"Use #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
4050	}
4051	}
4052	}
4053
4054	# multi-statement macros should be enclosed in a do while loop, grab the
4055	# first statement and ensure its the whole macro if its not enclosed
4056	# in a known good container
4057	if ($realfile !~ m@/vmlinux.lds.h$@ &&
4058	$line =~ /^.\s\#\sdefine\s*$Ident(\()?/) {
4059	my $ln = $linenr;
4060	my $cnt = $realcnt;
4061	my ($off, $dstat, $dcond, $rest);
4062	my $ctx = '';
4063	($dstat, $dcond, $ln, $cnt, $off) =
4064	ctx_statement_block($linenr, $realcnt, 0);
4065	$ctx = $dstat;
4066	#print "dstat<$dstat> dcond<$dcond> cnt<$cnt> off<$off>\n";
4067	#print "LINE<$lines[$ln-1]> len<" . length($lines[$ln-1]) . "\n";
4068
4069	$dstat =~ s/^.\s\#\sdefine\s+$Ident(?:$[^$]\))?\s//;
4070	$dstat =~ s/$;//g;
4071	$dstat =~ s/\\\n.//g;
4072	$dstat =~ s/^\s*//s;
4073	$dstat =~ s/\s*$//s;
4074
4075	# Flatten any parentheses and braces
4076	while ($dstat =~ s/$[^\($]*\)/1/ \|\|
4077	$dstat =~ s/\{[^\{\}]*\}/1/ \|\|
4078	$dstat =~ s/\[[^\[\]]*\]/1/)
4079	{
4080	}
4081
4082	# Flatten any obvious string concatentation.
4083	while ($dstat =~ s/("X")\s$Ident/$1/ \|\|
4084	$dstat =~ s/$Ident\s("X")/$1/)
4085	{
4086	}
4087
4088	my $exceptions = qr{
4089	$Declare\|
4090	module_param_named\|
4091	MODULE_PARM_DESC\|
4092	DECLARE_PER_CPU\|
4093	DEFINE_PER_CPU\|
4094	__typeof__\(\|
4095	union\|
4096	struct\|
4097	\.$Ident\s=\s\|
4098	^\"\|\"$
4099	}x;
4100	#print "REST<$rest> dstat<$dstat> ctx<$ctx>\n";
4101	if ($dstat ne '' &&
4102	$dstat !~ /^(?:$Ident\|-?$Constant),$/ && # 10, // foo(),
4103	$dstat !~ /^(?:$Ident\|-?$Constant);$/ && # foo();
4104	$dstat !~ /^[!~-]?(?:$Lval\|$Constant)$/ && # 10 // foo() // !foo // ~foo // -foo // foo->bar // foo.bar->baz
4105	$dstat !~ /^'X'$/ && $dstat !~ /^'XX'$/ && # character constants
4106	$dstat !~ /$exceptions/ &&
4107	$dstat !~ /^\.$Ident\s*=/ && # .foo =
4108	$dstat !~ /^(?:\#\s$Ident\|\#\s$Constant)\s*$/ && # stringification #foo
4109	$dstat !~ /^do\s$Constant\swhile\s*$Constant;?$/ && # do {...} while (...); // do {...} while (...)
4110	$dstat !~ /^for\s*$Constant$/ && # for (...)
4111	$dstat !~ /^for\s*$Constant\s+(?:$Ident\|-?$Constant)$/ && # for (...) bar()
4112	$dstat !~ /^do\s*{/ && # do {...
4113	$dstat !~ /^\({/ && # ({...
4114	$ctx !~ /^.\s#\sdefine\s+TRACE_(?:SYSTEM\|INCLUDE_FILE\|INCLUDE_PATH)\b/)
4115	{
4116	$ctx =~ s/\n*$//;
4117	my $herectx = $here . "\n";
4118	my $cnt = statement_rawlines($ctx);
4119
4120	for (my $n = 0; $n < $cnt; $n++) {
4121	$herectx .= raw_line($linenr, $n) . "\n";
4122	}
4123
4124	if ($dstat =~ /;/) {
4125	ERROR("MULTISTATEMENT_MACRO_USE_DO_WHILE",
4126	"Macros with multiple statements should be enclosed in a do - while loop\n" . "$herectx");
4127	} else {
4128	ERROR("COMPLEX_MACRO",
4129	"Macros with complex values should be enclosed in parenthesis\n" . "$herectx");
4130	}
4131	}
4132
4133	# check for line continuations outside of #defines, preprocessor #, and asm
4134
4135	} else {
4136	if ($prevline !~ /^..*\\$/ &&
4137	$line !~ /^\+\s\#.\\$/ && # preprocessor
4138	$line !~ /^\+.\b(__asm__\|asm)\b.\\$/ && # asm
4139	$line =~ /^\+.*\\$/) {
4140	WARN("LINE_CONTINUATIONS",
4141	"Avoid unnecessary line continuations\n" . $herecurr);
4142	}
4143	}
4144
4145	# do {} while (0) macro tests:
4146	# single-statement macros do not need to be enclosed in do while (0) loop,
4147	# macro should not end with a semicolon
4148	if ($^V && $^V ge 5.10.0 &&
4149	$realfile !~ m@/vmlinux.lds.h$@ &&
4150	$line =~ /^.\s\#\sdefine\s+$Ident(\()?/) {
4151	my $ln = $linenr;
4152	my $cnt = $realcnt;
4153	my ($off, $dstat, $dcond, $rest);
4154	my $ctx = '';
4155	($dstat, $dcond, $ln, $cnt, $off) =
4156	ctx_statement_block($linenr, $realcnt, 0);
4157	$ctx = $dstat;
4158
4159	$dstat =~ s/\\\n.//g;
4160
4161	if ($dstat =~ /^\+\s#\sdefine\s+$Ident\s${balanced_parens}\sdo\s{(.)\s}\swhile\s$\s0\s$\s([;\s])\s$/) {
4162	my $stmts = $2;
4163	my $semis = $3;
4164
4165	$ctx =~ s/\n*$//;
4166	my $cnt = statement_rawlines($ctx);
4167	my $herectx = $here . "\n";
4168
4169	for (my $n = 0; $n < $cnt; $n++) {
4170	$herectx .= raw_line($linenr, $n) . "\n";
4171	}
4172
4173	if (($stmts =~ tr/;/;/) == 1 &&
4174	$stmts !~ /^\s*(if\|while\|for\|switch)\b/) {
4175	WARN("SINGLE_STATEMENT_DO_WHILE_MACRO",
4176	"Single statement macros should not use a do {} while (0) loop\n" . "$herectx");
4177	}
4178	if (defined $semis && $semis ne "") {
4179	WARN("DO_WHILE_MACRO_WITH_TRAILING_SEMICOLON",
4180	"do {} while (0) macros should not be semicolon terminated\n" . "$herectx");
4181	}
4182	} elsif ($dstat =~ /^\+\s#\sdefine\s+$Ident.;\s$/) {
4183	$ctx =~ s/\n*$//;
4184	my $cnt = statement_rawlines($ctx);
4185	my $herectx = $here . "\n";
4186
4187	for (my $n = 0; $n < $cnt; $n++) {
4188	$herectx .= raw_line($linenr, $n) . "\n";
4189	}
4190
4191	WARN("TRAILING_SEMICOLON",
4192	"macros should not use a trailing semicolon\n" . "$herectx");
4193	}
4194	}
4195
4196	# make sure symbols are always wrapped with VMLINUX_SYMBOL() ...
4197	# all assignments may have only one of the following with an assignment:
4198	# .
4199	# ALIGN(...)
4200	# VMLINUX_SYMBOL(...)
4201	if ($realfile eq 'vmlinux.lds.h' && $line =~ /(?:(?:^\|\s)$Ident\s=\|=\s$Ident(?:\s\|$))/) {
4202	WARN("MISSING_VMLINUX_SYMBOL",
4203	"vmlinux.lds.h needs VMLINUX_SYMBOL() around C-visible symbols\n" . $herecurr);
4204	}
4205
4206	# check for redundant bracing round if etc
4207	if ($line =~ /(^.)\bif\b/ && $1 !~ /else\s$/) {
4208	my ($level, $endln, @chunks) =
4209	ctx_statement_full($linenr, $realcnt, 1);
4210	#print "chunks<$#chunks> linenr<$linenr> endln<$endln> level<$level>\n";
4211	#print "APW: <<$chunks[1][0]>><<$chunks[1][1]>>\n";
4212	if ($#chunks > 0 && $level == 0) {
4213	my @allowed = ();
4214	my $allow = 0;
4215	my $seen = 0;
4216	my $herectx = $here . "\n";
4217	my $ln = $linenr - 1;
4218	for my $chunk (@chunks) {
4219	my ($cond, $block) = @{$chunk};
4220
4221	# If the condition carries leading newlines, then count those as offsets.
4222	my ($whitespace) = ($cond =~ /^((?:\s\n[+-])\s*)/s);
4223	my $offset = statement_rawlines($whitespace) - 1;
4224
4225	$allowed[$allow] = 0;
4226	#print "COND<$cond> whitespace<$whitespace> offset<$offset>\n";
4227
4228	# We have looked at and allowed this specific line.
4229	$suppress_ifbraces{$ln + $offset} = 1;
4230
4231	$herectx .= "$rawlines[$ln + $offset]\n[...]\n";
4232	$ln += statement_rawlines($block) - 1;
4233
4234	substr($block, 0, length($cond), '');
4235
4236	$seen++ if ($block =~ /^\s*{/);
4237
4238	#print "cond<$cond> block<$block> allowed<$allowed[$allow]>\n";
4239	if (statement_lines($cond) > 1) {
4240	#print "APW: ALLOWED: cond<$cond>\n";
4241	$allowed[$allow] = 1;
4242	}
4243	if ($block =~/\b(?:if\|for\|while)\b/) {
4244	#print "APW: ALLOWED: block<$block>\n";
4245	$allowed[$allow] = 1;
4246	}
4247	if (statement_block_size($block) > 1) {
4248	#print "APW: ALLOWED: lines block<$block>\n";
4249	$allowed[$allow] = 1;
4250	}
4251	$allow++;
4252	}
4253	if ($seen) {
4254	my $sum_allowed = 0;
4255	foreach (@allowed) {
4256	$sum_allowed += $_;
4257	}
4258	if ($sum_allowed == 0) {
4259	WARN("BRACES",
4260	"braces {} are not necessary for any arm of this statement\n" . $herectx);
4261	} elsif ($sum_allowed != $allow &&
4262	$seen != $allow) {
4263	CHK("BRACES",
4264	"braces {} should be used on all arms of this statement\n" . $herectx);
4265	}
4266	}
4267	}
4268	}
4269	if (!defined $suppress_ifbraces{$linenr - 1} &&
4270	$line =~ /\b(if\|while\|for\|else)\b/) {
4271	my $allowed = 0;
4272
4273	# Check the pre-context.
4274	if (substr($line, 0, $-[0]) =~ /(\}\s*)$/) {
4275	#print "APW: ALLOWED: pre<$1>\n";
4276	$allowed = 1;
4277	}
4278
4279	my ($level, $endln, @chunks) =
4280	ctx_statement_full($linenr, $realcnt, $-[0]);
4281
4282	# Check the condition.
4283	my ($cond, $block) = @{$chunks[0]};
4284	#print "CHECKING<$linenr> cond<$cond> block<$block>\n";
4285	if (defined $cond) {
4286	substr($block, 0, length($cond), '');
4287	}
4288	if (statement_lines($cond) > 1) {
4289	#print "APW: ALLOWED: cond<$cond>\n";
4290	$allowed = 1;
4291	}
4292	if ($block =~/\b(?:if\|for\|while)\b/) {
4293	#print "APW: ALLOWED: block<$block>\n";
4294	$allowed = 1;
4295	}
4296	if (statement_block_size($block) > 1) {
4297	#print "APW: ALLOWED: lines block<$block>\n";
4298	$allowed = 1;
4299	}
4300	# Check the post-context.
4301	if (defined $chunks[1]) {
4302	my ($cond, $block) = @{$chunks[1]};
4303	if (defined $cond) {
4304	substr($block, 0, length($cond), '');
4305	}
4306	if ($block =~ /^\s*\{/) {
4307	#print "APW: ALLOWED: chunk-1 block<$block>\n";
4308	$allowed = 1;
4309	}
4310	}
4311	if ($level == 0 && $block =~ /^\s*\{/ && !$allowed) {
4312	my $herectx = $here . "\n";
4313	my $cnt = statement_rawlines($block);
4314
4315	for (my $n = 0; $n < $cnt; $n++) {
4316	$herectx .= raw_line($linenr, $n) . "\n";
4317	}
4318
4319	WARN("BRACES",
4320	"braces {} are not necessary for single statement blocks\n" . $herectx);
4321	}
4322	}
4323
4324	# check for unnecessary blank lines around braces
4325	if (($line =~ /^.\s}\s$/ && $prevrawline =~ /^.\s*$/)) {
4326	CHK("BRACES",
4327	"Blank lines aren't necessary before a close brace '}'\n" . $hereprev);
4328	}
4329	if (($rawline =~ /^.\s$/ && $prevline =~ /^..{\s*$/)) {
4330	CHK("BRACES",
4331	"Blank lines aren't necessary after an open brace '{'\n" . $hereprev);
4332	}
4333
4334	# no volatiles please
4335	my $asm_volatile = qr{\b(__asm__\|asm)\s+(__volatile__\|volatile)\b};
4336	if ($line =~ /\bvolatile\b/ && $line !~ /$asm_volatile/) {
4337	WARN("VOLATILE",
4338	"Use of volatile is usually wrong: see Documentation/volatile-considered-harmful.txt\n" . $herecurr);
4339	}
4340
4341	# warn about #if 0
4342	if ($line =~ /^.\s\#\sif\s+0\b/) {
4343	CHK("REDUNDANT_CODE",
4344	"if this code is redundant consider removing it\n" .
4345	$herecurr);
4346	}
4347
4348	# check for needless "if (<foo>) fn(<foo>)" uses
4349	if ($prevline =~ /\bif\s$\s($Lval)\s*$/) {
4350	my $expr = '\s$\s' . quotemeta($1) . '\s$\s;';
4351	if ($line =~ /\b(kfree\|usb_free_urb\|debugfs_remove(?:_recursive)?)$expr/) {
4352	WARN('NEEDLESS_IF',
4353	"$1(NULL) is safe this check is probably not required\n" . $hereprev);
4354	}
4355	}
4356
4357	# check for unnecessary "Out of Memory" messages
4358	if ($line =~ /^\+.\b$logFunctions\s\(/ &&
4359	$prevline =~ /^[ \+]\sif\s$\s(\!\s\|NULL\s==\s)?($Lval)(\s==\sNULL\s)?\s$/ &&
4360	(defined $1 \|\| defined $3) &&
4361	$linenr > 3) {
4362	my $testval = $2;
4363	my $testline = $lines[$linenr - 3];
4364
4365	my ($s, $c) = ctx_statement_block($linenr - 3, $realcnt, 0);
4366	# print("line: <$line>\nprevline: <$prevline>\ns: <$s>\nc: <$c>\n\n\n");
4367
4368	if ($c =~ /(?:^\|\n)[ \+]\s(?:$Type\s)?\Q$testval\E\s=\s(?:$[^$]\)\s)?\s*(?:devm_)?(?:[kv][czm]alloc(?:_node\|_array)?\b\|kstrdup\|(?:dev_)?alloc_skb)/) {
4369	WARN("OOM_MESSAGE",
4370	"Possible unnecessary 'out of memory' message\n" . $hereprev);
4371	}
4372	}
4373
4374	# check for bad placement of section $InitAttribute (e.g.: __initdata)
4375	if ($line =~ /(\b$InitAttribute\b)/) {
4376	my $attr = $1;
4377	if ($line =~ /^\+\sstatic\s+(?:const\s+)?(?:$attr\s+)?($NonptrTypeWithAttr)\s+(?:$attr\s+)?($Ident(?:\[[^]]\])?)\s*[=;]/) {
4378	my $ptr = $1;
4379	my $var = $2;
4380	if ((($ptr =~ /\b(union\|struct)\s+$attr\b/ &&
4381	ERROR("MISPLACED_INIT",
4382	"$attr should be placed after $var\n" . $herecurr)) \|\|
4383	($ptr !~ /\b(union\|struct)\s+$attr\b/ &&
4384	WARN("MISPLACED_INIT",
4385	"$attr should be placed after $var\n" . $herecurr))) &&
4386	$fix) {
4387	$fixed[$fixlinenr] =~ s/(\bstatic\s+(?:const\s+)?)(?:$attr\s+)?($NonptrTypeWithAttr)\s+(?:$attr\s+)?($Ident(?:\[[^]]\])?)\s([=;])\s/"$1" . trim(string_find_replace($2, "\\s$attr\\s", " ")) . " " . trim(string_find_replace($3, "\\s$attr\\s*", "")) . " $attr" . ("$4" eq ";" ? ";" : " = ")/e;
4388	}
4389	}
4390	}
4391
4392	# check for $InitAttributeData (ie: __initdata) with const
4393	if ($line =~ /\bconst\b/ && $line =~ /($InitAttributeData)/) {
4394	my $attr = $1;
4395	$attr =~ /($InitAttributePrefix)(.*)/;
4396	my $attr_prefix = $1;
4397	my $attr_type = $2;
4398	if (ERROR("INIT_ATTRIBUTE",
4399	"Use of const init definition must use ${attr_prefix}initconst\n" . $herecurr) &&
4400	$fix) {
4401	$fixed[$fixlinenr] =~
4402	s/$InitAttributeData/${attr_prefix}initconst/;
4403	}
4404	}
4405
4406	# check for $InitAttributeConst (ie: __initconst) without const
4407	if ($line !~ /\bconst\b/ && $line =~ /($InitAttributeConst)/) {
4408	my $attr = $1;
4409	if (ERROR("INIT_ATTRIBUTE",
4410	"Use of $attr requires a separate use of const\n" . $herecurr) &&
4411	$fix) {
4412	my $lead = $fixed[$fixlinenr] =~
4413	/(^\+\s*(?:static\s+))/;
4414	$lead = rtrim($1);
4415	$lead = "$lead " if ($lead !~ /^\+$/);
4416	$lead = "${lead}const ";
4417	$fixed[$fixlinenr] =~ s/(^\+\s*(?:static\s+))/$lead/;
4418	}
4419	}
4420
4421	# don't use __constant_<foo> functions outside of include/uapi/
4422	if ($realfile !~ m@^include/uapi/@ &&
4423	$line =~ /(__constant_(?:htons\|ntohs\|[bl]e(?:16\|32\|64)_to_cpu\|cpu_to_[bl]e(?:16\|32\|64)))\s*\(/) {
4424	my $constant_func = $1;
4425	my $func = $constant_func;
4426	$func =~ s/^__constant_//;
4427	if (WARN("CONSTANT_CONVERSION",
4428	"$constant_func should be $func\n" . $herecurr) &&
4429	$fix) {
4430	$fixed[$fixlinenr] =~ s/\b$constant_func\b/$func/g;
4431	}
4432	}
4433
4434	# prefer usleep_range over udelay
4435	if ($line =~ /\budelay\s$\s(\d+)\s*$/) {
4436	my $delay = $1;
4437	# ignore udelay's < 10, however
4438	if (! ($delay < 10) ) {
4439	CHK("USLEEP_RANGE",
4440	"usleep_range is preferred over udelay; see Documentation/timers/timers-howto.txt\n" . $herecurr);
4441	}
4442	if ($delay > 2000) {
4443	WARN("LONG_UDELAY",
4444	"long udelay - prefer mdelay; see arch/arm/include/asm/delay.h\n" . $herecurr);
4445	}
4446	}
4447
4448	# warn about unexpectedly long msleep's
4449	if ($line =~ /\bmsleep\s*$(\d+)$;/) {
4450	if ($1 < 20) {
4451	WARN("MSLEEP",
4452	"msleep < 20ms can sleep for up to 20ms; see Documentation/timers/timers-howto.txt\n" . $herecurr);
4453	}
4454	}
4455
4456	# check for comparisons of jiffies
4457	if ($line =~ /\bjiffies\s$Compare\|$Compare\sjiffies\b/) {
4458	WARN("JIFFIES_COMPARISON",
4459	"Comparing jiffies is almost always wrong; prefer time_after, time_before and friends\n" . $herecurr);
4460	}
4461
4462	# check for comparisons of get_jiffies_64()
4463	if ($line =~ /\bget_jiffies_64\s$\s$\s$Compare\|$Compare\sget_jiffies_64\s$\s$/) {
4464	WARN("JIFFIES_COMPARISON",
4465	"Comparing get_jiffies_64() is almost always wrong; prefer time_after64, time_before64 and friends\n" . $herecurr);
4466	}
4467
4468	# warn about #ifdefs in C files
4469	# if ($line =~ /^.\s\#\sif(\|n)def/ && ($realfile =~ /\.c$/)) {
4470	# print "#ifdef in C files should be avoided\n";
4471	# print "$herecurr";
4472	# $clean = 0;
4473	# }
4474
4475	# warn about spacing in #ifdefs
4476	if ($line =~ /^.\s\#\s(ifdef\|ifndef\|elif)\s\s+/) {
4477	if (ERROR("SPACING",
4478	"exactly one space required after that #$1\n" . $herecurr) &&
4479	$fix) {
4480	$fixed[$fixlinenr] =~
4481	s/^(.\s\#\s(ifdef\|ifndef\|elif))\s{2,}/$1 /;
4482	}
4483
4484	}
4485
4486	# check for spinlock_t definitions without a comment.
4487	if ($line =~ /^.\s*(struct\s+mutex\|spinlock_t)\s+\S+;/ \|\|
4488	$line =~ /^.\s(DEFINE_MUTEX)\s\(/) {
4489	my $which = $1;
4490	if (!ctx_has_comment($first_line, $linenr)) {
4491	CHK("UNCOMMENTED_DEFINITION",
4492	"$1 definition without comment\n" . $herecurr);
4493	}
4494	}
4495	# check for memory barriers without a comment.
4496	if ($line =~ /\b(mb\|rmb\|wmb\|read_barrier_depends\|smp_mb\|smp_rmb\|smp_wmb\|smp_read_barrier_depends)\(/) {
4497	if (!ctx_has_comment($first_line, $linenr)) {
4498	WARN("MEMORY_BARRIER",
4499	"memory barrier without comment\n" . $herecurr);
4500	}
4501	}
4502	# check of hardware specific defines
4503	if ($line =~ m@^.\s\#\sif.*\b(__i386__\|__powerpc64__\|__sun__\|__s390x__)\b@ && $realfile !~ m@include/asm-@) {
4504	CHK("ARCH_DEFINES",
4505	"architecture specific defines should be avoided\n" . $herecurr);
4506	}
4507
4508	# Check that the storage class is at the beginning of a declaration
4509	if ($line =~ /\b$Storage\b/ && $line !~ /^.\s*$Storage\b/) {
4510	WARN("STORAGE_CLASS",
4511	"storage class should be at the beginning of the declaration\n" . $herecurr)
4512	}
4513
4514	# check the location of the inline attribute, that it is between
4515	# storage class and type.
4516	if ($line =~ /\b$Type\s+$Inline\b/ \|\|
4517	$line =~ /\b$Inline\s+$Storage\b/) {
4518	ERROR("INLINE_LOCATION",
4519	"inline keyword should sit between storage class and type\n" . $herecurr);
4520	}
4521
4522	# Check for __inline__ and __inline, prefer inline
4523	if ($realfile !~ m@\binclude/uapi/@ &&
4524	$line =~ /\b(__inline__\|__inline)\b/) {
4525	if (WARN("INLINE",
4526	"plain inline is preferred over $1\n" . $herecurr) &&
4527	$fix) {
4528	$fixed[$fixlinenr] =~ s/\b(__inline__\|__inline)\b/inline/;
4529
4530	}
4531	}
4532
4533	# Check for __attribute__ packed, prefer __packed
4534	if ($realfile !~ m@\binclude/uapi/@ &&
4535	$line =~ /\b__attribute__\s\(\s\(.*\bpacked\b/) {
4536	WARN("PREFER_PACKED",
4537	"__packed is preferred over __attribute__((packed))\n" . $herecurr);
4538	}
4539
4540	# Check for __attribute__ aligned, prefer __aligned
4541	if ($realfile !~ m@\binclude/uapi/@ &&
4542	$line =~ /\b__attribute__\s\(\s\(.*aligned/) {
4543	WARN("PREFER_ALIGNED",
4544	"__aligned(size) is preferred over __attribute__((aligned(size)))\n" . $herecurr);
4545	}
4546
4547	# Check for __attribute__ format(printf, prefer __printf
4548	if ($realfile !~ m@\binclude/uapi/@ &&
4549	$line =~ /\b__attribute__\s\(\s\(\sformat\s\(\s*printf/) {
4550	if (WARN("PREFER_PRINTF",
4551	"__printf(string-index, first-to-check) is preferred over __attribute__((format(printf, string-index, first-to-check)))\n" . $herecurr) &&
4552	$fix) {
4553	$fixed[$fixlinenr] =~ s/\b__attribute__\s$\s\(\sformat\s\(\sprintf\s,\s(.)$\s\)\s\)/"__printf(" . trim($1) . ")"/ex;
4554
4555	}
4556	}
4557
4558	# Check for __attribute__ format(scanf, prefer __scanf
4559	if ($realfile !~ m@\binclude/uapi/@ &&
4560	$line =~ /\b__attribute__\s\(\s\(\sformat\s\(\s*scanf\b/) {
4561	if (WARN("PREFER_SCANF",
4562	"__scanf(string-index, first-to-check) is preferred over __attribute__((format(scanf, string-index, first-to-check)))\n" . $herecurr) &&
4563	$fix) {
4564	$fixed[$fixlinenr] =~ s/\b__attribute__\s$\s\(\sformat\s\(\sscanf\s,\s(.)$\s\)\s\)/"__scanf(" . trim($1) . ")"/ex;
4565	}
4566	}
4567
4568	# check for sizeof(&)
4569	if ($line =~ /\bsizeof\s\(\s\&/) {
4570	WARN("SIZEOF_ADDRESS",
4571	"sizeof(& should be avoided\n" . $herecurr);
4572	}
4573
4574	# check for sizeof without parenthesis
4575	if ($line =~ /\bsizeof\s+((?:\\s\|)$Lval\|$Type(?:\s+$Lval\|))/) {
4576	if (WARN("SIZEOF_PARENTHESIS",
4577	"sizeof $1 should be sizeof($1)\n" . $herecurr) &&
4578	$fix) {
4579	$fixed[$fixlinenr] =~ s/\bsizeof\s+((?:\\s\|)$Lval\|$Type(?:\s+$Lval\|))/"sizeof(" . trim($1) . ")"/ex;
4580	}
4581	}
4582
4583	# check for line continuations in quoted strings with odd counts of "
4584	if ($rawline =~ /\\$/ && $rawline =~ tr/"/"/ % 2) {
4585	WARN("LINE_CONTINUATIONS",
4586	"Avoid line continuations in quoted strings\n" . $herecurr);
4587	}
4588
4589	# check for struct spinlock declarations
4590	if ($line =~ /^.\s\bstruct\s+spinlock\s+\w+\s;/) {
4591	WARN("USE_SPINLOCK_T",
4592	"struct spinlock should be spinlock_t\n" . $herecurr);
4593	}
4594
4595	# check for seq_printf uses that could be seq_puts
4596	if ($sline =~ /\bseq_printf\s$."\s$\s;\s*$/) {
4597	my $fmt = get_quoted_string($line, $rawline);
4598	if ($fmt ne "" && $fmt !~ /[^\\]\%/) {
4599	if (WARN("PREFER_SEQ_PUTS",
4600	"Prefer seq_puts to seq_printf\n" . $herecurr) &&
4601	$fix) {
4602	$fixed[$fixlinenr] =~ s/\bseq_printf\b/seq_puts/;
4603	}
4604	}
4605	}
4606
4607	# Check for misused memsets
4608	if ($^V && $^V ge 5.10.0 &&
4609	defined $stat &&
4610	$stat =~ /^\+(?:.?)\bmemset\s$\s$FuncArg\s,\s$FuncArg\s\,\s$FuncArg\s$/s) {
4611
4612	my $ms_addr = $2;
4613	my $ms_val = $7;
4614	my $ms_size = $12;
4615
4616	if ($ms_size =~ /^(0x\|)0$/i) {
4617	ERROR("MEMSET",
4618	"memset to 0's uses 0 as the 2nd argument, not the 3rd\n" . "$here\n$stat\n");
4619	} elsif ($ms_size =~ /^(0x\|)1$/i) {
4620	WARN("MEMSET",
4621	"single byte memset is suspicious. Swapped 2nd/3rd argument?\n" . "$here\n$stat\n");
4622	}
4623	}
4624
4625	# Check for memcpy(foo, bar, ETH_ALEN) that could be ether_addr_copy(foo, bar)
4626	if ($^V && $^V ge 5.10.0 &&
4627	$line =~ /^\+(?:.?)\bmemcpy\s$\s$FuncArg\s,\s$FuncArg\s\,\sETH_ALEN\s$/s) {
4628	if (WARN("PREFER_ETHER_ADDR_COPY",
4629	"Prefer ether_addr_copy() over memcpy() if the Ethernet addresses are __aligned(2)\n" . $herecurr) &&
4630	$fix) {
4631	$fixed[$fixlinenr] =~ s/\bmemcpy\s$\s$FuncArg\s,\s$FuncArg\s\,\sETH_ALEN\s*$/ether_addr_copy($2, $7)/;
4632	}
4633	}
4634
4635	# typecasts on min/max could be min_t/max_t
4636	if ($^V && $^V ge 5.10.0 &&
4637	defined $stat &&
4638	$stat =~ /^\+(?:.?)\b(min\|max)\s$\s$FuncArg\s,\s$FuncArg\s$/) {
4639	if (defined $2 \|\| defined $7) {
4640	my $call = $1;
4641	my $cast1 = deparenthesize($2);
4642	my $arg1 = $3;
4643	my $cast2 = deparenthesize($7);
4644	my $arg2 = $8;
4645	my $cast;
4646
4647	if ($cast1 ne "" && $cast2 ne "" && $cast1 ne $cast2) {
4648	$cast = "$cast1 or $cast2";
4649	} elsif ($cast1 ne "") {
4650	$cast = $cast1;
4651	} else {
4652	$cast = $cast2;
4653	}
4654	WARN("MINMAX",
4655	"$call() should probably be ${call}_t($cast, $arg1, $arg2)\n" . "$here\n$stat\n");
4656	}
4657	}
4658
4659	# check usleep_range arguments
4660	if ($^V && $^V ge 5.10.0 &&
4661	defined $stat &&
4662	$stat =~ /^\+(?:.?)\busleep_range\s$\s($FuncArg)\s,\s($FuncArg)\s$/) {
4663	my $min = $1;
4664	my $max = $7;
4665	if ($min eq $max) {
4666	WARN("USLEEP_RANGE",
4667	"usleep_range should not use min == max args; see Documentation/timers/timers-howto.txt\n" . "$here\n$stat\n");
4668	} elsif ($min =~ /^\d+$/ && $max =~ /^\d+$/ &&
4669	$min > $max) {
4670	WARN("USLEEP_RANGE",
4671	"usleep_range args reversed, use min then max; see Documentation/timers/timers-howto.txt\n" . "$here\n$stat\n");
4672	}
4673	}
4674
4675	# check for naked sscanf
4676	if ($^V && $^V ge 5.10.0 &&
4677	defined $stat &&
4678	$line =~ /\bsscanf\b/ &&
4679	($stat !~ /$Ident\s=\ssscanf\s*$balanced_parens/ &&
4680	$stat !~ /\bsscanf\s$balanced_parens\s(?:$Compare)/ &&
4681	$stat !~ /(?:$Compare)\s\bsscanf\s$balanced_parens/)) {
4682	my $lc = $stat =~ tr@\n@@;
4683	$lc = $lc + $linenr;
4684	my $stat_real = raw_line($linenr, 0);
4685	for (my $count = $linenr + 1; $count <= $lc; $count++) {
4686	$stat_real = $stat_real . "\n" . raw_line($count, 0);
4687	}
4688	WARN("NAKED_SSCANF",
4689	"unchecked sscanf return value\n" . "$here\n$stat_real\n");
4690	}
4691
4692	# check for simple sscanf that should be kstrto<foo>
4693	if ($^V && $^V ge 5.10.0 &&
4694	defined $stat &&
4695	$line =~ /\bsscanf\b/) {
4696	my $lc = $stat =~ tr@\n@@;
4697	$lc = $lc + $linenr;
4698	my $stat_real = raw_line($linenr, 0);
4699	for (my $count = $linenr + 1; $count <= $lc; $count++) {
4700	$stat_real = $stat_real . "\n" . raw_line($count, 0);
4701	}
4702	if ($stat_real =~ /\bsscanf\b\s\(\s$FuncArg\s,\s("[^"]+")/) {
4703	my $format = $6;
4704	my $count = $format =~ tr@%@%@;
4705	if ($count == 1 &&
4706	$format =~ /^"\%(?i:ll[udxi]\|[udxi]ll\|ll\|[hl]h?[udxi]\|[udxi][hl]h?\|[hl]h?\|[udxi])"$/) {
4707	WARN("SSCANF_TO_KSTRTO",
4708	"Prefer kstrto<type> to single variable sscanf\n" . "$here\n$stat_real\n");
4709	}
4710	}
4711	}
4712
4713	# check for new externs in .h files.
4714	if ($realfile =~ /\.h$/ &&
4715	$line =~ /^\+\s(extern\s+)$Type\s$Ident\s*\(/s) {
4716	if (CHK("AVOID_EXTERNS",
4717	"extern prototypes should be avoided in .h files\n" . $herecurr) &&
4718	$fix) {
4719	$fixed[$fixlinenr] =~ s/(.)\bextern\b\s(.*)/$1$2/;
4720	}
4721	}
4722
4723	# check for new externs in .c files.
4724	if ($realfile =~ /\.c$/ && defined $stat &&
4725	$stat =~ /^.\s(?:extern\s+)?$Type\s+($Ident)(\s)\(/s)
4726	{
4727	my $function_name = $1;
4728	my $paren_space = $2;
4729
4730	my $s = $stat;
4731	if (defined $cond) {
4732	substr($s, 0, length($cond), '');
4733	}
4734	if ($s =~ /^\s*;/ &&
4735	$function_name ne 'uninitialized_var')
4736	{
4737	WARN("AVOID_EXTERNS",
4738	"externs should be avoided in .c files\n" . $herecurr);
4739	}
4740
4741	if ($paren_space =~ /\n/) {
4742	WARN("FUNCTION_ARGUMENTS",
4743	"arguments for function declarations should follow identifier\n" . $herecurr);
4744	}
4745
4746	} elsif ($realfile =~ /\.c$/ && defined $stat &&
4747	$stat =~ /^.\s*extern\s+/)
4748	{
4749	WARN("AVOID_EXTERNS",
4750	"externs should be avoided in .c files\n" . $herecurr);
4751	}
4752
4753	# checks for new __setup's
4754	if ($rawline =~ /\b__setup\("([^"]*)"/) {
4755	my $name = $1;
4756
4757	if (!grep(/$name/, @setup_docs)) {
4758	CHK("UNDOCUMENTED_SETUP",
4759	"__setup appears un-documented -- check Documentation/kernel-parameters.txt\n" . $herecurr);
4760	}
4761	}
4762
4763	# check for pointless casting of kmalloc return
4764	if ($line =~ /\\s\)\s*[kv][czm]alloc(_node){0,1}\b/) {
4765	WARN("UNNECESSARY_CASTS",
4766	"unnecessary cast may hide bugs, see http://c-faq.com/malloc/mallocnocast.html\n" . $herecurr);
4767	}
4768
4769	# alloc style
4770	# p = alloc(sizeof(struct foo), ...) should be p = alloc(sizeof(*p), ...)
4771	if ($^V && $^V ge 5.10.0 &&
4772	$line =~ /\b($Lval)\s\=\s(?:$balanced_parens)?\s([kv][mz]alloc(?:_node)?)\s$\s(sizeof\s\(\sstruct\s+$Lval\s$)/) {
4773	CHK("ALLOC_SIZEOF_STRUCT",
4774	"Prefer $3(sizeof(*$1)...) over $3($4...)\n" . $herecurr);
4775	}
4776
4777	# check for k[mz]alloc with multiplies that could be kmalloc_array/kcalloc
4778	if ($^V && $^V ge 5.10.0 &&
4779	$line =~ /\b($Lval)\s\=\s(?:$balanced_parens)?\s(k[mz]alloc)\s\(\s($FuncArg)\s\\s($FuncArg)\s*,/) {
4780	my $oldfunc = $3;
4781	my $a1 = $4;
4782	my $a2 = $10;
4783	my $newfunc = "kmalloc_array";
4784	$newfunc = "kcalloc" if ($oldfunc eq "kzalloc");
4785	my $r1 = $a1;
4786	my $r2 = $a2;
4787	if ($a1 =~ /^sizeof\s*\S/) {
4788	$r1 = $a2;
4789	$r2 = $a1;
4790	}
4791	if ($r1 !~ /^sizeof\b/ && $r2 =~ /^sizeof\s*\S/ &&
4792	!($r1 =~ /^$Constant$/ \|\| $r1 =~ /^[A-Z_][A-Z0-9_]*$/)) {
4793	if (WARN("ALLOC_WITH_MULTIPLY",
4794	"Prefer $newfunc over $oldfunc with multiply\n" . $herecurr) &&
4795	$fix) {
4796	$fixed[$fixlinenr] =~ s/\b($Lval)\s\=\s(?:$balanced_parens)?\s(k[mz]alloc)\s\(\s($FuncArg)\s\\s($FuncArg)/$1 . ' = ' . "$newfunc(" . trim($r1) . ', ' . trim($r2)/e;
4797
4798	}
4799	}
4800	}
4801
4802	# check for krealloc arg reuse
4803	if ($^V && $^V ge 5.10.0 &&
4804	$line =~ /\b($Lval)\s\=\s(?:$balanced_parens)?\skrealloc\s\(\s\1\s,/) {
4805	WARN("KREALLOC_ARG_REUSE",
4806	"Reusing the krealloc arg is almost always a bug\n" . $herecurr);
4807	}
4808
4809	# check for alloc argument mismatch
4810	if ($line =~ /\b(kcalloc\|kmalloc_array)\s\(\ssizeof\b/) {
4811	WARN("ALLOC_ARRAY_ARGS",
4812	"$1 uses number as first arg, sizeof is generally wrong\n" . $herecurr);
4813	}
4814
4815	# check for multiple semicolons
4816	if ($line =~ /;\s;\s$/) {
4817	if (WARN("ONE_SEMICOLON",
4818	"Statements terminations use 1 semicolon\n" . $herecurr) &&
4819	$fix) {
4820	$fixed[$fixlinenr] =~ s/(\s;\s){2,}$/;/g;
4821	}
4822	}
4823
4824	# check for case / default statements not preceded by break/fallthrough/switch
4825	if ($line =~ /^.\s(?:case\s+(?:$Ident\|$Constant)\s\|default):/) {
4826	my $has_break = 0;
4827	my $has_statement = 0;
4828	my $count = 0;
4829	my $prevline = $linenr;
4830	while ($prevline > 1 && ($file \|\| $count < 3) && !$has_break) {
4831	$prevline--;
4832	my $rline = $rawlines[$prevline - 1];
4833	my $fline = $lines[$prevline - 1];
4834	last if ($fline =~ /^\@\@/);
4835	next if ($fline =~ /^\-/);
4836	next if ($fline =~ /^.(?:\s(?:case\s+(?:$Ident\|$Constant)[\s$;]\|default):[\s$;])$/);
4837	$has_break = 1 if ($rline =~ /fall[\s_-]*(through\|thru)/i);
4838	next if ($fline =~ /^.[\s$;]*$/);
4839	$has_statement = 1;
4840	$count++;
4841	$has_break = 1 if ($fline =~ /\bswitch\b\|\b(?:break\s;[\s$;]$\|return\b\|goto\b\|continue\b)/);
4842	}
4843	if (!$has_break && $has_statement) {
4844	WARN("MISSING_BREAK",
4845	"Possible switch case/default not preceeded by break or fallthrough comment\n" . $herecurr);
4846	}
4847	}
4848
4849	# check for switch/default statements without a break;
4850	if ($^V && $^V ge 5.10.0 &&
4851	defined $stat &&
4852	$stat =~ /^\+[$;\s](?:case[$;\s]+\w+[$;\s]:[$;\s]\|)[$;\s]\bdefault[$;\s]:[$;\s]*;/g) {
4853	my $ctx = '';
4854	my $herectx = $here . "\n";
4855	my $cnt = statement_rawlines($stat);
4856	for (my $n = 0; $n < $cnt; $n++) {
4857	$herectx .= raw_line($linenr, $n) . "\n";
4858	}
4859	WARN("DEFAULT_NO_BREAK",
4860	"switch default: should use break\n" . $herectx);
4861	}
4862
4863	# check for gcc specific __FUNCTION__
4864	if ($line =~ /\b__FUNCTION__\b/) {
4865	if (WARN("USE_FUNC",
4866	"__func__ should be used instead of gcc specific __FUNCTION__\n" . $herecurr) &&
4867	$fix) {
4868	$fixed[$fixlinenr] =~ s/\b__FUNCTION__\b/__func__/g;
4869	}
4870	}
4871
4872	# check for use of yield()
4873	if ($line =~ /\byield\s$\s$/) {
4874	WARN("YIELD",
4875	"Using yield() is generally wrong. See yield() kernel-doc (sched/core.c)\n" . $herecurr);
4876	}
4877
4878	# check for comparisons against true and false
4879	if ($line =~ /\+\s(.?)\b(true\|false\|$Lval)\s(==\|\!=)\s(true\|false\|$Lval)\b(.*)$/i) {
4880	my $lead = $1;
4881	my $arg = $2;
4882	my $test = $3;
4883	my $otype = $4;
4884	my $trail = $5;
4885	my $op = "!";
4886
4887	($arg, $otype) = ($otype, $arg) if ($arg =~ /^(?:true\|false)$/i);
4888
4889	my $type = lc($otype);
4890	if ($type =~ /^(?:true\|false)$/) {
4891	if (("$test" eq "==" && "$type" eq "true") \|\|
4892	("$test" eq "!=" && "$type" eq "false")) {
4893	$op = "";
4894	}
4895
4896	CHK("BOOL_COMPARISON",
4897	"Using comparison to $otype is error prone\n" . $herecurr);
4898
4899	## maybe suggesting a correct construct would better
4900	## "Using comparison to $otype is error prone. Perhaps use '${lead}${op}${arg}${trail}'\n" . $herecurr);
4901
4902	}
4903	}
4904
4905	# check for semaphores initialized locked
4906	if ($line =~ /^.\s*sema_init.+,\W?0\W?\)/) {
4907	WARN("CONSIDER_COMPLETION",
4908	"consider using a completion\n" . $herecurr);
4909	}
4910
4911	# recommend kstrto* over simple_strto* and strict_strto*
4912	if ($line =~ /\b((simple\|strict)_(strto(l\|ll\|ul\|ull)))\s*\(/) {
4913	WARN("CONSIDER_KSTRTO",
4914	"$1 is obsolete, use k$3 instead\n" . $herecurr);
4915	}
4916
4917	# check for __initcall(), use device_initcall() explicitly or more appropriate function please
4918	if ($line =~ /^.\s__initcall\s\(/) {
4919	WARN("USE_DEVICE_INITCALL",
4920	"please use device_initcall() or more appropriate function instead of __initcall() (see include/linux/init.h)\n" . $herecurr);
4921	}
4922
4923	# check for various ops structs, ensure they are const.
4924	my $struct_ops = qr{acpi_dock_ops\|
4925	address_space_operations\|
4926	backlight_ops\|
4927	block_device_operations\|
4928	dentry_operations\|
4929	dev_pm_ops\|
4930	dma_map_ops\|
4931	extent_io_ops\|
4932	file_lock_operations\|
4933	file_operations\|
4934	hv_ops\|
4935	ide_dma_ops\|
4936	intel_dvo_dev_ops\|
4937	item_operations\|
4938	iwl_ops\|
4939	kgdb_arch\|
4940	kgdb_io\|
4941	kset_uevent_ops\|
4942	lock_manager_operations\|
4943	microcode_ops\|
4944	mtrr_ops\|
4945	neigh_ops\|
4946	nlmsvc_binding\|
4947	pci_raw_ops\|
4948	pipe_buf_operations\|
4949	platform_hibernation_ops\|
4950	platform_suspend_ops\|
4951	proto_ops\|
4952	rpc_pipe_ops\|
4953	seq_operations\|
4954	snd_ac97_build_ops\|
4955	soc_pcmcia_socket_ops\|
4956	stacktrace_ops\|
4957	sysfs_ops\|
4958	tty_operations\|
4959	usb_mon_operations\|
4960	wd_ops}x;
4961	if ($line !~ /\bconst\b/ &&
4962	$line =~ /\bstruct\s+($struct_ops)\b/) {
4963	WARN("CONST_STRUCT",
4964	"struct $1 should normally be const\n" .
4965	$herecurr);
4966	}
4967
4968	# use of NR_CPUS is usually wrong
4969	# ignore definitions of NR_CPUS and usage to define arrays as likely right
4970	if ($line =~ /\bNR_CPUS\b/ &&
4971	$line !~ /^.\s\s#\sif\b.\bNR_CPUS\b/ &&
4972	$line !~ /^.\s\s#\sdefine\b.\bNR_CPUS\b/ &&
4973	$line !~ /^.\s$Declare\s.\[[^\]]NR_CPUS[^\]]\]/ &&
4974	$line !~ /\[[^\]]\.\.\.[^\]]NR_CPUS[^\]]*\]/ &&
4975	$line !~ /\[[^\]]NR_CPUS[^\]]\.\.\.[^\]]*\]/)
4976	{
4977	WARN("NR_CPUS",
4978	"usage of NR_CPUS is often wrong - consider using cpu_possible(), num_possible_cpus(), for_each_possible_cpu(), etc\n" . $herecurr);
4979	}
4980
4981	# Use of __ARCH_HAS_<FOO> or ARCH_HAVE_<BAR> is wrong.
4982	if ($line =~ /\+\s#\sdefine\s+((?:__)?ARCH_(?:HAS\|HAVE)\w*)\b/) {
4983	ERROR("DEFINE_ARCH_HAS",
4984	"#define of '$1' is wrong - use Kconfig variables or standard guards instead\n" . $herecurr);
4985	}
4986
4987	# check for %L{u,d,i} in strings
4988	my $string;
4989	while ($line =~ /(?:^\|")([X\t]*)(?:"\|$)/g) {
4990	$string = substr($rawline, $-[1], $+[1] - $-[1]);
4991	$string =~ s/%%/__/g;
4992	if ($string =~ /(?<!%)%L[udi]/) {
4993	WARN("PRINTF_L",
4994	"\%Ld/%Lu are not-standard C, use %lld/%llu\n" . $herecurr);
4995	last;
4996	}
4997	}
4998
4999	# whine mightly about in_atomic
5000	if ($line =~ /\bin_atomic\s*\(/) {
5001	if ($realfile =~ m@^drivers/@) {
5002	ERROR("IN_ATOMIC",
5003	"do not use in_atomic in drivers\n" . $herecurr);
5004	} elsif ($realfile !~ m@^kernel/@) {
5005	WARN("IN_ATOMIC",
5006	"use of in_atomic() is incorrect outside core kernel code\n" . $herecurr);
5007	}
5008	}
5009
5010	# check for lockdep_set_novalidate_class
5011	if ($line =~ /^.\slockdep_set_novalidate_class\s\(/ \|\|
5012	$line =~ /__lockdep_no_validate__\s*\)/ ) {
5013	if ($realfile !~ m@^kernel/lockdep@ &&
5014	$realfile !~ m@^include/linux/lockdep@ &&
5015	$realfile !~ m@^drivers/base/core@) {
5016	ERROR("LOCKDEP",
5017	"lockdep_no_validate class is reserved for device->mutex.\n" . $herecurr);
5018	}
5019	}
5020
5021	if ($line =~ /debugfs_create_file.*S_IWUGO/ \|\|
5022	$line =~ /DEVICE_ATTR.*S_IWUGO/ ) {
5023	WARN("EXPORTED_WORLD_WRITABLE",
5024	"Exporting world writable files is usually an error. Consider more restrictive permissions.\n" . $herecurr);
5025	}
5026
5027	# Mode permission misuses where it seems decimal should be octal
5028	# This uses a shortcut match to avoid unnecessary uses of a slow foreach loop
5029	if ($^V && $^V ge 5.10.0 &&
5030	$line =~ /$mode_perms_search/) {
5031	foreach my $entry (@mode_permission_funcs) {
5032	my $func = $entry->[0];
5033	my $arg_pos = $entry->[1];
5034
5035	my $skip_args = "";
5036	if ($arg_pos > 1) {
5037	$arg_pos--;
5038	$skip_args = "(?:\\s$FuncArg\\s,\\s*){$arg_pos,$arg_pos}";
5039	}
5040	my $test = "\\b$func\\s\$${skip_args}([\\d]+)\\s[,\$]";
5041	if ($line =~ /$test/) {
5042	my $val = $1;
5043	$val = $6 if ($skip_args ne "");
5044
5045	if ($val !~ /^0$/ &&
5046	(($val =~ /^$Int$/ && $val !~ /^$Octal$/) \|\|
5047	length($val) ne 4)) {
5048	ERROR("NON_OCTAL_PERMISSIONS",
5049	"Use 4 digit octal (0777) not decimal permissions\n" . $herecurr);
5050	}
5051	}
5052	}
5053	}
5054	}
5055
5056	# If we have no input at all, then there is nothing to report on
5057	# so just keep quiet.
5058	if ($#rawlines == -1) {
5059	exit(0);
5060	}
5061
5062	# In mailback mode only produce a report in the negative, for
5063	# things that appear to be patches.
5064	if ($mailback && ($clean == 1 \|\| !$is_patch)) {
5065	exit(0);
5066	}
5067
5068	# This is not a patch, and we are are in 'no-patch' mode so
5069	# just keep quiet.
5070	if (!$chk_patch && !$is_patch) {
5071	exit(0);
5072	}
5073
5074	if (!$is_patch) {
5075	ERROR("NOT_UNIFIED_DIFF",
5076	"Does not appear to be a unified-diff format patch\n");
5077	}
5078	if ($is_patch && $chk_signoff && $signoff == 0) {
5079	ERROR("MISSING_SIGN_OFF",
5080	"Missing Signed-off-by: line(s)\n");
5081	}
5082
5083	print report_dump();
5084	if ($summary && !($clean == 1 && $quiet == 1)) {
5085	print "$filename " if ($summary_file);
5086	print "total: $cnt_error errors, $cnt_warn warnings, " .
5087	(($check)? "$cnt_chk checks, " : "") .
5088	"$cnt_lines lines checked\n";
5089	print "\n" if ($quiet == 0);
5090	}
5091
5092	if ($quiet == 0) {
5093
5094	if ($^V lt 5.10.0) {
5095	print("NOTE: perl $^V is not modern enough to detect all possible issues.\n");
5096	print("An upgrade to at least perl v5.10.0 is suggested.\n\n");
5097	}
5098
5099	# If there were whitespace errors which cleanpatch can fix
5100	# then suggest that.
5101	if ($rpt_cleaners) {
5102	print "NOTE: whitespace errors detected, you may wish to use scripts/cleanpatch or\n";
5103	print " scripts/cleanfile\n\n";
5104	$rpt_cleaners = 0;
5105	}
5106	}
5107
5108	hash_show_words(\%use_type, "Used");
5109	hash_show_words(\%ignore_type, "Ignored");
5110
5111	if ($clean == 0 && $fix &&
5112	("@rawlines" ne "@fixed" \|\|
5113	$#fixed_inserted >= 0 \|\| $#fixed_deleted >= 0)) {
5114	my $newfile = $filename;
5115	$newfile .= ".EXPERIMENTAL-checkpatch-fixes" if (!$fix_inplace);
5116	my $linecount = 0;
5117	my $f;
5118
5119	@fixed = fix_inserted_deleted_lines(\@fixed, \@fixed_inserted, \@fixed_deleted);
5120
5121	open($f, '>', $newfile)
5122	or die "$P: Can't open $newfile for write\n";
5123	foreach my $fixed_line (@fixed) {
5124	$linecount++;
5125	if ($file) {
5126	if ($linecount > 3) {
5127	$fixed_line =~ s/^\+//;
5128	print $f $fixed_line . "\n";
5129	}
5130	} else {
5131	print $f $fixed_line . "\n";
5132	}
5133	}
5134	close($f);
5135
5136	if (!$quiet) {
5137	print << "EOM";
5138	Wrote EXPERIMENTAL --fix correction(s) to '$newfile'
5139
5140	Do _NOT_ trust the results written to this file.
5141	Do _NOT_ submit these changes without inspecting them for correctness.
5142
5143	This EXPERIMENTAL file is simply a convenience to help rewrite patches.
5144	No warranties, expressed or implied...
5145
5146	EOM
5147	}
5148	}
5149
5150	if ($clean == 1 && $quiet == 0) {
5151	print "$vname has no obvious style problems and is ready for submission.\n"
5152	}
5153	if ($clean == 0 && $quiet == 0) {
5154	print << "EOM";
5155	$vname has style problems, please review.
5156
5157	If any of these errors are false positives, please report
5158	them to the maintainer, see CHECKPATCH in MAINTAINERS.
5159	EOM
5160	}
5161
5162	return $clean;
5163	}