781   def IsInAlphabeticalOrder(self, clean_lines, linenum, header_path):  argument
798         Match(r'^\s*#\s*include\b', clean_lines.elided[linenum - 1])):
1591 def CloseExpression(clean_lines, linenum, pos):  argument
1614   line = clean_lines.elided[linenum]
1616     return (line, clean_lines.NumLines(), -1)
1624   while stack and linenum < clean_lines.NumLines() - 1:
1626     line = clean_lines.elided[linenum]
1632   return (line, clean_lines.NumLines(), -1)
1712 def ReverseCloseExpression(clean_lines, linenum, pos):  argument
1729   line = clean_lines.elided[linenum]
1741     line = clean_lines.elided[linenum]
1879 def CheckForHeaderGuard(filename, clean_lines, error):  argument
1897   raw_lines = clean_lines.lines_without_raw_strings
2045 def CheckForMultilineCommentsAndStrings(filename, clean_lines, linenum, error):  argument
2062   line = clean_lines.elided[linenum]
2113 def CheckPosixThreading(filename, clean_lines, linenum, error):  argument
2128   line = clean_lines.elided[linenum]
2139 def CheckVlogArguments(filename, clean_lines, linenum, error):  argument
2151   line = clean_lines.elided[linenum]
2163 def CheckInvalidIncrement(filename, clean_lines, linenum, error):  argument
2179   line = clean_lines.elided[linenum]
2185 def IsMacroDefinition(clean_lines, linenum):  argument
2186   if Search(r'^#define', clean_lines[linenum]):
2189   if linenum > 0 and Search(r'\\$', clean_lines[linenum - 1]):
2195 def IsForwardClassDeclaration(clean_lines, linenum):  argument
2196   return Match(r'^\s*(\btemplate\b)*.*class\s+\w+;\s*$', clean_lines[linenum])
2209   def CheckBegin(self, filename, clean_lines, linenum, error):  argument
2224   def CheckEnd(self, filename, clean_lines, linenum, error):  argument
2259   def __init__(self, name, class_or_struct, clean_lines, linenum):  argument
2273     self.class_indent = GetIndentLevel(clean_lines.raw_lines[linenum])
2282     for i in range(linenum, clean_lines.NumLines()):
2283       line = clean_lines.elided[i]
2289   def CheckBegin(self, filename, clean_lines, linenum, error):  argument
2291     if Search('(^|[^:]):($|[^:])', clean_lines.elided[linenum]):
2294   def CheckEnd(self, filename, clean_lines, linenum, error):  argument
2302           clean_lines.elided[i])
2309       if not Match(r'^\s*$', clean_lines.elided[i]):
2315     indent = Match(r'^( *)\}', clean_lines.elided[linenum])
2333   def CheckEnd(self, filename, clean_lines, linenum, error):  argument
2335     line = clean_lines.raw_lines[linenum]
2467   def InTemplateArgumentList(self, clean_lines, linenum, pos):  argument
2477     while linenum < clean_lines.NumLines():
2479       line = clean_lines.elided[linenum]
2511       (_, end_line, end_pos) = CloseExpression(clean_lines, linenum, pos - 1)
2576   def Update(self, filename, clean_lines, linenum, error):  argument
2585     line = clean_lines.elided[linenum]
2664       if not self.InTemplateArgumentList(clean_lines, linenum, end_declaration):
2667             clean_lines, linenum))
2673       self.stack[-1].CheckBegin(filename, clean_lines, linenum, error)
2736           self.stack[-1].CheckEnd(filename, clean_lines, linenum, error)
2774 def CheckForNonStandardConstructs(filename, clean_lines, linenum,  argument
2804   line = clean_lines.lines[linenum]
2822   line = clean_lines.elided[linenum]
2934 def CheckSpacingForFunctionCall(filename, clean_lines, linenum, error):  argument
2943   line = clean_lines.elided[linenum]
3026 def CheckForNamespaceIndentation(filename, nesting_state, clean_lines, line,  argument
3035                                      clean_lines.elided, line):
3036     CheckItemIndentationInNamespace(filename, clean_lines.elided,
3040 def CheckForFunctionLengths(filename, clean_lines, linenum,  argument
3063   lines = clean_lines.lines
3080     for start_linenum in xrange(linenum, clean_lines.NumLines()):
3165 def CheckSpacing(filename, clean_lines, linenum, nesting_state, error):  argument
3186   raw = clean_lines.lines_without_raw_strings
3207     elided = clean_lines.elided
3255     if linenum + 1 < clean_lines.NumLines():
3271   if linenum + 1 < clean_lines.NumLines():
3277   line = clean_lines.elided[linenum]
3293 def CheckOperatorSpacing(filename, clean_lines, linenum, error):  argument
3302   line = clean_lines.elided[linenum]
3357           clean_lines, linenum, len(match.group(1)))
3368           clean_lines, linenum, len(match.group(1)))
3408 def CheckParenthesisSpacing(filename, clean_lines, linenum, error):  argument
3417   line = clean_lines.elided[linenum]
3446 def CheckCommaSpacing(filename, clean_lines, linenum, error):  argument
3455   raw = clean_lines.lines_without_raw_strings
3456   line = clean_lines.elided[linenum]
3482 def _IsType(clean_lines, nesting_state, expr):  argument
3527       if clean_lines.elided[first_line].find('template') >= 0:
3538       if Search(typename_pattern, clean_lines.elided[i]):
3545 def CheckBracesSpacing(filename, clean_lines, linenum, nesting_state, error):  argument
3556   line = clean_lines.elided[linenum]
3597         clean_lines, linenum, len(match.group(1)))
3602                          min(endlinenum + 3, clean_lines.NumLines() - 1)):
3603       trailing_text += clean_lines.elided[offset]
3608         and not _IsType(clean_lines, nesting_state, leading_text)):
3634 def IsDecltype(clean_lines, linenum, column):  argument
3644   (text, _, start_col) = ReverseCloseExpression(clean_lines, linenum, column)
3652 def CheckSectionSpacing(filename, clean_lines, class_info, linenum, error):  argument
3679   matched = Match(r'\s*(public|protected|private):', clean_lines.lines[linenum])
3689     prev_line = clean_lines.lines[linenum - 1]
3699         if Search(r'\{\s*$', clean_lines.lines[i]):
3707 def GetPreviousNonBlankLine(clean_lines, linenum):  argument
3723     prevline = clean_lines.elided[prevlinenum]
3730 def CheckBraces(filename, clean_lines, linenum, error):  argument
3740   line = clean_lines.elided[linenum]        # get rid of comments and strings
3752     prevline = GetPreviousNonBlankLine(clean_lines, linenum)[0]
3761     prevline = GetPreviousNonBlankLine(clean_lines, linenum)[0]
3774       (endline, _, endpos) = CloseExpression(clean_lines, linenum, pos)
3808       (endline, endlinenum, endpos) = CloseExpression(clean_lines, linenum, pos)
3813                  and endlinenum < (len(clean_lines.elided) - 1)
3814                  and Match(r'\s*{', clean_lines.elided[endlinenum + 1]))):
3815       while (endlinenum < len(clean_lines.elided)
3816              and ';' not in clean_lines.elided[endlinenum][endpos:]):
3819       if endlinenum < len(clean_lines.elided):
3820         endline = clean_lines.elided[endlinenum]
3832         elif endlinenum < len(clean_lines.elided) - 1:
3834           next_line = clean_lines.elided[endlinenum + 1]
3849 def CheckTrailingSemicolon(filename, clean_lines, linenum, error):  argument
3859   line = clean_lines.elided[linenum]
3935         clean_lines, linenum, closing_brace_pos)
3952         Search(r'\]\s*$', clean_lines.elided[opening_parenthesis[1] - 1])):
3968       prevline = GetPreviousNonBlankLine(clean_lines, linenum)[0]
3975         clean_lines, linenum, len(match.group(1)))
3986       raw_lines = clean_lines.raw_lines
3996 def CheckEmptyBlockBody(filename, clean_lines, linenum, error):  argument
4012   line = clean_lines.elided[linenum]
4017         clean_lines, linenum, line.find('('))
4043         if opening_linenum == len(clean_lines.elided):
4046         opening_line_fragment = clean_lines.elided[opening_linenum]
4048       opening_line = clean_lines.elided[opening_linenum]
4056           clean_lines, opening_linenum, opening_pos)
4063       if (clean_lines.raw_lines[opening_linenum] !=
4064           CleanseComments(clean_lines.raw_lines[opening_linenum])):
4071         body.extend(clean_lines.raw_lines[opening_linenum+1:closing_linenum])
4073         body.append(clean_lines.elided[closing_linenum][:closing_pos-1])
4091         if current_linenum == len(clean_lines.elided):
4093         current_line_fragment = clean_lines.elided[current_linenum]
4123 def CheckCheck(filename, clean_lines, linenum, error):  argument
4134   lines = clean_lines.elided
4141       clean_lines, linenum, start_pos)
4241 def CheckAltTokens(filename, clean_lines, linenum, error):  argument
4250   line = clean_lines.elided[linenum]
4295 def CheckStyle(filename, clean_lines, linenum, file_extension, nesting_state,  argument
4316   raw_lines = clean_lines.lines_without_raw_strings
4339   cleansed_line = clean_lines.elided[linenum]
4350       not (clean_lines.raw_lines[linenum] != line and
4388       (GetPreviousNonBlankLine(clean_lines, linenum)[0].find('for') == -1 or
4389        GetPreviousNonBlankLine(clean_lines, linenum)[0].find(';') != -1) and
4398   CheckBraces(filename, clean_lines, linenum, error)
4399   CheckTrailingSemicolon(filename, clean_lines, linenum, error)
4400   CheckEmptyBlockBody(filename, clean_lines, linenum, error)
4401   CheckSpacing(filename, clean_lines, linenum, nesting_state, error)
4402   CheckOperatorSpacing(filename, clean_lines, linenum, error)
4403   CheckParenthesisSpacing(filename, clean_lines, linenum, error)
4404   CheckCommaSpacing(filename, clean_lines, linenum, error)
4405   CheckBracesSpacing(filename, clean_lines, linenum, nesting_state, error)
4406   CheckSpacingForFunctionCall(filename, clean_lines, linenum, error)
4407   CheckCheck(filename, clean_lines, linenum, error)
4408   CheckAltTokens(filename, clean_lines, linenum, error)
4411     CheckSectionSpacing(filename, clean_lines, classinfo, linenum, error)
4510 def CheckIncludeLine(filename, clean_lines, linenum, include_state, error):  argument
4525   line = clean_lines.lines[linenum]
4577           clean_lines, linenum, canonical_include):
4669 def CheckLanguage(filename, clean_lines, linenum, file_extension,  argument
4688   line = clean_lines.elided[linenum]
4694     CheckIncludeLine(filename, clean_lines, linenum, include_state, error)
4707   CheckCasts(filename, clean_lines, linenum, error)
4708   CheckGlobalStatic(filename, clean_lines, linenum, error)
4709   CheckPrintf(filename, clean_lines, linenum, error)
4827 def CheckGlobalStatic(filename, clean_lines, linenum, error):  argument
4836   line = clean_lines.elided[linenum]
4839   if linenum + 1 < clean_lines.NumLines() and not Search(r'[;({]', line):
4840     line += clean_lines.elided[linenum + 1].strip()
4888 def CheckPrintf(filename, clean_lines, linenum, error):  argument
4897   line = clean_lines.elided[linenum]
4917 def IsDerivedFunction(clean_lines, linenum):  argument
4929     match = Match(r'^([^()]*\w+)\(', clean_lines.elided[i])
4933           clean_lines, i, len(match.group(1)))
4939 def IsOutOfLineMethodDefinition(clean_lines, linenum):  argument
4950     if Match(r'^([^()]*\w+)\(', clean_lines.elided[i]):
4951       return Match(r'^[^()]*\w+::\w+\(', clean_lines.elided[i]) is not None
4955 def IsInitializerList(clean_lines, linenum):  argument
4966     line = clean_lines.elided[i]
4997 def CheckForNonConstReference(filename, clean_lines, linenum,  argument
5013   line = clean_lines.elided[linenum]
5020   if IsDerivedFunction(clean_lines, linenum):
5025   if IsOutOfLineMethodDefinition(clean_lines, linenum):
5049                         clean_lines.elided[linenum - 1])
5053                         clean_lines.elided[linenum - 1])
5061             clean_lines, linenum, endpos)
5067             line += clean_lines.elided[i].strip()
5091       previous_line = clean_lines.elided[i]
5102   if IsInitializerList(clean_lines, linenum):
5123           Search(whitelisted_functions, clean_lines.elided[linenum - i - 1])):
5136 def CheckCasts(filename, clean_lines, linenum, error):  argument
5145   line = clean_lines.elided[linenum]
5155   expecting_function = ExpectingFunctionArgs(clean_lines, linenum)
5197     CheckCStyleCast(filename, clean_lines, linenum, 'static_cast',
5204   if CheckCStyleCast(filename, clean_lines, linenum, 'const_cast',
5209     CheckCStyleCast(filename, clean_lines, linenum, 'reinterpret_cast',
5233       _, y1, x1 = CloseExpression(clean_lines, linenum, len(match.group(1)))
5234       if x1 >= 0 and clean_lines.elided[y1][x1] == '(':
5235         _, y2, x2 = CloseExpression(clean_lines, y1, x1)
5237           extended_line = clean_lines.elided[y2][x2:]
5238           if y2 < clean_lines.NumLines() - 1:
5239             extended_line += clean_lines.elided[y2 + 1]
5255 def CheckCStyleCast(filename, clean_lines, linenum, cast_type, pattern, error):  argument
5271   line = clean_lines.elided[linenum]
5285       context = clean_lines.elided[i] + context
5308 def ExpectingFunctionArgs(clean_lines, linenum):  argument
5319   line = clean_lines.elided[linenum]
5323                   clean_lines.elided[linenum - 1]) or
5325                   clean_lines.elided[linenum - 2]) or
5327                    clean_lines.elided[linenum - 1]))))
5482 def CheckForIncludeWhatYouUse(filename, clean_lines, include_state, error,  argument
5503   for linenum in xrange(clean_lines.NumLines()):
5504     line = clean_lines.elided[linenum]
5584 def CheckMakePairUsesDeduction(filename, clean_lines, linenum, error):  argument
5596   line = clean_lines.elided[linenum]
5605 def CheckRedundantVirtual(filename, clean_lines, linenum, error):  argument
5615   line = clean_lines.elided[linenum]
5639   for start_line in xrange(linenum, min(linenum + 3, clean_lines.NumLines())):
5640     line = clean_lines.elided[start_line][start_col:]
5645           clean_lines, start_line, start_col + len(parameter_list.group(1)))
5654   for i in xrange(end_line, min(end_line + 3, clean_lines.NumLines())):
5655     line = clean_lines.elided[i][end_col:]
5669 def CheckRedundantOverrideOrFinal(filename, clean_lines, linenum, error):  argument
5681   line = clean_lines.elided[linenum]
5686     if linenum > 1 and clean_lines.elided[linenum - 1].rfind(')') >= 0:
5764 def ProcessLine(filename, file_extension, clean_lines, line,  argument
5785   raw_lines = clean_lines.raw_lines
5787   nesting_state.Update(filename, clean_lines, line, error)
5788   CheckForNamespaceIndentation(filename, nesting_state, clean_lines, line,
5791   CheckForFunctionLengths(filename, clean_lines, line, function_state, error)
5792   CheckForMultilineCommentsAndStrings(filename, clean_lines, line, error)
5793   CheckStyle(filename, clean_lines, line, file_extension, nesting_state, error)
5794   CheckLanguage(filename, clean_lines, line, file_extension, include_state,
5796   CheckForNonConstReference(filename, clean_lines, line, nesting_state, error)
5797   CheckForNonStandardConstructs(filename, clean_lines, line,
5799   CheckVlogArguments(filename, clean_lines, line, error)
5800   CheckPosixThreading(filename, clean_lines, line, error)
5801   CheckInvalidIncrement(filename, clean_lines, line, error)
5802   CheckMakePairUsesDeduction(filename, clean_lines, line, error)
5803   CheckRedundantVirtual(filename, clean_lines, line, error)
5804   CheckRedundantOverrideOrFinal(filename, clean_lines, line, error)
5806     check_fn(filename, clean_lines, line, error)
5808 def FlagCxx11Features(filename, clean_lines, linenum, error):  argument
5817   line = clean_lines.elided[linenum]
5860 def FlagCxx14Features(filename, clean_lines, linenum, error):  argument
5869   line = clean_lines.elided[linenum]
5906   clean_lines = CleansedLines(lines)
5909     CheckForHeaderGuard(filename, clean_lines, error)
5911   for line in xrange(clean_lines.NumLines()):
5912     ProcessLine(filename, file_extension, clean_lines, line,
5915     FlagCxx11Features(filename, clean_lines, line, error)
5918   CheckForIncludeWhatYouUse(filename, clean_lines, include_state, error)