xref: /openbmc/linux/scripts/checkpatch.pl (revision 206a81c1)
1#!/usr/bin/perl -w
2# (c) 2001, Dave Jones. (the file handling bit)
3# (c) 2005, Joel Schopp <jschopp@austin.ibm.com> (the ugly bit)
4# (c) 2007,2008, Andy Whitcroft <apw@uk.ibm.com> (new conditions, test suite)
5# (c) 2008-2010 Andy Whitcroft <apw@canonical.com>
6# Licensed under the terms of the GNU GPL License version 2
7
8use strict;
9use POSIX;
10
11my $P = $0;
12$P =~ s@.*/@@g;
13
14my $V = '0.32';
15
16use Getopt::Long qw(:config no_auto_abbrev);
17
18my $quiet = 0;
19my $tree = 1;
20my $chk_signoff = 1;
21my $chk_patch = 1;
22my $tst_only;
23my $emacs = 0;
24my $terse = 0;
25my $file = 0;
26my $check = 0;
27my $check_orig = 0;
28my $summary = 1;
29my $mailback = 0;
30my $summary_file = 0;
31my $show_types = 0;
32my $fix = 0;
33my $fix_inplace = 0;
34my $root;
35my %debug;
36my %camelcase = ();
37my %use_type = ();
38my @use = ();
39my %ignore_type = ();
40my @ignore = ();
41my $help = 0;
42my $configuration_file = ".checkpatch.conf";
43my $max_line_length = 80;
44my $ignore_perl_version = 0;
45my $minimum_perl_version = 5.10.0;
46
47sub help {
48	my ($exitcode) = @_;
49
50	print << "EOM";
51Usage: $P [OPTION]... [FILE]...
52Version: $V
53
54Options:
55  -q, --quiet                quiet
56  --no-tree                  run without a kernel tree
57  --no-signoff               do not check for 'Signed-off-by' line
58  --patch                    treat FILE as patchfile (default)
59  --emacs                    emacs compile window format
60  --terse                    one line per report
61  -f, --file                 treat FILE as regular source file
62  --subjective, --strict     enable more subjective tests
63  --types TYPE(,TYPE2...)    show only these comma separated message types
64  --ignore TYPE(,TYPE2...)   ignore various comma separated message types
65  --max-line-length=n        set the maximum line length, if exceeded, warn
66  --show-types               show the message "types" in the output
67  --root=PATH                PATH to the kernel tree root
68  --no-summary               suppress the per-file summary
69  --mailback                 only produce a report in case of warnings/errors
70  --summary-file             include the filename in summary
71  --debug KEY=[0|1]          turn on/off debugging of KEY, where KEY is one of
72                             'values', 'possible', 'type', and 'attr' (default
73                             is all off)
74  --test-only=WORD           report only warnings/errors containing WORD
75                             literally
76  --fix                      EXPERIMENTAL - may create horrible results
77                             If correctable single-line errors exist, create
78                             "<inputfile>.EXPERIMENTAL-checkpatch-fixes"
79                             with potential errors corrected to the preferred
80                             checkpatch style
81  --fix-inplace              EXPERIMENTAL - may create horrible results
82                             Is the same as --fix, but overwrites the input
83                             file.  It's your fault if there's no backup or git
84  --ignore-perl-version      override checking of perl version.  expect
85                             runtime errors.
86  -h, --help, --version      display this help and exit
87
88When FILE is - read standard input.
89EOM
90
91	exit($exitcode);
92}
93
94my $conf = which_conf($configuration_file);
95if (-f $conf) {
96	my @conf_args;
97	open(my $conffile, '<', "$conf")
98	    or warn "$P: Can't find a readable $configuration_file file $!\n";
99
100	while (<$conffile>) {
101		my $line = $_;
102
103		$line =~ s/\s*\n?$//g;
104		$line =~ s/^\s*//g;
105		$line =~ s/\s+/ /g;
106
107		next if ($line =~ m/^\s*#/);
108		next if ($line =~ m/^\s*$/);
109
110		my @words = split(" ", $line);
111		foreach my $word (@words) {
112			last if ($word =~ m/^#/);
113			push (@conf_args, $word);
114		}
115	}
116	close($conffile);
117	unshift(@ARGV, @conf_args) if @conf_args;
118}
119
120GetOptions(
121	'q|quiet+'	=> \$quiet,
122	'tree!'		=> \$tree,
123	'signoff!'	=> \$chk_signoff,
124	'patch!'	=> \$chk_patch,
125	'emacs!'	=> \$emacs,
126	'terse!'	=> \$terse,
127	'f|file!'	=> \$file,
128	'subjective!'	=> \$check,
129	'strict!'	=> \$check,
130	'ignore=s'	=> \@ignore,
131	'types=s'	=> \@use,
132	'show-types!'	=> \$show_types,
133	'max-line-length=i' => \$max_line_length,
134	'root=s'	=> \$root,
135	'summary!'	=> \$summary,
136	'mailback!'	=> \$mailback,
137	'summary-file!'	=> \$summary_file,
138	'fix!'		=> \$fix,
139	'fix-inplace!'	=> \$fix_inplace,
140	'ignore-perl-version!' => \$ignore_perl_version,
141	'debug=s'	=> \%debug,
142	'test-only=s'	=> \$tst_only,
143	'h|help'	=> \$help,
144	'version'	=> \$help
145) or help(1);
146
147help(0) if ($help);
148
149$fix = 1 if ($fix_inplace);
150$check_orig = $check;
151
152my $exit = 0;
153
154if ($^V && $^V lt $minimum_perl_version) {
155	printf "$P: requires at least perl version %vd\n", $minimum_perl_version;
156	if (!$ignore_perl_version) {
157		exit(1);
158	}
159}
160
161if ($#ARGV < 0) {
162	print "$P: no input files\n";
163	exit(1);
164}
165
166sub hash_save_array_words {
167	my ($hashRef, $arrayRef) = @_;
168
169	my @array = split(/,/, join(',', @$arrayRef));
170	foreach my $word (@array) {
171		$word =~ s/\s*\n?$//g;
172		$word =~ s/^\s*//g;
173		$word =~ s/\s+/ /g;
174		$word =~ tr/[a-z]/[A-Z]/;
175
176		next if ($word =~ m/^\s*#/);
177		next if ($word =~ m/^\s*$/);
178
179		$hashRef->{$word}++;
180	}
181}
182
183sub hash_show_words {
184	my ($hashRef, $prefix) = @_;
185
186	if ($quiet == 0 && keys %$hashRef) {
187		print "NOTE: $prefix message types:";
188		foreach my $word (sort keys %$hashRef) {
189			print " $word";
190		}
191		print "\n\n";
192	}
193}
194
195hash_save_array_words(\%ignore_type, \@ignore);
196hash_save_array_words(\%use_type, \@use);
197
198my $dbg_values = 0;
199my $dbg_possible = 0;
200my $dbg_type = 0;
201my $dbg_attr = 0;
202for my $key (keys %debug) {
203	## no critic
204	eval "\${dbg_$key} = '$debug{$key}';";
205	die "$@" if ($@);
206}
207
208my $rpt_cleaners = 0;
209
210if ($terse) {
211	$emacs = 1;
212	$quiet++;
213}
214
215if ($tree) {
216	if (defined $root) {
217		if (!top_of_kernel_tree($root)) {
218			die "$P: $root: --root does not point at a valid tree\n";
219		}
220	} else {
221		if (top_of_kernel_tree('.')) {
222			$root = '.';
223		} elsif ($0 =~ m@(.*)/scripts/[^/]*$@ &&
224						top_of_kernel_tree($1)) {
225			$root = $1;
226		}
227	}
228
229	if (!defined $root) {
230		print "Must be run from the top-level dir. of a kernel tree\n";
231		exit(2);
232	}
233}
234
235my $emitted_corrupt = 0;
236
237our $Ident	= qr{
238			[A-Za-z_][A-Za-z\d_]*
239			(?:\s*\#\#\s*[A-Za-z_][A-Za-z\d_]*)*
240		}x;
241our $Storage	= qr{extern|static|asmlinkage};
242our $Sparse	= qr{
243			__user|
244			__kernel|
245			__force|
246			__iomem|
247			__must_check|
248			__init_refok|
249			__kprobes|
250			__ref|
251			__rcu
252		}x;
253our $InitAttributePrefix = qr{__(?:mem|cpu|dev|net_|)};
254our $InitAttributeData = qr{$InitAttributePrefix(?:initdata\b)};
255our $InitAttributeConst = qr{$InitAttributePrefix(?:initconst\b)};
256our $InitAttributeInit = qr{$InitAttributePrefix(?:init\b)};
257our $InitAttribute = qr{$InitAttributeData|$InitAttributeConst|$InitAttributeInit};
258
259# Notes to $Attribute:
260# We need \b after 'init' otherwise 'initconst' will cause a false positive in a check
261our $Attribute	= qr{
262			const|
263			__percpu|
264			__nocast|
265			__safe|
266			__bitwise__|
267			__packed__|
268			__packed2__|
269			__naked|
270			__maybe_unused|
271			__always_unused|
272			__noreturn|
273			__used|
274			__cold|
275			__noclone|
276			__deprecated|
277			__read_mostly|
278			__kprobes|
279			$InitAttribute|
280			____cacheline_aligned|
281			____cacheline_aligned_in_smp|
282			____cacheline_internodealigned_in_smp|
283			__weak
284		  }x;
285our $Modifier;
286our $Inline	= qr{inline|__always_inline|noinline|__inline|__inline__};
287our $Member	= qr{->$Ident|\.$Ident|\[[^]]*\]};
288our $Lval	= qr{$Ident(?:$Member)*};
289
290our $Int_type	= qr{(?i)llu|ull|ll|lu|ul|l|u};
291our $Binary	= qr{(?i)0b[01]+$Int_type?};
292our $Hex	= qr{(?i)0x[0-9a-f]+$Int_type?};
293our $Int	= qr{[0-9]+$Int_type?};
294our $Octal	= qr{0[0-7]+$Int_type?};
295our $Float_hex	= qr{(?i)0x[0-9a-f]+p-?[0-9]+[fl]?};
296our $Float_dec	= qr{(?i)(?:[0-9]+\.[0-9]*|[0-9]*\.[0-9]+)(?:e-?[0-9]+)?[fl]?};
297our $Float_int	= qr{(?i)[0-9]+e-?[0-9]+[fl]?};
298our $Float	= qr{$Float_hex|$Float_dec|$Float_int};
299our $Constant	= qr{$Float|$Binary|$Octal|$Hex|$Int};
300our $Assignment	= qr{\*\=|/=|%=|\+=|-=|<<=|>>=|&=|\^=|\|=|=};
301our $Compare    = qr{<=|>=|==|!=|<|(?<!-)>};
302our $Arithmetic = qr{\+|-|\*|\/|%};
303our $Operators	= qr{
304			<=|>=|==|!=|
305			=>|->|<<|>>|<|>|!|~|
306			&&|\|\||,|\^|\+\+|--|&|\||$Arithmetic
307		  }x;
308
309our $c90_Keywords = qr{do|for|while|if|else|return|goto|continue|switch|default|case|break}x;
310
311our $NonptrType;
312our $NonptrTypeWithAttr;
313our $Type;
314our $Declare;
315
316our $NON_ASCII_UTF8	= qr{
317	[\xC2-\xDF][\x80-\xBF]               # non-overlong 2-byte
318	|  \xE0[\xA0-\xBF][\x80-\xBF]        # excluding overlongs
319	| [\xE1-\xEC\xEE\xEF][\x80-\xBF]{2}  # straight 3-byte
320	|  \xED[\x80-\x9F][\x80-\xBF]        # excluding surrogates
321	|  \xF0[\x90-\xBF][\x80-\xBF]{2}     # planes 1-3
322	| [\xF1-\xF3][\x80-\xBF]{3}          # planes 4-15
323	|  \xF4[\x80-\x8F][\x80-\xBF]{2}     # plane 16
324}x;
325
326our $UTF8	= qr{
327	[\x09\x0A\x0D\x20-\x7E]              # ASCII
328	| $NON_ASCII_UTF8
329}x;
330
331our $typeTypedefs = qr{(?x:
332	(?:__)?(?:u|s|be|le)(?:8|16|32|64)|
333	atomic_t
334)};
335
336our $logFunctions = qr{(?x:
337	printk(?:_ratelimited|_once|)|
338	(?:[a-z0-9]+_){1,2}(?:printk|emerg|alert|crit|err|warning|warn|notice|info|debug|dbg|vdbg|devel|cont|WARN)(?:_ratelimited|_once|)|
339	WARN(?:_RATELIMIT|_ONCE|)|
340	panic|
341	MODULE_[A-Z_]+|
342	seq_vprintf|seq_printf|seq_puts
343)};
344
345our $signature_tags = qr{(?xi:
346	Signed-off-by:|
347	Acked-by:|
348	Tested-by:|
349	Reviewed-by:|
350	Reported-by:|
351	Suggested-by:|
352	To:|
353	Cc:
354)};
355
356our @typeList = (
357	qr{void},
358	qr{(?:unsigned\s+)?char},
359	qr{(?:unsigned\s+)?short},
360	qr{(?:unsigned\s+)?int},
361	qr{(?:unsigned\s+)?long},
362	qr{(?:unsigned\s+)?long\s+int},
363	qr{(?:unsigned\s+)?long\s+long},
364	qr{(?:unsigned\s+)?long\s+long\s+int},
365	qr{unsigned},
366	qr{float},
367	qr{double},
368	qr{bool},
369	qr{struct\s+$Ident},
370	qr{union\s+$Ident},
371	qr{enum\s+$Ident},
372	qr{${Ident}_t},
373	qr{${Ident}_handler},
374	qr{${Ident}_handler_fn},
375);
376our @typeListWithAttr = (
377	@typeList,
378	qr{struct\s+$InitAttribute\s+$Ident},
379	qr{union\s+$InitAttribute\s+$Ident},
380);
381
382our @modifierList = (
383	qr{fastcall},
384);
385
386our @mode_permission_funcs = (
387	["module_param", 3],
388	["module_param_(?:array|named|string)", 4],
389	["module_param_array_named", 5],
390	["debugfs_create_(?:file|u8|u16|u32|u64|x8|x16|x32|x64|size_t|atomic_t|bool|blob|regset32|u32_array)", 2],
391	["proc_create(?:_data|)", 2],
392	["(?:CLASS|DEVICE|SENSOR)_ATTR", 2],
393);
394
395#Create a search pattern for all these functions to speed up a loop below
396our $mode_perms_search = "";
397foreach my $entry (@mode_permission_funcs) {
398	$mode_perms_search .= '|' if ($mode_perms_search ne "");
399	$mode_perms_search .= $entry->[0];
400}
401
402our $declaration_macros = qr{(?x:
403	(?:$Storage\s+)?(?:DECLARE|DEFINE)_[A-Z]+\s*\(|
404	(?:$Storage\s+)?LIST_HEAD\s*\(
405)};
406
407our $allowed_asm_includes = qr{(?x:
408	irq|
409	memory
410)};
411# memory.h: ARM has a custom one
412
413sub build_types {
414	my $mods = "(?x:  \n" . join("|\n  ", @modifierList) . "\n)";
415	my $all = "(?x:  \n" . join("|\n  ", @typeList) . "\n)";
416	my $allWithAttr = "(?x:  \n" . join("|\n  ", @typeListWithAttr) . "\n)";
417	$Modifier	= qr{(?:$Attribute|$Sparse|$mods)};
418	$NonptrType	= qr{
419			(?:$Modifier\s+|const\s+)*
420			(?:
421				(?:typeof|__typeof__)\s*\([^\)]*\)|
422				(?:$typeTypedefs\b)|
423				(?:${all}\b)
424			)
425			(?:\s+$Modifier|\s+const)*
426		  }x;
427	$NonptrTypeWithAttr	= qr{
428			(?:$Modifier\s+|const\s+)*
429			(?:
430				(?:typeof|__typeof__)\s*\([^\)]*\)|
431				(?:$typeTypedefs\b)|
432				(?:${allWithAttr}\b)
433			)
434			(?:\s+$Modifier|\s+const)*
435		  }x;
436	$Type	= qr{
437			$NonptrType
438			(?:(?:\s|\*|\[\])+\s*const|(?:\s|\*|\[\])+|(?:\s*\[\s*\])+)?
439			(?:\s+$Inline|\s+$Modifier)*
440		  }x;
441	$Declare	= qr{(?:$Storage\s+(?:$Inline\s+)?)?$Type};
442}
443build_types();
444
445our $Typecast	= qr{\s*(\(\s*$NonptrType\s*\)){0,1}\s*};
446
447# Using $balanced_parens, $LvalOrFunc, or $FuncArg
448# requires at least perl version v5.10.0
449# Any use must be runtime checked with $^V
450
451our $balanced_parens = qr/(\((?:[^\(\)]++|(?-1))*\))/;
452our $LvalOrFunc	= qr{((?:[\&\*]\s*)?$Lval)\s*($balanced_parens{0,1})\s*};
453our $FuncArg = qr{$Typecast{0,1}($LvalOrFunc|$Constant)};
454
455sub deparenthesize {
456	my ($string) = @_;
457	return "" if (!defined($string));
458
459	while ($string =~ /^\s*\(.*\)\s*$/) {
460		$string =~ s@^\s*\(\s*@@;
461		$string =~ s@\s*\)\s*$@@;
462	}
463
464	$string =~ s@\s+@ @g;
465
466	return $string;
467}
468
469sub seed_camelcase_file {
470	my ($file) = @_;
471
472	return if (!(-f $file));
473
474	local $/;
475
476	open(my $include_file, '<', "$file")
477	    or warn "$P: Can't read '$file' $!\n";
478	my $text = <$include_file>;
479	close($include_file);
480
481	my @lines = split('\n', $text);
482
483	foreach my $line (@lines) {
484		next if ($line !~ /(?:[A-Z][a-z]|[a-z][A-Z])/);
485		if ($line =~ /^[ \t]*(?:#[ \t]*define|typedef\s+$Type)\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)/) {
486			$camelcase{$1} = 1;
487		} elsif ($line =~ /^\s*$Declare\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)\s*[\(\[,;]/) {
488			$camelcase{$1} = 1;
489		} elsif ($line =~ /^\s*(?:union|struct|enum)\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)\s*[;\{]/) {
490			$camelcase{$1} = 1;
491		}
492	}
493}
494
495my $camelcase_seeded = 0;
496sub seed_camelcase_includes {
497	return if ($camelcase_seeded);
498
499	my $files;
500	my $camelcase_cache = "";
501	my @include_files = ();
502
503	$camelcase_seeded = 1;
504
505	if (-e ".git") {
506		my $git_last_include_commit = `git log --no-merges --pretty=format:"%h%n" -1 -- include`;
507		chomp $git_last_include_commit;
508		$camelcase_cache = ".checkpatch-camelcase.git.$git_last_include_commit";
509	} else {
510		my $last_mod_date = 0;
511		$files = `find $root/include -name "*.h"`;
512		@include_files = split('\n', $files);
513		foreach my $file (@include_files) {
514			my $date = POSIX::strftime("%Y%m%d%H%M",
515						   localtime((stat $file)[9]));
516			$last_mod_date = $date if ($last_mod_date < $date);
517		}
518		$camelcase_cache = ".checkpatch-camelcase.date.$last_mod_date";
519	}
520
521	if ($camelcase_cache ne "" && -f $camelcase_cache) {
522		open(my $camelcase_file, '<', "$camelcase_cache")
523		    or warn "$P: Can't read '$camelcase_cache' $!\n";
524		while (<$camelcase_file>) {
525			chomp;
526			$camelcase{$_} = 1;
527		}
528		close($camelcase_file);
529
530		return;
531	}
532
533	if (-e ".git") {
534		$files = `git ls-files "include/*.h"`;
535		@include_files = split('\n', $files);
536	}
537
538	foreach my $file (@include_files) {
539		seed_camelcase_file($file);
540	}
541
542	if ($camelcase_cache ne "") {
543		unlink glob ".checkpatch-camelcase.*";
544		open(my $camelcase_file, '>', "$camelcase_cache")
545		    or warn "$P: Can't write '$camelcase_cache' $!\n";
546		foreach (sort { lc($a) cmp lc($b) } keys(%camelcase)) {
547			print $camelcase_file ("$_\n");
548		}
549		close($camelcase_file);
550	}
551}
552
553$chk_signoff = 0 if ($file);
554
555my @rawlines = ();
556my @lines = ();
557my @fixed = ();
558my $vname;
559for my $filename (@ARGV) {
560	my $FILE;
561	if ($file) {
562		open($FILE, '-|', "diff -u /dev/null $filename") ||
563			die "$P: $filename: diff failed - $!\n";
564	} elsif ($filename eq '-') {
565		open($FILE, '<&STDIN');
566	} else {
567		open($FILE, '<', "$filename") ||
568			die "$P: $filename: open failed - $!\n";
569	}
570	if ($filename eq '-') {
571		$vname = 'Your patch';
572	} else {
573		$vname = $filename;
574	}
575	while (<$FILE>) {
576		chomp;
577		push(@rawlines, $_);
578	}
579	close($FILE);
580	if (!process($filename)) {
581		$exit = 1;
582	}
583	@rawlines = ();
584	@lines = ();
585	@fixed = ();
586}
587
588exit($exit);
589
590sub top_of_kernel_tree {
591	my ($root) = @_;
592
593	my @tree_check = (
594		"COPYING", "CREDITS", "Kbuild", "MAINTAINERS", "Makefile",
595		"README", "Documentation", "arch", "include", "drivers",
596		"fs", "init", "ipc", "kernel", "lib", "scripts",
597	);
598
599	foreach my $check (@tree_check) {
600		if (! -e $root . '/' . $check) {
601			return 0;
602		}
603	}
604	return 1;
605}
606
607sub parse_email {
608	my ($formatted_email) = @_;
609
610	my $name = "";
611	my $address = "";
612	my $comment = "";
613
614	if ($formatted_email =~ /^(.*)<(\S+\@\S+)>(.*)$/) {
615		$name = $1;
616		$address = $2;
617		$comment = $3 if defined $3;
618	} elsif ($formatted_email =~ /^\s*<(\S+\@\S+)>(.*)$/) {
619		$address = $1;
620		$comment = $2 if defined $2;
621	} elsif ($formatted_email =~ /(\S+\@\S+)(.*)$/) {
622		$address = $1;
623		$comment = $2 if defined $2;
624		$formatted_email =~ s/$address.*$//;
625		$name = $formatted_email;
626		$name = trim($name);
627		$name =~ s/^\"|\"$//g;
628		# If there's a name left after stripping spaces and
629		# leading quotes, and the address doesn't have both
630		# leading and trailing angle brackets, the address
631		# is invalid. ie:
632		#   "joe smith joe@smith.com" bad
633		#   "joe smith <joe@smith.com" bad
634		if ($name ne "" && $address !~ /^<[^>]+>$/) {
635			$name = "";
636			$address = "";
637			$comment = "";
638		}
639	}
640
641	$name = trim($name);
642	$name =~ s/^\"|\"$//g;
643	$address = trim($address);
644	$address =~ s/^\<|\>$//g;
645
646	if ($name =~ /[^\w \-]/i) { ##has "must quote" chars
647		$name =~ s/(?<!\\)"/\\"/g; ##escape quotes
648		$name = "\"$name\"";
649	}
650
651	return ($name, $address, $comment);
652}
653
654sub format_email {
655	my ($name, $address) = @_;
656
657	my $formatted_email;
658
659	$name = trim($name);
660	$name =~ s/^\"|\"$//g;
661	$address = trim($address);
662
663	if ($name =~ /[^\w \-]/i) { ##has "must quote" chars
664		$name =~ s/(?<!\\)"/\\"/g; ##escape quotes
665		$name = "\"$name\"";
666	}
667
668	if ("$name" eq "") {
669		$formatted_email = "$address";
670	} else {
671		$formatted_email = "$name <$address>";
672	}
673
674	return $formatted_email;
675}
676
677sub which_conf {
678	my ($conf) = @_;
679
680	foreach my $path (split(/:/, ".:$ENV{HOME}:.scripts")) {
681		if (-e "$path/$conf") {
682			return "$path/$conf";
683		}
684	}
685
686	return "";
687}
688
689sub expand_tabs {
690	my ($str) = @_;
691
692	my $res = '';
693	my $n = 0;
694	for my $c (split(//, $str)) {
695		if ($c eq "\t") {
696			$res .= ' ';
697			$n++;
698			for (; ($n % 8) != 0; $n++) {
699				$res .= ' ';
700			}
701			next;
702		}
703		$res .= $c;
704		$n++;
705	}
706
707	return $res;
708}
709sub copy_spacing {
710	(my $res = shift) =~ tr/\t/ /c;
711	return $res;
712}
713
714sub line_stats {
715	my ($line) = @_;
716
717	# Drop the diff line leader and expand tabs
718	$line =~ s/^.//;
719	$line = expand_tabs($line);
720
721	# Pick the indent from the front of the line.
722	my ($white) = ($line =~ /^(\s*)/);
723
724	return (length($line), length($white));
725}
726
727my $sanitise_quote = '';
728
729sub sanitise_line_reset {
730	my ($in_comment) = @_;
731
732	if ($in_comment) {
733		$sanitise_quote = '*/';
734	} else {
735		$sanitise_quote = '';
736	}
737}
738sub sanitise_line {
739	my ($line) = @_;
740
741	my $res = '';
742	my $l = '';
743
744	my $qlen = 0;
745	my $off = 0;
746	my $c;
747
748	# Always copy over the diff marker.
749	$res = substr($line, 0, 1);
750
751	for ($off = 1; $off < length($line); $off++) {
752		$c = substr($line, $off, 1);
753
754		# Comments we are wacking completly including the begin
755		# and end, all to $;.
756		if ($sanitise_quote eq '' && substr($line, $off, 2) eq '/*') {
757			$sanitise_quote = '*/';
758
759			substr($res, $off, 2, "$;$;");
760			$off++;
761			next;
762		}
763		if ($sanitise_quote eq '*/' && substr($line, $off, 2) eq '*/') {
764			$sanitise_quote = '';
765			substr($res, $off, 2, "$;$;");
766			$off++;
767			next;
768		}
769		if ($sanitise_quote eq '' && substr($line, $off, 2) eq '//') {
770			$sanitise_quote = '//';
771
772			substr($res, $off, 2, $sanitise_quote);
773			$off++;
774			next;
775		}
776
777		# A \ in a string means ignore the next character.
778		if (($sanitise_quote eq "'" || $sanitise_quote eq '"') &&
779		    $c eq "\\") {
780			substr($res, $off, 2, 'XX');
781			$off++;
782			next;
783		}
784		# Regular quotes.
785		if ($c eq "'" || $c eq '"') {
786			if ($sanitise_quote eq '') {
787				$sanitise_quote = $c;
788
789				substr($res, $off, 1, $c);
790				next;
791			} elsif ($sanitise_quote eq $c) {
792				$sanitise_quote = '';
793			}
794		}
795
796		#print "c<$c> SQ<$sanitise_quote>\n";
797		if ($off != 0 && $sanitise_quote eq '*/' && $c ne "\t") {
798			substr($res, $off, 1, $;);
799		} elsif ($off != 0 && $sanitise_quote eq '//' && $c ne "\t") {
800			substr($res, $off, 1, $;);
801		} elsif ($off != 0 && $sanitise_quote && $c ne "\t") {
802			substr($res, $off, 1, 'X');
803		} else {
804			substr($res, $off, 1, $c);
805		}
806	}
807
808	if ($sanitise_quote eq '//') {
809		$sanitise_quote = '';
810	}
811
812	# The pathname on a #include may be surrounded by '<' and '>'.
813	if ($res =~ /^.\s*\#\s*include\s+\<(.*)\>/) {
814		my $clean = 'X' x length($1);
815		$res =~ s@\<.*\>@<$clean>@;
816
817	# The whole of a #error is a string.
818	} elsif ($res =~ /^.\s*\#\s*(?:error|warning)\s+(.*)\b/) {
819		my $clean = 'X' x length($1);
820		$res =~ s@(\#\s*(?:error|warning)\s+).*@$1$clean@;
821	}
822
823	return $res;
824}
825
826sub get_quoted_string {
827	my ($line, $rawline) = @_;
828
829	return "" if ($line !~ m/(\"[X]+\")/g);
830	return substr($rawline, $-[0], $+[0] - $-[0]);
831}
832
833sub ctx_statement_block {
834	my ($linenr, $remain, $off) = @_;
835	my $line = $linenr - 1;
836	my $blk = '';
837	my $soff = $off;
838	my $coff = $off - 1;
839	my $coff_set = 0;
840
841	my $loff = 0;
842
843	my $type = '';
844	my $level = 0;
845	my @stack = ();
846	my $p;
847	my $c;
848	my $len = 0;
849
850	my $remainder;
851	while (1) {
852		@stack = (['', 0]) if ($#stack == -1);
853
854		#warn "CSB: blk<$blk> remain<$remain>\n";
855		# If we are about to drop off the end, pull in more
856		# context.
857		if ($off >= $len) {
858			for (; $remain > 0; $line++) {
859				last if (!defined $lines[$line]);
860				next if ($lines[$line] =~ /^-/);
861				$remain--;
862				$loff = $len;
863				$blk .= $lines[$line] . "\n";
864				$len = length($blk);
865				$line++;
866				last;
867			}
868			# Bail if there is no further context.
869			#warn "CSB: blk<$blk> off<$off> len<$len>\n";
870			if ($off >= $len) {
871				last;
872			}
873			if ($level == 0 && substr($blk, $off) =~ /^.\s*#\s*define/) {
874				$level++;
875				$type = '#';
876			}
877		}
878		$p = $c;
879		$c = substr($blk, $off, 1);
880		$remainder = substr($blk, $off);
881
882		#warn "CSB: c<$c> type<$type> level<$level> remainder<$remainder> coff_set<$coff_set>\n";
883
884		# Handle nested #if/#else.
885		if ($remainder =~ /^#\s*(?:ifndef|ifdef|if)\s/) {
886			push(@stack, [ $type, $level ]);
887		} elsif ($remainder =~ /^#\s*(?:else|elif)\b/) {
888			($type, $level) = @{$stack[$#stack - 1]};
889		} elsif ($remainder =~ /^#\s*endif\b/) {
890			($type, $level) = @{pop(@stack)};
891		}
892
893		# Statement ends at the ';' or a close '}' at the
894		# outermost level.
895		if ($level == 0 && $c eq ';') {
896			last;
897		}
898
899		# An else is really a conditional as long as its not else if
900		if ($level == 0 && $coff_set == 0 &&
901				(!defined($p) || $p =~ /(?:\s|\}|\+)/) &&
902				$remainder =~ /^(else)(?:\s|{)/ &&
903				$remainder !~ /^else\s+if\b/) {
904			$coff = $off + length($1) - 1;
905			$coff_set = 1;
906			#warn "CSB: mark coff<$coff> soff<$soff> 1<$1>\n";
907			#warn "[" . substr($blk, $soff, $coff - $soff + 1) . "]\n";
908		}
909
910		if (($type eq '' || $type eq '(') && $c eq '(') {
911			$level++;
912			$type = '(';
913		}
914		if ($type eq '(' && $c eq ')') {
915			$level--;
916			$type = ($level != 0)? '(' : '';
917
918			if ($level == 0 && $coff < $soff) {
919				$coff = $off;
920				$coff_set = 1;
921				#warn "CSB: mark coff<$coff>\n";
922			}
923		}
924		if (($type eq '' || $type eq '{') && $c eq '{') {
925			$level++;
926			$type = '{';
927		}
928		if ($type eq '{' && $c eq '}') {
929			$level--;
930			$type = ($level != 0)? '{' : '';
931
932			if ($level == 0) {
933				if (substr($blk, $off + 1, 1) eq ';') {
934					$off++;
935				}
936				last;
937			}
938		}
939		# Preprocessor commands end at the newline unless escaped.
940		if ($type eq '#' && $c eq "\n" && $p ne "\\") {
941			$level--;
942			$type = '';
943			$off++;
944			last;
945		}
946		$off++;
947	}
948	# We are truly at the end, so shuffle to the next line.
949	if ($off == $len) {
950		$loff = $len + 1;
951		$line++;
952		$remain--;
953	}
954
955	my $statement = substr($blk, $soff, $off - $soff + 1);
956	my $condition = substr($blk, $soff, $coff - $soff + 1);
957
958	#warn "STATEMENT<$statement>\n";
959	#warn "CONDITION<$condition>\n";
960
961	#print "coff<$coff> soff<$off> loff<$loff>\n";
962
963	return ($statement, $condition,
964			$line, $remain + 1, $off - $loff + 1, $level);
965}
966
967sub statement_lines {
968	my ($stmt) = @_;
969
970	# Strip the diff line prefixes and rip blank lines at start and end.
971	$stmt =~ s/(^|\n)./$1/g;
972	$stmt =~ s/^\s*//;
973	$stmt =~ s/\s*$//;
974
975	my @stmt_lines = ($stmt =~ /\n/g);
976
977	return $#stmt_lines + 2;
978}
979
980sub statement_rawlines {
981	my ($stmt) = @_;
982
983	my @stmt_lines = ($stmt =~ /\n/g);
984
985	return $#stmt_lines + 2;
986}
987
988sub statement_block_size {
989	my ($stmt) = @_;
990
991	$stmt =~ s/(^|\n)./$1/g;
992	$stmt =~ s/^\s*{//;
993	$stmt =~ s/}\s*$//;
994	$stmt =~ s/^\s*//;
995	$stmt =~ s/\s*$//;
996
997	my @stmt_lines = ($stmt =~ /\n/g);
998	my @stmt_statements = ($stmt =~ /;/g);
999
1000	my $stmt_lines = $#stmt_lines + 2;
1001	my $stmt_statements = $#stmt_statements + 1;
1002
1003	if ($stmt_lines > $stmt_statements) {
1004		return $stmt_lines;
1005	} else {
1006		return $stmt_statements;
1007	}
1008}
1009
1010sub ctx_statement_full {
1011	my ($linenr, $remain, $off) = @_;
1012	my ($statement, $condition, $level);
1013
1014	my (@chunks);
1015
1016	# Grab the first conditional/block pair.
1017	($statement, $condition, $linenr, $remain, $off, $level) =
1018				ctx_statement_block($linenr, $remain, $off);
1019	#print "F: c<$condition> s<$statement> remain<$remain>\n";
1020	push(@chunks, [ $condition, $statement ]);
1021	if (!($remain > 0 && $condition =~ /^\s*(?:\n[+-])?\s*(?:if|else|do)\b/s)) {
1022		return ($level, $linenr, @chunks);
1023	}
1024
1025	# Pull in the following conditional/block pairs and see if they
1026	# could continue the statement.
1027	for (;;) {
1028		($statement, $condition, $linenr, $remain, $off, $level) =
1029				ctx_statement_block($linenr, $remain, $off);
1030		#print "C: c<$condition> s<$statement> remain<$remain>\n";
1031		last if (!($remain > 0 && $condition =~ /^(?:\s*\n[+-])*\s*(?:else|do)\b/s));
1032		#print "C: push\n";
1033		push(@chunks, [ $condition, $statement ]);
1034	}
1035
1036	return ($level, $linenr, @chunks);
1037}
1038
1039sub ctx_block_get {
1040	my ($linenr, $remain, $outer, $open, $close, $off) = @_;
1041	my $line;
1042	my $start = $linenr - 1;
1043	my $blk = '';
1044	my @o;
1045	my @c;
1046	my @res = ();
1047
1048	my $level = 0;
1049	my @stack = ($level);
1050	for ($line = $start; $remain > 0; $line++) {
1051		next if ($rawlines[$line] =~ /^-/);
1052		$remain--;
1053
1054		$blk .= $rawlines[$line];
1055
1056		# Handle nested #if/#else.
1057		if ($lines[$line] =~ /^.\s*#\s*(?:ifndef|ifdef|if)\s/) {
1058			push(@stack, $level);
1059		} elsif ($lines[$line] =~ /^.\s*#\s*(?:else|elif)\b/) {
1060			$level = $stack[$#stack - 1];
1061		} elsif ($lines[$line] =~ /^.\s*#\s*endif\b/) {
1062			$level = pop(@stack);
1063		}
1064
1065		foreach my $c (split(//, $lines[$line])) {
1066			##print "C<$c>L<$level><$open$close>O<$off>\n";
1067			if ($off > 0) {
1068				$off--;
1069				next;
1070			}
1071
1072			if ($c eq $close && $level > 0) {
1073				$level--;
1074				last if ($level == 0);
1075			} elsif ($c eq $open) {
1076				$level++;
1077			}
1078		}
1079
1080		if (!$outer || $level <= 1) {
1081			push(@res, $rawlines[$line]);
1082		}
1083
1084		last if ($level == 0);
1085	}
1086
1087	return ($level, @res);
1088}
1089sub ctx_block_outer {
1090	my ($linenr, $remain) = @_;
1091
1092	my ($level, @r) = ctx_block_get($linenr, $remain, 1, '{', '}', 0);
1093	return @r;
1094}
1095sub ctx_block {
1096	my ($linenr, $remain) = @_;
1097
1098	my ($level, @r) = ctx_block_get($linenr, $remain, 0, '{', '}', 0);
1099	return @r;
1100}
1101sub ctx_statement {
1102	my ($linenr, $remain, $off) = @_;
1103
1104	my ($level, @r) = ctx_block_get($linenr, $remain, 0, '(', ')', $off);
1105	return @r;
1106}
1107sub ctx_block_level {
1108	my ($linenr, $remain) = @_;
1109
1110	return ctx_block_get($linenr, $remain, 0, '{', '}', 0);
1111}
1112sub ctx_statement_level {
1113	my ($linenr, $remain, $off) = @_;
1114
1115	return ctx_block_get($linenr, $remain, 0, '(', ')', $off);
1116}
1117
1118sub ctx_locate_comment {
1119	my ($first_line, $end_line) = @_;
1120
1121	# Catch a comment on the end of the line itself.
1122	my ($current_comment) = ($rawlines[$end_line - 1] =~ m@.*(/\*.*\*/)\s*(?:\\\s*)?$@);
1123	return $current_comment if (defined $current_comment);
1124
1125	# Look through the context and try and figure out if there is a
1126	# comment.
1127	my $in_comment = 0;
1128	$current_comment = '';
1129	for (my $linenr = $first_line; $linenr < $end_line; $linenr++) {
1130		my $line = $rawlines[$linenr - 1];
1131		#warn "           $line\n";
1132		if ($linenr == $first_line and $line =~ m@^.\s*\*@) {
1133			$in_comment = 1;
1134		}
1135		if ($line =~ m@/\*@) {
1136			$in_comment = 1;
1137		}
1138		if (!$in_comment && $current_comment ne '') {
1139			$current_comment = '';
1140		}
1141		$current_comment .= $line . "\n" if ($in_comment);
1142		if ($line =~ m@\*/@) {
1143			$in_comment = 0;
1144		}
1145	}
1146
1147	chomp($current_comment);
1148	return($current_comment);
1149}
1150sub ctx_has_comment {
1151	my ($first_line, $end_line) = @_;
1152	my $cmt = ctx_locate_comment($first_line, $end_line);
1153
1154	##print "LINE: $rawlines[$end_line - 1 ]\n";
1155	##print "CMMT: $cmt\n";
1156
1157	return ($cmt ne '');
1158}
1159
1160sub raw_line {
1161	my ($linenr, $cnt) = @_;
1162
1163	my $offset = $linenr - 1;
1164	$cnt++;
1165
1166	my $line;
1167	while ($cnt) {
1168		$line = $rawlines[$offset++];
1169		next if (defined($line) && $line =~ /^-/);
1170		$cnt--;
1171	}
1172
1173	return $line;
1174}
1175
1176sub cat_vet {
1177	my ($vet) = @_;
1178	my ($res, $coded);
1179
1180	$res = '';
1181	while ($vet =~ /([^[:cntrl:]]*)([[:cntrl:]]|$)/g) {
1182		$res .= $1;
1183		if ($2 ne '') {
1184			$coded = sprintf("^%c", unpack('C', $2) + 64);
1185			$res .= $coded;
1186		}
1187	}
1188	$res =~ s/$/\$/;
1189
1190	return $res;
1191}
1192
1193my $av_preprocessor = 0;
1194my $av_pending;
1195my @av_paren_type;
1196my $av_pend_colon;
1197
1198sub annotate_reset {
1199	$av_preprocessor = 0;
1200	$av_pending = '_';
1201	@av_paren_type = ('E');
1202	$av_pend_colon = 'O';
1203}
1204
1205sub annotate_values {
1206	my ($stream, $type) = @_;
1207
1208	my $res;
1209	my $var = '_' x length($stream);
1210	my $cur = $stream;
1211
1212	print "$stream\n" if ($dbg_values > 1);
1213
1214	while (length($cur)) {
1215		@av_paren_type = ('E') if ($#av_paren_type < 0);
1216		print " <" . join('', @av_paren_type) .
1217				"> <$type> <$av_pending>" if ($dbg_values > 1);
1218		if ($cur =~ /^(\s+)/o) {
1219			print "WS($1)\n" if ($dbg_values > 1);
1220			if ($1 =~ /\n/ && $av_preprocessor) {
1221				$type = pop(@av_paren_type);
1222				$av_preprocessor = 0;
1223			}
1224
1225		} elsif ($cur =~ /^(\(\s*$Type\s*)\)/ && $av_pending eq '_') {
1226			print "CAST($1)\n" if ($dbg_values > 1);
1227			push(@av_paren_type, $type);
1228			$type = 'c';
1229
1230		} elsif ($cur =~ /^($Type)\s*(?:$Ident|,|\)|\(|\s*$)/) {
1231			print "DECLARE($1)\n" if ($dbg_values > 1);
1232			$type = 'T';
1233
1234		} elsif ($cur =~ /^($Modifier)\s*/) {
1235			print "MODIFIER($1)\n" if ($dbg_values > 1);
1236			$type = 'T';
1237
1238		} elsif ($cur =~ /^(\#\s*define\s*$Ident)(\(?)/o) {
1239			print "DEFINE($1,$2)\n" if ($dbg_values > 1);
1240			$av_preprocessor = 1;
1241			push(@av_paren_type, $type);
1242			if ($2 ne '') {
1243				$av_pending = 'N';
1244			}
1245			$type = 'E';
1246
1247		} elsif ($cur =~ /^(\#\s*(?:undef\s*$Ident|include\b))/o) {
1248			print "UNDEF($1)\n" if ($dbg_values > 1);
1249			$av_preprocessor = 1;
1250			push(@av_paren_type, $type);
1251
1252		} elsif ($cur =~ /^(\#\s*(?:ifdef|ifndef|if))/o) {
1253			print "PRE_START($1)\n" if ($dbg_values > 1);
1254			$av_preprocessor = 1;
1255
1256			push(@av_paren_type, $type);
1257			push(@av_paren_type, $type);
1258			$type = 'E';
1259
1260		} elsif ($cur =~ /^(\#\s*(?:else|elif))/o) {
1261			print "PRE_RESTART($1)\n" if ($dbg_values > 1);
1262			$av_preprocessor = 1;
1263
1264			push(@av_paren_type, $av_paren_type[$#av_paren_type]);
1265
1266			$type = 'E';
1267
1268		} elsif ($cur =~ /^(\#\s*(?:endif))/o) {
1269			print "PRE_END($1)\n" if ($dbg_values > 1);
1270
1271			$av_preprocessor = 1;
1272
1273			# Assume all arms of the conditional end as this
1274			# one does, and continue as if the #endif was not here.
1275			pop(@av_paren_type);
1276			push(@av_paren_type, $type);
1277			$type = 'E';
1278
1279		} elsif ($cur =~ /^(\\\n)/o) {
1280			print "PRECONT($1)\n" if ($dbg_values > 1);
1281
1282		} elsif ($cur =~ /^(__attribute__)\s*\(?/o) {
1283			print "ATTR($1)\n" if ($dbg_values > 1);
1284			$av_pending = $type;
1285			$type = 'N';
1286
1287		} elsif ($cur =~ /^(sizeof)\s*(\()?/o) {
1288			print "SIZEOF($1)\n" if ($dbg_values > 1);
1289			if (defined $2) {
1290				$av_pending = 'V';
1291			}
1292			$type = 'N';
1293
1294		} elsif ($cur =~ /^(if|while|for)\b/o) {
1295			print "COND($1)\n" if ($dbg_values > 1);
1296			$av_pending = 'E';
1297			$type = 'N';
1298
1299		} elsif ($cur =~/^(case)/o) {
1300			print "CASE($1)\n" if ($dbg_values > 1);
1301			$av_pend_colon = 'C';
1302			$type = 'N';
1303
1304		} elsif ($cur =~/^(return|else|goto|typeof|__typeof__)\b/o) {
1305			print "KEYWORD($1)\n" if ($dbg_values > 1);
1306			$type = 'N';
1307
1308		} elsif ($cur =~ /^(\()/o) {
1309			print "PAREN('$1')\n" if ($dbg_values > 1);
1310			push(@av_paren_type, $av_pending);
1311			$av_pending = '_';
1312			$type = 'N';
1313
1314		} elsif ($cur =~ /^(\))/o) {
1315			my $new_type = pop(@av_paren_type);
1316			if ($new_type ne '_') {
1317				$type = $new_type;
1318				print "PAREN('$1') -> $type\n"
1319							if ($dbg_values > 1);
1320			} else {
1321				print "PAREN('$1')\n" if ($dbg_values > 1);
1322			}
1323
1324		} elsif ($cur =~ /^($Ident)\s*\(/o) {
1325			print "FUNC($1)\n" if ($dbg_values > 1);
1326			$type = 'V';
1327			$av_pending = 'V';
1328
1329		} elsif ($cur =~ /^($Ident\s*):(?:\s*\d+\s*(,|=|;))?/) {
1330			if (defined $2 && $type eq 'C' || $type eq 'T') {
1331				$av_pend_colon = 'B';
1332			} elsif ($type eq 'E') {
1333				$av_pend_colon = 'L';
1334			}
1335			print "IDENT_COLON($1,$type>$av_pend_colon)\n" if ($dbg_values > 1);
1336			$type = 'V';
1337
1338		} elsif ($cur =~ /^($Ident|$Constant)/o) {
1339			print "IDENT($1)\n" if ($dbg_values > 1);
1340			$type = 'V';
1341
1342		} elsif ($cur =~ /^($Assignment)/o) {
1343			print "ASSIGN($1)\n" if ($dbg_values > 1);
1344			$type = 'N';
1345
1346		} elsif ($cur =~/^(;|{|})/) {
1347			print "END($1)\n" if ($dbg_values > 1);
1348			$type = 'E';
1349			$av_pend_colon = 'O';
1350
1351		} elsif ($cur =~/^(,)/) {
1352			print "COMMA($1)\n" if ($dbg_values > 1);
1353			$type = 'C';
1354
1355		} elsif ($cur =~ /^(\?)/o) {
1356			print "QUESTION($1)\n" if ($dbg_values > 1);
1357			$type = 'N';
1358
1359		} elsif ($cur =~ /^(:)/o) {
1360			print "COLON($1,$av_pend_colon)\n" if ($dbg_values > 1);
1361
1362			substr($var, length($res), 1, $av_pend_colon);
1363			if ($av_pend_colon eq 'C' || $av_pend_colon eq 'L') {
1364				$type = 'E';
1365			} else {
1366				$type = 'N';
1367			}
1368			$av_pend_colon = 'O';
1369
1370		} elsif ($cur =~ /^(\[)/o) {
1371			print "CLOSE($1)\n" if ($dbg_values > 1);
1372			$type = 'N';
1373
1374		} elsif ($cur =~ /^(-(?![->])|\+(?!\+)|\*|\&\&|\&)/o) {
1375			my $variant;
1376
1377			print "OPV($1)\n" if ($dbg_values > 1);
1378			if ($type eq 'V') {
1379				$variant = 'B';
1380			} else {
1381				$variant = 'U';
1382			}
1383
1384			substr($var, length($res), 1, $variant);
1385			$type = 'N';
1386
1387		} elsif ($cur =~ /^($Operators)/o) {
1388			print "OP($1)\n" if ($dbg_values > 1);
1389			if ($1 ne '++' && $1 ne '--') {
1390				$type = 'N';
1391			}
1392
1393		} elsif ($cur =~ /(^.)/o) {
1394			print "C($1)\n" if ($dbg_values > 1);
1395		}
1396		if (defined $1) {
1397			$cur = substr($cur, length($1));
1398			$res .= $type x length($1);
1399		}
1400	}
1401
1402	return ($res, $var);
1403}
1404
1405sub possible {
1406	my ($possible, $line) = @_;
1407	my $notPermitted = qr{(?:
1408		^(?:
1409			$Modifier|
1410			$Storage|
1411			$Type|
1412			DEFINE_\S+
1413		)$|
1414		^(?:
1415			goto|
1416			return|
1417			case|
1418			else|
1419			asm|__asm__|
1420			do|
1421			\#|
1422			\#\#|
1423		)(?:\s|$)|
1424		^(?:typedef|struct|enum)\b
1425	    )}x;
1426	warn "CHECK<$possible> ($line)\n" if ($dbg_possible > 2);
1427	if ($possible !~ $notPermitted) {
1428		# Check for modifiers.
1429		$possible =~ s/\s*$Storage\s*//g;
1430		$possible =~ s/\s*$Sparse\s*//g;
1431		if ($possible =~ /^\s*$/) {
1432
1433		} elsif ($possible =~ /\s/) {
1434			$possible =~ s/\s*$Type\s*//g;
1435			for my $modifier (split(' ', $possible)) {
1436				if ($modifier !~ $notPermitted) {
1437					warn "MODIFIER: $modifier ($possible) ($line)\n" if ($dbg_possible);
1438					push(@modifierList, $modifier);
1439				}
1440			}
1441
1442		} else {
1443			warn "POSSIBLE: $possible ($line)\n" if ($dbg_possible);
1444			push(@typeList, $possible);
1445		}
1446		build_types();
1447	} else {
1448		warn "NOTPOSS: $possible ($line)\n" if ($dbg_possible > 1);
1449	}
1450}
1451
1452my $prefix = '';
1453
1454sub show_type {
1455	my ($type) = @_;
1456
1457	return defined $use_type{$type} if (scalar keys %use_type > 0);
1458
1459	return !defined $ignore_type{$type};
1460}
1461
1462sub report {
1463	my ($level, $type, $msg) = @_;
1464
1465	if (!show_type($type) ||
1466	    (defined $tst_only && $msg !~ /\Q$tst_only\E/)) {
1467		return 0;
1468	}
1469	my $line;
1470	if ($show_types) {
1471		$line = "$prefix$level:$type: $msg\n";
1472	} else {
1473		$line = "$prefix$level: $msg\n";
1474	}
1475	$line = (split('\n', $line))[0] . "\n" if ($terse);
1476
1477	push(our @report, $line);
1478
1479	return 1;
1480}
1481
1482sub report_dump {
1483	our @report;
1484}
1485
1486sub ERROR {
1487	my ($type, $msg) = @_;
1488
1489	if (report("ERROR", $type, $msg)) {
1490		our $clean = 0;
1491		our $cnt_error++;
1492		return 1;
1493	}
1494	return 0;
1495}
1496sub WARN {
1497	my ($type, $msg) = @_;
1498
1499	if (report("WARNING", $type, $msg)) {
1500		our $clean = 0;
1501		our $cnt_warn++;
1502		return 1;
1503	}
1504	return 0;
1505}
1506sub CHK {
1507	my ($type, $msg) = @_;
1508
1509	if ($check && report("CHECK", $type, $msg)) {
1510		our $clean = 0;
1511		our $cnt_chk++;
1512		return 1;
1513	}
1514	return 0;
1515}
1516
1517sub check_absolute_file {
1518	my ($absolute, $herecurr) = @_;
1519	my $file = $absolute;
1520
1521	##print "absolute<$absolute>\n";
1522
1523	# See if any suffix of this path is a path within the tree.
1524	while ($file =~ s@^[^/]*/@@) {
1525		if (-f "$root/$file") {
1526			##print "file<$file>\n";
1527			last;
1528		}
1529	}
1530	if (! -f _)  {
1531		return 0;
1532	}
1533
1534	# It is, so see if the prefix is acceptable.
1535	my $prefix = $absolute;
1536	substr($prefix, -length($file)) = '';
1537
1538	##print "prefix<$prefix>\n";
1539	if ($prefix ne ".../") {
1540		WARN("USE_RELATIVE_PATH",
1541		     "use relative pathname instead of absolute in changelog text\n" . $herecurr);
1542	}
1543}
1544
1545sub trim {
1546	my ($string) = @_;
1547
1548	$string =~ s/^\s+|\s+$//g;
1549
1550	return $string;
1551}
1552
1553sub ltrim {
1554	my ($string) = @_;
1555
1556	$string =~ s/^\s+//;
1557
1558	return $string;
1559}
1560
1561sub rtrim {
1562	my ($string) = @_;
1563
1564	$string =~ s/\s+$//;
1565
1566	return $string;
1567}
1568
1569sub string_find_replace {
1570	my ($string, $find, $replace) = @_;
1571
1572	$string =~ s/$find/$replace/g;
1573
1574	return $string;
1575}
1576
1577sub tabify {
1578	my ($leading) = @_;
1579
1580	my $source_indent = 8;
1581	my $max_spaces_before_tab = $source_indent - 1;
1582	my $spaces_to_tab = " " x $source_indent;
1583
1584	#convert leading spaces to tabs
1585	1 while $leading =~ s@^([\t]*)$spaces_to_tab@$1\t@g;
1586	#Remove spaces before a tab
1587	1 while $leading =~ s@^([\t]*)( {1,$max_spaces_before_tab})\t@$1\t@g;
1588
1589	return "$leading";
1590}
1591
1592sub pos_last_openparen {
1593	my ($line) = @_;
1594
1595	my $pos = 0;
1596
1597	my $opens = $line =~ tr/\(/\(/;
1598	my $closes = $line =~ tr/\)/\)/;
1599
1600	my $last_openparen = 0;
1601
1602	if (($opens == 0) || ($closes >= $opens)) {
1603		return -1;
1604	}
1605
1606	my $len = length($line);
1607
1608	for ($pos = 0; $pos < $len; $pos++) {
1609		my $string = substr($line, $pos);
1610		if ($string =~ /^($FuncArg|$balanced_parens)/) {
1611			$pos += length($1) - 1;
1612		} elsif (substr($line, $pos, 1) eq '(') {
1613			$last_openparen = $pos;
1614		} elsif (index($string, '(') == -1) {
1615			last;
1616		}
1617	}
1618
1619	return length(expand_tabs(substr($line, 0, $last_openparen))) + 1;
1620}
1621
1622sub process {
1623	my $filename = shift;
1624
1625	my $linenr=0;
1626	my $prevline="";
1627	my $prevrawline="";
1628	my $stashline="";
1629	my $stashrawline="";
1630
1631	my $length;
1632	my $indent;
1633	my $previndent=0;
1634	my $stashindent=0;
1635
1636	our $clean = 1;
1637	my $signoff = 0;
1638	my $is_patch = 0;
1639
1640	my $in_header_lines = 1;
1641	my $in_commit_log = 0;		#Scanning lines before patch
1642
1643	my $non_utf8_charset = 0;
1644
1645	our @report = ();
1646	our $cnt_lines = 0;
1647	our $cnt_error = 0;
1648	our $cnt_warn = 0;
1649	our $cnt_chk = 0;
1650
1651	# Trace the real file/line as we go.
1652	my $realfile = '';
1653	my $realline = 0;
1654	my $realcnt = 0;
1655	my $here = '';
1656	my $in_comment = 0;
1657	my $comment_edge = 0;
1658	my $first_line = 0;
1659	my $p1_prefix = '';
1660
1661	my $prev_values = 'E';
1662
1663	# suppression flags
1664	my %suppress_ifbraces;
1665	my %suppress_whiletrailers;
1666	my %suppress_export;
1667	my $suppress_statement = 0;
1668
1669	my %signatures = ();
1670
1671	# Pre-scan the patch sanitizing the lines.
1672	# Pre-scan the patch looking for any __setup documentation.
1673	#
1674	my @setup_docs = ();
1675	my $setup_docs = 0;
1676
1677	my $camelcase_file_seeded = 0;
1678
1679	sanitise_line_reset();
1680	my $line;
1681	foreach my $rawline (@rawlines) {
1682		$linenr++;
1683		$line = $rawline;
1684
1685		push(@fixed, $rawline) if ($fix);
1686
1687		if ($rawline=~/^\+\+\+\s+(\S+)/) {
1688			$setup_docs = 0;
1689			if ($1 =~ m@Documentation/kernel-parameters.txt$@) {
1690				$setup_docs = 1;
1691			}
1692			#next;
1693		}
1694		if ($rawline=~/^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@/) {
1695			$realline=$1-1;
1696			if (defined $2) {
1697				$realcnt=$3+1;
1698			} else {
1699				$realcnt=1+1;
1700			}
1701			$in_comment = 0;
1702
1703			# Guestimate if this is a continuing comment.  Run
1704			# the context looking for a comment "edge".  If this
1705			# edge is a close comment then we must be in a comment
1706			# at context start.
1707			my $edge;
1708			my $cnt = $realcnt;
1709			for (my $ln = $linenr + 1; $cnt > 0; $ln++) {
1710				next if (defined $rawlines[$ln - 1] &&
1711					 $rawlines[$ln - 1] =~ /^-/);
1712				$cnt--;
1713				#print "RAW<$rawlines[$ln - 1]>\n";
1714				last if (!defined $rawlines[$ln - 1]);
1715				if ($rawlines[$ln - 1] =~ m@(/\*|\*/)@ &&
1716				    $rawlines[$ln - 1] !~ m@"[^"]*(?:/\*|\*/)[^"]*"@) {
1717					($edge) = $1;
1718					last;
1719				}
1720			}
1721			if (defined $edge && $edge eq '*/') {
1722				$in_comment = 1;
1723			}
1724
1725			# Guestimate if this is a continuing comment.  If this
1726			# is the start of a diff block and this line starts
1727			# ' *' then it is very likely a comment.
1728			if (!defined $edge &&
1729			    $rawlines[$linenr] =~ m@^.\s*(?:\*\*+| \*)(?:\s|$)@)
1730			{
1731				$in_comment = 1;
1732			}
1733
1734			##print "COMMENT:$in_comment edge<$edge> $rawline\n";
1735			sanitise_line_reset($in_comment);
1736
1737		} elsif ($realcnt && $rawline =~ /^(?:\+| |$)/) {
1738			# Standardise the strings and chars within the input to
1739			# simplify matching -- only bother with positive lines.
1740			$line = sanitise_line($rawline);
1741		}
1742		push(@lines, $line);
1743
1744		if ($realcnt > 1) {
1745			$realcnt-- if ($line =~ /^(?:\+| |$)/);
1746		} else {
1747			$realcnt = 0;
1748		}
1749
1750		#print "==>$rawline\n";
1751		#print "-->$line\n";
1752
1753		if ($setup_docs && $line =~ /^\+/) {
1754			push(@setup_docs, $line);
1755		}
1756	}
1757
1758	$prefix = '';
1759
1760	$realcnt = 0;
1761	$linenr = 0;
1762	foreach my $line (@lines) {
1763		$linenr++;
1764		my $sline = $line;	#copy of $line
1765		$sline =~ s/$;/ /g;	#with comments as spaces
1766
1767		my $rawline = $rawlines[$linenr - 1];
1768
1769#extract the line range in the file after the patch is applied
1770		if ($line=~/^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@/) {
1771			$is_patch = 1;
1772			$first_line = $linenr + 1;
1773			$realline=$1-1;
1774			if (defined $2) {
1775				$realcnt=$3+1;
1776			} else {
1777				$realcnt=1+1;
1778			}
1779			annotate_reset();
1780			$prev_values = 'E';
1781
1782			%suppress_ifbraces = ();
1783			%suppress_whiletrailers = ();
1784			%suppress_export = ();
1785			$suppress_statement = 0;
1786			next;
1787
1788# track the line number as we move through the hunk, note that
1789# new versions of GNU diff omit the leading space on completely
1790# blank context lines so we need to count that too.
1791		} elsif ($line =~ /^( |\+|$)/) {
1792			$realline++;
1793			$realcnt-- if ($realcnt != 0);
1794
1795			# Measure the line length and indent.
1796			($length, $indent) = line_stats($rawline);
1797
1798			# Track the previous line.
1799			($prevline, $stashline) = ($stashline, $line);
1800			($previndent, $stashindent) = ($stashindent, $indent);
1801			($prevrawline, $stashrawline) = ($stashrawline, $rawline);
1802
1803			#warn "line<$line>\n";
1804
1805		} elsif ($realcnt == 1) {
1806			$realcnt--;
1807		}
1808
1809		my $hunk_line = ($realcnt != 0);
1810
1811#make up the handle for any error we report on this line
1812		$prefix = "$filename:$realline: " if ($emacs && $file);
1813		$prefix = "$filename:$linenr: " if ($emacs && !$file);
1814
1815		$here = "#$linenr: " if (!$file);
1816		$here = "#$realline: " if ($file);
1817
1818		my $found_file = 0;
1819		# extract the filename as it passes
1820		if ($line =~ /^diff --git.*?(\S+)$/) {
1821			$realfile = $1;
1822			$realfile =~ s@^([^/]*)/@@ if (!$file);
1823			$in_commit_log = 0;
1824			$found_file = 1;
1825		} elsif ($line =~ /^\+\+\+\s+(\S+)/) {
1826			$realfile = $1;
1827			$realfile =~ s@^([^/]*)/@@ if (!$file);
1828			$in_commit_log = 0;
1829
1830			$p1_prefix = $1;
1831			if (!$file && $tree && $p1_prefix ne '' &&
1832			    -e "$root/$p1_prefix") {
1833				WARN("PATCH_PREFIX",
1834				     "patch prefix '$p1_prefix' exists, appears to be a -p0 patch\n");
1835			}
1836
1837			if ($realfile =~ m@^include/asm/@) {
1838				ERROR("MODIFIED_INCLUDE_ASM",
1839				      "do not modify files in include/asm, change architecture specific files in include/asm-<architecture>\n" . "$here$rawline\n");
1840			}
1841			$found_file = 1;
1842		}
1843
1844		if ($found_file) {
1845			if ($realfile =~ m@^(drivers/net/|net/)@) {
1846				$check = 1;
1847			} else {
1848				$check = $check_orig;
1849			}
1850			next;
1851		}
1852
1853		$here .= "FILE: $realfile:$realline:" if ($realcnt != 0);
1854
1855		my $hereline = "$here\n$rawline\n";
1856		my $herecurr = "$here\n$rawline\n";
1857		my $hereprev = "$here\n$prevrawline\n$rawline\n";
1858
1859		$cnt_lines++ if ($realcnt != 0);
1860
1861# Check for incorrect file permissions
1862		if ($line =~ /^new (file )?mode.*[7531]\d{0,2}$/) {
1863			my $permhere = $here . "FILE: $realfile\n";
1864			if ($realfile !~ m@scripts/@ &&
1865			    $realfile !~ /\.(py|pl|awk|sh)$/) {
1866				ERROR("EXECUTE_PERMISSIONS",
1867				      "do not set execute permissions for source files\n" . $permhere);
1868			}
1869		}
1870
1871# Check the patch for a signoff:
1872		if ($line =~ /^\s*signed-off-by:/i) {
1873			$signoff++;
1874			$in_commit_log = 0;
1875		}
1876
1877# Check signature styles
1878		if (!$in_header_lines &&
1879		    $line =~ /^(\s*)([a-z0-9_-]+by:|$signature_tags)(\s*)(.*)/i) {
1880			my $space_before = $1;
1881			my $sign_off = $2;
1882			my $space_after = $3;
1883			my $email = $4;
1884			my $ucfirst_sign_off = ucfirst(lc($sign_off));
1885
1886			if ($sign_off !~ /$signature_tags/) {
1887				WARN("BAD_SIGN_OFF",
1888				     "Non-standard signature: $sign_off\n" . $herecurr);
1889			}
1890			if (defined $space_before && $space_before ne "") {
1891				if (WARN("BAD_SIGN_OFF",
1892					 "Do not use whitespace before $ucfirst_sign_off\n" . $herecurr) &&
1893				    $fix) {
1894					$fixed[$linenr - 1] =
1895					    "$ucfirst_sign_off $email";
1896				}
1897			}
1898			if ($sign_off =~ /-by:$/i && $sign_off ne $ucfirst_sign_off) {
1899				if (WARN("BAD_SIGN_OFF",
1900					 "'$ucfirst_sign_off' is the preferred signature form\n" . $herecurr) &&
1901				    $fix) {
1902					$fixed[$linenr - 1] =
1903					    "$ucfirst_sign_off $email";
1904				}
1905
1906			}
1907			if (!defined $space_after || $space_after ne " ") {
1908				if (WARN("BAD_SIGN_OFF",
1909					 "Use a single space after $ucfirst_sign_off\n" . $herecurr) &&
1910				    $fix) {
1911					$fixed[$linenr - 1] =
1912					    "$ucfirst_sign_off $email";
1913				}
1914			}
1915
1916			my ($email_name, $email_address, $comment) = parse_email($email);
1917			my $suggested_email = format_email(($email_name, $email_address));
1918			if ($suggested_email eq "") {
1919				ERROR("BAD_SIGN_OFF",
1920				      "Unrecognized email address: '$email'\n" . $herecurr);
1921			} else {
1922				my $dequoted = $suggested_email;
1923				$dequoted =~ s/^"//;
1924				$dequoted =~ s/" </ </;
1925				# Don't force email to have quotes
1926				# Allow just an angle bracketed address
1927				if ("$dequoted$comment" ne $email &&
1928				    "<$email_address>$comment" ne $email &&
1929				    "$suggested_email$comment" ne $email) {
1930					WARN("BAD_SIGN_OFF",
1931					     "email address '$email' might be better as '$suggested_email$comment'\n" . $herecurr);
1932				}
1933			}
1934
1935# Check for duplicate signatures
1936			my $sig_nospace = $line;
1937			$sig_nospace =~ s/\s//g;
1938			$sig_nospace = lc($sig_nospace);
1939			if (defined $signatures{$sig_nospace}) {
1940				WARN("BAD_SIGN_OFF",
1941				     "Duplicate signature\n" . $herecurr);
1942			} else {
1943				$signatures{$sig_nospace} = 1;
1944			}
1945		}
1946
1947# Check for old stable address
1948		if ($line =~ /^\s*cc:\s*.*<?\bstable\@kernel\.org\b>?.*$/i) {
1949			ERROR("STABLE_ADDRESS",
1950			      "The 'stable' address should be 'stable\@vger.kernel.org'\n" . $herecurr);
1951		}
1952
1953# Check for unwanted Gerrit info
1954		if ($in_commit_log && $line =~ /^\s*change-id:/i) {
1955			ERROR("GERRIT_CHANGE_ID",
1956			      "Remove Gerrit Change-Id's before submitting upstream.\n" . $herecurr);
1957		}
1958
1959# Check for wrappage within a valid hunk of the file
1960		if ($realcnt != 0 && $line !~ m{^(?:\+|-| |\\ No newline|$)}) {
1961			ERROR("CORRUPTED_PATCH",
1962			      "patch seems to be corrupt (line wrapped?)\n" .
1963				$herecurr) if (!$emitted_corrupt++);
1964		}
1965
1966# Check for absolute kernel paths.
1967		if ($tree) {
1968			while ($line =~ m{(?:^|\s)(/\S*)}g) {
1969				my $file = $1;
1970
1971				if ($file =~ m{^(.*?)(?::\d+)+:?$} &&
1972				    check_absolute_file($1, $herecurr)) {
1973					#
1974				} else {
1975					check_absolute_file($file, $herecurr);
1976				}
1977			}
1978		}
1979
1980# UTF-8 regex found at http://www.w3.org/International/questions/qa-forms-utf-8.en.php
1981		if (($realfile =~ /^$/ || $line =~ /^\+/) &&
1982		    $rawline !~ m/^$UTF8*$/) {
1983			my ($utf8_prefix) = ($rawline =~ /^($UTF8*)/);
1984
1985			my $blank = copy_spacing($rawline);
1986			my $ptr = substr($blank, 0, length($utf8_prefix)) . "^";
1987			my $hereptr = "$hereline$ptr\n";
1988
1989			CHK("INVALID_UTF8",
1990			    "Invalid UTF-8, patch and commit message should be encoded in UTF-8\n" . $hereptr);
1991		}
1992
1993# Check if it's the start of a commit log
1994# (not a header line and we haven't seen the patch filename)
1995		if ($in_header_lines && $realfile =~ /^$/ &&
1996		    $rawline !~ /^(commit\b|from\b|[\w-]+:).+$/i) {
1997			$in_header_lines = 0;
1998			$in_commit_log = 1;
1999		}
2000
2001# Check if there is UTF-8 in a commit log when a mail header has explicitly
2002# declined it, i.e defined some charset where it is missing.
2003		if ($in_header_lines &&
2004		    $rawline =~ /^Content-Type:.+charset="(.+)".*$/ &&
2005		    $1 !~ /utf-8/i) {
2006			$non_utf8_charset = 1;
2007		}
2008
2009		if ($in_commit_log && $non_utf8_charset && $realfile =~ /^$/ &&
2010		    $rawline =~ /$NON_ASCII_UTF8/) {
2011			WARN("UTF8_BEFORE_PATCH",
2012			    "8-bit UTF-8 used in possible commit log\n" . $herecurr);
2013		}
2014
2015# ignore non-hunk lines and lines being removed
2016		next if (!$hunk_line || $line =~ /^-/);
2017
2018#trailing whitespace
2019		if ($line =~ /^\+.*\015/) {
2020			my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2021			if (ERROR("DOS_LINE_ENDINGS",
2022				  "DOS line endings\n" . $herevet) &&
2023			    $fix) {
2024				$fixed[$linenr - 1] =~ s/[\s\015]+$//;
2025			}
2026		} elsif ($rawline =~ /^\+.*\S\s+$/ || $rawline =~ /^\+\s+$/) {
2027			my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2028			if (ERROR("TRAILING_WHITESPACE",
2029				  "trailing whitespace\n" . $herevet) &&
2030			    $fix) {
2031				$fixed[$linenr - 1] =~ s/\s+$//;
2032			}
2033
2034			$rpt_cleaners = 1;
2035		}
2036
2037# Check for FSF mailing addresses.
2038		if ($rawline =~ /\bwrite to the Free/i ||
2039		    $rawline =~ /\b59\s+Temple\s+Pl/i ||
2040		    $rawline =~ /\b51\s+Franklin\s+St/i) {
2041			my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2042			my $msg_type = \&ERROR;
2043			$msg_type = \&CHK if ($file);
2044			&{$msg_type}("FSF_MAILING_ADDRESS",
2045				     "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)
2046		}
2047
2048# check for Kconfig help text having a real description
2049# Only applies when adding the entry originally, after that we do not have
2050# sufficient context to determine whether it is indeed long enough.
2051		if ($realfile =~ /Kconfig/ &&
2052		    $line =~ /.\s*config\s+/) {
2053			my $length = 0;
2054			my $cnt = $realcnt;
2055			my $ln = $linenr + 1;
2056			my $f;
2057			my $is_start = 0;
2058			my $is_end = 0;
2059			for (; $cnt > 0 && defined $lines[$ln - 1]; $ln++) {
2060				$f = $lines[$ln - 1];
2061				$cnt-- if ($lines[$ln - 1] !~ /^-/);
2062				$is_end = $lines[$ln - 1] =~ /^\+/;
2063
2064				next if ($f =~ /^-/);
2065
2066				if ($lines[$ln - 1] =~ /.\s*(?:bool|tristate)\s*\"/) {
2067					$is_start = 1;
2068				} elsif ($lines[$ln - 1] =~ /.\s*(?:---)?help(?:---)?$/) {
2069					$length = -1;
2070				}
2071
2072				$f =~ s/^.//;
2073				$f =~ s/#.*//;
2074				$f =~ s/^\s+//;
2075				next if ($f =~ /^$/);
2076				if ($f =~ /^\s*config\s/) {
2077					$is_end = 1;
2078					last;
2079				}
2080				$length++;
2081			}
2082			WARN("CONFIG_DESCRIPTION",
2083			     "please write a paragraph that describes the config symbol fully\n" . $herecurr) if ($is_start && $is_end && $length < 4);
2084			#print "is_start<$is_start> is_end<$is_end> length<$length>\n";
2085		}
2086
2087# discourage the addition of CONFIG_EXPERIMENTAL in Kconfig.
2088		if ($realfile =~ /Kconfig/ &&
2089		    $line =~ /.\s*depends on\s+.*\bEXPERIMENTAL\b/) {
2090			WARN("CONFIG_EXPERIMENTAL",
2091			     "Use of CONFIG_EXPERIMENTAL is deprecated. For alternatives, see https://lkml.org/lkml/2012/10/23/580\n");
2092		}
2093
2094		if (($realfile =~ /Makefile.*/ || $realfile =~ /Kbuild.*/) &&
2095		    ($line =~ /\+(EXTRA_[A-Z]+FLAGS).*/)) {
2096			my $flag = $1;
2097			my $replacement = {
2098				'EXTRA_AFLAGS' =>   'asflags-y',
2099				'EXTRA_CFLAGS' =>   'ccflags-y',
2100				'EXTRA_CPPFLAGS' => 'cppflags-y',
2101				'EXTRA_LDFLAGS' =>  'ldflags-y',
2102			};
2103
2104			WARN("DEPRECATED_VARIABLE",
2105			     "Use of $flag is deprecated, please use \`$replacement->{$flag} instead.\n" . $herecurr) if ($replacement->{$flag});
2106		}
2107
2108# check for DT compatible documentation
2109		if (defined $root &&
2110			(($realfile =~ /\.dtsi?$/ && $line =~ /^\+\s*compatible\s*=\s*\"/) ||
2111			 ($realfile =~ /\.[ch]$/ && $line =~ /^\+.*\.compatible\s*=\s*\"/))) {
2112
2113			my @compats = $rawline =~ /\"([a-zA-Z0-9\-\,\.\+_]+)\"/g;
2114
2115			my $dt_path = $root . "/Documentation/devicetree/bindings/";
2116			my $vp_file = $dt_path . "vendor-prefixes.txt";
2117
2118			foreach my $compat (@compats) {
2119				my $compat2 = $compat;
2120				$compat2 =~ s/\,[a-zA-Z0-9]*\-/\,<\.\*>\-/;
2121				my $compat3 = $compat;
2122				$compat3 =~ s/\,([a-z]*)[0-9]*\-/\,$1<\.\*>\-/;
2123				`grep -Erq "$compat|$compat2|$compat3" $dt_path`;
2124				if ( $? >> 8 ) {
2125					WARN("UNDOCUMENTED_DT_STRING",
2126					     "DT compatible string \"$compat\" appears un-documented -- check $dt_path\n" . $herecurr);
2127				}
2128
2129				next if $compat !~ /^([a-zA-Z0-9\-]+)\,/;
2130				my $vendor = $1;
2131				`grep -Eq "^$vendor\\b" $vp_file`;
2132				if ( $? >> 8 ) {
2133					WARN("UNDOCUMENTED_DT_STRING",
2134					     "DT compatible string vendor \"$vendor\" appears un-documented -- check $vp_file\n" . $herecurr);
2135				}
2136			}
2137		}
2138
2139# check we are in a valid source file if not then ignore this hunk
2140		next if ($realfile !~ /\.(h|c|s|S|pl|sh)$/);
2141
2142#line length limit
2143		if ($line =~ /^\+/ && $prevrawline !~ /\/\*\*/ &&
2144		    $rawline !~ /^.\s*\*\s*\@$Ident\s/ &&
2145		    !($line =~ /^\+\s*$logFunctions\s*\(\s*(?:(KERN_\S+\s*|[^"]*))?"[X\t]*"\s*(?:|,|\)\s*;)\s*$/ ||
2146		    $line =~ /^\+\s*"[^"]*"\s*(?:\s*|,|\)\s*;)\s*$/) &&
2147		    $length > $max_line_length)
2148		{
2149			WARN("LONG_LINE",
2150			     "line over $max_line_length characters\n" . $herecurr);
2151		}
2152
2153# Check for user-visible strings broken across lines, which breaks the ability
2154# to grep for the string.  Make exceptions when the previous string ends in a
2155# newline (multiple lines in one string constant) or '\t', '\r', ';', or '{'
2156# (common in inline assembly) or is a octal \123 or hexadecimal \xaf value
2157		if ($line =~ /^\+\s*"/ &&
2158		    $prevline =~ /"\s*$/ &&
2159		    $prevrawline !~ /(?:\\(?:[ntr]|[0-7]{1,3}|x[0-9a-fA-F]{1,2})|;\s*|\{\s*)"\s*$/) {
2160			WARN("SPLIT_STRING",
2161			     "quoted string split across lines\n" . $hereprev);
2162		}
2163
2164# check for spaces before a quoted newline
2165		if ($rawline =~ /^.*\".*\s\\n/) {
2166			if (WARN("QUOTED_WHITESPACE_BEFORE_NEWLINE",
2167				 "unnecessary whitespace before a quoted newline\n" . $herecurr) &&
2168			    $fix) {
2169				$fixed[$linenr - 1] =~ s/^(\+.*\".*)\s+\\n/$1\\n/;
2170			}
2171
2172		}
2173
2174# check for adding lines without a newline.
2175		if ($line =~ /^\+/ && defined $lines[$linenr] && $lines[$linenr] =~ /^\\ No newline at end of file/) {
2176			WARN("MISSING_EOF_NEWLINE",
2177			     "adding a line without newline at end of file\n" . $herecurr);
2178		}
2179
2180# Blackfin: use hi/lo macros
2181		if ($realfile =~ m@arch/blackfin/.*\.S$@) {
2182			if ($line =~ /\.[lL][[:space:]]*=.*&[[:space:]]*0x[fF][fF][fF][fF]/) {
2183				my $herevet = "$here\n" . cat_vet($line) . "\n";
2184				ERROR("LO_MACRO",
2185				      "use the LO() macro, not (... & 0xFFFF)\n" . $herevet);
2186			}
2187			if ($line =~ /\.[hH][[:space:]]*=.*>>[[:space:]]*16/) {
2188				my $herevet = "$here\n" . cat_vet($line) . "\n";
2189				ERROR("HI_MACRO",
2190				      "use the HI() macro, not (... >> 16)\n" . $herevet);
2191			}
2192		}
2193
2194# check we are in a valid source file C or perl if not then ignore this hunk
2195		next if ($realfile !~ /\.(h|c|pl)$/);
2196
2197# at the beginning of a line any tabs must come first and anything
2198# more than 8 must use tabs.
2199		if ($rawline =~ /^\+\s* \t\s*\S/ ||
2200		    $rawline =~ /^\+\s*        \s*/) {
2201			my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2202			$rpt_cleaners = 1;
2203			if (ERROR("CODE_INDENT",
2204				  "code indent should use tabs where possible\n" . $herevet) &&
2205			    $fix) {
2206				$fixed[$linenr - 1] =~ s/^\+([ \t]+)/"\+" . tabify($1)/e;
2207			}
2208		}
2209
2210# check for space before tabs.
2211		if ($rawline =~ /^\+/ && $rawline =~ / \t/) {
2212			my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2213			if (WARN("SPACE_BEFORE_TAB",
2214				"please, no space before tabs\n" . $herevet) &&
2215			    $fix) {
2216				while ($fixed[$linenr - 1] =~
2217					   s/(^\+.*) {8,8}+\t/$1\t\t/) {}
2218				while ($fixed[$linenr - 1] =~
2219					   s/(^\+.*) +\t/$1\t/) {}
2220			}
2221		}
2222
2223# check for && or || at the start of a line
2224		if ($rawline =~ /^\+\s*(&&|\|\|)/) {
2225			CHK("LOGICAL_CONTINUATIONS",
2226			    "Logical continuations should be on the previous line\n" . $hereprev);
2227		}
2228
2229# check multi-line statement indentation matches previous line
2230		if ($^V && $^V ge 5.10.0 &&
2231		    $prevline =~ /^\+([ \t]*)((?:$c90_Keywords(?:\s+if)\s*)|(?:$Declare\s*)?(?:$Ident|\(\s*\*\s*$Ident\s*\))\s*|$Ident\s*=\s*$Ident\s*)\(.*(\&\&|\|\||,)\s*$/) {
2232			$prevline =~ /^\+(\t*)(.*)$/;
2233			my $oldindent = $1;
2234			my $rest = $2;
2235
2236			my $pos = pos_last_openparen($rest);
2237			if ($pos >= 0) {
2238				$line =~ /^(\+| )([ \t]*)/;
2239				my $newindent = $2;
2240
2241				my $goodtabindent = $oldindent .
2242					"\t" x ($pos / 8) .
2243					" "  x ($pos % 8);
2244				my $goodspaceindent = $oldindent . " "  x $pos;
2245
2246				if ($newindent ne $goodtabindent &&
2247				    $newindent ne $goodspaceindent) {
2248
2249					if (CHK("PARENTHESIS_ALIGNMENT",
2250						"Alignment should match open parenthesis\n" . $hereprev) &&
2251					    $fix && $line =~ /^\+/) {
2252						$fixed[$linenr - 1] =~
2253						    s/^\+[ \t]*/\+$goodtabindent/;
2254					}
2255				}
2256			}
2257		}
2258
2259		if ($line =~ /^\+.*\*[ \t]*\)[ \t]+(?!$Assignment|$Arithmetic)/) {
2260			if (CHK("SPACING",
2261				"No space is necessary after a cast\n" . $hereprev) &&
2262			    $fix) {
2263				$fixed[$linenr - 1] =~
2264				    s/^(\+.*\*[ \t]*\))[ \t]+/$1/;
2265			}
2266		}
2267
2268		if ($realfile =~ m@^(drivers/net/|net/)@ &&
2269		    $prevrawline =~ /^\+[ \t]*\/\*[ \t]*$/ &&
2270		    $rawline =~ /^\+[ \t]*\*/ &&
2271		    $realline > 2) {
2272			WARN("NETWORKING_BLOCK_COMMENT_STYLE",
2273			     "networking block comments don't use an empty /* line, use /* Comment...\n" . $hereprev);
2274		}
2275
2276		if ($realfile =~ m@^(drivers/net/|net/)@ &&
2277		    $prevrawline =~ /^\+[ \t]*\/\*/ &&		#starting /*
2278		    $prevrawline !~ /\*\/[ \t]*$/ &&		#no trailing */
2279		    $rawline =~ /^\+/ &&			#line is new
2280		    $rawline !~ /^\+[ \t]*\*/) {		#no leading *
2281			WARN("NETWORKING_BLOCK_COMMENT_STYLE",
2282			     "networking block comments start with * on subsequent lines\n" . $hereprev);
2283		}
2284
2285		if ($realfile =~ m@^(drivers/net/|net/)@ &&
2286		    $rawline !~ m@^\+[ \t]*\*/[ \t]*$@ &&	#trailing */
2287		    $rawline !~ m@^\+.*/\*.*\*/[ \t]*$@ &&	#inline /*...*/
2288		    $rawline !~ m@^\+.*\*{2,}/[ \t]*$@ &&	#trailing **/
2289		    $rawline =~ m@^\+[ \t]*.+\*\/[ \t]*$@) {	#non blank */
2290			WARN("NETWORKING_BLOCK_COMMENT_STYLE",
2291			     "networking block comments put the trailing */ on a separate line\n" . $herecurr);
2292		}
2293
2294# check for missing blank lines after declarations
2295		if ($sline =~ /^\+\s+\S/ &&			#Not at char 1
2296			# actual declarations
2297		    ($prevline =~ /^\+\s+$Declare\s*$Ident\s*[=,;:\[]/ ||
2298			# foo bar; where foo is some local typedef or #define
2299		     $prevline =~ /^\+\s+$Ident(?:\s+|\s*\*\s*)$Ident\s*[=,;\[]/ ||
2300			# known declaration macros
2301		     $prevline =~ /^\+\s+$declaration_macros/) &&
2302			# for "else if" which can look like "$Ident $Ident"
2303		    !($prevline =~ /^\+\s+$c90_Keywords\b/ ||
2304			# other possible extensions of declaration lines
2305		      $prevline =~ /(?:$Compare|$Assignment|$Operators)\s*$/ ||
2306			# not starting a section or a macro "\" extended line
2307		      $prevline =~ /(?:\{\s*|\\)$/) &&
2308			# looks like a declaration
2309		    !($sline =~ /^\+\s+$Declare\s*$Ident\s*[=,;:\[]/ ||
2310			# foo bar; where foo is some local typedef or #define
2311		      $sline =~ /^\+\s+$Ident(?:\s+|\s*\*\s*)$Ident\s*[=,;\[]/ ||
2312			# known declaration macros
2313		      $sline =~ /^\+\s+$declaration_macros/ ||
2314			# start of struct or union or enum
2315		      $sline =~ /^\+\s+(?:union|struct|enum|typedef)\b/ ||
2316			# start or end of block or continuation of declaration
2317		      $sline =~ /^\+\s+(?:$|[\{\}\.\#\"\?\:\(\[])/ ||
2318			# bitfield continuation
2319		      $sline =~ /^\+\s+$Ident\s*:\s*\d+\s*[,;]/ ||
2320			# other possible extensions of declaration lines
2321		      $sline =~ /^\+\s+\(?\s*(?:$Compare|$Assignment|$Operators)/) &&
2322			# indentation of previous and current line are the same
2323		    (($prevline =~ /\+(\s+)\S/) && $sline =~ /^\+$1\S/)) {
2324			WARN("SPACING",
2325			     "Missing a blank line after declarations\n" . $hereprev);
2326		}
2327
2328# check for spaces at the beginning of a line.
2329# Exceptions:
2330#  1) within comments
2331#  2) indented preprocessor commands
2332#  3) hanging labels
2333		if ($rawline =~ /^\+ / && $line !~ /^\+ *(?:$;|#|$Ident:)/)  {
2334			my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2335			if (WARN("LEADING_SPACE",
2336				 "please, no spaces at the start of a line\n" . $herevet) &&
2337			    $fix) {
2338				$fixed[$linenr - 1] =~ s/^\+([ \t]+)/"\+" . tabify($1)/e;
2339			}
2340		}
2341
2342# check we are in a valid C source file if not then ignore this hunk
2343		next if ($realfile !~ /\.(h|c)$/);
2344
2345# discourage the addition of CONFIG_EXPERIMENTAL in #if(def).
2346		if ($line =~ /^\+\s*\#\s*if.*\bCONFIG_EXPERIMENTAL\b/) {
2347			WARN("CONFIG_EXPERIMENTAL",
2348			     "Use of CONFIG_EXPERIMENTAL is deprecated. For alternatives, see https://lkml.org/lkml/2012/10/23/580\n");
2349		}
2350
2351# check for RCS/CVS revision markers
2352		if ($rawline =~ /^\+.*\$(Revision|Log|Id)(?:\$|)/) {
2353			WARN("CVS_KEYWORD",
2354			     "CVS style keyword markers, these will _not_ be updated\n". $herecurr);
2355		}
2356
2357# Blackfin: don't use __builtin_bfin_[cs]sync
2358		if ($line =~ /__builtin_bfin_csync/) {
2359			my $herevet = "$here\n" . cat_vet($line) . "\n";
2360			ERROR("CSYNC",
2361			      "use the CSYNC() macro in asm/blackfin.h\n" . $herevet);
2362		}
2363		if ($line =~ /__builtin_bfin_ssync/) {
2364			my $herevet = "$here\n" . cat_vet($line) . "\n";
2365			ERROR("SSYNC",
2366			      "use the SSYNC() macro in asm/blackfin.h\n" . $herevet);
2367		}
2368
2369# check for old HOTPLUG __dev<foo> section markings
2370		if ($line =~ /\b(__dev(init|exit)(data|const|))\b/) {
2371			WARN("HOTPLUG_SECTION",
2372			     "Using $1 is unnecessary\n" . $herecurr);
2373		}
2374
2375# Check for potential 'bare' types
2376		my ($stat, $cond, $line_nr_next, $remain_next, $off_next,
2377		    $realline_next);
2378#print "LINE<$line>\n";
2379		if ($linenr >= $suppress_statement &&
2380		    $realcnt && $sline =~ /.\s*\S/) {
2381			($stat, $cond, $line_nr_next, $remain_next, $off_next) =
2382				ctx_statement_block($linenr, $realcnt, 0);
2383			$stat =~ s/\n./\n /g;
2384			$cond =~ s/\n./\n /g;
2385
2386#print "linenr<$linenr> <$stat>\n";
2387			# If this statement has no statement boundaries within
2388			# it there is no point in retrying a statement scan
2389			# until we hit end of it.
2390			my $frag = $stat; $frag =~ s/;+\s*$//;
2391			if ($frag !~ /(?:{|;)/) {
2392#print "skip<$line_nr_next>\n";
2393				$suppress_statement = $line_nr_next;
2394			}
2395
2396			# Find the real next line.
2397			$realline_next = $line_nr_next;
2398			if (defined $realline_next &&
2399			    (!defined $lines[$realline_next - 1] ||
2400			     substr($lines[$realline_next - 1], $off_next) =~ /^\s*$/)) {
2401				$realline_next++;
2402			}
2403
2404			my $s = $stat;
2405			$s =~ s/{.*$//s;
2406
2407			# Ignore goto labels.
2408			if ($s =~ /$Ident:\*$/s) {
2409
2410			# Ignore functions being called
2411			} elsif ($s =~ /^.\s*$Ident\s*\(/s) {
2412
2413			} elsif ($s =~ /^.\s*else\b/s) {
2414
2415			# declarations always start with types
2416			} 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) {
2417				my $type = $1;
2418				$type =~ s/\s+/ /g;
2419				possible($type, "A:" . $s);
2420
2421			# definitions in global scope can only start with types
2422			} elsif ($s =~ /^.(?:$Storage\s+)?(?:$Inline\s+)?(?:const\s+)?($Ident)\b\s*(?!:)/s) {
2423				possible($1, "B:" . $s);
2424			}
2425
2426			# any (foo ... *) is a pointer cast, and foo is a type
2427			while ($s =~ /\(($Ident)(?:\s+$Sparse)*[\s\*]+\s*\)/sg) {
2428				possible($1, "C:" . $s);
2429			}
2430
2431			# Check for any sort of function declaration.
2432			# int foo(something bar, other baz);
2433			# void (*store_gdt)(x86_descr_ptr *);
2434			if ($prev_values eq 'E' && $s =~ /^(.(?:typedef\s*)?(?:(?:$Storage|$Inline)\s*)*\s*$Type\s*(?:\b$Ident|\(\*\s*$Ident\))\s*)\(/s) {
2435				my ($name_len) = length($1);
2436
2437				my $ctx = $s;
2438				substr($ctx, 0, $name_len + 1, '');
2439				$ctx =~ s/\)[^\)]*$//;
2440
2441				for my $arg (split(/\s*,\s*/, $ctx)) {
2442					if ($arg =~ /^(?:const\s+)?($Ident)(?:\s+$Sparse)*\s*\**\s*(:?\b$Ident)?$/s || $arg =~ /^($Ident)$/s) {
2443
2444						possible($1, "D:" . $s);
2445					}
2446				}
2447			}
2448
2449		}
2450
2451#
2452# Checks which may be anchored in the context.
2453#
2454
2455# Check for switch () and associated case and default
2456# statements should be at the same indent.
2457		if ($line=~/\bswitch\s*\(.*\)/) {
2458			my $err = '';
2459			my $sep = '';
2460			my @ctx = ctx_block_outer($linenr, $realcnt);
2461			shift(@ctx);
2462			for my $ctx (@ctx) {
2463				my ($clen, $cindent) = line_stats($ctx);
2464				if ($ctx =~ /^\+\s*(case\s+|default:)/ &&
2465							$indent != $cindent) {
2466					$err .= "$sep$ctx\n";
2467					$sep = '';
2468				} else {
2469					$sep = "[...]\n";
2470				}
2471			}
2472			if ($err ne '') {
2473				ERROR("SWITCH_CASE_INDENT_LEVEL",
2474				      "switch and case should be at the same indent\n$hereline$err");
2475			}
2476		}
2477
2478# if/while/etc brace do not go on next line, unless defining a do while loop,
2479# or if that brace on the next line is for something else
2480		if ($line =~ /(.*)\b((?:if|while|for|switch)\s*\(|do\b|else\b)/ && $line !~ /^.\s*\#/) {
2481			my $pre_ctx = "$1$2";
2482
2483			my ($level, @ctx) = ctx_statement_level($linenr, $realcnt, 0);
2484
2485			if ($line =~ /^\+\t{6,}/) {
2486				WARN("DEEP_INDENTATION",
2487				     "Too many leading tabs - consider code refactoring\n" . $herecurr);
2488			}
2489
2490			my $ctx_cnt = $realcnt - $#ctx - 1;
2491			my $ctx = join("\n", @ctx);
2492
2493			my $ctx_ln = $linenr;
2494			my $ctx_skip = $realcnt;
2495
2496			while ($ctx_skip > $ctx_cnt || ($ctx_skip == $ctx_cnt &&
2497					defined $lines[$ctx_ln - 1] &&
2498					$lines[$ctx_ln - 1] =~ /^-/)) {
2499				##print "SKIP<$ctx_skip> CNT<$ctx_cnt>\n";
2500				$ctx_skip-- if (!defined $lines[$ctx_ln - 1] || $lines[$ctx_ln - 1] !~ /^-/);
2501				$ctx_ln++;
2502			}
2503
2504			#print "realcnt<$realcnt> ctx_cnt<$ctx_cnt>\n";
2505			#print "pre<$pre_ctx>\nline<$line>\nctx<$ctx>\nnext<$lines[$ctx_ln - 1]>\n";
2506
2507			if ($ctx !~ /{\s*/ && defined($lines[$ctx_ln -1]) && $lines[$ctx_ln - 1] =~ /^\+\s*{/) {
2508				ERROR("OPEN_BRACE",
2509				      "that open brace { should be on the previous line\n" .
2510					"$here\n$ctx\n$rawlines[$ctx_ln - 1]\n");
2511			}
2512			if ($level == 0 && $pre_ctx !~ /}\s*while\s*\($/ &&
2513			    $ctx =~ /\)\s*\;\s*$/ &&
2514			    defined $lines[$ctx_ln - 1])
2515			{
2516				my ($nlength, $nindent) = line_stats($lines[$ctx_ln - 1]);
2517				if ($nindent > $indent) {
2518					WARN("TRAILING_SEMICOLON",
2519					     "trailing semicolon indicates no statements, indent implies otherwise\n" .
2520						"$here\n$ctx\n$rawlines[$ctx_ln - 1]\n");
2521				}
2522			}
2523		}
2524
2525# Check relative indent for conditionals and blocks.
2526		if ($line =~ /\b(?:(?:if|while|for)\s*\(|do\b)/ && $line !~ /^.\s*#/ && $line !~ /\}\s*while\s*/) {
2527			($stat, $cond, $line_nr_next, $remain_next, $off_next) =
2528				ctx_statement_block($linenr, $realcnt, 0)
2529					if (!defined $stat);
2530			my ($s, $c) = ($stat, $cond);
2531
2532			substr($s, 0, length($c), '');
2533
2534			# Make sure we remove the line prefixes as we have
2535			# none on the first line, and are going to readd them
2536			# where necessary.
2537			$s =~ s/\n./\n/gs;
2538
2539			# Find out how long the conditional actually is.
2540			my @newlines = ($c =~ /\n/gs);
2541			my $cond_lines = 1 + $#newlines;
2542
2543			# We want to check the first line inside the block
2544			# starting at the end of the conditional, so remove:
2545			#  1) any blank line termination
2546			#  2) any opening brace { on end of the line
2547			#  3) any do (...) {
2548			my $continuation = 0;
2549			my $check = 0;
2550			$s =~ s/^.*\bdo\b//;
2551			$s =~ s/^\s*{//;
2552			if ($s =~ s/^\s*\\//) {
2553				$continuation = 1;
2554			}
2555			if ($s =~ s/^\s*?\n//) {
2556				$check = 1;
2557				$cond_lines++;
2558			}
2559
2560			# Also ignore a loop construct at the end of a
2561			# preprocessor statement.
2562			if (($prevline =~ /^.\s*#\s*define\s/ ||
2563			    $prevline =~ /\\\s*$/) && $continuation == 0) {
2564				$check = 0;
2565			}
2566
2567			my $cond_ptr = -1;
2568			$continuation = 0;
2569			while ($cond_ptr != $cond_lines) {
2570				$cond_ptr = $cond_lines;
2571
2572				# If we see an #else/#elif then the code
2573				# is not linear.
2574				if ($s =~ /^\s*\#\s*(?:else|elif)/) {
2575					$check = 0;
2576				}
2577
2578				# Ignore:
2579				#  1) blank lines, they should be at 0,
2580				#  2) preprocessor lines, and
2581				#  3) labels.
2582				if ($continuation ||
2583				    $s =~ /^\s*?\n/ ||
2584				    $s =~ /^\s*#\s*?/ ||
2585				    $s =~ /^\s*$Ident\s*:/) {
2586					$continuation = ($s =~ /^.*?\\\n/) ? 1 : 0;
2587					if ($s =~ s/^.*?\n//) {
2588						$cond_lines++;
2589					}
2590				}
2591			}
2592
2593			my (undef, $sindent) = line_stats("+" . $s);
2594			my $stat_real = raw_line($linenr, $cond_lines);
2595
2596			# Check if either of these lines are modified, else
2597			# this is not this patch's fault.
2598			if (!defined($stat_real) ||
2599			    $stat !~ /^\+/ && $stat_real !~ /^\+/) {
2600				$check = 0;
2601			}
2602			if (defined($stat_real) && $cond_lines > 1) {
2603				$stat_real = "[...]\n$stat_real";
2604			}
2605
2606			#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";
2607
2608			if ($check && (($sindent % 8) != 0 ||
2609			    ($sindent <= $indent && $s ne ''))) {
2610				WARN("SUSPECT_CODE_INDENT",
2611				     "suspect code indent for conditional statements ($indent, $sindent)\n" . $herecurr . "$stat_real\n");
2612			}
2613		}
2614
2615		# Track the 'values' across context and added lines.
2616		my $opline = $line; $opline =~ s/^./ /;
2617		my ($curr_values, $curr_vars) =
2618				annotate_values($opline . "\n", $prev_values);
2619		$curr_values = $prev_values . $curr_values;
2620		if ($dbg_values) {
2621			my $outline = $opline; $outline =~ s/\t/ /g;
2622			print "$linenr > .$outline\n";
2623			print "$linenr > $curr_values\n";
2624			print "$linenr >  $curr_vars\n";
2625		}
2626		$prev_values = substr($curr_values, -1);
2627
2628#ignore lines not being added
2629		next if ($line =~ /^[^\+]/);
2630
2631# TEST: allow direct testing of the type matcher.
2632		if ($dbg_type) {
2633			if ($line =~ /^.\s*$Declare\s*$/) {
2634				ERROR("TEST_TYPE",
2635				      "TEST: is type\n" . $herecurr);
2636			} elsif ($dbg_type > 1 && $line =~ /^.+($Declare)/) {
2637				ERROR("TEST_NOT_TYPE",
2638				      "TEST: is not type ($1 is)\n". $herecurr);
2639			}
2640			next;
2641		}
2642# TEST: allow direct testing of the attribute matcher.
2643		if ($dbg_attr) {
2644			if ($line =~ /^.\s*$Modifier\s*$/) {
2645				ERROR("TEST_ATTR",
2646				      "TEST: is attr\n" . $herecurr);
2647			} elsif ($dbg_attr > 1 && $line =~ /^.+($Modifier)/) {
2648				ERROR("TEST_NOT_ATTR",
2649				      "TEST: is not attr ($1 is)\n". $herecurr);
2650			}
2651			next;
2652		}
2653
2654# check for initialisation to aggregates open brace on the next line
2655		if ($line =~ /^.\s*{/ &&
2656		    $prevline =~ /(?:^|[^=])=\s*$/) {
2657			ERROR("OPEN_BRACE",
2658			      "that open brace { should be on the previous line\n" . $hereprev);
2659		}
2660
2661#
2662# Checks which are anchored on the added line.
2663#
2664
2665# check for malformed paths in #include statements (uses RAW line)
2666		if ($rawline =~ m{^.\s*\#\s*include\s+[<"](.*)[">]}) {
2667			my $path = $1;
2668			if ($path =~ m{//}) {
2669				ERROR("MALFORMED_INCLUDE",
2670				      "malformed #include filename\n" . $herecurr);
2671			}
2672			if ($path =~ "^uapi/" && $realfile =~ m@\binclude/uapi/@) {
2673				ERROR("UAPI_INCLUDE",
2674				      "No #include in ...include/uapi/... should use a uapi/ path prefix\n" . $herecurr);
2675			}
2676		}
2677
2678# no C99 // comments
2679		if ($line =~ m{//}) {
2680			if (ERROR("C99_COMMENTS",
2681				  "do not use C99 // comments\n" . $herecurr) &&
2682			    $fix) {
2683				my $line = $fixed[$linenr - 1];
2684				if ($line =~ /\/\/(.*)$/) {
2685					my $comment = trim($1);
2686					$fixed[$linenr - 1] =~ s@\/\/(.*)$@/\* $comment \*/@;
2687				}
2688			}
2689		}
2690		# Remove C99 comments.
2691		$line =~ s@//.*@@;
2692		$opline =~ s@//.*@@;
2693
2694# EXPORT_SYMBOL should immediately follow the thing it is exporting, consider
2695# the whole statement.
2696#print "APW <$lines[$realline_next - 1]>\n";
2697		if (defined $realline_next &&
2698		    exists $lines[$realline_next - 1] &&
2699		    !defined $suppress_export{$realline_next} &&
2700		    ($lines[$realline_next - 1] =~ /EXPORT_SYMBOL.*\((.*)\)/ ||
2701		     $lines[$realline_next - 1] =~ /EXPORT_UNUSED_SYMBOL.*\((.*)\)/)) {
2702			# Handle definitions which produce identifiers with
2703			# a prefix:
2704			#   XXX(foo);
2705			#   EXPORT_SYMBOL(something_foo);
2706			my $name = $1;
2707			if ($stat =~ /^(?:.\s*}\s*\n)?.([A-Z_]+)\s*\(\s*($Ident)/ &&
2708			    $name =~ /^${Ident}_$2/) {
2709#print "FOO C name<$name>\n";
2710				$suppress_export{$realline_next} = 1;
2711
2712			} elsif ($stat !~ /(?:
2713				\n.}\s*$|
2714				^.DEFINE_$Ident\(\Q$name\E\)|
2715				^.DECLARE_$Ident\(\Q$name\E\)|
2716				^.LIST_HEAD\(\Q$name\E\)|
2717				^.(?:$Storage\s+)?$Type\s*\(\s*\*\s*\Q$name\E\s*\)\s*\(|
2718				\b\Q$name\E(?:\s+$Attribute)*\s*(?:;|=|\[|\()
2719			    )/x) {
2720#print "FOO A<$lines[$realline_next - 1]> stat<$stat> name<$name>\n";
2721				$suppress_export{$realline_next} = 2;
2722			} else {
2723				$suppress_export{$realline_next} = 1;
2724			}
2725		}
2726		if (!defined $suppress_export{$linenr} &&
2727		    $prevline =~ /^.\s*$/ &&
2728		    ($line =~ /EXPORT_SYMBOL.*\((.*)\)/ ||
2729		     $line =~ /EXPORT_UNUSED_SYMBOL.*\((.*)\)/)) {
2730#print "FOO B <$lines[$linenr - 1]>\n";
2731			$suppress_export{$linenr} = 2;
2732		}
2733		if (defined $suppress_export{$linenr} &&
2734		    $suppress_export{$linenr} == 2) {
2735			WARN("EXPORT_SYMBOL",
2736			     "EXPORT_SYMBOL(foo); should immediately follow its function/variable\n" . $herecurr);
2737		}
2738
2739# check for global initialisers.
2740		if ($line =~ /^\+(\s*$Type\s*$Ident\s*(?:\s+$Modifier))*\s*=\s*(0|NULL|false)\s*;/) {
2741			if (ERROR("GLOBAL_INITIALISERS",
2742				  "do not initialise globals to 0 or NULL\n" .
2743				      $herecurr) &&
2744			    $fix) {
2745				$fixed[$linenr - 1] =~ s/($Type\s*$Ident\s*(?:\s+$Modifier))*\s*=\s*(0|NULL|false)\s*;/$1;/;
2746			}
2747		}
2748# check for static initialisers.
2749		if ($line =~ /^\+.*\bstatic\s.*=\s*(0|NULL|false)\s*;/) {
2750			if (ERROR("INITIALISED_STATIC",
2751				  "do not initialise statics to 0 or NULL\n" .
2752				      $herecurr) &&
2753			    $fix) {
2754				$fixed[$linenr - 1] =~ s/(\bstatic\s.*?)\s*=\s*(0|NULL|false)\s*;/$1;/;
2755			}
2756		}
2757
2758# check for static const char * arrays.
2759		if ($line =~ /\bstatic\s+const\s+char\s*\*\s*(\w+)\s*\[\s*\]\s*=\s*/) {
2760			WARN("STATIC_CONST_CHAR_ARRAY",
2761			     "static const char * array should probably be static const char * const\n" .
2762				$herecurr);
2763               }
2764
2765# check for static char foo[] = "bar" declarations.
2766		if ($line =~ /\bstatic\s+char\s+(\w+)\s*\[\s*\]\s*=\s*"/) {
2767			WARN("STATIC_CONST_CHAR_ARRAY",
2768			     "static char array declaration should probably be static const char\n" .
2769				$herecurr);
2770               }
2771
2772# check for non-global char *foo[] = {"bar", ...} declarations.
2773		if ($line =~ /^.\s+(?:static\s+|const\s+)?char\s+\*\s*\w+\s*\[\s*\]\s*=\s*\{/) {
2774			WARN("STATIC_CONST_CHAR_ARRAY",
2775			     "char * array declaration might be better as static const\n" .
2776				$herecurr);
2777               }
2778
2779# check for function declarations without arguments like "int foo()"
2780		if ($line =~ /(\b$Type\s+$Ident)\s*\(\s*\)/) {
2781			if (ERROR("FUNCTION_WITHOUT_ARGS",
2782				  "Bad function definition - $1() should probably be $1(void)\n" . $herecurr) &&
2783			    $fix) {
2784				$fixed[$linenr - 1] =~ s/(\b($Type)\s+($Ident))\s*\(\s*\)/$2 $3(void)/;
2785			}
2786		}
2787
2788# check for uses of DEFINE_PCI_DEVICE_TABLE
2789		if ($line =~ /\bDEFINE_PCI_DEVICE_TABLE\s*\(\s*(\w+)\s*\)\s*=/) {
2790			if (WARN("DEFINE_PCI_DEVICE_TABLE",
2791				 "Prefer struct pci_device_id over deprecated DEFINE_PCI_DEVICE_TABLE\n" . $herecurr) &&
2792			    $fix) {
2793				$fixed[$linenr - 1] =~ s/\b(?:static\s+|)DEFINE_PCI_DEVICE_TABLE\s*\(\s*(\w+)\s*\)\s*=\s*/static const struct pci_device_id $1\[\] = /;
2794			}
2795		}
2796
2797# check for new typedefs, only function parameters and sparse annotations
2798# make sense.
2799		if ($line =~ /\btypedef\s/ &&
2800		    $line !~ /\btypedef\s+$Type\s*\(\s*\*?$Ident\s*\)\s*\(/ &&
2801		    $line !~ /\btypedef\s+$Type\s+$Ident\s*\(/ &&
2802		    $line !~ /\b$typeTypedefs\b/ &&
2803		    $line !~ /\b__bitwise(?:__|)\b/) {
2804			WARN("NEW_TYPEDEFS",
2805			     "do not add new typedefs\n" . $herecurr);
2806		}
2807
2808# * goes on variable not on type
2809		# (char*[ const])
2810		while ($line =~ m{(\($NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)\))}g) {
2811			#print "AA<$1>\n";
2812			my ($ident, $from, $to) = ($1, $2, $2);
2813
2814			# Should start with a space.
2815			$to =~ s/^(\S)/ $1/;
2816			# Should not end with a space.
2817			$to =~ s/\s+$//;
2818			# '*'s should not have spaces between.
2819			while ($to =~ s/\*\s+\*/\*\*/) {
2820			}
2821
2822##			print "1: from<$from> to<$to> ident<$ident>\n";
2823			if ($from ne $to) {
2824				if (ERROR("POINTER_LOCATION",
2825					  "\"(foo$from)\" should be \"(foo$to)\"\n" .  $herecurr) &&
2826				    $fix) {
2827					my $sub_from = $ident;
2828					my $sub_to = $ident;
2829					$sub_to =~ s/\Q$from\E/$to/;
2830					$fixed[$linenr - 1] =~
2831					    s@\Q$sub_from\E@$sub_to@;
2832				}
2833			}
2834		}
2835		while ($line =~ m{(\b$NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)($Ident))}g) {
2836			#print "BB<$1>\n";
2837			my ($match, $from, $to, $ident) = ($1, $2, $2, $3);
2838
2839			# Should start with a space.
2840			$to =~ s/^(\S)/ $1/;
2841			# Should not end with a space.
2842			$to =~ s/\s+$//;
2843			# '*'s should not have spaces between.
2844			while ($to =~ s/\*\s+\*/\*\*/) {
2845			}
2846			# Modifiers should have spaces.
2847			$to =~ s/(\b$Modifier$)/$1 /;
2848
2849##			print "2: from<$from> to<$to> ident<$ident>\n";
2850			if ($from ne $to && $ident !~ /^$Modifier$/) {
2851				if (ERROR("POINTER_LOCATION",
2852					  "\"foo${from}bar\" should be \"foo${to}bar\"\n" .  $herecurr) &&
2853				    $fix) {
2854
2855					my $sub_from = $match;
2856					my $sub_to = $match;
2857					$sub_to =~ s/\Q$from\E/$to/;
2858					$fixed[$linenr - 1] =~
2859					    s@\Q$sub_from\E@$sub_to@;
2860				}
2861			}
2862		}
2863
2864# # no BUG() or BUG_ON()
2865# 		if ($line =~ /\b(BUG|BUG_ON)\b/) {
2866# 			print "Try to use WARN_ON & Recovery code rather than BUG() or BUG_ON()\n";
2867# 			print "$herecurr";
2868# 			$clean = 0;
2869# 		}
2870
2871		if ($line =~ /\bLINUX_VERSION_CODE\b/) {
2872			WARN("LINUX_VERSION_CODE",
2873			     "LINUX_VERSION_CODE should be avoided, code should be for the version to which it is merged\n" . $herecurr);
2874		}
2875
2876# check for uses of printk_ratelimit
2877		if ($line =~ /\bprintk_ratelimit\s*\(/) {
2878			WARN("PRINTK_RATELIMITED",
2879"Prefer printk_ratelimited or pr_<level>_ratelimited to printk_ratelimit\n" . $herecurr);
2880		}
2881
2882# printk should use KERN_* levels.  Note that follow on printk's on the
2883# same line do not need a level, so we use the current block context
2884# to try and find and validate the current printk.  In summary the current
2885# printk includes all preceding printk's which have no newline on the end.
2886# we assume the first bad printk is the one to report.
2887		if ($line =~ /\bprintk\((?!KERN_)\s*"/) {
2888			my $ok = 0;
2889			for (my $ln = $linenr - 1; $ln >= $first_line; $ln--) {
2890				#print "CHECK<$lines[$ln - 1]\n";
2891				# we have a preceding printk if it ends
2892				# with "\n" ignore it, else it is to blame
2893				if ($lines[$ln - 1] =~ m{\bprintk\(}) {
2894					if ($rawlines[$ln - 1] !~ m{\\n"}) {
2895						$ok = 1;
2896					}
2897					last;
2898				}
2899			}
2900			if ($ok == 0) {
2901				WARN("PRINTK_WITHOUT_KERN_LEVEL",
2902				     "printk() should include KERN_ facility level\n" . $herecurr);
2903			}
2904		}
2905
2906		if ($line =~ /\bprintk\s*\(\s*KERN_([A-Z]+)/) {
2907			my $orig = $1;
2908			my $level = lc($orig);
2909			$level = "warn" if ($level eq "warning");
2910			my $level2 = $level;
2911			$level2 = "dbg" if ($level eq "debug");
2912			WARN("PREFER_PR_LEVEL",
2913			     "Prefer [subsystem eg: netdev]_$level2([subsystem]dev, ... then dev_$level2(dev, ... then pr_$level(...  to printk(KERN_$orig ...\n" . $herecurr);
2914		}
2915
2916		if ($line =~ /\bpr_warning\s*\(/) {
2917			if (WARN("PREFER_PR_LEVEL",
2918				 "Prefer pr_warn(... to pr_warning(...\n" . $herecurr) &&
2919			    $fix) {
2920				$fixed[$linenr - 1] =~
2921				    s/\bpr_warning\b/pr_warn/;
2922			}
2923		}
2924
2925		if ($line =~ /\bdev_printk\s*\(\s*KERN_([A-Z]+)/) {
2926			my $orig = $1;
2927			my $level = lc($orig);
2928			$level = "warn" if ($level eq "warning");
2929			$level = "dbg" if ($level eq "debug");
2930			WARN("PREFER_DEV_LEVEL",
2931			     "Prefer dev_$level(... to dev_printk(KERN_$orig, ...\n" . $herecurr);
2932		}
2933
2934# function brace can't be on same line, except for #defines of do while,
2935# or if closed on same line
2936		if (($line=~/$Type\s*$Ident\(.*\).*\s{/) and
2937		    !($line=~/\#\s*define.*do\s{/) and !($line=~/}/)) {
2938			ERROR("OPEN_BRACE",
2939			      "open brace '{' following function declarations go on the next line\n" . $herecurr);
2940		}
2941
2942# open braces for enum, union and struct go on the same line.
2943		if ($line =~ /^.\s*{/ &&
2944		    $prevline =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident)?\s*$/) {
2945			ERROR("OPEN_BRACE",
2946			      "open brace '{' following $1 go on the same line\n" . $hereprev);
2947		}
2948
2949# missing space after union, struct or enum definition
2950		if ($line =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident){1,2}[=\{]/) {
2951			if (WARN("SPACING",
2952				 "missing space after $1 definition\n" . $herecurr) &&
2953			    $fix) {
2954				$fixed[$linenr - 1] =~
2955				    s/^(.\s*(?:typedef\s+)?(?:enum|union|struct)(?:\s+$Ident){1,2})([=\{])/$1 $2/;
2956			}
2957		}
2958
2959# Function pointer declarations
2960# check spacing between type, funcptr, and args
2961# canonical declaration is "type (*funcptr)(args...)"
2962		if ($line =~ /^.\s*($Declare)\((\s*)\*(\s*)($Ident)(\s*)\)(\s*)\(/) {
2963			my $declare = $1;
2964			my $pre_pointer_space = $2;
2965			my $post_pointer_space = $3;
2966			my $funcname = $4;
2967			my $post_funcname_space = $5;
2968			my $pre_args_space = $6;
2969
2970# the $Declare variable will capture all spaces after the type
2971# so check it for a missing trailing missing space but pointer return types
2972# don't need a space so don't warn for those.
2973			my $post_declare_space = "";
2974			if ($declare =~ /(\s+)$/) {
2975				$post_declare_space = $1;
2976				$declare = rtrim($declare);
2977			}
2978			if ($declare !~ /\*$/ && $post_declare_space =~ /^$/) {
2979				WARN("SPACING",
2980				     "missing space after return type\n" . $herecurr);
2981				$post_declare_space = " ";
2982			}
2983
2984# unnecessary space "type  (*funcptr)(args...)"
2985# This test is not currently implemented because these declarations are
2986# equivalent to
2987#	int  foo(int bar, ...)
2988# and this is form shouldn't/doesn't generate a checkpatch warning.
2989#
2990#			elsif ($declare =~ /\s{2,}$/) {
2991#				WARN("SPACING",
2992#				     "Multiple spaces after return type\n" . $herecurr);
2993#			}
2994
2995# unnecessary space "type ( *funcptr)(args...)"
2996			if (defined $pre_pointer_space &&
2997			    $pre_pointer_space =~ /^\s/) {
2998				WARN("SPACING",
2999				     "Unnecessary space after function pointer open parenthesis\n" . $herecurr);
3000			}
3001
3002# unnecessary space "type (* funcptr)(args...)"
3003			if (defined $post_pointer_space &&
3004			    $post_pointer_space =~ /^\s/) {
3005				WARN("SPACING",
3006				     "Unnecessary space before function pointer name\n" . $herecurr);
3007			}
3008
3009# unnecessary space "type (*funcptr )(args...)"
3010			if (defined $post_funcname_space &&
3011			    $post_funcname_space =~ /^\s/) {
3012				WARN("SPACING",
3013				     "Unnecessary space after function pointer name\n" . $herecurr);
3014			}
3015
3016# unnecessary space "type (*funcptr) (args...)"
3017			if (defined $pre_args_space &&
3018			    $pre_args_space =~ /^\s/) {
3019				WARN("SPACING",
3020				     "Unnecessary space before function pointer arguments\n" . $herecurr);
3021			}
3022
3023			if (show_type("SPACING") && $fix) {
3024				$fixed[$linenr - 1] =~
3025				    s/^(.\s*)$Declare\s*\(\s*\*\s*$Ident\s*\)\s*\(/$1 . $declare . $post_declare_space . '(*' . $funcname . ')('/ex;
3026			}
3027		}
3028
3029# check for spacing round square brackets; allowed:
3030#  1. with a type on the left -- int [] a;
3031#  2. at the beginning of a line for slice initialisers -- [0...10] = 5,
3032#  3. inside a curly brace -- = { [0...10] = 5 }
3033		while ($line =~ /(.*?\s)\[/g) {
3034			my ($where, $prefix) = ($-[1], $1);
3035			if ($prefix !~ /$Type\s+$/ &&
3036			    ($where != 0 || $prefix !~ /^.\s+$/) &&
3037			    $prefix !~ /[{,]\s+$/) {
3038				if (ERROR("BRACKET_SPACE",
3039					  "space prohibited before open square bracket '['\n" . $herecurr) &&
3040				    $fix) {
3041				    $fixed[$linenr - 1] =~
3042					s/^(\+.*?)\s+\[/$1\[/;
3043				}
3044			}
3045		}
3046
3047# check for spaces between functions and their parentheses.
3048		while ($line =~ /($Ident)\s+\(/g) {
3049			my $name = $1;
3050			my $ctx_before = substr($line, 0, $-[1]);
3051			my $ctx = "$ctx_before$name";
3052
3053			# Ignore those directives where spaces _are_ permitted.
3054			if ($name =~ /^(?:
3055				if|for|while|switch|return|case|
3056				volatile|__volatile__|
3057				__attribute__|format|__extension__|
3058				asm|__asm__)$/x)
3059			{
3060			# cpp #define statements have non-optional spaces, ie
3061			# if there is a space between the name and the open
3062			# parenthesis it is simply not a parameter group.
3063			} elsif ($ctx_before =~ /^.\s*\#\s*define\s*$/) {
3064
3065			# cpp #elif statement condition may start with a (
3066			} elsif ($ctx =~ /^.\s*\#\s*elif\s*$/) {
3067
3068			# If this whole things ends with a type its most
3069			# likely a typedef for a function.
3070			} elsif ($ctx =~ /$Type$/) {
3071
3072			} else {
3073				if (WARN("SPACING",
3074					 "space prohibited between function name and open parenthesis '('\n" . $herecurr) &&
3075					     $fix) {
3076					$fixed[$linenr - 1] =~
3077					    s/\b$name\s+\(/$name\(/;
3078				}
3079			}
3080		}
3081
3082# Check operator spacing.
3083		if (!($line=~/\#\s*include/)) {
3084			my $fixed_line = "";
3085			my $line_fixed = 0;
3086
3087			my $ops = qr{
3088				<<=|>>=|<=|>=|==|!=|
3089				\+=|-=|\*=|\/=|%=|\^=|\|=|&=|
3090				=>|->|<<|>>|<|>|=|!|~|
3091				&&|\|\||,|\^|\+\+|--|&|\||\+|-|\*|\/|%|
3092				\?:|\?|:
3093			}x;
3094			my @elements = split(/($ops|;)/, $opline);
3095
3096##			print("element count: <" . $#elements . ">\n");
3097##			foreach my $el (@elements) {
3098##				print("el: <$el>\n");
3099##			}
3100
3101			my @fix_elements = ();
3102			my $off = 0;
3103
3104			foreach my $el (@elements) {
3105				push(@fix_elements, substr($rawline, $off, length($el)));
3106				$off += length($el);
3107			}
3108
3109			$off = 0;
3110
3111			my $blank = copy_spacing($opline);
3112			my $last_after = -1;
3113
3114			for (my $n = 0; $n < $#elements; $n += 2) {
3115
3116				my $good = $fix_elements[$n] . $fix_elements[$n + 1];
3117
3118##				print("n: <$n> good: <$good>\n");
3119
3120				$off += length($elements[$n]);
3121
3122				# Pick up the preceding and succeeding characters.
3123				my $ca = substr($opline, 0, $off);
3124				my $cc = '';
3125				if (length($opline) >= ($off + length($elements[$n + 1]))) {
3126					$cc = substr($opline, $off + length($elements[$n + 1]));
3127				}
3128				my $cb = "$ca$;$cc";
3129
3130				my $a = '';
3131				$a = 'V' if ($elements[$n] ne '');
3132				$a = 'W' if ($elements[$n] =~ /\s$/);
3133				$a = 'C' if ($elements[$n] =~ /$;$/);
3134				$a = 'B' if ($elements[$n] =~ /(\[|\()$/);
3135				$a = 'O' if ($elements[$n] eq '');
3136				$a = 'E' if ($ca =~ /^\s*$/);
3137
3138				my $op = $elements[$n + 1];
3139
3140				my $c = '';
3141				if (defined $elements[$n + 2]) {
3142					$c = 'V' if ($elements[$n + 2] ne '');
3143					$c = 'W' if ($elements[$n + 2] =~ /^\s/);
3144					$c = 'C' if ($elements[$n + 2] =~ /^$;/);
3145					$c = 'B' if ($elements[$n + 2] =~ /^(\)|\]|;)/);
3146					$c = 'O' if ($elements[$n + 2] eq '');
3147					$c = 'E' if ($elements[$n + 2] =~ /^\s*\\$/);
3148				} else {
3149					$c = 'E';
3150				}
3151
3152				my $ctx = "${a}x${c}";
3153
3154				my $at = "(ctx:$ctx)";
3155
3156				my $ptr = substr($blank, 0, $off) . "^";
3157				my $hereptr = "$hereline$ptr\n";
3158
3159				# Pull out the value of this operator.
3160				my $op_type = substr($curr_values, $off + 1, 1);
3161
3162				# Get the full operator variant.
3163				my $opv = $op . substr($curr_vars, $off, 1);
3164
3165				# Ignore operators passed as parameters.
3166				if ($op_type ne 'V' &&
3167				    $ca =~ /\s$/ && $cc =~ /^\s*,/) {
3168
3169#				# Ignore comments
3170#				} elsif ($op =~ /^$;+$/) {
3171
3172				# ; should have either the end of line or a space or \ after it
3173				} elsif ($op eq ';') {
3174					if ($ctx !~ /.x[WEBC]/ &&
3175					    $cc !~ /^\\/ && $cc !~ /^;/) {
3176						if (ERROR("SPACING",
3177							  "space required after that '$op' $at\n" . $hereptr)) {
3178							$good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";
3179							$line_fixed = 1;
3180						}
3181					}
3182
3183				# // is a comment
3184				} elsif ($op eq '//') {
3185
3186				#   :   when part of a bitfield
3187				} elsif ($opv eq ':B') {
3188					# skip the bitfield test for now
3189
3190				# No spaces for:
3191				#   ->
3192				} elsif ($op eq '->') {
3193					if ($ctx =~ /Wx.|.xW/) {
3194						if (ERROR("SPACING",
3195							  "spaces prohibited around that '$op' $at\n" . $hereptr)) {
3196							$good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
3197							if (defined $fix_elements[$n + 2]) {
3198								$fix_elements[$n + 2] =~ s/^\s+//;
3199							}
3200							$line_fixed = 1;
3201						}
3202					}
3203
3204				# , must have a space on the right.
3205				} elsif ($op eq ',') {
3206					if ($ctx !~ /.x[WEC]/ && $cc !~ /^}/) {
3207						if (ERROR("SPACING",
3208							  "space required after that '$op' $at\n" . $hereptr)) {
3209							$good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";
3210							$line_fixed = 1;
3211							$last_after = $n;
3212						}
3213					}
3214
3215				# '*' as part of a type definition -- reported already.
3216				} elsif ($opv eq '*_') {
3217					#warn "'*' is part of type\n";
3218
3219				# unary operators should have a space before and
3220				# none after.  May be left adjacent to another
3221				# unary operator, or a cast
3222				} elsif ($op eq '!' || $op eq '~' ||
3223					 $opv eq '*U' || $opv eq '-U' ||
3224					 $opv eq '&U' || $opv eq '&&U') {
3225					if ($ctx !~ /[WEBC]x./ && $ca !~ /(?:\)|!|~|\*|-|\&|\||\+\+|\-\-|\{)$/) {
3226						if (ERROR("SPACING",
3227							  "space required before that '$op' $at\n" . $hereptr)) {
3228							if ($n != $last_after + 2) {
3229								$good = $fix_elements[$n] . " " . ltrim($fix_elements[$n + 1]);
3230								$line_fixed = 1;
3231							}
3232						}
3233					}
3234					if ($op eq '*' && $cc =~/\s*$Modifier\b/) {
3235						# A unary '*' may be const
3236
3237					} elsif ($ctx =~ /.xW/) {
3238						if (ERROR("SPACING",
3239							  "space prohibited after that '$op' $at\n" . $hereptr)) {
3240							$good = $fix_elements[$n] . rtrim($fix_elements[$n + 1]);
3241							if (defined $fix_elements[$n + 2]) {
3242								$fix_elements[$n + 2] =~ s/^\s+//;
3243							}
3244							$line_fixed = 1;
3245						}
3246					}
3247
3248				# unary ++ and unary -- are allowed no space on one side.
3249				} elsif ($op eq '++' or $op eq '--') {
3250					if ($ctx !~ /[WEOBC]x[^W]/ && $ctx !~ /[^W]x[WOBEC]/) {
3251						if (ERROR("SPACING",
3252							  "space required one side of that '$op' $at\n" . $hereptr)) {
3253							$good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";
3254							$line_fixed = 1;
3255						}
3256					}
3257					if ($ctx =~ /Wx[BE]/ ||
3258					    ($ctx =~ /Wx./ && $cc =~ /^;/)) {
3259						if (ERROR("SPACING",
3260							  "space prohibited before that '$op' $at\n" . $hereptr)) {
3261							$good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
3262							$line_fixed = 1;
3263						}
3264					}
3265					if ($ctx =~ /ExW/) {
3266						if (ERROR("SPACING",
3267							  "space prohibited after that '$op' $at\n" . $hereptr)) {
3268							$good = $fix_elements[$n] . trim($fix_elements[$n + 1]);
3269							if (defined $fix_elements[$n + 2]) {
3270								$fix_elements[$n + 2] =~ s/^\s+//;
3271							}
3272							$line_fixed = 1;
3273						}
3274					}
3275
3276				# << and >> may either have or not have spaces both sides
3277				} elsif ($op eq '<<' or $op eq '>>' or
3278					 $op eq '&' or $op eq '^' or $op eq '|' or
3279					 $op eq '+' or $op eq '-' or
3280					 $op eq '*' or $op eq '/' or
3281					 $op eq '%')
3282				{
3283					if ($ctx =~ /Wx[^WCE]|[^WCE]xW/) {
3284						if (ERROR("SPACING",
3285							  "need consistent spacing around '$op' $at\n" . $hereptr)) {
3286							$good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
3287							if (defined $fix_elements[$n + 2]) {
3288								$fix_elements[$n + 2] =~ s/^\s+//;
3289							}
3290							$line_fixed = 1;
3291						}
3292					}
3293
3294				# A colon needs no spaces before when it is
3295				# terminating a case value or a label.
3296				} elsif ($opv eq ':C' || $opv eq ':L') {
3297					if ($ctx =~ /Wx./) {
3298						if (ERROR("SPACING",
3299							  "space prohibited before that '$op' $at\n" . $hereptr)) {
3300							$good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
3301							$line_fixed = 1;
3302						}
3303					}
3304
3305				# All the others need spaces both sides.
3306				} elsif ($ctx !~ /[EWC]x[CWE]/) {
3307					my $ok = 0;
3308
3309					# Ignore email addresses <foo@bar>
3310					if (($op eq '<' &&
3311					     $cc =~ /^\S+\@\S+>/) ||
3312					    ($op eq '>' &&
3313					     $ca =~ /<\S+\@\S+$/))
3314					{
3315					    	$ok = 1;
3316					}
3317
3318					# messages are ERROR, but ?: are CHK
3319					if ($ok == 0) {
3320						my $msg_type = \&ERROR;
3321						$msg_type = \&CHK if (($op eq '?:' || $op eq '?' || $op eq ':') && $ctx =~ /VxV/);
3322
3323						if (&{$msg_type}("SPACING",
3324								 "spaces required around that '$op' $at\n" . $hereptr)) {
3325							$good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
3326							if (defined $fix_elements[$n + 2]) {
3327								$fix_elements[$n + 2] =~ s/^\s+//;
3328							}
3329							$line_fixed = 1;
3330						}
3331					}
3332				}
3333				$off += length($elements[$n + 1]);
3334
3335##				print("n: <$n> GOOD: <$good>\n");
3336
3337				$fixed_line = $fixed_line . $good;
3338			}
3339
3340			if (($#elements % 2) == 0) {
3341				$fixed_line = $fixed_line . $fix_elements[$#elements];
3342			}
3343
3344			if ($fix && $line_fixed && $fixed_line ne $fixed[$linenr - 1]) {
3345				$fixed[$linenr - 1] = $fixed_line;
3346			}
3347
3348
3349		}
3350
3351# check for whitespace before a non-naked semicolon
3352		if ($line =~ /^\+.*\S\s+;\s*$/) {
3353			if (WARN("SPACING",
3354				 "space prohibited before semicolon\n" . $herecurr) &&
3355			    $fix) {
3356				1 while $fixed[$linenr - 1] =~
3357				    s/^(\+.*\S)\s+;/$1;/;
3358			}
3359		}
3360
3361# check for multiple assignments
3362		if ($line =~ /^.\s*$Lval\s*=\s*$Lval\s*=(?!=)/) {
3363			CHK("MULTIPLE_ASSIGNMENTS",
3364			    "multiple assignments should be avoided\n" . $herecurr);
3365		}
3366
3367## # check for multiple declarations, allowing for a function declaration
3368## # continuation.
3369## 		if ($line =~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Ident.*/ &&
3370## 		    $line !~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Type\s*$Ident.*/) {
3371##
3372## 			# Remove any bracketed sections to ensure we do not
3373## 			# falsly report the parameters of functions.
3374## 			my $ln = $line;
3375## 			while ($ln =~ s/\([^\(\)]*\)//g) {
3376## 			}
3377## 			if ($ln =~ /,/) {
3378## 				WARN("MULTIPLE_DECLARATION",
3379##				     "declaring multiple variables together should be avoided\n" . $herecurr);
3380## 			}
3381## 		}
3382
3383#need space before brace following if, while, etc
3384		if (($line =~ /\(.*\){/ && $line !~ /\($Type\){/) ||
3385		    $line =~ /do{/) {
3386			if (ERROR("SPACING",
3387				  "space required before the open brace '{'\n" . $herecurr) &&
3388			    $fix) {
3389				$fixed[$linenr - 1] =~ s/^(\+.*(?:do|\))){/$1 {/;
3390			}
3391		}
3392
3393## # check for blank lines before declarations
3394##		if ($line =~ /^.\t+$Type\s+$Ident(?:\s*=.*)?;/ &&
3395##		    $prevrawline =~ /^.\s*$/) {
3396##			WARN("SPACING",
3397##			     "No blank lines before declarations\n" . $hereprev);
3398##		}
3399##
3400
3401# closing brace should have a space following it when it has anything
3402# on the line
3403		if ($line =~ /}(?!(?:,|;|\)))\S/) {
3404			if (ERROR("SPACING",
3405				  "space required after that close brace '}'\n" . $herecurr) &&
3406			    $fix) {
3407				$fixed[$linenr - 1] =~
3408				    s/}((?!(?:,|;|\)))\S)/} $1/;
3409			}
3410		}
3411
3412# check spacing on square brackets
3413		if ($line =~ /\[\s/ && $line !~ /\[\s*$/) {
3414			if (ERROR("SPACING",
3415				  "space prohibited after that open square bracket '['\n" . $herecurr) &&
3416			    $fix) {
3417				$fixed[$linenr - 1] =~
3418				    s/\[\s+/\[/;
3419			}
3420		}
3421		if ($line =~ /\s\]/) {
3422			if (ERROR("SPACING",
3423				  "space prohibited before that close square bracket ']'\n" . $herecurr) &&
3424			    $fix) {
3425				$fixed[$linenr - 1] =~
3426				    s/\s+\]/\]/;
3427			}
3428		}
3429
3430# check spacing on parentheses
3431		if ($line =~ /\(\s/ && $line !~ /\(\s*(?:\\)?$/ &&
3432		    $line !~ /for\s*\(\s+;/) {
3433			if (ERROR("SPACING",
3434				  "space prohibited after that open parenthesis '('\n" . $herecurr) &&
3435			    $fix) {
3436				$fixed[$linenr - 1] =~
3437				    s/\(\s+/\(/;
3438			}
3439		}
3440		if ($line =~ /(\s+)\)/ && $line !~ /^.\s*\)/ &&
3441		    $line !~ /for\s*\(.*;\s+\)/ &&
3442		    $line !~ /:\s+\)/) {
3443			if (ERROR("SPACING",
3444				  "space prohibited before that close parenthesis ')'\n" . $herecurr) &&
3445			    $fix) {
3446				$fixed[$linenr - 1] =~
3447				    s/\s+\)/\)/;
3448			}
3449		}
3450
3451#goto labels aren't indented, allow a single space however
3452		if ($line=~/^.\s+[A-Za-z\d_]+:(?![0-9]+)/ and
3453		   !($line=~/^. [A-Za-z\d_]+:/) and !($line=~/^.\s+default:/)) {
3454			if (WARN("INDENTED_LABEL",
3455				 "labels should not be indented\n" . $herecurr) &&
3456			    $fix) {
3457				$fixed[$linenr - 1] =~
3458				    s/^(.)\s+/$1/;
3459			}
3460		}
3461
3462# return is not a function
3463		if (defined($stat) && $stat =~ /^.\s*return(\s*)\(/s) {
3464			my $spacing = $1;
3465			if ($^V && $^V ge 5.10.0 &&
3466			    $stat =~ /^.\s*return\s*($balanced_parens)\s*;\s*$/) {
3467				my $value = $1;
3468				$value = deparenthesize($value);
3469				if ($value =~ m/^\s*$FuncArg\s*(?:\?|$)/) {
3470					ERROR("RETURN_PARENTHESES",
3471					      "return is not a function, parentheses are not required\n" . $herecurr);
3472				}
3473			} elsif ($spacing !~ /\s+/) {
3474				ERROR("SPACING",
3475				      "space required before the open parenthesis '('\n" . $herecurr);
3476			}
3477		}
3478
3479# unnecessary return in a void function? (a single leading tab, then return;)
3480		if ($sline =~ /^\+\treturn\s*;\s*$/ &&
3481		    $prevline =~ /^\+/) {
3482			WARN("RETURN_VOID",
3483			     "void function return statements are not generally useful\n" . $herecurr);
3484		}
3485
3486# if statements using unnecessary parentheses - ie: if ((foo == bar))
3487		if ($^V && $^V ge 5.10.0 &&
3488		    $line =~ /\bif\s*((?:\(\s*){2,})/) {
3489			my $openparens = $1;
3490			my $count = $openparens =~ tr@\(@\(@;
3491			my $msg = "";
3492			if ($line =~ /\bif\s*(?:\(\s*){$count,$count}$LvalOrFunc\s*($Compare)\s*$LvalOrFunc(?:\s*\)){$count,$count}/) {
3493				my $comp = $4;	#Not $1 because of $LvalOrFunc
3494				$msg = " - maybe == should be = ?" if ($comp eq "==");
3495				WARN("UNNECESSARY_PARENTHESES",
3496				     "Unnecessary parentheses$msg\n" . $herecurr);
3497			}
3498		}
3499
3500# Return of what appears to be an errno should normally be -'ve
3501		if ($line =~ /^.\s*return\s*(E[A-Z]*)\s*;/) {
3502			my $name = $1;
3503			if ($name ne 'EOF' && $name ne 'ERROR') {
3504				WARN("USE_NEGATIVE_ERRNO",
3505				     "return of an errno should typically be -ve (return -$1)\n" . $herecurr);
3506			}
3507		}
3508
3509# Need a space before open parenthesis after if, while etc
3510		if ($line =~ /\b(if|while|for|switch)\(/) {
3511			if (ERROR("SPACING",
3512				  "space required before the open parenthesis '('\n" . $herecurr) &&
3513			    $fix) {
3514				$fixed[$linenr - 1] =~
3515				    s/\b(if|while|for|switch)\(/$1 \(/;
3516			}
3517		}
3518
3519# Check for illegal assignment in if conditional -- and check for trailing
3520# statements after the conditional.
3521		if ($line =~ /do\s*(?!{)/) {
3522			($stat, $cond, $line_nr_next, $remain_next, $off_next) =
3523				ctx_statement_block($linenr, $realcnt, 0)
3524					if (!defined $stat);
3525			my ($stat_next) = ctx_statement_block($line_nr_next,
3526						$remain_next, $off_next);
3527			$stat_next =~ s/\n./\n /g;
3528			##print "stat<$stat> stat_next<$stat_next>\n";
3529
3530			if ($stat_next =~ /^\s*while\b/) {
3531				# If the statement carries leading newlines,
3532				# then count those as offsets.
3533				my ($whitespace) =
3534					($stat_next =~ /^((?:\s*\n[+-])*\s*)/s);
3535				my $offset =
3536					statement_rawlines($whitespace) - 1;
3537
3538				$suppress_whiletrailers{$line_nr_next +
3539								$offset} = 1;
3540			}
3541		}
3542		if (!defined $suppress_whiletrailers{$linenr} &&
3543		    defined($stat) && defined($cond) &&
3544		    $line =~ /\b(?:if|while|for)\s*\(/ && $line !~ /^.\s*#/) {
3545			my ($s, $c) = ($stat, $cond);
3546
3547			if ($c =~ /\bif\s*\(.*[^<>!=]=[^=].*/s) {
3548				ERROR("ASSIGN_IN_IF",
3549				      "do not use assignment in if condition\n" . $herecurr);
3550			}
3551
3552			# Find out what is on the end of the line after the
3553			# conditional.
3554			substr($s, 0, length($c), '');
3555			$s =~ s/\n.*//g;
3556			$s =~ s/$;//g; 	# Remove any comments
3557			if (length($c) && $s !~ /^\s*{?\s*\\*\s*$/ &&
3558			    $c !~ /}\s*while\s*/)
3559			{
3560				# Find out how long the conditional actually is.
3561				my @newlines = ($c =~ /\n/gs);
3562				my $cond_lines = 1 + $#newlines;
3563				my $stat_real = '';
3564
3565				$stat_real = raw_line($linenr, $cond_lines)
3566							. "\n" if ($cond_lines);
3567				if (defined($stat_real) && $cond_lines > 1) {
3568					$stat_real = "[...]\n$stat_real";
3569				}
3570
3571				ERROR("TRAILING_STATEMENTS",
3572				      "trailing statements should be on next line\n" . $herecurr . $stat_real);
3573			}
3574		}
3575
3576# Check for bitwise tests written as boolean
3577		if ($line =~ /
3578			(?:
3579				(?:\[|\(|\&\&|\|\|)
3580				\s*0[xX][0-9]+\s*
3581				(?:\&\&|\|\|)
3582			|
3583				(?:\&\&|\|\|)
3584				\s*0[xX][0-9]+\s*
3585				(?:\&\&|\|\||\)|\])
3586			)/x)
3587		{
3588			WARN("HEXADECIMAL_BOOLEAN_TEST",
3589			     "boolean test with hexadecimal, perhaps just 1 \& or \|?\n" . $herecurr);
3590		}
3591
3592# if and else should not have general statements after it
3593		if ($line =~ /^.\s*(?:}\s*)?else\b(.*)/) {
3594			my $s = $1;
3595			$s =~ s/$;//g; 	# Remove any comments
3596			if ($s !~ /^\s*(?:\sif|(?:{|)\s*\\?\s*$)/) {
3597				ERROR("TRAILING_STATEMENTS",
3598				      "trailing statements should be on next line\n" . $herecurr);
3599			}
3600		}
3601# if should not continue a brace
3602		if ($line =~ /}\s*if\b/) {
3603			ERROR("TRAILING_STATEMENTS",
3604			      "trailing statements should be on next line\n" .
3605				$herecurr);
3606		}
3607# case and default should not have general statements after them
3608		if ($line =~ /^.\s*(?:case\s*.*|default\s*):/g &&
3609		    $line !~ /\G(?:
3610			(?:\s*$;*)(?:\s*{)?(?:\s*$;*)(?:\s*\\)?\s*$|
3611			\s*return\s+
3612		    )/xg)
3613		{
3614			ERROR("TRAILING_STATEMENTS",
3615			      "trailing statements should be on next line\n" . $herecurr);
3616		}
3617
3618		# Check for }<nl>else {, these must be at the same
3619		# indent level to be relevant to each other.
3620		if ($prevline=~/}\s*$/ and $line=~/^.\s*else\s*/ and
3621						$previndent == $indent) {
3622			ERROR("ELSE_AFTER_BRACE",
3623			      "else should follow close brace '}'\n" . $hereprev);
3624		}
3625
3626		if ($prevline=~/}\s*$/ and $line=~/^.\s*while\s*/ and
3627						$previndent == $indent) {
3628			my ($s, $c) = ctx_statement_block($linenr, $realcnt, 0);
3629
3630			# Find out what is on the end of the line after the
3631			# conditional.
3632			substr($s, 0, length($c), '');
3633			$s =~ s/\n.*//g;
3634
3635			if ($s =~ /^\s*;/) {
3636				ERROR("WHILE_AFTER_BRACE",
3637				      "while should follow close brace '}'\n" . $hereprev);
3638			}
3639		}
3640
3641#Specific variable tests
3642		while ($line =~ m{($Constant|$Lval)}g) {
3643			my $var = $1;
3644
3645#gcc binary extension
3646			if ($var =~ /^$Binary$/) {
3647				if (WARN("GCC_BINARY_CONSTANT",
3648					 "Avoid gcc v4.3+ binary constant extension: <$var>\n" . $herecurr) &&
3649				    $fix) {
3650					my $hexval = sprintf("0x%x", oct($var));
3651					$fixed[$linenr - 1] =~
3652					    s/\b$var\b/$hexval/;
3653				}
3654			}
3655
3656#CamelCase
3657			if ($var !~ /^$Constant$/ &&
3658			    $var =~ /[A-Z][a-z]|[a-z][A-Z]/ &&
3659#Ignore Page<foo> variants
3660			    $var !~ /^(?:Clear|Set|TestClear|TestSet|)Page[A-Z]/ &&
3661#Ignore SI style variants like nS, mV and dB (ie: max_uV, regulator_min_uA_show)
3662			    $var !~ /^(?:[a-z_]*?)_?[a-z][A-Z](?:_[a-z_]+)?$/) {
3663				while ($var =~ m{($Ident)}g) {
3664					my $word = $1;
3665					next if ($word !~ /[A-Z][a-z]|[a-z][A-Z]/);
3666					if ($check) {
3667						seed_camelcase_includes();
3668						if (!$file && !$camelcase_file_seeded) {
3669							seed_camelcase_file($realfile);
3670							$camelcase_file_seeded = 1;
3671						}
3672					}
3673					if (!defined $camelcase{$word}) {
3674						$camelcase{$word} = 1;
3675						CHK("CAMELCASE",
3676						    "Avoid CamelCase: <$word>\n" . $herecurr);
3677					}
3678				}
3679			}
3680		}
3681
3682#no spaces allowed after \ in define
3683		if ($line =~ /\#\s*define.*\\\s+$/) {
3684			if (WARN("WHITESPACE_AFTER_LINE_CONTINUATION",
3685				 "Whitespace after \\ makes next lines useless\n" . $herecurr) &&
3686			    $fix) {
3687				$fixed[$linenr - 1] =~ s/\s+$//;
3688			}
3689		}
3690
3691#warn if <asm/foo.h> is #included and <linux/foo.h> is available (uses RAW line)
3692		if ($tree && $rawline =~ m{^.\s*\#\s*include\s*\<asm\/(.*)\.h\>}) {
3693			my $file = "$1.h";
3694			my $checkfile = "include/linux/$file";
3695			if (-f "$root/$checkfile" &&
3696			    $realfile ne $checkfile &&
3697			    $1 !~ /$allowed_asm_includes/)
3698			{
3699				if ($realfile =~ m{^arch/}) {
3700					CHK("ARCH_INCLUDE_LINUX",
3701					    "Consider using #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
3702				} else {
3703					WARN("INCLUDE_LINUX",
3704					     "Use #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
3705				}
3706			}
3707		}
3708
3709# multi-statement macros should be enclosed in a do while loop, grab the
3710# first statement and ensure its the whole macro if its not enclosed
3711# in a known good container
3712		if ($realfile !~ m@/vmlinux.lds.h$@ &&
3713		    $line =~ /^.\s*\#\s*define\s*$Ident(\()?/) {
3714			my $ln = $linenr;
3715			my $cnt = $realcnt;
3716			my ($off, $dstat, $dcond, $rest);
3717			my $ctx = '';
3718			($dstat, $dcond, $ln, $cnt, $off) =
3719				ctx_statement_block($linenr, $realcnt, 0);
3720			$ctx = $dstat;
3721			#print "dstat<$dstat> dcond<$dcond> cnt<$cnt> off<$off>\n";
3722			#print "LINE<$lines[$ln-1]> len<" . length($lines[$ln-1]) . "\n";
3723
3724			$dstat =~ s/^.\s*\#\s*define\s+$Ident(?:\([^\)]*\))?\s*//;
3725			$dstat =~ s/$;//g;
3726			$dstat =~ s/\\\n.//g;
3727			$dstat =~ s/^\s*//s;
3728			$dstat =~ s/\s*$//s;
3729
3730			# Flatten any parentheses and braces
3731			while ($dstat =~ s/\([^\(\)]*\)/1/ ||
3732			       $dstat =~ s/\{[^\{\}]*\}/1/ ||
3733			       $dstat =~ s/\[[^\[\]]*\]/1/)
3734			{
3735			}
3736
3737			# Flatten any obvious string concatentation.
3738			while ($dstat =~ s/("X*")\s*$Ident/$1/ ||
3739			       $dstat =~ s/$Ident\s*("X*")/$1/)
3740			{
3741			}
3742
3743			my $exceptions = qr{
3744				$Declare|
3745				module_param_named|
3746				MODULE_PARM_DESC|
3747				DECLARE_PER_CPU|
3748				DEFINE_PER_CPU|
3749				__typeof__\(|
3750				union|
3751				struct|
3752				\.$Ident\s*=\s*|
3753				^\"|\"$
3754			}x;
3755			#print "REST<$rest> dstat<$dstat> ctx<$ctx>\n";
3756			if ($dstat ne '' &&
3757			    $dstat !~ /^(?:$Ident|-?$Constant),$/ &&			# 10, // foo(),
3758			    $dstat !~ /^(?:$Ident|-?$Constant);$/ &&			# foo();
3759			    $dstat !~ /^[!~-]?(?:$Lval|$Constant)$/ &&		# 10 // foo() // !foo // ~foo // -foo // foo->bar // foo.bar->baz
3760			    $dstat !~ /^'X'$/ &&					# character constants
3761			    $dstat !~ /$exceptions/ &&
3762			    $dstat !~ /^\.$Ident\s*=/ &&				# .foo =
3763			    $dstat !~ /^(?:\#\s*$Ident|\#\s*$Constant)\s*$/ &&		# stringification #foo
3764			    $dstat !~ /^do\s*$Constant\s*while\s*$Constant;?$/ &&	# do {...} while (...); // do {...} while (...)
3765			    $dstat !~ /^for\s*$Constant$/ &&				# for (...)
3766			    $dstat !~ /^for\s*$Constant\s+(?:$Ident|-?$Constant)$/ &&	# for (...) bar()
3767			    $dstat !~ /^do\s*{/ &&					# do {...
3768			    $dstat !~ /^\({/ &&						# ({...
3769			    $ctx !~ /^.\s*#\s*define\s+TRACE_(?:SYSTEM|INCLUDE_FILE|INCLUDE_PATH)\b/)
3770			{
3771				$ctx =~ s/\n*$//;
3772				my $herectx = $here . "\n";
3773				my $cnt = statement_rawlines($ctx);
3774
3775				for (my $n = 0; $n < $cnt; $n++) {
3776					$herectx .= raw_line($linenr, $n) . "\n";
3777				}
3778
3779				if ($dstat =~ /;/) {
3780					ERROR("MULTISTATEMENT_MACRO_USE_DO_WHILE",
3781					      "Macros with multiple statements should be enclosed in a do - while loop\n" . "$herectx");
3782				} else {
3783					ERROR("COMPLEX_MACRO",
3784					      "Macros with complex values should be enclosed in parenthesis\n" . "$herectx");
3785				}
3786			}
3787
3788# check for line continuations outside of #defines, preprocessor #, and asm
3789
3790		} else {
3791			if ($prevline !~ /^..*\\$/ &&
3792			    $line !~ /^\+\s*\#.*\\$/ &&		# preprocessor
3793			    $line !~ /^\+.*\b(__asm__|asm)\b.*\\$/ &&	# asm
3794			    $line =~ /^\+.*\\$/) {
3795				WARN("LINE_CONTINUATIONS",
3796				     "Avoid unnecessary line continuations\n" . $herecurr);
3797			}
3798		}
3799
3800# do {} while (0) macro tests:
3801# single-statement macros do not need to be enclosed in do while (0) loop,
3802# macro should not end with a semicolon
3803		if ($^V && $^V ge 5.10.0 &&
3804		    $realfile !~ m@/vmlinux.lds.h$@ &&
3805		    $line =~ /^.\s*\#\s*define\s+$Ident(\()?/) {
3806			my $ln = $linenr;
3807			my $cnt = $realcnt;
3808			my ($off, $dstat, $dcond, $rest);
3809			my $ctx = '';
3810			($dstat, $dcond, $ln, $cnt, $off) =
3811				ctx_statement_block($linenr, $realcnt, 0);
3812			$ctx = $dstat;
3813
3814			$dstat =~ s/\\\n.//g;
3815
3816			if ($dstat =~ /^\+\s*#\s*define\s+$Ident\s*${balanced_parens}\s*do\s*{(.*)\s*}\s*while\s*\(\s*0\s*\)\s*([;\s]*)\s*$/) {
3817				my $stmts = $2;
3818				my $semis = $3;
3819
3820				$ctx =~ s/\n*$//;
3821				my $cnt = statement_rawlines($ctx);
3822				my $herectx = $here . "\n";
3823
3824				for (my $n = 0; $n < $cnt; $n++) {
3825					$herectx .= raw_line($linenr, $n) . "\n";
3826				}
3827
3828				if (($stmts =~ tr/;/;/) == 1 &&
3829				    $stmts !~ /^\s*(if|while|for|switch)\b/) {
3830					WARN("SINGLE_STATEMENT_DO_WHILE_MACRO",
3831					     "Single statement macros should not use a do {} while (0) loop\n" . "$herectx");
3832				}
3833				if (defined $semis && $semis ne "") {
3834					WARN("DO_WHILE_MACRO_WITH_TRAILING_SEMICOLON",
3835					     "do {} while (0) macros should not be semicolon terminated\n" . "$herectx");
3836				}
3837			} elsif ($dstat =~ /^\+\s*#\s*define\s+$Ident.*;\s*$/) {
3838				$ctx =~ s/\n*$//;
3839				my $cnt = statement_rawlines($ctx);
3840				my $herectx = $here . "\n";
3841
3842				for (my $n = 0; $n < $cnt; $n++) {
3843					$herectx .= raw_line($linenr, $n) . "\n";
3844				}
3845
3846				WARN("TRAILING_SEMICOLON",
3847				     "macros should not use a trailing semicolon\n" . "$herectx");
3848			}
3849		}
3850
3851# make sure symbols are always wrapped with VMLINUX_SYMBOL() ...
3852# all assignments may have only one of the following with an assignment:
3853#	.
3854#	ALIGN(...)
3855#	VMLINUX_SYMBOL(...)
3856		if ($realfile eq 'vmlinux.lds.h' && $line =~ /(?:(?:^|\s)$Ident\s*=|=\s*$Ident(?:\s|$))/) {
3857			WARN("MISSING_VMLINUX_SYMBOL",
3858			     "vmlinux.lds.h needs VMLINUX_SYMBOL() around C-visible symbols\n" . $herecurr);
3859		}
3860
3861# check for redundant bracing round if etc
3862		if ($line =~ /(^.*)\bif\b/ && $1 !~ /else\s*$/) {
3863			my ($level, $endln, @chunks) =
3864				ctx_statement_full($linenr, $realcnt, 1);
3865			#print "chunks<$#chunks> linenr<$linenr> endln<$endln> level<$level>\n";
3866			#print "APW: <<$chunks[1][0]>><<$chunks[1][1]>>\n";
3867			if ($#chunks > 0 && $level == 0) {
3868				my @allowed = ();
3869				my $allow = 0;
3870				my $seen = 0;
3871				my $herectx = $here . "\n";
3872				my $ln = $linenr - 1;
3873				for my $chunk (@chunks) {
3874					my ($cond, $block) = @{$chunk};
3875
3876					# If the condition carries leading newlines, then count those as offsets.
3877					my ($whitespace) = ($cond =~ /^((?:\s*\n[+-])*\s*)/s);
3878					my $offset = statement_rawlines($whitespace) - 1;
3879
3880					$allowed[$allow] = 0;
3881					#print "COND<$cond> whitespace<$whitespace> offset<$offset>\n";
3882
3883					# We have looked at and allowed this specific line.
3884					$suppress_ifbraces{$ln + $offset} = 1;
3885
3886					$herectx .= "$rawlines[$ln + $offset]\n[...]\n";
3887					$ln += statement_rawlines($block) - 1;
3888
3889					substr($block, 0, length($cond), '');
3890
3891					$seen++ if ($block =~ /^\s*{/);
3892
3893					#print "cond<$cond> block<$block> allowed<$allowed[$allow]>\n";
3894					if (statement_lines($cond) > 1) {
3895						#print "APW: ALLOWED: cond<$cond>\n";
3896						$allowed[$allow] = 1;
3897					}
3898					if ($block =~/\b(?:if|for|while)\b/) {
3899						#print "APW: ALLOWED: block<$block>\n";
3900						$allowed[$allow] = 1;
3901					}
3902					if (statement_block_size($block) > 1) {
3903						#print "APW: ALLOWED: lines block<$block>\n";
3904						$allowed[$allow] = 1;
3905					}
3906					$allow++;
3907				}
3908				if ($seen) {
3909					my $sum_allowed = 0;
3910					foreach (@allowed) {
3911						$sum_allowed += $_;
3912					}
3913					if ($sum_allowed == 0) {
3914						WARN("BRACES",
3915						     "braces {} are not necessary for any arm of this statement\n" . $herectx);
3916					} elsif ($sum_allowed != $allow &&
3917						 $seen != $allow) {
3918						CHK("BRACES",
3919						    "braces {} should be used on all arms of this statement\n" . $herectx);
3920					}
3921				}
3922			}
3923		}
3924		if (!defined $suppress_ifbraces{$linenr - 1} &&
3925					$line =~ /\b(if|while|for|else)\b/) {
3926			my $allowed = 0;
3927
3928			# Check the pre-context.
3929			if (substr($line, 0, $-[0]) =~ /(\}\s*)$/) {
3930				#print "APW: ALLOWED: pre<$1>\n";
3931				$allowed = 1;
3932			}
3933
3934			my ($level, $endln, @chunks) =
3935				ctx_statement_full($linenr, $realcnt, $-[0]);
3936
3937			# Check the condition.
3938			my ($cond, $block) = @{$chunks[0]};
3939			#print "CHECKING<$linenr> cond<$cond> block<$block>\n";
3940			if (defined $cond) {
3941				substr($block, 0, length($cond), '');
3942			}
3943			if (statement_lines($cond) > 1) {
3944				#print "APW: ALLOWED: cond<$cond>\n";
3945				$allowed = 1;
3946			}
3947			if ($block =~/\b(?:if|for|while)\b/) {
3948				#print "APW: ALLOWED: block<$block>\n";
3949				$allowed = 1;
3950			}
3951			if (statement_block_size($block) > 1) {
3952				#print "APW: ALLOWED: lines block<$block>\n";
3953				$allowed = 1;
3954			}
3955			# Check the post-context.
3956			if (defined $chunks[1]) {
3957				my ($cond, $block) = @{$chunks[1]};
3958				if (defined $cond) {
3959					substr($block, 0, length($cond), '');
3960				}
3961				if ($block =~ /^\s*\{/) {
3962					#print "APW: ALLOWED: chunk-1 block<$block>\n";
3963					$allowed = 1;
3964				}
3965			}
3966			if ($level == 0 && $block =~ /^\s*\{/ && !$allowed) {
3967				my $herectx = $here . "\n";
3968				my $cnt = statement_rawlines($block);
3969
3970				for (my $n = 0; $n < $cnt; $n++) {
3971					$herectx .= raw_line($linenr, $n) . "\n";
3972				}
3973
3974				WARN("BRACES",
3975				     "braces {} are not necessary for single statement blocks\n" . $herectx);
3976			}
3977		}
3978
3979# check for unnecessary blank lines around braces
3980		if (($line =~ /^.\s*}\s*$/ && $prevrawline =~ /^.\s*$/)) {
3981			CHK("BRACES",
3982			    "Blank lines aren't necessary before a close brace '}'\n" . $hereprev);
3983		}
3984		if (($rawline =~ /^.\s*$/ && $prevline =~ /^..*{\s*$/)) {
3985			CHK("BRACES",
3986			    "Blank lines aren't necessary after an open brace '{'\n" . $hereprev);
3987		}
3988
3989# no volatiles please
3990		my $asm_volatile = qr{\b(__asm__|asm)\s+(__volatile__|volatile)\b};
3991		if ($line =~ /\bvolatile\b/ && $line !~ /$asm_volatile/) {
3992			WARN("VOLATILE",
3993			     "Use of volatile is usually wrong: see Documentation/volatile-considered-harmful.txt\n" . $herecurr);
3994		}
3995
3996# warn about #if 0
3997		if ($line =~ /^.\s*\#\s*if\s+0\b/) {
3998			CHK("REDUNDANT_CODE",
3999			    "if this code is redundant consider removing it\n" .
4000				$herecurr);
4001		}
4002
4003# check for needless "if (<foo>) fn(<foo>)" uses
4004		if ($prevline =~ /\bif\s*\(\s*($Lval)\s*\)/) {
4005			my $expr = '\s*\(\s*' . quotemeta($1) . '\s*\)\s*;';
4006			if ($line =~ /\b(kfree|usb_free_urb|debugfs_remove(?:_recursive)?)$expr/) {
4007				WARN('NEEDLESS_IF',
4008				     "$1(NULL) is safe this check is probably not required\n" . $hereprev);
4009			}
4010		}
4011
4012# check for bad placement of section $InitAttribute (e.g.: __initdata)
4013		if ($line =~ /(\b$InitAttribute\b)/) {
4014			my $attr = $1;
4015			if ($line =~ /^\+\s*static\s+(?:const\s+)?(?:$attr\s+)?($NonptrTypeWithAttr)\s+(?:$attr\s+)?($Ident(?:\[[^]]*\])?)\s*[=;]/) {
4016				my $ptr = $1;
4017				my $var = $2;
4018				if ((($ptr =~ /\b(union|struct)\s+$attr\b/ &&
4019				      ERROR("MISPLACED_INIT",
4020					    "$attr should be placed after $var\n" . $herecurr)) ||
4021				     ($ptr !~ /\b(union|struct)\s+$attr\b/ &&
4022				      WARN("MISPLACED_INIT",
4023					   "$attr should be placed after $var\n" . $herecurr))) &&
4024				    $fix) {
4025					$fixed[$linenr - 1] =~ 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;
4026				}
4027			}
4028		}
4029
4030# check for $InitAttributeData (ie: __initdata) with const
4031		if ($line =~ /\bconst\b/ && $line =~ /($InitAttributeData)/) {
4032			my $attr = $1;
4033			$attr =~ /($InitAttributePrefix)(.*)/;
4034			my $attr_prefix = $1;
4035			my $attr_type = $2;
4036			if (ERROR("INIT_ATTRIBUTE",
4037				  "Use of const init definition must use ${attr_prefix}initconst\n" . $herecurr) &&
4038			    $fix) {
4039				$fixed[$linenr - 1] =~
4040				    s/$InitAttributeData/${attr_prefix}initconst/;
4041			}
4042		}
4043
4044# check for $InitAttributeConst (ie: __initconst) without const
4045		if ($line !~ /\bconst\b/ && $line =~ /($InitAttributeConst)/) {
4046			my $attr = $1;
4047			if (ERROR("INIT_ATTRIBUTE",
4048				  "Use of $attr requires a separate use of const\n" . $herecurr) &&
4049			    $fix) {
4050				my $lead = $fixed[$linenr - 1] =~
4051				    /(^\+\s*(?:static\s+))/;
4052				$lead = rtrim($1);
4053				$lead = "$lead " if ($lead !~ /^\+$/);
4054				$lead = "${lead}const ";
4055				$fixed[$linenr - 1] =~ s/(^\+\s*(?:static\s+))/$lead/;
4056			}
4057		}
4058
4059# don't use __constant_<foo> functions outside of include/uapi/
4060		if ($realfile !~ m@^include/uapi/@ &&
4061		    $line =~ /(__constant_(?:htons|ntohs|[bl]e(?:16|32|64)_to_cpu|cpu_to_[bl]e(?:16|32|64)))\s*\(/) {
4062			my $constant_func = $1;
4063			my $func = $constant_func;
4064			$func =~ s/^__constant_//;
4065			if (WARN("CONSTANT_CONVERSION",
4066				 "$constant_func should be $func\n" . $herecurr) &&
4067			    $fix) {
4068				$fixed[$linenr - 1] =~ s/\b$constant_func\b/$func/g;
4069			}
4070		}
4071
4072# prefer usleep_range over udelay
4073		if ($line =~ /\budelay\s*\(\s*(\d+)\s*\)/) {
4074			my $delay = $1;
4075			# ignore udelay's < 10, however
4076			if (! ($delay < 10) ) {
4077				CHK("USLEEP_RANGE",
4078				    "usleep_range is preferred over udelay; see Documentation/timers/timers-howto.txt\n" . $herecurr);
4079			}
4080			if ($delay > 2000) {
4081				WARN("LONG_UDELAY",
4082				     "long udelay - prefer mdelay; see arch/arm/include/asm/delay.h\n" . $herecurr);
4083			}
4084		}
4085
4086# warn about unexpectedly long msleep's
4087		if ($line =~ /\bmsleep\s*\((\d+)\);/) {
4088			if ($1 < 20) {
4089				WARN("MSLEEP",
4090				     "msleep < 20ms can sleep for up to 20ms; see Documentation/timers/timers-howto.txt\n" . $herecurr);
4091			}
4092		}
4093
4094# check for comparisons of jiffies
4095		if ($line =~ /\bjiffies\s*$Compare|$Compare\s*jiffies\b/) {
4096			WARN("JIFFIES_COMPARISON",
4097			     "Comparing jiffies is almost always wrong; prefer time_after, time_before and friends\n" . $herecurr);
4098		}
4099
4100# check for comparisons of get_jiffies_64()
4101		if ($line =~ /\bget_jiffies_64\s*\(\s*\)\s*$Compare|$Compare\s*get_jiffies_64\s*\(\s*\)/) {
4102			WARN("JIFFIES_COMPARISON",
4103			     "Comparing get_jiffies_64() is almost always wrong; prefer time_after64, time_before64 and friends\n" . $herecurr);
4104		}
4105
4106# warn about #ifdefs in C files
4107#		if ($line =~ /^.\s*\#\s*if(|n)def/ && ($realfile =~ /\.c$/)) {
4108#			print "#ifdef in C files should be avoided\n";
4109#			print "$herecurr";
4110#			$clean = 0;
4111#		}
4112
4113# warn about spacing in #ifdefs
4114		if ($line =~ /^.\s*\#\s*(ifdef|ifndef|elif)\s\s+/) {
4115			if (ERROR("SPACING",
4116				  "exactly one space required after that #$1\n" . $herecurr) &&
4117			    $fix) {
4118				$fixed[$linenr - 1] =~
4119				    s/^(.\s*\#\s*(ifdef|ifndef|elif))\s{2,}/$1 /;
4120			}
4121
4122		}
4123
4124# check for spinlock_t definitions without a comment.
4125		if ($line =~ /^.\s*(struct\s+mutex|spinlock_t)\s+\S+;/ ||
4126		    $line =~ /^.\s*(DEFINE_MUTEX)\s*\(/) {
4127			my $which = $1;
4128			if (!ctx_has_comment($first_line, $linenr)) {
4129				CHK("UNCOMMENTED_DEFINITION",
4130				    "$1 definition without comment\n" . $herecurr);
4131			}
4132		}
4133# check for memory barriers without a comment.
4134		if ($line =~ /\b(mb|rmb|wmb|read_barrier_depends|smp_mb|smp_rmb|smp_wmb|smp_read_barrier_depends)\(/) {
4135			if (!ctx_has_comment($first_line, $linenr)) {
4136				WARN("MEMORY_BARRIER",
4137				     "memory barrier without comment\n" . $herecurr);
4138			}
4139		}
4140# check of hardware specific defines
4141		if ($line =~ m@^.\s*\#\s*if.*\b(__i386__|__powerpc64__|__sun__|__s390x__)\b@ && $realfile !~ m@include/asm-@) {
4142			CHK("ARCH_DEFINES",
4143			    "architecture specific defines should be avoided\n" .  $herecurr);
4144		}
4145
4146# Check that the storage class is at the beginning of a declaration
4147		if ($line =~ /\b$Storage\b/ && $line !~ /^.\s*$Storage\b/) {
4148			WARN("STORAGE_CLASS",
4149			     "storage class should be at the beginning of the declaration\n" . $herecurr)
4150		}
4151
4152# check the location of the inline attribute, that it is between
4153# storage class and type.
4154		if ($line =~ /\b$Type\s+$Inline\b/ ||
4155		    $line =~ /\b$Inline\s+$Storage\b/) {
4156			ERROR("INLINE_LOCATION",
4157			      "inline keyword should sit between storage class and type\n" . $herecurr);
4158		}
4159
4160# Check for __inline__ and __inline, prefer inline
4161		if ($realfile !~ m@\binclude/uapi/@ &&
4162		    $line =~ /\b(__inline__|__inline)\b/) {
4163			if (WARN("INLINE",
4164				 "plain inline is preferred over $1\n" . $herecurr) &&
4165			    $fix) {
4166				$fixed[$linenr - 1] =~ s/\b(__inline__|__inline)\b/inline/;
4167
4168			}
4169		}
4170
4171# Check for __attribute__ packed, prefer __packed
4172		if ($realfile !~ m@\binclude/uapi/@ &&
4173		    $line =~ /\b__attribute__\s*\(\s*\(.*\bpacked\b/) {
4174			WARN("PREFER_PACKED",
4175			     "__packed is preferred over __attribute__((packed))\n" . $herecurr);
4176		}
4177
4178# Check for __attribute__ aligned, prefer __aligned
4179		if ($realfile !~ m@\binclude/uapi/@ &&
4180		    $line =~ /\b__attribute__\s*\(\s*\(.*aligned/) {
4181			WARN("PREFER_ALIGNED",
4182			     "__aligned(size) is preferred over __attribute__((aligned(size)))\n" . $herecurr);
4183		}
4184
4185# Check for __attribute__ format(printf, prefer __printf
4186		if ($realfile !~ m@\binclude/uapi/@ &&
4187		    $line =~ /\b__attribute__\s*\(\s*\(\s*format\s*\(\s*printf/) {
4188			if (WARN("PREFER_PRINTF",
4189				 "__printf(string-index, first-to-check) is preferred over __attribute__((format(printf, string-index, first-to-check)))\n" . $herecurr) &&
4190			    $fix) {
4191				$fixed[$linenr - 1] =~ s/\b__attribute__\s*\(\s*\(\s*format\s*\(\s*printf\s*,\s*(.*)\)\s*\)\s*\)/"__printf(" . trim($1) . ")"/ex;
4192
4193			}
4194		}
4195
4196# Check for __attribute__ format(scanf, prefer __scanf
4197		if ($realfile !~ m@\binclude/uapi/@ &&
4198		    $line =~ /\b__attribute__\s*\(\s*\(\s*format\s*\(\s*scanf\b/) {
4199			if (WARN("PREFER_SCANF",
4200				 "__scanf(string-index, first-to-check) is preferred over __attribute__((format(scanf, string-index, first-to-check)))\n" . $herecurr) &&
4201			    $fix) {
4202				$fixed[$linenr - 1] =~ s/\b__attribute__\s*\(\s*\(\s*format\s*\(\s*scanf\s*,\s*(.*)\)\s*\)\s*\)/"__scanf(" . trim($1) . ")"/ex;
4203			}
4204		}
4205
4206# check for sizeof(&)
4207		if ($line =~ /\bsizeof\s*\(\s*\&/) {
4208			WARN("SIZEOF_ADDRESS",
4209			     "sizeof(& should be avoided\n" . $herecurr);
4210		}
4211
4212# check for sizeof without parenthesis
4213		if ($line =~ /\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/) {
4214			if (WARN("SIZEOF_PARENTHESIS",
4215				 "sizeof $1 should be sizeof($1)\n" . $herecurr) &&
4216			    $fix) {
4217				$fixed[$linenr - 1] =~ s/\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/"sizeof(" . trim($1) . ")"/ex;
4218			}
4219		}
4220
4221# check for line continuations in quoted strings with odd counts of "
4222		if ($rawline =~ /\\$/ && $rawline =~ tr/"/"/ % 2) {
4223			WARN("LINE_CONTINUATIONS",
4224			     "Avoid line continuations in quoted strings\n" . $herecurr);
4225		}
4226
4227# check for struct spinlock declarations
4228		if ($line =~ /^.\s*\bstruct\s+spinlock\s+\w+\s*;/) {
4229			WARN("USE_SPINLOCK_T",
4230			     "struct spinlock should be spinlock_t\n" . $herecurr);
4231		}
4232
4233# check for seq_printf uses that could be seq_puts
4234		if ($sline =~ /\bseq_printf\s*\(.*"\s*\)\s*;\s*$/) {
4235			my $fmt = get_quoted_string($line, $rawline);
4236			if ($fmt ne "" && $fmt !~ /[^\\]\%/) {
4237				if (WARN("PREFER_SEQ_PUTS",
4238					 "Prefer seq_puts to seq_printf\n" . $herecurr) &&
4239				    $fix) {
4240					$fixed[$linenr - 1] =~ s/\bseq_printf\b/seq_puts/;
4241				}
4242			}
4243		}
4244
4245# Check for misused memsets
4246		if ($^V && $^V ge 5.10.0 &&
4247		    defined $stat &&
4248		    $stat =~ /^\+(?:.*?)\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*$FuncArg\s*\)/s) {
4249
4250			my $ms_addr = $2;
4251			my $ms_val = $7;
4252			my $ms_size = $12;
4253
4254			if ($ms_size =~ /^(0x|)0$/i) {
4255				ERROR("MEMSET",
4256				      "memset to 0's uses 0 as the 2nd argument, not the 3rd\n" . "$here\n$stat\n");
4257			} elsif ($ms_size =~ /^(0x|)1$/i) {
4258				WARN("MEMSET",
4259				     "single byte memset is suspicious. Swapped 2nd/3rd argument?\n" . "$here\n$stat\n");
4260			}
4261		}
4262
4263# Check for memcpy(foo, bar, ETH_ALEN) that could be ether_addr_copy(foo, bar)
4264		if ($^V && $^V ge 5.10.0 &&
4265		    $line =~ /^\+(?:.*?)\bmemcpy\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/s) {
4266			if (WARN("PREFER_ETHER_ADDR_COPY",
4267				 "Prefer ether_addr_copy() over memcpy() if the Ethernet addresses are __aligned(2)\n" . $herecurr) &&
4268			    $fix) {
4269				$fixed[$linenr - 1] =~ s/\bmemcpy\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/ether_addr_copy($2, $7)/;
4270			}
4271		}
4272
4273# typecasts on min/max could be min_t/max_t
4274		if ($^V && $^V ge 5.10.0 &&
4275		    defined $stat &&
4276		    $stat =~ /^\+(?:.*?)\b(min|max)\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\)/) {
4277			if (defined $2 || defined $7) {
4278				my $call = $1;
4279				my $cast1 = deparenthesize($2);
4280				my $arg1 = $3;
4281				my $cast2 = deparenthesize($7);
4282				my $arg2 = $8;
4283				my $cast;
4284
4285				if ($cast1 ne "" && $cast2 ne "" && $cast1 ne $cast2) {
4286					$cast = "$cast1 or $cast2";
4287				} elsif ($cast1 ne "") {
4288					$cast = $cast1;
4289				} else {
4290					$cast = $cast2;
4291				}
4292				WARN("MINMAX",
4293				     "$call() should probably be ${call}_t($cast, $arg1, $arg2)\n" . "$here\n$stat\n");
4294			}
4295		}
4296
4297# check usleep_range arguments
4298		if ($^V && $^V ge 5.10.0 &&
4299		    defined $stat &&
4300		    $stat =~ /^\+(?:.*?)\busleep_range\s*\(\s*($FuncArg)\s*,\s*($FuncArg)\s*\)/) {
4301			my $min = $1;
4302			my $max = $7;
4303			if ($min eq $max) {
4304				WARN("USLEEP_RANGE",
4305				     "usleep_range should not use min == max args; see Documentation/timers/timers-howto.txt\n" . "$here\n$stat\n");
4306			} elsif ($min =~ /^\d+$/ && $max =~ /^\d+$/ &&
4307				 $min > $max) {
4308				WARN("USLEEP_RANGE",
4309				     "usleep_range args reversed, use min then max; see Documentation/timers/timers-howto.txt\n" . "$here\n$stat\n");
4310			}
4311		}
4312
4313# check for naked sscanf
4314		if ($^V && $^V ge 5.10.0 &&
4315		    defined $stat &&
4316		    $line =~ /\bsscanf\b/ &&
4317		    ($stat !~ /$Ident\s*=\s*sscanf\s*$balanced_parens/ &&
4318		     $stat !~ /\bsscanf\s*$balanced_parens\s*(?:$Compare)/ &&
4319		     $stat !~ /(?:$Compare)\s*\bsscanf\s*$balanced_parens/)) {
4320			my $lc = $stat =~ tr@\n@@;
4321			$lc = $lc + $linenr;
4322			my $stat_real = raw_line($linenr, 0);
4323		        for (my $count = $linenr + 1; $count <= $lc; $count++) {
4324				$stat_real = $stat_real . "\n" . raw_line($count, 0);
4325			}
4326			WARN("NAKED_SSCANF",
4327			     "unchecked sscanf return value\n" . "$here\n$stat_real\n");
4328		}
4329
4330# check for simple sscanf that should be kstrto<foo>
4331		if ($^V && $^V ge 5.10.0 &&
4332		    defined $stat &&
4333		    $line =~ /\bsscanf\b/) {
4334			my $lc = $stat =~ tr@\n@@;
4335			$lc = $lc + $linenr;
4336			my $stat_real = raw_line($linenr, 0);
4337		        for (my $count = $linenr + 1; $count <= $lc; $count++) {
4338				$stat_real = $stat_real . "\n" . raw_line($count, 0);
4339			}
4340			if ($stat_real =~ /\bsscanf\b\s*\(\s*$FuncArg\s*,\s*("[^"]+")/) {
4341				my $format = $6;
4342				my $count = $format =~ tr@%@%@;
4343				if ($count == 1 &&
4344				    $format =~ /^"\%(?i:ll[udxi]|[udxi]ll|ll|[hl]h?[udxi]|[udxi][hl]h?|[hl]h?|[udxi])"$/) {
4345					WARN("SSCANF_TO_KSTRTO",
4346					     "Prefer kstrto<type> to single variable sscanf\n" . "$here\n$stat_real\n");
4347				}
4348			}
4349		}
4350
4351# check for new externs in .h files.
4352		if ($realfile =~ /\.h$/ &&
4353		    $line =~ /^\+\s*(extern\s+)$Type\s*$Ident\s*\(/s) {
4354			if (CHK("AVOID_EXTERNS",
4355				"extern prototypes should be avoided in .h files\n" . $herecurr) &&
4356			    $fix) {
4357				$fixed[$linenr - 1] =~ s/(.*)\bextern\b\s*(.*)/$1$2/;
4358			}
4359		}
4360
4361# check for new externs in .c files.
4362		if ($realfile =~ /\.c$/ && defined $stat &&
4363		    $stat =~ /^.\s*(?:extern\s+)?$Type\s+($Ident)(\s*)\(/s)
4364		{
4365			my $function_name = $1;
4366			my $paren_space = $2;
4367
4368			my $s = $stat;
4369			if (defined $cond) {
4370				substr($s, 0, length($cond), '');
4371			}
4372			if ($s =~ /^\s*;/ &&
4373			    $function_name ne 'uninitialized_var')
4374			{
4375				WARN("AVOID_EXTERNS",
4376				     "externs should be avoided in .c files\n" .  $herecurr);
4377			}
4378
4379			if ($paren_space =~ /\n/) {
4380				WARN("FUNCTION_ARGUMENTS",
4381				     "arguments for function declarations should follow identifier\n" . $herecurr);
4382			}
4383
4384		} elsif ($realfile =~ /\.c$/ && defined $stat &&
4385		    $stat =~ /^.\s*extern\s+/)
4386		{
4387			WARN("AVOID_EXTERNS",
4388			     "externs should be avoided in .c files\n" .  $herecurr);
4389		}
4390
4391# checks for new __setup's
4392		if ($rawline =~ /\b__setup\("([^"]*)"/) {
4393			my $name = $1;
4394
4395			if (!grep(/$name/, @setup_docs)) {
4396				CHK("UNDOCUMENTED_SETUP",
4397				    "__setup appears un-documented -- check Documentation/kernel-parameters.txt\n" . $herecurr);
4398			}
4399		}
4400
4401# check for pointless casting of kmalloc return
4402		if ($line =~ /\*\s*\)\s*[kv][czm]alloc(_node){0,1}\b/) {
4403			WARN("UNNECESSARY_CASTS",
4404			     "unnecessary cast may hide bugs, see http://c-faq.com/malloc/mallocnocast.html\n" . $herecurr);
4405		}
4406
4407# alloc style
4408# p = alloc(sizeof(struct foo), ...) should be p = alloc(sizeof(*p), ...)
4409		if ($^V && $^V ge 5.10.0 &&
4410		    $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*([kv][mz]alloc(?:_node)?)\s*\(\s*(sizeof\s*\(\s*struct\s+$Lval\s*\))/) {
4411			CHK("ALLOC_SIZEOF_STRUCT",
4412			    "Prefer $3(sizeof(*$1)...) over $3($4...)\n" . $herecurr);
4413		}
4414
4415# check for k[mz]alloc with multiplies that could be kmalloc_array/kcalloc
4416		if ($^V && $^V ge 5.10.0 &&
4417		    $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*(k[mz]alloc)\s*\(\s*($FuncArg)\s*\*\s*($FuncArg)/) {
4418			my $oldfunc = $3;
4419			my $a1 = $4;
4420			my $a2 = $10;
4421			my $newfunc = "kmalloc_array";
4422			$newfunc = "kcalloc" if ($oldfunc eq "kzalloc");
4423			if ($a1 =~ /^sizeof\s*\S/ || $a2 =~ /^sizeof\s*\S/) {
4424				if (WARN("ALLOC_WITH_MULTIPLY",
4425					 "Prefer $newfunc over $oldfunc with multiply\n" . $herecurr) &&
4426				    $fix) {
4427					my $r1 = $a1;
4428					my $r2 = $a2;
4429					if ($a1 =~ /^sizeof\s*\S/) {
4430						$r1 = $a2;
4431						$r2 = $a1;
4432					}
4433					$fixed[$linenr - 1] =~ s/\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*(k[mz]alloc)\s*\(\s*($FuncArg)\s*\*\s*($FuncArg)/$1 . ' = ' . "$newfunc(" . trim($r1) . ', ' . trim($r2)/e;
4434
4435				}
4436			}
4437		}
4438
4439# check for krealloc arg reuse
4440		if ($^V && $^V ge 5.10.0 &&
4441		    $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*krealloc\s*\(\s*\1\s*,/) {
4442			WARN("KREALLOC_ARG_REUSE",
4443			     "Reusing the krealloc arg is almost always a bug\n" . $herecurr);
4444		}
4445
4446# check for alloc argument mismatch
4447		if ($line =~ /\b(kcalloc|kmalloc_array)\s*\(\s*sizeof\b/) {
4448			WARN("ALLOC_ARRAY_ARGS",
4449			     "$1 uses number as first arg, sizeof is generally wrong\n" . $herecurr);
4450		}
4451
4452# check for multiple semicolons
4453		if ($line =~ /;\s*;\s*$/) {
4454			if (WARN("ONE_SEMICOLON",
4455				 "Statements terminations use 1 semicolon\n" . $herecurr) &&
4456			    $fix) {
4457				$fixed[$linenr - 1] =~ s/(\s*;\s*){2,}$/;/g;
4458			}
4459		}
4460
4461# check for case / default statements not preceeded by break/fallthrough/switch
4462		if ($line =~ /^.\s*(?:case\s+(?:$Ident|$Constant)\s*|default):/) {
4463			my $has_break = 0;
4464			my $has_statement = 0;
4465			my $count = 0;
4466			my $prevline = $linenr;
4467			while ($prevline > 1 && $count < 3 && !$has_break) {
4468				$prevline--;
4469				my $rline = $rawlines[$prevline - 1];
4470				my $fline = $lines[$prevline - 1];
4471				last if ($fline =~ /^\@\@/);
4472				next if ($fline =~ /^\-/);
4473				next if ($fline =~ /^.(?:\s*(?:case\s+(?:$Ident|$Constant)[\s$;]*|default):[\s$;]*)*$/);
4474				$has_break = 1 if ($rline =~ /fall[\s_-]*(through|thru)/i);
4475				next if ($fline =~ /^.[\s$;]*$/);
4476				$has_statement = 1;
4477				$count++;
4478				$has_break = 1 if ($fline =~ /\bswitch\b|\b(?:break\s*;[\s$;]*$|return\b|goto\b|continue\b)/);
4479			}
4480			if (!$has_break && $has_statement) {
4481				WARN("MISSING_BREAK",
4482				     "Possible switch case/default not preceeded by break or fallthrough comment\n" . $herecurr);
4483			}
4484		}
4485
4486# check for switch/default statements without a break;
4487		if ($^V && $^V ge 5.10.0 &&
4488		    defined $stat &&
4489		    $stat =~ /^\+[$;\s]*(?:case[$;\s]+\w+[$;\s]*:[$;\s]*|)*[$;\s]*\bdefault[$;\s]*:[$;\s]*;/g) {
4490			my $ctx = '';
4491			my $herectx = $here . "\n";
4492			my $cnt = statement_rawlines($stat);
4493			for (my $n = 0; $n < $cnt; $n++) {
4494				$herectx .= raw_line($linenr, $n) . "\n";
4495			}
4496			WARN("DEFAULT_NO_BREAK",
4497			     "switch default: should use break\n" . $herectx);
4498		}
4499
4500# check for gcc specific __FUNCTION__
4501		if ($line =~ /\b__FUNCTION__\b/) {
4502			if (WARN("USE_FUNC",
4503				 "__func__ should be used instead of gcc specific __FUNCTION__\n"  . $herecurr) &&
4504			    $fix) {
4505				$fixed[$linenr - 1] =~ s/\b__FUNCTION__\b/__func__/g;
4506			}
4507		}
4508
4509# check for use of yield()
4510		if ($line =~ /\byield\s*\(\s*\)/) {
4511			WARN("YIELD",
4512			     "Using yield() is generally wrong. See yield() kernel-doc (sched/core.c)\n"  . $herecurr);
4513		}
4514
4515# check for comparisons against true and false
4516		if ($line =~ /\+\s*(.*?)\b(true|false|$Lval)\s*(==|\!=)\s*(true|false|$Lval)\b(.*)$/i) {
4517			my $lead = $1;
4518			my $arg = $2;
4519			my $test = $3;
4520			my $otype = $4;
4521			my $trail = $5;
4522			my $op = "!";
4523
4524			($arg, $otype) = ($otype, $arg) if ($arg =~ /^(?:true|false)$/i);
4525
4526			my $type = lc($otype);
4527			if ($type =~ /^(?:true|false)$/) {
4528				if (("$test" eq "==" && "$type" eq "true") ||
4529				    ("$test" eq "!=" && "$type" eq "false")) {
4530					$op = "";
4531				}
4532
4533				CHK("BOOL_COMPARISON",
4534				    "Using comparison to $otype is error prone\n" . $herecurr);
4535
4536## maybe suggesting a correct construct would better
4537##				    "Using comparison to $otype is error prone.  Perhaps use '${lead}${op}${arg}${trail}'\n" . $herecurr);
4538
4539			}
4540		}
4541
4542# check for semaphores initialized locked
4543		if ($line =~ /^.\s*sema_init.+,\W?0\W?\)/) {
4544			WARN("CONSIDER_COMPLETION",
4545			     "consider using a completion\n" . $herecurr);
4546		}
4547
4548# recommend kstrto* over simple_strto* and strict_strto*
4549		if ($line =~ /\b((simple|strict)_(strto(l|ll|ul|ull)))\s*\(/) {
4550			WARN("CONSIDER_KSTRTO",
4551			     "$1 is obsolete, use k$3 instead\n" . $herecurr);
4552		}
4553
4554# check for __initcall(), use device_initcall() explicitly or more appropriate function please
4555		if ($line =~ /^.\s*__initcall\s*\(/) {
4556			WARN("USE_DEVICE_INITCALL",
4557			     "please use device_initcall() or more appropriate function instead of __initcall() (see include/linux/init.h)\n" . $herecurr);
4558		}
4559
4560# check for various ops structs, ensure they are const.
4561		my $struct_ops = qr{acpi_dock_ops|
4562				address_space_operations|
4563				backlight_ops|
4564				block_device_operations|
4565				dentry_operations|
4566				dev_pm_ops|
4567				dma_map_ops|
4568				extent_io_ops|
4569				file_lock_operations|
4570				file_operations|
4571				hv_ops|
4572				ide_dma_ops|
4573				intel_dvo_dev_ops|
4574				item_operations|
4575				iwl_ops|
4576				kgdb_arch|
4577				kgdb_io|
4578				kset_uevent_ops|
4579				lock_manager_operations|
4580				microcode_ops|
4581				mtrr_ops|
4582				neigh_ops|
4583				nlmsvc_binding|
4584				pci_raw_ops|
4585				pipe_buf_operations|
4586				platform_hibernation_ops|
4587				platform_suspend_ops|
4588				proto_ops|
4589				rpc_pipe_ops|
4590				seq_operations|
4591				snd_ac97_build_ops|
4592				soc_pcmcia_socket_ops|
4593				stacktrace_ops|
4594				sysfs_ops|
4595				tty_operations|
4596				usb_mon_operations|
4597				wd_ops}x;
4598		if ($line !~ /\bconst\b/ &&
4599		    $line =~ /\bstruct\s+($struct_ops)\b/) {
4600			WARN("CONST_STRUCT",
4601			     "struct $1 should normally be const\n" .
4602				$herecurr);
4603		}
4604
4605# use of NR_CPUS is usually wrong
4606# ignore definitions of NR_CPUS and usage to define arrays as likely right
4607		if ($line =~ /\bNR_CPUS\b/ &&
4608		    $line !~ /^.\s*\s*#\s*if\b.*\bNR_CPUS\b/ &&
4609		    $line !~ /^.\s*\s*#\s*define\b.*\bNR_CPUS\b/ &&
4610		    $line !~ /^.\s*$Declare\s.*\[[^\]]*NR_CPUS[^\]]*\]/ &&
4611		    $line !~ /\[[^\]]*\.\.\.[^\]]*NR_CPUS[^\]]*\]/ &&
4612		    $line !~ /\[[^\]]*NR_CPUS[^\]]*\.\.\.[^\]]*\]/)
4613		{
4614			WARN("NR_CPUS",
4615			     "usage of NR_CPUS is often wrong - consider using cpu_possible(), num_possible_cpus(), for_each_possible_cpu(), etc\n" . $herecurr);
4616		}
4617
4618# Use of __ARCH_HAS_<FOO> or ARCH_HAVE_<BAR> is wrong.
4619		if ($line =~ /\+\s*#\s*define\s+((?:__)?ARCH_(?:HAS|HAVE)\w*)\b/) {
4620			ERROR("DEFINE_ARCH_HAS",
4621			      "#define of '$1' is wrong - use Kconfig variables or standard guards instead\n" . $herecurr);
4622		}
4623
4624# check for %L{u,d,i} in strings
4625		my $string;
4626		while ($line =~ /(?:^|")([X\t]*)(?:"|$)/g) {
4627			$string = substr($rawline, $-[1], $+[1] - $-[1]);
4628			$string =~ s/%%/__/g;
4629			if ($string =~ /(?<!%)%L[udi]/) {
4630				WARN("PRINTF_L",
4631				     "\%Ld/%Lu are not-standard C, use %lld/%llu\n" . $herecurr);
4632				last;
4633			}
4634		}
4635
4636# whine mightly about in_atomic
4637		if ($line =~ /\bin_atomic\s*\(/) {
4638			if ($realfile =~ m@^drivers/@) {
4639				ERROR("IN_ATOMIC",
4640				      "do not use in_atomic in drivers\n" . $herecurr);
4641			} elsif ($realfile !~ m@^kernel/@) {
4642				WARN("IN_ATOMIC",
4643				     "use of in_atomic() is incorrect outside core kernel code\n" . $herecurr);
4644			}
4645		}
4646
4647# check for lockdep_set_novalidate_class
4648		if ($line =~ /^.\s*lockdep_set_novalidate_class\s*\(/ ||
4649		    $line =~ /__lockdep_no_validate__\s*\)/ ) {
4650			if ($realfile !~ m@^kernel/lockdep@ &&
4651			    $realfile !~ m@^include/linux/lockdep@ &&
4652			    $realfile !~ m@^drivers/base/core@) {
4653				ERROR("LOCKDEP",
4654				      "lockdep_no_validate class is reserved for device->mutex.\n" . $herecurr);
4655			}
4656		}
4657
4658		if ($line =~ /debugfs_create_file.*S_IWUGO/ ||
4659		    $line =~ /DEVICE_ATTR.*S_IWUGO/ ) {
4660			WARN("EXPORTED_WORLD_WRITABLE",
4661			     "Exporting world writable files is usually an error. Consider more restrictive permissions.\n" . $herecurr);
4662		}
4663
4664# Mode permission misuses where it seems decimal should be octal
4665# This uses a shortcut match to avoid unnecessary uses of a slow foreach loop
4666		if ($^V && $^V ge 5.10.0 &&
4667		    $line =~ /$mode_perms_search/) {
4668			foreach my $entry (@mode_permission_funcs) {
4669				my $func = $entry->[0];
4670				my $arg_pos = $entry->[1];
4671
4672				my $skip_args = "";
4673				if ($arg_pos > 1) {
4674					$arg_pos--;
4675					$skip_args = "(?:\\s*$FuncArg\\s*,\\s*){$arg_pos,$arg_pos}";
4676				}
4677				my $test = "\\b$func\\s*\\(${skip_args}([\\d]+)\\s*[,\\)]";
4678				if ($line =~ /$test/) {
4679					my $val = $1;
4680					$val = $6 if ($skip_args ne "");
4681
4682					if ($val !~ /^0$/ &&
4683					    (($val =~ /^$Int$/ && $val !~ /^$Octal$/) ||
4684					     length($val) ne 4)) {
4685						ERROR("NON_OCTAL_PERMISSIONS",
4686						      "Use 4 digit octal (0777) not decimal permissions\n" . $herecurr);
4687					}
4688				}
4689			}
4690		}
4691	}
4692
4693	# If we have no input at all, then there is nothing to report on
4694	# so just keep quiet.
4695	if ($#rawlines == -1) {
4696		exit(0);
4697	}
4698
4699	# In mailback mode only produce a report in the negative, for
4700	# things that appear to be patches.
4701	if ($mailback && ($clean == 1 || !$is_patch)) {
4702		exit(0);
4703	}
4704
4705	# This is not a patch, and we are are in 'no-patch' mode so
4706	# just keep quiet.
4707	if (!$chk_patch && !$is_patch) {
4708		exit(0);
4709	}
4710
4711	if (!$is_patch) {
4712		ERROR("NOT_UNIFIED_DIFF",
4713		      "Does not appear to be a unified-diff format patch\n");
4714	}
4715	if ($is_patch && $chk_signoff && $signoff == 0) {
4716		ERROR("MISSING_SIGN_OFF",
4717		      "Missing Signed-off-by: line(s)\n");
4718	}
4719
4720	print report_dump();
4721	if ($summary && !($clean == 1 && $quiet == 1)) {
4722		print "$filename " if ($summary_file);
4723		print "total: $cnt_error errors, $cnt_warn warnings, " .
4724			(($check)? "$cnt_chk checks, " : "") .
4725			"$cnt_lines lines checked\n";
4726		print "\n" if ($quiet == 0);
4727	}
4728
4729	if ($quiet == 0) {
4730
4731		if ($^V lt 5.10.0) {
4732			print("NOTE: perl $^V is not modern enough to detect all possible issues.\n");
4733			print("An upgrade to at least perl v5.10.0 is suggested.\n\n");
4734		}
4735
4736		# If there were whitespace errors which cleanpatch can fix
4737		# then suggest that.
4738		if ($rpt_cleaners) {
4739			print "NOTE: whitespace errors detected, you may wish to use scripts/cleanpatch or\n";
4740			print "      scripts/cleanfile\n\n";
4741			$rpt_cleaners = 0;
4742		}
4743	}
4744
4745	hash_show_words(\%use_type, "Used");
4746	hash_show_words(\%ignore_type, "Ignored");
4747
4748	if ($clean == 0 && $fix && "@rawlines" ne "@fixed") {
4749		my $newfile = $filename;
4750		$newfile .= ".EXPERIMENTAL-checkpatch-fixes" if (!$fix_inplace);
4751		my $linecount = 0;
4752		my $f;
4753
4754		open($f, '>', $newfile)
4755		    or die "$P: Can't open $newfile for write\n";
4756		foreach my $fixed_line (@fixed) {
4757			$linecount++;
4758			if ($file) {
4759				if ($linecount > 3) {
4760					$fixed_line =~ s/^\+//;
4761					print $f $fixed_line. "\n";
4762				}
4763			} else {
4764				print $f $fixed_line . "\n";
4765			}
4766		}
4767		close($f);
4768
4769		if (!$quiet) {
4770			print << "EOM";
4771Wrote EXPERIMENTAL --fix correction(s) to '$newfile'
4772
4773Do _NOT_ trust the results written to this file.
4774Do _NOT_ submit these changes without inspecting them for correctness.
4775
4776This EXPERIMENTAL file is simply a convenience to help rewrite patches.
4777No warranties, expressed or implied...
4778
4779EOM
4780		}
4781	}
4782
4783	if ($clean == 1 && $quiet == 0) {
4784		print "$vname has no obvious style problems and is ready for submission.\n"
4785	}
4786	if ($clean == 0 && $quiet == 0) {
4787		print << "EOM";
4788$vname has style problems, please review.
4789
4790If any of these errors are false positives, please report
4791them to the maintainer, see CHECKPATCH in MAINTAINERS.
4792EOM
4793	}
4794
4795	return $clean;
4796}
4797