Classes
class	_BlockInfo

class	_ClassInfo

class	_CppLintState

class	_FunctionState

class	_IncludeError

class	_IncludeState

class	_NamespaceInfo

class	_NestingState

class	_PreprocessorInfo

class	CleansedLines

class	FileInfo

Functions
def	_ClassifyInclude (fileinfo, include, is_system)

def	_DropCommonSuffixes (filename)

def	_Filters ()

def	_GetTextInside (text, start_pattern)

def	_IsTestFilename (filename)

def	_OutputFormat ()

def	_SetCountingStyle (level)

def	_SetFilters (filters)

def	_SetOutputFormat (output_format)

def	_SetVerboseLevel (level)

def	_ShouldPrintError (category, confidence, linenum)

def	_VerboseLevel ()

def	CheckAccess (filename, clean_lines, linenum, nesting_state, error)

def	CheckAltTokens (filename, clean_lines, linenum, error)

def	CheckBraces (filename, clean_lines, linenum, error)

def	CheckCheck (filename, clean_lines, linenum, error)

def	CheckComment (comment, filename, linenum, error)

def	CheckCStyleCast (filename, linenum, line, raw_line, cast_type, pattern, error)

def	CheckEmptyBlockBody (filename, clean_lines, linenum, error)

def	CheckForBadCharacters (filename, lines, error)

def	CheckForCopyright (filename, lines, error)

def	CheckForFunctionLengths (filename, clean_lines, linenum, function_state, error)

def	CheckForHeaderGuard (filename, lines, error)

def	CheckForIncludeWhatYouUse (filename, clean_lines, include_state, error, io=codecs)

def	CheckForMultilineCommentsAndStrings (filename, clean_lines, linenum, error)

def	CheckForNewlineAtEOF (filename, lines, error)

def	CheckForNonConstReference (filename, clean_lines, linenum, nesting_state, error)

def	CheckForNonStandardConstructs (filename, clean_lines, linenum, nesting_state, error)

def	CheckIncludeLine (filename, clean_lines, linenum, include_state, error)

def	CheckInvalidIncrement (filename, clean_lines, linenum, error)

def	CheckLanguage (filename, clean_lines, linenum, file_extension, include_state, nesting_state, error)

def	CheckMakePairUsesDeduction (filename, clean_lines, linenum, error)

def	CheckPosixThreading (filename, clean_lines, linenum, error)

def	CheckSectionSpacing (filename, clean_lines, class_info, linenum, error)

def	CheckSpacing (filename, clean_lines, linenum, nesting_state, error)

def	CheckSpacingForFunctionCall (filename, line, linenum, error)

def	CheckStyle (filename, clean_lines, linenum, file_extension, nesting_state, error)

def	CheckVlogArguments (filename, clean_lines, linenum, error)

def	CleanseComments (line)

def	CleanseRawStrings (raw_lines)

def	CloseExpression (clean_lines, linenum, pos)

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

def	FilesBelongToSameModule (filename_cc, filename_h)

def	FindEndOfExpressionInLine (line, startpos, depth, startchar, endchar)

def	FindNextMatchingAngleBracket (clean_lines, linenum, init_suffix)

def	FindNextMultiLineCommentEnd (lines, lineix)

def	FindNextMultiLineCommentStart (lines, lineix)

def	FindPreviousMatchingAngleBracket (clean_lines, linenum, init_prefix)

def	FindStartOfExpressionInLine (line, endpos, depth, startchar, endchar)

def	GetHeaderGuardCPPVariable (filename)

def	GetLineWidth (line)

def	GetPreviousNonBlankLine (clean_lines, linenum)

def	IsBlankLine (line)

def	IsCppString (line)

def	IsErrorSuppressedByNolint (category, linenum)

def	main ()

def	Match (pattern, s)

def	ParseArguments (args)

def	ParseNolintSuppressions (filename, raw_line, linenum, error)

def	PrintCategories ()

def	PrintUsage (message)

def	ProcessFile (filename, vlevel, extra_check_functions=[])

def	ProcessFileData (filename, file_extension, lines, error, extra_check_functions=[])

def	ProcessLine (filename, file_extension, clean_lines, line, include_state, function_state, nesting_state, error, extra_check_functions=[])

def	RemoveMultiLineComments (filename, lines, error)

def	RemoveMultiLineCommentsFromRange (lines, begin, end)

def	ReplaceAll (pattern, rep, s)

def	ResetNolintSuppressions ()

def	ReverseCloseExpression (clean_lines, linenum, pos)

def	Search (pattern, s)

def	UpdateIncludeState (filename, include_state, io=codecs)

Variables
dictionary	_ALT_TOKEN_REPLACEMENT

	_ALT_TOKEN_REPLACEMENT_PATTERN

int	_BLOCK_ASM = 3

int	_C_SYS_HEADER = 1

list	_CHECK_MACROS

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

	_CPP_HEADERS

int	_CPP_SYS_HEADER = 2

	_cpplint_state = _CppLintState()

list	_DEFAULT_FILTERS = ['-build/include_alpha']

int	_END_ASM = 2

list	_ERROR_CATEGORIES

dictionary	_error_suppressions = {}

tuple	_HEADERS_CONTAINING_TEMPLATES

int	_INSIDE_ASM = 1

int	_LIKELY_MY_HEADER = 3

int	_line_length = 80

	_MATCH_ASM

int	_NO_ASM = 0

int	_OTHER_HEADER = 5

int	_POSSIBLE_MY_HEADER = 4

	_RE_FIRST_COMPONENT = re.compile(r'^[^-_.]+')

list	_re_pattern_algorithm_header = []

	_RE_PATTERN_CLEANSE_LINE_C_COMMENTS

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

	_RE_PATTERN_CLEANSE_LINE_ESCAPES

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

tuple	_RE_PATTERN_CONST_REF_PARAM

	_RE_PATTERN_EXPLICIT_MAKEPAIR = re.compile(r'\bmake_pair\s*<')

string	_RE_PATTERN_IDENT = r'[_a-zA-Z]\w*'

	_RE_PATTERN_INCLUDE = re.compile(r'^\s#\sinclude\s([<"])([^>"])[>"].*$')

	_RE_PATTERN_INCLUDE_NEW_STYLE = re.compile(r'#include +"[^/]+\.h"')

	_RE_PATTERN_INVALID_INCREMENT

	_RE_PATTERN_REF_PARAM

	_RE_PATTERN_STRING = re.compile(r'\bstring\b')

list	_re_pattern_templates = []

	_RE_PATTERN_TODO = re.compile(r'^//(\s*)TODO($.+?$)?:?(\s\|$)?')

tuple	_RE_PATTERN_TYPE

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

dictionary	_regexp_compile_cache = {}

	_root = None

string	_USAGE

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

tuple	threading_list

Function Documentation

def cpplint._ClassifyInclude	(	fileinfo,
		include,
		is_system
	)

private

Figures out what kind of header 'include' is.

Args:
  fileinfo: The current file cpplint is running over. A FileInfo instance.
  include: The path to a #included file.
  is_system: True if the #include used <> rather than "".

Returns:
  One of the _XXX_HEADER constants.

For example:
  >>> _ClassifyInclude(FileInfo('foo/foo.cc'), 'stdio.h', True)
  _C_SYS_HEADER
  >>> _ClassifyInclude(FileInfo('foo/foo.cc'), 'string', True)
  _CPP_SYS_HEADER
  >>> _ClassifyInclude(FileInfo('foo/foo.cc'), 'foo/foo.h', False)
  _LIKELY_MY_HEADER
  >>> _ClassifyInclude(FileInfo('foo/foo_unknown_extension.cc'),
  ...                  'bar/foo_other_ext.h', False)
  _POSSIBLE_MY_HEADER
  >>> _ClassifyInclude(FileInfo('foo/foo.cc'), 'foo/bar.h', False)
  _OTHER_HEADER

Definition at line 3512 of file cpplint.py.

def cpplint._DropCommonSuffixes ( filename )

private

Drops common suffixes like _test.cc or -inl.h from filename.

For example:
  >>> _DropCommonSuffixes('foo/foo-inl.h')
  'foo/foo'
  >>> _DropCommonSuffixes('foo/bar/foo.cc')
  'foo/bar/foo'
  >>> _DropCommonSuffixes('foo/foo_internal.h')
  'foo/foo'
  >>> _DropCommonSuffixes('foo/foo_unusualinternal.h')
  'foo/foo_unusualinternal'

Args:
  filename: The input filename.

Returns:
  The filename with the common suffix removed.

Definition at line 3468 of file cpplint.py.

def cpplint._Filters ( )

private

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

Definition at line 784 of file cpplint.py.

def cpplint._GetTextInside	(	text,
		start_pattern
	)

private

Definition at line 3644 of file cpplint.py.

def cpplint._IsTestFilename ( filename )

private

Determines if the given filename has a suffix that identifies it as a test.

Args:
  filename: The input filename.

Returns:
  True if 'filename' looks like a test, False otherwise.

Definition at line 3495 of file cpplint.py.

def cpplint._OutputFormat ( )

private

Gets the module's output format.

Definition at line 759 of file cpplint.py.

def cpplint._SetCountingStyle ( level )

private

Sets the module's counting options.

Definition at line 779 of file cpplint.py.

def cpplint._SetFilters ( filters )

private

Sets the module's error-message filters.

These filters are applied when deciding whether to emit a given
error message.

Args:
  filters: A string of comma-separated filters (eg "whitespace/indent").
           Each filter should start with + or -; else we die.

Definition at line 789 of file cpplint.py.

def cpplint._SetOutputFormat ( output_format )

private

Sets the module's output format.

Definition at line 764 of file cpplint.py.

def cpplint._SetVerboseLevel ( level )

private

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

Definition at line 774 of file cpplint.py.

def cpplint._ShouldPrintError	(	category,
		confidence,
		linenum
	)

private

If confidence >= verbose, category passes filter and is not suppressed.

Definition at line 953 of file cpplint.py.

def cpplint._VerboseLevel ( )

private

Returns the module's verbosity setting.

Definition at line 769 of file cpplint.py.

def cpplint.CheckAccess	(	filename,
		clean_lines,
		linenum,
		nesting_state,
		error
	)

Checks for improper use of DISALLOW* macros.

Args:
  filename: The name of the current file.
  clean_lines: A CleansedLines instance containing the file.
  linenum: The number of the line to check.
  nesting_state: A _NestingState instance which maintains information about
                 the current stack of nested blocks being parsed.
  error: The function to call with any errors found.

Definition at line 2378 of file cpplint.py.

def cpplint.CheckAltTokens	(	filename,
		clean_lines,
		linenum,
		error
	)

Check alternative keywords being used in boolean expressions.

Args:
  filename: The name of the current file.
  clean_lines: A CleansedLines instance containing the file.
  linenum: The number of the line to check.
  error: The function to call with any errors found.

