proxygen: cpp.ast.AstBuilder Class Reference

def cpp.ast.AstBuilder.__init__	(	self,
		token_stream,
		filename,
		in_class = `''`,
		visibility = `None`,
		namespace_stack = `[]`
	)

Definition at line 678 of file ast.py.

                  namespace_stack=[]):
         self.tokens = token_stream
         self.filename = filename
         # TODO(nnorwitz): use a better data structure (deque) for the queue.
         # Switching directions of the "queue" improved perf by about 25%.
         # Using a deque should be even better since we access from both sides.
         self.token_queue = []
         self.namespace_stack = namespace_stack[:]
         self.in_class = in_class
         if in_class is None:
             self.in_class_name_only = None
         else:
             self.in_class_name_only = in_class.split('::')[-1]
         self.visibility = visibility
         self.in_function = False
         self.current_token = None
         # Keep the state whether we are currently handling a typedef or not.
         self._handling_typedef = False
 
         self.converter = TypeConverter(self.namespace_stack)
 

def cpp.ast.AstBuilder.__init__	(	self,
		token_stream,
		filename,
		in_class = `''`,
		visibility = `None`,
		namespace_stack = `[]`
	)

Definition at line 678 of file ast.py.

References cpp.ast.AstBuilder._handling_typedef, cpp.ast.AstBuilder.converter, cpp.ast.AstBuilder.current_token, cpp.ast.Include.filename, cpp.ast.AstBuilder.filename, cpp.ast.Method.in_class, cpp.ast.AstBuilder.in_class, cpp.ast.AstBuilder.in_class_name_only, cpp.ast.AstBuilder.in_function, cpp.ast.TypeConverter.namespace_stack, cpp.ast.AstBuilder.namespace_stack, cpp.ast.AstBuilder.token_queue, cpp.ast.AstBuilder.tokens, and cpp.ast.AstBuilder.visibility.

                  namespace_stack=[]):
         self.tokens = token_stream
         self.filename = filename
         # TODO(nnorwitz): use a better data structure (deque) for the queue.
         # Switching directions of the "queue" improved perf by about 25%.
         # Using a deque should be even better since we access from both sides.
         self.token_queue = []
         self.namespace_stack = namespace_stack[:]
         self.in_class = in_class
         if in_class is None:
             self.in_class_name_only = None
         else:
             self.in_class_name_only = in_class.split('::')[-1]
         self.visibility = visibility
         self.in_function = False
         self.current_token = None
         # Keep the state whether we are currently handling a typedef or not.
         self._handling_typedef = False
 
         self.converter = TypeConverter(self.namespace_stack)
 

def cpp.ast.AstBuilder.__init__	(	self,
		token_stream,
		filename,
		in_class = `''`,
		visibility = `None`,
		namespace_stack = `[]`
	)

Definition at line 678 of file ast.py.

References cpp.ast.AstBuilder._handling_typedef, cpp.ast.AstBuilder.converter, cpp.ast.AstBuilder.current_token, cpp.ast.Include.filename, cpp.ast.AstBuilder.filename, cpp.ast.Method.in_class, cpp.ast.AstBuilder.in_class, cpp.ast.AstBuilder.in_class_name_only, cpp.ast.AstBuilder.in_function, cpp.ast.TypeConverter.namespace_stack, cpp.ast.AstBuilder.namespace_stack, cpp.ast.AstBuilder.token_queue, cpp.ast.AstBuilder.tokens, and cpp.ast.AstBuilder.visibility.

                  namespace_stack=[]):
         self.tokens = token_stream
         self.filename = filename
         # TODO(nnorwitz): use a better data structure (deque) for the queue.
         # Switching directions of the "queue" improved perf by about 25%.
         # Using a deque should be even better since we access from both sides.
         self.token_queue = []
         self.namespace_stack = namespace_stack[:]
         self.in_class = in_class
         if in_class is None:
             self.in_class_name_only = None
         else:
             self.in_class_name_only = in_class.split('::')[-1]
         self.visibility = visibility
         self.in_function = False
         self.current_token = None
         # Keep the state whether we are currently handling a typedef or not.
         self._handling_typedef = False
 
         self.converter = TypeConverter(self.namespace_stack)
 

def cpp.ast.AstBuilder._AddBackToken	(	self,
		token
	)

private

Definition at line 910 of file ast.py.

Referenced by cpp.ast.AstBuilder._AddBackToken(), cpp.ast.AstBuilder._GenerateOne(), cpp.ast.AstBuilder._GetBases(), cpp.ast.AstBuilder._GetClass(), cpp.ast.AstBuilder.handle_namespace(), cpp.ast.AstBuilder.handle_struct(), and cpp.ast.AstBuilder.handle_template().

     def _AddBackToken(self, token):
         if token.whence == tokenize.WHENCE_STREAM:
             token.whence = tokenize.WHENCE_QUEUE
             self.token_queue.insert(0, token)
         else:
             assert token.whence == tokenize.WHENCE_QUEUE, token
             self.token_queue.append(token)
 

def cpp.ast.AstBuilder._AddBackToken	(	self,
		token
	)

private

Definition at line 910 of file ast.py.

References cpp.ast.AstBuilder._AddBackToken().

     def _AddBackToken(self, token):
         if token.whence == tokenize.WHENCE_STREAM:
             token.whence = tokenize.WHENCE_QUEUE
             self.token_queue.insert(0, token)
         else:
             assert token.whence == tokenize.WHENCE_QUEUE, token
             self.token_queue.append(token)
 

def cpp.ast.AstBuilder._AddBackToken	(	self,
		token
	)

private

Definition at line 910 of file ast.py.

References cpp.ast.AstBuilder._AddBackToken().

     def _AddBackToken(self, token):
         if token.whence == tokenize.WHENCE_STREAM:
             token.whence = tokenize.WHENCE_QUEUE
             self.token_queue.insert(0, token)
         else:
             assert token.whence == tokenize.WHENCE_QUEUE, token
             self.token_queue.append(token)
 

def cpp.ast.AstBuilder._AddBackTokens	(	self,
		tokens
	)

private

Definition at line 918 of file ast.py.

References cpp.ast.AstBuilder._AddBackTokens(), cpp.ast.reversed(), and cpp.ast.AstBuilder.token_queue.

     def _AddBackTokens(self, tokens):
         if tokens:
             if tokens[-1].whence == tokenize.WHENCE_STREAM:
                 for token in tokens:
                     token.whence = tokenize.WHENCE_QUEUE
                 self.token_queue[:0] = reversed(tokens)
             else:
                 assert tokens[-1].whence == tokenize.WHENCE_QUEUE, tokens
                 self.token_queue.extend(reversed(tokens))
 

def cpp.ast.AstBuilder._AddBackTokens	(	self,
		tokens
	)

private

Definition at line 918 of file ast.py.

References cpp.ast.reversed(), and cpp.ast.AstBuilder.token_queue.

Referenced by cpp.ast.AstBuilder._AddBackTokens(), cpp.ast.AstBuilder._GenerateOne(), cpp.ast.AstBuilder._GetClass(), cpp.ast.AstBuilder.handle_namespace(), cpp.ast.AstBuilder.handle_struct(), and cpp.ast.AstBuilder.handle_template().

     def _AddBackTokens(self, tokens):
         if tokens:
             if tokens[-1].whence == tokenize.WHENCE_STREAM:
                 for token in tokens:
                     token.whence = tokenize.WHENCE_QUEUE
                 self.token_queue[:0] = reversed(tokens)
             else:
                 assert tokens[-1].whence == tokenize.WHENCE_QUEUE, tokens
                 self.token_queue.extend(reversed(tokens))
 

def cpp.ast.AstBuilder._AddBackTokens	(	self,
		tokens
	)

private

Definition at line 918 of file ast.py.

References cpp.ast.AstBuilder._AddBackTokens(), cpp.ast.reversed(), and cpp.ast.AstBuilder.token_queue.

     def _AddBackTokens(self, tokens):
         if tokens:
             if tokens[-1].whence == tokenize.WHENCE_STREAM:
                 for token in tokens:
                     token.whence = tokenize.WHENCE_QUEUE
                 self.token_queue[:0] = reversed(tokens)
             else:
                 assert tokens[-1].whence == tokenize.WHENCE_QUEUE, tokens
                 self.token_queue.extend(reversed(tokens))
 

def cpp.ast.AstBuilder._CreateVariable	(	self,
		pos_token,
		name,
		type_name,
		type_modifiers,
		ref_pointer_name_seq,
		templated_types,
		value = `None`
	)

private

Definition at line 728 of file ast.py.

References cpp.ast.TypeConverter.namespace_stack, and cpp.ast.AstBuilder.namespace_stack.

                         ref_pointer_name_seq, templated_types, value=None):
         reference = '&' in ref_pointer_name_seq
         pointer = '*' in ref_pointer_name_seq
         array = '[' in ref_pointer_name_seq
         var_type = Type(pos_token.start, pos_token.end, type_name,
                         templated_types, type_modifiers,
                         reference, pointer, array)
         return VariableDeclaration(pos_token.start, pos_token.end,
                                    name, var_type, value, self.namespace_stack)
 

def cpp.ast.AstBuilder._CreateVariable	(	self,
		pos_token,
		name,
		type_name,
		type_modifiers,
		ref_pointer_name_seq,
		templated_types,
		value = `None`
	)

private

Definition at line 728 of file ast.py.

References cpp.ast.TypeConverter.namespace_stack, and cpp.ast.AstBuilder.namespace_stack.

                         ref_pointer_name_seq, templated_types, value=None):
         reference = '&' in ref_pointer_name_seq
         pointer = '*' in ref_pointer_name_seq
         array = '[' in ref_pointer_name_seq
         var_type = Type(pos_token.start, pos_token.end, type_name,
                         templated_types, type_modifiers,
                         reference, pointer, array)
         return VariableDeclaration(pos_token.start, pos_token.end,
                                    name, var_type, value, self.namespace_stack)
 

def cpp.ast.AstBuilder._CreateVariable	(	self,
		pos_token,
		name,
		type_name,
		type_modifiers,
		ref_pointer_name_seq,
		templated_types,
		value = `None`
	)

private

Definition at line 728 of file ast.py.

References cpp.ast.TypeConverter.namespace_stack, and cpp.ast.AstBuilder.namespace_stack.

Referenced by cpp.ast.AstBuilder._GenerateOne(), cpp.ast.AstBuilder._GetClass(), cpp.ast.AstBuilder._GetMethod(), cpp.ast.AstBuilder.Generate(), and cpp.ast.AstBuilder.handle_struct().

                         ref_pointer_name_seq, templated_types, value=None):
         reference = '&' in ref_pointer_name_seq
         pointer = '*' in ref_pointer_name_seq
         array = '[' in ref_pointer_name_seq
         var_type = Type(pos_token.start, pos_token.end, type_name,
                         templated_types, type_modifiers,
                         reference, pointer, array)
         return VariableDeclaration(pos_token.start, pos_token.end,
                                    name, var_type, value, self.namespace_stack)
 

def cpp.ast.AstBuilder._GenerateOne	(	self,
		token
	)

private

Definition at line 738 of file ast.py.

References cpp.ast.AstBuilder._AddBackToken(), cpp.ast.AstBuilder._AddBackTokens(), cpp.ast.AstBuilder._CreateVariable(), cpp.ast.AstBuilder._GetMethod(), cpp.ast.AstBuilder._GetNextToken(), cpp.ast.AstBuilder._GetTokensUpTo(), cpp.ast.AstBuilder._GetVarTokensUpTo(), cpp.ast.AstBuilder._SkipIf0Blocks(), folly.enumerate(), cpp.ast.Method.in_class, cpp.ast.AstBuilder.in_class, cpp.ast.AstBuilder.in_class_name_only, join, and folly::detail::distributed_mutex.strip().

Referenced by cpp.ast.AstBuilder._GenerateOne(), and cpp.ast.AstBuilder.Generate().

     def _GenerateOne(self, token):
         if token.token_type == tokenize.NAME:
             if (keywords.IsKeyword(token.name) and
                 not keywords.IsBuiltinType(token.name)):
                 method = getattr(self, 'handle_' + token.name)
                 return method()
             elif token.name == self.in_class_name_only:
                 # The token name is the same as the class, must be a ctor if
                 # there is a paren.  Otherwise, it's the return type.
                 # Peek ahead to get the next token to figure out which.
                 next = self._GetNextToken()
                 self._AddBackToken(next)
                 if next.token_type == tokenize.SYNTAX and next.name == '(':
                     return self._GetMethod([token], FUNCTION_CTOR, None, True)
                 # Fall through--handle like any other method.
 
             # Handle data or function declaration/definition.
             syntax = tokenize.SYNTAX
             temp_tokens, last_token = \
                 self._GetVarTokensUpTo(syntax, '(', ';', '{', '[')
             temp_tokens.insert(0, token)
             if last_token.name == '(':
                 # If there is an assignment before the paren,
                 # this is an expression, not a method.
                 expr = bool([e for e in temp_tokens if e.name == '='])
                 if expr:
                     new_temp = self._GetTokensUpTo(tokenize.SYNTAX, ';')
                     temp_tokens.append(last_token)
                     temp_tokens.extend(new_temp)
                     last_token = tokenize.Token(tokenize.SYNTAX, ';', 0, 0)
 
             if last_token.name == '[':
                 # Handle array, this isn't a method, unless it's an operator.
                 # TODO(nnorwitz): keep the size somewhere.
                 # unused_size = self._GetTokensUpTo(tokenize.SYNTAX, ']')
                 temp_tokens.append(last_token)
                 if temp_tokens[-2].name == 'operator':
                     temp_tokens.append(self._GetNextToken())
                 else:
                     temp_tokens2, last_token = \
                         self._GetVarTokensUpTo(tokenize.SYNTAX, ';')
                     temp_tokens.extend(temp_tokens2)
 
             if last_token.name == ';':
                 # Handle data, this isn't a method.
                 parts = self.converter.DeclarationToParts(temp_tokens, True)
                 (name, type_name, templated_types, modifiers, default,
                  unused_other_tokens) = parts
 
                 t0 = temp_tokens[0]
                 names = [t.name for t in temp_tokens]
                 if templated_types:
                     start, end = self.converter.GetTemplateIndices(names)
                     names = names[:start] + names[end:]
                 default = ''.join([t.name for t in default])
                 return self._CreateVariable(t0, name, type_name, modifiers,
                                             names, templated_types, default)
             if last_token.name == '{':
                 self._AddBackTokens(temp_tokens[1:])
                 self._AddBackToken(last_token)
                 method_name = temp_tokens[0].name
                 method = getattr(self, 'handle_' + method_name, None)
                 if not method:
                     # Must be declaring a variable.
                     # TODO(nnorwitz): handle the declaration.
                     return None
                 return method()
             return self._GetMethod(temp_tokens, 0, None, False)
         elif token.token_type == tokenize.SYNTAX:
             if token.name == '~' and self.in_class:
                 # Must be a dtor (probably not in method body).
                 token = self._GetNextToken()
                 # self.in_class can contain A::Name, but the dtor will only
                 # be Name.  Make sure to compare against the right value.
                 if (token.token_type == tokenize.NAME and
                     token.name == self.in_class_name_only):
                     return self._GetMethod([token], FUNCTION_DTOR, None, True)
             # TODO(nnorwitz): handle a lot more syntax.
         elif token.token_type == tokenize.PREPROCESSOR:
             # TODO(nnorwitz): handle more preprocessor directives.
             # token starts with a #, so remove it and strip whitespace.
             name = token.name[1:].lstrip()
             if name.startswith('include'):
                 # Remove "include".
                 name = name[7:].strip()
                 assert name
                 # Handle #include <newline> "header-on-second-line.h".
                 if name.startswith('\\'):
                     name = name[1:].strip()
                 assert name[0] in '<"', token
                 assert name[-1] in '>"', token
                 system = name[0] == '<'
                 filename = name[1:-1]
                 return Include(token.start, token.end, filename, system)
             if name.startswith('define'):
                 # Remove "define".
                 name = name[6:].strip()
                 assert name
                 value = ''
                 for i, c in enumerate(name):
                     if c.isspace():
                         value = name[i:].lstrip()
                         name = name[:i]
                         break
                 return Define(token.start, token.end, name, value)
             if name.startswith('if') and name[2:3].isspace():
                 condition = name[3:].strip()
                 if condition.startswith('0') or condition.startswith('(0)'):
                     self._SkipIf0Blocks()
         return None
 

def cpp.ast.AstBuilder._GenerateOne	(	self,
		token
	)

private

Definition at line 738 of file ast.py.

     def _GenerateOne(self, token):
         if token.token_type == tokenize.NAME:
             if (keywords.IsKeyword(token.name) and
                 not keywords.IsBuiltinType(token.name)):
                 method = getattr(self, 'handle_' + token.name)
                 return method()
             elif token.name == self.in_class_name_only:
                 # The token name is the same as the class, must be a ctor if
                 # there is a paren.  Otherwise, it's the return type.
                 # Peek ahead to get the next token to figure out which.
                 next = self._GetNextToken()
                 self._AddBackToken(next)
                 if next.token_type == tokenize.SYNTAX and next.name == '(':
                     return self._GetMethod([token], FUNCTION_CTOR, None, True)
                 # Fall through--handle like any other method.
 
             # Handle data or function declaration/definition.
             syntax = tokenize.SYNTAX
             temp_tokens, last_token = \
                 self._GetVarTokensUpTo(syntax, '(', ';', '{', '[')
             temp_tokens.insert(0, token)
             if last_token.name == '(':
                 # If there is an assignment before the paren,
                 # this is an expression, not a method.
                 expr = bool([e for e in temp_tokens if e.name == '='])
                 if expr:
                     new_temp = self._GetTokensUpTo(tokenize.SYNTAX, ';')
                     temp_tokens.append(last_token)
                     temp_tokens.extend(new_temp)
                     last_token = tokenize.Token(tokenize.SYNTAX, ';', 0, 0)
 
             if last_token.name == '[':
                 # Handle array, this isn't a method, unless it's an operator.
                 # TODO(nnorwitz): keep the size somewhere.
                 # unused_size = self._GetTokensUpTo(tokenize.SYNTAX, ']')
                 temp_tokens.append(last_token)
                 if temp_tokens[-2].name == 'operator':
                     temp_tokens.append(self._GetNextToken())
                 else:
                     temp_tokens2, last_token = \
                         self._GetVarTokensUpTo(tokenize.SYNTAX, ';')
                     temp_tokens.extend(temp_tokens2)
 
             if last_token.name == ';':
                 # Handle data, this isn't a method.
                 parts = self.converter.DeclarationToParts(temp_tokens, True)
                 (name, type_name, templated_types, modifiers, default,
                  unused_other_tokens) = parts
 
                 t0 = temp_tokens[0]
                 names = [t.name for t in temp_tokens]
                 if templated_types:
                     start, end = self.converter.GetTemplateIndices(names)
                     names = names[:start] + names[end:]
                 default = ''.join([t.name for t in default])
                 return self._CreateVariable(t0, name, type_name, modifiers,
                                             names, templated_types, default)
             if last_token.name == '{':
                 self._AddBackTokens(temp_tokens[1:])
                 self._AddBackToken(last_token)
                 method_name = temp_tokens[0].name
                 method = getattr(self, 'handle_' + method_name, None)
                 if not method:
                     # Must be declaring a variable.
                     # TODO(nnorwitz): handle the declaration.
                     return None
                 return method()
             return self._GetMethod(temp_tokens, 0, None, False)
         elif token.token_type == tokenize.SYNTAX:
             if token.name == '~' and self.in_class:
                 # Must be a dtor (probably not in method body).
                 token = self._GetNextToken()
                 # self.in_class can contain A::Name, but the dtor will only
                 # be Name.  Make sure to compare against the right value.
                 if (token.token_type == tokenize.NAME and
                     token.name == self.in_class_name_only):
                     return self._GetMethod([token], FUNCTION_DTOR, None, True)
             # TODO(nnorwitz): handle a lot more syntax.
         elif token.token_type == tokenize.PREPROCESSOR:
             # TODO(nnorwitz): handle more preprocessor directives.
             # token starts with a #, so remove it and strip whitespace.
             name = token.name[1:].lstrip()
             if name.startswith('include'):
                 # Remove "include".
                 name = name[7:].strip()
                 assert name
                 # Handle #include <newline> "header-on-second-line.h".
                 if name.startswith('\\'):
                     name = name[1:].strip()
                 assert name[0] in '<"', token
                 assert name[-1] in '>"', token
                 system = name[0] == '<'
                 filename = name[1:-1]
                 return Include(token.start, token.end, filename, system)
             if name.startswith('define'):
                 # Remove "define".
                 name = name[6:].strip()
                 assert name
                 value = ''
                 for i, c in enumerate(name):
                     if c.isspace():
                         value = name[i:].lstrip()
                         name = name[:i]
                         break
                 return Define(token.start, token.end, name, value)
             if name.startswith('if') and name[2:3].isspace():
                 condition = name[3:].strip()
                 if condition.startswith('0') or condition.startswith('(0)'):
                     self._SkipIf0Blocks()
         return None
 

def cpp.ast.AstBuilder._GenerateOne	(	self,
		token
	)

private

