Run auto-formatter (autopep8) on webkitpy.

third_party/WebKit/Tools/Scripts/webkitpy/style/checkers/cpp.py

 # -*- coding: utf-8 -*-
 #
 # Copyright (C) 2009, 2010, 2012 Google Inc. All rights reserved.
 # Copyright (C) 2009 Torch Mobile Inc.
 # Copyright (C) 2009 Apple Inc. All rights reserved.
 # Copyright (C) 2010 Chris Jerdonek (cjerdonek@webkit.org)
 #
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions are
 # met:
@@ skipping 38 matching lines @@
 from webkitpy.common.system.filesystem import FileSystem
 
 # Headers that we consider STL headers.
 _STL_HEADERS = frozenset([
     'algobase.h', 'algorithm', 'alloc.h', 'bitset', 'deque', 'exception',
     'function.h', 'functional', 'hash_map', 'hash_map.h', 'hash_set',
     'hash_set.h', 'iterator', 'list', 'list.h', 'map', 'memory', 'pair.h',
     'pthread_alloc', 'queue', 'set', 'set.h', 'sstream', 'stack',
     'stl_alloc.h', 'stl_relops.h', 'type_traits.h',
     'utility', 'vector', 'vector.h',
-    ])
+])
 
 
 # Non-STL C++ system headers.
 _CPP_HEADERS = frozenset([
     'algo.h', 'builtinbuf.h', 'bvector.h', 'cassert', 'cctype',
     'cerrno', 'cfloat', 'ciso646', 'climits', 'clocale', 'cmath',
     'complex', 'complex.h', 'csetjmp', 'csignal', 'cstdarg', 'cstddef',
     'cstdio', 'cstdlib', 'cstring', 'ctime', 'cwchar', 'cwctype',
     'defalloc.h', 'deque.h', 'editbuf.h', 'exception', 'fstream',
     'fstream.h', 'hashtable.h', 'heap.h', 'indstream.h', 'iomanip',
     'iomanip.h', 'ios', 'iosfwd', 'iostream', 'iostream.h', 'istream.h',
     'iterator.h', 'limits', 'map.h', 'multimap.h', 'multiset.h',
     'numeric', 'ostream.h', 'parsestream.h', 'pfstream.h', 'PlotFile.h',
     'procbuf.h', 'pthread_alloc.h', 'rope', 'rope.h', 'ropeimpl.h',
     'SFile.h', 'slist', 'slist.h', 'stack.h', 'stdexcept',
     'stdiostream.h', 'streambuf.h', 'stream.h', 'strfile.h', 'string',
     'strstream', 'strstream.h', 'tempbuf.h', 'tree.h', 'typeinfo', 'valarray',
-    ])
+])
 
 
 # Assertion macros.  These are defined in base/logging.h and
 # testing/base/gunit.h.  Note that the _M versions need to come first
 # for substring matching to work.
 _CHECK_MACROS = [
     'DCHECK', 'CHECK',
     'EXPECT_TRUE_M', 'EXPECT_TRUE',
     'ASSERT_TRUE_M', 'ASSERT_TRUE',
     'EXPECT_FALSE_M', 'EXPECT_FALSE',
     'ASSERT_FALSE_M', 'ASSERT_FALSE',
-    ]
+]
 
 # Replacement macros for CHECK/DCHECK/EXPECT_TRUE/EXPECT_FALSE
 _CHECK_REPLACEMENT = dict([(m, {}) for m in _CHECK_MACROS])
 
 for op, replacement in [('==', 'EQ'), ('!=', 'NE'),
                         ('>=', 'GE'), ('>', 'GT'),
                         ('<=', 'LE'), ('<', 'LT')]:
     _CHECK_REPLACEMENT['DCHECK'][op] = 'DCHECK_%s' % replacement
     _CHECK_REPLACEMENT['CHECK'][op] = 'CHECK_%s' % replacement
     _CHECK_REPLACEMENT['EXPECT_TRUE'][op] = 'EXPECT_%s' % replacement
@@ skipping 99 matching lines @@
         if found_match:
             return Position(current_row, starting_offset + found_match.start())
 
         # A match was not found so continue forward.
         current_row += 1
         starting_offset = 0
         if current_row >= len(lines):
             return not_found_position
         current_line = lines[current_row]
 
+
 def _rfind_in_lines(regex, lines, start_position, not_found_position):
     """Does a reverse find starting at start position and going backwards until
     a match is found.
 
     Returns the position where the regex ended.
     """
     # Put the regex in a group and proceed it with a greedy expression that
     # matches anything to ensure that we get the last possible match in a line.
     last_in_line_regex = r'.*(' + regex + ')'
     current_row = start_position.row
@@ skipping 25 matching lines @@
     # (This puts an underscore before A in isA but not A in CBA).
     text = sub(r'(?<=[a-z0-9])([A-Z])(?=\b)', r'_\1', text)
 
     # Next add underscores when you have a captial letter which is followed by a capital letter
     # but is not proceeded by one. (This puts an underscore before A in 'WordADay').
     text = sub(r'(?<=[a-z0-9])([A-Z][A-Z_])', r'_\1', text)
 
     return text.lower()
 
 
-
 def _create_acronym(text):
     """Creates an acronym for the given text."""
     # Removes all lower case letters except those starting words.
     text = sub(r'(?<!\b)[a-z]', '', text)
     return text.upper()
 
 
 def up_to_unmatched_closing_paren(s):
     """Splits a string into two parts up to first unmatched ')'.
 
     Args:
       s: a string which is a substring of line after '('
       (e.g., "a == (b + c))").
 
     Returns:
       A pair of strings (prefix before first unmatched ')',
       remainder of s after first unmatched ')'), e.g.,
       up_to_unmatched_closing_paren("a == (b + c)) { ")
       returns "a == (b + c)", " {".
       Returns None, None if there is no unmatched ')'
 
     """
     i = 1
     for pos, c in enumerate(s):