Definition at line 3297 of file cpplint.py.

def cpplint.CheckBraces	(	filename,
		clean_lines,
		linenum,
		error
	)

Looks for misplaced braces (e.g. at the end of line).

Args:
  filename: The name of the current file.
  clean_lines: A CleansedLines instance containing the file.
  linenum: The number of the line to check.
  error: The function to call with any errors found.

Definition at line 2961 of file cpplint.py.

def cpplint.CheckCheck	(	filename,
		clean_lines,
		linenum,
		error
	)

Checks the use of CHECK and EXPECT macros.

Args:
  filename: The name of the current file.
  clean_lines: A CleansedLines instance containing the file.
  linenum: The number of the line to check.
  error: The function to call with any errors found.

Definition at line 3170 of file cpplint.py.

def cpplint.CheckComment	(	comment,
		filename,
		linenum,
		error
	)

Checks for common mistakes in TODO comments.

Args:
  comment: The text of the comment from the line in question.
  filename: The name of the current file.
  linenum: The number of the line to check.
  error: The function to call with any errors found.

Definition at line 2349 of file cpplint.py.

def cpplint.CheckCStyleCast	(	filename,
		linenum,
		line,
		raw_line,
		cast_type,
		pattern,
		error
	)

Checks for a C-style cast by looking for the pattern.

Args:
  filename: The name of the current file.
  linenum: The number of the line to check.
  line: The line of code to check.
  raw_line: The raw line of code to check, with comments.
  cast_type: The string for the C++ cast to recommend.  This is either
    reinterpret_cast, static_cast, or const_cast, depending.
  pattern: The regular expression used to find C-style casts.
  error: The function to call with any errors found.

Returns:
  True if an error was emitted.
  False otherwise.

Definition at line 4140 of file cpplint.py.

def cpplint.CheckEmptyBlockBody	(	filename,
		clean_lines,
		linenum,
		error
	)

Look for empty loop/conditional body with only a single semicolon.

Args:
  filename: The name of the current file.
  clean_lines: A CleansedLines instance containing the file.
  linenum: The number of the line to check.
  error: The function to call with any errors found.

Definition at line 3135 of file cpplint.py.

def cpplint.CheckForBadCharacters	(	filename,
		lines,
		error
	)

Logs an error for each line containing bad characters.

Two kinds of bad characters:

1. Unicode replacement characters: These indicate that either the file
contained invalid UTF-8 (likely) or Unicode replacement characters (which
it shouldn't).  Note that it's possible for this to throw off line
numbering if the invalid UTF-8 occurred adjacent to a newline.

2. NUL bytes.  These are problematic for some tools.

Args:
  filename: The name of the current file.
  lines: An array of strings, each representing a line of the file.
  error: The function to call with any errors found.

Definition at line 1476 of file cpplint.py.

def cpplint.CheckForCopyright	(	filename,
		lines,
		error
	)

Logs an error if no Copyright message appears at the top of the file.

Definition at line 1364 of file cpplint.py.

def cpplint.CheckForFunctionLengths	(	filename,
		clean_lines,
		linenum,
		function_state,
		error
	)

Reports for long function bodies.

For an overview why this is done, see:
http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml#Write_Short_Functions

Uses a simplistic algorithm assuming other style guidelines
(especially spacing) are followed.
Only checks unindented functions, so class members are unchecked.
Trivial bodies are unchecked, so constructors with huge initializer lists
may be missed.
Blank/comment lines are not counted so as to avoid encouraging the removal
of vertical space and comments just to get through a lint check.
NOLINT *on the last line of a function* disables this check.

Args:
  filename: The name of the current file.
  clean_lines: A CleansedLines instance containing the file.
  linenum: The number of the line to check.
  function_state: Current function name and lines in body so far.
  error: The function to call with any errors found.

Definition at line 2277 of file cpplint.py.

def cpplint.CheckForHeaderGuard	(	filename,
		lines,
		error
	)

Checks that the file contains a header guard.

Logs an error if no #ifndef header guard is present.  For other
headers, checks that the full pathname is used.

Args:
  filename: The name of the C++ header file.
  lines: An array of strings, each representing a line of the file.
  error: The function to call with any errors found.

Definition at line 1401 of file cpplint.py.

def cpplint.CheckForIncludeWhatYouUse	(	filename,
		clean_lines,
		include_state,
		error,
		io = `codecs`
	)

Reports for missing stl includes.

This function will output warnings to make sure you are including the headers
necessary for the stl containers and functions that you use. We only give one
reason to include a header. For example, if you use both equal_to<> and
less<> in a .h file, only one (the latter in the file) of these will be
reported as a reason to include the <functional>.

Args:
  filename: The name of the current file.
  clean_lines: A CleansedLines instance containing the file.
  include_state: An _IncludeState instance.
  error: The function to call with any errors found.
  io: The IO factory to use to read the header file. Provided for unittest
      injection.

Definition at line 4376 of file cpplint.py.

def cpplint.CheckForMultilineCommentsAndStrings	(	filename,
		clean_lines,
		linenum,
		error
	)

Logs an error if we see /* ... */ or "..." that extend past one line.

/* ... */ comments are legit inside macros, for one line.
Otherwise, we prefer // comments, so it's ok to warn about the
other.  Likewise, it's ok for strings to extend across multiple
lines, as long as a line continuation character (backslash)
terminates each line. Although not currently prohibited by the C++
style guide, it's ugly and unnecessary. We don't do well with either
in this lint program, so we warn about both.

Args:
  filename: The name of the current file.
  clean_lines: A CleansedLines instance containing the file.
  linenum: The number of the line to check.
  error: The function to call with any errors found.

Definition at line 1519 of file cpplint.py.

def cpplint.CheckForNewlineAtEOF	(	filename,
		lines,
		error
	)

Logs an error if there is no newline char at the end of the file.

Args:
  filename: The name of the current file.
  lines: An array of strings, each representing a line of the file.
  error: The function to call with any errors found.

Definition at line 1501 of file cpplint.py.

def cpplint.CheckForNonConstReference	(	filename,
		clean_lines,
		linenum,
		nesting_state,
		error
	)

Check for non-const references.

Separate from CheckLanguage since it scans backwards from current
line, instead of scanning forward.

Args:
  filename: The name of the current file.
  clean_lines: A CleansedLines instance containing the file.
  linenum: The number of the line to check.
  nesting_state: A _NestingState instance which maintains information about
                 the current stack of nested blocks being parsed.
  error: The function to call with any errors found.

Definition at line 4027 of file cpplint.py.

def cpplint.CheckForNonStandardConstructs	(	filename,
		clean_lines,
		linenum,
		nesting_state,
		error
	)

Definition at line 2087 of file cpplint.py.

def cpplint.CheckIncludeLine	(	filename,
		clean_lines,
		linenum,
		include_state,
		error
	)

Check rules that are applicable to #include lines.

Strings on #include lines are NOT removed from elided line, to make
certain tasks easier. However, to prevent false positives, checks
applicable to #include lines in CheckLanguage must be put here.

Args:
  filename: The name of the current file.
  clean_lines: A CleansedLines instance containing the file.
  linenum: The number of the line to check.
  include_state: An _IncludeState instance in which the headers are inserted.
  error: The function to call with any errors found.

Definition at line 3572 of file cpplint.py.

def cpplint.CheckInvalidIncrement	(	filename,
		clean_lines,
		linenum,
		error
	)

Checks for invalid increment *count++.

For example following function:
void increment_counter(int* count) {
  *count++;
}
is invalid, because it effectively does count++, moving pointer, and should
be replaced with ++*count, (*count)++ or *count += 1.

Args:
  filename: The name of the current file.
  clean_lines: A CleansedLines instance containing the file.
  linenum: The number of the line to check.
  error: The function to call with any errors found.

Definition at line 1625 of file cpplint.py.

def cpplint.CheckLanguage	(	filename,
		clean_lines,
		linenum,
		file_extension,
		include_state,
		nesting_state,
		error
	)

Checks rules from the 'C++ language rules' section of cppguide.html.

Some of these rules are hard to test (function overloading, using
uint32 inappropriately), but we do the best we can.

Args:
  filename: The name of the current file.
  clean_lines: A CleansedLines instance containing the file.
  linenum: The number of the line to check.
  file_extension: The extension (without the dot) of the filename.
  include_state: An _IncludeState instance in which the headers are inserted.
  nesting_state: A _NestingState instance which maintains information about
                 the current stack of nested blocks being parsed.
  error: The function to call with any errors found.

Definition at line 3727 of file cpplint.py.

def cpplint.CheckMakePairUsesDeduction	(	filename,
		clean_lines,
		linenum,
		error
	)

Check that make_pair's template arguments are deduced.

G++ 4.6 in C++0x mode fails badly if make_pair's template arguments are
specified explicitly, and such use isn't intended in any case.

Args:
  filename: The name of the current file.
  clean_lines: A CleansedLines instance containing the file.
  linenum: The number of the line to check.
  error: The function to call with any errors found.

Definition at line 4471 of file cpplint.py.

def cpplint.CheckPosixThreading	(	filename,
		clean_lines,
		linenum,
		error
	)

Checks for calls to thread-unsafe functions.

Much code has been originally written without consideration of
multi-threading. Also, engineers are relying on their old experience;
they have learned posix before threading extensions were added. These
tests guide the engineers to use thread-safe functions (when using
posix directly).

Args:
  filename: The name of the current file.
  clean_lines: A CleansedLines instance containing the file.
  linenum: The number of the line to check.
  error: The function to call with any errors found.

Definition at line 1573 of file cpplint.py.

def cpplint.CheckSectionSpacing	(	filename,
		clean_lines,
		class_info,
		linenum,
		error
	)

Checks for additional blank line issues related to sections.

Currently the only thing checked here is blank line before protected/private.

Args:
  filename: The name of the current file.
  clean_lines: A CleansedLines instance containing the file.
  class_info: A _ClassInfo objects.
  linenum: The number of the line to check.
  error: The function to call with any errors found.

Definition at line 2883 of file cpplint.py.

def cpplint.CheckSpacing	(	filename,
		clean_lines,
		linenum,
		nesting_state,
		error
	)

Checks for the correctness of various spacing issues in the code.

Things we check for: spaces around operators, spaces after
if/for/while/switch, no spaces around parens in function calls, two
spaces between code and comment, don't start a block with a blank
line, don't end a function with a blank line, don't add a blank line
after public/protected/private, don't have too many blank lines in a row.

Args:
  filename: The name of the current file.
  clean_lines: A CleansedLines instance containing the file.
  linenum: The number of the line to check.
  nesting_state: A _NestingState instance which maintains information about
                 the current stack of nested blocks being parsed.
  error: The function to call with any errors found.

Definition at line 2535 of file cpplint.py.

def cpplint.CheckSpacingForFunctionCall	(	filename,
		line,
		linenum,
		error
	)

Checks for the correctness of various spacing around function calls.

Args:
  filename: The name of the current file.
  line: The text of the line to check.
  linenum: The number of the line to check.
  error: The function to call with any errors found.

Definition at line 2193 of file cpplint.py.

def cpplint.CheckStyle	(	filename,
		clean_lines,
		linenum,
		file_extension,
		nesting_state,
		error
	)

Checks rules from the 'C++ style rules' section of cppguide.html.

Most of these rules are hard to test (naming, comment style), but we
do what we can.  In particular we check for 2-space indents, line lengths,
tab usage, spaces inside code, etc.

Args:
  filename: The name of the current file.
  clean_lines: A CleansedLines instance containing the file.
  linenum: The number of the line to check.
  file_extension: The extension (without the dot) of the filename.
  nesting_state: A _NestingState instance which maintains information about
                 the current stack of nested blocks being parsed.
  error: The function to call with any errors found.

Definition at line 3352 of file cpplint.py.

def cpplint.CheckVlogArguments	(	filename,
		clean_lines,
		linenum,
		error
	)

Checks that VLOG() is only used for defining a logging level.

For example, VLOG(2) is correct. VLOG(INFO), VLOG(WARNING), VLOG(ERROR), and
VLOG(FATAL) are not.

Args:
  filename: The name of the current file.
  clean_lines: A CleansedLines instance containing the file.
  linenum: The number of the line to check.
  error: The function to call with any errors found.

Definition at line 1600 of file cpplint.py.

def cpplint.CleanseComments ( line )

Removes //-comments and single-line C-style /* */ comments.

Args:
  line: A line of C++ source.

Returns:
  The line with single-line comments removed.

Definition at line 1159 of file cpplint.py.

def cpplint.CleanseRawStrings ( raw_lines )

Removes C++11 raw strings from lines.

  Before:
    static const char kData[] = R"(
        multi-line string
        )";

  After:
    static const char kData[] = ""
        (replaced by blank line)
        "";