Definition at line 738 of file ast.py.

     def _GenerateOne(self, token):
         if token.token_type == tokenize.NAME:
             if (keywords.IsKeyword(token.name) and
                 not keywords.IsBuiltinType(token.name)):
                 method = getattr(self, 'handle_' + token.name)
                 return method()
             elif token.name == self.in_class_name_only:
                 # The token name is the same as the class, must be a ctor if
                 # there is a paren.  Otherwise, it's the return type.
                 # Peek ahead to get the next token to figure out which.
                 next = self._GetNextToken()
                 self._AddBackToken(next)
                 if next.token_type == tokenize.SYNTAX and next.name == '(':
                     return self._GetMethod([token], FUNCTION_CTOR, None, True)
                 # Fall through--handle like any other method.
 
             # Handle data or function declaration/definition.
             syntax = tokenize.SYNTAX
             temp_tokens, last_token = \
                 self._GetVarTokensUpTo(syntax, '(', ';', '{', '[')
             temp_tokens.insert(0, token)
             if last_token.name == '(':
                 # If there is an assignment before the paren,
                 # this is an expression, not a method.
                 expr = bool([e for e in temp_tokens if e.name == '='])
                 if expr:
                     new_temp = self._GetTokensUpTo(tokenize.SYNTAX, ';')
                     temp_tokens.append(last_token)
                     temp_tokens.extend(new_temp)
                     last_token = tokenize.Token(tokenize.SYNTAX, ';', 0, 0)
 
             if last_token.name == '[':
                 # Handle array, this isn't a method, unless it's an operator.
                 # TODO(nnorwitz): keep the size somewhere.
                 # unused_size = self._GetTokensUpTo(tokenize.SYNTAX, ']')
                 temp_tokens.append(last_token)
                 if temp_tokens[-2].name == 'operator':
                     temp_tokens.append(self._GetNextToken())
                 else:
                     temp_tokens2, last_token = \
                         self._GetVarTokensUpTo(tokenize.SYNTAX, ';')
                     temp_tokens.extend(temp_tokens2)
 
             if last_token.name == ';':
                 # Handle data, this isn't a method.
                 parts = self.converter.DeclarationToParts(temp_tokens, True)
                 (name, type_name, templated_types, modifiers, default,
                  unused_other_tokens) = parts
 
                 t0 = temp_tokens[0]
                 names = [t.name for t in temp_tokens]
                 if templated_types:
                     start, end = self.converter.GetTemplateIndices(names)
                     names = names[:start] + names[end:]
                 default = ''.join([t.name for t in default])
                 return self._CreateVariable(t0, name, type_name, modifiers,
                                             names, templated_types, default)
             if last_token.name == '{':
                 self._AddBackTokens(temp_tokens[1:])
                 self._AddBackToken(last_token)
                 method_name = temp_tokens[0].name
                 method = getattr(self, 'handle_' + method_name, None)
                 if not method:
                     # Must be declaring a variable.
                     # TODO(nnorwitz): handle the declaration.
                     return None
                 return method()
             return self._GetMethod(temp_tokens, 0, None, False)
         elif token.token_type == tokenize.SYNTAX:
             if token.name == '~' and self.in_class:
                 # Must be a dtor (probably not in method body).
                 token = self._GetNextToken()
                 # self.in_class can contain A::Name, but the dtor will only
                 # be Name.  Make sure to compare against the right value.
                 if (token.token_type == tokenize.NAME and
                     token.name == self.in_class_name_only):
                     return self._GetMethod([token], FUNCTION_DTOR, None, True)
             # TODO(nnorwitz): handle a lot more syntax.
         elif token.token_type == tokenize.PREPROCESSOR:
             # TODO(nnorwitz): handle more preprocessor directives.
             # token starts with a #, so remove it and strip whitespace.
             name = token.name[1:].lstrip()
             if name.startswith('include'):
                 # Remove "include".
                 name = name[7:].strip()
                 assert name
                 # Handle #include <newline> "header-on-second-line.h".
                 if name.startswith('\\'):
                     name = name[1:].strip()
                 assert name[0] in '<"', token
                 assert name[-1] in '>"', token
                 system = name[0] == '<'
                 filename = name[1:-1]
                 return Include(token.start, token.end, filename, system)
             if name.startswith('define'):
                 # Remove "define".
                 name = name[6:].strip()
                 assert name
                 value = ''
                 for i, c in enumerate(name):
                     if c.isspace():
                         value = name[i:].lstrip()
                         name = name[:i]
                         break
                 return Define(token.start, token.end, name, value)
             if name.startswith('if') and name[2:3].isspace():
                 condition = name[3:].strip()
                 if condition.startswith('0') or condition.startswith('(0)'):
                     self._SkipIf0Blocks()
         return None
 

def cpp.ast.AstBuilder._GetBases ( self )

private

Definition at line 1457 of file ast.py.

References cpp.ast.AstBuilder._AddBackToken(), cpp.ast.AstBuilder._GetBases(), cpp.ast.AstBuilder._GetNextToken(), and cpp.ast.AstBuilder.GetName().

     def _GetBases(self):
         # Get base classes.
         bases = []
         while 1:
             token = self._GetNextToken()
             assert token.token_type == tokenize.NAME, token
             # TODO(nnorwitz): store kind of inheritance...maybe.
             if token.name not in ('public', 'protected', 'private'):
                 # If inheritance type is not specified, it is private.
                 # Just put the token back so we can form a name.
                 # TODO(nnorwitz): it would be good to warn about this.
                 self._AddBackToken(token)
             else:
                 # Check for virtual inheritance.
                 token = self._GetNextToken()
                 if token.name != 'virtual':
                     self._AddBackToken(token)
                 else:
                     # TODO(nnorwitz): store that we got virtual for this base.
                     pass
             base, next_token = self.GetName()
             bases_ast = self.converter.ToType(base)
             assert len(bases_ast) == 1, bases_ast
             bases.append(bases_ast[0])
             assert next_token.token_type == tokenize.SYNTAX, next_token
             if next_token.name == '{':
                 token = next_token
                 break
             # Support multiple inheritance.
             assert next_token.name == ',', next_token
         return bases, token
 

def cpp.ast.AstBuilder._GetBases ( self )

private

Definition at line 1457 of file ast.py.

References cpp.ast.AstBuilder._AddBackToken(), cpp.ast.AstBuilder._GetBases(), cpp.ast.AstBuilder._GetNextToken(), and cpp.ast.AstBuilder.GetName().

     def _GetBases(self):
         # Get base classes.
         bases = []
         while 1:
             token = self._GetNextToken()
             assert token.token_type == tokenize.NAME, token
             # TODO(nnorwitz): store kind of inheritance...maybe.
             if token.name not in ('public', 'protected', 'private'):
                 # If inheritance type is not specified, it is private.
                 # Just put the token back so we can form a name.
                 # TODO(nnorwitz): it would be good to warn about this.
                 self._AddBackToken(token)
             else:
                 # Check for virtual inheritance.
                 token = self._GetNextToken()
                 if token.name != 'virtual':
                     self._AddBackToken(token)
                 else:
                     # TODO(nnorwitz): store that we got virtual for this base.
                     pass
             base, next_token = self.GetName()
             bases_ast = self.converter.ToType(base)
             assert len(bases_ast) == 1, bases_ast
             bases.append(bases_ast[0])
             assert next_token.token_type == tokenize.SYNTAX, next_token
             if next_token.name == '{':
                 token = next_token
                 break
             # Support multiple inheritance.
             assert next_token.name == ',', next_token
         return bases, token
 

def cpp.ast.AstBuilder._GetBases ( self )

private

Definition at line 1457 of file ast.py.

References cpp.ast.AstBuilder._AddBackToken(), cpp.ast.AstBuilder._GetNextToken(), and cpp.ast.AstBuilder.GetName().

Referenced by cpp.ast.AstBuilder._GetBases(), and cpp.ast.AstBuilder._GetClass().

     def _GetBases(self):
         # Get base classes.
         bases = []
         while 1:
             token = self._GetNextToken()
             assert token.token_type == tokenize.NAME, token
             # TODO(nnorwitz): store kind of inheritance...maybe.
             if token.name not in ('public', 'protected', 'private'):
                 # If inheritance type is not specified, it is private.
                 # Just put the token back so we can form a name.
                 # TODO(nnorwitz): it would be good to warn about this.
                 self._AddBackToken(token)
             else:
                 # Check for virtual inheritance.
                 token = self._GetNextToken()
                 if token.name != 'virtual':
                     self._AddBackToken(token)
                 else:
                     # TODO(nnorwitz): store that we got virtual for this base.
                     pass
             base, next_token = self.GetName()
             bases_ast = self.converter.ToType(base)
             assert len(bases_ast) == 1, bases_ast
             bases.append(bases_ast[0])
             assert next_token.token_type == tokenize.SYNTAX, next_token
             if next_token.name == '{':
                 token = next_token
                 break
             # Support multiple inheritance.
             assert next_token.name == ',', next_token
         return bases, token
 

def cpp.ast.AstBuilder._GetClass	(	self,
		class_type,
		visibility,
		templated_types
	)

private

Definition at line 1489 of file ast.py.

     def _GetClass(self, class_type, visibility, templated_types):
         class_name = None
         class_token = self._GetNextToken()
         if class_token.token_type != tokenize.NAME:
             assert class_token.token_type == tokenize.SYNTAX, class_token
             token = class_token
         else:
             # Skip any macro (e.g. storage class specifiers) after the
             # 'class' keyword.
             next_token = self._GetNextToken()
             if next_token.token_type == tokenize.NAME:
                 self._AddBackToken(next_token)
             else:
                 self._AddBackTokens([class_token, next_token])
             name_tokens, token = self.GetName()
             class_name = ''.join([t.name for t in name_tokens])
         bases = None
         if token.token_type == tokenize.SYNTAX:
             if token.name == ';':
                 # Forward declaration.
                 return class_type(class_token.start, class_token.end,
                                   class_name, None, templated_types, None,
                                   self.namespace_stack)
             if token.name in '*&':
                 # Inline forward declaration.  Could be method or data.
                 name_token = self._GetNextToken()
                 next_token = self._GetNextToken()
                 if next_token.name == ';':
                     # Handle data
                     modifiers = ['class']
                     return self._CreateVariable(class_token, name_token.name,
                                                 class_name,
                                                 modifiers, token.name, None)
                 else:
                     # Assume this is a method.
                     tokens = (class_token, token, name_token, next_token)
                     self._AddBackTokens(tokens)
                     return self.GetMethod(FUNCTION_NONE, None)
             if token.name == ':':
                 bases, token = self._GetBases()
 
         body = None
         if token.token_type == tokenize.SYNTAX and token.name == '{':
             assert token.token_type == tokenize.SYNTAX, token
             assert token.name == '{', token
 
             ast = AstBuilder(self.GetScope(), self.filename, class_name,
                              visibility, self.namespace_stack)
             body = list(ast.Generate())
 
             if not self._handling_typedef:
                 token = self._GetNextToken()
                 if token.token_type != tokenize.NAME:
                     assert token.token_type == tokenize.SYNTAX, token
                     assert token.name == ';', token
                 else:
                     new_class = class_type(class_token.start, class_token.end,
                                            class_name, bases, None,
                                            body, self.namespace_stack)
 
                     modifiers = []
                     return self._CreateVariable(class_token,
                                                 token.name, new_class,
                                                 modifiers, token.name, None)
         else:
             if not self._handling_typedef:
                 self.HandleError('non-typedef token', token)
             self._AddBackToken(token)
 
         return class_type(class_token.start, class_token.end, class_name,
                           bases, templated_types, body, self.namespace_stack)
 

def cpp.ast.AstBuilder._GetClass	(	self,
		class_type,
		visibility,
		templated_types
	)

private

Definition at line 1489 of file ast.py.

     def _GetClass(self, class_type, visibility, templated_types):
         class_name = None
         class_token = self._GetNextToken()
         if class_token.token_type != tokenize.NAME:
             assert class_token.token_type == tokenize.SYNTAX, class_token
             token = class_token
         else:
             # Skip any macro (e.g. storage class specifiers) after the
             # 'class' keyword.
             next_token = self._GetNextToken()
             if next_token.token_type == tokenize.NAME:
                 self._AddBackToken(next_token)
             else:
                 self._AddBackTokens([class_token, next_token])
             name_tokens, token = self.GetName()
             class_name = ''.join([t.name for t in name_tokens])
         bases = None
         if token.token_type == tokenize.SYNTAX:
             if token.name == ';':
                 # Forward declaration.
                 return class_type(class_token.start, class_token.end,
                                   class_name, None, templated_types, None,
                                   self.namespace_stack)
             if token.name in '*&':
                 # Inline forward declaration.  Could be method or data.
                 name_token = self._GetNextToken()
                 next_token = self._GetNextToken()
                 if next_token.name == ';':
                     # Handle data
                     modifiers = ['class']
                     return self._CreateVariable(class_token, name_token.name,
                                                 class_name,
                                                 modifiers, token.name, None)
                 else:
                     # Assume this is a method.
                     tokens = (class_token, token, name_token, next_token)
                     self._AddBackTokens(tokens)
                     return self.GetMethod(FUNCTION_NONE, None)
             if token.name == ':':
                 bases, token = self._GetBases()
 
         body = None
         if token.token_type == tokenize.SYNTAX and token.name == '{':
             assert token.token_type == tokenize.SYNTAX, token
             assert token.name == '{', token
 
             ast = AstBuilder(self.GetScope(), self.filename, class_name,
                              visibility, self.namespace_stack)
             body = list(ast.Generate())
 
             if not self._handling_typedef:
                 token = self._GetNextToken()
                 if token.token_type != tokenize.NAME:
                     assert token.token_type == tokenize.SYNTAX, token
                     assert token.name == ';', token
                 else:
                     new_class = class_type(class_token.start, class_token.end,
                                            class_name, bases, None,
                                            body, self.namespace_stack)
 
                     modifiers = []
                     return self._CreateVariable(class_token,
                                                 token.name, new_class,
                                                 modifiers, token.name, None)
         else:
             if not self._handling_typedef:
                 self.HandleError('non-typedef token', token)
             self._AddBackToken(token)
 
         return class_type(class_token.start, class_token.end, class_name,
                           bases, templated_types, body, self.namespace_stack)
 

def cpp.ast.AstBuilder._GetClass	(	self,
		class_type,
		visibility,
		templated_types
	)

private

Definition at line 1489 of file ast.py.

Referenced by cpp.ast.AstBuilder._GetClass(), cpp.ast.AstBuilder.handle_class(), cpp.ast.AstBuilder.handle_struct(), and cpp.ast.AstBuilder.handle_template().

     def _GetClass(self, class_type, visibility, templated_types):
         class_name = None
         class_token = self._GetNextToken()
         if class_token.token_type != tokenize.NAME:
             assert class_token.token_type == tokenize.SYNTAX, class_token
             token = class_token
         else:
             # Skip any macro (e.g. storage class specifiers) after the
             # 'class' keyword.
             next_token = self._GetNextToken()
             if next_token.token_type == tokenize.NAME:
                 self._AddBackToken(next_token)
             else:
                 self._AddBackTokens([class_token, next_token])
             name_tokens, token = self.GetName()
             class_name = ''.join([t.name for t in name_tokens])
         bases = None
         if token.token_type == tokenize.SYNTAX:
             if token.name == ';':
                 # Forward declaration.
                 return class_type(class_token.start, class_token.end,
                                   class_name, None, templated_types, None,
                                   self.namespace_stack)
             if token.name in '*&':
                 # Inline forward declaration.  Could be method or data.
                 name_token = self._GetNextToken()
                 next_token = self._GetNextToken()
                 if next_token.name == ';':
                     # Handle data
                     modifiers = ['class']
                     return self._CreateVariable(class_token, name_token.name,
                                                 class_name,
                                                 modifiers, token.name, None)
                 else:
                     # Assume this is a method.
                     tokens = (class_token, token, name_token, next_token)
                     self._AddBackTokens(tokens)
                     return self.GetMethod(FUNCTION_NONE, None)
             if token.name == ':':
                 bases, token = self._GetBases()
 
         body = None
         if token.token_type == tokenize.SYNTAX and token.name == '{':
             assert token.token_type == tokenize.SYNTAX, token
             assert token.name == '{', token
 
             ast = AstBuilder(self.GetScope(), self.filename, class_name,
                              visibility, self.namespace_stack)
             body = list(ast.Generate())
 
             if not self._handling_typedef:
                 token = self._GetNextToken()
                 if token.token_type != tokenize.NAME:
                     assert token.token_type == tokenize.SYNTAX, token
                     assert token.name == ';', token
                 else:
                     new_class = class_type(class_token.start, class_token.end,
                                            class_name, bases, None,
                                            body, self.namespace_stack)
 
                     modifiers = []
                     return self._CreateVariable(class_token,
                                                 token.name, new_class,
                                                 modifiers, token.name, None)
         else:
             if not self._handling_typedef:
                 self.HandleError('non-typedef token', token)
             self._AddBackToken(token)
 
         return class_type(class_token.start, class_token.end, class_name,
                           bases, templated_types, body, self.namespace_stack)
 

def cpp.ast.AstBuilder._GetMatchingChar	(	self,
		open_paren,
		close_paren,
		GetNextToken = `None`
	)

private

Definition at line 880 of file ast.py.

References cpp.ast.AstBuilder._GetNextToken().

Referenced by cpp.ast.AstBuilder._GetMatchingChar(), cpp.ast.AstBuilder._GetMethod(), cpp.ast.AstBuilder._GetParameters(), cpp.ast.AstBuilder._GetTemplatedTypes(), cpp.ast.AstBuilder.GetName(), and cpp.ast.AstBuilder.GetScope().

     def _GetMatchingChar(self, open_paren, close_paren, GetNextToken=None):
         if GetNextToken is None:
             GetNextToken = self._GetNextToken
         # Assumes the current token is open_paren and we will consume
         # and return up to the close_paren.
         count = 1
         token = GetNextToken()
         while 1:
             if token.token_type == tokenize.SYNTAX:
                 if token.name == open_paren:
                     count += 1
                 elif token.name == close_paren:
                     count -= 1
                     if count == 0:
                         break
             yield token
             token = GetNextToken()
         yield token
 

def cpp.ast.AstBuilder._GetMatchingChar	(	self,
		open_paren,
		close_paren,
		GetNextToken = `None`
	)

private

Definition at line 880 of file ast.py.

References cpp.ast.AstBuilder._GetMatchingChar(), and cpp.ast.AstBuilder._GetNextToken().

     def _GetMatchingChar(self, open_paren, close_paren, GetNextToken=None):
         if GetNextToken is None:
             GetNextToken = self._GetNextToken
         # Assumes the current token is open_paren and we will consume
         # and return up to the close_paren.
         count = 1
         token = GetNextToken()
         while 1:
             if token.token_type == tokenize.SYNTAX:
                 if token.name == open_paren:
                     count += 1
                 elif token.name == close_paren:
                     count -= 1
                     if count == 0:
                         break
             yield token
             token = GetNextToken()
         yield token
 

def cpp.ast.AstBuilder._GetMatchingChar	(	self,
		open_paren,
		close_paren,
		GetNextToken = `None`
	)

private

Definition at line 880 of file ast.py.

References cpp.ast.AstBuilder._GetMatchingChar(), and cpp.ast.AstBuilder._GetNextToken().

     def _GetMatchingChar(self, open_paren, close_paren, GetNextToken=None):
         if GetNextToken is None:
             GetNextToken = self._GetNextToken
         # Assumes the current token is open_paren and we will consume
         # and return up to the close_paren.
         count = 1
         token = GetNextToken()
         while 1:
             if token.token_type == tokenize.SYNTAX:
                 if token.name == open_paren:
                     count += 1
                 elif token.name == close_paren:
                     count -= 1
                     if count == 0:
                         break
             yield token
             token = GetNextToken()
         yield token
 

def cpp.ast.AstBuilder._GetMethod	(	self,
		return_type_and_name,
		modifiers,
		templated_types,
		get_paren
	)

private

Definition at line 960 of file ast.py.

References cpp.ast.AstBuilder._CreateVariable(), cpp.ast.AstBuilder._GetMatchingChar(), cpp.ast.AstBuilder._GetNextToken(), cpp.ast.AstBuilder._GetParameters(), cpp.ast.AstBuilder._GetReturnTypeAndClassName(), cpp.ast.AstBuilder.GetScope(), cpp.ast.AstBuilder.HandleError(), cpp.ast.Method.in_class, cpp.ast.AstBuilder.in_class, bm.list, cpp.ast.TypeConverter.namespace_stack, and cpp.ast.AstBuilder.namespace_stack.

