parameters: (self, filename, clean_lines, linenum, error)
docstring: Update nesting state with current 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.
docstring_summary: Update nesting state with current line.
docstring_tokens: Update nesting state with current line .
function: def Update(self, filename, clean_lines, linenum, error):
          """Update nesting state with current 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.
      """
          line = clean_lines.elided[linenum]
  
          # Remember top of the previous nesting stack.
          #
          # The stack is always pushed/popped and not modified in place, so
          # we can just do a shallow copy instead of copy.deepcopy.  Using
          # deepcopy would slow down cpplint by ~28%.
          if self.stack:
              self.previous_stack_top = self.stack[-1]
          else:
              self.previous_stack_top = None
  
          # Update pp_stack
          self.UpdatePreprocessor(line)
  
          # Count parentheses.  This is to avoid adding struct arguments to
          # the nesting stack.
          if self.stack:
              inner_block = self.stack[-1]
              depth_change = line.count('(') - line.count(')')
              inner_block.open_parentheses += depth_change
  
              # Also check if we are starting or ending an inline assembly block.
              if inner_block.inline_asm in (_NO_ASM, _END_ASM):
                  if (depth_change != 0 and
                          inner_block.open_parentheses == 1 and
                          _MATCH_ASM.match(line)):
                      # Enter assembly block
                      inner_block.inline_asm = _INSIDE_ASM
                  else:
                      # Not entering assembly block.  If previous line was _END_ASM,
                      # we will now shift to _NO_ASM state.
                      inner_block.inline_asm = _NO_ASM
              elif (inner_block.inline_asm == _INSIDE_ASM and
                    inner_block.open_parentheses == 0):
                  # Exit assembly block
                  inner_block.inline_asm = _END_ASM
  
          # Consume namespace declaration at the beginning of the line.  Do
          # this in a loop so that we catch same line declarations like this:
          #   namespace proto2 { namespace bridge { class MessageSet; } }
          while True:
              # Match start of namespace.  The "\b\s*" below catches namespace
              # declarations even if it weren't followed by a whitespace, this
              # is so that we don't confuse our namespace checker.  The
              # missing spaces will be flagged by CheckSpacing.
              namespace_decl_match = Match(r'^\s*namespace\b\s*([:\w]+)?(.*)$', line)
              if not namespace_decl_match:
                  break
  
              new_namespace = _NamespaceInfo(namespace_decl_match.group(1), linenum)
              self.stack.append(new_namespace)
  
              line = namespace_decl_match.group(2)
              if line.find('{') != -1:
                  new_namespace.seen_open_brace = True
                  line = line[line.find('{') + 1:]
  
          # Look for a class declaration in whatever is left of the line
          # after parsing namespaces.  The regexp accounts for decorated classes
          # such as in:
          #   class LOCKABLE API Object {
          #   };
          class_decl_match = Match(
              r'^(\s*(?:template\s*<[\w\s<>,:=]*>\s*)?'
              r'(class|struct)\s+(?:[A-Z_]+\s+)*(\w+(?:::\w+)*))'
              r'(.*)$', line)
          if (class_decl_match and
                  (not self.stack or self.stack[-1].open_parentheses == 0)):
              # We do not want to accept classes that are actually template arguments:
              #   template <class Ignore1,
              #             class Ignore2 = Default<Args>,
              #             template <Args> class Ignore3>
              #   void Function() {};
              #
              # To avoid template argument cases, we scan forward and look for
              # an unmatched '>'.  If we see one, assume we are inside a
              # template argument list.
              end_declaration = len(class_decl_match.group(1))
              if not self.InTemplateArgumentList(clean_lines, linenum, end_declaration):
                  self.stack.append(_ClassInfo(
                      class_decl_match.group(3), class_decl_match.group(2),
                      clean_lines, linenum))
                  line = class_decl_match.group(4)
  
          # If we have not yet seen the opening brace for the innermost block,
          # run checks here.
          if not self.SeenOpenBrace():
              self.stack[-1].CheckBegin(filename, clean_lines, linenum, error)
  
          # Update access control if we are inside a class/struct
          if self.stack and isinstance(self.stack[-1], _ClassInfo):
              classinfo = self.stack[-1]
              access_match = Match(
                  r'^(.*)\b(public|private|protected|signals)(\s+(?:slots\s*)?)?'
                  r':(?:[^:]|$)',
                  line)
              if access_match:
                  classinfo.access = access_match.group(2)
  
                  # Check that access keywords are indented +1 space.  Skip this
                  # check if the keywords are not preceded by whitespaces.
                  indent = access_match.group(1)
                  if (len(indent) != classinfo.class_indent + 1 and
                          Match(r'^\s*$', indent)):
                      if classinfo.is_struct:
                          parent = 'struct ' + classinfo.name
                      else:
                          parent = 'class ' + classinfo.name
                      slots = ''
                      if access_match.group(3):
                          slots = access_match.group(3)
                      error(filename, linenum, 'whitespace/indent', 3,
                            '%s%s: should be indented +1 space inside %s' % (
                                access_match.group(2), slots, parent))
  
          # Consume braces or semicolons from what's left of the line
          while True:
              # Match first brace, semicolon, or closed parenthesis.
              matched = Match(r'^[^{;)}]*([{;)}])(.*)$', line)
              if not matched:
                  break
  
              token = matched.group(1)
              if token == '{':
                  # If namespace or class hasn't seen a opening brace yet, mark
                  # namespace/class head as complete.  Push a new block onto the
                  # stack otherwise.
                  if not self.SeenOpenBrace():
                      self.stack[-1].seen_open_brace = True
                  elif Match(r'^extern\s*"[^"]*"\s*\{', line):
                      self.stack.append(_ExternCInfo(linenum))
                  else:
                      self.stack.append(_BlockInfo(linenum, True))
                      if _MATCH_ASM.match(line):
                          self.stack[-1].inline_asm = _BLOCK_ASM
  
              elif token == ';' or token == ')':
                  # If we haven't seen an opening brace yet, but we already saw
                  # a semicolon, this is probably a forward declaration.  Pop
                  # the stack for these.
                  #
                  # Similarly, if we haven't seen an opening brace yet, but we
                  # already saw a closing parenthesis, then these are probably
                  # function arguments with extra "class" or "struct" keywords.
                  # Also pop these stack for these.
                  if not self.SeenOpenBrace():
                      self.stack.pop()
              else:  # token == '}'
                  # Perform end of block checks and pop the stack.
                  if self.stack:
                      self.stack[-1].CheckEnd(filename, clean_lines, linenum, error)
                      self.stack.pop()
              line = matched.group(2)
