checkpatch.pl 25.4 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.07';
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
22
23
24
25
GetOptions(
	'q|quiet'	=> \$quiet,
	'tree!'		=> \$tree,
	'signoff!'	=> \$chk_signoff,
	'patch!'	=> \$chk_patch,
26
	'test-type!'	=> \$tst_type,
27
28
29
30
31
) or exit;

my $exit = 0;

if ($#ARGV < 0) {
32
	print "usage: $P [options] patchfile\n";
33
34
35
36
37
38
39
40
41
42
43
	print "version: $V\n";
	print "options: -q           => quiet\n";
	print "         --no-tree    => run without a kernel tree\n";
	exit(1);
}

if ($tree && !top_of_kernel_tree()) {
	print "Must be run from the top-level dir. of a kernel tree\n";
	exit(2);
}

44
45
my @dep_includes = ();
my @dep_functions = ();
46
47
48
49
50
51
52
my $removal = 'Documentation/feature-removal-schedule.txt';
if ($tree && -f $removal) {
	open(REMOVE, "<$removal") || die "$P: $removal: open failed - $!\n";
	while (<REMOVE>) {
		if (/^Files:\s+(.*\S)/) {
			for my $file (split(/[, ]+/, $1)) {
				if ($file =~ m@include/(.*)@) {
53
					push(@dep_includes, $1);
54
55
				}
			}
56
57
58
59
60

		} elsif (/^Funcs:\s+(.*\S)/) {
			for my $func (split(/[, ]+/, $1)) {
				push(@dep_functions, $func);
			}
61
62
63
64
		}
	}
}

65
my @rawlines = ();
66
67
while (<>) {
	chomp;
68
	push(@rawlines, $_);
69
	if (eof(ARGV)) {
70
		if (!process($ARGV, @rawlines)) {
71
72
			$exit = 1;
		}
73
		@rawlines = ();
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
	}
}

exit($exit);

sub top_of_kernel_tree {
	if ((-f "COPYING") && (-f "CREDITS") && (-f "Kbuild") &&
	    (-f "MAINTAINERS") && (-f "Makefile") && (-f "README") &&
	    (-d "Documentation") && (-d "arch") && (-d "include") &&
	    (-d "drivers") && (-d "fs") && (-d "init") && (-d "ipc") &&
	    (-d "kernel") && (-d "lib") && (-d "scripts")) {
		return 1;
	}
	return 0;
}

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

111
112
113
114
115
116
117
118
119
120
121
122
123
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));
}

124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
sub sanitise_line {
	my ($line) = @_;

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

	my $quote = '';

	foreach my $c (split(//, $line)) {
		if ($l ne "\\" && ($c eq "'" || $c eq '"')) {
			if ($quote eq '') {
				$quote = $c;
				$res .= $c;
				$l = $c;
				next;
			} elsif ($quote eq $c) {
				$quote = '';
			}
		}
		if ($quote && $c ne "\t") {
			$res .= "X";
		} else {
			$res .= $c;
		}

		$l = $c;
	}

	return $res;
}

155
sub ctx_block_get {
156
	my ($linenr, $remain, $outer, $open, $close) = @_;
157
158
159
160
161
162
163
	my $line;
	my $start = $linenr - 1;
	my $blk = '';
	my @o;
	my @c;
	my @res = ();

164
165
166
167
168
	for ($line = $start; $remain > 0; $line++) {
		next if ($rawlines[$line] =~ /^-/);
		$remain--;

		$blk .= $rawlines[$line];
169

170
171
		@o = ($blk =~ /$open/g);
		@c = ($blk =~ /$close/g);
172
173

		if (!$outer || (scalar(@o) - scalar(@c)) == 1) {
174
			push(@res, $rawlines[$line]);
175
176
177
178
179
180
181
182
183
184
		}

		last if (scalar(@o) == scalar(@c));
	}

	return @res;
}
sub ctx_block_outer {
	my ($linenr, $remain) = @_;

185
	return ctx_block_get($linenr, $remain, 1, '\{', '\}');
186
187
188
189
}
sub ctx_block {
	my ($linenr, $remain) = @_;

190
191
192
193
194
195
	return ctx_block_get($linenr, $remain, 0, '\{', '\}');
}
sub ctx_statement {
	my ($linenr, $remain) = @_;

	return ctx_block_get($linenr, $remain, 0, '\(', '\)');
196
197
198
199
200
201
}

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

	# Catch a comment on the end of the line itself.
202
	my ($current_comment) = ($rawlines[$end_line - 1] =~ m@.*(/\*.*\*/)\s*$@);
203
204
205
206
207
208
209
	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++) {
210
211
		my $line = $rawlines[$linenr - 1];
		#warn "           $line\n";
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
		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);

