1 files changed, 0 insertions, 123 deletions

diff --git a/examples/synthetic/bitfield/example.py b/examples/synthetic/bitfield/example.py
deleted file mode 100644
index 57bbf0f76ac9..000000000000
--- a/examples/synthetic/bitfield/example.py
+++ /dev/null
@@ -1,123 +0,0 @@
-# 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