-      if c == '(':
-        i += 1
-      elif c == ')':
-        i -= 1
-        if i == 0:
-          return s[:pos], s[pos + 1:]
+        if c == '(':
+            i += 1
+        elif c == ')':
+            i -= 1
+            if i == 0:
+                return s[:pos], s[pos + 1:]
     return None, None
 
+
 class _IncludeState(dict):
     """Tracks line numbers for includes, and the order in which includes appear.
 
     As a dict, an _IncludeState object serves as a mapping between include
     filename and line number on which that file was included.
 
     Call check_next_include_order() once for each header in the file, passing
     in the type constants defined above. Calls in an illegal order will
     raise an _IncludeError with an appropriate error message.
 
     """
     # self._section will move monotonically through this set. If it ever
     # needs to move backwards, check_next_include_order will raise an error.
     _INITIAL_SECTION = 0
     _PRIMARY_SECTION = 1
     _OTHER_SECTION = 2
 
     _TYPE_NAMES = {
         _PRIMARY_HEADER: 'header this file implements',
         _OTHER_HEADER: 'other header',
         _MOC_HEADER: 'moc file',
-        }
+    }
     _SECTION_NAMES = {
         _INITIAL_SECTION: "... nothing.",
         _PRIMARY_SECTION: 'a header this file implements.',
         _OTHER_SECTION: 'other header.',
-        }
+    }
 
     def __init__(self):
         dict.__init__(self)
         self._section = self._INITIAL_SECTION
         self._visited_primary_section = False
-        self.header_types = dict();
+        self.header_types = dict()
 
     def visited_primary_section(self):
         return self._visited_primary_section
 
     def check_next_include_order(self, header_type, file_is_header, primary_header_exists):
         """Returns a non-empty error message if the next header is out of order.
 
         This function also updates the internal state to be ready to check
         the next include.
 
@@ skipping 10 matching lines @@
             return 'Header file should not contain itself.'
         if header_type == _MOC_HEADER:
             return ''
 
         error_message = ''
         if self._section != self._OTHER_SECTION:
             before_error_message = ('Found %s before %s' %
                                     (self._TYPE_NAMES[header_type],
                                      self._SECTION_NAMES[self._section + 1]))
         after_error_message = ('Found %s after %s' %
-                                (self._TYPE_NAMES[header_type],
-                                 self._SECTION_NAMES[self._section]))
+                               (self._TYPE_NAMES[header_type],
+                                self._SECTION_NAMES[self._section]))
 
         if header_type == _PRIMARY_HEADER:
             if self._section >= self._PRIMARY_SECTION:
                 error_message = after_error_message
             self._section = self._PRIMARY_SECTION
             self._visited_primary_section = True
         else:
             assert header_type == _OTHER_HEADER
             if not file_is_header and self._section < self._PRIMARY_SECTION:
                 if primary_header_exists:
                     error_message = before_error_message
             self._section = self._OTHER_SECTION
 
         return error_message
 
 
 class Position(object):
     """Holds the position of something."""
+
     def __init__(self, row, column):
         self.row = row
         self.column = column
 
     def __str__(self):
         return '(%s, %s)' % (self.row, self.column)
 
     def __cmp__(self, other):
         return self.row.__cmp__(other.row) or self.column.__cmp__(other.column)
 
 
 class Parameter(object):
     """Information about one function parameter."""
+
     def __init__(self, parameter, parameter_name_index, row):
         self.type = parameter[:parameter_name_index].strip()
         # Remove any initializers from the parameter name (e.g. int i = 5).
         self.name = sub(r'=.*', '', parameter[parameter_name_index:]).strip()
         self.row = row
 
     @memoized
     def lower_with_underscores_name(self):
         """Returns the parameter name in the lower with underscores format."""
         return _convert_to_lower_with_underscores(self.name)
 
 
 class SingleLineView(object):
     """Converts multiple lines into a single line (with line breaks replaced by a
        space) to allow for easier searching."""
+
     def __init__(self, lines, start_position, end_position):
         """Create a SingleLineView instance.
 
         Args:
           lines: a list of multiple lines to combine into a single line.
           start_position: offset within lines of where to start the single line.
           end_position: just after where to end (like a slice operation).
         """
         # Get the rows of interest.
         trimmed_lines = lines[start_position.row:end_position.row + 1]
@@ skipping 134 matching lines @@
         self.lines_in_function = -1  # Don't count the open brace line.
         self.current_function = function_name
         self.function_name_start_position = function_name_start_position
         self.body_start_position = body_start_position
         self.end_position = end_position
         self.is_declaration = clean_lines.elided[body_start_position.row][body_start_position.column] == ';'
         self.parameter_start_position = parameter_start_position
         self.parameter_end_position = parameter_end_position
         self.is_pure = False
         if self.is_declaration:
-            characters_after_parameters = SingleLineView(clean_lines.elided, parameter_end_position, body_start_position).single_line
+            characters_after_parameters = SingleLineView(
+                clean_lines.elided, parameter_end_position, body_start_position).single_line
             self.is_pure = bool(match(r'\s*=\s*0\s*', characters_after_parameters))
         self._clean_lines = clean_lines
         self._parameter_list = None
 
     def modifiers_and_return_type(self):
         """Returns the modifiers and the return type."""
         # Go backwards from where the function name is until we encounter one of several things:
         #   ';' or '{' or '}' or 'private:', etc. or '#' or return Position(0, 0)
         elided = self._clean_lines.elided
         start_modifiers = _rfind_in_lines(r';|\{|\}|((private|public|protected):)|(#.*)',
                                           elided, self.parameter_start_position, Position(0, 0))
         return SingleLineView(elided, start_modifiers, self.function_name_start_position).single_line.strip()
 
     def parameter_list(self):
         if not self._parameter_list:
             # Store the final result as a tuple since that is immutable.
-            self._parameter_list = tuple(parameter_list(self._clean_lines.elided, self.parameter_start_position, self.parameter_end_position))
+            self._parameter_list = tuple(parameter_list(self._clean_lines.elided,
+                                                        self.parameter_start_position, self.parameter_end_position))
 
         return self._parameter_list
 
     def count(self, line_number):
         """Count line in current function body."""
         if self.in_a_function and line_number >= self.body_start_position.row:
             self.lines_in_function += 1
 
     def check(self, error, line_number):
         """Report if too many lines in function body.
 
         Args:
           error: The function to call with any errors found.
           line_number: The number of the line to check.
         """
         if match(r'T(EST|est)', self.current_function):
             base_trigger = self._TEST_TRIGGER
         else:
             base_trigger = self._NORMAL_TRIGGER
         trigger = base_trigger * 2 ** self.min_confidence
 
         if self.lines_in_function > trigger:
             error_level = int(math.log(self.lines_in_function / base_trigger, 2))
             # 50 => 0, 100 => 1, 200 => 2, 400 => 3, 800 => 4, 1600 => 5, ...
             if error_level > 5:
                 error_level = 5
             error(line_number, 'readability/fn_size', error_level,
                   'Small and focused functions are preferred:'
                   ' %s has %d non-comment lines'
-                  ' (error triggered by exceeding %d lines).'  % (
+                  ' (error triggered by exceeding %d lines).' % (
                       self.current_function, self.lines_in_function, trigger))
 
     def end(self):
         """Stop analyzing function body."""
         self.in_a_function = False
 
 
 class _IncludeError(Exception):
     """Indicates a problem with the include order in a file."""
     pass
@@ skipping 279 matching lines @@
                 if not net_open:
                     return Position(line_number, current_column)
 
         # Proceed to the next line.
         line_number += 1
         current_column = 0
 
     # The given item was not closed.
     return Position(len(elided), -1)
 
+
 def check_for_copyright(lines, error):
     """Logs an error if no Copyright message appears at the top of the file."""
 
     # We'll say it should occur by line 10. Don't forget there's a
     # dummy line at the front.
     for line in xrange(1, min(len(lines), 11)):
         if re.search(r'Copyright', lines[line], re.I):
             break
     else:                       # means no copyright line was found
         error(0, 'legal/copyright', 5,
@@ skipping 178 matching lines @@
     ('getgrnam(', 'getgrnam_r('),
     ('getlogin(', 'getlogin_r('),
     ('getpwnam(', 'getpwnam_r('),
     ('getpwuid(', 'getpwuid_r('),
     ('gmtime(', 'gmtime_r('),
     ('localtime(', 'localtime_r('),
     ('rand(', 'rand_r('),
     ('readdir(', 'readdir_r('),
     ('strtok(', 'strtok_r('),
     ('ttyname(', 'ttyname_r('),
-    )
+)
 
 
 def check_posix_threading(clean_lines, line_number, error):
     """Checks for calls to thread-unsafe functions.
 
     Much code has been originally written without consideration of
     multi-threading. Also, engineers are relying on their old experience;
     they have learned posix before threading extensions were added. These
     tests guide the engineers to use thread-safe functions (when using
     posix directly).
