checkpatch.pl 53.3 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.16';
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
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
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+)?
162
163
164
165
			(?:
				$all|
				(?:typeof|__typeof__)\s*\(\s*\**\s*$Ident\s*\)
			)
166
167
168
169
170
171
			(?:\s+$Sparse|\s+const)*
			\b
		  }x;
	$Type	= qr{
			\b$NonptrType\b
			(?:\s*\*+\s*const|\s*\*+|(?:\s*\[\s*\])+)?
172
			(?:\s+$Inline|\s+$Sparse|\s+$Attribute)*
173
174
175
176
		  }x;
	$Declare	= qr{(?:$Storage\s+)?$Type};
}
build_types();
177
178
179

$chk_signoff = 0 if ($file);

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

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

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

exit($exit);

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

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;
}
267
sub copy_spacing {
268
	(my $res = shift) =~ tr/\t/ /c;
269
270
	return $res;
}
271

272
273
274
275
276
277
278
279
280
281
282
283
284
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));
}

285
286
287
288
289
290
291
292
293
294
295
my $sanitise_quote = '';

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

	if ($in_comment) {
		$sanitise_quote = '*/';
	} else {
		$sanitise_quote = '';
	}
}
296
297
298
299
300
301
sub sanitise_line {
	my ($line) = @_;

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

302
	my $qlen = 0;
303
304
	my $off = 0;
	my $c;
305

306
307
308
309
310
311
312
313
314
315
316
317
318
319
	# 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;
320
		}
321
322
323
324
325
		if (substr($line, $off, 2) eq $sanitise_quote) {
			$sanitise_quote = '';
			substr($res, $off, 2, "$;$;");
			$off++;
			next;
326
		}
327
328
329
330
331
332
333

		# 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;
334
		}
335
336
337
338
		# Regular quotes.
		if ($c eq "'" || $c eq '"') {
			if ($sanitise_quote eq '') {
				$sanitise_quote = $c;
339

340
341
342
343
344
345
				substr($res, $off, 1, $c);
				next;
			} elsif ($sanitise_quote eq $c) {
				$sanitise_quote = '';
			}
		}
346

347
348
349
350
351
352
353
354
		#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);
		}
355
356
357
358
359
360
361
362
363
364
365
366
367
	}

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

368
369
370
	return $res;
}

371
372
373
374
375
376
sub ctx_statement_block {
	my ($linenr, $remain, $off) = @_;
	my $line = $linenr - 1;
	my $blk = '';
	my $soff = $off;
	my $coff = $off - 1;
377
	my $coff_set = 0;
378

379
380
	my $loff = 0;

381
382
	my $type = '';
	my $level = 0;
383
	my $p;
384
385
	my $c;
	my $len = 0;
386
387

	my $remainder;
388
	while (1) {
389
		#warn "CSB: blk<$blk> remain<$remain>\n";
390
391
392
393
		# If we are about to drop off the end, pull in more
		# context.
		if ($off >= $len) {
			for (; $remain > 0; $line++) {
394
				next if ($lines[$line] =~ /^-/);
395
				$remain--;
396
				$loff = $len;
397
				$blk .= $lines[$line] . "\n";
398
399
400
401
402
403
				$len = length($blk);
				$line++;
				last;
			}
			# Bail if there is no further context.
			#warn "CSB: blk<$blk> off<$off> len<$len>\n";
404
			if ($off >= $len) {
405
406
407
				last;
			}
		}
408
		$p = $c;
409
		$c = substr($blk, $off, 1);
410
		$remainder = substr($blk, $off);
411

412
		#warn "CSB: c<$c> type<$type> level<$level> remainder<$remainder> coff_set<$coff_set>\n";
413
414
415
416
417
418
		# Statement ends at the ';' or a close '}' at the
		# outermost level.
		if ($level == 0 && $c eq ';') {
			last;
		}

419
		# An else is really a conditional as long as its not else if
420
421
422
423
424
425
426
427
		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";
428
429
		}

430
431
432
433
434
435
436
437
438
439
		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;
440
441
				$coff_set = 1;
				#warn "CSB: mark coff<$coff>\n";
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
			}
		}
		if (($type eq '' || $type eq '{') && $c eq '{') {
			$level++;
			$type = '{';
		}
		if ($type eq '{' && $c eq '}') {
			$level--;
			$type = ($level != 0)? '{' : '';

			if ($level == 0) {
				last;
			}
		}
		$off++;
	}
458
459
460
461
	if ($off == $len) {
		$line++;
		$remain--;
	}
462
463
464
465
466
467
468

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

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

