checkpatch.pl 48.6 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.14';
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
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
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|
			__kprobes|
			fastcall
		}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{
			<=|>=|==|!=|
			=>|->|<<|>>|<|>|!|~|
126
			&&|\|\||,|\^|\+\+|--|&|\||\+|-|\*|\/|%
127
128
		  }x;

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
160
161
162
163
164
165
166
167
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+)?
			$all
			(?:\s+$Sparse|\s+const)*
			\b
		  }x;
	$Type	= qr{
			\b$NonptrType\b
			(?:\s*\*+\s*const|\s*\*+|(?:\s*\[\s*\])+)?
168
			(?:\s+$Inline|\s+$Sparse|\s+$Attribute)*
169
170
171
172
		  }x;
	$Declare	= qr{(?:$Storage\s+)?$Type};
}
build_types();
173
174
175

$chk_signoff = 0 if ($file);

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

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

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

exit($exit);

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

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

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

	return $res;
}
277

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

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

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

	my $quote = '';
298
	my $qlen = 0;
299
300

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

		$l = $c;
	}

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

	# 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@;
	}

351
352
353
	return $res;
}

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

361
362
	my $loff = 0;

363
364
365
366
	my $type = '';
	my $level = 0;
	my $c;
	my $len = 0;
367
368

	my $remainder;
369
370
371
372
373
374
	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++) {
375
				next if ($lines[$line] =~ /^-/);
376
				$remain--;
377
				$loff = $len;
378
				$blk .= $lines[$line] . "\n";
379
380
381
382
383
384
				$len = length($blk);
				$line++;
				last;
			}
			# Bail if there is no further context.
			#warn "CSB: blk<$blk> off<$off> len<$len>\n";
385
			if ($off >= $len) {
386
387
388
389
				last;
			}
		}
		$c = substr($blk, $off, 1);
390
		$remainder = substr($blk, $off);
391
392
393
394
395
396
397
398

		#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;
		}

399
400
401
402
403
404
		# An else is really a conditional as long as its not else if
		if ($level == 0 && $remainder =~ /(\s+else)(?:\s|{)/ &&
					$remainder !~ /\s+else\s+if\b/) {
			$coff = $off + length($1);
		}

405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
		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++;
	}
431
432
433
434
	if ($off == $len) {
		$line++;
		$remain--;
	}
435
436
437
438
439
440
441

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

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

442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
	#print "off<$off> loff<$loff>\n";

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

sub ctx_statement_full {
	my ($linenr, $remain, $off) = @_;
	my ($statement, $condition, $level);

	my (@chunks);

	($statement, $condition, $linenr, $remain, $off, $level) =
				ctx_statement_block($linenr, $remain, $off);
	#print "F: c<$condition> s<$statement>\n";
	for (;;) {
		push(@chunks, [ $condition, $statement ]);
		last if (!($remain > 0 && $condition =~ /^.\s*(?:if|else|do)/));
		($statement, $condition, $linenr, $remain, $off, $level) =
				ctx_statement_block($linenr, $remain, $off);
		#print "C: c<$condition> s<$statement>\n";
	}

	return ($level, $linenr, @chunks);
466
467
}

468
sub ctx_block_get {
469
	my ($linenr, $remain, $outer, $open, $close, $off) = @_;
470
471
472
473
474
475
476
	my $line;
	my $start = $linenr - 1;
	my $blk = '';
	my @o;
	my @c;
	my @res = ();

477
	my $level = 0;
478
479
480
481
482
	for ($line = $start; $remain > 0; $line++) {
		next if ($rawlines[$line] =~ /^-/);
		$remain--;

		$blk .= $rawlines[$line];
483
484
485
486
487
488
		foreach my $c (split(//, $rawlines[$line])) {
			##print "C<$c>L<$level><$open$close>O<$off>\n";
			if ($off > 0) {
				$off--;
				next;
			}
489

490
491
492
493
494
495
496
			if ($c eq $close && $level > 0) {
				$level--;
				last if ($level == 0);
			} elsif ($c eq $open) {
				$level++;
			}
		}
497

498
		if (!$outer || $level <= 1) {
499
			push(@res, $rawlines[$line]);
500
501
		}

502
		last if ($level == 0);
503
504
	}

505
	return ($level, @res);
506
507
508
509
}
sub ctx_block_outer {
	my ($linenr, $remain) = @_;

510
511
	my ($level, @r) = ctx_block_get($linenr, $remain, 1, '{', '}', 0);
	return @r;
512
513
514
515
}
sub ctx_block {
	my ($linenr, $remain) = @_;

516
517
	my ($level, @r) = ctx_block_get($linenr, $remain, 0, '{', '}', 0);
	return @r;
518
519
}
sub ctx_statement {
520
521
522
523
524
525
	my ($linenr, $remain, $off) = @_;

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

528
	return ctx_block_get($linenr, $remain, 0, '{', '}', 0);
529
}
530
531
532
533
534
sub ctx_statement_level {
	my ($linenr, $remain, $off) = @_;

	return ctx_block_get($linenr, $remain, 0, '(', ')', $off);
}
535
536
537
538
539

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

	# Catch a comment on the end of the line itself.
540
	my ($current_comment) = ($rawlines[$end_line - 1] =~ m@.*(/\*.*\*/)\s*$@);
541
542
543
544
545
546
547
	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++) {
548
549
		my $line = $rawlines[$linenr - 1];
		#warn "           $line\n";
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
		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);

