From e0c8b6ae14e931c6aaef621151cbad59467f0e3bcaebd8076eb0af0a4c9e6648 Mon Sep 17 00:00:00 2001 From: Daniel Garcia Date: Mon, 10 Apr 2023 12:05:37 +0000 Subject: [PATCH] - Add drop-sre-compile.patch upstream patch to fix issues with deprecated usage of sre_compile gh#cpplint/cpplint#214 - Update to 1.6.1 * Fix #195 Fix post increment/decrement operator causing a false positive. * Fix #202 .hh files should not be considered sytem headers * Fix #207 Python2 incompatibility for loading CPPLINT.cfg file * Fix #184 NOLINT(clang-analyzer) comments should not cause warnings - 1.6.0 (2022-02-19) * Fix #188: "Include the directory when naming header files" also for header files with other names like "*.hpp" - 1.5.5 (2021-05-20) * Fix #172: Added 'size_t' to typecasts detected by CheckCStyleCast * Fixed wrong CLI help text: Each filter needs + or - * Fix #164: add elif as an exception for CheckSpacingForFunctionCall() * Fix google#346: --root option not working on windows due to slashes in path OBS-URL: https://build.opensuse.org/package/show/devel:languages:python/python-cpplint?expand=0&rev=12 --- cpplint-1.5.4.tar.gz | 3 - cpplint-1.6.1.tar.gz | 3 + drop-sre-compile.patch | 1774 ++++++++++++++++++++++++++++++++++++++++ python-cpplint.changes | 20 + python-cpplint.spec | 16 +- 5 files changed, 1806 insertions(+), 10 deletions(-) delete mode 100644 cpplint-1.5.4.tar.gz create mode 100644 cpplint-1.6.1.tar.gz create mode 100644 drop-sre-compile.patch diff --git a/cpplint-1.5.4.tar.gz b/cpplint-1.5.4.tar.gz deleted file mode 100644 index e46195f..0000000 --- a/cpplint-1.5.4.tar.gz +++ /dev/null @@ -1,3 +0,0 @@ -version https://git-lfs.github.com/spec/v1 -oid sha256:c5d70711f06a7a8bfdc09bd7a19c13e114e009a70c8dc16caad1e5f0d2f3cc71 -size 359495 diff --git a/cpplint-1.6.1.tar.gz b/cpplint-1.6.1.tar.gz new file mode 100644 index 0000000..b4523c6 --- /dev/null +++ b/cpplint-1.6.1.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d430ce8f67afc1839340e60daa89e90de08b874bc27149833077bba726dfc13a +size 364487 diff --git a/drop-sre-compile.patch b/drop-sre-compile.patch new file mode 100644 index 0000000..09afe2e --- /dev/null +++ b/drop-sre-compile.patch @@ -0,0 +1,1774 @@ +From e84e84f53915ae2a9214e756cf89c573a73bbcd3 Mon Sep 17 00:00:00 2001 +From: Jochen Sprickerhof +Date: Sat, 24 Dec 2022 16:46:29 +0100 +Subject: [PATCH 1/2] Drop deprecated sre_compile usage + +--- + cpplint.py | 7 +++---- + 1 file changed, 3 insertions(+), 4 deletions(-) + +Index: cpplint-1.6.1/cpplint.py +=================================================================== +--- cpplint-1.6.1.orig/cpplint.py ++++ cpplint-1.6.1/cpplint.py +@@ -53,7 +53,6 @@ import itertools + import math # for log + import os + import re +-import sre_compile + import string + import sys + import sysconfig +@@ -853,8 +852,6 @@ _SED_FIXUPS = { + 'Missing space after ,': r's/,\([^ ]\)/, \1/g', + } + +-_regexp_compile_cache = {} +- + # {str, set(int)}: a map from error categories to sets of linenumbers + # on which those errors are expected and should be suppressed. + _error_suppressions = {} +@@ -978,7 +975,7 @@ def ParseNolintSuppressions(filename, ra + linenum: int, the number of the current line. + error: function, an error handler. + """ +- matched = Search(r'\bNOLINT(NEXTLINE)?\b(\([^)]+\))?', raw_line) ++ matched = re.search(r'\bNOLINT(NEXTLINE)?\b(\([^)]+\))?', raw_line) + if matched: + if matched.group(1): + suppressed_line = linenum + 1 +@@ -1042,41 +1039,6 @@ def IsErrorSuppressedByNolint(category, + linenum in _error_suppressions.get(None, set())) + + +-def Match(pattern, s): +- """Matches the string with the pattern, caching the compiled regexp.""" +- # The regexp compilation caching is inlined in both Match and Search for +- # performance reasons; factoring it out into a separate function turns out +- # to be noticeably expensive. +- if pattern not in _regexp_compile_cache: +- _regexp_compile_cache[pattern] = sre_compile.compile(pattern) +- return _regexp_compile_cache[pattern].match(s) +- +- +-def ReplaceAll(pattern, rep, s): +- """Replaces instances of pattern in a string with a replacement. +- +- The compiled regex is kept in a cache shared by Match and Search. +- +- Args: +- pattern: regex pattern +- rep: replacement text +- s: search string +- +- Returns: +- string with replacements made (or original string if no replacements) +- """ +- if pattern not in _regexp_compile_cache: +- _regexp_compile_cache[pattern] = sre_compile.compile(pattern) +- return _regexp_compile_cache[pattern].sub(rep, s) +- +- +-def Search(pattern, s): +- """Searches the string for the pattern, caching the compiled regexp.""" +- if pattern not in _regexp_compile_cache: +- _regexp_compile_cache[pattern] = sre_compile.compile(pattern) +- return _regexp_compile_cache[pattern].search(s) +- +- + def _IsSourceExtension(s): + """File extension (excluding dot) matches a source file extension.""" + return s in GetNonHeaderExtensions() +@@ -1194,7 +1156,7 @@ class _IncludeState(object): + # If previous line was a blank line, assume that the headers are + # intentionally sorted the way they are. + if (self._last_header > header_path and +- Match(r'^\s*#\s*include\b', clean_lines.elided[linenum - 1])): ++ re.match(r'^\s*#\s*include\b', clean_lines.elided[linenum - 1])): + return False + return True + +@@ -1536,7 +1498,7 @@ class _FunctionState(object): + if not self.in_a_function: + return + +- if Match(r'T(EST|est)', self.current_function): ++ if re.match(r'T(EST|est)', self.current_function): + base_trigger = self._TEST_TRIGGER + else: + base_trigger = self._NORMAL_TRIGGER +@@ -1808,7 +1770,7 @@ def CleanseRawStrings(raw_lines): + # Found the end of the string, match leading space for this + # line and resume copying the original lines, and also insert + # a "" on the last line. +- leading_space = Match(r'^(\s*)\S', line) ++ leading_space = re.match(r'^(\s*)\S', line) + line = leading_space.group(1) + '""' + line[end + len(delimiter):] + delimiter = None + else: +@@ -1829,9 +1791,9 @@ def CleanseRawStrings(raw_lines): + # before removing raw strings. This is because there are some + # cpplint checks that requires the comments to be preserved, but + # we don't want to check comments that are inside raw strings. +- matched = Match(r'^(.*?)\b(?:R|u8R|uR|UR|LR)"([^\s\\()]*)\((.*)$', line) ++ matched = re.match(r'^(.*?)\b(?:R|u8R|uR|UR|LR)"([^\s\\()]*)\((.*)$', line) + if (matched and +- not Match(r'^([^\'"]|\'(\\.|[^\'])*\'|"(\\.|[^"])*")*//', ++ not re.match(r'^([^\'"]|\'(\\.|[^\'])*\'|"(\\.|[^"])*")*//', + matched.group(1))): + delimiter = ')' + matched.group(2) + '"' + +@@ -1968,7 +1930,7 @@ class CleansedLines(object): + collapsed = '' + while True: + # Find the first quote character +- match = Match(r'^([^\'"]*)([\'"])(.*)$', elided) ++ match = re.match(r'^([^\'"]*)([\'"])(.*)$', elided) + if not match: + collapsed += elided + break +@@ -1993,8 +1955,8 @@ class CleansedLines(object): + # correctly as long as there are digits on both sides of the + # separator. So we are fine as long as we don't see something + # like "0.'3" (gcc 4.9.0 will not allow this literal). +- if Search(r'\b(?:0[bBxX]?|[1-9])[0-9a-fA-F]*$', head): +- match_literal = Match(r'^((?:\'?[0-9a-zA-Z_])*)(.*)$', "'" + tail) ++ if re.search(r'\b(?:0[bBxX]?|[1-9])[0-9a-fA-F]*$', head): ++ match_literal = re.match(r'^((?:\'?[0-9a-zA-Z_])*)(.*)$', "'" + tail) + collapsed += head + match_literal.group(1).replace("'", '') + elided = match_literal.group(2) + else: +@@ -2036,7 +1998,7 @@ def FindEndOfExpressionInLine(line, star + stack.pop() + if not stack: + return (-1, None) +- elif i > 0 and Search(r'\boperator\s*$', line[0:i]): ++ elif i > 0 and re.search(r'\boperator\s*$', line[0:i]): + # operator<, don't add to stack + continue + else: +@@ -2065,7 +2027,7 @@ def FindEndOfExpressionInLine(line, star + + # Ignore "->" and operator functions + if (i > 0 and +- (line[i - 1] == '-' or Search(r'\boperator\s*$', line[0:i - 1]))): ++ (line[i - 1] == '-' or re.search(r'\boperator\s*$', line[0:i - 1]))): + continue + + # Pop the stack if there is a matching '<'. Otherwise, ignore +@@ -2112,7 +2074,7 @@ def CloseExpression(clean_lines, linenum + """ + + line = clean_lines.elided[linenum] +- if (line[pos] not in '({[<') or Match(r'<[<=]', line[pos:]): ++ if (line[pos] not in '({[<') or re.match(r'<[<=]', line[pos:]): + return (line, clean_lines.NumLines(), -1) + + # Check first line +@@ -2160,8 +2122,8 @@ def FindStartOfExpressionInLine(line, en + # Ignore it if it's a "->" or ">=" or "operator>" + if (i > 0 and + (line[i - 1] == '-' or +- Match(r'\s>=\s', line[i - 1:]) or +- Search(r'\boperator\s*$', line[0:i]))): ++ re.match(r'\s>=\s', line[i - 1:]) or ++ re.search(r'\boperator\s*$', line[0:i]))): + i -= 1 + else: + stack.append('>') +@@ -2269,7 +2231,7 @@ def GetIndentLevel(line): + Returns: + An integer count of leading spaces, possibly zero. + """ +- indent = Match(r'^( *)\S', line) ++ indent = re.match(r'^( *)\S', line) + if indent: + return len(indent.group(1)) + else: +@@ -2397,12 +2359,12 @@ def CheckForHeaderGuard(filename, clean_ + # and not the general NOLINT or NOLINT(*) syntax. + raw_lines = clean_lines.lines_without_raw_strings + for i in raw_lines: +- if Search(r'//\s*NOLINT\(build/header_guard\)', i): ++ if re.search(r'//\s*NOLINT\(build/header_guard\)', i): + return + + # Allow pragma once instead of header guards + for i in raw_lines: +- if Search(r'^\s*#pragma\s+once', i): ++ if re.search(r'^\s*#pragma\s+once', i): + return + + cppvar = GetHeaderGuardCPPVariable(filename) +@@ -2448,7 +2410,7 @@ def CheckForHeaderGuard(filename, clean_ + # Check for "//" comments on endif line. + ParseNolintSuppressions(filename, raw_lines[endif_linenum], endif_linenum, + error) +- match = Match(r'#endif\s*//\s*' + cppvar + r'(_)?\b', endif) ++ match = re.match(r'#endif\s*//\s*' + cppvar + r'(_)?\b', endif) + if match: + if match.group(1) == '_': + # Issue low severity warning for deprecated double trailing underscore +@@ -2462,12 +2424,12 @@ def CheckForHeaderGuard(filename, clean_ + no_single_line_comments = True + for i in xrange(1, len(raw_lines) - 1): + line = raw_lines[i] +- if Match(r'^(?:(?:\'(?:\.|[^\'])*\')|(?:"(?:\.|[^"])*")|[^\'"])*//', line): ++ if re.match(r'^(?:(?:\'(?:\.|[^\'])*\')|(?:"(?:\.|[^"])*")|[^\'"])*//', line): + no_single_line_comments = False + break + + if no_single_line_comments: +- match = Match(r'#endif\s*/\*\s*' + cppvar + r'(_)?\s*\*/', endif) ++ match = re.match(r'#endif\s*/\*\s*' + cppvar + r'(_)?\s*\*/', endif) + if match: + if match.group(1) == '_': + # Low severity warning for double trailing underscore +@@ -2485,7 +2447,7 @@ def CheckHeaderFileIncluded(filename, in + + # Do not check test files + fileinfo = FileInfo(filename) +- if Search(_TEST_FILE_SUFFIX, fileinfo.BaseName()): ++ if re.search(_TEST_FILE_SUFFIX, fileinfo.BaseName()): + return + + for ext in GetHeaderExtensions(): +@@ -2643,7 +2605,7 @@ def CheckPosixThreading(filename, clean_ + for single_thread_func, multithread_safe_func, pattern in _THREADING_LIST: + # Additional pattern matching check to confirm that this is the + # function we are looking for +- if Search(pattern, line): ++ if re.search(pattern, line): + error(filename, linenum, 'runtime/threadsafe_fn', 2, + 'Consider using ' + multithread_safe_func + + '...) instead of ' + single_thread_func + +@@ -2663,7 +2625,7 @@ def CheckVlogArguments(filename, clean_l + error: The function to call with any errors found. + """ + line = clean_lines.elided[linenum] +- if Search(r'\bVLOG\((INFO|ERROR|WARNING|DFATAL|FATAL)\)', line): ++ if re.search(r'\bVLOG\((INFO|ERROR|WARNING|DFATAL|FATAL)\)', line): + error(filename, linenum, 'runtime/vlog', 5, + 'VLOG() should be used with numeric verbosity level. ' + 'Use LOG() if you want symbolic severity levels.') +@@ -2697,17 +2659,17 @@ def CheckInvalidIncrement(filename, clea + + + def IsMacroDefinition(clean_lines, linenum): +- if Search(r'^#define', clean_lines[linenum]): ++ if re.search(r'^#define', clean_lines[linenum]): + return True + +- if linenum > 0 and Search(r'\\$', clean_lines[linenum - 1]): ++ if linenum > 0 and re.search(r'\\$', clean_lines[linenum - 1]): + return True + + return False + + + def IsForwardClassDeclaration(clean_lines, linenum): +- return Match(r'^\s*(\btemplate\b)*.*class\s+\w+;\s*$', clean_lines[linenum]) ++ return re.match(r'^\s*(\btemplate\b)*.*class\s+\w+;\s*$', clean_lines[linenum]) + + + class _BlockInfo(object): +@@ -2802,7 +2764,7 @@ class _ClassInfo(_BlockInfo): + + def CheckBegin(self, filename, clean_lines, linenum, error): + # Look for a bare ':' +- if Search('(^|[^:]):($|[^:])', clean_lines.elided[linenum]): ++ if re.search('(^|[^:]):($|[^:])', clean_lines.elided[linenum]): + self.is_derived = True + + def CheckEnd(self, filename, clean_lines, linenum, error): +@@ -2810,7 +2772,7 @@ class _ClassInfo(_BlockInfo): + # the class. + seen_last_thing_in_class = False + for i in xrange(linenum - 1, self.starting_linenum, -1): +- match = Search( ++ match = re.search( + r'\b(DISALLOW_COPY_AND_ASSIGN|DISALLOW_IMPLICIT_CONSTRUCTORS)\(' + + self.name + r'\)', + clean_lines.elided[i]) +@@ -2820,13 +2782,13 @@ class _ClassInfo(_BlockInfo): + match.group(1) + ' should be the last thing in the class') + break + +- if not Match(r'^\s*$', clean_lines.elided[i]): ++ if not re.match(r'^\s*$', clean_lines.elided[i]): + seen_last_thing_in_class = True + + # Check that closing brace is aligned with beginning of the class. + # Only do this if the closing brace is indented by only whitespaces. + # This means we will not check single-line class definitions. +- indent = Match(r'^( *)\}', clean_lines.elided[linenum]) ++ indent = re.match(r'^( *)\}', clean_lines.elided[linenum]) + if indent and len(indent.group(1)) != self.class_indent: + if self.is_struct: + parent = 'struct ' + self.name +@@ -2860,7 +2822,7 @@ class _NamespaceInfo(_BlockInfo): + # deciding what these nontrivial things are, so this check is + # triggered by namespace size only, which works most of the time. + if (linenum - self.starting_linenum < 10 +- and not Match(r'^\s*};*\s*(//|/\*).*\bnamespace\b', line)): ++ and not re.match(r'^\s*};*\s*(//|/\*).*\bnamespace\b', line)): + return + + # Look for matching comment at end of namespace. +@@ -2877,7 +2839,7 @@ class _NamespaceInfo(_BlockInfo): + # expected namespace. + if self.name: + # Named namespace +- if not Match((r'^\s*};*\s*(//|/\*).*\bnamespace\s+' + ++ if not re.match((r'^\s*};*\s*(//|/\*).*\bnamespace\s+' + + re.escape(self.name) + r'[\*/\.\\\s]*$'), + line): + error(filename, linenum, 'readability/namespace', 5, +@@ -2885,10 +2847,10 @@ class _NamespaceInfo(_BlockInfo): + self.name) + else: + # Anonymous namespace +- if not Match(r'^\s*};*\s*(//|/\*).*\bnamespace[\*/\.\\\s]*$', line): ++ if not re.match(r'^\s*};*\s*(//|/\*).*\bnamespace[\*/\.\\\s]*$', line): + # If "// namespace anonymous" or "// anonymous namespace (more text)", + # mention "// anonymous namespace" as an acceptable form +- if Match(r'^\s*}.*\b(namespace anonymous|anonymous namespace)\b', line): ++ if re.match(r'^\s*}.*\b(namespace anonymous|anonymous namespace)\b', line): + error(filename, linenum, 'readability/namespace', 5, + 'Anonymous namespace should be terminated with "// namespace"' + ' or "// anonymous namespace"') +@@ -2991,7 +2953,7 @@ class NestingState(object): + while linenum < clean_lines.NumLines(): + # Find the earliest character that might indicate a template argument + line = clean_lines.elided[linenum] +- match = Match(r'^[^{};=\[\]\.<>]*(.)', line[pos:]) ++ match = re.match(r'^[^{};=\[\]\.<>]*(.)', line[pos:]) + if not match: + linenum += 1 + pos = 0 +@@ -3051,11 +3013,11 @@ class NestingState(object): + Args: + line: current line to check. + """ +- if Match(r'^\s*#\s*(if|ifdef|ifndef)\b', line): ++ if re.match(r'^\s*#\s*(if|ifdef|ifndef)\b', line): + # Beginning of #if block, save the nesting stack here. The saved + # stack will allow us to restore the parsing state in the #else case. + self.pp_stack.append(_PreprocessorInfo(copy.deepcopy(self.stack))) +- elif Match(r'^\s*#\s*(else|elif)\b', line): ++ elif re.match(r'^\s*#\s*(else|elif)\b', line): + # Beginning of #else block + if self.pp_stack: + if not self.pp_stack[-1].seen_else: +@@ -3070,7 +3032,7 @@ class NestingState(object): + else: + # TODO(unknown): unexpected #else, issue warning? + pass +- elif Match(r'^\s*#\s*endif\b', line): ++ elif re.match(r'^\s*#\s*endif\b', line): + # End of #if or #else blocks. + if self.pp_stack: + # If we saw an #else, we will need to restore the nesting +@@ -3142,7 +3104,7 @@ class NestingState(object): + # declarations even if it weren't followed by a whitespace, this + # is so that we don't confuse our namespace checker. The + # missing spaces will be flagged by CheckSpacing. +- namespace_decl_match = Match(r'^\s*namespace\b\s*([:\w]+)?(.*)$', line) ++ namespace_decl_match = re.match(r'^\s*namespace\b\s*([:\w]+)?(.*)$', line) + if not namespace_decl_match: + break + +@@ -3159,7 +3121,7 @@ class NestingState(object): + # such as in: + # class LOCKABLE API Object { + # }; +- class_decl_match = Match( ++ class_decl_match = re.match( + r'^(\s*(?:template\s*<[\w\s<>,:=]*>\s*)?' + r'(class|struct)\s+(?:[a-zA-Z0-9_]+\s+)*(\w+(?:::\w+)*))' + r'(.*)$', line) +@@ -3189,7 +3151,7 @@ class NestingState(object): + # Update access control if we are inside a class/struct + if self.stack and isinstance(self.stack[-1], _ClassInfo): + classinfo = self.stack[-1] +- access_match = Match( ++ access_match = re.match( + r'^(.*)\b(public|private|protected|signals)(\s+(?:slots\s*)?)?' + r':(?:[^:]|$)', + line) +@@ -3200,7 +3162,7 @@ class NestingState(object): + # check if the keywords are not preceded by whitespaces. + indent = access_match.group(1) + if (len(indent) != classinfo.class_indent + 1 and +- Match(r'^\s*$', indent)): ++ re.match(r'^\s*$', indent)): + if classinfo.is_struct: + parent = 'struct ' + classinfo.name + else: +@@ -3215,7 +3177,7 @@ class NestingState(object): + # Consume braces or semicolons from what's left of the line + while True: + # Match first brace, semicolon, or closed parenthesis. +- matched = Match(r'^[^{;)}]*([{;)}])(.*)$', line) ++ matched = re.match(r'^[^{;)}]*([{;)}])(.*)$', line) + if not matched: + break + +@@ -3226,7 +3188,7 @@ class NestingState(object): + # stack otherwise. + if not self.SeenOpenBrace(): + self.stack[-1].seen_open_brace = True +- elif Match(r'^extern\s*"[^"]*"\s*\{', line): ++ elif re.match(r'^extern\s*"[^"]*"\s*\{', line): + self.stack.append(_ExternCInfo(linenum)) + else: + self.stack.append(_BlockInfo(linenum, True)) +@@ -3317,25 +3279,25 @@ def CheckForNonStandardConstructs(filena + # Remove comments from the line, but leave in strings for now. + line = clean_lines.lines[linenum] + +- if Search(r'printf\s*\(.*".*%[-+ ]?\d*q', line): ++ if re.search(r'printf\s*\(.*".*%[-+ ]?\d*q', line): + error(filename, linenum, 'runtime/printf_format', 3, + '%q in format strings is deprecated. Use %ll instead.') + +- if Search(r'printf\s*\(.*".*%\d+\$', line): ++ if re.search(r'printf\s*\(.*".*%\d+\$', line): + error(filename, linenum, 'runtime/printf_format', 2, + '%N$ formats are unconventional. Try rewriting to avoid them.') + + # Remove escaped backslashes before looking for undefined escapes. + line = line.replace('\\\\', '') + +- if Search(r'("|\').*\\(%|\[|\(|{)', line): ++ if re.search(r'("|\').*\\(%|\[|\(|{)', line): + error(filename, linenum, 'build/printf_format', 3, + '%, [, (, and { are undefined character escapes. Unescape them.') + + # For the rest, work with both comments and strings removed. + line = clean_lines.elided[linenum] + +- if Search(r'\b(const|volatile|void|char|short|int|long' ++ if re.search(r'\b(const|volatile|void|char|short|int|long' + r'|float|double|signed|unsigned' + r'|schar|u?int8|u?int16|u?int32|u?int64)' + r'\s+(register|static|extern|typedef)\b', +@@ -3344,20 +3306,20 @@ def CheckForNonStandardConstructs(filena + 'Storage-class specifier (static, extern, typedef, etc) should be ' + 'at the beginning of the declaration.') + +- if Match(r'\s*#\s*endif\s*[^/\s]+', line): ++ if re.match(r'\s*#\s*endif\s*[^/\s]+', line): + error(filename, linenum, 'build/endif_comment', 5, + 'Uncommented text after #endif is non-standard. Use a comment.') + +- if Match(r'\s*class\s+(\w+\s*::\s*)+\w+\s*;', line): ++ if re.match(r'\s*class\s+(\w+\s*::\s*)+\w+\s*;', line): + error(filename, linenum, 'build/forward_decl', 5, + 'Inner-style forward declarations are invalid. Remove this line.') + +- if Search(r'(\w+|[+-]?\d+(\.\d*)?)\s*(<|>)\?=?\s*(\w+|[+-]?\d+)(\.\d*)?', ++ if re.search(r'(\w+|[+-]?\d+(\.\d*)?)\s*(<|>)\?=?\s*(\w+|[+-]?\d+)(\.\d*)?', + line): + error(filename, linenum, 'build/deprecated', 3, + '>? and = 1)) + initializer_list_constructor = bool( + onearg_constructor and +- Search(r'\bstd\s*::\s*initializer_list\b', constructor_args[0])) ++ re.search(r'\bstd\s*::\s*initializer_list\b', constructor_args[0])) + copy_constructor = bool( + onearg_constructor and +- Match(r'((const\s+(volatile\s+)?)?|(volatile\s+(const\s+)?))?' ++ re.match(r'((const\s+(volatile\s+)?)?|(volatile\s+(const\s+)?))?' + r'%s(\s*<[^>]*>)?(\s+const)?\s*(?:<\w+>\s*)?&' + % re.escape(base_classname), constructor_args[0].strip())) + +@@ -3470,7 +3432,7 @@ def CheckSpacingForFunctionCall(filename + r'\bfor\s*\((.*)\)\s*{', + r'\bwhile\s*\((.*)\)\s*[{;]', + r'\bswitch\s*\((.*)\)\s*{'): +- match = Search(pattern, line) ++ match = re.search(pattern, line) + if match: + fncall = match.group(1) # look inside the parens for function calls + break +@@ -3489,26 +3451,26 @@ def CheckSpacingForFunctionCall(filename + # 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|elif|for|while|switch|return|new|delete|catch|sizeof)\b', ++ not re.search(r'\b(if|elif|for|while|switch|return|new|delete|catch|sizeof)\b', + fncall) and + # Ignore pointers/references to functions. +- not Search(r' \([^)]+\)\([^)]*(\)|,$)', fncall) and ++ not re.search(r' \([^)]+\)\([^)]*(\)|,$)', fncall) and + # Ignore pointers/references to arrays. +- not Search(r' \([^)]+\)\[[^\]]+\]', fncall)): +- if Search(r'\w\s*\(\s(?!\s*\\$)', fncall): # a ( used for a fn call ++ not re.search(r' \([^)]+\)\[[^\]]+\]', fncall)): ++ if re.search(r'\w\s*\(\s(?!\s*\\$)', fncall): # a ( used for a fn call + error(filename, linenum, 'whitespace/parens', 4, + 'Extra space after ( in function call') +- elif Search(r'\(\s+(?!(\s*\\)|\()', fncall): ++ elif re.search(r'\(\s+(?!(\s*\\)|\()', fncall): + error(filename, linenum, 'whitespace/parens', 2, + 'Extra space after (') +- if (Search(r'\w\s+\(', fncall) and +- not Search(r'_{0,2}asm_{0,2}\s+_{0,2}volatile_{0,2}\s+\(', fncall) and +- not Search(r'#\s*define|typedef|using\s+\w+\s*=', fncall) and +- not Search(r'\w\s+\((\w+::)*\*\w+\)\(', fncall) and +- not Search(r'\bcase\s+\(', fncall)): ++ if (re.search(r'\w\s+\(', fncall) and ++ not re.search(r'_{0,2}asm_{0,2}\s+_{0,2}volatile_{0,2}\s+\(', fncall) and ++ not re.search(r'#\s*define|typedef|using\s+\w+\s*=', fncall) and ++ not re.search(r'\w\s+\((\w+::)*\*\w+\)\(', fncall) and ++ not re.search(r'\bcase\s+\(', fncall)): + # TODO(unknown): Space after an operator function seem to be a common + # error, silence those for now by restricting them to highest verbosity. +- if Search(r'\boperator_*\b', line): ++ if re.search(r'\boperator_*\b', line): + error(filename, linenum, 'whitespace/parens', 0, + 'Extra space before ( in function call') + else: +@@ -3516,10 +3478,10 @@ def CheckSpacingForFunctionCall(filename + '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]', fncall): ++ if re.search(r'[^)]\s+\)\s*[^{\s]', fncall): + # If the closing parenthesis is preceded by only whitespaces, + # try to give a more descriptive error message. +- if Search(r'^\s+\)', fncall): ++ if re.search(r'^\s+\)', fncall): + error(filename, linenum, 'whitespace/parens', 2, + 'Closing ) should be moved to the previous line') + else: +@@ -3585,13 +3547,13 @@ def CheckForFunctionLengths(filename, cl + + starting_func = False + regexp = r'(\w(\w|::|\*|\&|\s)*)\(' # decls * & space::name( ... +- match_result = Match(regexp, line) ++ match_result = re.match(regexp, line) + if match_result: + # If the name is all caps and underscores, figure it's a macro and + # ignore it, unless it's TEST or TEST_F. + function_name = match_result.group(1).split()[-1] + if function_name == 'TEST' or function_name == 'TEST_F' or ( +- not Match(r'[A-Z_]+$', function_name)): ++ not re.match(r'[A-Z_]+$', function_name)): + starting_func = True + + if starting_func: +@@ -3599,14 +3561,14 @@ def CheckForFunctionLengths(filename, cl + for start_linenum in xrange(linenum, clean_lines.NumLines()): + start_line = lines[start_linenum] + joined_line += ' ' + start_line.lstrip() +- if Search(r'(;|})', start_line): # Declarations and trivial functions ++ if re.search(r'(;|})', start_line): # Declarations and trivial functions + body_found = True + break # ... ignore +- if Search(r'{', start_line): ++ if re.search(r'{', start_line): + body_found = True +- function = Search(r'((\w|:)*)\(', line).group(1) +- if Match(r'TEST', function): # Handle TEST... macros +- parameter_regexp = Search(r'(\(.*\))', joined_line) ++ function = re.search(r'((\w|:)*)\(', line).group(1) ++ if re.match(r'TEST', function): # Handle TEST... macros ++ parameter_regexp = re.search(r'(\(.*\))', joined_line) + if parameter_regexp: # Ignore bad syntax + function += parameter_regexp.group(1) + else: +@@ -3617,10 +3579,10 @@ def CheckForFunctionLengths(filename, cl + # No body for the function (or evidence of a non-function) was found. + error(filename, linenum, 'readability/fn_size', 5, + 'Lint failed to find start of function body.') +- elif Match(r'^\}\s*$', line): # function end ++ elif re.match(r'^\}\s*$', line): # function end + function_state.Check(error, filename, linenum) + function_state.End() +- elif not Match(r'^\s*$', line): ++ elif not re.match(r'^\s*$', line): + function_state.Count() # Count non-blank/non-comment lines. + + +@@ -3642,7 +3604,7 @@ def CheckComment(line, filename, linenum + # Check if the // may be in quotes. If so, ignore it + if re.sub(r'\\.', '', line[0:commentpos]).count('"') % 2 == 0: + # Allow one space for new scopes, two spaces otherwise: +- if (not (Match(r'^.*{ *//', line) and next_line_start == commentpos) and ++ if (not (re.match(r'^.*{ *//', line) and next_line_start == commentpos) and + ((commentpos >= 1 and + line[commentpos-1] not in string.whitespace) or + (commentpos >= 2 and +@@ -3675,8 +3637,8 @@ def CheckComment(line, filename, linenum + # If the comment contains an alphanumeric character, there + # should be a space somewhere between it and the // unless + # it's a /// or //! Doxygen comment. +- if (Match(r'//[^ ]*\w', comment) and +- not Match(r'(///|//\!)(\s+|$)', comment)): ++ if (re.match(r'//[^ ]*\w', comment) and ++ not re.match(r'(///|//\!)(\s+|$)', comment)): + error(filename, linenum, 'whitespace/comments', 4, + 'Should have a space between // and comment') + +@@ -3739,12 +3701,12 @@ def CheckSpacing(filename, clean_lines, + # 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', prev_line): # Initializer list? ++ if re.match(r' {6}\w', prev_line): # Initializer list? + # We are looking for the opening column of initializer list, which + # should be indented 4 spaces to cause 6 space indentation afterwards. + search_position = linenum-2 + while (search_position >= 0 +- and Match(r' {6}\w', elided[search_position])): ++ and re.match(r' {6}\w', elided[search_position])): + search_position -= 1 + exception = (search_position >= 0 + and elided[search_position][:5] == ' :') +@@ -3755,9 +3717,9 @@ def CheckSpacing(filename, clean_lines, + # or colon (for initializer lists) we assume that it is the last line of + # a function header. If we have a colon indented 4 spaces, it is an + # initializer list. +- exception = (Match(r' {4}\w[^\(]*\)\s*(const\s*)?(\{\s*$|:)', ++ exception = (re.match(r' {4}\w[^\(]*\)\s*(const\s*)?(\{\s*$|:)', + prev_line) +- or Match(r' {4}:', prev_line)) ++ or re.match(r' {4}:', prev_line)) + + if not exception: + error(filename, linenum, 'whitespace/blank_line', 2, +@@ -3774,13 +3736,13 @@ def CheckSpacing(filename, clean_lines, + if linenum + 1 < clean_lines.NumLines(): + next_line = raw[linenum + 1] + if (next_line +- and Match(r'\s*}', next_line) ++ and re.match(r'\s*}', next_line) + and next_line.find('} else ') == -1): + error(filename, linenum, 'whitespace/blank_line', 3, + 'Redundant blank line at the end of a code block ' + 'should be deleted.') + +- matched = Match(r'\s*(public|protected|private):', prev_line) ++ matched = re.match(r'\s*(public|protected|private):', prev_line) + if matched: + error(filename, linenum, 'whitespace/blank_line', 3, + 'Do not leave a blank line after "%s:"' % matched.group(1)) +@@ -3797,15 +3759,15 @@ def CheckSpacing(filename, clean_lines, + + # You shouldn't have spaces before your brackets, except for C++11 attributes + # or maybe after 'delete []', 'return []() {};', or 'auto [abc, ...] = ...;'. +- if (Search(r'\w\s+\[(?!\[)', line) and +- not Search(r'(?:auto&?|delete|return)\s+\[', line)): ++ if (re.search(r'\w\s+\[(?!\[)', line) and ++ not re.search(r'(?:auto&?|delete|return)\s+\[', line)): + error(filename, linenum, 'whitespace/braces', 5, + 'Extra space before [') + + # In range-based for, we wanted spaces before and after the colon, but + # not around "::" tokens that might appear. +- if (Search(r'for *\(.*[^:]:[^: ]', line) or +- Search(r'for *\(.*[^: ]:[^:]', line)): ++ if (re.search(r'for *\(.*[^:]:[^: ]', line) or ++ re.search(r'for *\(.*[^: ]:[^:]', line)): + error(filename, linenum, 'whitespace/forcolon', 2, + 'Missing space around colon in range-based for loop') + +@@ -3828,7 +3790,7 @@ def CheckOperatorSpacing(filename, clean + # The replacement is done repeatedly to avoid false positives from + # operators that call operators. + while True: +- match = Match(r'^(.*\boperator\b)(\S+)(\s*\(.*)$', line) ++ match = re.match(r'^(.*\boperator\b)(\S+)(\s*\(.*)$', line) + if match: + line = match.group(1) + ('_' * len(match.group(2))) + match.group(3) + else: +@@ -3838,12 +3800,12 @@ def CheckOperatorSpacing(filename, clean + # Otherwise not. Note we only check for non-spaces on *both* sides; + # sometimes people put non-spaces on one side when aligning ='s among + # many lines (not that this is behavior that I approve of...) +- if ((Search(r'[\w.]=', line) or +- Search(r'=[\w.]', line)) +- and not Search(r'\b(if|while|for) ', line) ++ if ((re.search(r'[\w.]=', line) or ++ re.search(r'=[\w.]', line)) ++ and not re.search(r'\b(if|while|for) ', line) + # Operators taken from [lex.operators] in C++11 standard. +- and not Search(r'(>=|<=|==|!=|&=|\^=|\|=|\+=|\*=|\/=|\%=)', line) +- and not Search(r'operator=', line)): ++ and not re.search(r'(>=|<=|==|!=|&=|\^=|\|=|\+=|\*=|\/=|\%=)', line) ++ and not re.search(r'operator=', line)): + error(filename, linenum, 'whitespace/operators', 4, + 'Missing spaces around =') + +@@ -3862,16 +3824,16 @@ def CheckOperatorSpacing(filename, clean + # + # Note that && is not included here. This is because there are too + # many false positives due to RValue references. +- match = Search(r'[^<>=!\s](==|!=|<=|>=|\|\|)[^<>=!\s,;\)]', line) ++ match = re.search(r'[^<>=!\s](==|!=|<=|>=|\|\|)[^<>=!\s,;\)]', line) + if match: + error(filename, linenum, 'whitespace/operators', 3, + 'Missing spaces around %s' % match.group(1)) +- elif not Match(r'#.*include', line): ++ elif not re.match(r'#.*include', line): + # Look for < that is not surrounded by spaces. This is only + # triggered if both sides are missing spaces, even though + # technically should should flag if at least one side is missing a + # space. This is done to avoid some false positives with shifts. +- match = Match(r'^(.*[^\s<])<[^\s=<,]', line) ++ match = re.match(r'^(.*[^\s<])<[^\s=<,]', line) + if match: + (_, _, end_pos) = CloseExpression( + clean_lines, linenum, len(match.group(1))) +@@ -3882,7 +3844,7 @@ def CheckOperatorSpacing(filename, clean + # Look for > that is not surrounded by spaces. Similar to the + # above, we only trigger if both sides are missing spaces to avoid + # false positives with shifts. +- match = Match(r'^(.*[^-\s>])>[^\s=>,]', line) ++ match = re.match(r'^(.*[^-\s>])>[^\s=>,]', line) + if match: + (_, _, start_pos) = ReverseCloseExpression( + clean_lines, linenum, len(match.group(1))) +@@ -3895,7 +3857,7 @@ def CheckOperatorSpacing(filename, clean + # + # We also allow operators following an opening parenthesis, since + # those tend to be macros that deal with operators. +- match = Search(r'(operator|[^\s(<])(?:L|UL|LL|ULL|l|ul|ll|ull)?<<([^\s,=<])', line) ++ match = re.search(r'(operator|[^\s(<])(?:L|UL|LL|ULL|l|ul|ll|ull)?<<([^\s,=<])', line) + if (match and not (match.group(1).isdigit() and match.group(2).isdigit()) and + not (match.group(1) == 'operator' and match.group(2) == ';')): + error(filename, linenum, 'whitespace/operators', 3, +@@ -3913,13 +3875,13 @@ def CheckOperatorSpacing(filename, clean + # follows would be part of an identifier, and there should still be + # a space separating the template type and the identifier. + # type> alpha +- match = Search(r'>>[a-zA-Z_]', line) ++ match = re.search(r'>>[a-zA-Z_]', line) + if match: + error(filename, linenum, 'whitespace/operators', 3, + 'Missing spaces around >>') + + # There shouldn't be space around unary operators +- match = Search(r'(!\s|~\s|[\s]--[\s;]|[\s]\+\+[\s;])', line) ++ match = re.search(r'(!\s|~\s|[\s]--[\s;]|[\s]\+\+[\s;])', line) + if match: + error(filename, linenum, 'whitespace/operators', 4, + 'Extra space for operator %s' % match.group(1)) +@@ -3937,7 +3899,7 @@ def CheckParenthesisSpacing(filename, cl + line = clean_lines.elided[linenum] + + # No spaces after an if, while, switch, or for +- match = Search(r' (if\(|for\(|while\(|switch\()', line) ++ match = re.search(r' (if\(|for\(|while\(|switch\()', line) + if match: + error(filename, linenum, 'whitespace/parens', 5, + 'Missing space before ( in %s' % match.group(1)) +@@ -3947,14 +3909,14 @@ def CheckParenthesisSpacing(filename, cl + # there should either be zero or one spaces inside the parens. + # We don't want: "if ( foo)" or "if ( foo )". + # Exception: "for ( ; foo; bar)" and "for (foo; bar; )" are allowed. +- match = Search(r'\b(if|for|while|switch)\s*' ++ match = re.search(r'\b(if|for|while|switch)\s*' + r'\(([ ]*)(.).*[^ ]+([ ]*)\)\s*{\s*$', + line) + if match: + if len(match.group(2)) != len(match.group(4)): + if not (match.group(3) == ';' and + len(match.group(2)) == 1 + len(match.group(4)) or +- not match.group(2) and Search(r'\bfor\s*\(.*; \)', line)): ++ not match.group(2) and re.search(r'\bfor\s*\(.*; \)', line)): + error(filename, linenum, 'whitespace/parens', 5, + 'Mismatching spaces inside () in %s' % match.group(1)) + if len(match.group(2)) not in [0, 1]: +@@ -3985,8 +3947,8 @@ def CheckCommaSpacing(filename, clean_li + # verify that lines contain missing whitespaces, second pass on raw + # lines to confirm that those missing whitespaces are not due to + # elided comments. +- if (Search(r',[^,\s]', ReplaceAll(r'\boperator\s*,\s*\(', 'F(', line)) and +- Search(r',[^,\s]', raw[linenum])): ++ if (re.search(r',[^,\s]', re.sub(r'\boperator\s*,\s*\(', 'F(', line)) and ++ re.search(r',[^,\s]', raw[linenum])): + error(filename, linenum, 'whitespace/comma', 3, + 'Missing space after ,') + +@@ -3994,7 +3956,7 @@ def CheckCommaSpacing(filename, clean_li + # except for few corner cases + # TODO(unknown): clarify if 'if (1) { return 1;}' is requires one more + # space after ; +- if Search(r';[^\s};\\)/]', line): ++ if re.search(r';[^\s};\\)/]', line): + error(filename, linenum, 'whitespace/semicolon', 3, + 'Missing space after ;') + +@@ -4011,7 +3973,7 @@ def _IsType(clean_lines, nesting_state, + True, if token looks like a type. + """ + # Keep only the last token in the expression +- last_word = Match(r'^.*(\b\S+)$', expr) ++ last_word = re.match(r'^.*(\b\S+)$', expr) + if last_word: + token = last_word.group(1) + else: +@@ -4055,7 +4017,7 @@ def _IsType(clean_lines, nesting_state, + + # Look for typename in the specified range + for i in xrange(first_line, last_line + 1, 1): +- if Search(typename_pattern, clean_lines.elided[i]): ++ if re.search(typename_pattern, clean_lines.elided[i]): + return True + block_index -= 1 + +@@ -4081,7 +4043,7 @@ def CheckBracesSpacing(filename, clean_l + # And since you should never have braces at the beginning of a line, + # this is an easy test. Except that braces used for initialization don't + # follow the same rule; we often don't want spaces before those. +- match = Match(r'^(.*[^ ({>]){', line) ++ match = re.match(r'^(.*[^ ({>]){', line) + + if match: + # Try a bit harder to check for brace initialization. This +@@ -4124,28 +4086,28 @@ def CheckBracesSpacing(filename, clean_l + # We also suppress warnings for `uint64_t{expression}` etc., as the style + # guide recommends brace initialization for integral types to avoid + # overflow/truncation. +- if (not Match(r'^[\s}]*[{.;,)<>\]:]', trailing_text) ++ if (not re.match(r'^[\s}]*[{.;,)<>\]:]', trailing_text) + and not _IsType(clean_lines, nesting_state, leading_text)): + error(filename, linenum, 'whitespace/braces', 5, + 'Missing space before {') + + # Make sure '} else {' has spaces. +- if Search(r'}else', line): ++ if re.search(r'}else', line): + error(filename, linenum, 'whitespace/braces', 5, + 'Missing space before else') + + # You shouldn't have a space before a semicolon at the end of the line. + # There's a special case for "for" since the style guide allows space before + # the semicolon there. +- if Search(r':\s*;\s*$', line): ++ if re.search(r':\s*;\s*$', line): + error(filename, linenum, 'whitespace/semicolon', 5, + 'Semicolon defining empty statement. Use {} instead.') +- elif Search(r'^\s*;\s*$', line): ++ elif re.search(r'^\s*;\s*$', line): + error(filename, linenum, 'whitespace/semicolon', 5, + 'Line contains only semicolon. If this should be an empty statement, ' + 'use {} instead.') +- elif (Search(r'\s+;\s*$', line) and +- not Search(r'\bfor\b', line)): ++ elif (re.search(r'\s+;\s*$', line) and ++ not re.search(r'\bfor\b', line)): + error(filename, linenum, 'whitespace/semicolon', 5, + 'Extra space before last semicolon. If this should be an empty ' + 'statement, use {} instead.') +@@ -4164,7 +4126,7 @@ def IsDecltype(clean_lines, linenum, col + (text, _, start_col) = ReverseCloseExpression(clean_lines, linenum, column) + if start_col < 0: + return False +- if Search(r'\bdecltype\s*$', text[0:start_col]): ++ if re.search(r'\bdecltype\s*$', text[0:start_col]): + return True + return False + +@@ -4195,7 +4157,7 @@ def CheckSectionSpacing(filename, clean_ + linenum <= class_info.starting_linenum): + return + +- matched = Match(r'\s*(public|protected|private):', clean_lines.lines[linenum]) ++ matched = re.match(r'\s*(public|protected|private):', clean_lines.lines[linenum]) + if matched: + # Issue warning if the line before public/protected/private was + # not a blank line, but don't do this if the previous line contains +@@ -4207,15 +4169,15 @@ def CheckSectionSpacing(filename, clean_ + # common when defining classes in C macros. + prev_line = clean_lines.lines[linenum - 1] + if (not IsBlankLine(prev_line) and +- not Search(r'\b(class|struct)\b', prev_line) and +- not Search(r'\\$', prev_line)): ++ not re.search(r'\b(class|struct)\b', prev_line) and ++ not re.search(r'\\$', prev_line)): + # Try a bit harder to find the beginning of the class. This is to + # account for multi-line base-specifier lists, e.g.: + # class Derived + # : public Base { + end_class_head = class_info.starting_linenum + for i in range(class_info.starting_linenum, linenum): +- if Search(r'\{\s*$', clean_lines.lines[i]): ++ if re.search(r'\{\s*$', clean_lines.lines[i]): + end_class_head = i + break + if end_class_head < linenum - 1: +@@ -4258,7 +4220,7 @@ def CheckBraces(filename, clean_lines, l + + line = clean_lines.elided[linenum] # get rid of comments and strings + +- if Match(r'\s*{\s*$', line): ++ if re.match(r'\s*{\s*$', line): + # We allow an open brace to start a line in the case where someone is using + # braces in a block to explicitly create a new scope, which is commonly used + # to control the lifetime of stack-allocated variables. Braces are also +@@ -4269,23 +4231,23 @@ def CheckBraces(filename, clean_lines, l + # following line if it is part of an array initialization and would not fit + # within the 80 character limit of the preceding line. + prevline = GetPreviousNonBlankLine(clean_lines, linenum)[0] +- if (not Search(r'[,;:}{(]\s*$', prevline) and +- not Match(r'\s*#', prevline) and ++ if (not re.search(r'[,;:}{(]\s*$', prevline) and ++ not re.match(r'\s*#', prevline) and + not (GetLineWidth(prevline) > _line_length - 2 and '[]' in prevline)): + error(filename, linenum, 'whitespace/braces', 4, + '{ should almost always be at the end of the previous line') + + # An else clause should be on the same line as the preceding closing brace. +- if Match(r'\s*else\b\s*(?:if\b|\{|$)', line): ++ if re.match(r'\s*else\b\s*(?:if\b|\{|$)', line): + prevline = GetPreviousNonBlankLine(clean_lines, linenum)[0] +- if Match(r'\s*}\s*$', prevline): ++ if re.match(r'\s*}\s*$', prevline): + error(filename, linenum, 'whitespace/newline', 4, + 'An else should appear on the same line as the preceding }') + + # If braces come on one side of an else, they should be on both. + # However, we have to worry about "else if" that spans multiple lines! +- if Search(r'else if\s*\(', line): # could be multi-line if +- brace_on_left = bool(Search(r'}\s*else if\s*\(', line)) ++ if re.search(r'else if\s*\(', line): # could be multi-line if ++ brace_on_left = bool(re.search(r'}\s*else if\s*\(', line)) + # find the ( after the if + pos = line.find('else if') + pos = line.find('(', pos) +@@ -4295,17 +4257,17 @@ def CheckBraces(filename, clean_lines, l + if brace_on_left != brace_on_right: # must be brace after if + error(filename, linenum, 'readability/braces', 5, + 'If an else has a brace on one side, it should have it on both') +- elif Search(r'}\s*else[^{]*$', line) or Match(r'[^}]*else\s*{', line): ++ elif re.search(r'}\s*else[^{]*$', line) or re.match(r'[^}]*else\s*{', line): + error(filename, linenum, 'readability/braces', 5, + 'If an else has a brace on one side, it should have it on both') + + # Likewise, an else should never have the else clause on the same line +- if Search(r'\belse [^\s{]', line) and not Search(r'\belse if\b', line): ++ if re.search(r'\belse [^\s{]', line) and not re.search(r'\belse if\b', line): + error(filename, linenum, 'whitespace/newline', 4, + 'Else clause should never be on same line as else (use 2 lines)') + + # In the same way, a do/while should never be on one line +- if Match(r'\s*do [^\s{]', line): ++ if re.match(r'\s*do [^\s{]', line): + error(filename, linenum, 'whitespace/newline', 4, + 'do/while clauses should not be on a single line') + +@@ -4316,21 +4278,21 @@ def CheckBraces(filename, clean_lines, l + # its line, and the line after that should have an indent level equal to or + # lower than the if. We also check for ambiguous if/else nesting without + # braces. +- if_else_match = Search(r'\b(if\s*(|constexpr)\s*\(|else\b)', line) +- if if_else_match and not Match(r'\s*#', line): ++ if_else_match = re.search(r'\b(if\s*(|constexpr)\s*\(|else\b)', line) ++ if if_else_match and not re.match(r'\s*#', line): + if_indent = GetIndentLevel(line) + endline, endlinenum, endpos = line, linenum, if_else_match.end() +- if_match = Search(r'\bif\s*(|constexpr)\s*\(', line) ++ if_match = re.search(r'\bif\s*(|constexpr)\s*\(', line) + if if_match: + # This could be a multiline if condition, so find the end first. + pos = if_match.end() - 1 + (endline, endlinenum, endpos) = CloseExpression(clean_lines, linenum, pos) + # Check for an opening brace, either directly after the if or on the next + # line. If found, this isn't a single-statement conditional. +- if (not Match(r'\s*{', endline[endpos:]) +- and not (Match(r'\s*$', endline[endpos:]) ++ if (not re.match(r'\s*{', endline[endpos:]) ++ and not (re.match(r'\s*$', endline[endpos:]) + and endlinenum < (len(clean_lines.elided) - 1) +- and Match(r'\s*{', clean_lines.elided[endlinenum + 1]))): ++ and re.match(r'\s*{', clean_lines.elided[endlinenum + 1]))): + while (endlinenum < len(clean_lines.elided) + and ';' not in clean_lines.elided[endlinenum][endpos:]): + endlinenum += 1 +@@ -4340,11 +4302,11 @@ def CheckBraces(filename, clean_lines, l + # We allow a mix of whitespace and closing braces (e.g. for one-liner + # methods) and a single \ after the semicolon (for macros) + endpos = endline.find(';') +- if not Match(r';[\s}]*(\\?)$', endline[endpos:]): ++ if not re.match(r';[\s}]*(\\?)$', endline[endpos:]): + # Semicolon isn't the last character, there's something trailing. + # Output a warning if the semicolon is not contained inside + # a lambda expression. +- if not Match(r'^[^{};]*\[[^\[\]]*\][^{}]*\{[^{}]*\}\s*\)*[;,]\s*$', ++ if not re.match(r'^[^{};]*\[[^\[\]]*\][^{}]*\{[^{}]*\}\s*\)*[;,]\s*$', + endline): + error(filename, linenum, 'readability/braces', 4, + 'If/else bodies with multiple statements require braces') +@@ -4355,7 +4317,7 @@ def CheckBraces(filename, clean_lines, l + # With ambiguous nested if statements, this will error out on the + # if that *doesn't* match the else, regardless of whether it's the + # inner one or outer one. +- if (if_match and Match(r'\s*else\b', next_line) ++ if (if_match and re.match(r'\s*else\b', next_line) + and next_indent != if_indent): + error(filename, linenum, 'readability/braces', 4, + 'Else clause should be indented at the same level as if. ' +@@ -4421,7 +4383,7 @@ def CheckTrailingSemicolon(filename, cle + # to namespaces. For now we do not warn for this case. + # + # Try matching case 1 first. +- match = Match(r'^(.*\)\s*)\{', line) ++ match = re.match(r'^(.*\)\s*)\{', line) + if match: + # Matched closing parenthesis (case 1). Check the token before the + # matching opening parenthesis, and don't warn if it looks like a +@@ -4454,27 +4416,27 @@ def CheckTrailingSemicolon(filename, cle + clean_lines, linenum, closing_brace_pos) + if opening_parenthesis[2] > -1: + line_prefix = opening_parenthesis[0][0:opening_parenthesis[2]] +- macro = Search(r'\b([A-Z_][A-Z0-9_]*)\s*$', line_prefix) +- func = Match(r'^(.*\])\s*$', line_prefix) ++ macro = re.search(r'\b([A-Z_][A-Z0-9_]*)\s*$', line_prefix) ++ func = re.match(r'^(.*\])\s*$', line_prefix) + if ((macro and + macro.group(1) not in ( + 'TEST', 'TEST_F', 'MATCHER', 'MATCHER_P', 'TYPED_TEST', + 'EXCLUSIVE_LOCKS_REQUIRED', 'SHARED_LOCKS_REQUIRED', + 'LOCKS_EXCLUDED', 'INTERFACE_DEF')) or +- (func and not Search(r'\boperator\s*\[\s*\]', func.group(1))) or +- Search(r'\b(?:struct|union)\s+alignas\s*$', line_prefix) or +- Search(r'\bdecltype$', line_prefix) or +- Search(r'\s+=\s*$', line_prefix)): ++ (func and not re.search(r'\boperator\s*\[\s*\]', func.group(1))) or ++ re.search(r'\b(?:struct|union)\s+alignas\s*$', line_prefix) or ++ re.search(r'\bdecltype$', line_prefix) or ++ re.search(r'\s+=\s*$', line_prefix)): + match = None + if (match and + opening_parenthesis[1] > 1 and +- Search(r'\]\s*$', clean_lines.elided[opening_parenthesis[1] - 1])): ++ re.search(r'\]\s*$', clean_lines.elided[opening_parenthesis[1] - 1])): + # Multi-line lambda-expression + match = None + + else: + # Try matching cases 2-3. +- match = Match(r'^(.*(?:else|\)\s*const)\s*)\{', line) ++ match = re.match(r'^(.*(?:else|\)\s*const)\s*)\{', line) + if not match: + # Try matching cases 4-6. These are always matched on separate lines. + # +@@ -4485,14 +4447,14 @@ def CheckTrailingSemicolon(filename, cle + # // blank line + # } + prevline = GetPreviousNonBlankLine(clean_lines, linenum)[0] +- if prevline and Search(r'[;{}]\s*$', prevline): +- match = Match(r'^(\s*)\{', line) ++ if prevline and re.search(r'[;{}]\s*$', prevline): ++ match = re.match(r'^(\s*)\{', line) + + # Check matching closing brace + if match: + (endline, endlinenum, endpos) = CloseExpression( + clean_lines, linenum, len(match.group(1))) +- if endpos > -1 and Match(r'^\s*;', endline[endpos:]): ++ if endpos > -1 and re.match(r'^\s*;', endline[endpos:]): + # Current {} pair is eligible for semicolon check, and we have found + # the redundant semicolon, output warning here. + # +@@ -4529,7 +4491,7 @@ def CheckEmptyBlockBody(filename, clean_ + # We also check "if" blocks here, since an empty conditional block + # is likely an error. + line = clean_lines.elided[linenum] +- matched = Match(r'\s*(for|while|if)\s*\(', line) ++ matched = re.match(r'\s*(for|while|if)\s*\(', line) + if matched: + # Find the end of the conditional expression. + (end_line, end_linenum, end_pos) = CloseExpression( +@@ -4538,7 +4500,7 @@ def CheckEmptyBlockBody(filename, clean_ + # Output warning if what follows the condition expression is a semicolon. + # No warning for all other cases, including whitespace or newline, since we + # have a separate check for semicolons preceded by whitespace. +- if end_pos >= 0 and Match(r';', end_line[end_pos:]): ++ if end_pos >= 0 and re.match(r';', end_line[end_pos:]): + if matched.group(1) == 'if': + error(filename, end_linenum, 'whitespace/empty_conditional_body', 5, + 'Empty conditional bodies should use {}') +@@ -4554,8 +4516,8 @@ def CheckEmptyBlockBody(filename, clean_ + opening_linenum = end_linenum + opening_line_fragment = end_line[end_pos:] + # Loop until EOF or find anything that's not whitespace or opening {. +- while not Search(r'^\s*\{', opening_line_fragment): +- if Search(r'^(?!\s*$)', opening_line_fragment): ++ while not re.search(r'^\s*\{', opening_line_fragment): ++ if re.search(r'^(?!\s*$)', opening_line_fragment): + # Conditional has no brackets. + return + opening_linenum += 1 +@@ -4602,8 +4564,8 @@ def CheckEmptyBlockBody(filename, clean_ + current_linenum = closing_linenum + current_line_fragment = closing_line[closing_pos:] + # Loop until EOF or find anything that's not whitespace or else clause. +- while Search(r'^\s*$|^(?=\s*else)', current_line_fragment): +- if Search(r'^(?=\s*else)', current_line_fragment): ++ while re.search(r'^\s*$|^(?=\s*else)', current_line_fragment): ++ if re.search(r'^(?=\s*else)', current_line_fragment): + # Found an else clause, so don't log an error. + return + current_linenum += 1 +@@ -4632,7 +4594,7 @@ def FindCheckMacro(line): + # to make sure that we are matching the expected CHECK macro, as + # opposed to some other macro that happens to contain the CHECK + # substring. +- matched = Match(r'^(.*\b' + macro + r'\s*)\(', line) ++ matched = re.match(r'^(.*\b' + macro + r'\s*)\(', line) + if not matched: + continue + return (macro, len(matched.group(1))) +@@ -4664,7 +4626,7 @@ def CheckCheck(filename, clean_lines, li + # If the check macro is followed by something other than a + # semicolon, assume users will log their own custom error messages + # and don't suggest any replacements. +- if not Match(r'\s*;', last_line[end_pos:]): ++ if not re.match(r'\s*;', last_line[end_pos:]): + return + + if linenum == end_line: +@@ -4682,7 +4644,7 @@ def CheckCheck(filename, clean_lines, li + rhs = '' + operator = None + while expression: +- matched = Match(r'^\s*(<<|<<=|>>|>>=|->\*|->|&&|\|\||' ++ matched = re.match(r'^\s*(<<|<<=|>>|>>=|->\*|->|&&|\|\||' + r'==|!=|>=|>|<=|<|\()(.*)$', expression) + if matched: + token = matched.group(1) +@@ -4716,9 +4678,9 @@ def CheckCheck(filename, clean_lines, li + # characters at once if possible. Trivial benchmark shows that this + # is more efficient when the operands are longer than a single + # character, which is generally the case. +- matched = Match(r'^([^-=!<>()&|]+)(.*)$', expression) ++ matched = re.match(r'^([^-=!<>()&|]+)(.*)$', expression) + if not matched: +- matched = Match(r'^(\s*\S)(.*)$', expression) ++ matched = re.match(r'^(\s*\S)(.*)$', expression) + if not matched: + break + lhs += matched.group(1) +@@ -4742,7 +4704,7 @@ def CheckCheck(filename, clean_lines, li + lhs = lhs.strip() + rhs = rhs.strip() + match_constant = r'^([-+]?(\d+|0[xX][0-9a-fA-F]+)[lLuU]{0,3}|".*"|\'.*\')$' +- if Match(match_constant, lhs) or Match(match_constant, rhs): ++ if re.match(match_constant, lhs) or re.match(match_constant, rhs): + # Note: since we know both lhs and rhs, we can provide a more + # descriptive error message like: + # Consider using CHECK_EQ(x, 42) instead of CHECK(x == 42) +@@ -4769,7 +4731,7 @@ def CheckAltTokens(filename, clean_lines + line = clean_lines.elided[linenum] + + # Avoid preprocessor lines +- if Match(r'^\s*#', line): ++ if re.match(r'^\s*#', line): + return + + # Last ditch effort to avoid multi-line comments. This will not help +@@ -4873,11 +4835,11 @@ def CheckStyle(filename, clean_lines, li + # We also don't check for lines that look like continuation lines + # (of lines ending in double quotes, commas, equals, or angle brackets) + # because the rules for how to indent those are non-trivial. +- if (not Search(r'[",=><] *$', prev) and ++ if (not re.search(r'[",=><] *$', prev) and + (initial_spaces == 1 or initial_spaces == 3) and +- not Match(scope_or_label_pattern, cleansed_line) and ++ not re.match(scope_or_label_pattern, cleansed_line) and + not (clean_lines.raw_lines[linenum] != line and +- Match(r'^\s*""', line))): ++ re.match(r'^\s*""', line))): + error(filename, linenum, 'whitespace/indent', 3, + 'Weird number of spaces at line-start. ' + 'Are you using a 2-space indent?') +@@ -4906,10 +4868,10 @@ def CheckStyle(filename, clean_lines, li + # Doxygen documentation copying can get pretty long when using an overloaded + # function declaration + if (not line.startswith('#include') and not is_header_guard and +- not Match(r'^\s*//.*http(s?)://\S*$', line) and +- not Match(r'^\s*//\s*[^\s]*$', line) and +- not Match(r'^// \$Id:.*#[0-9]+ \$$', line) and +- not Match(r'^\s*/// [@\\](copydoc|copydetails|copybrief) .*$', line)): ++ not re.match(r'^\s*//.*http(s?)://\S*$', line) and ++ not re.match(r'^\s*//\s*[^\s]*$', line) and ++ not re.match(r'^// \$Id:.*#[0-9]+ \$$', line) and ++ not re.match(r'^\s*/// [@\\](copydoc|copydetails|copybrief) .*$', line)): + line_width = GetLineWidth(line) + if line_width > _line_length: + error(filename, linenum, 'whitespace/line_length', 2, +@@ -4917,7 +4879,7 @@ def CheckStyle(filename, clean_lines, li + + if (cleansed_line.count(';') > 1 and + # allow simple single line lambdas +- not Match(r'^[^{};]*\[[^\[\]]*\][^{}]*\{[^{}\n\r]*\}', ++ not re.match(r'^[^{};]*\[[^\[\]]*\][^{}]*\{[^{}\n\r]*\}', + line) and + # for loops are allowed two ;'s (and may run over two lines). + cleansed_line.find('for') == -1 and +@@ -5020,7 +4982,7 @@ def _ClassifyInclude(fileinfo, include, + # Mark include as C header if in list or in a known folder for standard-ish C headers. + is_std_c_header = (include_order == "default") or (include in _C_HEADERS + # additional linux glibc header folders +- or Search(r'(?:%s)\/.*\.h' % "|".join(C_STANDARD_HEADER_FOLDERS), include)) ++ or re.search(r'(?:%s)\/.*\.h' % "|".join(C_STANDARD_HEADER_FOLDERS), include)) + + # Headers with C++ extensions shouldn't be considered C system headers + include_ext = os.path.splitext(include)[1] +@@ -5086,7 +5048,7 @@ def CheckIncludeLine(filename, clean_lin + # + # We also make an exception for Lua headers, which follow google + # naming convention but not the include convention. +- match = Match(r'#include\s*"([^/]+\.(.*))"', line) ++ match = re.match(r'#include\s*"([^/]+\.(.*))"', line) + if match: + if (IsHeaderExtension(match.group(2)) and + not _THIRD_PARTY_HEADERS_PATTERN.match(match.group(1))): +@@ -5270,7 +5232,7 @@ def CheckLanguage(filename, clean_lines, + + # Reset include state across preprocessor directives. This is meant + # to silence warnings for conditional includes. +- match = Match(r'^\s*#\s*(if|ifdef|ifndef|elif|else|endif)\b', line) ++ match = re.match(r'^\s*#\s*(if|ifdef|ifndef|elif|else|endif)\b', line) + if match: + include_state.ResetSection(match.group(1)) + +@@ -5290,12 +5252,12 @@ def CheckLanguage(filename, clean_lines, + + # Check if people are using the verboten C basic types. The only exception + # we regularly allow is "unsigned short port" for port. +- if Search(r'\bshort port\b', line): +- if not Search(r'\bunsigned short port\b', line): ++ if re.search(r'\bshort port\b', line): ++ if not re.search(r'\bunsigned short port\b', line): + error(filename, linenum, 'runtime/int', 4, + 'Use "unsigned short" for ports, not "short"') + else: +- match = Search(r'\b(short|long(?! +double)|long long)\b', line) ++ match = re.search(r'\b(short|long(?! +double)|long long)\b', line) + if match: + error(filename, linenum, 'runtime/int', 4, + 'Use int16/int64/etc, rather than the C type %s' % match.group(1)) +@@ -5306,13 +5268,13 @@ def CheckLanguage(filename, clean_lines, + # int operator&(const X& x) { return 42; } // unary operator& + # The trick is it's hard to tell apart from binary operator&: + # class Y { int operator&(const Y& x) { return 23; } }; // binary operator& +- if Search(r'\boperator\s*&\s*\(\s*\)', line): ++ if re.search(r'\boperator\s*&\s*\(\s*\)', line): + error(filename, linenum, 'runtime/operator', 4, + 'Unary operator& is dangerous. Do not use it.') + + # Check for suspicious usage of "if" like + # } if (a == b) { +- if Search(r'\}\s*if\s*\(', line): ++ if re.search(r'\}\s*if\s*\(', line): + error(filename, linenum, 'readability/braces', 4, + 'Did you mean "else if"? If not, start a new line for "if".') + +@@ -5325,7 +5287,7 @@ def CheckLanguage(filename, clean_lines, + # boy_this_is_a_really_long_variable_that_cannot_fit_on_the_prev_line); + printf_args = _GetTextInside(line, r'(?i)\b(string)?printf\s*\(') + if printf_args: +- match = Match(r'([\w.\->()]+)$', printf_args) ++ match = re.match(r'([\w.\->()]+)$', printf_args) + if match and match.group(1) != '__VA_ARGS__': + function_name = re.search(r'\b((?:string)?printf)\s*\(', + line, re.I).group(1) +@@ -5334,14 +5296,14 @@ def CheckLanguage(filename, clean_lines, + % (function_name, match.group(1))) + + # Check for potential memset bugs like memset(buf, sizeof(buf), 0). +- match = Search(r'memset\s*\(([^,]*),\s*([^,]*),\s*0\s*\)', line) +- if match and not Match(r"^''|-?[0-9]+|0x[0-9A-Fa-f]$", match.group(2)): ++ match = re.search(r'memset\s*\(([^,]*),\s*([^,]*),\s*0\s*\)', line) ++ if match and not re.match(r"^''|-?[0-9]+|0x[0-9A-Fa-f]$", match.group(2)): + error(filename, linenum, 'runtime/memset', 4, + 'Did you mean "memset(%s, 0, %s)"?' + % (match.group(1), match.group(2))) + +- if Search(r'\busing namespace\b', line): +- if Search(r'\bliterals\b', line): ++ if re.search(r'\busing namespace\b', line): ++ if re.search(r'\bliterals\b', line): + error(filename, linenum, 'build/namespaces_literals', 5, + 'Do not use namespace using-directives. ' + 'Use using-declarations instead.') +@@ -5351,7 +5313,7 @@ def CheckLanguage(filename, clean_lines, + 'Use using-declarations instead.') + + # Detect variable-length arrays. +- match = Match(r'\s*(.+::)?(\w+) [a-z]\w*\[(.+)];', line) ++ match = re.match(r'\s*(.+::)?(\w+) [a-z]\w*\[(.+)];', line) + if (match and match.group(2) != 'return' and match.group(2) != 'delete' and + match.group(3).find(']') == -1): + # Split the size using space and arithmetic operators as delimiters. +@@ -5365,17 +5327,17 @@ def CheckLanguage(filename, clean_lines, + skip_next = False + continue + +- if Search(r'sizeof\(.+\)', tok): continue +- if Search(r'arraysize\(\w+\)', tok): continue ++ if re.search(r'sizeof\(.+\)', tok): continue ++ if re.search(r'arraysize\(\w+\)', tok): continue + + tok = tok.lstrip('(') + tok = tok.rstrip(')') + if not tok: continue +- if Match(r'\d+', tok): continue +- if Match(r'0[xX][0-9a-fA-F]+', tok): continue +- if Match(r'k[A-Z0-9]\w*', tok): continue +- if Match(r'(.+::)?k[A-Z0-9]\w*', tok): continue +- if Match(r'(.+::)?[A-Z][A-Z0-9_]*', tok): continue ++ if re.match(r'\d+', tok): continue ++ if re.match(r'0[xX][0-9a-fA-F]+', tok): continue ++ if re.match(r'k[A-Z0-9]\w*', tok): continue ++ if re.match(r'(.+::)?k[A-Z0-9]\w*', tok): continue ++ if re.match(r'(.+::)?[A-Z][A-Z0-9_]*', tok): continue + # A catch all for tricky sizeof cases, including 'sizeof expression', + # 'sizeof(*type)', 'sizeof(const type)', 'sizeof(struct StructName)' + # requires skipping the next token because we split on ' ' and '*'. +@@ -5393,7 +5355,7 @@ def CheckLanguage(filename, clean_lines, + # macros are typically OK, so we allow use of "namespace {" on lines + # that end with backslashes. + if (IsHeaderExtension(file_extension) +- and Search(r'\bnamespace\s*{', line) ++ and re.search(r'\bnamespace\s*{', line) + and line[-1] != '\\'): + error(filename, linenum, 'build/namespaces_headers', 4, + 'Do not use unnamed namespaces in header files. See ' +@@ -5413,7 +5375,7 @@ def CheckGlobalStatic(filename, clean_li + line = clean_lines.elided[linenum] + + # Match two lines at a time to support multiline declarations +- if linenum + 1 < clean_lines.NumLines() and not Search(r'[;({]', line): ++ if linenum + 1 < clean_lines.NumLines() and not re.search(r'[;({]', line): + line += clean_lines.elided[linenum + 1].strip() + + # Check for people declaring static/global STL strings at the top level. +@@ -5422,7 +5384,7 @@ def CheckGlobalStatic(filename, clean_li + # also because globals can be destroyed when some threads are still running. + # TODO(unknown): Generalize this to also find static unique_ptr instances. + # TODO(unknown): File bugs for clang-tidy to find these. +- match = Match( ++ match = re.match( + r'((?:|static +)(?:|const +))(?::*std::)?string( +const)? +' + r'([a-zA-Z0-9_:]+)\b(.*)', + line) +@@ -5444,10 +5406,10 @@ def CheckGlobalStatic(filename, clean_li + # matching identifiers. + # string Class::operator*() + if (match and +- not Search(r'\bstring\b(\s+const)?\s*[\*\&]\s*(const\s+)?\w', line) and +- not Search(r'\boperator\W', line) and +- not Match(r'\s*(<.*>)?(::[a-zA-Z0-9_]+)*\s*\(([^"]|$)', match.group(4))): +- if Search(r'\bconst\b', line): ++ not re.search(r'\bstring\b(\s+const)?\s*[\*\&]\s*(const\s+)?\w', line) and ++ not re.search(r'\boperator\W', line) and ++ not re.match(r'\s*(<.*>)?(::[a-zA-Z0-9_]+)*\s*\(([^"]|$)', match.group(4))): ++ if re.search(r'\bconst\b', line): + error(filename, linenum, 'runtime/string', 4, + 'For a static/global string constant, use a C style string ' + 'instead: "%schar%s %s[]".' % +@@ -5456,8 +5418,8 @@ def CheckGlobalStatic(filename, clean_li + error(filename, linenum, 'runtime/string', 4, + 'Static/global string variables are not permitted.') + +- if (Search(r'\b([A-Za-z0-9_]*_)\(\1\)', line) or +- Search(r'\b([A-Za-z0-9_]*_)\(CHECK_NOTNULL\(\1\)\)', line)): ++ if (re.search(r'\b([A-Za-z0-9_]*_)\(\1\)', line) or ++ re.search(r'\b([A-Za-z0-9_]*_)\(CHECK_NOTNULL\(\1\)\)', line)): + error(filename, linenum, 'runtime/init', 4, + 'You seem to be initializing a member variable with itself.') + +@@ -5474,7 +5436,7 @@ def CheckPrintf(filename, clean_lines, l + line = clean_lines.elided[linenum] + + # When snprintf is used, the second argument shouldn't be a literal. +- match = Search(r'snprintf\s*\(([^,]*),\s*([0-9]*)\s*,', line) ++ match = re.search(r'snprintf\s*\(([^,]*),\s*([0-9]*)\s*,', line) + if match and match.group(2) != '0': + # If 2nd arg is zero, snprintf is used to calculate size. + error(filename, linenum, 'runtime/printf', 3, +@@ -5482,10 +5444,10 @@ def CheckPrintf(filename, clean_lines, l + 'to snprintf.' % (match.group(1), match.group(2))) + + # Check if some verboten C functions are being used. +- if Search(r'\bsprintf\s*\(', line): ++ if re.search(r'\bsprintf\s*\(', line): + error(filename, linenum, 'runtime/printf', 5, + 'Never use sprintf. Use snprintf instead.') +- match = Search(r'\b(strcpy|strcat)\s*\(', line) ++ match = re.search(r'\b(strcpy|strcat)\s*\(', line) + if match: + error(filename, linenum, 'runtime/printf', 4, + 'Almost always, snprintf is better than %s' % match.group(1)) +@@ -5503,13 +5465,13 @@ def IsDerivedFunction(clean_lines, linen + """ + # Scan back a few lines for start of current function + for i in xrange(linenum, max(-1, linenum - 10), -1): +- match = Match(r'^([^()]*\w+)\(', clean_lines.elided[i]) ++ match = re.match(r'^([^()]*\w+)\(', clean_lines.elided[i]) + if match: + # Look for "override" after the matching closing parenthesis + line, _, closing_paren = CloseExpression( + clean_lines, i, len(match.group(1))) + return (closing_paren >= 0 and +- Search(r'\boverride\b', line[closing_paren:])) ++ re.search(r'\boverride\b', line[closing_paren:])) + return False + + +@@ -5524,8 +5486,8 @@ def IsOutOfLineMethodDefinition(clean_li + """ + # Scan back a few lines for start of current function + for i in xrange(linenum, max(-1, linenum - 10), -1): +- if Match(r'^([^()]*\w+)\(', clean_lines.elided[i]): +- return Match(r'^[^()]*\w+::\w+\(', clean_lines.elided[i]) is not None ++ if re.match(r'^([^()]*\w+)\(', clean_lines.elided[i]): ++ return re.match(r'^[^()]*\w+::\w+\(', clean_lines.elided[i]) is not None + return False + + +@@ -5542,21 +5504,21 @@ def IsInitializerList(clean_lines, linen + for i in xrange(linenum, 1, -1): + line = clean_lines.elided[i] + if i == linenum: +- remove_function_body = Match(r'^(.*)\{\s*$', line) ++ remove_function_body = re.match(r'^(.*)\{\s*$', line) + if remove_function_body: + line = remove_function_body.group(1) + +- if Search(r'\s:\s*\w+[({]', line): ++ if re.search(r'\s:\s*\w+[({]', line): + # A lone colon tend to indicate the start of a constructor + # initializer list. It could also be a ternary operator, which + # also tend to appear in constructor initializer lists as + # opposed to parameter lists. + return True +- if Search(r'\}\s*,\s*$', line): ++ if re.search(r'\}\s*,\s*$', line): + # A closing brace followed by a comma is probably the end of a + # brace-initialized member in constructor initializer list. + return True +- if Search(r'[{};]\s*$', line): ++ if re.search(r'[{};]\s*$', line): + # Found one of the following: + # - A closing brace or semicolon, probably the end of the previous + # function. +@@ -5620,13 +5582,13 @@ def CheckForNonConstReference(filename, + # that spans more than 2 lines, please use a typedef. + if linenum > 1: + previous = None +- if Match(r'\s*::(?:[\w<>]|::)+\s*&\s*\S', line): ++ if re.match(r'\s*::(?:[\w<>]|::)+\s*&\s*\S', line): + # previous_line\n + ::current_line +- previous = Search(r'\b((?:const\s*)?(?:[\w<>]|::)+[\w<>])\s*$', ++ previous = re.search(r'\b((?:const\s*)?(?:[\w<>]|::)+[\w<>])\s*$', + clean_lines.elided[linenum - 1]) +- elif Match(r'\s*[a-zA-Z_]([\w<>]|::)+\s*&\s*\S', line): ++ elif re.match(r'\s*[a-zA-Z_]([\w<>]|::)+\s*&\s*\S', line): + # previous_line::\n + current_line +- previous = Search(r'\b((?:const\s*)?(?:[\w<>]|::)+::)\s*$', ++ previous = re.search(r'\b((?:const\s*)?(?:[\w<>]|::)+::)\s*$', + clean_lines.elided[linenum - 1]) + if previous: + line = previous.group(1) + line.lstrip() +@@ -5666,13 +5628,13 @@ def CheckForNonConstReference(filename, + if linenum > 0: + for i in xrange(linenum - 1, max(0, linenum - 10), -1): + previous_line = clean_lines.elided[i] +- if not Search(r'[),]\s*$', previous_line): ++ if not re.search(r'[),]\s*$', previous_line): + break +- if Match(r'^\s*:\s+\S', previous_line): ++ if re.match(r'^\s*:\s+\S', previous_line): + return + + # Avoid preprocessors +- if Search(r'\\\s*$', line): ++ if re.search(r'\\\s*$', line): + return + + # Avoid constructor initializer lists +@@ -5689,25 +5651,25 @@ def CheckForNonConstReference(filename, + r'operator\s*[<>][<>]|' + r'static_assert|COMPILE_ASSERT' + r')\s*\(') +- if Search(allowed_functions, line): ++ if re.search(allowed_functions, line): + return +- elif not Search(r'\S+\([^)]*$', line): ++ elif not re.search(r'\S+\([^)]*$', line): + # Don't see an allowed function on this line. Actually we + # didn't see any function name on this line, so this is likely a + # multi-line parameter list. Try a bit harder to catch this case. + for i in xrange(2): + if (linenum > i and +- Search(allowed_functions, clean_lines.elided[linenum - i - 1])): ++ re.search(allowed_functions, clean_lines.elided[linenum - i - 1])): + return + +- decls = ReplaceAll(r'{[^}]*}', ' ', line) # exclude function body ++ decls = re.sub(r'{[^}]*}', ' ', line) # exclude function body + for parameter in re.findall(_RE_PATTERN_REF_PARAM, decls): +- if (not Match(_RE_PATTERN_CONST_REF_PARAM, parameter) and +- not Match(_RE_PATTERN_REF_STREAM_PARAM, parameter)): ++ if (not re.match(_RE_PATTERN_CONST_REF_PARAM, parameter) and ++ not re.match(_RE_PATTERN_REF_STREAM_PARAM, parameter)): + error(filename, linenum, 'runtime/references', 2, + 'Is this a non-const reference? ' + 'If so, make const or use a pointer: ' + +- ReplaceAll(' *<', '<', parameter)) ++ re.sub(' *<', '<', parameter)) + + + def CheckCasts(filename, clean_lines, linenum, error): +@@ -5725,7 +5687,7 @@ def CheckCasts(filename, clean_lines, li + # I just try to capture the most common basic types, though there are more. + # Parameterless conversion functions, such as bool(), are allowed as they are + # probably a member operator declaration or default constructor. +- match = Search( ++ match = re.search( + r'(\bnew\s+(?:const\s+)?|\S<\s*(?:const\s+)?)?\b' + r'(int|float|double|bool|char|int32|uint32|int64|uint64)' + r'(\([^)].*)', line) +@@ -5749,7 +5711,7 @@ def CheckCasts(filename, clean_lines, li + + # Avoid arrays by looking for brackets that come after the closing + # parenthesis. +- if Match(r'\([^()]+\)\s*\[', match.group(3)): ++ if re.match(r'\([^()]+\)\s*\[', match.group(3)): + return + + # Other things to ignore: +@@ -5760,11 +5722,11 @@ def CheckCasts(filename, clean_lines, li + matched_funcptr = match.group(3) + if (matched_new_or_template is None and + not (matched_funcptr and +- (Match(r'\((?:[^() ]+::\s*\*\s*)?[^() ]+\)\s*\(', ++ (re.match(r'\((?:[^() ]+::\s*\*\s*)?[^() ]+\)\s*\(', + matched_funcptr) or + matched_funcptr.startswith('(*)'))) and +- not Match(r'\s*using\s+\S+\s*=\s*' + matched_type, line) and +- not Search(r'new\(\S+\)\s*' + matched_type, line)): ++ not re.match(r'\s*using\s+\S+\s*=\s*' + matched_type, line) and ++ not re.search(r'new\(\S+\)\s*' + matched_type, line)): + error(filename, linenum, 'readability/casting', 4, + 'Using deprecated casting style. ' + 'Use static_cast<%s>(...) instead' % +@@ -5797,7 +5759,7 @@ def CheckCasts(filename, clean_lines, li + # + # This is not a cast: + # reference_type&(int* function_param); +- match = Search( ++ match = re.search( + r'(?:[^\w]&\(([^)*][^)]*)\)[\w(])|' + r'(?:[^\w]&(static|dynamic|down|reinterpret)_cast\b)', line) + if match: +@@ -5805,7 +5767,7 @@ def CheckCasts(filename, clean_lines, li + # dereferenced by the casted pointer, as opposed to the casted + # pointer itself. + parenthesis_error = False +- match = Match(r'^(.*&(?:static|dynamic|down|reinterpret)_cast\b)<', line) ++ match = re.match(r'^(.*&(?:static|dynamic|down|reinterpret)_cast\b)<', line) + if match: + _, y1, x1 = CloseExpression(clean_lines, linenum, len(match.group(1))) + if x1 >= 0 and clean_lines.elided[y1][x1] == '(': +@@ -5814,7 +5776,7 @@ def CheckCasts(filename, clean_lines, li + extended_line = clean_lines.elided[y2][x2:] + if y2 < clean_lines.NumLines() - 1: + extended_line += clean_lines.elided[y2 + 1] +- if Match(r'\s*(?:->|\[)', extended_line): ++ if re.match(r'\s*(?:->|\[)', extended_line): + parenthesis_error = True + + if parenthesis_error: +@@ -5846,13 +5808,13 @@ def CheckCStyleCast(filename, clean_line + False otherwise. + """ + line = clean_lines.elided[linenum] +- match = Search(pattern, line) ++ match = re.search(pattern, line) + if not match: + return False + + # Exclude lines with keywords that tend to look like casts + context = line[0:match.start(1) - 1] +- if Match(r'.*\b(?:sizeof|alignof|alignas|[_A-Z][_A-Z0-9]*)\s*$', context): ++ if re.match(r'.*\b(?:sizeof|alignof|alignas|[_A-Z][_A-Z0-9]*)\s*$', context): + return False + + # Try expanding current context to see if we one level of +@@ -5860,7 +5822,7 @@ def CheckCStyleCast(filename, clean_line + if linenum > 0: + for i in xrange(linenum - 1, max(0, linenum - 5), -1): + context = clean_lines.elided[i] + context +- if Match(r'.*\b[_A-Z][_A-Z0-9]*\s*\((?:\([^()]*\)|[^()])*$', context): ++ if re.match(r'.*\b[_A-Z][_A-Z0-9]*\s*\((?:\([^()]*\)|[^()])*$', context): + return False + + # operator++(int) and operator--(int) +@@ -5871,7 +5833,7 @@ def CheckCStyleCast(filename, clean_line + # A single unnamed argument for a function tends to look like old style cast. + # If we see those, don't issue warnings for deprecated casts. + remainder = line[match.end(0):] +- if Match(r'^\s*(?:;|const\b|throw\b|final\b|override\b|[=>{),]|->)', ++ if re.match(r'^\s*(?:;|const\b|throw\b|final\b|override\b|[=>{),]|->)', + remainder): + return False + +@@ -5895,13 +5857,13 @@ def ExpectingFunctionArgs(clean_lines, l + of function types. + """ + line = clean_lines.elided[linenum] +- return (Match(r'^\s*MOCK_(CONST_)?METHOD\d+(_T)?\(', line) or ++ return (re.match(r'^\s*MOCK_(CONST_)?METHOD\d+(_T)?\(', line) or + (linenum >= 2 and +- (Match(r'^\s*MOCK_(?:CONST_)?METHOD\d+(?:_T)?\((?:\S+,)?\s*$', ++ (re.match(r'^\s*MOCK_(?:CONST_)?METHOD\d+(?:_T)?\((?:\S+,)?\s*$', + clean_lines.elided[linenum - 1]) or +- Match(r'^\s*MOCK_(?:CONST_)?METHOD\d+(?:_T)?\(\s*$', ++ re.match(r'^\s*MOCK_(?:CONST_)?METHOD\d+(?:_T)?\(\s*$', + clean_lines.elided[linenum - 2]) or +- Search(r'\bstd::m?function\s*\<\s*$', ++ re.search(r'\bstd::m?function\s*\<\s*$', + clean_lines.elided[linenum - 1])))) + + +@@ -6023,7 +5985,7 @@ def FilesBelongToSameModule(filename_cc, + return (False, '') + + filename_cc = filename_cc[:-(len(fileinfo_cc.Extension()))] +- matched_test_suffix = Search(_TEST_FILE_SUFFIX, fileinfo_cc.BaseName()) ++ matched_test_suffix = re.search(_TEST_FILE_SUFFIX, fileinfo_cc.BaseName()) + if matched_test_suffix: + filename_cc = filename_cc[:-len(matched_test_suffix.group(1))] + +@@ -6207,20 +6169,20 @@ def CheckRedundantVirtual(filename, clea + """ + # Look for "virtual" on current line. + line = clean_lines.elided[linenum] +- virtual = Match(r'^(.*)(\bvirtual\b)(.*)$', line) ++ virtual = re.match(r'^(.*)(\bvirtual\b)(.*)$', line) + if not virtual: return + + # Ignore "virtual" keywords that are near access-specifiers. These + # are only used in class base-specifier and do not apply to member + # functions. +- if (Search(r'\b(public|protected|private)\s+$', virtual.group(1)) or +- Match(r'^\s+(public|protected|private)\b', virtual.group(3))): ++ if (re.search(r'\b(public|protected|private)\s+$', virtual.group(1)) or ++ re.match(r'^\s+(public|protected|private)\b', virtual.group(3))): + return + + # Ignore the "virtual" keyword from virtual base classes. Usually + # there is a column on the same line in these cases (virtual base + # classes are rare in google3 because multiple inheritance is rare). +- if Match(r'^.*[^:]:[^:].*$', line): return ++ if re.match(r'^.*[^:]:[^:].*$', line): return + + # Look for the next opening parenthesis. This is the start of the + # parameter list (possibly on the next line shortly after virtual). +@@ -6232,7 +6194,7 @@ def CheckRedundantVirtual(filename, clea + start_col = len(virtual.group(2)) + for start_line in xrange(linenum, min(linenum + 3, clean_lines.NumLines())): + line = clean_lines.elided[start_line][start_col:] +- parameter_list = Match(r'^([^(]*)\(', line) ++ parameter_list = re.match(r'^([^(]*)\(', line) + if parameter_list: + # Match parentheses to find the end of the parameter list + (_, end_line, end_col) = CloseExpression( +@@ -6247,7 +6209,7 @@ def CheckRedundantVirtual(filename, clea + # (possibly on the next few lines). + for i in xrange(end_line, min(end_line + 3, clean_lines.NumLines())): + line = clean_lines.elided[i][end_col:] +- match = Search(r'\b(override|final)\b', line) ++ match = re.search(r'\b(override|final)\b', line) + if match: + error(filename, linenum, 'readability/inheritance', 4, + ('"virtual" is redundant since function is ' +@@ -6256,7 +6218,7 @@ def CheckRedundantVirtual(filename, clea + # Set end_col to check whole lines after we are done with the + # first line. + end_col = 0 +- if Search(r'[^\w]\s*$', line): ++ if re.search(r'[^\w]\s*$', line): + break + + +@@ -6283,7 +6245,7 @@ def CheckRedundantOverrideOrFinal(filena + return + + # Check that at most one of "override" or "final" is present, not both +- if Search(r'\boverride\b', fragment) and Search(r'\bfinal\b', fragment): ++ if re.search(r'\boverride\b', fragment) and re.search(r'\bfinal\b', fragment): + error(filename, linenum, 'readability/inheritance', 4, + ('"override" is redundant since function is ' + 'already declared as "final"')) +@@ -6348,7 +6310,7 @@ def ShouldCheckNamespaceIndentation(nest + def CheckItemIndentationInNamespace(filename, raw_lines_no_comments, linenum, + error): + line = raw_lines_no_comments[linenum] +- if Match(r'^\s+', line): ++ if re.match(r'^\s+', line): + error(filename, linenum, 'runtime/indentation_namespace', 4, + 'Do not indent within a namespace') + +@@ -6409,7 +6371,7 @@ def FlagCxx11Features(filename, clean_li + """ + line = clean_lines.elided[linenum] + +- include = Match(r'\s*#\s*include\s+[<"]([^<"]+)[">]', line) ++ include = re.match(r'\s*#\s*include\s+[<"]([^<"]+)[">]', line) + + # Flag unapproved C++ TR1 headers. + if include and include.group(1).startswith('tr1/'): +@@ -6433,7 +6395,7 @@ def FlagCxx11Features(filename, clean_li + + # The only place where we need to worry about C++11 keywords and library + # features in preprocessor directives is in macro definitions. +- if Match(r'\s*#', line) and not Match(r'\s*#\s*define\b', line): return ++ if re.match(r'\s*#', line) and not re.match(r'\s*#\s*define\b', line): return + + # These are classes and free functions. The classes are always + # mentioned as std::*, but we only catch the free functions if +@@ -6443,7 +6405,7 @@ def FlagCxx11Features(filename, clean_li + 'alignment_of', + 'aligned_union', + ): +- if Search(r'\bstd::%s\b' % top_name, line): ++ if re.search(r'\bstd::%s\b' % top_name, line): + error(filename, linenum, 'build/c++11', 5, + ('std::%s is an unapproved C++11 class or function. Send c-style ' + 'an example of where it would make your code more readable, and ' +@@ -6461,7 +6423,7 @@ def FlagCxx14Features(filename, clean_li + """ + line = clean_lines.elided[linenum] + +- include = Match(r'\s*#\s*include\s+[<"]([^<"]+)[">]', line) ++ include = re.match(r'\s*#\s*include\s+[<"]([^<"]+)[">]', line) + + # Flag unapproved C++14 headers. + if include and include.group(1) in ('scoped_allocator', 'shared_mutex'): diff --git a/python-cpplint.changes b/python-cpplint.changes index 08788ca..287c8f1 100644 --- a/python-cpplint.changes +++ b/python-cpplint.changes @@ -1,3 +1,23 @@ +------------------------------------------------------------------- +Mon Apr 10 12:03:48 UTC 2023 - Daniel Garcia + +- Add drop-sre-compile.patch upstream patch to fix issues with + deprecated usage of sre_compile gh#cpplint/cpplint#214 +- Update to 1.6.1 + * Fix #195 Fix post increment/decrement operator causing a false positive. + * Fix #202 .hh files should not be considered sytem headers + * Fix #207 Python2 incompatibility for loading CPPLINT.cfg file + * Fix #184 NOLINT(clang-analyzer) comments should not cause warnings +- 1.6.0 (2022-02-19) + * Fix #188: "Include the directory when naming header files" also + for header files with other names like "*.hpp" +- 1.5.5 (2021-05-20) + * Fix #172: Added 'size_t' to typecasts detected by CheckCStyleCast + * Fixed wrong CLI help text: Each filter needs + or - + * Fix #164: add elif as an exception for CheckSpacingForFunctionCall() + * Fix google#346: --root option not working on windows due to + slashes in path + ------------------------------------------------------------------- Mon Aug 31 06:47:40 UTC 2020 - Steve Kowalik diff --git a/python-cpplint.spec b/python-cpplint.spec index aced712..1ad8846 100644 --- a/python-cpplint.spec +++ b/python-cpplint.spec @@ -1,7 +1,7 @@ # # spec file for package python-cpplint # -# Copyright (c) 2020 SUSE LLC +# Copyright (c) 2023 SUSE LLC # # All modifications and additions to the file contributed by third parties # remain the property of their copyright owners, unless otherwise agreed @@ -16,21 +16,22 @@ # -%{?!python_module:%define python_module() python-%{**} python3-%{**}} Name: python-cpplint -Version: 1.5.4 +Version: 1.6.1 Release: 0 Summary: An automated checker to make sure a C++ file follows Google's C++ style guide License: BSD-3-Clause URL: https://github.com/cpplint/cpplint Source: https://files.pythonhosted.org/packages/source/c/cpplint/cpplint-%{version}.tar.gz +# PATCH-FIX-UPSTREAM drop-sre-compile.patch gh#cpplint/cpplint#214 +Patch0: drop-sre-compile.patch BuildRequires: %{python_module pytest} BuildRequires: %{python_module setuptools} BuildRequires: %{python_module testfixtures} BuildRequires: fdupes BuildRequires: python-rpm-macros Requires(post): update-alternatives -Requires(postun): update-alternatives +Requires(postun):update-alternatives BuildArch: noarch %python_subpackages @@ -42,9 +43,9 @@ fork of google/styleguide (https://github.com/google/styleguide) in hopes that it can be merged in the future. %prep -%setup -q -n cpplint-%{version} +%autosetup -p1 -n cpplint-%{version} sed -i -e '/^#!\//, 1d' cpplint.py -sed -i 's/pytest-runner//' setup.py +sed -i 's/pytest-runner==5.2//' setup.py sed -i 's/pytest-cov//' test-requirements sed -i 's/--cov-fail-under=75 --cov=cpplint//' setup.cfg @@ -69,6 +70,7 @@ sed -i 's/--cov-fail-under=75 --cov=cpplint//' setup.cfg %license LICENSE %doc README.rst %python_alternative %{_bindir}/cpplint -%{python_sitelib}/* +%{python_sitelib}/cpplint* +%pycache_only %{python_sitelib}/__pycache__ %changelog