b9c1b51e45
*** to conform to clang-format’s LLVM style. This kind of mass change has
*** two obvious implications:
Firstly, merging this particular commit into a downstream fork may be a huge
effort. Alternatively, it may be worth merging all changes up to this commit,
performing the same reformatting operation locally, and then discarding the
merge for this particular commit. The commands used to accomplish this
reformatting were as follows (with current working directory as the root of
the repository):
find . \( -iname "*.c" -or -iname "*.cpp" -or -iname "*.h" -or -iname "*.mm" \) -exec clang-format -i {} +
find . -iname "*.py" -exec autopep8 --in-place --aggressive --aggressive {} + ;
The version of clang-format used was 3.9.0, and autopep8 was 1.2.4.
Secondly, “blame” style tools will generally point to this commit instead of
a meaningful prior commit. There are alternatives available that will attempt
to look through this change and find the appropriate prior commit. YMMV.
llvm-svn: 280751
124 lines
5.5 KiB
Python
124 lines
5.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):
|
|
# remember the SBValue since you will not have another chance to get it
|
|
# :-)
|
|
self.valobj = valobj
|
|
|
|
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
|