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

use strict;

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

Andy Whitcroft's avatar
Andy Whitcroft committed
12
my $V = '0.24';
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_only;
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-only=s'	=> \$tst_only,
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
my $dbg_values = 0;
my $dbg_possible = 0;
68
my $dbg_type = 0;
69
my $dbg_attr = 0;
70
71
72
73
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
		}x;
our $Attribute	= qr{
			const|
			__read_mostly|
			__kprobes|
116
117
118
119
			__(?:mem|cpu|dev|)(?:initdata|init)|
			____cacheline_aligned|
			____cacheline_aligned_in_smp|
			____cacheline_internodealigned_in_smp
120
		  }x;
121
our $Modifier;
122
123
124
125
126
127
128
129
130
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{
			<=|>=|==|!=|
			=>|->|<<|>>|<|>|!|~|
131
			&&|\|\||,|\^|\+\+|--|&|\||\+|-|\*|\/|%
132
133
		  }x;

134
135
136
137
our $NonptrType;
our $Type;
our $Declare;

138
139
140
141
142
143
144
145
146
147
148
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;

149
150
151
152
153
our $typeTypedefs = qr{(?x:
	(?:__)?(?:u|s|be|le)(?:\d|\d\d)|
	atomic_t
)};

154
155
our @typeList = (
	qr{void},
156
157
158
159
160
161
162
	qr{(?:unsigned\s+)?char},
	qr{(?:unsigned\s+)?short},
	qr{(?:unsigned\s+)?int},
	qr{(?:unsigned\s+)?long},
	qr{(?:unsigned\s+)?long\s+int},
	qr{(?:unsigned\s+)?long\s+long},
	qr{(?:unsigned\s+)?long\s+long\s+int},
163
164
165
166
167
168
169
170
171
172
173
	qr{unsigned},
	qr{float},
	qr{double},
	qr{bool},
	qr{struct\s+$Ident},
	qr{union\s+$Ident},
	qr{enum\s+$Ident},
	qr{${Ident}_t},
	qr{${Ident}_handler},
	qr{${Ident}_handler_fn},
);
174
175
176
our @modifierList = (
	qr{fastcall},
);
177
178

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

$chk_signoff = 0 if ($file);

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

214
215
216
				} elsif ($entry !~ m@/@) {
					push(@dep_functions, $entry);
				}
217
			}
218
219
220
221
		}
	}
}

222
my @rawlines = ();
223
224
my @lines = ();
my $vname;
225
226
227
228
229
230
231
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";
232
	}
233
234
235
236
237
	if ($filename eq '-') {
		$vname = 'Your patch';
	} else {
		$vname = $filename;
	}
238
239
240
241
242
	while (<FILE>) {
		chomp;
		push(@rawlines, $_);
	}
	close(FILE);
243
	if (!process($filename)) {
244
245
246
		$exit = 1;
	}
	@rawlines = ();
247
	@lines = ();
248
249
250
251
252
}

exit($exit);

sub top_of_kernel_tree {
253
254
255
256
257
258
259
260
261
262
263
264
	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;
		}
265
	}
266
	return 1;
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
}

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;
}
289
sub copy_spacing {
290
	(my $res = shift) =~ tr/\t/ /c;
291
292
	return $res;
}
293

294
295
296
297
298
299
300
301
302
303
304
305
306
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));
}

307
308
309
310
311
312
313
314
315
316
317
my $sanitise_quote = '';

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

	if ($in_comment) {
		$sanitise_quote = '*/';
	} else {
		$sanitise_quote = '';
	}
}
318
319
320
321
322
323
sub sanitise_line {
	my ($line) = @_;

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

324
	my $qlen = 0;
325
326
	my $off = 0;
	my $c;
327

328
329
330
331
332
333
334
335
336
337
338
339
340
341
	# 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;
342
		}
343
		if ($sanitise_quote eq '*/' && substr($line, $off, 2) eq '*/') {
344
345
346
347
			$sanitise_quote = '';
			substr($res, $off, 2, "$;$;");
			$off++;
			next;
348
		}
349
350
351
352
353
354
355

		# 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;
356
		}
