checkpatch.pl 24.8 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.06';
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
249
250
251
252
253
254
255
256
sub cat_vet {
	my ($vet) = @_;

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

	return $vet;
}

sub process {
	my $filename = shift;
	my @lines = @_;

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

257
	my $length;
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
	my $indent;
	my $previndent=0;
	my $stashindent=0;

	my $clean = 1;
	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;

274
275
276
277
278
279
280
281
282
283
284
285
286
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|
					struct\s+$Ident|
					union\s+$Ident|
					${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};
306

307
308
309
	foreach my $line (@lines) {
		$linenr++;

310
311
		my $rawline = $line;

312
313
314
#extract the filename as it passes
		if ($line=~/^\+\+\+\s+(\S+)/) {
			$realfile=$1;
315
			$realfile =~ s@^[^/]*/@@;
316
317
318
319
320
321
			$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;
322
			$first_line = $linenr + 1;
323
324
325
326
327
328
329
330
331
332
			$in_comment = 0;
			$realline=$1-1;
			if (defined $2) {
				$realcnt=$3+1;
			} else {
				$realcnt=1+1;
			}
			next;
		}

333
334
335
336
# 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 =~ /^( |\+|$)/) {
337
			$realline++;
338
			$realcnt-- if ($realcnt != 0);
339
340
341
342
343
344
345
346

			# 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.
347
			if ($linenr == $first_line and $line =~ m@^.\s*\*@) {
348
349
350
351
352
353
354
355
356
				$in_comment = 1;
			}
			if ($line =~ m@/\*@) {
				$in_comment = 1;
			}
			if ($line =~ m@\*/@) {
				$in_comment = 0;
			}

357
358
			# Measure the line length and indent.
			($length, $indent) = line_stats($line);
359
360
361
362

			# Track the previous line.
			($prevline, $stashline) = ($stashline, $line);
			($previndent, $stashindent) = ($stashindent, $indent);
363
364
		} elsif ($realcnt == 1) {
			$realcnt--;
365
366
367
		}

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

371
		my $hereline = "$here\n$line\n";
372
373
374
375
		my $herecurr = "$here\n$line\n\n";
		my $hereprev = "$here\n$prevline\n$line\n\n";

#check the patch for a signoff:
376
		if ($line =~ /^\s*signed-off-by:/i) {
377
378
			# This is a signoff, if ugly, so do not double report.
			$signoff++;
379
			if (!($line =~ /^\s*Signed-off-by:/)) {
380
				print "Signed-off-by: is the preferred form\n";
381
382
383
384
385
386
387
388
389
390
				print "$herecurr";
				$clean = 0;
			}
			if ($line =~ /^\s*signed-off-by:\S/i) {
				print "need space after Signed-off-by:\n";
				print "$herecurr";
				$clean = 0;
			}
		}

391
392
393
394
395
396
397
398
399
# Check for wrappage within a valid hunk of the file
		if ($realcnt != 0 && $line !~ m{^(?:\+|-| |$)}) {
			print "patch seems to be corrupt (line wrapped?) [$realcnt]\n";
			print "$herecurr";
			$clean = 0;
		}

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

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

#trailing whitespace
405
		if ($line =~ /^\+.*\S\s+$/ || $line =~ /^\+\s+$/) {
406
407
408
409
410
411
			my $herevet = "$here\n" . cat_vet($line) . "\n\n";
			print "trailing whitespace\n";
			print "$herevet";
			$clean = 0;
		}
#80 column limit
412
		if ($line =~ /^\+/ && !($prevline=~/\/\*\*/) && $length > 80) {
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
			print "line over 80 characters\n";
			print "$herecurr";
			$clean = 0;
		}

# 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*/) {
			my $herevet = "$here\n" . cat_vet($line) . "\n\n";
			print "use tabs not spaces\n";
			print "$herevet";
			$clean = 0;
		}

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

436
# Remove comments from the line before processing.
437
438
439
440
		$line =~ s@/\*.*\*/@@g;
		$line =~ s@/\*.*@@;
		$line =~ s@.*\*/@@;