572
	##print "LINE: $rawlines[$end_line - 1 ]\n";
573
574
575
576
577
	##print "CMMT: $cmt\n";

	return ($cmt ne '');
}

578
579
580
sub cat_vet {
	my ($vet) = @_;
	my ($res, $coded);
581

582
583
584
585
586
587
	$res = '';
	while ($vet =~ /([^[:cntrl:]]*)([[:cntrl:]]|$)/g) {
		$res .= $1;
		if ($2 ne '') {
			$coded = sprintf("^%c", unpack('C', $2) + 64);
			$res .= $coded;
588
589
		}
	}
590
	$res =~ s/$/\$/;
591

592
	return $res;
593
594
}

595
596
597
598
599
600
601
602
603
604
my $av_preprocessor = 0;
my $av_paren = 0;
my @av_paren_type;

sub annotate_reset {
	$av_preprocessor = 0;
	$av_paren = 0;
	@av_paren_type = ();
}

605
606
sub annotate_values {
	my ($stream, $type) = @_;
607

608
609
610
	my $res;
	my $cur = $stream;

611
	print "$stream\n" if ($dbg_values > 1);
612
613

	while (length($cur)) {
614
		print " <$type> " if ($dbg_values > 1);
615
		if ($cur =~ /^(\s+)/o) {
616
617
618
			print "WS($1)\n" if ($dbg_values > 1);
			if ($1 =~ /\n/ && $av_preprocessor) {
				$av_preprocessor = 0;
619
620
621
				$type = 'N';
			}

622
		} elsif ($cur =~ /^($Type)/) {
623
			print "DECLARE($1)\n" if ($dbg_values > 1);
624
625
626
			$type = 'T';

		} elsif ($cur =~ /^(#\s*define\s*$Ident)(\(?)/o) {
627
628
629
			print "DEFINE($1)\n" if ($dbg_values > 1);
			$av_preprocessor = 1;
			$av_paren_type[$av_paren] = 'N';
630

631
632
633
		} elsif ($cur =~ /^(#\s*(?:ifdef|ifndef|if|else|elif|endif))/o) {
			print "PRE($1)\n" if ($dbg_values > 1);
			$av_preprocessor = 1;
634
635
636
			$type = 'N';

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

		} elsif ($cur =~ /^(sizeof)\s*(\()?/o) {
640
			print "SIZEOF($1)\n" if ($dbg_values > 1);
641
			if (defined $2) {
642
				$av_paren_type[$av_paren] = 'V';
643
644
645
			}
			$type = 'N';

646
		} elsif ($cur =~ /^(if|while|typeof|__typeof__|for)\b/o) {
647
648
			print "COND($1)\n" if ($dbg_values > 1);
			$av_paren_type[$av_paren] = 'N';
649
650
651
			$type = 'N';

		} elsif ($cur =~/^(return|case|else)/o) {
652
			print "KEYWORD($1)\n" if ($dbg_values > 1);
653
654
655
			$type = 'N';

		} elsif ($cur =~ /^(\()/o) {
656
657
			print "PAREN('$1')\n" if ($dbg_values > 1);
			$av_paren++;
658
659
660
			$type = 'N';

		} elsif ($cur =~ /^(\))/o) {
661
662
663
664
665
666
			$av_paren-- if ($av_paren > 0);
			if (defined $av_paren_type[$av_paren]) {
				$type = $av_paren_type[$av_paren];
				undef $av_paren_type[$av_paren];
				print "PAREN('$1') -> $type\n"
							if ($dbg_values > 1);
667
			} else {
668
				print "PAREN('$1')\n" if ($dbg_values > 1);
669
670
671
			}

		} elsif ($cur =~ /^($Ident)\(/o) {
672
673
			print "FUNC($1)\n" if ($dbg_values > 1);
			$av_paren_type[$av_paren] = 'V';
674
675

		} elsif ($cur =~ /^($Ident|$Constant)/o) {
676
			print "IDENT($1)\n" if ($dbg_values > 1);
677
678
679
			$type = 'V';

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

683
		} elsif ($cur =~/^(;)/) {
684
			print "END($1)\n" if ($dbg_values > 1);
685
686
687
688
			$type = 'E';

		} elsif ($cur =~ /^(;|{|}|\?|:|\[)/o) {
			print "CLOSE($1)\n" if ($dbg_values > 1);
689
690
691
			$type = 'N';

		} elsif ($cur =~ /^($Operators)/o) {
692
			print "OP($1)\n" if ($dbg_values > 1);
693
694
695
696
697
			if ($1 ne '++' && $1 ne '--') {
				$type = 'N';
			}

		} elsif ($cur =~ /(^.)/o) {
698
			print "C($1)\n" if ($dbg_values > 1);
699
700
701
702
703
		}
		if (defined $1) {
			$cur = substr($cur, length($1));
			$res .= $type x length($1);
		}
704
	}
705

706
	return $res;
707
708
}

709
sub possible {
710
	my ($possible, $line) = @_;
711
712
713
714
715
716
717

	#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') {
718
		warn "POSSIBLE: $possible ($line)\n" if ($dbg_possible);
719
720
721
722
723
		push(@typeList, $possible);
		build_types();
	}
}

724
725
my $prefix = '';

726
sub report {
727
728
729
730
	my $line = $prefix . $_[0];

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

731
	push(our @report, $line);
732
733
}
sub report_dump {
734
	our @report;
735
}
736
sub ERROR {
737
	report("ERROR: $_[0]\n");
738
	our $clean = 0;
739
	our $cnt_error++;
740
741
}
sub WARN {
742
	report("WARNING: $_[0]\n");
743
	our $clean = 0;
744
	our $cnt_warn++;
745
746
}
sub CHK {
747
748
749
750
751
	if ($check) {
		report("CHECK: $_[0]\n");
		our $clean = 0;
		our $cnt_chk++;
	}
752
753
}

754
755
756
757
758
sub process {
	my $filename = shift;

	my $linenr=0;
	my $prevline="";
759
	my $prevrawline="";
760
	my $stashline="";
761
	my $stashrawline="";
762

763
	my $length;
764
765
766
767
	my $indent;
	my $previndent=0;
	my $stashindent=0;

768
	our $clean = 1;
769
770
771
	my $signoff = 0;
	my $is_patch = 0;

772
	our @report = ();
773
774
775
776
777
	our $cnt_lines = 0;
	our $cnt_error = 0;
	our $cnt_warn = 0;
	our $cnt_chk = 0;

778
779
780
781
782
783
	# Trace the real file/line as we go.
	my $realfile = '';
	my $realline = 0;
	my $realcnt = 0;
	my $here = '';
	my $in_comment = 0;
784
	my $comment_edge = 0;
785
786
	my $first_line = 0;

787
788
789
790
	my $prev_values = 'E';

	# suppression flags
	my $suppress_ifbraces = 0;
791

792
	# Pre-scan the patch sanitizing the lines.
793
	# Pre-scan the patch looking for any __setup documentation.
794
	#
795
796
	my @setup_docs = ();
	my $setup_docs = 0;
797
798
799
800
801
802
803
804
805
806
	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";

807
808
809
810
811
812
813
814
815
816
817
818
819
		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);
		}
	}

820
821
	$prefix = '';

822
823
824
	foreach my $line (@lines) {
		$linenr++;

825
		my $rawline = $rawlines[$linenr - 1];
826

827
828
829
#extract the filename as it passes
		if ($line=~/^\+\+\+\s+(\S+)/) {
			$realfile=$1;
830
			$realfile =~ s@^[^/]*/@@;
831
832
833
834
			$in_comment = 0;
			next;
		}
#extract the line range in the file after the patch is applied
835
		if ($line=~/^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@/) {
836
			$is_patch = 1;
837
			$first_line = $linenr + 1;
838
839
840
841
842
843
844
			$in_comment = 0;
			$realline=$1-1;
			if (defined $2) {
				$realcnt=$3+1;
			} else {
				$realcnt=1+1;
			}
845
			annotate_reset();
846
847
848
			$prev_values = 'E';

			$suppress_ifbraces = $linenr - 1;
849
850
851
			next;
		}

852
853
854
855
# 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 =~ /^( |\+|$)/) {
856
			$realline++;
857
			$realcnt-- if ($realcnt != 0);
858

859
860
861
862
863
864
865
			# 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++) {
866
					($edge) = ($rawlines[$ln - 1] =~ m@(/\*|\*/)@);
867
868
869
870
871
872
873
					last if (defined $edge);
				}
				if (defined $edge && $edge eq '*/') {
					$in_comment = 1;
				}
			}

874
875
876
			# 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.
877
			if ($linenr == $first_line and $rawline =~ m@^.\s* \*(?:\s|$)@) {
878
879
				$in_comment = 1;
			}
880
881

			# Find the last comment edge on _this_ line.
882
883
			$comment_edge = 0;
			while (($rawline =~ m@(/\*|\*/)@g)) {
884
885
886
887
888
				if ($1 eq '/*') {
					$in_comment = 1;
				} else {
					$in_comment = 0;
				}
889
				$comment_edge = 1;
890
891
			}

892
			# Measure the line length and indent.
893
			($length, $indent) = line_stats($rawline);
894
895
896
897

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

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

902
903
		} elsif ($realcnt == 1) {
			$realcnt--;
904
905
906
		}

