104     __contains__ = lambda self: False  argument
105     keys = values = items = iterkeys = itervalues = iteritems = lambda self: ()
112     def __init__(self, start, end):  argument
113         self.start = start
114         self.end = end
116     def IsDeclaration(self):  argument
120     def IsDefinition(self):  argument
124     def IsExportable(self):  argument
128     def Requires(self, node):  argument
132     def XXX__str__(self):  argument
133         return self._StringHelper(self.__class__.__name__, '')
135     def _StringHelper(self, name, suffix):  argument
138         return '%s(%d, %d, %s)' % (name, self.start, self.end, suffix)
140     def __repr__(self):  argument
141         return str(self)
145     def __init__(self, start, end, name, definition):  argument
146         Node.__init__(self, start, end)
147         self.name = name
148         self.definition = definition
150     def __str__(self):  argument
151         value = '%s %s' % (self.name, self.definition)
152         return self._StringHelper(self.__class__.__name__, value)
156     def __init__(self, start, end, filename, system):  argument
157         Node.__init__(self, start, end)
158         self.filename = filename
159         self.system = system
161     def __str__(self):  argument
163         if self.system:
165         return self._StringHelper(self.__class__.__name__, fmt % self.filename)
169     def __init__(self, start, end, label):  argument
170         Node.__init__(self, start, end)
171         self.label = label
173     def __str__(self):  argument
174         return self._StringHelper(self.__class__.__name__, str(self.label))
178     def __init__(self, start, end, expr):  argument
179         Node.__init__(self, start, end)
180         self.expr = expr
182     def Requires(self, node):  argument
186     def __str__(self):  argument
187         return self._StringHelper(self.__class__.__name__, str(self.expr))
199     def __init__(self, start, end, expr, namespace):  argument
200         Expr.__init__(self, start, end, expr)
201         self.namespace = namespace[:]
205     def __init__(self, start, end, names):  argument
206         Node.__init__(self, start, end)
207         self.names = names
209     def __str__(self):  argument
210         return self._StringHelper(self.__class__.__name__, str(self.names))
214     def __init__(self, start, end, name, parameter_type, default):  argument
215         Node.__init__(self, start, end)
216         self.name = name
217         self.type = parameter_type
218         self.default = default
220     def Requires(self, node):  argument
222         return self.type.name == node.name
224     def __str__(self):  argument
225         name = str(self.type)
226         suffix = '%s %s' % (name, self.name)
227         if self.default:
228             suffix += ' = ' + ''.join([d.name for d in self.default])
229         return self._StringHelper(self.__class__.__name__, suffix)
233     def __init__(self, start, end, name, namespace):  argument
234         Node.__init__(self, start, end)
235         self.name = name
236         self.namespace = namespace[:]
238     def FullName(self):  argument
240         if self.namespace and self.namespace[-1]:
241             prefix = '::'.join(self.namespace) + '::'
242         return prefix + self.name
244     def _TypeStringHelper(self, suffix):  argument
245         if self.namespace:
246             names = [n or '<anonymous>' for n in self.namespace]
248         return self._StringHelper(self.__class__.__name__, suffix)
253     def __init__(self, start, end, name, var_type, initial_value, namespace):  argument
254         _GenericDeclaration.__init__(self, start, end, name, namespace)
255         self.type = var_type
256         self.initial_value = initial_value
258     def Requires(self, node):  argument
260         return self.type.name == node.name
262     def ToString(self):  argument
264         suffix = '%s %s' % (self.type, self.name)
265         if self.initial_value:
266             suffix += ' = ' + self.initial_value
269     def __str__(self):  argument
270         return self._StringHelper(self.__class__.__name__, self.ToString())
274     def __init__(self, start, end, name, alias, namespace):  argument
275         _GenericDeclaration.__init__(self, start, end, name, namespace)
276         self.alias = alias
278     def IsDefinition(self):  argument
281     def IsExportable(self):  argument
284     def Requires(self, node):  argument
287         for token in self.alias:
292     def __str__(self):  argument
293         suffix = '%s, %s' % (self.name, self.alias)
294         return self._TypeStringHelper(suffix)
298     def __init__(self, start, end, name, fields, namespace):  argument
299         _GenericDeclaration.__init__(self, start, end, name, namespace)
300         self.fields = fields
302     def IsDefinition(self):  argument
305     def IsExportable(self):  argument
308     def __str__(self):  argument
309         suffix = '%s, {%s}' % (self.name, self.fields)
310         return self._TypeStringHelper(suffix)
322     def __init__(self, start, end, name, bases, templated_types, body, namespace):  argument
323         _GenericDeclaration.__init__(self, start, end, name, namespace)
324         self.bases = bases
325         self.body = body
326         self.templated_types = templated_types
328     def IsDeclaration(self):  argument
329         return self.bases is None and self.body is None
331     def IsDefinition(self):  argument
332         return not self.IsDeclaration()
334     def IsExportable(self):  argument
335         return not self.IsDeclaration()
337     def Requires(self, node):  argument
339         if self.bases:
340             for token_list in self.bases:
348     def __str__(self):  argument
349         name = self.name
350         if self.templated_types:
351             name += '<%s>' % self.templated_types
352         suffix = '%s, %s, %s' % (name, self.bases, self.body)
353         return self._TypeStringHelper(suffix)
361     def __init__(self, start, end, name, return_type, parameters,  argument
363         _GenericDeclaration.__init__(self, start, end, name, namespace)
365         self.return_type = converter.CreateReturnType(return_type)
366         self.parameters = converter.ToParameters(parameters)
367         self.modifiers = modifiers
368         self.body = body
369         self.templated_types = templated_types
371     def IsDeclaration(self):  argument
372         return self.body is None
374     def IsDefinition(self):  argument
375         return self.body is not None
377     def IsExportable(self):  argument
378         if self.return_type and 'static' in self.return_type.modifiers:
380         return None not in self.namespace
382     def Requires(self, node):  argument
383         if self.parameters:
385             for p in self.parameters:
391     def __str__(self):  argument
394                   (self.return_type, self.name, self.parameters,
395                    self.modifiers, self.body))
396         return self._TypeStringHelper(suffix)
400     def __init__(self, start, end, name, in_class, return_type, parameters,  argument
402         Function.__init__(self, start, end, name, return_type, parameters,
406         self.in_class = in_class
412     def __init__(self, start, end, name, templated_types, modifiers,  argument
421         _GenericDeclaration.__init__(self, start, end, name, [])
422         self.templated_types = templated_types
424             self.name = modifiers.pop()
425         self.modifiers = modifiers
426         self.reference = reference
427         self.pointer = pointer
428         self.array = array
430     def __str__(self):  argument
432         if self.modifiers:
433             prefix = ' '.join(self.modifiers) + ' '
434         name = str(self.name)
435         if self.templated_types:
436             name += '<%s>' % self.templated_types
438         if self.reference:
440         if self.pointer:
442         if self.array:
444         return self._TypeStringHelper(suffix)
448     def IsDeclaration(self):  argument
451     def IsDefinition(self):  argument
454     def IsExportable(self):  argument
460     def __init__(self, namespace_stack):  argument
461         self.namespace_stack = namespace_stack
463     def _GetTemplateEnd(self, tokens, start):  argument
477     def ToType(self, tokens):  argument
510                 new_tokens, new_end = self._GetTemplateEnd(tokens, i+1)
511                 AddType(self.ToType(new_tokens))
536     def DeclarationToParts(self, parts, needs_name_removed):  argument
569                 templated_tokens, new_end = self._GetTemplateEnd(parts, i+1)
570                 templated_types = self.ToType(templated_tokens)
591     def ToParameters(self, tokens):  argument
605             parts = self.DeclarationToParts(type_modifiers, True)
652     def CreateReturnType(self, return_type_seq):  argument
658            self.DeclarationToParts(return_type_seq, False)
666     def GetTemplateIndices(self, names):  argument
677     def __init__(self, token_stream, filename, in_class='', visibility=None,  argument
679         self.tokens = token_stream
680         self.filename = filename
684         self.token_queue = []
685         self.namespace_stack = namespace_stack[:]
686         self.in_class = in_class
688             self.in_class_name_only = None
690             self.in_class_name_only = in_class.split('::')[-1]
691         self.visibility = visibility
692         self.in_function = False
693         self.current_token = None
695         self._handling_typedef = False
697         self.converter = TypeConverter(self.namespace_stack)
699     def HandleError(self, msg, token):  argument
700         printable_queue = list(reversed(self.token_queue[-20:]))
702                          (msg, self.filename, token, printable_queue))
704     def Generate(self):  argument
706             token = self._GetNextToken()
711             self.current_token = token
716                     self.namespace_stack.pop()
720                 result = self._GenerateOne(token)
724                 self.HandleError('exception', token)
727     def _CreateVariable(self, pos_token, name, type_name, type_modifiers,  argument
736                                    name, var_type, value, self.namespace_stack)
738     def _GenerateOne(self, token):  argument
742                 method = getattr(self, 'handle_' + token.name)
744             elif token.name == self.in_class_name_only:
748                 next = self._GetNextToken()
749                 self._AddBackToken(next)
751                     return self._GetMethod([token], FUNCTION_CTOR, None, True)
757                 self._GetVarTokensUpTo(syntax, '(', ';', '{', '[')
764                     new_temp = self._GetTokensUpTo(tokenize.SYNTAX, ';')
775                     temp_tokens.append(self._GetNextToken())
778                         self._GetVarTokensUpTo(tokenize.SYNTAX, ';')
783                 parts = self.converter.DeclarationToParts(temp_tokens, True)
790                     start, end = self.converter.GetTemplateIndices(names)
793                 return self._CreateVariable(t0, name, type_name, modifiers,
796                 self._AddBackTokens(temp_tokens[1:])
797                 self._AddBackToken(last_token)
799                 method = getattr(self, 'handle_' + method_name, None)
805             return self._GetMethod(temp_tokens, 0, None, False)
807             if token.name == '~' and self.in_class:
809                 token = self._GetNextToken()
813                     token.name == self.in_class_name_only):
814                     return self._GetMethod([token], FUNCTION_DTOR, None, True)
846                     self._SkipIf0Blocks()
849     def _GetTokensUpTo(self, expected_token_type, expected_token):  argument
850         return self._GetVarTokensUpTo(expected_token_type, expected_token)[0]
852     def _GetVarTokensUpTo(self, expected_token_type, *expected_tokens):  argument
853         last_token = self._GetNextToken()
858             last_token = self._GetNextToken()
862     def _IgnoreUpTo(self, token_type, token):  argument
863         unused_tokens = self._GetTokensUpTo(token_type, token)
865     def _SkipIf0Blocks(self):  argument
868             token = self._GetNextToken()
880     def _GetMatchingChar(self, open_paren, close_paren, GetNextToken=None):  argument
882             GetNextToken = self._GetNextToken
899     def _GetParameters(self):  argument
900         return self._GetMatchingChar('(', ')')
902     def GetScope(self):  argument
903         return self._GetMatchingChar('{', '}')
905     def _GetNextToken(self):  argument
906         if self.token_queue:
907             return self.token_queue.pop()
908         return next(self.tokens)
910     def _AddBackToken(self, token):  argument
913             self.token_queue.insert(0, token)
916             self.token_queue.append(token)
918     def _AddBackTokens(self, tokens):  argument
923                 self.token_queue[:0] = reversed(tokens)
926                 self.token_queue.extend(reversed(tokens))
928     def GetName(self, seq=None):  argument
930         GetNextToken = self._GetNextToken
948                 tokens.extend(self._GetMatchingChar('<', '>', GetNextToken))
953     def GetMethod(self, modifiers, templated_types):  argument
954         return_type_and_name = self._GetTokensUpTo(tokenize.SYNTAX, '(')
956         return self._GetMethod(return_type_and_name, modifiers, templated_types,
959     def _GetMethod(self, return_type_and_name, modifiers, templated_types,  argument
963             token = self._GetNextToken()
968                 template_portion.extend(self._GetMatchingChar('<', '>'))
969                 token = self._GetNextToken()
991             unused_open_paren = self._GetNextToken()
1000         if name.name == self.in_class and not modifiers:
1002         parameters = list(self._GetParameters())
1007             token = self._GetNextToken()
1009             parameters = list(self._GetParameters())
1012         token = self._GetNextToken()
1015             token = self._GetNextToken()
1023                 unused_tokens = list(self._GetMatchingChar('(', ')'))
1024                 token = self._GetNextToken()
1029                 unused_tokens = list(self._GetMatchingChar('(', ')'))
1030                 token = self._GetNextToken()
1038                 self.HandleError('unexpected token', modifier_token)
1045                 token = self._GetNextToken()
1056                 function_parameters = list(self._GetMatchingChar('(', ')'))
1059                 token = self._GetNextToken()
1062                 return self._CreateVariable(indices, name.name, indices.name,
1073             modifiers = [p.name for p in self._GetParameters()]
1075             return self._CreateVariable(indices, real_name.name, indices.name,
1079             body = list(self.GetScope())
1084                 token = self._GetNextToken()
1089                     token = self._GetNextToken()
1095                     token = self._GetNextToken()
1100                 tokens = list(self._GetMatchingChar('[', ']'))
1101                 token = self._GetNextToken()
1108                          self._GetReturnTypeAndClassName(return_type)
1111                           body, self.namespace_stack)
1114                         self.namespace_stack)
1116     def _GetReturnTypeAndClassName(self, token_seq):  argument
1142             new_name, next = self.GetName(seq_copy[i:])
1160     def handle_bool(self):  argument
1163     def handle_char(self):  argument
1166     def handle_int(self):  argument
1169     def handle_long(self):  argument
1172     def handle_short(self):  argument
1175     def handle_double(self):  argument
1178     def handle_float(self):  argument
1181     def handle_void(self):  argument
1184     def handle_wchar_t(self):  argument
1187     def handle_unsigned(self):  argument
1190     def handle_signed(self):  argument
1193     def _GetNestedType(self, ctor):  argument
1195         name_tokens, token = self.GetName()
1202                         self.namespace_stack)
1204         if token.token_type == tokenize.NAME and self._handling_typedef:
1205             self._AddBackToken(token)
1207                         self.namespace_stack)
1210         fields = list(self._GetMatchingChar('{', '}'))
1213             next = self._GetNextToken()
1215                             self.namespace_stack)
1225         return self._CreateVariable(token, token.name, name, [], '', None)
1227     def handle_struct(self):  argument
1230         name_tokens, var_token = self.GetName()
1232             next_token = self._GetNextToken()
1240                 temp = self._GetNextToken()
1249                     return self._GetMethod(type_and_name, 0, None, False)
1251             if is_syntax or (is_variable and not self._handling_typedef):
1255                 return self._CreateVariable(position, variable.name, type_name,
1258             self._AddBackTokens(name_tokens)
1260             self._AddBackToken(var_token)
1261         return self._GetClass(Struct, VISIBILITY_PUBLIC, None)
1263     def handle_union(self):  argument
1264         return self._GetNestedType(Union)
1266     def handle_enum(self):  argument
1267         token = self._GetNextToken()
1269             self._AddBackToken(token)
1270         return self._GetNestedType(Enum)
1272     def handle_auto(self):  argument
1277     def handle_register(self):  argument
1280     def handle_const(self):  argument
1283     def handle_inline(self):  argument
1286     def handle_extern(self):  argument
1289     def handle_static(self):  argument
1292     def handle_virtual(self):  argument
1294         token = token2 = self._GetNextToken()
1297             token2 = self._GetNextToken()
1299             return self.GetMethod(FUNCTION_VIRTUAL + FUNCTION_DTOR, None)
1301         return_type_and_name = self._GetTokensUpTo(tokenize.SYNTAX, '(')  # )
1305         return self._GetMethod(return_type_and_name, FUNCTION_VIRTUAL,
1308     def handle_volatile(self):  argument
1311     def handle_mutable(self):  argument
1314     def handle_public(self):  argument
1315         assert self.in_class
1316         self.visibility = VISIBILITY_PUBLIC
1318     def handle_protected(self):  argument
1319         assert self.in_class
1320         self.visibility = VISIBILITY_PROTECTED
1322     def handle_private(self):  argument
1323         assert self.in_class
1324         self.visibility = VISIBILITY_PRIVATE
1326     def handle_friend(self):  argument
1327         tokens = self._GetTokensUpTo(tokenize.SYNTAX, ';')
1330         return Friend(t0.start, t0.end, tokens, self.namespace_stack)
1332     def handle_static_cast(self):  argument
1335     def handle_const_cast(self):  argument
1338     def handle_dynamic_cast(self):  argument
1341     def handle_reinterpret_cast(self):  argument
1344     def handle_new(self):  argument
1347     def handle_delete(self):  argument
1348         tokens = self._GetTokensUpTo(tokenize.SYNTAX, ';')
1352     def handle_typedef(self):  argument
1353         token = self._GetNextToken()
1357             method = getattr(self, 'handle_' + token.name)
1358             self._handling_typedef = True
1360             self._handling_typedef = False
1365         tokens.extend(self._GetTokensUpTo(tokenize.SYNTAX, ';'))
1388             new_type = self.converter.ToType(tokens)[0]
1390                        new_type, self.namespace_stack)
1392     def handle_typeid(self):  argument
1395     def handle_typename(self):  argument
1398     def _GetTemplatedTypes(self):  argument
1400         tokens = list(self._GetMatchingChar('<', '>'))
1413                     default, unused_next_token = self.GetName(tokens[i:])
1425     def handle_template(self):  argument
1426         token = self._GetNextToken()
1429         templated_types = self._GetTemplatedTypes()
1431         token = self._GetNextToken()
1434                 return self._GetClass(Class, VISIBILITY_PRIVATE, templated_types)
1436                 return self._GetClass(Struct, VISIBILITY_PUBLIC, templated_types)
1438                 return self.handle_friend()
1439         self._AddBackToken(token)
1440         tokens, last = self._GetVarTokensUpTo(tokenize.SYNTAX, '(', ';')
1442         self._AddBackTokens(tokens)
1444             return self.GetMethod(FUNCTION_NONE, templated_types)
1448     def handle_true(self):  argument
1451     def handle_false(self):  argument
1454     def handle_asm(self):  argument
1457     def handle_class(self):  argument
1458         return self._GetClass(Class, VISIBILITY_PRIVATE, None)
1460     def _GetBases(self):  argument
1464             token = self._GetNextToken()
1471                 self._AddBackToken(token)
1474                 token = self._GetNextToken()
1476                     self._AddBackToken(token)
1480             base, next_token = self.GetName()
1481             bases_ast = self.converter.ToType(base)
1492     def _GetClass(self, class_type, visibility, templated_types):  argument
1494         class_token = self._GetNextToken()
1501             next_token = self._GetNextToken()
1503                 self._AddBackToken(next_token)
1505                 self._AddBackTokens([class_token, next_token])
1506             name_tokens, token = self.GetName()
1514                                   self.namespace_stack)
1517                 name_token = self._GetNextToken()
1518                 next_token = self._GetNextToken()
1522                     return self._CreateVariable(class_token, name_token.name,
1528                     self._AddBackTokens(tokens)
1529                     return self.GetMethod(FUNCTION_NONE, None)
1531                 bases, token = self._GetBases()
1538             ast = AstBuilder(self.GetScope(), self.filename, class_name,
1539                              visibility, self.namespace_stack)
1542             if not self._handling_typedef:
1543                 token = self._GetNextToken()
1550                                            body, self.namespace_stack)
1553                     return self._CreateVariable(class_token,
1557             if not self._handling_typedef:
1558                 self.HandleError('non-typedef token', token)
1559             self._AddBackToken(token)
1562                           bases, templated_types, body, self.namespace_stack)
1564     def handle_namespace(self):  argument
1565         token = self._GetNextToken()
1570             token = self._GetNextToken()
1571         self.namespace_stack.append(name)
1579             name, next_token = self.GetName()
1581             self._AddBackToken(internal_token)
1584             tokens = list(self.GetScope())
1588             self._AddBackTokens(tokens)
1591     def handle_using(self):  argument
1592         tokens = self._GetTokensUpTo(tokenize.SYNTAX, ';')
1596     def handle_explicit(self):  argument
1597         assert self.in_class
1601         return self.GetMethod(FUNCTION_CTOR, None)
1603     def handle_this(self):  argument
1606     def handle_operator(self):  argument
1610     def handle_sizeof(self):  argument
1613     def handle_case(self):  argument
1616     def handle_switch(self):  argument
1619     def handle_default(self):  argument
1620         token = self._GetNextToken()
1624     def handle_if(self):  argument
1627     def handle_else(self):  argument
1630     def handle_return(self):  argument
1631         tokens = self._GetTokensUpTo(tokenize.SYNTAX, ';')
1633             return Return(self.current_token.start, self.current_token.end, None)
1636     def handle_goto(self):  argument
1637         tokens = self._GetTokensUpTo(tokenize.SYNTAX, ';')
1641     def handle_try(self):  argument
1644     def handle_catch(self):  argument
1647     def handle_throw(self):  argument
1650     def handle_while(self):  argument
1653     def handle_do(self):  argument
1656     def handle_for(self):  argument
1659     def handle_break(self):  argument
1660         self._IgnoreUpTo(tokenize.SYNTAX, ';')
1662     def handle_continue(self):  argument
1663         self._IgnoreUpTo(tokenize.SYNTAX, ';')