Lines Matching refs:name
135 def _StringHelper(self, name, suffix):
137 return '%s(%s)' % (name, suffix)
138 return '%s(%d, %d, %s)' % (name, self.start, self.end, suffix)
145 def __init__(self, start, end, name, definition):
147 self.name = name
151 value = '%s %s' % (self.name, self.definition)
214 def __init__(self, start, end, name, parameter_type, default):
216 self.name = name
222 return self.type.name == node.name
225 name = str(self.type)
226 suffix = '%s %s' % (name, self.name)
228 suffix += ' = ' + ''.join([d.name for d in self.default])
233 def __init__(self, start, end, name, namespace):
235 self.name = name
242 return prefix + self.name
253 def __init__(self, start, end, name, var_type, initial_value, namespace):
254 _GenericDeclaration.__init__(self, start, end, name, namespace)
260 return self.type.name == node.name
264 suffix = '%s %s' % (self.type, self.name)
274 def __init__(self, start, end, name, alias, namespace):
275 _GenericDeclaration.__init__(self, start, end, name, namespace)
286 name = node.name
288 if token is not None and name == token.name:
293 suffix = '%s, %s' % (self.name, self.alias)
298 def __init__(self, start, end, name, fields, namespace):
299 _GenericDeclaration.__init__(self, start, end, name, namespace)
309 suffix = '%s, {%s}' % (self.name, self.fields)
322 def __init__(self, start, end, name, bases, templated_types, body, namespace):
323 _GenericDeclaration.__init__(self, start, end, name, namespace)
341 # TODO(nnorwitz): bases are tokens, do name comparision.
343 if token.name == node.name:
349 name = self.name
351 name += '<%s>' % self.templated_types
352 suffix = '%s, %s, %s' % (name, self.bases, self.body)
361 def __init__(self, start, end, name, return_type, parameters,
363 _GenericDeclaration.__init__(self, start, end, name, namespace)
384 # TODO(nnorwitz): parameters are tokens, do name comparision.
386 if p.name == node.name:
394 (self.return_type, self.name, self.parameters,
400 def __init__(self, start, end, name, in_class, return_type, parameters,
402 Function.__init__(self, start, end, name, return_type, parameters,
412 def __init__(self, start, end, name, templated_types, modifiers,
416 name: str name of main type
421 _GenericDeclaration.__init__(self, start, end, name, [])
423 if not name and modifiers:
424 self.name = modifiers.pop()
434 name = str(self.name)
436 name += '<%s>' % self.templated_types
437 suffix = prefix + name
469 if token.name == '<':
471 elif token.name == '>':
490 # Partition tokens into name and modifier tokens.
494 if keywords.IsKeyword(t.name):
495 modifiers.append(t.name)
497 names.append(t.name)
498 name = ''.join(names)
501 name, templated_types, modifiers,
509 if token.name == '<':
513 # that here otherwise it becomes part of the name.
516 elif token.name == ',':
519 elif token.name == '*':
521 elif token.name == '&':
523 elif token.name == '[':
525 elif token.name == ']':
532 # No '<' in the tokens, just a simple name and no template.
537 name = None
542 if t.name == '=':
544 name = parts[i-1].name
545 if name == ']' and parts[i-2].name == '[':
546 name = parts[i-3].name
552 name = parts.pop().name
557 name = '???'
566 if keywords.IsKeyword(p.name):
567 modifiers.append(p.name)
568 elif p.name == '<':
574 if next_index < end and parts[next_index].name == '::':
576 elif p.name in ('[', ']', '='):
579 elif p.name not in ('*', '&', '>'):
588 type_name = ''.join([t.name for t in type_name])
589 return name, type_name, templated_types, modifiers, default, other_tokens
596 name = type_name = ''
606 (name, type_name, templated_types, modifiers,
611 p = Parameter(first_token.start, end, name,
619 if s.name == '<':
621 elif s.name == '>':
627 if s.name == ',':
629 name = type_name = ''
634 elif s.name == '*':
636 elif s.name == '&':
638 elif s.name == '[':
640 elif s.name == ']':
642 elif s.name == '=':
657 _, name, templated_types, modifiers, default, other_tokens = \
659 names = [n.name for n in other_tokens]
663 return Type(start, end, name, templated_types, modifiers,
715 if token.name == _NAMESPACE_POP:
727 def _CreateVariable(self, pos_token, name, type_name, type_modifiers,
736 name, var_type, value, self.namespace_stack)
740 if (keywords.IsKeyword(token.name) and
741 not keywords.IsBuiltinType(token.name)):
742 method = getattr(self, 'handle_' + token.name)
744 elif token.name == self.in_class_name_only:
745 # The token name is the same as the class, must be a ctor if
750 if next.token_type == tokenize.SYNTAX and next.name == '(':
759 if last_token.name == '(':
762 expr = bool([e for e in temp_tokens if e.name == '='])
769 if last_token.name == '[':
774 if temp_tokens[-2].name == 'operator':
781 if last_token.name == ';':
784 (name, type_name, templated_types, modifiers, default,
788 names = [t.name for t in temp_tokens]
792 default = ''.join([t.name for t in default])
793 return self._CreateVariable(t0, name, type_name, modifiers,
795 if last_token.name == '{':
798 method_name = temp_tokens[0].name
807 if token.name == '~' and self.in_class:
813 token.name == self.in_class_name_only):
819 name = token.name[1:].lstrip()
820 if name.startswith('include'):
822 name = name[7:].strip()
823 assert name
825 if name.startswith('\\'):
826 name = name[1:].strip()
827 assert name[0] in '<"', token
828 assert name[-1] in '>"', token
829 system = name[0] == '<'
830 filename = name[1:-1]
832 if name.startswith('define'):
834 name = name[6:].strip()
835 assert name
837 for i, c in enumerate(name):
839 value = name[i:].lstrip()
840 name = name[:i]
842 return Define(token.start, token.end, name, value)
843 if name.startswith('if') and name[2:3].isspace():
844 condition = name[3:].strip()
856 last_token.name not in expected_tokens):
872 name = token.name[1:].lstrip()
873 if name.startswith('endif'):
877 elif name.startswith('if'):
889 if token.name == open_paren:
891 elif token.name == close_paren:
939 next_token.name in ('::', '<'))):
947 if next_token.name == '<':
965 if token.name == '<':
971 assert token.name == '(', token
973 name = return_type_and_name.pop()
975 if name.name == '>':
977 while return_type_and_name[index].name != '<':
979 template_portion = return_type_and_name[index:] + [name]
981 name = return_type_and_name.pop()
982 elif name.name == ']':
984 assert rt[-1].name == '[', return_type_and_name
985 assert rt[-2].name == 'operator', return_type_and_name
988 name = tokenize.Token(tokenize.NAME, 'operator[]',
989 name_seq[0].start, name.end)
995 indices = name
1000 if name.name == self.in_class and not modifiers:
1006 if name.name == 'operator' and not parameters:
1008 assert token.name == '(', token
1016 if modifier_token.name == 'const':
1018 elif modifier_token.name == '__attribute__':
1021 assert token.name == '(', token
1025 elif modifier_token.name == 'throw':
1027 assert token.name == '(', token
1031 elif modifier_token.name == 'override':
1033 elif modifier_token.name == modifier_token.name.upper():
1042 if token.name == ':':
1044 while token.name != ';' and token.name != '{':
1049 if token.name == '(':
1050 if parameters[0].name == '*':
1051 # name contains the return type.
1052 name = parameters.pop()
1053 # parameters contains the name of the data.
1054 modifiers = [p.name for p in parameters]
1061 assert token.name == ';', token
1062 return self._CreateVariable(indices, name.name, indices.name,
1068 # We get: name=void return_type=[] parameters=sq_type ... field_
1073 modifiers = [p.name for p in self._GetParameters()]
1075 return self._CreateVariable(indices, real_name.name, indices.name,
1078 if token.name == '{':
1083 if token.name == '=':
1086 if token.name == 'default' or token.name == 'delete':
1093 assert token.name == '0', token
1097 if token.name == '[':
1103 assert token.name == ';', (token, return_type_and_name, parameters)
1106 if len(return_type) > 2 and return_type[-1].name == '::':
1109 return Method(indices.start, indices.end, name.name, in_class,
1112 return Function(indices.start, indices.end, name.name, return_type,
1117 # Splitting the return type from the class name in a method
1119 # Where is the return type and where is the class name?
1120 # The heuristic used is to pull the last name as the class name.
1122 # TODO(nnorwitz): if there is only One name like in the
1123 # example above, punt and assume the last bit is the class name.
1125 # Ignore a :: prefix, if exists so we can find the first real name.
1127 if token_seq[0].name == '::':
1131 if token_seq[end-1].name == '::':
1136 # terminating condition beyond the last name.
1141 # Iterate through the sequence parsing out each name.
1144 # We got a pointer or ref. Add it to the name.
1156 # The class name is the last name.
1194 name = None
1197 name = ''.join([t.name for t in name_tokens])
1200 if token.token_type == tokenize.SYNTAX and token.name == ';':
1201 return ctor(token.start, token.end, name, None,
1206 return ctor(token.start, token.end, name, None,
1212 if token.token_type == tokenize.SYNTAX and token.name == '{':
1214 new_type = ctor(token.start, token.end, name, fields,
1216 # A name means this is an anonymous type and the name
1220 name = new_type
1225 return self._CreateVariable(token, token.name, name, [], '', None)
1234 var_token.name[0] in '*&')
1236 next_token.name == ';')
1241 if temp.token_type == tokenize.SYNTAX and temp.name == '(':
1250 assert temp.name == ';', (temp, name_tokens, var_token)
1253 type_name = ''.join([t.name for t in name_tokens])
1255 return self._CreateVariable(position, variable.name, type_name,
1256 modifiers, var_token.name, None)
1292 if token.name == 'inline':
1295 if token2.token_type == tokenize.SYNTAX and token2.name == '~':
1297 assert token.token_type == tokenize.NAME or token.name == '::', token
1352 keywords.IsKeyword(token.name)):
1354 method = getattr(self, 'handle_' + token.name)
1366 name = tokens.pop()
1367 indices = name
1372 if name.name == ')':
1375 tokens[1].name == '(' and tokens[2].name == '*'):
1376 tokens.append(name)
1377 name = tokens[3]
1378 elif name.name == ']':
1381 tokens.append(name)
1382 name = tokens[1]
1386 return Typedef(indices.start, indices.end, name.name,
1401 key = tokens[i].name
1408 if tokens[i-1].name == '=':
1413 if tokens[i-1].name != ',':
1416 key = tokens[i-1].name
1425 assert token.name == '<', token
1430 if token.name == 'class':
1432 elif token.name == 'struct':
1434 elif token.name == 'friend':
1440 if last.name == '(':
1464 if token.name not in ('public', 'protected', 'private'):
1466 # Just put the token back so we can form a name.
1472 if token.name != 'virtual':
1482 if next_token.name == '{':
1486 assert next_token.name == ',', next_token
1504 class_name = ''.join([t.name for t in name_tokens])
1507 if token.name == ';':
1512 if token.name in '*&':
1516 if next_token.name == ';':
1519 return self._CreateVariable(class_token, name_token.name,
1521 modifiers, token.name, None)
1527 if token.name == ':':
1531 if token.token_type == tokenize.SYNTAX and token.name == '{':
1533 assert token.name == '{', token
1543 assert token.name == ';', token
1551 token.name, new_class,
1552 modifiers, token.name, None)
1564 name = None
1566 name = token.name
1568 self.namespace_stack.append(name)
1574 if token.name == '=':
1576 name, next_token = self.GetName()
1577 assert next_token.name == ';', next_token
1580 assert token.name == '{', token
1596 # TODO(nnorwitz): maybe verify the method name == class name.
1604 # Pull off the next token(s?) and make that part of the method name.
1619 assert token.name == ':'
1636 return Goto(tokens[0].start, tokens[0].end, tokens[0].name)
1693 print(node.name)