Version:  2.0.40 2.2.26 2.4.37 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2 4.3 4.4 4.5 4.6 4.7 4.8 4.9 4.10

Linux/scripts/checkpatch.pl

  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 
  8 use strict;
  9 use POSIX;
 10 use File::Basename;
 11 use Cwd 'abs_path';
 12 use Term::ANSIColor qw(:constants);
 13 
 14 my $P = $0;
 15 my $D = dirname(abs_path($P));
 16 
 17 my $V = '0.32';
 18 
 19 use Getopt::Long qw(:config no_auto_abbrev);
 20 
 21 my $quiet = 0;
 22 my $tree = 1;
 23 my $chk_signoff = 1;
 24 my $chk_patch = 1;
 25 my $tst_only;
 26 my $emacs = 0;
 27 my $terse = 0;
 28 my $showfile = 0;
 29 my $file = 0;
 30 my $git = 0;
 31 my %git_commits = ();
 32 my $check = 0;
 33 my $check_orig = 0;
 34 my $summary = 1;
 35 my $mailback = 0;
 36 my $summary_file = 0;
 37 my $show_types = 0;
 38 my $list_types = 0;
 39 my $fix = 0;
 40 my $fix_inplace = 0;
 41 my $root;
 42 my %debug;
 43 my %camelcase = ();
 44 my %use_type = ();
 45 my @use = ();
 46 my %ignore_type = ();
 47 my @ignore = ();
 48 my $help = 0;
 49 my $configuration_file = ".checkpatch.conf";
 50 my $max_line_length = 80;
 51 my $ignore_perl_version = 0;
 52 my $minimum_perl_version = 5.10.0;
 53 my $min_conf_desc_length = 4;
 54 my $spelling_file = "$D/spelling.txt";
 55 my $codespell = 0;
 56 my $codespellfile = "/usr/share/codespell/dictionary.txt";
 57 my $conststructsfile = "$D/const_structs.checkpatch";
 58 my $color = 1;
 59 my $allow_c99_comments = 1;
 60 
 61 sub help {
 62         my ($exitcode) = @_;
 63 
 64         print << "EOM";
 65 Usage: $P [OPTION]... [FILE]...
 66 Version: $V
 67 
 68 Options:
 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 
119 When FILE is - read standard input.
120 EOM
121 
122         exit($exitcode);
123 }
124 
125 sub uniq {
126         my %seen;
127         return grep { !$seen{$_}++ } @_;
128 }
129 
130 sub 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 
156 my $conf = which_conf($configuration_file);
157 if (-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 
182 GetOptions(
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 
216 help(0) if ($help);
217 
218 list_types(0) if ($list_types);
219 
220 $fix = 1 if ($fix_inplace);
221 $check_orig = $check;
222 
223 my $exit = 0;
224 
225 if ($^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
233 if ($#ARGV < 0) {
234         push(@ARGV, '-');
235 }
236 
237 sub 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 
254 sub 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 
266 hash_save_array_words(\%ignore_type, \@ignore);
267 hash_save_array_words(\%use_type, \@use);
268 
269 my $dbg_values = 0;
270 my $dbg_possible = 0;
271 my $dbg_type = 0;
272 my $dbg_attr = 0;
273 for my $key (keys %debug) {
274         ## no critic
275         eval "\${dbg_$key} = '$debug{$key}';";
276         die "$@" if ($@);
277 }
278 
279 my $rpt_cleaners = 0;
280 
281 if ($terse) {
282         $emacs = 1;
283         $quiet++;
284 }
285 
286 if ($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 
306 my $emitted_corrupt = 0;
307 
308 our $Ident      = qr{
309                         [A-Za-z_][A-Za-z\d_]*
310                         (?:\s*\#\#\s*[A-Za-z_][A-Za-z\d_]*)*
311                 }x;
312 our $Storage    = qr{extern|static|asmlinkage};
313 our $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;
325 our $InitAttributePrefix = qr{__(?:mem|cpu|dev|net_|)};
326 our $InitAttributeData = qr{$InitAttributePrefix(?:initdata\b)};
327 our $InitAttributeConst = qr{$InitAttributePrefix(?:initconst\b)};
328 our $InitAttributeInit = qr{$InitAttributePrefix(?:init\b)};
329 our $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
333 our $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;
358 our $Modifier;
359 our $Inline     = qr{inline|__always_inline|noinline|__inline|__inline__};
360 our $Member     = qr{->$Ident|\.$Ident|\[[^]]*\]};
361 our $Lval       = qr{$Ident(?:$Member)*};
362 
363 our $Int_type   = qr{(?i)llu|ull|ll|lu|ul|l|u};
364 our $Binary     = qr{(?i)0b[01]+$Int_type?};
365 our $Hex        = qr{(?i)0x[0-9a-f]+$Int_type?};
366 our $Int        = qr{[0-9]+$Int_type?};
367 our $Octal      = qr{0[0-7]+$Int_type?};
368 our $String     = qr{"[X\t]*"};
369 our $Float_hex  = qr{(?i)0x[0-9a-f]+p-?[0-9]+[fl]?};
370 our $Float_dec  = qr{(?i)(?:[0-9]+\.[0-9]*|[0-9]*\.[0-9]+)(?:e-?[0-9]+)?[fl]?};
371 our $Float_int  = qr{(?i)[0-9]+e-?[0-9]+[fl]?};
372 our $Float      = qr{$Float_hex|$Float_dec|$Float_int};
373 our $Constant   = qr{$Float|$Binary|$Octal|$Hex|$Int};
374 our $Assignment = qr{\*\=|/=|%=|\+=|-=|<<=|>>=|&=|\^=|\|=|=};
375 our $Compare    = qr{<=|>=|==|!=|<|(?<!-)>};
376 our $Arithmetic = qr{\+|-|\*|\/|%};
377 our $Operators  = qr{
378                         <=|>=|==|!=|
379                         =>|->|<<|>>|<|>|!|~|
380                         &&|\|\||,|\^|\+\+|--|&|\||$Arithmetic
381                   }x;
382 
383 our $c90_Keywords = qr{do|for|while|if|else|return|goto|continue|switch|default|case|break}x;
384 
385 our $BasicType;
386 our $NonptrType;
387 our $NonptrTypeMisordered;
388 our $NonptrTypeWithAttr;
389 our $Type;
390 our $TypeMisordered;
391 our $Declare;
392 our $DeclareMisordered;
393 
394 our $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 
404 our $UTF8       = qr{
405         [\x09\x0A\x0D\x20-\x7E]              # ASCII
406         | $NON_ASCII_UTF8
407 }x;
408 
409 our $typeC99Typedefs = qr{(?:__)?(?:[us]_?)?int_?(?:8|16|32|64)_t};
410 our $typeOtherOSTypedefs = qr{(?x:
411         u_(?:char|short|int|long) |          # bsd
412         u(?:nchar|short|int|long)            # sysv
413 )};
414 our $typeKernelTypedefs = qr{(?x:
415         (?:__)?(?:u|s|be|le)(?:8|16|32|64)|
416         atomic_t
417 )};
418 our $typeTypedefs = qr{(?x:
419         $typeC99Typedefs\b|
420         $typeOtherOSTypedefs\b|
421         $typeKernelTypedefs\b
422 )};
423 
424 our $zero_initializer = qr{(?:(?:0[xX])?0+$Int_type?|NULL|false)\b};
425 
426 our $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 
435 our $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 
446 our @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 
465 our @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 
488 our $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 
509 our @typeListFile = ();
510 our @typeListWithAttr = (
511         @typeList,
512         qr{struct\s+$InitAttribute\s+$Ident},
513         qr{union\s+$InitAttribute\s+$Ident},
514 );
515 
516 our @modifierList = (
517         qr{fastcall},
518 );
519 our @modifierListFile = ();
520 
521 our @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
535 our $mode_perms_search = "";
536 foreach my $entry (@mode_permission_funcs) {
537         $mode_perms_search .= '|' if ($mode_perms_search ne "");
538         $mode_perms_search .= $entry->[0];
539 }
540 
541 our $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 
549 our %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
569 our $mode_perms_string_search = "";
570 foreach 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 
575 our $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.
584 my $misspellings;
585 my %spelling_fix;
586 
587 if (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 
606 if ($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 
632 my $const_structs = "";
633 if (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 
655 sub 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 }
703 build_types();
704 
705 our $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 
711 our $balanced_parens = qr/(\((?:[^\(\)]++|(?-1))*\))/;
712 our $LvalOrFunc = qr{((?:[\&\*]\s*)?$Lval)\s*($balanced_parens{0,1})\s*};
713 our $FuncArg = qr{$Typecast{0,1}($LvalOrFunc|$Constant|$String)};
714 
715 our $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 
721 sub 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 
735 sub 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 
761 sub 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 
771 my $camelcase_seeded = 0;
772 sub 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 
829 sub 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 
861 my @rawlines = ();
862 my @lines = ();
863 my @fixed = ();
864 my @fixed_inserted = ();
865 my @fixed_deleted = ();
866 my $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'.
870 die "$P: No git repository found\n" if ($git && !-e ".git");
871 
872 if ($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 
897 my $vname;
898 for 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 
945 if (!$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 
952 NOTE: perl $^V is not modern enough to detect all possible issues.
953       An upgrade to at least perl v5.10.0 is suggested.
954 EOM
955         }
956         if ($exit) {
957                 print << "EOM"
958 
959 NOTE: If any of the errors are false positives, please report
960       them to the maintainer, see CHECKPATCH in MAINTAINERS.
961 EOM
962         }
963 }
964 
965 exit($exit);
966 
967 sub 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 
984 sub 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 
1031 sub 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 
1054 sub 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 
1066 sub 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 
1078 sub 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 }
1098 sub copy_spacing {
1099         (my $res = shift) =~ tr/\t/ /c;
1100         return $res;
1101 }
1102 
1103 sub 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 
1116 my $sanitise_quote = '';
1117 
1118 sub sanitise_line_reset {
1119         my ($in_comment) = @_;
1120 
1121         if ($in_comment) {
1122                 $sanitise_quote = '*/';
1123         } else {
1124                 $sanitise_quote = '';
1125         }
1126 }
1127 sub 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 
1220 sub get_quoted_string {
1221         my ($line, $rawline) = @_;
1222 
1223         return "" if ($line !~ m/($String)/g);
1224         return substr($rawline, $-[0], $+[0] - $-[0]);
1225 }
1226 
1227 sub 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 
1361 sub 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 
1374 sub statement_rawlines {
1375         my ($stmt) = @_;
1376 
1377         my @stmt_lines = ($stmt =~ /\n/g);
1378 
1379         return $#stmt_lines + 2;
1380 }
1381 
1382 sub 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 
1404 sub 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 
1433 sub 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 }
1483 sub ctx_block_outer {
1484         my ($linenr, $remain) = @_;
1485 
1486         my ($level, @r) = ctx_block_get($linenr, $remain, 1, '{', '}', 0);
1487         return @r;
1488 }
1489 sub ctx_block {
1490         my ($linenr, $remain) = @_;
1491 
1492         my ($level, @r) = ctx_block_get($linenr, $remain, 0, '{', '}', 0);
1493         return @r;
1494 }
1495 sub ctx_statement {
1496         my ($linenr, $remain, $off) = @_;
1497 
1498         my ($level, @r) = ctx_block_get($linenr, $remain, 0, '(', ')', $off);
1499         return @r;
1500 }
1501 sub ctx_block_level {
1502         my ($linenr, $remain) = @_;
1503 
1504         return ctx_block_get($linenr, $remain, 0, '{', '}', 0);
1505 }
1506 sub ctx_statement_level {
1507         my ($linenr, $remain, $off) = @_;
1508 
1509         return ctx_block_get($linenr, $remain, 0, '(', ')', $off);
1510 }
1511 
1512 sub 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 }
1544 sub 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 
1554 sub 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 
1570 sub 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 
1587 my $av_preprocessor = 0;
1588 my $av_pending;
1589 my @av_paren_type;
1590 my $av_pend_colon;
1591 
1592 sub annotate_reset {
1593         $av_preprocessor = 0;
1594         $av_pending = '_';
1595         @av_paren_type = ('E');
1596         $av_pend_colon = 'O';
1597 }
1598 
1599 sub 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 
1799 sub 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 
1846 my $prefix = '';
1847 
1848 sub 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 
1856 sub 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 
1893 sub report_dump {
1894         our @report;
1895 }
1896 
1897 sub 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 
1909 sub 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 
1960 sub 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 
1970 sub 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 
1981 sub 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 }
1991 sub 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 }
2001 sub 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 
2012 sub 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 
2040 sub trim {
2041         my ($string) = @_;
2042 
2043         $string =~ s/^\s+|\s+$//g;
2044 
2045         return $string;
2046 }
2047 
2048 sub ltrim {
2049         my ($string) = @_;
2050 
2051         $string =~ s/^\s+//;
2052 
2053         return $string;
2054 }
2055 
2056 sub rtrim {
2057         my ($string) = @_;
2058 
2059         $string =~ s/\s+$//;
2060 
2061         return $string;
2062 }
2063 
2064 sub string_find_replace {
2065         my ($string, $find, $replace) = @_;
2066 
2067         $string =~ s/$find/$replace/g;
2068 
2069         return $string;
2070 }
2071 
2072 sub 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 
2087 sub 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 
2117 sub 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 
6241 NOTE: For some of the reported defects, checkpatch may be able to
6242       mechanically convert to the typical style using --fix or --fix-inplace.
6243 EOM
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 
6251 NOTE: Whitespace errors detected.
6252       You may wish to use scripts/cleanpatch or scripts/cleanfile
6253 EOM
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 
6285 Wrote EXPERIMENTAL --fix correction(s) to '$newfile'
6286 
6287 Do _NOT_ trust the results written to this file.
6288 Do _NOT_ submit these changes without inspecting them for correctness.
6289 
6290 This EXPERIMENTAL file is simply a convenience to help rewrite patches.
6291 No warranties, expressed or implied...
6292 EOM
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 }

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us