469
	#print "coff<$coff> soff<$off> loff<$loff>\n";
470
471
472
473
474

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

475
476
477
478
479
480
481
482
483
484
485
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
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;
	}
}

518
519
520
521
522
523
sub ctx_statement_full {
	my ($linenr, $remain, $off) = @_;
	my ($statement, $condition, $level);

	my (@chunks);

524
	# Grab the first conditional/block pair.
525
526
	($statement, $condition, $linenr, $remain, $off, $level) =
				ctx_statement_block($linenr, $remain, $off);
527
	#print "F: c<$condition> s<$statement> remain<$remain>\n";
528
529
530
531
532
533
534
	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.
535
536
537
	for (;;) {
		($statement, $condition, $linenr, $remain, $off, $level) =
				ctx_statement_block($linenr, $remain, $off);
538
		#print "C: c<$condition> s<$statement> remain<$remain>\n";
539
		last if (!($remain > 0 && $condition =~ /^(?:\s*\n[+-])*\s*(?:else|do)\b/s));
540
541
		#print "C: push\n";
		push(@chunks, [ $condition, $statement ]);
542
543
544
	}

	return ($level, $linenr, @chunks);
545
546
}

547
sub ctx_block_get {
548
	my ($linenr, $remain, $outer, $open, $close, $off) = @_;
549
550
551
552
553
554
555
	my $line;
	my $start = $linenr - 1;
	my $blk = '';
	my @o;
	my @c;
	my @res = ();

556
	my $level = 0;
557
558
559
560
561
	for ($line = $start; $remain > 0; $line++) {
		next if ($rawlines[$line] =~ /^-/);
		$remain--;

		$blk .= $rawlines[$line];
562
563
564
565
566
567
		foreach my $c (split(//, $rawlines[$line])) {
			##print "C<$c>L<$level><$open$close>O<$off>\n";
			if ($off > 0) {
				$off--;
				next;
			}
568

569
570
571
572
573
574
575
			if ($c eq $close && $level > 0) {
				$level--;
				last if ($level == 0);
			} elsif ($c eq $open) {
				$level++;
			}
		}
576

577
		if (!$outer || $level <= 1) {
578
			push(@res, $rawlines[$line]);
579
580
		}

581
		last if ($level == 0);
582
583
	}

584
	return ($level, @res);
585
586
587
588
}
sub ctx_block_outer {
	my ($linenr, $remain) = @_;

589
590
	my ($level, @r) = ctx_block_get($linenr, $remain, 1, '{', '}', 0);
	return @r;
591
592
593
594
}
sub ctx_block {
	my ($linenr, $remain) = @_;

595
596
	my ($level, @r) = ctx_block_get($linenr, $remain, 0, '{', '}', 0);
	return @r;
597
598
}
sub ctx_statement {
599
600
601
602
603
604
	my ($linenr, $remain, $off) = @_;

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

607
	return ctx_block_get($linenr, $remain, 0, '{', '}', 0);
608
}
609
610
611
612
613
sub ctx_statement_level {
	my ($linenr, $remain, $off) = @_;

	return ctx_block_get($linenr, $remain, 0, '(', ')', $off);
}
614
615
616
617
618

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

	# Catch a comment on the end of the line itself.
619
	my ($current_comment) = ($rawlines[$end_line - 1] =~ m@.*(/\*.*\*/)\s*$@);
620
621
622
623
624
625
626
	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++) {
627
628
		my $line = $rawlines[$linenr - 1];
		#warn "           $line\n";
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
		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);

651
	##print "LINE: $rawlines[$end_line - 1 ]\n";
652
653
654
655
656
	##print "CMMT: $cmt\n";

	return ($cmt ne '');
}

657
658
659
sub cat_vet {
	my ($vet) = @_;
	my ($res, $coded);
660

661
662
663
664
665
666
	$res = '';
	while ($vet =~ /([^[:cntrl:]]*)([[:cntrl:]]|$)/g) {
		$res .= $1;
		if ($2 ne '') {
			$coded = sprintf("^%c", unpack('C', $2) + 64);
			$res .= $coded;
667
668
		}
	}
669
	$res =~ s/$/\$/;
670

671
	return $res;
672
673
}

674
my $av_preprocessor = 0;
675
my $av_pending;
676
677
678
679
my @av_paren_type;

sub annotate_reset {
	$av_preprocessor = 0;
680
681
	$av_pending = '_';
	@av_paren_type = ('E');
682
683
}

