cpplint.py revision 08fc03ae5dded4adc9b45b7014a4b9dfedbe95a6
1#!/usr/bin/python 2# 3# Copyright (c) 2009 Google Inc. All rights reserved. 4# 5# Redistribution and use in source and binary forms, with or without 6# modification, are permitted provided that the following conditions are 7# met: 8# 9# * Redistributions of source code must retain the above copyright 10# notice, this list of conditions and the following disclaimer. 11# * Redistributions in binary form must reproduce the above 12# copyright notice, this list of conditions and the following disclaimer 13# in the documentation and/or other materials provided with the 14# distribution. 15# * Neither the name of Google Inc. nor the names of its 16# contributors may be used to endorse or promote products derived from 17# this software without specific prior written permission. 18# 19# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 20# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 21# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 22# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 23# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 24# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 25# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 26# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 27# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 28# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 29# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 30 31# Here are some issues that I've had people identify in my code during reviews, 32# that I think are possible to flag automatically in a lint tool. If these were 33# caught by lint, it would save time both for myself and that of my reviewers. 34# Most likely, some of these are beyond the scope of the current lint framework, 35# but I think it is valuable to retain these wish-list items even if they cannot 36# be immediately implemented. 37# 38# Suggestions 39# ----------- 40# - Check for no 'explicit' for multi-arg ctor 41# - Check for boolean assign RHS in parens 42# - Check for ctor initializer-list colon position and spacing 43# - Check that if there's a ctor, there should be a dtor 44# - Check accessors that return non-pointer member variables are 45# declared const 46# - Check accessors that return non-const pointer member vars are 47# *not* declared const 48# - Check for using public includes for testing 49# - Check for spaces between brackets in one-line inline method 50# - Check for no assert() 51# - Check for spaces surrounding operators 52# - Check for 0 in pointer context (should be NULL) 53# - Check for 0 in char context (should be '\0') 54# - Check for camel-case method name conventions for methods 55# that are not simple inline getters and setters 56# - Check that base classes have virtual destructors 57# put " // namespace" after } that closes a namespace, with 58# namespace's name after 'namespace' if it is named. 59# - Do not indent namespace contents 60# - Avoid inlining non-trivial constructors in header files 61# include base/basictypes.h if DISALLOW_EVIL_CONSTRUCTORS is used 62# - Check for old-school (void) cast for call-sites of functions 63# ignored return value 64# - Check gUnit usage of anonymous namespace 65# - Check for class declaration order (typedefs, consts, enums, 66# ctor(s?), dtor, friend declarations, methods, member vars) 67# 68 69"""Does google-lint on c++ files. 70 71The goal of this script is to identify places in the code that *may* 72be in non-compliance with google style. It does not attempt to fix 73up these problems -- the point is to educate. It does also not 74attempt to find all problems, or to ensure that everything it does 75find is legitimately a problem. 76 77In particular, we can get very confused by /* and // inside strings! 78We do a small hack, which is to ignore //'s with "'s after them on the 79same line, but it is far from perfect (in either direction). 80""" 81 82import codecs 83import getopt 84import math # for log 85import os 86import re 87import sre_compile 88import string 89import sys 90import unicodedata 91 92 93_USAGE = """ 94Syntax: cpplint.py [--verbose=#] [--output=vs7] [--filter=-x,+y,...] 95 [--counting=total|toplevel|detailed] 96 <file> [file] ... 97 98 The style guidelines this tries to follow are those in 99 http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml 100 101 Every problem is given a confidence score from 1-5, with 5 meaning we are 102 certain of the problem, and 1 meaning it could be a legitimate construct. 103 This will miss some errors, and is not a substitute for a code review. 104 105 To suppress false-positive errors of a certain category, add a 106 'NOLINT(category)' comment to the line. NOLINT or NOLINT(*) 107 suppresses errors of all categories on that line. 108 109 The files passed in will be linted; at least one file must be provided. 110 Linted extensions are .cc, .cpp, and .h. Other file types will be ignored. 111 112 Flags: 113 114 output=vs7 115 By default, the output is formatted to ease emacs parsing. Visual Studio 116 compatible output (vs7) may also be used. Other formats are unsupported. 117 118 verbose=# 119 Specify a number 0-5 to restrict errors to certain verbosity levels. 120 121 filter=-x,+y,... 122 Specify a comma-separated list of category-filters to apply: only 123 error messages whose category names pass the filters will be printed. 124 (Category names are printed with the message and look like 125 "[whitespace/indent]".) Filters are evaluated left to right. 126 "-FOO" and "FOO" means "do not print categories that start with FOO". 127 "+FOO" means "do print categories that start with FOO". 128 129 Examples: --filter=-whitespace,+whitespace/braces 130 --filter=whitespace,runtime/printf,+runtime/printf_format 131 --filter=-,+build/include_what_you_use 132 133 To see a list of all the categories used in cpplint, pass no arg: 134 --filter= 135 136 counting=total|toplevel|detailed 137 The total number of errors found is always printed. If 138 'toplevel' is provided, then the count of errors in each of 139 the top-level categories like 'build' and 'whitespace' will 140 also be printed. If 'detailed' is provided, then a count 141 is provided for each category like 'build/class'. 142""" 143 144# We categorize each error message we print. Here are the categories. 145# We want an explicit list so we can list them all in cpplint --filter=. 146# If you add a new error message with a new category, add it to the list 147# here! cpplint_unittest.py should tell you if you forget to do this. 148# \ used for clearer layout -- pylint: disable-msg=C6013 149_ERROR_CATEGORIES = [ 150 'build/class', 151 'build/deprecated', 152 'build/endif_comment', 153 'build/explicit_make_pair', 154 'build/forward_decl', 155 'build/header_guard', 156 'build/include', 157 'build/include_alpha', 158 'build/include_order', 159 'build/include_what_you_use', 160 'build/namespaces', 161 'build/printf_format', 162 'build/storage_class', 163 'legal/copyright', 164 'readability/braces', 165 'readability/casting', 166 'readability/check', 167 'readability/constructors', 168 'readability/fn_size', 169 'readability/function', 170 'readability/multiline_comment', 171 'readability/multiline_string', 172 'readability/nolint', 173 'readability/streams', 174 'readability/todo', 175 'readability/utf8', 176 'runtime/arrays', 177 'runtime/casting', 178 'runtime/explicit', 179 'runtime/int', 180 'runtime/init', 181 'runtime/invalid_increment', 182 'runtime/member_string_references', 183 'runtime/memset', 184 'runtime/operator', 185 'runtime/printf', 186 'runtime/printf_format', 187 'runtime/references', 188 'runtime/rtti', 189 'runtime/sizeof', 190 'runtime/string', 191 'runtime/threadsafe_fn', 192 'runtime/virtual', 193 'whitespace/blank_line', 194 'whitespace/braces', 195 'whitespace/comma', 196 'whitespace/comments', 197 'whitespace/end_of_line', 198 'whitespace/ending_newline', 199 'whitespace/indent', 200 'whitespace/labels', 201 'whitespace/line_length', 202 'whitespace/newline', 203 'whitespace/operators', 204 'whitespace/parens', 205 'whitespace/semicolon', 206 'whitespace/tab', 207 'whitespace/todo' 208 ] 209 210# The default state of the category filter. This is overrided by the --filter= 211# flag. By default all errors are on, so only add here categories that should be 212# off by default (i.e., categories that must be enabled by the --filter= flags). 213# All entries here should start with a '-' or '+', as in the --filter= flag. 214_DEFAULT_FILTERS = ['-build/include_alpha'] 215 216# We used to check for high-bit characters, but after much discussion we 217# decided those were OK, as long as they were in UTF-8 and didn't represent 218# hard-coded international strings, which belong in a separate i18n file. 219 220# Headers that we consider STL headers. 221_STL_HEADERS = frozenset([ 222 'algobase.h', 'algorithm', 'alloc.h', 'bitset', 'deque', 'exception', 223 'function.h', 'functional', 'hash_map', 'hash_map.h', 'hash_set', 224 'hash_set.h', 'iterator', 'list', 'list.h', 'map', 'memory', 'new', 225 'pair.h', 'pthread_alloc', 'queue', 'set', 'set.h', 'sstream', 'stack', 226 'stl_alloc.h', 'stl_relops.h', 'type_traits.h', 227 'utility', 'vector', 'vector.h', 228 ]) 229 230 231# Non-STL C++ system headers. 232_CPP_HEADERS = frozenset([ 233 'algo.h', 'builtinbuf.h', 'bvector.h', 'cassert', 'cctype', 234 'cerrno', 'cfloat', 'ciso646', 'climits', 'clocale', 'cmath', 235 'complex', 'complex.h', 'csetjmp', 'csignal', 'cstdarg', 'cstddef', 236 'cstdio', 'cstdlib', 'cstring', 'ctime', 'cwchar', 'cwctype', 237 'defalloc.h', 'deque.h', 'editbuf.h', 'exception', 'fstream', 238 'fstream.h', 'hashtable.h', 'heap.h', 'indstream.h', 'iomanip', 239 'iomanip.h', 'ios', 'iosfwd', 'iostream', 'iostream.h', 'istream', 240 'istream.h', 'iterator.h', 'limits', 'map.h', 'multimap.h', 'multiset.h', 241 'numeric', 'ostream', 'ostream.h', 'parsestream.h', 'pfstream.h', 242 'PlotFile.h', 'procbuf.h', 'pthread_alloc.h', 'rope', 'rope.h', 243 'ropeimpl.h', 'SFile.h', 'slist', 'slist.h', 'stack.h', 'stdexcept', 244 'stdiostream.h', 'streambuf.h', 'stream.h', 'strfile.h', 'string', 245 'strstream', 'strstream.h', 'tempbuf.h', 'tree.h', 'typeinfo', 'valarray', 246 ]) 247 248 249# Assertion macros. These are defined in base/logging.h and 250# testing/base/gunit.h. Note that the _M versions need to come first 251# for substring matching to work. 252_CHECK_MACROS = [ 253 'DCHECK', 'CHECK', 254 'EXPECT_TRUE_M', 'EXPECT_TRUE', 255 'ASSERT_TRUE_M', 'ASSERT_TRUE', 256 'EXPECT_FALSE_M', 'EXPECT_FALSE', 257 'ASSERT_FALSE_M', 'ASSERT_FALSE', 258 ] 259 260# Replacement macros for CHECK/DCHECK/EXPECT_TRUE/EXPECT_FALSE 261_CHECK_REPLACEMENT = dict([(m, {}) for m in _CHECK_MACROS]) 262 263for op, replacement in [('==', 'EQ'), ('!=', 'NE'), 264 ('>=', 'GE'), ('>', 'GT'), 265 ('<=', 'LE'), ('<', 'LT')]: 266 _CHECK_REPLACEMENT['DCHECK'][op] = 'DCHECK_%s' % replacement 267 _CHECK_REPLACEMENT['CHECK'][op] = 'CHECK_%s' % replacement 268 _CHECK_REPLACEMENT['EXPECT_TRUE'][op] = 'EXPECT_%s' % replacement 269 _CHECK_REPLACEMENT['ASSERT_TRUE'][op] = 'ASSERT_%s' % replacement 270 _CHECK_REPLACEMENT['EXPECT_TRUE_M'][op] = 'EXPECT_%s_M' % replacement 271 _CHECK_REPLACEMENT['ASSERT_TRUE_M'][op] = 'ASSERT_%s_M' % replacement 272 273for op, inv_replacement in [('==', 'NE'), ('!=', 'EQ'), 274 ('>=', 'LT'), ('>', 'LE'), 275 ('<=', 'GT'), ('<', 'GE')]: 276 _CHECK_REPLACEMENT['EXPECT_FALSE'][op] = 'EXPECT_%s' % inv_replacement 277 _CHECK_REPLACEMENT['ASSERT_FALSE'][op] = 'ASSERT_%s' % inv_replacement 278 _CHECK_REPLACEMENT['EXPECT_FALSE_M'][op] = 'EXPECT_%s_M' % inv_replacement 279 _CHECK_REPLACEMENT['ASSERT_FALSE_M'][op] = 'ASSERT_%s_M' % inv_replacement 280 281 282# These constants define types of headers for use with 283# _IncludeState.CheckNextIncludeOrder(). 284_C_SYS_HEADER = 1 285_CPP_SYS_HEADER = 2 286_LIKELY_MY_HEADER = 3 287_POSSIBLE_MY_HEADER = 4 288_OTHER_HEADER = 5 289 290 291_regexp_compile_cache = {} 292 293# Finds occurrences of NOLINT or NOLINT(...). 294_RE_SUPPRESSION = re.compile(r'\bNOLINT\b(\([^)]*\))?') 295 296# {str, set(int)}: a map from error categories to sets of linenumbers 297# on which those errors are expected and should be suppressed. 298_error_suppressions = {} 299 300def ParseNolintSuppressions(filename, raw_line, linenum, error): 301 """Updates the global list of error-suppressions. 302 303 Parses any NOLINT comments on the current line, updating the global 304 error_suppressions store. Reports an error if the NOLINT comment 305 was malformed. 306 307 Args: 308 filename: str, the name of the input file. 309 raw_line: str, the line of input text, with comments. 310 linenum: int, the number of the current line. 311 error: function, an error handler. 312 """ 313 # FIXME(adonovan): "NOLINT(" is misparsed as NOLINT(*). 314 matched = _RE_SUPPRESSION.search(raw_line) 315 if matched: 316 category = matched.group(1) 317 if category in (None, '(*)'): # => "suppress all" 318 _error_suppressions.setdefault(None, set()).add(linenum) 319 else: 320 if category.startswith('(') and category.endswith(')'): 321 category = category[1:-1] 322 if category in _ERROR_CATEGORIES: 323 _error_suppressions.setdefault(category, set()).add(linenum) 324 else: 325 error(filename, linenum, 'readability/nolint', 5, 326 'Unknown NOLINT error category: %s' % category) 327 328 329def ResetNolintSuppressions(): 330 "Resets the set of NOLINT suppressions to empty." 331 _error_suppressions.clear() 332 333 334def IsErrorSuppressedByNolint(category, linenum): 335 """Returns true if the specified error category is suppressed on this line. 336 337 Consults the global error_suppressions map populated by 338 ParseNolintSuppressions/ResetNolintSuppressions. 339 340 Args: 341 category: str, the category of the error. 342 linenum: int, the current line number. 343 Returns: 344 bool, True iff the error should be suppressed due to a NOLINT comment. 345 """ 346 return (linenum in _error_suppressions.get(category, set()) or 347 linenum in _error_suppressions.get(None, set())) 348 349def Match(pattern, s): 350 """Matches the string with the pattern, caching the compiled regexp.""" 351 # The regexp compilation caching is inlined in both Match and Search for 352 # performance reasons; factoring it out into a separate function turns out 353 # to be noticeably expensive. 354 if not pattern in _regexp_compile_cache: 355 _regexp_compile_cache[pattern] = sre_compile.compile(pattern) 356 return _regexp_compile_cache[pattern].match(s) 357 358 359def Search(pattern, s): 360 """Searches the string for the pattern, caching the compiled regexp.""" 361 if not pattern in _regexp_compile_cache: 362 _regexp_compile_cache[pattern] = sre_compile.compile(pattern) 363 return _regexp_compile_cache[pattern].search(s) 364 365 366class _IncludeState(dict): 367 """Tracks line numbers for includes, and the order in which includes appear. 368 369 As a dict, an _IncludeState object serves as a mapping between include 370 filename and line number on which that file was included. 371 372 Call CheckNextIncludeOrder() once for each header in the file, passing 373 in the type constants defined above. Calls in an illegal order will 374 raise an _IncludeError with an appropriate error message. 375 376 """ 377 # self._section will move monotonically through this set. If it ever 378 # needs to move backwards, CheckNextIncludeOrder will raise an error. 379 _INITIAL_SECTION = 0 380 _MY_H_SECTION = 1 381 _C_SECTION = 2 382 _CPP_SECTION = 3 383 _OTHER_H_SECTION = 4 384 385 _TYPE_NAMES = { 386 _C_SYS_HEADER: 'C system header', 387 _CPP_SYS_HEADER: 'C++ system header', 388 _LIKELY_MY_HEADER: 'header this file implements', 389 _POSSIBLE_MY_HEADER: 'header this file may implement', 390 _OTHER_HEADER: 'other header', 391 } 392 _SECTION_NAMES = { 393 _INITIAL_SECTION: "... nothing. (This can't be an error.)", 394 _MY_H_SECTION: 'a header this file implements', 395 _C_SECTION: 'C system header', 396 _CPP_SECTION: 'C++ system header', 397 _OTHER_H_SECTION: 'other header', 398 } 399 400 def __init__(self): 401 dict.__init__(self) 402 # The name of the current section. 403 self._section = self._INITIAL_SECTION 404 # The path of last found header. 405 self._last_header = '' 406 407 def CanonicalizeAlphabeticalOrder(self, header_path): 408 """Returns a path canonicalized for alphabetical comparison. 409 410 - replaces "-" with "_" so they both cmp the same. 411 - removes '-inl' since we don't require them to be after the main header. 412 - lowercase everything, just in case. 413 414 Args: 415 header_path: Path to be canonicalized. 416 417 Returns: 418 Canonicalized path. 419 """ 420 return header_path.replace('-inl.h', '.h').replace('-', '_').lower() 421 422 def IsInAlphabeticalOrder(self, header_path): 423 """Check if a header is in alphabetical order with the previous header. 424 425 Args: 426 header_path: Header to be checked. 427 428 Returns: 429 Returns true if the header is in alphabetical order. 430 """ 431 canonical_header = self.CanonicalizeAlphabeticalOrder(header_path) 432 if self._last_header > canonical_header: 433 return False 434 self._last_header = canonical_header 435 return True 436 437 def CheckNextIncludeOrder(self, header_type): 438 """Returns a non-empty error message if the next header is out of order. 439 440 This function also updates the internal state to be ready to check 441 the next include. 442 443 Args: 444 header_type: One of the _XXX_HEADER constants defined above. 445 446 Returns: 447 The empty string if the header is in the right order, or an 448 error message describing what's wrong. 449 450 """ 451 error_message = ('Found %s after %s' % 452 (self._TYPE_NAMES[header_type], 453 self._SECTION_NAMES[self._section])) 454 455 last_section = self._section 456 457 if header_type == _C_SYS_HEADER: 458 if self._section <= self._C_SECTION: 459 self._section = self._C_SECTION 460 else: 461 self._last_header = '' 462 return error_message 463 elif header_type == _CPP_SYS_HEADER: 464 if self._section <= self._CPP_SECTION: 465 self._section = self._CPP_SECTION 466 else: 467 self._last_header = '' 468 return error_message 469 elif header_type == _LIKELY_MY_HEADER: 470 if self._section <= self._MY_H_SECTION: 471 self._section = self._MY_H_SECTION 472 else: 473 self._section = self._OTHER_H_SECTION 474 elif header_type == _POSSIBLE_MY_HEADER: 475 if self._section <= self._MY_H_SECTION: 476 self._section = self._MY_H_SECTION 477 else: 478 # This will always be the fallback because we're not sure 479 # enough that the header is associated with this file. 480 self._section = self._OTHER_H_SECTION 481 else: 482 assert header_type == _OTHER_HEADER 483 self._section = self._OTHER_H_SECTION 484 485 if last_section != self._section: 486 self._last_header = '' 487 488 return '' 489 490 491class _CppLintState(object): 492 """Maintains module-wide state..""" 493 494 def __init__(self): 495 self.verbose_level = 1 # global setting. 496 self.error_count = 0 # global count of reported errors 497 # filters to apply when emitting error messages 498 self.filters = _DEFAULT_FILTERS[:] 499 self.counting = 'total' # In what way are we counting errors? 500 self.errors_by_category = {} # string to int dict storing error counts 501 502 # output format: 503 # "emacs" - format that emacs can parse (default) 504 # "vs7" - format that Microsoft Visual Studio 7 can parse 505 self.output_format = 'emacs' 506 507 def SetOutputFormat(self, output_format): 508 """Sets the output format for errors.""" 509 self.output_format = output_format 510 511 def SetVerboseLevel(self, level): 512 """Sets the module's verbosity, and returns the previous setting.""" 513 last_verbose_level = self.verbose_level 514 self.verbose_level = level 515 return last_verbose_level 516 517 def SetCountingStyle(self, counting_style): 518 """Sets the module's counting options.""" 519 self.counting = counting_style 520 521 def SetFilters(self, filters): 522 """Sets the error-message filters. 523 524 These filters are applied when deciding whether to emit a given 525 error message. 526 527 Args: 528 filters: A string of comma-separated filters (eg "+whitespace/indent"). 529 Each filter should start with + or -; else we die. 530 531 Raises: 532 ValueError: The comma-separated filters did not all start with '+' or '-'. 533 E.g. "-,+whitespace,-whitespace/indent,whitespace/badfilter" 534 """ 535 # Default filters always have less priority than the flag ones. 536 self.filters = _DEFAULT_FILTERS[:] 537 for filt in filters.split(','): 538 clean_filt = filt.strip() 539 if clean_filt: 540 self.filters.append(clean_filt) 541 for filt in self.filters: 542 if not (filt.startswith('+') or filt.startswith('-')): 543 raise ValueError('Every filter in --filters must start with + or -' 544 ' (%s does not)' % filt) 545 546 def ResetErrorCounts(self): 547 """Sets the module's error statistic back to zero.""" 548 self.error_count = 0 549 self.errors_by_category = {} 550 551 def IncrementErrorCount(self, category): 552 """Bumps the module's error statistic.""" 553 self.error_count += 1 554 if self.counting in ('toplevel', 'detailed'): 555 if self.counting != 'detailed': 556 category = category.split('/')[0] 557 if category not in self.errors_by_category: 558 self.errors_by_category[category] = 0 559 self.errors_by_category[category] += 1 560 561 def PrintErrorCounts(self): 562 """Print a summary of errors by category, and the total.""" 563 for category, count in self.errors_by_category.iteritems(): 564 sys.stderr.write('Category \'%s\' errors found: %d\n' % 565 (category, count)) 566 sys.stderr.write('Total errors found: %d\n' % self.error_count) 567 568_cpplint_state = _CppLintState() 569 570 571def _OutputFormat(): 572 """Gets the module's output format.""" 573 return _cpplint_state.output_format 574 575 576def _SetOutputFormat(output_format): 577 """Sets the module's output format.""" 578 _cpplint_state.SetOutputFormat(output_format) 579 580 581def _VerboseLevel(): 582 """Returns the module's verbosity setting.""" 583 return _cpplint_state.verbose_level 584 585 586def _SetVerboseLevel(level): 587 """Sets the module's verbosity, and returns the previous setting.""" 588 return _cpplint_state.SetVerboseLevel(level) 589 590 591def _SetCountingStyle(level): 592 """Sets the module's counting options.""" 593 _cpplint_state.SetCountingStyle(level) 594 595 596def _Filters(): 597 """Returns the module's list of output filters, as a list.""" 598 return _cpplint_state.filters 599 600 601def _SetFilters(filters): 602 """Sets the module's error-message filters. 603 604 These filters are applied when deciding whether to emit a given 605 error message. 606 607 Args: 608 filters: A string of comma-separated filters (eg "whitespace/indent"). 609 Each filter should start with + or -; else we die. 610 """ 611 _cpplint_state.SetFilters(filters) 612 613 614class _FunctionState(object): 615 """Tracks current function name and the number of lines in its body.""" 616 617 _NORMAL_TRIGGER = 250 # for --v=0, 500 for --v=1, etc. 618 _TEST_TRIGGER = 400 # about 50% more than _NORMAL_TRIGGER. 619 620 def __init__(self): 621 self.in_a_function = False 622 self.lines_in_function = 0 623 self.current_function = '' 624 625 def Begin(self, function_name): 626 """Start analyzing function body. 627 628 Args: 629 function_name: The name of the function being tracked. 630 """ 631 self.in_a_function = True 632 self.lines_in_function = 0 633 self.current_function = function_name 634 635 def Count(self): 636 """Count line in current function body.""" 637 if self.in_a_function: 638 self.lines_in_function += 1 639 640 def Check(self, error, filename, linenum): 641 """Report if too many lines in function body. 642 643 Args: 644 error: The function to call with any errors found. 645 filename: The name of the current file. 646 linenum: The number of the line to check. 647 """ 648 if Match(r'T(EST|est)', self.current_function): 649 base_trigger = self._TEST_TRIGGER 650 else: 651 base_trigger = self._NORMAL_TRIGGER 652 trigger = base_trigger * 2**_VerboseLevel() 653 654 if self.lines_in_function > trigger: 655 error_level = int(math.log(self.lines_in_function / base_trigger, 2)) 656 # 50 => 0, 100 => 1, 200 => 2, 400 => 3, 800 => 4, 1600 => 5, ... 657 if error_level > 5: 658 error_level = 5 659 error(filename, linenum, 'readability/fn_size', error_level, 660 'Small and focused functions are preferred:' 661 ' %s has %d non-comment lines' 662 ' (error triggered by exceeding %d lines).' % ( 663 self.current_function, self.lines_in_function, trigger)) 664 665 def End(self): 666 """Stop analyzing function body.""" 667 self.in_a_function = False 668 669 670class _IncludeError(Exception): 671 """Indicates a problem with the include order in a file.""" 672 pass 673 674 675class FileInfo: 676 """Provides utility functions for filenames. 677 678 FileInfo provides easy access to the components of a file's path 679 relative to the project root. 680 """ 681 682 def __init__(self, filename): 683 self._filename = filename 684 685 def FullName(self): 686 """Make Windows paths like Unix.""" 687 return os.path.abspath(self._filename).replace('\\', '/') 688 689 def RepositoryName(self): 690 """FullName after removing the local path to the repository. 691 692 If we have a real absolute path name here we can try to do something smart: 693 detecting the root of the checkout and truncating /path/to/checkout from 694 the name so that we get header guards that don't include things like 695 "C:\Documents and Settings\..." or "/home/username/..." in them and thus 696 people on different computers who have checked the source out to different 697 locations won't see bogus errors. 698 """ 699 fullname = self.FullName() 700 701 if os.path.exists(fullname): 702 project_dir = os.path.dirname(fullname) 703 704 if os.path.exists(os.path.join(project_dir, ".svn")): 705 # If there's a .svn file in the current directory, we recursively look 706 # up the directory tree for the top of the SVN checkout 707 root_dir = project_dir 708 one_up_dir = os.path.dirname(root_dir) 709 while os.path.exists(os.path.join(one_up_dir, ".svn")): 710 root_dir = os.path.dirname(root_dir) 711 one_up_dir = os.path.dirname(one_up_dir) 712 713 prefix = os.path.commonprefix([root_dir, project_dir]) 714 return fullname[len(prefix) + 1:] 715 716 # Not SVN <= 1.6? Try to find a git, hg, or svn top level directory by 717 # searching up from the current path. 718 root_dir = os.path.dirname(fullname) 719 while (root_dir != os.path.dirname(root_dir) and 720 not os.path.exists(os.path.join(root_dir, ".git")) and 721 not os.path.exists(os.path.join(root_dir, ".hg")) and 722 not os.path.exists(os.path.join(root_dir, ".svn"))): 723 root_dir = os.path.dirname(root_dir) 724 725 if (os.path.exists(os.path.join(root_dir, ".git")) or 726 os.path.exists(os.path.join(root_dir, ".hg")) or 727 os.path.exists(os.path.join(root_dir, ".svn"))): 728 prefix = os.path.commonprefix([root_dir, project_dir]) 729 return fullname[len(prefix) + 1:] 730 731 # Don't know what to do; header guard warnings may be wrong... 732 return fullname 733 734 def Split(self): 735 """Splits the file into the directory, basename, and extension. 736 737 For 'chrome/browser/browser.cc', Split() would 738 return ('chrome/browser', 'browser', '.cc') 739 740 Returns: 741 A tuple of (directory, basename, extension). 742 """ 743 744 googlename = self.RepositoryName() 745 project, rest = os.path.split(googlename) 746 return (project,) + os.path.splitext(rest) 747 748 def BaseName(self): 749 """File base name - text after the final slash, before the final period.""" 750 return self.Split()[1] 751 752 def Extension(self): 753 """File extension - text following the final period.""" 754 return self.Split()[2] 755 756 def NoExtension(self): 757 """File has no source file extension.""" 758 return '/'.join(self.Split()[0:2]) 759 760 def IsSource(self): 761 """File has a source file extension.""" 762 return self.Extension()[1:] in ('c', 'cc', 'cpp', 'cxx') 763 764 765def _ShouldPrintError(category, confidence, linenum): 766 """If confidence >= verbose, category passes filter and is not suppressed.""" 767 768 # There are three ways we might decide not to print an error message: 769 # a "NOLINT(category)" comment appears in the source, 770 # the verbosity level isn't high enough, or the filters filter it out. 771 if IsErrorSuppressedByNolint(category, linenum): 772 return False 773 if confidence < _cpplint_state.verbose_level: 774 return False 775 776 is_filtered = False 777 for one_filter in _Filters(): 778 if one_filter.startswith('-'): 779 if category.startswith(one_filter[1:]): 780 is_filtered = True 781 elif one_filter.startswith('+'): 782 if category.startswith(one_filter[1:]): 783 is_filtered = False 784 else: 785 assert False # should have been checked for in SetFilter. 786 if is_filtered: 787 return False 788 789 return True 790 791 792def Error(filename, linenum, category, confidence, message): 793 """Logs the fact we've found a lint error. 794 795 We log where the error was found, and also our confidence in the error, 796 that is, how certain we are this is a legitimate style regression, and 797 not a misidentification or a use that's sometimes justified. 798 799 False positives can be suppressed by the use of 800 "cpplint(category)" comments on the offending line. These are 801 parsed into _error_suppressions. 802 803 Args: 804 filename: The name of the file containing the error. 805 linenum: The number of the line containing the error. 806 category: A string used to describe the "category" this bug 807 falls under: "whitespace", say, or "runtime". Categories 808 may have a hierarchy separated by slashes: "whitespace/indent". 809 confidence: A number from 1-5 representing a confidence score for 810 the error, with 5 meaning that we are certain of the problem, 811 and 1 meaning that it could be a legitimate construct. 812 message: The error message. 813 """ 814 if _ShouldPrintError(category, confidence, linenum): 815 _cpplint_state.IncrementErrorCount(category) 816 if _cpplint_state.output_format == 'vs7': 817 sys.stderr.write('%s(%s): %s [%s] [%d]\n' % ( 818 filename, linenum, message, category, confidence)) 819 else: 820 sys.stderr.write('%s:%s: %s [%s] [%d]\n' % ( 821 filename, linenum, message, category, confidence)) 822 823 824# Matches standard C++ escape esequences per 2.13.2.3 of the C++ standard. 825_RE_PATTERN_CLEANSE_LINE_ESCAPES = re.compile( 826 r'\\([abfnrtv?"\\\']|\d+|x[0-9a-fA-F]+)') 827# Matches strings. Escape codes should already be removed by ESCAPES. 828_RE_PATTERN_CLEANSE_LINE_DOUBLE_QUOTES = re.compile(r'"[^"]*"') 829# Matches characters. Escape codes should already be removed by ESCAPES. 830_RE_PATTERN_CLEANSE_LINE_SINGLE_QUOTES = re.compile(r"'.'") 831# Matches multi-line C++ comments. 832# This RE is a little bit more complicated than one might expect, because we 833# have to take care of space removals tools so we can handle comments inside 834# statements better. 835# The current rule is: We only clear spaces from both sides when we're at the 836# end of the line. Otherwise, we try to remove spaces from the right side, 837# if this doesn't work we try on left side but only if there's a non-character 838# on the right. 839_RE_PATTERN_CLEANSE_LINE_C_COMMENTS = re.compile( 840 r"""(\s*/\*.*\*/\s*$| 841 /\*.*\*/\s+| 842 \s+/\*.*\*/(?=\W)| 843 /\*.*\*/)""", re.VERBOSE) 844 845 846def IsCppString(line): 847 """Does line terminate so, that the next symbol is in string constant. 848 849 This function does not consider single-line nor multi-line comments. 850 851 Args: 852 line: is a partial line of code starting from the 0..n. 853 854 Returns: 855 True, if next character appended to 'line' is inside a 856 string constant. 857 """ 858 859 line = line.replace(r'\\', 'XX') # after this, \\" does not match to \" 860 return ((line.count('"') - line.count(r'\"') - line.count("'\"'")) & 1) == 1 861 862 863def FindNextMultiLineCommentStart(lines, lineix): 864 """Find the beginning marker for a multiline comment.""" 865 while lineix < len(lines): 866 if lines[lineix].strip().startswith('/*'): 867 # Only return this marker if the comment goes beyond this line 868 if lines[lineix].strip().find('*/', 2) < 0: 869 return lineix 870 lineix += 1 871 return len(lines) 872 873 874def FindNextMultiLineCommentEnd(lines, lineix): 875 """We are inside a comment, find the end marker.""" 876 while lineix < len(lines): 877 if lines[lineix].strip().endswith('*/'): 878 return lineix 879 lineix += 1 880 return len(lines) 881 882 883def RemoveMultiLineCommentsFromRange(lines, begin, end): 884 """Clears a range of lines for multi-line comments.""" 885 # Having // dummy comments makes the lines non-empty, so we will not get 886 # unnecessary blank line warnings later in the code. 887 for i in range(begin, end): 888 lines[i] = '// dummy' 889 890 891def RemoveMultiLineComments(filename, lines, error): 892 """Removes multiline (c-style) comments from lines.""" 893 lineix = 0 894 while lineix < len(lines): 895 lineix_begin = FindNextMultiLineCommentStart(lines, lineix) 896 if lineix_begin >= len(lines): 897 return 898 lineix_end = FindNextMultiLineCommentEnd(lines, lineix_begin) 899 if lineix_end >= len(lines): 900 error(filename, lineix_begin + 1, 'readability/multiline_comment', 5, 901 'Could not find end of multi-line comment') 902 return 903 RemoveMultiLineCommentsFromRange(lines, lineix_begin, lineix_end + 1) 904 lineix = lineix_end + 1 905 906 907def CleanseComments(line): 908 """Removes //-comments and single-line C-style /* */ comments. 909 910 Args: 911 line: A line of C++ source. 912 913 Returns: 914 The line with single-line comments removed. 915 """ 916 commentpos = line.find('//') 917 if commentpos != -1 and not IsCppString(line[:commentpos]): 918 line = line[:commentpos].rstrip() 919 # get rid of /* ... */ 920 return _RE_PATTERN_CLEANSE_LINE_C_COMMENTS.sub('', line) 921 922 923class CleansedLines(object): 924 """Holds 3 copies of all lines with different preprocessing applied to them. 925 926 1) elided member contains lines without strings and comments, 927 2) lines member contains lines without comments, and 928 3) raw member contains all the lines without processing. 929 All these three members are of <type 'list'>, and of the same length. 930 """ 931 932 def __init__(self, lines): 933 self.elided = [] 934 self.lines = [] 935 self.raw_lines = lines 936 self.num_lines = len(lines) 937 for linenum in range(len(lines)): 938 self.lines.append(CleanseComments(lines[linenum])) 939 elided = self._CollapseStrings(lines[linenum]) 940 self.elided.append(CleanseComments(elided)) 941 942 def NumLines(self): 943 """Returns the number of lines represented.""" 944 return self.num_lines 945 946 @staticmethod 947 def _CollapseStrings(elided): 948 """Collapses strings and chars on a line to simple "" or '' blocks. 949 950 We nix strings first so we're not fooled by text like '"http://"' 951 952 Args: 953 elided: The line being processed. 954 955 Returns: 956 The line with collapsed strings. 957 """ 958 if not _RE_PATTERN_INCLUDE.match(elided): 959 # Remove escaped characters first to make quote/single quote collapsing 960 # basic. Things that look like escaped characters shouldn't occur 961 # outside of strings and chars. 962 elided = _RE_PATTERN_CLEANSE_LINE_ESCAPES.sub('', elided) 963 elided = _RE_PATTERN_CLEANSE_LINE_SINGLE_QUOTES.sub("''", elided) 964 elided = _RE_PATTERN_CLEANSE_LINE_DOUBLE_QUOTES.sub('""', elided) 965 return elided 966 967 968def CloseExpression(clean_lines, linenum, pos): 969 """If input points to ( or { or [, finds the position that closes it. 970 971 If lines[linenum][pos] points to a '(' or '{' or '[', finds the 972 linenum/pos that correspond to the closing of the expression. 973 974 Args: 975 clean_lines: A CleansedLines instance containing the file. 976 linenum: The number of the line to check. 977 pos: A position on the line. 978 979 Returns: 980 A tuple (line, linenum, pos) pointer *past* the closing brace, or 981 (line, len(lines), -1) if we never find a close. Note we ignore 982 strings and comments when matching; and the line we return is the 983 'cleansed' line at linenum. 984 """ 985 986 line = clean_lines.elided[linenum] 987 startchar = line[pos] 988 if startchar not in '({[': 989 return (line, clean_lines.NumLines(), -1) 990 if startchar == '(': endchar = ')' 991 if startchar == '[': endchar = ']' 992 if startchar == '{': endchar = '}' 993 994 num_open = line.count(startchar) - line.count(endchar) 995 while linenum < clean_lines.NumLines() and num_open > 0: 996 linenum += 1 997 line = clean_lines.elided[linenum] 998 num_open += line.count(startchar) - line.count(endchar) 999 # OK, now find the endchar that actually got us back to even 1000 endpos = len(line) 1001 while num_open >= 0: 1002 endpos = line.rfind(')', 0, endpos) 1003 num_open -= 1 # chopped off another ) 1004 return (line, linenum, endpos + 1) 1005 1006 1007def CheckForCopyright(filename, lines, error): 1008 """Logs an error if no Copyright message appears at the top of the file.""" 1009 1010 # We'll say it should occur by line 10. Don't forget there's a 1011 # dummy line at the front. 1012 for line in xrange(1, min(len(lines), 11)): 1013 if re.search(r'Copyright', lines[line], re.I): break 1014 else: # means no copyright line was found 1015 error(filename, 0, 'legal/copyright', 5, 1016 'No copyright message found. ' 1017 'You should have a line: "Copyright [year] <Copyright Owner>"') 1018 1019 1020def GetHeaderGuardCPPVariable(filename): 1021 """Returns the CPP variable that should be used as a header guard. 1022 1023 Args: 1024 filename: The name of a C++ header file. 1025 1026 Returns: 1027 The CPP variable that should be used as a header guard in the 1028 named file. 1029 1030 """ 1031 1032 # Restores original filename in case that cpplint is invoked from Emacs's 1033 # flymake. 1034 filename = re.sub(r'_flymake\.h$', '.h', filename) 1035 1036 fileinfo = FileInfo(filename) 1037 return re.sub(r'[-./\s]', '_', fileinfo.RepositoryName()).upper() + '_' 1038 1039 1040def CheckForHeaderGuard(filename, lines, error): 1041 """Checks that the file contains a header guard. 1042 1043 Logs an error if no #ifndef header guard is present. For other 1044 headers, checks that the full pathname is used. 1045 1046 Args: 1047 filename: The name of the C++ header file. 1048 lines: An array of strings, each representing a line of the file. 1049 error: The function to call with any errors found. 1050 """ 1051 1052 cppvar = GetHeaderGuardCPPVariable(filename) 1053 1054 ifndef = None 1055 ifndef_linenum = 0 1056 define = None 1057 endif = None 1058 endif_linenum = 0 1059 for linenum, line in enumerate(lines): 1060 linesplit = line.split() 1061 if len(linesplit) >= 2: 1062 # find the first occurrence of #ifndef and #define, save arg 1063 if not ifndef and linesplit[0] == '#ifndef': 1064 # set ifndef to the header guard presented on the #ifndef line. 1065 ifndef = linesplit[1] 1066 ifndef_linenum = linenum 1067 if not define and linesplit[0] == '#define': 1068 define = linesplit[1] 1069 # find the last occurrence of #endif, save entire line 1070 if line.startswith('#endif'): 1071 endif = line 1072 endif_linenum = linenum 1073 1074 if not ifndef: 1075 error(filename, 0, 'build/header_guard', 5, 1076 'No #ifndef header guard found, suggested CPP variable is: %s' % 1077 cppvar) 1078 return 1079 1080 if not define: 1081 error(filename, 0, 'build/header_guard', 5, 1082 'No #define header guard found, suggested CPP variable is: %s' % 1083 cppvar) 1084 return 1085 1086 # The guard should be PATH_FILE_H_, but we also allow PATH_FILE_H__ 1087 # for backward compatibility. 1088 if ifndef != cppvar: 1089 error_level = 0 1090 if ifndef != cppvar + '_': 1091 error_level = 5 1092 1093 ParseNolintSuppressions(filename, lines[ifndef_linenum], ifndef_linenum, 1094 error) 1095 error(filename, ifndef_linenum, 'build/header_guard', error_level, 1096 '#ifndef header guard has wrong style, please use: %s' % cppvar) 1097 1098 if define != ifndef: 1099 error(filename, 0, 'build/header_guard', 5, 1100 '#ifndef and #define don\'t match, suggested CPP variable is: %s' % 1101 cppvar) 1102 return 1103 1104 if endif != ('#endif // %s' % cppvar): 1105 error_level = 0 1106 if endif != ('#endif // %s' % (cppvar + '_')): 1107 error_level = 5 1108 1109 ParseNolintSuppressions(filename, lines[endif_linenum], endif_linenum, 1110 error) 1111 error(filename, endif_linenum, 'build/header_guard', error_level, 1112 '#endif line should be "#endif // %s"' % cppvar) 1113 1114 1115def CheckForUnicodeReplacementCharacters(filename, lines, error): 1116 """Logs an error for each line containing Unicode replacement characters. 1117 1118 These indicate that either the file contained invalid UTF-8 (likely) 1119 or Unicode replacement characters (which it shouldn't). Note that 1120 it's possible for this to throw off line numbering if the invalid 1121 UTF-8 occurred adjacent to a newline. 1122 1123 Args: 1124 filename: The name of the current file. 1125 lines: An array of strings, each representing a line of the file. 1126 error: The function to call with any errors found. 1127 """ 1128 for linenum, line in enumerate(lines): 1129 if u'\ufffd' in line: 1130 error(filename, linenum, 'readability/utf8', 5, 1131 'Line contains invalid UTF-8 (or Unicode replacement character).') 1132 1133 1134def CheckForNewlineAtEOF(filename, lines, error): 1135 """Logs an error if there is no newline char at the end of the file. 1136 1137 Args: 1138 filename: The name of the current file. 1139 lines: An array of strings, each representing a line of the file. 1140 error: The function to call with any errors found. 1141 """ 1142 1143 # The array lines() was created by adding two newlines to the 1144 # original file (go figure), then splitting on \n. 1145 # To verify that the file ends in \n, we just have to make sure the 1146 # last-but-two element of lines() exists and is empty. 1147 if len(lines) < 3 or lines[-2]: 1148 error(filename, len(lines) - 2, 'whitespace/ending_newline', 5, 1149 'Could not find a newline character at the end of the file.') 1150 1151 1152def CheckForMultilineCommentsAndStrings(filename, clean_lines, linenum, error): 1153 """Logs an error if we see /* ... */ or "..." that extend past one line. 1154 1155 /* ... */ comments are legit inside macros, for one line. 1156 Otherwise, we prefer // comments, so it's ok to warn about the 1157 other. Likewise, it's ok for strings to extend across multiple 1158 lines, as long as a line continuation character (backslash) 1159 terminates each line. Although not currently prohibited by the C++ 1160 style guide, it's ugly and unnecessary. We don't do well with either 1161 in this lint program, so we warn about both. 1162 1163 Args: 1164 filename: The name of the current file. 1165 clean_lines: A CleansedLines instance containing the file. 1166 linenum: The number of the line to check. 1167 error: The function to call with any errors found. 1168 """ 1169 line = clean_lines.elided[linenum] 1170 1171 # Remove all \\ (escaped backslashes) from the line. They are OK, and the 1172 # second (escaped) slash may trigger later \" detection erroneously. 1173 line = line.replace('\\\\', '') 1174 1175 if line.count('/*') > line.count('*/'): 1176 error(filename, linenum, 'readability/multiline_comment', 5, 1177 'Complex multi-line /*...*/-style comment found. ' 1178 'Lint may give bogus warnings. ' 1179 'Consider replacing these with //-style comments, ' 1180 'with #if 0...#endif, ' 1181 'or with more clearly structured multi-line comments.') 1182 1183 if (line.count('"') - line.count('\\"')) % 2: 1184 error(filename, linenum, 'readability/multiline_string', 5, 1185 'Multi-line string ("...") found. This lint script doesn\'t ' 1186 'do well with such strings, and may give bogus warnings. They\'re ' 1187 'ugly and unnecessary, and you should use concatenation instead".') 1188 1189 1190threading_list = ( 1191 ('asctime(', 'asctime_r('), 1192 ('ctime(', 'ctime_r('), 1193 ('getgrgid(', 'getgrgid_r('), 1194 ('getgrnam(', 'getgrnam_r('), 1195 ('getlogin(', 'getlogin_r('), 1196 ('getpwnam(', 'getpwnam_r('), 1197 ('getpwuid(', 'getpwuid_r('), 1198 ('gmtime(', 'gmtime_r('), 1199 ('localtime(', 'localtime_r('), 1200 ('rand(', 'rand_r('), 1201 ('readdir(', 'readdir_r('), 1202 ('strtok(', 'strtok_r('), 1203 ('ttyname(', 'ttyname_r('), 1204 ) 1205 1206 1207def CheckPosixThreading(filename, clean_lines, linenum, error): 1208 """Checks for calls to thread-unsafe functions. 1209 1210 Much code has been originally written without consideration of 1211 multi-threading. Also, engineers are relying on their old experience; 1212 they have learned posix before threading extensions were added. These 1213 tests guide the engineers to use thread-safe functions (when using 1214 posix directly). 1215 1216 Args: 1217 filename: The name of the current file. 1218 clean_lines: A CleansedLines instance containing the file. 1219 linenum: The number of the line to check. 1220 error: The function to call with any errors found. 1221 """ 1222 line = clean_lines.elided[linenum] 1223 for single_thread_function, multithread_safe_function in threading_list: 1224 ix = line.find(single_thread_function) 1225 # Comparisons made explicit for clarity -- pylint: disable-msg=C6403 1226 if ix >= 0 and (ix == 0 or (not line[ix - 1].isalnum() and 1227 line[ix - 1] not in ('_', '.', '>'))): 1228 error(filename, linenum, 'runtime/threadsafe_fn', 2, 1229 'Consider using ' + multithread_safe_function + 1230 '...) instead of ' + single_thread_function + 1231 '...) for improved thread safety.') 1232 1233 1234# Matches invalid increment: *count++, which moves pointer instead of 1235# incrementing a value. 1236_RE_PATTERN_INVALID_INCREMENT = re.compile( 1237 r'^\s*\*\w+(\+\+|--);') 1238 1239 1240def CheckInvalidIncrement(filename, clean_lines, linenum, error): 1241 """Checks for invalid increment *count++. 1242 1243 For example following function: 1244 void increment_counter(int* count) { 1245 *count++; 1246 } 1247 is invalid, because it effectively does count++, moving pointer, and should 1248 be replaced with ++*count, (*count)++ or *count += 1. 1249 1250 Args: 1251 filename: The name of the current file. 1252 clean_lines: A CleansedLines instance containing the file. 1253 linenum: The number of the line to check. 1254 error: The function to call with any errors found. 1255 """ 1256 line = clean_lines.elided[linenum] 1257 if _RE_PATTERN_INVALID_INCREMENT.match(line): 1258 error(filename, linenum, 'runtime/invalid_increment', 5, 1259 'Changing pointer instead of value (or unused value of operator*).') 1260 1261 1262class _ClassInfo(object): 1263 """Stores information about a class.""" 1264 1265 def __init__(self, name, clean_lines, linenum): 1266 self.name = name 1267 self.linenum = linenum 1268 self.seen_open_brace = False 1269 self.is_derived = False 1270 self.virtual_method_linenumber = None 1271 self.has_virtual_destructor = False 1272 self.brace_depth = 0 1273 1274 # Try to find the end of the class. This will be confused by things like: 1275 # class A { 1276 # } *x = { ... 1277 # 1278 # But it's still good enough for CheckSectionSpacing. 1279 self.last_line = 0 1280 depth = 0 1281 for i in range(linenum, clean_lines.NumLines()): 1282 line = clean_lines.lines[i] 1283 depth += line.count('{') - line.count('}') 1284 if not depth: 1285 self.last_line = i 1286 break 1287 1288 1289class _ClassState(object): 1290 """Holds the current state of the parse relating to class declarations. 1291 1292 It maintains a stack of _ClassInfos representing the parser's guess 1293 as to the current nesting of class declarations. The innermost class 1294 is at the top (back) of the stack. Typically, the stack will either 1295 be empty or have exactly one entry. 1296 """ 1297 1298 def __init__(self): 1299 self.classinfo_stack = [] 1300 1301 def CheckFinished(self, filename, error): 1302 """Checks that all classes have been completely parsed. 1303 1304 Call this when all lines in a file have been processed. 1305 Args: 1306 filename: The name of the current file. 1307 error: The function to call with any errors found. 1308 """ 1309 if self.classinfo_stack: 1310 # Note: This test can result in false positives if #ifdef constructs 1311 # get in the way of brace matching. See the testBuildClass test in 1312 # cpplint_unittest.py for an example of this. 1313 error(filename, self.classinfo_stack[0].linenum, 'build/class', 5, 1314 'Failed to find complete declaration of class %s' % 1315 self.classinfo_stack[0].name) 1316 1317 1318def CheckForNonStandardConstructs(filename, clean_lines, linenum, 1319 class_state, error): 1320 """Logs an error if we see certain non-ANSI constructs ignored by gcc-2. 1321 1322 Complain about several constructs which gcc-2 accepts, but which are 1323 not standard C++. Warning about these in lint is one way to ease the 1324 transition to new compilers. 1325 - put storage class first (e.g. "static const" instead of "const static"). 1326 - "%lld" instead of %qd" in printf-type functions. 1327 - "%1$d" is non-standard in printf-type functions. 1328 - "\%" is an undefined character escape sequence. 1329 - text after #endif is not allowed. 1330 - invalid inner-style forward declaration. 1331 - >? and <? operators, and their >?= and <?= cousins. 1332 - classes with virtual methods need virtual destructors (compiler warning 1333 available, but not turned on yet.) 1334 1335 Additionally, check for constructor/destructor style violations and reference 1336 members, as it is very convenient to do so while checking for 1337 gcc-2 compliance. 1338 1339 Args: 1340 filename: The name of the current file. 1341 clean_lines: A CleansedLines instance containing the file. 1342 linenum: The number of the line to check. 1343 class_state: A _ClassState instance which maintains information about 1344 the current stack of nested class declarations being parsed. 1345 error: A callable to which errors are reported, which takes 4 arguments: 1346 filename, line number, error level, and message 1347 """ 1348 1349 # Remove comments from the line, but leave in strings for now. 1350 line = clean_lines.lines[linenum] 1351 1352 if Search(r'printf\s*\(.*".*%[-+ ]?\d*q', line): 1353 error(filename, linenum, 'runtime/printf_format', 3, 1354 '%q in format strings is deprecated. Use %ll instead.') 1355 1356 if Search(r'printf\s*\(.*".*%\d+\$', line): 1357 error(filename, linenum, 'runtime/printf_format', 2, 1358 '%N$ formats are unconventional. Try rewriting to avoid them.') 1359 1360 # Remove escaped backslashes before looking for undefined escapes. 1361 line = line.replace('\\\\', '') 1362 1363 if Search(r'("|\').*\\(%|\[|\(|{)', line): 1364 error(filename, linenum, 'build/printf_format', 3, 1365 '%, [, (, and { are undefined character escapes. Unescape them.') 1366 1367 # For the rest, work with both comments and strings removed. 1368 line = clean_lines.elided[linenum] 1369 1370 if Search(r'\b(const|volatile|void|char|short|int|long' 1371 r'|float|double|signed|unsigned' 1372 r'|schar|u?int8|u?int16|u?int32|u?int64)' 1373 r'\s+(auto|register|static|extern|typedef)\b', 1374 line): 1375 error(filename, linenum, 'build/storage_class', 5, 1376 'Storage class (static, extern, typedef, etc) should be first.') 1377 1378 if Match(r'\s*#\s*endif\s*[^/\s]+', line): 1379 error(filename, linenum, 'build/endif_comment', 5, 1380 'Uncommented text after #endif is non-standard. Use a comment.') 1381 1382 if Match(r'\s*class\s+(\w+\s*::\s*)+\w+\s*;', line): 1383 error(filename, linenum, 'build/forward_decl', 5, 1384 'Inner-style forward declarations are invalid. Remove this line.') 1385 1386 if Search(r'(\w+|[+-]?\d+(\.\d*)?)\s*(<|>)\?=?\s*(\w+|[+-]?\d+)(\.\d*)?', 1387 line): 1388 error(filename, linenum, 'build/deprecated', 3, 1389 '>? and <? (max and min) operators are non-standard and deprecated.') 1390 1391 if Search(r'^\s*const\s*string\s*&\s*\w+\s*;', line): 1392 # TODO(unknown): Could it be expanded safely to arbitrary references, 1393 # without triggering too many false positives? The first 1394 # attempt triggered 5 warnings for mostly benign code in the regtest, hence 1395 # the restriction. 1396 # Here's the original regexp, for the reference: 1397 # type_name = r'\w+((\s*::\s*\w+)|(\s*<\s*\w+?\s*>))?' 1398 # r'\s*const\s*' + type_name + '\s*&\s*\w+\s*;' 1399 error(filename, linenum, 'runtime/member_string_references', 2, 1400 'const string& members are dangerous. It is much better to use ' 1401 'alternatives, such as pointers or simple constants.') 1402 1403 # Track class entry and exit, and attempt to find cases within the 1404 # class declaration that don't meet the C++ style 1405 # guidelines. Tracking is very dependent on the code matching Google 1406 # style guidelines, but it seems to perform well enough in testing 1407 # to be a worthwhile addition to the checks. 1408 classinfo_stack = class_state.classinfo_stack 1409 # Look for a class declaration. The regexp accounts for decorated classes 1410 # such as in: 1411 # class LOCKABLE API Object { 1412 # }; 1413 class_decl_match = Match( 1414 r'\s*(template\s*<[\w\s<>,:]*>\s*)?' 1415 '(class|struct)\s+([A-Z_]+\s+)*(\w+(::\w+)*)', line) 1416 if class_decl_match: 1417 classinfo_stack.append(_ClassInfo( 1418 class_decl_match.group(4), clean_lines, linenum)) 1419 1420 # Everything else in this function uses the top of the stack if it's 1421 # not empty. 1422 if not classinfo_stack: 1423 return 1424 1425 classinfo = classinfo_stack[-1] 1426 1427 # If the opening brace hasn't been seen look for it and also 1428 # parent class declarations. 1429 if not classinfo.seen_open_brace: 1430 # If the line has a ';' in it, assume it's a forward declaration or 1431 # a single-line class declaration, which we won't process. 1432 if line.find(';') != -1: 1433 classinfo_stack.pop() 1434 return 1435 classinfo.seen_open_brace = (line.find('{') != -1) 1436 # Look for a bare ':' 1437 if Search('(^|[^:]):($|[^:])', line): 1438 classinfo.is_derived = True 1439 if not classinfo.seen_open_brace: 1440 return # Everything else in this function is for after open brace 1441 1442 # The class may have been declared with namespace or classname qualifiers. 1443 # The constructor and destructor will not have those qualifiers. 1444 base_classname = classinfo.name.split('::')[-1] 1445 1446 # Look for single-argument constructors that aren't marked explicit. 1447 # Technically a valid construct, but against style. 1448 args = Match(r'\s+(?:inline\s+)?%s\s*\(([^,()]+)\)' 1449 % re.escape(base_classname), 1450 line) 1451 if (args and 1452 args.group(1) != 'void' and 1453 not Match(r'(const\s+)?%s\s*(?:<\w+>\s*)?&' % re.escape(base_classname), 1454 args.group(1).strip())): 1455 error(filename, linenum, 'runtime/explicit', 5, 1456 'Single-argument constructors should be marked explicit.') 1457 1458 # Look for methods declared virtual. 1459 if Search(r'\bvirtual\b', line): 1460 classinfo.virtual_method_linenumber = linenum 1461 # Only look for a destructor declaration on the same line. It would 1462 # be extremely unlikely for the destructor declaration to occupy 1463 # more than one line. 1464 if Search(r'~%s\s*\(' % base_classname, line): 1465 classinfo.has_virtual_destructor = True 1466 1467 # Look for class end. 1468 brace_depth = classinfo.brace_depth 1469 brace_depth = brace_depth + line.count('{') - line.count('}') 1470 if brace_depth <= 0: 1471 classinfo = classinfo_stack.pop() 1472 # Try to detect missing virtual destructor declarations. 1473 # For now, only warn if a non-derived class with virtual methods lacks 1474 # a virtual destructor. This is to make it less likely that people will 1475 # declare derived virtual destructors without declaring the base 1476 # destructor virtual. 1477 if ((classinfo.virtual_method_linenumber is not None) and 1478 (not classinfo.has_virtual_destructor) and 1479 (not classinfo.is_derived)): # Only warn for base classes 1480 error(filename, classinfo.linenum, 'runtime/virtual', 4, 1481 'The class %s probably needs a virtual destructor due to ' 1482 'having virtual method(s), one declared at line %d.' 1483 % (classinfo.name, classinfo.virtual_method_linenumber)) 1484 else: 1485 classinfo.brace_depth = brace_depth 1486 1487 1488def CheckSpacingForFunctionCall(filename, line, linenum, error): 1489 """Checks for the correctness of various spacing around function calls. 1490 1491 Args: 1492 filename: The name of the current file. 1493 line: The text of the line to check. 1494 linenum: The number of the line to check. 1495 error: The function to call with any errors found. 1496 """ 1497 1498 # Since function calls often occur inside if/for/while/switch 1499 # expressions - which have their own, more liberal conventions - we 1500 # first see if we should be looking inside such an expression for a 1501 # function call, to which we can apply more strict standards. 1502 fncall = line # if there's no control flow construct, look at whole line 1503 for pattern in (r'\bif\s*\((.*)\)\s*{', 1504 r'\bfor\s*\((.*)\)\s*{', 1505 r'\bwhile\s*\((.*)\)\s*[{;]', 1506 r'\bswitch\s*\((.*)\)\s*{'): 1507 match = Search(pattern, line) 1508 if match: 1509 fncall = match.group(1) # look inside the parens for function calls 1510 break 1511 1512 # Except in if/for/while/switch, there should never be space 1513 # immediately inside parens (eg "f( 3, 4 )"). We make an exception 1514 # for nested parens ( (a+b) + c ). Likewise, there should never be 1515 # a space before a ( when it's a function argument. I assume it's a 1516 # function argument when the char before the whitespace is legal in 1517 # a function name (alnum + _) and we're not starting a macro. Also ignore 1518 # pointers and references to arrays and functions coz they're too tricky: 1519 # we use a very simple way to recognize these: 1520 # " (something)(maybe-something)" or 1521 # " (something)(maybe-something," or 1522 # " (something)[something]" 1523 # Note that we assume the contents of [] to be short enough that 1524 # they'll never need to wrap. 1525 if ( # Ignore control structures. 1526 not Search(r'\b(if|for|while|switch|return|delete)\b', fncall) and 1527 # Ignore pointers/references to functions. 1528 not Search(r' \([^)]+\)\([^)]*(\)|,$)', fncall) and 1529 # Ignore pointers/references to arrays. 1530 not Search(r' \([^)]+\)\[[^\]]+\]', fncall)): 1531 if Search(r'\w\s*\(\s(?!\s*\\$)', fncall): # a ( used for a fn call 1532 error(filename, linenum, 'whitespace/parens', 4, 1533 'Extra space after ( in function call') 1534 elif Search(r'\(\s+(?!(\s*\\)|\()', fncall): 1535 error(filename, linenum, 'whitespace/parens', 2, 1536 'Extra space after (') 1537 if (Search(r'\w\s+\(', fncall) and 1538 not Search(r'#\s*define|typedef', fncall)): 1539 error(filename, linenum, 'whitespace/parens', 4, 1540 'Extra space before ( in function call') 1541 # If the ) is followed only by a newline or a { + newline, assume it's 1542 # part of a control statement (if/while/etc), and don't complain 1543 if Search(r'[^)]\s+\)\s*[^{\s]', fncall): 1544 # If the closing parenthesis is preceded by only whitespaces, 1545 # try to give a more descriptive error message. 1546 if Search(r'^\s+\)', fncall): 1547 error(filename, linenum, 'whitespace/parens', 2, 1548 'Closing ) should be moved to the previous line') 1549 else: 1550 error(filename, linenum, 'whitespace/parens', 2, 1551 'Extra space before )') 1552 1553 1554def IsBlankLine(line): 1555 """Returns true if the given line is blank. 1556 1557 We consider a line to be blank if the line is empty or consists of 1558 only white spaces. 1559 1560 Args: 1561 line: A line of a string. 1562 1563 Returns: 1564 True, if the given line is blank. 1565 """ 1566 return not line or line.isspace() 1567 1568 1569def CheckForFunctionLengths(filename, clean_lines, linenum, 1570 function_state, error): 1571 """Reports for long function bodies. 1572 1573 For an overview why this is done, see: 1574 http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml#Write_Short_Functions 1575 1576 Uses a simplistic algorithm assuming other style guidelines 1577 (especially spacing) are followed. 1578 Only checks unindented functions, so class members are unchecked. 1579 Trivial bodies are unchecked, so constructors with huge initializer lists 1580 may be missed. 1581 Blank/comment lines are not counted so as to avoid encouraging the removal 1582 of vertical space and comments just to get through a lint check. 1583 NOLINT *on the last line of a function* disables this check. 1584 1585 Args: 1586 filename: The name of the current file. 1587 clean_lines: A CleansedLines instance containing the file. 1588 linenum: The number of the line to check. 1589 function_state: Current function name and lines in body so far. 1590 error: The function to call with any errors found. 1591 """ 1592 lines = clean_lines.lines 1593 line = lines[linenum] 1594 raw = clean_lines.raw_lines 1595 raw_line = raw[linenum] 1596 joined_line = '' 1597 1598 starting_func = False 1599 regexp = r'(\w(\w|::|\*|\&|\s)*)\(' # decls * & space::name( ... 1600 match_result = Match(regexp, line) 1601 if match_result: 1602 # If the name is all caps and underscores, figure it's a macro and 1603 # ignore it, unless it's TEST or TEST_F. 1604 function_name = match_result.group(1).split()[-1] 1605 if function_name == 'TEST' or function_name == 'TEST_F' or ( 1606 not Match(r'[A-Z_]+$', function_name)): 1607 starting_func = True 1608 1609 if starting_func: 1610 body_found = False 1611 for start_linenum in xrange(linenum, clean_lines.NumLines()): 1612 start_line = lines[start_linenum] 1613 joined_line += ' ' + start_line.lstrip() 1614 if Search(r'(;|})', start_line): # Declarations and trivial functions 1615 body_found = True 1616 break # ... ignore 1617 elif Search(r'{', start_line): 1618 body_found = True 1619 function = Search(r'((\w|:)*)\(', line).group(1) 1620 if Match(r'TEST', function): # Handle TEST... macros 1621 parameter_regexp = Search(r'(\(.*\))', joined_line) 1622 if parameter_regexp: # Ignore bad syntax 1623 function += parameter_regexp.group(1) 1624 else: 1625 function += '()' 1626 function_state.Begin(function) 1627 break 1628 if not body_found: 1629 # No body for the function (or evidence of a non-function) was found. 1630 error(filename, linenum, 'readability/fn_size', 5, 1631 'Lint failed to find start of function body.') 1632 elif Match(r'^\}\s*$', line): # function end 1633 function_state.Check(error, filename, linenum) 1634 function_state.End() 1635 elif not Match(r'^\s*$', line): 1636 function_state.Count() # Count non-blank/non-comment lines. 1637 1638 1639_RE_PATTERN_TODO = re.compile(r'^//(\s*)TODO(\(.+?\))?:?(\s|$)?') 1640 1641 1642def CheckComment(comment, filename, linenum, error): 1643 """Checks for common mistakes in TODO comments. 1644 1645 Args: 1646 comment: The text of the comment from the line in question. 1647 filename: The name of the current file. 1648 linenum: The number of the line to check. 1649 error: The function to call with any errors found. 1650 """ 1651 match = _RE_PATTERN_TODO.match(comment) 1652 if match: 1653 # One whitespace is correct; zero whitespace is handled elsewhere. 1654 leading_whitespace = match.group(1) 1655 if len(leading_whitespace) > 1: 1656 error(filename, linenum, 'whitespace/todo', 2, 1657 'Too many spaces before TODO') 1658 1659 username = match.group(2) 1660 if not username: 1661 error(filename, linenum, 'readability/todo', 2, 1662 'Missing username in TODO; it should look like ' 1663 '"// TODO(my_username): Stuff."') 1664 1665 middle_whitespace = match.group(3) 1666 # Comparisons made explicit for correctness -- pylint: disable-msg=C6403 1667 if middle_whitespace != ' ' and middle_whitespace != '': 1668 error(filename, linenum, 'whitespace/todo', 2, 1669 'TODO(my_username) should be followed by a space') 1670 1671 1672def CheckSpacing(filename, clean_lines, linenum, error): 1673 """Checks for the correctness of various spacing issues in the code. 1674 1675 Things we check for: spaces around operators, spaces after 1676 if/for/while/switch, no spaces around parens in function calls, two 1677 spaces between code and comment, don't start a block with a blank 1678 line, don't end a function with a blank line, don't add a blank line 1679 after public/protected/private, don't have too many blank lines in a row. 1680 1681 Args: 1682 filename: The name of the current file. 1683 clean_lines: A CleansedLines instance containing the file. 1684 linenum: The number of the line to check. 1685 error: The function to call with any errors found. 1686 """ 1687 1688 raw = clean_lines.raw_lines 1689 line = raw[linenum] 1690 1691 # Before nixing comments, check if the line is blank for no good 1692 # reason. This includes the first line after a block is opened, and 1693 # blank lines at the end of a function (ie, right before a line like '}' 1694 if IsBlankLine(line): 1695 elided = clean_lines.elided 1696 prev_line = elided[linenum - 1] 1697 prevbrace = prev_line.rfind('{') 1698 # TODO(unknown): Don't complain if line before blank line, and line after, 1699 # both start with alnums and are indented the same amount. 1700 # This ignores whitespace at the start of a namespace block 1701 # because those are not usually indented. 1702 if (prevbrace != -1 and prev_line[prevbrace:].find('}') == -1 1703 and prev_line[:prevbrace].find('namespace') == -1): 1704 # OK, we have a blank line at the start of a code block. Before we 1705 # complain, we check if it is an exception to the rule: The previous 1706 # non-empty line has the parameters of a function header that are indented 1707 # 4 spaces (because they did not fit in a 80 column line when placed on 1708 # the same line as the function name). We also check for the case where 1709 # the previous line is indented 6 spaces, which may happen when the 1710 # initializers of a constructor do not fit into a 80 column line. 1711 exception = False 1712 if Match(r' {6}\w', prev_line): # Initializer list? 1713 # We are looking for the opening column of initializer list, which 1714 # should be indented 4 spaces to cause 6 space indentation afterwards. 1715 search_position = linenum-2 1716 while (search_position >= 0 1717 and Match(r' {6}\w', elided[search_position])): 1718 search_position -= 1 1719 exception = (search_position >= 0 1720 and elided[search_position][:5] == ' :') 1721 else: 1722 # Search for the function arguments or an initializer list. We use a 1723 # simple heuristic here: If the line is indented 4 spaces; and we have a 1724 # closing paren, without the opening paren, followed by an opening brace 1725 # or colon (for initializer lists) we assume that it is the last line of 1726 # a function header. If we have a colon indented 4 spaces, it is an 1727 # initializer list. 1728 exception = (Match(r' {4}\w[^\(]*\)\s*(const\s*)?(\{\s*$|:)', 1729 prev_line) 1730 or Match(r' {4}:', prev_line)) 1731 1732 if not exception: 1733 error(filename, linenum, 'whitespace/blank_line', 2, 1734 'Blank line at the start of a code block. Is this needed?') 1735 # This doesn't ignore whitespace at the end of a namespace block 1736 # because that is too hard without pairing open/close braces; 1737 # however, a special exception is made for namespace closing 1738 # brackets which have a comment containing "namespace". 1739 # 1740 # Also, ignore blank lines at the end of a block in a long if-else 1741 # chain, like this: 1742 # if (condition1) { 1743 # // Something followed by a blank line 1744 # 1745 # } else if (condition2) { 1746 # // Something else 1747 # } 1748 if linenum + 1 < clean_lines.NumLines(): 1749 next_line = raw[linenum + 1] 1750 if (next_line 1751 and Match(r'\s*}', next_line) 1752 and next_line.find('namespace') == -1 1753 and next_line.find('} else ') == -1): 1754 error(filename, linenum, 'whitespace/blank_line', 3, 1755 'Blank line at the end of a code block. Is this needed?') 1756 1757 matched = Match(r'\s*(public|protected|private):', prev_line) 1758 if matched: 1759 error(filename, linenum, 'whitespace/blank_line', 3, 1760 'Do not leave a blank line after "%s:"' % matched.group(1)) 1761 1762 # Next, we complain if there's a comment too near the text 1763 commentpos = line.find('//') 1764 if commentpos != -1: 1765 # Check if the // may be in quotes. If so, ignore it 1766 # Comparisons made explicit for clarity -- pylint: disable-msg=C6403 1767 if (line.count('"', 0, commentpos) - 1768 line.count('\\"', 0, commentpos)) % 2 == 0: # not in quotes 1769 # Allow one space for new scopes, two spaces otherwise: 1770 if (not Match(r'^\s*{ //', line) and 1771 ((commentpos >= 1 and 1772 line[commentpos-1] not in string.whitespace) or 1773 (commentpos >= 2 and 1774 line[commentpos-2] not in string.whitespace))): 1775 error(filename, linenum, 'whitespace/comments', 2, 1776 'At least two spaces is best between code and comments') 1777 # There should always be a space between the // and the comment 1778 commentend = commentpos + 2 1779 if commentend < len(line) and not line[commentend] == ' ': 1780 # but some lines are exceptions -- e.g. if they're big 1781 # comment delimiters like: 1782 # //---------------------------------------------------------- 1783 # or are an empty C++ style Doxygen comment, like: 1784 # /// 1785 # or they begin with multiple slashes followed by a space: 1786 # //////// Header comment 1787 match = (Search(r'[=/-]{4,}\s*$', line[commentend:]) or 1788 Search(r'^/$', line[commentend:]) or 1789 Search(r'^/+ ', line[commentend:])) 1790 if not match: 1791 error(filename, linenum, 'whitespace/comments', 4, 1792 'Should have a space between // and comment') 1793 CheckComment(line[commentpos:], filename, linenum, error) 1794 1795 line = clean_lines.elided[linenum] # get rid of comments and strings 1796 1797 # Don't try to do spacing checks for operator methods 1798 line = re.sub(r'operator(==|!=|<|<<|<=|>=|>>|>)\(', 'operator\(', line) 1799 1800 # We allow no-spaces around = within an if: "if ( (a=Foo()) == 0 )". 1801 # Otherwise not. Note we only check for non-spaces on *both* sides; 1802 # sometimes people put non-spaces on one side when aligning ='s among 1803 # many lines (not that this is behavior that I approve of...) 1804 if Search(r'[\w.]=[\w.]', line) and not Search(r'\b(if|while) ', line): 1805 error(filename, linenum, 'whitespace/operators', 4, 1806 'Missing spaces around =') 1807 1808 # It's ok not to have spaces around binary operators like + - * /, but if 1809 # there's too little whitespace, we get concerned. It's hard to tell, 1810 # though, so we punt on this one for now. TODO. 1811 1812 # You should always have whitespace around binary operators. 1813 # Alas, we can't test < or > because they're legitimately used sans spaces 1814 # (a->b, vector<int> a). The only time we can tell is a < with no >, and 1815 # only if it's not template params list spilling into the next line. 1816 match = Search(r'[^<>=!\s](==|!=|<=|>=)[^<>=!\s]', line) 1817 if not match: 1818 # Note that while it seems that the '<[^<]*' term in the following 1819 # regexp could be simplified to '<.*', which would indeed match 1820 # the same class of strings, the [^<] means that searching for the 1821 # regexp takes linear rather than quadratic time. 1822 if not Search(r'<[^<]*,\s*$', line): # template params spill 1823 match = Search(r'[^<>=!\s](<)[^<>=!\s]([^>]|->)*$', line) 1824 if match: 1825 error(filename, linenum, 'whitespace/operators', 3, 1826 'Missing spaces around %s' % match.group(1)) 1827 # We allow no-spaces around << and >> when used like this: 10<<20, but 1828 # not otherwise (particularly, not when used as streams) 1829 match = Search(r'[^0-9\s](<<|>>)[^0-9\s]', line) 1830 if match: 1831 error(filename, linenum, 'whitespace/operators', 3, 1832 'Missing spaces around %s' % match.group(1)) 1833 1834 # There shouldn't be space around unary operators 1835 match = Search(r'(!\s|~\s|[\s]--[\s;]|[\s]\+\+[\s;])', line) 1836 if match: 1837 error(filename, linenum, 'whitespace/operators', 4, 1838 'Extra space for operator %s' % match.group(1)) 1839 1840 # A pet peeve of mine: no spaces after an if, while, switch, or for 1841 match = Search(r' (if\(|for\(|while\(|switch\()', line) 1842 if match: 1843 error(filename, linenum, 'whitespace/parens', 5, 1844 'Missing space before ( in %s' % match.group(1)) 1845 1846 # For if/for/while/switch, the left and right parens should be 1847 # consistent about how many spaces are inside the parens, and 1848 # there should either be zero or one spaces inside the parens. 1849 # We don't want: "if ( foo)" or "if ( foo )". 1850 # Exception: "for ( ; foo; bar)" and "for (foo; bar; )" are allowed. 1851 match = Search(r'\b(if|for|while|switch)\s*' 1852 r'\(([ ]*)(.).*[^ ]+([ ]*)\)\s*{\s*$', 1853 line) 1854 if match: 1855 if len(match.group(2)) != len(match.group(4)): 1856 if not (match.group(3) == ';' and 1857 len(match.group(2)) == 1 + len(match.group(4)) or 1858 not match.group(2) and Search(r'\bfor\s*\(.*; \)', line)): 1859 error(filename, linenum, 'whitespace/parens', 5, 1860 'Mismatching spaces inside () in %s' % match.group(1)) 1861 if not len(match.group(2)) in [0, 1]: 1862 error(filename, linenum, 'whitespace/parens', 5, 1863 'Should have zero or one spaces inside ( and ) in %s' % 1864 match.group(1)) 1865 1866 # You should always have a space after a comma (either as fn arg or operator) 1867 if Search(r',[^\s]', line): 1868 error(filename, linenum, 'whitespace/comma', 3, 1869 'Missing space after ,') 1870 1871 # You should always have a space after a semicolon 1872 # except for few corner cases 1873 # TODO(unknown): clarify if 'if (1) { return 1;}' is requires one more 1874 # space after ; 1875 if Search(r';[^\s};\\)/]', line): 1876 error(filename, linenum, 'whitespace/semicolon', 3, 1877 'Missing space after ;') 1878 1879 # Next we will look for issues with function calls. 1880 CheckSpacingForFunctionCall(filename, line, linenum, error) 1881 1882 # Except after an opening paren, or after another opening brace (in case of 1883 # an initializer list, for instance), you should have spaces before your 1884 # braces. And since you should never have braces at the beginning of a line, 1885 # this is an easy test. 1886 if Search(r'[^ ({]{', line): 1887 error(filename, linenum, 'whitespace/braces', 5, 1888 'Missing space before {') 1889 1890 # Make sure '} else {' has spaces. 1891 if Search(r'}else', line): 1892 error(filename, linenum, 'whitespace/braces', 5, 1893 'Missing space before else') 1894 1895 # You shouldn't have spaces before your brackets, except maybe after 1896 # 'delete []' or 'new char * []'. 1897 if Search(r'\w\s+\[', line) and not Search(r'delete\s+\[', line): 1898 error(filename, linenum, 'whitespace/braces', 5, 1899 'Extra space before [') 1900 1901 # You shouldn't have a space before a semicolon at the end of the line. 1902 # There's a special case for "for" since the style guide allows space before 1903 # the semicolon there. 1904 if Search(r':\s*;\s*$', line): 1905 error(filename, linenum, 'whitespace/semicolon', 5, 1906 'Semicolon defining empty statement. Use { } instead.') 1907 elif Search(r'^\s*;\s*$', line): 1908 error(filename, linenum, 'whitespace/semicolon', 5, 1909 'Line contains only semicolon. If this should be an empty statement, ' 1910 'use { } instead.') 1911 elif (Search(r'\s+;\s*$', line) and 1912 not Search(r'\bfor\b', line)): 1913 error(filename, linenum, 'whitespace/semicolon', 5, 1914 'Extra space before last semicolon. If this should be an empty ' 1915 'statement, use { } instead.') 1916 1917 1918def CheckSectionSpacing(filename, clean_lines, class_info, linenum, error): 1919 """Checks for additional blank line issues related to sections. 1920 1921 Currently the only thing checked here is blank line before protected/private. 1922 1923 Args: 1924 filename: The name of the current file. 1925 clean_lines: A CleansedLines instance containing the file. 1926 class_info: A _ClassInfo objects. 1927 linenum: The number of the line to check. 1928 error: The function to call with any errors found. 1929 """ 1930 # Skip checks if the class is small, where small means 25 lines or less. 1931 # 25 lines seems like a good cutoff since that's the usual height of 1932 # terminals, and any class that can't fit in one screen can't really 1933 # be considered "small". 1934 # 1935 # Also skip checks if we are on the first line. This accounts for 1936 # classes that look like 1937 # class Foo { public: ... }; 1938 # 1939 # If we didn't find the end of the class, last_line would be zero, 1940 # and the check will be skipped by the first condition. 1941 if (class_info.last_line - class_info.linenum <= 24 or 1942 linenum <= class_info.linenum): 1943 return 1944 1945 matched = Match(r'\s*(public|protected|private):', clean_lines.lines[linenum]) 1946 if matched: 1947 # Issue warning if the line before public/protected/private was 1948 # not a blank line, but don't do this if the previous line contains 1949 # "class" or "struct". This can happen two ways: 1950 # - We are at the beginning of the class. 1951 # - We are forward-declaring an inner class that is semantically 1952 # private, but needed to be public for implementation reasons. 1953 prev_line = clean_lines.lines[linenum - 1] 1954 if (not IsBlankLine(prev_line) and 1955 not Search(r'\b(class|struct)\b', prev_line)): 1956 # Try a bit harder to find the beginning of the class. This is to 1957 # account for multi-line base-specifier lists, e.g.: 1958 # class Derived 1959 # : public Base { 1960 end_class_head = class_info.linenum 1961 for i in range(class_info.linenum, linenum): 1962 if Search(r'\{\s*$', clean_lines.lines[i]): 1963 end_class_head = i 1964 break 1965 if end_class_head < linenum - 1: 1966 error(filename, linenum, 'whitespace/blank_line', 3, 1967 '"%s:" should be preceded by a blank line' % matched.group(1)) 1968 1969 1970def GetPreviousNonBlankLine(clean_lines, linenum): 1971 """Return the most recent non-blank line and its line number. 1972 1973 Args: 1974 clean_lines: A CleansedLines instance containing the file contents. 1975 linenum: The number of the line to check. 1976 1977 Returns: 1978 A tuple with two elements. The first element is the contents of the last 1979 non-blank line before the current line, or the empty string if this is the 1980 first non-blank line. The second is the line number of that line, or -1 1981 if this is the first non-blank line. 1982 """ 1983 1984 prevlinenum = linenum - 1 1985 while prevlinenum >= 0: 1986 prevline = clean_lines.elided[prevlinenum] 1987 if not IsBlankLine(prevline): # if not a blank line... 1988 return (prevline, prevlinenum) 1989 prevlinenum -= 1 1990 return ('', -1) 1991 1992 1993def CheckBraces(filename, clean_lines, linenum, error): 1994 """Looks for misplaced braces (e.g. at the end of line). 1995 1996 Args: 1997 filename: The name of the current file. 1998 clean_lines: A CleansedLines instance containing the file. 1999 linenum: The number of the line to check. 2000 error: The function to call with any errors found. 2001 """ 2002 2003 line = clean_lines.elided[linenum] # get rid of comments and strings 2004 2005 if Match(r'\s*{\s*$', line): 2006 # We allow an open brace to start a line in the case where someone 2007 # is using braces in a block to explicitly create a new scope, 2008 # which is commonly used to control the lifetime of 2009 # stack-allocated variables. We don't detect this perfectly: we 2010 # just don't complain if the last non-whitespace character on the 2011 # previous non-blank line is ';', ':', '{', or '}'. 2012 prevline = GetPreviousNonBlankLine(clean_lines, linenum)[0] 2013 if not Search(r'[;:}{]\s*$', prevline): 2014 error(filename, linenum, 'whitespace/braces', 4, 2015 '{ should almost always be at the end of the previous line') 2016 2017 # An else clause should be on the same line as the preceding closing brace. 2018 if Match(r'\s*else\s*', line): 2019 prevline = GetPreviousNonBlankLine(clean_lines, linenum)[0] 2020 if Match(r'\s*}\s*$', prevline): 2021 error(filename, linenum, 'whitespace/newline', 4, 2022 'An else should appear on the same line as the preceding }') 2023 2024 # If braces come on one side of an else, they should be on both. 2025 # However, we have to worry about "else if" that spans multiple lines! 2026 if Search(r'}\s*else[^{]*$', line) or Match(r'[^}]*else\s*{', line): 2027 if Search(r'}\s*else if([^{]*)$', line): # could be multi-line if 2028 # find the ( after the if 2029 pos = line.find('else if') 2030 pos = line.find('(', pos) 2031 if pos > 0: 2032 (endline, _, endpos) = CloseExpression(clean_lines, linenum, pos) 2033 if endline[endpos:].find('{') == -1: # must be brace after if 2034 error(filename, linenum, 'readability/braces', 5, 2035 'If an else has a brace on one side, it should have it on both') 2036 else: # common case: else not followed by a multi-line if 2037 error(filename, linenum, 'readability/braces', 5, 2038 'If an else has a brace on one side, it should have it on both') 2039 2040 # Likewise, an else should never have the else clause on the same line 2041 if Search(r'\belse [^\s{]', line) and not Search(r'\belse if\b', line): 2042 error(filename, linenum, 'whitespace/newline', 4, 2043 'Else clause should never be on same line as else (use 2 lines)') 2044 2045 # In the same way, a do/while should never be on one line 2046 if Match(r'\s*do [^\s{]', line): 2047 error(filename, linenum, 'whitespace/newline', 4, 2048 'do/while clauses should not be on a single line') 2049 2050 # Braces shouldn't be followed by a ; unless they're defining a struct 2051 # or initializing an array. 2052 # We can't tell in general, but we can for some common cases. 2053 prevlinenum = linenum 2054 while True: 2055 (prevline, prevlinenum) = GetPreviousNonBlankLine(clean_lines, prevlinenum) 2056 if Match(r'\s+{.*}\s*;', line) and not prevline.count(';'): 2057 line = prevline + line 2058 else: 2059 break 2060 if (Search(r'{.*}\s*;', line) and 2061 line.count('{') == line.count('}') and 2062 not Search(r'struct|class|enum|\s*=\s*{', line)): 2063 error(filename, linenum, 'readability/braces', 4, 2064 "You don't need a ; after a }") 2065 2066 2067def ReplaceableCheck(operator, macro, line): 2068 """Determine whether a basic CHECK can be replaced with a more specific one. 2069 2070 For example suggest using CHECK_EQ instead of CHECK(a == b) and 2071 similarly for CHECK_GE, CHECK_GT, CHECK_LE, CHECK_LT, CHECK_NE. 2072 2073 Args: 2074 operator: The C++ operator used in the CHECK. 2075 macro: The CHECK or EXPECT macro being called. 2076 line: The current source line. 2077 2078 Returns: 2079 True if the CHECK can be replaced with a more specific one. 2080 """ 2081 2082 # This matches decimal and hex integers, strings, and chars (in that order). 2083 match_constant = r'([-+]?(\d+|0[xX][0-9a-fA-F]+)[lLuU]{0,3}|".*"|\'.*\')' 2084 2085 # Expression to match two sides of the operator with something that 2086 # looks like a literal, since CHECK(x == iterator) won't compile. 2087 # This means we can't catch all the cases where a more specific 2088 # CHECK is possible, but it's less annoying than dealing with 2089 # extraneous warnings. 2090 match_this = (r'\s*' + macro + r'\((\s*' + 2091 match_constant + r'\s*' + operator + r'[^<>].*|' 2092 r'.*[^<>]' + operator + r'\s*' + match_constant + 2093 r'\s*\))') 2094 2095 # Don't complain about CHECK(x == NULL) or similar because 2096 # CHECK_EQ(x, NULL) won't compile (requires a cast). 2097 # Also, don't complain about more complex boolean expressions 2098 # involving && or || such as CHECK(a == b || c == d). 2099 return Match(match_this, line) and not Search(r'NULL|&&|\|\|', line) 2100 2101 2102def CheckCheck(filename, clean_lines, linenum, error): 2103 """Checks the use of CHECK and EXPECT macros. 2104 2105 Args: 2106 filename: The name of the current file. 2107 clean_lines: A CleansedLines instance containing the file. 2108 linenum: The number of the line to check. 2109 error: The function to call with any errors found. 2110 """ 2111 2112 # Decide the set of replacement macros that should be suggested 2113 raw_lines = clean_lines.raw_lines 2114 current_macro = '' 2115 for macro in _CHECK_MACROS: 2116 if raw_lines[linenum].find(macro) >= 0: 2117 current_macro = macro 2118 break 2119 if not current_macro: 2120 # Don't waste time here if line doesn't contain 'CHECK' or 'EXPECT' 2121 return 2122 2123 line = clean_lines.elided[linenum] # get rid of comments and strings 2124 2125 # Encourage replacing plain CHECKs with CHECK_EQ/CHECK_NE/etc. 2126 for operator in ['==', '!=', '>=', '>', '<=', '<']: 2127 if ReplaceableCheck(operator, current_macro, line): 2128 error(filename, linenum, 'readability/check', 2, 2129 'Consider using %s instead of %s(a %s b)' % ( 2130 _CHECK_REPLACEMENT[current_macro][operator], 2131 current_macro, operator)) 2132 break 2133 2134 2135def GetLineWidth(line): 2136 """Determines the width of the line in column positions. 2137 2138 Args: 2139 line: A string, which may be a Unicode string. 2140 2141 Returns: 2142 The width of the line in column positions, accounting for Unicode 2143 combining characters and wide characters. 2144 """ 2145 if isinstance(line, unicode): 2146 width = 0 2147 for uc in unicodedata.normalize('NFC', line): 2148 if unicodedata.east_asian_width(uc) in ('W', 'F'): 2149 width += 2 2150 elif not unicodedata.combining(uc): 2151 width += 1 2152 return width 2153 else: 2154 return len(line) 2155 2156 2157def CheckStyle(filename, clean_lines, linenum, file_extension, class_state, 2158 error): 2159 """Checks rules from the 'C++ style rules' section of cppguide.html. 2160 2161 Most of these rules are hard to test (naming, comment style), but we 2162 do what we can. In particular we check for 2-space indents, line lengths, 2163 tab usage, spaces inside code, etc. 2164 2165 Args: 2166 filename: The name of the current file. 2167 clean_lines: A CleansedLines instance containing the file. 2168 linenum: The number of the line to check. 2169 file_extension: The extension (without the dot) of the filename. 2170 error: The function to call with any errors found. 2171 """ 2172 2173 raw_lines = clean_lines.raw_lines 2174 line = raw_lines[linenum] 2175 2176 if line.find('\t') != -1: 2177 error(filename, linenum, 'whitespace/tab', 1, 2178 'Tab found; better to use spaces') 2179 2180 # One or three blank spaces at the beginning of the line is weird; it's 2181 # hard to reconcile that with 2-space indents. 2182 # NOTE: here are the conditions rob pike used for his tests. Mine aren't 2183 # as sophisticated, but it may be worth becoming so: RLENGTH==initial_spaces 2184 # if(RLENGTH > 20) complain = 0; 2185 # if(match($0, " +(error|private|public|protected):")) complain = 0; 2186 # if(match(prev, "&& *$")) complain = 0; 2187 # if(match(prev, "\\|\\| *$")) complain = 0; 2188 # if(match(prev, "[\",=><] *$")) complain = 0; 2189 # if(match($0, " <<")) complain = 0; 2190 # if(match(prev, " +for \\(")) complain = 0; 2191 # if(prevodd && match(prevprev, " +for \\(")) complain = 0; 2192 initial_spaces = 0 2193 cleansed_line = clean_lines.elided[linenum] 2194 while initial_spaces < len(line) and line[initial_spaces] == ' ': 2195 initial_spaces += 1 2196 if line and line[-1].isspace(): 2197 error(filename, linenum, 'whitespace/end_of_line', 4, 2198 'Line ends in whitespace. Consider deleting these extra spaces.') 2199 # There are certain situations we allow one space, notably for labels 2200 elif ((initial_spaces == 1 or initial_spaces == 3) and 2201 not Match(r'\s*\w+\s*:\s*$', cleansed_line)): 2202 error(filename, linenum, 'whitespace/indent', 3, 2203 'Weird number of spaces at line-start. ' 2204 'Are you using a 2-space indent?') 2205 # Labels should always be indented at least one space. 2206 elif not initial_spaces and line[:2] != '//' and Search(r'[^:]:\s*$', 2207 line): 2208 error(filename, linenum, 'whitespace/labels', 4, 2209 'Labels should always be indented at least one space. ' 2210 'If this is a member-initializer list in a constructor or ' 2211 'the base class list in a class definition, the colon should ' 2212 'be on the following line.') 2213 2214 2215 # Check if the line is a header guard. 2216 is_header_guard = False 2217 if file_extension == 'h': 2218 cppvar = GetHeaderGuardCPPVariable(filename) 2219 if (line.startswith('#ifndef %s' % cppvar) or 2220 line.startswith('#define %s' % cppvar) or 2221 line.startswith('#endif // %s' % cppvar)): 2222 is_header_guard = True 2223 # #include lines and header guards can be long, since there's no clean way to 2224 # split them. 2225 # 2226 # URLs can be long too. It's possible to split these, but it makes them 2227 # harder to cut&paste. 2228 # 2229 # The "$Id:...$" comment may also get very long without it being the 2230 # developers fault. 2231 if (not line.startswith('#include') and not is_header_guard and 2232 not Match(r'^\s*//.*http(s?)://\S*$', line) and 2233 not Match(r'^// \$Id:.*#[0-9]+ \$$', line)): 2234 line_width = GetLineWidth(line) 2235 if line_width > 100: 2236 error(filename, linenum, 'whitespace/line_length', 4, 2237 'Lines should very rarely be longer than 100 characters') 2238 elif line_width > 80: 2239 error(filename, linenum, 'whitespace/line_length', 2, 2240 'Lines should be <= 80 characters long') 2241 2242 if (cleansed_line.count(';') > 1 and 2243 # for loops are allowed two ;'s (and may run over two lines). 2244 cleansed_line.find('for') == -1 and 2245 (GetPreviousNonBlankLine(clean_lines, linenum)[0].find('for') == -1 or 2246 GetPreviousNonBlankLine(clean_lines, linenum)[0].find(';') != -1) and 2247 # It's ok to have many commands in a switch case that fits in 1 line 2248 not ((cleansed_line.find('case ') != -1 or 2249 cleansed_line.find('default:') != -1) and 2250 cleansed_line.find('break;') != -1)): 2251 error(filename, linenum, 'whitespace/newline', 4, 2252 'More than one command on the same line') 2253 2254 # Some more style checks 2255 CheckBraces(filename, clean_lines, linenum, error) 2256 CheckSpacing(filename, clean_lines, linenum, error) 2257 CheckCheck(filename, clean_lines, linenum, error) 2258 if class_state and class_state.classinfo_stack: 2259 CheckSectionSpacing(filename, clean_lines, 2260 class_state.classinfo_stack[-1], linenum, error) 2261 2262 2263_RE_PATTERN_INCLUDE_NEW_STYLE = re.compile(r'#include +"[^/]+\.h"') 2264_RE_PATTERN_INCLUDE = re.compile(r'^\s*#\s*include\s*([<"])([^>"]*)[>"].*$') 2265# Matches the first component of a filename delimited by -s and _s. That is: 2266# _RE_FIRST_COMPONENT.match('foo').group(0) == 'foo' 2267# _RE_FIRST_COMPONENT.match('foo.cc').group(0) == 'foo' 2268# _RE_FIRST_COMPONENT.match('foo-bar_baz.cc').group(0) == 'foo' 2269# _RE_FIRST_COMPONENT.match('foo_bar-baz.cc').group(0) == 'foo' 2270_RE_FIRST_COMPONENT = re.compile(r'^[^-_.]+') 2271 2272 2273def _DropCommonSuffixes(filename): 2274 """Drops common suffixes like _test.cc or -inl.h from filename. 2275 2276 For example: 2277 >>> _DropCommonSuffixes('foo/foo-inl.h') 2278 'foo/foo' 2279 >>> _DropCommonSuffixes('foo/bar/foo.cc') 2280 'foo/bar/foo' 2281 >>> _DropCommonSuffixes('foo/foo_internal.h') 2282 'foo/foo' 2283 >>> _DropCommonSuffixes('foo/foo_unusualinternal.h') 2284 'foo/foo_unusualinternal' 2285 2286 Args: 2287 filename: The input filename. 2288 2289 Returns: 2290 The filename with the common suffix removed. 2291 """ 2292 for suffix in ('test.cc', 'regtest.cc', 'unittest.cc', 2293 'inl.h', 'impl.h', 'internal.h'): 2294 if (filename.endswith(suffix) and len(filename) > len(suffix) and 2295 filename[-len(suffix) - 1] in ('-', '_')): 2296 return filename[:-len(suffix) - 1] 2297 return os.path.splitext(filename)[0] 2298 2299 2300def _IsTestFilename(filename): 2301 """Determines if the given filename has a suffix that identifies it as a test. 2302 2303 Args: 2304 filename: The input filename. 2305 2306 Returns: 2307 True if 'filename' looks like a test, False otherwise. 2308 """ 2309 if (filename.endswith('_test.cc') or 2310 filename.endswith('_unittest.cc') or 2311 filename.endswith('_regtest.cc')): 2312 return True 2313 else: 2314 return False 2315 2316 2317def _ClassifyInclude(fileinfo, include, is_system): 2318 """Figures out what kind of header 'include' is. 2319 2320 Args: 2321 fileinfo: The current file cpplint is running over. A FileInfo instance. 2322 include: The path to a #included file. 2323 is_system: True if the #include used <> rather than "". 2324 2325 Returns: 2326 One of the _XXX_HEADER constants. 2327 2328 For example: 2329 >>> _ClassifyInclude(FileInfo('foo/foo.cc'), 'stdio.h', True) 2330 _C_SYS_HEADER 2331 >>> _ClassifyInclude(FileInfo('foo/foo.cc'), 'string', True) 2332 _CPP_SYS_HEADER 2333 >>> _ClassifyInclude(FileInfo('foo/foo.cc'), 'foo/foo.h', False) 2334 _LIKELY_MY_HEADER 2335 >>> _ClassifyInclude(FileInfo('foo/foo_unknown_extension.cc'), 2336 ... 'bar/foo_other_ext.h', False) 2337 _POSSIBLE_MY_HEADER 2338 >>> _ClassifyInclude(FileInfo('foo/foo.cc'), 'foo/bar.h', False) 2339 _OTHER_HEADER 2340 """ 2341 # This is a list of all standard c++ header files, except 2342 # those already checked for above. 2343 is_stl_h = include in _STL_HEADERS 2344 is_cpp_h = is_stl_h or include in _CPP_HEADERS 2345 2346 if is_system: 2347 if is_cpp_h: 2348 return _CPP_SYS_HEADER 2349 else: 2350 return _C_SYS_HEADER 2351 2352 # If the target file and the include we're checking share a 2353 # basename when we drop common extensions, and the include 2354 # lives in . , then it's likely to be owned by the target file. 2355 target_dir, target_base = ( 2356 os.path.split(_DropCommonSuffixes(fileinfo.RepositoryName()))) 2357 include_dir, include_base = os.path.split(_DropCommonSuffixes(include)) 2358 if target_base == include_base and ( 2359 include_dir == target_dir or 2360 include_dir == os.path.normpath(target_dir + '/../public')): 2361 return _LIKELY_MY_HEADER 2362 2363 # If the target and include share some initial basename 2364 # component, it's possible the target is implementing the 2365 # include, so it's allowed to be first, but we'll never 2366 # complain if it's not there. 2367 target_first_component = _RE_FIRST_COMPONENT.match(target_base) 2368 include_first_component = _RE_FIRST_COMPONENT.match(include_base) 2369 if (target_first_component and include_first_component and 2370 target_first_component.group(0) == 2371 include_first_component.group(0)): 2372 return _POSSIBLE_MY_HEADER 2373 2374 return _OTHER_HEADER 2375 2376 2377 2378def CheckIncludeLine(filename, clean_lines, linenum, include_state, error): 2379 """Check rules that are applicable to #include lines. 2380 2381 Strings on #include lines are NOT removed from elided line, to make 2382 certain tasks easier. However, to prevent false positives, checks 2383 applicable to #include lines in CheckLanguage must be put here. 2384 2385 Args: 2386 filename: The name of the current file. 2387 clean_lines: A CleansedLines instance containing the file. 2388 linenum: The number of the line to check. 2389 include_state: An _IncludeState instance in which the headers are inserted. 2390 error: The function to call with any errors found. 2391 """ 2392 fileinfo = FileInfo(filename) 2393 2394 line = clean_lines.lines[linenum] 2395 2396 # "include" should use the new style "foo/bar.h" instead of just "bar.h" 2397 if _RE_PATTERN_INCLUDE_NEW_STYLE.search(line): 2398 error(filename, linenum, 'build/include', 4, 2399 'Include the directory when naming .h files') 2400 2401 # we shouldn't include a file more than once. actually, there are a 2402 # handful of instances where doing so is okay, but in general it's 2403 # not. 2404 match = _RE_PATTERN_INCLUDE.search(line) 2405 if match: 2406 include = match.group(2) 2407 is_system = (match.group(1) == '<') 2408 if include in include_state: 2409 error(filename, linenum, 'build/include', 4, 2410 '"%s" already included at %s:%s' % 2411 (include, filename, include_state[include])) 2412 else: 2413 include_state[include] = linenum 2414 2415 # We want to ensure that headers appear in the right order: 2416 # 1) for foo.cc, foo.h (preferred location) 2417 # 2) c system files 2418 # 3) cpp system files 2419 # 4) for foo.cc, foo.h (deprecated location) 2420 # 5) other google headers 2421 # 2422 # We classify each include statement as one of those 5 types 2423 # using a number of techniques. The include_state object keeps 2424 # track of the highest type seen, and complains if we see a 2425 # lower type after that. 2426 error_message = include_state.CheckNextIncludeOrder( 2427 _ClassifyInclude(fileinfo, include, is_system)) 2428 if error_message: 2429 error(filename, linenum, 'build/include_order', 4, 2430 '%s. Should be: %s.h, c system, c++ system, other.' % 2431 (error_message, fileinfo.BaseName())) 2432 if not include_state.IsInAlphabeticalOrder(include): 2433 error(filename, linenum, 'build/include_alpha', 4, 2434 'Include "%s" not in alphabetical order' % include) 2435 2436 # Look for any of the stream classes that are part of standard C++. 2437 match = _RE_PATTERN_INCLUDE.match(line) 2438 if match: 2439 include = match.group(2) 2440 if Match(r'(f|ind|io|i|o|parse|pf|stdio|str|)?stream$', include): 2441 # Many unit tests use cout, so we exempt them. 2442 if not _IsTestFilename(filename): 2443 error(filename, linenum, 'readability/streams', 3, 2444 'Streams are highly discouraged.') 2445 2446 2447def _GetTextInside(text, start_pattern): 2448 """Retrieves all the text between matching open and close parentheses. 2449 2450 Given a string of lines and a regular expression string, retrieve all the text 2451 following the expression and between opening punctuation symbols like 2452 (, [, or {, and the matching close-punctuation symbol. This properly nested 2453 occurrences of the punctuations, so for the text like 2454 printf(a(), b(c())); 2455 a call to _GetTextInside(text, r'printf\(') will return 'a(), b(c())'. 2456 start_pattern must match string having an open punctuation symbol at the end. 2457 2458 Args: 2459 text: The lines to extract text. Its comments and strings must be elided. 2460 It can be single line and can span multiple lines. 2461 start_pattern: The regexp string indicating where to start extracting 2462 the text. 2463 Returns: 2464 The extracted text. 2465 None if either the opening string or ending punctuation could not be found. 2466 """ 2467 # TODO(sugawarayu): Audit cpplint.py to see what places could be profitably 2468 # rewritten to use _GetTextInside (and use inferior regexp matching today). 2469 2470 # Give opening punctuations to get the matching close-punctuations. 2471 matching_punctuation = {'(': ')', '{': '}', '[': ']'} 2472 closing_punctuation = set(matching_punctuation.itervalues()) 2473 2474 # Find the position to start extracting text. 2475 match = re.search(start_pattern, text, re.M) 2476 if not match: # start_pattern not found in text. 2477 return None 2478 start_position = match.end(0) 2479 2480 assert start_position > 0, ( 2481 'start_pattern must ends with an opening punctuation.') 2482 assert text[start_position - 1] in matching_punctuation, ( 2483 'start_pattern must ends with an opening punctuation.') 2484 # Stack of closing punctuations we expect to have in text after position. 2485 punctuation_stack = [matching_punctuation[text[start_position - 1]]] 2486 position = start_position 2487 while punctuation_stack and position < len(text): 2488 if text[position] == punctuation_stack[-1]: 2489 punctuation_stack.pop() 2490 elif text[position] in closing_punctuation: 2491 # A closing punctuation without matching opening punctuations. 2492 return None 2493 elif text[position] in matching_punctuation: 2494 punctuation_stack.append(matching_punctuation[text[position]]) 2495 position += 1 2496 if punctuation_stack: 2497 # Opening punctuations left without matching close-punctuations. 2498 return None 2499 # punctuations match. 2500 return text[start_position:position - 1] 2501 2502 2503def CheckLanguage(filename, clean_lines, linenum, file_extension, include_state, 2504 error): 2505 """Checks rules from the 'C++ language rules' section of cppguide.html. 2506 2507 Some of these rules are hard to test (function overloading, using 2508 uint32 inappropriately), but we do the best we can. 2509 2510 Args: 2511 filename: The name of the current file. 2512 clean_lines: A CleansedLines instance containing the file. 2513 linenum: The number of the line to check. 2514 file_extension: The extension (without the dot) of the filename. 2515 include_state: An _IncludeState instance in which the headers are inserted. 2516 error: The function to call with any errors found. 2517 """ 2518 # If the line is empty or consists of entirely a comment, no need to 2519 # check it. 2520 line = clean_lines.elided[linenum] 2521 if not line: 2522 return 2523 2524 match = _RE_PATTERN_INCLUDE.search(line) 2525 if match: 2526 CheckIncludeLine(filename, clean_lines, linenum, include_state, error) 2527 return 2528 2529 # Create an extended_line, which is the concatenation of the current and 2530 # next lines, for more effective checking of code that may span more than one 2531 # line. 2532 if linenum + 1 < clean_lines.NumLines(): 2533 extended_line = line + clean_lines.elided[linenum + 1] 2534 else: 2535 extended_line = line 2536 2537 # Make Windows paths like Unix. 2538 fullname = os.path.abspath(filename).replace('\\', '/') 2539 2540 # TODO(unknown): figure out if they're using default arguments in fn proto. 2541 2542 # Check for non-const references in functions. This is tricky because & 2543 # is also used to take the address of something. We allow <> for templates, 2544 # (ignoring whatever is between the braces) and : for classes. 2545 # These are complicated re's. They try to capture the following: 2546 # paren (for fn-prototype start), typename, &, varname. For the const 2547 # version, we're willing for const to be before typename or after 2548 # Don't check the implementation on same line. 2549 fnline = line.split('{', 1)[0] 2550 if (len(re.findall(r'\([^()]*\b(?:[\w:]|<[^()]*>)+(\s?&|&\s?)\w+', fnline)) > 2551 len(re.findall(r'\([^()]*\bconst\s+(?:typename\s+)?(?:struct\s+)?' 2552 r'(?:[\w:]|<[^()]*>)+(\s?&|&\s?)\w+', fnline)) + 2553 len(re.findall(r'\([^()]*\b(?:[\w:]|<[^()]*>)+\s+const(\s?&|&\s?)[\w]+', 2554 fnline))): 2555 2556 # We allow non-const references in a few standard places, like functions 2557 # called "swap()" or iostream operators like "<<" or ">>". 2558 if not Search( 2559 r'(swap|Swap|operator[<>][<>])\s*\(\s*(?:[\w:]|<.*>)+\s*&', 2560 fnline): 2561 error(filename, linenum, 'runtime/references', 2, 2562 'Is this a non-const reference? ' 2563 'If so, make const or use a pointer.') 2564 2565 # Check to see if they're using an conversion function cast. 2566 # I just try to capture the most common basic types, though there are more. 2567 # Parameterless conversion functions, such as bool(), are allowed as they are 2568 # probably a member operator declaration or default constructor. 2569 match = Search( 2570 r'(\bnew\s+)?\b' # Grab 'new' operator, if it's there 2571 r'(int|float|double|bool|char|u?int(8|16|32|64)_t)\([^)]', line) # TODO(enh): upstream change to handle all stdint types. 2572 if match: 2573 # gMock methods are defined using some variant of MOCK_METHODx(name, type) 2574 # where type may be float(), int(string), etc. Without context they are 2575 # virtually indistinguishable from int(x) casts. Likewise, gMock's 2576 # MockCallback takes a template parameter of the form return_type(arg_type), 2577 # which looks much like the cast we're trying to detect. 2578 if (match.group(1) is None and # If new operator, then this isn't a cast 2579 not (Match(r'^\s*MOCK_(CONST_)?METHOD\d+(_T)?\(', line) or 2580 Match(r'^\s*MockCallback<.*>', line))): 2581 error(filename, linenum, 'readability/casting', 4, 2582 'Using deprecated casting style. ' 2583 'Use static_cast<%s>(...) instead' % 2584 match.group(2)) 2585 2586 CheckCStyleCast(filename, linenum, line, clean_lines.raw_lines[linenum], 2587 'static_cast', 2588 r'\((int|float|double|bool|char|u?int(8|16|32|64))\)', error) # TODO(enh): upstream change to handle all stdint types. 2589 2590 # This doesn't catch all cases. Consider (const char * const)"hello". 2591 # 2592 # (char *) "foo" should always be a const_cast (reinterpret_cast won't 2593 # compile). 2594 if CheckCStyleCast(filename, linenum, line, clean_lines.raw_lines[linenum], 2595 'const_cast', r'\((char\s?\*+\s?)\)\s*"', error): 2596 pass 2597 else: 2598 # Check pointer casts for other than string constants 2599 CheckCStyleCast(filename, linenum, line, clean_lines.raw_lines[linenum], 2600 'reinterpret_cast', r'\((\w+\s?\*+\s?)\)', error) 2601 2602 # In addition, we look for people taking the address of a cast. This 2603 # is dangerous -- casts can assign to temporaries, so the pointer doesn't 2604 # point where you think. 2605 if Search( 2606 r'(&\([^)]+\)[\w(])|(&(static|dynamic|reinterpret)_cast\b)', line): 2607 error(filename, linenum, 'runtime/casting', 4, 2608 ('Are you taking an address of a cast? ' 2609 'This is dangerous: could be a temp var. ' 2610 'Take the address before doing the cast, rather than after')) 2611 2612 # Check for people declaring static/global STL strings at the top level. 2613 # This is dangerous because the C++ language does not guarantee that 2614 # globals with constructors are initialized before the first access. 2615 match = Match( 2616 r'((?:|static +)(?:|const +))string +([a-zA-Z0-9_:]+)\b(.*)', 2617 line) 2618 # Make sure it's not a function. 2619 # Function template specialization looks like: "string foo<Type>(...". 2620 # Class template definitions look like: "string Foo<Type>::Method(...". 2621 if match and not Match(r'\s*(<.*>)?(::[a-zA-Z0-9_]+)?\s*\(([^"]|$)', 2622 match.group(3)): 2623 error(filename, linenum, 'runtime/string', 4, 2624 'For a static/global string constant, use a C style string instead: ' 2625 '"%schar %s[]".' % 2626 (match.group(1), match.group(2))) 2627 2628 # Check that we're not using RTTI outside of testing code. 2629 if Search(r'\bdynamic_cast<', line) and not _IsTestFilename(filename): 2630 error(filename, linenum, 'runtime/rtti', 5, 2631 'Do not use dynamic_cast<>. If you need to cast within a class ' 2632 "hierarchy, use static_cast<> to upcast. Google doesn't support " 2633 'RTTI.') 2634 2635 if Search(r'\b([A-Za-z0-9_]*_)\(\1\)', line): 2636 error(filename, linenum, 'runtime/init', 4, 2637 'You seem to be initializing a member variable with itself.') 2638 2639 if file_extension == 'h': 2640 # TODO(unknown): check that 1-arg constructors are explicit. 2641 # How to tell it's a constructor? 2642 # (handled in CheckForNonStandardConstructs for now) 2643 # TODO(unknown): check that classes have DISALLOW_EVIL_CONSTRUCTORS 2644 # (level 1 error) 2645 pass 2646 2647 # Check if people are using the verboten C basic types. The only exception 2648 # we regularly allow is "unsigned short port" for port. 2649 if Search(r'\bshort port\b', line): 2650 if not Search(r'\bunsigned short port\b', line): 2651 error(filename, linenum, 'runtime/int', 4, 2652 'Use "unsigned short" for ports, not "short"') 2653 else: 2654 match = Search(r'\b(short|long(?! +double)|long long)\b', line) 2655 if match: 2656 error(filename, linenum, 'runtime/int', 4, 2657 'Use int16/int64/etc, rather than the C type %s' % match.group(1)) 2658 2659 # When snprintf is used, the second argument shouldn't be a literal. 2660 match = Search(r'snprintf\s*\(([^,]*),\s*([0-9]*)\s*,', line) 2661 if match and match.group(2) != '0': 2662 # If 2nd arg is zero, snprintf is used to calculate size. 2663 error(filename, linenum, 'runtime/printf', 3, 2664 'If you can, use sizeof(%s) instead of %s as the 2nd arg ' 2665 'to snprintf.' % (match.group(1), match.group(2))) 2666 2667 # Check if some verboten C functions are being used. 2668 if Search(r'\bsprintf\b', line): 2669 error(filename, linenum, 'runtime/printf', 5, 2670 'Never use sprintf. Use snprintf instead.') 2671 match = Search(r'\b(strcpy|strcat)\b', line) 2672 if match: 2673 error(filename, linenum, 'runtime/printf', 4, 2674 'Almost always, snprintf is better than %s' % match.group(1)) 2675 2676 if Search(r'\bsscanf\b', line): 2677 error(filename, linenum, 'runtime/printf', 1, 2678 'sscanf can be ok, but is slow and can overflow buffers.') 2679 2680 # Check if some verboten operator overloading is going on 2681 # TODO(unknown): catch out-of-line unary operator&: 2682 # class X {}; 2683 # int operator&(const X& x) { return 42; } // unary operator& 2684 # The trick is it's hard to tell apart from binary operator&: 2685 # class Y { int operator&(const Y& x) { return 23; } }; // binary operator& 2686 if Search(r'\boperator\s*&\s*\(\s*\)', line): 2687 error(filename, linenum, 'runtime/operator', 4, 2688 'Unary operator& is dangerous. Do not use it.') 2689 2690 # Check for suspicious usage of "if" like 2691 # } if (a == b) { 2692 if Search(r'\}\s*if\s*\(', line): 2693 error(filename, linenum, 'readability/braces', 4, 2694 'Did you mean "else if"? If not, start a new line for "if".') 2695 2696 # Check for potential format string bugs like printf(foo). 2697 # We constrain the pattern not to pick things like DocidForPrintf(foo). 2698 # Not perfect but it can catch printf(foo.c_str()) and printf(foo->c_str()) 2699 # TODO(sugawarayu): Catch the following case. Need to change the calling 2700 # convention of the whole function to process multiple line to handle it. 2701 # printf( 2702 # boy_this_is_a_really_long_variable_that_cannot_fit_on_the_prev_line); 2703 printf_args = _GetTextInside(line, r'(?i)\b(string)?printf\s*\(') 2704 if printf_args: 2705 match = Match(r'([\w.\->()]+)$', printf_args) 2706 if match: 2707 function_name = re.search(r'\b((?:string)?printf)\s*\(', 2708 line, re.I).group(1) 2709 error(filename, linenum, 'runtime/printf', 4, 2710 'Potential format string bug. Do %s("%%s", %s) instead.' 2711 % (function_name, match.group(1))) 2712 2713 # Check for potential memset bugs like memset(buf, sizeof(buf), 0). 2714 match = Search(r'memset\s*\(([^,]*),\s*([^,]*),\s*0\s*\)', line) 2715 if match and not Match(r"^''|-?[0-9]+|0x[0-9A-Fa-f]$", match.group(2)): 2716 error(filename, linenum, 'runtime/memset', 4, 2717 'Did you mean "memset(%s, 0, %s)"?' 2718 % (match.group(1), match.group(2))) 2719 2720 if Search(r'\busing namespace\b', line): 2721 error(filename, linenum, 'build/namespaces', 5, 2722 'Do not use namespace using-directives. ' 2723 'Use using-declarations instead.') 2724 2725 # Detect variable-length arrays. 2726 match = Match(r'\s*(.+::)?(\w+) [a-z]\w*\[(.+)];', line) 2727 if (match and match.group(2) != 'return' and match.group(2) != 'delete' and 2728 match.group(3).find(']') == -1): 2729 # Split the size using space and arithmetic operators as delimiters. 2730 # If any of the resulting tokens are not compile time constants then 2731 # report the error. 2732 tokens = re.split(r'\s|\+|\-|\*|\/|<<|>>]', match.group(3)) 2733 is_const = True 2734 skip_next = False 2735 for tok in tokens: 2736 if skip_next: 2737 skip_next = False 2738 continue 2739 2740 if Search(r'sizeof\(.+\)', tok): continue 2741 if Search(r'arraysize\(\w+\)', tok): continue 2742 2743 tok = tok.lstrip('(') 2744 tok = tok.rstrip(')') 2745 if not tok: continue 2746 if Match(r'\d+', tok): continue 2747 if Match(r'0[xX][0-9a-fA-F]+', tok): continue 2748 if Match(r'k[A-Z0-9]\w*', tok): continue 2749 if Match(r'(.+::)?k[A-Z0-9]\w*', tok): continue 2750 if Match(r'(.+::)?[A-Z][A-Z0-9_]*', tok): continue 2751 # A catch all for tricky sizeof cases, including 'sizeof expression', 2752 # 'sizeof(*type)', 'sizeof(const type)', 'sizeof(struct StructName)' 2753 # requires skipping the next token because we split on ' ' and '*'. 2754 if tok.startswith('sizeof'): 2755 skip_next = True 2756 continue 2757 is_const = False 2758 break 2759 if not is_const: 2760 error(filename, linenum, 'runtime/arrays', 1, 2761 'Do not use variable-length arrays. Use an appropriately named ' 2762 "('k' followed by CamelCase) compile-time constant for the size.") 2763 2764 # If DISALLOW_EVIL_CONSTRUCTORS, DISALLOW_COPY_AND_ASSIGN, or 2765 # DISALLOW_IMPLICIT_CONSTRUCTORS is present, then it should be the last thing 2766 # in the class declaration. 2767 match = Match( 2768 (r'\s*' 2769 r'(DISALLOW_(EVIL_CONSTRUCTORS|COPY_AND_ASSIGN|IMPLICIT_CONSTRUCTORS))' 2770 r'\(.*\);$'), 2771 line) 2772 if match and linenum + 1 < clean_lines.NumLines(): 2773 next_line = clean_lines.elided[linenum + 1] 2774 # We allow some, but not all, declarations of variables to be present 2775 # in the statement that defines the class. The [\w\*,\s]* fragment of 2776 # the regular expression below allows users to declare instances of 2777 # the class or pointers to instances, but not less common types such 2778 # as function pointers or arrays. It's a tradeoff between allowing 2779 # reasonable code and avoiding trying to parse more C++ using regexps. 2780 if not Search(r'^\s*}[\w\*,\s]*;', next_line): 2781 error(filename, linenum, 'readability/constructors', 3, 2782 match.group(1) + ' should be the last thing in the class') 2783 2784 # Check for use of unnamed namespaces in header files. Registration 2785 # macros are typically OK, so we allow use of "namespace {" on lines 2786 # that end with backslashes. 2787 if (file_extension == 'h' 2788 and Search(r'\bnamespace\s*{', line) 2789 and line[-1] != '\\'): 2790 error(filename, linenum, 'build/namespaces', 4, 2791 'Do not use unnamed namespaces in header files. See ' 2792 'http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml#Namespaces' 2793 ' for more information.') 2794 2795 2796def CheckCStyleCast(filename, linenum, line, raw_line, cast_type, pattern, 2797 error): 2798 """Checks for a C-style cast by looking for the pattern. 2799 2800 This also handles sizeof(type) warnings, due to similarity of content. 2801 2802 Args: 2803 filename: The name of the current file. 2804 linenum: The number of the line to check. 2805 line: The line of code to check. 2806 raw_line: The raw line of code to check, with comments. 2807 cast_type: The string for the C++ cast to recommend. This is either 2808 reinterpret_cast, static_cast, or const_cast, depending. 2809 pattern: The regular expression used to find C-style casts. 2810 error: The function to call with any errors found. 2811 2812 Returns: 2813 True if an error was emitted. 2814 False otherwise. 2815 """ 2816 match = Search(pattern, line) 2817 if not match: 2818 return False 2819 2820 # e.g., sizeof(int) 2821 sizeof_match = Match(r'.*sizeof\s*$', line[0:match.start(1) - 1]) 2822 if sizeof_match: 2823 error(filename, linenum, 'runtime/sizeof', 1, 2824 'Using sizeof(type). Use sizeof(varname) instead if possible') 2825 return True 2826 2827 remainder = line[match.end(0):] 2828 2829 # The close paren is for function pointers as arguments to a function. 2830 # eg, void foo(void (*bar)(int)); 2831 # The semicolon check is a more basic function check; also possibly a 2832 # function pointer typedef. 2833 # eg, void foo(int); or void foo(int) const; 2834 # The equals check is for function pointer assignment. 2835 # eg, void *(*foo)(int) = ... 2836 # The > is for MockCallback<...> ... 2837 # 2838 # Right now, this will only catch cases where there's a single argument, and 2839 # it's unnamed. It should probably be expanded to check for multiple 2840 # arguments with some unnamed. 2841 function_match = Match(r'\s*(\)|=|(const)?\s*(;|\{|throw\(\)|>))', remainder) 2842 if function_match: 2843 if (not function_match.group(3) or 2844 function_match.group(3) == ';' or 2845 ('MockCallback<' not in raw_line and 2846 '/*' not in raw_line)): 2847 error(filename, linenum, 'readability/function', 3, 2848 'All parameters should be named in a function') 2849 return True 2850 2851 # At this point, all that should be left is actual casts. 2852 error(filename, linenum, 'readability/casting', 4, 2853 'Using C-style cast. Use %s<%s>(...) instead' % 2854 (cast_type, match.group(1))) 2855 2856 return True 2857 2858 2859_HEADERS_CONTAINING_TEMPLATES = ( 2860 ('<deque>', ('deque',)), 2861 ('<functional>', ('unary_function', 'binary_function', 2862 'plus', 'minus', 'multiplies', 'divides', 'modulus', 2863 'negate', 2864 'equal_to', 'not_equal_to', 'greater', 'less', 2865 'greater_equal', 'less_equal', 2866 'logical_and', 'logical_or', 'logical_not', 2867 'unary_negate', 'not1', 'binary_negate', 'not2', 2868 'bind1st', 'bind2nd', 2869 'pointer_to_unary_function', 2870 'pointer_to_binary_function', 2871 'ptr_fun', 2872 'mem_fun_t', 'mem_fun', 'mem_fun1_t', 'mem_fun1_ref_t', 2873 'mem_fun_ref_t', 2874 'const_mem_fun_t', 'const_mem_fun1_t', 2875 'const_mem_fun_ref_t', 'const_mem_fun1_ref_t', 2876 'mem_fun_ref', 2877 )), 2878 ('<limits>', ('numeric_limits',)), 2879 ('<list>', ('list',)), 2880 ('<map>', ('map', 'multimap',)), 2881 ('<memory>', ('allocator',)), 2882 ('<queue>', ('queue', 'priority_queue',)), 2883 ('<set>', ('set', 'multiset',)), 2884 ('<stack>', ('stack',)), 2885 ('<string>', ('char_traits', 'basic_string',)), 2886 ('<utility>', ('pair',)), 2887 ('<vector>', ('vector',)), 2888 2889 # gcc extensions. 2890 # Note: std::hash is their hash, ::hash is our hash 2891 ('<hash_map>', ('hash_map', 'hash_multimap',)), 2892 ('<hash_set>', ('hash_set', 'hash_multiset',)), 2893 ('<slist>', ('slist',)), 2894 ) 2895 2896_RE_PATTERN_STRING = re.compile(r'\bstring\b') 2897 2898_re_pattern_algorithm_header = [] 2899for _template in ('copy', 'max', 'min', 'min_element', 'sort', 'swap', 2900 'transform'): 2901 # Match max<type>(..., ...), max(..., ...), but not foo->max, foo.max or 2902 # type::max(). 2903 _re_pattern_algorithm_header.append( 2904 (re.compile(r'[^>.]\b' + _template + r'(<.*?>)?\([^\)]'), 2905 _template, 2906 '<algorithm>')) 2907 2908_re_pattern_templates = [] 2909for _header, _templates in _HEADERS_CONTAINING_TEMPLATES: 2910 for _template in _templates: 2911 _re_pattern_templates.append( 2912 (re.compile(r'(\<|\b)' + _template + r'\s*\<'), 2913 _template + '<>', 2914 _header)) 2915 2916 2917def FilesBelongToSameModule(filename_cc, filename_h): 2918 """Check if these two filenames belong to the same module. 2919 2920 The concept of a 'module' here is a as follows: 2921 foo.h, foo-inl.h, foo.cc, foo_test.cc and foo_unittest.cc belong to the 2922 same 'module' if they are in the same directory. 2923 some/path/public/xyzzy and some/path/internal/xyzzy are also considered 2924 to belong to the same module here. 2925 2926 If the filename_cc contains a longer path than the filename_h, for example, 2927 '/absolute/path/to/base/sysinfo.cc', and this file would include 2928 'base/sysinfo.h', this function also produces the prefix needed to open the 2929 header. This is used by the caller of this function to more robustly open the 2930 header file. We don't have access to the real include paths in this context, 2931 so we need this guesswork here. 2932 2933 Known bugs: tools/base/bar.cc and base/bar.h belong to the same module 2934 according to this implementation. Because of this, this function gives 2935 some false positives. This should be sufficiently rare in practice. 2936 2937 Args: 2938 filename_cc: is the path for the .cc file 2939 filename_h: is the path for the header path 2940 2941 Returns: 2942 Tuple with a bool and a string: 2943 bool: True if filename_cc and filename_h belong to the same module. 2944 string: the additional prefix needed to open the header file. 2945 """ 2946 2947 if not filename_cc.endswith('.cc'): 2948 return (False, '') 2949 filename_cc = filename_cc[:-len('.cc')] 2950 if filename_cc.endswith('_unittest'): 2951 filename_cc = filename_cc[:-len('_unittest')] 2952 elif filename_cc.endswith('_test'): 2953 filename_cc = filename_cc[:-len('_test')] 2954 filename_cc = filename_cc.replace('/public/', '/') 2955 filename_cc = filename_cc.replace('/internal/', '/') 2956 2957 if not filename_h.endswith('.h'): 2958 return (False, '') 2959 filename_h = filename_h[:-len('.h')] 2960 if filename_h.endswith('-inl'): 2961 filename_h = filename_h[:-len('-inl')] 2962 filename_h = filename_h.replace('/public/', '/') 2963 filename_h = filename_h.replace('/internal/', '/') 2964 2965 files_belong_to_same_module = filename_cc.endswith(filename_h) 2966 common_path = '' 2967 if files_belong_to_same_module: 2968 common_path = filename_cc[:-len(filename_h)] 2969 return files_belong_to_same_module, common_path 2970 2971 2972def UpdateIncludeState(filename, include_state, io=codecs): 2973 """Fill up the include_state with new includes found from the file. 2974 2975 Args: 2976 filename: the name of the header to read. 2977 include_state: an _IncludeState instance in which the headers are inserted. 2978 io: The io factory to use to read the file. Provided for testability. 2979 2980 Returns: 2981 True if a header was succesfully added. False otherwise. 2982 """ 2983 headerfile = None 2984 try: 2985 headerfile = io.open(filename, 'r', 'utf8', 'replace') 2986 except IOError: 2987 return False 2988 linenum = 0 2989 for line in headerfile: 2990 linenum += 1 2991 clean_line = CleanseComments(line) 2992 match = _RE_PATTERN_INCLUDE.search(clean_line) 2993 if match: 2994 include = match.group(2) 2995 # The value formatting is cute, but not really used right now. 2996 # What matters here is that the key is in include_state. 2997 include_state.setdefault(include, '%s:%d' % (filename, linenum)) 2998 return True 2999 3000 3001def CheckForIncludeWhatYouUse(filename, clean_lines, include_state, error, 3002 io=codecs): 3003 """Reports for missing stl includes. 3004 3005 This function will output warnings to make sure you are including the headers 3006 necessary for the stl containers and functions that you use. We only give one 3007 reason to include a header. For example, if you use both equal_to<> and 3008 less<> in a .h file, only one (the latter in the file) of these will be 3009 reported as a reason to include the <functional>. 3010 3011 Args: 3012 filename: The name of the current file. 3013 clean_lines: A CleansedLines instance containing the file. 3014 include_state: An _IncludeState instance. 3015 error: The function to call with any errors found. 3016 io: The IO factory to use to read the header file. Provided for unittest 3017 injection. 3018 """ 3019 required = {} # A map of header name to linenumber and the template entity. 3020 # Example of required: { '<functional>': (1219, 'less<>') } 3021 3022 for linenum in xrange(clean_lines.NumLines()): 3023 line = clean_lines.elided[linenum] 3024 if not line or line[0] == '#': 3025 continue 3026 3027 # String is special -- it is a non-templatized type in STL. 3028 matched = _RE_PATTERN_STRING.search(line) 3029 if matched: 3030 # Don't warn about strings in non-STL namespaces: 3031 # (We check only the first match per line; good enough.) 3032 prefix = line[:matched.start()] 3033 if prefix.endswith('std::') or not prefix.endswith('::'): 3034 required['<string>'] = (linenum, 'string') 3035 3036 for pattern, template, header in _re_pattern_algorithm_header: 3037 if pattern.search(line): 3038 required[header] = (linenum, template) 3039 3040 # The following function is just a speed up, no semantics are changed. 3041 if not '<' in line: # Reduces the cpu time usage by skipping lines. 3042 continue 3043 3044 for pattern, template, header in _re_pattern_templates: 3045 if pattern.search(line): 3046 required[header] = (linenum, template) 3047 3048 # The policy is that if you #include something in foo.h you don't need to 3049 # include it again in foo.cc. Here, we will look at possible includes. 3050 # Let's copy the include_state so it is only messed up within this function. 3051 include_state = include_state.copy() 3052 3053 # Did we find the header for this file (if any) and succesfully load it? 3054 header_found = False 3055 3056 # Use the absolute path so that matching works properly. 3057 abs_filename = FileInfo(filename).FullName() 3058 3059 # For Emacs's flymake. 3060 # If cpplint is invoked from Emacs's flymake, a temporary file is generated 3061 # by flymake and that file name might end with '_flymake.cc'. In that case, 3062 # restore original file name here so that the corresponding header file can be 3063 # found. 3064 # e.g. If the file name is 'foo_flymake.cc', we should search for 'foo.h' 3065 # instead of 'foo_flymake.h' 3066 abs_filename = re.sub(r'_flymake\.cc$', '.cc', abs_filename) 3067 3068 # include_state is modified during iteration, so we iterate over a copy of 3069 # the keys. 3070 header_keys = include_state.keys() 3071 for header in header_keys: 3072 (same_module, common_path) = FilesBelongToSameModule(abs_filename, header) 3073 fullpath = common_path + header 3074 if same_module and UpdateIncludeState(fullpath, include_state, io): 3075 header_found = True 3076 3077 # If we can't find the header file for a .cc, assume it's because we don't 3078 # know where to look. In that case we'll give up as we're not sure they 3079 # didn't include it in the .h file. 3080 # TODO(unknown): Do a better job of finding .h files so we are confident that 3081 # not having the .h file means there isn't one. 3082 if filename.endswith('.cc') and not header_found: 3083 return 3084 3085 # All the lines have been processed, report the errors found. 3086 for required_header_unstripped in required: 3087 template = required[required_header_unstripped][1] 3088 if required_header_unstripped.strip('<>"') not in include_state: 3089 error(filename, required[required_header_unstripped][0], 3090 'build/include_what_you_use', 4, 3091 'Add #include ' + required_header_unstripped + ' for ' + template) 3092 3093 3094_RE_PATTERN_EXPLICIT_MAKEPAIR = re.compile(r'\bmake_pair\s*<') 3095 3096 3097def CheckMakePairUsesDeduction(filename, clean_lines, linenum, error): 3098 """Check that make_pair's template arguments are deduced. 3099 3100 G++ 4.6 in C++0x mode fails badly if make_pair's template arguments are 3101 specified explicitly, and such use isn't intended in any case. 3102 3103 Args: 3104 filename: The name of the current file. 3105 clean_lines: A CleansedLines instance containing the file. 3106 linenum: The number of the line to check. 3107 error: The function to call with any errors found. 3108 """ 3109 raw = clean_lines.raw_lines 3110 line = raw[linenum] 3111 match = _RE_PATTERN_EXPLICIT_MAKEPAIR.search(line) 3112 if match: 3113 error(filename, linenum, 'build/explicit_make_pair', 3114 4, # 4 = high confidence 3115 'Omit template arguments from make_pair OR use pair directly OR' 3116 ' if appropriate, construct a pair directly') 3117 3118 3119def ProcessLine(filename, file_extension, 3120 clean_lines, line, include_state, function_state, 3121 class_state, error, extra_check_functions=[]): 3122 """Processes a single line in the file. 3123 3124 Args: 3125 filename: Filename of the file that is being processed. 3126 file_extension: The extension (dot not included) of the file. 3127 clean_lines: An array of strings, each representing a line of the file, 3128 with comments stripped. 3129 line: Number of line being processed. 3130 include_state: An _IncludeState instance in which the headers are inserted. 3131 function_state: A _FunctionState instance which counts function lines, etc. 3132 class_state: A _ClassState instance which maintains information about 3133 the current stack of nested class declarations being parsed. 3134 error: A callable to which errors are reported, which takes 4 arguments: 3135 filename, line number, error level, and message 3136 extra_check_functions: An array of additional check functions that will be 3137 run on each source line. Each function takes 4 3138 arguments: filename, clean_lines, line, error 3139 """ 3140 raw_lines = clean_lines.raw_lines 3141 ParseNolintSuppressions(filename, raw_lines[line], line, error) 3142 CheckForFunctionLengths(filename, clean_lines, line, function_state, error) 3143 CheckForMultilineCommentsAndStrings(filename, clean_lines, line, error) 3144 CheckStyle(filename, clean_lines, line, file_extension, class_state, error) 3145 CheckLanguage(filename, clean_lines, line, file_extension, include_state, 3146 error) 3147 CheckForNonStandardConstructs(filename, clean_lines, line, 3148 class_state, error) 3149 CheckPosixThreading(filename, clean_lines, line, error) 3150 CheckInvalidIncrement(filename, clean_lines, line, error) 3151 CheckMakePairUsesDeduction(filename, clean_lines, line, error) 3152 for check_fn in extra_check_functions: 3153 check_fn(filename, clean_lines, line, error) 3154 3155def ProcessFileData(filename, file_extension, lines, error, 3156 extra_check_functions=[]): 3157 """Performs lint checks and reports any errors to the given error function. 3158 3159 Args: 3160 filename: Filename of the file that is being processed. 3161 file_extension: The extension (dot not included) of the file. 3162 lines: An array of strings, each representing a line of the file, with the 3163 last element being empty if the file is terminated with a newline. 3164 error: A callable to which errors are reported, which takes 4 arguments: 3165 filename, line number, error level, and message 3166 extra_check_functions: An array of additional check functions that will be 3167 run on each source line. Each function takes 4 3168 arguments: filename, clean_lines, line, error 3169 """ 3170 lines = (['// marker so line numbers and indices both start at 1'] + lines + 3171 ['// marker so line numbers end in a known way']) 3172 3173 include_state = _IncludeState() 3174 function_state = _FunctionState() 3175 class_state = _ClassState() 3176 3177 ResetNolintSuppressions() 3178 3179 CheckForCopyright(filename, lines, error) 3180 3181 if file_extension == 'h': 3182 CheckForHeaderGuard(filename, lines, error) 3183 3184 RemoveMultiLineComments(filename, lines, error) 3185 clean_lines = CleansedLines(lines) 3186 for line in xrange(clean_lines.NumLines()): 3187 ProcessLine(filename, file_extension, clean_lines, line, 3188 include_state, function_state, class_state, error, 3189 extra_check_functions) 3190 class_state.CheckFinished(filename, error) 3191 3192 CheckForIncludeWhatYouUse(filename, clean_lines, include_state, error) 3193 3194 # We check here rather than inside ProcessLine so that we see raw 3195 # lines rather than "cleaned" lines. 3196 CheckForUnicodeReplacementCharacters(filename, lines, error) 3197 3198 CheckForNewlineAtEOF(filename, lines, error) 3199 3200def ProcessFile(filename, vlevel, extra_check_functions=[]): 3201 """Does google-lint on a single file. 3202 3203 Args: 3204 filename: The name of the file to parse. 3205 3206 vlevel: The level of errors to report. Every error of confidence 3207 >= verbose_level will be reported. 0 is a good default. 3208 3209 extra_check_functions: An array of additional check functions that will be 3210 run on each source line. Each function takes 4 3211 arguments: filename, clean_lines, line, error 3212 """ 3213 3214 _SetVerboseLevel(vlevel) 3215 3216 try: 3217 # Support the UNIX convention of using "-" for stdin. Note that 3218 # we are not opening the file with universal newline support 3219 # (which codecs doesn't support anyway), so the resulting lines do 3220 # contain trailing '\r' characters if we are reading a file that 3221 # has CRLF endings. 3222 # If after the split a trailing '\r' is present, it is removed 3223 # below. If it is not expected to be present (i.e. os.linesep != 3224 # '\r\n' as in Windows), a warning is issued below if this file 3225 # is processed. 3226 3227 if filename == '-': 3228 lines = codecs.StreamReaderWriter(sys.stdin, 3229 codecs.getreader('utf8'), 3230 codecs.getwriter('utf8'), 3231 'replace').read().split('\n') 3232 else: 3233 lines = codecs.open(filename, 'r', 'utf8', 'replace').read().split('\n') 3234 3235 carriage_return_found = False 3236 # Remove trailing '\r'. 3237 for linenum in range(len(lines)): 3238 if lines[linenum].endswith('\r'): 3239 lines[linenum] = lines[linenum].rstrip('\r') 3240 carriage_return_found = True 3241 3242 except IOError: 3243 sys.stderr.write( 3244 "Skipping input '%s': Can't open for reading\n" % filename) 3245 return 3246 3247 # Note, if no dot is found, this will give the entire filename as the ext. 3248 file_extension = filename[filename.rfind('.') + 1:] 3249 3250 # When reading from stdin, the extension is unknown, so no cpplint tests 3251 # should rely on the extension. 3252 if (filename != '-' and file_extension != 'cc' and file_extension != 'h' 3253 and file_extension != 'cpp'): 3254 sys.stderr.write('Ignoring %s; not a .cc or .h file\n' % filename) 3255 else: 3256 ProcessFileData(filename, file_extension, lines, Error, 3257 extra_check_functions) 3258 if carriage_return_found and os.linesep != '\r\n': 3259 # Use 0 for linenum since outputting only one error for potentially 3260 # several lines. 3261 Error(filename, 0, 'whitespace/newline', 1, 3262 'One or more unexpected \\r (^M) found;' 3263 'better to use only a \\n') 3264 3265 sys.stderr.write('Done processing %s\n' % filename) 3266 3267 3268def PrintUsage(message): 3269 """Prints a brief usage string and exits, optionally with an error message. 3270 3271 Args: 3272 message: The optional error message. 3273 """ 3274 sys.stderr.write(_USAGE) 3275 if message: 3276 sys.exit('\nFATAL ERROR: ' + message) 3277 else: 3278 sys.exit(1) 3279 3280 3281def PrintCategories(): 3282 """Prints a list of all the error-categories used by error messages. 3283 3284 These are the categories used to filter messages via --filter. 3285 """ 3286 sys.stderr.write(''.join(' %s\n' % cat for cat in _ERROR_CATEGORIES)) 3287 sys.exit(0) 3288 3289 3290def ParseArguments(args): 3291 """Parses the command line arguments. 3292 3293 This may set the output format and verbosity level as side-effects. 3294 3295 Args: 3296 args: The command line arguments: 3297 3298 Returns: 3299 The list of filenames to lint. 3300 """ 3301 try: 3302 (opts, filenames) = getopt.getopt(args, '', ['help', 'output=', 'verbose=', 3303 'stdout', # TODO(enh): added --stdout 3304 'counting=', 3305 'filter=']) 3306 except getopt.GetoptError: 3307 PrintUsage('Invalid arguments.') 3308 3309 verbosity = _VerboseLevel() 3310 output_format = _OutputFormat() 3311 output_stream = sys.stderr # TODO(enh): added --stdout 3312 filters = '' 3313 counting_style = '' 3314 3315 for (opt, val) in opts: 3316 if opt == '--help': 3317 PrintUsage(None) 3318 elif opt == '--stdout': # TODO(enh): added --stdout 3319 output_stream = sys.stdout # TODO(enh): added --stdout 3320 elif opt == '--output': 3321 if not val in ('emacs', 'vs7'): 3322 PrintUsage('The only allowed output formats are emacs and vs7.') 3323 output_format = val 3324 elif opt == '--verbose': 3325 verbosity = int(val) 3326 elif opt == '--filter': 3327 filters = val 3328 if not filters: 3329 PrintCategories() 3330 elif opt == '--counting': 3331 if val not in ('total', 'toplevel', 'detailed'): 3332 PrintUsage('Valid counting options are total, toplevel, and detailed') 3333 counting_style = val 3334 3335 if not filenames: 3336 PrintUsage('No files were specified.') 3337 3338 _SetOutputFormat(output_format) 3339 _SetVerboseLevel(verbosity) 3340 _SetFilters(filters) 3341 _SetCountingStyle(counting_style) 3342 3343 sys.stderr = output_stream # TODO(enh): added --stdout 3344 3345 return filenames 3346 3347 3348def main(): 3349 filenames = ParseArguments(sys.argv[1:]) 3350 3351 # Change stderr to write with replacement characters so we don't die 3352 # if we try to print something containing non-ASCII characters. 3353 sys.stderr = codecs.StreamReaderWriter(sys.stderr, 3354 codecs.getreader('utf8'), 3355 codecs.getwriter('utf8'), 3356 'replace') 3357 3358 _cpplint_state.ResetErrorCounts() 3359 for filename in filenames: 3360 ProcessFile(filename, _cpplint_state.verbose_level) 3361 _cpplint_state.PrintErrorCounts() 3362 3363 sys.exit(_cpplint_state.error_count > 0) 3364 3365 3366if __name__ == '__main__': 3367 main() 3368