xref: /openbmc/u-boot/scripts/checkpatch.pl (revision 971a54193c9a90a6651064c4a7879e3568e9e7b8)
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 
8 use strict;
9 use warnings;
10 use POSIX;
11 use File::Basename;
12 use Cwd 'abs_path';
13 use Term::ANSIColor qw(:constants);
14 
15 my $P = $0;
16 my $D = dirname(abs_path($P));
17 
18 my $V = '0.32';
19 
20 use Getopt::Long qw(:config no_auto_abbrev);
21 
22 my $quiet = 0;
23 my $tree = 1;
24 my $chk_signoff = 1;
25 my $chk_patch = 1;
26 my $tst_only;
27 my $emacs = 0;
28 my $terse = 0;
29 my $showfile = 0;
30 my $file = 0;
31 my $git = 0;
32 my %git_commits = ();
33 my $check = 0;
34 my $check_orig = 0;
35 my $summary = 1;
36 my $mailback = 0;
37 my $summary_file = 0;
38 my $show_types = 0;
39 my $list_types = 0;
40 my $fix = 0;
41 my $fix_inplace = 0;
42 my $root;
43 my %debug;
44 my %camelcase = ();
45 my %use_type = ();
46 my @use = ();
47 my %ignore_type = ();
48 my @ignore = ();
49 my $help = 0;
50 my $configuration_file = ".checkpatch.conf";
51 my $max_line_length = 80;
52 my $ignore_perl_version = 0;
53 my $minimum_perl_version = 5.10.0;
54 my $min_conf_desc_length = 4;
55 my $spelling_file = "$D/spelling.txt";
56 my $codespell = 0;
57 my $codespellfile = "/usr/share/codespell/dictionary.txt";
58 my $conststructsfile = "$D/const_structs.checkpatch";
59 my $typedefsfile = "";
60 my $color = "auto";
61 my $allow_c99_comments = 1;
62 
63 sub help {
64 	my ($exitcode) = @_;
65 
66 	print << "EOM";
67 Usage: $P [OPTION]... [FILE]...
68 Version: $V
69 
70 Options:
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 
123 When FILE is - read standard input.
124 EOM
125 
126 	exit($exitcode);
127 }
128 
129 sub uniq {
130 	my %seen;
131 	return grep { !$seen{$_}++ } @_;
132 }
133 
134 sub 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 
160 my $conf = which_conf($configuration_file);
161 if (-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
188 foreach (@ARGV) {
189 	if ($_ eq "--color" || $_ eq "-color") {
190 		$_ = "--color=$color";
191 	}
192 }
193 
194 GetOptions(
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 
231 help(0) if ($help);
232 
233 list_types(0) if ($list_types);
234 
235 $fix = 1 if ($fix_inplace);
236 $check_orig = $check;
237 
238 my $exit = 0;
239 
240 if ($^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
248 if ($#ARGV < 0) {
249 	push(@ARGV, '-');
250 }
251 
252 if ($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 
264 sub 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 
281 sub 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 
293 hash_save_array_words(\%ignore_type, \@ignore);
294 hash_save_array_words(\%use_type, \@use);
295 
296 my $dbg_values = 0;
297 my $dbg_possible = 0;
298 my $dbg_type = 0;
299 my $dbg_attr = 0;
300 for my $key (keys %debug) {
301 	## no critic
302 	eval "\${dbg_$key} = '$debug{$key}';";
303 	die "$@" if ($@);
304 }
305 
306 my $rpt_cleaners = 0;
307 
308 if ($terse) {
309 	$emacs = 1;
310 	$quiet++;
311 }
312 
313 if ($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 
333 my $emitted_corrupt = 0;
334 
335 our $Ident	= qr{
336 			[A-Za-z_][A-Za-z\d_]*
337 			(?:\s*\#\#\s*[A-Za-z_][A-Za-z\d_]*)*
338 		}x;
339 our $Storage	= qr{extern|static|asmlinkage};
340 our $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;
352 our $InitAttributePrefix = qr{__(?:mem|cpu|dev|net_|)};
353 our $InitAttributeData = qr{$InitAttributePrefix(?:initdata\b)};
354 our $InitAttributeConst = qr{$InitAttributePrefix(?:initconst\b)};
355 our $InitAttributeInit = qr{$InitAttributePrefix(?:init\b)};
356 our $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
360 our $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;
385 our $Modifier;
386 our $Inline	= qr{inline|__always_inline|noinline|__inline|__inline__};
387 our $Member	= qr{->$Ident|\.$Ident|\[[^]]*\]};
388 our $Lval	= qr{$Ident(?:$Member)*};
389 
390 our $Int_type	= qr{(?i)llu|ull|ll|lu|ul|l|u};
391 our $Binary	= qr{(?i)0b[01]+$Int_type?};
392 our $Hex	= qr{(?i)0x[0-9a-f]+$Int_type?};
393 our $Int	= qr{[0-9]+$Int_type?};
394 our $Octal	= qr{0[0-7]+$Int_type?};
395 our $String	= qr{(?:\bL)?"[X\t]*"};
396 our $Float_hex	= qr{(?i)0x[0-9a-f]+p-?[0-9]+[fl]?};
397 our $Float_dec	= qr{(?i)(?:[0-9]+\.[0-9]*|[0-9]*\.[0-9]+)(?:e-?[0-9]+)?[fl]?};
398 our $Float_int	= qr{(?i)[0-9]+e-?[0-9]+[fl]?};
399 our $Float	= qr{$Float_hex|$Float_dec|$Float_int};
400 our $Constant	= qr{$Float|$Binary|$Octal|$Hex|$Int};
401 our $Assignment	= qr{\*\=|/=|%=|\+=|-=|<<=|>>=|&=|\^=|\|=|=};
402 our $Compare    = qr{<=|>=|==|!=|<|(?<!-)>};
403 our $Arithmetic = qr{\+|-|\*|\/|%};
404 our $Operators	= qr{
405 			<=|>=|==|!=|
406 			=>|->|<<|>>|<|>|!|~|
407 			&&|\|\||,|\^|\+\+|--|&|\||$Arithmetic
408 		  }x;
409 
410 our $c90_Keywords = qr{do|for|while|if|else|return|goto|continue|switch|default|case|break}x;
411 
412 our $BasicType;
413 our $NonptrType;
414 our $NonptrTypeMisordered;
415 our $NonptrTypeWithAttr;
416 our $Type;
417 our $TypeMisordered;
418 our $Declare;
419 our $DeclareMisordered;
420 
421 our $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 
431 our $UTF8	= qr{
432 	[\x09\x0A\x0D\x20-\x7E]              # ASCII
433 	| $NON_ASCII_UTF8
434 }x;
435 
436 our $typeC99Typedefs = qr{(?:__)?(?:[us]_?)?int_?(?:8|16|32|64)_t};
437 our $typeOtherOSTypedefs = qr{(?x:
438 	u_(?:char|short|int|long) |          # bsd
439 	u(?:nchar|short|int|long)            # sysv
440 )};
441 our $typeKernelTypedefs = qr{(?x:
442 	(?:__)?(?:u|s|be|le)(?:8|16|32|64)|
443 	atomic_t
444 )};
445 our $typeTypedefs = qr{(?x:
446 	$typeC99Typedefs\b|
447 	$typeOtherOSTypedefs\b|
448 	$typeKernelTypedefs\b
449 )};
450 
451 our $zero_initializer = qr{(?:(?:0[xX])?0+$Int_type?|NULL|false)\b};
452 
453 our $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 
462 our $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 
473 our @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 
492 our @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 
515 our $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 
536 our @typeListFile = ();
537 our @typeListWithAttr = (
538 	@typeList,
539 	qr{struct\s+$InitAttribute\s+$Ident},
540 	qr{union\s+$InitAttribute\s+$Ident},
541 );
542 
543 our @modifierList = (
544 	qr{fastcall},
545 );
546 our @modifierListFile = ();
547 
548 our @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
562 our $mode_perms_search = "";
563 foreach my $entry (@mode_permission_funcs) {
564 	$mode_perms_search .= '|' if ($mode_perms_search ne "");
565 	$mode_perms_search .= $entry->[0];
566 }
567 
568 our $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 
576 our %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
596 our $mode_perms_string_search = "";
597 foreach 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 
602 our $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.
611 my $misspellings;
612 my %spelling_fix;
613 
614 if (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 
633 if ($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 
659 sub 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 
686 my $const_structs = "";
687 read_words(\$const_structs, $conststructsfile)
688     or warn "No structs that should be const will be found - file '$conststructsfile': $!\n";
689 
690 my $typeOtherTypedefs = "";
691 if (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 
697 sub 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 }
745 build_types();
746 
747 our $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 
753 our $balanced_parens = qr/(\((?:[^\(\)]++|(?-1))*\))/;
754 our $LvalOrFunc	= qr{((?:[\&\*]\s*)?$Lval)\s*($balanced_parens{0,1})\s*};
755 our $FuncArg = qr{$Typecast{0,1}($LvalOrFunc|$Constant|$String)};
756 
757 our $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 
763 sub 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 
777 sub 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 
803 sub 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 
813 my $camelcase_seeded = 0;
814 sub 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 
871 sub 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 
904 my @rawlines = ();
905 my @lines = ();
906 my @fixed = ();
907 my @fixed_inserted = ();
908 my @fixed_deleted = ();
909 my $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'.
913 die "$P: No git repository found\n" if ($git && !-e ".git");
914 
915 if ($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 
940 my $vname;
941 for 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 
988 if (!$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 
995 NOTE: perl $^V is not modern enough to detect all possible issues.
996       An upgrade to at least perl v5.10.0 is suggested.
997 EOM
998 	}
999 	if ($exit) {
1000 		print << "EOM"
1001 
1002 NOTE: If any of the errors are false positives, please report
1003       them to the maintainer, see CHECKPATCH in MAINTAINERS.
1004 EOM
1005 	}
1006 }
1007 
1008 exit($exit);
1009 
1010 sub 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 
1027 sub 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 
1074 sub 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 
1097 sub 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 
1109 sub 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 
1121 sub 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 }
1141 sub copy_spacing {
1142 	(my $res = shift) =~ tr/\t/ /c;
1143 	return $res;
1144 }
1145 
1146 sub 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 
1159 my $sanitise_quote = '';
1160 
1161 sub sanitise_line_reset {
1162 	my ($in_comment) = @_;
1163 
1164 	if ($in_comment) {
1165 		$sanitise_quote = '*/';
1166 	} else {
1167 		$sanitise_quote = '';
1168 	}
1169 }
1170 sub 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 
1263 sub get_quoted_string {
1264 	my ($line, $rawline) = @_;
1265 
1266 	return "" if ($line !~ m/($String)/g);
1267 	return substr($rawline, $-[0], $+[0] - $-[0]);
1268 }
1269 
1270 sub 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 
1404 sub 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 
1417 sub statement_rawlines {
1418 	my ($stmt) = @_;
1419 
1420 	my @stmt_lines = ($stmt =~ /\n/g);
1421 
1422 	return $#stmt_lines + 2;
1423 }
1424 
1425 sub 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 
1447 sub 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 
1476 sub 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 }
1526 sub ctx_block_outer {
1527 	my ($linenr, $remain) = @_;
1528 
1529 	my ($level, @r) = ctx_block_get($linenr, $remain, 1, '{', '}', 0);
1530 	return @r;
1531 }
1532 sub ctx_block {
1533 	my ($linenr, $remain) = @_;
1534 
1535 	my ($level, @r) = ctx_block_get($linenr, $remain, 0, '{', '}', 0);
1536 	return @r;
1537 }
1538 sub ctx_statement {
1539 	my ($linenr, $remain, $off) = @_;
1540 
1541 	my ($level, @r) = ctx_block_get($linenr, $remain, 0, '(', ')', $off);
1542 	return @r;
1543 }
1544 sub ctx_block_level {
1545 	my ($linenr, $remain) = @_;
1546 
1547 	return ctx_block_get($linenr, $remain, 0, '{', '}', 0);
1548 }
1549 sub ctx_statement_level {
1550 	my ($linenr, $remain, $off) = @_;
1551 
1552 	return ctx_block_get($linenr, $remain, 0, '(', ')', $off);
1553 }
1554 
1555 sub 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 }
1587 sub 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 
1597 sub 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 
1613 sub 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 
1630 my $av_preprocessor = 0;
1631 my $av_pending;
1632 my @av_paren_type;
1633 my $av_pend_colon;
1634 
1635 sub annotate_reset {
1636 	$av_preprocessor = 0;
1637 	$av_pending = '_';
1638 	@av_paren_type = ('E');
1639 	$av_pend_colon = 'O';
1640 }
1641 
1642 sub 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 
1842 sub 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 
1889 my $prefix = '';
1890 
1891 sub 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 
1901 sub 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 
1938 sub report_dump {
1939 	our @report;
1940 }
1941 
1942 sub 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 
1954 sub 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 
2005 sub 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 
2015 sub 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 
2026 sub 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 }
2036 sub 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 }
2046 sub 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 
2057 sub 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 
2085 sub trim {
2086 	my ($string) = @_;
2087 
2088 	$string =~ s/^\s+|\s+$//g;
2089 
2090 	return $string;
2091 }
2092 
2093 sub ltrim {
2094 	my ($string) = @_;
2095 
2096 	$string =~ s/^\s+//;
2097 
2098 	return $string;
2099 }
2100 
2101 sub rtrim {
2102 	my ($string) = @_;
2103 
2104 	$string =~ s/\s+$//;
2105 
2106 	return $string;
2107 }
2108 
2109 sub string_find_replace {
2110 	my ($string, $find, $replace) = @_;
2111 
2112 	$string =~ s/$find/$replace/g;
2113 
2114 	return $string;
2115 }
2116 
2117 sub 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 
2132 sub 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 
2162 sub 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 
6398 NOTE: For some of the reported defects, checkpatch may be able to
6399       mechanically convert to the typical style using --fix or --fix-inplace.
6400 EOM
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 
6408 NOTE: Whitespace errors detected.
6409       You may wish to use scripts/cleanpatch or scripts/cleanfile
6410 EOM
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 
6442 Wrote EXPERIMENTAL --fix correction(s) to '$newfile'
6443 
6444 Do _NOT_ trust the results written to this file.
6445 Do _NOT_ submit these changes without inspecting them for correctness.
6446 
6447 This EXPERIMENTAL file is simply a convenience to help rewrite patches.
6448 No warranties, expressed or implied...
6449 EOM
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