357
358
359
360
		# Regular quotes.
		if ($c eq "'" || $c eq '"') {
			if ($sanitise_quote eq '') {
				$sanitise_quote = $c;
361

362
363
364
365
366
367
				substr($res, $off, 1, $c);
				next;
			} elsif ($sanitise_quote eq $c) {
				$sanitise_quote = '';
			}
		}
368

369
370
371
372
373
374
375
376
		#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);
		}
377
378
379
	}

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

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

390
391
392
	return $res;
}

393
394
395
396
397
398
sub ctx_statement_block {
	my ($linenr, $remain, $off) = @_;
	my $line = $linenr - 1;
	my $blk = '';
	my $soff = $off;
	my $coff = $off - 1;
399
	my $coff_set = 0;
400

401
402
	my $loff = 0;

403
404
	my $type = '';
	my $level = 0;
405
	my $p;
406
407
	my $c;
	my $len = 0;
408
409

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

435
		#warn "CSB: c<$c> type<$type> level<$level> remainder<$remainder> coff_set<$coff_set>\n";
436
437
438
439
440
441
		# Statement ends at the ';' or a close '}' at the
		# outermost level.
		if ($level == 0 && $c eq ';') {
			last;
		}

442
		# An else is really a conditional as long as its not else if
443
444
445
446
447
448
449
450
		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";
451
452
		}

453
454
455
456
457
458
459
460
461
462
		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;
463
464
				$coff_set = 1;
				#warn "CSB: mark coff<$coff>\n";
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
			}
		}
		if (($type eq '' || $type eq '{') && $c eq '{') {
			$level++;
			$type = '{';
		}
		if ($type eq '{' && $c eq '}') {
			$level--;
			$type = ($level != 0)? '{' : '';

			if ($level == 0) {
				last;
			}
		}
		$off++;
	}
481
	# We are truly at the end, so shuffle to the next line.
482
	if ($off == $len) {
483
		$loff = $len + 1;
484
485
486
		$line++;
		$remain--;
	}
487
488
489
490
491
492
493

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

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

494
	#print "coff<$coff> soff<$off> loff<$loff>\n";
495
496
497
498
499

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

500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
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;
	}
}

543
544
545
546
547
548
sub ctx_statement_full {
	my ($linenr, $remain, $off) = @_;
	my ($statement, $condition, $level);

	my (@chunks);

549
	# Grab the first conditional/block pair.
550
551
	($statement, $condition, $linenr, $remain, $off, $level) =
				ctx_statement_block($linenr, $remain, $off);
552
	#print "F: c<$condition> s<$statement> remain<$remain>\n";
553
554
555
556
557
558
559
	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.
560
561
562
	for (;;) {
		($statement, $condition, $linenr, $remain, $off, $level) =
				ctx_statement_block($linenr, $remain, $off);
563
		#print "C: c<$condition> s<$statement> remain<$remain>\n";
564
		last if (!($remain > 0 && $condition =~ /^(?:\s*\n[+-])*\s*(?:else|do)\b/s));
565
566
		#print "C: push\n";
		push(@chunks, [ $condition, $statement ]);
567
568
569
	}

	return ($level, $linenr, @chunks);
570
571
}

572
sub ctx_block_get {
573
	my ($linenr, $remain, $outer, $open, $close, $off) = @_;
574
575
576
577
578
579
580
	my $line;
	my $start = $linenr - 1;
	my $blk = '';
	my @o;
	my @c;
	my @res = ();

581
	my $level = 0;
582
583
584
585
586
	for ($line = $start; $remain > 0; $line++) {
		next if ($rawlines[$line] =~ /^-/);
		$remain--;

		$blk .= $rawlines[$line];
587
588
589
590
591
592
		foreach my $c (split(//, $rawlines[$line])) {
			##print "C<$c>L<$level><$open$close>O<$off>\n";
			if ($off > 0) {
				$off--;
				next;
			}
593

594
595
596
597
598
599
600
			if ($c eq $close && $level > 0) {
				$level--;
				last if ($level == 0);
			} elsif ($c eq $open) {
				$level++;
			}
		}
601

602
		if (!$outer || $level <= 1) {
603
			push(@res, $rawlines[$line]);
604
605
		}

606
		last if ($level == 0);
607
608
	}

609
	return ($level, @res);
610
611
612
613
}
sub ctx_block_outer {
	my ($linenr, $remain) = @_;

614
615
	my ($level, @r) = ctx_block_get($linenr, $remain, 1, '{', '}', 0);
	return @r;
616
617
618
619
}
sub ctx_block {
	my ($linenr, $remain) = @_;

620
621
	my ($level, @r) = ctx_block_get($linenr, $remain, 0, '{', '}', 0);
	return @r;
622
623
}
sub ctx_statement {
624
625
626
627
628
629
	my ($linenr, $remain, $off) = @_;

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

632
	return ctx_block_get($linenr, $remain, 0, '{', '}', 0);
633
}
634
635
636
637
638
sub ctx_statement_level {
	my ($linenr, $remain, $off) = @_;

	return ctx_block_get($linenr, $remain, 0, '(', ')', $off);
}
639
640
641
642
643

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

	# Catch a comment on the end of the line itself.
644
	my ($current_comment) = ($rawlines[$end_line - 1] =~ m@.*(/\*.*\*/)\s*(?:\\\s*)?$@);
645
646
647
648
649
650
651
	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++) {
652
653
		my $line = $rawlines[$linenr - 1];
		#warn "           $line\n";
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
		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);