234
	##print "LINE: $rawlines[$end_line - 1 ]\n";
235
236
237
238
239
	##print "CMMT: $cmt\n";

	return ($cmt ne '');
}

240
241
242
243
244
245
246
247
248
sub cat_vet {
	my ($vet) = @_;

	$vet =~ s/\t/^I/;
	$vet =~ s/$/\$/;

	return $vet;
}

249
250
251
252
253
254
255
256
257
258
259
260
261
sub ERROR {
	print "ERROR: $_[0]\n";
	our $clean = 0;
}
sub WARN {
	print "WARNING: $_[0]\n";
	our $clean = 0;
}
sub CHK {
	print "CHECK: $_[0]\n";
	our $clean = 0;
}

262
263
264
265
266
267
268
269
sub process {
	my $filename = shift;
	my @lines = @_;

	my $linenr=0;
	my $prevline="";
	my $stashline="";

270
	my $length;
271
272
273
274
	my $indent;
	my $previndent=0;
	my $stashindent=0;

275
	our $clean = 1;
276
277
278
279
280
281
282
283
284
285
286
	my $signoff = 0;
	my $is_patch = 0;

	# Trace the real file/line as we go.
	my $realfile = '';
	my $realline = 0;
	my $realcnt = 0;
	my $here = '';
	my $in_comment = 0;
	my $first_line = 0;

287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
	my $Ident	= qr{[A-Za-z\d_]+};
	my $Storage	= qr{extern|static};
	my $Sparse	= qr{__user|__kernel|__force|__iomem};
	my $NonptrType	= qr{
				\b
				(?:const\s+)?
				(?:unsigned\s+)?
				(?:
					void|
					char|
					short|
					int|
					long|
					unsigned|
					float|
					double|
					long\s+int|
					long\s+long|
					long\s+long\s+int|
306
307
					u8|u16|u32|u64|
					s8|s16|s32|s64|
308
309
					struct\s+$Ident|
					union\s+$Ident|
310
					enum\s+$Ident|
311
312
313
314
315
316
317
318
319
320
321
					${Ident}_t
				)
				(?:\s+$Sparse)*
				\b
			  }x;
	my $Type	= qr{
				\b$NonptrType\b
				(?:\s*\*+\s*const|\s*\*+)?
			  }x;
	my $Declare	= qr{(?:$Storage\s+)?$Type};
	my $Attribute	= qr{__read_mostly|__init|__initdata};
322

323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
	# Pre-scan the patch looking for any __setup documentation.
	my @setup_docs = ();
	my $setup_docs = 0;
	foreach my $line (@lines) {
		if ($line=~/^\+\+\+\s+(\S+)/) {
			$setup_docs = 0;
			if ($1 =~ m@Documentation/kernel-parameters.txt$@) {
				$setup_docs = 1;
			}
			next;
		}

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

340
341
342
	foreach my $line (@lines) {
		$linenr++;

343
344
		my $rawline = $line;

345
346
347
#extract the filename as it passes
		if ($line=~/^\+\+\+\s+(\S+)/) {
			$realfile=$1;
348
			$realfile =~ s@^[^/]*/@@;
349
350
351
352
353
354
			$in_comment = 0;
			next;
		}
#extract the line range in the file after the patch is applied
		if ($line=~/^\@\@ -\d+,\d+ \+(\d+)(,(\d+))? \@\@/) {
			$is_patch = 1;
355
			$first_line = $linenr + 1;
356
357
358
359
360
361
362
363
364
365
			$in_comment = 0;
			$realline=$1-1;
			if (defined $2) {
				$realcnt=$3+1;
			} else {
				$realcnt=1+1;
			}
			next;
		}

366
367
368
369
# track the line number as we move through the hunk, note that
# new versions of GNU diff omit the leading space on completely
# blank context lines so we need to count that too.
		if ($line =~ /^( |\+|$)/) {
370
			$realline++;
371
			$realcnt-- if ($realcnt != 0);
372
373
374
375
376
377
378
379

			# track any sort of multi-line comment.  Obviously if
			# the added text or context do not include the whole
			# comment we will not see it. Such is life.
			#
			# 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.
380
			if ($linenr == $first_line and $line =~ m@^.\s*\*@) {
381
382
383
384
385
386
387
388
389
				$in_comment = 1;
			}
			if ($line =~ m@/\*@) {
				$in_comment = 1;
			}
			if ($line =~ m@\*/@) {
				$in_comment = 0;
			}

390
391
			# Measure the line length and indent.
			($length, $indent) = line_stats($line);
392
393
394
395

			# Track the previous line.
			($prevline, $stashline) = ($stashline, $line);
			($previndent, $stashindent) = ($stashindent, $indent);
396
397
		} elsif ($realcnt == 1) {
			$realcnt--;
398
399
400
		}

#make up the handle for any error we report on this line
401
402
		$here = "#$linenr: ";
		$here .= "FILE: $realfile:$realline:" if ($realcnt != 0);
403

404
		my $hereline = "$here\n$line\n";
405
406
		my $herecurr = "$here\n$line\n";
		my $hereprev = "$here\n$prevline\n$line\n";
407
408

#check the patch for a signoff:
409
		if ($line =~ /^\s*signed-off-by:/i) {
410
411
			# This is a signoff, if ugly, so do not double report.
			$signoff++;
412
			if (!($line =~ /^\s*Signed-off-by:/)) {
413
414
				WARN("Signed-off-by: is the preferred form\n" .
					$herecurr);
415
416
			}
			if ($line =~ /^\s*signed-off-by:\S/i) {
417
418
				WARN("need space after Signed-off-by:\n" .
					$herecurr);
419
420
421
			}
		}

422
423
# Check for wrappage within a valid hunk of the file
		if ($realcnt != 0 && $line !~ m{^(?:\+|-| |$)}) {
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
			ERROR("patch seems to be corrupt (line wrapped?)\n" .
				$herecurr);
		}

# UTF-8 regex found at http://www.w3.org/International/questions/qa-forms-utf-8.en.php
		if (($realfile =~ /^$/ || $line =~ /^\+/) &&
		     !($line =~ m/^(
				[\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 )) {
			ERROR("Invalid UTF-8\n" . $herecurr);
441
442
443
444
		}

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

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

#trailing whitespace
450
		if ($line =~ /^\+.*\S\s+$/ || $line =~ /^\+\s+$/) {
451
452
			my $herevet = "$here\n" . cat_vet($line) . "\n";
			ERROR("trailing whitespace\n" . $herevet);
453
454
		}
#80 column limit
455
		if ($line =~ /^\+/ && !($prevline=~/\/\*\*/) && $length > 80) {
456
			WARN("line over 80 characters\n" . $herecurr);
457
458
459
460
461
462
463
464
		}

# 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.
		if ($line=~/^\+\s* \t\s*\S/ or $line=~/^\+\s*        \s*/) {
465
466
			my $herevet = "$here\n" . cat_vet($line) . "\n";
			ERROR("use tabs not spaces\n" . $herevet);
467
468
469
470
471
472
473
474
		}

		#
		# The rest of our checks refer specifically to C style
		# only apply those _outside_ comments.
		#
		next if ($in_comment);

475
# Remove comments from the line before processing.
476
477
478
479
		$line =~ s@/\*.*\*/@@g;
		$line =~ s@/\*.*@@;
		$line =~ s@.*\*/@@;

480
481
482
483
484
485
# Standardise the strings and chars within the input to simplify matching.
		$line = sanitise_line($line);

#
# Checks which may be anchored in the context.
#
486

487
488
# Check for switch () and associated case and default
# statements should be at the same indent.
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
		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 '') {
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
				ERROR("switch and case should be at the same indent\n$hereline\n$err\n");
			}
		}

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

			while ($ctx_cnt > 0 && $lines[$ctx_ln - 1] =~ /^-/) {
				$ctx_ln++;
				$ctx_cnt--;
			}
			##warn "line<$line>\nctx<$ctx>\nnext<$lines[$ctx_ln - 1]>";

			if ($ctx !~ /{\s*/ && $ctx_cnt > 0 && $lines[$ctx_ln - 1] =~ /^\+\s*{/) {
				ERROR("That { should be on the previous line\n" .
					"$here\n$ctx\n$lines[$ctx_ln - 1]");
526
527
528
529
530
531
			}
		}

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

532
533
# TEST: allow direct testing of the type matcher.
		if ($tst_type && $line =~ /^.$Declare$/) {
534
			ERROR("TEST: is type $Declare\n" . $herecurr);
535
536
537
538
539
540
541
542
543
544
545
			next;
		}

#
# Checks which are anchored on the added line.
#

# check for malformed paths in #include statements (uses RAW line)
		if ($rawline =~ m{^.#\s*include\s+[<"](.*)[">]}) {
			my $path = $1;
			if ($path =~ m{//}) {
546
547
				ERROR("malformed #include filename\n" .
					$herecurr);
548
549
550
551
552
			}
			# Sanitise this special form of string.
			$path = 'X' x length($path);
			$line =~ s{\<.*\>}{<$path>};
		}
553

554
# no C99 // comments
555
		if ($line =~ m{//}) {
556
			ERROR("do not use C99 // comments\n" . $herecurr);
557
		}
558
		# Remove C99 comments.
559
560
561
		$line =~ s@//.*@@;

#EXPORT_SYMBOL should immediately follow its function closing }.
562
563
564
		if (($line =~ /EXPORT_SYMBOL.*\((.*)\)/) ||
		    ($line =~ /EXPORT_UNUSED_SYMBOL.*\((.*)\)/)) {
			my $name = $1;
565
566
			if (($prevline !~ /^}/) &&
			   ($prevline !~ /^\+}/) &&
567
568
			   ($prevline !~ /^ }/) &&
			   ($prevline !~ /\s$name(?:\s+$Attribute)?\s*(?:;|=)/)) {
569
				WARN("EXPORT_SYMBOL(foo); should immediately follow its function/variable\n" . $herecurr);
570
571
572
			}
		}

573
# check for static initialisers.
574
		if ($line=~/\s*static\s.*=\s+(0|NULL);/) {
575
576
			ERROR("do not initialise statics to 0 or NULL\n" .
				$herecurr);
577
578
		}

579
580
581
# check for new typedefs, only function parameters and sparse annotations
# make sense.
		if ($line =~ /\btypedef\s/ &&
582
		    $line !~ /\btypedef\s+$Type\s+\(\s*\*$Ident\s*\)\s*\(/ &&
583
		    $line !~ /\b__bitwise(?:__|)\b/) {
584
			WARN("do not add new typedefs\n" . $herecurr);
585
586
587
		}

# * goes on variable not on type
588
		if ($line =~ m{\($NonptrType(\*+)(?:\s+const)?\)}) {
589
590
			ERROR("\"(foo$1)\" should be \"(foo $1)\"\n" .
				$herecurr);
591
592

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

		} elsif ($line =~ m{$NonptrType(\*+)(?:\s+const)?\s+[A-Za-z\d_]+}) {
597
598
			ERROR("\"foo$1 bar\" should be \"foo $1bar\"\n" .
				$herecurr);
599
600

		} elsif ($line =~ m{$NonptrType\s+(\*+)(?!\s+const)\s+[A-Za-z\d_]+}) {
601
602
			ERROR("\"foo $1 bar\" should be \"foo $1bar\"\n" .
				$herecurr);
603
604
605
606
607
608
609
610
611
		}

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

612
613
614
615
616
# printk should use KERN_* levels.  Note that follow on printk's on the
# same line do not need a level, so we use the current block context
# to try and find and validate the current printk.  In summary the current
# printk includes all preceeding printk's which have no newline on the end.
# we assume the first bad printk is the one to report.
617
		if ($line =~ /\bprintk\((?!KERN_)/) {
618
619
620
621
622
623
624
625
626
627
628
629
630
			my $ok = 0;
			for (my $ln = $linenr - 1; $ln >= $first_line; $ln--) {
				#print "CHECK<$lines[$ln - 1]\n";
				# we have a preceeding printk if it ends
				# with "\n" ignore it, else it is to blame
				if ($lines[$ln - 1] =~ m{\bprintk\(}) {
					if ($rawlines[$ln - 1] !~ m{\\n"}) {
						$ok = 1;
					}
					last;
				}
			}
			if ($ok == 0) {
631
				WARN("printk() should include KERN_ facility level\n" . $herecurr);
632
			}
633
634
		}

635
636
# function brace can't be on same line, except for #defines of do while,
# or if closed on same line
637
		if (($line=~/$Type\s*[A-Za-z\d_]+\(.*\).* {/) and
638
		    !($line=~/\#define.*do\s{/) and !($line=~/}/)) {
639
			ERROR("open brace '{' following function declarations go on the next line\n" . $herecurr);
640
		}
641
642

# Check operator spacing.
643
644
645
		# Note we expand the line with the leading + as the real
		# line will be displayed with the leading + and the tabs
		# will therefore also expand that way.
646
		my $opline = $line;
647
		$opline = expand_tabs($opline);
648
		$opline =~ s/^./ /;
649
650
		if (!($line=~/\#\s*include/)) {
			my @elements = split(/(<<=|>>=|<=|>=|==|!=|\+=|-=|\*=|\/=|%=|\^=|\|=|&=|->|<<|>>|<|>|=|!|~|&&|\|\||,|\^|\+\+|--|;|&|\||\+|-|\*|\/\/|\/)/, $opline);
651
			my $off = 0;
652
			for (my $n = 0; $n < $#elements; $n += 2) {
653
654
655
656
657
658
659
660
661
				$off += length($elements[$n]);

				my $a = '';
				$a = 'V' if ($elements[$n] ne '');
				$a = 'W' if ($elements[$n] =~ /\s$/);
				$a = 'B' if ($elements[$n] =~ /(\[|\()$/);
				$a = 'O' if ($elements[$n] eq '');
				$a = 'E' if ($elements[$n] eq '' && $n == 0);

662
				my $op = $elements[$n + 1];
663
664

				my $c = '';
665
				if (defined $elements[$n + 2]) {
666
667
668
669
670
671
					$c = 'V' if ($elements[$n + 2] ne '');
					$c = 'W' if ($elements[$n + 2] =~ /^\s/);
					$c = 'B' if ($elements[$n + 2] =~ /^(\)|\]|;)/);
					$c = 'O' if ($elements[$n + 2] eq '');
				} else {
					$c = 'E';
672
673
				}

674
				# Pick up the preceeding and succeeding characters.
675
				my $ca = substr($opline, 0, $off);
676
				my $cc = '';
677
				if (length($opline) >= ($off + length($elements[$n + 1]))) {
678
					$cc = substr($opline, $off + length($elements[$n + 1]));
679
				}
680
				my $cb = "$ca$;$cc";
681

682
683
684
685
686
				my $ctx = "${a}x${c}";

				my $at = "(ctx:$ctx)";

				my $ptr = (" " x $off) . "^";
687
				my $hereptr = "$hereline$ptr\n";
688
689
690

				##print "<$s1:$op:$s2> <$elements[$n]:$elements[$n + 1]:$elements[$n + 2]>\n";

691
692
				# ; should have either the end of line or a space or \ after it
				if ($op eq ';') {
693
694
695
					if ($ctx !~ /.x[WEB]/ && $cc !~ /^\\/ &&
					    $cc !~ /^;/) {
						ERROR("need space after that '$op' $at\n" . $hereptr);
696
697
698
699
					}

				# // is a comment
				} elsif ($op eq '//') {
700
701
702

				# -> should have no spaces
				} elsif ($op eq '->') {
703
					if ($ctx =~ /Wx.|.xW/) {
704
						ERROR("no spaces around that '$op' $at\n" . $hereptr);
705
706
707
708
					}

				# , must have a space on the right.
				} elsif ($op eq ',') {
709
					if ($ctx !~ /.xW|.xE/ && $cc !~ /^}/) {
710
						ERROR("need space after that '$op' $at\n" . $hereptr);
711
712
713
714
					}

				# unary ! and unary ~ are allowed no space on the right
				} elsif ($op eq '!' or $op eq '~') {
715
					if ($ctx !~ /[WOEB]x./) {
716
						ERROR("need space before that '$op' $at\n" . $hereptr);
717
					}
718
					if ($ctx =~ /.xW/) {
719
						ERROR("no space after that '$op' $at\n" . $hereptr);
720
721
722
723
					}

				# unary ++ and unary -- are allowed no space on one side.
				} elsif ($op eq '++' or $op eq '--') {
724
					if ($ctx !~ /[WOB]x[^W]/ && $ctx !~ /[^W]x[WOBE]/) {
725
						ERROR("need space one side of that '$op' $at\n" . $hereptr);
726
					}
727
					if ($ctx =~ /Wx./ && $cc =~ /^;/) {
728
						ERROR("no space before that '$op' $at\n" . $hereptr);
729
					}
730
731
732
733
734
735
736
737
738
739
740
741
742

				# & is both unary and binary
				# unary:
				# 	a &b
				# binary (consistent spacing):
				#	a&b		OK
				#	a & b		OK
				#
				# boiling down to: if there is a space on the right then there
				# should be one on the left.
				#
				# - is the same
				#
743
				} elsif ($op eq '&' or $op eq '-') {
744
					if ($ctx !~ /VxV|[EW]x[WE]|[EWB]x[VO]/) {
745
						ERROR("need space before that '$op' $at\n" . $hereptr);
746
747
					}

748
749
750
751
752
				# * is the same as & only adding:
				# type:
				# 	(foo *)
				#	(foo **)
				#
753
				} elsif ($op eq '*') {
754
755
756
					if ($ca !~ /$Type$/ && $cb !~ /(\*$;|$;\*)/ &&
					    $ctx !~ /VxV|[EW]x[WE]|[EWB]x[VO]|OxV|WxB|BxB/) {
						ERROR("need space before that '$op' $at\n" . $hereptr);
757
758
759
760
761
762
					}

				# << and >> may either have or not have spaces both sides
				} elsif ($op eq '<<' or $op eq '>>' or $op eq '+' or $op eq '/' or
					 $op eq '^' or $op eq '|')
				{
763
					if ($ctx !~ /VxV|WxW|VxE|WxE/) {
764
765
						ERROR("need consistent spacing around '$op' $at\n" .
							$hereptr);
766
767
768
					}

				# All the others need spaces both sides.
769
				} elsif ($ctx !~ /[EW]x[WE]/) {
770
					ERROR("need spaces around that '$op' $at\n" . $hereptr);
771
				}
772
				$off += length($elements[$n + 1]);
773
774
775
776
			}
		}

#need space before brace following if, while, etc
777
778
779
780
781
782
783
784
		if ($line =~ /\(.*\){/ || $line =~ /do{/) {
			ERROR("need a space before the open brace '{'\n" . $herecurr);
		}

# closing brace should have a space following it when it has anything
# on the line
		if ($line =~ /}(?!(?:,|;|\)))\S/) {
			ERROR("need a space after that close brace '}'\n" . $herecurr);
785
786
787
		}

#goto labels aren't indented, allow a single space however
788
		if ($line=~/^.\s+[A-Za-z\d_]+:(?![0-9]+)/ and
789
		   !($line=~/^. [A-Za-z\d_]+:/) and !($line=~/^.\s+default:/)) {
790
			WARN("labels should not be indented\n" . $herecurr);
791
792
793
		}

# Need a space before open parenthesis after if, while etc
794
		if ($line=~/\b(if|while|for|switch)\(/) {
795
			ERROR("need a space before the open parenthesis '('\n" . $herecurr);
796
797
798
		}

# Check for illegal assignment in if conditional.
799
		if ($line=~/\bif\s*\(.*[^<>!=]=[^=].*\)/) {
800
			#next if ($line=~/\".*\Q$op\E.*\"/ or $line=~/\'\Q$op\E\'/);
801
			ERROR("do not use assignment in if condition\n" . $herecurr);
802
803
804
805
806
807
		}

		# Check for }<nl>else {, these must be at the same
		# indent level to be relevant to each other.
		if ($prevline=~/}\s*$/ and $line=~/^.\s*else\s*/ and
						$previndent == $indent) {
808
			ERROR("else should follow close brace '}'\n" . $hereprev);
809
810
811
812
813
814
815
816
817
818
819
		}

#studly caps, commented out until figure out how to distinguish between use of existing and adding new
#		if (($line=~/[\w_][a-z\d]+[A-Z]/) and !($line=~/print/)) {
#		    print "No studly caps, use _\n";
#		    print "$herecurr";
#		    $clean = 0;
#		}

#no spaces allowed after \ in define
		if ($line=~/\#define.*\\\s$/) {
820
			WARN("Whitepspace after \\ makes next lines useless\n" . $herecurr);
821
822
		}

823
824
#warn if <asm/foo.h> is #included and <linux/foo.h> is available (uses RAW line)
		if ($tree && $rawline =~ m{^.\#\s*include\s*\<asm\/(.*)\.h\>}) {
825
826
			my $checkfile = "include/linux/$1.h";
			if (-f $checkfile) {
827
828
				CHK("Use #include <linux/$1.h> instead of <asm/$1.h>\n" .
					$herecurr);
829
830
831
			}
		}

832
833
# if and else should not have general statements after it
		if ($line =~ /^.\s*(?:}\s*)?else\b(.*)/ &&
834
835
		    $1 !~ /^\s*(?:\sif|{|\\|$)/) {
			ERROR("trailing statements should be on next line\n" . $herecurr);
836
837
		}

838
839
840
841
842
843
844
845
846
847
# multi-statement macros should be enclosed in a do while loop, grab the
# first statement and ensure its the whole macro if its not enclosed
# in a known goot container
		if (($prevline=~/\#define.*\\/) and
		   !($prevline=~/do\s+{/) and !($prevline=~/\(\{/) and
		   !($line=~/do.*{/) and !($line=~/\(\{/) and
		   !($line=~/^.\s*$Declare\s/)) {
			# Grab the first statement, if that is the entire macro
			# its ok.  This may start either on the #define line
			# or the one below.
848
849
			my $ln = $linenr;
			my $cnt = $realcnt;
850

851
852
853
854
855
			# If the macro starts on the define line start there.
			if ($prevline !~ m{^.#\s*define\s*$Ident(?:\([^\)]*\))?\s*\\\s*$}) {
				$ln--;
				$cnt++;
			}
856
857
858
859
860
861
862
863
864
865
			my @ctx = ctx_statement($ln, $cnt);
			my $ctx_ln = $ln + $#ctx + 1;
			my $ctx = join("\n", @ctx);

			# Pull in any empty extension lines.
			while ($ctx =~ /\\$/ &&
			       $lines[$ctx_ln - 1] =~ /^.\s*(?:\\)?$/) {
				$ctx .= $lines[$ctx_ln - 1];
				$ctx_ln++;
			}
866
867
868

			if ($ctx =~ /\\$/) {
				if ($ctx =~ /;/) {
869
					ERROR("Macros with multiple statements should be enclosed in a do - while loop\n" . "$here\n$ctx\n");
870
				} else {
871
					ERROR("Macros with complex values should be enclosed in parenthesis\n" . "$here\n$ctx\n");
872
				}
873
			}
874
875
		}

876
# don't include deprecated include files (uses RAW line)
877
		for my $inc (@dep_includes) {
878
			if ($rawline =~ m@\#\s*include\s*\<$inc>@) {
879
				ERROR("Don't use <$inc>: see Documentation/feature-removal-schedule.txt\n" . $herecurr);
880
881
882
			}
		}

883
884
# don't use deprecated functions
		for my $func (@dep_functions) {
885
			if ($line =~ /\b$func\b/) {
886
				ERROR("Don't use $func(): see Documentation/feature-removal-schedule.txt\n" . $herecurr);
887
888
889
890
			}
		}

# no volatiles please
891
		if ($line =~ /\bvolatile\b/ && $line !~ /\basm\s+volatile\b/) {
892
			WARN("Use of volatile is usually wrong: see Documentation/volatile-considered-harmful.txt\n" . $herecurr);
893
894
		}

895
896
# warn about #if 0
		if ($line =~ /^.#\s*if\s+0\b/) {
897
898
			CHK("if this code is redundant consider removing it\n" .
				$herecurr);
899
900
		}

901
902
903
904
905
906
907
# warn about #ifdefs in C files
#		if ($line =~ /^.#\s*if(|n)def/ && ($realfile =~ /\.c$/)) {
#			print "#ifdef in C files should be avoided\n";
#			print "$herecurr";
#			$clean = 0;
#		}

908
909
910
911
# check for spinlock_t definitions without a comment.
		if ($line =~ /^.\s*(struct\s+mutex|spinlock_t)\s+\S+;/) {
			my $which = $1;
			if (!ctx_has_comment($first_line, $linenr)) {
912
				CHK("$1 definition without comment\n" . $herecurr);
913
914
915
916
917
			}
		}
# check for memory barriers without a comment.
		if ($line =~ /\b(mb|rmb|wmb|read_barrier_depends|smp_mb|smp_rmb|smp_wmb|smp_read_barrier_depends)\(/) {
			if (!ctx_has_comment($first_line, $linenr)) {
918
				CHK("memory barrier without comment\n" . $herecurr);
919
920
921
922
			}
		}
# check of hardware specific defines
		if ($line =~ m@^.#\s*if.*\b(__i386__|__powerpc64__|__sun__|__s390x__)\b@) {
923
			CHK("architecture specific defines should be avoided\n" .  $herecurr);
924
		}
925

926
927
# check the location of the inline attribute, that it is between
# storage class and type.
928
929
		if ($line =~ /$Type\s+(?:inline|__always_inline)\b/ ||
		    $line =~ /\b(?:inline|always_inline)\s+$Storage/) {
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
			ERROR("inline keyword should sit between storage class and type\n" . $herecurr);
		}

# check for new externs in .c files.
		if ($line =~ /^.\s*extern\s/ && ($realfile =~ /\.c$/)) {
			WARN("externs should be avoided in .c files\n" .  $herecurr);
		}

# checks for new __setup's
		if ($rawline =~ /\b__setup\("([^"]*)"/) {
			my $name = $1;

			if (!grep(/$name/, @setup_docs)) {
				CHK("__setup appears un-documented -- check Documentation/kernel-parameters.txt\n" . $herecurr);
			}
945
		}
946
947
948
	}

	if ($chk_patch && !$is_patch) {
949
		ERROR("Does not appear to be a unified-diff format patch\n");
950
951
	}
	if ($is_patch && $chk_signoff && $signoff == 0) {
952
		ERROR("Missing Signed-off-by: line(s)\n");
953
954
955
956
957
958
959
960
961
962
963
964
	}

	if ($clean == 1 && $quiet == 0) {
		print "Your patch has no obvious style problems and is ready for submission.\n"
	}
	if ($clean == 0 && $quiet == 0) {
		print "Your patch has style problems, please review.  If any of these errors\n";
		print "are false positives report them to the maintainer, see\n";
		print "CHECKPATCH in MAINTAINERS.\n";
	}
	return $clean;
}