Args:
  raw_lines: list of raw lines.

Returns:
  list of lines with C++11 raw strings replaced by empty strings.

Definition at line 1054 of file cpplint.py.

def cpplint.CloseExpression	(	clean_lines,
		linenum,
		pos
	)

If input points to ( or { or [ or <, finds the position that closes it.

If lines[linenum][pos] points to a '(' or '{' or '[' or '<', finds the
linenum/pos that correspond to the closing of the expression.

Args:
  clean_lines: A CleansedLines instance containing the file.
  linenum: The number of the line to check.
  pos: A position on the line.

Returns:
  A tuple (line, linenum, pos) pointer *past* the closing brace, or
  (line, len(lines), -1) if we never find a close.  Note we ignore
  strings and comments when matching; and the line we return is the
  'cleansed' line at linenum.

Definition at line 1246 of file cpplint.py.

def cpplint.Error	(	filename,
		linenum,
		category,
		confidence,
		message
	)

Logs the fact we've found a lint error.

We log where the error was found, and also our confidence in the error,
that is, how certain we are this is a legitimate style regression, and
not a misidentification or a use that's sometimes justified.

False positives can be suppressed by the use of
"cpplint(category)"  comments on the offending line.  These are
parsed into _error_suppressions.

Args:
  filename: The name of the file containing the error.
  linenum: The number of the line containing the error.
  category: A string used to describe the "category" this bug
    falls under: "whitespace", say, or "runtime".  Categories
    may have a hierarchy separated by slashes: "whitespace/indent".
  confidence: A number from 1-5 representing a confidence score for
    the error, with 5 meaning that we are certain of the problem,
    and 1 meaning that it could be a legitimate construct.
  message: The error message.

Definition at line 980 of file cpplint.py.

def cpplint.FilesBelongToSameModule	(	filename_cc,
		filename_h
	)

Check if these two filenames belong to the same module.

The concept of a 'module' here is a as follows:
foo.h, foo-inl.h, foo.cc, foo_test.cc and foo_unittest.cc belong to the
same 'module' if they are in the same directory.
some/path/public/xyzzy and some/path/internal/xyzzy are also considered
to belong to the same module here.

If the filename_cc contains a longer path than the filename_h, for example,
'/absolute/path/to/base/sysinfo.cc', and this file would include
'base/sysinfo.h', this function also produces the prefix needed to open the
header. This is used by the caller of this function to more robustly open the
header file. We don't have access to the real include paths in this context,
so we need this guesswork here.

Known bugs: tools/base/bar.cc and base/bar.h belong to the same module
according to this implementation. Because of this, this function gives
some false positives. This should be sufficiently rare in practice.

Args:
  filename_cc: is the path for the .cc file
  filename_h: is the path for the header path

Returns:
  Tuple with a bool and a string:
  bool: True if filename_cc and filename_h belong to the same module.
  string: the additional prefix needed to open the header file.

Definition at line 4291 of file cpplint.py.

def cpplint.FindEndOfExpressionInLine	(	line,
		startpos,
		depth,
		startchar,
		endchar
	)

Find the position just after the matching endchar.

Args:
  line: a CleansedLines line.
  startpos: start searching at this position.
  depth: nesting level at startpos.
  startchar: expression opening character.
  endchar: expression closing character.

Returns:
  On finding matching endchar: (index just after matching endchar, 0)
  Otherwise: (-1, new depth at end of this line)

Definition at line 1222 of file cpplint.py.

def cpplint.FindNextMatchingAngleBracket	(	clean_lines,
		linenum,
		init_suffix
	)

Find the corresponding > to close a template.

Args:
  clean_lines: A CleansedLines instance containing the file.
  linenum: Current line number.
  init_suffix: Remainder of the current line after the initial <.

Returns:
  True if a matching bracket exists.

Definition at line 2409 of file cpplint.py.

def cpplint.FindNextMultiLineCommentEnd	(	lines,
		lineix
	)

We are inside a comment, find the end marker.

Definition at line 1126 of file cpplint.py.

def cpplint.FindNextMultiLineCommentStart	(	lines,
		lineix
	)

Find the beginning marker for a multiline comment.

Definition at line 1115 of file cpplint.py.

def cpplint.FindPreviousMatchingAngleBracket	(	clean_lines,
		linenum,
		init_prefix
	)

Find the corresponding < that started a template.

Args:
  clean_lines: A CleansedLines instance containing the file.
  linenum: Current line number.
  init_prefix: Part of the current line before the initial >.

Returns:
  True if a matching bracket exists.

Definition at line 2478 of file cpplint.py.

def cpplint.FindStartOfExpressionInLine	(	line,
		endpos,
		depth,
		startchar,
		endchar
	)

Find position at the matching startchar.

This is almost the reverse of FindEndOfExpressionInLine, but note
that the input position and returned position differs by 1.

Args:
  line: a CleansedLines line.
  endpos: start searching at this position.
  depth: nesting level at endpos.
  startchar: expression opening character.
  endchar: expression closing character.

Returns:
  On finding matching startchar: (index at matching startchar, 0)
  Otherwise: (-1, new depth at beginning of this line)

Definition at line 1292 of file cpplint.py.

def cpplint.GetHeaderGuardCPPVariable ( filename )

Returns the CPP variable that should be used as a header guard.

Args:
  filename: The name of a C++ header file.

Returns:
  The CPP variable that should be used as a header guard in the
  named file.

Definition at line 1377 of file cpplint.py.

def cpplint.GetLineWidth ( line )

Determines the width of the line in column positions.

Args:
  line: A string, which may be a Unicode string.

Returns:
  The width of the line in column positions, accounting for Unicode
  combining characters and wide characters.

Definition at line 3329 of file cpplint.py.

def cpplint.GetPreviousNonBlankLine	(	clean_lines,
		linenum
	)

Return the most recent non-blank line and its line number.

Args:
  clean_lines: A CleansedLines instance containing the file contents.
  linenum: The number of the line to check.

Returns:
  A tuple with two elements.  The first element is the contents of the last
  non-blank line before the current line, or the empty string if this is the
  first non-blank line.  The second is the line number of that line, or -1
  if this is the first non-blank line.

Definition at line 2938 of file cpplint.py.

def cpplint.IsBlankLine ( line )

Returns true if the given line is blank.

We consider a line to be blank if the line is empty or consists of
only white spaces.

Args:
  line: A line of a string.

Returns:
  True, if the given line is blank.

Definition at line 2261 of file cpplint.py.

def cpplint.IsCppString ( line )

Does line terminate so, that the next symbol is in string constant.

This function does not consider single-line nor multi-line comments.

Args:
  line: is a partial line of code starting from the 0..n.

Returns:
  True, if next character appended to 'line' is inside a
  string constant.

Definition at line 1037 of file cpplint.py.

def cpplint.IsErrorSuppressedByNolint	(	category,
		linenum
	)

Returns true if the specified error category is suppressed on this line.

Consults the global error_suppressions map populated by
ParseNolintSuppressions/ResetNolintSuppressions.

Args:
  category: str, the category of the error.
  linenum: int, the current line number.
Returns:
  bool, True iff the error should be suppressed due to a NOLINT comment.

Definition at line 492 of file cpplint.py.

def cpplint.main ( void )

Definition at line 4739 of file cpplint.py.

def cpplint.Match	(	pattern,
		s
	)

Matches the string with the pattern, caching the compiled regexp.

Definition at line 507 of file cpplint.py.

def cpplint.ParseArguments ( args )

Parses the command line arguments.

This may set the output format and verbosity level as side-effects.

Args:
  args: The command line arguments:

Returns:
  The list of filenames to lint.

Definition at line 4669 of file cpplint.py.

def cpplint.ParseNolintSuppressions	(	filename,
		raw_line,
		linenum,
		error
	)

Updates the global list of error-suppressions.

Parses any NOLINT comments on the current line, updating the global
error_suppressions store.  Reports an error if the NOLINT comment
was malformed.

Args:
  filename: str, the name of the input file.
  raw_line: str, the line of input text, with comments.
  linenum: int, the number of the current line.
  error: function, an error handler.

Definition at line 458 of file cpplint.py.

def cpplint.PrintCategories ( )

Prints a list of all the error-categories used by error messages.

These are the categories used to filter messages via --filter.

Definition at line 4660 of file cpplint.py.

def cpplint.PrintUsage ( message )

Prints a brief usage string and exits, optionally with an error message.

Args:
  message: The optional error message.

Definition at line 4647 of file cpplint.py.

def cpplint.ProcessFile	(	filename,
		vlevel,
		extra_check_functions = `[]`
	)

Does google-lint on a single file.

Args:
  filename: The name of the file to parse.

  vlevel: The level of errors to report.  Every error of confidence
  >= verbose_level will be reported.  0 is a good default.

  extra_check_functions: An array of additional check functions that will be
                         run on each source line. Each function takes 4
                         arguments: filename, clean_lines, line, error

Definition at line 4578 of file cpplint.py.

def cpplint.ProcessFileData	(	filename,
		file_extension,
		lines,
		error,
		extra_check_functions = `[]`
	)

Performs lint checks and reports any errors to the given error function.

Args:
  filename: Filename of the file that is being processed.
  file_extension: The extension (dot not included) of the file.
  lines: An array of strings, each representing a line of the file, with the
         last element being empty if the file is terminated with a newline.
  error: A callable to which errors are reported, which takes 4 arguments:
         filename, line number, error level, and message
  extra_check_functions: An array of additional check functions that will be
                         run on each source line. Each function takes 4
                         arguments: filename, clean_lines, line, error

Definition at line 4534 of file cpplint.py.

def cpplint.ProcessLine	(	filename,
		file_extension,
		clean_lines,
		line,
		include_state,
		function_state,
		nesting_state,
		error,
		extra_check_functions = `[]`
	)

Processes a single line in the file.

Args:
  filename: Filename of the file that is being processed.
  file_extension: The extension (dot not included) of the file.
  clean_lines: An array of strings, each representing a line of the file,
               with comments stripped.
  line: Number of line being processed.
  include_state: An _IncludeState instance in which the headers are inserted.
  function_state: A _FunctionState instance which counts function lines, etc.
  nesting_state: A _NestingState instance which maintains information about
                 the current stack of nested blocks being parsed.
  error: A callable to which errors are reported, which takes 4 arguments:
         filename, line number, error level, and message
  extra_check_functions: An array of additional check functions that will be
                         run on each source line. Each function takes 4
                         arguments: filename, clean_lines, line, error

Definition at line 4494 of file cpplint.py.

def cpplint.RemoveMultiLineComments	(	filename,
		lines,
		error
	)

Removes multiline (c-style) comments from lines.

Definition at line 1143 of file cpplint.py.

def cpplint.RemoveMultiLineCommentsFromRange	(	lines,
		begin,
		end
	)

Clears a range of lines for multi-line comments.

Definition at line 1135 of file cpplint.py.

def cpplint.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)

Definition at line 517 of file cpplint.py.

def cpplint.ResetNolintSuppressions ( )

Definition at line 487 of file cpplint.py.

def cpplint.ReverseCloseExpression	(	clean_lines,
		linenum,
		pos
	)

If input points to ) or } or ] or >, finds the position that opens it.

If lines[linenum][pos] points to a ')' or '}' or ']' or '>', finds the
linenum/pos that correspond to the opening of the expression.

Args:
  clean_lines: A CleansedLines instance containing the file.
  linenum: The number of the line to check.
  pos: A position on the line.

Returns:
  A tuple (line, linenum, pos) pointer *at* the opening brace, or
  (line, 0, -1) if we never find the matching opening brace.  Note
  we ignore strings and comments when matching; and the line we
  return is the 'cleansed' line at linenum.

Definition at line 1319 of file cpplint.py.

def cpplint.Search	(	pattern,
		s
	)

Searches the string for the pattern, caching the compiled regexp.

Definition at line 535 of file cpplint.py.

def cpplint.UpdateIncludeState	(	filename,
		include_state,
		io = `codecs`
	)

Fill up the include_state with new includes found from the file.

Args:
  filename: the name of the header to read.
  include_state: an _IncludeState instance in which the headers are inserted.
  io: The io factory to use to read the file. Provided for testability.

Returns:
  True if a header was succesfully added. False otherwise.

Definition at line 4346 of file cpplint.py.

Variable Documentation

dictionary cpplint._ALT_TOKEN_REPLACEMENT

private

Initial value:

 = {
     'and': '&&',
     'bitor': '|',
     'or': '||',
     'xor': '^',
     'compl': '~',
     'bitand': '&',
     'and_eq': '&=',
     'or_eq': '|=',
     'xor_eq': '^=',
     'not': '!',
     'not_eq': '!='
     }

