checkpatch.pl 55 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.18';
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
118
119
120
121
122
123
124
125
126
		}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{
			<=|>=|==|!=|
			=>|->|<<|>>|<|>|!|~|
127
			&&|\|\||,|\^|\+\+|--|&|\||\+|-|\*|\/|%
128
129
		  }x;

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

134
135
136
137
138
139
140
141
142
143
144
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;

145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
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+)?
173
174
175
176
			(?:
				$all|
				(?:typeof|__typeof__)\s*\(\s*\**\s*$Ident\s*\)
			)
177
178
179
180
181
182
			(?:\s+$Sparse|\s+const)*
			\b
		  }x;
	$Type	= qr{
			\b$NonptrType\b
			(?:\s*\*+\s*const|\s*\*+|(?:\s*\[\s*\])+)?
183
			(?:\s+$Inline|\s+$Sparse|\s+$Attribute)*
184
185
186
187
		  }x;
	$Declare	= qr{(?:$Storage\s+)?$Type};
}
build_types();
188
189
190

$chk_signoff = 0 if ($file);

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

203
204
205
				} elsif ($entry !~ m@/@) {
					push(@dep_functions, $entry);
				}
206
			}
207
208
209
210
		}
	}
}

211
my @rawlines = ();
212
213
my @lines = ();
my $vname;
214
215
216
217
218
219
220
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";
221
	}
222
223
224
225
226
	if ($filename eq '-') {
		$vname = 'Your patch';
	} else {
		$vname = $filename;
	}
227
228
229
230
231
	while (<FILE>) {
		chomp;
		push(@rawlines, $_);
	}
	close(FILE);
232
	if (!process($filename)) {
233
234
235
		$exit = 1;
	}
	@rawlines = ();
236
	@lines = ();
237
238
239
240
241
}

exit($exit);

sub top_of_kernel_tree {
242
243
244
245
246
247
248
249
250
251
252
253
	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;
		}
254
	}
255
	return 1;
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
}

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;
}
278
sub copy_spacing {
279
	(my $res = shift) =~ tr/\t/ /c;
280
281
	return $res;
}
282

283
284
285
286
287
288
289
290
291
292
293
294
295
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));
}

296
297
298
299
300
301
302
303
304
305
306
my $sanitise_quote = '';

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

	if ($in_comment) {
		$sanitise_quote = '*/';
	} else {
		$sanitise_quote = '';
	}
}
307
308
309
310
311
312
sub sanitise_line {
	my ($line) = @_;

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

313
	my $qlen = 0;
314
315
	my $off = 0;
	my $c;
316

317
318
319
320
321
322
323
324
325
326
327
328
329
330
	# 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;
331
		}
332
333
334
335
336
		if (substr($line, $off, 2) eq $sanitise_quote) {
			$sanitise_quote = '';
			substr($res, $off, 2, "$;$;");
			$off++;
			next;
337
		}
338
339
340
341
342
343
344

		# 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;
345
		}
346
347
348
349
		# Regular quotes.
		if ($c eq "'" || $c eq '"') {
			if ($sanitise_quote eq '') {
				$sanitise_quote = $c;
350

351
352
353
354
355
356
				substr($res, $off, 1, $c);
				next;
			} elsif ($sanitise_quote eq $c) {
				$sanitise_quote = '';
			}
		}
357

358
359
360
361
362
363
364
365
		#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);
		}
366
367
368
369
370
371
372
373
374
375
376
377
378
	}

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

379
380
381
	return $res;
}

382
383
384
385
386
387
sub ctx_statement_block {
	my ($linenr, $remain, $off) = @_;
	my $line = $linenr - 1;
	my $blk = '';
	my $soff = $off;
	my $coff = $off - 1;
388
	my $coff_set = 0;
389

390
391
	my $loff = 0;

392
393
	my $type = '';
	my $level = 0;
394
	my $p;
395
396
	my $c;
	my $len = 0;
397
398

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

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

430
		# An else is really a conditional as long as its not else if
431
432
433
434
435
436
437
438
		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";
439
440
		}