@@ skipping 79 matching lines @@
         if self.classinfo_stack:
             # Note: This test can result in false positives if #ifdef constructs
             # get in the way of brace matching. See the testBuildClass test in
             # cpp_style_unittest.py for an example of this.
             error(self.classinfo_stack[0].line_number, 'build/class', 5,
                   'Failed to find complete declaration of class %s' %
                   self.classinfo_stack[0].name)
 
 
 class _FileState(object):
+
     def __init__(self, clean_lines, file_extension):
         self._did_inside_namespace_indent_warning = False
         self._clean_lines = clean_lines
         if file_extension in ['m', 'mm']:
             self._is_objective_c = True
             self._is_c = False
         elif file_extension == 'h':
             # In the case of header files, it is unknown if the file
             # is c / objective c or not, so set this value to None and then
             # if it is requested, use heuristics to guess the value.
@@ skipping 79 matching lines @@
                         if match(expr_all_uppercase, member):
                             found_invalid_member = not self.is_webidl_enum
                         if match(expr_starts_lowercase, member):
                             found_invalid_member = True
                         if found_invalid_member:
                             self.is_webidl_enum = False
                             return False
                     return True
         return True
 
+
 def check_for_non_standard_constructs(clean_lines, line_number,
                                       class_state, error):
     """Logs an error if we see certain non-ANSI constructs ignored by gcc-2.
 
     Complain about several constructs which gcc-2 accepts, but which are
     not standard C++.  Warning about these in lint is one way to ease the
     transition to new compilers.
     - put storage class first (e.g. "static const" instead of "const static").
     - "%lld" instead of %qd" in printf-type functions.
     - "%1$d" is non-standard in printf-type functions.
@@ skipping 147 matching lines @@
             unsigned_list = ', '.join(classinfo.unsigned_bitfields)
             error(classinfo.line_number, 'runtime/bitfields', 5,
                   'The class %s contains mixed unsigned and bool bitfields, '
                   'which will pack into separate words on the MSVC compiler.\n'
                   'Bool bitfields are [%s].\nUnsigned bitfields are [%s].\n'
                   'Consider converting bool bitfields to unsigned.'
                   % (classinfo.name, bool_list, unsigned_list))
     else:
         classinfo.brace_depth = brace_depth
 
-    well_typed_bitfield = False;
+    well_typed_bitfield = False
     # Look for bool <name> : 1 declarations.
     args = search(r'\bbool\s+(\S*)\s*:\s*\d+\s*;', line)
     if args:
         classinfo.bool_bitfields.append('%d: %s' % (line_number, args.group(1)))
-        well_typed_bitfield = True;
+        well_typed_bitfield = True
 
     # Look for unsigned <name> : n declarations.
     args = search(r'\bunsigned\s+(?:int\s+)?(\S+)\s*:\s*\d+\s*;', line)
     if args:
         classinfo.unsigned_bitfields.append('%d: %s' % (line_number, args.group(1)))
-        well_typed_bitfield = True;
+        well_typed_bitfield = True
 
     # Look for other bitfield declarations. We don't care about those in
     # size-matching structs.
     if not (well_typed_bitfield or classinfo.name.startswith('SameSizeAs') or
             classinfo.name.startswith('Expected')):
         args = match(r'\s*(\S+)\s+(\S+)\s*:\s*\d+\s*;', line)
         if args:
             error(line_number, 'runtime/bitfields', 4,
                   'Member %s of class %s defined as a bitfield of type %s. '
                   'Please declare all bitfields as unsigned.'
                   % (args.group(2), classinfo.name, args.group(1)))
 
+
 def check_spacing_for_function_call(line, line_number, error):
     """Checks for the correctness of various spacing around function calls.
 
     Args:
       line: The text of the line to check.
       line_number: The number of the line to check.
       error: The function to call with any errors found.
     """
 
     # Since function calls often occur inside if/for/foreach/while/switch
@@ skipping 254 matching lines @@
         elif not file_extension == "h":
             error(function_state.function_name_start_position.row, 'readability/webkit_export', 5,
                   'WEBKIT_EXPORT should only be used in header files.')
         elif not function_state.is_declaration or search(r'\binline\b', modifiers_and_return_type):
             error(function_state.function_name_start_position.row, 'readability/webkit_export', 5,
                   'WEBKIT_EXPORT should not be used on a function with a body.')
         elif function_state.is_pure:
             error(function_state.function_name_start_position.row, 'readability/webkit_export', 5,
                   'WEBKIT_EXPORT should not be used with a pure virtual function.')
 
-    check_function_definition_and_pass_ptr(modifiers_and_return_type, function_state.function_name_start_position.row, 'return', error)
+    check_function_definition_and_pass_ptr(
+        modifiers_and_return_type, function_state.function_name_start_position.row, 'return', error)
 
     parameter_list = function_state.parameter_list()
     for parameter in parameter_list:
         check_function_definition_and_pass_ptr(parameter.type, parameter.row, 'parameter', error)
 
         # Do checks specific to function declarations and parameter names.
         if not function_state.is_declaration or not parameter.name:
             continue
 
         # Check the parameter name against the function name for single parameter set functions.
@@ skipping 145 matching lines @@
 
     # Next, we check for proper spacing with respect to comments.
     comment_position = line.find('//')
     if comment_position != -1:
         # Check if the // may be in quotes.  If so, ignore it
         # Comparisons made explicit for clarity
         if (line.count('"', 0, comment_position) - line.count('\\"', 0, comment_position)) % 2 == 0:   # not in quotes
             # Allow one space before end of line comment.
             if (not match(r'^\s*$', line[:comment_position])
                 and (comment_position >= 1
-                and ((line[comment_position - 1] not in string.whitespace)
-                     or (comment_position >= 2
-                         and line[comment_position - 2] in string.whitespace)))):
+                     and ((line[comment_position - 1] not in string.whitespace)
+                          or (comment_position >= 2
+                              and line[comment_position - 2] in string.whitespace)))):
                 error(line_number, 'whitespace/comments', 5,
                       'One space before end of line comments')
             # There should always be a space between the // and the comment
             commentend = comment_position + 2
             if commentend < len(line) and not line[commentend] == ' ':
                 # but some lines are exceptions -- e.g. if they're big
                 # comment delimiters like:
                 # //----------------------------------------------------------
                 # or they begin with multiple slashes followed by a space:
                 # //////// Header comment
@@ skipping 184 matching lines @@
 
     Args:
       clean_lines: A CleansedLines instance containing the file.
       line_number: The number of the line to check.
       file_extension: The extension (dot not included) of the file.
       file_state: A _FileState instance which maintains information about
                   the state of things in the file.
       error: The function to call with any errors found.
     """
 