Referenced by cpp.ast.AstBuilder._GenerateOne(), cpp.ast.AstBuilder.GetMethod(), and cpp.ast.AstBuilder.handle_struct().

                    get_paren):
         template_portion = None
         if get_paren:
             token = self._GetNextToken()
             assert token.token_type == tokenize.SYNTAX, token
             if token.name == '<':
                 # Handle templatized dtors.
                 template_portion = [token]
                 template_portion.extend(self._GetMatchingChar('<', '>'))
                 token = self._GetNextToken()
             assert token.token_type == tokenize.SYNTAX, token
             assert token.name == '(', token
 
         name = return_type_and_name.pop()
         # Handle templatized ctors.
         if name.name == '>':
             index = 1
             while return_type_and_name[index].name != '<':
                 index += 1
             template_portion = return_type_and_name[index:] + [name]
             del return_type_and_name[index:]
             name = return_type_and_name.pop()
         elif name.name == ']':
             rt = return_type_and_name
             assert rt[-1].name == '[', return_type_and_name
             assert rt[-2].name == 'operator', return_type_and_name
             name_seq = return_type_and_name[-2:]
             del return_type_and_name[-2:]
             name = tokenize.Token(tokenize.NAME, 'operator[]',
                                   name_seq[0].start, name.end)
             # Get the open paren so _GetParameters() below works.
             unused_open_paren = self._GetNextToken()
 
         # TODO(nnorwitz): store template_portion.
         return_type = return_type_and_name
         indices = name
         if return_type:
             indices = return_type[0]
 
         # Force ctor for templatized ctors.
         if name.name == self.in_class and not modifiers:
             modifiers |= FUNCTION_CTOR
         parameters = list(self._GetParameters())
         del parameters[-1]              # Remove trailing ')'.
 
         # Handling operator() is especially weird.
         if name.name == 'operator' and not parameters:
             token = self._GetNextToken()
             assert token.name == '(', token
             parameters = list(self._GetParameters())
             del parameters[-1]          # Remove trailing ')'.
 
         token = self._GetNextToken()
         while token.token_type == tokenize.NAME:
             modifier_token = token
             token = self._GetNextToken()
             if modifier_token.name == 'const':
                 modifiers |= FUNCTION_CONST
             elif modifier_token.name == '__attribute__':
                 # TODO(nnorwitz): handle more __attribute__ details.
                 modifiers |= FUNCTION_ATTRIBUTE
                 assert token.name == '(', token
                 # Consume everything between the (parens).
                 unused_tokens = list(self._GetMatchingChar('(', ')'))
                 token = self._GetNextToken()
             elif modifier_token.name == 'throw':
                 modifiers |= FUNCTION_THROW
                 assert token.name == '(', token
                 # Consume everything between the (parens).
                 unused_tokens = list(self._GetMatchingChar('(', ')'))
                 token = self._GetNextToken()
             elif modifier_token.name == 'override':
                 modifiers |= FUNCTION_OVERRIDE
             elif modifier_token.name == modifier_token.name.upper():
                 # HACK(nnorwitz):  assume that all upper-case names
                 # are some macro we aren't expanding.
                 modifiers |= FUNCTION_UNKNOWN_ANNOTATION
             else:
                 self.HandleError('unexpected token', modifier_token)
 
         assert token.token_type == tokenize.SYNTAX, token
         # Handle ctor initializers.
         if token.name == ':':
             # TODO(nnorwitz): anything else to handle for initializer list?
             while token.name != ';' and token.name != '{':
                 token = self._GetNextToken()
 
         # Handle pointer to functions that are really data but look
         # like method declarations.
         if token.name == '(':
             if parameters[0].name == '*':
                 # name contains the return type.
                 name = parameters.pop()
                 # parameters contains the name of the data.
                 modifiers = [p.name for p in parameters]
                 # Already at the ( to open the parameter list.
                 function_parameters = list(self._GetMatchingChar('(', ')'))
                 del function_parameters[-1]  # Remove trailing ')'.
                 # TODO(nnorwitz): store the function_parameters.
                 token = self._GetNextToken()
                 assert token.token_type == tokenize.SYNTAX, token
                 assert token.name == ';', token
                 return self._CreateVariable(indices, name.name, indices.name,
                                             modifiers, '', None)
             # At this point, we got something like:
             #  return_type (type::*name_)(params);
             # This is a data member called name_ that is a function pointer.
             # With this code: void (sq_type::*field_)(string&);
             # We get: name=void return_type=[] parameters=sq_type ... field_
             # TODO(nnorwitz): is return_type always empty?
             # TODO(nnorwitz): this isn't even close to being correct.
             # Just put in something so we don't crash and can move on.
             real_name = parameters[-1]
             modifiers = [p.name for p in self._GetParameters()]
             del modifiers[-1]           # Remove trailing ')'.
             return self._CreateVariable(indices, real_name.name, indices.name,
                                         modifiers, '', None)
 
         if token.name == '{':
             body = list(self.GetScope())
             del body[-1]                # Remove trailing '}'.
         else:
             body = None
             if token.name == '=':
                 token = self._GetNextToken()
 
                 if token.name == 'default' or token.name == 'delete':
                     # Ignore explicitly defaulted and deleted special members
                     # in C++11.
                     token = self._GetNextToken()
                 else:
                     # Handle pure-virtual declarations.
                     assert token.token_type == tokenize.CONSTANT, token
                     assert token.name == '0', token
                     modifiers |= FUNCTION_PURE_VIRTUAL
                     token = self._GetNextToken()
 
             if token.name == '[':
                 # TODO(nnorwitz): store tokens and improve parsing.
                 # template <typename T, size_t N> char (&ASH(T (&seq)[N]))[N];
                 tokens = list(self._GetMatchingChar('[', ']'))
                 token = self._GetNextToken()
 
             assert token.name == ';', (token, return_type_and_name, parameters)
 
         # Looks like we got a method, not a function.
         if len(return_type) > 2 and return_type[-1].name == '::':
             return_type, in_class = \
                          self._GetReturnTypeAndClassName(return_type)
             return Method(indices.start, indices.end, name.name, in_class,
                           return_type, parameters, modifiers, templated_types,
                           body, self.namespace_stack)
         return Function(indices.start, indices.end, name.name, return_type,
                         parameters, modifiers, templated_types, body,
                         self.namespace_stack)
 

def cpp.ast.AstBuilder._GetMethod	(	self,
		return_type_and_name,
		modifiers,
		templated_types,
		get_paren
	)

private

Definition at line 960 of file ast.py.

References cpp.ast.AstBuilder._CreateVariable(), cpp.ast.AstBuilder._GetMatchingChar(), cpp.ast.AstBuilder._GetNextToken(), cpp.ast.AstBuilder._GetParameters(), cpp.ast.AstBuilder._GetReturnTypeAndClassName(), cpp.ast.AstBuilder.GetScope(), cpp.ast.AstBuilder.HandleError(), cpp.ast.Method.in_class, cpp.ast.AstBuilder.in_class, bm.list, cpp.ast.TypeConverter.namespace_stack, and cpp.ast.AstBuilder.namespace_stack.

                    get_paren):
         template_portion = None
         if get_paren:
             token = self._GetNextToken()
             assert token.token_type == tokenize.SYNTAX, token
             if token.name == '<':
                 # Handle templatized dtors.
                 template_portion = [token]
                 template_portion.extend(self._GetMatchingChar('<', '>'))
                 token = self._GetNextToken()
             assert token.token_type == tokenize.SYNTAX, token
             assert token.name == '(', token
 
         name = return_type_and_name.pop()
         # Handle templatized ctors.
         if name.name == '>':
             index = 1
             while return_type_and_name[index].name != '<':
                 index += 1
             template_portion = return_type_and_name[index:] + [name]
             del return_type_and_name[index:]
             name = return_type_and_name.pop()
         elif name.name == ']':
             rt = return_type_and_name
             assert rt[-1].name == '[', return_type_and_name
             assert rt[-2].name == 'operator', return_type_and_name
             name_seq = return_type_and_name[-2:]
             del return_type_and_name[-2:]
             name = tokenize.Token(tokenize.NAME, 'operator[]',
                                   name_seq[0].start, name.end)
             # Get the open paren so _GetParameters() below works.
             unused_open_paren = self._GetNextToken()
 
         # TODO(nnorwitz): store template_portion.
         return_type = return_type_and_name
         indices = name
         if return_type:
             indices = return_type[0]
 
         # Force ctor for templatized ctors.
         if name.name == self.in_class and not modifiers:
             modifiers |= FUNCTION_CTOR
         parameters = list(self._GetParameters())
         del parameters[-1]              # Remove trailing ')'.
 
         # Handling operator() is especially weird.
         if name.name == 'operator' and not parameters:
             token = self._GetNextToken()
             assert token.name == '(', token
             parameters = list(self._GetParameters())
             del parameters[-1]          # Remove trailing ')'.
 
         token = self._GetNextToken()
         while token.token_type == tokenize.NAME:
             modifier_token = token
             token = self._GetNextToken()
             if modifier_token.name == 'const':
                 modifiers |= FUNCTION_CONST
             elif modifier_token.name == '__attribute__':
                 # TODO(nnorwitz): handle more __attribute__ details.
                 modifiers |= FUNCTION_ATTRIBUTE
                 assert token.name == '(', token
                 # Consume everything between the (parens).
                 unused_tokens = list(self._GetMatchingChar('(', ')'))
                 token = self._GetNextToken()
             elif modifier_token.name == 'throw':
                 modifiers |= FUNCTION_THROW
                 assert token.name == '(', token
                 # Consume everything between the (parens).
                 unused_tokens = list(self._GetMatchingChar('(', ')'))
                 token = self._GetNextToken()
             elif modifier_token.name == 'override':
                 modifiers |= FUNCTION_OVERRIDE
             elif modifier_token.name == modifier_token.name.upper():
                 # HACK(nnorwitz):  assume that all upper-case names
                 # are some macro we aren't expanding.
                 modifiers |= FUNCTION_UNKNOWN_ANNOTATION
             else:
                 self.HandleError('unexpected token', modifier_token)
 
         assert token.token_type == tokenize.SYNTAX, token
         # Handle ctor initializers.
         if token.name == ':':
             # TODO(nnorwitz): anything else to handle for initializer list?
             while token.name != ';' and token.name != '{':
                 token = self._GetNextToken()
 
         # Handle pointer to functions that are really data but look
         # like method declarations.
         if token.name == '(':
             if parameters[0].name == '*':
                 # name contains the return type.
                 name = parameters.pop()
                 # parameters contains the name of the data.
                 modifiers = [p.name for p in parameters]
                 # Already at the ( to open the parameter list.
                 function_parameters = list(self._GetMatchingChar('(', ')'))
                 del function_parameters[-1]  # Remove trailing ')'.
                 # TODO(nnorwitz): store the function_parameters.
                 token = self._GetNextToken()
                 assert token.token_type == tokenize.SYNTAX, token
                 assert token.name == ';', token
                 return self._CreateVariable(indices, name.name, indices.name,
                                             modifiers, '', None)
             # At this point, we got something like:
             #  return_type (type::*name_)(params);
             # This is a data member called name_ that is a function pointer.
             # With this code: void (sq_type::*field_)(string&);
             # We get: name=void return_type=[] parameters=sq_type ... field_
             # TODO(nnorwitz): is return_type always empty?
             # TODO(nnorwitz): this isn't even close to being correct.
             # Just put in something so we don't crash and can move on.
             real_name = parameters[-1]
             modifiers = [p.name for p in self._GetParameters()]
             del modifiers[-1]           # Remove trailing ')'.
             return self._CreateVariable(indices, real_name.name, indices.name,
                                         modifiers, '', None)
 
         if token.name == '{':
             body = list(self.GetScope())
             del body[-1]                # Remove trailing '}'.
         else:
             body = None
             if token.name == '=':
                 token = self._GetNextToken()
 
                 if token.name == 'default' or token.name == 'delete':
                     # Ignore explicitly defaulted and deleted special members
                     # in C++11.
                     token = self._GetNextToken()
                 else:
                     # Handle pure-virtual declarations.
                     assert token.token_type == tokenize.CONSTANT, token
                     assert token.name == '0', token
                     modifiers |= FUNCTION_PURE_VIRTUAL
                     token = self._GetNextToken()
 
             if token.name == '[':
                 # TODO(nnorwitz): store tokens and improve parsing.
                 # template <typename T, size_t N> char (&ASH(T (&seq)[N]))[N];
                 tokens = list(self._GetMatchingChar('[', ']'))
                 token = self._GetNextToken()
 
             assert token.name == ';', (token, return_type_and_name, parameters)
 
         # Looks like we got a method, not a function.
         if len(return_type) > 2 and return_type[-1].name == '::':
             return_type, in_class = \
                          self._GetReturnTypeAndClassName(return_type)
             return Method(indices.start, indices.end, name.name, in_class,
                           return_type, parameters, modifiers, templated_types,
                           body, self.namespace_stack)
         return Function(indices.start, indices.end, name.name, return_type,
                         parameters, modifiers, templated_types, body,
                         self.namespace_stack)
 

def cpp.ast.AstBuilder._GetMethod	(	self,
		return_type_and_name,
		modifiers,
		templated_types,
		get_paren
	)

private

Definition at line 960 of file ast.py.

References cpp.ast.AstBuilder._CreateVariable(), cpp.ast.AstBuilder._GetMatchingChar(), cpp.ast.AstBuilder._GetNextToken(), cpp.ast.AstBuilder._GetParameters(), cpp.ast.AstBuilder._GetReturnTypeAndClassName(), cpp.ast.AstBuilder.GetScope(), cpp.ast.AstBuilder.HandleError(), cpp.ast.Method.in_class, cpp.ast.AstBuilder.in_class, bm.list, cpp.ast.TypeConverter.namespace_stack, and cpp.ast.AstBuilder.namespace_stack.

                    get_paren):
         template_portion = None
         if get_paren:
             token = self._GetNextToken()
             assert token.token_type == tokenize.SYNTAX, token
             if token.name == '<':
                 # Handle templatized dtors.
                 template_portion = [token]
                 template_portion.extend(self._GetMatchingChar('<', '>'))
                 token = self._GetNextToken()
             assert token.token_type == tokenize.SYNTAX, token
             assert token.name == '(', token
 
         name = return_type_and_name.pop()
         # Handle templatized ctors.
         if name.name == '>':
             index = 1
             while return_type_and_name[index].name != '<':
                 index += 1
             template_portion = return_type_and_name[index:] + [name]
             del return_type_and_name[index:]
             name = return_type_and_name.pop()
         elif name.name == ']':
             rt = return_type_and_name
             assert rt[-1].name == '[', return_type_and_name
             assert rt[-2].name == 'operator', return_type_and_name
             name_seq = return_type_and_name[-2:]
             del return_type_and_name[-2:]
             name = tokenize.Token(tokenize.NAME, 'operator[]',
                                   name_seq[0].start, name.end)
             # Get the open paren so _GetParameters() below works.
             unused_open_paren = self._GetNextToken()
 
         # TODO(nnorwitz): store template_portion.
         return_type = return_type_and_name
         indices = name
         if return_type:
             indices = return_type[0]
 
         # Force ctor for templatized ctors.
         if name.name == self.in_class and not modifiers:
             modifiers |= FUNCTION_CTOR
         parameters = list(self._GetParameters())
         del parameters[-1]              # Remove trailing ')'.
 
         # Handling operator() is especially weird.
         if name.name == 'operator' and not parameters:
             token = self._GetNextToken()
             assert token.name == '(', token
             parameters = list(self._GetParameters())
             del parameters[-1]          # Remove trailing ')'.
 
         token = self._GetNextToken()
         while token.token_type == tokenize.NAME:
             modifier_token = token
             token = self._GetNextToken()
             if modifier_token.name == 'const':
                 modifiers |= FUNCTION_CONST
             elif modifier_token.name == '__attribute__':
                 # TODO(nnorwitz): handle more __attribute__ details.
                 modifiers |= FUNCTION_ATTRIBUTE
                 assert token.name == '(', token
                 # Consume everything between the (parens).
                 unused_tokens = list(self._GetMatchingChar('(', ')'))
                 token = self._GetNextToken()
             elif modifier_token.name == 'throw':
                 modifiers |= FUNCTION_THROW
                 assert token.name == '(', token
                 # Consume everything between the (parens).
                 unused_tokens = list(self._GetMatchingChar('(', ')'))
                 token = self._GetNextToken()
             elif modifier_token.name == 'override':
                 modifiers |= FUNCTION_OVERRIDE
             elif modifier_token.name == modifier_token.name.upper():
                 # HACK(nnorwitz):  assume that all upper-case names
                 # are some macro we aren't expanding.
                 modifiers |= FUNCTION_UNKNOWN_ANNOTATION
             else:
                 self.HandleError('unexpected token', modifier_token)
 
         assert token.token_type == tokenize.SYNTAX, token
         # Handle ctor initializers.
         if token.name == ':':
             # TODO(nnorwitz): anything else to handle for initializer list?
             while token.name != ';' and token.name != '{':
                 token = self._GetNextToken()
 
         # Handle pointer to functions that are really data but look
         # like method declarations.
         if token.name == '(':
             if parameters[0].name == '*':
                 # name contains the return type.
                 name = parameters.pop()
                 # parameters contains the name of the data.
                 modifiers = [p.name for p in parameters]
                 # Already at the ( to open the parameter list.
                 function_parameters = list(self._GetMatchingChar('(', ')'))
                 del function_parameters[-1]  # Remove trailing ')'.
                 # TODO(nnorwitz): store the function_parameters.
                 token = self._GetNextToken()
                 assert token.token_type == tokenize.SYNTAX, token
                 assert token.name == ';', token
                 return self._CreateVariable(indices, name.name, indices.name,
                                             modifiers, '', None)
             # At this point, we got something like:
             #  return_type (type::*name_)(params);
             # This is a data member called name_ that is a function pointer.
             # With this code: void (sq_type::*field_)(string&);
             # We get: name=void return_type=[] parameters=sq_type ... field_
             # TODO(nnorwitz): is return_type always empty?
             # TODO(nnorwitz): this isn't even close to being correct.
             # Just put in something so we don't crash and can move on.
             real_name = parameters[-1]
             modifiers = [p.name for p in self._GetParameters()]
             del modifiers[-1]           # Remove trailing ')'.
             return self._CreateVariable(indices, real_name.name, indices.name,
                                         modifiers, '', None)
 
         if token.name == '{':
             body = list(self.GetScope())
             del body[-1]                # Remove trailing '}'.
         else:
             body = None
             if token.name == '=':
                 token = self._GetNextToken()
 
                 if token.name == 'default' or token.name == 'delete':
                     # Ignore explicitly defaulted and deleted special members
                     # in C++11.
                     token = self._GetNextToken()
                 else:
                     # Handle pure-virtual declarations.
                     assert token.token_type == tokenize.CONSTANT, token
                     assert token.name == '0', token
                     modifiers |= FUNCTION_PURE_VIRTUAL
                     token = self._GetNextToken()
 
             if token.name == '[':
                 # TODO(nnorwitz): store tokens and improve parsing.
                 # template <typename T, size_t N> char (&ASH(T (&seq)[N]))[N];
                 tokens = list(self._GetMatchingChar('[', ']'))
                 token = self._GetNextToken()
 
             assert token.name == ';', (token, return_type_and_name, parameters)
 
         # Looks like we got a method, not a function.
         if len(return_type) > 2 and return_type[-1].name == '::':
             return_type, in_class = \
                          self._GetReturnTypeAndClassName(return_type)
             return Method(indices.start, indices.end, name.name, in_class,
                           return_type, parameters, modifiers, templated_types,
                           body, self.namespace_stack)
         return Function(indices.start, indices.end, name.name, return_type,
                         parameters, modifiers, templated_types, body,
                         self.namespace_stack)
 

def cpp.ast.AstBuilder._GetNestedType	(	self,
		ctor
	)

private

Definition at line 1193 of file ast.py.

     def _GetNestedType(self, ctor):
         name = None
         name_tokens, token = self.GetName()
         if name_tokens:
             name = ''.join([t.name for t in name_tokens])
 
         # Handle forward declarations.
         if token.token_type == tokenize.SYNTAX and token.name == ';':
             return ctor(token.start, token.end, name, None,
                         self.namespace_stack)
 
         if token.token_type == tokenize.NAME and self._handling_typedef:
             self._AddBackToken(token)
             return ctor(token.start, token.end, name, None,
                         self.namespace_stack)
 
         # Must be the type declaration.
         fields = list(self._GetMatchingChar('{', '}'))
         del fields[-1]                  # Remove trailing '}'.
         if token.token_type == tokenize.SYNTAX and token.name == '{':
             next = self._GetNextToken()
             new_type = ctor(token.start, token.end, name, fields,
                             self.namespace_stack)
             # A name means this is an anonymous type and the name
             # is the variable declaration.
             if next.token_type != tokenize.NAME:
                 return new_type
             name = new_type
             token = next
 
         # Must be variable declaration using the type prefixed with keyword.
         assert token.token_type == tokenize.NAME, token
         return self._CreateVariable(token, token.name, name, [], '', None)
 

def cpp.ast.AstBuilder._GetNestedType	(	self,
		ctor
	)

private

Definition at line 1193 of file ast.py.

     def _GetNestedType(self, ctor):
         name = None
         name_tokens, token = self.GetName()
         if name_tokens:
             name = ''.join([t.name for t in name_tokens])
 
         # Handle forward declarations.
         if token.token_type == tokenize.SYNTAX and token.name == ';':
             return ctor(token.start, token.end, name, None,
                         self.namespace_stack)
 
         if token.token_type == tokenize.NAME and self._handling_typedef:
             self._AddBackToken(token)
             return ctor(token.start, token.end, name, None,
                         self.namespace_stack)
 
         # Must be the type declaration.
         fields = list(self._GetMatchingChar('{', '}'))
         del fields[-1]                  # Remove trailing '}'.
         if token.token_type == tokenize.SYNTAX and token.name == '{':
             next = self._GetNextToken()
             new_type = ctor(token.start, token.end, name, fields,
                             self.namespace_stack)
             # A name means this is an anonymous type and the name
             # is the variable declaration.
             if next.token_type != tokenize.NAME:
                 return new_type
             name = new_type
             token = next
 
         # Must be variable declaration using the type prefixed with keyword.
         assert token.token_type == tokenize.NAME, token
         return self._CreateVariable(token, token.name, name, [], '', None)
 