441
442
443
444
445
446
447
448
449
450
		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;
451
452
				$coff_set = 1;
				#warn "CSB: mark coff<$coff>\n";
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
			}
		}
		if (($type eq '' || $type eq '{') && $c eq '{') {
			$level++;
			$type = '{';
		}
		if ($type eq '{' && $c eq '}') {
			$level--;
			$type = ($level != 0)? '{' : '';

			if ($level == 0) {
				last;
			}
		}
		$off++;
	}
469
470
471
472
	if ($off == $len) {
		$line++;
		$remain--;
	}
473
474
475
476
477
478
479

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

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

480
	#print "coff<$coff> soff<$off> loff<$loff>\n";
481
482
483
484
485

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

486
487
488
489
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
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;
	}
}

529
530
531
532
533
534
sub ctx_statement_full {
	my ($linenr, $remain, $off) = @_;
	my ($statement, $condition, $level);

	my (@chunks);

535
	# Grab the first conditional/block pair.
536
537
	($statement, $condition, $linenr, $remain, $off, $level) =
				ctx_statement_block($linenr, $remain, $off);
538
	#print "F: c<$condition> s<$statement> remain<$remain>\n";
539
540
541
542
543
544
545
	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.
546
547
548
	for (;;) {
		($statement, $condition, $linenr, $remain, $off, $level) =
				ctx_statement_block($linenr, $remain, $off);
549
		#print "C: c<$condition> s<$statement> remain<$remain>\n";
550
		last if (!($remain > 0 && $condition =~ /^(?:\s*\n[+-])*\s*(?:else|do)\b/s));
551
552
		#print "C: push\n";
		push(@chunks, [ $condition, $statement ]);
553
554
555
	}

	return ($level, $linenr, @chunks);
556
557
}

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

567
	my $level = 0;
568
569
570
571
572
	for ($line = $start; $remain > 0; $line++) {
		next if ($rawlines[$line] =~ /^-/);
		$remain--;

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

580
581
582
583
584
585
586
			if ($c eq $close && $level > 0) {
				$level--;
				last if ($level == 0);
			} elsif ($c eq $open) {
				$level++;
			}
		}
587

588
		if (!$outer || $level <= 1) {
589
			push(@res, $rawlines[$line]);
590
591
		}

592
		last if ($level == 0);
593
594
	}

595
	return ($level, @res);
596
597
598
599
}
sub ctx_block_outer {
	my ($linenr, $remain) = @_;

600
601
	my ($level, @r) = ctx_block_get($linenr, $remain, 1, '{', '}', 0);
	return @r;
602
603
604
605
}
sub ctx_block {
	my ($linenr, $remain) = @_;

606
607
	my ($level, @r) = ctx_block_get($linenr, $remain, 0, '{', '}', 0);
	return @r;
608
609
}
sub ctx_statement {
610
611
612
613
614
615
	my ($linenr, $remain, $off) = @_;

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

618
	return ctx_block_get($linenr, $remain, 0, '{', '}', 0);
619
}
620
621
622
623
624
sub ctx_statement_level {
	my ($linenr, $remain, $off) = @_;

	return ctx_block_get($linenr, $remain, 0, '(', ')', $off);
}
625
626
627
628
629

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

	# Catch a comment on the end of the line itself.
630
	my ($current_comment) = ($rawlines[$end_line - 1] =~ m@.*(/\*.*\*/)\s*$@);
631
632
633
634
635
636
637
	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++) {
638
639
		my $line = $rawlines[$linenr - 1];
		#warn "           $line\n";
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
		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);

662
	##print "LINE: $rawlines[$end_line - 1 ]\n";
663
664
665
666
667
	##print "CMMT: $cmt\n";

	return ($cmt ne '');
}

