linux - scripts/checkpatch.pl

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