-    line = clean_lines.elided[line_number] # Get rid of comments and strings.
+    line = clean_lines.elided[line_number]  # Get rid of comments and strings.
 
     namespace_match = match(r'(?P<namespace_indentation>\s*)namespace\s+\S+\s*{\s*$', line)
     if not namespace_match:
         return
 
     current_indentation_level = len(namespace_match.group('namespace_indentation'))
     if current_indentation_level > 0:
         # Don't warn about an indented namespace if we already warned about indented code.
         if not file_state.did_inside_namespace_indent_warning():
             error(line_number, 'whitespace/indent', 4,
                   'namespace should never be indented.')
         return
-    looking_for_semicolon = False;
+    looking_for_semicolon = False
     line_offset = 0
-    in_preprocessor_directive = False;
+    in_preprocessor_directive = False
     for current_line in clean_lines.elided[line_number + 1:]:
         line_offset += 1
         if not current_line.strip():
             continue
         if not current_indentation_level:
             if not (in_preprocessor_directive or looking_for_semicolon):
                 if not match(r'\S', current_line) and not file_state.did_inside_namespace_indent_warning():
                     file_state.set_did_inside_namespace_indent_warning()
                     error(line_number + line_offset, 'whitespace/indent', 4,
                           'Code inside a namespace should not be indented.')
-            if in_preprocessor_directive or (current_line.strip()[0] == '#'): # This takes care of preprocessor directive syntax.
+            if in_preprocessor_directive or (current_line.strip()[0] == '#'):  # This takes care of preprocessor directive syntax.
                 in_preprocessor_directive = current_line[-1] == '\\'
             else:
-                looking_for_semicolon = ((current_line.find(';') == -1) and (current_line.strip()[-1] != '}')) or (current_line[-1] == '\\')
+                looking_for_semicolon = ((current_line.find(';') == -1) and (current_line.strip()
+                                                                             [-1] != '}')) or (current_line[-1] == '\\')
         else:
-            looking_for_semicolon = False; # If we have a brace we may not need a semicolon.
+            looking_for_semicolon = False  # If we have a brace we may not need a semicolon.
         current_indentation_level += current_line.count('{') - current_line.count('}')
         if current_indentation_level < 0:
-            break;
+            break
 
 
 def check_enum_casing(clean_lines, line_number, enum_state, error):
     """Looks for incorrectly named enum values.
 
     Args:
       clean_lines: A CleansedLines instance containing the file.
       line_number: The number of the line to check.
       enum_state: A _EnumState instance which maintains enum declaration state.
       error: The function to call with any errors found.
     """
 
     enum_state.is_webidl_enum |= bool(match(r'\s*// Web(?:Kit)?IDL enum\s*$', clean_lines.raw_lines[line_number]))
 
     line = clean_lines.elided[line_number]  # Get rid of comments and strings.
     if not enum_state.process_clean_line(line):
         error(line_number, 'readability/enum_casing', 4,
               'enum members should use InterCaps with an initial capital letter.')
 
+
 def check_directive_indentation(clean_lines, line_number, file_state, error):
     """Looks for indentation of preprocessor directives.
 
     Args:
       clean_lines: A CleansedLines instance containing the file.
       line_number: The number of the line to check.
       file_state: A _FileState instance which maintains information about
                   the state of things in the file.
       error: The function to call with any errors found.
     """
@@ skipping 40 matching lines @@
       line_number: The number of the line to check.
       file_state: A _FileState instance which maintains information about
                   the state of things in the file.
       error: The function to call with any errors found.
     """
 
     # This check doesn't apply to C or Objective-C implementation files.
     if file_state.is_c_or_objective_c():
         return
 
-    line = clean_lines.elided[line_number] # Get rid of comments and strings.
+    line = clean_lines.elided[line_number]  # Get rid of comments and strings.
 
     using_std_match = match(r'\s*using\s+std::(?P<method_name>\S+)\s*;\s*$', line)
     if not using_std_match:
         return
 
     method_name = using_std_match.group('method_name')
     # Exception for the established idiom for swapping objects in generic code.
     if method_name == 'swap':
         return
     error(line_number, 'build/using_std', 4,
           "Use 'using namespace std;' instead of 'using std::%s;'." % method_name)
 
 
 def check_max_min_macros(clean_lines, line_number, file_state, error):
     """Looks use of MAX() and MIN() macros that should be replaced with std::max() and std::min().
 
     Args:
       clean_lines: A CleansedLines instance containing the file.
       line_number: The number of the line to check.
       file_state: A _FileState instance which maintains information about
                   the state of things in the file.
       error: The function to call with any errors found.
     """
 
     # This check doesn't apply to C or Objective-C implementation files.
     if file_state.is_c_or_objective_c():
         return
 
-    line = clean_lines.elided[line_number] # Get rid of comments and strings.
+    line = clean_lines.elided[line_number]  # Get rid of comments and strings.
 
     max_min_macros_search = search(r'\b(?P<max_min_macro>(MAX|MIN))\s*\(', line)
     if not max_min_macros_search:
         return
 
     max_min_macro = max_min_macros_search.group('max_min_macro')
     max_min_macro_lower = max_min_macro.lower()
     error(line_number, 'runtime/max_min_macros', 4,
           'Use std::%s() or std::%s<type>() instead of the %s() macro.'
           % (max_min_macro_lower, max_min_macro_lower, max_min_macro))
 
 
 def check_ctype_functions(clean_lines, line_number, file_state, error):
     """Looks for use of the standard functions in ctype.h and suggest they be replaced
        by use of equivilent ones in <wtf/ASCIICType.h>?.
 
     Args:
       clean_lines: A CleansedLines instance containing the file.
       line_number: The number of the line to check.
       file_state: A _FileState instance which maintains information about
                   the state of things in the file.
       error: The function to call with any errors found.
     """
 
     line = clean_lines.elided[line_number]  # Get rid of comments and strings.
 
-    ctype_function_search = search(r'\b(?P<ctype_function>(isalnum|isalpha|isascii|isblank|iscntrl|isdigit|isgraph|islower|isprint|ispunct|isspace|isupper|isxdigit|toascii|tolower|toupper))\s*\(', line)
+    ctype_function_search = search(
+        r'\b(?P<ctype_function>(isalnum|isalpha|isascii|isblank|iscntrl|isdigit|isgraph|islower|isprint|ispunct|isspace|isupper|isxdigit|toascii|tolower|toupper))\s*\(', line)
     if not ctype_function_search:
         return
 
     ctype_function = ctype_function_search.group('ctype_function')
     error(line_number, 'runtime/ctype_function', 4,
           'Use equivelent function in <wtf/ASCIICType.h> instead of the %s() function.'
           % (ctype_function))
 
+
 def check_switch_indentation(clean_lines, line_number, error):
     """Looks for indentation errors inside of switch statements.
 
     Args:
       clean_lines: A CleansedLines instance containing the file.
       line_number: The number of the line to check.
       error: The function to call with any errors found.
     """
 
-    line = clean_lines.elided[line_number] # Get rid of comments and strings.
+    line = clean_lines.elided[line_number]  # Get rid of comments and strings.
 
     switch_match = match(r'(?P<switch_indentation>\s*)switch\s*\(.+\)\s*{\s*$', line)
     if not switch_match:
         return
 
     switch_indentation = switch_match.group('switch_indentation')
     inner_indentation = switch_indentation + ' ' * 4
     line_offset = 0
     encountered_nested_switch = False
 
     for current_line in clean_lines.elided[line_number + 1:]:
         line_offset += 1
 
         # Skip not only empty lines but also those with preprocessor directives.
         if current_line.strip() == '' or current_line.startswith('#'):
             continue
 
         if match(r'\s*switch\s*\(.+\)\s*{\s*$', current_line):
             # Complexity alarm - another switch statement nested inside the one
             # that we're currently testing. We'll need to track the extent of
             # that inner switch if the upcoming label tests are still supposed
             # to work correctly. Let's not do that; instead, we'll finish
             # checking this line, and then leave it like that. Assuming the
             # indentation is done consistently (even if incorrectly), this will
             # still catch all indentation issues in practice.
             encountered_nested_switch = True
 
-        current_indentation_match = match(r'(?P<indentation>\s*)(?P<remaining_line>.*)$', current_line);
+        current_indentation_match = match(r'(?P<indentation>\s*)(?P<remaining_line>.*)$', current_line)
         current_indentation = current_indentation_match.group('indentation')
         remaining_line = current_indentation_match.group('remaining_line')
 
         # End the check at the end of the switch statement.
         if remaining_line.startswith('}') and current_indentation == switch_indentation:
             break
         # Case and default branches should not be indented. The regexp also
         # catches single-line cases like "default: break;" but does not trigger
         # on stuff like "Document::Foo();".
         elif match(r'(default|case\s+.*)\s*:([^:].*)?$', remaining_line):
@@ skipping 21 matching lines @@
 
 def check_braces(clean_lines, line_number, error):
     """Looks for misplaced braces (e.g. at the end of line).
 
     Args:
       clean_lines: A CleansedLines instance containing the file.
       line_number: The number of the line to check.
       error: The function to call with any errors found.
     """
 
-    line = clean_lines.elided[line_number] # Get rid of comments and strings.
+    line = clean_lines.elided[line_number]  # Get rid of comments and strings.
 
     if match(r'\s*{\s*$', line):
         # We allow an open brace to start a line in the case where someone
         # is using braces for function definition or in a block to
         # explicitly create a new scope, which is commonly used to control
         # the lifetime of stack-allocated variables.  We don't detect this
         # perfectly: we just don't complain if the last non-whitespace
         # character on the previous non-blank line is ';', ':', '{', '}',
         # ')' or is like a function declaration, and doesn't begin with
         # 'if|for|while|switch|else' without a beginning '{'.
@@ skipping 49 matching lines @@
     """Looks for else or else-if statements that should be written as an
     if statement when the prior if concludes with a return, break, continue or
     goto statement.
 
     Args:
       clean_lines: A CleansedLines instance containing the file.
       line_number: The number of the line to check.
       error: The function to call with any errors found.
     """
 
-    line = clean_lines.elided[line_number] # Get rid of comments and strings.
+    line = clean_lines.elided[line_number]  # Get rid of comments and strings.
 
     else_match = match(r'(?P<else_indentation>\s*)(\}\s*)?else(\s+if\s*\(|(?P<else>\s*(\{\s*)?\Z))', line)
     if not else_match:
         return
 
     else_indentation = else_match.group('else_indentation')
     inner_indentation = else_indentation + ' ' * 4
 
     previous_lines = clean_lines.elided[:line_number]
     previous_lines.reverse()
     line_offset = 0
     encountered_exit_statement = False
 
     for current_line in previous_lines:
         line_offset -= 1
 
         # Skip not only empty lines but also those with preprocessor directives
         # and goto labels.
         if current_line.strip() == '' or current_line.startswith('#') or match(r'\w+\s*:\s*$', current_line):
             continue
 
         # Skip lines with closing braces on the original indentation level.
         # Even though the styleguide says they should be on the same line as
         # the "else if" statement, we also want to check for instances where
         # the current code does not comply with the coding style. Thus, ignore
         # these lines and proceed to the line before that.
         if current_line == else_indentation + '}':
             continue
 
-        current_indentation_match = match(r'(?P<indentation>\s*)(?P<remaining_line>.*)$', current_line);
+        current_indentation_match = match(r'(?P<indentation>\s*)(?P<remaining_line>.*)$', current_line)
         current_indentation = current_indentation_match.group('indentation')
         remaining_line = current_indentation_match.group('remaining_line')
 
         # As we're going up the lines, the first real statement to encounter
         # has to be an exit statement (return, break, continue or goto) -
         # otherwise, this check doesn't apply.
         if not encountered_exit_statement:
             # We only want to find exit statements if they are on exactly
             # the same level of indentation as expected from the code inside
             # the block. If the indentation doesn't strictly match then we
@@ skipping 125 matching lines @@
         return
 
     # Don't warn about NULL usage in gst_*(). See Bug 70498.
     if search(r'\bgst(_[a-z]+)+\b', line):
         return
 
     # Don't warn about NULL usage in gdk_pixbuf_save_to_*{join,concat}(). See Bug 43090.
     if search(r'\bgdk_pixbuf_save_to\w+\b', line):
         return
 
-    # Don't warn about NULL usage in gtk_widget_style_get(), gtk_style_context_get_style(), or gtk_style_context_get(). See Bug 51758
+    # Don't warn about NULL usage in gtk_widget_style_get(),
+    # gtk_style_context_get_style(), or gtk_style_context_get(). See Bug 51758
     if search(r'\bgtk_widget_style_get\(\w+\b', line) or search(r'\bgtk_style_context_get_style\(\w+\b', line) or search(r'\bgtk_style_context_get\(\w+\b', line):
         return
 
     # Don't warn about NULL usage in soup_server_new(). See Bug 77890.
     if search(r'\bsoup_server_new\(\w+\b', line):
         return
 
     if search(r'\bNULL\b', line):
         error(line_number, 'readability/null', 5, 'Use 0 instead of NULL.')
         return
 
     line = clean_lines.raw_lines[line_number]
     # See if NULL occurs in any comments in the line. If the search for NULL using the raw line
     # matches, then do the check with strings collapsed to avoid giving errors for
     # NULLs occurring in strings.
     if search(r'\bNULL\b', line) and search(r'\bNULL\b', CleansedLines.collapse_strings(line)):
         error(line_number, 'readability/null', 4, 'Use 0 or null instead of NULL (even in *comments*).')
 
+
 def get_line_width(line):
     """Determines the width of the line in column positions.
 
     Args:
       line: A string, which may be a Unicode string.
 
     Returns:
       The width of the line in column positions, accounting for Unicode
       combining characters and wide characters.
     """
@@ skipping 354 matching lines @@
     """
 
     # If it is a system header we know it is classified as _OTHER_HEADER.
     if is_system and not include.startswith('public/'):
         return _OTHER_HEADER
 
     # There cannot be primary includes in header files themselves. Only an
     # include exactly matches the header filename will be is flagged as
     # primary, so that it triggers the "don't include yourself" check.
     if filename.endswith('.h') and filename != include:
-        return _OTHER_HEADER;
+        return _OTHER_HEADER
 
     # Qt's moc files do not follow the naming and ordering rules, so they should be skipped
     if include.startswith('moc_') and include.endswith('.cpp'):
         return _MOC_HEADER
 
     if include.endswith('.moc'):
         return _MOC_HEADER
 
     # If the target file basename starts with the include we're checking
     # then we consider it the primary header.
@@ skipping 97 matching lines @@
     # 1) for implementation files: primary header, blank line, alphabetically sorted
     # 2) for header files: alphabetically sorted
     # The include_state object keeps track of the last type seen
     # and complains if the header types are out of order or missing.
     error_message = include_state.check_next_include_order(header_type,
                                                            file_extension == "h",
                                                            primary_header_exists)
 
     # Check to make sure we have a blank line after primary header.
     if not error_message and header_type == _PRIMARY_HEADER:
-         next_line = clean_lines.raw_lines[line_number + 1]
-         if not is_blank_line(next_line):
+        next_line = clean_lines.raw_lines[line_number + 1]
+        if not is_blank_line(next_line):
             error(line_number, 'build/include_order', 4,
                   'You should add a blank line after implementation file\'s own header.')
 
     # Check to make sure all headers besides the primary header are
     # alphabetically sorted. Skip Qt's moc files.
     if not error_message and header_type == _OTHER_HEADER:
-         previous_line_number = line_number - 1;
-         previous_line = clean_lines.lines[previous_line_number]
-         previous_match = _RE_PATTERN_INCLUDE.search(previous_line)
-         while (not previous_match and previous_line_number > 0
-                and not search(r'\A(#if|#ifdef|#ifndef|#else|#elif|#endif)', previous_line)):
-            previous_line_number -= 1;
+        previous_line_number = line_number - 1
+        previous_line = clean_lines.lines[previous_line_number]
+        previous_match = _RE_PATTERN_INCLUDE.search(previous_line)
+        while (not previous_match and previous_line_number > 0
+               and not search(r'\A(#if|#ifdef|#ifndef|#else|#elif|#endif)', previous_line)):
+            previous_line_number -= 1
             previous_line = clean_lines.lines[previous_line_number]
             previous_match = _RE_PATTERN_INCLUDE.search(previous_line)
-         if previous_match:
+        if previous_match:
             previous_header_type = include_state.header_types[previous_line_number]
             if previous_header_type == _OTHER_HEADER and previous_line.strip() > line.strip():
                 # This type of error is potentially a problem with this line or the previous one,
                 # so if the error is filtered for one line, report it for the next. This is so that
                 # we properly handle patches, for which only modified lines produce errors.
                 if not error(line_number - 1, 'build/include_order', 4, 'Alphabetical sorting problem.'):
                     error(line_number, 'build/include_order', 4, 'Alphabetical sorting problem.')
 
     if error_message:
         if file_extension == 'h':
@@ skipping 206 matching lines @@
         and search(r'\bnamespace\s*{', line)
         and line[-1] != '\\'):
         error(line_number, 'build/namespaces', 4,
               'Do not use unnamed namespaces in header files.  See '
               'http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml#Namespaces'
               ' for more information.')
 
     # Check for plain bitfields declared without either "singed" or "unsigned".
     # Most compilers treat such bitfields as signed, but there are still compilers like
     # RVCT 4.0 that use unsigned by default.
-    matched = re.match(r'\s*((const|mutable)\s+)?(char|(short(\s+int)?)|int|long(\s+(long|int))?)\s+[a-zA-Z_][a-zA-Z0-9_]*\s*:\s*\d+\s*;', line)
+    matched = re.match(
+        r'\s*((const|mutable)\s+)?(char|(short(\s+int)?)|int|long(\s+(long|int))?)\s+[a-zA-Z_][a-zA-Z0-9_]*\s*:\s*\d+\s*;', line)
     if matched:
         error(line_number, 'runtime/bitfields', 5,
               'Please declare integral type bitfields with either signed or unsigned.')
 
     check_identifier_name_in_declaration(filename, line_number, line, file_state, error)
 
     # Check for unsigned int (should be just 'unsigned')
     if search(r'\bunsigned int\b', line):
         error(line_number, 'runtime/unsigned', 1,
               'Omit int when using unsigned')
@@ skipping 108 matching lines @@
                 and not modified_identifier.startswith('Ecore_')
                 and not modified_identifier.startswith('Eina_')
                 and not modified_identifier.startswith('Evas_')
                 and not modified_identifier.startswith('Ewk_')
                 and not modified_identifier.startswith('cti_')
                 and not modified_identifier.find('::qt_') >= 0
                 and not modified_identifier.find('::_q_') >= 0
                 and not modified_identifier == "const_iterator"
                 and not modified_identifier == "vm_throw"
                 and not modified_identifier == "DFG_OPERATION"):
-                error(line_number, 'readability/naming/underscores', 4, identifier + " is incorrectly named. Don't use underscores in your identifier names.")
+                error(line_number, 'readability/naming/underscores', 4, identifier +
+                      " is incorrectly named. Don't use underscores in your identifier names.")
 
         # Check for variables named 'l', these are too easy to confuse with '1' in some fonts
         if modified_identifier == 'l':
-            error(line_number, 'readability/naming', 4, identifier + " is incorrectly named. Don't use the single letter 'l' as an identifier name.")
+            error(line_number, 'readability/naming', 4, identifier +
+                  " is incorrectly named. Don't use the single letter 'l' as an identifier name.")
 
         # There can be only one declaration in non-for-control statements.
         if control_statement:
             return
         # We should continue checking if this is a function
         # declaration because we need to check its arguments.
         # Also, we need to check multiple declarations.
         if character_after_identifier != '(' and character_after_identifier != ',':
             return
 