441
442
443
444
445
446
# Standardise the strings and chars within the input to simplify matching.
		$line = sanitise_line($line);

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

448
449
# Check for switch () and associated case and default
# statements should be at the same indent.
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
		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 '') {
				print "switch and case should be at the same indent\n";
				print "$here\n$line\n$err\n";
				$clean = 0;
			}
		}

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

475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
# TEST: allow direct testing of the type matcher.
		if ($tst_type && $line =~ /^.$Declare$/) {
			print "TEST: is type $Declare\n";
			print "$herecurr";
			$clean = 0;
			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{//}) {
				print "malformed #include filename\n";
				print "$herecurr";
				$clean = 0;
			}
			# Sanitise this special form of string.
			$path = 'X' x length($path);
			$line =~ s{\<.*\>}{<$path>};
		}
499

500
# no C99 // comments
501
		if ($line =~ m{//}) {
502
503
504
505
			print "do not use C99 // comments\n";
			print "$herecurr";
			$clean = 0;
		}
506
		# Remove C99 comments.
507
508
509
		$line =~ s@//.*@@;

#EXPORT_SYMBOL should immediately follow its function closing }.
510
511
512
		if (($line =~ /EXPORT_SYMBOL.*\((.*)\)/) ||
		    ($line =~ /EXPORT_UNUSED_SYMBOL.*\((.*)\)/)) {
			my $name = $1;
513
514
			if (($prevline !~ /^}/) &&
			   ($prevline !~ /^\+}/) &&
515
516
517
			   ($prevline !~ /^ }/) &&
			   ($prevline !~ /\s$name(?:\s+$Attribute)?\s*(?:;|=)/)) {
				print "EXPORT_SYMBOL(foo); should immediately follow its function/variable\n";
518
519
520
521
522
				print "$herecurr";
				$clean = 0;
			}
		}

523
# check for static initialisers.
524
525
526
527
528
529
		if ($line=~/\s*static\s.*=\s+(0|NULL);/) {
			print "do not initialise statics to 0 or NULL\n";
			print "$herecurr";
			$clean = 0;
		}

