OpenGL rendering added, cleaned up paths

1 files changed, 0 insertions, 305 deletions

diff --git a/Release/share/glib-2.0/gdb/gobject.py b/Release/share/glib-2.0/gdb/gobject.py
deleted file mode 100644
index b96d150..0000000
--- a/Release/share/glib-2.0/gdb/gobject.py
+++ /dev/null
@@ -1,305 +0,0 @@
-import gdb
-import glib
-import gdb.backtrace
-import gdb.command.backtrace
-
-# This is not quite right, as local vars may override symname
-def read_global_var (symname):
-    return gdb.selected_frame().read_var(symname)
-
-def g_type_to_name (gtype):
-    def lookup_fundamental_type (typenode):
-        if typenode == 0:
-            return None
-        val = read_global_var ("static_fundamental_type_nodes")
-        if val == None:
-            return None
-        return val[typenode >> 2].address()
-
-    gtype = long(gtype)
-    typenode = gtype - gtype % 4
-    if typenode > (255 << 2):
-        typenode = gdb.Value(typenode).cast (gdb.lookup_type("TypeNode").pointer())
-    else:
-        typenode = lookup_fundamental_type (typenode)
-    if typenode != None:
-        return glib.g_quark_to_string (typenode["qname"])
-    return None
-
-def is_g_type_instance (val):
-    def is_g_type_instance_helper (type):
-        if str(type) == "GTypeInstance":
-            return True
-
-        while type.code == gdb.TYPE_CODE_TYPEDEF:
-            type = type.target()
-
-        if type.code != gdb.TYPE_CODE_STRUCT:
-            return False
-
-        fields = type.fields()
-        if len (fields) < 1:
-            return False
-
-        first_field = fields[0]
-        return is_g_type_instance_helper(first_field.type)
-
-    type = val.type
-    if type.code != gdb.TYPE_CODE_PTR:
-        return False
-    type = type.target()
-    return is_g_type_instance_helper (type)
-
-def g_type_name_from_instance (instance):
-    if long(instance) != 0:
-        try:
-            inst = instance.cast (gdb.lookup_type("GTypeInstance").pointer())
-            klass = inst["g_class"]
-            gtype = klass["g_type"]
-            name = g_type_to_name (gtype)
-            return name
-        except RuntimeError:
-            pass
-    return None
-
-class GTypePrettyPrinter:
-    "Prints a GType instance pointer"
-
-    def __init__ (self, val):
-        self.val = val
-
-    def to_string (self):
-        name = g_type_name_from_instance (self.val)
-        if name:
-            return ("0x%x [%s]")% (long(self.val), name)
-        return  ("0x%x") % (long(self.val))
-
-def pretty_printer_lookup (val):
-    if is_g_type_instance (val):
-        return GTypePrettyPrinter (val)
-
-    return None
-
-def get_signal_name (id):
-  if id == None:
-    return None
-  id = long(id)
-  if id == 0:
-    return None
-  val = read_global_var ("g_signal_nodes")
-  max_s = read_global_var ("g_n_signal_nodes")
-  max_s = long(max_s)
-  if id < max_s:
-    return val[id]["name"].string()
-  return None
-
-class GFrameWrapper:
-    def __init__ (self, frame):
-        self.frame = frame;
-
-    def name (self):
-        name = self.frame.name()
-        if name and name.startswith("IA__"):
-            return name[4:]
-        return name
-
-    def __getattr__ (self, name):
-        return getattr (self.frame, name)
-
-# Monkey patch FrameWrapper to avoid IA__ in symbol names
-old__init__ = gdb.command.backtrace.FrameWrapper.__init__
-def monkey_patched_init(self, frame):
-    name = frame.name()
-    if name and name.startswith("IA__"):
-        frame = GFrameWrapper(frame)
-    old__init__(self,frame)
-gdb.command.backtrace.FrameWrapper.__init__ = monkey_patched_init
-
-class DummyFrame:
-    def __init__ (self, frame):
-        self.frame = frame
-
-    def name (self):
-        return "signal-emission-dummy"
-
-    def describe (self, stream, full):
-        stream.write (" <...>\n")
-
-    def __getattr__ (self, name):
-        return getattr (self.frame, name)
-
-class SignalFrame:
-    def __init__ (self, frames):
-        self.frame = frames[-1]
-        self.frames = frames;
-
-    def name (self):
-        return "signal-emission"
-
-    def read_var (self, frame, name, array = None):
-        try:
-            v = frame.read_var (name)
-            if v == None or v.is_optimized_out:
-                return None
-            if array != None:
-                array.append (v)
-            return v
-        except ValueError:
-            return None
-
-    def read_object (self, frame, name, array = None):
-        try:
-            v = frame.read_var (name)
-            if v == None or v.is_optimized_out:
-                return None
-            v = v.cast (gdb.lookup_type("GObject").pointer())
-            # Ensure this is a somewhat correct object pointer
-            if v != None and g_type_name_from_instance (v):
-                if array != None:
-                    array.append (v)
-                return v
-            return None
-        except ValueError:
-            return None
-
-    def append (self, array, obj):
-        if obj != None:
-            array.append (obj)
-
-    def or_join_array (self, array):
-        if len(array) == 0:
-            return "???"
-
-        v = {}
-        for i in range(len(array)):
-            v[str(array[i])] = 1
-        array = v.keys()
-        s = array[0]
-        for i in range(1, len(array)):
-            s = s + " or %s"%array[i]
-
-        return s
-
-    def describe (self, stream, full):
-        instances = []
-        signals = []
-
-        for frame in self.frames:
-            name = frame.name()
-            if name == "signal_emit_unlocked_R":
-                self.read_object (frame, "instance", instances)
-                node = self.read_var (frame, "node")
-                if node:
-                    signal = node["name"].string()
-                    detail = self.read_var (frame, "detail")
-                    detail = glib.g_quark_to_string (detail)
-                    if detail != None:
-                        signal = signal + ":" + detail
-                    self.append (signals, signal)
-
-            if name == "g_signal_emitv":
-                instance_and_params = self.read_var (frame, "instance_and_params")
-                if instance_and_params:
-                    instance = instance_and_params[0]["v_pointer"].cast (gdb.Type("GObject").pointer())
-                    self.append (instances, instance)
-                id = self.read_var (frame, "signal_id")
-                signal = get_signal_name (id)
-                if signal:
-                    detail = self.read_var (frame, "detail")
-                    detail = glib.g_quark_to_string (detail)
-                    if detail != None:
-                        signal = signal + ":" + detail
-                    self.append (signals, signal)
-
-            if name == "g_signal_emit_valist" or name == "g_signal_emit":
-                self.read_object (frame, "instance", instances)
-                id = self.read_var (frame, "signal_id")
-                signal = get_signal_name (id)
-                if signal:
-                    detail = self.read_var (frame, "detail")
-                    detail = glib.g_quark_to_string (detail)
-                    if detail != None:
-                        signal = signal + ":" + detail
-                    self.append (signals, signal)
-
-            if name == "g_signal_emit_by_name":
-                self.read_object (frame, "instance", instances)
-                self.read_var (frame, "detailed_signal", signals)
-                break
-
-        instance = self.or_join_array (instances)
-        signal = self.or_join_array (signals)
-
-        stream.write (" <emit signal %s on instance %s>\n" %  (signal, instance))
-
-    def __getattr__ (self, name):
-        return getattr (self.frame, name)
-
-class GFrameFilter:
-    def __init__ (self, iter):
-        self.queue = []
-        self.iter = iter
-
-    def __iter__ (self):
-        return self
-
-    def fill (self):
-        while len(self.queue) <= 6:
-            try:
-                f = self.iter.next ()
-                self.queue.append (f)
-            except StopIteration:
-                return
-
-    def find_signal_emission (self):
-        for i in range (min (len(self.queue), 3)):
-            if self.queue[i].name() == "signal_emit_unlocked_R":
-                return i
-        return -1
-
-    def next (self):
-        # Ensure we have enough frames for a full signal emission
-        self.fill()
-
-        # Are we at the end?
-        if len(self.queue) == 0:
-            raise StopIteration
-
-        emission = self.find_signal_emission ()
-        if emission > 0:
-            start = emission
-            while True:
-                if start == 0:
-                    break
-                prev_name = self.queue[start-1].name()
-                if prev_name.find("_marshal_") or prev_name == "g_closure_invoke":
-                    start = start - 1
-                else:
-                    break
-            end = emission + 1
-            while end < len(self.queue):
-                if self.queue[end].name() in ["g_signal_emitv",
-                                              "g_signal_emit_valist",
-                                              "g_signal_emit",
-                                              "g_signal_emit_by_name"]:
-                    end = end + 1
-                else:
-                    break
-
-            signal_frames = self.queue[start:end]
-            new_frames = []
-            for i in range(len(signal_frames)-1):
-                new_frames.append(DummyFrame(signal_frames[i]))
-            new_frames.append(SignalFrame(signal_frames))
-
-            self.queue[start:end] = new_frames
-
-        return self.queue.pop(0)
-
-
-def register (obj):
-    if obj == None:
-        obj = gdb
-
-    gdb.backtrace.push_frame_filter (GFrameFilter)
-    obj.pretty_printers.append(pretty_printer_lookup)