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

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)