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