583 def ParseNolintSuppressions(filename, raw_line, linenum, error):  argument
593     linenum: int, the number of the current line.
599       suppressed_line = linenum + 1
601       suppressed_line = linenum
611           error(filename, linenum, 'readability/nolint', 5,
639 def IsErrorSuppressedByNolint(category, linenum):  argument
647     linenum: int, the current line number.
653           linenum in _error_suppressions.get(category, set()) or
654           linenum in _error_suppressions.get(None, set()))
787   def IsInAlphabeticalOrder(self, clean_lines, linenum, header_path):  argument
792       linenum: The number of the line to check.
804         Match(r'^\s*#\s*include\b', clean_lines.elided[linenum - 1])):
1059   def Check(self, error, filename, linenum):  argument
1065       linenum: The number of the line to check.
1081       error(filename, linenum, 'readability/fn_size', error_level,
1188 def _ShouldPrintError(category, confidence, linenum):  argument
1194   if IsErrorSuppressedByNolint(category, linenum):
1216 def Error(filename, linenum, category, confidence, message):  argument
1229     linenum: The number of the line containing the error.
1238   if _ShouldPrintError(category, confidence, linenum):
1242           filename, linenum, category, message, confidence))
1245           filename, linenum, message, category, confidence))
1248           filename, linenum, message, category, confidence))
1441     for linenum in range(len(self.lines_without_raw_strings)):
1443           self.lines_without_raw_strings[linenum]))
1444       elided = self._CollapseStrings(self.lines_without_raw_strings[linenum])
1597 def CloseExpression(clean_lines, linenum, pos):  argument
1600   If lines[linenum][pos] points to a '(' or '{' or '[' or '<', finds the
1601   linenum/pos that correspond to the closing of the expression.
1610     linenum: The number of the line to check.
1614     A tuple (line, linenum, pos) pointer *past* the closing brace, or
1617     'cleansed' line at linenum.
1620   line = clean_lines.elided[linenum]
1627     return (line, linenum, end_pos)
1630   while stack and linenum < clean_lines.NumLines() - 1:
1631     linenum += 1
1632     line = clean_lines.elided[linenum]
1635       return (line, linenum, end_pos)
1718 def ReverseCloseExpression(clean_lines, linenum, pos):  argument
1721   If lines[linenum][pos] points to a ')' or '}' or ']' or '>', finds the
1722   linenum/pos that correspond to the opening of the expression.
1726     linenum: The number of the line to check.
1730     A tuple (line, linenum, pos) pointer *at* the opening brace, or
1733     return is the 'cleansed' line at linenum.
1735   line = clean_lines.elided[linenum]
1742     return (line, linenum, start_pos)
1745   while stack and linenum > 0:
1746     linenum -= 1
1747     line = clean_lines.elided[linenum]
1750       return (line, linenum, start_pos)
1915   for linenum, line in enumerate(raw_lines):
1922         ifndef_linenum = linenum
1928       endif_linenum = linenum
2025   for linenum, line in enumerate(lines):
2027       error(filename, linenum, 'readability/utf8', 5,
2030       error(filename, linenum, 'readability/nul', 5, 'Line contains NUL byte.')
2051 def CheckForMultilineCommentsAndStrings(filename, clean_lines, linenum, error):  argument
2065     linenum: The number of the line to check.
2068   line = clean_lines.elided[linenum]
2075     error(filename, linenum, 'readability/multiline_comment', 5,
2083     error(filename, linenum, 'readability/multiline_string', 5,
2119 def CheckPosixThreading(filename, clean_lines, linenum, error):  argument
2131     linenum: The number of the line to check.
2134   line = clean_lines.elided[linenum]
2139       error(filename, linenum, 'runtime/threadsafe_fn', 2,
2145 def CheckVlogArguments(filename, clean_lines, linenum, error):  argument
2154     linenum: The number of the line to check.
2157   line = clean_lines.elided[linenum]
2159     error(filename, linenum, 'runtime/vlog', 5,
2169 def CheckInvalidIncrement(filename, clean_lines, linenum, error):  argument
2182     linenum: The number of the line to check.
2185   line = clean_lines.elided[linenum]
2187     error(filename, linenum, 'runtime/invalid_increment', 5,
2191 def IsMacroDefinition(clean_lines, linenum):  argument
2192   if Search(r'^#define', clean_lines[linenum]):
2195   if linenum > 0 and Search(r'\\$', clean_lines[linenum - 1]):
2201 def IsForwardClassDeclaration(clean_lines, linenum):  argument
2202   return Match(r'^\s*(\btemplate\b)*.*class\s+\w+;\s*$', clean_lines[linenum])
2208   def __init__(self, linenum, seen_open_brace):  argument
2209     self.starting_linenum = linenum
2215   def CheckBegin(self, filename, clean_lines, linenum, error):  argument
2225       linenum: The number of the line to check.
2230   def CheckEnd(self, filename, clean_lines, linenum, error):  argument
2238       linenum: The number of the line to check.
2258   def __init__(self, linenum):  argument
2259     _BlockInfo.__init__(self, linenum, True)
2265   def __init__(self, name, class_or_struct, clean_lines, linenum):  argument
2266     _BlockInfo.__init__(self, linenum, False)
2279     self.class_indent = GetIndentLevel(clean_lines.raw_lines[linenum])
2288     for i in range(linenum, clean_lines.NumLines()):
2295   def CheckBegin(self, filename, clean_lines, linenum, error):  argument
2297     if Search('(^|[^:]):($|[^:])', clean_lines.elided[linenum]):
2300   def CheckEnd(self, filename, clean_lines, linenum, error):  argument
2304     for i in xrange(linenum - 1, self.starting_linenum, -1):
2321     indent = Match(r'^( *)\}', clean_lines.elided[linenum])
2327       error(filename, linenum, 'whitespace/indent', 3,
2334   def __init__(self, name, linenum):  argument
2335     _BlockInfo.__init__(self, linenum, False)
2339   def CheckEnd(self, filename, clean_lines, linenum, error):  argument
2341     line = clean_lines.raw_lines[linenum]
2354     if (linenum - self.starting_linenum < 10
2375         error(filename, linenum, 'readability/namespace', 5,
2384           error(filename, linenum, 'readability/namespace', 5,
2388           error(filename, linenum, 'readability/namespace', 5,
2473   def InTemplateArgumentList(self, clean_lines, linenum, pos):  argument
2478       linenum: The number of the line to check.
2481       True if (linenum, pos) is inside template arguments.
2483     while linenum < clean_lines.NumLines():
2485       line = clean_lines.elided[linenum]
2488         linenum += 1
2511           linenum += 1
2517       (_, end_line, end_pos) = CloseExpression(clean_lines, linenum, pos - 1)
2521       linenum = end_line
2582   def Update(self, filename, clean_lines, linenum, error):  argument
2588       linenum: The number of the line to check.
2591     line = clean_lines.elided[linenum]
2641       new_namespace = _NamespaceInfo(namespace_decl_match.group(1), linenum)
2670       if not self.InTemplateArgumentList(clean_lines, linenum, end_declaration):
2673             clean_lines, linenum))
2679       self.stack[-1].CheckBegin(filename, clean_lines, linenum, error)
2703           error(filename, linenum, 'whitespace/indent', 3,
2722           self.stack.append(_ExternCInfo(linenum))
2724           self.stack.append(_BlockInfo(linenum, True))
2742           self.stack[-1].CheckEnd(filename, clean_lines, linenum, error)
2780 def CheckForNonStandardConstructs(filename, clean_lines, linenum,  argument
2802     linenum: The number of the line to check.
2810   line = clean_lines.lines[linenum]
2813     error(filename, linenum, 'runtime/printf_format', 3,
2817     error(filename, linenum, 'runtime/printf_format', 2,
2824     error(filename, linenum, 'build/printf_format', 3,
2828   line = clean_lines.elided[linenum]
2835     error(filename, linenum, 'build/storage_class', 5,
2840     error(filename, linenum, 'build/endif_comment', 5,
2844     error(filename, linenum, 'build/forward_decl', 5,
2849     error(filename, linenum, 'build/deprecated', 3,
2860     error(filename, linenum, 'runtime/member_string_references', 2,
2928         error(filename, linenum, 'runtime/explicit', 5,
2932         error(filename, linenum, 'runtime/explicit', 5,
2936         error(filename, linenum, 'runtime/explicit', 5,
2940 def CheckSpacingForFunctionCall(filename, clean_lines, linenum, error):  argument
2946     linenum: The number of the line to check.
2949   line = clean_lines.elided[linenum]
2986       error(filename, linenum, 'whitespace/parens', 4,
2989       error(filename, linenum, 'whitespace/parens', 2,
2999         error(filename, linenum, 'whitespace/parens', 0,
3002         error(filename, linenum, 'whitespace/parens', 4,
3010         error(filename, linenum, 'whitespace/parens', 2,
3013         error(filename, linenum, 'whitespace/parens', 2,
3046 def CheckForFunctionLengths(filename, clean_lines, linenum,  argument
3065     linenum: The number of the line to check.
3070   line = lines[linenum]
3086     for start_linenum in xrange(linenum, clean_lines.NumLines()):
3105       error(filename, linenum, 'readability/fn_size', 5,
3108     function_state.Check(error, filename, linenum)
3117 def CheckComment(line, filename, linenum, next_line_start, error):  argument
3123     linenum: The number of the line to check.
3137         error(filename, linenum, 'whitespace/comments', 2,
3147           error(filename, linenum, 'whitespace/todo', 2,
3152           error(filename, linenum, 'readability/todo', 2,
3159           error(filename, linenum, 'whitespace/todo', 2,
3167         error(filename, linenum, 'whitespace/comments', 4,
3171 def CheckSpacing(filename, clean_lines, linenum, nesting_state, error):  argument
3183     linenum: The number of the line to check.
3193   line = raw[linenum]
3214     prev_line = elided[linenum - 1]
3232         search_position = linenum-2
3250         error(filename, linenum, 'whitespace/blank_line', 2,
3261     if linenum + 1 < clean_lines.NumLines():
3262       next_line = raw[linenum + 1]
3266         error(filename, linenum, 'whitespace/blank_line', 3,
3272       error(filename, linenum, 'whitespace/blank_line', 3,
3277   if linenum + 1 < clean_lines.NumLines():
3278     next_line = raw[linenum + 1]
3280   CheckComment(line, filename, linenum, next_line_start, error)
3283   line = clean_lines.elided[linenum]
3288     error(filename, linenum, 'whitespace/braces', 5,
3295     error(filename, linenum, 'whitespace/forcolon', 2,
3299 def CheckOperatorSpacing(filename, clean_lines, linenum, error):  argument
3305     linenum: The number of the line to check.
3308   line = clean_lines.elided[linenum]
3333     error(filename, linenum, 'whitespace/operators', 4,
3353     error(filename, linenum, 'whitespace/operators', 3,
3363           clean_lines, linenum, len(match.group(1)))
3365         error(filename, linenum, 'whitespace/operators', 3,
3374           clean_lines, linenum, len(match.group(1)))
3376         error(filename, linenum, 'whitespace/operators', 3,
3387     error(filename, linenum, 'whitespace/operators', 3,
3404     error(filename, linenum, 'whitespace/operators', 3,
3410     error(filename, linenum, 'whitespace/operators', 4,
3414 def CheckParenthesisSpacing(filename, clean_lines, linenum, error):  argument
3420     linenum: The number of the line to check.
3423   line = clean_lines.elided[linenum]
3428     error(filename, linenum, 'whitespace/parens', 5,
3444         error(filename, linenum, 'whitespace/parens', 5,
3447       error(filename, linenum, 'whitespace/parens', 5,
3452 def CheckCommaSpacing(filename, clean_lines, linenum, error):  argument
3458     linenum: The number of the line to check.
3462   line = clean_lines.elided[linenum]
3475       Search(r',[^,\s]', raw[linenum])):
3476     error(filename, linenum, 'whitespace/comma', 3,
3484     error(filename, linenum, 'whitespace/semicolon', 3,
3551 def CheckBracesSpacing(filename, clean_lines, linenum, nesting_state, error):  argument
3557     linenum: The number of the line to check.
3562   line = clean_lines.elided[linenum]
3603         clean_lines, linenum, len(match.group(1)))
3615       error(filename, linenum, 'whitespace/braces', 5,
3620     error(filename, linenum, 'whitespace/braces', 5,
3627     error(filename, linenum, 'whitespace/semicolon', 5,
3630     error(filename, linenum, 'whitespace/semicolon', 5,
3635     error(filename, linenum, 'whitespace/semicolon', 5,
3640 def IsDecltype(clean_lines, linenum, column):  argument
3641   """Check if the token ending on (linenum, column) is decltype().
3645     linenum: the number of the line to check.
3650   (text, _, start_col) = ReverseCloseExpression(clean_lines, linenum, column)
3658 def CheckSectionSpacing(filename, clean_lines, class_info, linenum, error):  argument
3667     linenum: The number of the line to check.
3682       linenum <= class_info.starting_linenum):
3685   matched = Match(r'\s*(public|protected|private):', clean_lines.lines[linenum])
3695     prev_line = clean_lines.lines[linenum - 1]
3704       for i in range(class_info.starting_linenum, linenum):
3708       if end_class_head < linenum - 1:
3709         error(filename, linenum, 'whitespace/blank_line', 3,
3713 def GetPreviousNonBlankLine(clean_lines, linenum):  argument
3718     linenum: The number of the line to check.
3727   prevlinenum = linenum - 1
3736 def CheckBraces(filename, clean_lines, linenum, error):  argument
3742     linenum: The number of the line to check.
3746   line = clean_lines.elided[linenum]        # get rid of comments and strings
3758     prevline = GetPreviousNonBlankLine(clean_lines, linenum)[0]
3762       error(filename, linenum, 'whitespace/braces', 4,
3767     prevline = GetPreviousNonBlankLine(clean_lines, linenum)[0]
3769       error(filename, linenum, 'whitespace/newline', 4,
3780       (endline, _, endpos) = CloseExpression(clean_lines, linenum, pos)
3783         error(filename, linenum, 'readability/braces', 5,
3786     error(filename, linenum, 'readability/braces', 5,
3791     error(filename, linenum, 'whitespace/newline', 4,
3796     error(filename, linenum, 'whitespace/newline', 4,
3809     endline, endlinenum, endpos = line, linenum, if_else_match.end()
3814       (endline, endlinenum, endpos) = CloseExpression(clean_lines, linenum, pos)
3836             error(filename, linenum, 'readability/braces', 4,
3847             error(filename, linenum, 'readability/braces', 4,
3851             error(filename, linenum, 'readability/braces', 4,
3855 def CheckTrailingSemicolon(filename, clean_lines, linenum, error):  argument
3861     linenum: The number of the line to check.
3865   line = clean_lines.elided[linenum]
3941         clean_lines, linenum, closing_brace_pos)
3974       prevline = GetPreviousNonBlankLine(clean_lines, linenum)[0]
3981         clean_lines, linenum, len(match.group(1)))
4002 def CheckEmptyBlockBody(filename, clean_lines, linenum, error):  argument
4008     linenum: The number of the line to check.
4018   line = clean_lines.elided[linenum]
4023         clean_lines, linenum, line.find('('))
4129 def CheckCheck(filename, clean_lines, linenum, error):  argument
4135     linenum: The number of the line to check.
4141   (check_macro, start_pos) = FindCheckMacro(lines[linenum])
4147       clean_lines, linenum, start_pos)
4157   if linenum == end_line:
4158     expression = lines[linenum][start_pos + 1:end_pos - 1]
4160     expression = lines[linenum][start_pos + 1:]
4161     for i in xrange(linenum + 1, end_line):
4241     error(filename, linenum, 'readability/check', 2,
4247 def CheckAltTokens(filename, clean_lines, linenum, error):  argument
4253     linenum: The number of the line to check.
4256   line = clean_lines.elided[linenum]
4274     error(filename, linenum, 'readability/alt_tokens', 2,
4314 def CheckStyle(filename, clean_lines, linenum, file_extension, nesting_state,  argument
4325     linenum: The number of the line to check.
4336   line = raw_lines[linenum]
4337   prev = raw_lines[linenum - 1] if linenum > 0 else ''
4340     error(filename, linenum, 'whitespace/tab', 1,
4358   cleansed_line = clean_lines.elided[linenum]
4369       not (clean_lines.raw_lines[linenum] != line and
4371     error(filename, linenum, 'whitespace/indent', 3,
4376     error(filename, linenum, 'whitespace/end_of_line', 4,
4401       error(filename, linenum, 'whitespace/line_length', 2,
4407       (GetPreviousNonBlankLine(clean_lines, linenum)[0].find('for') == -1 or
4408        GetPreviousNonBlankLine(clean_lines, linenum)[0].find(';') != -1) and
4413     error(filename, linenum, 'whitespace/newline', 0,
4417   CheckBraces(filename, clean_lines, linenum, error)
4418   CheckTrailingSemicolon(filename, clean_lines, linenum, error)
4419   CheckEmptyBlockBody(filename, clean_lines, linenum, error)
4420   CheckSpacing(filename, clean_lines, linenum, nesting_state, error)
4421   CheckOperatorSpacing(filename, clean_lines, linenum, error)
4422   CheckParenthesisSpacing(filename, clean_lines, linenum, error)
4423   CheckCommaSpacing(filename, clean_lines, linenum, error)
4424   CheckBracesSpacing(filename, clean_lines, linenum, nesting_state, error)
4425   CheckSpacingForFunctionCall(filename, clean_lines, linenum, error)
4426   CheckCheck(filename, clean_lines, linenum, error)
4427   CheckAltTokens(filename, clean_lines, linenum, error)
4430     CheckSectionSpacing(filename, clean_lines, classinfo, linenum, error)
4529 def CheckIncludeLine(filename, clean_lines, linenum, include_state, error):  argument
4539     linenum: The number of the line to check.
4544   line = clean_lines.lines[linenum]
4555     error(filename, linenum, 'build/include', 4,
4567       error(filename, linenum, 'build/include', 4,
4572       error(filename, linenum, 'build/include', 4,
4575       include_state.include_list[-1].append((include, linenum))
4591         error(filename, linenum, 'build/include_order', 4,
4596           clean_lines, linenum, canonical_include):
4597         error(filename, linenum, 'build/include_alpha', 4,
4688 def CheckLanguage(filename, clean_lines, linenum, file_extension,  argument
4698     linenum: The number of the line to check.
4707   line = clean_lines.elided[linenum]
4713     CheckIncludeLine(filename, clean_lines, linenum, include_state, error)
4726   CheckCasts(filename, clean_lines, linenum, error)
4727   CheckGlobalStatic(filename, clean_lines, linenum, error)
4728   CheckPrintf(filename, clean_lines, linenum, error)
4742       error(filename, linenum, 'runtime/int', 4,
4747       error(filename, linenum, 'runtime/int', 4,
4757     error(filename, linenum, 'runtime/operator', 4,
4763     error(filename, linenum, 'readability/braces', 4,
4779       error(filename, linenum, 'runtime/printf', 4,
4786     error(filename, linenum, 'runtime/memset', 4,
4791     error(filename, linenum, 'build/namespaces', 5,
4830       error(filename, linenum, 'runtime/arrays', 1,
4840     error(filename, linenum, 'build/namespaces', 4,
4846 def CheckGlobalStatic(filename, clean_lines, linenum, error):  argument
4852     linenum: The number of the line to check.
4855   line = clean_lines.elided[linenum]
4858   if linenum + 1 < clean_lines.NumLines() and not Search(r'[;({]', line):
4859     line += clean_lines.elided[linenum + 1].strip()
4893       error(filename, linenum, 'runtime/string', 4,
4898       error(filename, linenum, 'runtime/string', 4,
4903     error(filename, linenum, 'runtime/init', 4,
4907 def CheckPrintf(filename, clean_lines, linenum, error):  argument
4913     linenum: The number of the line to check.
4916   line = clean_lines.elided[linenum]
4922     error(filename, linenum, 'runtime/printf', 3,
4928     error(filename, linenum, 'runtime/printf', 5,
4932     error(filename, linenum, 'runtime/printf', 4,
4936 def IsDerivedFunction(clean_lines, linenum):  argument
4941     linenum: The number of the line to check.
4947   for i in xrange(linenum, max(-1, linenum - 10), -1):
4958 def IsOutOfLineMethodDefinition(clean_lines, linenum):  argument
4963     linenum: The number of the line to check.
4968   for i in xrange(linenum, max(-1, linenum - 10), -1):
4974 def IsInitializerList(clean_lines, linenum):  argument
4979     linenum: The number of the line to check.
4984   for i in xrange(linenum, 1, -1):
4986     if i == linenum:
5016 def CheckForNonConstReference(filename, clean_lines, linenum,  argument
5026     linenum: The number of the line to check.
5032   line = clean_lines.elided[linenum]
5039   if IsDerivedFunction(clean_lines, linenum):
5044   if IsOutOfLineMethodDefinition(clean_lines, linenum):
5063   if linenum > 1:
5068                         clean_lines.elided[linenum - 1])
5072                         clean_lines.elided[linenum - 1])
5080             clean_lines, linenum, endpos)
5081         if startpos > -1 and startline < linenum:
5085           for i in xrange(startline, linenum + 1):
5108   if linenum > 0:
5109     for i in xrange(linenum - 1, max(0, linenum - 10), -1):
5121   if IsInitializerList(clean_lines, linenum):
5141       if (linenum > i and
5142           Search(whitelisted_functions, clean_lines.elided[linenum - i - 1])):
5149       error(filename, linenum, 'runtime/references', 2,
5155 def CheckCasts(filename, clean_lines, linenum, error):  argument
5161     linenum: The number of the line to check.
5164   line = clean_lines.elided[linenum]
5174   expecting_function = ExpectingFunctionArgs(clean_lines, linenum)
5210       error(filename, linenum, 'readability/casting', 4,
5216     CheckCStyleCast(filename, clean_lines, linenum, 'static_cast',
5223   if CheckCStyleCast(filename, clean_lines, linenum, 'const_cast',
5228     CheckCStyleCast(filename, clean_lines, linenum, 'reinterpret_cast',
5252       _, y1, x1 = CloseExpression(clean_lines, linenum, len(match.group(1)))
5263       error(filename, linenum, 'readability/casting', 4,
5268       error(filename, linenum, 'runtime/casting', 4,
5274 def CheckCStyleCast(filename, clean_lines, linenum, cast_type, pattern, error):  argument
5280     linenum: The number of the line to check.
5290   line = clean_lines.elided[linenum]
5302   if linenum > 0:
5303     for i in xrange(linenum - 1, max(0, linenum - 5), -1):
5320   error(filename, linenum, 'readability/casting', 4,
5327 def ExpectingFunctionArgs(clean_lines, linenum):  argument
5332     linenum: The number of the line to check.
5335     True if the line at 'linenum' is inside something that expects arguments
5338   line = clean_lines.elided[linenum]
5340           (linenum >= 2 and
5342                   clean_lines.elided[linenum - 1]) or
5344                   clean_lines.elided[linenum - 2]) or
5346                    clean_lines.elided[linenum - 1]))))
5490   linenum = 0
5492     linenum += 1
5497       include_dict.setdefault(include, linenum)
5522   for linenum in xrange(clean_lines.NumLines()):
5523     line = clean_lines.elided[linenum]
5534         required['<string>'] = (linenum, 'string')
5538         required[header] = (linenum, template)
5551           required[header] = (linenum, template)
5603 def CheckMakePairUsesDeduction(filename, clean_lines, linenum, error):  argument
5612     linenum: The number of the line to check.
5615   line = clean_lines.elided[linenum]
5618     error(filename, linenum, 'build/explicit_make_pair',
5624 def CheckRedundantVirtual(filename, clean_lines, linenum, error):  argument
5630     linenum: The number of the line to check.
5634   line = clean_lines.elided[linenum]
5658   for start_line in xrange(linenum, min(linenum + 3, clean_lines.NumLines())):
5677       error(filename, linenum, 'readability/inheritance', 4,
5688 def CheckRedundantOverrideOrFinal(filename, clean_lines, linenum, error):  argument
5694     linenum: The number of the line to check.
5700   line = clean_lines.elided[linenum]
5705     if linenum > 1 and clean_lines.elided[linenum - 1].rfind(')') >= 0:
5712     error(filename, linenum, 'readability/inheritance', 4,
5743                                     raw_lines_no_comments, linenum):  argument
5752     linenum: The current line number we are processing.
5760                                                      linenum)
5766   if IsMacroDefinition(raw_lines_no_comments, linenum):
5775 def CheckItemIndentationInNamespace(filename, raw_lines_no_comments, linenum,  argument
5777   line = raw_lines_no_comments[linenum]
5779     error(filename, linenum, 'runtime/indentation_namespace', 4,
5827 def FlagCxx11Features(filename, clean_lines, linenum, error):  argument
5833     linenum: The number of the line to check.
5836   line = clean_lines.elided[linenum]
5842     error(filename, linenum, 'build/c++tr1', 5,
5857     error(filename, linenum, 'build/c++11', 5,
5873       error(filename, linenum, 'build/c++11', 5,
5879 def FlagCxx14Features(filename, clean_lines, linenum, error):  argument
5885     linenum: The number of the line to check.
5888   line = clean_lines.elided[linenum]
5894     error(filename, linenum, 'build/c++14', 5,
6076     for linenum in range(len(lines) - 1):
6077       if lines[linenum].endswith('\r'):
6078         lines[linenum] = lines[linenum].rstrip('\r')
6079         crlf_lines.append(linenum + 1)
6081         lf_lines.append(linenum + 1)
6115       for linenum in crlf_lines:
6116         Error(filename, linenum, 'whitespace/newline', 1,