checkpatch.pl 57.2 KB
Newer Older
1
2
#!/usr/bin/perl -w
# (c) 2001, Dave Jones. <davej@codemonkey.org.uk> (the file handling bit)
3
# (c) 2005, Joel Schopp <jschopp@austin.ibm.com> (the ugly bit)
4
5
6
7
8
9
# (c) 2007, Andy Whitcroft <apw@uk.ibm.com> (new conditions, test suite, etc)
# Licensed under the terms of the GNU GPL License version 2

use strict;

my $P = $0;
10
$P =~ s@.*/@@g;
11

Andy Whitcroft's avatar
Andy Whitcroft committed
12
my $V = '0.20';
13
14
15
16
17
18
19

use Getopt::Long qw(:config no_auto_abbrev);

my $quiet = 0;
my $tree = 1;
my $chk_signoff = 1;
my $chk_patch = 1;
20
my $tst_type = 0;
21
my $tst_only;
22
my $emacs = 0;
23
my $terse = 0;
24
25
my $file = 0;
my $check = 0;
26
27
my $summary = 1;
my $mailback = 0;
28
my $summary_file = 0;
29
my $root;
30
my %debug;
31
GetOptions(
32
	'q|quiet+'	=> \$quiet,
33
34
35
	'tree!'		=> \$tree,
	'signoff!'	=> \$chk_signoff,
	'patch!'	=> \$chk_patch,
36
	'emacs!'	=> \$emacs,
37
	'terse!'	=> \$terse,
38
39
40
41
	'file!'		=> \$file,
	'subjective!'	=> \$check,
	'strict!'	=> \$check,
	'root=s'	=> \$root,
42
43
	'summary!'	=> \$summary,
	'mailback!'	=> \$mailback,
44
45
	'summary-file!'	=> \$summary_file,

46
	'debug=s'	=> \%debug,
47
	'test-type!'	=> \$tst_type,
48
	'test-only=s'	=> \$tst_only,
49
50
51
52
53
) or exit;

my $exit = 0;

if ($#ARGV < 0) {
54
	print "usage: $P [options] patchfile\n";
55
	print "version: $V\n";
56
57
58
59
60
61
62
63
64
	print "options: -q               => quiet\n";
	print "         --no-tree        => run without a kernel tree\n";
	print "         --terse          => one line per report\n";
	print "         --emacs          => emacs compile window format\n";
	print "         --file           => check a source file\n";
	print "         --strict         => enable more subjective tests\n";
	print "         --root           => path to the kernel tree root\n";
	print "         --no-summary     => suppress the per-file summary\n";
	print "         --summary-file   => include the filename in summary\n";
65
66
67
	exit(1);
}

68
69
70
71
72
73
my $dbg_values = 0;
my $dbg_possible = 0;
for my $key (keys %debug) {
	eval "\${dbg_$key} = '$debug{$key}';"
}

74
75
76
77
78
if ($terse) {
	$emacs = 1;
	$quiet++;
}

79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
if ($tree) {
	if (defined $root) {
		if (!top_of_kernel_tree($root)) {
			die "$P: $root: --root does not point at a valid tree\n";
		}
	} else {
		if (top_of_kernel_tree('.')) {
			$root = '.';
		} elsif ($0 =~ m@(.*)/scripts/[^/]*$@ &&
						top_of_kernel_tree($1)) {
			$root = $1;
		}
	}

	if (!defined $root) {
		print "Must be run from the top-level dir. of a kernel tree\n";
		exit(2);
	}
97
98
}

99
100
101
102
103
104
105
106
107
108
109
my $emitted_corrupt = 0;

our $Ident       = qr{[A-Za-z_][A-Za-z\d_]*};
our $Storage	= qr{extern|static|asmlinkage};
our $Sparse	= qr{
			__user|
			__kernel|
			__force|
			__iomem|
			__must_check|
			__init_refok|
110
			__kprobes
111
112
113
114
115
116
117
		}x;
our $Attribute	= qr{
			const|
			__read_mostly|
			__kprobes|
			__(?:mem|cpu|dev|)(?:initdata|init)
		  }x;
118
our $Modifier;
119
120
121
122
123
124
125
126
127
our $Inline	= qr{inline|__always_inline|noinline};
our $Member	= qr{->$Ident|\.$Ident|\[[^]]*\]};
our $Lval	= qr{$Ident(?:$Member)*};

our $Constant	= qr{(?:[0-9]+|0x[0-9a-fA-F]+)[UL]*};
our $Assignment	= qr{(?:\*\=|/=|%=|\+=|-=|<<=|>>=|&=|\^=|\|=|=)};
our $Operators	= qr{
			<=|>=|==|!=|
			=>|->|<<|>>|<|>|!|~|
128
			&&|\|\||,|\^|\+\+|--|&|\||\+|-|\*|\/|%
129
130
		  }x;

131
132
133
134
our $NonptrType;
our $Type;
our $Declare;

