wpiformat/wpiformat/cpplint.py
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)

    # 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)
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.
    
Update nesting state with current line.
Update nesting state with current line .
def Update(self, filename, clean_lines, linenum, error):
    line = clean_lines.elided[linenum]
     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)
     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)
def Update ( self , filename , clean_lines , linenum , error ) : line = clean_lines . elided [ linenum ] if self . stack : self . previous_stack_top = self . stack [ - 1 ] else : self . previous_stack_top = None self . UpdatePreprocessor ( line ) if self . stack : inner_block = self . stack [ - 1 ] depth_change = line . count ( '(' ) - line . count ( ')' ) inner_block . open_parentheses += depth_change 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 ) ) : inner_block . inline_asm = _INSIDE_ASM else : inner_block . inline_asm = _NO_ASM elif ( inner_block . inline_asm == _INSIDE_ASM and inner_block . open_parentheses == 0 ) : inner_block . inline_asm = _END_ASM while True : 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 : ] 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 ) ) : 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 not self . SeenOpenBrace ( ) : self . stack [ - 1 ] . CheckBegin ( filename , clean_lines , linenum , error ) 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 ) while True : matched = Match ( r'^[^{;)}]*([{;)}])(.*)$' , line ) if not matched : break token = matched . group ( 1 ) if token == '{' : 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 not self . SeenOpenBrace ( ) : self . stack . pop ( ) else : if self . stack : self . stack [ - 1 ] . CheckEnd ( filename , clean_lines , linenum , error ) self . stack . pop ( ) line = matched . group ( 2 )
Update nesting state with current line.
Update nesting state with current line .
"""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.
    """ # 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%. # Update pp_stack # Count parentheses.  This is to avoid adding struct arguments to # the nesting stack. # Also check if we are starting or ending an inline assembly block. # Enter assembly block # Not entering assembly block.  If previous line was _END_ASM, # we will now shift to _NO_ASM state. # Exit assembly block # 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; } } # 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. # 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 { #   }; # 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. # If we have not yet seen the opening brace for the innermost block, # run checks here. # Update access control if we are inside a class/struct # Consume braces or semicolons from what's left of the line # Match first brace, semicolon, or closed parenthesis. # 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 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. # token == '}' # Perform end of block checks and pop the stack.
self
filename
The name of the current file.
The name of the current file .
clean_lines
A CleansedLines instance containing the file.
A CleansedLines instance containing the file .
linenum
The number of the line to check.
The number of the line to check .
error
The function to call with any errors found.
The function to call with any errors found .