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