def cpp.ast.AstBuilder._GetNestedType	(	self,
		ctor
	)

private

Definition at line 1193 of file ast.py.

Referenced by cpp.ast.AstBuilder._GetNestedType(), cpp.ast.AstBuilder.handle_enum(), and cpp.ast.AstBuilder.handle_union().

     def _GetNestedType(self, ctor):
         name = None
         name_tokens, token = self.GetName()
         if name_tokens:
             name = ''.join([t.name for t in name_tokens])
 
         # Handle forward declarations.
         if token.token_type == tokenize.SYNTAX and token.name == ';':
             return ctor(token.start, token.end, name, None,
                         self.namespace_stack)
 
         if token.token_type == tokenize.NAME and self._handling_typedef:
             self._AddBackToken(token)
             return ctor(token.start, token.end, name, None,
                         self.namespace_stack)
 
         # Must be the type declaration.
         fields = list(self._GetMatchingChar('{', '}'))
         del fields[-1]                  # Remove trailing '}'.
         if token.token_type == tokenize.SYNTAX and token.name == '{':
             next = self._GetNextToken()
             new_type = ctor(token.start, token.end, name, fields,
                             self.namespace_stack)
             # A name means this is an anonymous type and the name
             # is the variable declaration.
             if next.token_type != tokenize.NAME:
                 return new_type
             name = new_type
             token = next
 
         # Must be variable declaration using the type prefixed with keyword.
         assert token.token_type == tokenize.NAME, token
         return self._CreateVariable(token, token.name, name, [], '', None)
 

def cpp.ast.AstBuilder._GetNextToken ( self )

private

Definition at line 905 of file ast.py.

References cpp.ast.AstBuilder._GetNextToken(), cpp.ast.next(), cpp.ast.AstBuilder.token_queue, and cpp.ast.AstBuilder.tokens.

     def _GetNextToken(self):
         if self.token_queue:
             return self.token_queue.pop()
         return next(self.tokens)
 

def cpp.ast.AstBuilder._GetNextToken ( self )

private

Definition at line 905 of file ast.py.

References cpp.ast.next(), cpp.ast.AstBuilder.token_queue, and cpp.ast.AstBuilder.tokens.

     def _GetNextToken(self):
         if self.token_queue:
             return self.token_queue.pop()
         return next(self.tokens)
 

def cpp.ast.AstBuilder._GetNextToken ( self )

private

Definition at line 905 of file ast.py.

References cpp.ast.AstBuilder._GetNextToken(), cpp.ast.next(), cpp.ast.AstBuilder.token_queue, and cpp.ast.AstBuilder.tokens.

     def _GetNextToken(self):
         if self.token_queue:
             return self.token_queue.pop()
         return next(self.tokens)
 

def cpp.ast.AstBuilder._GetParameters ( self )

private

Definition at line 899 of file ast.py.

References cpp.ast.AstBuilder._GetMatchingChar().

Referenced by cpp.ast.AstBuilder._GetMethod(), and cpp.ast.AstBuilder._GetParameters().

     def _GetParameters(self):
         return self._GetMatchingChar('(', ')')
 

def cpp.ast.AstBuilder._GetParameters ( self )

private

Definition at line 899 of file ast.py.

References cpp.ast.AstBuilder._GetMatchingChar(), and cpp.ast.AstBuilder._GetParameters().

     def _GetParameters(self):
         return self._GetMatchingChar('(', ')')
 

def cpp.ast.AstBuilder._GetParameters ( self )

private

Definition at line 899 of file ast.py.

References cpp.ast.AstBuilder._GetMatchingChar(), and cpp.ast.AstBuilder._GetParameters().

     def _GetParameters(self):
         return self._GetMatchingChar('(', ')')
 

def cpp.ast.AstBuilder._GetReturnTypeAndClassName	(	self,
		token_seq
	)

private

Definition at line 1116 of file ast.py.

References cpp.ast.AstBuilder.GetName().

Referenced by cpp.ast.AstBuilder._GetMethod(), and cpp.ast.AstBuilder._GetReturnTypeAndClassName().

     def _GetReturnTypeAndClassName(self, token_seq):
         # Splitting the return type from the class name in a method
         # can be tricky.  For example, Return::Type::Is::Hard::To::Find().
         # Where is the return type and where is the class name?
         # The heuristic used is to pull the last name as the class name.
         # This includes all the templated type info.
         # TODO(nnorwitz): if there is only One name like in the
         # example above, punt and assume the last bit is the class name.
 
         # Ignore a :: prefix, if exists so we can find the first real name.
         i = 0
         if token_seq[0].name == '::':
             i = 1
         # Ignore a :: suffix, if exists.
         end = len(token_seq) - 1
         if token_seq[end-1].name == '::':
             end -= 1
 
         # Make a copy of the sequence so we can append a sentinel
         # value. This is required for GetName will has to have some
         # terminating condition beyond the last name.
         seq_copy = token_seq[i:end]
         seq_copy.append(tokenize.Token(tokenize.SYNTAX, '', 0, 0))
         names = []
         while i < end:
             # Iterate through the sequence parsing out each name.
             new_name, next = self.GetName(seq_copy[i:])
             assert new_name, 'Got empty new_name, next=%s' % next
             # We got a pointer or ref.  Add it to the name.
             if next and next.token_type == tokenize.SYNTAX:
                 new_name.append(next)
             names.append(new_name)
             i += len(new_name)
 
         # Now that we have the names, it's time to undo what we did.
 
         # Remove the sentinel value.
         names[-1].pop()
         # Flatten the token sequence for the return type.
         return_type = [e for seq in names[:-1] for e in seq]
         # The class name is the last name.
         class_name = names[-1]
         return return_type, class_name
 

def cpp.ast.AstBuilder._GetReturnTypeAndClassName	(	self,
		token_seq
	)

private

Definition at line 1116 of file ast.py.

References cpp.ast.AstBuilder._GetReturnTypeAndClassName(), and cpp.ast.AstBuilder.GetName().

     def _GetReturnTypeAndClassName(self, token_seq):
         # Splitting the return type from the class name in a method
         # can be tricky.  For example, Return::Type::Is::Hard::To::Find().
         # Where is the return type and where is the class name?
         # The heuristic used is to pull the last name as the class name.
         # This includes all the templated type info.
         # TODO(nnorwitz): if there is only One name like in the
         # example above, punt and assume the last bit is the class name.
 
         # Ignore a :: prefix, if exists so we can find the first real name.
         i = 0
         if token_seq[0].name == '::':
             i = 1
         # Ignore a :: suffix, if exists.
         end = len(token_seq) - 1
         if token_seq[end-1].name == '::':
             end -= 1
 
         # Make a copy of the sequence so we can append a sentinel
         # value. This is required for GetName will has to have some
         # terminating condition beyond the last name.
         seq_copy = token_seq[i:end]
         seq_copy.append(tokenize.Token(tokenize.SYNTAX, '', 0, 0))
         names = []
         while i < end:
             # Iterate through the sequence parsing out each name.
             new_name, next = self.GetName(seq_copy[i:])
             assert new_name, 'Got empty new_name, next=%s' % next
             # We got a pointer or ref.  Add it to the name.
             if next and next.token_type == tokenize.SYNTAX:
                 new_name.append(next)
             names.append(new_name)
             i += len(new_name)
 
         # Now that we have the names, it's time to undo what we did.
 
         # Remove the sentinel value.
         names[-1].pop()
         # Flatten the token sequence for the return type.
         return_type = [e for seq in names[:-1] for e in seq]
         # The class name is the last name.
         class_name = names[-1]
         return return_type, class_name
 

def cpp.ast.AstBuilder._GetReturnTypeAndClassName	(	self,
		token_seq
	)

private

Definition at line 1116 of file ast.py.

References cpp.ast.AstBuilder._GetReturnTypeAndClassName(), and cpp.ast.AstBuilder.GetName().

     def _GetReturnTypeAndClassName(self, token_seq):
         # Splitting the return type from the class name in a method
         # can be tricky.  For example, Return::Type::Is::Hard::To::Find().
         # Where is the return type and where is the class name?
         # The heuristic used is to pull the last name as the class name.
         # This includes all the templated type info.
         # TODO(nnorwitz): if there is only One name like in the
         # example above, punt and assume the last bit is the class name.
 
         # Ignore a :: prefix, if exists so we can find the first real name.
         i = 0
         if token_seq[0].name == '::':
             i = 1
         # Ignore a :: suffix, if exists.
         end = len(token_seq) - 1
         if token_seq[end-1].name == '::':
             end -= 1
 
         # Make a copy of the sequence so we can append a sentinel
         # value. This is required for GetName will has to have some
         # terminating condition beyond the last name.
         seq_copy = token_seq[i:end]
         seq_copy.append(tokenize.Token(tokenize.SYNTAX, '', 0, 0))
         names = []
         while i < end:
             # Iterate through the sequence parsing out each name.
             new_name, next = self.GetName(seq_copy[i:])
             assert new_name, 'Got empty new_name, next=%s' % next
             # We got a pointer or ref.  Add it to the name.
             if next and next.token_type == tokenize.SYNTAX:
                 new_name.append(next)
             names.append(new_name)
             i += len(new_name)
 
         # Now that we have the names, it's time to undo what we did.
 
         # Remove the sentinel value.
         names[-1].pop()
         # Flatten the token sequence for the return type.
         return_type = [e for seq in names[:-1] for e in seq]
         # The class name is the last name.
         class_name = names[-1]
         return return_type, class_name
 

def cpp.ast.AstBuilder._GetTemplatedTypes ( self )

private

Definition at line 1395 of file ast.py.

References cpp.ast.AstBuilder._GetMatchingChar(), cpp.ast.AstBuilder._GetTemplatedTypes(), cpp.ast.AstBuilder.GetName(), and bm.list.

     def _GetTemplatedTypes(self):
         result = {}
         tokens = list(self._GetMatchingChar('<', '>'))
         len_tokens = len(tokens) - 1    # Ignore trailing '>'.
         i = 0
         while i < len_tokens:
             key = tokens[i].name
             i += 1
             if keywords.IsKeyword(key) or key == ',':
                 continue
             type_name = default = None
             if i < len_tokens:
                 i += 1
                 if tokens[i-1].name == '=':
                     assert i < len_tokens, '%s %s' % (i, tokens)
                     default, unused_next_token = self.GetName(tokens[i:])
                     i += len(default)
                 else:
                     if tokens[i-1].name != ',':
                         # We got something like: Type variable.
                         # Re-adjust the key (variable) and type_name (Type).
                         key = tokens[i-1].name
                         type_name = tokens[i-2]
 
             result[key] = (type_name, default)
         return result
 

def cpp.ast.AstBuilder._GetTemplatedTypes ( self )

private

Definition at line 1395 of file ast.py.

References cpp.ast.AstBuilder._GetMatchingChar(), cpp.ast.AstBuilder._GetTemplatedTypes(), cpp.ast.AstBuilder.GetName(), and bm.list.

     def _GetTemplatedTypes(self):
         result = {}
         tokens = list(self._GetMatchingChar('<', '>'))
         len_tokens = len(tokens) - 1    # Ignore trailing '>'.
         i = 0
         while i < len_tokens:
             key = tokens[i].name
             i += 1
             if keywords.IsKeyword(key) or key == ',':
                 continue
             type_name = default = None
             if i < len_tokens:
                 i += 1
                 if tokens[i-1].name == '=':
                     assert i < len_tokens, '%s %s' % (i, tokens)
                     default, unused_next_token = self.GetName(tokens[i:])
                     i += len(default)
                 else:
                     if tokens[i-1].name != ',':
                         # We got something like: Type variable.
                         # Re-adjust the key (variable) and type_name (Type).
                         key = tokens[i-1].name
                         type_name = tokens[i-2]
 
             result[key] = (type_name, default)
         return result
 

def cpp.ast.AstBuilder._GetTemplatedTypes ( self )

private

Definition at line 1395 of file ast.py.

References cpp.ast.AstBuilder._GetMatchingChar(), cpp.ast.AstBuilder.GetName(), and bm.list.

Referenced by cpp.ast.AstBuilder._GetTemplatedTypes(), and cpp.ast.AstBuilder.handle_template().

     def _GetTemplatedTypes(self):
         result = {}
         tokens = list(self._GetMatchingChar('<', '>'))
         len_tokens = len(tokens) - 1    # Ignore trailing '>'.
         i = 0
         while i < len_tokens:
             key = tokens[i].name
             i += 1
             if keywords.IsKeyword(key) or key == ',':
                 continue
             type_name = default = None
             if i < len_tokens:
                 i += 1
                 if tokens[i-1].name == '=':
                     assert i < len_tokens, '%s %s' % (i, tokens)
                     default, unused_next_token = self.GetName(tokens[i:])
                     i += len(default)
                 else:
                     if tokens[i-1].name != ',':
                         # We got something like: Type variable.
                         # Re-adjust the key (variable) and type_name (Type).
                         key = tokens[i-1].name
                         type_name = tokens[i-2]
 
             result[key] = (type_name, default)
         return result
 

def cpp.ast.AstBuilder._GetTokensUpTo	(	self,
		expected_token_type,
		expected_token
	)

private

Definition at line 849 of file ast.py.

References cpp.ast.AstBuilder._GetVarTokensUpTo().

Referenced by cpp.ast.AstBuilder._GenerateOne(), cpp.ast.AstBuilder._GetTokensUpTo(), cpp.ast.AstBuilder._IgnoreUpTo(), cpp.ast.AstBuilder.GetMethod(), cpp.ast.AstBuilder.handle_friend(), cpp.ast.AstBuilder.handle_goto(), cpp.ast.AstBuilder.handle_typedef(), and cpp.ast.AstBuilder.handle_using().

     def _GetTokensUpTo(self, expected_token_type, expected_token):
         return self._GetVarTokensUpTo(expected_token_type, expected_token)[0]
 

def cpp.ast.AstBuilder._GetTokensUpTo	(	self,
		expected_token_type,
		expected_token
	)

private

Definition at line 849 of file ast.py.

References cpp.ast.AstBuilder._GetTokensUpTo(), and cpp.ast.AstBuilder._GetVarTokensUpTo().

     def _GetTokensUpTo(self, expected_token_type, expected_token):
         return self._GetVarTokensUpTo(expected_token_type, expected_token)[0]
 

def cpp.ast.AstBuilder._GetTokensUpTo	(	self,
		expected_token_type,
		expected_token
	)

private

Definition at line 849 of file ast.py.

References cpp.ast.AstBuilder._GetTokensUpTo(), and cpp.ast.AstBuilder._GetVarTokensUpTo().

     def _GetTokensUpTo(self, expected_token_type, expected_token):
         return self._GetVarTokensUpTo(expected_token_type, expected_token)[0]
 

def cpp.ast.AstBuilder._GetVarTokensUpTo	(	self,
		expected_token_type,
		expected_tokens
	)

private

Definition at line 852 of file ast.py.

References cpp.ast.AstBuilder._GetNextToken(), and cpp.ast.AstBuilder._GetVarTokensUpTo().

     def _GetVarTokensUpTo(self, expected_token_type, *expected_tokens):
         last_token = self._GetNextToken()
         tokens = []
         while (last_token.token_type != expected_token_type or
                last_token.name not in expected_tokens):
             tokens.append(last_token)
             last_token = self._GetNextToken()
         return tokens, last_token
 

def cpp.ast.AstBuilder._GetVarTokensUpTo	(	self,
		expected_token_type,
		expected_tokens
	)

private

Definition at line 852 of file ast.py.

References cpp.ast.AstBuilder._GetNextToken(), and cpp.ast.AstBuilder._GetVarTokensUpTo().

     def _GetVarTokensUpTo(self, expected_token_type, *expected_tokens):
         last_token = self._GetNextToken()
         tokens = []
         while (last_token.token_type != expected_token_type or
                last_token.name not in expected_tokens):
             tokens.append(last_token)
             last_token = self._GetNextToken()
         return tokens, last_token
 

def cpp.ast.AstBuilder._GetVarTokensUpTo	(	self,
		expected_token_type,
		expected_tokens
	)

private

Definition at line 852 of file ast.py.

References cpp.ast.AstBuilder._GetNextToken().

Referenced by cpp.ast.AstBuilder._GenerateOne(), cpp.ast.AstBuilder._GetTokensUpTo(), cpp.ast.AstBuilder._GetVarTokensUpTo(), and cpp.ast.AstBuilder.handle_template().

     def _GetVarTokensUpTo(self, expected_token_type, *expected_tokens):
         last_token = self._GetNextToken()
         tokens = []
         while (last_token.token_type != expected_token_type or
                last_token.name not in expected_tokens):
             tokens.append(last_token)
             last_token = self._GetNextToken()
         return tokens, last_token
 

def cpp.ast.AstBuilder._IgnoreUpTo	(	self,
		token_type,
		token
	)

private

Definition at line 862 of file ast.py.

References cpp.ast.AstBuilder._GetTokensUpTo(), and cpp.ast.AstBuilder._IgnoreUpTo().

     def _IgnoreUpTo(self, token_type, token):
         unused_tokens = self._GetTokensUpTo(token_type, token)
 

def cpp.ast.AstBuilder._IgnoreUpTo	(	self,
		token_type,
		token
	)

private

Definition at line 862 of file ast.py.

References cpp.ast.AstBuilder._GetTokensUpTo(), and cpp.ast.AstBuilder._IgnoreUpTo().

     def _IgnoreUpTo(self, token_type, token):
         unused_tokens = self._GetTokensUpTo(token_type, token)
 

def cpp.ast.AstBuilder._IgnoreUpTo	(	self,
		token_type,
		token
	)

private

Definition at line 862 of file ast.py.

References cpp.ast.AstBuilder._GetTokensUpTo().

Referenced by cpp.ast.AstBuilder._IgnoreUpTo(), and cpp.ast.AstBuilder.handle_continue().

     def _IgnoreUpTo(self, token_type, token):
         unused_tokens = self._GetTokensUpTo(token_type, token)
 

def cpp.ast.AstBuilder._SkipIf0Blocks ( self )

private

Definition at line 865 of file ast.py.

References cpp.ast.AstBuilder._GetNextToken().

Referenced by cpp.ast.AstBuilder._GenerateOne(), and cpp.ast.AstBuilder._SkipIf0Blocks().

     def _SkipIf0Blocks(self):
         count = 1
         while 1:
             token = self._GetNextToken()
             if token.token_type != tokenize.PREPROCESSOR:
                 continue
 
             name = token.name[1:].lstrip()
             if name.startswith('endif'):
                 count -= 1
                 if count == 0:
                     break
             elif name.startswith('if'):
                 count += 1
 

def cpp.ast.AstBuilder._SkipIf0Blocks ( self )

private

Definition at line 865 of file ast.py.

References cpp.ast.AstBuilder._GetNextToken(), and cpp.ast.AstBuilder._SkipIf0Blocks().

     def _SkipIf0Blocks(self):
         count = 1
         while 1:
             token = self._GetNextToken()
             if token.token_type != tokenize.PREPROCESSOR:
                 continue
 
             name = token.name[1:].lstrip()
             if name.startswith('endif'):
                 count -= 1
                 if count == 0:
                     break
             elif name.startswith('if'):
                 count += 1
 

def cpp.ast.AstBuilder._SkipIf0Blocks ( self )

private

Definition at line 865 of file ast.py.

References cpp.ast.AstBuilder._GetNextToken(), and cpp.ast.AstBuilder._SkipIf0Blocks().

     def _SkipIf0Blocks(self):
         count = 1
         while 1:
             token = self._GetNextToken()
             if token.token_type != tokenize.PREPROCESSOR:
                 continue
 
             name = token.name[1:].lstrip()
             if name.startswith('endif'):
                 count -= 1
                 if count == 0:
                     break
             elif name.startswith('if'):
                 count += 1
 

def cpp.ast.AstBuilder.Generate ( self )

Definition at line 704 of file ast.py.

References cpp.ast.AstBuilder._CreateVariable(), cpp.ast.AstBuilder._GenerateOne(), cpp.ast.AstBuilder._GetNextToken(), cpp.ast.AstBuilder.current_token, cpp.ast.AstBuilder.Generate(), and cpp.ast.AstBuilder.HandleError().

     def Generate(self):
         while 1:
             token = self._GetNextToken()
             if not token:
                 break
 
             # Get the next token.
             self.current_token = token
 
             # Dispatch on the next token type.
             if token.token_type == _INTERNAL_TOKEN:
                 if token.name == _NAMESPACE_POP:
                     self.namespace_stack.pop()
                 continue
 
             try:
                 result = self._GenerateOne(token)
                 if result is not None:
                     yield result
             except:
                 self.HandleError('exception', token)
                 raise
 

def cpp.ast.AstBuilder.Generate ( self )

Definition at line 704 of file ast.py.