668
669
670
sub cat_vet {
	my ($vet) = @_;
	my ($res, $coded);
671

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

682
	return $res;
683
684
}

685
my $av_preprocessor = 0;
686
my $av_pending;
687
688
689
690
my @av_paren_type;

sub annotate_reset {
	$av_preprocessor = 0;
691
692
	$av_pending = '_';
	@av_paren_type = ('E');
693
694
}

695
696
sub annotate_values {
	my ($stream, $type) = @_;
697

698
699
700
	my $res;
	my $cur = $stream;

701
	print "$stream\n" if ($dbg_values > 1);
702
703

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

714
		} elsif ($cur =~ /^($Type)/) {
715
			print "DECLARE($1)\n" if ($dbg_values > 1);
716
717
718
			$type = 'T';

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

		} elsif ($cur =~ /^(#\s*undef\s*$Ident)/o) {
			print "UNDEF($1)\n" if ($dbg_values > 1);
			$av_preprocessor = 1;
			push(@av_paren_type, $type);
731

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

			push(@av_paren_type, $type);
			push(@av_paren_type, $type);
738
			$type = 'E';
739
740
741
742
743
744
745

		} 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]);

746
			$type = 'E';
747
748
749
750
751
752
753
754
755
756

		} 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);
757
			$type = 'E';
758
759

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