#make up the handle for any error we report on this line
907
908
		$here = "#$linenr: " if (!$file);
		$here = "#$realline: " if ($file);
909
		$here .= "FILE: $realfile:$realline:" if ($realcnt != 0);
910

911
912
913
		my $hereline = "$here\n$rawline\n";
		my $herecurr = "$here\n$rawline\n";
		my $hereprev = "$here\n$prevrawline\n$rawline\n";
914

915
916
917
918
		$prefix = "$filename:$realline: " if ($emacs && $file);
		$prefix = "$filename:$linenr: " if ($emacs && !$file);
		$cnt_lines++ if ($realcnt != 0);

919
#check the patch for a signoff:
920
		if ($line =~ /^\s*signed-off-by:/i) {
921
922
			# This is a signoff, if ugly, so do not double report.
			$signoff++;
923
			if (!($line =~ /^\s*Signed-off-by:/)) {
924
925
				WARN("Signed-off-by: is the preferred form\n" .
					$herecurr);
926
927
			}
			if ($line =~ /^\s*signed-off-by:\S/i) {
928
929
				WARN("need space after Signed-off-by:\n" .
					$herecurr);
930
931
932
			}
		}

933
# Check for wrappage within a valid hunk of the file
934
		if ($realcnt != 0 && $line !~ m{^(?:\+|-| |\\ No newline|$)}) {
935
			ERROR("patch seems to be corrupt (line wrapped?)\n" .
936
				$herecurr) if (!$emitted_corrupt++);
937
938
939
940
		}