References cpp.ast.AstBuilder._CreateVariable(), cpp.ast.AstBuilder._GenerateOne(), cpp.ast.AstBuilder._GetNextToken(), cpp.ast.AstBuilder.current_token, cpp.ast.AstBuilder.Generate(), and cpp.ast.AstBuilder.HandleError().

     def Generate(self):
         while 1:
             token = self._GetNextToken()
             if not token:
                 break
 
             # Get the next token.
             self.current_token = token
 
             # Dispatch on the next token type.
             if token.token_type == _INTERNAL_TOKEN:
                 if token.name == _NAMESPACE_POP:
                     self.namespace_stack.pop()
                 continue
 
             try:
                 result = self._GenerateOne(token)
                 if result is not None:
                     yield result
             except:
                 self.HandleError('exception', token)
                 raise
 

def cpp.ast.AstBuilder.Generate ( self )

Definition at line 704 of file ast.py.

References cpp.ast.AstBuilder._CreateVariable(), cpp.ast.AstBuilder._GenerateOne(), cpp.ast.AstBuilder._GetNextToken(), cpp.ast.AstBuilder.current_token, and cpp.ast.AstBuilder.HandleError().

Referenced by cpp.ast.AstBuilder.Generate().

     def Generate(self):
         while 1:
             token = self._GetNextToken()
             if not token:
                 break
 
             # Get the next token.
             self.current_token = token
 
             # Dispatch on the next token type.
             if token.token_type == _INTERNAL_TOKEN:
                 if token.name == _NAMESPACE_POP:
                     self.namespace_stack.pop()
                 continue
 
             try:
                 result = self._GenerateOne(token)
                 if result is not None:
                     yield result
             except:
                 self.HandleError('exception', token)
                 raise
 

def cpp.ast.AstBuilder.GetMethod	(	self,
		modifiers,
		templated_types
	)

Definition at line 953 of file ast.py.

References cpp.ast.AstBuilder._GetMethod(), and cpp.ast.AstBuilder._GetTokensUpTo().

Referenced by cpp.ast.AstBuilder._GetClass(), cpp.ast.AstBuilder.GetMethod(), cpp.ast.AstBuilder.handle_explicit(), and cpp.ast.AstBuilder.handle_template().

     def GetMethod(self, modifiers, templated_types):
         return_type_and_name = self._GetTokensUpTo(tokenize.SYNTAX, '(')
         assert len(return_type_and_name) >= 1
         return self._GetMethod(return_type_and_name, modifiers, templated_types,
                                False)
 

def cpp.ast.AstBuilder.GetMethod	(	self,
		modifiers,
		templated_types
	)

Definition at line 953 of file ast.py.

References cpp.ast.AstBuilder._GetMethod(), cpp.ast.AstBuilder._GetTokensUpTo(), and cpp.ast.AstBuilder.GetMethod().

     def GetMethod(self, modifiers, templated_types):
         return_type_and_name = self._GetTokensUpTo(tokenize.SYNTAX, '(')
         assert len(return_type_and_name) >= 1
         return self._GetMethod(return_type_and_name, modifiers, templated_types,
                                False)
 

def cpp.ast.AstBuilder.GetMethod	(	self,
		modifiers,
		templated_types
	)

Definition at line 953 of file ast.py.

References cpp.ast.AstBuilder._GetMethod(), cpp.ast.AstBuilder._GetTokensUpTo(), and cpp.ast.AstBuilder.GetMethod().

     def GetMethod(self, modifiers, templated_types):
         return_type_and_name = self._GetTokensUpTo(tokenize.SYNTAX, '(')
         assert len(return_type_and_name) >= 1
         return self._GetMethod(return_type_and_name, modifiers, templated_types,
                                False)
 

def cpp.ast.AstBuilder.GetName	(	self,
		seq = `None`
	)

Returns ([tokens], next_token_info).

Definition at line 928 of file ast.py.

References cpp.ast.AstBuilder._GetMatchingChar(), cpp.ast.AstBuilder._GetNextToken(), cpp.ast.AstBuilder.GetName(), and cpp.ast.next().

     def GetName(self, seq=None):
         """Returns ([tokens], next_token_info)."""
         GetNextToken = self._GetNextToken
         if seq is not None:
             it = iter(seq)
             GetNextToken = lambda: next(it)
         next_token = GetNextToken()
         tokens = []
         last_token_was_name = False
         while (next_token.token_type == tokenize.NAME or
                (next_token.token_type == tokenize.SYNTAX and
                 next_token.name in ('::', '<'))):
             # Two NAMEs in a row means the identifier should terminate.
             # It's probably some sort of variable declaration.
             if last_token_was_name and next_token.token_type == tokenize.NAME:
                 break
             last_token_was_name = next_token.token_type == tokenize.NAME
             tokens.append(next_token)
             # Handle templated names.
             if next_token.name == '<':
                 tokens.extend(self._GetMatchingChar('<', '>', GetNextToken))
                 last_token_was_name = True
             next_token = GetNextToken()
         return tokens, next_token
 

def cpp.ast.AstBuilder.GetName	(	self,
		seq = `None`
	)

Returns ([tokens], next_token_info).

Definition at line 928 of file ast.py.

References cpp.ast.AstBuilder._GetMatchingChar(), cpp.ast.AstBuilder._GetNextToken(), cpp.ast.AstBuilder.GetName(), and cpp.ast.next().

     def GetName(self, seq=None):
         """Returns ([tokens], next_token_info)."""
         GetNextToken = self._GetNextToken
         if seq is not None:
             it = iter(seq)
             GetNextToken = lambda: next(it)
         next_token = GetNextToken()
         tokens = []
         last_token_was_name = False
         while (next_token.token_type == tokenize.NAME or
                (next_token.token_type == tokenize.SYNTAX and
                 next_token.name in ('::', '<'))):
             # Two NAMEs in a row means the identifier should terminate.
             # It's probably some sort of variable declaration.
             if last_token_was_name and next_token.token_type == tokenize.NAME:
                 break
             last_token_was_name = next_token.token_type == tokenize.NAME
             tokens.append(next_token)
             # Handle templated names.
             if next_token.name == '<':
                 tokens.extend(self._GetMatchingChar('<', '>', GetNextToken))
                 last_token_was_name = True
             next_token = GetNextToken()
         return tokens, next_token
 

def cpp.ast.AstBuilder.GetName	(	self,
		seq = `None`
	)

Returns ([tokens], next_token_info).

Definition at line 928 of file ast.py.

References cpp.ast.AstBuilder._GetMatchingChar(), cpp.ast.AstBuilder._GetNextToken(), and cpp.ast.next().

Referenced by cpp.ast.AstBuilder._GetBases(), cpp.ast.AstBuilder._GetClass(), cpp.ast.AstBuilder._GetNestedType(), cpp.ast.AstBuilder._GetReturnTypeAndClassName(), cpp.ast.AstBuilder._GetTemplatedTypes(), cpp.ast.AstBuilder.GetName(), cpp.ast.AstBuilder.handle_namespace(), and cpp.ast.AstBuilder.handle_struct().

     def GetName(self, seq=None):
         """Returns ([tokens], next_token_info)."""
         GetNextToken = self._GetNextToken
         if seq is not None:
             it = iter(seq)
             GetNextToken = lambda: next(it)
         next_token = GetNextToken()
         tokens = []
         last_token_was_name = False
         while (next_token.token_type == tokenize.NAME or
                (next_token.token_type == tokenize.SYNTAX and
                 next_token.name in ('::', '<'))):
             # Two NAMEs in a row means the identifier should terminate.
             # It's probably some sort of variable declaration.
             if last_token_was_name and next_token.token_type == tokenize.NAME:
                 break
             last_token_was_name = next_token.token_type == tokenize.NAME
             tokens.append(next_token)
             # Handle templated names.
             if next_token.name == '<':
                 tokens.extend(self._GetMatchingChar('<', '>', GetNextToken))
                 last_token_was_name = True
             next_token = GetNextToken()
         return tokens, next_token
 

def cpp.ast.AstBuilder.GetScope ( self )

Definition at line 902 of file ast.py.

References cpp.ast.AstBuilder._GetMatchingChar().

Referenced by cpp.ast.AstBuilder._GetClass(), cpp.ast.AstBuilder._GetMethod(), cpp.ast.AstBuilder.GetScope(), and cpp.ast.AstBuilder.handle_namespace().

     def GetScope(self):
         return self._GetMatchingChar('{', '}')
 

def cpp.ast.AstBuilder.GetScope ( self )

Definition at line 902 of file ast.py.

References cpp.ast.AstBuilder._GetMatchingChar(), and cpp.ast.AstBuilder.GetScope().

     def GetScope(self):
         return self._GetMatchingChar('{', '}')
 

def cpp.ast.AstBuilder.GetScope ( self )

Definition at line 902 of file ast.py.

References cpp.ast.AstBuilder._GetMatchingChar(), and cpp.ast.AstBuilder.GetScope().

     def GetScope(self):
         return self._GetMatchingChar('{', '}')
 

def cpp.ast.AstBuilder.handle_asm ( self )

Definition at line 1451 of file ast.py.

References cpp.ast.AstBuilder.handle_asm().

     def handle_asm(self):
         pass  # Not needed yet.
 

def cpp.ast.AstBuilder.handle_asm ( self )

Definition at line 1451 of file ast.py.

References cpp.ast.AstBuilder.handle_asm().

     def handle_asm(self):
         pass  # Not needed yet.
 

def cpp.ast.AstBuilder.handle_asm ( self )

Definition at line 1451 of file ast.py.

Referenced by cpp.ast.AstBuilder.handle_asm().

     def handle_asm(self):
         pass  # Not needed yet.
 

def cpp.ast.AstBuilder.handle_auto ( self )

Definition at line 1269 of file ast.py.

Referenced by cpp.ast.AstBuilder.handle_auto().

     def handle_auto(self):
         # TODO(nnorwitz): warn about using auto?  Probably not since it
         # will be reclaimed and useful for C++0x.
         pass
 

def cpp.ast.AstBuilder.handle_auto ( self )

Definition at line 1269 of file ast.py.

References cpp.ast.AstBuilder.handle_auto().

     def handle_auto(self):
         # TODO(nnorwitz): warn about using auto?  Probably not since it
         # will be reclaimed and useful for C++0x.
         pass
 

def cpp.ast.AstBuilder.handle_auto ( self )

Definition at line 1269 of file ast.py.

References cpp.ast.AstBuilder.handle_auto().

     def handle_auto(self):
         # TODO(nnorwitz): warn about using auto?  Probably not since it
         # will be reclaimed and useful for C++0x.
         pass
 

def cpp.ast.AstBuilder.handle_bool ( self )

Definition at line 1160 of file ast.py.

Referenced by cpp.ast.AstBuilder.handle_bool().

     def handle_bool(self):
         pass
 

def cpp.ast.AstBuilder.handle_bool ( self )

Definition at line 1160 of file ast.py.

References cpp.ast.AstBuilder.handle_bool().

     def handle_bool(self):
         pass
 

def cpp.ast.AstBuilder.handle_bool ( self )

Definition at line 1160 of file ast.py.

References cpp.ast.AstBuilder.handle_bool().

     def handle_bool(self):
         pass
 

def cpp.ast.AstBuilder.handle_break ( self )

Definition at line 1656 of file ast.py.

     def handle_break(self):
         self._IgnoreUpTo(tokenize.SYNTAX, ';')
 

def cpp.ast.AstBuilder.handle_break ( self )

Definition at line 1656 of file ast.py.

     def handle_break(self):
         self._IgnoreUpTo(tokenize.SYNTAX, ';')
 

def cpp.ast.AstBuilder.handle_break ( self )

Definition at line 1656 of file ast.py.

     def handle_break(self):
         self._IgnoreUpTo(tokenize.SYNTAX, ';')
 

def cpp.ast.AstBuilder.handle_case ( self )

Definition at line 1610 of file ast.py.

     def handle_case(self):
         pass
 

def cpp.ast.AstBuilder.handle_case ( self )

Definition at line 1610 of file ast.py.

     def handle_case(self):
         pass
 

def cpp.ast.AstBuilder.handle_case ( self )

Definition at line 1610 of file ast.py.

     def handle_case(self):
         pass
 

def cpp.ast.AstBuilder.handle_catch ( self )

Definition at line 1641 of file ast.py.

Referenced by cpp.ast.AstBuilder.handle_catch().

     def handle_catch(self):
         pass  # Not needed yet.
 

def cpp.ast.AstBuilder.handle_catch ( self )

Definition at line 1641 of file ast.py.

References cpp.ast.AstBuilder.handle_catch().

     def handle_catch(self):
         pass  # Not needed yet.
 

def cpp.ast.AstBuilder.handle_catch ( self )

Definition at line 1641 of file ast.py.

References cpp.ast.AstBuilder.handle_catch().

     def handle_catch(self):
         pass  # Not needed yet.
 

def cpp.ast.AstBuilder.handle_char ( self )

Definition at line 1163 of file ast.py.

     def handle_char(self):
         pass
 

def cpp.ast.AstBuilder.handle_char ( self )

Definition at line 1163 of file ast.py.

     def handle_char(self):
         pass
 

def cpp.ast.AstBuilder.handle_char ( self )

Definition at line 1163 of file ast.py.

     def handle_char(self):
         pass
 

def cpp.ast.AstBuilder.handle_class ( self )

Definition at line 1454 of file ast.py.

References cpp.ast.AstBuilder._GetClass(), and cpp.ast.AstBuilder.handle_class().

     def handle_class(self):
         return self._GetClass(Class, VISIBILITY_PRIVATE, None)
 

def cpp.ast.AstBuilder.handle_class ( self )

Definition at line 1454 of file ast.py.

References cpp.ast.AstBuilder._GetClass(), and cpp.ast.AstBuilder.handle_class().

     def handle_class(self):
         return self._GetClass(Class, VISIBILITY_PRIVATE, None)
 

def cpp.ast.AstBuilder.handle_class ( self )

Definition at line 1454 of file ast.py.

References cpp.ast.AstBuilder._GetClass().

Referenced by cpp.ast.AstBuilder.handle_class().

     def handle_class(self):
         return self._GetClass(Class, VISIBILITY_PRIVATE, None)
 

def cpp.ast.AstBuilder.handle_const ( self )

Definition at line 1277 of file ast.py.

     def handle_const(self):
         pass
 

def cpp.ast.AstBuilder.handle_const ( self )

Definition at line 1277 of file ast.py.

     def handle_const(self):
         pass
 

def cpp.ast.AstBuilder.handle_const ( self )

Definition at line 1277 of file ast.py.

     def handle_const(self):
         pass
 

def cpp.ast.AstBuilder.handle_const_cast ( self )

Definition at line 1332 of file ast.py.

     def handle_const_cast(self):
         pass
 

def cpp.ast.AstBuilder.handle_const_cast ( self )

Definition at line 1332 of file ast.py.

Referenced by cpp.ast.AstBuilder.handle_const_cast().

     def handle_const_cast(self):
         pass
 

def cpp.ast.AstBuilder.handle_const_cast ( self )

Definition at line 1332 of file ast.py.

     def handle_const_cast(self):
         pass
 

def cpp.ast.AstBuilder.handle_continue ( self )

Definition at line 1659 of file ast.py.

References cpp.ast.AstBuilder._IgnoreUpTo(), cpp.ast.BuilderFromSource(), folly::pushmi::operators.filter, cpp.ast.AstBuilder.handle_continue(), cpp.ast.main(), cpp.ast.PrintAllIndentifiers(), and cpp.ast.PrintIndentifiers().

     def handle_continue(self):
         self._IgnoreUpTo(tokenize.SYNTAX, ';')

def cpp.ast.AstBuilder.handle_continue ( self )

Definition at line 1659 of file ast.py.

References cpp.ast.AstBuilder._IgnoreUpTo().

Referenced by cpp.ast.AstBuilder.handle_continue().

     def handle_continue(self):
         self._IgnoreUpTo(tokenize.SYNTAX, ';')

def cpp.ast.AstBuilder.handle_continue ( self )

Definition at line 1659 of file ast.py.

References cpp.ast.AstBuilder._IgnoreUpTo(), cpp.ast.BuilderFromSource(), folly::pushmi::operators.filter, cpp.ast.AstBuilder.handle_continue(), cpp.ast.main(), cpp.ast.PrintAllIndentifiers(), and cpp.ast.PrintIndentifiers().

     def handle_continue(self):
         self._IgnoreUpTo(tokenize.SYNTAX, ';')

def cpp.ast.AstBuilder.handle_default ( self )

Definition at line 1616 of file ast.py.

     def handle_default(self):
         token = self._GetNextToken()
         assert token.token_type == tokenize.SYNTAX
         assert token.name == ':'
 

def cpp.ast.AstBuilder.handle_default ( self )

Definition at line 1616 of file ast.py.

     def handle_default(self):
         token = self._GetNextToken()
         assert token.token_type == tokenize.SYNTAX
         assert token.name == ':'
 

def cpp.ast.AstBuilder.handle_default ( self )

Definition at line 1616 of file ast.py.

     def handle_default(self):
         token = self._GetNextToken()
         assert token.token_type == tokenize.SYNTAX
         assert token.name == ':'
 

def cpp.ast.AstBuilder.handle_delete ( self )

Definition at line 1344 of file ast.py.

     def handle_delete(self):
         tokens = self._GetTokensUpTo(tokenize.SYNTAX, ';')
         assert tokens
         return Delete(tokens[0].start, tokens[0].end, tokens)
 

def cpp.ast.AstBuilder.handle_delete ( self )

Definition at line 1344 of file ast.py.

Referenced by cpp.ast.AstBuilder.handle_delete().

     def handle_delete(self):
         tokens = self._GetTokensUpTo(tokenize.SYNTAX, ';')
         assert tokens
         return Delete(tokens[0].start, tokens[0].end, tokens)
 

def cpp.ast.AstBuilder.handle_delete ( self )

Definition at line 1344 of file ast.py.

     def handle_delete(self):
         tokens = self._GetTokensUpTo(tokenize.SYNTAX, ';')
         assert tokens
         return Delete(tokens[0].start, tokens[0].end, tokens)
 

def cpp.ast.AstBuilder.handle_do ( self )

Definition at line 1650 of file ast.py.

     def handle_do(self):
         pass
 

def cpp.ast.AstBuilder.handle_do ( self )

Definition at line 1650 of file ast.py.

     def handle_do(self):
         pass
 

def cpp.ast.AstBuilder.handle_do ( self )

Definition at line 1650 of file ast.py.

     def handle_do(self):
         pass
 

def cpp.ast.AstBuilder.handle_double ( self )

Definition at line 1175 of file ast.py.

     def handle_double(self):
         pass
 

def cpp.ast.AstBuilder.handle_double ( self )

Definition at line 1175 of file ast.py.

     def handle_double(self):
         pass
 

def cpp.ast.AstBuilder.handle_double ( self )

Definition at line 1175 of file ast.py.

     def handle_double(self):
         pass
 

def cpp.ast.AstBuilder.handle_dynamic_cast ( self )

Definition at line 1335 of file ast.py.

     def handle_dynamic_cast(self):
         pass
 

def cpp.ast.AstBuilder.handle_dynamic_cast ( self )

Definition at line 1335 of file ast.py.

Referenced by cpp.ast.AstBuilder.handle_dynamic_cast().

     def handle_dynamic_cast(self):
         pass
 

def cpp.ast.AstBuilder.handle_dynamic_cast ( self )

Definition at line 1335 of file ast.py.

     def handle_dynamic_cast(self):
         pass
 

def cpp.ast.AstBuilder.handle_else ( self )

Definition at line 1624 of file ast.py.

     def handle_else(self):
         pass
 

def cpp.ast.AstBuilder.handle_else ( self )

Definition at line 1624 of file ast.py.

     def handle_else(self):
         pass
 

def cpp.ast.AstBuilder.handle_else ( self )

Definition at line 1624 of file ast.py.

     def handle_else(self):
         pass
 

def cpp.ast.AstBuilder.handle_enum ( self )

Definition at line 1266 of file ast.py.

References cpp.ast.AstBuilder._GetNestedType().

Referenced by cpp.ast.AstBuilder.handle_enum().

     def handle_enum(self):
         return self._GetNestedType(Enum)
 

def cpp.ast.AstBuilder.handle_enum ( self )

Definition at line 1266 of file ast.py.

References cpp.ast.AstBuilder._GetNestedType(), and cpp.ast.AstBuilder.handle_enum().

     def handle_enum(self):
         return self._GetNestedType(Enum)
 

def cpp.ast.AstBuilder.handle_enum ( self )

Definition at line 1266 of file ast.py.

References cpp.ast.AstBuilder._GetNestedType(), and cpp.ast.AstBuilder.handle_enum().

     def handle_enum(self):
         return self._GetNestedType(Enum)
 

def cpp.ast.AstBuilder.handle_explicit ( self )

Definition at line 1593 of file ast.py.

References cpp.ast.AstBuilder.GetMethod(), cpp.ast.Method.in_class, and cpp.ast.AstBuilder.in_class.

Referenced by cpp.ast.AstBuilder.handle_explicit().

     def handle_explicit(self):
         assert self.in_class
         # Nothing much to do.
         # TODO(nnorwitz): maybe verify the method name == class name.
         # This must be a ctor.
         return self.GetMethod(FUNCTION_CTOR, None)
 

