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