checkpatch.pl 50.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

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

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

my $exit = 0;

if ($#ARGV < 0) {
52
	print "usage: $P [options] patchfile\n";
53
	print "version: $V\n";
54
55
56
57
58
59
60
61
62
	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";
63
64
65
	exit(1);
}

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

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

77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
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);
	}
95
96
}

97
98
99
100
101
102
103
104
105
106
107
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|
108
			__kprobes
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
		}x;
our $Attribute	= qr{
			const|
			__read_mostly|
			__kprobes|
			__(?:mem|cpu|dev|)(?:initdata|init)
		  }x;
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{
			<=|>=|==|!=|
			=>|->|<<|>>|<|>|!|~|
125
			&&|\|\||,|\^|\+\+|--|&|\||\+|-|\*|\/|%
126
127
		  }x;

128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
our $NonptrType;
our $Type;
our $Declare;

our @typeList = (
	qr{void},
	qr{char},
	qr{short},
	qr{int},
	qr{long},
	qr{unsigned},
	qr{float},
	qr{double},
	qr{bool},
	qr{long\s+int},
	qr{long\s+long},
	qr{long\s+long\s+int},
	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},
);

sub build_types {
	my $all = "(?:  \n" . join("|\n  ", @typeList) . "\n)";
	$NonptrType	= qr{
			\b
			(?:const\s+)?
			(?:unsigned\s+)?
160
161
162
163
			(?:
				$all|
				(?:typeof|__typeof__)\s*\(\s*\**\s*$Ident\s*\)
			)
164
165
166
167
168
169
			(?:\s+$Sparse|\s+const)*
			\b
		  }x;
	$Type	= qr{
			\b$NonptrType\b
			(?:\s*\*+\s*const|\s*\*+|(?:\s*\[\s*\])+)?
170
			(?:\s+$Inline|\s+$Sparse|\s+$Attribute)*
171
172
173
174
		  }x;
	$Declare	= qr{(?:$Storage\s+)?$Type};
}
build_types();
175
176
177

$chk_signoff = 0 if ($file);

178
179
my @dep_includes = ();
my @dep_functions = ();
180
181
182
183
my $removal = "Documentation/feature-removal-schedule.txt";
if ($tree && -f "$root/$removal") {
	open(REMOVE, "<$root/$removal") ||
				die "$P: $removal: open failed - $!\n";
184
	while (<REMOVE>) {
185
186
187
		if (/^Check:\s+(.*\S)/) {
			for my $entry (split(/[, ]+/, $1)) {
				if ($entry =~ m@include/(.*)@) {
188
189
					push(@dep_includes, $1);

190
191
192
				} elsif ($entry !~ m@/@) {
					push(@dep_functions, $entry);
				}
193
			}
194
195
196
197
		}
	}
}

198
my @rawlines = ();
199
200
my @lines = ();
my $vname;
201
202
203
204
205
206
207
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";
208
	}
209
210
211
212
213
	if ($filename eq '-') {
		$vname = 'Your patch';
	} else {
		$vname = $filename;
	}
214
215
216
217
218
	while (<FILE>) {
		chomp;
		push(@rawlines, $_);
	}
	close(FILE);
219
	if (!process($filename)) {
220
221
222
		$exit = 1;
	}
	@rawlines = ();
223
	@lines = ();
224
225
226
227
228
}

exit($exit);

sub top_of_kernel_tree {
229
230
231
232
233
234
235
236
237
238
239
240
	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;
		}
241
	}
242
	return 1;
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
}

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;
}
265
266
267
268
269
270
271
272
273
274
275
276
277
278
sub copy_spacing {
	my ($str) = @_;

	my $res = '';
	for my $c (split(//, $str)) {
		if ($c eq "\t") {
			$res .= $c;
		} else {
			$res .= ' ';
		}
	}

	return $res;
}
279

280
281
282
283
284
285
286
287
288
289
290
291
292
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));
}

293
294
295
296
297
298
299
sub sanitise_line {
	my ($line) = @_;

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

	my $quote = '';
300
	my $qlen = 0;
301
302

	foreach my $c (split(//, $line)) {
303
304
305
306
		# The second backslash of a pair is not a "quote".
		if ($l eq "\\" && $c eq "\\") {
			$c = 'X';
		}
307
308
309
310
311
		if ($l ne "\\" && ($c eq "'" || $c eq '"')) {
			if ($quote eq '') {
				$quote = $c;
				$res .= $c;
				$l = $c;
312
				$qlen = 0;
313
314
315
316
317
				next;
			} elsif ($quote eq $c) {
				$quote = '';
			}
		}
318
319
320
		if ($quote eq "'" && $qlen > 1) {
			$quote = '';
		}
321
322
		if ($quote && $c ne "\t") {
			$res .= "X";
323
			$qlen++;
324
325
326
327
328
329
330
		} else {
			$res .= $c;
		}

		$l = $c;
	}

331
	# Clear out the comments.
332
333
	while ($res =~ m@(/\*.*?\*/)@g) {
		substr($res, $-[1], $+[1] - $-[1]) = $; x ($+[1] - $-[1]);
334
335
	}
	if ($res =~ m@(/\*.*)@) {
336
		substr($res, $-[1], $+[1] - $-[1]) = $; x ($+[1] - $-[1]);
337
338
	}
	if ($res =~ m@^.(.*\*/)@) {
339
		substr($res, $-[1], $+[1] - $-[1]) = $; x ($+[1] - $-[1]);
340
341
342
343
344
345
346
347
348
349
350
351
352
	}

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

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

353
354
355
	return $res;
}

356
357
358
359
360
361
362
sub ctx_statement_block {
	my ($linenr, $remain, $off) = @_;
	my $line = $linenr - 1;
	my $blk = '';
	my $soff = $off;
	my $coff = $off - 1;

363
364
	my $loff = 0;

365
366
	my $type = '';
	my $level = 0;
367
	my $p;
368
369
	my $c;
	my $len = 0;
370
371

	my $remainder;
372
373
374
375
376
377
	while (1) {
		#warn "CSB: blk<$blk>\n";
		# If we are about to drop off the end, pull in more
		# context.
		if ($off >= $len) {
			for (; $remain > 0; $line++) {
378
				next if ($lines[$line] =~ /^-/);
379
				$remain--;
380
				$loff = $len;
381
				$blk .= $lines[$line] . "\n";
382
383
384
385
386
387
				$len = length($blk);
				$line++;
				last;
			}
			# Bail if there is no further context.
			#warn "CSB: blk<$blk> off<$off> len<$len>\n";
388
			if ($off >= $len) {
389
390
391
				last;
			}
		}
392
		$p = $c;
393
		$c = substr($blk, $off, 1);
394
		$remainder = substr($blk, $off);
395
396
397
398
399
400
401
402

		#warn "CSB: c<$c> type<$type> level<$level>\n";
		# Statement ends at the ';' or a close '}' at the
		# outermost level.
		if ($level == 0 && $c eq ';') {
			last;
		}

403
		# An else is really a conditional as long as its not else if
404
405
406
		if ($level == 0 && (!defined($p) || $p =~ /(?:\s|\})/) &&
				$remainder =~ /(else)(?:\s|{)/ &&
				$remainder !~ /else\s+if\b/) {
407
408
409
			$coff = $off + length($1);
		}

410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
		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;
			}
		}
		if (($type eq '' || $type eq '{') && $c eq '{') {
			$level++;
			$type = '{';
		}
		if ($type eq '{' && $c eq '}') {
			$level--;
			$type = ($level != 0)? '{' : '';

			if ($level == 0) {
				last;
			}
		}
		$off++;
	}
436
437
438
439
	if ($off == $len) {
		$line++;
		$remain--;
	}
440
441
442
443
444
445
446

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

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

447
448
449
450
451
452
	#print "off<$off> loff<$loff>\n";

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

453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
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;
	}
}