676
	##print "LINE: $rawlines[$end_line - 1 ]\n";
677
678
679
680
681
	##print "CMMT: $cmt\n";

	return ($cmt ne '');
}

682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
sub raw_line {
	my ($linenr, $cnt) = @_;

	my $offset = $linenr - 1;
	$cnt++;

	my $line;
	while ($cnt) {
		$line = $rawlines[$offset++];
		next if (defined($line) && $line =~ /^-/);
		$cnt--;
	}

	return $line;
}

698
699
700
sub cat_vet {
	my ($vet) = @_;
	my ($res, $coded);
701

702
703
704
705
706
707
	$res = '';
	while ($vet =~ /([^[:cntrl:]]*)([[:cntrl:]]|$)/g) {
		$res .= $1;
		if ($2 ne '') {
			$coded = sprintf("^%c", unpack('C', $2) + 64);
			$res .= $coded;
708
709
		}
	}
710
	$res =~ s/$/\$/;
711

712
	return $res;
713
714
}

715
my $av_preprocessor = 0;
716
my $av_pending;
717
my @av_paren_type;
718
my $av_pend_colon;
719
720
721

sub annotate_reset {
	$av_preprocessor = 0;
722
723
	$av_pending = '_';
	@av_paren_type = ('E');
724
	$av_pend_colon = 'O';
725
726
}

