forked from OSchip/llvm-project
101 lines
4.5 KiB
Python
101 lines
4.5 KiB
Python
# Synthetic children provider example for class MaskedData
|
|
# to use me:
|
|
# command script import ./example.py --allow-reload
|
|
# type synthetic add MaskedData --python-class example.MaskedData_SyntheticChildrenProvider
|
|
class MaskedData_SyntheticChildrenProvider:
|
|
def __init__(self, valobj, dict):
|
|
self.valobj = valobj # remember the SBValue since you will not have another chance to get it :-)
|
|
|
|
def num_children(self):
|
|
# you could perform calculations involving the SBValue and/or its children to determine this value
|
|
# here, we have an hardcoded value - but since you have stored the SBValue you could use it to
|
|
# help figure out the correct thing to return here. if you return a number N, you should be prepared to
|
|
# answer questions about N children
|
|
return 4
|
|
|
|
def has_children(self):
|
|
# we simply say True here because we know we have 4 children
|
|
# in general, you want to make this calculation as simple as possible
|
|
# and return True if in doubt (you can always return num_children == 0 later)
|
|
return True
|
|
|
|
def get_child_index(self,name):
|
|
# given a name, return its index
|
|
# you can return None if you don't know the answer for a given name
|
|
if name == "value":
|
|
return 0
|
|
# here, we are using a reserved C++ keyword as a child name - we could not do that in the source code
|
|
# but we are free to use the names we like best in the synthetic children provider class
|
|
# we are also not respecting the order of declaration in the C++ class itself - as long as
|
|
# we are consistent, we can do that freely
|
|
if name == "operator":
|
|
return 1
|
|
if name == "mask":
|
|
return 2
|
|
# this member does not exist in the original class - we will compute its value and show it to the user
|
|
# when returning synthetic children, there is no need to only stick to what already exists in memory
|
|
if name == "apply()":
|
|
return 3
|
|
return None # no clue, just say none
|
|
|
|
def get_child_at_index(self,index):
|
|
# precautionary measures
|
|
if index < 0:
|
|
return None
|
|
if index > self.num_children():
|
|
return None
|
|
if self.valobj.IsValid() == False:
|
|
return None
|
|
if index == 0:
|
|
return self.valobj.GetChildMemberWithName("value")
|
|
if index == 1:
|
|
# fetch the value of the operator
|
|
op_chosen = self.valobj.GetChildMemberWithName("oper").GetValueAsUnsigned()
|
|
# if it is a known value, return a descriptive string for it
|
|
# we are not doing this in the most efficient possible way, but the code is very readable
|
|
# and easy to maintain - if you change the values on the C++ side, the same changes must be made here
|
|
if op_chosen == 0:
|
|
return self.valobj.CreateValueFromExpression("operator",'(const char*)"none"')
|
|
elif op_chosen == 1:
|
|
return self.valobj.CreateValueFromExpression("operator",'(const char*)"AND"')
|
|
elif op_chosen == 2:
|
|
return self.valobj.CreateValueFromExpression("operator",'(const char*)"OR"')
|
|
elif op_chosen == 3:
|
|
return self.valobj.CreateValueFromExpression("operator",'(const char*)"XOR"')
|
|
elif op_chosen == 4:
|
|
return self.valobj.CreateValueFromExpression("operator",'(const char*)"NAND"')
|
|
elif op_chosen == 5:
|
|
return self.valobj.CreateValueFromExpression("operator",'(const char*)"NOR"')
|
|
else:
|
|
return self.valobj.CreateValueFromExpression("operator",'(const char*)"unknown"') # something else
|
|
if index == 2:
|
|
return self.valobj.GetChildMemberWithName("mask")
|
|
if index == 3:
|
|
# for this, we must fetch all the other elements
|
|
# in an efficient implementation, we would be caching this data for efficiency
|
|
value = self.valobj.GetChildMemberWithName("value").GetValueAsUnsigned()
|
|
operator = self.valobj.GetChildMemberWithName("oper").GetValueAsUnsigned()
|
|
mask = self.valobj.GetChildMemberWithName("mask").GetValueAsUnsigned()
|
|
# compute the masked value according to the operator
|
|
if operator == 1:
|
|
value = value & mask
|
|
elif operator == 2:
|
|
value = value | mask
|
|
elif operator == 3:
|
|
value = value ^ mask
|
|
elif operator == 4:
|
|
value = ~(value & mask)
|
|
elif operator == 5:
|
|
value = ~(value | mask)
|
|
else:
|
|
pass
|
|
value &= 0xFFFFFFFF # make sure Python does not extend our values to 64-bits
|
|
# return it - again, not the most efficient possible way. we should actually be pushing the computed value
|
|
# into an SBData, and using the SBData to create an SBValue - this has the advantage of readability
|
|
return self.valobj.CreateValueFromExpression("apply()",'(uint32_t)(' + str(value) + ')')
|
|
|
|
def update(self):
|
|
# we do not do anything special in update - but this would be the right place to lookup
|
|
# the data we use in get_child_at_index and cache it
|
|
pass
|