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 274 matching lines @@
         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.
 
     """
@@ skipping 61 matching lines @@
             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).
@@ skipping 93 matching lines @@
         row = single_line_view.convert_column_to_row(end_index)
 
         # Parse the parameter into a type and parameter name.
         skeleton_parameter = skeleton_parameters[start_index:end_index]
         name_offset = find_parameter_name_index(skeleton_parameter)
         parameter = single_line_view.single_line[start_index:end_index]
         yield Parameter(parameter, name_offset, row)
 
 
 class _FunctionState(object):
+
     """Tracks current function name and the number of lines in its body.
 
     Attributes:
       min_confidence: The minimum confidence level to use while checking style.
 
     """
 
     _NORMAL_TRIGGER = 250  # for --v=0, 500 for --v=1, etc.
     _TEST_TRIGGER = 400    # about 50% more than _NORMAL_TRIGGER.
 
@@ skipping 33 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 28 matching lines @@
                   ' %s has %d non-comment 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
 
 
 class FileInfo:
+
     """Provides utility functions for filenames.
 
     FileInfo provides easy access to the components of a file's path
     relative to the project root.
     """
 
     def __init__(self, filename):
         self._filename = filename
 
     def full_name(self):
@@ skipping 168 matching lines @@
       The line with single-line comments removed.
     """
     comment_position = line.find('//')
     if comment_position != -1 and not is_cpp_string(line[:comment_position]):
         line = line[:comment_position]
     # get rid of /* ... */
     return _RE_PATTERN_CLEANSE_LINE_C_COMMENTS.sub('', line)
 
 
 class CleansedLines(object):
+
     """Holds 3 copies of all lines with different preprocessing applied to them.
 
     1) elided member contains lines without strings and comments,
     2) lines member contains lines without comments, and
     3) raw member contains all the lines without processing.
     All these three members are of <type 'list'>, and of the same length.
     """
 
     def __init__(self, lines):
         self.elided = []
@@ skipping 334 matching lines @@
       line_number: The number of the line to check.
       error: The function to call with any errors found.
     """
     line = clean_lines.elided[line_number]
     if _RE_PATTERN_INVALID_INCREMENT.match(line):
         error(line_number, 'runtime/invalid_increment', 5,
               'Changing pointer instead of value (or unused value of operator*).')
 
 
 class _ClassInfo(object):
+
     """Stores information about a class."""
 
     def __init__(self, name, line_number):
         self.name = name
         self.line_number = line_number
         self.seen_open_brace = False
         self.is_derived = False
         self.virtual_method_line_number = None
         self.has_virtual_destructor = False
         self.brace_depth = 0
         self.unsigned_bitfields = []
         self.bool_bitfields = []
 
 
 class _ClassState(object):
+
     """Holds the current state of the parse relating to class declarations.
 
     It maintains a stack of _ClassInfos representing the parser's guess
     as to the current nesting of class declarations. The innermost class
     is at the top (back) of the stack. Typically, the stack will either
     be empty or have exactly one entry.
     """
 
     def __init__(self):
         self.classinfo_stack = []
@@ skipping 64 matching lines @@
             else:
                 self._is_c = False
         return self._is_c
 
     def is_c_or_objective_c(self):
         """Return whether the file extension corresponds to C or Objective-C."""
         return self.is_c() or self.is_objective_c()
 
 
 class _EnumState(object):
+
     """Maintains whether currently in an enum declaration, and checks whether
     enum declarations follow the style guide.
     """
 
     def __init__(self):
         self.in_enum_decl = False
         self.is_webidl_enum = False
 
     def process_clean_line(self, line):
         # FIXME: The regular expressions for expr_all_uppercase and expr_enum_end only accept integers
@@ skipping 173 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)