Andy Whitcroft | 0a920b5 | 2007-06-01 00:46:48 -0700 | [diff] [blame] | 1 | #!/usr/bin/perl -w |
Dave Jones | dbf004d | 2010-01-12 16:59:52 -0500 | [diff] [blame] | 2 | # (c) 2001, Dave Jones. (the file handling bit) |
Andy Whitcroft | 00df344 | 2007-06-08 13:47:06 -0700 | [diff] [blame] | 3 | # (c) 2005, Joel Schopp <jschopp@austin.ibm.com> (the ugly bit) |
Andy Whitcroft | 2a5a2c2 | 2009-01-06 14:41:23 -0800 | [diff] [blame] | 4 | # (c) 2007,2008, Andy Whitcroft <apw@uk.ibm.com> (new conditions, test suite) |
Andy Whitcroft | 015830b | 2010-10-26 14:23:17 -0700 | [diff] [blame] | 5 | # (c) 2008-2010 Andy Whitcroft <apw@canonical.com> |
Andy Whitcroft | 0a920b5 | 2007-06-01 00:46:48 -0700 | [diff] [blame] | 6 | # Licensed under the terms of the GNU GPL License version 2 |
| 7 | |
| 8 | use strict; |
Joe Perches | c707a81 | 2013-07-08 16:00:43 -0700 | [diff] [blame] | 9 | use POSIX; |
Joe Perches | 36061e3 | 2014-12-10 15:51:43 -0800 | [diff] [blame] | 10 | use File::Basename; |
| 11 | use Cwd 'abs_path'; |
Joe Perches | 5723029 | 2015-06-25 15:03:03 -0700 | [diff] [blame] | 12 | use Term::ANSIColor qw(:constants); |
Andy Whitcroft | 0a920b5 | 2007-06-01 00:46:48 -0700 | [diff] [blame] | 13 | |
| 14 | my $P = $0; |
Joe Perches | 36061e3 | 2014-12-10 15:51:43 -0800 | [diff] [blame] | 15 | my $D = dirname(abs_path($P)); |
Andy Whitcroft | 0a920b5 | 2007-06-01 00:46:48 -0700 | [diff] [blame] | 16 | |
Joe Perches | 000d1cc1 | 2011-07-25 17:13:25 -0700 | [diff] [blame] | 17 | my $V = '0.32'; |
Andy Whitcroft | 0a920b5 | 2007-06-01 00:46:48 -0700 | [diff] [blame] | 18 | |
| 19 | use Getopt::Long qw(:config no_auto_abbrev); |
| 20 | |
| 21 | my $quiet = 0; |
| 22 | my $tree = 1; |
| 23 | my $chk_signoff = 1; |
| 24 | my $chk_patch = 1; |
Andy Whitcroft | 773647a | 2008-03-28 14:15:58 -0700 | [diff] [blame] | 25 | my $tst_only; |
Andy Whitcroft | 6c72ffa | 2007-10-18 03:05:08 -0700 | [diff] [blame] | 26 | my $emacs = 0; |
Andy Whitcroft | 8905a67 | 2007-11-28 16:21:06 -0800 | [diff] [blame] | 27 | my $terse = 0; |
Joe Perches | 34d8815 | 2015-06-25 15:03:05 -0700 | [diff] [blame] | 28 | my $showfile = 0; |
Andy Whitcroft | 6c72ffa | 2007-10-18 03:05:08 -0700 | [diff] [blame] | 29 | my $file = 0; |
| 30 | my $check = 0; |
Joe Perches | 2ac73b4 | 2014-06-04 16:12:05 -0700 | [diff] [blame] | 31 | my $check_orig = 0; |
Andy Whitcroft | 8905a67 | 2007-11-28 16:21:06 -0800 | [diff] [blame] | 32 | my $summary = 1; |
| 33 | my $mailback = 0; |
Andy Whitcroft | 13214ad | 2008-02-08 04:22:03 -0800 | [diff] [blame] | 34 | my $summary_file = 0; |
Joe Perches | 000d1cc1 | 2011-07-25 17:13:25 -0700 | [diff] [blame] | 35 | my $show_types = 0; |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 36 | my $fix = 0; |
Joe Perches | 9624b8d | 2014-01-23 15:54:44 -0800 | [diff] [blame] | 37 | my $fix_inplace = 0; |
Andy Whitcroft | 6c72ffa | 2007-10-18 03:05:08 -0700 | [diff] [blame] | 38 | my $root; |
Andy Whitcroft | c2fdda0 | 2008-02-08 04:20:54 -0800 | [diff] [blame] | 39 | my %debug; |
Joe Perches | 3445686 | 2013-07-03 15:05:34 -0700 | [diff] [blame] | 40 | my %camelcase = (); |
Joe Perches | 91bfe48 | 2013-09-11 14:23:59 -0700 | [diff] [blame] | 41 | my %use_type = (); |
| 42 | my @use = (); |
| 43 | my %ignore_type = (); |
Joe Perches | 000d1cc1 | 2011-07-25 17:13:25 -0700 | [diff] [blame] | 44 | my @ignore = (); |
Hannes Eder | 77f5b10 | 2009-09-21 17:04:37 -0700 | [diff] [blame] | 45 | my $help = 0; |
Joe Perches | 000d1cc1 | 2011-07-25 17:13:25 -0700 | [diff] [blame] | 46 | my $configuration_file = ".checkpatch.conf"; |
Joe Perches | 6cd7f38 | 2012-12-17 16:01:54 -0800 | [diff] [blame] | 47 | my $max_line_length = 80; |
Dave Hansen | d62a201 | 2013-09-11 14:23:56 -0700 | [diff] [blame] | 48 | my $ignore_perl_version = 0; |
| 49 | my $minimum_perl_version = 5.10.0; |
Vadim Bendebury | 5619327 | 2014-10-13 15:51:48 -0700 | [diff] [blame] | 50 | my $min_conf_desc_length = 4; |
Kees Cook | 66b47b4 | 2014-10-13 15:51:57 -0700 | [diff] [blame] | 51 | my $spelling_file = "$D/spelling.txt"; |
Joe Perches | ebfd7d6 | 2015-04-16 12:44:14 -0700 | [diff] [blame] | 52 | my $codespell = 0; |
Maxim Uvarov | f1a6367 | 2015-06-25 15:03:08 -0700 | [diff] [blame] | 53 | my $codespellfile = "/usr/share/codespell/dictionary.txt"; |
Joe Perches | 5723029 | 2015-06-25 15:03:03 -0700 | [diff] [blame] | 54 | my $color = 1; |
Hannes Eder | 77f5b10 | 2009-09-21 17:04:37 -0700 | [diff] [blame] | 55 | |
| 56 | sub help { |
| 57 | my ($exitcode) = @_; |
| 58 | |
| 59 | print << "EOM"; |
| 60 | Usage: $P [OPTION]... [FILE]... |
| 61 | Version: $V |
| 62 | |
| 63 | Options: |
| 64 | -q, --quiet quiet |
| 65 | --no-tree run without a kernel tree |
| 66 | --no-signoff do not check for 'Signed-off-by' line |
| 67 | --patch treat FILE as patchfile (default) |
| 68 | --emacs emacs compile window format |
| 69 | --terse one line per report |
Joe Perches | 34d8815 | 2015-06-25 15:03:05 -0700 | [diff] [blame] | 70 | --showfile emit diffed file position, not input file position |
Hannes Eder | 77f5b10 | 2009-09-21 17:04:37 -0700 | [diff] [blame] | 71 | -f, --file treat FILE as regular source file |
| 72 | --subjective, --strict enable more subjective tests |
Joe Perches | 91bfe48 | 2013-09-11 14:23:59 -0700 | [diff] [blame] | 73 | --types TYPE(,TYPE2...) show only these comma separated message types |
Joe Perches | 000d1cc1 | 2011-07-25 17:13:25 -0700 | [diff] [blame] | 74 | --ignore TYPE(,TYPE2...) ignore various comma separated message types |
Joe Perches | 6cd7f38 | 2012-12-17 16:01:54 -0800 | [diff] [blame] | 75 | --max-line-length=n set the maximum line length, if exceeded, warn |
Vadim Bendebury | 5619327 | 2014-10-13 15:51:48 -0700 | [diff] [blame] | 76 | --min-conf-desc-length=n set the min description length, if shorter, warn |
Joe Perches | 000d1cc1 | 2011-07-25 17:13:25 -0700 | [diff] [blame] | 77 | --show-types show the message "types" in the output |
Hannes Eder | 77f5b10 | 2009-09-21 17:04:37 -0700 | [diff] [blame] | 78 | --root=PATH PATH to the kernel tree root |
| 79 | --no-summary suppress the per-file summary |
| 80 | --mailback only produce a report in case of warnings/errors |
| 81 | --summary-file include the filename in summary |
| 82 | --debug KEY=[0|1] turn on/off debugging of KEY, where KEY is one of |
| 83 | 'values', 'possible', 'type', and 'attr' (default |
| 84 | is all off) |
| 85 | --test-only=WORD report only warnings/errors containing WORD |
| 86 | literally |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 87 | --fix EXPERIMENTAL - may create horrible results |
| 88 | If correctable single-line errors exist, create |
| 89 | "<inputfile>.EXPERIMENTAL-checkpatch-fixes" |
| 90 | with potential errors corrected to the preferred |
| 91 | checkpatch style |
Joe Perches | 9624b8d | 2014-01-23 15:54:44 -0800 | [diff] [blame] | 92 | --fix-inplace EXPERIMENTAL - may create horrible results |
| 93 | Is the same as --fix, but overwrites the input |
| 94 | file. It's your fault if there's no backup or git |
Dave Hansen | d62a201 | 2013-09-11 14:23:56 -0700 | [diff] [blame] | 95 | --ignore-perl-version override checking of perl version. expect |
| 96 | runtime errors. |
Joe Perches | ebfd7d6 | 2015-04-16 12:44:14 -0700 | [diff] [blame] | 97 | --codespell Use the codespell dictionary for spelling/typos |
Maxim Uvarov | f1a6367 | 2015-06-25 15:03:08 -0700 | [diff] [blame] | 98 | (default:/usr/share/codespell/dictionary.txt) |
Joe Perches | ebfd7d6 | 2015-04-16 12:44:14 -0700 | [diff] [blame] | 99 | --codespellfile Use this codespell dictionary |
Joe Perches | 5723029 | 2015-06-25 15:03:03 -0700 | [diff] [blame] | 100 | --color Use colors when output is STDOUT (default: on) |
Hannes Eder | 77f5b10 | 2009-09-21 17:04:37 -0700 | [diff] [blame] | 101 | -h, --help, --version display this help and exit |
| 102 | |
| 103 | When FILE is - read standard input. |
| 104 | EOM |
| 105 | |
| 106 | exit($exitcode); |
| 107 | } |
| 108 | |
Joe Perches | 000d1cc1 | 2011-07-25 17:13:25 -0700 | [diff] [blame] | 109 | my $conf = which_conf($configuration_file); |
| 110 | if (-f $conf) { |
| 111 | my @conf_args; |
| 112 | open(my $conffile, '<', "$conf") |
| 113 | or warn "$P: Can't find a readable $configuration_file file $!\n"; |
| 114 | |
| 115 | while (<$conffile>) { |
| 116 | my $line = $_; |
| 117 | |
| 118 | $line =~ s/\s*\n?$//g; |
| 119 | $line =~ s/^\s*//g; |
| 120 | $line =~ s/\s+/ /g; |
| 121 | |
| 122 | next if ($line =~ m/^\s*#/); |
| 123 | next if ($line =~ m/^\s*$/); |
| 124 | |
| 125 | my @words = split(" ", $line); |
| 126 | foreach my $word (@words) { |
| 127 | last if ($word =~ m/^#/); |
| 128 | push (@conf_args, $word); |
| 129 | } |
| 130 | } |
| 131 | close($conffile); |
| 132 | unshift(@ARGV, @conf_args) if @conf_args; |
| 133 | } |
| 134 | |
Andy Whitcroft | 0a920b5 | 2007-06-01 00:46:48 -0700 | [diff] [blame] | 135 | GetOptions( |
Andy Whitcroft | 6c72ffa | 2007-10-18 03:05:08 -0700 | [diff] [blame] | 136 | 'q|quiet+' => \$quiet, |
Andy Whitcroft | 0a920b5 | 2007-06-01 00:46:48 -0700 | [diff] [blame] | 137 | 'tree!' => \$tree, |
| 138 | 'signoff!' => \$chk_signoff, |
| 139 | 'patch!' => \$chk_patch, |
Andy Whitcroft | 6c72ffa | 2007-10-18 03:05:08 -0700 | [diff] [blame] | 140 | 'emacs!' => \$emacs, |
Andy Whitcroft | 8905a67 | 2007-11-28 16:21:06 -0800 | [diff] [blame] | 141 | 'terse!' => \$terse, |
Joe Perches | 34d8815 | 2015-06-25 15:03:05 -0700 | [diff] [blame] | 142 | 'showfile!' => \$showfile, |
Hannes Eder | 77f5b10 | 2009-09-21 17:04:37 -0700 | [diff] [blame] | 143 | 'f|file!' => \$file, |
Andy Whitcroft | 6c72ffa | 2007-10-18 03:05:08 -0700 | [diff] [blame] | 144 | 'subjective!' => \$check, |
| 145 | 'strict!' => \$check, |
Joe Perches | 000d1cc1 | 2011-07-25 17:13:25 -0700 | [diff] [blame] | 146 | 'ignore=s' => \@ignore, |
Joe Perches | 91bfe48 | 2013-09-11 14:23:59 -0700 | [diff] [blame] | 147 | 'types=s' => \@use, |
Joe Perches | 000d1cc1 | 2011-07-25 17:13:25 -0700 | [diff] [blame] | 148 | 'show-types!' => \$show_types, |
Joe Perches | 6cd7f38 | 2012-12-17 16:01:54 -0800 | [diff] [blame] | 149 | 'max-line-length=i' => \$max_line_length, |
Vadim Bendebury | 5619327 | 2014-10-13 15:51:48 -0700 | [diff] [blame] | 150 | 'min-conf-desc-length=i' => \$min_conf_desc_length, |
Andy Whitcroft | 6c72ffa | 2007-10-18 03:05:08 -0700 | [diff] [blame] | 151 | 'root=s' => \$root, |
Andy Whitcroft | 8905a67 | 2007-11-28 16:21:06 -0800 | [diff] [blame] | 152 | 'summary!' => \$summary, |
| 153 | 'mailback!' => \$mailback, |
Andy Whitcroft | 13214ad | 2008-02-08 04:22:03 -0800 | [diff] [blame] | 154 | 'summary-file!' => \$summary_file, |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 155 | 'fix!' => \$fix, |
Joe Perches | 9624b8d | 2014-01-23 15:54:44 -0800 | [diff] [blame] | 156 | 'fix-inplace!' => \$fix_inplace, |
Dave Hansen | d62a201 | 2013-09-11 14:23:56 -0700 | [diff] [blame] | 157 | 'ignore-perl-version!' => \$ignore_perl_version, |
Andy Whitcroft | c2fdda0 | 2008-02-08 04:20:54 -0800 | [diff] [blame] | 158 | 'debug=s' => \%debug, |
Andy Whitcroft | 773647a | 2008-03-28 14:15:58 -0700 | [diff] [blame] | 159 | 'test-only=s' => \$tst_only, |
Joe Perches | ebfd7d6 | 2015-04-16 12:44:14 -0700 | [diff] [blame] | 160 | 'codespell!' => \$codespell, |
| 161 | 'codespellfile=s' => \$codespellfile, |
Joe Perches | 5723029 | 2015-06-25 15:03:03 -0700 | [diff] [blame] | 162 | 'color!' => \$color, |
Hannes Eder | 77f5b10 | 2009-09-21 17:04:37 -0700 | [diff] [blame] | 163 | 'h|help' => \$help, |
| 164 | 'version' => \$help |
| 165 | ) or help(1); |
| 166 | |
| 167 | help(0) if ($help); |
Andy Whitcroft | 0a920b5 | 2007-06-01 00:46:48 -0700 | [diff] [blame] | 168 | |
Joe Perches | 9624b8d | 2014-01-23 15:54:44 -0800 | [diff] [blame] | 169 | $fix = 1 if ($fix_inplace); |
Joe Perches | 2ac73b4 | 2014-06-04 16:12:05 -0700 | [diff] [blame] | 170 | $check_orig = $check; |
Joe Perches | 9624b8d | 2014-01-23 15:54:44 -0800 | [diff] [blame] | 171 | |
Andy Whitcroft | 0a920b5 | 2007-06-01 00:46:48 -0700 | [diff] [blame] | 172 | my $exit = 0; |
| 173 | |
Dave Hansen | d62a201 | 2013-09-11 14:23:56 -0700 | [diff] [blame] | 174 | if ($^V && $^V lt $minimum_perl_version) { |
| 175 | printf "$P: requires at least perl version %vd\n", $minimum_perl_version; |
| 176 | if (!$ignore_perl_version) { |
| 177 | exit(1); |
| 178 | } |
| 179 | } |
| 180 | |
Andy Whitcroft | 0a920b5 | 2007-06-01 00:46:48 -0700 | [diff] [blame] | 181 | if ($#ARGV < 0) { |
Hannes Eder | 77f5b10 | 2009-09-21 17:04:37 -0700 | [diff] [blame] | 182 | print "$P: no input files\n"; |
Andy Whitcroft | 0a920b5 | 2007-06-01 00:46:48 -0700 | [diff] [blame] | 183 | exit(1); |
| 184 | } |
| 185 | |
Joe Perches | 91bfe48 | 2013-09-11 14:23:59 -0700 | [diff] [blame] | 186 | sub hash_save_array_words { |
| 187 | my ($hashRef, $arrayRef) = @_; |
Joe Perches | 000d1cc1 | 2011-07-25 17:13:25 -0700 | [diff] [blame] | 188 | |
Joe Perches | 91bfe48 | 2013-09-11 14:23:59 -0700 | [diff] [blame] | 189 | my @array = split(/,/, join(',', @$arrayRef)); |
| 190 | foreach my $word (@array) { |
| 191 | $word =~ s/\s*\n?$//g; |
| 192 | $word =~ s/^\s*//g; |
| 193 | $word =~ s/\s+/ /g; |
| 194 | $word =~ tr/[a-z]/[A-Z]/; |
Joe Perches | 000d1cc1 | 2011-07-25 17:13:25 -0700 | [diff] [blame] | 195 | |
Joe Perches | 91bfe48 | 2013-09-11 14:23:59 -0700 | [diff] [blame] | 196 | next if ($word =~ m/^\s*#/); |
| 197 | next if ($word =~ m/^\s*$/); |
| 198 | |
| 199 | $hashRef->{$word}++; |
| 200 | } |
Joe Perches | 000d1cc1 | 2011-07-25 17:13:25 -0700 | [diff] [blame] | 201 | } |
| 202 | |
Joe Perches | 91bfe48 | 2013-09-11 14:23:59 -0700 | [diff] [blame] | 203 | sub hash_show_words { |
| 204 | my ($hashRef, $prefix) = @_; |
| 205 | |
Joe Perches | 3c816e4 | 2015-06-25 15:03:29 -0700 | [diff] [blame] | 206 | if (keys %$hashRef) { |
Joe Perches | d8469f1 | 2015-06-25 15:03:00 -0700 | [diff] [blame] | 207 | print "\nNOTE: $prefix message types:"; |
Joe Perches | 58cb3cf | 2013-09-11 14:24:04 -0700 | [diff] [blame] | 208 | foreach my $word (sort keys %$hashRef) { |
Joe Perches | 91bfe48 | 2013-09-11 14:23:59 -0700 | [diff] [blame] | 209 | print " $word"; |
| 210 | } |
Joe Perches | d8469f1 | 2015-06-25 15:03:00 -0700 | [diff] [blame] | 211 | print "\n"; |
Joe Perches | 91bfe48 | 2013-09-11 14:23:59 -0700 | [diff] [blame] | 212 | } |
| 213 | } |
| 214 | |
| 215 | hash_save_array_words(\%ignore_type, \@ignore); |
| 216 | hash_save_array_words(\%use_type, \@use); |
| 217 | |
Andy Whitcroft | c2fdda0 | 2008-02-08 04:20:54 -0800 | [diff] [blame] | 218 | my $dbg_values = 0; |
| 219 | my $dbg_possible = 0; |
Andy Whitcroft | 7429c69 | 2008-07-23 21:29:06 -0700 | [diff] [blame] | 220 | my $dbg_type = 0; |
Andy Whitcroft | a1ef277 | 2008-10-15 22:02:17 -0700 | [diff] [blame] | 221 | my $dbg_attr = 0; |
Andy Whitcroft | c2fdda0 | 2008-02-08 04:20:54 -0800 | [diff] [blame] | 222 | for my $key (keys %debug) { |
Andy Whitcroft | 21caa13 | 2009-01-06 14:41:30 -0800 | [diff] [blame] | 223 | ## no critic |
| 224 | eval "\${dbg_$key} = '$debug{$key}';"; |
| 225 | die "$@" if ($@); |
Andy Whitcroft | c2fdda0 | 2008-02-08 04:20:54 -0800 | [diff] [blame] | 226 | } |
| 227 | |
Andy Whitcroft | d2c0a23 | 2010-10-26 14:23:12 -0700 | [diff] [blame] | 228 | my $rpt_cleaners = 0; |
| 229 | |
Andy Whitcroft | 8905a67 | 2007-11-28 16:21:06 -0800 | [diff] [blame] | 230 | if ($terse) { |
| 231 | $emacs = 1; |
| 232 | $quiet++; |
| 233 | } |
| 234 | |
Andy Whitcroft | 6c72ffa | 2007-10-18 03:05:08 -0700 | [diff] [blame] | 235 | if ($tree) { |
| 236 | if (defined $root) { |
| 237 | if (!top_of_kernel_tree($root)) { |
| 238 | die "$P: $root: --root does not point at a valid tree\n"; |
| 239 | } |
| 240 | } else { |
| 241 | if (top_of_kernel_tree('.')) { |
| 242 | $root = '.'; |
| 243 | } elsif ($0 =~ m@(.*)/scripts/[^/]*$@ && |
| 244 | top_of_kernel_tree($1)) { |
| 245 | $root = $1; |
| 246 | } |
| 247 | } |
| 248 | |
| 249 | if (!defined $root) { |
| 250 | print "Must be run from the top-level dir. of a kernel tree\n"; |
| 251 | exit(2); |
| 252 | } |
Andy Whitcroft | 0a920b5 | 2007-06-01 00:46:48 -0700 | [diff] [blame] | 253 | } |
| 254 | |
Andy Whitcroft | 6c72ffa | 2007-10-18 03:05:08 -0700 | [diff] [blame] | 255 | my $emitted_corrupt = 0; |
| 256 | |
Andy Whitcroft | 2ceb532 | 2009-10-26 16:50:14 -0700 | [diff] [blame] | 257 | our $Ident = qr{ |
| 258 | [A-Za-z_][A-Za-z\d_]* |
| 259 | (?:\s*\#\#\s*[A-Za-z_][A-Za-z\d_]*)* |
| 260 | }x; |
Andy Whitcroft | 6c72ffa | 2007-10-18 03:05:08 -0700 | [diff] [blame] | 261 | our $Storage = qr{extern|static|asmlinkage}; |
| 262 | our $Sparse = qr{ |
| 263 | __user| |
| 264 | __kernel| |
| 265 | __force| |
| 266 | __iomem| |
Joe Perches | 54507b5 | 2015-09-09 15:37:55 -0700 | [diff] [blame] | 267 | __pmem| |
Andy Whitcroft | 6c72ffa | 2007-10-18 03:05:08 -0700 | [diff] [blame] | 268 | __must_check| |
| 269 | __init_refok| |
Andy Whitcroft | 417495e | 2009-02-27 14:03:08 -0800 | [diff] [blame] | 270 | __kprobes| |
Sven Eckelmann | 165e72a | 2011-07-25 17:13:23 -0700 | [diff] [blame] | 271 | __ref| |
| 272 | __rcu |
Andy Whitcroft | 6c72ffa | 2007-10-18 03:05:08 -0700 | [diff] [blame] | 273 | }x; |
Joe Perches | e970b884 | 2013-11-12 15:10:10 -0800 | [diff] [blame] | 274 | our $InitAttributePrefix = qr{__(?:mem|cpu|dev|net_|)}; |
| 275 | our $InitAttributeData = qr{$InitAttributePrefix(?:initdata\b)}; |
| 276 | our $InitAttributeConst = qr{$InitAttributePrefix(?:initconst\b)}; |
| 277 | our $InitAttributeInit = qr{$InitAttributePrefix(?:init\b)}; |
| 278 | our $InitAttribute = qr{$InitAttributeData|$InitAttributeConst|$InitAttributeInit}; |
Joe Perches | 8716de3 | 2013-09-11 14:24:05 -0700 | [diff] [blame] | 279 | |
Wolfram Sang | 5213129 | 2010-03-05 13:43:51 -0800 | [diff] [blame] | 280 | # Notes to $Attribute: |
| 281 | # We need \b after 'init' otherwise 'initconst' will cause a false positive in a check |
Andy Whitcroft | 6c72ffa | 2007-10-18 03:05:08 -0700 | [diff] [blame] | 282 | our $Attribute = qr{ |
| 283 | const| |
Joe Perches | 03f1df7 | 2010-10-26 14:23:16 -0700 | [diff] [blame] | 284 | __percpu| |
| 285 | __nocast| |
| 286 | __safe| |
| 287 | __bitwise__| |
| 288 | __packed__| |
| 289 | __packed2__| |
| 290 | __naked| |
| 291 | __maybe_unused| |
| 292 | __always_unused| |
| 293 | __noreturn| |
| 294 | __used| |
| 295 | __cold| |
Joe Perches | e23ef1f | 2015-02-13 14:38:24 -0800 | [diff] [blame] | 296 | __pure| |
Joe Perches | 03f1df7 | 2010-10-26 14:23:16 -0700 | [diff] [blame] | 297 | __noclone| |
| 298 | __deprecated| |
Andy Whitcroft | 6c72ffa | 2007-10-18 03:05:08 -0700 | [diff] [blame] | 299 | __read_mostly| |
| 300 | __kprobes| |
Joe Perches | 8716de3 | 2013-09-11 14:24:05 -0700 | [diff] [blame] | 301 | $InitAttribute| |
Andy Whitcroft | 24e1d81 | 2008-10-15 22:02:18 -0700 | [diff] [blame] | 302 | ____cacheline_aligned| |
| 303 | ____cacheline_aligned_in_smp| |
Andy Whitcroft | 5fe3af1 | 2009-01-06 14:41:18 -0800 | [diff] [blame] | 304 | ____cacheline_internodealigned_in_smp| |
| 305 | __weak |
Andy Whitcroft | 6c72ffa | 2007-10-18 03:05:08 -0700 | [diff] [blame] | 306 | }x; |
Andy Whitcroft | c45dcab | 2008-06-05 22:46:01 -0700 | [diff] [blame] | 307 | our $Modifier; |
Joe Perches | 91cb519 | 2014-04-03 14:49:32 -0700 | [diff] [blame] | 308 | our $Inline = qr{inline|__always_inline|noinline|__inline|__inline__}; |
Andy Whitcroft | 6c72ffa | 2007-10-18 03:05:08 -0700 | [diff] [blame] | 309 | our $Member = qr{->$Ident|\.$Ident|\[[^]]*\]}; |
| 310 | our $Lval = qr{$Ident(?:$Member)*}; |
| 311 | |
Joe Perches | 95e2c60 | 2013-07-03 15:05:20 -0700 | [diff] [blame] | 312 | our $Int_type = qr{(?i)llu|ull|ll|lu|ul|l|u}; |
| 313 | our $Binary = qr{(?i)0b[01]+$Int_type?}; |
| 314 | our $Hex = qr{(?i)0x[0-9a-f]+$Int_type?}; |
| 315 | our $Int = qr{[0-9]+$Int_type?}; |
Joe Perches | 2435880 | 2014-04-03 14:49:13 -0700 | [diff] [blame] | 316 | our $Octal = qr{0[0-7]+$Int_type?}; |
Joe Perches | c0a5c89 | 2015-02-13 14:38:21 -0800 | [diff] [blame] | 317 | our $String = qr{"[X\t]*"}; |
Joe Perches | 326b1ff | 2013-02-04 14:28:51 -0800 | [diff] [blame] | 318 | our $Float_hex = qr{(?i)0x[0-9a-f]+p-?[0-9]+[fl]?}; |
| 319 | our $Float_dec = qr{(?i)(?:[0-9]+\.[0-9]*|[0-9]*\.[0-9]+)(?:e-?[0-9]+)?[fl]?}; |
| 320 | our $Float_int = qr{(?i)[0-9]+e-?[0-9]+[fl]?}; |
Joe Perches | 74349bc | 2012-12-17 16:02:05 -0800 | [diff] [blame] | 321 | our $Float = qr{$Float_hex|$Float_dec|$Float_int}; |
Joe Perches | 2435880 | 2014-04-03 14:49:13 -0700 | [diff] [blame] | 322 | our $Constant = qr{$Float|$Binary|$Octal|$Hex|$Int}; |
Joe Perches | 326b1ff | 2013-02-04 14:28:51 -0800 | [diff] [blame] | 323 | our $Assignment = qr{\*\=|/=|%=|\+=|-=|<<=|>>=|&=|\^=|\|=|=}; |
Joe Perches | 447432f | 2014-04-03 14:49:17 -0700 | [diff] [blame] | 324 | our $Compare = qr{<=|>=|==|!=|<|(?<!-)>}; |
Joe Perches | 23f780c | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 325 | our $Arithmetic = qr{\+|-|\*|\/|%}; |
Andy Whitcroft | 6c72ffa | 2007-10-18 03:05:08 -0700 | [diff] [blame] | 326 | our $Operators = qr{ |
| 327 | <=|>=|==|!=| |
| 328 | =>|->|<<|>>|<|>|!|~| |
Joe Perches | 23f780c | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 329 | &&|\|\||,|\^|\+\+|--|&|\||$Arithmetic |
Andy Whitcroft | 6c72ffa | 2007-10-18 03:05:08 -0700 | [diff] [blame] | 330 | }x; |
| 331 | |
Joe Perches | 91cb519 | 2014-04-03 14:49:32 -0700 | [diff] [blame] | 332 | our $c90_Keywords = qr{do|for|while|if|else|return|goto|continue|switch|default|case|break}x; |
| 333 | |
Joe Perches | ab7e23f | 2015-04-16 12:44:22 -0700 | [diff] [blame] | 334 | our $BasicType; |
Andy Whitcroft | 8905a67 | 2007-11-28 16:21:06 -0800 | [diff] [blame] | 335 | our $NonptrType; |
Joe Perches | 1813087 | 2014-08-06 16:11:22 -0700 | [diff] [blame] | 336 | our $NonptrTypeMisordered; |
Joe Perches | 8716de3 | 2013-09-11 14:24:05 -0700 | [diff] [blame] | 337 | our $NonptrTypeWithAttr; |
Andy Whitcroft | 8905a67 | 2007-11-28 16:21:06 -0800 | [diff] [blame] | 338 | our $Type; |
Joe Perches | 1813087 | 2014-08-06 16:11:22 -0700 | [diff] [blame] | 339 | our $TypeMisordered; |
Andy Whitcroft | 8905a67 | 2007-11-28 16:21:06 -0800 | [diff] [blame] | 340 | our $Declare; |
Joe Perches | 1813087 | 2014-08-06 16:11:22 -0700 | [diff] [blame] | 341 | our $DeclareMisordered; |
Andy Whitcroft | 8905a67 | 2007-11-28 16:21:06 -0800 | [diff] [blame] | 342 | |
Joe Perches | 15662b3 | 2011-10-31 17:13:12 -0700 | [diff] [blame] | 343 | our $NON_ASCII_UTF8 = qr{ |
| 344 | [\xC2-\xDF][\x80-\xBF] # non-overlong 2-byte |
Andy Whitcroft | 171ae1a | 2008-04-29 00:59:32 -0700 | [diff] [blame] | 345 | | \xE0[\xA0-\xBF][\x80-\xBF] # excluding overlongs |
| 346 | | [\xE1-\xEC\xEE\xEF][\x80-\xBF]{2} # straight 3-byte |
| 347 | | \xED[\x80-\x9F][\x80-\xBF] # excluding surrogates |
| 348 | | \xF0[\x90-\xBF][\x80-\xBF]{2} # planes 1-3 |
| 349 | | [\xF1-\xF3][\x80-\xBF]{3} # planes 4-15 |
| 350 | | \xF4[\x80-\x8F][\x80-\xBF]{2} # plane 16 |
| 351 | }x; |
| 352 | |
Joe Perches | 15662b3 | 2011-10-31 17:13:12 -0700 | [diff] [blame] | 353 | our $UTF8 = qr{ |
| 354 | [\x09\x0A\x0D\x20-\x7E] # ASCII |
| 355 | | $NON_ASCII_UTF8 |
| 356 | }x; |
| 357 | |
Joe Perches | e6176fa | 2015-06-25 15:02:49 -0700 | [diff] [blame] | 358 | our $typeC99Typedefs = qr{(?:__)?(?:[us]_?)?int_?(?:8|16|32|64)_t}; |
Joe Perches | 021158b | 2015-02-13 14:38:43 -0800 | [diff] [blame] | 359 | our $typeOtherOSTypedefs = qr{(?x: |
| 360 | u_(?:char|short|int|long) | # bsd |
| 361 | u(?:nchar|short|int|long) # sysv |
| 362 | )}; |
Joe Perches | e6176fa | 2015-06-25 15:02:49 -0700 | [diff] [blame] | 363 | our $typeKernelTypedefs = qr{(?x: |
Andy Whitcroft | fb9e909 | 2009-09-21 17:04:38 -0700 | [diff] [blame] | 364 | (?:__)?(?:u|s|be|le)(?:8|16|32|64)| |
Andy Whitcroft | 8ed22ca | 2008-10-15 22:02:32 -0700 | [diff] [blame] | 365 | atomic_t |
| 366 | )}; |
Joe Perches | e6176fa | 2015-06-25 15:02:49 -0700 | [diff] [blame] | 367 | our $typeTypedefs = qr{(?x: |
| 368 | $typeC99Typedefs\b| |
| 369 | $typeOtherOSTypedefs\b| |
| 370 | $typeKernelTypedefs\b |
| 371 | )}; |
Andy Whitcroft | 8ed22ca | 2008-10-15 22:02:32 -0700 | [diff] [blame] | 372 | |
Joe Perches | 6d32f7a | 2015-11-06 16:31:37 -0800 | [diff] [blame] | 373 | our $zero_initializer = qr{(?:(?:0[xX])?0+$Int_type?|NULL|false)\b}; |
| 374 | |
Joe Perches | 691e669 | 2010-03-05 13:43:51 -0800 | [diff] [blame] | 375 | our $logFunctions = qr{(?x: |
Joe Perches | 6e60c02 | 2011-07-25 17:13:27 -0700 | [diff] [blame] | 376 | printk(?:_ratelimited|_once|)| |
Jacob Keller | 7d0b659 | 2013-07-03 15:05:35 -0700 | [diff] [blame] | 377 | (?:[a-z0-9]+_){1,2}(?:printk|emerg|alert|crit|err|warning|warn|notice|info|debug|dbg|vdbg|devel|cont|WARN)(?:_ratelimited|_once|)| |
Joe Perches | 6e60c02 | 2011-07-25 17:13:27 -0700 | [diff] [blame] | 378 | WARN(?:_RATELIMIT|_ONCE|)| |
Joe Perches | b053172 | 2011-05-24 17:13:40 -0700 | [diff] [blame] | 379 | panic| |
Joe Perches | 0666872 | 2013-11-12 15:10:07 -0800 | [diff] [blame] | 380 | MODULE_[A-Z_]+| |
| 381 | seq_vprintf|seq_printf|seq_puts |
Joe Perches | 691e669 | 2010-03-05 13:43:51 -0800 | [diff] [blame] | 382 | )}; |
| 383 | |
Joe Perches | 2011247 | 2011-07-25 17:13:23 -0700 | [diff] [blame] | 384 | our $signature_tags = qr{(?xi: |
| 385 | Signed-off-by:| |
| 386 | Acked-by:| |
| 387 | Tested-by:| |
| 388 | Reviewed-by:| |
| 389 | Reported-by:| |
Mugunthan V N | 8543ae1 | 2013-04-29 16:18:17 -0700 | [diff] [blame] | 390 | Suggested-by:| |
Joe Perches | 2011247 | 2011-07-25 17:13:23 -0700 | [diff] [blame] | 391 | To:| |
| 392 | Cc: |
| 393 | )}; |
| 394 | |
Joe Perches | 1813087 | 2014-08-06 16:11:22 -0700 | [diff] [blame] | 395 | our @typeListMisordered = ( |
| 396 | qr{char\s+(?:un)?signed}, |
| 397 | qr{int\s+(?:(?:un)?signed\s+)?short\s}, |
| 398 | qr{int\s+short(?:\s+(?:un)?signed)}, |
| 399 | qr{short\s+int(?:\s+(?:un)?signed)}, |
| 400 | qr{(?:un)?signed\s+int\s+short}, |
| 401 | qr{short\s+(?:un)?signed}, |
| 402 | qr{long\s+int\s+(?:un)?signed}, |
| 403 | qr{int\s+long\s+(?:un)?signed}, |
| 404 | qr{long\s+(?:un)?signed\s+int}, |
| 405 | qr{int\s+(?:un)?signed\s+long}, |
| 406 | qr{int\s+(?:un)?signed}, |
| 407 | qr{int\s+long\s+long\s+(?:un)?signed}, |
| 408 | qr{long\s+long\s+int\s+(?:un)?signed}, |
| 409 | qr{long\s+long\s+(?:un)?signed\s+int}, |
| 410 | qr{long\s+long\s+(?:un)?signed}, |
| 411 | qr{long\s+(?:un)?signed}, |
| 412 | ); |
| 413 | |
Andy Whitcroft | 8905a67 | 2007-11-28 16:21:06 -0800 | [diff] [blame] | 414 | our @typeList = ( |
| 415 | qr{void}, |
Joe Perches | 0c773d9 | 2014-08-06 16:11:20 -0700 | [diff] [blame] | 416 | qr{(?:(?:un)?signed\s+)?char}, |
| 417 | qr{(?:(?:un)?signed\s+)?short\s+int}, |
| 418 | qr{(?:(?:un)?signed\s+)?short}, |
| 419 | qr{(?:(?:un)?signed\s+)?int}, |
| 420 | qr{(?:(?:un)?signed\s+)?long\s+int}, |
| 421 | qr{(?:(?:un)?signed\s+)?long\s+long\s+int}, |
| 422 | qr{(?:(?:un)?signed\s+)?long\s+long}, |
| 423 | qr{(?:(?:un)?signed\s+)?long}, |
| 424 | qr{(?:un)?signed}, |
Andy Whitcroft | 8905a67 | 2007-11-28 16:21:06 -0800 | [diff] [blame] | 425 | qr{float}, |
| 426 | qr{double}, |
| 427 | qr{bool}, |
Andy Whitcroft | 8905a67 | 2007-11-28 16:21:06 -0800 | [diff] [blame] | 428 | qr{struct\s+$Ident}, |
| 429 | qr{union\s+$Ident}, |
| 430 | qr{enum\s+$Ident}, |
| 431 | qr{${Ident}_t}, |
| 432 | qr{${Ident}_handler}, |
| 433 | qr{${Ident}_handler_fn}, |
Joe Perches | 1813087 | 2014-08-06 16:11:22 -0700 | [diff] [blame] | 434 | @typeListMisordered, |
Andy Whitcroft | 8905a67 | 2007-11-28 16:21:06 -0800 | [diff] [blame] | 435 | ); |
Joe Perches | 938224b | 2016-01-20 14:59:15 -0800 | [diff] [blame] | 436 | |
| 437 | our $C90_int_types = qr{(?x: |
| 438 | long\s+long\s+int\s+(?:un)?signed| |
| 439 | long\s+long\s+(?:un)?signed\s+int| |
| 440 | long\s+long\s+(?:un)?signed| |
| 441 | (?:(?:un)?signed\s+)?long\s+long\s+int| |
| 442 | (?:(?:un)?signed\s+)?long\s+long| |
| 443 | int\s+long\s+long\s+(?:un)?signed| |
| 444 | int\s+(?:(?:un)?signed\s+)?long\s+long| |
| 445 | |
| 446 | long\s+int\s+(?:un)?signed| |
| 447 | long\s+(?:un)?signed\s+int| |
| 448 | long\s+(?:un)?signed| |
| 449 | (?:(?:un)?signed\s+)?long\s+int| |
| 450 | (?:(?:un)?signed\s+)?long| |
| 451 | int\s+long\s+(?:un)?signed| |
| 452 | int\s+(?:(?:un)?signed\s+)?long| |
| 453 | |
| 454 | int\s+(?:un)?signed| |
| 455 | (?:(?:un)?signed\s+)?int |
| 456 | )}; |
| 457 | |
Alex Dowad | 485ff23 | 2015-06-25 15:02:52 -0700 | [diff] [blame] | 458 | our @typeListFile = (); |
Joe Perches | 8716de3 | 2013-09-11 14:24:05 -0700 | [diff] [blame] | 459 | our @typeListWithAttr = ( |
| 460 | @typeList, |
| 461 | qr{struct\s+$InitAttribute\s+$Ident}, |
| 462 | qr{union\s+$InitAttribute\s+$Ident}, |
| 463 | ); |
| 464 | |
Andy Whitcroft | c45dcab | 2008-06-05 22:46:01 -0700 | [diff] [blame] | 465 | our @modifierList = ( |
| 466 | qr{fastcall}, |
| 467 | ); |
Alex Dowad | 485ff23 | 2015-06-25 15:02:52 -0700 | [diff] [blame] | 468 | our @modifierListFile = (); |
Andy Whitcroft | 8905a67 | 2007-11-28 16:21:06 -0800 | [diff] [blame] | 469 | |
Joe Perches | 2435880 | 2014-04-03 14:49:13 -0700 | [diff] [blame] | 470 | our @mode_permission_funcs = ( |
| 471 | ["module_param", 3], |
| 472 | ["module_param_(?:array|named|string)", 4], |
| 473 | ["module_param_array_named", 5], |
| 474 | ["debugfs_create_(?:file|u8|u16|u32|u64|x8|x16|x32|x64|size_t|atomic_t|bool|blob|regset32|u32_array)", 2], |
| 475 | ["proc_create(?:_data|)", 2], |
| 476 | ["(?:CLASS|DEVICE|SENSOR)_ATTR", 2], |
| 477 | ); |
| 478 | |
Joe Perches | 515a235 | 2014-04-03 14:49:24 -0700 | [diff] [blame] | 479 | #Create a search pattern for all these functions to speed up a loop below |
| 480 | our $mode_perms_search = ""; |
| 481 | foreach my $entry (@mode_permission_funcs) { |
| 482 | $mode_perms_search .= '|' if ($mode_perms_search ne ""); |
| 483 | $mode_perms_search .= $entry->[0]; |
| 484 | } |
| 485 | |
Joe Perches | b392c64 | 2015-04-16 12:44:16 -0700 | [diff] [blame] | 486 | our $mode_perms_world_writable = qr{ |
| 487 | S_IWUGO | |
| 488 | S_IWOTH | |
| 489 | S_IRWXUGO | |
| 490 | S_IALLUGO | |
| 491 | 0[0-7][0-7][2367] |
| 492 | }x; |
| 493 | |
Wolfram Sang | 7840a94 | 2010-08-09 17:20:57 -0700 | [diff] [blame] | 494 | our $allowed_asm_includes = qr{(?x: |
| 495 | irq| |
Sergey Ryazanov | cdcee68 | 2014-10-13 15:51:44 -0700 | [diff] [blame] | 496 | memory| |
| 497 | time| |
| 498 | reboot |
Wolfram Sang | 7840a94 | 2010-08-09 17:20:57 -0700 | [diff] [blame] | 499 | )}; |
| 500 | # memory.h: ARM has a custom one |
| 501 | |
Kees Cook | 66b47b4 | 2014-10-13 15:51:57 -0700 | [diff] [blame] | 502 | # Load common spelling mistakes and build regular expression list. |
| 503 | my $misspellings; |
Kees Cook | 66b47b4 | 2014-10-13 15:51:57 -0700 | [diff] [blame] | 504 | my %spelling_fix; |
Kees Cook | 66b47b4 | 2014-10-13 15:51:57 -0700 | [diff] [blame] | 505 | |
Joe Perches | 36061e3 | 2014-12-10 15:51:43 -0800 | [diff] [blame] | 506 | if (open(my $spelling, '<', $spelling_file)) { |
Joe Perches | 36061e3 | 2014-12-10 15:51:43 -0800 | [diff] [blame] | 507 | while (<$spelling>) { |
| 508 | my $line = $_; |
Kees Cook | 66b47b4 | 2014-10-13 15:51:57 -0700 | [diff] [blame] | 509 | |
Joe Perches | 36061e3 | 2014-12-10 15:51:43 -0800 | [diff] [blame] | 510 | $line =~ s/\s*\n?$//g; |
| 511 | $line =~ s/^\s*//g; |
Kees Cook | 66b47b4 | 2014-10-13 15:51:57 -0700 | [diff] [blame] | 512 | |
Joe Perches | 36061e3 | 2014-12-10 15:51:43 -0800 | [diff] [blame] | 513 | next if ($line =~ m/^\s*#/); |
| 514 | next if ($line =~ m/^\s*$/); |
Kees Cook | 66b47b4 | 2014-10-13 15:51:57 -0700 | [diff] [blame] | 515 | |
Joe Perches | 36061e3 | 2014-12-10 15:51:43 -0800 | [diff] [blame] | 516 | my ($suspect, $fix) = split(/\|\|/, $line); |
| 517 | |
Joe Perches | 36061e3 | 2014-12-10 15:51:43 -0800 | [diff] [blame] | 518 | $spelling_fix{$suspect} = $fix; |
| 519 | } |
| 520 | close($spelling); |
Joe Perches | 36061e3 | 2014-12-10 15:51:43 -0800 | [diff] [blame] | 521 | } else { |
| 522 | warn "No typos will be found - file '$spelling_file': $!\n"; |
Kees Cook | 66b47b4 | 2014-10-13 15:51:57 -0700 | [diff] [blame] | 523 | } |
Kees Cook | 66b47b4 | 2014-10-13 15:51:57 -0700 | [diff] [blame] | 524 | |
Joe Perches | ebfd7d6 | 2015-04-16 12:44:14 -0700 | [diff] [blame] | 525 | if ($codespell) { |
| 526 | if (open(my $spelling, '<', $codespellfile)) { |
| 527 | while (<$spelling>) { |
| 528 | my $line = $_; |
| 529 | |
| 530 | $line =~ s/\s*\n?$//g; |
| 531 | $line =~ s/^\s*//g; |
| 532 | |
| 533 | next if ($line =~ m/^\s*#/); |
| 534 | next if ($line =~ m/^\s*$/); |
| 535 | next if ($line =~ m/, disabled/i); |
| 536 | |
| 537 | $line =~ s/,.*$//; |
| 538 | |
| 539 | my ($suspect, $fix) = split(/->/, $line); |
| 540 | |
| 541 | $spelling_fix{$suspect} = $fix; |
| 542 | } |
| 543 | close($spelling); |
| 544 | } else { |
| 545 | warn "No codespell typos will be found - file '$codespellfile': $!\n"; |
| 546 | } |
| 547 | } |
| 548 | |
| 549 | $misspellings = join("|", sort keys %spelling_fix) if keys %spelling_fix; |
| 550 | |
Andy Whitcroft | 8905a67 | 2007-11-28 16:21:06 -0800 | [diff] [blame] | 551 | sub build_types { |
Alex Dowad | 485ff23 | 2015-06-25 15:02:52 -0700 | [diff] [blame] | 552 | my $mods = "(?x: \n" . join("|\n ", (@modifierList, @modifierListFile)) . "\n)"; |
| 553 | my $all = "(?x: \n" . join("|\n ", (@typeList, @typeListFile)) . "\n)"; |
Joe Perches | 1813087 | 2014-08-06 16:11:22 -0700 | [diff] [blame] | 554 | my $Misordered = "(?x: \n" . join("|\n ", @typeListMisordered) . "\n)"; |
Joe Perches | 8716de3 | 2013-09-11 14:24:05 -0700 | [diff] [blame] | 555 | my $allWithAttr = "(?x: \n" . join("|\n ", @typeListWithAttr) . "\n)"; |
Andy Whitcroft | c8cb2ca | 2008-07-23 21:28:57 -0700 | [diff] [blame] | 556 | $Modifier = qr{(?:$Attribute|$Sparse|$mods)}; |
Joe Perches | ab7e23f | 2015-04-16 12:44:22 -0700 | [diff] [blame] | 557 | $BasicType = qr{ |
Joe Perches | ab7e23f | 2015-04-16 12:44:22 -0700 | [diff] [blame] | 558 | (?:$typeTypedefs\b)| |
| 559 | (?:${all}\b) |
| 560 | }x; |
Andy Whitcroft | 8905a67 | 2007-11-28 16:21:06 -0800 | [diff] [blame] | 561 | $NonptrType = qr{ |
Andy Whitcroft | d2172eb | 2008-07-23 21:29:07 -0700 | [diff] [blame] | 562 | (?:$Modifier\s+|const\s+)* |
Andy Whitcroft | cf65504 | 2008-03-04 14:28:20 -0800 | [diff] [blame] | 563 | (?: |
Andy Whitcroft | 6b48db2 | 2012-01-10 15:10:13 -0800 | [diff] [blame] | 564 | (?:typeof|__typeof__)\s*\([^\)]*\)| |
Andy Whitcroft | 8ed22ca | 2008-10-15 22:02:32 -0700 | [diff] [blame] | 565 | (?:$typeTypedefs\b)| |
Andy Whitcroft | c45dcab | 2008-06-05 22:46:01 -0700 | [diff] [blame] | 566 | (?:${all}\b) |
Andy Whitcroft | cf65504 | 2008-03-04 14:28:20 -0800 | [diff] [blame] | 567 | ) |
Andy Whitcroft | c8cb2ca | 2008-07-23 21:28:57 -0700 | [diff] [blame] | 568 | (?:\s+$Modifier|\s+const)* |
Andy Whitcroft | 8905a67 | 2007-11-28 16:21:06 -0800 | [diff] [blame] | 569 | }x; |
Joe Perches | 1813087 | 2014-08-06 16:11:22 -0700 | [diff] [blame] | 570 | $NonptrTypeMisordered = qr{ |
| 571 | (?:$Modifier\s+|const\s+)* |
| 572 | (?: |
| 573 | (?:${Misordered}\b) |
| 574 | ) |
| 575 | (?:\s+$Modifier|\s+const)* |
| 576 | }x; |
Joe Perches | 8716de3 | 2013-09-11 14:24:05 -0700 | [diff] [blame] | 577 | $NonptrTypeWithAttr = qr{ |
| 578 | (?:$Modifier\s+|const\s+)* |
| 579 | (?: |
| 580 | (?:typeof|__typeof__)\s*\([^\)]*\)| |
| 581 | (?:$typeTypedefs\b)| |
| 582 | (?:${allWithAttr}\b) |
| 583 | ) |
| 584 | (?:\s+$Modifier|\s+const)* |
| 585 | }x; |
Andy Whitcroft | 8905a67 | 2007-11-28 16:21:06 -0800 | [diff] [blame] | 586 | $Type = qr{ |
Andy Whitcroft | c45dcab | 2008-06-05 22:46:01 -0700 | [diff] [blame] | 587 | $NonptrType |
Joe Perches | 1574a29 | 2014-08-06 16:10:50 -0700 | [diff] [blame] | 588 | (?:(?:\s|\*|\[\])+\s*const|(?:\s|\*\s*(?:const\s*)?|\[\])+|(?:\s*\[\s*\])+)? |
Andy Whitcroft | c8cb2ca | 2008-07-23 21:28:57 -0700 | [diff] [blame] | 589 | (?:\s+$Inline|\s+$Modifier)* |
Andy Whitcroft | 8905a67 | 2007-11-28 16:21:06 -0800 | [diff] [blame] | 590 | }x; |
Joe Perches | 1813087 | 2014-08-06 16:11:22 -0700 | [diff] [blame] | 591 | $TypeMisordered = qr{ |
| 592 | $NonptrTypeMisordered |
| 593 | (?:(?:\s|\*|\[\])+\s*const|(?:\s|\*\s*(?:const\s*)?|\[\])+|(?:\s*\[\s*\])+)? |
| 594 | (?:\s+$Inline|\s+$Modifier)* |
| 595 | }x; |
Joe Perches | 91cb519 | 2014-04-03 14:49:32 -0700 | [diff] [blame] | 596 | $Declare = qr{(?:$Storage\s+(?:$Inline\s+)?)?$Type}; |
Joe Perches | 1813087 | 2014-08-06 16:11:22 -0700 | [diff] [blame] | 597 | $DeclareMisordered = qr{(?:$Storage\s+(?:$Inline\s+)?)?$TypeMisordered}; |
Andy Whitcroft | 8905a67 | 2007-11-28 16:21:06 -0800 | [diff] [blame] | 598 | } |
| 599 | build_types(); |
Andy Whitcroft | 6c72ffa | 2007-10-18 03:05:08 -0700 | [diff] [blame] | 600 | |
Joe Perches | 7d2367a | 2011-07-25 17:13:22 -0700 | [diff] [blame] | 601 | our $Typecast = qr{\s*(\(\s*$NonptrType\s*\)){0,1}\s*}; |
Joe Perches | d1fe9c0 | 2012-03-23 15:02:16 -0700 | [diff] [blame] | 602 | |
| 603 | # Using $balanced_parens, $LvalOrFunc, or $FuncArg |
| 604 | # requires at least perl version v5.10.0 |
| 605 | # Any use must be runtime checked with $^V |
| 606 | |
| 607 | our $balanced_parens = qr/(\((?:[^\(\)]++|(?-1))*\))/; |
Joe Perches | 2435880 | 2014-04-03 14:49:13 -0700 | [diff] [blame] | 608 | our $LvalOrFunc = qr{((?:[\&\*]\s*)?$Lval)\s*($balanced_parens{0,1})\s*}; |
Joe Perches | c0a5c89 | 2015-02-13 14:38:21 -0800 | [diff] [blame] | 609 | our $FuncArg = qr{$Typecast{0,1}($LvalOrFunc|$Constant|$String)}; |
Joe Perches | 7d2367a | 2011-07-25 17:13:22 -0700 | [diff] [blame] | 610 | |
Joe Perches | f842230 | 2014-08-06 16:11:31 -0700 | [diff] [blame] | 611 | our $declaration_macros = qr{(?x: |
Joe Perches | 3e838b6 | 2015-09-09 15:37:33 -0700 | [diff] [blame] | 612 | (?:$Storage\s+)?(?:[A-Z_][A-Z0-9]*_){0,2}(?:DEFINE|DECLARE)(?:_[A-Z0-9]+){1,6}\s*\(| |
Joe Perches | f842230 | 2014-08-06 16:11:31 -0700 | [diff] [blame] | 613 | (?:$Storage\s+)?LIST_HEAD\s*\(| |
| 614 | (?:$Storage\s+)?${Type}\s+uninitialized_var\s*\( |
| 615 | )}; |
| 616 | |
Joe Perches | 7d2367a | 2011-07-25 17:13:22 -0700 | [diff] [blame] | 617 | sub deparenthesize { |
| 618 | my ($string) = @_; |
| 619 | return "" if (!defined($string)); |
Joe Perches | 5b9553a | 2014-04-03 14:49:21 -0700 | [diff] [blame] | 620 | |
| 621 | while ($string =~ /^\s*\(.*\)\s*$/) { |
| 622 | $string =~ s@^\s*\(\s*@@; |
| 623 | $string =~ s@\s*\)\s*$@@; |
| 624 | } |
| 625 | |
Joe Perches | 7d2367a | 2011-07-25 17:13:22 -0700 | [diff] [blame] | 626 | $string =~ s@\s+@ @g; |
Joe Perches | 5b9553a | 2014-04-03 14:49:21 -0700 | [diff] [blame] | 627 | |
Joe Perches | 7d2367a | 2011-07-25 17:13:22 -0700 | [diff] [blame] | 628 | return $string; |
| 629 | } |
| 630 | |
Joe Perches | 3445686 | 2013-07-03 15:05:34 -0700 | [diff] [blame] | 631 | sub seed_camelcase_file { |
| 632 | my ($file) = @_; |
| 633 | |
| 634 | return if (!(-f $file)); |
| 635 | |
| 636 | local $/; |
| 637 | |
| 638 | open(my $include_file, '<', "$file") |
| 639 | or warn "$P: Can't read '$file' $!\n"; |
| 640 | my $text = <$include_file>; |
| 641 | close($include_file); |
| 642 | |
| 643 | my @lines = split('\n', $text); |
| 644 | |
| 645 | foreach my $line (@lines) { |
| 646 | next if ($line !~ /(?:[A-Z][a-z]|[a-z][A-Z])/); |
| 647 | if ($line =~ /^[ \t]*(?:#[ \t]*define|typedef\s+$Type)\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)/) { |
| 648 | $camelcase{$1} = 1; |
Joe Perches | 11ea516 | 2013-11-12 15:10:08 -0800 | [diff] [blame] | 649 | } elsif ($line =~ /^\s*$Declare\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)\s*[\(\[,;]/) { |
| 650 | $camelcase{$1} = 1; |
| 651 | } elsif ($line =~ /^\s*(?:union|struct|enum)\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)\s*[;\{]/) { |
Joe Perches | 3445686 | 2013-07-03 15:05:34 -0700 | [diff] [blame] | 652 | $camelcase{$1} = 1; |
| 653 | } |
| 654 | } |
| 655 | } |
| 656 | |
| 657 | my $camelcase_seeded = 0; |
| 658 | sub seed_camelcase_includes { |
| 659 | return if ($camelcase_seeded); |
| 660 | |
| 661 | my $files; |
Joe Perches | c707a81 | 2013-07-08 16:00:43 -0700 | [diff] [blame] | 662 | my $camelcase_cache = ""; |
| 663 | my @include_files = (); |
| 664 | |
| 665 | $camelcase_seeded = 1; |
Joe Perches | 351b2a1 | 2013-07-03 15:05:36 -0700 | [diff] [blame] | 666 | |
Richard Genoud | 3645e32 | 2014-02-10 14:25:32 -0800 | [diff] [blame] | 667 | if (-e ".git") { |
Joe Perches | 351b2a1 | 2013-07-03 15:05:36 -0700 | [diff] [blame] | 668 | my $git_last_include_commit = `git log --no-merges --pretty=format:"%h%n" -1 -- include`; |
| 669 | chomp $git_last_include_commit; |
Joe Perches | c707a81 | 2013-07-08 16:00:43 -0700 | [diff] [blame] | 670 | $camelcase_cache = ".checkpatch-camelcase.git.$git_last_include_commit"; |
Joe Perches | 3445686 | 2013-07-03 15:05:34 -0700 | [diff] [blame] | 671 | } else { |
Joe Perches | c707a81 | 2013-07-08 16:00:43 -0700 | [diff] [blame] | 672 | my $last_mod_date = 0; |
Joe Perches | 3445686 | 2013-07-03 15:05:34 -0700 | [diff] [blame] | 673 | $files = `find $root/include -name "*.h"`; |
Joe Perches | c707a81 | 2013-07-08 16:00:43 -0700 | [diff] [blame] | 674 | @include_files = split('\n', $files); |
| 675 | foreach my $file (@include_files) { |
| 676 | my $date = POSIX::strftime("%Y%m%d%H%M", |
| 677 | localtime((stat $file)[9])); |
| 678 | $last_mod_date = $date if ($last_mod_date < $date); |
| 679 | } |
| 680 | $camelcase_cache = ".checkpatch-camelcase.date.$last_mod_date"; |
Joe Perches | 3445686 | 2013-07-03 15:05:34 -0700 | [diff] [blame] | 681 | } |
Joe Perches | c707a81 | 2013-07-08 16:00:43 -0700 | [diff] [blame] | 682 | |
| 683 | if ($camelcase_cache ne "" && -f $camelcase_cache) { |
| 684 | open(my $camelcase_file, '<', "$camelcase_cache") |
| 685 | or warn "$P: Can't read '$camelcase_cache' $!\n"; |
| 686 | while (<$camelcase_file>) { |
| 687 | chomp; |
| 688 | $camelcase{$_} = 1; |
| 689 | } |
| 690 | close($camelcase_file); |
| 691 | |
| 692 | return; |
| 693 | } |
| 694 | |
Richard Genoud | 3645e32 | 2014-02-10 14:25:32 -0800 | [diff] [blame] | 695 | if (-e ".git") { |
Joe Perches | c707a81 | 2013-07-08 16:00:43 -0700 | [diff] [blame] | 696 | $files = `git ls-files "include/*.h"`; |
| 697 | @include_files = split('\n', $files); |
| 698 | } |
| 699 | |
Joe Perches | 3445686 | 2013-07-03 15:05:34 -0700 | [diff] [blame] | 700 | foreach my $file (@include_files) { |
| 701 | seed_camelcase_file($file); |
| 702 | } |
Joe Perches | 351b2a1 | 2013-07-03 15:05:36 -0700 | [diff] [blame] | 703 | |
Joe Perches | c707a81 | 2013-07-08 16:00:43 -0700 | [diff] [blame] | 704 | if ($camelcase_cache ne "") { |
Joe Perches | 351b2a1 | 2013-07-03 15:05:36 -0700 | [diff] [blame] | 705 | unlink glob ".checkpatch-camelcase.*"; |
Joe Perches | c707a81 | 2013-07-08 16:00:43 -0700 | [diff] [blame] | 706 | open(my $camelcase_file, '>', "$camelcase_cache") |
| 707 | or warn "$P: Can't write '$camelcase_cache' $!\n"; |
Joe Perches | 351b2a1 | 2013-07-03 15:05:36 -0700 | [diff] [blame] | 708 | foreach (sort { lc($a) cmp lc($b) } keys(%camelcase)) { |
| 709 | print $camelcase_file ("$_\n"); |
| 710 | } |
| 711 | close($camelcase_file); |
| 712 | } |
Joe Perches | 3445686 | 2013-07-03 15:05:34 -0700 | [diff] [blame] | 713 | } |
| 714 | |
Joe Perches | d311cd4 | 2014-08-06 16:10:57 -0700 | [diff] [blame] | 715 | sub git_commit_info { |
| 716 | my ($commit, $id, $desc) = @_; |
| 717 | |
| 718 | return ($id, $desc) if ((which("git") eq "") || !(-e ".git")); |
| 719 | |
| 720 | my $output = `git log --no-color --format='%H %s' -1 $commit 2>&1`; |
| 721 | $output =~ s/^\s*//gm; |
| 722 | my @lines = split("\n", $output); |
| 723 | |
Joe Perches | 0d7835f | 2015-02-13 14:38:35 -0800 | [diff] [blame] | 724 | return ($id, $desc) if ($#lines < 0); |
| 725 | |
Joe Perches | d311cd4 | 2014-08-06 16:10:57 -0700 | [diff] [blame] | 726 | if ($lines[0] =~ /^error: short SHA1 $commit is ambiguous\./) { |
| 727 | # Maybe one day convert this block of bash into something that returns |
| 728 | # all matching commit ids, but it's very slow... |
| 729 | # |
| 730 | # echo "checking commits $1..." |
| 731 | # git rev-list --remotes | grep -i "^$1" | |
| 732 | # while read line ; do |
| 733 | # git log --format='%H %s' -1 $line | |
| 734 | # echo "commit $(cut -c 1-12,41-)" |
| 735 | # done |
| 736 | } elsif ($lines[0] =~ /^fatal: ambiguous argument '$commit': unknown revision or path not in the working tree\./) { |
| 737 | } else { |
| 738 | $id = substr($lines[0], 0, 12); |
| 739 | $desc = substr($lines[0], 41); |
| 740 | } |
| 741 | |
| 742 | return ($id, $desc); |
| 743 | } |
| 744 | |
Andy Whitcroft | 6c72ffa | 2007-10-18 03:05:08 -0700 | [diff] [blame] | 745 | $chk_signoff = 0 if ($file); |
| 746 | |
Andy Whitcroft | 00df344 | 2007-06-08 13:47:06 -0700 | [diff] [blame] | 747 | my @rawlines = (); |
Andy Whitcroft | c2fdda0 | 2008-02-08 04:20:54 -0800 | [diff] [blame] | 748 | my @lines = (); |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 749 | my @fixed = (); |
Joe Perches | d752fcc | 2014-08-06 16:11:05 -0700 | [diff] [blame] | 750 | my @fixed_inserted = (); |
| 751 | my @fixed_deleted = (); |
Joe Perches | 194f66f | 2014-08-06 16:11:03 -0700 | [diff] [blame] | 752 | my $fixlinenr = -1; |
| 753 | |
Andy Whitcroft | c2fdda0 | 2008-02-08 04:20:54 -0800 | [diff] [blame] | 754 | my $vname; |
Andy Whitcroft | 6c72ffa | 2007-10-18 03:05:08 -0700 | [diff] [blame] | 755 | for my $filename (@ARGV) { |
Andy Whitcroft | 21caa13 | 2009-01-06 14:41:30 -0800 | [diff] [blame] | 756 | my $FILE; |
Andy Whitcroft | 6c72ffa | 2007-10-18 03:05:08 -0700 | [diff] [blame] | 757 | if ($file) { |
Andy Whitcroft | 21caa13 | 2009-01-06 14:41:30 -0800 | [diff] [blame] | 758 | open($FILE, '-|', "diff -u /dev/null $filename") || |
Andy Whitcroft | 6c72ffa | 2007-10-18 03:05:08 -0700 | [diff] [blame] | 759 | die "$P: $filename: diff failed - $!\n"; |
Andy Whitcroft | 21caa13 | 2009-01-06 14:41:30 -0800 | [diff] [blame] | 760 | } elsif ($filename eq '-') { |
| 761 | open($FILE, '<&STDIN'); |
Andy Whitcroft | 6c72ffa | 2007-10-18 03:05:08 -0700 | [diff] [blame] | 762 | } else { |
Andy Whitcroft | 21caa13 | 2009-01-06 14:41:30 -0800 | [diff] [blame] | 763 | open($FILE, '<', "$filename") || |
Andy Whitcroft | 6c72ffa | 2007-10-18 03:05:08 -0700 | [diff] [blame] | 764 | die "$P: $filename: open failed - $!\n"; |
Andy Whitcroft | 0a920b5 | 2007-06-01 00:46:48 -0700 | [diff] [blame] | 765 | } |
Andy Whitcroft | c2fdda0 | 2008-02-08 04:20:54 -0800 | [diff] [blame] | 766 | if ($filename eq '-') { |
| 767 | $vname = 'Your patch'; |
| 768 | } else { |
| 769 | $vname = $filename; |
| 770 | } |
Andy Whitcroft | 21caa13 | 2009-01-06 14:41:30 -0800 | [diff] [blame] | 771 | while (<$FILE>) { |
Andy Whitcroft | 6c72ffa | 2007-10-18 03:05:08 -0700 | [diff] [blame] | 772 | chomp; |
| 773 | push(@rawlines, $_); |
| 774 | } |
Andy Whitcroft | 21caa13 | 2009-01-06 14:41:30 -0800 | [diff] [blame] | 775 | close($FILE); |
Joe Perches | d8469f1 | 2015-06-25 15:03:00 -0700 | [diff] [blame] | 776 | |
| 777 | if ($#ARGV > 0 && $quiet == 0) { |
| 778 | print '-' x length($vname) . "\n"; |
| 779 | print "$vname\n"; |
| 780 | print '-' x length($vname) . "\n"; |
| 781 | } |
| 782 | |
Andy Whitcroft | c2fdda0 | 2008-02-08 04:20:54 -0800 | [diff] [blame] | 783 | if (!process($filename)) { |
Andy Whitcroft | 6c72ffa | 2007-10-18 03:05:08 -0700 | [diff] [blame] | 784 | $exit = 1; |
| 785 | } |
| 786 | @rawlines = (); |
Andy Whitcroft | 13214ad | 2008-02-08 04:22:03 -0800 | [diff] [blame] | 787 | @lines = (); |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 788 | @fixed = (); |
Joe Perches | d752fcc | 2014-08-06 16:11:05 -0700 | [diff] [blame] | 789 | @fixed_inserted = (); |
| 790 | @fixed_deleted = (); |
Joe Perches | 194f66f | 2014-08-06 16:11:03 -0700 | [diff] [blame] | 791 | $fixlinenr = -1; |
Alex Dowad | 485ff23 | 2015-06-25 15:02:52 -0700 | [diff] [blame] | 792 | @modifierListFile = (); |
| 793 | @typeListFile = (); |
| 794 | build_types(); |
Andy Whitcroft | 0a920b5 | 2007-06-01 00:46:48 -0700 | [diff] [blame] | 795 | } |
| 796 | |
Joe Perches | d8469f1 | 2015-06-25 15:03:00 -0700 | [diff] [blame] | 797 | if (!$quiet) { |
Joe Perches | 3c816e4 | 2015-06-25 15:03:29 -0700 | [diff] [blame] | 798 | hash_show_words(\%use_type, "Used"); |
| 799 | hash_show_words(\%ignore_type, "Ignored"); |
| 800 | |
Joe Perches | d8469f1 | 2015-06-25 15:03:00 -0700 | [diff] [blame] | 801 | if ($^V lt 5.10.0) { |
| 802 | print << "EOM" |
| 803 | |
| 804 | NOTE: perl $^V is not modern enough to detect all possible issues. |
| 805 | An upgrade to at least perl v5.10.0 is suggested. |
| 806 | EOM |
| 807 | } |
| 808 | if ($exit) { |
| 809 | print << "EOM" |
| 810 | |
| 811 | NOTE: If any of the errors are false positives, please report |
| 812 | them to the maintainer, see CHECKPATCH in MAINTAINERS. |
| 813 | EOM |
| 814 | } |
| 815 | } |
| 816 | |
Andy Whitcroft | 0a920b5 | 2007-06-01 00:46:48 -0700 | [diff] [blame] | 817 | exit($exit); |
| 818 | |
| 819 | sub top_of_kernel_tree { |
Andy Whitcroft | 6c72ffa | 2007-10-18 03:05:08 -0700 | [diff] [blame] | 820 | my ($root) = @_; |
| 821 | |
| 822 | my @tree_check = ( |
| 823 | "COPYING", "CREDITS", "Kbuild", "MAINTAINERS", "Makefile", |
| 824 | "README", "Documentation", "arch", "include", "drivers", |
| 825 | "fs", "init", "ipc", "kernel", "lib", "scripts", |
| 826 | ); |
| 827 | |
| 828 | foreach my $check (@tree_check) { |
| 829 | if (! -e $root . '/' . $check) { |
| 830 | return 0; |
| 831 | } |
Andy Whitcroft | 0a920b5 | 2007-06-01 00:46:48 -0700 | [diff] [blame] | 832 | } |
Andy Whitcroft | 6c72ffa | 2007-10-18 03:05:08 -0700 | [diff] [blame] | 833 | return 1; |
Joe Perches | 8f26b83 | 2012-10-04 17:13:32 -0700 | [diff] [blame] | 834 | } |
Andy Whitcroft | 0a920b5 | 2007-06-01 00:46:48 -0700 | [diff] [blame] | 835 | |
Joe Perches | 2011247 | 2011-07-25 17:13:23 -0700 | [diff] [blame] | 836 | sub parse_email { |
| 837 | my ($formatted_email) = @_; |
| 838 | |
| 839 | my $name = ""; |
| 840 | my $address = ""; |
| 841 | my $comment = ""; |
| 842 | |
| 843 | if ($formatted_email =~ /^(.*)<(\S+\@\S+)>(.*)$/) { |
| 844 | $name = $1; |
| 845 | $address = $2; |
| 846 | $comment = $3 if defined $3; |
| 847 | } elsif ($formatted_email =~ /^\s*<(\S+\@\S+)>(.*)$/) { |
| 848 | $address = $1; |
| 849 | $comment = $2 if defined $2; |
| 850 | } elsif ($formatted_email =~ /(\S+\@\S+)(.*)$/) { |
| 851 | $address = $1; |
| 852 | $comment = $2 if defined $2; |
| 853 | $formatted_email =~ s/$address.*$//; |
| 854 | $name = $formatted_email; |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 855 | $name = trim($name); |
Joe Perches | 2011247 | 2011-07-25 17:13:23 -0700 | [diff] [blame] | 856 | $name =~ s/^\"|\"$//g; |
| 857 | # If there's a name left after stripping spaces and |
| 858 | # leading quotes, and the address doesn't have both |
| 859 | # leading and trailing angle brackets, the address |
| 860 | # is invalid. ie: |
| 861 | # "joe smith joe@smith.com" bad |
| 862 | # "joe smith <joe@smith.com" bad |
| 863 | if ($name ne "" && $address !~ /^<[^>]+>$/) { |
| 864 | $name = ""; |
| 865 | $address = ""; |
| 866 | $comment = ""; |
| 867 | } |
| 868 | } |
| 869 | |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 870 | $name = trim($name); |
Joe Perches | 2011247 | 2011-07-25 17:13:23 -0700 | [diff] [blame] | 871 | $name =~ s/^\"|\"$//g; |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 872 | $address = trim($address); |
Joe Perches | 2011247 | 2011-07-25 17:13:23 -0700 | [diff] [blame] | 873 | $address =~ s/^\<|\>$//g; |
| 874 | |
| 875 | if ($name =~ /[^\w \-]/i) { ##has "must quote" chars |
| 876 | $name =~ s/(?<!\\)"/\\"/g; ##escape quotes |
| 877 | $name = "\"$name\""; |
| 878 | } |
| 879 | |
| 880 | return ($name, $address, $comment); |
| 881 | } |
| 882 | |
| 883 | sub format_email { |
| 884 | my ($name, $address) = @_; |
| 885 | |
| 886 | my $formatted_email; |
| 887 | |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 888 | $name = trim($name); |
Joe Perches | 2011247 | 2011-07-25 17:13:23 -0700 | [diff] [blame] | 889 | $name =~ s/^\"|\"$//g; |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 890 | $address = trim($address); |
Joe Perches | 2011247 | 2011-07-25 17:13:23 -0700 | [diff] [blame] | 891 | |
| 892 | if ($name =~ /[^\w \-]/i) { ##has "must quote" chars |
| 893 | $name =~ s/(?<!\\)"/\\"/g; ##escape quotes |
| 894 | $name = "\"$name\""; |
| 895 | } |
| 896 | |
| 897 | if ("$name" eq "") { |
| 898 | $formatted_email = "$address"; |
| 899 | } else { |
| 900 | $formatted_email = "$name <$address>"; |
| 901 | } |
| 902 | |
| 903 | return $formatted_email; |
| 904 | } |
| 905 | |
Joe Perches | d311cd4 | 2014-08-06 16:10:57 -0700 | [diff] [blame] | 906 | sub which { |
Joe Perches | bd474ca | 2014-08-06 16:11:10 -0700 | [diff] [blame] | 907 | my ($bin) = @_; |
Joe Perches | d311cd4 | 2014-08-06 16:10:57 -0700 | [diff] [blame] | 908 | |
Joe Perches | bd474ca | 2014-08-06 16:11:10 -0700 | [diff] [blame] | 909 | foreach my $path (split(/:/, $ENV{PATH})) { |
| 910 | if (-e "$path/$bin") { |
| 911 | return "$path/$bin"; |
| 912 | } |
Joe Perches | d311cd4 | 2014-08-06 16:10:57 -0700 | [diff] [blame] | 913 | } |
Joe Perches | d311cd4 | 2014-08-06 16:10:57 -0700 | [diff] [blame] | 914 | |
Joe Perches | bd474ca | 2014-08-06 16:11:10 -0700 | [diff] [blame] | 915 | return ""; |
Joe Perches | d311cd4 | 2014-08-06 16:10:57 -0700 | [diff] [blame] | 916 | } |
| 917 | |
Joe Perches | 000d1cc1 | 2011-07-25 17:13:25 -0700 | [diff] [blame] | 918 | sub which_conf { |
| 919 | my ($conf) = @_; |
| 920 | |
| 921 | foreach my $path (split(/:/, ".:$ENV{HOME}:.scripts")) { |
| 922 | if (-e "$path/$conf") { |
| 923 | return "$path/$conf"; |
| 924 | } |
| 925 | } |
| 926 | |
| 927 | return ""; |
| 928 | } |
| 929 | |
Andy Whitcroft | 0a920b5 | 2007-06-01 00:46:48 -0700 | [diff] [blame] | 930 | sub expand_tabs { |
| 931 | my ($str) = @_; |
| 932 | |
| 933 | my $res = ''; |
| 934 | my $n = 0; |
| 935 | for my $c (split(//, $str)) { |
| 936 | if ($c eq "\t") { |
| 937 | $res .= ' '; |
| 938 | $n++; |
| 939 | for (; ($n % 8) != 0; $n++) { |
| 940 | $res .= ' '; |
| 941 | } |
| 942 | next; |
| 943 | } |
| 944 | $res .= $c; |
| 945 | $n++; |
| 946 | } |
| 947 | |
| 948 | return $res; |
| 949 | } |
Andy Whitcroft | 6c72ffa | 2007-10-18 03:05:08 -0700 | [diff] [blame] | 950 | sub copy_spacing { |
Andy Whitcroft | 773647a | 2008-03-28 14:15:58 -0700 | [diff] [blame] | 951 | (my $res = shift) =~ tr/\t/ /c; |
Andy Whitcroft | 6c72ffa | 2007-10-18 03:05:08 -0700 | [diff] [blame] | 952 | return $res; |
| 953 | } |
Andy Whitcroft | 0a920b5 | 2007-06-01 00:46:48 -0700 | [diff] [blame] | 954 | |
Andy Whitcroft | 4a0df2e | 2007-06-08 13:46:39 -0700 | [diff] [blame] | 955 | sub line_stats { |
| 956 | my ($line) = @_; |
| 957 | |
| 958 | # Drop the diff line leader and expand tabs |
| 959 | $line =~ s/^.//; |
| 960 | $line = expand_tabs($line); |
| 961 | |
| 962 | # Pick the indent from the front of the line. |
| 963 | my ($white) = ($line =~ /^(\s*)/); |
| 964 | |
| 965 | return (length($line), length($white)); |
| 966 | } |
| 967 | |
Andy Whitcroft | 773647a | 2008-03-28 14:15:58 -0700 | [diff] [blame] | 968 | my $sanitise_quote = ''; |
| 969 | |
| 970 | sub sanitise_line_reset { |
| 971 | my ($in_comment) = @_; |
| 972 | |
| 973 | if ($in_comment) { |
| 974 | $sanitise_quote = '*/'; |
| 975 | } else { |
| 976 | $sanitise_quote = ''; |
| 977 | } |
| 978 | } |
Andy Whitcroft | 00df344 | 2007-06-08 13:47:06 -0700 | [diff] [blame] | 979 | sub sanitise_line { |
| 980 | my ($line) = @_; |
| 981 | |
| 982 | my $res = ''; |
| 983 | my $l = ''; |
| 984 | |
Andy Whitcroft | c2fdda0 | 2008-02-08 04:20:54 -0800 | [diff] [blame] | 985 | my $qlen = 0; |
Andy Whitcroft | 773647a | 2008-03-28 14:15:58 -0700 | [diff] [blame] | 986 | my $off = 0; |
| 987 | my $c; |
Andy Whitcroft | 00df344 | 2007-06-08 13:47:06 -0700 | [diff] [blame] | 988 | |
Andy Whitcroft | 773647a | 2008-03-28 14:15:58 -0700 | [diff] [blame] | 989 | # Always copy over the diff marker. |
| 990 | $res = substr($line, 0, 1); |
| 991 | |
| 992 | for ($off = 1; $off < length($line); $off++) { |
| 993 | $c = substr($line, $off, 1); |
| 994 | |
| 995 | # Comments we are wacking completly including the begin |
| 996 | # and end, all to $;. |
| 997 | if ($sanitise_quote eq '' && substr($line, $off, 2) eq '/*') { |
| 998 | $sanitise_quote = '*/'; |
| 999 | |
| 1000 | substr($res, $off, 2, "$;$;"); |
| 1001 | $off++; |
| 1002 | next; |
Andy Whitcroft | c2fdda0 | 2008-02-08 04:20:54 -0800 | [diff] [blame] | 1003 | } |
Andy Whitcroft | 81bc0e0 | 2008-10-15 22:02:26 -0700 | [diff] [blame] | 1004 | if ($sanitise_quote eq '*/' && substr($line, $off, 2) eq '*/') { |
Andy Whitcroft | 773647a | 2008-03-28 14:15:58 -0700 | [diff] [blame] | 1005 | $sanitise_quote = ''; |
| 1006 | substr($res, $off, 2, "$;$;"); |
| 1007 | $off++; |
| 1008 | next; |
| 1009 | } |
Daniel Walker | 113f04a | 2009-09-21 17:04:35 -0700 | [diff] [blame] | 1010 | if ($sanitise_quote eq '' && substr($line, $off, 2) eq '//') { |
| 1011 | $sanitise_quote = '//'; |
| 1012 | |
| 1013 | substr($res, $off, 2, $sanitise_quote); |
| 1014 | $off++; |
| 1015 | next; |
| 1016 | } |
Andy Whitcroft | 773647a | 2008-03-28 14:15:58 -0700 | [diff] [blame] | 1017 | |
| 1018 | # A \ in a string means ignore the next character. |
| 1019 | if (($sanitise_quote eq "'" || $sanitise_quote eq '"') && |
| 1020 | $c eq "\\") { |
| 1021 | substr($res, $off, 2, 'XX'); |
| 1022 | $off++; |
| 1023 | next; |
| 1024 | } |
| 1025 | # Regular quotes. |
| 1026 | if ($c eq "'" || $c eq '"') { |
| 1027 | if ($sanitise_quote eq '') { |
| 1028 | $sanitise_quote = $c; |
| 1029 | |
| 1030 | substr($res, $off, 1, $c); |
Andy Whitcroft | 00df344 | 2007-06-08 13:47:06 -0700 | [diff] [blame] | 1031 | next; |
Andy Whitcroft | 773647a | 2008-03-28 14:15:58 -0700 | [diff] [blame] | 1032 | } elsif ($sanitise_quote eq $c) { |
| 1033 | $sanitise_quote = ''; |
Andy Whitcroft | 00df344 | 2007-06-08 13:47:06 -0700 | [diff] [blame] | 1034 | } |
| 1035 | } |
Andy Whitcroft | 773647a | 2008-03-28 14:15:58 -0700 | [diff] [blame] | 1036 | |
Andy Whitcroft | fae17da | 2009-01-06 14:41:20 -0800 | [diff] [blame] | 1037 | #print "c<$c> SQ<$sanitise_quote>\n"; |
Andy Whitcroft | 773647a | 2008-03-28 14:15:58 -0700 | [diff] [blame] | 1038 | if ($off != 0 && $sanitise_quote eq '*/' && $c ne "\t") { |
| 1039 | substr($res, $off, 1, $;); |
Daniel Walker | 113f04a | 2009-09-21 17:04:35 -0700 | [diff] [blame] | 1040 | } elsif ($off != 0 && $sanitise_quote eq '//' && $c ne "\t") { |
| 1041 | substr($res, $off, 1, $;); |
Andy Whitcroft | 773647a | 2008-03-28 14:15:58 -0700 | [diff] [blame] | 1042 | } elsif ($off != 0 && $sanitise_quote && $c ne "\t") { |
| 1043 | substr($res, $off, 1, 'X'); |
Andy Whitcroft | 00df344 | 2007-06-08 13:47:06 -0700 | [diff] [blame] | 1044 | } else { |
Andy Whitcroft | 773647a | 2008-03-28 14:15:58 -0700 | [diff] [blame] | 1045 | substr($res, $off, 1, $c); |
Andy Whitcroft | 00df344 | 2007-06-08 13:47:06 -0700 | [diff] [blame] | 1046 | } |
Andy Whitcroft | c2fdda0 | 2008-02-08 04:20:54 -0800 | [diff] [blame] | 1047 | } |
| 1048 | |
Daniel Walker | 113f04a | 2009-09-21 17:04:35 -0700 | [diff] [blame] | 1049 | if ($sanitise_quote eq '//') { |
| 1050 | $sanitise_quote = ''; |
| 1051 | } |
| 1052 | |
Andy Whitcroft | c2fdda0 | 2008-02-08 04:20:54 -0800 | [diff] [blame] | 1053 | # The pathname on a #include may be surrounded by '<' and '>'. |
Andy Whitcroft | c45dcab | 2008-06-05 22:46:01 -0700 | [diff] [blame] | 1054 | if ($res =~ /^.\s*\#\s*include\s+\<(.*)\>/) { |
Andy Whitcroft | c2fdda0 | 2008-02-08 04:20:54 -0800 | [diff] [blame] | 1055 | my $clean = 'X' x length($1); |
| 1056 | $res =~ s@\<.*\>@<$clean>@; |
| 1057 | |
| 1058 | # The whole of a #error is a string. |
Andy Whitcroft | c45dcab | 2008-06-05 22:46:01 -0700 | [diff] [blame] | 1059 | } elsif ($res =~ /^.\s*\#\s*(?:error|warning)\s+(.*)\b/) { |
Andy Whitcroft | c2fdda0 | 2008-02-08 04:20:54 -0800 | [diff] [blame] | 1060 | my $clean = 'X' x length($1); |
Andy Whitcroft | c45dcab | 2008-06-05 22:46:01 -0700 | [diff] [blame] | 1061 | $res =~ s@(\#\s*(?:error|warning)\s+).*@$1$clean@; |
Andy Whitcroft | c2fdda0 | 2008-02-08 04:20:54 -0800 | [diff] [blame] | 1062 | } |
| 1063 | |
Andy Whitcroft | 00df344 | 2007-06-08 13:47:06 -0700 | [diff] [blame] | 1064 | return $res; |
| 1065 | } |
| 1066 | |
Joe Perches | a6962d7 | 2013-04-29 16:18:13 -0700 | [diff] [blame] | 1067 | sub get_quoted_string { |
| 1068 | my ($line, $rawline) = @_; |
| 1069 | |
Joe Perches | 33acb54 | 2015-06-25 15:02:54 -0700 | [diff] [blame] | 1070 | return "" if ($line !~ m/($String)/g); |
Joe Perches | a6962d7 | 2013-04-29 16:18:13 -0700 | [diff] [blame] | 1071 | return substr($rawline, $-[0], $+[0] - $-[0]); |
| 1072 | } |
| 1073 | |
Andy Whitcroft | 8905a67 | 2007-11-28 16:21:06 -0800 | [diff] [blame] | 1074 | sub ctx_statement_block { |
| 1075 | my ($linenr, $remain, $off) = @_; |
| 1076 | my $line = $linenr - 1; |
| 1077 | my $blk = ''; |
| 1078 | my $soff = $off; |
| 1079 | my $coff = $off - 1; |
Andy Whitcroft | 773647a | 2008-03-28 14:15:58 -0700 | [diff] [blame] | 1080 | my $coff_set = 0; |
Andy Whitcroft | 8905a67 | 2007-11-28 16:21:06 -0800 | [diff] [blame] | 1081 | |
Andy Whitcroft | 13214ad | 2008-02-08 04:22:03 -0800 | [diff] [blame] | 1082 | my $loff = 0; |
| 1083 | |
Andy Whitcroft | 8905a67 | 2007-11-28 16:21:06 -0800 | [diff] [blame] | 1084 | my $type = ''; |
| 1085 | my $level = 0; |
Andy Whitcroft | a275064 | 2009-01-15 13:51:04 -0800 | [diff] [blame] | 1086 | my @stack = (); |
Andy Whitcroft | cf65504 | 2008-03-04 14:28:20 -0800 | [diff] [blame] | 1087 | my $p; |
Andy Whitcroft | 8905a67 | 2007-11-28 16:21:06 -0800 | [diff] [blame] | 1088 | my $c; |
| 1089 | my $len = 0; |
Andy Whitcroft | 13214ad | 2008-02-08 04:22:03 -0800 | [diff] [blame] | 1090 | |
| 1091 | my $remainder; |
Andy Whitcroft | 8905a67 | 2007-11-28 16:21:06 -0800 | [diff] [blame] | 1092 | while (1) { |
Andy Whitcroft | a275064 | 2009-01-15 13:51:04 -0800 | [diff] [blame] | 1093 | @stack = (['', 0]) if ($#stack == -1); |
| 1094 | |
Andy Whitcroft | 773647a | 2008-03-28 14:15:58 -0700 | [diff] [blame] | 1095 | #warn "CSB: blk<$blk> remain<$remain>\n"; |
Andy Whitcroft | 8905a67 | 2007-11-28 16:21:06 -0800 | [diff] [blame] | 1096 | # If we are about to drop off the end, pull in more |
| 1097 | # context. |
| 1098 | if ($off >= $len) { |
| 1099 | for (; $remain > 0; $line++) { |
Andy Whitcroft | dea3349 | 2008-10-15 22:02:25 -0700 | [diff] [blame] | 1100 | last if (!defined $lines[$line]); |
Andy Whitcroft | c2fdda0 | 2008-02-08 04:20:54 -0800 | [diff] [blame] | 1101 | next if ($lines[$line] =~ /^-/); |
Andy Whitcroft | 8905a67 | 2007-11-28 16:21:06 -0800 | [diff] [blame] | 1102 | $remain--; |
Andy Whitcroft | 13214ad | 2008-02-08 04:22:03 -0800 | [diff] [blame] | 1103 | $loff = $len; |
Andy Whitcroft | c2fdda0 | 2008-02-08 04:20:54 -0800 | [diff] [blame] | 1104 | $blk .= $lines[$line] . "\n"; |
Andy Whitcroft | 8905a67 | 2007-11-28 16:21:06 -0800 | [diff] [blame] | 1105 | $len = length($blk); |
| 1106 | $line++; |
| 1107 | last; |
| 1108 | } |
| 1109 | # Bail if there is no further context. |
| 1110 | #warn "CSB: blk<$blk> off<$off> len<$len>\n"; |
Andy Whitcroft | 13214ad | 2008-02-08 04:22:03 -0800 | [diff] [blame] | 1111 | if ($off >= $len) { |
Andy Whitcroft | 8905a67 | 2007-11-28 16:21:06 -0800 | [diff] [blame] | 1112 | last; |
| 1113 | } |
Andy Whitcroft | f74bd19 | 2012-01-10 15:09:54 -0800 | [diff] [blame] | 1114 | if ($level == 0 && substr($blk, $off) =~ /^.\s*#\s*define/) { |
| 1115 | $level++; |
| 1116 | $type = '#'; |
| 1117 | } |
Andy Whitcroft | 8905a67 | 2007-11-28 16:21:06 -0800 | [diff] [blame] | 1118 | } |
Andy Whitcroft | cf65504 | 2008-03-04 14:28:20 -0800 | [diff] [blame] | 1119 | $p = $c; |
Andy Whitcroft | 8905a67 | 2007-11-28 16:21:06 -0800 | [diff] [blame] | 1120 | $c = substr($blk, $off, 1); |
Andy Whitcroft | 13214ad | 2008-02-08 04:22:03 -0800 | [diff] [blame] | 1121 | $remainder = substr($blk, $off); |
Andy Whitcroft | 8905a67 | 2007-11-28 16:21:06 -0800 | [diff] [blame] | 1122 | |
Andy Whitcroft | 773647a | 2008-03-28 14:15:58 -0700 | [diff] [blame] | 1123 | #warn "CSB: c<$c> type<$type> level<$level> remainder<$remainder> coff_set<$coff_set>\n"; |
Andy Whitcroft | 4635f4f | 2009-01-06 14:41:27 -0800 | [diff] [blame] | 1124 | |
| 1125 | # Handle nested #if/#else. |
| 1126 | if ($remainder =~ /^#\s*(?:ifndef|ifdef|if)\s/) { |
| 1127 | push(@stack, [ $type, $level ]); |
| 1128 | } elsif ($remainder =~ /^#\s*(?:else|elif)\b/) { |
| 1129 | ($type, $level) = @{$stack[$#stack - 1]}; |
| 1130 | } elsif ($remainder =~ /^#\s*endif\b/) { |
| 1131 | ($type, $level) = @{pop(@stack)}; |
| 1132 | } |
| 1133 | |
Andy Whitcroft | 8905a67 | 2007-11-28 16:21:06 -0800 | [diff] [blame] | 1134 | # Statement ends at the ';' or a close '}' at the |
| 1135 | # outermost level. |
| 1136 | if ($level == 0 && $c eq ';') { |
| 1137 | last; |
| 1138 | } |
| 1139 | |
Andy Whitcroft | 13214ad | 2008-02-08 04:22:03 -0800 | [diff] [blame] | 1140 | # An else is really a conditional as long as its not else if |
Andy Whitcroft | 773647a | 2008-03-28 14:15:58 -0700 | [diff] [blame] | 1141 | if ($level == 0 && $coff_set == 0 && |
| 1142 | (!defined($p) || $p =~ /(?:\s|\}|\+)/) && |
| 1143 | $remainder =~ /^(else)(?:\s|{)/ && |
| 1144 | $remainder !~ /^else\s+if\b/) { |
| 1145 | $coff = $off + length($1) - 1; |
| 1146 | $coff_set = 1; |
| 1147 | #warn "CSB: mark coff<$coff> soff<$soff> 1<$1>\n"; |
| 1148 | #warn "[" . substr($blk, $soff, $coff - $soff + 1) . "]\n"; |
Andy Whitcroft | 13214ad | 2008-02-08 04:22:03 -0800 | [diff] [blame] | 1149 | } |
| 1150 | |
Andy Whitcroft | 8905a67 | 2007-11-28 16:21:06 -0800 | [diff] [blame] | 1151 | if (($type eq '' || $type eq '(') && $c eq '(') { |
| 1152 | $level++; |
| 1153 | $type = '('; |
| 1154 | } |
| 1155 | if ($type eq '(' && $c eq ')') { |
| 1156 | $level--; |
| 1157 | $type = ($level != 0)? '(' : ''; |
| 1158 | |
| 1159 | if ($level == 0 && $coff < $soff) { |
| 1160 | $coff = $off; |
Andy Whitcroft | 773647a | 2008-03-28 14:15:58 -0700 | [diff] [blame] | 1161 | $coff_set = 1; |
| 1162 | #warn "CSB: mark coff<$coff>\n"; |
Andy Whitcroft | 8905a67 | 2007-11-28 16:21:06 -0800 | [diff] [blame] | 1163 | } |
| 1164 | } |
| 1165 | if (($type eq '' || $type eq '{') && $c eq '{') { |
| 1166 | $level++; |
| 1167 | $type = '{'; |
| 1168 | } |
| 1169 | if ($type eq '{' && $c eq '}') { |
| 1170 | $level--; |
| 1171 | $type = ($level != 0)? '{' : ''; |
| 1172 | |
| 1173 | if ($level == 0) { |
Patrick Pannuto | b998e00 | 2010-08-09 17:21:03 -0700 | [diff] [blame] | 1174 | if (substr($blk, $off + 1, 1) eq ';') { |
| 1175 | $off++; |
| 1176 | } |
Andy Whitcroft | 8905a67 | 2007-11-28 16:21:06 -0800 | [diff] [blame] | 1177 | last; |
| 1178 | } |
| 1179 | } |
Andy Whitcroft | f74bd19 | 2012-01-10 15:09:54 -0800 | [diff] [blame] | 1180 | # Preprocessor commands end at the newline unless escaped. |
| 1181 | if ($type eq '#' && $c eq "\n" && $p ne "\\") { |
| 1182 | $level--; |
| 1183 | $type = ''; |
| 1184 | $off++; |
| 1185 | last; |
| 1186 | } |
Andy Whitcroft | 8905a67 | 2007-11-28 16:21:06 -0800 | [diff] [blame] | 1187 | $off++; |
| 1188 | } |
Andy Whitcroft | a3bb97a | 2008-07-23 21:29:00 -0700 | [diff] [blame] | 1189 | # We are truly at the end, so shuffle to the next line. |
Andy Whitcroft | 13214ad | 2008-02-08 04:22:03 -0800 | [diff] [blame] | 1190 | if ($off == $len) { |
Andy Whitcroft | a3bb97a | 2008-07-23 21:29:00 -0700 | [diff] [blame] | 1191 | $loff = $len + 1; |
Andy Whitcroft | 13214ad | 2008-02-08 04:22:03 -0800 | [diff] [blame] | 1192 | $line++; |
| 1193 | $remain--; |
| 1194 | } |
Andy Whitcroft | 8905a67 | 2007-11-28 16:21:06 -0800 | [diff] [blame] | 1195 | |
| 1196 | my $statement = substr($blk, $soff, $off - $soff + 1); |
| 1197 | my $condition = substr($blk, $soff, $coff - $soff + 1); |
| 1198 | |
| 1199 | #warn "STATEMENT<$statement>\n"; |
| 1200 | #warn "CONDITION<$condition>\n"; |
| 1201 | |
Andy Whitcroft | 773647a | 2008-03-28 14:15:58 -0700 | [diff] [blame] | 1202 | #print "coff<$coff> soff<$off> loff<$loff>\n"; |
Andy Whitcroft | 13214ad | 2008-02-08 04:22:03 -0800 | [diff] [blame] | 1203 | |
| 1204 | return ($statement, $condition, |
| 1205 | $line, $remain + 1, $off - $loff + 1, $level); |
| 1206 | } |
| 1207 | |
Andy Whitcroft | cf65504 | 2008-03-04 14:28:20 -0800 | [diff] [blame] | 1208 | sub statement_lines { |
| 1209 | my ($stmt) = @_; |
| 1210 | |
| 1211 | # Strip the diff line prefixes and rip blank lines at start and end. |
| 1212 | $stmt =~ s/(^|\n)./$1/g; |
| 1213 | $stmt =~ s/^\s*//; |
| 1214 | $stmt =~ s/\s*$//; |
| 1215 | |
| 1216 | my @stmt_lines = ($stmt =~ /\n/g); |
| 1217 | |
| 1218 | return $#stmt_lines + 2; |
| 1219 | } |
| 1220 | |
| 1221 | sub statement_rawlines { |
| 1222 | my ($stmt) = @_; |
| 1223 | |
| 1224 | my @stmt_lines = ($stmt =~ /\n/g); |
| 1225 | |
| 1226 | return $#stmt_lines + 2; |
| 1227 | } |
| 1228 | |
| 1229 | sub statement_block_size { |
| 1230 | my ($stmt) = @_; |
| 1231 | |
| 1232 | $stmt =~ s/(^|\n)./$1/g; |
| 1233 | $stmt =~ s/^\s*{//; |
| 1234 | $stmt =~ s/}\s*$//; |
| 1235 | $stmt =~ s/^\s*//; |
| 1236 | $stmt =~ s/\s*$//; |
| 1237 | |
| 1238 | my @stmt_lines = ($stmt =~ /\n/g); |
| 1239 | my @stmt_statements = ($stmt =~ /;/g); |
| 1240 | |
| 1241 | my $stmt_lines = $#stmt_lines + 2; |
| 1242 | my $stmt_statements = $#stmt_statements + 1; |
| 1243 | |
| 1244 | if ($stmt_lines > $stmt_statements) { |
| 1245 | return $stmt_lines; |
| 1246 | } else { |
| 1247 | return $stmt_statements; |
| 1248 | } |
| 1249 | } |
| 1250 | |
Andy Whitcroft | 13214ad | 2008-02-08 04:22:03 -0800 | [diff] [blame] | 1251 | sub ctx_statement_full { |
| 1252 | my ($linenr, $remain, $off) = @_; |
| 1253 | my ($statement, $condition, $level); |
| 1254 | |
| 1255 | my (@chunks); |
| 1256 | |
Andy Whitcroft | cf65504 | 2008-03-04 14:28:20 -0800 | [diff] [blame] | 1257 | # Grab the first conditional/block pair. |
Andy Whitcroft | 13214ad | 2008-02-08 04:22:03 -0800 | [diff] [blame] | 1258 | ($statement, $condition, $linenr, $remain, $off, $level) = |
| 1259 | ctx_statement_block($linenr, $remain, $off); |
Andy Whitcroft | 773647a | 2008-03-28 14:15:58 -0700 | [diff] [blame] | 1260 | #print "F: c<$condition> s<$statement> remain<$remain>\n"; |
Andy Whitcroft | cf65504 | 2008-03-04 14:28:20 -0800 | [diff] [blame] | 1261 | push(@chunks, [ $condition, $statement ]); |
| 1262 | if (!($remain > 0 && $condition =~ /^\s*(?:\n[+-])?\s*(?:if|else|do)\b/s)) { |
| 1263 | return ($level, $linenr, @chunks); |
| 1264 | } |
| 1265 | |
| 1266 | # Pull in the following conditional/block pairs and see if they |
| 1267 | # could continue the statement. |
Andy Whitcroft | 13214ad | 2008-02-08 04:22:03 -0800 | [diff] [blame] | 1268 | for (;;) { |
Andy Whitcroft | 13214ad | 2008-02-08 04:22:03 -0800 | [diff] [blame] | 1269 | ($statement, $condition, $linenr, $remain, $off, $level) = |
| 1270 | ctx_statement_block($linenr, $remain, $off); |
Andy Whitcroft | cf65504 | 2008-03-04 14:28:20 -0800 | [diff] [blame] | 1271 | #print "C: c<$condition> s<$statement> remain<$remain>\n"; |
Andy Whitcroft | 773647a | 2008-03-28 14:15:58 -0700 | [diff] [blame] | 1272 | last if (!($remain > 0 && $condition =~ /^(?:\s*\n[+-])*\s*(?:else|do)\b/s)); |
Andy Whitcroft | cf65504 | 2008-03-04 14:28:20 -0800 | [diff] [blame] | 1273 | #print "C: push\n"; |
| 1274 | push(@chunks, [ $condition, $statement ]); |
Andy Whitcroft | 13214ad | 2008-02-08 04:22:03 -0800 | [diff] [blame] | 1275 | } |
| 1276 | |
| 1277 | return ($level, $linenr, @chunks); |
Andy Whitcroft | 8905a67 | 2007-11-28 16:21:06 -0800 | [diff] [blame] | 1278 | } |
| 1279 | |
Andy Whitcroft | 4a0df2e | 2007-06-08 13:46:39 -0700 | [diff] [blame] | 1280 | sub ctx_block_get { |
Andy Whitcroft | f0a594c | 2007-07-19 01:48:34 -0700 | [diff] [blame] | 1281 | my ($linenr, $remain, $outer, $open, $close, $off) = @_; |
Andy Whitcroft | 4a0df2e | 2007-06-08 13:46:39 -0700 | [diff] [blame] | 1282 | my $line; |
| 1283 | my $start = $linenr - 1; |
Andy Whitcroft | 4a0df2e | 2007-06-08 13:46:39 -0700 | [diff] [blame] | 1284 | my $blk = ''; |
| 1285 | my @o; |
| 1286 | my @c; |
| 1287 | my @res = (); |
| 1288 | |
Andy Whitcroft | f0a594c | 2007-07-19 01:48:34 -0700 | [diff] [blame] | 1289 | my $level = 0; |
Andy Whitcroft | 4635f4f | 2009-01-06 14:41:27 -0800 | [diff] [blame] | 1290 | my @stack = ($level); |
Andy Whitcroft | 00df344 | 2007-06-08 13:47:06 -0700 | [diff] [blame] | 1291 | for ($line = $start; $remain > 0; $line++) { |
| 1292 | next if ($rawlines[$line] =~ /^-/); |
| 1293 | $remain--; |
| 1294 | |
| 1295 | $blk .= $rawlines[$line]; |
Andy Whitcroft | 4635f4f | 2009-01-06 14:41:27 -0800 | [diff] [blame] | 1296 | |
| 1297 | # Handle nested #if/#else. |
Andy Whitcroft | 01464f3 | 2010-10-26 14:23:19 -0700 | [diff] [blame] | 1298 | if ($lines[$line] =~ /^.\s*#\s*(?:ifndef|ifdef|if)\s/) { |
Andy Whitcroft | 4635f4f | 2009-01-06 14:41:27 -0800 | [diff] [blame] | 1299 | push(@stack, $level); |
Andy Whitcroft | 01464f3 | 2010-10-26 14:23:19 -0700 | [diff] [blame] | 1300 | } elsif ($lines[$line] =~ /^.\s*#\s*(?:else|elif)\b/) { |
Andy Whitcroft | 4635f4f | 2009-01-06 14:41:27 -0800 | [diff] [blame] | 1301 | $level = $stack[$#stack - 1]; |
Andy Whitcroft | 01464f3 | 2010-10-26 14:23:19 -0700 | [diff] [blame] | 1302 | } elsif ($lines[$line] =~ /^.\s*#\s*endif\b/) { |
Andy Whitcroft | 4635f4f | 2009-01-06 14:41:27 -0800 | [diff] [blame] | 1303 | $level = pop(@stack); |
| 1304 | } |
| 1305 | |
Andy Whitcroft | 01464f3 | 2010-10-26 14:23:19 -0700 | [diff] [blame] | 1306 | foreach my $c (split(//, $lines[$line])) { |
Andy Whitcroft | f0a594c | 2007-07-19 01:48:34 -0700 | [diff] [blame] | 1307 | ##print "C<$c>L<$level><$open$close>O<$off>\n"; |
| 1308 | if ($off > 0) { |
| 1309 | $off--; |
| 1310 | next; |
| 1311 | } |
Andy Whitcroft | 4a0df2e | 2007-06-08 13:46:39 -0700 | [diff] [blame] | 1312 | |
Andy Whitcroft | f0a594c | 2007-07-19 01:48:34 -0700 | [diff] [blame] | 1313 | if ($c eq $close && $level > 0) { |
| 1314 | $level--; |
| 1315 | last if ($level == 0); |
| 1316 | } elsif ($c eq $open) { |
| 1317 | $level++; |
| 1318 | } |
| 1319 | } |
Andy Whitcroft | 4a0df2e | 2007-06-08 13:46:39 -0700 | [diff] [blame] | 1320 | |
Andy Whitcroft | f0a594c | 2007-07-19 01:48:34 -0700 | [diff] [blame] | 1321 | if (!$outer || $level <= 1) { |
Andy Whitcroft | 00df344 | 2007-06-08 13:47:06 -0700 | [diff] [blame] | 1322 | push(@res, $rawlines[$line]); |
Andy Whitcroft | 4a0df2e | 2007-06-08 13:46:39 -0700 | [diff] [blame] | 1323 | } |
| 1324 | |
Andy Whitcroft | f0a594c | 2007-07-19 01:48:34 -0700 | [diff] [blame] | 1325 | last if ($level == 0); |
Andy Whitcroft | 4a0df2e | 2007-06-08 13:46:39 -0700 | [diff] [blame] | 1326 | } |
| 1327 | |
Andy Whitcroft | f0a594c | 2007-07-19 01:48:34 -0700 | [diff] [blame] | 1328 | return ($level, @res); |
Andy Whitcroft | 4a0df2e | 2007-06-08 13:46:39 -0700 | [diff] [blame] | 1329 | } |
| 1330 | sub ctx_block_outer { |
| 1331 | my ($linenr, $remain) = @_; |
| 1332 | |
Andy Whitcroft | f0a594c | 2007-07-19 01:48:34 -0700 | [diff] [blame] | 1333 | my ($level, @r) = ctx_block_get($linenr, $remain, 1, '{', '}', 0); |
| 1334 | return @r; |
Andy Whitcroft | 4a0df2e | 2007-06-08 13:46:39 -0700 | [diff] [blame] | 1335 | } |
| 1336 | sub ctx_block { |
| 1337 | my ($linenr, $remain) = @_; |
| 1338 | |
Andy Whitcroft | f0a594c | 2007-07-19 01:48:34 -0700 | [diff] [blame] | 1339 | my ($level, @r) = ctx_block_get($linenr, $remain, 0, '{', '}', 0); |
| 1340 | return @r; |
Andy Whitcroft | 653d487 | 2007-06-23 17:16:34 -0700 | [diff] [blame] | 1341 | } |
| 1342 | sub ctx_statement { |
Andy Whitcroft | f0a594c | 2007-07-19 01:48:34 -0700 | [diff] [blame] | 1343 | my ($linenr, $remain, $off) = @_; |
| 1344 | |
| 1345 | my ($level, @r) = ctx_block_get($linenr, $remain, 0, '(', ')', $off); |
| 1346 | return @r; |
| 1347 | } |
| 1348 | sub ctx_block_level { |
Andy Whitcroft | 653d487 | 2007-06-23 17:16:34 -0700 | [diff] [blame] | 1349 | my ($linenr, $remain) = @_; |
| 1350 | |
Andy Whitcroft | f0a594c | 2007-07-19 01:48:34 -0700 | [diff] [blame] | 1351 | return ctx_block_get($linenr, $remain, 0, '{', '}', 0); |
Andy Whitcroft | 4a0df2e | 2007-06-08 13:46:39 -0700 | [diff] [blame] | 1352 | } |
Andy Whitcroft | 9c0ca6f | 2007-10-16 23:29:38 -0700 | [diff] [blame] | 1353 | sub ctx_statement_level { |
| 1354 | my ($linenr, $remain, $off) = @_; |
| 1355 | |
| 1356 | return ctx_block_get($linenr, $remain, 0, '(', ')', $off); |
| 1357 | } |
Andy Whitcroft | 4a0df2e | 2007-06-08 13:46:39 -0700 | [diff] [blame] | 1358 | |
| 1359 | sub ctx_locate_comment { |
| 1360 | my ($first_line, $end_line) = @_; |
| 1361 | |
| 1362 | # Catch a comment on the end of the line itself. |
Andy Whitcroft | beae633 | 2008-07-23 21:28:59 -0700 | [diff] [blame] | 1363 | my ($current_comment) = ($rawlines[$end_line - 1] =~ m@.*(/\*.*\*/)\s*(?:\\\s*)?$@); |
Andy Whitcroft | 4a0df2e | 2007-06-08 13:46:39 -0700 | [diff] [blame] | 1364 | return $current_comment if (defined $current_comment); |
| 1365 | |
| 1366 | # Look through the context and try and figure out if there is a |
| 1367 | # comment. |
| 1368 | my $in_comment = 0; |
| 1369 | $current_comment = ''; |
| 1370 | for (my $linenr = $first_line; $linenr < $end_line; $linenr++) { |
Andy Whitcroft | 00df344 | 2007-06-08 13:47:06 -0700 | [diff] [blame] | 1371 | my $line = $rawlines[$linenr - 1]; |
| 1372 | #warn " $line\n"; |
Andy Whitcroft | 4a0df2e | 2007-06-08 13:46:39 -0700 | [diff] [blame] | 1373 | if ($linenr == $first_line and $line =~ m@^.\s*\*@) { |
| 1374 | $in_comment = 1; |
| 1375 | } |
| 1376 | if ($line =~ m@/\*@) { |
| 1377 | $in_comment = 1; |
| 1378 | } |
| 1379 | if (!$in_comment && $current_comment ne '') { |
| 1380 | $current_comment = ''; |
| 1381 | } |
| 1382 | $current_comment .= $line . "\n" if ($in_comment); |
| 1383 | if ($line =~ m@\*/@) { |
| 1384 | $in_comment = 0; |
| 1385 | } |
| 1386 | } |
| 1387 | |
| 1388 | chomp($current_comment); |
| 1389 | return($current_comment); |
| 1390 | } |
| 1391 | sub ctx_has_comment { |
| 1392 | my ($first_line, $end_line) = @_; |
| 1393 | my $cmt = ctx_locate_comment($first_line, $end_line); |
| 1394 | |
Andy Whitcroft | 00df344 | 2007-06-08 13:47:06 -0700 | [diff] [blame] | 1395 | ##print "LINE: $rawlines[$end_line - 1 ]\n"; |
Andy Whitcroft | 4a0df2e | 2007-06-08 13:46:39 -0700 | [diff] [blame] | 1396 | ##print "CMMT: $cmt\n"; |
| 1397 | |
| 1398 | return ($cmt ne ''); |
| 1399 | } |
| 1400 | |
Andy Whitcroft | 4d001e4 | 2008-10-15 22:02:21 -0700 | [diff] [blame] | 1401 | sub raw_line { |
| 1402 | my ($linenr, $cnt) = @_; |
| 1403 | |
| 1404 | my $offset = $linenr - 1; |
| 1405 | $cnt++; |
| 1406 | |
| 1407 | my $line; |
| 1408 | while ($cnt) { |
| 1409 | $line = $rawlines[$offset++]; |
| 1410 | next if (defined($line) && $line =~ /^-/); |
| 1411 | $cnt--; |
| 1412 | } |
| 1413 | |
| 1414 | return $line; |
| 1415 | } |
| 1416 | |
Andy Whitcroft | 0a920b5 | 2007-06-01 00:46:48 -0700 | [diff] [blame] | 1417 | sub cat_vet { |
| 1418 | my ($vet) = @_; |
Andy Whitcroft | 9c0ca6f | 2007-10-16 23:29:38 -0700 | [diff] [blame] | 1419 | my ($res, $coded); |
Andy Whitcroft | 0a920b5 | 2007-06-01 00:46:48 -0700 | [diff] [blame] | 1420 | |
Andy Whitcroft | 9c0ca6f | 2007-10-16 23:29:38 -0700 | [diff] [blame] | 1421 | $res = ''; |
Andy Whitcroft | 6c72ffa | 2007-10-18 03:05:08 -0700 | [diff] [blame] | 1422 | while ($vet =~ /([^[:cntrl:]]*)([[:cntrl:]]|$)/g) { |
| 1423 | $res .= $1; |
| 1424 | if ($2 ne '') { |
| 1425 | $coded = sprintf("^%c", unpack('C', $2) + 64); |
| 1426 | $res .= $coded; |
| 1427 | } |
Andy Whitcroft | 9c0ca6f | 2007-10-16 23:29:38 -0700 | [diff] [blame] | 1428 | } |
| 1429 | $res =~ s/$/\$/; |
Andy Whitcroft | 0a920b5 | 2007-06-01 00:46:48 -0700 | [diff] [blame] | 1430 | |
Andy Whitcroft | 9c0ca6f | 2007-10-16 23:29:38 -0700 | [diff] [blame] | 1431 | return $res; |
Andy Whitcroft | 0a920b5 | 2007-06-01 00:46:48 -0700 | [diff] [blame] | 1432 | } |
| 1433 | |
Andy Whitcroft | c2fdda0 | 2008-02-08 04:20:54 -0800 | [diff] [blame] | 1434 | my $av_preprocessor = 0; |
Andy Whitcroft | cf65504 | 2008-03-04 14:28:20 -0800 | [diff] [blame] | 1435 | my $av_pending; |
Andy Whitcroft | c2fdda0 | 2008-02-08 04:20:54 -0800 | [diff] [blame] | 1436 | my @av_paren_type; |
Andy Whitcroft | 1f65f94 | 2008-07-23 21:29:10 -0700 | [diff] [blame] | 1437 | my $av_pend_colon; |
Andy Whitcroft | c2fdda0 | 2008-02-08 04:20:54 -0800 | [diff] [blame] | 1438 | |
| 1439 | sub annotate_reset { |
| 1440 | $av_preprocessor = 0; |
Andy Whitcroft | cf65504 | 2008-03-04 14:28:20 -0800 | [diff] [blame] | 1441 | $av_pending = '_'; |
| 1442 | @av_paren_type = ('E'); |
Andy Whitcroft | 1f65f94 | 2008-07-23 21:29:10 -0700 | [diff] [blame] | 1443 | $av_pend_colon = 'O'; |
Andy Whitcroft | c2fdda0 | 2008-02-08 04:20:54 -0800 | [diff] [blame] | 1444 | } |
| 1445 | |
Andy Whitcroft | 6c72ffa | 2007-10-18 03:05:08 -0700 | [diff] [blame] | 1446 | sub annotate_values { |
| 1447 | my ($stream, $type) = @_; |
| 1448 | |
| 1449 | my $res; |
Andy Whitcroft | 1f65f94 | 2008-07-23 21:29:10 -0700 | [diff] [blame] | 1450 | my $var = '_' x length($stream); |
Andy Whitcroft | 6c72ffa | 2007-10-18 03:05:08 -0700 | [diff] [blame] | 1451 | my $cur = $stream; |
| 1452 | |
Andy Whitcroft | c2fdda0 | 2008-02-08 04:20:54 -0800 | [diff] [blame] | 1453 | print "$stream\n" if ($dbg_values > 1); |
Andy Whitcroft | 6c72ffa | 2007-10-18 03:05:08 -0700 | [diff] [blame] | 1454 | |
Andy Whitcroft | 6c72ffa | 2007-10-18 03:05:08 -0700 | [diff] [blame] | 1455 | while (length($cur)) { |
Andy Whitcroft | 773647a | 2008-03-28 14:15:58 -0700 | [diff] [blame] | 1456 | @av_paren_type = ('E') if ($#av_paren_type < 0); |
Andy Whitcroft | cf65504 | 2008-03-04 14:28:20 -0800 | [diff] [blame] | 1457 | print " <" . join('', @av_paren_type) . |
Andy Whitcroft | 171ae1a | 2008-04-29 00:59:32 -0700 | [diff] [blame] | 1458 | "> <$type> <$av_pending>" if ($dbg_values > 1); |
Andy Whitcroft | 6c72ffa | 2007-10-18 03:05:08 -0700 | [diff] [blame] | 1459 | if ($cur =~ /^(\s+)/o) { |
Andy Whitcroft | c2fdda0 | 2008-02-08 04:20:54 -0800 | [diff] [blame] | 1460 | print "WS($1)\n" if ($dbg_values > 1); |
| 1461 | if ($1 =~ /\n/ && $av_preprocessor) { |
Andy Whitcroft | cf65504 | 2008-03-04 14:28:20 -0800 | [diff] [blame] | 1462 | $type = pop(@av_paren_type); |
Andy Whitcroft | c2fdda0 | 2008-02-08 04:20:54 -0800 | [diff] [blame] | 1463 | $av_preprocessor = 0; |
Andy Whitcroft | 6c72ffa | 2007-10-18 03:05:08 -0700 | [diff] [blame] | 1464 | } |
| 1465 | |
Florian Mickler | c023e473 | 2011-01-12 16:59:58 -0800 | [diff] [blame] | 1466 | } elsif ($cur =~ /^(\(\s*$Type\s*)\)/ && $av_pending eq '_') { |
Andy Whitcroft | 9446ef5 | 2010-10-26 14:23:13 -0700 | [diff] [blame] | 1467 | print "CAST($1)\n" if ($dbg_values > 1); |
| 1468 | push(@av_paren_type, $type); |
Andy Whitcroft | addcdce | 2012-01-10 15:10:11 -0800 | [diff] [blame] | 1469 | $type = 'c'; |
Andy Whitcroft | 9446ef5 | 2010-10-26 14:23:13 -0700 | [diff] [blame] | 1470 | |
Andy Whitcroft | e91b6e2 | 2010-10-26 14:23:11 -0700 | [diff] [blame] | 1471 | } elsif ($cur =~ /^($Type)\s*(?:$Ident|,|\)|\(|\s*$)/) { |
Andy Whitcroft | c2fdda0 | 2008-02-08 04:20:54 -0800 | [diff] [blame] | 1472 | print "DECLARE($1)\n" if ($dbg_values > 1); |
Andy Whitcroft | 6c72ffa | 2007-10-18 03:05:08 -0700 | [diff] [blame] | 1473 | $type = 'T'; |
| 1474 | |
Andy Whitcroft | 389a2fe | 2008-07-23 21:29:05 -0700 | [diff] [blame] | 1475 | } elsif ($cur =~ /^($Modifier)\s*/) { |
| 1476 | print "MODIFIER($1)\n" if ($dbg_values > 1); |
| 1477 | $type = 'T'; |
| 1478 | |
Andy Whitcroft | c45dcab | 2008-06-05 22:46:01 -0700 | [diff] [blame] | 1479 | } elsif ($cur =~ /^(\#\s*define\s*$Ident)(\(?)/o) { |
Andy Whitcroft | 171ae1a | 2008-04-29 00:59:32 -0700 | [diff] [blame] | 1480 | print "DEFINE($1,$2)\n" if ($dbg_values > 1); |
Andy Whitcroft | c2fdda0 | 2008-02-08 04:20:54 -0800 | [diff] [blame] | 1481 | $av_preprocessor = 1; |
Andy Whitcroft | 171ae1a | 2008-04-29 00:59:32 -0700 | [diff] [blame] | 1482 | push(@av_paren_type, $type); |
| 1483 | if ($2 ne '') { |
| 1484 | $av_pending = 'N'; |
| 1485 | } |
| 1486 | $type = 'E'; |
| 1487 | |
Andy Whitcroft | c45dcab | 2008-06-05 22:46:01 -0700 | [diff] [blame] | 1488 | } elsif ($cur =~ /^(\#\s*(?:undef\s*$Ident|include\b))/o) { |
Andy Whitcroft | 171ae1a | 2008-04-29 00:59:32 -0700 | [diff] [blame] | 1489 | print "UNDEF($1)\n" if ($dbg_values > 1); |
| 1490 | $av_preprocessor = 1; |
| 1491 | push(@av_paren_type, $type); |
Andy Whitcroft | 6c72ffa | 2007-10-18 03:05:08 -0700 | [diff] [blame] | 1492 | |
Andy Whitcroft | c45dcab | 2008-06-05 22:46:01 -0700 | [diff] [blame] | 1493 | } elsif ($cur =~ /^(\#\s*(?:ifdef|ifndef|if))/o) { |
Andy Whitcroft | cf65504 | 2008-03-04 14:28:20 -0800 | [diff] [blame] | 1494 | print "PRE_START($1)\n" if ($dbg_values > 1); |
Andy Whitcroft | c2fdda0 | 2008-02-08 04:20:54 -0800 | [diff] [blame] | 1495 | $av_preprocessor = 1; |
Andy Whitcroft | cf65504 | 2008-03-04 14:28:20 -0800 | [diff] [blame] | 1496 | |
| 1497 | push(@av_paren_type, $type); |
| 1498 | push(@av_paren_type, $type); |
Andy Whitcroft | 171ae1a | 2008-04-29 00:59:32 -0700 | [diff] [blame] | 1499 | $type = 'E'; |
Andy Whitcroft | cf65504 | 2008-03-04 14:28:20 -0800 | [diff] [blame] | 1500 | |
Andy Whitcroft | c45dcab | 2008-06-05 22:46:01 -0700 | [diff] [blame] | 1501 | } elsif ($cur =~ /^(\#\s*(?:else|elif))/o) { |
Andy Whitcroft | cf65504 | 2008-03-04 14:28:20 -0800 | [diff] [blame] | 1502 | print "PRE_RESTART($1)\n" if ($dbg_values > 1); |
| 1503 | $av_preprocessor = 1; |
| 1504 | |
| 1505 | push(@av_paren_type, $av_paren_type[$#av_paren_type]); |
| 1506 | |
Andy Whitcroft | 171ae1a | 2008-04-29 00:59:32 -0700 | [diff] [blame] | 1507 | $type = 'E'; |
Andy Whitcroft | cf65504 | 2008-03-04 14:28:20 -0800 | [diff] [blame] | 1508 | |
Andy Whitcroft | c45dcab | 2008-06-05 22:46:01 -0700 | [diff] [blame] | 1509 | } elsif ($cur =~ /^(\#\s*(?:endif))/o) { |
Andy Whitcroft | cf65504 | 2008-03-04 14:28:20 -0800 | [diff] [blame] | 1510 | print "PRE_END($1)\n" if ($dbg_values > 1); |
| 1511 | |
| 1512 | $av_preprocessor = 1; |
| 1513 | |
| 1514 | # Assume all arms of the conditional end as this |
| 1515 | # one does, and continue as if the #endif was not here. |
| 1516 | pop(@av_paren_type); |
| 1517 | push(@av_paren_type, $type); |
Andy Whitcroft | 171ae1a | 2008-04-29 00:59:32 -0700 | [diff] [blame] | 1518 | $type = 'E'; |
Andy Whitcroft | 6c72ffa | 2007-10-18 03:05:08 -0700 | [diff] [blame] | 1519 | |
| 1520 | } elsif ($cur =~ /^(\\\n)/o) { |
Andy Whitcroft | c2fdda0 | 2008-02-08 04:20:54 -0800 | [diff] [blame] | 1521 | print "PRECONT($1)\n" if ($dbg_values > 1); |
Andy Whitcroft | 6c72ffa | 2007-10-18 03:05:08 -0700 | [diff] [blame] | 1522 | |
Andy Whitcroft | 171ae1a | 2008-04-29 00:59:32 -0700 | [diff] [blame] | 1523 | } elsif ($cur =~ /^(__attribute__)\s*\(?/o) { |
| 1524 | print "ATTR($1)\n" if ($dbg_values > 1); |
| 1525 | $av_pending = $type; |
| 1526 | $type = 'N'; |
| 1527 | |
Andy Whitcroft | 6c72ffa | 2007-10-18 03:05:08 -0700 | [diff] [blame] | 1528 | } elsif ($cur =~ /^(sizeof)\s*(\()?/o) { |
Andy Whitcroft | c2fdda0 | 2008-02-08 04:20:54 -0800 | [diff] [blame] | 1529 | print "SIZEOF($1)\n" if ($dbg_values > 1); |
Andy Whitcroft | 6c72ffa | 2007-10-18 03:05:08 -0700 | [diff] [blame] | 1530 | if (defined $2) { |
Andy Whitcroft | cf65504 | 2008-03-04 14:28:20 -0800 | [diff] [blame] | 1531 | $av_pending = 'V'; |
Andy Whitcroft | 6c72ffa | 2007-10-18 03:05:08 -0700 | [diff] [blame] | 1532 | } |
| 1533 | $type = 'N'; |
| 1534 | |
Andy Whitcroft | 14b111c | 2008-10-15 22:02:16 -0700 | [diff] [blame] | 1535 | } elsif ($cur =~ /^(if|while|for)\b/o) { |
Andy Whitcroft | c2fdda0 | 2008-02-08 04:20:54 -0800 | [diff] [blame] | 1536 | print "COND($1)\n" if ($dbg_values > 1); |
Andy Whitcroft | 14b111c | 2008-10-15 22:02:16 -0700 | [diff] [blame] | 1537 | $av_pending = 'E'; |
Andy Whitcroft | 6c72ffa | 2007-10-18 03:05:08 -0700 | [diff] [blame] | 1538 | $type = 'N'; |
| 1539 | |
Andy Whitcroft | 1f65f94 | 2008-07-23 21:29:10 -0700 | [diff] [blame] | 1540 | } elsif ($cur =~/^(case)/o) { |
| 1541 | print "CASE($1)\n" if ($dbg_values > 1); |
| 1542 | $av_pend_colon = 'C'; |
| 1543 | $type = 'N'; |
| 1544 | |
Andy Whitcroft | 14b111c | 2008-10-15 22:02:16 -0700 | [diff] [blame] | 1545 | } elsif ($cur =~/^(return|else|goto|typeof|__typeof__)\b/o) { |
Andy Whitcroft | c2fdda0 | 2008-02-08 04:20:54 -0800 | [diff] [blame] | 1546 | print "KEYWORD($1)\n" if ($dbg_values > 1); |
Andy Whitcroft | 6c72ffa | 2007-10-18 03:05:08 -0700 | [diff] [blame] | 1547 | $type = 'N'; |
| 1548 | |
| 1549 | } elsif ($cur =~ /^(\()/o) { |
Andy Whitcroft | c2fdda0 | 2008-02-08 04:20:54 -0800 | [diff] [blame] | 1550 | print "PAREN('$1')\n" if ($dbg_values > 1); |
Andy Whitcroft | cf65504 | 2008-03-04 14:28:20 -0800 | [diff] [blame] | 1551 | push(@av_paren_type, $av_pending); |
| 1552 | $av_pending = '_'; |
Andy Whitcroft | 6c72ffa | 2007-10-18 03:05:08 -0700 | [diff] [blame] | 1553 | $type = 'N'; |
| 1554 | |
| 1555 | } elsif ($cur =~ /^(\))/o) { |
Andy Whitcroft | cf65504 | 2008-03-04 14:28:20 -0800 | [diff] [blame] | 1556 | my $new_type = pop(@av_paren_type); |
| 1557 | if ($new_type ne '_') { |
| 1558 | $type = $new_type; |
Andy Whitcroft | c2fdda0 | 2008-02-08 04:20:54 -0800 | [diff] [blame] | 1559 | print "PAREN('$1') -> $type\n" |
| 1560 | if ($dbg_values > 1); |
Andy Whitcroft | 6c72ffa | 2007-10-18 03:05:08 -0700 | [diff] [blame] | 1561 | } else { |
Andy Whitcroft | c2fdda0 | 2008-02-08 04:20:54 -0800 | [diff] [blame] | 1562 | print "PAREN('$1')\n" if ($dbg_values > 1); |
Andy Whitcroft | 6c72ffa | 2007-10-18 03:05:08 -0700 | [diff] [blame] | 1563 | } |
| 1564 | |
Andy Whitcroft | c8cb2ca | 2008-07-23 21:28:57 -0700 | [diff] [blame] | 1565 | } elsif ($cur =~ /^($Ident)\s*\(/o) { |
Andy Whitcroft | c2fdda0 | 2008-02-08 04:20:54 -0800 | [diff] [blame] | 1566 | print "FUNC($1)\n" if ($dbg_values > 1); |
Andy Whitcroft | c8cb2ca | 2008-07-23 21:28:57 -0700 | [diff] [blame] | 1567 | $type = 'V'; |
Andy Whitcroft | cf65504 | 2008-03-04 14:28:20 -0800 | [diff] [blame] | 1568 | $av_pending = 'V'; |
Andy Whitcroft | 6c72ffa | 2007-10-18 03:05:08 -0700 | [diff] [blame] | 1569 | |
Andy Whitcroft | 8e761b0 | 2009-01-06 14:41:19 -0800 | [diff] [blame] | 1570 | } elsif ($cur =~ /^($Ident\s*):(?:\s*\d+\s*(,|=|;))?/) { |
| 1571 | if (defined $2 && $type eq 'C' || $type eq 'T') { |
Andy Whitcroft | 1f65f94 | 2008-07-23 21:29:10 -0700 | [diff] [blame] | 1572 | $av_pend_colon = 'B'; |
Andy Whitcroft | 8e761b0 | 2009-01-06 14:41:19 -0800 | [diff] [blame] | 1573 | } elsif ($type eq 'E') { |
| 1574 | $av_pend_colon = 'L'; |
Andy Whitcroft | 1f65f94 | 2008-07-23 21:29:10 -0700 | [diff] [blame] | 1575 | } |
| 1576 | print "IDENT_COLON($1,$type>$av_pend_colon)\n" if ($dbg_values > 1); |
| 1577 | $type = 'V'; |
| 1578 | |
Andy Whitcroft | 6c72ffa | 2007-10-18 03:05:08 -0700 | [diff] [blame] | 1579 | } elsif ($cur =~ /^($Ident|$Constant)/o) { |
Andy Whitcroft | c2fdda0 | 2008-02-08 04:20:54 -0800 | [diff] [blame] | 1580 | print "IDENT($1)\n" if ($dbg_values > 1); |
Andy Whitcroft | 6c72ffa | 2007-10-18 03:05:08 -0700 | [diff] [blame] | 1581 | $type = 'V'; |
| 1582 | |
| 1583 | } elsif ($cur =~ /^($Assignment)/o) { |
Andy Whitcroft | c2fdda0 | 2008-02-08 04:20:54 -0800 | [diff] [blame] | 1584 | print "ASSIGN($1)\n" if ($dbg_values > 1); |
Andy Whitcroft | 6c72ffa | 2007-10-18 03:05:08 -0700 | [diff] [blame] | 1585 | $type = 'N'; |
| 1586 | |
Andy Whitcroft | cf65504 | 2008-03-04 14:28:20 -0800 | [diff] [blame] | 1587 | } elsif ($cur =~/^(;|{|})/) { |
Andy Whitcroft | c2fdda0 | 2008-02-08 04:20:54 -0800 | [diff] [blame] | 1588 | print "END($1)\n" if ($dbg_values > 1); |
Andy Whitcroft | 13214ad | 2008-02-08 04:22:03 -0800 | [diff] [blame] | 1589 | $type = 'E'; |
Andy Whitcroft | 1f65f94 | 2008-07-23 21:29:10 -0700 | [diff] [blame] | 1590 | $av_pend_colon = 'O'; |
Andy Whitcroft | 13214ad | 2008-02-08 04:22:03 -0800 | [diff] [blame] | 1591 | |
Andy Whitcroft | 8e761b0 | 2009-01-06 14:41:19 -0800 | [diff] [blame] | 1592 | } elsif ($cur =~/^(,)/) { |
| 1593 | print "COMMA($1)\n" if ($dbg_values > 1); |
| 1594 | $type = 'C'; |
| 1595 | |
Andy Whitcroft | 1f65f94 | 2008-07-23 21:29:10 -0700 | [diff] [blame] | 1596 | } elsif ($cur =~ /^(\?)/o) { |
| 1597 | print "QUESTION($1)\n" if ($dbg_values > 1); |
| 1598 | $type = 'N'; |
| 1599 | |
| 1600 | } elsif ($cur =~ /^(:)/o) { |
| 1601 | print "COLON($1,$av_pend_colon)\n" if ($dbg_values > 1); |
| 1602 | |
| 1603 | substr($var, length($res), 1, $av_pend_colon); |
| 1604 | if ($av_pend_colon eq 'C' || $av_pend_colon eq 'L') { |
| 1605 | $type = 'E'; |
| 1606 | } else { |
| 1607 | $type = 'N'; |
| 1608 | } |
| 1609 | $av_pend_colon = 'O'; |
| 1610 | |
Andy Whitcroft | 8e761b0 | 2009-01-06 14:41:19 -0800 | [diff] [blame] | 1611 | } elsif ($cur =~ /^(\[)/o) { |
Andy Whitcroft | 13214ad | 2008-02-08 04:22:03 -0800 | [diff] [blame] | 1612 | print "CLOSE($1)\n" if ($dbg_values > 1); |
Andy Whitcroft | 6c72ffa | 2007-10-18 03:05:08 -0700 | [diff] [blame] | 1613 | $type = 'N'; |
| 1614 | |
Andy Whitcroft | 0d41386 | 2008-10-15 22:02:16 -0700 | [diff] [blame] | 1615 | } elsif ($cur =~ /^(-(?![->])|\+(?!\+)|\*|\&\&|\&)/o) { |
Andy Whitcroft | 74048ed | 2008-07-23 21:29:10 -0700 | [diff] [blame] | 1616 | my $variant; |
| 1617 | |
| 1618 | print "OPV($1)\n" if ($dbg_values > 1); |
| 1619 | if ($type eq 'V') { |
| 1620 | $variant = 'B'; |
| 1621 | } else { |
| 1622 | $variant = 'U'; |
| 1623 | } |
| 1624 | |
| 1625 | substr($var, length($res), 1, $variant); |
| 1626 | $type = 'N'; |
| 1627 | |
Andy Whitcroft | 6c72ffa | 2007-10-18 03:05:08 -0700 | [diff] [blame] | 1628 | } elsif ($cur =~ /^($Operators)/o) { |
Andy Whitcroft | c2fdda0 | 2008-02-08 04:20:54 -0800 | [diff] [blame] | 1629 | print "OP($1)\n" if ($dbg_values > 1); |
Andy Whitcroft | 6c72ffa | 2007-10-18 03:05:08 -0700 | [diff] [blame] | 1630 | if ($1 ne '++' && $1 ne '--') { |
| 1631 | $type = 'N'; |
| 1632 | } |
| 1633 | |
| 1634 | } elsif ($cur =~ /(^.)/o) { |
Andy Whitcroft | c2fdda0 | 2008-02-08 04:20:54 -0800 | [diff] [blame] | 1635 | print "C($1)\n" if ($dbg_values > 1); |
Andy Whitcroft | 6c72ffa | 2007-10-18 03:05:08 -0700 | [diff] [blame] | 1636 | } |
| 1637 | if (defined $1) { |
| 1638 | $cur = substr($cur, length($1)); |
| 1639 | $res .= $type x length($1); |
| 1640 | } |
| 1641 | } |
| 1642 | |
Andy Whitcroft | 1f65f94 | 2008-07-23 21:29:10 -0700 | [diff] [blame] | 1643 | return ($res, $var); |
Andy Whitcroft | 6c72ffa | 2007-10-18 03:05:08 -0700 | [diff] [blame] | 1644 | } |
| 1645 | |
Andy Whitcroft | 8905a67 | 2007-11-28 16:21:06 -0800 | [diff] [blame] | 1646 | sub possible { |
Andy Whitcroft | 13214ad | 2008-02-08 04:22:03 -0800 | [diff] [blame] | 1647 | my ($possible, $line) = @_; |
Andy Whitcroft | 9a974fd | 2009-10-26 16:50:12 -0700 | [diff] [blame] | 1648 | my $notPermitted = qr{(?: |
Andy Whitcroft | 0776e59 | 2008-10-15 22:02:29 -0700 | [diff] [blame] | 1649 | ^(?: |
| 1650 | $Modifier| |
| 1651 | $Storage| |
| 1652 | $Type| |
Andy Whitcroft | 9a974fd | 2009-10-26 16:50:12 -0700 | [diff] [blame] | 1653 | DEFINE_\S+ |
| 1654 | )$| |
| 1655 | ^(?: |
Andy Whitcroft | 0776e59 | 2008-10-15 22:02:29 -0700 | [diff] [blame] | 1656 | goto| |
| 1657 | return| |
| 1658 | case| |
| 1659 | else| |
| 1660 | asm|__asm__| |
Andy Whitcroft | 89a8835 | 2012-01-10 15:10:00 -0800 | [diff] [blame] | 1661 | do| |
| 1662 | \#| |
| 1663 | \#\#| |
Andy Whitcroft | 9a974fd | 2009-10-26 16:50:12 -0700 | [diff] [blame] | 1664 | )(?:\s|$)| |
Andy Whitcroft | 0776e59 | 2008-10-15 22:02:29 -0700 | [diff] [blame] | 1665 | ^(?:typedef|struct|enum)\b |
Andy Whitcroft | 9a974fd | 2009-10-26 16:50:12 -0700 | [diff] [blame] | 1666 | )}x; |
| 1667 | warn "CHECK<$possible> ($line)\n" if ($dbg_possible > 2); |
| 1668 | if ($possible !~ $notPermitted) { |
Andy Whitcroft | c45dcab | 2008-06-05 22:46:01 -0700 | [diff] [blame] | 1669 | # Check for modifiers. |
| 1670 | $possible =~ s/\s*$Storage\s*//g; |
| 1671 | $possible =~ s/\s*$Sparse\s*//g; |
| 1672 | if ($possible =~ /^\s*$/) { |
| 1673 | |
| 1674 | } elsif ($possible =~ /\s/) { |
| 1675 | $possible =~ s/\s*$Type\s*//g; |
Andy Whitcroft | d250658 | 2008-07-23 21:29:09 -0700 | [diff] [blame] | 1676 | for my $modifier (split(' ', $possible)) { |
Andy Whitcroft | 9a974fd | 2009-10-26 16:50:12 -0700 | [diff] [blame] | 1677 | if ($modifier !~ $notPermitted) { |
| 1678 | warn "MODIFIER: $modifier ($possible) ($line)\n" if ($dbg_possible); |
Alex Dowad | 485ff23 | 2015-06-25 15:02:52 -0700 | [diff] [blame] | 1679 | push(@modifierListFile, $modifier); |
Andy Whitcroft | 9a974fd | 2009-10-26 16:50:12 -0700 | [diff] [blame] | 1680 | } |
Andy Whitcroft | d250658 | 2008-07-23 21:29:09 -0700 | [diff] [blame] | 1681 | } |
Andy Whitcroft | c45dcab | 2008-06-05 22:46:01 -0700 | [diff] [blame] | 1682 | |
| 1683 | } else { |
| 1684 | warn "POSSIBLE: $possible ($line)\n" if ($dbg_possible); |
Alex Dowad | 485ff23 | 2015-06-25 15:02:52 -0700 | [diff] [blame] | 1685 | push(@typeListFile, $possible); |
Andy Whitcroft | c45dcab | 2008-06-05 22:46:01 -0700 | [diff] [blame] | 1686 | } |
Andy Whitcroft | 8905a67 | 2007-11-28 16:21:06 -0800 | [diff] [blame] | 1687 | build_types(); |
Andy Whitcroft | 0776e59 | 2008-10-15 22:02:29 -0700 | [diff] [blame] | 1688 | } else { |
| 1689 | warn "NOTPOSS: $possible ($line)\n" if ($dbg_possible > 1); |
Andy Whitcroft | 8905a67 | 2007-11-28 16:21:06 -0800 | [diff] [blame] | 1690 | } |
| 1691 | } |
| 1692 | |
Andy Whitcroft | 6c72ffa | 2007-10-18 03:05:08 -0700 | [diff] [blame] | 1693 | my $prefix = ''; |
| 1694 | |
Joe Perches | 000d1cc1 | 2011-07-25 17:13:25 -0700 | [diff] [blame] | 1695 | sub show_type { |
Joe Perches | cbec18a | 2014-04-03 14:49:19 -0700 | [diff] [blame] | 1696 | my ($type) = @_; |
Joe Perches | 91bfe48 | 2013-09-11 14:23:59 -0700 | [diff] [blame] | 1697 | |
Joe Perches | cbec18a | 2014-04-03 14:49:19 -0700 | [diff] [blame] | 1698 | return defined $use_type{$type} if (scalar keys %use_type > 0); |
| 1699 | |
| 1700 | return !defined $ignore_type{$type}; |
Joe Perches | 000d1cc1 | 2011-07-25 17:13:25 -0700 | [diff] [blame] | 1701 | } |
| 1702 | |
Andy Whitcroft | f0a594c | 2007-07-19 01:48:34 -0700 | [diff] [blame] | 1703 | sub report { |
Joe Perches | cbec18a | 2014-04-03 14:49:19 -0700 | [diff] [blame] | 1704 | my ($level, $type, $msg) = @_; |
| 1705 | |
| 1706 | if (!show_type($type) || |
| 1707 | (defined $tst_only && $msg !~ /\Q$tst_only\E/)) { |
Andy Whitcroft | 773647a | 2008-03-28 14:15:58 -0700 | [diff] [blame] | 1708 | return 0; |
| 1709 | } |
Joe Perches | 5723029 | 2015-06-25 15:03:03 -0700 | [diff] [blame] | 1710 | my $output = ''; |
| 1711 | if (-t STDOUT && $color) { |
| 1712 | if ($level eq 'ERROR') { |
| 1713 | $output .= RED; |
| 1714 | } elsif ($level eq 'WARNING') { |
| 1715 | $output .= YELLOW; |
| 1716 | } else { |
| 1717 | $output .= GREEN; |
| 1718 | } |
Joe Perches | 000d1cc1 | 2011-07-25 17:13:25 -0700 | [diff] [blame] | 1719 | } |
Joe Perches | 5723029 | 2015-06-25 15:03:03 -0700 | [diff] [blame] | 1720 | $output .= $prefix . $level . ':'; |
| 1721 | if ($show_types) { |
| 1722 | $output .= BLUE if (-t STDOUT && $color); |
| 1723 | $output .= "$type:"; |
| 1724 | } |
| 1725 | $output .= RESET if (-t STDOUT && $color); |
| 1726 | $output .= ' ' . $msg . "\n"; |
Joe Perches | 34d8815 | 2015-06-25 15:03:05 -0700 | [diff] [blame] | 1727 | |
| 1728 | if ($showfile) { |
| 1729 | my @lines = split("\n", $output, -1); |
| 1730 | splice(@lines, 1, 1); |
| 1731 | $output = join("\n", @lines); |
| 1732 | } |
Joe Perches | 5723029 | 2015-06-25 15:03:03 -0700 | [diff] [blame] | 1733 | $output = (split('\n', $output))[0] . "\n" if ($terse); |
Andy Whitcroft | 8905a67 | 2007-11-28 16:21:06 -0800 | [diff] [blame] | 1734 | |
Joe Perches | 5723029 | 2015-06-25 15:03:03 -0700 | [diff] [blame] | 1735 | push(our @report, $output); |
Andy Whitcroft | 773647a | 2008-03-28 14:15:58 -0700 | [diff] [blame] | 1736 | |
| 1737 | return 1; |
Andy Whitcroft | f0a594c | 2007-07-19 01:48:34 -0700 | [diff] [blame] | 1738 | } |
Joe Perches | cbec18a | 2014-04-03 14:49:19 -0700 | [diff] [blame] | 1739 | |
Andy Whitcroft | f0a594c | 2007-07-19 01:48:34 -0700 | [diff] [blame] | 1740 | sub report_dump { |
Andy Whitcroft | 13214ad | 2008-02-08 04:22:03 -0800 | [diff] [blame] | 1741 | our @report; |
Andy Whitcroft | f0a594c | 2007-07-19 01:48:34 -0700 | [diff] [blame] | 1742 | } |
Joe Perches | 000d1cc1 | 2011-07-25 17:13:25 -0700 | [diff] [blame] | 1743 | |
Joe Perches | d752fcc | 2014-08-06 16:11:05 -0700 | [diff] [blame] | 1744 | sub fixup_current_range { |
| 1745 | my ($lineRef, $offset, $length) = @_; |
| 1746 | |
| 1747 | if ($$lineRef =~ /^\@\@ -\d+,\d+ \+(\d+),(\d+) \@\@/) { |
| 1748 | my $o = $1; |
| 1749 | my $l = $2; |
| 1750 | my $no = $o + $offset; |
| 1751 | my $nl = $l + $length; |
| 1752 | $$lineRef =~ s/\+$o,$l \@\@/\+$no,$nl \@\@/; |
| 1753 | } |
| 1754 | } |
| 1755 | |
| 1756 | sub fix_inserted_deleted_lines { |
| 1757 | my ($linesRef, $insertedRef, $deletedRef) = @_; |
| 1758 | |
| 1759 | my $range_last_linenr = 0; |
| 1760 | my $delta_offset = 0; |
| 1761 | |
| 1762 | my $old_linenr = 0; |
| 1763 | my $new_linenr = 0; |
| 1764 | |
| 1765 | my $next_insert = 0; |
| 1766 | my $next_delete = 0; |
| 1767 | |
| 1768 | my @lines = (); |
| 1769 | |
| 1770 | my $inserted = @{$insertedRef}[$next_insert++]; |
| 1771 | my $deleted = @{$deletedRef}[$next_delete++]; |
| 1772 | |
| 1773 | foreach my $old_line (@{$linesRef}) { |
| 1774 | my $save_line = 1; |
| 1775 | my $line = $old_line; #don't modify the array |
Joe Perches | 323b267 | 2015-04-16 12:44:50 -0700 | [diff] [blame] | 1776 | if ($line =~ /^(?:\+\+\+|\-\-\-)\s+\S+/) { #new filename |
Joe Perches | d752fcc | 2014-08-06 16:11:05 -0700 | [diff] [blame] | 1777 | $delta_offset = 0; |
| 1778 | } elsif ($line =~ /^\@\@ -\d+,\d+ \+\d+,\d+ \@\@/) { #new hunk |
| 1779 | $range_last_linenr = $new_linenr; |
| 1780 | fixup_current_range(\$line, $delta_offset, 0); |
| 1781 | } |
| 1782 | |
| 1783 | while (defined($deleted) && ${$deleted}{'LINENR'} == $old_linenr) { |
| 1784 | $deleted = @{$deletedRef}[$next_delete++]; |
| 1785 | $save_line = 0; |
| 1786 | fixup_current_range(\$lines[$range_last_linenr], $delta_offset--, -1); |
| 1787 | } |
| 1788 | |
| 1789 | while (defined($inserted) && ${$inserted}{'LINENR'} == $old_linenr) { |
| 1790 | push(@lines, ${$inserted}{'LINE'}); |
| 1791 | $inserted = @{$insertedRef}[$next_insert++]; |
| 1792 | $new_linenr++; |
| 1793 | fixup_current_range(\$lines[$range_last_linenr], $delta_offset++, 1); |
| 1794 | } |
| 1795 | |
| 1796 | if ($save_line) { |
| 1797 | push(@lines, $line); |
| 1798 | $new_linenr++; |
| 1799 | } |
| 1800 | |
| 1801 | $old_linenr++; |
| 1802 | } |
| 1803 | |
| 1804 | return @lines; |
| 1805 | } |
| 1806 | |
Joe Perches | f2d7e4d | 2014-08-06 16:11:07 -0700 | [diff] [blame] | 1807 | sub fix_insert_line { |
| 1808 | my ($linenr, $line) = @_; |
| 1809 | |
| 1810 | my $inserted = { |
| 1811 | LINENR => $linenr, |
| 1812 | LINE => $line, |
| 1813 | }; |
| 1814 | push(@fixed_inserted, $inserted); |
| 1815 | } |
| 1816 | |
| 1817 | sub fix_delete_line { |
| 1818 | my ($linenr, $line) = @_; |
| 1819 | |
| 1820 | my $deleted = { |
| 1821 | LINENR => $linenr, |
| 1822 | LINE => $line, |
| 1823 | }; |
| 1824 | |
| 1825 | push(@fixed_deleted, $deleted); |
| 1826 | } |
| 1827 | |
Andy Whitcroft | de7d4f0 | 2007-07-15 23:37:22 -0700 | [diff] [blame] | 1828 | sub ERROR { |
Joe Perches | cbec18a | 2014-04-03 14:49:19 -0700 | [diff] [blame] | 1829 | my ($type, $msg) = @_; |
| 1830 | |
| 1831 | if (report("ERROR", $type, $msg)) { |
Andy Whitcroft | 773647a | 2008-03-28 14:15:58 -0700 | [diff] [blame] | 1832 | our $clean = 0; |
| 1833 | our $cnt_error++; |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 1834 | return 1; |
Andy Whitcroft | 773647a | 2008-03-28 14:15:58 -0700 | [diff] [blame] | 1835 | } |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 1836 | return 0; |
Andy Whitcroft | de7d4f0 | 2007-07-15 23:37:22 -0700 | [diff] [blame] | 1837 | } |
| 1838 | sub WARN { |
Joe Perches | cbec18a | 2014-04-03 14:49:19 -0700 | [diff] [blame] | 1839 | my ($type, $msg) = @_; |
| 1840 | |
| 1841 | if (report("WARNING", $type, $msg)) { |
Andy Whitcroft | 773647a | 2008-03-28 14:15:58 -0700 | [diff] [blame] | 1842 | our $clean = 0; |
| 1843 | our $cnt_warn++; |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 1844 | return 1; |
Andy Whitcroft | 773647a | 2008-03-28 14:15:58 -0700 | [diff] [blame] | 1845 | } |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 1846 | return 0; |
Andy Whitcroft | de7d4f0 | 2007-07-15 23:37:22 -0700 | [diff] [blame] | 1847 | } |
| 1848 | sub CHK { |
Joe Perches | cbec18a | 2014-04-03 14:49:19 -0700 | [diff] [blame] | 1849 | my ($type, $msg) = @_; |
| 1850 | |
| 1851 | if ($check && report("CHECK", $type, $msg)) { |
Andy Whitcroft | 6c72ffa | 2007-10-18 03:05:08 -0700 | [diff] [blame] | 1852 | our $clean = 0; |
| 1853 | our $cnt_chk++; |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 1854 | return 1; |
Andy Whitcroft | 6c72ffa | 2007-10-18 03:05:08 -0700 | [diff] [blame] | 1855 | } |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 1856 | return 0; |
Andy Whitcroft | de7d4f0 | 2007-07-15 23:37:22 -0700 | [diff] [blame] | 1857 | } |
| 1858 | |
Andy Whitcroft | 6ecd967 | 2008-10-15 22:02:21 -0700 | [diff] [blame] | 1859 | sub check_absolute_file { |
| 1860 | my ($absolute, $herecurr) = @_; |
| 1861 | my $file = $absolute; |
| 1862 | |
| 1863 | ##print "absolute<$absolute>\n"; |
| 1864 | |
| 1865 | # See if any suffix of this path is a path within the tree. |
| 1866 | while ($file =~ s@^[^/]*/@@) { |
| 1867 | if (-f "$root/$file") { |
| 1868 | ##print "file<$file>\n"; |
| 1869 | last; |
| 1870 | } |
| 1871 | } |
| 1872 | if (! -f _) { |
| 1873 | return 0; |
| 1874 | } |
| 1875 | |
| 1876 | # It is, so see if the prefix is acceptable. |
| 1877 | my $prefix = $absolute; |
| 1878 | substr($prefix, -length($file)) = ''; |
| 1879 | |
| 1880 | ##print "prefix<$prefix>\n"; |
| 1881 | if ($prefix ne ".../") { |
Joe Perches | 000d1cc1 | 2011-07-25 17:13:25 -0700 | [diff] [blame] | 1882 | WARN("USE_RELATIVE_PATH", |
| 1883 | "use relative pathname instead of absolute in changelog text\n" . $herecurr); |
Andy Whitcroft | 6ecd967 | 2008-10-15 22:02:21 -0700 | [diff] [blame] | 1884 | } |
| 1885 | } |
| 1886 | |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 1887 | sub trim { |
| 1888 | my ($string) = @_; |
| 1889 | |
Joe Perches | b34c648 | 2013-09-11 14:24:01 -0700 | [diff] [blame] | 1890 | $string =~ s/^\s+|\s+$//g; |
| 1891 | |
| 1892 | return $string; |
| 1893 | } |
| 1894 | |
| 1895 | sub ltrim { |
| 1896 | my ($string) = @_; |
| 1897 | |
| 1898 | $string =~ s/^\s+//; |
| 1899 | |
| 1900 | return $string; |
| 1901 | } |
| 1902 | |
| 1903 | sub rtrim { |
| 1904 | my ($string) = @_; |
| 1905 | |
| 1906 | $string =~ s/\s+$//; |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 1907 | |
| 1908 | return $string; |
| 1909 | } |
| 1910 | |
Joe Perches | 52ea850 | 2013-11-12 15:10:09 -0800 | [diff] [blame] | 1911 | sub string_find_replace { |
| 1912 | my ($string, $find, $replace) = @_; |
| 1913 | |
| 1914 | $string =~ s/$find/$replace/g; |
| 1915 | |
| 1916 | return $string; |
| 1917 | } |
| 1918 | |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 1919 | sub tabify { |
| 1920 | my ($leading) = @_; |
| 1921 | |
| 1922 | my $source_indent = 8; |
| 1923 | my $max_spaces_before_tab = $source_indent - 1; |
| 1924 | my $spaces_to_tab = " " x $source_indent; |
| 1925 | |
| 1926 | #convert leading spaces to tabs |
| 1927 | 1 while $leading =~ s@^([\t]*)$spaces_to_tab@$1\t@g; |
| 1928 | #Remove spaces before a tab |
| 1929 | 1 while $leading =~ s@^([\t]*)( {1,$max_spaces_before_tab})\t@$1\t@g; |
| 1930 | |
| 1931 | return "$leading"; |
| 1932 | } |
| 1933 | |
Joe Perches | d1fe9c0 | 2012-03-23 15:02:16 -0700 | [diff] [blame] | 1934 | sub pos_last_openparen { |
| 1935 | my ($line) = @_; |
| 1936 | |
| 1937 | my $pos = 0; |
| 1938 | |
| 1939 | my $opens = $line =~ tr/\(/\(/; |
| 1940 | my $closes = $line =~ tr/\)/\)/; |
| 1941 | |
| 1942 | my $last_openparen = 0; |
| 1943 | |
| 1944 | if (($opens == 0) || ($closes >= $opens)) { |
| 1945 | return -1; |
| 1946 | } |
| 1947 | |
| 1948 | my $len = length($line); |
| 1949 | |
| 1950 | for ($pos = 0; $pos < $len; $pos++) { |
| 1951 | my $string = substr($line, $pos); |
| 1952 | if ($string =~ /^($FuncArg|$balanced_parens)/) { |
| 1953 | $pos += length($1) - 1; |
| 1954 | } elsif (substr($line, $pos, 1) eq '(') { |
| 1955 | $last_openparen = $pos; |
| 1956 | } elsif (index($string, '(') == -1) { |
| 1957 | last; |
| 1958 | } |
| 1959 | } |
| 1960 | |
Joe Perches | 91cb519 | 2014-04-03 14:49:32 -0700 | [diff] [blame] | 1961 | return length(expand_tabs(substr($line, 0, $last_openparen))) + 1; |
Joe Perches | d1fe9c0 | 2012-03-23 15:02:16 -0700 | [diff] [blame] | 1962 | } |
| 1963 | |
Andy Whitcroft | 0a920b5 | 2007-06-01 00:46:48 -0700 | [diff] [blame] | 1964 | sub process { |
| 1965 | my $filename = shift; |
Andy Whitcroft | 0a920b5 | 2007-06-01 00:46:48 -0700 | [diff] [blame] | 1966 | |
| 1967 | my $linenr=0; |
| 1968 | my $prevline=""; |
Andy Whitcroft | c2fdda0 | 2008-02-08 04:20:54 -0800 | [diff] [blame] | 1969 | my $prevrawline=""; |
Andy Whitcroft | 0a920b5 | 2007-06-01 00:46:48 -0700 | [diff] [blame] | 1970 | my $stashline=""; |
Andy Whitcroft | c2fdda0 | 2008-02-08 04:20:54 -0800 | [diff] [blame] | 1971 | my $stashrawline=""; |
Andy Whitcroft | 0a920b5 | 2007-06-01 00:46:48 -0700 | [diff] [blame] | 1972 | |
Andy Whitcroft | 4a0df2e | 2007-06-08 13:46:39 -0700 | [diff] [blame] | 1973 | my $length; |
Andy Whitcroft | 0a920b5 | 2007-06-01 00:46:48 -0700 | [diff] [blame] | 1974 | my $indent; |
| 1975 | my $previndent=0; |
| 1976 | my $stashindent=0; |
| 1977 | |
Andy Whitcroft | de7d4f0 | 2007-07-15 23:37:22 -0700 | [diff] [blame] | 1978 | our $clean = 1; |
Andy Whitcroft | 0a920b5 | 2007-06-01 00:46:48 -0700 | [diff] [blame] | 1979 | my $signoff = 0; |
| 1980 | my $is_patch = 0; |
Joe Perches | 29ee1b0 | 2014-08-06 16:10:35 -0700 | [diff] [blame] | 1981 | my $in_header_lines = $file ? 0 : 1; |
Joe Perches | 15662b3 | 2011-10-31 17:13:12 -0700 | [diff] [blame] | 1982 | my $in_commit_log = 0; #Scanning lines before patch |
Joe Perches | bf4daf1 | 2015-09-09 15:37:50 -0700 | [diff] [blame] | 1983 | my $commit_log_possible_stack_dump = 0; |
Joe Perches | 2a076f4 | 2015-04-16 12:44:28 -0700 | [diff] [blame] | 1984 | my $commit_log_long_line = 0; |
Joe Perches | e518e9a | 2015-06-25 15:03:27 -0700 | [diff] [blame] | 1985 | my $commit_log_has_diff = 0; |
Joe Perches | 13f1937 | 2014-08-06 16:10:59 -0700 | [diff] [blame] | 1986 | my $reported_maintainer_file = 0; |
Pasi Savanainen | fa64205d | 2012-10-04 17:13:29 -0700 | [diff] [blame] | 1987 | my $non_utf8_charset = 0; |
| 1988 | |
Joe Perches | 365dd4e | 2014-08-06 16:10:42 -0700 | [diff] [blame] | 1989 | my $last_blank_line = 0; |
Joe Perches | 5e4f6ba | 2014-12-10 15:52:05 -0800 | [diff] [blame] | 1990 | my $last_coalesced_string_linenr = -1; |
Joe Perches | 365dd4e | 2014-08-06 16:10:42 -0700 | [diff] [blame] | 1991 | |
Andy Whitcroft | 13214ad | 2008-02-08 04:22:03 -0800 | [diff] [blame] | 1992 | our @report = (); |
Andy Whitcroft | 6c72ffa | 2007-10-18 03:05:08 -0700 | [diff] [blame] | 1993 | our $cnt_lines = 0; |
| 1994 | our $cnt_error = 0; |
| 1995 | our $cnt_warn = 0; |
| 1996 | our $cnt_chk = 0; |
| 1997 | |
Andy Whitcroft | 0a920b5 | 2007-06-01 00:46:48 -0700 | [diff] [blame] | 1998 | # Trace the real file/line as we go. |
| 1999 | my $realfile = ''; |
| 2000 | my $realline = 0; |
| 2001 | my $realcnt = 0; |
| 2002 | my $here = ''; |
| 2003 | my $in_comment = 0; |
Andy Whitcroft | c2fdda0 | 2008-02-08 04:20:54 -0800 | [diff] [blame] | 2004 | my $comment_edge = 0; |
Andy Whitcroft | 0a920b5 | 2007-06-01 00:46:48 -0700 | [diff] [blame] | 2005 | my $first_line = 0; |
Wolfram Sang | 1e85572 | 2009-01-06 14:41:24 -0800 | [diff] [blame] | 2006 | my $p1_prefix = ''; |
Andy Whitcroft | 0a920b5 | 2007-06-01 00:46:48 -0700 | [diff] [blame] | 2007 | |
Andy Whitcroft | 13214ad | 2008-02-08 04:22:03 -0800 | [diff] [blame] | 2008 | my $prev_values = 'E'; |
| 2009 | |
| 2010 | # suppression flags |
Andy Whitcroft | 773647a | 2008-03-28 14:15:58 -0700 | [diff] [blame] | 2011 | my %suppress_ifbraces; |
Andy Whitcroft | 170d3a2 | 2008-10-15 22:02:30 -0700 | [diff] [blame] | 2012 | my %suppress_whiletrailers; |
Andy Whitcroft | 2b474a1 | 2009-10-26 16:50:16 -0700 | [diff] [blame] | 2013 | my %suppress_export; |
Andy Whitcroft | 3e469cd | 2012-01-10 15:10:01 -0800 | [diff] [blame] | 2014 | my $suppress_statement = 0; |
Andy Whitcroft | 653d487 | 2007-06-23 17:16:34 -0700 | [diff] [blame] | 2015 | |
Joe Perches | 7e51f19 | 2013-09-11 14:23:57 -0700 | [diff] [blame] | 2016 | my %signatures = (); |
Joe Perches | 323c126 | 2012-12-17 16:02:07 -0800 | [diff] [blame] | 2017 | |
Andy Whitcroft | c2fdda0 | 2008-02-08 04:20:54 -0800 | [diff] [blame] | 2018 | # Pre-scan the patch sanitizing the lines. |
Andy Whitcroft | de7d4f0 | 2007-07-15 23:37:22 -0700 | [diff] [blame] | 2019 | # Pre-scan the patch looking for any __setup documentation. |
Andy Whitcroft | c2fdda0 | 2008-02-08 04:20:54 -0800 | [diff] [blame] | 2020 | # |
Andy Whitcroft | de7d4f0 | 2007-07-15 23:37:22 -0700 | [diff] [blame] | 2021 | my @setup_docs = (); |
| 2022 | my $setup_docs = 0; |
Andy Whitcroft | 773647a | 2008-03-28 14:15:58 -0700 | [diff] [blame] | 2023 | |
Joe Perches | d8b0771 | 2013-11-12 15:10:06 -0800 | [diff] [blame] | 2024 | my $camelcase_file_seeded = 0; |
| 2025 | |
Andy Whitcroft | 773647a | 2008-03-28 14:15:58 -0700 | [diff] [blame] | 2026 | sanitise_line_reset(); |
Andy Whitcroft | c2fdda0 | 2008-02-08 04:20:54 -0800 | [diff] [blame] | 2027 | my $line; |
| 2028 | foreach my $rawline (@rawlines) { |
Andy Whitcroft | 773647a | 2008-03-28 14:15:58 -0700 | [diff] [blame] | 2029 | $linenr++; |
| 2030 | $line = $rawline; |
Andy Whitcroft | c2fdda0 | 2008-02-08 04:20:54 -0800 | [diff] [blame] | 2031 | |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 2032 | push(@fixed, $rawline) if ($fix); |
| 2033 | |
Andy Whitcroft | 773647a | 2008-03-28 14:15:58 -0700 | [diff] [blame] | 2034 | if ($rawline=~/^\+\+\+\s+(\S+)/) { |
Andy Whitcroft | de7d4f0 | 2007-07-15 23:37:22 -0700 | [diff] [blame] | 2035 | $setup_docs = 0; |
| 2036 | if ($1 =~ m@Documentation/kernel-parameters.txt$@) { |
| 2037 | $setup_docs = 1; |
| 2038 | } |
Andy Whitcroft | 773647a | 2008-03-28 14:15:58 -0700 | [diff] [blame] | 2039 | #next; |
Andy Whitcroft | de7d4f0 | 2007-07-15 23:37:22 -0700 | [diff] [blame] | 2040 | } |
Andy Whitcroft | 773647a | 2008-03-28 14:15:58 -0700 | [diff] [blame] | 2041 | if ($rawline=~/^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@/) { |
| 2042 | $realline=$1-1; |
| 2043 | if (defined $2) { |
| 2044 | $realcnt=$3+1; |
| 2045 | } else { |
| 2046 | $realcnt=1+1; |
| 2047 | } |
Andy Whitcroft | c45dcab | 2008-06-05 22:46:01 -0700 | [diff] [blame] | 2048 | $in_comment = 0; |
Andy Whitcroft | 773647a | 2008-03-28 14:15:58 -0700 | [diff] [blame] | 2049 | |
| 2050 | # Guestimate if this is a continuing comment. Run |
| 2051 | # the context looking for a comment "edge". If this |
| 2052 | # edge is a close comment then we must be in a comment |
| 2053 | # at context start. |
| 2054 | my $edge; |
Andy Whitcroft | 01fa914 | 2008-10-15 22:02:19 -0700 | [diff] [blame] | 2055 | my $cnt = $realcnt; |
| 2056 | for (my $ln = $linenr + 1; $cnt > 0; $ln++) { |
| 2057 | next if (defined $rawlines[$ln - 1] && |
| 2058 | $rawlines[$ln - 1] =~ /^-/); |
| 2059 | $cnt--; |
| 2060 | #print "RAW<$rawlines[$ln - 1]>\n"; |
Andy Whitcroft | 721c1cb | 2009-01-06 14:41:16 -0800 | [diff] [blame] | 2061 | last if (!defined $rawlines[$ln - 1]); |
Andy Whitcroft | fae17da | 2009-01-06 14:41:20 -0800 | [diff] [blame] | 2062 | if ($rawlines[$ln - 1] =~ m@(/\*|\*/)@ && |
| 2063 | $rawlines[$ln - 1] !~ m@"[^"]*(?:/\*|\*/)[^"]*"@) { |
| 2064 | ($edge) = $1; |
| 2065 | last; |
| 2066 | } |
Andy Whitcroft | 773647a | 2008-03-28 14:15:58 -0700 | [diff] [blame] | 2067 | } |
| 2068 | if (defined $edge && $edge eq '*/') { |
| 2069 | $in_comment = 1; |
| 2070 | } |
| 2071 | |
| 2072 | # Guestimate if this is a continuing comment. If this |
| 2073 | # is the start of a diff block and this line starts |
| 2074 | # ' *' then it is very likely a comment. |
| 2075 | if (!defined $edge && |
Andy Whitcroft | 83242e0 | 2009-01-06 14:41:17 -0800 | [diff] [blame] | 2076 | $rawlines[$linenr] =~ m@^.\s*(?:\*\*+| \*)(?:\s|$)@) |
Andy Whitcroft | 773647a | 2008-03-28 14:15:58 -0700 | [diff] [blame] | 2077 | { |
| 2078 | $in_comment = 1; |
| 2079 | } |
| 2080 | |
| 2081 | ##print "COMMENT:$in_comment edge<$edge> $rawline\n"; |
| 2082 | sanitise_line_reset($in_comment); |
| 2083 | |
Andy Whitcroft | 171ae1a | 2008-04-29 00:59:32 -0700 | [diff] [blame] | 2084 | } elsif ($realcnt && $rawline =~ /^(?:\+| |$)/) { |
Andy Whitcroft | 773647a | 2008-03-28 14:15:58 -0700 | [diff] [blame] | 2085 | # Standardise the strings and chars within the input to |
Andy Whitcroft | 171ae1a | 2008-04-29 00:59:32 -0700 | [diff] [blame] | 2086 | # simplify matching -- only bother with positive lines. |
Andy Whitcroft | 773647a | 2008-03-28 14:15:58 -0700 | [diff] [blame] | 2087 | $line = sanitise_line($rawline); |
| 2088 | } |
| 2089 | push(@lines, $line); |
| 2090 | |
| 2091 | if ($realcnt > 1) { |
| 2092 | $realcnt-- if ($line =~ /^(?:\+| |$)/); |
| 2093 | } else { |
| 2094 | $realcnt = 0; |
| 2095 | } |
| 2096 | |
| 2097 | #print "==>$rawline\n"; |
| 2098 | #print "-->$line\n"; |
Andy Whitcroft | de7d4f0 | 2007-07-15 23:37:22 -0700 | [diff] [blame] | 2099 | |
| 2100 | if ($setup_docs && $line =~ /^\+/) { |
| 2101 | push(@setup_docs, $line); |
| 2102 | } |
| 2103 | } |
| 2104 | |
Andy Whitcroft | 6c72ffa | 2007-10-18 03:05:08 -0700 | [diff] [blame] | 2105 | $prefix = ''; |
| 2106 | |
Andy Whitcroft | 773647a | 2008-03-28 14:15:58 -0700 | [diff] [blame] | 2107 | $realcnt = 0; |
| 2108 | $linenr = 0; |
Joe Perches | 194f66f | 2014-08-06 16:11:03 -0700 | [diff] [blame] | 2109 | $fixlinenr = -1; |
Andy Whitcroft | 0a920b5 | 2007-06-01 00:46:48 -0700 | [diff] [blame] | 2110 | foreach my $line (@lines) { |
| 2111 | $linenr++; |
Joe Perches | 194f66f | 2014-08-06 16:11:03 -0700 | [diff] [blame] | 2112 | $fixlinenr++; |
Joe Perches | 1b5539b | 2013-09-11 14:24:03 -0700 | [diff] [blame] | 2113 | my $sline = $line; #copy of $line |
| 2114 | $sline =~ s/$;/ /g; #with comments as spaces |
Andy Whitcroft | 0a920b5 | 2007-06-01 00:46:48 -0700 | [diff] [blame] | 2115 | |
Andy Whitcroft | c2fdda0 | 2008-02-08 04:20:54 -0800 | [diff] [blame] | 2116 | my $rawline = $rawlines[$linenr - 1]; |
Andy Whitcroft | 6c72ffa | 2007-10-18 03:05:08 -0700 | [diff] [blame] | 2117 | |
Andy Whitcroft | 0a920b5 | 2007-06-01 00:46:48 -0700 | [diff] [blame] | 2118 | #extract the line range in the file after the patch is applied |
Joe Perches | e518e9a | 2015-06-25 15:03:27 -0700 | [diff] [blame] | 2119 | if (!$in_commit_log && |
| 2120 | $line =~ /^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@/) { |
Andy Whitcroft | 0a920b5 | 2007-06-01 00:46:48 -0700 | [diff] [blame] | 2121 | $is_patch = 1; |
Andy Whitcroft | 4a0df2e | 2007-06-08 13:46:39 -0700 | [diff] [blame] | 2122 | $first_line = $linenr + 1; |
Andy Whitcroft | 0a920b5 | 2007-06-01 00:46:48 -0700 | [diff] [blame] | 2123 | $realline=$1-1; |
| 2124 | if (defined $2) { |
| 2125 | $realcnt=$3+1; |
| 2126 | } else { |
| 2127 | $realcnt=1+1; |
| 2128 | } |
Andy Whitcroft | c2fdda0 | 2008-02-08 04:20:54 -0800 | [diff] [blame] | 2129 | annotate_reset(); |
Andy Whitcroft | 13214ad | 2008-02-08 04:22:03 -0800 | [diff] [blame] | 2130 | $prev_values = 'E'; |
| 2131 | |
Andy Whitcroft | 773647a | 2008-03-28 14:15:58 -0700 | [diff] [blame] | 2132 | %suppress_ifbraces = (); |
Andy Whitcroft | 170d3a2 | 2008-10-15 22:02:30 -0700 | [diff] [blame] | 2133 | %suppress_whiletrailers = (); |
Andy Whitcroft | 2b474a1 | 2009-10-26 16:50:16 -0700 | [diff] [blame] | 2134 | %suppress_export = (); |
Andy Whitcroft | 3e469cd | 2012-01-10 15:10:01 -0800 | [diff] [blame] | 2135 | $suppress_statement = 0; |
Andy Whitcroft | 0a920b5 | 2007-06-01 00:46:48 -0700 | [diff] [blame] | 2136 | next; |
Andy Whitcroft | 0a920b5 | 2007-06-01 00:46:48 -0700 | [diff] [blame] | 2137 | |
Andy Whitcroft | 4a0df2e | 2007-06-08 13:46:39 -0700 | [diff] [blame] | 2138 | # track the line number as we move through the hunk, note that |
| 2139 | # new versions of GNU diff omit the leading space on completely |
| 2140 | # blank context lines so we need to count that too. |
Andy Whitcroft | 773647a | 2008-03-28 14:15:58 -0700 | [diff] [blame] | 2141 | } elsif ($line =~ /^( |\+|$)/) { |
Andy Whitcroft | 0a920b5 | 2007-06-01 00:46:48 -0700 | [diff] [blame] | 2142 | $realline++; |
Andy Whitcroft | d8aaf12 | 2007-06-23 17:16:44 -0700 | [diff] [blame] | 2143 | $realcnt-- if ($realcnt != 0); |
Andy Whitcroft | 0a920b5 | 2007-06-01 00:46:48 -0700 | [diff] [blame] | 2144 | |
Andy Whitcroft | 4a0df2e | 2007-06-08 13:46:39 -0700 | [diff] [blame] | 2145 | # Measure the line length and indent. |
Andy Whitcroft | c2fdda0 | 2008-02-08 04:20:54 -0800 | [diff] [blame] | 2146 | ($length, $indent) = line_stats($rawline); |
Andy Whitcroft | 0a920b5 | 2007-06-01 00:46:48 -0700 | [diff] [blame] | 2147 | |
| 2148 | # Track the previous line. |
| 2149 | ($prevline, $stashline) = ($stashline, $line); |
| 2150 | ($previndent, $stashindent) = ($stashindent, $indent); |
Andy Whitcroft | c2fdda0 | 2008-02-08 04:20:54 -0800 | [diff] [blame] | 2151 | ($prevrawline, $stashrawline) = ($stashrawline, $rawline); |
| 2152 | |
Andy Whitcroft | 773647a | 2008-03-28 14:15:58 -0700 | [diff] [blame] | 2153 | #warn "line<$line>\n"; |
Andy Whitcroft | 6c72ffa | 2007-10-18 03:05:08 -0700 | [diff] [blame] | 2154 | |
Andy Whitcroft | d8aaf12 | 2007-06-23 17:16:44 -0700 | [diff] [blame] | 2155 | } elsif ($realcnt == 1) { |
| 2156 | $realcnt--; |
Andy Whitcroft | 0a920b5 | 2007-06-01 00:46:48 -0700 | [diff] [blame] | 2157 | } |
| 2158 | |
Andy Whitcroft | cc77cdc | 2009-10-26 16:50:13 -0700 | [diff] [blame] | 2159 | my $hunk_line = ($realcnt != 0); |
| 2160 | |
Andy Whitcroft | 6c72ffa | 2007-10-18 03:05:08 -0700 | [diff] [blame] | 2161 | $here = "#$linenr: " if (!$file); |
| 2162 | $here = "#$realline: " if ($file); |
Andy Whitcroft | 773647a | 2008-03-28 14:15:58 -0700 | [diff] [blame] | 2163 | |
Joe Perches | 2ac73b4 | 2014-06-04 16:12:05 -0700 | [diff] [blame] | 2164 | my $found_file = 0; |
Andy Whitcroft | 773647a | 2008-03-28 14:15:58 -0700 | [diff] [blame] | 2165 | # extract the filename as it passes |
Rabin Vincent | 3bf9a00 | 2010-10-26 14:23:16 -0700 | [diff] [blame] | 2166 | if ($line =~ /^diff --git.*?(\S+)$/) { |
| 2167 | $realfile = $1; |
Joe Perches | 2b7ab45 | 2013-11-12 15:10:14 -0800 | [diff] [blame] | 2168 | $realfile =~ s@^([^/]*)/@@ if (!$file); |
Joe Perches | 270c49a | 2012-01-10 15:09:50 -0800 | [diff] [blame] | 2169 | $in_commit_log = 0; |
Joe Perches | 2ac73b4 | 2014-06-04 16:12:05 -0700 | [diff] [blame] | 2170 | $found_file = 1; |
Rabin Vincent | 3bf9a00 | 2010-10-26 14:23:16 -0700 | [diff] [blame] | 2171 | } elsif ($line =~ /^\+\+\+\s+(\S+)/) { |
Andy Whitcroft | 773647a | 2008-03-28 14:15:58 -0700 | [diff] [blame] | 2172 | $realfile = $1; |
Joe Perches | 2b7ab45 | 2013-11-12 15:10:14 -0800 | [diff] [blame] | 2173 | $realfile =~ s@^([^/]*)/@@ if (!$file); |
Joe Perches | 270c49a | 2012-01-10 15:09:50 -0800 | [diff] [blame] | 2174 | $in_commit_log = 0; |
Wolfram Sang | 1e85572 | 2009-01-06 14:41:24 -0800 | [diff] [blame] | 2175 | |
| 2176 | $p1_prefix = $1; |
Andy Whitcroft | e2f7aa4 | 2009-02-27 14:03:06 -0800 | [diff] [blame] | 2177 | if (!$file && $tree && $p1_prefix ne '' && |
| 2178 | -e "$root/$p1_prefix") { |
Joe Perches | 000d1cc1 | 2011-07-25 17:13:25 -0700 | [diff] [blame] | 2179 | WARN("PATCH_PREFIX", |
| 2180 | "patch prefix '$p1_prefix' exists, appears to be a -p0 patch\n"); |
Wolfram Sang | 1e85572 | 2009-01-06 14:41:24 -0800 | [diff] [blame] | 2181 | } |
Andy Whitcroft | 773647a | 2008-03-28 14:15:58 -0700 | [diff] [blame] | 2182 | |
Andy Whitcroft | c1ab332 | 2008-10-15 22:02:20 -0700 | [diff] [blame] | 2183 | if ($realfile =~ m@^include/asm/@) { |
Joe Perches | 000d1cc1 | 2011-07-25 17:13:25 -0700 | [diff] [blame] | 2184 | ERROR("MODIFIED_INCLUDE_ASM", |
| 2185 | "do not modify files in include/asm, change architecture specific files in include/asm-<architecture>\n" . "$here$rawline\n"); |
Andy Whitcroft | 773647a | 2008-03-28 14:15:58 -0700 | [diff] [blame] | 2186 | } |
Joe Perches | 2ac73b4 | 2014-06-04 16:12:05 -0700 | [diff] [blame] | 2187 | $found_file = 1; |
| 2188 | } |
| 2189 | |
Joe Perches | 34d8815 | 2015-06-25 15:03:05 -0700 | [diff] [blame] | 2190 | #make up the handle for any error we report on this line |
| 2191 | if ($showfile) { |
| 2192 | $prefix = "$realfile:$realline: " |
| 2193 | } elsif ($emacs) { |
Joe Perches | 7d3a9f6 | 2015-09-09 15:37:39 -0700 | [diff] [blame] | 2194 | if ($file) { |
| 2195 | $prefix = "$filename:$realline: "; |
| 2196 | } else { |
| 2197 | $prefix = "$filename:$linenr: "; |
| 2198 | } |
Joe Perches | 34d8815 | 2015-06-25 15:03:05 -0700 | [diff] [blame] | 2199 | } |
| 2200 | |
Joe Perches | 2ac73b4 | 2014-06-04 16:12:05 -0700 | [diff] [blame] | 2201 | if ($found_file) { |
Joe Perches | 7bd7e48 | 2015-09-09 15:37:44 -0700 | [diff] [blame] | 2202 | if ($realfile =~ m@^(?:drivers/net/|net/|drivers/staging/)@) { |
Joe Perches | 2ac73b4 | 2014-06-04 16:12:05 -0700 | [diff] [blame] | 2203 | $check = 1; |
| 2204 | } else { |
| 2205 | $check = $check_orig; |
| 2206 | } |
Andy Whitcroft | 773647a | 2008-03-28 14:15:58 -0700 | [diff] [blame] | 2207 | next; |
| 2208 | } |
| 2209 | |
Randy Dunlap | 389834b | 2007-06-08 13:47:03 -0700 | [diff] [blame] | 2210 | $here .= "FILE: $realfile:$realline:" if ($realcnt != 0); |
Andy Whitcroft | 0a920b5 | 2007-06-01 00:46:48 -0700 | [diff] [blame] | 2211 | |
Andy Whitcroft | c2fdda0 | 2008-02-08 04:20:54 -0800 | [diff] [blame] | 2212 | my $hereline = "$here\n$rawline\n"; |
| 2213 | my $herecurr = "$here\n$rawline\n"; |
| 2214 | my $hereprev = "$here\n$prevrawline\n$rawline\n"; |
Andy Whitcroft | 0a920b5 | 2007-06-01 00:46:48 -0700 | [diff] [blame] | 2215 | |
Andy Whitcroft | 6c72ffa | 2007-10-18 03:05:08 -0700 | [diff] [blame] | 2216 | $cnt_lines++ if ($realcnt != 0); |
| 2217 | |
Joe Perches | e518e9a | 2015-06-25 15:03:27 -0700 | [diff] [blame] | 2218 | # Check if the commit log has what seems like a diff which can confuse patch |
| 2219 | if ($in_commit_log && !$commit_log_has_diff && |
| 2220 | (($line =~ m@^\s+diff\b.*a/[\w/]+@ && |
| 2221 | $line =~ m@^\s+diff\b.*a/([\w/]+)\s+b/$1\b@) || |
| 2222 | $line =~ m@^\s*(?:\-\-\-\s+a/|\+\+\+\s+b/)@ || |
| 2223 | $line =~ m/^\s*\@\@ \-\d+,\d+ \+\d+,\d+ \@\@/)) { |
| 2224 | ERROR("DIFF_IN_COMMIT_MSG", |
| 2225 | "Avoid using diff content in the commit message - patch(1) might not work\n" . $herecurr); |
| 2226 | $commit_log_has_diff = 1; |
| 2227 | } |
| 2228 | |
Rabin Vincent | 3bf9a00 | 2010-10-26 14:23:16 -0700 | [diff] [blame] | 2229 | # Check for incorrect file permissions |
| 2230 | if ($line =~ /^new (file )?mode.*[7531]\d{0,2}$/) { |
| 2231 | my $permhere = $here . "FILE: $realfile\n"; |
Joe Perches | 04db4d2 | 2013-04-29 16:18:14 -0700 | [diff] [blame] | 2232 | if ($realfile !~ m@scripts/@ && |
| 2233 | $realfile !~ /\.(py|pl|awk|sh)$/) { |
Joe Perches | 000d1cc1 | 2011-07-25 17:13:25 -0700 | [diff] [blame] | 2234 | ERROR("EXECUTE_PERMISSIONS", |
| 2235 | "do not set execute permissions for source files\n" . $permhere); |
Rabin Vincent | 3bf9a00 | 2010-10-26 14:23:16 -0700 | [diff] [blame] | 2236 | } |
| 2237 | } |
| 2238 | |
Joe Perches | 2011247 | 2011-07-25 17:13:23 -0700 | [diff] [blame] | 2239 | # Check the patch for a signoff: |
Andy Whitcroft | d8aaf12 | 2007-06-23 17:16:44 -0700 | [diff] [blame] | 2240 | if ($line =~ /^\s*signed-off-by:/i) { |
Andy Whitcroft | 4a0df2e | 2007-06-08 13:46:39 -0700 | [diff] [blame] | 2241 | $signoff++; |
Joe Perches | 15662b3 | 2011-10-31 17:13:12 -0700 | [diff] [blame] | 2242 | $in_commit_log = 0; |
Joe Perches | 2011247 | 2011-07-25 17:13:23 -0700 | [diff] [blame] | 2243 | } |
| 2244 | |
Joe Perches | e0d975b | 2014-12-10 15:51:49 -0800 | [diff] [blame] | 2245 | # Check if MAINTAINERS is being updated. If so, there's probably no need to |
| 2246 | # emit the "does MAINTAINERS need updating?" message on file add/move/delete |
| 2247 | if ($line =~ /^\s*MAINTAINERS\s*\|/) { |
| 2248 | $reported_maintainer_file = 1; |
| 2249 | } |
| 2250 | |
Joe Perches | 2011247 | 2011-07-25 17:13:23 -0700 | [diff] [blame] | 2251 | # Check signature styles |
Joe Perches | 270c49a | 2012-01-10 15:09:50 -0800 | [diff] [blame] | 2252 | if (!$in_header_lines && |
Joe Perches | ce0338df3c | 2012-07-30 14:41:18 -0700 | [diff] [blame] | 2253 | $line =~ /^(\s*)([a-z0-9_-]+by:|$signature_tags)(\s*)(.*)/i) { |
Joe Perches | 2011247 | 2011-07-25 17:13:23 -0700 | [diff] [blame] | 2254 | my $space_before = $1; |
| 2255 | my $sign_off = $2; |
| 2256 | my $space_after = $3; |
| 2257 | my $email = $4; |
| 2258 | my $ucfirst_sign_off = ucfirst(lc($sign_off)); |
| 2259 | |
Joe Perches | ce0338df3c | 2012-07-30 14:41:18 -0700 | [diff] [blame] | 2260 | if ($sign_off !~ /$signature_tags/) { |
| 2261 | WARN("BAD_SIGN_OFF", |
| 2262 | "Non-standard signature: $sign_off\n" . $herecurr); |
| 2263 | } |
Joe Perches | 2011247 | 2011-07-25 17:13:23 -0700 | [diff] [blame] | 2264 | if (defined $space_before && $space_before ne "") { |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 2265 | if (WARN("BAD_SIGN_OFF", |
| 2266 | "Do not use whitespace before $ucfirst_sign_off\n" . $herecurr) && |
| 2267 | $fix) { |
Joe Perches | 194f66f | 2014-08-06 16:11:03 -0700 | [diff] [blame] | 2268 | $fixed[$fixlinenr] = |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 2269 | "$ucfirst_sign_off $email"; |
| 2270 | } |
Andy Whitcroft | 0a920b5 | 2007-06-01 00:46:48 -0700 | [diff] [blame] | 2271 | } |
Joe Perches | 2011247 | 2011-07-25 17:13:23 -0700 | [diff] [blame] | 2272 | if ($sign_off =~ /-by:$/i && $sign_off ne $ucfirst_sign_off) { |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 2273 | if (WARN("BAD_SIGN_OFF", |
| 2274 | "'$ucfirst_sign_off' is the preferred signature form\n" . $herecurr) && |
| 2275 | $fix) { |
Joe Perches | 194f66f | 2014-08-06 16:11:03 -0700 | [diff] [blame] | 2276 | $fixed[$fixlinenr] = |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 2277 | "$ucfirst_sign_off $email"; |
| 2278 | } |
| 2279 | |
Joe Perches | 2011247 | 2011-07-25 17:13:23 -0700 | [diff] [blame] | 2280 | } |
| 2281 | if (!defined $space_after || $space_after ne " ") { |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 2282 | if (WARN("BAD_SIGN_OFF", |
| 2283 | "Use a single space after $ucfirst_sign_off\n" . $herecurr) && |
| 2284 | $fix) { |
Joe Perches | 194f66f | 2014-08-06 16:11:03 -0700 | [diff] [blame] | 2285 | $fixed[$fixlinenr] = |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 2286 | "$ucfirst_sign_off $email"; |
| 2287 | } |
Joe Perches | 2011247 | 2011-07-25 17:13:23 -0700 | [diff] [blame] | 2288 | } |
| 2289 | |
| 2290 | my ($email_name, $email_address, $comment) = parse_email($email); |
| 2291 | my $suggested_email = format_email(($email_name, $email_address)); |
| 2292 | if ($suggested_email eq "") { |
Joe Perches | 000d1cc1 | 2011-07-25 17:13:25 -0700 | [diff] [blame] | 2293 | ERROR("BAD_SIGN_OFF", |
| 2294 | "Unrecognized email address: '$email'\n" . $herecurr); |
Joe Perches | 2011247 | 2011-07-25 17:13:23 -0700 | [diff] [blame] | 2295 | } else { |
| 2296 | my $dequoted = $suggested_email; |
| 2297 | $dequoted =~ s/^"//; |
| 2298 | $dequoted =~ s/" </ </; |
| 2299 | # Don't force email to have quotes |
| 2300 | # Allow just an angle bracketed address |
| 2301 | if ("$dequoted$comment" ne $email && |
| 2302 | "<$email_address>$comment" ne $email && |
| 2303 | "$suggested_email$comment" ne $email) { |
Joe Perches | 000d1cc1 | 2011-07-25 17:13:25 -0700 | [diff] [blame] | 2304 | WARN("BAD_SIGN_OFF", |
| 2305 | "email address '$email' might be better as '$suggested_email$comment'\n" . $herecurr); |
Joe Perches | 2011247 | 2011-07-25 17:13:23 -0700 | [diff] [blame] | 2306 | } |
Andy Whitcroft | 0a920b5 | 2007-06-01 00:46:48 -0700 | [diff] [blame] | 2307 | } |
Joe Perches | 7e51f19 | 2013-09-11 14:23:57 -0700 | [diff] [blame] | 2308 | |
| 2309 | # Check for duplicate signatures |
| 2310 | my $sig_nospace = $line; |
| 2311 | $sig_nospace =~ s/\s//g; |
| 2312 | $sig_nospace = lc($sig_nospace); |
| 2313 | if (defined $signatures{$sig_nospace}) { |
| 2314 | WARN("BAD_SIGN_OFF", |
| 2315 | "Duplicate signature\n" . $herecurr); |
| 2316 | } else { |
| 2317 | $signatures{$sig_nospace} = 1; |
| 2318 | } |
Andy Whitcroft | 0a920b5 | 2007-06-01 00:46:48 -0700 | [diff] [blame] | 2319 | } |
| 2320 | |
Joe Perches | a2fe16b | 2015-02-13 14:39:02 -0800 | [diff] [blame] | 2321 | # Check email subject for common tools that don't need to be mentioned |
| 2322 | if ($in_header_lines && |
| 2323 | $line =~ /^Subject:.*\b(?:checkpatch|sparse|smatch)\b[^:]/i) { |
| 2324 | WARN("EMAIL_SUBJECT", |
| 2325 | "A patch subject line should describe the change not the tool that found it\n" . $herecurr); |
| 2326 | } |
| 2327 | |
Joe Perches | 9b3189e | 2014-06-04 16:12:10 -0700 | [diff] [blame] | 2328 | # Check for old stable address |
| 2329 | if ($line =~ /^\s*cc:\s*.*<?\bstable\@kernel\.org\b>?.*$/i) { |
| 2330 | ERROR("STABLE_ADDRESS", |
| 2331 | "The 'stable' address should be 'stable\@vger.kernel.org'\n" . $herecurr); |
| 2332 | } |
| 2333 | |
Christopher Covington | 7ebd05e | 2014-04-03 14:49:31 -0700 | [diff] [blame] | 2334 | # Check for unwanted Gerrit info |
| 2335 | if ($in_commit_log && $line =~ /^\s*change-id:/i) { |
| 2336 | ERROR("GERRIT_CHANGE_ID", |
| 2337 | "Remove Gerrit Change-Id's before submitting upstream.\n" . $herecurr); |
| 2338 | } |
| 2339 | |
Joe Perches | 369c8dd | 2015-11-06 16:31:34 -0800 | [diff] [blame] | 2340 | # Check if the commit log is in a possible stack dump |
| 2341 | if ($in_commit_log && !$commit_log_possible_stack_dump && |
| 2342 | ($line =~ /^\s*(?:WARNING:|BUG:)/ || |
| 2343 | $line =~ /^\s*\[\s*\d+\.\d{6,6}\s*\]/ || |
| 2344 | # timestamp |
| 2345 | $line =~ /^\s*\[\<[0-9a-fA-F]{8,}\>\]/)) { |
| 2346 | # stack dump address |
| 2347 | $commit_log_possible_stack_dump = 1; |
| 2348 | } |
| 2349 | |
Joe Perches | 2a076f4 | 2015-04-16 12:44:28 -0700 | [diff] [blame] | 2350 | # Check for line lengths > 75 in commit log, warn once |
| 2351 | if ($in_commit_log && !$commit_log_long_line && |
Joe Perches | 369c8dd | 2015-11-06 16:31:34 -0800 | [diff] [blame] | 2352 | length($line) > 75 && |
| 2353 | !($line =~ /^\s*[a-zA-Z0-9_\/\.]+\s+\|\s+\d+/ || |
| 2354 | # file delta changes |
| 2355 | $line =~ /^\s*(?:[\w\.\-]+\/)++[\w\.\-]+:/ || |
| 2356 | # filename then : |
| 2357 | $line =~ /^\s*(?:Fixes:|Link:)/i || |
| 2358 | # A Fixes: or Link: line |
| 2359 | $commit_log_possible_stack_dump)) { |
Joe Perches | 2a076f4 | 2015-04-16 12:44:28 -0700 | [diff] [blame] | 2360 | WARN("COMMIT_LOG_LONG_LINE", |
| 2361 | "Possible unwrapped commit description (prefer a maximum 75 chars per line)\n" . $herecurr); |
| 2362 | $commit_log_long_line = 1; |
| 2363 | } |
| 2364 | |
Joe Perches | bf4daf1 | 2015-09-09 15:37:50 -0700 | [diff] [blame] | 2365 | # Reset possible stack dump if a blank line is found |
Joe Perches | 369c8dd | 2015-11-06 16:31:34 -0800 | [diff] [blame] | 2366 | if ($in_commit_log && $commit_log_possible_stack_dump && |
| 2367 | $line =~ /^\s*$/) { |
| 2368 | $commit_log_possible_stack_dump = 0; |
| 2369 | } |
Joe Perches | bf4daf1 | 2015-09-09 15:37:50 -0700 | [diff] [blame] | 2370 | |
Joe Perches | 0d7835f | 2015-02-13 14:38:35 -0800 | [diff] [blame] | 2371 | # Check for git id commit length and improperly formed commit descriptions |
Joe Perches | 369c8dd | 2015-11-06 16:31:34 -0800 | [diff] [blame] | 2372 | if ($in_commit_log && !$commit_log_possible_stack_dump && |
Joe Perches | fe043ea | 2015-09-09 15:37:25 -0700 | [diff] [blame] | 2373 | ($line =~ /\bcommit\s+[0-9a-f]{5,}\b/i || |
Joe Perches | 369c8dd | 2015-11-06 16:31:34 -0800 | [diff] [blame] | 2374 | ($line =~ /\b[0-9a-f]{12,40}\b/i && |
| 2375 | $line !~ /[\<\[][0-9a-f]{12,40}[\>\]]/i && |
| 2376 | $line !~ /\bfixes:\s*[0-9a-f]{12,40}/i))) { |
Joe Perches | fe043ea | 2015-09-09 15:37:25 -0700 | [diff] [blame] | 2377 | my $init_char = "c"; |
| 2378 | my $orig_commit = ""; |
Joe Perches | 0d7835f | 2015-02-13 14:38:35 -0800 | [diff] [blame] | 2379 | my $short = 1; |
| 2380 | my $long = 0; |
| 2381 | my $case = 1; |
| 2382 | my $space = 1; |
| 2383 | my $hasdesc = 0; |
Joe Perches | 19c146a | 2015-02-13 14:39:00 -0800 | [diff] [blame] | 2384 | my $hasparens = 0; |
Joe Perches | 0d7835f | 2015-02-13 14:38:35 -0800 | [diff] [blame] | 2385 | my $id = '0123456789ab'; |
| 2386 | my $orig_desc = "commit description"; |
| 2387 | my $description = ""; |
| 2388 | |
Joe Perches | fe043ea | 2015-09-09 15:37:25 -0700 | [diff] [blame] | 2389 | if ($line =~ /\b(c)ommit\s+([0-9a-f]{5,})\b/i) { |
| 2390 | $init_char = $1; |
| 2391 | $orig_commit = lc($2); |
| 2392 | } elsif ($line =~ /\b([0-9a-f]{12,40})\b/i) { |
| 2393 | $orig_commit = lc($1); |
| 2394 | } |
| 2395 | |
Joe Perches | 0d7835f | 2015-02-13 14:38:35 -0800 | [diff] [blame] | 2396 | $short = 0 if ($line =~ /\bcommit\s+[0-9a-f]{12,40}/i); |
| 2397 | $long = 1 if ($line =~ /\bcommit\s+[0-9a-f]{41,}/i); |
| 2398 | $space = 0 if ($line =~ /\bcommit [0-9a-f]/i); |
| 2399 | $case = 0 if ($line =~ /\b[Cc]ommit\s+[0-9a-f]{5,40}[^A-F]/); |
| 2400 | if ($line =~ /\bcommit\s+[0-9a-f]{5,}\s+\("([^"]+)"\)/i) { |
| 2401 | $orig_desc = $1; |
Joe Perches | 19c146a | 2015-02-13 14:39:00 -0800 | [diff] [blame] | 2402 | $hasparens = 1; |
Joe Perches | 0d7835f | 2015-02-13 14:38:35 -0800 | [diff] [blame] | 2403 | } elsif ($line =~ /\bcommit\s+[0-9a-f]{5,}\s*$/i && |
| 2404 | defined $rawlines[$linenr] && |
| 2405 | $rawlines[$linenr] =~ /^\s*\("([^"]+)"\)/) { |
| 2406 | $orig_desc = $1; |
Joe Perches | 19c146a | 2015-02-13 14:39:00 -0800 | [diff] [blame] | 2407 | $hasparens = 1; |
Joe Perches | b671fde | 2015-02-13 14:38:41 -0800 | [diff] [blame] | 2408 | } elsif ($line =~ /\bcommit\s+[0-9a-f]{5,}\s+\("[^"]+$/i && |
| 2409 | defined $rawlines[$linenr] && |
| 2410 | $rawlines[$linenr] =~ /^\s*[^"]+"\)/) { |
| 2411 | $line =~ /\bcommit\s+[0-9a-f]{5,}\s+\("([^"]+)$/i; |
| 2412 | $orig_desc = $1; |
| 2413 | $rawlines[$linenr] =~ /^\s*([^"]+)"\)/; |
| 2414 | $orig_desc .= " " . $1; |
Joe Perches | 19c146a | 2015-02-13 14:39:00 -0800 | [diff] [blame] | 2415 | $hasparens = 1; |
Joe Perches | 0d7835f | 2015-02-13 14:38:35 -0800 | [diff] [blame] | 2416 | } |
| 2417 | |
| 2418 | ($id, $description) = git_commit_info($orig_commit, |
| 2419 | $id, $orig_desc); |
| 2420 | |
Joe Perches | 19c146a | 2015-02-13 14:39:00 -0800 | [diff] [blame] | 2421 | if ($short || $long || $space || $case || ($orig_desc ne $description) || !$hasparens) { |
Joe Perches | 0d7835f | 2015-02-13 14:38:35 -0800 | [diff] [blame] | 2422 | ERROR("GIT_COMMIT_ID", |
| 2423 | "Please use git commit description style 'commit <12+ chars of sha1> (\"<title line>\")' - ie: '${init_char}ommit $id (\"$description\")'\n" . $herecurr); |
| 2424 | } |
Joe Perches | d311cd4 | 2014-08-06 16:10:57 -0700 | [diff] [blame] | 2425 | } |
| 2426 | |
Joe Perches | 13f1937 | 2014-08-06 16:10:59 -0700 | [diff] [blame] | 2427 | # Check for added, moved or deleted files |
| 2428 | if (!$reported_maintainer_file && !$in_commit_log && |
| 2429 | ($line =~ /^(?:new|deleted) file mode\s*\d+\s*$/ || |
| 2430 | $line =~ /^rename (?:from|to) [\w\/\.\-]+\s*$/ || |
| 2431 | ($line =~ /\{\s*([\w\/\.\-]*)\s*\=\>\s*([\w\/\.\-]*)\s*\}/ && |
| 2432 | (defined($1) || defined($2))))) { |
| 2433 | $reported_maintainer_file = 1; |
| 2434 | WARN("FILE_PATH_CHANGES", |
| 2435 | "added, moved or deleted file(s), does MAINTAINERS need updating?\n" . $herecurr); |
| 2436 | } |
| 2437 | |
Andy Whitcroft | 00df344 | 2007-06-08 13:47:06 -0700 | [diff] [blame] | 2438 | # Check for wrappage within a valid hunk of the file |
Andy Whitcroft | 8905a67 | 2007-11-28 16:21:06 -0800 | [diff] [blame] | 2439 | if ($realcnt != 0 && $line !~ m{^(?:\+|-| |\\ No newline|$)}) { |
Joe Perches | 000d1cc1 | 2011-07-25 17:13:25 -0700 | [diff] [blame] | 2440 | ERROR("CORRUPTED_PATCH", |
| 2441 | "patch seems to be corrupt (line wrapped?)\n" . |
Andy Whitcroft | 6c72ffa | 2007-10-18 03:05:08 -0700 | [diff] [blame] | 2442 | $herecurr) if (!$emitted_corrupt++); |
Andy Whitcroft | de7d4f0 | 2007-07-15 23:37:22 -0700 | [diff] [blame] | 2443 | } |
| 2444 | |
Andy Whitcroft | 6ecd967 | 2008-10-15 22:02:21 -0700 | [diff] [blame] | 2445 | # Check for absolute kernel paths. |
| 2446 | if ($tree) { |
| 2447 | while ($line =~ m{(?:^|\s)(/\S*)}g) { |
| 2448 | my $file = $1; |
| 2449 | |
| 2450 | if ($file =~ m{^(.*?)(?::\d+)+:?$} && |
| 2451 | check_absolute_file($1, $herecurr)) { |
| 2452 | # |
| 2453 | } else { |
| 2454 | check_absolute_file($file, $herecurr); |
| 2455 | } |
| 2456 | } |
| 2457 | } |
| 2458 | |
Andy Whitcroft | de7d4f0 | 2007-07-15 23:37:22 -0700 | [diff] [blame] | 2459 | # UTF-8 regex found at http://www.w3.org/International/questions/qa-forms-utf-8.en.php |
| 2460 | if (($realfile =~ /^$/ || $line =~ /^\+/) && |
Andy Whitcroft | 171ae1a | 2008-04-29 00:59:32 -0700 | [diff] [blame] | 2461 | $rawline !~ m/^$UTF8*$/) { |
| 2462 | my ($utf8_prefix) = ($rawline =~ /^($UTF8*)/); |
| 2463 | |
| 2464 | my $blank = copy_spacing($rawline); |
| 2465 | my $ptr = substr($blank, 0, length($utf8_prefix)) . "^"; |
| 2466 | my $hereptr = "$hereline$ptr\n"; |
| 2467 | |
Joe Perches | 34d9921 | 2011-07-25 17:13:26 -0700 | [diff] [blame] | 2468 | CHK("INVALID_UTF8", |
| 2469 | "Invalid UTF-8, patch and commit message should be encoded in UTF-8\n" . $hereptr); |
Andy Whitcroft | 00df344 | 2007-06-08 13:47:06 -0700 | [diff] [blame] | 2470 | } |
Andy Whitcroft | 0a920b5 | 2007-06-01 00:46:48 -0700 | [diff] [blame] | 2471 | |
Joe Perches | 15662b3 | 2011-10-31 17:13:12 -0700 | [diff] [blame] | 2472 | # Check if it's the start of a commit log |
| 2473 | # (not a header line and we haven't seen the patch filename) |
| 2474 | if ($in_header_lines && $realfile =~ /^$/ && |
Joe Perches | 29ee1b0 | 2014-08-06 16:10:35 -0700 | [diff] [blame] | 2475 | !($rawline =~ /^\s+\S/ || |
| 2476 | $rawline =~ /^(commit\b|from\b|[\w-]+:).*$/i)) { |
Joe Perches | 15662b3 | 2011-10-31 17:13:12 -0700 | [diff] [blame] | 2477 | $in_header_lines = 0; |
| 2478 | $in_commit_log = 1; |
| 2479 | } |
| 2480 | |
Pasi Savanainen | fa64205d | 2012-10-04 17:13:29 -0700 | [diff] [blame] | 2481 | # Check if there is UTF-8 in a commit log when a mail header has explicitly |
| 2482 | # declined it, i.e defined some charset where it is missing. |
| 2483 | if ($in_header_lines && |
| 2484 | $rawline =~ /^Content-Type:.+charset="(.+)".*$/ && |
| 2485 | $1 !~ /utf-8/i) { |
| 2486 | $non_utf8_charset = 1; |
| 2487 | } |
| 2488 | |
| 2489 | if ($in_commit_log && $non_utf8_charset && $realfile =~ /^$/ && |
Joe Perches | 15662b3 | 2011-10-31 17:13:12 -0700 | [diff] [blame] | 2490 | $rawline =~ /$NON_ASCII_UTF8/) { |
Pasi Savanainen | fa64205d | 2012-10-04 17:13:29 -0700 | [diff] [blame] | 2491 | WARN("UTF8_BEFORE_PATCH", |
Joe Perches | 15662b3 | 2011-10-31 17:13:12 -0700 | [diff] [blame] | 2492 | "8-bit UTF-8 used in possible commit log\n" . $herecurr); |
| 2493 | } |
| 2494 | |
Kees Cook | 66b47b4 | 2014-10-13 15:51:57 -0700 | [diff] [blame] | 2495 | # Check for various typo / spelling mistakes |
Joe Perches | 66d7a38 | 2015-04-16 12:44:08 -0700 | [diff] [blame] | 2496 | if (defined($misspellings) && |
| 2497 | ($in_commit_log || $line =~ /^(?:\+|Subject:)/i)) { |
Joe Perches | ebfd7d6 | 2015-04-16 12:44:14 -0700 | [diff] [blame] | 2498 | while ($rawline =~ /(?:^|[^a-z@])($misspellings)(?:\b|$|[^a-z@])/gi) { |
Kees Cook | 66b47b4 | 2014-10-13 15:51:57 -0700 | [diff] [blame] | 2499 | my $typo = $1; |
| 2500 | my $typo_fix = $spelling_fix{lc($typo)}; |
| 2501 | $typo_fix = ucfirst($typo_fix) if ($typo =~ /^[A-Z]/); |
| 2502 | $typo_fix = uc($typo_fix) if ($typo =~ /^[A-Z]+$/); |
| 2503 | my $msg_type = \&WARN; |
| 2504 | $msg_type = \&CHK if ($file); |
| 2505 | if (&{$msg_type}("TYPO_SPELLING", |
| 2506 | "'$typo' may be misspelled - perhaps '$typo_fix'?\n" . $herecurr) && |
| 2507 | $fix) { |
| 2508 | $fixed[$fixlinenr] =~ s/(^|[^A-Za-z@])($typo)($|[^A-Za-z@])/$1$typo_fix$3/; |
| 2509 | } |
| 2510 | } |
| 2511 | } |
| 2512 | |
Andy Whitcroft | 30670854 | 2008-10-15 22:02:28 -0700 | [diff] [blame] | 2513 | # ignore non-hunk lines and lines being removed |
| 2514 | next if (!$hunk_line || $line =~ /^-/); |
Andy Whitcroft | 00df344 | 2007-06-08 13:47:06 -0700 | [diff] [blame] | 2515 | |
Andy Whitcroft | 0a920b5 | 2007-06-01 00:46:48 -0700 | [diff] [blame] | 2516 | #trailing whitespace |
Andy Whitcroft | 9c0ca6f | 2007-10-16 23:29:38 -0700 | [diff] [blame] | 2517 | if ($line =~ /^\+.*\015/) { |
Andy Whitcroft | c2fdda0 | 2008-02-08 04:20:54 -0800 | [diff] [blame] | 2518 | my $herevet = "$here\n" . cat_vet($rawline) . "\n"; |
Joe Perches | d5e616f | 2013-09-11 14:23:54 -0700 | [diff] [blame] | 2519 | if (ERROR("DOS_LINE_ENDINGS", |
| 2520 | "DOS line endings\n" . $herevet) && |
| 2521 | $fix) { |
Joe Perches | 194f66f | 2014-08-06 16:11:03 -0700 | [diff] [blame] | 2522 | $fixed[$fixlinenr] =~ s/[\s\015]+$//; |
Joe Perches | d5e616f | 2013-09-11 14:23:54 -0700 | [diff] [blame] | 2523 | } |
Andy Whitcroft | c2fdda0 | 2008-02-08 04:20:54 -0800 | [diff] [blame] | 2524 | } elsif ($rawline =~ /^\+.*\S\s+$/ || $rawline =~ /^\+\s+$/) { |
| 2525 | my $herevet = "$here\n" . cat_vet($rawline) . "\n"; |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 2526 | if (ERROR("TRAILING_WHITESPACE", |
| 2527 | "trailing whitespace\n" . $herevet) && |
| 2528 | $fix) { |
Joe Perches | 194f66f | 2014-08-06 16:11:03 -0700 | [diff] [blame] | 2529 | $fixed[$fixlinenr] =~ s/\s+$//; |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 2530 | } |
| 2531 | |
Andy Whitcroft | d2c0a23 | 2010-10-26 14:23:12 -0700 | [diff] [blame] | 2532 | $rpt_cleaners = 1; |
Andy Whitcroft | 0a920b5 | 2007-06-01 00:46:48 -0700 | [diff] [blame] | 2533 | } |
Andy Whitcroft | 5368df2 | 2008-10-15 22:02:27 -0700 | [diff] [blame] | 2534 | |
Josh Triplett | 4783f89 | 2013-11-12 15:10:12 -0800 | [diff] [blame] | 2535 | # Check for FSF mailing addresses. |
Alexander Duyck | 109d8cb | 2014-01-23 15:54:50 -0800 | [diff] [blame] | 2536 | if ($rawline =~ /\bwrite to the Free/i || |
Joe Perches | 3e2232f | 2014-01-23 15:54:48 -0800 | [diff] [blame] | 2537 | $rawline =~ /\b59\s+Temple\s+Pl/i || |
| 2538 | $rawline =~ /\b51\s+Franklin\s+St/i) { |
Josh Triplett | 4783f89 | 2013-11-12 15:10:12 -0800 | [diff] [blame] | 2539 | my $herevet = "$here\n" . cat_vet($rawline) . "\n"; |
| 2540 | my $msg_type = \&ERROR; |
| 2541 | $msg_type = \&CHK if ($file); |
| 2542 | &{$msg_type}("FSF_MAILING_ADDRESS", |
Joe Perches | 3e2232f | 2014-01-23 15:54:48 -0800 | [diff] [blame] | 2543 | "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) |
Josh Triplett | 4783f89 | 2013-11-12 15:10:12 -0800 | [diff] [blame] | 2544 | } |
| 2545 | |
Andi Kleen | 3354957 | 2010-05-24 14:33:29 -0700 | [diff] [blame] | 2546 | # check for Kconfig help text having a real description |
Andy Whitcroft | 9fe287d7 | 2010-10-26 14:23:15 -0700 | [diff] [blame] | 2547 | # Only applies when adding the entry originally, after that we do not have |
| 2548 | # sufficient context to determine whether it is indeed long enough. |
Andi Kleen | 3354957 | 2010-05-24 14:33:29 -0700 | [diff] [blame] | 2549 | if ($realfile =~ /Kconfig/ && |
Joe Perches | 8d73e0e | 2014-08-06 16:10:46 -0700 | [diff] [blame] | 2550 | $line =~ /^\+\s*config\s+/) { |
Andi Kleen | 3354957 | 2010-05-24 14:33:29 -0700 | [diff] [blame] | 2551 | my $length = 0; |
Andy Whitcroft | 9fe287d7 | 2010-10-26 14:23:15 -0700 | [diff] [blame] | 2552 | my $cnt = $realcnt; |
| 2553 | my $ln = $linenr + 1; |
| 2554 | my $f; |
Andy Whitcroft | a138580 | 2012-01-10 15:10:03 -0800 | [diff] [blame] | 2555 | my $is_start = 0; |
Andy Whitcroft | 9fe287d7 | 2010-10-26 14:23:15 -0700 | [diff] [blame] | 2556 | my $is_end = 0; |
Andy Whitcroft | a138580 | 2012-01-10 15:10:03 -0800 | [diff] [blame] | 2557 | for (; $cnt > 0 && defined $lines[$ln - 1]; $ln++) { |
Andy Whitcroft | 9fe287d7 | 2010-10-26 14:23:15 -0700 | [diff] [blame] | 2558 | $f = $lines[$ln - 1]; |
| 2559 | $cnt-- if ($lines[$ln - 1] !~ /^-/); |
| 2560 | $is_end = $lines[$ln - 1] =~ /^\+/; |
Andy Whitcroft | 9fe287d7 | 2010-10-26 14:23:15 -0700 | [diff] [blame] | 2561 | |
| 2562 | next if ($f =~ /^-/); |
Joe Perches | 8d73e0e | 2014-08-06 16:10:46 -0700 | [diff] [blame] | 2563 | last if (!$file && $f =~ /^\@\@/); |
Andy Whitcroft | a138580 | 2012-01-10 15:10:03 -0800 | [diff] [blame] | 2564 | |
Joe Perches | 8d73e0e | 2014-08-06 16:10:46 -0700 | [diff] [blame] | 2565 | if ($lines[$ln - 1] =~ /^\+\s*(?:bool|tristate)\s*\"/) { |
Andy Whitcroft | a138580 | 2012-01-10 15:10:03 -0800 | [diff] [blame] | 2566 | $is_start = 1; |
Joe Perches | 8d73e0e | 2014-08-06 16:10:46 -0700 | [diff] [blame] | 2567 | } elsif ($lines[$ln - 1] =~ /^\+\s*(?:---)?help(?:---)?$/) { |
Andy Whitcroft | a138580 | 2012-01-10 15:10:03 -0800 | [diff] [blame] | 2568 | $length = -1; |
| 2569 | } |
| 2570 | |
Andy Whitcroft | 9fe287d7 | 2010-10-26 14:23:15 -0700 | [diff] [blame] | 2571 | $f =~ s/^.//; |
Andi Kleen | 3354957 | 2010-05-24 14:33:29 -0700 | [diff] [blame] | 2572 | $f =~ s/#.*//; |
| 2573 | $f =~ s/^\s+//; |
| 2574 | next if ($f =~ /^$/); |
Andy Whitcroft | 9fe287d7 | 2010-10-26 14:23:15 -0700 | [diff] [blame] | 2575 | if ($f =~ /^\s*config\s/) { |
| 2576 | $is_end = 1; |
| 2577 | last; |
| 2578 | } |
Andi Kleen | 3354957 | 2010-05-24 14:33:29 -0700 | [diff] [blame] | 2579 | $length++; |
| 2580 | } |
Vadim Bendebury | 5619327 | 2014-10-13 15:51:48 -0700 | [diff] [blame] | 2581 | if ($is_start && $is_end && $length < $min_conf_desc_length) { |
| 2582 | WARN("CONFIG_DESCRIPTION", |
| 2583 | "please write a paragraph that describes the config symbol fully\n" . $herecurr); |
| 2584 | } |
Andy Whitcroft | a138580 | 2012-01-10 15:10:03 -0800 | [diff] [blame] | 2585 | #print "is_start<$is_start> is_end<$is_end> length<$length>\n"; |
Andi Kleen | 3354957 | 2010-05-24 14:33:29 -0700 | [diff] [blame] | 2586 | } |
| 2587 | |
Kees Cook | 1ba8dfd | 2012-12-17 16:01:48 -0800 | [diff] [blame] | 2588 | # discourage the addition of CONFIG_EXPERIMENTAL in Kconfig. |
| 2589 | if ($realfile =~ /Kconfig/ && |
| 2590 | $line =~ /.\s*depends on\s+.*\bEXPERIMENTAL\b/) { |
| 2591 | WARN("CONFIG_EXPERIMENTAL", |
| 2592 | "Use of CONFIG_EXPERIMENTAL is deprecated. For alternatives, see https://lkml.org/lkml/2012/10/23/580\n"); |
| 2593 | } |
| 2594 | |
Christoph Jaeger | 327953e | 2015-02-13 14:38:29 -0800 | [diff] [blame] | 2595 | # discourage the use of boolean for type definition attributes of Kconfig options |
| 2596 | if ($realfile =~ /Kconfig/ && |
| 2597 | $line =~ /^\+\s*\bboolean\b/) { |
| 2598 | WARN("CONFIG_TYPE_BOOLEAN", |
| 2599 | "Use of boolean is deprecated, please use bool instead.\n" . $herecurr); |
| 2600 | } |
| 2601 | |
Arnaud Lacombe | c68e587 | 2011-08-15 01:07:14 -0400 | [diff] [blame] | 2602 | if (($realfile =~ /Makefile.*/ || $realfile =~ /Kbuild.*/) && |
| 2603 | ($line =~ /\+(EXTRA_[A-Z]+FLAGS).*/)) { |
| 2604 | my $flag = $1; |
| 2605 | my $replacement = { |
| 2606 | 'EXTRA_AFLAGS' => 'asflags-y', |
| 2607 | 'EXTRA_CFLAGS' => 'ccflags-y', |
| 2608 | 'EXTRA_CPPFLAGS' => 'cppflags-y', |
| 2609 | 'EXTRA_LDFLAGS' => 'ldflags-y', |
| 2610 | }; |
| 2611 | |
| 2612 | WARN("DEPRECATED_VARIABLE", |
| 2613 | "Use of $flag is deprecated, please use \`$replacement->{$flag} instead.\n" . $herecurr) if ($replacement->{$flag}); |
| 2614 | } |
| 2615 | |
Rob Herring | bff5da4 | 2014-01-23 15:54:51 -0800 | [diff] [blame] | 2616 | # check for DT compatible documentation |
Florian Vaussard | 7dd05b3 | 2014-04-03 14:49:26 -0700 | [diff] [blame] | 2617 | if (defined $root && |
| 2618 | (($realfile =~ /\.dtsi?$/ && $line =~ /^\+\s*compatible\s*=\s*\"/) || |
| 2619 | ($realfile =~ /\.[ch]$/ && $line =~ /^\+.*\.compatible\s*=\s*\"/))) { |
| 2620 | |
Rob Herring | bff5da4 | 2014-01-23 15:54:51 -0800 | [diff] [blame] | 2621 | my @compats = $rawline =~ /\"([a-zA-Z0-9\-\,\.\+_]+)\"/g; |
| 2622 | |
Florian Vaussard | cc93319 | 2014-04-03 14:49:27 -0700 | [diff] [blame] | 2623 | my $dt_path = $root . "/Documentation/devicetree/bindings/"; |
| 2624 | my $vp_file = $dt_path . "vendor-prefixes.txt"; |
| 2625 | |
Rob Herring | bff5da4 | 2014-01-23 15:54:51 -0800 | [diff] [blame] | 2626 | foreach my $compat (@compats) { |
| 2627 | my $compat2 = $compat; |
Rob Herring | 185d566 | 2014-06-04 16:12:03 -0700 | [diff] [blame] | 2628 | $compat2 =~ s/\,[a-zA-Z0-9]*\-/\,<\.\*>\-/; |
| 2629 | my $compat3 = $compat; |
| 2630 | $compat3 =~ s/\,([a-z]*)[0-9]*\-/\,$1<\.\*>\-/; |
| 2631 | `grep -Erq "$compat|$compat2|$compat3" $dt_path`; |
Rob Herring | bff5da4 | 2014-01-23 15:54:51 -0800 | [diff] [blame] | 2632 | if ( $? >> 8 ) { |
| 2633 | WARN("UNDOCUMENTED_DT_STRING", |
| 2634 | "DT compatible string \"$compat\" appears un-documented -- check $dt_path\n" . $herecurr); |
| 2635 | } |
| 2636 | |
Florian Vaussard | 4fbf32a | 2014-04-03 14:49:25 -0700 | [diff] [blame] | 2637 | next if $compat !~ /^([a-zA-Z0-9\-]+)\,/; |
| 2638 | my $vendor = $1; |
Florian Vaussard | cc93319 | 2014-04-03 14:49:27 -0700 | [diff] [blame] | 2639 | `grep -Eq "^$vendor\\b" $vp_file`; |
Rob Herring | bff5da4 | 2014-01-23 15:54:51 -0800 | [diff] [blame] | 2640 | if ( $? >> 8 ) { |
| 2641 | WARN("UNDOCUMENTED_DT_STRING", |
Florian Vaussard | cc93319 | 2014-04-03 14:49:27 -0700 | [diff] [blame] | 2642 | "DT compatible string vendor \"$vendor\" appears un-documented -- check $vp_file\n" . $herecurr); |
Rob Herring | bff5da4 | 2014-01-23 15:54:51 -0800 | [diff] [blame] | 2643 | } |
| 2644 | } |
| 2645 | } |
| 2646 | |
Andy Whitcroft | 5368df2 | 2008-10-15 22:02:27 -0700 | [diff] [blame] | 2647 | # check we are in a valid source file if not then ignore this hunk |
Geert Uytterhoeven | de4c924 | 2014-10-13 15:51:46 -0700 | [diff] [blame] | 2648 | next if ($realfile !~ /\.(h|c|s|S|pl|sh|dtsi|dts)$/); |
Andy Whitcroft | 5368df2 | 2008-10-15 22:02:27 -0700 | [diff] [blame] | 2649 | |
Joe Perches | 47e0c88 | 2015-06-25 15:02:57 -0700 | [diff] [blame] | 2650 | # line length limit (with some exclusions) |
| 2651 | # |
| 2652 | # There are a few types of lines that may extend beyond $max_line_length: |
| 2653 | # logging functions like pr_info that end in a string |
| 2654 | # lines with a single string |
| 2655 | # #defines that are a single string |
| 2656 | # |
| 2657 | # There are 3 different line length message types: |
| 2658 | # LONG_LINE_COMMENT a comment starts before but extends beyond $max_linelength |
| 2659 | # LONG_LINE_STRING a string starts before but extends beyond $max_line_length |
| 2660 | # LONG_LINE all other lines longer than $max_line_length |
| 2661 | # |
| 2662 | # if LONG_LINE is ignored, the other 2 types are also ignored |
| 2663 | # |
| 2664 | |
Joe Perches | b4749e9 | 2015-07-17 16:24:01 -0700 | [diff] [blame] | 2665 | if ($line =~ /^\+/ && $length > $max_line_length) { |
Joe Perches | 47e0c88 | 2015-06-25 15:02:57 -0700 | [diff] [blame] | 2666 | my $msg_type = "LONG_LINE"; |
| 2667 | |
| 2668 | # Check the allowed long line types first |
| 2669 | |
| 2670 | # logging functions that end in a string that starts |
| 2671 | # before $max_line_length |
| 2672 | if ($line =~ /^\+\s*$logFunctions\s*\(\s*(?:(?:KERN_\S+\s*|[^"]*))?($String\s*(?:|,|\)\s*;)\s*)$/ && |
| 2673 | length(expand_tabs(substr($line, 1, length($line) - length($1) - 1))) <= $max_line_length) { |
| 2674 | $msg_type = ""; |
| 2675 | |
| 2676 | # lines with only strings (w/ possible termination) |
| 2677 | # #defines with only strings |
| 2678 | } elsif ($line =~ /^\+\s*$String\s*(?:\s*|,|\)\s*;)\s*$/ || |
| 2679 | $line =~ /^\+\s*#\s*define\s+\w+\s+$String$/) { |
| 2680 | $msg_type = ""; |
| 2681 | |
| 2682 | # Otherwise set the alternate message types |
| 2683 | |
| 2684 | # a comment starts before $max_line_length |
| 2685 | } elsif ($line =~ /($;[\s$;]*)$/ && |
| 2686 | length(expand_tabs(substr($line, 1, length($line) - length($1) - 1))) <= $max_line_length) { |
| 2687 | $msg_type = "LONG_LINE_COMMENT" |
| 2688 | |
| 2689 | # a quoted string starts before $max_line_length |
| 2690 | } elsif ($sline =~ /\s*($String(?:\s*(?:\\|,\s*|\)\s*;\s*))?)$/ && |
| 2691 | length(expand_tabs(substr($line, 1, length($line) - length($1) - 1))) <= $max_line_length) { |
| 2692 | $msg_type = "LONG_LINE_STRING" |
| 2693 | } |
| 2694 | |
| 2695 | if ($msg_type ne "" && |
| 2696 | (show_type("LONG_LINE") || show_type($msg_type))) { |
| 2697 | WARN($msg_type, |
| 2698 | "line over $max_line_length characters\n" . $herecurr); |
| 2699 | } |
Andy Whitcroft | 0a920b5 | 2007-06-01 00:46:48 -0700 | [diff] [blame] | 2700 | } |
| 2701 | |
Andy Whitcroft | 8905a67 | 2007-11-28 16:21:06 -0800 | [diff] [blame] | 2702 | # check for adding lines without a newline. |
| 2703 | if ($line =~ /^\+/ && defined $lines[$linenr] && $lines[$linenr] =~ /^\\ No newline at end of file/) { |
Joe Perches | 000d1cc1 | 2011-07-25 17:13:25 -0700 | [diff] [blame] | 2704 | WARN("MISSING_EOF_NEWLINE", |
| 2705 | "adding a line without newline at end of file\n" . $herecurr); |
Andy Whitcroft | 8905a67 | 2007-11-28 16:21:06 -0800 | [diff] [blame] | 2706 | } |
| 2707 | |
Mike Frysinger | 42e41c5 | 2009-09-21 17:04:40 -0700 | [diff] [blame] | 2708 | # Blackfin: use hi/lo macros |
| 2709 | if ($realfile =~ m@arch/blackfin/.*\.S$@) { |
| 2710 | if ($line =~ /\.[lL][[:space:]]*=.*&[[:space:]]*0x[fF][fF][fF][fF]/) { |
| 2711 | my $herevet = "$here\n" . cat_vet($line) . "\n"; |
Joe Perches | 000d1cc1 | 2011-07-25 17:13:25 -0700 | [diff] [blame] | 2712 | ERROR("LO_MACRO", |
| 2713 | "use the LO() macro, not (... & 0xFFFF)\n" . $herevet); |
Mike Frysinger | 42e41c5 | 2009-09-21 17:04:40 -0700 | [diff] [blame] | 2714 | } |
| 2715 | if ($line =~ /\.[hH][[:space:]]*=.*>>[[:space:]]*16/) { |
| 2716 | my $herevet = "$here\n" . cat_vet($line) . "\n"; |
Joe Perches | 000d1cc1 | 2011-07-25 17:13:25 -0700 | [diff] [blame] | 2717 | ERROR("HI_MACRO", |
| 2718 | "use the HI() macro, not (... >> 16)\n" . $herevet); |
Mike Frysinger | 42e41c5 | 2009-09-21 17:04:40 -0700 | [diff] [blame] | 2719 | } |
| 2720 | } |
| 2721 | |
Andy Whitcroft | b9ea10d | 2008-10-15 22:02:24 -0700 | [diff] [blame] | 2722 | # check we are in a valid source file C or perl if not then ignore this hunk |
Geert Uytterhoeven | de4c924 | 2014-10-13 15:51:46 -0700 | [diff] [blame] | 2723 | next if ($realfile !~ /\.(h|c|pl|dtsi|dts)$/); |
Andy Whitcroft | 0a920b5 | 2007-06-01 00:46:48 -0700 | [diff] [blame] | 2724 | |
| 2725 | # at the beginning of a line any tabs must come first and anything |
| 2726 | # more than 8 must use tabs. |
Andy Whitcroft | c2fdda0 | 2008-02-08 04:20:54 -0800 | [diff] [blame] | 2727 | if ($rawline =~ /^\+\s* \t\s*\S/ || |
| 2728 | $rawline =~ /^\+\s* \s*/) { |
| 2729 | my $herevet = "$here\n" . cat_vet($rawline) . "\n"; |
Andy Whitcroft | d2c0a23 | 2010-10-26 14:23:12 -0700 | [diff] [blame] | 2730 | $rpt_cleaners = 1; |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 2731 | if (ERROR("CODE_INDENT", |
| 2732 | "code indent should use tabs where possible\n" . $herevet) && |
| 2733 | $fix) { |
Joe Perches | 194f66f | 2014-08-06 16:11:03 -0700 | [diff] [blame] | 2734 | $fixed[$fixlinenr] =~ s/^\+([ \t]+)/"\+" . tabify($1)/e; |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 2735 | } |
Andy Whitcroft | 0a920b5 | 2007-06-01 00:46:48 -0700 | [diff] [blame] | 2736 | } |
| 2737 | |
Alberto Panizzo | 08e4436 | 2010-03-05 13:43:54 -0800 | [diff] [blame] | 2738 | # check for space before tabs. |
| 2739 | if ($rawline =~ /^\+/ && $rawline =~ / \t/) { |
| 2740 | my $herevet = "$here\n" . cat_vet($rawline) . "\n"; |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 2741 | if (WARN("SPACE_BEFORE_TAB", |
| 2742 | "please, no space before tabs\n" . $herevet) && |
| 2743 | $fix) { |
Joe Perches | 194f66f | 2014-08-06 16:11:03 -0700 | [diff] [blame] | 2744 | while ($fixed[$fixlinenr] =~ |
Joe Perches | d2207cc | 2014-10-13 15:51:53 -0700 | [diff] [blame] | 2745 | s/(^\+.*) {8,8}\t/$1\t\t/) {} |
Joe Perches | 194f66f | 2014-08-06 16:11:03 -0700 | [diff] [blame] | 2746 | while ($fixed[$fixlinenr] =~ |
Joe Perches | c76f4cb | 2014-01-23 15:54:46 -0800 | [diff] [blame] | 2747 | s/(^\+.*) +\t/$1\t/) {} |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 2748 | } |
Alberto Panizzo | 08e4436 | 2010-03-05 13:43:54 -0800 | [diff] [blame] | 2749 | } |
| 2750 | |
Joe Perches | d1fe9c0 | 2012-03-23 15:02:16 -0700 | [diff] [blame] | 2751 | # check for && or || at the start of a line |
| 2752 | if ($rawline =~ /^\+\s*(&&|\|\|)/) { |
| 2753 | CHK("LOGICAL_CONTINUATIONS", |
| 2754 | "Logical continuations should be on the previous line\n" . $hereprev); |
| 2755 | } |
| 2756 | |
| 2757 | # check multi-line statement indentation matches previous line |
| 2758 | if ($^V && $^V ge 5.10.0 && |
Joe Perches | 91cb519 | 2014-04-03 14:49:32 -0700 | [diff] [blame] | 2759 | $prevline =~ /^\+([ \t]*)((?:$c90_Keywords(?:\s+if)\s*)|(?:$Declare\s*)?(?:$Ident|\(\s*\*\s*$Ident\s*\))\s*|$Ident\s*=\s*$Ident\s*)\(.*(\&\&|\|\||,)\s*$/) { |
Joe Perches | d1fe9c0 | 2012-03-23 15:02:16 -0700 | [diff] [blame] | 2760 | $prevline =~ /^\+(\t*)(.*)$/; |
| 2761 | my $oldindent = $1; |
| 2762 | my $rest = $2; |
| 2763 | |
| 2764 | my $pos = pos_last_openparen($rest); |
| 2765 | if ($pos >= 0) { |
Joe Perches | b34a26f | 2012-07-30 14:41:16 -0700 | [diff] [blame] | 2766 | $line =~ /^(\+| )([ \t]*)/; |
| 2767 | my $newindent = $2; |
Joe Perches | d1fe9c0 | 2012-03-23 15:02:16 -0700 | [diff] [blame] | 2768 | |
| 2769 | my $goodtabindent = $oldindent . |
| 2770 | "\t" x ($pos / 8) . |
| 2771 | " " x ($pos % 8); |
| 2772 | my $goodspaceindent = $oldindent . " " x $pos; |
| 2773 | |
| 2774 | if ($newindent ne $goodtabindent && |
| 2775 | $newindent ne $goodspaceindent) { |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 2776 | |
| 2777 | if (CHK("PARENTHESIS_ALIGNMENT", |
| 2778 | "Alignment should match open parenthesis\n" . $hereprev) && |
| 2779 | $fix && $line =~ /^\+/) { |
Joe Perches | 194f66f | 2014-08-06 16:11:03 -0700 | [diff] [blame] | 2780 | $fixed[$fixlinenr] =~ |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 2781 | s/^\+[ \t]*/\+$goodtabindent/; |
| 2782 | } |
Joe Perches | d1fe9c0 | 2012-03-23 15:02:16 -0700 | [diff] [blame] | 2783 | } |
| 2784 | } |
| 2785 | } |
| 2786 | |
Joe Perches | 6ab3a97 | 2015-04-16 12:44:05 -0700 | [diff] [blame] | 2787 | # check for space after cast like "(int) foo" or "(struct foo) bar" |
| 2788 | # avoid checking a few false positives: |
| 2789 | # "sizeof(<type>)" or "__alignof__(<type>)" |
| 2790 | # function pointer declarations like "(*foo)(int) = bar;" |
| 2791 | # structure definitions like "(struct foo) { 0 };" |
| 2792 | # multiline macros that define functions |
| 2793 | # known attributes or the __attribute__ keyword |
| 2794 | if ($line =~ /^\+(.*)\(\s*$Type\s*\)([ \t]++)((?![={]|\\$|$Attribute|__attribute__))/ && |
| 2795 | (!defined($1) || $1 !~ /\b(?:sizeof|__alignof__)\s*$/)) { |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 2796 | if (CHK("SPACING", |
Joe Perches | f27c95d | 2014-08-06 16:10:52 -0700 | [diff] [blame] | 2797 | "No space is necessary after a cast\n" . $herecurr) && |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 2798 | $fix) { |
Joe Perches | 194f66f | 2014-08-06 16:11:03 -0700 | [diff] [blame] | 2799 | $fixed[$fixlinenr] =~ |
Joe Perches | f27c95d | 2014-08-06 16:10:52 -0700 | [diff] [blame] | 2800 | s/(\(\s*$Type\s*\))[ \t]+/$1/; |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 2801 | } |
Joe Perches | aad4f61 | 2012-03-23 15:02:19 -0700 | [diff] [blame] | 2802 | } |
| 2803 | |
Joe Perches | 86406b1 | 2015-09-09 15:37:41 -0700 | [diff] [blame] | 2804 | # Block comment styles |
| 2805 | # Networking with an initial /* |
Joe Perches | 0588060 | 2012-10-04 17:13:35 -0700 | [diff] [blame] | 2806 | if ($realfile =~ m@^(drivers/net/|net/)@ && |
Joe Perches | fdb4bcd | 2013-07-03 15:05:23 -0700 | [diff] [blame] | 2807 | $prevrawline =~ /^\+[ \t]*\/\*[ \t]*$/ && |
Joe Perches | 85ad978 | 2014-04-03 14:49:20 -0700 | [diff] [blame] | 2808 | $rawline =~ /^\+[ \t]*\*/ && |
| 2809 | $realline > 2) { |
Joe Perches | 0588060 | 2012-10-04 17:13:35 -0700 | [diff] [blame] | 2810 | WARN("NETWORKING_BLOCK_COMMENT_STYLE", |
| 2811 | "networking block comments don't use an empty /* line, use /* Comment...\n" . $hereprev); |
| 2812 | } |
| 2813 | |
Joe Perches | 86406b1 | 2015-09-09 15:37:41 -0700 | [diff] [blame] | 2814 | # Block comments use * on subsequent lines |
| 2815 | if ($prevline =~ /$;[ \t]*$/ && #ends in comment |
| 2816 | $prevrawline =~ /^\+.*?\/\*/ && #starting /* |
Joe Perches | a605e32 | 2013-07-03 15:05:24 -0700 | [diff] [blame] | 2817 | $prevrawline !~ /\*\/[ \t]*$/ && #no trailing */ |
Joe Perches | 61135e9 | 2013-09-11 14:23:59 -0700 | [diff] [blame] | 2818 | $rawline =~ /^\+/ && #line is new |
Joe Perches | a605e32 | 2013-07-03 15:05:24 -0700 | [diff] [blame] | 2819 | $rawline !~ /^\+[ \t]*\*/) { #no leading * |
Joe Perches | 86406b1 | 2015-09-09 15:37:41 -0700 | [diff] [blame] | 2820 | WARN("BLOCK_COMMENT_STYLE", |
| 2821 | "Block comments use * on subsequent lines\n" . $hereprev); |
Joe Perches | a605e32 | 2013-07-03 15:05:24 -0700 | [diff] [blame] | 2822 | } |
| 2823 | |
Joe Perches | 86406b1 | 2015-09-09 15:37:41 -0700 | [diff] [blame] | 2824 | # Block comments use */ on trailing lines |
| 2825 | if ($rawline !~ m@^\+[ \t]*\*/[ \t]*$@ && #trailing */ |
Joe Perches | c24f9f1 | 2012-11-08 15:53:29 -0800 | [diff] [blame] | 2826 | $rawline !~ m@^\+.*/\*.*\*/[ \t]*$@ && #inline /*...*/ |
| 2827 | $rawline !~ m@^\+.*\*{2,}/[ \t]*$@ && #trailing **/ |
| 2828 | $rawline =~ m@^\+[ \t]*.+\*\/[ \t]*$@) { #non blank */ |
Joe Perches | 86406b1 | 2015-09-09 15:37:41 -0700 | [diff] [blame] | 2829 | WARN("BLOCK_COMMENT_STYLE", |
| 2830 | "Block comments use a trailing */ on a separate line\n" . $herecurr); |
Joe Perches | 0588060 | 2012-10-04 17:13:35 -0700 | [diff] [blame] | 2831 | } |
| 2832 | |
Joe Perches | 7f61919 | 2014-08-06 16:10:39 -0700 | [diff] [blame] | 2833 | # check for missing blank lines after struct/union declarations |
| 2834 | # with exceptions for various attributes and macros |
| 2835 | if ($prevline =~ /^[\+ ]};?\s*$/ && |
| 2836 | $line =~ /^\+/ && |
| 2837 | !($line =~ /^\+\s*$/ || |
| 2838 | $line =~ /^\+\s*EXPORT_SYMBOL/ || |
| 2839 | $line =~ /^\+\s*MODULE_/i || |
| 2840 | $line =~ /^\+\s*\#\s*(?:end|elif|else)/ || |
| 2841 | $line =~ /^\+[a-z_]*init/ || |
| 2842 | $line =~ /^\+\s*(?:static\s+)?[A-Z_]*ATTR/ || |
| 2843 | $line =~ /^\+\s*DECLARE/ || |
| 2844 | $line =~ /^\+\s*__setup/)) { |
Joe Perches | d752fcc | 2014-08-06 16:11:05 -0700 | [diff] [blame] | 2845 | if (CHK("LINE_SPACING", |
| 2846 | "Please use a blank line after function/struct/union/enum declarations\n" . $hereprev) && |
| 2847 | $fix) { |
Joe Perches | f2d7e4d | 2014-08-06 16:11:07 -0700 | [diff] [blame] | 2848 | fix_insert_line($fixlinenr, "\+"); |
Joe Perches | d752fcc | 2014-08-06 16:11:05 -0700 | [diff] [blame] | 2849 | } |
Joe Perches | 7f61919 | 2014-08-06 16:10:39 -0700 | [diff] [blame] | 2850 | } |
| 2851 | |
Joe Perches | 365dd4e | 2014-08-06 16:10:42 -0700 | [diff] [blame] | 2852 | # check for multiple consecutive blank lines |
| 2853 | if ($prevline =~ /^[\+ ]\s*$/ && |
| 2854 | $line =~ /^\+\s*$/ && |
| 2855 | $last_blank_line != ($linenr - 1)) { |
Joe Perches | d752fcc | 2014-08-06 16:11:05 -0700 | [diff] [blame] | 2856 | if (CHK("LINE_SPACING", |
| 2857 | "Please don't use multiple blank lines\n" . $hereprev) && |
| 2858 | $fix) { |
Joe Perches | f2d7e4d | 2014-08-06 16:11:07 -0700 | [diff] [blame] | 2859 | fix_delete_line($fixlinenr, $rawline); |
Joe Perches | d752fcc | 2014-08-06 16:11:05 -0700 | [diff] [blame] | 2860 | } |
| 2861 | |
Joe Perches | 365dd4e | 2014-08-06 16:10:42 -0700 | [diff] [blame] | 2862 | $last_blank_line = $linenr; |
| 2863 | } |
| 2864 | |
Joe Perches | 3b617e3 | 2014-04-03 14:49:28 -0700 | [diff] [blame] | 2865 | # check for missing blank lines after declarations |
Joe Perches | 3f7bac0 | 2014-06-04 16:12:04 -0700 | [diff] [blame] | 2866 | if ($sline =~ /^\+\s+\S/ && #Not at char 1 |
| 2867 | # actual declarations |
| 2868 | ($prevline =~ /^\+\s+$Declare\s*$Ident\s*[=,;:\[]/ || |
Joe Perches | 5a4e1fd | 2014-08-06 16:10:33 -0700 | [diff] [blame] | 2869 | # function pointer declarations |
| 2870 | $prevline =~ /^\+\s+$Declare\s*\(\s*\*\s*$Ident\s*\)\s*[=,;:\[\(]/ || |
Joe Perches | 3f7bac0 | 2014-06-04 16:12:04 -0700 | [diff] [blame] | 2871 | # foo bar; where foo is some local typedef or #define |
| 2872 | $prevline =~ /^\+\s+$Ident(?:\s+|\s*\*\s*)$Ident\s*[=,;\[]/ || |
| 2873 | # known declaration macros |
| 2874 | $prevline =~ /^\+\s+$declaration_macros/) && |
| 2875 | # for "else if" which can look like "$Ident $Ident" |
| 2876 | !($prevline =~ /^\+\s+$c90_Keywords\b/ || |
| 2877 | # other possible extensions of declaration lines |
| 2878 | $prevline =~ /(?:$Compare|$Assignment|$Operators)\s*$/ || |
| 2879 | # not starting a section or a macro "\" extended line |
| 2880 | $prevline =~ /(?:\{\s*|\\)$/) && |
| 2881 | # looks like a declaration |
| 2882 | !($sline =~ /^\+\s+$Declare\s*$Ident\s*[=,;:\[]/ || |
Joe Perches | 5a4e1fd | 2014-08-06 16:10:33 -0700 | [diff] [blame] | 2883 | # function pointer declarations |
| 2884 | $sline =~ /^\+\s+$Declare\s*\(\s*\*\s*$Ident\s*\)\s*[=,;:\[\(]/ || |
Joe Perches | 3f7bac0 | 2014-06-04 16:12:04 -0700 | [diff] [blame] | 2885 | # foo bar; where foo is some local typedef or #define |
| 2886 | $sline =~ /^\+\s+$Ident(?:\s+|\s*\*\s*)$Ident\s*[=,;\[]/ || |
| 2887 | # known declaration macros |
| 2888 | $sline =~ /^\+\s+$declaration_macros/ || |
| 2889 | # start of struct or union or enum |
Joe Perches | 3b617e3 | 2014-04-03 14:49:28 -0700 | [diff] [blame] | 2890 | $sline =~ /^\+\s+(?:union|struct|enum|typedef)\b/ || |
Joe Perches | 3f7bac0 | 2014-06-04 16:12:04 -0700 | [diff] [blame] | 2891 | # start or end of block or continuation of declaration |
| 2892 | $sline =~ /^\+\s+(?:$|[\{\}\.\#\"\?\:\(\[])/ || |
| 2893 | # bitfield continuation |
| 2894 | $sline =~ /^\+\s+$Ident\s*:\s*\d+\s*[,;]/ || |
| 2895 | # other possible extensions of declaration lines |
| 2896 | $sline =~ /^\+\s+\(?\s*(?:$Compare|$Assignment|$Operators)/) && |
| 2897 | # indentation of previous and current line are the same |
| 2898 | (($prevline =~ /\+(\s+)\S/) && $sline =~ /^\+$1\S/)) { |
Joe Perches | d752fcc | 2014-08-06 16:11:05 -0700 | [diff] [blame] | 2899 | if (WARN("LINE_SPACING", |
| 2900 | "Missing a blank line after declarations\n" . $hereprev) && |
| 2901 | $fix) { |
Joe Perches | f2d7e4d | 2014-08-06 16:11:07 -0700 | [diff] [blame] | 2902 | fix_insert_line($fixlinenr, "\+"); |
Joe Perches | d752fcc | 2014-08-06 16:11:05 -0700 | [diff] [blame] | 2903 | } |
Joe Perches | 3b617e3 | 2014-04-03 14:49:28 -0700 | [diff] [blame] | 2904 | } |
| 2905 | |
Raffaele Recalcati | 5f7ddae | 2010-08-09 17:20:59 -0700 | [diff] [blame] | 2906 | # check for spaces at the beginning of a line. |
Andy Whitcroft | 6b4c5be | 2010-10-26 14:23:11 -0700 | [diff] [blame] | 2907 | # Exceptions: |
| 2908 | # 1) within comments |
| 2909 | # 2) indented preprocessor commands |
| 2910 | # 3) hanging labels |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 2911 | if ($rawline =~ /^\+ / && $line !~ /^\+ *(?:$;|#|$Ident:)/) { |
Raffaele Recalcati | 5f7ddae | 2010-08-09 17:20:59 -0700 | [diff] [blame] | 2912 | my $herevet = "$here\n" . cat_vet($rawline) . "\n"; |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 2913 | if (WARN("LEADING_SPACE", |
| 2914 | "please, no spaces at the start of a line\n" . $herevet) && |
| 2915 | $fix) { |
Joe Perches | 194f66f | 2014-08-06 16:11:03 -0700 | [diff] [blame] | 2916 | $fixed[$fixlinenr] =~ s/^\+([ \t]+)/"\+" . tabify($1)/e; |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 2917 | } |
Raffaele Recalcati | 5f7ddae | 2010-08-09 17:20:59 -0700 | [diff] [blame] | 2918 | } |
| 2919 | |
Andy Whitcroft | b9ea10d | 2008-10-15 22:02:24 -0700 | [diff] [blame] | 2920 | # check we are in a valid C source file if not then ignore this hunk |
| 2921 | next if ($realfile !~ /\.(h|c)$/); |
| 2922 | |
Joe Perches | 032a4c0 | 2014-08-06 16:10:29 -0700 | [diff] [blame] | 2923 | # check indentation of any line with a bare else |
Joe Perches | 840080a | 2014-10-13 15:51:59 -0700 | [diff] [blame] | 2924 | # (but not if it is a multiple line "if (foo) return bar; else return baz;") |
Joe Perches | 032a4c0 | 2014-08-06 16:10:29 -0700 | [diff] [blame] | 2925 | # if the previous line is a break or return and is indented 1 tab more... |
| 2926 | if ($sline =~ /^\+([\t]+)(?:}[ \t]*)?else(?:[ \t]*{)?\s*$/) { |
| 2927 | my $tabs = length($1) + 1; |
Joe Perches | 840080a | 2014-10-13 15:51:59 -0700 | [diff] [blame] | 2928 | if ($prevline =~ /^\+\t{$tabs,$tabs}break\b/ || |
| 2929 | ($prevline =~ /^\+\t{$tabs,$tabs}return\b/ && |
| 2930 | defined $lines[$linenr] && |
| 2931 | $lines[$linenr] !~ /^[ \+]\t{$tabs,$tabs}return/)) { |
Joe Perches | 032a4c0 | 2014-08-06 16:10:29 -0700 | [diff] [blame] | 2932 | WARN("UNNECESSARY_ELSE", |
| 2933 | "else is not generally useful after a break or return\n" . $hereprev); |
| 2934 | } |
| 2935 | } |
| 2936 | |
Joe Perches | c00df19 | 2014-08-06 16:11:01 -0700 | [diff] [blame] | 2937 | # check indentation of a line with a break; |
| 2938 | # if the previous line is a goto or return and is indented the same # of tabs |
| 2939 | if ($sline =~ /^\+([\t]+)break\s*;\s*$/) { |
| 2940 | my $tabs = $1; |
| 2941 | if ($prevline =~ /^\+$tabs(?:goto|return)\b/) { |
| 2942 | WARN("UNNECESSARY_BREAK", |
| 2943 | "break is not useful after a goto or return\n" . $hereprev); |
| 2944 | } |
| 2945 | } |
| 2946 | |
Kees Cook | 1ba8dfd | 2012-12-17 16:01:48 -0800 | [diff] [blame] | 2947 | # discourage the addition of CONFIG_EXPERIMENTAL in #if(def). |
| 2948 | if ($line =~ /^\+\s*\#\s*if.*\bCONFIG_EXPERIMENTAL\b/) { |
| 2949 | WARN("CONFIG_EXPERIMENTAL", |
| 2950 | "Use of CONFIG_EXPERIMENTAL is deprecated. For alternatives, see https://lkml.org/lkml/2012/10/23/580\n"); |
| 2951 | } |
| 2952 | |
Andy Whitcroft | c2fdda0 | 2008-02-08 04:20:54 -0800 | [diff] [blame] | 2953 | # check for RCS/CVS revision markers |
Andy Whitcroft | cf65504 | 2008-03-04 14:28:20 -0800 | [diff] [blame] | 2954 | if ($rawline =~ /^\+.*\$(Revision|Log|Id)(?:\$|)/) { |
Joe Perches | 000d1cc1 | 2011-07-25 17:13:25 -0700 | [diff] [blame] | 2955 | WARN("CVS_KEYWORD", |
| 2956 | "CVS style keyword markers, these will _not_ be updated\n". $herecurr); |
Andy Whitcroft | c2fdda0 | 2008-02-08 04:20:54 -0800 | [diff] [blame] | 2957 | } |
Andy Whitcroft | 22f2a2e | 2007-08-10 13:01:03 -0700 | [diff] [blame] | 2958 | |
Mike Frysinger | 42e41c5 | 2009-09-21 17:04:40 -0700 | [diff] [blame] | 2959 | # Blackfin: don't use __builtin_bfin_[cs]sync |
| 2960 | if ($line =~ /__builtin_bfin_csync/) { |
| 2961 | my $herevet = "$here\n" . cat_vet($line) . "\n"; |
Joe Perches | 000d1cc1 | 2011-07-25 17:13:25 -0700 | [diff] [blame] | 2962 | ERROR("CSYNC", |
| 2963 | "use the CSYNC() macro in asm/blackfin.h\n" . $herevet); |
Mike Frysinger | 42e41c5 | 2009-09-21 17:04:40 -0700 | [diff] [blame] | 2964 | } |
| 2965 | if ($line =~ /__builtin_bfin_ssync/) { |
| 2966 | my $herevet = "$here\n" . cat_vet($line) . "\n"; |
Joe Perches | 000d1cc1 | 2011-07-25 17:13:25 -0700 | [diff] [blame] | 2967 | ERROR("SSYNC", |
| 2968 | "use the SSYNC() macro in asm/blackfin.h\n" . $herevet); |
Mike Frysinger | 42e41c5 | 2009-09-21 17:04:40 -0700 | [diff] [blame] | 2969 | } |
| 2970 | |
Joe Perches | 56e77d7 | 2013-02-21 16:44:14 -0800 | [diff] [blame] | 2971 | # check for old HOTPLUG __dev<foo> section markings |
| 2972 | if ($line =~ /\b(__dev(init|exit)(data|const|))\b/) { |
| 2973 | WARN("HOTPLUG_SECTION", |
| 2974 | "Using $1 is unnecessary\n" . $herecurr); |
| 2975 | } |
| 2976 | |
Andy Whitcroft | 9c0ca6f | 2007-10-16 23:29:38 -0700 | [diff] [blame] | 2977 | # Check for potential 'bare' types |
Andy Whitcroft | 2b474a1 | 2009-10-26 16:50:16 -0700 | [diff] [blame] | 2978 | my ($stat, $cond, $line_nr_next, $remain_next, $off_next, |
| 2979 | $realline_next); |
Andy Whitcroft | 3e469cd | 2012-01-10 15:10:01 -0800 | [diff] [blame] | 2980 | #print "LINE<$line>\n"; |
| 2981 | if ($linenr >= $suppress_statement && |
Joe Perches | 1b5539b | 2013-09-11 14:24:03 -0700 | [diff] [blame] | 2982 | $realcnt && $sline =~ /.\s*\S/) { |
Andy Whitcroft | 170d3a2 | 2008-10-15 22:02:30 -0700 | [diff] [blame] | 2983 | ($stat, $cond, $line_nr_next, $remain_next, $off_next) = |
Andy Whitcroft | f5fe35d | 2008-07-23 21:29:03 -0700 | [diff] [blame] | 2984 | ctx_statement_block($linenr, $realcnt, 0); |
Andy Whitcroft | 171ae1a | 2008-04-29 00:59:32 -0700 | [diff] [blame] | 2985 | $stat =~ s/\n./\n /g; |
| 2986 | $cond =~ s/\n./\n /g; |
| 2987 | |
Andy Whitcroft | 3e469cd | 2012-01-10 15:10:01 -0800 | [diff] [blame] | 2988 | #print "linenr<$linenr> <$stat>\n"; |
| 2989 | # If this statement has no statement boundaries within |
| 2990 | # it there is no point in retrying a statement scan |
| 2991 | # until we hit end of it. |
| 2992 | my $frag = $stat; $frag =~ s/;+\s*$//; |
| 2993 | if ($frag !~ /(?:{|;)/) { |
| 2994 | #print "skip<$line_nr_next>\n"; |
| 2995 | $suppress_statement = $line_nr_next; |
| 2996 | } |
Andy Whitcroft | f74bd19 | 2012-01-10 15:09:54 -0800 | [diff] [blame] | 2997 | |
Andy Whitcroft | 2b474a1 | 2009-10-26 16:50:16 -0700 | [diff] [blame] | 2998 | # Find the real next line. |
| 2999 | $realline_next = $line_nr_next; |
| 3000 | if (defined $realline_next && |
| 3001 | (!defined $lines[$realline_next - 1] || |
| 3002 | substr($lines[$realline_next - 1], $off_next) =~ /^\s*$/)) { |
| 3003 | $realline_next++; |
| 3004 | } |
| 3005 | |
Andy Whitcroft | 171ae1a | 2008-04-29 00:59:32 -0700 | [diff] [blame] | 3006 | my $s = $stat; |
| 3007 | $s =~ s/{.*$//s; |
Andy Whitcroft | cf65504 | 2008-03-04 14:28:20 -0800 | [diff] [blame] | 3008 | |
Andy Whitcroft | c2fdda0 | 2008-02-08 04:20:54 -0800 | [diff] [blame] | 3009 | # Ignore goto labels. |
Andy Whitcroft | 171ae1a | 2008-04-29 00:59:32 -0700 | [diff] [blame] | 3010 | if ($s =~ /$Ident:\*$/s) { |
Andy Whitcroft | c2fdda0 | 2008-02-08 04:20:54 -0800 | [diff] [blame] | 3011 | |
| 3012 | # Ignore functions being called |
Andy Whitcroft | 171ae1a | 2008-04-29 00:59:32 -0700 | [diff] [blame] | 3013 | } elsif ($s =~ /^.\s*$Ident\s*\(/s) { |
Andy Whitcroft | c2fdda0 | 2008-02-08 04:20:54 -0800 | [diff] [blame] | 3014 | |
Andy Whitcroft | 463f286 | 2009-09-21 17:04:34 -0700 | [diff] [blame] | 3015 | } elsif ($s =~ /^.\s*else\b/s) { |
| 3016 | |
Andy Whitcroft | c45dcab | 2008-06-05 22:46:01 -0700 | [diff] [blame] | 3017 | # declarations always start with types |
Andy Whitcroft | d250658 | 2008-07-23 21:29:09 -0700 | [diff] [blame] | 3018 | } 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) { |
Andy Whitcroft | c45dcab | 2008-06-05 22:46:01 -0700 | [diff] [blame] | 3019 | my $type = $1; |
| 3020 | $type =~ s/\s+/ /g; |
| 3021 | possible($type, "A:" . $s); |
| 3022 | |
Andy Whitcroft | 8905a67 | 2007-11-28 16:21:06 -0800 | [diff] [blame] | 3023 | # definitions in global scope can only start with types |
Andy Whitcroft | a6a84062 | 2008-10-15 22:02:30 -0700 | [diff] [blame] | 3024 | } elsif ($s =~ /^.(?:$Storage\s+)?(?:$Inline\s+)?(?:const\s+)?($Ident)\b\s*(?!:)/s) { |
Andy Whitcroft | c45dcab | 2008-06-05 22:46:01 -0700 | [diff] [blame] | 3025 | possible($1, "B:" . $s); |
Andy Whitcroft | c2fdda0 | 2008-02-08 04:20:54 -0800 | [diff] [blame] | 3026 | } |
Andy Whitcroft | 8905a67 | 2007-11-28 16:21:06 -0800 | [diff] [blame] | 3027 | |
| 3028 | # any (foo ... *) is a pointer cast, and foo is a type |
Andy Whitcroft | 6586386 | 2009-01-06 14:41:21 -0800 | [diff] [blame] | 3029 | while ($s =~ /\(($Ident)(?:\s+$Sparse)*[\s\*]+\s*\)/sg) { |
Andy Whitcroft | c45dcab | 2008-06-05 22:46:01 -0700 | [diff] [blame] | 3030 | possible($1, "C:" . $s); |
Andy Whitcroft | 9c0ca6f | 2007-10-16 23:29:38 -0700 | [diff] [blame] | 3031 | } |
Andy Whitcroft | 8905a67 | 2007-11-28 16:21:06 -0800 | [diff] [blame] | 3032 | |
| 3033 | # Check for any sort of function declaration. |
| 3034 | # int foo(something bar, other baz); |
| 3035 | # void (*store_gdt)(x86_descr_ptr *); |
Andy Whitcroft | 171ae1a | 2008-04-29 00:59:32 -0700 | [diff] [blame] | 3036 | if ($prev_values eq 'E' && $s =~ /^(.(?:typedef\s*)?(?:(?:$Storage|$Inline)\s*)*\s*$Type\s*(?:\b$Ident|\(\*\s*$Ident\))\s*)\(/s) { |
Andy Whitcroft | 8905a67 | 2007-11-28 16:21:06 -0800 | [diff] [blame] | 3037 | my ($name_len) = length($1); |
Andy Whitcroft | 8905a67 | 2007-11-28 16:21:06 -0800 | [diff] [blame] | 3038 | |
Andy Whitcroft | cf65504 | 2008-03-04 14:28:20 -0800 | [diff] [blame] | 3039 | my $ctx = $s; |
Andy Whitcroft | 773647a | 2008-03-28 14:15:58 -0700 | [diff] [blame] | 3040 | substr($ctx, 0, $name_len + 1, ''); |
Andy Whitcroft | 8905a67 | 2007-11-28 16:21:06 -0800 | [diff] [blame] | 3041 | $ctx =~ s/\)[^\)]*$//; |
Andy Whitcroft | cf65504 | 2008-03-04 14:28:20 -0800 | [diff] [blame] | 3042 | |
Andy Whitcroft | 8905a67 | 2007-11-28 16:21:06 -0800 | [diff] [blame] | 3043 | for my $arg (split(/\s*,\s*/, $ctx)) { |
Andy Whitcroft | c45dcab | 2008-06-05 22:46:01 -0700 | [diff] [blame] | 3044 | if ($arg =~ /^(?:const\s+)?($Ident)(?:\s+$Sparse)*\s*\**\s*(:?\b$Ident)?$/s || $arg =~ /^($Ident)$/s) { |
Andy Whitcroft | 8905a67 | 2007-11-28 16:21:06 -0800 | [diff] [blame] | 3045 | |
Andy Whitcroft | c45dcab | 2008-06-05 22:46:01 -0700 | [diff] [blame] | 3046 | possible($1, "D:" . $s); |
Andy Whitcroft | 8905a67 | 2007-11-28 16:21:06 -0800 | [diff] [blame] | 3047 | } |
| 3048 | } |
| 3049 | } |
| 3050 | |
Andy Whitcroft | 9c0ca6f | 2007-10-16 23:29:38 -0700 | [diff] [blame] | 3051 | } |
| 3052 | |
Andy Whitcroft | 653d487 | 2007-06-23 17:16:34 -0700 | [diff] [blame] | 3053 | # |
| 3054 | # Checks which may be anchored in the context. |
| 3055 | # |
| 3056 | |
| 3057 | # Check for switch () and associated case and default |
| 3058 | # statements should be at the same indent. |
Andy Whitcroft | 00df344 | 2007-06-08 13:47:06 -0700 | [diff] [blame] | 3059 | if ($line=~/\bswitch\s*\(.*\)/) { |
| 3060 | my $err = ''; |
| 3061 | my $sep = ''; |
| 3062 | my @ctx = ctx_block_outer($linenr, $realcnt); |
| 3063 | shift(@ctx); |
| 3064 | for my $ctx (@ctx) { |
| 3065 | my ($clen, $cindent) = line_stats($ctx); |
| 3066 | if ($ctx =~ /^\+\s*(case\s+|default:)/ && |
| 3067 | $indent != $cindent) { |
| 3068 | $err .= "$sep$ctx\n"; |
| 3069 | $sep = ''; |
| 3070 | } else { |
| 3071 | $sep = "[...]\n"; |
| 3072 | } |
| 3073 | } |
| 3074 | if ($err ne '') { |
Joe Perches | 000d1cc1 | 2011-07-25 17:13:25 -0700 | [diff] [blame] | 3075 | ERROR("SWITCH_CASE_INDENT_LEVEL", |
| 3076 | "switch and case should be at the same indent\n$hereline$err"); |
Andy Whitcroft | de7d4f0 | 2007-07-15 23:37:22 -0700 | [diff] [blame] | 3077 | } |
| 3078 | } |
| 3079 | |
| 3080 | # if/while/etc brace do not go on next line, unless defining a do while loop, |
| 3081 | # or if that brace on the next line is for something else |
Joe Perches | 0fe3dc2 | 2014-08-06 16:11:16 -0700 | [diff] [blame] | 3082 | if ($line =~ /(.*)\b((?:if|while|for|switch|(?:[a-z_]+|)for_each[a-z_]+)\s*\(|do\b|else\b)/ && $line !~ /^.\s*\#/) { |
Andy Whitcroft | 773647a | 2008-03-28 14:15:58 -0700 | [diff] [blame] | 3083 | my $pre_ctx = "$1$2"; |
| 3084 | |
Andy Whitcroft | 9c0ca6f | 2007-10-16 23:29:38 -0700 | [diff] [blame] | 3085 | my ($level, @ctx) = ctx_statement_level($linenr, $realcnt, 0); |
Joe Perches | 8eef05d | 2012-02-03 15:20:39 -0800 | [diff] [blame] | 3086 | |
| 3087 | if ($line =~ /^\+\t{6,}/) { |
| 3088 | WARN("DEEP_INDENTATION", |
| 3089 | "Too many leading tabs - consider code refactoring\n" . $herecurr); |
| 3090 | } |
| 3091 | |
Andy Whitcroft | de7d4f0 | 2007-07-15 23:37:22 -0700 | [diff] [blame] | 3092 | my $ctx_cnt = $realcnt - $#ctx - 1; |
| 3093 | my $ctx = join("\n", @ctx); |
| 3094 | |
Andy Whitcroft | 548596d | 2008-07-23 21:29:01 -0700 | [diff] [blame] | 3095 | my $ctx_ln = $linenr; |
| 3096 | my $ctx_skip = $realcnt; |
Andy Whitcroft | de7d4f0 | 2007-07-15 23:37:22 -0700 | [diff] [blame] | 3097 | |
Andy Whitcroft | 548596d | 2008-07-23 21:29:01 -0700 | [diff] [blame] | 3098 | while ($ctx_skip > $ctx_cnt || ($ctx_skip == $ctx_cnt && |
| 3099 | defined $lines[$ctx_ln - 1] && |
| 3100 | $lines[$ctx_ln - 1] =~ /^-/)) { |
| 3101 | ##print "SKIP<$ctx_skip> CNT<$ctx_cnt>\n"; |
| 3102 | $ctx_skip-- if (!defined $lines[$ctx_ln - 1] || $lines[$ctx_ln - 1] !~ /^-/); |
Andy Whitcroft | 773647a | 2008-03-28 14:15:58 -0700 | [diff] [blame] | 3103 | $ctx_ln++; |
| 3104 | } |
Andy Whitcroft | 548596d | 2008-07-23 21:29:01 -0700 | [diff] [blame] | 3105 | |
Andy Whitcroft | 5321016 | 2008-07-23 21:29:03 -0700 | [diff] [blame] | 3106 | #print "realcnt<$realcnt> ctx_cnt<$ctx_cnt>\n"; |
| 3107 | #print "pre<$pre_ctx>\nline<$line>\nctx<$ctx>\nnext<$lines[$ctx_ln - 1]>\n"; |
Andy Whitcroft | 773647a | 2008-03-28 14:15:58 -0700 | [diff] [blame] | 3108 | |
Joe Perches | d752fcc | 2014-08-06 16:11:05 -0700 | [diff] [blame] | 3109 | if ($ctx !~ /{\s*/ && defined($lines[$ctx_ln - 1]) && $lines[$ctx_ln - 1] =~ /^\+\s*{/) { |
Joe Perches | 000d1cc1 | 2011-07-25 17:13:25 -0700 | [diff] [blame] | 3110 | ERROR("OPEN_BRACE", |
| 3111 | "that open brace { should be on the previous line\n" . |
Andy Whitcroft | 01464f3 | 2010-10-26 14:23:19 -0700 | [diff] [blame] | 3112 | "$here\n$ctx\n$rawlines[$ctx_ln - 1]\n"); |
Andy Whitcroft | 00df344 | 2007-06-08 13:47:06 -0700 | [diff] [blame] | 3113 | } |
Andy Whitcroft | 773647a | 2008-03-28 14:15:58 -0700 | [diff] [blame] | 3114 | if ($level == 0 && $pre_ctx !~ /}\s*while\s*\($/ && |
| 3115 | $ctx =~ /\)\s*\;\s*$/ && |
| 3116 | defined $lines[$ctx_ln - 1]) |
| 3117 | { |
Andy Whitcroft | 9c0ca6f | 2007-10-16 23:29:38 -0700 | [diff] [blame] | 3118 | my ($nlength, $nindent) = line_stats($lines[$ctx_ln - 1]); |
| 3119 | if ($nindent > $indent) { |
Joe Perches | 000d1cc1 | 2011-07-25 17:13:25 -0700 | [diff] [blame] | 3120 | WARN("TRAILING_SEMICOLON", |
| 3121 | "trailing semicolon indicates no statements, indent implies otherwise\n" . |
Andy Whitcroft | 01464f3 | 2010-10-26 14:23:19 -0700 | [diff] [blame] | 3122 | "$here\n$ctx\n$rawlines[$ctx_ln - 1]\n"); |
Andy Whitcroft | 9c0ca6f | 2007-10-16 23:29:38 -0700 | [diff] [blame] | 3123 | } |
| 3124 | } |
Andy Whitcroft | 00df344 | 2007-06-08 13:47:06 -0700 | [diff] [blame] | 3125 | } |
| 3126 | |
Andy Whitcroft | 4d001e4 | 2008-10-15 22:02:21 -0700 | [diff] [blame] | 3127 | # Check relative indent for conditionals and blocks. |
Joe Perches | 0fe3dc2 | 2014-08-06 16:11:16 -0700 | [diff] [blame] | 3128 | if ($line =~ /\b(?:(?:if|while|for|(?:[a-z_]+|)for_each[a-z_]+)\s*\(|do\b)/ && $line !~ /^.\s*#/ && $line !~ /\}\s*while\s*/) { |
Andy Whitcroft | 3e469cd | 2012-01-10 15:10:01 -0800 | [diff] [blame] | 3129 | ($stat, $cond, $line_nr_next, $remain_next, $off_next) = |
| 3130 | ctx_statement_block($linenr, $realcnt, 0) |
| 3131 | if (!defined $stat); |
Andy Whitcroft | 4d001e4 | 2008-10-15 22:02:21 -0700 | [diff] [blame] | 3132 | my ($s, $c) = ($stat, $cond); |
| 3133 | |
| 3134 | substr($s, 0, length($c), ''); |
| 3135 | |
Joe Perches | 9f5af48 | 2015-09-09 15:37:30 -0700 | [diff] [blame] | 3136 | # remove inline comments |
| 3137 | $s =~ s/$;/ /g; |
| 3138 | $c =~ s/$;/ /g; |
Andy Whitcroft | 4d001e4 | 2008-10-15 22:02:21 -0700 | [diff] [blame] | 3139 | |
| 3140 | # Find out how long the conditional actually is. |
Andy Whitcroft | 6f779c1 | 2008-10-15 22:02:27 -0700 | [diff] [blame] | 3141 | my @newlines = ($c =~ /\n/gs); |
| 3142 | my $cond_lines = 1 + $#newlines; |
Andy Whitcroft | 4d001e4 | 2008-10-15 22:02:21 -0700 | [diff] [blame] | 3143 | |
Joe Perches | 9f5af48 | 2015-09-09 15:37:30 -0700 | [diff] [blame] | 3144 | # Make sure we remove the line prefixes as we have |
| 3145 | # none on the first line, and are going to readd them |
| 3146 | # where necessary. |
| 3147 | $s =~ s/\n./\n/gs; |
| 3148 | while ($s =~ /\n\s+\\\n/) { |
| 3149 | $cond_lines += $s =~ s/\n\s+\\\n/\n/g; |
| 3150 | } |
| 3151 | |
Andy Whitcroft | 4d001e4 | 2008-10-15 22:02:21 -0700 | [diff] [blame] | 3152 | # We want to check the first line inside the block |
| 3153 | # starting at the end of the conditional, so remove: |
| 3154 | # 1) any blank line termination |
| 3155 | # 2) any opening brace { on end of the line |
| 3156 | # 3) any do (...) { |
| 3157 | my $continuation = 0; |
| 3158 | my $check = 0; |
| 3159 | $s =~ s/^.*\bdo\b//; |
| 3160 | $s =~ s/^\s*{//; |
| 3161 | if ($s =~ s/^\s*\\//) { |
| 3162 | $continuation = 1; |
| 3163 | } |
Andy Whitcroft | 9bd49ef | 2008-10-15 22:02:22 -0700 | [diff] [blame] | 3164 | if ($s =~ s/^\s*?\n//) { |
Andy Whitcroft | 4d001e4 | 2008-10-15 22:02:21 -0700 | [diff] [blame] | 3165 | $check = 1; |
| 3166 | $cond_lines++; |
| 3167 | } |
| 3168 | |
| 3169 | # Also ignore a loop construct at the end of a |
| 3170 | # preprocessor statement. |
| 3171 | if (($prevline =~ /^.\s*#\s*define\s/ || |
| 3172 | $prevline =~ /\\\s*$/) && $continuation == 0) { |
| 3173 | $check = 0; |
| 3174 | } |
| 3175 | |
Andy Whitcroft | 9bd49ef | 2008-10-15 22:02:22 -0700 | [diff] [blame] | 3176 | my $cond_ptr = -1; |
Andy Whitcroft | 740504c | 2008-10-15 22:02:35 -0700 | [diff] [blame] | 3177 | $continuation = 0; |
Andy Whitcroft | 9bd49ef | 2008-10-15 22:02:22 -0700 | [diff] [blame] | 3178 | while ($cond_ptr != $cond_lines) { |
| 3179 | $cond_ptr = $cond_lines; |
Andy Whitcroft | 4d001e4 | 2008-10-15 22:02:21 -0700 | [diff] [blame] | 3180 | |
Andy Whitcroft | f16fa28 | 2008-10-15 22:02:32 -0700 | [diff] [blame] | 3181 | # If we see an #else/#elif then the code |
| 3182 | # is not linear. |
| 3183 | if ($s =~ /^\s*\#\s*(?:else|elif)/) { |
| 3184 | $check = 0; |
| 3185 | } |
| 3186 | |
Andy Whitcroft | 9bd49ef | 2008-10-15 22:02:22 -0700 | [diff] [blame] | 3187 | # Ignore: |
| 3188 | # 1) blank lines, they should be at 0, |
| 3189 | # 2) preprocessor lines, and |
| 3190 | # 3) labels. |
Andy Whitcroft | 740504c | 2008-10-15 22:02:35 -0700 | [diff] [blame] | 3191 | if ($continuation || |
| 3192 | $s =~ /^\s*?\n/ || |
Andy Whitcroft | 9bd49ef | 2008-10-15 22:02:22 -0700 | [diff] [blame] | 3193 | $s =~ /^\s*#\s*?/ || |
| 3194 | $s =~ /^\s*$Ident\s*:/) { |
Andy Whitcroft | 740504c | 2008-10-15 22:02:35 -0700 | [diff] [blame] | 3195 | $continuation = ($s =~ /^.*?\\\n/) ? 1 : 0; |
Andy Whitcroft | 30dad6e | 2009-09-21 17:04:36 -0700 | [diff] [blame] | 3196 | if ($s =~ s/^.*?\n//) { |
| 3197 | $cond_lines++; |
| 3198 | } |
Andy Whitcroft | 9bd49ef | 2008-10-15 22:02:22 -0700 | [diff] [blame] | 3199 | } |
Andy Whitcroft | 4d001e4 | 2008-10-15 22:02:21 -0700 | [diff] [blame] | 3200 | } |
| 3201 | |
| 3202 | my (undef, $sindent) = line_stats("+" . $s); |
| 3203 | my $stat_real = raw_line($linenr, $cond_lines); |
| 3204 | |
| 3205 | # Check if either of these lines are modified, else |
| 3206 | # this is not this patch's fault. |
| 3207 | if (!defined($stat_real) || |
| 3208 | $stat !~ /^\+/ && $stat_real !~ /^\+/) { |
| 3209 | $check = 0; |
| 3210 | } |
| 3211 | if (defined($stat_real) && $cond_lines > 1) { |
| 3212 | $stat_real = "[...]\n$stat_real"; |
| 3213 | } |
| 3214 | |
Andy Whitcroft | 9bd49ef | 2008-10-15 22:02:22 -0700 | [diff] [blame] | 3215 | #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"; |
Andy Whitcroft | 4d001e4 | 2008-10-15 22:02:21 -0700 | [diff] [blame] | 3216 | |
Joe Perches | 9f5af48 | 2015-09-09 15:37:30 -0700 | [diff] [blame] | 3217 | if ($check && $s ne '' && |
| 3218 | (($sindent % 8) != 0 || |
| 3219 | ($sindent < $indent) || |
| 3220 | ($sindent > $indent + 8))) { |
Joe Perches | 000d1cc1 | 2011-07-25 17:13:25 -0700 | [diff] [blame] | 3221 | WARN("SUSPECT_CODE_INDENT", |
| 3222 | "suspect code indent for conditional statements ($indent, $sindent)\n" . $herecurr . "$stat_real\n"); |
Andy Whitcroft | 4d001e4 | 2008-10-15 22:02:21 -0700 | [diff] [blame] | 3223 | } |
| 3224 | } |
| 3225 | |
Andy Whitcroft | 6c72ffa | 2007-10-18 03:05:08 -0700 | [diff] [blame] | 3226 | # Track the 'values' across context and added lines. |
| 3227 | my $opline = $line; $opline =~ s/^./ /; |
Andy Whitcroft | 1f65f94 | 2008-07-23 21:29:10 -0700 | [diff] [blame] | 3228 | my ($curr_values, $curr_vars) = |
| 3229 | annotate_values($opline . "\n", $prev_values); |
Andy Whitcroft | 6c72ffa | 2007-10-18 03:05:08 -0700 | [diff] [blame] | 3230 | $curr_values = $prev_values . $curr_values; |
Andy Whitcroft | c2fdda0 | 2008-02-08 04:20:54 -0800 | [diff] [blame] | 3231 | if ($dbg_values) { |
| 3232 | my $outline = $opline; $outline =~ s/\t/ /g; |
Andy Whitcroft | cf65504 | 2008-03-04 14:28:20 -0800 | [diff] [blame] | 3233 | print "$linenr > .$outline\n"; |
| 3234 | print "$linenr > $curr_values\n"; |
Andy Whitcroft | 1f65f94 | 2008-07-23 21:29:10 -0700 | [diff] [blame] | 3235 | print "$linenr > $curr_vars\n"; |
Andy Whitcroft | c2fdda0 | 2008-02-08 04:20:54 -0800 | [diff] [blame] | 3236 | } |
Andy Whitcroft | 6c72ffa | 2007-10-18 03:05:08 -0700 | [diff] [blame] | 3237 | $prev_values = substr($curr_values, -1); |
| 3238 | |
Andy Whitcroft | 00df344 | 2007-06-08 13:47:06 -0700 | [diff] [blame] | 3239 | #ignore lines not being added |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 3240 | next if ($line =~ /^[^\+]/); |
Andy Whitcroft | 00df344 | 2007-06-08 13:47:06 -0700 | [diff] [blame] | 3241 | |
Andy Whitcroft | 653d487 | 2007-06-23 17:16:34 -0700 | [diff] [blame] | 3242 | # TEST: allow direct testing of the type matcher. |
Andy Whitcroft | 7429c69 | 2008-07-23 21:29:06 -0700 | [diff] [blame] | 3243 | if ($dbg_type) { |
| 3244 | if ($line =~ /^.\s*$Declare\s*$/) { |
Joe Perches | 000d1cc1 | 2011-07-25 17:13:25 -0700 | [diff] [blame] | 3245 | ERROR("TEST_TYPE", |
| 3246 | "TEST: is type\n" . $herecurr); |
Andy Whitcroft | 7429c69 | 2008-07-23 21:29:06 -0700 | [diff] [blame] | 3247 | } elsif ($dbg_type > 1 && $line =~ /^.+($Declare)/) { |
Joe Perches | 000d1cc1 | 2011-07-25 17:13:25 -0700 | [diff] [blame] | 3248 | ERROR("TEST_NOT_TYPE", |
| 3249 | "TEST: is not type ($1 is)\n". $herecurr); |
Andy Whitcroft | 7429c69 | 2008-07-23 21:29:06 -0700 | [diff] [blame] | 3250 | } |
Andy Whitcroft | 653d487 | 2007-06-23 17:16:34 -0700 | [diff] [blame] | 3251 | next; |
| 3252 | } |
Andy Whitcroft | a1ef277 | 2008-10-15 22:02:17 -0700 | [diff] [blame] | 3253 | # TEST: allow direct testing of the attribute matcher. |
| 3254 | if ($dbg_attr) { |
Andy Whitcroft | 9360b0e | 2009-02-27 14:03:08 -0800 | [diff] [blame] | 3255 | if ($line =~ /^.\s*$Modifier\s*$/) { |
Joe Perches | 000d1cc1 | 2011-07-25 17:13:25 -0700 | [diff] [blame] | 3256 | ERROR("TEST_ATTR", |
| 3257 | "TEST: is attr\n" . $herecurr); |
Andy Whitcroft | 9360b0e | 2009-02-27 14:03:08 -0800 | [diff] [blame] | 3258 | } elsif ($dbg_attr > 1 && $line =~ /^.+($Modifier)/) { |
Joe Perches | 000d1cc1 | 2011-07-25 17:13:25 -0700 | [diff] [blame] | 3259 | ERROR("TEST_NOT_ATTR", |
| 3260 | "TEST: is not attr ($1 is)\n". $herecurr); |
Andy Whitcroft | a1ef277 | 2008-10-15 22:02:17 -0700 | [diff] [blame] | 3261 | } |
| 3262 | next; |
| 3263 | } |
Andy Whitcroft | 653d487 | 2007-06-23 17:16:34 -0700 | [diff] [blame] | 3264 | |
Andy Whitcroft | f0a594c | 2007-07-19 01:48:34 -0700 | [diff] [blame] | 3265 | # check for initialisation to aggregates open brace on the next line |
Andy Whitcroft | 99423c2 | 2009-10-26 16:50:15 -0700 | [diff] [blame] | 3266 | if ($line =~ /^.\s*{/ && |
| 3267 | $prevline =~ /(?:^|[^=])=\s*$/) { |
Joe Perches | d752fcc | 2014-08-06 16:11:05 -0700 | [diff] [blame] | 3268 | if (ERROR("OPEN_BRACE", |
| 3269 | "that open brace { should be on the previous line\n" . $hereprev) && |
Joe Perches | f2d7e4d | 2014-08-06 16:11:07 -0700 | [diff] [blame] | 3270 | $fix && $prevline =~ /^\+/ && $line =~ /^\+/) { |
| 3271 | fix_delete_line($fixlinenr - 1, $prevrawline); |
| 3272 | fix_delete_line($fixlinenr, $rawline); |
Joe Perches | d752fcc | 2014-08-06 16:11:05 -0700 | [diff] [blame] | 3273 | my $fixedline = $prevrawline; |
| 3274 | $fixedline =~ s/\s*=\s*$/ = {/; |
Joe Perches | f2d7e4d | 2014-08-06 16:11:07 -0700 | [diff] [blame] | 3275 | fix_insert_line($fixlinenr, $fixedline); |
Joe Perches | d752fcc | 2014-08-06 16:11:05 -0700 | [diff] [blame] | 3276 | $fixedline = $line; |
| 3277 | $fixedline =~ s/^(.\s*){\s*/$1/; |
Joe Perches | f2d7e4d | 2014-08-06 16:11:07 -0700 | [diff] [blame] | 3278 | fix_insert_line($fixlinenr, $fixedline); |
Joe Perches | d752fcc | 2014-08-06 16:11:05 -0700 | [diff] [blame] | 3279 | } |
Andy Whitcroft | f0a594c | 2007-07-19 01:48:34 -0700 | [diff] [blame] | 3280 | } |
| 3281 | |
Andy Whitcroft | 653d487 | 2007-06-23 17:16:34 -0700 | [diff] [blame] | 3282 | # |
| 3283 | # Checks which are anchored on the added line. |
| 3284 | # |
| 3285 | |
| 3286 | # check for malformed paths in #include statements (uses RAW line) |
Andy Whitcroft | c45dcab | 2008-06-05 22:46:01 -0700 | [diff] [blame] | 3287 | if ($rawline =~ m{^.\s*\#\s*include\s+[<"](.*)[">]}) { |
Andy Whitcroft | 653d487 | 2007-06-23 17:16:34 -0700 | [diff] [blame] | 3288 | my $path = $1; |
| 3289 | if ($path =~ m{//}) { |
Joe Perches | 000d1cc1 | 2011-07-25 17:13:25 -0700 | [diff] [blame] | 3290 | ERROR("MALFORMED_INCLUDE", |
Joe Perches | 495e9d8 | 2012-12-20 15:05:37 -0800 | [diff] [blame] | 3291 | "malformed #include filename\n" . $herecurr); |
| 3292 | } |
| 3293 | if ($path =~ "^uapi/" && $realfile =~ m@\binclude/uapi/@) { |
| 3294 | ERROR("UAPI_INCLUDE", |
| 3295 | "No #include in ...include/uapi/... should use a uapi/ path prefix\n" . $herecurr); |
Andy Whitcroft | 653d487 | 2007-06-23 17:16:34 -0700 | [diff] [blame] | 3296 | } |
Andy Whitcroft | 653d487 | 2007-06-23 17:16:34 -0700 | [diff] [blame] | 3297 | } |
Andy Whitcroft | 00df344 | 2007-06-08 13:47:06 -0700 | [diff] [blame] | 3298 | |
| 3299 | # no C99 // comments |
| 3300 | if ($line =~ m{//}) { |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 3301 | if (ERROR("C99_COMMENTS", |
| 3302 | "do not use C99 // comments\n" . $herecurr) && |
| 3303 | $fix) { |
Joe Perches | 194f66f | 2014-08-06 16:11:03 -0700 | [diff] [blame] | 3304 | my $line = $fixed[$fixlinenr]; |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 3305 | if ($line =~ /\/\/(.*)$/) { |
| 3306 | my $comment = trim($1); |
Joe Perches | 194f66f | 2014-08-06 16:11:03 -0700 | [diff] [blame] | 3307 | $fixed[$fixlinenr] =~ s@\/\/(.*)$@/\* $comment \*/@; |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 3308 | } |
| 3309 | } |
Andy Whitcroft | 00df344 | 2007-06-08 13:47:06 -0700 | [diff] [blame] | 3310 | } |
| 3311 | # Remove C99 comments. |
Andy Whitcroft | 0a920b5 | 2007-06-01 00:46:48 -0700 | [diff] [blame] | 3312 | $line =~ s@//.*@@; |
Andy Whitcroft | 6c72ffa | 2007-10-18 03:05:08 -0700 | [diff] [blame] | 3313 | $opline =~ s@//.*@@; |
Andy Whitcroft | 0a920b5 | 2007-06-01 00:46:48 -0700 | [diff] [blame] | 3314 | |
Andy Whitcroft | 2b474a1 | 2009-10-26 16:50:16 -0700 | [diff] [blame] | 3315 | # EXPORT_SYMBOL should immediately follow the thing it is exporting, consider |
| 3316 | # the whole statement. |
| 3317 | #print "APW <$lines[$realline_next - 1]>\n"; |
| 3318 | if (defined $realline_next && |
| 3319 | exists $lines[$realline_next - 1] && |
| 3320 | !defined $suppress_export{$realline_next} && |
| 3321 | ($lines[$realline_next - 1] =~ /EXPORT_SYMBOL.*\((.*)\)/ || |
| 3322 | $lines[$realline_next - 1] =~ /EXPORT_UNUSED_SYMBOL.*\((.*)\)/)) { |
Andy Whitcroft | 3cbf62d | 2010-10-26 14:23:18 -0700 | [diff] [blame] | 3323 | # Handle definitions which produce identifiers with |
| 3324 | # a prefix: |
| 3325 | # XXX(foo); |
| 3326 | # EXPORT_SYMBOL(something_foo); |
Andy Whitcroft | 653d487 | 2007-06-23 17:16:34 -0700 | [diff] [blame] | 3327 | my $name = $1; |
Andy Whitcroft | 87a5387 | 2012-01-10 15:10:04 -0800 | [diff] [blame] | 3328 | if ($stat =~ /^(?:.\s*}\s*\n)?.([A-Z_]+)\s*\(\s*($Ident)/ && |
Andy Whitcroft | 3cbf62d | 2010-10-26 14:23:18 -0700 | [diff] [blame] | 3329 | $name =~ /^${Ident}_$2/) { |
| 3330 | #print "FOO C name<$name>\n"; |
| 3331 | $suppress_export{$realline_next} = 1; |
| 3332 | |
| 3333 | } elsif ($stat !~ /(?: |
Andy Whitcroft | 2b474a1 | 2009-10-26 16:50:16 -0700 | [diff] [blame] | 3334 | \n.}\s*$| |
Andy Whitcroft | 4801205 | 2008-10-15 22:02:34 -0700 | [diff] [blame] | 3335 | ^.DEFINE_$Ident\(\Q$name\E\)| |
| 3336 | ^.DECLARE_$Ident\(\Q$name\E\)| |
| 3337 | ^.LIST_HEAD\(\Q$name\E\)| |
Andy Whitcroft | 2b474a1 | 2009-10-26 16:50:16 -0700 | [diff] [blame] | 3338 | ^.(?:$Storage\s+)?$Type\s*\(\s*\*\s*\Q$name\E\s*\)\s*\(| |
| 3339 | \b\Q$name\E(?:\s+$Attribute)*\s*(?:;|=|\[|\() |
Andy Whitcroft | 4801205 | 2008-10-15 22:02:34 -0700 | [diff] [blame] | 3340 | )/x) { |
Andy Whitcroft | 2b474a1 | 2009-10-26 16:50:16 -0700 | [diff] [blame] | 3341 | #print "FOO A<$lines[$realline_next - 1]> stat<$stat> name<$name>\n"; |
| 3342 | $suppress_export{$realline_next} = 2; |
| 3343 | } else { |
| 3344 | $suppress_export{$realline_next} = 1; |
Andy Whitcroft | 0a920b5 | 2007-06-01 00:46:48 -0700 | [diff] [blame] | 3345 | } |
| 3346 | } |
Andy Whitcroft | 2b474a1 | 2009-10-26 16:50:16 -0700 | [diff] [blame] | 3347 | if (!defined $suppress_export{$linenr} && |
| 3348 | $prevline =~ /^.\s*$/ && |
| 3349 | ($line =~ /EXPORT_SYMBOL.*\((.*)\)/ || |
| 3350 | $line =~ /EXPORT_UNUSED_SYMBOL.*\((.*)\)/)) { |
| 3351 | #print "FOO B <$lines[$linenr - 1]>\n"; |
| 3352 | $suppress_export{$linenr} = 2; |
| 3353 | } |
| 3354 | if (defined $suppress_export{$linenr} && |
| 3355 | $suppress_export{$linenr} == 2) { |
Joe Perches | 000d1cc1 | 2011-07-25 17:13:25 -0700 | [diff] [blame] | 3356 | WARN("EXPORT_SYMBOL", |
| 3357 | "EXPORT_SYMBOL(foo); should immediately follow its function/variable\n" . $herecurr); |
Andy Whitcroft | 2b474a1 | 2009-10-26 16:50:16 -0700 | [diff] [blame] | 3358 | } |
Andy Whitcroft | 0a920b5 | 2007-06-01 00:46:48 -0700 | [diff] [blame] | 3359 | |
Joe Eloff | 5150bda | 2010-08-09 17:21:00 -0700 | [diff] [blame] | 3360 | # check for global initialisers. |
Joe Perches | 6d32f7a | 2015-11-06 16:31:37 -0800 | [diff] [blame] | 3361 | if ($line =~ /^\+$Type\s*$Ident(?:\s+$Modifier)*\s*=\s*($zero_initializer)\s*;/) { |
Joe Perches | d5e616f | 2013-09-11 14:23:54 -0700 | [diff] [blame] | 3362 | if (ERROR("GLOBAL_INITIALISERS", |
Joe Perches | 6d32f7a | 2015-11-06 16:31:37 -0800 | [diff] [blame] | 3363 | "do not initialise globals to $1\n" . $herecurr) && |
Joe Perches | d5e616f | 2013-09-11 14:23:54 -0700 | [diff] [blame] | 3364 | $fix) { |
Joe Perches | 6d32f7a | 2015-11-06 16:31:37 -0800 | [diff] [blame] | 3365 | $fixed[$fixlinenr] =~ s/(^.$Type\s*$Ident(?:\s+$Modifier)*)\s*=\s*$zero_initializer\s*;/$1;/; |
Joe Perches | d5e616f | 2013-09-11 14:23:54 -0700 | [diff] [blame] | 3366 | } |
Andy Whitcroft | f0a594c | 2007-07-19 01:48:34 -0700 | [diff] [blame] | 3367 | } |
Andy Whitcroft | 653d487 | 2007-06-23 17:16:34 -0700 | [diff] [blame] | 3368 | # check for static initialisers. |
Joe Perches | 6d32f7a | 2015-11-06 16:31:37 -0800 | [diff] [blame] | 3369 | if ($line =~ /^\+.*\bstatic\s.*=\s*($zero_initializer)\s*;/) { |
Joe Perches | d5e616f | 2013-09-11 14:23:54 -0700 | [diff] [blame] | 3370 | if (ERROR("INITIALISED_STATIC", |
Joe Perches | 6d32f7a | 2015-11-06 16:31:37 -0800 | [diff] [blame] | 3371 | "do not initialise statics to $1\n" . |
Joe Perches | d5e616f | 2013-09-11 14:23:54 -0700 | [diff] [blame] | 3372 | $herecurr) && |
| 3373 | $fix) { |
Joe Perches | 6d32f7a | 2015-11-06 16:31:37 -0800 | [diff] [blame] | 3374 | $fixed[$fixlinenr] =~ s/(\bstatic\s.*?)\s*=\s*$zero_initializer\s*;/$1;/; |
Joe Perches | d5e616f | 2013-09-11 14:23:54 -0700 | [diff] [blame] | 3375 | } |
Andy Whitcroft | 0a920b5 | 2007-06-01 00:46:48 -0700 | [diff] [blame] | 3376 | } |
| 3377 | |
Joe Perches | 1813087 | 2014-08-06 16:11:22 -0700 | [diff] [blame] | 3378 | # check for misordered declarations of char/short/int/long with signed/unsigned |
| 3379 | while ($sline =~ m{(\b$TypeMisordered\b)}g) { |
| 3380 | my $tmp = trim($1); |
| 3381 | WARN("MISORDERED_TYPE", |
| 3382 | "type '$tmp' should be specified in [[un]signed] [short|int|long|long long] order\n" . $herecurr); |
| 3383 | } |
| 3384 | |
Joe Perches | cb710ec | 2010-10-26 14:23:20 -0700 | [diff] [blame] | 3385 | # check for static const char * arrays. |
| 3386 | if ($line =~ /\bstatic\s+const\s+char\s*\*\s*(\w+)\s*\[\s*\]\s*=\s*/) { |
Joe Perches | 000d1cc1 | 2011-07-25 17:13:25 -0700 | [diff] [blame] | 3387 | WARN("STATIC_CONST_CHAR_ARRAY", |
| 3388 | "static const char * array should probably be static const char * const\n" . |
Joe Perches | cb710ec | 2010-10-26 14:23:20 -0700 | [diff] [blame] | 3389 | $herecurr); |
| 3390 | } |
| 3391 | |
| 3392 | # check for static char foo[] = "bar" declarations. |
| 3393 | if ($line =~ /\bstatic\s+char\s+(\w+)\s*\[\s*\]\s*=\s*"/) { |
Joe Perches | 000d1cc1 | 2011-07-25 17:13:25 -0700 | [diff] [blame] | 3394 | WARN("STATIC_CONST_CHAR_ARRAY", |
| 3395 | "static char array declaration should probably be static const char\n" . |
Joe Perches | cb710ec | 2010-10-26 14:23:20 -0700 | [diff] [blame] | 3396 | $herecurr); |
| 3397 | } |
| 3398 | |
Joe Perches | ab7e23f | 2015-04-16 12:44:22 -0700 | [diff] [blame] | 3399 | # check for const <foo> const where <foo> is not a pointer or array type |
| 3400 | if ($sline =~ /\bconst\s+($BasicType)\s+const\b/) { |
| 3401 | my $found = $1; |
| 3402 | if ($sline =~ /\bconst\s+\Q$found\E\s+const\b\s*\*/) { |
| 3403 | WARN("CONST_CONST", |
| 3404 | "'const $found const *' should probably be 'const $found * const'\n" . $herecurr); |
| 3405 | } elsif ($sline !~ /\bconst\s+\Q$found\E\s+const\s+\w+\s*\[/) { |
| 3406 | WARN("CONST_CONST", |
| 3407 | "'const $found const' should probably be 'const $found'\n" . $herecurr); |
| 3408 | } |
| 3409 | } |
| 3410 | |
Joe Perches | 9b0fa60 | 2014-04-03 14:49:18 -0700 | [diff] [blame] | 3411 | # check for non-global char *foo[] = {"bar", ...} declarations. |
| 3412 | if ($line =~ /^.\s+(?:static\s+|const\s+)?char\s+\*\s*\w+\s*\[\s*\]\s*=\s*\{/) { |
| 3413 | WARN("STATIC_CONST_CHAR_ARRAY", |
| 3414 | "char * array declaration might be better as static const\n" . |
| 3415 | $herecurr); |
| 3416 | } |
| 3417 | |
Joe Perches | b598b67 | 2015-04-16 12:44:36 -0700 | [diff] [blame] | 3418 | # check for sizeof(foo)/sizeof(foo[0]) that could be ARRAY_SIZE(foo) |
| 3419 | if ($line =~ m@\bsizeof\s*\(\s*($Lval)\s*\)@) { |
| 3420 | my $array = $1; |
| 3421 | if ($line =~ m@\b(sizeof\s*\(\s*\Q$array\E\s*\)\s*/\s*sizeof\s*\(\s*\Q$array\E\s*\[\s*0\s*\]\s*\))@) { |
| 3422 | my $array_div = $1; |
| 3423 | if (WARN("ARRAY_SIZE", |
| 3424 | "Prefer ARRAY_SIZE($array)\n" . $herecurr) && |
| 3425 | $fix) { |
| 3426 | $fixed[$fixlinenr] =~ s/\Q$array_div\E/ARRAY_SIZE($array)/; |
| 3427 | } |
| 3428 | } |
| 3429 | } |
| 3430 | |
Joe Perches | b36190c | 2014-01-27 17:07:18 -0800 | [diff] [blame] | 3431 | # check for function declarations without arguments like "int foo()" |
| 3432 | if ($line =~ /(\b$Type\s+$Ident)\s*\(\s*\)/) { |
| 3433 | if (ERROR("FUNCTION_WITHOUT_ARGS", |
| 3434 | "Bad function definition - $1() should probably be $1(void)\n" . $herecurr) && |
| 3435 | $fix) { |
Joe Perches | 194f66f | 2014-08-06 16:11:03 -0700 | [diff] [blame] | 3436 | $fixed[$fixlinenr] =~ s/(\b($Type)\s+($Ident))\s*\(\s*\)/$2 $3(void)/; |
Joe Perches | b36190c | 2014-01-27 17:07:18 -0800 | [diff] [blame] | 3437 | } |
| 3438 | } |
| 3439 | |
Joe Perches | 92e112f | 2013-12-13 11:36:22 -0700 | [diff] [blame] | 3440 | # check for uses of DEFINE_PCI_DEVICE_TABLE |
| 3441 | if ($line =~ /\bDEFINE_PCI_DEVICE_TABLE\s*\(\s*(\w+)\s*\)\s*=/) { |
| 3442 | if (WARN("DEFINE_PCI_DEVICE_TABLE", |
| 3443 | "Prefer struct pci_device_id over deprecated DEFINE_PCI_DEVICE_TABLE\n" . $herecurr) && |
| 3444 | $fix) { |
Joe Perches | 194f66f | 2014-08-06 16:11:03 -0700 | [diff] [blame] | 3445 | $fixed[$fixlinenr] =~ s/\b(?:static\s+|)DEFINE_PCI_DEVICE_TABLE\s*\(\s*(\w+)\s*\)\s*=\s*/static const struct pci_device_id $1\[\] = /; |
Joe Perches | 92e112f | 2013-12-13 11:36:22 -0700 | [diff] [blame] | 3446 | } |
Joe Perches | 93ed0e2 | 2010-10-26 14:23:21 -0700 | [diff] [blame] | 3447 | } |
| 3448 | |
Andy Whitcroft | 653d487 | 2007-06-23 17:16:34 -0700 | [diff] [blame] | 3449 | # check for new typedefs, only function parameters and sparse annotations |
| 3450 | # make sense. |
| 3451 | if ($line =~ /\btypedef\s/ && |
Andy Whitcroft | 8054576 | 2009-01-06 14:41:26 -0800 | [diff] [blame] | 3452 | $line !~ /\btypedef\s+$Type\s*\(\s*\*?$Ident\s*\)\s*\(/ && |
Andy Whitcroft | c45dcab | 2008-06-05 22:46:01 -0700 | [diff] [blame] | 3453 | $line !~ /\btypedef\s+$Type\s+$Ident\s*\(/ && |
Andy Whitcroft | 8ed22ca | 2008-10-15 22:02:32 -0700 | [diff] [blame] | 3454 | $line !~ /\b$typeTypedefs\b/ && |
Andy Whitcroft | 653d487 | 2007-06-23 17:16:34 -0700 | [diff] [blame] | 3455 | $line !~ /\b__bitwise(?:__|)\b/) { |
Joe Perches | 000d1cc1 | 2011-07-25 17:13:25 -0700 | [diff] [blame] | 3456 | WARN("NEW_TYPEDEFS", |
| 3457 | "do not add new typedefs\n" . $herecurr); |
Andy Whitcroft | 0a920b5 | 2007-06-01 00:46:48 -0700 | [diff] [blame] | 3458 | } |
| 3459 | |
| 3460 | # * goes on variable not on type |
Andy Whitcroft | 6586386 | 2009-01-06 14:41:21 -0800 | [diff] [blame] | 3461 | # (char*[ const]) |
Andy Whitcroft | bfcb2cc | 2012-01-10 15:10:15 -0800 | [diff] [blame] | 3462 | while ($line =~ m{(\($NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)\))}g) { |
| 3463 | #print "AA<$1>\n"; |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 3464 | my ($ident, $from, $to) = ($1, $2, $2); |
Andy Whitcroft | d8aaf12 | 2007-06-23 17:16:44 -0700 | [diff] [blame] | 3465 | |
Andy Whitcroft | 6586386 | 2009-01-06 14:41:21 -0800 | [diff] [blame] | 3466 | # Should start with a space. |
| 3467 | $to =~ s/^(\S)/ $1/; |
| 3468 | # Should not end with a space. |
| 3469 | $to =~ s/\s+$//; |
| 3470 | # '*'s should not have spaces between. |
Andy Whitcroft | f9a0b3d | 2009-01-15 13:51:05 -0800 | [diff] [blame] | 3471 | while ($to =~ s/\*\s+\*/\*\*/) { |
Andy Whitcroft | 6586386 | 2009-01-06 14:41:21 -0800 | [diff] [blame] | 3472 | } |
Andy Whitcroft | d8aaf12 | 2007-06-23 17:16:44 -0700 | [diff] [blame] | 3473 | |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 3474 | ## print "1: from<$from> to<$to> ident<$ident>\n"; |
Andy Whitcroft | 6586386 | 2009-01-06 14:41:21 -0800 | [diff] [blame] | 3475 | if ($from ne $to) { |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 3476 | if (ERROR("POINTER_LOCATION", |
| 3477 | "\"(foo$from)\" should be \"(foo$to)\"\n" . $herecurr) && |
| 3478 | $fix) { |
| 3479 | my $sub_from = $ident; |
| 3480 | my $sub_to = $ident; |
| 3481 | $sub_to =~ s/\Q$from\E/$to/; |
Joe Perches | 194f66f | 2014-08-06 16:11:03 -0700 | [diff] [blame] | 3482 | $fixed[$fixlinenr] =~ |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 3483 | s@\Q$sub_from\E@$sub_to@; |
| 3484 | } |
Andy Whitcroft | 6586386 | 2009-01-06 14:41:21 -0800 | [diff] [blame] | 3485 | } |
Andy Whitcroft | bfcb2cc | 2012-01-10 15:10:15 -0800 | [diff] [blame] | 3486 | } |
| 3487 | while ($line =~ m{(\b$NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)($Ident))}g) { |
| 3488 | #print "BB<$1>\n"; |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 3489 | my ($match, $from, $to, $ident) = ($1, $2, $2, $3); |
Andy Whitcroft | d8aaf12 | 2007-06-23 17:16:44 -0700 | [diff] [blame] | 3490 | |
Andy Whitcroft | 6586386 | 2009-01-06 14:41:21 -0800 | [diff] [blame] | 3491 | # Should start with a space. |
| 3492 | $to =~ s/^(\S)/ $1/; |
| 3493 | # Should not end with a space. |
| 3494 | $to =~ s/\s+$//; |
| 3495 | # '*'s should not have spaces between. |
Andy Whitcroft | f9a0b3d | 2009-01-15 13:51:05 -0800 | [diff] [blame] | 3496 | while ($to =~ s/\*\s+\*/\*\*/) { |
Andy Whitcroft | 6586386 | 2009-01-06 14:41:21 -0800 | [diff] [blame] | 3497 | } |
| 3498 | # Modifiers should have spaces. |
| 3499 | $to =~ s/(\b$Modifier$)/$1 /; |
| 3500 | |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 3501 | ## print "2: from<$from> to<$to> ident<$ident>\n"; |
Andy Whitcroft | 667026e | 2009-02-27 14:03:08 -0800 | [diff] [blame] | 3502 | if ($from ne $to && $ident !~ /^$Modifier$/) { |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 3503 | if (ERROR("POINTER_LOCATION", |
| 3504 | "\"foo${from}bar\" should be \"foo${to}bar\"\n" . $herecurr) && |
| 3505 | $fix) { |
| 3506 | |
| 3507 | my $sub_from = $match; |
| 3508 | my $sub_to = $match; |
| 3509 | $sub_to =~ s/\Q$from\E/$to/; |
Joe Perches | 194f66f | 2014-08-06 16:11:03 -0700 | [diff] [blame] | 3510 | $fixed[$fixlinenr] =~ |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 3511 | s@\Q$sub_from\E@$sub_to@; |
| 3512 | } |
Andy Whitcroft | 6586386 | 2009-01-06 14:41:21 -0800 | [diff] [blame] | 3513 | } |
Andy Whitcroft | 0a920b5 | 2007-06-01 00:46:48 -0700 | [diff] [blame] | 3514 | } |
| 3515 | |
Joe Perches | 9d3e3c7 | 2015-09-09 15:37:27 -0700 | [diff] [blame] | 3516 | # avoid BUG() or BUG_ON() |
| 3517 | if ($line =~ /\b(?:BUG|BUG_ON)\b/) { |
| 3518 | my $msg_type = \&WARN; |
| 3519 | $msg_type = \&CHK if ($file); |
| 3520 | &{$msg_type}("AVOID_BUG", |
| 3521 | "Avoid crashing the kernel - try using WARN_ON & recovery code rather than BUG() or BUG_ON()\n" . $herecurr); |
| 3522 | } |
Andy Whitcroft | 0a920b5 | 2007-06-01 00:46:48 -0700 | [diff] [blame] | 3523 | |
Joe Perches | 9d3e3c7 | 2015-09-09 15:37:27 -0700 | [diff] [blame] | 3524 | # avoid LINUX_VERSION_CODE |
Andy Whitcroft | 8905a67 | 2007-11-28 16:21:06 -0800 | [diff] [blame] | 3525 | if ($line =~ /\bLINUX_VERSION_CODE\b/) { |
Joe Perches | 000d1cc1 | 2011-07-25 17:13:25 -0700 | [diff] [blame] | 3526 | WARN("LINUX_VERSION_CODE", |
| 3527 | "LINUX_VERSION_CODE should be avoided, code should be for the version to which it is merged\n" . $herecurr); |
Andy Whitcroft | 8905a67 | 2007-11-28 16:21:06 -0800 | [diff] [blame] | 3528 | } |
| 3529 | |
Joe Perches | 1744122 | 2011-06-15 15:08:17 -0700 | [diff] [blame] | 3530 | # check for uses of printk_ratelimit |
| 3531 | if ($line =~ /\bprintk_ratelimit\s*\(/) { |
Joe Perches | 000d1cc1 | 2011-07-25 17:13:25 -0700 | [diff] [blame] | 3532 | WARN("PRINTK_RATELIMITED", |
Joe Perches | 101ee68 | 2015-02-13 14:38:54 -0800 | [diff] [blame] | 3533 | "Prefer printk_ratelimited or pr_<level>_ratelimited to printk_ratelimit\n" . $herecurr); |
Joe Perches | 1744122 | 2011-06-15 15:08:17 -0700 | [diff] [blame] | 3534 | } |
| 3535 | |
Andy Whitcroft | 00df344 | 2007-06-08 13:47:06 -0700 | [diff] [blame] | 3536 | # printk should use KERN_* levels. Note that follow on printk's on the |
| 3537 | # same line do not need a level, so we use the current block context |
| 3538 | # to try and find and validate the current printk. In summary the current |
Lucas De Marchi | 25985ed | 2011-03-30 22:57:33 -0300 | [diff] [blame] | 3539 | # printk includes all preceding printk's which have no newline on the end. |
Andy Whitcroft | 00df344 | 2007-06-08 13:47:06 -0700 | [diff] [blame] | 3540 | # we assume the first bad printk is the one to report. |
Andy Whitcroft | f0a594c | 2007-07-19 01:48:34 -0700 | [diff] [blame] | 3541 | if ($line =~ /\bprintk\((?!KERN_)\s*"/) { |
Andy Whitcroft | 00df344 | 2007-06-08 13:47:06 -0700 | [diff] [blame] | 3542 | my $ok = 0; |
| 3543 | for (my $ln = $linenr - 1; $ln >= $first_line; $ln--) { |
| 3544 | #print "CHECK<$lines[$ln - 1]\n"; |
Lucas De Marchi | 25985ed | 2011-03-30 22:57:33 -0300 | [diff] [blame] | 3545 | # we have a preceding printk if it ends |
Andy Whitcroft | 00df344 | 2007-06-08 13:47:06 -0700 | [diff] [blame] | 3546 | # with "\n" ignore it, else it is to blame |
| 3547 | if ($lines[$ln - 1] =~ m{\bprintk\(}) { |
| 3548 | if ($rawlines[$ln - 1] !~ m{\\n"}) { |
| 3549 | $ok = 1; |
| 3550 | } |
| 3551 | last; |
| 3552 | } |
| 3553 | } |
| 3554 | if ($ok == 0) { |
Joe Perches | 000d1cc1 | 2011-07-25 17:13:25 -0700 | [diff] [blame] | 3555 | WARN("PRINTK_WITHOUT_KERN_LEVEL", |
| 3556 | "printk() should include KERN_ facility level\n" . $herecurr); |
Andy Whitcroft | 00df344 | 2007-06-08 13:47:06 -0700 | [diff] [blame] | 3557 | } |
Andy Whitcroft | 0a920b5 | 2007-06-01 00:46:48 -0700 | [diff] [blame] | 3558 | } |
| 3559 | |
Joe Perches | 243f380 | 2012-05-31 16:26:09 -0700 | [diff] [blame] | 3560 | if ($line =~ /\bprintk\s*\(\s*KERN_([A-Z]+)/) { |
| 3561 | my $orig = $1; |
| 3562 | my $level = lc($orig); |
| 3563 | $level = "warn" if ($level eq "warning"); |
Joe Perches | 8f26b83 | 2012-10-04 17:13:32 -0700 | [diff] [blame] | 3564 | my $level2 = $level; |
| 3565 | $level2 = "dbg" if ($level eq "debug"); |
Joe Perches | 243f380 | 2012-05-31 16:26:09 -0700 | [diff] [blame] | 3566 | WARN("PREFER_PR_LEVEL", |
Yogesh Chaudhari | daa8b05 | 2014-04-03 14:49:23 -0700 | [diff] [blame] | 3567 | "Prefer [subsystem eg: netdev]_$level2([subsystem]dev, ... then dev_$level2(dev, ... then pr_$level(... to printk(KERN_$orig ...\n" . $herecurr); |
Joe Perches | 243f380 | 2012-05-31 16:26:09 -0700 | [diff] [blame] | 3568 | } |
| 3569 | |
| 3570 | if ($line =~ /\bpr_warning\s*\(/) { |
Joe Perches | d5e616f | 2013-09-11 14:23:54 -0700 | [diff] [blame] | 3571 | if (WARN("PREFER_PR_LEVEL", |
| 3572 | "Prefer pr_warn(... to pr_warning(...\n" . $herecurr) && |
| 3573 | $fix) { |
Joe Perches | 194f66f | 2014-08-06 16:11:03 -0700 | [diff] [blame] | 3574 | $fixed[$fixlinenr] =~ |
Joe Perches | d5e616f | 2013-09-11 14:23:54 -0700 | [diff] [blame] | 3575 | s/\bpr_warning\b/pr_warn/; |
| 3576 | } |
Joe Perches | 243f380 | 2012-05-31 16:26:09 -0700 | [diff] [blame] | 3577 | } |
| 3578 | |
Joe Perches | dc13931 | 2013-02-21 16:44:13 -0800 | [diff] [blame] | 3579 | if ($line =~ /\bdev_printk\s*\(\s*KERN_([A-Z]+)/) { |
| 3580 | my $orig = $1; |
| 3581 | my $level = lc($orig); |
| 3582 | $level = "warn" if ($level eq "warning"); |
| 3583 | $level = "dbg" if ($level eq "debug"); |
| 3584 | WARN("PREFER_DEV_LEVEL", |
| 3585 | "Prefer dev_$level(... to dev_printk(KERN_$orig, ...\n" . $herecurr); |
| 3586 | } |
| 3587 | |
Andy Lutomirski | 91c9afa | 2015-04-16 12:44:44 -0700 | [diff] [blame] | 3588 | # ENOSYS means "bad syscall nr" and nothing else. This will have a small |
| 3589 | # number of false positives, but assembly files are not checked, so at |
| 3590 | # least the arch entry code will not trigger this warning. |
| 3591 | if ($line =~ /\bENOSYS\b/) { |
| 3592 | WARN("ENOSYS", |
| 3593 | "ENOSYS means 'invalid syscall nr' and nothing else\n" . $herecurr); |
| 3594 | } |
| 3595 | |
Andy Whitcroft | 653d487 | 2007-06-23 17:16:34 -0700 | [diff] [blame] | 3596 | # function brace can't be on same line, except for #defines of do while, |
| 3597 | # or if closed on same line |
Joe Perches | 8d18247 | 2014-08-06 16:11:12 -0700 | [diff] [blame] | 3598 | if (($line=~/$Type\s*$Ident\(.*\).*\s*{/) and |
Eddie Kovsky | 4e5d56b | 2015-09-09 15:37:52 -0700 | [diff] [blame] | 3599 | !($line=~/\#\s*define.*do\s\{/) and !($line=~/}/)) { |
Joe Perches | 8d18247 | 2014-08-06 16:11:12 -0700 | [diff] [blame] | 3600 | if (ERROR("OPEN_BRACE", |
| 3601 | "open brace '{' following function declarations go on the next line\n" . $herecurr) && |
| 3602 | $fix) { |
| 3603 | fix_delete_line($fixlinenr, $rawline); |
| 3604 | my $fixed_line = $rawline; |
| 3605 | $fixed_line =~ /(^..*$Type\s*$Ident\(.*\)\s*){(.*)$/; |
| 3606 | my $line1 = $1; |
| 3607 | my $line2 = $2; |
| 3608 | fix_insert_line($fixlinenr, ltrim($line1)); |
| 3609 | fix_insert_line($fixlinenr, "\+{"); |
| 3610 | if ($line2 !~ /^\s*$/) { |
| 3611 | fix_insert_line($fixlinenr, "\+\t" . trim($line2)); |
| 3612 | } |
| 3613 | } |
Andy Whitcroft | 0a920b5 | 2007-06-01 00:46:48 -0700 | [diff] [blame] | 3614 | } |
Andy Whitcroft | 653d487 | 2007-06-23 17:16:34 -0700 | [diff] [blame] | 3615 | |
Andy Whitcroft | 8905a67 | 2007-11-28 16:21:06 -0800 | [diff] [blame] | 3616 | # open braces for enum, union and struct go on the same line. |
| 3617 | if ($line =~ /^.\s*{/ && |
| 3618 | $prevline =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident)?\s*$/) { |
Joe Perches | 8d18247 | 2014-08-06 16:11:12 -0700 | [diff] [blame] | 3619 | if (ERROR("OPEN_BRACE", |
| 3620 | "open brace '{' following $1 go on the same line\n" . $hereprev) && |
| 3621 | $fix && $prevline =~ /^\+/ && $line =~ /^\+/) { |
| 3622 | fix_delete_line($fixlinenr - 1, $prevrawline); |
| 3623 | fix_delete_line($fixlinenr, $rawline); |
| 3624 | my $fixedline = rtrim($prevrawline) . " {"; |
| 3625 | fix_insert_line($fixlinenr, $fixedline); |
| 3626 | $fixedline = $rawline; |
| 3627 | $fixedline =~ s/^(.\s*){\s*/$1\t/; |
| 3628 | if ($fixedline !~ /^\+\s*$/) { |
| 3629 | fix_insert_line($fixlinenr, $fixedline); |
| 3630 | } |
| 3631 | } |
Andy Whitcroft | 8905a67 | 2007-11-28 16:21:06 -0800 | [diff] [blame] | 3632 | } |
| 3633 | |
Andy Whitcroft | 0c73b4e | 2010-10-26 14:23:15 -0700 | [diff] [blame] | 3634 | # missing space after union, struct or enum definition |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 3635 | if ($line =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident){1,2}[=\{]/) { |
| 3636 | if (WARN("SPACING", |
| 3637 | "missing space after $1 definition\n" . $herecurr) && |
| 3638 | $fix) { |
Joe Perches | 194f66f | 2014-08-06 16:11:03 -0700 | [diff] [blame] | 3639 | $fixed[$fixlinenr] =~ |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 3640 | s/^(.\s*(?:typedef\s+)?(?:enum|union|struct)(?:\s+$Ident){1,2})([=\{])/$1 $2/; |
| 3641 | } |
Andy Whitcroft | 0c73b4e | 2010-10-26 14:23:15 -0700 | [diff] [blame] | 3642 | } |
| 3643 | |
Joe Perches | 31070b5 | 2014-01-23 15:54:49 -0800 | [diff] [blame] | 3644 | # Function pointer declarations |
| 3645 | # check spacing between type, funcptr, and args |
| 3646 | # canonical declaration is "type (*funcptr)(args...)" |
Joe Perches | 91f72e9 | 2014-04-03 14:49:12 -0700 | [diff] [blame] | 3647 | if ($line =~ /^.\s*($Declare)\((\s*)\*(\s*)($Ident)(\s*)\)(\s*)\(/) { |
Joe Perches | 31070b5 | 2014-01-23 15:54:49 -0800 | [diff] [blame] | 3648 | my $declare = $1; |
| 3649 | my $pre_pointer_space = $2; |
| 3650 | my $post_pointer_space = $3; |
| 3651 | my $funcname = $4; |
| 3652 | my $post_funcname_space = $5; |
| 3653 | my $pre_args_space = $6; |
| 3654 | |
Joe Perches | 91f72e9 | 2014-04-03 14:49:12 -0700 | [diff] [blame] | 3655 | # the $Declare variable will capture all spaces after the type |
| 3656 | # so check it for a missing trailing missing space but pointer return types |
| 3657 | # don't need a space so don't warn for those. |
| 3658 | my $post_declare_space = ""; |
| 3659 | if ($declare =~ /(\s+)$/) { |
| 3660 | $post_declare_space = $1; |
| 3661 | $declare = rtrim($declare); |
| 3662 | } |
| 3663 | if ($declare !~ /\*$/ && $post_declare_space =~ /^$/) { |
Joe Perches | 31070b5 | 2014-01-23 15:54:49 -0800 | [diff] [blame] | 3664 | WARN("SPACING", |
| 3665 | "missing space after return type\n" . $herecurr); |
Joe Perches | 91f72e9 | 2014-04-03 14:49:12 -0700 | [diff] [blame] | 3666 | $post_declare_space = " "; |
Joe Perches | 31070b5 | 2014-01-23 15:54:49 -0800 | [diff] [blame] | 3667 | } |
| 3668 | |
| 3669 | # unnecessary space "type (*funcptr)(args...)" |
Joe Perches | 91f72e9 | 2014-04-03 14:49:12 -0700 | [diff] [blame] | 3670 | # This test is not currently implemented because these declarations are |
| 3671 | # equivalent to |
| 3672 | # int foo(int bar, ...) |
| 3673 | # and this is form shouldn't/doesn't generate a checkpatch warning. |
| 3674 | # |
| 3675 | # elsif ($declare =~ /\s{2,}$/) { |
| 3676 | # WARN("SPACING", |
| 3677 | # "Multiple spaces after return type\n" . $herecurr); |
| 3678 | # } |
Joe Perches | 31070b5 | 2014-01-23 15:54:49 -0800 | [diff] [blame] | 3679 | |
| 3680 | # unnecessary space "type ( *funcptr)(args...)" |
| 3681 | if (defined $pre_pointer_space && |
| 3682 | $pre_pointer_space =~ /^\s/) { |
| 3683 | WARN("SPACING", |
| 3684 | "Unnecessary space after function pointer open parenthesis\n" . $herecurr); |
| 3685 | } |
| 3686 | |
| 3687 | # unnecessary space "type (* funcptr)(args...)" |
| 3688 | if (defined $post_pointer_space && |
| 3689 | $post_pointer_space =~ /^\s/) { |
| 3690 | WARN("SPACING", |
| 3691 | "Unnecessary space before function pointer name\n" . $herecurr); |
| 3692 | } |
| 3693 | |
| 3694 | # unnecessary space "type (*funcptr )(args...)" |
| 3695 | if (defined $post_funcname_space && |
| 3696 | $post_funcname_space =~ /^\s/) { |
| 3697 | WARN("SPACING", |
| 3698 | "Unnecessary space after function pointer name\n" . $herecurr); |
| 3699 | } |
| 3700 | |
| 3701 | # unnecessary space "type (*funcptr) (args...)" |
| 3702 | if (defined $pre_args_space && |
| 3703 | $pre_args_space =~ /^\s/) { |
| 3704 | WARN("SPACING", |
| 3705 | "Unnecessary space before function pointer arguments\n" . $herecurr); |
| 3706 | } |
| 3707 | |
| 3708 | if (show_type("SPACING") && $fix) { |
Joe Perches | 194f66f | 2014-08-06 16:11:03 -0700 | [diff] [blame] | 3709 | $fixed[$fixlinenr] =~ |
Joe Perches | 91f72e9 | 2014-04-03 14:49:12 -0700 | [diff] [blame] | 3710 | s/^(.\s*)$Declare\s*\(\s*\*\s*$Ident\s*\)\s*\(/$1 . $declare . $post_declare_space . '(*' . $funcname . ')('/ex; |
Joe Perches | 31070b5 | 2014-01-23 15:54:49 -0800 | [diff] [blame] | 3711 | } |
| 3712 | } |
| 3713 | |
Andy Whitcroft | 8d31cfc | 2008-07-23 21:29:02 -0700 | [diff] [blame] | 3714 | # check for spacing round square brackets; allowed: |
| 3715 | # 1. with a type on the left -- int [] a; |
Andy Whitcroft | fe2a7db | 2008-10-15 22:02:15 -0700 | [diff] [blame] | 3716 | # 2. at the beginning of a line for slice initialisers -- [0...10] = 5, |
| 3717 | # 3. inside a curly brace -- = { [0...10] = 5 } |
Andy Whitcroft | 8d31cfc | 2008-07-23 21:29:02 -0700 | [diff] [blame] | 3718 | while ($line =~ /(.*?\s)\[/g) { |
| 3719 | my ($where, $prefix) = ($-[1], $1); |
| 3720 | if ($prefix !~ /$Type\s+$/ && |
Andy Whitcroft | fe2a7db | 2008-10-15 22:02:15 -0700 | [diff] [blame] | 3721 | ($where != 0 || $prefix !~ /^.\s+$/) && |
Andy Whitcroft | daebc53 | 2012-03-23 15:02:17 -0700 | [diff] [blame] | 3722 | $prefix !~ /[{,]\s+$/) { |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 3723 | if (ERROR("BRACKET_SPACE", |
| 3724 | "space prohibited before open square bracket '['\n" . $herecurr) && |
| 3725 | $fix) { |
Joe Perches | 194f66f | 2014-08-06 16:11:03 -0700 | [diff] [blame] | 3726 | $fixed[$fixlinenr] =~ |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 3727 | s/^(\+.*?)\s+\[/$1\[/; |
| 3728 | } |
Andy Whitcroft | 8d31cfc | 2008-07-23 21:29:02 -0700 | [diff] [blame] | 3729 | } |
| 3730 | } |
| 3731 | |
Andy Whitcroft | f0a594c | 2007-07-19 01:48:34 -0700 | [diff] [blame] | 3732 | # check for spaces between functions and their parentheses. |
Andy Whitcroft | 6c72ffa | 2007-10-18 03:05:08 -0700 | [diff] [blame] | 3733 | while ($line =~ /($Ident)\s+\(/g) { |
Andy Whitcroft | c2fdda0 | 2008-02-08 04:20:54 -0800 | [diff] [blame] | 3734 | my $name = $1; |
Andy Whitcroft | 773647a | 2008-03-28 14:15:58 -0700 | [diff] [blame] | 3735 | my $ctx_before = substr($line, 0, $-[1]); |
| 3736 | my $ctx = "$ctx_before$name"; |
Andy Whitcroft | c2fdda0 | 2008-02-08 04:20:54 -0800 | [diff] [blame] | 3737 | |
| 3738 | # Ignore those directives where spaces _are_ permitted. |
Andy Whitcroft | 773647a | 2008-03-28 14:15:58 -0700 | [diff] [blame] | 3739 | if ($name =~ /^(?: |
| 3740 | if|for|while|switch|return|case| |
| 3741 | volatile|__volatile__| |
| 3742 | __attribute__|format|__extension__| |
| 3743 | asm|__asm__)$/x) |
| 3744 | { |
Andy Whitcroft | c2fdda0 | 2008-02-08 04:20:54 -0800 | [diff] [blame] | 3745 | # cpp #define statements have non-optional spaces, ie |
| 3746 | # if there is a space between the name and the open |
| 3747 | # parenthesis it is simply not a parameter group. |
Andy Whitcroft | c45dcab | 2008-06-05 22:46:01 -0700 | [diff] [blame] | 3748 | } elsif ($ctx_before =~ /^.\s*\#\s*define\s*$/) { |
Andy Whitcroft | 773647a | 2008-03-28 14:15:58 -0700 | [diff] [blame] | 3749 | |
| 3750 | # cpp #elif statement condition may start with a ( |
Andy Whitcroft | c45dcab | 2008-06-05 22:46:01 -0700 | [diff] [blame] | 3751 | } elsif ($ctx =~ /^.\s*\#\s*elif\s*$/) { |
Andy Whitcroft | c2fdda0 | 2008-02-08 04:20:54 -0800 | [diff] [blame] | 3752 | |
| 3753 | # If this whole things ends with a type its most |
| 3754 | # likely a typedef for a function. |
Andy Whitcroft | 773647a | 2008-03-28 14:15:58 -0700 | [diff] [blame] | 3755 | } elsif ($ctx =~ /$Type$/) { |
Andy Whitcroft | c2fdda0 | 2008-02-08 04:20:54 -0800 | [diff] [blame] | 3756 | |
| 3757 | } else { |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 3758 | if (WARN("SPACING", |
| 3759 | "space prohibited between function name and open parenthesis '('\n" . $herecurr) && |
| 3760 | $fix) { |
Joe Perches | 194f66f | 2014-08-06 16:11:03 -0700 | [diff] [blame] | 3761 | $fixed[$fixlinenr] =~ |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 3762 | s/\b$name\s+\(/$name\(/; |
| 3763 | } |
Andy Whitcroft | 6c72ffa | 2007-10-18 03:05:08 -0700 | [diff] [blame] | 3764 | } |
Andy Whitcroft | f0a594c | 2007-07-19 01:48:34 -0700 | [diff] [blame] | 3765 | } |
Eric Nelson | 9a4cad4 | 2012-05-31 16:26:09 -0700 | [diff] [blame] | 3766 | |
Andy Whitcroft | 653d487 | 2007-06-23 17:16:34 -0700 | [diff] [blame] | 3767 | # Check operator spacing. |
Andy Whitcroft | 0a920b5 | 2007-06-01 00:46:48 -0700 | [diff] [blame] | 3768 | if (!($line=~/\#\s*include/)) { |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 3769 | my $fixed_line = ""; |
| 3770 | my $line_fixed = 0; |
| 3771 | |
Andy Whitcroft | 9c0ca6f | 2007-10-16 23:29:38 -0700 | [diff] [blame] | 3772 | my $ops = qr{ |
| 3773 | <<=|>>=|<=|>=|==|!=| |
| 3774 | \+=|-=|\*=|\/=|%=|\^=|\|=|&=| |
| 3775 | =>|->|<<|>>|<|>|=|!|~| |
Andy Whitcroft | 1f65f94 | 2008-07-23 21:29:10 -0700 | [diff] [blame] | 3776 | &&|\|\||,|\^|\+\+|--|&|\||\+|-|\*|\/|%| |
Joe Perches | 8473162 | 2013-11-12 15:10:05 -0800 | [diff] [blame] | 3777 | \?:|\?|: |
Andy Whitcroft | 9c0ca6f | 2007-10-16 23:29:38 -0700 | [diff] [blame] | 3778 | }x; |
Andy Whitcroft | cf65504 | 2008-03-04 14:28:20 -0800 | [diff] [blame] | 3779 | my @elements = split(/($ops|;)/, $opline); |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 3780 | |
| 3781 | ## print("element count: <" . $#elements . ">\n"); |
| 3782 | ## foreach my $el (@elements) { |
| 3783 | ## print("el: <$el>\n"); |
| 3784 | ## } |
| 3785 | |
| 3786 | my @fix_elements = (); |
Andy Whitcroft | 00df344 | 2007-06-08 13:47:06 -0700 | [diff] [blame] | 3787 | my $off = 0; |
Andy Whitcroft | 6c72ffa | 2007-10-18 03:05:08 -0700 | [diff] [blame] | 3788 | |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 3789 | foreach my $el (@elements) { |
| 3790 | push(@fix_elements, substr($rawline, $off, length($el))); |
| 3791 | $off += length($el); |
| 3792 | } |
| 3793 | |
| 3794 | $off = 0; |
| 3795 | |
Andy Whitcroft | 6c72ffa | 2007-10-18 03:05:08 -0700 | [diff] [blame] | 3796 | my $blank = copy_spacing($opline); |
Joe Perches | b34c648 | 2013-09-11 14:24:01 -0700 | [diff] [blame] | 3797 | my $last_after = -1; |
Andy Whitcroft | 6c72ffa | 2007-10-18 03:05:08 -0700 | [diff] [blame] | 3798 | |
Andy Whitcroft | 0a920b5 | 2007-06-01 00:46:48 -0700 | [diff] [blame] | 3799 | for (my $n = 0; $n < $#elements; $n += 2) { |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 3800 | |
| 3801 | my $good = $fix_elements[$n] . $fix_elements[$n + 1]; |
| 3802 | |
| 3803 | ## print("n: <$n> good: <$good>\n"); |
| 3804 | |
Andy Whitcroft | 4a0df2e | 2007-06-08 13:46:39 -0700 | [diff] [blame] | 3805 | $off += length($elements[$n]); |
| 3806 | |
Lucas De Marchi | 25985ed | 2011-03-30 22:57:33 -0300 | [diff] [blame] | 3807 | # Pick up the preceding and succeeding characters. |
Andy Whitcroft | 773647a | 2008-03-28 14:15:58 -0700 | [diff] [blame] | 3808 | my $ca = substr($opline, 0, $off); |
| 3809 | my $cc = ''; |
| 3810 | if (length($opline) >= ($off + length($elements[$n + 1]))) { |
| 3811 | $cc = substr($opline, $off + length($elements[$n + 1])); |
| 3812 | } |
| 3813 | my $cb = "$ca$;$cc"; |
| 3814 | |
Andy Whitcroft | 4a0df2e | 2007-06-08 13:46:39 -0700 | [diff] [blame] | 3815 | my $a = ''; |
| 3816 | $a = 'V' if ($elements[$n] ne ''); |
| 3817 | $a = 'W' if ($elements[$n] =~ /\s$/); |
Andy Whitcroft | cf65504 | 2008-03-04 14:28:20 -0800 | [diff] [blame] | 3818 | $a = 'C' if ($elements[$n] =~ /$;$/); |
Andy Whitcroft | 4a0df2e | 2007-06-08 13:46:39 -0700 | [diff] [blame] | 3819 | $a = 'B' if ($elements[$n] =~ /(\[|\()$/); |
| 3820 | $a = 'O' if ($elements[$n] eq ''); |
Andy Whitcroft | 773647a | 2008-03-28 14:15:58 -0700 | [diff] [blame] | 3821 | $a = 'E' if ($ca =~ /^\s*$/); |
Andy Whitcroft | 4a0df2e | 2007-06-08 13:46:39 -0700 | [diff] [blame] | 3822 | |
Andy Whitcroft | 0a920b5 | 2007-06-01 00:46:48 -0700 | [diff] [blame] | 3823 | my $op = $elements[$n + 1]; |
Andy Whitcroft | 4a0df2e | 2007-06-08 13:46:39 -0700 | [diff] [blame] | 3824 | |
| 3825 | my $c = ''; |
Andy Whitcroft | 0a920b5 | 2007-06-01 00:46:48 -0700 | [diff] [blame] | 3826 | if (defined $elements[$n + 2]) { |
Andy Whitcroft | 4a0df2e | 2007-06-08 13:46:39 -0700 | [diff] [blame] | 3827 | $c = 'V' if ($elements[$n + 2] ne ''); |
| 3828 | $c = 'W' if ($elements[$n + 2] =~ /^\s/); |
Andy Whitcroft | cf65504 | 2008-03-04 14:28:20 -0800 | [diff] [blame] | 3829 | $c = 'C' if ($elements[$n + 2] =~ /^$;/); |
Andy Whitcroft | 4a0df2e | 2007-06-08 13:46:39 -0700 | [diff] [blame] | 3830 | $c = 'B' if ($elements[$n + 2] =~ /^(\)|\]|;)/); |
| 3831 | $c = 'O' if ($elements[$n + 2] eq ''); |
Andy Whitcroft | 8b1b337 | 2009-01-06 14:41:27 -0800 | [diff] [blame] | 3832 | $c = 'E' if ($elements[$n + 2] =~ /^\s*\\$/); |
Andy Whitcroft | 4a0df2e | 2007-06-08 13:46:39 -0700 | [diff] [blame] | 3833 | } else { |
| 3834 | $c = 'E'; |
Andy Whitcroft | 0a920b5 | 2007-06-01 00:46:48 -0700 | [diff] [blame] | 3835 | } |
| 3836 | |
Andy Whitcroft | 4a0df2e | 2007-06-08 13:46:39 -0700 | [diff] [blame] | 3837 | my $ctx = "${a}x${c}"; |
| 3838 | |
| 3839 | my $at = "(ctx:$ctx)"; |
| 3840 | |
Andy Whitcroft | 6c72ffa | 2007-10-18 03:05:08 -0700 | [diff] [blame] | 3841 | my $ptr = substr($blank, 0, $off) . "^"; |
Andy Whitcroft | de7d4f0 | 2007-07-15 23:37:22 -0700 | [diff] [blame] | 3842 | my $hereptr = "$hereline$ptr\n"; |
Andy Whitcroft | 0a920b5 | 2007-06-01 00:46:48 -0700 | [diff] [blame] | 3843 | |
Andy Whitcroft | 74048ed | 2008-07-23 21:29:10 -0700 | [diff] [blame] | 3844 | # Pull out the value of this operator. |
Andy Whitcroft | 6c72ffa | 2007-10-18 03:05:08 -0700 | [diff] [blame] | 3845 | my $op_type = substr($curr_values, $off + 1, 1); |
Andy Whitcroft | 0a920b5 | 2007-06-01 00:46:48 -0700 | [diff] [blame] | 3846 | |
Andy Whitcroft | 1f65f94 | 2008-07-23 21:29:10 -0700 | [diff] [blame] | 3847 | # Get the full operator variant. |
| 3848 | my $opv = $op . substr($curr_vars, $off, 1); |
| 3849 | |
Andy Whitcroft | 13214ad | 2008-02-08 04:22:03 -0800 | [diff] [blame] | 3850 | # Ignore operators passed as parameters. |
| 3851 | if ($op_type ne 'V' && |
Sam Bobroff | d7fe806 | 2015-04-16 12:44:39 -0700 | [diff] [blame] | 3852 | $ca =~ /\s$/ && $cc =~ /^\s*[,\)]/) { |
Andy Whitcroft | 13214ad | 2008-02-08 04:22:03 -0800 | [diff] [blame] | 3853 | |
Andy Whitcroft | cf65504 | 2008-03-04 14:28:20 -0800 | [diff] [blame] | 3854 | # # Ignore comments |
| 3855 | # } elsif ($op =~ /^$;+$/) { |
Andy Whitcroft | 13214ad | 2008-02-08 04:22:03 -0800 | [diff] [blame] | 3856 | |
Andy Whitcroft | d8aaf12 | 2007-06-23 17:16:44 -0700 | [diff] [blame] | 3857 | # ; should have either the end of line or a space or \ after it |
Andy Whitcroft | 13214ad | 2008-02-08 04:22:03 -0800 | [diff] [blame] | 3858 | } elsif ($op eq ';') { |
Andy Whitcroft | cf65504 | 2008-03-04 14:28:20 -0800 | [diff] [blame] | 3859 | if ($ctx !~ /.x[WEBC]/ && |
| 3860 | $cc !~ /^\\/ && $cc !~ /^;/) { |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 3861 | if (ERROR("SPACING", |
| 3862 | "space required after that '$op' $at\n" . $hereptr)) { |
Joe Perches | b34c648 | 2013-09-11 14:24:01 -0700 | [diff] [blame] | 3863 | $good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " "; |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 3864 | $line_fixed = 1; |
| 3865 | } |
Andy Whitcroft | d8aaf12 | 2007-06-23 17:16:44 -0700 | [diff] [blame] | 3866 | } |
| 3867 | |
| 3868 | # // is a comment |
| 3869 | } elsif ($op eq '//') { |
Andy Whitcroft | 0a920b5 | 2007-06-01 00:46:48 -0700 | [diff] [blame] | 3870 | |
Joe Perches | b00e481 | 2014-04-03 14:49:33 -0700 | [diff] [blame] | 3871 | # : when part of a bitfield |
| 3872 | } elsif ($opv eq ':B') { |
| 3873 | # skip the bitfield test for now |
| 3874 | |
Andy Whitcroft | 1f65f94 | 2008-07-23 21:29:10 -0700 | [diff] [blame] | 3875 | # No spaces for: |
| 3876 | # -> |
Joe Perches | b00e481 | 2014-04-03 14:49:33 -0700 | [diff] [blame] | 3877 | } elsif ($op eq '->') { |
Andy Whitcroft | 4a0df2e | 2007-06-08 13:46:39 -0700 | [diff] [blame] | 3878 | if ($ctx =~ /Wx.|.xW/) { |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 3879 | if (ERROR("SPACING", |
| 3880 | "spaces prohibited around that '$op' $at\n" . $hereptr)) { |
Joe Perches | b34c648 | 2013-09-11 14:24:01 -0700 | [diff] [blame] | 3881 | $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]); |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 3882 | if (defined $fix_elements[$n + 2]) { |
| 3883 | $fix_elements[$n + 2] =~ s/^\s+//; |
| 3884 | } |
Joe Perches | b34c648 | 2013-09-11 14:24:01 -0700 | [diff] [blame] | 3885 | $line_fixed = 1; |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 3886 | } |
Andy Whitcroft | 0a920b5 | 2007-06-01 00:46:48 -0700 | [diff] [blame] | 3887 | } |
| 3888 | |
Joe Perches | 2381097 | 2014-12-10 15:51:32 -0800 | [diff] [blame] | 3889 | # , must not have a space before and must have a space on the right. |
Andy Whitcroft | 0a920b5 | 2007-06-01 00:46:48 -0700 | [diff] [blame] | 3890 | } elsif ($op eq ',') { |
Joe Perches | 2381097 | 2014-12-10 15:51:32 -0800 | [diff] [blame] | 3891 | my $rtrim_before = 0; |
| 3892 | my $space_after = 0; |
| 3893 | if ($ctx =~ /Wx./) { |
| 3894 | if (ERROR("SPACING", |
| 3895 | "space prohibited before that '$op' $at\n" . $hereptr)) { |
| 3896 | $line_fixed = 1; |
| 3897 | $rtrim_before = 1; |
| 3898 | } |
| 3899 | } |
Andy Whitcroft | cf65504 | 2008-03-04 14:28:20 -0800 | [diff] [blame] | 3900 | if ($ctx !~ /.x[WEC]/ && $cc !~ /^}/) { |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 3901 | if (ERROR("SPACING", |
| 3902 | "space required after that '$op' $at\n" . $hereptr)) { |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 3903 | $line_fixed = 1; |
Joe Perches | b34c648 | 2013-09-11 14:24:01 -0700 | [diff] [blame] | 3904 | $last_after = $n; |
Joe Perches | 2381097 | 2014-12-10 15:51:32 -0800 | [diff] [blame] | 3905 | $space_after = 1; |
| 3906 | } |
| 3907 | } |
| 3908 | if ($rtrim_before || $space_after) { |
| 3909 | if ($rtrim_before) { |
| 3910 | $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]); |
| 3911 | } else { |
| 3912 | $good = $fix_elements[$n] . trim($fix_elements[$n + 1]); |
| 3913 | } |
| 3914 | if ($space_after) { |
| 3915 | $good .= " "; |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 3916 | } |
Andy Whitcroft | 0a920b5 | 2007-06-01 00:46:48 -0700 | [diff] [blame] | 3917 | } |
| 3918 | |
Andy Whitcroft | 9c0ca6f | 2007-10-16 23:29:38 -0700 | [diff] [blame] | 3919 | # '*' as part of a type definition -- reported already. |
Andy Whitcroft | 74048ed | 2008-07-23 21:29:10 -0700 | [diff] [blame] | 3920 | } elsif ($opv eq '*_') { |
Andy Whitcroft | 9c0ca6f | 2007-10-16 23:29:38 -0700 | [diff] [blame] | 3921 | #warn "'*' is part of type\n"; |
| 3922 | |
| 3923 | # unary operators should have a space before and |
| 3924 | # none after. May be left adjacent to another |
| 3925 | # unary operator, or a cast |
| 3926 | } elsif ($op eq '!' || $op eq '~' || |
Andy Whitcroft | 74048ed | 2008-07-23 21:29:10 -0700 | [diff] [blame] | 3927 | $opv eq '*U' || $opv eq '-U' || |
Andy Whitcroft | 0d41386 | 2008-10-15 22:02:16 -0700 | [diff] [blame] | 3928 | $opv eq '&U' || $opv eq '&&U') { |
Andy Whitcroft | cf65504 | 2008-03-04 14:28:20 -0800 | [diff] [blame] | 3929 | if ($ctx !~ /[WEBC]x./ && $ca !~ /(?:\)|!|~|\*|-|\&|\||\+\+|\-\-|\{)$/) { |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 3930 | if (ERROR("SPACING", |
| 3931 | "space required before that '$op' $at\n" . $hereptr)) { |
Joe Perches | b34c648 | 2013-09-11 14:24:01 -0700 | [diff] [blame] | 3932 | if ($n != $last_after + 2) { |
| 3933 | $good = $fix_elements[$n] . " " . ltrim($fix_elements[$n + 1]); |
| 3934 | $line_fixed = 1; |
| 3935 | } |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 3936 | } |
Andy Whitcroft | 0a920b5 | 2007-06-01 00:46:48 -0700 | [diff] [blame] | 3937 | } |
Andy Whitcroft | a3340b3 | 2009-02-27 14:03:07 -0800 | [diff] [blame] | 3938 | if ($op eq '*' && $cc =~/\s*$Modifier\b/) { |
Andy Whitcroft | 171ae1a | 2008-04-29 00:59:32 -0700 | [diff] [blame] | 3939 | # A unary '*' may be const |
| 3940 | |
| 3941 | } elsif ($ctx =~ /.xW/) { |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 3942 | if (ERROR("SPACING", |
| 3943 | "space prohibited after that '$op' $at\n" . $hereptr)) { |
Joe Perches | b34c648 | 2013-09-11 14:24:01 -0700 | [diff] [blame] | 3944 | $good = $fix_elements[$n] . rtrim($fix_elements[$n + 1]); |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 3945 | if (defined $fix_elements[$n + 2]) { |
| 3946 | $fix_elements[$n + 2] =~ s/^\s+//; |
| 3947 | } |
Joe Perches | b34c648 | 2013-09-11 14:24:01 -0700 | [diff] [blame] | 3948 | $line_fixed = 1; |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 3949 | } |
Andy Whitcroft | 0a920b5 | 2007-06-01 00:46:48 -0700 | [diff] [blame] | 3950 | } |
| 3951 | |
| 3952 | # unary ++ and unary -- are allowed no space on one side. |
| 3953 | } elsif ($op eq '++' or $op eq '--') { |
Andy Whitcroft | 773647a | 2008-03-28 14:15:58 -0700 | [diff] [blame] | 3954 | if ($ctx !~ /[WEOBC]x[^W]/ && $ctx !~ /[^W]x[WOBEC]/) { |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 3955 | if (ERROR("SPACING", |
| 3956 | "space required one side of that '$op' $at\n" . $hereptr)) { |
Joe Perches | b34c648 | 2013-09-11 14:24:01 -0700 | [diff] [blame] | 3957 | $good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " "; |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 3958 | $line_fixed = 1; |
| 3959 | } |
Andy Whitcroft | 0a920b5 | 2007-06-01 00:46:48 -0700 | [diff] [blame] | 3960 | } |
Andy Whitcroft | 773647a | 2008-03-28 14:15:58 -0700 | [diff] [blame] | 3961 | if ($ctx =~ /Wx[BE]/ || |
| 3962 | ($ctx =~ /Wx./ && $cc =~ /^;/)) { |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 3963 | if (ERROR("SPACING", |
| 3964 | "space prohibited before that '$op' $at\n" . $hereptr)) { |
Joe Perches | b34c648 | 2013-09-11 14:24:01 -0700 | [diff] [blame] | 3965 | $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]); |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 3966 | $line_fixed = 1; |
| 3967 | } |
Andy Whitcroft | 653d487 | 2007-06-23 17:16:34 -0700 | [diff] [blame] | 3968 | } |
Andy Whitcroft | 773647a | 2008-03-28 14:15:58 -0700 | [diff] [blame] | 3969 | if ($ctx =~ /ExW/) { |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 3970 | if (ERROR("SPACING", |
| 3971 | "space prohibited after that '$op' $at\n" . $hereptr)) { |
Joe Perches | b34c648 | 2013-09-11 14:24:01 -0700 | [diff] [blame] | 3972 | $good = $fix_elements[$n] . trim($fix_elements[$n + 1]); |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 3973 | if (defined $fix_elements[$n + 2]) { |
| 3974 | $fix_elements[$n + 2] =~ s/^\s+//; |
| 3975 | } |
Joe Perches | b34c648 | 2013-09-11 14:24:01 -0700 | [diff] [blame] | 3976 | $line_fixed = 1; |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 3977 | } |
Andy Whitcroft | 773647a | 2008-03-28 14:15:58 -0700 | [diff] [blame] | 3978 | } |
| 3979 | |
Andy Whitcroft | 0a920b5 | 2007-06-01 00:46:48 -0700 | [diff] [blame] | 3980 | # << and >> may either have or not have spaces both sides |
Andy Whitcroft | 9c0ca6f | 2007-10-16 23:29:38 -0700 | [diff] [blame] | 3981 | } elsif ($op eq '<<' or $op eq '>>' or |
| 3982 | $op eq '&' or $op eq '^' or $op eq '|' or |
| 3983 | $op eq '+' or $op eq '-' or |
Andy Whitcroft | c2fdda0 | 2008-02-08 04:20:54 -0800 | [diff] [blame] | 3984 | $op eq '*' or $op eq '/' or |
| 3985 | $op eq '%') |
Andy Whitcroft | 0a920b5 | 2007-06-01 00:46:48 -0700 | [diff] [blame] | 3986 | { |
Joe Perches | d2e025f | 2015-02-13 14:38:57 -0800 | [diff] [blame] | 3987 | if ($check) { |
| 3988 | if (defined $fix_elements[$n + 2] && $ctx !~ /[EW]x[EW]/) { |
| 3989 | if (CHK("SPACING", |
| 3990 | "spaces preferred around that '$op' $at\n" . $hereptr)) { |
| 3991 | $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " "; |
| 3992 | $fix_elements[$n + 2] =~ s/^\s+//; |
| 3993 | $line_fixed = 1; |
| 3994 | } |
| 3995 | } elsif (!defined $fix_elements[$n + 2] && $ctx !~ /Wx[OE]/) { |
| 3996 | if (CHK("SPACING", |
| 3997 | "space preferred before that '$op' $at\n" . $hereptr)) { |
| 3998 | $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]); |
| 3999 | $line_fixed = 1; |
| 4000 | } |
| 4001 | } |
| 4002 | } elsif ($ctx =~ /Wx[^WCE]|[^WCE]xW/) { |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 4003 | if (ERROR("SPACING", |
| 4004 | "need consistent spacing around '$op' $at\n" . $hereptr)) { |
Joe Perches | b34c648 | 2013-09-11 14:24:01 -0700 | [diff] [blame] | 4005 | $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " "; |
| 4006 | if (defined $fix_elements[$n + 2]) { |
| 4007 | $fix_elements[$n + 2] =~ s/^\s+//; |
| 4008 | } |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 4009 | $line_fixed = 1; |
| 4010 | } |
Andy Whitcroft | 0a920b5 | 2007-06-01 00:46:48 -0700 | [diff] [blame] | 4011 | } |
| 4012 | |
Andy Whitcroft | 1f65f94 | 2008-07-23 21:29:10 -0700 | [diff] [blame] | 4013 | # A colon needs no spaces before when it is |
| 4014 | # terminating a case value or a label. |
| 4015 | } elsif ($opv eq ':C' || $opv eq ':L') { |
| 4016 | if ($ctx =~ /Wx./) { |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 4017 | if (ERROR("SPACING", |
| 4018 | "space prohibited before that '$op' $at\n" . $hereptr)) { |
Joe Perches | b34c648 | 2013-09-11 14:24:01 -0700 | [diff] [blame] | 4019 | $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]); |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 4020 | $line_fixed = 1; |
| 4021 | } |
Andy Whitcroft | 1f65f94 | 2008-07-23 21:29:10 -0700 | [diff] [blame] | 4022 | } |
| 4023 | |
Andy Whitcroft | 0a920b5 | 2007-06-01 00:46:48 -0700 | [diff] [blame] | 4024 | # All the others need spaces both sides. |
Andy Whitcroft | cf65504 | 2008-03-04 14:28:20 -0800 | [diff] [blame] | 4025 | } elsif ($ctx !~ /[EWC]x[CWE]/) { |
Andy Whitcroft | 1f65f94 | 2008-07-23 21:29:10 -0700 | [diff] [blame] | 4026 | my $ok = 0; |
| 4027 | |
Andy Whitcroft | 22f2a2e | 2007-08-10 13:01:03 -0700 | [diff] [blame] | 4028 | # Ignore email addresses <foo@bar> |
Andy Whitcroft | 1f65f94 | 2008-07-23 21:29:10 -0700 | [diff] [blame] | 4029 | if (($op eq '<' && |
| 4030 | $cc =~ /^\S+\@\S+>/) || |
| 4031 | ($op eq '>' && |
| 4032 | $ca =~ /<\S+\@\S+$/)) |
| 4033 | { |
| 4034 | $ok = 1; |
| 4035 | } |
| 4036 | |
Joe Perches | e0df7e1 | 2015-04-16 12:44:53 -0700 | [diff] [blame] | 4037 | # for asm volatile statements |
| 4038 | # ignore a colon with another |
| 4039 | # colon immediately before or after |
| 4040 | if (($op eq ':') && |
| 4041 | ($ca =~ /:$/ || $cc =~ /^:/)) { |
| 4042 | $ok = 1; |
| 4043 | } |
| 4044 | |
Joe Perches | 8473162 | 2013-11-12 15:10:05 -0800 | [diff] [blame] | 4045 | # messages are ERROR, but ?: are CHK |
Andy Whitcroft | 1f65f94 | 2008-07-23 21:29:10 -0700 | [diff] [blame] | 4046 | if ($ok == 0) { |
Joe Perches | 8473162 | 2013-11-12 15:10:05 -0800 | [diff] [blame] | 4047 | my $msg_type = \&ERROR; |
| 4048 | $msg_type = \&CHK if (($op eq '?:' || $op eq '?' || $op eq ':') && $ctx =~ /VxV/); |
| 4049 | |
| 4050 | if (&{$msg_type}("SPACING", |
| 4051 | "spaces required around that '$op' $at\n" . $hereptr)) { |
Joe Perches | b34c648 | 2013-09-11 14:24:01 -0700 | [diff] [blame] | 4052 | $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " "; |
| 4053 | if (defined $fix_elements[$n + 2]) { |
| 4054 | $fix_elements[$n + 2] =~ s/^\s+//; |
| 4055 | } |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 4056 | $line_fixed = 1; |
| 4057 | } |
Andy Whitcroft | 22f2a2e | 2007-08-10 13:01:03 -0700 | [diff] [blame] | 4058 | } |
Andy Whitcroft | 0a920b5 | 2007-06-01 00:46:48 -0700 | [diff] [blame] | 4059 | } |
Andy Whitcroft | 4a0df2e | 2007-06-08 13:46:39 -0700 | [diff] [blame] | 4060 | $off += length($elements[$n + 1]); |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 4061 | |
| 4062 | ## print("n: <$n> GOOD: <$good>\n"); |
| 4063 | |
| 4064 | $fixed_line = $fixed_line . $good; |
Andy Whitcroft | 0a920b5 | 2007-06-01 00:46:48 -0700 | [diff] [blame] | 4065 | } |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 4066 | |
| 4067 | if (($#elements % 2) == 0) { |
| 4068 | $fixed_line = $fixed_line . $fix_elements[$#elements]; |
| 4069 | } |
| 4070 | |
Joe Perches | 194f66f | 2014-08-06 16:11:03 -0700 | [diff] [blame] | 4071 | if ($fix && $line_fixed && $fixed_line ne $fixed[$fixlinenr]) { |
| 4072 | $fixed[$fixlinenr] = $fixed_line; |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 4073 | } |
| 4074 | |
| 4075 | |
Andy Whitcroft | 0a920b5 | 2007-06-01 00:46:48 -0700 | [diff] [blame] | 4076 | } |
| 4077 | |
Joe Perches | 786b632 | 2013-07-03 15:05:32 -0700 | [diff] [blame] | 4078 | # check for whitespace before a non-naked semicolon |
Joe Perches | d2e248e | 2014-01-23 15:54:41 -0800 | [diff] [blame] | 4079 | if ($line =~ /^\+.*\S\s+;\s*$/) { |
Joe Perches | 786b632 | 2013-07-03 15:05:32 -0700 | [diff] [blame] | 4080 | if (WARN("SPACING", |
| 4081 | "space prohibited before semicolon\n" . $herecurr) && |
| 4082 | $fix) { |
Joe Perches | 194f66f | 2014-08-06 16:11:03 -0700 | [diff] [blame] | 4083 | 1 while $fixed[$fixlinenr] =~ |
Joe Perches | 786b632 | 2013-07-03 15:05:32 -0700 | [diff] [blame] | 4084 | s/^(\+.*\S)\s+;/$1;/; |
| 4085 | } |
| 4086 | } |
| 4087 | |
Andy Whitcroft | f0a594c | 2007-07-19 01:48:34 -0700 | [diff] [blame] | 4088 | # check for multiple assignments |
| 4089 | if ($line =~ /^.\s*$Lval\s*=\s*$Lval\s*=(?!=)/) { |
Joe Perches | 000d1cc1 | 2011-07-25 17:13:25 -0700 | [diff] [blame] | 4090 | CHK("MULTIPLE_ASSIGNMENTS", |
| 4091 | "multiple assignments should be avoided\n" . $herecurr); |
Andy Whitcroft | f0a594c | 2007-07-19 01:48:34 -0700 | [diff] [blame] | 4092 | } |
| 4093 | |
Andy Whitcroft | 22f2a2e | 2007-08-10 13:01:03 -0700 | [diff] [blame] | 4094 | ## # check for multiple declarations, allowing for a function declaration |
| 4095 | ## # continuation. |
| 4096 | ## if ($line =~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Ident.*/ && |
| 4097 | ## $line !~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Type\s*$Ident.*/) { |
| 4098 | ## |
| 4099 | ## # Remove any bracketed sections to ensure we do not |
| 4100 | ## # falsly report the parameters of functions. |
| 4101 | ## my $ln = $line; |
| 4102 | ## while ($ln =~ s/\([^\(\)]*\)//g) { |
| 4103 | ## } |
| 4104 | ## if ($ln =~ /,/) { |
Joe Perches | 000d1cc1 | 2011-07-25 17:13:25 -0700 | [diff] [blame] | 4105 | ## WARN("MULTIPLE_DECLARATION", |
| 4106 | ## "declaring multiple variables together should be avoided\n" . $herecurr); |
Andy Whitcroft | 22f2a2e | 2007-08-10 13:01:03 -0700 | [diff] [blame] | 4107 | ## } |
| 4108 | ## } |
Andy Whitcroft | f0a594c | 2007-07-19 01:48:34 -0700 | [diff] [blame] | 4109 | |
Andy Whitcroft | 0a920b5 | 2007-06-01 00:46:48 -0700 | [diff] [blame] | 4110 | #need space before brace following if, while, etc |
Eddie Kovsky | 4e5d56b | 2015-09-09 15:37:52 -0700 | [diff] [blame] | 4111 | if (($line =~ /\(.*\)\{/ && $line !~ /\($Type\){/) || |
| 4112 | $line =~ /do\{/) { |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 4113 | if (ERROR("SPACING", |
| 4114 | "space required before the open brace '{'\n" . $herecurr) && |
| 4115 | $fix) { |
Joe Perches | 194f66f | 2014-08-06 16:11:03 -0700 | [diff] [blame] | 4116 | $fixed[$fixlinenr] =~ s/^(\+.*(?:do|\))){/$1 {/; |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 4117 | } |
Andy Whitcroft | de7d4f0 | 2007-07-15 23:37:22 -0700 | [diff] [blame] | 4118 | } |
| 4119 | |
Joe Perches | c4a62ef | 2013-07-03 15:05:28 -0700 | [diff] [blame] | 4120 | ## # check for blank lines before declarations |
| 4121 | ## if ($line =~ /^.\t+$Type\s+$Ident(?:\s*=.*)?;/ && |
| 4122 | ## $prevrawline =~ /^.\s*$/) { |
| 4123 | ## WARN("SPACING", |
| 4124 | ## "No blank lines before declarations\n" . $hereprev); |
| 4125 | ## } |
| 4126 | ## |
| 4127 | |
Andy Whitcroft | de7d4f0 | 2007-07-15 23:37:22 -0700 | [diff] [blame] | 4128 | # closing brace should have a space following it when it has anything |
| 4129 | # on the line |
| 4130 | if ($line =~ /}(?!(?:,|;|\)))\S/) { |
Joe Perches | d5e616f | 2013-09-11 14:23:54 -0700 | [diff] [blame] | 4131 | if (ERROR("SPACING", |
| 4132 | "space required after that close brace '}'\n" . $herecurr) && |
| 4133 | $fix) { |
Joe Perches | 194f66f | 2014-08-06 16:11:03 -0700 | [diff] [blame] | 4134 | $fixed[$fixlinenr] =~ |
Joe Perches | d5e616f | 2013-09-11 14:23:54 -0700 | [diff] [blame] | 4135 | s/}((?!(?:,|;|\)))\S)/} $1/; |
| 4136 | } |
Andy Whitcroft | 0a920b5 | 2007-06-01 00:46:48 -0700 | [diff] [blame] | 4137 | } |
| 4138 | |
Andy Whitcroft | 22f2a2e | 2007-08-10 13:01:03 -0700 | [diff] [blame] | 4139 | # check spacing on square brackets |
| 4140 | if ($line =~ /\[\s/ && $line !~ /\[\s*$/) { |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 4141 | if (ERROR("SPACING", |
| 4142 | "space prohibited after that open square bracket '['\n" . $herecurr) && |
| 4143 | $fix) { |
Joe Perches | 194f66f | 2014-08-06 16:11:03 -0700 | [diff] [blame] | 4144 | $fixed[$fixlinenr] =~ |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 4145 | s/\[\s+/\[/; |
| 4146 | } |
Andy Whitcroft | 22f2a2e | 2007-08-10 13:01:03 -0700 | [diff] [blame] | 4147 | } |
| 4148 | if ($line =~ /\s\]/) { |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 4149 | if (ERROR("SPACING", |
| 4150 | "space prohibited before that close square bracket ']'\n" . $herecurr) && |
| 4151 | $fix) { |
Joe Perches | 194f66f | 2014-08-06 16:11:03 -0700 | [diff] [blame] | 4152 | $fixed[$fixlinenr] =~ |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 4153 | s/\s+\]/\]/; |
| 4154 | } |
Andy Whitcroft | 22f2a2e | 2007-08-10 13:01:03 -0700 | [diff] [blame] | 4155 | } |
| 4156 | |
Andy Whitcroft | c45dcab | 2008-06-05 22:46:01 -0700 | [diff] [blame] | 4157 | # check spacing on parentheses |
Andy Whitcroft | 9c0ca6f | 2007-10-16 23:29:38 -0700 | [diff] [blame] | 4158 | if ($line =~ /\(\s/ && $line !~ /\(\s*(?:\\)?$/ && |
| 4159 | $line !~ /for\s*\(\s+;/) { |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 4160 | if (ERROR("SPACING", |
| 4161 | "space prohibited after that open parenthesis '('\n" . $herecurr) && |
| 4162 | $fix) { |
Joe Perches | 194f66f | 2014-08-06 16:11:03 -0700 | [diff] [blame] | 4163 | $fixed[$fixlinenr] =~ |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 4164 | s/\(\s+/\(/; |
| 4165 | } |
Andy Whitcroft | 22f2a2e | 2007-08-10 13:01:03 -0700 | [diff] [blame] | 4166 | } |
Andy Whitcroft | 13214ad | 2008-02-08 04:22:03 -0800 | [diff] [blame] | 4167 | if ($line =~ /(\s+)\)/ && $line !~ /^.\s*\)/ && |
Andy Whitcroft | c45dcab | 2008-06-05 22:46:01 -0700 | [diff] [blame] | 4168 | $line !~ /for\s*\(.*;\s+\)/ && |
| 4169 | $line !~ /:\s+\)/) { |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 4170 | if (ERROR("SPACING", |
| 4171 | "space prohibited before that close parenthesis ')'\n" . $herecurr) && |
| 4172 | $fix) { |
Joe Perches | 194f66f | 2014-08-06 16:11:03 -0700 | [diff] [blame] | 4173 | $fixed[$fixlinenr] =~ |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 4174 | s/\s+\)/\)/; |
| 4175 | } |
Andy Whitcroft | 22f2a2e | 2007-08-10 13:01:03 -0700 | [diff] [blame] | 4176 | } |
| 4177 | |
Joe Perches | e2826fd | 2014-08-06 16:10:48 -0700 | [diff] [blame] | 4178 | # check unnecessary parentheses around addressof/dereference single $Lvals |
| 4179 | # ie: &(foo->bar) should be &foo->bar and *(foo->bar) should be *foo->bar |
| 4180 | |
| 4181 | while ($line =~ /(?:[^&]&\s*|\*)\(\s*($Ident\s*(?:$Member\s*)+)\s*\)/g) { |
Joe Perches | ea4acbb | 2014-12-10 15:51:51 -0800 | [diff] [blame] | 4182 | my $var = $1; |
| 4183 | if (CHK("UNNECESSARY_PARENTHESES", |
| 4184 | "Unnecessary parentheses around $var\n" . $herecurr) && |
| 4185 | $fix) { |
| 4186 | $fixed[$fixlinenr] =~ s/\(\s*\Q$var\E\s*\)/$var/; |
| 4187 | } |
| 4188 | } |
| 4189 | |
| 4190 | # check for unnecessary parentheses around function pointer uses |
| 4191 | # ie: (foo->bar)(); should be foo->bar(); |
| 4192 | # but not "if (foo->bar) (" to avoid some false positives |
| 4193 | if ($line =~ /(\bif\s*|)(\(\s*$Ident\s*(?:$Member\s*)+\))[ \t]*\(/ && $1 !~ /^if/) { |
| 4194 | my $var = $2; |
| 4195 | if (CHK("UNNECESSARY_PARENTHESES", |
| 4196 | "Unnecessary parentheses around function pointer $var\n" . $herecurr) && |
| 4197 | $fix) { |
| 4198 | my $var2 = deparenthesize($var); |
| 4199 | $var2 =~ s/\s//g; |
| 4200 | $fixed[$fixlinenr] =~ s/\Q$var\E/$var2/; |
| 4201 | } |
| 4202 | } |
Joe Perches | e2826fd | 2014-08-06 16:10:48 -0700 | [diff] [blame] | 4203 | |
Andy Whitcroft | 0a920b5 | 2007-06-01 00:46:48 -0700 | [diff] [blame] | 4204 | #goto labels aren't indented, allow a single space however |
Andy Whitcroft | 4a0df2e | 2007-06-08 13:46:39 -0700 | [diff] [blame] | 4205 | if ($line=~/^.\s+[A-Za-z\d_]+:(?![0-9]+)/ and |
Andy Whitcroft | 0a920b5 | 2007-06-01 00:46:48 -0700 | [diff] [blame] | 4206 | !($line=~/^. [A-Za-z\d_]+:/) and !($line=~/^.\s+default:/)) { |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 4207 | if (WARN("INDENTED_LABEL", |
| 4208 | "labels should not be indented\n" . $herecurr) && |
| 4209 | $fix) { |
Joe Perches | 194f66f | 2014-08-06 16:11:03 -0700 | [diff] [blame] | 4210 | $fixed[$fixlinenr] =~ |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 4211 | s/^(.)\s+/$1/; |
| 4212 | } |
Andy Whitcroft | 0a920b5 | 2007-06-01 00:46:48 -0700 | [diff] [blame] | 4213 | } |
| 4214 | |
Joe Perches | 5b9553a | 2014-04-03 14:49:21 -0700 | [diff] [blame] | 4215 | # return is not a function |
Joe Perches | 507e514 | 2013-11-12 15:10:13 -0800 | [diff] [blame] | 4216 | if (defined($stat) && $stat =~ /^.\s*return(\s*)\(/s) { |
Andy Whitcroft | c45dcab | 2008-06-05 22:46:01 -0700 | [diff] [blame] | 4217 | my $spacing = $1; |
Joe Perches | 507e514 | 2013-11-12 15:10:13 -0800 | [diff] [blame] | 4218 | if ($^V && $^V ge 5.10.0 && |
Joe Perches | 5b9553a | 2014-04-03 14:49:21 -0700 | [diff] [blame] | 4219 | $stat =~ /^.\s*return\s*($balanced_parens)\s*;\s*$/) { |
| 4220 | my $value = $1; |
| 4221 | $value = deparenthesize($value); |
| 4222 | if ($value =~ m/^\s*$FuncArg\s*(?:\?|$)/) { |
| 4223 | ERROR("RETURN_PARENTHESES", |
| 4224 | "return is not a function, parentheses are not required\n" . $herecurr); |
| 4225 | } |
Andy Whitcroft | c45dcab | 2008-06-05 22:46:01 -0700 | [diff] [blame] | 4226 | } elsif ($spacing !~ /\s+/) { |
Joe Perches | 000d1cc1 | 2011-07-25 17:13:25 -0700 | [diff] [blame] | 4227 | ERROR("SPACING", |
| 4228 | "space required before the open parenthesis '('\n" . $herecurr); |
Andy Whitcroft | c45dcab | 2008-06-05 22:46:01 -0700 | [diff] [blame] | 4229 | } |
| 4230 | } |
Joe Perches | 507e514 | 2013-11-12 15:10:13 -0800 | [diff] [blame] | 4231 | |
Joe Perches | b43ae21 | 2014-06-23 13:22:07 -0700 | [diff] [blame] | 4232 | # unnecessary return in a void function |
| 4233 | # at end-of-function, with the previous line a single leading tab, then return; |
| 4234 | # and the line before that not a goto label target like "out:" |
| 4235 | if ($sline =~ /^[ \+]}\s*$/ && |
| 4236 | $prevline =~ /^\+\treturn\s*;\s*$/ && |
| 4237 | $linenr >= 3 && |
| 4238 | $lines[$linenr - 3] =~ /^[ +]/ && |
| 4239 | $lines[$linenr - 3] !~ /^[ +]\s*$Ident\s*:/) { |
Joe Perches | 9819cf2 | 2014-06-04 16:12:09 -0700 | [diff] [blame] | 4240 | WARN("RETURN_VOID", |
Joe Perches | b43ae21 | 2014-06-23 13:22:07 -0700 | [diff] [blame] | 4241 | "void function return statements are not generally useful\n" . $hereprev); |
| 4242 | } |
Joe Perches | 9819cf2 | 2014-06-04 16:12:09 -0700 | [diff] [blame] | 4243 | |
Joe Perches | 189248d | 2014-01-23 15:54:47 -0800 | [diff] [blame] | 4244 | # if statements using unnecessary parentheses - ie: if ((foo == bar)) |
| 4245 | if ($^V && $^V ge 5.10.0 && |
| 4246 | $line =~ /\bif\s*((?:\(\s*){2,})/) { |
| 4247 | my $openparens = $1; |
| 4248 | my $count = $openparens =~ tr@\(@\(@; |
| 4249 | my $msg = ""; |
| 4250 | if ($line =~ /\bif\s*(?:\(\s*){$count,$count}$LvalOrFunc\s*($Compare)\s*$LvalOrFunc(?:\s*\)){$count,$count}/) { |
| 4251 | my $comp = $4; #Not $1 because of $LvalOrFunc |
| 4252 | $msg = " - maybe == should be = ?" if ($comp eq "=="); |
| 4253 | WARN("UNNECESSARY_PARENTHESES", |
| 4254 | "Unnecessary parentheses$msg\n" . $herecurr); |
| 4255 | } |
| 4256 | } |
| 4257 | |
Joe Perches | c5595fa | 2015-09-09 15:37:58 -0700 | [diff] [blame] | 4258 | # comparisons with a constant or upper case identifier on the left |
| 4259 | # avoid cases like "foo + BAR < baz" |
| 4260 | # only fix matches surrounded by parentheses to avoid incorrect |
| 4261 | # conversions like "FOO < baz() + 5" being "misfixed" to "baz() > FOO + 5" |
| 4262 | if ($^V && $^V ge 5.10.0 && |
| 4263 | $line =~ /^\+(.*)\b($Constant|[A-Z_][A-Z0-9_]*)\s*($Compare)\s*($LvalOrFunc)/) { |
| 4264 | my $lead = $1; |
| 4265 | my $const = $2; |
| 4266 | my $comp = $3; |
| 4267 | my $to = $4; |
| 4268 | my $newcomp = $comp; |
| 4269 | if ($lead !~ /$Operators\s*$/ && |
| 4270 | $to !~ /^(?:Constant|[A-Z_][A-Z0-9_]*)$/ && |
| 4271 | WARN("CONSTANT_COMPARISON", |
| 4272 | "Comparisons should place the constant on the right side of the test\n" . $herecurr) && |
| 4273 | $fix) { |
| 4274 | if ($comp eq "<") { |
| 4275 | $newcomp = ">"; |
| 4276 | } elsif ($comp eq "<=") { |
| 4277 | $newcomp = ">="; |
| 4278 | } elsif ($comp eq ">") { |
| 4279 | $newcomp = "<"; |
| 4280 | } elsif ($comp eq ">=") { |
| 4281 | $newcomp = "<="; |
| 4282 | } |
| 4283 | $fixed[$fixlinenr] =~ s/\(\s*\Q$const\E\s*$Compare\s*\Q$to\E\s*\)/($to $newcomp $const)/; |
| 4284 | } |
| 4285 | } |
| 4286 | |
Joe Perches | f34e4a4 | 2015-04-16 12:44:19 -0700 | [diff] [blame] | 4287 | # Return of what appears to be an errno should normally be negative |
| 4288 | if ($sline =~ /\breturn(?:\s*\(+\s*|\s+)(E[A-Z]+)(?:\s*\)+\s*|\s*)[;:,]/) { |
Andy Whitcroft | 53a3c44 | 2010-10-26 14:23:14 -0700 | [diff] [blame] | 4289 | my $name = $1; |
| 4290 | if ($name ne 'EOF' && $name ne 'ERROR') { |
Joe Perches | 000d1cc1 | 2011-07-25 17:13:25 -0700 | [diff] [blame] | 4291 | WARN("USE_NEGATIVE_ERRNO", |
Joe Perches | f34e4a4 | 2015-04-16 12:44:19 -0700 | [diff] [blame] | 4292 | "return of an errno should typically be negative (ie: return -$1)\n" . $herecurr); |
Andy Whitcroft | 53a3c44 | 2010-10-26 14:23:14 -0700 | [diff] [blame] | 4293 | } |
| 4294 | } |
Andy Whitcroft | c45dcab | 2008-06-05 22:46:01 -0700 | [diff] [blame] | 4295 | |
Andy Whitcroft | 0a920b5 | 2007-06-01 00:46:48 -0700 | [diff] [blame] | 4296 | # Need a space before open parenthesis after if, while etc |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 4297 | if ($line =~ /\b(if|while|for|switch)\(/) { |
| 4298 | if (ERROR("SPACING", |
| 4299 | "space required before the open parenthesis '('\n" . $herecurr) && |
| 4300 | $fix) { |
Joe Perches | 194f66f | 2014-08-06 16:11:03 -0700 | [diff] [blame] | 4301 | $fixed[$fixlinenr] =~ |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 4302 | s/\b(if|while|for|switch)\(/$1 \(/; |
| 4303 | } |
Andy Whitcroft | 0a920b5 | 2007-06-01 00:46:48 -0700 | [diff] [blame] | 4304 | } |
| 4305 | |
Andy Whitcroft | f5fe35d | 2008-07-23 21:29:03 -0700 | [diff] [blame] | 4306 | # Check for illegal assignment in if conditional -- and check for trailing |
| 4307 | # statements after the conditional. |
Andy Whitcroft | 170d3a2 | 2008-10-15 22:02:30 -0700 | [diff] [blame] | 4308 | if ($line =~ /do\s*(?!{)/) { |
Andy Whitcroft | 3e469cd | 2012-01-10 15:10:01 -0800 | [diff] [blame] | 4309 | ($stat, $cond, $line_nr_next, $remain_next, $off_next) = |
| 4310 | ctx_statement_block($linenr, $realcnt, 0) |
| 4311 | if (!defined $stat); |
Andy Whitcroft | 170d3a2 | 2008-10-15 22:02:30 -0700 | [diff] [blame] | 4312 | my ($stat_next) = ctx_statement_block($line_nr_next, |
| 4313 | $remain_next, $off_next); |
| 4314 | $stat_next =~ s/\n./\n /g; |
| 4315 | ##print "stat<$stat> stat_next<$stat_next>\n"; |
| 4316 | |
| 4317 | if ($stat_next =~ /^\s*while\b/) { |
| 4318 | # If the statement carries leading newlines, |
| 4319 | # then count those as offsets. |
| 4320 | my ($whitespace) = |
| 4321 | ($stat_next =~ /^((?:\s*\n[+-])*\s*)/s); |
| 4322 | my $offset = |
| 4323 | statement_rawlines($whitespace) - 1; |
| 4324 | |
| 4325 | $suppress_whiletrailers{$line_nr_next + |
| 4326 | $offset} = 1; |
| 4327 | } |
| 4328 | } |
| 4329 | if (!defined $suppress_whiletrailers{$linenr} && |
Joe Perches | c11230f | 2013-11-21 14:31:57 -0800 | [diff] [blame] | 4330 | defined($stat) && defined($cond) && |
Andy Whitcroft | 170d3a2 | 2008-10-15 22:02:30 -0700 | [diff] [blame] | 4331 | $line =~ /\b(?:if|while|for)\s*\(/ && $line !~ /^.\s*#/) { |
Andy Whitcroft | 171ae1a | 2008-04-29 00:59:32 -0700 | [diff] [blame] | 4332 | my ($s, $c) = ($stat, $cond); |
Andy Whitcroft | 8905a67 | 2007-11-28 16:21:06 -0800 | [diff] [blame] | 4333 | |
Andy Whitcroft | b53c8e1 | 2009-01-06 14:41:29 -0800 | [diff] [blame] | 4334 | if ($c =~ /\bif\s*\(.*[^<>!=]=[^=].*/s) { |
Joe Perches | 000d1cc1 | 2011-07-25 17:13:25 -0700 | [diff] [blame] | 4335 | ERROR("ASSIGN_IN_IF", |
| 4336 | "do not use assignment in if condition\n" . $herecurr); |
Andy Whitcroft | 8905a67 | 2007-11-28 16:21:06 -0800 | [diff] [blame] | 4337 | } |
| 4338 | |
| 4339 | # Find out what is on the end of the line after the |
| 4340 | # conditional. |
Andy Whitcroft | 773647a | 2008-03-28 14:15:58 -0700 | [diff] [blame] | 4341 | substr($s, 0, length($c), ''); |
Andy Whitcroft | 8905a67 | 2007-11-28 16:21:06 -0800 | [diff] [blame] | 4342 | $s =~ s/\n.*//g; |
Andy Whitcroft | 13214ad | 2008-02-08 04:22:03 -0800 | [diff] [blame] | 4343 | $s =~ s/$;//g; # Remove any comments |
Andy Whitcroft | 5321016 | 2008-07-23 21:29:03 -0700 | [diff] [blame] | 4344 | if (length($c) && $s !~ /^\s*{?\s*\\*\s*$/ && |
| 4345 | $c !~ /}\s*while\s*/) |
Andy Whitcroft | 773647a | 2008-03-28 14:15:58 -0700 | [diff] [blame] | 4346 | { |
Andy Whitcroft | bb44ad3 | 2008-10-15 22:02:34 -0700 | [diff] [blame] | 4347 | # Find out how long the conditional actually is. |
| 4348 | my @newlines = ($c =~ /\n/gs); |
| 4349 | my $cond_lines = 1 + $#newlines; |
Hidetoshi Seto | 42bdf74 | 2010-03-05 13:43:50 -0800 | [diff] [blame] | 4350 | my $stat_real = ''; |
Andy Whitcroft | bb44ad3 | 2008-10-15 22:02:34 -0700 | [diff] [blame] | 4351 | |
Hidetoshi Seto | 42bdf74 | 2010-03-05 13:43:50 -0800 | [diff] [blame] | 4352 | $stat_real = raw_line($linenr, $cond_lines) |
| 4353 | . "\n" if ($cond_lines); |
Andy Whitcroft | bb44ad3 | 2008-10-15 22:02:34 -0700 | [diff] [blame] | 4354 | if (defined($stat_real) && $cond_lines > 1) { |
| 4355 | $stat_real = "[...]\n$stat_real"; |
| 4356 | } |
| 4357 | |
Joe Perches | 000d1cc1 | 2011-07-25 17:13:25 -0700 | [diff] [blame] | 4358 | ERROR("TRAILING_STATEMENTS", |
| 4359 | "trailing statements should be on next line\n" . $herecurr . $stat_real); |
Andy Whitcroft | 8905a67 | 2007-11-28 16:21:06 -0800 | [diff] [blame] | 4360 | } |
| 4361 | } |
| 4362 | |
Andy Whitcroft | 13214ad | 2008-02-08 04:22:03 -0800 | [diff] [blame] | 4363 | # Check for bitwise tests written as boolean |
| 4364 | if ($line =~ / |
| 4365 | (?: |
| 4366 | (?:\[|\(|\&\&|\|\|) |
| 4367 | \s*0[xX][0-9]+\s* |
| 4368 | (?:\&\&|\|\|) |
| 4369 | | |
| 4370 | (?:\&\&|\|\|) |
| 4371 | \s*0[xX][0-9]+\s* |
| 4372 | (?:\&\&|\|\||\)|\]) |
| 4373 | )/x) |
| 4374 | { |
Joe Perches | 000d1cc1 | 2011-07-25 17:13:25 -0700 | [diff] [blame] | 4375 | WARN("HEXADECIMAL_BOOLEAN_TEST", |
| 4376 | "boolean test with hexadecimal, perhaps just 1 \& or \|?\n" . $herecurr); |
Andy Whitcroft | 13214ad | 2008-02-08 04:22:03 -0800 | [diff] [blame] | 4377 | } |
| 4378 | |
Andy Whitcroft | 8905a67 | 2007-11-28 16:21:06 -0800 | [diff] [blame] | 4379 | # if and else should not have general statements after it |
Andy Whitcroft | 13214ad | 2008-02-08 04:22:03 -0800 | [diff] [blame] | 4380 | if ($line =~ /^.\s*(?:}\s*)?else\b(.*)/) { |
| 4381 | my $s = $1; |
| 4382 | $s =~ s/$;//g; # Remove any comments |
| 4383 | if ($s !~ /^\s*(?:\sif|(?:{|)\s*\\?\s*$)/) { |
Joe Perches | 000d1cc1 | 2011-07-25 17:13:25 -0700 | [diff] [blame] | 4384 | ERROR("TRAILING_STATEMENTS", |
| 4385 | "trailing statements should be on next line\n" . $herecurr); |
Andy Whitcroft | 13214ad | 2008-02-08 04:22:03 -0800 | [diff] [blame] | 4386 | } |
Andy Whitcroft | 0a920b5 | 2007-06-01 00:46:48 -0700 | [diff] [blame] | 4387 | } |
Andy Whitcroft | 3966778 | 2009-01-15 13:51:06 -0800 | [diff] [blame] | 4388 | # if should not continue a brace |
| 4389 | if ($line =~ /}\s*if\b/) { |
Joe Perches | 000d1cc1 | 2011-07-25 17:13:25 -0700 | [diff] [blame] | 4390 | ERROR("TRAILING_STATEMENTS", |
Rasmus Villemoes | 048b123 | 2014-08-06 16:10:37 -0700 | [diff] [blame] | 4391 | "trailing statements should be on next line (or did you mean 'else if'?)\n" . |
Andy Whitcroft | 3966778 | 2009-01-15 13:51:06 -0800 | [diff] [blame] | 4392 | $herecurr); |
| 4393 | } |
Andy Whitcroft | a1080bf | 2008-10-15 22:02:25 -0700 | [diff] [blame] | 4394 | # case and default should not have general statements after them |
| 4395 | if ($line =~ /^.\s*(?:case\s*.*|default\s*):/g && |
| 4396 | $line !~ /\G(?: |
Andy Whitcroft | 3fef12d | 2008-10-15 22:02:36 -0700 | [diff] [blame] | 4397 | (?:\s*$;*)(?:\s*{)?(?:\s*$;*)(?:\s*\\)?\s*$| |
Andy Whitcroft | a1080bf | 2008-10-15 22:02:25 -0700 | [diff] [blame] | 4398 | \s*return\s+ |
| 4399 | )/xg) |
| 4400 | { |
Joe Perches | 000d1cc1 | 2011-07-25 17:13:25 -0700 | [diff] [blame] | 4401 | ERROR("TRAILING_STATEMENTS", |
| 4402 | "trailing statements should be on next line\n" . $herecurr); |
Andy Whitcroft | a1080bf | 2008-10-15 22:02:25 -0700 | [diff] [blame] | 4403 | } |
Andy Whitcroft | 0a920b5 | 2007-06-01 00:46:48 -0700 | [diff] [blame] | 4404 | |
| 4405 | # Check for }<nl>else {, these must be at the same |
| 4406 | # indent level to be relevant to each other. |
Joe Perches | 8b8856f | 2014-08-06 16:11:14 -0700 | [diff] [blame] | 4407 | if ($prevline=~/}\s*$/ and $line=~/^.\s*else\s*/ && |
| 4408 | $previndent == $indent) { |
| 4409 | if (ERROR("ELSE_AFTER_BRACE", |
| 4410 | "else should follow close brace '}'\n" . $hereprev) && |
| 4411 | $fix && $prevline =~ /^\+/ && $line =~ /^\+/) { |
| 4412 | fix_delete_line($fixlinenr - 1, $prevrawline); |
| 4413 | fix_delete_line($fixlinenr, $rawline); |
| 4414 | my $fixedline = $prevrawline; |
| 4415 | $fixedline =~ s/}\s*$//; |
| 4416 | if ($fixedline !~ /^\+\s*$/) { |
| 4417 | fix_insert_line($fixlinenr, $fixedline); |
| 4418 | } |
| 4419 | $fixedline = $rawline; |
| 4420 | $fixedline =~ s/^(.\s*)else/$1} else/; |
| 4421 | fix_insert_line($fixlinenr, $fixedline); |
| 4422 | } |
Andy Whitcroft | 0a920b5 | 2007-06-01 00:46:48 -0700 | [diff] [blame] | 4423 | } |
| 4424 | |
Joe Perches | 8b8856f | 2014-08-06 16:11:14 -0700 | [diff] [blame] | 4425 | if ($prevline=~/}\s*$/ and $line=~/^.\s*while\s*/ && |
| 4426 | $previndent == $indent) { |
Andy Whitcroft | c2fdda0 | 2008-02-08 04:20:54 -0800 | [diff] [blame] | 4427 | my ($s, $c) = ctx_statement_block($linenr, $realcnt, 0); |
| 4428 | |
| 4429 | # Find out what is on the end of the line after the |
| 4430 | # conditional. |
Andy Whitcroft | 773647a | 2008-03-28 14:15:58 -0700 | [diff] [blame] | 4431 | substr($s, 0, length($c), ''); |
Andy Whitcroft | c2fdda0 | 2008-02-08 04:20:54 -0800 | [diff] [blame] | 4432 | $s =~ s/\n.*//g; |
| 4433 | |
| 4434 | if ($s =~ /^\s*;/) { |
Joe Perches | 8b8856f | 2014-08-06 16:11:14 -0700 | [diff] [blame] | 4435 | if (ERROR("WHILE_AFTER_BRACE", |
| 4436 | "while should follow close brace '}'\n" . $hereprev) && |
| 4437 | $fix && $prevline =~ /^\+/ && $line =~ /^\+/) { |
| 4438 | fix_delete_line($fixlinenr - 1, $prevrawline); |
| 4439 | fix_delete_line($fixlinenr, $rawline); |
| 4440 | my $fixedline = $prevrawline; |
| 4441 | my $trailing = $rawline; |
| 4442 | $trailing =~ s/^\+//; |
| 4443 | $trailing = trim($trailing); |
| 4444 | $fixedline =~ s/}\s*$/} $trailing/; |
| 4445 | fix_insert_line($fixlinenr, $fixedline); |
| 4446 | } |
Andy Whitcroft | c2fdda0 | 2008-02-08 04:20:54 -0800 | [diff] [blame] | 4447 | } |
| 4448 | } |
| 4449 | |
Joe Perches | 95e2c60 | 2013-07-03 15:05:20 -0700 | [diff] [blame] | 4450 | #Specific variable tests |
Joe Perches | 323c126 | 2012-12-17 16:02:07 -0800 | [diff] [blame] | 4451 | while ($line =~ m{($Constant|$Lval)}g) { |
| 4452 | my $var = $1; |
Joe Perches | 95e2c60 | 2013-07-03 15:05:20 -0700 | [diff] [blame] | 4453 | |
| 4454 | #gcc binary extension |
| 4455 | if ($var =~ /^$Binary$/) { |
Joe Perches | d5e616f | 2013-09-11 14:23:54 -0700 | [diff] [blame] | 4456 | if (WARN("GCC_BINARY_CONSTANT", |
| 4457 | "Avoid gcc v4.3+ binary constant extension: <$var>\n" . $herecurr) && |
| 4458 | $fix) { |
| 4459 | my $hexval = sprintf("0x%x", oct($var)); |
Joe Perches | 194f66f | 2014-08-06 16:11:03 -0700 | [diff] [blame] | 4460 | $fixed[$fixlinenr] =~ |
Joe Perches | d5e616f | 2013-09-11 14:23:54 -0700 | [diff] [blame] | 4461 | s/\b$var\b/$hexval/; |
| 4462 | } |
Joe Perches | 95e2c60 | 2013-07-03 15:05:20 -0700 | [diff] [blame] | 4463 | } |
| 4464 | |
| 4465 | #CamelCase |
Joe Perches | 807bd26 | 2013-07-03 15:05:22 -0700 | [diff] [blame] | 4466 | if ($var !~ /^$Constant$/ && |
Joe Perches | be79794 | 2013-07-03 15:05:20 -0700 | [diff] [blame] | 4467 | $var =~ /[A-Z][a-z]|[a-z][A-Z]/ && |
Joe Perches | 22735ce | 2013-07-03 15:05:33 -0700 | [diff] [blame] | 4468 | #Ignore Page<foo> variants |
Joe Perches | 807bd26 | 2013-07-03 15:05:22 -0700 | [diff] [blame] | 4469 | $var !~ /^(?:Clear|Set|TestClear|TestSet|)Page[A-Z]/ && |
Joe Perches | 22735ce | 2013-07-03 15:05:33 -0700 | [diff] [blame] | 4470 | #Ignore SI style variants like nS, mV and dB (ie: max_uV, regulator_min_uA_show) |
Julius Werner | f512357 | 2014-12-10 15:51:54 -0800 | [diff] [blame] | 4471 | $var !~ /^(?:[a-z_]*?)_?[a-z][A-Z](?:_[a-z_]+)?$/ && |
| 4472 | #Ignore some three character SI units explicitly, like MiB and KHz |
| 4473 | $var !~ /^(?:[a-z_]*?)_?(?:[KMGT]iB|[KMGT]?Hz)(?:_[a-z_]+)?$/) { |
Joe Perches | 7e781f6 | 2013-09-11 14:23:55 -0700 | [diff] [blame] | 4474 | while ($var =~ m{($Ident)}g) { |
| 4475 | my $word = $1; |
| 4476 | next if ($word !~ /[A-Z][a-z]|[a-z][A-Z]/); |
Joe Perches | d8b0771 | 2013-11-12 15:10:06 -0800 | [diff] [blame] | 4477 | if ($check) { |
| 4478 | seed_camelcase_includes(); |
| 4479 | if (!$file && !$camelcase_file_seeded) { |
| 4480 | seed_camelcase_file($realfile); |
| 4481 | $camelcase_file_seeded = 1; |
| 4482 | } |
| 4483 | } |
Joe Perches | 7e781f6 | 2013-09-11 14:23:55 -0700 | [diff] [blame] | 4484 | if (!defined $camelcase{$word}) { |
| 4485 | $camelcase{$word} = 1; |
| 4486 | CHK("CAMELCASE", |
| 4487 | "Avoid CamelCase: <$word>\n" . $herecurr); |
| 4488 | } |
Joe Perches | 3445686 | 2013-07-03 15:05:34 -0700 | [diff] [blame] | 4489 | } |
Joe Perches | 323c126 | 2012-12-17 16:02:07 -0800 | [diff] [blame] | 4490 | } |
| 4491 | } |
Andy Whitcroft | 0a920b5 | 2007-06-01 00:46:48 -0700 | [diff] [blame] | 4492 | |
| 4493 | #no spaces allowed after \ in define |
Joe Perches | d5e616f | 2013-09-11 14:23:54 -0700 | [diff] [blame] | 4494 | if ($line =~ /\#\s*define.*\\\s+$/) { |
| 4495 | if (WARN("WHITESPACE_AFTER_LINE_CONTINUATION", |
| 4496 | "Whitespace after \\ makes next lines useless\n" . $herecurr) && |
| 4497 | $fix) { |
Joe Perches | 194f66f | 2014-08-06 16:11:03 -0700 | [diff] [blame] | 4498 | $fixed[$fixlinenr] =~ s/\s+$//; |
Joe Perches | d5e616f | 2013-09-11 14:23:54 -0700 | [diff] [blame] | 4499 | } |
Andy Whitcroft | 0a920b5 | 2007-06-01 00:46:48 -0700 | [diff] [blame] | 4500 | } |
| 4501 | |
Fabian Frederick | 0e212e0 | 2015-04-16 12:44:25 -0700 | [diff] [blame] | 4502 | # warn if <asm/foo.h> is #included and <linux/foo.h> is available and includes |
| 4503 | # itself <asm/foo.h> (uses RAW line) |
Andy Whitcroft | c45dcab | 2008-06-05 22:46:01 -0700 | [diff] [blame] | 4504 | if ($tree && $rawline =~ m{^.\s*\#\s*include\s*\<asm\/(.*)\.h\>}) { |
Andy Whitcroft | e09dec4 | 2008-10-15 22:02:20 -0700 | [diff] [blame] | 4505 | my $file = "$1.h"; |
| 4506 | my $checkfile = "include/linux/$file"; |
| 4507 | if (-f "$root/$checkfile" && |
| 4508 | $realfile ne $checkfile && |
Wolfram Sang | 7840a94 | 2010-08-09 17:20:57 -0700 | [diff] [blame] | 4509 | $1 !~ /$allowed_asm_includes/) |
Andy Whitcroft | c45dcab | 2008-06-05 22:46:01 -0700 | [diff] [blame] | 4510 | { |
Fabian Frederick | 0e212e0 | 2015-04-16 12:44:25 -0700 | [diff] [blame] | 4511 | my $asminclude = `grep -Ec "#include\\s+<asm/$file>" $root/$checkfile`; |
| 4512 | if ($asminclude > 0) { |
| 4513 | if ($realfile =~ m{^arch/}) { |
| 4514 | CHK("ARCH_INCLUDE_LINUX", |
| 4515 | "Consider using #include <linux/$file> instead of <asm/$file>\n" . $herecurr); |
| 4516 | } else { |
| 4517 | WARN("INCLUDE_LINUX", |
| 4518 | "Use #include <linux/$file> instead of <asm/$file>\n" . $herecurr); |
| 4519 | } |
Andy Whitcroft | e09dec4 | 2008-10-15 22:02:20 -0700 | [diff] [blame] | 4520 | } |
Andy Whitcroft | 0a920b5 | 2007-06-01 00:46:48 -0700 | [diff] [blame] | 4521 | } |
| 4522 | } |
| 4523 | |
Andy Whitcroft | 653d487 | 2007-06-23 17:16:34 -0700 | [diff] [blame] | 4524 | # multi-statement macros should be enclosed in a do while loop, grab the |
| 4525 | # first statement and ensure its the whole macro if its not enclosed |
Andy Whitcroft | cf65504 | 2008-03-04 14:28:20 -0800 | [diff] [blame] | 4526 | # in a known good container |
Andy Whitcroft | b8f96a3 | 2008-07-23 21:29:07 -0700 | [diff] [blame] | 4527 | if ($realfile !~ m@/vmlinux.lds.h$@ && |
| 4528 | $line =~ /^.\s*\#\s*define\s*$Ident(\()?/) { |
Andy Whitcroft | d8aaf12 | 2007-06-23 17:16:44 -0700 | [diff] [blame] | 4529 | my $ln = $linenr; |
| 4530 | my $cnt = $realcnt; |
Andy Whitcroft | c45dcab | 2008-06-05 22:46:01 -0700 | [diff] [blame] | 4531 | my ($off, $dstat, $dcond, $rest); |
| 4532 | my $ctx = ''; |
Joe Perches | 08a2843 | 2014-10-13 15:51:55 -0700 | [diff] [blame] | 4533 | my $has_flow_statement = 0; |
| 4534 | my $has_arg_concat = 0; |
Andy Whitcroft | c45dcab | 2008-06-05 22:46:01 -0700 | [diff] [blame] | 4535 | ($dstat, $dcond, $ln, $cnt, $off) = |
Andy Whitcroft | f74bd19 | 2012-01-10 15:09:54 -0800 | [diff] [blame] | 4536 | ctx_statement_block($linenr, $realcnt, 0); |
| 4537 | $ctx = $dstat; |
Andy Whitcroft | c45dcab | 2008-06-05 22:46:01 -0700 | [diff] [blame] | 4538 | #print "dstat<$dstat> dcond<$dcond> cnt<$cnt> off<$off>\n"; |
Andy Whitcroft | a3bb97a | 2008-07-23 21:29:00 -0700 | [diff] [blame] | 4539 | #print "LINE<$lines[$ln-1]> len<" . length($lines[$ln-1]) . "\n"; |
Andy Whitcroft | c45dcab | 2008-06-05 22:46:01 -0700 | [diff] [blame] | 4540 | |
Joe Perches | 08a2843 | 2014-10-13 15:51:55 -0700 | [diff] [blame] | 4541 | $has_flow_statement = 1 if ($ctx =~ /\b(goto|return)\b/); |
Joe Perches | 62e15a6 | 2016-01-20 14:59:18 -0800 | [diff] [blame] | 4542 | $has_arg_concat = 1 if ($ctx =~ /\#\#/ && $ctx !~ /\#\#\s*(?:__VA_ARGS__|args)\b/); |
Joe Perches | 08a2843 | 2014-10-13 15:51:55 -0700 | [diff] [blame] | 4543 | |
Andy Whitcroft | f74bd19 | 2012-01-10 15:09:54 -0800 | [diff] [blame] | 4544 | $dstat =~ s/^.\s*\#\s*define\s+$Ident(?:\([^\)]*\))?\s*//; |
Andy Whitcroft | 292f1a9 | 2008-07-23 21:29:11 -0700 | [diff] [blame] | 4545 | $dstat =~ s/$;//g; |
Andy Whitcroft | c45dcab | 2008-06-05 22:46:01 -0700 | [diff] [blame] | 4546 | $dstat =~ s/\\\n.//g; |
| 4547 | $dstat =~ s/^\s*//s; |
| 4548 | $dstat =~ s/\s*$//s; |
| 4549 | |
| 4550 | # Flatten any parentheses and braces |
Andy Whitcroft | bf30d6e | 2008-10-15 22:02:33 -0700 | [diff] [blame] | 4551 | while ($dstat =~ s/\([^\(\)]*\)/1/ || |
| 4552 | $dstat =~ s/\{[^\{\}]*\}/1/ || |
Vladimir Zapolskiy | 6b10df4 | 2016-01-20 14:59:21 -0800 | [diff] [blame] | 4553 | $dstat =~ s/.\[[^\[\]]*\]/1/) |
Andy Whitcroft | bf30d6e | 2008-10-15 22:02:33 -0700 | [diff] [blame] | 4554 | { |
Andy Whitcroft | de7d4f0 | 2007-07-15 23:37:22 -0700 | [diff] [blame] | 4555 | } |
Andy Whitcroft | d8aaf12 | 2007-06-23 17:16:44 -0700 | [diff] [blame] | 4556 | |
Andy Whitcroft | e45bab8 | 2012-03-23 15:02:18 -0700 | [diff] [blame] | 4557 | # Flatten any obvious string concatentation. |
Joe Perches | 33acb54 | 2015-06-25 15:02:54 -0700 | [diff] [blame] | 4558 | while ($dstat =~ s/($String)\s*$Ident/$1/ || |
| 4559 | $dstat =~ s/$Ident\s*($String)/$1/) |
Andy Whitcroft | e45bab8 | 2012-03-23 15:02:18 -0700 | [diff] [blame] | 4560 | { |
| 4561 | } |
| 4562 | |
Andy Whitcroft | c45dcab | 2008-06-05 22:46:01 -0700 | [diff] [blame] | 4563 | my $exceptions = qr{ |
| 4564 | $Declare| |
| 4565 | module_param_named| |
Kees Cook | a0a0a7a | 2012-10-04 17:13:38 -0700 | [diff] [blame] | 4566 | MODULE_PARM_DESC| |
Andy Whitcroft | c45dcab | 2008-06-05 22:46:01 -0700 | [diff] [blame] | 4567 | DECLARE_PER_CPU| |
| 4568 | DEFINE_PER_CPU| |
Andy Whitcroft | 383099f | 2009-01-06 14:41:18 -0800 | [diff] [blame] | 4569 | __typeof__\(| |
Stefani Seibold | 22fd2d3 | 2010-03-05 13:43:52 -0800 | [diff] [blame] | 4570 | union| |
| 4571 | struct| |
Andy Whitcroft | ea71a0a | 2009-09-21 17:04:38 -0700 | [diff] [blame] | 4572 | \.$Ident\s*=\s*| |
Vladimir Zapolskiy | 6b10df4 | 2016-01-20 14:59:21 -0800 | [diff] [blame] | 4573 | ^\"|\"$| |
| 4574 | ^\[ |
Andy Whitcroft | c45dcab | 2008-06-05 22:46:01 -0700 | [diff] [blame] | 4575 | }x; |
Andy Whitcroft | 5eaa20b | 2010-10-26 14:23:18 -0700 | [diff] [blame] | 4576 | #print "REST<$rest> dstat<$dstat> ctx<$ctx>\n"; |
Andy Whitcroft | f74bd19 | 2012-01-10 15:09:54 -0800 | [diff] [blame] | 4577 | if ($dstat ne '' && |
| 4578 | $dstat !~ /^(?:$Ident|-?$Constant),$/ && # 10, // foo(), |
| 4579 | $dstat !~ /^(?:$Ident|-?$Constant);$/ && # foo(); |
Joe Perches | 3cc4b1c | 2013-07-03 15:05:27 -0700 | [diff] [blame] | 4580 | $dstat !~ /^[!~-]?(?:$Lval|$Constant)$/ && # 10 // foo() // !foo // ~foo // -foo // foo->bar // foo.bar->baz |
Joe Perches | 356fd39 | 2014-08-06 16:10:31 -0700 | [diff] [blame] | 4581 | $dstat !~ /^'X'$/ && $dstat !~ /^'XX'$/ && # character constants |
Andy Whitcroft | f74bd19 | 2012-01-10 15:09:54 -0800 | [diff] [blame] | 4582 | $dstat !~ /$exceptions/ && |
| 4583 | $dstat !~ /^\.$Ident\s*=/ && # .foo = |
Joe Perches | e942e2c | 2013-04-17 15:58:26 -0700 | [diff] [blame] | 4584 | $dstat !~ /^(?:\#\s*$Ident|\#\s*$Constant)\s*$/ && # stringification #foo |
Andy Whitcroft | 72f115f | 2012-01-10 15:10:06 -0800 | [diff] [blame] | 4585 | $dstat !~ /^do\s*$Constant\s*while\s*$Constant;?$/ && # do {...} while (...); // do {...} while (...) |
Andy Whitcroft | f74bd19 | 2012-01-10 15:09:54 -0800 | [diff] [blame] | 4586 | $dstat !~ /^for\s*$Constant$/ && # for (...) |
| 4587 | $dstat !~ /^for\s*$Constant\s+(?:$Ident|-?$Constant)$/ && # for (...) bar() |
| 4588 | $dstat !~ /^do\s*{/ && # do {... |
Eddie Kovsky | 4e5d56b | 2015-09-09 15:37:52 -0700 | [diff] [blame] | 4589 | $dstat !~ /^\(\{/ && # ({... |
Joe Perches | f95a7e6 | 2013-09-11 14:24:00 -0700 | [diff] [blame] | 4590 | $ctx !~ /^.\s*#\s*define\s+TRACE_(?:SYSTEM|INCLUDE_FILE|INCLUDE_PATH)\b/) |
Andy Whitcroft | f74bd19 | 2012-01-10 15:09:54 -0800 | [diff] [blame] | 4591 | { |
| 4592 | $ctx =~ s/\n*$//; |
| 4593 | my $herectx = $here . "\n"; |
| 4594 | my $cnt = statement_rawlines($ctx); |
| 4595 | |
| 4596 | for (my $n = 0; $n < $cnt; $n++) { |
| 4597 | $herectx .= raw_line($linenr, $n) . "\n"; |
Andy Whitcroft | c45dcab | 2008-06-05 22:46:01 -0700 | [diff] [blame] | 4598 | } |
| 4599 | |
Andy Whitcroft | f74bd19 | 2012-01-10 15:09:54 -0800 | [diff] [blame] | 4600 | if ($dstat =~ /;/) { |
| 4601 | ERROR("MULTISTATEMENT_MACRO_USE_DO_WHILE", |
| 4602 | "Macros with multiple statements should be enclosed in a do - while loop\n" . "$herectx"); |
| 4603 | } else { |
Joe Perches | 000d1cc1 | 2011-07-25 17:13:25 -0700 | [diff] [blame] | 4604 | ERROR("COMPLEX_MACRO", |
Andrew Morton | 388982b | 2014-10-13 15:51:40 -0700 | [diff] [blame] | 4605 | "Macros with complex values should be enclosed in parentheses\n" . "$herectx"); |
Andy Whitcroft | d8aaf12 | 2007-06-23 17:16:44 -0700 | [diff] [blame] | 4606 | } |
Andy Whitcroft | 653d487 | 2007-06-23 17:16:34 -0700 | [diff] [blame] | 4607 | } |
Joe Perches | 5023d34 | 2012-12-17 16:01:47 -0800 | [diff] [blame] | 4608 | |
Joe Perches | 08a2843 | 2014-10-13 15:51:55 -0700 | [diff] [blame] | 4609 | # check for macros with flow control, but without ## concatenation |
| 4610 | # ## concatenation is commonly a macro that defines a function so ignore those |
| 4611 | if ($has_flow_statement && !$has_arg_concat) { |
| 4612 | my $herectx = $here . "\n"; |
| 4613 | my $cnt = statement_rawlines($ctx); |
| 4614 | |
| 4615 | for (my $n = 0; $n < $cnt; $n++) { |
| 4616 | $herectx .= raw_line($linenr, $n) . "\n"; |
| 4617 | } |
| 4618 | WARN("MACRO_WITH_FLOW_CONTROL", |
| 4619 | "Macros with flow control statements should be avoided\n" . "$herectx"); |
| 4620 | } |
| 4621 | |
Joe Perches | 481eb48 | 2012-12-17 16:01:56 -0800 | [diff] [blame] | 4622 | # check for line continuations outside of #defines, preprocessor #, and asm |
Joe Perches | 5023d34 | 2012-12-17 16:01:47 -0800 | [diff] [blame] | 4623 | |
| 4624 | } else { |
| 4625 | if ($prevline !~ /^..*\\$/ && |
Joe Perches | 481eb48 | 2012-12-17 16:01:56 -0800 | [diff] [blame] | 4626 | $line !~ /^\+\s*\#.*\\$/ && # preprocessor |
| 4627 | $line !~ /^\+.*\b(__asm__|asm)\b.*\\$/ && # asm |
Joe Perches | 5023d34 | 2012-12-17 16:01:47 -0800 | [diff] [blame] | 4628 | $line =~ /^\+.*\\$/) { |
| 4629 | WARN("LINE_CONTINUATIONS", |
| 4630 | "Avoid unnecessary line continuations\n" . $herecurr); |
| 4631 | } |
Andy Whitcroft | 0a920b5 | 2007-06-01 00:46:48 -0700 | [diff] [blame] | 4632 | } |
| 4633 | |
Joe Perches | b13edf7 | 2012-07-30 14:41:24 -0700 | [diff] [blame] | 4634 | # do {} while (0) macro tests: |
| 4635 | # single-statement macros do not need to be enclosed in do while (0) loop, |
| 4636 | # macro should not end with a semicolon |
| 4637 | if ($^V && $^V ge 5.10.0 && |
| 4638 | $realfile !~ m@/vmlinux.lds.h$@ && |
| 4639 | $line =~ /^.\s*\#\s*define\s+$Ident(\()?/) { |
| 4640 | my $ln = $linenr; |
| 4641 | my $cnt = $realcnt; |
| 4642 | my ($off, $dstat, $dcond, $rest); |
| 4643 | my $ctx = ''; |
| 4644 | ($dstat, $dcond, $ln, $cnt, $off) = |
| 4645 | ctx_statement_block($linenr, $realcnt, 0); |
| 4646 | $ctx = $dstat; |
| 4647 | |
| 4648 | $dstat =~ s/\\\n.//g; |
Joe Perches | 1b36b20 | 2015-02-13 14:38:32 -0800 | [diff] [blame] | 4649 | $dstat =~ s/$;/ /g; |
Joe Perches | b13edf7 | 2012-07-30 14:41:24 -0700 | [diff] [blame] | 4650 | |
| 4651 | if ($dstat =~ /^\+\s*#\s*define\s+$Ident\s*${balanced_parens}\s*do\s*{(.*)\s*}\s*while\s*\(\s*0\s*\)\s*([;\s]*)\s*$/) { |
| 4652 | my $stmts = $2; |
| 4653 | my $semis = $3; |
| 4654 | |
| 4655 | $ctx =~ s/\n*$//; |
| 4656 | my $cnt = statement_rawlines($ctx); |
| 4657 | my $herectx = $here . "\n"; |
| 4658 | |
| 4659 | for (my $n = 0; $n < $cnt; $n++) { |
| 4660 | $herectx .= raw_line($linenr, $n) . "\n"; |
| 4661 | } |
| 4662 | |
Joe Perches | ac8e97f | 2012-08-21 16:15:53 -0700 | [diff] [blame] | 4663 | if (($stmts =~ tr/;/;/) == 1 && |
| 4664 | $stmts !~ /^\s*(if|while|for|switch)\b/) { |
Joe Perches | b13edf7 | 2012-07-30 14:41:24 -0700 | [diff] [blame] | 4665 | WARN("SINGLE_STATEMENT_DO_WHILE_MACRO", |
| 4666 | "Single statement macros should not use a do {} while (0) loop\n" . "$herectx"); |
| 4667 | } |
| 4668 | if (defined $semis && $semis ne "") { |
| 4669 | WARN("DO_WHILE_MACRO_WITH_TRAILING_SEMICOLON", |
| 4670 | "do {} while (0) macros should not be semicolon terminated\n" . "$herectx"); |
| 4671 | } |
Joe Perches | f5ef95b | 2014-06-04 16:12:06 -0700 | [diff] [blame] | 4672 | } elsif ($dstat =~ /^\+\s*#\s*define\s+$Ident.*;\s*$/) { |
| 4673 | $ctx =~ s/\n*$//; |
| 4674 | my $cnt = statement_rawlines($ctx); |
| 4675 | my $herectx = $here . "\n"; |
| 4676 | |
| 4677 | for (my $n = 0; $n < $cnt; $n++) { |
| 4678 | $herectx .= raw_line($linenr, $n) . "\n"; |
| 4679 | } |
| 4680 | |
| 4681 | WARN("TRAILING_SEMICOLON", |
| 4682 | "macros should not use a trailing semicolon\n" . "$herectx"); |
Joe Perches | b13edf7 | 2012-07-30 14:41:24 -0700 | [diff] [blame] | 4683 | } |
| 4684 | } |
| 4685 | |
Mike Frysinger | 080ba92 | 2009-01-06 14:41:25 -0800 | [diff] [blame] | 4686 | # make sure symbols are always wrapped with VMLINUX_SYMBOL() ... |
| 4687 | # all assignments may have only one of the following with an assignment: |
| 4688 | # . |
| 4689 | # ALIGN(...) |
| 4690 | # VMLINUX_SYMBOL(...) |
| 4691 | if ($realfile eq 'vmlinux.lds.h' && $line =~ /(?:(?:^|\s)$Ident\s*=|=\s*$Ident(?:\s|$))/) { |
Joe Perches | 000d1cc1 | 2011-07-25 17:13:25 -0700 | [diff] [blame] | 4692 | WARN("MISSING_VMLINUX_SYMBOL", |
| 4693 | "vmlinux.lds.h needs VMLINUX_SYMBOL() around C-visible symbols\n" . $herecurr); |
Mike Frysinger | 080ba92 | 2009-01-06 14:41:25 -0800 | [diff] [blame] | 4694 | } |
| 4695 | |
Andy Whitcroft | f0a594c | 2007-07-19 01:48:34 -0700 | [diff] [blame] | 4696 | # check for redundant bracing round if etc |
Andy Whitcroft | 13214ad | 2008-02-08 04:22:03 -0800 | [diff] [blame] | 4697 | if ($line =~ /(^.*)\bif\b/ && $1 !~ /else\s*$/) { |
| 4698 | my ($level, $endln, @chunks) = |
Andy Whitcroft | cf65504 | 2008-03-04 14:28:20 -0800 | [diff] [blame] | 4699 | ctx_statement_full($linenr, $realcnt, 1); |
Andy Whitcroft | 13214ad | 2008-02-08 04:22:03 -0800 | [diff] [blame] | 4700 | #print "chunks<$#chunks> linenr<$linenr> endln<$endln> level<$level>\n"; |
Andy Whitcroft | cf65504 | 2008-03-04 14:28:20 -0800 | [diff] [blame] | 4701 | #print "APW: <<$chunks[1][0]>><<$chunks[1][1]>>\n"; |
| 4702 | if ($#chunks > 0 && $level == 0) { |
Joe Perches | aad4f61 | 2012-03-23 15:02:19 -0700 | [diff] [blame] | 4703 | my @allowed = (); |
| 4704 | my $allow = 0; |
Andy Whitcroft | 13214ad | 2008-02-08 04:22:03 -0800 | [diff] [blame] | 4705 | my $seen = 0; |
Andy Whitcroft | 773647a | 2008-03-28 14:15:58 -0700 | [diff] [blame] | 4706 | my $herectx = $here . "\n"; |
Andy Whitcroft | cf65504 | 2008-03-04 14:28:20 -0800 | [diff] [blame] | 4707 | my $ln = $linenr - 1; |
Andy Whitcroft | 13214ad | 2008-02-08 04:22:03 -0800 | [diff] [blame] | 4708 | for my $chunk (@chunks) { |
| 4709 | my ($cond, $block) = @{$chunk}; |
| 4710 | |
Andy Whitcroft | 773647a | 2008-03-28 14:15:58 -0700 | [diff] [blame] | 4711 | # If the condition carries leading newlines, then count those as offsets. |
| 4712 | my ($whitespace) = ($cond =~ /^((?:\s*\n[+-])*\s*)/s); |
| 4713 | my $offset = statement_rawlines($whitespace) - 1; |
| 4714 | |
Joe Perches | aad4f61 | 2012-03-23 15:02:19 -0700 | [diff] [blame] | 4715 | $allowed[$allow] = 0; |
Andy Whitcroft | 773647a | 2008-03-28 14:15:58 -0700 | [diff] [blame] | 4716 | #print "COND<$cond> whitespace<$whitespace> offset<$offset>\n"; |
| 4717 | |
| 4718 | # We have looked at and allowed this specific line. |
| 4719 | $suppress_ifbraces{$ln + $offset} = 1; |
| 4720 | |
| 4721 | $herectx .= "$rawlines[$ln + $offset]\n[...]\n"; |
Andy Whitcroft | cf65504 | 2008-03-04 14:28:20 -0800 | [diff] [blame] | 4722 | $ln += statement_rawlines($block) - 1; |
| 4723 | |
Andy Whitcroft | 773647a | 2008-03-28 14:15:58 -0700 | [diff] [blame] | 4724 | substr($block, 0, length($cond), ''); |
Andy Whitcroft | 13214ad | 2008-02-08 04:22:03 -0800 | [diff] [blame] | 4725 | |
| 4726 | $seen++ if ($block =~ /^\s*{/); |
| 4727 | |
Joe Perches | aad4f61 | 2012-03-23 15:02:19 -0700 | [diff] [blame] | 4728 | #print "cond<$cond> block<$block> allowed<$allowed[$allow]>\n"; |
Andy Whitcroft | cf65504 | 2008-03-04 14:28:20 -0800 | [diff] [blame] | 4729 | if (statement_lines($cond) > 1) { |
| 4730 | #print "APW: ALLOWED: cond<$cond>\n"; |
Joe Perches | aad4f61 | 2012-03-23 15:02:19 -0700 | [diff] [blame] | 4731 | $allowed[$allow] = 1; |
Andy Whitcroft | 13214ad | 2008-02-08 04:22:03 -0800 | [diff] [blame] | 4732 | } |
| 4733 | if ($block =~/\b(?:if|for|while)\b/) { |
Andy Whitcroft | cf65504 | 2008-03-04 14:28:20 -0800 | [diff] [blame] | 4734 | #print "APW: ALLOWED: block<$block>\n"; |
Joe Perches | aad4f61 | 2012-03-23 15:02:19 -0700 | [diff] [blame] | 4735 | $allowed[$allow] = 1; |
Andy Whitcroft | 13214ad | 2008-02-08 04:22:03 -0800 | [diff] [blame] | 4736 | } |
Andy Whitcroft | cf65504 | 2008-03-04 14:28:20 -0800 | [diff] [blame] | 4737 | if (statement_block_size($block) > 1) { |
| 4738 | #print "APW: ALLOWED: lines block<$block>\n"; |
Joe Perches | aad4f61 | 2012-03-23 15:02:19 -0700 | [diff] [blame] | 4739 | $allowed[$allow] = 1; |
Andy Whitcroft | 13214ad | 2008-02-08 04:22:03 -0800 | [diff] [blame] | 4740 | } |
Joe Perches | aad4f61 | 2012-03-23 15:02:19 -0700 | [diff] [blame] | 4741 | $allow++; |
Andy Whitcroft | 13214ad | 2008-02-08 04:22:03 -0800 | [diff] [blame] | 4742 | } |
Joe Perches | aad4f61 | 2012-03-23 15:02:19 -0700 | [diff] [blame] | 4743 | if ($seen) { |
| 4744 | my $sum_allowed = 0; |
| 4745 | foreach (@allowed) { |
| 4746 | $sum_allowed += $_; |
| 4747 | } |
| 4748 | if ($sum_allowed == 0) { |
| 4749 | WARN("BRACES", |
| 4750 | "braces {} are not necessary for any arm of this statement\n" . $herectx); |
| 4751 | } elsif ($sum_allowed != $allow && |
| 4752 | $seen != $allow) { |
| 4753 | CHK("BRACES", |
| 4754 | "braces {} should be used on all arms of this statement\n" . $herectx); |
| 4755 | } |
Andy Whitcroft | 13214ad | 2008-02-08 04:22:03 -0800 | [diff] [blame] | 4756 | } |
| 4757 | } |
| 4758 | } |
Andy Whitcroft | 773647a | 2008-03-28 14:15:58 -0700 | [diff] [blame] | 4759 | if (!defined $suppress_ifbraces{$linenr - 1} && |
Andy Whitcroft | 13214ad | 2008-02-08 04:22:03 -0800 | [diff] [blame] | 4760 | $line =~ /\b(if|while|for|else)\b/) { |
Andy Whitcroft | cf65504 | 2008-03-04 14:28:20 -0800 | [diff] [blame] | 4761 | my $allowed = 0; |
Andy Whitcroft | f0a594c | 2007-07-19 01:48:34 -0700 | [diff] [blame] | 4762 | |
Andy Whitcroft | cf65504 | 2008-03-04 14:28:20 -0800 | [diff] [blame] | 4763 | # Check the pre-context. |
| 4764 | if (substr($line, 0, $-[0]) =~ /(\}\s*)$/) { |
| 4765 | #print "APW: ALLOWED: pre<$1>\n"; |
| 4766 | $allowed = 1; |
| 4767 | } |
Andy Whitcroft | 773647a | 2008-03-28 14:15:58 -0700 | [diff] [blame] | 4768 | |
| 4769 | my ($level, $endln, @chunks) = |
| 4770 | ctx_statement_full($linenr, $realcnt, $-[0]); |
| 4771 | |
Andy Whitcroft | cf65504 | 2008-03-04 14:28:20 -0800 | [diff] [blame] | 4772 | # Check the condition. |
| 4773 | my ($cond, $block) = @{$chunks[0]}; |
Andy Whitcroft | 773647a | 2008-03-28 14:15:58 -0700 | [diff] [blame] | 4774 | #print "CHECKING<$linenr> cond<$cond> block<$block>\n"; |
Andy Whitcroft | cf65504 | 2008-03-04 14:28:20 -0800 | [diff] [blame] | 4775 | if (defined $cond) { |
Andy Whitcroft | 773647a | 2008-03-28 14:15:58 -0700 | [diff] [blame] | 4776 | substr($block, 0, length($cond), ''); |
Andy Whitcroft | cf65504 | 2008-03-04 14:28:20 -0800 | [diff] [blame] | 4777 | } |
| 4778 | if (statement_lines($cond) > 1) { |
| 4779 | #print "APW: ALLOWED: cond<$cond>\n"; |
| 4780 | $allowed = 1; |
| 4781 | } |
| 4782 | if ($block =~/\b(?:if|for|while)\b/) { |
| 4783 | #print "APW: ALLOWED: block<$block>\n"; |
| 4784 | $allowed = 1; |
| 4785 | } |
| 4786 | if (statement_block_size($block) > 1) { |
| 4787 | #print "APW: ALLOWED: lines block<$block>\n"; |
| 4788 | $allowed = 1; |
| 4789 | } |
| 4790 | # Check the post-context. |
| 4791 | if (defined $chunks[1]) { |
| 4792 | my ($cond, $block) = @{$chunks[1]}; |
| 4793 | if (defined $cond) { |
Andy Whitcroft | 773647a | 2008-03-28 14:15:58 -0700 | [diff] [blame] | 4794 | substr($block, 0, length($cond), ''); |
Andy Whitcroft | f0a594c | 2007-07-19 01:48:34 -0700 | [diff] [blame] | 4795 | } |
Andy Whitcroft | cf65504 | 2008-03-04 14:28:20 -0800 | [diff] [blame] | 4796 | if ($block =~ /^\s*\{/) { |
| 4797 | #print "APW: ALLOWED: chunk-1 block<$block>\n"; |
| 4798 | $allowed = 1; |
| 4799 | } |
| 4800 | } |
| 4801 | if ($level == 0 && $block =~ /^\s*\{/ && !$allowed) { |
Justin P. Mattock | 6993248 | 2011-07-26 23:06:29 -0700 | [diff] [blame] | 4802 | my $herectx = $here . "\n"; |
Andy Whitcroft | f055663 | 2008-10-15 22:02:23 -0700 | [diff] [blame] | 4803 | my $cnt = statement_rawlines($block); |
Andy Whitcroft | cf65504 | 2008-03-04 14:28:20 -0800 | [diff] [blame] | 4804 | |
Andy Whitcroft | f055663 | 2008-10-15 22:02:23 -0700 | [diff] [blame] | 4805 | for (my $n = 0; $n < $cnt; $n++) { |
Justin P. Mattock | 6993248 | 2011-07-26 23:06:29 -0700 | [diff] [blame] | 4806 | $herectx .= raw_line($linenr, $n) . "\n"; |
Andy Whitcroft | cf65504 | 2008-03-04 14:28:20 -0800 | [diff] [blame] | 4807 | } |
| 4808 | |
Joe Perches | 000d1cc1 | 2011-07-25 17:13:25 -0700 | [diff] [blame] | 4809 | WARN("BRACES", |
| 4810 | "braces {} are not necessary for single statement blocks\n" . $herectx); |
Andy Whitcroft | f0a594c | 2007-07-19 01:48:34 -0700 | [diff] [blame] | 4811 | } |
| 4812 | } |
| 4813 | |
Joe Perches | 0979ae6 | 2012-12-17 16:01:59 -0800 | [diff] [blame] | 4814 | # check for unnecessary blank lines around braces |
Joe Perches | 77b9a53 | 2013-07-03 15:05:29 -0700 | [diff] [blame] | 4815 | if (($line =~ /^.\s*}\s*$/ && $prevrawline =~ /^.\s*$/)) { |
Joe Perches | f8e5821 | 2015-02-13 14:38:46 -0800 | [diff] [blame] | 4816 | if (CHK("BRACES", |
| 4817 | "Blank lines aren't necessary before a close brace '}'\n" . $hereprev) && |
| 4818 | $fix && $prevrawline =~ /^\+/) { |
| 4819 | fix_delete_line($fixlinenr - 1, $prevrawline); |
| 4820 | } |
Joe Perches | 0979ae6 | 2012-12-17 16:01:59 -0800 | [diff] [blame] | 4821 | } |
Joe Perches | 77b9a53 | 2013-07-03 15:05:29 -0700 | [diff] [blame] | 4822 | if (($rawline =~ /^.\s*$/ && $prevline =~ /^..*{\s*$/)) { |
Joe Perches | f8e5821 | 2015-02-13 14:38:46 -0800 | [diff] [blame] | 4823 | if (CHK("BRACES", |
| 4824 | "Blank lines aren't necessary after an open brace '{'\n" . $hereprev) && |
| 4825 | $fix) { |
| 4826 | fix_delete_line($fixlinenr, $rawline); |
| 4827 | } |
Joe Perches | 0979ae6 | 2012-12-17 16:01:59 -0800 | [diff] [blame] | 4828 | } |
| 4829 | |
Andy Whitcroft | 4a0df2e | 2007-06-08 13:46:39 -0700 | [diff] [blame] | 4830 | # no volatiles please |
Andy Whitcroft | 6c72ffa | 2007-10-18 03:05:08 -0700 | [diff] [blame] | 4831 | my $asm_volatile = qr{\b(__asm__|asm)\s+(__volatile__|volatile)\b}; |
| 4832 | if ($line =~ /\bvolatile\b/ && $line !~ /$asm_volatile/) { |
Joe Perches | 000d1cc1 | 2011-07-25 17:13:25 -0700 | [diff] [blame] | 4833 | WARN("VOLATILE", |
| 4834 | "Use of volatile is usually wrong: see Documentation/volatile-considered-harmful.txt\n" . $herecurr); |
Andy Whitcroft | 4a0df2e | 2007-06-08 13:46:39 -0700 | [diff] [blame] | 4835 | } |
| 4836 | |
Joe Perches | 5e4f6ba | 2014-12-10 15:52:05 -0800 | [diff] [blame] | 4837 | # Check for user-visible strings broken across lines, which breaks the ability |
| 4838 | # to grep for the string. Make exceptions when the previous string ends in a |
| 4839 | # newline (multiple lines in one string constant) or '\t', '\r', ';', or '{' |
| 4840 | # (common in inline assembly) or is a octal \123 or hexadecimal \xaf value |
Joe Perches | 33acb54 | 2015-06-25 15:02:54 -0700 | [diff] [blame] | 4841 | if ($line =~ /^\+\s*$String/ && |
Joe Perches | 5e4f6ba | 2014-12-10 15:52:05 -0800 | [diff] [blame] | 4842 | $prevline =~ /"\s*$/ && |
| 4843 | $prevrawline !~ /(?:\\(?:[ntr]|[0-7]{1,3}|x[0-9a-fA-F]{1,2})|;\s*|\{\s*)"\s*$/) { |
| 4844 | if (WARN("SPLIT_STRING", |
| 4845 | "quoted string split across lines\n" . $hereprev) && |
| 4846 | $fix && |
| 4847 | $prevrawline =~ /^\+.*"\s*$/ && |
| 4848 | $last_coalesced_string_linenr != $linenr - 1) { |
| 4849 | my $extracted_string = get_quoted_string($line, $rawline); |
| 4850 | my $comma_close = ""; |
| 4851 | if ($rawline =~ /\Q$extracted_string\E(\s*\)\s*;\s*$|\s*,\s*)/) { |
| 4852 | $comma_close = $1; |
| 4853 | } |
| 4854 | |
| 4855 | fix_delete_line($fixlinenr - 1, $prevrawline); |
| 4856 | fix_delete_line($fixlinenr, $rawline); |
| 4857 | my $fixedline = $prevrawline; |
| 4858 | $fixedline =~ s/"\s*$//; |
| 4859 | $fixedline .= substr($extracted_string, 1) . trim($comma_close); |
| 4860 | fix_insert_line($fixlinenr - 1, $fixedline); |
| 4861 | $fixedline = $rawline; |
| 4862 | $fixedline =~ s/\Q$extracted_string\E\Q$comma_close\E//; |
| 4863 | if ($fixedline !~ /\+\s*$/) { |
| 4864 | fix_insert_line($fixlinenr, $fixedline); |
| 4865 | } |
| 4866 | $last_coalesced_string_linenr = $linenr; |
| 4867 | } |
| 4868 | } |
| 4869 | |
| 4870 | # check for missing a space in a string concatenation |
| 4871 | if ($prevrawline =~ /[^\\]\w"$/ && $rawline =~ /^\+[\t ]+"\w/) { |
| 4872 | WARN('MISSING_SPACE', |
| 4873 | "break quoted strings at a space character\n" . $hereprev); |
| 4874 | } |
| 4875 | |
| 4876 | # check for spaces before a quoted newline |
| 4877 | if ($rawline =~ /^.*\".*\s\\n/) { |
| 4878 | if (WARN("QUOTED_WHITESPACE_BEFORE_NEWLINE", |
| 4879 | "unnecessary whitespace before a quoted newline\n" . $herecurr) && |
| 4880 | $fix) { |
| 4881 | $fixed[$fixlinenr] =~ s/^(\+.*\".*)\s+\\n/$1\\n/; |
| 4882 | } |
| 4883 | |
| 4884 | } |
| 4885 | |
Joe Perches | f17dba4 | 2014-10-13 15:51:51 -0700 | [diff] [blame] | 4886 | # concatenated string without spaces between elements |
Joe Perches | 33acb54 | 2015-06-25 15:02:54 -0700 | [diff] [blame] | 4887 | if ($line =~ /$String[A-Z_]/ || $line =~ /[A-Za-z0-9_]$String/) { |
Joe Perches | f17dba4 | 2014-10-13 15:51:51 -0700 | [diff] [blame] | 4888 | CHK("CONCATENATED_STRING", |
| 4889 | "Concatenated strings should use spaces between elements\n" . $herecurr); |
| 4890 | } |
| 4891 | |
Joe Perches | 90ad30e | 2014-12-10 15:51:59 -0800 | [diff] [blame] | 4892 | # uncoalesced string fragments |
Joe Perches | 33acb54 | 2015-06-25 15:02:54 -0700 | [diff] [blame] | 4893 | if ($line =~ /$String\s*"/) { |
Joe Perches | 90ad30e | 2014-12-10 15:51:59 -0800 | [diff] [blame] | 4894 | WARN("STRING_FRAGMENTS", |
| 4895 | "Consecutive strings are generally better as a single string\n" . $herecurr); |
| 4896 | } |
| 4897 | |
Joe Perches | 6e30075 | 2015-09-09 15:37:47 -0700 | [diff] [blame] | 4898 | # check for %L{u,d,i} and 0x%[udi] in strings |
Joe Perches | 5e4f6ba | 2014-12-10 15:52:05 -0800 | [diff] [blame] | 4899 | my $string; |
| 4900 | while ($line =~ /(?:^|")([X\t]*)(?:"|$)/g) { |
| 4901 | $string = substr($rawline, $-[1], $+[1] - $-[1]); |
| 4902 | $string =~ s/%%/__/g; |
Joe Perches | 6e30075 | 2015-09-09 15:37:47 -0700 | [diff] [blame] | 4903 | if ($string =~ /(?<!%)%[\*\d\.\$]*L[udi]/) { |
Joe Perches | 5e4f6ba | 2014-12-10 15:52:05 -0800 | [diff] [blame] | 4904 | WARN("PRINTF_L", |
| 4905 | "\%Ld/%Lu are not-standard C, use %lld/%llu\n" . $herecurr); |
| 4906 | last; |
| 4907 | } |
Joe Perches | 6e30075 | 2015-09-09 15:37:47 -0700 | [diff] [blame] | 4908 | if ($string =~ /0x%[\*\d\.\$\Llzth]*[udi]/) { |
| 4909 | ERROR("PRINTF_0xDECIMAL", |
| 4910 | "Prefixing 0x with decimal output is defective\n" . $herecurr); |
| 4911 | } |
Joe Perches | 5e4f6ba | 2014-12-10 15:52:05 -0800 | [diff] [blame] | 4912 | } |
| 4913 | |
| 4914 | # check for line continuations in quoted strings with odd counts of " |
| 4915 | if ($rawline =~ /\\$/ && $rawline =~ tr/"/"/ % 2) { |
| 4916 | WARN("LINE_CONTINUATIONS", |
| 4917 | "Avoid line continuations in quoted strings\n" . $herecurr); |
| 4918 | } |
| 4919 | |
Andy Whitcroft | 00df344 | 2007-06-08 13:47:06 -0700 | [diff] [blame] | 4920 | # warn about #if 0 |
Andy Whitcroft | c45dcab | 2008-06-05 22:46:01 -0700 | [diff] [blame] | 4921 | if ($line =~ /^.\s*\#\s*if\s+0\b/) { |
Joe Perches | 000d1cc1 | 2011-07-25 17:13:25 -0700 | [diff] [blame] | 4922 | CHK("REDUNDANT_CODE", |
| 4923 | "if this code is redundant consider removing it\n" . |
Andy Whitcroft | de7d4f0 | 2007-07-15 23:37:22 -0700 | [diff] [blame] | 4924 | $herecurr); |
Andy Whitcroft | 4a0df2e | 2007-06-08 13:46:39 -0700 | [diff] [blame] | 4925 | } |
| 4926 | |
Andy Whitcroft | 03df4b5 | 2012-12-17 16:01:52 -0800 | [diff] [blame] | 4927 | # check for needless "if (<foo>) fn(<foo>)" uses |
| 4928 | if ($prevline =~ /\bif\s*\(\s*($Lval)\s*\)/) { |
Joe Perches | 100425d | 2015-09-09 15:37:36 -0700 | [diff] [blame] | 4929 | my $tested = quotemeta($1); |
| 4930 | my $expr = '\s*\(\s*' . $tested . '\s*\)\s*;'; |
| 4931 | if ($line =~ /\b(kfree|usb_free_urb|debugfs_remove(?:_recursive)?|(?:kmem_cache|mempool|dma_pool)_destroy)$expr/) { |
| 4932 | my $func = $1; |
| 4933 | if (WARN('NEEDLESS_IF', |
| 4934 | "$func(NULL) is safe and this check is probably not required\n" . $hereprev) && |
| 4935 | $fix) { |
| 4936 | my $do_fix = 1; |
| 4937 | my $leading_tabs = ""; |
| 4938 | my $new_leading_tabs = ""; |
| 4939 | if ($lines[$linenr - 2] =~ /^\+(\t*)if\s*\(\s*$tested\s*\)\s*$/) { |
| 4940 | $leading_tabs = $1; |
| 4941 | } else { |
| 4942 | $do_fix = 0; |
| 4943 | } |
| 4944 | if ($lines[$linenr - 1] =~ /^\+(\t+)$func\s*\(\s*$tested\s*\)\s*;\s*$/) { |
| 4945 | $new_leading_tabs = $1; |
| 4946 | if (length($leading_tabs) + 1 ne length($new_leading_tabs)) { |
| 4947 | $do_fix = 0; |
| 4948 | } |
| 4949 | } else { |
| 4950 | $do_fix = 0; |
| 4951 | } |
| 4952 | if ($do_fix) { |
| 4953 | fix_delete_line($fixlinenr - 1, $prevrawline); |
| 4954 | $fixed[$fixlinenr] =~ s/^\+$new_leading_tabs/\+$leading_tabs/; |
| 4955 | } |
| 4956 | } |
Greg Kroah-Hartman | 4c432a8 | 2008-07-23 21:29:04 -0700 | [diff] [blame] | 4957 | } |
| 4958 | } |
Andy Whitcroft | f0a594c | 2007-07-19 01:48:34 -0700 | [diff] [blame] | 4959 | |
Joe Perches | ebfdc40 | 2014-08-06 16:10:27 -0700 | [diff] [blame] | 4960 | # check for unnecessary "Out of Memory" messages |
| 4961 | if ($line =~ /^\+.*\b$logFunctions\s*\(/ && |
| 4962 | $prevline =~ /^[ \+]\s*if\s*\(\s*(\!\s*|NULL\s*==\s*)?($Lval)(\s*==\s*NULL\s*)?\s*\)/ && |
| 4963 | (defined $1 || defined $3) && |
| 4964 | $linenr > 3) { |
| 4965 | my $testval = $2; |
| 4966 | my $testline = $lines[$linenr - 3]; |
| 4967 | |
| 4968 | my ($s, $c) = ctx_statement_block($linenr - 3, $realcnt, 0); |
| 4969 | # print("line: <$line>\nprevline: <$prevline>\ns: <$s>\nc: <$c>\n\n\n"); |
| 4970 | |
| 4971 | if ($c =~ /(?:^|\n)[ \+]\s*(?:$Type\s*)?\Q$testval\E\s*=\s*(?:\([^\)]*\)\s*)?\s*(?:devm_)?(?:[kv][czm]alloc(?:_node|_array)?\b|kstrdup|(?:dev_)?alloc_skb)/) { |
| 4972 | WARN("OOM_MESSAGE", |
| 4973 | "Possible unnecessary 'out of memory' message\n" . $hereprev); |
| 4974 | } |
| 4975 | } |
| 4976 | |
Joe Perches | f78d98f | 2014-10-13 15:52:01 -0700 | [diff] [blame] | 4977 | # check for logging functions with KERN_<LEVEL> |
Paolo Bonzini | dcaf112 | 2015-02-13 14:38:26 -0800 | [diff] [blame] | 4978 | if ($line !~ /printk(?:_ratelimited|_once)?\s*\(/ && |
Joe Perches | f78d98f | 2014-10-13 15:52:01 -0700 | [diff] [blame] | 4979 | $line =~ /\b$logFunctions\s*\(.*\b(KERN_[A-Z]+)\b/) { |
| 4980 | my $level = $1; |
| 4981 | if (WARN("UNNECESSARY_KERN_LEVEL", |
| 4982 | "Possible unnecessary $level\n" . $herecurr) && |
| 4983 | $fix) { |
| 4984 | $fixed[$fixlinenr] =~ s/\s*$level\s*//; |
| 4985 | } |
| 4986 | } |
| 4987 | |
Joe Perches | abb08a5 | 2014-12-10 15:51:46 -0800 | [diff] [blame] | 4988 | # check for mask then right shift without a parentheses |
| 4989 | if ($^V && $^V ge 5.10.0 && |
| 4990 | $line =~ /$LvalOrFunc\s*\&\s*($LvalOrFunc)\s*>>/ && |
| 4991 | $4 !~ /^\&/) { # $LvalOrFunc may be &foo, ignore if so |
| 4992 | WARN("MASK_THEN_SHIFT", |
| 4993 | "Possible precedence defect with mask then right shift - may need parentheses\n" . $herecurr); |
| 4994 | } |
| 4995 | |
Joe Perches | b75ac61 | 2014-12-10 15:52:02 -0800 | [diff] [blame] | 4996 | # check for pointer comparisons to NULL |
| 4997 | if ($^V && $^V ge 5.10.0) { |
| 4998 | while ($line =~ /\b$LvalOrFunc\s*(==|\!=)\s*NULL\b/g) { |
| 4999 | my $val = $1; |
| 5000 | my $equal = "!"; |
| 5001 | $equal = "" if ($4 eq "!="); |
| 5002 | if (CHK("COMPARISON_TO_NULL", |
| 5003 | "Comparison to NULL could be written \"${equal}${val}\"\n" . $herecurr) && |
| 5004 | $fix) { |
| 5005 | $fixed[$fixlinenr] =~ s/\b\Q$val\E\s*(?:==|\!=)\s*NULL\b/$equal$val/; |
| 5006 | } |
| 5007 | } |
| 5008 | } |
| 5009 | |
Joe Perches | 8716de3 | 2013-09-11 14:24:05 -0700 | [diff] [blame] | 5010 | # check for bad placement of section $InitAttribute (e.g.: __initdata) |
| 5011 | if ($line =~ /(\b$InitAttribute\b)/) { |
| 5012 | my $attr = $1; |
| 5013 | if ($line =~ /^\+\s*static\s+(?:const\s+)?(?:$attr\s+)?($NonptrTypeWithAttr)\s+(?:$attr\s+)?($Ident(?:\[[^]]*\])?)\s*[=;]/) { |
| 5014 | my $ptr = $1; |
| 5015 | my $var = $2; |
| 5016 | if ((($ptr =~ /\b(union|struct)\s+$attr\b/ && |
| 5017 | ERROR("MISPLACED_INIT", |
| 5018 | "$attr should be placed after $var\n" . $herecurr)) || |
| 5019 | ($ptr !~ /\b(union|struct)\s+$attr\b/ && |
| 5020 | WARN("MISPLACED_INIT", |
| 5021 | "$attr should be placed after $var\n" . $herecurr))) && |
| 5022 | $fix) { |
Joe Perches | 194f66f | 2014-08-06 16:11:03 -0700 | [diff] [blame] | 5023 | $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; |
Joe Perches | 8716de3 | 2013-09-11 14:24:05 -0700 | [diff] [blame] | 5024 | } |
| 5025 | } |
| 5026 | } |
| 5027 | |
Joe Perches | e970b884 | 2013-11-12 15:10:10 -0800 | [diff] [blame] | 5028 | # check for $InitAttributeData (ie: __initdata) with const |
| 5029 | if ($line =~ /\bconst\b/ && $line =~ /($InitAttributeData)/) { |
| 5030 | my $attr = $1; |
| 5031 | $attr =~ /($InitAttributePrefix)(.*)/; |
| 5032 | my $attr_prefix = $1; |
| 5033 | my $attr_type = $2; |
| 5034 | if (ERROR("INIT_ATTRIBUTE", |
| 5035 | "Use of const init definition must use ${attr_prefix}initconst\n" . $herecurr) && |
| 5036 | $fix) { |
Joe Perches | 194f66f | 2014-08-06 16:11:03 -0700 | [diff] [blame] | 5037 | $fixed[$fixlinenr] =~ |
Joe Perches | e970b884 | 2013-11-12 15:10:10 -0800 | [diff] [blame] | 5038 | s/$InitAttributeData/${attr_prefix}initconst/; |
| 5039 | } |
| 5040 | } |
| 5041 | |
| 5042 | # check for $InitAttributeConst (ie: __initconst) without const |
| 5043 | if ($line !~ /\bconst\b/ && $line =~ /($InitAttributeConst)/) { |
| 5044 | my $attr = $1; |
| 5045 | if (ERROR("INIT_ATTRIBUTE", |
| 5046 | "Use of $attr requires a separate use of const\n" . $herecurr) && |
| 5047 | $fix) { |
Joe Perches | 194f66f | 2014-08-06 16:11:03 -0700 | [diff] [blame] | 5048 | my $lead = $fixed[$fixlinenr] =~ |
Joe Perches | e970b884 | 2013-11-12 15:10:10 -0800 | [diff] [blame] | 5049 | /(^\+\s*(?:static\s+))/; |
| 5050 | $lead = rtrim($1); |
| 5051 | $lead = "$lead " if ($lead !~ /^\+$/); |
| 5052 | $lead = "${lead}const "; |
Joe Perches | 194f66f | 2014-08-06 16:11:03 -0700 | [diff] [blame] | 5053 | $fixed[$fixlinenr] =~ s/(^\+\s*(?:static\s+))/$lead/; |
Joe Perches | e970b884 | 2013-11-12 15:10:10 -0800 | [diff] [blame] | 5054 | } |
| 5055 | } |
| 5056 | |
Joe Perches | c17893c | 2015-04-16 12:44:42 -0700 | [diff] [blame] | 5057 | # check for __read_mostly with const non-pointer (should just be const) |
| 5058 | if ($line =~ /\b__read_mostly\b/ && |
| 5059 | $line =~ /($Type)\s*$Ident/ && $1 !~ /\*\s*$/ && $1 =~ /\bconst\b/) { |
| 5060 | if (ERROR("CONST_READ_MOSTLY", |
| 5061 | "Invalid use of __read_mostly with const type\n" . $herecurr) && |
| 5062 | $fix) { |
| 5063 | $fixed[$fixlinenr] =~ s/\s+__read_mostly\b//; |
| 5064 | } |
| 5065 | } |
| 5066 | |
Joe Perches | fbdb813 | 2014-04-03 14:49:14 -0700 | [diff] [blame] | 5067 | # don't use __constant_<foo> functions outside of include/uapi/ |
| 5068 | if ($realfile !~ m@^include/uapi/@ && |
| 5069 | $line =~ /(__constant_(?:htons|ntohs|[bl]e(?:16|32|64)_to_cpu|cpu_to_[bl]e(?:16|32|64)))\s*\(/) { |
| 5070 | my $constant_func = $1; |
| 5071 | my $func = $constant_func; |
| 5072 | $func =~ s/^__constant_//; |
| 5073 | if (WARN("CONSTANT_CONVERSION", |
| 5074 | "$constant_func should be $func\n" . $herecurr) && |
| 5075 | $fix) { |
Joe Perches | 194f66f | 2014-08-06 16:11:03 -0700 | [diff] [blame] | 5076 | $fixed[$fixlinenr] =~ s/\b$constant_func\b/$func/g; |
Joe Perches | fbdb813 | 2014-04-03 14:49:14 -0700 | [diff] [blame] | 5077 | } |
| 5078 | } |
| 5079 | |
Patrick Pannuto | 1a15a25 | 2010-08-09 17:21:01 -0700 | [diff] [blame] | 5080 | # prefer usleep_range over udelay |
Bruce Allan | 37581c2 | 2013-02-21 16:44:19 -0800 | [diff] [blame] | 5081 | if ($line =~ /\budelay\s*\(\s*(\d+)\s*\)/) { |
Joe Perches | 43c1d77 | 2014-04-03 14:49:11 -0700 | [diff] [blame] | 5082 | my $delay = $1; |
Patrick Pannuto | 1a15a25 | 2010-08-09 17:21:01 -0700 | [diff] [blame] | 5083 | # ignore udelay's < 10, however |
Joe Perches | 43c1d77 | 2014-04-03 14:49:11 -0700 | [diff] [blame] | 5084 | if (! ($delay < 10) ) { |
Joe Perches | 000d1cc1 | 2011-07-25 17:13:25 -0700 | [diff] [blame] | 5085 | CHK("USLEEP_RANGE", |
Joe Perches | 43c1d77 | 2014-04-03 14:49:11 -0700 | [diff] [blame] | 5086 | "usleep_range is preferred over udelay; see Documentation/timers/timers-howto.txt\n" . $herecurr); |
| 5087 | } |
| 5088 | if ($delay > 2000) { |
| 5089 | WARN("LONG_UDELAY", |
| 5090 | "long udelay - prefer mdelay; see arch/arm/include/asm/delay.h\n" . $herecurr); |
Patrick Pannuto | 1a15a25 | 2010-08-09 17:21:01 -0700 | [diff] [blame] | 5091 | } |
| 5092 | } |
| 5093 | |
Patrick Pannuto | 09ef872 | 2010-08-09 17:21:02 -0700 | [diff] [blame] | 5094 | # warn about unexpectedly long msleep's |
| 5095 | if ($line =~ /\bmsleep\s*\((\d+)\);/) { |
| 5096 | if ($1 < 20) { |
Joe Perches | 000d1cc1 | 2011-07-25 17:13:25 -0700 | [diff] [blame] | 5097 | WARN("MSLEEP", |
Joe Perches | 43c1d77 | 2014-04-03 14:49:11 -0700 | [diff] [blame] | 5098 | "msleep < 20ms can sleep for up to 20ms; see Documentation/timers/timers-howto.txt\n" . $herecurr); |
Patrick Pannuto | 09ef872 | 2010-08-09 17:21:02 -0700 | [diff] [blame] | 5099 | } |
| 5100 | } |
| 5101 | |
Joe Perches | 36ec193 | 2013-07-03 15:05:25 -0700 | [diff] [blame] | 5102 | # check for comparisons of jiffies |
| 5103 | if ($line =~ /\bjiffies\s*$Compare|$Compare\s*jiffies\b/) { |
| 5104 | WARN("JIFFIES_COMPARISON", |
| 5105 | "Comparing jiffies is almost always wrong; prefer time_after, time_before and friends\n" . $herecurr); |
| 5106 | } |
| 5107 | |
Joe Perches | 9d7a34a | 2013-07-03 15:05:26 -0700 | [diff] [blame] | 5108 | # check for comparisons of get_jiffies_64() |
| 5109 | if ($line =~ /\bget_jiffies_64\s*\(\s*\)\s*$Compare|$Compare\s*get_jiffies_64\s*\(\s*\)/) { |
| 5110 | WARN("JIFFIES_COMPARISON", |
| 5111 | "Comparing get_jiffies_64() is almost always wrong; prefer time_after64, time_before64 and friends\n" . $herecurr); |
| 5112 | } |
| 5113 | |
Andy Whitcroft | 00df344 | 2007-06-08 13:47:06 -0700 | [diff] [blame] | 5114 | # warn about #ifdefs in C files |
Andy Whitcroft | c45dcab | 2008-06-05 22:46:01 -0700 | [diff] [blame] | 5115 | # if ($line =~ /^.\s*\#\s*if(|n)def/ && ($realfile =~ /\.c$/)) { |
Andy Whitcroft | 00df344 | 2007-06-08 13:47:06 -0700 | [diff] [blame] | 5116 | # print "#ifdef in C files should be avoided\n"; |
| 5117 | # print "$herecurr"; |
| 5118 | # $clean = 0; |
| 5119 | # } |
| 5120 | |
Andy Whitcroft | 22f2a2e | 2007-08-10 13:01:03 -0700 | [diff] [blame] | 5121 | # warn about spacing in #ifdefs |
Andy Whitcroft | c45dcab | 2008-06-05 22:46:01 -0700 | [diff] [blame] | 5122 | if ($line =~ /^.\s*\#\s*(ifdef|ifndef|elif)\s\s+/) { |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 5123 | if (ERROR("SPACING", |
| 5124 | "exactly one space required after that #$1\n" . $herecurr) && |
| 5125 | $fix) { |
Joe Perches | 194f66f | 2014-08-06 16:11:03 -0700 | [diff] [blame] | 5126 | $fixed[$fixlinenr] =~ |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 5127 | s/^(.\s*\#\s*(ifdef|ifndef|elif))\s{2,}/$1 /; |
| 5128 | } |
| 5129 | |
Andy Whitcroft | 22f2a2e | 2007-08-10 13:01:03 -0700 | [diff] [blame] | 5130 | } |
| 5131 | |
Andy Whitcroft | 4a0df2e | 2007-06-08 13:46:39 -0700 | [diff] [blame] | 5132 | # check for spinlock_t definitions without a comment. |
Andy Whitcroft | 171ae1a | 2008-04-29 00:59:32 -0700 | [diff] [blame] | 5133 | if ($line =~ /^.\s*(struct\s+mutex|spinlock_t)\s+\S+;/ || |
| 5134 | $line =~ /^.\s*(DEFINE_MUTEX)\s*\(/) { |
Andy Whitcroft | 4a0df2e | 2007-06-08 13:46:39 -0700 | [diff] [blame] | 5135 | my $which = $1; |
| 5136 | if (!ctx_has_comment($first_line, $linenr)) { |
Joe Perches | 000d1cc1 | 2011-07-25 17:13:25 -0700 | [diff] [blame] | 5137 | CHK("UNCOMMENTED_DEFINITION", |
| 5138 | "$1 definition without comment\n" . $herecurr); |
Andy Whitcroft | 4a0df2e | 2007-06-08 13:46:39 -0700 | [diff] [blame] | 5139 | } |
| 5140 | } |
| 5141 | # check for memory barriers without a comment. |
Michael S. Tsirkin | 402c255 | 2016-01-04 09:39:01 +0200 | [diff] [blame] | 5142 | |
| 5143 | my $barriers = qr{ |
| 5144 | mb| |
| 5145 | rmb| |
| 5146 | wmb| |
| 5147 | read_barrier_depends |
| 5148 | }x; |
| 5149 | my $barrier_stems = qr{ |
| 5150 | mb__before_atomic| |
| 5151 | mb__after_atomic| |
| 5152 | store_release| |
| 5153 | load_acquire| |
| 5154 | store_mb| |
| 5155 | (?:$barriers) |
| 5156 | }x; |
| 5157 | my $all_barriers = qr{ |
| 5158 | (?:$barriers)| |
Michael S. Tsirkin | 43e361f | 2016-01-04 10:00:10 +0200 | [diff] [blame] | 5159 | smp_(?:$barrier_stems)| |
| 5160 | virt_(?:$barrier_stems) |
Michael S. Tsirkin | 402c255 | 2016-01-04 09:39:01 +0200 | [diff] [blame] | 5161 | }x; |
| 5162 | |
| 5163 | if ($line =~ /\b(?:$all_barriers)\s*\(/) { |
Andy Whitcroft | 4a0df2e | 2007-06-08 13:46:39 -0700 | [diff] [blame] | 5164 | if (!ctx_has_comment($first_line, $linenr)) { |
Joe Perches | c1fd7bb | 2013-11-12 15:10:11 -0800 | [diff] [blame] | 5165 | WARN("MEMORY_BARRIER", |
| 5166 | "memory barrier without comment\n" . $herecurr); |
Andy Whitcroft | 4a0df2e | 2007-06-08 13:46:39 -0700 | [diff] [blame] | 5167 | } |
| 5168 | } |
Paul E. McKenney | 3ad8177 | 2015-07-02 11:55:40 -0700 | [diff] [blame] | 5169 | |
Michael S. Tsirkin | f4073b0 | 2016-01-04 09:54:51 +0200 | [diff] [blame] | 5170 | my $underscore_smp_barriers = qr{__smp_(?:$barrier_stems)}x; |
| 5171 | |
| 5172 | if ($realfile !~ m@^include/asm-generic/@ && |
| 5173 | $realfile !~ m@/barrier\.h$@ && |
| 5174 | $line =~ m/\b(?:$underscore_smp_barriers)\s*\(/ && |
| 5175 | $line !~ m/^.\s*\#\s*define\s+(?:$underscore_smp_barriers)\s*\(/) { |
| 5176 | WARN("MEMORY_BARRIER", |
| 5177 | "__smp memory barriers shouldn't be used outside barrier.h and asm-generic\n" . $herecurr); |
| 5178 | } |
| 5179 | |
Joe Perches | cb426e9 | 2015-06-25 15:02:46 -0700 | [diff] [blame] | 5180 | # check for waitqueue_active without a comment. |
| 5181 | if ($line =~ /\bwaitqueue_active\s*\(/) { |
| 5182 | if (!ctx_has_comment($first_line, $linenr)) { |
| 5183 | WARN("WAITQUEUE_ACTIVE", |
| 5184 | "waitqueue_active without comment\n" . $herecurr); |
| 5185 | } |
| 5186 | } |
Paul E. McKenney | 3ad8177 | 2015-07-02 11:55:40 -0700 | [diff] [blame] | 5187 | |
| 5188 | # Check for expedited grace periods that interrupt non-idle non-nohz |
| 5189 | # online CPUs. These expedited can therefore degrade real-time response |
| 5190 | # if used carelessly, and should be avoided where not absolutely |
| 5191 | # needed. It is always OK to use synchronize_rcu_expedited() and |
| 5192 | # synchronize_sched_expedited() at boot time (before real-time applications |
| 5193 | # start) and in error situations where real-time response is compromised in |
| 5194 | # any case. Note that synchronize_srcu_expedited() does -not- interrupt |
| 5195 | # other CPUs, so don't warn on uses of synchronize_srcu_expedited(). |
| 5196 | # Of course, nothing comes for free, and srcu_read_lock() and |
| 5197 | # srcu_read_unlock() do contain full memory barriers in payment for |
| 5198 | # synchronize_srcu_expedited() non-interruption properties. |
| 5199 | if ($line =~ /\b(synchronize_rcu_expedited|synchronize_sched_expedited)\(/) { |
| 5200 | WARN("EXPEDITED_RCU_GRACE_PERIOD", |
| 5201 | "expedited RCU grace periods should be avoided where they can degrade real-time response\n" . $herecurr); |
| 5202 | |
| 5203 | } |
| 5204 | |
Andy Whitcroft | 4a0df2e | 2007-06-08 13:46:39 -0700 | [diff] [blame] | 5205 | # check of hardware specific defines |
Andy Whitcroft | c45dcab | 2008-06-05 22:46:01 -0700 | [diff] [blame] | 5206 | if ($line =~ m@^.\s*\#\s*if.*\b(__i386__|__powerpc64__|__sun__|__s390x__)\b@ && $realfile !~ m@include/asm-@) { |
Joe Perches | 000d1cc1 | 2011-07-25 17:13:25 -0700 | [diff] [blame] | 5207 | CHK("ARCH_DEFINES", |
| 5208 | "architecture specific defines should be avoided\n" . $herecurr); |
Andy Whitcroft | 0a920b5 | 2007-06-01 00:46:48 -0700 | [diff] [blame] | 5209 | } |
Andy Whitcroft | 653d487 | 2007-06-23 17:16:34 -0700 | [diff] [blame] | 5210 | |
Tobias Klauser | d4977c7 | 2010-05-24 14:33:30 -0700 | [diff] [blame] | 5211 | # Check that the storage class is at the beginning of a declaration |
| 5212 | if ($line =~ /\b$Storage\b/ && $line !~ /^.\s*$Storage\b/) { |
Joe Perches | 000d1cc1 | 2011-07-25 17:13:25 -0700 | [diff] [blame] | 5213 | WARN("STORAGE_CLASS", |
| 5214 | "storage class should be at the beginning of the declaration\n" . $herecurr) |
Tobias Klauser | d4977c7 | 2010-05-24 14:33:30 -0700 | [diff] [blame] | 5215 | } |
| 5216 | |
Andy Whitcroft | de7d4f0 | 2007-07-15 23:37:22 -0700 | [diff] [blame] | 5217 | # check the location of the inline attribute, that it is between |
| 5218 | # storage class and type. |
Andy Whitcroft | 9c0ca6f | 2007-10-16 23:29:38 -0700 | [diff] [blame] | 5219 | if ($line =~ /\b$Type\s+$Inline\b/ || |
| 5220 | $line =~ /\b$Inline\s+$Storage\b/) { |
Joe Perches | 000d1cc1 | 2011-07-25 17:13:25 -0700 | [diff] [blame] | 5221 | ERROR("INLINE_LOCATION", |
| 5222 | "inline keyword should sit between storage class and type\n" . $herecurr); |
Andy Whitcroft | de7d4f0 | 2007-07-15 23:37:22 -0700 | [diff] [blame] | 5223 | } |
| 5224 | |
Andy Whitcroft | 8905a67 | 2007-11-28 16:21:06 -0800 | [diff] [blame] | 5225 | # Check for __inline__ and __inline, prefer inline |
Joe Perches | 2b7ab45 | 2013-11-12 15:10:14 -0800 | [diff] [blame] | 5226 | if ($realfile !~ m@\binclude/uapi/@ && |
| 5227 | $line =~ /\b(__inline__|__inline)\b/) { |
Joe Perches | d5e616f | 2013-09-11 14:23:54 -0700 | [diff] [blame] | 5228 | if (WARN("INLINE", |
| 5229 | "plain inline is preferred over $1\n" . $herecurr) && |
| 5230 | $fix) { |
Joe Perches | 194f66f | 2014-08-06 16:11:03 -0700 | [diff] [blame] | 5231 | $fixed[$fixlinenr] =~ s/\b(__inline__|__inline)\b/inline/; |
Joe Perches | d5e616f | 2013-09-11 14:23:54 -0700 | [diff] [blame] | 5232 | |
| 5233 | } |
Andy Whitcroft | 8905a67 | 2007-11-28 16:21:06 -0800 | [diff] [blame] | 5234 | } |
| 5235 | |
Joe Perches | 3d130fd | 2011-01-12 17:00:00 -0800 | [diff] [blame] | 5236 | # Check for __attribute__ packed, prefer __packed |
Joe Perches | 2b7ab45 | 2013-11-12 15:10:14 -0800 | [diff] [blame] | 5237 | if ($realfile !~ m@\binclude/uapi/@ && |
| 5238 | $line =~ /\b__attribute__\s*\(\s*\(.*\bpacked\b/) { |
Joe Perches | 000d1cc1 | 2011-07-25 17:13:25 -0700 | [diff] [blame] | 5239 | WARN("PREFER_PACKED", |
| 5240 | "__packed is preferred over __attribute__((packed))\n" . $herecurr); |
Joe Perches | 3d130fd | 2011-01-12 17:00:00 -0800 | [diff] [blame] | 5241 | } |
| 5242 | |
Joe Perches | 39b7e28 | 2011-07-25 17:13:24 -0700 | [diff] [blame] | 5243 | # Check for __attribute__ aligned, prefer __aligned |
Joe Perches | 2b7ab45 | 2013-11-12 15:10:14 -0800 | [diff] [blame] | 5244 | if ($realfile !~ m@\binclude/uapi/@ && |
| 5245 | $line =~ /\b__attribute__\s*\(\s*\(.*aligned/) { |
Joe Perches | 000d1cc1 | 2011-07-25 17:13:25 -0700 | [diff] [blame] | 5246 | WARN("PREFER_ALIGNED", |
| 5247 | "__aligned(size) is preferred over __attribute__((aligned(size)))\n" . $herecurr); |
Joe Perches | 39b7e28 | 2011-07-25 17:13:24 -0700 | [diff] [blame] | 5248 | } |
| 5249 | |
Joe Perches | 5f14d3b | 2012-01-10 15:09:52 -0800 | [diff] [blame] | 5250 | # Check for __attribute__ format(printf, prefer __printf |
Joe Perches | 2b7ab45 | 2013-11-12 15:10:14 -0800 | [diff] [blame] | 5251 | if ($realfile !~ m@\binclude/uapi/@ && |
| 5252 | $line =~ /\b__attribute__\s*\(\s*\(\s*format\s*\(\s*printf/) { |
Joe Perches | d5e616f | 2013-09-11 14:23:54 -0700 | [diff] [blame] | 5253 | if (WARN("PREFER_PRINTF", |
| 5254 | "__printf(string-index, first-to-check) is preferred over __attribute__((format(printf, string-index, first-to-check)))\n" . $herecurr) && |
| 5255 | $fix) { |
Joe Perches | 194f66f | 2014-08-06 16:11:03 -0700 | [diff] [blame] | 5256 | $fixed[$fixlinenr] =~ s/\b__attribute__\s*\(\s*\(\s*format\s*\(\s*printf\s*,\s*(.*)\)\s*\)\s*\)/"__printf(" . trim($1) . ")"/ex; |
Joe Perches | d5e616f | 2013-09-11 14:23:54 -0700 | [diff] [blame] | 5257 | |
| 5258 | } |
Joe Perches | 5f14d3b | 2012-01-10 15:09:52 -0800 | [diff] [blame] | 5259 | } |
| 5260 | |
Joe Perches | 6061d94 | 2012-03-23 15:02:16 -0700 | [diff] [blame] | 5261 | # Check for __attribute__ format(scanf, prefer __scanf |
Joe Perches | 2b7ab45 | 2013-11-12 15:10:14 -0800 | [diff] [blame] | 5262 | if ($realfile !~ m@\binclude/uapi/@ && |
| 5263 | $line =~ /\b__attribute__\s*\(\s*\(\s*format\s*\(\s*scanf\b/) { |
Joe Perches | d5e616f | 2013-09-11 14:23:54 -0700 | [diff] [blame] | 5264 | if (WARN("PREFER_SCANF", |
| 5265 | "__scanf(string-index, first-to-check) is preferred over __attribute__((format(scanf, string-index, first-to-check)))\n" . $herecurr) && |
| 5266 | $fix) { |
Joe Perches | 194f66f | 2014-08-06 16:11:03 -0700 | [diff] [blame] | 5267 | $fixed[$fixlinenr] =~ s/\b__attribute__\s*\(\s*\(\s*format\s*\(\s*scanf\s*,\s*(.*)\)\s*\)\s*\)/"__scanf(" . trim($1) . ")"/ex; |
Joe Perches | d5e616f | 2013-09-11 14:23:54 -0700 | [diff] [blame] | 5268 | } |
Joe Perches | 6061d94 | 2012-03-23 15:02:16 -0700 | [diff] [blame] | 5269 | } |
| 5270 | |
Joe Perches | 619a908 | 2014-12-10 15:51:35 -0800 | [diff] [blame] | 5271 | # Check for __attribute__ weak, or __weak declarations (may have link issues) |
| 5272 | if ($^V && $^V ge 5.10.0 && |
| 5273 | $line =~ /(?:$Declare|$DeclareMisordered)\s*$Ident\s*$balanced_parens\s*(?:$Attribute)?\s*;/ && |
| 5274 | ($line =~ /\b__attribute__\s*\(\s*\(.*\bweak\b/ || |
| 5275 | $line =~ /\b__weak\b/)) { |
| 5276 | ERROR("WEAK_DECLARATION", |
| 5277 | "Using weak declarations can have unintended link defects\n" . $herecurr); |
| 5278 | } |
| 5279 | |
Joe Perches | e6176fa | 2015-06-25 15:02:49 -0700 | [diff] [blame] | 5280 | # check for c99 types like uint8_t used outside of uapi/ |
| 5281 | if ($realfile !~ m@\binclude/uapi/@ && |
| 5282 | $line =~ /\b($Declare)\s*$Ident\s*[=;,\[]/) { |
| 5283 | my $type = $1; |
| 5284 | if ($type =~ /\b($typeC99Typedefs)\b/) { |
| 5285 | $type = $1; |
| 5286 | my $kernel_type = 'u'; |
| 5287 | $kernel_type = 's' if ($type =~ /^_*[si]/); |
| 5288 | $type =~ /(\d+)/; |
| 5289 | $kernel_type .= $1; |
| 5290 | if (CHK("PREFER_KERNEL_TYPES", |
| 5291 | "Prefer kernel type '$kernel_type' over '$type'\n" . $herecurr) && |
| 5292 | $fix) { |
| 5293 | $fixed[$fixlinenr] =~ s/\b$type\b/$kernel_type/; |
| 5294 | } |
| 5295 | } |
| 5296 | } |
| 5297 | |
Joe Perches | 938224b | 2016-01-20 14:59:15 -0800 | [diff] [blame] | 5298 | # check for cast of C90 native int or longer types constants |
| 5299 | if ($line =~ /(\(\s*$C90_int_types\s*\)\s*)($Constant)\b/) { |
| 5300 | my $cast = $1; |
| 5301 | my $const = $2; |
| 5302 | if (WARN("TYPECAST_INT_CONSTANT", |
| 5303 | "Unnecessary typecast of c90 int constant\n" . $herecurr) && |
| 5304 | $fix) { |
| 5305 | my $suffix = ""; |
| 5306 | my $newconst = $const; |
| 5307 | $newconst =~ s/${Int_type}$//; |
| 5308 | $suffix .= 'U' if ($cast =~ /\bunsigned\b/); |
| 5309 | if ($cast =~ /\blong\s+long\b/) { |
| 5310 | $suffix .= 'LL'; |
| 5311 | } elsif ($cast =~ /\blong\b/) { |
| 5312 | $suffix .= 'L'; |
| 5313 | } |
| 5314 | $fixed[$fixlinenr] =~ s/\Q$cast\E$const\b/$newconst$suffix/; |
| 5315 | } |
| 5316 | } |
| 5317 | |
Joe Perches | 8f53a9b | 2010-03-05 13:43:48 -0800 | [diff] [blame] | 5318 | # check for sizeof(&) |
| 5319 | if ($line =~ /\bsizeof\s*\(\s*\&/) { |
Joe Perches | 000d1cc1 | 2011-07-25 17:13:25 -0700 | [diff] [blame] | 5320 | WARN("SIZEOF_ADDRESS", |
| 5321 | "sizeof(& should be avoided\n" . $herecurr); |
Joe Perches | 8f53a9b | 2010-03-05 13:43:48 -0800 | [diff] [blame] | 5322 | } |
| 5323 | |
Joe Perches | 66c80b6 | 2012-07-30 14:41:22 -0700 | [diff] [blame] | 5324 | # check for sizeof without parenthesis |
| 5325 | if ($line =~ /\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/) { |
Joe Perches | d5e616f | 2013-09-11 14:23:54 -0700 | [diff] [blame] | 5326 | if (WARN("SIZEOF_PARENTHESIS", |
| 5327 | "sizeof $1 should be sizeof($1)\n" . $herecurr) && |
| 5328 | $fix) { |
Joe Perches | 194f66f | 2014-08-06 16:11:03 -0700 | [diff] [blame] | 5329 | $fixed[$fixlinenr] =~ s/\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/"sizeof(" . trim($1) . ")"/ex; |
Joe Perches | d5e616f | 2013-09-11 14:23:54 -0700 | [diff] [blame] | 5330 | } |
Joe Perches | 66c80b6 | 2012-07-30 14:41:22 -0700 | [diff] [blame] | 5331 | } |
| 5332 | |
Joe Perches | 88982fe | 2012-12-17 16:02:00 -0800 | [diff] [blame] | 5333 | # check for struct spinlock declarations |
| 5334 | if ($line =~ /^.\s*\bstruct\s+spinlock\s+\w+\s*;/) { |
| 5335 | WARN("USE_SPINLOCK_T", |
| 5336 | "struct spinlock should be spinlock_t\n" . $herecurr); |
| 5337 | } |
| 5338 | |
Joe Perches | a6962d7 | 2013-04-29 16:18:13 -0700 | [diff] [blame] | 5339 | # check for seq_printf uses that could be seq_puts |
Joe Perches | 0666872 | 2013-11-12 15:10:07 -0800 | [diff] [blame] | 5340 | if ($sline =~ /\bseq_printf\s*\(.*"\s*\)\s*;\s*$/) { |
Joe Perches | a6962d7 | 2013-04-29 16:18:13 -0700 | [diff] [blame] | 5341 | my $fmt = get_quoted_string($line, $rawline); |
Heba Aamer | caac1d5 | 2015-02-13 14:38:49 -0800 | [diff] [blame] | 5342 | $fmt =~ s/%%//g; |
| 5343 | if ($fmt !~ /%/) { |
Joe Perches | d5e616f | 2013-09-11 14:23:54 -0700 | [diff] [blame] | 5344 | if (WARN("PREFER_SEQ_PUTS", |
| 5345 | "Prefer seq_puts to seq_printf\n" . $herecurr) && |
| 5346 | $fix) { |
Joe Perches | 194f66f | 2014-08-06 16:11:03 -0700 | [diff] [blame] | 5347 | $fixed[$fixlinenr] =~ s/\bseq_printf\b/seq_puts/; |
Joe Perches | d5e616f | 2013-09-11 14:23:54 -0700 | [diff] [blame] | 5348 | } |
Joe Perches | a6962d7 | 2013-04-29 16:18:13 -0700 | [diff] [blame] | 5349 | } |
| 5350 | } |
| 5351 | |
Andy Whitcroft | 554e165 | 2012-01-10 15:09:57 -0800 | [diff] [blame] | 5352 | # Check for misused memsets |
Joe Perches | d1fe9c0 | 2012-03-23 15:02:16 -0700 | [diff] [blame] | 5353 | if ($^V && $^V ge 5.10.0 && |
| 5354 | defined $stat && |
Mateusz Kulikowski | 9e20a85 | 2015-06-25 15:03:16 -0700 | [diff] [blame] | 5355 | $stat =~ /^\+(?:.*?)\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*$FuncArg\s*\)/) { |
Andy Whitcroft | 554e165 | 2012-01-10 15:09:57 -0800 | [diff] [blame] | 5356 | |
Joe Perches | d7c76ba | 2012-01-10 15:09:58 -0800 | [diff] [blame] | 5357 | my $ms_addr = $2; |
Joe Perches | d1fe9c0 | 2012-03-23 15:02:16 -0700 | [diff] [blame] | 5358 | my $ms_val = $7; |
| 5359 | my $ms_size = $12; |
Joe Perches | d7c76ba | 2012-01-10 15:09:58 -0800 | [diff] [blame] | 5360 | |
Andy Whitcroft | 554e165 | 2012-01-10 15:09:57 -0800 | [diff] [blame] | 5361 | if ($ms_size =~ /^(0x|)0$/i) { |
| 5362 | ERROR("MEMSET", |
Joe Perches | d7c76ba | 2012-01-10 15:09:58 -0800 | [diff] [blame] | 5363 | "memset to 0's uses 0 as the 2nd argument, not the 3rd\n" . "$here\n$stat\n"); |
Andy Whitcroft | 554e165 | 2012-01-10 15:09:57 -0800 | [diff] [blame] | 5364 | } elsif ($ms_size =~ /^(0x|)1$/i) { |
| 5365 | WARN("MEMSET", |
Joe Perches | d7c76ba | 2012-01-10 15:09:58 -0800 | [diff] [blame] | 5366 | "single byte memset is suspicious. Swapped 2nd/3rd argument?\n" . "$here\n$stat\n"); |
| 5367 | } |
| 5368 | } |
| 5369 | |
Joe Perches | 98a9bba | 2014-01-23 15:54:52 -0800 | [diff] [blame] | 5370 | # Check for memcpy(foo, bar, ETH_ALEN) that could be ether_addr_copy(foo, bar) |
| 5371 | if ($^V && $^V ge 5.10.0 && |
Mateusz Kulikowski | 10895d2 | 2015-06-25 15:03:21 -0700 | [diff] [blame] | 5372 | defined $stat && |
| 5373 | $stat =~ /^\+(?:.*?)\bmemcpy\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/) { |
Joe Perches | 98a9bba | 2014-01-23 15:54:52 -0800 | [diff] [blame] | 5374 | if (WARN("PREFER_ETHER_ADDR_COPY", |
Mateusz Kulikowski | 10895d2 | 2015-06-25 15:03:21 -0700 | [diff] [blame] | 5375 | "Prefer ether_addr_copy() over memcpy() if the Ethernet addresses are __aligned(2)\n" . "$here\n$stat\n") && |
Joe Perches | 98a9bba | 2014-01-23 15:54:52 -0800 | [diff] [blame] | 5376 | $fix) { |
Joe Perches | 194f66f | 2014-08-06 16:11:03 -0700 | [diff] [blame] | 5377 | $fixed[$fixlinenr] =~ s/\bmemcpy\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/ether_addr_copy($2, $7)/; |
Joe Perches | 98a9bba | 2014-01-23 15:54:52 -0800 | [diff] [blame] | 5378 | } |
| 5379 | } |
| 5380 | |
Mateusz Kulikowski | b6117d1 | 2015-06-25 15:03:13 -0700 | [diff] [blame] | 5381 | # Check for memcmp(foo, bar, ETH_ALEN) that could be ether_addr_equal*(foo, bar) |
| 5382 | if ($^V && $^V ge 5.10.0 && |
| 5383 | defined $stat && |
| 5384 | $stat =~ /^\+(?:.*?)\bmemcmp\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/) { |
| 5385 | WARN("PREFER_ETHER_ADDR_EQUAL", |
| 5386 | "Prefer ether_addr_equal() or ether_addr_equal_unaligned() over memcmp()\n" . "$here\n$stat\n") |
| 5387 | } |
| 5388 | |
Mateusz Kulikowski | 8617cd0 | 2015-06-25 15:03:19 -0700 | [diff] [blame] | 5389 | # check for memset(foo, 0x0, ETH_ALEN) that could be eth_zero_addr |
| 5390 | # check for memset(foo, 0xFF, ETH_ALEN) that could be eth_broadcast_addr |
| 5391 | if ($^V && $^V ge 5.10.0 && |
| 5392 | defined $stat && |
| 5393 | $stat =~ /^\+(?:.*?)\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/) { |
| 5394 | |
| 5395 | my $ms_val = $7; |
| 5396 | |
| 5397 | if ($ms_val =~ /^(?:0x|)0+$/i) { |
| 5398 | if (WARN("PREFER_ETH_ZERO_ADDR", |
| 5399 | "Prefer eth_zero_addr over memset()\n" . "$here\n$stat\n") && |
| 5400 | $fix) { |
| 5401 | $fixed[$fixlinenr] =~ s/\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*,\s*ETH_ALEN\s*\)/eth_zero_addr($2)/; |
| 5402 | } |
| 5403 | } elsif ($ms_val =~ /^(?:0xff|255)$/i) { |
| 5404 | if (WARN("PREFER_ETH_BROADCAST_ADDR", |
| 5405 | "Prefer eth_broadcast_addr() over memset()\n" . "$here\n$stat\n") && |
| 5406 | $fix) { |
| 5407 | $fixed[$fixlinenr] =~ s/\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*,\s*ETH_ALEN\s*\)/eth_broadcast_addr($2)/; |
| 5408 | } |
| 5409 | } |
| 5410 | } |
| 5411 | |
Joe Perches | d7c76ba | 2012-01-10 15:09:58 -0800 | [diff] [blame] | 5412 | # typecasts on min/max could be min_t/max_t |
Joe Perches | d1fe9c0 | 2012-03-23 15:02:16 -0700 | [diff] [blame] | 5413 | if ($^V && $^V ge 5.10.0 && |
| 5414 | defined $stat && |
Joe Perches | d7c76ba | 2012-01-10 15:09:58 -0800 | [diff] [blame] | 5415 | $stat =~ /^\+(?:.*?)\b(min|max)\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\)/) { |
Joe Perches | d1fe9c0 | 2012-03-23 15:02:16 -0700 | [diff] [blame] | 5416 | if (defined $2 || defined $7) { |
Joe Perches | d7c76ba | 2012-01-10 15:09:58 -0800 | [diff] [blame] | 5417 | my $call = $1; |
| 5418 | my $cast1 = deparenthesize($2); |
| 5419 | my $arg1 = $3; |
Joe Perches | d1fe9c0 | 2012-03-23 15:02:16 -0700 | [diff] [blame] | 5420 | my $cast2 = deparenthesize($7); |
| 5421 | my $arg2 = $8; |
Joe Perches | d7c76ba | 2012-01-10 15:09:58 -0800 | [diff] [blame] | 5422 | my $cast; |
| 5423 | |
Joe Perches | d1fe9c0 | 2012-03-23 15:02:16 -0700 | [diff] [blame] | 5424 | if ($cast1 ne "" && $cast2 ne "" && $cast1 ne $cast2) { |
Joe Perches | d7c76ba | 2012-01-10 15:09:58 -0800 | [diff] [blame] | 5425 | $cast = "$cast1 or $cast2"; |
| 5426 | } elsif ($cast1 ne "") { |
| 5427 | $cast = $cast1; |
| 5428 | } else { |
| 5429 | $cast = $cast2; |
| 5430 | } |
| 5431 | WARN("MINMAX", |
| 5432 | "$call() should probably be ${call}_t($cast, $arg1, $arg2)\n" . "$here\n$stat\n"); |
Andy Whitcroft | 554e165 | 2012-01-10 15:09:57 -0800 | [diff] [blame] | 5433 | } |
| 5434 | } |
| 5435 | |
Joe Perches | 4a27319 | 2012-07-30 14:41:20 -0700 | [diff] [blame] | 5436 | # check usleep_range arguments |
| 5437 | if ($^V && $^V ge 5.10.0 && |
| 5438 | defined $stat && |
| 5439 | $stat =~ /^\+(?:.*?)\busleep_range\s*\(\s*($FuncArg)\s*,\s*($FuncArg)\s*\)/) { |
| 5440 | my $min = $1; |
| 5441 | my $max = $7; |
| 5442 | if ($min eq $max) { |
| 5443 | WARN("USLEEP_RANGE", |
| 5444 | "usleep_range should not use min == max args; see Documentation/timers/timers-howto.txt\n" . "$here\n$stat\n"); |
| 5445 | } elsif ($min =~ /^\d+$/ && $max =~ /^\d+$/ && |
| 5446 | $min > $max) { |
| 5447 | WARN("USLEEP_RANGE", |
| 5448 | "usleep_range args reversed, use min then max; see Documentation/timers/timers-howto.txt\n" . "$here\n$stat\n"); |
| 5449 | } |
| 5450 | } |
| 5451 | |
Joe Perches | 823b794 | 2013-11-12 15:10:15 -0800 | [diff] [blame] | 5452 | # check for naked sscanf |
| 5453 | if ($^V && $^V ge 5.10.0 && |
| 5454 | defined $stat && |
Joe Perches | 6c8bd70 | 2014-04-03 14:49:16 -0700 | [diff] [blame] | 5455 | $line =~ /\bsscanf\b/ && |
Joe Perches | 823b794 | 2013-11-12 15:10:15 -0800 | [diff] [blame] | 5456 | ($stat !~ /$Ident\s*=\s*sscanf\s*$balanced_parens/ && |
| 5457 | $stat !~ /\bsscanf\s*$balanced_parens\s*(?:$Compare)/ && |
| 5458 | $stat !~ /(?:$Compare)\s*\bsscanf\s*$balanced_parens/)) { |
| 5459 | my $lc = $stat =~ tr@\n@@; |
| 5460 | $lc = $lc + $linenr; |
| 5461 | my $stat_real = raw_line($linenr, 0); |
| 5462 | for (my $count = $linenr + 1; $count <= $lc; $count++) { |
| 5463 | $stat_real = $stat_real . "\n" . raw_line($count, 0); |
| 5464 | } |
| 5465 | WARN("NAKED_SSCANF", |
| 5466 | "unchecked sscanf return value\n" . "$here\n$stat_real\n"); |
| 5467 | } |
| 5468 | |
Joe Perches | afc819a | 2014-06-04 16:12:08 -0700 | [diff] [blame] | 5469 | # check for simple sscanf that should be kstrto<foo> |
| 5470 | if ($^V && $^V ge 5.10.0 && |
| 5471 | defined $stat && |
| 5472 | $line =~ /\bsscanf\b/) { |
| 5473 | my $lc = $stat =~ tr@\n@@; |
| 5474 | $lc = $lc + $linenr; |
| 5475 | my $stat_real = raw_line($linenr, 0); |
| 5476 | for (my $count = $linenr + 1; $count <= $lc; $count++) { |
| 5477 | $stat_real = $stat_real . "\n" . raw_line($count, 0); |
| 5478 | } |
| 5479 | if ($stat_real =~ /\bsscanf\b\s*\(\s*$FuncArg\s*,\s*("[^"]+")/) { |
| 5480 | my $format = $6; |
| 5481 | my $count = $format =~ tr@%@%@; |
| 5482 | if ($count == 1 && |
| 5483 | $format =~ /^"\%(?i:ll[udxi]|[udxi]ll|ll|[hl]h?[udxi]|[udxi][hl]h?|[hl]h?|[udxi])"$/) { |
| 5484 | WARN("SSCANF_TO_KSTRTO", |
| 5485 | "Prefer kstrto<type> to single variable sscanf\n" . "$here\n$stat_real\n"); |
| 5486 | } |
| 5487 | } |
| 5488 | } |
| 5489 | |
Joe Perches | 70dc8a4 | 2013-09-11 14:23:58 -0700 | [diff] [blame] | 5490 | # check for new externs in .h files. |
| 5491 | if ($realfile =~ /\.h$/ && |
| 5492 | $line =~ /^\+\s*(extern\s+)$Type\s*$Ident\s*\(/s) { |
Joe Perches | d1d8578 | 2013-09-24 15:27:46 -0700 | [diff] [blame] | 5493 | if (CHK("AVOID_EXTERNS", |
| 5494 | "extern prototypes should be avoided in .h files\n" . $herecurr) && |
Joe Perches | 70dc8a4 | 2013-09-11 14:23:58 -0700 | [diff] [blame] | 5495 | $fix) { |
Joe Perches | 194f66f | 2014-08-06 16:11:03 -0700 | [diff] [blame] | 5496 | $fixed[$fixlinenr] =~ s/(.*)\bextern\b\s*(.*)/$1$2/; |
Joe Perches | 70dc8a4 | 2013-09-11 14:23:58 -0700 | [diff] [blame] | 5497 | } |
| 5498 | } |
| 5499 | |
Andy Whitcroft | de7d4f0 | 2007-07-15 23:37:22 -0700 | [diff] [blame] | 5500 | # check for new externs in .c files. |
Andy Whitcroft | 171ae1a | 2008-04-29 00:59:32 -0700 | [diff] [blame] | 5501 | if ($realfile =~ /\.c$/ && defined $stat && |
Andy Whitcroft | c45dcab | 2008-06-05 22:46:01 -0700 | [diff] [blame] | 5502 | $stat =~ /^.\s*(?:extern\s+)?$Type\s+($Ident)(\s*)\(/s) |
Andy Whitcroft | 171ae1a | 2008-04-29 00:59:32 -0700 | [diff] [blame] | 5503 | { |
Andy Whitcroft | c45dcab | 2008-06-05 22:46:01 -0700 | [diff] [blame] | 5504 | my $function_name = $1; |
| 5505 | my $paren_space = $2; |
Andy Whitcroft | 171ae1a | 2008-04-29 00:59:32 -0700 | [diff] [blame] | 5506 | |
| 5507 | my $s = $stat; |
| 5508 | if (defined $cond) { |
| 5509 | substr($s, 0, length($cond), ''); |
| 5510 | } |
Andy Whitcroft | c45dcab | 2008-06-05 22:46:01 -0700 | [diff] [blame] | 5511 | if ($s =~ /^\s*;/ && |
| 5512 | $function_name ne 'uninitialized_var') |
| 5513 | { |
Joe Perches | 000d1cc1 | 2011-07-25 17:13:25 -0700 | [diff] [blame] | 5514 | WARN("AVOID_EXTERNS", |
| 5515 | "externs should be avoided in .c files\n" . $herecurr); |
Andy Whitcroft | 171ae1a | 2008-04-29 00:59:32 -0700 | [diff] [blame] | 5516 | } |
| 5517 | |
| 5518 | if ($paren_space =~ /\n/) { |
Joe Perches | 000d1cc1 | 2011-07-25 17:13:25 -0700 | [diff] [blame] | 5519 | WARN("FUNCTION_ARGUMENTS", |
| 5520 | "arguments for function declarations should follow identifier\n" . $herecurr); |
Andy Whitcroft | 171ae1a | 2008-04-29 00:59:32 -0700 | [diff] [blame] | 5521 | } |
Andy Whitcroft | 9c9ba34 | 2008-04-29 00:59:33 -0700 | [diff] [blame] | 5522 | |
| 5523 | } elsif ($realfile =~ /\.c$/ && defined $stat && |
| 5524 | $stat =~ /^.\s*extern\s+/) |
| 5525 | { |
Joe Perches | 000d1cc1 | 2011-07-25 17:13:25 -0700 | [diff] [blame] | 5526 | WARN("AVOID_EXTERNS", |
| 5527 | "externs should be avoided in .c files\n" . $herecurr); |
Andy Whitcroft | de7d4f0 | 2007-07-15 23:37:22 -0700 | [diff] [blame] | 5528 | } |
| 5529 | |
| 5530 | # checks for new __setup's |
| 5531 | if ($rawline =~ /\b__setup\("([^"]*)"/) { |
| 5532 | my $name = $1; |
| 5533 | |
| 5534 | if (!grep(/$name/, @setup_docs)) { |
Joe Perches | 000d1cc1 | 2011-07-25 17:13:25 -0700 | [diff] [blame] | 5535 | CHK("UNDOCUMENTED_SETUP", |
| 5536 | "__setup appears un-documented -- check Documentation/kernel-parameters.txt\n" . $herecurr); |
Andy Whitcroft | de7d4f0 | 2007-07-15 23:37:22 -0700 | [diff] [blame] | 5537 | } |
Andy Whitcroft | 653d487 | 2007-06-23 17:16:34 -0700 | [diff] [blame] | 5538 | } |
Andy Whitcroft | 9c0ca6f | 2007-10-16 23:29:38 -0700 | [diff] [blame] | 5539 | |
| 5540 | # check for pointless casting of kmalloc return |
Joe Perches | caf2a54 | 2011-01-12 16:59:56 -0800 | [diff] [blame] | 5541 | if ($line =~ /\*\s*\)\s*[kv][czm]alloc(_node){0,1}\b/) { |
Joe Perches | 000d1cc1 | 2011-07-25 17:13:25 -0700 | [diff] [blame] | 5542 | WARN("UNNECESSARY_CASTS", |
| 5543 | "unnecessary cast may hide bugs, see http://c-faq.com/malloc/mallocnocast.html\n" . $herecurr); |
Andy Whitcroft | 9c0ca6f | 2007-10-16 23:29:38 -0700 | [diff] [blame] | 5544 | } |
Andy Whitcroft | 13214ad | 2008-02-08 04:22:03 -0800 | [diff] [blame] | 5545 | |
Joe Perches | a640d25 | 2013-07-03 15:05:21 -0700 | [diff] [blame] | 5546 | # alloc style |
| 5547 | # p = alloc(sizeof(struct foo), ...) should be p = alloc(sizeof(*p), ...) |
| 5548 | if ($^V && $^V ge 5.10.0 && |
| 5549 | $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*([kv][mz]alloc(?:_node)?)\s*\(\s*(sizeof\s*\(\s*struct\s+$Lval\s*\))/) { |
| 5550 | CHK("ALLOC_SIZEOF_STRUCT", |
| 5551 | "Prefer $3(sizeof(*$1)...) over $3($4...)\n" . $herecurr); |
| 5552 | } |
| 5553 | |
Joe Perches | 60a5536 | 2014-06-04 16:12:07 -0700 | [diff] [blame] | 5554 | # check for k[mz]alloc with multiplies that could be kmalloc_array/kcalloc |
| 5555 | if ($^V && $^V ge 5.10.0 && |
Joe Perches | e367455 | 2014-08-06 16:10:55 -0700 | [diff] [blame] | 5556 | $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*(k[mz]alloc)\s*\(\s*($FuncArg)\s*\*\s*($FuncArg)\s*,/) { |
Joe Perches | 60a5536 | 2014-06-04 16:12:07 -0700 | [diff] [blame] | 5557 | my $oldfunc = $3; |
| 5558 | my $a1 = $4; |
| 5559 | my $a2 = $10; |
| 5560 | my $newfunc = "kmalloc_array"; |
| 5561 | $newfunc = "kcalloc" if ($oldfunc eq "kzalloc"); |
Joe Perches | e367455 | 2014-08-06 16:10:55 -0700 | [diff] [blame] | 5562 | my $r1 = $a1; |
| 5563 | my $r2 = $a2; |
| 5564 | if ($a1 =~ /^sizeof\s*\S/) { |
| 5565 | $r1 = $a2; |
| 5566 | $r2 = $a1; |
| 5567 | } |
| 5568 | if ($r1 !~ /^sizeof\b/ && $r2 =~ /^sizeof\s*\S/ && |
| 5569 | !($r1 =~ /^$Constant$/ || $r1 =~ /^[A-Z_][A-Z0-9_]*$/)) { |
Joe Perches | 60a5536 | 2014-06-04 16:12:07 -0700 | [diff] [blame] | 5570 | if (WARN("ALLOC_WITH_MULTIPLY", |
| 5571 | "Prefer $newfunc over $oldfunc with multiply\n" . $herecurr) && |
| 5572 | $fix) { |
Joe Perches | 194f66f | 2014-08-06 16:11:03 -0700 | [diff] [blame] | 5573 | $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; |
Joe Perches | 60a5536 | 2014-06-04 16:12:07 -0700 | [diff] [blame] | 5574 | |
| 5575 | } |
| 5576 | } |
| 5577 | } |
| 5578 | |
Joe Perches | 972fdea | 2013-04-29 16:18:12 -0700 | [diff] [blame] | 5579 | # check for krealloc arg reuse |
| 5580 | if ($^V && $^V ge 5.10.0 && |
| 5581 | $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*krealloc\s*\(\s*\1\s*,/) { |
| 5582 | WARN("KREALLOC_ARG_REUSE", |
| 5583 | "Reusing the krealloc arg is almost always a bug\n" . $herecurr); |
| 5584 | } |
| 5585 | |
Joe Perches | 5ce59ae | 2013-02-21 16:44:18 -0800 | [diff] [blame] | 5586 | # check for alloc argument mismatch |
| 5587 | if ($line =~ /\b(kcalloc|kmalloc_array)\s*\(\s*sizeof\b/) { |
| 5588 | WARN("ALLOC_ARRAY_ARGS", |
| 5589 | "$1 uses number as first arg, sizeof is generally wrong\n" . $herecurr); |
| 5590 | } |
| 5591 | |
Joe Perches | caf2a54 | 2011-01-12 16:59:56 -0800 | [diff] [blame] | 5592 | # check for multiple semicolons |
| 5593 | if ($line =~ /;\s*;\s*$/) { |
Joe Perches | d5e616f | 2013-09-11 14:23:54 -0700 | [diff] [blame] | 5594 | if (WARN("ONE_SEMICOLON", |
| 5595 | "Statements terminations use 1 semicolon\n" . $herecurr) && |
| 5596 | $fix) { |
Joe Perches | 194f66f | 2014-08-06 16:11:03 -0700 | [diff] [blame] | 5597 | $fixed[$fixlinenr] =~ s/(\s*;\s*){2,}$/;/g; |
Joe Perches | d5e616f | 2013-09-11 14:23:54 -0700 | [diff] [blame] | 5598 | } |
Joe Perches | d1e2ad0 | 2012-12-17 16:02:01 -0800 | [diff] [blame] | 5599 | } |
| 5600 | |
Joe Perches | 0ab9019 | 2014-12-10 15:51:57 -0800 | [diff] [blame] | 5601 | # check for #defines like: 1 << <digit> that could be BIT(digit) |
| 5602 | if ($line =~ /#\s*define\s+\w+\s+\(?\s*1\s*([ulUL]*)\s*\<\<\s*(?:\d+|$Ident)\s*\)?/) { |
| 5603 | my $ull = ""; |
| 5604 | $ull = "_ULL" if (defined($1) && $1 =~ /ll/i); |
| 5605 | if (CHK("BIT_MACRO", |
| 5606 | "Prefer using the BIT$ull macro\n" . $herecurr) && |
| 5607 | $fix) { |
| 5608 | $fixed[$fixlinenr] =~ s/\(?\s*1\s*[ulUL]*\s*<<\s*(\d+|$Ident)\s*\)?/BIT${ull}($1)/; |
| 5609 | } |
| 5610 | } |
| 5611 | |
Joe Perches | e81f239 | 2014-08-06 16:11:25 -0700 | [diff] [blame] | 5612 | # check for case / default statements not preceded by break/fallthrough/switch |
Joe Perches | c34c09a | 2014-01-23 15:54:43 -0800 | [diff] [blame] | 5613 | if ($line =~ /^.\s*(?:case\s+(?:$Ident|$Constant)\s*|default):/) { |
| 5614 | my $has_break = 0; |
| 5615 | my $has_statement = 0; |
| 5616 | my $count = 0; |
| 5617 | my $prevline = $linenr; |
Joe Perches | e81f239 | 2014-08-06 16:11:25 -0700 | [diff] [blame] | 5618 | while ($prevline > 1 && ($file || $count < 3) && !$has_break) { |
Joe Perches | c34c09a | 2014-01-23 15:54:43 -0800 | [diff] [blame] | 5619 | $prevline--; |
| 5620 | my $rline = $rawlines[$prevline - 1]; |
| 5621 | my $fline = $lines[$prevline - 1]; |
| 5622 | last if ($fline =~ /^\@\@/); |
| 5623 | next if ($fline =~ /^\-/); |
| 5624 | next if ($fline =~ /^.(?:\s*(?:case\s+(?:$Ident|$Constant)[\s$;]*|default):[\s$;]*)*$/); |
| 5625 | $has_break = 1 if ($rline =~ /fall[\s_-]*(through|thru)/i); |
| 5626 | next if ($fline =~ /^.[\s$;]*$/); |
| 5627 | $has_statement = 1; |
| 5628 | $count++; |
| 5629 | $has_break = 1 if ($fline =~ /\bswitch\b|\b(?:break\s*;[\s$;]*$|return\b|goto\b|continue\b)/); |
| 5630 | } |
| 5631 | if (!$has_break && $has_statement) { |
| 5632 | WARN("MISSING_BREAK", |
| 5633 | "Possible switch case/default not preceeded by break or fallthrough comment\n" . $herecurr); |
| 5634 | } |
| 5635 | } |
| 5636 | |
Joe Perches | d1e2ad0 | 2012-12-17 16:02:01 -0800 | [diff] [blame] | 5637 | # check for switch/default statements without a break; |
| 5638 | if ($^V && $^V ge 5.10.0 && |
| 5639 | defined $stat && |
| 5640 | $stat =~ /^\+[$;\s]*(?:case[$;\s]+\w+[$;\s]*:[$;\s]*|)*[$;\s]*\bdefault[$;\s]*:[$;\s]*;/g) { |
| 5641 | my $ctx = ''; |
| 5642 | my $herectx = $here . "\n"; |
| 5643 | my $cnt = statement_rawlines($stat); |
| 5644 | for (my $n = 0; $n < $cnt; $n++) { |
| 5645 | $herectx .= raw_line($linenr, $n) . "\n"; |
| 5646 | } |
| 5647 | WARN("DEFAULT_NO_BREAK", |
| 5648 | "switch default: should use break\n" . $herectx); |
Joe Perches | caf2a54 | 2011-01-12 16:59:56 -0800 | [diff] [blame] | 5649 | } |
| 5650 | |
Andy Whitcroft | 13214ad | 2008-02-08 04:22:03 -0800 | [diff] [blame] | 5651 | # check for gcc specific __FUNCTION__ |
Joe Perches | d5e616f | 2013-09-11 14:23:54 -0700 | [diff] [blame] | 5652 | if ($line =~ /\b__FUNCTION__\b/) { |
| 5653 | if (WARN("USE_FUNC", |
| 5654 | "__func__ should be used instead of gcc specific __FUNCTION__\n" . $herecurr) && |
| 5655 | $fix) { |
Joe Perches | 194f66f | 2014-08-06 16:11:03 -0700 | [diff] [blame] | 5656 | $fixed[$fixlinenr] =~ s/\b__FUNCTION__\b/__func__/g; |
Joe Perches | d5e616f | 2013-09-11 14:23:54 -0700 | [diff] [blame] | 5657 | } |
Andy Whitcroft | 13214ad | 2008-02-08 04:22:03 -0800 | [diff] [blame] | 5658 | } |
Andy Whitcroft | 773647a | 2008-03-28 14:15:58 -0700 | [diff] [blame] | 5659 | |
Joe Perches | 62ec818 | 2015-02-13 14:38:18 -0800 | [diff] [blame] | 5660 | # check for uses of __DATE__, __TIME__, __TIMESTAMP__ |
| 5661 | while ($line =~ /\b(__(?:DATE|TIME|TIMESTAMP)__)\b/g) { |
| 5662 | ERROR("DATE_TIME", |
| 5663 | "Use of the '$1' macro makes the build non-deterministic\n" . $herecurr); |
| 5664 | } |
| 5665 | |
Joe Perches | 2c92488 | 2012-03-23 15:02:20 -0700 | [diff] [blame] | 5666 | # check for use of yield() |
| 5667 | if ($line =~ /\byield\s*\(\s*\)/) { |
| 5668 | WARN("YIELD", |
| 5669 | "Using yield() is generally wrong. See yield() kernel-doc (sched/core.c)\n" . $herecurr); |
| 5670 | } |
| 5671 | |
Joe Perches | 179f8f4 | 2013-07-03 15:05:30 -0700 | [diff] [blame] | 5672 | # check for comparisons against true and false |
| 5673 | if ($line =~ /\+\s*(.*?)\b(true|false|$Lval)\s*(==|\!=)\s*(true|false|$Lval)\b(.*)$/i) { |
| 5674 | my $lead = $1; |
| 5675 | my $arg = $2; |
| 5676 | my $test = $3; |
| 5677 | my $otype = $4; |
| 5678 | my $trail = $5; |
| 5679 | my $op = "!"; |
| 5680 | |
| 5681 | ($arg, $otype) = ($otype, $arg) if ($arg =~ /^(?:true|false)$/i); |
| 5682 | |
| 5683 | my $type = lc($otype); |
| 5684 | if ($type =~ /^(?:true|false)$/) { |
| 5685 | if (("$test" eq "==" && "$type" eq "true") || |
| 5686 | ("$test" eq "!=" && "$type" eq "false")) { |
| 5687 | $op = ""; |
| 5688 | } |
| 5689 | |
| 5690 | CHK("BOOL_COMPARISON", |
| 5691 | "Using comparison to $otype is error prone\n" . $herecurr); |
| 5692 | |
| 5693 | ## maybe suggesting a correct construct would better |
| 5694 | ## "Using comparison to $otype is error prone. Perhaps use '${lead}${op}${arg}${trail}'\n" . $herecurr); |
| 5695 | |
| 5696 | } |
| 5697 | } |
| 5698 | |
Thomas Gleixner | 4882720b | 2010-09-07 14:34:01 +0000 | [diff] [blame] | 5699 | # check for semaphores initialized locked |
| 5700 | if ($line =~ /^.\s*sema_init.+,\W?0\W?\)/) { |
Joe Perches | 000d1cc1 | 2011-07-25 17:13:25 -0700 | [diff] [blame] | 5701 | WARN("CONSIDER_COMPLETION", |
| 5702 | "consider using a completion\n" . $herecurr); |
Andy Whitcroft | 773647a | 2008-03-28 14:15:58 -0700 | [diff] [blame] | 5703 | } |
Joe Perches | 6712d85 | 2012-03-23 15:02:20 -0700 | [diff] [blame] | 5704 | |
Joe Perches | 67d0a07 | 2011-10-31 17:13:10 -0700 | [diff] [blame] | 5705 | # recommend kstrto* over simple_strto* and strict_strto* |
| 5706 | if ($line =~ /\b((simple|strict)_(strto(l|ll|ul|ull)))\s*\(/) { |
Joe Perches | 000d1cc1 | 2011-07-25 17:13:25 -0700 | [diff] [blame] | 5707 | WARN("CONSIDER_KSTRTO", |
Joe Perches | 67d0a07 | 2011-10-31 17:13:10 -0700 | [diff] [blame] | 5708 | "$1 is obsolete, use k$3 instead\n" . $herecurr); |
Andy Whitcroft | 773647a | 2008-03-28 14:15:58 -0700 | [diff] [blame] | 5709 | } |
Joe Perches | 6712d85 | 2012-03-23 15:02:20 -0700 | [diff] [blame] | 5710 | |
Fabian Frederick | ae3ccc4 | 2014-06-04 16:12:10 -0700 | [diff] [blame] | 5711 | # check for __initcall(), use device_initcall() explicitly or more appropriate function please |
Michael Ellerman | f3db663 | 2008-07-23 21:28:57 -0700 | [diff] [blame] | 5712 | if ($line =~ /^.\s*__initcall\s*\(/) { |
Joe Perches | 000d1cc1 | 2011-07-25 17:13:25 -0700 | [diff] [blame] | 5713 | WARN("USE_DEVICE_INITCALL", |
Fabian Frederick | ae3ccc4 | 2014-06-04 16:12:10 -0700 | [diff] [blame] | 5714 | "please use device_initcall() or more appropriate function instead of __initcall() (see include/linux/init.h)\n" . $herecurr); |
Michael Ellerman | f3db663 | 2008-07-23 21:28:57 -0700 | [diff] [blame] | 5715 | } |
Joe Perches | 6712d85 | 2012-03-23 15:02:20 -0700 | [diff] [blame] | 5716 | |
Joe Perches | 0f3c5aa | 2015-02-13 14:39:05 -0800 | [diff] [blame] | 5717 | # check for various structs that are normally const (ops, kgdb, device_tree) |
| 5718 | my $const_structs = qr{ |
| 5719 | acpi_dock_ops| |
Emese Revfy | 7940484 | 2010-03-05 13:43:53 -0800 | [diff] [blame] | 5720 | address_space_operations| |
| 5721 | backlight_ops| |
| 5722 | block_device_operations| |
| 5723 | dentry_operations| |
| 5724 | dev_pm_ops| |
| 5725 | dma_map_ops| |
| 5726 | extent_io_ops| |
| 5727 | file_lock_operations| |
| 5728 | file_operations| |
| 5729 | hv_ops| |
| 5730 | ide_dma_ops| |
| 5731 | intel_dvo_dev_ops| |
| 5732 | item_operations| |
| 5733 | iwl_ops| |
| 5734 | kgdb_arch| |
| 5735 | kgdb_io| |
| 5736 | kset_uevent_ops| |
| 5737 | lock_manager_operations| |
| 5738 | microcode_ops| |
| 5739 | mtrr_ops| |
| 5740 | neigh_ops| |
| 5741 | nlmsvc_binding| |
Joe Perches | 0f3c5aa | 2015-02-13 14:39:05 -0800 | [diff] [blame] | 5742 | of_device_id| |
Emese Revfy | 7940484 | 2010-03-05 13:43:53 -0800 | [diff] [blame] | 5743 | pci_raw_ops| |
| 5744 | pipe_buf_operations| |
| 5745 | platform_hibernation_ops| |
| 5746 | platform_suspend_ops| |
| 5747 | proto_ops| |
| 5748 | rpc_pipe_ops| |
| 5749 | seq_operations| |
| 5750 | snd_ac97_build_ops| |
| 5751 | soc_pcmcia_socket_ops| |
| 5752 | stacktrace_ops| |
| 5753 | sysfs_ops| |
| 5754 | tty_operations| |
Joe Perches | 6d07d01b | 2015-04-16 12:44:33 -0700 | [diff] [blame] | 5755 | uart_ops| |
Emese Revfy | 7940484 | 2010-03-05 13:43:53 -0800 | [diff] [blame] | 5756 | usb_mon_operations| |
| 5757 | wd_ops}x; |
Andy Whitcroft | 6903ffb | 2009-01-15 13:51:07 -0800 | [diff] [blame] | 5758 | if ($line !~ /\bconst\b/ && |
Joe Perches | 0f3c5aa | 2015-02-13 14:39:05 -0800 | [diff] [blame] | 5759 | $line =~ /\bstruct\s+($const_structs)\b/) { |
Joe Perches | 000d1cc1 | 2011-07-25 17:13:25 -0700 | [diff] [blame] | 5760 | WARN("CONST_STRUCT", |
| 5761 | "struct $1 should normally be const\n" . |
Andy Whitcroft | 6903ffb | 2009-01-15 13:51:07 -0800 | [diff] [blame] | 5762 | $herecurr); |
Andy Whitcroft | 2b6db5c | 2009-01-06 14:41:29 -0800 | [diff] [blame] | 5763 | } |
Andy Whitcroft | 773647a | 2008-03-28 14:15:58 -0700 | [diff] [blame] | 5764 | |
| 5765 | # use of NR_CPUS is usually wrong |
| 5766 | # ignore definitions of NR_CPUS and usage to define arrays as likely right |
| 5767 | if ($line =~ /\bNR_CPUS\b/ && |
Andy Whitcroft | c45dcab | 2008-06-05 22:46:01 -0700 | [diff] [blame] | 5768 | $line !~ /^.\s*\s*#\s*if\b.*\bNR_CPUS\b/ && |
| 5769 | $line !~ /^.\s*\s*#\s*define\b.*\bNR_CPUS\b/ && |
Andy Whitcroft | 171ae1a | 2008-04-29 00:59:32 -0700 | [diff] [blame] | 5770 | $line !~ /^.\s*$Declare\s.*\[[^\]]*NR_CPUS[^\]]*\]/ && |
| 5771 | $line !~ /\[[^\]]*\.\.\.[^\]]*NR_CPUS[^\]]*\]/ && |
| 5772 | $line !~ /\[[^\]]*NR_CPUS[^\]]*\.\.\.[^\]]*\]/) |
Andy Whitcroft | 773647a | 2008-03-28 14:15:58 -0700 | [diff] [blame] | 5773 | { |
Joe Perches | 000d1cc1 | 2011-07-25 17:13:25 -0700 | [diff] [blame] | 5774 | WARN("NR_CPUS", |
| 5775 | "usage of NR_CPUS is often wrong - consider using cpu_possible(), num_possible_cpus(), for_each_possible_cpu(), etc\n" . $herecurr); |
Andy Whitcroft | 773647a | 2008-03-28 14:15:58 -0700 | [diff] [blame] | 5776 | } |
Andy Whitcroft | 9c9ba34 | 2008-04-29 00:59:33 -0700 | [diff] [blame] | 5777 | |
Joe Perches | 52ea850 | 2013-11-12 15:10:09 -0800 | [diff] [blame] | 5778 | # Use of __ARCH_HAS_<FOO> or ARCH_HAVE_<BAR> is wrong. |
| 5779 | if ($line =~ /\+\s*#\s*define\s+((?:__)?ARCH_(?:HAS|HAVE)\w*)\b/) { |
| 5780 | ERROR("DEFINE_ARCH_HAS", |
| 5781 | "#define of '$1' is wrong - use Kconfig variables or standard guards instead\n" . $herecurr); |
| 5782 | } |
| 5783 | |
Joe Perches | acd9362 | 2015-02-13 14:38:38 -0800 | [diff] [blame] | 5784 | # likely/unlikely comparisons similar to "(likely(foo) > 0)" |
| 5785 | if ($^V && $^V ge 5.10.0 && |
| 5786 | $line =~ /\b((?:un)?likely)\s*\(\s*$FuncArg\s*\)\s*$Compare/) { |
| 5787 | WARN("LIKELY_MISUSE", |
| 5788 | "Using $1 should generally have parentheses around the comparison\n" . $herecurr); |
| 5789 | } |
| 5790 | |
Andy Whitcroft | 691d77b | 2009-01-06 14:41:16 -0800 | [diff] [blame] | 5791 | # whine mightly about in_atomic |
| 5792 | if ($line =~ /\bin_atomic\s*\(/) { |
| 5793 | if ($realfile =~ m@^drivers/@) { |
Joe Perches | 000d1cc1 | 2011-07-25 17:13:25 -0700 | [diff] [blame] | 5794 | ERROR("IN_ATOMIC", |
| 5795 | "do not use in_atomic in drivers\n" . $herecurr); |
Andy Whitcroft | f4a8773 | 2009-02-27 14:03:05 -0800 | [diff] [blame] | 5796 | } elsif ($realfile !~ m@^kernel/@) { |
Joe Perches | 000d1cc1 | 2011-07-25 17:13:25 -0700 | [diff] [blame] | 5797 | WARN("IN_ATOMIC", |
| 5798 | "use of in_atomic() is incorrect outside core kernel code\n" . $herecurr); |
Andy Whitcroft | 691d77b | 2009-01-06 14:41:16 -0800 | [diff] [blame] | 5799 | } |
| 5800 | } |
Peter Zijlstra | 1704f47 | 2010-03-19 01:37:42 +0100 | [diff] [blame] | 5801 | |
| 5802 | # check for lockdep_set_novalidate_class |
| 5803 | if ($line =~ /^.\s*lockdep_set_novalidate_class\s*\(/ || |
| 5804 | $line =~ /__lockdep_no_validate__\s*\)/ ) { |
| 5805 | if ($realfile !~ m@^kernel/lockdep@ && |
| 5806 | $realfile !~ m@^include/linux/lockdep@ && |
| 5807 | $realfile !~ m@^drivers/base/core@) { |
Joe Perches | 000d1cc1 | 2011-07-25 17:13:25 -0700 | [diff] [blame] | 5808 | ERROR("LOCKDEP", |
| 5809 | "lockdep_no_validate class is reserved for device->mutex.\n" . $herecurr); |
Peter Zijlstra | 1704f47 | 2010-03-19 01:37:42 +0100 | [diff] [blame] | 5810 | } |
| 5811 | } |
Dave Jones | 88f8831 | 2011-01-12 16:59:59 -0800 | [diff] [blame] | 5812 | |
Joe Perches | b392c64 | 2015-04-16 12:44:16 -0700 | [diff] [blame] | 5813 | if ($line =~ /debugfs_create_\w+.*\b$mode_perms_world_writable\b/ || |
| 5814 | $line =~ /DEVICE_ATTR.*\b$mode_perms_world_writable\b/) { |
Joe Perches | 000d1cc1 | 2011-07-25 17:13:25 -0700 | [diff] [blame] | 5815 | WARN("EXPORTED_WORLD_WRITABLE", |
| 5816 | "Exporting world writable files is usually an error. Consider more restrictive permissions.\n" . $herecurr); |
Dave Jones | 88f8831 | 2011-01-12 16:59:59 -0800 | [diff] [blame] | 5817 | } |
Joe Perches | 2435880 | 2014-04-03 14:49:13 -0700 | [diff] [blame] | 5818 | |
Joe Perches | 515a235 | 2014-04-03 14:49:24 -0700 | [diff] [blame] | 5819 | # Mode permission misuses where it seems decimal should be octal |
| 5820 | # This uses a shortcut match to avoid unnecessary uses of a slow foreach loop |
| 5821 | if ($^V && $^V ge 5.10.0 && |
| 5822 | $line =~ /$mode_perms_search/) { |
| 5823 | foreach my $entry (@mode_permission_funcs) { |
| 5824 | my $func = $entry->[0]; |
| 5825 | my $arg_pos = $entry->[1]; |
Joe Perches | 2435880 | 2014-04-03 14:49:13 -0700 | [diff] [blame] | 5826 | |
Joe Perches | 515a235 | 2014-04-03 14:49:24 -0700 | [diff] [blame] | 5827 | my $skip_args = ""; |
| 5828 | if ($arg_pos > 1) { |
| 5829 | $arg_pos--; |
| 5830 | $skip_args = "(?:\\s*$FuncArg\\s*,\\s*){$arg_pos,$arg_pos}"; |
| 5831 | } |
| 5832 | my $test = "\\b$func\\s*\\(${skip_args}([\\d]+)\\s*[,\\)]"; |
| 5833 | if ($line =~ /$test/) { |
| 5834 | my $val = $1; |
| 5835 | $val = $6 if ($skip_args ne ""); |
Joe Perches | 2435880 | 2014-04-03 14:49:13 -0700 | [diff] [blame] | 5836 | |
Joe Perches | 515a235 | 2014-04-03 14:49:24 -0700 | [diff] [blame] | 5837 | if ($val !~ /^0$/ && |
| 5838 | (($val =~ /^$Int$/ && $val !~ /^$Octal$/) || |
| 5839 | length($val) ne 4)) { |
| 5840 | ERROR("NON_OCTAL_PERMISSIONS", |
| 5841 | "Use 4 digit octal (0777) not decimal permissions\n" . $herecurr); |
Joe Perches | c0a5c89 | 2015-02-13 14:38:21 -0800 | [diff] [blame] | 5842 | } elsif ($val =~ /^$Octal$/ && (oct($val) & 02)) { |
| 5843 | ERROR("EXPORTED_WORLD_WRITABLE", |
| 5844 | "Exporting writable files is usually an error. Consider more restrictive permissions.\n" . $herecurr); |
Joe Perches | 515a235 | 2014-04-03 14:49:24 -0700 | [diff] [blame] | 5845 | } |
Joe Perches | 2435880 | 2014-04-03 14:49:13 -0700 | [diff] [blame] | 5846 | } |
| 5847 | } |
| 5848 | } |
Bjorn Andersson | 5a6d20c | 2015-06-25 15:03:24 -0700 | [diff] [blame] | 5849 | |
| 5850 | # validate content of MODULE_LICENSE against list from include/linux/module.h |
| 5851 | if ($line =~ /\bMODULE_LICENSE\s*\(\s*($String)\s*\)/) { |
| 5852 | my $extracted_string = get_quoted_string($line, $rawline); |
| 5853 | my $valid_licenses = qr{ |
| 5854 | GPL| |
| 5855 | GPL\ v2| |
| 5856 | GPL\ and\ additional\ rights| |
| 5857 | Dual\ BSD/GPL| |
| 5858 | Dual\ MIT/GPL| |
| 5859 | Dual\ MPL/GPL| |
| 5860 | Proprietary |
| 5861 | }x; |
| 5862 | if ($extracted_string !~ /^"(?:$valid_licenses)"$/x) { |
| 5863 | WARN("MODULE_LICENSE", |
| 5864 | "unknown module license " . $extracted_string . "\n" . $herecurr); |
| 5865 | } |
| 5866 | } |
Andy Whitcroft | 13214ad | 2008-02-08 04:22:03 -0800 | [diff] [blame] | 5867 | } |
| 5868 | |
| 5869 | # If we have no input at all, then there is nothing to report on |
| 5870 | # so just keep quiet. |
| 5871 | if ($#rawlines == -1) { |
| 5872 | exit(0); |
Andy Whitcroft | 0a920b5 | 2007-06-01 00:46:48 -0700 | [diff] [blame] | 5873 | } |
| 5874 | |
Andy Whitcroft | 8905a67 | 2007-11-28 16:21:06 -0800 | [diff] [blame] | 5875 | # In mailback mode only produce a report in the negative, for |
| 5876 | # things that appear to be patches. |
| 5877 | if ($mailback && ($clean == 1 || !$is_patch)) { |
| 5878 | exit(0); |
| 5879 | } |
| 5880 | |
| 5881 | # This is not a patch, and we are are in 'no-patch' mode so |
| 5882 | # just keep quiet. |
| 5883 | if (!$chk_patch && !$is_patch) { |
| 5884 | exit(0); |
| 5885 | } |
| 5886 | |
Joe Perches | 06330fc | 2015-06-25 15:03:11 -0700 | [diff] [blame] | 5887 | if (!$is_patch && $file !~ /cover-letter\.patch$/) { |
Joe Perches | 000d1cc1 | 2011-07-25 17:13:25 -0700 | [diff] [blame] | 5888 | ERROR("NOT_UNIFIED_DIFF", |
| 5889 | "Does not appear to be a unified-diff format patch\n"); |
Andy Whitcroft | 0a920b5 | 2007-06-01 00:46:48 -0700 | [diff] [blame] | 5890 | } |
Joe Perches | 34d8815 | 2015-06-25 15:03:05 -0700 | [diff] [blame] | 5891 | if ($is_patch && $filename ne '-' && $chk_signoff && $signoff == 0) { |
Joe Perches | 000d1cc1 | 2011-07-25 17:13:25 -0700 | [diff] [blame] | 5892 | ERROR("MISSING_SIGN_OFF", |
| 5893 | "Missing Signed-off-by: line(s)\n"); |
Andy Whitcroft | 0a920b5 | 2007-06-01 00:46:48 -0700 | [diff] [blame] | 5894 | } |
| 5895 | |
Andy Whitcroft | 8905a67 | 2007-11-28 16:21:06 -0800 | [diff] [blame] | 5896 | print report_dump(); |
Andy Whitcroft | 13214ad | 2008-02-08 04:22:03 -0800 | [diff] [blame] | 5897 | if ($summary && !($clean == 1 && $quiet == 1)) { |
| 5898 | print "$filename " if ($summary_file); |
Andy Whitcroft | 8905a67 | 2007-11-28 16:21:06 -0800 | [diff] [blame] | 5899 | print "total: $cnt_error errors, $cnt_warn warnings, " . |
| 5900 | (($check)? "$cnt_chk checks, " : "") . |
| 5901 | "$cnt_lines lines checked\n"; |
Andy Whitcroft | f0a594c | 2007-07-19 01:48:34 -0700 | [diff] [blame] | 5902 | } |
Andy Whitcroft | 8905a67 | 2007-11-28 16:21:06 -0800 | [diff] [blame] | 5903 | |
Andy Whitcroft | d2c0a23 | 2010-10-26 14:23:12 -0700 | [diff] [blame] | 5904 | if ($quiet == 0) { |
| 5905 | # If there were whitespace errors which cleanpatch can fix |
| 5906 | # then suggest that. |
| 5907 | if ($rpt_cleaners) { |
Mike Frysinger | b078121 | 2011-03-22 16:34:43 -0700 | [diff] [blame] | 5908 | $rpt_cleaners = 0; |
Joe Perches | d8469f1 | 2015-06-25 15:03:00 -0700 | [diff] [blame] | 5909 | print << "EOM" |
| 5910 | |
| 5911 | NOTE: Whitespace errors detected. |
| 5912 | You may wish to use scripts/cleanpatch or scripts/cleanfile |
| 5913 | EOM |
Andy Whitcroft | d2c0a23 | 2010-10-26 14:23:12 -0700 | [diff] [blame] | 5914 | } |
| 5915 | } |
| 5916 | |
Joe Perches | d752fcc | 2014-08-06 16:11:05 -0700 | [diff] [blame] | 5917 | if ($clean == 0 && $fix && |
| 5918 | ("@rawlines" ne "@fixed" || |
| 5919 | $#fixed_inserted >= 0 || $#fixed_deleted >= 0)) { |
Joe Perches | 9624b8d | 2014-01-23 15:54:44 -0800 | [diff] [blame] | 5920 | my $newfile = $filename; |
| 5921 | $newfile .= ".EXPERIMENTAL-checkpatch-fixes" if (!$fix_inplace); |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 5922 | my $linecount = 0; |
| 5923 | my $f; |
| 5924 | |
Joe Perches | d752fcc | 2014-08-06 16:11:05 -0700 | [diff] [blame] | 5925 | @fixed = fix_inserted_deleted_lines(\@fixed, \@fixed_inserted, \@fixed_deleted); |
| 5926 | |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 5927 | open($f, '>', $newfile) |
| 5928 | or die "$P: Can't open $newfile for write\n"; |
| 5929 | foreach my $fixed_line (@fixed) { |
| 5930 | $linecount++; |
| 5931 | if ($file) { |
| 5932 | if ($linecount > 3) { |
| 5933 | $fixed_line =~ s/^\+//; |
Joe Perches | d752fcc | 2014-08-06 16:11:05 -0700 | [diff] [blame] | 5934 | print $f $fixed_line . "\n"; |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 5935 | } |
| 5936 | } else { |
| 5937 | print $f $fixed_line . "\n"; |
| 5938 | } |
| 5939 | } |
| 5940 | close($f); |
| 5941 | |
| 5942 | if (!$quiet) { |
| 5943 | print << "EOM"; |
Joe Perches | d8469f1 | 2015-06-25 15:03:00 -0700 | [diff] [blame] | 5944 | |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 5945 | Wrote EXPERIMENTAL --fix correction(s) to '$newfile' |
| 5946 | |
| 5947 | Do _NOT_ trust the results written to this file. |
| 5948 | Do _NOT_ submit these changes without inspecting them for correctness. |
| 5949 | |
| 5950 | This EXPERIMENTAL file is simply a convenience to help rewrite patches. |
| 5951 | No warranties, expressed or implied... |
Joe Perches | 3705ce5 | 2013-07-03 15:05:31 -0700 | [diff] [blame] | 5952 | EOM |
| 5953 | } |
| 5954 | } |
| 5955 | |
Joe Perches | d8469f1 | 2015-06-25 15:03:00 -0700 | [diff] [blame] | 5956 | if ($quiet == 0) { |
| 5957 | print "\n"; |
| 5958 | if ($clean == 1) { |
| 5959 | print "$vname has no obvious style problems and is ready for submission.\n"; |
| 5960 | } else { |
| 5961 | print "$vname has style problems, please review.\n"; |
| 5962 | } |
Andy Whitcroft | 0a920b5 | 2007-06-01 00:46:48 -0700 | [diff] [blame] | 5963 | } |
Andy Whitcroft | 0a920b5 | 2007-06-01 00:46:48 -0700 | [diff] [blame] | 5964 | return $clean; |
| 5965 | } |