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,
4311 def CheckStyle(filename, clean_lines, linenum, file_extension, nesting_state,  argument
4322     linenum: The number of the line to check.
4333   line = raw_lines[linenum]
4334   prev = raw_lines[linenum - 1] if linenum > 0 else ''
4337     error(filename, linenum, 'whitespace/tab', 1,
4355   cleansed_line = clean_lines.elided[linenum]
4366       not (clean_lines.raw_lines[linenum] != line and
4368     error(filename, linenum, 'whitespace/indent', 3,
4373     error(filename, linenum, 'whitespace/end_of_line', 4,
4398       error(filename, linenum, 'whitespace/line_length', 2,
4404       (GetPreviousNonBlankLine(clean_lines, linenum)[0].find('for') == -1 or
4405        GetPreviousNonBlankLine(clean_lines, linenum)[0].find(';') != -1) and
4410     error(filename, linenum, 'whitespace/newline', 0,
4414   CheckBraces(filename, clean_lines, linenum, error)
4415   CheckTrailingSemicolon(filename, clean_lines, linenum, error)
4416   CheckEmptyBlockBody(filename, clean_lines, linenum, error)
4417   CheckSpacing(filename, clean_lines, linenum, nesting_state, error)
4418   CheckOperatorSpacing(filename, clean_lines, linenum, error)
4419   CheckParenthesisSpacing(filename, clean_lines, linenum, error)
4420   CheckCommaSpacing(filename, clean_lines, linenum, error)
4421   CheckBracesSpacing(filename, clean_lines, linenum, nesting_state, error)
4422   CheckSpacingForFunctionCall(filename, clean_lines, linenum, error)
4423   CheckCheck(filename, clean_lines, linenum, error)
4424   CheckAltTokens(filename, clean_lines, linenum, error)
4427     CheckSectionSpacing(filename, clean_lines, classinfo, linenum, error)
4526 def CheckIncludeLine(filename, clean_lines, linenum, include_state, error):  argument
4536     linenum: The number of the line to check.
4541   line = clean_lines.lines[linenum]
4552     error(filename, linenum, 'build/include', 4,
4564       error(filename, linenum, 'build/include', 4,
4569       error(filename, linenum, 'build/include', 4,
4572       include_state.include_list[-1].append((include, linenum))
4588         error(filename, linenum, 'build/include_order', 4,
4593           clean_lines, linenum, canonical_include):
4594         error(filename, linenum, 'build/include_alpha', 4,
4685 def CheckLanguage(filename, clean_lines, linenum, file_extension,  argument
4695     linenum: The number of the line to check.
4704   line = clean_lines.elided[linenum]
4710     CheckIncludeLine(filename, clean_lines, linenum, include_state, error)
4723   CheckCasts(filename, clean_lines, linenum, error)
4724   CheckGlobalStatic(filename, clean_lines, linenum, error)
4725   CheckPrintf(filename, clean_lines, linenum, error)
4739       error(filename, linenum, 'runtime/int', 4,
4744       error(filename, linenum, 'runtime/int', 4,
4754     error(filename, linenum, 'runtime/operator', 4,
4760     error(filename, linenum, 'readability/braces', 4,
4776       error(filename, linenum, 'runtime/printf', 4,
4783     error(filename, linenum, 'runtime/memset', 4,
4788     error(filename, linenum, 'build/namespaces', 5,
4827       error(filename, linenum, 'runtime/arrays', 1,
4837     error(filename, linenum, 'build/namespaces', 4,
4843 def CheckGlobalStatic(filename, clean_lines, linenum, error):  argument
4849     linenum: The number of the line to check.
4852   line = clean_lines.elided[linenum]
4855   if linenum + 1 < clean_lines.NumLines() and not Search(r'[;({]', line):
4856     line += clean_lines.elided[linenum + 1].strip()
4890       error(filename, linenum, 'runtime/string', 4,
4895       error(filename, linenum, 'runtime/string', 4,
4900     error(filename, linenum, 'runtime/init', 4,
4904 def CheckPrintf(filename, clean_lines, linenum, error):  argument
4910     linenum: The number of the line to check.
4913   line = clean_lines.elided[linenum]
4919     error(filename, linenum, 'runtime/printf', 3,
4925     error(filename, linenum, 'runtime/printf', 5,
4929     error(filename, linenum, 'runtime/printf', 4,
4933 def IsDerivedFunction(clean_lines, linenum):  argument
4938     linenum: The number of the line to check.
4944   for i in xrange(linenum, max(-1, linenum - 10), -1):
4955 def IsOutOfLineMethodDefinition(clean_lines, linenum):  argument
4960     linenum: The number of the line to check.
4965   for i in xrange(linenum, max(-1, linenum - 10), -1):
4971 def IsInitializerList(clean_lines, linenum):  argument
4976     linenum: The number of the line to check.
4981   for i in xrange(linenum, 1, -1):
4983     if i == linenum:
5013 def CheckForNonConstReference(filename, clean_lines, linenum,  argument
5023     linenum: The number of the line to check.
5029   line = clean_lines.elided[linenum]
5036   if IsDerivedFunction(clean_lines, linenum):
5041   if IsOutOfLineMethodDefinition(clean_lines, linenum):
5060   if linenum > 1:
5065                         clean_lines.elided[linenum - 1])
5069                         clean_lines.elided[linenum - 1])
5077             clean_lines, linenum, endpos)
5078         if startpos > -1 and startline < linenum:
5082           for i in xrange(startline, linenum + 1):
5105   if linenum > 0:
5106     for i in xrange(linenum - 1, max(0, linenum - 10), -1):
5118   if IsInitializerList(clean_lines, linenum):
5138       if (linenum > i and
5139           Search(allowed_functions, clean_lines.elided[linenum - i - 1])):
5146       error(filename, linenum, 'runtime/references', 2,
5152 def CheckCasts(filename, clean_lines, linenum, error):  argument
5158     linenum: The number of the line to check.
5161   line = clean_lines.elided[linenum]
5171   expecting_function = ExpectingFunctionArgs(clean_lines, linenum)
5207       error(filename, linenum, 'readability/casting', 4,
5213     CheckCStyleCast(filename, clean_lines, linenum, 'static_cast',
5220   if CheckCStyleCast(filename, clean_lines, linenum, 'const_cast',
5225     CheckCStyleCast(filename, clean_lines, linenum, 'reinterpret_cast',
5249       _, y1, x1 = CloseExpression(clean_lines, linenum, len(match.group(1)))
5260       error(filename, linenum, 'readability/casting', 4,
5265       error(filename, linenum, 'runtime/casting', 4,
5271 def CheckCStyleCast(filename, clean_lines, linenum, cast_type, pattern, error):  argument
5277     linenum: The number of the line to check.
5287   line = clean_lines.elided[linenum]
5299   if linenum > 0:
5300     for i in xrange(linenum - 1, max(0, linenum - 5), -1):
5317   error(filename, linenum, 'readability/casting', 4,
5324 def ExpectingFunctionArgs(clean_lines, linenum):  argument
5329     linenum: The number of the line to check.
5332     True if the line at 'linenum' is inside something that expects arguments
5335   line = clean_lines.elided[linenum]
5337           (linenum >= 2 and
5339                   clean_lines.elided[linenum - 1]) or
5341                   clean_lines.elided[linenum - 2]) or
5343                    clean_lines.elided[linenum - 1]))))
5487   linenum = 0
5489     linenum += 1
5494       include_dict.setdefault(include, linenum)
5519   for linenum in xrange(clean_lines.NumLines()):
5520     line = clean_lines.elided[linenum]
5531         required['<string>'] = (linenum, 'string')
5535         required[header] = (linenum, template)
5548           required[header] = (linenum, template)
5600 def CheckMakePairUsesDeduction(filename, clean_lines, linenum, error):  argument
5609     linenum: The number of the line to check.
5612   line = clean_lines.elided[linenum]
5615     error(filename, linenum, 'build/explicit_make_pair',
5621 def CheckRedundantVirtual(filename, clean_lines, linenum, error):  argument
5627     linenum: The number of the line to check.
5631   line = clean_lines.elided[linenum]
5655   for start_line in xrange(linenum, min(linenum + 3, clean_lines.NumLines())):
5674       error(filename, linenum, 'readability/inheritance', 4,
5685 def CheckRedundantOverrideOrFinal(filename, clean_lines, linenum, error):  argument
5691     linenum: The number of the line to check.
5697   line = clean_lines.elided[linenum]
5702     if linenum > 1 and clean_lines.elided[linenum - 1].rfind(')') >= 0:
5709     error(filename, linenum, 'readability/inheritance', 4,
5740                                     raw_lines_no_comments, linenum):  argument
5749     linenum: The current line number we are processing.
5757                                                      linenum)
5763   if IsMacroDefinition(raw_lines_no_comments, linenum):
5772 def CheckItemIndentationInNamespace(filename, raw_lines_no_comments, linenum,  argument
5774   line = raw_lines_no_comments[linenum]
5776     error(filename, linenum, 'runtime/indentation_namespace', 4,
5824 def FlagCxx11Features(filename, clean_lines, linenum, error):  argument
5830     linenum: The number of the line to check.
5833   line = clean_lines.elided[linenum]
5839     error(filename, linenum, 'build/c++tr1', 5,
5854     error(filename, linenum, 'build/c++11', 5,
5870       error(filename, linenum, 'build/c++11', 5,
5876 def FlagCxx14Features(filename, clean_lines, linenum, error):  argument
5882     linenum: The number of the line to check.
5885   line = clean_lines.elided[linenum]
5891     error(filename, linenum, 'build/c++14', 5,
6073     for linenum in range(len(lines) - 1):
6074       if lines[linenum].endswith('\r'):
6075         lines[linenum] = lines[linenum].rstrip('\r')
6076         crlf_lines.append(linenum + 1)
6078         lf_lines.append(linenum + 1)
6112       for linenum in crlf_lines:
6113         Error(filename, linenum, 'whitespace/newline', 1,