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