Doug / smarc-fsl-linux-kernel

Download as
Browse Code ยป

Commit 15662b3e8644905032c2e26808401a487d4e90c1

Authored by Joe Perches
Committed by Linus Torvalds
1 parent 67d0a07544
Exists in master and in 6 other branches imx_3.10.17_1.0.1_ga, imx_3.10.53_1.1.0_ga, imx_3.14.28_1.0.0_ga, smarc-imx_3.10.53_1.1.0_ga, smarc-imx_3.14.28_1.0.0_ga, smarc-l5.0.0_1.0.0-ga

checkpatch: add a --strict check for utf-8 in commit logs 

Some find using utf-8 in commit logs inappropriate.

Some patch commit logs contain unintended utf-8 characters when doing
things like copy/pasting compilation output.

Look for the start of any commit log by skipping initial lines that look
like email headers and "From: " lines.

Stop looking for utf-8 at the first signature line.

Signed-off-by: Joe Perches <joe@perches.com>
Suggested-by: Andrew Morton <akpm@linux-foundation.org>
Cc: Andy Whitcroft <apw@shadowen.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

Showing 1 changed file with 26 additions and 4 deletions Inline Diff

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