Run format-webkit on webkitpy code (without string conversion).

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 550 matching lines @@
         if self.is_declaration:
             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)
+        # ';' 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))
@@ skipping 867 matching lines @@
     brace_depth = classinfo.brace_depth
     brace_depth = brace_depth + line.count('{') - line.count('}')
     if brace_depth <= 0:
         classinfo = classinfo_stack.pop()
         # Try to detect missing virtual destructor declarations.
         # For now, only warn if a non-derived class with virtual methods lacks
         # a virtual destructor. This is to make it less likely that people will
         # declare derived virtual destructors without declaring the base
         # destructor virtual.
         if ((classinfo.virtual_method_line_number is not None)
-            and (not classinfo.has_virtual_destructor)
-            and (not classinfo.is_derived)):  # Only warn for base classes
+                and (not classinfo.has_virtual_destructor)
+                and (not classinfo.is_derived)):  # Only warn for base classes
             error(classinfo.line_number, 'runtime/virtual', 4,
                   'The class %s probably needs a virtual destructor due to '
                   'having virtual method(s), one declared at line %d.'
                   % (classinfo.name, classinfo.virtual_method_line_number))
         # Look for mixed bool and unsigned bitfields.
         if (classinfo.bool_bitfields and classinfo.unsigned_bitfields):
             bool_list = ', '.join(classinfo.bool_bitfields)
             unsigned_list = ', '.join(classinfo.unsigned_bitfields)
             error(classinfo.line_number, 'runtime/bitfields', 5,
                   'The class %s contains mixed unsigned and bool bitfields, '
@@ skipping 60 matching lines @@
     # function argument when the char before the whitespace is legal in
     # a function name (alnum + _) and we're not starting a macro. Also ignore
     # pointers and references to arrays and functions coz they're too tricky:
     # we use a very simple way to recognize these:
     # " (something)(maybe-something)" or
     # " (something)(maybe-something," or
     # " (something)[something]"
     # Note that we assume the contents of [] to be short enough that
     # they'll never need to wrap.
     if (  # Ignore control structures.
-        not search(r'\b(if|for|foreach|while|switch|return|new|delete)\b', function_call)
-        # Ignore pointers/references to functions.
-        and not search(r' \([^)]+\)\([^)]*(\)|,$)', function_call)
-        # Ignore pointers/references to arrays.
-        and not search(r' \([^)]+\)\[[^\]]+\]', function_call)):
+            not search(r'\b(if|for|foreach|while|switch|return|new|delete)\b', function_call)
+            # Ignore pointers/references to functions.
+            and not search(r' \([^)]+\)\([^)]*(\)|,$)', function_call)
+            # Ignore pointers/references to arrays.
+            and not search(r' \([^)]+\)\[[^\]]+\]', function_call)):
         if search(r'\w\s*\([ \t](?!\s*\\$)', function_call):      # a ( used for a fn call
             error(line_number, 'whitespace/parens', 4,
                   'Extra space after ( in function call')
         elif search(r'\([ \t]+(?!(\s*\\)|\()', function_call):
             error(line_number, 'whitespace/parens', 2,
                   'Extra space after (')
         if (search(r'\w\s+\(', function_call)
-            and not match(r'\s*(#|typedef)', function_call)):
+                and not match(r'\s*(#|typedef)', function_call)):
             error(line_number, 'whitespace/parens', 4,
                   'Extra space before ( in function call')
         # If the ) is followed only by a newline or a { + newline, assume it's
         # part of a control statement (if/while/etc), and don't complain
         if search(r'[^)\s]\s+\)(?!\s*$|{\s*$)', function_call):
             error(line_number, 'whitespace/parens', 2,
                   'Extra space before )')
 
 
 def is_blank_line(line):
