Merge branch 'master' of https://collaborating.tuhh.de/cev7691/mandelbrot-zoom

3 files changed, 724 insertions, 0 deletions

diff --git a/Release/share/glib-2.0/gdb/glib.py b/Release/share/glib-2.0/gdb/glib.py
new file mode 100644
index 0000000..de763ae
--- /dev/null
+++ b/Release/share/glib-2.0/gdb/glib.py
@@ -0,0 +1,257 @@
+import gdb
+
+# 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_quark_to_string (quark):
+    if quark == None:
+        return None
+    quark = long(quark)
+    if quark == 0:
+        return None
+    try:
+        val = read_global_var ("quarks")
+        max_q = long(read_global_var ("quark_seq_id"))
+    except:
+        try:
+            val = read_global_var ("g_quarks")
+            max_q = long(read_global_var ("g_quark_seq_id"))
+        except:
+            return None;
+    if quark < max_q:
+        return val[quark].string()
+    return None
+
+# We override the node printers too, so that node->next is not expanded
+class GListNodePrinter:
+    "Prints a GList node"
+
+    def __init__ (self, val):
+        self.val = val
+
+    def to_string (self):
+        return "{data=%s, next=0x%x, prev=0x%x}" % (str(self.val["data"]), long(self.val["next"]), long(self.val["prev"]))
+
+class GSListNodePrinter:
+    "Prints a GSList node"
+
+    def __init__ (self, val):
+        self.val = val
+
+    def to_string (self):
+        return "{data=%s, next=0x%x}" % (str(self.val["data"]), long(self.val["next"]))
+
+class GListPrinter:
+    "Prints a GList"
+
+    class _iterator:
+        def __init__(self, head, listtype):
+            self.link = head
+            self.listtype = listtype
+            self.count = 0
+
+        def __iter__(self):
+            return self
+
+        def next(self):
+            if self.link == 0:
+                raise StopIteration
+            data = self.link['data']
+            self.link = self.link['next']
+            count = self.count
+            self.count = self.count + 1
+            return ('[%d]' % count, data)
+
+    def __init__ (self, val, listtype):
+        self.val = val
+        self.listtype = listtype
+
+    def children(self):
+        return self._iterator(self.val, self.listtype)
+
+    def to_string (self):
+        return  "0x%x" % (long(self.val))
+
+    def display_hint (self):
+        return "array"
+
+class GHashPrinter:
+    "Prints a GHashTable"
+
+    class _iterator:
+        def __init__(self, ht, keys_are_strings):
+            self.ht = ht
+            if ht != 0:
+                self.keys = ht["keys"]
+                self.values = ht["values"]
+                self.hashes = ht["hashes"]
+                self.size = ht["size"]
+            self.pos = 0
+            self.keys_are_strings = keys_are_strings
+            self.value = None
+
+        def __iter__(self):
+            return self
+
+        def next(self):
+            if self.ht == 0:
+                raise StopIteration
+            if self.value != None:
+                v = self.value
+                self.value = None
+                return v
+            while long(self.pos) < long(self.size):
+                self.pos = self.pos + 1
+                if long (self.hashes[self.pos]) >= 2:
+                    key = self.keys[self.pos]
+                    val = self.values[self.pos]
+
+                    if self.keys_are_strings:
+                        key = key.cast (gdb.lookup_type("char").pointer())
+
+                    # Queue value for next result
+                    self.value = ('[%dv]'% (self.pos), val)
+
+                    # Return key
+                    return ('[%dk]'% (self.pos), key)
+            raise StopIteration
+
+    def __init__ (self, val):
+        self.val = val
+        self.keys_are_strings = False
+        try:
+            string_hash = read_global_var ("g_str_hash")
+        except:
+            string_hash = None
+        if self.val != 0 and string_hash != None and self.val["hash_func"] == string_hash:
+            self.keys_are_strings = True
+
+    def children(self):
+        return self._iterator(self.val, self.keys_are_strings)
+
+    def to_string (self):
+        return  "0x%x" % (long(self.val))
+
+    def display_hint (self):
+        return "map"
+
+def pretty_printer_lookup (val):
+    if is_g_type_instance (val):
+        return GTypePrettyPrinter (val)
+
+def pretty_printer_lookup (val):
+    # None yet, want things like hash table and list
+
+    type = val.type.unqualified()
+
+    # If it points to a reference, get the reference.
+    if type.code == gdb.TYPE_CODE_REF:
+        type = type.target ()
+
+    if type.code == gdb.TYPE_CODE_PTR:
+        type = type.target().unqualified()
+        t = str(type)
+        if t == "GList":
+            return GListPrinter(val, "GList")
+        if t == "GSList":
+            return GListPrinter(val, "GSList")
+        if t == "GHashTable":
+            return GHashPrinter(val)
+    else:
+        t = str(type)
+        if t == "GList":
+            return GListNodePrinter(val)
+        if t == "GSList *":
+            return GListPrinter(val, "GSList")
+    return None
+
+def register (obj):
+    if obj == None:
+        obj = gdb
+
+    obj.pretty_printers.append(pretty_printer_lookup)
+
+class ForeachCommand (gdb.Command):
+    """Foreach on list"""
+
+    def __init__ (self):
+        super (ForeachCommand, self).__init__ ("gforeach",
+                                               gdb.COMMAND_DATA,
+                                               gdb.COMPLETE_SYMBOL)
+
+    def valid_name (self, name):
+        if not name[0].isalpha():
+            return False
+        return True
+
+    def parse_args (self, arg):
+        i = arg.find(" ")
+        if i <= 0:
+            raise Exception ("No var specified")
+        var = arg[:i]
+        if not self.valid_name(var):
+            raise Exception ("Invalid variable name")
+
+        while i < len (arg) and arg[i].isspace():
+            i = i + 1
+
+        if arg[i:i+2] != "in":
+            raise Exception ("Invalid syntax, missing in")
+
+        i = i + 2
+
+        while i < len (arg) and arg[i].isspace():
+            i = i + 1
+
+        colon = arg.find (":", i)
+        if colon == -1:
+            raise Exception ("Invalid syntax, missing colon")
+
+        val = arg[i:colon]
+
+        colon = colon + 1
+        while colon < len (arg) and arg[colon].isspace():
+            colon = colon + 1
+
+        command = arg[colon:]
+
+        return (var, val, command)
+
+    def do_iter(self, arg, item, command):
+        item = item.cast (gdb.lookup_type("void").pointer())
+        item = long(item)
+        to_eval = "set $%s = (void *)0x%x\n"%(arg, item)
+        gdb.execute(to_eval)
+        gdb.execute(command)
+
+    def slist_iterator (self, arg, container, command):
+        l = container.cast (gdb.lookup_type("GSList").pointer())
+        while long(l) != 0:
+            self.do_iter (arg, l["data"], command)
+            l = l["next"]
+
+    def list_iterator (self, arg, container, command):
+        l = container.cast (gdb.lookup_type("GList").pointer())
+        while long(l) != 0:
+            self.do_iter (arg, l["data"], command)
+            l = l["next"]
+
+    def pick_iterator (self, container):
+        t = container.type.unqualified()
+        if t.code == gdb.TYPE_CODE_PTR:
+            t = t.target().unqualified()
+            t = str(t)
+            if t == "GSList":
+                return self.slist_iterator
+            if t == "GList":
+                return self.list_iterator
+        raise Exception("Invalid container type %s"%(str(container.type)))
+
+    def invoke (self, arg, from_tty):
+        (var, container, command) = self.parse_args(arg)
+        container = gdb.parse_and_eval (container)
+        func = self.pick_iterator(container)
+        func(var, container, command)
+
+ForeachCommand ()
diff --git a/Release/share/glib-2.0/gdb/gobject.py b/Release/share/glib-2.0/gdb/gobject.py
new file mode 100644
index 0000000..b96d150
--- /dev/null
+++ b/Release/share/glib-2.0/gdb/gobject.py
@@ -0,0 +1,305 @@
+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)
diff --git a/Release/share/glib-2.0/gettext/mkinstalldirs b/Release/share/glib-2.0/gettext/mkinstalldirs
new file mode 100644
index 0000000..55d537f
--- /dev/null
+++ b/Release/share/glib-2.0/gettext/mkinstalldirs
@@ -0,0 +1,162 @@
+#! /bin/sh
+# mkinstalldirs --- make directory hierarchy
+
+scriptversion=2009-04-28.21; # UTC
+
+# Original author: Noah Friedman <friedman@prep.ai.mit.edu>
+# Created: 1993-05-16
+# Public domain.
+#
+# This file is maintained in Automake, please report
+# bugs to <bug-automake@gnu.org> or send patches to
+# <automake-patches@gnu.org>.
+
+nl='
+'
+IFS=" ""	$nl"
+errstatus=0
+dirmode=
+
+usage="\
+Usage: mkinstalldirs [-h] [--help] [--version] [-m MODE] DIR ...
+
+Create each directory DIR (with mode MODE, if specified), including all
+leading file name components.
+
+Report bugs to <bug-automake@gnu.org>."
+
+# process command line arguments
+while test $# -gt 0 ; do
+  case $1 in
+    -h | --help | --h*)         # -h for help
+      echo "$usage"
+      exit $?
+      ;;
+    -m)                         # -m PERM arg
+      shift
+      test $# -eq 0 && { echo "$usage" 1>&2; exit 1; }
+      dirmode=$1
+      shift
+      ;;
+    --version)
+      echo "$0 $scriptversion"
+      exit $?
+      ;;
+    --)                         # stop option processing
+      shift
+      break
+      ;;
+    -*)                         # unknown option
+      echo "$usage" 1>&2
+      exit 1
+      ;;
+    *)                          # first non-opt arg
+      break
+      ;;
+  esac
+done
+
+for file
+do
+  if test -d "$file"; then
+    shift
+  else
+    break
+  fi
+done
+
+case $# in
+  0) exit 0 ;;
+esac
+
+# Solaris 8's mkdir -p isn't thread-safe.  If you mkdir -p a/b and
+# mkdir -p a/c at the same time, both will detect that a is missing,
+# one will create a, then the other will try to create a and die with
+# a "File exists" error.  This is a problem when calling mkinstalldirs
+# from a parallel make.  We use --version in the probe to restrict
+# ourselves to GNU mkdir, which is thread-safe.
+case $dirmode in
+  '')
+    if mkdir -p --version . >/dev/null 2>&1 && test ! -d ./--version; then
+      echo "mkdir -p -- $*"
+      exec mkdir -p -- "$@"
+    else
+      # On NextStep and OpenStep, the 'mkdir' command does not
+      # recognize any option.  It will interpret all options as
+      # directories to create, and then abort because '.' already
+      # exists.
+      test -d ./-p && rmdir ./-p
+      test -d ./--version && rmdir ./--version
+    fi
+    ;;
+  *)
+    if mkdir -m "$dirmode" -p --version . >/dev/null 2>&1 &&
+       test ! -d ./--version; then
+      echo "mkdir -m $dirmode -p -- $*"
+      exec mkdir -m "$dirmode" -p -- "$@"
+    else
+      # Clean up after NextStep and OpenStep mkdir.
+      for d in ./-m ./-p ./--version "./$dirmode";
+      do
+        test -d $d && rmdir $d
+      done
+    fi
+    ;;
+esac
+
+for file
+do
+  case $file in
+    /*) pathcomp=/ ;;
+    *)  pathcomp= ;;
+  esac
+  oIFS=$IFS
+  IFS=/
+  set fnord $file
+  shift
+  IFS=$oIFS
+
+  for d
+  do
+    test "x$d" = x && continue
+
+    pathcomp=$pathcomp$d
+    case $pathcomp in
+      -*) pathcomp=./$pathcomp ;;
+    esac
+
+    if test ! -d "$pathcomp"; then
+      echo "mkdir $pathcomp"
+
+      mkdir "$pathcomp" || lasterr=$?
+
+      if test ! -d "$pathcomp"; then
+	errstatus=$lasterr
+      else
+	if test ! -z "$dirmode"; then
+	  echo "chmod $dirmode $pathcomp"
+	  lasterr=
+	  chmod "$dirmode" "$pathcomp" || lasterr=$?
+
+	  if test ! -z "$lasterr"; then
+	    errstatus=$lasterr
+	  fi
+	fi
+      fi
+    fi
+
+    pathcomp=$pathcomp/
+  done
+done
+
+exit $errstatus
+
+# Local Variables:
+# mode: shell-script
+# sh-indentation: 2
+# eval: (add-hook 'write-file-hooks 'time-stamp)
+# time-stamp-start: "scriptversion="
+# time-stamp-format: "%:y-%02m-%02d.%02H"
+# time-stamp-time-zone: "UTC"
+# time-stamp-end: "; # UTC"
+# End: