#!/usr/bin/python2.4

#

# Copyright (c) 2009 Google Inc. All rights reserved.

#

# Redistribution and use in source and binary forms, with or without

# modification, are permitted provided that the following conditions are

# met:

#

# * Redistributions of source code must retain the above copyright

# notice, this list of conditions and the following disclaimer.

# * Redistributions in binary form must reproduce the above

# copyright notice, this list of conditions and the following disclaimer

# in the documentation and/or other materials provided with the

# distribution.

# * Neither the name of Google Inc. nor the names of its

# contributors may be used to endorse or promote products derived from

# this software without specific prior written permission.

#

# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

# Here are some issues that I've had people identify in my code during reviews,

# that I think are possible to flag automatically in a lint tool. If these were

# caught by lint, it would save time both for myself and that of my reviewers.

# Most likely, some of these are beyond the scope of the current lint framework,

# but I think it is valuable to retain these wish-list items even if they cannot

# be immediately implemented.

#

# Suggestions

# -----------

# - Check for no 'explicit' for multi-arg ctor

# - Check for boolean assign RHS in parens

# - Check for ctor initializer-list colon position and spacing

# - Check that if there's a ctor, there should be a dtor

# - Check accessors that return non-pointer member variables are

# declared const

# - Check accessors that return non-const pointer member vars are

# *not* declared const

# - Check for using public includes for testing

# - Check for spaces between brackets in one-line inline method

# - Check for no assert()

# - Check for spaces surrounding operators

# - Check for 0 in pointer context (should be NULL)

# - Check for 0 in char context (should be '\0')

# - Check for camel-case method name conventions for methods

# that are not simple inline getters and setters

# - Check that base classes have virtual destructors

# put " // namespace" after } that closes a namespace, with

# namespace's name after 'namespace' if it is named.

# - Do not indent namespace contents

# - Avoid inlining non-trivial constructors in header files

# include base/basictypes.h if DISALLOW_EVIL_CONSTRUCTORS is used

# - Check for old-school (void) cast for call-sites of functions

# ignored return value

# - Check gUnit usage of anonymous namespace

# - Check for class declaration order (typedefs, consts, enums,

# ctor(s?), dtor, friend declarations, methods, member vars)

#

"""Does google-lint on c++ files.

The goal of this script is to identify places in the code that *may*

be in non-compliance with google style. It does not attempt to fix

up these problems -- the point is to educate. It does also not

attempt to find all problems, or to ensure that everything it does

find is legitimately a problem.

In particular, we can get very confused by /* and // inside strings!

We do a small hack, which is to ignore //'s with "'s after them on the

same line, but it is far from perfect (in either direction).

"""

import codecs

import getopt

import math # for log

import os

import re

import sre_compile

import string

import sys

import unicodedata

_USAGE = """

"""

# We categorize each error message we print. Here are the categories.

# We want an explicit list so we can list them all in cpplint --filter=.

# If you add a new error message with a new category, add it to the list

# here! cpplint_unittest.py should tell you if you forget to do this.

# \ used for clearer layout -- pylint: disable-msg=C6013

_ERROR_CATEGORIES = [

]

# The default state of the category filter. This is overrided by the --filter=

# flag. By default all errors are on, so only add here categories that should be

# off by default (i.e., categories that must be enabled by the --filter= flags).

# All entries here should start with a '-' or '+', as in the --filter= flag.

_DEFAULT_FILTERS = ['-build/include_alpha']

# We used to check for high-bit characters, but after much discussion we

# decided those were OK, as long as they were in UTF-8 and didn't represent

# hard-coded international strings, which belong in a separate i18n file.

# Headers that we consider STL headers.

_STL_HEADERS = frozenset([

])

# Non-STL C++ system headers.

_CPP_HEADERS = frozenset([

])

# Assertion macros. These are defined in base/logging.h and

# testing/base/gunit.h. Note that the _M versions need to come first

# for substring matching to work.

_CHECK_MACROS = [

]

# Replacement macros for CHECK/DCHECK/EXPECT_TRUE/EXPECT_FALSE

_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

_CHECK_REPLACEMENT['EXPECT_TRUE_M'][op] = 'EXPECT_%s_M' % replacement

_CHECK_REPLACEMENT['ASSERT_TRUE_M'][op] = 'ASSERT_%s_M' % 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

_CHECK_REPLACEMENT['EXPECT_FALSE_M'][op] = 'EXPECT_%s_M' % inv_replacement

_CHECK_REPLACEMENT['ASSERT_FALSE_M'][op] = 'ASSERT_%s_M' % inv_replacement

# These constants define types of headers for use with

# _IncludeState.CheckNextIncludeOrder().

_C_SYS_HEADER = 1

_CPP_SYS_HEADER = 2

_LIKELY_MY_HEADER = 3

_POSSIBLE_MY_HEADER = 4

_OTHER_HEADER = 5

_regexp_compile_cache = {}

# Finds occurrences of NOLINT or NOLINT(...).

_RE_SUPPRESSION = re.compile(r'\bNOLINT\b(\([^)]*\))?')

# {str, set(int)}: a map from error categories to sets of linenumbers

# on which those errors are expected and should be suppressed.

_error_suppressions = {}

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

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

def ResetNolintSuppressions():

"Resets the set of NOLINT suppressions to empty."

_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 Search(pattern, s):

return _regexp_compile_cache[pattern].search(s)

class _IncludeState(dict):

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)

class _FunctionState(object):

self.in_a_function = False

class _IncludeError(Exception):

"""Indicates a problem with the include order in a file."""

pass

class FileInfo:

return self.Extension()[1:] in ('c', 'cc', 'cpp', 'cxx')

def _ShouldPrintError(category, confidence, linenum):

return True

def Error(filename, linenum, category, confidence, message):

filename, linenum, message, category, confidence))

# Matches standard C++ escape esequences per 2.13.2.3 of the C++ standard.

_RE_PATTERN_CLEANSE_LINE_ESCAPES = re.compile(

r'\\([abfnrtv?"\\\']|\d+|x[0-9a-fA-F]+)')

# Matches strings. Escape codes should already be removed by ESCAPES.

_RE_PATTERN_CLEANSE_LINE_DOUBLE_QUOTES = re.compile(r'"[^"]*"')

# Matches characters. Escape codes should already be removed by ESCAPES.

_RE_PATTERN_CLEANSE_LINE_SINGLE_QUOTES = re.compile(r"'.'")

# Matches multi-line C++ comments.

# This RE is a little bit more complicated than one might expect, because we

# have to take care of space removals tools so we can handle comments inside

# statements better.

# The current rule is: We only clear spaces from both sides when we're at the

# end of the line. Otherwise, we try to remove spaces from the right side,

# if this doesn't work we try on left side but only if there's a non-character

# on the right.

_RE_PATTERN_CLEANSE_LINE_C_COMMENTS = re.compile(

/\*.*\*/)""", re.VERBOSE)

def IsCppString(line):

return ((line.count('"') - line.count(r'\"') - line.count("'\"'")) & 1) == 1

def FindNextMultiLineCommentStart(lines, lineix):

return len(lines)

def FindNextMultiLineCommentEnd(lines, lineix):

return len(lines)

def RemoveMultiLineCommentsFromRange(lines, begin, end):

lines[i] = '// dummy'

def RemoveMultiLineComments(filename, lines, error):

lineix = lineix_end + 1

def CleanseComments(line):

return _RE_PATTERN_CLEANSE_LINE_C_COMMENTS.sub('', line)

class CleansedLines(object):

return elided

def CloseExpression(clean_lines, linenum, pos):