import codecs

import copy

import getopt

import glob

import itertools

import math # for log

import os

import re

import string

import sys

import sysconfig

import unicodedata

import xml.etree.ElementTree

_valid_extensions = set([])

__VERSION__ = '1.6.1'

try:

srecompile = re._compiler.compile

except AttributeError:

import sre_compile

srecompile = sre_compile.compile

try:

# -- pylint: disable=used-before-assignment

xrange # Python 2

except NameError:

# -- pylint: disable=redefined-builtin

xrange = range # Python 3

_USAGE = """

_ERROR_CATEGORIES = [

]

_MACHINE_OUTPUTS = [

]

_LEGACY_ERROR_CATEGORIES = [

'readability/streams',

'readability/function',

]

_OTHER_NOLINT_CATEGORY_PREFIXES = [

'clang-analyzer',

]

_DEFAULT_FILTERS = ['-build/include_alpha']

_DEFAULT_C_SUPPRESSED_CATEGORIES = [

'readability/casting',

]

_DEFAULT_KERNEL_SUPPRESSED_CATEGORIES = [

'whitespace/tab',

]

_CPP_HEADERS = frozenset([

])

_C_HEADERS = frozenset([

])

C_STANDARD_HEADER_FOLDERS = 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

_OTHER_SYS_HEADER = 3

_LIKELY_MY_HEADER = 4

_POSSIBLE_MY_HEADER = 5

_OTHER_HEADER = 6

_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)')

_SED_FIXUPS = {

}

_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

_include_order = "default"

try:

# -- pylint: disable=used-before-assignment

unicode

except NameError:

# -- pylint: disable=redefined-builtin

basestring = unicode = str

try:

# -- pylint: disable=used-before-assignment

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([])

_global_error_suppressions = {}

def ProcessHppHeadersOption(val):

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

def ProcessIncludeOrderOption(val):

PrintUsage('Invalid includeorder value %s. Expected default|standardcfirst')

def IsHeaderExtension(file_extension):

return file_extension in GetHeaderExtensions()

def GetHeaderExtensions():

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

def GetAllExtensions():

return GetHeaderExtensions().union(_valid_extensions or set(

['c', 'cc', 'cpp', 'cxx', 'c++', 'cu']))

def ProcessExtensionsOption(val):