Print this page
patch cstyle-x86
| Split |
Close |
| Expand all |
| Collapse all |
--- old/usr/src/tools/scripts/cstyle.pl
+++ new/usr/src/tools/scripts/cstyle.pl
1 1 #!/usr/bin/perl -w
2 2 #
3 3 # CDDL HEADER START
4 4 #
5 5 # The contents of this file are subject to the terms of the
6 6 # Common Development and Distribution License (the "License").
7 7 # You may not use this file except in compliance with the License.
8 8 #
9 9 # You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10 10 # or http://www.opensolaris.org/os/licensing.
11 11 # See the License for the specific language governing permissions
12 12 # and limitations under the License.
13 13 #
14 14 # When distributing Covered Code, include this CDDL HEADER in each
15 15 # file and include the License file at usr/src/OPENSOLARIS.LICENSE.
|
↓ open down ↓ |
15 lines elided |
↑ open up ↑ |
16 16 # If applicable, add the following below this CDDL HEADER, with the
17 17 # fields enclosed by brackets "[]" replaced with your own identifying
18 18 # information: Portions Copyright [yyyy] [name of copyright owner]
19 19 #
20 20 # CDDL HEADER END
21 21 #
22 22 #
23 23 # Copyright 2008 Sun Microsystems, Inc. All rights reserved.
24 24 # Use is subject to license terms.
25 25 #
26 -# @(#)cstyle 1.58 98/09/09 (from shannon)
27 -#ident "%Z%%M% %I% %E% SMI"
28 -#
29 26 # cstyle - check for some common stylistic errors.
30 27 #
31 28 # cstyle is a sort of "lint" for C coding style.
32 29 # It attempts to check for the style used in the
33 30 # kernel, sometimes known as "Bill Joy Normal Form".
34 31 #
35 32 # There's a lot this can't check for, like proper indentation
36 33 # of code blocks. There's also a lot more this could check for.
37 34 #
38 35 # A note to the non perl literate:
39 36 #
40 37 # perl regular expressions are pretty much like egrep
41 38 # regular expressions, with the following special symbols
42 39 #
43 40 # \s any space character
44 41 # \S any non-space character
45 42 # \w any "word" character [a-zA-Z0-9_]
46 43 # \W any non-word character
47 44 # \d a digit [0-9]
48 45 # \D a non-digit
49 46 # \b word boundary (between \w and \W)
50 47 # \B non-word boundary
51 48 #
52 49
53 50 require 5.0;
54 51 use IO::File;
55 52 use Getopt::Std;
56 53 use strict;
57 54
58 55 my $usage =
59 56 "usage: cstyle [-chpvCP] [-o constructs] file ...
60 57 -c check continuation indentation inside functions
61 58 -h perform heuristic checks that are sometimes wrong
62 59 -p perform some of the more picky checks
63 60 -v verbose
64 61 -C don't check anything in header block comments
65 62 -P check for use of non-POSIX types
66 63 -o constructs
67 64 allow a comma-seperated list of optional constructs:
68 65 doxygen allow doxygen-style block comments (/** /*!)
69 66 splint allow splint-style lint comments (/*@ ... @*/)
70 67 ";
71 68
72 69 my %opts;
73 70
74 71 if (!getopts("cho:pvCP", \%opts)) {
75 72 print $usage;
76 73 exit 2;
77 74 }
78 75
79 76 my $check_continuation = $opts{'c'};
80 77 my $heuristic = $opts{'h'};
81 78 my $picky = $opts{'p'};
82 79 my $verbose = $opts{'v'};
83 80 my $ignore_hdr_comment = $opts{'C'};
84 81 my $check_posix_types = $opts{'P'};
85 82
86 83 my $doxygen_comments = 0;
87 84 my $splint_comments = 0;
88 85
89 86 if (defined($opts{'o'})) {
90 87 for my $x (split /,/, $opts{'o'}) {
91 88 if ($x eq "doxygen") {
92 89 $doxygen_comments = 1;
93 90 } elsif ($x eq "splint") {
94 91 $splint_comments = 1;
95 92 } else {
96 93 print "cstyle: unrecognized construct \"$x\"\n";
97 94 print $usage;
98 95 exit 2;
99 96 }
100 97 }
101 98 }
102 99
103 100 my ($filename, $line, $prev); # shared globals
104 101
105 102 my $fmt;
106 103 my $hdr_comment_start;
107 104
108 105 if ($verbose) {
109 106 $fmt = "%s: %d: %s\n%s\n";
110 107 } else {
111 108 $fmt = "%s: %d: %s\n";
112 109 }
113 110
114 111 if ($doxygen_comments) {
115 112 # doxygen comments look like "/*!" or "/**"; allow them.
116 113 $hdr_comment_start = qr/^\s*\/\*[\!\*]?$/;
117 114 } else {
118 115 $hdr_comment_start = qr/^\s*\/\*$/;
119 116 }
120 117
121 118 # Note, following must be in single quotes so that \s and \w work right.
122 119 my $typename = '(int|char|short|long|unsigned|float|double' .
123 120 '|\w+_t|struct\s+\w+|union\s+\w+|FILE)';
124 121
125 122 # mapping of old types to POSIX compatible types
126 123 my %old2posix = (
127 124 'unchar' => 'uchar_t',
128 125 'ushort' => 'ushort_t',
129 126 'uint' => 'uint_t',
130 127 'ulong' => 'ulong_t',
131 128 'u_int' => 'uint_t',
132 129 'u_short' => 'ushort_t',
133 130 'u_long' => 'ulong_t',
134 131 'u_char' => 'uchar_t',
135 132 'quad' => 'quad_t'
136 133 );
137 134
138 135 my $lint_re = qr/\/\*(?:
139 136 ARGSUSED[0-9]*|NOTREACHED|LINTLIBRARY|VARARGS[0-9]*|
140 137 CONSTCOND|CONSTANTCOND|CONSTANTCONDITION|EMPTY|
141 138 FALLTHRU|FALLTHROUGH|LINTED.*?|PRINTFLIKE[0-9]*|
142 139 PROTOLIB[0-9]*|SCANFLIKE[0-9]*|CSTYLED.*?
143 140 )\*\//x;
144 141
145 142 my $splint_re = qr/\/\*@.*?@\*\//x;
146 143
147 144 my $warlock_re = qr/\/\*\s*(?:
148 145 VARIABLES\ PROTECTED\ BY|
149 146 MEMBERS\ PROTECTED\ BY|
150 147 ALL\ MEMBERS\ PROTECTED\ BY|
151 148 READ-ONLY\ VARIABLES:|
152 149 READ-ONLY\ MEMBERS:|
153 150 VARIABLES\ READABLE\ WITHOUT\ LOCK:|
154 151 MEMBERS\ READABLE\ WITHOUT\ LOCK:|
155 152 LOCKS\ COVERED\ BY|
156 153 LOCK\ UNNEEDED\ BECAUSE|
157 154 LOCK\ NEEDED:|
158 155 LOCK\ HELD\ ON\ ENTRY:|
159 156 READ\ LOCK\ HELD\ ON\ ENTRY:|
160 157 WRITE\ LOCK\ HELD\ ON\ ENTRY:|
161 158 LOCK\ ACQUIRED\ AS\ SIDE\ EFFECT:|
162 159 READ\ LOCK\ ACQUIRED\ AS\ SIDE\ EFFECT:|
163 160 WRITE\ LOCK\ ACQUIRED\ AS\ SIDE\ EFFECT:|
164 161 LOCK\ RELEASED\ AS\ SIDE\ EFFECT:|
165 162 LOCK\ UPGRADED\ AS\ SIDE\ EFFECT:|
166 163 LOCK\ DOWNGRADED\ AS\ SIDE\ EFFECT:|
167 164 FUNCTIONS\ CALLED\ THROUGH\ POINTER|
168 165 FUNCTIONS\ CALLED\ THROUGH\ MEMBER|
169 166 LOCK\ ORDER:
170 167 )/x;
171 168
172 169 my $err_stat = 0; # exit status
173 170
174 171 if ($#ARGV >= 0) {
175 172 foreach my $arg (@ARGV) {
176 173 my $fh = new IO::File $arg, "r";
177 174 if (!defined($fh)) {
178 175 printf "%s: can not open\n", $arg;
179 176 } else {
180 177 &cstyle($arg, $fh);
181 178 close $fh;
182 179 }
183 180 }
184 181 } else {
185 182 &cstyle("<stdin>", *STDIN);
186 183 }
187 184 exit $err_stat;
188 185
189 186 my $no_errs = 0; # set for CSTYLED-protected lines
190 187
191 188 sub err($) {
192 189 my ($error) = @_;
193 190 unless ($no_errs) {
194 191 printf $fmt, $filename, $., $error, $line;
195 192 $err_stat = 1;
196 193 }
197 194 }
198 195
199 196 sub err_prefix($$) {
200 197 my ($prevline, $error) = @_;
201 198 my $out = $prevline."\n".$line;
202 199 unless ($no_errs) {
203 200 printf $fmt, $filename, $., $error, $out;
204 201 $err_stat = 1;
205 202 }
206 203 }
207 204
208 205 sub err_prev($) {
209 206 my ($error) = @_;
210 207 unless ($no_errs) {
211 208 printf $fmt, $filename, $. - 1, $error, $prev;
212 209 $err_stat = 1;
213 210 }
214 211 }
215 212
216 213 sub cstyle($$) {
217 214
218 215 my ($fn, $filehandle) = @_;
219 216 $filename = $fn; # share it globally
220 217
221 218 my $in_cpp = 0;
222 219 my $next_in_cpp = 0;
223 220
224 221 my $in_comment = 0;
225 222 my $in_header_comment = 0;
226 223 my $comment_done = 0;
227 224 my $in_warlock_comment = 0;
228 225 my $in_function = 0;
229 226 my $in_function_header = 0;
230 227 my $in_declaration = 0;
231 228 my $note_level = 0;
232 229 my $nextok = 0;
233 230 my $nocheck = 0;
234 231
235 232 my $in_string = 0;
236 233
237 234 my ($okmsg, $comment_prefix);
238 235
239 236 $line = '';
240 237 $prev = '';
241 238 reset_indent();
242 239
243 240 line: while (<$filehandle>) {
244 241 s/\r?\n$//; # strip return and newline
245 242
246 243 # save the original line, then remove all text from within
247 244 # double or single quotes, we do not want to check such text.
248 245
249 246 $line = $_;
250 247
251 248 #
252 249 # C allows strings to be continued with a backslash at the end of
253 250 # the line. We translate that into a quoted string on the previous
254 251 # line followed by an initial quote on the next line.
255 252 #
256 253 # (we assume that no-one will use backslash-continuation with character
257 254 # constants)
258 255 #
259 256 $_ = '"' . $_ if ($in_string && !$nocheck && !$in_comment);
260 257
261 258 #
262 259 # normal strings and characters
263 260 #
264 261 s/'([^\\']|\\[^xX0]|\\0[0-9]*|\\[xX][0-9a-fA-F]*)'/''/g;
265 262 s/"([^\\"]|\\.)*"/\"\"/g;
266 263
267 264 #
268 265 # detect string continuation
269 266 #
270 267 if ($nocheck || $in_comment) {
271 268 $in_string = 0;
272 269 } else {
273 270 #
274 271 # Now that all full strings are replaced with "", we check
275 272 # for unfinished strings continuing onto the next line.
276 273 #
277 274 $in_string =
278 275 (s/([^"](?:"")*)"([^\\"]|\\.)*\\$/$1""/ ||
279 276 s/^("")*"([^\\"]|\\.)*\\$/""/);
280 277 }
281 278
282 279 #
283 280 # figure out if we are in a cpp directive
284 281 #
285 282 $in_cpp = $next_in_cpp || /^\s*#/; # continued or started
286 283 $next_in_cpp = $in_cpp && /\\$/; # only if continued
287 284
288 285 # strip off trailing backslashes, which appear in long macros
289 286 s/\s*\\$//;
290 287
291 288 # an /* END CSTYLED */ comment ends a no-check block.
292 289 if ($nocheck) {
293 290 if (/\/\* *END *CSTYLED *\*\//) {
294 291 $nocheck = 0;
295 292 } else {
296 293 reset_indent();
297 294 next line;
298 295 }
299 296 }
300 297
301 298 # a /*CSTYLED*/ comment indicates that the next line is ok.
302 299 if ($nextok) {
303 300 if ($okmsg) {
304 301 err($okmsg);
305 302 }
306 303 $nextok = 0;
307 304 $okmsg = 0;
308 305 if (/\/\* *CSTYLED.*\*\//) {
309 306 /^.*\/\* *CSTYLED *(.*) *\*\/.*$/;
310 307 $okmsg = $1;
311 308 $nextok = 1;
312 309 }
313 310 $no_errs = 1;
314 311 } elsif ($no_errs) {
315 312 $no_errs = 0;
316 313 }
317 314
318 315 # check length of line.
319 316 # first, a quick check to see if there is any chance of being too long.
320 317 if (($line =~ tr/\t/\t/) * 7 + length($line) > 80) {
321 318 # yes, there is a chance.
322 319 # replace tabs with spaces and check again.
323 320 my $eline = $line;
324 321 1 while $eline =~
325 322 s/\t+/' ' x (length($&) * 8 - length($`) % 8)/e;
326 323 if (length($eline) > 80) {
327 324 err("line > 80 characters");
328 325 }
329 326 }
330 327
331 328 # ignore NOTE(...) annotations (assumes NOTE is on lines by itself).
332 329 if ($note_level || /\b_?NOTE\s*\(/) { # if in NOTE or this is NOTE
333 330 s/[^()]//g; # eliminate all non-parens
334 331 $note_level += s/\(//g - length; # update paren nest level
335 332 next;
336 333 }
337 334
338 335 # a /* BEGIN CSTYLED */ comment starts a no-check block.
339 336 if (/\/\* *BEGIN *CSTYLED *\*\//) {
340 337 $nocheck = 1;
341 338 }
342 339
343 340 # a /*CSTYLED*/ comment indicates that the next line is ok.
344 341 if (/\/\* *CSTYLED.*\*\//) {
345 342 /^.*\/\* *CSTYLED *(.*) *\*\/.*$/;
346 343 $okmsg = $1;
347 344 $nextok = 1;
348 345 }
349 346 if (/\/\/ *CSTYLED/) {
350 347 /^.*\/\/ *CSTYLED *(.*)$/;
351 348 $okmsg = $1;
352 349 $nextok = 1;
353 350 }
354 351
355 352 # universal checks; apply to everything
356 353 if (/\t +\t/) {
357 354 err("spaces between tabs");
358 355 }
359 356 if (/ \t+ /) {
360 357 err("tabs between spaces");
361 358 }
362 359 if (/\s$/) {
363 360 err("space or tab at end of line");
364 361 }
365 362 if (/[^ \t(]\/\*/ && !/\w\(\/\*.*\*\/\);/) {
366 363 err("comment preceded by non-blank");
367 364 }
368 365
369 366 # is this the beginning or ending of a function?
370 367 # (not if "struct foo\n{\n")
371 368 if (/^{$/ && $prev =~ /\)\s*(const\s*)?(\/\*.*\*\/\s*)?\\?$/) {
372 369 $in_function = 1;
373 370 $in_declaration = 1;
374 371 $in_function_header = 0;
375 372 $prev = $line;
376 373 next line;
377 374 }
378 375 if (/^}\s*(\/\*.*\*\/\s*)*$/) {
379 376 if ($prev =~ /^\s*return\s*;/) {
380 377 err_prev("unneeded return at end of function");
381 378 }
382 379 $in_function = 0;
383 380 reset_indent(); # we don't check between functions
384 381 $prev = $line;
385 382 next line;
386 383 }
387 384 if (/^\w*\($/) {
388 385 $in_function_header = 1;
389 386 }
390 387
391 388 if ($in_warlock_comment && /\*\//) {
392 389 $in_warlock_comment = 0;
393 390 $prev = $line;
394 391 next line;
395 392 }
396 393
397 394 # a blank line terminates the declarations within a function.
398 395 # XXX - but still a problem in sub-blocks.
399 396 if ($in_declaration && /^$/) {
400 397 $in_declaration = 0;
401 398 }
402 399
403 400 if ($comment_done) {
404 401 $in_comment = 0;
405 402 $in_header_comment = 0;
406 403 $comment_done = 0;
407 404 }
408 405 # does this looks like the start of a block comment?
409 406 if (/$hdr_comment_start/) {
410 407 if (!/^\t*\/\*/) {
411 408 err("block comment not indented by tabs");
412 409 }
413 410 $in_comment = 1;
414 411 /^(\s*)\//;
415 412 $comment_prefix = $1;
416 413 if ($comment_prefix eq "") {
417 414 $in_header_comment = 1;
418 415 }
419 416 $prev = $line;
420 417 next line;
421 418 }
422 419 # are we still in the block comment?
423 420 if ($in_comment) {
424 421 if (/^$comment_prefix \*\/$/) {
425 422 $comment_done = 1;
426 423 } elsif (/\*\//) {
427 424 $comment_done = 1;
428 425 err("improper block comment close")
429 426 unless ($ignore_hdr_comment && $in_header_comment);
430 427 } elsif (!/^$comment_prefix \*[ \t]/ &&
431 428 !/^$comment_prefix \*$/) {
432 429 err("improper block comment")
433 430 unless ($ignore_hdr_comment && $in_header_comment);
434 431 }
435 432 }
436 433
437 434 if ($in_header_comment && $ignore_hdr_comment) {
438 435 $prev = $line;
439 436 next line;
440 437 }
441 438
442 439 # check for errors that might occur in comments and in code.
443 440
444 441 # allow spaces to be used to draw pictures in header comments.
445 442 if (/[^ ] / && !/".* .*"/ && !$in_header_comment) {
446 443 err("spaces instead of tabs");
447 444 }
448 445 if (/^ / && !/^ \*[ \t\/]/ && !/^ \*$/ &&
449 446 (!/^ \w/ || $in_function != 0)) {
450 447 err("indent by spaces instead of tabs");
451 448 }
452 449 if (/^\t+ [^ \t\*]/ || /^\t+ \S/ || /^\t+ \S/) {
453 450 err("continuation line not indented by 4 spaces");
454 451 }
455 452 if (/$warlock_re/ && !/\*\//) {
456 453 $in_warlock_comment = 1;
457 454 $prev = $line;
458 455 next line;
459 456 }
460 457 if (/^\s*\/\*./ && !/^\s*\/\*.*\*\// && !/$hdr_comment_start/) {
461 458 err("improper first line of block comment");
462 459 }
463 460
464 461 if ($in_comment) { # still in comment, don't do further checks
465 462 $prev = $line;
466 463 next line;
467 464 }
468 465
469 466 if ((/[^(]\/\*\S/ || /^\/\*\S/) &&
470 467 !(/$lint_re/ || ($splint_comments && /$splint_re/))) {
471 468 err("missing blank after open comment");
472 469 }
473 470 if (/\S\*\/[^)]|\S\*\/$/ &&
474 471 !(/$lint_re/ || ($splint_comments && /$splint_re/))) {
|
↓ open down ↓ |
436 lines elided |
↑ open up ↑ |
475 472 err("missing blank before close comment");
476 473 }
477 474 if (/\/\/\S/) { # C++ comments
478 475 err("missing blank after start comment");
479 476 }
480 477 # check for unterminated single line comments, but allow them when
481 478 # they are used to comment out the argument list of a function
482 479 # declaration.
483 480 if (/\S.*\/\*/ && !/\S.*\/\*.*\*\// && !/\(\/\*/) {
484 481 err("unterminated single line comment");
482 + }
483 +
484 + # check that #if doesn't enumerate ISA defines when there are more
485 + # concise ways of checking. E.g., don't do:
486 + # #if defined(__amd64) || defined(__i386)
487 + # when there is:
488 + # #ifdef __x86
489 + if (/^#if\sdefined\((.*)\)\s\|\|\sdefined\((.*)\)/) {
490 + my $first = $1;
491 + my $second = $2;
492 + ($first, $second) = ($second, $first) if ($first gt $second);
493 +
494 + if (($first eq "__amd64") && ($second eq "__i386")) {
495 + err("#if checking for $first or $second instead of " .
496 + "__x86");
497 + }
485 498 }
486 499
487 500 if (/^(#else|#endif|#include)(.*)$/) {
488 501 $prev = $line;
489 502 if ($picky) {
490 503 my $directive = $1;
491 504 my $clause = $2;
492 505 # Enforce ANSI rules for #else and #endif: no noncomment
493 506 # identifiers are allowed after #endif or #else. Allow
494 507 # C++ comments since they seem to be a fact of life.
495 508 if ((($1 eq "#endif") || ($1 eq "#else")) &&
496 509 ($clause ne "") &&
497 510 (!($clause =~ /^\s+\/\*.*\*\/$/)) &&
498 511 (!($clause =~ /^\s+\/\/.*$/))) {
499 512 err("non-comment text following " .
500 513 "$directive (or malformed $directive " .
501 514 "directive)");
502 515 }
503 516 }
504 517 next line;
505 518 }
506 519
507 520 #
508 521 # delete any comments and check everything else. Note that
509 522 # ".*?" is a non-greedy match, so that we don't get confused by
510 523 # multiple comments on the same line.
511 524 #
512 525 s/\/\*.*?\*\///g;
513 526 s/\/\/.*$//; # C++ comments
514 527
515 528 # delete any trailing whitespace; we have already checked for that.
516 529 s/\s*$//;
517 530
518 531 # following checks do not apply to text in comments.
519 532
520 533 if (/[^<>\s][!<>=]=/ || /[^<>][!<>=]=[^\s,]/ ||
521 534 (/[^->]>[^,=>\s]/ && !/[^->]>$/) ||
522 535 (/[^<]<[^,=<\s]/ && !/[^<]<$/) ||
523 536 /[^<\s]<[^<]/ || /[^->\s]>[^>]/) {
524 537 err("missing space around relational operator");
525 538 }
526 539 if (/\S>>=/ || /\S<<=/ || />>=\S/ || /<<=\S/ || /\S[-+*\/&|^%]=/ ||
527 540 (/[^-+*\/&|^%!<>=\s]=[^=]/ && !/[^-+*\/&|^%!<>=\s]=$/) ||
528 541 (/[^!<>=]=[^=\s]/ && !/[^!<>=]=$/)) {
529 542 # XXX - should only check this for C++ code
530 543 # XXX - there are probably other forms that should be allowed
531 544 if (!/\soperator=/) {
532 545 err("missing space around assignment operator");
533 546 }
534 547 }
535 548 if (/[,;]\S/ && !/\bfor \(;;\)/) {
536 549 err("comma or semicolon followed by non-blank");
537 550 }
538 551 # allow "for" statements to have empty "while" clauses
539 552 if (/\s[,;]/ && !/^[\t]+;$/ && !/^\s*for \([^;]*; ;[^;]*\)/) {
540 553 err("comma or semicolon preceded by blank");
541 554 }
542 555 if (/^\s*(&&|\|\|)/) {
543 556 err("improper boolean continuation");
544 557 }
545 558 if (/\S *(&&|\|\|)/ || /(&&|\|\|) *\S/) {
546 559 err("more than one space around boolean operator");
547 560 }
548 561 if (/\b(for|if|while|switch|sizeof|return|case)\(/) {
549 562 err("missing space between keyword and paren");
550 563 }
551 564 if (/(\b(for|if|while|switch|return)\b.*){2,}/ && !/^#define/) {
552 565 # multiple "case" and "sizeof" allowed
553 566 err("more than one keyword on line");
554 567 }
555 568 if (/\b(for|if|while|switch|sizeof|return|case)\s\s+\(/ &&
556 569 !/^#if\s+\(/) {
557 570 err("extra space between keyword and paren");
558 571 }
559 572 # try to detect "func (x)" but not "if (x)" or
560 573 # "#define foo (x)" or "int (*func)();"
561 574 if (/\w\s\(/) {
562 575 my $s = $_;
563 576 # strip off all keywords on the line
564 577 s/\b(for|if|while|switch|return|case|sizeof)\s\(/XXX(/g;
565 578 s/#elif\s\(/XXX(/g;
566 579 s/^#define\s+\w+\s+\(/XXX(/;
567 580 # do not match things like "void (*f)();"
568 581 # or "typedef void (func_t)();"
569 582 s/\w\s\(+\*/XXX(*/g;
570 583 s/\b($typename|void)\s+\(+/XXX(/og;
571 584 if (/\w\s\(/) {
572 585 err("extra space between function name and left paren");
573 586 }
574 587 $_ = $s;
575 588 }
576 589 # try to detect "int foo(x)", but not "extern int foo(x);"
577 590 # XXX - this still trips over too many legitimate things,
578 591 # like "int foo(x,\n\ty);"
579 592 # if (/^(\w+(\s|\*)+)+\w+\(/ && !/\)[;,](\s|)*$/ &&
580 593 # !/^(extern|static)\b/) {
581 594 # err("return type of function not on separate line");
582 595 # }
583 596 # this is a close approximation
584 597 if (/^(\w+(\s|\*)+)+\w+\(.*\)(\s|)*$/ &&
585 598 !/^(extern|static)\b/) {
586 599 err("return type of function not on separate line");
587 600 }
588 601 if (/^#define /) {
589 602 err("#define followed by space instead of tab");
590 603 }
591 604 if (/^\s*return\W[^;]*;/ && !/^\s*return\s*\(.*\);/) {
592 605 err("unparenthesized return expression");
593 606 }
594 607 if (/\bsizeof\b/ && !/\bsizeof\s*\(.*\)/) {
595 608 err("unparenthesized sizeof expression");
596 609 }
597 610 if (/\(\s/) {
598 611 err("whitespace after left paren");
599 612 }
600 613 # allow "for" statements to have empty "continue" clauses
601 614 if (/\s\)/ && !/^\s*for \([^;]*;[^;]*; \)/) {
602 615 err("whitespace before right paren");
603 616 }
604 617 if (/^\s*\(void\)[^ ]/) {
605 618 err("missing space after (void) cast");
606 619 }
607 620 if (/\S{/ && !/{{/) {
608 621 err("missing space before left brace");
609 622 }
610 623 if ($in_function && /^\s+{/ &&
611 624 ($prev =~ /\)\s*$/ || $prev =~ /\bstruct\s+\w+$/)) {
612 625 err("left brace starting a line");
613 626 }
614 627 if (/}(else|while)/) {
615 628 err("missing space after right brace");
616 629 }
617 630 if (/}\s\s+(else|while)/) {
618 631 err("extra space after right brace");
619 632 }
620 633 if (/\b_VOID\b|\bVOID\b|\bSTATIC\b/) {
621 634 err("obsolete use of VOID or STATIC");
622 635 }
623 636 if (/\b$typename\*/o) {
624 637 err("missing space between type name and *");
625 638 }
626 639 if (/^\s+#/) {
627 640 err("preprocessor statement not in column 1");
628 641 }
629 642 if (/^#\s/) {
630 643 err("blank after preprocessor #");
631 644 }
632 645 if (/!\s*(strcmp|strncmp|bcmp)\s*\(/) {
633 646 err("don't use boolean ! with comparison functions");
634 647 }
635 648
636 649 #
637 650 # We completely ignore, for purposes of indentation:
638 651 # * lines outside of functions
639 652 # * preprocessor lines
640 653 #
641 654 if ($check_continuation && $in_function && !$in_cpp) {
642 655 process_indent($_);
643 656 }
644 657 if ($picky) {
645 658 # try to detect spaces after casts, but allow (e.g.)
646 659 # "sizeof (int) + 1", "void (*funcptr)(int) = foo;", and
647 660 # "int foo(int) __NORETURN;"
648 661 if ((/^\($typename( \*+)?\)\s/o ||
649 662 /\W\($typename( \*+)?\)\s/o) &&
650 663 !/sizeof\s*\($typename( \*)?\)\s/o &&
651 664 !/\($typename( \*+)?\)\s+=[^=]/o) {
652 665 err("space after cast");
653 666 }
654 667 if (/\b$typename\s*\*\s/o &&
655 668 !/\b$typename\s*\*\s+const\b/o) {
656 669 err("unary * followed by space");
657 670 }
658 671 }
659 672 if ($check_posix_types) {
660 673 # try to detect old non-POSIX types.
661 674 # POSIX requires all non-standard typedefs to end in _t,
662 675 # but historically these have been used.
663 676 if (/\b(unchar|ushort|uint|ulong|u_int|u_short|u_long|u_char|quad)\b/) {
664 677 err("non-POSIX typedef $1 used: use $old2posix{$1} instead");
665 678 }
666 679 }
667 680 if ($heuristic) {
668 681 # cannot check this everywhere due to "struct {\n...\n} foo;"
669 682 if ($in_function && !$in_declaration &&
670 683 /}./ && !/}\s+=/ && !/{.*}[;,]$/ && !/}(\s|)*$/ &&
671 684 !/} (else|while)/ && !/}}/) {
672 685 err("possible bad text following right brace");
673 686 }
674 687 # cannot check this because sub-blocks in
675 688 # the middle of code are ok
676 689 if ($in_function && /^\s+{/) {
677 690 err("possible left brace starting a line");
678 691 }
679 692 }
680 693 if (/^\s*else\W/) {
681 694 if ($prev =~ /^\s*}$/) {
682 695 err_prefix($prev,
683 696 "else and right brace should be on same line");
684 697 }
685 698 }
686 699 $prev = $line;
687 700 }
688 701
689 702 if ($prev eq "") {
690 703 err("last line in file is blank");
691 704 }
692 705
693 706 }
694 707
695 708 #
696 709 # Continuation-line checking
697 710 #
698 711 # The rest of this file contains the code for the continuation checking
699 712 # engine. It's a pretty simple state machine which tracks the expression
700 713 # depth (unmatched '('s and '['s).
701 714 #
702 715 # Keep in mind that the argument to process_indent() has already been heavily
703 716 # processed; all comments have been replaced by control-A, and the contents of
704 717 # strings and character constants have been elided.
705 718 #
706 719
707 720 my $cont_in; # currently inside of a continuation
708 721 my $cont_off; # skipping an initializer or definition
709 722 my $cont_noerr; # suppress cascading errors
710 723 my $cont_start; # the line being continued
711 724 my $cont_base; # the base indentation
712 725 my $cont_first; # this is the first line of a statement
713 726 my $cont_multiseg; # this continuation has multiple segments
714 727
715 728 my $cont_special; # this is a C statement (if, for, etc.)
716 729 my $cont_macro; # this is a macro
717 730 my $cont_case; # this is a multi-line case
718 731
719 732 my @cont_paren; # the stack of unmatched ( and [s we've seen
720 733
721 734 sub
722 735 reset_indent()
723 736 {
724 737 $cont_in = 0;
725 738 $cont_off = 0;
726 739 }
727 740
728 741 sub
729 742 delabel($)
730 743 {
731 744 #
732 745 # replace labels with tabs. Note that there may be multiple
733 746 # labels on a line.
734 747 #
735 748 local $_ = $_[0];
736 749
737 750 while (/^(\t*)( *(?:(?:\w+\s*)|(?:case\b[^:]*)): *)(.*)$/) {
738 751 my ($pre_tabs, $label, $rest) = ($1, $2, $3);
739 752 $_ = $pre_tabs;
740 753 while ($label =~ s/^([^\t]*)(\t+)//) {
741 754 $_ .= "\t" x (length($2) + length($1) / 8);
742 755 }
743 756 $_ .= ("\t" x (length($label) / 8)).$rest;
744 757 }
745 758
746 759 return ($_);
747 760 }
748 761
749 762 sub
750 763 process_indent($)
751 764 {
752 765 require strict;
753 766 local $_ = $_[0]; # preserve the global $_
754 767
755 768 s///g; # No comments
756 769 s/\s+$//; # Strip trailing whitespace
757 770
758 771 return if (/^$/); # skip empty lines
759 772
760 773 # regexps used below; keywords taking (), macros, and continued cases
761 774 my $special = '(?:(?:\}\s*)?else\s+)?(?:if|for|while|switch)\b';
762 775 my $macro = '[A-Z_][A-Z_0-9]*\(';
763 776 my $case = 'case\b[^:]*$';
764 777
765 778 # skip over enumerations, array definitions, initializers, etc.
766 779 if ($cont_off <= 0 && !/^\s*$special/ &&
767 780 (/(?:(?:\b(?:enum|struct|union)\s*[^\{]*)|(?:\s+=\s*)){/ ||
768 781 (/^\s*{/ && $prev =~ /=\s*(?:\/\*.*\*\/\s*)*$/))) {
769 782 $cont_in = 0;
770 783 $cont_off = tr/{/{/ - tr/}/}/;
771 784 return;
772 785 }
773 786 if ($cont_off) {
774 787 $cont_off += tr/{/{/ - tr/}/}/;
775 788 return;
776 789 }
777 790
778 791 if (!$cont_in) {
779 792 $cont_start = $line;
780 793
781 794 if (/^\t* /) {
782 795 err("non-continuation indented 4 spaces");
783 796 $cont_noerr = 1; # stop reporting
784 797 }
785 798 $_ = delabel($_); # replace labels with tabs
786 799
787 800 # check if the statement is complete
788 801 return if (/^\s*\}?$/);
789 802 return if (/^\s*\}?\s*else\s*\{?$/);
790 803 return if (/^\s*do\s*\{?$/);
791 804 return if (/{$/);
792 805 return if (/}[,;]?$/);
793 806
794 807 # Allow macros on their own lines
795 808 return if (/^\s*[A-Z_][A-Z_0-9]*$/);
796 809
797 810 # cases we don't deal with, generally non-kosher
798 811 if (/{/) {
799 812 err("stuff after {");
800 813 return;
801 814 }
802 815
803 816 # Get the base line, and set up the state machine
804 817 /^(\t*)/;
805 818 $cont_base = $1;
806 819 $cont_in = 1;
807 820 @cont_paren = ();
808 821 $cont_first = 1;
809 822 $cont_multiseg = 0;
810 823
811 824 # certain things need special processing
812 825 $cont_special = /^\s*$special/? 1 : 0;
813 826 $cont_macro = /^\s*$macro/? 1 : 0;
814 827 $cont_case = /^\s*$case/? 1 : 0;
815 828 } else {
816 829 $cont_first = 0;
817 830
818 831 # Strings may be pulled back to an earlier (half-)tabstop
819 832 unless ($cont_noerr || /^$cont_base / ||
820 833 (/^\t*(?: )?(?:gettext\()?\"/ && !/^$cont_base\t/)) {
821 834 err_prefix($cont_start,
822 835 "continuation should be indented 4 spaces");
823 836 }
824 837 }
825 838
826 839 my $rest = $_; # keeps the remainder of the line
827 840
828 841 #
829 842 # The split matches 0 characters, so that each 'special' character
830 843 # is processed separately. Parens and brackets are pushed and
831 844 # popped off the @cont_paren stack. For normal processing, we wait
832 845 # until a ; or { terminates the statement. "special" processing
833 846 # (if/for/while/switch) is allowed to stop when the stack empties,
834 847 # as is macro processing. Case statements are terminated with a :
835 848 # and an empty paren stack.
836 849 #
837 850 foreach $_ (split /[^\(\)\[\]\{\}\;\:]*/) {
838 851 next if (length($_) == 0);
839 852
840 853 # rest contains the remainder of the line
841 854 my $rxp = "[^\Q$_\E]*\Q$_\E";
842 855 $rest =~ s/^$rxp//;
843 856
844 857 if (/\(/ || /\[/) {
845 858 push @cont_paren, $_;
846 859 } elsif (/\)/ || /\]/) {
847 860 my $cur = $_;
848 861 tr/\)\]/\(\[/;
849 862
850 863 my $old = (pop @cont_paren);
851 864 if (!defined($old)) {
852 865 err("unexpected '$cur'");
853 866 $cont_in = 0;
854 867 last;
855 868 } elsif ($old ne $_) {
856 869 err("'$cur' mismatched with '$old'");
857 870 $cont_in = 0;
858 871 last;
859 872 }
860 873
861 874 #
862 875 # If the stack is now empty, do special processing
863 876 # for if/for/while/switch and macro statements.
864 877 #
865 878 next if (@cont_paren != 0);
866 879 if ($cont_special) {
867 880 if ($rest =~ /^\s*{?$/) {
868 881 $cont_in = 0;
869 882 last;
870 883 }
871 884 if ($rest =~ /^\s*;$/) {
872 885 err("empty if/for/while body ".
873 886 "not on its own line");
874 887 $cont_in = 0;
875 888 last;
876 889 }
877 890 if (!$cont_first && $cont_multiseg == 1) {
878 891 err_prefix($cont_start,
879 892 "multiple statements continued ".
880 893 "over multiple lines");
881 894 $cont_multiseg = 2;
882 895 } elsif ($cont_multiseg == 0) {
883 896 $cont_multiseg = 1;
884 897 }
885 898 # We've finished this section, start
886 899 # processing the next.
887 900 goto section_ended;
888 901 }
889 902 if ($cont_macro) {
890 903 if ($rest =~ /^$/) {
891 904 $cont_in = 0;
892 905 last;
893 906 }
894 907 }
895 908 } elsif (/\;/) {
896 909 if ($cont_case) {
897 910 err("unexpected ;");
898 911 } elsif (!$cont_special) {
899 912 err("unexpected ;") if (@cont_paren != 0);
900 913 if (!$cont_first && $cont_multiseg == 1) {
901 914 err_prefix($cont_start,
902 915 "multiple statements continued ".
903 916 "over multiple lines");
904 917 $cont_multiseg = 2;
905 918 } elsif ($cont_multiseg == 0) {
906 919 $cont_multiseg = 1;
907 920 }
908 921 if ($rest =~ /^$/) {
909 922 $cont_in = 0;
910 923 last;
911 924 }
912 925 if ($rest =~ /^\s*special/) {
913 926 err("if/for/while/switch not started ".
914 927 "on its own line");
915 928 }
916 929 goto section_ended;
917 930 }
918 931 } elsif (/\{/) {
919 932 err("{ while in parens/brackets") if (@cont_paren != 0);
920 933 err("stuff after {") if ($rest =~ /[^\s}]/);
921 934 $cont_in = 0;
922 935 last;
923 936 } elsif (/\}/) {
924 937 err("} while in parens/brackets") if (@cont_paren != 0);
925 938 if (!$cont_special && $rest !~ /^\s*(while|else)\b/) {
926 939 if ($rest =~ /^$/) {
927 940 err("unexpected }");
928 941 } else {
929 942 err("stuff after }");
930 943 }
931 944 $cont_in = 0;
932 945 last;
933 946 }
934 947 } elsif (/\:/ && $cont_case && @cont_paren == 0) {
935 948 err("stuff after multi-line case") if ($rest !~ /$^/);
936 949 $cont_in = 0;
937 950 last;
938 951 }
939 952 next;
940 953 section_ended:
941 954 # End of a statement or if/while/for loop. Reset
942 955 # cont_special and cont_macro based on the rest of the
943 956 # line.
944 957 $cont_special = ($rest =~ /^\s*$special/)? 1 : 0;
945 958 $cont_macro = ($rest =~ /^\s*$macro/)? 1 : 0;
946 959 $cont_case = 0;
947 960 next;
948 961 }
949 962 $cont_noerr = 0 if (!$cont_in);
950 963 }
|
↓ open down ↓ |
456 lines elided |
↑ open up ↑ |
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX