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