def cpp.ast.AstBuilder.handle_explicit ( self )

Definition at line 1593 of file ast.py.

References cpp.ast.AstBuilder.GetMethod(), cpp.ast.AstBuilder.handle_explicit(), cpp.ast.Method.in_class, and cpp.ast.AstBuilder.in_class.

     def handle_explicit(self):
         assert self.in_class
         # Nothing much to do.
         # TODO(nnorwitz): maybe verify the method name == class name.
         # This must be a ctor.
         return self.GetMethod(FUNCTION_CTOR, None)
 

def cpp.ast.AstBuilder.handle_explicit ( self )

Definition at line 1593 of file ast.py.

References cpp.ast.AstBuilder.GetMethod(), cpp.ast.AstBuilder.handle_explicit(), cpp.ast.Method.in_class, and cpp.ast.AstBuilder.in_class.

     def handle_explicit(self):
         assert self.in_class
         # Nothing much to do.
         # TODO(nnorwitz): maybe verify the method name == class name.
         # This must be a ctor.
         return self.GetMethod(FUNCTION_CTOR, None)
 

def cpp.ast.AstBuilder.handle_extern ( self )

Definition at line 1283 of file ast.py.

     def handle_extern(self):
         pass
 

def cpp.ast.AstBuilder.handle_extern ( self )

Definition at line 1283 of file ast.py.

     def handle_extern(self):
         pass
 

def cpp.ast.AstBuilder.handle_extern ( self )

Definition at line 1283 of file ast.py.

     def handle_extern(self):
         pass
 

def cpp.ast.AstBuilder.handle_false ( self )

Definition at line 1448 of file ast.py.

References cpp.ast.AstBuilder.handle_false().

     def handle_false(self):
         pass  # Nothing to do.
 

def cpp.ast.AstBuilder.handle_false ( self )

Definition at line 1448 of file ast.py.

References cpp.ast.AstBuilder.handle_false().

     def handle_false(self):
         pass  # Nothing to do.
 

def cpp.ast.AstBuilder.handle_false ( self )

Definition at line 1448 of file ast.py.

Referenced by cpp.ast.AstBuilder.handle_false().

     def handle_false(self):
         pass  # Nothing to do.
 

def cpp.ast.AstBuilder.handle_float ( self )

Definition at line 1178 of file ast.py.

     def handle_float(self):
         pass
 

def cpp.ast.AstBuilder.handle_float ( self )

Definition at line 1178 of file ast.py.

     def handle_float(self):
         pass
 

def cpp.ast.AstBuilder.handle_float ( self )

Definition at line 1178 of file ast.py.

Referenced by cpp.ast.AstBuilder.handle_float().

     def handle_float(self):
         pass
 

def cpp.ast.AstBuilder.handle_for ( self )

Definition at line 1653 of file ast.py.

     def handle_for(self):
         pass
 

def cpp.ast.AstBuilder.handle_for ( self )

Definition at line 1653 of file ast.py.

     def handle_for(self):
         pass
 

def cpp.ast.AstBuilder.handle_for ( self )

Definition at line 1653 of file ast.py.

Referenced by cpp.ast.AstBuilder.handle_for().

     def handle_for(self):
         pass
 

def cpp.ast.AstBuilder.handle_friend ( self )

Definition at line 1323 of file ast.py.

References cpp.ast.AstBuilder._GetTokensUpTo(), cpp.ast.AstBuilder.handle_friend(), cpp.ast.TypeConverter.namespace_stack, and cpp.ast.AstBuilder.namespace_stack.

     def handle_friend(self):
         tokens = self._GetTokensUpTo(tokenize.SYNTAX, ';')
         assert tokens
         t0 = tokens[0]
         return Friend(t0.start, t0.end, tokens, self.namespace_stack)
 

def cpp.ast.AstBuilder.handle_friend ( self )

Definition at line 1323 of file ast.py.

References cpp.ast.AstBuilder._GetTokensUpTo(), cpp.ast.TypeConverter.namespace_stack, and cpp.ast.AstBuilder.namespace_stack.

Referenced by cpp.ast.AstBuilder.handle_friend(), and cpp.ast.AstBuilder.handle_template().

     def handle_friend(self):
         tokens = self._GetTokensUpTo(tokenize.SYNTAX, ';')
         assert tokens
         t0 = tokens[0]
         return Friend(t0.start, t0.end, tokens, self.namespace_stack)
 

def cpp.ast.AstBuilder.handle_friend ( self )

Definition at line 1323 of file ast.py.

References cpp.ast.AstBuilder._GetTokensUpTo(), cpp.ast.AstBuilder.handle_friend(), cpp.ast.TypeConverter.namespace_stack, and cpp.ast.AstBuilder.namespace_stack.

     def handle_friend(self):
         tokens = self._GetTokensUpTo(tokenize.SYNTAX, ';')
         assert tokens
         t0 = tokens[0]
         return Friend(t0.start, t0.end, tokens, self.namespace_stack)
 

def cpp.ast.AstBuilder.handle_goto ( self )

Definition at line 1633 of file ast.py.

References cpp.ast.AstBuilder._GetTokensUpTo().

Referenced by cpp.ast.AstBuilder.handle_goto().

     def handle_goto(self):
         tokens = self._GetTokensUpTo(tokenize.SYNTAX, ';')
         assert len(tokens) == 1, str(tokens)
         return Goto(tokens[0].start, tokens[0].end, tokens[0].name)
 

def cpp.ast.AstBuilder.handle_goto ( self )

Definition at line 1633 of file ast.py.

References cpp.ast.AstBuilder._GetTokensUpTo(), and cpp.ast.AstBuilder.handle_goto().

     def handle_goto(self):
         tokens = self._GetTokensUpTo(tokenize.SYNTAX, ';')
         assert len(tokens) == 1, str(tokens)
         return Goto(tokens[0].start, tokens[0].end, tokens[0].name)
 

def cpp.ast.AstBuilder.handle_goto ( self )

Definition at line 1633 of file ast.py.

References cpp.ast.AstBuilder._GetTokensUpTo(), and cpp.ast.AstBuilder.handle_goto().

     def handle_goto(self):
         tokens = self._GetTokensUpTo(tokenize.SYNTAX, ';')
         assert len(tokens) == 1, str(tokens)
         return Goto(tokens[0].start, tokens[0].end, tokens[0].name)
 

def cpp.ast.AstBuilder.handle_if ( self )

Definition at line 1621 of file ast.py.

References cpp.ast.AstBuilder.handle_if().

     def handle_if(self):
         pass
 

def cpp.ast.AstBuilder.handle_if ( self )

Definition at line 1621 of file ast.py.

Referenced by cpp.ast.AstBuilder.handle_if().

     def handle_if(self):
         pass
 

def cpp.ast.AstBuilder.handle_if ( self )

Definition at line 1621 of file ast.py.

References cpp.ast.AstBuilder.handle_if().

     def handle_if(self):
         pass
 

def cpp.ast.AstBuilder.handle_inline ( self )

Definition at line 1280 of file ast.py.

     def handle_inline(self):
         pass
 

def cpp.ast.AstBuilder.handle_inline ( self )

Definition at line 1280 of file ast.py.

     def handle_inline(self):
         pass
 

def cpp.ast.AstBuilder.handle_inline ( self )

Definition at line 1280 of file ast.py.

     def handle_inline(self):
         pass
 

def cpp.ast.AstBuilder.handle_int ( self )

Definition at line 1166 of file ast.py.

     def handle_int(self):
         pass
 

def cpp.ast.AstBuilder.handle_int ( self )

Definition at line 1166 of file ast.py.

     def handle_int(self):
         pass
 

def cpp.ast.AstBuilder.handle_int ( self )

Definition at line 1166 of file ast.py.

     def handle_int(self):
         pass
 

def cpp.ast.AstBuilder.handle_long ( self )

Definition at line 1169 of file ast.py.

     def handle_long(self):
         pass
 

def cpp.ast.AstBuilder.handle_long ( self )

Definition at line 1169 of file ast.py.

     def handle_long(self):
         pass
 

def cpp.ast.AstBuilder.handle_long ( self )

Definition at line 1169 of file ast.py.

     def handle_long(self):
         pass
 

def cpp.ast.AstBuilder.handle_mutable ( self )

Definition at line 1308 of file ast.py.

     def handle_mutable(self):
         pass
 

def cpp.ast.AstBuilder.handle_mutable ( self )

Definition at line 1308 of file ast.py.

     def handle_mutable(self):
         pass
 

def cpp.ast.AstBuilder.handle_mutable ( self )

Definition at line 1308 of file ast.py.

     def handle_mutable(self):
         pass
 

def cpp.ast.AstBuilder.handle_namespace ( self )

Definition at line 1561 of file ast.py.

References cpp.ast.AstBuilder._AddBackToken(), cpp.ast.AstBuilder._AddBackTokens(), cpp.ast.AstBuilder._GetNextToken(), cpp.ast.AstBuilder.GetName(), cpp.ast.AstBuilder.GetScope(), and bm.list.

Referenced by cpp.ast.AstBuilder.handle_namespace().

     def handle_namespace(self):
         token = self._GetNextToken()
         # Support anonymous namespaces.
         name = None
         if token.token_type == tokenize.NAME:
             name = token.name
             token = self._GetNextToken()
         self.namespace_stack.append(name)
         assert token.token_type == tokenize.SYNTAX, token
         # Create an internal token that denotes when the namespace is complete.
         internal_token = tokenize.Token(_INTERNAL_TOKEN, _NAMESPACE_POP,
                                         None, None)
         internal_token.whence = token.whence
         if token.name == '=':
             # TODO(nnorwitz): handle aliasing namespaces.
             name, next_token = self.GetName()
             assert next_token.name == ';', next_token
             self._AddBackToken(internal_token)
         else:
             assert token.name == '{', token
             tokens = list(self.GetScope())
             # Replace the trailing } with the internal namespace pop token.
             tokens[-1] = internal_token
             # Handle namespace with nothing in it.
             self._AddBackTokens(tokens)
         return None
 

def cpp.ast.AstBuilder.handle_namespace ( self )

Definition at line 1561 of file ast.py.

References cpp.ast.AstBuilder._AddBackToken(), cpp.ast.AstBuilder._AddBackTokens(), cpp.ast.AstBuilder._GetNextToken(), cpp.ast.AstBuilder.GetName(), cpp.ast.AstBuilder.GetScope(), cpp.ast.AstBuilder.handle_namespace(), and bm.list.

     def handle_namespace(self):
         token = self._GetNextToken()
         # Support anonymous namespaces.
         name = None
         if token.token_type == tokenize.NAME:
             name = token.name
             token = self._GetNextToken()
         self.namespace_stack.append(name)
         assert token.token_type == tokenize.SYNTAX, token
         # Create an internal token that denotes when the namespace is complete.
         internal_token = tokenize.Token(_INTERNAL_TOKEN, _NAMESPACE_POP,
                                         None, None)
         internal_token.whence = token.whence
         if token.name == '=':
             # TODO(nnorwitz): handle aliasing namespaces.
             name, next_token = self.GetName()
             assert next_token.name == ';', next_token
             self._AddBackToken(internal_token)
         else:
             assert token.name == '{', token
             tokens = list(self.GetScope())
             # Replace the trailing } with the internal namespace pop token.
             tokens[-1] = internal_token
             # Handle namespace with nothing in it.
             self._AddBackTokens(tokens)
         return None
 

def cpp.ast.AstBuilder.handle_namespace ( self )

Definition at line 1561 of file ast.py.

References cpp.ast.AstBuilder._AddBackToken(), cpp.ast.AstBuilder._AddBackTokens(), cpp.ast.AstBuilder._GetNextToken(), cpp.ast.AstBuilder.GetName(), cpp.ast.AstBuilder.GetScope(), cpp.ast.AstBuilder.handle_namespace(), and bm.list.

     def handle_namespace(self):
         token = self._GetNextToken()
         # Support anonymous namespaces.
         name = None
         if token.token_type == tokenize.NAME:
             name = token.name
             token = self._GetNextToken()
         self.namespace_stack.append(name)
         assert token.token_type == tokenize.SYNTAX, token
         # Create an internal token that denotes when the namespace is complete.
         internal_token = tokenize.Token(_INTERNAL_TOKEN, _NAMESPACE_POP,
                                         None, None)
         internal_token.whence = token.whence
         if token.name == '=':
             # TODO(nnorwitz): handle aliasing namespaces.
             name, next_token = self.GetName()
             assert next_token.name == ';', next_token
             self._AddBackToken(internal_token)
         else:
             assert token.name == '{', token
             tokens = list(self.GetScope())
             # Replace the trailing } with the internal namespace pop token.
             tokens[-1] = internal_token
             # Handle namespace with nothing in it.
             self._AddBackTokens(tokens)
         return None
 

def cpp.ast.AstBuilder.handle_new ( self )

Definition at line 1341 of file ast.py.

     def handle_new(self):
         pass
 

def cpp.ast.AstBuilder.handle_new ( self )

Definition at line 1341 of file ast.py.

     def handle_new(self):
         pass
 

def cpp.ast.AstBuilder.handle_new ( self )

Definition at line 1341 of file ast.py.

Referenced by cpp.ast.AstBuilder.handle_new().

     def handle_new(self):
         pass
 

def cpp.ast.AstBuilder.handle_operator ( self )

Definition at line 1603 of file ast.py.

Referenced by cpp.ast.AstBuilder.handle_operator().

     def handle_operator(self):
         # Pull off the next token(s?) and make that part of the method name.
         pass
 

def cpp.ast.AstBuilder.handle_operator ( self )

Definition at line 1603 of file ast.py.

References cpp.ast.AstBuilder.handle_operator().

     def handle_operator(self):
         # Pull off the next token(s?) and make that part of the method name.
         pass
 

def cpp.ast.AstBuilder.handle_operator ( self )

Definition at line 1603 of file ast.py.

References cpp.ast.AstBuilder.handle_operator().

     def handle_operator(self):
         # Pull off the next token(s?) and make that part of the method name.
         pass
 

def cpp.ast.AstBuilder.handle_private ( self )

Definition at line 1319 of file ast.py.

References cpp.ast.AstBuilder.handle_private(), cpp.ast.Method.in_class, cpp.ast.AstBuilder.in_class, and cpp.ast.AstBuilder.visibility.

     def handle_private(self):
         assert self.in_class
         self.visibility = VISIBILITY_PRIVATE
 

def cpp.ast.AstBuilder.handle_private ( self )

Definition at line 1319 of file ast.py.

References cpp.ast.Method.in_class, cpp.ast.AstBuilder.in_class, and cpp.ast.AstBuilder.visibility.

Referenced by cpp.ast.AstBuilder.handle_private().

     def handle_private(self):
         assert self.in_class
         self.visibility = VISIBILITY_PRIVATE
 

def cpp.ast.AstBuilder.handle_private ( self )

Definition at line 1319 of file ast.py.

References cpp.ast.AstBuilder.handle_private(), cpp.ast.Method.in_class, cpp.ast.AstBuilder.in_class, and cpp.ast.AstBuilder.visibility.

     def handle_private(self):
         assert self.in_class
         self.visibility = VISIBILITY_PRIVATE
 

def cpp.ast.AstBuilder.handle_protected ( self )

Definition at line 1315 of file ast.py.

References cpp.ast.AstBuilder.handle_protected(), cpp.ast.Method.in_class, cpp.ast.AstBuilder.in_class, and cpp.ast.AstBuilder.visibility.

     def handle_protected(self):
         assert self.in_class
         self.visibility = VISIBILITY_PROTECTED
 

def cpp.ast.AstBuilder.handle_protected ( self )

Definition at line 1315 of file ast.py.

References cpp.ast.AstBuilder.handle_protected(), cpp.ast.Method.in_class, cpp.ast.AstBuilder.in_class, and cpp.ast.AstBuilder.visibility.

     def handle_protected(self):
         assert self.in_class
         self.visibility = VISIBILITY_PROTECTED
 

def cpp.ast.AstBuilder.handle_protected ( self )

Definition at line 1315 of file ast.py.

References cpp.ast.Method.in_class, cpp.ast.AstBuilder.in_class, and cpp.ast.AstBuilder.visibility.

Referenced by cpp.ast.AstBuilder.handle_protected().

     def handle_protected(self):
         assert self.in_class
         self.visibility = VISIBILITY_PROTECTED
 

def cpp.ast.AstBuilder.handle_public ( self )

Definition at line 1311 of file ast.py.

     def handle_public(self):
         assert self.in_class
         self.visibility = VISIBILITY_PUBLIC
 

def cpp.ast.AstBuilder.handle_public ( self )

Definition at line 1311 of file ast.py.

     def handle_public(self):
         assert self.in_class
         self.visibility = VISIBILITY_PUBLIC
 

def cpp.ast.AstBuilder.handle_public ( self )

Definition at line 1311 of file ast.py.

     def handle_public(self):
         assert self.in_class
         self.visibility = VISIBILITY_PUBLIC
 

def cpp.ast.AstBuilder.handle_register ( self )

Definition at line 1274 of file ast.py.

     def handle_register(self):
         pass
 

def cpp.ast.AstBuilder.handle_register ( self )

Definition at line 1274 of file ast.py.

Referenced by cpp.ast.AstBuilder.handle_register().

     def handle_register(self):
         pass
 

def cpp.ast.AstBuilder.handle_register ( self )

Definition at line 1274 of file ast.py.

     def handle_register(self):
         pass
 

def cpp.ast.AstBuilder.handle_reinterpret_cast ( self )

Definition at line 1338 of file ast.py.

     def handle_reinterpret_cast(self):
         pass
 

def cpp.ast.AstBuilder.handle_reinterpret_cast ( self )

Definition at line 1338 of file ast.py.

     def handle_reinterpret_cast(self):
         pass
 

def cpp.ast.AstBuilder.handle_reinterpret_cast ( self )

Definition at line 1338 of file ast.py.

Referenced by cpp.ast.AstBuilder.handle_reinterpret_cast().

     def handle_reinterpret_cast(self):
         pass
 

def cpp.ast.AstBuilder.handle_return ( self )

Definition at line 1627 of file ast.py.

     def handle_return(self):
         tokens = self._GetTokensUpTo(tokenize.SYNTAX, ';')
         if not tokens:
             return Return(self.current_token.start, self.current_token.end, None)
         return Return(tokens[0].start, tokens[0].end, tokens)
 

def cpp.ast.AstBuilder.handle_return ( self )

Definition at line 1627 of file ast.py.

     def handle_return(self):
         tokens = self._GetTokensUpTo(tokenize.SYNTAX, ';')
         if not tokens:
             return Return(self.current_token.start, self.current_token.end, None)
         return Return(tokens[0].start, tokens[0].end, tokens)
 

def cpp.ast.AstBuilder.handle_return ( self )

Definition at line 1627 of file ast.py.

     def handle_return(self):
         tokens = self._GetTokensUpTo(tokenize.SYNTAX, ';')
         if not tokens:
             return Return(self.current_token.start, self.current_token.end, None)
         return Return(tokens[0].start, tokens[0].end, tokens)
 

def cpp.ast.AstBuilder.handle_short ( self )

Definition at line 1172 of file ast.py.

     def handle_short(self):
         pass
 

def cpp.ast.AstBuilder.handle_short ( self )

Definition at line 1172 of file ast.py.

     def handle_short(self):
         pass
 

def cpp.ast.AstBuilder.handle_short ( self )

Definition at line 1172 of file ast.py.

Referenced by cpp.ast.AstBuilder.handle_short().

     def handle_short(self):
         pass
 

def cpp.ast.AstBuilder.handle_signed ( self )

Definition at line 1190 of file ast.py.

     def handle_signed(self):
         pass
 

def cpp.ast.AstBuilder.handle_signed ( self )

Definition at line 1190 of file ast.py.

Referenced by cpp.ast.AstBuilder.handle_signed().

     def handle_signed(self):
         pass
 

def cpp.ast.AstBuilder.handle_signed ( self )

Definition at line 1190 of file ast.py.

     def handle_signed(self):
         pass
 

def cpp.ast.AstBuilder.handle_sizeof ( self )

Definition at line 1607 of file ast.py.

     def handle_sizeof(self):
         pass
 

def cpp.ast.AstBuilder.handle_sizeof ( self )

Definition at line 1607 of file ast.py.

     def handle_sizeof(self):
         pass
 

def cpp.ast.AstBuilder.handle_sizeof ( self )

Definition at line 1607 of file ast.py.

     def handle_sizeof(self):
         pass
 

def cpp.ast.AstBuilder.handle_static ( self )

Definition at line 1286 of file ast.py.

     def handle_static(self):
         pass
 

def cpp.ast.AstBuilder.handle_static ( self )

Definition at line 1286 of file ast.py.

     def handle_static(self):
         pass
 

def cpp.ast.AstBuilder.handle_static ( self )

Definition at line 1286 of file ast.py.

Referenced by cpp.ast.AstBuilder.handle_static().

     def handle_static(self):
         pass
 

def cpp.ast.AstBuilder.handle_static_cast ( self )

Definition at line 1329 of file ast.py.

References cpp.ast.AstBuilder.handle_static_cast().

     def handle_static_cast(self):
         pass
 

def cpp.ast.AstBuilder.handle_static_cast ( self )

