#!/usr/bin/perl -w

  # (c) 2001, Dave Jones. (the file handling bit)

  # (c) 2005, Joel Schopp <jschopp@austin.ibm.com> (the ugly bit)

  # (c) 2007,2008, Andy Whitcroft <apw@uk.ibm.com> (new conditions, test suite)

  # (c) 2008,2009, Andy Whitcroft <apw@canonical.com>

  # Licensed under the terms of the GNU GPL License version 2
  
  use strict;
  
  my $P = $0;

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

  my $V = '0.30';

  
  use Getopt::Long qw(:config no_auto_abbrev);
  
  my $quiet = 0;
  my $tree = 1;
  my $chk_signoff = 1;
  my $chk_patch = 1;

  my $tst_only;

  my $emacs = 0;

  my $terse = 0;

  my $file = 0;
  my $check = 0;

  my $summary = 1;
  my $mailback = 0;

  my $summary_file = 0;

  my $root;

  my %debug;

  my $help = 0;
  
  sub help {
  	my ($exitcode) = @_;
  
  	print << "EOM";
  Usage: $P [OPTION]... [FILE]...
  Version: $V
  
  Options:
    -q, --quiet                quiet
    --no-tree                  run without a kernel tree
    --no-signoff               do not check for 'Signed-off-by' line
    --patch                    treat FILE as patchfile (default)
    --emacs                    emacs compile window format
    --terse                    one line per report
    -f, --file                 treat FILE as regular source file
    --subjective, --strict     enable more subjective tests
    --root=PATH                PATH to the kernel tree root
    --no-summary               suppress the per-file summary
    --mailback                 only produce a report in case of warnings/errors
    --summary-file             include the filename in summary
    --debug KEY=[0|1]          turn on/off debugging of KEY, where KEY is one of
                               'values', 'possible', 'type', and 'attr' (default
                               is all off)
    --test-only=WORD           report only warnings/errors containing WORD
                               literally
    -h, --help, --version      display this help and exit
  
  When FILE is - read standard input.
  EOM
  
  	exit($exitcode);
  }

  GetOptions(

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

  	'tree!'		=> \$tree,
  	'signoff!'	=> \$chk_signoff,
  	'patch!'	=> \$chk_patch,

  	'emacs!'	=> \$emacs,

  	'terse!'	=> \$terse,

  	'f|file!'	=> \$file,

  	'subjective!'	=> \$check,
  	'strict!'	=> \$check,
  	'root=s'	=> \$root,

  	'summary!'	=> \$summary,
  	'mailback!'	=> \$mailback,

  	'summary-file!'	=> \$summary_file,

  	'debug=s'	=> \%debug,

  	'test-only=s'	=> \$tst_only,

  	'h|help'	=> \$help,
  	'version'	=> \$help
  ) or help(1);
  
  help(0) if ($help);

  
  my $exit = 0;
  
  if ($#ARGV < 0) {

  	print "$P: no input files
  ";

  	exit(1);
  }

  my $dbg_values = 0;
  my $dbg_possible = 0;

  my $dbg_type = 0;

  my $dbg_attr = 0;

  for my $key (keys %debug) {

  	## no critic
  	eval "\${dbg_$key} = '$debug{$key}';";
  	die "$@" if ($@);

  }

  if ($terse) {
  	$emacs = 1;
  	$quiet++;
  }

  if ($tree) {
  	if (defined $root) {
  		if (!top_of_kernel_tree($root)) {
  			die "$P: $root: --root does not point at a valid tree
  ";
  		}
  	} 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
  ";
  		exit(2);
  	}

  }

  my $emitted_corrupt = 0;

  our $Ident	= qr{
  			[A-Za-z_][A-Za-z\d_]*
  			(?:\s*\#\#\s*[A-Za-z_][A-Za-z\d_]*)*
  		}x;

  our $Storage	= qr{extern|static|asmlinkage};
  our $Sparse	= qr{
  			__user|
  			__kernel|
  			__force|
  			__iomem|
  			__must_check|
  			__init_refok|

  			__kprobes|
  			__ref

  		}x;

  
  # Notes to $Attribute:
  # We need \b after 'init' otherwise 'initconst' will cause a false positive in a check

  our $Attribute	= qr{
  			const|
  			__read_mostly|
  			__kprobes|

  			__(?:mem|cpu|dev|)(?:initdata|initconst|init\b)|

  			____cacheline_aligned|
  			____cacheline_aligned_in_smp|

  			____cacheline_internodealigned_in_smp|
  			__weak

  		  }x;

  our $Modifier;

  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 $Compare    = qr{<=|>=|==|!=|<|>};

  our $Operators	= qr{
  			<=|>=|==|!=|
  			=>|->|<<|>>|<|>|!|~|

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

  		  }x;

  our $NonptrType;
  our $Type;
  our $Declare;

  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;

  our $typeTypedefs = qr{(?x:

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

  	atomic_t
  )};

  our $logFunctions = qr{(?x:
  	printk|
  	pr_(debug|dbg|vdbg|devel|info|warning|err|notice|alert|crit|emerg|cont)|
  	dev_(printk|dbg|vdbg|info|warn|err|notice|alert|crit|emerg|WARN)|
  	WARN|
  	panic
  )};

  our @typeList = (
  	qr{void},

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

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

  our @modifierList = (
  	qr{fastcall},
  );

  
  sub build_types {

  	my $mods = "(?x:  
  " . join("|
    ", @modifierList) . "
  )";
  	my $all = "(?x:  
  " . join("|
    ", @typeList) . "
  )";

  	$Modifier	= qr{(?:$Attribute|$Sparse|$mods)};

  	$NonptrType	= qr{

  			(?:$Modifier\s+|const\s+)*

  			(?:

  				(?:typeof|__typeof__)\s*\(\s*\**\s*$Ident\s*\)|

  				(?:$typeTypedefs\b)|

  				(?:${all}\b)

  			)

  			(?:\s+$Modifier|\s+const)*

  		  }x;
  	$Type	= qr{

  			$NonptrType

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

  			(?:\s+$Inline|\s+$Modifier)*

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

  
  $chk_signoff = 0 if ($file);

  my @dep_includes = ();
  my @dep_functions = ();

  my $removal = "Documentation/feature-removal-schedule.txt";
  if ($tree && -f "$root/$removal") {

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

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

  	while (<$REMOVE>) {

  		if (/^Check:\s+(.*\S)/) {
  			for my $entry (split(/[, ]+/, $1)) {
  				if ($entry =~ m@include/(.*)@) {

  					push(@dep_includes, $1);

  				} elsif ($entry !~ m@/@) {
  					push(@dep_functions, $entry);
  				}

  			}

  		}
  	}

  	close($REMOVE);

  }

  my @rawlines = ();

  my @lines = ();
  my $vname;

  for my $filename (@ARGV) {

  	my $FILE;

  	if ($file) {

  		open($FILE, '-|', "diff -u /dev/null $filename") ||

  			die "$P: $filename: diff failed - $!
  ";

  	} elsif ($filename eq '-') {
  		open($FILE, '<&STDIN');

  	} else {

  		open($FILE, '<', "$filename") ||

  			die "$P: $filename: open failed - $!
  ";

  	}

  	if ($filename eq '-') {
  		$vname = 'Your patch';
  	} else {
  		$vname = $filename;
  	}

  	while (<$FILE>) {

  		chomp;
  		push(@rawlines, $_);
  	}

  	close($FILE);

  	if (!process($filename)) {

  		$exit = 1;
  	}
  	@rawlines = ();

  	@lines = ();

  }
  
  exit($exit);
  
  sub top_of_kernel_tree {

  	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) = @_;
  
  	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;
  }

  sub copy_spacing {

  	(my $res = shift) =~ tr/\t/ /c;

  	return $res;
  }

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

  my $sanitise_quote = '';
  
  sub sanitise_line_reset {
  	my ($in_comment) = @_;
  
  	if ($in_comment) {
  		$sanitise_quote = '*/';
  	} else {
  		$sanitise_quote = '';
  	}
  }

  sub sanitise_line {
  	my ($line) = @_;
  
  	my $res = '';
  	my $l = '';

  	my $qlen = 0;

  	my $off = 0;
  	my $c;

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

  		}

  		if ($sanitise_quote eq '*/' && substr($line, $off, 2) eq '*/') {

  			$sanitise_quote = '';
  			substr($res, $off, 2, "$;$;");
  			$off++;
  			next;

  		}

  		if ($sanitise_quote eq '' && substr($line, $off, 2) eq '//') {
  			$sanitise_quote = '//';
  
  			substr($res, $off, 2, $sanitise_quote);
  			$off++;
  			next;
  		}

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

  		}

  		# Regular quotes.
  		if ($c eq "'" || $c eq '"') {
  			if ($sanitise_quote eq '') {
  				$sanitise_quote = $c;

  				substr($res, $off, 1, $c);
  				next;
  			} elsif ($sanitise_quote eq $c) {
  				$sanitise_quote = '';
  			}
  		}

  		#print "c<$c> SQ<$sanitise_quote>
  ";

  		if ($off != 0 && $sanitise_quote eq '*/' && $c ne "\t") {
  			substr($res, $off, 1, $;);

  		} elsif ($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);
  		}

  	}

  	if ($sanitise_quote eq '//') {
  		$sanitise_quote = '';
  	}

  	# The pathname on a #include may be surrounded by '<' and '>'.

  	if ($res =~ /^.\s*\#\s*include\s+\<(.*)\>/) {

  		my $clean = 'X' x length($1);
  		$res =~ s@\<.*\>@<$clean>@;
  
  	# The whole of a #error is a string.

  	} elsif ($res =~ /^.\s*\#\s*(?:error|warning)\s+(.*)\b/) {

  		my $clean = 'X' x length($1);

  		$res =~ s@(\#\s*(?:error|warning)\s+).*@$1$clean@;

  	}

  	return $res;
  }

  sub ctx_statement_block {
  	my ($linenr, $remain, $off) = @_;
  	my $line = $linenr - 1;
  	my $blk = '';
  	my $soff = $off;
  	my $coff = $off - 1;

  	my $coff_set = 0;

  	my $loff = 0;

  	my $type = '';
  	my $level = 0;

  	my @stack = ();

  	my $p;

  	my $c;
  	my $len = 0;

  
  	my $remainder;

  	while (1) {

  		@stack = (['', 0]) if ($#stack == -1);

  		#warn "CSB: blk<$blk> remain<$remain>
  ";

  		# If we are about to drop off the end, pull in more
  		# context.
  		if ($off >= $len) {
  			for (; $remain > 0; $line++) {

  				last if (!defined $lines[$line]);

  				next if ($lines[$line] =~ /^-/);

  				$remain--;

  				$loff = $len;

  				$blk .= $lines[$line] . "
  ";

  				$len = length($blk);
  				$line++;
  				last;
  			}
  			# Bail if there is no further context.
  			#warn "CSB: blk<$blk> off<$off> len<$len>
  ";

  			if ($off >= $len) {

  				last;
  			}
  		}

  		$p = $c;

  		$c = substr($blk, $off, 1);

  		$remainder = substr($blk, $off);

  		#warn "CSB: c<$c> type<$type> level<$level> remainder<$remainder> coff_set<$coff_set>
  ";

  
  		# Handle nested #if/#else.
  		if ($remainder =~ /^#\s*(?:ifndef|ifdef|if)\s/) {
  			push(@stack, [ $type, $level ]);
  		} elsif ($remainder =~ /^#\s*(?:else|elif)\b/) {
  			($type, $level) = @{$stack[$#stack - 1]};
  		} elsif ($remainder =~ /^#\s*endif\b/) {
  			($type, $level) = @{pop(@stack)};
  		}

  		# Statement ends at the ';' or a close '}' at the
  		# outermost level.
  		if ($level == 0 && $c eq ';') {
  			last;
  		}

  		# An else is really a conditional as long as its not else if

  		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>
  ";
  			#warn "[" . substr($blk, $soff, $coff - $soff + 1) . "]
  ";

  		}

  		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;

  				$coff_set = 1;
  				#warn "CSB: mark coff<$coff>
  ";

  			}
  		}
  		if (($type eq '' || $type eq '{') && $c eq '{') {
  			$level++;
  			$type = '{';
  		}
  		if ($type eq '{' && $c eq '}') {
  			$level--;
  			$type = ($level != 0)? '{' : '';
  
  			if ($level == 0) {
  				last;
  			}
  		}
  		$off++;
  	}

  	# We are truly at the end, so shuffle to the next line.

  	if ($off == $len) {

  		$loff = $len + 1;

  		$line++;
  		$remain--;
  	}

  
  	my $statement = substr($blk, $soff, $off - $soff + 1);
  	my $condition = substr($blk, $soff, $coff - $soff + 1);
  
  	#warn "STATEMENT<$statement>
  ";
  	#warn "CONDITION<$condition>
  ";

  	#print "coff<$coff> soff<$off> loff<$loff>
  ";

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

  sub statement_lines {
  	my ($stmt) = @_;
  
  	# Strip the diff line prefixes and rip blank lines at start and end.
  	$stmt =~ s/(^|
  )./$1/g;
  	$stmt =~ s/^\s*//;
  	$stmt =~ s/\s*$//;
  
  	my @stmt_lines = ($stmt =~ /
  /g);
  
  	return $#stmt_lines + 2;
  }
  
  sub statement_rawlines {
  	my ($stmt) = @_;
  
  	my @stmt_lines = ($stmt =~ /
  /g);
  
  	return $#stmt_lines + 2;
  }
  
  sub statement_block_size {
  	my ($stmt) = @_;
  
  	$stmt =~ s/(^|
  )./$1/g;
  	$stmt =~ s/^\s*{//;
  	$stmt =~ s/}\s*$//;
  	$stmt =~ s/^\s*//;
  	$stmt =~ s/\s*$//;
  
  	my @stmt_lines = ($stmt =~ /
  /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;
  	}
  }

  sub ctx_statement_full {
  	my ($linenr, $remain, $off) = @_;
  	my ($statement, $condition, $level);
  
  	my (@chunks);

  	# Grab the first conditional/block pair.

  	($statement, $condition, $linenr, $remain, $off, $level) =
  				ctx_statement_block($linenr, $remain, $off);

  	#print "F: c<$condition> s<$statement> remain<$remain>
  ";

  	push(@chunks, [ $condition, $statement ]);
  	if (!($remain > 0 && $condition =~ /^\s*(?:
  [+-])?\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.

  	for (;;) {

  		($statement, $condition, $linenr, $remain, $off, $level) =
  				ctx_statement_block($linenr, $remain, $off);

  		#print "C: c<$condition> s<$statement> remain<$remain>
  ";

  		last if (!($remain > 0 && $condition =~ /^(?:\s*
  [+-])*\s*(?:else|do)\b/s));

  		#print "C: push
  ";
  		push(@chunks, [ $condition, $statement ]);

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

  }

  sub ctx_block_get {

  	my ($linenr, $remain, $outer, $open, $close, $off) = @_;

  	my $line;
  	my $start = $linenr - 1;

  	my $blk = '';
  	my @o;
  	my @c;
  	my @res = ();

  	my $level = 0;

  	my @stack = ($level);

  	for ($line = $start; $remain > 0; $line++) {
  		next if ($rawlines[$line] =~ /^-/);
  		$remain--;
  
  		$blk .= $rawlines[$line];

  
  		# Handle nested #if/#else.
  		if ($rawlines[$line] =~ /^.\s*#\s*(?:ifndef|ifdef|if)\s/) {
  			push(@stack, $level);
  		} elsif ($rawlines[$line] =~ /^.\s*#\s*(?:else|elif)\b/) {
  			$level = $stack[$#stack - 1];
  		} elsif ($rawlines[$line] =~ /^.\s*#\s*endif\b/) {
  			$level = pop(@stack);
  		}

  		foreach my $c (split(//, $rawlines[$line])) {
  			##print "C<$c>L<$level><$open$close>O<$off>
  ";
  			if ($off > 0) {
  				$off--;
  				next;
  			}

  			if ($c eq $close && $level > 0) {
  				$level--;
  				last if ($level == 0);
  			} elsif ($c eq $open) {
  				$level++;
  			}
  		}

  		if (!$outer || $level <= 1) {

  			push(@res, $rawlines[$line]);

  		}

  		last if ($level == 0);

  	}

  	return ($level, @res);

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

  	my ($level, @r) = ctx_block_get($linenr, $remain, 1, '{', '}', 0);
  	return @r;

  }
  sub ctx_block {
  	my ($linenr, $remain) = @_;

  	my ($level, @r) = ctx_block_get($linenr, $remain, 0, '{', '}', 0);
  	return @r;

  }
  sub ctx_statement {

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

  	my ($linenr, $remain) = @_;

  	return ctx_block_get($linenr, $remain, 0, '{', '}', 0);

  }

  sub ctx_statement_level {
  	my ($linenr, $remain, $off) = @_;
  
  	return ctx_block_get($linenr, $remain, 0, '(', ')', $off);
  }

  
  sub ctx_locate_comment {
  	my ($first_line, $end_line) = @_;
  
  	# Catch a comment on the end of the line itself.

  	my ($current_comment) = ($rawlines[$end_line - 1] =~ m@.*(/\*.*\*/)\s*(?:\\\s*)?$@);

  	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++) {

  		my $line = $rawlines[$linenr - 1];
  		#warn "           $line
  ";

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

  	##print "LINE: $rawlines[$end_line - 1 ]
  ";

  	##print "CMMT: $cmt
  ";
  
  	return ($cmt ne '');
  }

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

  sub cat_vet {
  	my ($vet) = @_;
  	my ($res, $coded);

  	$res = '';
  	while ($vet =~ /([^[:cntrl:]]*)([[:cntrl:]]|$)/g) {
  		$res .= $1;
  		if ($2 ne '') {
  			$coded = sprintf("^%c", unpack('C', $2) + 64);
  			$res .= $coded;

  		}
  	}

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

  	return $res;

  }

  my $av_preprocessor = 0;

  my $av_pending;

  my @av_paren_type;

  my $av_pend_colon;

  
  sub annotate_reset {
  	$av_preprocessor = 0;

  	$av_pending = '_';
  	@av_paren_type = ('E');

  	$av_pend_colon = 'O';

  }

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

  	my $res;

  	my $var = '_' x length($stream);

  	my $cur = $stream;

  	print "$stream
  " if ($dbg_values > 1);

  	while (length($cur)) {

  		@av_paren_type = ('E') if ($#av_paren_type < 0);

  		print " <" . join('', @av_paren_type) .

  				"> <$type> <$av_pending>" if ($dbg_values > 1);

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

  			print "WS($1)
  " if ($dbg_values > 1);
  			if ($1 =~ /
  / && $av_preprocessor) {

  				$type = pop(@av_paren_type);

  				$av_preprocessor = 0;

  			}

  		} elsif ($cur =~ /^($Type)\s*(?:$Ident|,|\)|\()/) {

  			print "DECLARE($1)
  " if ($dbg_values > 1);

  			$type = 'T';

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

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

  			print "DEFINE($1,$2)
  " if ($dbg_values > 1);

  			$av_preprocessor = 1;

  			push(@av_paren_type, $type);
  			if ($2 ne '') {
  				$av_pending = 'N';
  			}
  			$type = 'E';

  		} elsif ($cur =~ /^(\#\s*(?:undef\s*$Ident|include\b))/o) {

  			print "UNDEF($1)
  " if ($dbg_values > 1);
  			$av_preprocessor = 1;
  			push(@av_paren_type, $type);

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

  			print "PRE_START($1)
  " if ($dbg_values > 1);

  			$av_preprocessor = 1;

  
  			push(@av_paren_type, $type);
  			push(@av_paren_type, $type);

  			$type = 'E';

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

  			print "PRE_RESTART($1)
  " if ($dbg_values > 1);
  			$av_preprocessor = 1;
  
  			push(@av_paren_type, $av_paren_type[$#av_paren_type]);

  			$type = 'E';

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

  			print "PRE_END($1)
  " 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);

  			$type = 'E';

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

  			print "PRECONT($1)
  " if ($dbg_values > 1);

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

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

  			print "SIZEOF($1)
  " if ($dbg_values > 1);

  			if (defined $2) {

  				$av_pending = 'V';

  			}
  			$type = 'N';

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

  			print "COND($1)
  " if ($dbg_values > 1);

  			$av_pending = 'E';

  			$type = 'N';

  		} elsif ($cur =~/^(case)/o) {
  			print "CASE($1)
  " if ($dbg_values > 1);
  			$av_pend_colon = 'C';
  			$type = 'N';

  		} elsif ($cur =~/^(return|else|goto|typeof|__typeof__)\b/o) {

  			print "KEYWORD($1)
  " if ($dbg_values > 1);

  			$type = 'N';
  
  		} elsif ($cur =~ /^(\()/o) {

  			print "PAREN('$1')
  " if ($dbg_values > 1);

  			push(@av_paren_type, $av_pending);
  			$av_pending = '_';

  			$type = 'N';
  
  		} elsif ($cur =~ /^(\))/o) {

  			my $new_type = pop(@av_paren_type);
  			if ($new_type ne '_') {
  				$type = $new_type;

  				print "PAREN('$1') -> $type
  "
  							if ($dbg_values > 1);

  			} else {

  				print "PAREN('$1')
  " if ($dbg_values > 1);

  			}

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

  			print "FUNC($1)
  " if ($dbg_values > 1);

  			$type = 'V';

  			$av_pending = 'V';

  		} elsif ($cur =~ /^($Ident\s*):(?:\s*\d+\s*(,|=|;))?/) {
  			if (defined $2 && $type eq 'C' || $type eq 'T') {

  				$av_pend_colon = 'B';

  			} elsif ($type eq 'E') {
  				$av_pend_colon = 'L';

  			}
  			print "IDENT_COLON($1,$type>$av_pend_colon)
  " if ($dbg_values > 1);
  			$type = 'V';

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

  			print "IDENT($1)
  " if ($dbg_values > 1);

  			$type = 'V';
  
  		} elsif ($cur =~ /^($Assignment)/o) {

  			print "ASSIGN($1)
  " if ($dbg_values > 1);

  			$type = 'N';

  		} elsif ($cur =~/^(;|{|})/) {

  			print "END($1)
  " if ($dbg_values > 1);

  			$type = 'E';

  			$av_pend_colon = 'O';

  		} elsif ($cur =~/^(,)/) {
  			print "COMMA($1)
  " if ($dbg_values > 1);
  			$type = 'C';

  		} elsif ($cur =~ /^(\?)/o) {
  			print "QUESTION($1)
  " if ($dbg_values > 1);
  			$type = 'N';
  
  		} elsif ($cur =~ /^(:)/o) {
  			print "COLON($1,$av_pend_colon)
  " 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';

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

  			print "CLOSE($1)
  " if ($dbg_values > 1);

  			$type = 'N';

  		} elsif ($cur =~ /^(-(?![->])|\+(?!\+)|\*|\&\&|\&)/o) {

  			my $variant;
  
  			print "OPV($1)
  " if ($dbg_values > 1);
  			if ($type eq 'V') {
  				$variant = 'B';
  			} else {
  				$variant = 'U';
  			}
  
  			substr($var, length($res), 1, $variant);
  			$type = 'N';

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

  			print "OP($1)
  " if ($dbg_values > 1);

  			if ($1 ne '++' && $1 ne '--') {
  				$type = 'N';
  			}
  
  		} elsif ($cur =~ /(^.)/o) {

  			print "C($1)
  " if ($dbg_values > 1);

  		}
  		if (defined $1) {
  			$cur = substr($cur, length($1));
  			$res .= $type x length($1);
  		}

  	}

  	return ($res, $var);

  }

  sub possible {

  	my ($possible, $line) = @_;

  	my $notPermitted = qr{(?:

  		^(?:
  			$Modifier|
  			$Storage|
  			$Type|

  			DEFINE_\S+
  		)$|
  		^(?:

  			goto|
  			return|
  			case|
  			else|
  			asm|__asm__|
  			do

  		)(?:\s|$)|

  		^(?:typedef|struct|enum)\b

  	    )}x;
  	warn "CHECK<$possible> ($line)
  " if ($dbg_possible > 2);
  	if ($possible !~ $notPermitted) {

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

  			for my $modifier (split(' ', $possible)) {

  				if ($modifier !~ $notPermitted) {
  					warn "MODIFIER: $modifier ($possible) ($line)
  " if ($dbg_possible);
  					push(@modifierList, $modifier);
  				}

  			}

  
  		} else {
  			warn "POSSIBLE: $possible ($line)
  " if ($dbg_possible);
  			push(@typeList, $possible);
  		}

  		build_types();

  	} else {
  		warn "NOTPOSS: $possible ($line)
  " if ($dbg_possible > 1);

  	}
  }

  my $prefix = '';

  sub report {

  	if (defined $tst_only && $_[0] !~ /\Q$tst_only\E/) {
  		return 0;
  	}

  	my $line = $prefix . $_[0];
  
  	$line = (split('
  ', $line))[0] . "
  " if ($terse);

  	push(our @report, $line);

  
  	return 1;

  }
  sub report_dump {

  	our @report;

  }

  sub ERROR {

  	if (report("ERROR: $_[0]
  ")) {
  		our $clean = 0;
  		our $cnt_error++;
  	}

  }
  sub WARN {

  	if (report("WARNING: $_[0]
  ")) {
  		our $clean = 0;
  		our $cnt_warn++;
  	}

  }
  sub CHK {

  	if ($check && report("CHECK: $_[0]
  ")) {

  		our $clean = 0;
  		our $cnt_chk++;
  	}

  }

  sub check_absolute_file {
  	my ($absolute, $herecurr) = @_;
  	my $file = $absolute;
  
  	##print "absolute<$absolute>
  ";
  
  	# See if any suffix of this path is a path within the tree.
  	while ($file =~ s@^[^/]*/@@) {
  		if (-f "$root/$file") {
  			##print "file<$file>
  ";
  			last;
  		}
  	}
  	if (! -f _)  {
  		return 0;
  	}
  
  	# It is, so see if the prefix is acceptable.
  	my $prefix = $absolute;
  	substr($prefix, -length($file)) = '';
  
  	##print "prefix<$prefix>
  ";
  	if ($prefix ne ".../") {
  		WARN("use relative pathname instead of absolute in changelog text
  " . $herecurr);
  	}
  }

  sub process {
  	my $filename = shift;

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

  	my $prevrawline="";

  	my $stashline="";

  	my $stashrawline="";

  	my $length;

  	my $indent;
  	my $previndent=0;
  	my $stashindent=0;

  	our $clean = 1;

  	my $signoff = 0;
  	my $is_patch = 0;

  	our @report = ();

  	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;
  	my $realcnt = 0;
  	my $here = '';
  	my $in_comment = 0;

  	my $comment_edge = 0;

  	my $first_line = 0;

  	my $p1_prefix = '';

  	my $prev_values = 'E';
  
  	# suppression flags

  	my %suppress_ifbraces;

  	my %suppress_whiletrailers;

  	my %suppress_export;

  	# Pre-scan the patch sanitizing the lines.

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

  	#

  	my @setup_docs = ();
  	my $setup_docs = 0;

  
  	sanitise_line_reset();

  	my $line;
  	foreach my $rawline (@rawlines) {

  		$linenr++;
  		$line = $rawline;

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

  			$setup_docs = 0;
  			if ($1 =~ m@Documentation/kernel-parameters.txt$@) {
  				$setup_docs = 1;
  			}

  			#next;
  		}
  		if ($rawline=~/^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@/) {
  			$realline=$1-1;
  			if (defined $2) {
  				$realcnt=$3+1;
  			} else {
  				$realcnt=1+1;
  			}

  			$in_comment = 0;

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

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

  				last if (!defined $rawlines[$ln - 1]);

  				if ($rawlines[$ln - 1] =~ m@(/\*|\*/)@ &&
  				    $rawlines[$ln - 1] !~ m@"[^"]*(?:/\*|\*/)[^"]*"@) {
  					($edge) = $1;
  					last;
  				}

  			}
  			if (defined $edge && $edge eq '*/') {
  				$in_comment = 1;
  			}
  
  			# Guestimate if this is a continuing comment.  If this
  			# is the start of a diff block and this line starts
  			# ' *' then it is very likely a comment.
  			if (!defined $edge &&

  			    $rawlines[$linenr] =~ m@^.\s*(?:\*\*+| \*)(?:\s|$)@)

  			{
  				$in_comment = 1;
  			}
  
  			##print "COMMENT:$in_comment edge<$edge> $rawline
  ";
  			sanitise_line_reset($in_comment);

  		} elsif ($realcnt && $rawline =~ /^(?:\+| |$)/) {

  			# Standardise the strings and chars within the input to

  			# simplify matching -- only bother with positive lines.

  			$line = sanitise_line($rawline);

  		}

  		push(@lines, $line);
  
  		if ($realcnt > 1) {
  			$realcnt-- if ($line =~ /^(?:\+| |$)/);
  		} else {
  			$realcnt = 0;
  		}
  
  		#print "==>$rawline
  ";
  		#print "-->$line
  ";

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

  	$prefix = '';

  	$realcnt = 0;
  	$linenr = 0;

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

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

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

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

  			$is_patch = 1;

  			$first_line = $linenr + 1;

  			$realline=$1-1;
  			if (defined $2) {
  				$realcnt=$3+1;
  			} else {
  				$realcnt=1+1;
  			}

  			annotate_reset();

  			$prev_values = 'E';

  			%suppress_ifbraces = ();

  			%suppress_whiletrailers = ();

  			%suppress_export = ();

  			next;

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

  		} elsif ($line =~ /^( |\+|$)/) {

  			$realline++;

  			$realcnt-- if ($realcnt != 0);

  			# Measure the line length and indent.

  			($length, $indent) = line_stats($rawline);

  
  			# Track the previous line.
  			($prevline, $stashline) = ($stashline, $line);
  			($previndent, $stashindent) = ($stashindent, $indent);

  			($prevrawline, $stashrawline) = ($stashrawline, $rawline);

  			#warn "line<$line>
  ";

  		} elsif ($realcnt == 1) {
  			$realcnt--;

  		}

  		my $hunk_line = ($realcnt != 0);

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

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

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

  
  		# extract the filename as it passes
  		if ($line=~/^\+\+\+\s+(\S+)/) {
  			$realfile = $1;

  			$realfile =~ s@^([^/]*)/@@;
  
  			$p1_prefix = $1;

  			if (!$file && $tree && $p1_prefix ne '' &&
  			    -e "$root/$p1_prefix") {

  				WARN("patch prefix '$p1_prefix' exists, appears to be a -p0 patch
  ");
  			}

  			if ($realfile =~ m@^include/asm/@) {

  				ERROR("do not modify files in include/asm, change architecture specific files in include/asm-<architecture>
  " . "$here$rawline
  ");
  			}
  			next;
  		}

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

  		my $hereline = "$here
  $rawline
  ";
  		my $herecurr = "$here
  $rawline
  ";
  		my $hereprev = "$here
  $prevrawline
  $rawline
  ";

  		$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.
  			$signoff++;

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

  				WARN("Signed-off-by: is the preferred form
  " .
  					$herecurr);

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

  				WARN("space required after Signed-off-by:
  " .

  					$herecurr);

  			}
  		}

  # Check for wrappage within a valid hunk of the file

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

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

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

  		}

  # Check for absolute kernel paths.
  		if ($tree) {
  			while ($line =~ m{(?:^|\s)(/\S*)}g) {
  				my $file = $1;
  
  				if ($file =~ m{^(.*?)(?::\d+)+:?$} &&
  				    check_absolute_file($1, $herecurr)) {
  					#
  				} else {
  					check_absolute_file($file, $herecurr);
  				}
  			}
  		}

  # UTF-8 regex found at http://www.w3.org/International/questions/qa-forms-utf-8.en.php
  		if (($realfile =~ /^$/ || $line =~ /^\+/) &&

  		    $rawline !~ m/^$UTF8*$/) {
  			my ($utf8_prefix) = ($rawline =~ /^($UTF8*)/);
  
  			my $blank = copy_spacing($rawline);
  			my $ptr = substr($blank, 0, length($utf8_prefix)) . "^";
  			my $hereptr = "$hereline$ptr
  ";
  
  			ERROR("Invalid UTF-8, patch and commit message should be encoded in UTF-8
  " . $hereptr);

  		}

  # ignore non-hunk lines and lines being removed
  		next if (!$hunk_line || $line =~ /^-/);

  #trailing whitespace

  		if ($line =~ /^\+.*\015/) {

  			my $herevet = "$here
  " . cat_vet($rawline) . "
  ";

  			ERROR("DOS line endings
  " . $herevet);

  		} elsif ($rawline =~ /^\+.*\S\s+$/ || $rawline =~ /^\+\s+$/) {
  			my $herevet = "$here
  " . cat_vet($rawline) . "
  ";

  			ERROR("trailing whitespace
  " . $herevet);

  		}

  # check for Kconfig help text having a real description
  		if ($realfile =~ /Kconfig/ &&
  		    $line =~ /\+?\s*(---)?help(---)?$/) {
  			my $length = 0;
  			for (my $l = $linenr; defined($lines[$l]); $l++) {
  				my $f = $lines[$l];
  				$f =~ s/#.*//;
  				$f =~ s/^\s+//;
  				next if ($f =~ /^$/);
  				last if ($f =~ /^\s*config\s/);
  				$length++;
  			}
  			WARN("please write a paragraph that describes the config symbol fully
  " . $herecurr) if ($length < 4);
  		}

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

  #80 column limit

  		if ($line =~ /^\+/ && $prevrawline !~ /\/\*\*/ &&

  		    $rawline !~ /^.\s*\*\s*\@$Ident\s/ &&

  		    $line !~ /^\+\s*$logFunctions\s*\(\s*(?:KERN_\S+\s*)?"[X\t]*"\s*(?:,|\)\s*;)\s*$/ &&

  		    $length > 80)

  		{

  			WARN("line over 80 characters
  " . $herecurr);

  		}

  # check for spaces before a quoted newline
  		if ($rawline =~ /^.*\".*\s\
  /) {
  			WARN("unnecessary whitespace before a quoted newline
  " . $herecurr);
  		}

  # check for adding lines without a newline.
  		if ($line =~ /^\+/ && defined $lines[$linenr] && $lines[$linenr] =~ /^\\ No newline at end of file/) {
  			WARN("adding a line without newline at end of file
  " . $herecurr);
  		}

  # Blackfin: use hi/lo macros
  		if ($realfile =~ m@arch/blackfin/.*\.S$@) {
  			if ($line =~ /\.[lL][[:space:]]*=.*&[[:space:]]*0x[fF][fF][fF][fF]/) {
  				my $herevet = "$here
  " . cat_vet($line) . "
  ";
  				ERROR("use the LO() macro, not (... & 0xFFFF)
  " . $herevet);
  			}
  			if ($line =~ /\.[hH][[:space:]]*=.*>>[[:space:]]*16/) {
  				my $herevet = "$here
  " . cat_vet($line) . "
  ";
  				ERROR("use the HI() macro, not (... >> 16)
  " . $herevet);
  			}
  		}

  # check we are in a valid source file C or perl if not then ignore this hunk
  		next if ($realfile !~ /\.(h|c|pl)$/);

  
  # at the beginning of a line any tabs must come first and anything
  # more than 8 must use tabs.

  		if ($rawline =~ /^\+\s* \t\s*\S/ ||
  		    $rawline =~ /^\+\s*        \s*/) {
  			my $herevet = "$here
  " . cat_vet($rawline) . "
  ";

  			ERROR("code indent should use tabs where possible
  " . $herevet);

  		}

  # check for space before tabs.
  		if ($rawline =~ /^\+/ && $rawline =~ / \t/) {
  			my $herevet = "$here
  " . cat_vet($rawline) . "
  ";
  			WARN("please, no space before tabs
  " . $herevet);
  		}

  # check we are in a valid C source file if not then ignore this hunk
  		next if ($realfile !~ /\.(h|c)$/);

  # check for RCS/CVS revision markers

  		if ($rawline =~ /^\+.*\$(Revision|Log|Id)(?:\$|)/) {

  			WARN("CVS style keyword markers, these will _not_ be updated
  ". $herecurr);
  		}

  # Blackfin: don't use __builtin_bfin_[cs]sync
  		if ($line =~ /__builtin_bfin_csync/) {
  			my $herevet = "$here
  " . cat_vet($line) . "
  ";
  			ERROR("use the CSYNC() macro in asm/blackfin.h
  " . $herevet);
  		}
  		if ($line =~ /__builtin_bfin_ssync/) {
  			my $herevet = "$here
  " . cat_vet($line) . "
  ";
  			ERROR("use the SSYNC() macro in asm/blackfin.h
  " . $herevet);
  		}

  # Check for potential 'bare' types

  		my ($stat, $cond, $line_nr_next, $remain_next, $off_next,
  		    $realline_next);

  		if ($realcnt && $line =~ /.\s*\S/) {

  			($stat, $cond, $line_nr_next, $remain_next, $off_next) =

  				ctx_statement_block($linenr, $realcnt, 0);

  			$stat =~ s/
  ./
   /g;
  			$cond =~ s/
  ./
   /g;

  			# Find the real next line.
  			$realline_next = $line_nr_next;
  			if (defined $realline_next &&
  			    (!defined $lines[$realline_next - 1] ||
  			     substr($lines[$realline_next - 1], $off_next) =~ /^\s*$/)) {
  				$realline_next++;
  			}

  			my $s = $stat;
  			$s =~ s/{.*$//s;

  			# Ignore goto labels.

  			if ($s =~ /$Ident:\*$/s) {

  
  			# Ignore functions being called

  			} elsif ($s =~ /^.\s*$Ident\s*\(/s) {

  			} elsif ($s =~ /^.\s*else\b/s) {

  			# declarations always start with types

  			} elsif ($prev_values eq 'E' && $s =~ /^.\s*(?:$Storage\s+)?(?:$Inline\s+)?(?:const\s+)?((?:\s*$Ident)+?)\b(?:\s+$Sparse)?\s*\**\s*(?:$Ident|\(\*[^\)]*\))(?:\s*$Modifier)?\s*(?:;|=|,|\()/s) {

  				my $type = $1;
  				$type =~ s/\s+/ /g;
  				possible($type, "A:" . $s);

  			# definitions in global scope can only start with types

  			} elsif ($s =~ /^.(?:$Storage\s+)?(?:$Inline\s+)?(?:const\s+)?($Ident)\b\s*(?!:)/s) {

  				possible($1, "B:" . $s);

  			}

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

  			while ($s =~ /\(($Ident)(?:\s+$Sparse)*[\s\*]+\s*\)/sg) {

  				possible($1, "C:" . $s);

  			}
  
  			# Check for any sort of function declaration.
  			# int foo(something bar, other baz);
  			# void (*store_gdt)(x86_descr_ptr *);

  			if ($prev_values eq 'E' && $s =~ /^(.(?:typedef\s*)?(?:(?:$Storage|$Inline)\s*)*\s*$Type\s*(?:\b$Ident|\(\*\s*$Ident\))\s*)\(/s) {

  				my ($name_len) = length($1);

  				my $ctx = $s;

  				substr($ctx, 0, $name_len + 1, '');

  				$ctx =~ s/\)[^\)]*$//;

  				for my $arg (split(/\s*,\s*/, $ctx)) {

  					if ($arg =~ /^(?:const\s+)?($Ident)(?:\s+$Sparse)*\s*\**\s*(:?\b$Ident)?$/s || $arg =~ /^($Ident)$/s) {

  						possible($1, "D:" . $s);

  					}
  				}

  			}

  		}

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

  # Check for switch () and associated case and default
  # statements should be at the same indent.

  		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
  ";
  					$sep = '';
  				} else {
  					$sep = "[...]
  ";
  				}
  			}
  			if ($err ne '') {

  				ERROR("switch and case should be at the same indent
  $hereline$err");

  			}
  		}
  
  # 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 !~ /^.\s*\#/) {

  			my $pre_ctx = "$1$2";

  			my ($level, @ctx) = ctx_statement_level($linenr, $realcnt, 0);

  			my $ctx_cnt = $realcnt - $#ctx - 1;
  			my $ctx = join("
  ", @ctx);

  			my $ctx_ln = $linenr;
  			my $ctx_skip = $realcnt;

  			while ($ctx_skip > $ctx_cnt || ($ctx_skip == $ctx_cnt &&
  					defined $lines[$ctx_ln - 1] &&
  					$lines[$ctx_ln - 1] =~ /^-/)) {
  				##print "SKIP<$ctx_skip> CNT<$ctx_cnt>
  ";
  				$ctx_skip-- if (!defined $lines[$ctx_ln - 1] || $lines[$ctx_ln - 1] !~ /^-/);

  				$ctx_ln++;

  			}

  			#print "realcnt<$realcnt> ctx_cnt<$ctx_cnt>
  ";
  			#print "pre<$pre_ctx>
  line<$line>
  ctx<$ctx>
  next<$lines[$ctx_ln - 1]>
  ";

  			if ($ctx !~ /{\s*/ && defined($lines[$ctx_ln -1]) && $lines[$ctx_ln - 1] =~ /^\+\s*{/) {
  				ERROR("that open brace { should be on the previous line
  " .

  					"$here
  $ctx
  $lines[$ctx_ln - 1]
  ");

  			}

  			if ($level == 0 && $pre_ctx !~ /}\s*while\s*\($/ &&
  			    $ctx =~ /\)\s*\;\s*$/ &&
  			    defined $lines[$ctx_ln - 1])
  			{

  				my ($nlength, $nindent) = line_stats($lines[$ctx_ln - 1]);
  				if ($nindent > $indent) {

  					WARN("trailing semicolon indicates no statements, indent implies otherwise
  " .

  						"$here
  $ctx
  $lines[$ctx_ln - 1]
  ");

  				}
  			}

  		}

  # Check relative indent for conditionals and blocks.
  		if ($line =~ /\b(?:(?:if|while|for)\s*\(|do\b)/ && $line !~ /^.\s*#/ && $line !~ /\}\s*while\s*/) {
  			my ($s, $c) = ($stat, $cond);
  
  			substr($s, 0, length($c), '');
  
  			# Make sure we remove the line prefixes as we have
  			# none on the first line, and are going to readd them
  			# where necessary.
  			$s =~ s/
  ./
  /gs;
  
  			# Find out how long the conditional actually is.

  			my @newlines = ($c =~ /
  /gs);
  			my $cond_lines = 1 + $#newlines;

  
  			# We want to check the first line inside the block
  			# starting at the end of the conditional, so remove:
  			#  1) any blank line termination
  			#  2) any opening brace { on end of the line
  			#  3) any do (...) {
  			my $continuation = 0;
  			my $check = 0;
  			$s =~ s/^.*\bdo\b//;
  			$s =~ s/^\s*{//;
  			if ($s =~ s/^\s*\\//) {
  				$continuation = 1;
  			}

  			if ($s =~ s/^\s*?
  //) {

  				$check = 1;
  				$cond_lines++;
  			}
  
  			# Also ignore a loop construct at the end of a
  			# preprocessor statement.
  			if (($prevline =~ /^.\s*#\s*define\s/ ||
  			    $prevline =~ /\\\s*$/) && $continuation == 0) {
  				$check = 0;
  			}

  			my $cond_ptr = -1;

  			$continuation = 0;

  			while ($cond_ptr != $cond_lines) {
  				$cond_ptr = $cond_lines;

  				# If we see an #else/#elif then the code
  				# is not linear.
  				if ($s =~ /^\s*\#\s*(?:else|elif)/) {
  					$check = 0;
  				}

  				# Ignore:
  				#  1) blank lines, they should be at 0,
  				#  2) preprocessor lines, and
  				#  3) labels.

  				if ($continuation ||
  				    $s =~ /^\s*?
  / ||

  				    $s =~ /^\s*#\s*?/ ||
  				    $s =~ /^\s*$Ident\s*:/) {

  					$continuation = ($s =~ /^.*?\\
  /) ? 1 : 0;

  					if ($s =~ s/^.*?
  //) {
  						$cond_lines++;
  					}

  				}

  			}
  
  			my (undef, $sindent) = line_stats("+" . $s);
  			my $stat_real = raw_line($linenr, $cond_lines);
  
  			# Check if either of these lines are modified, else
  			# this is not this patch's fault.
  			if (!defined($stat_real) ||
  			    $stat !~ /^\+/ && $stat_real !~ /^\+/) {
  				$check = 0;
  			}
  			if (defined($stat_real) && $cond_lines > 1) {
  				$stat_real = "[...]
  $stat_real";
  			}

  			#print "line<$line> prevline<$prevline> indent<$indent> sindent<$sindent> check<$check> continuation<$continuation> s<$s> cond_lines<$cond_lines> stat_real<$stat_real> stat<$stat>
  ";

  
  			if ($check && (($sindent % 8) != 0 ||
  			    ($sindent <= $indent && $s ne ''))) {
  				WARN("suspect code indent for conditional statements ($indent, $sindent)
  " . $herecurr . "$stat_real
  ");
  			}
  		}

  		# Track the 'values' across context and added lines.
  		my $opline = $line; $opline =~ s/^./ /;

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

  		$curr_values = $prev_values . $curr_values;

  		if ($dbg_values) {
  			my $outline = $opline; $outline =~ s/\t/ /g;

  			print "$linenr > .$outline
  ";
  			print "$linenr > $curr_values
  ";

  			print "$linenr >  $curr_vars
  ";

  		}

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

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

  # TEST: allow direct testing of the type matcher.

  		if ($dbg_type) {
  			if ($line =~ /^.\s*$Declare\s*$/) {
  				ERROR("TEST: is type
  " . $herecurr);
  			} elsif ($dbg_type > 1 && $line =~ /^.+($Declare)/) {
  				ERROR("TEST: is not type ($1 is)
  ". $herecurr);
  			}

  			next;
  		}

  # TEST: allow direct testing of the attribute matcher.
  		if ($dbg_attr) {

  			if ($line =~ /^.\s*$Modifier\s*$/) {

  				ERROR("TEST: is attr
  " . $herecurr);

  			} elsif ($dbg_attr > 1 && $line =~ /^.+($Modifier)/) {

  				ERROR("TEST: is not attr ($1 is)
  ". $herecurr);
  			}
  			next;
  		}

  # check for initialisation to aggregates open brace on the next line

  		if ($line =~ /^.\s*{/ &&
  		    $prevline =~ /(?:^|[^=])=\s*$/) {

  			ERROR("that open brace { should be on the previous line
  " . $hereprev);

  		}

  #
  # Checks which are anchored on the added line.
  #
  
  # check for malformed paths in #include statements (uses RAW line)

  		if ($rawline =~ m{^.\s*\#\s*include\s+[<"](.*)[">]}) {

  			my $path = $1;
  			if ($path =~ m{//}) {

  				ERROR("malformed #include filename
  " .
  					$herecurr);

  			}