135
136
137
138
139
140
141
142
143
144
145
our $UTF8	= qr {
	[\x09\x0A\x0D\x20-\x7E]              # ASCII
	| [\xC2-\xDF][\x80-\xBF]             # non-overlong 2-byte
	|  \xE0[\xA0-\xBF][\x80-\xBF]        # excluding overlongs
	| [\xE1-\xEC\xEE\xEF][\x80-\xBF]{2}  # straight 3-byte
	|  \xED[\x80-\x9F][\x80-\xBF]        # excluding surrogates
	|  \xF0[\x90-\xBF][\x80-\xBF]{2}     # planes 1-3
	| [\xF1-\xF3][\x80-\xBF]{3}          # planes 4-15
	|  \xF4[\x80-\x8F][\x80-\xBF]{2}     # plane 16
}x;

146
147
our @typeList = (
	qr{void},
148
149
150
151
152
153
154
	qr{(?:unsigned\s+)?char},
	qr{(?:unsigned\s+)?short},
	qr{(?:unsigned\s+)?int},
	qr{(?:unsigned\s+)?long},
	qr{(?:unsigned\s+)?long\s+int},
	qr{(?:unsigned\s+)?long\s+long},
	qr{(?:unsigned\s+)?long\s+long\s+int},
155
156
157
158
159
160
161
162
163
164
165
166
	qr{unsigned},
	qr{float},
	qr{double},
	qr{bool},
	qr{(?:__)?(?:u|s|be|le)(?:8|16|32|64)},
	qr{struct\s+$Ident},
	qr{union\s+$Ident},
	qr{enum\s+$Ident},
	qr{${Ident}_t},
	qr{${Ident}_handler},
	qr{${Ident}_handler_fn},
);
167
168
169
our @modifierList = (
	qr{fastcall},
);
170
171

sub build_types {
172
	my $mods = "(?:  \n" . join("|\n  ", @modifierList) . "\n)";
173
174
175
	my $all = "(?:  \n" . join("|\n  ", @typeList) . "\n)";
	$NonptrType	= qr{
			(?:const\s+)?
176
			(?:$mods\s+)?
177
			(?:
178
179
				(?:typeof|__typeof__)\s*\(\s*\**\s*$Ident\s*\)|
				(?:${all}\b)
180
			)
181
182
183
			(?:\s+$Sparse|\s+const)*
		  }x;
	$Type	= qr{
184
			$NonptrType
185
			(?:\s*\*+\s*const|\s*\*+|(?:\s*\[\s*\])+)?
186
			(?:\s+$Inline|\s+$Sparse|\s+$Attribute|\s+$mods)*
187
188
		  }x;
	$Declare	= qr{(?:$Storage\s+)?$Type};
189
	$Modifier	= qr{(?:$Attribute|$Sparse|$mods)};
190
191
}
build_types();
192
193
194

$chk_signoff = 0 if ($file);

195
196
my @dep_includes = ();
my @dep_functions = ();
197
198
199
200
my $removal = "Documentation/feature-removal-schedule.txt";
if ($tree && -f "$root/$removal") {
	open(REMOVE, "<$root/$removal") ||
				die "$P: $removal: open failed - $!\n";
201
	while (<REMOVE>) {
202
203
204
		if (/^Check:\s+(.*\S)/) {
			for my $entry (split(/[, ]+/, $1)) {
				if ($entry =~ m@include/(.*)@) {
205
206
					push(@dep_includes, $1);

207
208
209
				} elsif ($entry !~ m@/@) {
					push(@dep_functions, $entry);
				}
210
			}
211
212
213
214
		}
	}
}

215
my @rawlines = ();
216
217
my @lines = ();
my $vname;
218
219
220
221
222
223
224
for my $filename (@ARGV) {
	if ($file) {
		open(FILE, "diff -u /dev/null $filename|") ||
			die "$P: $filename: diff failed - $!\n";
	} else {
		open(FILE, "<$filename") ||
			die "$P: $filename: open failed - $!\n";
225
	}
226
227
228
229
230
	if ($filename eq '-') {
		$vname = 'Your patch';
	} else {
		$vname = $filename;
	}
231
232
233
234
235
	while (<FILE>) {
		chomp;
		push(@rawlines, $_);
	}
	close(FILE);
236
	if (!process($filename)) {
237
238
239
		$exit = 1;
	}
	@rawlines = ();
240
	@lines = ();
241
242
243
244
245
}

exit($exit);

sub top_of_kernel_tree {
246
247
248
249
250
251
252
253
254
255
256
257
	my ($root) = @_;

	my @tree_check = (
		"COPYING", "CREDITS", "Kbuild", "MAINTAINERS", "Makefile",
		"README", "Documentation", "arch", "include", "drivers",
		"fs", "init", "ipc", "kernel", "lib", "scripts",
	);

	foreach my $check (@tree_check) {
		if (! -e $root . '/' . $check) {
			return 0;
		}
258
	}
259
	return 1;
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
}

sub expand_tabs {
	my ($str) = @_;

	my $res = '';
	my $n = 0;
	for my $c (split(//, $str)) {
		if ($c eq "\t") {
			$res .= ' ';
			$n++;
			for (; ($n % 8) != 0; $n++) {
				$res .= ' ';
			}
			next;
		}
		$res .= $c;
		$n++;
	}

	return $res;
}
282
sub copy_spacing {
283
	(my $res = shift) =~ tr/\t/ /c;
284
285
	return $res;
}
286

287
288
289
290
291
292
293
294
295
296
297
298
299
sub line_stats {
	my ($line) = @_;

	# Drop the diff line leader and expand tabs
	$line =~ s/^.//;
	$line = expand_tabs($line);

	# Pick the indent from the front of the line.
	my ($white) = ($line =~ /^(\s*)/);

	return (length($line), length($white));
}

300
301
302
303
304
305
306
307
308
309
310
my $sanitise_quote = '';

sub sanitise_line_reset {
	my ($in_comment) = @_;

	if ($in_comment) {
		$sanitise_quote = '*/';
	} else {
		$sanitise_quote = '';
	}
}
311
312
313
314
315
316
sub sanitise_line {
	my ($line) = @_;

	my $res = '';
	my $l = '';

317
	my $qlen = 0;
318
319
	my $off = 0;
	my $c;
320

321
322
323
324
325
326
327
328
329
330
331
332
333
334
	# Always copy over the diff marker.
	$res = substr($line, 0, 1);

	for ($off = 1; $off < length($line); $off++) {
		$c = substr($line, $off, 1);

		# Comments we are wacking completly including the begin
		# and end, all to $;.
		if ($sanitise_quote eq '' && substr($line, $off, 2) eq '/*') {
			$sanitise_quote = '*/';

			substr($res, $off, 2, "$;$;");
			$off++;
			next;
335
		}
336
		if (substr($line, $off, 2) eq '*/') {
337
338
339
340
			$sanitise_quote = '';
			substr($res, $off, 2, "$;$;");
			$off++;
			next;
341
		}
342
343
344
345
346
347
348

		# A \ in a string means ignore the next character.
		if (($sanitise_quote eq "'" || $sanitise_quote eq '"') &&
		    $c eq "\\") {
			substr($res, $off, 2, 'XX');
			$off++;
			next;
349
		}
350
351
352
353
		# Regular quotes.
		if ($c eq "'" || $c eq '"') {
			if ($sanitise_quote eq '') {
				$sanitise_quote = $c;
354

355
356
357
358
359
360
				substr($res, $off, 1, $c);
				next;
			} elsif ($sanitise_quote eq $c) {
				$sanitise_quote = '';
			}
		}
361

362
363
364
365
366
367
368
369
		#print "SQ:$sanitise_quote\n";
		if ($off != 0 && $sanitise_quote eq '*/' && $c ne "\t") {
			substr($res, $off, 1, $;);
		} elsif ($off != 0 && $sanitise_quote && $c ne "\t") {
			substr($res, $off, 1, 'X');
		} else {
			substr($res, $off, 1, $c);
		}
370
371
372
	}

	# The pathname on a #include may be surrounded by '<' and '>'.
373
	if ($res =~ /^.\s*\#\s*include\s+\<(.*)\>/) {
374
375
376
377
		my $clean = 'X' x length($1);
		$res =~ s@\<.*\>@<$clean>@;

	# The whole of a #error is a string.
378
	} elsif ($res =~ /^.\s*\#\s*(?:error|warning)\s+(.*)\b/) {
379
		my $clean = 'X' x length($1);
380
		$res =~ s@(\#\s*(?:error|warning)\s+).*@$1$clean@;
381
382
	}

383
384
385
	return $res;
}

386
387
388
389
390
391
sub ctx_statement_block {
	my ($linenr, $remain, $off) = @_;
	my $line = $linenr - 1;
	my $blk = '';
	my $soff = $off;
	my $coff = $off - 1;
392
	my $coff_set = 0;
393

394
395
	my $loff = 0;

396
397
	my $type = '';
	my $level = 0;
398
	my $p;
399
400
	my $c;
	my $len = 0;
401
402

	my $remainder;
403
	while (1) {
404
		#warn "CSB: blk<$blk> remain<$remain>\n";
405
406
407
408
		# If we are about to drop off the end, pull in more
		# context.
		if ($off >= $len) {
			for (; $remain > 0; $line++) {
409
				next if ($lines[$line] =~ /^-/);
410
				$remain--;
411
				$loff = $len;
412
				$blk .= $lines[$line] . "\n";
413
414
415
416
417
418
				$len = length($blk);
				$line++;
				last;
			}
			# Bail if there is no further context.
			#warn "CSB: blk<$blk> off<$off> len<$len>\n";
419
			if ($off >= $len) {
420
421
422
				last;
			}
		}
423
		$p = $c;
424
		$c = substr($blk, $off, 1);
425
		$remainder = substr($blk, $off);
426

427
		#warn "CSB: c<$c> type<$type> level<$level> remainder<$remainder> coff_set<$coff_set>\n";
428
429
430
431
432
433
		# Statement ends at the ';' or a close '}' at the
		# outermost level.
		if ($level == 0 && $c eq ';') {
			last;
		}

434
		# An else is really a conditional as long as its not else if
435
436
437
438
439
440
441
442
		if ($level == 0 && $coff_set == 0 &&
				(!defined($p) || $p =~ /(?:\s|\}|\+)/) &&
				$remainder =~ /^(else)(?:\s|{)/ &&
				$remainder !~ /^else\s+if\b/) {
			$coff = $off + length($1) - 1;
			$coff_set = 1;
			#warn "CSB: mark coff<$coff> soff<$soff> 1<$1>\n";
			#warn "[" . substr($blk, $soff, $coff - $soff + 1) . "]\n";
443
444
		}

445
446
447
448
449
450
451
452
453
454
		if (($type eq '' || $type eq '(') && $c eq '(') {
			$level++;
			$type = '(';
		}
		if ($type eq '(' && $c eq ')') {
			$level--;
			$type = ($level != 0)? '(' : '';

			if ($level == 0 && $coff < $soff) {
				$coff = $off;
455
456
				$coff_set = 1;
				#warn "CSB: mark coff<$coff>\n";
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
			}
		}
		if (($type eq '' || $type eq '{') && $c eq '{') {
			$level++;
			$type = '{';
		}
		if ($type eq '{' && $c eq '}') {
			$level--;
			$type = ($level != 0)? '{' : '';

			if ($level == 0) {
				last;
			}
		}
		$off++;
	}
473
474
475
476
	if ($off == $len) {
		$line++;
		$remain--;
	}
477
478
479
480
481
482
483

	my $statement = substr($blk, $soff, $off - $soff + 1);
	my $condition = substr($blk, $soff, $coff - $soff + 1);

	#warn "STATEMENT<$statement>\n";
	#warn "CONDITION<$condition>\n";

484
	#print "coff<$coff> soff<$off> loff<$loff>\n";
485
486
487
488
489

	return ($statement, $condition,
			$line, $remain + 1, $off - $loff + 1, $level);
}

490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
sub statement_lines {
	my ($stmt) = @_;

	# Strip the diff line prefixes and rip blank lines at start and end.
	$stmt =~ s/(^|\n)./$1/g;
	$stmt =~ s/^\s*//;
	$stmt =~ s/\s*$//;

	my @stmt_lines = ($stmt =~ /\n/g);

	return $#stmt_lines + 2;
}

sub statement_rawlines {
	my ($stmt) = @_;

	my @stmt_lines = ($stmt =~ /\n/g);

	return $#stmt_lines + 2;
}

sub statement_block_size {
	my ($stmt) = @_;

	$stmt =~ s/(^|\n)./$1/g;
	$stmt =~ s/^\s*{//;
	$stmt =~ s/}\s*$//;
	$stmt =~ s/^\s*//;
	$stmt =~ s/\s*$//;

	my @stmt_lines = ($stmt =~ /\n/g);
	my @stmt_statements = ($stmt =~ /;/g);

	my $stmt_lines = $#stmt_lines + 2;
	my $stmt_statements = $#stmt_statements + 1;

	if ($stmt_lines > $stmt_statements) {
		return $stmt_lines;
	} else {
		return $stmt_statements;
	}
}

533
534
535
536
537
538
sub ctx_statement_full {
	my ($linenr, $remain, $off) = @_;
	my ($statement, $condition, $level);

	my (@chunks);

539
	# Grab the first conditional/block pair.
540
541
	($statement, $condition, $linenr, $remain, $off, $level) =
				ctx_statement_block($linenr, $remain, $off);
542
	#print "F: c<$condition> s<$statement> remain<$remain>\n";
543
544
545
546
547
548
549
	push(@chunks, [ $condition, $statement ]);
	if (!($remain > 0 && $condition =~ /^\s*(?:\n[+-])?\s*(?:if|else|do)\b/s)) {
		return ($level, $linenr, @chunks);
	}

	# Pull in the following conditional/block pairs and see if they
	# could continue the statement.
550
551
552
	for (;;) {
		($statement, $condition, $linenr, $remain, $off, $level) =
				ctx_statement_block($linenr, $remain, $off);
553
		#print "C: c<$condition> s<$statement> remain<$remain>\n";
554
		last if (!($remain > 0 && $condition =~ /^(?:\s*\n[+-])*\s*(?:else|do)\b/s));
555
556
		#print "C: push\n";
		push(@chunks, [ $condition, $statement ]);
557
558
559
	}

	return ($level, $linenr, @chunks);
560
561
}

562
sub ctx_block_get {
563
	my ($linenr, $remain, $outer, $open, $close, $off) = @_;
564
565
566
567
568
569
570
	my $line;
	my $start = $linenr - 1;
	my $blk = '';
	my @o;
	my @c;
	my @res = ();

571
	my $level = 0;
572
573
574
575
576
	for ($line = $start; $remain > 0; $line++) {
		next if ($rawlines[$line] =~ /^-/);
		$remain--;

		$blk .= $rawlines[$line];
577
578
579
580
581
582
		foreach my $c (split(//, $rawlines[$line])) {
			##print "C<$c>L<$level><$open$close>O<$off>\n";
			if ($off > 0) {
				$off--;
				next;
			}
583

584
585
586
587
588
589
590
			if ($c eq $close && $level > 0) {
				$level--;
				last if ($level == 0);
			} elsif ($c eq $open) {
				$level++;
			}
		}
591

592
		if (!$outer || $level <= 1) {
593
			push(@res, $rawlines[$line]);
594
595
		}

596
		last if ($level == 0);
597
598
	}

599
	return ($level, @res);
600
601
602
603
}
sub ctx_block_outer {
	my ($linenr, $remain) = @_;

604
605
	my ($level, @r) = ctx_block_get($linenr, $remain, 1, '{', '}', 0);
	return @r;
606
607
608
609
}
sub ctx_block {
	my ($linenr, $remain) = @_;

610
611
	my ($level, @r) = ctx_block_get($linenr, $remain, 0, '{', '}', 0);
	return @r;
612
613
}
sub ctx_statement {
614
615
616
617
618
619
	my ($linenr, $remain, $off) = @_;

	my ($level, @r) = ctx_block_get($linenr, $remain, 0, '(', ')', $off);
	return @r;
}
sub ctx_block_level {
620
621
	my ($linenr, $remain) = @_;

622
	return ctx_block_get($linenr, $remain, 0, '{', '}', 0);
623
}
624
625
626
627
628
sub ctx_statement_level {
	my ($linenr, $remain, $off) = @_;

	return ctx_block_get($linenr, $remain, 0, '(', ')', $off);
}
629
630
631
632
633

sub ctx_locate_comment {
	my ($first_line, $end_line) = @_;

	# Catch a comment on the end of the line itself.
634
	my ($current_comment) = ($rawlines[$end_line - 1] =~ m@.*(/\*.*\*/)\s*$@);
635
636
637
638
639
640
641
	return $current_comment if (defined $current_comment);

	# Look through the context and try and figure out if there is a
	# comment.
	my $in_comment = 0;
	$current_comment = '';
	for (my $linenr = $first_line; $linenr < $end_line; $linenr++) {
642
643
		my $line = $rawlines[$linenr - 1];
		#warn "           $line\n";
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
		if ($linenr == $first_line and $line =~ m@^.\s*\*@) {
			$in_comment = 1;
		}
		if ($line =~ m@/\*@) {
			$in_comment = 1;
		}
		if (!$in_comment && $current_comment ne '') {
			$current_comment = '';
		}
		$current_comment .= $line . "\n" if ($in_comment);
		if ($line =~ m@\*/@) {
			$in_comment = 0;
		}
	}

	chomp($current_comment);
	return($current_comment);
}
sub ctx_has_comment {
	my ($first_line, $end_line) = @_;
	my $cmt = ctx_locate_comment($first_line, $end_line);

666
	##print "LINE: $rawlines[$end_line - 1 ]\n";
667
668
669
670
671
	##print "CMMT: $cmt\n";

	return ($cmt ne '');
}

672
673
674
sub cat_vet {
	my ($vet) = @_;
	my ($res, $coded);
675

676
677
678
679
680
681
	$res = '';
	while ($vet =~ /([^[:cntrl:]]*)([[:cntrl:]]|$)/g) {
		$res .= $1;
		if ($2 ne '') {
			$coded = sprintf("^%c", unpack('C', $2) + 64);
			$res .= $coded;
682
683
		}
	}
684
	$res =~ s/$/\$/;
685

686
	return $res;
687
688
}

689
my $av_preprocessor = 0;
690
my $av_pending;
691
692
693
694
my @av_paren_type;

sub annotate_reset {
	$av_preprocessor = 0;
695
696
	$av_pending = '_';
	@av_paren_type = ('E');
697
698
}

699
700
sub annotate_values {
	my ($stream, $type) = @_;
701

702
703
704
	my $res;
	my $cur = $stream;

705
	print "$stream\n" if ($dbg_values > 1);
706
707

	while (length($cur)) {
708
		@av_paren_type = ('E') if ($#av_paren_type < 0);
709
		print " <" . join('', @av_paren_type) .
710
				"> <$type> <$av_pending>" if ($dbg_values > 1);
711
		if ($cur =~ /^(\s+)/o) {
712
713
			print "WS($1)\n" if ($dbg_values > 1);
			if ($1 =~ /\n/ && $av_preprocessor) {
714
				$type = pop(@av_paren_type);
715
				$av_preprocessor = 0;
716
717
			}

718
		} elsif ($cur =~ /^($Type)/) {
719
			print "DECLARE($1)\n" if ($dbg_values > 1);
720
721
			$type = 'T';

722
		} elsif ($cur =~ /^(\#\s*define\s*$Ident)(\(?)/o) {
723
			print "DEFINE($1,$2)\n" if ($dbg_values > 1);
724
			$av_preprocessor = 1;
725
726
727
728
729
730
			push(@av_paren_type, $type);
			if ($2 ne '') {
				$av_pending = 'N';
			}
			$type = 'E';

731
		} elsif ($cur =~ /^(\#\s*(?:undef\s*$Ident|include\b))/o) {
732
733
734
			print "UNDEF($1)\n" if ($dbg_values > 1);
			$av_preprocessor = 1;
			push(@av_paren_type, $type);
735

736
		} elsif ($cur =~ /^(\#\s*(?:ifdef|ifndef|if))/o) {
737
			print "PRE_START($1)\n" if ($dbg_values > 1);
738
			$av_preprocessor = 1;
739
740
741

			push(@av_paren_type, $type);
			push(@av_paren_type, $type);
742
			$type = 'E';
743

744
		} elsif ($cur =~ /^(\#\s*(?:else|elif))/o) {
745
746
747
748
749
			print "PRE_RESTART($1)\n" if ($dbg_values > 1);
			$av_preprocessor = 1;

			push(@av_paren_type, $av_paren_type[$#av_paren_type]);

750
			$type = 'E';
751

752
		} elsif ($cur =~ /^(\#\s*(?:endif))/o) {
753
754
755
756
757
758
759
760
			print "PRE_END($1)\n" if ($dbg_values > 1);

			$av_preprocessor = 1;

			# Assume all arms of the conditional end as this
			# one does, and continue as if the #endif was not here.
			pop(@av_paren_type);
			push(@av_paren_type, $type);
761
			$type = 'E';
762
763

		} elsif ($cur =~ /^(\\\n)/o) {
764
			print "PRECONT($1)\n" if ($dbg_values > 1);
765

766
767
768
769
770
		} elsif ($cur =~ /^(__attribute__)\s*\(?/o) {
			print "ATTR($1)\n" if ($dbg_values > 1);
			$av_pending = $type;
			$type = 'N';

771
		} elsif ($cur =~ /^(sizeof)\s*(\()?/o) {
772
			print "SIZEOF($1)\n" if ($dbg_values > 1);
773
			if (defined $2) {
774
				$av_pending = 'V';
775
776
777
			}
			$type = 'N';

778
		} elsif ($cur =~ /^(if|while|typeof|__typeof__|for)\b/o) {
779
			print "COND($1)\n" if ($dbg_values > 1);
780
			$av_pending = 'N';
781
782
783
			$type = 'N';

		} elsif ($cur =~/^(return|case|else)/o) {
784
			print "KEYWORD($1)\n" if ($dbg_values > 1);
785
786
787
			$type = 'N';

		} elsif ($cur =~ /^(\()/o) {
788
			print "PAREN('$1')\n" if ($dbg_values > 1);
789
790
			push(@av_paren_type, $av_pending);
			$av_pending = '_';
791
792
793
			$type = 'N';

		} elsif ($cur =~ /^(\))/o) {
794
795
796
			my $new_type = pop(@av_paren_type);
			if ($new_type ne '_') {
				$type = $new_type;
797
798
				print "PAREN('$1') -> $type\n"
							if ($dbg_values > 1);
799
			} else {
800
				print "PAREN('$1')\n" if ($dbg_values > 1);
801
802
803
			}

		} elsif ($cur =~ /^($Ident)\(/o) {
804
			print "FUNC($1)\n" if ($dbg_values > 1);
805
			$av_pending = 'V';
806
807

		} elsif ($cur =~ /^($Ident|$Constant)/o) {
808
			print "IDENT($1)\n" if ($dbg_values > 1);
809
810
811
			$type = 'V';

		} elsif ($cur =~ /^($Assignment)/o) {
812
			print "ASSIGN($1)\n" if ($dbg_values > 1);
813
814
			$type = 'N';

815
		} elsif ($cur =~/^(;|{|})/) {
816
			print "END($1)\n" if ($dbg_values > 1);
817
818
			$type = 'E';

819
		} elsif ($cur =~ /^(;|\?|:|\[)/o) {
820
			print "CLOSE($1)\n" if ($dbg_values > 1);
821
822
823
			$type = 'N';

		} elsif ($cur =~ /^($Operators)/o) {
824
			print "OP($1)\n" if ($dbg_values > 1);
825
826
827
828
829
			if ($1 ne '++' && $1 ne '--') {
				$type = 'N';
			}

		} elsif ($cur =~ /(^.)/o) {
830
			print "C($1)\n" if ($dbg_values > 1);
831
832
833
834
835
		}
		if (defined $1) {
			$cur = substr($cur, length($1));
			$res .= $type x length($1);
		}
836
	}
837

838
	return $res;
839
840
}

841
sub possible {
842
	my ($possible, $line) = @_;
843

844
	print "CHECK<$possible> ($line)\n" if ($dbg_possible > 1);
845
846
847
	if ($possible !~ /^(?:$Storage|$Type|DEFINE_\S+)$/ &&
	    $possible ne 'goto' && $possible ne 'return' &&
	    $possible ne 'case' && $possible ne 'else' &&
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
	    $possible ne 'asm' &&
	    $possible !~ /^(typedef|struct|enum)\b/) {
		# Check for modifiers.
		$possible =~ s/\s*$Storage\s*//g;
		$possible =~ s/\s*$Sparse\s*//g;
		if ($possible =~ /^\s*$/) {

		} elsif ($possible =~ /\s/) {
			$possible =~ s/\s*$Type\s*//g;
			warn "MODIFIER: $possible ($line)\n" if ($dbg_possible);
			push(@modifierList, $possible);

		} else {
			warn "POSSIBLE: $possible ($line)\n" if ($dbg_possible);
			push(@typeList, $possible);
		}
864
865
866
867
		build_types();
	}
}

868
869
my $prefix = '';

870
sub report {
871
872
873
	if (defined $tst_only && $_[0] !~ /\Q$tst_only\E/) {
		return 0;
	}
874
875
876
877
	my $line = $prefix . $_[0];

	$line = (split('\n', $line))[0] . "\n" if ($terse);

878
	push(our @report, $line);
879
880

	return 1;
881
882
}
sub report_dump {
883
	our @report;
884
}
885
sub ERROR {
886
887
888
889
	if (report("ERROR: $_[0]\n")) {
		our $clean = 0;
		our $cnt_error++;
	}
890
891
}
sub WARN {
892
893
894
895
	if (report("WARNING: $_[0]\n")) {
		our $clean = 0;
		our $cnt_warn++;
	}
896
897
}
sub CHK {
898
	if ($check && report("CHECK: $_[0]\n")) {
899
900
901
		our $clean = 0;
		our $cnt_chk++;
	}
902
903
}

904
905
906
907
908
sub process {
	my $filename = shift;

	my $linenr=0;
	my $prevline="";
909
	my $prevrawline="";
910
	my $stashline="";
911
	my $stashrawline="";
912

913
	my $length;
914
915
916
917
	my $indent;
	my $previndent=0;
	my $stashindent=0;

918
	our $clean = 1;
919
920
921
	my $signoff = 0;
	my $is_patch = 0;

922
	our @report = ();
923
924
925
926
927
	our $cnt_lines = 0;
	our $cnt_error = 0;
	our $cnt_warn = 0;
	our $cnt_chk = 0;

928
929
930
931
932
933
	# Trace the real file/line as we go.
	my $realfile = '';
	my $realline = 0;
	my $realcnt = 0;
	my $here = '';
	my $in_comment = 0;
934
	my $comment_edge = 0;
935
936
	my $first_line = 0;

937
938
939
	my $prev_values = 'E';

	# suppression flags
940
	my %suppress_ifbraces;
941

942
	# Pre-scan the patch sanitizing the lines.
943
	# Pre-scan the patch looking for any __setup documentation.
944
	#
945
946
	my @setup_docs = ();
	my $setup_docs = 0;
947
948

	sanitise_line_reset();
949
950
	my $line;
	foreach my $rawline (@rawlines) {
951
952
		$linenr++;
		$line = $rawline;
953

954
		if ($rawline=~/^\+\+\+\s+(\S+)/) {
955
956
957
958
			$setup_docs = 0;
			if ($1 =~ m@Documentation/kernel-parameters.txt$@) {
				$setup_docs = 1;
			}
959
960
961
962
963
964
965
966
967
			#next;
		}
		if ($rawline=~/^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@/) {
			$realline=$1-1;
			if (defined $2) {
				$realcnt=$3+1;
			} else {
				$realcnt=1+1;
			}
968
			$in_comment = 0;
969
970
971
972
973
974

			# Guestimate if this is a continuing comment.  Run
			# the context looking for a comment "edge".  If this
			# edge is a close comment then we must be in a comment
			# at context start.
			my $edge;
975
			for (my $ln = $linenr + 1; $ln < ($linenr + $realcnt); $ln++) {
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
				next if ($line =~ /^-/);
				($edge) = ($rawlines[$ln - 1] =~ m@(/\*|\*/)@);
				last if (defined $edge);
			}
			if (defined $edge && $edge eq '*/') {
				$in_comment = 1;
			}

			# Guestimate if this is a continuing comment.  If this
			# is the start of a diff block and this line starts
			# ' *' then it is very likely a comment.
			if (!defined $edge &&
			    $rawlines[$linenr] =~ m@^.\s* \*(?:\s|$)@)
			{
				$in_comment = 1;
			}

			##print "COMMENT:$in_comment edge<$edge> $rawline\n";
			sanitise_line_reset($in_comment);

996
		} elsif ($realcnt && $rawline =~ /^(?:\+| |$)/) {
997
			# Standardise the strings and chars within the input to
998
			# simplify matching -- only bother with positive lines.
999
			$line = sanitise_line($rawline);
1000
		}
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
		push(@lines, $line);

		if ($realcnt > 1) {
			$realcnt-- if ($line =~ /^(?:\+| |$)/);
		} else {
			$realcnt = 0;
		}

		#print "==>$rawline\n";
		#print "-->$line\n";
1011
1012
1013
1014
1015
1016

		if ($setup_docs && $line =~ /^\+/) {
			push(@setup_docs, $line);
		}
	}

1017
1018
	$prefix = '';

1019
1020
	$realcnt = 0;
	$linenr = 0;
1021
1022
1023
	foreach my $line (@lines) {
		$linenr++;

1024
		my $rawline = $rawlines[$linenr - 1];
1025

1026
#extract the line range in the file after the patch is applied
1027
		if ($line=~/^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@/) {
1028
			$is_patch = 1;
1029
			$first_line = $linenr + 1;
1030
1031
1032
1033
1034
1035
			$realline=$1-1;
			if (defined $2) {
				$realcnt=$3+1;
			} else {
				$realcnt=1+1;
			}
1036
			annotate_reset();
1037
1038
			$prev_values = 'E';

1039
			%suppress_ifbraces = ();
1040
1041
			next;

1042
1043
1044
# track the line number as we move through the hunk, note that
# new versions of GNU diff omit the leading space on completely
# blank context lines so we need to count that too.
1045
		} elsif ($line =~ /^( |\+|$)/) {
1046
			$realline++;
1047
			$realcnt-- if ($realcnt != 0);
1048

1049
			# Measure the line length and indent.
1050
			($length, $indent) = line_stats($rawline);
1051
1052
1053
1054

			# Track the previous line.
			($prevline, $stashline) = ($stashline, $line);
			($previndent, $stashindent) = ($stashindent, $indent);
1055
1056
			($prevrawline, $stashrawline) = ($stashrawline, $rawline);

1057
			#warn "line<$line>\n";
1058

1059
1060
		} elsif ($realcnt == 1) {
			$realcnt--;
1061
1062
1063
		}

#make up the handle for any error we report on this line
1064
1065
1066
		$prefix = "$filename:$realline: " if ($emacs && $file);
		$prefix = "$filename:$linenr: " if ($emacs && !$file);

1067
1068
		$here = "#$linenr: " if (!$file);
		$here = "#$realline: " if ($file);
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080

		# extract the filename as it passes
		if ($line=~/^\+\+\+\s+(\S+)/) {
			$realfile = $1;
			$realfile =~ s@^[^/]*/@@;

			if ($realfile =~ m@include/asm/@) {
				ERROR("do not modify files in include/asm, change architecture specific files in include/asm-<architecture>\n" . "$here$rawline\n");
			}
			next;
		}

1081
		$here .= "FILE: $realfile:$realline:" if ($realcnt != 0);
1082

1083
1084
1085
		my $hereline = "$here\n$rawline\n";
		my $herecurr = "$here\n$rawline\n";
		my $hereprev = "$here\n$prevrawline\n$rawline\n";
1086

1087
1088
		$cnt_lines++ if ($realcnt != 0);

1089
#check the patch for a signoff:
1090
		if ($line =~ /^\s*signed-off-by:/i) {
1091
1092
			# This is a signoff, if ugly, so do not double report.
			$signoff++;
1093
			if (!($line =~ /^\s*Signed-off-by:/)) {
1094
1095
				WARN("Signed-off-by: is the preferred form\n" .
					$herecurr);
1096
1097
			}
			if ($line =~ /^\s*signed-off-by:\S/i) {
1098
				WARN("space required after Signed-off-by:\n" .
1099
					$herecurr);
1100
1101
1102
			}
		}

1103
# Check for wrappage within a valid hunk of the file
1104
		if ($realcnt != 0 && $line !~ m{^(?:\+|-| |\\ No newline|$)}) {
1105
			ERROR("patch seems to be corrupt (line wrapped?)\n" .
1106
				$herecurr) if (!$emitted_corrupt++);
1107
1108
1109
1110
		}

# UTF-8 regex found at http://www.w3.org/International/questions/qa-forms-utf-8.en.php
		if (($realfile =~ /^$/ || $line =~ /^\+/) &&
1111
1112
1113
1114
1115
1116
1117
1118
		    $rawline !~ m/^$UTF8*$/) {
			my ($utf8_prefix) = ($rawline =~ /^($UTF8*)/);

			my $blank = copy_spacing($rawline);
			my $ptr = substr($blank, 0, length($utf8_prefix)) . "^";
			my $hereptr = "$hereline$ptr\n";

			ERROR("Invalid UTF-8, patch and commit message should be encoded in UTF-8\n" . $hereptr);
1119
1120
1121
1122
		}

#ignore lines being removed
		if ($line=~/^-/) {next;}
1123

1124
1125
# check we are in a valid source file if not then ignore this hunk
		next if ($realfile !~ /\.(h|c|s|S|pl|sh)$/);
1126
1127

#trailing whitespace
1128
		if ($line =~ /^\+.*\015/) {
1129
			my $herevet = "$here\n" . cat_vet($rawline) . "\n";
1130
1131
			ERROR("DOS line endings\n" . $herevet);

1132
1133
		} elsif ($rawline =~ /^\+.*\S\s+$/ || $rawline =~ /^\+\s+$/) {
			my $herevet = "$here\n" . cat_vet($rawline) . "\n";
1134
			ERROR("trailing whitespace\n" . $herevet);
1135
1136
		}
#80 column limit
1137
1138
1139
		if ($line =~ /^\+/ && $prevrawline !~ /\/\*\*/ &&
		    $rawline !~ /^.\s*\*\s*\@$Ident\s/ && $length > 80)
		{
1140
			WARN("line over 80 characters\n" . $herecurr);
1141
1142
		}

1143
1144
1145
1146
1147
# check for adding lines without a newline.
		if ($line =~ /^\+/ && defined $lines[$linenr] && $lines[$linenr] =~ /^\\ No newline at end of file/) {
			WARN("adding a line without newline at end of file\n" . $herecurr);
		}

1148
1149
1150
1151
1152
# check we are in a valid source file *.[hc] if not then ignore this hunk
		next if ($realfile !~ /\.[hc]$/);

# at the beginning of a line any tabs must come first and anything
# more than 8 must use tabs.
1153
1154
1155
		if ($rawline =~ /^\+\s* \t\s*\S/ ||
		    $rawline =~ /^\+\s*        \s*/) {
			my $herevet = "$here\n" . cat_vet($rawline) . "\n";
1156
			ERROR("code indent should use tabs where possible\n" . $herevet);
1157
1158
		}

1159
# check for RCS/CVS revision markers
1160
		if ($rawline =~ /^\+.*\$(Revision|Log|Id)(?:\$|)/) {
1161
1162
			WARN("CVS style keyword markers, these will _not_ be updated\n". $herecurr);
		}
1163