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