RubyGems - atk - Versions diffs - 0.90.5-x86-mingw32 → 0.90.6-x86-mingw32 - Mend

atk 0.90.5-x86-mingw32 → 0.90.6-x86-mingw32

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (765) hide show

data/vendor/local/share/doc/libasprintf/autosprintf_all.html DELETED Viewed

@@ -1,174 +0,0 @@
-<HTML>
-<HEAD>
-<!-- This HTML file has been created by texi2html 1.52b
-     from autosprintf.texi on 1 September 2007 -->
-<META HTTP-EQUIV="content-type" CONTENT="text/html; charset=UTF-8">
-<TITLE>GNU autosprintf</TITLE>
-</HEAD>
-<BODY>
-<H1>GNU autosprintf, version 1.0</H1>
-<H2>Formatted Output to Strings in C++</H2>
-<ADDRESS>Bruno Haible</ADDRESS>
-<P>
-<P><HR><P>
-<H1>Table of Contents</H1>
-<UL>
-<LI><A NAME="TOC1" HREF="autosprintf.html#SEC1">1  Introduction</A>
-<LI><A NAME="TOC2" HREF="autosprintf.html#SEC2">2  The <CODE>autosprintf</CODE> class</A>
-<LI><A NAME="TOC3" HREF="autosprintf.html#SEC3">3  Using <CODE>autosprintf</CODE> in own programs</A>
-</UL>
-<P><HR><P>
-<P>
-Copyright (C) 2002-2003, 2006-2007 Free Software Foundation, Inc.
-</P>
-<P>
-This manual is free documentation.  It is dually licensed under the
-GNU FDL and the GNU GPL.  This means that you can redistribute this
-manual under either of these two licenses, at your choice.
-</P>
-<P>
-This manual is covered by the GNU FDL.  Permission is granted to copy,
-distribute and/or modify this document under the terms of the
-GNU Free Documentation License (FDL), either version 1.2 of the
-License, or (at your option) any later version published by the
-Free Software Foundation (FSF); with no Invariant Sections, with no
-Front-Cover Text, and with no Back-Cover Texts.
-A copy of the license is at <A HREF="http://www.gnu.org/licenses/fdl.html">http://www.gnu.org/licenses/fdl.html</A>.
-</P>
-<P>
-This manual is covered by the GNU GPL.  You can redistribute it and/or
-modify it under the terms of the GNU General Public License (GPL), either
-version 2 of the License, or (at your option) any later version published
-by the Free Software Foundation (FSF).
-A copy of the license is at <A HREF="http://www.gnu.org/licenses/gpl.html">http://www.gnu.org/licenses/gpl.html</A>.
-</P>
-<H1><A NAME="SEC1" HREF="autosprintf.html#TOC1">1  Introduction</A></H1>
-<P>
-This package makes the C formatted output routines (<CODE>fprintf</CODE> et al.)
-usable in C++ programs, for use with the <CODE>&#60;string&#62;</CODE> strings and the
-<CODE>&#60;iostream&#62;</CODE> streams.
-</P>
-<P>
-It allows to write code like
-</P>
-<PRE>
-cerr &#60;&#60; autosprintf ("syntax error in %s:%d: %s", filename, line, errstring);
-</PRE>
-<P>
-instead of
-</P>
-<PRE>
-cerr &#60;&#60; "syntax error in " &#60;&#60; filename &#60;&#60; ":" &#60;&#60; line &#60;&#60; ": " &#60;&#60; errstring;
-</PRE>
-<P>
-The benefits of the autosprintf syntax are:
-</P>
-<UL>
-<LI>
-It reuses the standard POSIX printf facility. Easy migration from C to C++.
-<LI>
-English sentences are kept together.
-<LI>
-It makes internationalization possible. Internationalization requires format
-strings, because in some cases the translator needs to change the order of a
-sentence, and more generally it is easier for the translator to work with a
-single string for a sentence than with multiple string pieces.
-<LI>
-It reduces the risk of programming errors due to forgotten state in the
-output stream (e.g. <CODE>cout &#60;&#60; hex;</CODE> not followed by <CODE>cout &#60;&#60; dec;</CODE>).
-</UL>
-<H1><A NAME="SEC2" HREF="autosprintf.html#TOC2">2  The <CODE>autosprintf</CODE> class</A></H1>
-<P>
-An instance of class <CODE>autosprintf</CODE> just contains a string with the
-formatted output result. Such an instance is usually allocated as an
-automatic storage variable, i.e. on the stack, not with <CODE>new</CODE> on the
-heap.
-</P>
-<P>
-The constructor <CODE>autosprintf (const char *format, ...)</CODE> takes a format
-string and additional arguments, like the C function <CODE>printf</CODE>.
-</P>
-<P>
-Conversions to <CODE>char *</CODE> and <CODE>std::string</CODE> are defined that return
-the encapsulated string.  The conversion to <CODE>char *</CODE> returns a freshly
-allocated copy of the encapsulated string; it needs to be freed using
-<CODE>delete[]</CODE>.  The conversion to <CODE>std::string</CODE> returns a copy of
-the encapsulated string, with automatic memory management.
-</P>
-<P>
-The destructor <CODE>~autosprintf ()</CODE> destroys the encapsulated string.
-</P>
-<P>
-An <CODE>operator &#60;&#60;</CODE> is provided that outputs the encapsulated string to the
-given <CODE>ostream</CODE>.
-</P>
-<H1><A NAME="SEC3" HREF="autosprintf.html#TOC3">3  Using <CODE>autosprintf</CODE> in own programs</A></H1>
-<P>
-To use the <CODE>autosprintf</CODE> class in your programs, you need to add
-</P>
-<PRE>
-#include "autosprintf.h"
-using gnu::autosprintf;
-</PRE>
-<P>
-to your source code.
-The include file defines the class <CODE>autosprintf</CODE>, in a namespace called
-<CODE>gnu</CODE>. The <SAMP>&lsquo;using&rsquo;</SAMP> statement makes it possible to use the class
-without the (otherwise natural) <CODE>gnu::</CODE> prefix.
-</P>
-<P>
-When linking your program, you need to link with <CODE>libasprintf</CODE>, because
-that's where the class is defined. In projects using GNU <CODE>autoconf</CODE>,
-this means adding <SAMP>&lsquo;AC_LIB_LINKFLAGS([asprintf])&rsquo;</SAMP> to <CODE>configure.in</CODE>
-or <CODE>configure.ac</CODE>, and using the @LIBASPRINTF@ Makefile variable that
-it provides.
-</P>
-<P><HR><P>
-This document was generated on 1 September 2007 using the
-<A HREF="http://wwwinfo.cern.ch/dis/texi2html/">texi2html</A>
-translator version 1.52b.</P>
-</BODY>
-</HTML>

data/vendor/local/share/glib-2.0/gdb/glib.py DELETED Viewed

@@ -1,249 +0,0 @@
-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
-    val = read_global_var ("g_quarks")
-    max_q = long(read_global_var ("g_quark_seq_id"))
-    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.array = ht["nodes"]
-                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):
-                node = self.array[self.pos]
-                self.pos = self.pos + 1
-                if long (node["key_hash"]) >= 2:
-                    key = node["key"]
-                    val = node["value"]
-                    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 ()

data/vendor/local/share/glib-2.0/gdb/gobject.py DELETED Viewed

@@ -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)