496
497
498
499
500
501
sub ctx_statement_full {
	my ($linenr, $remain, $off) = @_;
	my ($statement, $condition, $level);

	my (@chunks);

502
	# Grab the first conditional/block pair.
503
504
505
	($statement, $condition, $linenr, $remain, $off, $level) =
				ctx_statement_block($linenr, $remain, $off);
	#print "F: c<$condition> s<$statement>\n";
506
507
508
509
510
511
512
	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.
513
514
515
	for (;;) {
		($statement, $condition, $linenr, $remain, $off, $level) =
				ctx_statement_block($linenr, $remain, $off);
516
517
518
519
		#print "C: c<$condition> s<$statement> remain<$remain>\n";
		last if (!($remain > 0 && $condition =~ /^\s*(?:\n[+-])?\s*(?:else|do)\b/s));
		#print "C: push\n";
		push(@chunks, [ $condition, $statement ]);
520
521
522
	}

	return ($level, $linenr, @chunks);
523
524
}

525
sub ctx_block_get {
526
	my ($linenr, $remain, $outer, $open, $close, $off) = @_;
527
528
529
530
531
532
533
	my $line;
	my $start = $linenr - 1;
	my $blk = '';
	my @o;
	my @c;
	my @res = ();

534
	my $level = 0;
535
536
537
538
539
	for ($line = $start; $remain > 0; $line++) {
		next if ($rawlines[$line] =~ /^-/);
		$remain--;

		$blk .= $rawlines[$line];
540
541
542
543
544
545
		foreach my $c (split(//, $rawlines[$line])) {
			##print "C<$c>L<$level><$open$close>O<$off>\n";
			if ($off > 0) {
				$off--;
				next;
			}
546

547
548
549
550
551
552
553
			if ($c eq $close && $level > 0) {
				$level--;
				last if ($level == 0);
			} elsif ($c eq $open) {
				$level++;
			}
		}
554

555
		if (!$outer || $level <= 1) {
556
			push(@res, $rawlines[$line]);
557
558
		}

559
		last if ($level == 0);
560
561
	}

562
	return ($level, @res);
563
564
565
566
}
sub ctx_block_outer {
	my ($linenr, $remain) = @_;

567
568
	my ($level, @r) = ctx_block_get($linenr, $remain, 1, '{', '}', 0);
	return @r;
569
570
571
572
}
sub ctx_block {
	my ($linenr, $remain) = @_;

573
574
	my ($level, @r) = ctx_block_get($linenr, $remain, 0, '{', '}', 0);
	return @r;
575
576
}
sub ctx_statement {
577
578
579
580
581
582
	my ($linenr, $remain, $off) = @_;

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

585
	return ctx_block_get($linenr, $remain, 0, '{', '}', 0);
586
}
587
588
589
590
591
sub ctx_statement_level {
	my ($linenr, $remain, $off) = @_;

	return ctx_block_get($linenr, $remain, 0, '(', ')', $off);
}
592
593
594
595
596

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

	# Catch a comment on the end of the line itself.
597
	my ($current_comment) = ($rawlines[$end_line - 1] =~ m@.*(/\*.*\*/)\s*$@);
598
599
600
601
602
603
604
	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++) {
605
606
		my $line = $rawlines[$linenr - 1];
		#warn "           $line\n";
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
		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);

629
	##print "LINE: $rawlines[$end_line - 1 ]\n";
630
631
632
633
634
	##print "CMMT: $cmt\n";

	return ($cmt ne '');
}

635
636
637
sub cat_vet {
	my ($vet) = @_;
	my ($res, $coded);
638

639
640
641
642
643
644
	$res = '';
	while ($vet =~ /([^[:cntrl:]]*)([[:cntrl:]]|$)/g) {
		$res .= $1;
		if ($2 ne '') {
			$coded = sprintf("^%c", unpack('C', $2) + 64);
			$res .= $coded;
645
646
		}
	}
647
	$res =~ s/$/\$/;
648

649
	return $res;
650
651
}

652
my $av_preprocessor = 0;
653
my $av_pending;
654
655
656
657
my @av_paren_type;