Definition at line 394 of file cpplint.py.

cpplint._ALT_TOKEN_REPLACEMENT_PATTERN

private

Initial value:

1 = re.compile(

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

Definition at line 413 of file cpplint.py.

int cpplint._BLOCK_ASM = 3

private

Definition at line 429 of file cpplint.py.

int cpplint._C_SYS_HEADER = 1

private

Definition at line 419 of file cpplint.py.

list cpplint._CHECK_MACROS

private

Initial value:

 = [
     'DCHECK', 'CHECK',
     'EXPECT_TRUE_M', 'EXPECT_TRUE',
     'ASSERT_TRUE_M', 'ASSERT_TRUE',
     'EXPECT_FALSE_M', 'EXPECT_FALSE',
     'ASSERT_FALSE_M', 'ASSERT_FALSE',
     ]

Definition at line 360 of file cpplint.py.

cpplint._CHECK_REPLACEMENT = dict([(m, {}) for m in _CHECK_MACROS])

private

Definition at line 369 of file cpplint.py.

cpplint._CPP_HEADERS

private

Definition at line 222 of file cpplint.py.

int cpplint._CPP_SYS_HEADER = 2

private

Definition at line 420 of file cpplint.py.

cpplint._cpplint_state = _CppLintState()

private

Definition at line 756 of file cpplint.py.

list cpplint._DEFAULT_FILTERS = ['-build/include_alpha']

private

Definition at line 214 of file cpplint.py.

int cpplint._END_ASM = 2

private

Definition at line 428 of file cpplint.py.

list cpplint._ERROR_CATEGORIES

private

Definition at line 146 of file cpplint.py.

dictionary cpplint._error_suppressions = {}

private

Definition at line 444 of file cpplint.py.

tuple cpplint._HEADERS_CONTAINING_TEMPLATES

private

Definition at line 4233 of file cpplint.py.

int cpplint._INSIDE_ASM = 1

private

Definition at line 427 of file cpplint.py.

int cpplint._LIKELY_MY_HEADER = 3

private

Definition at line 421 of file cpplint.py.

int cpplint._line_length = 80

private

Definition at line 452 of file cpplint.py.

cpplint._MATCH_ASM

private

Initial value:

 = re.compile(r'^\s*(?:asm|_asm|__asm|__asm__)'
                         r'(?:\s+(volatile|__volatile__))?'
                         r'\s*[{(]')

Definition at line 432 of file cpplint.py.

int cpplint._NO_ASM = 0

private

Definition at line 426 of file cpplint.py.

int cpplint._OTHER_HEADER = 5

private

Definition at line 423 of file cpplint.py.

int cpplint._POSSIBLE_MY_HEADER = 4

private

Definition at line 422 of file cpplint.py.

cpplint._RE_FIRST_COMPONENT = re.compile(r'^[^-_.]+')

private

Definition at line 3465 of file cpplint.py.

list cpplint._re_pattern_algorithm_header = []

private

Definition at line 4272 of file cpplint.py.

cpplint._RE_PATTERN_CLEANSE_LINE_C_COMMENTS

private

Initial value:

1 = re.compile(

2 r, re.VERBOSE)

Definition at line 1030 of file cpplint.py.

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

private

Definition at line 1019 of file cpplint.py.

cpplint._RE_PATTERN_CLEANSE_LINE_ESCAPES

private

Initial value:

1 = re.compile(

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

Definition at line 1016 of file cpplint.py.

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

private

Definition at line 1021 of file cpplint.py.

tuple cpplint._RE_PATTERN_CONST_REF_PARAM

private

Initial value:

 = (
     r'(?:.*\s*\bconst\s*&\s*' + _RE_PATTERN_IDENT +
     r'|const\s+' + _RE_PATTERN_TYPE + r'\s*&\s*' + _RE_PATTERN_IDENT + r')')

Definition at line 3721 of file cpplint.py.

cpplint._RE_PATTERN_EXPLICIT_MAKEPAIR = re.compile(r'\bmake_pair\s*<')

private

Definition at line 4468 of file cpplint.py.

string cpplint._RE_PATTERN_IDENT = r'[_a-zA-Z]\w*'

private

Definition at line 3709 of file cpplint.py.

cpplint._RE_PATTERN_INCLUDE = re.compile(r'^\s*#\s*include\s*([<"])([^>"]*)[>"].*$')

private

Definition at line 3459 of file cpplint.py.

cpplint._RE_PATTERN_INCLUDE_NEW_STYLE = re.compile(r'#include +"[^/]+\.h"')

private

Definition at line 3458 of file cpplint.py.

cpplint._RE_PATTERN_INVALID_INCREMENT

private

Initial value:

1 = re.compile(

2 r'^\s*\*\w+(\+\+|--);')

Definition at line 1621 of file cpplint.py.

cpplint._RE_PATTERN_REF_PARAM

private

Initial value:

 = re.compile(
     r'(' + _RE_PATTERN_TYPE + r'(?:\s*(?:\bconst\b|[*]))*\s*'
     r'&\s*' + _RE_PATTERN_IDENT + r')\s*(?:=[^,()]+)?[,)]')

Definition at line 3716 of file cpplint.py.

cpplint._RE_PATTERN_STRING = re.compile(r'\bstring\b')

private

Definition at line 4270 of file cpplint.py.

list cpplint._re_pattern_templates = []

private

Definition at line 4282 of file cpplint.py.

cpplint._RE_PATTERN_TODO = re.compile(r'^//(\s*)TODO($.+?$)?:?(\s|$)?')

private

Definition at line 2346 of file cpplint.py.

tuple cpplint._RE_PATTERN_TYPE

private

Initial value:

 = (
     r'(?:const\s+)?(?:typename\s+|class\s+|struct\s+|union\s+|enum\s+)?'
     r'(?:\w|'
     r'\s*<(?:<(?:<[^<>]*>|[^<>])*>|[^<>])*>|'
     r'::)+')

Definition at line 3710 of file cpplint.py.

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

private

Definition at line 440 of file cpplint.py.

dictionary cpplint._regexp_compile_cache = {}

private

Definition at line 437 of file cpplint.py.

cpplint._root = None

private

Definition at line 448 of file cpplint.py.

string cpplint._USAGE

private

Definition at line 60 of file cpplint.py.

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

private

Definition at line 456 of file cpplint.py.

tuple cpplint.threading_list

Initial value:

 = (
     ('asctime(', 'asctime_r('),
     ('ctime(', 'ctime_r('),
     ('getgrgid(', 'getgrgid_r('),
     ('getgrnam(', 'getgrnam_r('),
     ('getlogin(', 'getlogin_r('),
     ('getpwnam(', 'getpwnam_r('),
     ('getpwuid(', 'getpwuid_r('),
     ('gmtime(', 'gmtime_r('),
     ('localtime(', 'localtime_r('),
     ('rand(', 'rand_r('),
     ('strtok(', 'strtok_r('),
     ('ttyname(', 'ttyname_r('),
     )

Definition at line 1557 of file cpplint.py.

Classes

Functions

Variables

Function Documentation

Variable Documentation