762
763
764
765
766
		} elsif ($cur =~ /^(__attribute__)\s*\(?/o) {
			print "ATTR($1)\n" if ($dbg_values > 1);
			$av_pending = $type;
			$type = 'N';

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

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

		} elsif ($cur =~/^(return|case|else)/o) {
780
			print "KEYWORD($1)\n" if ($dbg_values > 1);
781
782
783
			$type = 'N';

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

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

		} elsif ($cur =~ /^($Ident)\(/o) {
800
			print "FUNC($1)\n" if ($dbg_values > 1);
801
			$av_pending = 'V';
802
803

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

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

811
		} elsif ($cur =~/^(;|{|})/) {
812
			print "END($1)\n" if ($dbg_values > 1);
813
814
			$type = 'E';

815
		} elsif ($cur =~ /^(;|\?|:|\[)/o) {
816
			print "CLOSE($1)\n" if ($dbg_values > 1);
817
818
819
			$type = 'N';

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

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

834
	return $res;
835
836
}

837
sub possible {
838
	my ($possible, $line) = @_;
839
840
841
842
843
844
845

	#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') {
846
		warn "POSSIBLE: $possible ($line)\n" if ($dbg_possible);
847
848
849
850
851
		push(@typeList, $possible);
		build_types();
	}
}

852
853
my $prefix = '';

854
sub report {
855
856
857
	if (defined $tst_only && $_[0] !~ /\Q$tst_only\E/) {
		return 0;
	}
858
859
860
861
	my $line = $prefix . $_[0];

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

862
	push(our @report, $line);
863
864

	return 1;
865
866
}
sub report_dump {
867
	our @report;
868
}
869
sub ERROR {
870
871
872
873
	if (report("ERROR: $_[0]\n")) {
		our $clean = 0;
		our $cnt_error++;
	}
874
875
}
sub WARN {
876
877
878
879
	if (report("WARNING: $_[0]\n")) {
		our $clean = 0;
		our $cnt_warn++;
	}
880
881
}
sub CHK {
882
	if ($check && report("CHECK: $_[0]\n")) {
883
884
885
		our $clean = 0;
		our $cnt_chk++;
	}
886
887
}

888
889
890
891
892
sub process {
	my $filename = shift;

	my $linenr=0;
	my $prevline="";
893
	my $prevrawline="";
894
	my $stashline="";
895
	my $stashrawline="";
896

897
	my $length;
898
899
900
901
	my $indent;
	my $previndent=0;
	my $stashindent=0;

902
	our $clean = 1;
903
904
905
	my $signoff = 0;
	my $is_patch = 0;

906
	our @report = ();
907
908
909
910
911
	our $cnt_lines = 0;
	our $cnt_error = 0;
	our $cnt_warn = 0;
	our $cnt_chk = 0;

912
913
914
915
916
917
	# Trace the real file/line as we go.
	my $realfile = '';
	my $realline = 0;
	my $realcnt = 0;
	my $here = '';
	my $in_comment = 0;
918
	my $comment_edge = 0;
919
920
	my $first_line = 0;

921
922
923
	my $prev_values = 'E';

	# suppression flags
924
	my %suppress_ifbraces;
925

926
	# Pre-scan the patch sanitizing the lines.
927
	# Pre-scan the patch looking for any __setup documentation.
928
	#
929
930
	my @setup_docs = ();
	my $setup_docs = 0;
931
932

	sanitise_line_reset();
933
934
	my $line;
	foreach my $rawline (@rawlines) {
935
936
		$linenr++;
		$line = $rawline;
937

938
		if ($rawline=~/^\+\+\+\s+(\S+)/) {
939
940
941
942
			$setup_docs = 0;
			if ($1 =~ m@Documentation/kernel-parameters.txt$@) {
				$setup_docs = 1;
			}
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
			#next;
		}
		if ($rawline=~/^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@/) {
			$realline=$1-1;
			if (defined $2) {
				$realcnt=$3+1;
			} else {
				$realcnt=1+1;
			}

			# 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;
958
			for (my $ln = $linenr + 1; $ln < ($linenr + $realcnt); $ln++) {
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
				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);

979
		} elsif ($realcnt && $rawline =~ /^(?:\+| |$)/) {
980
			# Standardise the strings and chars within the input to
981
			# simplify matching -- only bother with positive lines.
982
			$line = sanitise_line($rawline);
983
		}
984
985
986
987
988
989
990
991
992
993
		push(@lines, $line);

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

		#print "==>$rawline\n";
		#print "-->$line\n";
994
995
996
997
998
999

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

1000
1001
	$prefix = '';

1002
1003
	$realcnt = 0;
	$linenr = 0;
1004
1005
1006
	foreach my $line (@lines) {
		$linenr++;

1007
		my $rawline = $rawlines[$linenr - 1];
1008

1009
#extract the line range in the file after the patch is applied
1010
		if ($line=~/^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@/) {
1011
			$is_patch = 1;
1012
			$first_line = $linenr + 1;
1013
1014
1015
1016
1017
1018
			$realline=$1-1;
			if (defined $2) {
				$realcnt=$3+1;
			} else {
				$realcnt=1+1;
			}
1019
			annotate_reset();
1020
1021
			$prev_values = 'E';

1022
			%suppress_ifbraces = ();
1023
1024
			next;

1025
1026
1027
# 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.
1028
		} elsif ($line =~ /^( |\+|$)/) {
1029
			$realline++;
1030
			$realcnt-- if ($realcnt != 0);
1031

1032
			# Measure the line length and indent.
1033
			($length, $indent) = line_stats($rawline);
1034
1035
1036
1037

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

1040
			#warn "line<$line>\n";
1041

1042
1043
		} elsif ($realcnt == 1) {
			$realcnt--;
1044
1045
1046
		}

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

1050
1051
		$here = "#$linenr: " if (!$file);
		$here = "#$realline: " if ($file);
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063

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

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

1066
1067
1068
		my $hereline = "$here\n$rawline\n";
		my $herecurr = "$here\n$rawline\n";
		my $hereprev = "$here\n$prevrawline\n$rawline\n";
1069

1070
1071
		$cnt_lines++ if ($realcnt != 0);

1072
#check the patch for a signoff:
1073
		if ($line =~ /^\s*signed-off-by:/i) {
1074
1075
			# This is a signoff, if ugly, so do not double report.
			$signoff++;
1076
			if (!($line =~ /^\s*Signed-off-by:/)) {
1077
1078
				WARN("Signed-off-by: is the preferred form\n" .
					$herecurr);
1079
1080
			}
			if ($line =~ /^\s*signed-off-by:\S/i) {
1081
				WARN("space required after Signed-off-by:\n" .
1082
					$herecurr);
1083
1084
1085
			}
		}

1086
# Check for wrappage within a valid hunk of the file
1087
		if ($realcnt != 0 && $line !~ m{^(?:\+|-| |\\ No newline|$)}) {
1088
			ERROR("patch seems to be corrupt (line wrapped?)\n" .
1089
				$herecurr) if (!$emitted_corrupt++);
1090
1091
1092
1093
		}

# UTF-8 regex found at http://www.w3.org/International/questions/qa-forms-utf-8.en.php
		if (($realfile =~ /^$/ || $line =~ /^\+/) &&
1094
1095
1096
1097
1098
1099
1100
1101
		    $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);
1102
1103
1104
1105
		}

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

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

#trailing whitespace
1111
		if ($line =~ /^\+.*\015/) {
1112
			my $herevet = "$here\n" . cat_vet($rawline) . "\n";
1113
1114
			ERROR("DOS line endings\n" . $herevet);

1115
1116
		} elsif ($rawline =~ /^\+.*\S\s+$/ || $rawline =~ /^\+\s+$/) {
			my $herevet = "$here\n" . cat_vet($rawline) . "\n";
1117
			ERROR("trailing whitespace\n" . $herevet);
1118
1119
		}
#80 column limit
1120
		if ($line =~ /^\+/ && !($prevrawline=~/\/\*\*/) && $length > 80) {
1121
			WARN("line over 80 characters\n" . $herecurr);
1122
1123
		}

1124
1125
1126
1127
1128
# 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);
		}

1129
1130
1131
1132
1133
# 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.
1134
1135
1136
		if ($rawline =~ /^\+\s* \t\s*\S/ ||
		    $rawline =~ /^\+\s*        \s*/) {
			my $herevet = "$here\n" . cat_vet($rawline) . "\n";
1137
			ERROR("code indent should use tabs where possible\n" . $herevet);
1138
1139
		}

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

1145
# Check for potential 'bare' types
1146
		my ($stat, $cond);
1147
		if ($realcnt && $line =~ /.\s*\S/) {
1148
1149
1150
1151
1152
1153
1154
			($stat, $cond) = ctx_statement_block($linenr,
								$realcnt, 0);
			$stat =~ s/\n./\n /g;
			$cond =~ s/\n./\n /g;

			my $s = $stat;
			$s =~ s/{.*$//s;
1155

1156
			# Ignore goto labels.
1157
			if ($s =~ /$Ident:\*$/s) {
1158
1159

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

1162
			# definitions in global scope can only start with types
1163
			} elsif ($s =~ /^.(?:$Storage\s+)?(?:$Inline\s+)?(?:const\s+)?($Ident)\b/s) {
1164
				possible($1, $s);
1165
1166

			# declarations always start with types
1167
			} elsif ($prev_values eq 'E' && $s =~ /^.\s*(?:$Storage\s+)?(?:const\s+)?($Ident)\b(:?\s+$Sparse)?\s*\**\s*$Ident\s*(?:;|=|,)/s) {
1168
				possible($1, $s);
1169
			}
1170
1171

			# any (foo ... *) is a pointer cast, and foo is a type
1172
			while ($s =~ /\(($Ident)(?:\s+$Sparse)*\s*\*+\s*\)/sg) {
1173
				possible($1, $s);
1174
1175
1176
1177
1178
			}

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

1182
				my $ctx = $s;
1183
				substr($ctx, 0, $name_len + 1, '');
1184
				$ctx =~ s/\)[^\)]*$//;
1185

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

Andy Whitcroft's avatar