Definition at line 1329 of file ast.py.

References cpp.ast.AstBuilder.handle_static_cast().

     def handle_static_cast(self):
         pass
 

def cpp.ast.AstBuilder.handle_static_cast ( self )

Definition at line 1329 of file ast.py.

Referenced by cpp.ast.AstBuilder.handle_static_cast().

     def handle_static_cast(self):
         pass
 

def cpp.ast.AstBuilder.handle_struct ( self )

Definition at line 1227 of file ast.py.

References cpp.ast.AstBuilder._AddBackToken(), cpp.ast.AstBuilder._AddBackTokens(), cpp.ast.AstBuilder._CreateVariable(), cpp.ast.AstBuilder._GetClass(), cpp.ast.AstBuilder._GetMethod(), cpp.ast.AstBuilder._GetNextToken(), cpp.ast.AstBuilder._handling_typedef, cpp.ast.AstBuilder.GetName(), cpp.ast.AstBuilder.handle_struct(), and join.

     def handle_struct(self):
         # Special case the handling typedef/aliasing of structs here.
         # It would be a pain to handle in the class code.
         name_tokens, var_token = self.GetName()
         if name_tokens:
             next_token = self._GetNextToken()
             is_syntax = (var_token.token_type == tokenize.SYNTAX and
                          var_token.name[0] in '*&')
             is_variable = (var_token.token_type == tokenize.NAME and
                            next_token.name == ';')
             variable = var_token
             if is_syntax and not is_variable:
                 variable = next_token
                 temp = self._GetNextToken()
                 if temp.token_type == tokenize.SYNTAX and temp.name == '(':
                     # Handle methods declared to return a struct.
                     t0 = name_tokens[0]
                     struct = tokenize.Token(tokenize.NAME, 'struct',
                                             t0.start-7, t0.start-2)
                     type_and_name = [struct]
                     type_and_name.extend(name_tokens)
                     type_and_name.extend((var_token, next_token))
                     return self._GetMethod(type_and_name, 0, None, False)
                 assert temp.name == ';', (temp, name_tokens, var_token)
             if is_syntax or (is_variable and not self._handling_typedef):
                 modifiers = ['struct']
                 type_name = ''.join([t.name for t in name_tokens])
                 position = name_tokens[0]
                 return self._CreateVariable(position, variable.name, type_name,
                                             modifiers, var_token.name, None)
             name_tokens.extend((var_token, next_token))
             self._AddBackTokens(name_tokens)
         else:
             self._AddBackToken(var_token)
         return self._GetClass(Struct, VISIBILITY_PUBLIC, None)
 

def cpp.ast.AstBuilder.handle_struct ( self )

Definition at line 1227 of file ast.py.

References cpp.ast.AstBuilder._AddBackToken(), cpp.ast.AstBuilder._AddBackTokens(), cpp.ast.AstBuilder._CreateVariable(), cpp.ast.AstBuilder._GetClass(), cpp.ast.AstBuilder._GetMethod(), cpp.ast.AstBuilder._GetNextToken(), cpp.ast.AstBuilder._handling_typedef, cpp.ast.AstBuilder.GetName(), cpp.ast.AstBuilder.handle_struct(), and join.

     def handle_struct(self):
         # Special case the handling typedef/aliasing of structs here.
         # It would be a pain to handle in the class code.
         name_tokens, var_token = self.GetName()
         if name_tokens:
             next_token = self._GetNextToken()
             is_syntax = (var_token.token_type == tokenize.SYNTAX and
                          var_token.name[0] in '*&')
             is_variable = (var_token.token_type == tokenize.NAME and
                            next_token.name == ';')
             variable = var_token
             if is_syntax and not is_variable:
                 variable = next_token
                 temp = self._GetNextToken()
                 if temp.token_type == tokenize.SYNTAX and temp.name == '(':
                     # Handle methods declared to return a struct.
                     t0 = name_tokens[0]
                     struct = tokenize.Token(tokenize.NAME, 'struct',
                                             t0.start-7, t0.start-2)
                     type_and_name = [struct]
                     type_and_name.extend(name_tokens)
                     type_and_name.extend((var_token, next_token))
                     return self._GetMethod(type_and_name, 0, None, False)
                 assert temp.name == ';', (temp, name_tokens, var_token)
             if is_syntax or (is_variable and not self._handling_typedef):
                 modifiers = ['struct']
                 type_name = ''.join([t.name for t in name_tokens])
                 position = name_tokens[0]
                 return self._CreateVariable(position, variable.name, type_name,
                                             modifiers, var_token.name, None)
             name_tokens.extend((var_token, next_token))
             self._AddBackTokens(name_tokens)
         else:
             self._AddBackToken(var_token)
         return self._GetClass(Struct, VISIBILITY_PUBLIC, None)
 

def cpp.ast.AstBuilder.handle_struct ( self )

Definition at line 1227 of file ast.py.

References cpp.ast.AstBuilder._AddBackToken(), cpp.ast.AstBuilder._AddBackTokens(), cpp.ast.AstBuilder._CreateVariable(), cpp.ast.AstBuilder._GetClass(), cpp.ast.AstBuilder._GetMethod(), cpp.ast.AstBuilder._GetNextToken(), cpp.ast.AstBuilder._handling_typedef, cpp.ast.AstBuilder.GetName(), and join.

Referenced by cpp.ast.AstBuilder.handle_struct().

     def handle_struct(self):
         # Special case the handling typedef/aliasing of structs here.
         # It would be a pain to handle in the class code.
         name_tokens, var_token = self.GetName()
         if name_tokens:
             next_token = self._GetNextToken()
             is_syntax = (var_token.token_type == tokenize.SYNTAX and
                          var_token.name[0] in '*&')
             is_variable = (var_token.token_type == tokenize.NAME and
                            next_token.name == ';')
             variable = var_token
             if is_syntax and not is_variable:
                 variable = next_token
                 temp = self._GetNextToken()
                 if temp.token_type == tokenize.SYNTAX and temp.name == '(':
                     # Handle methods declared to return a struct.
                     t0 = name_tokens[0]
                     struct = tokenize.Token(tokenize.NAME, 'struct',
                                             t0.start-7, t0.start-2)
                     type_and_name = [struct]
                     type_and_name.extend(name_tokens)
                     type_and_name.extend((var_token, next_token))
                     return self._GetMethod(type_and_name, 0, None, False)
                 assert temp.name == ';', (temp, name_tokens, var_token)
             if is_syntax or (is_variable and not self._handling_typedef):
                 modifiers = ['struct']
                 type_name = ''.join([t.name for t in name_tokens])
                 position = name_tokens[0]
                 return self._CreateVariable(position, variable.name, type_name,
                                             modifiers, var_token.name, None)
             name_tokens.extend((var_token, next_token))
             self._AddBackTokens(name_tokens)
         else:
             self._AddBackToken(var_token)
         return self._GetClass(Struct, VISIBILITY_PUBLIC, None)
 

def cpp.ast.AstBuilder.handle_switch ( self )

Definition at line 1613 of file ast.py.

     def handle_switch(self):
         pass
 

def cpp.ast.AstBuilder.handle_switch ( self )

Definition at line 1613 of file ast.py.

     def handle_switch(self):
         pass
 

def cpp.ast.AstBuilder.handle_switch ( self )

Definition at line 1613 of file ast.py.

Referenced by cpp.ast.AstBuilder.handle_switch().

     def handle_switch(self):
         pass
 

def cpp.ast.AstBuilder.handle_template ( self )

Definition at line 1422 of file ast.py.

References cpp.ast.AstBuilder._AddBackToken(), cpp.ast.AstBuilder._AddBackTokens(), cpp.ast.AstBuilder._GetClass(), cpp.ast.AstBuilder._GetNextToken(), cpp.ast.AstBuilder._GetTemplatedTypes(), cpp.ast.AstBuilder._GetVarTokensUpTo(), cpp.ast.AstBuilder.GetMethod(), cpp.ast.AstBuilder.handle_friend(), and cpp.ast.AstBuilder.handle_template().

     def handle_template(self):
         token = self._GetNextToken()
         assert token.token_type == tokenize.SYNTAX, token
         assert token.name == '<', token
         templated_types = self._GetTemplatedTypes()
         # TODO(nnorwitz): for now, just ignore the template params.
         token = self._GetNextToken()
         if token.token_type == tokenize.NAME:
             if token.name == 'class':
                 return self._GetClass(Class, VISIBILITY_PRIVATE, templated_types)
             elif token.name == 'struct':
                 return self._GetClass(Struct, VISIBILITY_PUBLIC, templated_types)
             elif token.name == 'friend':
                 return self.handle_friend()
         self._AddBackToken(token)
         tokens, last = self._GetVarTokensUpTo(tokenize.SYNTAX, '(', ';')
         tokens.append(last)
         self._AddBackTokens(tokens)
         if last.name == '(':
             return self.GetMethod(FUNCTION_NONE, templated_types)
         # Must be a variable definition.
         return None
 

def cpp.ast.AstBuilder.handle_template ( self )

Definition at line 1422 of file ast.py.

References cpp.ast.AstBuilder._AddBackToken(), cpp.ast.AstBuilder._AddBackTokens(), cpp.ast.AstBuilder._GetClass(), cpp.ast.AstBuilder._GetNextToken(), cpp.ast.AstBuilder._GetTemplatedTypes(), cpp.ast.AstBuilder._GetVarTokensUpTo(), cpp.ast.AstBuilder.GetMethod(), and cpp.ast.AstBuilder.handle_friend().

Referenced by cpp.ast.AstBuilder.handle_template().

     def handle_template(self):
         token = self._GetNextToken()
         assert token.token_type == tokenize.SYNTAX, token
         assert token.name == '<', token
         templated_types = self._GetTemplatedTypes()
         # TODO(nnorwitz): for now, just ignore the template params.
         token = self._GetNextToken()
         if token.token_type == tokenize.NAME:
             if token.name == 'class':
                 return self._GetClass(Class, VISIBILITY_PRIVATE, templated_types)
             elif token.name == 'struct':
                 return self._GetClass(Struct, VISIBILITY_PUBLIC, templated_types)
             elif token.name == 'friend':
                 return self.handle_friend()
         self._AddBackToken(token)
         tokens, last = self._GetVarTokensUpTo(tokenize.SYNTAX, '(', ';')
         tokens.append(last)
         self._AddBackTokens(tokens)
         if last.name == '(':
             return self.GetMethod(FUNCTION_NONE, templated_types)
         # Must be a variable definition.
         return None
 

def cpp.ast.AstBuilder.handle_template ( self )

Definition at line 1422 of file ast.py.

References cpp.ast.AstBuilder._AddBackToken(), cpp.ast.AstBuilder._AddBackTokens(), cpp.ast.AstBuilder._GetClass(), cpp.ast.AstBuilder._GetNextToken(), cpp.ast.AstBuilder._GetTemplatedTypes(), cpp.ast.AstBuilder._GetVarTokensUpTo(), cpp.ast.AstBuilder.GetMethod(), cpp.ast.AstBuilder.handle_friend(), and cpp.ast.AstBuilder.handle_template().

     def handle_template(self):
         token = self._GetNextToken()
         assert token.token_type == tokenize.SYNTAX, token
         assert token.name == '<', token
         templated_types = self._GetTemplatedTypes()
         # TODO(nnorwitz): for now, just ignore the template params.
         token = self._GetNextToken()
         if token.token_type == tokenize.NAME:
             if token.name == 'class':
                 return self._GetClass(Class, VISIBILITY_PRIVATE, templated_types)
             elif token.name == 'struct':
                 return self._GetClass(Struct, VISIBILITY_PUBLIC, templated_types)
             elif token.name == 'friend':
                 return self.handle_friend()
         self._AddBackToken(token)
         tokens, last = self._GetVarTokensUpTo(tokenize.SYNTAX, '(', ';')
         tokens.append(last)
         self._AddBackTokens(tokens)
         if last.name == '(':
             return self.GetMethod(FUNCTION_NONE, templated_types)
         # Must be a variable definition.
         return None
 

def cpp.ast.AstBuilder.handle_this ( self )

Definition at line 1600 of file ast.py.

Referenced by cpp.ast.AstBuilder.handle_this().

     def handle_this(self):
         pass  # Nothing to do.
 

def cpp.ast.AstBuilder.handle_this ( self )

Definition at line 1600 of file ast.py.

References cpp.ast.AstBuilder.handle_this().

     def handle_this(self):
         pass  # Nothing to do.
 

def cpp.ast.AstBuilder.handle_this ( self )

Definition at line 1600 of file ast.py.

References cpp.ast.AstBuilder.handle_this().

     def handle_this(self):
         pass  # Nothing to do.
 

def cpp.ast.AstBuilder.handle_throw ( self )

Definition at line 1644 of file ast.py.

References cpp.ast.AstBuilder.handle_throw().

     def handle_throw(self):
         pass  # Not needed yet.
 

def cpp.ast.AstBuilder.handle_throw ( self )

Definition at line 1644 of file ast.py.

References cpp.ast.AstBuilder.handle_throw().

     def handle_throw(self):
         pass  # Not needed yet.
 

def cpp.ast.AstBuilder.handle_throw ( self )

Definition at line 1644 of file ast.py.

Referenced by cpp.ast.AstBuilder.handle_throw().

     def handle_throw(self):
         pass  # Not needed yet.
 

def cpp.ast.AstBuilder.handle_true ( self )

Definition at line 1445 of file ast.py.

References cpp.ast.AstBuilder.handle_true().

     def handle_true(self):
         pass  # Nothing to do.
 

def cpp.ast.AstBuilder.handle_true ( self )

Definition at line 1445 of file ast.py.

References cpp.ast.AstBuilder.handle_true().

     def handle_true(self):
         pass  # Nothing to do.
 

def cpp.ast.AstBuilder.handle_true ( self )

Definition at line 1445 of file ast.py.

Referenced by cpp.ast.AstBuilder.handle_true().

     def handle_true(self):
         pass  # Nothing to do.
 

def cpp.ast.AstBuilder.handle_try ( self )

Definition at line 1638 of file ast.py.

References cpp.ast.AstBuilder.handle_try().

     def handle_try(self):
         pass  # Not needed yet.
 

def cpp.ast.AstBuilder.handle_try ( self )

Definition at line 1638 of file ast.py.

Referenced by cpp.ast.AstBuilder.handle_try().

     def handle_try(self):
         pass  # Not needed yet.
 

def cpp.ast.AstBuilder.handle_try ( self )

Definition at line 1638 of file ast.py.

References cpp.ast.AstBuilder.handle_try().

     def handle_try(self):
         pass  # Not needed yet.
 

def cpp.ast.AstBuilder.handle_typedef ( self )

Definition at line 1349 of file ast.py.

References cpp.ast.AstBuilder._GetNextToken(), cpp.ast.AstBuilder._GetTokensUpTo(), cpp.ast.AstBuilder._handling_typedef, cpp.ast.AstBuilder.handle_typedef(), cpp.ast.TypeConverter.namespace_stack, and cpp.ast.AstBuilder.namespace_stack.

     def handle_typedef(self):
         token = self._GetNextToken()
         if (token.token_type == tokenize.NAME and
             keywords.IsKeyword(token.name)):
             # Token must be struct/enum/union/class.
             method = getattr(self, 'handle_' + token.name)
             self._handling_typedef = True
             tokens = [method()]
             self._handling_typedef = False
         else:
             tokens = [token]
 
         # Get the remainder of the typedef up to the semi-colon.
         tokens.extend(self._GetTokensUpTo(tokenize.SYNTAX, ';'))
 
         # TODO(nnorwitz): clean all this up.
         assert tokens
         name = tokens.pop()
         indices = name
         if tokens:
             indices = tokens[0]
         if not indices:
             indices = token
         if name.name == ')':
             # HACK(nnorwitz): Handle pointers to functions "properly".
             if (len(tokens) >= 4 and
                 tokens[1].name == '(' and tokens[2].name == '*'):
                 tokens.append(name)
                 name = tokens[3]
         elif name.name == ']':
             # HACK(nnorwitz): Handle arrays properly.
             if len(tokens) >= 2:
                 tokens.append(name)
                 name = tokens[1]
         new_type = tokens
         if tokens and isinstance(tokens[0], tokenize.Token):
             new_type = self.converter.ToType(tokens)[0]
         return Typedef(indices.start, indices.end, name.name,
                        new_type, self.namespace_stack)
 

def cpp.ast.AstBuilder.handle_typedef ( self )

Definition at line 1349 of file ast.py.

References cpp.ast.AstBuilder._GetNextToken(), cpp.ast.AstBuilder._GetTokensUpTo(), cpp.ast.AstBuilder._handling_typedef, cpp.ast.AstBuilder.handle_typedef(), cpp.ast.TypeConverter.namespace_stack, and cpp.ast.AstBuilder.namespace_stack.

     def handle_typedef(self):
         token = self._GetNextToken()
         if (token.token_type == tokenize.NAME and
             keywords.IsKeyword(token.name)):
             # Token must be struct/enum/union/class.
             method = getattr(self, 'handle_' + token.name)
             self._handling_typedef = True
             tokens = [method()]
             self._handling_typedef = False
         else:
             tokens = [token]
 
         # Get the remainder of the typedef up to the semi-colon.
         tokens.extend(self._GetTokensUpTo(tokenize.SYNTAX, ';'))
 
         # TODO(nnorwitz): clean all this up.
         assert tokens
         name = tokens.pop()
         indices = name
         if tokens:
             indices = tokens[0]
         if not indices:
             indices = token
         if name.name == ')':
             # HACK(nnorwitz): Handle pointers to functions "properly".
             if (len(tokens) >= 4 and
                 tokens[1].name == '(' and tokens[2].name == '*'):
                 tokens.append(name)
                 name = tokens[3]
         elif name.name == ']':
             # HACK(nnorwitz): Handle arrays properly.
             if len(tokens) >= 2:
                 tokens.append(name)
                 name = tokens[1]
         new_type = tokens
         if tokens and isinstance(tokens[0], tokenize.Token):
             new_type = self.converter.ToType(tokens)[0]
         return Typedef(indices.start, indices.end, name.name,
                        new_type, self.namespace_stack)
 

def cpp.ast.AstBuilder.handle_typedef ( self )

Definition at line 1349 of file ast.py.

References cpp.ast.AstBuilder._GetNextToken(), cpp.ast.AstBuilder._GetTokensUpTo(), cpp.ast.AstBuilder._handling_typedef, cpp.ast.TypeConverter.namespace_stack, and cpp.ast.AstBuilder.namespace_stack.

Referenced by cpp.ast.AstBuilder.handle_typedef().

     def handle_typedef(self):
         token = self._GetNextToken()
         if (token.token_type == tokenize.NAME and
             keywords.IsKeyword(token.name)):
             # Token must be struct/enum/union/class.
             method = getattr(self, 'handle_' + token.name)
             self._handling_typedef = True
             tokens = [method()]
             self._handling_typedef = False
         else:
             tokens = [token]
 
         # Get the remainder of the typedef up to the semi-colon.
         tokens.extend(self._GetTokensUpTo(tokenize.SYNTAX, ';'))
 
         # TODO(nnorwitz): clean all this up.
         assert tokens
         name = tokens.pop()
         indices = name
         if tokens:
             indices = tokens[0]
         if not indices:
             indices = token
         if name.name == ')':
             # HACK(nnorwitz): Handle pointers to functions "properly".
             if (len(tokens) >= 4 and
                 tokens[1].name == '(' and tokens[2].name == '*'):
                 tokens.append(name)
                 name = tokens[3]
         elif name.name == ']':
             # HACK(nnorwitz): Handle arrays properly.
             if len(tokens) >= 2:
                 tokens.append(name)
                 name = tokens[1]
         new_type = tokens
         if tokens and isinstance(tokens[0], tokenize.Token):
             new_type = self.converter.ToType(tokens)[0]
         return Typedef(indices.start, indices.end, name.name,
                        new_type, self.namespace_stack)
 

def cpp.ast.AstBuilder.handle_typeid ( self )

Definition at line 1389 of file ast.py.

Referenced by cpp.ast.AstBuilder.handle_typeid().

     def handle_typeid(self):
         pass  # Not needed yet.
 

def cpp.ast.AstBuilder.handle_typeid ( self )

Definition at line 1389 of file ast.py.

References cpp.ast.AstBuilder.handle_typeid().

     def handle_typeid(self):
         pass  # Not needed yet.
 

def cpp.ast.AstBuilder.handle_typeid ( self )

Definition at line 1389 of file ast.py.

References cpp.ast.AstBuilder.handle_typeid().

     def handle_typeid(self):
         pass  # Not needed yet.
 

def cpp.ast.AstBuilder.handle_typename ( self )

Definition at line 1392 of file ast.py.

Referenced by cpp.ast.AstBuilder.handle_typename().

     def handle_typename(self):
         pass  # Not needed yet.
 

def cpp.ast.AstBuilder.handle_typename ( self )

Definition at line 1392 of file ast.py.

References cpp.ast.AstBuilder.handle_typename().

     def handle_typename(self):
         pass  # Not needed yet.
 

def cpp.ast.AstBuilder.handle_typename ( self )

Definition at line 1392 of file ast.py.

References cpp.ast.AstBuilder.handle_typename().

     def handle_typename(self):
         pass  # Not needed yet.
 

