Root/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
8use strict;
9use POSIX;
10
11my $P = $0;
12$P =~ s@(.*)/@@g;
13my $D = $1;
14
15my $V = '0.32';
16
17use Getopt::Long qw(:config no_auto_abbrev);
18
19my $quiet = 0;
20my $tree = 1;
21my $chk_signoff = 1;
22my $chk_patch = 1;
23my $tst_only;
24my $emacs = 0;
25my $terse = 0;
26my $file = 0;
27my $check = 0;
28my $check_orig = 0;
29my $summary = 1;
30my $mailback = 0;
31my $summary_file = 0;
32my $show_types = 0;
33my $fix = 0;
34my $fix_inplace = 0;
35my $root;
36my %debug;
37my %camelcase = ();
38my %use_type = ();
39my @use = ();
40my %ignore_type = ();
41my @ignore = ();
42my $help = 0;
43my $configuration_file = ".checkpatch.conf";
44my $max_line_length = 80;
45my $ignore_perl_version = 0;
46my $minimum_perl_version = 5.10.0;
47my $min_conf_desc_length = 4;
48my $spelling_file = "$D/spelling.txt";
49
50sub help {
51    my ($exitcode) = @_;
52
53    print << "EOM";
54Usage: $P [OPTION]... [FILE]...
55Version: $V
56
57Options:
58  -q, --quiet quiet
59  --no-tree run without a kernel tree
60  --no-signoff do not check for 'Signed-off-by' line
61  --patch treat FILE as patchfile (default)
62  --emacs emacs compile window format
63  --terse one line per report
64  -f, --file treat FILE as regular source file
65  --subjective, --strict enable more subjective tests
66  --types TYPE(,TYPE2...) show only these comma separated message types
67  --ignore TYPE(,TYPE2...) ignore various comma separated message types
68  --max-line-length=n set the maximum line length, if exceeded, warn
69  --min-conf-desc-length=n set the min description length, if shorter, warn
70  --show-types show the message "types" in the output
71  --root=PATH PATH to the kernel tree root
72  --no-summary suppress the per-file summary
73  --mailback only produce a report in case of warnings/errors
74  --summary-file include the filename in summary
75  --debug KEY=[0|1] turn on/off debugging of KEY, where KEY is one of
76                             'values', 'possible', 'type', and 'attr' (default
77                             is all off)
78  --test-only=WORD report only warnings/errors containing WORD
79                             literally
80  --fix EXPERIMENTAL - may create horrible results
81                             If correctable single-line errors exist, create
82                             "<inputfile>.EXPERIMENTAL-checkpatch-fixes"
83                             with potential errors corrected to the preferred
84                             checkpatch style
85  --fix-inplace EXPERIMENTAL - may create horrible results
86                             Is the same as --fix, but overwrites the input
87                             file. It's your fault if there's no backup or git
88  --ignore-perl-version override checking of perl version. expect
89                             runtime errors.
90  -h, --help, --version display this help and exit
91
92When FILE is - read standard input.
93EOM
94
95    exit($exitcode);
96}
97
98my $conf = which_conf($configuration_file);
99if (-f $conf) {
100    my @conf_args;
101    open(my $conffile, '<', "$conf")
102        or warn "$P: Can't find a readable $configuration_file file $!\n";
103
104    while (<$conffile>) {
105        my $line = $_;
106
107        $line =~ s/\s*\n?$//g;
108        $line =~ s/^\s*//g;
109        $line =~ s/\s+/ /g;
110
111        next if ($line =~ m/^\s*#/);
112        next if ($line =~ m/^\s*$/);
113
114        my @words = split(" ", $line);
115        foreach my $word (@words) {
116            last if ($word =~ m/^#/);
117            push (@conf_args, $word);
118        }
119    }
120    close($conffile);
121    unshift(@ARGV, @conf_args) if @conf_args;
122}
123
124GetOptions(
125    'q|quiet+' => \$quiet,
126    'tree!' => \$tree,
127    'signoff!' => \$chk_signoff,
128    'patch!' => \$chk_patch,
129    'emacs!' => \$emacs,
130    'terse!' => \$terse,
131    'f|file!' => \$file,
132    'subjective!' => \$check,
133    'strict!' => \$check,
134    'ignore=s' => \@ignore,
135    'types=s' => \@use,
136    'show-types!' => \$show_types,
137    'max-line-length=i' => \$max_line_length,
138    'min-conf-desc-length=i' => \$min_conf_desc_length,
139    'root=s' => \$root,
140    'summary!' => \$summary,
141    'mailback!' => \$mailback,
142    'summary-file!' => \$summary_file,
143    'fix!' => \$fix,
144    'fix-inplace!' => \$fix_inplace,
145    'ignore-perl-version!' => \$ignore_perl_version,
146    'debug=s' => \%debug,
147    'test-only=s' => \$tst_only,
148    'h|help' => \$help,
149    'version' => \$help
150) or help(1);
151
152help(0) if ($help);
153
154$fix = 1 if ($fix_inplace);
155$check_orig = $check;
156
157my $exit = 0;
158
159if ($^V && $^V lt $minimum_perl_version) {
160    printf "$P: requires at least perl version %vd\n", $minimum_perl_version;
161    if (!$ignore_perl_version) {
162        exit(1);
163    }
164}
165
166if ($#ARGV < 0) {
167    print "$P: no input files\n";
168    exit(1);
169}
170
171sub hash_save_array_words {
172    my ($hashRef, $arrayRef) = @_;
173
174    my @array = split(/,/, join(',', @$arrayRef));
175    foreach my $word (@array) {
176        $word =~ s/\s*\n?$//g;
177        $word =~ s/^\s*//g;
178        $word =~ s/\s+/ /g;
179        $word =~ tr/[a-z]/[A-Z]/;
180
181        next if ($word =~ m/^\s*#/);
182        next if ($word =~ m/^\s*$/);
183
184        $hashRef->{$word}++;
185    }
186}
187
188sub hash_show_words {
189    my ($hashRef, $prefix) = @_;
190
191    if ($quiet == 0 && keys %$hashRef) {
192        print "NOTE: $prefix message types:";
193        foreach my $word (sort keys %$hashRef) {
194            print " $word";
195        }
196        print "\n\n";
197    }
198}
199
200hash_save_array_words(\%ignore_type, \@ignore);
201hash_save_array_words(\%use_type, \@use);
202
203my $dbg_values = 0;
204my $dbg_possible = 0;
205my $dbg_type = 0;
206my $dbg_attr = 0;
207for my $key (keys %debug) {
208    ## no critic
209    eval "\${dbg_$key} = '$debug{$key}';";
210    die "$@" if ($@);
211}
212
213my $rpt_cleaners = 0;
214
215if ($terse) {
216    $emacs = 1;
217    $quiet++;
218}
219
220if ($tree) {
221    if (defined $root) {
222        if (!top_of_kernel_tree($root)) {
223            die "$P: $root: --root does not point at a valid tree\n";
224        }
225    } else {
226        if (top_of_kernel_tree('.')) {
227            $root = '.';
228        } elsif ($0 =~ m@(.*)/scripts/[^/]*$@ &&
229                        top_of_kernel_tree($1)) {
230            $root = $1;
231        }
232    }
233
234    if (!defined $root) {
235        print "Must be run from the top-level dir. of a kernel tree\n";
236        exit(2);
237    }
238}
239
240my $emitted_corrupt = 0;
241
242our $Ident = qr{
243            [A-Za-z_][A-Za-z\d_]*
244            (?:\s*\#\#\s*[A-Za-z_][A-Za-z\d_]*)*
245        }x;
246our $Storage = qr{extern|static|asmlinkage};
247our $Sparse = qr{
248            __user|
249            __kernel|
250            __force|
251            __iomem|
252            __must_check|
253            __init_refok|
254            __kprobes|
255            __ref|
256            __rcu
257        }x;
258our $InitAttributePrefix = qr{__(?:mem|cpu|dev|net_|)};
259our $InitAttributeData = qr{$InitAttributePrefix(?:initdata\b)};
260our $InitAttributeConst = qr{$InitAttributePrefix(?:initconst\b)};
261our $InitAttributeInit = qr{$InitAttributePrefix(?:init\b)};
262our $InitAttribute = qr{$InitAttributeData|$InitAttributeConst|$InitAttributeInit};
263
264# Notes to $Attribute:
265# We need \b after 'init' otherwise 'initconst' will cause a false positive in a check
266our $Attribute = qr{
267            const|
268            __percpu|
269            __nocast|
270            __safe|
271            __bitwise__|
272            __packed__|
273            __packed2__|
274            __naked|
275            __maybe_unused|
276            __always_unused|
277            __noreturn|
278            __used|
279            __cold|
280            __noclone|
281            __deprecated|
282            __read_mostly|
283            __kprobes|
284            $InitAttribute|
285            ____cacheline_aligned|
286            ____cacheline_aligned_in_smp|
287            ____cacheline_internodealigned_in_smp|
288            __weak
289          }x;
290our $Modifier;
291our $Inline = qr{inline|__always_inline|noinline|__inline|__inline__};
292our $Member = qr{->$Ident|\.$Ident|\[[^]]*\]};
293our $Lval = qr{$Ident(?:$Member)*};
294
295our $Int_type = qr{(?i)llu|ull|ll|lu|ul|l|u};
296our $Binary = qr{(?i)0b[01]+$Int_type?};
297our $Hex = qr{(?i)0x[0-9a-f]+$Int_type?};
298our $Int = qr{[0-9]+$Int_type?};
299our $Octal = qr{0[0-7]+$Int_type?};
300our $Float_hex = qr{(?i)0x[0-9a-f]+p-?[0-9]+[fl]?};
301our $Float_dec = qr{(?i)(?:[0-9]+\.[0-9]*|[0-9]*\.[0-9]+)(?:e-?[0-9]+)?[fl]?};
302our $Float_int = qr{(?i)[0-9]+e-?[0-9]+[fl]?};
303our $Float = qr{$Float_hex|$Float_dec|$Float_int};
304our $Constant = qr{$Float|$Binary|$Octal|$Hex|$Int};
305our $Assignment = qr{\*\=|/=|%=|\+=|-=|<<=|>>=|&=|\^=|\|=|=};
306our $Compare = qr{<=|>=|==|!=|<|(?<!-)>};
307our $Arithmetic = qr{\+|-|\*|\/|%};
308our $Operators = qr{
309            <=|>=|==|!=|
310            =>|->|<<|>>|<|>|!|~|
311            &&|\|\||,|\^|\+\+|--|&|\||$Arithmetic
312          }x;
313
314our $c90_Keywords = qr{do|for|while|if|else|return|goto|continue|switch|default|case|break}x;
315
316our $NonptrType;
317our $NonptrTypeMisordered;
318our $NonptrTypeWithAttr;
319our $Type;
320our $TypeMisordered;
321our $Declare;
322our $DeclareMisordered;
323
324our $NON_ASCII_UTF8 = qr{
325    [\xC2-\xDF][\x80-\xBF] # non-overlong 2-byte
326    | \xE0[\xA0-\xBF][\x80-\xBF] # excluding overlongs
327    | [\xE1-\xEC\xEE\xEF][\x80-\xBF]{2} # straight 3-byte
328    | \xED[\x80-\x9F][\x80-\xBF] # excluding surrogates
329    | \xF0[\x90-\xBF][\x80-\xBF]{2} # planes 1-3
330    | [\xF1-\xF3][\x80-\xBF]{3} # planes 4-15
331    | \xF4[\x80-\x8F][\x80-\xBF]{2} # plane 16
332}x;
333
334our $UTF8 = qr{
335    [\x09\x0A\x0D\x20-\x7E] # ASCII
336    | $NON_ASCII_UTF8
337}x;
338
339our $typeTypedefs = qr{(?x:
340    (?:__)?(?:u|s|be|le)(?:8|16|32|64)|
341    atomic_t
342)};
343
344our $logFunctions = qr{(?x:
345    printk(?:_ratelimited|_once|)|
346    (?:[a-z0-9]+_){1,2}(?:printk|emerg|alert|crit|err|warning|warn|notice|info|debug|dbg|vdbg|devel|cont|WARN)(?:_ratelimited|_once|)|
347    WARN(?:_RATELIMIT|_ONCE|)|
348    panic|
349    MODULE_[A-Z_]+|
350    seq_vprintf|seq_printf|seq_puts
351)};
352
353our $signature_tags = qr{(?xi:
354    Signed-off-by:|
355    Acked-by:|
356    Tested-by:|
357    Reviewed-by:|
358    Reported-by:|
359    Suggested-by:|
360    To:|
361    Cc:
362)};
363
364our @typeListMisordered = (
365    qr{char\s+(?:un)?signed},
366    qr{int\s+(?:(?:un)?signed\s+)?short\s},
367    qr{int\s+short(?:\s+(?:un)?signed)},
368    qr{short\s+int(?:\s+(?:un)?signed)},
369    qr{(?:un)?signed\s+int\s+short},
370    qr{short\s+(?:un)?signed},
371    qr{long\s+int\s+(?:un)?signed},
372    qr{int\s+long\s+(?:un)?signed},
373    qr{long\s+(?:un)?signed\s+int},
374    qr{int\s+(?:un)?signed\s+long},
375    qr{int\s+(?:un)?signed},
376    qr{int\s+long\s+long\s+(?:un)?signed},
377    qr{long\s+long\s+int\s+(?:un)?signed},
378    qr{long\s+long\s+(?:un)?signed\s+int},
379    qr{long\s+long\s+(?:un)?signed},
380    qr{long\s+(?:un)?signed},
381);
382
383our @typeList = (
384    qr{void},
385    qr{(?:(?:un)?signed\s+)?char},
386    qr{(?:(?:un)?signed\s+)?short\s+int},
387    qr{(?:(?:un)?signed\s+)?short},
388    qr{(?:(?:un)?signed\s+)?int},
389    qr{(?:(?:un)?signed\s+)?long\s+int},
390    qr{(?:(?:un)?signed\s+)?long\s+long\s+int},
391    qr{(?:(?:un)?signed\s+)?long\s+long},
392    qr{(?:(?:un)?signed\s+)?long},
393    qr{(?:un)?signed},
394    qr{float},
395    qr{double},
396    qr{bool},
397    qr{struct\s+$Ident},
398    qr{union\s+$Ident},
399    qr{enum\s+$Ident},
400    qr{${Ident}_t},
401    qr{${Ident}_handler},
402    qr{${Ident}_handler_fn},
403    @typeListMisordered,
404);
405our @typeListWithAttr = (
406    @typeList,
407    qr{struct\s+$InitAttribute\s+$Ident},
408    qr{union\s+$InitAttribute\s+$Ident},
409);
410
411our @modifierList = (
412    qr{fastcall},
413);
414
415our @mode_permission_funcs = (
416    ["module_param", 3],
417    ["module_param_(?:array|named|string)", 4],
418    ["module_param_array_named", 5],
419    ["debugfs_create_(?:file|u8|u16|u32|u64|x8|x16|x32|x64|size_t|atomic_t|bool|blob|regset32|u32_array)", 2],
420    ["proc_create(?:_data|)", 2],
421    ["(?:CLASS|DEVICE|SENSOR)_ATTR", 2],
422);
423
424#Create a search pattern for all these functions to speed up a loop below
425our $mode_perms_search = "";
426foreach my $entry (@mode_permission_funcs) {
427    $mode_perms_search .= '|' if ($mode_perms_search ne "");
428    $mode_perms_search .= $entry->[0];
429}
430
431our $allowed_asm_includes = qr{(?x:
432    irq|
433    memory|
434    time|
435    reboot
436)};
437# memory.h: ARM has a custom one
438
439# Load common spelling mistakes and build regular expression list.
440my $misspellings;
441my @spelling_list;
442my %spelling_fix;
443open(my $spelling, '<', $spelling_file)
444    or die "$P: Can't open $spelling_file for reading: $!\n";
445while (<$spelling>) {
446    my $line = $_;
447
448    $line =~ s/\s*\n?$//g;
449    $line =~ s/^\s*//g;
450
451    next if ($line =~ m/^\s*#/);
452    next if ($line =~ m/^\s*$/);
453
454    my ($suspect, $fix) = split(/\|\|/, $line);
455
456    push(@spelling_list, $suspect);
457    $spelling_fix{$suspect} = $fix;
458}
459close($spelling);
460$misspellings = join("|", @spelling_list);
461
462sub build_types {
463    my $mods = "(?x: \n" . join("|\n ", @modifierList) . "\n)";
464    my $all = "(?x: \n" . join("|\n ", @typeList) . "\n)";
465    my $Misordered = "(?x: \n" . join("|\n ", @typeListMisordered) . "\n)";
466    my $allWithAttr = "(?x: \n" . join("|\n ", @typeListWithAttr) . "\n)";
467    $Modifier = qr{(?:$Attribute|$Sparse|$mods)};
468    $NonptrType = qr{
469            (?:$Modifier\s+|const\s+)*
470            (?:
471                (?:typeof|__typeof__)\s*\([^\)]*\)|
472                (?:$typeTypedefs\b)|
473                (?:${all}\b)
474            )
475            (?:\s+$Modifier|\s+const)*
476          }x;
477    $NonptrTypeMisordered = qr{
478            (?:$Modifier\s+|const\s+)*
479            (?:
480                (?:${Misordered}\b)
481            )
482            (?:\s+$Modifier|\s+const)*
483          }x;
484    $NonptrTypeWithAttr = qr{
485            (?:$Modifier\s+|const\s+)*
486            (?:
487                (?:typeof|__typeof__)\s*\([^\)]*\)|
488                (?:$typeTypedefs\b)|
489                (?:${allWithAttr}\b)
490            )
491            (?:\s+$Modifier|\s+const)*
492          }x;
493    $Type = qr{
494            $NonptrType
495            (?:(?:\s|\*|\[\])+\s*const|(?:\s|\*\s*(?:const\s*)?|\[\])+|(?:\s*\[\s*\])+)?
496            (?:\s+$Inline|\s+$Modifier)*
497          }x;
498    $TypeMisordered = qr{
499            $NonptrTypeMisordered
500            (?:(?:\s|\*|\[\])+\s*const|(?:\s|\*\s*(?:const\s*)?|\[\])+|(?:\s*\[\s*\])+)?
501            (?:\s+$Inline|\s+$Modifier)*
502          }x;
503    $Declare = qr{(?:$Storage\s+(?:$Inline\s+)?)?$Type};
504    $DeclareMisordered = qr{(?:$Storage\s+(?:$Inline\s+)?)?$TypeMisordered};
505}
506build_types();
507
508our $Typecast = qr{\s*(\(\s*$NonptrType\s*\)){0,1}\s*};
509
510# Using $balanced_parens, $LvalOrFunc, or $FuncArg
511# requires at least perl version v5.10.0
512# Any use must be runtime checked with $^V
513
514our $balanced_parens = qr/(\((?:[^\(\)]++|(?-1))*\))/;
515our $LvalOrFunc = qr{((?:[\&\*]\s*)?$Lval)\s*($balanced_parens{0,1})\s*};
516our $FuncArg = qr{$Typecast{0,1}($LvalOrFunc|$Constant)};
517
518our $declaration_macros = qr{(?x:
519    (?:$Storage\s+)?(?:[A-Z_][A-Z0-9]*_){0,2}(?:DEFINE|DECLARE)(?:_[A-Z0-9]+){1,2}\s*\(|
520    (?:$Storage\s+)?LIST_HEAD\s*\(|
521    (?:$Storage\s+)?${Type}\s+uninitialized_var\s*\(
522)};
523
524sub deparenthesize {
525    my ($string) = @_;
526    return "" if (!defined($string));
527
528    while ($string =~ /^\s*\(.*\)\s*$/) {
529        $string =~ s@^\s*\(\s*@@;
530        $string =~ s@\s*\)\s*$@@;
531    }
532
533    $string =~ s@\s+@ @g;
534
535    return $string;
536}
537
538sub seed_camelcase_file {
539    my ($file) = @_;
540
541    return if (!(-f $file));
542
543    local $/;
544
545    open(my $include_file, '<', "$file")
546        or warn "$P: Can't read '$file' $!\n";
547    my $text = <$include_file>;
548    close($include_file);
549
550    my @lines = split('\n', $text);
551
552    foreach my $line (@lines) {
553        next if ($line !~ /(?:[A-Z][a-z]|[a-z][A-Z])/);
554        if ($line =~ /^[ \t]*(?:#[ \t]*define|typedef\s+$Type)\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)/) {
555            $camelcase{$1} = 1;
556        } elsif ($line =~ /^\s*$Declare\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)\s*[\(\[,;]/) {
557            $camelcase{$1} = 1;
558        } elsif ($line =~ /^\s*(?:union|struct|enum)\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)\s*[;\{]/) {
559            $camelcase{$1} = 1;
560        }
561    }
562}
563
564my $camelcase_seeded = 0;
565sub seed_camelcase_includes {
566    return if ($camelcase_seeded);
567
568    my $files;
569    my $camelcase_cache = "";
570    my @include_files = ();
571
572    $camelcase_seeded = 1;
573
574    if (-e ".git") {
575        my $git_last_include_commit = `git log --no-merges --pretty=format:"%h%n" -1 -- include`;
576        chomp $git_last_include_commit;
577        $camelcase_cache = ".checkpatch-camelcase.git.$git_last_include_commit";
578    } else {
579        my $last_mod_date = 0;
580        $files = `find $root/include -name "*.h"`;
581        @include_files = split('\n', $files);
582        foreach my $file (@include_files) {
583            my $date = POSIX::strftime("%Y%m%d%H%M",
584                           localtime((stat $file)[9]));
585            $last_mod_date = $date if ($last_mod_date < $date);
586        }
587        $camelcase_cache = ".checkpatch-camelcase.date.$last_mod_date";
588    }
589
590    if ($camelcase_cache ne "" && -f $camelcase_cache) {
591        open(my $camelcase_file, '<', "$camelcase_cache")
592            or warn "$P: Can't read '$camelcase_cache' $!\n";
593        while (<$camelcase_file>) {
594            chomp;
595            $camelcase{$_} = 1;
596        }
597        close($camelcase_file);
598
599        return;
600    }
601
602    if (-e ".git") {
603        $files = `git ls-files "include/*.h"`;
604        @include_files = split('\n', $files);
605    }
606
607    foreach my $file (@include_files) {
608        seed_camelcase_file($file);
609    }
610
611    if ($camelcase_cache ne "") {
612        unlink glob ".checkpatch-camelcase.*";
613        open(my $camelcase_file, '>', "$camelcase_cache")
614            or warn "$P: Can't write '$camelcase_cache' $!\n";
615        foreach (sort { lc($a) cmp lc($b) } keys(%camelcase)) {
616            print $camelcase_file ("$_\n");
617        }
618        close($camelcase_file);
619    }
620}
621
622sub git_commit_info {
623    my ($commit, $id, $desc) = @_;
624
625    return ($id, $desc) if ((which("git") eq "") || !(-e ".git"));
626
627    my $output = `git log --no-color --format='%H %s' -1 $commit 2>&1`;
628    $output =~ s/^\s*//gm;
629    my @lines = split("\n", $output);
630
631    if ($lines[0] =~ /^error: short SHA1 $commit is ambiguous\./) {
632# Maybe one day convert this block of bash into something that returns
633# all matching commit ids, but it's very slow...
634#
635# echo "checking commits $1..."
636# git rev-list --remotes | grep -i "^$1" |
637# while read line ; do
638# git log --format='%H %s' -1 $line |
639# echo "commit $(cut -c 1-12,41-)"
640# done
641    } elsif ($lines[0] =~ /^fatal: ambiguous argument '$commit': unknown revision or path not in the working tree\./) {
642    } else {
643        $id = substr($lines[0], 0, 12);
644        $desc = substr($lines[0], 41);
645    }
646
647    return ($id, $desc);
648}
649
650$chk_signoff = 0 if ($file);
651
652my @rawlines = ();
653my @lines = ();
654my @fixed = ();
655my @fixed_inserted = ();
656my @fixed_deleted = ();
657my $fixlinenr = -1;
658
659my $vname;
660for my $filename (@ARGV) {
661    my $FILE;
662    if ($file) {
663        open($FILE, '-|', "diff -u /dev/null $filename") ||
664            die "$P: $filename: diff failed - $!\n";
665    } elsif ($filename eq '-') {
666        open($FILE, '<&STDIN');
667    } else {
668        open($FILE, '<', "$filename") ||
669            die "$P: $filename: open failed - $!\n";
670    }
671    if ($filename eq '-') {
672        $vname = 'Your patch';
673    } else {
674        $vname = $filename;
675    }
676    while (<$FILE>) {
677        chomp;
678        push(@rawlines, $_);
679    }
680    close($FILE);
681    if (!process($filename)) {
682        $exit = 1;
683    }
684    @rawlines = ();
685    @lines = ();
686    @fixed = ();
687    @fixed_inserted = ();
688    @fixed_deleted = ();
689    $fixlinenr = -1;
690}
691
692exit($exit);
693
694sub top_of_kernel_tree {
695    my ($root) = @_;
696
697    my @tree_check = (
698        "COPYING", "CREDITS", "Kbuild", "MAINTAINERS", "Makefile",
699        "README", "Documentation", "arch", "include", "drivers",
700        "fs", "init", "ipc", "kernel", "lib", "scripts",
701    );
702
703    foreach my $check (@tree_check) {
704        if (! -e $root . '/' . $check) {
705            return 0;
706        }
707    }
708    return 1;
709}
710
711sub parse_email {
712    my ($formatted_email) = @_;
713
714    my $name = "";
715    my $address = "";
716    my $comment = "";
717
718    if ($formatted_email =~ /^(.*)<(\S+\@\S+)>(.*)$/) {
719        $name = $1;
720        $address = $2;
721        $comment = $3 if defined $3;
722    } elsif ($formatted_email =~ /^\s*<(\S+\@\S+)>(.*)$/) {
723        $address = $1;
724        $comment = $2 if defined $2;
725    } elsif ($formatted_email =~ /(\S+\@\S+)(.*)$/) {
726        $address = $1;
727        $comment = $2 if defined $2;
728        $formatted_email =~ s/$address.*$//;
729        $name = $formatted_email;
730        $name = trim($name);
731        $name =~ s/^\"|\"$//g;
732        # If there's a name left after stripping spaces and
733        # leading quotes, and the address doesn't have both
734        # leading and trailing angle brackets, the address
735        # is invalid. ie:
736        # "joe smith joe@smith.com" bad
737        # "joe smith <joe@smith.com" bad
738        if ($name ne "" && $address !~ /^<[^>]+>$/) {
739            $name = "";
740            $address = "";
741            $comment = "";
742        }
743    }
744
745    $name = trim($name);
746    $name =~ s/^\"|\"$//g;
747    $address = trim($address);
748    $address =~ s/^\<|\>$//g;
749
750    if ($name =~ /[^\w \-]/i) { ##has "must quote" chars
751        $name =~ s/(?<!\\)"/\\"/g; ##escape quotes
752        $name = "\"$name\"";
753    }
754
755    return ($name, $address, $comment);
756}
757
758sub format_email {
759    my ($name, $address) = @_;
760
761    my $formatted_email;
762
763    $name = trim($name);
764    $name =~ s/^\"|\"$//g;
765    $address = trim($address);
766
767    if ($name =~ /[^\w \-]/i) { ##has "must quote" chars
768        $name =~ s/(?<!\\)"/\\"/g; ##escape quotes
769        $name = "\"$name\"";
770    }
771
772    if ("$name" eq "") {
773        $formatted_email = "$address";
774    } else {
775        $formatted_email = "$name <$address>";
776    }
777
778    return $formatted_email;
779}
780
781sub which {
782    my ($bin) = @_;
783
784    foreach my $path (split(/:/, $ENV{PATH})) {
785        if (-e "$path/$bin") {
786            return "$path/$bin";
787        }
788    }
789
790    return "";
791}
792
793sub which_conf {
794    my ($conf) = @_;
795
796    foreach my $path (split(/:/, ".:$ENV{HOME}:.scripts")) {
797        if (-e "$path/$conf") {
798            return "$path/$conf";
799        }
800    }
801
802    return "";
803}
804
805sub expand_tabs {
806    my ($str) = @_;
807
808    my $res = '';
809    my $n = 0;
810    for my $c (split(//, $str)) {
811        if ($c eq "\t") {
812            $res .= ' ';
813            $n++;
814            for (; ($n % 8) != 0; $n++) {
815                $res .= ' ';
816            }
817            next;
818        }
819        $res .= $c;
820        $n++;
821    }
822
823    return $res;
824}
825sub copy_spacing {
826    (my $res = shift) =~ tr/\t/ /c;
827    return $res;
828}
829
830sub line_stats {
831    my ($line) = @_;
832
833    # Drop the diff line leader and expand tabs
834    $line =~ s/^.//;
835    $line = expand_tabs($line);
836
837    # Pick the indent from the front of the line.
838    my ($white) = ($line =~ /^(\s*)/);
839
840    return (length($line), length($white));
841}
842
843my $sanitise_quote = '';
844
845sub sanitise_line_reset {
846    my ($in_comment) = @_;
847
848    if ($in_comment) {
849        $sanitise_quote = '*/';
850    } else {
851        $sanitise_quote = '';
852    }
853}
854sub sanitise_line {
855    my ($line) = @_;
856
857    my $res = '';
858    my $l = '';
859
860    my $qlen = 0;
861    my $off = 0;
862    my $c;
863
864    # Always copy over the diff marker.
865    $res = substr($line, 0, 1);
866
867    for ($off = 1; $off < length($line); $off++) {
868        $c = substr($line, $off, 1);
869
870        # Comments we are wacking completly including the begin
871        # and end, all to $;.
872        if ($sanitise_quote eq '' && substr($line, $off, 2) eq '/*') {
873            $sanitise_quote = '*/';
874
875            substr($res, $off, 2, "$;$;");
876            $off++;
877            next;
878        }
879        if ($sanitise_quote eq '*/' && substr($line, $off, 2) eq '*/') {
880            $sanitise_quote = '';
881            substr($res, $off, 2, "$;$;");
882            $off++;
883            next;
884        }
885        if ($sanitise_quote eq '' && substr($line, $off, 2) eq '//') {
886            $sanitise_quote = '//';
887
888            substr($res, $off, 2, $sanitise_quote);
889            $off++;
890            next;
891        }
892
893        # A \ in a string means ignore the next character.
894        if (($sanitise_quote eq "'" || $sanitise_quote eq '"') &&
895            $c eq "\\") {
896            substr($res, $off, 2, 'XX');
897            $off++;
898            next;
899        }
900        # Regular quotes.
901        if ($c eq "'" || $c eq '"') {
902            if ($sanitise_quote eq '') {
903                $sanitise_quote = $c;
904
905                substr($res, $off, 1, $c);
906                next;
907            } elsif ($sanitise_quote eq $c) {
908                $sanitise_quote = '';
909            }
910        }
911
912        #print "c<$c> SQ<$sanitise_quote>\n";
913        if ($off != 0 && $sanitise_quote eq '*/' && $c ne "\t") {
914            substr($res, $off, 1, $;);
915        } elsif ($off != 0 && $sanitise_quote eq '//' && $c ne "\t") {
916            substr($res, $off, 1, $;);
917        } elsif ($off != 0 && $sanitise_quote && $c ne "\t") {
918            substr($res, $off, 1, 'X');
919        } else {
920            substr($res, $off, 1, $c);
921        }
922    }
923
924    if ($sanitise_quote eq '//') {
925        $sanitise_quote = '';
926    }
927
928    # The pathname on a #include may be surrounded by '<' and '>'.
929    if ($res =~ /^.\s*\#\s*include\s+\<(.*)\>/) {
930        my $clean = 'X' x length($1);
931        $res =~ s@\<.*\>@<$clean>@;
932
933    # The whole of a #error is a string.
934    } elsif ($res =~ /^.\s*\#\s*(?:error|warning)\s+(.*)\b/) {
935        my $clean = 'X' x length($1);
936        $res =~ s@(\#\s*(?:error|warning)\s+).*@$1$clean@;
937    }
938
939    return $res;
940}
941
942sub get_quoted_string {
943    my ($line, $rawline) = @_;
944
945    return "" if ($line !~ m/(\"[X]+\")/g);
946    return substr($rawline, $-[0], $+[0] - $-[0]);
947}
948
949sub ctx_statement_block {
950    my ($linenr, $remain, $off) = @_;
951    my $line = $linenr - 1;
952    my $blk = '';
953    my $soff = $off;
954    my $coff = $off - 1;
955    my $coff_set = 0;
956
957    my $loff = 0;
958
959    my $type = '';
960    my $level = 0;
961    my @stack = ();
962    my $p;
963    my $c;
964    my $len = 0;
965
966    my $remainder;
967    while (1) {
968        @stack = (['', 0]) if ($#stack == -1);
969
970        #warn "CSB: blk<$blk> remain<$remain>\n";
971        # If we are about to drop off the end, pull in more
972        # context.
973        if ($off >= $len) {
974            for (; $remain > 0; $line++) {
975                last if (!defined $lines[$line]);
976                next if ($lines[$line] =~ /^-/);
977                $remain--;
978                $loff = $len;
979                $blk .= $lines[$line] . "\n";
980                $len = length($blk);
981                $line++;
982                last;
983            }
984            # Bail if there is no further context.
985            #warn "CSB: blk<$blk> off<$off> len<$len>\n";
986            if ($off >= $len) {
987                last;
988            }
989            if ($level == 0 && substr($blk, $off) =~ /^.\s*#\s*define/) {
990                $level++;
991                $type = '#';
992            }
993        }
994        $p = $c;
995        $c = substr($blk, $off, 1);
996        $remainder = substr($blk, $off);
997
998        #warn "CSB: c<$c> type<$type> level<$level> remainder<$remainder> coff_set<$coff_set>\n";
999
1000        # Handle nested #if/#else.
1001        if ($remainder =~ /^#\s*(?:ifndef|ifdef|if)\s/) {
1002            push(@stack, [ $type, $level ]);
1003        } elsif ($remainder =~ /^#\s*(?:else|elif)\b/) {
1004            ($type, $level) = @{$stack[$#stack - 1]};
1005        } elsif ($remainder =~ /^#\s*endif\b/) {
1006            ($type, $level) = @{pop(@stack)};
1007        }
1008
1009        # Statement ends at the ';' or a close '}' at the
1010        # outermost level.
1011        if ($level == 0 && $c eq ';') {
1012            last;
1013        }
1014
1015        # An else is really a conditional as long as its not else if
1016        if ($level == 0 && $coff_set == 0 &&
1017                (!defined($p) || $p =~ /(?:\s|\}|\+)/) &&
1018                $remainder =~ /^(else)(?:\s|{)/ &&
1019                $remainder !~ /^else\s+if\b/) {
1020            $coff = $off + length($1) - 1;
1021            $coff_set = 1;
1022            #warn "CSB: mark coff<$coff> soff<$soff> 1<$1>\n";
1023            #warn "[" . substr($blk, $soff, $coff - $soff + 1) . "]\n";
1024        }
1025
1026        if (($type eq '' || $type eq '(') && $c eq '(') {
1027            $level++;
1028            $type = '(';
1029        }
1030        if ($type eq '(' && $c eq ')') {
1031            $level--;
1032            $type = ($level != 0)? '(' : '';
1033
1034            if ($level == 0 && $coff < $soff) {
1035                $coff = $off;
1036                $coff_set = 1;
1037                #warn "CSB: mark coff<$coff>\n";
1038            }
1039        }
1040        if (($type eq '' || $type eq '{') && $c eq '{') {
1041            $level++;
1042            $type = '{';
1043        }
1044        if ($type eq '{' && $c eq '}') {
1045            $level--;
1046            $type = ($level != 0)? '{' : '';
1047
1048            if ($level == 0) {
1049                if (substr($blk, $off + 1, 1) eq ';') {
1050                    $off++;
1051                }
1052                last;
1053            }
1054        }
1055        # Preprocessor commands end at the newline unless escaped.
1056        if ($type eq '#' && $c eq "\n" && $p ne "\\") {
1057            $level--;
1058            $type = '';
1059            $off++;
1060            last;
1061        }
1062        $off++;
1063    }
1064    # We are truly at the end, so shuffle to the next line.
1065    if ($off == $len) {
1066        $loff = $len + 1;
1067        $line++;
1068        $remain--;
1069    }
1070
1071    my $statement = substr($blk, $soff, $off - $soff + 1);
1072    my $condition = substr($blk, $soff, $coff - $soff + 1);
1073
1074    #warn "STATEMENT<$statement>\n";
1075    #warn "CONDITION<$condition>\n";
1076
1077    #print "coff<$coff> soff<$off> loff<$loff>\n";
1078
1079    return ($statement, $condition,
1080            $line, $remain + 1, $off - $loff + 1, $level);
1081}
1082
1083sub statement_lines {
1084    my ($stmt) = @_;
1085
1086    # Strip the diff line prefixes and rip blank lines at start and end.
1087    $stmt =~ s/(^|\n)./$1/g;
1088    $stmt =~ s/^\s*//;
1089    $stmt =~ s/\s*$//;
1090
1091    my @stmt_lines = ($stmt =~ /\n/g);
1092
1093    return $#stmt_lines + 2;
1094}
1095
1096sub statement_rawlines {
1097    my ($stmt) = @_;
1098
1099    my @stmt_lines = ($stmt =~ /\n/g);
1100
1101    return $#stmt_lines + 2;
1102}
1103
1104sub statement_block_size {
1105    my ($stmt) = @_;
1106
1107    $stmt =~ s/(^|\n)./$1/g;
1108    $stmt =~ s/^\s*{//;
1109    $stmt =~ s/}\s*$//;
1110    $stmt =~ s/^\s*//;
1111    $stmt =~ s/\s*$//;
1112
1113    my @stmt_lines = ($stmt =~ /\n/g);
1114    my @stmt_statements = ($stmt =~ /;/g);
1115
1116    my $stmt_lines = $#stmt_lines + 2;
1117    my $stmt_statements = $#stmt_statements + 1;
1118
1119    if ($stmt_lines > $stmt_statements) {
1120        return $stmt_lines;
1121    } else {
1122        return $stmt_statements;
1123    }
1124}
1125
1126sub ctx_statement_full {
1127    my ($linenr, $remain, $off) = @_;
1128    my ($statement, $condition, $level);
1129
1130    my (@chunks);
1131
1132    # Grab the first conditional/block pair.
1133    ($statement, $condition, $linenr, $remain, $off, $level) =
1134                ctx_statement_block($linenr, $remain, $off);
1135    #print "F: c<$condition> s<$statement> remain<$remain>\n";
1136    push(@chunks, [ $condition, $statement ]);
1137    if (!($remain > 0 && $condition =~ /^\s*(?:\n[+-])?\s*(?:if|else|do)\b/s)) {
1138        return ($level, $linenr, @chunks);
1139    }
1140
1141    # Pull in the following conditional/block pairs and see if they
1142    # could continue the statement.
1143    for (;;) {
1144        ($statement, $condition, $linenr, $remain, $off, $level) =
1145                ctx_statement_block($linenr, $remain, $off);
1146        #print "C: c<$condition> s<$statement> remain<$remain>\n";
1147        last if (!($remain > 0 && $condition =~ /^(?:\s*\n[+-])*\s*(?:else|do)\b/s));
1148        #print "C: push\n";
1149        push(@chunks, [ $condition, $statement ]);
1150    }
1151
1152    return ($level, $linenr, @chunks);
1153}
1154
1155sub ctx_block_get {
1156    my ($linenr, $remain, $outer, $open, $close, $off) = @_;
1157    my $line;
1158    my $start = $linenr - 1;
1159    my $blk = '';
1160    my @o;
1161    my @c;
1162    my @res = ();
1163
1164    my $level = 0;
1165    my @stack = ($level);
1166    for ($line = $start; $remain > 0; $line++) {
1167        next if ($rawlines[$line] =~ /^-/);
1168        $remain--;
1169
1170        $blk .= $rawlines[$line];
1171
1172        # Handle nested #if/#else.
1173        if ($lines[$line] =~ /^.\s*#\s*(?:ifndef|ifdef|if)\s/) {
1174            push(@stack, $level);
1175        } elsif ($lines[$line] =~ /^.\s*#\s*(?:else|elif)\b/) {
1176            $level = $stack[$#stack - 1];
1177        } elsif ($lines[$line] =~ /^.\s*#\s*endif\b/) {
1178            $level = pop(@stack);
1179        }
1180
1181        foreach my $c (split(//, $lines[$line])) {
1182            ##print "C<$c>L<$level><$open$close>O<$off>\n";
1183            if ($off > 0) {
1184                $off--;
1185                next;
1186            }
1187
1188            if ($c eq $close && $level > 0) {
1189                $level--;
1190                last if ($level == 0);
1191            } elsif ($c eq $open) {
1192                $level++;
1193            }
1194        }
1195
1196        if (!$outer || $level <= 1) {
1197            push(@res, $rawlines[$line]);
1198        }
1199
1200        last if ($level == 0);
1201    }
1202
1203    return ($level, @res);
1204}
1205sub ctx_block_outer {
1206    my ($linenr, $remain) = @_;
1207
1208    my ($level, @r) = ctx_block_get($linenr, $remain, 1, '{', '}', 0);
1209    return @r;
1210}
1211sub ctx_block {
1212    my ($linenr, $remain) = @_;
1213
1214    my ($level, @r) = ctx_block_get($linenr, $remain, 0, '{', '}', 0);
1215    return @r;
1216}
1217sub ctx_statement {
1218    my ($linenr, $remain, $off) = @_;
1219
1220    my ($level, @r) = ctx_block_get($linenr, $remain, 0, '(', ')', $off);
1221    return @r;
1222}
1223sub ctx_block_level {
1224    my ($linenr, $remain) = @_;
1225
1226    return ctx_block_get($linenr, $remain, 0, '{', '}', 0);
1227}
1228sub ctx_statement_level {
1229    my ($linenr, $remain, $off) = @_;
1230
1231    return ctx_block_get($linenr, $remain, 0, '(', ')', $off);
1232}
1233
1234sub ctx_locate_comment {
1235    my ($first_line, $end_line) = @_;
1236
1237    # Catch a comment on the end of the line itself.
1238    my ($current_comment) = ($rawlines[$end_line - 1] =~ m@.*(/\*.*\*/)\s*(?:\\\s*)?$@);
1239    return $current_comment if (defined $current_comment);
1240
1241    # Look through the context and try and figure out if there is a
1242    # comment.
1243    my $in_comment = 0;
1244    $current_comment = '';
1245    for (my $linenr = $first_line; $linenr < $end_line; $linenr++) {
1246        my $line = $rawlines[$linenr - 1];
1247        #warn " $line\n";
1248        if ($linenr == $first_line and $line =~ m@^.\s*\*@) {
1249            $in_comment = 1;
1250        }
1251        if ($line =~ m@/\*@) {
1252            $in_comment = 1;
1253        }
1254        if (!$in_comment && $current_comment ne '') {
1255            $current_comment = '';
1256        }
1257        $current_comment .= $line . "\n" if ($in_comment);
1258        if ($line =~ m@\*/@) {
1259            $in_comment = 0;
1260        }
1261    }
1262
1263    chomp($current_comment);
1264    return($current_comment);
1265}
1266sub ctx_has_comment {
1267    my ($first_line, $end_line) = @_;
1268    my $cmt = ctx_locate_comment($first_line, $end_line);
1269
1270    ##print "LINE: $rawlines[$end_line - 1 ]\n";
1271    ##print "CMMT: $cmt\n";
1272
1273    return ($cmt ne '');
1274}
1275
1276sub raw_line {
1277    my ($linenr, $cnt) = @_;
1278
1279    my $offset = $linenr - 1;
1280    $cnt++;
1281
1282    my $line;
1283    while ($cnt) {
1284        $line = $rawlines[$offset++];
1285        next if (defined($line) && $line =~ /^-/);
1286        $cnt--;
1287    }
1288
1289    return $line;
1290}
1291
1292sub cat_vet {
1293    my ($vet) = @_;
1294    my ($res, $coded);
1295
1296    $res = '';
1297    while ($vet =~ /([^[:cntrl:]]*)([[:cntrl:]]|$)/g) {
1298        $res .= $1;
1299        if ($2 ne '') {
1300            $coded = sprintf("^%c", unpack('C', $2) + 64);
1301            $res .= $coded;
1302        }
1303    }
1304    $res =~ s/$/\$/;
1305
1306    return $res;
1307}
1308
1309my $av_preprocessor = 0;
1310my $av_pending;
1311my @av_paren_type;
1312my $av_pend_colon;
1313
1314sub annotate_reset {
1315    $av_preprocessor = 0;
1316    $av_pending = '_';
1317    @av_paren_type = ('E');
1318    $av_pend_colon = 'O';
1319}
1320
1321sub annotate_values {
1322    my ($stream, $type) = @_;
1323
1324    my $res;
1325    my $var = '_' x length($stream);
1326    my $cur = $stream;
1327
1328    print "$stream\n" if ($dbg_values > 1);
1329
1330    while (length($cur)) {
1331        @av_paren_type = ('E') if ($#av_paren_type < 0);
1332        print " <" . join('', @av_paren_type) .
1333                "> <$type> <$av_pending>" if ($dbg_values > 1);
1334        if ($cur =~ /^(\s+)/o) {
1335            print "WS($1)\n" if ($dbg_values > 1);
1336            if ($1 =~ /\n/ && $av_preprocessor) {
1337                $type = pop(@av_paren_type);
1338                $av_preprocessor = 0;
1339            }
1340
1341        } elsif ($cur =~ /^(\(\s*$Type\s*)\)/ && $av_pending eq '_') {
1342            print "CAST($1)\n" if ($dbg_values > 1);
1343            push(@av_paren_type, $type);
1344            $type = 'c';
1345
1346        } elsif ($cur =~ /^($Type)\s*(?:$Ident|,|\)|\(|\s*$)/) {
1347            print "DECLARE($1)\n" if ($dbg_values > 1);
1348            $type = 'T';
1349
1350        } elsif ($cur =~ /^($Modifier)\s*/) {
1351            print "MODIFIER($1)\n" if ($dbg_values > 1);
1352            $type = 'T';
1353
1354        } elsif ($cur =~ /^(\#\s*define\s*$Ident)(\(?)/o) {
1355            print "DEFINE($1,$2)\n" if ($dbg_values > 1);
1356            $av_preprocessor = 1;
1357            push(@av_paren_type, $type);
1358            if ($2 ne '') {
1359                $av_pending = 'N';
1360            }
1361            $type = 'E';
1362
1363        } elsif ($cur =~ /^(\#\s*(?:undef\s*$Ident|include\b))/o) {
1364            print "UNDEF($1)\n" if ($dbg_values > 1);
1365            $av_preprocessor = 1;
1366            push(@av_paren_type, $type);
1367
1368        } elsif ($cur =~ /^(\#\s*(?:ifdef|ifndef|if))/o) {
1369            print "PRE_START($1)\n" if ($dbg_values > 1);
1370            $av_preprocessor = 1;
1371
1372            push(@av_paren_type, $type);
1373            push(@av_paren_type, $type);
1374            $type = 'E';
1375
1376        } elsif ($cur =~ /^(\#\s*(?:else|elif))/o) {
1377            print "PRE_RESTART($1)\n" if ($dbg_values > 1);
1378            $av_preprocessor = 1;
1379
1380            push(@av_paren_type, $av_paren_type[$#av_paren_type]);
1381
1382            $type = 'E';
1383
1384        } elsif ($cur =~ /^(\#\s*(?:endif))/o) {
1385            print "PRE_END($1)\n" if ($dbg_values > 1);
1386
1387            $av_preprocessor = 1;
1388
1389            # Assume all arms of the conditional end as this
1390            # one does, and continue as if the #endif was not here.
1391            pop(@av_paren_type);
1392            push(@av_paren_type, $type);
1393            $type = 'E';
1394
1395        } elsif ($cur =~ /^(\\\n)/o) {
1396            print "PRECONT($1)\n" if ($dbg_values > 1);
1397
1398        } elsif ($cur =~ /^(__attribute__)\s*\(?/o) {
1399            print "ATTR($1)\n" if ($dbg_values > 1);
1400            $av_pending = $type;
1401            $type = 'N';
1402
1403        } elsif ($cur =~ /^(sizeof)\s*(\()?/o) {
1404            print "SIZEOF($1)\n" if ($dbg_values > 1);
1405            if (defined $2) {
1406                $av_pending = 'V';
1407            }
1408            $type = 'N';
1409
1410        } elsif ($cur =~ /^(if|while|for)\b/o) {
1411            print "COND($1)\n" if ($dbg_values > 1);
1412            $av_pending = 'E';
1413            $type = 'N';
1414
1415        } elsif ($cur =~/^(case)/o) {
1416            print "CASE($1)\n" if ($dbg_values > 1);
1417            $av_pend_colon = 'C';
1418            $type = 'N';
1419
1420        } elsif ($cur =~/^(return|else|goto|typeof|__typeof__)\b/o) {
1421            print "KEYWORD($1)\n" if ($dbg_values > 1);
1422            $type = 'N';
1423
1424        } elsif ($cur =~ /^(\()/o) {
1425            print "PAREN('$1')\n" if ($dbg_values > 1);
1426            push(@av_paren_type, $av_pending);
1427            $av_pending = '_';
1428            $type = 'N';
1429
1430        } elsif ($cur =~ /^(\))/o) {
1431            my $new_type = pop(@av_paren_type);
1432            if ($new_type ne '_') {
1433                $type = $new_type;
1434                print "PAREN('$1') -> $type\n"
1435                            if ($dbg_values > 1);
1436            } else {
1437                print "PAREN('$1')\n" if ($dbg_values > 1);
1438            }
1439
1440        } elsif ($cur =~ /^($Ident)\s*\(/o) {
1441            print "FUNC($1)\n" if ($dbg_values > 1);
1442            $type = 'V';
1443            $av_pending = 'V';
1444
1445        } elsif ($cur =~ /^($Ident\s*):(?:\s*\d+\s*(,|=|;))?/) {
1446            if (defined $2 && $type eq 'C' || $type eq 'T') {
1447                $av_pend_colon = 'B';
1448            } elsif ($type eq 'E') {
1449                $av_pend_colon = 'L';
1450            }
1451            print "IDENT_COLON($1,$type>$av_pend_colon)\n" if ($dbg_values > 1);
1452            $type = 'V';
1453
1454        } elsif ($cur =~ /^($Ident|$Constant)/o) {
1455            print "IDENT($1)\n" if ($dbg_values > 1);
1456            $type = 'V';
1457
1458        } elsif ($cur =~ /^($Assignment)/o) {
1459            print "ASSIGN($1)\n" if ($dbg_values > 1);
1460            $type = 'N';
1461
1462        } elsif ($cur =~/^(;|{|})/) {
1463            print "END($1)\n" if ($dbg_values > 1);
1464            $type = 'E';
1465            $av_pend_colon = 'O';
1466
1467        } elsif ($cur =~/^(,)/) {
1468            print "COMMA($1)\n" if ($dbg_values > 1);
1469            $type = 'C';
1470
1471        } elsif ($cur =~ /^(\?)/o) {
1472            print "QUESTION($1)\n" if ($dbg_values > 1);
1473            $type = 'N';
1474
1475        } elsif ($cur =~ /^(:)/o) {
1476            print "COLON($1,$av_pend_colon)\n" if ($dbg_values > 1);
1477
1478            substr($var, length($res), 1, $av_pend_colon);
1479            if ($av_pend_colon eq 'C' || $av_pend_colon eq 'L') {
1480                $type = 'E';
1481            } else {
1482                $type = 'N';
1483            }
1484            $av_pend_colon = 'O';
1485
1486        } elsif ($cur =~ /^(\[)/o) {
1487            print "CLOSE($1)\n" if ($dbg_values > 1);
1488            $type = 'N';
1489
1490        } elsif ($cur =~ /^(-(?![->])|\+(?!\+)|\*|\&\&|\&)/o) {
1491            my $variant;
1492
1493            print "OPV($1)\n" if ($dbg_values > 1);
1494            if ($type eq 'V') {
1495                $variant = 'B';
1496            } else {
1497                $variant = 'U';
1498            }
1499
1500            substr($var, length($res), 1, $variant);
1501            $type = 'N';
1502
1503        } elsif ($cur =~ /^($Operators)/o) {
1504            print "OP($1)\n" if ($dbg_values > 1);
1505            if ($1 ne '++' && $1 ne '--') {
1506                $type = 'N';
1507            }
1508
1509        } elsif ($cur =~ /(^.)/o) {
1510            print "C($1)\n" if ($dbg_values > 1);
1511        }
1512        if (defined $1) {
1513            $cur = substr($cur, length($1));
1514            $res .= $type x length($1);
1515        }
1516    }
1517
1518    return ($res, $var);
1519}
1520
1521sub possible {
1522    my ($possible, $line) = @_;
1523    my $notPermitted = qr{(?:
1524        ^(?:
1525            $Modifier|
1526            $Storage|
1527            $Type|
1528            DEFINE_\S+
1529        )$|
1530        ^(?:
1531            goto|
1532            return|
1533            case|
1534            else|
1535            asm|__asm__|
1536            do|
1537            \#|
1538            \#\#|
1539        )(?:\s|$)|
1540        ^(?:typedef|struct|enum)\b
1541        )}x;
1542    warn "CHECK<$possible> ($line)\n" if ($dbg_possible > 2);
1543    if ($possible !~ $notPermitted) {
1544        # Check for modifiers.
1545        $possible =~ s/\s*$Storage\s*//g;
1546        $possible =~ s/\s*$Sparse\s*//g;
1547        if ($possible =~ /^\s*$/) {
1548
1549        } elsif ($possible =~ /\s/) {
1550            $possible =~ s/\s*$Type\s*//g;
1551            for my $modifier (split(' ', $possible)) {
1552                if ($modifier !~ $notPermitted) {
1553                    warn "MODIFIER: $modifier ($possible) ($line)\n" if ($dbg_possible);
1554                    push(@modifierList, $modifier);
1555                }
1556            }
1557
1558        } else {
1559            warn "POSSIBLE: $possible ($line)\n" if ($dbg_possible);
1560            push(@typeList, $possible);
1561        }
1562        build_types();
1563    } else {
1564        warn "NOTPOSS: $possible ($line)\n" if ($dbg_possible > 1);
1565    }
1566}
1567
1568my $prefix = '';
1569
1570sub show_type {
1571    my ($type) = @_;
1572
1573    return defined $use_type{$type} if (scalar keys %use_type > 0);
1574
1575    return !defined $ignore_type{$type};
1576}
1577
1578sub report {
1579    my ($level, $type, $msg) = @_;
1580
1581    if (!show_type($type) ||
1582        (defined $tst_only && $msg !~ /\Q$tst_only\E/)) {
1583        return 0;
1584    }
1585    my $line;
1586    if ($show_types) {
1587        $line = "$prefix$level:$type: $msg\n";
1588    } else {
1589        $line = "$prefix$level: $msg\n";
1590    }
1591    $line = (split('\n', $line))[0] . "\n" if ($terse);
1592
1593    push(our @report, $line);
1594
1595    return 1;
1596}
1597
1598sub report_dump {
1599    our @report;
1600}
1601
1602sub fixup_current_range {
1603    my ($lineRef, $offset, $length) = @_;
1604
1605    if ($$lineRef =~ /^\@\@ -\d+,\d+ \+(\d+),(\d+) \@\@/) {
1606        my $o = $1;
1607        my $l = $2;
1608        my $no = $o + $offset;
1609        my $nl = $l + $length;
1610        $$lineRef =~ s/\+$o,$l \@\@/\+$no,$nl \@\@/;
1611    }
1612}
1613
1614sub fix_inserted_deleted_lines {
1615    my ($linesRef, $insertedRef, $deletedRef) = @_;
1616
1617    my $range_last_linenr = 0;
1618    my $delta_offset = 0;
1619
1620    my $old_linenr = 0;
1621    my $new_linenr = 0;
1622
1623    my $next_insert = 0;
1624    my $next_delete = 0;
1625
1626    my @lines = ();
1627
1628    my $inserted = @{$insertedRef}[$next_insert++];
1629    my $deleted = @{$deletedRef}[$next_delete++];
1630
1631    foreach my $old_line (@{$linesRef}) {
1632        my $save_line = 1;
1633        my $line = $old_line; #don't modify the array
1634        if ($line =~ /^(?:\+\+\+\|\-\-\-)\s+\S+/) { #new filename
1635            $delta_offset = 0;
1636        } elsif ($line =~ /^\@\@ -\d+,\d+ \+\d+,\d+ \@\@/) { #new hunk
1637            $range_last_linenr = $new_linenr;
1638            fixup_current_range(\$line, $delta_offset, 0);
1639        }
1640
1641        while (defined($deleted) && ${$deleted}{'LINENR'} == $old_linenr) {
1642            $deleted = @{$deletedRef}[$next_delete++];
1643            $save_line = 0;
1644            fixup_current_range(\$lines[$range_last_linenr], $delta_offset--, -1);
1645        }
1646
1647        while (defined($inserted) && ${$inserted}{'LINENR'} == $old_linenr) {
1648            push(@lines, ${$inserted}{'LINE'});
1649            $inserted = @{$insertedRef}[$next_insert++];
1650            $new_linenr++;
1651            fixup_current_range(\$lines[$range_last_linenr], $delta_offset++, 1);
1652        }
1653
1654        if ($save_line) {
1655            push(@lines, $line);
1656            $new_linenr++;
1657        }
1658
1659        $old_linenr++;
1660    }
1661
1662    return @lines;
1663}
1664
1665sub fix_insert_line {
1666    my ($linenr, $line) = @_;
1667
1668    my $inserted = {
1669        LINENR => $linenr,
1670        LINE => $line,
1671    };
1672    push(@fixed_inserted, $inserted);
1673}
1674
1675sub fix_delete_line {
1676    my ($linenr, $line) = @_;
1677
1678    my $deleted = {
1679        LINENR => $linenr,
1680        LINE => $line,
1681    };
1682
1683    push(@fixed_deleted, $deleted);
1684}
1685
1686sub ERROR {
1687    my ($type, $msg) = @_;
1688
1689    if (report("ERROR", $type, $msg)) {
1690        our $clean = 0;
1691        our $cnt_error++;
1692        return 1;
1693    }
1694    return 0;
1695}
1696sub WARN {
1697    my ($type, $msg) = @_;
1698
1699    if (report("WARNING", $type, $msg)) {
1700        our $clean = 0;
1701        our $cnt_warn++;
1702        return 1;
1703    }
1704    return 0;
1705}
1706sub CHK {
1707    my ($type, $msg) = @_;
1708
1709    if ($check && report("CHECK", $type, $msg)) {
1710        our $clean = 0;
1711        our $cnt_chk++;
1712        return 1;
1713    }
1714    return 0;
1715}
1716
1717sub check_absolute_file {
1718    my ($absolute, $herecurr) = @_;
1719    my $file = $absolute;
1720
1721    ##print "absolute<$absolute>\n";
1722
1723    # See if any suffix of this path is a path within the tree.
1724    while ($file =~ s@^[^/]*/@@) {
1725        if (-f "$root/$file") {
1726            ##print "file<$file>\n";
1727            last;
1728        }
1729    }
1730    if (! -f _) {
1731        return 0;
1732    }
1733
1734    # It is, so see if the prefix is acceptable.
1735    my $prefix = $absolute;
1736    substr($prefix, -length($file)) = '';
1737
1738    ##print "prefix<$prefix>\n";
1739    if ($prefix ne ".../") {
1740        WARN("USE_RELATIVE_PATH",
1741             "use relative pathname instead of absolute in changelog text\n" . $herecurr);
1742    }
1743}
1744
1745sub trim {
1746    my ($string) = @_;
1747
1748    $string =~ s/^\s+|\s+$//g;
1749
1750    return $string;
1751}
1752
1753sub ltrim {
1754    my ($string) = @_;
1755
1756    $string =~ s/^\s+//;
1757
1758    return $string;
1759}
1760
1761sub rtrim {
1762    my ($string) = @_;
1763
1764    $string =~ s/\s+$//;
1765
1766    return $string;
1767}
1768
1769sub string_find_replace {
1770    my ($string, $find, $replace) = @_;
1771
1772    $string =~ s/$find/$replace/g;
1773
1774    return $string;
1775}
1776
1777sub tabify {
1778    my ($leading) = @_;
1779
1780    my $source_indent = 8;
1781    my $max_spaces_before_tab = $source_indent - 1;
1782    my $spaces_to_tab = " " x $source_indent;
1783
1784    #convert leading spaces to tabs
1785    1 while $leading =~ s@^([\t]*)$spaces_to_tab@$1\t@g;
1786    #Remove spaces before a tab
1787    1 while $leading =~ s@^([\t]*)( {1,$max_spaces_before_tab})\t@$1\t@g;
1788
1789    return "$leading";
1790}
1791
1792sub pos_last_openparen {
1793    my ($line) = @_;
1794
1795    my $pos = 0;
1796
1797    my $opens = $line =~ tr/\(/\(/;
1798    my $closes = $line =~ tr/\)/\)/;
1799
1800    my $last_openparen = 0;
1801
1802    if (($opens == 0) || ($closes >= $opens)) {
1803        return -1;
1804    }
1805
1806    my $len = length($line);
1807
1808    for ($pos = 0; $pos < $len; $pos++) {
1809        my $string = substr($line, $pos);
1810        if ($string =~ /^($FuncArg|$balanced_parens)/) {
1811            $pos += length($1) - 1;
1812        } elsif (substr($line, $pos, 1) eq '(') {
1813            $last_openparen = $pos;
1814        } elsif (index($string, '(') == -1) {
1815            last;
1816        }
1817    }
1818
1819    return length(expand_tabs(substr($line, 0, $last_openparen))) + 1;
1820}
1821
1822sub process {
1823    my $filename = shift;
1824
1825    my $linenr=0;
1826    my $prevline="";
1827    my $prevrawline="";
1828    my $stashline="";
1829    my $stashrawline="";
1830
1831    my $length;
1832    my $indent;
1833    my $previndent=0;
1834    my $stashindent=0;
1835
1836    our $clean = 1;
1837    my $signoff = 0;
1838    my $is_patch = 0;
1839
1840    my $in_header_lines = $file ? 0 : 1;
1841    my $in_commit_log = 0; #Scanning lines before patch
1842    my $reported_maintainer_file = 0;
1843    my $non_utf8_charset = 0;
1844
1845    my $last_blank_line = 0;
1846
1847    our @report = ();
1848    our $cnt_lines = 0;
1849    our $cnt_error = 0;
1850    our $cnt_warn = 0;
1851    our $cnt_chk = 0;
1852
1853    # Trace the real file/line as we go.
1854    my $realfile = '';
1855    my $realline = 0;
1856    my $realcnt = 0;
1857    my $here = '';
1858    my $in_comment = 0;
1859    my $comment_edge = 0;
1860    my $first_line = 0;
1861    my $p1_prefix = '';
1862
1863    my $prev_values = 'E';
1864
1865    # suppression flags
1866    my %suppress_ifbraces;
1867    my %suppress_whiletrailers;
1868    my %suppress_export;
1869    my $suppress_statement = 0;
1870
1871    my %signatures = ();
1872
1873    # Pre-scan the patch sanitizing the lines.
1874    # Pre-scan the patch looking for any __setup documentation.
1875    #
1876    my @setup_docs = ();
1877    my $setup_docs = 0;
1878
1879    my $camelcase_file_seeded = 0;
1880
1881    sanitise_line_reset();
1882    my $line;
1883    foreach my $rawline (@rawlines) {
1884        $linenr++;
1885        $line = $rawline;
1886
1887        push(@fixed, $rawline) if ($fix);
1888
1889        if ($rawline=~/^\+\+\+\s+(\S+)/) {
1890            $setup_docs = 0;
1891            if ($1 =~ m@Documentation/kernel-parameters.txt$@) {
1892                $setup_docs = 1;
1893            }
1894            #next;
1895        }
1896        if ($rawline=~/^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@/) {
1897            $realline=$1-1;
1898            if (defined $2) {
1899                $realcnt=$3+1;
1900            } else {
1901                $realcnt=1+1;
1902            }
1903            $in_comment = 0;
1904
1905            # Guestimate if this is a continuing comment. Run
1906            # the context looking for a comment "edge". If this
1907            # edge is a close comment then we must be in a comment
1908            # at context start.
1909            my $edge;
1910            my $cnt = $realcnt;
1911            for (my $ln = $linenr + 1; $cnt > 0; $ln++) {
1912                next if (defined $rawlines[$ln - 1] &&
1913                     $rawlines[$ln - 1] =~ /^-/);
1914                $cnt--;
1915                #print "RAW<$rawlines[$ln - 1]>\n";
1916                last if (!defined $rawlines[$ln - 1]);
1917                if ($rawlines[$ln - 1] =~ m@(/\*|\*/)@ &&
1918                    $rawlines[$ln - 1] !~ m@"[^"]*(?:/\*|\*/)[^"]*"@) {
1919                    ($edge) = $1;
1920                    last;
1921                }
1922            }
1923            if (defined $edge && $edge eq '*/') {
1924                $in_comment = 1;
1925            }
1926
1927            # Guestimate if this is a continuing comment. If this
1928            # is the start of a diff block and this line starts
1929            # ' *' then it is very likely a comment.
1930            if (!defined $edge &&
1931                $rawlines[$linenr] =~ m@^.\s*(?:\*\*+| \*)(?:\s|$)@)
1932            {
1933                $in_comment = 1;
1934            }
1935
1936            ##print "COMMENT:$in_comment edge<$edge> $rawline\n";
1937            sanitise_line_reset($in_comment);
1938
1939        } elsif ($realcnt && $rawline =~ /^(?:\+| |$)/) {
1940            # Standardise the strings and chars within the input to
1941            # simplify matching -- only bother with positive lines.
1942            $line = sanitise_line($rawline);
1943        }
1944        push(@lines, $line);
1945
1946        if ($realcnt > 1) {
1947            $realcnt-- if ($line =~ /^(?:\+| |$)/);
1948        } else {
1949            $realcnt = 0;
1950        }
1951
1952        #print "==>$rawline\n";
1953        #print "-->$line\n";
1954
1955        if ($setup_docs && $line =~ /^\+/) {
1956            push(@setup_docs, $line);
1957        }
1958    }
1959
1960    $prefix = '';
1961
1962    $realcnt = 0;
1963    $linenr = 0;
1964    $fixlinenr = -1;
1965    foreach my $line (@lines) {
1966        $linenr++;
1967        $fixlinenr++;
1968        my $sline = $line; #copy of $line
1969        $sline =~ s/$;/ /g; #with comments as spaces
1970
1971        my $rawline = $rawlines[$linenr - 1];
1972
1973#extract the line range in the file after the patch is applied
1974        if ($line=~/^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@/) {
1975            $is_patch = 1;
1976            $first_line = $linenr + 1;
1977            $realline=$1-1;
1978            if (defined $2) {
1979                $realcnt=$3+1;
1980            } else {
1981                $realcnt=1+1;
1982            }
1983            annotate_reset();
1984            $prev_values = 'E';
1985
1986            %suppress_ifbraces = ();
1987            %suppress_whiletrailers = ();
1988            %suppress_export = ();
1989            $suppress_statement = 0;
1990            next;
1991
1992# track the line number as we move through the hunk, note that
1993# new versions of GNU diff omit the leading space on completely
1994# blank context lines so we need to count that too.
1995        } elsif ($line =~ /^( |\+|$)/) {
1996            $realline++;
1997            $realcnt-- if ($realcnt != 0);
1998
1999            # Measure the line length and indent.
2000            ($length, $indent) = line_stats($rawline);
2001
2002            # Track the previous line.
2003            ($prevline, $stashline) = ($stashline, $line);
2004            ($previndent, $stashindent) = ($stashindent, $indent);
2005            ($prevrawline, $stashrawline) = ($stashrawline, $rawline);
2006
2007            #warn "line<$line>\n";
2008
2009        } elsif ($realcnt == 1) {
2010            $realcnt--;
2011        }
2012
2013        my $hunk_line = ($realcnt != 0);
2014
2015#make up the handle for any error we report on this line
2016        $prefix = "$filename:$realline: " if ($emacs && $file);
2017        $prefix = "$filename:$linenr: " if ($emacs && !$file);
2018
2019        $here = "#$linenr: " if (!$file);
2020        $here = "#$realline: " if ($file);
2021
2022        my $found_file = 0;
2023        # extract the filename as it passes
2024        if ($line =~ /^diff --git.*?(\S+)$/) {
2025            $realfile = $1;
2026            $realfile =~ s@^([^/]*)/@@ if (!$file);
2027            $in_commit_log = 0;
2028            $found_file = 1;
2029        } elsif ($line =~ /^\+\+\+\s+(\S+)/) {
2030            $realfile = $1;
2031            $realfile =~ s@^([^/]*)/@@ if (!$file);
2032            $in_commit_log = 0;
2033
2034            $p1_prefix = $1;
2035            if (!$file && $tree && $p1_prefix ne '' &&
2036                -e "$root/$p1_prefix") {
2037                WARN("PATCH_PREFIX",
2038                     "patch prefix '$p1_prefix' exists, appears to be a -p0 patch\n");
2039            }
2040
2041            if ($realfile =~ m@^include/asm/@) {
2042                ERROR("MODIFIED_INCLUDE_ASM",
2043                      "do not modify files in include/asm, change architecture specific files in include/asm-<architecture>\n" . "$here$rawline\n");
2044            }
2045            $found_file = 1;
2046        }
2047
2048        if ($found_file) {
2049            if ($realfile =~ m@^(drivers/net/|net/)@) {
2050                $check = 1;
2051            } else {
2052                $check = $check_orig;
2053            }
2054            next;
2055        }
2056
2057        $here .= "FILE: $realfile:$realline:" if ($realcnt != 0);
2058
2059        my $hereline = "$here\n$rawline\n";
2060        my $herecurr = "$here\n$rawline\n";
2061        my $hereprev = "$here\n$prevrawline\n$rawline\n";
2062
2063        $cnt_lines++ if ($realcnt != 0);
2064
2065# Check for incorrect file permissions
2066        if ($line =~ /^new (file )?mode.*[7531]\d{0,2}$/) {
2067            my $permhere = $here . "FILE: $realfile\n";
2068            if ($realfile !~ m@scripts/@ &&
2069                $realfile !~ /\.(py|pl|awk|sh)$/) {
2070                ERROR("EXECUTE_PERMISSIONS",
2071                      "do not set execute permissions for source files\n" . $permhere);
2072            }
2073        }
2074
2075# Check the patch for a signoff:
2076        if ($line =~ /^\s*signed-off-by:/i) {
2077            $signoff++;
2078            $in_commit_log = 0;
2079        }
2080
2081# Check signature styles
2082        if (!$in_header_lines &&
2083            $line =~ /^(\s*)([a-z0-9_-]+by:|$signature_tags)(\s*)(.*)/i) {
2084            my $space_before = $1;
2085            my $sign_off = $2;
2086            my $space_after = $3;
2087            my $email = $4;
2088            my $ucfirst_sign_off = ucfirst(lc($sign_off));
2089
2090            if ($sign_off !~ /$signature_tags/) {
2091                WARN("BAD_SIGN_OFF",
2092                     "Non-standard signature: $sign_off\n" . $herecurr);
2093            }
2094            if (defined $space_before && $space_before ne "") {
2095                if (WARN("BAD_SIGN_OFF",
2096                     "Do not use whitespace before $ucfirst_sign_off\n" . $herecurr) &&
2097                    $fix) {
2098                    $fixed[$fixlinenr] =
2099                        "$ucfirst_sign_off $email";
2100                }
2101            }
2102            if ($sign_off =~ /-by:$/i && $sign_off ne $ucfirst_sign_off) {
2103                if (WARN("BAD_SIGN_OFF",
2104                     "'$ucfirst_sign_off' is the preferred signature form\n" . $herecurr) &&
2105                    $fix) {
2106                    $fixed[$fixlinenr] =
2107                        "$ucfirst_sign_off $email";
2108                }
2109
2110            }
2111            if (!defined $space_after || $space_after ne " ") {
2112                if (WARN("BAD_SIGN_OFF",
2113                     "Use a single space after $ucfirst_sign_off\n" . $herecurr) &&
2114                    $fix) {
2115                    $fixed[$fixlinenr] =
2116                        "$ucfirst_sign_off $email";
2117                }
2118            }
2119
2120            my ($email_name, $email_address, $comment) = parse_email($email);
2121            my $suggested_email = format_email(($email_name, $email_address));
2122            if ($suggested_email eq "") {
2123                ERROR("BAD_SIGN_OFF",
2124                      "Unrecognized email address: '$email'\n" . $herecurr);
2125            } else {
2126                my $dequoted = $suggested_email;
2127                $dequoted =~ s/^"//;
2128                $dequoted =~ s/" </ </;
2129                # Don't force email to have quotes
2130                # Allow just an angle bracketed address
2131                if ("$dequoted$comment" ne $email &&
2132                    "<$email_address>$comment" ne $email &&
2133                    "$suggested_email$comment" ne $email) {
2134                    WARN("BAD_SIGN_OFF",
2135                         "email address '$email' might be better as '$suggested_email$comment'\n" . $herecurr);
2136                }
2137            }
2138
2139# Check for duplicate signatures
2140            my $sig_nospace = $line;
2141            $sig_nospace =~ s/\s//g;
2142            $sig_nospace = lc($sig_nospace);
2143            if (defined $signatures{$sig_nospace}) {
2144                WARN("BAD_SIGN_OFF",
2145                     "Duplicate signature\n" . $herecurr);
2146            } else {
2147                $signatures{$sig_nospace} = 1;
2148            }
2149        }
2150
2151# Check for old stable address
2152        if ($line =~ /^\s*cc:\s*.*<?\bstable\@kernel\.org\b>?.*$/i) {
2153            ERROR("STABLE_ADDRESS",
2154                  "The 'stable' address should be 'stable\@vger.kernel.org'\n" . $herecurr);
2155        }
2156
2157# Check for unwanted Gerrit info
2158        if ($in_commit_log && $line =~ /^\s*change-id:/i) {
2159            ERROR("GERRIT_CHANGE_ID",
2160                  "Remove Gerrit Change-Id's before submitting upstream.\n" . $herecurr);
2161        }
2162
2163# Check for improperly formed commit descriptions
2164        if ($in_commit_log &&
2165            $line =~ /\bcommit\s+[0-9a-f]{5,}/i &&
2166            !($line =~ /\b[Cc]ommit [0-9a-f]{12,40} \("/ ||
2167              ($line =~ /\b[Cc]ommit [0-9a-f]{12,40}\s*$/ &&
2168               defined $rawlines[$linenr] &&
2169               $rawlines[$linenr] =~ /^\s*\("/))) {
2170            $line =~ /\b(c)ommit\s+([0-9a-f]{5,})/i;
2171            my $init_char = $1;
2172            my $orig_commit = lc($2);
2173            my $id = '01234567890ab';
2174            my $desc = 'commit description';
2175                ($id, $desc) = git_commit_info($orig_commit, $id, $desc);
2176            ERROR("GIT_COMMIT_ID",
2177                  "Please use 12 or more chars for the git commit ID like: '${init_char}ommit $id (\"$desc\")'\n" . $herecurr);
2178        }
2179
2180# Check for added, moved or deleted files
2181        if (!$reported_maintainer_file && !$in_commit_log &&
2182            ($line =~ /^(?:new|deleted) file mode\s*\d+\s*$/ ||
2183             $line =~ /^rename (?:from|to) [\w\/\.\-]+\s*$/ ||
2184             ($line =~ /\{\s*([\w\/\.\-]*)\s*\=\>\s*([\w\/\.\-]*)\s*\}/ &&
2185              (defined($1) || defined($2))))) {
2186            $reported_maintainer_file = 1;
2187            WARN("FILE_PATH_CHANGES",
2188                 "added, moved or deleted file(s), does MAINTAINERS need updating?\n" . $herecurr);
2189        }
2190
2191# Check for wrappage within a valid hunk of the file
2192        if ($realcnt != 0 && $line !~ m{^(?:\+|-| |\\ No newline|$)}) {
2193            ERROR("CORRUPTED_PATCH",
2194                  "patch seems to be corrupt (line wrapped?)\n" .
2195                $herecurr) if (!$emitted_corrupt++);
2196        }
2197
2198# Check for absolute kernel paths.
2199        if ($tree) {
2200            while ($line =~ m{(?:^|\s)(/\S*)}g) {
2201                my $file = $1;
2202
2203                if ($file =~ m{^(.*?)(?::\d+)+:?$} &&
2204                    check_absolute_file($1, $herecurr)) {
2205                    #
2206                } else {
2207                    check_absolute_file($file, $herecurr);
2208                }
2209            }
2210        }
2211
2212# UTF-8 regex found at http://www.w3.org/International/questions/qa-forms-utf-8.en.php
2213        if (($realfile =~ /^$/ || $line =~ /^\+/) &&
2214            $rawline !~ m/^$UTF8*$/) {
2215            my ($utf8_prefix) = ($rawline =~ /^($UTF8*)/);
2216
2217            my $blank = copy_spacing($rawline);
2218            my $ptr = substr($blank, 0, length($utf8_prefix)) . "^";
2219            my $hereptr = "$hereline$ptr\n";
2220
2221            CHK("INVALID_UTF8",
2222                "Invalid UTF-8, patch and commit message should be encoded in UTF-8\n" . $hereptr);
2223        }
2224
2225# Check if it's the start of a commit log
2226# (not a header line and we haven't seen the patch filename)
2227        if ($in_header_lines && $realfile =~ /^$/ &&
2228            !($rawline =~ /^\s+\S/ ||
2229              $rawline =~ /^(commit\b|from\b|[\w-]+:).*$/i)) {
2230            $in_header_lines = 0;
2231            $in_commit_log = 1;
2232        }
2233
2234# Check if there is UTF-8 in a commit log when a mail header has explicitly
2235# declined it, i.e defined some charset where it is missing.
2236        if ($in_header_lines &&
2237            $rawline =~ /^Content-Type:.+charset="(.+)".*$/ &&
2238            $1 !~ /utf-8/i) {
2239            $non_utf8_charset = 1;
2240        }
2241
2242        if ($in_commit_log && $non_utf8_charset && $realfile =~ /^$/ &&
2243            $rawline =~ /$NON_ASCII_UTF8/) {
2244            WARN("UTF8_BEFORE_PATCH",
2245                "8-bit UTF-8 used in possible commit log\n" . $herecurr);
2246        }
2247
2248# Check for various typo / spelling mistakes
2249        if ($in_commit_log || $line =~ /^\+/) {
2250            while ($rawline =~ /(?:^|[^a-z@])($misspellings)(?:$|[^a-z@])/gi) {
2251                my $typo = $1;
2252                my $typo_fix = $spelling_fix{lc($typo)};
2253                $typo_fix = ucfirst($typo_fix) if ($typo =~ /^[A-Z]/);
2254                $typo_fix = uc($typo_fix) if ($typo =~ /^[A-Z]+$/);
2255                my $msg_type = \&WARN;
2256                $msg_type = \&CHK if ($file);
2257                if (&{$msg_type}("TYPO_SPELLING",
2258                         "'$typo' may be misspelled - perhaps '$typo_fix'?\n" . $herecurr) &&
2259                    $fix) {
2260                    $fixed[$fixlinenr] =~ s/(^|[^A-Za-z@])($typo)($|[^A-Za-z@])/$1$typo_fix$3/;
2261                }
2262            }
2263        }
2264
2265# ignore non-hunk lines and lines being removed
2266        next if (!$hunk_line || $line =~ /^-/);
2267
2268#trailing whitespace
2269        if ($line =~ /^\+.*\015/) {
2270            my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2271            if (ERROR("DOS_LINE_ENDINGS",
2272                  "DOS line endings\n" . $herevet) &&
2273                $fix) {
2274                $fixed[$fixlinenr] =~ s/[\s\015]+$//;
2275            }
2276        } elsif ($rawline =~ /^\+.*\S\s+$/ || $rawline =~ /^\+\s+$/) {
2277            my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2278            if (ERROR("TRAILING_WHITESPACE",
2279                  "trailing whitespace\n" . $herevet) &&
2280                $fix) {
2281                $fixed[$fixlinenr] =~ s/\s+$//;
2282            }
2283
2284            $rpt_cleaners = 1;
2285        }
2286
2287# Check for FSF mailing addresses.
2288        if ($rawline =~ /\bwrite to the Free/i ||
2289            $rawline =~ /\b59\s+Temple\s+Pl/i ||
2290            $rawline =~ /\b51\s+Franklin\s+St/i) {
2291            my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2292            my $msg_type = \&ERROR;
2293            $msg_type = \&CHK if ($file);
2294            &{$msg_type}("FSF_MAILING_ADDRESS",
2295                     "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)
2296        }
2297
2298# check for Kconfig help text having a real description
2299# Only applies when adding the entry originally, after that we do not have
2300# sufficient context to determine whether it is indeed long enough.
2301        if ($realfile =~ /Kconfig/ &&
2302            $line =~ /^\+\s*config\s+/) {
2303            my $length = 0;
2304            my $cnt = $realcnt;
2305            my $ln = $linenr + 1;
2306            my $f;
2307            my $is_start = 0;
2308            my $is_end = 0;
2309            for (; $cnt > 0 && defined $lines[$ln - 1]; $ln++) {
2310                $f = $lines[$ln - 1];
2311                $cnt-- if ($lines[$ln - 1] !~ /^-/);
2312                $is_end = $lines[$ln - 1] =~ /^\+/;
2313
2314                next if ($f =~ /^-/);
2315                last if (!$file && $f =~ /^\@\@/);
2316
2317                if ($lines[$ln - 1] =~ /^\+\s*(?:bool|tristate)\s*\"/) {
2318                    $is_start = 1;
2319                } elsif ($lines[$ln - 1] =~ /^\+\s*(?:---)?help(?:---)?$/) {
2320                    $length = -1;
2321                }
2322
2323                $f =~ s/^.//;
2324                $f =~ s/#.*//;
2325                $f =~ s/^\s+//;
2326                next if ($f =~ /^$/);
2327                if ($f =~ /^\s*config\s/) {
2328                    $is_end = 1;
2329                    last;
2330                }
2331                $length++;
2332            }
2333            if ($is_start && $is_end && $length < $min_conf_desc_length) {
2334                WARN("CONFIG_DESCRIPTION",
2335                     "please write a paragraph that describes the config symbol fully\n" . $herecurr);
2336            }
2337            #print "is_start<$is_start> is_end<$is_end> length<$length>\n";
2338        }
2339
2340# discourage the addition of CONFIG_EXPERIMENTAL in Kconfig.
2341        if ($realfile =~ /Kconfig/ &&
2342            $line =~ /.\s*depends on\s+.*\bEXPERIMENTAL\b/) {
2343            WARN("CONFIG_EXPERIMENTAL",
2344                 "Use of CONFIG_EXPERIMENTAL is deprecated. For alternatives, see https://lkml.org/lkml/2012/10/23/580\n");
2345        }
2346
2347        if (($realfile =~ /Makefile.*/ || $realfile =~ /Kbuild.*/) &&
2348            ($line =~ /\+(EXTRA_[A-Z]+FLAGS).*/)) {
2349            my $flag = $1;
2350            my $replacement = {
2351                'EXTRA_AFLAGS' => 'asflags-y',
2352                'EXTRA_CFLAGS' => 'ccflags-y',
2353                'EXTRA_CPPFLAGS' => 'cppflags-y',
2354                'EXTRA_LDFLAGS' => 'ldflags-y',
2355            };
2356
2357            WARN("DEPRECATED_VARIABLE",
2358                 "Use of $flag is deprecated, please use \`$replacement->{$flag} instead.\n" . $herecurr) if ($replacement->{$flag});
2359        }
2360
2361# check for DT compatible documentation
2362        if (defined $root &&
2363            (($realfile =~ /\.dtsi?$/ && $line =~ /^\+\s*compatible\s*=\s*\"/) ||
2364             ($realfile =~ /\.[ch]$/ && $line =~ /^\+.*\.compatible\s*=\s*\"/))) {
2365
2366            my @compats = $rawline =~ /\"([a-zA-Z0-9\-\,\.\+_]+)\"/g;
2367
2368            my $dt_path = $root . "/Documentation/devicetree/bindings/";
2369            my $vp_file = $dt_path . "vendor-prefixes.txt";
2370
2371            foreach my $compat (@compats) {
2372                my $compat2 = $compat;
2373                $compat2 =~ s/\,[a-zA-Z0-9]*\-/\,<\.\*>\-/;
2374                my $compat3 = $compat;
2375                $compat3 =~ s/\,([a-z]*)[0-9]*\-/\,$1<\.\*>\-/;
2376                `grep -Erq "$compat|$compat2|$compat3" $dt_path`;
2377                if ( $? >> 8 ) {
2378                    WARN("UNDOCUMENTED_DT_STRING",
2379                         "DT compatible string \"$compat\" appears un-documented -- check $dt_path\n" . $herecurr);
2380                }
2381
2382                next if $compat !~ /^([a-zA-Z0-9\-]+)\,/;
2383                my $vendor = $1;
2384                `grep -Eq "^$vendor\\b" $vp_file`;
2385                if ( $? >> 8 ) {
2386                    WARN("UNDOCUMENTED_DT_STRING",
2387                         "DT compatible string vendor \"$vendor\" appears un-documented -- check $vp_file\n" . $herecurr);
2388                }
2389            }
2390        }
2391
2392# check we are in a valid source file if not then ignore this hunk
2393        next if ($realfile !~ /\.(h|c|s|S|pl|sh|dtsi|dts)$/);
2394
2395#line length limit
2396        if ($line =~ /^\+/ && $prevrawline !~ /\/\*\*/ &&
2397            $rawline !~ /^.\s*\*\s*\@$Ident\s/ &&
2398            !($line =~ /^\+\s*$logFunctions\s*\(\s*(?:(KERN_\S+\s*|[^"]*))?"[X\t]*"\s*(?:|,|\)\s*;)\s*$/ ||
2399            $line =~ /^\+\s*"[^"]*"\s*(?:\s*|,|\)\s*;)\s*$/) &&
2400            $length > $max_line_length)
2401        {
2402            WARN("LONG_LINE",
2403                 "line over $max_line_length characters\n" . $herecurr);
2404        }
2405
2406# Check for user-visible strings broken across lines, which breaks the ability
2407# to grep for the string. Make exceptions when the previous string ends in a
2408# newline (multiple lines in one string constant) or '\t', '\r', ';', or '{'
2409# (common in inline assembly) or is a octal \123 or hexadecimal \xaf value
2410        if ($line =~ /^\+\s*"/ &&
2411            $prevline =~ /"\s*$/ &&
2412            $prevrawline !~ /(?:\\(?:[ntr]|[0-7]{1,3}|x[0-9a-fA-F]{1,2})|;\s*|\{\s*)"\s*$/) {
2413            WARN("SPLIT_STRING",
2414                 "quoted string split across lines\n" . $hereprev);
2415        }
2416
2417# check for missing a space in a string concatination
2418        if ($prevrawline =~ /[^\\]\w"$/ && $rawline =~ /^\+[\t ]+"\w/) {
2419            WARN('MISSING_SPACE',
2420                 "break quoted strings at a space character\n" . $hereprev);
2421        }
2422
2423# check for spaces before a quoted newline
2424        if ($rawline =~ /^.*\".*\s\\n/) {
2425            if (WARN("QUOTED_WHITESPACE_BEFORE_NEWLINE",
2426                 "unnecessary whitespace before a quoted newline\n" . $herecurr) &&
2427                $fix) {
2428                $fixed[$fixlinenr] =~ s/^(\+.*\".*)\s+\\n/$1\\n/;
2429            }
2430
2431        }
2432
2433# check for adding lines without a newline.
2434        if ($line =~ /^\+/ && defined $lines[$linenr] && $lines[$linenr] =~ /^\\ No newline at end of file/) {
2435            WARN("MISSING_EOF_NEWLINE",
2436                 "adding a line without newline at end of file\n" . $herecurr);
2437        }
2438
2439# Blackfin: use hi/lo macros
2440        if ($realfile =~ m@arch/blackfin/.*\.S$@) {
2441            if ($line =~ /\.[lL][[:space:]]*=.*&[[:space:]]*0x[fF][fF][fF][fF]/) {
2442                my $herevet = "$here\n" . cat_vet($line) . "\n";
2443                ERROR("LO_MACRO",
2444                      "use the LO() macro, not (... & 0xFFFF)\n" . $herevet);
2445            }
2446            if ($line =~ /\.[hH][[:space:]]*=.*>>[[:space:]]*16/) {
2447                my $herevet = "$here\n" . cat_vet($line) . "\n";
2448                ERROR("HI_MACRO",
2449                      "use the HI() macro, not (... >> 16)\n" . $herevet);
2450            }
2451        }
2452
2453# check we are in a valid source file C or perl if not then ignore this hunk
2454        next if ($realfile !~ /\.(h|c|pl|dtsi|dts)$/);
2455
2456# at the beginning of a line any tabs must come first and anything
2457# more than 8 must use tabs.
2458        if ($rawline =~ /^\+\s* \t\s*\S/ ||
2459            $rawline =~ /^\+\s* \s*/) {
2460            my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2461            $rpt_cleaners = 1;
2462            if (ERROR("CODE_INDENT",
2463                  "code indent should use tabs where possible\n" . $herevet) &&
2464                $fix) {
2465                $fixed[$fixlinenr] =~ s/^\+([ \t]+)/"\+" . tabify($1)/e;
2466            }
2467        }
2468
2469# check for space before tabs.
2470        if ($rawline =~ /^\+/ && $rawline =~ / \t/) {
2471            my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2472            if (WARN("SPACE_BEFORE_TAB",
2473                "please, no space before tabs\n" . $herevet) &&
2474                $fix) {
2475                while ($fixed[$fixlinenr] =~
2476                       s/(^\+.*) {8,8}\t/$1\t\t/) {}
2477                while ($fixed[$fixlinenr] =~
2478                       s/(^\+.*) +\t/$1\t/) {}
2479            }
2480        }
2481
2482# check for && or || at the start of a line
2483        if ($rawline =~ /^\+\s*(&&|\|\|)/) {
2484            CHK("LOGICAL_CONTINUATIONS",
2485                "Logical continuations should be on the previous line\n" . $hereprev);
2486        }
2487
2488# check multi-line statement indentation matches previous line
2489        if ($^V && $^V ge 5.10.0 &&
2490            $prevline =~ /^\+([ \t]*)((?:$c90_Keywords(?:\s+if)\s*)|(?:$Declare\s*)?(?:$Ident|\(\s*\*\s*$Ident\s*\))\s*|$Ident\s*=\s*$Ident\s*)\(.*(\&\&|\|\||,)\s*$/) {
2491            $prevline =~ /^\+(\t*)(.*)$/;
2492            my $oldindent = $1;
2493            my $rest = $2;
2494
2495            my $pos = pos_last_openparen($rest);
2496            if ($pos >= 0) {
2497                $line =~ /^(\+| )([ \t]*)/;
2498                my $newindent = $2;
2499
2500                my $goodtabindent = $oldindent .
2501                    "\t" x ($pos / 8) .
2502                    " " x ($pos % 8);
2503                my $goodspaceindent = $oldindent . " " x $pos;
2504
2505                if ($newindent ne $goodtabindent &&
2506                    $newindent ne $goodspaceindent) {
2507
2508                    if (CHK("PARENTHESIS_ALIGNMENT",
2509                        "Alignment should match open parenthesis\n" . $hereprev) &&
2510                        $fix && $line =~ /^\+/) {
2511                        $fixed[$fixlinenr] =~
2512                            s/^\+[ \t]*/\+$goodtabindent/;
2513                    }
2514                }
2515            }
2516        }
2517
2518        if ($line =~ /^\+.*\(\s*$Type\s*\)[ \t]+(?!$Assignment|$Arithmetic|{)/) {
2519            if (CHK("SPACING",
2520                "No space is necessary after a cast\n" . $herecurr) &&
2521                $fix) {
2522                $fixed[$fixlinenr] =~
2523                    s/(\(\s*$Type\s*\))[ \t]+/$1/;
2524            }
2525        }
2526
2527        if ($realfile =~ m@^(drivers/net/|net/)@ &&
2528            $prevrawline =~ /^\+[ \t]*\/\*[ \t]*$/ &&
2529            $rawline =~ /^\+[ \t]*\*/ &&
2530            $realline > 2) {
2531            WARN("NETWORKING_BLOCK_COMMENT_STYLE",
2532                 "networking block comments don't use an empty /* line, use /* Comment...\n" . $hereprev);
2533        }
2534
2535        if ($realfile =~ m@^(drivers/net/|net/)@ &&
2536            $prevrawline =~ /^\+[ \t]*\/\*/ && #starting /*
2537            $prevrawline !~ /\*\/[ \t]*$/ && #no trailing */
2538            $rawline =~ /^\+/ && #line is new
2539            $rawline !~ /^\+[ \t]*\*/) { #no leading *
2540            WARN("NETWORKING_BLOCK_COMMENT_STYLE",
2541                 "networking block comments start with * on subsequent lines\n" . $hereprev);
2542        }
2543
2544        if ($realfile =~ m@^(drivers/net/|net/)@ &&
2545            $rawline !~ m@^\+[ \t]*\*/[ \t]*$@ && #trailing */
2546            $rawline !~ m@^\+.*/\*.*\*/[ \t]*$@ && #inline /*...*/
2547            $rawline !~ m@^\+.*\*{2,}/[ \t]*$@ && #trailing **/
2548            $rawline =~ m@^\+[ \t]*.+\*\/[ \t]*$@) { #non blank */
2549            WARN("NETWORKING_BLOCK_COMMENT_STYLE",
2550                 "networking block comments put the trailing */ on a separate line\n" . $herecurr);
2551        }
2552
2553# check for missing blank lines after struct/union declarations
2554# with exceptions for various attributes and macros
2555        if ($prevline =~ /^[\+ ]};?\s*$/ &&
2556            $line =~ /^\+/ &&
2557            !($line =~ /^\+\s*$/ ||
2558              $line =~ /^\+\s*EXPORT_SYMBOL/ ||
2559              $line =~ /^\+\s*MODULE_/i ||
2560              $line =~ /^\+\s*\#\s*(?:end|elif|else)/ ||
2561              $line =~ /^\+[a-z_]*init/ ||
2562              $line =~ /^\+\s*(?:static\s+)?[A-Z_]*ATTR/ ||
2563              $line =~ /^\+\s*DECLARE/ ||
2564              $line =~ /^\+\s*__setup/)) {
2565            if (CHK("LINE_SPACING",
2566                "Please use a blank line after function/struct/union/enum declarations\n" . $hereprev) &&
2567                $fix) {
2568                fix_insert_line($fixlinenr, "\+");
2569            }
2570        }
2571
2572# check for multiple consecutive blank lines
2573        if ($prevline =~ /^[\+ ]\s*$/ &&
2574            $line =~ /^\+\s*$/ &&
2575            $last_blank_line != ($linenr - 1)) {
2576            if (CHK("LINE_SPACING",
2577                "Please don't use multiple blank lines\n" . $hereprev) &&
2578                $fix) {
2579                fix_delete_line($fixlinenr, $rawline);
2580            }
2581
2582            $last_blank_line = $linenr;
2583        }
2584
2585# check for missing blank lines after declarations
2586        if ($sline =~ /^\+\s+\S/ && #Not at char 1
2587            # actual declarations
2588            ($prevline =~ /^\+\s+$Declare\s*$Ident\s*[=,;:\[]/ ||
2589            # function pointer declarations
2590             $prevline =~ /^\+\s+$Declare\s*\(\s*\*\s*$Ident\s*\)\s*[=,;:\[\(]/ ||
2591            # foo bar; where foo is some local typedef or #define
2592             $prevline =~ /^\+\s+$Ident(?:\s+|\s*\*\s*)$Ident\s*[=,;\[]/ ||
2593            # known declaration macros
2594             $prevline =~ /^\+\s+$declaration_macros/) &&
2595            # for "else if" which can look like "$Ident $Ident"
2596            !($prevline =~ /^\+\s+$c90_Keywords\b/ ||
2597            # other possible extensions of declaration lines
2598              $prevline =~ /(?:$Compare|$Assignment|$Operators)\s*$/ ||
2599            # not starting a section or a macro "\" extended line
2600              $prevline =~ /(?:\{\s*|\\)$/) &&
2601            # looks like a declaration
2602            !($sline =~ /^\+\s+$Declare\s*$Ident\s*[=,;:\[]/ ||
2603            # function pointer declarations
2604              $sline =~ /^\+\s+$Declare\s*\(\s*\*\s*$Ident\s*\)\s*[=,;:\[\(]/ ||
2605            # foo bar; where foo is some local typedef or #define
2606              $sline =~ /^\+\s+$Ident(?:\s+|\s*\*\s*)$Ident\s*[=,;\[]/ ||
2607            # known declaration macros
2608              $sline =~ /^\+\s+$declaration_macros/ ||
2609            # start of struct or union or enum
2610              $sline =~ /^\+\s+(?:union|struct|enum|typedef)\b/ ||
2611            # start or end of block or continuation of declaration
2612              $sline =~ /^\+\s+(?:$|[\{\}\.\#\"\?\:\(\[])/ ||
2613            # bitfield continuation
2614              $sline =~ /^\+\s+$Ident\s*:\s*\d+\s*[,;]/ ||
2615            # other possible extensions of declaration lines
2616              $sline =~ /^\+\s+\(?\s*(?:$Compare|$Assignment|$Operators)/) &&
2617            # indentation of previous and current line are the same
2618            (($prevline =~ /\+(\s+)\S/) && $sline =~ /^\+$1\S/)) {
2619            if (WARN("LINE_SPACING",
2620                 "Missing a blank line after declarations\n" . $hereprev) &&
2621                $fix) {
2622                fix_insert_line($fixlinenr, "\+");
2623            }
2624        }
2625
2626# check for spaces at the beginning of a line.
2627# Exceptions:
2628# 1) within comments
2629# 2) indented preprocessor commands
2630# 3) hanging labels
2631        if ($rawline =~ /^\+ / && $line !~ /^\+ *(?:$;|#|$Ident:)/) {
2632            my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2633            if (WARN("LEADING_SPACE",
2634                 "please, no spaces at the start of a line\n" . $herevet) &&
2635                $fix) {
2636                $fixed[$fixlinenr] =~ s/^\+([ \t]+)/"\+" . tabify($1)/e;
2637            }
2638        }
2639
2640# check we are in a valid C source file if not then ignore this hunk
2641        next if ($realfile !~ /\.(h|c)$/);
2642
2643# check indentation of any line with a bare else
2644# (but not if it is a multiple line "if (foo) return bar; else return baz;")
2645# if the previous line is a break or return and is indented 1 tab more...
2646        if ($sline =~ /^\+([\t]+)(?:}[ \t]*)?else(?:[ \t]*{)?\s*$/) {
2647            my $tabs = length($1) + 1;
2648            if ($prevline =~ /^\+\t{$tabs,$tabs}break\b/ ||
2649                ($prevline =~ /^\+\t{$tabs,$tabs}return\b/ &&
2650                 defined $lines[$linenr] &&
2651                 $lines[$linenr] !~ /^[ \+]\t{$tabs,$tabs}return/)) {
2652                WARN("UNNECESSARY_ELSE",
2653                     "else is not generally useful after a break or return\n" . $hereprev);
2654            }
2655        }
2656
2657# check indentation of a line with a break;
2658# if the previous line is a goto or return and is indented the same # of tabs
2659        if ($sline =~ /^\+([\t]+)break\s*;\s*$/) {
2660            my $tabs = $1;
2661            if ($prevline =~ /^\+$tabs(?:goto|return)\b/) {
2662                WARN("UNNECESSARY_BREAK",
2663                     "break is not useful after a goto or return\n" . $hereprev);
2664            }
2665        }
2666
2667# discourage the addition of CONFIG_EXPERIMENTAL in #if(def).
2668        if ($line =~ /^\+\s*\#\s*if.*\bCONFIG_EXPERIMENTAL\b/) {
2669            WARN("CONFIG_EXPERIMENTAL",
2670                 "Use of CONFIG_EXPERIMENTAL is deprecated. For alternatives, see https://lkml.org/lkml/2012/10/23/580\n");
2671        }
2672
2673# check for RCS/CVS revision markers
2674        if ($rawline =~ /^\+.*\$(Revision|Log|Id)(?:\$|)/) {
2675            WARN("CVS_KEYWORD",
2676                 "CVS style keyword markers, these will _not_ be updated\n". $herecurr);
2677        }
2678
2679# Blackfin: don't use __builtin_bfin_[cs]sync
2680        if ($line =~ /__builtin_bfin_csync/) {
2681            my $herevet = "$here\n" . cat_vet($line) . "\n";
2682            ERROR("CSYNC",
2683                  "use the CSYNC() macro in asm/blackfin.h\n" . $herevet);
2684        }
2685        if ($line =~ /__builtin_bfin_ssync/) {
2686            my $herevet = "$here\n" . cat_vet($line) . "\n";
2687            ERROR("SSYNC",
2688                  "use the SSYNC() macro in asm/blackfin.h\n" . $herevet);
2689        }
2690
2691# check for old HOTPLUG __dev<foo> section markings
2692        if ($line =~ /\b(__dev(init|exit)(data|const|))\b/) {
2693            WARN("HOTPLUG_SECTION",
2694                 "Using $1 is unnecessary\n" . $herecurr);
2695        }
2696
2697# Check for potential 'bare' types
2698        my ($stat, $cond, $line_nr_next, $remain_next, $off_next,
2699            $realline_next);
2700#print "LINE<$line>\n";
2701        if ($linenr >= $suppress_statement &&
2702            $realcnt && $sline =~ /.\s*\S/) {
2703            ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
2704                ctx_statement_block($linenr, $realcnt, 0);
2705            $stat =~ s/\n./\n /g;
2706            $cond =~ s/\n./\n /g;
2707
2708#print "linenr<$linenr> <$stat>\n";
2709            # If this statement has no statement boundaries within
2710            # it there is no point in retrying a statement scan
2711            # until we hit end of it.
2712            my $frag = $stat; $frag =~ s/;+\s*$//;
2713            if ($frag !~ /(?:{|;)/) {
2714#print "skip<$line_nr_next>\n";
2715                $suppress_statement = $line_nr_next;
2716            }
2717
2718            # Find the real next line.
2719            $realline_next = $line_nr_next;
2720            if (defined $realline_next &&
2721                (!defined $lines[$realline_next - 1] ||
2722                 substr($lines[$realline_next - 1], $off_next) =~ /^\s*$/)) {
2723                $realline_next++;
2724            }
2725
2726            my $s = $stat;
2727            $s =~ s/{.*$//s;
2728
2729            # Ignore goto labels.
2730            if ($s =~ /$Ident:\*$/s) {
2731
2732            # Ignore functions being called
2733            } elsif ($s =~ /^.\s*$Ident\s*\(/s) {
2734
2735            } elsif ($s =~ /^.\s*else\b/s) {
2736
2737            # declarations always start with types
2738            } 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) {
2739                my $type = $1;
2740                $type =~ s/\s+/ /g;
2741                possible($type, "A:" . $s);
2742
2743            # definitions in global scope can only start with types
2744            } elsif ($s =~ /^.(?:$Storage\s+)?(?:$Inline\s+)?(?:const\s+)?($Ident)\b\s*(?!:)/s) {
2745                possible($1, "B:" . $s);
2746            }
2747
2748            # any (foo ... *) is a pointer cast, and foo is a type
2749            while ($s =~ /\(($Ident)(?:\s+$Sparse)*[\s\*]+\s*\)/sg) {
2750                possible($1, "C:" . $s);
2751            }
2752
2753            # Check for any sort of function declaration.
2754            # int foo(something bar, other baz);
2755            # void (*store_gdt)(x86_descr_ptr *);
2756            if ($prev_values eq 'E' && $s =~ /^(.(?:typedef\s*)?(?:(?:$Storage|$Inline)\s*)*\s*$Type\s*(?:\b$Ident|\(\*\s*$Ident\))\s*)\(/s) {
2757                my ($name_len) = length($1);
2758
2759                my $ctx = $s;
2760                substr($ctx, 0, $name_len + 1, '');
2761                $ctx =~ s/\)[^\)]*$//;
2762
2763                for my $arg (split(/\s*,\s*/, $ctx)) {
2764                    if ($arg =~ /^(?:const\s+)?($Ident)(?:\s+$Sparse)*\s*\**\s*(:?\b$Ident)?$/s || $arg =~ /^($Ident)$/s) {
2765
2766                        possible($1, "D:" . $s);
2767                    }
2768                }
2769            }
2770
2771        }
2772
2773#
2774# Checks which may be anchored in the context.
2775#
2776
2777# Check for switch () and associated case and default
2778# statements should be at the same indent.
2779        if ($line=~/\bswitch\s*\(.*\)/) {
2780            my $err = '';
2781            my $sep = '';
2782            my @ctx = ctx_block_outer($linenr, $realcnt);
2783            shift(@ctx);
2784            for my $ctx (@ctx) {
2785                my ($clen, $cindent) = line_stats($ctx);
2786                if ($ctx =~ /^\+\s*(case\s+|default:)/ &&
2787                            $indent != $cindent) {
2788                    $err .= "$sep$ctx\n";
2789                    $sep = '';
2790                } else {
2791                    $sep = "[...]\n";
2792                }
2793            }
2794            if ($err ne '') {
2795                ERROR("SWITCH_CASE_INDENT_LEVEL",
2796                      "switch and case should be at the same indent\n$hereline$err");
2797            }
2798        }
2799
2800# if/while/etc brace do not go on next line, unless defining a do while loop,
2801# or if that brace on the next line is for something else
2802        if ($line =~ /(.*)\b((?:if|while|for|switch|(?:[a-z_]+|)for_each[a-z_]+)\s*\(|do\b|else\b)/ && $line !~ /^.\s*\#/) {
2803            my $pre_ctx = "$1$2";
2804
2805            my ($level, @ctx) = ctx_statement_level($linenr, $realcnt, 0);
2806
2807            if ($line =~ /^\+\t{6,}/) {
2808                WARN("DEEP_INDENTATION",
2809                     "Too many leading tabs - consider code refactoring\n" . $herecurr);
2810            }
2811
2812            my $ctx_cnt = $realcnt - $#ctx - 1;
2813            my $ctx = join("\n", @ctx);
2814
2815            my $ctx_ln = $linenr;
2816            my $ctx_skip = $realcnt;
2817
2818            while ($ctx_skip > $ctx_cnt || ($ctx_skip == $ctx_cnt &&
2819                    defined $lines[$ctx_ln - 1] &&
2820                    $lines[$ctx_ln - 1] =~ /^-/)) {
2821                ##print "SKIP<$ctx_skip> CNT<$ctx_cnt>\n";
2822                $ctx_skip-- if (!defined $lines[$ctx_ln - 1] || $lines[$ctx_ln - 1] !~ /^-/);
2823                $ctx_ln++;
2824            }
2825
2826            #print "realcnt<$realcnt> ctx_cnt<$ctx_cnt>\n";
2827            #print "pre<$pre_ctx>\nline<$line>\nctx<$ctx>\nnext<$lines[$ctx_ln - 1]>\n";
2828
2829            if ($ctx !~ /{\s*/ && defined($lines[$ctx_ln - 1]) && $lines[$ctx_ln - 1] =~ /^\+\s*{/) {
2830                ERROR("OPEN_BRACE",
2831                      "that open brace { should be on the previous line\n" .
2832                    "$here\n$ctx\n$rawlines[$ctx_ln - 1]\n");
2833            }
2834            if ($level == 0 && $pre_ctx !~ /}\s*while\s*\($/ &&
2835                $ctx =~ /\)\s*\;\s*$/ &&
2836                defined $lines[$ctx_ln - 1])
2837            {
2838                my ($nlength, $nindent) = line_stats($lines[$ctx_ln - 1]);
2839                if ($nindent > $indent) {
2840                    WARN("TRAILING_SEMICOLON",
2841                         "trailing semicolon indicates no statements, indent implies otherwise\n" .
2842                        "$here\n$ctx\n$rawlines[$ctx_ln - 1]\n");
2843                }
2844            }
2845        }
2846
2847# Check relative indent for conditionals and blocks.
2848        if ($line =~ /\b(?:(?:if|while|for|(?:[a-z_]+|)for_each[a-z_]+)\s*\(|do\b)/ && $line !~ /^.\s*#/ && $line !~ /\}\s*while\s*/) {
2849            ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
2850                ctx_statement_block($linenr, $realcnt, 0)
2851                    if (!defined $stat);
2852            my ($s, $c) = ($stat, $cond);
2853
2854            substr($s, 0, length($c), '');
2855
2856            # Make sure we remove the line prefixes as we have
2857            # none on the first line, and are going to readd them
2858            # where necessary.
2859            $s =~ s/\n./\n/gs;
2860
2861            # Find out how long the conditional actually is.
2862            my @newlines = ($c =~ /\n/gs);
2863            my $cond_lines = 1 + $#newlines;
2864
2865            # We want to check the first line inside the block
2866            # starting at the end of the conditional, so remove:
2867            # 1) any blank line termination
2868            # 2) any opening brace { on end of the line
2869            # 3) any do (...) {
2870            my $continuation = 0;
2871            my $check = 0;
2872            $s =~ s/^.*\bdo\b//;
2873            $s =~ s/^\s*{//;
2874            if ($s =~ s/^\s*\\//) {
2875                $continuation = 1;
2876            }
2877            if ($s =~ s/^\s*?\n//) {
2878                $check = 1;
2879                $cond_lines++;
2880            }
2881
2882            # Also ignore a loop construct at the end of a
2883            # preprocessor statement.
2884            if (($prevline =~ /^.\s*#\s*define\s/ ||
2885                $prevline =~ /\\\s*$/) && $continuation == 0) {
2886                $check = 0;
2887            }
2888
2889            my $cond_ptr = -1;
2890            $continuation = 0;
2891            while ($cond_ptr != $cond_lines) {
2892                $cond_ptr = $cond_lines;
2893
2894                # If we see an #else/#elif then the code
2895                # is not linear.
2896                if ($s =~ /^\s*\#\s*(?:else|elif)/) {
2897                    $check = 0;
2898                }
2899
2900                # Ignore:
2901                # 1) blank lines, they should be at 0,
2902                # 2) preprocessor lines, and
2903                # 3) labels.
2904                if ($continuation ||
2905                    $s =~ /^\s*?\n/ ||
2906                    $s =~ /^\s*#\s*?/ ||
2907                    $s =~ /^\s*$Ident\s*:/) {
2908                    $continuation = ($s =~ /^.*?\\\n/) ? 1 : 0;
2909                    if ($s =~ s/^.*?\n//) {
2910                        $cond_lines++;
2911                    }
2912                }
2913            }
2914
2915            my (undef, $sindent) = line_stats("+" . $s);
2916            my $stat_real = raw_line($linenr, $cond_lines);
2917
2918            # Check if either of these lines are modified, else
2919            # this is not this patch's fault.
2920            if (!defined($stat_real) ||
2921                $stat !~ /^\+/ && $stat_real !~ /^\+/) {
2922                $check = 0;
2923            }
2924            if (defined($stat_real) && $cond_lines > 1) {
2925                $stat_real = "[...]\n$stat_real";
2926            }
2927
2928            #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";
2929
2930            if ($check && (($sindent % 8) != 0 ||
2931                ($sindent <= $indent && $s ne ''))) {
2932                WARN("SUSPECT_CODE_INDENT",
2933                     "suspect code indent for conditional statements ($indent, $sindent)\n" . $herecurr . "$stat_real\n");
2934            }
2935        }
2936
2937        # Track the 'values' across context and added lines.
2938        my $opline = $line; $opline =~ s/^./ /;
2939        my ($curr_values, $curr_vars) =
2940                annotate_values($opline . "\n", $prev_values);
2941        $curr_values = $prev_values . $curr_values;
2942        if ($dbg_values) {
2943            my $outline = $opline; $outline =~ s/\t/ /g;
2944            print "$linenr > .$outline\n";
2945            print "$linenr > $curr_values\n";
2946            print "$linenr > $curr_vars\n";
2947        }
2948        $prev_values = substr($curr_values, -1);
2949
2950#ignore lines not being added
2951        next if ($line =~ /^[^\+]/);
2952
2953# TEST: allow direct testing of the type matcher.
2954        if ($dbg_type) {
2955            if ($line =~ /^.\s*$Declare\s*$/) {
2956                ERROR("TEST_TYPE",
2957                      "TEST: is type\n" . $herecurr);
2958            } elsif ($dbg_type > 1 && $line =~ /^.+($Declare)/) {
2959                ERROR("TEST_NOT_TYPE",
2960                      "TEST: is not type ($1 is)\n". $herecurr);
2961            }
2962            next;
2963        }
2964# TEST: allow direct testing of the attribute matcher.
2965        if ($dbg_attr) {
2966            if ($line =~ /^.\s*$Modifier\s*$/) {
2967                ERROR("TEST_ATTR",
2968                      "TEST: is attr\n" . $herecurr);
2969            } elsif ($dbg_attr > 1 && $line =~ /^.+($Modifier)/) {
2970                ERROR("TEST_NOT_ATTR",
2971                      "TEST: is not attr ($1 is)\n". $herecurr);
2972            }
2973            next;
2974        }
2975
2976# check for initialisation to aggregates open brace on the next line
2977        if ($line =~ /^.\s*{/ &&
2978            $prevline =~ /(?:^|[^=])=\s*$/) {
2979            if (ERROR("OPEN_BRACE",
2980                  "that open brace { should be on the previous line\n" . $hereprev) &&
2981                $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
2982                fix_delete_line($fixlinenr - 1, $prevrawline);
2983                fix_delete_line($fixlinenr, $rawline);
2984                my $fixedline = $prevrawline;
2985                $fixedline =~ s/\s*=\s*$/ = {/;
2986                fix_insert_line($fixlinenr, $fixedline);
2987                $fixedline = $line;
2988                $fixedline =~ s/^(.\s*){\s*/$1/;
2989                fix_insert_line($fixlinenr, $fixedline);
2990            }
2991        }
2992
2993#
2994# Checks which are anchored on the added line.
2995#
2996
2997# check for malformed paths in #include statements (uses RAW line)
2998        if ($rawline =~ m{^.\s*\#\s*include\s+[<"](.*)[">]}) {
2999            my $path = $1;
3000            if ($path =~ m{//}) {
3001                ERROR("MALFORMED_INCLUDE",
3002                      "malformed #include filename\n" . $herecurr);
3003            }
3004            if ($path =~ "^uapi/" && $realfile =~ m@\binclude/uapi/@) {
3005                ERROR("UAPI_INCLUDE",
3006                      "No #include in ...include/uapi/... should use a uapi/ path prefix\n" . $herecurr);
3007            }
3008        }
3009
3010# no C99 // comments
3011        if ($line =~ m{//}) {
3012            if (ERROR("C99_COMMENTS",
3013                  "do not use C99 // comments\n" . $herecurr) &&
3014                $fix) {
3015                my $line = $fixed[$fixlinenr];
3016                if ($line =~ /\/\/(.*)$/) {
3017                    my $comment = trim($1);
3018                    $fixed[$fixlinenr] =~ s@\/\/(.*)$@/\* $comment \*/@;
3019                }
3020            }
3021        }
3022        # Remove C99 comments.
3023        $line =~ s@//.*@@;
3024        $opline =~ s@//.*@@;
3025
3026# EXPORT_SYMBOL should immediately follow the thing it is exporting, consider
3027# the whole statement.
3028#print "APW <$lines[$realline_next - 1]>\n";
3029        if (defined $realline_next &&
3030            exists $lines[$realline_next - 1] &&
3031            !defined $suppress_export{$realline_next} &&
3032            ($lines[$realline_next - 1] =~ /EXPORT_SYMBOL.*\((.*)\)/ ||
3033             $lines[$realline_next - 1] =~ /EXPORT_UNUSED_SYMBOL.*\((.*)\)/)) {
3034            # Handle definitions which produce identifiers with
3035            # a prefix:
3036            # XXX(foo);
3037            # EXPORT_SYMBOL(something_foo);
3038            my $name = $1;
3039            if ($stat =~ /^(?:.\s*}\s*\n)?.([A-Z_]+)\s*\(\s*($Ident)/ &&
3040                $name =~ /^${Ident}_$2/) {
3041#print "FOO C name<$name>\n";
3042                $suppress_export{$realline_next} = 1;
3043
3044            } elsif ($stat !~ /(?:
3045                \n.}\s*$|
3046                ^.DEFINE_$Ident\(\Q$name\E\)|
3047                ^.DECLARE_$Ident\(\Q$name\E\)|
3048                ^.LIST_HEAD\(\Q$name\E\)|
3049                ^.(?:$Storage\s+)?$Type\s*\(\s*\*\s*\Q$name\E\s*\)\s*\(|
3050                \b\Q$name\E(?:\s+$Attribute)*\s*(?:;|=|\[|\()
3051                )/x) {
3052#print "FOO A<$lines[$realline_next - 1]> stat<$stat> name<$name>\n";
3053                $suppress_export{$realline_next} = 2;
3054            } else {
3055                $suppress_export{$realline_next} = 1;
3056            }
3057        }
3058        if (!defined $suppress_export{$linenr} &&
3059            $prevline =~ /^.\s*$/ &&
3060            ($line =~ /EXPORT_SYMBOL.*\((.*)\)/ ||
3061             $line =~ /EXPORT_UNUSED_SYMBOL.*\((.*)\)/)) {
3062#print "FOO B <$lines[$linenr - 1]>\n";
3063            $suppress_export{$linenr} = 2;
3064        }
3065        if (defined $suppress_export{$linenr} &&
3066            $suppress_export{$linenr} == 2) {
3067            WARN("EXPORT_SYMBOL",
3068                 "EXPORT_SYMBOL(foo); should immediately follow its function/variable\n" . $herecurr);
3069        }
3070
3071# check for global initialisers.
3072        if ($line =~ /^\+(\s*$Type\s*$Ident\s*(?:\s+$Modifier))*\s*=\s*(0|NULL|false)\s*;/) {
3073            if (ERROR("GLOBAL_INITIALISERS",
3074                  "do not initialise globals to 0 or NULL\n" .
3075                      $herecurr) &&
3076                $fix) {
3077                $fixed[$fixlinenr] =~ s/($Type\s*$Ident\s*(?:\s+$Modifier))*\s*=\s*(0|NULL|false)\s*;/$1;/;
3078            }
3079        }
3080# check for static initialisers.
3081        if ($line =~ /^\+.*\bstatic\s.*=\s*(0|NULL|false)\s*;/) {
3082            if (ERROR("INITIALISED_STATIC",
3083                  "do not initialise statics to 0 or NULL\n" .
3084                      $herecurr) &&
3085                $fix) {
3086                $fixed[$fixlinenr] =~ s/(\bstatic\s.*?)\s*=\s*(0|NULL|false)\s*;/$1;/;
3087            }
3088        }
3089
3090# check for misordered declarations of char/short/int/long with signed/unsigned
3091        while ($sline =~ m{(\b$TypeMisordered\b)}g) {
3092            my $tmp = trim($1);
3093            WARN("MISORDERED_TYPE",
3094                 "type '$tmp' should be specified in [[un]signed] [short|int|long|long long] order\n" . $herecurr);
3095        }
3096
3097# check for static const char * arrays.
3098        if ($line =~ /\bstatic\s+const\s+char\s*\*\s*(\w+)\s*\[\s*\]\s*=\s*/) {
3099            WARN("STATIC_CONST_CHAR_ARRAY",
3100                 "static const char * array should probably be static const char * const\n" .
3101                $herecurr);
3102               }
3103
3104# check for static char foo[] = "bar" declarations.
3105        if ($line =~ /\bstatic\s+char\s+(\w+)\s*\[\s*\]\s*=\s*"/) {
3106            WARN("STATIC_CONST_CHAR_ARRAY",
3107                 "static char array declaration should probably be static const char\n" .
3108                $herecurr);
3109               }
3110
3111# check for non-global char *foo[] = {"bar", ...} declarations.
3112        if ($line =~ /^.\s+(?:static\s+|const\s+)?char\s+\*\s*\w+\s*\[\s*\]\s*=\s*\{/) {
3113            WARN("STATIC_CONST_CHAR_ARRAY",
3114                 "char * array declaration might be better as static const\n" .
3115                $herecurr);
3116               }
3117
3118# check for function declarations without arguments like "int foo()"
3119        if ($line =~ /(\b$Type\s+$Ident)\s*\(\s*\)/) {
3120            if (ERROR("FUNCTION_WITHOUT_ARGS",
3121                  "Bad function definition - $1() should probably be $1(void)\n" . $herecurr) &&
3122                $fix) {
3123                $fixed[$fixlinenr] =~ s/(\b($Type)\s+($Ident))\s*\(\s*\)/$2 $3(void)/;
3124            }
3125        }
3126
3127# check for uses of DEFINE_PCI_DEVICE_TABLE
3128        if ($line =~ /\bDEFINE_PCI_DEVICE_TABLE\s*\(\s*(\w+)\s*\)\s*=/) {
3129            if (WARN("DEFINE_PCI_DEVICE_TABLE",
3130                 "Prefer struct pci_device_id over deprecated DEFINE_PCI_DEVICE_TABLE\n" . $herecurr) &&
3131                $fix) {
3132                $fixed[$fixlinenr] =~ s/\b(?:static\s+|)DEFINE_PCI_DEVICE_TABLE\s*\(\s*(\w+)\s*\)\s*=\s*/static const struct pci_device_id $1\[\] = /;
3133            }
3134        }
3135
3136# check for new typedefs, only function parameters and sparse annotations
3137# make sense.
3138        if ($line =~ /\btypedef\s/ &&
3139            $line !~ /\btypedef\s+$Type\s*\(\s*\*?$Ident\s*\)\s*\(/ &&
3140            $line !~ /\btypedef\s+$Type\s+$Ident\s*\(/ &&
3141            $line !~ /\b$typeTypedefs\b/ &&
3142            $line !~ /\b__bitwise(?:__|)\b/) {
3143            WARN("NEW_TYPEDEFS",
3144                 "do not add new typedefs\n" . $herecurr);
3145        }
3146
3147# * goes on variable not on type
3148        # (char*[ const])
3149        while ($line =~ m{(\($NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)\))}g) {
3150            #print "AA<$1>\n";
3151            my ($ident, $from, $to) = ($1, $2, $2);
3152
3153            # Should start with a space.
3154            $to =~ s/^(\S)/ $1/;
3155            # Should not end with a space.
3156            $to =~ s/\s+$//;
3157            # '*'s should not have spaces between.
3158            while ($to =~ s/\*\s+\*/\*\*/) {
3159            }
3160
3161## print "1: from<$from> to<$to> ident<$ident>\n";
3162            if ($from ne $to) {
3163                if (ERROR("POINTER_LOCATION",
3164                      "\"(foo$from)\" should be \"(foo$to)\"\n" . $herecurr) &&
3165                    $fix) {
3166                    my $sub_from = $ident;
3167                    my $sub_to = $ident;
3168                    $sub_to =~ s/\Q$from\E/$to/;
3169                    $fixed[$fixlinenr] =~
3170                        s@\Q$sub_from\E@$sub_to@;
3171                }
3172            }
3173        }
3174        while ($line =~ m{(\b$NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)($Ident))}g) {
3175            #print "BB<$1>\n";
3176            my ($match, $from, $to, $ident) = ($1, $2, $2, $3);
3177
3178            # Should start with a space.
3179            $to =~ s/^(\S)/ $1/;
3180            # Should not end with a space.
3181            $to =~ s/\s+$//;
3182            # '*'s should not have spaces between.
3183            while ($to =~ s/\*\s+\*/\*\*/) {
3184            }
3185            # Modifiers should have spaces.
3186            $to =~ s/(\b$Modifier$)/$1 /;
3187
3188## print "2: from<$from> to<$to> ident<$ident>\n";
3189            if ($from ne $to && $ident !~ /^$Modifier$/) {
3190                if (ERROR("POINTER_LOCATION",
3191                      "\"foo${from}bar\" should be \"foo${to}bar\"\n" . $herecurr) &&
3192                    $fix) {
3193
3194                    my $sub_from = $match;
3195                    my $sub_to = $match;
3196                    $sub_to =~ s/\Q$from\E/$to/;
3197                    $fixed[$fixlinenr] =~
3198                        s@\Q$sub_from\E@$sub_to@;
3199                }
3200            }
3201        }
3202
3203# # no BUG() or BUG_ON()
3204# if ($line =~ /\b(BUG|BUG_ON)\b/) {
3205# print "Try to use WARN_ON & Recovery code rather than BUG() or BUG_ON()\n";
3206# print "$herecurr";
3207# $clean = 0;
3208# }
3209
3210        if ($line =~ /\bLINUX_VERSION_CODE\b/) {
3211            WARN("LINUX_VERSION_CODE",
3212                 "LINUX_VERSION_CODE should be avoided, code should be for the version to which it is merged\n" . $herecurr);
3213        }
3214
3215# check for uses of printk_ratelimit
3216        if ($line =~ /\bprintk_ratelimit\s*\(/) {
3217            WARN("PRINTK_RATELIMITED",
3218"Prefer printk_ratelimited or pr_<level>_ratelimited to printk_ratelimit\n" . $herecurr);
3219        }
3220
3221# printk should use KERN_* levels. Note that follow on printk's on the
3222# same line do not need a level, so we use the current block context
3223# to try and find and validate the current printk. In summary the current
3224# printk includes all preceding printk's which have no newline on the end.
3225# we assume the first bad printk is the one to report.
3226        if ($line =~ /\bprintk\((?!KERN_)\s*"/) {
3227            my $ok = 0;
3228            for (my $ln = $linenr - 1; $ln >= $first_line; $ln--) {
3229                #print "CHECK<$lines[$ln - 1]\n";
3230                # we have a preceding printk if it ends
3231                # with "\n" ignore it, else it is to blame
3232                if ($lines[$ln - 1] =~ m{\bprintk\(}) {
3233                    if ($rawlines[$ln - 1] !~ m{\\n"}) {
3234                        $ok = 1;
3235                    }
3236                    last;
3237                }
3238            }
3239            if ($ok == 0) {
3240                WARN("PRINTK_WITHOUT_KERN_LEVEL",
3241                     "printk() should include KERN_ facility level\n" . $herecurr);
3242            }
3243        }
3244
3245        if ($line =~ /\bprintk\s*\(\s*KERN_([A-Z]+)/) {
3246            my $orig = $1;
3247            my $level = lc($orig);
3248            $level = "warn" if ($level eq "warning");
3249            my $level2 = $level;
3250            $level2 = "dbg" if ($level eq "debug");
3251            WARN("PREFER_PR_LEVEL",
3252                 "Prefer [subsystem eg: netdev]_$level2([subsystem]dev, ... then dev_$level2(dev, ... then pr_$level(... to printk(KERN_$orig ...\n" . $herecurr);
3253        }
3254
3255        if ($line =~ /\bpr_warning\s*\(/) {
3256            if (WARN("PREFER_PR_LEVEL",
3257                 "Prefer pr_warn(... to pr_warning(...\n" . $herecurr) &&
3258                $fix) {
3259                $fixed[$fixlinenr] =~
3260                    s/\bpr_warning\b/pr_warn/;
3261            }
3262        }
3263
3264        if ($line =~ /\bdev_printk\s*\(\s*KERN_([A-Z]+)/) {
3265            my $orig = $1;
3266            my $level = lc($orig);
3267            $level = "warn" if ($level eq "warning");
3268            $level = "dbg" if ($level eq "debug");
3269            WARN("PREFER_DEV_LEVEL",
3270                 "Prefer dev_$level(... to dev_printk(KERN_$orig, ...\n" . $herecurr);
3271        }
3272
3273# function brace can't be on same line, except for #defines of do while,
3274# or if closed on same line
3275        if (($line=~/$Type\s*$Ident\(.*\).*\s*{/) and
3276            !($line=~/\#\s*define.*do\s{/) and !($line=~/}/)) {
3277            if (ERROR("OPEN_BRACE",
3278                  "open brace '{' following function declarations go on the next line\n" . $herecurr) &&
3279                $fix) {
3280                fix_delete_line($fixlinenr, $rawline);
3281                my $fixed_line = $rawline;
3282                $fixed_line =~ /(^..*$Type\s*$Ident\(.*\)\s*){(.*)$/;
3283                my $line1 = $1;
3284                my $line2 = $2;
3285                fix_insert_line($fixlinenr, ltrim($line1));
3286                fix_insert_line($fixlinenr, "\+{");
3287                if ($line2 !~ /^\s*$/) {
3288                    fix_insert_line($fixlinenr, "\+\t" . trim($line2));
3289                }
3290            }
3291        }
3292
3293# open braces for enum, union and struct go on the same line.
3294        if ($line =~ /^.\s*{/ &&
3295            $prevline =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident)?\s*$/) {
3296            if (ERROR("OPEN_BRACE",
3297                  "open brace '{' following $1 go on the same line\n" . $hereprev) &&
3298                $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
3299                fix_delete_line($fixlinenr - 1, $prevrawline);
3300                fix_delete_line($fixlinenr, $rawline);
3301                my $fixedline = rtrim($prevrawline) . " {";
3302                fix_insert_line($fixlinenr, $fixedline);
3303                $fixedline = $rawline;
3304                $fixedline =~ s/^(.\s*){\s*/$1\t/;
3305                if ($fixedline !~ /^\+\s*$/) {
3306                    fix_insert_line($fixlinenr, $fixedline);
3307                }
3308            }
3309        }
3310
3311# missing space after union, struct or enum definition
3312        if ($line =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident){1,2}[=\{]/) {
3313            if (WARN("SPACING",
3314                 "missing space after $1 definition\n" . $herecurr) &&
3315                $fix) {
3316                $fixed[$fixlinenr] =~
3317                    s/^(.\s*(?:typedef\s+)?(?:enum|union|struct)(?:\s+$Ident){1,2})([=\{])/$1 $2/;
3318            }
3319        }
3320
3321# Function pointer declarations
3322# check spacing between type, funcptr, and args
3323# canonical declaration is "type (*funcptr)(args...)"
3324        if ($line =~ /^.\s*($Declare)\((\s*)\*(\s*)($Ident)(\s*)\)(\s*)\(/) {
3325            my $declare = $1;
3326            my $pre_pointer_space = $2;
3327            my $post_pointer_space = $3;
3328            my $funcname = $4;
3329            my $post_funcname_space = $5;
3330            my $pre_args_space = $6;
3331
3332# the $Declare variable will capture all spaces after the type
3333# so check it for a missing trailing missing space but pointer return types
3334# don't need a space so don't warn for those.
3335            my $post_declare_space = "";
3336            if ($declare =~ /(\s+)$/) {
3337                $post_declare_space = $1;
3338                $declare = rtrim($declare);
3339            }
3340            if ($declare !~ /\*$/ && $post_declare_space =~ /^$/) {
3341                WARN("SPACING",
3342                     "missing space after return type\n" . $herecurr);
3343                $post_declare_space = " ";
3344            }
3345
3346# unnecessary space "type (*funcptr)(args...)"
3347# This test is not currently implemented because these declarations are
3348# equivalent to
3349# int foo(int bar, ...)
3350# and this is form shouldn't/doesn't generate a checkpatch warning.
3351#
3352# elsif ($declare =~ /\s{2,}$/) {
3353# WARN("SPACING",
3354# "Multiple spaces after return type\n" . $herecurr);
3355# }
3356
3357# unnecessary space "type ( *funcptr)(args...)"
3358            if (defined $pre_pointer_space &&
3359                $pre_pointer_space =~ /^\s/) {
3360                WARN("SPACING",
3361                     "Unnecessary space after function pointer open parenthesis\n" . $herecurr);
3362            }
3363
3364# unnecessary space "type (* funcptr)(args...)"
3365            if (defined $post_pointer_space &&
3366                $post_pointer_space =~ /^\s/) {
3367                WARN("SPACING",
3368                     "Unnecessary space before function pointer name\n" . $herecurr);
3369            }
3370
3371# unnecessary space "type (*funcptr )(args...)"
3372            if (defined $post_funcname_space &&
3373                $post_funcname_space =~ /^\s/) {
3374                WARN("SPACING",
3375                     "Unnecessary space after function pointer name\n" . $herecurr);
3376            }
3377
3378# unnecessary space "type (*funcptr) (args...)"
3379            if (defined $pre_args_space &&
3380                $pre_args_space =~ /^\s/) {
3381                WARN("SPACING",
3382                     "Unnecessary space before function pointer arguments\n" . $herecurr);
3383            }
3384
3385            if (show_type("SPACING") && $fix) {
3386                $fixed[$fixlinenr] =~
3387                    s/^(.\s*)$Declare\s*\(\s*\*\s*$Ident\s*\)\s*\(/$1 . $declare . $post_declare_space . '(*' . $funcname . ')('/ex;
3388            }
3389        }
3390
3391# check for spacing round square brackets; allowed:
3392# 1. with a type on the left -- int [] a;
3393# 2. at the beginning of a line for slice initialisers -- [0...10] = 5,
3394# 3. inside a curly brace -- = { [0...10] = 5 }
3395        while ($line =~ /(.*?\s)\[/g) {
3396            my ($where, $prefix) = ($-[1], $1);
3397            if ($prefix !~ /$Type\s+$/ &&
3398                ($where != 0 || $prefix !~ /^.\s+$/) &&
3399                $prefix !~ /[{,]\s+$/) {
3400                if (ERROR("BRACKET_SPACE",
3401                      "space prohibited before open square bracket '['\n" . $herecurr) &&
3402                    $fix) {
3403                    $fixed[$fixlinenr] =~
3404                    s/^(\+.*?)\s+\[/$1\[/;
3405                }
3406            }
3407        }
3408
3409# check for spaces between functions and their parentheses.
3410        while ($line =~ /($Ident)\s+\(/g) {
3411            my $name = $1;
3412            my $ctx_before = substr($line, 0, $-[1]);
3413            my $ctx = "$ctx_before$name";
3414
3415            # Ignore those directives where spaces _are_ permitted.
3416            if ($name =~ /^(?:
3417                if|for|while|switch|return|case|
3418                volatile|__volatile__|
3419                __attribute__|format|__extension__|
3420                asm|__asm__)$/x)
3421            {
3422            # cpp #define statements have non-optional spaces, ie
3423            # if there is a space between the name and the open
3424            # parenthesis it is simply not a parameter group.
3425            } elsif ($ctx_before =~ /^.\s*\#\s*define\s*$/) {
3426
3427            # cpp #elif statement condition may start with a (
3428            } elsif ($ctx =~ /^.\s*\#\s*elif\s*$/) {
3429
3430            # If this whole things ends with a type its most
3431            # likely a typedef for a function.
3432            } elsif ($ctx =~ /$Type$/) {
3433
3434            } else {
3435                if (WARN("SPACING",
3436                     "space prohibited between function name and open parenthesis '('\n" . $herecurr) &&
3437                         $fix) {
3438                    $fixed[$fixlinenr] =~
3439                        s/\b$name\s+\(/$name\(/;
3440                }
3441            }
3442        }
3443
3444# Check operator spacing.
3445        if (!($line=~/\#\s*include/)) {
3446            my $fixed_line = "";
3447            my $line_fixed = 0;
3448
3449            my $ops = qr{
3450                <<=|>>=|<=|>=|==|!=|
3451                \+=|-=|\*=|\/=|%=|\^=|\|=|&=|
3452                =>|->|<<|>>|<|>|=|!|~|
3453                &&|\|\||,|\^|\+\+|--|&|\||\+|-|\*|\/|%|
3454                \?:|\?|:
3455            }x;
3456            my @elements = split(/($ops|;)/, $opline);
3457
3458## print("element count: <" . $#elements . ">\n");
3459## foreach my $el (@elements) {
3460## print("el: <$el>\n");
3461## }
3462
3463            my @fix_elements = ();
3464            my $off = 0;
3465
3466            foreach my $el (@elements) {
3467                push(@fix_elements, substr($rawline, $off, length($el)));
3468                $off += length($el);
3469            }
3470
3471            $off = 0;
3472
3473            my $blank = copy_spacing($opline);
3474            my $last_after = -1;
3475
3476            for (my $n = 0; $n < $#elements; $n += 2) {
3477
3478                my $good = $fix_elements[$n] . $fix_elements[$n + 1];
3479
3480## print("n: <$n> good: <$good>\n");
3481
3482                $off += length($elements[$n]);
3483
3484                # Pick up the preceding and succeeding characters.
3485                my $ca = substr($opline, 0, $off);
3486                my $cc = '';
3487                if (length($opline) >= ($off + length($elements[$n + 1]))) {
3488                    $cc = substr($opline, $off + length($elements[$n + 1]));
3489                }
3490                my $cb = "$ca$;$cc";
3491
3492                my $a = '';
3493                $a = 'V' if ($elements[$n] ne '');
3494                $a = 'W' if ($elements[$n] =~ /\s$/);
3495                $a = 'C' if ($elements[$n] =~ /$;$/);
3496                $a = 'B' if ($elements[$n] =~ /(\[|\()$/);
3497                $a = 'O' if ($elements[$n] eq '');
3498                $a = 'E' if ($ca =~ /^\s*$/);
3499
3500                my $op = $elements[$n + 1];
3501
3502                my $c = '';
3503                if (defined $elements[$n + 2]) {
3504                    $c = 'V' if ($elements[$n + 2] ne '');
3505                    $c = 'W' if ($elements[$n + 2] =~ /^\s/);
3506                    $c = 'C' if ($elements[$n + 2] =~ /^$;/);
3507                    $c = 'B' if ($elements[$n + 2] =~ /^(\)|\]|;)/);
3508                    $c = 'O' if ($elements[$n + 2] eq '');
3509                    $c = 'E' if ($elements[$n + 2] =~ /^\s*\\$/);
3510                } else {
3511                    $c = 'E';
3512                }
3513
3514                my $ctx = "${a}x${c}";
3515
3516                my $at = "(ctx:$ctx)";
3517
3518                my $ptr = substr($blank, 0, $off) . "^";
3519                my $hereptr = "$hereline$ptr\n";
3520
3521                # Pull out the value of this operator.
3522                my $op_type = substr($curr_values, $off + 1, 1);
3523
3524                # Get the full operator variant.
3525                my $opv = $op . substr($curr_vars, $off, 1);
3526
3527                # Ignore operators passed as parameters.
3528                if ($op_type ne 'V' &&
3529                    $ca =~ /\s$/ && $cc =~ /^\s*,/) {
3530
3531# # Ignore comments
3532# } elsif ($op =~ /^$;+$/) {
3533
3534                # ; should have either the end of line or a space or \ after it
3535                } elsif ($op eq ';') {
3536                    if ($ctx !~ /.x[WEBC]/ &&
3537                        $cc !~ /^\\/ && $cc !~ /^;/) {
3538                        if (ERROR("SPACING",
3539                              "space required after that '$op' $at\n" . $hereptr)) {
3540                            $good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";
3541                            $line_fixed = 1;
3542                        }
3543                    }
3544
3545                # // is a comment
3546                } elsif ($op eq '//') {
3547
3548                # : when part of a bitfield
3549                } elsif ($opv eq ':B') {
3550                    # skip the bitfield test for now
3551
3552                # No spaces for:
3553                # ->
3554                } elsif ($op eq '->') {
3555                    if ($ctx =~ /Wx.|.xW/) {
3556                        if (ERROR("SPACING",
3557                              "spaces prohibited around that '$op' $at\n" . $hereptr)) {
3558                            $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
3559                            if (defined $fix_elements[$n + 2]) {
3560                                $fix_elements[$n + 2] =~ s/^\s+//;
3561                            }
3562                            $line_fixed = 1;
3563                        }
3564                    }
3565
3566                # , must have a space on the right.
3567                } elsif ($op eq ',') {
3568                    if ($ctx !~ /.x[WEC]/ && $cc !~ /^}/) {
3569                        if (ERROR("SPACING",
3570                              "space required after that '$op' $at\n" . $hereptr)) {
3571                            $good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";
3572                            $line_fixed = 1;
3573                            $last_after = $n;
3574                        }
3575                    }
3576
3577                # '*' as part of a type definition -- reported already.
3578                } elsif ($opv eq '*_') {
3579                    #warn "'*' is part of type\n";
3580
3581                # unary operators should have a space before and
3582                # none after. May be left adjacent to another
3583                # unary operator, or a cast
3584                } elsif ($op eq '!' || $op eq '~' ||
3585                     $opv eq '*U' || $opv eq '-U' ||
3586                     $opv eq '&U' || $opv eq '&&U') {
3587                    if ($ctx !~ /[WEBC]x./ && $ca !~ /(?:\)|!|~|\*|-|\&|\||\+\+|\-\-|\{)$/) {
3588                        if (ERROR("SPACING",
3589                              "space required before that '$op' $at\n" . $hereptr)) {
3590                            if ($n != $last_after + 2) {
3591                                $good = $fix_elements[$n] . " " . ltrim($fix_elements[$n + 1]);
3592                                $line_fixed = 1;
3593                            }
3594                        }
3595                    }
3596                    if ($op eq '*' && $cc =~/\s*$Modifier\b/) {
3597                        # A unary '*' may be const
3598
3599                    } elsif ($ctx =~ /.xW/) {
3600                        if (ERROR("SPACING",
3601                              "space prohibited after that '$op' $at\n" . $hereptr)) {
3602                            $good = $fix_elements[$n] . rtrim($fix_elements[$n + 1]);
3603                            if (defined $fix_elements[$n + 2]) {
3604                                $fix_elements[$n + 2] =~ s/^\s+//;
3605                            }
3606                            $line_fixed = 1;
3607                        }
3608                    }
3609
3610                # unary ++ and unary -- are allowed no space on one side.
3611                } elsif ($op eq '++' or $op eq '--') {
3612                    if ($ctx !~ /[WEOBC]x[^W]/ && $ctx !~ /[^W]x[WOBEC]/) {
3613                        if (ERROR("SPACING",
3614                              "space required one side of that '$op' $at\n" . $hereptr)) {
3615                            $good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";
3616                            $line_fixed = 1;
3617                        }
3618                    }
3619                    if ($ctx =~ /Wx[BE]/ ||
3620                        ($ctx =~ /Wx./ && $cc =~ /^;/)) {
3621                        if (ERROR("SPACING",
3622                              "space prohibited before that '$op' $at\n" . $hereptr)) {
3623                            $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
3624                            $line_fixed = 1;
3625                        }
3626                    }
3627                    if ($ctx =~ /ExW/) {
3628                        if (ERROR("SPACING",
3629                              "space prohibited after that '$op' $at\n" . $hereptr)) {
3630                            $good = $fix_elements[$n] . trim($fix_elements[$n + 1]);
3631                            if (defined $fix_elements[$n + 2]) {
3632                                $fix_elements[$n + 2] =~ s/^\s+//;
3633                            }
3634                            $line_fixed = 1;
3635                        }
3636                    }
3637
3638                # << and >> may either have or not have spaces both sides
3639                } elsif ($op eq '<<' or $op eq '>>' or
3640                     $op eq '&' or $op eq '^' or $op eq '|' or
3641                     $op eq '+' or $op eq '-' or
3642                     $op eq '*' or $op eq '/' or
3643                     $op eq '%')
3644                {
3645                    if ($ctx =~ /Wx[^WCE]|[^WCE]xW/) {
3646                        if (ERROR("SPACING",
3647                              "need consistent spacing around '$op' $at\n" . $hereptr)) {
3648                            $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
3649                            if (defined $fix_elements[$n + 2]) {
3650                                $fix_elements[$n + 2] =~ s/^\s+//;
3651                            }
3652                            $line_fixed = 1;
3653                        }
3654                    }
3655
3656                # A colon needs no spaces before when it is
3657                # terminating a case value or a label.
3658                } elsif ($opv eq ':C' || $opv eq ':L') {
3659                    if ($ctx =~ /Wx./) {
3660                        if (ERROR("SPACING",
3661                              "space prohibited before that '$op' $at\n" . $hereptr)) {
3662                            $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
3663                            $line_fixed = 1;
3664                        }
3665                    }
3666
3667                # All the others need spaces both sides.
3668                } elsif ($ctx !~ /[EWC]x[CWE]/) {
3669                    my $ok = 0;
3670
3671                    # Ignore email addresses <foo@bar>
3672                    if (($op eq '<' &&
3673                         $cc =~ /^\S+\@\S+>/) ||
3674                        ($op eq '>' &&
3675                         $ca =~ /<\S+\@\S+$/))
3676                    {
3677                            $ok = 1;
3678                    }
3679
3680                    # messages are ERROR, but ?: are CHK
3681                    if ($ok == 0) {
3682                        my $msg_type = \&ERROR;
3683                        $msg_type = \&CHK if (($op eq '?:' || $op eq '?' || $op eq ':') && $ctx =~ /VxV/);
3684
3685                        if (&{$msg_type}("SPACING",
3686                                 "spaces required around that '$op' $at\n" . $hereptr)) {
3687                            $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
3688                            if (defined $fix_elements[$n + 2]) {
3689                                $fix_elements[$n + 2] =~ s/^\s+//;
3690                            }
3691                            $line_fixed = 1;
3692                        }
3693                    }
3694                }
3695                $off += length($elements[$n + 1]);
3696
3697## print("n: <$n> GOOD: <$good>\n");
3698
3699                $fixed_line = $fixed_line . $good;
3700            }
3701
3702            if (($#elements % 2) == 0) {
3703                $fixed_line = $fixed_line . $fix_elements[$#elements];
3704            }
3705
3706            if ($fix && $line_fixed && $fixed_line ne $fixed[$fixlinenr]) {
3707                $fixed[$fixlinenr] = $fixed_line;
3708            }
3709
3710
3711        }
3712
3713# check for whitespace before a non-naked semicolon
3714        if ($line =~ /^\+.*\S\s+;\s*$/) {
3715            if (WARN("SPACING",
3716                 "space prohibited before semicolon\n" . $herecurr) &&
3717                $fix) {
3718                1 while $fixed[$fixlinenr] =~
3719                    s/^(\+.*\S)\s+;/$1;/;
3720            }
3721        }
3722
3723# check for multiple assignments
3724        if ($line =~ /^.\s*$Lval\s*=\s*$Lval\s*=(?!=)/) {
3725            CHK("MULTIPLE_ASSIGNMENTS",
3726                "multiple assignments should be avoided\n" . $herecurr);
3727        }
3728
3729## # check for multiple declarations, allowing for a function declaration
3730## # continuation.
3731## if ($line =~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Ident.*/ &&
3732## $line !~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Type\s*$Ident.*/) {
3733##
3734## # Remove any bracketed sections to ensure we do not
3735## # falsly report the parameters of functions.
3736## my $ln = $line;
3737## while ($ln =~ s/\([^\(\)]*\)//g) {
3738## }
3739## if ($ln =~ /,/) {
3740## WARN("MULTIPLE_DECLARATION",
3741## "declaring multiple variables together should be avoided\n" . $herecurr);
3742## }
3743## }
3744
3745#need space before brace following if, while, etc
3746        if (($line =~ /\(.*\){/ && $line !~ /\($Type\){/) ||
3747            $line =~ /do{/) {
3748            if (ERROR("SPACING",
3749                  "space required before the open brace '{'\n" . $herecurr) &&
3750                $fix) {
3751                $fixed[$fixlinenr] =~ s/^(\+.*(?:do|\))){/$1 {/;
3752            }
3753        }
3754
3755## # check for blank lines before declarations
3756## if ($line =~ /^.\t+$Type\s+$Ident(?:\s*=.*)?;/ &&
3757## $prevrawline =~ /^.\s*$/) {
3758## WARN("SPACING",
3759## "No blank lines before declarations\n" . $hereprev);
3760## }
3761##
3762
3763# closing brace should have a space following it when it has anything
3764# on the line
3765        if ($line =~ /}(?!(?:,|;|\)))\S/) {
3766            if (ERROR("SPACING",
3767                  "space required after that close brace '}'\n" . $herecurr) &&
3768                $fix) {
3769                $fixed[$fixlinenr] =~
3770                    s/}((?!(?:,|;|\)))\S)/} $1/;
3771            }
3772        }
3773
3774# check spacing on square brackets
3775        if ($line =~ /\[\s/ && $line !~ /\[\s*$/) {
3776            if (ERROR("SPACING",
3777                  "space prohibited after that open square bracket '['\n" . $herecurr) &&
3778                $fix) {
3779                $fixed[$fixlinenr] =~
3780                    s/\[\s+/\[/;
3781            }
3782        }
3783        if ($line =~ /\s\]/) {
3784            if (ERROR("SPACING",
3785                  "space prohibited before that close square bracket ']'\n" . $herecurr) &&
3786                $fix) {
3787                $fixed[$fixlinenr] =~
3788                    s/\s+\]/\]/;
3789            }
3790        }
3791
3792# check spacing on parentheses
3793        if ($line =~ /\(\s/ && $line !~ /\(\s*(?:\\)?$/ &&
3794            $line !~ /for\s*\(\s+;/) {
3795            if (ERROR("SPACING",
3796                  "space prohibited after that open parenthesis '('\n" . $herecurr) &&
3797                $fix) {
3798                $fixed[$fixlinenr] =~
3799                    s/\(\s+/\(/;
3800            }
3801        }
3802        if ($line =~ /(\s+)\)/ && $line !~ /^.\s*\)/ &&
3803            $line !~ /for\s*\(.*;\s+\)/ &&
3804            $line !~ /:\s+\)/) {
3805            if (ERROR("SPACING",
3806                  "space prohibited before that close parenthesis ')'\n" . $herecurr) &&
3807                $fix) {
3808                $fixed[$fixlinenr] =~
3809                    s/\s+\)/\)/;
3810            }
3811        }
3812
3813# check unnecessary parentheses around addressof/dereference single $Lvals
3814# ie: &(foo->bar) should be &foo->bar and *(foo->bar) should be *foo->bar
3815
3816        while ($line =~ /(?:[^&]&\s*|\*)\(\s*($Ident\s*(?:$Member\s*)+)\s*\)/g) {
3817            CHK("UNNECESSARY_PARENTHESES",
3818                "Unnecessary parentheses around $1\n" . $herecurr);
3819            }
3820
3821#goto labels aren't indented, allow a single space however
3822        if ($line=~/^.\s+[A-Za-z\d_]+:(?![0-9]+)/ and
3823           !($line=~/^. [A-Za-z\d_]+:/) and !($line=~/^.\s+default:/)) {
3824            if (WARN("INDENTED_LABEL",
3825                 "labels should not be indented\n" . $herecurr) &&
3826                $fix) {
3827                $fixed[$fixlinenr] =~
3828                    s/^(.)\s+/$1/;
3829            }
3830        }
3831
3832# return is not a function
3833        if (defined($stat) && $stat =~ /^.\s*return(\s*)\(/s) {
3834            my $spacing = $1;
3835            if ($^V && $^V ge 5.10.0 &&
3836                $stat =~ /^.\s*return\s*($balanced_parens)\s*;\s*$/) {
3837                my $value = $1;
3838                $value = deparenthesize($value);
3839                if ($value =~ m/^\s*$FuncArg\s*(?:\?|$)/) {
3840                    ERROR("RETURN_PARENTHESES",
3841                          "return is not a function, parentheses are not required\n" . $herecurr);
3842                }
3843            } elsif ($spacing !~ /\s+/) {
3844                ERROR("SPACING",
3845                      "space required before the open parenthesis '('\n" . $herecurr);
3846            }
3847        }
3848
3849# unnecessary return in a void function
3850# at end-of-function, with the previous line a single leading tab, then return;
3851# and the line before that not a goto label target like "out:"
3852        if ($sline =~ /^[ \+]}\s*$/ &&
3853            $prevline =~ /^\+\treturn\s*;\s*$/ &&
3854            $linenr >= 3 &&
3855            $lines[$linenr - 3] =~ /^[ +]/ &&
3856            $lines[$linenr - 3] !~ /^[ +]\s*$Ident\s*:/) {
3857            WARN("RETURN_VOID",
3858                 "void function return statements are not generally useful\n" . $hereprev);
3859               }
3860
3861# if statements using unnecessary parentheses - ie: if ((foo == bar))
3862        if ($^V && $^V ge 5.10.0 &&
3863            $line =~ /\bif\s*((?:\(\s*){2,})/) {
3864            my $openparens = $1;
3865            my $count = $openparens =~ tr@\(@\(@;
3866            my $msg = "";
3867            if ($line =~ /\bif\s*(?:\(\s*){$count,$count}$LvalOrFunc\s*($Compare)\s*$LvalOrFunc(?:\s*\)){$count,$count}/) {
3868                my $comp = $4; #Not $1 because of $LvalOrFunc
3869                $msg = " - maybe == should be = ?" if ($comp eq "==");
3870                WARN("UNNECESSARY_PARENTHESES",
3871                     "Unnecessary parentheses$msg\n" . $herecurr);
3872            }
3873        }
3874
3875# Return of what appears to be an errno should normally be -'ve
3876        if ($line =~ /^.\s*return\s*(E[A-Z]*)\s*;/) {
3877            my $name = $1;
3878            if ($name ne 'EOF' && $name ne 'ERROR') {
3879                WARN("USE_NEGATIVE_ERRNO",
3880                     "return of an errno should typically be -ve (return -$1)\n" . $herecurr);
3881            }
3882        }
3883
3884# Need a space before open parenthesis after if, while etc
3885        if ($line =~ /\b(if|while|for|switch)\(/) {
3886            if (ERROR("SPACING",
3887                  "space required before the open parenthesis '('\n" . $herecurr) &&
3888                $fix) {
3889                $fixed[$fixlinenr] =~
3890                    s/\b(if|while|for|switch)\(/$1 \(/;
3891            }
3892        }
3893
3894# Check for illegal assignment in if conditional -- and check for trailing
3895# statements after the conditional.
3896        if ($line =~ /do\s*(?!{)/) {
3897            ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
3898                ctx_statement_block($linenr, $realcnt, 0)
3899                    if (!defined $stat);
3900            my ($stat_next) = ctx_statement_block($line_nr_next,
3901                        $remain_next, $off_next);
3902            $stat_next =~ s/\n./\n /g;
3903            ##print "stat<$stat> stat_next<$stat_next>\n";
3904
3905            if ($stat_next =~ /^\s*while\b/) {
3906                # If the statement carries leading newlines,
3907                # then count those as offsets.
3908                my ($whitespace) =
3909                    ($stat_next =~ /^((?:\s*\n[+-])*\s*)/s);
3910                my $offset =
3911                    statement_rawlines($whitespace) - 1;
3912
3913                $suppress_whiletrailers{$line_nr_next +
3914                                $offset} = 1;
3915            }
3916        }
3917        if (!defined $suppress_whiletrailers{$linenr} &&
3918            defined($stat) && defined($cond) &&
3919            $line =~ /\b(?:if|while|for)\s*\(/ && $line !~ /^.\s*#/) {
3920            my ($s, $c) = ($stat, $cond);
3921
3922            if ($c =~ /\bif\s*\(.*[^<>!=]=[^=].*/s) {
3923                ERROR("ASSIGN_IN_IF",
3924                      "do not use assignment in if condition\n" . $herecurr);
3925            }
3926
3927            # Find out what is on the end of the line after the
3928            # conditional.
3929            substr($s, 0, length($c), '');
3930            $s =~ s/\n.*//g;
3931            $s =~ s/$;//g; # Remove any comments
3932            if (length($c) && $s !~ /^\s*{?\s*\\*\s*$/ &&
3933                $c !~ /}\s*while\s*/)
3934            {
3935                # Find out how long the conditional actually is.
3936                my @newlines = ($c =~ /\n/gs);
3937                my $cond_lines = 1 + $#newlines;
3938                my $stat_real = '';
3939
3940                $stat_real = raw_line($linenr, $cond_lines)
3941                            . "\n" if ($cond_lines);
3942                if (defined($stat_real) && $cond_lines > 1) {
3943                    $stat_real = "[...]\n$stat_real";
3944                }
3945
3946                ERROR("TRAILING_STATEMENTS",
3947                      "trailing statements should be on next line\n" . $herecurr . $stat_real);
3948            }
3949        }
3950
3951# Check for bitwise tests written as boolean
3952        if ($line =~ /
3953            (?:
3954                (?:\[|\(|\&\&|\|\|)
3955                \s*0[xX][0-9]+\s*
3956                (?:\&\&|\|\|)
3957            |
3958                (?:\&\&|\|\|)
3959                \s*0[xX][0-9]+\s*
3960                (?:\&\&|\|\||\)|\])
3961            )/x)
3962        {
3963            WARN("HEXADECIMAL_BOOLEAN_TEST",
3964                 "boolean test with hexadecimal, perhaps just 1 \& or \|?\n" . $herecurr);
3965        }
3966
3967# if and else should not have general statements after it
3968        if ($line =~ /^.\s*(?:}\s*)?else\b(.*)/) {
3969            my $s = $1;
3970            $s =~ s/$;//g; # Remove any comments
3971            if ($s !~ /^\s*(?:\sif|(?:{|)\s*\\?\s*$)/) {
3972                ERROR("TRAILING_STATEMENTS",
3973                      "trailing statements should be on next line\n" . $herecurr);
3974            }
3975        }
3976# if should not continue a brace
3977        if ($line =~ /}\s*if\b/) {
3978            ERROR("TRAILING_STATEMENTS",
3979                  "trailing statements should be on next line (or did you mean 'else if'?)\n" .
3980                $herecurr);
3981        }
3982# case and default should not have general statements after them
3983        if ($line =~ /^.\s*(?:case\s*.*|default\s*):/g &&
3984            $line !~ /\G(?:
3985            (?:\s*$;*)(?:\s*{)?(?:\s*$;*)(?:\s*\\)?\s*$|
3986            \s*return\s+
3987            )/xg)
3988        {
3989            ERROR("TRAILING_STATEMENTS",
3990                  "trailing statements should be on next line\n" . $herecurr);
3991        }
3992
3993        # Check for }<nl>else {, these must be at the same
3994        # indent level to be relevant to each other.
3995        if ($prevline=~/}\s*$/ and $line=~/^.\s*else\s*/ &&
3996            $previndent == $indent) {
3997            if (ERROR("ELSE_AFTER_BRACE",
3998                  "else should follow close brace '}'\n" . $hereprev) &&
3999                $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
4000                fix_delete_line($fixlinenr - 1, $prevrawline);
4001                fix_delete_line($fixlinenr, $rawline);
4002                my $fixedline = $prevrawline;
4003                $fixedline =~ s/}\s*$//;
4004                if ($fixedline !~ /^\+\s*$/) {
4005                    fix_insert_line($fixlinenr, $fixedline);
4006                }
4007                $fixedline = $rawline;
4008                $fixedline =~ s/^(.\s*)else/$1} else/;
4009                fix_insert_line($fixlinenr, $fixedline);
4010            }
4011        }
4012
4013        if ($prevline=~/}\s*$/ and $line=~/^.\s*while\s*/ &&
4014            $previndent == $indent) {
4015            my ($s, $c) = ctx_statement_block($linenr, $realcnt, 0);
4016
4017            # Find out what is on the end of the line after the
4018            # conditional.
4019            substr($s, 0, length($c), '');
4020            $s =~ s/\n.*//g;
4021
4022            if ($s =~ /^\s*;/) {
4023                if (ERROR("WHILE_AFTER_BRACE",
4024                      "while should follow close brace '}'\n" . $hereprev) &&
4025                    $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
4026                    fix_delete_line($fixlinenr - 1, $prevrawline);
4027                    fix_delete_line($fixlinenr, $rawline);
4028                    my $fixedline = $prevrawline;
4029                    my $trailing = $rawline;
4030                    $trailing =~ s/^\+//;
4031                    $trailing = trim($trailing);
4032                    $fixedline =~ s/}\s*$/} $trailing/;
4033                    fix_insert_line($fixlinenr, $fixedline);
4034                }
4035            }
4036        }
4037
4038#Specific variable tests
4039        while ($line =~ m{($Constant|$Lval)}g) {
4040            my $var = $1;
4041
4042#gcc binary extension
4043            if ($var =~ /^$Binary$/) {
4044                if (WARN("GCC_BINARY_CONSTANT",
4045                     "Avoid gcc v4.3+ binary constant extension: <$var>\n" . $herecurr) &&
4046                    $fix) {
4047                    my $hexval = sprintf("0x%x", oct($var));
4048                    $fixed[$fixlinenr] =~
4049                        s/\b$var\b/$hexval/;
4050                }
4051            }
4052
4053#CamelCase
4054            if ($var !~ /^$Constant$/ &&
4055                $var =~ /[A-Z][a-z]|[a-z][A-Z]/ &&
4056#Ignore Page<foo> variants
4057                $var !~ /^(?:Clear|Set|TestClear|TestSet|)Page[A-Z]/ &&
4058#Ignore SI style variants like nS, mV and dB (ie: max_uV, regulator_min_uA_show)
4059                $var !~ /^(?:[a-z_]*?)_?[a-z][A-Z](?:_[a-z_]+)?$/) {
4060                while ($var =~ m{($Ident)}g) {
4061                    my $word = $1;
4062                    next if ($word !~ /[A-Z][a-z]|[a-z][A-Z]/);
4063                    if ($check) {
4064                        seed_camelcase_includes();
4065                        if (!$file && !$camelcase_file_seeded) {
4066                            seed_camelcase_file($realfile);
4067                            $camelcase_file_seeded = 1;
4068                        }
4069                    }
4070                    if (!defined $camelcase{$word}) {
4071                        $camelcase{$word} = 1;
4072                        CHK("CAMELCASE",
4073                            "Avoid CamelCase: <$word>\n" . $herecurr);
4074                    }
4075                }
4076            }
4077        }
4078
4079#no spaces allowed after \ in define
4080        if ($line =~ /\#\s*define.*\\\s+$/) {
4081            if (WARN("WHITESPACE_AFTER_LINE_CONTINUATION",
4082                 "Whitespace after \\ makes next lines useless\n" . $herecurr) &&
4083                $fix) {
4084                $fixed[$fixlinenr] =~ s/\s+$//;
4085            }
4086        }
4087
4088#warn if <asm/foo.h> is #included and <linux/foo.h> is available (uses RAW line)
4089        if ($tree && $rawline =~ m{^.\s*\#\s*include\s*\<asm\/(.*)\.h\>}) {
4090            my $file = "$1.h";
4091            my $checkfile = "include/linux/$file";
4092            if (-f "$root/$checkfile" &&
4093                $realfile ne $checkfile &&
4094                $1 !~ /$allowed_asm_includes/)
4095            {
4096                if ($realfile =~ m{^arch/}) {
4097                    CHK("ARCH_INCLUDE_LINUX",
4098                        "Consider using #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
4099                } else {
4100                    WARN("INCLUDE_LINUX",
4101                         "Use #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
4102                }
4103            }
4104        }
4105
4106# multi-statement macros should be enclosed in a do while loop, grab the
4107# first statement and ensure its the whole macro if its not enclosed
4108# in a known good container
4109        if ($realfile !~ m@/vmlinux.lds.h$@ &&
4110            $line =~ /^.\s*\#\s*define\s*$Ident(\()?/) {
4111            my $ln = $linenr;
4112            my $cnt = $realcnt;
4113            my ($off, $dstat, $dcond, $rest);
4114            my $ctx = '';
4115            my $has_flow_statement = 0;
4116            my $has_arg_concat = 0;
4117            ($dstat, $dcond, $ln, $cnt, $off) =
4118                ctx_statement_block($linenr, $realcnt, 0);
4119            $ctx = $dstat;
4120            #print "dstat<$dstat> dcond<$dcond> cnt<$cnt> off<$off>\n";
4121            #print "LINE<$lines[$ln-1]> len<" . length($lines[$ln-1]) . "\n";
4122
4123            $has_flow_statement = 1 if ($ctx =~ /\b(goto|return)\b/);
4124            $has_arg_concat = 1 if ($ctx =~ /\#\#/);
4125
4126            $dstat =~ s/^.\s*\#\s*define\s+$Ident(?:\([^\)]*\))?\s*//;
4127            $dstat =~ s/$;//g;
4128            $dstat =~ s/\\\n.//g;
4129            $dstat =~ s/^\s*//s;
4130            $dstat =~ s/\s*$//s;
4131
4132            # Flatten any parentheses and braces
4133            while ($dstat =~ s/\([^\(\)]*\)/1/ ||
4134                   $dstat =~ s/\{[^\{\}]*\}/1/ ||
4135                   $dstat =~ s/\[[^\[\]]*\]/1/)
4136            {
4137            }
4138
4139            # Flatten any obvious string concatentation.
4140            while ($dstat =~ s/("X*")\s*$Ident/$1/ ||
4141                   $dstat =~ s/$Ident\s*("X*")/$1/)
4142            {
4143            }
4144
4145            my $exceptions = qr{
4146                $Declare|
4147                module_param_named|
4148                MODULE_PARM_DESC|
4149                DECLARE_PER_CPU|
4150                DEFINE_PER_CPU|
4151                __typeof__\(|
4152                union|
4153                struct|
4154                \.$Ident\s*=\s*|
4155                ^\"|\"$
4156            }x;
4157            #print "REST<$rest> dstat<$dstat> ctx<$ctx>\n";
4158            if ($dstat ne '' &&
4159                $dstat !~ /^(?:$Ident|-?$Constant),$/ && # 10, // foo(),
4160                $dstat !~ /^(?:$Ident|-?$Constant);$/ && # foo();
4161                $dstat !~ /^[!~-]?(?:$Lval|$Constant)$/ && # 10 // foo() // !foo // ~foo // -foo // foo->bar // foo.bar->baz
4162                $dstat !~ /^'X'$/ && $dstat !~ /^'XX'$/ && # character constants
4163                $dstat !~ /$exceptions/ &&
4164                $dstat !~ /^\.$Ident\s*=/ && # .foo =
4165                $dstat !~ /^(?:\#\s*$Ident|\#\s*$Constant)\s*$/ && # stringification #foo
4166                $dstat !~ /^do\s*$Constant\s*while\s*$Constant;?$/ && # do {...} while (...); // do {...} while (...)
4167                $dstat !~ /^for\s*$Constant$/ && # for (...)
4168                $dstat !~ /^for\s*$Constant\s+(?:$Ident|-?$Constant)$/ && # for (...) bar()
4169                $dstat !~ /^do\s*{/ && # do {...
4170                $dstat !~ /^\({/ && # ({...
4171                $ctx !~ /^.\s*#\s*define\s+TRACE_(?:SYSTEM|INCLUDE_FILE|INCLUDE_PATH)\b/)
4172            {
4173                $ctx =~ s/\n*$//;
4174                my $herectx = $here . "\n";
4175                my $cnt = statement_rawlines($ctx);
4176
4177                for (my $n = 0; $n < $cnt; $n++) {
4178                    $herectx .= raw_line($linenr, $n) . "\n";
4179                }
4180
4181                if ($dstat =~ /;/) {
4182                    ERROR("MULTISTATEMENT_MACRO_USE_DO_WHILE",
4183                          "Macros with multiple statements should be enclosed in a do - while loop\n" . "$herectx");
4184                } else {
4185                    ERROR("COMPLEX_MACRO",
4186                          "Macros with complex values should be enclosed in parentheses\n" . "$herectx");
4187                }
4188            }
4189
4190# check for macros with flow control, but without ## concatenation
4191# ## concatenation is commonly a macro that defines a function so ignore those
4192            if ($has_flow_statement && !$has_arg_concat) {
4193                my $herectx = $here . "\n";
4194                my $cnt = statement_rawlines($ctx);
4195
4196                for (my $n = 0; $n < $cnt; $n++) {
4197                    $herectx .= raw_line($linenr, $n) . "\n";
4198                }
4199                WARN("MACRO_WITH_FLOW_CONTROL",
4200                     "Macros with flow control statements should be avoided\n" . "$herectx");
4201            }
4202
4203# check for line continuations outside of #defines, preprocessor #, and asm
4204
4205        } else {
4206            if ($prevline !~ /^..*\\$/ &&
4207                $line !~ /^\+\s*\#.*\\$/ && # preprocessor
4208                $line !~ /^\+.*\b(__asm__|asm)\b.*\\$/ && # asm
4209                $line =~ /^\+.*\\$/) {
4210                WARN("LINE_CONTINUATIONS",
4211                     "Avoid unnecessary line continuations\n" . $herecurr);
4212            }
4213        }
4214
4215# do {} while (0) macro tests:
4216# single-statement macros do not need to be enclosed in do while (0) loop,
4217# macro should not end with a semicolon
4218        if ($^V && $^V ge 5.10.0 &&
4219            $realfile !~ m@/vmlinux.lds.h$@ &&
4220            $line =~ /^.\s*\#\s*define\s+$Ident(\()?/) {
4221            my $ln = $linenr;
4222            my $cnt = $realcnt;
4223            my ($off, $dstat, $dcond, $rest);
4224            my $ctx = '';
4225            ($dstat, $dcond, $ln, $cnt, $off) =
4226                ctx_statement_block($linenr, $realcnt, 0);
4227            $ctx = $dstat;
4228
4229            $dstat =~ s/\\\n.//g;
4230
4231            if ($dstat =~ /^\+\s*#\s*define\s+$Ident\s*${balanced_parens}\s*do\s*{(.*)\s*}\s*while\s*\(\s*0\s*\)\s*([;\s]*)\s*$/) {
4232                my $stmts = $2;
4233                my $semis = $3;
4234
4235                $ctx =~ s/\n*$//;
4236                my $cnt = statement_rawlines($ctx);
4237                my $herectx = $here . "\n";
4238
4239                for (my $n = 0; $n < $cnt; $n++) {
4240                    $herectx .= raw_line($linenr, $n) . "\n";
4241                }
4242
4243                if (($stmts =~ tr/;/;/) == 1 &&
4244                    $stmts !~ /^\s*(if|while|for|switch)\b/) {
4245                    WARN("SINGLE_STATEMENT_DO_WHILE_MACRO",
4246                         "Single statement macros should not use a do {} while (0) loop\n" . "$herectx");
4247                }
4248                if (defined $semis && $semis ne "") {
4249                    WARN("DO_WHILE_MACRO_WITH_TRAILING_SEMICOLON",
4250                         "do {} while (0) macros should not be semicolon terminated\n" . "$herectx");
4251                }
4252            } elsif ($dstat =~ /^\+\s*#\s*define\s+$Ident.*;\s*$/) {
4253                $ctx =~ s/\n*$//;
4254                my $cnt = statement_rawlines($ctx);
4255                my $herectx = $here . "\n";
4256
4257                for (my $n = 0; $n < $cnt; $n++) {
4258                    $herectx .= raw_line($linenr, $n) . "\n";
4259                }
4260
4261                WARN("TRAILING_SEMICOLON",
4262                     "macros should not use a trailing semicolon\n" . "$herectx");
4263            }
4264        }
4265
4266# make sure symbols are always wrapped with VMLINUX_SYMBOL() ...
4267# all assignments may have only one of the following with an assignment:
4268# .
4269# ALIGN(...)
4270# VMLINUX_SYMBOL(...)
4271        if ($realfile eq 'vmlinux.lds.h' && $line =~ /(?:(?:^|\s)$Ident\s*=|=\s*$Ident(?:\s|$))/) {
4272            WARN("MISSING_VMLINUX_SYMBOL",
4273                 "vmlinux.lds.h needs VMLINUX_SYMBOL() around C-visible symbols\n" . $herecurr);
4274        }
4275
4276# check for redundant bracing round if etc
4277        if ($line =~ /(^.*)\bif\b/ && $1 !~ /else\s*$/) {
4278            my ($level, $endln, @chunks) =
4279                ctx_statement_full($linenr, $realcnt, 1);
4280            #print "chunks<$#chunks> linenr<$linenr> endln<$endln> level<$level>\n";
4281            #print "APW: <<$chunks[1][0]>><<$chunks[1][1]>>\n";
4282            if ($#chunks > 0 && $level == 0) {
4283                my @allowed = ();
4284                my $allow = 0;
4285                my $seen = 0;
4286                my $herectx = $here . "\n";
4287                my $ln = $linenr - 1;
4288                for my $chunk (@chunks) {
4289                    my ($cond, $block) = @{$chunk};
4290
4291                    # If the condition carries leading newlines, then count those as offsets.
4292                    my ($whitespace) = ($cond =~ /^((?:\s*\n[+-])*\s*)/s);
4293                    my $offset = statement_rawlines($whitespace) - 1;
4294
4295                    $allowed[$allow] = 0;
4296                    #print "COND<$cond> whitespace<$whitespace> offset<$offset>\n";
4297
4298                    # We have looked at and allowed this specific line.
4299                    $suppress_ifbraces{$ln + $offset} = 1;
4300
4301                    $herectx .= "$rawlines[$ln + $offset]\n[...]\n";
4302                    $ln += statement_rawlines($block) - 1;
4303
4304                    substr($block, 0, length($cond), '');
4305
4306                    $seen++ if ($block =~ /^\s*{/);
4307
4308                    #print "cond<$cond> block<$block> allowed<$allowed[$allow]>\n";
4309                    if (statement_lines($cond) > 1) {
4310                        #print "APW: ALLOWED: cond<$cond>\n";
4311                        $allowed[$allow] = 1;
4312                    }
4313                    if ($block =~/\b(?:if|for|while)\b/) {
4314                        #print "APW: ALLOWED: block<$block>\n";
4315                        $allowed[$allow] = 1;
4316                    }
4317                    if (statement_block_size($block) > 1) {
4318                        #print "APW: ALLOWED: lines block<$block>\n";
4319                        $allowed[$allow] = 1;
4320                    }
4321                    $allow++;
4322                }
4323                if ($seen) {
4324                    my $sum_allowed = 0;
4325                    foreach (@allowed) {
4326                        $sum_allowed += $_;
4327                    }
4328                    if ($sum_allowed == 0) {
4329                        WARN("BRACES",
4330                             "braces {} are not necessary for any arm of this statement\n" . $herectx);
4331                    } elsif ($sum_allowed != $allow &&
4332                         $seen != $allow) {
4333                        CHK("BRACES",
4334                            "braces {} should be used on all arms of this statement\n" . $herectx);
4335                    }
4336                }
4337            }
4338        }
4339        if (!defined $suppress_ifbraces{$linenr - 1} &&
4340                    $line =~ /\b(if|while|for|else)\b/) {
4341            my $allowed = 0;
4342
4343            # Check the pre-context.
4344            if (substr($line, 0, $-[0]) =~ /(\}\s*)$/) {
4345                #print "APW: ALLOWED: pre<$1>\n";
4346                $allowed = 1;
4347            }
4348
4349            my ($level, $endln, @chunks) =
4350                ctx_statement_full($linenr, $realcnt, $-[0]);
4351
4352            # Check the condition.
4353            my ($cond, $block) = @{$chunks[0]};
4354            #print "CHECKING<$linenr> cond<$cond> block<$block>\n";
4355            if (defined $cond) {
4356                substr($block, 0, length($cond), '');
4357            }
4358            if (statement_lines($cond) > 1) {
4359                #print "APW: ALLOWED: cond<$cond>\n";
4360                $allowed = 1;
4361            }
4362            if ($block =~/\b(?:if|for|while)\b/) {
4363                #print "APW: ALLOWED: block<$block>\n";
4364                $allowed = 1;
4365            }
4366            if (statement_block_size($block) > 1) {
4367                #print "APW: ALLOWED: lines block<$block>\n";
4368                $allowed = 1;
4369            }
4370            # Check the post-context.
4371            if (defined $chunks[1]) {
4372                my ($cond, $block) = @{$chunks[1]};
4373                if (defined $cond) {
4374                    substr($block, 0, length($cond), '');
4375                }
4376                if ($block =~ /^\s*\{/) {
4377                    #print "APW: ALLOWED: chunk-1 block<$block>\n";
4378                    $allowed = 1;
4379                }
4380            }
4381            if ($level == 0 && $block =~ /^\s*\{/ && !$allowed) {
4382                my $herectx = $here . "\n";
4383                my $cnt = statement_rawlines($block);
4384
4385                for (my $n = 0; $n < $cnt; $n++) {
4386                    $herectx .= raw_line($linenr, $n) . "\n";
4387                }
4388
4389                WARN("BRACES",
4390                     "braces {} are not necessary for single statement blocks\n" . $herectx);
4391            }
4392        }
4393
4394# check for unnecessary blank lines around braces
4395        if (($line =~ /^.\s*}\s*$/ && $prevrawline =~ /^.\s*$/)) {
4396            CHK("BRACES",
4397                "Blank lines aren't necessary before a close brace '}'\n" . $hereprev);
4398        }
4399        if (($rawline =~ /^.\s*$/ && $prevline =~ /^..*{\s*$/)) {
4400            CHK("BRACES",
4401                "Blank lines aren't necessary after an open brace '{'\n" . $hereprev);
4402        }
4403
4404# no volatiles please
4405        my $asm_volatile = qr{\b(__asm__|asm)\s+(__volatile__|volatile)\b};
4406        if ($line =~ /\bvolatile\b/ && $line !~ /$asm_volatile/) {
4407            WARN("VOLATILE",
4408                 "Use of volatile is usually wrong: see Documentation/volatile-considered-harmful.txt\n" . $herecurr);
4409        }
4410
4411# concatenated string without spaces between elements
4412        if ($line =~ /"X+"[A-Z_]+/ || $line =~ /[A-Z_]+"X+"/) {
4413            CHK("CONCATENATED_STRING",
4414                "Concatenated strings should use spaces between elements\n" . $herecurr);
4415        }
4416
4417# warn about #if 0
4418        if ($line =~ /^.\s*\#\s*if\s+0\b/) {
4419            CHK("REDUNDANT_CODE",
4420                "if this code is redundant consider removing it\n" .
4421                $herecurr);
4422        }
4423
4424# check for needless "if (<foo>) fn(<foo>)" uses
4425        if ($prevline =~ /\bif\s*\(\s*($Lval)\s*\)/) {
4426            my $expr = '\s*\(\s*' . quotemeta($1) . '\s*\)\s*;';
4427            if ($line =~ /\b(kfree|usb_free_urb|debugfs_remove(?:_recursive)?)$expr/) {
4428                WARN('NEEDLESS_IF',
4429                     "$1(NULL) is safe this check is probably not required\n" . $hereprev);
4430            }
4431        }
4432
4433# check for unnecessary "Out of Memory" messages
4434        if ($line =~ /^\+.*\b$logFunctions\s*\(/ &&
4435            $prevline =~ /^[ \+]\s*if\s*\(\s*(\!\s*|NULL\s*==\s*)?($Lval)(\s*==\s*NULL\s*)?\s*\)/ &&
4436            (defined $1 || defined $3) &&
4437            $linenr > 3) {
4438            my $testval = $2;
4439            my $testline = $lines[$linenr - 3];
4440
4441            my ($s, $c) = ctx_statement_block($linenr - 3, $realcnt, 0);
4442# print("line: <$line>\nprevline: <$prevline>\ns: <$s>\nc: <$c>\n\n\n");
4443
4444            if ($c =~ /(?:^|\n)[ \+]\s*(?:$Type\s*)?\Q$testval\E\s*=\s*(?:\([^\)]*\)\s*)?\s*(?:devm_)?(?:[kv][czm]alloc(?:_node|_array)?\b|kstrdup|(?:dev_)?alloc_skb)/) {
4445                WARN("OOM_MESSAGE",
4446                     "Possible unnecessary 'out of memory' message\n" . $hereprev);
4447            }
4448        }
4449
4450# check for logging functions with KERN_<LEVEL>
4451        if ($line !~ /printk\s*\(/ &&
4452            $line =~ /\b$logFunctions\s*\(.*\b(KERN_[A-Z]+)\b/) {
4453            my $level = $1;
4454            if (WARN("UNNECESSARY_KERN_LEVEL",
4455                 "Possible unnecessary $level\n" . $herecurr) &&
4456                $fix) {
4457                $fixed[$fixlinenr] =~ s/\s*$level\s*//;
4458            }
4459        }
4460
4461# check for bad placement of section $InitAttribute (e.g.: __initdata)
4462        if ($line =~ /(\b$InitAttribute\b)/) {
4463            my $attr = $1;
4464            if ($line =~ /^\+\s*static\s+(?:const\s+)?(?:$attr\s+)?($NonptrTypeWithAttr)\s+(?:$attr\s+)?($Ident(?:\[[^]]*\])?)\s*[=;]/) {
4465                my $ptr = $1;
4466                my $var = $2;
4467                if ((($ptr =~ /\b(union|struct)\s+$attr\b/ &&
4468                      ERROR("MISPLACED_INIT",
4469                        "$attr should be placed after $var\n" . $herecurr)) ||
4470                     ($ptr !~ /\b(union|struct)\s+$attr\b/ &&
4471                      WARN("MISPLACED_INIT",
4472                       "$attr should be placed after $var\n" . $herecurr))) &&
4473                    $fix) {
4474                    $fixed[$fixlinenr] =~ s/(\bstatic\s+(?:const\s+)?)(?:$attr\s+)?($NonptrTypeWithAttr)\s+(?:$attr\s+)?($Ident(?:\[[^]]*\])?)\s*([=;])\s*/"$1" . trim(string_find_replace($2, "\\s*$attr\\s*", " ")) . " " . trim(string_find_replace($3, "\\s*$attr\\s*", "")) . " $attr" . ("$4" eq ";" ? ";" : " = ")/e;
4475                }
4476            }
4477        }
4478
4479# check for $InitAttributeData (ie: __initdata) with const
4480        if ($line =~ /\bconst\b/ && $line =~ /($InitAttributeData)/) {
4481            my $attr = $1;
4482            $attr =~ /($InitAttributePrefix)(.*)/;
4483            my $attr_prefix = $1;
4484            my $attr_type = $2;
4485            if (ERROR("INIT_ATTRIBUTE",
4486                  "Use of const init definition must use ${attr_prefix}initconst\n" . $herecurr) &&
4487                $fix) {
4488                $fixed[$fixlinenr] =~
4489                    s/$InitAttributeData/${attr_prefix}initconst/;
4490            }
4491        }
4492
4493# check for $InitAttributeConst (ie: __initconst) without const
4494        if ($line !~ /\bconst\b/ && $line =~ /($InitAttributeConst)/) {
4495            my $attr = $1;
4496            if (ERROR("INIT_ATTRIBUTE",
4497                  "Use of $attr requires a separate use of const\n" . $herecurr) &&
4498                $fix) {
4499                my $lead = $fixed[$fixlinenr] =~
4500                    /(^\+\s*(?:static\s+))/;
4501                $lead = rtrim($1);
4502                $lead = "$lead " if ($lead !~ /^\+$/);
4503                $lead = "${lead}const ";
4504                $fixed[$fixlinenr] =~ s/(^\+\s*(?:static\s+))/$lead/;
4505            }
4506        }
4507
4508# don't use __constant_<foo> functions outside of include/uapi/
4509        if ($realfile !~ m@^include/uapi/@ &&
4510            $line =~ /(__constant_(?:htons|ntohs|[bl]e(?:16|32|64)_to_cpu|cpu_to_[bl]e(?:16|32|64)))\s*\(/) {
4511            my $constant_func = $1;
4512            my $func = $constant_func;
4513            $func =~ s/^__constant_//;
4514            if (WARN("CONSTANT_CONVERSION",
4515                 "$constant_func should be $func\n" . $herecurr) &&
4516                $fix) {
4517                $fixed[$fixlinenr] =~ s/\b$constant_func\b/$func/g;
4518            }
4519        }
4520
4521# prefer usleep_range over udelay
4522        if ($line =~ /\budelay\s*\(\s*(\d+)\s*\)/) {
4523            my $delay = $1;
4524            # ignore udelay's < 10, however
4525            if (! ($delay < 10) ) {
4526                CHK("USLEEP_RANGE",
4527                    "usleep_range is preferred over udelay; see Documentation/timers/timers-howto.txt\n" . $herecurr);
4528            }
4529            if ($delay > 2000) {
4530                WARN("LONG_UDELAY",
4531                     "long udelay - prefer mdelay; see arch/arm/include/asm/delay.h\n" . $herecurr);
4532            }
4533        }
4534
4535# warn about unexpectedly long msleep's
4536        if ($line =~ /\bmsleep\s*\((\d+)\);/) {
4537            if ($1 < 20) {
4538                WARN("MSLEEP",
4539                     "msleep < 20ms can sleep for up to 20ms; see Documentation/timers/timers-howto.txt\n" . $herecurr);
4540            }
4541        }
4542
4543# check for comparisons of jiffies
4544        if ($line =~ /\bjiffies\s*$Compare|$Compare\s*jiffies\b/) {
4545            WARN("JIFFIES_COMPARISON",
4546                 "Comparing jiffies is almost always wrong; prefer time_after, time_before and friends\n" . $herecurr);
4547        }
4548
4549# check for comparisons of get_jiffies_64()
4550        if ($line =~ /\bget_jiffies_64\s*\(\s*\)\s*$Compare|$Compare\s*get_jiffies_64\s*\(\s*\)/) {
4551            WARN("JIFFIES_COMPARISON",
4552                 "Comparing get_jiffies_64() is almost always wrong; prefer time_after64, time_before64 and friends\n" . $herecurr);
4553        }
4554
4555# warn about #ifdefs in C files
4556# if ($line =~ /^.\s*\#\s*if(|n)def/ && ($realfile =~ /\.c$/)) {
4557# print "#ifdef in C files should be avoided\n";
4558# print "$herecurr";
4559# $clean = 0;
4560# }
4561
4562# warn about spacing in #ifdefs
4563        if ($line =~ /^.\s*\#\s*(ifdef|ifndef|elif)\s\s+/) {
4564            if (ERROR("SPACING",
4565                  "exactly one space required after that #$1\n" . $herecurr) &&
4566                $fix) {
4567                $fixed[$fixlinenr] =~
4568                    s/^(.\s*\#\s*(ifdef|ifndef|elif))\s{2,}/$1 /;
4569            }
4570
4571        }
4572
4573# check for spinlock_t definitions without a comment.
4574        if ($line =~ /^.\s*(struct\s+mutex|spinlock_t)\s+\S+;/ ||
4575            $line =~ /^.\s*(DEFINE_MUTEX)\s*\(/) {
4576            my $which = $1;
4577            if (!ctx_has_comment($first_line, $linenr)) {
4578                CHK("UNCOMMENTED_DEFINITION",
4579                    "$1 definition without comment\n" . $herecurr);
4580            }
4581        }
4582# check for memory barriers without a comment.
4583        if ($line =~ /\b(mb|rmb|wmb|read_barrier_depends|smp_mb|smp_rmb|smp_wmb|smp_read_barrier_depends)\(/) {
4584            if (!ctx_has_comment($first_line, $linenr)) {
4585                WARN("MEMORY_BARRIER",
4586                     "memory barrier without comment\n" . $herecurr);
4587            }
4588        }
4589# check of hardware specific defines
4590        if ($line =~ m@^.\s*\#\s*if.*\b(__i386__|__powerpc64__|__sun__|__s390x__)\b@ && $realfile !~ m@include/asm-@) {
4591            CHK("ARCH_DEFINES",
4592                "architecture specific defines should be avoided\n" . $herecurr);
4593        }
4594
4595# Check that the storage class is at the beginning of a declaration
4596        if ($line =~ /\b$Storage\b/ && $line !~ /^.\s*$Storage\b/) {
4597            WARN("STORAGE_CLASS",
4598                 "storage class should be at the beginning of the declaration\n" . $herecurr)
4599        }
4600
4601# check the location of the inline attribute, that it is between
4602# storage class and type.
4603        if ($line =~ /\b$Type\s+$Inline\b/ ||
4604            $line =~ /\b$Inline\s+$Storage\b/) {
4605            ERROR("INLINE_LOCATION",
4606                  "inline keyword should sit between storage class and type\n" . $herecurr);
4607        }
4608
4609# Check for __inline__ and __inline, prefer inline
4610        if ($realfile !~ m@\binclude/uapi/@ &&
4611            $line =~ /\b(__inline__|__inline)\b/) {
4612            if (WARN("INLINE",
4613                 "plain inline is preferred over $1\n" . $herecurr) &&
4614                $fix) {
4615                $fixed[$fixlinenr] =~ s/\b(__inline__|__inline)\b/inline/;
4616
4617            }
4618        }
4619
4620# Check for __attribute__ packed, prefer __packed
4621        if ($realfile !~ m@\binclude/uapi/@ &&
4622            $line =~ /\b__attribute__\s*\(\s*\(.*\bpacked\b/) {
4623            WARN("PREFER_PACKED",
4624                 "__packed is preferred over __attribute__((packed))\n" . $herecurr);
4625        }
4626
4627# Check for __attribute__ aligned, prefer __aligned
4628        if ($realfile !~ m@\binclude/uapi/@ &&
4629            $line =~ /\b__attribute__\s*\(\s*\(.*aligned/) {
4630            WARN("PREFER_ALIGNED",
4631                 "__aligned(size) is preferred over __attribute__((aligned(size)))\n" . $herecurr);
4632        }
4633
4634# Check for __attribute__ format(printf, prefer __printf
4635        if ($realfile !~ m@\binclude/uapi/@ &&
4636            $line =~ /\b__attribute__\s*\(\s*\(\s*format\s*\(\s*printf/) {
4637            if (WARN("PREFER_PRINTF",
4638                 "__printf(string-index, first-to-check) is preferred over __attribute__((format(printf, string-index, first-to-check)))\n" . $herecurr) &&
4639                $fix) {
4640                $fixed[$fixlinenr] =~ s/\b__attribute__\s*\(\s*\(\s*format\s*\(\s*printf\s*,\s*(.*)\)\s*\)\s*\)/"__printf(" . trim($1) . ")"/ex;
4641
4642            }
4643        }
4644
4645# Check for __attribute__ format(scanf, prefer __scanf
4646        if ($realfile !~ m@\binclude/uapi/@ &&
4647            $line =~ /\b__attribute__\s*\(\s*\(\s*format\s*\(\s*scanf\b/) {
4648            if (WARN("PREFER_SCANF",
4649                 "__scanf(string-index, first-to-check) is preferred over __attribute__((format(scanf, string-index, first-to-check)))\n" . $herecurr) &&
4650                $fix) {
4651                $fixed[$fixlinenr] =~ s/\b__attribute__\s*\(\s*\(\s*format\s*\(\s*scanf\s*,\s*(.*)\)\s*\)\s*\)/"__scanf(" . trim($1) . ")"/ex;
4652            }
4653        }
4654
4655# check for sizeof(&)
4656        if ($line =~ /\bsizeof\s*\(\s*\&/) {
4657            WARN("SIZEOF_ADDRESS",
4658                 "sizeof(& should be avoided\n" . $herecurr);
4659        }
4660
4661# check for sizeof without parenthesis
4662        if ($line =~ /\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/) {
4663            if (WARN("SIZEOF_PARENTHESIS",
4664                 "sizeof $1 should be sizeof($1)\n" . $herecurr) &&
4665                $fix) {
4666                $fixed[$fixlinenr] =~ s/\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/"sizeof(" . trim($1) . ")"/ex;
4667            }
4668        }
4669
4670# check for line continuations in quoted strings with odd counts of "
4671        if ($rawline =~ /\\$/ && $rawline =~ tr/"/"/ % 2) {
4672            WARN("LINE_CONTINUATIONS",
4673                 "Avoid line continuations in quoted strings\n" . $herecurr);
4674        }
4675
4676# check for struct spinlock declarations
4677        if ($line =~ /^.\s*\bstruct\s+spinlock\s+\w+\s*;/) {
4678            WARN("USE_SPINLOCK_T",
4679                 "struct spinlock should be spinlock_t\n" . $herecurr);
4680        }
4681
4682# check for seq_printf uses that could be seq_puts
4683        if ($sline =~ /\bseq_printf\s*\(.*"\s*\)\s*;\s*$/) {
4684            my $fmt = get_quoted_string($line, $rawline);
4685            if ($fmt ne "" && $fmt !~ /[^\\]\%/) {
4686                if (WARN("PREFER_SEQ_PUTS",
4687                     "Prefer seq_puts to seq_printf\n" . $herecurr) &&
4688                    $fix) {
4689                    $fixed[$fixlinenr] =~ s/\bseq_printf\b/seq_puts/;
4690                }
4691            }
4692        }
4693
4694# Check for misused memsets
4695        if ($^V && $^V ge 5.10.0 &&
4696            defined $stat &&
4697            $stat =~ /^\+(?:.*?)\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*$FuncArg\s*\)/s) {
4698
4699            my $ms_addr = $2;
4700            my $ms_val = $7;
4701            my $ms_size = $12;
4702
4703            if ($ms_size =~ /^(0x|)0$/i) {
4704                ERROR("MEMSET",
4705                      "memset to 0's uses 0 as the 2nd argument, not the 3rd\n" . "$here\n$stat\n");
4706            } elsif ($ms_size =~ /^(0x|)1$/i) {
4707                WARN("MEMSET",
4708                     "single byte memset is suspicious. Swapped 2nd/3rd argument?\n" . "$here\n$stat\n");
4709            }
4710        }
4711
4712# Check for memcpy(foo, bar, ETH_ALEN) that could be ether_addr_copy(foo, bar)
4713        if ($^V && $^V ge 5.10.0 &&
4714            $line =~ /^\+(?:.*?)\bmemcpy\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/s) {
4715            if (WARN("PREFER_ETHER_ADDR_COPY",
4716                 "Prefer ether_addr_copy() over memcpy() if the Ethernet addresses are __aligned(2)\n" . $herecurr) &&
4717                $fix) {
4718                $fixed[$fixlinenr] =~ s/\bmemcpy\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/ether_addr_copy($2, $7)/;
4719            }
4720        }
4721
4722# typecasts on min/max could be min_t/max_t
4723        if ($^V && $^V ge 5.10.0 &&
4724            defined $stat &&
4725            $stat =~ /^\+(?:.*?)\b(min|max)\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\)/) {
4726            if (defined $2 || defined $7) {
4727                my $call = $1;
4728                my $cast1 = deparenthesize($2);
4729                my $arg1 = $3;
4730                my $cast2 = deparenthesize($7);
4731                my $arg2 = $8;
4732                my $cast;
4733
4734                if ($cast1 ne "" && $cast2 ne "" && $cast1 ne $cast2) {
4735                    $cast = "$cast1 or $cast2";
4736                } elsif ($cast1 ne "") {
4737                    $cast = $cast1;
4738                } else {
4739                    $cast = $cast2;
4740                }
4741                WARN("MINMAX",
4742                     "$call() should probably be ${call}_t($cast, $arg1, $arg2)\n" . "$here\n$stat\n");
4743            }
4744        }
4745
4746# check usleep_range arguments
4747        if ($^V && $^V ge 5.10.0 &&
4748            defined $stat &&
4749            $stat =~ /^\+(?:.*?)\busleep_range\s*\(\s*($FuncArg)\s*,\s*($FuncArg)\s*\)/) {
4750            my $min = $1;
4751            my $max = $7;
4752            if ($min eq $max) {
4753                WARN("USLEEP_RANGE",
4754                     "usleep_range should not use min == max args; see Documentation/timers/timers-howto.txt\n" . "$here\n$stat\n");
4755            } elsif ($min =~ /^\d+$/ && $max =~ /^\d+$/ &&
4756                 $min > $max) {
4757                WARN("USLEEP_RANGE",
4758                     "usleep_range args reversed, use min then max; see Documentation/timers/timers-howto.txt\n" . "$here\n$stat\n");
4759            }
4760        }
4761
4762# check for naked sscanf
4763        if ($^V && $^V ge 5.10.0 &&
4764            defined $stat &&
4765            $line =~ /\bsscanf\b/ &&
4766            ($stat !~ /$Ident\s*=\s*sscanf\s*$balanced_parens/ &&
4767             $stat !~ /\bsscanf\s*$balanced_parens\s*(?:$Compare)/ &&
4768             $stat !~ /(?:$Compare)\s*\bsscanf\s*$balanced_parens/)) {
4769            my $lc = $stat =~ tr@\n@@;
4770            $lc = $lc + $linenr;
4771            my $stat_real = raw_line($linenr, 0);
4772                for (my $count = $linenr + 1; $count <= $lc; $count++) {
4773                $stat_real = $stat_real . "\n" . raw_line($count, 0);
4774            }
4775            WARN("NAKED_SSCANF",
4776                 "unchecked sscanf return value\n" . "$here\n$stat_real\n");
4777        }
4778
4779# check for simple sscanf that should be kstrto<foo>
4780        if ($^V && $^V ge 5.10.0 &&
4781            defined $stat &&
4782            $line =~ /\bsscanf\b/) {
4783            my $lc = $stat =~ tr@\n@@;
4784            $lc = $lc + $linenr;
4785            my $stat_real = raw_line($linenr, 0);
4786                for (my $count = $linenr + 1; $count <= $lc; $count++) {
4787                $stat_real = $stat_real . "\n" . raw_line($count, 0);
4788            }
4789            if ($stat_real =~ /\bsscanf\b\s*\(\s*$FuncArg\s*,\s*("[^"]+")/) {
4790                my $format = $6;
4791                my $count = $format =~ tr@%@%@;
4792                if ($count == 1 &&
4793                    $format =~ /^"\%(?i:ll[udxi]|[udxi]ll|ll|[hl]h?[udxi]|[udxi][hl]h?|[hl]h?|[udxi])"$/) {
4794                    WARN("SSCANF_TO_KSTRTO",
4795                         "Prefer kstrto<type> to single variable sscanf\n" . "$here\n$stat_real\n");
4796                }
4797            }
4798        }
4799
4800# check for new externs in .h files.
4801        if ($realfile =~ /\.h$/ &&
4802            $line =~ /^\+\s*(extern\s+)$Type\s*$Ident\s*\(/s) {
4803            if (CHK("AVOID_EXTERNS",
4804                "extern prototypes should be avoided in .h files\n" . $herecurr) &&
4805                $fix) {
4806                $fixed[$fixlinenr] =~ s/(.*)\bextern\b\s*(.*)/$1$2/;
4807            }
4808        }
4809
4810# check for new externs in .c files.
4811        if ($realfile =~ /\.c$/ && defined $stat &&
4812            $stat =~ /^.\s*(?:extern\s+)?$Type\s+($Ident)(\s*)\(/s)
4813        {
4814            my $function_name = $1;
4815            my $paren_space = $2;
4816
4817            my $s = $stat;
4818            if (defined $cond) {
4819                substr($s, 0, length($cond), '');
4820            }
4821            if ($s =~ /^\s*;/ &&
4822                $function_name ne 'uninitialized_var')
4823            {
4824                WARN("AVOID_EXTERNS",
4825                     "externs should be avoided in .c files\n" . $herecurr);
4826            }
4827
4828            if ($paren_space =~ /\n/) {
4829                WARN("FUNCTION_ARGUMENTS",
4830                     "arguments for function declarations should follow identifier\n" . $herecurr);
4831            }
4832
4833        } elsif ($realfile =~ /\.c$/ && defined $stat &&
4834            $stat =~ /^.\s*extern\s+/)
4835        {
4836            WARN("AVOID_EXTERNS",
4837                 "externs should be avoided in .c files\n" . $herecurr);
4838        }
4839
4840# checks for new __setup's
4841        if ($rawline =~ /\b__setup\("([^"]*)"/) {
4842            my $name = $1;
4843
4844            if (!grep(/$name/, @setup_docs)) {
4845                CHK("UNDOCUMENTED_SETUP",
4846                    "__setup appears un-documented -- check Documentation/kernel-parameters.txt\n" . $herecurr);
4847            }
4848        }
4849
4850# check for pointless casting of kmalloc return
4851        if ($line =~ /\*\s*\)\s*[kv][czm]alloc(_node){0,1}\b/) {
4852            WARN("UNNECESSARY_CASTS",
4853                 "unnecessary cast may hide bugs, see http://c-faq.com/malloc/mallocnocast.html\n" . $herecurr);
4854        }
4855
4856# alloc style
4857# p = alloc(sizeof(struct foo), ...) should be p = alloc(sizeof(*p), ...)
4858        if ($^V && $^V ge 5.10.0 &&
4859            $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*([kv][mz]alloc(?:_node)?)\s*\(\s*(sizeof\s*\(\s*struct\s+$Lval\s*\))/) {
4860            CHK("ALLOC_SIZEOF_STRUCT",
4861                "Prefer $3(sizeof(*$1)...) over $3($4...)\n" . $herecurr);
4862        }
4863
4864# check for k[mz]alloc with multiplies that could be kmalloc_array/kcalloc
4865        if ($^V && $^V ge 5.10.0 &&
4866            $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*(k[mz]alloc)\s*\(\s*($FuncArg)\s*\*\s*($FuncArg)\s*,/) {
4867            my $oldfunc = $3;
4868            my $a1 = $4;
4869            my $a2 = $10;
4870            my $newfunc = "kmalloc_array";
4871            $newfunc = "kcalloc" if ($oldfunc eq "kzalloc");
4872            my $r1 = $a1;
4873            my $r2 = $a2;
4874            if ($a1 =~ /^sizeof\s*\S/) {
4875                $r1 = $a2;
4876                $r2 = $a1;
4877            }
4878            if ($r1 !~ /^sizeof\b/ && $r2 =~ /^sizeof\s*\S/ &&
4879                !($r1 =~ /^$Constant$/ || $r1 =~ /^[A-Z_][A-Z0-9_]*$/)) {
4880                if (WARN("ALLOC_WITH_MULTIPLY",
4881                     "Prefer $newfunc over $oldfunc with multiply\n" . $herecurr) &&
4882                    $fix) {
4883                    $fixed[$fixlinenr] =~ s/\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*(k[mz]alloc)\s*\(\s*($FuncArg)\s*\*\s*($FuncArg)/$1 . ' = ' . "$newfunc(" . trim($r1) . ', ' . trim($r2)/e;
4884
4885                }
4886            }
4887        }
4888
4889# check for krealloc arg reuse
4890        if ($^V && $^V ge 5.10.0 &&
4891            $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*krealloc\s*\(\s*\1\s*,/) {
4892            WARN("KREALLOC_ARG_REUSE",
4893                 "Reusing the krealloc arg is almost always a bug\n" . $herecurr);
4894        }
4895
4896# check for alloc argument mismatch
4897        if ($line =~ /\b(kcalloc|kmalloc_array)\s*\(\s*sizeof\b/) {
4898            WARN("ALLOC_ARRAY_ARGS",
4899                 "$1 uses number as first arg, sizeof is generally wrong\n" . $herecurr);
4900        }
4901
4902# check for multiple semicolons
4903        if ($line =~ /;\s*;\s*$/) {
4904            if (WARN("ONE_SEMICOLON",
4905                 "Statements terminations use 1 semicolon\n" . $herecurr) &&
4906                $fix) {
4907                $fixed[$fixlinenr] =~ s/(\s*;\s*){2,}$/;/g;
4908            }
4909        }
4910
4911# check for case / default statements not preceded by break/fallthrough/switch
4912        if ($line =~ /^.\s*(?:case\s+(?:$Ident|$Constant)\s*|default):/) {
4913            my $has_break = 0;
4914            my $has_statement = 0;
4915            my $count = 0;
4916            my $prevline = $linenr;
4917            while ($prevline > 1 && ($file || $count < 3) && !$has_break) {
4918                $prevline--;
4919                my $rline = $rawlines[$prevline - 1];
4920                my $fline = $lines[$prevline - 1];
4921                last if ($fline =~ /^\@\@/);
4922                next if ($fline =~ /^\-/);
4923                next if ($fline =~ /^.(?:\s*(?:case\s+(?:$Ident|$Constant)[\s$;]*|default):[\s$;]*)*$/);
4924                $has_break = 1 if ($rline =~ /fall[\s_-]*(through|thru)/i);
4925                next if ($fline =~ /^.[\s$;]*$/);
4926                $has_statement = 1;
4927                $count++;
4928                $has_break = 1 if ($fline =~ /\bswitch\b|\b(?:break\s*;[\s$;]*$|return\b|goto\b|continue\b)/);
4929            }
4930            if (!$has_break && $has_statement) {
4931                WARN("MISSING_BREAK",
4932                     "Possible switch case/default not preceeded by break or fallthrough comment\n" . $herecurr);
4933            }
4934        }
4935
4936# check for switch/default statements without a break;
4937        if ($^V && $^V ge 5.10.0 &&
4938            defined $stat &&
4939            $stat =~ /^\+[$;\s]*(?:case[$;\s]+\w+[$;\s]*:[$;\s]*|)*[$;\s]*\bdefault[$;\s]*:[$;\s]*;/g) {
4940            my $ctx = '';
4941            my $herectx = $here . "\n";
4942            my $cnt = statement_rawlines($stat);
4943            for (my $n = 0; $n < $cnt; $n++) {
4944                $herectx .= raw_line($linenr, $n) . "\n";
4945            }
4946            WARN("DEFAULT_NO_BREAK",
4947                 "switch default: should use break\n" . $herectx);
4948        }
4949
4950# check for gcc specific __FUNCTION__
4951        if ($line =~ /\b__FUNCTION__\b/) {
4952            if (WARN("USE_FUNC",
4953                 "__func__ should be used instead of gcc specific __FUNCTION__\n" . $herecurr) &&
4954                $fix) {
4955                $fixed[$fixlinenr] =~ s/\b__FUNCTION__\b/__func__/g;
4956            }
4957        }
4958
4959# check for use of yield()
4960        if ($line =~ /\byield\s*\(\s*\)/) {
4961            WARN("YIELD",
4962                 "Using yield() is generally wrong. See yield() kernel-doc (sched/core.c)\n" . $herecurr);
4963        }
4964
4965# check for comparisons against true and false
4966        if ($line =~ /\+\s*(.*?)\b(true|false|$Lval)\s*(==|\!=)\s*(true|false|$Lval)\b(.*)$/i) {
4967            my $lead = $1;
4968            my $arg = $2;
4969            my $test = $3;
4970            my $otype = $4;
4971            my $trail = $5;
4972            my $op = "!";
4973
4974            ($arg, $otype) = ($otype, $arg) if ($arg =~ /^(?:true|false)$/i);
4975
4976            my $type = lc($otype);
4977            if ($type =~ /^(?:true|false)$/) {
4978                if (("$test" eq "==" && "$type" eq "true") ||
4979                    ("$test" eq "!=" && "$type" eq "false")) {
4980                    $op = "";
4981                }
4982
4983                CHK("BOOL_COMPARISON",
4984                    "Using comparison to $otype is error prone\n" . $herecurr);
4985
4986## maybe suggesting a correct construct would better
4987## "Using comparison to $otype is error prone. Perhaps use '${lead}${op}${arg}${trail}'\n" . $herecurr);
4988
4989            }
4990        }
4991
4992# check for semaphores initialized locked
4993        if ($line =~ /^.\s*sema_init.+,\W?0\W?\)/) {
4994            WARN("CONSIDER_COMPLETION",
4995                 "consider using a completion\n" . $herecurr);
4996        }
4997
4998# recommend kstrto* over simple_strto* and strict_strto*
4999        if ($line =~ /\b((simple|strict)_(strto(l|ll|ul|ull)))\s*\(/) {
5000            WARN("CONSIDER_KSTRTO",
5001                 "$1 is obsolete, use k$3 instead\n" . $herecurr);
5002        }
5003
5004# check for __initcall(), use device_initcall() explicitly or more appropriate function please
5005        if ($line =~ /^.\s*__initcall\s*\(/) {
5006            WARN("USE_DEVICE_INITCALL",
5007                 "please use device_initcall() or more appropriate function instead of __initcall() (see include/linux/init.h)\n" . $herecurr);
5008        }
5009
5010# check for various ops structs, ensure they are const.
5011        my $struct_ops = qr{acpi_dock_ops|
5012                address_space_operations|
5013                backlight_ops|
5014                block_device_operations|
5015                dentry_operations|
5016                dev_pm_ops|
5017                dma_map_ops|
5018                extent_io_ops|
5019                file_lock_operations|
5020                file_operations|
5021                hv_ops|
5022                ide_dma_ops|
5023                intel_dvo_dev_ops|
5024                item_operations|
5025                iwl_ops|
5026                kgdb_arch|
5027                kgdb_io|
5028                kset_uevent_ops|
5029                lock_manager_operations|
5030                microcode_ops|
5031                mtrr_ops|
5032                neigh_ops|
5033                nlmsvc_binding|
5034                pci_raw_ops|
5035                pipe_buf_operations|
5036                platform_hibernation_ops|
5037                platform_suspend_ops|
5038                proto_ops|
5039                rpc_pipe_ops|
5040                seq_operations|
5041                snd_ac97_build_ops|
5042                soc_pcmcia_socket_ops|
5043                stacktrace_ops|
5044                sysfs_ops|
5045                tty_operations|
5046                usb_mon_operations|
5047                wd_ops}x;
5048        if ($line !~ /\bconst\b/ &&
5049            $line =~ /\bstruct\s+($struct_ops)\b/) {
5050            WARN("CONST_STRUCT",
5051                 "struct $1 should normally be const\n" .
5052                $herecurr);
5053        }
5054
5055# use of NR_CPUS is usually wrong
5056# ignore definitions of NR_CPUS and usage to define arrays as likely right
5057        if ($line =~ /\bNR_CPUS\b/ &&
5058           &