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