684
685
sub annotate_values {
	my ($stream, $type) = @_;
686

687
688
689
	my $res;
	my $cur = $stream;

690
	print "$stream\n" if ($dbg_values > 1);
691
692

	while (length($cur)) {
693
		@av_paren_type = ('E') if ($#av_paren_type < 0);
694
695
		print " <" . join('', @av_paren_type) .
					"> <$type> " if ($dbg_values > 1);
696
		if ($cur =~ /^(\s+)/o) {
697
698
			print "WS($1)\n" if ($dbg_values > 1);
			if ($1 =~ /\n/ && $av_preprocessor) {
699
				$type = pop(@av_paren_type);
700
				$av_preprocessor = 0;
701
702
			}

703
		} elsif ($cur =~ /^($Type)/) {
704
			print "DECLARE($1)\n" if ($dbg_values > 1);
705
706
707
			$type = 'T';

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

712
713
		} elsif ($cur =~ /^(#\s*(?:ifdef|ifndef|if))/o) {
			print "PRE_START($1)\n" if ($dbg_values > 1);
714
			$av_preprocessor = 1;
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736

			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);
737
738
739
			$type = 'N';

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

		} elsif ($cur =~ /^(sizeof)\s*(\()?/o) {
743
			print "SIZEOF($1)\n" if ($dbg_values > 1);
744
			if (defined $2) {
745
				$av_pending = 'V';
746
747
748
			}
			$type = 'N';

749
		} elsif ($cur =~ /^(if|while|typeof|__typeof__|for)\b/o) {
750
			print "COND($1)\n" if ($dbg_values > 1);
751
			$av_pending = 'N';
752
753
754
			$type = 'N';

		} elsif ($cur =~/^(return|case|else)/o) {
755
			print "KEYWORD($1)\n" if ($dbg_values > 1);
756
757
758
			$type = 'N';

		} elsif ($cur =~ /^(\()/o) {
759
			print "PAREN('$1')\n" if ($dbg_values > 1);
760
761
			push(@av_paren_type, $av_pending);
			$av_pending = '_';
762
763
764
			$type = 'N';

		} elsif ($cur =~ /^(\))/o) {
765
766
767
			my $new_type = pop(@av_paren_type);
			if ($new_type ne '_') {
				$type = $new_type;
768
769
				print "PAREN('$1') -> $type\n"
							if ($dbg_values > 1);
770
			} else {
771
				print "PAREN('$1')\n" if ($dbg_values > 1);
772
773
774
			}

		} elsif ($cur =~ /^($Ident)\(/o) {
775
			print "FUNC($1)\n" if ($dbg_values > 1);
776
			$av_pending = 'V';
777
778

		} elsif ($cur =~ /^($Ident|$Constant)/o) {
779
			print "IDENT($1)\n" if ($dbg_values > 1);
780
781
782
			$type = 'V';

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

786
		} elsif ($cur =~/^(;|{|})/) {
787
			print "END($1)\n" if ($dbg_values > 1);
788
789
			$type = 'E';

790
		} elsif ($cur =~ /^(;|\?|:|\[)/o) {
791
			print "CLOSE($1)\n" if ($dbg_values > 1);
792
793
794
			$type = 'N';

		} elsif ($cur =~ /^($Operators)/o) {
795
			print "OP($1)\n" if ($dbg_values > 1);
796
797
798
799
800
			if ($1 ne '++' && $1 ne '--') {
				$type = 'N';
			}

		} elsif ($cur =~ /(^.)/o) {
801
			print "C($1)\n" if ($dbg_values > 1);
802
803
804
805
806
		}
		if (defined $1) {
			$cur = substr($cur, length($1));
			$res .= $type x length($1);
		}
807
	}
808

809
	return $res;
810
811
}

812
sub possible {
813
	my ($possible, $line) = @_;
814
815
816
817
818
819
820

	#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') {
821
		warn "POSSIBLE: $possible ($line)\n" if ($dbg_possible);
822
823
824
825
826
		push(@typeList, $possible);
		build_types();
	}
}

827
828
my $prefix = '';

829
sub report {
830
831
832
	if (defined $tst_only && $_[0] !~ /\Q$tst_only\E/) {
		return 0;
	}
833
834
835
836
	my $line = $prefix . $_[0];

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

837
	push(our @report, $line);
838
839

	return 1;
840
841
}
sub report_dump {
842
	our @report;
843
}
844
sub ERROR {
845
846
847
848
	if (report("ERROR: $_[0]\n")) {
		our $clean = 0;
		our $cnt_error++;
	}
849
850
}
sub WARN {
851
852
853
854
	if (report("WARNING: $_[0]\n")) {
		our $clean = 0;
		our $cnt_warn++;
	}
855
856
}
sub CHK {
857
	if ($check && report("CHECK: $_[0]\n")) {
858
859
860
		our $clean = 0;
		our $cnt_chk++;
	}
861
862
}

863
864
865
866
867
sub process {
	my $filename = shift;

	my $linenr=0;
	my $prevline="";
868
	my $prevrawline="";
869
	my $stashline="";
870
	my $stashrawline="";
871

872
	my $length;
873
874
875
876
	my $indent;
	my $previndent=0;
	my $stashindent=0;

877
	our $clean = 1;
878
879
880
	my $signoff = 0;
	my $is_patch = 0;

881
	our @report = ();
882
883
884
885
886
	our $cnt_lines = 0;
	our $cnt_error = 0;
	our $cnt_warn = 0;
	our $cnt_chk = 0;

887
888
889
890
891
892
	# Trace the real file/line as we go.
	my $realfile = '';
	my $realline = 0;
	my $realcnt = 0;
	my $here = '';
	my $in_comment = 0;
893
	my $comment_edge = 0;
894
895
	my $first_line = 0;

896
897
898
	my $prev_values = 'E';

	# suppression flags
899
	my %suppress_ifbraces;
900

901
	# Pre-scan the patch sanitizing the lines.
902
	# Pre-scan the patch looking for any __setup documentation.
903
	#
904
905
	my @setup_docs = ();
	my $setup_docs = 0;
906
907

	sanitise_line_reset();
908
909
	my $line;
	foreach my $rawline (@rawlines) {
910
911
		$linenr++;
		$line = $rawline;
912

913
		if ($rawline=~/^\+\+\+\s+(\S+)/) {
914
915
916
917
			$setup_docs = 0;
			if ($1 =~ m@Documentation/kernel-parameters.txt$@) {
				$setup_docs = 1;
			}
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
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;
			for (my $ln = $linenr; $ln < ($linenr + $realcnt); $ln++) {
				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);

		} elsif ($realcnt) {
			# Standardise the strings and chars within the input to
			# simplify matching.
			$line = sanitise_line($rawline);
958
		}
959
960
961
962
963
964
965
966
967
968
		push(@lines, $line);

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

		#print "==>$rawline\n";
		#print "-->$line\n";
969
970
971
972
973
974

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

975
976
	$prefix = '';

977
978
	$realcnt = 0;
	$linenr = 0;
979
980
981
	foreach my $line (@lines) {
		$linenr++;

982
		my $rawline = $rawlines[$linenr - 1];
983

984
#extract the line range in the file after the patch is applied
985
		if ($line=~/^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@/) {
986
			$is_patch = 1;
987
			$first_line = $linenr + 1;
988
989
990
991
992
993
			$realline=$1-1;
			if (defined $2) {
				$realcnt=$3+1;
			} else {
				$realcnt=1+1;
			}
994
			annotate_reset();
995
996
			$prev_values = 'E';

997
			%suppress_ifbraces = ();
998
999
			next;

1000
1001
1002
# 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.
1003
		} elsif ($line =~ /^( |\+|$)/) {
1004
			$realline++;
1005
			$realcnt-- if ($realcnt != 0);
1006

1007
			# Measure the line length and indent.
1008
			($length, $indent) = line_stats($rawline);
1009
1010
1011
1012

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

1015
			#warn "line<$line>\n";
1016

1017
1018
		} elsif ($realcnt == 1) {
			$realcnt--;
1019
1020
1021
		}

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

1025
1026
		$here = "#$linenr: " if (!$file);
		$here = "#$realline: " if ($file);
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038

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

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

1041
1042
1043
		my $hereline = "$here\n$rawline\n";
		my $herecurr = "$here\n$rawline\n";
		my $hereprev = "$here\n$prevrawline\n$rawline\n";
1044

1045
1046
		$cnt_lines++ if ($realcnt != 0);

1047
#check the patch for a signoff:
1048
		if ($line =~ /^\s*signed-off-by:/i) {
1049
1050
			# This is a signoff, if ugly, so do not double report.
			$signoff++;
1051
			if (!($line =~ /^\s*Signed-off-by:/)) {
1052
1053
				WARN("Signed-off-by: is the preferred form\n" .
					$herecurr);
1054
1055
			}
			if ($line =~ /^\s*signed-off-by:\S/i) {
1056
				WARN("space required after Signed-off-by:\n" .
1057
					$herecurr);
1058
1059
1060
			}
		}

1061
# Check for wrappage within a valid hunk of the file
1062
		if ($realcnt != 0 && $line !~ m{^(?:\+|-| |\\ No newline|$)}) {
1063
			ERROR("patch seems to be corrupt (line wrapped?)\n" .
1064
				$herecurr) if (!$emitted_corrupt++);
1065
1066
1067
1068
		}

# UTF-8 regex found at http://www.w3.org/International/questions/qa-forms-utf-8.en.php
		if (($realfile =~ /^$/ || $line =~ /^\+/) &&
1069
		     !($rawline =~ m/^(
1070
1071
1072
1073
1074
1075
1076
1077
1078
				[\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 )) {
1079
			ERROR("Invalid UTF-8, patch and commit message should be encoded in UTF-8\n" . $herecurr);
1080
1081
1082
1083
		}

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

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

#trailing whitespace
1089
		if ($line =~ /^\+.*\015/) {
1090
			my $herevet = "$here\n" . cat_vet($rawline) . "\n";
1091
1092
			ERROR("DOS line endings\n" . $herevet);

1093
1094
		} elsif ($rawline =~ /^\+.*\S\s+$/ || $rawline =~ /^\+\s+$/) {
			my $herevet = "$here\n" . cat_vet($rawline) . "\n";
1095
			ERROR("trailing whitespace\n" . $herevet);
1096
1097
		}
#80 column limit
1098
		if ($line =~ /^\+/ && !($prevrawline=~/\/\*\*/) && $length > 80) {
1099
			WARN("line over 80 characters\n" . $herecurr);
1100
1101
		}

1102
1103
1104
1105
1106
# 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);
		}

1107
1108
1109
1110
1111
# 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.
1112
1113
1114
		if ($rawline =~ /^\+\s* \t\s*\S/ ||
		    $rawline =~ /^\+\s*        \s*/) {
			my $herevet = "$here\n" . cat_vet($rawline) . "\n";
1115
			ERROR("use tabs not spaces\n" . $herevet);
1116
1117
		}

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

1123
# Check for potential 'bare' types
1124
		if ($realcnt) {
1125
1126
1127
1128
			my ($s, $c) = ctx_statement_block($linenr, $realcnt, 0);
			$s =~ s/\n./ /g;
			$s =~ s/{.*$//;

1129
			# Ignore goto labels.
1130
			if ($s =~ /$Ident:\*$/) {
1131
1132

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

1135
			# definitions in global scope can only start with types
1136
1137
			} elsif ($s =~ /^.(?:$Storage\s+)?(?:$Inline\s+)?(?:const\s+)?($Ident)\b/) {
				possible($1, $s);
1138
1139

			# declarations always start with types
1140
1141
			} elsif ($prev_values eq 'E' && $s =~ /^.\s*(?:$Storage\s+)?(?:const\s+)?($Ident)\b(:?\s+$Sparse)?\s*\**\s*$Ident\s*(?:;|=|,)/) {
				possible($1, $s);
1142
			}
1143
1144

			# any (foo ... *) is a pointer cast, and foo is a type
1145
1146
			while ($s =~ /\(($Ident)(?:\s+$Sparse)*\s*\*+\s*\)/g) {
				possible($1, $s);
1147
1148
1149
1150
1151
			}

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

1155
				my $ctx = $s;
1156
				substr($ctx, 0, $name_len + 1, '');
1157
				$ctx =~ s/\)[^\)]*$//;
1158

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

1162
						possible($1, $s);
1163
1164
					}
				}
1165
			}
1166

1167
1168
		}

1169
1170
1171
#
# Checks which may be anchored in the context.
#
1172

1173
1174
# Check for switch () and associated case and default
# statements should be at the same indent.
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
		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 '') {
1191
				ERROR("switch and case should be at the same indent\n$hereline$err");
1192
1193
1194
1195
1196
			}
		}

# 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
1197
1198
1199
		if ($line =~ /(.*)\b((?:if|while|for|switch)\s*\(|do\b|else\b)/ && $line !~ /^.#/) {
			my $pre_ctx = "$1$2";

1200
			my ($level, @ctx) = ctx_statement_level($linenr, $realcnt, 0);
1201
1202
1203
1204
			my $ctx_ln = $linenr + $#ctx + 1;
			my $ctx_cnt = $realcnt - $#ctx - 1;
			my $ctx = join("\n", @ctx);

1205
1206
			##warn "realcnt<$realcnt> ctx_cnt<$ctx_cnt>\n";

1207
			# Skip over any removed lines in the context following statement.
1208
			while (defined($lines[$ctx_ln - 1]) && $lines[$ctx_ln - 1] =~ /^-/) {