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