sub annotate_reset {
	$av_preprocessor = 0;
658
659
	$av_pending = '_';
	@av_paren_type = ('E');
660
661
}

662
663
sub annotate_values {
	my ($stream, $type) = @_;
664

665
666
667
	my $res;
	my $cur = $stream;

668
	print "$stream\n" if ($dbg_values > 1);
669
670

	while (length($cur)) {
671
672
		print " <" . join('', @av_paren_type) .
					"> <$type> " if ($dbg_values > 1);
673
		if ($cur =~ /^(\s+)/o) {
674
675
			print "WS($1)\n" if ($dbg_values > 1);
			if ($1 =~ /\n/ && $av_preprocessor) {
676
				$type = pop(@av_paren_type);
677
				$av_preprocessor = 0;
678
679
			}

680
		} elsif ($cur =~ /^($Type)/) {
681
			print "DECLARE($1)\n" if ($dbg_values > 1);
682
683
684
			$type = 'T';

		} elsif ($cur =~ /^(#\s*define\s*$Ident)(\(?)/o) {
685
686
			print "DEFINE($1)\n" if ($dbg_values > 1);
			$av_preprocessor = 1;
687
			$av_pending = 'N';
688

689
690
		} elsif ($cur =~ /^(#\s*(?:ifdef|ifndef|if))/o) {
			print "PRE_START($1)\n" if ($dbg_values > 1);
691
			$av_preprocessor = 1;
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713

			push(@av_paren_type, $type);
			push(@av_paren_type, $type);
			$type = 'N';

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

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

			$type = 'N';

		} elsif ($cur =~ /^(#\s*(?:endif))/o) {
			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);
714
715
716
			$type = 'N';

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

		} elsif ($cur =~ /^(sizeof)\s*(\()?/o) {
720
			print "SIZEOF($1)\n" if ($dbg_values > 1);
721
			if (defined $2) {
722
				$av_pending = 'V';
723
724
725
			}
			$type = 'N';

726
		} elsif ($cur =~ /^(if|while|typeof|__typeof__|for)\b/o) {
727
			print "COND($1)\n" if ($dbg_values > 1);
728
			$av_pending = 'N';
729
730
731
			$type = 'N';

		} elsif ($cur =~/^(return|case|else)/o) {
732
			print "KEYWORD($1)\n" if ($dbg_values > 1);
733
734
735
			$type = 'N';

		} elsif ($cur =~ /^(\()/o) {
736
			print "PAREN('$1')\n" if ($dbg_values > 1);
737
738
			push(@av_paren_type, $av_pending);
			$av_pending = '_';
739
740
741
			$type = 'N';

		} elsif ($cur =~ /^(\))/o) {
742
743
744
			my $new_type = pop(@av_paren_type);
			if ($new_type ne '_') {
				$type = $new_type;
745
746
				print "PAREN('$1') -> $type\n"
							if ($dbg_values > 1);
747
			} else {
748
				print "PAREN('$1')\n" if ($dbg_values > 1);
749
750
751
			}

		} elsif ($cur =~ /^($Ident)\(/o) {
752
			print "FUNC($1)\n" if ($dbg_values > 1);
753
			$av_pending = 'V';
754
755

		} elsif ($cur =~ /^($Ident|$Constant)/o) {
756
			print "IDENT($1)\n" if ($dbg_values > 1);
757
758
759
			$type = 'V';

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

763
		} elsif ($cur =~/^(;|{|})/) {
764
			print "END($1)\n" if ($dbg_values > 1);
765
766
			$type = 'E';

767
		} elsif ($cur =~ /^(;|\?|:|\[)/o) {
768
			print "CLOSE($1)\n" if ($dbg_values > 1);
769
770
771
			$type = 'N';

		} elsif ($cur =~ /^($Operators)/o) {
772
			print "OP($1)\n" if ($dbg_values > 1);
773
774
775
776
777
			if ($1 ne '++' && $1 ne '--') {
				$type = 'N';
			}

		} elsif ($cur =~ /(^.)/o) {
778
			print "C($1)\n" if ($dbg_values > 1);
779
780
781
782
783
		}
		if (defined $1) {
			$cur = substr($cur, length($1));
			$res .= $type x length($1);
		}
784
	}
785

786
	return $res;
787
788
}

789
sub possible {
790
	my ($possible, $line) = @_;
791
792
793
794
795
796
797

	#print "CHECK<$possible>\n";
	if ($possible !~ /^(?:$Storage|$Type|DEFINE_\S+)$/ &&
	    $possible ne 'goto' && $possible ne 'return' &&
	    $possible ne 'struct' && $possible ne 'enum' &&
	    $possible ne 'case' && $possible ne 'else' &&
	    $possible ne 'typedef') {
798
		warn "POSSIBLE: $possible ($line)\n" if ($dbg_possible);
799
800
801
802
803
		push(@typeList, $possible);
		build_types();
	}
}

804
805
my $prefix = '';

806
sub report {
807
808
809
810
	my $line = $prefix . $_[0];

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

811
	push(our @report, $line);
812
813
}
sub report_dump {
814
	our @report;
815
}
816
sub ERROR {
817
	report("ERROR: $_[0]\n");
818
	our $clean = 0;
819
	our $cnt_error++;
820
821
}
sub WARN {
822
	report("WARNING: $_[0]\n");
823
	our $clean = 0;
824
	our $cnt_warn++;
825
826
}
sub CHK {
827
828
829
830
831
	if ($check) {
		report("CHECK: $_[0]\n");
		our $clean = 0;
		our $cnt_chk++;
	}
832
833
}

834
835
836
837
838
sub process {
	my $filename = shift;

	my $linenr=0;
	my $prevline="";
839
	my $prevrawline="";
840
	my $stashline="";
841
	my $stashrawline="";
842

843
	my $length;
844
845
846
847
	my $indent;
	my $previndent=0;
	my $stashindent=0;

848
	our $clean = 1;
849
850
851
	my $signoff = 0;
	my $is_patch = 0;

852
	our @report = ();
853
854
855
856
857
	our $cnt_lines = 0;
	our $cnt_error = 0;
	our $cnt_warn = 0;
	our $cnt_chk = 0;

858
859
860
861
862
863
	# Trace the real file/line as we go.
	my $realfile = '';
	my $realline = 0;
	my $realcnt = 0;
	my $here = '';
	my $in_comment = 0;
864
	my $comment_edge = 0;
865
866
	my $first_line = 0;

867
868
869
870
	my $prev_values = 'E';

	# suppression flags
	my $suppress_ifbraces = 0;
871

872
	# Pre-scan the patch sanitizing the lines.
873
	# Pre-scan the patch looking for any __setup documentation.
874
	#
875
876
	my @setup_docs = ();
	my $setup_docs = 0;
877
878
879
880
881
882
883
884
885
886
	my $line;
	foreach my $rawline (@rawlines) {
		# Standardise the strings and chars within the input to
		# simplify matching.
		$line = sanitise_line($rawline);
		push(@lines, $line);

		##print "==>$rawline\n";
		##print "-->$line\n";

887
888
889
890
891
892
893
894
895
896
897
898
899
		if ($line=~/^\+\+\+\s+(\S+)/) {
			$setup_docs = 0;
			if ($1 =~ m@Documentation/kernel-parameters.txt$@) {
				$setup_docs = 1;
			}
			next;
		}

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

900
901
	$prefix = '';

902
903
904
	foreach my $line (@lines) {
		$linenr++;

905
		my $rawline = $rawlines[$linenr - 1];
906

907
908
909
#extract the filename as it passes
		if ($line=~/^\+\+\+\s+(\S+)/) {
			$realfile=$1;
910
			$realfile =~ s@^[^/]*/@@;
911
912
913
914
			$in_comment = 0;
			next;
		}
#extract the line range in the file after the patch is applied
915
		if ($line=~/^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@/) {
916
			$is_patch = 1;
917
			$first_line = $linenr + 1;
918
919
920
921
922
923
924
			$in_comment = 0;
			$realline=$1-1;
			if (defined $2) {
				$realcnt=$3+1;
			} else {
				$realcnt=1+1;
			}
925
			annotate_reset();
926
927
928
			$prev_values = 'E';

			$suppress_ifbraces = $linenr - 1;
929
930
931
			next;
		}

932
933
934
935
# 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.
		if ($line =~ /^( |\+|$)/) {
936
			$realline++;
937
			$realcnt-- if ($realcnt != 0);
938

939
940
941
942
943
944
945
			# 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.
			if ($linenr == $first_line) {
				my $edge;
				for (my $ln = $first_line; $ln < ($linenr + $realcnt); $ln++) {
946
					($edge) = ($rawlines[$ln - 1] =~ m@(/\*|\*/)@);
947
948
949
950
951
952
953
					last if (defined $edge);
				}
				if (defined $edge && $edge eq '*/') {
					$in_comment = 1;
				}
			}

954
955
956
			# 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.
957
			if ($linenr == $first_line and $rawline =~ m@^.\s* \*(?:\s|$)@) {
958
959
				$in_comment = 1;
			}
960
961

			# Find the last comment edge on _this_ line.
962
963
			$comment_edge = 0;
			while (($rawline =~ m@(/\*|\*/)@g)) {
964
965
966
967
968
				if ($1 eq '/*') {
					$in_comment = 1;
				} else {
					$in_comment = 0;
				}
969
				$comment_edge = 1;
970
971
			}

972
			# Measure the line length and indent.
973
			($length, $indent) = line_stats($rawline);
974
975
976
977

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

			#warn "ic<$in_comment> ce<$comment_edge> line<$line>\n";
981

982
983
		} elsif ($realcnt == 1) {
			$realcnt--;
984
985
986
		}

#make up the handle for any error we report on this line
987
988
		$here = "#$linenr: " if (!$file);
		$here = "#$realline: " if ($file);
989
		$here .= "FILE: $realfile:$realline:" if ($realcnt != 0);
990

991
992
993
		my $hereline = "$here\n$rawline\n";
		my $herecurr = "$here\n$rawline\n";
		my $hereprev = "$here\n$prevrawline\n$rawline\n";
994

995
996
997
998
		$prefix = "$filename:$realline: " if ($emacs && $file);
		$prefix = "$filename:$linenr: " if ($emacs && !$file);
		$cnt_lines++ if ($realcnt != 0);

999
#check the patch for a signoff:
1000
		if ($line =~ /^\s*signed-off-by:/i) {
1001
1002
			# This is a signoff, if ugly, so do not double report.
			$signoff++;
1003
			if (!($line =~ /^\s*Signed-off-by:/)) {
1004
1005
				WARN("Signed-off-by: is the preferred form\n" .
					$herecurr);
1006
1007
			}
			if ($line =~ /^\s*signed-off-by:\S/i) {
1008
1009
				WARN("need space after Signed-off-by:\n" .
					$herecurr);
1010
1011
1012
			}
		}

1013
# Check for wrappage within a valid hunk of the file
1014
		if ($realcnt != 0 && $line !~ m{^(?:\+|-| |\\ No newline|$)}) {
1015
			ERROR("patch seems to be corrupt (line wrapped?)\n" .
1016
				$herecurr) if (!$emitted_corrupt++);
1017
1018
1019
1020
		}

# UTF-8 regex found at http://www.w3.org/International/questions/qa-forms-utf-8.en.php
		if (($realfile =~ /^$/ || $line =~ /^\+/) &&
1021
		     !($rawline =~ m/^(
1022
1023
1024
1025
1026
1027
1028
1029
1030
				[\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 )) {
1031
			ERROR("Invalid UTF-8, patch and commit message should be encoded in UTF-8\n" . $herecurr);
1032
1033
1034
1035
		}

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

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

#trailing whitespace
1041
		if ($line =~ /^\+.*\015/) {
1042
			my $herevet = "$here\n" . cat_vet($rawline) . "\n";
1043
1044
			ERROR("DOS line endings\n" . $herevet);

1045
1046
		} elsif ($rawline =~ /^\+.*\S\s+$/ || $rawline =~ /^\+\s+$/) {
			my $herevet = "$here\n" . cat_vet($rawline) . "\n";
1047
			ERROR("trailing whitespace\n" . $herevet);
1048
1049
		}
#80 column limit
1050
		if ($line =~ /^\+/ && !($prevrawline=~/\/\*\*/) && $length > 80) {
1051
			WARN("line over 80 characters\n" . $herecurr);
1052
1053
		}

1054
1055
1056
1057
1058
# 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);
		}

1059
1060
1061
1062
1063
# 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.
1064
1065
1066
		if ($rawline =~ /^\+\s* \t\s*\S/ ||
		    $rawline =~ /^\+\s*        \s*/) {
			my $herevet = "$here\n" . cat_vet($rawline) . "\n";
1067
			ERROR("use tabs not spaces\n" . $herevet);
1068
1069
		}

1070
# check for RCS/CVS revision markers
1071
		if ($rawline =~ /^\+.*\$(Revision|Log|Id)(?:\$|)/) {
1072
1073
			WARN("CVS style keyword markers, these will _not_ be updated\n". $herecurr);
		}
1074
1075
1076
1077
1078

# The rest of our checks refer specifically to C style
# only apply those _outside_ comments.  Only skip
# lines in the middle of comments.
		next if (!$comment_edge && $in_comment);
1079

1080
# Check for potential 'bare' types
1081
		if ($realcnt) {
1082
1083
1084
1085
			my ($s, $c) = ctx_statement_block($linenr, $realcnt, 0);
			$s =~ s/\n./ /g;
			$s =~ s/{.*$//;

1086
			# Ignore goto labels.
1087
			if ($s =~ /$Ident:\*$/) {
1088
1089

			# Ignore functions being called
1090
			} elsif ($s =~ /^.\s*$Ident\s*\(/) {
1091

1092
			# definitions in global scope can only start with types
1093
1094
			} elsif ($s =~ /^.(?:$Storage\s+)?(?:$Inline\s+)?(?:const\s+)?($Ident)\b/) {
				possible($1, $s);
1095
1096

			# declarations always start with types
1097
1098
			} elsif ($prev_values eq 'E' && $s =~ /^.\s*(?:$Storage\s+)?(?:const\s+)?($Ident)\b(:?\s+$Sparse)?\s*\**\s*$Ident\s*(?:;|=|,)/) {
				possible($1, $s);
1099
			}
1100
1101

			# any (foo ... *) is a pointer cast, and foo is a type
1102
1103
			while ($s =~ /\(($Ident)(?:\s+$Sparse)*\s*\*+\s*\)/g) {
				possible($1, $s);
1104
1105
1106
1107
1108
			}

			# Check for any sort of function declaration.
			# int foo(something bar, other baz);
			# void (*store_gdt)(x86_descr_ptr *);
1109
			if ($prev_values eq 'E' && $s =~ /^(.(?:typedef\s*)?(?:(?:$Storage|$Inline)\s*)*\s*$Type\s*(?:\b$Ident|\(\*\s*$Ident\))\s*)\(/) {
1110
1111
				my ($name_len) = length($1);

1112
				my $ctx = $s;
1113
1114
				substr($ctx, 0, $name_len + 1) = '';
				$ctx =~ s/\)[^\)]*$//;
1115

1116
1117
1118
				for my $arg (split(/\s*,\s*/, $ctx)) {
					if ($arg =~ /^(?:const\s+)?($Ident)(?:\s+$Sparse)*\s*\**\s*(:?\b$Ident)?$/ || $arg =~ /^($Ident)$/) {

1119
						possible($1, $s);
1120
1121
					}
				}
1122
			}
1123

1124
1125
		}

1126
1127
1128
#
# Checks which may be anchored in the context.
#
1129

1130
1131
# Check for switch () and associated case and default
# statements should be at the same indent.
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
		if ($line=~/\bswitch\s*\(.*\)/) {
			my $err = '';
			my $sep = '';
			my @ctx = ctx_block_outer($linenr, $realcnt);
			shift(@ctx);
			for my $ctx (@ctx) {
				my ($clen, $cindent) = line_stats($ctx);
				if ($ctx =~ /^\+\s*(case\s+|default:)/ &&
							$indent != $cindent) {
					$err .= "$sep$ctx\n";
					$sep = '';
				} else {
					$sep = "[...]\n";
				}
			}
			if ($err ne '') {
1148
				ERROR("switch and case should be at the same indent\n$hereline$err");
1149
1150
1151
1152
1153
1154
			}
		}

# if/while/etc brace do not go on next line, unless defining a do while loop,
# or if that brace on the next line is for something else
		if ($line =~ /\b(?:(if|while|for|switch)\s*\(|do\b|else\b)/ && $line !~ /^.#/) {
1155
			my ($level, @ctx) = ctx_statement_level($linenr, $realcnt, 0);
1156
1157
1158
1159
			my $ctx_ln = $linenr + $#ctx + 1;
			my $ctx_cnt = $realcnt - $#ctx - 1;
			my $ctx = join("\n", @ctx);

1160
			# Skip over any removed lines in the context following statement.
1161
1162
1163
1164
1165
1166
1167
			while ($ctx_cnt > 0 && $lines[$ctx_ln - 1] =~ /^-/) {
				$ctx_ln++;
				$ctx_cnt--;
			}
			##warn "line<$line>\nctx<$ctx>\nnext<$lines[$ctx_ln - 1]>";

			if ($ctx !~ /{\s*/ && $ctx_cnt > 0 && $lines[$ctx_ln - 1] =~ /^\+\s*{/) {
1168
				ERROR("That open brace { should be on the previous line\n" .
1169
					"$here\n$ctx\n$lines[$ctx_ln - 1]");
1170
			}
1171
1172
1173
1174
1175
1176
1177
			if ($level == 0 && $ctx =~ /\)\s*\;\s*$/ && defined $lines[$ctx_ln - 1]) {
				my ($nlength, $nindent) = line_stats($lines[$ctx_ln - 1]);
				if ($nindent > $indent) {
					WARN("Trailing semicolon indicates no statements, indent implies otherwise\n" .
						"$here\n$ctx\n$lines[$ctx_ln - 1]");
				}
			}
1178
1179
		}

1180
1181
1182
1183
		# Track the 'values' across context and added lines.
		my $opline = $line; $opline =~ s/^./ /;
		my $curr_values = annotate_values($opline . "\n", $prev_values);
		$curr_values = $prev_values . $curr_values;
1184
1185
		if ($dbg_values) {
			my $outline = $opline; $outline =~ s/\t/ /g;
1186
1187
			print "$linenr > .$outline\n";
			print "$linenr > $curr_values\n";
1188
		}
1189
1190
		$prev_values = substr($curr_values, -1);

1191
1192
1193
#ignore lines not being added
		if ($line=~/^[^\+]/) {next;}

1194
1195
# TEST: allow direct testing of the type matcher.
		if ($tst_type && $line =~ /^.$Declare$/) {
1196
			ERROR("TEST: is type $Declare\n" . $herecurr);
1197
1198
1199
			next;
		}

1200
1201
1202
1203
1204
1205
# check for initialisation to aggregates open brace on the next line
		if ($prevline =~ /$Declare\s*$Ident\s*=\s*$/ &&
		    $line =~ /^.\s*{/) {
			ERROR("That open brace { should be on the previous line\n" . $hereprev);
		}

1206
1207
1208
1209
1210
1211
1212
1213
#
# Checks which are anchored on the added line.
#

# check for malformed paths in #include statements (uses RAW line)
		if ($rawline =~ m{^.#\s*include\s+[<"](.*)[">]}) {
			my $path = $1;
			if ($path =~ m{//}) {
1214
1215
				ERROR("malformed #include filename\n" .
					$herecurr);