# UTF-8 regex found at http://www.w3.org/International/questions/qa-forms-utf-8.en.php
		if (($realfile =~ /^$/ || $line =~ /^\+/) &&
941
		     !($rawline =~ m/^(
942
943
944
945
946
947
948
949
950
				[\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 )) {
951
			ERROR("Invalid UTF-8, patch and commit message should be encoded in UTF-8\n" . $herecurr);
952
953
954
955
		}

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

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

#trailing whitespace
961
		if ($line =~ /^\+.*\015/) {
962
			my $herevet = "$here\n" . cat_vet($rawline) . "\n";
963
964
			ERROR("DOS line endings\n" . $herevet);

965
966
		} elsif ($rawline =~ /^\+.*\S\s+$/ || $rawline =~ /^\+\s+$/) {
			my $herevet = "$here\n" . cat_vet($rawline) . "\n";
967
			ERROR("trailing whitespace\n" . $herevet);
968
969
		}
#80 column limit
970
		if ($line =~ /^\+/ && !($prevrawline=~/\/\*\*/) && $length > 80) {
971
			WARN("line over 80 characters\n" . $herecurr);
972
973
		}

974
975
976
977
978
# 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);
		}

979
980
981
982
983
# 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.
984
985
986
		if ($rawline =~ /^\+\s* \t\s*\S/ ||
		    $rawline =~ /^\+\s*        \s*/) {
			my $herevet = "$here\n" . cat_vet($rawline) . "\n";
987
			ERROR("use tabs not spaces\n" . $herevet);
988
989
		}

990
991
992
993
# check for RCS/CVS revision markers
		if ($rawline =~ /\$(Revision|Log|Id)(?:\$|)/) {
			WARN("CVS style keyword markers, these will _not_ be updated\n". $herecurr);
		}
994
995
996
997
998

# 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);
999

1000
# Check for potential 'bare' types
1001
1002
1003
1004
1005
1006
1007
		if ($realcnt) {
			# Ignore goto labels.
			if ($line =~ /$Ident:\*$/) {

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

1008
			# definitions in global scope can only start with types
1009
			} elsif ($line =~ /^.(?:$Storage\s+)?(?:$Inline\s+)?(?:const\s+)?($Ident)\b/) {
1010
				possible($1, $line);
1011
1012

			# declarations always start with types
1013
			} elsif ($prev_values eq 'E' && $line =~ /^.\s*(?:$Storage\s+)?(?:const\s+)?($Ident)\b(:?\s+$Sparse)?\s*\**\s*$Ident\s*(?:;|=|,)/) {
1014
				possible($1);
1015
			}
1016
1017

			# any (foo ... *) is a pointer cast, and foo is a type
1018
			while ($line =~ /\(($Ident)(?:\s+$Sparse)*\s*\*+\s*\)/g) {
1019
				possible($1, $line);
1020
1021
1022
1023
1024
			}

			# Check for any sort of function declaration.
			# int foo(something bar, other baz);
			# void (*store_gdt)(x86_descr_ptr *);
1025
			if ($prev_values eq 'E' && $line =~ /^(.(?:typedef\s*)?(?:(?:$Storage|$Inline)\s*)*\s*$Type\s*(?:\b$Ident|\(\*\s*$Ident\))\s*)\(/) {
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
				my ($name_len) = length($1);
				my ($level, @ctx) = ctx_statement_level($linenr, $realcnt, $name_len);
				my $ctx = join("\n", @ctx);

				$ctx =~ s/\n.//;
				substr($ctx, 0, $name_len + 1) = '';
				$ctx =~ s/\)[^\)]*$//;
				for my $arg (split(/\s*,\s*/, $ctx)) {
					if ($arg =~ /^(?:const\s+)?($Ident)(?:\s+$Sparse)*\s*\**\s*(:?\b$Ident)?$/ || $arg =~ /^($Ident)$/) {

1036
						possible($1, $line);
1037
1038
					}
				}
1039
			}
1040

1041
1042
		}