727
728
sub annotate_values {
	my ($stream, $type) = @_;
729

730
	my $res;
731
	my $var = '_' x length($stream);
732
733
	my $cur = $stream;

734
	print "$stream\n" if ($dbg_values > 1);
735
736

	while (length($cur)) {
737
		@av_paren_type = ('E') if ($#av_paren_type < 0);
738
		print " <" . join('', @av_paren_type) .
739
				"> <$type> <$av_pending>" if ($dbg_values > 1);
740
		if ($cur =~ /^(\s+)/o) {
741
742
			print "WS($1)\n" if ($dbg_values > 1);
			if ($1 =~ /\n/ && $av_preprocessor) {
743
				$type = pop(@av_paren_type);
744
				$av_preprocessor = 0;
745
746
			}

747
		} elsif ($cur =~ /^($Type)\s*(?:$Ident|,|\)|\()/) {
748
			print "DECLARE($1)\n" if ($dbg_values > 1);
749
750
			$type = 'T';

751
752
753
754
		} elsif ($cur =~ /^($Modifier)\s*/) {
			print "MODIFIER($1)\n" if ($dbg_values > 1);
			$type = 'T';

755
		} elsif ($cur =~ /^(\#\s*define\s*$Ident)(\(?)/o) {
756
			print "DEFINE($1,$2)\n" if ($dbg_values > 1);
757
			$av_preprocessor = 1;
758
759
760
761
762
763
			push(@av_paren_type, $type);
			if ($2 ne '') {
				$av_pending = 'N';
			}
			$type = 'E';

764
		} elsif ($cur =~ /^(\#\s*(?:undef\s*$Ident|include\b))/o) {
765
766
767
			print "UNDEF($1)\n" if ($dbg_values > 1);
			$av_preprocessor = 1;
			push(@av_paren_type, $type);
768

769
		} elsif ($cur =~ /^(\#\s*(?:ifdef|ifndef|if))/o) {
770
			print "PRE_START($1)\n" if ($dbg_values > 1);
771
			$av_preprocessor = 1;
772
773
774

			push(@av_paren_type, $type);
			push(@av_paren_type, $type);
775
			$type = 'E';
776

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

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

783
			$type = 'E';
784

785
		} elsif ($cur =~ /^(\#\s*(?:endif))/o) {
786
787
788
789
790
791
792
793
			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);
794
			$type = 'E';
795
796

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

799
800
801
802
803
		} elsif ($cur =~ /^(__attribute__)\s*\(?/o) {
			print "ATTR($1)\n" if ($dbg_values > 1);
			$av_pending = $type;
			$type = 'N';

804
		} elsif ($cur =~ /^(sizeof)\s*(\()?/o) {
805
			print "SIZEOF($1)\n" if ($dbg_values > 1);
806
			if (defined $2) {
807
				$av_pending = 'V';
808
809
810
			}
			$type = 'N';

811
		} elsif ($cur =~ /^(if|while|for)\b/o) {
812
			print "COND($1)\n" if ($dbg_values > 1);
813
			$av_pending = 'E';
814
815
			$type = 'N';

816
817
818
819
820
		} elsif ($cur =~/^(case)/o) {
			print "CASE($1)\n" if ($dbg_values > 1);
			$av_pend_colon = 'C';
			$type = 'N';

821
		} elsif ($cur =~/^(return|else|goto|typeof|__typeof__)\b/o) {
822
			print "KEYWORD($1)\n" if ($dbg_values > 1);
823
824
825
			$type = 'N';

		} elsif ($cur =~ /^(\()/o) {
826
			print "PAREN('$1')\n" if ($dbg_values > 1);
827
828
			push(@av_paren_type, $av_pending);
			$av_pending = '_';
829
830
831
			$type = 'N';

		} elsif ($cur =~ /^(\))/o) {
832
833
834
			my $new_type = pop(@av_paren_type);
			if ($new_type ne '_') {
				$type = $new_type;
835
836
				print "PAREN('$1') -> $type\n"
							if ($dbg_values > 1);
837
			} else {
838
				print "PAREN('$1')\n" if ($dbg_values > 1);
839
840
			}

841
		} elsif ($cur =~ /^($Ident)\s*\(/o) {
842
			print "FUNC($1)\n" if ($dbg_values > 1);
843
			$type = 'V';
844
			$av_pending = 'V';
845

846
847
848
849
850
851
852
853
854
		} elsif ($cur =~ /^($Ident\s*):/) {
			if ($type eq 'E') {
				$av_pend_colon = 'L';
			} elsif ($type eq 'T') {
				$av_pend_colon = 'B';
			}
			print "IDENT_COLON($1,$type>$av_pend_colon)\n" if ($dbg_values > 1);
			$type = 'V';

855
		} elsif ($cur =~ /^($Ident|$Constant)/o) {
856
			print "IDENT($1)\n" if ($dbg_values > 1);
857
858
859
			$type = 'V';

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

863
		} elsif ($cur =~/^(;|{|})/) {
864
			print "END($1)\n" if ($dbg_values > 1);
865
			$type = 'E';
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
			$av_pend_colon = 'O';

		} elsif ($cur =~ /^(\?)/o) {
			print "QUESTION($1)\n" if ($dbg_values > 1);
			$type = 'N';

		} elsif ($cur =~ /^(:)/o) {
			print "COLON($1,$av_pend_colon)\n" if ($dbg_values > 1);

			substr($var, length($res), 1, $av_pend_colon);
			if ($av_pend_colon eq 'C' || $av_pend_colon eq 'L') {
				$type = 'E';
			} else {
				$type = 'N';
			}
			$av_pend_colon = 'O';
882

883
		} elsif ($cur =~ /^(;|\[)/o) {
884
			print "CLOSE($1)\n" if ($dbg_values > 1);
885
886
			$type = 'N';

887
		} elsif ($cur =~ /^(-(?![->])|\+(?!\+)|\*|\&\&|\&)/o) {
888
889
890
891
892
893
894
895
896
897
898
899
			my $variant;

			print "OPV($1)\n" if ($dbg_values > 1);
			if ($type eq 'V') {
				$variant = 'B';
			} else {
				$variant = 'U';
			}

			substr($var, length($res), 1, $variant);
			$type = 'N';

900
		} elsif ($cur =~ /^($Operators)/o) {
901
			print "OP($1)\n" if ($dbg_values > 1);
902
903
904
905
906
			if ($1 ne '++' && $1 ne '--') {
				$type = 'N';
			}

		} elsif ($cur =~ /(^.)/o) {
907
			print "C($1)\n" if ($dbg_values > 1);
908
909
910
911
912
		}
		if (defined $1) {
			$cur = substr($cur, length($1));
			$res .= $type x length($1);
		}
913
	}
914

915
	return ($res, $var);
916
917
}

918
sub possible {
919
	my ($possible, $line) = @_;
920

921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
	print "CHECK<$possible> ($line)\n" if ($dbg_possible > 2);
	if ($possible !~ /(?:
		^(?:
			$Modifier|
			$Storage|
			$Type|
			DEFINE_\S+|
			goto|
			return|
			case|
			else|
			asm|__asm__|
			do
		)$|
		^(?:typedef|struct|enum)\b
	    )/x) {
937
938
939
940
941
942
943
		# Check for modifiers.
		$possible =~ s/\s*$Storage\s*//g;
		$possible =~ s/\s*$Sparse\s*//g;
		if ($possible =~ /^\s*$/) {

		} elsif ($possible =~ /\s/) {
			$possible =~ s/\s*$Type\s*//g;
944
945
946
947
			for my $modifier (split(' ', $possible)) {
				warn "MODIFIER: $modifier ($possible) ($line)\n" if ($dbg_possible);
				push(@modifierList, $modifier);
			}
948
949
950
951
952

		} else {
			warn "POSSIBLE: $possible ($line)\n" if ($dbg_possible);
			push(@typeList, $possible);
		}
953
		build_types();
954
955
	} else {
		warn "NOTPOSS: $possible ($line)\n" if ($dbg_possible > 1);
956
957
958
	}
}

959
960
my $prefix = '';

961
sub report {
962
963
964
	if (defined $tst_only && $_[0] !~ /\Q$tst_only\E/) {
		return 0;
	}
965
966
967
968
	my $line = $prefix . $_[0];

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

969
	push(our @report, $line);
970
971

	return 1;
972
973
}
sub report_dump {
974
	our @report;
975
}
976
sub ERROR {
977
978
979
980
	if (report("ERROR: $_[0]\n")) {
		our $clean = 0;
		our $cnt_error++;
	}
981
982
}
sub WARN {
983
984
985
986
	if (report("WARNING: $_[0]\n")) {
		our $clean = 0;
		our $cnt_warn++;
	}
987
988
}
sub CHK {
989
	if ($check && report("CHECK: $_[0]\n")) {
990
991
992
		our $clean = 0;
		our $cnt_chk++;
	}
993
994
}

995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
sub check_absolute_file {
	my ($absolute, $herecurr) = @_;
	my $file = $absolute;

	##print "absolute<$absolute>\n";

	# See if any suffix of this path is a path within the tree.
	while ($file =~ s@^[^/]*/@@) {
		if (-f "$root/$file") {
			##print "file<$file>\n";
			last;
		}
	}
	if (! -f _)  {
		return 0;
	}

	# It is, so see if the prefix is acceptable.
	my $prefix = $absolute;
	substr($prefix, -length($file)) = '';

	##print "prefix<$prefix>\n";
	if ($prefix ne ".../") {
		WARN("use relative pathname instead of absolute in changelog text\n" . $herecurr);
	}
}

1022
1023
1024
1025
1026
sub process {
	my $filename = shift;

	my $linenr=0;
	my $prevline="";
1027
	my $prevrawline="";
1028
	my $stashline="";
1029
	my $stashrawline="";
1030

1031
	my $length;
1032
1033
1034
1035
	my $indent;
	my $previndent=0;
	my $stashindent=0;

1036
	our $clean = 1;
1037
1038
1039
	my $signoff = 0;
	my $is_patch = 0;

1040
	our @report = ();
1041
1042
1043
1044
1045
	our $cnt_lines = 0;
	our $cnt_error = 0;
	our $cnt_warn = 0;
	our $cnt_chk = 0;

1046
1047
1048
1049
1050
1051
	# Trace the real file/line as we go.
	my $realfile = '';
	my $realline = 0;
	my $realcnt = 0;
	my $here = '';
	my $in_comment = 0;
1052
	my $comment_edge = 0;
1053
1054
	my $first_line = 0;

1055
1056
1057
	my $prev_values = 'E';

	# suppression flags
1058
	my %suppress_ifbraces;
1059
	my %suppress_whiletrailers;
1060

1061
	# Pre-scan the patch sanitizing the lines.
1062
	# Pre-scan the patch looking for any __setup documentation.
1063
	#
1064
1065
	my @setup_docs = ();
	my $setup_docs = 0;
1066
1067

	sanitise_line_reset();
1068
1069
	my $line;
	foreach my $rawline (@rawlines) {
1070
1071
		$linenr++;
		$line = $rawline;
1072

1073
		if ($rawline=~/^\+\+\+\s+(\S+)/) {
1074
1075
1076
1077
			$setup_docs = 0;
			if ($1 =~ m@Documentation/kernel-parameters.txt$@) {
				$setup_docs = 1;
			}
1078
1079
1080
1081
1082
1083
1084
1085
1086
			#next;
		}
		if ($rawline=~/^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@/) {
			$realline=$1-1;
			if (defined $2) {
				$realcnt=$3+1;
			} else {
				$realcnt=1+1;
			}
1087
			$in_comment = 0;
1088
1089
1090
1091
1092
1093

			# 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;
1094
1095
1096
1097
1098
1099
			my $cnt = $realcnt;
			for (my $ln = $linenr + 1; $cnt > 0; $ln++) {
				next if (defined $rawlines[$ln - 1] &&
					 $rawlines[$ln - 1] =~ /^-/);
				$cnt--;
				#print "RAW<$rawlines[$ln - 1]>\n";
1100
1101
				last if (!defined $rawlines[$ln - 1]);
				($edge) = ($rawlines[$ln - 1] =~ m@(/\*|\*/)@);
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
				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 &&
1112
			    $rawlines[$linenr] =~ m@^.\s*(?:\*\*+| \*)(?:\s|$)@)
1113
1114
1115
1116
1117
1118
1119
			{
				$in_comment = 1;
			}

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

1120
		} elsif ($realcnt && $rawline =~ /^(?:\+| |$)/) {
1121
			# Standardise the strings and chars within the input to
1122
			# simplify matching -- only bother with positive lines.
1123
			$line = sanitise_line($rawline);
1124
		}
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
		push(@lines, $line);

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

		#print "==>$rawline\n";
		#print "-->$line\n";
1135
1136
1137
1138
1139
1140

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

1141
1142
	$prefix = '';

1143
1144
	$realcnt = 0;
	$linenr = 0;
1145
1146
1147
	foreach my $line (@lines) {
		$linenr++;

1148
		my $rawline = $rawlines[$linenr - 1];
1149
		my $hunk_line = ($realcnt != 0);
1150

1151
#extract the line range in the file after the patch is applied
1152
		if ($line=~/^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@/) {
1153
			$is_patch = 1;
1154
			$first_line = $linenr + 1;
1155
1156
1157
1158
1159
1160
			$realline=$1-1;
			if (defined $2) {
				$realcnt=$3+1;
			} else {
				$realcnt=1+1;
			}
1161
			annotate_reset();
1162
1163
			$prev_values = 'E';

1164
			%suppress_ifbraces = ();
1165
			%suppress_whiletrailers = ();
1166
1167
			next;

1168
1169
1170
# 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.
1171
		} elsif ($line =~ /^( |\+|$)/) {
1172
			$realline++;
1173
			$realcnt-- if ($realcnt != 0);
1174

1175
			# Measure the line length and indent.
1176
			($length, $indent) = line_stats($rawline);
1177
1178
1179
1180

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

1183
			#warn "line<$line>\n";
1184

1185
1186
		} elsif ($realcnt == 1) {
			$realcnt--;
1187
1188
1189
		}

#make up the handle for any error we report on this line
Andy Whitcroft's avatar