linux - scripts/checkpatch.pl

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