Commit 6c72ffaa authored by Andy Whitcroft's avatar Andy Whitcroft Committed by Linus Torvalds
Browse files

update checkpatch.pl to version 0.11 



This version brings a more cautious checkpatch.pl by default.  The more
subjective checks are only applied with the --strict option.  It also
brings the usual slew of corrections for false positives.  Of note:

  - new tree detection, the source tree will be found via the executable
  - a major revamp of the unary detection to make it more parser like
  - a new summary at the bottom of the report
  - --strict option for subjective checks
  - --file to enable checking on complete files
  - support for use in emacs "compile" window

Andy Whitcroft (27):
      Version: 0.11
      fix up cat_vet for the case where there are no control characters
      any cast to a pointer introduces a type
      cpp unary operator detection needs to float
      attributes are also valid in type definitions
      sizeof may be a bareword and makes its argument unary
      unary checks for #ifdef et al need to find end of line
      add new --file mode to handle raw source files
      add --strict/--subjective which enables the subjective tests
      add some additional standard type suffixes
      cpp #elif is also a unary prefix
      case is not a function name
      widen asm volatile exceptions
      __kprobes is a type attribute
      typeof is a unary operator
      function open parenthesis checks should check all occurances
      expand sizeof() binary exceptions
      linux/irq.h should not be recommended
      work harder to find the kernel root and add --root=
      fix --emacs mode line numbers and string concatenation warnings
      add a summary to the bottom of the main report
      loosen assignment in if checks
      update operator spacing to maintain tabs in output
      revamp unary detection
      corruption/line wrapped patches need only reporting once
      revamp s/u/be/le 8/16/32/64 bit types
      handle missing ,1 in uni-diff header

Mike D. Day (2):
      Adds support to checkpatch.pl for running in the emacs compile window.
      checkpatch: Fix line number reporting

Signed-off-by: default avatarAndy Whitcroft <apw@shadowen.org>
Signed-off-by: default avatarAndrew Morton <akpm@linux-foundation.org>
Signed-off-by: default avatarLinus Torvalds <torvalds@linux-foundation.org>
parent faf8c714

scripts/checkpatch.pl

+340 −174
Original line number Diff line number Diff line
@@ -9,7 +9,7 @@ use strict; 
my $P = $0;

$P =~ s@.*/@@g;



my $V = '0.10';

my $V = '0.11';



use Getopt::Long qw(:config no_auto_abbrev);
@@ -18,12 +18,21 @@ my $tree = 1; 
my $chk_signoff = 1;

my $chk_patch = 1;

my $tst_type = 0;

my $emacs = 0;

my $file = 0;

my $check = 0;

my $root;

GetOptions(

	'q|quiet'	=> \$quiet,

	'q|quiet+'	=> \$quiet,

	'tree!'		=> \$tree,

	'signoff!'	=> \$chk_signoff,

	'patch!'	=> \$chk_patch,

	'test-type!'	=> \$tst_type,

	'emacs!'	=> \$emacs,

	'file!'		=> \$file,

	'subjective!'	=> \$check,

	'strict!'	=> \$check,

	'root=s'	=> \$root,

) or exit;



my $exit = 0;
@@ -33,19 +42,110 @@ if ($#ARGV < 0) { 
	print "version: $V\n";

	print "options: -q           => quiet\n";

	print "         --no-tree    => run without a kernel tree\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";

	exit(1);

}



if ($tree && !top_of_kernel_tree()) {

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

	}

}



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|

			__kprobes|

			fastcall

		}x;

our $Attribute	= qr{

			const|

			__read_mostly|

			__kprobes|

			__(?:mem|cpu|dev|)(?:initdata|init)

		  }x;

our $Inline	= qr{inline|__always_inline|noinline};

our $NonptrType	= qr{

			\b

			(?:const\s+)?

			(?:unsigned\s+)?

			(?:

				void|

				char|

				short|

				int|

				long|

				unsigned|

				float|

				double|

				bool|

				long\s+int|

				long\s+long|

				long\s+long\s+int|

				(?:__)?(?:u|s|be|le)(?:8|16|32|64)|

				struct\s+$Ident|

				union\s+$Ident|

				enum\s+$Ident|

				${Ident}_t|

				${Ident}_handler|

				${Ident}_handler_fn

			)

			(?:\s+$Sparse)*

			\b

		  }x;