530
531
532
533
534
# check for new typedefs, only function parameters and sparse annotations
# make sense.
		if ($line =~ /\btypedef\s/ &&
		    $line !~ /\btypedef\s+$Type\s+\(\s*$Ident\s*\)\s*\(/ &&
		    $line !~ /\b__bitwise(?:__|)\b/) {
535
536
537
538
539
540
			print "do not add new typedefs\n";
			print "$herecurr";
			$clean = 0;
		}

# * goes on variable not on type
541
542
		if ($line =~ m{\($NonptrType(\*+)(?:\s+const)?\)}) {
			print "\"(foo$1)\" should be \"(foo $1)\"\n";
543
544
			print "$herecurr";
			$clean = 0;
545
546
547

		} elsif ($line =~ m{\($NonptrType\s+(\*+)(?!\s+const)\s+\)}) {
			print "\"(foo $1 )\" should be \"(foo $1)\"\n";
548
549
			print "$herecurr";
			$clean = 0;
550
551
552

		} elsif ($line =~ m{$NonptrType(\*+)(?:\s+const)?\s+[A-Za-z\d_]+}) {
			print "\"foo$1 bar\" should be \"foo $1bar\"\n";
553
554
			print "$herecurr";
			$clean = 0;
555
556
557

		} elsif ($line =~ m{$NonptrType\s+(\*+)(?!\s+const)\s+[A-Za-z\d_]+}) {
			print "\"foo $1 bar\" should be \"foo $1bar\"\n";
558
559
560
561
562
563
564
565
566
567
568
			print "$herecurr";
			$clean = 0;
		}

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

569
570
571
572
573
# 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.
574
		if ($line =~ /\bprintk\((?!KERN_)/) {
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
			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) {
				print "printk() should include KERN_ facility level\n";
				print "$herecurr";
				$clean = 0;
			}
592
593
		}

594
595
# function brace can't be on same line, except for #defines of do while,
# or if closed on same line
596
		if (($line=~/$Type\s*[A-Za-z\d_]+\(.*\).* {/) and
597
598
599
600
601
		    !($line=~/\#define.*do\s{/) and !($line=~/}/)) {
			print "braces following function declarations go on the next line\n";
			print "$herecurr";
			$clean = 0;
		}
602
603

# Check operator spacing.
604
605
606
		# 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.
607
		my $opline = $line;
608
		$opline = expand_tabs($opline);
609
		$opline =~ s/^./ /;
610
611
		if (!($line=~/\#\s*include/)) {
			my @elements = split(/(<<=|>>=|<=|>=|==|!=|\+=|-=|\*=|\/=|%=|\^=|\|=|&=|->|<<|>>|<|>|=|!|~|&&|\|\||,|\^|\+\+|--|;|&|\||\+|-|\*|\/\/|\/)/, $opline);
612
			my $off = 0;
613
			for (my $n = 0; $n < $#elements; $n += 2) {
614
615
616
617
618
619
620
621
622
				$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);

623
				my $op = $elements[$n + 1];
624
625

				my $c = '';
626
				if (defined $elements[$n + 2]) {
627
628
629
630
631
632
					$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';
633
634
				}

635
636
637
				# Pick up the preceeding and succeeding characters.
				my $ca = substr($opline, $off - 1, 1);
				my $cc = '';
638
				if (length($opline) >= ($off + length($elements[$n + 1]))) {
639
					$cc = substr($opline, $off + length($elements[$n + 1]));
640
641
				}

642
643
644
645
646
				my $ctx = "${a}x${c}";

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

				my $ptr = (" " x $off) . "^";
647
				my $hereptr = "$hereline$ptr\n\n";
648
649
650

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

651
652
653
654
655
656
657
658
659
660
				# ; should have either the end of line or a space or \ after it
				if ($op eq ';') {
					if ($ctx !~ /.x[WE]/ && $cc !~ /^\\/) {
						print "need space after that '$op' $at\n";
						print "$hereptr";
						$clean = 0;
					}

				# // is a comment
				} elsif ($op eq '//') {
661
662
663

				# -> should have no spaces
				} elsif ($op eq '->') {
664
					if ($ctx =~ /Wx.|.xW/) {
665
						print "no spaces around that '$op' $at\n";
666
						print "$hereptr";
667
668
669
670
671
						$clean = 0;
					}

				# , must have a space on the right.
				} elsif ($op eq ',') {
672
					if ($ctx !~ /.xW|.xE/ && $cc !~ /^}/) {
673
						print "need space after that '$op' $at\n";
674
						print "$hereptr";
675
676
677
678
679
						$clean = 0;
					}

				# unary ! and unary ~ are allowed no space on the right
				} elsif ($op eq '!' or $op eq '~') {
680
					if ($ctx !~ /[WOEB]x./) {
681
						print "need space before that '$op' $at\n";
682
						print "$hereptr";
683
684
						$clean = 0;
					}
685
					if ($ctx =~ /.xW/) {
686
						print "no space after that '$op' $at\n";
687
						print "$hereptr";
688
689
690
691
692
						$clean = 0;
					}

				# unary ++ and unary -- are allowed no space on one side.
				} elsif ($op eq '++' or $op eq '--') {
693
					if ($ctx !~ /[WOB]x[^W]/ && $ctx !~ /[^W]x[WOBE]/) {
694
						print "need space one side of that '$op' $at\n";
695
						print "$hereptr";
696
697
						$clean = 0;
					}
698
					if ($ctx =~ /Wx./ && $cc =~ /^;/) {
699
700
701
702
						print "no space before that '$op' $at\n";
						print "$hereptr";
						$clean = 0;
					}
703
704
705
706
707
708
709
710
711
712
713
714
715

				# & 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
				#
716
				} elsif ($op eq '&' or $op eq '-') {
717
					if ($ctx !~ /VxV|[EW]x[WE]|[EWB]x[VO]/) {
718
719
720
721
722
						print "need space before that '$op' $at\n";
						print "$hereptr";
						$clean = 0;
					}

723
724
725
726
727
				# * is the same as & only adding:
				# type:
				# 	(foo *)
				#	(foo **)
				#
728
				} elsif ($op eq '*') {
729
					if ($ca eq '*') {
730
						if ($cc =~ /^\s(?!\s*const)/) {
731
732
733
734
							print "no space after that '$op' $at\n";
							print "$hereptr";
							$clean = 0;
						}
735
					} elsif ($ctx !~ /VxV|[EW]x[WE]|[EWB]x[VO]|OxV|WxB|BxB/) {
736
						print "need space before that '$op' $at\n";
737
						print "$hereptr";
738
739
740
741
742
743
744
						$clean = 0;
					}

				# << 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 '|')
				{
745
					if ($ctx !~ /VxV|WxW|VxE|WxE/) {
746
						print "need consistent spacing around '$op' $at\n";
747
						print "$hereptr";
748
749
750
751
						$clean = 0;
					}

				# All the others need spaces both sides.
752
				} elsif ($ctx !~ /[EW]x[WE]/) {
753
					print "need spaces around that '$op' $at\n";
754
					print "$hereptr";
755
756
					$clean = 0;
				}
757
				$off += length($elements[$n + 1]);
758
759
760
761
762
763
764
765
766
767
768
			}
		}

#need space before brace following if, while, etc
		if ($line=~/\(.*\){/) {
			print "need a space before the brace\n";
			print "$herecurr";
			$clean = 0;
		}

#goto labels aren't indented, allow a single space however
769
		if ($line=~/^.\s+[A-Za-z\d_]+:(?![0-9]+)/ and
770
771
772
773
774
775
776
		   !($line=~/^. [A-Za-z\d_]+:/) and !($line=~/^.\s+default:/)) {
			print "labels should not be indented\n";
			print "$herecurr";
			$clean = 0;
		}

# Need a space before open parenthesis after if, while etc
777
		if ($line=~/\b(if|while|for|switch)\(/) {
778
779
780
781
782
783
			print "need a space before the open parenthesis\n";
			print "$herecurr";
			$clean = 0;
		}

# Check for illegal assignment in if conditional.
784
		if ($line=~/\bif\s*\(.*[^<>!=]=[^=].*\)/) {
785
			#next if ($line=~/\".*\Q$op\E.*\"/ or $line=~/\'\Q$op\E\'/);
786
			print "do not use assignment in if condition\n";
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
			print "$herecurr";
			$clean = 0;
		}

		# 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) {
			print "else should follow close brace\n";
			print "$hereprev";
			$clean = 0;
		}

#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$/) {
			print("Whitepspace after \\ makes next lines useless\n");
			print "$herecurr";
			$clean = 0;
		}

814
815
#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\>}) {
816
817
818
819
820
821
822
823
			my $checkfile = "include/linux/$1.h";
			if (-f $checkfile) {
				print "Use #include <linux/$1.h> instead of <asm/$1.h>\n";
				print $herecurr;
				$clean = 0;
			}
		}

824
825
# 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
826
		if ($prevline=~/\b(?:(if|while|for|switch)\s*\(|do\b|else\b)/) {
827
828
829
			my @opened = $prevline=~/\(/g;
			my @closed = $prevline=~/\)/g;
			my $nr_line = $linenr;
830
			my $remaining = $realcnt - 1;
831
832
833
834
			my $next_line = $line;
			my $extra_lines = 0;
			my $display_segment = $prevline;

835
			while ($remaining > 0 && scalar @opened > scalar @closed) {
836
837
838
839
840
841
842
843
844
845
				$prevline .= $next_line;
				$display_segment .= "\n" . $next_line;
				$next_line = $lines[$nr_line];
				$nr_line++;
				$remaining--;

				@opened = $prevline=~/\(/g;
				@closed = $prevline=~/\)/g;
			}

846
847
			if (($prevline=~/\b(?:(if|while|for|switch)\s*\(.*\)|do|else)\s*$/) and ($next_line=~/{/) and
			   !($next_line=~/\b(?:if|while|for|switch|do|else)\b/) and !($next_line=~/\#define.*do.*while/)) {
848
				print "That { should be on the previous line\n";
849
				print "$here\n$display_segment\n$next_line\n\n";
850
851
852
853
				$clean = 0;
			}
		}

854
855
856
857
858
859
860
861
# if and else should not have general statements after it
		if ($line =~ /^.\s*(?:}\s*)?else\b(.*)/ &&
		    $1 !~ /^\s*(?:\sif|{|$)/) {
			print "trailing statements should be on next line\n";
			print "$herecurr";
			$clean = 0;
		}

862
863
864
865
866
867
868
869
870
871
# 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.
872
873
			my $ln = $linenr;
			my $cnt = $realcnt;
874

875
876
877
878
879
880
881
882
883
884
885
886
887
			# If the macro starts on the define line start there.
			if ($prevline !~ m{^.#\s*define\s*$Ident(?:\([^\)]*\))?\s*\\\s*$}) {
				$ln--;
				$cnt++;
			}
			my $ctx = join('', ctx_statement($ln, $cnt));

			if ($ctx =~ /\\$/) {
				if ($ctx =~ /;/) {
					print "Macros with multiple statements should be enclosed in a do - while loop\n";
				} else {
					print "Macros with complex values should be enclosed in parenthesis\n";
				}
888
889
890
				print "$hereprev";
				$clean = 0;
			}
891
892
		}

893
# don't include deprecated include files (uses RAW line)
894
		for my $inc (@dep_includes) {
895
			if ($rawline =~ m@\#\s*include\s*\<$inc>@) {
896
897
898
899
900
901
				print "Don't use <$inc>: see Documentation/feature-removal-schedule.txt\n";
				print "$herecurr";
				$clean = 0;
			}
		}

902
903
# don't use deprecated functions
		for my $func (@dep_functions) {
904
			if ($line =~ /\b$func\b/) {
905
906
907
908
909
910
911
				print "Don't use $func(): see Documentation/feature-removal-schedule.txt\n";
				print "$herecurr";
				$clean = 0;
			}
		}

# no volatiles please
912
		if ($line =~ /\bvolatile\b/ && $line !~ /\basm\s+volatile\b/) {
913
914
915
916
917
			print "Use of volatile is usually wrong: see Documentation/volatile-considered-harmful.txt\n";
			print "$herecurr";
			$clean = 0;
		}

918
919
920
# warn about #if 0
		if ($line =~ /^.#\s*if\s+0\b/) {
			print "#if 0 -- if this code redundant remove it\n";
921
922
923
924
			print "$herecurr";
			$clean = 0;
		}

925
926
927
928
929
930
931
# 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;
#		}

932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
# 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)) {
				print "$1 definition without comment\n";
				print "$herecurr";
				$clean = 0;
			}
		}
# 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)) {
				print "memory barrier without comment\n";
				print "$herecurr";
				$clean = 0;
			}
		}
# check of hardware specific defines
		if ($line =~ m@^.#\s*if.*\b(__i386__|__powerpc64__|__sun__|__s390x__)\b@) {
			print "architecture specific defines should be avoided\n";
952
953
954
			print "$herecurr";
			$clean = 0;
		}
955
956
957
958
959
960
961

		if ($line =~ /$Type\s+(?:inline|__always_inline)\b/ ||
		    $line =~ /\b(?:inline|always_inline)\s+$Storage/) {
			print "inline keyword should sit between storage class and type\n";
			print "$herecurr";
			$clean = 0;
		}
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
	}

	if ($chk_patch && !$is_patch) {
		$clean = 0;
		print "Does not appear to be a unified-diff format patch\n";
	}
	if ($is_patch && $chk_signoff && $signoff == 0) {
		$clean = 0;
		print "Missing Signed-off-by: line(s)\n";
	}

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