23     def __init__(self, valobj, dict):  argument
24         self.valobj = valobj
26     def update(self):  argument
28             self.payload = self.valobj.GetChildMemberWithName('_M_payload')
29             self.value = self.payload.GetChildMemberWithName('_M_payload')
30 …      self.has_value = self.payload.GetChildMemberWithName('_M_engaged').GetValueAsUnsigned(0) != 0
32             self.has_value = False
36     def num_children(self):  argument
37         return 1 if self.has_value else 0
39     def get_child_index(self, name):  argument
42     def get_child_at_index(self, index):  argument
44         possible_value = self.value.GetChildMemberWithName('_M_value')
47         return self.value.Clone('Value')
54     def __init__(self, valobj, dict):  argument
55         self.valobj = valobj
56         self.count = None
57         self.kind = self.get_object_kind(valobj)
59     def get_object_kind(self, valobj):  argument
63     def extract_type(self):  argument
64         type = self.valobj.GetType()
69         template_arg_num = 4 if self.kind == "map" else 3
74     def update(self):  argument
77         self.count = None
79             self.head = self.valobj.GetChildMemberWithName('_M_h')
80             self.before_begin = self.head.GetChildMemberWithName('_M_before_begin')
81             self.next = self.before_begin.GetChildMemberWithName('_M_nxt')
82             self.data_type = self.extract_type()
83             self.skip_size = self.next.GetType().GetByteSize()
84             self.data_size = self.data_type.GetByteSize()
85             if (not self.data_type.IsValid()) or (not self.next.IsValid()):
86                 self.count = 0
88             self.count = 0
91     def get_child_index(self, name):  argument
97     def get_child_at_index(self, index):  argument
102         if index >= self.num_children():
106             current = self.next
110 …        return current.CreateChildAtOffset( '[' + str(index) + ']', self.skip_size, self.data_type)
116     def num_children(self):  argument
117         if self.count is None:
118             self.count = self.num_children_impl()
119         return self.count
121     def num_children_impl(self):  argument
124             count = self.head.GetChildMemberWithName('_M_element_count').GetValueAsUnsigned(0)
132     def __init__(self, valobj, dict, has_prev):  argument
139         self.valobj = valobj
140         self.count = None
141         self.has_prev = has_prev
142         self.list_capping_size = self.valobj.GetTarget().GetMaximumNumberOfChildrenToDisplay()
146     def next_node(self, node):  argument
150     def is_valid(self, node):  argument
152         valid = self.value(self.next_node(node)) != self.get_end_of_list_address()
154             logger >> "%s is valid" % str(self.valobj.GetName())
159     def value(self, node):  argument
163             str(self.valobj.GetName()), value)
168     def has_loop(self):  argument
174         slow = self.next
175         fast1 = self.next
176         fast2 = self.next
177         while self.is_valid(slow):
178             slow_value = self.value(slow)
179             fast1 = self.next_node(fast2)
180             fast2 = self.next_node(fast1)
181             if self.value(fast1) == slow_value or self.value(
184             slow = self.next_node(slow)
187     def num_children(self):  argument
189         if self.count is None:
191             count_child = self.node.GetChildMemberWithName('_M_data')
193                 self.count = count_child.GetValueAsUnsigned(0)
194             if self.count is None:
195                 self.count = self.num_children_impl()
196         return self.count
198     def num_children_impl(self):  argument
203             next_val = self.next.GetValueAsUnsigned(0)
206             if self.has_loop():
208             if self.has_prev:
209                 prev_val = self.prev.GetValueAsUnsigned(0)
212                 if next_val == self.node_address:
217             current = self.next
219                     '_M_next').GetValueAsUnsigned(0) != self.get_end_of_list_address():
224                 if size >= self.list_capping_size:
232     def get_child_index(self, name):  argument
239     def get_child_at_index(self, index):  argument
244         if index >= self.num_children():
248             current = self.next
256                (2 if self.has_prev else 1) * current.GetType().GetByteSize(),
257                 self.data_type)
261     def extract_type(self):  argument
263         list_type = self.valobj.GetType().GetUnqualifiedType()
270     def update(self):  argument
274         self.count = None
276             self.impl = self.valobj.GetChildMemberWithName('_M_impl')
277             self.data_type = self.extract_type()
278             if (not self.data_type.IsValid()) or (not self.impl.IsValid()):
279                 self.count = 0
280             elif not self.updateNodes():
281                 self.count = 0
283                 self.data_size = self.data_type.GetByteSize()
285             self.count = 0
293     def updateNodes(self):  argument
296     def has_children(self):  argument
303     def get_end_of_list_address(self):  argument
309     def __init__(self, valobj, dict):  argument
313     def updateNodes(self):  argument
314         self.node = self.impl.GetChildMemberWithName('_M_head')
315         self.next = self.node.GetChildMemberWithName('_M_next')
316         if (not self.node.IsValid()) or (not self.next.IsValid()):
320     def get_end_of_list_address(self):  argument
326     def __init__(self, valobj, dict):  argument
330     def updateNodes(self):  argument
331         self.node_address = self.valobj.AddressOf().GetValueAsUnsigned(0)
332         self.node = self.impl.GetChildMemberWithName('_M_node')
333         self.prev = self.node.GetChildMemberWithName('_M_prev')
334         self.next = self.node.GetChildMemberWithName('_M_next')
335 …if self.node_address == 0 or (not self.node.IsValid()) or (not self.next.IsValid()) or (not self.p…
339     def get_end_of_list_address(self):  argument
340         return self.node_address
347         def __init__(self, valobj):  argument
348             self.valobj = valobj
349             self.count = None
351         def num_children(self):  argument
352             if self.count is None:
353                 self.count = self.num_children_impl()
354             return self.count
356         def num_children_impl(self):  argument
358                 start_val = self.start.GetValueAsUnsigned(0)
359                 finish_val = self.finish.GetValueAsUnsigned(0)
360                 end_val = self.end.GetValueAsUnsigned(0)
383                 if (num_children % self.data_size) != 0:
386                     num_children = num_children // self.data_size
391         def get_child_at_index(self, index):  argument
396             if index >= self.num_children():
399                 offset = index * self.data_size
400                 return self.start.CreateChildAtOffset(
401                     '[' + str(index) + ']', offset, self.data_type)
405         def update(self):  argument
408             self.count = None
410                 impl = self.valobj.GetChildMemberWithName('_M_impl')
411                 self.start = impl.GetChildMemberWithName('_M_start')
412                 self.finish = impl.GetChildMemberWithName('_M_finish')
413                 self.end = impl.GetChildMemberWithName('_M_end_of_storage')
414                 self.data_type = self.start.GetType().GetPointeeType()
415                 self.data_size = self.data_type.GetByteSize()
418                 if self.start.IsValid() and self.finish.IsValid(
419                 ) and self.end.IsValid() and self.data_type.IsValid():
420                     self.count = None
422                     self.count = 0
424                 self.count = 0
429         def __init__(self, valobj, bool_type):  argument
430             self.valobj = valobj
431             self.bool_type = bool_type
432             self.valid = False
434         def num_children(self):  argument
435             if self.valid:
436                 start = self.start_p.GetValueAsUnsigned(0)
437                 finish = self.finish_p.GetValueAsUnsigned(0)
438                 offset = self.offset.GetValueAsUnsigned(0)
443         def get_child_at_index(self, index):  argument
444             if index >= self.num_children():
446             element_type = self.start_p.GetType().GetPointeeType()
451             element = self.start_p.CreateChildAtOffset(
458             return self.valobj.CreateValueFromExpression(
461         def update(self):  argument
463                 m_impl = self.valobj.GetChildMemberWithName('_M_impl')
464                 self.m_start = m_impl.GetChildMemberWithName('_M_start')
465                 self.m_finish = m_impl.GetChildMemberWithName('_M_finish')
466                 self.start_p = self.m_start.GetChildMemberWithName('_M_p')
467                 self.finish_p = self.m_finish.GetChildMemberWithName('_M_p')
468                 self.offset = self.m_finish.GetChildMemberWithName('_M_offset')
469                 if self.offset.IsValid() and self.start_p.IsValid() and self.finish_p.IsValid():
470                     self.valid = True
472                     self.valid = False
474                 self.valid = False
477     def __init__(self, valobj, dict):  argument
481             self.impl = self.StdVBoolImplementation(
484             self.impl = self.StdVectorImplementation(valobj)
488     def num_children(self):  argument
489         return self.impl.num_children()
491     def get_child_index(self, name):  argument
497     def get_child_at_index(self, index):  argument
498         return self.impl.get_child_at_index(index)
500     def update(self):  argument
501         return self.impl.update()
503     def has_children(self):  argument
512     def __init__(self, valobj, dict):  argument
514         self.valobj = valobj
515         self.count = None
516         self.kind = self.get_object_kind(valobj)
517         logger >> "Providing synthetic children for a " + self.kind + " named " + \
520     def get_object_kind(self, valobj):  argument
534     def fixup_class_name(self, class_name):  argument
546     def update(self):  argument
550         self.count = None
555             self.garbage = False
556             self.Mt = self.valobj.GetChildMemberWithName('_M_t')
557             self.Mimpl = self.Mt.GetChildMemberWithName('_M_impl')
558             self.Mheader = self.Mimpl.GetChildMemberWithName('_M_header')
559             if not self.Mheader.IsValid():
560                 self.count = 0
562                 map_type = self.valobj.GetType()
570                 self.data_type = allocator_type.GetTemplateArgumentType(0)
571                 if not self.data_type:
575                     rep_type = self.valobj.GetChildMemberWithName('_M_t').GetType()
576                     self.data_type = rep_type.GetTypedefedType().GetTemplateArgumentType(1)
579                 self.Mroot = self.Mheader.GetChildMemberWithName('_M_parent')
580                 self.data_size = self.data_type.GetByteSize()
581                 self.skip_size = self.Mheader.GetType().GetByteSize()
583             self.count = 0
586     def num_children(self):  argument
588         if self.count is None:
589             self.count = self.num_children_impl()
590         return self.count
592     def num_children_impl(self):  argument
595             root_ptr_val = self.node_ptr_value(self.Mroot)
598             count = self.Mimpl.GetChildMemberWithName(
605     def get_child_index(self, name):  argument
612     def get_child_at_index(self, index):  argument
617         if index >= self.num_children():
619         if self.garbage:
624             current = self.left(self.Mheader)
626                 current = self.increment_node(current)
630                 '[' + str(index) + ']', self.skip_size, self.data_type)
635     def node_ptr_value(self, node):  argument
639     def right(self, node):  argument
643     def left(self, node):  argument
647     def parent(self, node):  argument
652     def increment_node(self, node):  argument
654         max_steps = self.num_children()
655         if self.node_ptr_value(self.right(node)) != 0:
656             x = self.right(node)
658             while self.node_ptr_value(self.left(x)) != 0:
659                 x = self.left(x)
663                     self.garbage = True
668             y = self.parent(x)
670             while(self.node_ptr_value(x) == self.node_ptr_value(self.right(y))):
672                 y = self.parent(y)
676                     self.garbage = True
678             if self.node_ptr_value(self.right(x)) != self.node_ptr_value(y):
682     def has_children(self):  argument
688     def __init__(self, valobj, d):  argument
689         self.valobj = valobj
690         self.pointer_size = self.valobj.GetProcess().GetAddressByteSize()
691         self.count = None
692         self.block_size = -1
693         self.element_size = -1
694         self.find_block_size()
697     def find_block_size(self):  argument
700         self.element_type = self.valobj.GetType().GetTemplateArgumentType(0)
701         if not self.element_type.IsValid():
703         self.element_size = self.element_type.GetByteSize()
711         if self.element_size < 512:
712             self.block_size = 512 // self.element_size
714             self.block_size = 1
716     def num_children(self):  argument
717         if self.count is None:
719         return self.count
721     def has_children(self):  argument
724     def get_child_index(self, name):  argument
730     def get_child_at_index(self, index):  argument
731         if index < 0 or self.count is None:
733         if index >= self.num_children():
739             if index < self.first_node_size:
742 …     return self.first_elem.CreateChildAtOffset(name, index * self.element_size, self.element_type)
746             i, j = divmod(index - self.first_node_size, self.block_size)
749             node = self.start_node.CreateChildAtOffset(
751                 (1 + i) * self.valobj.GetProcess().GetAddressByteSize(),
752                 self.element_type.GetPointerType())
753             return node.CreateChildAtOffset(name, j * self.element_size, self.element_type)
758     def update(self):  argument
760         self.count = 0
772             if self.block_size < 0 or self.element_size < 0:
777             impl = self.valobj.GetChildMemberWithName('_M_impl')
780             self.start = impl.GetChildMemberWithName('_M_start')
781             self.start_node = self.start.GetChildMemberWithName('_M_node')
782             first_node_address = self.start_node.GetValueAsUnsigned(0)
783 …          first_node_last_elem = self.start.GetChildMemberWithName('_M_last').GetValueAsUnsigned(0)
784             self.first_elem = self.start.GetChildMemberWithName('_M_cur')
785             first_node_first_elem = self.first_elem.GetValueAsUnsigned(0)
800 …          self.first_node_size = (last_node_last_elem - first_node_first_elem) // self.element_size
801                 count += self.first_node_size
803 …         self.first_node_size = (first_node_last_elem - first_node_first_elem) // self.element_size
804                 count += self.first_node_size
809                 count += (last_node_last_elem - last_node_first_elem) // self.element_size
812 …num_intermediate_nodes = (last_node_address - first_node_address - 1) // self.valobj.GetProcess().…
813                 count += self.block_size * num_intermediate_nodes
814             self.count = count