our $Type	= qr{

			\b$NonptrType\b

			(?:\s*\*+\s*const|\s*\*+|(?:\s*\[\s*\])+)?

			(?:\s+$Sparse|\s+$Attribute)*

		  }x;

our $Declare	= qr{(?:$Storage\s+)?$Type};

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{

			<=|>=|==|!=|

			=>|->|<<|>>|<|>|!|~|

			&&|\|\||,|\^|\+\+|--|&|\||\+|-|\*|\/

		  }x;



our $Bare = '';



$chk_signoff = 0 if ($file);



my @dep_includes = ();

my @dep_functions = ();

my $removal = 'Documentation/feature-removal-schedule.txt';

if ($tree && -f $removal) {

	open(REMOVE, "<$removal") || die "$P: $removal: open failed - $!\n";

my $removal = "Documentation/feature-removal-schedule.txt";

if ($tree && -f "$root/$removal") {

	open(REMOVE, "<$root/$removal") ||

				die "$P: $removal: open failed - $!\n";

	while (<REMOVE>) {

		if (/^Check:\s+(.*\S)/) {

			for my $entry (split(/[, ]+/, $1)) {
@@ -61,29 +161,43 @@ if ($tree && -f $removal) { 
}



my @rawlines = ();

while (<>) {

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

	}

	while (<FILE>) {

		chomp;

		push(@rawlines, $_);

	if (eof(ARGV)) {

		if (!process($ARGV, @rawlines)) {

	}

	close(FILE);

	if (!process($filename, @rawlines)) {

		$exit = 1;

	}

	@rawlines = ();

}

}



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;

	}

	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;

		}

	}

	return 1;

}



sub expand_tabs {

	my ($str) = @_;
@@ -105,6 +219,20 @@ sub expand_tabs { 


	return $res;

}

sub copy_spacing {

	my ($str) = @_;



	my $res = '';

	for my $c (split(//, $str)) {

		if ($c eq "\t") {

			$res .= $c;

		} else {

			$res .= ' ';

		}

	}



	return $res;

}



sub line_stats {

	my ($line) = @_;
@@ -260,47 +388,138 @@ sub ctx_has_comment { 
	return ($cmt ne '');

}



sub ctx_expr_before {

	my ($line) = @_;



	##print "CHECK<$line>\n";

sub cat_vet {

	my ($vet) = @_;

	my ($res, $coded);



	my $pos = length($line) - 1;

	my $count = 0;

	my $c;

	$res = '';

	while ($vet =~ /([^[:cntrl:]]*)([[:cntrl:]]|$)/g) {

		$res .= $1;

		if ($2 ne '') {

			$coded = sprintf("^%c", unpack('C', $2) + 64);

			$res .= $coded;

		}

	}

	$res =~ s/$/\$/;



	for (; $pos >= 0; $pos--) {

		$c = substr($line, $pos, 1);

		##print "CHECK: c<$c> count<$count>\n";

		if ($c eq ')') {

			$count++;

		} elsif ($c eq '(') {

			last if (--$count == 0);

	return $res;

}



sub annotate_values {

	my ($stream, $type) = @_;



	my $res;

	my $cur = $stream;



	my $debug = 0;



	print "$stream\n" if ($debug);



	##my $type = 'N';

	my $pos = 0;

	my $preprocessor = 0;

	my $paren = 0;

	my @paren_type;



	# Include any user defined types we may have found as we went.

	my $type_match = "(?:$Type$Bare)";



	while (length($cur)) {

		print " <$type> " if ($debug);

		if ($cur =~ /^(\s+)/o) {

			print "WS($1)\n" if ($debug);

			if ($1 =~ /\n/ && $preprocessor) {

				$preprocessor = 0;

				$type = 'N';

			}



	##print "CHECK: result<" . substr($line, 0, $pos) . ">\n";

		} elsif ($cur =~ /^($type_match)/) {

			print "DECLARE($1)\n" if ($debug);

			$type = 'T';



		} elsif ($cur =~ /^(#\s*define\s*$Ident)(\(?)/o) {

			print "DEFINE($1)\n" if ($debug);

			$preprocessor = 1;

			$paren_type[$paren] = 'N';



		} elsif ($cur =~ /^(#\s*(?:ifdef|ifndef|if|else|endif))/o) {

			print "PRE($1)\n" if ($debug);

			$preprocessor = 1;

			$type = 'N';



	return substr($line, 0, $pos);

		} elsif ($cur =~ /^(\\\n)/o) {

			print "PRECONT($1)\n" if ($debug);



		} elsif ($cur =~ /^(sizeof)\s*(\()?/o) {

			print "SIZEOF($1)\n" if ($debug);

			if (defined $2) {

				$paren_type[$paren] = 'V';

			}

			$type = 'N';



		} elsif ($cur =~ /^(if|while|typeof)\b/o) {

			print "COND($1)\n" if ($debug);

			$paren_type[$paren] = 'N';

			$type = 'N';



		} elsif ($cur =~/^(return|case|else)/o) {

			print "KEYWORD($1)\n" if ($debug);

			$type = 'N';



		} elsif ($cur =~ /^(\()/o) {

			print "PAREN('$1')\n" if ($debug);

			$paren++;

			$type = 'N';



		} elsif ($cur =~ /^(\))/o) {

			$paren-- if ($paren > 0);

			if (defined $paren_type[$paren]) {

				$type = $paren_type[$paren];

				undef $paren_type[$paren];

				print "PAREN('$1') -> $type\n" if ($debug);

			} else {

				print "PAREN('$1')\n" if ($debug);

			}



sub cat_vet {

	my ($vet) = @_;

	my ($res, $coded);

		} elsif ($cur =~ /^($Ident)\(/o) {

			print "FUNC($1)\n" if ($debug);

			$paren_type[$paren] = 'V';



	$res = '';

	while ($vet =~ /([^[:cntrl:]]*)([[:cntrl:]])/g) {

		$coded = sprintf("^%c", unpack('C', $2) + 64);

		$res .= $1 . $coded;

		} elsif ($cur =~ /^($Ident|$Constant)/o) {

			print "IDENT($1)\n" if ($debug);

			$type = 'V';



		} elsif ($cur =~ /^($Assignment)/o) {

			print "ASSIGN($1)\n" if ($debug);

			$type = 'N';



		} elsif ($cur =~ /^(;|{|}|\?|:|\[)/o) {

			print "END($1)\n" if ($debug);

			$type = 'N';



		} elsif ($cur =~ /^($Operators)/o) {

			print "OP($1)\n" if ($debug);

			if ($1 ne '++' && $1 ne '--') {

				$type = 'N';

			}



		} elsif ($cur =~ /(^.)/o) {

			print "C($1)\n" if ($debug);

		}

		if (defined $1) {

			$cur = substr($cur, length($1));

			$res .= $type x length($1);

		}

	}

	$res =~ s/$/\$/;



	return $res;

}



my $prefix = '';



my @report = ();

sub report {

	push(@report, $_[0]);

	push(@report, $prefix . $_[0]);

}

sub report_dump {

	@report;
@@ -308,14 +527,19 @@ sub report_dump { 
sub ERROR {

	report("ERROR: $_[0]\n");

	our $clean = 0;

	our $cnt_error++;

}

sub WARN {

	report("WARNING: $_[0]\n");

	our $clean = 0;

	our $cnt_warn++;

}

sub CHK {

	if ($check) {

		report("CHECK: $_[0]\n");

		our $clean = 0;

		our $cnt_chk++;

	}

}



sub process {
@@ -335,6 +559,11 @@ sub process { 
	my $signoff = 0;

	my $is_patch = 0;



	our $cnt_lines = 0;

	our $cnt_error = 0;

	our $cnt_warn = 0;

	our $cnt_chk = 0;



	# Trace the real file/line as we go.

	my $realfile = '';

	my $realline = 0;
@@ -343,62 +572,10 @@ sub process { 
	my $in_comment = 0;

	my $first_line = 0;



	my $Ident	= qr{[A-Za-z\d_]+};

	my $Storage	= qr{extern|static|asmlinkage};

	my $Sparse	= qr{

				__user|

				__kernel|

				__force|

				__iomem|

				__must_check|

				__init_refok|

				fastcall

			}x;

	my $Inline	= qr{inline|__always_inline|noinline};

	my $NonptrType	= qr{

				\b

				(?:const\s+)?

				(?:unsigned\s+)?

				(?:

					void|

					char|

					short|

					int|

					long|

					unsigned|

					float|

					double|

					bool|

					long\s+int|

					long\s+long|

					long\s+long\s+int|

					u8|u16|u32|u64|

					s8|s16|s32|s64|

					struct\s+$Ident|

					union\s+$Ident|

					enum\s+$Ident|

					${Ident}_t

				)

				(?:\s+$Sparse)*

				\b

			  }x;

	my $Type	= qr{

				\b$NonptrType\b

				(?:\s*\*+\s*const|\s*\*+|(?:\s*\[\s*\])+)?

				(?:\s+$Sparse)*

			  }x;

	my $Declare	= qr{(?:$Storage\s+)?$Type};

	my $Attribute	= qr{

				const|

				__read_mostly|

				__(?:mem|cpu|dev|)(?:initdata|init)

			  }x;

	my $Member	= qr{->$Ident|\.$Ident|\[[^]]*\]};

	my $Lval	= qr{$Ident(?:$Member)*};

	my $prev_values = 'N';



	# Possible bare types.

	my @bare = ();

	my $Bare = $NonptrType;



	# Pre-scan the patch looking for any __setup documentation.

	my @setup_docs = ();
@@ -417,11 +594,14 @@ sub process { 
		}

	}



	$prefix = '';



	foreach my $line (@lines) {

		$linenr++;



		my $rawline = $line;





#extract the filename as it passes

		if ($line=~/^\+\+\+\s+(\S+)/) {

			$realfile=$1;
@@ -430,7 +610,7 @@ sub process { 
			next;

		}

#extract the line range in the file after the patch is applied

		if ($line=~/^\@\@ -\d+,\d+ \+(\d+)(,(\d+))? \@\@/) {

		if ($line=~/^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@/) {

			$is_patch = 1;

			$first_line = $linenr + 1;

			$in_comment = 0;
@@ -440,6 +620,7 @@ sub process { 
			} else {

				$realcnt=1+1;

			}

			$prev_values = 'N';

			next;

		}
@@ -473,18 +654,24 @@ sub process { 
			# Track the previous line.

			($prevline, $stashline) = ($stashline, $line);

			($previndent, $stashindent) = ($stashindent, $indent);



		} elsif ($realcnt == 1) {

			$realcnt--;

		}



#make up the handle for any error we report on this line

		$here = "#$linenr: ";

		$here = "#$linenr: " if (!$file);

		$here = "#$realline: " if ($file);

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



		my $hereline = "$here\n$line\n";

		my $herecurr = "$here\n$line\n";

		my $hereprev = "$here\n$prevline\n$line\n";



		$prefix = "$filename:$realline: " if ($emacs && $file);

		$prefix = "$filename:$linenr: " if ($emacs && !$file);

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



#check the patch for a signoff:

		if ($line =~ /^\s*signed-off-by:/i) {

			# This is a signoff, if ugly, so do not double report.
@@ -502,7 +689,7 @@ sub process { 
# Check for wrappage within a valid hunk of the file

		if ($realcnt != 0 && $line !~ m{^(?:\+|-| |$)}) {

			ERROR("patch seems to be corrupt (line wrapped?)\n" .

				$herecurr);

				$herecurr) if (!$emitted_corrupt++);

		}



# UTF-8 regex found at http://www.w3.org/International/questions/qa-forms-utf-8.en.php
@@ -568,8 +755,12 @@ sub process { 
		    $line !~ /^.\s*(?:$Storage\s+)?(?:$Inline\s+)?$Type\b/ &&

		    $line !~ /$Ident:\s*$/ &&

		    $line !~ /^.\s*$Ident\s*\(/ &&

		     # definitions in global scope can only start with types

		    ($line =~ /^.(?:$Storage\s+)?(?:$Inline\s+)?($Ident)\b/ ||

		     $line =~ /^.\s*(?:$Storage\s+)?($Ident)\b\s*\**\s*$Ident\s*(?:;|=)/)) {

		     # declarations always start with types

		     $line =~ /^.\s*(?:$Storage\s+)?($Ident)\b\s*\**\s*$Ident\s*(?:;|=)/) ||

		     # any (foo ... *) is a pointer cast, and foo is a type

		     $line =~ /\(($Ident)(?:\s+$Sparse)*\s*\*+\s*\)/) {

			my $possible = $1;

			if ($possible !~ /^(?:$Storage|$Type|DEFINE_\S+)$/ &&

			    $possible ne 'goto' && $possible ne 'return' &&
@@ -579,7 +770,7 @@ sub process { 
				#print "POSSIBLE<$possible>\n";

				push(@bare, $possible);

				my $bare = join("|", @bare);

				$Bare	= qr{

				$Bare	= '|' . qr{

						\b(?:$bare)\b

						(?:\s*\*+\s*const|\s*\*+|(?:\s*\[\s*\])+)?

						(?:\s+$Sparse)*
@@ -641,6 +832,14 @@ sub process { 
			}

		}



		# Track the 'values' across context and added lines.

		my $opline = $line; $opline =~ s/^./ /;

		my $curr_values = annotate_values($opline . "\n", $prev_values);

		$curr_values = $prev_values . $curr_values;

		#warn "--> $opline\n";

		#warn "--> $curr_values ($prev_values)\n";

		$prev_values = substr($curr_values, -1);



#ignore lines not being added

		if ($line=~/^[^\+]/) {next;}
@@ -678,6 +877,7 @@ sub process { 
		}

		# Remove C99 comments.

		$line =~ s@//.*@@;

		$opline =~ s@//.*@@;



#EXPORT_SYMBOL should immediately follow its function closing }.

		if (($line =~ /EXPORT_SYMBOL.*\((.*)\)/) ||
@@ -766,18 +966,13 @@ sub process { 
		}



# check for spaces between functions and their parentheses.

		if ($line =~ /($Ident)\s+\(/ &&

		    $1 !~ /^(?:if|for|while|switch|return|volatile|__volatile__|__attribute__|format|__extension__|Copyright)$/ &&

		while ($line =~ /($Ident)\s+\(/g) {

			if ($1 !~ /^(?:if|for|while|switch|return|volatile|__volatile__|__attribute__|format|__extension__|Copyright|case)$/ &&

		            $line !~ /$Type\s+\(/ && $line !~ /^.\#\s*define\b/) {

				WARN("no space between function name and open parenthesis '('\n" . $herecurr);

			}

		}

# Check operator spacing.

		# 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.

		my $opline = $line;

		$opline = expand_tabs($opline);

		$opline =~ s/^./ /;

		if (!($line=~/\#\s*include/)) {

			my $ops = qr{

				<<=|>>=|<=|>=|==|!=|
@@ -787,6 +982,9 @@ sub process { 
			}x;

			my @elements = split(/($ops|;)/, $opline);

			my $off = 0;



			my $blank = copy_spacing($opline);



			for (my $n = 0; $n < $#elements; $n += 2) {

				$off += length($elements[$n]);
@@ -822,62 +1020,24 @@ sub process { 


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



				my $ptr = (" " x $off) . "^";

				my $ptr = substr($blank, 0, $off) . "^";

				my $hereptr = "$hereline$ptr\n";



				# Classify operators into binary, unary, or

				# definitions (* only) where they have more

				# than one mode.

				my $unary_ctx = $prevline . $ca;

				$unary_ctx =~ s/^./ /;

				my $is_unary = 0;

				my $Unary = qr{

					(?:

						^|;|,|$ops|\(|\?|:|

						\(\s*$Type\s*\)|

						$Type|

						return|case|else|

						\{|\}|

						\[|

						^.\#\s*define\s+$Ident\s*(?:\([^\)]*\))?|

						^.\#\s*else|

						^.\#\s*endif|

						^.\#\s*(?:if|ifndef|ifdef)\b.*

					)\s*(?:|\\)\s*$

				}x;

				my $UnaryFalse = qr{

					sizeof\s*\(\s*$Type\s*\)\s*$

				}x;

				my $UnaryDefine = qr{

					 (?:$Type|$Bare)\s*|

					 (?:$Type|$Bare).*,\s*\**

				}x;

				if ($op eq '-' || $op eq '&' || $op eq '*') {

					# An operator is binary if the left hand

					# side is a value.  Pick out the known

					# non-values.

					if ($unary_ctx =~ /$Unary$/s &&

					    $unary_ctx !~ /$UnaryFalse$/s) {

						$is_unary = 1;



					# Special handling for ')' check if this

					# brace represents a conditional, if so

					# we are unary.

					} elsif ($unary_ctx =~ /\)\s*$/) {

						my $before = ctx_expr_before($unary_ctx);

						if ($before =~ /(?:for|if|while)\s*$/) {

							$is_unary = 1;

						}

					}



					# Check for type definition for of '*'.

					if ($op eq '*' && $unary_ctx =~ /$UnaryDefine$/) {

				my $op_type = substr($curr_values, $off + 1, 1);

				my $op_left = substr($curr_values, $off, 1);

				my $is_unary;

				if ($op_type eq 'T') {

					$is_unary = 2;

				} elsif ($op_left eq 'V') {

					$is_unary = 0;

				} else {

					$is_unary = 1;

				}

				}



				#if ($op eq '-' || $op eq '&' || $op eq '*') {

				#	print "UNARY: <$is_unary $a:$op:$c> <$ca:$op:$cc> <$unary_ctx>\n";

				#	print "UNARY: <$op_left$op_type $is_unary $a:$op:$c> <$ca:$op:$cc> <$unary_ctx>\n";

				#}



				# ; should have either the end of line or a space or \ after it
@@ -952,7 +1112,7 @@ sub process { 


# check for multiple assignments

		if ($line =~ /^.\s*$Lval\s*=\s*$Lval\s*=(?!=)/) {

			WARN("multiple assignments should be avoided\n" . $herecurr);

			CHK("multiple assignments should be avoided\n" . $herecurr);

		}



## # check for multiple declarations, allowing for a function declaration
@@ -1012,7 +1172,7 @@ sub process { 
		}



# Check for illegal assignment in if conditional.

		if ($line=~/\bif\s*\(.*[^<>!=]=[^=].*\)/) {

		if ($line=~/\bif\s*\(.*[^<>!=]=[^=]/) {

			#next if ($line=~/\".*\Q$op\E.*\"/ or $line=~/\'\Q$op\E\'/);

			ERROR("do not use assignment in if condition\n" . $herecurr);

		}
@@ -1038,8 +1198,8 @@ sub process { 


#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\>}) {

			my $checkfile = "include/linux/$1.h";

			if (-f $checkfile) {

			my $checkfile = "$root/include/linux/$1.h";

			if (-f $checkfile && $1 ne 'irq.h') {

				CHK("Use #include <linux/$1.h> instead of <asm/$1.h>\n" .

					$herecurr);

			}
@@ -1151,7 +1311,8 @@ sub process { 
		}



# no volatiles please

		if ($line =~ /\bvolatile\b/ && $line !~ /\basm\s+volatile\b/) {

		my $asm_volatile = qr{\b(__asm__|asm)\s+(__volatile__|volatile)\b};

		if ($line =~ /\bvolatile\b/ && $line !~ /$asm_volatile/) {

			WARN("Use of volatile is usually wrong: see Documentation/volatile-considered-harmful.txt\n" . $herecurr);

		}
@@ -1240,6 +1401,11 @@ sub process { 


	if ($clean == 0 && ($chk_patch || $is_patch)) {

		print report_dump();

		if ($quiet < 2) {

			print "total: $cnt_error errors, $cnt_warn warnings, " .

				(($check)? "$cnt_chk checks, " : "") .

				"$cnt_lines lines checked\n";

		}

	}

	if ($clean == 1 && $quiet == 0) {

		print "Your patch has no obvious style problems and is ready for submission.\n"

CRA Git | Maintained and supported by SUSTech CRA and CCSE