function_tokens: def Update ( self , filename , clean_lines , linenum , error ) : line = clean_lines . elided [ linenum ] # Remember top of the previous nesting stack. # # The stack is always pushed/popped and not modified in place, so # we can just do a shallow copy instead of copy.deepcopy.  Using # deepcopy would slow down cpplint by ~28%. if self . stack : self . previous_stack_top = self . stack [ - 1 ] else : self . previous_stack_top = None # Update pp_stack self . UpdatePreprocessor ( line ) # Count parentheses.  This is to avoid adding struct arguments to # the nesting stack. if self . stack : inner_block = self . stack [ - 1 ] depth_change = line . count ( '(' ) - line . count ( ')' ) inner_block . open_parentheses += depth_change # Also check if we are starting or ending an inline assembly block. if inner_block . inline_asm in ( _NO_ASM , _END_ASM ) : if ( depth_change != 0 and inner_block . open_parentheses == 1 and _MATCH_ASM . match ( line ) ) : # Enter assembly block inner_block . inline_asm = _INSIDE_ASM else : # Not entering assembly block.  If previous line was _END_ASM, # we will now shift to _NO_ASM state. inner_block . inline_asm = _NO_ASM elif ( inner_block . inline_asm == _INSIDE_ASM and inner_block . open_parentheses == 0 ) : # Exit assembly block inner_block . inline_asm = _END_ASM # Consume namespace declaration at the beginning of the line.  Do # this in a loop so that we catch same line declarations like this: #   namespace proto2 { namespace bridge { class MessageSet; } } while True : # Match start of namespace.  The "\b\s*" below catches namespace # declarations even if it weren't followed by a whitespace, this # is so that we don't confuse our namespace checker.  The # missing spaces will be flagged by CheckSpacing. namespace_decl_match = Match ( r'^\s*namespace\b\s*([:\w]+)?(.*)$' , line ) if not namespace_decl_match : break new_namespace = _NamespaceInfo ( namespace_decl_match . group ( 1 ) , linenum ) self . stack . append ( new_namespace ) line = namespace_decl_match . group ( 2 ) if line . find ( '{' ) != - 1 : new_namespace . seen_open_brace = True line = line [ line . find ( '{' ) + 1 : ] # Look for a class declaration in whatever is left of the line # after parsing namespaces.  The regexp accounts for decorated classes # such as in: #   class LOCKABLE API Object { #   }; class_decl_match = Match ( r'^(\s*(?:template\s*<[\w\s<>,:=]*>\s*)?' r'(class|struct)\s+(?:[A-Z_]+\s+)*(\w+(?:::\w+)*))' r'(.*)$' , line ) if ( class_decl_match and ( not self . stack or self . stack [ - 1 ] . open_parentheses == 0 ) ) : # We do not want to accept classes that are actually template arguments: #   template <class Ignore1, #             class Ignore2 = Default<Args>, #             template <Args> class Ignore3> #   void Function() {}; # # To avoid template argument cases, we scan forward and look for # an unmatched '>'.  If we see one, assume we are inside a # template argument list. end_declaration = len ( class_decl_match . group ( 1 ) ) if not self . InTemplateArgumentList ( clean_lines , linenum , end_declaration ) : self . stack . append ( _ClassInfo ( class_decl_match . group ( 3 ) , class_decl_match . group ( 2 ) , clean_lines , linenum ) ) line = class_decl_match . group ( 4 ) # If we have not yet seen the opening brace for the innermost block, # run checks here. if not self . SeenOpenBrace ( ) : self . stack [ - 1 ] . CheckBegin ( filename , clean_lines , linenum , error ) # Update access control if we are inside a class/struct if self . stack and isinstance ( self . stack [ - 1 ] , _ClassInfo ) : classinfo = self . stack [ - 1 ] access_match = Match ( r'^(.*)\b(public|private|protected|signals)(\s+(?:slots\s*)?)?' r':(?:[^:]|$)' , line ) if access_match : classinfo . access = access_match . group ( 2 ) # Check that access keywords are indented +1 space.  Skip this # check if the keywords are not preceded by whitespaces. indent = access_match . group ( 1 ) if ( len ( indent ) != classinfo . class_indent + 1 and Match ( r'^\s*$' , indent ) ) : if classinfo . is_struct : parent = 'struct ' + classinfo . name else : parent = 'class ' + classinfo . name slots = '' if access_match . group ( 3 ) : slots = access_match . group ( 3 ) error ( filename , linenum , 'whitespace/indent' , 3 , '%s%s: should be indented +1 space inside %s' % ( access_match . group ( 2 ) , slots , parent ) ) # Consume braces or semicolons from what's left of the line while True : # Match first brace, semicolon, or closed parenthesis. matched = Match ( r'^[^{;)}]*([{;)}])(.*)$' , line ) if not matched : break token = matched . group ( 1 ) if token == '{' : # If namespace or class hasn't seen a opening brace yet, mark # namespace/class head as complete.  Push a new block onto the # stack otherwise. if not self . SeenOpenBrace ( ) : self . stack [ - 1 ] . seen_open_brace = True elif Match ( r'^extern\s*"[^"]*"\s*\{' , line ) : self . stack . append ( _ExternCInfo ( linenum ) ) else : self . stack . append ( _BlockInfo ( linenum , True ) ) if _MATCH_ASM . match ( line ) : self . stack [ - 1 ] . inline_asm = _BLOCK_ASM elif token == ';' or token == ')' : # If we haven't seen an opening brace yet, but we already saw # a semicolon, this is probably a forward declaration.  Pop # the stack for these. # # Similarly, if we haven't seen an opening brace yet, but we # already saw a closing parenthesis, then these are probably # function arguments with extra "class" or "struct" keywords. # Also pop these stack for these. if not self . SeenOpenBrace ( ) : self . stack . pop ( ) else : # token == '}' # Perform end of block checks and pop the stack. if self . stack : self . stack [ - 1 ] . CheckEnd ( filename , clean_lines , linenum , error ) self . stack . pop ( ) line = matched . group ( 2 )