Merge remote-tracking branch 'origin/gir-docbook'

Conflicts:
	.gitignore
	tests/scanner/Regress-1.0-expected.gir

12 files changed, 2484 insertions, 4 deletions

diff --git a/Makefile-giscanner.am b/Makefile-giscanner.am
index 0ca98f6c..4b98ecd3 100644
--- a/Makefile-giscanner.am
+++ b/Makefile-giscanner.am
@@ -33,6 +33,8 @@ pkgpyexec_PYTHON =			\
 	giscanner/ast.py		\
 	giscanner/cachestore.py		\
 	giscanner/codegen.py		\
+	giscanner/docbookwriter.py	\
+	giscanner/docmain.py	\
 	giscanner/dumper.py		\
 	giscanner/introspectablepass.py	\
 	giscanner/girparser.py		\
diff --git a/Makefile-tools.am b/Makefile-tools.am
index 7bc2f3f6..84858c84 100644
--- a/Makefile-tools.am
+++ b/Makefile-tools.am
@@ -1,6 +1,10 @@
 bin_PROGRAMS += g-ir-compiler g-ir-generate
-bin_SCRIPTS += g-ir-scanner g-ir-annotation-tool
-EXTRA_DIST += tools/g-ir-scanner.in tools/g-ir-annotation-tool.in
+bin_SCRIPTS += g-ir-scanner g-ir-annotation-tool g-ir-doc-tool
+
+EXTRA_DIST += 				\
+	tools/g-ir-scanner.in 		\
+	tools/g-ir-annotation-tool.in	\
+	tools/g-ir-doc-tool.in
 
 TOOL_SUBSTITUTIONS = sed -e s,@libdir\@,$(libdir), -e s,@datarootdir\@,$(datarootdir), -e s,@PYTHON\@,$(PYTHON),
 
@@ -12,6 +16,10 @@ g-ir-annotation-tool: tools/g-ir-annotation-tool.in _giscanner.la Makefile
 	$(AM_V_GEN) $(TOOL_SUBSTITUTIONS) $< > $@.tmp && mv $@.tmp $@
 	@chmod a+x $@
 
+g-ir-doc-tool: tools/g-ir-doc-tool.in _giscanner.la Makefile
+	$(AM_V_GEN) sed -e s,@libdir\@,$(libdir), -e s,@PYTHON\@,$(PYTHON), $< > $@.tmp && mv $@.tmp $@
+	@chmod a+x $@
+
 g_ir_compiler_SOURCES = tools/compiler.c
 g_ir_compiler_CPPFLAGS = -DGIREPO_DEFAULT_SEARCH_PATH="\"$(libdir)\"" \
 			 -I$(top_srcdir)/girepository
@@ -34,4 +42,4 @@ GCOVSOURCES =					\
 	$(g_ir_compiler_SOURCES)		\
 	$(g_ir_generate_SOURCES)
 
-CLEANFILES += g-ir-scanner g-ir-annotation-tool
+CLEANFILES += g-ir-scanner g-ir-annotation-tool g-ir-doc-tool
diff --git a/common.mk b/common.mk
index 21485fd2..df72b208 100644
--- a/common.mk
+++ b/common.mk
@@ -26,3 +26,5 @@ INTROSPECTION_COMPILER_ARGS = \
     --includedir=$(top_srcdir)/gir \
     --includedir=$(builddir) \
     --includedir=$(top_builddir)
+
+INTROSPECTION_DOCTOOL = $(top_builddir)/g-ir-doc-tool$(EXEEXT)
diff --git a/configure.ac b/configure.ac
index 69da250c..b349d8ec 100644
--- a/configure.ac
+++ b/configure.ac
@@ -276,6 +276,7 @@ tests/offsets/Makefile
 tests/scanner/Makefile
 tests/repository/Makefile
 tests/warn/Makefile
+tests/doctool/Makefile
 docs/Makefile
 docs/reference/Makefile
 gobject-introspection-1.0.pc
diff --git a/giscanner/ast.py b/giscanner/ast.py
index d63fdb88..1433422c 100644
--- a/giscanner/ast.py
+++ b/giscanner/ast.py
@@ -592,6 +592,13 @@ class ErrorQuarkFunction(Function):
         self.error_domain = error_domain
 
 
+class ErrorQuarkFunction(Function):
+
+    def __init__(self, name, retval, parameters, throws, symbol, error_domain):
+        Function.__init__(self, name, retval, parameters, throws, symbol)
+        self.error_domain = error_domain
+
+
 class VFunction(Callable):
 
     def __init__(self, name, retval, parameters, throws):
