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