def cpp.ast.AstBuilder.handle_union ( self )

Definition at line 1263 of file ast.py.

References cpp.ast.AstBuilder._GetNestedType(), and cpp.ast.AstBuilder.handle_union().

     def handle_union(self):
         return self._GetNestedType(Union)
 

def cpp.ast.AstBuilder.handle_union ( self )

Definition at line 1263 of file ast.py.

References cpp.ast.AstBuilder._GetNestedType(), and cpp.ast.AstBuilder.handle_union().

     def handle_union(self):
         return self._GetNestedType(Union)
 

def cpp.ast.AstBuilder.handle_union ( self )

Definition at line 1263 of file ast.py.

References cpp.ast.AstBuilder._GetNestedType().

Referenced by cpp.ast.AstBuilder.handle_union().

     def handle_union(self):
         return self._GetNestedType(Union)
 

def cpp.ast.AstBuilder.handle_unsigned ( self )

Definition at line 1187 of file ast.py.

     def handle_unsigned(self):
         pass
 

def cpp.ast.AstBuilder.handle_unsigned ( self )

Definition at line 1187 of file ast.py.

Referenced by cpp.ast.AstBuilder.handle_unsigned().

     def handle_unsigned(self):
         pass
 

def cpp.ast.AstBuilder.handle_unsigned ( self )

Definition at line 1187 of file ast.py.

     def handle_unsigned(self):
         pass
 

def cpp.ast.AstBuilder.handle_using ( self )

Definition at line 1588 of file ast.py.

References cpp.ast.AstBuilder._GetTokensUpTo(), and cpp.ast.AstBuilder.handle_using().

     def handle_using(self):
         tokens = self._GetTokensUpTo(tokenize.SYNTAX, ';')
         assert tokens
         return Using(tokens[0].start, tokens[0].end, tokens)
 

def cpp.ast.AstBuilder.handle_using ( self )

Definition at line 1588 of file ast.py.

References cpp.ast.AstBuilder._GetTokensUpTo().

Referenced by cpp.ast.AstBuilder.handle_using().

     def handle_using(self):
         tokens = self._GetTokensUpTo(tokenize.SYNTAX, ';')
         assert tokens
         return Using(tokens[0].start, tokens[0].end, tokens)
 

def cpp.ast.AstBuilder.handle_using ( self )

Definition at line 1588 of file ast.py.

References cpp.ast.AstBuilder._GetTokensUpTo(), and cpp.ast.AstBuilder.handle_using().

     def handle_using(self):
         tokens = self._GetTokensUpTo(tokenize.SYNTAX, ';')
         assert tokens
         return Using(tokens[0].start, tokens[0].end, tokens)
 

def cpp.ast.AstBuilder.handle_virtual ( self )

Definition at line 1289 of file ast.py.

     def handle_virtual(self):
         # What follows must be a method.
         token = token2 = self._GetNextToken()
         if token.name == 'inline':
             # HACK(nnorwitz): handle inline dtors by ignoring 'inline'.
             token2 = self._GetNextToken()
         if token2.token_type == tokenize.SYNTAX and token2.name == '~':
             return self.GetMethod(FUNCTION_VIRTUAL + FUNCTION_DTOR, None)
         assert token.token_type == tokenize.NAME or token.name == '::', token
         return_type_and_name = self._GetTokensUpTo(tokenize.SYNTAX, '(')  # )
         return_type_and_name.insert(0, token)
         if token2 is not token:
             return_type_and_name.insert(1, token2)
         return self._GetMethod(return_type_and_name, FUNCTION_VIRTUAL,
                                None, False)
 

def cpp.ast.AstBuilder.handle_virtual ( self )

Definition at line 1289 of file ast.py.

     def handle_virtual(self):
         # What follows must be a method.
         token = token2 = self._GetNextToken()
         if token.name == 'inline':
             # HACK(nnorwitz): handle inline dtors by ignoring 'inline'.
             token2 = self._GetNextToken()
         if token2.token_type == tokenize.SYNTAX and token2.name == '~':
             return self.GetMethod(FUNCTION_VIRTUAL + FUNCTION_DTOR, None)
         assert token.token_type == tokenize.NAME or token.name == '::', token
         return_type_and_name = self._GetTokensUpTo(tokenize.SYNTAX, '(')  # )
         return_type_and_name.insert(0, token)
         if token2 is not token:
             return_type_and_name.insert(1, token2)
         return self._GetMethod(return_type_and_name, FUNCTION_VIRTUAL,
                                None, False)
 

def cpp.ast.AstBuilder.handle_virtual ( self )

Definition at line 1289 of file ast.py.

Referenced by cpp.ast.AstBuilder.handle_virtual().

     def handle_virtual(self):
         # What follows must be a method.
         token = token2 = self._GetNextToken()
         if token.name == 'inline':
             # HACK(nnorwitz): handle inline dtors by ignoring 'inline'.
             token2 = self._GetNextToken()
         if token2.token_type == tokenize.SYNTAX and token2.name == '~':
             return self.GetMethod(FUNCTION_VIRTUAL + FUNCTION_DTOR, None)
         assert token.token_type == tokenize.NAME or token.name == '::', token
         return_type_and_name = self._GetTokensUpTo(tokenize.SYNTAX, '(')  # )
         return_type_and_name.insert(0, token)
         if token2 is not token:
             return_type_and_name.insert(1, token2)
         return self._GetMethod(return_type_and_name, FUNCTION_VIRTUAL,
                                None, False)
 

def cpp.ast.AstBuilder.handle_void ( self )

Definition at line 1181 of file ast.py.

     def handle_void(self):
         pass
 

def cpp.ast.AstBuilder.handle_void ( self )

Definition at line 1181 of file ast.py.

Referenced by cpp.ast.AstBuilder.handle_void().

     def handle_void(self):
         pass
 

def cpp.ast.AstBuilder.handle_void ( self )

Definition at line 1181 of file ast.py.

     def handle_void(self):
         pass
 

def cpp.ast.AstBuilder.handle_volatile ( self )

Definition at line 1305 of file ast.py.

References cpp.ast.AstBuilder.handle_volatile().

     def handle_volatile(self):
         pass
 

def cpp.ast.AstBuilder.handle_volatile ( self )

Definition at line 1305 of file ast.py.

Referenced by cpp.ast.AstBuilder.handle_volatile().

     def handle_volatile(self):
         pass
 

def cpp.ast.AstBuilder.handle_volatile ( self )

Definition at line 1305 of file ast.py.

References cpp.ast.AstBuilder.handle_volatile().

     def handle_volatile(self):
         pass
 

def cpp.ast.AstBuilder.handle_wchar_t ( self )

Definition at line 1184 of file ast.py.

     def handle_wchar_t(self):
         pass
 

def cpp.ast.AstBuilder.handle_wchar_t ( self )

Definition at line 1184 of file ast.py.

Referenced by cpp.ast.AstBuilder.handle_wchar_t().

     def handle_wchar_t(self):
         pass
 

def cpp.ast.AstBuilder.handle_wchar_t ( self )

Definition at line 1184 of file ast.py.

     def handle_wchar_t(self):
         pass
 

def cpp.ast.AstBuilder.handle_while ( self )

Definition at line 1647 of file ast.py.

References cpp.ast.AstBuilder.handle_while().

     def handle_while(self):
         pass
 

def cpp.ast.AstBuilder.handle_while ( self )

Definition at line 1647 of file ast.py.

Referenced by cpp.ast.AstBuilder.handle_while().

     def handle_while(self):
         pass
 

def cpp.ast.AstBuilder.handle_while ( self )

Definition at line 1647 of file ast.py.

References cpp.ast.AstBuilder.handle_while().

     def handle_while(self):
         pass
 

def cpp.ast.AstBuilder.HandleError	(	self,
		msg,
		token
	)

Definition at line 699 of file ast.py.

References cpp.ast.Include.filename, cpp.ast.AstBuilder.filename, cpp.ast.AstBuilder.HandleError(), bm.list, cpp.ast.reversed(), and cpp.ast.AstBuilder.token_queue.

     def HandleError(self, msg, token):
         printable_queue = list(reversed(self.token_queue[-20:]))
         sys.stderr.write('Got %s in %s @ %s %s\n' %
                          (msg, self.filename, token, printable_queue))
 

def cpp.ast.AstBuilder.HandleError	(	self,
		msg,
		token
	)

Definition at line 699 of file ast.py.

References cpp.ast.Include.filename, cpp.ast.AstBuilder.filename, cpp.ast.AstBuilder.HandleError(), bm.list, cpp.ast.reversed(), and cpp.ast.AstBuilder.token_queue.

     def HandleError(self, msg, token):
         printable_queue = list(reversed(self.token_queue[-20:]))
         sys.stderr.write('Got %s in %s @ %s %s\n' %
                          (msg, self.filename, token, printable_queue))
 

def cpp.ast.AstBuilder.HandleError	(	self,
		msg,
		token
	)

Definition at line 699 of file ast.py.

References cpp.ast.Include.filename, cpp.ast.AstBuilder.filename, bm.list, cpp.ast.reversed(), and cpp.ast.AstBuilder.token_queue.

Referenced by cpp.ast.AstBuilder._GetClass(), cpp.ast.AstBuilder._GetMethod(), cpp.ast.AstBuilder.Generate(), and cpp.ast.AstBuilder.HandleError().

     def HandleError(self, msg, token):
         printable_queue = list(reversed(self.token_queue[-20:]))
         sys.stderr.write('Got %s in %s @ %s %s\n' %
                          (msg, self.filename, token, printable_queue))
 

cpp.ast.AstBuilder._handling_typedef

private

Definition at line 695 of file ast.py.

Referenced by cpp.ast.AstBuilder.__init__(), cpp.ast.AstBuilder._GetClass(), cpp.ast.AstBuilder._GetNestedType(), cpp.ast.AstBuilder.handle_struct(), and cpp.ast.AstBuilder.handle_typedef().

cpp.ast.AstBuilder.converter

Definition at line 697 of file ast.py.

Referenced by cpp.ast.AstBuilder.__init__().

cpp.ast.AstBuilder.current_token

Definition at line 693 of file ast.py.

Referenced by cpp.ast.AstBuilder.__init__(), and cpp.ast.AstBuilder.Generate().

cpp.ast.AstBuilder.filename

Definition at line 680 of file ast.py.

Referenced by cpp.ast.AstBuilder.__init__(), cpp.ast.AstBuilder._GetClass(), and cpp.ast.AstBuilder.HandleError().

cpp.ast.AstBuilder.in_class

Definition at line 686 of file ast.py.

Referenced by cpp.ast.AstBuilder.__init__(), cpp.ast.AstBuilder._GenerateOne(), cpp.ast.AstBuilder._GetMethod(), cpp.ast.AstBuilder.handle_explicit(), cpp.ast.AstBuilder.handle_private(), cpp.ast.AstBuilder.handle_protected(), and cpp.ast.AstBuilder.handle_public().

cpp.ast.AstBuilder.in_class_name_only

Definition at line 688 of file ast.py.

Referenced by cpp.ast.AstBuilder.__init__(), and cpp.ast.AstBuilder._GenerateOne().

cpp.ast.AstBuilder.in_function

Definition at line 692 of file ast.py.

Referenced by cpp.ast.AstBuilder.__init__().

cpp.ast.AstBuilder.namespace_stack

Definition at line 685 of file ast.py.

Referenced by cpp.ast.AstBuilder.__init__(), cpp.ast.AstBuilder._CreateVariable(), cpp.ast.AstBuilder._GetClass(), cpp.ast.AstBuilder._GetMethod(), cpp.ast.AstBuilder._GetNestedType(), cpp.ast.AstBuilder.handle_friend(), and cpp.ast.AstBuilder.handle_typedef().

cpp.ast.AstBuilder.token_queue

Definition at line 684 of file ast.py.

Referenced by cpp.ast.AstBuilder.__init__(), cpp.ast.AstBuilder._AddBackTokens(), cpp.ast.AstBuilder._GetNextToken(), and cpp.ast.AstBuilder.HandleError().

cpp.ast.AstBuilder.tokens

Definition at line 679 of file ast.py.

Referenced by cpp.ast.AstBuilder.__init__(), and cpp.ast.AstBuilder._GetNextToken().

cpp.ast.AstBuilder.visibility

Definition at line 691 of file ast.py.

Referenced by cpp.ast.AstBuilder.__init__(), cpp.ast.AstBuilder.handle_private(), cpp.ast.AstBuilder.handle_protected(), and cpp.ast.AstBuilder.handle_public().

Private Member Functions
def	_CreateVariable (self, pos_token, name, type_name, type_modifiers, ref_pointer_name_seq, templated_types, value=None)

def	_GenerateOne (self, token)

def	_GetTokensUpTo (self, expected_token_type, expected_token)

def	_GetVarTokensUpTo (self, expected_token_type, expected_tokens)

def	_IgnoreUpTo (self, token_type, token)

def	_SkipIf0Blocks (self)

def	_GetMatchingChar (self, open_paren, close_paren, GetNextToken=None)

def	_GetParameters (self)

def	_GetNextToken (self)

def	_AddBackToken (self, token)

def	_AddBackTokens (self, tokens)

def	_GetMethod (self, return_type_and_name, modifiers, templated_types, get_paren)

def	_GetReturnTypeAndClassName (self, token_seq)

def	_GetNestedType (self, ctor)

def	_GetTemplatedTypes (self)

def	_GetBases (self)

def	_GetClass (self, class_type, visibility, templated_types)

def	_CreateVariable (self, pos_token, name, type_name, type_modifiers, ref_pointer_name_seq, templated_types, value=None)

def	_GenerateOne (self, token)

def	_GetTokensUpTo (self, expected_token_type, expected_token)

def	_GetVarTokensUpTo (self, expected_token_type, expected_tokens)

def	_IgnoreUpTo (self, token_type, token)

def	_SkipIf0Blocks (self)

def	_GetMatchingChar (self, open_paren, close_paren, GetNextToken=None)

def	_GetParameters (self)

def	_GetNextToken (self)

def	_AddBackToken (self, token)

def	_AddBackTokens (self, tokens)

def	_GetMethod (self, return_type_and_name, modifiers, templated_types, get_paren)

def	_GetReturnTypeAndClassName (self, token_seq)

def	_GetNestedType (self, ctor)

def	_GetTemplatedTypes (self)

def	_GetBases (self)

def	_GetClass (self, class_type, visibility, templated_types)

def	_CreateVariable (self, pos_token, name, type_name, type_modifiers, ref_pointer_name_seq, templated_types, value=None)

def	_GenerateOne (self, token)

def	_GetTokensUpTo (self, expected_token_type, expected_token)

def	_GetVarTokensUpTo (self, expected_token_type, expected_tokens)

def	_IgnoreUpTo (self, token_type, token)

def	_SkipIf0Blocks (self)

def	_GetMatchingChar (self, open_paren, close_paren, GetNextToken=None)

def	_GetParameters (self)

def	_GetNextToken (self)

def	_AddBackToken (self, token)

def	_AddBackTokens (self, tokens)

def	_GetMethod (self, return_type_and_name, modifiers, templated_types, get_paren)

def	_GetReturnTypeAndClassName (self, token_seq)

def	_GetNestedType (self, ctor)

def	_GetTemplatedTypes (self)

def	_GetBases (self)

def	_GetClass (self, class_type, visibility, templated_types)

Public Member Functions

Public Attributes

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation

Public Member Functions
def	__init__ (self, token_stream, filename, in_class='', visibility=None, namespace_stack=[])

def	HandleError (self, msg, token)

def	Generate (self)

def	GetScope (self)

def	GetName (self, seq=None)

def	GetMethod (self, modifiers, templated_types)

def	handle_bool (self)

def	handle_char (self)

def	handle_int (self)

def	handle_long (self)

def	handle_short (self)

def	handle_double (self)

def	handle_float (self)

def	handle_void (self)

def	handle_wchar_t (self)

def	handle_unsigned (self)

def	handle_signed (self)

def	handle_struct (self)

def	handle_union (self)

def	handle_enum (self)

def	handle_auto (self)

def	handle_register (self)

def	handle_const (self)

def	handle_inline (self)

def	handle_extern (self)

def	handle_static (self)

def	handle_virtual (self)

def	handle_volatile (self)

def	handle_mutable (self)

def	handle_public (self)

def	handle_protected (self)

def	handle_private (self)

def	handle_friend (self)

def	handle_static_cast (self)

def	handle_const_cast (self)

def	handle_dynamic_cast (self)

def	handle_reinterpret_cast (self)

def	handle_new (self)

def	handle_delete (self)

def	handle_typedef (self)

def	handle_typeid (self)

def	handle_typename (self)

def	handle_template (self)

def	handle_true (self)

def	handle_false (self)

def	handle_asm (self)

def	handle_class (self)

def	handle_namespace (self)

def	handle_using (self)

def	handle_explicit (self)

def	handle_this (self)

def	handle_operator (self)

def	handle_sizeof (self)

def	handle_case (self)

def	handle_switch (self)

def	handle_default (self)

def	handle_if (self)

def	handle_else (self)

def	handle_return (self)

def	handle_goto (self)

def	handle_try (self)

def	handle_catch (self)

def	handle_throw (self)

def	handle_while (self)

def	handle_do (self)

def	handle_for (self)

def	handle_break (self)

def	handle_continue (self)

def	__init__ (self, token_stream, filename, in_class='', visibility=None, namespace_stack=[])

def	HandleError (self, msg, token)

def	Generate (self)

def	GetScope (self)

def	GetName (self, seq=None)

def	GetMethod (self, modifiers, templated_types)

def	handle_bool (self)

def	handle_char (self)

def	handle_int (self)

def	handle_long (self)

def	handle_short (self)

def	handle_double (self)

def	handle_float (self)

def	handle_void (self)

def	handle_wchar_t (self)

def	handle_unsigned (self)

def	handle_signed (self)

def	handle_struct (self)

def	handle_union (self)

def	handle_enum (self)

def	handle_auto (self)

def	handle_register (self)

def	handle_const (self)

def	handle_inline (self)

def	handle_extern (self)

def	handle_static (self)

def	handle_virtual (self)

def	handle_volatile (self)

def	handle_mutable (self)

def	handle_public (self)

def	handle_protected (self)

def	handle_private (self)

def	handle_friend (self)

def	handle_static_cast (self)

def	handle_const_cast (self)

def	handle_dynamic_cast (self)

def	handle_reinterpret_cast (self)

def	handle_new (self)

def	handle_delete (self)

def	handle_typedef (self)

def	handle_typeid (self)

def	handle_typename (self)

def	handle_template (self)

def	handle_true (self)

def	handle_false (self)

def	handle_asm (self)

def	handle_class (self)

def	handle_namespace (self)

def	handle_using (self)

def	handle_explicit (self)

def	handle_this (self)

def	handle_operator (self)

def	handle_sizeof (self)

def	handle_case (self)

def	handle_switch (self)

def	handle_default (self)

def	handle_if (self)

def	handle_else (self)

def	handle_return (self)

def	handle_goto (self)

def	handle_try (self)

def	handle_catch (self)

def	handle_throw (self)

def	handle_while (self)

def	handle_do (self)

def	handle_for (self)

def	handle_break (self)

def	handle_continue (self)

def	__init__ (self, token_stream, filename, in_class='', visibility=None, namespace_stack=[])

def	HandleError (self, msg, token)

def	Generate (self)

def	GetScope (self)

def	GetName (self, seq=None)

def	GetMethod (self, modifiers, templated_types)

def	handle_bool (self)

def	handle_char (self)

def	handle_int (self)

def	handle_long (self)

def	handle_short (self)

def	handle_double (self)

def	handle_float (self)

def	handle_void (self)

def	handle_wchar_t (self)

def	handle_unsigned (self)

def	handle_signed (self)

def	handle_struct (self)

def	handle_union (self)

def	handle_enum (self)

def	handle_auto (self)

def	handle_register (self)

def	handle_const (self)

def	handle_inline (self)

def	handle_extern (self)

def	handle_static (self)

def	handle_virtual (self)

def	handle_volatile (self)

def	handle_mutable (self)

def	handle_public (self)

def	handle_protected (self)

def	handle_private (self)

def	handle_friend (self)

def	handle_static_cast (self)

def	handle_const_cast (self)

def	handle_dynamic_cast (self)

def	handle_reinterpret_cast (self)

def	handle_new (self)

def	handle_delete (self)

def	handle_typedef (self)

def	handle_typeid (self)

def	handle_typename (self)

def	handle_template (self)

def	handle_true (self)

def	handle_false (self)

def	handle_asm (self)

def	handle_class (self)

def	handle_namespace (self)

def	handle_using (self)

def	handle_explicit (self)

def	handle_this (self)

def	handle_operator (self)

def	handle_sizeof (self)

def	handle_case (self)

def	handle_switch (self)

def	handle_default (self)

def	handle_if (self)

def	handle_else (self)

def	handle_return (self)

def	handle_goto (self)

def	handle_try (self)

def	handle_catch (self)

def	handle_throw (self)

def	handle_while (self)

def	handle_do (self)

def	handle_for (self)

def	handle_break (self)

def	handle_continue (self)

Public Attributes
	tokens

	filename

	token_queue

	namespace_stack

	in_class

	in_class_name_only

	visibility

	in_function

	current_token

	converter