Eric Lee / smarc-uboot

20
Download as
Browse Code ยป

Commit f503cc49a570b1e28a93b75bc912aedc93ba2cd0

Authored by Tom Rini
Committed by Albert ARIBAUD
1 parent b60eff31f3
Exists in master and in 49 other branches 8qm-imx_v2020.04_5.4.70_2.3.0, emb_lf_v2022.04, imx_v2015.04_4.1.15_1.0.0_ga, pitx_8mp_lf_v2020.04, smarc-8m-android-10.0.0_2.6.0, smarc-8m-android-11.0.0_2.0.0, smarc-8mp-android-11.0.0_2.0.0, smarc-emmc-imx_v2014.04_3.10.53_1.1.0_ga, smarc-emmc-imx_v2014.04_3.14.28_1.0.0_ga, smarc-imx-l5.0.0_1.0.0-ga, smarc-imx6_v2018.03_4.14.98_2.0.0_ga, smarc-imx7_v2017.03_4.9.11_1.0.0_ga, smarc-imx7_v2018.03_4.14.98_2.0.0_ga, smarc-imx_v2014.04_3.14.28_1.0.0_ga, smarc-imx_v2015.04_4.1.15_1.0.0_ga, smarc-imx_v2017.03_4.9.11_1.0.0_ga, smarc-imx_v2017.03_4.9.88_2.0.0_ga, smarc-imx_v2017.03_o8.1.0_1.3.0_8m, smarc-imx_v2018.03_4.14.78_1.0.0_ga, smarc-m6.0.1_2.1.0-ga, smarc-n7.1.2_2.0.0-ga, smarc-rel_imx_4.1.15_2.0.0_ga, smarc_8m-imx_v2018.03_4.14.98_2.0.0_ga, smarc_8m-imx_v2019.04_4.19.35_1.1.0, smarc_8m_00d0-imx_v2018.03_4.14.98_2.0.0_ga, smarc_8mm-imx_v2018.03_4.14.98_2.0.0_ga, smarc_8mm-imx_v2019.04_4.19.35_1.1.0, smarc_8mm-imx_v2020.04_5.4.24_2.1.0, smarc_8mp_lf_v2020.04, smarc_8mq-imx_v2020.04_5.4.24_2.1.0, smarc_8mq_lf_v2020.04, ti-u-boot-2015.07, v2014.04, v2014.04-smarct33, v2014.04-smarct33-emmc, v2014.04-smartmen, v2014.07, v2014.07-smarct33, v2014.07-smartmen, v2015.07-smarct33, v2015.07-smarct33-emmc, v2015.07-smarct4x, v2016.05-dlt, v2016.05-smarct3x, v2016.05-smarct3x-emmc, v2016.05-smarct4x, v2017.01-smarct3x, v2017.01-smarct3x-emmc, v2017.01-smarct4x

checkpatch.pl: Add warning for new __packed additions 

While there are valid reasons to use __packed, often the answer is that
you should be doing something else here instead.

Signed-off-by: Tom Rini <trini@ti.com>

Showing 1 changed file with 5 additions and 0 deletions Inline Diff

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