import codecs

import copy

import getopt

import glob

import itertools

import math # for log

import os

import re

import sre_compile

import string

import sys

import sysconfig

import unicodedata

import xml.etree.ElementTree

_valid_extensions = set([])

__VERSION__ = '1.4.4'

try:

xrange # Python 2

except NameError:

# -- pylint: disable=redefined-builtin

xrange = range # Python 3

_USAGE = """

_ERROR_CATEGORIES = [

]

_LEGACY_ERROR_CATEGORIES = [

'readability/streams',

'readability/function',

]

_DEFAULT_FILTERS = ['-build/include_alpha']

_DEFAULT_C_SUPPRESSED_CATEGORIES = [

'readability/casting',

]

_DEFAULT_KERNEL_SUPPRESSED_CATEGORIES = [

'whitespace/tab',

]

_CPP_HEADERS = frozenset([

])

_TYPES = re.compile(

r')$')

_THIRD_PARTY_HEADERS_PATTERN = re.compile(

r'^(?:[^/]*[A-Z][^/]*\.h|lua\.h|lauxlib\.h|lualib\.h)$')

_test_suffixes = ['_test', '_regtest', '_unittest']

_TEST_FILE_SUFFIX = '(' + '|'.join(_test_suffixes) + r')$'

_EMPTY_CONDITIONAL_BODY_PATTERN = re.compile(r'^\s*$', re.DOTALL)

_CHECK_MACROS = [

]

_CHECK_REPLACEMENT = dict([(macro_var, {}) for macro_var in _CHECK_MACROS])

for op, replacement in [('==', 'EQ'), ('!=', 'NE'),

('>=', 'GE'), ('>', 'GT'),

('<=', 'LE'), ('<', 'LT')]:

_CHECK_REPLACEMENT['DCHECK'][op] = 'DCHECK_%s' % replacement

_CHECK_REPLACEMENT['CHECK'][op] = 'CHECK_%s' % replacement

_CHECK_REPLACEMENT['EXPECT_TRUE'][op] = 'EXPECT_%s' % replacement

_CHECK_REPLACEMENT['ASSERT_TRUE'][op] = 'ASSERT_%s' % replacement

for op, inv_replacement in [('==', 'NE'), ('!=', 'EQ'),

('>=', 'LT'), ('>', 'LE'),

('<=', 'GT'), ('<', 'GE')]:

_CHECK_REPLACEMENT['EXPECT_FALSE'][op] = 'EXPECT_%s' % inv_replacement

_CHECK_REPLACEMENT['ASSERT_FALSE'][op] = 'ASSERT_%s' % inv_replacement

_ALT_TOKEN_REPLACEMENT = {

}

_ALT_TOKEN_REPLACEMENT_PATTERN = re.compile(

r'[ =()](' + ('|'.join(_ALT_TOKEN_REPLACEMENT.keys())) + r')(?=[ (]|$)')

_C_SYS_HEADER = 1

_CPP_SYS_HEADER = 2

_LIKELY_MY_HEADER = 3

_POSSIBLE_MY_HEADER = 4

_OTHER_HEADER = 5

_NO_ASM = 0 # Outside of inline assembly block

_INSIDE_ASM = 1 # Inside inline assembly block

_END_ASM = 2 # Last line of inline assembly block

_BLOCK_ASM = 3 # The whole block is an inline assembly block

_MATCH_ASM = re.compile(r'^\s*(?:asm|_asm|__asm|__asm__)'

r'(?:\s+(volatile|__volatile__))?'

r'\s*[{(]')

_SEARCH_C_FILE = re.compile(r'\b(?:LINT_C_FILE|'

r'vim?:\s*.*(\s*|:)filetype=c(\s*|:|$))')

_SEARCH_KERNEL_FILE = re.compile(r'\b(?:LINT_KERNEL_FILE)')

_NULL_TOKEN_PATTERN = re.compile(r'\bNULL\b')

_V8_PERSISTENT_PATTERN = re.compile(r'\bv8::Persistent\b')

_RIGHT_LEANING_POINTER_PATTERN = re.compile(r'[^=|(,\s><);&?:}]'

r'(?<!(sizeof|return))'

r'\s\*[a-zA-Z_][0-9a-zA-Z_]*')

_regexp_compile_cache = {}

_error_suppressions = {}

_root = None

_root_debug = False

_repository = None

_excludes = None

_quiet = False

_line_length = 80

try:

unicode

except NameError:

# -- pylint: disable=redefined-builtin

basestring = unicode = str

try:

long

except NameError:

# -- pylint: disable=redefined-builtin

long = int

if sys.version_info < (3,):

# -- pylint: disable=no-member

# BINARY_TYPE = str

itervalues = dict.itervalues

iteritems = dict.iteritems

else:

# BINARY_TYPE = bytes

itervalues = dict.values

iteritems = dict.items

def unicode_escape_decode(x):

return x

_hpp_headers = set(['h', 'hh', 'hpp', 'hxx', 'h++', 'cuh'])

_global_error_suppressions = {}

def ProcessHppHeadersOption(val):

PrintUsage('Header extensions must be comma separated list.')

def IsHeaderExtension(file_extension):

return file_extension in _hpp_headers

def GetHeaderExtensions():

return _hpp_headers or ['h']

def GetAllExtensions():

if not _valid_extensions:

return GetHeaderExtensions().union(set(['c', 'cc', 'cpp', 'cxx', 'c++', 'cu']))

return _valid_extensions

def GetNonHeaderExtensions():

return GetAllExtensions().difference(GetHeaderExtensions())

def ParseNolintSuppressions(filename, raw_line, linenum, error):

'Unknown NOLINT error category: %s' % category)

def ProcessGlobalSuppresions(lines):

_global_error_suppressions[category] = True

def ResetNolintSuppressions():

"""Resets the set of NOLINT suppressions to empty."""

_error_suppressions.clear()

_global_error_suppressions.clear()

def IsErrorSuppressedByNolint(category, linenum):

linenum in _error_suppressions.get(None, set()))

def Match(pattern, s):

return _regexp_compile_cache[pattern].match(s)

def ReplaceAll(pattern, rep, s):

return _regexp_compile_cache[pattern].sub(rep, s)

def Search(pattern, s):

return _regexp_compile_cache[pattern].search(s)

def _IsSourceExtension(s):

"""File extension (excluding dot) matches a source file extension."""

return s in GetNonHeaderExtensions()

class _IncludeState(object):