Add checkpatch.pl
[akaros.git] / 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 $check = 0;
31 my $check_orig = 0;
32 my $summary = 1;
33 my $mailback = 0;
34 my $summary_file = 0;
35 my $show_types = 0;
36 my $fix = 0;
37 my $fix_inplace = 0;
38 my $root;
39 my %debug;
40 my %camelcase = ();
41 my %use_type = ();
42 my @use = ();
43 my %ignore_type = ();
44 my @ignore = ();
45 my $help = 0;
46 my $configuration_file = ".checkpatch.conf";
47 my $max_line_length = 80;
48 my $ignore_perl_version = 0;
49 my $minimum_perl_version = 5.10.0;
50 my $min_conf_desc_length = 4;
51 my $spelling_file = "$D/spelling.txt";
52 my $codespell = 0;
53 my $codespellfile = "/usr/share/codespell/dictionary.txt";
54 my $color = 1;
55
56 sub help {
57         my ($exitcode) = @_;
58
59         print << "EOM";
60 Usage: $P [OPTION]... [FILE]...
61 Version: $V
62
63 Options:
64   -q, --quiet                quiet
65   --no-tree                  run without a kernel tree
66   --no-signoff               do not check for 'Signed-off-by' line
67   --patch                    treat FILE as patchfile (default)
68   --emacs                    emacs compile window format
69   --terse                    one line per report
70   --showfile                 emit diffed file position, not input file position
71   -f, --file                 treat FILE as regular source file
72   --subjective, --strict     enable more subjective tests
73   --types TYPE(,TYPE2...)    show only these comma separated message types
74   --ignore TYPE(,TYPE2...)   ignore various comma separated message types
75   --max-line-length=n        set the maximum line length, if exceeded, warn
76   --min-conf-desc-length=n   set the min description length, if shorter, warn
77   --show-types               show the message "types" in the output
78   --root=PATH                PATH to the kernel tree root
79   --no-summary               suppress the per-file summary
80   --mailback                 only produce a report in case of warnings/errors
81   --summary-file             include the filename in summary
82   --debug KEY=[0|1]          turn on/off debugging of KEY, where KEY is one of
83                              'values', 'possible', 'type', and 'attr' (default
84                              is all off)
85   --test-only=WORD           report only warnings/errors containing WORD
86                              literally
87   --fix                      EXPERIMENTAL - may create horrible results
88                              If correctable single-line errors exist, create
89                              "<inputfile>.EXPERIMENTAL-checkpatch-fixes"
90                              with potential errors corrected to the preferred
91                              checkpatch style
92   --fix-inplace              EXPERIMENTAL - may create horrible results
93                              Is the same as --fix, but overwrites the input
94                              file.  It's your fault if there's no backup or git
95   --ignore-perl-version      override checking of perl version.  expect
96                              runtime errors.
97   --codespell                Use the codespell dictionary for spelling/typos
98                              (default:/usr/share/codespell/dictionary.txt)
99   --codespellfile            Use this codespell dictionary
100   --color                    Use colors when output is STDOUT (default: on)
101   -h, --help, --version      display this help and exit
102
103 When FILE is - read standard input.
104 EOM
105
106         exit($exitcode);
107 }
108
109 my $conf = which_conf($configuration_file);
110 if (-f $conf) {
111         my @conf_args;
112         open(my $conffile, '<', "$conf")
113             or warn "$P: Can't find a readable $configuration_file file $!\n";
114
115         while (<$conffile>) {
116                 my $line = $_;
117
118                 $line =~ s/\s*\n?$//g;
119                 $line =~ s/^\s*//g;
120                 $line =~ s/\s+/ /g;
121
122                 next if ($line =~ m/^\s*#/);
123                 next if ($line =~ m/^\s*$/);
124
125                 my @words = split(" ", $line);
126                 foreach my $word (@words) {
127                         last if ($word =~ m/^#/);
128                         push (@conf_args, $word);
129                 }
130         }
131         close($conffile);
132         unshift(@ARGV, @conf_args) if @conf_args;
133 }
134
135 GetOptions(
136         'q|quiet+'      => \$quiet,
137         'tree!'         => \$tree,
138         'signoff!'      => \$chk_signoff,
139         'patch!'        => \$chk_patch,
140         'emacs!'        => \$emacs,
141         'terse!'        => \$terse,
142         'showfile!'     => \$showfile,
143         'f|file!'       => \$file,
144         'subjective!'   => \$check,
145         'strict!'       => \$check,
146         'ignore=s'      => \@ignore,
147         'types=s'       => \@use,
148         'show-types!'   => \$show_types,
149         'max-line-length=i' => \$max_line_length,
150         'min-conf-desc-length=i' => \$min_conf_desc_length,
151         'root=s'        => \$root,
152         'summary!'      => \$summary,
153         'mailback!'     => \$mailback,
154         'summary-file!' => \$summary_file,
155         'fix!'          => \$fix,
156         'fix-inplace!'  => \$fix_inplace,
157         'ignore-perl-version!' => \$ignore_perl_version,
158         'debug=s'       => \%debug,
159         'test-only=s'   => \$tst_only,
160         'codespell!'    => \$codespell,
161         'codespellfile=s'       => \$codespellfile,
162         'color!'        => \$color,
163         'h|help'        => \$help,
164         'version'       => \$help
165 ) or help(1);
166
167 help(0) if ($help);
168
169 $fix = 1 if ($fix_inplace);
170 $check_orig = $check;
171
172 my $exit = 0;
173
174 if ($^V && $^V lt $minimum_perl_version) {
175         printf "$P: requires at least perl version %vd\n", $minimum_perl_version;
176         if (!$ignore_perl_version) {
177                 exit(1);
178         }
179 }
180
181 if ($#ARGV < 0) {
182         print "$P: no input files\n";
183         exit(1);
184 }
185
186 sub hash_save_array_words {
187         my ($hashRef, $arrayRef) = @_;
188
189         my @array = split(/,/, join(',', @$arrayRef));
190         foreach my $word (@array) {
191                 $word =~ s/\s*\n?$//g;
192                 $word =~ s/^\s*//g;
193                 $word =~ s/\s+/ /g;
194                 $word =~ tr/[a-z]/[A-Z]/;
195
196                 next if ($word =~ m/^\s*#/);
197                 next if ($word =~ m/^\s*$/);
198
199                 $hashRef->{$word}++;
200         }
201 }
202
203 sub hash_show_words {
204         my ($hashRef, $prefix) = @_;
205
206         if (keys %$hashRef) {
207                 print "\nNOTE: $prefix message types:";
208                 foreach my $word (sort keys %$hashRef) {
209                         print " $word";
210                 }
211                 print "\n";
212         }
213 }
214
215 hash_save_array_words(\%ignore_type, \@ignore);
216 hash_save_array_words(\%use_type, \@use);
217
218 my $dbg_values = 0;
219 my $dbg_possible = 0;
220 my $dbg_type = 0;
221 my $dbg_attr = 0;
222 for my $key (keys %debug) {
223         ## no critic
224         eval "\${dbg_$key} = '$debug{$key}';";
225         die "$@" if ($@);
226 }
227
228 my $rpt_cleaners = 0;
229
230 if ($terse) {
231         $emacs = 1;
232         $quiet++;
233 }
234
235 if ($tree) {
236         if (defined $root) {
237                 if (!top_of_kernel_tree($root)) {
238                         die "$P: $root: --root does not point at a valid tree\n";
239                 }
240         } else {
241                 if (top_of_kernel_tree('.')) {
242                         $root = '.';
243                 } elsif ($0 =~ m@(.*)/scripts/[^/]*$@ &&
244                                                 top_of_kernel_tree($1)) {
245                         $root = $1;
246                 }
247         }
248
249         if (!defined $root) {
250                 print "Must be run from the top-level dir. of a kernel tree\n";
251                 exit(2);
252         }
253 }
254
255 my $emitted_corrupt = 0;
256
257 our $Ident      = qr{
258                         [A-Za-z_][A-Za-z\d_]*
259                         (?:\s*\#\#\s*[A-Za-z_][A-Za-z\d_]*)*
260                 }x;
261 our $Storage    = qr{extern|static|asmlinkage};
262 our $Sparse     = qr{
263                         __user|
264                         __kernel|
265                         __force|
266                         __iomem|
267                         __pmem|
268                         __must_check|
269                         __init_refok|
270                         __kprobes|
271                         __ref|
272                         __rcu
273                 }x;
274 our $InitAttributePrefix = qr{__(?:mem|cpu|dev|net_|)};
275 our $InitAttributeData = qr{$InitAttributePrefix(?:initdata\b)};
276 our $InitAttributeConst = qr{$InitAttributePrefix(?:initconst\b)};
277 our $InitAttributeInit = qr{$InitAttributePrefix(?:init\b)};
278 our $InitAttribute = qr{$InitAttributeData|$InitAttributeConst|$InitAttributeInit};
279
280 # Notes to $Attribute:
281 # We need \b after 'init' otherwise 'initconst' will cause a false positive in a check
282 our $Attribute  = qr{
283                         const|
284                         __percpu|
285                         __nocast|
286                         __safe|
287                         __bitwise__|
288                         __packed__|
289                         __packed2__|
290                         __naked|
291                         __maybe_unused|
292                         __always_unused|
293                         __noreturn|
294                         __used|
295                         __cold|
296                         __pure|
297                         __noclone|
298                         __deprecated|
299                         __read_mostly|
300                         __kprobes|
301                         $InitAttribute|
302                         ____cacheline_aligned|
303                         ____cacheline_aligned_in_smp|
304                         ____cacheline_internodealigned_in_smp|
305                         __weak
306                   }x;
307 our $Modifier;
308 our $Inline     = qr{inline|__always_inline|noinline|__inline|__inline__};
309 our $Member     = qr{->$Ident|\.$Ident|\[[^]]*\]};
310 our $Lval       = qr{$Ident(?:$Member)*};
311
312 our $Int_type   = qr{(?i)llu|ull|ll|lu|ul|l|u};
313 our $Binary     = qr{(?i)0b[01]+$Int_type?};
314 our $Hex        = qr{(?i)0x[0-9a-f]+$Int_type?};
315 our $Int        = qr{[0-9]+$Int_type?};
316 our $Octal      = qr{0[0-7]+$Int_type?};
317 our $String     = qr{"[X\t]*"};
318 our $Float_hex  = qr{(?i)0x[0-9a-f]+p-?[0-9]+[fl]?};
319 our $Float_dec  = qr{(?i)(?:[0-9]+\.[0-9]*|[0-9]*\.[0-9]+)(?:e-?[0-9]+)?[fl]?};
320 our $Float_int  = qr{(?i)[0-9]+e-?[0-9]+[fl]?};
321 our $Float      = qr{$Float_hex|$Float_dec|$Float_int};
322 our $Constant   = qr{$Float|$Binary|$Octal|$Hex|$Int};
323 our $Assignment = qr{\*\=|/=|%=|\+=|-=|<<=|>>=|&=|\^=|\|=|=};
324 our $Compare    = qr{<=|>=|==|!=|<|(?<!-)>};
325 our $Arithmetic = qr{\+|-|\*|\/|%};
326 our $Operators  = qr{
327                         <=|>=|==|!=|
328                         =>|->|<<|>>|<|>|!|~|
329                         &&|\|\||,|\^|\+\+|--|&|\||$Arithmetic
330                   }x;
331
332 our $c90_Keywords = qr{do|for|while|if|else|return|goto|continue|switch|default|case|break}x;
333
334 our $BasicType;
335 our $NonptrType;
336 our $NonptrTypeMisordered;
337 our $NonptrTypeWithAttr;
338 our $Type;
339 our $TypeMisordered;
340 our $Declare;
341 our $DeclareMisordered;
342
343 our $NON_ASCII_UTF8     = qr{
344         [\xC2-\xDF][\x80-\xBF]               # non-overlong 2-byte
345         |  \xE0[\xA0-\xBF][\x80-\xBF]        # excluding overlongs
346         | [\xE1-\xEC\xEE\xEF][\x80-\xBF]{2}  # straight 3-byte
347         |  \xED[\x80-\x9F][\x80-\xBF]        # excluding surrogates
348         |  \xF0[\x90-\xBF][\x80-\xBF]{2}     # planes 1-3
349         | [\xF1-\xF3][\x80-\xBF]{3}          # planes 4-15
350         |  \xF4[\x80-\x8F][\x80-\xBF]{2}     # plane 16
351 }x;
352
353 our $UTF8       = qr{
354         [\x09\x0A\x0D\x20-\x7E]              # ASCII
355         | $NON_ASCII_UTF8
356 }x;
357
358 our $typeC99Typedefs = qr{(?:__)?(?:[us]_?)?int_?(?:8|16|32|64)_t};
359 our $typeOtherOSTypedefs = qr{(?x:
360         u_(?:char|short|int|long) |          # bsd
361         u(?:nchar|short|int|long)            # sysv
362 )};
363 our $typeKernelTypedefs = qr{(?x:
364         (?:__)?(?:u|s|be|le)(?:8|16|32|64)|
365         atomic_t
366 )};
367 our $typeTypedefs = qr{(?x:
368         $typeC99Typedefs\b|
369         $typeOtherOSTypedefs\b|
370         $typeKernelTypedefs\b
371 )};
372
373 our $logFunctions = qr{(?x:
374         printk(?:_ratelimited|_once|)|
375         (?:[a-z0-9]+_){1,2}(?:printk|emerg|alert|crit|err|warning|warn|notice|info|debug|dbg|vdbg|devel|cont|WARN)(?:_ratelimited|_once|)|
376         WARN(?:_RATELIMIT|_ONCE|)|
377         panic|
378         MODULE_[A-Z_]+|
379         seq_vprintf|seq_printf|seq_puts
380 )};
381
382 our $signature_tags = qr{(?xi:
383         Signed-off-by:|
384         Acked-by:|
385         Tested-by:|
386         Reviewed-by:|
387         Reported-by:|
388         Suggested-by:|
389         To:|
390         Cc:
391 )};
392
393 our @typeListMisordered = (
394         qr{char\s+(?:un)?signed},
395         qr{int\s+(?:(?:un)?signed\s+)?short\s},
396         qr{int\s+short(?:\s+(?:un)?signed)},
397         qr{short\s+int(?:\s+(?:un)?signed)},
398         qr{(?:un)?signed\s+int\s+short},
399         qr{short\s+(?:un)?signed},
400         qr{long\s+int\s+(?:un)?signed},
401         qr{int\s+long\s+(?:un)?signed},
402         qr{long\s+(?:un)?signed\s+int},
403         qr{int\s+(?:un)?signed\s+long},
404         qr{int\s+(?:un)?signed},
405         qr{int\s+long\s+long\s+(?:un)?signed},
406         qr{long\s+long\s+int\s+(?:un)?signed},
407         qr{long\s+long\s+(?:un)?signed\s+int},
408         qr{long\s+long\s+(?:un)?signed},
409         qr{long\s+(?:un)?signed},
410 );
411
412 our @typeList = (
413         qr{void},
414         qr{(?:(?:un)?signed\s+)?char},
415         qr{(?:(?:un)?signed\s+)?short\s+int},
416         qr{(?:(?:un)?signed\s+)?short},
417         qr{(?:(?:un)?signed\s+)?int},
418         qr{(?:(?:un)?signed\s+)?long\s+int},
419         qr{(?:(?:un)?signed\s+)?long\s+long\s+int},
420         qr{(?:(?:un)?signed\s+)?long\s+long},
421         qr{(?:(?:un)?signed\s+)?long},
422         qr{(?:un)?signed},
423         qr{float},
424         qr{double},
425         qr{bool},
426         qr{struct\s+$Ident},
427         qr{union\s+$Ident},
428         qr{enum\s+$Ident},
429         qr{${Ident}_t},
430         qr{${Ident}_handler},
431         qr{${Ident}_handler_fn},
432         @typeListMisordered,
433 );
434 our @typeListFile = ();
435 our @typeListWithAttr = (
436         @typeList,
437         qr{struct\s+$InitAttribute\s+$Ident},
438         qr{union\s+$InitAttribute\s+$Ident},
439 );
440
441 our @modifierList = (
442         qr{fastcall},
443 );
444 our @modifierListFile = ();
445
446 our @mode_permission_funcs = (
447         ["module_param", 3],
448         ["module_param_(?:array|named|string)", 4],
449         ["module_param_array_named", 5],
450         ["debugfs_create_(?:file|u8|u16|u32|u64|x8|x16|x32|x64|size_t|atomic_t|bool|blob|regset32|u32_array)", 2],
451         ["proc_create(?:_data|)", 2],
452         ["(?:CLASS|DEVICE|SENSOR)_ATTR", 2],
453 );
454
455 #Create a search pattern for all these functions to speed up a loop below
456 our $mode_perms_search = "";
457 foreach my $entry (@mode_permission_funcs) {
458         $mode_perms_search .= '|' if ($mode_perms_search ne "");
459         $mode_perms_search .= $entry->[0];
460 }
461
462 our $mode_perms_world_writable = qr{
463         S_IWUGO         |
464         S_IWOTH         |
465         S_IRWXUGO       |
466         S_IALLUGO       |
467         0[0-7][0-7][2367]
468 }x;
469
470 our $allowed_asm_includes = qr{(?x:
471         irq|
472         memory|
473         time|
474         reboot
475 )};
476 # memory.h: ARM has a custom one
477
478 # Load common spelling mistakes and build regular expression list.
479 my $misspellings;
480 my %spelling_fix;
481
482 if (open(my $spelling, '<', $spelling_file)) {
483         while (<$spelling>) {
484                 my $line = $_;
485
486                 $line =~ s/\s*\n?$//g;
487                 $line =~ s/^\s*//g;
488
489                 next if ($line =~ m/^\s*#/);
490                 next if ($line =~ m/^\s*$/);
491
492                 my ($suspect, $fix) = split(/\|\|/, $line);
493
494                 $spelling_fix{$suspect} = $fix;
495         }
496         close($spelling);
497 } else {
498         warn "No typos will be found - file '$spelling_file': $!\n";
499 }
500
501 if ($codespell) {
502         if (open(my $spelling, '<', $codespellfile)) {
503                 while (<$spelling>) {
504                         my $line = $_;
505
506                         $line =~ s/\s*\n?$//g;
507                         $line =~ s/^\s*//g;
508
509                         next if ($line =~ m/^\s*#/);
510                         next if ($line =~ m/^\s*$/);
511                         next if ($line =~ m/, disabled/i);
512
513                         $line =~ s/,.*$//;
514
515                         my ($suspect, $fix) = split(/->/, $line);
516
517                         $spelling_fix{$suspect} = $fix;
518                 }
519                 close($spelling);
520         } else {
521                 warn "No codespell typos will be found - file '$codespellfile': $!\n";
522         }
523 }
524
525 $misspellings = join("|", sort keys %spelling_fix) if keys %spelling_fix;
526
527 sub build_types {
528         my $mods = "(?x:  \n" . join("|\n  ", (@modifierList, @modifierListFile)) . "\n)";
529         my $all = "(?x:  \n" . join("|\n  ", (@typeList, @typeListFile)) . "\n)";
530         my $Misordered = "(?x:  \n" . join("|\n  ", @typeListMisordered) . "\n)";
531         my $allWithAttr = "(?x:  \n" . join("|\n  ", @typeListWithAttr) . "\n)";
532         $Modifier       = qr{(?:$Attribute|$Sparse|$mods)};
533         $BasicType      = qr{
534                                 (?:$typeTypedefs\b)|
535                                 (?:${all}\b)
536                 }x;
537         $NonptrType     = qr{
538                         (?:$Modifier\s+|const\s+)*
539                         (?:
540                                 (?:typeof|__typeof__)\s*\([^\)]*\)|
541                                 (?:$typeTypedefs\b)|
542                                 (?:${all}\b)
543                         )
544                         (?:\s+$Modifier|\s+const)*
545                   }x;
546         $NonptrTypeMisordered   = qr{
547                         (?:$Modifier\s+|const\s+)*
548                         (?:
549                                 (?:${Misordered}\b)
550                         )
551                         (?:\s+$Modifier|\s+const)*
552                   }x;
553         $NonptrTypeWithAttr     = qr{
554                         (?:$Modifier\s+|const\s+)*
555                         (?:
556                                 (?:typeof|__typeof__)\s*\([^\)]*\)|
557                                 (?:$typeTypedefs\b)|
558                                 (?:${allWithAttr}\b)
559                         )
560                         (?:\s+$Modifier|\s+const)*
561                   }x;
562         $Type   = qr{
563                         $NonptrType
564                         (?:(?:\s|\*|\[\])+\s*const|(?:\s|\*\s*(?:const\s*)?|\[\])+|(?:\s*\[\s*\])+)?
565                         (?:\s+$Inline|\s+$Modifier)*
566                   }x;
567         $TypeMisordered = qr{
568                         $NonptrTypeMisordered
569                         (?:(?:\s|\*|\[\])+\s*const|(?:\s|\*\s*(?:const\s*)?|\[\])+|(?:\s*\[\s*\])+)?
570                         (?:\s+$Inline|\s+$Modifier)*
571                   }x;
572         $Declare        = qr{(?:$Storage\s+(?:$Inline\s+)?)?$Type};
573         $DeclareMisordered      = qr{(?:$Storage\s+(?:$Inline\s+)?)?$TypeMisordered};
574 }
575 build_types();
576
577 our $Typecast   = qr{\s*(\(\s*$NonptrType\s*\)){0,1}\s*};
578
579 # Using $balanced_parens, $LvalOrFunc, or $FuncArg
580 # requires at least perl version v5.10.0
581 # Any use must be runtime checked with $^V
582
583 our $balanced_parens = qr/(\((?:[^\(\)]++|(?-1))*\))/;
584 our $LvalOrFunc = qr{((?:[\&\*]\s*)?$Lval)\s*($balanced_parens{0,1})\s*};
585 our $FuncArg = qr{$Typecast{0,1}($LvalOrFunc|$Constant|$String)};
586
587 our $declaration_macros = qr{(?x:
588         (?:$Storage\s+)?(?:[A-Z_][A-Z0-9]*_){0,2}(?:DEFINE|DECLARE)(?:_[A-Z0-9]+){1,6}\s*\(|
589         (?:$Storage\s+)?LIST_HEAD\s*\(|
590         (?:$Storage\s+)?${Type}\s+uninitialized_var\s*\(
591 )};
592
593 sub deparenthesize {
594         my ($string) = @_;
595         return "" if (!defined($string));
596
597         while ($string =~ /^\s*\(.*\)\s*$/) {
598                 $string =~ s@^\s*\(\s*@@;
599                 $string =~ s@\s*\)\s*$@@;
600         }
601
602         $string =~ s@\s+@ @g;
603
604         return $string;
605 }
606
607 sub seed_camelcase_file {
608         my ($file) = @_;
609
610         return if (!(-f $file));
611
612         local $/;
613
614         open(my $include_file, '<', "$file")
615             or warn "$P: Can't read '$file' $!\n";
616         my $text = <$include_file>;
617         close($include_file);
618
619         my @lines = split('\n', $text);
620
621         foreach my $line (@lines) {
622                 next if ($line !~ /(?:[A-Z][a-z]|[a-z][A-Z])/);
623                 if ($line =~ /^[ \t]*(?:#[ \t]*define|typedef\s+$Type)\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)/) {
624                         $camelcase{$1} = 1;
625                 } elsif ($line =~ /^\s*$Declare\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)\s*[\(\[,;]/) {
626                         $camelcase{$1} = 1;
627                 } elsif ($line =~ /^\s*(?:union|struct|enum)\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)\s*[;\{]/) {
628                         $camelcase{$1} = 1;
629                 }
630         }
631 }
632
633 my $camelcase_seeded = 0;
634 sub seed_camelcase_includes {
635         return if ($camelcase_seeded);
636
637         my $files;
638         my $camelcase_cache = "";
639         my @include_files = ();
640
641         $camelcase_seeded = 1;
642
643         if (-e ".git") {
644                 my $git_last_include_commit = `git log --no-merges --pretty=format:"%h%n" -1 -- include`;
645                 chomp $git_last_include_commit;
646                 $camelcase_cache = ".checkpatch-camelcase.git.$git_last_include_commit";
647         } else {
648                 my $last_mod_date = 0;
649                 $files = `find $root/include -name "*.h"`;
650                 @include_files = split('\n', $files);
651                 foreach my $file (@include_files) {
652                         my $date = POSIX::strftime("%Y%m%d%H%M",
653                                                    localtime((stat $file)[9]));
654                         $last_mod_date = $date if ($last_mod_date < $date);
655                 }
656                 $camelcase_cache = ".checkpatch-camelcase.date.$last_mod_date";
657         }
658
659         if ($camelcase_cache ne "" && -f $camelcase_cache) {
660                 open(my $camelcase_file, '<', "$camelcase_cache")
661                     or warn "$P: Can't read '$camelcase_cache' $!\n";
662                 while (<$camelcase_file>) {
663                         chomp;
664                         $camelcase{$_} = 1;
665                 }
666                 close($camelcase_file);
667
668                 return;
669         }
670
671         if (-e ".git") {
672                 $files = `git ls-files "include/*.h"`;
673                 @include_files = split('\n', $files);
674         }
675
676         foreach my $file (@include_files) {
677                 seed_camelcase_file($file);
678         }
679
680         if ($camelcase_cache ne "") {
681                 unlink glob ".checkpatch-camelcase.*";
682                 open(my $camelcase_file, '>', "$camelcase_cache")
683                     or warn "$P: Can't write '$camelcase_cache' $!\n";
684                 foreach (sort { lc($a) cmp lc($b) } keys(%camelcase)) {
685                         print $camelcase_file ("$_\n");
686                 }
687                 close($camelcase_file);
688         }
689 }
690
691 sub git_commit_info {
692         my ($commit, $id, $desc) = @_;
693
694         return ($id, $desc) if ((which("git") eq "") || !(-e ".git"));
695
696         my $output = `git log --no-color --format='%H %s' -1 $commit 2>&1`;
697         $output =~ s/^\s*//gm;
698         my @lines = split("\n", $output);
699
700         return ($id, $desc) if ($#lines < 0);
701
702         if ($lines[0] =~ /^error: short SHA1 $commit is ambiguous\./) {
703 # Maybe one day convert this block of bash into something that returns
704 # all matching commit ids, but it's very slow...
705 #
706 #               echo "checking commits $1..."
707 #               git rev-list --remotes | grep -i "^$1" |
708 #               while read line ; do
709 #                   git log --format='%H %s' -1 $line |
710 #                   echo "commit $(cut -c 1-12,41-)"
711 #               done
712         } elsif ($lines[0] =~ /^fatal: ambiguous argument '$commit': unknown revision or path not in the working tree\./) {
713         } else {
714                 $id = substr($lines[0], 0, 12);
715                 $desc = substr($lines[0], 41);
716         }
717
718         return ($id, $desc);
719 }
720
721 $chk_signoff = 0 if ($file);
722
723 my @rawlines = ();
724 my @lines = ();
725 my @fixed = ();
726 my @fixed_inserted = ();
727 my @fixed_deleted = ();
728 my $fixlinenr = -1;
729
730 my $vname;
731 for my $filename (@ARGV) {
732         my $FILE;
733         if ($file) {
734                 open($FILE, '-|', "diff -u /dev/null $filename") ||
735                         die "$P: $filename: diff failed - $!\n";
736         } elsif ($filename eq '-') {
737                 open($FILE, '<&STDIN');
738         } else {
739                 open($FILE, '<', "$filename") ||
740                         die "$P: $filename: open failed - $!\n";
741         }
742         if ($filename eq '-') {
743                 $vname = 'Your patch';
744         } else {
745                 $vname = $filename;
746         }
747         while (<$FILE>) {
748                 chomp;
749                 push(@rawlines, $_);
750         }
751         close($FILE);
752
753         if ($#ARGV > 0 && $quiet == 0) {
754                 print '-' x length($vname) . "\n";
755                 print "$vname\n";
756                 print '-' x length($vname) . "\n";
757         }
758
759         if (!process($filename)) {
760                 $exit = 1;
761         }
762         @rawlines = ();
763         @lines = ();
764         @fixed = ();
765         @fixed_inserted = ();
766         @fixed_deleted = ();
767         $fixlinenr = -1;
768         @modifierListFile = ();
769         @typeListFile = ();
770         build_types();
771 }
772
773 if (!$quiet) {
774         hash_show_words(\%use_type, "Used");
775         hash_show_words(\%ignore_type, "Ignored");
776
777         if ($^V lt 5.10.0) {
778                 print << "EOM"
779
780 NOTE: perl $^V is not modern enough to detect all possible issues.
781       An upgrade to at least perl v5.10.0 is suggested.
782 EOM
783         }
784         if ($exit) {
785                 print << "EOM"
786
787 NOTE: If any of the errors are false positives, please report
788       them to the maintainer, see CHECKPATCH in MAINTAINERS.
789 EOM
790         }
791 }
792
793 exit($exit);
794
795 sub top_of_kernel_tree {
796         my ($root) = @_;
797
798         my @tree_check = (
799                 "COPYING", "CREDITS", "Kbuild", "MAINTAINERS", "Makefile",
800                 "README", "Documentation", "arch", "include", "drivers",
801                 "fs", "init", "ipc", "kernel", "lib", "scripts",
802         );
803
804         foreach my $check (@tree_check) {
805                 if (! -e $root . '/' . $check) {
806                         return 0;
807                 }
808         }
809         return 1;
810 }
811
812 sub parse_email {
813         my ($formatted_email) = @_;
814
815         my $name = "";
816         my $address = "";
817         my $comment = "";
818
819         if ($formatted_email =~ /^(.*)<(\S+\@\S+)>(.*)$/) {
820                 $name = $1;
821                 $address = $2;
822                 $comment = $3 if defined $3;
823         } elsif ($formatted_email =~ /^\s*<(\S+\@\S+)>(.*)$/) {
824                 $address = $1;
825                 $comment = $2 if defined $2;
826         } elsif ($formatted_email =~ /(\S+\@\S+)(.*)$/) {
827                 $address = $1;
828                 $comment = $2 if defined $2;
829                 $formatted_email =~ s/$address.*$//;
830                 $name = $formatted_email;
831                 $name = trim($name);
832                 $name =~ s/^\"|\"$//g;
833                 # If there's a name left after stripping spaces and
834                 # leading quotes, and the address doesn't have both
835                 # leading and trailing angle brackets, the address
836                 # is invalid. ie:
837                 #   "joe smith joe@smith.com" bad
838                 #   "joe smith <joe@smith.com" bad
839                 if ($name ne "" && $address !~ /^<[^>]+>$/) {
840                         $name = "";
841                         $address = "";
842                         $comment = "";
843                 }
844         }
845
846         $name = trim($name);
847         $name =~ s/^\"|\"$//g;
848         $address = trim($address);
849         $address =~ s/^\<|\>$//g;
850
851         if ($name =~ /[^\w \-]/i) { ##has "must quote" chars
852                 $name =~ s/(?<!\\)"/\\"/g; ##escape quotes
853                 $name = "\"$name\"";
854         }
855
856         return ($name, $address, $comment);
857 }
858
859 sub format_email {
860         my ($name, $address) = @_;
861
862         my $formatted_email;
863
864         $name = trim($name);
865         $name =~ s/^\"|\"$//g;
866         $address = trim($address);
867
868         if ($name =~ /[^\w \-]/i) { ##has "must quote" chars
869                 $name =~ s/(?<!\\)"/\\"/g; ##escape quotes
870                 $name = "\"$name\"";
871         }
872
873         if ("$name" eq "") {
874                 $formatted_email = "$address";
875         } else {
876                 $formatted_email = "$name <$address>";
877         }
878
879         return $formatted_email;
880 }
881
882 sub which {
883         my ($bin) = @_;
884
885         foreach my $path (split(/:/, $ENV{PATH})) {
886                 if (-e "$path/$bin") {
887                         return "$path/$bin";
888                 }
889         }
890
891         return "";
892 }
893
894 sub which_conf {
895         my ($conf) = @_;
896
897         foreach my $path (split(/:/, ".:$ENV{HOME}:.scripts")) {
898                 if (-e "$path/$conf") {
899                         return "$path/$conf";
900                 }
901         }
902
903         return "";
904 }
905
906 sub expand_tabs {
907         my ($str) = @_;
908
909         my $res = '';
910         my $n = 0;
911         for my $c (split(//, $str)) {
912                 if ($c eq "\t") {
913                         $res .= ' ';
914                         $n++;
915                         for (; ($n % 8) != 0; $n++) {
916                                 $res .= ' ';
917                         }
918                         next;
919                 }
920                 $res .= $c;
921                 $n++;
922         }
923
924         return $res;
925 }
926 sub copy_spacing {
927         (my $res = shift) =~ tr/\t/ /c;
928         return $res;
929 }
930
931 sub line_stats {
932         my ($line) = @_;
933
934         # Drop the diff line leader and expand tabs
935         $line =~ s/^.//;
936         $line = expand_tabs($line);
937
938         # Pick the indent from the front of the line.
939         my ($white) = ($line =~ /^(\s*)/);
940
941         return (length($line), length($white));
942 }
943
944 my $sanitise_quote = '';
945
946 sub sanitise_line_reset {
947         my ($in_comment) = @_;
948
949         if ($in_comment) {
950                 $sanitise_quote = '*/';
951         } else {
952                 $sanitise_quote = '';
953         }
954 }
955 sub sanitise_line {
956         my ($line) = @_;
957
958         my $res = '';
959         my $l = '';
960
961         my $qlen = 0;
962         my $off = 0;
963         my $c;
964
965         # Always copy over the diff marker.
966         $res = substr($line, 0, 1);
967
968         for ($off = 1; $off < length($line); $off++) {
969                 $c = substr($line, $off, 1);
970
971                 # Comments we are wacking completly including the begin
972                 # and end, all to $;.
973                 if ($sanitise_quote eq '' && substr($line, $off, 2) eq '/*') {
974                         $sanitise_quote = '*/';
975
976                         substr($res, $off, 2, "$;$;");
977                         $off++;
978                         next;
979                 }
980                 if ($sanitise_quote eq '*/' && substr($line, $off, 2) eq '*/') {
981                         $sanitise_quote = '';
982                         substr($res, $off, 2, "$;$;");
983                         $off++;
984                         next;
985                 }
986                 if ($sanitise_quote eq '' && substr($line, $off, 2) eq '//') {
987                         $sanitise_quote = '//';
988
989                         substr($res, $off, 2, $sanitise_quote);
990                         $off++;
991                         next;
992                 }
993
994                 # A \ in a string means ignore the next character.
995                 if (($sanitise_quote eq "'" || $sanitise_quote eq '"') &&
996                     $c eq "\\") {
997                         substr($res, $off, 2, 'XX');
998                         $off++;
999                         next;
1000                 }
1001                 # Regular quotes.
1002                 if ($c eq "'" || $c eq '"') {
1003                         if ($sanitise_quote eq '') {
1004                                 $sanitise_quote = $c;
1005
1006                                 substr($res, $off, 1, $c);
1007                                 next;
1008                         } elsif ($sanitise_quote eq $c) {
1009                                 $sanitise_quote = '';
1010                         }
1011                 }
1012
1013                 #print "c<$c> SQ<$sanitise_quote>\n";
1014                 if ($off != 0 && $sanitise_quote eq '*/' && $c ne "\t") {
1015                         substr($res, $off, 1, $;);
1016                 } elsif ($off != 0 && $sanitise_quote eq '//' && $c ne "\t") {
1017                         substr($res, $off, 1, $;);
1018                 } elsif ($off != 0 && $sanitise_quote && $c ne "\t") {
1019                         substr($res, $off, 1, 'X');
1020                 } else {
1021                         substr($res, $off, 1, $c);
1022                 }
1023         }
1024
1025         if ($sanitise_quote eq '//') {
1026                 $sanitise_quote = '';
1027         }
1028
1029         # The pathname on a #include may be surrounded by '<' and '>'.
1030         if ($res =~ /^.\s*\#\s*include\s+\<(.*)\>/) {
1031                 my $clean = 'X' x length($1);
1032                 $res =~ s@\<.*\>@<$clean>@;
1033
1034         # The whole of a #error is a string.
1035         } elsif ($res =~ /^.\s*\#\s*(?:error|warning)\s+(.*)\b/) {
1036                 my $clean = 'X' x length($1);
1037                 $res =~ s@(\#\s*(?:error|warning)\s+).*@$1$clean@;
1038         }
1039
1040         return $res;
1041 }
1042
1043 sub get_quoted_string {
1044         my ($line, $rawline) = @_;
1045
1046         return "" if ($line !~ m/($String)/g);
1047         return substr($rawline, $-[0], $+[0] - $-[0]);
1048 }
1049
1050 sub ctx_statement_block {
1051         my ($linenr, $remain, $off) = @_;
1052         my $line = $linenr - 1;
1053         my $blk = '';
1054         my $soff = $off;
1055         my $coff = $off - 1;
1056         my $coff_set = 0;
1057
1058         my $loff = 0;
1059
1060         my $type = '';
1061         my $level = 0;
1062         my @stack = ();
1063         my $p;
1064         my $c;
1065         my $len = 0;
1066
1067         my $remainder;
1068         while (1) {
1069                 @stack = (['', 0]) if ($#stack == -1);
1070
1071                 #warn "CSB: blk<$blk> remain<$remain>\n";
1072                 # If we are about to drop off the end, pull in more
1073                 # context.
1074                 if ($off >= $len) {
1075                         for (; $remain > 0; $line++) {
1076                                 last if (!defined $lines[$line]);
1077                                 next if ($lines[$line] =~ /^-/);
1078                                 $remain--;
1079                                 $loff = $len;
1080                                 $blk .= $lines[$line] . "\n";
1081                                 $len = length($blk);
1082                                 $line++;
1083                                 last;
1084                         }
1085                         # Bail if there is no further context.
1086                         #warn "CSB: blk<$blk> off<$off> len<$len>\n";
1087                         if ($off >= $len) {
1088                                 last;
1089                         }
1090                         if ($level == 0 && substr($blk, $off) =~ /^.\s*#\s*define/) {
1091                                 $level++;
1092                                 $type = '#';
1093                         }
1094                 }
1095                 $p = $c;
1096                 $c = substr($blk, $off, 1);
1097                 $remainder = substr($blk, $off);
1098
1099                 #warn "CSB: c<$c> type<$type> level<$level> remainder<$remainder> coff_set<$coff_set>\n";
1100
1101                 # Handle nested #if/#else.
1102                 if ($remainder =~ /^#\s*(?:ifndef|ifdef|if)\s/) {
1103                         push(@stack, [ $type, $level ]);
1104                 } elsif ($remainder =~ /^#\s*(?:else|elif)\b/) {
1105                         ($type, $level) = @{$stack[$#stack - 1]};
1106                 } elsif ($remainder =~ /^#\s*endif\b/) {
1107                         ($type, $level) = @{pop(@stack)};
1108                 }
1109
1110                 # Statement ends at the ';' or a close '}' at the
1111                 # outermost level.
1112                 if ($level == 0 && $c eq ';') {
1113                         last;
1114                 }
1115
1116                 # An else is really a conditional as long as its not else if
1117                 if ($level == 0 && $coff_set == 0 &&
1118                                 (!defined($p) || $p =~ /(?:\s|\}|\+)/) &&
1119                                 $remainder =~ /^(else)(?:\s|{)/ &&
1120                                 $remainder !~ /^else\s+if\b/) {
1121                         $coff = $off + length($1) - 1;
1122                         $coff_set = 1;
1123                         #warn "CSB: mark coff<$coff> soff<$soff> 1<$1>\n";
1124                         #warn "[" . substr($blk, $soff, $coff - $soff + 1) . "]\n";
1125                 }
1126
1127                 if (($type eq '' || $type eq '(') && $c eq '(') {
1128                         $level++;
1129                         $type = '(';
1130                 }
1131                 if ($type eq '(' && $c eq ')') {
1132                         $level--;
1133                         $type = ($level != 0)? '(' : '';
1134
1135                         if ($level == 0 && $coff < $soff) {
1136                                 $coff = $off;
1137                                 $coff_set = 1;
1138                                 #warn "CSB: mark coff<$coff>\n";
1139                         }
1140                 }
1141                 if (($type eq '' || $type eq '{') && $c eq '{') {
1142                         $level++;
1143                         $type = '{';
1144                 }
1145                 if ($type eq '{' && $c eq '}') {
1146                         $level--;
1147                         $type = ($level != 0)? '{' : '';
1148
1149                         if ($level == 0) {
1150                                 if (substr($blk, $off + 1, 1) eq ';') {
1151                                         $off++;
1152                                 }
1153                                 last;
1154                         }
1155                 }
1156                 # Preprocessor commands end at the newline unless escaped.
1157                 if ($type eq '#' && $c eq "\n" && $p ne "\\") {
1158                         $level--;
1159                         $type = '';
1160                         $off++;
1161                         last;
1162                 }
1163                 $off++;
1164         }
1165         # We are truly at the end, so shuffle to the next line.
1166         if ($off == $len) {
1167                 $loff = $len + 1;
1168                 $line++;
1169                 $remain--;
1170         }
1171
1172         my $statement = substr($blk, $soff, $off - $soff + 1);
1173         my $condition = substr($blk, $soff, $coff - $soff + 1);
1174
1175         #warn "STATEMENT<$statement>\n";
1176         #warn "CONDITION<$condition>\n";
1177
1178         #print "coff<$coff> soff<$off> loff<$loff>\n";
1179
1180         return ($statement, $condition,
1181                         $line, $remain + 1, $off - $loff + 1, $level);
1182 }
1183
1184 sub statement_lines {
1185         my ($stmt) = @_;
1186
1187         # Strip the diff line prefixes and rip blank lines at start and end.
1188         $stmt =~ s/(^|\n)./$1/g;
1189         $stmt =~ s/^\s*//;
1190         $stmt =~ s/\s*$//;
1191
1192         my @stmt_lines = ($stmt =~ /\n/g);
1193
1194         return $#stmt_lines + 2;
1195 }
1196
1197 sub statement_rawlines {
1198         my ($stmt) = @_;
1199
1200         my @stmt_lines = ($stmt =~ /\n/g);
1201
1202         return $#stmt_lines + 2;
1203 }
1204
1205 sub statement_block_size {
1206         my ($stmt) = @_;
1207
1208         $stmt =~ s/(^|\n)./$1/g;
1209         $stmt =~ s/^\s*{//;
1210         $stmt =~ s/}\s*$//;
1211         $stmt =~ s/^\s*//;
1212         $stmt =~ s/\s*$//;
1213
1214         my @stmt_lines = ($stmt =~ /\n/g);
1215         my @stmt_statements = ($stmt =~ /;/g);
1216
1217         my $stmt_lines = $#stmt_lines + 2;
1218         my $stmt_statements = $#stmt_statements + 1;
1219
1220         if ($stmt_lines > $stmt_statements) {
1221                 return $stmt_lines;
1222         } else {
1223                 return $stmt_statements;
1224         }
1225 }
1226
1227 sub ctx_statement_full {
1228         my ($linenr, $remain, $off) = @_;
1229         my ($statement, $condition, $level);
1230
1231         my (@chunks);
1232
1233         # Grab the first conditional/block pair.
1234         ($statement, $condition, $linenr, $remain, $off, $level) =
1235                                 ctx_statement_block($linenr, $remain, $off);
1236         #print "F: c<$condition> s<$statement> remain<$remain>\n";
1237         push(@chunks, [ $condition, $statement ]);
1238         if (!($remain > 0 && $condition =~ /^\s*(?:\n[+-])?\s*(?:if|else|do)\b/s)) {
1239                 return ($level, $linenr, @chunks);
1240         }
1241
1242         # Pull in the following conditional/block pairs and see if they
1243         # could continue the statement.
1244         for (;;) {
1245                 ($statement, $condition, $linenr, $remain, $off, $level) =
1246                                 ctx_statement_block($linenr, $remain, $off);
1247                 #print "C: c<$condition> s<$statement> remain<$remain>\n";
1248                 last if (!($remain > 0 && $condition =~ /^(?:\s*\n[+-])*\s*(?:else|do)\b/s));
1249                 #print "C: push\n";
1250                 push(@chunks, [ $condition, $statement ]);
1251         }
1252
1253         return ($level, $linenr, @chunks);
1254 }
1255
1256 sub ctx_block_get {
1257         my ($linenr, $remain, $outer, $open, $close, $off) = @_;
1258         my $line;
1259         my $start = $linenr - 1;
1260         my $blk = '';
1261         my @o;
1262         my @c;
1263         my @res = ();
1264
1265         my $level = 0;
1266         my @stack = ($level);
1267         for ($line = $start; $remain > 0; $line++) {
1268                 next if ($rawlines[$line] =~ /^-/);
1269                 $remain--;
1270
1271                 $blk .= $rawlines[$line];
1272
1273                 # Handle nested #if/#else.
1274                 if ($lines[$line] =~ /^.\s*#\s*(?:ifndef|ifdef|if)\s/) {
1275                         push(@stack, $level);
1276                 } elsif ($lines[$line] =~ /^.\s*#\s*(?:else|elif)\b/) {
1277                         $level = $stack[$#stack - 1];
1278                 } elsif ($lines[$line] =~ /^.\s*#\s*endif\b/) {
1279                         $level = pop(@stack);
1280                 }
1281
1282                 foreach my $c (split(//, $lines[$line])) {
1283                         ##print "C<$c>L<$level><$open$close>O<$off>\n";
1284                         if ($off > 0) {
1285                                 $off--;
1286                                 next;
1287                         }
1288
1289                         if ($c eq $close && $level > 0) {
1290                                 $level--;
1291                                 last if ($level == 0);
1292                         } elsif ($c eq $open) {
1293                                 $level++;
1294                         }
1295                 }
1296
1297                 if (!$outer || $level <= 1) {
1298                         push(@res, $rawlines[$line]);
1299                 }
1300
1301                 last if ($level == 0);
1302         }
1303
1304         return ($level, @res);
1305 }
1306 sub ctx_block_outer {
1307         my ($linenr, $remain) = @_;
1308
1309         my ($level, @r) = ctx_block_get($linenr, $remain, 1, '{', '}', 0);
1310         return @r;
1311 }
1312 sub ctx_block {
1313         my ($linenr, $remain) = @_;
1314
1315         my ($level, @r) = ctx_block_get($linenr, $remain, 0, '{', '}', 0);
1316         return @r;
1317 }
1318 sub ctx_statement {
1319         my ($linenr, $remain, $off) = @_;
1320
1321         my ($level, @r) = ctx_block_get($linenr, $remain, 0, '(', ')', $off);
1322         return @r;
1323 }
1324 sub ctx_block_level {
1325         my ($linenr, $remain) = @_;
1326
1327         return ctx_block_get($linenr, $remain, 0, '{', '}', 0);
1328 }
1329 sub ctx_statement_level {
1330         my ($linenr, $remain, $off) = @_;
1331
1332         return ctx_block_get($linenr, $remain, 0, '(', ')', $off);
1333 }
1334
1335 sub ctx_locate_comment {
1336         my ($first_line, $end_line) = @_;
1337
1338         # Catch a comment on the end of the line itself.
1339         my ($current_comment) = ($rawlines[$end_line - 1] =~ m@.*(/\*.*\*/)\s*(?:\\\s*)?$@);
1340         return $current_comment if (defined $current_comment);
1341
1342         # Look through the context and try and figure out if there is a
1343         # comment.
1344         my $in_comment = 0;
1345         $current_comment = '';
1346         for (my $linenr = $first_line; $linenr < $end_line; $linenr++) {
1347                 my $line = $rawlines[$linenr - 1];
1348                 #warn "           $line\n";
1349                 if ($linenr == $first_line and $line =~ m@^.\s*\*@) {
1350                         $in_comment = 1;
1351                 }
1352                 if ($line =~ m@/\*@) {
1353                         $in_comment = 1;
1354                 }
1355                 if (!$in_comment && $current_comment ne '') {
1356                         $current_comment = '';
1357                 }
1358                 $current_comment .= $line . "\n" if ($in_comment);
1359                 if ($line =~ m@\*/@) {
1360                         $in_comment = 0;
1361                 }
1362         }
1363
1364         chomp($current_comment);
1365         return($current_comment);
1366 }
1367 sub ctx_has_comment {
1368         my ($first_line, $end_line) = @_;
1369         my $cmt = ctx_locate_comment($first_line, $end_line);
1370
1371         ##print "LINE: $rawlines[$end_line - 1 ]\n";
1372         ##print "CMMT: $cmt\n";
1373
1374         return ($cmt ne '');
1375 }
1376
1377 sub raw_line {
1378         my ($linenr, $cnt) = @_;
1379
1380         my $offset = $linenr - 1;
1381         $cnt++;
1382
1383         my $line;
1384         while ($cnt) {
1385                 $line = $rawlines[$offset++];
1386                 next if (defined($line) && $line =~ /^-/);
1387                 $cnt--;
1388         }
1389
1390         return $line;
1391 }
1392
1393 sub cat_vet {
1394         my ($vet) = @_;
1395         my ($res, $coded);
1396
1397         $res = '';
1398         while ($vet =~ /([^[:cntrl:]]*)([[:cntrl:]]|$)/g) {
1399                 $res .= $1;
1400                 if ($2 ne '') {
1401                         $coded = sprintf("^%c", unpack('C', $2) + 64);
1402                         $res .= $coded;
1403                 }
1404         }
1405         $res =~ s/$/\$/;
1406
1407         return $res;
1408 }
1409
1410 my $av_preprocessor = 0;
1411 my $av_pending;
1412 my @av_paren_type;
1413 my $av_pend_colon;
1414
1415 sub annotate_reset {
1416         $av_preprocessor = 0;
1417         $av_pending = '_';
1418         @av_paren_type = ('E');
1419         $av_pend_colon = 'O';
1420 }
1421
1422 sub annotate_values {
1423         my ($stream, $type) = @_;
1424
1425         my $res;
1426         my $var = '_' x length($stream);
1427         my $cur = $stream;
1428
1429         print "$stream\n" if ($dbg_values > 1);
1430
1431         while (length($cur)) {
1432                 @av_paren_type = ('E') if ($#av_paren_type < 0);
1433                 print " <" . join('', @av_paren_type) .
1434                                 "> <$type> <$av_pending>" if ($dbg_values > 1);
1435                 if ($cur =~ /^(\s+)/o) {
1436                         print "WS($1)\n" if ($dbg_values > 1);
1437                         if ($1 =~ /\n/ && $av_preprocessor) {
1438                                 $type = pop(@av_paren_type);
1439                                 $av_preprocessor = 0;
1440                         }
1441
1442                 } elsif ($cur =~ /^(\(\s*$Type\s*)\)/ && $av_pending eq '_') {
1443                         print "CAST($1)\n" if ($dbg_values > 1);
1444                         push(@av_paren_type, $type);
1445                         $type = 'c';
1446
1447                 } elsif ($cur =~ /^($Type)\s*(?:$Ident|,|\)|\(|\s*$)/) {
1448                         print "DECLARE($1)\n" if ($dbg_values > 1);
1449                         $type = 'T';
1450
1451                 } elsif ($cur =~ /^($Modifier)\s*/) {
1452                         print "MODIFIER($1)\n" if ($dbg_values > 1);
1453                         $type = 'T';
1454
1455                 } elsif ($cur =~ /^(\#\s*define\s*$Ident)(\(?)/o) {
1456                         print "DEFINE($1,$2)\n" if ($dbg_values > 1);
1457                         $av_preprocessor = 1;
1458                         push(@av_paren_type, $type);
1459                         if ($2 ne '') {
1460                                 $av_pending = 'N';
1461                         }
1462                         $type = 'E';
1463
1464                 } elsif ($cur =~ /^(\#\s*(?:undef\s*$Ident|include\b))/o) {
1465                         print "UNDEF($1)\n" if ($dbg_values > 1);
1466                         $av_preprocessor = 1;
1467                         push(@av_paren_type, $type);
1468
1469                 } elsif ($cur =~ /^(\#\s*(?:ifdef|ifndef|if))/o) {
1470                         print "PRE_START($1)\n" if ($dbg_values > 1);
1471                         $av_preprocessor = 1;
1472
1473                         push(@av_paren_type, $type);
1474                         push(@av_paren_type, $type);
1475                         $type = 'E';
1476
1477                 } elsif ($cur =~ /^(\#\s*(?:else|elif))/o) {
1478                         print "PRE_RESTART($1)\n" if ($dbg_values > 1);
1479                         $av_preprocessor = 1;
1480
1481                         push(@av_paren_type, $av_paren_type[$#av_paren_type]);
1482
1483                         $type = 'E';
1484
1485                 } elsif ($cur =~ /^(\#\s*(?:endif))/o) {
1486                         print "PRE_END($1)\n" if ($dbg_values > 1);
1487
1488                         $av_preprocessor = 1;
1489
1490                         # Assume all arms of the conditional end as this
1491                         # one does, and continue as if the #endif was not here.
1492                         pop(@av_paren_type);
1493                         push(@av_paren_type, $type);
1494                         $type = 'E';
1495
1496                 } elsif ($cur =~ /^(\\\n)/o) {
1497                         print "PRECONT($1)\n" if ($dbg_values > 1);
1498
1499                 } elsif ($cur =~ /^(__attribute__)\s*\(?/o) {
1500                         print "ATTR($1)\n" if ($dbg_values > 1);
1501                         $av_pending = $type;
1502                         $type = 'N';
1503
1504                 } elsif ($cur =~ /^(sizeof)\s*(\()?/o) {
1505                         print "SIZEOF($1)\n" if ($dbg_values > 1);
1506                         if (defined $2) {
1507                                 $av_pending = 'V';
1508                         }
1509                         $type = 'N';
1510
1511                 } elsif ($cur =~ /^(if|while|for)\b/o) {
1512                         print "COND($1)\n" if ($dbg_values > 1);
1513                         $av_pending = 'E';
1514                         $type = 'N';
1515
1516                 } elsif ($cur =~/^(case)/o) {
1517                         print "CASE($1)\n" if ($dbg_values > 1);
1518                         $av_pend_colon = 'C';
1519                         $type = 'N';
1520
1521                 } elsif ($cur =~/^(return|else|goto|typeof|__typeof__)\b/o) {
1522                         print "KEYWORD($1)\n" if ($dbg_values > 1);
1523                         $type = 'N';
1524
1525                 } elsif ($cur =~ /^(\()/o) {
1526                         print "PAREN('$1')\n" if ($dbg_values > 1);
1527                         push(@av_paren_type, $av_pending);
1528                         $av_pending = '_';
1529                         $type = 'N';
1530
1531                 } elsif ($cur =~ /^(\))/o) {
1532                         my $new_type = pop(@av_paren_type);
1533                         if ($new_type ne '_') {
1534                                 $type = $new_type;
1535                                 print "PAREN('$1') -> $type\n"
1536                                                         if ($dbg_values > 1);
1537                         } else {
1538                                 print "PAREN('$1')\n" if ($dbg_values > 1);
1539                         }
1540
1541                 } elsif ($cur =~ /^($Ident)\s*\(/o) {
1542                         print "FUNC($1)\n" if ($dbg_values > 1);
1543                         $type = 'V';
1544                         $av_pending = 'V';
1545
1546                 } elsif ($cur =~ /^($Ident\s*):(?:\s*\d+\s*(,|=|;))?/) {
1547                         if (defined $2 && $type eq 'C' || $type eq 'T') {
1548                                 $av_pend_colon = 'B';
1549                         } elsif ($type eq 'E') {
1550                                 $av_pend_colon = 'L';
1551                         }
1552                         print "IDENT_COLON($1,$type>$av_pend_colon)\n" if ($dbg_values > 1);
1553                         $type = 'V';
1554
1555                 } elsif ($cur =~ /^($Ident|$Constant)/o) {
1556                         print "IDENT($1)\n" if ($dbg_values > 1);
1557                         $type = 'V';
1558
1559                 } elsif ($cur =~ /^($Assignment)/o) {
1560                         print "ASSIGN($1)\n" if ($dbg_values > 1);
1561                         $type = 'N';
1562
1563                 } elsif ($cur =~/^(;|{|})/) {
1564                         print "END($1)\n" if ($dbg_values > 1);
1565                         $type = 'E';
1566                         $av_pend_colon = 'O';
1567
1568                 } elsif ($cur =~/^(,)/) {
1569                         print "COMMA($1)\n" if ($dbg_values > 1);
1570                         $type = 'C';
1571
1572                 } elsif ($cur =~ /^(\?)/o) {
1573                         print "QUESTION($1)\n" if ($dbg_values > 1);
1574                         $type = 'N';
1575
1576                 } elsif ($cur =~ /^(:)/o) {
1577                         print "COLON($1,$av_pend_colon)\n" if ($dbg_values > 1);
1578
1579                         substr($var, length($res), 1, $av_pend_colon);
1580                         if ($av_pend_colon eq 'C' || $av_pend_colon eq 'L') {
1581                                 $type = 'E';
1582                         } else {
1583                                 $type = 'N';
1584                         }
1585                         $av_pend_colon = 'O';
1586
1587                 } elsif ($cur =~ /^(\[)/o) {
1588                         print "CLOSE($1)\n" if ($dbg_values > 1);
1589                         $type = 'N';
1590
1591                 } elsif ($cur =~ /^(-(?![->])|\+(?!\+)|\*|\&\&|\&)/o) {
1592                         my $variant;
1593
1594                         print "OPV($1)\n" if ($dbg_values > 1);
1595                         if ($type eq 'V') {
1596                                 $variant = 'B';
1597                         } else {
1598                                 $variant = 'U';
1599                         }
1600
1601                         substr($var, length($res), 1, $variant);
1602                         $type = 'N';
1603
1604                 } elsif ($cur =~ /^($Operators)/o) {
1605                         print "OP($1)\n" if ($dbg_values > 1);
1606                         if ($1 ne '++' && $1 ne '--') {
1607                                 $type = 'N';
1608                         }
1609
1610                 } elsif ($cur =~ /(^.)/o) {
1611                         print "C($1)\n" if ($dbg_values > 1);
1612                 }
1613                 if (defined $1) {
1614                         $cur = substr($cur, length($1));
1615                         $res .= $type x length($1);
1616                 }
1617         }
1618
1619         return ($res, $var);
1620 }
1621
1622 sub possible {
1623         my ($possible, $line) = @_;
1624         my $notPermitted = qr{(?:
1625                 ^(?:
1626                         $Modifier|
1627                         $Storage|
1628                         $Type|
1629                         DEFINE_\S+
1630                 )$|
1631                 ^(?:
1632                         goto|
1633                         return|
1634                         case|
1635                         else|
1636                         asm|__asm__|
1637                         do|
1638                         \#|
1639                         \#\#|
1640                 )(?:\s|$)|
1641                 ^(?:typedef|struct|enum)\b
1642             )}x;
1643         warn "CHECK<$possible> ($line)\n" if ($dbg_possible > 2);
1644         if ($possible !~ $notPermitted) {
1645                 # Check for modifiers.
1646                 $possible =~ s/\s*$Storage\s*//g;
1647                 $possible =~ s/\s*$Sparse\s*//g;
1648                 if ($possible =~ /^\s*$/) {
1649
1650                 } elsif ($possible =~ /\s/) {
1651                         $possible =~ s/\s*$Type\s*//g;
1652                         for my $modifier (split(' ', $possible)) {
1653                                 if ($modifier !~ $notPermitted) {
1654                                         warn "MODIFIER: $modifier ($possible) ($line)\n" if ($dbg_possible);
1655                                         push(@modifierListFile, $modifier);
1656                                 }
1657                         }
1658
1659                 } else {
1660                         warn "POSSIBLE: $possible ($line)\n" if ($dbg_possible);
1661                         push(@typeListFile, $possible);
1662                 }
1663                 build_types();
1664         } else {
1665                 warn "NOTPOSS: $possible ($line)\n" if ($dbg_possible > 1);
1666         }
1667 }
1668
1669 my $prefix = '';
1670
1671 sub show_type {
1672         my ($type) = @_;
1673
1674         return defined $use_type{$type} if (scalar keys %use_type > 0);
1675
1676         return !defined $ignore_type{$type};
1677 }
1678
1679 sub report {
1680         my ($level, $type, $msg) = @_;
1681
1682         if (!show_type($type) ||
1683             (defined $tst_only && $msg !~ /\Q$tst_only\E/)) {
1684                 return 0;
1685         }
1686         my $output = '';
1687         if (-t STDOUT && $color) {
1688                 if ($level eq 'ERROR') {
1689                         $output .= RED;
1690                 } elsif ($level eq 'WARNING') {
1691                         $output .= YELLOW;
1692                 } else {
1693                         $output .= GREEN;
1694                 }
1695         }
1696         $output .= $prefix . $level . ':';
1697         if ($show_types) {
1698                 $output .= BLUE if (-t STDOUT && $color);
1699                 $output .= "$type:";
1700         }
1701         $output .= RESET if (-t STDOUT && $color);
1702         $output .= ' ' . $msg . "\n";
1703
1704         if ($showfile) {
1705                 my @lines = split("\n", $output, -1);
1706                 splice(@lines, 1, 1);
1707                 $output = join("\n", @lines);
1708         }
1709         $output = (split('\n', $output))[0] . "\n" if ($terse);
1710
1711         push(our @report, $output);
1712
1713         return 1;
1714 }
1715
1716 sub report_dump {
1717         our @report;
1718 }
1719
1720 sub fixup_current_range {
1721         my ($lineRef, $offset, $length) = @_;
1722
1723         if ($$lineRef =~ /^\@\@ -\d+,\d+ \+(\d+),(\d+) \@\@/) {
1724                 my $o = $1;
1725                 my $l = $2;
1726                 my $no = $o + $offset;
1727                 my $nl = $l + $length;
1728                 $$lineRef =~ s/\+$o,$l \@\@/\+$no,$nl \@\@/;
1729         }
1730 }
1731
1732 sub fix_inserted_deleted_lines {
1733         my ($linesRef, $insertedRef, $deletedRef) = @_;
1734
1735         my $range_last_linenr = 0;
1736         my $delta_offset = 0;
1737
1738         my $old_linenr = 0;
1739         my $new_linenr = 0;
1740
1741         my $next_insert = 0;
1742         my $next_delete = 0;
1743
1744         my @lines = ();
1745
1746         my $inserted = @{$insertedRef}[$next_insert++];
1747         my $deleted = @{$deletedRef}[$next_delete++];
1748
1749         foreach my $old_line (@{$linesRef}) {
1750                 my $save_line = 1;
1751                 my $line = $old_line;   #don't modify the array
1752                 if ($line =~ /^(?:\+\+\+|\-\-\-)\s+\S+/) {      #new filename
1753                         $delta_offset = 0;
1754                 } elsif ($line =~ /^\@\@ -\d+,\d+ \+\d+,\d+ \@\@/) {    #new hunk
1755                         $range_last_linenr = $new_linenr;
1756                         fixup_current_range(\$line, $delta_offset, 0);
1757                 }
1758
1759                 while (defined($deleted) && ${$deleted}{'LINENR'} == $old_linenr) {
1760                         $deleted = @{$deletedRef}[$next_delete++];
1761                         $save_line = 0;
1762                         fixup_current_range(\$lines[$range_last_linenr], $delta_offset--, -1);
1763                 }
1764
1765                 while (defined($inserted) && ${$inserted}{'LINENR'} == $old_linenr) {
1766                         push(@lines, ${$inserted}{'LINE'});
1767                         $inserted = @{$insertedRef}[$next_insert++];
1768                         $new_linenr++;
1769                         fixup_current_range(\$lines[$range_last_linenr], $delta_offset++, 1);
1770                 }
1771
1772                 if ($save_line) {
1773                         push(@lines, $line);
1774                         $new_linenr++;
1775                 }
1776
1777                 $old_linenr++;
1778         }
1779
1780         return @lines;
1781 }
1782
1783 sub fix_insert_line {
1784         my ($linenr, $line) = @_;
1785
1786         my $inserted = {
1787                 LINENR => $linenr,
1788                 LINE => $line,
1789         };
1790         push(@fixed_inserted, $inserted);
1791 }
1792
1793 sub fix_delete_line {
1794         my ($linenr, $line) = @_;
1795
1796         my $deleted = {
1797                 LINENR => $linenr,
1798                 LINE => $line,
1799         };
1800
1801         push(@fixed_deleted, $deleted);
1802 }
1803
1804 sub ERROR {
1805         my ($type, $msg) = @_;
1806
1807         if (report("ERROR", $type, $msg)) {
1808                 our $clean = 0;
1809                 our $cnt_error++;
1810                 return 1;
1811         }
1812         return 0;
1813 }
1814 sub WARN {
1815         my ($type, $msg) = @_;
1816
1817         if (report("WARNING", $type, $msg)) {
1818                 our $clean = 0;
1819                 our $cnt_warn++;
1820                 return 1;
1821         }
1822         return 0;
1823 }
1824 sub CHK {
1825         my ($type, $msg) = @_;
1826
1827         if ($check && report("CHECK", $type, $msg)) {
1828                 our $clean = 0;
1829                 our $cnt_chk++;
1830                 return 1;
1831         }
1832         return 0;
1833 }
1834
1835 sub check_absolute_file {
1836         my ($absolute, $herecurr) = @_;
1837         my $file = $absolute;
1838
1839         ##print "absolute<$absolute>\n";
1840
1841         # See if any suffix of this path is a path within the tree.
1842         while ($file =~ s@^[^/]*/@@) {
1843                 if (-f "$root/$file") {
1844                         ##print "file<$file>\n";
1845                         last;
1846                 }
1847         }
1848         if (! -f _)  {
1849                 return 0;
1850         }
1851
1852         # It is, so see if the prefix is acceptable.
1853         my $prefix = $absolute;
1854         substr($prefix, -length($file)) = '';
1855
1856         ##print "prefix<$prefix>\n";
1857         if ($prefix ne ".../") {
1858                 WARN("USE_RELATIVE_PATH",
1859                      "use relative pathname instead of absolute in changelog text\n" . $herecurr);
1860         }
1861 }
1862
1863 sub trim {
1864         my ($string) = @_;
1865
1866         $string =~ s/^\s+|\s+$//g;
1867
1868         return $string;
1869 }
1870
1871 sub ltrim {
1872         my ($string) = @_;
1873
1874         $string =~ s/^\s+//;
1875
1876         return $string;
1877 }
1878
1879 sub rtrim {
1880         my ($string) = @_;
1881
1882         $string =~ s/\s+$//;
1883
1884         return $string;
1885 }
1886
1887 sub string_find_replace {
1888         my ($string, $find, $replace) = @_;
1889
1890         $string =~ s/$find/$replace/g;
1891
1892         return $string;
1893 }
1894
1895 sub tabify {
1896         my ($leading) = @_;
1897
1898         my $source_indent = 8;
1899         my $max_spaces_before_tab = $source_indent - 1;
1900         my $spaces_to_tab = " " x $source_indent;
1901
1902         #convert leading spaces to tabs
1903         1 while $leading =~ s@^([\t]*)$spaces_to_tab@$1\t@g;
1904         #Remove spaces before a tab
1905         1 while $leading =~ s@^([\t]*)( {1,$max_spaces_before_tab})\t@$1\t@g;
1906
1907         return "$leading";
1908 }
1909
1910 sub pos_last_openparen {
1911         my ($line) = @_;
1912
1913         my $pos = 0;
1914
1915         my $opens = $line =~ tr/\(/\(/;
1916         my $closes = $line =~ tr/\)/\)/;
1917
1918         my $last_openparen = 0;
1919
1920         if (($opens == 0) || ($closes >= $opens)) {
1921                 return -1;
1922         }
1923
1924         my $len = length($line);
1925
1926         for ($pos = 0; $pos < $len; $pos++) {
1927                 my $string = substr($line, $pos);
1928                 if ($string =~ /^($FuncArg|$balanced_parens)/) {
1929                         $pos += length($1) - 1;
1930                 } elsif (substr($line, $pos, 1) eq '(') {
1931                         $last_openparen = $pos;
1932                 } elsif (index($string, '(') == -1) {
1933                         last;
1934                 }
1935         }
1936
1937         return length(expand_tabs(substr($line, 0, $last_openparen))) + 1;
1938 }
1939
1940 sub process {
1941         my $filename = shift;
1942
1943         my $linenr=0;
1944         my $prevline="";
1945         my $prevrawline="";
1946         my $stashline="";
1947         my $stashrawline="";
1948
1949         my $length;
1950         my $indent;
1951         my $previndent=0;
1952         my $stashindent=0;
1953
1954         our $clean = 1;
1955         my $signoff = 0;
1956         my $is_patch = 0;
1957         my $in_header_lines = $file ? 0 : 1;
1958         my $in_commit_log = 0;          #Scanning lines before patch
1959        my $commit_log_possible_stack_dump = 0;
1960         my $commit_log_long_line = 0;
1961         my $commit_log_has_diff = 0;
1962         my $reported_maintainer_file = 0;
1963         my $non_utf8_charset = 0;
1964
1965         my $last_blank_line = 0;
1966         my $last_coalesced_string_linenr = -1;
1967
1968         our @report = ();
1969         our $cnt_lines = 0;
1970         our $cnt_error = 0;
1971         our $cnt_warn = 0;
1972         our $cnt_chk = 0;
1973
1974         # Trace the real file/line as we go.
1975         my $realfile = '';
1976         my $realline = 0;
1977         my $realcnt = 0;
1978         my $here = '';
1979         my $in_comment = 0;
1980         my $comment_edge = 0;
1981         my $first_line = 0;
1982         my $p1_prefix = '';
1983
1984         my $prev_values = 'E';
1985
1986         # suppression flags
1987         my %suppress_ifbraces;
1988         my %suppress_whiletrailers;
1989         my %suppress_export;
1990         my $suppress_statement = 0;
1991
1992         my %signatures = ();
1993
1994         # Pre-scan the patch sanitizing the lines.
1995         # Pre-scan the patch looking for any __setup documentation.
1996         #
1997         my @setup_docs = ();
1998         my $setup_docs = 0;
1999
2000         my $camelcase_file_seeded = 0;
2001
2002         sanitise_line_reset();
2003         my $line;
2004         foreach my $rawline (@rawlines) {
2005                 $linenr++;
2006                 $line = $rawline;
2007
2008                 push(@fixed, $rawline) if ($fix);
2009
2010                 if ($rawline=~/^\+\+\+\s+(\S+)/) {
2011                         $setup_docs = 0;
2012                         if ($1 =~ m@Documentation/kernel-parameters.txt$@) {
2013                                 $setup_docs = 1;
2014                         }
2015                         #next;
2016                 }
2017                 if ($rawline=~/^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@/) {
2018                         $realline=$1-1;
2019                         if (defined $2) {
2020                                 $realcnt=$3+1;
2021                         } else {
2022                                 $realcnt=1+1;
2023                         }
2024                         $in_comment = 0;
2025
2026                         # Guestimate if this is a continuing comment.  Run
2027                         # the context looking for a comment "edge".  If this
2028                         # edge is a close comment then we must be in a comment
2029                         # at context start.
2030                         my $edge;
2031                         my $cnt = $realcnt;
2032                         for (my $ln = $linenr + 1; $cnt > 0; $ln++) {
2033                                 next if (defined $rawlines[$ln - 1] &&
2034                                          $rawlines[$ln - 1] =~ /^-/);
2035                                 $cnt--;
2036                                 #print "RAW<$rawlines[$ln - 1]>\n";
2037                                 last if (!defined $rawlines[$ln - 1]);
2038                                 if ($rawlines[$ln - 1] =~ m@(/\*|\*/)@ &&
2039                                     $rawlines[$ln - 1] !~ m@"[^"]*(?:/\*|\*/)[^"]*"@) {
2040                                         ($edge) = $1;
2041                                         last;
2042                                 }
2043                         }
2044                         if (defined $edge && $edge eq '*/') {
2045                                 $in_comment = 1;
2046                         }
2047
2048                         # Guestimate if this is a continuing comment.  If this
2049                         # is the start of a diff block and this line starts
2050                         # ' *' then it is very likely a comment.
2051                         if (!defined $edge &&
2052                             $rawlines[$linenr] =~ m@^.\s*(?:\*\*+| \*)(?:\s|$)@)
2053                         {
2054                                 $in_comment = 1;
2055                         }
2056
2057                         ##print "COMMENT:$in_comment edge<$edge> $rawline\n";
2058                         sanitise_line_reset($in_comment);
2059
2060                 } elsif ($realcnt && $rawline =~ /^(?:\+| |$)/) {
2061                         # Standardise the strings and chars within the input to
2062                         # simplify matching -- only bother with positive lines.
2063                         $line = sanitise_line($rawline);
2064                 }
2065                 push(@lines, $line);
2066
2067                 if ($realcnt > 1) {
2068                         $realcnt-- if ($line =~ /^(?:\+| |$)/);
2069                 } else {
2070                         $realcnt = 0;
2071                 }
2072
2073                 #print "==>$rawline\n";
2074                 #print "-->$line\n";
2075
2076                 if ($setup_docs && $line =~ /^\+/) {
2077                         push(@setup_docs, $line);
2078                 }
2079         }
2080
2081         $prefix = '';
2082
2083         $realcnt = 0;
2084         $linenr = 0;
2085         $fixlinenr = -1;
2086         foreach my $line (@lines) {
2087                 $linenr++;
2088                 $fixlinenr++;
2089                 my $sline = $line;      #copy of $line
2090                 $sline =~ s/$;/ /g;     #with comments as spaces
2091
2092                 my $rawline = $rawlines[$linenr - 1];
2093
2094 #extract the line range in the file after the patch is applied
2095                 if (!$in_commit_log &&
2096                     $line =~ /^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@/) {
2097                         $is_patch = 1;
2098                         $first_line = $linenr + 1;
2099                         $realline=$1-1;
2100                         if (defined $2) {
2101                                 $realcnt=$3+1;
2102                         } else {
2103                                 $realcnt=1+1;
2104                         }
2105                         annotate_reset();
2106                         $prev_values = 'E';
2107
2108                         %suppress_ifbraces = ();
2109                         %suppress_whiletrailers = ();
2110                         %suppress_export = ();
2111                         $suppress_statement = 0;
2112                         next;
2113
2114 # track the line number as we move through the hunk, note that
2115 # new versions of GNU diff omit the leading space on completely
2116 # blank context lines so we need to count that too.
2117                 } elsif ($line =~ /^( |\+|$)/) {
2118                         $realline++;
2119                         $realcnt-- if ($realcnt != 0);
2120
2121                         # Measure the line length and indent.
2122                         ($length, $indent) = line_stats($rawline);
2123
2124                         # Track the previous line.
2125                         ($prevline, $stashline) = ($stashline, $line);
2126                         ($previndent, $stashindent) = ($stashindent, $indent);
2127                         ($prevrawline, $stashrawline) = ($stashrawline, $rawline);
2128
2129                         #warn "line<$line>\n";
2130
2131                 } elsif ($realcnt == 1) {
2132                         $realcnt--;
2133                 }
2134
2135                 my $hunk_line = ($realcnt != 0);
2136
2137                 $here = "#$linenr: " if (!$file);
2138                 $here = "#$realline: " if ($file);
2139
2140                 my $found_file = 0;
2141                 # extract the filename as it passes
2142                 if ($line =~ /^diff --git.*?(\S+)$/) {
2143                         $realfile = $1;
2144                         $realfile =~ s@^([^/]*)/@@ if (!$file);
2145                         $in_commit_log = 0;
2146                         $found_file = 1;
2147                 } elsif ($line =~ /^\+\+\+\s+(\S+)/) {
2148                         $realfile = $1;
2149                         $realfile =~ s@^([^/]*)/@@ if (!$file);
2150                         $in_commit_log = 0;
2151
2152                         $p1_prefix = $1;
2153                         if (!$file && $tree && $p1_prefix ne '' &&
2154                             -e "$root/$p1_prefix") {
2155                                 WARN("PATCH_PREFIX",
2156                                      "patch prefix '$p1_prefix' exists, appears to be a -p0 patch\n");
2157                         }
2158
2159                         if ($realfile =~ m@^include/asm/@) {
2160                                 ERROR("MODIFIED_INCLUDE_ASM",
2161                                       "do not modify files in include/asm, change architecture specific files in include/asm-<architecture>\n" . "$here$rawline\n");
2162                         }
2163                         $found_file = 1;
2164                 }
2165
2166 #make up the handle for any error we report on this line
2167                 if ($showfile) {
2168                         $prefix = "$realfile:$realline: "
2169                 } elsif ($emacs) {
2170                         if ($file) {
2171                                 $prefix = "$filename:$realline: ";
2172                         } else {
2173                                 $prefix = "$filename:$linenr: ";
2174                         }
2175                 }
2176
2177                 if ($found_file) {
2178                         if ($realfile =~ m@^(?:drivers/net/|net/|drivers/staging/)@) {
2179                                 $check = 1;
2180                         } else {
2181                                 $check = $check_orig;
2182                         }
2183                         next;
2184                 }
2185
2186                 $here .= "FILE: $realfile:$realline:" if ($realcnt != 0);
2187
2188                 my $hereline = "$here\n$rawline\n";
2189                 my $herecurr = "$here\n$rawline\n";
2190                 my $hereprev = "$here\n$prevrawline\n$rawline\n";
2191
2192                 $cnt_lines++ if ($realcnt != 0);
2193
2194 # Check if the commit log has what seems like a diff which can confuse patch
2195                 if ($in_commit_log && !$commit_log_has_diff &&
2196                     (($line =~ m@^\s+diff\b.*a/[\w/]+@ &&
2197                       $line =~ m@^\s+diff\b.*a/([\w/]+)\s+b/$1\b@) ||
2198                      $line =~ m@^\s*(?:\-\-\-\s+a/|\+\+\+\s+b/)@ ||
2199                      $line =~ m/^\s*\@\@ \-\d+,\d+ \+\d+,\d+ \@\@/)) {
2200                         ERROR("DIFF_IN_COMMIT_MSG",
2201                               "Avoid using diff content in the commit message - patch(1) might not work\n" . $herecurr);
2202                         $commit_log_has_diff = 1;
2203                 }
2204
2205 # Check for incorrect file permissions
2206                 if ($line =~ /^new (file )?mode.*[7531]\d{0,2}$/) {
2207                         my $permhere = $here . "FILE: $realfile\n";
2208                         if ($realfile !~ m@scripts/@ &&
2209                             $realfile !~ /\.(py|pl|awk|sh)$/) {
2210                                 ERROR("EXECUTE_PERMISSIONS",
2211                                       "do not set execute permissions for source files\n" . $permhere);
2212                         }
2213                 }
2214
2215 # Check the patch for a signoff:
2216                 if ($line =~ /^\s*signed-off-by:/i) {
2217                         $signoff++;
2218                         $in_commit_log = 0;
2219                 }
2220
2221 # Check if MAINTAINERS is being updated.  If so, there's probably no need to
2222 # emit the "does MAINTAINERS need updating?" message on file add/move/delete
2223                 if ($line =~ /^\s*MAINTAINERS\s*\|/) {
2224                         $reported_maintainer_file = 1;
2225                 }
2226
2227 # Check signature styles
2228                 if (!$in_header_lines &&
2229                     $line =~ /^(\s*)([a-z0-9_-]+by:|$signature_tags)(\s*)(.*)/i) {
2230                         my $space_before = $1;
2231                         my $sign_off = $2;
2232                         my $space_after = $3;
2233                         my $email = $4;
2234                         my $ucfirst_sign_off = ucfirst(lc($sign_off));
2235
2236                         if ($sign_off !~ /$signature_tags/) {
2237                                 WARN("BAD_SIGN_OFF",
2238                                      "Non-standard signature: $sign_off\n" . $herecurr);
2239                         }
2240                         if (defined $space_before && $space_before ne "") {
2241                                 if (WARN("BAD_SIGN_OFF",
2242                                          "Do not use whitespace before $ucfirst_sign_off\n" . $herecurr) &&
2243                                     $fix) {
2244                                         $fixed[$fixlinenr] =
2245                                             "$ucfirst_sign_off $email";
2246                                 }
2247                         }
2248                         if ($sign_off =~ /-by:$/i && $sign_off ne $ucfirst_sign_off) {
2249                                 if (WARN("BAD_SIGN_OFF",
2250                                          "'$ucfirst_sign_off' is the preferred signature form\n" . $herecurr) &&
2251                                     $fix) {
2252                                         $fixed[$fixlinenr] =
2253                                             "$ucfirst_sign_off $email";
2254                                 }
2255
2256                         }
2257                         if (!defined $space_after || $space_after ne " ") {
2258                                 if (WARN("BAD_SIGN_OFF",
2259                                          "Use a single space after $ucfirst_sign_off\n" . $herecurr) &&
2260                                     $fix) {
2261                                         $fixed[$fixlinenr] =
2262                                             "$ucfirst_sign_off $email";
2263                                 }
2264                         }
2265
2266                         my ($email_name, $email_address, $comment) = parse_email($email);
2267                         my $suggested_email = format_email(($email_name, $email_address));
2268                         if ($suggested_email eq "") {
2269                                 ERROR("BAD_SIGN_OFF",
2270                                       "Unrecognized email address: '$email'\n" . $herecurr);
2271                         } else {
2272                                 my $dequoted = $suggested_email;
2273                                 $dequoted =~ s/^"//;
2274                                 $dequoted =~ s/" </ </;
2275                                 # Don't force email to have quotes
2276                                 # Allow just an angle bracketed address
2277                                 if ("$dequoted$comment" ne $email &&
2278                                     "<$email_address>$comment" ne $email &&
2279                                     "$suggested_email$comment" ne $email) {
2280                                         WARN("BAD_SIGN_OFF",
2281                                              "email address '$email' might be better as '$suggested_email$comment'\n" . $herecurr);
2282                                 }
2283                         }
2284
2285 # Check for duplicate signatures
2286                         my $sig_nospace = $line;
2287                         $sig_nospace =~ s/\s//g;
2288                         $sig_nospace = lc($sig_nospace);
2289                         if (defined $signatures{$sig_nospace}) {
2290                                 WARN("BAD_SIGN_OFF",
2291                                      "Duplicate signature\n" . $herecurr);
2292                         } else {
2293                                 $signatures{$sig_nospace} = 1;
2294                         }
2295                 }
2296
2297 # Check email subject for common tools that don't need to be mentioned
2298                 if ($in_header_lines &&
2299                     $line =~ /^Subject:.*\b(?:checkpatch|sparse|smatch)\b[^:]/i) {
2300                         WARN("EMAIL_SUBJECT",
2301                              "A patch subject line should describe the change not the tool that found it\n" . $herecurr);
2302                 }
2303
2304 # Check for old stable address
2305                 if ($line =~ /^\s*cc:\s*.*<?\bstable\@kernel\.org\b>?.*$/i) {
2306                         ERROR("STABLE_ADDRESS",
2307                               "The 'stable' address should be 'stable\@vger.kernel.org'\n" . $herecurr);
2308                 }
2309
2310 # Check for unwanted Gerrit info
2311                 if ($in_commit_log && $line =~ /^\s*change-id:/i) {
2312                         ERROR("GERRIT_CHANGE_ID",
2313                               "Remove Gerrit Change-Id's before submitting upstream.\n" . $herecurr);
2314                 }
2315
2316 # Check for line lengths > 75 in commit log, warn once
2317                 if ($in_commit_log && !$commit_log_long_line &&
2318                    length($line) > 75 &&
2319                    !($line =~ /^\s*[a-zA-Z0-9_\/\.]+\s+\|\s+\d+/ ||
2320                                        # file delta changes
2321                      $line =~ /^\s*(?:[\w\.\-]+\/)++[\w\.\-]+:/ ||
2322                                        # filename then :
2323                      $line =~ /^\s*(?:Fixes:|Link:)/i ||
2324                                        # A Fixes: or Link: line
2325                      $commit_log_possible_stack_dump)) {
2326                         WARN("COMMIT_LOG_LONG_LINE",
2327                              "Possible unwrapped commit description (prefer a maximum 75 chars per line)\n" . $herecurr);
2328                         $commit_log_long_line = 1;
2329                 }
2330
2331 # Check if the commit log is in a possible stack dump
2332                if ($in_commit_log && !$commit_log_possible_stack_dump &&
2333                    ($line =~ /^\s*(?:WARNING:|BUG:)/ ||
2334                     $line =~ /^\s*\[\s*\d+\.\d{6,6}\s*\]/ ||
2335                                # timestamp
2336                     $line =~ /^\s*\[\<[0-9a-fA-F]{8,}\>\]/)) {
2337                                # stack dump address
2338                        $commit_log_possible_stack_dump = 1;
2339                }
2340
2341 # Reset possible stack dump if a blank line is found
2342                if ($in_commit_log && $commit_log_possible_stack_dump &&
2343                    $line =~ /^\s*$/) {
2344                        $commit_log_possible_stack_dump = 0;
2345                }
2346
2347 # Check for git id commit length and improperly formed commit descriptions
2348                 if ($in_commit_log &&
2349                     ($line =~ /\bcommit\s+[0-9a-f]{5,}\b/i ||
2350                     ($line =~ /\b[0-9a-f]{12,40}\b/i &&
2351                      $line !~ /\bfixes:\s*[0-9a-f]{12,40}/i))) {
2352                         my $init_char = "c";
2353                         my $orig_commit = "";
2354                         my $short = 1;
2355                         my $long = 0;
2356                         my $case = 1;
2357                         my $space = 1;
2358                         my $hasdesc = 0;
2359                         my $hasparens = 0;
2360                         my $id = '0123456789ab';
2361                         my $orig_desc = "commit description";
2362                         my $description = "";
2363
2364                         if ($line =~ /\b(c)ommit\s+([0-9a-f]{5,})\b/i) {
2365                                 $init_char = $1;
2366                                 $orig_commit = lc($2);
2367                         } elsif ($line =~ /\b([0-9a-f]{12,40})\b/i) {
2368                                 $orig_commit = lc($1);
2369                         }
2370
2371                         $short = 0 if ($line =~ /\bcommit\s+[0-9a-f]{12,40}/i);
2372                         $long = 1 if ($line =~ /\bcommit\s+[0-9a-f]{41,}/i);
2373                         $space = 0 if ($line =~ /\bcommit [0-9a-f]/i);
2374                         $case = 0 if ($line =~ /\b[Cc]ommit\s+[0-9a-f]{5,40}[^A-F]/);
2375                         if ($line =~ /\bcommit\s+[0-9a-f]{5,}\s+\("([^"]+)"\)/i) {
2376                                 $orig_desc = $1;
2377                                 $hasparens = 1;
2378                         } elsif ($line =~ /\bcommit\s+[0-9a-f]{5,}\s*$/i &&
2379                                  defined $rawlines[$linenr] &&
2380                                  $rawlines[$linenr] =~ /^\s*\("([^"]+)"\)/) {
2381                                 $orig_desc = $1;
2382                                 $hasparens = 1;
2383                         } elsif ($line =~ /\bcommit\s+[0-9a-f]{5,}\s+\("[^"]+$/i &&
2384                                  defined $rawlines[$linenr] &&
2385                                  $rawlines[$linenr] =~ /^\s*[^"]+"\)/) {
2386                                 $line =~ /\bcommit\s+[0-9a-f]{5,}\s+\("([^"]+)$/i;
2387                                 $orig_desc = $1;
2388                                 $rawlines[$linenr] =~ /^\s*([^"]+)"\)/;
2389                                 $orig_desc .= " " . $1;
2390                                 $hasparens = 1;
2391                         }
2392
2393                         ($id, $description) = git_commit_info($orig_commit,
2394                                                               $id, $orig_desc);
2395
2396                         if ($short || $long || $space || $case || ($orig_desc ne $description) || !$hasparens) {
2397                                 ERROR("GIT_COMMIT_ID",
2398                                       "Please use git commit description style 'commit <12+ chars of sha1> (\"<title line>\")' - ie: '${init_char}ommit $id (\"$description\")'\n" . $herecurr);
2399                         }
2400                 }
2401
2402 # Check for added, moved or deleted files
2403                 if (!$reported_maintainer_file && !$in_commit_log &&
2404                     ($line =~ /^(?:new|deleted) file mode\s*\d+\s*$/ ||
2405                      $line =~ /^rename (?:from|to) [\w\/\.\-]+\s*$/ ||
2406                      ($line =~ /\{\s*([\w\/\.\-]*)\s*\=\>\s*([\w\/\.\-]*)\s*\}/ &&
2407                       (defined($1) || defined($2))))) {
2408                         $reported_maintainer_file = 1;
2409                         WARN("FILE_PATH_CHANGES",
2410                              "added, moved or deleted file(s), does MAINTAINERS need updating?\n" . $herecurr);
2411                 }
2412
2413 # Check for wrappage within a valid hunk of the file
2414                 if ($realcnt != 0 && $line !~ m{^(?:\+|-| |\\ No newline|$)}) {
2415                         ERROR("CORRUPTED_PATCH",
2416                               "patch seems to be corrupt (line wrapped?)\n" .
2417                                 $herecurr) if (!$emitted_corrupt++);
2418                 }
2419
2420 # Check for absolute kernel paths.
2421                 if ($tree) {
2422                         while ($line =~ m{(?:^|\s)(/\S*)}g) {
2423                                 my $file = $1;
2424
2425                                 if ($file =~ m{^(.*?)(?::\d+)+:?$} &&
2426                                     check_absolute_file($1, $herecurr)) {
2427                                         #
2428                                 } else {
2429                                         check_absolute_file($file, $herecurr);
2430                                 }
2431                         }
2432                 }
2433
2434 # UTF-8 regex found at http://www.w3.org/International/questions/qa-forms-utf-8.en.php
2435                 if (($realfile =~ /^$/ || $line =~ /^\+/) &&
2436                     $rawline !~ m/^$UTF8*$/) {
2437                         my ($utf8_prefix) = ($rawline =~ /^($UTF8*)/);
2438
2439                         my $blank = copy_spacing($rawline);
2440                         my $ptr = substr($blank, 0, length($utf8_prefix)) . "^";
2441                         my $hereptr = "$hereline$ptr\n";
2442
2443                         CHK("INVALID_UTF8",
2444                             "Invalid UTF-8, patch and commit message should be encoded in UTF-8\n" . $hereptr);
2445                 }
2446
2447 # Check if it's the start of a commit log
2448 # (not a header line and we haven't seen the patch filename)
2449                 if ($in_header_lines && $realfile =~ /^$/ &&
2450                     !($rawline =~ /^\s+\S/ ||
2451                       $rawline =~ /^(commit\b|from\b|[\w-]+:).*$/i)) {
2452                         $in_header_lines = 0;
2453                         $in_commit_log = 1;
2454                 }
2455
2456 # Check if there is UTF-8 in a commit log when a mail header has explicitly
2457 # declined it, i.e defined some charset where it is missing.
2458                 if ($in_header_lines &&
2459                     $rawline =~ /^Content-Type:.+charset="(.+)".*$/ &&
2460                     $1 !~ /utf-8/i) {
2461                         $non_utf8_charset = 1;
2462                 }
2463
2464                 if ($in_commit_log && $non_utf8_charset && $realfile =~ /^$/ &&
2465                     $rawline =~ /$NON_ASCII_UTF8/) {
2466                         WARN("UTF8_BEFORE_PATCH",
2467                             "8-bit UTF-8 used in possible commit log\n" . $herecurr);
2468                 }
2469
2470 # Check for various typo / spelling mistakes
2471                 if (defined($misspellings) &&
2472                     ($in_commit_log || $line =~ /^(?:\+|Subject:)/i)) {
2473                         while ($rawline =~ /(?:^|[^a-z@])($misspellings)(?:\b|$|[^a-z@])/gi) {
2474                                 my $typo = $1;
2475                                 my $typo_fix = $spelling_fix{lc($typo)};
2476                                 $typo_fix = ucfirst($typo_fix) if ($typo =~ /^[A-Z]/);
2477                                 $typo_fix = uc($typo_fix) if ($typo =~ /^[A-Z]+$/);
2478                                 my $msg_type = \&WARN;
2479                                 $msg_type = \&CHK if ($file);
2480                                 if (&{$msg_type}("TYPO_SPELLING",
2481                                                  "'$typo' may be misspelled - perhaps '$typo_fix'?\n" . $herecurr) &&
2482                                     $fix) {
2483                                         $fixed[$fixlinenr] =~ s/(^|[^A-Za-z@])($typo)($|[^A-Za-z@])/$1$typo_fix$3/;
2484                                 }
2485                         }
2486                 }
2487
2488 # ignore non-hunk lines and lines being removed
2489                 next if (!$hunk_line || $line =~ /^-/);
2490
2491 #trailing whitespace
2492                 if ($line =~ /^\+.*\015/) {
2493                         my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2494                         if (ERROR("DOS_LINE_ENDINGS",
2495                                   "DOS line endings\n" . $herevet) &&
2496                             $fix) {
2497                                 $fixed[$fixlinenr] =~ s/[\s\015]+$//;
2498                         }
2499                 } elsif ($rawline =~ /^\+.*\S\s+$/ || $rawline =~ /^\+\s+$/) {
2500                         my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2501                         if (ERROR("TRAILING_WHITESPACE",
2502                                   "trailing whitespace\n" . $herevet) &&
2503                             $fix) {
2504                                 $fixed[$fixlinenr] =~ s/\s+$//;
2505                         }
2506
2507                         $rpt_cleaners = 1;
2508                 }
2509
2510 # Check for FSF mailing addresses.
2511                 if ($rawline =~ /\bwrite to the Free/i ||
2512                     $rawline =~ /\b59\s+Temple\s+Pl/i ||
2513                     $rawline =~ /\b51\s+Franklin\s+St/i) {
2514                         my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2515                         my $msg_type = \&ERROR;
2516                         $msg_type = \&CHK if ($file);
2517                         &{$msg_type}("FSF_MAILING_ADDRESS",
2518                                      "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)
2519                 }
2520
2521 # check for Kconfig help text having a real description
2522 # Only applies when adding the entry originally, after that we do not have
2523 # sufficient context to determine whether it is indeed long enough.
2524                 if ($realfile =~ /Kconfig/ &&
2525                     $line =~ /^\+\s*config\s+/) {
2526                         my $length = 0;
2527                         my $cnt = $realcnt;
2528                         my $ln = $linenr + 1;
2529                         my $f;
2530                         my $is_start = 0;
2531                         my $is_end = 0;
2532                         for (; $cnt > 0 && defined $lines[$ln - 1]; $ln++) {
2533                                 $f = $lines[$ln - 1];
2534                                 $cnt-- if ($lines[$ln - 1] !~ /^-/);
2535                                 $is_end = $lines[$ln - 1] =~ /^\+/;
2536
2537                                 next if ($f =~ /^-/);
2538                                 last if (!$file && $f =~ /^\@\@/);
2539
2540                                 if ($lines[$ln - 1] =~ /^\+\s*(?:bool|tristate)\s*\"/) {
2541                                         $is_start = 1;
2542                                 } elsif ($lines[$ln - 1] =~ /^\+\s*(?:---)?help(?:---)?$/) {
2543                                         $length = -1;
2544                                 }
2545
2546                                 $f =~ s/^.//;
2547                                 $f =~ s/#.*//;
2548                                 $f =~ s/^\s+//;
2549                                 next if ($f =~ /^$/);
2550                                 if ($f =~ /^\s*config\s/) {
2551                                         $is_end = 1;
2552                                         last;
2553                                 }
2554                                 $length++;
2555                         }
2556                         if ($is_start && $is_end && $length < $min_conf_desc_length) {
2557                                 WARN("CONFIG_DESCRIPTION",
2558                                      "please write a paragraph that describes the config symbol fully\n" . $herecurr);
2559                         }
2560                         #print "is_start<$is_start> is_end<$is_end> length<$length>\n";
2561                 }
2562
2563 # discourage the addition of CONFIG_EXPERIMENTAL in Kconfig.
2564                 if ($realfile =~ /Kconfig/ &&
2565                     $line =~ /.\s*depends on\s+.*\bEXPERIMENTAL\b/) {
2566                         WARN("CONFIG_EXPERIMENTAL",
2567                              "Use of CONFIG_EXPERIMENTAL is deprecated. For alternatives, see https://lkml.org/lkml/2012/10/23/580\n");
2568                 }
2569
2570 # discourage the use of boolean for type definition attributes of Kconfig options
2571                 if ($realfile =~ /Kconfig/ &&
2572                     $line =~ /^\+\s*\bboolean\b/) {
2573                         WARN("CONFIG_TYPE_BOOLEAN",
2574                              "Use of boolean is deprecated, please use bool instead.\n" . $herecurr);
2575                 }
2576
2577                 if (($realfile =~ /Makefile.*/ || $realfile =~ /Kbuild.*/) &&
2578                     ($line =~ /\+(EXTRA_[A-Z]+FLAGS).*/)) {
2579                         my $flag = $1;
2580                         my $replacement = {
2581                                 'EXTRA_AFLAGS' =>   'asflags-y',
2582                                 'EXTRA_CFLAGS' =>   'ccflags-y',
2583                                 'EXTRA_CPPFLAGS' => 'cppflags-y',
2584                                 'EXTRA_LDFLAGS' =>  'ldflags-y',
2585                         };
2586
2587                         WARN("DEPRECATED_VARIABLE",
2588                              "Use of $flag is deprecated, please use \`$replacement->{$flag} instead.\n" . $herecurr) if ($replacement->{$flag});
2589                 }
2590
2591 # check for DT compatible documentation
2592                 if (defined $root &&
2593                         (($realfile =~ /\.dtsi?$/ && $line =~ /^\+\s*compatible\s*=\s*\"/) ||
2594                          ($realfile =~ /\.[ch]$/ && $line =~ /^\+.*\.compatible\s*=\s*\"/))) {
2595
2596                         my @compats = $rawline =~ /\"([a-zA-Z0-9\-\,\.\+_]+)\"/g;
2597
2598                         my $dt_path = $root . "/Documentation/devicetree/bindings/";
2599                         my $vp_file = $dt_path . "vendor-prefixes.txt";
2600
2601                         foreach my $compat (@compats) {
2602                                 my $compat2 = $compat;
2603                                 $compat2 =~ s/\,[a-zA-Z0-9]*\-/\,<\.\*>\-/;
2604                                 my $compat3 = $compat;
2605                                 $compat3 =~ s/\,([a-z]*)[0-9]*\-/\,$1<\.\*>\-/;
2606                                 `grep -Erq "$compat|$compat2|$compat3" $dt_path`;
2607                                 if ( $? >> 8 ) {
2608                                         WARN("UNDOCUMENTED_DT_STRING",
2609                                              "DT compatible string \"$compat\" appears un-documented -- check $dt_path\n" . $herecurr);
2610                                 }
2611
2612                                 next if $compat !~ /^([a-zA-Z0-9\-]+)\,/;
2613                                 my $vendor = $1;
2614                                 `grep -Eq "^$vendor\\b" $vp_file`;
2615                                 if ( $? >> 8 ) {
2616                                         WARN("UNDOCUMENTED_DT_STRING",
2617                                              "DT compatible string vendor \"$vendor\" appears un-documented -- check $vp_file\n" . $herecurr);
2618                                 }
2619                         }
2620                 }
2621
2622 # check we are in a valid source file if not then ignore this hunk
2623                 next if ($realfile !~ /\.(h|c|s|S|pl|sh|dtsi|dts)$/);
2624
2625 # line length limit (with some exclusions)
2626 #
2627 # There are a few types of lines that may extend beyond $max_line_length:
2628 #       logging functions like pr_info that end in a string
2629 #       lines with a single string
2630 #       #defines that are a single string
2631 #
2632 # There are 3 different line length message types:
2633 # LONG_LINE_COMMENT     a comment starts before but extends beyond $max_linelength
2634 # LONG_LINE_STRING      a string starts before but extends beyond $max_line_length
2635 # LONG_LINE             all other lines longer than $max_line_length
2636 #
2637 # if LONG_LINE is ignored, the other 2 types are also ignored
2638 #
2639
2640                 if ($line =~ /^\+/ && $length > $max_line_length) {
2641                         my $msg_type = "LONG_LINE";
2642
2643                         # Check the allowed long line types first
2644
2645                         # logging functions that end in a string that starts
2646                         # before $max_line_length
2647                         if ($line =~ /^\+\s*$logFunctions\s*\(\s*(?:(?:KERN_\S+\s*|[^"]*))?($String\s*(?:|,|\)\s*;)\s*)$/ &&
2648                             length(expand_tabs(substr($line, 1, length($line) - length($1) - 1))) <= $max_line_length) {
2649                                 $msg_type = "";
2650
2651                         # lines with only strings (w/ possible termination)
2652                         # #defines with only strings
2653                         } elsif ($line =~ /^\+\s*$String\s*(?:\s*|,|\)\s*;)\s*$/ ||
2654                                  $line =~ /^\+\s*#\s*define\s+\w+\s+$String$/) {
2655                                 $msg_type = "";
2656
2657                         # Otherwise set the alternate message types
2658
2659                         # a comment starts before $max_line_length
2660                         } elsif ($line =~ /($;[\s$;]*)$/ &&
2661                                  length(expand_tabs(substr($line, 1, length($line) - length($1) - 1))) <= $max_line_length) {
2662                                 $msg_type = "LONG_LINE_COMMENT"
2663
2664                         # a quoted string starts before $max_line_length
2665                         } elsif ($sline =~ /\s*($String(?:\s*(?:\\|,\s*|\)\s*;\s*))?)$/ &&
2666                                  length(expand_tabs(substr($line, 1, length($line) - length($1) - 1))) <= $max_line_length) {
2667                                 $msg_type = "LONG_LINE_STRING"
2668                         }
2669
2670                         if ($msg_type ne "" &&
2671                             (show_type("LONG_LINE") || show_type($msg_type))) {
2672                                 WARN($msg_type,
2673                                      "line over $max_line_length characters\n" . $herecurr);
2674                         }
2675                 }
2676
2677 # check for adding lines without a newline.
2678                 if ($line =~ /^\+/ && defined $lines[$linenr] && $lines[$linenr] =~ /^\\ No newline at end of file/) {
2679                         WARN("MISSING_EOF_NEWLINE",
2680                              "adding a line without newline at end of file\n" . $herecurr);
2681                 }
2682
2683 # Blackfin: use hi/lo macros
2684                 if ($realfile =~ m@arch/blackfin/.*\.S$@) {
2685                         if ($line =~ /\.[lL][[:space:]]*=.*&[[:space:]]*0x[fF][fF][fF][fF]/) {
2686                                 my $herevet = "$here\n" . cat_vet($line) . "\n";
2687                                 ERROR("LO_MACRO",
2688                                       "use the LO() macro, not (... & 0xFFFF)\n" . $herevet);
2689                         }
2690                         if ($line =~ /\.[hH][[:space:]]*=.*>>[[:space:]]*16/) {
2691                                 my $herevet = "$here\n" . cat_vet($line) . "\n";
2692                                 ERROR("HI_MACRO",
2693                                       "use the HI() macro, not (... >> 16)\n" . $herevet);
2694                         }
2695                 }
2696
2697 # check we are in a valid source file C or perl if not then ignore this hunk
2698                 next if ($realfile !~ /\.(h|c|pl|dtsi|dts)$/);
2699
2700 # at the beginning of a line any tabs must come first and anything
2701 # more than 8 must use tabs.
2702                 if ($rawline =~ /^\+\s* \t\s*\S/ ||
2703                     $rawline =~ /^\+\s*        \s*/) {
2704                         my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2705                         $rpt_cleaners = 1;
2706                         if (ERROR("CODE_INDENT",
2707                                   "code indent should use tabs where possible\n" . $herevet) &&
2708                             $fix) {
2709                                 $fixed[$fixlinenr] =~ s/^\+([ \t]+)/"\+" . tabify($1)/e;
2710                         }
2711                 }
2712
2713 # check for space before tabs.
2714                 if ($rawline =~ /^\+/ && $rawline =~ / \t/) {
2715                         my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2716                         if (WARN("SPACE_BEFORE_TAB",
2717                                 "please, no space before tabs\n" . $herevet) &&
2718                             $fix) {
2719                                 while ($fixed[$fixlinenr] =~
2720                                            s/(^\+.*) {8,8}\t/$1\t\t/) {}
2721                                 while ($fixed[$fixlinenr] =~
2722                                            s/(^\+.*) +\t/$1\t/) {}
2723                         }
2724                 }
2725
2726 # check for && or || at the start of a line
2727                 if ($rawline =~ /^\+\s*(&&|\|\|)/) {
2728                         CHK("LOGICAL_CONTINUATIONS",
2729                             "Logical continuations should be on the previous line\n" . $hereprev);
2730                 }
2731
2732 # check multi-line statement indentation matches previous line
2733                 if ($^V && $^V ge 5.10.0 &&
2734                     $prevline =~ /^\+([ \t]*)((?:$c90_Keywords(?:\s+if)\s*)|(?:$Declare\s*)?(?:$Ident|\(\s*\*\s*$Ident\s*\))\s*|$Ident\s*=\s*$Ident\s*)\(.*(\&\&|\|\||,)\s*$/) {
2735                         $prevline =~ /^\+(\t*)(.*)$/;
2736                         my $oldindent = $1;
2737                         my $rest = $2;
2738
2739                         my $pos = pos_last_openparen($rest);
2740                         if ($pos >= 0) {
2741                                 $line =~ /^(\+| )([ \t]*)/;
2742                                 my $newindent = $2;
2743
2744                                 my $goodtabindent = $oldindent .
2745                                         "\t" x ($pos / 8) .
2746                                         " "  x ($pos % 8);
2747                                 my $goodspaceindent = $oldindent . " "  x $pos;
2748
2749                                 if ($newindent ne $goodtabindent &&
2750                                     $newindent ne $goodspaceindent) {
2751
2752                                         if (CHK("PARENTHESIS_ALIGNMENT",
2753                                                 "Alignment should match open parenthesis\n" . $hereprev) &&
2754                                             $fix && $line =~ /^\+/) {
2755                                                 $fixed[$fixlinenr] =~
2756                                                     s/^\+[ \t]*/\+$goodtabindent/;
2757                                         }
2758                                 }
2759                         }
2760                 }
2761
2762 # check for space after cast like "(int) foo" or "(struct foo) bar"
2763 # avoid checking a few false positives:
2764 #   "sizeof(<type>)" or "__alignof__(<type>)"
2765 #   function pointer declarations like "(*foo)(int) = bar;"
2766 #   structure definitions like "(struct foo) { 0 };"
2767 #   multiline macros that define functions
2768 #   known attributes or the __attribute__ keyword
2769                 if ($line =~ /^\+(.*)\(\s*$Type\s*\)([ \t]++)((?![={]|\\$|$Attribute|__attribute__))/ &&
2770                     (!defined($1) || $1 !~ /\b(?:sizeof|__alignof__)\s*$/)) {
2771                         if (CHK("SPACING",
2772                                 "No space is necessary after a cast\n" . $herecurr) &&
2773                             $fix) {
2774                                 $fixed[$fixlinenr] =~
2775                                     s/(\(\s*$Type\s*\))[ \t]+/$1/;
2776                         }
2777                 }
2778
2779 # Block comment styles
2780 # Networking with an initial /*
2781                 if ($realfile =~ m@^(drivers/net/|net/)@ &&
2782                     $prevrawline =~ /^\+[ \t]*\/\*[ \t]*$/ &&
2783                     $rawline =~ /^\+[ \t]*\*/ &&
2784                     $realline > 2) {
2785                         WARN("NETWORKING_BLOCK_COMMENT_STYLE",
2786                              "networking block comments don't use an empty /* line, use /* Comment...\n" . $hereprev);
2787                 }
2788
2789 # Block comments use * on subsequent lines
2790                 if ($prevline =~ /$;[ \t]*$/ &&                 #ends in comment
2791                     $prevrawline =~ /^\+.*?\/\*/ &&             #starting /*
2792                     $prevrawline !~ /\*\/[ \t]*$/ &&            #no trailing */
2793                     $rawline =~ /^\+/ &&                        #line is new
2794                     $rawline !~ /^\+[ \t]*\*/) {                #no leading *
2795                         WARN("BLOCK_COMMENT_STYLE",
2796                              "Block comments use * on subsequent lines\n" . $hereprev);
2797                 }
2798
2799 # Block comments use */ on trailing lines
2800                 if ($rawline !~ m@^\+[ \t]*\*/[ \t]*$@ &&       #trailing */
2801                     $rawline !~ m@^\+.*/\*.*\*/[ \t]*$@ &&      #inline /*...*/
2802                     $rawline !~ m@^\+.*\*{2,}/[ \t]*$@ &&       #trailing **/
2803                     $rawline =~ m@^\+[ \t]*.+\*\/[ \t]*$@) {    #non blank */
2804                         WARN("BLOCK_COMMENT_STYLE",
2805                              "Block comments use a trailing */ on a separate line\n" . $herecurr);
2806                 }
2807
2808 # check for missing blank lines after struct/union declarations
2809 # with exceptions for various attributes and macros
2810                 if ($prevline =~ /^[\+ ]};?\s*$/ &&
2811                     $line =~ /^\+/ &&
2812                     !($line =~ /^\+\s*$/ ||
2813                       $line =~ /^\+\s*EXPORT_SYMBOL/ ||
2814                       $line =~ /^\+\s*MODULE_/i ||
2815                       $line =~ /^\+\s*\#\s*(?:end|elif|else)/ ||
2816                       $line =~ /^\+[a-z_]*init/ ||
2817                       $line =~ /^\+\s*(?:static\s+)?[A-Z_]*ATTR/ ||
2818                       $line =~ /^\+\s*DECLARE/ ||
2819                       $line =~ /^\+\s*__setup/)) {
2820                         if (CHK("LINE_SPACING",
2821                                 "Please use a blank line after function/struct/union/enum declarations\n" . $hereprev) &&
2822                             $fix) {
2823                                 fix_insert_line($fixlinenr, "\+");
2824                         }
2825                 }
2826
2827 # check for multiple consecutive blank lines
2828                 if ($prevline =~ /^[\+ ]\s*$/ &&
2829                     $line =~ /^\+\s*$/ &&
2830                     $last_blank_line != ($linenr - 1)) {
2831                         if (CHK("LINE_SPACING",
2832                                 "Please don't use multiple blank lines\n" . $hereprev) &&
2833                             $fix) {
2834                                 fix_delete_line($fixlinenr, $rawline);
2835                         }
2836
2837                         $last_blank_line = $linenr;
2838                 }
2839
2840 # check for missing blank lines after declarations
2841                 if ($sline =~ /^\+\s+\S/ &&                     #Not at char 1
2842                         # actual declarations
2843                     ($prevline =~ /^\+\s+$Declare\s*$Ident\s*[=,;:\[]/ ||
2844                         # function pointer declarations
2845                      $prevline =~ /^\+\s+$Declare\s*\(\s*\*\s*$Ident\s*\)\s*[=,;:\[\(]/ ||
2846                         # foo bar; where foo is some local typedef or #define
2847                      $prevline =~ /^\+\s+$Ident(?:\s+|\s*\*\s*)$Ident\s*[=,;\[]/ ||
2848                         # known declaration macros
2849                      $prevline =~ /^\+\s+$declaration_macros/) &&
2850                         # for "else if" which can look like "$Ident $Ident"
2851                     !($prevline =~ /^\+\s+$c90_Keywords\b/ ||
2852                         # other possible extensions of declaration lines
2853                       $prevline =~ /(?:$Compare|$Assignment|$Operators)\s*$/ ||
2854                         # not starting a section or a macro "\" extended line
2855                       $prevline =~ /(?:\{\s*|\\)$/) &&
2856                         # looks like a declaration
2857                     !($sline =~ /^\+\s+$Declare\s*$Ident\s*[=,;:\[]/ ||
2858                         # function pointer declarations
2859                       $sline =~ /^\+\s+$Declare\s*\(\s*\*\s*$Ident\s*\)\s*[=,;:\[\(]/ ||
2860                         # foo bar; where foo is some local typedef or #define
2861                       $sline =~ /^\+\s+$Ident(?:\s+|\s*\*\s*)$Ident\s*[=,;\[]/ ||
2862                         # known declaration macros
2863                       $sline =~ /^\+\s+$declaration_macros/ ||
2864                         # start of struct or union or enum
2865                       $sline =~ /^\+\s+(?:union|struct|enum|typedef)\b/ ||
2866                         # start or end of block or continuation of declaration
2867                       $sline =~ /^\+\s+(?:$|[\{\}\.\#\"\?\:\(\[])/ ||
2868                         # bitfield continuation
2869                       $sline =~ /^\+\s+$Ident\s*:\s*\d+\s*[,;]/ ||
2870                         # other possible extensions of declaration lines
2871                       $sline =~ /^\+\s+\(?\s*(?:$Compare|$Assignment|$Operators)/) &&
2872                         # indentation of previous and current line are the same
2873                     (($prevline =~ /\+(\s+)\S/) && $sline =~ /^\+$1\S/)) {
2874                         if (WARN("LINE_SPACING",
2875                                  "Missing a blank line after declarations\n" . $hereprev) &&
2876                             $fix) {
2877                                 fix_insert_line($fixlinenr, "\+");
2878                         }
2879                 }
2880
2881 # check for spaces at the beginning of a line.
2882 # Exceptions:
2883 #  1) within comments
2884 #  2) indented preprocessor commands
2885 #  3) hanging labels
2886                 if ($rawline =~ /^\+ / && $line !~ /^\+ *(?:$;|#|$Ident:)/)  {
2887                         my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2888                         if (WARN("LEADING_SPACE",
2889                                  "please, no spaces at the start of a line\n" . $herevet) &&
2890                             $fix) {
2891                                 $fixed[$fixlinenr] =~ s/^\+([ \t]+)/"\+" . tabify($1)/e;
2892                         }
2893                 }
2894
2895 # check we are in a valid C source file if not then ignore this hunk
2896                 next if ($realfile !~ /\.(h|c)$/);
2897
2898 # check indentation of any line with a bare else
2899 # (but not if it is a multiple line "if (foo) return bar; else return baz;")
2900 # if the previous line is a break or return and is indented 1 tab more...
2901                 if ($sline =~ /^\+([\t]+)(?:}[ \t]*)?else(?:[ \t]*{)?\s*$/) {
2902                         my $tabs = length($1) + 1;
2903                         if ($prevline =~ /^\+\t{$tabs,$tabs}break\b/ ||
2904                             ($prevline =~ /^\+\t{$tabs,$tabs}return\b/ &&
2905                              defined $lines[$linenr] &&
2906                              $lines[$linenr] !~ /^[ \+]\t{$tabs,$tabs}return/)) {
2907                                 WARN("UNNECESSARY_ELSE",
2908                                      "else is not generally useful after a break or return\n" . $hereprev);
2909                         }
2910                 }
2911
2912 # check indentation of a line with a break;
2913 # if the previous line is a goto or return and is indented the same # of tabs
2914                 if ($sline =~ /^\+([\t]+)break\s*;\s*$/) {
2915                         my $tabs = $1;
2916                         if ($prevline =~ /^\+$tabs(?:goto|return)\b/) {
2917                                 WARN("UNNECESSARY_BREAK",
2918                                      "break is not useful after a goto or return\n" . $hereprev);
2919                         }
2920                 }
2921
2922 # discourage the addition of CONFIG_EXPERIMENTAL in #if(def).
2923                 if ($line =~ /^\+\s*\#\s*if.*\bCONFIG_EXPERIMENTAL\b/) {
2924                         WARN("CONFIG_EXPERIMENTAL",
2925                              "Use of CONFIG_EXPERIMENTAL is deprecated. For alternatives, see https://lkml.org/lkml/2012/10/23/580\n");
2926                 }
2927
2928 # check for RCS/CVS revision markers
2929                 if ($rawline =~ /^\+.*\$(Revision|Log|Id)(?:\$|)/) {
2930                         WARN("CVS_KEYWORD",
2931                              "CVS style keyword markers, these will _not_ be updated\n". $herecurr);
2932                 }
2933
2934 # Blackfin: don't use __builtin_bfin_[cs]sync
2935                 if ($line =~ /__builtin_bfin_csync/) {
2936                         my $herevet = "$here\n" . cat_vet($line) . "\n";
2937                         ERROR("CSYNC",
2938                               "use the CSYNC() macro in asm/blackfin.h\n" . $herevet);
2939                 }
2940                 if ($line =~ /__builtin_bfin_ssync/) {
2941                         my $herevet = "$here\n" . cat_vet($line) . "\n";
2942                         ERROR("SSYNC",
2943                               "use the SSYNC() macro in asm/blackfin.h\n" . $herevet);
2944                 }
2945
2946 # check for old HOTPLUG __dev<foo> section markings
2947                 if ($line =~ /\b(__dev(init|exit)(data|const|))\b/) {
2948                         WARN("HOTPLUG_SECTION",
2949                              "Using $1 is unnecessary\n" . $herecurr);
2950                 }
2951
2952 # Check for potential 'bare' types
2953                 my ($stat, $cond, $line_nr_next, $remain_next, $off_next,
2954                     $realline_next);
2955 #print "LINE<$line>\n";
2956                 if ($linenr >= $suppress_statement &&
2957                     $realcnt && $sline =~ /.\s*\S/) {
2958                         ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
2959                                 ctx_statement_block($linenr, $realcnt, 0);
2960                         $stat =~ s/\n./\n /g;
2961                         $cond =~ s/\n./\n /g;
2962
2963 #print "linenr<$linenr> <$stat>\n";
2964                         # If this statement has no statement boundaries within
2965                         # it there is no point in retrying a statement scan
2966                         # until we hit end of it.
2967                         my $frag = $stat; $frag =~ s/;+\s*$//;
2968                         if ($frag !~ /(?:{|;)/) {
2969 #print "skip<$line_nr_next>\n";
2970                                 $suppress_statement = $line_nr_next;
2971                         }
2972
2973                         # Find the real next line.
2974                         $realline_next = $line_nr_next;
2975                         if (defined $realline_next &&
2976                             (!defined $lines[$realline_next - 1] ||
2977                              substr($lines[$realline_next - 1], $off_next) =~ /^\s*$/)) {
2978                                 $realline_next++;
2979                         }
2980
2981                         my $s = $stat;
2982                         $s =~ s/{.*$//s;
2983
2984                         # Ignore goto labels.
2985                         if ($s =~ /$Ident:\*$/s) {
2986
2987                         # Ignore functions being called
2988                         } elsif ($s =~ /^.\s*$Ident\s*\(/s) {
2989
2990                         } elsif ($s =~ /^.\s*else\b/s) {
2991
2992                         # declarations always start with types
2993                         } 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) {
2994                                 my $type = $1;
2995                                 $type =~ s/\s+/ /g;
2996                                 possible($type, "A:" . $s);
2997
2998                         # definitions in global scope can only start with types
2999                         } elsif ($s =~ /^.(?:$Storage\s+)?(?:$Inline\s+)?(?:const\s+)?($Ident)\b\s*(?!:)/s) {
3000                                 possible($1, "B:" . $s);
3001                         }
3002
3003                         # any (foo ... *) is a pointer cast, and foo is a type
3004                         while ($s =~ /\(($Ident)(?:\s+$Sparse)*[\s\*]+\s*\)/sg) {
3005                                 possible($1, "C:" . $s);
3006                         }
3007
3008                         # Check for any sort of function declaration.
3009                         # int foo(something bar, other baz);
3010                         # void (*store_gdt)(x86_descr_ptr *);
3011                         if ($prev_values eq 'E' && $s =~ /^(.(?:typedef\s*)?(?:(?:$Storage|$Inline)\s*)*\s*$Type\s*(?:\b$Ident|\(\*\s*$Ident\))\s*)\(/s) {
3012                                 my ($name_len) = length($1);
3013
3014                                 my $ctx = $s;
3015                                 substr($ctx, 0, $name_len + 1, '');
3016                                 $ctx =~ s/\)[^\)]*$//;
3017
3018                                 for my $arg (split(/\s*,\s*/, $ctx)) {
3019                                         if ($arg =~ /^(?:const\s+)?($Ident)(?:\s+$Sparse)*\s*\**\s*(:?\b$Ident)?$/s || $arg =~ /^($Ident)$/s) {
3020
3021                                                 possible($1, "D:" . $s);
3022                                         }
3023                                 }
3024                         }
3025
3026                 }
3027
3028 #
3029 # Checks which may be anchored in the context.
3030 #
3031
3032 # Check for switch () and associated case and default
3033 # statements should be at the same indent.
3034                 if ($line=~/\bswitch\s*\(.*\)/) {
3035                         my $err = '';
3036                         my $sep = '';
3037                         my @ctx = ctx_block_outer($linenr, $realcnt);
3038                         shift(@ctx);
3039                         for my $ctx (@ctx) {
3040                                 my ($clen, $cindent) = line_stats($ctx);
3041                                 if ($ctx =~ /^\+\s*(case\s+|default:)/ &&
3042                                                         $indent != $cindent) {
3043                                         $err .= "$sep$ctx\n";
3044                                         $sep = '';
3045                                 } else {
3046                                         $sep = "[...]\n";
3047                                 }
3048                         }
3049                         if ($err ne '') {
3050                                 ERROR("SWITCH_CASE_INDENT_LEVEL",
3051                                       "switch and case should be at the same indent\n$hereline$err");
3052                         }
3053                 }
3054
3055 # if/while/etc brace do not go on next line, unless defining a do while loop,
3056 # or if that brace on the next line is for something else
3057                 if ($line =~ /(.*)\b((?:if|while|for|switch|(?:[a-z_]+|)for_each[a-z_]+)\s*\(|do\b|else\b)/ && $line !~ /^.\s*\#/) {
3058                         my $pre_ctx = "$1$2";
3059
3060                         my ($level, @ctx) = ctx_statement_level($linenr, $realcnt, 0);
3061
3062                         if ($line =~ /^\+\t{6,}/) {
3063                                 WARN("DEEP_INDENTATION",
3064                                      "Too many leading tabs - consider code refactoring\n" . $herecurr);
3065                         }
3066
3067                         my $ctx_cnt = $realcnt - $#ctx - 1;
3068                         my $ctx = join("\n", @ctx);
3069
3070                         my $ctx_ln = $linenr;
3071                         my $ctx_skip = $realcnt;
3072
3073                         while ($ctx_skip > $ctx_cnt || ($ctx_skip == $ctx_cnt &&
3074                                         defined $lines[$ctx_ln - 1] &&
3075                                         $lines[$ctx_ln - 1] =~ /^-/)) {
3076                                 ##print "SKIP<$ctx_skip> CNT<$ctx_cnt>\n";
3077                                 $ctx_skip-- if (!defined $lines[$ctx_ln - 1] || $lines[$ctx_ln - 1] !~ /^-/);
3078                                 $ctx_ln++;
3079                         }
3080
3081                         #print "realcnt<$realcnt> ctx_cnt<$ctx_cnt>\n";
3082                         #print "pre<$pre_ctx>\nline<$line>\nctx<$ctx>\nnext<$lines[$ctx_ln - 1]>\n";
3083
3084                         if ($ctx !~ /{\s*/ && defined($lines[$ctx_ln - 1]) && $lines[$ctx_ln - 1] =~ /^\+\s*{/) {
3085                                 ERROR("OPEN_BRACE",
3086                                       "that open brace { should be on the previous line\n" .
3087                                         "$here\n$ctx\n$rawlines[$ctx_ln - 1]\n");
3088                         }
3089                         if ($level == 0 && $pre_ctx !~ /}\s*while\s*\($/ &&
3090                             $ctx =~ /\)\s*\;\s*$/ &&
3091                             defined $lines[$ctx_ln - 1])
3092                         {
3093                                 my ($nlength, $nindent) = line_stats($lines[$ctx_ln - 1]);
3094                                 if ($nindent > $indent) {
3095                                         WARN("TRAILING_SEMICOLON",
3096                                              "trailing semicolon indicates no statements, indent implies otherwise\n" .
3097                                                 "$here\n$ctx\n$rawlines[$ctx_ln - 1]\n");
3098                                 }
3099                         }
3100                 }
3101
3102 # Check relative indent for conditionals and blocks.
3103                 if ($line =~ /\b(?:(?:if|while|for|(?:[a-z_]+|)for_each[a-z_]+)\s*\(|do\b)/ && $line !~ /^.\s*#/ && $line !~ /\}\s*while\s*/) {
3104                         ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
3105                                 ctx_statement_block($linenr, $realcnt, 0)
3106                                         if (!defined $stat);
3107                         my ($s, $c) = ($stat, $cond);
3108
3109                         substr($s, 0, length($c), '');
3110
3111                         # remove inline comments
3112                         $s =~ s/$;/ /g;
3113                         $c =~ s/$;/ /g;
3114
3115                         # Find out how long the conditional actually is.
3116                         my @newlines = ($c =~ /\n/gs);
3117                         my $cond_lines = 1 + $#newlines;
3118
3119                         # Make sure we remove the line prefixes as we have
3120                         # none on the first line, and are going to readd them
3121                         # where necessary.
3122                         $s =~ s/\n./\n/gs;
3123                         while ($s =~ /\n\s+\\\n/) {
3124                                 $cond_lines += $s =~ s/\n\s+\\\n/\n/g;
3125                         }
3126
3127                         # We want to check the first line inside the block
3128                         # starting at the end of the conditional, so remove:
3129                         #  1) any blank line termination
3130                         #  2) any opening brace { on end of the line
3131                         #  3) any do (...) {
3132                         my $continuation = 0;
3133                         my $check = 0;
3134                         $s =~ s/^.*\bdo\b//;
3135                         $s =~ s/^\s*{//;
3136                         if ($s =~ s/^\s*\\//) {
3137                                 $continuation = 1;
3138                         }
3139                         if ($s =~ s/^\s*?\n//) {
3140                                 $check = 1;
3141                                 $cond_lines++;
3142                         }
3143
3144                         # Also ignore a loop construct at the end of a
3145                         # preprocessor statement.
3146                         if (($prevline =~ /^.\s*#\s*define\s/ ||
3147                             $prevline =~ /\\\s*$/) && $continuation == 0) {
3148                                 $check = 0;
3149                         }
3150
3151                         my $cond_ptr = -1;
3152                         $continuation = 0;
3153                         while ($cond_ptr != $cond_lines) {
3154                                 $cond_ptr = $cond_lines;
3155
3156                                 # If we see an #else/#elif then the code
3157                                 # is not linear.
3158                                 if ($s =~ /^\s*\#\s*(?:else|elif)/) {
3159                                         $check = 0;
3160                                 }
3161
3162                                 # Ignore:
3163                                 #  1) blank lines, they should be at 0,
3164                                 #  2) preprocessor lines, and
3165                                 #  3) labels.
3166                                 if ($continuation ||
3167                                     $s =~ /^\s*?\n/ ||
3168                                     $s =~ /^\s*#\s*?/ ||
3169                                     $s =~ /^\s*$Ident\s*:/) {
3170                                         $continuation = ($s =~ /^.*?\\\n/) ? 1 : 0;
3171                                         if ($s =~ s/^.*?\n//) {
3172                                                 $cond_lines++;
3173                                         }
3174                                 }
3175                         }
3176
3177                         my (undef, $sindent) = line_stats("+" . $s);
3178                         my $stat_real = raw_line($linenr, $cond_lines);
3179
3180                         # Check if either of these lines are modified, else
3181                         # this is not this patch's fault.
3182                         if (!defined($stat_real) ||
3183                             $stat !~ /^\+/ && $stat_real !~ /^\+/) {
3184                                 $check = 0;
3185                         }
3186                         if (defined($stat_real) && $cond_lines > 1) {
3187                                 $stat_real = "[...]\n$stat_real";
3188                         }
3189
3190                         #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";
3191
3192                         if ($check && $s ne '' &&
3193                             (($sindent % 8) != 0 ||
3194                              ($sindent < $indent) ||
3195                              ($sindent > $indent + 8))) {
3196                                 WARN("SUSPECT_CODE_INDENT",
3197                                      "suspect code indent for conditional statements ($indent, $sindent)\n" . $herecurr . "$stat_real\n");
3198                         }
3199                 }
3200
3201                 # Track the 'values' across context and added lines.
3202                 my $opline = $line; $opline =~ s/^./ /;
3203                 my ($curr_values, $curr_vars) =
3204                                 annotate_values($opline . "\n", $prev_values);
3205                 $curr_values = $prev_values . $curr_values;
3206                 if ($dbg_values) {
3207                         my $outline = $opline; $outline =~ s/\t/ /g;
3208                         print "$linenr > .$outline\n";
3209                         print "$linenr > $curr_values\n";
3210                         print "$linenr >  $curr_vars\n";
3211                 }
3212                 $prev_values = substr($curr_values, -1);
3213
3214 #ignore lines not being added
3215                 next if ($line =~ /^[^\+]/);
3216
3217 # TEST: allow direct testing of the type matcher.
3218                 if ($dbg_type) {
3219                         if ($line =~ /^.\s*$Declare\s*$/) {
3220                                 ERROR("TEST_TYPE",
3221                                       "TEST: is type\n" . $herecurr);
3222                         } elsif ($dbg_type > 1 && $line =~ /^.+($Declare)/) {
3223                                 ERROR("TEST_NOT_TYPE",
3224                                       "TEST: is not type ($1 is)\n". $herecurr);
3225                         }
3226                         next;
3227                 }
3228 # TEST: allow direct testing of the attribute matcher.
3229                 if ($dbg_attr) {
3230                         if ($line =~ /^.\s*$Modifier\s*$/) {
3231                                 ERROR("TEST_ATTR",
3232                                       "TEST: is attr\n" . $herecurr);
3233                         } elsif ($dbg_attr > 1 && $line =~ /^.+($Modifier)/) {
3234                                 ERROR("TEST_NOT_ATTR",
3235                                       "TEST: is not attr ($1 is)\n". $herecurr);
3236                         }
3237                         next;
3238                 }
3239
3240 # check for initialisation to aggregates open brace on the next line
3241                 if ($line =~ /^.\s*{/ &&
3242                     $prevline =~ /(?:^|[^=])=\s*$/) {
3243                         if (ERROR("OPEN_BRACE",
3244                                   "that open brace { should be on the previous line\n" . $hereprev) &&
3245                             $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
3246                                 fix_delete_line($fixlinenr - 1, $prevrawline);
3247                                 fix_delete_line($fixlinenr, $rawline);
3248                                 my $fixedline = $prevrawline;
3249                                 $fixedline =~ s/\s*=\s*$/ = {/;
3250                                 fix_insert_line($fixlinenr, $fixedline);
3251                                 $fixedline = $line;
3252                                 $fixedline =~ s/^(.\s*){\s*/$1/;
3253                                 fix_insert_line($fixlinenr, $fixedline);
3254                         }
3255                 }
3256
3257 #
3258 # Checks which are anchored on the added line.
3259 #
3260
3261 # check for malformed paths in #include statements (uses RAW line)
3262                 if ($rawline =~ m{^.\s*\#\s*include\s+[<"](.*)[">]}) {
3263                         my $path = $1;
3264                         if ($path =~ m{//}) {
3265                                 ERROR("MALFORMED_INCLUDE",
3266                                       "malformed #include filename\n" . $herecurr);
3267                         }
3268                         if ($path =~ "^uapi/" && $realfile =~ m@\binclude/uapi/@) {
3269                                 ERROR("UAPI_INCLUDE",
3270                                       "No #include in ...include/uapi/... should use a uapi/ path prefix\n" . $herecurr);
3271                         }
3272                 }
3273
3274 # no C99 // comments
3275                 if ($line =~ m{//}) {
3276                         if (ERROR("C99_COMMENTS",
3277                                   "do not use C99 // comments\n" . $herecurr) &&
3278                             $fix) {
3279                                 my $line = $fixed[$fixlinenr];
3280                                 if ($line =~ /\/\/(.*)$/) {
3281                                         my $comment = trim($1);
3282                                         $fixed[$fixlinenr] =~ s@\/\/(.*)$@/\* $comment \*/@;
3283                                 }
3284                         }
3285                 }
3286                 # Remove C99 comments.
3287                 $line =~ s@//.*@@;
3288                 $opline =~ s@//.*@@;
3289
3290 # EXPORT_SYMBOL should immediately follow the thing it is exporting, consider
3291 # the whole statement.
3292 #print "APW <$lines[$realline_next - 1]>\n";
3293                 if (defined $realline_next &&
3294                     exists $lines[$realline_next - 1] &&
3295                     !defined $suppress_export{$realline_next} &&
3296                     ($lines[$realline_next - 1] =~ /EXPORT_SYMBOL.*\((.*)\)/ ||
3297                      $lines[$realline_next - 1] =~ /EXPORT_UNUSED_SYMBOL.*\((.*)\)/)) {
3298                         # Handle definitions which produce identifiers with
3299                         # a prefix:
3300                         #   XXX(foo);
3301                         #   EXPORT_SYMBOL(something_foo);
3302                         my $name = $1;
3303                         if ($stat =~ /^(?:.\s*}\s*\n)?.([A-Z_]+)\s*\(\s*($Ident)/ &&
3304                             $name =~ /^${Ident}_$2/) {
3305 #print "FOO C name<$name>\n";
3306                                 $suppress_export{$realline_next} = 1;
3307
3308                         } elsif ($stat !~ /(?:
3309                                 \n.}\s*$|
3310                                 ^.DEFINE_$Ident\(\Q$name\E\)|
3311                                 ^.DECLARE_$Ident\(\Q$name\E\)|
3312                                 ^.LIST_HEAD\(\Q$name\E\)|
3313                                 ^.(?:$Storage\s+)?$Type\s*\(\s*\*\s*\Q$name\E\s*\)\s*\(|
3314                                 \b\Q$name\E(?:\s+$Attribute)*\s*(?:;|=|\[|\()
3315                             )/x) {
3316 #print "FOO A<$lines[$realline_next - 1]> stat<$stat> name<$name>\n";
3317                                 $suppress_export{$realline_next} = 2;
3318                         } else {
3319                                 $suppress_export{$realline_next} = 1;
3320                         }
3321                 }
3322                 if (!defined $suppress_export{$linenr} &&
3323                     $prevline =~ /^.\s*$/ &&
3324                     ($line =~ /EXPORT_SYMBOL.*\((.*)\)/ ||
3325                      $line =~ /EXPORT_UNUSED_SYMBOL.*\((.*)\)/)) {
3326 #print "FOO B <$lines[$linenr - 1]>\n";
3327                         $suppress_export{$linenr} = 2;
3328                 }
3329                 if (defined $suppress_export{$linenr} &&
3330                     $suppress_export{$linenr} == 2) {
3331                         WARN("EXPORT_SYMBOL",
3332                              "EXPORT_SYMBOL(foo); should immediately follow its function/variable\n" . $herecurr);
3333                 }
3334
3335 # check for global initialisers.
3336                 if ($line =~ /^\+$Type\s*$Ident(?:\s+$Modifier)*\s*=\s*(?:0|NULL|false)\s*;/) {
3337                         if (ERROR("GLOBAL_INITIALISERS",
3338                                   "do not initialise globals to 0 or NULL\n" .
3339                                       $herecurr) &&
3340                             $fix) {
3341                                 $fixed[$fixlinenr] =~ s/(^.$Type\s*$Ident(?:\s+$Modifier)*)\s*=\s*(0|NULL|false)\s*;/$1;/;
3342                         }
3343                 }
3344 # check for static initialisers.
3345                 if ($line =~ /^\+.*\bstatic\s.*=\s*(0|NULL|false)\s*;/) {
3346                         if (ERROR("INITIALISED_STATIC",
3347                                   "do not initialise statics to 0 or NULL\n" .
3348                                       $herecurr) &&
3349                             $fix) {
3350                                 $fixed[$fixlinenr] =~ s/(\bstatic\s.*?)\s*=\s*(0|NULL|false)\s*;/$1;/;
3351                         }
3352                 }
3353
3354 # check for misordered declarations of char/short/int/long with signed/unsigned
3355                 while ($sline =~ m{(\b$TypeMisordered\b)}g) {
3356                         my $tmp = trim($1);
3357                         WARN("MISORDERED_TYPE",
3358                              "type '$tmp' should be specified in [[un]signed] [short|int|long|long long] order\n" . $herecurr);
3359                 }
3360
3361 # check for static const char * arrays.
3362                 if ($line =~ /\bstatic\s+const\s+char\s*\*\s*(\w+)\s*\[\s*\]\s*=\s*/) {
3363                         WARN("STATIC_CONST_CHAR_ARRAY",
3364                              "static const char * array should probably be static const char * const\n" .
3365                                 $herecurr);
3366                }
3367
3368 # check for static char foo[] = "bar" declarations.
3369                 if ($line =~ /\bstatic\s+char\s+(\w+)\s*\[\s*\]\s*=\s*"/) {
3370                         WARN("STATIC_CONST_CHAR_ARRAY",
3371                              "static char array declaration should probably be static const char\n" .
3372                                 $herecurr);
3373                }
3374
3375 # check for const <foo> const where <foo> is not a pointer or array type
3376                 if ($sline =~ /\bconst\s+($BasicType)\s+const\b/) {
3377                         my $found = $1;
3378                         if ($sline =~ /\bconst\s+\Q$found\E\s+const\b\s*\*/) {
3379                                 WARN("CONST_CONST",
3380                                      "'const $found const *' should probably be 'const $found * const'\n" . $herecurr);
3381                         } elsif ($sline !~ /\bconst\s+\Q$found\E\s+const\s+\w+\s*\[/) {
3382                                 WARN("CONST_CONST",
3383                                      "'const $found const' should probably be 'const $found'\n" . $herecurr);
3384                         }
3385                 }
3386
3387 # check for non-global char *foo[] = {"bar", ...} declarations.
3388                 if ($line =~ /^.\s+(?:static\s+|const\s+)?char\s+\*\s*\w+\s*\[\s*\]\s*=\s*\{/) {
3389                         WARN("STATIC_CONST_CHAR_ARRAY",
3390                              "char * array declaration might be better as static const\n" .
3391                                 $herecurr);
3392                }
3393
3394 # check for sizeof(foo)/sizeof(foo[0]) that could be ARRAY_SIZE(foo)
3395                 if ($line =~ m@\bsizeof\s*\(\s*($Lval)\s*\)@) {
3396                         my $array = $1;
3397                         if ($line =~ m@\b(sizeof\s*\(\s*\Q$array\E\s*\)\s*/\s*sizeof\s*\(\s*\Q$array\E\s*\[\s*0\s*\]\s*\))@) {
3398                                 my $array_div = $1;
3399                                 if (WARN("ARRAY_SIZE",
3400                                          "Prefer ARRAY_SIZE($array)\n" . $herecurr) &&
3401                                     $fix) {
3402                                         $fixed[$fixlinenr] =~ s/\Q$array_div\E/ARRAY_SIZE($array)/;
3403                                 }
3404                         }
3405                 }
3406
3407 # check for function declarations without arguments like "int foo()"
3408                 if ($line =~ /(\b$Type\s+$Ident)\s*\(\s*\)/) {
3409                         if (ERROR("FUNCTION_WITHOUT_ARGS",
3410                                   "Bad function definition - $1() should probably be $1(void)\n" . $herecurr) &&
3411                             $fix) {
3412                                 $fixed[$fixlinenr] =~ s/(\b($Type)\s+($Ident))\s*\(\s*\)/$2 $3(void)/;
3413                         }
3414                 }
3415
3416 # check for uses of DEFINE_PCI_DEVICE_TABLE
3417                 if ($line =~ /\bDEFINE_PCI_DEVICE_TABLE\s*\(\s*(\w+)\s*\)\s*=/) {
3418                         if (WARN("DEFINE_PCI_DEVICE_TABLE",
3419                                  "Prefer struct pci_device_id over deprecated DEFINE_PCI_DEVICE_TABLE\n" . $herecurr) &&
3420                             $fix) {
3421                                 $fixed[$fixlinenr] =~ s/\b(?:static\s+|)DEFINE_PCI_DEVICE_TABLE\s*\(\s*(\w+)\s*\)\s*=\s*/static const struct pci_device_id $1\[\] = /;
3422                         }
3423                 }
3424
3425 # check for new typedefs, only function parameters and sparse annotations
3426 # make sense.
3427                 if ($line =~ /\btypedef\s/ &&
3428                     $line !~ /\btypedef\s+$Type\s*\(\s*\*?$Ident\s*\)\s*\(/ &&
3429                     $line !~ /\btypedef\s+$Type\s+$Ident\s*\(/ &&
3430                     $line !~ /\b$typeTypedefs\b/ &&
3431                     $line !~ /\b__bitwise(?:__|)\b/) {
3432                         WARN("NEW_TYPEDEFS",
3433                              "do not add new typedefs\n" . $herecurr);
3434                 }
3435
3436 # * goes on variable not on type
3437                 # (char*[ const])
3438                 while ($line =~ m{(\($NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)\))}g) {
3439                         #print "AA<$1>\n";
3440                         my ($ident, $from, $to) = ($1, $2, $2);
3441
3442                         # Should start with a space.
3443                         $to =~ s/^(\S)/ $1/;
3444                         # Should not end with a space.
3445                         $to =~ s/\s+$//;
3446                         # '*'s should not have spaces between.
3447                         while ($to =~ s/\*\s+\*/\*\*/) {
3448                         }
3449
3450 ##                      print "1: from<$from> to<$to> ident<$ident>\n";
3451                         if ($from ne $to) {
3452                                 if (ERROR("POINTER_LOCATION",
3453                                           "\"(foo$from)\" should be \"(foo$to)\"\n" .  $herecurr) &&
3454                                     $fix) {
3455                                         my $sub_from = $ident;
3456                                         my $sub_to = $ident;
3457                                         $sub_to =~ s/\Q$from\E/$to/;
3458                                         $fixed[$fixlinenr] =~
3459                                             s@\Q$sub_from\E@$sub_to@;
3460                                 }
3461                         }
3462                 }
3463                 while ($line =~ m{(\b$NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)($Ident))}g) {
3464                         #print "BB<$1>\n";
3465                         my ($match, $from, $to, $ident) = ($1, $2, $2, $3);
3466
3467                         # Should start with a space.
3468                         $to =~ s/^(\S)/ $1/;
3469                         # Should not end with a space.
3470                         $to =~ s/\s+$//;
3471                         # '*'s should not have spaces between.
3472                         while ($to =~ s/\*\s+\*/\*\*/) {
3473                         }
3474                         # Modifiers should have spaces.
3475                         $to =~ s/(\b$Modifier$)/$1 /;
3476
3477 ##                      print "2: from<$from> to<$to> ident<$ident>\n";
3478                         if ($from ne $to && $ident !~ /^$Modifier$/) {
3479                                 if (ERROR("POINTER_LOCATION",
3480                                           "\"foo${from}bar\" should be \"foo${to}bar\"\n" .  $herecurr) &&
3481                                     $fix) {
3482
3483                                         my $sub_from = $match;
3484                                         my $sub_to = $match;
3485                                         $sub_to =~ s/\Q$from\E/$to/;