1043
1044
1045
#
# Checks which may be anchored in the context.
#
1046

1047
1048
# Check for switch () and associated case and default
# statements should be at the same indent.
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
		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 '') {
1065
				ERROR("switch and case should be at the same indent\n$hereline$err");
1066
1067
1068
1069
1070
1071
			}
		}

# 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 !~ /^.#/) {
1072
			my ($level, @ctx) = ctx_statement_level($linenr, $realcnt, 0);
1073
1074
1075
1076
			my $ctx_ln = $linenr + $#ctx + 1;
			my $ctx_cnt = $realcnt - $#ctx - 1;
			my $ctx = join("\n", @ctx);

1077
			# Skip over any removed lines in the context following statement.
1078
1079
1080
1081
1082
1083
1084
			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*{/) {
1085
				ERROR("That open brace { should be on the previous line\n" .
1086
					"$here\n$ctx\n$lines[$ctx_ln - 1]");
1087
			}
1088
1089
1090
1091
1092
1093
1094
			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]");
				}
			}
1095
1096
		}

1097
1098
1099
1100
		# 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;
1101
1102
1103
1104
1105
		if ($dbg_values) {
			my $outline = $opline; $outline =~ s/\t/ /g;
			warn "--> .$outline\n";
			warn "--> $curr_values\n";
		}
1106
1107
		$prev_values = substr($curr_values, -1);

1108
1109
1110
#ignore lines not being added
		if ($line=~/^[^\+]/) {next;}

1111
1112
# TEST: allow direct testing of the type matcher.
		if ($tst_type && $line =~ /^.$Declare$/) {
1113
			ERROR("TEST: is type $Declare\n" . $herecurr);
1114
1115
1116
			next;
		}

1117
1118
1119
1120
1121
1122
# 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);
		}

1123
1124
1125
1126
1127
1128
1129
1130
#
# 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{//}) {
1131
1132
				ERROR("malformed #include filename\n" .
					$herecurr);