@@ skipping 203 matching lines @@
                       'unary_negate', 'not1', 'binary_negate', 'not2',
                       'bind1st', 'bind2nd',
                       'pointer_to_unary_function',
                       'pointer_to_binary_function',
                       'ptr_fun',
                       'mem_fun_t', 'mem_fun', 'mem_fun1_t', 'mem_fun1_ref_t',
                       'mem_fun_ref_t',
                       'const_mem_fun_t', 'const_mem_fun1_t',
                       'const_mem_fun_ref_t', 'const_mem_fun1_ref_t',
                       'mem_fun_ref',
-                     )),
+                      )),
     ('<limits>', ('numeric_limits',)),
     ('<list>', ('list',)),
     ('<map>', ('map', 'multimap',)),
     ('<memory>', ('allocator',)),
     ('<queue>', ('queue', 'priority_queue',)),
     ('<set>', ('set', 'multiset',)),
     ('<stack>', ('stack',)),
     ('<string>', ('char_traits', 'basic_string',)),
     ('<utility>', ('pair',)),
     ('<vector>', ('vector',)),
 
     # gcc extensions.
     # Note: std::hash is their hash, ::hash is our hash
     ('<hash_map>', ('hash_map', 'hash_multimap',)),
     ('<hash_set>', ('hash_set', 'hash_multiset',)),
     ('<slist>', ('slist',)),
-    )
+)
 
 _HEADERS_ACCEPTED_BUT_NOT_PROMOTED = {
     # We can trust with reasonable confidence that map gives us pair<>, too.
     'pair<>': ('map', 'multimap', 'hash_map', 'hash_multimap')
 }
 
 _RE_PATTERN_STRING = re.compile(r'\bstring\b')
 
 _re_pattern_algorithm_header = []
 for _template in ('copy', 'max', 'min', 'min_element', 'sort', 'swap',
@@ skipping 107 matching lines @@
     less<> in a .h file, only one (the latter in the file) of these will be
     reported as a reason to include the <functional>.
 
     Args:
       filename: The name of the current file.
       clean_lines: A CleansedLines instance containing the file.
       include_state: An _IncludeState instance.
       error: The function to call with any errors found.
     """
     required = {}  # A map of header name to line_number and the template entity.
-        # Example of required: { '<functional>': (1219, 'less<>') }
+    # Example of required: { '<functional>': (1219, 'less<>') }
 
     for line_number in xrange(clean_lines.num_lines()):
         line = clean_lines.elided[line_number]
         if not line or line[0] == '#':
             continue
 
         # String is special -- it is a non-templatized type in STL.
         if _RE_PATTERN_STRING.search(line):
             required['<string>'] = (line_number, 'string')
 
@@ skipping 24 matching lines @@
     # If cpp_style is invoked from Emacs's flymake, a temporary file is generated
     # by flymake and that file name might end with '_flymake.cpp'. In that case,
     # restore original file name here so that the corresponding header file can be
     # found.
     # e.g. If the file name is 'foo_flymake.cpp', we should search for 'foo.h'
     # instead of 'foo_flymake.h'
     abs_filename = re.sub(r'_flymake\.cpp$', '.cpp', abs_filename)
 
     # include_state is modified during iteration, so we iterate over a copy of
     # the keys.
-    for header in include_state.keys():  #NOLINT
+    for header in include_state.keys():  # NOLINT
         (same_module, common_path) = files_belong_to_same_module(abs_filename, header)
         fullpath = common_path + header
         if same_module and update_include_state(fullpath, include_state):
             header_found = True
 
     # If we can't find the header file for a .cpp, assume it's because we don't
     # know where to look. In that case we'll give up as we're not sure they
     # didn't include it in the .h file.
     # FIXME: Do a better job of finding .h files so we are confident that
     #        not having the .h file means there isn't one.
@@ skipping 50 matching lines @@
     check_style(clean_lines, line, file_extension, class_state, file_state, enum_state, error)
     check_language(filename, clean_lines, line, file_extension, include_state,
                    file_state, error)
     check_for_non_standard_constructs(clean_lines, line, class_state, error)
     check_posix_threading(clean_lines, line, error)
     check_invalid_increment(clean_lines, line, error)
     check_conditional_and_loop_bodies_for_brace_violations(clean_lines, line, error)
     check_redundant_virtual(clean_lines, line, error)
     check_redundant_override(clean_lines, line, error)
 
+
 def _process_lines(filename, file_extension, lines, error, min_confidence):
     """Performs lint checks and reports any errors to the given error function.
 
     Args:
       filename: Filename of the file that is being processed.
       file_extension: The extension (dot not included) of the file.
       lines: An array of strings, each representing a line of the file, with the
              last element being empty if the file is termined with a newline.
       error: A callable to which errors are reported, which takes 4 arguments:
     """
@@ skipping 102 matching lines @@
         'whitespace/end_of_line',
         'whitespace/ending_newline',
         'whitespace/indent',
         'whitespace/line_length',
         'whitespace/newline',
         'whitespace/operators',
         'whitespace/parens',
         'whitespace/semicolon',
         'whitespace/tab',
         'whitespace/todo',
-        ])
+    ])
 
     fs = None
 
     def __init__(self, file_path, file_extension, handle_style_error,
                  min_confidence, fs=None):
         """Create a CppChecker instance.
 
         Args:
           file_extension: A string that is the file extension, without
                           the leading dot.
@@ skipping 26 matching lines @@
 
     def check(self, lines):
         _process_lines(self.file_path, self.file_extension, lines,
                        self.handle_style_error, self.min_confidence)
 
 
 # FIXME: Remove this function (requires refactoring unit tests).
 def process_file_data(filename, file_extension, lines, error, min_confidence, fs=None):
     checker = CppChecker(filename, file_extension, error, min_confidence, fs)
     checker.check(lines)