@@ skipping 190 matching lines @@
        clean_lines: A CleansedLines instance containing the file.
        line_number: The number of the line to check.
        function_state: Current function name and lines in body so far.
        error: The function to call with any errors found.
     """
     if line_number != function_state.body_start_position.row:
         return
 
     modifiers_and_return_type = function_state.modifiers_and_return_type()
     if filename.find('/chromium/') != -1 and search(r'\bWEBKIT_EXPORT\b', modifiers_and_return_type):
-        if filename.find('/chromium/public/') == -1 and filename.find('/chromium/tests/') == -1 and filename.find('chromium/platform') == -1:
+        if filename.find('/chromium/public/') == -1 and filename.find('/chromium/tests/') == - \
+                1 and filename.find('chromium/platform') == -1:
             error(function_state.function_name_start_position.row, 'readability/webkit_export', 5,
                   'WEBKIT_EXPORT should only appear in the chromium public (or tests) directory.')
         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,
@@ skipping 96 matching lines @@
     # blank lines at the end of a function (ie, right before a line like '}').
     if is_blank_line(line):
         elided = clean_lines.elided
         previous_line = elided[line_number - 1]
         previous_brace = previous_line.rfind('{')
         # FIXME: Don't complain if line before blank line, and line after,
         #        both start with alnums and are indented the same amount.
         #        This ignores whitespace at the start of a namespace block
         #        because those are not usually indented.
         if (previous_brace != -1 and previous_line[previous_brace:].find('}') == -1
-            and previous_line[:previous_brace].find('namespace') == -1):
+                and previous_line[:previous_brace].find('namespace') == -1):
             # OK, we have a blank line at the start of a code block.  Before we
             # complain, we check if it is an exception to the rule: The previous
             # non-empty line has the parameters of a function header that are indented
             # 4 spaces (because they did not fit in a 80 column line when placed on
             # the same line as the function name).  We also check for the case where
             # the previous line is indented 6 spaces, which may happen when the
             # initializers of a constructor do not fit into a 80 column line.
             exception = False
             if match(r' {6}\w', previous_line):  # Initializer list?
                 # We are looking for the opening column of initializer list, which
@@ skipping 276 matching lines @@
         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.
                 in_preprocessor_directive = current_line[-1] == '\\'
             else:
                 looking_for_semicolon = ((';' not in current_line) and (current_line.strip()
-                                                                             [-1] != '}')) or (current_line[-1] == '\\')
+                                                                        [-1] != '}')) or (current_line[-1] == '\\')
         else:
             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
 
 
 def check_enum_casing(clean_lines, line_number, enum_state, error):
     """Looks for incorrectly named enum values.
 
@@ skipping 226 matching lines @@
         # 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 '{'.
         # We also allow '#' for #endif and '=' for array initialization.
         previous_line = get_previous_non_blank_line(clean_lines, line_number)[0]
         if ((not search(r'[;:}{)=]\s*$|\)\s*((const|override|final)\s*)*\s*(->\s*.+)?$', previous_line)
              or search(r'^\s*\b(if|for|foreach|while|switch|else)\b.*[^{]\s*$', previous_line))
-            and previous_line.find('#') < 0):
+                and previous_line.find('#') < 0):
             error(line_number, 'whitespace/braces', 4,
                   'This { should be at the end of the previous line')
     elif (search(r'\)\s*(((const|override|final)\s*)*\s*)?{\s*$', line)
           and line.count('(') == line.count(')')
           and not search(r'\b(if|for|foreach|while|switch)\b', line)
           and not match(r'\s+[A-Z_][A-Z_0-9]+\b', line)):
         error(line_number, 'whitespace/braces', 4,
               'Place brace on its own line for function definitions.')
 
     # An else clause should be on the same line as the preceding closing brace.
