Lines Matching refs:self
104 __contains__ = lambda self: False
105 keys = values = items = iterkeys = itervalues = iteritems = lambda self: ()
112 def __init__(self, start, end):
113 self.start = start
114 self.end = end
116 def IsDeclaration(self):
120 def IsDefinition(self):
124 def IsExportable(self):
128 def Requires(self, node):
132 def XXX__str__(self):
133 return self._StringHelper(self.__class__.__name__, '')
135 def _StringHelper(self, name, suffix):
138 return '%s(%d, %d, %s)' % (name, self.start, self.end, suffix)
140 def __repr__(self):
141 return str(self)
145 def __init__(self, start, end, name, definition):
146 Node.__init__(self, start, end)
147 self.name = name
148 self.definition = definition
150 def __str__(self):
151 value = '%s %s' % (self.name, self.definition)
152 return self._StringHelper(self.__class__.__name__, value)
156 def __init__(self, start, end, filename, system):
157 Node.__init__(self, start, end)
158 self.filename = filename
159 self.system = system
161 def __str__(self):
163 if self.system:
165 return self._StringHelper(self.__class__.__name__, fmt % self.filename)
169 def __init__(self, start, end, label):
170 Node.__init__(self, start, end)
171 self.label = label
173 def __str__(self):
174 return self._StringHelper(self.__class__.__name__, str(self.label))
178 def __init__(self, start, end, expr):
179 Node.__init__(self, start, end)
180 self.expr = expr
182 def Requires(self, node):
186 def __str__(self):
187 return self._StringHelper(self.__class__.__name__, str(self.expr))
199 def __init__(self, start, end, expr, namespace):
200 Expr.__init__(self, start, end, expr)
201 self.namespace = namespace[:]
205 def __init__(self, start, end, names):
206 Node.__init__(self, start, end)
207 self.names = names
209 def __str__(self):
210 return self._StringHelper(self.__class__.__name__, str(self.names))
214 def __init__(self, start, end, name, parameter_type, default):
215 Node.__init__(self, start, end)
216 self.name = name
217 self.type = parameter_type
218 self.default = default
220 def Requires(self, node):
222 return self.type.name == node.name
224 def __str__(self):
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):
234 Node.__init__(self, start, end)
235 self.name = name
236 self.namespace = namespace[:]
238 def FullName(self):
240 if self.namespace and self.namespace[-1]:
241 prefix = '::'.join(self.namespace) + '::'
242 return prefix + self.name
244 def _TypeStringHelper(self, suffix):
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):
254 _GenericDeclaration.__init__(self, start, end, name, namespace)
255 self.type = var_type
256 self.initial_value = initial_value
258 def Requires(self, node):
260 return self.type.name == node.name
262 def ToString(self):
264 suffix = '%s %s' % (self.type, self.name)
265 if self.initial_value:
266 suffix += ' = ' + self.initial_value
269 def __str__(self):
270 return self._StringHelper(self.__class__.__name__, self.ToString())
274 def __init__(self, start, end, name, alias, namespace):
275 _GenericDeclaration.__init__(self, start, end, name, namespace)
276 self.alias = alias
278 def IsDefinition(self):
281 def IsExportable(self):
284 def Requires(self, node):
287 for token in self.alias:
292 def __str__(self):
293 suffix = '%s, %s' % (self.name, self.alias)
294 return self._TypeStringHelper(suffix)
298 def __init__(self, start, end, name, fields, namespace):
299 _GenericDeclaration.__init__(self, start, end, name, namespace)
300 self.fields = fields
302 def IsDefinition(self):
305 def IsExportable(self):
308 def __str__(self):
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):
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):
329 return self.bases is None and self.body is None
331 def IsDefinition(self):
332 return not self.IsDeclaration()
334 def IsExportable(self):
335 return not self.IsDeclaration()
337 def Requires(self, node):
339 if self.bases:
340 for token_list in self.bases:
348 def __str__(self):
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,
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):
372 return self.body is None
374 def IsDefinition(self):
375 return self.body is not None
377 def IsExportable(self):
378 if self.return_type and 'static' in self.return_type.modifiers:
380 return None not in self.namespace
382 def Requires(self, node):
383 if self.parameters:
385 for p in self.parameters:
391 def __str__(self):
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,
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,
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):
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):
451 def IsDefinition(self):
454 def IsExportable(self):
460 def __init__(self, namespace_stack):
461 self.namespace_stack = namespace_stack
463 def _GetTemplateEnd(self, tokens, start):
477 def ToType(self, tokens):
510 new_tokens, new_end = self._GetTemplateEnd(tokens, i+1)
511 AddType(self.ToType(new_tokens))
536 def DeclarationToParts(self, parts, needs_name_removed):
569 templated_tokens, new_end = self._GetTemplateEnd(parts, i+1)
570 templated_types = self.ToType(templated_tokens)
591 def ToParameters(self, tokens):
605 parts = self.DeclarationToParts(type_modifiers, True)
652 def CreateReturnType(self, return_type_seq):
658 self.DeclarationToParts(return_type_seq, False)
666 def GetTemplateIndices(self, names):
677 def __init__(self, token_stream, filename, in_class='', visibility=None,
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):
700 printable_queue = list(reversed(self.token_queue[-20:]))
702 (msg, self.filename, token, printable_queue))
704 def Generate(self):
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,
736 name, var_type, value, self.namespace_stack)
738 def _GenerateOne(self, token):
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, ';')
772 # unused_size = 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()
810 # self.in_class can contain A::Name, but the dtor will only
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):
850 return self._GetVarTokensUpTo(expected_token_type, expected_token)[0]
852 def _GetVarTokensUpTo(self, expected_token_type, *expected_tokens):
853 last_token = self._GetNextToken()
858 last_token = self._GetNextToken()
862 def _IgnoreUpTo(self, token_type, token):
863 unused_tokens = self._GetTokensUpTo(token_type, token)
865 def _SkipIf0Blocks(self):
868 token = self._GetNextToken()
880 def _GetMatchingChar(self, open_paren, close_paren, GetNextToken=None):
882 GetNextToken = self._GetNextToken
899 def _GetParameters(self):
900 return self._GetMatchingChar('(', ')')
902 def GetScope(self):
903 return self._GetMatchingChar('{', '}')
905 def _GetNextToken(self):
906 if self.token_queue:
907 return self.token_queue.pop()
908 return next(self.tokens)
910 def _AddBackToken(self, token):
913 self.token_queue.insert(0, token)
916 self.token_queue.append(token)
918 def _AddBackTokens(self, tokens):
923 self.token_queue[:0] = reversed(tokens)
926 self.token_queue.extend(reversed(tokens))
928 def GetName(self, seq=None):
930 GetNextToken = self._GetNextToken
948 tokens.extend(self._GetMatchingChar('<', '>', GetNextToken))
953 def GetMethod(self, modifiers, templated_types):
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,
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):
1142 new_name, next = self.GetName(seq_copy[i:])
1160 def handle_bool(self):
1163 def handle_char(self):
1166 def handle_int(self):
1169 def handle_long(self):
1172 def handle_short(self):
1175 def handle_double(self):
1178 def handle_float(self):
1181 def handle_void(self):
1184 def handle_wchar_t(self):
1187 def handle_unsigned(self):
1190 def handle_signed(self):
1193 def _GetNestedType(self, ctor):
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):
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):
1264 return self._GetNestedType(Union)
1266 def handle_enum(self):
1267 return self._GetNestedType(Enum)
1269 def handle_auto(self):
1274 def handle_register(self):
1277 def handle_const(self):
1280 def handle_inline(self):
1283 def handle_extern(self):
1286 def handle_static(self):
1289 def handle_virtual(self):
1291 token = token2 = self._GetNextToken()
1294 token2 = self._GetNextToken()
1296 return self.GetMethod(FUNCTION_VIRTUAL + FUNCTION_DTOR, None)
1298 return_type_and_name = self._GetTokensUpTo(tokenize.SYNTAX, '(') # )
1302 return self._GetMethod(return_type_and_name, FUNCTION_VIRTUAL,
1305 def handle_volatile(self):
1308 def handle_mutable(self):
1311 def handle_public(self):
1312 assert self.in_class
1313 self.visibility = VISIBILITY_PUBLIC
1315 def handle_protected(self):
1316 assert self.in_class
1317 self.visibility = VISIBILITY_PROTECTED
1319 def handle_private(self):
1320 assert self.in_class
1321 self.visibility = VISIBILITY_PRIVATE
1323 def handle_friend(self):
1324 tokens = self._GetTokensUpTo(tokenize.SYNTAX, ';')
1327 return Friend(t0.start, t0.end, tokens, self.namespace_stack)
1329 def handle_static_cast(self):
1332 def handle_const_cast(self):
1335 def handle_dynamic_cast(self):
1338 def handle_reinterpret_cast(self):
1341 def handle_new(self):
1344 def handle_delete(self):
1345 tokens = self._GetTokensUpTo(tokenize.SYNTAX, ';')
1349 def handle_typedef(self):
1350 token = self._GetNextToken()
1354 method = getattr(self, 'handle_' + token.name)
1355 self._handling_typedef = True
1357 self._handling_typedef = False
1362 tokens.extend(self._GetTokensUpTo(tokenize.SYNTAX, ';'))
1385 new_type = self.converter.ToType(tokens)[0]
1387 new_type, self.namespace_stack)
1389 def handle_typeid(self):
1392 def handle_typename(self):
1395 def _GetTemplatedTypes(self):
1397 tokens = list(self._GetMatchingChar('<', '>'))
1410 default, unused_next_token = self.GetName(tokens[i:])
1422 def handle_template(self):
1423 token = self._GetNextToken()
1426 templated_types = self._GetTemplatedTypes()
1428 token = self._GetNextToken()
1431 return self._GetClass(Class, VISIBILITY_PRIVATE, templated_types)
1433 return self._GetClass(Struct, VISIBILITY_PUBLIC, templated_types)
1435 return self.handle_friend()
1436 self._AddBackToken(token)
1437 tokens, last = self._GetVarTokensUpTo(tokenize.SYNTAX, '(', ';')
1439 self._AddBackTokens(tokens)
1441 return self.GetMethod(FUNCTION_NONE, templated_types)
1445 def handle_true(self):
1448 def handle_false(self):
1451 def handle_asm(self):
1454 def handle_class(self):
1455 return self._GetClass(Class, VISIBILITY_PRIVATE, None)
1457 def _GetBases(self):
1461 token = self._GetNextToken()
1468 self._AddBackToken(token)
1471 token = self._GetNextToken()
1473 self._AddBackToken(token)
1477 base, next_token = self.GetName()
1478 bases_ast = self.converter.ToType(base)
1489 def _GetClass(self, class_type, visibility, templated_types):
1491 class_token = self._GetNextToken()
1498 next_token = self._GetNextToken()
1500 self._AddBackToken(next_token)
1502 self._AddBackTokens([class_token, next_token])
1503 name_tokens, token = self.GetName()
1511 self.namespace_stack)
1514 name_token = self._GetNextToken()
1515 next_token = self._GetNextToken()
1519 return self._CreateVariable(class_token, name_token.name,
1525 self._AddBackTokens(tokens)
1526 return self.GetMethod(FUNCTION_NONE, None)
1528 bases, token = self._GetBases()
1535 ast = AstBuilder(self.GetScope(), self.filename, class_name,
1536 visibility, self.namespace_stack)
1539 if not self._handling_typedef:
1540 token = self._GetNextToken()
1547 body, self.namespace_stack)
1550 return self._CreateVariable(class_token,
1554 if not self._handling_typedef:
1555 self.HandleError('non-typedef token', token)
1556 self._AddBackToken(token)
1559 bases, templated_types, body, self.namespace_stack)
1561 def handle_namespace(self):
1562 token = self._GetNextToken()
1567 token = self._GetNextToken()
1568 self.namespace_stack.append(name)
1576 name, next_token = self.GetName()
1578 self._AddBackToken(internal_token)
1581 tokens = list(self.GetScope())
1585 self._AddBackTokens(tokens)
1588 def handle_using(self):
1589 tokens = self._GetTokensUpTo(tokenize.SYNTAX, ';')
1593 def handle_explicit(self):
1594 assert self.in_class
1598 return self.GetMethod(FUNCTION_CTOR, None)
1600 def handle_this(self):
1603 def handle_operator(self):
1607 def handle_sizeof(self):
1610 def handle_case(self):
1613 def handle_switch(self):
1616 def handle_default(self):
1617 token = self._GetNextToken()
1621 def handle_if(self):
1624 def handle_else(self):
1627 def handle_return(self):
1628 tokens = self._GetTokensUpTo(tokenize.SYNTAX, ';')
1630 return Return(self.current_token.start, self.current_token.end, None)
1633 def handle_goto(self):
1634 tokens = self._GetTokensUpTo(tokenize.SYNTAX, ';')
1638 def handle_try(self):
1641 def handle_catch(self):
1644 def handle_throw(self):
1647 def handle_while(self):
1650 def handle_do(self):
1653 def handle_for(self):
1656 def handle_break(self):
1657 self._IgnoreUpTo(tokenize.SYNTAX, ';')
1659 def handle_continue(self):
1660 self._IgnoreUpTo(tokenize.SYNTAX, ';')