1133
1134
			}
		}
1135

1136
# no C99 // comments
1137
		if ($line =~ m{//}) {
1138
			ERROR("do not use C99 // comments\n" . $herecurr);
1139
		}
1140
		# Remove C99 comments.
1141
		$line =~ s@//.*@@;
1142
		$opline =~ s@//.*@@;
1143
1144

#EXPORT_SYMBOL should immediately follow its function closing }.
1145
1146
1147
		if (($line =~ /EXPORT_SYMBOL.*\((.*)\)/) ||
		    ($line =~ /EXPORT_UNUSED_SYMBOL.*\((.*)\)/)) {
			my $name = $1;
1148
1149
			if (($prevline !~ /^}/) &&
			   ($prevline !~ /^\+}/) &&
1150
			   ($prevline !~ /^ }/) &&
1151
			   ($prevline !~ /\b\Q$name\E(?:\s+$Attribute)?\s*(?:;|=)/)) {
1152
				WARN("EXPORT_SYMBOL(foo); should immediately follow its function/variable\n" . $herecurr);
1153
1154
1155
			}
		}

1156
1157
1158
1159
1160
# check for external initialisers.
		if ($line =~ /^.$Type\s*$Ident\s*=\s*(0|NULL);/) {
			ERROR("do not initialise externals to 0 or NULL\n" .
				$herecurr);
		}
1161
# check for static initialisers.
1162
		if ($line =~ /\s*static\s.*=\s*(0|NULL);/) {
1163
1164
			ERROR("do not initialise statics to 0 or NULL\n" .
				$herecurr);
1165
1166
		}

1167
1168
1169
# check for new typedefs, only function parameters and sparse annotations
# make sense.
		if ($line =~ /\btypedef\s/ &&
1170
		    $line !~ /\btypedef\s+$Type\s+\(\s*\*?$Ident\s*\)\s*\(/ &&
1171
		    $line !~ /\b__bitwise(?:__|)\b/) {
1172
			WARN("do not add new typedefs\n" . $herecurr);
1173
1174
1175
		}

# * goes on variable not on type
1176
		if ($line =~ m{\($NonptrType(\*+)(?:\s+const)?\)}) {
1177
1178
			ERROR("\"(foo$1)\" should be \"(foo $1)\"\n" .
				$herecurr);
1179
1180

		} elsif ($line =~ m{\($NonptrType\s+(\*+)(?!\s+const)\s+\)}) {
1181
1182
			ERROR("\"(foo $1 )\" should be \"(foo $1)\"\n" .
				$herecurr);
1183

1184
		} elsif ($line =~ m{$NonptrType(\*+)(?:\s+(?:$Attribute|$Sparse))?\s+[A-Za-z\d_]+}) {
1185
1186
			ERROR("\"foo$1 bar\" should be \"foo $1bar\"\n" .
				$herecurr);
1187

1188
		} elsif ($line =~ m{$NonptrType\s+(\*+)(?!\s+(?:$Attribute|$Sparse))\s+[A-Za-z\d_]+}) {
1189
1190
			ERROR("\"foo $1 bar\" should be \"foo $1bar\"\n" .
				$herecurr);
1191
1192
1193
1194
1195
1196
1197
1198
1199
		}

# # no BUG() or BUG_ON()
# 		if ($line =~ /\b(BUG|BUG_ON)\b/) {
# 			print "Try to use WARN_ON & Recovery code rather than BUG() or BUG_ON()\n";
# 			print "$herecurr";
# 			$clean = 0;
# 		}

1200
		if ($line =~ /\bLINUX_VERSION_CODE\b/) {
1201
			WARN("LINUX_VERSION_CODE should be avoided, code should be for the version to which it is merged\n" . $herecurr);
1202
1203
		}

1204
1205
1206
1207
1208
# printk should use KERN_* levels.  Note that follow on printk's on the
# same line do not need a level, so we use the current block context
# to try and find and validate the current printk.  In summary the current
# printk includes all preceeding printk's which have no newline on the end.
# we assume the first bad printk is the one to report.
1209
		if ($line =~ /\bprintk\((?!KERN_)\s*"/) {
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
			my $ok = 0;
			for (my $ln = $linenr - 1; $ln >= $first_line; $ln--) {
				#print "CHECK<$lines[$ln - 1]\n";
				# we have a preceeding printk if it ends
				# with "\n" ignore it, else it is to blame
				if ($lines[$ln - 1] =~ m{\bprintk\(}) {
					if