1#!/usr/bin/perl -w
   2# (c) 2001, Dave Jones. (the file handling bit)
   3# (c) 2005, Joel Schopp <jschopp@austin.ibm.com> (the ugly bit)
   4# (c) 2007,2008, Andy Whitcroft <apw@uk.ibm.com> (new conditions, test suite)
   5# (c) 2008-2010 Andy Whitcroft <apw@canonical.com>
   6# Licensed under the terms of the GNU GPL License version 2
   7
   8use strict;
 
   9use POSIX;
  10use File::Basename;
  11use Cwd 'abs_path';
  12use Term::ANSIColor qw(:constants);
  13
  14my $P = $0;
  15my $D = dirname(abs_path($P));
  16
  17my $V = '0.32';
  18
  19use Getopt::Long qw(:config no_auto_abbrev);
  20
  21my $quiet = 0;
  22my $tree = 1;
  23my $chk_signoff = 1;
  24my $chk_patch = 1;
  25my $tst_only;
  26my $emacs = 0;
  27my $terse = 0;
  28my $showfile = 0;
  29my $file = 0;
  30my $git = 0;
  31my %git_commits = ();
  32my $check = 0;
  33my $check_orig = 0;
  34my $summary = 1;
  35my $mailback = 0;
  36my $summary_file = 0;
  37my $show_types = 0;
  38my $list_types = 0;
  39my $fix = 0;
  40my $fix_inplace = 0;
  41my $root;
  42my %debug;
  43my %camelcase = ();
  44my %use_type = ();
  45my @use = ();
  46my %ignore_type = ();
  47my @ignore = ();
  48my $help = 0;
  49my $configuration_file = ".checkpatch.conf";
  50my $max_line_length = 80;
  51my $ignore_perl_version = 0;
  52my $minimum_perl_version = 5.10.0;
  53my $min_conf_desc_length = 4;
  54my $spelling_file = "$D/spelling.txt";
  55my $codespell = 0;
  56my $codespellfile = "/usr/share/codespell/dictionary.txt";
  57my $conststructsfile = "$D/const_structs.checkpatch";
  58my $color = 1;
 
  59my $allow_c99_comments = 1;
  60
  61sub help {
  62	my ($exitcode) = @_;
  63
  64	print << "EOM";
  65Usage: $P [OPTION]... [FILE]...
  66Version: $V
  67
  68Options:
  69  -q, --quiet                quiet
  70  --no-tree                  run without a kernel tree
  71  --no-signoff               do not check for 'Signed-off-by' line
  72  --patch                    treat FILE as patchfile (default)
  73  --emacs                    emacs compile window format
  74  --terse                    one line per report
  75  --showfile                 emit diffed file position, not input file position
  76  -g, --git                  treat FILE as a single commit or git revision range
  77                             single git commit with:
  78                               <rev>
  79                               <rev>^
  80                               <rev>~n
  81                             multiple git commits with:
  82                               <rev1>..<rev2>
  83                               <rev1>...<rev2>
  84                               <rev>-<count>
  85                             git merges are ignored
  86  -f, --file                 treat FILE as regular source file
  87  --subjective, --strict     enable more subjective tests
  88  --list-types               list the possible message types
  89  --types TYPE(,TYPE2...)    show only these comma separated message types
  90  --ignore TYPE(,TYPE2...)   ignore various comma separated message types
  91  --show-types               show the specific message type in the output
  92  --max-line-length=n        set the maximum line length, if exceeded, warn
  93  --min-conf-desc-length=n   set the min description length, if shorter, warn
  94  --root=PATH                PATH to the kernel tree root
  95  --no-summary               suppress the per-file summary
  96  --mailback                 only produce a report in case of warnings/errors
  97  --summary-file             include the filename in summary
  98  --debug KEY=[0|1]          turn on/off debugging of KEY, where KEY is one of
  99                             'values', 'possible', 'type', and 'attr' (default
 100                             is all off)
 101  --test-only=WORD           report only warnings/errors containing WORD
 102                             literally
 103  --fix                      EXPERIMENTAL - may create horrible results
 104                             If correctable single-line errors exist, create
 105                             "<inputfile>.EXPERIMENTAL-checkpatch-fixes"
 106                             with potential errors corrected to the preferred
 107                             checkpatch style
 108  --fix-inplace              EXPERIMENTAL - may create horrible results
 109                             Is the same as --fix, but overwrites the input
 110                             file.  It's your fault if there's no backup or git
 111  --ignore-perl-version      override checking of perl version.  expect
 112                             runtime errors.
 113  --codespell                Use the codespell dictionary for spelling/typos
 114                             (default:/usr/share/codespell/dictionary.txt)
 115  --codespellfile            Use this codespell dictionary
 116  --color                    Use colors when output is STDOUT (default: on)
 
 
 117  -h, --help, --version      display this help and exit
 118
 119When FILE is - read standard input.
 120EOM
 121
 122	exit($exitcode);
 123}
 124
 125sub uniq {
 126	my %seen;
 127	return grep { !$seen{$_}++ } @_;
 128}
 129
 130sub list_types {
 131	my ($exitcode) = @_;
 132
 133	my $count = 0;
 134
 135	local $/ = undef;
 136
 137	open(my $script, '<', abs_path($P)) or
 138	    die "$P: Can't read '$P' $!\n";
 139
 140	my $text = <$script>;
 141	close($script);
 142
 143	my @types = ();
 144	for ($text =~ /\b(?:(?:CHK|WARN|ERROR)\s*\(\s*"([^"]+)")/g) {
 
 145		push (@types, $_);
 146	}
 147	@types = sort(uniq(@types));
 148	print("#\tMessage type\n\n");
 149	foreach my $type (@types) {
 150		print(++$count . "\t" . $type . "\n");
 151	}
 152
 153	exit($exitcode);
 154}
 155
 156my $conf = which_conf($configuration_file);
 157if (-f $conf) {
 158	my @conf_args;
 159	open(my $conffile, '<', "$conf")
 160	    or warn "$P: Can't find a readable $configuration_file file $!\n";
 161
 162	while (<$conffile>) {
 163		my $line = $_;
 164
 165		$line =~ s/\s*\n?$//g;
 166		$line =~ s/^\s*//g;
 167		$line =~ s/\s+/ /g;
 168
 169		next if ($line =~ m/^\s*#/);
 170		next if ($line =~ m/^\s*$/);
 171
 172		my @words = split(" ", $line);
 173		foreach my $word (@words) {
 174			last if ($word =~ m/^#/);
 175			push (@conf_args, $word);
 176		}
 177	}
 178	close($conffile);
 179	unshift(@ARGV, @conf_args) if @conf_args;
 180}
 181
 
 
 
 
 
 
 
 
 182GetOptions(
 183	'q|quiet+'	=> \$quiet,
 184	'tree!'		=> \$tree,
 185	'signoff!'	=> \$chk_signoff,
 186	'patch!'	=> \$chk_patch,
 187	'emacs!'	=> \$emacs,
 188	'terse!'	=> \$terse,
 189	'showfile!'	=> \$showfile,
 190	'f|file!'	=> \$file,
 191	'g|git!'	=> \$git,
 192	'subjective!'	=> \$check,
 193	'strict!'	=> \$check,
 194	'ignore=s'	=> \@ignore,
 195	'types=s'	=> \@use,
 196	'show-types!'	=> \$show_types,
 197	'list-types!'	=> \$list_types,
 198	'max-line-length=i' => \$max_line_length,
 199	'min-conf-desc-length=i' => \$min_conf_desc_length,
 200	'root=s'	=> \$root,
 201	'summary!'	=> \$summary,
 202	'mailback!'	=> \$mailback,
 203	'summary-file!'	=> \$summary_file,
 204	'fix!'		=> \$fix,
 205	'fix-inplace!'	=> \$fix_inplace,
 206	'ignore-perl-version!' => \$ignore_perl_version,
 207	'debug=s'	=> \%debug,
 208	'test-only=s'	=> \$tst_only,
 209	'codespell!'	=> \$codespell,
 210	'codespellfile=s'	=> \$codespellfile,
 211	'color!'	=> \$color,
 
 
 
 212	'h|help'	=> \$help,
 213	'version'	=> \$help
 214) or help(1);
 215
 216help(0) if ($help);
 217
 218list_types(0) if ($list_types);
 219
 220$fix = 1 if ($fix_inplace);
 221$check_orig = $check;
 222
 223my $exit = 0;
 224
 225if ($^V && $^V lt $minimum_perl_version) {
 226	printf "$P: requires at least perl version %vd\n", $minimum_perl_version;
 227	if (!$ignore_perl_version) {
 228		exit(1);
 229	}
 230}
 231
 232#if no filenames are given, push '-' to read patch from stdin
 233if ($#ARGV < 0) {
 234	push(@ARGV, '-');
 235}
 236
 
 
 
 
 
 
 
 
 
 
 
 
 237sub hash_save_array_words {
 238	my ($hashRef, $arrayRef) = @_;
 239
 240	my @array = split(/,/, join(',', @$arrayRef));
 241	foreach my $word (@array) {
 242		$word =~ s/\s*\n?$//g;
 243		$word =~ s/^\s*//g;
 244		$word =~ s/\s+/ /g;
 245		$word =~ tr/[a-z]/[A-Z]/;
 246
 247		next if ($word =~ m/^\s*#/);
 248		next if ($word =~ m/^\s*$/);
 249
 250		$hashRef->{$word}++;
 251	}
 252}
 253
 254sub hash_show_words {
 255	my ($hashRef, $prefix) = @_;
 256
 257	if (keys %$hashRef) {
 258		print "\nNOTE: $prefix message types:";
 259		foreach my $word (sort keys %$hashRef) {
 260			print " $word";
 261		}
 262		print "\n";
 263	}
 264}
 265
 266hash_save_array_words(\%ignore_type, \@ignore);
 267hash_save_array_words(\%use_type, \@use);
 268
 269my $dbg_values = 0;
 270my $dbg_possible = 0;
 271my $dbg_type = 0;
 272my $dbg_attr = 0;
 273for my $key (keys %debug) {
 274	## no critic
 275	eval "\${dbg_$key} = '$debug{$key}';";
 276	die "$@" if ($@);
 277}
 278
 279my $rpt_cleaners = 0;
 280
 281if ($terse) {
 282	$emacs = 1;
 283	$quiet++;
 284}
 285
 286if ($tree) {
 287	if (defined $root) {
 288		if (!top_of_kernel_tree($root)) {
 289			die "$P: $root: --root does not point at a valid tree\n";
 290		}
 291	} else {
 292		if (top_of_kernel_tree('.')) {
 293			$root = '.';
 294		} elsif ($0 =~ m@(.*)/scripts/[^/]*$@ &&
 295						top_of_kernel_tree($1)) {
 296			$root = $1;
 297		}
 298	}
 299
 300	if (!defined $root) {
 301		print "Must be run from the top-level dir. of a kernel tree\n";
 302		exit(2);
 303	}
 304}
 305
 306my $emitted_corrupt = 0;
 307
 308our $Ident	= qr{
 309			[A-Za-z_][A-Za-z\d_]*
 310			(?:\s*\#\#\s*[A-Za-z_][A-Za-z\d_]*)*
 311		}x;
 312our $Storage	= qr{extern|static|asmlinkage};
 313our $Sparse	= qr{
 314			__user|
 315			__kernel|
 316			__force|
 317			__iomem|
 318			__must_check|
 319			__init_refok|
 320			__kprobes|
 321			__ref|
 322			__rcu|
 323			__private
 324		}x;
 325our $InitAttributePrefix = qr{__(?:mem|cpu|dev|net_|)};
 326our $InitAttributeData = qr{$InitAttributePrefix(?:initdata\b)};
 327our $InitAttributeConst = qr{$InitAttributePrefix(?:initconst\b)};
 328our $InitAttributeInit = qr{$InitAttributePrefix(?:init\b)};
 329our $InitAttribute = qr{$InitAttributeData|$InitAttributeConst|$InitAttributeInit};
 330
 331# Notes to $Attribute:
 332# We need \b after 'init' otherwise 'initconst' will cause a false positive in a check
 333our $Attribute	= qr{
 334			const|
 335			__percpu|
 336			__nocast|
 337			__safe|
 338			__bitwise|
 339			__packed__|
 340			__packed2__|
 341			__naked|
 342			__maybe_unused|
 343			__always_unused|
 344			__noreturn|
 345			__used|
 346			__cold|
 347			__pure|
 348			__noclone|
 349			__deprecated|
 350			__read_mostly|
 351			__kprobes|
 352			$InitAttribute|
 353			____cacheline_aligned|
 354			____cacheline_aligned_in_smp|
 355			____cacheline_internodealigned_in_smp|
 356			__weak
 357		  }x;
 358our $Modifier;
 359our $Inline	= qr{inline|__always_inline|noinline|__inline|__inline__};
 360our $Member	= qr{->$Ident|\.$Ident|\[[^]]*\]};
 361our $Lval	= qr{$Ident(?:$Member)*};
 362
 363our $Int_type	= qr{(?i)llu|ull|ll|lu|ul|l|u};
 364our $Binary	= qr{(?i)0b[01]+$Int_type?};
 365our $Hex	= qr{(?i)0x[0-9a-f]+$Int_type?};
 366our $Int	= qr{[0-9]+$Int_type?};
 367our $Octal	= qr{0[0-7]+$Int_type?};
 368our $String	= qr{"[X\t]*"};
 369our $Float_hex	= qr{(?i)0x[0-9a-f]+p-?[0-9]+[fl]?};
 370our $Float_dec	= qr{(?i)(?:[0-9]+\.[0-9]*|[0-9]*\.[0-9]+)(?:e-?[0-9]+)?[fl]?};
 371our $Float_int	= qr{(?i)[0-9]+e-?[0-9]+[fl]?};
 372our $Float	= qr{$Float_hex|$Float_dec|$Float_int};
 373our $Constant	= qr{$Float|$Binary|$Octal|$Hex|$Int};
 374our $Assignment	= qr{\*\=|/=|%=|\+=|-=|<<=|>>=|&=|\^=|\|=|=};
 375our $Compare    = qr{<=|>=|==|!=|<|(?<!-)>};
 376our $Arithmetic = qr{\+|-|\*|\/|%};
 377our $Operators	= qr{
 378			<=|>=|==|!=|
 379			=>|->|<<|>>|<|>|!|~|
 380			&&|\|\||,|\^|\+\+|--|&|\||$Arithmetic
 381		  }x;
 382
 383our $c90_Keywords = qr{do|for|while|if|else|return|goto|continue|switch|default|case|break}x;
 384
 385our $BasicType;
 386our $NonptrType;
 387our $NonptrTypeMisordered;
 388our $NonptrTypeWithAttr;
 389our $Type;
 390our $TypeMisordered;
 391our $Declare;
 392our $DeclareMisordered;
 393
 394our $NON_ASCII_UTF8	= qr{
 395	[\xC2-\xDF][\x80-\xBF]               # non-overlong 2-byte
 396	|  \xE0[\xA0-\xBF][\x80-\xBF]        # excluding overlongs
 397	| [\xE1-\xEC\xEE\xEF][\x80-\xBF]{2}  # straight 3-byte
 398	|  \xED[\x80-\x9F][\x80-\xBF]        # excluding surrogates
 399	|  \xF0[\x90-\xBF][\x80-\xBF]{2}     # planes 1-3
 400	| [\xF1-\xF3][\x80-\xBF]{3}          # planes 4-15
 401	|  \xF4[\x80-\x8F][\x80-\xBF]{2}     # plane 16
 402}x;
 403
 404our $UTF8	= qr{
 405	[\x09\x0A\x0D\x20-\x7E]              # ASCII
 406	| $NON_ASCII_UTF8
 407}x;
 408
 409our $typeC99Typedefs = qr{(?:__)?(?:[us]_?)?int_?(?:8|16|32|64)_t};
 410our $typeOtherOSTypedefs = qr{(?x:
 411	u_(?:char|short|int|long) |          # bsd
 412	u(?:nchar|short|int|long)            # sysv
 413)};
 414our $typeKernelTypedefs = qr{(?x:
 415	(?:__)?(?:u|s|be|le)(?:8|16|32|64)|
 416	atomic_t
 417)};
 418our $typeTypedefs = qr{(?x:
 419	$typeC99Typedefs\b|
 420	$typeOtherOSTypedefs\b|
 421	$typeKernelTypedefs\b
 422)};
 423
 424our $zero_initializer = qr{(?:(?:0[xX])?0+$Int_type?|NULL|false)\b};
 425
 426our $logFunctions = qr{(?x:
 427	printk(?:_ratelimited|_once|)|
 428	(?:[a-z0-9]+_){1,2}(?:printk|emerg|alert|crit|err|warning|warn|notice|info|debug|dbg|vdbg|devel|cont|WARN)(?:_ratelimited|_once|)|
 
 429	WARN(?:_RATELIMIT|_ONCE|)|
 430	panic|
 431	MODULE_[A-Z_]+|
 432	seq_vprintf|seq_printf|seq_puts
 433)};
 434
 435our $signature_tags = qr{(?xi:
 436	Signed-off-by:|
 437	Acked-by:|
 438	Tested-by:|
 439	Reviewed-by:|
 440	Reported-by:|
 441	Suggested-by:|
 442	To:|
 443	Cc:
 444)};
 445
 446our @typeListMisordered = (
 447	qr{char\s+(?:un)?signed},
 448	qr{int\s+(?:(?:un)?signed\s+)?short\s},
 449	qr{int\s+short(?:\s+(?:un)?signed)},
 450	qr{short\s+int(?:\s+(?:un)?signed)},
 451	qr{(?:un)?signed\s+int\s+short},
 452	qr{short\s+(?:un)?signed},
 453	qr{long\s+int\s+(?:un)?signed},
 454	qr{int\s+long\s+(?:un)?signed},
 455	qr{long\s+(?:un)?signed\s+int},
 456	qr{int\s+(?:un)?signed\s+long},
 457	qr{int\s+(?:un)?signed},
 458	qr{int\s+long\s+long\s+(?:un)?signed},
 459	qr{long\s+long\s+int\s+(?:un)?signed},
 460	qr{long\s+long\s+(?:un)?signed\s+int},
 461	qr{long\s+long\s+(?:un)?signed},
 462	qr{long\s+(?:un)?signed},
 463);
 464
 465our @typeList = (
 466	qr{void},
 467	qr{(?:(?:un)?signed\s+)?char},
 468	qr{(?:(?:un)?signed\s+)?short\s+int},
 469	qr{(?:(?:un)?signed\s+)?short},
 470	qr{(?:(?:un)?signed\s+)?int},
 471	qr{(?:(?:un)?signed\s+)?long\s+int},
 472	qr{(?:(?:un)?signed\s+)?long\s+long\s+int},
 473	qr{(?:(?:un)?signed\s+)?long\s+long},
 474	qr{(?:(?:un)?signed\s+)?long},
 475	qr{(?:un)?signed},
 476	qr{float},
 477	qr{double},
 478	qr{bool},
 479	qr{struct\s+$Ident},
 480	qr{union\s+$Ident},
 481	qr{enum\s+$Ident},
 482	qr{${Ident}_t},
 483	qr{${Ident}_handler},
 484	qr{${Ident}_handler_fn},
 485	@typeListMisordered,
 486);
 487
 488our $C90_int_types = qr{(?x:
 489	long\s+long\s+int\s+(?:un)?signed|
 490	long\s+long\s+(?:un)?signed\s+int|
 491	long\s+long\s+(?:un)?signed|
 492	(?:(?:un)?signed\s+)?long\s+long\s+int|
 493	(?:(?:un)?signed\s+)?long\s+long|
 494	int\s+long\s+long\s+(?:un)?signed|
 495	int\s+(?:(?:un)?signed\s+)?long\s+long|
 496
 497	long\s+int\s+(?:un)?signed|
 498	long\s+(?:un)?signed\s+int|
 499	long\s+(?:un)?signed|
 500	(?:(?:un)?signed\s+)?long\s+int|
 501	(?:(?:un)?signed\s+)?long|
 502	int\s+long\s+(?:un)?signed|
 503	int\s+(?:(?:un)?signed\s+)?long|
 504
 505	int\s+(?:un)?signed|
 506	(?:(?:un)?signed\s+)?int
 507)};
 508
 509our @typeListFile = ();
 510our @typeListWithAttr = (
 511	@typeList,
 512	qr{struct\s+$InitAttribute\s+$Ident},
 513	qr{union\s+$InitAttribute\s+$Ident},
 514);
 515
 516our @modifierList = (
 517	qr{fastcall},
 518);
 519our @modifierListFile = ();
 520
 521our @mode_permission_funcs = (
 522	["module_param", 3],
 523	["module_param_(?:array|named|string)", 4],
 524	["module_param_array_named", 5],
 525	["debugfs_create_(?:file|u8|u16|u32|u64|x8|x16|x32|x64|size_t|atomic_t|bool|blob|regset32|u32_array)", 2],
 526	["proc_create(?:_data|)", 2],
 527	["(?:CLASS|DEVICE|SENSOR|SENSOR_DEVICE|IIO_DEVICE)_ATTR", 2],
 528	["IIO_DEV_ATTR_[A-Z_]+", 1],
 529	["SENSOR_(?:DEVICE_|)ATTR_2", 2],
 530	["SENSOR_TEMPLATE(?:_2|)", 3],
 531	["__ATTR", 2],
 532);
 533
 534#Create a search pattern for all these functions to speed up a loop below
 535our $mode_perms_search = "";
 536foreach my $entry (@mode_permission_funcs) {
 537	$mode_perms_search .= '|' if ($mode_perms_search ne "");
 538	$mode_perms_search .= $entry->[0];
 539}
 
 540
 541our $mode_perms_world_writable = qr{
 542	S_IWUGO		|
 543	S_IWOTH		|
 544	S_IRWXUGO	|
 545	S_IALLUGO	|
 546	0[0-7][0-7][2367]
 547}x;
 548
 549our %mode_permission_string_types = (
 550	"S_IRWXU" => 0700,
 551	"S_IRUSR" => 0400,
 552	"S_IWUSR" => 0200,
 553	"S_IXUSR" => 0100,
 554	"S_IRWXG" => 0070,
 555	"S_IRGRP" => 0040,
 556	"S_IWGRP" => 0020,
 557	"S_IXGRP" => 0010,
 558	"S_IRWXO" => 0007,
 559	"S_IROTH" => 0004,
 560	"S_IWOTH" => 0002,
 561	"S_IXOTH" => 0001,
 562	"S_IRWXUGO" => 0777,
 563	"S_IRUGO" => 0444,
 564	"S_IWUGO" => 0222,
 565	"S_IXUGO" => 0111,
 566);
 567
 568#Create a search pattern for all these strings to speed up a loop below
 569our $mode_perms_string_search = "";
 570foreach my $entry (keys %mode_permission_string_types) {
 571	$mode_perms_string_search .= '|' if ($mode_perms_string_search ne "");
 572	$mode_perms_string_search .= $entry;
 573}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 574
 575our $allowed_asm_includes = qr{(?x:
 576	irq|
 577	memory|
 578	time|
 579	reboot
 580)};
 581# memory.h: ARM has a custom one
 582
 583# Load common spelling mistakes and build regular expression list.
 584my $misspellings;
 585my %spelling_fix;
 586
 587if (open(my $spelling, '<', $spelling_file)) {
 588	while (<$spelling>) {
 589		my $line = $_;
 590
 591		$line =~ s/\s*\n?$//g;
 592		$line =~ s/^\s*//g;
 593
 594		next if ($line =~ m/^\s*#/);
 595		next if ($line =~ m/^\s*$/);
 596
 597		my ($suspect, $fix) = split(/\|\|/, $line);
 598
 599		$spelling_fix{$suspect} = $fix;
 600	}
 601	close($spelling);
 602} else {
 603	warn "No typos will be found - file '$spelling_file': $!\n";
 604}
 605
 606if ($codespell) {
 607	if (open(my $spelling, '<', $codespellfile)) {
 608		while (<$spelling>) {
 609			my $line = $_;
 610
 611			$line =~ s/\s*\n?$//g;
 612			$line =~ s/^\s*//g;
 613
 614			next if ($line =~ m/^\s*#/);
 615			next if ($line =~ m/^\s*$/);
 616			next if ($line =~ m/, disabled/i);
 617
 618			$line =~ s/,.*$//;
 619
 620			my ($suspect, $fix) = split(/->/, $line);
 621
 622			$spelling_fix{$suspect} = $fix;
 623		}
 624		close($spelling);
 625	} else {
 626		warn "No codespell typos will be found - file '$codespellfile': $!\n";
 627	}
 628}
 629
 630$misspellings = join("|", sort keys %spelling_fix) if keys %spelling_fix;
 631
 632my $const_structs = "";
 633if (open(my $conststructs, '<', $conststructsfile)) {
 634	while (<$conststructs>) {
 635		my $line = $_;
 636
 637		$line =~ s/\s*\n?$//g;
 638		$line =~ s/^\s*//g;
 
 639
 640		next if ($line =~ m/^\s*#/);
 641		next if ($line =~ m/^\s*$/);
 642		if ($line =~ /\s/) {
 643			print("$conststructsfile: '$line' invalid - ignored\n");
 644			next;
 645		}
 646
 647		$const_structs .= '|' if ($const_structs ne "");
 648		$const_structs .= $line;
 
 
 
 
 
 
 
 
 
 
 649	}
 650	close($conststructsfile);
 651} else {
 652	warn "No structs that should be const will be found - file '$conststructsfile': $!\n";
 653}
 654
 
 
 
 
 
 
 
 
 
 
 
 655sub build_types {
 656	my $mods = "(?x:  \n" . join("|\n  ", (@modifierList, @modifierListFile)) . "\n)";
 657	my $all = "(?x:  \n" . join("|\n  ", (@typeList, @typeListFile)) . "\n)";
 658	my $Misordered = "(?x:  \n" . join("|\n  ", @typeListMisordered) . "\n)";
 659	my $allWithAttr = "(?x:  \n" . join("|\n  ", @typeListWithAttr) . "\n)";
 660	$Modifier	= qr{(?:$Attribute|$Sparse|$mods)};
 661	$BasicType	= qr{
 662				(?:$typeTypedefs\b)|
 663				(?:${all}\b)
 664		}x;
 665	$NonptrType	= qr{
 666			(?:$Modifier\s+|const\s+)*
 667			(?:
 668				(?:typeof|__typeof__)\s*\([^\)]*\)|
 669				(?:$typeTypedefs\b)|
 670				(?:${all}\b)
 671			)
 672			(?:\s+$Modifier|\s+const)*
 673		  }x;
 674	$NonptrTypeMisordered	= qr{
 675			(?:$Modifier\s+|const\s+)*
 676			(?:
 677				(?:${Misordered}\b)
 678			)
 679			(?:\s+$Modifier|\s+const)*
 680		  }x;
 681	$NonptrTypeWithAttr	= qr{
 682			(?:$Modifier\s+|const\s+)*
 683			(?:
 684				(?:typeof|__typeof__)\s*\([^\)]*\)|
 685				(?:$typeTypedefs\b)|
 686				(?:${allWithAttr}\b)
 687			)
 688			(?:\s+$Modifier|\s+const)*
 689		  }x;
 690	$Type	= qr{
 691			$NonptrType
 692			(?:(?:\s|\*|\[\])+\s*const|(?:\s|\*\s*(?:const\s*)?|\[\])+|(?:\s*\[\s*\])+)?
 693			(?:\s+$Inline|\s+$Modifier)*
 694		  }x;
 695	$TypeMisordered	= qr{
 696			$NonptrTypeMisordered
 697			(?:(?:\s|\*|\[\])+\s*const|(?:\s|\*\s*(?:const\s*)?|\[\])+|(?:\s*\[\s*\])+)?
 698			(?:\s+$Inline|\s+$Modifier)*
 699		  }x;
 700	$Declare	= qr{(?:$Storage\s+(?:$Inline\s+)?)?$Type};
 701	$DeclareMisordered	= qr{(?:$Storage\s+(?:$Inline\s+)?)?$TypeMisordered};
 702}
 703build_types();
 704
 705our $Typecast	= qr{\s*(\(\s*$NonptrType\s*\)){0,1}\s*};
 706
 707# Using $balanced_parens, $LvalOrFunc, or $FuncArg
 708# requires at least perl version v5.10.0
 709# Any use must be runtime checked with $^V
 710
 711our $balanced_parens = qr/(\((?:[^\(\)]++|(?-1))*\))/;
 712our $LvalOrFunc	= qr{((?:[\&\*]\s*)?$Lval)\s*($balanced_parens{0,1})\s*};
 713our $FuncArg = qr{$Typecast{0,1}($LvalOrFunc|$Constant|$String)};
 714
 715our $declaration_macros = qr{(?x:
 716	(?:$Storage\s+)?(?:[A-Z_][A-Z0-9]*_){0,2}(?:DEFINE|DECLARE)(?:_[A-Z0-9]+){1,6}\s*\(|
 717	(?:$Storage\s+)?LIST_HEAD\s*\(|
 718	(?:$Storage\s+)?${Type}\s+uninitialized_var\s*\(
 
 719)};
 720
 721sub deparenthesize {
 722	my ($string) = @_;
 723	return "" if (!defined($string));
 724
 725	while ($string =~ /^\s*\(.*\)\s*$/) {
 726		$string =~ s@^\s*\(\s*@@;
 727		$string =~ s@\s*\)\s*$@@;
 728	}
 729
 730	$string =~ s@\s+@ @g;
 731
 732	return $string;
 733}
 734
 735sub seed_camelcase_file {
 736	my ($file) = @_;
 737
 738	return if (!(-f $file));
 739
 740	local $/;
 741
 742	open(my $include_file, '<', "$file")
 743	    or warn "$P: Can't read '$file' $!\n";
 744	my $text = <$include_file>;
 745	close($include_file);
 746
 747	my @lines = split('\n', $text);
 748
 749	foreach my $line (@lines) {
 750		next if ($line !~ /(?:[A-Z][a-z]|[a-z][A-Z])/);
 751		if ($line =~ /^[ \t]*(?:#[ \t]*define|typedef\s+$Type)\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)/) {
 752			$camelcase{$1} = 1;
 753		} elsif ($line =~ /^\s*$Declare\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)\s*[\(\[,;]/) {
 754			$camelcase{$1} = 1;
 755		} elsif ($line =~ /^\s*(?:union|struct|enum)\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)\s*[;\{]/) {
 756			$camelcase{$1} = 1;
 757		}
 758	}
 759}
 760
 761sub is_maintained_obsolete {
 762	my ($filename) = @_;
 763
 764	return 0 if (!$tree || !(-e "$root/scripts/get_maintainer.pl"));
 765
 766	my $status = `perl $root/scripts/get_maintainer.pl --status --nom --nol --nogit --nogit-fallback -f $filename 2>&1`;
 767
 768	return $status =~ /obsolete/i;
 769}
 770
 771my $camelcase_seeded = 0;
 772sub seed_camelcase_includes {
 773	return if ($camelcase_seeded);
 774
 775	my $files;
 776	my $camelcase_cache = "";
 777	my @include_files = ();
 778
 779	$camelcase_seeded = 1;
 780
 781	if (-e ".git") {
 782		my $git_last_include_commit = `git log --no-merges --pretty=format:"%h%n" -1 -- include`;
 783		chomp $git_last_include_commit;
 784		$camelcase_cache = ".checkpatch-camelcase.git.$git_last_include_commit";
 785	} else {
 786		my $last_mod_date = 0;
 787		$files = `find $root/include -name "*.h"`;
 788		@include_files = split('\n', $files);
 789		foreach my $file (@include_files) {
 790			my $date = POSIX::strftime("%Y%m%d%H%M",
 791						   localtime((stat $file)[9]));
 792			$last_mod_date = $date if ($last_mod_date < $date);
 793		}
 794		$camelcase_cache = ".checkpatch-camelcase.date.$last_mod_date";
 795	}
 796
 797	if ($camelcase_cache ne "" && -f $camelcase_cache) {
 798		open(my $camelcase_file, '<', "$camelcase_cache")
 799		    or warn "$P: Can't read '$camelcase_cache' $!\n";
 800		while (<$camelcase_file>) {
 801			chomp;
 802			$camelcase{$_} = 1;
 803		}
 804		close($camelcase_file);
 805
 806		return;
 807	}
 808
 809	if (-e ".git") {
 810		$files = `git ls-files "include/*.h"`;
 811		@include_files = split('\n', $files);
 812	}
 813
 814	foreach my $file (@include_files) {
 815		seed_camelcase_file($file);
 816	}
 817
 818	if ($camelcase_cache ne "") {
 819		unlink glob ".checkpatch-camelcase.*";
 820		open(my $camelcase_file, '>', "$camelcase_cache")
 821		    or warn "$P: Can't write '$camelcase_cache' $!\n";
 822		foreach (sort { lc($a) cmp lc($b) } keys(%camelcase)) {
 823			print $camelcase_file ("$_\n");
 824		}
 825		close($camelcase_file);
 826	}
 827}
 828
 829sub git_commit_info {
 830	my ($commit, $id, $desc) = @_;
 831
 832	return ($id, $desc) if ((which("git") eq "") || !(-e ".git"));
 833
 834	my $output = `git log --no-color --format='%H %s' -1 $commit 2>&1`;
 835	$output =~ s/^\s*//gm;
 836	my @lines = split("\n", $output);
 837
 838	return ($id, $desc) if ($#lines < 0);
 839
 840	if ($lines[0] =~ /^error: short SHA1 $commit is ambiguous\./) {
 841# Maybe one day convert this block of bash into something that returns
 842# all matching commit ids, but it's very slow...
 843#
 844#		echo "checking commits $1..."
 845#		git rev-list --remotes | grep -i "^$1" |
 846#		while read line ; do
 847#		    git log --format='%H %s' -1 $line |
 848#		    echo "commit $(cut -c 1-12,41-)"
 849#		done
 850	} elsif ($lines[0] =~ /^fatal: ambiguous argument '$commit': unknown revision or path not in the working tree\./) {
 
 851	} else {
 852		$id = substr($lines[0], 0, 12);
 853		$desc = substr($lines[0], 41);
 854	}
 855
 856	return ($id, $desc);
 857}
 858
 859$chk_signoff = 0 if ($file);
 860
 861my @rawlines = ();
 862my @lines = ();
 863my @fixed = ();
 864my @fixed_inserted = ();
 865my @fixed_deleted = ();
 866my $fixlinenr = -1;
 867
 868# If input is git commits, extract all commits from the commit expressions.
 869# For example, HEAD-3 means we need check 'HEAD, HEAD~1, HEAD~2'.
 870die "$P: No git repository found\n" if ($git && !-e ".git");
 871
 872if ($git) {
 873	my @commits = ();
 874	foreach my $commit_expr (@ARGV) {
 875		my $git_range;
 876		if ($commit_expr =~ m/^(.*)-(\d+)$/) {
 877			$git_range = "-$2 $1";
 878		} elsif ($commit_expr =~ m/\.\./) {
 879			$git_range = "$commit_expr";
 880		} else {
 881			$git_range = "-1 $commit_expr";
 882		}
 883		my $lines = `git log --no-color --no-merges --pretty=format:'%H %s' $git_range`;
 884		foreach my $line (split(/\n/, $lines)) {
 885			$line =~ /^([0-9a-fA-F]{40,40}) (.*)$/;
 886			next if (!defined($1) || !defined($2));
 887			my $sha1 = $1;
 888			my $subject = $2;
 889			unshift(@commits, $sha1);
 890			$git_commits{$sha1} = $subject;
 891		}
 892	}
 893	die "$P: no git commits after extraction!\n" if (@commits == 0);
 894	@ARGV = @commits;
 895}
 896
 897my $vname;
 898for my $filename (@ARGV) {
 899	my $FILE;
 900	if ($git) {
 901		open($FILE, '-|', "git format-patch -M --stdout -1 $filename") ||
 902			die "$P: $filename: git format-patch failed - $!\n";
 903	} elsif ($file) {
 904		open($FILE, '-|', "diff -u /dev/null $filename") ||
 905			die "$P: $filename: diff failed - $!\n";
 906	} elsif ($filename eq '-') {
 907		open($FILE, '<&STDIN');
 908	} else {
 909		open($FILE, '<', "$filename") ||
 910			die "$P: $filename: open failed - $!\n";
 911	}
 912	if ($filename eq '-') {
 913		$vname = 'Your patch';
 914	} elsif ($git) {
 915		$vname = "Commit " . substr($filename, 0, 12) . ' ("' . $git_commits{$filename} . '")';
 916	} else {
 917		$vname = $filename;
 918	}
 919	while (<$FILE>) {
 920		chomp;
 921		push(@rawlines, $_);
 922	}
 923	close($FILE);
 924
 925	if ($#ARGV > 0 && $quiet == 0) {
 926		print '-' x length($vname) . "\n";
 927		print "$vname\n";
 928		print '-' x length($vname) . "\n";
 929	}
 930
 931	if (!process($filename)) {
 932		$exit = 1;
 933	}
 934	@rawlines = ();
 935	@lines = ();
 936	@fixed = ();
 937	@fixed_inserted = ();
 938	@fixed_deleted = ();
 939	$fixlinenr = -1;
 940	@modifierListFile = ();
 941	@typeListFile = ();
 942	build_types();
 943}
 944
 945if (!$quiet) {
 946	hash_show_words(\%use_type, "Used");
 947	hash_show_words(\%ignore_type, "Ignored");
 948
 949	if ($^V lt 5.10.0) {
 950		print << "EOM"
 951
 952NOTE: perl $^V is not modern enough to detect all possible issues.
 953      An upgrade to at least perl v5.10.0 is suggested.
 954EOM
 955	}
 956	if ($exit) {
 957		print << "EOM"
 958
 959NOTE: If any of the errors are false positives, please report
 960      them to the maintainer, see CHECKPATCH in MAINTAINERS.
 961EOM
 962	}
 963}
 964
 965exit($exit);
 966
 967sub top_of_kernel_tree {
 968	my ($root) = @_;
 969
 970	my @tree_check = (
 971		"COPYING", "CREDITS", "Kbuild", "MAINTAINERS", "Makefile",
 972		"README", "Documentation", "arch", "include", "drivers",
 973		"fs", "init", "ipc", "kernel", "lib", "scripts",
 974	);
 975
 976	foreach my $check (@tree_check) {
 977		if (! -e $root . '/' . $check) {
 978			return 0;
 979		}
 980	}
 981	return 1;
 982}
 983
 984sub parse_email {
 985	my ($formatted_email) = @_;
 986
 987	my $name = "";
 988	my $address = "";
 989	my $comment = "";
 990
 991	if ($formatted_email =~ /^(.*)<(\S+\@\S+)>(.*)$/) {
 992		$name = $1;
 993		$address = $2;
 994		$comment = $3 if defined $3;
 995	} elsif ($formatted_email =~ /^\s*<(\S+\@\S+)>(.*)$/) {
 996		$address = $1;
 997		$comment = $2 if defined $2;
 998	} elsif ($formatted_email =~ /(\S+\@\S+)(.*)$/) {
 999		$address = $1;
1000		$comment = $2 if defined $2;
1001		$formatted_email =~ s/$address.*$//;
1002		$name = $formatted_email;
1003		$name = trim($name);
1004		$name =~ s/^\"|\"$//g;
1005		# If there's a name left after stripping spaces and
1006		# leading quotes, and the address doesn't have both
1007		# leading and trailing angle brackets, the address
1008		# is invalid. ie:
1009		#   "joe smith joe@smith.com" bad
1010		#   "joe smith <joe@smith.com" bad
1011		if ($name ne "" && $address !~ /^<[^>]+>$/) {
1012			$name = "";
1013			$address = "";
1014			$comment = "";
1015		}
1016	}
1017
1018	$name = trim($name);
1019	$name =~ s/^\"|\"$//g;
1020	$address = trim($address);
1021	$address =~ s/^\<|\>$//g;
1022
1023	if ($name =~ /[^\w \-]/i) { ##has "must quote" chars
1024		$name =~ s/(?<!\\)"/\\"/g; ##escape quotes
1025		$name = "\"$name\"";
1026	}
1027
1028	return ($name, $address, $comment);
1029}
1030
1031sub format_email {
1032	my ($name, $address) = @_;
1033
1034	my $formatted_email;
1035
1036	$name = trim($name);
1037	$name =~ s/^\"|\"$//g;
1038	$address = trim($address);
1039
1040	if ($name =~ /[^\w \-]/i) { ##has "must quote" chars
1041		$name =~ s/(?<!\\)"/\\"/g; ##escape quotes
1042		$name = "\"$name\"";
1043	}
1044
1045	if ("$name" eq "") {
1046		$formatted_email = "$address";
1047	} else {
1048		$formatted_email = "$name <$address>";
1049	}
1050
1051	return $formatted_email;
1052}
1053
1054sub which {
1055	my ($bin) = @_;
1056
1057	foreach my $path (split(/:/, $ENV{PATH})) {
1058		if (-e "$path/$bin") {
1059			return "$path/$bin";
1060		}
1061	}
1062
1063	return "";
1064}
1065
1066sub which_conf {
1067	my ($conf) = @_;
1068
1069	foreach my $path (split(/:/, ".:$ENV{HOME}:.scripts")) {
1070		if (-e "$path/$conf") {
1071			return "$path/$conf";
1072		}
1073	}
1074
1075	return "";
1076}
1077
1078sub expand_tabs {
1079	my ($str) = @_;
1080
1081	my $res = '';
1082	my $n = 0;
1083	for my $c (split(//, $str)) {
1084		if ($c eq "\t") {
1085			$res .= ' ';
1086			$n++;
1087			for (; ($n % 8) != 0; $n++) {
1088				$res .= ' ';
1089			}
1090			next;
1091		}
1092		$res .= $c;
1093		$n++;
1094	}
1095
1096	return $res;
1097}
1098sub copy_spacing {
1099	(my $res = shift) =~ tr/\t/ /c;
1100	return $res;
1101}
1102
1103sub line_stats {
1104	my ($line) = @_;
1105
1106	# Drop the diff line leader and expand tabs
1107	$line =~ s/^.//;
1108	$line = expand_tabs($line);
1109
1110	# Pick the indent from the front of the line.
1111	my ($white) = ($line =~ /^(\s*)/);
1112
1113	return (length($line), length($white));
1114}
1115
1116my $sanitise_quote = '';
1117
1118sub sanitise_line_reset {
1119	my ($in_comment) = @_;
1120
1121	if ($in_comment) {
1122		$sanitise_quote = '*/';
1123	} else {
1124		$sanitise_quote = '';
1125	}
1126}
1127sub sanitise_line {
1128	my ($line) = @_;
1129
1130	my $res = '';
1131	my $l = '';
1132
1133	my $qlen = 0;
1134	my $off = 0;
1135	my $c;
1136
1137	# Always copy over the diff marker.
1138	$res = substr($line, 0, 1);
1139
1140	for ($off = 1; $off < length($line); $off++) {
1141		$c = substr($line, $off, 1);
1142
1143		# Comments we are wacking completly including the begin
1144		# and end, all to $;.
1145		if ($sanitise_quote eq '' && substr($line, $off, 2) eq '/*') {
1146			$sanitise_quote = '*/';
1147
1148			substr($res, $off, 2, "$;$;");
1149			$off++;
1150			next;
1151		}
1152		if ($sanitise_quote eq '*/' && substr($line, $off, 2) eq '*/') {
1153			$sanitise_quote = '';
1154			substr($res, $off, 2, "$;$;");
1155			$off++;
1156			next;
1157		}
1158		if ($sanitise_quote eq '' && substr($line, $off, 2) eq '//') {
1159			$sanitise_quote = '//';
1160
1161			substr($res, $off, 2, $sanitise_quote);
1162			$off++;
1163			next;
1164		}
1165
1166		# A \ in a string means ignore the next character.
1167		if (($sanitise_quote eq "'" || $sanitise_quote eq '"') &&
1168		    $c eq "\\") {
1169			substr($res, $off, 2, 'XX');
1170			$off++;
1171			next;
1172		}
1173		# Regular quotes.
1174		if ($c eq "'" || $c eq '"') {
1175			if ($sanitise_quote eq '') {
1176				$sanitise_quote = $c;
1177
1178				substr($res, $off, 1, $c);
1179				next;
1180			} elsif ($sanitise_quote eq $c) {
1181				$sanitise_quote = '';
1182			}
1183		}
1184
1185		#print "c<$c> SQ<$sanitise_quote>\n";
1186		if ($off != 0 && $sanitise_quote eq '*/' && $c ne "\t") {
1187			substr($res, $off, 1, $;);
1188		} elsif ($off != 0 && $sanitise_quote eq '//' && $c ne "\t") {
1189			substr($res, $off, 1, $;);
1190		} elsif ($off != 0 && $sanitise_quote && $c ne "\t") {
1191			substr($res, $off, 1, 'X');
1192		} else {
1193			substr($res, $off, 1, $c);
1194		}
1195	}
1196
1197	if ($sanitise_quote eq '//') {
1198		$sanitise_quote = '';
1199	}
1200
1201	# The pathname on a #include may be surrounded by '<' and '>'.
1202	if ($res =~ /^.\s*\#\s*include\s+\<(.*)\>/) {
1203		my $clean = 'X' x length($1);
1204		$res =~ s@\<.*\>@<$clean>@;
1205
1206	# The whole of a #error is a string.
1207	} elsif ($res =~ /^.\s*\#\s*(?:error|warning)\s+(.*)\b/) {
1208		my $clean = 'X' x length($1);
1209		$res =~ s@(\#\s*(?:error|warning)\s+).*@$1$clean@;
1210	}
1211
1212	if ($allow_c99_comments && $res =~ m@(//.*$)@) {
1213		my $match = $1;
1214		$res =~ s/\Q$match\E/"$;" x length($match)/e;
1215	}
1216
1217	return $res;
1218}
1219
1220sub get_quoted_string {
1221	my ($line, $rawline) = @_;
1222
 
1223	return "" if ($line !~ m/($String)/g);
1224	return substr($rawline, $-[0], $+[0] - $-[0]);
1225}
1226
1227sub ctx_statement_block {
1228	my ($linenr, $remain, $off) = @_;
1229	my $line = $linenr - 1;
1230	my $blk = '';
1231	my $soff = $off;
1232	my $coff = $off - 1;
1233	my $coff_set = 0;
1234
1235	my $loff = 0;
1236
1237	my $type = '';
1238	my $level = 0;
1239	my @stack = ();
1240	my $p;
1241	my $c;
1242	my $len = 0;
1243
1244	my $remainder;
1245	while (1) {
1246		@stack = (['', 0]) if ($#stack == -1);
1247
1248		#warn "CSB: blk<$blk> remain<$remain>\n";
1249		# If we are about to drop off the end, pull in more
1250		# context.
1251		if ($off >= $len) {
1252			for (; $remain > 0; $line++) {
1253				last if (!defined $lines[$line]);
1254				next if ($lines[$line] =~ /^-/);
1255				$remain--;
1256				$loff = $len;
1257				$blk .= $lines[$line] . "\n";
1258				$len = length($blk);
1259				$line++;
1260				last;
1261			}
1262			# Bail if there is no further context.
1263			#warn "CSB: blk<$blk> off<$off> len<$len>\n";
1264			if ($off >= $len) {
1265				last;
1266			}
1267			if ($level == 0 && substr($blk, $off) =~ /^.\s*#\s*define/) {
1268				$level++;
1269				$type = '#';
1270			}
1271		}
1272		$p = $c;
1273		$c = substr($blk, $off, 1);
1274		$remainder = substr($blk, $off);
1275
1276		#warn "CSB: c<$c> type<$type> level<$level> remainder<$remainder> coff_set<$coff_set>\n";
1277
1278		# Handle nested #if/#else.
1279		if ($remainder =~ /^#\s*(?:ifndef|ifdef|if)\s/) {
1280			push(@stack, [ $type, $level ]);
1281		} elsif ($remainder =~ /^#\s*(?:else|elif)\b/) {
1282			($type, $level) = @{$stack[$#stack - 1]};
1283		} elsif ($remainder =~ /^#\s*endif\b/) {
1284			($type, $level) = @{pop(@stack)};
1285		}
1286
1287		# Statement ends at the ';' or a close '}' at the
1288		# outermost level.
1289		if ($level == 0 && $c eq ';') {
1290			last;
1291		}
1292
1293		# An else is really a conditional as long as its not else if
1294		if ($level == 0 && $coff_set == 0 &&
1295				(!defined($p) || $p =~ /(?:\s|\}|\+)/) &&
1296				$remainder =~ /^(else)(?:\s|{)/ &&
1297				$remainder !~ /^else\s+if\b/) {
1298			$coff = $off + length($1) - 1;
1299			$coff_set = 1;
1300			#warn "CSB: mark coff<$coff> soff<$soff> 1<$1>\n";
1301			#warn "[" . substr($blk, $soff, $coff - $soff + 1) . "]\n";
1302		}
1303
1304		if (($type eq '' || $type eq '(') && $c eq '(') {
1305			$level++;
1306			$type = '(';
1307		}
1308		if ($type eq '(' && $c eq ')') {
1309			$level--;
1310			$type = ($level != 0)? '(' : '';
1311
1312			if ($level == 0 && $coff < $soff) {
1313				$coff = $off;
1314				$coff_set = 1;
1315				#warn "CSB: mark coff<$coff>\n";
1316			}
1317		}
1318		if (($type eq '' || $type eq '{') && $c eq '{') {
1319			$level++;
1320			$type = '{';
1321		}
1322		if ($type eq '{' && $c eq '}') {
1323			$level--;
1324			$type = ($level != 0)? '{' : '';
1325
1326			if ($level == 0) {
1327				if (substr($blk, $off + 1, 1) eq ';') {
1328					$off++;
1329				}
1330				last;
1331			}
1332		}
1333		# Preprocessor commands end at the newline unless escaped.
1334		if ($type eq '#' && $c eq "\n" && $p ne "\\") {
1335			$level--;
1336			$type = '';
1337			$off++;
1338			last;
1339		}
1340		$off++;
1341	}
1342	# We are truly at the end, so shuffle to the next line.
1343	if ($off == $len) {
1344		$loff = $len + 1;
1345		$line++;
1346		$remain--;
1347	}
1348
1349	my $statement = substr($blk, $soff, $off - $soff + 1);
1350	my $condition = substr($blk, $soff, $coff - $soff + 1);
1351
1352	#warn "STATEMENT<$statement>\n";
1353	#warn "CONDITION<$condition>\n";
1354
1355	#print "coff<$coff> soff<$off> loff<$loff>\n";
1356
1357	return ($statement, $condition,
1358			$line, $remain + 1, $off - $loff + 1, $level);
1359}
1360
1361sub statement_lines {
1362	my ($stmt) = @_;
1363
1364	# Strip the diff line prefixes and rip blank lines at start and end.
1365	$stmt =~ s/(^|\n)./$1/g;
1366	$stmt =~ s/^\s*//;
1367	$stmt =~ s/\s*$//;
1368
1369	my @stmt_lines = ($stmt =~ /\n/g);
1370
1371	return $#stmt_lines + 2;
1372}
1373
1374sub statement_rawlines {
1375	my ($stmt) = @_;
1376
1377	my @stmt_lines = ($stmt =~ /\n/g);
1378
1379	return $#stmt_lines + 2;
1380}
1381
1382sub statement_block_size {
1383	my ($stmt) = @_;
1384
1385	$stmt =~ s/(^|\n)./$1/g;
1386	$stmt =~ s/^\s*{//;
1387	$stmt =~ s/}\s*$//;
1388	$stmt =~ s/^\s*//;
1389	$stmt =~ s/\s*$//;
1390
1391	my @stmt_lines = ($stmt =~ /\n/g);
1392	my @stmt_statements = ($stmt =~ /;/g);
1393
1394	my $stmt_lines = $#stmt_lines + 2;
1395	my $stmt_statements = $#stmt_statements + 1;
1396
1397	if ($stmt_lines > $stmt_statements) {
1398		return $stmt_lines;
1399	} else {
1400		return $stmt_statements;
1401	}
1402}
1403
1404sub ctx_statement_full {
1405	my ($linenr, $remain, $off) = @_;
1406	my ($statement, $condition, $level);
1407
1408	my (@chunks);
1409
1410	# Grab the first conditional/block pair.
1411	($statement, $condition, $linenr, $remain, $off, $level) =
1412				ctx_statement_block($linenr, $remain, $off);
1413	#print "F: c<$condition> s<$statement> remain<$remain>\n";
1414	push(@chunks, [ $condition, $statement ]);
1415	if (!($remain > 0 && $condition =~ /^\s*(?:\n[+-])?\s*(?:if|else|do)\b/s)) {
1416		return ($level, $linenr, @chunks);
1417	}
1418
1419	# Pull in the following conditional/block pairs and see if they
1420	# could continue the statement.
1421	for (;;) {
1422		($statement, $condition, $linenr, $remain, $off, $level) =
1423				ctx_statement_block($linenr, $remain, $off);
1424		#print "C: c<$condition> s<$statement> remain<$remain>\n";
1425		last if (!($remain > 0 && $condition =~ /^(?:\s*\n[+-])*\s*(?:else|do)\b/s));
1426		#print "C: push\n";
1427		push(@chunks, [ $condition, $statement ]);
1428	}
1429
1430	return ($level, $linenr, @chunks);
1431}
1432
1433sub ctx_block_get {
1434	my ($linenr, $remain, $outer, $open, $close, $off) = @_;
1435	my $line;
1436	my $start = $linenr - 1;
1437	my $blk = '';
1438	my @o;
1439	my @c;
1440	my @res = ();
1441
1442	my $level = 0;
1443	my @stack = ($level);
1444	for ($line = $start; $remain > 0; $line++) {
1445		next if ($rawlines[$line] =~ /^-/);
1446		$remain--;
1447
1448		$blk .= $rawlines[$line];
1449
1450		# Handle nested #if/#else.
1451		if ($lines[$line] =~ /^.\s*#\s*(?:ifndef|ifdef|if)\s/) {
1452			push(@stack, $level);
1453		} elsif ($lines[$line] =~ /^.\s*#\s*(?:else|elif)\b/) {
1454			$level = $stack[$#stack - 1];
1455		} elsif ($lines[$line] =~ /^.\s*#\s*endif\b/) {
1456			$level = pop(@stack);
1457		}
1458
1459		foreach my $c (split(//, $lines[$line])) {
1460			##print "C<$c>L<$level><$open$close>O<$off>\n";
1461			if ($off > 0) {
1462				$off--;
1463				next;
1464			}
1465
1466			if ($c eq $close && $level > 0) {
1467				$level--;
1468				last if ($level == 0);
1469			} elsif ($c eq $open) {
1470				$level++;
1471			}
1472		}
1473
1474		if (!$outer || $level <= 1) {
1475			push(@res, $rawlines[$line]);
1476		}
1477
1478		last if ($level == 0);
1479	}
1480
1481	return ($level, @res);
1482}
1483sub ctx_block_outer {
1484	my ($linenr, $remain) = @_;
1485
1486	my ($level, @r) = ctx_block_get($linenr, $remain, 1, '{', '}', 0);
1487	return @r;
1488}
1489sub ctx_block {
1490	my ($linenr, $remain) = @_;
1491
1492	my ($level, @r) = ctx_block_get($linenr, $remain, 0, '{', '}', 0);
1493	return @r;
1494}
1495sub ctx_statement {
1496	my ($linenr, $remain, $off) = @_;
1497
1498	my ($level, @r) = ctx_block_get($linenr, $remain, 0, '(', ')', $off);
1499	return @r;
1500}
1501sub ctx_block_level {
1502	my ($linenr, $remain) = @_;
1503
1504	return ctx_block_get($linenr, $remain, 0, '{', '}', 0);
1505}
1506sub ctx_statement_level {
1507	my ($linenr, $remain, $off) = @_;
1508
1509	return ctx_block_get($linenr, $remain, 0, '(', ')', $off);
1510}
1511
1512sub ctx_locate_comment {
1513	my ($first_line, $end_line) = @_;
1514
1515	# Catch a comment on the end of the line itself.
1516	my ($current_comment) = ($rawlines[$end_line - 1] =~ m@.*(/\*.*\*/)\s*(?:\\\s*)?$@);
1517	return $current_comment if (defined $current_comment);
1518
1519	# Look through the context and try and figure out if there is a
1520	# comment.
1521	my $in_comment = 0;
1522	$current_comment = '';
1523	for (my $linenr = $first_line; $linenr < $end_line; $linenr++) {
1524		my $line = $rawlines[$linenr - 1];
1525		#warn "           $line\n";
1526		if ($linenr == $first_line and $line =~ m@^.\s*\*@) {
1527			$in_comment = 1;
1528		}
1529		if ($line =~ m@/\*@) {
1530			$in_comment = 1;
1531		}
1532		if (!$in_comment && $current_comment ne '') {
1533			$current_comment = '';
1534		}
1535		$current_comment .= $line . "\n" if ($in_comment);
1536		if ($line =~ m@\*/@) {
1537			$in_comment = 0;
1538		}
1539	}
1540
1541	chomp($current_comment);
1542	return($current_comment);
1543}
1544sub ctx_has_comment {
1545	my ($first_line, $end_line) = @_;
1546	my $cmt = ctx_locate_comment($first_line, $end_line);
1547
1548	##print "LINE: $rawlines[$end_line - 1 ]\n";
1549	##print "CMMT: $cmt\n";
1550
1551	return ($cmt ne '');
1552}
1553
1554sub raw_line {
1555	my ($linenr, $cnt) = @_;
1556
1557	my $offset = $linenr - 1;
1558	$cnt++;
1559
1560	my $line;
1561	while ($cnt) {
1562		$line = $rawlines[$offset++];
1563		next if (defined($line) && $line =~ /^-/);
1564		$cnt--;
1565	}
1566
1567	return $line;
1568}
1569
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1570sub cat_vet {
1571	my ($vet) = @_;
1572	my ($res, $coded);
1573
1574	$res = '';
1575	while ($vet =~ /([^[:cntrl:]]*)([[:cntrl:]]|$)/g) {
1576		$res .= $1;
1577		if ($2 ne '') {
1578			$coded = sprintf("^%c", unpack('C', $2) + 64);
1579			$res .= $coded;
1580		}
1581	}
1582	$res =~ s/$/\$/;
1583
1584	return $res;
1585}
1586
1587my $av_preprocessor = 0;
1588my $av_pending;
1589my @av_paren_type;
1590my $av_pend_colon;
1591
1592sub annotate_reset {
1593	$av_preprocessor = 0;
1594	$av_pending = '_';
1595	@av_paren_type = ('E');
1596	$av_pend_colon = 'O';
1597}
1598
1599sub annotate_values {
1600	my ($stream, $type) = @_;
1601
1602	my $res;
1603	my $var = '_' x length($stream);
1604	my $cur = $stream;
1605
1606	print "$stream\n" if ($dbg_values > 1);
1607
1608	while (length($cur)) {
1609		@av_paren_type = ('E') if ($#av_paren_type < 0);
1610		print " <" . join('', @av_paren_type) .
1611				"> <$type> <$av_pending>" if ($dbg_values > 1);
1612		if ($cur =~ /^(\s+)/o) {
1613			print "WS($1)\n" if ($dbg_values > 1);
1614			if ($1 =~ /\n/ && $av_preprocessor) {
1615				$type = pop(@av_paren_type);
1616				$av_preprocessor = 0;
1617			}
1618
1619		} elsif ($cur =~ /^(\(\s*$Type\s*)\)/ && $av_pending eq '_') {
1620			print "CAST($1)\n" if ($dbg_values > 1);
1621			push(@av_paren_type, $type);
1622			$type = 'c';
1623
1624		} elsif ($cur =~ /^($Type)\s*(?:$Ident|,|\)|\(|\s*$)/) {
1625			print "DECLARE($1)\n" if ($dbg_values > 1);
1626			$type = 'T';
1627
1628		} elsif ($cur =~ /^($Modifier)\s*/) {
1629			print "MODIFIER($1)\n" if ($dbg_values > 1);
1630			$type = 'T';
1631
1632		} elsif ($cur =~ /^(\#\s*define\s*$Ident)(\(?)/o) {
1633			print "DEFINE($1,$2)\n" if ($dbg_values > 1);
1634			$av_preprocessor = 1;
1635			push(@av_paren_type, $type);
1636			if ($2 ne '') {
1637				$av_pending = 'N';
1638			}
1639			$type = 'E';
1640
1641		} elsif ($cur =~ /^(\#\s*(?:undef\s*$Ident|include\b))/o) {
1642			print "UNDEF($1)\n" if ($dbg_values > 1);
1643			$av_preprocessor = 1;
1644			push(@av_paren_type, $type);
1645
1646		} elsif ($cur =~ /^(\#\s*(?:ifdef|ifndef|if))/o) {
1647			print "PRE_START($1)\n" if ($dbg_values > 1);
1648			$av_preprocessor = 1;
1649
1650			push(@av_paren_type, $type);
1651			push(@av_paren_type, $type);
1652			$type = 'E';
1653
1654		} elsif ($cur =~ /^(\#\s*(?:else|elif))/o) {
1655			print "PRE_RESTART($1)\n" if ($dbg_values > 1);
1656			$av_preprocessor = 1;
1657
1658			push(@av_paren_type, $av_paren_type[$#av_paren_type]);
1659
1660			$type = 'E';
1661
1662		} elsif ($cur =~ /^(\#\s*(?:endif))/o) {
1663			print "PRE_END($1)\n" if ($dbg_values > 1);
1664
1665			$av_preprocessor = 1;
1666
1667			# Assume all arms of the conditional end as this
1668			# one does, and continue as if the #endif was not here.
1669			pop(@av_paren_type);
1670			push(@av_paren_type, $type);
1671			$type = 'E';
1672
1673		} elsif ($cur =~ /^(\\\n)/o) {
1674			print "PRECONT($1)\n" if ($dbg_values > 1);
1675
1676		} elsif ($cur =~ /^(__attribute__)\s*\(?/o) {
1677			print "ATTR($1)\n" if ($dbg_values > 1);
1678			$av_pending = $type;
1679			$type = 'N';
1680
1681		} elsif ($cur =~ /^(sizeof)\s*(\()?/o) {
1682			print "SIZEOF($1)\n" if ($dbg_values > 1);
1683			if (defined $2) {
1684				$av_pending = 'V';
1685			}
1686			$type = 'N';
1687
1688		} elsif ($cur =~ /^(if|while|for)\b/o) {
1689			print "COND($1)\n" if ($dbg_values > 1);
1690			$av_pending = 'E';
1691			$type = 'N';
1692
1693		} elsif ($cur =~/^(case)/o) {
1694			print "CASE($1)\n" if ($dbg_values > 1);
1695			$av_pend_colon = 'C';
1696			$type = 'N';
1697
1698		} elsif ($cur =~/^(return|else|goto|typeof|__typeof__)\b/o) {
1699			print "KEYWORD($1)\n" if ($dbg_values > 1);
1700			$type = 'N';
1701
1702		} elsif ($cur =~ /^(\()/o) {
1703			print "PAREN('$1')\n" if ($dbg_values > 1);
1704			push(@av_paren_type, $av_pending);
1705			$av_pending = '_';
1706			$type = 'N';
1707
1708		} elsif ($cur =~ /^(\))/o) {
1709			my $new_type = pop(@av_paren_type);
1710			if ($new_type ne '_') {
1711				$type = $new_type;
1712				print "PAREN('$1') -> $type\n"
1713							if ($dbg_values > 1);
1714			} else {
1715				print "PAREN('$1')\n" if ($dbg_values > 1);
1716			}
1717
1718		} elsif ($cur =~ /^($Ident)\s*\(/o) {
1719			print "FUNC($1)\n" if ($dbg_values > 1);
1720			$type = 'V';
1721			$av_pending = 'V';
1722
1723		} elsif ($cur =~ /^($Ident\s*):(?:\s*\d+\s*(,|=|;))?/) {
1724			if (defined $2 && $type eq 'C' || $type eq 'T') {
1725				$av_pend_colon = 'B';
1726			} elsif ($type eq 'E') {
1727				$av_pend_colon = 'L';
1728			}
1729			print "IDENT_COLON($1,$type>$av_pend_colon)\n" if ($dbg_values > 1);
1730			$type = 'V';
1731
1732		} elsif ($cur =~ /^($Ident|$Constant)/o) {
1733			print "IDENT($1)\n" if ($dbg_values > 1);
1734			$type = 'V';
1735
1736		} elsif ($cur =~ /^($Assignment)/o) {
1737			print "ASSIGN($1)\n" if ($dbg_values > 1);
1738			$type = 'N';
1739
1740		} elsif ($cur =~/^(;|{|})/) {
1741			print "END($1)\n" if ($dbg_values > 1);
1742			$type = 'E';
1743			$av_pend_colon = 'O';
1744
1745		} elsif ($cur =~/^(,)/) {
1746			print "COMMA($1)\n" if ($dbg_values > 1);
1747			$type = 'C';
1748
1749		} elsif ($cur =~ /^(\?)/o) {
1750			print "QUESTION($1)\n" if ($dbg_values > 1);
1751			$type = 'N';
1752
1753		} elsif ($cur =~ /^(:)/o) {
1754			print "COLON($1,$av_pend_colon)\n" if ($dbg_values > 1);
1755
1756			substr($var, length($res), 1, $av_pend_colon);
1757			if ($av_pend_colon eq 'C' || $av_pend_colon eq 'L') {
1758				$type = 'E';
1759			} else {
1760				$type = 'N';
1761			}
1762			$av_pend_colon = 'O';
1763
1764		} elsif ($cur =~ /^(\[)/o) {
1765			print "CLOSE($1)\n" if ($dbg_values > 1);
1766			$type = 'N';
1767
1768		} elsif ($cur =~ /^(-(?![->])|\+(?!\+)|\*|\&\&|\&)/o) {
1769			my $variant;
1770
1771			print "OPV($1)\n" if ($dbg_values > 1);
1772			if ($type eq 'V') {
1773				$variant = 'B';
1774			} else {
1775				$variant = 'U';
1776			}
1777
1778			substr($var, length($res), 1, $variant);
1779			$type = 'N';
1780
1781		} elsif ($cur =~ /^($Operators)/o) {
1782			print "OP($1)\n" if ($dbg_values > 1);
1783			if ($1 ne '++' && $1 ne '--') {
1784				$type = 'N';
1785			}
1786
1787		} elsif ($cur =~ /(^.)/o) {
1788			print "C($1)\n" if ($dbg_values > 1);
1789		}
1790		if (defined $1) {
1791			$cur = substr($cur, length($1));
1792			$res .= $type x length($1);
1793		}
1794	}
1795
1796	return ($res, $var);
1797}
1798
1799sub possible {
1800	my ($possible, $line) = @_;
1801	my $notPermitted = qr{(?:
1802		^(?:
1803			$Modifier|
1804			$Storage|
1805			$Type|
1806			DEFINE_\S+
1807		)$|
1808		^(?:
1809			goto|
1810			return|
1811			case|
1812			else|
1813			asm|__asm__|
1814			do|
1815			\#|
1816			\#\#|
1817		)(?:\s|$)|
1818		^(?:typedef|struct|enum)\b
1819	    )}x;
1820	warn "CHECK<$possible> ($line)\n" if ($dbg_possible > 2);
1821	if ($possible !~ $notPermitted) {
1822		# Check for modifiers.
1823		$possible =~ s/\s*$Storage\s*//g;
1824		$possible =~ s/\s*$Sparse\s*//g;
1825		if ($possible =~ /^\s*$/) {
1826
1827		} elsif ($possible =~ /\s/) {
1828			$possible =~ s/\s*$Type\s*//g;
1829			for my $modifier (split(' ', $possible)) {
1830				if ($modifier !~ $notPermitted) {
1831					warn "MODIFIER: $modifier ($possible) ($line)\n" if ($dbg_possible);
1832					push(@modifierListFile, $modifier);
1833				}
1834			}
1835
1836		} else {
1837			warn "POSSIBLE: $possible ($line)\n" if ($dbg_possible);
1838			push(@typeListFile, $possible);
1839		}
1840		build_types();
1841	} else {
1842		warn "NOTPOSS: $possible ($line)\n" if ($dbg_possible > 1);
1843	}
1844}
1845
1846my $prefix = '';
1847
1848sub show_type {
1849	my ($type) = @_;
1850
 
 
1851	return defined $use_type{$type} if (scalar keys %use_type > 0);
1852
1853	return !defined $ignore_type{$type};
1854}
1855
1856sub report {
1857	my ($level, $type, $msg) = @_;
1858
1859	if (!show_type($type) ||
1860	    (defined $tst_only && $msg !~ /\Q$tst_only\E/)) {
1861		return 0;
1862	}
1863	my $output = '';
1864	if (-t STDOUT && $color) {
1865		if ($level eq 'ERROR') {
1866			$output .= RED;
1867		} elsif ($level eq 'WARNING') {
1868			$output .= YELLOW;
1869		} else {
1870			$output .= GREEN;
1871		}
1872	}
1873	$output .= $prefix . $level . ':';
1874	if ($show_types) {
1875		$output .= BLUE if (-t STDOUT && $color);
1876		$output .= "$type:";
1877	}
1878	$output .= RESET if (-t STDOUT && $color);
1879	$output .= ' ' . $msg . "\n";
1880
1881	if ($showfile) {
1882		my @lines = split("\n", $output, -1);
1883		splice(@lines, 1, 1);
1884		$output = join("\n", @lines);
1885	}
1886	$output = (split('\n', $output))[0] . "\n" if ($terse);
1887
1888	push(our @report, $output);
1889
1890	return 1;
1891}
1892
1893sub report_dump {
1894	our @report;
1895}
1896
1897sub fixup_current_range {
1898	my ($lineRef, $offset, $length) = @_;
1899
1900	if ($$lineRef =~ /^\@\@ -\d+,\d+ \+(\d+),(\d+) \@\@/) {
1901		my $o = $1;
1902		my $l = $2;
1903		my $no = $o + $offset;
1904		my $nl = $l + $length;
1905		$$lineRef =~ s/\+$o,$l \@\@/\+$no,$nl \@\@/;
1906	}
1907}
1908
1909sub fix_inserted_deleted_lines {
1910	my ($linesRef, $insertedRef, $deletedRef) = @_;
1911
1912	my $range_last_linenr = 0;
1913	my $delta_offset = 0;
1914
1915	my $old_linenr = 0;
1916	my $new_linenr = 0;
1917
1918	my $next_insert = 0;
1919	my $next_delete = 0;
1920
1921	my @lines = ();
1922
1923	my $inserted = @{$insertedRef}[$next_insert++];
1924	my $deleted = @{$deletedRef}[$next_delete++];
1925
1926	foreach my $old_line (@{$linesRef}) {
1927		my $save_line = 1;
1928		my $line = $old_line;	#don't modify the array
1929		if ($line =~ /^(?:\+\+\+|\-\-\-)\s+\S+/) {	#new filename
1930			$delta_offset = 0;
1931		} elsif ($line =~ /^\@\@ -\d+,\d+ \+\d+,\d+ \@\@/) {	#new hunk
1932			$range_last_linenr = $new_linenr;
1933			fixup_current_range(\$line, $delta_offset, 0);
1934		}
1935
1936		while (defined($deleted) && ${$deleted}{'LINENR'} == $old_linenr) {
1937			$deleted = @{$deletedRef}[$next_delete++];
1938			$save_line = 0;
1939			fixup_current_range(\$lines[$range_last_linenr], $delta_offset--, -1);
1940		}
1941
1942		while (defined($inserted) && ${$inserted}{'LINENR'} == $old_linenr) {
1943			push(@lines, ${$inserted}{'LINE'});
1944			$inserted = @{$insertedRef}[$next_insert++];
1945			$new_linenr++;
1946			fixup_current_range(\$lines[$range_last_linenr], $delta_offset++, 1);
1947		}
1948
1949		if ($save_line) {
1950			push(@lines, $line);
1951			$new_linenr++;
1952		}
1953
1954		$old_linenr++;
1955	}
1956
1957	return @lines;
1958}
1959
1960sub fix_insert_line {
1961	my ($linenr, $line) = @_;
1962
1963	my $inserted = {
1964		LINENR => $linenr,
1965		LINE => $line,
1966	};
1967	push(@fixed_inserted, $inserted);
1968}
1969
1970sub fix_delete_line {
1971	my ($linenr, $line) = @_;
1972
1973	my $deleted = {
1974		LINENR => $linenr,
1975		LINE => $line,
1976	};
1977
1978	push(@fixed_deleted, $deleted);
1979}
1980
1981sub ERROR {
1982	my ($type, $msg) = @_;
1983
1984	if (report("ERROR", $type, $msg)) {
1985		our $clean = 0;
1986		our $cnt_error++;
1987		return 1;
1988	}
1989	return 0;
1990}
1991sub WARN {
1992	my ($type, $msg) = @_;
1993
1994	if (report("WARNING", $type, $msg)) {
1995		our $clean = 0;
1996		our $cnt_warn++;
1997		return 1;
1998	}
1999	return 0;
2000}
2001sub CHK {
2002	my ($type, $msg) = @_;
2003
2004	if ($check && report("CHECK", $type, $msg)) {
2005		our $clean = 0;
2006		our $cnt_chk++;
2007		return 1;
2008	}
2009	return 0;
2010}
2011
2012sub check_absolute_file {
2013	my ($absolute, $herecurr) = @_;
2014	my $file = $absolute;
2015
2016	##print "absolute<$absolute>\n";
2017
2018	# See if any suffix of this path is a path within the tree.
2019	while ($file =~ s@^[^/]*/@@) {
2020		if (-f "$root/$file") {
2021			##print "file<$file>\n";
2022			last;
2023		}
2024	}
2025	if (! -f _)  {
2026		return 0;
2027	}
2028
2029	# It is, so see if the prefix is acceptable.
2030	my $prefix = $absolute;
2031	substr($prefix, -length($file)) = '';
2032
2033	##print "prefix<$prefix>\n";
2034	if ($prefix ne ".../") {
2035		WARN("USE_RELATIVE_PATH",
2036		     "use relative pathname instead of absolute in changelog text\n" . $herecurr);
2037	}
2038}
2039
2040sub trim {
2041	my ($string) = @_;
2042
2043	$string =~ s/^\s+|\s+$//g;
2044
2045	return $string;
2046}
2047
2048sub ltrim {
2049	my ($string) = @_;
2050
2051	$string =~ s/^\s+//;
2052
2053	return $string;
2054}
2055
2056sub rtrim {
2057	my ($string) = @_;
2058
2059	$string =~ s/\s+$//;
2060
2061	return $string;
2062}
2063
2064sub string_find_replace {
2065	my ($string, $find, $replace) = @_;
2066
2067	$string =~ s/$find/$replace/g;
2068
2069	return $string;
2070}
2071
2072sub tabify {
2073	my ($leading) = @_;
2074
2075	my $source_indent = 8;
2076	my $max_spaces_before_tab = $source_indent - 1;
2077	my $spaces_to_tab = " " x $source_indent;
2078
2079	#convert leading spaces to tabs
2080	1 while $leading =~ s@^([\t]*)$spaces_to_tab@$1\t@g;
2081	#Remove spaces before a tab
2082	1 while $leading =~ s@^([\t]*)( {1,$max_spaces_before_tab})\t@$1\t@g;
2083
2084	return "$leading";
2085}
2086
2087sub pos_last_openparen {
2088	my ($line) = @_;
2089
2090	my $pos = 0;
2091
2092	my $opens = $line =~ tr/\(/\(/;
2093	my $closes = $line =~ tr/\)/\)/;
2094
2095	my $last_openparen = 0;
2096
2097	if (($opens == 0) || ($closes >= $opens)) {
2098		return -1;
2099	}
2100
2101	my $len = length($line);
2102
2103	for ($pos = 0; $pos < $len; $pos++) {
2104		my $string = substr($line, $pos);
2105		if ($string =~ /^($FuncArg|$balanced_parens)/) {
2106			$pos += length($1) - 1;
2107		} elsif (substr($line, $pos, 1) eq '(') {
2108			$last_openparen = $pos;
2109		} elsif (index($string, '(') == -1) {
2110			last;
2111		}
2112	}
2113
2114	return length(expand_tabs(substr($line, 0, $last_openparen))) + 1;
2115}
2116
2117sub process {
2118	my $filename = shift;
2119
2120	my $linenr=0;
2121	my $prevline="";
2122	my $prevrawline="";
2123	my $stashline="";
2124	my $stashrawline="";
2125
2126	my $length;
2127	my $indent;
2128	my $previndent=0;
2129	my $stashindent=0;
2130
2131	our $clean = 1;
2132	my $signoff = 0;
2133	my $is_patch = 0;
2134	my $in_header_lines = $file ? 0 : 1;
2135	my $in_commit_log = 0;		#Scanning lines before patch
2136	my $has_commit_log = 0;		#Encountered lines before patch
2137       my $commit_log_possible_stack_dump = 0;
2138	my $commit_log_long_line = 0;
2139	my $commit_log_has_diff = 0;
2140	my $reported_maintainer_file = 0;
2141	my $non_utf8_charset = 0;
2142
2143	my $last_blank_line = 0;
2144	my $last_coalesced_string_linenr = -1;
2145
2146	our @report = ();
2147	our $cnt_lines = 0;
2148	our $cnt_error = 0;
2149	our $cnt_warn = 0;
2150	our $cnt_chk = 0;
2151
2152	# Trace the real file/line as we go.
2153	my $realfile = '';
2154	my $realline = 0;
2155	my $realcnt = 0;
2156	my $here = '';
 
2157	my $in_comment = 0;
2158	my $comment_edge = 0;
2159	my $first_line = 0;
2160	my $p1_prefix = '';
2161
2162	my $prev_values = 'E';
2163
2164	# suppression flags
2165	my %suppress_ifbraces;
2166	my %suppress_whiletrailers;
2167	my %suppress_export;
2168	my $suppress_statement = 0;
2169
2170	my %signatures = ();
2171
2172	# Pre-scan the patch sanitizing the lines.
2173	# Pre-scan the patch looking for any __setup documentation.
2174	#
2175	my @setup_docs = ();
2176	my $setup_docs = 0;
2177
2178	my $camelcase_file_seeded = 0;
2179
 
 
2180	sanitise_line_reset();
2181	my $line;
2182	foreach my $rawline (@rawlines) {
2183		$linenr++;
2184		$line = $rawline;
2185
2186		push(@fixed, $rawline) if ($fix);
2187
2188		if ($rawline=~/^\+\+\+\s+(\S+)/) {
2189			$setup_docs = 0;
2190			if ($1 =~ m@Documentation/admin-guide/kernel-parameters.rst$@) {
2191				$setup_docs = 1;
2192			}
2193			#next;
2194		}
2195		if ($rawline=~/^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@/) {
2196			$realline=$1-1;
2197			if (defined $2) {
2198				$realcnt=$3+1;
2199			} else {
2200				$realcnt=1+1;
2201			}
2202			$in_comment = 0;
2203
2204			# Guestimate if this is a continuing comment.  Run
2205			# the context looking for a comment "edge".  If this
2206			# edge is a close comment then we must be in a comment
2207			# at context start.
2208			my $edge;
2209			my $cnt = $realcnt;
2210			for (my $ln = $linenr + 1; $cnt > 0; $ln++) {
2211				next if (defined $rawlines[$ln - 1] &&
2212					 $rawlines[$ln - 1] =~ /^-/);
2213				$cnt--;
2214				#print "RAW<$rawlines[$ln - 1]>\n";
2215				last if (!defined $rawlines[$ln - 1]);
2216				if ($rawlines[$ln - 1] =~ m@(/\*|\*/)@ &&
2217				    $rawlines[$ln - 1] !~ m@"[^"]*(?:/\*|\*/)[^"]*"@) {
2218					($edge) = $1;
2219					last;
2220				}
2221			}
2222			if (defined $edge && $edge eq '*/') {
2223				$in_comment = 1;
2224			}
2225
2226			# Guestimate if this is a continuing comment.  If this
2227			# is the start of a diff block and this line starts
2228			# ' *' then it is very likely a comment.
2229			if (!defined $edge &&
2230			    $rawlines[$linenr] =~ m@^.\s*(?:\*\*+| \*)(?:\s|$)@)
2231			{
2232				$in_comment = 1;
2233			}
2234
2235			##print "COMMENT:$in_comment edge<$edge> $rawline\n";
2236			sanitise_line_reset($in_comment);
2237
2238		} elsif ($realcnt && $rawline =~ /^(?:\+| |$)/) {
2239			# Standardise the strings and chars within the input to
2240			# simplify matching -- only bother with positive lines.
2241			$line = sanitise_line($rawline);
2242		}
2243		push(@lines, $line);
2244
2245		if ($realcnt > 1) {
2246			$realcnt-- if ($line =~ /^(?:\+| |$)/);
2247		} else {
2248			$realcnt = 0;
2249		}
2250
2251		#print "==>$rawline\n";
2252		#print "-->$line\n";
2253
2254		if ($setup_docs && $line =~ /^\+/) {
2255			push(@setup_docs, $line);
2256		}
2257	}
2258
2259	$prefix = '';
2260
2261	$realcnt = 0;
2262	$linenr = 0;
2263	$fixlinenr = -1;
2264	foreach my $line (@lines) {
2265		$linenr++;
2266		$fixlinenr++;
2267		my $sline = $line;	#copy of $line
2268		$sline =~ s/$;/ /g;	#with comments as spaces
2269
2270		my $rawline = $rawlines[$linenr - 1];
2271
2272#extract the line range in the file after the patch is applied
2273		if (!$in_commit_log &&
2274		    $line =~ /^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@/) {
 
2275			$is_patch = 1;
2276			$first_line = $linenr + 1;
2277			$realline=$1-1;
2278			if (defined $2) {
2279				$realcnt=$3+1;
2280			} else {
2281				$realcnt=1+1;
2282			}
2283			annotate_reset();
2284			$prev_values = 'E';
2285
2286			%suppress_ifbraces = ();
2287			%suppress_whiletrailers = ();
2288			%suppress_export = ();
2289			$suppress_statement = 0;
 
 
 
 
 
2290			next;
2291
2292# track the line number as we move through the hunk, note that
2293# new versions of GNU diff omit the leading space on completely
2294# blank context lines so we need to count that too.
2295		} elsif ($line =~ /^( |\+|$)/) {
2296			$realline++;
2297			$realcnt-- if ($realcnt != 0);
2298
2299			# Measure the line length and indent.
2300			($length, $indent) = line_stats($rawline);
2301
2302			# Track the previous line.
2303			($prevline, $stashline) = ($stashline, $line);
2304			($previndent, $stashindent) = ($stashindent, $indent);
2305			($prevrawline, $stashrawline) = ($stashrawline, $rawline);
2306
2307			#warn "line<$line>\n";
2308
2309		} elsif ($realcnt == 1) {
2310			$realcnt--;
2311		}
2312
2313		my $hunk_line = ($realcnt != 0);
2314
2315		$here = "#$linenr: " if (!$file);
2316		$here = "#$realline: " if ($file);
2317
2318		my $found_file = 0;
2319		# extract the filename as it passes
2320		if ($line =~ /^diff --git.*?(\S+)$/) {
2321			$realfile = $1;
2322			$realfile =~ s@^([^/]*)/@@ if (!$file);
2323			$in_commit_log = 0;
2324			$found_file = 1;
2325		} elsif ($line =~ /^\+\+\+\s+(\S+)/) {
2326			$realfile = $1;
2327			$realfile =~ s@^([^/]*)/@@ if (!$file);
2328			$in_commit_log = 0;
2329
2330			$p1_prefix = $1;
2331			if (!$file && $tree && $p1_prefix ne '' &&
2332			    -e "$root/$p1_prefix") {
2333				WARN("PATCH_PREFIX",
2334				     "patch prefix '$p1_prefix' exists, appears to be a -p0 patch\n");
2335			}
2336
2337			if ($realfile =~ m@^include/asm/@) {
2338				ERROR("MODIFIED_INCLUDE_ASM",
2339				      "do not modify files in include/asm, change architecture specific files in include/asm-<architecture>\n" . "$here$rawline\n");
2340			}
2341			$found_file = 1;
2342		}
2343
2344#make up the handle for any error we report on this line
2345		if ($showfile) {
2346			$prefix = "$realfile:$realline: "
2347		} elsif ($emacs) {
2348			if ($file) {
2349				$prefix = "$filename:$realline: ";
2350			} else {
2351				$prefix = "$filename:$linenr: ";
2352			}
2353		}
2354
2355		if ($found_file) {
2356			if (is_maintained_obsolete($realfile)) {
2357				WARN("OBSOLETE",
2358				     "$realfile is marked as 'obsolete' in the MAINTAINERS hierarchy.  No unnecessary modifications please.\n");
2359			}
2360			if ($realfile =~ m@^(?:drivers/net/|net/|drivers/staging/)@) {
2361				$check = 1;
2362			} else {
2363				$check = $check_orig;
2364			}
 
2365			next;
2366		}
2367
2368		$here .= "FILE: $realfile:$realline:" if ($realcnt != 0);
2369
2370		my $hereline = "$here\n$rawline\n";
2371		my $herecurr = "$here\n$rawline\n";
2372		my $hereprev = "$here\n$prevrawline\n$rawline\n";
2373
2374		$cnt_lines++ if ($realcnt != 0);
2375
2376# Check if the commit log has what seems like a diff which can confuse patch
2377		if ($in_commit_log && !$commit_log_has_diff &&
2378		    (($line =~ m@^\s+diff\b.*a/[\w/]+@ &&
2379		      $line =~ m@^\s+diff\b.*a/([\w/]+)\s+b/$1\b@) ||
2380		     $line =~ m@^\s*(?:\-\-\-\s+a/|\+\+\+\s+b/)@ ||
2381		     $line =~ m/^\s*\@\@ \-\d+,\d+ \+\d+,\d+ \@\@/)) {
2382			ERROR("DIFF_IN_COMMIT_MSG",
2383			      "Avoid using diff content in the commit message - patch(1) might not work\n" . $herecurr);
2384			$commit_log_has_diff = 1;
2385		}
2386
2387# Check for incorrect file permissions
2388		if ($line =~ /^new (file )?mode.*[7531]\d{0,2}$/) {
2389			my $permhere = $here . "FILE: $realfile\n";
2390			if ($realfile !~ m@scripts/@ &&
2391			    $realfile !~ /\.(py|pl|awk|sh)$/) {
2392				ERROR("EXECUTE_PERMISSIONS",
2393				      "do not set execute permissions for source files\n" . $permhere);
2394			}
2395		}
2396
2397# Check the patch for a signoff:
2398		if ($line =~ /^\s*signed-off-by:/i) {
2399			$signoff++;
2400			$in_commit_log = 0;
2401		}
2402
2403# Check if MAINTAINERS is being updated.  If so, there's probably no need to
2404# emit the "does MAINTAINERS need updating?" message on file add/move/delete
2405		if ($line =~ /^\s*MAINTAINERS\s*\|/) {
2406			$reported_maintainer_file = 1;
2407		}
2408
2409# Check signature styles
2410		if (!$in_header_lines &&
2411		    $line =~ /^(\s*)([a-z0-9_-]+by:|$signature_tags)(\s*)(.*)/i) {
2412			my $space_before = $1;
2413			my $sign_off = $2;
2414			my $space_after = $3;
2415			my $email = $4;
2416			my $ucfirst_sign_off = ucfirst(lc($sign_off));
2417
2418			if ($sign_off !~ /$signature_tags/) {
2419				WARN("BAD_SIGN_OFF",
2420				     "Non-standard signature: $sign_off\n" . $herecurr);
2421			}
2422			if (defined $space_before && $space_before ne "") {
2423				if (WARN("BAD_SIGN_OFF",
2424					 "Do not use whitespace before $ucfirst_sign_off\n" . $herecurr) &&
2425				    $fix) {
2426					$fixed[$fixlinenr] =
2427					    "$ucfirst_sign_off $email";
2428				}
2429			}
2430			if ($sign_off =~ /-by:$/i && $sign_off ne $ucfirst_sign_off) {
2431				if (WARN("BAD_SIGN_OFF",
2432					 "'$ucfirst_sign_off' is the preferred signature form\n" . $herecurr) &&
2433				    $fix) {
2434					$fixed[$fixlinenr] =
2435					    "$ucfirst_sign_off $email";
2436				}
2437
2438			}
2439			if (!defined $space_after || $space_after ne " ") {
2440				if (WARN("BAD_SIGN_OFF",
2441					 "Use a single space after $ucfirst_sign_off\n" . $herecurr) &&
2442				    $fix) {
2443					$fixed[$fixlinenr] =
2444					    "$ucfirst_sign_off $email";
2445				}
2446			}
2447
2448			my ($email_name, $email_address, $comment) = parse_email($email);
2449			my $suggested_email = format_email(($email_name, $email_address));
2450			if ($suggested_email eq "") {
2451				ERROR("BAD_SIGN_OFF",
2452				      "Unrecognized email address: '$email'\n" . $herecurr);
2453			} else {
2454				my $dequoted = $suggested_email;
2455				$dequoted =~ s/^"//;
2456				$dequoted =~ s/" </ </;
2457				# Don't force email to have quotes
2458				# Allow just an angle bracketed address
2459				if ("$dequoted$comment" ne $email &&
2460				    "<$email_address>$comment" ne $email &&
2461				    "$suggested_email$comment" ne $email) {
2462					WARN("BAD_SIGN_OFF",
2463					     "email address '$email' might be better as '$suggested_email$comment'\n" . $herecurr);
2464				}
2465			}
2466
2467# Check for duplicate signatures
2468			my $sig_nospace = $line;
2469			$sig_nospace =~ s/\s//g;
2470			$sig_nospace = lc($sig_nospace);
2471			if (defined $signatures{$sig_nospace}) {
2472				WARN("BAD_SIGN_OFF",
2473				     "Duplicate signature\n" . $herecurr);
2474			} else {
2475				$signatures{$sig_nospace} = 1;
2476			}
2477		}
2478
2479# Check email subject for common tools that don't need to be mentioned
2480		if ($in_header_lines &&
2481		    $line =~ /^Subject:.*\b(?:checkpatch|sparse|smatch)\b[^:]/i) {
2482			WARN("EMAIL_SUBJECT",
2483			     "A patch subject line should describe the change not the tool that found it\n" . $herecurr);
2484		}
2485
2486# Check for old stable address
2487		if ($line =~ /^\s*cc:\s*.*<?\bstable\@kernel\.org\b>?.*$/i) {
2488			ERROR("STABLE_ADDRESS",
2489			      "The 'stable' address should be 'stable\@vger.kernel.org'\n" . $herecurr);
2490		}
2491
2492# Check for unwanted Gerrit info
2493		if ($in_commit_log && $line =~ /^\s*change-id:/i) {
2494			ERROR("GERRIT_CHANGE_ID",
2495			      "Remove Gerrit Change-Id's before submitting upstream.\n" . $herecurr);
2496		}
2497
2498# Check if the commit log is in a possible stack dump
2499		if ($in_commit_log && !$commit_log_possible_stack_dump &&
2500		    ($line =~ /^\s*(?:WARNING:|BUG:)/ ||
2501		     $line =~ /^\s*\[\s*\d+\.\d{6,6}\s*\]/ ||
2502					# timestamp
2503		     $line =~ /^\s*\[\<[0-9a-fA-F]{8,}\>\]/)) {
2504					# stack dump address
2505			$commit_log_possible_stack_dump = 1;
2506		}
2507
2508# Check for line lengths > 75 in commit log, warn once
2509		if ($in_commit_log && !$commit_log_long_line &&
2510		    length($line) > 75 &&
2511		    !($line =~ /^\s*[a-zA-Z0-9_\/\.]+\s+\|\s+\d+/ ||
2512					# file delta changes
2513		      $line =~ /^\s*(?:[\w\.\-]+\/)++[\w\.\-]+:/ ||
2514					# filename then :
2515		      $line =~ /^\s*(?:Fixes:|Link:)/i ||
2516					# A Fixes: or Link: line
2517		      $commit_log_possible_stack_dump)) {
2518			WARN("COMMIT_LOG_LONG_LINE",
2519			     "Possible unwrapped commit description (prefer a maximum 75 chars per line)\n" . $herecurr);
2520			$commit_log_long_line = 1;
2521		}
2522
2523# Reset possible stack dump if a blank line is found
2524		if ($in_commit_log && $commit_log_possible_stack_dump &&
2525		    $line =~ /^\s*$/) {
2526			$commit_log_possible_stack_dump = 0;
2527		}
2528
2529# Check for git id commit length and improperly formed commit descriptions
2530		if ($in_commit_log && !$commit_log_possible_stack_dump &&
2531		    $line !~ /^\s*(?:Link|Patchwork|http|https|BugLink):/i &&
 
2532		    ($line =~ /\bcommit\s+[0-9a-f]{5,}\b/i ||
2533		     ($line =~ /(?:\s|^)[0-9a-f]{12,40}(?:[\s"'\(\[]|$)/i &&
2534		      $line !~ /[\<\[][0-9a-f]{12,40}[\>\]]/i &&
2535		      $line !~ /\bfixes:\s*[0-9a-f]{12,40}/i))) {
2536			my $init_char = "c";
2537			my $orig_commit = "";
2538			my $short = 1;
2539			my $long = 0;
2540			my $case = 1;
2541			my $space = 1;
2542			my $hasdesc = 0;
2543			my $hasparens = 0;
2544			my $id = '0123456789ab';
2545			my $orig_desc = "commit description";
2546			my $description = "";
2547
2548			if ($line =~ /\b(c)ommit\s+([0-9a-f]{5,})\b/i) {
2549				$init_char = $1;
2550				$orig_commit = lc($2);
2551			} elsif ($line =~ /\b([0-9a-f]{12,40})\b/i) {
2552				$orig_commit = lc($1);
2553			}
2554
2555			$short = 0 if ($line =~ /\bcommit\s+[0-9a-f]{12,40}/i);
2556			$long = 1 if ($line =~ /\bcommit\s+[0-9a-f]{41,}/i);
2557			$space = 0 if ($line =~ /\bcommit [0-9a-f]/i);
2558			$case = 0 if ($line =~ /\b[Cc]ommit\s+[0-9a-f]{5,40}[^A-F]/);
2559			if ($line =~ /\bcommit\s+[0-9a-f]{5,}\s+\("([^"]+)"\)/i) {
2560				$orig_desc = $1;
2561				$hasparens = 1;
2562			} elsif ($line =~ /\bcommit\s+[0-9a-f]{5,}\s*$/i &&
2563				 defined $rawlines[$linenr] &&
2564				 $rawlines[$linenr] =~ /^\s*\("([^"]+)"\)/) {
2565				$orig_desc = $1;
2566				$hasparens = 1;
2567			} elsif ($line =~ /\bcommit\s+[0-9a-f]{5,}\s+\("[^"]+$/i &&
2568				 defined $rawlines[$linenr] &&
2569				 $rawlines[$linenr] =~ /^\s*[^"]+"\)/) {
2570				$line =~ /\bcommit\s+[0-9a-f]{5,}\s+\("([^"]+)$/i;
2571				$orig_desc = $1;
2572				$rawlines[$linenr] =~ /^\s*([^"]+)"\)/;
2573				$orig_desc .= " " . $1;
2574				$hasparens = 1;
2575			}
2576
2577			($id, $description) = git_commit_info($orig_commit,
2578							      $id, $orig_desc);
2579
2580			if ($short || $long || $space || $case || ($orig_desc ne $description) || !$hasparens) {
 
2581				ERROR("GIT_COMMIT_ID",
2582				      "Please use git commit description style 'commit <12+ chars of sha1> (\"<title line>\")' - ie: '${init_char}ommit $id (\"$description\")'\n" . $herecurr);
2583			}
2584		}
2585
2586# Check for added, moved or deleted files
2587		if (!$reported_maintainer_file && !$in_commit_log &&
2588		    ($line =~ /^(?:new|deleted) file mode\s*\d+\s*$/ ||
2589		     $line =~ /^rename (?:from|to) [\w\/\.\-]+\s*$/ ||
2590		     ($line =~ /\{\s*([\w\/\.\-]*)\s*\=\>\s*([\w\/\.\-]*)\s*\}/ &&
2591		      (defined($1) || defined($2))))) {
2592			$is_patch = 1;
2593			$reported_maintainer_file = 1;
2594			WARN("FILE_PATH_CHANGES",
2595			     "added, moved or deleted file(s), does MAINTAINERS need updating?\n" . $herecurr);
2596		}
2597
2598# Check for wrappage within a valid hunk of the file
2599		if ($realcnt != 0 && $line !~ m{^(?:\+|-| |\\ No newline|$)}) {
2600			ERROR("CORRUPTED_PATCH",
2601			      "patch seems to be corrupt (line wrapped?)\n" .
2602				$herecurr) if (!$emitted_corrupt++);
2603		}
2604
2605# UTF-8 regex found at http://www.w3.org/International/questions/qa-forms-utf-8.en.php
2606		if (($realfile =~ /^$/ || $line =~ /^\+/) &&
2607		    $rawline !~ m/^$UTF8*$/) {
2608			my ($utf8_prefix) = ($rawline =~ /^($UTF8*)/);
2609
2610			my $blank = copy_spacing($rawline);
2611			my $ptr = substr($blank, 0, length($utf8_prefix)) . "^";
2612			my $hereptr = "$hereline$ptr\n";
2613
2614			CHK("INVALID_UTF8",
2615			    "Invalid UTF-8, patch and commit message should be encoded in UTF-8\n" . $hereptr);
2616		}
2617
2618# Check if it's the start of a commit log
2619# (not a header line and we haven't seen the patch filename)
2620		if ($in_header_lines && $realfile =~ /^$/ &&
2621		    !($rawline =~ /^\s+\S/ ||
2622		      $rawline =~ /^(commit\b|from\b|[\w-]+:).*$/i)) {
2623			$in_header_lines = 0;
2624			$in_commit_log = 1;
2625			$has_commit_log = 1;
2626		}
2627
2628# Check if there is UTF-8 in a commit log when a mail header has explicitly
2629# declined it, i.e defined some charset where it is missing.
2630		if ($in_header_lines &&
2631		    $rawline =~ /^Content-Type:.+charset="(.+)".*$/ &&
2632		    $1 !~ /utf-8/i) {
2633			$non_utf8_charset = 1;
2634		}
2635
2636		if ($in_commit_log && $non_utf8_charset && $realfile =~ /^$/ &&
2637		    $rawline =~ /$NON_ASCII_UTF8/) {
2638			WARN("UTF8_BEFORE_PATCH",
2639			    "8-bit UTF-8 used in possible commit log\n" . $herecurr);
2640		}
2641
2642# Check for absolute kernel paths in commit message
2643		if ($tree && $in_commit_log) {
2644			while ($line =~ m{(?:^|\s)(/\S*)}g) {
2645				my $file = $1;
2646
2647				if ($file =~ m{^(.*?)(?::\d+)+:?$} &&
2648				    check_absolute_file($1, $herecurr)) {
2649					#
2650				} else {
2651					check_absolute_file($file, $herecurr);
2652				}
2653			}
2654		}
2655
2656# Check for various typo / spelling mistakes
2657		if (defined($misspellings) &&
2658		    ($in_commit_log || $line =~ /^(?:\+|Subject:)/i)) {
2659			while ($rawline =~ /(?:^|[^a-z@])($misspellings)(?:\b|$|[^a-z@])/gi) {
2660				my $typo = $1;
2661				my $typo_fix = $spelling_fix{lc($typo)};
2662				$typo_fix = ucfirst($typo_fix) if ($typo =~ /^[A-Z]/);
2663				$typo_fix = uc($typo_fix) if ($typo =~ /^[A-Z]+$/);
2664				my $msg_type = \&WARN;
2665				$msg_type = \&CHK if ($file);
2666				if (&{$msg_type}("TYPO_SPELLING",
2667						 "'$typo' may be misspelled - perhaps '$typo_fix'?\n" . $herecurr) &&
2668				    $fix) {
2669					$fixed[$fixlinenr] =~ s/(^|[^A-Za-z@])($typo)($|[^A-Za-z@])/$1$typo_fix$3/;
2670				}
2671			}
2672		}
2673
2674# ignore non-hunk lines and lines being removed
2675		next if (!$hunk_line || $line =~ /^-/);
2676
2677#trailing whitespace
2678		if ($line =~ /^\+.*\015/) {
2679			my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2680			if (ERROR("DOS_LINE_ENDINGS",
2681				  "DOS line endings\n" . $herevet) &&
2682			    $fix) {
2683				$fixed[$fixlinenr] =~ s/[\s\015]+$//;
2684			}
2685		} elsif ($rawline =~ /^\+.*\S\s+$/ || $rawline =~ /^\+\s+$/) {
2686			my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2687			if (ERROR("TRAILING_WHITESPACE",
2688				  "trailing whitespace\n" . $herevet) &&
2689			    $fix) {
2690				$fixed[$fixlinenr] =~ s/\s+$//;
2691			}
2692
2693			$rpt_cleaners = 1;
2694		}
2695
2696# Check for FSF mailing addresses.
2697		if ($rawline =~ /\bwrite to the Free/i ||
 
2698		    $rawline =~ /\b59\s+Temple\s+Pl/i ||
2699		    $rawline =~ /\b51\s+Franklin\s+St/i) {
2700			my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2701			my $msg_type = \&ERROR;
2702			$msg_type = \&CHK if ($file);
2703			&{$msg_type}("FSF_MAILING_ADDRESS",
2704				     "Do not include the paragraph about writing to the Free Software Foundation's mailing address from the sample GPL notice. The FSF has changed addresses in the past, and may do so again. Linux already includes a copy of the GPL.\n" . $herevet)
2705		}
2706
2707# check for Kconfig help text having a real description
2708# Only applies when adding the entry originally, after that we do not have
2709# sufficient context to determine whether it is indeed long enough.
2710		if ($realfile =~ /Kconfig/ &&
2711		    $line =~ /^\+\s*config\s+/) {
 
 
 
2712			my $length = 0;
2713			my $cnt = $realcnt;
2714			my $ln = $linenr + 1;
2715			my $f;
2716			my $is_start = 0;
2717			my $is_end = 0;
2718			for (; $cnt > 0 && defined $lines[$ln - 1]; $ln++) {
2719				$f = $lines[$ln - 1];
2720				$cnt-- if ($lines[$ln - 1] !~ /^-/);
2721				$is_end = $lines[$ln - 1] =~ /^\+/;
2722
2723				next if ($f =~ /^-/);
2724				last if (!$file && $f =~ /^\@\@/);
2725
2726				if ($lines[$ln - 1] =~ /^\+\s*(?:bool|tristate)\s*\"/) {
2727					$is_start = 1;
2728				} elsif ($lines[$ln - 1] =~ /^\+\s*(?:---)?help(?:---)?$/) {
 
 
 
 
2729					$length = -1;
2730				}
2731
2732				$f =~ s/^.//;
2733				$f =~ s/#.*//;
2734				$f =~ s/^\s+//;
2735				next if ($f =~ /^$/);
2736				if ($f =~ /^\s*config\s/) {
 
 
 
 
 
 
2737					$is_end = 1;
2738					last;
2739				}
2740				$length++;
2741			}
2742			if ($is_start && $is_end && $length < $min_conf_desc_length) {
2743				WARN("CONFIG_DESCRIPTION",
2744				     "please write a paragraph that describes the config symbol fully\n" . $herecurr);
2745			}
2746			#print "is_start<$is_start> is_end<$is_end> length<$length>\n";
2747		}
2748
2749# discourage the addition of CONFIG_EXPERIMENTAL in Kconfig.
2750		if ($realfile =~ /Kconfig/ &&
2751		    $line =~ /.\s*depends on\s+.*\bEXPERIMENTAL\b/) {
2752			WARN("CONFIG_EXPERIMENTAL",
2753			     "Use of CONFIG_EXPERIMENTAL is deprecated. For alternatives, see https://lkml.org/lkml/2012/10/23/580\n");
 
 
 
 
2754		}
2755
2756# discourage the use of boolean for type definition attributes of Kconfig options
2757		if ($realfile =~ /Kconfig/ &&
2758		    $line =~ /^\+\s*\bboolean\b/) {
2759			WARN("CONFIG_TYPE_BOOLEAN",
2760			     "Use of boolean is deprecated, please use bool instead.\n" . $herecurr);
2761		}
2762
2763		if (($realfile =~ /Makefile.*/ || $realfile =~ /Kbuild.*/) &&
2764		    ($line =~ /\+(EXTRA_[A-Z]+FLAGS).*/)) {
2765			my $flag = $1;
2766			my $replacement = {
2767				'EXTRA_AFLAGS' =>   'asflags-y',
2768				'EXTRA_CFLAGS' =>   'ccflags-y',
2769				'EXTRA_CPPFLAGS' => 'cppflags-y',
2770				'EXTRA_LDFLAGS' =>  'ldflags-y',
2771			};
2772
2773			WARN("DEPRECATED_VARIABLE",
2774			     "Use of $flag is deprecated, please use \`$replacement->{$flag} instead.\n" . $herecurr) if ($replacement->{$flag});
2775		}
2776
2777# check for DT compatible documentation
2778		if (defined $root &&
2779			(($realfile =~ /\.dtsi?$/ && $line =~ /^\+\s*compatible\s*=\s*\"/) ||
2780			 ($realfile =~ /\.[ch]$/ && $line =~ /^\+.*\.compatible\s*=\s*\"/))) {
2781
2782			my @compats = $rawline =~ /\"([a-zA-Z0-9\-\,\.\+_]+)\"/g;
2783
2784			my $dt_path = $root . "/Documentation/devicetree/bindings/";
2785			my $vp_file = $dt_path . "vendor-prefixes.txt";
2786
2787			foreach my $compat (@compats) {
2788				my $compat2 = $compat;
2789				$compat2 =~ s/\,[a-zA-Z0-9]*\-/\,<\.\*>\-/;
2790				my $compat3 = $compat;
2791				$compat3 =~ s/\,([a-z]*)[0-9]*\-/\,$1<\.\*>\-/;
2792				`grep -Erq "$compat|$compat2|$compat3" $dt_path`;
2793				if ( $? >> 8 ) {
2794					WARN("UNDOCUMENTED_DT_STRING",
2795					     "DT compatible string \"$compat\" appears un-documented -- check $dt_path\n" . $herecurr);
2796				}
2797
2798				next if $compat !~ /^([a-zA-Z0-9\-]+)\,/;
2799				my $vendor = $1;
2800				`grep -Eq "^$vendor\\b" $vp_file`;
2801				if ( $? >> 8 ) {
2802					WARN("UNDOCUMENTED_DT_STRING",
2803					     "DT compatible string vendor \"$vendor\" appears un-documented -- check $vp_file\n" . $herecurr);
2804				}
2805			}
2806		}
2807
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2808# check we are in a valid source file if not then ignore this hunk
2809		next if ($realfile !~ /\.(h|c|s|S|sh|dtsi|dts)$/);
2810
2811# line length limit (with some exclusions)
2812#
2813# There are a few types of lines that may extend beyond $max_line_length:
2814#	logging functions like pr_info that end in a string
2815#	lines with a single string
2816#	#defines that are a single string
 
2817#
2818# There are 3 different line length message types:
2819# LONG_LINE_COMMENT	a comment starts before but extends beyond $max_linelength
2820# LONG_LINE_STRING	a string starts before but extends beyond $max_line_length
2821# LONG_LINE		all other lines longer than $max_line_length
2822#
2823# if LONG_LINE is ignored, the other 2 types are also ignored
2824#
2825
2826		if ($line =~ /^\+/ && $length > $max_line_length) {
2827			my $msg_type = "LONG_LINE";
2828
2829			# Check the allowed long line types first
2830
2831			# logging functions that end in a string that starts
2832			# before $max_line_length
2833			if ($line =~ /^\+\s*$logFunctions\s*\(\s*(?:(?:KERN_\S+\s*|[^"]*))?($String\s*(?:|,|\)\s*;)\s*)$/ &&
2834			    length(expand_tabs(substr($line, 1, length($line) - length($1) - 1))) <= $max_line_length) {
2835				$msg_type = "";
2836
2837			# lines with only strings (w/ possible termination)
2838			# #defines with only strings
2839			} elsif ($line =~ /^\+\s*$String\s*(?:\s*|,|\)\s*;)\s*$/ ||
2840				 $line =~ /^\+\s*#\s*define\s+\w+\s+$String$/) {
2841				$msg_type = "";
2842
2843			# EFI_GUID is another special case
2844			} elsif ($line =~ /^\+.*\bEFI_GUID\s*\(/) {
 
 
 
 
 
2845				$msg_type = "";
2846
2847			# Otherwise set the alternate message types
2848
2849			# a comment starts before $max_line_length
2850			} elsif ($line =~ /($;[\s$;]*)$/ &&
2851				 length(expand_tabs(substr($line, 1, length($line) - length($1) - 1))) <= $max_line_length) {
2852				$msg_type = "LONG_LINE_COMMENT"
2853
2854			# a quoted string starts before $max_line_length
2855			} elsif ($sline =~ /\s*($String(?:\s*(?:\\|,\s*|\)\s*;\s*))?)$/ &&
2856				 length(expand_tabs(substr($line, 1, length($line) - length($1) - 1))) <= $max_line_length) {
2857				$msg_type = "LONG_LINE_STRING"
2858			}
2859
2860			if ($msg_type ne "" &&
2861			    (show_type("LONG_LINE") || show_type($msg_type))) {
2862				WARN($msg_type,
2863				     "line over $max_line_length characters\n" . $herecurr);
2864			}
2865		}
2866
2867# check for adding lines without a newline.
2868		if ($line =~ /^\+/ && defined $lines[$linenr] && $lines[$linenr] =~ /^\\ No newline at end of file/) {
2869			WARN("MISSING_EOF_NEWLINE",
2870			     "adding a line without newline at end of file\n" . $herecurr);
2871		}
2872
2873# Blackfin: use hi/lo macros
2874		if ($realfile =~ m@arch/blackfin/.*\.S$@) {
2875			if ($line =~ /\.[lL][[:space:]]*=.*&[[:space:]]*0x[fF][fF][fF][fF]/) {
2876				my $herevet = "$here\n" . cat_vet($line) . "\n";
2877				ERROR("LO_MACRO",
2878				      "use the LO() macro, not (... & 0xFFFF)\n" . $herevet);
2879			}
2880			if ($line =~ /\.[hH][[:space:]]*=.*>>[[:space:]]*16/) {
2881				my $herevet = "$here\n" . cat_vet($line) . "\n";
2882				ERROR("HI_MACRO",
2883				      "use the HI() macro, not (... >> 16)\n" . $herevet);
2884			}
2885		}
2886
2887# check we are in a valid source file C or perl if not then ignore this hunk
2888		next if ($realfile !~ /\.(h|c|pl|dtsi|dts)$/);
2889
2890# at the beginning of a line any tabs must come first and anything
2891# more than 8 must use tabs.
2892		if ($rawline =~ /^\+\s* \t\s*\S/ ||
2893		    $rawline =~ /^\+\s*        \s*/) {
2894			my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2895			$rpt_cleaners = 1;
2896			if (ERROR("CODE_INDENT",
2897				  "code indent should use tabs where possible\n" . $herevet) &&
2898			    $fix) {
2899				$fixed[$fixlinenr] =~ s/^\+([ \t]+)/"\+" . tabify($1)/e;
2900			}
2901		}
2902
2903# check for space before tabs.
2904		if ($rawline =~ /^\+/ && $rawline =~ / \t/) {
2905			my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2906			if (WARN("SPACE_BEFORE_TAB",
2907				"please, no space before tabs\n" . $herevet) &&
2908			    $fix) {
2909				while ($fixed[$fixlinenr] =~
2910					   s/(^\+.*) {8,8}\t/$1\t\t/) {}
2911				while ($fixed[$fixlinenr] =~
2912					   s/(^\+.*) +\t/$1\t/) {}
2913			}
2914		}
2915
 
 
 
 
 
 
2916# check for && or || at the start of a line
2917		if ($rawline =~ /^\+\s*(&&|\|\|)/) {
2918			CHK("LOGICAL_CONTINUATIONS",
2919			    "Logical continuations should be on the previous line\n" . $hereprev);
2920		}
2921
2922# check indentation starts on a tab stop
2923		if ($^V && $^V ge 5.10.0 &&
2924		    $sline =~ /^\+\t+( +)(?:$c90_Keywords\b|\{\s*$|\}\s*(?:else\b|while\b|\s*$))/) {
2925			my $indent = length($1);
2926			if ($indent % 8) {
2927				if (WARN("TABSTOP",
2928					 "Statements should start on a tabstop\n" . $herecurr) &&
2929				    $fix) {
2930					$fixed[$fixlinenr] =~ s@(^\+\t+) +@$1 . "\t" x ($indent/8)@e;
2931				}
2932			}
2933		}
2934
2935# check multi-line statement indentation matches previous line
2936		if ($^V && $^V ge 5.10.0 &&
2937		    $prevline =~ /^\+([ \t]*)((?:$c90_Keywords(?:\s+if)\s*)|(?:$Declare\s*)?(?:$Ident|\(\s*\*\s*$Ident\s*\))\s*|$Ident\s*=\s*$Ident\s*)\(.*(\&\&|\|\||,)\s*$/) {
2938			$prevline =~ /^\+(\t*)(.*)$/;
2939			my $oldindent = $1;
2940			my $rest = $2;
2941
2942			my $pos = pos_last_openparen($rest);
2943			if ($pos >= 0) {
2944				$line =~ /^(\+| )([ \t]*)/;
2945				my $newindent = $2;
2946
2947				my $goodtabindent = $oldindent .
2948					"\t" x ($pos / 8) .
2949					" "  x ($pos % 8);
2950				my $goodspaceindent = $oldindent . " "  x $pos;
2951
2952				if ($newindent ne $goodtabindent &&
2953				    $newindent ne $goodspaceindent) {
2954
2955					if (CHK("PARENTHESIS_ALIGNMENT",
2956						"Alignment should match open parenthesis\n" . $hereprev) &&
2957					    $fix && $line =~ /^\+/) {
2958						$fixed[$fixlinenr] =~
2959						    s/^\+[ \t]*/\+$goodtabindent/;
2960					}
2961				}
2962			}
2963		}
2964
2965# check for space after cast like "(int) foo" or "(struct foo) bar"
2966# avoid checking a few false positives:
2967#   "sizeof(<type>)" or "__alignof__(<type>)"
2968#   function pointer declarations like "(*foo)(int) = bar;"
2969#   structure definitions like "(struct foo) { 0 };"
2970#   multiline macros that define functions
2971#   known attributes or the __attribute__ keyword
2972		if ($line =~ /^\+(.*)\(\s*$Type\s*\)([ \t]++)((?![={]|\\$|$Attribute|__attribute__))/ &&
2973		    (!defined($1) || $1 !~ /\b(?:sizeof|__alignof__)\s*$/)) {
2974			if (CHK("SPACING",
2975				"No space is necessary after a cast\n" . $herecurr) &&
2976			    $fix) {
2977				$fixed[$fixlinenr] =~
2978				    s/(\(\s*$Type\s*\))[ \t]+/$1/;
2979			}
2980		}
2981
2982# Block comment styles
2983# Networking with an initial /*
2984		if ($realfile =~ m@^(drivers/net/|net/)@ &&
2985		    $prevrawline =~ /^\+[ \t]*\/\*[ \t]*$/ &&
2986		    $rawline =~ /^\+[ \t]*\*/ &&
2987		    $realline > 2) {
2988			WARN("NETWORKING_BLOCK_COMMENT_STYLE",
2989			     "networking block comments don't use an empty /* line, use /* Comment...\n" . $hereprev);
2990		}
2991
2992# Block comments use * on subsequent lines
2993		if ($prevline =~ /$;[ \t]*$/ &&			#ends in comment
2994		    $prevrawline =~ /^\+.*?\/\*/ &&		#starting /*
2995		    $prevrawline !~ /\*\/[ \t]*$/ &&		#no trailing */
2996		    $rawline =~ /^\+/ &&			#line is new
2997		    $rawline !~ /^\+[ \t]*\*/) {		#no leading *
2998			WARN("BLOCK_COMMENT_STYLE",
2999			     "Block comments use * on subsequent lines\n" . $hereprev);
3000		}
3001
3002# Block comments use */ on trailing lines
3003		if ($rawline !~ m@^\+[ \t]*\*/[ \t]*$@ &&	#trailing */
3004		    $rawline !~ m@^\+.*/\*.*\*/[ \t]*$@ &&	#inline /*...*/
3005		    $rawline !~ m@^\+.*\*{2,}/[ \t]*$@ &&	#trailing **/
3006		    $rawline =~ m@^\+[ \t]*.+\*\/[ \t]*$@) {	#non blank */
3007			WARN("BLOCK_COMMENT_STYLE",
3008			     "Block comments use a trailing */ on a separate line\n" . $herecurr);
3009		}
3010
3011# Block comment * alignment
3012		if ($prevline =~ /$;[ \t]*$/ &&			#ends in comment
3013		    $line =~ /^\+[ \t]*$;/ &&			#leading comment
3014		    $rawline =~ /^\+[ \t]*\*/ &&		#leading *
3015		    (($prevrawline =~ /^\+.*?\/\*/ &&		#leading /*
3016		      $prevrawline !~ /\*\/[ \t]*$/) ||		#no trailing */
3017		     $prevrawline =~ /^\+[ \t]*\*/)) {		#leading *
3018			my $oldindent;
3019			$prevrawline =~ m@^\+([ \t]*/?)\*@;
3020			if (defined($1)) {
3021				$oldindent = expand_tabs($1);
3022			} else {
3023				$prevrawline =~ m@^\+(.*/?)\*@;
3024				$oldindent = expand_tabs($1);
3025			}
3026			$rawline =~ m@^\+([ \t]*)\*@;
3027			my $newindent = $1;
3028			$newindent = expand_tabs($newindent);
3029			if (length($oldindent) ne length($newindent)) {
3030				WARN("BLOCK_COMMENT_STYLE",
3031				     "Block comments should align the * on each line\n" . $hereprev);
3032			}
3033		}
3034
3035# check for missing blank lines after struct/union declarations
3036# with exceptions for various attributes and macros
3037		if ($prevline =~ /^[\+ ]};?\s*$/ &&
3038		    $line =~ /^\+/ &&
3039		    !($line =~ /^\+\s*$/ ||
3040		      $line =~ /^\+\s*EXPORT_SYMBOL/ ||
3041		      $line =~ /^\+\s*MODULE_/i ||
3042		      $line =~ /^\+\s*\#\s*(?:end|elif|else)/ ||
3043		      $line =~ /^\+[a-z_]*init/ ||
3044		      $line =~ /^\+\s*(?:static\s+)?[A-Z_]*ATTR/ ||
3045		      $line =~ /^\+\s*DECLARE/ ||
 
3046		      $line =~ /^\+\s*__setup/)) {
3047			if (CHK("LINE_SPACING",
3048				"Please use a blank line after function/struct/union/enum declarations\n" . $hereprev) &&
3049			    $fix) {
3050				fix_insert_line($fixlinenr, "\+");
3051			}
3052		}
3053
3054# check for multiple consecutive blank lines
3055		if ($prevline =~ /^[\+ ]\s*$/ &&
3056		    $line =~ /^\+\s*$/ &&
3057		    $last_blank_line != ($linenr - 1)) {
3058			if (CHK("LINE_SPACING",
3059				"Please don't use multiple blank lines\n" . $hereprev) &&
3060			    $fix) {
3061				fix_delete_line($fixlinenr, $rawline);
3062			}
3063
3064			$last_blank_line = $linenr;
3065		}
3066
3067# check for missing blank lines after declarations
3068		if ($sline =~ /^\+\s+\S/ &&			#Not at char 1
3069			# actual declarations
3070		    ($prevline =~ /^\+\s+$Declare\s*$Ident\s*[=,;:\[]/ ||
3071			# function pointer declarations
3072		     $prevline =~ /^\+\s+$Declare\s*\(\s*\*\s*$Ident\s*\)\s*[=,;:\[\(]/ ||
3073			# foo bar; where foo is some local typedef or #define
3074		     $prevline =~ /^\+\s+$Ident(?:\s+|\s*\*\s*)$Ident\s*[=,;\[]/ ||
3075			# known declaration macros
3076		     $prevline =~ /^\+\s+$declaration_macros/) &&
3077			# for "else if" which can look like "$Ident $Ident"
3078		    !($prevline =~ /^\+\s+$c90_Keywords\b/ ||
3079			# other possible extensions of declaration lines
3080		      $prevline =~ /(?:$Compare|$Assignment|$Operators)\s*$/ ||
3081			# not starting a section or a macro "\" extended line
3082		      $prevline =~ /(?:\{\s*|\\)$/) &&
3083			# looks like a declaration
3084		    !($sline =~ /^\+\s+$Declare\s*$Ident\s*[=,;:\[]/ ||
3085			# function pointer declarations
3086		      $sline =~ /^\+\s+$Declare\s*\(\s*\*\s*$Ident\s*\)\s*[=,;:\[\(]/ ||
3087			# foo bar; where foo is some local typedef or #define
3088		      $sline =~ /^\+\s+$Ident(?:\s+|\s*\*\s*)$Ident\s*[=,;\[]/ ||
3089			# known declaration macros
3090		      $sline =~ /^\+\s+$declaration_macros/ ||
3091			# start of struct or union or enum
3092		      $sline =~ /^\+\s+(?:union|struct|enum|typedef)\b/ ||
3093			# start or end of block or continuation of declaration
3094		      $sline =~ /^\+\s+(?:$|[\{\}\.\#\"\?\:\(\[])/ ||
3095			# bitfield continuation
3096		      $sline =~ /^\+\s+$Ident\s*:\s*\d+\s*[,;]/ ||
3097			# other possible extensions of declaration lines
3098		      $sline =~ /^\+\s+\(?\s*(?:$Compare|$Assignment|$Operators)/) &&
3099			# indentation of previous and current line are the same
3100		    (($prevline =~ /\+(\s+)\S/) && $sline =~ /^\+$1\S/)) {
3101			if (WARN("LINE_SPACING",
3102				 "Missing a blank line after declarations\n" . $hereprev) &&
3103			    $fix) {
3104				fix_insert_line($fixlinenr, "\+");
3105			}
3106		}
3107
3108# check for spaces at the beginning of a line.
3109# Exceptions:
3110#  1) within comments
3111#  2) indented preprocessor commands
3112#  3) hanging labels
3113		if ($rawline =~ /^\+ / && $line !~ /^\+ *(?:$;|#|$Ident:)/)  {
3114			my $herevet = "$here\n" . cat_vet($rawline) . "\n";
3115			if (WARN("LEADING_SPACE",
3116				 "please, no spaces at the start of a line\n" . $herevet) &&
3117			    $fix) {
3118				$fixed[$fixlinenr] =~ s/^\+([ \t]+)/"\+" . tabify($1)/e;
3119			}
3120		}
3121
3122# check we are in a valid C source file if not then ignore this hunk
3123		next if ($realfile !~ /\.(h|c)$/);
3124
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3125# check indentation of any line with a bare else
3126# (but not if it is a multiple line "if (foo) return bar; else return baz;")
3127# if the previous line is a break or return and is indented 1 tab more...
3128		if ($sline =~ /^\+([\t]+)(?:}[ \t]*)?else(?:[ \t]*{)?\s*$/) {
3129			my $tabs = length($1) + 1;
3130			if ($prevline =~ /^\+\t{$tabs,$tabs}break\b/ ||
3131			    ($prevline =~ /^\+\t{$tabs,$tabs}return\b/ &&
3132			     defined $lines[$linenr] &&
3133			     $lines[$linenr] !~ /^[ \+]\t{$tabs,$tabs}return/)) {
3134				WARN("UNNECESSARY_ELSE",
3135				     "else is not generally useful after a break or return\n" . $hereprev);
3136			}
3137		}
3138
3139# check indentation of a line with a break;
3140# if the previous line is a goto or return and is indented the same # of tabs
3141		if ($sline =~ /^\+([\t]+)break\s*;\s*$/) {
3142			my $tabs = $1;
3143			if ($prevline =~ /^\+$tabs(?:goto|return)\b/) {
3144				WARN("UNNECESSARY_BREAK",
3145				     "break is not useful after a goto or return\n" . $hereprev);
3146			}
3147		}
3148
3149# discourage the addition of CONFIG_EXPERIMENTAL in #if(def).
3150		if ($line =~ /^\+\s*\#\s*if.*\bCONFIG_EXPERIMENTAL\b/) {
3151			WARN("CONFIG_EXPERIMENTAL",
3152			     "Use of CONFIG_EXPERIMENTAL is deprecated. For alternatives, see https://lkml.org/lkml/2012/10/23/580\n");
3153		}
3154
3155# check for RCS/CVS revision markers
3156		if ($rawline =~ /^\+.*\$(Revision|Log|Id)(?:\$|)/) {
3157			WARN("CVS_KEYWORD",
3158			     "CVS style keyword markers, these will _not_ be updated\n". $herecurr);
3159		}
3160
3161# Blackfin: don't use __builtin_bfin_[cs]sync
3162		if ($line =~ /__builtin_bfin_csync/) {
3163			my $herevet = "$here\n" . cat_vet($line) . "\n";
3164			ERROR("CSYNC",
3165			      "use the CSYNC() macro in asm/blackfin.h\n" . $herevet);
3166		}
3167		if ($line =~ /__builtin_bfin_ssync/) {
3168			my $herevet = "$here\n" . cat_vet($line) . "\n";
3169			ERROR("SSYNC",
3170			      "use the SSYNC() macro in asm/blackfin.h\n" . $herevet);
3171		}
3172
3173# check for old HOTPLUG __dev<foo> section markings
3174		if ($line =~ /\b(__dev(init|exit)(data|const|))\b/) {
3175			WARN("HOTPLUG_SECTION",
3176			     "Using $1 is unnecessary\n" . $herecurr);
3177		}
3178
3179# Check for potential 'bare' types
3180		my ($stat, $cond, $line_nr_next, $remain_next, $off_next,
3181		    $realline_next);
3182#print "LINE<$line>\n";
3183		if ($linenr >= $suppress_statement &&
3184		    $realcnt && $sline =~ /.\s*\S/) {
3185			($stat, $cond, $line_nr_next, $remain_next, $off_next) =
3186				ctx_statement_block($linenr, $realcnt, 0);
3187			$stat =~ s/\n./\n /g;
3188			$cond =~ s/\n./\n /g;
3189
3190#print "linenr<$linenr> <$stat>\n";
3191			# If this statement has no statement boundaries within
3192			# it there is no point in retrying a statement scan
3193			# until we hit end of it.
3194			my $frag = $stat; $frag =~ s/;+\s*$//;
3195			if ($frag !~ /(?:{|;)/) {
3196#print "skip<$line_nr_next>\n";
3197				$suppress_statement = $line_nr_next;
3198			}
3199
3200			# Find the real next line.
3201			$realline_next = $line_nr_next;
3202			if (defined $realline_next &&
3203			    (!defined $lines[$realline_next - 1] ||
3204			     substr($lines[$realline_next - 1], $off_next) =~ /^\s*$/)) {
3205				$realline_next++;
3206			}
3207
3208			my $s = $stat;
3209			$s =~ s/{.*$//s;
3210
3211			# Ignore goto labels.
3212			if ($s =~ /$Ident:\*$/s) {
3213
3214			# Ignore functions being called
3215			} elsif ($s =~ /^.\s*$Ident\s*\(/s) {
3216
3217			} elsif ($s =~ /^.\s*else\b/s) {
3218
3219			# declarations always start with types
3220			} 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) {
3221				my $type = $1;
3222				$type =~ s/\s+/ /g;
3223				possible($type, "A:" . $s);
3224
3225			# definitions in global scope can only start with types
3226			} elsif ($s =~ /^.(?:$Storage\s+)?(?:$Inline\s+)?(?:const\s+)?($Ident)\b\s*(?!:)/s) {
3227				possible($1, "B:" . $s);
3228			}
3229
3230			# any (foo ... *) is a pointer cast, and foo is a type
3231			while ($s =~ /\(($Ident)(?:\s+$Sparse)*[\s\*]+\s*\)/sg) {
3232				possible($1, "C:" . $s);
3233			}
3234
3235			# Check for any sort of function declaration.
3236			# int foo(something bar, other baz);
3237			# void (*store_gdt)(x86_descr_ptr *);
3238			if ($prev_values eq 'E' && $s =~ /^(.(?:typedef\s*)?(?:(?:$Storage|$Inline)\s*)*\s*$Type\s*(?:\b$Ident|\(\*\s*$Ident\))\s*)\(/s) {
3239				my ($name_len) = length($1);
3240
3241				my $ctx = $s;
3242				substr($ctx, 0, $name_len + 1, '');
3243				$ctx =~ s/\)[^\)]*$//;
3244
3245				for my $arg (split(/\s*,\s*/, $ctx)) {
3246					if ($arg =~ /^(?:const\s+)?($Ident)(?:\s+$Sparse)*\s*\**\s*(:?\b$Ident)?$/s || $arg =~ /^($Ident)$/s) {
3247
3248						possible($1, "D:" . $s);
3249					}
3250				}
3251			}
3252
3253		}
3254
3255#
3256# Checks which may be anchored in the context.
3257#
3258
3259# Check for switch () and associated case and default
3260# statements should be at the same indent.
3261		if ($line=~/\bswitch\s*\(.*\)/) {
3262			my $err = '';
3263			my $sep = '';
3264			my @ctx = ctx_block_outer($linenr, $realcnt);
3265			shift(@ctx);
3266			for my $ctx (@ctx) {
3267				my ($clen, $cindent) = line_stats($ctx);
3268				if ($ctx =~ /^\+\s*(case\s+|default:)/ &&
3269							$indent != $cindent) {
3270					$err .= "$sep$ctx\n";
3271					$sep = '';
3272				} else {
3273					$sep = "[...]\n";
3274				}
3275			}
3276			if ($err ne '') {
3277				ERROR("SWITCH_CASE_INDENT_LEVEL",
3278				      "switch and case should be at the same indent\n$hereline$err");
3279			}
3280		}
3281
3282# if/while/etc brace do not go on next line, unless defining a do while loop,
3283# or if that brace on the next line is for something else
3284		if ($line =~ /(.*)\b((?:if|while|for|switch|(?:[a-z_]+|)for_each[a-z_]+)\s*\(|do\b|else\b)/ && $line !~ /^.\s*\#/) {
3285			my $pre_ctx = "$1$2";
3286
3287			my ($level, @ctx) = ctx_statement_level($linenr, $realcnt, 0);
3288
3289			if ($line =~ /^\+\t{6,}/) {
3290				WARN("DEEP_INDENTATION",
3291				     "Too many leading tabs - consider code refactoring\n" . $herecurr);
3292			}
3293
3294			my $ctx_cnt = $realcnt - $#ctx - 1;
3295			my $ctx = join("\n", @ctx);
3296
3297			my $ctx_ln = $linenr;
3298			my $ctx_skip = $realcnt;
3299
3300			while ($ctx_skip > $ctx_cnt || ($ctx_skip == $ctx_cnt &&
3301					defined $lines[$ctx_ln - 1] &&
3302					$lines[$ctx_ln - 1] =~ /^-/)) {
3303				##print "SKIP<$ctx_skip> CNT<$ctx_cnt>\n";
3304				$ctx_skip-- if (!defined $lines[$ctx_ln - 1] || $lines[$ctx_ln - 1] !~ /^-/);
3305				$ctx_ln++;
3306			}
3307
3308			#print "realcnt<$realcnt> ctx_cnt<$ctx_cnt>\n";
3309			#print "pre<$pre_ctx>\nline<$line>\nctx<$ctx>\nnext<$lines[$ctx_ln - 1]>\n";
3310
3311			if ($ctx !~ /{\s*/ && defined($lines[$ctx_ln - 1]) && $lines[$ctx_ln - 1] =~ /^\+\s*{/) {
3312				ERROR("OPEN_BRACE",
3313				      "that open brace { should be on the previous line\n" .
3314					"$here\n$ctx\n$rawlines[$ctx_ln - 1]\n");
3315			}
3316			if ($level == 0 && $pre_ctx !~ /}\s*while\s*\($/ &&
3317			    $ctx =~ /\)\s*\;\s*$/ &&
3318			    defined $lines[$ctx_ln - 1])
3319			{
3320				my ($nlength, $nindent) = line_stats($lines[$ctx_ln - 1]);
3321				if ($nindent > $indent) {
3322					WARN("TRAILING_SEMICOLON",
3323					     "trailing semicolon indicates no statements, indent implies otherwise\n" .
3324						"$here\n$ctx\n$rawlines[$ctx_ln - 1]\n");
3325				}
3326			}
3327		}
3328
3329# Check relative indent for conditionals and blocks.
3330		if ($line =~ /\b(?:(?:if|while|for|(?:[a-z_]+|)for_each[a-z_]+)\s*\(|do\b)/ && $line !~ /^.\s*#/ && $line !~ /\}\s*while\s*/) {
3331			($stat, $cond, $line_nr_next, $remain_next, $off_next) =
3332				ctx_statement_block($linenr, $realcnt, 0)
3333					if (!defined $stat);
3334			my ($s, $c) = ($stat, $cond);
3335
3336			substr($s, 0, length($c), '');
3337
3338			# remove inline comments
3339			$s =~ s/$;/ /g;
3340			$c =~ s/$;/ /g;
3341
3342			# Find out how long the conditional actually is.
3343			my @newlines = ($c =~ /\n/gs);
3344			my $cond_lines = 1 + $#newlines;
3345
3346			# Make sure we remove the line prefixes as we have
3347			# none on the first line, and are going to readd them
3348			# where necessary.
3349			$s =~ s/\n./\n/gs;
3350			while ($s =~ /\n\s+\\\n/) {
3351				$cond_lines += $s =~ s/\n\s+\\\n/\n/g;
3352			}
3353
3354			# We want to check the first line inside the block
3355			# starting at the end of the conditional, so remove:
3356			#  1) any blank line termination
3357			#  2) any opening brace { on end of the line
3358			#  3) any do (...) {
3359			my $continuation = 0;
3360			my $check = 0;
3361			$s =~ s/^.*\bdo\b//;
3362			$s =~ s/^\s*{//;
3363			if ($s =~ s/^\s*\\//) {
3364				$continuation = 1;
3365			}
3366			if ($s =~ s/^\s*?\n//) {
3367				$check = 1;
3368				$cond_lines++;
3369			}
3370
3371			# Also ignore a loop construct at the end of a
3372			# preprocessor statement.
3373			if (($prevline =~ /^.\s*#\s*define\s/ ||
3374			    $prevline =~ /\\\s*$/) && $continuation == 0) {
3375				$check = 0;
3376			}
3377
3378			my $cond_ptr = -1;
3379			$continuation = 0;
3380			while ($cond_ptr != $cond_lines) {
3381				$cond_ptr = $cond_lines;
3382
3383				# If we see an #else/#elif then the code
3384				# is not linear.
3385				if ($s =~ /^\s*\#\s*(?:else|elif)/) {
3386					$check = 0;
3387				}
3388
3389				# Ignore:
3390				#  1) blank lines, they should be at 0,
3391				#  2) preprocessor lines, and
3392				#  3) labels.
3393				if ($continuation ||
3394				    $s =~ /^\s*?\n/ ||
3395				    $s =~ /^\s*#\s*?/ ||
3396				    $s =~ /^\s*$Ident\s*:/) {
3397					$continuation = ($s =~ /^.*?\\\n/) ? 1 : 0;
3398					if ($s =~ s/^.*?\n//) {
3399						$cond_lines++;
3400					}
3401				}
3402			}
3403
3404			my (undef, $sindent) = line_stats("+" . $s);
3405			my $stat_real = raw_line($linenr, $cond_lines);
3406
3407			# Check if either of these lines are modified, else
3408			# this is not this patch's fault.
3409			if (!defined($stat_real) ||
3410			    $stat !~ /^\+/ && $stat_real !~ /^\+/) {
3411				$check = 0;
3412			}
3413			if (defined($stat_real) && $cond_lines > 1) {
3414				$stat_real = "[...]\n$stat_real";
3415			}
3416
3417			#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>\n";
3418
3419			if ($check && $s ne '' &&
3420			    (($sindent % 8) != 0 ||
3421			     ($sindent < $indent) ||
 
 
3422			     ($sindent > $indent + 8))) {
3423				WARN("SUSPECT_CODE_INDENT",
3424				     "suspect code indent for conditional statements ($indent, $sindent)\n" . $herecurr . "$stat_real\n");
3425			}
3426		}
3427
3428		# Track the 'values' across context and added lines.
3429		my $opline = $line; $opline =~ s/^./ /;
3430		my ($curr_values, $curr_vars) =
3431				annotate_values($opline . "\n", $prev_values);
3432		$curr_values = $prev_values . $curr_values;
3433		if ($dbg_values) {
3434			my $outline = $opline; $outline =~ s/\t/ /g;
3435			print "$linenr > .$outline\n";
3436			print "$linenr > $curr_values\n";
3437			print "$linenr >  $curr_vars\n";
3438		}
3439		$prev_values = substr($curr_values, -1);
3440
3441#ignore lines not being added
3442		next if ($line =~ /^[^\+]/);
3443
3444# check for dereferences that span multiple lines
3445		if ($prevline =~ /^\+.*$Lval\s*(?:\.|->)\s*$/ &&
3446		    $line =~ /^\+\s*(?!\#\s*(?!define\s+|if))\s*$Lval/) {
3447			$prevline =~ /($Lval\s*(?:\.|->))\s*$/;
3448			my $ref = $1;
3449			$line =~ /^.\s*($Lval)/;
3450			$ref .= $1;
3451			$ref =~ s/\s//g;
3452			WARN("MULTILINE_DEREFERENCE",
3453			     "Avoid multiple line dereference - prefer '$ref'\n" . $hereprev);
3454		}
3455
3456# check for declarations of signed or unsigned without int
3457		while ($line =~ m{\b($Declare)\s*(?!char\b|short\b|int\b|long\b)\s*($Ident)?\s*[=,;\[\)\(]}g) {
3458			my $type = $1;
3459			my $var = $2;
3460			$var = "" if (!defined $var);
3461			if ($type =~ /^(?:(?:$Storage|$Inline|$Attribute)\s+)*((?:un)?signed)((?:\s*\*)*)\s*$/) {
3462				my $sign = $1;
3463				my $pointer = $2;
3464
3465				$pointer = "" if (!defined $pointer);
3466
3467				if (WARN("UNSPECIFIED_INT",
3468					 "Prefer '" . trim($sign) . " int" . rtrim($pointer) . "' to bare use of '$sign" . rtrim($pointer) . "'\n" . $herecurr) &&
3469				    $fix) {
3470					my $decl = trim($sign) . " int ";
3471					my $comp_pointer = $pointer;
3472					$comp_pointer =~ s/\s//g;
3473					$decl .= $comp_pointer;
3474					$decl = rtrim($decl) if ($var eq "");
3475					$fixed[$fixlinenr] =~ s@\b$sign\s*\Q$pointer\E\s*$var\b@$decl$var@;
3476				}
3477			}
3478		}
3479
3480# TEST: allow direct testing of the type matcher.
3481		if ($dbg_type) {
3482			if ($line =~ /^.\s*$Declare\s*$/) {
3483				ERROR("TEST_TYPE",
3484				      "TEST: is type\n" . $herecurr);
3485			} elsif ($dbg_type > 1 && $line =~ /^.+($Declare)/) {
3486				ERROR("TEST_NOT_TYPE",
3487				      "TEST: is not type ($1 is)\n". $herecurr);
3488			}
3489			next;
3490		}
3491# TEST: allow direct testing of the attribute matcher.
3492		if ($dbg_attr) {
3493			if ($line =~ /^.\s*$Modifier\s*$/) {
3494				ERROR("TEST_ATTR",
3495				      "TEST: is attr\n" . $herecurr);
3496			} elsif ($dbg_attr > 1 && $line =~ /^.+($Modifier)/) {
3497				ERROR("TEST_NOT_ATTR",
3498				      "TEST: is not attr ($1 is)\n". $herecurr);
3499			}
3500			next;
3501		}
3502
3503# check for initialisation to aggregates open brace on the next line
3504		if ($line =~ /^.\s*{/ &&
3505		    $prevline =~ /(?:^|[^=])=\s*$/) {
3506			if (ERROR("OPEN_BRACE",
3507				  "that open brace { should be on the previous line\n" . $hereprev) &&
3508			    $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
3509				fix_delete_line($fixlinenr - 1, $prevrawline);
3510				fix_delete_line($fixlinenr, $rawline);
3511				my $fixedline = $prevrawline;
3512				$fixedline =~ s/\s*=\s*$/ = {/;
3513				fix_insert_line($fixlinenr, $fixedline);
3514				$fixedline = $line;
3515				$fixedline =~ s/^(.\s*){\s*/$1/;
3516				fix_insert_line($fixlinenr, $fixedline);
3517			}
3518		}
3519
3520#
3521# Checks which are anchored on the added line.
3522#
3523
3524# check for malformed paths in #include statements (uses RAW line)
3525		if ($rawline =~ m{^.\s*\#\s*include\s+[<"](.*)[">]}) {
3526			my $path = $1;
3527			if ($path =~ m{//}) {
3528				ERROR("MALFORMED_INCLUDE",
3529				      "malformed #include filename\n" . $herecurr);
3530			}
3531			if ($path =~ "^uapi/" && $realfile =~ m@\binclude/uapi/@) {
3532				ERROR("UAPI_INCLUDE",
3533				      "No #include in ...include/uapi/... should use a uapi/ path prefix\n" . $herecurr);
3534			}
3535		}
3536
3537# no C99 // comments
3538		if ($line =~ m{//}) {
3539			if (ERROR("C99_COMMENTS",
3540				  "do not use C99 // comments\n" . $herecurr) &&
3541			    $fix) {
3542				my $line = $fixed[$fixlinenr];
3543				if ($line =~ /\/\/(.*)$/) {
3544					my $comment = trim($1);
3545					$fixed[$fixlinenr] =~ s@\/\/(.*)$@/\* $comment \*/@;
3546				}
3547			}
3548		}
3549		# Remove C99 comments.
3550		$line =~ s@//.*@@;
3551		$opline =~ s@//.*@@;
3552
3553# EXPORT_SYMBOL should immediately follow the thing it is exporting, consider
3554# the whole statement.
3555#print "APW <$lines[$realline_next - 1]>\n";
3556		if (defined $realline_next &&
3557		    exists $lines[$realline_next - 1] &&
3558		    !defined $suppress_export{$realline_next} &&
3559		    ($lines[$realline_next - 1] =~ /EXPORT_SYMBOL.*\((.*)\)/ ||
3560		     $lines[$realline_next - 1] =~ /EXPORT_UNUSED_SYMBOL.*\((.*)\)/)) {
3561			# Handle definitions which produce identifiers with
3562			# a prefix:
3563			#   XXX(foo);
3564			#   EXPORT_SYMBOL(something_foo);
3565			my $name = $1;
3566			if ($stat =~ /^(?:.\s*}\s*\n)?.([A-Z_]+)\s*\(\s*($Ident)/ &&
3567			    $name =~ /^${Ident}_$2/) {
3568#print "FOO C name<$name>\n";
3569				$suppress_export{$realline_next} = 1;
3570
3571			} elsif ($stat !~ /(?:
3572				\n.}\s*$|
3573				^.DEFINE_$Ident\(\Q$name\E\)|
3574				^.DECLARE_$Ident\(\Q$name\E\)|
3575				^.LIST_HEAD\(\Q$name\E\)|
3576				^.(?:$Storage\s+)?$Type\s*\(\s*\*\s*\Q$name\E\s*\)\s*\(|
3577				\b\Q$name\E(?:\s+$Attribute)*\s*(?:;|=|\[|\()
3578			    )/x) {
3579#print "FOO A<$lines[$realline_next - 1]> stat<$stat> name<$name>\n";
3580				$suppress_export{$realline_next} = 2;
3581			} else {
3582				$suppress_export{$realline_next} = 1;
3583			}
3584		}
3585		if (!defined $suppress_export{$linenr} &&
3586		    $prevline =~ /^.\s*$/ &&
3587		    ($line =~ /EXPORT_SYMBOL.*\((.*)\)/ ||
3588		     $line =~ /EXPORT_UNUSED_SYMBOL.*\((.*)\)/)) {
3589#print "FOO B <$lines[$linenr - 1]>\n";
3590			$suppress_export{$linenr} = 2;
3591		}
3592		if (defined $suppress_export{$linenr} &&
3593		    $suppress_export{$linenr} == 2) {
3594			WARN("EXPORT_SYMBOL",
3595			     "EXPORT_SYMBOL(foo); should immediately follow its function/variable\n" . $herecurr);
3596		}
3597
3598# check for global initialisers.
3599		if ($line =~ /^\+$Type\s*$Ident(?:\s+$Modifier)*\s*=\s*($zero_initializer)\s*;/) {
3600			if (ERROR("GLOBAL_INITIALISERS",
3601				  "do not initialise globals to $1\n" . $herecurr) &&
3602			    $fix) {
3603				$fixed[$fixlinenr] =~ s/(^.$Type\s*$Ident(?:\s+$Modifier)*)\s*=\s*$zero_initializer\s*;/$1;/;
3604			}
3605		}
3606# check for static initialisers.
3607		if ($line =~ /^\+.*\bstatic\s.*=\s*($zero_initializer)\s*;/) {
3608			if (ERROR("INITIALISED_STATIC",
3609				  "do not initialise statics to $1\n" .
3610				      $herecurr) &&
3611			    $fix) {
3612				$fixed[$fixlinenr] =~ s/(\bstatic\s.*?)\s*=\s*$zero_initializer\s*;/$1;/;
3613			}
3614		}
3615
3616# check for misordered declarations of char/short/int/long with signed/unsigned
3617		while ($sline =~ m{(\b$TypeMisordered\b)}g) {
3618			my $tmp = trim($1);
3619			WARN("MISORDERED_TYPE",
3620			     "type '$tmp' should be specified in [[un]signed] [short|int|long|long long] order\n" . $herecurr);
3621		}
3622
3623# check for static const char * arrays.
3624		if ($line =~ /\bstatic\s+const\s+char\s*\*\s*(\w+)\s*\[\s*\]\s*=\s*/) {
3625			WARN("STATIC_CONST_CHAR_ARRAY",
3626			     "static const char * array should probably be static const char * const\n" .
3627				$herecurr);
3628               }
3629
3630# check for static char foo[] = "bar" declarations.
3631		if ($line =~ /\bstatic\s+char\s+(\w+)\s*\[\s*\]\s*=\s*"/) {
3632			WARN("STATIC_CONST_CHAR_ARRAY",
3633			     "static char array declaration should probably be static const char\n" .
3634				$herecurr);
3635               }
3636
3637# check for const <foo> const where <foo> is not a pointer or array type
3638		if ($sline =~ /\bconst\s+($BasicType)\s+const\b/) {
3639			my $found = $1;
3640			if ($sline =~ /\bconst\s+\Q$found\E\s+const\b\s*\*/) {
3641				WARN("CONST_CONST",
3642				     "'const $found const *' should probably be 'const $found * const'\n" . $herecurr);
3643			} elsif ($sline !~ /\bconst\s+\Q$found\E\s+const\s+\w+\s*\[/) {
3644				WARN("CONST_CONST",
3645				     "'const $found const' should probably be 'const $found'\n" . $herecurr);
3646			}
3647		}
3648
3649# check for non-global char *foo[] = {"bar", ...} declarations.
3650		if ($line =~ /^.\s+(?:static\s+|const\s+)?char\s+\*\s*\w+\s*\[\s*\]\s*=\s*\{/) {
3651			WARN("STATIC_CONST_CHAR_ARRAY",
3652			     "char * array declaration might be better as static const\n" .
3653				$herecurr);
3654               }
3655
3656# check for sizeof(foo)/sizeof(foo[0]) that could be ARRAY_SIZE(foo)
3657		if ($line =~ m@\bsizeof\s*\(\s*($Lval)\s*\)@) {
3658			my $array = $1;
3659			if ($line =~ m@\b(sizeof\s*\(\s*\Q$array\E\s*\)\s*/\s*sizeof\s*\(\s*\Q$array\E\s*\[\s*0\s*\]\s*\))@) {
3660				my $array_div = $1;
3661				if (WARN("ARRAY_SIZE",
3662					 "Prefer ARRAY_SIZE($array)\n" . $herecurr) &&
3663				    $fix) {
3664					$fixed[$fixlinenr] =~ s/\Q$array_div\E/ARRAY_SIZE($array)/;
3665				}
3666			}
3667		}
3668
3669# check for function declarations without arguments like "int foo()"
3670		if ($line =~ /(\b$Type\s+$Ident)\s*\(\s*\)/) {
3671			if (ERROR("FUNCTION_WITHOUT_ARGS",
3672				  "Bad function definition - $1() should probably be $1(void)\n" . $herecurr) &&
3673			    $fix) {
3674				$fixed[$fixlinenr] =~ s/(\b($Type)\s+($Ident))\s*\(\s*\)/$2 $3(void)/;
3675			}
3676		}
3677
3678# check for new typedefs, only function parameters and sparse annotations
3679# make sense.
3680		if ($line =~ /\btypedef\s/ &&
3681		    $line !~ /\btypedef\s+$Type\s*\(\s*\*?$Ident\s*\)\s*\(/ &&
3682		    $line !~ /\btypedef\s+$Type\s+$Ident\s*\(/ &&
3683		    $line !~ /\b$typeTypedefs\b/ &&
3684		    $line !~ /\b__bitwise\b/) {
3685			WARN("NEW_TYPEDEFS",
3686			     "do not add new typedefs\n" . $herecurr);
3687		}
3688
3689# * goes on variable not on type
3690		# (char*[ const])
3691		while ($line =~ m{(\($NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)\))}g) {
3692			#print "AA<$1>\n";
3693			my ($ident, $from, $to) = ($1, $2, $2);
3694
3695			# Should start with a space.
3696			$to =~ s/^(\S)/ $1/;
3697			# Should not end with a space.
3698			$to =~ s/\s+$//;
3699			# '*'s should not have spaces between.
3700			while ($to =~ s/\*\s+\*/\*\*/) {
3701			}
3702
3703##			print "1: from<$from> to<$to> ident<$ident>\n";
3704			if ($from ne $to) {
3705				if (ERROR("POINTER_LOCATION",
3706					  "\"(foo$from)\" should be \"(foo$to)\"\n" .  $herecurr) &&
3707				    $fix) {
3708					my $sub_from = $ident;
3709					my $sub_to = $ident;
3710					$sub_to =~ s/\Q$from\E/$to/;
3711					$fixed[$fixlinenr] =~
3712					    s@\Q$sub_from\E@$sub_to@;
3713				}
3714			}
3715		}
3716		while ($line =~ m{(\b$NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)($Ident))}g) {
3717			#print "BB<$1>\n";
3718			my ($match, $from, $to, $ident) = ($1, $2, $2, $3);
3719
3720			# Should start with a space.
3721			$to =~ s/^(\S)/ $1/;
3722			# Should not end with a space.
3723			$to =~ s/\s+$//;
3724			# '*'s should not have spaces between.
3725			while ($to =~ s/\*\s+\*/\*\*/) {
3726			}
3727			# Modifiers should have spaces.
3728			$to =~ s/(\b$Modifier$)/$1 /;
3729
3730##			print "2: from<$from> to<$to> ident<$ident>\n";
3731			if ($from ne $to && $ident !~ /^$Modifier$/) {
3732				if (ERROR("POINTER_LOCATION",
3733					  "\"foo${from}bar\" should be \"foo${to}bar\"\n" .  $herecurr) &&
3734				    $fix) {
3735
3736					my $sub_from = $match;
3737					my $sub_to = $match;
3738					$sub_to =~ s/\Q$from\E/$to/;
3739					$fixed[$fixlinenr] =~
3740					    s@\Q$sub_from\E@$sub_to@;
3741				}
3742			}
3743		}
3744
3745# avoid BUG() or BUG_ON()
3746		if ($line =~ /\b(?:BUG|BUG_ON)\b/) {
3747			my $msg_type = \&WARN;
3748			$msg_type = \&CHK if ($file);
3749			&{$msg_type}("AVOID_BUG",
3750				     "Avoid crashing the kernel - try using WARN_ON & recovery code rather than BUG() or BUG_ON()\n" . $herecurr);
3751		}
3752
3753# avoid LINUX_VERSION_CODE
3754		if ($line =~ /\bLINUX_VERSION_CODE\b/) {
3755			WARN("LINUX_VERSION_CODE",
3756			     "LINUX_VERSION_CODE should be avoided, code should be for the version to which it is merged\n" . $herecurr);
3757		}
3758
3759# check for uses of printk_ratelimit
3760		if ($line =~ /\bprintk_ratelimit\s*\(/) {
3761			WARN("PRINTK_RATELIMITED",
3762			     "Prefer printk_ratelimited or pr_<level>_ratelimited to printk_ratelimit\n" . $herecurr);
3763		}
3764
3765# printk should use KERN_* levels.  Note that follow on printk's on the
3766# same line do not need a level, so we use the current block context
3767# to try and find and validate the current printk.  In summary the current
3768# printk includes all preceding printk's which have no newline on the end.
3769# we assume the first bad printk is the one to report.
3770		if ($line =~ /\bprintk\((?!KERN_)\s*"/) {
3771			my $ok = 0;
3772			for (my $ln = $linenr - 1; $ln >= $first_line; $ln--) {
3773				#print "CHECK<$lines[$ln - 1]\n";
3774				# we have a preceding printk if it ends
3775				# with "\n" ignore it, else it is to blame
3776				if ($lines[$ln - 1] =~ m{\bprintk\(}) {
3777					if ($rawlines[$ln - 1] !~ m{\\n"}) {
3778						$ok = 1;
3779					}
3780					last;
3781				}
3782			}
3783			if ($ok == 0) {
3784				WARN("PRINTK_WITHOUT_KERN_LEVEL",
3785				     "printk() should include KERN_ facility level\n" . $herecurr);
3786			}
3787		}
3788
3789		if ($line =~ /\bprintk\s*\(\s*KERN_([A-Z]+)/) {
3790			my $orig = $1;
3791			my $level = lc($orig);
3792			$level = "warn" if ($level eq "warning");
3793			my $level2 = $level;
3794			$level2 = "dbg" if ($level eq "debug");
3795			WARN("PREFER_PR_LEVEL",
3796			     "Prefer [subsystem eg: netdev]_$level2([subsystem]dev, ... then dev_$level2(dev, ... then pr_$level(...  to printk(KERN_$orig ...\n" . $herecurr);
3797		}
3798
3799		if ($line =~ /\bpr_warning\s*\(/) {
3800			if (WARN("PREFER_PR_LEVEL",
3801				 "Prefer pr_warn(... to pr_warning(...\n" . $herecurr) &&
3802			    $fix) {
3803				$fixed[$fixlinenr] =~
3804				    s/\bpr_warning\b/pr_warn/;
3805			}
3806		}
3807
3808		if ($line =~ /\bdev_printk\s*\(\s*KERN_([A-Z]+)/) {
3809			my $orig = $1;
3810			my $level = lc($orig);
3811			$level = "warn" if ($level eq "warning");
3812			$level = "dbg" if ($level eq "debug");
3813			WARN("PREFER_DEV_LEVEL",
3814			     "Prefer dev_$level(... to dev_printk(KERN_$orig, ...\n" . $herecurr);
3815		}
3816
3817# ENOSYS means "bad syscall nr" and nothing else.  This will have a small
3818# number of false positives, but assembly files are not checked, so at
3819# least the arch entry code will not trigger this warning.
3820		if ($line =~ /\bENOSYS\b/) {
3821			WARN("ENOSYS",
3822			     "ENOSYS means 'invalid syscall nr' and nothing else\n" . $herecurr);
3823		}
3824
3825# function brace can't be on same line, except for #defines of do while,
3826# or if closed on same line
3827		if (($line=~/$Type\s*$Ident\(.*\).*\s*{/) and
3828		    !($line=~/\#\s*define.*do\s\{/) and !($line=~/}/)) {
 
 
3829			if (ERROR("OPEN_BRACE",
3830				  "open brace '{' following function declarations go on the next line\n" . $herecurr) &&
3831			    $fix) {
3832				fix_delete_line($fixlinenr, $rawline);
3833				my $fixed_line = $rawline;
3834				$fixed_line =~ /(^..*$Type\s*$Ident\(.*\)\s*){(.*)$/;
3835				my $line1 = $1;
3836				my $line2 = $2;
3837				fix_insert_line($fixlinenr, ltrim($line1));
3838				fix_insert_line($fixlinenr, "\+{");
3839				if ($line2 !~ /^\s*$/) {
3840					fix_insert_line($fixlinenr, "\+\t" . trim($line2));
3841				}
3842			}
3843		}
3844
3845# open braces for enum, union and struct go on the same line.
3846		if ($line =~ /^.\s*{/ &&
3847		    $prevline =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident)?\s*$/) {
3848			if (ERROR("OPEN_BRACE",
3849				  "open brace '{' following $1 go on the same line\n" . $hereprev) &&
3850			    $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
3851				fix_delete_line($fixlinenr - 1, $prevrawline);
3852				fix_delete_line($fixlinenr, $rawline);
3853				my $fixedline = rtrim($prevrawline) . " {";
3854				fix_insert_line($fixlinenr, $fixedline);
3855				$fixedline = $rawline;
3856				$fixedline =~ s/^(.\s*){\s*/$1\t/;
3857				if ($fixedline !~ /^\+\s*$/) {
3858					fix_insert_line($fixlinenr, $fixedline);
3859				}
3860			}
3861		}
3862
3863# missing space after union, struct or enum definition
3864		if ($line =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident){1,2}[=\{]/) {
3865			if (WARN("SPACING",
3866				 "missing space after $1 definition\n" . $herecurr) &&
3867			    $fix) {
3868				$fixed[$fixlinenr] =~
3869				    s/^(.\s*(?:typedef\s+)?(?:enum|union|struct)(?:\s+$Ident){1,2})([=\{])/$1 $2/;
3870			}
3871		}
3872
3873# Function pointer declarations
3874# check spacing between type, funcptr, and args
3875# canonical declaration is "type (*funcptr)(args...)"
3876		if ($line =~ /^.\s*($Declare)\((\s*)\*(\s*)($Ident)(\s*)\)(\s*)\(/) {
3877			my $declare = $1;
3878			my $pre_pointer_space = $2;
3879			my $post_pointer_space = $3;
3880			my $funcname = $4;
3881			my $post_funcname_space = $5;
3882			my $pre_args_space = $6;
3883
3884# the $Declare variable will capture all spaces after the type
3885# so check it for a missing trailing missing space but pointer return types
3886# don't need a space so don't warn for those.
3887			my $post_declare_space = "";
3888			if ($declare =~ /(\s+)$/) {
3889				$post_declare_space = $1;
3890				$declare = rtrim($declare);
3891			}
3892			if ($declare !~ /\*$/ && $post_declare_space =~ /^$/) {
3893				WARN("SPACING",
3894				     "missing space after return type\n" . $herecurr);
3895				$post_declare_space = " ";
3896			}
3897
3898# unnecessary space "type  (*funcptr)(args...)"
3899# This test is not currently implemented because these declarations are
3900# equivalent to
3901#	int  foo(int bar, ...)
3902# and this is form shouldn't/doesn't generate a checkpatch warning.
3903#
3904#			elsif ($declare =~ /\s{2,}$/) {
3905#				WARN("SPACING",
3906#				     "Multiple spaces after return type\n" . $herecurr);
3907#			}
3908
3909# unnecessary space "type ( *funcptr)(args...)"
3910			if (defined $pre_pointer_space &&
3911			    $pre_pointer_space =~ /^\s/) {
3912				WARN("SPACING",
3913				     "Unnecessary space after function pointer open parenthesis\n" . $herecurr);
3914			}
3915
3916# unnecessary space "type (* funcptr)(args...)"
3917			if (defined $post_pointer_space &&
3918			    $post_pointer_space =~ /^\s/) {
3919				WARN("SPACING",
3920				     "Unnecessary space before function pointer name\n" . $herecurr);
3921			}
3922
3923# unnecessary space "type (*funcptr )(args...)"
3924			if (defined $post_funcname_space &&
3925			    $post_funcname_space =~ /^\s/) {
3926				WARN("SPACING",
3927				     "Unnecessary space after function pointer name\n" . $herecurr);
3928			}
3929
3930# unnecessary space "type (*funcptr) (args...)"
3931			if (defined $pre_args_space &&
3932			    $pre_args_space =~ /^\s/) {
3933				WARN("SPACING",
3934				     "Unnecessary space before function pointer arguments\n" . $herecurr);
3935			}
3936
3937			if (show_type("SPACING") && $fix) {
3938				$fixed[$fixlinenr] =~
3939				    s/^(.\s*)$Declare\s*\(\s*\*\s*$Ident\s*\)\s*\(/$1 . $declare . $post_declare_space . '(*' . $funcname . ')('/ex;
3940			}
3941		}
3942
3943# check for spacing round square brackets; allowed:
3944#  1. with a type on the left -- int [] a;
3945#  2. at the beginning of a line for slice initialisers -- [0...10] = 5,
3946#  3. inside a curly brace -- = { [0...10] = 5 }
3947		while ($line =~ /(.*?\s)\[/g) {
3948			my ($where, $prefix) = ($-[1], $1);
3949			if ($prefix !~ /$Type\s+$/ &&
3950			    ($where != 0 || $prefix !~ /^.\s+$/) &&
3951			    $prefix !~ /[{,]\s+$/) {
3952				if (ERROR("BRACKET_SPACE",
3953					  "space prohibited before open square bracket '['\n" . $herecurr) &&
3954				    $fix) {
3955				    $fixed[$fixlinenr] =~
3956					s/^(\+.*?)\s+\[/$1\[/;
3957				}
3958			}
3959		}
3960
3961# check for spaces between functions and their parentheses.
3962		while ($line =~ /($Ident)\s+\(/g) {
3963			my $name = $1;
3964			my $ctx_before = substr($line, 0, $-[1]);
3965			my $ctx = "$ctx_before$name";
3966
3967			# Ignore those directives where spaces _are_ permitted.
3968			if ($name =~ /^(?:
3969				if|for|while|switch|return|case|
3970				volatile|__volatile__|
3971				__attribute__|format|__extension__|
3972				asm|__asm__)$/x)
3973			{
3974			# cpp #define statements have non-optional spaces, ie
3975			# if there is a space between the name and the open
3976			# parenthesis it is simply not a parameter group.
3977			} elsif ($ctx_before =~ /^.\s*\#\s*define\s*$/) {
3978
3979			# cpp #elif statement condition may start with a (
3980			} elsif ($ctx =~ /^.\s*\#\s*elif\s*$/) {
3981
3982			# If this whole things ends with a type its most
3983			# likely a typedef for a function.
3984			} elsif ($ctx =~ /$Type$/) {
3985
3986			} else {
3987				if (WARN("SPACING",
3988					 "space prohibited between function name and open parenthesis '('\n" . $herecurr) &&
3989					     $fix) {
3990					$fixed[$fixlinenr] =~
3991					    s/\b$name\s+\(/$name\(/;
3992				}
3993			}
3994		}
3995
3996# Check operator spacing.
3997		if (!($line=~/\#\s*include/)) {
3998			my $fixed_line = "";
3999			my $line_fixed = 0;
4000
4001			my $ops = qr{
4002				<<=|>>=|<=|>=|==|!=|
4003				\+=|-=|\*=|\/=|%=|\^=|\|=|&=|
4004				=>|->|<<|>>|<|>|=|!|~|
4005				&&|\|\||,|\^|\+\+|--|&|\||\+|-|\*|\/|%|
4006				\?:|\?|:
4007			}x;
4008			my @elements = split(/($ops|;)/, $opline);
4009
4010##			print("element count: <" . $#elements . ">\n");
4011##			foreach my $el (@elements) {
4012##				print("el: <$el>\n");
4013##			}
4014
4015			my @fix_elements = ();
4016			my $off = 0;
4017
4018			foreach my $el (@elements) {
4019				push(@fix_elements, substr($rawline, $off, length($el)));
4020				$off += length($el);
4021			}
4022
4023			$off = 0;
4024
4025			my $blank = copy_spacing($opline);
4026			my $last_after = -1;
4027
4028			for (my $n = 0; $n < $#elements; $n += 2) {
4029
4030				my $good = $fix_elements[$n] . $fix_elements[$n + 1];
4031
4032##				print("n: <$n> good: <$good>\n");
4033
4034				$off += length($elements[$n]);
4035
4036				# Pick up the preceding and succeeding characters.
4037				my $ca = substr($opline, 0, $off);
4038				my $cc = '';
4039				if (length($opline) >= ($off + length($elements[$n + 1]))) {
4040					$cc = substr($opline, $off + length($elements[$n + 1]));
4041				}
4042				my $cb = "$ca$;$cc";
4043
4044				my $a = '';
4045				$a = 'V' if ($elements[$n] ne '');
4046				$a = 'W' if ($elements[$n] =~ /\s$/);
4047				$a = 'C' if ($elements[$n] =~ /$;$/);
4048				$a = 'B' if ($elements[$n] =~ /(\[|\()$/);
4049				$a = 'O' if ($elements[$n] eq '');
4050				$a = 'E' if ($ca =~ /^\s*$/);
4051
4052				my $op = $elements[$n + 1];
4053
4054				my $c = '';
4055				if (defined $elements[$n + 2]) {
4056					$c = 'V' if ($elements[$n + 2] ne '');
4057					$c = 'W' if ($elements[$n + 2] =~ /^\s/);
4058					$c = 'C' if ($elements[$n + 2] =~ /^$;/);
4059					$c = 'B' if ($elements[$n + 2] =~ /^(\)|\]|;)/);
4060					$c = 'O' if ($elements[$n + 2] eq '');
4061					$c = 'E' if ($elements[$n + 2] =~ /^\s*\\$/);
4062				} else {
4063					$c = 'E';
4064				}
4065
4066				my $ctx = "${a}x${c}";
4067
4068				my $at = "(ctx:$ctx)";
4069
4070				my $ptr = substr($blank, 0, $off) . "^";
4071				my $hereptr = "$hereline$ptr\n";
4072
4073				# Pull out the value of this operator.
4074				my $op_type = substr($curr_values, $off + 1, 1);
4075
4076				# Get the full operator variant.
4077				my $opv = $op . substr($curr_vars, $off, 1);
4078
4079				# Ignore operators passed as parameters.
4080				if ($op_type ne 'V' &&
4081				    $ca =~ /\s$/ && $cc =~ /^\s*[,\)]/) {
4082
4083#				# Ignore comments
4084#				} elsif ($op =~ /^$;+$/) {
4085
4086				# ; should have either the end of line or a space or \ after it
4087				} elsif ($op eq ';') {
4088					if ($ctx !~ /.x[WEBC]/ &&
4089					    $cc !~ /^\\/ && $cc !~ /^;/) {
4090						if (ERROR("SPACING",
4091							  "space required after that '$op' $at\n" . $hereptr)) {
4092							$good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";
4093							$line_fixed = 1;
4094						}
4095					}
4096
4097				# // is a comment
4098				} elsif ($op eq '//') {
4099
4100				#   :   when part of a bitfield
4101				} elsif ($opv eq ':B') {
4102					# skip the bitfield test for now
4103
4104				# No spaces for:
4105				#   ->
4106				} elsif ($op eq '->') {
4107					if ($ctx =~ /Wx.|.xW/) {
4108						if (ERROR("SPACING",
4109							  "spaces prohibited around that '$op' $at\n" . $hereptr)) {
4110							$good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
4111							if (defined $fix_elements[$n + 2]) {
4112								$fix_elements[$n + 2] =~ s/^\s+//;
4113							}
4114							$line_fixed = 1;
4115						}
4116					}
4117
4118				# , must not have a space before and must have a space on the right.
4119				} elsif ($op eq ',') {
4120					my $rtrim_before = 0;
4121					my $space_after = 0;
4122					if ($ctx =~ /Wx./) {
4123						if (ERROR("SPACING",
4124							  "space prohibited before that '$op' $at\n" . $hereptr)) {
4125							$line_fixed = 1;
4126							$rtrim_before = 1;
4127						}
4128					}
4129					if ($ctx !~ /.x[WEC]/ && $cc !~ /^}/) {
4130						if (ERROR("SPACING",
4131							  "space required after that '$op' $at\n" . $hereptr)) {
4132							$line_fixed = 1;
4133							$last_after = $n;
4134							$space_after = 1;
4135						}
4136					}
4137					if ($rtrim_before || $space_after) {
4138						if ($rtrim_before) {
4139							$good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
4140						} else {
4141							$good = $fix_elements[$n] . trim($fix_elements[$n + 1]);
4142						}
4143						if ($space_after) {
4144							$good .= " ";
4145						}
4146					}
4147
4148				# '*' as part of a type definition -- reported already.
4149				} elsif ($opv eq '*_') {
4150					#warn "'*' is part of type\n";
4151
4152				# unary operators should have a space before and
4153				# none after.  May be left adjacent to another
4154				# unary operator, or a cast
4155				} elsif ($op eq '!' || $op eq '~' ||
4156					 $opv eq '*U' || $opv eq '-U' ||
4157					 $opv eq '&U' || $opv eq '&&U') {
4158					if ($ctx !~ /[WEBC]x./ && $ca !~ /(?:\)|!|~|\*|-|\&|\||\+\+|\-\-|\{)$/) {
4159						if (ERROR("SPACING",
4160							  "space required before that '$op' $at\n" . $hereptr)) {
4161							if ($n != $last_after + 2) {
4162								$good = $fix_elements[$n] . " " . ltrim($fix_elements[$n + 1]);
4163								$line_fixed = 1;
4164							}
4165						}
4166					}
4167					if ($op eq '*' && $cc =~/\s*$Modifier\b/) {
4168						# A unary '*' may be const
4169
4170					} elsif ($ctx =~ /.xW/) {
4171						if (ERROR("SPACING",
4172							  "space prohibited after that '$op' $at\n" . $hereptr)) {
4173							$good = $fix_elements[$n] . rtrim($fix_elements[$n + 1]);
4174							if (defined $fix_elements[$n + 2]) {
4175								$fix_elements[$n + 2] =~ s/^\s+//;
4176							}
4177							$line_fixed = 1;
4178						}
4179					}
4180
4181				# unary ++ and unary -- are allowed no space on one side.
4182				} elsif ($op eq '++' or $op eq '--') {
4183					if ($ctx !~ /[WEOBC]x[^W]/ && $ctx !~ /[^W]x[WOBEC]/) {
4184						if (ERROR("SPACING",
4185							  "space required one side of that '$op' $at\n" . $hereptr)) {
4186							$good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";
4187							$line_fixed = 1;
4188						}
4189					}
4190					if ($ctx =~ /Wx[BE]/ ||
4191					    ($ctx =~ /Wx./ && $cc =~ /^;/)) {
4192						if (ERROR("SPACING",
4193							  "space prohibited before that '$op' $at\n" . $hereptr)) {
4194							$good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
4195							$line_fixed = 1;
4196						}
4197					}
4198					if ($ctx =~ /ExW/) {
4199						if (ERROR("SPACING",
4200							  "space prohibited after that '$op' $at\n" . $hereptr)) {
4201							$good = $fix_elements[$n] . trim($fix_elements[$n + 1]);
4202							if (defined $fix_elements[$n + 2]) {
4203								$fix_elements[$n + 2] =~ s/^\s+//;
4204							}
4205							$line_fixed = 1;
4206						}
4207					}
4208
4209				# << and >> may either have or not have spaces both sides
4210				} elsif ($op eq '<<' or $op eq '>>' or
4211					 $op eq '&' or $op eq '^' or $op eq '|' or
4212					 $op eq '+' or $op eq '-' or
4213					 $op eq '*' or $op eq '/' or
4214					 $op eq '%')
4215				{
4216					if ($check) {
4217						if (defined $fix_elements[$n + 2] && $ctx !~ /[EW]x[EW]/) {
4218							if (CHK("SPACING",
4219								"spaces preferred around that '$op' $at\n" . $hereptr)) {
4220								$good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
4221								$fix_elements[$n + 2] =~ s/^\s+//;
4222								$line_fixed = 1;
4223							}
4224						} elsif (!defined $fix_elements[$n + 2] && $ctx !~ /Wx[OE]/) {
4225							if (CHK("SPACING",
4226								"space preferred before that '$op' $at\n" . $hereptr)) {
4227								$good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]);
4228								$line_fixed = 1;
4229							}
4230						}
4231					} elsif ($ctx =~ /Wx[^WCE]|[^WCE]xW/) {
4232						if (ERROR("SPACING",
4233							  "need consistent spacing around '$op' $at\n" . $hereptr)) {
4234							$good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
4235							if (defined $fix_elements[$n + 2]) {
4236								$fix_elements[$n + 2] =~ s/^\s+//;
4237							}
4238							$line_fixed = 1;
4239						}
4240					}
4241
4242				# A colon needs no spaces before when it is
4243				# terminating a case value or a label.
4244				} elsif ($opv eq ':C' || $opv eq ':L') {
4245					if ($ctx =~ /Wx./) {
4246						if (ERROR("SPACING",
4247							  "space prohibited before that '$op' $at\n" . $hereptr)) {
4248							$good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
4249							$line_fixed = 1;
4250						}
4251					}
4252
4253				# All the others need spaces both sides.
4254				} elsif ($ctx !~ /[EWC]x[CWE]/) {
4255					my $ok = 0;
4256
4257					# Ignore email addresses <foo@bar>
4258					if (($op eq '<' &&
4259					     $cc =~ /^\S+\@\S+>/) ||
4260					    ($op eq '>' &&
4261					     $ca =~ /<\S+\@\S+$/))
4262					{
4263					    	$ok = 1;
4264					}
4265
4266					# for asm volatile statements
4267					# ignore a colon with another
4268					# colon immediately before or after
4269					if (($op eq ':') &&
4270					    ($ca =~ /:$/ || $cc =~ /^:/)) {
4271						$ok = 1;
4272					}
4273
4274					# messages are ERROR, but ?: are CHK
4275					if ($ok == 0) {
4276						my $msg_type = \&ERROR;
4277						$msg_type = \&CHK if (($op eq '?:' || $op eq '?' || $op eq ':') && $ctx =~ /VxV/);
4278
4279						if (&{$msg_type}("SPACING",
4280								 "spaces required around that '$op' $at\n" . $hereptr)) {
4281							$good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
4282							if (defined $fix_elements[$n + 2]) {
4283								$fix_elements[$n + 2] =~ s/^\s+//;
4284							}
4285							$line_fixed = 1;
4286						}
4287					}
4288				}
4289				$off += length($elements[$n + 1]);
4290
4291##				print("n: <$n> GOOD: <$good>\n");
4292
4293				$fixed_line = $fixed_line . $good;
4294			}
4295
4296			if (($#elements % 2) == 0) {
4297				$fixed_line = $fixed_line . $fix_elements[$#elements];
4298			}
4299
4300			if ($fix && $line_fixed && $fixed_line ne $fixed[$fixlinenr]) {
4301				$fixed[$fixlinenr] = $fixed_line;
4302			}
4303
4304
4305		}
4306
4307# check for whitespace before a non-naked semicolon
4308		if ($line =~ /^\+.*\S\s+;\s*$/) {
4309			if (WARN("SPACING",
4310				 "space prohibited before semicolon\n" . $herecurr) &&
4311			    $fix) {
4312				1 while $fixed[$fixlinenr] =~
4313				    s/^(\+.*\S)\s+;/$1;/;
4314			}
4315		}
4316
4317# check for multiple assignments
4318		if ($line =~ /^.\s*$Lval\s*=\s*$Lval\s*=(?!=)/) {
4319			CHK("MULTIPLE_ASSIGNMENTS",
4320			    "multiple assignments should be avoided\n" . $herecurr);
4321		}
4322
4323## # check for multiple declarations, allowing for a function declaration
4324## # continuation.
4325## 		if ($line =~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Ident.*/ &&
4326## 		    $line !~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Type\s*$Ident.*/) {
4327##
4328## 			# Remove any bracketed sections to ensure we do not
4329## 			# falsly report the parameters of functions.
4330## 			my $ln = $line;
4331## 			while ($ln =~ s/\([^\(\)]*\)//g) {
4332## 			}
4333## 			if ($ln =~ /,/) {
4334## 				WARN("MULTIPLE_DECLARATION",
4335##				     "declaring multiple variables together should be avoided\n" . $herecurr);
4336## 			}
4337## 		}
4338
4339#need space before brace following if, while, etc
4340		if (($line =~ /\(.*\)\{/ && $line !~ /\($Type\)\{/) ||
4341		    $line =~ /do\{/) {
4342			if (ERROR("SPACING",
4343				  "space required before the open brace '{'\n" . $herecurr) &&
4344			    $fix) {
4345				$fixed[$fixlinenr] =~ s/^(\+.*(?:do|\))){/$1 {/;
4346			}
4347		}
4348
4349## # check for blank lines before declarations
4350##		if ($line =~ /^.\t+$Type\s+$Ident(?:\s*=.*)?;/ &&
4351##		    $prevrawline =~ /^.\s*$/) {
4352##			WARN("SPACING",
4353##			     "No blank lines before declarations\n" . $hereprev);
4354##		}
4355##
4356
4357# closing brace should have a space following it when it has anything
4358# on the line
4359		if ($line =~ /}(?!(?:,|;|\)))\S/) {
4360			if (ERROR("SPACING",
4361				  "space required after that close brace '}'\n" . $herecurr) &&
4362			    $fix) {
4363				$fixed[$fixlinenr] =~
4364				    s/}((?!(?:,|;|\)))\S)/} $1/;
4365			}
4366		}
4367
4368# check spacing on square brackets
4369		if ($line =~ /\[\s/ && $line !~ /\[\s*$/) {
4370			if (ERROR("SPACING",
4371				  "space prohibited after that open square bracket '['\n" . $herecurr) &&
4372			    $fix) {
4373				$fixed[$fixlinenr] =~
4374				    s/\[\s+/\[/;
4375			}
4376		}
4377		if ($line =~ /\s\]/) {
4378			if (ERROR("SPACING",
4379				  "space prohibited before that close square bracket ']'\n" . $herecurr) &&
4380			    $fix) {
4381				$fixed[$fixlinenr] =~
4382				    s/\s+\]/\]/;
4383			}
4384		}
4385
4386# check spacing on parentheses
4387		if ($line =~ /\(\s/ && $line !~ /\(\s*(?:\\)?$/ &&
4388		    $line !~ /for\s*\(\s+;/) {
4389			if (ERROR("SPACING",
4390				  "space prohibited after that open parenthesis '('\n" . $herecurr) &&
4391			    $fix) {
4392				$fixed[$fixlinenr] =~
4393				    s/\(\s+/\(/;
4394			}
4395		}
4396		if ($line =~ /(\s+)\)/ && $line !~ /^.\s*\)/ &&
4397		    $line !~ /for\s*\(.*;\s+\)/ &&
4398		    $line !~ /:\s+\)/) {
4399			if (ERROR("SPACING",
4400				  "space prohibited before that close parenthesis ')'\n" . $herecurr) &&
4401			    $fix) {
4402				$fixed[$fixlinenr] =~
4403				    s/\s+\)/\)/;
4404			}
4405		}
4406
4407# check unnecessary parentheses around addressof/dereference single $Lvals
4408# ie: &(foo->bar) should be &foo->bar and *(foo->bar) should be *foo->bar
4409
4410		while ($line =~ /(?:[^&]&\s*|\*)\(\s*($Ident\s*(?:$Member\s*)+)\s*\)/g) {
4411			my $var = $1;
4412			if (CHK("UNNECESSARY_PARENTHESES",
4413				"Unnecessary parentheses around $var\n" . $herecurr) &&
4414			    $fix) {
4415				$fixed[$fixlinenr] =~ s/\(\s*\Q$var\E\s*\)/$var/;
4416			}
4417		}
4418
4419# check for unnecessary parentheses around function pointer uses
4420# ie: (foo->bar)(); should be foo->bar();
4421# but not "if (foo->bar) (" to avoid some false positives
4422		if ($line =~ /(\bif\s*|)(\(\s*$Ident\s*(?:$Member\s*)+\))[ \t]*\(/ && $1 !~ /^if/) {
4423			my $var = $2;
4424			if (CHK("UNNECESSARY_PARENTHESES",
4425				"Unnecessary parentheses around function pointer $var\n" . $herecurr) &&
4426			    $fix) {
4427				my $var2 = deparenthesize($var);
4428				$var2 =~ s/\s//g;
4429				$fixed[$fixlinenr] =~ s/\Q$var\E/$var2/;
4430			}
4431		}
4432
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
4433#goto labels aren't indented, allow a single space however
4434		if ($line=~/^.\s+[A-Za-z\d_]+:(?![0-9]+)/ and
4435		   !($line=~/^. [A-Za-z\d_]+:/) and !($line=~/^.\s+default:/)) {
4436			if (WARN("INDENTED_LABEL",
4437				 "labels should not be indented\n" . $herecurr) &&
4438			    $fix) {
4439				$fixed[$fixlinenr] =~
4440				    s/^(.)\s+/$1/;
4441			}
4442		}
4443
4444# return is not a function
4445		if (defined($stat) && $stat =~ /^.\s*return(\s*)\(/s) {
4446			my $spacing = $1;
4447			if ($^V && $^V ge 5.10.0 &&
4448			    $stat =~ /^.\s*return\s*($balanced_parens)\s*;\s*$/) {
4449				my $value = $1;
4450				$value = deparenthesize($value);
4451				if ($value =~ m/^\s*$FuncArg\s*(?:\?|$)/) {
4452					ERROR("RETURN_PARENTHESES",
4453					      "return is not a function, parentheses are not required\n" . $herecurr);
4454				}
4455			} elsif ($spacing !~ /\s+/) {
4456				ERROR("SPACING",
4457				      "space required before the open parenthesis '('\n" . $herecurr);
4458			}
4459		}
4460
4461# unnecessary return in a void function
4462# at end-of-function, with the previous line a single leading tab, then return;
4463# and the line before that not a goto label target like "out:"
4464		if ($sline =~ /^[ \+]}\s*$/ &&
4465		    $prevline =~ /^\+\treturn\s*;\s*$/ &&
4466		    $linenr >= 3 &&
4467		    $lines[$linenr - 3] =~ /^[ +]/ &&
4468		    $lines[$linenr - 3] !~ /^[ +]\s*$Ident\s*:/) {
4469			WARN("RETURN_VOID",
4470			     "void function return statements are not generally useful\n" . $hereprev);
4471               }
4472
4473# if statements using unnecessary parentheses - ie: if ((foo == bar))
4474		if ($^V && $^V ge 5.10.0 &&
4475		    $line =~ /\bif\s*((?:\(\s*){2,})/) {
4476			my $openparens = $1;
4477			my $count = $openparens =~ tr@\(@\(@;
4478			my $msg = "";
4479			if ($line =~ /\bif\s*(?:\(\s*){$count,$count}$LvalOrFunc\s*($Compare)\s*$LvalOrFunc(?:\s*\)){$count,$count}/) {
4480				my $comp = $4;	#Not $1 because of $LvalOrFunc
4481				$msg = " - maybe == should be = ?" if ($comp eq "==");
4482				WARN("UNNECESSARY_PARENTHESES",
4483				     "Unnecessary parentheses$msg\n" . $herecurr);
4484			}
4485		}
4486
4487# comparisons with a constant or upper case identifier on the left
4488#	avoid cases like "foo + BAR < baz"
4489#	only fix matches surrounded by parentheses to avoid incorrect
4490#	conversions like "FOO < baz() + 5" being "misfixed" to "baz() > FOO + 5"
4491		if ($^V && $^V ge 5.10.0 &&
4492		    $line =~ /^\+(.*)\b($Constant|[A-Z_][A-Z0-9_]*)\s*($Compare)\s*($LvalOrFunc)/) {
4493			my $lead = $1;
4494			my $const = $2;
4495			my $comp = $3;
4496			my $to = $4;
4497			my $newcomp = $comp;
4498			if ($lead !~ /(?:$Operators|\.)\s*$/ &&
4499			    $to !~ /^(?:Constant|[A-Z_][A-Z0-9_]*)$/ &&
4500			    WARN("CONSTANT_COMPARISON",
4501				 "Comparisons should place the constant on the right side of the test\n" . $herecurr) &&
4502			    $fix) {
4503				if ($comp eq "<") {
4504					$newcomp = ">";
4505				} elsif ($comp eq "<=") {
4506					$newcomp = ">=";
4507				} elsif ($comp eq ">") {
4508					$newcomp = "<";
4509				} elsif ($comp eq ">=") {
4510					$newcomp = "<=";
4511				}
4512				$fixed[$fixlinenr] =~ s/\(\s*\Q$const\E\s*$Compare\s*\Q$to\E\s*\)/($to $newcomp $const)/;
4513			}
4514		}
4515
4516# Return of what appears to be an errno should normally be negative
4517		if ($sline =~ /\breturn(?:\s*\(+\s*|\s+)(E[A-Z]+)(?:\s*\)+\s*|\s*)[;:,]/) {
4518			my $name = $1;
4519			if ($name ne 'EOF' && $name ne 'ERROR') {
4520				WARN("USE_NEGATIVE_ERRNO",
4521				     "return of an errno should typically be negative (ie: return -$1)\n" . $herecurr);
4522			}
4523		}
4524
4525# Need a space before open parenthesis after if, while etc
4526		if ($line =~ /\b(if|while|for|switch)\(/) {
4527			if (ERROR("SPACING",
4528				  "space required before the open parenthesis '('\n" . $herecurr) &&
4529			    $fix) {
4530				$fixed[$fixlinenr] =~
4531				    s/\b(if|while|for|switch)\(/$1 \(/;
4532			}
4533		}
4534
4535# Check for illegal assignment in if conditional -- and check for trailing
4536# statements after the conditional.
4537		if ($line =~ /do\s*(?!{)/) {
4538			($stat, $cond, $line_nr_next, $remain_next, $off_next) =
4539				ctx_statement_block($linenr, $realcnt, 0)
4540					if (!defined $stat);
4541			my ($stat_next) = ctx_statement_block($line_nr_next,
4542						$remain_next, $off_next);
4543			$stat_next =~ s/\n./\n /g;
4544			##print "stat<$stat> stat_next<$stat_next>\n";
4545
4546			if ($stat_next =~ /^\s*while\b/) {
4547				# If the statement carries leading newlines,
4548				# then count those as offsets.
4549				my ($whitespace) =
4550					($stat_next =~ /^((?:\s*\n[+-])*\s*)/s);
4551				my $offset =
4552					statement_rawlines($whitespace) - 1;
4553
4554				$suppress_whiletrailers{$line_nr_next +
4555								$offset} = 1;
4556			}
4557		}
4558		if (!defined $suppress_whiletrailers{$linenr} &&
4559		    defined($stat) && defined($cond) &&
4560		    $line =~ /\b(?:if|while|for)\s*\(/ && $line !~ /^.\s*#/) {
4561			my ($s, $c) = ($stat, $cond);
4562
4563			if ($c =~ /\bif\s*\(.*[^<>!=]=[^=].*/s) {
4564				ERROR("ASSIGN_IN_IF",
4565				      "do not use assignment in if condition\n" . $herecurr);
4566			}
4567
4568			# Find out what is on the end of the line after the
4569			# conditional.
4570			substr($s, 0, length($c), '');
4571			$s =~ s/\n.*//g;
4572			$s =~ s/$;//g; 	# Remove any comments
4573			if (length($c) && $s !~ /^\s*{?\s*\\*\s*$/ &&
4574			    $c !~ /}\s*while\s*/)
4575			{
4576				# Find out how long the conditional actually is.
4577				my @newlines = ($c =~ /\n/gs);
4578				my $cond_lines = 1 + $#newlines;
4579				my $stat_real = '';
4580
4581				$stat_real = raw_line($linenr, $cond_lines)
4582							. "\n" if ($cond_lines);
4583				if (defined($stat_real) && $cond_lines > 1) {
4584					$stat_real = "[...]\n$stat_real";
4585				}
4586
4587				ERROR("TRAILING_STATEMENTS",
4588				      "trailing statements should be on next line\n" . $herecurr . $stat_real);
4589			}
4590		}
4591
4592# Check for bitwise tests written as boolean
4593		if ($line =~ /
4594			(?:
4595				(?:\[|\(|\&\&|\|\|)
4596				\s*0[xX][0-9]+\s*
4597				(?:\&\&|\|\|)
4598			|
4599				(?:\&\&|\|\|)
4600				\s*0[xX][0-9]+\s*
4601				(?:\&\&|\|\||\)|\])
4602			)/x)
4603		{
4604			WARN("HEXADECIMAL_BOOLEAN_TEST",
4605			     "boolean test with hexadecimal, perhaps just 1 \& or \|?\n" . $herecurr);
4606		}
4607
4608# if and else should not have general statements after it
4609		if ($line =~ /^.\s*(?:}\s*)?else\b(.*)/) {
4610			my $s = $1;
4611			$s =~ s/$;//g; 	# Remove any comments
4612			if ($s !~ /^\s*(?:\sif|(?:{|)\s*\\?\s*$)/) {
4613				ERROR("TRAILING_STATEMENTS",
4614				      "trailing statements should be on next line\n" . $herecurr);
4615			}
4616		}
4617# if should not continue a brace
4618		if ($line =~ /}\s*if\b/) {
4619			ERROR("TRAILING_STATEMENTS",
4620			      "trailing statements should be on next line (or did you mean 'else if'?)\n" .
4621				$herecurr);
4622		}
4623# case and default should not have general statements after them
4624		if ($line =~ /^.\s*(?:case\s*.*|default\s*):/g &&
4625		    $line !~ /\G(?:
4626			(?:\s*$;*)(?:\s*{)?(?:\s*$;*)(?:\s*\\)?\s*$|
4627			\s*return\s+
4628		    )/xg)
4629		{
4630			ERROR("TRAILING_STATEMENTS",
4631			      "trailing statements should be on next line\n" . $herecurr);
4632		}
4633
4634		# Check for }<nl>else {, these must be at the same
4635		# indent level to be relevant to each other.
4636		if ($prevline=~/}\s*$/ and $line=~/^.\s*else\s*/ &&
4637		    $previndent == $indent) {
4638			if (ERROR("ELSE_AFTER_BRACE",
4639				  "else should follow close brace '}'\n" . $hereprev) &&
4640			    $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
4641				fix_delete_line($fixlinenr - 1, $prevrawline);
4642				fix_delete_line($fixlinenr, $rawline);
4643				my $fixedline = $prevrawline;
4644				$fixedline =~ s/}\s*$//;
4645				if ($fixedline !~ /^\+\s*$/) {
4646					fix_insert_line($fixlinenr, $fixedline);
4647				}
4648				$fixedline = $rawline;
4649				$fixedline =~ s/^(.\s*)else/$1} else/;
4650				fix_insert_line($fixlinenr, $fixedline);
4651			}
4652		}
4653
4654		if ($prevline=~/}\s*$/ and $line=~/^.\s*while\s*/ &&
4655		    $previndent == $indent) {
4656			my ($s, $c) = ctx_statement_block($linenr, $realcnt, 0);
4657
4658			# Find out what is on the end of the line after the
4659			# conditional.
4660			substr($s, 0, length($c), '');
4661			$s =~ s/\n.*//g;
4662
4663			if ($s =~ /^\s*;/) {
4664				if (ERROR("WHILE_AFTER_BRACE",
4665					  "while should follow close brace '}'\n" . $hereprev) &&
4666				    $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
4667					fix_delete_line($fixlinenr - 1, $prevrawline);
4668					fix_delete_line($fixlinenr, $rawline);
4669					my $fixedline = $prevrawline;
4670					my $trailing = $rawline;
4671					$trailing =~ s/^\+//;
4672					$trailing = trim($trailing);
4673					$fixedline =~ s/}\s*$/} $trailing/;
4674					fix_insert_line($fixlinenr, $fixedline);
4675				}
4676			}
4677		}
4678
4679#Specific variable tests
4680		while ($line =~ m{($Constant|$Lval)}g) {
4681			my $var = $1;
4682
4683#gcc binary extension
4684			if ($var =~ /^$Binary$/) {
4685				if (WARN("GCC_BINARY_CONSTANT",
4686					 "Avoid gcc v4.3+ binary constant extension: <$var>\n" . $herecurr) &&
4687				    $fix) {
4688					my $hexval = sprintf("0x%x", oct($var));
4689					$fixed[$fixlinenr] =~
4690					    s/\b$var\b/$hexval/;
4691				}
4692			}
4693
4694#CamelCase
4695			if ($var !~ /^$Constant$/ &&
4696			    $var =~ /[A-Z][a-z]|[a-z][A-Z]/ &&
4697#Ignore Page<foo> variants
4698			    $var !~ /^(?:Clear|Set|TestClear|TestSet|)Page[A-Z]/ &&
4699#Ignore SI style variants like nS, mV and dB (ie: max_uV, regulator_min_uA_show)
4700			    $var !~ /^(?:[a-z_]*?)_?[a-z][A-Z](?:_[a-z_]+)?$/ &&
4701#Ignore some three character SI units explicitly, like MiB and KHz
4702			    $var !~ /^(?:[a-z_]*?)_?(?:[KMGT]iB|[KMGT]?Hz)(?:_[a-z_]+)?$/) {
4703				while ($var =~ m{($Ident)}g) {
4704					my $word = $1;
4705					next if ($word !~ /[A-Z][a-z]|[a-z][A-Z]/);
4706					if ($check) {
4707						seed_camelcase_includes();
4708						if (!$file && !$camelcase_file_seeded) {
4709							seed_camelcase_file($realfile);
4710							$camelcase_file_seeded = 1;
4711						}
4712					}
4713					if (!defined $camelcase{$word}) {
4714						$camelcase{$word} = 1;
4715						CHK("CAMELCASE",
4716						    "Avoid CamelCase: <$word>\n" . $herecurr);
4717					}
4718				}
4719			}
4720		}
4721
4722#no spaces allowed after \ in define
4723		if ($line =~ /\#\s*define.*\\\s+$/) {
4724			if (WARN("WHITESPACE_AFTER_LINE_CONTINUATION",
4725				 "Whitespace after \\ makes next lines useless\n" . $herecurr) &&
4726			    $fix) {
4727				$fixed[$fixlinenr] =~ s/\s+$//;
4728			}
4729		}
4730
4731# warn if <asm/foo.h> is #included and <linux/foo.h> is available and includes
4732# itself <asm/foo.h> (uses RAW line)
4733		if ($tree && $rawline =~ m{^.\s*\#\s*include\s*\<asm\/(.*)\.h\>}) {
4734			my $file = "$1.h";
4735			my $checkfile = "include/linux/$file";
4736			if (-f "$root/$checkfile" &&
4737			    $realfile ne $checkfile &&
4738			    $1 !~ /$allowed_asm_includes/)
4739			{
4740				my $asminclude = `grep -Ec "#include\\s+<asm/$file>" $root/$checkfile`;
4741				if ($asminclude > 0) {
4742					if ($realfile =~ m{^arch/}) {
4743						CHK("ARCH_INCLUDE_LINUX",
4744						    "Consider using #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
4745					} else {
4746						WARN("INCLUDE_LINUX",
4747						     "Use #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
4748					}
4749				}
4750			}
4751		}
4752
4753# multi-statement macros should be enclosed in a do while loop, grab the
4754# first statement and ensure its the whole macro if its not enclosed
4755# in a known good container
4756		if ($realfile !~ m@/vmlinux.lds.h$@ &&
4757		    $line =~ /^.\s*\#\s*define\s*$Ident(\()?/) {
4758			my $ln = $linenr;
4759			my $cnt = $realcnt;
4760			my ($off, $dstat, $dcond, $rest);
4761			my $ctx = '';
4762			my $has_flow_statement = 0;
4763			my $has_arg_concat = 0;
4764			($dstat, $dcond, $ln, $cnt, $off) =
4765				ctx_statement_block($linenr, $realcnt, 0);
4766			$ctx = $dstat;
4767			#print "dstat<$dstat> dcond<$dcond> cnt<$cnt> off<$off>\n";
4768			#print "LINE<$lines[$ln-1]> len<" . length($lines[$ln-1]) . "\n";
4769
4770			$has_flow_statement = 1 if ($ctx =~ /\b(goto|return)\b/);
4771			$has_arg_concat = 1 if ($ctx =~ /\#\#/ && $ctx !~ /\#\#\s*(?:__VA_ARGS__|args)\b/);
4772
4773			$dstat =~ s/^.\s*\#\s*define\s+$Ident(\([^\)]*\))?\s*//;
4774			my $define_args = $1;
4775			my $define_stmt = $dstat;
4776			my @def_args = ();
4777
4778			if (defined $define_args && $define_args ne "") {
4779				$define_args = substr($define_args, 1, length($define_args) - 2);
4780				$define_args =~ s/\s*//g;
4781				@def_args = split(",", $define_args);
4782			}
4783
4784			$dstat =~ s/$;//g;
4785			$dstat =~ s/\\\n.//g;
4786			$dstat =~ s/^\s*//s;
4787			$dstat =~ s/\s*$//s;
4788
4789			# Flatten any parentheses and braces
4790			while ($dstat =~ s/\([^\(\)]*\)/1/ ||
4791			       $dstat =~ s/\{[^\{\}]*\}/1/ ||
4792			       $dstat =~ s/.\[[^\[\]]*\]/1/)
4793			{
4794			}
4795
4796			# Flatten any obvious string concatentation.
4797			while ($dstat =~ s/($String)\s*$Ident/$1/ ||
4798			       $dstat =~ s/$Ident\s*($String)/$1/)
4799			{
4800			}
4801
4802			# Make asm volatile uses seem like a generic function
4803			$dstat =~ s/\b_*asm_*\s+_*volatile_*\b/asm_volatile/g;
4804
4805			my $exceptions = qr{
4806				$Declare|
4807				module_param_named|
4808				MODULE_PARM_DESC|
4809				DECLARE_PER_CPU|
4810				DEFINE_PER_CPU|
4811				__typeof__\(|
4812				union|
4813				struct|
4814				\.$Ident\s*=\s*|
4815				^\"|\"$|
4816				^\[
4817			}x;
4818			#print "REST<$rest> dstat<$dstat> ctx<$ctx>\n";
4819
4820			$ctx =~ s/\n*$//;
4821			my $herectx = $here . "\n";
4822			my $stmt_cnt = statement_rawlines($ctx);
4823
4824			for (my $n = 0; $n < $stmt_cnt; $n++) {
4825				$herectx .= raw_line($linenr, $n) . "\n";
4826			}
4827
4828			if ($dstat ne '' &&
4829			    $dstat !~ /^(?:$Ident|-?$Constant),$/ &&			# 10, // foo(),
4830			    $dstat !~ /^(?:$Ident|-?$Constant);$/ &&			# foo();
4831			    $dstat !~ /^[!~-]?(?:$Lval|$Constant)$/ &&		# 10 // foo() // !foo // ~foo // -foo // foo->bar // foo.bar->baz
4832			    $dstat !~ /^'X'$/ && $dstat !~ /^'XX'$/ &&			# character constants
4833			    $dstat !~ /$exceptions/ &&
4834			    $dstat !~ /^\.$Ident\s*=/ &&				# .foo =
4835			    $dstat !~ /^(?:\#\s*$Ident|\#\s*$Constant)\s*$/ &&		# stringification #foo
4836			    $dstat !~ /^do\s*$Constant\s*while\s*$Constant;?$/ &&	# do {...} while (...); // do {...} while (...)
4837			    $dstat !~ /^for\s*$Constant$/ &&				# for (...)
4838			    $dstat !~ /^for\s*$Constant\s+(?:$Ident|-?$Constant)$/ &&	# for (...) bar()
4839			    $dstat !~ /^do\s*{/ &&					# do {...
4840			    $dstat !~ /^\(\{/ &&						# ({...
4841			    $ctx !~ /^.\s*#\s*define\s+TRACE_(?:SYSTEM|INCLUDE_FILE|INCLUDE_PATH)\b/)
4842			{
4843
4844				if ($dstat =~ /;/) {
 
 
4845					ERROR("MULTISTATEMENT_MACRO_USE_DO_WHILE",
4846					      "Macros with multiple statements should be enclosed in a do - while loop\n" . "$herectx");
4847				} else {
4848					ERROR("COMPLEX_MACRO",
4849					      "Macros with complex values should be enclosed in parentheses\n" . "$herectx");
4850				}
4851
4852			}
4853
4854			# Make $define_stmt single line, comment-free, etc
4855			my @stmt_array = split('\n', $define_stmt);
4856			my $first = 1;
4857			$define_stmt = "";
4858			foreach my $l (@stmt_array) {
4859				$l =~ s/\\$//;
4860				if ($first) {
4861					$define_stmt = $l;
4862					$first = 0;
4863				} elsif ($l =~ /^[\+ ]/) {
4864					$define_stmt .= substr($l, 1);
4865				}
4866			}
4867			$define_stmt =~ s/$;//g;
4868			$define_stmt =~ s/\s+/ /g;
4869			$define_stmt = trim($define_stmt);
4870
4871# check if any macro arguments are reused (ignore '...' and 'type')
4872			foreach my $arg (@def_args) {
4873			        next if ($arg =~ /\.\.\./);
4874			        next if ($arg =~ /^type$/i);
4875				my $tmp = $define_stmt;
4876				$tmp =~ s/\b(typeof|__typeof__|__builtin\w+|typecheck\s*\(\s*$Type\s*,|\#+)\s*\(*\s*$arg\s*\)*\b//g;
4877				$tmp =~ s/\#+\s*$arg\b//g;
4878				$tmp =~ s/\b$arg\s*\#\#//g;
4879				my $use_cnt = $tmp =~ s/\b$arg\b//g;
4880				if ($use_cnt > 1) {
4881					CHK("MACRO_ARG_REUSE",
4882					    "Macro argument reuse '$arg' - possible side-effects?\n" . "$herectx");
4883				    }
4884# check if any macro arguments may have other precedence issues
4885				if ($define_stmt =~ m/($Operators)?\s*\b$arg\b\s*($Operators)?/m &&
4886				    ((defined($1) && $1 ne ',') ||
4887				     (defined($2) && $2 ne ','))) {
4888					CHK("MACRO_ARG_PRECEDENCE",
4889					    "Macro argument '$arg' may be better as '($arg)' to avoid precedence issues\n" . "$herectx");
4890				}
4891			}
4892
4893# check for macros with flow control, but without ## concatenation
4894# ## concatenation is commonly a macro that defines a function so ignore those
4895			if ($has_flow_statement && !$has_arg_concat) {
4896				my $herectx = $here . "\n";
4897				my $cnt = statement_rawlines($ctx);
 
4898
4899				for (my $n = 0; $n < $cnt; $n++) {
4900					$herectx .= raw_line($linenr, $n) . "\n";
4901				}
4902				WARN("MACRO_WITH_FLOW_CONTROL",
4903				     "Macros with flow control statements should be avoided\n" . "$herectx");
4904			}
4905
4906# check for line continuations outside of #defines, preprocessor #, and asm
4907
4908		} else {
4909			if ($prevline !~ /^..*\\$/ &&
4910			    $line !~ /^\+\s*\#.*\\$/ &&		# preprocessor
4911			    $line !~ /^\+.*\b(__asm__|asm)\b.*\\$/ &&	# asm
4912			    $line =~ /^\+.*\\$/) {
4913				WARN("LINE_CONTINUATIONS",
4914				     "Avoid unnecessary line continuations\n" . $herecurr);
4915			}
4916		}
4917
4918# do {} while (0) macro tests:
4919# single-statement macros do not need to be enclosed in do while (0) loop,
4920# macro should not end with a semicolon
4921		if ($^V && $^V ge 5.10.0 &&
4922		    $realfile !~ m@/vmlinux.lds.h$@ &&
4923		    $line =~ /^.\s*\#\s*define\s+$Ident(\()?/) {
4924			my $ln = $linenr;
4925			my $cnt = $realcnt;
4926			my ($off, $dstat, $dcond, $rest);
4927			my $ctx = '';
4928			($dstat, $dcond, $ln, $cnt, $off) =
4929				ctx_statement_block($linenr, $realcnt, 0);
4930			$ctx = $dstat;
4931
4932			$dstat =~ s/\\\n.//g;
4933			$dstat =~ s/$;/ /g;
4934
4935			if ($dstat =~ /^\+\s*#\s*define\s+$Ident\s*${balanced_parens}\s*do\s*{(.*)\s*}\s*while\s*\(\s*0\s*\)\s*([;\s]*)\s*$/) {
4936				my $stmts = $2;
4937				my $semis = $3;
4938
4939				$ctx =~ s/\n*$//;
4940				my $cnt = statement_rawlines($ctx);
4941				my $herectx = $here . "\n";
4942
4943				for (my $n = 0; $n < $cnt; $n++) {
4944					$herectx .= raw_line($linenr, $n) . "\n";
4945				}
4946
4947				if (($stmts =~ tr/;/;/) == 1 &&
4948				    $stmts !~ /^\s*(if|while|for|switch)\b/) {
4949					WARN("SINGLE_STATEMENT_DO_WHILE_MACRO",
4950					     "Single statement macros should not use a do {} while (0) loop\n" . "$herectx");
4951				}
4952				if (defined $semis && $semis ne "") {
4953					WARN("DO_WHILE_MACRO_WITH_TRAILING_SEMICOLON",
4954					     "do {} while (0) macros should not be semicolon terminated\n" . "$herectx");
4955				}
4956			} elsif ($dstat =~ /^\+\s*#\s*define\s+$Ident.*;\s*$/) {
4957				$ctx =~ s/\n*$//;
4958				my $cnt = statement_rawlines($ctx);
4959				my $herectx = $here . "\n";
4960
4961				for (my $n = 0; $n < $cnt; $n++) {
4962					$herectx .= raw_line($linenr, $n) . "\n";
4963				}
4964
4965				WARN("TRAILING_SEMICOLON",
4966				     "macros should not use a trailing semicolon\n" . "$herectx");
4967			}
4968		}
4969
4970# make sure symbols are always wrapped with VMLINUX_SYMBOL() ...
4971# all assignments may have only one of the following with an assignment:
4972#	.
4973#	ALIGN(...)
4974#	VMLINUX_SYMBOL(...)
4975		if ($realfile eq 'vmlinux.lds.h' && $line =~ /(?:(?:^|\s)$Ident\s*=|=\s*$Ident(?:\s|$))/) {
4976			WARN("MISSING_VMLINUX_SYMBOL",
4977			     "vmlinux.lds.h needs VMLINUX_SYMBOL() around C-visible symbols\n" . $herecurr);
4978		}
4979
4980# check for redundant bracing round if etc
4981		if ($line =~ /(^.*)\bif\b/ && $1 !~ /else\s*$/) {
4982			my ($level, $endln, @chunks) =
4983				ctx_statement_full($linenr, $realcnt, 1);
4984			#print "chunks<$#chunks> linenr<$linenr> endln<$endln> level<$level>\n";
4985			#print "APW: <<$chunks[1][0]>><<$chunks[1][1]>>\n";
4986			if ($#chunks > 0 && $level == 0) {
4987				my @allowed = ();
4988				my $allow = 0;
4989				my $seen = 0;
4990				my $herectx = $here . "\n";
4991				my $ln = $linenr - 1;
4992				for my $chunk (@chunks) {
4993					my ($cond, $block) = @{$chunk};
4994
4995					# If the condition carries leading newlines, then count those as offsets.
4996					my ($whitespace) = ($cond =~ /^((?:\s*\n[+-])*\s*)/s);
4997					my $offset = statement_rawlines($whitespace) - 1;
4998
4999					$allowed[$allow] = 0;
5000					#print "COND<$cond> whitespace<$whitespace> offset<$offset>\n";
5001
5002					# We have looked at and allowed this specific line.
5003					$suppress_ifbraces{$ln + $offset} = 1;
5004
5005					$herectx .= "$rawlines[$ln + $offset]\n[...]\n";
5006					$ln += statement_rawlines($block) - 1;
5007
5008					substr($block, 0, length($cond), '');
5009
5010					$seen++ if ($block =~ /^\s*{/);
5011
5012					#print "cond<$cond> block<$block> allowed<$allowed[$allow]>\n";
5013					if (statement_lines($cond) > 1) {
5014						#print "APW: ALLOWED: cond<$cond>\n";
5015						$allowed[$allow] = 1;
5016					}
5017					if ($block =~/\b(?:if|for|while)\b/) {
5018						#print "APW: ALLOWED: block<$block>\n";
5019						$allowed[$allow] = 1;
5020					}
5021					if (statement_block_size($block) > 1) {
5022						#print "APW: ALLOWED: lines block<$block>\n";
5023						$allowed[$allow] = 1;
5024					}
5025					$allow++;
5026				}
5027				if ($seen) {
5028					my $sum_allowed = 0;
5029					foreach (@allowed) {
5030						$sum_allowed += $_;
5031					}
5032					if ($sum_allowed == 0) {
5033						WARN("BRACES",
5034						     "braces {} are not necessary for any arm of this statement\n" . $herectx);
5035					} elsif ($sum_allowed != $allow &&
5036						 $seen != $allow) {
5037						CHK("BRACES",
5038						    "braces {} should be used on all arms of this statement\n" . $herectx);
5039					}
5040				}
5041			}
5042		}
5043		if (!defined $suppress_ifbraces{$linenr - 1} &&
5044					$line =~ /\b(if|while|for|else)\b/) {
5045			my $allowed = 0;
5046
5047			# Check the pre-context.
5048			if (substr($line, 0, $-[0]) =~ /(\}\s*)$/) {
5049				#print "APW: ALLOWED: pre<$1>\n";
5050				$allowed = 1;
5051			}
5052
5053			my ($level, $endln, @chunks) =
5054				ctx_statement_full($linenr, $realcnt, $-[0]);
5055
5056			# Check the condition.
5057			my ($cond, $block) = @{$chunks[0]};
5058			#print "CHECKING<$linenr> cond<$cond> block<$block>\n";
5059			if (defined $cond) {
5060				substr($block, 0, length($cond), '');
5061			}
5062			if (statement_lines($cond) > 1) {
5063				#print "APW: ALLOWED: cond<$cond>\n";
5064				$allowed = 1;
5065			}
5066			if ($block =~/\b(?:if|for|while)\b/) {
5067				#print "APW: ALLOWED: block<$block>\n";
5068				$allowed = 1;
5069			}
5070			if (statement_block_size($block) > 1) {
5071				#print "APW: ALLOWED: lines block<$block>\n";
5072				$allowed = 1;
5073			}
5074			# Check the post-context.
5075			if (defined $chunks[1]) {
5076				my ($cond, $block) = @{$chunks[1]};
5077				if (defined $cond) {
5078					substr($block, 0, length($cond), '');
5079				}
5080				if ($block =~ /^\s*\{/) {
5081					#print "APW: ALLOWED: chunk-1 block<$block>\n";
5082					$allowed = 1;
5083				}
5084			}
5085			if ($level == 0 && $block =~ /^\s*\{/ && !$allowed) {
5086				my $herectx = $here . "\n";
5087				my $cnt = statement_rawlines($block);
5088
5089				for (my $n = 0; $n < $cnt; $n++) {
5090					$herectx .= raw_line($linenr, $n) . "\n";
5091				}
5092
5093				WARN("BRACES",
5094				     "braces {} are not necessary for single statement blocks\n" . $herectx);
5095			}
5096		}
5097
 
 
 
 
 
 
5098# check for unnecessary blank lines around braces
5099		if (($line =~ /^.\s*}\s*$/ && $prevrawline =~ /^.\s*$/)) {
5100			if (CHK("BRACES",
5101				"Blank lines aren't necessary before a close brace '}'\n" . $hereprev) &&
5102			    $fix && $prevrawline =~ /^\+/) {
5103				fix_delete_line($fixlinenr - 1, $prevrawline);
5104			}
5105		}
5106		if (($rawline =~ /^.\s*$/ && $prevline =~ /^..*{\s*$/)) {
5107			if (CHK("BRACES",
5108				"Blank lines aren't necessary after an open brace '{'\n" . $hereprev) &&
5109			    $fix) {
5110				fix_delete_line($fixlinenr, $rawline);
5111			}
5112		}
5113
5114# no volatiles please
5115		my $asm_volatile = qr{\b(__asm__|asm)\s+(__volatile__|volatile)\b};
5116		if ($line =~ /\bvolatile\b/ && $line !~ /$asm_volatile/) {
5117			WARN("VOLATILE",
5118			     "Use of volatile is usually wrong: see Documentation/process/volatile-considered-harmful.rst\n" . $herecurr);
5119		}
5120
5121# Check for user-visible strings broken across lines, which breaks the ability
5122# to grep for the string.  Make exceptions when the previous string ends in a
5123# newline (multiple lines in one string constant) or '\t', '\r', ';', or '{'
5124# (common in inline assembly) or is a octal \123 or hexadecimal \xaf value
5125		if ($line =~ /^\+\s*$String/ &&
5126		    $prevline =~ /"\s*$/ &&
5127		    $prevrawline !~ /(?:\\(?:[ntr]|[0-7]{1,3}|x[0-9a-fA-F]{1,2})|;\s*|\{\s*)"\s*$/) {
5128			if (WARN("SPLIT_STRING",
5129				 "quoted string split across lines\n" . $hereprev) &&
5130				     $fix &&
5131				     $prevrawline =~ /^\+.*"\s*$/ &&
5132				     $last_coalesced_string_linenr != $linenr - 1) {
5133				my $extracted_string = get_quoted_string($line, $rawline);
5134				my $comma_close = "";
5135				if ($rawline =~ /\Q$extracted_string\E(\s*\)\s*;\s*$|\s*,\s*)/) {
5136					$comma_close = $1;
5137				}
5138
5139				fix_delete_line($fixlinenr - 1, $prevrawline);
5140				fix_delete_line($fixlinenr, $rawline);
5141				my $fixedline = $prevrawline;
5142				$fixedline =~ s/"\s*$//;
5143				$fixedline .= substr($extracted_string, 1) . trim($comma_close);
5144				fix_insert_line($fixlinenr - 1, $fixedline);
5145				$fixedline = $rawline;
5146				$fixedline =~ s/\Q$extracted_string\E\Q$comma_close\E//;
5147				if ($fixedline !~ /\+\s*$/) {
5148					fix_insert_line($fixlinenr, $fixedline);
5149				}
5150				$last_coalesced_string_linenr = $linenr;
5151			}
5152		}
5153
5154# check for missing a space in a string concatenation
5155		if ($prevrawline =~ /[^\\]\w"$/ && $rawline =~ /^\+[\t ]+"\w/) {
5156			WARN('MISSING_SPACE',
5157			     "break quoted strings at a space character\n" . $hereprev);
5158		}
5159
 
 
 
 
 
 
 
 
 
 
 
 
5160# check for spaces before a quoted newline
5161		if ($rawline =~ /^.*\".*\s\\n/) {
5162			if (WARN("QUOTED_WHITESPACE_BEFORE_NEWLINE",
5163				 "unnecessary whitespace before a quoted newline\n" . $herecurr) &&
5164			    $fix) {
5165				$fixed[$fixlinenr] =~ s/^(\+.*\".*)\s+\\n/$1\\n/;
5166			}
5167
5168		}
5169
5170# concatenated string without spaces between elements
5171		if ($line =~ /$String[A-Z_]/ || $line =~ /[A-Za-z0-9_]$String/) {
5172			CHK("CONCATENATED_STRING",
5173			    "Concatenated strings should use spaces between elements\n" . $herecurr);
5174		}
5175
5176# uncoalesced string fragments
5177		if ($line =~ /$String\s*"/) {
5178			WARN("STRING_FRAGMENTS",
5179			     "Consecutive strings are generally better as a single string\n" . $herecurr);
5180		}
5181
5182# check for %L{u,d,i} and 0x%[udi] in strings
5183		my $string;
 
5184		while ($line =~ /(?:^|")([X\t]*)(?:"|$)/g) {
5185			$string = substr($rawline, $-[1], $+[1] - $-[1]);
5186			$string =~ s/%%/__/g;
5187			if ($string =~ /(?<!%)%[\*\d\.\$]*L[udi]/) {
 
5188				WARN("PRINTF_L",
5189				     "\%Ld/%Lu are not-standard C, use %lld/%llu\n" . $herecurr);
5190				last;
5191			}
5192			if ($string =~ /0x%[\*\d\.\$\Llzth]*[udi]/) {
5193				ERROR("PRINTF_0xDECIMAL",
 
 
 
 
 
 
 
5194				      "Prefixing 0x with decimal output is defective\n" . $herecurr);
5195			}
5196		}
5197
5198# check for line continuations in quoted strings with odd counts of "
5199		if ($rawline =~ /\\$/ && $rawline =~ tr/"/"/ % 2) {
5200			WARN("LINE_CONTINUATIONS",
5201			     "Avoid line continuations in quoted strings\n" . $herecurr);
5202		}
5203
5204# warn about #if 0
5205		if ($line =~ /^.\s*\#\s*if\s+0\b/) {
5206			CHK("REDUNDANT_CODE",
5207			    "if this code is redundant consider removing it\n" .
5208				$herecurr);
5209		}
5210
5211# check for needless "if (<foo>) fn(<foo>)" uses
5212		if ($prevline =~ /\bif\s*\(\s*($Lval)\s*\)/) {
5213			my $tested = quotemeta($1);
5214			my $expr = '\s*\(\s*' . $tested . '\s*\)\s*;';
5215			if ($line =~ /\b(kfree|usb_free_urb|debugfs_remove(?:_recursive)?|(?:kmem_cache|mempool|dma_pool)_destroy)$expr/) {
5216				my $func = $1;
5217				if (WARN('NEEDLESS_IF',
5218					 "$func(NULL) is safe and this check is probably not required\n" . $hereprev) &&
5219				    $fix) {
5220					my $do_fix = 1;
5221					my $leading_tabs = "";
5222					my $new_leading_tabs = "";
5223					if ($lines[$linenr - 2] =~ /^\+(\t*)if\s*\(\s*$tested\s*\)\s*$/) {
5224						$leading_tabs = $1;
5225					} else {
5226						$do_fix = 0;
5227					}
5228					if ($lines[$linenr - 1] =~ /^\+(\t+)$func\s*\(\s*$tested\s*\)\s*;\s*$/) {
5229						$new_leading_tabs = $1;
5230						if (length($leading_tabs) + 1 ne length($new_leading_tabs)) {
5231							$do_fix = 0;
5232						}
5233					} else {
5234						$do_fix = 0;
5235					}
5236					if ($do_fix) {
5237						fix_delete_line($fixlinenr - 1, $prevrawline);
5238						$fixed[$fixlinenr] =~ s/^\+$new_leading_tabs/\+$leading_tabs/;
5239					}
5240				}
5241			}
5242		}
5243
5244# check for unnecessary "Out of Memory" messages
5245		if ($line =~ /^\+.*\b$logFunctions\s*\(/ &&
5246		    $prevline =~ /^[ \+]\s*if\s*\(\s*(\!\s*|NULL\s*==\s*)?($Lval)(\s*==\s*NULL\s*)?\s*\)/ &&
5247		    (defined $1 || defined $3) &&
5248		    $linenr > 3) {
5249			my $testval = $2;
5250			my $testline = $lines[$linenr - 3];
5251
5252			my ($s, $c) = ctx_statement_block($linenr - 3, $realcnt, 0);
5253#			print("line: <$line>\nprevline: <$prevline>\ns: <$s>\nc: <$c>\n\n\n");
5254
5255			if ($c =~ /(?:^|\n)[ \+]\s*(?:$Type\s*)?\Q$testval\E\s*=\s*(?:\([^\)]*\)\s*)?\s*(?:devm_)?(?:[kv][czm]alloc(?:_node|_array)?\b|kstrdup|(?:dev_)?alloc_skb)/) {
5256				WARN("OOM_MESSAGE",
5257				     "Possible unnecessary 'out of memory' message\n" . $hereprev);
5258			}
5259		}
5260
5261# check for logging functions with KERN_<LEVEL>
5262		if ($line !~ /printk(?:_ratelimited|_once)?\s*\(/ &&
5263		    $line =~ /\b$logFunctions\s*\(.*\b(KERN_[A-Z]+)\b/) {
5264			my $level = $1;
5265			if (WARN("UNNECESSARY_KERN_LEVEL",
5266				 "Possible unnecessary $level\n" . $herecurr) &&
5267			    $fix) {
5268				$fixed[$fixlinenr] =~ s/\s*$level\s*//;
5269			}
5270		}
5271
 
 
 
 
 
 
5272# check for mask then right shift without a parentheses
5273		if ($^V && $^V ge 5.10.0 &&
5274		    $line =~ /$LvalOrFunc\s*\&\s*($LvalOrFunc)\s*>>/ &&
5275		    $4 !~ /^\&/) { # $LvalOrFunc may be &foo, ignore if so
5276			WARN("MASK_THEN_SHIFT",
5277			     "Possible precedence defect with mask then right shift - may need parentheses\n" . $herecurr);
5278		}
5279
5280# check for pointer comparisons to NULL
5281		if ($^V && $^V ge 5.10.0) {
5282			while ($line =~ /\b$LvalOrFunc\s*(==|\!=)\s*NULL\b/g) {
5283				my $val = $1;
5284				my $equal = "!";
5285				$equal = "" if ($4 eq "!=");
5286				if (CHK("COMPARISON_TO_NULL",
5287					"Comparison to NULL could be written \"${equal}${val}\"\n" . $herecurr) &&
5288					    $fix) {
5289					$fixed[$fixlinenr] =~ s/\b\Q$val\E\s*(?:==|\!=)\s*NULL\b/$equal$val/;
5290				}
5291			}
5292		}
5293
5294# check for bad placement of section $InitAttribute (e.g.: __initdata)
5295		if ($line =~ /(\b$InitAttribute\b)/) {
5296			my $attr = $1;
5297			if ($line =~ /^\+\s*static\s+(?:const\s+)?(?:$attr\s+)?($NonptrTypeWithAttr)\s+(?:$attr\s+)?($Ident(?:\[[^]]*\])?)\s*[=;]/) {
5298				my $ptr = $1;
5299				my $var = $2;
5300				if ((($ptr =~ /\b(union|struct)\s+$attr\b/ &&
5301				      ERROR("MISPLACED_INIT",
5302					    "$attr should be placed after $var\n" . $herecurr)) ||
5303				     ($ptr !~ /\b(union|struct)\s+$attr\b/ &&
5304				      WARN("MISPLACED_INIT",
5305					   "$attr should be placed after $var\n" . $herecurr))) &&
5306				    $fix) {
5307					$fixed[$fixlinenr] =~ s/(\bstatic\s+(?:const\s+)?)(?:$attr\s+)?($NonptrTypeWithAttr)\s+(?:$attr\s+)?($Ident(?:\[[^]]*\])?)\s*([=;])\s*/"$1" . trim(string_find_replace($2, "\\s*$attr\\s*", " ")) . " " . trim(string_find_replace($3, "\\s*$attr\\s*", "")) . " $attr" . ("$4" eq ";" ? ";" : " = ")/e;
5308				}
5309			}
5310		}
5311
5312# check for $InitAttributeData (ie: __initdata) with const
5313		if ($line =~ /\bconst\b/ && $line =~ /($InitAttributeData)/) {
5314			my $attr = $1;
5315			$attr =~ /($InitAttributePrefix)(.*)/;
5316			my $attr_prefix = $1;
5317			my $attr_type = $2;
5318			if (ERROR("INIT_ATTRIBUTE",
5319				  "Use of const init definition must use ${attr_prefix}initconst\n" . $herecurr) &&
5320			    $fix) {
5321				$fixed[$fixlinenr] =~
5322				    s/$InitAttributeData/${attr_prefix}initconst/;
5323			}
5324		}
5325
5326# check for $InitAttributeConst (ie: __initconst) without const
5327		if ($line !~ /\bconst\b/ && $line =~ /($InitAttributeConst)/) {
5328			my $attr = $1;
5329			if (ERROR("INIT_ATTRIBUTE",
5330				  "Use of $attr requires a separate use of const\n" . $herecurr) &&
5331			    $fix) {
5332				my $lead = $fixed[$fixlinenr] =~
5333				    /(^\+\s*(?:static\s+))/;
5334				$lead = rtrim($1);
5335				$lead = "$lead " if ($lead !~ /^\+$/);
5336				$lead = "${lead}const ";
5337				$fixed[$fixlinenr] =~ s/(^\+\s*(?:static\s+))/$lead/;
5338			}
5339		}
5340
5341# check for __read_mostly with const non-pointer (should just be const)
5342		if ($line =~ /\b__read_mostly\b/ &&
5343		    $line =~ /($Type)\s*$Ident/ && $1 !~ /\*\s*$/ && $1 =~ /\bconst\b/) {
5344			if (ERROR("CONST_READ_MOSTLY",
5345				  "Invalid use of __read_mostly with const type\n" . $herecurr) &&
5346			    $fix) {
5347				$fixed[$fixlinenr] =~ s/\s+__read_mostly\b//;
5348			}
5349		}
5350
5351# don't use __constant_<foo> functions outside of include/uapi/
5352		if ($realfile !~ m@^include/uapi/@ &&
5353		    $line =~ /(__constant_(?:htons|ntohs|[bl]e(?:16|32|64)_to_cpu|cpu_to_[bl]e(?:16|32|64)))\s*\(/) {
5354			my $constant_func = $1;
5355			my $func = $constant_func;
5356			$func =~ s/^__constant_//;
5357			if (WARN("CONSTANT_CONVERSION",
5358				 "$constant_func should be $func\n" . $herecurr) &&
5359			    $fix) {
5360				$fixed[$fixlinenr] =~ s/\b$constant_func\b/$func/g;
5361			}
5362		}
5363
5364# prefer usleep_range over udelay
5365		if ($line =~ /\budelay\s*\(\s*(\d+)\s*\)/) {
5366			my $delay = $1;
5367			# ignore udelay's < 10, however
5368			if (! ($delay < 10) ) {
5369				CHK("USLEEP_RANGE",
5370				    "usleep_range is preferred over udelay; see Documentation/timers/timers-howto.txt\n" . $herecurr);
5371			}
5372			if ($delay > 2000) {
5373				WARN("LONG_UDELAY",
5374				     "long udelay - prefer mdelay; see arch/arm/include/asm/delay.h\n" . $herecurr);
5375			}
5376		}
5377
5378# warn about unexpectedly long msleep's
5379		if ($line =~ /\bmsleep\s*\((\d+)\);/) {
5380			if ($1 < 20) {
5381				WARN("MSLEEP",
5382				     "msleep < 20ms can sleep for up to 20ms; see Documentation/timers/timers-howto.txt\n" . $herecurr);
5383			}
5384		}
5385
5386# check for comparisons of jiffies
5387		if ($line =~ /\bjiffies\s*$Compare|$Compare\s*jiffies\b/) {
5388			WARN("JIFFIES_COMPARISON",
5389			     "Comparing jiffies is almost always wrong; prefer time_after, time_before and friends\n" . $herecurr);
5390		}
5391
5392# check for comparisons of get_jiffies_64()
5393		if ($line =~ /\bget_jiffies_64\s*\(\s*\)\s*$Compare|$Compare\s*get_jiffies_64\s*\(\s*\)/) {
5394			WARN("JIFFIES_COMPARISON",
5395			     "Comparing get_jiffies_64() is almost always wrong; prefer time_after64, time_before64 and friends\n" . $herecurr);
5396		}
5397
5398# warn about #ifdefs in C files
5399#		if ($line =~ /^.\s*\#\s*if(|n)def/ && ($realfile =~ /\.c$/)) {
5400#			print "#ifdef in C files should be avoided\n";
5401#			print "$herecurr";
5402#			$clean = 0;
5403#		}
5404
5405# warn about spacing in #ifdefs
5406		if ($line =~ /^.\s*\#\s*(ifdef|ifndef|elif)\s\s+/) {
5407			if (ERROR("SPACING",
5408				  "exactly one space required after that #$1\n" . $herecurr) &&
5409			    $fix) {
5410				$fixed[$fixlinenr] =~
5411				    s/^(.\s*\#\s*(ifdef|ifndef|elif))\s{2,}/$1 /;
5412			}
5413
5414		}
5415
5416# check for spinlock_t definitions without a comment.
5417		if ($line =~ /^.\s*(struct\s+mutex|spinlock_t)\s+\S+;/ ||
5418		    $line =~ /^.\s*(DEFINE_MUTEX)\s*\(/) {
5419			my $which = $1;
5420			if (!ctx_has_comment($first_line, $linenr)) {
5421				CHK("UNCOMMENTED_DEFINITION",
5422				    "$1 definition without comment\n" . $herecurr);
5423			}
5424		}
5425# check for memory barriers without a comment.
5426
5427		my $barriers = qr{
5428			mb|
5429			rmb|
5430			wmb|
5431			read_barrier_depends
5432		}x;
5433		my $barrier_stems = qr{
5434			mb__before_atomic|
5435			mb__after_atomic|
5436			store_release|
5437			load_acquire|
5438			store_mb|
5439			(?:$barriers)
5440		}x;
5441		my $all_barriers = qr{
5442			(?:$barriers)|
5443			smp_(?:$barrier_stems)|
5444			virt_(?:$barrier_stems)
5445		}x;
5446
5447		if ($line =~ /\b(?:$all_barriers)\s*\(/) {
5448			if (!ctx_has_comment($first_line, $linenr)) {
5449				WARN("MEMORY_BARRIER",
5450				     "memory barrier without comment\n" . $herecurr);
5451			}
5452		}
5453
5454		my $underscore_smp_barriers = qr{__smp_(?:$barrier_stems)}x;
5455
5456		if ($realfile !~ m@^include/asm-generic/@ &&
5457		    $realfile !~ m@/barrier\.h$@ &&
5458		    $line =~ m/\b(?:$underscore_smp_barriers)\s*\(/ &&
5459		    $line !~ m/^.\s*\#\s*define\s+(?:$underscore_smp_barriers)\s*\(/) {
5460			WARN("MEMORY_BARRIER",
5461			     "__smp memory barriers shouldn't be used outside barrier.h and asm-generic\n" . $herecurr);
5462		}
5463
5464# check for waitqueue_active without a comment.
5465		if ($line =~ /\bwaitqueue_active\s*\(/) {
5466			if (!ctx_has_comment($first_line, $linenr)) {
5467				WARN("WAITQUEUE_ACTIVE",
5468				     "waitqueue_active without comment\n" . $herecurr);
5469			}
5470		}
5471
5472# Check for expedited grace periods that interrupt non-idle non-nohz
5473# online CPUs.  These expedited can therefore degrade real-time response
5474# if used carelessly, and should be avoided where not absolutely
5475# needed.  It is always OK to use synchronize_rcu_expedited() and
5476# synchronize_sched_expedited() at boot time (before real-time applications
5477# start) and in error situations where real-time response is compromised in
5478# any case.  Note that synchronize_srcu_expedited() does -not- interrupt
5479# other CPUs, so don't warn on uses of synchronize_srcu_expedited().
5480# Of course, nothing comes for free, and srcu_read_lock() and
5481# srcu_read_unlock() do contain full memory barriers in payment for
5482# synchronize_srcu_expedited() non-interruption properties.
5483		if ($line =~ /\b(synchronize_rcu_expedited|synchronize_sched_expedited)\(/) {
5484			WARN("EXPEDITED_RCU_GRACE_PERIOD",
5485			     "expedited RCU grace periods should be avoided where they can degrade real-time response\n" . $herecurr);
5486
5487		}
5488
5489# check of hardware specific defines
5490		if ($line =~ m@^.\s*\#\s*if.*\b(__i386__|__powerpc64__|__sun__|__s390x__)\b@ && $realfile !~ m@include/asm-@) {
5491			CHK("ARCH_DEFINES",
5492			    "architecture specific defines should be avoided\n" .  $herecurr);
5493		}
5494
 
 
 
 
 
5495# Check that the storage class is at the beginning of a declaration
5496		if ($line =~ /\b$Storage\b/ && $line !~ /^.\s*$Storage\b/) {
 
 
 
5497			WARN("STORAGE_CLASS",
5498			     "storage class should be at the beginning of the declaration\n" . $herecurr)
5499		}
5500
5501# check the location of the inline attribute, that it is between
5502# storage class and type.
5503		if ($line =~ /\b$Type\s+$Inline\b/ ||
5504		    $line =~ /\b$Inline\s+$Storage\b/) {
5505			ERROR("INLINE_LOCATION",
5506			      "inline keyword should sit between storage class and type\n" . $herecurr);
5507		}
5508
5509# Check for __inline__ and __inline, prefer inline
5510		if ($realfile !~ m@\binclude/uapi/@ &&
5511		    $line =~ /\b(__inline__|__inline)\b/) {
5512			if (WARN("INLINE",
5513				 "plain inline is preferred over $1\n" . $herecurr) &&
5514			    $fix) {
5515				$fixed[$fixlinenr] =~ s/\b(__inline__|__inline)\b/inline/;
5516
5517			}
5518		}
5519
5520# Check for __attribute__ packed, prefer __packed
5521		if ($realfile !~ m@\binclude/uapi/@ &&
5522		    $line =~ /\b__attribute__\s*\(\s*\(.*\bpacked\b/) {
5523			WARN("PREFER_PACKED",
5524			     "__packed is preferred over __attribute__((packed))\n" . $herecurr);
5525		}
5526
5527# Check for __attribute__ aligned, prefer __aligned
5528		if ($realfile !~ m@\binclude/uapi/@ &&
5529		    $line =~ /\b__attribute__\s*\(\s*\(.*aligned/) {
5530			WARN("PREFER_ALIGNED",
5531			     "__aligned(size) is preferred over __attribute__((aligned(size)))\n" . $herecurr);
5532		}
5533
5534# Check for __attribute__ format(printf, prefer __printf
5535		if ($realfile !~ m@\binclude/uapi/@ &&
5536		    $line =~ /\b__attribute__\s*\(\s*\(\s*format\s*\(\s*printf/) {
5537			if (WARN("PREFER_PRINTF",
5538				 "__printf(string-index, first-to-check) is preferred over __attribute__((format(printf, string-index, first-to-check)))\n" . $herecurr) &&
5539			    $fix) {
5540				$fixed[$fixlinenr] =~ s/\b__attribute__\s*\(\s*\(\s*format\s*\(\s*printf\s*,\s*(.*)\)\s*\)\s*\)/"__printf(" . trim($1) . ")"/ex;
5541
5542			}
5543		}
5544
5545# Check for __attribute__ format(scanf, prefer __scanf
5546		if ($realfile !~ m@\binclude/uapi/@ &&
5547		    $line =~ /\b__attribute__\s*\(\s*\(\s*format\s*\(\s*scanf\b/) {
5548			if (WARN("PREFER_SCANF",
5549				 "__scanf(string-index, first-to-check) is preferred over __attribute__((format(scanf, string-index, first-to-check)))\n" . $herecurr) &&
5550			    $fix) {
5551				$fixed[$fixlinenr] =~ s/\b__attribute__\s*\(\s*\(\s*format\s*\(\s*scanf\s*,\s*(.*)\)\s*\)\s*\)/"__scanf(" . trim($1) . ")"/ex;
5552			}
5553		}
5554
5555# Check for __attribute__ weak, or __weak declarations (may have link issues)
5556		if ($^V && $^V ge 5.10.0 &&
5557		    $line =~ /(?:$Declare|$DeclareMisordered)\s*$Ident\s*$balanced_parens\s*(?:$Attribute)?\s*;/ &&
5558		    ($line =~ /\b__attribute__\s*\(\s*\(.*\bweak\b/ ||
5559		     $line =~ /\b__weak\b/)) {
5560			ERROR("WEAK_DECLARATION",
5561			      "Using weak declarations can have unintended link defects\n" . $herecurr);
5562		}
5563
5564# check for c99 types like uint8_t used outside of uapi/ and tools/
5565		if ($realfile !~ m@\binclude/uapi/@ &&
5566		    $realfile !~ m@\btools/@ &&
5567		    $line =~ /\b($Declare)\s*$Ident\s*[=;,\[]/) {
5568			my $type = $1;
5569			if ($type =~ /\b($typeC99Typedefs)\b/) {
5570				$type = $1;
5571				my $kernel_type = 'u';
5572				$kernel_type = 's' if ($type =~ /^_*[si]/);
5573				$type =~ /(\d+)/;
5574				$kernel_type .= $1;
5575				if (CHK("PREFER_KERNEL_TYPES",
5576					"Prefer kernel type '$kernel_type' over '$type'\n" . $herecurr) &&
5577				    $fix) {
5578					$fixed[$fixlinenr] =~ s/\b$type\b/$kernel_type/;
5579				}
5580			}
5581		}
5582
5583# check for cast of C90 native int or longer types constants
5584		if ($line =~ /(\(\s*$C90_int_types\s*\)\s*)($Constant)\b/) {
5585			my $cast = $1;
5586			my $const = $2;
5587			if (WARN("TYPECAST_INT_CONSTANT",
5588				 "Unnecessary typecast of c90 int constant\n" . $herecurr) &&
5589			    $fix) {
5590				my $suffix = "";
5591				my $newconst = $const;
5592				$newconst =~ s/${Int_type}$//;
5593				$suffix .= 'U' if ($cast =~ /\bunsigned\b/);
5594				if ($cast =~ /\blong\s+long\b/) {
5595					$suffix .= 'LL';
5596				} elsif ($cast =~ /\blong\b/) {
5597					$suffix .= 'L';
5598				}
5599				$fixed[$fixlinenr] =~ s/\Q$cast\E$const\b/$newconst$suffix/;
5600			}
5601		}
5602
5603# check for sizeof(&)
5604		if ($line =~ /\bsizeof\s*\(\s*\&/) {
5605			WARN("SIZEOF_ADDRESS",
5606			     "sizeof(& should be avoided\n" . $herecurr);
5607		}
5608
5609# check for sizeof without parenthesis
5610		if ($line =~ /\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/) {
5611			if (WARN("SIZEOF_PARENTHESIS",
5612				 "sizeof $1 should be sizeof($1)\n" . $herecurr) &&
5613			    $fix) {
5614				$fixed[$fixlinenr] =~ s/\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/"sizeof(" . trim($1) . ")"/ex;
5615			}
5616		}
5617
5618# check for struct spinlock declarations
5619		if ($line =~ /^.\s*\bstruct\s+spinlock\s+\w+\s*;/) {
5620			WARN("USE_SPINLOCK_T",
5621			     "struct spinlock should be spinlock_t\n" . $herecurr);
5622		}
5623
5624# check for seq_printf uses that could be seq_puts
5625		if ($sline =~ /\bseq_printf\s*\(.*"\s*\)\s*;\s*$/) {
5626			my $fmt = get_quoted_string($line, $rawline);
5627			$fmt =~ s/%%//g;
5628			if ($fmt !~ /%/) {
5629				if (WARN("PREFER_SEQ_PUTS",
5630					 "Prefer seq_puts to seq_printf\n" . $herecurr) &&
5631				    $fix) {
5632					$fixed[$fixlinenr] =~ s/\bseq_printf\b/seq_puts/;
5633				}
5634			}
5635		}
5636
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
5637# Check for misused memsets
5638		if ($^V && $^V ge 5.10.0 &&
5639		    defined $stat &&
5640		    $stat =~ /^\+(?:.*?)\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*$FuncArg\s*\)/) {
5641
5642			my $ms_addr = $2;
5643			my $ms_val = $7;
5644			my $ms_size = $12;
5645
5646			if ($ms_size =~ /^(0x|)0$/i) {
5647				ERROR("MEMSET",
5648				      "memset to 0's uses 0 as the 2nd argument, not the 3rd\n" . "$here\n$stat\n");
5649			} elsif ($ms_size =~ /^(0x|)1$/i) {
5650				WARN("MEMSET",
5651				     "single byte memset is suspicious. Swapped 2nd/3rd argument?\n" . "$here\n$stat\n");
5652			}
5653		}
5654
5655# Check for memcpy(foo, bar, ETH_ALEN) that could be ether_addr_copy(foo, bar)
5656#		if ($^V && $^V ge 5.10.0 &&
5657#		    defined $stat &&
5658#		    $stat =~ /^\+(?:.*?)\bmemcpy\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/) {
5659#			if (WARN("PREFER_ETHER_ADDR_COPY",
5660#				 "Prefer ether_addr_copy() over memcpy() if the Ethernet addresses are __aligned(2)\n" . "$here\n$stat\n") &&
5661#			    $fix) {
5662#				$fixed[$fixlinenr] =~ s/\bmemcpy\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/ether_addr_copy($2, $7)/;
5663#			}
5664#		}
5665
5666# Check for memcmp(foo, bar, ETH_ALEN) that could be ether_addr_equal*(foo, bar)
5667#		if ($^V && $^V ge 5.10.0 &&
5668#		    defined $stat &&
5669#		    $stat =~ /^\+(?:.*?)\bmemcmp\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/) {
5670#			WARN("PREFER_ETHER_ADDR_EQUAL",
5671#			     "Prefer ether_addr_equal() or ether_addr_equal_unaligned() over memcmp()\n" . "$here\n$stat\n")
5672#		}
5673
5674# check for memset(foo, 0x0, ETH_ALEN) that could be eth_zero_addr
5675# check for memset(foo, 0xFF, ETH_ALEN) that could be eth_broadcast_addr
5676#		if ($^V && $^V ge 5.10.0 &&
5677#		    defined $stat &&
5678#		    $stat =~ /^\+(?:.*?)\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/) {
5679#
5680#			my $ms_val = $7;
5681#
5682#			if ($ms_val =~ /^(?:0x|)0+$/i) {
5683#				if (WARN("PREFER_ETH_ZERO_ADDR",
5684#					 "Prefer eth_zero_addr over memset()\n" . "$here\n$stat\n") &&
5685#				    $fix) {
5686#					$fixed[$fixlinenr] =~ s/\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*,\s*ETH_ALEN\s*\)/eth_zero_addr($2)/;
5687#				}
5688#			} elsif ($ms_val =~ /^(?:0xff|255)$/i) {
5689#				if (WARN("PREFER_ETH_BROADCAST_ADDR",
5690#					 "Prefer eth_broadcast_addr() over memset()\n" . "$here\n$stat\n") &&
5691#				    $fix) {
5692#					$fixed[$fixlinenr] =~ s/\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*,\s*ETH_ALEN\s*\)/eth_broadcast_addr($2)/;
5693#				}
5694#			}
5695#		}
5696
5697# typecasts on min/max could be min_t/max_t
5698		if ($^V && $^V ge 5.10.0 &&
5699		    defined $stat &&
5700		    $stat =~ /^\+(?:.*?)\b(min|max)\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\)/) {
5701			if (defined $2 || defined $7) {
5702				my $call = $1;
5703				my $cast1 = deparenthesize($2);
5704				my $arg1 = $3;
5705				my $cast2 = deparenthesize($7);
5706				my $arg2 = $8;
5707				my $cast;
5708
5709				if ($cast1 ne "" && $cast2 ne "" && $cast1 ne $cast2) {
5710					$cast = "$cast1 or $cast2";
5711				} elsif ($cast1 ne "") {
5712					$cast = $cast1;
5713				} else {
5714					$cast = $cast2;
5715				}
5716				WARN("MINMAX",
5717				     "$call() should probably be ${call}_t($cast, $arg1, $arg2)\n" . "$here\n$stat\n");
5718			}
5719		}
5720
5721# check usleep_range arguments
5722		if ($^V && $^V ge 5.10.0 &&
5723		    defined $stat &&
5724		    $stat =~ /^\+(?:.*?)\busleep_range\s*\(\s*($FuncArg)\s*,\s*($FuncArg)\s*\)/) {
5725			my $min = $1;
5726			my $max = $7;
5727			if ($min eq $max) {
5728				WARN("USLEEP_RANGE",
5729				     "usleep_range should not use min == max args; see Documentation/timers/timers-howto.txt\n" . "$here\n$stat\n");
5730			} elsif ($min =~ /^\d+$/ && $max =~ /^\d+$/ &&
5731				 $min > $max) {
5732				WARN("USLEEP_RANGE",
5733				     "usleep_range args reversed, use min then max; see Documentation/timers/timers-howto.txt\n" . "$here\n$stat\n");
5734			}
5735		}
5736
5737# check for naked sscanf
5738		if ($^V && $^V ge 5.10.0 &&
5739		    defined $stat &&
5740		    $line =~ /\bsscanf\b/ &&
5741		    ($stat !~ /$Ident\s*=\s*sscanf\s*$balanced_parens/ &&
5742		     $stat !~ /\bsscanf\s*$balanced_parens\s*(?:$Compare)/ &&
5743		     $stat !~ /(?:$Compare)\s*\bsscanf\s*$balanced_parens/)) {
5744			my $lc = $stat =~ tr@\n@@;
5745			$lc = $lc + $linenr;
5746			my $stat_real = raw_line($linenr, 0);
5747		        for (my $count = $linenr + 1; $count <= $lc; $count++) {
5748				$stat_real = $stat_real . "\n" . raw_line($count, 0);
5749			}
5750			WARN("NAKED_SSCANF",
5751			     "unchecked sscanf return value\n" . "$here\n$stat_real\n");
5752		}
5753
5754# check for simple sscanf that should be kstrto<foo>
5755		if ($^V && $^V ge 5.10.0 &&
5756		    defined $stat &&
5757		    $line =~ /\bsscanf\b/) {
5758			my $lc = $stat =~ tr@\n@@;
5759			$lc = $lc + $linenr;
5760			my $stat_real = raw_line($linenr, 0);
5761		        for (my $count = $linenr + 1; $count <= $lc; $count++) {
5762				$stat_real = $stat_real . "\n" . raw_line($count, 0);
5763			}
5764			if ($stat_real =~ /\bsscanf\b\s*\(\s*$FuncArg\s*,\s*("[^"]+")/) {
5765				my $format = $6;
5766				my $count = $format =~ tr@%@%@;
5767				if ($count == 1 &&
5768				    $format =~ /^"\%(?i:ll[udxi]|[udxi]ll|ll|[hl]h?[udxi]|[udxi][hl]h?|[hl]h?|[udxi])"$/) {
5769					WARN("SSCANF_TO_KSTRTO",
5770					     "Prefer kstrto<type> to single variable sscanf\n" . "$here\n$stat_real\n");
5771				}
5772			}
5773		}
5774
5775# check for new externs in .h files.
5776		if ($realfile =~ /\.h$/ &&
5777		    $line =~ /^\+\s*(extern\s+)$Type\s*$Ident\s*\(/s) {
5778			if (CHK("AVOID_EXTERNS",
5779				"extern prototypes should be avoided in .h files\n" . $herecurr) &&
5780			    $fix) {
5781				$fixed[$fixlinenr] =~ s/(.*)\bextern\b\s*(.*)/$1$2/;
5782			}
5783		}
5784
5785# check for new externs in .c files.
5786		if ($realfile =~ /\.c$/ && defined $stat &&
5787		    $stat =~ /^.\s*(?:extern\s+)?$Type\s+($Ident)(\s*)\(/s)
5788		{
5789			my $function_name = $1;
5790			my $paren_space = $2;
5791
5792			my $s = $stat;
5793			if (defined $cond) {
5794				substr($s, 0, length($cond), '');
5795			}
5796			if ($s =~ /^\s*;/ &&
5797			    $function_name ne 'uninitialized_var')
5798			{
5799				WARN("AVOID_EXTERNS",
5800				     "externs should be avoided in .c files\n" .  $herecurr);
5801			}
5802
5803			if ($paren_space =~ /\n/) {
5804				WARN("FUNCTION_ARGUMENTS",
5805				     "arguments for function declarations should follow identifier\n" . $herecurr);
5806			}
5807
5808		} elsif ($realfile =~ /\.c$/ && defined $stat &&
5809		    $stat =~ /^.\s*extern\s+/)
5810		{
5811			WARN("AVOID_EXTERNS",
5812			     "externs should be avoided in .c files\n" .  $herecurr);
5813		}
5814
5815		if ($realfile =~ /\.[ch]$/ && defined $stat &&
5816		    $stat =~ /^.\s*(?:extern\s+)?$Type\s*$Ident\s*\(\s*([^{]+)\s*\)\s*;/s &&
 
5817		    $1 ne "void") {
5818			my $args = trim($1);
5819			while ($args =~ m/\s*($Type\s*(?:$Ident|\(\s*\*\s*$Ident?\s*\)\s*$balanced_parens)?)/g) {
5820				my $arg = trim($1);
5821				if ($arg =~ /^$Type$/ && $arg !~ /enum\s+$Ident$/) {
5822					WARN("FUNCTION_ARGUMENTS",
5823					     "function definition argument '$arg' should also have an identifier name\n" . $herecurr);
5824				}
5825			}
5826		}
5827
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
5828# checks for new __setup's
5829		if ($rawline =~ /\b__setup\("([^"]*)"/) {
5830			my $name = $1;
5831
5832			if (!grep(/$name/, @setup_docs)) {
5833				CHK("UNDOCUMENTED_SETUP",
5834				    "__setup appears un-documented -- check Documentation/admin-guide/kernel-parameters.rst\n" . $herecurr);
5835			}
5836		}
5837
5838# check for pointless casting of kmalloc return
5839		if ($line =~ /\*\s*\)\s*[kv][czm]alloc(_node){0,1}\b/) {
5840			WARN("UNNECESSARY_CASTS",
5841			     "unnecessary cast may hide bugs, see http://c-faq.com/malloc/mallocnocast.html\n" . $herecurr);
5842		}
5843
5844# alloc style
5845# p = alloc(sizeof(struct foo), ...) should be p = alloc(sizeof(*p), ...)
5846		if ($^V && $^V ge 5.10.0 &&
5847		    $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*([kv][mz]alloc(?:_node)?)\s*\(\s*(sizeof\s*\(\s*struct\s+$Lval\s*\))/) {
5848			CHK("ALLOC_SIZEOF_STRUCT",
5849			    "Prefer $3(sizeof(*$1)...) over $3($4...)\n" . $herecurr);
5850		}
5851
5852# check for k[mz]alloc with multiplies that could be kmalloc_array/kcalloc
5853		if ($^V && $^V ge 5.10.0 &&
5854		    $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*(k[mz]alloc)\s*\(\s*($FuncArg)\s*\*\s*($FuncArg)\s*,/) {
 
5855			my $oldfunc = $3;
5856			my $a1 = $4;
5857			my $a2 = $10;
5858			my $newfunc = "kmalloc_array";
5859			$newfunc = "kcalloc" if ($oldfunc eq "kzalloc");
5860			my $r1 = $a1;
5861			my $r2 = $a2;
5862			if ($a1 =~ /^sizeof\s*\S/) {
5863				$r1 = $a2;
5864				$r2 = $a1;
5865			}
5866			if ($r1 !~ /^sizeof\b/ && $r2 =~ /^sizeof\s*\S/ &&
5867			    !($r1 =~ /^$Constant$/ || $r1 =~ /^[A-Z_][A-Z0-9_]*$/)) {
 
 
 
5868				if (WARN("ALLOC_WITH_MULTIPLY",
5869					 "Prefer $newfunc over $oldfunc with multiply\n" . $herecurr) &&
 
5870				    $fix) {
5871					$fixed[$fixlinenr] =~ s/\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*(k[mz]alloc)\s*\(\s*($FuncArg)\s*\*\s*($FuncArg)/$1 . ' = ' . "$newfunc(" . trim($r1) . ', ' . trim($r2)/e;
5872
5873				}
5874			}
5875		}
5876
5877# check for krealloc arg reuse
5878		if ($^V && $^V ge 5.10.0 &&
5879		    $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*krealloc\s*\(\s*\1\s*,/) {
5880			WARN("KREALLOC_ARG_REUSE",
5881			     "Reusing the krealloc arg is almost always a bug\n" . $herecurr);
5882		}
5883
5884# check for alloc argument mismatch
5885		if ($line =~ /\b(kcalloc|kmalloc_array)\s*\(\s*sizeof\b/) {
5886			WARN("ALLOC_ARRAY_ARGS",
5887			     "$1 uses number as first arg, sizeof is generally wrong\n" . $herecurr);
5888		}
5889
5890# check for multiple semicolons
5891		if ($line =~ /;\s*;\s*$/) {
5892			if (WARN("ONE_SEMICOLON",
5893				 "Statements terminations use 1 semicolon\n" . $herecurr) &&
5894			    $fix) {
5895				$fixed[$fixlinenr] =~ s/(\s*;\s*){2,}$/;/g;
5896			}
5897		}
5898
5899# check for #defines like: 1 << <digit> that could be BIT(digit), it is not exported to uapi
5900		if ($realfile !~ m@^include/uapi/@ &&
5901		    $line =~ /#\s*define\s+\w+\s+\(?\s*1\s*([ulUL]*)\s*\<\<\s*(?:\d+|$Ident)\s*\)?/) {
5902			my $ull = "";
5903			$ull = "_ULL" if (defined($1) && $1 =~ /ll/i);
5904			if (CHK("BIT_MACRO",
5905				"Prefer using the BIT$ull macro\n" . $herecurr) &&
5906			    $fix) {
5907				$fixed[$fixlinenr] =~ s/\(?\s*1\s*[ulUL]*\s*<<\s*(\d+|$Ident)\s*\)?/BIT${ull}($1)/;
5908			}
5909		}
5910
5911# check for #if defined CONFIG_<FOO> || defined CONFIG_<FOO>_MODULE
5912		if ($line =~ /^\+\s*#\s*if\s+defined(?:\s*\(?\s*|\s+)(CONFIG_[A-Z_]+)\s*\)?\s*\|\|\s*defined(?:\s*\(?\s*|\s+)\1_MODULE\s*\)?\s*$/) {
5913			my $config = $1;
5914			if (WARN("PREFER_IS_ENABLED",
5915				 "Prefer IS_ENABLED(<FOO>) to CONFIG_<FOO> || CONFIG_<FOO>_MODULE\n" . $herecurr) &&
5916			    $fix) {
5917				$fixed[$fixlinenr] = "\+#if IS_ENABLED($config)";
5918			}
5919		}
5920
5921# check for case / default statements not preceded by break/fallthrough/switch
5922		if ($line =~ /^.\s*(?:case\s+(?:$Ident|$Constant)\s*|default):/) {
5923			my $has_break = 0;
5924			my $has_statement = 0;
5925			my $count = 0;
5926			my $prevline = $linenr;
5927			while ($prevline > 1 && ($file || $count < 3) && !$has_break) {
5928				$prevline--;
5929				my $rline = $rawlines[$prevline - 1];
5930				my $fline = $lines[$prevline - 1];
5931				last if ($fline =~ /^\@\@/);
5932				next if ($fline =~ /^\-/);
5933				next if ($fline =~ /^.(?:\s*(?:case\s+(?:$Ident|$Constant)[\s$;]*|default):[\s$;]*)*$/);
5934				$has_break = 1 if ($rline =~ /fall[\s_-]*(through|thru)/i);
5935				next if ($fline =~ /^.[\s$;]*$/);
5936				$has_statement = 1;
5937				$count++;
5938				$has_break = 1 if ($fline =~ /\bswitch\b|\b(?:break\s*;[\s$;]*$|return\b|goto\b|continue\b)/);
5939			}
5940			if (!$has_break && $has_statement) {
5941				WARN("MISSING_BREAK",
5942				     "Possible switch case/default not preceded by break or fallthrough comment\n" . $herecurr);
5943			}
5944		}
5945
5946# check for switch/default statements without a break;
5947		if ($^V && $^V ge 5.10.0 &&
5948		    defined $stat &&
5949		    $stat =~ /^\+[$;\s]*(?:case[$;\s]+\w+[$;\s]*:[$;\s]*|)*[$;\s]*\bdefault[$;\s]*:[$;\s]*;/g) {
5950			my $ctx = '';
5951			my $herectx = $here . "\n";
5952			my $cnt = statement_rawlines($stat);
5953			for (my $n = 0; $n < $cnt; $n++) {
5954				$herectx .= raw_line($linenr, $n) . "\n";
5955			}
5956			WARN("DEFAULT_NO_BREAK",
5957			     "switch default: should use break\n" . $herectx);
5958		}
5959
5960# check for gcc specific __FUNCTION__
5961		if ($line =~ /\b__FUNCTION__\b/) {
5962			if (WARN("USE_FUNC",
5963				 "__func__ should be used instead of gcc specific __FUNCTION__\n"  . $herecurr) &&
5964			    $fix) {
5965				$fixed[$fixlinenr] =~ s/\b__FUNCTION__\b/__func__/g;
5966			}
5967		}
5968
5969# check for uses of __DATE__, __TIME__, __TIMESTAMP__
5970		while ($line =~ /\b(__(?:DATE|TIME|TIMESTAMP)__)\b/g) {
5971			ERROR("DATE_TIME",
5972			      "Use of the '$1' macro makes the build non-deterministic\n" . $herecurr);
5973		}
5974
5975# check for use of yield()
5976		if ($line =~ /\byield\s*\(\s*\)/) {
5977			WARN("YIELD",
5978			     "Using yield() is generally wrong. See yield() kernel-doc (sched/core.c)\n"  . $herecurr);
5979		}
5980
5981# check for comparisons against true and false
5982		if ($line =~ /\+\s*(.*?)\b(true|false|$Lval)\s*(==|\!=)\s*(true|false|$Lval)\b(.*)$/i) {
5983			my $lead = $1;
5984			my $arg = $2;
5985			my $test = $3;
5986			my $otype = $4;
5987			my $trail = $5;
5988			my $op = "!";
5989
5990			($arg, $otype) = ($otype, $arg) if ($arg =~ /^(?:true|false)$/i);
5991
5992			my $type = lc($otype);
5993			if ($type =~ /^(?:true|false)$/) {
5994				if (("$test" eq "==" && "$type" eq "true") ||
5995				    ("$test" eq "!=" && "$type" eq "false")) {
5996					$op = "";
5997				}
5998
5999				CHK("BOOL_COMPARISON",
6000				    "Using comparison to $otype is error prone\n" . $herecurr);
6001
6002## maybe suggesting a correct construct would better
6003##				    "Using comparison to $otype is error prone.  Perhaps use '${lead}${op}${arg}${trail}'\n" . $herecurr);
6004
6005			}
6006		}
6007
 
 
 
 
 
 
6008# check for semaphores initialized locked
6009		if ($line =~ /^.\s*sema_init.+,\W?0\W?\)/) {
6010			WARN("CONSIDER_COMPLETION",
6011			     "consider using a completion\n" . $herecurr);
6012		}
6013
6014# recommend kstrto* over simple_strto* and strict_strto*
6015		if ($line =~ /\b((simple|strict)_(strto(l|ll|ul|ull)))\s*\(/) {
6016			WARN("CONSIDER_KSTRTO",
6017			     "$1 is obsolete, use k$3 instead\n" . $herecurr);
6018		}
6019
6020# check for __initcall(), use device_initcall() explicitly or more appropriate function please
6021		if ($line =~ /^.\s*__initcall\s*\(/) {
6022			WARN("USE_DEVICE_INITCALL",
6023			     "please use device_initcall() or more appropriate function instead of __initcall() (see include/linux/init.h)\n" . $herecurr);
6024		}
6025
6026# check for various structs that are normally const (ops, kgdb, device_tree)
 
6027		if ($line !~ /\bconst\b/ &&
6028		    $line =~ /\bstruct\s+($const_structs)\b/) {
6029			WARN("CONST_STRUCT",
6030			     "struct $1 should normally be const\n" .
6031				$herecurr);
6032		}
6033
6034# use of NR_CPUS is usually wrong
6035# ignore definitions of NR_CPUS and usage to define arrays as likely right
6036		if ($line =~ /\bNR_CPUS\b/ &&
6037		    $line !~ /^.\s*\s*#\s*if\b.*\bNR_CPUS\b/ &&
6038		    $line !~ /^.\s*\s*#\s*define\b.*\bNR_CPUS\b/ &&
6039		    $line !~ /^.\s*$Declare\s.*\[[^\]]*NR_CPUS[^\]]*\]/ &&
6040		    $line !~ /\[[^\]]*\.\.\.[^\]]*NR_CPUS[^\]]*\]/ &&
6041		    $line !~ /\[[^\]]*NR_CPUS[^\]]*\.\.\.[^\]]*\]/)
6042		{
6043			WARN("NR_CPUS",
6044			     "usage of NR_CPUS is often wrong - consider using cpu_possible(), num_possible_cpus(), for_each_possible_cpu(), etc\n" . $herecurr);
6045		}
6046
6047# Use of __ARCH_HAS_<FOO> or ARCH_HAVE_<BAR> is wrong.
6048		if ($line =~ /\+\s*#\s*define\s+((?:__)?ARCH_(?:HAS|HAVE)\w*)\b/) {
6049			ERROR("DEFINE_ARCH_HAS",
6050			      "#define of '$1' is wrong - use Kconfig variables or standard guards instead\n" . $herecurr);
6051		}
6052
6053# likely/unlikely comparisons similar to "(likely(foo) > 0)"
6054		if ($^V && $^V ge 5.10.0 &&
6055		    $line =~ /\b((?:un)?likely)\s*\(\s*$FuncArg\s*\)\s*$Compare/) {
6056			WARN("LIKELY_MISUSE",
6057			     "Using $1 should generally have parentheses around the comparison\n" . $herecurr);
6058		}
6059
6060# whine mightly about in_atomic
6061		if ($line =~ /\bin_atomic\s*\(/) {
6062			if ($realfile =~ m@^drivers/@) {
6063				ERROR("IN_ATOMIC",
6064				      "do not use in_atomic in drivers\n" . $herecurr);
6065			} elsif ($realfile !~ m@^kernel/@) {
6066				WARN("IN_ATOMIC",
6067				     "use of in_atomic() is incorrect outside core kernel code\n" . $herecurr);
6068			}
6069		}
6070
6071# whine about ACCESS_ONCE
6072		if ($^V && $^V ge 5.10.0 &&
6073		    $line =~ /\bACCESS_ONCE\s*$balanced_parens\s*(=(?!=))?\s*($FuncArg)?/) {
6074			my $par = $1;
6075			my $eq = $2;
6076			my $fun = $3;
6077			$par =~ s/^\(\s*(.*)\s*\)$/$1/;
6078			if (defined($eq)) {
6079				if (WARN("PREFER_WRITE_ONCE",
6080					 "Prefer WRITE_ONCE(<FOO>, <BAR>) over ACCESS_ONCE(<FOO>) = <BAR>\n" . $herecurr) &&
6081				    $fix) {
6082					$fixed[$fixlinenr] =~ s/\bACCESS_ONCE\s*\(\s*\Q$par\E\s*\)\s*$eq\s*\Q$fun\E/WRITE_ONCE($par, $fun)/;
6083				}
6084			} else {
6085				if (WARN("PREFER_READ_ONCE",
6086					 "Prefer READ_ONCE(<FOO>) over ACCESS_ONCE(<FOO>)\n" . $herecurr) &&
6087				    $fix) {
6088					$fixed[$fixlinenr] =~ s/\bACCESS_ONCE\s*\(\s*\Q$par\E\s*\)/READ_ONCE($par)/;
6089				}
6090			}
6091		}
6092
6093# check for mutex_trylock_recursive usage
6094		if ($line =~ /mutex_trylock_recursive/) {
6095			ERROR("LOCKING",
6096			      "recursive locking is bad, do not use this ever.\n" . $herecurr);
6097		}
6098
6099# check for lockdep_set_novalidate_class
6100		if ($line =~ /^.\s*lockdep_set_novalidate_class\s*\(/ ||
6101		    $line =~ /__lockdep_no_validate__\s*\)/ ) {
6102			if ($realfile !~ m@^kernel/lockdep@ &&
6103			    $realfile !~ m@^include/linux/lockdep@ &&
6104			    $realfile !~ m@^drivers/base/core@) {
6105				ERROR("LOCKDEP",
6106				      "lockdep_no_validate class is reserved for device->mutex.\n" . $herecurr);
6107			}
6108		}
6109
6110		if ($line =~ /debugfs_create_\w+.*\b$mode_perms_world_writable\b/ ||
6111		    $line =~ /DEVICE_ATTR.*\b$mode_perms_world_writable\b/) {
6112			WARN("EXPORTED_WORLD_WRITABLE",
6113			     "Exporting world writable files is usually an error. Consider more restrictive permissions.\n" . $herecurr);
6114		}
6115
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
6116# Mode permission misuses where it seems decimal should be octal
6117# This uses a shortcut match to avoid unnecessary uses of a slow foreach loop
 
 
 
 
6118		if ($^V && $^V ge 5.10.0 &&
6119		    defined $stat &&
6120		    $line =~ /$mode_perms_search/) {
6121			foreach my $entry (@mode_permission_funcs) {
6122				my $func = $entry->[0];
6123				my $arg_pos = $entry->[1];
6124
6125				my $lc = $stat =~ tr@\n@@;
6126				$lc = $lc + $linenr;
6127				my $stat_real = raw_line($linenr, 0);
6128				for (my $count = $linenr + 1; $count <= $lc; $count++) {
6129					$stat_real = $stat_real . "\n" . raw_line($count, 0);
6130				}
6131
6132				my $skip_args = "";
6133				if ($arg_pos > 1) {
6134					$arg_pos--;
6135					$skip_args = "(?:\\s*$FuncArg\\s*,\\s*){$arg_pos,$arg_pos}";
6136				}
6137				my $test = "\\b$func\\s*\\(${skip_args}($FuncArg(?:\\|\\s*$FuncArg)*)\\s*[,\\)]";
6138				if ($stat =~ /$test/) {
6139					my $val = $1;
6140					$val = $6 if ($skip_args ne "");
6141					if (($val =~ /^$Int$/ && $val !~ /^$Octal$/) ||
6142					    ($val =~ /^$Octal$/ && length($val) ne 4)) {
 
6143						ERROR("NON_OCTAL_PERMISSIONS",
6144						      "Use 4 digit octal (0777) not decimal permissions\n" . "$here\n" . $stat_real);
6145					}
6146					if ($val =~ /^$Octal$/ && (oct($val) & 02)) {
6147						ERROR("EXPORTED_WORLD_WRITABLE",
6148						      "Exporting writable files is usually an error. Consider more restrictive permissions.\n" . "$here\n" . $stat_real);
6149					}
6150				}
6151			}
6152		}
6153
6154# check for uses of S_<PERMS> that could be octal for readability
6155		if ($line =~ /\b$mode_perms_string_search\b/) {
6156			my $val = "";
6157			my $oval = "";
6158			my $to = 0;
6159			my $curpos = 0;
6160			my $lastpos = 0;
6161			while ($line =~ /\b(($mode_perms_string_search)\b(?:\s*\|\s*)?\s*)/g) {
6162				$curpos = pos($line);
6163				my $match = $2;
6164				my $omatch = $1;
6165				last if ($lastpos > 0 && ($curpos - length($omatch) != $lastpos));
6166				$lastpos = $curpos;
6167				$to |= $mode_permission_string_types{$match};
6168				$val .= '\s*\|\s*' if ($val ne "");
6169				$val .= $match;
6170				$oval .= $omatch;
6171			}
6172			$oval =~ s/^\s*\|\s*//;
6173			$oval =~ s/\s*\|\s*$//;
6174			my $octal = sprintf("%04o", $to);
6175			if (WARN("SYMBOLIC_PERMS",
6176				 "Symbolic permissions '$oval' are not preferred. Consider using octal permissions '$octal'.\n" . $herecurr) &&
6177			    $fix) {
6178				$fixed[$fixlinenr] =~ s/$val/$octal/;
6179			}
6180		}
6181
6182# validate content of MODULE_LICENSE against list from include/linux/module.h
6183		if ($line =~ /\bMODULE_LICENSE\s*\(\s*($String)\s*\)/) {
6184			my $extracted_string = get_quoted_string($line, $rawline);
6185			my $valid_licenses = qr{
6186						GPL|
6187						GPL\ v2|
6188						GPL\ and\ additional\ rights|
6189						Dual\ BSD/GPL|
6190						Dual\ MIT/GPL|
6191						Dual\ MPL/GPL|
6192						Proprietary
6193					}x;
6194			if ($extracted_string !~ /^"(?:$valid_licenses)"$/x) {
6195				WARN("MODULE_LICENSE",
6196				     "unknown module license " . $extracted_string . "\n" . $herecurr);
6197			}
6198		}
6199	}
6200
6201	# If we have no input at all, then there is nothing to report on
6202	# so just keep quiet.
6203	if ($#rawlines == -1) {
6204		exit(0);
6205	}
6206
6207	# In mailback mode only produce a report in the negative, for
6208	# things that appear to be patches.
6209	if ($mailback && ($clean == 1 || !$is_patch)) {
6210		exit(0);
6211	}
6212
6213	# This is not a patch, and we are are in 'no-patch' mode so
6214	# just keep quiet.
6215	if (!$chk_patch && !$is_patch) {
6216		exit(0);
6217	}
6218
6219	if (!$is_patch && $file !~ /cover-letter\.patch$/) {
6220		ERROR("NOT_UNIFIED_DIFF",
6221		      "Does not appear to be a unified-diff format patch\n");
6222	}
6223	if ($is_patch && $has_commit_log && $chk_signoff && $signoff == 0) {
6224		ERROR("MISSING_SIGN_OFF",
6225		      "Missing Signed-off-by: line(s)\n");
6226	}
6227
6228	print report_dump();
6229	if ($summary && !($clean == 1 && $quiet == 1)) {
6230		print "$filename " if ($summary_file);
6231		print "total: $cnt_error errors, $cnt_warn warnings, " .
6232			(($check)? "$cnt_chk checks, " : "") .
6233			"$cnt_lines lines checked\n";
6234	}
6235
6236	if ($quiet == 0) {
6237		# If there were any defects found and not already fixing them
6238		if (!$clean and !$fix) {
6239			print << "EOM"
6240
6241NOTE: For some of the reported defects, checkpatch may be able to
6242      mechanically convert to the typical style using --fix or --fix-inplace.
6243EOM
6244		}
6245		# If there were whitespace errors which cleanpatch can fix
6246		# then suggest that.
6247		if ($rpt_cleaners) {
6248			$rpt_cleaners = 0;
6249			print << "EOM"
6250
6251NOTE: Whitespace errors detected.
6252      You may wish to use scripts/cleanpatch or scripts/cleanfile
6253EOM
6254		}
6255	}
6256
6257	if ($clean == 0 && $fix &&
6258	    ("@rawlines" ne "@fixed" ||
6259	     $#fixed_inserted >= 0 || $#fixed_deleted >= 0)) {
6260		my $newfile = $filename;
6261		$newfile .= ".EXPERIMENTAL-checkpatch-fixes" if (!$fix_inplace);
6262		my $linecount = 0;
6263		my $f;
6264
6265		@fixed = fix_inserted_deleted_lines(\@fixed, \@fixed_inserted, \@fixed_deleted);
6266
6267		open($f, '>', $newfile)
6268		    or die "$P: Can't open $newfile for write\n";
6269		foreach my $fixed_line (@fixed) {
6270			$linecount++;
6271			if ($file) {
6272				if ($linecount > 3) {
6273					$fixed_line =~ s/^\+//;
6274					print $f $fixed_line . "\n";
6275				}
6276			} else {
6277				print $f $fixed_line . "\n";
6278			}
6279		}
6280		close($f);
6281
6282		if (!$quiet) {
6283			print << "EOM";
6284
6285Wrote EXPERIMENTAL --fix correction(s) to '$newfile'
6286
6287Do _NOT_ trust the results written to this file.
6288Do _NOT_ submit these changes without inspecting them for correctness.
6289
6290This EXPERIMENTAL file is simply a convenience to help rewrite patches.
6291No warranties, expressed or implied...
6292EOM
6293		}
6294	}
6295
6296	if ($quiet == 0) {
6297		print "\n";
6298		if ($clean == 1) {
6299			print "$vname has no obvious style problems and is ready for submission.\n";
6300		} else {
6301			print "$vname has style problems, please review.\n";
6302		}
6303	}
6304	return $clean;
6305}