@@ skipping 17 matching lines @@
     # or initializing an array.
     # We can't tell in general, but we can for some common cases.
     previous_line_number = line_number
     while True:
         (previous_line, previous_line_number) = get_previous_non_blank_line(clean_lines, previous_line_number)
         if match(r'\s+{.*}\s*;', line) and not previous_line.count(';'):
             line = previous_line + line
         else:
             break
     if (search(r'{.*}\s*;', line)
-        and line.count('{') == line.count('}')
-        and not search(r'struct|class|enum|\s*=\s*{', line)):
+            and line.count('{') == line.count('}')
+            and not search(r'struct|class|enum|\s*=\s*{', line)):
         error(line_number, 'readability/braces', 4,
               "You don't need a ; after a }")
 
 
 def check_exit_statement_simplifications(clean_lines, line_number, error):
     """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:
@@ skipping 189 matching lines @@
     # 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
-    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):
+    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
 
@@ skipping 341 matching lines @@
 
     Args:
       filename: The input filename.
 
     Returns:
       The filename with the common suffix removed.
     """
     for suffix in ('test.cpp', 'regtest.cpp', 'unittest.cpp',
                    'inl.h', 'impl.h', 'internal.h'):
         if (filename.endswith(suffix) and len(filename) > len(suffix)
-            and filename[-len(suffix) - 1] in ('-', '_')):
+                and filename[-len(suffix) - 1] in ('-', '_')):
             return filename[:-len(suffix) - 1]
     return os.path.splitext(filename)[0]
 
 
 def _classify_include(filename, include, is_system, include_state):
     """Figures out what kind of header 'include' is.
 
     Args:
       filename: The current file cpp_style is running over.
       include: The path to a #included file.
@@ skipping 223 matching lines @@
                        r'\((int|float|double|bool|char|u?int(16|32|64))\)',
                        error)
     # This doesn't catch all cases.  Consider (const char * const)"hello".
     check_c_style_cast(line_number, line, clean_lines.raw_lines[line_number],
                        'reinterpret_cast', r'\((\w+\s?\*+\s?)\)', error)
 
     # In addition, we look for people taking the address of a cast.  This
     # is dangerous -- casts can assign to temporaries, so the pointer doesn't
     # point where you think.
     if search(
-        r'(&\([^)]+\)[\w(])|(&(static|dynamic|reinterpret)_cast\b)', line):
+            r'(&\([^)]+\)[\w(])|(&(static|dynamic|reinterpret)_cast\b)', line):
         error(line_number, 'runtime/casting', 4,
               ('Are you taking an address of a cast?  '
                'This is dangerous: could be a temp var.  '
                'Take the address before doing the cast, rather than after'))
 
     # Check for people declaring static/global STL strings at the top level.
     # This is dangerous because the C++ language does not guarantee that
     # globals with constructors are initialized before the first access.
     matched = match(
         r'((?:|static +)(?:|const +))string +([a-zA-Z0-9_:]+)\b(.*)',
@@ skipping 70 matching lines @@
     # Check for potential memset bugs like memset(buf, sizeof(buf), 0).
     matched = search(r'memset\s*\(([^,]*),\s*([^,]*),\s*0\s*\)', line)
     if matched and not match(r"^''|-?[0-9]+|0x[0-9A-Fa-f]$", matched.group(2)):
         error(line_number, 'runtime/memset', 4,
               'Did you mean "memset(%s, 0, %s)"?'
               % (matched.group(1), matched.group(2)))
 
     # Detect variable-length arrays.
     matched = match(r'\s*(.+::)?(\w+) [a-z]\w*\[(.+)];', line)
     if (matched and matched.group(2) != 'return' and matched.group(2) != 'delete' and
-        matched.group(3).find(']') == -1):
+            matched.group(3).find(']') == -1):
         # Split the size using space and arithmetic operators as delimiters.
         # If any of the resulting tokens are not compile time constants then
         # report the error.
         tokens = re.split(r'\s|\+|\-|\*|\/|<<|>>]', matched.group(3))
         is_const = True
         skip_next = False
         for tok in tokens:
             if skip_next:
                 skip_next = False
                 continue
@@ skipping 27 matching lines @@
             break
         if not is_const:
             error(line_number, 'runtime/arrays', 1,
                   'Do not use variable-length arrays.  Use an appropriately named '
                   "('k' followed by CamelCase) compile-time constant for the size.")
 
     # Check for use of unnamed namespaces in header files.  Registration
     # macros are typically OK, so we allow use of "namespace {" on lines
     # that end with backslashes.
     if (file_extension == 'h'
-        and search(r'\bnamespace\s*{', line)
-        and line[-1] != '\\'):
+            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)
@@ skipping 67 matching lines @@
     #
     # and we will need different treatments for them.
     line = sub(r'^\s*for\s*\(', '', line)
     line, control_statement = subn(r'^\s*(while|else if|if|switch)\s*\(', '', line)
 
     # Detect variable and functions.
     type_regexp = r'\w([\w]|\s*[*&]\s*|::)+'
     identifier_regexp = r'(?P<identifier>[\w:]+)'
     maybe_bitfield_regexp = r'(:\s*\d+\s*)?'
     character_after_identifier_regexp = r'(?P<character_after_identifier>[[;()=,])(?!=)'
-    declaration_without_type_regexp = r'\s*' + identifier_regexp + r'\s*' + maybe_bitfield_regexp + character_after_identifier_regexp
+    declaration_without_type_regexp = r'\s*' + identifier_regexp + \
+        r'\s*' + maybe_bitfield_regexp + character_after_identifier_regexp
     declaration_with_type_regexp = r'\s*' + type_regexp + r'\s' + declaration_without_type_regexp
     is_function_arguments = False
     number_of_identifiers = 0
     while True:
         # If we are seeing the first identifier or arguments of a
         # function, there should be a type name before an identifier.
         if not number_of_identifiers or is_function_arguments:
             declaration_regexp = declaration_with_type_regexp
         else:
             declaration_regexp = declaration_without_type_regexp
@@ skipping 10 matching lines @@
         if control_statement and character_after_identifier != '=':
             return
 
         is_function_arguments = is_function_arguments or character_after_identifier == '('
 
         # Remove "m_" and "s_" to allow them.
         modified_identifier = sub(r'(^|(?<=::))[ms]_', '', identifier)
         if not file_state.is_objective_c() and modified_identifier.find('_') >= 0:
             # Various exceptions to the rule: JavaScript op codes functions, const_iterator.
             if (not (filename.find('JavaScriptCore') >= 0 and modified_identifier.find('op_') >= 0)
-                and not (filename.find('gtk') >= 0 and modified_identifier.startswith('webkit_') >= 0)
-                and not modified_identifier.startswith('tst_')
-                and not modified_identifier.startswith('webkit_dom_object_')
-                and not modified_identifier.startswith('webkit_soup')
-                and not modified_identifier.startswith('NPN_')
-                and not modified_identifier.startswith('NPP_')
-                and not modified_identifier.startswith('NP_')
-                and not modified_identifier.startswith('qt_')
-                and not modified_identifier.startswith('_q_')
-                and not modified_identifier.startswith('cairo_')
-                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"):
+                    and not (filename.find('gtk') >= 0 and modified_identifier.startswith('webkit_') >= 0)
+                    and not modified_identifier.startswith('tst_')
+                    and not modified_identifier.startswith('webkit_dom_object_')
+                    and not modified_identifier.startswith('webkit_soup')
+                    and not modified_identifier.startswith('NPN_')
+                    and not modified_identifier.startswith('NPP_')
+                    and not modified_identifier.startswith('NP_')
+                    and not modified_identifier.startswith('qt_')
+                    and not modified_identifier.startswith('_q_')
+                    and not modified_identifier.startswith('cairo_')
+                    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.")
 
         # 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.")
 
         # There can be only one declaration in non-for-control statements.
         if control_statement:
@@ skipping 180 matching lines @@
     # eg, void foo(int); or void foo(int) const;
     # The equals check is for function pointer assignment.
     # eg, void *(*foo)(int) = ...
     #
     # Right now, this will only catch cases where there's a single argument, and
     # it's unnamed.  It should probably be expanded to check for multiple
     # arguments with some unnamed.
     function_match = match(r'\s*(\)|=|(const)?\s*(;|\{|throw\(\)))', remainder)
     if function_match:
         if (not function_match.group(3)
-            or function_match.group(3) == ';'
-            or raw_line.find('/*') < 0):
+                or function_match.group(3) == ';'
+                or raw_line.find('/*') < 0):
             error(line_number, 'readability/function', 3,
                   'All parameters should be named in a function')
         return
 
     # At this point, all that should be left is actual casts.
     error(line_number, 'readability/casting', 4,
           'Using C-style cast.  Use %s<%s>(...) instead' %
           (cast_type, matched.group(1)))
 
 
@@ skipping 439 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)