diff --git a/giscanner/docbookwriter.py b/giscanner/docbookwriter.py
new file mode 100644
index 00000000..30b15ee9
--- /dev/null
+++ b/giscanner/docbookwriter.py
@@ -0,0 +1,540 @@
+#!/usr/bin/env python
+# -*- Mode: Python -*-
+# GObject-Introspection - a framework for introspecting GObject libraries
+# Copyright (C) 2010 Zach Goldberg
+# Copyright (C) 2011 Johan Dahlin
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2
+# of the License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+# 02110-1301, USA.
+#
+
+import sys
+
+from . import ast
+from .girparser import GIRParser
+from .xmlwriter import XMLWriter
+
+XMLNS = "http://docbook.org/ns/docbook"
+XMLVERSION = "5.0"
+DOCTYPE = """<!DOCTYPE refentry PUBLIC "-//OASIS//DTD DocBook XML V4.1.2//EN"
+               "http://www.oasis-open.org/docbook/xml/4.1.2/docbookx.dtd" [
+<!ENTITY % local.common.attrib "xmlns:xi  CDATA  #FIXED 'http://www.w3.org/2003/XInclude'">
+<!ENTITY version SYSTEM "version.xml">
+]>""" #"
+
+def _space(num):
+    return " " * num
+
+class DocBookFormatter(object):
+    def __init__(self, writer):
+        self._namespace = None
+        self._writer = writer
+
+    def set_namespace(self, namespace):
+        self._namespace = namespace
+
+    def get_type_string(self, type):
+        return str(type.ctype)
+
+    def render_parameter(self, param_type, param_name):
+        return "%s %s" % (param_type, param_name)
+
+    def _render_parameter(self, param, extra_content=''):
+        with self._writer.tagcontext("parameter"):
+            if param.type.ctype is not None:
+                link_dest = param.type.ctype.replace("*", "")
+            else:
+                link_dest = param.type.ctype
+            with self._writer.tagcontext("link", [("linkend", "%s" % link_dest)]):
+                self._writer.write_tag("type", [], link_dest)
+            self._writer.write_line(extra_content)
+
+    def _render_parameters(self, parent, parameters):
+        self._writer.write_line(
+            "%s(" % _space(40 - len(parent.symbol)))
+
+        parent_class = parent.parent_class
+        ctype = ast.Type(parent.parent_class.ctype + '*')
+        params = []
+        params.append(ast.Parameter(parent_class.name.lower(), ctype))
+        params.extend(parameters)
+
+        first_param = True
+        for param in params:
+            if not first_param:
+                self._writer.write_line("\n%s" % _space(61))
+            else:
+                first_param = False
+
+            if not param == params[-1]:
+                comma = ", "
+            else:
+                comma = ""
+
+            if isinstance(param.type, ast.Varargs):
+                with self._writer.tagcontext("parameter"):
+                    self._writer.write_line('...%s' % comma)
+            else:
+                extra_content = " "
+                if param.type.ctype is not None and '*' in param.type.ctype:
+                    extra_content += '*'
+                extra_content += param.argname
+                extra_content += comma
+                self._render_parameter(param, extra_content)
+
+        self._writer.write_line(");\n")
+
+    def get_method_as_title(self, entity):
+        method = entity.get_ast()
+        return "%s ()" % method.symbol
+
+    def get_page_name(self, node):
+        if isinstance(node, ast.Alias) or node.gtype_name is None:
+            return node.ctype
+        return node.gtype_name
+
+    def get_class_name(self, node):
+        if node.gtype_name is None:
+            return node.ctype
+        return node.gtype_name
+
+    def get_type_name(self, node):
+        if isinstance(node, ast.Array):
+            if node.array_type == ast.Array.C:
+                return str(node.element_type) + "[]"
+            else:
+                return "%s&lt;%s&gt;" % (node.array_type, str(node.element_type))
+        elif isinstance(node, ast.Map):
+            return "GHashTable&lt;%s, %s&gt;" % (str(node.key_type), str(node.value_type))
+        elif isinstance(node, ast.List):
+            return "GList&lt;%s&gt;" % str(node.element_type)
+        else:
+            return str(node)
+
+    def render_method(self, entity, link=False):
+        method = entity.get_ast()
+        self._writer.disable_whitespace()
+
+        retval_type = method.retval.type
+        if retval_type.ctype:
+            link_dest = retval_type.ctype.replace("*", "")
+        else:
+            link_dest = str(retval_type)
+
+        if retval_type.target_giname:
+            ns = retval_type.target_giname.split('.')
+            if ns[0] == self._namespace.name:
+                link_dest = "%s" % (
+                    retval_type.ctype.replace("*", ""))
+
+        with self._writer.tagcontext("link", [("linkend", link_dest)]):
+            self._writer.write_tag("returnvalue", [], link_dest)
+
+        if '*' in retval_type.ctype:
+            self._writer.write_line(' *')
+
+        self._writer.write_line(
+            _space(20 - len(self.get_type_string(method.retval.type))))
+
+        if link:
+            self._writer.write_tag("link", [("linkend",
+                                            method.symbol.replace("_", "-"))],
+                                  method.symbol)
+        else:
+            self._writer.write_line(method.symbol)
+
+        self._render_parameters(method, method.parameters)
+        self._writer.enable_whitespace()
+
+    def _get_annotations(self, argument):
+        annotations = {}
+
+        if hasattr(argument.type, 'element_type') and \
+           argument.type.element_type is not None:
+            annotations['element-type'] = argument.type.element_type
+
+        if argument.transfer is not None and argument.transfer != 'none':
+            annotations['transfer'] = argument.transfer
+
+        if hasattr(argument, 'allow_none') and argument.allow_none:
+            annotations['allow-none'] = None
+
+        return annotations
+
+    def render_param_list(self, entity):
+        method = entity.get_ast()
+
+        self._render_param(method.parent_class.name.lower(), 'instance', [])
+
+        for param in method.parameters:
+            if isinstance(param.type, ast.Varargs):
+                argname = '...'
+            else:
+                argname = param.argname
+            self._render_param(argname, param.doc, self._get_annotations(param))
+
+        self._render_param('Returns', method.retval.doc,
+                           self._get_annotations(method.retval))
+
+    def _render_param(self, argname, doc, annotations):
+        with self._writer.tagcontext('varlistentry'):
+            with self._writer.tagcontext('term'):
+                self._writer.disable_whitespace()
+                try:
+                    with self._writer.tagcontext('parameter'):
+                        self._writer.write_line(argname)
+                    if doc is not None:
+                        self._writer.write_line('&#xA0;:')
+                finally:
+                    self._writer.enable_whitespace()
+            if doc is not None:
+                with self._writer.tagcontext('listitem'):
+                    with self._writer.tagcontext('simpara'):
+                        self._writer.write_line(doc)
+                        if annotations:
+                            with self._writer.tagcontext('emphasis', [('role', 'annotation')]):
+                                for key, value in annotations.iteritems():
+                                    self._writer.disable_whitespace()
+                                    try:
+                                        self._writer.write_line('[%s' % key)
+                                        if value is not None:
+                                            self._writer.write_line(' %s' % value)
+                                        self._writer.write_line(']')
+                                    finally:
+                                        self._writer.enable_whitespace()
+
+    def render_property(self, entity, link=False):
+        prop = entity.get_ast()
+        prop_name = '"%s"' % prop.name
+        prop_type = self.get_type_name(prop.type)
+
+        flags = []
+        if prop.readable:
+            flags.append("Read")
+        if prop.writable:
+            flags.append("Write")
+        if prop.construct:
+            flags.append("Construct")
+        if prop.construct_only:
+            flags.append("Construct Only")
+
+        self._render_prop_or_signal(prop_name, prop_type, flags)
+
+    def _render_prop_or_signal(self, name, type_, flags):
+        self._writer.disable_whitespace()
+
+        line = _space(2) + name + _space(27 - len(name))
+        line += str(type_) + _space(22 - len(str(type_)))
+        line += ": " + " / ".join(flags)
+
+        self._writer.write_line(line + "\n")
+
+        self._writer.enable_whitespace()
+
+
+    def render_signal(self, entity, link=False):
+        signal = entity.get_ast()
+
+        sig_name = '"%s"' % signal.name
+        flags = ["TODO: signal flags not in GIR currently"]
+        self._render_prop_or_signal(sig_name, "", flags)
+
+
+class DocBookPage(object):
+    def __init__(self, name, ast):
+        self.methods = []
+        self.properties = []
+        self.signals = []
+        self.name = name
+        self.description = ast.doc
+        self.ast = ast
+        self.id = None
+
+    def add_method(self, entity):
+        self.methods.append(entity)
+
+    def add_property(self, entity):
+        self.properties.append(entity)
+
+    def add_signal(self, entity):
+        self.signals.append(entity)
+
+    def get_methods(self):
+        return self.methods
+
+    def get_properties(self):
+        return self.properties
+
+    def get_signals(self):
+        return self.signals
+
+class DocBookEntity(object):
+    def __init__(self, entity_name, entity_type, entity_ast):
+        self.entity_name = entity_name
+        self.entity_type = entity_type
+        self.entity_ast = entity_ast
+
+    def get_ast(self):
+        return self.entity_ast
+
+    def get_type(self):
+        return self.entity_type
+
+    def get_name(self):
+        return self.entity_name
+
+
+class DocBookWriter(object):
+    def __init__(self):
+        self._namespace = None
+        self._pages = []
+
+        self._writer = XMLWriter()
+        self._formatter = DocBookFormatter(self._writer)
+
+    def _add_page(self, page):
+        self._pages.append(page)
+
+    def add_transformer(self, transformer):
+        self._transformer = transformer
+
+        self._namespace = self._transformer._namespace
+        self._formatter.set_namespace(self._namespace)
+
+        for name, node in self._namespace.iteritems():
+            if isinstance(node, (ast.Class, ast.Record, ast.Interface, ast.Alias)):
+                page_name = self._formatter.get_page_name(node)
+                self._add_node(node, page_name)
+
+    def _add_node(self, node, name):
+        page = DocBookPage(name, node)
+        self._add_page(page)
+
+        if isinstance(node, (ast.Class, ast.Record, ast.Interface, ast.Alias)):
+            page.id = node.ctype
+
+        if isinstance(node, (ast.Class, ast.Record, ast.Interface)):
+            for method in node.methods:
+                method.parent_class = node
+                page.add_method(DocBookEntity(method.name, "method", method))
+
+        if isinstance(node, (ast.Class, ast.Interface)):
+            for property_ in node.properties:
+                page.add_property(DocBookEntity(property_.name, "property", property_))
+            for signal in node.signals:
+                page.add_signal(DocBookEntity(signal.name, "signal", signal))
+
+    def write(self, output):
+        self._writer.write_line(DOCTYPE)
+        with self._writer.tagcontext("book", [
+            ("xml:id", "page_%s" % self._namespace.name),
+            ("xmlns", XMLNS),
+            ("version", XMLVERSION)]):
+            self._writer.write_tag("title", [], "%s Documentation" % (
+                self._namespace.name))
+
+            for page in self._pages:
+                self._render_page(page)
+
+        fp = open(output, 'w')
+        fp.write(self._writer.get_xml())
+        fp.close()
+
+    def _render_page(self, page):
+        with self._writer.tagcontext("chapter", [("xml:id", "ch_%s" % (
+                        page.name))]):
+            self._writer.write_tag(
+                "title", [], page.name)
+
+            with self._writer.tagcontext("refsynopsisdiv",
+                    [('id', '%s.synopsis' % page.name),
+                     ('role', 'synopsis')]):
+
+                self._writer.write_tag(
+                    "title", [("role", "synopsis.title")], "Synopsis")
+
+                if not isinstance(page.ast, ast.Alias):
+                    self._writer.write_tag("anchor", [("id", page.name)])
+
+                with self._writer.tagcontext('synopsis'):
+                    self._writer.disable_whitespace()
+                    try:
+                        self._writer.write_line("struct               ")
+                        self._writer.write_tag(
+                            "link",
+                            [("linkend", "%s-struct" % page.name)],
+                            "%s" % page.name)
+                        self._writer.write_line(";\n")
+                    finally:
+                        self._writer.enable_whitespace()
+
+                    for entity in page.get_methods():
+                        self._formatter.render_method(entity, link=True)
+
+            if isinstance(page.ast, (ast.Class, ast.Interface)):
+                with self._writer.tagcontext("refsect1",
+                                            [('id', '%s.object-hierarchy' % page.name),
+                                             ('role', 'object_hierarchy')]):
+                    self._writer.write_tag('title', [('role', 'object_hierarchy.title')],
+                                          "Object Hierarchy")
+                    with self._writer.tagcontext('synopsis'):
+                        self._render_page_object_hierarchy(page.ast)
+
+            if page.get_properties():
+                with self._writer.tagcontext('refsect1',
+                                            [('id', '%s.properties' % page.name),
+                                             ('role', 'properties')]):
+                    self._writer.write_tag("title", [('role', 'properties.title')],
+                                          "Properties")
+                    with self._writer.tagcontext("synopsis"):
+                        for entity in page.get_properties():
+                            self._formatter.render_property(entity, link=True)
+
+            if page.get_signals():
+                with self._writer.tagcontext('refsect1',
+                                            [('id', '%s.signals' % page.name),
+                                             ('role', 'signal_proto')]):
+                    self._writer.write_tag('title', [('role', 'signal_proto.title')],
+                                          "Signals")
+                    with self._writer.tagcontext('synopsis'):
+                        for entity in page.get_signals():
+                            self._formatter.render_signal(entity, link=True)
+
+            # if page.description:
+            #     with self._writer.tagcontext(
+            #         'refsect1',
+            #         [('id', '%s.description' % (page.name, )),
+            #          ]):
+            #         self._writer.write_tag(
+            #             "title", [("role", "desc.title")], "Description")
+            #         import cgi
+            #         desc = page.description
+            #         while True:
+            #             start = desc.find('|[')
+            #             if start == -1:
+            #                 break
+            #             end = desc.find(']|')
+            #             desc = desc[:start] + cgi.escape(desc[start+2:end]) + desc[end+2:]
+            #         desc = desc.replace("&", "&amp;")
+            #         self._writer.write_line(desc)
+
+            with self._writer.tagcontext('refsect1',
+                                        [('id', "%s-details" % page.id.lower()),
+                                         ("role", "details")]):
+                self._writer.write_tag("title", [("role", "details.title")],
+                                      "Details")
+
+                if isinstance(page.ast, ast.Alias):
+                    self._render_alias(page.ast)
+                else:
+                    self._render_struct(page.ast)
+
+                for entity in page.get_methods():
+                    self._render_method(entity)
+
+            if page.get_properties():
+                with self._writer.tagcontext('refsect1',
+                                            [('id', '%s.property-details' % page.name),
+                                             ('role', 'property_details')]):
+                    self._writer.write_tag('title', [('role', 'property_details.title')],
+                                           "Property Details")
+                    for entity in page.get_properties():
+                        self._render_property(entity)
+
+            if page.get_signals():
+                with self._writer.tagcontext('refsect1',
+                                            [('id', '%s.signal-details' % page.name),
+                                             ('role', 'signals')]):
+                    self._writer.write_tag('title', [('role', 'signal.title')],
+                                           "Signal Details")
+                    for entity in page.get_signals():
+                        self._render_signal(entity)
+
+    def _render_alias(self, alias):
+        with self._writer.tagcontext('refsect2',
+                              [('id', "%s" % alias.ctype),
+                               ('role', 'typedef')]):
+            self._writer.write_tag("title", [], "%s" % alias.ctype)
+            with self._writer.tagcontext("indexterm", [("zone", "%s" % alias.ctype)]):
+                self._writer.write_tag("primary", [("sortas", alias.name)], alias.ctype)
+            self._writer.write_tag("programlisting",
+                                   [],
+                                   "typedef %s %s" % (alias.target.ctype,
+                                                      alias.ctype))
+            self._writer.write_tag("para", [], alias.doc)
+
+    def _render_struct(self, struct):
+        with self._writer.tagcontext('refsect2',
+                              [('id', "%s-struct" % struct.ctype),
+                               ('role', 'struct')]):
+            self._writer.write_tag("title", [], "struct %s" % struct.ctype)
+            with self._writer.tagcontext("indexterm", [("zone", "%s-struct" % struct.ctype)]):
+                self._writer.write_tag("primary", [("sortas", struct.name)], struct.ctype)
+            self._writer.write_tag("programlisting", [], "struct %s;" % struct.ctype)
+
+    def _render_method(self, entity):
+
+        link_name = entity.get_ast().symbol.replace("_", "-")
+
+        self._writer.push_tag('refsect2',
+                              [('id', link_name),
+                               ('role', 'function')])
+        self._writer.write_tag("title", [],
+                               self._formatter.get_method_as_title(entity))
+
+        with self._writer.tagcontext("indexterm", [("zone", link_name)]):
+            self._writer.write_tag("primary", [], entity.get_name())
+
+        with self._writer.tagcontext("programlisting"):
+            self._formatter.render_method(entity)
+
+        self._writer.write_tag("para", [], entity.get_ast().doc)
+
+        with self._writer.tagcontext("variablelist", [("role", "params")]):
+            self._formatter.render_param_list(entity)
+
+        self._writer.pop_tag()
+
+    def _render_property(self, entity):
+        self._writer.write_line("Not implemented yet")
+
+    def _render_signal(self, entity):
+        self._writer.write_line("Not implemented yet")
+
+    def _render_page_object_hierarchy(self, page_node):
+        parent_chain = self._get_parent_chain(page_node)
+        parent_chain.append(page_node)
+        lines = []
+
+        for level, parent in enumerate(parent_chain):
+            prepend = ""
+            if level > 0:
+                prepend = _space((level - 1)* 6) + " +----"
+            lines.append(_space(2) + prepend + self._formatter.get_class_name(parent))
+
+        self._writer.disable_whitespace()
+        self._writer.write_line("\n".join(lines))
+        self._writer.enable_whitespace()
+
+    def _get_parent_chain(self, page_node):
+        parent_chain = []
+
+        node = page_node
+        while node.parent:
+            node = self._transformer.lookup_giname(str(node.parent))
+            parent_chain.append(node)
+
+        parent_chain.reverse()
+        return parent_chain
diff --git a/giscanner/docmain.py b/giscanner/docmain.py
new file mode 100644
index 00000000..29b5ddfb
--- /dev/null
+++ b/giscanner/docmain.py
@@ -0,0 +1,63 @@
+# -*- Mode: Python -*-
+# GObject-Introspection - a framework for introspecting GObject libraries
+# Copyright (C) 2008-2011 Johan Dahlin
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2
+# of the License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+# 02110-1301, USA.
+#
+
+import optparse
+
+from .docbookwriter import DocBookWriter
+from .transformer import Transformer
+
+class GIDocGenerator(object):
+
+    def parse(self, filename):
+        self.transformer = Transformer.parse_from_gir(filename)
+
+    def generate(self, writer, output):
+        writer.add_transformer(self.transformer)
+        writer.write(output)
+
+def doc_main(args):
+    parser = optparse.OptionParser('%prog [options] GIR-file')
+
+    parser.add_option("-o", "--output",
+                      action="store", dest="output",
+                      help="Filename to write output")
+    parser.add_option("-f", "--format",
+                      action="store", dest="format",
+                      default="docbook",
+                      help="Output format")
+
+    options, args = parser.parse_args(args)
+    if not options.output:
+        raise SystemExit("missing output parameter")
+
+    if len(args) < 2:
+        raise SystemExit("Need an input GIR filename")
+
+    if options.format == "docbook":
+        writer = DocBookWriter()
+    else:
+        raise SystemExit("Unsupported output format: %s" % (options.format, ))
+
+    generator = GIDocGenerator()
+    generator.parse(args[1])
+
+    generator.generate(writer, options.output)
+
+    return 0
diff --git a/giscanner/transformer.py b/giscanner/transformer.py
index 6689fc73..565d996e 100644
--- a/giscanner/transformer.py
+++ b/giscanner/transformer.py
@@ -178,6 +178,16 @@ None."""
                          % (girname, searchdirs))
         sys.exit(1)
 
+    @classmethod
+    def parse_from_gir(cls, filename):
+        self = cls(None)
+        self.set_passthrough_mode()
+        self._parse_include(filename)
+        parser = self._cachestore.load(filename)
+        self._namespace = parser.get_namespace()
+        del self._includes[self._namespace.name]
+        return self
+
     def _parse_include(self, filename, uninstalled=False):
         parser = None
         if self._cachestore is not None:
diff --git a/tests/Makefile.am b/tests/Makefile.am
index 4ae351fe..20ecc174 100644
--- a/tests/Makefile.am
+++ b/tests/Makefile.am
@@ -1,6 +1,6 @@
 include $(top_srcdir)/common.mk
 
-SUBDIRS = . scanner repository offsets warn
+SUBDIRS = . scanner repository offsets warn doctool
 
 EXTRA_DIST=
 BUILT_SOURCES=
diff --git a/tests/doctool/GIRepository-2.0-expected.xml b/tests/doctool/GIRepository-2.0-expected.xml
new file mode 100644
index 00000000..b4755860
--- /dev/null
+++ b/tests/doctool/GIRepository-2.0-expected.xml
@@ -0,0 +1,1781 @@
+<?xml version="1.0"?>
+<!DOCTYPE refentry PUBLIC "-//OASIS//DTD DocBook XML V4.1.2//EN"
+               "http://www.oasis-open.org/docbook/xml/4.1.2/docbookx.dtd" [
+<!ENTITY % local.common.attrib "xmlns:xi  CDATA  #FIXED 'http://www.w3.org/2003/XInclude'">
+<!ENTITY version SYSTEM "version.xml">
+]>
+<book xml:id="page_GIRepository"
+      xmlns="http://docbook.org/ns/docbook"
+      version="5.0">
+  <title>GIRepository Documentation</title>
+  <chapter xml:id="ch_GIArgInfo">
+    <title>GIArgInfo</title>
+    <refsynopsisdiv id="GIArgInfo.synopsis" role="synopsis">
+      <title role="synopsis.title">Synopsis</title>
+      <synopsis>
+struct               <link linkend="GIArgInfo-struct">GIArgInfo</link>;
+      </synopsis>
+    </refsynopsisdiv>
+    <refsect1 id="giarginfo-details" role="details">
+      <title role="details.title">Details</title>
+      <refsect2 id="GIArgInfo" role="typedef">
+        <title>GIArgInfo</title>
+        <indexterm zone="GIArgInfo">
+          <primary sortas="ArgInfo">GIArgInfo</primary>
+        </indexterm>
+        <programlisting>typedef GIBaseInfo GIArgInfo</programlisting>
+        <para>Represents an argument.</para>
+      </refsect2>
+    </refsect1>
+  </chapter>
+  <chapter xml:id="ch_GICallableInfo">
+    <title>GICallableInfo</title>
+    <refsynopsisdiv id="GICallableInfo.synopsis" role="synopsis">
+      <title role="synopsis.title">Synopsis</title>
+      <synopsis>
+struct               <link linkend="GICallableInfo-struct">GICallableInfo</link>;
+      </synopsis>
+    </refsynopsisdiv>
+    <refsect1 id="gicallableinfo-details" role="details">
+      <title role="details.title">Details</title>
+      <refsect2 id="GICallableInfo" role="typedef">
+        <title>GICallableInfo</title>
+        <indexterm zone="GICallableInfo">
+          <primary sortas="CallableInfo">GICallableInfo</primary>
+        </indexterm>
+        <programlisting>typedef GIBaseInfo GICallableInfo</programlisting>
+        <para>Represents a callable, either #GIFunctionInfo, #GICallbackInfo or
+#GIVFuncInfo.</para>
+      </refsect2>
+    </refsect1>
+  </chapter>
+  <chapter xml:id="ch_GICallbackInfo">
+    <title>GICallbackInfo</title>
+    <refsynopsisdiv id="GICallbackInfo.synopsis" role="synopsis">
+      <title role="synopsis.title">Synopsis</title>
+      <synopsis>
+struct               <link linkend="GICallbackInfo-struct">GICallbackInfo</link>;
+      </synopsis>
+    </refsynopsisdiv>
+    <refsect1 id="gicallbackinfo-details" role="details">
+      <title role="details.title">Details</title>
+      <refsect2 id="GICallbackInfo" role="typedef">
+        <title>GICallbackInfo</title>
+        <indexterm zone="GICallbackInfo">
+          <primary sortas="CallbackInfo">GICallbackInfo</primary>
+        </indexterm>
+        <programlisting>typedef GIBaseInfo GICallbackInfo</programlisting>
+        <para>Represents a callback, eg arguments and return value.</para>
+      </refsect2>
+    </refsect1>
+  </chapter>
+  <chapter xml:id="ch_GIConstantInfo">
+    <title>GIConstantInfo</title>
+    <refsynopsisdiv id="GIConstantInfo.synopsis" role="synopsis">
+      <title role="synopsis.title">Synopsis</title>
+      <synopsis>
+struct               <link linkend="GIConstantInfo-struct">GIConstantInfo</link>;
+      </synopsis>
+    </refsynopsisdiv>
+    <refsect1 id="giconstantinfo-details" role="details">
+      <title role="details.title">Details</title>
+      <refsect2 id="GIConstantInfo" role="typedef">
+        <title>GIConstantInfo</title>
+        <indexterm zone="GIConstantInfo">
+          <primary sortas="ConstantInfo">GIConstantInfo</primary>
+        </indexterm>
+        <programlisting>typedef GIBaseInfo GIConstantInfo</programlisting>
+        <para>Represents a constant.</para>
+      </refsect2>
+    </refsect1>
+  </chapter>
+  <chapter xml:id="ch_GIEnumInfo">
+    <title>GIEnumInfo</title>
+    <refsynopsisdiv id="GIEnumInfo.synopsis" role="synopsis">
+      <title role="synopsis.title">Synopsis</title>
+      <synopsis>
+struct               <link linkend="GIEnumInfo-struct">GIEnumInfo</link>;
+      </synopsis>
+    </refsynopsisdiv>
+    <refsect1 id="gienuminfo-details" role="details">
+      <title role="details.title">Details</title>
+      <refsect2 id="GIEnumInfo" role="typedef">
+        <title>GIEnumInfo</title>
+        <indexterm zone="GIEnumInfo">
+          <primary sortas="EnumInfo">GIEnumInfo</primary>
+        </indexterm>
+        <programlisting>typedef GIBaseInfo GIEnumInfo</programlisting>
+        <para>Represents an enum or a flag.</para>
+      </refsect2>
+    </refsect1>
+  </chapter>
+  <chapter xml:id="ch_GIErrorDomainInfo">
+    <title>GIErrorDomainInfo</title>
+    <refsynopsisdiv id="GIErrorDomainInfo.synopsis" role="synopsis">
+      <title role="synopsis.title">Synopsis</title>
+      <synopsis>
+struct               <link linkend="GIErrorDomainInfo-struct">GIErrorDomainInfo</link>;
+      </synopsis>
+    </refsynopsisdiv>
+    <refsect1 id="gierrordomaininfo-details" role="details">
+      <title role="details.title">Details</title>
+      <refsect2 id="GIErrorDomainInfo" role="typedef">
+        <title>GIErrorDomainInfo</title>
+        <indexterm zone="GIErrorDomainInfo">
+          <primary sortas="ErrorDomainInfo">GIErrorDomainInfo</primary>
+        </indexterm>
+        <programlisting>typedef GIBaseInfo GIErrorDomainInfo</programlisting>
+        <para>Represents a #GError error domain.</para>
+      </refsect2>
+    </refsect1>
+  </chapter>
+  <chapter xml:id="ch_GIFieldInfo">
+    <title>GIFieldInfo</title>
+    <refsynopsisdiv id="GIFieldInfo.synopsis" role="synopsis">
+      <title role="synopsis.title">Synopsis</title>
+      <synopsis>
+struct               <link linkend="GIFieldInfo-struct">GIFieldInfo</link>;
+      </synopsis>
+    </refsynopsisdiv>
+    <refsect1 id="gifieldinfo-details" role="details">
+      <title role="details.title">Details</title>
+      <refsect2 id="GIFieldInfo" role="typedef">
+        <title>GIFieldInfo</title>
+        <indexterm zone="GIFieldInfo">
+          <primary sortas="FieldInfo">GIFieldInfo</primary>
+        </indexterm>
+        <programlisting>typedef GIBaseInfo GIFieldInfo</programlisting>
+        <para>Represents a field of a #GIStructInfo or a #GIUnionInfo.</para>
+      </refsect2>
+    </refsect1>
+  </chapter>
+  <chapter xml:id="ch_GIFunctionInfo">
+    <title>GIFunctionInfo</title>
+    <refsynopsisdiv id="GIFunctionInfo.synopsis" role="synopsis">
+      <title role="synopsis.title">Synopsis</title>
+      <synopsis>
+struct               <link linkend="GIFunctionInfo-struct">GIFunctionInfo</link>;
+      </synopsis>
+    </refsynopsisdiv>
+    <refsect1 id="gifunctioninfo-details" role="details">
+      <title role="details.title">Details</title>
+      <refsect2 id="GIFunctionInfo" role="typedef">
+        <title>GIFunctionInfo</title>
+        <indexterm zone="GIFunctionInfo">
+          <primary sortas="FunctionInfo">GIFunctionInfo</primary>
+        </indexterm>
+        <programlisting>typedef GIBaseInfo GIFunctionInfo</programlisting>
+        <para>Represents a function, eg arguments and return value.</para>
+      </refsect2>
+    </refsect1>
+  </chapter>
+  <chapter xml:id="ch_GIInterfaceInfo">
+    <title>GIInterfaceInfo</title>
+    <refsynopsisdiv id="GIInterfaceInfo.synopsis" role="synopsis">
+      <title role="synopsis.title">Synopsis</title>
+      <synopsis>
+struct               <link linkend="GIInterfaceInfo-struct">GIInterfaceInfo</link>;
+      </synopsis>
+    </refsynopsisdiv>
+    <refsect1 id="giinterfaceinfo-details" role="details">
+      <title role="details.title">Details</title>
+      <refsect2 id="GIInterfaceInfo" role="typedef">
+        <title>GIInterfaceInfo</title>
+        <indexterm zone="GIInterfaceInfo">
+          <primary sortas="InterfaceInfo">GIInterfaceInfo</primary>
+        </indexterm>
+        <programlisting>typedef GIBaseInfo GIInterfaceInfo</programlisting>
+        <para>Represents an interface.</para>
+      </refsect2>
+    </refsect1>
+  </chapter>
+  <chapter xml:id="ch_GIObjectInfo">
+    <title>GIObjectInfo</title>
+    <refsynopsisdiv id="GIObjectInfo.synopsis" role="synopsis">
+      <title role="synopsis.title">Synopsis</title>
+      <synopsis>
+struct               <link linkend="GIObjectInfo-struct">GIObjectInfo</link>;
+      </synopsis>
+    </refsynopsisdiv>
+    <refsect1 id="giobjectinfo-details" role="details">
+      <title role="details.title">Details</title>
+      <refsect2 id="GIObjectInfo" role="typedef">
+        <title>GIObjectInfo</title>
+        <indexterm zone="GIObjectInfo">
+          <primary sortas="ObjectInfo">GIObjectInfo</primary>
+        </indexterm>
+        <programlisting>typedef GIBaseInfo GIObjectInfo</programlisting>
+        <para>Represents an object.</para>
+      </refsect2>
+    </refsect1>
+  </chapter>
+  <chapter xml:id="ch_GIPropertyInfo">
+    <title>GIPropertyInfo</title>
+    <refsynopsisdiv id="GIPropertyInfo.synopsis" role="synopsis">
+      <title role="synopsis.title">Synopsis</title>
+      <synopsis>
+struct               <link linkend="GIPropertyInfo-struct">GIPropertyInfo</link>;
+      </synopsis>
+    </refsynopsisdiv>
+    <refsect1 id="gipropertyinfo-details" role="details">
+      <title role="details.title">Details</title>
+      <refsect2 id="GIPropertyInfo" role="typedef">
+        <title>GIPropertyInfo</title>
+        <indexterm zone="GIPropertyInfo">
+          <primary sortas="PropertyInfo">GIPropertyInfo</primary>
+        </indexterm>
+        <programlisting>typedef GIBaseInfo GIPropertyInfo</programlisting>
+        <para>Represents a property of a #GIObjectInfo or a #GIInterfaceInfo.</para>
+      </refsect2>
+    </refsect1>
+  </chapter>
+  <chapter xml:id="ch_GIRegisteredTypeInfo">
+    <title>GIRegisteredTypeInfo</title>
+    <refsynopsisdiv id="GIRegisteredTypeInfo.synopsis" role="synopsis">
+      <title role="synopsis.title">Synopsis</title>
+      <synopsis>
+struct               <link linkend="GIRegisteredTypeInfo-struct">GIRegisteredTypeInfo</link>;
+      </synopsis>
+    </refsynopsisdiv>
+    <refsect1 id="giregisteredtypeinfo-details" role="details">
+      <title role="details.title">Details</title>
+      <refsect2 id="GIRegisteredTypeInfo" role="typedef">
+        <title>GIRegisteredTypeInfo</title>
+        <indexterm zone="GIRegisteredTypeInfo">
+          <primary sortas="RegisteredTypeInfo">GIRegisteredTypeInfo</primary>
+        </indexterm>
+        <programlisting>typedef GIBaseInfo GIRegisteredTypeInfo</programlisting>
+        <para>Represent a registered type.</para>
+      </refsect2>
+    </refsect1>
+  </chapter>
+  <chapter xml:id="ch_GISignalInfo">
+    <title>GISignalInfo</title>
+    <refsynopsisdiv id="GISignalInfo.synopsis" role="synopsis">
+      <title role="synopsis.title">Synopsis</title>
+      <synopsis>
+struct               <link linkend="GISignalInfo-struct">GISignalInfo</link>;
+      </synopsis>
+    </refsynopsisdiv>
+    <refsect1 id="gisignalinfo-details" role="details">
+      <title role="details.title">Details</title>
+      <refsect2 id="GISignalInfo" role="typedef">
+        <title>GISignalInfo</title>
+        <indexterm zone="GISignalInfo">
+          <primary sortas="SignalInfo">GISignalInfo</primary>
+        </indexterm>
+        <programlisting>typedef GIBaseInfo GISignalInfo</programlisting>
+        <para>Represents a signal.</para>
+      </refsect2>
+    </refsect1>
+  </chapter>
+  <chapter xml:id="ch_GIStructInfo">
+    <title>GIStructInfo</title>
+    <refsynopsisdiv id="GIStructInfo.synopsis" role="synopsis">
+      <title role="synopsis.title">Synopsis</title>
+      <synopsis>
+struct               <link linkend="GIStructInfo-struct">GIStructInfo</link>;
+      </synopsis>
+    </refsynopsisdiv>
+    <refsect1 id="gistructinfo-details" role="details">
+      <title role="details.title">Details</title>
+      <refsect2 id="GIStructInfo" role="typedef">
+        <title>GIStructInfo</title>
+        <indexterm zone="GIStructInfo">
+          <primary sortas="StructInfo">GIStructInfo</primary>
+        </indexterm>
+        <programlisting>typedef GIBaseInfo GIStructInfo</programlisting>
+        <para>Represents a struct.</para>
+      </refsect2>
+    </refsect1>
+  </chapter>
+  <chapter xml:id="ch_GITypeInfo">
+    <title>GITypeInfo</title>
+    <refsynopsisdiv id="GITypeInfo.synopsis" role="synopsis">
+      <title role="synopsis.title">Synopsis</title>
+      <synopsis>
+struct               <link linkend="GITypeInfo-struct">GITypeInfo</link>;
+      </synopsis>
+    </refsynopsisdiv>
+    <refsect1 id="gitypeinfo-details" role="details">
+      <title role="details.title">Details</title>
+      <refsect2 id="GITypeInfo" role="typedef">
+        <title>GITypeInfo</title>
+        <indexterm zone="GITypeInfo">
+          <primary sortas="TypeInfo">GITypeInfo</primary>
+        </indexterm>
+        <programlisting>typedef GIBaseInfo GITypeInfo</programlisting>
+        <para>Represents type information, direction, transfer etc.</para>
+      </refsect2>
+    </refsect1>
+  </chapter>
+  <chapter xml:id="ch_GIUnionInfo">
+    <title>GIUnionInfo</title>
+    <refsynopsisdiv id="GIUnionInfo.synopsis" role="synopsis">
+      <title role="synopsis.title">Synopsis</title>
+      <synopsis>
+struct               <link linkend="GIUnionInfo-struct">GIUnionInfo</link>;
+      </synopsis>
+    </refsynopsisdiv>
+    <refsect1 id="giunioninfo-details" role="details">
+      <title role="details.title">Details</title>
+      <refsect2 id="GIUnionInfo" role="typedef">
+        <title>GIUnionInfo</title>
+        <indexterm zone="GIUnionInfo">
+          <primary sortas="UnionInfo">GIUnionInfo</primary>
+        </indexterm>
+        <programlisting>typedef GIBaseInfo GIUnionInfo</programlisting>
+        <para>Represents a union.</para>
+      </refsect2>
+    </refsect1>
+  </chapter>
+  <chapter xml:id="ch_GIVFuncInfo">
+    <title>GIVFuncInfo</title>
+    <refsynopsisdiv id="GIVFuncInfo.synopsis" role="synopsis">
+      <title role="synopsis.title">Synopsis</title>
+      <synopsis>
+struct               <link linkend="GIVFuncInfo-struct">GIVFuncInfo</link>;
+      </synopsis>
+    </refsynopsisdiv>
+    <refsect1 id="givfuncinfo-details" role="details">
+      <title role="details.title">Details</title>
+      <refsect2 id="GIVFuncInfo" role="typedef">
+        <title>GIVFuncInfo</title>
+        <indexterm zone="GIVFuncInfo">
+          <primary sortas="VFuncInfo">GIVFuncInfo</primary>
+        </indexterm>
+        <programlisting>typedef GIBaseInfo GIVFuncInfo</programlisting>
+        <para>Represents a virtual function.</para>
+      </refsect2>
+    </refsect1>
+  </chapter>
+  <chapter xml:id="ch_GIValueInfo">
+    <title>GIValueInfo</title>
+    <refsynopsisdiv id="GIValueInfo.synopsis" role="synopsis">
+      <title role="synopsis.title">Synopsis</title>
+      <synopsis>
+struct               <link linkend="GIValueInfo-struct">GIValueInfo</link>;
+      </synopsis>
+    </refsynopsisdiv>
+    <refsect1 id="givalueinfo-details" role="details">
+      <title role="details.title">Details</title>
+      <refsect2 id="GIValueInfo" role="typedef">
+        <title>GIValueInfo</title>
+        <indexterm zone="GIValueInfo">
+          <primary sortas="ValueInfo">GIValueInfo</primary>
+        </indexterm>
+        <programlisting>typedef GIBaseInfo GIValueInfo</programlisting>
+        <para>Represents a enum value of a #GIEnumInfo.</para>
+      </refsect2>
+    </refsect1>
+  </chapter>
+  <chapter xml:id="ch_GIAttributeIter">
+    <title>GIAttributeIter</title>
+    <refsynopsisdiv id="GIAttributeIter.synopsis" role="synopsis">
+      <title role="synopsis.title">Synopsis</title>
+      <anchor id="GIAttributeIter"/>
+      <synopsis>
+struct               <link linkend="GIAttributeIter-struct">GIAttributeIter</link>;
+      </synopsis>
+    </refsynopsisdiv>
+    <refsect1 id="giattributeiter-details" role="details">
+      <title role="details.title">Details</title>
+      <refsect2 id="GIAttributeIter-struct" role="struct">
+        <title>struct GIAttributeIter</title>
+        <indexterm zone="GIAttributeIter-struct">
+          <primary sortas="AttributeIter">GIAttributeIter</primary>
+        </indexterm>
+        <programlisting>struct GIAttributeIter;</programlisting>
+      </refsect2>
+    </refsect1>
+  </chapter>
+  <chapter xml:id="ch_GIBaseInfo">
+    <title>GIBaseInfo</title>
+    <refsynopsisdiv id="GIBaseInfo.synopsis" role="synopsis">
+      <title role="synopsis.title">Synopsis</title>
+      <anchor id="GIBaseInfo"/>
+      <synopsis>
+struct               <link linkend="GIBaseInfo-struct">GIBaseInfo</link>;
+<link linkend="gboolean"><returnvalue>gboolean</returnvalue></link>            <link linkend="g-base-info-equal">g_base_info_equal</link>                       (<parameter><link linkend="GIBaseInfo"><type>GIBaseInfo</type></link> *baseinfo, </parameter>
+                                                             <parameter><link linkend="GIBaseInfo"><type>GIBaseInfo</type></link> *info2</parameter>);
+<link linkend="gchar"><returnvalue>gchar</returnvalue></link> *              <link linkend="g-base-info-get-attribute">g_base_info_get_attribute</link>               (<parameter><link linkend="GIBaseInfo"><type>GIBaseInfo</type></link> *baseinfo, </parameter>
+                                                             <parameter><link linkend="gchar"><type>gchar</type></link> *name</parameter>);
+<link linkend="GIBaseInfo"><returnvalue>GIBaseInfo</returnvalue></link> *         <link linkend="g-base-info-get-container">g_base_info_get_container</link>               (<parameter><link linkend="GIBaseInfo"><type>GIBaseInfo</type></link> *baseinfo</parameter>);
+<link linkend="gchar"><returnvalue>gchar</returnvalue></link> *              <link linkend="g-base-info-get-name">g_base_info_get_name</link>                    (<parameter><link linkend="GIBaseInfo"><type>GIBaseInfo</type></link> *baseinfo</parameter>);
+<link linkend="gchar"><returnvalue>gchar</returnvalue></link> *              <link linkend="g-base-info-get-namespace">g_base_info_get_namespace</link>               (<parameter><link linkend="GIBaseInfo"><type>GIBaseInfo</type></link> *baseinfo</parameter>);
+<link linkend="GITypelib"><returnvalue>GITypelib</returnvalue></link> *          <link linkend="g-base-info-get-typelib">g_base_info_get_typelib</link>                 (<parameter><link linkend="GIBaseInfo"><type>GIBaseInfo</type></link> *baseinfo</parameter>);
+<link linkend="gboolean"><returnvalue>gboolean</returnvalue></link>            <link linkend="g-base-info-is-deprecated">g_base_info_is_deprecated</link>               (<parameter><link linkend="GIBaseInfo"><type>GIBaseInfo</type></link> *baseinfo</parameter>);
+<link linkend="gboolean"><returnvalue>gboolean</returnvalue></link>            <link linkend="g-base-info-iterate-attributes">g_base_info_iterate_attributes</link>          (<parameter><link linkend="GIBaseInfo"><type>GIBaseInfo</type></link> *baseinfo, </parameter>
+                                                             <parameter><link linkend="GIAttributeIter"><type>GIAttributeIter</type></link> *iterator, </parameter>
+                                                             <parameter><link linkend="char"><type>char</type></link> *name, </parameter>
+                                                             <parameter><link linkend="char"><type>char</type></link> *value</parameter>);
+<link linkend="GIBaseInfo"><returnvalue>GIBaseInfo</returnvalue></link> *         <link linkend="g-base-info-ref">g_base_info_ref</link>                         (<parameter><link linkend="GIBaseInfo"><type>GIBaseInfo</type></link> *baseinfo</parameter>);
+<link linkend="void"><returnvalue>void</returnvalue></link>                <link linkend="g-base-info-unref">g_base_info_unref</link>                       (<parameter><link linkend="GIBaseInfo"><type>GIBaseInfo</type></link> *baseinfo</parameter>);
+      </synopsis>
+    </refsynopsisdiv>
+    <refsect1 id="gibaseinfo-details" role="details">
+      <title role="details.title">Details</title>
+      <refsect2 id="GIBaseInfo-struct" role="struct">
+        <title>struct GIBaseInfo</title>
+        <indexterm zone="GIBaseInfo-struct">
+          <primary sortas="BaseInfo">GIBaseInfo</primary>
+        </indexterm>
+        <programlisting>struct GIBaseInfo;</programlisting>
+      </refsect2>
+      <refsect2 id="g-base-info-equal" role="function">
+        <title>g_base_info_equal ()</title>
+        <indexterm zone="g-base-info-equal">
+          <primary>equal</primary>
+        </indexterm>
+        <programlisting>
+<link linkend="gboolean"><returnvalue>gboolean</returnvalue></link>            g_base_info_equal                       (<parameter><link linkend="GIBaseInfo"><type>GIBaseInfo</type></link> *baseinfo, </parameter>
+                                                             <parameter><link linkend="GIBaseInfo"><type>GIBaseInfo</type></link> *info2</parameter>);
+        </programlisting>
+        <para>Compare two #GIBaseInfo.
+Using pointer comparison is not practical since many functions return
+different instances of #GIBaseInfo that refers to the same part of the
+TypeLib; use this function instead to do #GIBaseInfo comparisons.</para>
+        <variablelist role="params">
+          <varlistentry>
+            <term>
+<parameter>baseinfo</parameter>&#xA0;:            </term>
+            <listitem>
+              <simpara>
+                instance
+              </simpara>
+            </listitem>
+          </varlistentry>
+          <varlistentry>
+            <term>
+<parameter>info2</parameter>&#xA0;:            </term>
+            <listitem>
+              <simpara>
+                a #GIBaseInfo
+              </simpara>
+            </listitem>
+          </varlistentry>
+          <varlistentry>
+            <term>
+<parameter>Returns</parameter>&#xA0;:            </term>
+            <listitem>
+              <simpara>
+                %TRUE if and only if @info1 equals @info2.
+              </simpara>
+            </listitem>
+          </varlistentry>
+        </variablelist>
+      </refsect2>
+      <refsect2 id="g-base-info-get-attribute" role="function">
+        <title>g_base_info_get_attribute ()</title>
+        <indexterm zone="g-base-info-get-attribute">
+          <primary>get_attribute</primary>
+        </indexterm>
+        <programlisting>
+<link linkend="gchar"><returnvalue>gchar</returnvalue></link> *              g_base_info_get_attribute               (<parameter><link linkend="GIBaseInfo"><type>GIBaseInfo</type></link> *baseinfo, </parameter>
+                                                             <parameter><link linkend="gchar"><type>gchar</type></link> *name</parameter>);
+        </programlisting>
+        <para>Retrieve an arbitrary attribute associated with this node.</para>
+        <variablelist role="params">
+          <varlistentry>
+            <term>
+<parameter>baseinfo</parameter>&#xA0;:            </term>
+            <listitem>
+              <simpara>
+                instance
+              </simpara>
+            </listitem>
+          </varlistentry>
+          <varlistentry>
+            <term>
+<parameter>name</parameter>&#xA0;:            </term>
+            <listitem>
+              <simpara>
+                a freeform string naming an attribute
+              </simpara>
+            </listitem>
+          </varlistentry>
+          <varlistentry>
+            <term>
+<parameter>Returns</parameter>&#xA0;:            </term>
+            <listitem>
+              <simpara>
+                The value of the attribute, or %NULL if no such attribute exists
+              </simpara>
+            </listitem>
+          </varlistentry>
+        </variablelist>
+      </refsect2>
+      <refsect2 id="g-base-info-get-container" role="function">
+        <title>g_base_info_get_container ()</title>
+        <indexterm zone="g-base-info-get-container">
+          <primary>get_container</primary>
+        </indexterm>
+        <programlisting>
+<link linkend="GIBaseInfo"><returnvalue>GIBaseInfo</returnvalue></link> *         g_base_info_get_container               (<parameter><link linkend="GIBaseInfo"><type>GIBaseInfo</type></link> *baseinfo</parameter>);
+        </programlisting>
+        <para>Obtain the container of the @info. The container is the parent
+GIBaseInfo. For instance, the parent of a #GIFunctionInfo is an
+#GIObjectInfo or #GIInterfaceInfo.</para>
+        <variablelist role="params">
+          <varlistentry>
+            <term>
+<parameter>baseinfo</parameter>&#xA0;:            </term>
+            <listitem>
+              <simpara>
+                instance
+              </simpara>
+            </listitem>
+          </varlistentry>
+          <varlistentry>
+            <term>
+<parameter>Returns</parameter>&#xA0;:            </term>
+            <listitem>
+              <simpara>
+                the container
+              </simpara>
+            </listitem>
+          </varlistentry>
+        </variablelist>
+      </refsect2>
+      <refsect2 id="g-base-info-get-name" role="function">
+        <title>g_base_info_get_name ()</title>
+        <indexterm zone="g-base-info-get-name">
+          <primary>get_name</primary>
+        </indexterm>
+        <programlisting>
+<link linkend="gchar"><returnvalue>gchar</returnvalue></link> *              g_base_info_get_name                    (<parameter><link linkend="GIBaseInfo"><type>GIBaseInfo</type></link> *baseinfo</parameter>);
+        </programlisting>
+        <para>Obtain the name of the @info. What the name represents depends on
+the #GIInfoType of the @info. For instance for #GIFunctionInfo it is
+the name of the function.</para>
+        <variablelist role="params">
+          <varlistentry>
+            <term>
+<parameter>baseinfo</parameter>&#xA0;:            </term>
+            <listitem>
+              <simpara>
+                instance
+              </simpara>
+            </listitem>
+          </varlistentry>
+          <varlistentry>
+            <term>
+<parameter>Returns</parameter>&#xA0;:            </term>
+            <listitem>
+              <simpara>
+                the name of @info or %NULL if it lacks a name.
+              </simpara>
+            </listitem>
+          </varlistentry>
+        </variablelist>
+      </refsect2>
+      <refsect2 id="g-base-info-get-namespace" role="function">
+        <title>g_base_info_get_namespace ()</title>
+        <indexterm zone="g-base-info-get-namespace">
+          <primary>get_namespace</primary>
+        </indexterm>
+        <programlisting>
+<link linkend="gchar"><returnvalue>gchar</returnvalue></link> *              g_base_info_get_namespace               (<parameter><link linkend="GIBaseInfo"><type>GIBaseInfo</type></link> *baseinfo</parameter>);
+        </programlisting>
+        <para>Obtain the namespace of @info.</para>
+        <variablelist role="params">
+          <varlistentry>
+            <term>
+<parameter>baseinfo</parameter>&#xA0;:            </term>
+            <listitem>
+              <simpara>
+                instance
+              </simpara>
+            </listitem>
+          </varlistentry>
+          <varlistentry>
+            <term>
+<parameter>Returns</parameter>&#xA0;:            </term>
+            <listitem>
+              <simpara>
+                the namespace
+              </simpara>
+            </listitem>
+          </varlistentry>
+        </variablelist>
+      </refsect2>
+      <refsect2 id="g-base-info-get-typelib" role="function">
+        <title>g_base_info_get_typelib ()</title>
+        <indexterm zone="g-base-info-get-typelib">
+          <primary>get_typelib</primary>
+        </indexterm>
+        <programlisting>
+<link linkend="GITypelib"><returnvalue>GITypelib</returnvalue></link> *          g_base_info_get_typelib                 (<parameter><link linkend="GIBaseInfo"><type>GIBaseInfo</type></link> *baseinfo</parameter>);
+        </programlisting>
+        <para>Obtain the typelib this @info belongs to</para>
+        <variablelist role="params">
+          <varlistentry>
+            <term>
+<parameter>baseinfo</parameter>&#xA0;:            </term>
+            <listitem>
+              <simpara>
+                instance
+              </simpara>
+            </listitem>
+          </varlistentry>
+          <varlistentry>
+            <term>
+<parameter>Returns</parameter>&#xA0;:            </term>
+            <listitem>
+              <simpara>
+                the typelib.
+              </simpara>
+            </listitem>
+          </varlistentry>
+        </variablelist>
+      </refsect2>
+      <refsect2 id="g-base-info-is-deprecated" role="function">
+        <title>g_base_info_is_deprecated ()</title>
+        <indexterm zone="g-base-info-is-deprecated">
+          <primary>is_deprecated</primary>
+        </indexterm>
+        <programlisting>
+<link linkend="gboolean"><returnvalue>gboolean</returnvalue></link>            g_base_info_is_deprecated               (<parameter><link linkend="GIBaseInfo"><type>GIBaseInfo</type></link> *baseinfo</parameter>);
+        </programlisting>
+        <para>Obtain whether the @info is represents a metadata which is
+deprecated or not.</para>
+        <variablelist role="params">
+          <varlistentry>
+            <term>
+<parameter>baseinfo</parameter>&#xA0;:            </term>
+            <listitem>
+              <simpara>
+                instance
+              </simpara>
+            </listitem>
+          </varlistentry>
+          <varlistentry>
+            <term>
+<parameter>Returns</parameter>&#xA0;:            </term>
+            <listitem>
+              <simpara>
+                %TRUE if deprecated
+              </simpara>
+            </listitem>
+          </varlistentry>
+        </variablelist>
+      </refsect2>
+      <refsect2 id="g-base-info-iterate-attributes" role="function">
+        <title>g_base_info_iterate_attributes ()</title>
+        <indexterm zone="g-base-info-iterate-attributes">
+          <primary>iterate_attributes</primary>
+        </indexterm>
+        <programlisting>
+<link linkend="gboolean"><returnvalue>gboolean</returnvalue></link>            g_base_info_iterate_attributes          (<parameter><link linkend="GIBaseInfo"><type>GIBaseInfo</type></link> *baseinfo, </parameter>
+                                                             <parameter><link linkend="GIAttributeIter"><type>GIAttributeIter</type></link> *iterator, </parameter>
+                                                             <parameter><link linkend="char"><type>char</type></link> *name, </parameter>
+                                                             <parameter><link linkend="char"><type>char</type></link> *value</parameter>);
+        </programlisting>
+        <para>Iterate over all attributes associated with this node.  The iterator
+structure is typically stack allocated, and must have its first
+member initialized to %NULL.
+Both the @name and @value should be treated as constants
+and must not be freed.
+&lt;example&gt;
+&lt;title&gt;Iterating over attributes&lt;/title&gt;
+&lt;programlisting&gt;
+void
+print_attributes (GIBaseInfo *info)
+{
+GIAttributeIter iter = { 0, };
+char *name;
+char *value;
+while (g_base_info_iterate_attributes (info, &amp;iter, &amp;name, &amp;value))
+{
+}
+}
+&lt;/programlisting&gt;
+&lt;/example&gt;</para>
+        <variablelist role="params">
+          <varlistentry>
+            <term>
+<parameter>baseinfo</parameter>&#xA0;:            </term>
+            <listitem>
+              <simpara>
+                instance
+              </simpara>
+            </listitem>
+          </varlistentry>
+          <varlistentry>
+            <term>
+<parameter>iterator</parameter>&#xA0;:            </term>
+            <listitem>
+              <simpara>
+                a #GIAttributeIter structure, must be initialized; see below
+              </simpara>
+            </listitem>
+          </varlistentry>
+          <varlistentry>
+            <term>
+<parameter>name</parameter>&#xA0;:            </term>
+            <listitem>
+              <simpara>
+                Returned name, must not be freed
+              </simpara>
+            </listitem>
+          </varlistentry>
+          <varlistentry>
+            <term>
+<parameter>value</parameter>&#xA0;:            </term>
+            <listitem>
+              <simpara>
+                Returned name, must not be freed
+              </simpara>
+            </listitem>
+          </varlistentry>
+          <varlistentry>
+            <term>
+<parameter>Returns</parameter>&#xA0;:            </term>
+            <listitem>
+              <simpara>
+                %TRUE if there are more attributes
+              </simpara>
+            </listitem>
+          </varlistentry>
+        </variablelist>
+      </refsect2>
+      <refsect2 id="g-base-info-ref" role="function">
+        <title>g_base_info_ref ()</title>
+        <indexterm zone="g-base-info-ref">
+          <primary>ref</primary>
+        </indexterm>
+        <programlisting>
+<link linkend="GIBaseInfo"><returnvalue>GIBaseInfo</returnvalue></link> *         g_base_info_ref                         (<parameter><link linkend="GIBaseInfo"><type>GIBaseInfo</type></link> *baseinfo</parameter>);
+        </programlisting>
+        <para>Increases the reference count of @info.</para>
+        <variablelist role="params">
+          <varlistentry>
+            <term>
+<parameter>baseinfo</parameter>&#xA0;:            </term>
+            <listitem>
+              <simpara>
+                instance
+              </simpara>
+            </listitem>
+          </varlistentry>
+          <varlistentry>
+            <term>
+<parameter>Returns</parameter>&#xA0;:            </term>
+            <listitem>
+              <simpara>
+                the same @info.
+                <emphasis role="annotation">
+[transfer full]                </emphasis>
+              </simpara>
+            </listitem>
+          </varlistentry>
+        </variablelist>
+      </refsect2>
+      <refsect2 id="g-base-info-unref" role="function">
+        <title>g_base_info_unref ()</title>
+        <indexterm zone="g-base-info-unref">
+          <primary>unref</primary>
+        </indexterm>
+        <programlisting>
+<link linkend="void"><returnvalue>void</returnvalue></link>                g_base_info_unref                       (<parameter><link linkend="GIBaseInfo"><type>GIBaseInfo</type></link> *baseinfo</parameter>);
+        </programlisting>
+        <para>Decreases the reference count of @info. When its reference count
+drops to 0, the info is freed.</para>
+        <variablelist role="params">
+          <varlistentry>
+            <term>
+<parameter>baseinfo</parameter>&#xA0;:            </term>
+            <listitem>
+              <simpara>
+                instance
+              </simpara>
+            </listitem>
+          </varlistentry>
+          <varlistentry>
+            <term>
+<parameter>Returns</parameter>            </term>
+          </varlistentry>
+        </variablelist>
+      </refsect2>
+    </refsect1>
+  </chapter>
+  <chapter xml:id="ch_GIRepository">
+    <title>GIRepository</title>
+    <refsynopsisdiv id="GIRepository.synopsis" role="synopsis">
+      <title role="synopsis.title">Synopsis</title>
+      <anchor id="GIRepository"/>
+      <synopsis>
+struct               <link linkend="GIRepository-struct">GIRepository</link>;
+<link linkend="GList"><returnvalue>GList</returnvalue></link> *              <link linkend="g-irepository-enumerate-versions">g_irepository_enumerate_versions</link>        (<parameter><link linkend="GIRepository"><type>GIRepository</type></link> *repository, </parameter>
+                                                             <parameter><link linkend="gchar"><type>gchar</type></link> *namespace_</parameter>);
+<link linkend="GIBaseInfo"><returnvalue>GIBaseInfo</returnvalue></link> *         <link linkend="g-irepository-find-by-gtype">g_irepository_find_by_gtype</link>             (<parameter><link linkend="GIRepository"><type>GIRepository</type></link> *repository, </parameter>
+                                                             <parameter><link linkend="GType"><type>GType</type></link> gtype</parameter>);
+<link linkend="GIBaseInfo"><returnvalue>GIBaseInfo</returnvalue></link> *         <link linkend="g-irepository-find-by-name">g_irepository_find_by_name</link>              (<parameter><link linkend="GIRepository"><type>GIRepository</type></link> *repository, </parameter>
+                                                             <parameter><link linkend="gchar"><type>gchar</type></link> *namespace_, </parameter>
+                                                             <parameter><link linkend="gchar"><type>gchar</type></link> *name</parameter>);
+<link linkend="gchar"><returnvalue>gchar</returnvalue></link> *              <link linkend="g-irepository-get-c-prefix">g_irepository_get_c_prefix</link>              (<parameter><link linkend="GIRepository"><type>GIRepository</type></link> *repository, </parameter>
+                                                             <parameter><link linkend="gchar"><type>gchar</type></link> *namespace_</parameter>);
+<link linkend="gchar"><returnvalue>gchar</returnvalue></link> *             <link linkend="g-irepository-get-dependencies">g_irepository_get_dependencies</link>          (<parameter><link linkend="GIRepository"><type>GIRepository</type></link> *repository, </parameter>
+                                                             <parameter><link linkend="gchar"><type>gchar</type></link> *namespace_</parameter>);
+<link linkend="GIBaseInfo"><returnvalue>GIBaseInfo</returnvalue></link> *         <link linkend="g-irepository-get-info">g_irepository_get_info</link>                  (<parameter><link linkend="GIRepository"><type>GIRepository</type></link> *repository, </parameter>
+                                                             <parameter><link linkend="gchar"><type>gchar</type></link> *namespace_, </parameter>
+                                                             <parameter><link linkend="gint"><type>gint</type></link> index</parameter>);
+<link linkend="gchar"><returnvalue>gchar</returnvalue></link> *             <link linkend="g-irepository-get-loaded-namespaces">g_irepository_get_loaded_namespaces</link>     (<parameter><link linkend="GIRepository"><type>GIRepository</type></link> *repository</parameter>);
+<link linkend="gint"><returnvalue>gint</returnvalue></link>                <link linkend="g-irepository-get-n-infos">g_irepository_get_n_infos</link>               (<parameter><link linkend="GIRepository"><type>GIRepository</type></link> *repository, </parameter>
+                                                             <parameter><link linkend="gchar"><type>gchar</type></link> *namespace_</parameter>);
+<link linkend="gchar"><returnvalue>gchar</returnvalue></link> *              <link linkend="g-irepository-get-shared-library">g_irepository_get_shared_library</link>        (<parameter><link linkend="GIRepository"><type>GIRepository</type></link> *repository, </parameter>
+                                                             <parameter><link linkend="gchar"><type>gchar</type></link> *namespace_</parameter>);
+<link linkend="gchar"><returnvalue>gchar</returnvalue></link> *              <link linkend="g-irepository-get-typelib-path">g_irepository_get_typelib_path</link>          (<parameter><link linkend="GIRepository"><type>GIRepository</type></link> *repository, </parameter>
+                                                             <parameter><link linkend="gchar"><type>gchar</type></link> *namespace_</parameter>);
+<link linkend="gchar"><returnvalue>gchar</returnvalue></link> *              <link linkend="g-irepository-get-version">g_irepository_get_version</link>               (<parameter><link linkend="GIRepository"><type>GIRepository</type></link> *repository, </parameter>
+                                                             <parameter><link linkend="gchar"><type>gchar</type></link> *namespace_</parameter>);
+<link linkend="gboolean"><returnvalue>gboolean</returnvalue></link>            <link linkend="g-irepository-is-registered">g_irepository_is_registered</link>             (<parameter><link linkend="GIRepository"><type>GIRepository</type></link> *repository, </parameter>
+                                                             <parameter><link linkend="gchar"><type>gchar</type></link> *namespace_, </parameter>
+                                                             <parameter><link linkend="gchar"><type>gchar</type></link> *version</parameter>);
+<link linkend="char"><returnvalue>char</returnvalue></link> *               <link linkend="g-irepository-load-typelib">g_irepository_load_typelib</link>              (<parameter><link linkend="GIRepository"><type>GIRepository</type></link> *repository, </parameter>
+                                                             <parameter><link linkend="GITypelib"><type>GITypelib</type></link> *typelib, </parameter>
+                                                             <parameter><link linkend="GIRepositoryLoadFlags"><type>GIRepositoryLoadFlags</type></link> flags</parameter>);
+<link linkend="GITypelib"><returnvalue>GITypelib</returnvalue></link> *          <link linkend="g-irepository-require">g_irepository_require</link>                   (<parameter><link linkend="GIRepository"><type>GIRepository</type></link> *repository, </parameter>
+                                                             <parameter><link linkend="gchar"><type>gchar</type></link> *namespace_, </parameter>
+                                                             <parameter><link linkend="gchar"><type>gchar</type></link> *version, </parameter>
+                                                             <parameter><link linkend="GIRepositoryLoadFlags"><type>GIRepositoryLoadFlags</type></link> flags</parameter>);
+<link linkend="GITypelib"><returnvalue>GITypelib</returnvalue></link> *          <link linkend="g-irepository-require-private">g_irepository_require_private</link>           (<parameter><link linkend="GIRepository"><type>GIRepository</type></link> *repository, </parameter>
+                                                             <parameter><link linkend="gchar"><type>gchar</type></link> *typelib_dir, </parameter>
+                                                             <parameter><link linkend="gchar"><type>gchar</type></link> *namespace_, </parameter>
+                                                             <parameter><link linkend="gchar"><type>gchar</type></link> *version, </parameter>
+                                                             <parameter><link linkend="GIRepositoryLoadFlags"><type>GIRepositoryLoadFlags</type></link> flags</parameter>);
+      </synopsis>
+    </refsynopsisdiv>
+    <refsect1 id="GIRepository.object-hierarchy" role="object_hierarchy">
+      <title role="object_hierarchy.title">Object Hierarchy</title>
+      <synopsis>
+  GObject
+   +----GIRepository      </synopsis>
+    </refsect1>
+    <refsect1 id="girepository-details" role="details">
+      <title role="details.title">Details</title>
+      <refsect2 id="GIRepository-struct" role="struct">
+        <title>struct GIRepository</title>
+        <indexterm zone="GIRepository-struct">
+          <primary sortas="Repository">GIRepository</primary>
+        </indexterm>
+        <programlisting>struct GIRepository;</programlisting>
+      </refsect2>
+      <refsect2 id="g-irepository-enumerate-versions" role="function">
+        <title>g_irepository_enumerate_versions ()</title>
+        <indexterm zone="g-irepository-enumerate-versions">
+          <primary>enumerate_versions</primary>
+        </indexterm>
+        <programlisting>
+<link linkend="GList"><returnvalue>GList</returnvalue></link> *              g_irepository_enumerate_versions        (<parameter><link linkend="GIRepository"><type>GIRepository</type></link> *repository, </parameter>
+                                                             <parameter><link linkend="gchar"><type>gchar</type></link> *namespace_</parameter>);
+        </programlisting>
+        <para>Obtain an unordered list of versions (either currently loaded or
+available) for @namespace_ in this @repository.</para>
+        <variablelist role="params">
+          <varlistentry>
+            <term>
+<parameter>repository</parameter>&#xA0;:            </term>
+            <listitem>
+              <simpara>
+                instance
+              </simpara>
+            </listitem>
+          </varlistentry>
+          <varlistentry>
+            <term>
+<parameter>namespace_</parameter>&#xA0;:            </term>
+            <listitem>
+              <simpara>
+                GI namespace, e.g. "Gtk"
+              </simpara>
+            </listitem>
+          </varlistentry>
+          <varlistentry>
+            <term>
+<parameter>Returns</parameter>&#xA0;:            </term>
+            <listitem>
+              <simpara>
+                the array of versions.
+                <emphasis role="annotation">
+[element-type utf8][transfer full]                </emphasis>
+              </simpara>
+            </listitem>
+          </varlistentry>
+        </variablelist>
+      </refsect2>
+      <refsect2 id="g-irepository-find-by-gtype" role="function">
+        <title>g_irepository_find_by_gtype ()</title>
+        <indexterm zone="g-irepository-find-by-gtype">
+          <primary>find_by_gtype</primary>
+        </indexterm>
+        <programlisting>
+<link linkend="GIBaseInfo"><returnvalue>GIBaseInfo</returnvalue></link> *         g_irepository_find_by_gtype             (<parameter><link linkend="GIRepository"><type>GIRepository</type></link> *repository, </parameter>
+                                                             <parameter><link linkend="GType"><type>GType</type></link> gtype</parameter>);
+        </programlisting>
+        <para>Searches all loaded namespaces for a particular #GType.  Note that
+in order to locate the metadata, the namespace corresponding to
+the type must first have been loaded.  There is currently no
+mechanism for determining the namespace which corresponds to an
+arbitrary GType - thus, this function will operate most reliably
+when you know the GType to originate from be from a loaded namespace.</para>
+        <variablelist role="params">
+          <varlistentry>
+            <term>
+<parameter>repository</parameter>&#xA0;:            </term>
+            <listitem>
+              <simpara>
+                instance
+              </simpara>
+            </listitem>
+          </varlistentry>
+          <varlistentry>
+            <term>
+<parameter>gtype</parameter>&#xA0;:            </term>
+            <listitem>
+              <simpara>
+                GType to search for
+              </simpara>
+            </listitem>
+          </varlistentry>
+          <varlistentry>
+            <term>
+<parameter>Returns</parameter>&#xA0;:            </term>
+            <listitem>
+              <simpara>
+                #GIBaseInfo representing metadata about @type, or %NULL
+                <emphasis role="annotation">
+[transfer full]                </emphasis>
+              </simpara>
+            </listitem>
+          </varlistentry>
+        </variablelist>
+      </refsect2>
+      <refsect2 id="g-irepository-find-by-name" role="function">
+        <title>g_irepository_find_by_name ()</title>
+        <indexterm zone="g-irepository-find-by-name">
+          <primary>find_by_name</primary>
+        </indexterm>
+        <programlisting>
+<link linkend="GIBaseInfo"><returnvalue>GIBaseInfo</returnvalue></link> *         g_irepository_find_by_name              (<parameter><link linkend="GIRepository"><type>GIRepository</type></link> *repository, </parameter>
+                                                             <parameter><link linkend="gchar"><type>gchar</type></link> *namespace_, </parameter>
+                                                             <parameter><link linkend="gchar"><type>gchar</type></link> *name</parameter>);
+        </programlisting>
+        <para>Searches for a particular entry in a namespace.  Before calling
+this function for a particular namespace, you must call
+#g_irepository_require once to load the namespace, or otherwise
+ensure the namespace has already been loaded.</para>
+        <variablelist role="params">
+          <varlistentry>
+            <term>
+<parameter>repository</parameter>&#xA0;:            </term>
+            <listitem>
+              <simpara>
+                instance
+              </simpara>
+            </listitem>
+          </varlistentry>
+          <varlistentry>
+            <term>
+<parameter>namespace_</parameter>&#xA0;:            </term>
+            <listitem>
+              <simpara>
+                Namespace which will be searched
+              </simpara>
+            </listitem>
+          </varlistentry>
+          <varlistentry>
+            <term>
+<parameter>name</parameter>&#xA0;:            </term>
+            <listitem>
+              <simpara>
+                Entry name to find
+              </simpara>
+            </listitem>
+          </varlistentry>
+          <varlistentry>
+            <term>
+<parameter>Returns</parameter>&#xA0;:            </term>
+            <listitem>
+              <simpara>
+                #GIBaseInfo representing metadata about @name, or %NULL
+                <emphasis role="annotation">
+[transfer full]                </emphasis>
+              </simpara>
+            </listitem>
+          </varlistentry>
+        </variablelist>
+      </refsect2>
+      <refsect2 id="g-irepository-get-c-prefix" role="function">
+        <title>g_irepository_get_c_prefix ()</title>
+        <indexterm zone="g-irepository-get-c-prefix">
+          <primary>get_c_prefix</primary>
+        </indexterm>
+        <programlisting>
+<link linkend="gchar"><returnvalue>gchar</returnvalue></link> *              g_irepository_get_c_prefix              (<parameter><link linkend="GIRepository"><type>GIRepository</type></link> *repository, </parameter>
+                                                             <parameter><link linkend="gchar"><type>gchar</type></link> *namespace_</parameter>);
+        </programlisting>
+        <para>This function returns the "C prefix", or the C level namespace
+associated with the given introspection namespace.  Each C symbol
+starts with this prefix, as well each #GType in the library.
+such as #g_irepository_require before calling this function.</para>
+        <variablelist role="params">
+          <varlistentry>
+            <term>
+<parameter>repository</parameter>&#xA0;:            </term>
+            <listitem>
+              <simpara>
+                instance
+              </simpara>
+            </listitem>
+          </varlistentry>
+          <varlistentry>
+            <term>
+<parameter>namespace_</parameter>&#xA0;:            </term>
+            <listitem>
+              <simpara>
+                Namespace to inspect
+              </simpara>
+            </listitem>
+          </varlistentry>
+          <varlistentry>
+            <term>
+<parameter>Returns</parameter>&#xA0;:            </term>
+            <listitem>
+              <simpara>
+                C namespace prefix, or %NULL if none associated
+              </simpara>
+            </listitem>
+          </varlistentry>
+        </variablelist>
+      </refsect2>
+      <refsect2 id="g-irepository-get-dependencies" role="function">
+        <title>g_irepository_get_dependencies ()</title>
+        <indexterm zone="g-irepository-get-dependencies">
+          <primary>get_dependencies</primary>
+        </indexterm>
+        <programlisting>
+<link linkend="gchar"><returnvalue>gchar</returnvalue></link> *             g_irepository_get_dependencies          (<parameter><link linkend="GIRepository"><type>GIRepository</type></link> *repository, </parameter>
+                                                             <parameter><link linkend="gchar"><type>gchar</type></link> *namespace_</parameter>);
+        </programlisting>
+        <para>Return an array of all (transitive) dependencies for namespace
+form &lt;code&gt;namespace-version&lt;/code&gt;.
+such as #g_irepository_require before calling this function.</para>
+        <variablelist role="params">
+          <varlistentry>
+            <term>
+<parameter>repository</parameter>&#xA0;:            </term>
+            <listitem>
+              <simpara>
+                instance
+              </simpara>
+            </listitem>
+          </varlistentry>
+          <varlistentry>
+            <term>
+<parameter>namespace_</parameter>&#xA0;:            </term>
+            <listitem>
+              <simpara>
+                Namespace of interest
+              </simpara>
+            </listitem>
+          </varlistentry>
+          <varlistentry>
+            <term>
+<parameter>Returns</parameter>&#xA0;:            </term>
+            <listitem>
+              <simpara>
+                Zero-terminated string array of versioned dependencies
+                <emphasis role="annotation">
+[element-type utf8][transfer full]                </emphasis>
+              </simpara>
+            </listitem>
+          </varlistentry>
+        </variablelist>
+      </refsect2>
+      <refsect2 id="g-irepository-get-info" role="function">
+        <title>g_irepository_get_info ()</title>
+        <indexterm zone="g-irepository-get-info">
+          <primary>get_info</primary>
+        </indexterm>
+        <programlisting>
+<link linkend="GIBaseInfo"><returnvalue>GIBaseInfo</returnvalue></link> *         g_irepository_get_info                  (<parameter><link linkend="GIRepository"><type>GIRepository</type></link> *repository, </parameter>
+                                                             <parameter><link linkend="gchar"><type>gchar</type></link> *namespace_, </parameter>
+                                                             <parameter><link linkend="gint"><type>gint</type></link> index</parameter>);
+        </programlisting>
+        <para>This function returns a particular metadata entry in the
+given namespace @namespace_.  The namespace must have
+already been loaded before calling this function.
+See g_irepository_get_n_infos() to find the maximum number of
+entries.</para>
+        <variablelist role="params">
+          <varlistentry>
+            <term>
+<parameter>repository</parameter>&#xA0;:            </term>
+            <listitem>
+              <simpara>
+                instance
+              </simpara>
+            </listitem>
+          </varlistentry>
+          <varlistentry>
+            <term>
+<parameter>namespace_</parameter>&#xA0;:            </term>
+            <listitem>
+              <simpara>
+                Namespace to inspect
+              </simpara>
+            </listitem>
+          </varlistentry>
+          <varlistentry>
+            <term>
+<parameter>index</parameter>&#xA0;:            </term>
+            <listitem>
+              <simpara>
+                0-based offset into namespace metadata for entry
+              </simpara>
+            </listitem>
+          </varlistentry>
+          <varlistentry>
+            <term>
+<parameter>Returns</parameter>&#xA0;:            </term>
+            <listitem>
+              <simpara>
+                #GIBaseInfo containing metadata
+                <emphasis role="annotation">
+[transfer full]                </emphasis>
+              </simpara>
+            </listitem>
+          </varlistentry>
+        </variablelist>
+      </refsect2>
+      <refsect2 id="g-irepository-get-loaded-namespaces" role="function">
+        <title>g_irepository_get_loaded_namespaces ()</title>
+        <indexterm zone="g-irepository-get-loaded-namespaces">
+          <primary>get_loaded_namespaces</primary>
+        </indexterm>
+        <programlisting>
+<link linkend="gchar"><returnvalue>gchar</returnvalue></link> *             g_irepository_get_loaded_namespaces     (<parameter><link linkend="GIRepository"><type>GIRepository</type></link> *repository</parameter>);
+        </programlisting>
+        <para>Return the list of currently loaded namespaces.</para>
+        <variablelist role="params">
+          <varlistentry>
+            <term>
+<parameter>repository</parameter>&#xA0;:            </term>
+            <listitem>
+              <simpara>
+                instance
+              </simpara>
+            </listitem>
+          </varlistentry>
+          <varlistentry>
+            <term>
+<parameter>Returns</parameter>&#xA0;:            </term>
+            <listitem>
+              <simpara>
+                List of namespaces
+                <emphasis role="annotation">
+[element-type utf8][transfer full]                </emphasis>
+              </simpara>
+            </listitem>
+          </varlistentry>
+        </variablelist>
+      </refsect2>
+      <refsect2 id="g-irepository-get-n-infos" role="function">
+        <title>g_irepository_get_n_infos ()</title>
+        <indexterm zone="g-irepository-get-n-infos">
+          <primary>get_n_infos</primary>
+        </indexterm>
+        <programlisting>
+<link linkend="gint"><returnvalue>gint</returnvalue></link>                g_irepository_get_n_infos               (<parameter><link linkend="GIRepository"><type>GIRepository</type></link> *repository, </parameter>
+                                                             <parameter><link linkend="gchar"><type>gchar</type></link> *namespace_</parameter>);
+        </programlisting>
+        <para>This function returns the number of metadata entries in
+given namespace @namespace_.  The namespace must have
+already been loaded before calling this function.</para>
+        <variablelist role="params">
+          <varlistentry>
+            <term>
+<parameter>repository</parameter>&#xA0;:            </term>
+            <listitem>
+              <simpara>
+                instance
+              </simpara>
+            </listitem>
+          </varlistentry>
+          <varlistentry>
+            <term>
+<parameter>namespace_</parameter>&#xA0;:            </term>
+            <listitem>
+              <simpara>
+                Namespace to inspect
+              </simpara>
+            </listitem>
+          </varlistentry>
+          <varlistentry>
+            <term>
+<parameter>Returns</parameter>&#xA0;:            </term>
+            <listitem>
+              <simpara>
+                number of metadata entries
+              </simpara>
+            </listitem>
+          </varlistentry>
+        </variablelist>
+      </refsect2>
+      <refsect2 id="g-irepository-get-shared-library" role="function">
+        <title>g_irepository_get_shared_library ()</title>
+        <indexterm zone="g-irepository-get-shared-library">
+          <primary>get_shared_library</primary>
+        </indexterm>
+        <programlisting>
+<link linkend="gchar"><returnvalue>gchar</returnvalue></link> *              g_irepository_get_shared_library        (<parameter><link linkend="GIRepository"><type>GIRepository</type></link> *repository, </parameter>
+                                                             <parameter><link linkend="gchar"><type>gchar</type></link> *namespace_</parameter>);
+        </programlisting>
+        <para>This function returns the full path to the shared C library
+associated with the given namespace @namespace_. There may be no
+shared library path associated, in which case this function will
+return %NULL.
+such as #g_irepository_require before calling this function.</para>
+        <variablelist role="params">
+          <varlistentry>
+            <term>
+<parameter>repository</parameter>&#xA0;:            </term>
+            <listitem>
+              <simpara>
+                instance
+              </simpara>
+            </listitem>
+          </varlistentry>
+          <varlistentry>
+            <term>
+<parameter>namespace_</parameter>&#xA0;:            </term>
+            <listitem>
+              <simpara>
+                Namespace to inspect
+              </simpara>
+            </listitem>
+          </varlistentry>
+          <varlistentry>
+            <term>
+<parameter>Returns</parameter>&#xA0;:            </term>
+            <listitem>
+              <simpara>
+                Full path to shared library, or %NULL if none associated
+              </simpara>
+            </listitem>
+          </varlistentry>
+        </variablelist>
+      </refsect2>
+      <refsect2 id="g-irepository-get-typelib-path" role="function">
+        <title>g_irepository_get_typelib_path ()</title>
+        <indexterm zone="g-irepository-get-typelib-path">
+          <primary>get_typelib_path</primary>
+        </indexterm>
+        <programlisting>
+<link linkend="gchar"><returnvalue>gchar</returnvalue></link> *              g_irepository_get_typelib_path          (<parameter><link linkend="GIRepository"><type>GIRepository</type></link> *repository, </parameter>
+                                                             <parameter><link linkend="gchar"><type>gchar</type></link> *namespace_</parameter>);
+        </programlisting>
+        <para>If namespace @namespace_ is loaded, return the full path to the
+.typelib file it was loaded from.  If the typelib for
+namespace @namespace_ was included in a shared library, return
+the special string "$lt;builtin$gt;".</para>
+        <variablelist role="params">
+          <varlistentry>
+            <term>
+<parameter>repository</parameter>&#xA0;:            </term>
+            <listitem>
+              <simpara>
+                instance
+              </simpara>
+            </listitem>
+          </varlistentry>
+          <varlistentry>
+            <term>
+<parameter>namespace_</parameter>&#xA0;:            </term>
+            <listitem>
+              <simpara>
+                GI namespace to use, e.g. "Gtk"
+              </simpara>
+            </listitem>
+          </varlistentry>
+          <varlistentry>
+            <term>
+<parameter>Returns</parameter>&#xA0;:            </term>
+            <listitem>
+              <simpara>
+                Filesystem path (or $lt;builtin$gt;) if successful, %NULL if namespace is not loaded
+              </simpara>
+            </listitem>
+          </varlistentry>
+        </variablelist>
+      </refsect2>
+      <refsect2 id="g-irepository-get-version" role="function">
+        <title>g_irepository_get_version ()</title>
+        <indexterm zone="g-irepository-get-version">
+          <primary>get_version</primary>
+        </indexterm>
+        <programlisting>
+<link linkend="gchar"><returnvalue>gchar</returnvalue></link> *              g_irepository_get_version               (<parameter><link linkend="GIRepository"><type>GIRepository</type></link> *repository, </parameter>
+                                                             <parameter><link linkend="gchar"><type>gchar</type></link> *namespace_</parameter>);
+        </programlisting>
+        <para>This function returns the loaded version associated with the given
+namespace @namespace_.
+such as #g_irepository_require before calling this function.</para>
+        <variablelist role="params">
+          <varlistentry>
+            <term>
+<parameter>repository</parameter>&#xA0;:            </term>
+            <listitem>
+              <simpara>
+                instance
+              </simpara>
+            </listitem>
+          </varlistentry>
+          <varlistentry>
+            <term>
+<parameter>namespace_</parameter>&#xA0;:            </term>
+            <listitem>
+              <simpara>
+                Namespace to inspect
+              </simpara>
+            </listitem>
+          </varlistentry>
+          <varlistentry>
+            <term>
+<parameter>Returns</parameter>&#xA0;:            </term>
+            <listitem>
+              <simpara>
+                Loaded version
+              </simpara>
+            </listitem>
+          </varlistentry>
+        </variablelist>
+      </refsect2>
+      <refsect2 id="g-irepository-is-registered" role="function">
+        <title>g_irepository_is_registered ()</title>
+        <indexterm zone="g-irepository-is-registered">
+          <primary>is_registered</primary>
+        </indexterm>
+        <programlisting>
+<link linkend="gboolean"><returnvalue>gboolean</returnvalue></link>            g_irepository_is_registered             (<parameter><link linkend="GIRepository"><type>GIRepository</type></link> *repository, </parameter>
+                                                             <parameter><link linkend="gchar"><type>gchar</type></link> *namespace_, </parameter>
+                                                             <parameter><link linkend="gchar"><type>gchar</type></link> *version</parameter>);
+        </programlisting>
+        <para>Check whether a particular namespace (and optionally, a specific
+version thereof) is currently loaded.  This function is likely to
+only be useful in unusual circumstances; in order to act upon
+metadata in the namespace, you should call #g_irepository_require
+instead which will ensure the namespace is loaded, and return as
+quickly as this function will if it has already been loaded.</para>
+        <variablelist role="params">
+          <varlistentry>
+            <term>
+<parameter>repository</parameter>&#xA0;:            </term>
+            <listitem>
+              <simpara>
+                instance
+              </simpara>
+            </listitem>
+          </varlistentry>
+          <varlistentry>
+            <term>
+<parameter>namespace_</parameter>&#xA0;:            </term>
+            <listitem>
+              <simpara>
+                Namespace of interest
+              </simpara>
+            </listitem>
+          </varlistentry>
+          <varlistentry>
+            <term>
+<parameter>version</parameter>&#xA0;:            </term>
+            <listitem>
+              <simpara>
+                Required version, may be %NULL for latest
+                <emphasis role="annotation">
+[allow-none]                </emphasis>
+              </simpara>
+            </listitem>
+          </varlistentry>
+          <varlistentry>
+            <term>
+<parameter>Returns</parameter>&#xA0;:            </term>
+            <listitem>
+              <simpara>
+                %TRUE if namespace-version is loaded, %FALSE otherwise
+              </simpara>
+            </listitem>
+          </varlistentry>
+        </variablelist>
+      </refsect2>
+      <refsect2 id="g-irepository-load-typelib" role="function">
+        <title>g_irepository_load_typelib ()</title>
+        <indexterm zone="g-irepository-load-typelib">
+          <primary>load_typelib</primary>
+        </indexterm>
+        <programlisting>
+<link linkend="char"><returnvalue>char</returnvalue></link> *               g_irepository_load_typelib              (<parameter><link linkend="GIRepository"><type>GIRepository</type></link> *repository, </parameter>
+                                                             <parameter><link linkend="GITypelib"><type>GITypelib</type></link> *typelib, </parameter>
+                                                             <parameter><link linkend="GIRepositoryLoadFlags"><type>GIRepositoryLoadFlags</type></link> flags</parameter>);
+        </programlisting>
+        <para/>
+        <variablelist role="params">
+          <varlistentry>
+            <term>
+<parameter>repository</parameter>&#xA0;:            </term>
+            <listitem>
+              <simpara>
+                instance
+              </simpara>
+            </listitem>
+          </varlistentry>
+          <varlistentry>
+            <term>
+<parameter>typelib</parameter>            </term>
+          </varlistentry>
+          <varlistentry>
+            <term>
+<parameter>flags</parameter>            </term>
+          </varlistentry>
+          <varlistentry>
+            <term>
+<parameter>Returns</parameter>            </term>
+          </varlistentry>
+        </variablelist>
+      </refsect2>
+      <refsect2 id="g-irepository-require" role="function">
+        <title>g_irepository_require ()</title>
+        <indexterm zone="g-irepository-require">
+          <primary>require</primary>
+        </indexterm>
+        <programlisting>
+<link linkend="GITypelib"><returnvalue>GITypelib</returnvalue></link> *          g_irepository_require                   (<parameter><link linkend="GIRepository"><type>GIRepository</type></link> *repository, </parameter>
+                                                             <parameter><link linkend="gchar"><type>gchar</type></link> *namespace_, </parameter>
+                                                             <parameter><link linkend="gchar"><type>gchar</type></link> *version, </parameter>
+                                                             <parameter><link linkend="GIRepositoryLoadFlags"><type>GIRepositoryLoadFlags</type></link> flags</parameter>);
+        </programlisting>
+        <para>Force the namespace @namespace_ to be loaded if it isn't already.
+If @namespace_ is not loaded, this function will search for a
+".typelib" file using the repository search path.  In addition, a
+version @version of namespace may be specified.  If @version is
+not specified, the latest will be used.</para>
+        <variablelist role="params">
+          <varlistentry>
+            <term>
+<parameter>repository</parameter>&#xA0;:            </term>
+            <listitem>
+              <simpara>
+                instance
+              </simpara>
+            </listitem>
+          </varlistentry>
+          <varlistentry>
+            <term>
+<parameter>namespace_</parameter>&#xA0;:            </term>
+            <listitem>
+              <simpara>
+                GI namespace to use, e.g. "Gtk"
+              </simpara>
+            </listitem>
+          </varlistentry>
+          <varlistentry>
+            <term>
+<parameter>version</parameter>&#xA0;:            </term>
+            <listitem>
+              <simpara>
+                Version of namespace, may be %NULL for latest
+                <emphasis role="annotation">
+[allow-none]                </emphasis>
+              </simpara>
+            </listitem>
+          </varlistentry>
+          <varlistentry>
+            <term>
+<parameter>flags</parameter>&#xA0;:            </term>
+            <listitem>
+              <simpara>
+                Set of %GIRepositoryLoadFlags, may be 0
+              </simpara>
+            </listitem>
+          </varlistentry>
+          <varlistentry>
+            <term>
+<parameter>Returns</parameter>&#xA0;:            </term>
+            <listitem>
+              <simpara>
+                a pointer to the #GITypelib if successful, %NULL otherwise
+              </simpara>
+            </listitem>
+          </varlistentry>
+        </variablelist>
+      </refsect2>
+      <refsect2 id="g-irepository-require-private" role="function">
+        <title>g_irepository_require_private ()</title>
+        <indexterm zone="g-irepository-require-private">
+          <primary>require_private</primary>
+        </indexterm>
+        <programlisting>
+<link linkend="GITypelib"><returnvalue>GITypelib</returnvalue></link> *          g_irepository_require_private           (<parameter><link linkend="GIRepository"><type>GIRepository</type></link> *repository, </parameter>
+                                                             <parameter><link linkend="gchar"><type>gchar</type></link> *typelib_dir, </parameter>
+                                                             <parameter><link linkend="gchar"><type>gchar</type></link> *namespace_, </parameter>
+                                                             <parameter><link linkend="gchar"><type>gchar</type></link> *version, </parameter>
+                                                             <parameter><link linkend="GIRepositoryLoadFlags"><type>GIRepositoryLoadFlags</type></link> flags</parameter>);
+        </programlisting>
+        <para>Force the namespace @namespace_ to be loaded if it isn't already.
+If @namespace_ is not loaded, this function will search for a
+".typelib" file within the private directory only. In addition, a
+version @version of namespace should be specified.  If @version is
+not specified, the latest will be used.</para>
+        <variablelist role="params">
+          <varlistentry>
+            <term>
+<parameter>repository</parameter>&#xA0;:            </term>
+            <listitem>
+              <simpara>
+                instance
+              </simpara>
+            </listitem>
+          </varlistentry>
+          <varlistentry>
+            <term>
+<parameter>typelib_dir</parameter>&#xA0;:            </term>
+            <listitem>
+              <simpara>
+                Private directory where to find the requested typelib
+              </simpara>
+            </listitem>
+          </varlistentry>
+          <varlistentry>
+            <term>
+<parameter>namespace_</parameter>&#xA0;:            </term>
+            <listitem>
+              <simpara>
+                GI namespace to use, e.g. "Gtk"
+              </simpara>
+            </listitem>
+          </varlistentry>
+          <varlistentry>
+            <term>
+<parameter>version</parameter>&#xA0;:            </term>
+            <listitem>
+              <simpara>
+                Version of namespace, may be %NULL for latest
+                <emphasis role="annotation">
+[allow-none]                </emphasis>
+              </simpara>
+            </listitem>
+          </varlistentry>
+          <varlistentry>
+            <term>
+<parameter>flags</parameter>&#xA0;:            </term>
+            <listitem>
+              <simpara>
+                Set of %GIRepositoryLoadFlags, may be 0
+              </simpara>
+            </listitem>
+          </varlistentry>
+          <varlistentry>
+            <term>
+<parameter>Returns</parameter>&#xA0;:            </term>
+            <listitem>
+              <simpara>
+                a pointer to the #GITypelib if successful, %NULL otherwise
+              </simpara>
+            </listitem>
+          </varlistentry>
+        </variablelist>
+      </refsect2>
+    </refsect1>
+  </chapter>
+  <chapter xml:id="ch_GIRepositoryClass">
+    <title>GIRepositoryClass</title>
+    <refsynopsisdiv id="GIRepositoryClass.synopsis" role="synopsis">
+      <title role="synopsis.title">Synopsis</title>
+      <anchor id="GIRepositoryClass"/>
+      <synopsis>
+struct               <link linkend="GIRepositoryClass-struct">GIRepositoryClass</link>;
+      </synopsis>
+    </refsynopsisdiv>
+    <refsect1 id="girepositoryclass-details" role="details">
+      <title role="details.title">Details</title>
+      <refsect2 id="GIRepositoryClass-struct" role="struct">
+        <title>struct GIRepositoryClass</title>
+        <indexterm zone="GIRepositoryClass-struct">
+          <primary sortas="RepositoryClass">GIRepositoryClass</primary>
+        </indexterm>
+        <programlisting>struct GIRepositoryClass;</programlisting>
+      </refsect2>
+    </refsect1>
+  </chapter>
+  <chapter xml:id="ch_GIRepositoryPrivate">
+    <title>GIRepositoryPrivate</title>
+    <refsynopsisdiv id="GIRepositoryPrivate.synopsis" role="synopsis">
+      <title role="synopsis.title">Synopsis</title>
+      <anchor id="GIRepositoryPrivate"/>
+      <synopsis>
+struct               <link linkend="GIRepositoryPrivate-struct">GIRepositoryPrivate</link>;
+      </synopsis>
+    </refsynopsisdiv>
+    <refsect1 id="girepositoryprivate-details" role="details">
+      <title role="details.title">Details</title>
+      <refsect2 id="GIRepositoryPrivate-struct" role="struct">
+        <title>struct GIRepositoryPrivate</title>
+        <indexterm zone="GIRepositoryPrivate-struct">
+          <primary sortas="RepositoryPrivate">GIRepositoryPrivate</primary>
+        </indexterm>
+        <programlisting>struct GIRepositoryPrivate;</programlisting>
+      </refsect2>
+    </refsect1>
+  </chapter>
+  <chapter xml:id="ch_GITypelib">
+    <title>GITypelib</title>
+    <refsynopsisdiv id="GITypelib.synopsis" role="synopsis">
+      <title role="synopsis.title">Synopsis</title>
+      <anchor id="GITypelib"/>
+      <synopsis>
+struct               <link linkend="GITypelib-struct">GITypelib</link>;
+<link linkend="void"><returnvalue>void</returnvalue></link>                <link linkend="g-typelib-free">g_typelib_free</link>                          (<parameter><link linkend="GITypelib"><type>GITypelib</type></link> *typelib</parameter>);
+<link linkend="gchar"><returnvalue>gchar</returnvalue></link> *              <link linkend="g-typelib-get-namespace">g_typelib_get_namespace</link>                 (<parameter><link linkend="GITypelib"><type>GITypelib</type></link> *typelib</parameter>);
+<link linkend="gboolean"><returnvalue>gboolean</returnvalue></link>            <link linkend="g-typelib-symbol">g_typelib_symbol</link>                        (<parameter><link linkend="GITypelib"><type>GITypelib</type></link> *typelib, </parameter>
+                                                             <parameter><link linkend="gchar"><type>gchar</type></link> *symbol_name, </parameter>
+                                                             <parameter><link linkend="gpointer"><type>gpointer</type></link> *symbol</parameter>);
+      </synopsis>
+    </refsynopsisdiv>
+    <refsect1 id="gitypelib-details" role="details">
+      <title role="details.title">Details</title>
+      <refsect2 id="GITypelib-struct" role="struct">
+        <title>struct GITypelib</title>
+        <indexterm zone="GITypelib-struct">
+          <primary sortas="Typelib">GITypelib</primary>
+        </indexterm>
+        <programlisting>struct GITypelib;</programlisting>
+      </refsect2>
+      <refsect2 id="g-typelib-free" role="function">
+        <title>g_typelib_free ()</title>
+        <indexterm zone="g-typelib-free">
+          <primary>free</primary>
+        </indexterm>
+        <programlisting>
+<link linkend="void"><returnvalue>void</returnvalue></link>                g_typelib_free                          (<parameter><link linkend="GITypelib"><type>GITypelib</type></link> *typelib</parameter>);
+        </programlisting>
+        <para/>
+        <variablelist role="params">
+          <varlistentry>
+            <term>
+<parameter>typelib</parameter>&#xA0;:            </term>
+            <listitem>
+              <simpara>
+                instance
+              </simpara>
+            </listitem>
+          </varlistentry>
+          <varlistentry>
+            <term>
+<parameter>Returns</parameter>            </term>
+          </varlistentry>
+        </variablelist>
+      </refsect2>
+      <refsect2 id="g-typelib-get-namespace" role="function">
+        <title>g_typelib_get_namespace ()</title>
+        <indexterm zone="g-typelib-get-namespace">
+          <primary>get_namespace</primary>
+        </indexterm>
+        <programlisting>
+<link linkend="gchar"><returnvalue>gchar</returnvalue></link> *              g_typelib_get_namespace                 (<parameter><link linkend="GITypelib"><type>GITypelib</type></link> *typelib</parameter>);
+        </programlisting>
+        <para/>
+        <variablelist role="params">
+          <varlistentry>
+            <term>
+<parameter>typelib</parameter>&#xA0;:            </term>
+            <listitem>
+              <simpara>
+                instance
+              </simpara>
+            </listitem>
+          </varlistentry>
+          <varlistentry>
+            <term>
+<parameter>Returns</parameter>            </term>
+          </varlistentry>
+        </variablelist>
+      </refsect2>
+      <refsect2 id="g-typelib-symbol" role="function">
+        <title>g_typelib_symbol ()</title>
+        <indexterm zone="g-typelib-symbol">
+          <primary>symbol</primary>
+        </indexterm>
+        <programlisting>
+<link linkend="gboolean"><returnvalue>gboolean</returnvalue></link>            g_typelib_symbol                        (<parameter><link linkend="GITypelib"><type>GITypelib</type></link> *typelib, </parameter>
+                                                             <parameter><link linkend="gchar"><type>gchar</type></link> *symbol_name, </parameter>
+                                                             <parameter><link linkend="gpointer"><type>gpointer</type></link> *symbol</parameter>);
+        </programlisting>
+        <para/>
+        <variablelist role="params">
+          <varlistentry>
+            <term>
+<parameter>typelib</parameter>&#xA0;:            </term>
+            <listitem>
+              <simpara>
+                instance
+              </simpara>
+            </listitem>
+          </varlistentry>
+          <varlistentry>
+            <term>
+<parameter>symbol_name</parameter>            </term>
+          </varlistentry>
+          <varlistentry>
+            <term>
+<parameter>symbol</parameter>            </term>
+          </varlistentry>
+          <varlistentry>
+            <term>
+<parameter>Returns</parameter>            </term>
+          </varlistentry>
+        </variablelist>
+      </refsect2>
+    </refsect1>
+  </chapter>
+  <chapter xml:id="ch_GIUnresolvedInfo">
+    <title>GIUnresolvedInfo</title>
+    <refsynopsisdiv id="GIUnresolvedInfo.synopsis" role="synopsis">
+      <title role="synopsis.title">Synopsis</title>
+      <anchor id="GIUnresolvedInfo"/>
+      <synopsis>
+struct               <link linkend="GIUnresolvedInfo-struct">GIUnresolvedInfo</link>;
+      </synopsis>
+    </refsynopsisdiv>
+    <refsect1 id="giunresolvedinfo-details" role="details">
+      <title role="details.title">Details</title>
+      <refsect2 id="GIUnresolvedInfo-struct" role="struct">
+        <title>struct GIUnresolvedInfo</title>
+        <indexterm zone="GIUnresolvedInfo-struct">
+          <primary sortas="UnresolvedInfo">GIUnresolvedInfo</primary>
+        </indexterm>
+        <programlisting>struct GIUnresolvedInfo;</programlisting>
+      </refsect2>
+    </refsect1>
+  </chapter>
+  <chapter xml:id="ch__GIBaseInfoStub">
+    <title>_GIBaseInfoStub</title>
+    <refsynopsisdiv id="_GIBaseInfoStub.synopsis" role="synopsis">
+      <title role="synopsis.title">Synopsis</title>
+      <anchor id="_GIBaseInfoStub"/>
+      <synopsis>
+struct               <link linkend="_GIBaseInfoStub-struct">_GIBaseInfoStub</link>;
+      </synopsis>
+    </refsynopsisdiv>
+    <refsect1 id="_gibaseinfostub-details" role="details">
+      <title role="details.title">Details</title>
+      <refsect2 id="_GIBaseInfoStub-struct" role="struct">
+        <title>struct _GIBaseInfoStub</title>
+        <indexterm zone="_GIBaseInfoStub-struct">
+          <primary sortas="_BaseInfoStub">_GIBaseInfoStub</primary>
+        </indexterm>
+        <programlisting>struct _GIBaseInfoStub;</programlisting>
+      </refsect2>
+    </refsect1>
+  </chapter>
+</book>
diff --git a/tests/doctool/Makefile.am b/tests/doctool/Makefile.am
new file mode 100644
index 00000000..1552930a
--- /dev/null
+++ b/tests/doctool/Makefile.am
@@ -0,0 +1,20 @@
+include $(top_srcdir)/common.mk
+
+GIRepository-2.0.gir:
+	cp ../../GIRepository-2.0.gir .
+
+GIRS = GIRepository-2.0.gir
+CHECKXML = $(GIRS:.gir=.xml.check)
+DOCBOOKFILES = $(GIRS:.gir=.xml)
+EXPECTEDDOCBOOKFILES = $(DOCBOOKFILES:.xml=-expected.xml)
+CLEANFILES = $(DOCBOOK_FILES)
+BUILT_SOURCES = $(DOCBOOK_FILES)
+EXTRA_DIST = $(EXPECTEDDOCBOOKFILES)
+
+%.xml: %.gir
+	$(INTROSPECTION_DOCTOOL) $*.gir -o $*.xml && echo "  GEN  $*.xml"
+
+%.xml.check: %.xml
+	@diff -u -U 10 $(srcdir)/$*-expected.xml $*.xml && echo "  TEST  $*.xml"
+
+check-local: $(CHECKXML) $(TYPELIBS)
diff --git a/tools/g-ir-doc-tool.in b/tools/g-ir-doc-tool.in
new file mode 100644
index 00000000..4a84afad
--- /dev/null
+++ b/tools/g-ir-doc-tool.in
@@ -0,0 +1,46 @@
+#!@PYTHON@
+# -*- Mode: Python -*-
+# GObject-Introspection - a framework for introspecting GObject libraries
+# Copyright (C) 2008  Johan Dahlin
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2
+# of the License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+# 02110-1301, USA.
+#
+
+import os
+import sys
+import __builtin__
+
+__builtin__.__dict__['DATADIR'] = "@datarootdir@"
+
+if 'GI_SCANNER_DEBUG' in os.environ:
+    def on_exception(exctype, value, tb):
+        print "Caught exception: %r %r" % (exctype, value)
+        import pdb
+        pdb.pm()
+    sys.excepthook = on_exception
+
+srcdir = os.getenv('UNINSTALLED_INTROSPECTION_SRCDIR', None)
+if srcdir is not None:
+    path = srcdir
+else:
+    # This is a private directory, we don't want to pollute the global
+    # namespace.
+    path = os.path.join('@libdir@', 'gobject-introspection')
+sys.path.insert(0, path)
+
+from giscanner.docmain import doc_main
+
+sys.exit(doc_main(sys.argv))