Lines Matching defs:self
21 # Therefore all self.FIELDs must be set in the pretty-printer's
163 def __init__(self, val):
164 self.val = val
165 self.child_iter = iter(self.val["__base_"].type.fields())
166 self.count = 0
168 def __iter__(self):
169 return self
171 def __next__(self):
173 field_name = next(self.child_iter)
174 child = self.val["__base_"][field_name]["__value_"]
175 self.count += 1
176 return ("[%d]" % (self.count - 1), child)
180 def __init__(self, val):
181 self.val = val
183 def to_string(self):
184 typename = _remove_generics(_prettify_typename(self.val.type))
185 if not self.val.type.fields():
189 def children(self):
190 if not self.val.type.fields():
192 return self._Children(self.val)
197 def __init__(self, val):
198 self.val = val
200 def to_string(self):
202 value_field = self.val["__rep_"]
214 def display_hint(self):
221 def __init__(self, val):
222 self.val = val
224 def display_hint(self):
227 def to_string(self): # pylint: disable=g-bad-name
230 ptr = _data_field(self.val)
232 size = _size_field(self.val)
239 def __init__(self, val):
240 self.val = val
241 self.addr = self.val["__ptr_"]
242 self.pointee_type = self.val.type.template_argument(0)
244 def to_string(self):
245 typename = _remove_generics(_prettify_typename(self.val.type))
246 if not self.addr:
250 _remove_generics(_prettify_typename(self.pointee_type)),
253 def __iter__(self):
254 if self.addr:
255 yield "__ptr_", self.addr.cast(self.pointee_type.pointer())
257 def children(self):
258 return self
264 def __init__(self, val):
265 self.val = val
266 self.addr = self.val["__ptr_"]
268 def to_string(self):
269 """Returns self as a string."""
270 typename = _remove_generics(_prettify_typename(self.val.type))
272 _prettify_typename(self.val.type.template_argument(0))
274 if not self.addr:
276 refcount = self.val["__cntrl_"]
295 def __iter__(self):
296 if self.addr:
297 yield "__ptr_", self.addr
299 def children(self):
300 return self
309 def __init__(self, begin, size, bits_per_word):
310 self.item = begin
311 self.size = size
312 self.bits_per_word = bits_per_word
313 self.count = 0
314 self.offset = 0
316 def __iter__(self):
317 return self
319 def __next__(self):
322 self.count += 1
323 if self.count > self.size:
325 entry = self.item.dereference()
326 if entry & (1 << self.offset):
330 self.offset += 1
331 if self.offset >= self.bits_per_word:
332 self.item += 1
333 self.offset = 0
334 return ("[%d]" % (self.count - 1), outbit)
341 def __init__(self, begin, end):
342 self.item = begin
343 self.end = end
344 self.count = 0
346 def __iter__(self):
347 return self
349 def __next__(self):
350 self.count += 1
351 if self.item == self.end:
353 entry = self.item.dereference()
354 self.item += 1
355 return ("[%d]" % (self.count - 1), entry)
359 def __init__(self, val):
361 self.val = val
362 self.typename = _remove_generics(_prettify_typename(val.type))
363 begin = self.val["__begin_"]
364 if self.val.type.template_argument(0).code == gdb.TYPE_CODE_BOOL:
365 self.typename += "<bool>"
366 self.length = self.val["__size_"]
367 bits_per_word = self.val["__bits_per_word"]
368 self.capacity = self.val["__cap_"] * bits_per_word
369 self.iterator = self._VectorBoolIterator(begin, self.length, bits_per_word)
371 end = self.val["__end_"]
372 self.length = end - begin
373 self.capacity = self.val["__cap_"] - begin
374 self.iterator = self._VectorIterator(begin, end)
376 def to_string(self):
378 self.typename,
379 self.length,
380 self.capacity,
383 def children(self):
384 return self.iterator
386 def display_hint(self):
393 def __init__(self, val):
394 self.val = val
395 self.n_words = int(self.val["__n_words"])
396 self.bits_per_word = int(self.val["__bits_per_word"])
397 self.bit_count = self.val.type.template_argument(0)
398 if self.n_words == 1:
399 self.values = [int(self.val["__first_"])]
401 self.values = [
402 int(self.val["__first_"][index]) for index in range(self.n_words)
405 def to_string(self):
406 typename = _prettify_typename(self.val.type)
409 def _list_it(self):
410 for bit in range(self.bit_count):
411 word = bit // self.bits_per_word
412 word_bit = bit % self.bits_per_word
413 if self.values[word] & (1 << word_bit):
416 def __iter__(self):
417 return self._list_it()
419 def children(self):
420 return self
426 def __init__(self, val):
427 self.val = val
428 self.size = int(val["__size_"])
429 self.start_ptr = self.val["__map_"]["__begin_"]
430 self.first_block_start_index = int(self.val["__start_"])
431 self.node_type = self.start_ptr.type
432 self.block_size = self._calculate_block_size(val.type.template_argument(0))
434 def _calculate_block_size(self, element_type):
440 def _bucket_it(self, start_addr, start_index, end_index):
444 def _list_it(self):
447 current_addr = self.start_ptr
448 start_index = self.first_block_start_index
450 while num_emitted < self.size:
451 end_index = min(start_index + self.size - num_emitted, self.block_size)
452 for _, elem in self._bucket_it(current_addr, start_index, end_index):
458 self.node_type
462 def to_string(self):
463 typename = _remove_generics(_prettify_typename(self.val.type))
464 if self.size:
465 return "%s with %d elements" % (typename, self.size)
468 def __iter__(self):
469 return self._list_it()
471 def children(self):
472 return self
474 def display_hint(self):
481 def __init__(self, val):
482 self.val = val
483 self.size = int(self.val["__size_"])
484 dummy_node = self.val["__end_"]
485 self.nodetype = gdb.lookup_type(
490 self.first_node = dummy_node["__next_"]
492 def to_string(self):
493 typename = _remove_generics(_prettify_typename(self.val.type))
494 if self.size:
495 return "%s with %d elements" % (typename, self.size)
498 def _list_iter(self):
499 current_node = self.first_node
500 for i in range(self.size):
501 yield "[%d]" % i, current_node.cast(self.nodetype).dereference()["__value_"]
504 def __iter__(self):
505 return self._list_iter()
507 def children(self):
508 return self if self.nodetype else iter(())
510 def display_hint(self):
517 def __init__(self, val):
518 self.typename = _remove_generics(_prettify_typename(val.type))
519 self.visualizer = gdb.default_visualizer(val["c"])
521 def to_string(self):
522 return "%s wrapping: %s" % (self.typename, self.visualizer.to_string())
524 def children(self):
525 return self.visualizer.children()
527 def display_hint(self):
534 def __init__(self, val):
535 self.typename = _remove_generics(_prettify_typename(val.type))
536 self.visualizer = gdb.default_visualizer(val["c"])
538 def to_string(self):
543 return "%s wrapping: %s" % (self.typename, self.visualizer.to_string())
545 def children(self):
546 return self.visualizer.children()
548 def display_hint(self):
555 def __init__(self, cast_type, root):
556 self.cast_type = cast_type
557 self.root = root
559 def left_child(self, node):
560 result = node.cast(self.cast_type).dereference()["__left_"]
563 def right_child(self, node):
564 result = node.cast(self.cast_type).dereference()["__right_"]
567 def parent(self, node):
571 if node == self.root:
581 if self.left_child(node) == self.root:
584 parent = node.cast(self.cast_type).dereference()["__parent_"]
598 def is_left_child(self, node):
599 parent = self.parent(node)
600 return parent is not None and self.left_child(parent) == node
602 def is_right_child(self, node):
603 parent = self.parent(node)
604 return parent is not None and self.right_child(parent) == node
610 def __init__(self, val):
611 self.val = val
612 tree = self.val["__tree_"]
613 self.size = int(tree["__size_"])
615 cast_type = self._init_cast_type(val.type)
616 self.util = RBTreeUtils(cast_type, root)
618 def _get_key_value(self, node):
622 def _traverse(self):
624 current = self.util.root
628 if not skip_left_child and self.util.left_child(current):
629 current = self.util.left_child(current)
632 for key_value in self._get_key_value(current):
636 right_child = self.util.right_child(current)
640 while self.util.is_right_child(current):
641 current = self.util.parent(current)
642 if self.util.is_left_child(current):
643 current = self.util.parent(current)
648 def __iter__(self):
649 return self._traverse()
651 def children(self):
652 return self if self.util.cast_type and self.size > 0 else iter(())
654 def to_string(self):
655 typename = _remove_generics(_prettify_typename(self.val.type))
656 if self.size:
657 return "%s with %d elements" % (typename, self.size)
664 def _init_cast_type(self, val_type):
672 def display_hint(self):
675 def _get_key_value(self, node):
676 key_value = _cc_field(node.cast(self.util.cast_type).dereference())
683 def _init_cast_type(self, val_type):
690 def display_hint(self):
693 def _get_key_value(self, node):
694 key_value = node.cast(self.util.cast_type).dereference()["__value_"]
701 def _initialize(self, val, typename):
702 self.typename = typename
703 self.val = val
704 self.addr = self.val["__ptr_"]
705 cast_type = self.val.type.template_argument(1)
706 self.util = RBTreeUtils(cast_type, None)
707 if self.addr:
708 self.node = self.addr.cast(cast_type).dereference()
710 def _is_valid_node(self):
711 if not self.util.parent(self.addr):
713 return self.util.is_left_child(self.addr) or self.util.is_right_child(self.addr)
715 def to_string(self):
716 if not self.addr:
717 return "%s is nullptr" % self.typename
718 return "%s " % self.typename
720 def _get_node_value(self, node):
723 def __iter__(self):
724 addr_str = "[%s]" % str(self.addr)
725 if not self._is_valid_node():
728 yield addr_str, self._get_node_value(self.node)
730 def children(self):
731 return self if self.addr else iter(())
737 def __init__(self, val):
738 self._initialize(val["__i_"], _remove_generics(_prettify_typename(val.type)))
740 def _get_node_value(self, node):
747 def __init__(self, val):
748 self._initialize(val, _remove_generics(_prettify_typename(val.type)))
750 def _get_node_value(self, node):
757 def __init__(self, val):
758 self.val = val
760 def to_string(self):
761 typename = _remove_generics(_prettify_typename(self.val.type))
762 offset = self.val["__off_"]
763 state = self.val["__st_"]
781 def __init__(self, val):
782 self.val = val
783 self.table = val["__table_"]
784 self.sentinel = self.table["__first_node_"]
785 self.size = int(self.table["__size_"])
786 node_base_type = self.sentinel.type
787 self.cast_type = node_base_type.template_argument(0)
789 def _list_it(self, sentinel_ptr):
793 next_val = next_ptr.cast(self.cast_type).dereference()
794 for key_value in self._get_key_value(next_val):
800 def to_string(self):
801 typename = _remove_generics(_prettify_typename(self.val.type))
802 if self.size:
803 return "%s with %d elements" % (typename, self.size)
806 def _get_key_value(self, node):
810 def children(self):
811 return self if self.cast_type and self.size > 0 else iter(())
813 def __iter__(self):
814 return self._list_it(self.sentinel)
820 def _get_key_value(self, node):
823 def display_hint(self):
830 def _get_key_value(self, node):
834 def display_hint(self):
841 def _initialize(self, val, addr):
842 self.val = val
843 self.typename = _remove_generics(_prettify_typename(self.val.type))
844 self.addr = addr
845 if self.addr:
846 self.node = self.addr.cast(self.cast_type).dereference()
848 def _get_key_value(self):
852 def to_string(self):
853 if not self.addr:
854 return "%s = end()" % self.typename
855 return "%s " % self.typename
857 def children(self):
858 return self if self.addr else iter(())
860 def __iter__(self):
861 for i, key_value in enumerate(self._get_key_value()):
868 def __init__(self, val):
869 self.cast_type = val.type.template_argument(0)
870 self._initialize(val, val["__node_"])
872 def _get_key_value(self):
873 return [self.node["__value_"]]
875 def display_hint(self):
882 def __init__(self, val):
883 self.cast_type = val.type.template_argument(0).template_argument(0)
884 self._initialize(val, val["__i_"]["__node_"])
886 def _get_key_value(self):
887 key_value = _cc_field(self.node)
890 def display_hint(self):
902 def __init__(self, name):
903 super(LibcxxPrettyPrinter, self).__init__()
904 self.name = name
905 self.enabled = True
907 self.lookup = {
941 self.subprinters = []
942 for name, subprinter in self.lookup.items():
946 if subprinter not in self.subprinters:
948 self.subprinters.append(subprinter)
950 def __call__(self, val):
974 if lookup_name in self.lookup:
975 return self.lookup[lookup_name](val)