import codecs

import copy

import getopt

import logging

import math # for log

import os

import re

import sre_compile

import string

import sys

import unicodedata

logger = logging.getLogger('testrunner')

_USAGE = """

_ERROR_CATEGORIES = [

]

_LEGACY_ERROR_CATEGORIES = [

'readability/streams',

'readability/function',

]

_DEFAULT_FILTERS = [

]

_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_FILE_SUFFIX = r'(_test|_unittest|_regtest)$'

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

_CHECK_MACROS = [

]

_CHECK_REPLACEMENT = dict([(m, {}) for m 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')

_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

_line_length = 80

_valid_extensions = set(['cc', 'h', 'cpp', 'cu', 'cuh'])

_global_error_suppressions = {}

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 ('c', 'cc', 'cpp', 'cxx')

class _IncludeState(object):

return ''

class _CppLintState(object):

sys.stderr.write('Total errors found: %d\n' % self.error_count)

_cpplint_state = _CppLintState()

def _OutputFormat():

"""Gets the module's output format."""

return _cpplint_state.output_format

def _SetOutputFormat(output_format):

"""Sets the module's output format."""

_cpplint_state.SetOutputFormat(output_format)

def _VerboseLevel():

"""Returns the module's verbosity setting."""

return _cpplint_state.verbose_level

def _SetVerboseLevel(level):

"""Sets the module's verbosity, and returns the previous setting."""

return _cpplint_state.SetVerboseLevel(level)

def _SetCountingStyle(level):

"""Sets the module's counting options."""

_cpplint_state.SetCountingStyle(level)

def _Filters():

"""Returns the module's list of output filters, as a list."""

return _cpplint_state.filters

def _SetFilters(filters):

_cpplint_state.SetFilters(filters)

def _AddFilters(filters):

_cpplint_state.AddFilters(filters)

def _BackupFilters():

""" Saves the current filter list to backup storage."""

_cpplint_state.BackupFilters()

def _RestoreFilters():

""" Restores filters previously backed up."""

_cpplint_state.RestoreFilters()

class _FunctionState(object):