Mon Apr 22 17:39:01 PDT 2013

Rebased ref, commits from common ancestor:
commit 84217e299724b8ee80dff63cb561b4bae0f44835
Author: Michael Stahl <mstahl at redhat.com>
Date:   Tue Apr 23 00:17:03 2013 +0200

    fdo#62147: sw: ODF import: apply styles in cells with string-value
    
    Apply the table-cell-style to paragraphs inside the table cell
    for cells with value-type="string" and office:string-value attribute.
    This should complete commit 1b5839f49c07beb6fbde6c7370a5636d22f9ab77.
    
    Change-Id: Ief34de1e7c5087906ea597ce3ca96e020f6eebe6

diff --git a/sw/source/filter/xml/xmltbli.cxx b/sw/source/filter/xml/xmltbli.cxx
index ec43a0c..d30cccf 100644
--- a/sw/source/filter/xml/xmltbli.cxx
+++ b/sw/source/filter/xml/xmltbli.cxx
@@ -587,8 +587,11 @@ SwXMLTableCellContext_Impl::~SwXMLTableCellContext_Impl()
 
 inline void SwXMLTableCellContext_Impl::_InsertContent()
 {
+    SwStartNode const*const pStartNode( GetTable()->InsertTableSection(0,
+            (m_bHasStringValue && m_bValueTypeIsString &&
+             !aStyleName.isEmpty()) ? & aStyleName : 0) );
     GetTable()->InsertCell( aStyleName, nRowSpan, nColSpan,
-                            GetTable()->InsertTableSection(),
+                            pStartNode,
                             mXmlId,
                             NULL, bProtect, &sFormula, bHasValue, fValue,
             (m_bHasStringValue && m_bValueTypeIsString) ? &m_StringValue : 0);
@@ -2881,12 +2884,14 @@ void SwXMLTableContext::MakeTable( SwTableBox *pBox, sal_Int32 nW )
 }
 
 const SwStartNode *SwXMLTableContext::InsertTableSection(
-                                            const SwStartNode *pPrevSttNd )
+        const SwStartNode *const pPrevSttNd,
+        OUString const*const pStringValueStyleName)
 {
     // The topmost table is the only table that maintains the two members
     // pBox1 and bFirstSection.
     if( xParentTable.Is() )
-        return ((SwXMLTableContext *)&xParentTable)->InsertTableSection( pPrevSttNd );
+        return static_cast<SwXMLTableContext *>(&xParentTable)
+                    ->InsertTableSection(pPrevSttNd, pStringValueStyleName);
 
     const SwStartNode *pStNd;
     Reference<XUnoTunnel> xCrsrTunnel( GetImport().GetTextImport()->GetCursor(),
@@ -2941,6 +2946,13 @@ const SwStartNode *SwXMLTableContext::InsertTableSection(
         }
     }
 
+    if (pStringValueStyleName)
+    {   // fdo#62147: apply style to paragraph on string-value cell
+        GetImport().GetTextImport()->SetStyleAndAttrs( GetImport(),
+            GetImport().GetTextImport()->GetCursor(), *pStringValueStyleName,
+            true, false, -1, false); // parameters same as sCellParaStyleName
+    }
+
     return pStNd;
 }
 
diff --git a/sw/source/filter/xml/xmltbli.hxx b/sw/source/filter/xml/xmltbli.hxx
index 7062dc4..0ba3130 100644
--- a/sw/source/filter/xml/xmltbli.hxx
+++ b/sw/source/filter/xml/xmltbli.hxx
@@ -186,7 +186,8 @@ public:
     void InsertRepRows( sal_uInt32 nCount );
     const SwXMLTableCell_Impl *GetCell( sal_uInt32 nRow, sal_uInt32 nCol ) const;
     SwXMLTableCell_Impl *GetCell( sal_uInt32 nRow, sal_uInt32 nCol );
-    const SwStartNode *InsertTableSection( const SwStartNode *pPrevSttNd=0 );
+    const SwStartNode *InsertTableSection(const SwStartNode *pPrevSttNd = 0,
+                                  OUString const* pStringValueStyleName = 0);
 
     virtual void EndElement();
 
commit 1d80c1cf22c1cb673da91b8aa59d770fc30dffdc
Author: Marco Cecchetti <mrcekets at gmail.com>
Date:   Mon Apr 22 23:14:53 2013 +0200

    Changed the MPL header from v1 to v2

diff --git a/filter/source/svg/js2hxx.py b/filter/source/svg/js2hxx.py
index 8aeb94c..5d6ddd5 100755
--- a/filter/source/svg/js2hxx.py
+++ b/filter/source/svg/js2hxx.py
@@ -1,11 +1,10 @@
 #!/usr/bin/env python
 #
-# Version: MPL 1.1 / GPLv3+ / LGPLv3+
+# This file is part of the LibreOffice project.
 #
-# The contents of this file are subject to the Mozilla Public License Version
-# 1.1 (the "License"); you may not use this file except in compliance with
-# the License or as specified alternatively below. You may obtain a copy of
-# the License at http://www.mozilla.org/MPL/
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
 #
 # Software distributed under the License is distributed on an "AS IS" basis,
 # WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
@@ -18,13 +17,6 @@
 # All Rights Reserved.
 #
 # For minor contributions see the git repository.
-#
-# Alternatively, the contents of this file may be used under the terms of
-# either the GNU General Public License Version 3 or later (the "GPLv3+"), or
-# the GNU Lesser General Public License Version 3 or later (the "LGPLv3+"),
-# in which case the provisions of the GPLv3+ or the LGPLv3+ are applicable
-# instead of those above.
-#
 
 import os, sys
 
commit 5cd4300f7ffc24d6bc0ed5704f37a04852fd322b
Author: Eike Rathke <erack at redhat.com>
Date:   Mon Apr 22 23:06:50 2013 +0200

    fixed a mess of out of bounds string accesses
    
    Change-Id: I800840e1b3c0d97a049b3ceba0ec244365dc8e6b

diff --git a/svl/source/numbers/zformat.cxx b/svl/source/numbers/zformat.cxx
index 88f55d0..85a9d2a 100644
--- a/svl/source/numbers/zformat.cxx
+++ b/svl/source/numbers/zformat.cxx
@@ -1416,6 +1416,21 @@ SvNumberformat::LocaleType SvNumberformat::ImpGetLocaleType(const OUString& rStr
     return (cToken == ']' || nPos == nLen) ? LocaleType(nNum) : LocaleType();
 }
 
+static bool lcl_matchKeywordAndGetNumber( const OUString & rString, const sal_Int32 nPos,
+        const OUString & rKeyword, sal_Int32 & nNumber )
+{
+    if (0 <= nPos && nPos + rKeyword.getLength() < rString.getLength() && rString.matchIgnoreAsciiCase( rKeyword, nPos))
+    {
+        nNumber = rString.copy( nPos + rKeyword.getLength()).toInt32();
+        return true;
+    }
+    else
+    {
+        nNumber = 0;
+        return false;
+    }
+}
+
 short SvNumberformat::ImpNextSymbol(OUStringBuffer& rString,
                                     sal_Int32& nPos,
                                     OUString& sSymbol)
@@ -1518,45 +1533,47 @@ short SvNumberformat::ImpNextSymbol(OUStringBuffer& rString,
             {
                 const OUString aNatNum("NATNUM");
                 const OUString aDBNum("DBNUM");
-                OUString aUpperNatNum( rChrCls().uppercase( rString.toString(), nPos-1, aNatNum.getLength() ) );
-                OUString aUpperDBNum( rChrCls().uppercase( rString.toString(), nPos-1, aDBNum.getLength() ) );
-                sal_Unicode cUpper = aUpperNatNum[0];
-                sal_Int32 nNatNumNum = rString.toString().copy( nPos - 1 + aNatNum.getLength() ).toInt32();
-                sal_Unicode cDBNum =
-                    nPos - 1 + aDBNum.getLength() < rString.getLength()
-                    ? rString[nPos - 1 + aDBNum.getLength()] : 0;
-                if ( aUpperNatNum == aNatNum && 0 <= nNatNumNum && nNatNumNum <= 19 )
+                const OUString aBufStr( rString.toString());
+                sal_Int32 nNatNumNum;
+                sal_Int32 nDBNum;
+                if ( lcl_matchKeywordAndGetNumber( aBufStr, nPos-1, aNatNum, nNatNumNum) &&
+                        0 <= nNatNumNum && nNatNumNum <= 19 )
                 {
                     sBuffSymbol.stripStart((sal_Unicode)'[');
-                    sBuffSymbol.append( rString.toString().copy( --nPos, aNatNum.getLength()+1 ));
+                    sBuffSymbol.append( aBufStr.copy( --nPos, aNatNum.getLength()+1 ));
                     nPos += aNatNum.getLength()+1;
                     //! SymbolType is negative
                     eSymbolType = (short) (BRACKET_SYMBOLTYPE_NATNUM0 - nNatNumNum);
                     eState = SsGetPrefix;
                 }
-                else if ( aUpperDBNum == aDBNum && '1' <= cDBNum && cDBNum <= '9' )
+                else if ( lcl_matchKeywordAndGetNumber( aBufStr, nPos-1, aDBNum, nDBNum) &&
+                        '1' <= nDBNum && nDBNum <= '9' )
                 {
                     sBuffSymbol.stripStart((sal_Unicode)'[');
                     sBuffSymbol.append(rString.toString().copy( --nPos, aDBNum.getLength()+1 ));
                     nPos += aDBNum.getLength()+1;
                     //! SymbolType is negative
-                    eSymbolType = sal::static_int_cast< short >( BRACKET_SYMBOLTYPE_DBNUM1 - (cDBNum - '1'));
+                    eSymbolType = sal::static_int_cast< short >( BRACKET_SYMBOLTYPE_DBNUM1 - (nDBNum - '1'));
                     eState = SsGetPrefix;
                 }
-                else if (cUpper == rKeywords[NF_KEY_H][0] ||  // H
-                         cUpper == rKeywords[NF_KEY_MI][0] ||  // M
-                         cUpper == rKeywords[NF_KEY_S][0] )   // S
-                {
-                    sBuffSymbol.append(cToken);
-                    eState = SsGetTime;
-                    cLetter = cToken;
-                }
                 else
                 {
-                    sBuffSymbol.stripStart((sal_Unicode)'[');
-                    sBuffSymbol.append(cToken);
-                    eSymbolType = BRACKET_SYMBOLTYPE_COLOR;
-                    eState = SsGetPrefix;
+                    sal_Unicode cUpper = rChrCls().uppercase( aBufStr, nPos-1, 1)[0];
+                    if (    cUpper == rKeywords[NF_KEY_H][0] ||     // H
+                            cUpper == rKeywords[NF_KEY_MI][0] ||    // M
+                            cUpper == rKeywords[NF_KEY_S][0] )      // S
+                    {
+                        sBuffSymbol.append(cToken);
+                        eState = SsGetTime;
+                        cLetter = cToken;
+                    }
+                    else
+                    {
+                        sBuffSymbol.stripStart((sal_Unicode)'[');
+                        sBuffSymbol.append(cToken);
+                        eSymbolType = BRACKET_SYMBOLTYPE_COLOR;
+                        eState = SsGetPrefix;
+                    }
                 }
             }
             }
commit dfcbc1e1af08f555d21ae85550ec16fb001da991
Author: Lionel Elie Mamane <lionel at mamane.lu>
Date:   Mon Apr 22 21:53:59 2013 +0200

    Data-aware ListBox: declare the newly supported External Binding Types
    
    Change-Id: I5ab021f99373f24b6be2ca6db00fe8b6e69bc9cb

diff --git a/forms/source/component/ListBox.cxx b/forms/source/component/ListBox.cxx
index 8771869..204d874 100644
--- a/forms/source/component/ListBox.cxx
+++ b/forms/source/component/ListBox.cxx
@@ -1619,11 +1619,13 @@ namespace frm
     //--------------------------------------------------------------------
     Sequence< Type > OListBoxModel::getSupportedBindingTypes()
     {
-        Sequence< Type > aTypes(4);
-        aTypes[0] = ::getCppuType( static_cast< Sequence< sal_Int32 >* >( NULL ) );
-        aTypes[1] = ::getCppuType( static_cast< sal_Int32* >( NULL ) );
-        aTypes[2] = ::getCppuType( static_cast< Sequence< OUString >* >( NULL ) );
-        aTypes[3] = ::getCppuType( static_cast< OUString* >( NULL ) );
+        Sequence< Type > aTypes(6);
+        aTypes[0] = ::getCppuType( static_cast< Sequence< Any >* >( NULL ) );
+        aTypes[1] = ::getCppuType( static_cast< Any* >( NULL ) );
+        aTypes[2] = ::getCppuType( static_cast< Sequence< sal_Int32 >* >( NULL ) );
+        aTypes[3] = ::getCppuType( static_cast< sal_Int32* >( NULL ) );
+        aTypes[4] = ::getCppuType( static_cast< Sequence< OUString >* >( NULL ) );
+        aTypes[5] = ::getCppuType( static_cast< OUString* >( NULL ) );
         return aTypes;
     }
 
commit 1e392ea7a0d1504f701f9fed1492e64a78a65339
Author: Fridrich Å trba <fridrich.strba at bluewin.ch>
Date:   Mon Apr 22 19:39:51 2013 +0200

    Trying to avoid linking with boost on Windows
    
    Change-Id: Ic0c538dfad88f850d95f417f2741ef7dba7fc5e4

diff --git a/libcdr/UnpackedTarball_cdr.mk b/libcdr/UnpackedTarball_cdr.mk
index be1e7d7..a4a427d 100644
--- a/libcdr/UnpackedTarball_cdr.mk
+++ b/libcdr/UnpackedTarball_cdr.mk
@@ -11,4 +11,10 @@ $(eval $(call gb_UnpackedTarball_UnpackedTarball,cdr))
 
 $(eval $(call gb_UnpackedTarball_set_tarball,cdr,$(CDR_TARBALL)))
 
+$(eval $(call gb_UnpackedTarball_set_patchlevel,cdr,1))
+
+$(eval $(call gb_UnpackedTarball_add_patches,cdr,\
+       libcdr/libcdr-0.0.13.patch \
+))
+
 # vim: set noet sw=4 ts=4:
diff --git a/libcdr/libcdr-0.0.13.patch b/libcdr/libcdr-0.0.13.patch
new file mode 100644
index 0000000..29b2b28
--- /dev/null
+++ b/libcdr/libcdr-0.0.13.patch
@@ -0,0 +1,12 @@
+--- a/src/lib/CDRParser.cpp
++++ b/src/lib/CDRParser.cpp
+@@ -32,6 +32,9 @@
+ #include <string.h>
+ #include <sstream>
+ #include <set>
++#ifndef BOOST_ALL_NO_LIB
++#define BOOST_ALL_NO_LIB 1
++#endif
+ #include <boost/property_tree/json_parser.hpp>
+ #include <boost/property_tree/ptree.hpp>
+ #include <boost/spirit/include/classic.hpp>
commit 41d2b58b1ed5c1c4a1ca6ab3e6d7c4f15874d3a3
Author: Fridrich Å trba <fridrich.strba at bluewin.ch>
Date:   Mon Apr 22 18:34:04 2013 +0200

    Trying to fix a boost::property_tree::json_parser error on windows
    
    Change-Id: Iea3ec9a56eb008c6a0729a151b392f1e62925720

diff --git a/boost/UnpackedTarball_boost.mk b/boost/UnpackedTarball_boost.mk
index 6474f22..687a163 100644
--- a/boost/UnpackedTarball_boost.mk
+++ b/boost/UnpackedTarball_boost.mk
@@ -62,6 +62,8 @@ boost_patches += boost_1_44_0-gcc4.8.patch
 # https://svn.boost.org/trac/boost/changeset/78496
 boost_patches += boost.4874.patch
 
+boost_patches += boost.ptree.patch
+
 $(eval $(call gb_UnpackedTarball_UnpackedTarball,boost))
 
 $(eval $(call gb_UnpackedTarball_set_tarball,boost,$(BOOST_TARBALL)))
diff --git a/boost/boost.ptree.patch b/boost/boost.ptree.patch
new file mode 100644
index 0000000..3fa98d8
--- /dev/null
+++ b/boost/boost.ptree.patch
@@ -0,0 +1,11 @@
+--- misc/build/boost_1_44_0/boost/property_tree/detail/json_parser_read.hpp	2013-04-22 18:22:16.961642320 +0200
++++ misc/build/boost_1_44_0/boost/property_tree/detail/json_parser_read.hpp	2013-04-22 18:22:59.991632602 +0200
+@@ -102,7 +102,7 @@
+             void operator()(It b, It e) const
+             {
+                 BOOST_ASSERT(c.stack.size() >= 1);
+-                c.stack.back()->push_back(std::make_pair(c.name, Str(b, e)));
++                c.stack.back()->push_back(std::make_pair(c.name, Ptree(Str(b, e))));
+                 c.name.clear();
+                 c.string.clear();
+             }
commit 5275ed805a6e42f56c59d1c5876a7994625905a9
Author: Stephan Bergmann <sbergman at redhat.com>
Date:   Wed Apr 17 16:43:13 2013 +0200

    Revert "Revert "WIP: Experimental new binary type.rdb format""
    
    This reverts commit 67e69a55820f50973ca0de75ccab2bb07d0bada8, applying a band-
    aid fix to cli_ure/source/climaker for now.
    
    Conflicts:
    	stoc/inc/bootstrapservices.hxx
    	stoc/source/tdmanager/lrucache.hxx
    	stoc/source/tdmanager/tdmgr.cxx
    	stoc/source/tdmanager/tdmgr_common.hxx
    	stoc/source/tdmanager/tdmgr_tdenumeration.cxx
    	stoc/source/tdmanager/tdmgr_tdenumeration.hxx
    
    Change-Id: Iae669985d0194f06fa349a4a39f0ebd230bc5d28

diff --git a/cli_ure/source/climaker/climaker_app.cxx b/cli_ure/source/climaker/climaker_app.cxx
old mode 100644
new mode 100755
index f7b1f27..e74cc23
--- a/cli_ure/source/climaker/climaker_app.cxx
+++ b/cli_ure/source/climaker/climaker_app.cxx
@@ -483,17 +483,15 @@ SAL_IMPLEMENT_MAIN()
                 Sequence< Any >( &arg, 1 ), xContext ) );
         // insert provider to tdmgr
         Reference< container::XSet > xSet( xTDmgr, UNO_QUERY_THROW );
-        Any provider( makeAny( xTD_provider ) );
-        xSet->insert( provider );
-        OSL_ASSERT( xSet->has( provider ) );
-        if (! extra_registries.empty())
+        for (vector< OUString >::iterator i(extra_registries.begin());
+             i != extra_registries.end(); ++i)
         {
-            arg = makeAny( open_registries( extra_registries, xContext ) );
-            provider = makeAny(
-                xTDprov_factory->createInstanceWithArgumentsAndContext(
-                    Sequence< Any >( &arg, 1 ), xContext ) );
-            xSet->insert( provider );
-            OSL_ASSERT( xSet->has( provider ) );
+            xSet->insert(makeAny(*i));
+        }
+        for (vector< OUString >::iterator i(mandatory_registries.begin());
+             i != mandatory_registries.end(); ++i)
+        {
+            xSet->insert(makeAny(*i));
         }
 
         if (0 == output.getLength()) // no output file specified
diff --git a/cppuhelper/Library_cppuhelper.mk b/cppuhelper/Library_cppuhelper.mk
index 577efbc..b594b53 100644
--- a/cppuhelper/Library_cppuhelper.mk
+++ b/cppuhelper/Library_cppuhelper.mk
@@ -75,7 +75,7 @@ $(eval $(call gb_Library_add_exception_objects,cppuhelper,\
 	cppuhelper/source/shlib \
 	cppuhelper/source/supportsservice \
 	cppuhelper/source/tdmgr \
-	cppuhelper/source/typedescriptionprovider \
+	cppuhelper/source/typemanager \
 	cppuhelper/source/typeprovider \
 	cppuhelper/source/unourl \
 	cppuhelper/source/weak \
diff --git a/cppuhelper/source/defaultbootstrap.cxx b/cppuhelper/source/defaultbootstrap.cxx
index 10c8eaf..fc790ba 100644
--- a/cppuhelper/source/defaultbootstrap.cxx
+++ b/cppuhelper/source/defaultbootstrap.cxx
@@ -12,8 +12,6 @@
 #include <cassert>
 #include <vector>
 
-#include "com/sun/star/container/XHierarchicalNameAccess.hpp"
-#include "com/sun/star/container/XSet.hpp"
 #include "com/sun/star/uno/DeploymentException.hpp"
 #include "com/sun/star/uno/Any.hxx"
 #include "com/sun/star/uno/Reference.hxx"
@@ -29,7 +27,7 @@ using rtl::OUString;
 #include "macro_expander.hxx"
 #include "paths.hxx"
 #include "servicemanager.hxx"
-#include "typedescriptionprovider.hxx"
+#include "typemanager.hxx"
 
 namespace {
 
@@ -60,6 +58,9 @@ cppu::defaultBootstrap_InitialComponentContext(rtl::OUString const & iniUri)
     rtl::Reference< cppuhelper::ServiceManager > smgr(
         new cppuhelper::ServiceManager(
             getBootstrapVariable(bs, "UNO_SERVICES")));
+    rtl::Reference< cppuhelper::TypeManager > tmgr(
+        new cppuhelper::TypeManager(
+            getBootstrapVariable(bs, "UNO_TYPES")));
     cppu::ContextEntry_Init entry;
     std::vector< cppu::ContextEntry_Init > context_values;
     context_values.push_back(
@@ -69,6 +70,13 @@ cppu::defaultBootstrap_InitialComponentContext(rtl::OUString const & iniUri)
                 css::uno::Reference< css::uno::XInterface >(
                     static_cast< cppu::OWeakObject * >(smgr.get()))),
             false));
+    context_values.push_back(
+        cppu::ContextEntry_Init(
+            "/singletons/com.sun.star.reflection.theTypeDescriptionManager",
+            css::uno::makeAny(
+                css::uno::Reference< css::uno::XInterface >(
+                    static_cast< cppu::OWeakObject * >(tmgr.get()))),
+            false));
     context_values.push_back( //TODO: from services.rdb?
         cppu::ContextEntry_Init(
             "/singletons/com.sun.star.util.theMacroExpander",
@@ -92,18 +100,7 @@ cppu::defaultBootstrap_InitialComponentContext(rtl::OUString const & iniUri)
             &context_values[0], context_values.size(),
             css::uno::Reference< css::uno::XComponentContext >()));
     smgr->setContext(context);
-    css::uno::Reference< css::container::XHierarchicalNameAccess > tdmgr(
-        context->getValueByName(
-            "/singletons/com.sun.star.reflection.theTypeDescriptionManager"),
-        css::uno::UNO_QUERY_THROW);
-    css::uno::Reference< css::container::XSet >(
-        tdmgr, css::uno::UNO_QUERY_THROW)->
-        insert(
-            css::uno::makeAny(
-                cppuhelper::createTypeDescriptionProviders(
-                    getBootstrapVariable(bs, "UNO_TYPES"), smgr.get(),
-                    context)));
-    cppu::installTypeDescriptionManager(tdmgr);
+    cppu::installTypeDescriptionManager(tmgr.get());
     return context;
 }
 
diff --git a/cppuhelper/source/typedescriptionprovider.hxx b/cppuhelper/source/typedescriptionprovider.hxx
deleted file mode 100644
index 93336e8..0000000
--- a/cppuhelper/source/typedescriptionprovider.hxx
+++ /dev/null
@@ -1,39 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-/*
- * This file is part of the LibreOffice project.
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/.
- */
-
-#ifndef INCLUDED_CPPUHELPER_SOURCE_TYPEDESCRIPTIONPROVIDER_HXX
-#define INCLUDED_CPPUHELPER_SOURCE_TYPEDESCRIPTIONPROVIDER_HXX
-
-#include "sal/config.h"
-
-#include "com/sun/star/uno/Reference.hxx"
-#include "com/sun/star/uno/Sequence.hxx"
-
-namespace com { namespace sun { namespace star {
-     namespace container { class XHierarchicalNameAccess; }
-     namespace lang { class XMultiComponentFactory; }
-     namespace uno { class XComponentContext; }
-} } }
-namespace rtl { class OUString; }
-
-namespace cppuhelper {
-
-css::uno::Sequence<
-    css::uno::Reference< css::container::XHierarchicalNameAccess > >
-createTypeDescriptionProviders(
-    rtl::OUString const & uris,
-    css::uno::Reference< css::lang::XMultiComponentFactory > const &
-        serviceManager,
-    css::uno::Reference< css::uno::XComponentContext > const & context);
-
-}
-
-#endif
-
-/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/cppuhelper/source/typedescriptionprovider.cxx b/cppuhelper/source/typemanager.cxx
similarity index 63%
rename from cppuhelper/source/typedescriptionprovider.cxx
rename to cppuhelper/source/typemanager.cxx
index b87575d..4185ddc 100644
--- a/cppuhelper/source/typedescriptionprovider.cxx
+++ b/cppuhelper/source/typemanager.cxx
@@ -10,16 +10,17 @@
 #include "sal/config.h"
 
 #include <cassert>
+#include <cstddef>
 #include <cstdlib>
+#include <cstring>
 #include <set>
 #include <stack>
 #include <vector>
 
 #include "boost/noncopyable.hpp"
+#include "com/sun/star/container/ElementExistException.hpp"
 #include "com/sun/star/container/NoSuchElementException.hpp"
-#include "com/sun/star/container/XHierarchicalNameAccess.hpp"
-#include "com/sun/star/lang/XInitialization.hpp"
-#include "com/sun/star/lang/XMultiComponentFactory.hpp"
+#include "com/sun/star/lang/IllegalArgumentException.hpp"
 #include "com/sun/star/reflection/InvalidTypeNameException.hpp"
 #include "com/sun/star/reflection/NoSuchTypeNameException.hpp"
 #include "com/sun/star/reflection/TypeDescriptionSearchDepth.hpp"
@@ -35,61 +36,99 @@
 #include "com/sun/star/reflection/XServiceTypeDescription2.hpp"
 #include "com/sun/star/reflection/XSingletonTypeDescription2.hpp"
 #include "com/sun/star/reflection/XStructTypeDescription.hpp"
-#include "com/sun/star/reflection/XTypeDescriptionEnumeration.hpp"
-#include "com/sun/star/reflection/XTypeDescriptionEnumerationAccess.hpp"
-#include "com/sun/star/registry/InvalidRegistryException.hpp"
-#include "com/sun/star/registry/XSimpleRegistry.hpp"
+#include "com/sun/star/reflection/XTypeDescription.hpp"
 #include "com/sun/star/uno/Any.hxx"
 #include "com/sun/star/uno/DeploymentException.hpp"
 #include "com/sun/star/uno/Reference.hxx"
 #include "com/sun/star/uno/RuntimeException.hpp"
 #include "com/sun/star/uno/Sequence.hxx"
+#include "com/sun/star/uno/Type.hxx"
 #include "com/sun/star/uno/TypeClass.hpp"
-#include "com/sun/star/uno/XComponentContext.hpp"
-#include "com/sun/star/uno/XInterface.hpp"
-#include "cppuhelper/compbase2.hxx"
+#include "cppu/unotype.hxx"
 #include "cppuhelper/implbase1.hxx"
+#include "cppuhelper/supportsservice.hxx"
 #include "osl/file.hxx"
 #include "osl/mutex.hxx"
 #include "rtl/ref.hxx"
+#include "rtl/string.h"
 #include "rtl/ustring.hxx"
+#include "sal/macros.h"
 #include "sal/types.h"
 
 using rtl::OUString;
 
 #include "unoidl/unoidl.hxx"
-#include "unoidl/unoidlprovider.hxx"
 
 #include "paths.hxx"
-#include "typedescriptionprovider.hxx"
+#include "typemanager.hxx"
 
 namespace {
 
-css::uno::Reference< css::reflection::XTypeDescription > resolve(
-    css::uno::Reference< css::uno::XComponentContext > const & context,
-    rtl::OUString const & name)
-{
-    assert(context.is());
-    try {
-        return css::uno::Reference< css::reflection::XTypeDescription >(
-            (css::uno::Reference< css::container::XHierarchicalNameAccess >(
-                context->getValueByName(
-                    "/singletons/"
-                    "com.sun.star.reflection.theTypeDescriptionManager"),
-                css::uno::UNO_QUERY_THROW)->
-             getByHierarchicalName(name)),
-            css::uno::UNO_QUERY_THROW);
-    } catch (css::container::NoSuchElementException & e) {
-        throw css::uno::DeploymentException(
-            ("cannot resolve type \"" + name + "\"; NoSuchElementException: "
-             + e.Message),
-            e.Context);
+css::uno::Any resolveTypedefs(css::uno::Any const & type) {
+    for (css::uno::Any t(type);;) {
+        css::uno::Reference< css::reflection::XIndirectTypeDescription > ind(
+            type, css::uno::UNO_QUERY);
+        if (!ind.is() || ind->getTypeClass() != css::uno::TypeClass_TYPEDEF) {
+            return t;
+        }
+        t = css::uno::makeAny(ind->getReferencedType());
     }
 }
 
+class SimpleTypeDescription:
+    public cppu::WeakImplHelper1< css::reflection::XTypeDescription >
+{
+public:
+    SimpleTypeDescription(
+        css::uno::TypeClass typeClass, rtl::OUString const & name):
+        typeClass_(typeClass), name_(name)
+    {}
+
+private:
+    virtual ~SimpleTypeDescription() {}
+
+    virtual css::uno::TypeClass SAL_CALL getTypeClass()
+        throw (css::uno::RuntimeException)
+    { return typeClass_; }
+
+    virtual rtl::OUString SAL_CALL getName() throw (css::uno::RuntimeException)
+    { return name_; }
+
+    css::uno::TypeClass typeClass_;
+    rtl::OUString name_;
+};
+
+class SequenceTypeDescription:
+    public cppu::WeakImplHelper1< css::reflection::XIndirectTypeDescription >
+{
+public:
+    SequenceTypeDescription(
+        rtl::Reference< cppuhelper::TypeManager > const & manager,
+        rtl::OUString const & name, rtl::OUString const & componentType):
+        manager_(manager), name_(name), componentType_(componentType)
+    { assert(manager.is()); }
+
+private:
+    virtual ~SequenceTypeDescription() {}
+
+    virtual css::uno::TypeClass SAL_CALL getTypeClass()
+        throw (css::uno::RuntimeException)
+    { return css::uno::TypeClass_SEQUENCE; }
+
+    virtual rtl::OUString SAL_CALL getName() throw (css::uno::RuntimeException)
+    { return name_; }
+
+    virtual css::uno::Reference< css::reflection::XTypeDescription > SAL_CALL
+    getReferencedType() throw (css::uno::RuntimeException)
+    { return manager_->resolve(componentType_); }
+
+    rtl::Reference< cppuhelper::TypeManager > manager_;
+    rtl::OUString name_;
+    rtl::OUString componentType_;
+};
+
 class PublishableDescription:
-    public cppu::WeakImplHelper1< css::reflection::XPublished >,
-    private boost::noncopyable
+    public cppu::WeakImplHelper1< css::reflection::XPublished >
 {
 protected:
     PublishableDescription(bool published): published_(published) {}
@@ -104,16 +143,15 @@ private:
 };
 
 class ModuleDescription:
-    public cppu::WeakImplHelper1< css::reflection::XModuleTypeDescription >,
-    private boost::noncopyable
+    public cppu::WeakImplHelper1< css::reflection::XModuleTypeDescription >
 {
 public:
     ModuleDescription(
-        css::uno::Reference< css::uno::XComponentContext > const & context,
+        rtl::Reference< cppuhelper::TypeManager > const & manager,
         rtl::OUString const & name,
         rtl::Reference< unoidl::ModuleEntity > const & entity):
-        context_(context), name_(name), entity_(entity)
-    { assert(entity.is()); }
+        manager_(manager), name_(name), entity_(entity)
+    { assert(manager.is()); assert(entity.is()); }
 
 private:
     virtual ~ModuleDescription() {}
@@ -130,7 +168,7 @@ private:
         css::uno::Reference< css::reflection::XTypeDescription > >
     SAL_CALL getMembers() throw (css::uno::RuntimeException);
 
-    css::uno::Reference< css::uno::XComponentContext > context_;
+    rtl::Reference< cppuhelper::TypeManager > manager_;
     rtl::OUString name_;
     rtl::Reference< unoidl::ModuleEntity > entity_;
 };
@@ -144,7 +182,7 @@ ModuleDescription::getMembers() throw (css::uno::RuntimeException) {
         css::uno::Sequence<
             css::uno::Reference< css::reflection::XTypeDescription > > s(n);
         for (sal_Int32 i = 0; i != n; ++i) {
-            s[i] = resolve(context_, name_ + "." + names[i]);
+            s[i] = manager_->resolve(name_ + "." + names[i]);
         }
         return s;
     } catch (unoidl::FileFormatException & e) {
@@ -222,12 +260,12 @@ PlainStructTypeDescription_Base;
 class PlainStructTypeDescription: public PlainStructTypeDescription_Base {
 public:
     PlainStructTypeDescription(
-        css::uno::Reference< css::uno::XComponentContext > const & context,
+        rtl::Reference< cppuhelper::TypeManager > const & manager,
         rtl::OUString const & name,
         rtl::Reference< unoidl::PlainStructTypeEntity > const & entity):
         PlainStructTypeDescription_Base(entity->isPublished()),
-        context_(context), name_(name), entity_(entity)
-    { assert(entity.is()); }
+        manager_(manager), name_(name), entity_(entity)
+    { assert(manager.is()); assert(entity.is()); }
 
 private:
     virtual ~PlainStructTypeDescription() {}
@@ -243,7 +281,7 @@ private:
     getBaseType() throw (css::uno::RuntimeException) {
         return entity_->getDirectBase().isEmpty()
             ? css::uno::Reference< css::reflection::XTypeDescription >()
-            : resolve(context_, entity_->getDirectBase());
+            : manager_->resolve(entity_->getDirectBase());
     }
 
     virtual
@@ -266,7 +304,7 @@ private:
             css::uno::Reference< css::reflection::XTypeDescription > >();
     }
 
-    css::uno::Reference< css::uno::XComponentContext > context_;
+    rtl::Reference< cppuhelper::TypeManager > manager_;
     rtl::OUString name_;
     rtl::Reference< unoidl::PlainStructTypeEntity > entity_;
 };
@@ -279,7 +317,7 @@ PlainStructTypeDescription::getMemberTypes() throw (css::uno::RuntimeException)
     css::uno::Sequence<
         css::uno::Reference< css::reflection::XTypeDescription > > s(n);
     for (sal_Int32 i = 0; i != n; ++i) {
-        s[i] = resolve(context_, entity_->getDirectMembers()[i].type);
+        s[i] = manager_->resolve(entity_->getDirectMembers()[i].type);
     }
     return s;
 }
@@ -297,8 +335,7 @@ css::uno::Sequence< rtl::OUString > PlainStructTypeDescription::getMemberNames()
 }
 
 class ParameterizedMemberTypeDescription:
-    public cppu::WeakImplHelper1< css::reflection::XTypeDescription >,
-    private boost::noncopyable
+    public cppu::WeakImplHelper1< css::reflection::XTypeDescription >
 {
 public:
     explicit ParameterizedMemberTypeDescription(
@@ -328,13 +365,13 @@ class PolymorphicStructTypeTemplateDescription:
 {
 public:
     PolymorphicStructTypeTemplateDescription(
-        css::uno::Reference< css::uno::XComponentContext > const & context,
+        rtl::Reference< cppuhelper::TypeManager > const & manager,
         rtl::OUString const & name,
         rtl::Reference< unoidl::PolymorphicStructTypeTemplateEntity > const &
             entity):
         PolymorphicStructTypeTemplateDescription_Base(entity->isPublished()),
-        context_(context), name_(name), entity_(entity)
-    { assert(entity.is()); }
+        manager_(manager), name_(name), entity_(entity)
+    { assert(manager.is()); assert(entity.is()); }
 
 private:
     virtual ~PolymorphicStructTypeTemplateDescription() {}
@@ -369,7 +406,7 @@ private:
             css::uno::Reference< css::reflection::XTypeDescription > >();
     }
 
-    css::uno::Reference< css::uno::XComponentContext > context_;
+    rtl::Reference< cppuhelper::TypeManager > manager_;
     rtl::OUString name_;
     rtl::Reference< unoidl::PolymorphicStructTypeTemplateEntity > entity_;
 };
@@ -386,7 +423,7 @@ PolymorphicStructTypeTemplateDescription::getMemberTypes()
         s[i] = entity_->getMembers()[i].parameterized
             ? new ParameterizedMemberTypeDescription(
                 entity_->getMembers()[i].type)
-            : resolve(context_, entity_->getMembers()[i].type);
+            : manager_->resolve(entity_->getMembers()[i].type);
     }
     return s;
 }
@@ -417,6 +454,114 @@ PolymorphicStructTypeTemplateDescription::getTypeParameters()
     return s;
 }
 
+class InstantiatedPolymorphicStructTypeDescription:
+    public cppu::WeakImplHelper1< css::reflection::XStructTypeDescription >
+{
+public:
+    InstantiatedPolymorphicStructTypeDescription(
+        rtl::Reference< cppuhelper::TypeManager > const & manager,
+        rtl::OUString const & name,
+        rtl::Reference< unoidl::PolymorphicStructTypeTemplateEntity > const &
+            entity,
+        std::vector< rtl::OUString > const & arguments):
+        manager_(manager), name_(name), entity_(entity), arguments_(arguments)
+    {
+        assert(manager.is());
+        assert(entity.is());
+        assert(arguments.size() == entity->getTypeParameters().size());
+    }
+
+private:
+    virtual ~InstantiatedPolymorphicStructTypeDescription() {}
+
+    virtual css::uno::TypeClass SAL_CALL getTypeClass()
+        throw (css::uno::RuntimeException)
+    { return css::uno::TypeClass_STRUCT; }
+
+    virtual rtl::OUString SAL_CALL getName() throw (css::uno::RuntimeException)
+    { return name_; }
+
+    virtual css::uno::Reference< css::reflection::XTypeDescription > SAL_CALL
+    getBaseType() throw (css::uno::RuntimeException)
+    { return css::uno::Reference< css::reflection::XTypeDescription >(); }
+
+    virtual
+    css::uno::Sequence<
+        css::uno::Reference< css::reflection::XTypeDescription > >
+    SAL_CALL getMemberTypes() throw (css::uno::RuntimeException);
+
+    virtual css::uno::Sequence< rtl::OUString > SAL_CALL getMemberNames()
+        throw (css::uno::RuntimeException);
+
+    virtual css::uno::Sequence< rtl::OUString > SAL_CALL getTypeParameters()
+        throw (css::uno::RuntimeException)
+    { return css::uno::Sequence< rtl::OUString >(); }
+
+    virtual
+    css::uno::Sequence<
+        css::uno::Reference< css::reflection::XTypeDescription > >
+    SAL_CALL getTypeArguments() throw (css::uno::RuntimeException);
+
+    rtl::Reference< cppuhelper::TypeManager > manager_;
+    rtl::OUString name_;
+    rtl::Reference< unoidl::PolymorphicStructTypeTemplateEntity > entity_;
+    std::vector< rtl::OUString > arguments_;
+};
+
+css::uno::Sequence< css::uno::Reference< css::reflection::XTypeDescription > >
+InstantiatedPolymorphicStructTypeDescription::getMemberTypes()
+    throw (css::uno::RuntimeException)
+{
+    assert(entity_->getMembers().size() <= SAL_MAX_INT32);
+    sal_Int32 n = static_cast< sal_Int32 >(entity_->getMembers().size());
+    css::uno::Sequence<
+        css::uno::Reference< css::reflection::XTypeDescription > > s(n);
+    for (sal_Int32 i = 0; i != n; ++i) {
+        rtl::OUString type(entity_->getMembers()[i].type);
+        if (entity_->getMembers()[i].parameterized) {
+            for (std::vector< rtl::OUString >::const_iterator j(
+                     entity_->getTypeParameters().begin());
+                 j != entity_->getTypeParameters().end(); ++j)
+            {
+                if (*j == type) {
+                    type = arguments_[j - entity_->getTypeParameters().begin()];
+                    goto found;
+                }
+            }
+            assert(false); // this cannot happen                         //TODO!
+        found:;
+        }
+        s[i] = manager_->resolve(type);
+    }
+    return s;
+}
+
+css::uno::Sequence< rtl::OUString >
+InstantiatedPolymorphicStructTypeDescription::getMemberNames()
+    throw (css::uno::RuntimeException)
+{
+    assert(entity_->getMembers().size() <= SAL_MAX_INT32);
+    sal_Int32 n = static_cast< sal_Int32 >(entity_->getMembers().size());
+    css::uno::Sequence< rtl::OUString > s(n);
+    for (sal_Int32 i = 0; i != n; ++i) {
+        s[i] = entity_->getMembers()[i].name;
+    }
+    return s;
+}
+css::uno::Sequence< css::uno::Reference< css::reflection::XTypeDescription > >
+InstantiatedPolymorphicStructTypeDescription::getTypeArguments()
+    throw (css::uno::RuntimeException)
+{
+    assert(arguments_.size() <= SAL_MAX_INT32);
+    sal_Int32 n = static_cast< sal_Int32 >(arguments_.size());
+    css::uno::Sequence<
+        css::uno::Reference< css::reflection::XTypeDescription > > s(n);
+    for (sal_Int32 i = 0; i != n; ++i) {
+        s[i] = manager_->resolve(arguments_[i]);
+    }
+    return s;
+}
+
 typedef cppu::ImplInheritanceHelper1<
     PublishableDescription, css::reflection::XCompoundTypeDescription >
 ExceptionTypeDescription_Base;
@@ -424,12 +569,12 @@ ExceptionTypeDescription_Base;
 class ExceptionTypeDescription: public ExceptionTypeDescription_Base {
 public:
     ExceptionTypeDescription(
-        css::uno::Reference< css::uno::XComponentContext > const & context,
+        rtl::Reference< cppuhelper::TypeManager > const & manager,
         rtl::OUString const & name,
         rtl::Reference< unoidl::ExceptionTypeEntity > const & entity):
-        ExceptionTypeDescription_Base(entity->isPublished()), context_(context),
+        ExceptionTypeDescription_Base(entity->isPublished()), manager_(manager),
         name_(name), entity_(entity)
-    { assert(entity.is()); }
+    { assert(manager.is()); assert(entity.is()); }
 
 private:
     virtual ~ExceptionTypeDescription() {}
@@ -445,7 +590,7 @@ private:
     getBaseType() throw (css::uno::RuntimeException) {
         return entity_->getDirectBase().isEmpty()
             ? css::uno::Reference< css::reflection::XTypeDescription >()
-            : resolve(context_, entity_->getDirectBase());
+            : manager_->resolve(entity_->getDirectBase());
     }
 
     virtual
@@ -456,7 +601,7 @@ private:
     virtual css::uno::Sequence< rtl::OUString > SAL_CALL getMemberNames()
         throw (css::uno::RuntimeException);
 
-    css::uno::Reference< css::uno::XComponentContext > context_;
+    rtl::Reference< cppuhelper::TypeManager > manager_;
     rtl::OUString name_;
     rtl::Reference< unoidl::ExceptionTypeEntity > entity_;
 };
@@ -468,7 +613,7 @@ ExceptionTypeDescription::getMemberTypes() throw (css::uno::RuntimeException) {
     css::uno::Sequence<
         css::uno::Reference< css::reflection::XTypeDescription > > s(n);
     for (sal_Int32 i = 0; i != n; ++i) {
-        s[i] = resolve(context_, entity_->getDirectMembers()[i].type);
+        s[i] = manager_->resolve(entity_->getDirectMembers()[i].type);
     }
     return s;
 }
@@ -485,86 +630,19 @@ css::uno::Sequence< rtl::OUString > ExceptionTypeDescription::getMemberNames()
     return s;
 }
 
-css::uno::Reference< css::reflection::XTypeDescription > resolveTypedefs(
-    css::uno::Reference< css::reflection::XTypeDescription > const & type)
-{
-    css::uno::Reference< css::reflection::XTypeDescription > resolved(type);
-    while (resolved->getTypeClass() == css::uno::TypeClass_TYPEDEF) {
-        resolved
-            = (css::uno::Reference< css::reflection::XIndirectTypeDescription >(
-                   resolved, css::uno::UNO_QUERY_THROW)->
-               getReferencedType());
-    }
-    return resolved;
-}
-
-class BaseOffset: private boost::noncopyable {
-public:
-    BaseOffset(
-        css::uno::Reference< css::reflection::XInterfaceTypeDescription2 >
-            const & description);
-
-    sal_Int32 get() const { return offset_; }
-
-private:
-    void calculateBases(
-        css::uno::Reference< css::reflection::XInterfaceTypeDescription2 >
-            const & description);
-
-    void calculate(
-        css::uno::Reference< css::reflection::XInterfaceTypeDescription2 >
-            const & description);
-
-    std::set< rtl::OUString > set_;
-    sal_Int32 offset_;
-};
-
-BaseOffset::BaseOffset(
-    css::uno::Reference< css::reflection::XInterfaceTypeDescription2 > const &
-        description):
-    offset_(0)
-{
-    calculateBases(description);
-}
-
-void BaseOffset::calculateBases(
-    css::uno::Reference< css::reflection::XInterfaceTypeDescription2 > const &
-        description)
-{
-    css::uno::Sequence<
-        css::uno::Reference < css::reflection::XTypeDescription > > bases(
-            description->getBaseTypes());
-    for (sal_Int32 i = 0; i != bases.getLength(); ++i) {
-        calculate(
-            css::uno::Reference< css::reflection::XInterfaceTypeDescription2 >(
-                resolveTypedefs(bases[i]), css::uno::UNO_QUERY_THROW));
-    }
-}
-
-void BaseOffset::calculate(
-    css::uno::Reference< css::reflection::XInterfaceTypeDescription2 > const &
-        description)
-{
-    if (set_.insert(description->getName()).second) {
-        calculateBases(description);
-        offset_ += description->getMembers().getLength();
-    }
-}
-
 class AttributeDescription:
     public cppu::WeakImplHelper1<
-        css::reflection::XInterfaceAttributeTypeDescription2 >,
-    private boost::noncopyable
+        css::reflection::XInterfaceAttributeTypeDescription2 >
 {
 public:
     AttributeDescription(
-        css::uno::Reference< css::uno::XComponentContext > const & context,
+        rtl::Reference< cppuhelper::TypeManager > const & manager,
         rtl::OUString const & name,
         unoidl::InterfaceTypeEntity::Attribute const & attribute,
         sal_Int32 position):
-        context_(context), name_(name), attribute_(attribute),
+        manager_(manager), name_(name), attribute_(attribute),
         position_(position)
-    {}
+    { assert(manager.is()); }
 
 private:
     virtual ~AttributeDescription() {}
@@ -588,7 +666,7 @@ private:
 
     virtual css::uno::Reference< css::reflection::XTypeDescription > SAL_CALL
     getType() throw (css::uno::RuntimeException)
-    { return resolve(context_, attribute_.type); }
+    { return manager_->resolve(attribute_.type); }
 
     virtual sal_Bool SAL_CALL isBound() throw (css::uno::RuntimeException)
     { return attribute_.bound; }
@@ -603,7 +681,7 @@ private:
         css::uno::Reference< css::reflection::XCompoundTypeDescription > >
     SAL_CALL getSetExceptions() throw (css::uno::RuntimeException);
 
-    css::uno::Reference< css::uno::XComponentContext > context_;
+    rtl::Reference< cppuhelper::TypeManager > manager_;
     rtl::OUString name_;
     unoidl::InterfaceTypeEntity::Attribute attribute_;
     sal_Int32 position_;
@@ -618,7 +696,7 @@ AttributeDescription::getGetExceptions() throw (css::uno::RuntimeException) {
         css::uno::Reference< css::reflection::XCompoundTypeDescription > > s(n);
     for (sal_Int32 i = 0; i != n; ++i) {
         s[i].set(
-            resolve(context_, attribute_.getExceptions[i]),
+            manager_->resolve(attribute_.getExceptions[i]),
             css::uno::UNO_QUERY_THROW);
     }
     return s;
@@ -633,23 +711,22 @@ AttributeDescription::getSetExceptions() throw (css::uno::RuntimeException) {
         css::uno::Reference< css::reflection::XCompoundTypeDescription > > s(n);
     for (sal_Int32 i = 0; i != n; ++i) {
         s[i].set(
-            resolve(context_, attribute_.setExceptions[i]),
+            manager_->resolve(attribute_.setExceptions[i]),
             css::uno::UNO_QUERY_THROW);
     }
     return s;
 }
 
 class MethodParameter:
-    public cppu::WeakImplHelper1< css::reflection::XMethodParameter >,
-    private boost::noncopyable
+    public cppu::WeakImplHelper1< css::reflection::XMethodParameter >
 {
 public:
     MethodParameter(
-        css::uno::Reference< css::uno::XComponentContext > const & context,
+        rtl::Reference< cppuhelper::TypeManager > const & manager,
         unoidl::InterfaceTypeEntity::Method::Parameter const & parameter,
         sal_Int32 position):
-        context_(context), parameter_(parameter), position_(position)
-    {}
+        manager_(manager), parameter_(parameter), position_(position)
+    { assert(manager.is()); }
 
 private:
     virtual ~MethodParameter() {}
@@ -659,7 +736,7 @@ private:
 
     virtual css::uno::Reference< css::reflection::XTypeDescription > SAL_CALL
     getType() throw (css::uno::RuntimeException)
-    { return resolve(context_, parameter_.type); }
+    { return manager_->resolve(parameter_.type); }
 
     virtual sal_Bool SAL_CALL isIn() throw (css::uno::RuntimeException) {
         return
@@ -682,23 +759,22 @@ private:
     virtual sal_Int32 SAL_CALL getPosition() throw (css::uno::RuntimeException)
     { return position_; }
 
-    css::uno::Reference< css::uno::XComponentContext > context_;
+    rtl::Reference< cppuhelper::TypeManager > manager_;
     unoidl::InterfaceTypeEntity::Method::Parameter parameter_;
     sal_Int32 position_;
 };
 
 class MethodDescription:
     public cppu::WeakImplHelper1<
-        css::reflection::XInterfaceMethodTypeDescription >,
-    private boost::noncopyable
+        css::reflection::XInterfaceMethodTypeDescription >
 {
 public:
     MethodDescription(
-        css::uno::Reference< css::uno::XComponentContext > const & context,
+        rtl::Reference< cppuhelper::TypeManager > const & manager,
         rtl::OUString const & name,
         unoidl::InterfaceTypeEntity::Method const & method, sal_Int32 position):
-        context_(context), name_(name), method_(method), position_(position)
-    {}
+        manager_(manager), name_(name), method_(method), position_(position)
+    { assert(manager.is()); }
 
 private:
     virtual ~MethodDescription() {}
@@ -719,7 +795,7 @@ private:
 
     virtual css::uno::Reference< css::reflection::XTypeDescription > SAL_CALL
     getReturnType() throw (css::uno::RuntimeException)
-    { return resolve(context_, method_.returnType); }
+    { return manager_->resolve(method_.returnType); }
 
     virtual sal_Bool SAL_CALL isOneway() throw (css::uno::RuntimeException)
     { return false; }
@@ -734,7 +810,7 @@ private:
         css::uno::Reference< css::reflection::XTypeDescription > >
     SAL_CALL getExceptions() throw (css::uno::RuntimeException);
 
-    css::uno::Reference< css::uno::XComponentContext > context_;
+    rtl::Reference< cppuhelper::TypeManager > manager_;
     rtl::OUString name_;
     unoidl::InterfaceTypeEntity::Method method_;
     sal_Int32 position_;
@@ -747,7 +823,7 @@ MethodDescription::getParameters() throw (css::uno::RuntimeException) {
     css::uno::Sequence<
         css::uno::Reference< css::reflection::XMethodParameter > > s(n);
     for (sal_Int32 i = 0; i != n; ++i) {
-        s[i] = new MethodParameter(context_, method_.parameters[i], i);
+        s[i] = new MethodParameter(manager_, method_.parameters[i], i);
     }
     return s;
 }
@@ -759,11 +835,65 @@ MethodDescription::getExceptions() throw (css::uno::RuntimeException) {
     css::uno::Sequence<
         css::uno::Reference< css::reflection::XTypeDescription > > s(n);
     for (sal_Int32 i = 0; i != n; ++i) {
-        s[i] = resolve(context_, method_.exceptions[i]);
+        s[i] = manager_->resolve(method_.exceptions[i]);
     }
     return s;
 }
 
+class BaseOffset: private boost::noncopyable {
+public:
+    BaseOffset(
+        css::uno::Reference< css::reflection::XInterfaceTypeDescription2 >
+            const & description);
+
+    sal_Int32 get() const { return offset_; }
+
+private:
+    void calculateBases(
+        css::uno::Reference< css::reflection::XInterfaceTypeDescription2 >
+            const & description);
+
+    void calculate(
+        css::uno::Reference< css::reflection::XInterfaceTypeDescription2 >
+            const & description);
+
+    std::set< rtl::OUString > set_;
+    sal_Int32 offset_;
+};
+
+BaseOffset::BaseOffset(
+    css::uno::Reference< css::reflection::XInterfaceTypeDescription2 > const &
+        description):
+    offset_(0)
+{
+    calculateBases(description);
+}
+
+void BaseOffset::calculateBases(
+    css::uno::Reference< css::reflection::XInterfaceTypeDescription2 > const &
+        description)
+{
+    css::uno::Sequence<
+        css::uno::Reference < css::reflection::XTypeDescription > > bases(
+            description->getBaseTypes());
+    for (sal_Int32 i = 0; i != bases.getLength(); ++i) {
+        calculate(
+            css::uno::Reference< css::reflection::XInterfaceTypeDescription2 >(
+                resolveTypedefs(css::uno::makeAny(bases[i])),
+                css::uno::UNO_QUERY_THROW));
+    }
+}
+
+void BaseOffset::calculate(
+    css::uno::Reference< css::reflection::XInterfaceTypeDescription2 > const &
+        description)
+{
+    if (set_.insert(description->getName()).second) {
+        calculateBases(description);
+        offset_ += description->getMembers().getLength();
+    }
+}
+
 typedef cppu::ImplInheritanceHelper1<
     PublishableDescription, css::reflection::XInterfaceTypeDescription2 >
 InterfaceTypeDescription_Base;
@@ -771,12 +901,12 @@ InterfaceTypeDescription_Base;
 class InterfaceTypeDescription: public InterfaceTypeDescription_Base {
 public:
     InterfaceTypeDescription(
-        css::uno::Reference< css::uno::XComponentContext > const & context,
+        rtl::Reference< cppuhelper::TypeManager > const & manager,
         rtl::OUString const & name,
         rtl::Reference< unoidl::InterfaceTypeEntity > const & entity):
-        InterfaceTypeDescription_Base(entity->isPublished()), context_(context),
+        InterfaceTypeDescription_Base(entity->isPublished()), manager_(manager),
         name_(name), entity_(entity)
-    { assert(entity.is()); }
+    { assert(manager.is()); assert(entity.is()); }
 
 private:
     virtual ~InterfaceTypeDescription() {}
@@ -792,7 +922,7 @@ private:
     getBaseType() throw (css::uno::RuntimeException) {
         return entity_->getDirectMandatoryBases().empty()
             ? css::uno::Reference< css::reflection::XTypeDescription >()
-            : resolve(context_, entity_->getDirectMandatoryBases()[0]);
+            : manager_->resolve(entity_->getDirectMandatoryBases()[0]);
     }
 
     virtual css::uno::Uik SAL_CALL getUik() throw (css::uno::RuntimeException)
@@ -814,7 +944,7 @@ private:
         css::uno::Reference< css::reflection::XTypeDescription > >
     SAL_CALL getOptionalBaseTypes() throw (css::uno::RuntimeException);
 
-    css::uno::Reference< css::uno::XComponentContext > context_;
+    rtl::Reference< cppuhelper::TypeManager > manager_;
     rtl::OUString name_;
     rtl::Reference< unoidl::InterfaceTypeEntity > entity_;
 };
@@ -835,12 +965,12 @@ InterfaceTypeDescription::getMembers() throw (css::uno::RuntimeException) {
     sal_Int32 off = BaseOffset(this).get();
     for (sal_Int32 i = 0; i != n1; ++i) {
         s[i] = new AttributeDescription(
-            context_, name_ + "::" + entity_->getDirectAttributes()[i].name,
+            manager_, name_ + "::" + entity_->getDirectAttributes()[i].name,
             entity_->getDirectAttributes()[i], off + i);
     }
     for (sal_Int32 i = 0; i != n2; ++i) {
         s[n1 + i] = new MethodDescription(
-            context_, name_ + "::" + entity_->getDirectMethods()[i].name,
+            manager_, name_ + "::" + entity_->getDirectMethods()[i].name,
             entity_->getDirectMethods()[i], off + n1 + i);
     }
     return s;
@@ -854,7 +984,7 @@ InterfaceTypeDescription::getBaseTypes() throw (css::uno::RuntimeException) {
     css::uno::Sequence<
         css::uno::Reference< css::reflection::XTypeDescription > > s(n);
     for (sal_Int32 i = 0; i != n; ++i) {
-        s[i] = resolve(context_, entity_->getDirectMandatoryBases()[i]);
+        s[i] = manager_->resolve(entity_->getDirectMandatoryBases()[i]);
     }
     return s;
 }
@@ -869,20 +999,17 @@ InterfaceTypeDescription::getOptionalBaseTypes()
     css::uno::Sequence<
         css::uno::Reference< css::reflection::XTypeDescription > > s(n);
     for (sal_Int32 i = 0; i != n; ++i) {
-        s[i] = resolve(context_, entity_->getDirectOptionalBases()[i]);
+        s[i] = manager_->resolve(entity_->getDirectOptionalBases()[i]);
     }
     return s;
 }
 
 class ConstantDescription:
-    public cppu::WeakImplHelper1< css::reflection::XConstantTypeDescription >,
-    private boost::noncopyable
+    public cppu::WeakImplHelper1< css::reflection::XConstantTypeDescription >
 {
 public:
-    ConstantDescription(
-        rtl::OUString const & name, css::uno::Any const & value):
-        name_(name), value_(value)
-    {}
+    explicit ConstantDescription(
+        unoidl::ConstantGroupEntity::Member const & member);
 
 private:
     virtual ~ConstantDescription() {}
@@ -902,6 +1029,46 @@ private:
     css::uno::Any value_;
 };
 
+ConstantDescription::ConstantDescription(
+    unoidl::ConstantGroupEntity::Member const & member):
+    name_(member.name)
+{
+    switch (member.value.type) {
+    case unoidl::ConstantValue::TYPE_BOOLEAN:
+        value_ <<= member.value.booleanValue;
+        break;
+    case unoidl::ConstantValue::TYPE_BYTE:
+        value_ <<= member.value.byteValue;
+        break;
+    case unoidl::ConstantValue::TYPE_SHORT:
+        value_ <<= member.value.shortValue;
+        break;
+    case unoidl::ConstantValue::TYPE_UNSIGNED_SHORT:
+        value_ <<= member.value.unsignedShortValue;
+        break;
+    case unoidl::ConstantValue::TYPE_LONG:
+        value_ <<= member.value.longValue;
+        break;
+    case unoidl::ConstantValue::TYPE_UNSIGNED_LONG:
+        value_ <<= member.value.unsignedLongValue;
+        break;
+    case unoidl::ConstantValue::TYPE_HYPER:
+        value_ <<= member.value.hyperValue;
+        break;
+    case unoidl::ConstantValue::TYPE_UNSIGNED_HYPER:
+        value_ <<= member.value.unsignedHyperValue;
+        break;
+    case unoidl::ConstantValue::TYPE_FLOAT:
+        value_ <<= member.value.floatValue;
+        break;
+    case unoidl::ConstantValue::TYPE_DOUBLE:
+        value_ <<= member.value.doubleValue;
+        break;
+    default:
+        for (;;) { std::abort(); } // this cannot happen
+    }
+}
+
 typedef cppu::ImplInheritanceHelper1<
     PublishableDescription, css::reflection::XConstantsTypeDescription >
 ConstantGroupDescription_Base;
@@ -909,11 +1076,10 @@ ConstantGroupDescription_Base;
 class ConstantGroupDescription: public ConstantGroupDescription_Base {
 public:
     ConstantGroupDescription(
-        css::uno::Reference< css::uno::XComponentContext > const & context,
         rtl::OUString const & name,
         rtl::Reference< unoidl::ConstantGroupEntity > const & entity):
-        ConstantGroupDescription_Base(entity->isPublished()), context_(context),
-        name_(name), entity_(entity)
+        ConstantGroupDescription_Base(entity->isPublished()), name_(name),
+        entity_(entity)
     { assert(entity.is()); }
 
 private:
@@ -931,7 +1097,6 @@ private:
         css::uno::Reference< css::reflection::XConstantTypeDescription > >
     SAL_CALL getConstants() throw (css::uno::RuntimeException);
 
-    css::uno::Reference< css::uno::XComponentContext > context_;
     rtl::OUString name_;
     rtl::Reference< unoidl::ConstantGroupEntity > entity_;
 };
@@ -944,10 +1109,7 @@ ConstantGroupDescription::getConstants() throw (css::uno::RuntimeException) {
     css::uno::Sequence<
         css::uno::Reference< css::reflection::XConstantTypeDescription > > s(n);
     for (sal_Int32 i = 0; i != n; ++i) {
-        //TODO: use entity_->getMembers()[i].value directly?
-        s[i].set(
-            resolve(context_, name_ + "." + entity_->getMembers()[i].name),
-            css::uno::UNO_QUERY_THROW);
+        s[i] = new ConstantDescription(entity_->getMembers()[i]);
     }
     return s;
 }
@@ -959,12 +1121,12 @@ TypedefDescription_Base;
 class TypedefDescription: public TypedefDescription_Base {
 public:
     TypedefDescription(
-        css::uno::Reference< css::uno::XComponentContext > const & context,
+        rtl::Reference< cppuhelper::TypeManager > const & manager,
         rtl::OUString const & name,
         rtl::Reference< unoidl::TypedefEntity > const & entity):
-        TypedefDescription_Base(entity->isPublished()), context_(context),
+        TypedefDescription_Base(entity->isPublished()), manager_(manager),
         name_(name), entity_(entity)
-    { assert(entity.is()); }
+    { assert(manager.is()); assert(entity.is()); }
 
 private:
     virtual ~TypedefDescription() {}
@@ -978,25 +1140,24 @@ private:
 
     virtual css::uno::Reference< css::reflection::XTypeDescription > SAL_CALL
     getReferencedType() throw (css::uno::RuntimeException)
-    { return resolve(context_, entity_->getType()); }
+    { return manager_->resolve(entity_->getType()); }
 
-    css::uno::Reference< css::uno::XComponentContext > context_;
+    rtl::Reference< cppuhelper::TypeManager > manager_;
     rtl::OUString name_;
     rtl::Reference< unoidl::TypedefEntity > entity_;
 };
 
 class ConstructorParameter:
-    public cppu::WeakImplHelper1< css::reflection::XParameter >,
-    private boost::noncopyable
+    public cppu::WeakImplHelper1< css::reflection::XParameter >
 {
 public:
     ConstructorParameter(
-        css::uno::Reference< css::uno::XComponentContext > const & context,
+        rtl::Reference< cppuhelper::TypeManager > const & manager,
         unoidl::SingleInterfaceBasedServiceEntity::Constructor::Parameter
             const & parameter,
         sal_Int32 position):
-        context_(context), parameter_(parameter), position_(position)
-    {}
+        manager_(manager), parameter_(parameter), position_(position)
+    { assert(manager.is()); }
 
 private:
     virtual ~ConstructorParameter() {}
@@ -1006,7 +1167,7 @@ private:
 
     virtual css::uno::Reference< css::reflection::XTypeDescription > SAL_CALL
     getType() throw (css::uno::RuntimeException)
-    { return resolve(context_, parameter_.type); }
+    { return manager_->resolve(parameter_.type); }
 
     virtual sal_Bool SAL_CALL isIn() throw (css::uno::RuntimeException)
     { return true; }
@@ -1021,7 +1182,7 @@ private:
         throw (css::uno::RuntimeException)
     { return parameter_.rest; }
 
-    css::uno::Reference< css::uno::XComponentContext > context_;
+    rtl::Reference< cppuhelper::TypeManager > manager_;
     unoidl::SingleInterfaceBasedServiceEntity::Constructor::Parameter
         parameter_;
     sal_Int32 position_;
@@ -1029,16 +1190,15 @@ private:
 
 class ConstructorDescription:
     public cppu::WeakImplHelper1<
-        css::reflection::XServiceConstructorDescription >,
-    private boost::noncopyable
+        css::reflection::XServiceConstructorDescription >
 {
 public:
     ConstructorDescription(
-        css::uno::Reference< css::uno::XComponentContext > const & context,
+        rtl::Reference< cppuhelper::TypeManager > const & manager,
         unoidl::SingleInterfaceBasedServiceEntity::Constructor const &
             constructor):
-        context_(context), constructor_(constructor)
-    {}
+        manager_(manager), constructor_(constructor)
+    { assert(manager.is()); }
 
 private:
     virtual ~ConstructorDescription() {}
@@ -1060,7 +1220,7 @@ private:
         css::uno::Reference< css::reflection::XCompoundTypeDescription > >
     SAL_CALL getExceptions() throw (css::uno::RuntimeException);
 
-    css::uno::Reference< css::uno::XComponentContext > context_;
+    rtl::Reference< cppuhelper::TypeManager > manager_;
     unoidl::SingleInterfaceBasedServiceEntity::Constructor constructor_;
 };
 
@@ -1072,7 +1232,7 @@ ConstructorDescription::getParameters() throw (css::uno::RuntimeException) {
         n);
     for (sal_Int32 i = 0; i != n; ++i) {
         s[i] = new ConstructorParameter(
-            context_, constructor_.parameters[i], i);
+            manager_, constructor_.parameters[i], i);
     }
     return s;
 }
@@ -1086,7 +1246,7 @@ ConstructorDescription::getExceptions() throw (css::uno::RuntimeException) {
         css::uno::Reference< css::reflection::XCompoundTypeDescription > > s(n);
     for (sal_Int32 i = 0; i != n; ++i) {
         s[i].set(
-            resolve(context_, constructor_.exceptions[i]),
+            manager_->resolve(constructor_.exceptions[i]),
             css::uno::UNO_QUERY_THROW);
     }
     return s;
@@ -1101,13 +1261,13 @@ class SingleInterfaceBasedServiceDescription:
 {
 public:
     SingleInterfaceBasedServiceDescription(
-        css::uno::Reference< css::uno::XComponentContext > const & context,
+        rtl::Reference< cppuhelper::TypeManager > const & manager,
         rtl::OUString const & name,
         rtl::Reference< unoidl::SingleInterfaceBasedServiceEntity > const &
             entity):
         SingleInterfaceBasedServiceDescription_Base(entity->isPublished()),
-        context_(context), name_(name), entity_(entity)
-    { assert(entity.is()); }
+        manager_(manager), name_(name), entity_(entity)
+    { assert(manager.is()); assert(entity.is()); }
 
 private:
     virtual ~SingleInterfaceBasedServiceDescription() {}
@@ -1173,14 +1333,14 @@ private:
 
     virtual css::uno::Reference< css::reflection::XTypeDescription > SAL_CALL
     getInterface() throw (css::uno::RuntimeException)
-    { return resolve(context_, entity_->getBase()); }
+    { return manager_->resolve(entity_->getBase()); }
 
     virtual
     css::uno::Sequence<
         css::uno::Reference< css::reflection::XServiceConstructorDescription > >
     SAL_CALL getConstructors() throw (css::uno::RuntimeException);
 
-    css::uno::Reference< css::uno::XComponentContext > context_;
+    rtl::Reference< cppuhelper::TypeManager > manager_;
     rtl::OUString name_;
     rtl::Reference< unoidl::SingleInterfaceBasedServiceEntity > entity_;
 };
@@ -1197,21 +1357,20 @@ SingleInterfaceBasedServiceDescription::getConstructors()
             s(n);
     for (sal_Int32 i = 0; i != n; ++i) {
         s[i] = new ConstructorDescription(
-            context_, entity_->getConstructors()[i]);
+            manager_, entity_->getConstructors()[i]);
     }
     return s;
 }
 
 class PropertyDescription:
-    public cppu::WeakImplHelper1< css::reflection::XPropertyTypeDescription >,
-    private boost::noncopyable
+    public cppu::WeakImplHelper1< css::reflection::XPropertyTypeDescription >
 {
 public:
     PropertyDescription(
-        css::uno::Reference< css::uno::XComponentContext > const & context,
+        rtl::Reference< cppuhelper::TypeManager > const & manager,
         unoidl::AccumulationBasedServiceEntity::Property const & property):
-        context_(context), property_(property)
-    {}
+        manager_(manager), property_(property)
+    { assert(manager.is()); }
 
 private:
     virtual ~PropertyDescription() {}
@@ -1229,9 +1388,9 @@ private:
 
     virtual css::uno::Reference< css::reflection::XTypeDescription > SAL_CALL
     getPropertyTypeDescription() throw (css::uno::RuntimeException)
-    { return resolve(context_, property_.type); }
+    { return manager_->resolve(property_.type); }
 
-    css::uno::Reference< css::uno::XComponentContext > context_;
+    rtl::Reference< cppuhelper::TypeManager > manager_;
     unoidl::AccumulationBasedServiceEntity::Property property_;
 };
 
@@ -1244,13 +1403,13 @@ class AccumulationBasedServiceDescription:
 {
 public:
     AccumulationBasedServiceDescription(
-        css::uno::Reference< css::uno::XComponentContext > const & context,
+        rtl::Reference< cppuhelper::TypeManager > const & manager,
         rtl::OUString const & name,
         rtl::Reference< unoidl::AccumulationBasedServiceEntity > const &
             entity):
         AccumulationBasedServiceDescription_Base(entity->isPublished()),
-        context_(context), name_(name), entity_(entity)
-    { assert(entity.is()); }
+        manager_(manager), name_(name), entity_(entity)
+    { assert(manager.is()); assert(entity.is()); }
 
 private:
     virtual ~AccumulationBasedServiceDescription() {}
@@ -1305,7 +1464,7 @@ private:
                 css::reflection::XServiceConstructorDescription > >();
     }
 
-    css::uno::Reference< css::uno::XComponentContext > context_;
+    rtl::Reference< cppuhelper::TypeManager > manager_;
     rtl::OUString name_;
     rtl::Reference< unoidl::AccumulationBasedServiceEntity > entity_;
 };
@@ -1322,7 +1481,7 @@ AccumulationBasedServiceDescription::getMandatoryServices()
         css::uno::Reference< css::reflection::XServiceTypeDescription > > s(n);
     for (sal_Int32 i = 0; i != n; ++i) {
         s[i].set(
-            resolve(context_, entity_->getDirectMandatoryBaseServices()[i]),
+            manager_->resolve(entity_->getDirectMandatoryBaseServices()[i]),
             css::uno::UNO_QUERY_THROW);
     }
     return s;
@@ -1340,7 +1499,7 @@ AccumulationBasedServiceDescription::getOptionalServices()
         css::uno::Reference< css::reflection::XServiceTypeDescription > > s(n);
     for (sal_Int32 i = 0; i != n; ++i) {
         s[i].set(
-            resolve(context_, entity_->getDirectOptionalBaseServices()[i]),
+            manager_->resolve(entity_->getDirectOptionalBaseServices()[i]),
             css::uno::UNO_QUERY_THROW);
     }
     return s;
@@ -1360,8 +1519,8 @@ AccumulationBasedServiceDescription::getMandatoryInterfaces()
     for (sal_Int32 i = 0; i != n; ++i) {
         s[i].set(
             resolveTypedefs(
-                resolve(
-                    context_, entity_->getDirectMandatoryBaseInterfaces()[i])),
+                manager_->find(
+                    entity_->getDirectMandatoryBaseInterfaces()[i])),
             css::uno::UNO_QUERY_THROW);
     }
     return s;
@@ -1381,8 +1540,8 @@ AccumulationBasedServiceDescription::getOptionalInterfaces()
     for (sal_Int32 i = 0; i != n; ++i) {
         s[i].set(
             resolveTypedefs(
-                resolve(
-                    context_, entity_->getDirectOptionalBaseInterfaces()[i])),
+                manager_->find(
+                    entity_->getDirectOptionalBaseInterfaces()[i])),
             css::uno::UNO_QUERY_THROW);
     }
     return s;
@@ -1400,7 +1559,7 @@ AccumulationBasedServiceDescription::getProperties()
         css::uno::Reference< css::reflection::XPropertyTypeDescription > > s(n);
     for (sal_Int32 i = 0; i != n; ++i) {
         s[i] = new PropertyDescription(
-            context_, entity_->getDirectProperties()[i]);
+            manager_, entity_->getDirectProperties()[i]);
     }
     return s;
 }
@@ -1414,12 +1573,12 @@ class InterfaceBasedSingletonDescription:
 {
 public:
     InterfaceBasedSingletonDescription(
-        css::uno::Reference< css::uno::XComponentContext > const & context,
+        rtl::Reference< cppuhelper::TypeManager > const & manager,
         rtl::OUString const & name,
         rtl::Reference< unoidl::InterfaceBasedSingletonEntity > const & entity):
         InterfaceBasedSingletonDescription_Base(entity->isPublished()),
-        context_(context), name_(name), entity_(entity)
-    { assert(entity.is()); }
+        manager_(manager), name_(name), entity_(entity)
+    { assert(manager.is()); assert(entity.is()); }
 
 private:
     virtual ~InterfaceBasedSingletonDescription() {}
@@ -1444,9 +1603,9 @@ private:
 
     virtual css::uno::Reference< css::reflection::XTypeDescription >
     SAL_CALL getInterface() throw (css::uno::RuntimeException)
-    { return resolve(context_, entity_->getBase()); }
+    { return manager_->resolve(entity_->getBase()); }
 
-    css::uno::Reference< css::uno::XComponentContext > context_;
+    rtl::Reference< cppuhelper::TypeManager > manager_;
     rtl::OUString name_;
     rtl::Reference< unoidl::InterfaceBasedSingletonEntity > entity_;
 };
@@ -1460,12 +1619,12 @@ class ServiceBasedSingletonDescription:
 {
 public:
     ServiceBasedSingletonDescription(
-        css::uno::Reference< css::uno::XComponentContext > const & context,
+        rtl::Reference< cppuhelper::TypeManager > const & manager,
         rtl::OUString const & name,
         rtl::Reference< unoidl::ServiceBasedSingletonEntity > const & entity):
         ServiceBasedSingletonDescription_Base(entity_->isPublished()),
-        context_(context), name_(name), entity_(entity)
-    { assert(entity.is()); }
+        manager_(manager), name_(name), entity_(entity)
+    { assert(manager.is()); assert(entity.is()); }
 
 private:
     virtual ~ServiceBasedSingletonDescription() {}
@@ -1481,7 +1640,7 @@ private:
     SAL_CALL getService() throw (css::uno::RuntimeException)
     {
         return css::uno::Reference< css::reflection::XServiceTypeDescription >(
-            resolve(context_, entity_->getBase()), css::uno::UNO_QUERY_THROW);
+            manager_->resolve(entity_->getBase()), css::uno::UNO_QUERY_THROW);
     }
 
     virtual sal_Bool SAL_CALL isInterfaceBased()
@@ -1492,24 +1651,23 @@ private:
     SAL_CALL getInterface() throw (css::uno::RuntimeException)
     { return css::uno::Reference< css::reflection::XTypeDescription >(); }
 
-    css::uno::Reference< css::uno::XComponentContext > context_;
+    rtl::Reference< cppuhelper::TypeManager > manager_;
     rtl::OUString name_;
     rtl::Reference< unoidl::ServiceBasedSingletonEntity > entity_;
 };
 
 class Enumeration:
-    public cppu::WeakImplHelper1<
-        css::reflection::XTypeDescriptionEnumeration >,
-    private boost::noncopyable
+    public cppu::WeakImplHelper1< css::reflection::XTypeDescriptionEnumeration >
 {
 public:
     Enumeration(
-        css::uno::Reference< css::uno::XComponentContext > const & context,
+        rtl::Reference< cppuhelper::TypeManager > const & manager,
         rtl::OUString const & prefix,
         rtl::Reference< unoidl::MapCursor > const & cursor,
         css::uno::Sequence< css::uno::TypeClass > const & types, bool deep):
-        context_(context), types_(types), deep_(deep)
+        manager_(manager), types_(types), deep_(deep)
     {
+        assert(manager.is());
         positions_.push(Position(prefix, cursor));
         findNextMatch();
     }
@@ -1558,7 +1716,7 @@ private:
             constantGroupIndex;
     };
 
-    css::uno::Reference< css::uno::XComponentContext > context_;
+    rtl::Reference< cppuhelper::TypeManager > manager_;
     css::uno::Sequence< css::uno::TypeClass > types_;
     bool deep_;
 
@@ -1582,7 +1740,7 @@ Enumeration::nextTypeDescription()
         name = current_;
         findNextMatch();
     }
-    return resolve(context_, name);
+    return manager_->resolve(name);
 }
 
 bool Enumeration::matches(css::uno::TypeClass tc) const {
@@ -1688,324 +1846,259 @@ void Enumeration::findNextMatch() {
     }
 }
 
-typedef cppu::WeakComponentImplHelper2<
-    css::container::XHierarchicalNameAccess,
-    css::reflection::XTypeDescriptionEnumerationAccess >
-Provider_Base;
+}
 
-class Provider:
-    private osl::Mutex, public Provider_Base, private boost::noncopyable
+cppuhelper::TypeManager::TypeManager(rtl::OUString const & rdbUris):
+    TypeManager_Base(*static_cast< osl::Mutex * >(this)),
+    manager_(new unoidl::Manager)
 {
-public:
-    // throws unoidl::FileFormatException, unoidl::NoSuchFileException:
-    Provider(
-        css::uno::Reference< css::uno::XComponentContext > const & context,
-        rtl::OUString const & uri):
-        Provider_Base(*static_cast< osl::Mutex * >(this)), context_(context),
-        provider_(new unoidl::UnoidlProvider(uri))
-    {}
-
-    using Provider_Base::acquire;
-    using Provider_Base::release;
-
-private:
-    virtual ~Provider() {}
-
-    virtual void SAL_CALL disposing() {} //TODO
-
-    virtual css::uno::Any SAL_CALL getByHierarchicalName(
-        rtl::OUString const & aName)
-        throw (
-            css::container::NoSuchElementException, css::uno::RuntimeException);
-
-    virtual sal_Bool SAL_CALL hasByHierarchicalName(
-        rtl::OUString const & aName) throw (css::uno::RuntimeException);
-
-    virtual css::uno::Reference< css::reflection::XTypeDescriptionEnumeration >
-    SAL_CALL createTypeDescriptionEnumeration(
-        rtl::OUString const & moduleName,
-        css::uno::Sequence< css::uno::TypeClass > const & types,
-        css::reflection::TypeDescriptionSearchDepth depth)
-        throw(
-            css::reflection::NoSuchTypeNameException,
-            css::reflection::InvalidTypeNameException,
-            css::uno::RuntimeException);
-
-    css::uno::Reference< css::uno::XComponentContext > context_;
-    rtl::Reference< unoidl::UnoidlProvider > provider_;
-};
+    readRdbs(rdbUris);
+}
 
-css::uno::Any Provider::getByHierarchicalName(rtl::OUString const & aName)
-    throw (css::container::NoSuchElementException, css::uno::RuntimeException)
-{
-    try {
-        bool cnst;
-        sal_uInt32 off = provider_->find(aName, &cnst);
-        if (off == 0) {
-            throw css::container::NoSuchElementException(
-                aName, static_cast< cppu::OWeakObject * >(this));
-        }
-        if (cnst) {
-            unoidl::ConstantValue val1(provider_->getConstant(off));
-            css::uno::Any val2;
-            switch (val1.type) {
-            case unoidl::ConstantValue::TYPE_BOOLEAN:
-                val2 <<= val1.booleanValue;
-                break;
-            case unoidl::ConstantValue::TYPE_BYTE:
-                val2 <<= val1.byteValue;
-                break;
-            case unoidl::ConstantValue::TYPE_SHORT:
-                val2 <<= val1.shortValue;
-                break;
-            case unoidl::ConstantValue::TYPE_UNSIGNED_SHORT:
-                val2 <<= val1.unsignedShortValue;
-                break;
-            case unoidl::ConstantValue::TYPE_LONG:
-                val2 <<= val1.longValue;
-                break;
-            case unoidl::ConstantValue::TYPE_UNSIGNED_LONG:
-                val2 <<= val1.unsignedLongValue;
-                break;
-            case unoidl::ConstantValue::TYPE_HYPER:
-                val2 <<= val1.hyperValue;
-                break;
-            case unoidl::ConstantValue::TYPE_UNSIGNED_HYPER:
-                val2 <<= val1.unsignedHyperValue;
-                break;
-            case unoidl::ConstantValue::TYPE_FLOAT:
-                val2 <<= val1.floatValue;
-                break;
-            case unoidl::ConstantValue::TYPE_DOUBLE:
-                val2 <<= val1.doubleValue;
-                break;
-            default:
-                for (;;) { std::abort(); } // this cannot happen
-            }
+css::uno::Any cppuhelper::TypeManager::find(rtl::OUString const & name) {
+    //TODO: caching? (here or in unoidl::Manager?)
+    struct Simple {
+        char const * name; sal_Int32 length;
+        css::uno::TypeClass typeClass;
+    };
+    static Simple const simple[] = {
+        { RTL_CONSTASCII_STRINGPARAM("void"), css::uno::TypeClass_VOID },
+        { RTL_CONSTASCII_STRINGPARAM("boolean"), css::uno::TypeClass_BOOLEAN },
+        { RTL_CONSTASCII_STRINGPARAM("byte"), css::uno::TypeClass_BYTE },
+        { RTL_CONSTASCII_STRINGPARAM("short"), css::uno::TypeClass_SHORT },
+        { RTL_CONSTASCII_STRINGPARAM("unsigned short"),
+          css::uno::TypeClass_UNSIGNED_SHORT },
+        { RTL_CONSTASCII_STRINGPARAM("long"), css::uno::TypeClass_LONG },
+        { RTL_CONSTASCII_STRINGPARAM("unsigned long"),
+          css::uno::TypeClass_UNSIGNED_LONG },
+        { RTL_CONSTASCII_STRINGPARAM("hyper"), css::uno::TypeClass_HYPER },
+        { RTL_CONSTASCII_STRINGPARAM("unsigned hyper"),
+          css::uno::TypeClass_UNSIGNED_HYPER },
+        { RTL_CONSTASCII_STRINGPARAM("float"), css::uno::TypeClass_FLOAT },
+        { RTL_CONSTASCII_STRINGPARAM("double"), css::uno::TypeClass_DOUBLE },
+        { RTL_CONSTASCII_STRINGPARAM("char"), css::uno::TypeClass_CHAR },
+        { RTL_CONSTASCII_STRINGPARAM("string"), css::uno::TypeClass_STRING },
+        { RTL_CONSTASCII_STRINGPARAM("type"), css::uno::TypeClass_TYPE },
+        { RTL_CONSTASCII_STRINGPARAM("any"), css::uno::TypeClass_ANY } };
+    for (std::size_t i = 0; i != SAL_N_ELEMENTS(simple); ++i) {
+        if (name.equalsAsciiL(simple[i].name, simple[i].length)) {
             return css::uno::makeAny<
                 css::uno::Reference< css::reflection::XTypeDescription > >(
-                    new ConstantDescription(aName, val2));
-        } else {
-            rtl::Reference< unoidl::Entity > ent(provider_->getEntity(off));
+                    new SimpleTypeDescription(simple[i].typeClass, name));
+        }
+    }
+    if (name.match("[]")) {
+        return getSequenceType(name);
+    }
+    sal_Int32 i = name.indexOf('<');
+    if (i != -1) {
+        return getInstantiatedStruct(name, i);
+    }
+    i = name.indexOf("::");
+    if (i != -1) {
+        return getInterfaceMember(name, i);
+    }
+    rtl::Reference< unoidl::Entity > ent(findEntity(name));
+    if (ent.is()) {
+        return getNamed(name, ent);
+    }
+    i = name.lastIndexOf('.');
+    if (i != -1) {
+        ent = findEntity(name.copy(0, i));
+        if (ent.is()) {
             switch (ent->getSort()) {
-            case unoidl::Entity::SORT_MODULE:
-                return css::uno::makeAny<
-                    css::uno::Reference< css::reflection::XTypeDescription > >(
-                        new ModuleDescription(
-                            context_, aName,
-                            static_cast< unoidl::ModuleEntity * >(ent.get())));
             case unoidl::Entity::SORT_ENUM_TYPE:
-                return css::uno::makeAny<
-                    css::uno::Reference< css::reflection::XTypeDescription > >(
-                        new EnumTypeDescription(
-                            aName,
-                            static_cast< unoidl::EnumTypeEntity * >(
-                                ent.get())));
-            case unoidl::Entity::SORT_PLAIN_STRUCT_TYPE:
-                return css::uno::makeAny<
-                    css::uno::Reference< css::reflection::XTypeDescription > >(
-                        new PlainStructTypeDescription(
-                            context_, aName,
-                            static_cast< unoidl::PlainStructTypeEntity * >(
-                                ent.get())));
-            case unoidl::Entity::SORT_POLYMORPHIC_STRUCT_TYPE_TEMPLATE:
-                return css::uno::makeAny<
-                    css::uno::Reference< css::reflection::XTypeDescription > >(
-                        new PolymorphicStructTypeTemplateDescription(
-                            context_, aName,
-                            static_cast<
-                                unoidl::PolymorphicStructTypeTemplateEntity * >(
-                                    ent.get())));
-            case unoidl::Entity::SORT_EXCEPTION_TYPE:
-                return css::uno::makeAny<
-                    css::uno::Reference< css::reflection::XTypeDescription > >(
-                        new ExceptionTypeDescription(
-                            context_, aName,
-                            static_cast< unoidl::ExceptionTypeEntity * >(
-                                ent.get())));
-            case unoidl::Entity::SORT_INTERFACE_TYPE:
-                return css::uno::makeAny<
-                    css::uno::Reference< css::reflection::XTypeDescription > >(
-                        new InterfaceTypeDescription(
-                            context_, aName,
-                            static_cast< unoidl::InterfaceTypeEntity * >(
-                                ent.get())));
-            case unoidl::Entity::SORT_TYPEDEF:
-                return css::uno::makeAny<
-                    css::uno::Reference< css::reflection::XTypeDescription > >(
-                        new TypedefDescription(
-                            context_, aName,
-                            static_cast< unoidl::TypedefEntity * >(ent.get())));
+                return getEnumMember(
+                    static_cast< unoidl::EnumTypeEntity * >(ent.get()),
+                    name.copy(i + 1));
             case unoidl::Entity::SORT_CONSTANT_GROUP:
-                return css::uno::makeAny<
-                    css::uno::Reference< css::reflection::XTypeDescription > >(
-                        new ConstantGroupDescription(
-                            context_, aName,
-                            static_cast< unoidl::ConstantGroupEntity * >(
-                                ent.get())));
-            case unoidl::Entity::SORT_SINGLE_INTERFACE_BASED_SERVICE:
-                return css::uno::makeAny<
-                    css::uno::Reference< css::reflection::XTypeDescription > >(
-                        new SingleInterfaceBasedServiceDescription(
-                            context_, aName,
-                            static_cast<
-                                unoidl::SingleInterfaceBasedServiceEntity * >(
-                                    ent.get())));
-            case unoidl::Entity::SORT_ACCUMULATION_BASED_SERVICE:
-                return css::uno::makeAny<
-                    css::uno::Reference< css::reflection::XTypeDescription > >(
-                        new AccumulationBasedServiceDescription(
-                            context_, aName,
-                            static_cast<
-                                unoidl::AccumulationBasedServiceEntity * >(
-                                    ent.get())));
-            case unoidl::Entity::SORT_INTERFACE_BASED_SINGLETON:
-                return css::uno::makeAny<
-                    css::uno::Reference< css::reflection::XTypeDescription > >(
-                        new InterfaceBasedSingletonDescription(
-                            context_, aName,
-                            static_cast<
-                                unoidl::InterfaceBasedSingletonEntity * >(
-                                    ent.get())));
-            case unoidl::Entity::SORT_SERVICE_BASED_SINGLETON:
-                return css::uno::makeAny<
-                    css::uno::Reference< css::reflection::XTypeDescription > >(
-                        new ServiceBasedSingletonDescription(
-                            context_, aName,
-                            static_cast<
-                                unoidl::ServiceBasedSingletonEntity * >(
-                                    ent.get())));
+                return getConstant(
+                    static_cast< unoidl::ConstantGroupEntity * >(ent.get()),
+                    name.copy(i + 1));
             default:
-                for (;;) { std::abort(); } // this cannot happen
+                break;
             }
         }
-    } catch (unoidl::FileFormatException & e) {
+    }
+    return css::uno::Any();
+}
+
+css::uno::Reference< css::reflection::XTypeDescription >
+cppuhelper::TypeManager::resolve(rtl::OUString const & name) {
+    css::uno::Reference< css::reflection::XTypeDescription > desc(
+        find(name), css::uno::UNO_QUERY);
+    if (!desc.is()) {
         throw css::uno::DeploymentException(
-            e.getUri() + ": " + e.getDetail(),
+            "cannot resolve type \"" + name + "\"",
             static_cast< cppu::OWeakObject * >(this));
     }
+    return desc;
 }
 
-sal_Bool Provider::hasByHierarchicalName(
-    rtl::OUString const & aName) throw (css::uno::RuntimeException)
+cppuhelper::TypeManager::~TypeManager() throw () {}
+
+void cppuhelper::TypeManager::disposing() {} //TODO
+
+rtl::OUString cppuhelper::TypeManager::getImplementationName()
+    throw (css::uno::RuntimeException)
 {
-    try {
-        return provider_->find(aName) != 0;
-    } catch (unoidl::FileFormatException & e) {
-        throw css::uno::DeploymentException(
-            e.getUri() + ": " + e.getDetail(),
-            static_cast< cppu::OWeakObject * >(this));
+    return rtl::OUString(
+        "com.sun.star.comp.cppuhelper.bootstrap.TypeManager");
+}
+
+sal_Bool cppuhelper::TypeManager::supportsService(
+    rtl::OUString const & ServiceName)
+    throw (css::uno::RuntimeException)
+{
+    return cppu::supportsService(this, ServiceName);
+}
+
+css::uno::Sequence< rtl::OUString >
+cppuhelper::TypeManager::getSupportedServiceNames()
+    throw (css::uno::RuntimeException)
+{
+    css::uno::Sequence< rtl::OUString > names(1);
+    names[0] = "com.sun.star.reflection.TypeDescriptionManager"; //TODO
+    return names;
+}
+
+css::uno::Any cppuhelper::TypeManager::getByHierarchicalName(
+    rtl::OUString const & aName)
+    throw (css::container::NoSuchElementException, css::uno::RuntimeException)
+{
+    css::uno::Any desc(find(aName));
+    if (!desc.hasValue()) {
+        throw css::container::NoSuchElementException(
+            aName, static_cast< cppu::OWeakObject * >(this));
     }
+    return desc;
+}
+
+sal_Bool cppuhelper::TypeManager::hasByHierarchicalName(
+    rtl::OUString const & aName)
+    throw (css::uno::RuntimeException)
+{
+    return find(aName).hasValue();
+}
+
+css::uno::Type cppuhelper::TypeManager::getElementType()
+    throw (css::uno::RuntimeException)
+{
+    return cppu::UnoType< rtl::OUString >::get();
+}
+
+sal_Bool cppuhelper::TypeManager::hasElements()
+    throw (css::uno::RuntimeException)
+{
+    throw css::uno::RuntimeException(
+        "TypeManager hasElements: method not supported",
+        static_cast< cppu::OWeakObject * >(this));
+}
+
+css::uno::Reference< css::container::XEnumeration >
+cppuhelper::TypeManager::createEnumeration()
+    throw (css::uno::RuntimeException)
+{
+    throw css::uno::RuntimeException(
+        "TypeManager createEnumeration: method not supported",
+        static_cast< cppu::OWeakObject * >(this));
+}
+
+sal_Bool cppuhelper::TypeManager::has(css::uno::Any const &)
+    throw (css::uno::RuntimeException)
+{
+    throw css::uno::RuntimeException(
+        "TypeManager has: method not supported",
+        static_cast< cppu::OWeakObject * >(this));
+}
+
+void cppuhelper::TypeManager::insert(css::uno::Any const & aElement)
+    throw (
+        css::lang::IllegalArgumentException,
+        css::container::ElementExistException, css::uno::RuntimeException)
+{
+    rtl::OUString uri;
+    if (!(aElement >>= uri)) {
+        throw css::lang::IllegalArgumentException(
+            ("css.uno.theTypeDescriptionManager.insert expects a string URI"
+             " argument"),
+            static_cast< cppu::OWeakObject * >(this), 0);
+    }
+    //TODO: check for ElementExistException
+    //TODO: check for consistency with existing data
+    readRdbFile(uri, false);
+}
+
+void cppuhelper::TypeManager::remove(css::uno::Any const & aElement)
+    throw (
+        css::lang::IllegalArgumentException,
+        css::container::NoSuchElementException, css::uno::RuntimeException)
+{
+    rtl::OUString uri;
+    if (!(aElement >>= uri)) {
+        throw css::lang::IllegalArgumentException(
+            ("css.uno.theTypeDescriptionManager.remove expects a string URI"
+             " argument"),
+            static_cast< cppu::OWeakObject * >(this), 0);
+    }
+    //TODO: remove requests are silently ignored for now
 }
 
 css::uno::Reference< css::reflection::XTypeDescriptionEnumeration >
-Provider::createTypeDescriptionEnumeration(
+cppuhelper::TypeManager::createTypeDescriptionEnumeration(
     rtl::OUString const & moduleName,
     css::uno::Sequence< css::uno::TypeClass > const & types,
     css::reflection::TypeDescriptionSearchDepth depth)
-    throw(
+    throw (
         css::reflection::NoSuchTypeNameException,
-        css::reflection::InvalidTypeNameException, css::uno::RuntimeException)
+        css::reflection::InvalidTypeNameException,
+        css::uno::RuntimeException)
 {
+    //TODO: This fails for modules spread across multiple providers, esp. for
+    // the empty moduleName
+    rtl::Reference< unoidl::Entity > ent(findEntity(moduleName));
+    if (!ent.is()) {
+        throw css::reflection::NoSuchTypeNameException(
+            moduleName, static_cast< cppu::OWeakObject * >(this));
+    }
+    if (ent->getSort() != unoidl::Entity::SORT_MODULE) {
+        throw css::reflection::InvalidTypeNameException(
+            moduleName, static_cast< cppu::OWeakObject * >(this));
+    }
+    rtl::Reference< unoidl::MapCursor > cursor;
     try {
-        rtl::OUString prefix;
-        rtl::Reference< unoidl::MapCursor > cursor;
-        if (moduleName.isEmpty()) {
-            cursor = provider_->createRootCursor();
-        } else {
-            prefix = moduleName + ".";
-            bool cnst;
-            sal_uInt32 off = provider_->find(moduleName, &cnst);
-            if (off == 0) {
-                throw css::reflection::NoSuchTypeNameException(
-                    moduleName, static_cast< cppu::OWeakObject * >(this));
-            }
-            if (cnst) {
-                throw css::reflection::InvalidTypeNameException(
-                    moduleName, static_cast< cppu::OWeakObject * >(this));
-            }
-            rtl::Reference< unoidl::Entity > ent(provider_->getEntity(off));
-            if (ent->getSort() != unoidl::Entity::SORT_MODULE) {
-                throw css::reflection::InvalidTypeNameException(
-                    moduleName, static_cast< cppu::OWeakObject * >(this));
-            }
-            cursor = static_cast< unoidl::ModuleEntity * >(ent.get())->
-                createCursor();
-        }
-        return new Enumeration(
-            context_, prefix, cursor, types,
-            depth == css::reflection::TypeDescriptionSearchDepth_INFINITE);
+        cursor = static_cast< unoidl::ModuleEntity * >(ent.get())->
+            createCursor();
     } catch (unoidl::FileFormatException & e) {
         throw css::uno::DeploymentException(
-            e.getUri() + ": " + e.getDetail(),
+            ("unoidl::FileFormatException for <" + e.getUri() + ">: "
+             + e.getDetail()),
             static_cast< cppu::OWeakObject * >(this));
     }
+    return new Enumeration(
+        this, moduleName + ".", cursor, types,
+        depth == css::reflection::TypeDescriptionSearchDepth_INFINITE);
 }
 
-css::uno::Reference< css::container::XHierarchicalNameAccess >
-readLegacyRdbFile(
-    rtl::OUString const & uri,
-    css::uno::Reference< css::lang::XMultiComponentFactory > const &
-        serviceManager,
-    css::uno::Reference< css::uno::XComponentContext > const & context)
-{
-    assert(serviceManager.is());
-    css::uno::Reference< css::registry::XSimpleRegistry > reg(
-        serviceManager->createInstanceWithContext(
-            "com.sun.star.comp.stoc.SimpleRegistry", context),
-        css::uno::UNO_QUERY_THROW);
-    try {
-        reg->open(uri, true, false);
-    } catch (css::registry::InvalidRegistryException & e) {
-        throw css::uno::DeploymentException(
-            "Invalid registry " + uri + ":" + e.Message,
-            css::uno::Reference< css::uno::XInterface >());
-    }
-    css::uno::Sequence< css::uno::Any > arg(1);
-    arg[0] <<= reg;
-    return css::uno::Reference< css::container::XHierarchicalNameAccess >(
-        serviceManager->createInstanceWithArgumentsAndContext(
-            "com.sun.star.comp.stoc.RegistryTypeDescriptionProvider", arg,
-            context),
-        css::uno::UNO_QUERY_THROW);
-}
-
-void readRdbFile(
-    rtl::OUString const & uri, bool optional,
-    css::uno::Reference< css::lang::XMultiComponentFactory > const &
-        serviceManager,
-    css::uno::Reference< css::uno::XComponentContext > const & context,
-    std::vector<
-        css::uno::Reference< css::container::XHierarchicalNameAccess > > *
-            providers)
-{
-    assert(providers != 0);
-    css::uno::Reference< css::container::XHierarchicalNameAccess > prov;
-    try {
-        prov = new Provider(context, uri);
-    } catch (unoidl::NoSuchFileException &) {
-        if (optional) {
-            SAL_INFO("cppuhelper", "Ignored optional " << uri);
-            return;
+void cppuhelper::TypeManager::readRdbs(rtl::OUString const & uris) {
+    for (sal_Int32 i = 0; i != -1;) {
+        rtl::OUString uri(uris.getToken(0, ' ', i));
+        if (uri.isEmpty()) {
+            continue;
+        }
+        bool optional;
+        bool directory;
+        cppu::decodeRdbUri(&uri, &optional, &directory);
+        if (directory) {
+            readRdbDirectory(uri, optional);
+        } else {
+            readRdbFile(uri, optional);
         }
-        throw css::uno::DeploymentException(
-            uri + ": no such file",
-            css::uno::Reference< css::uno::XInterface >());
-    } catch (unoidl::FileFormatException &) {
-        prov = readLegacyRdbFile(uri, serviceManager, context);
     }
-    assert(prov.is());
-    providers->push_back(prov);
 }
 
-void readRdbDirectory(
-    rtl::OUString const & uri, bool optional,
-    css::uno::Reference< css::lang::XMultiComponentFactory > const &
-        serviceManager,
-    css::uno::Reference< css::uno::XComponentContext > const & context,
-    std::vector<
-        css::uno::Reference< css::container::XHierarchicalNameAccess > > *
-            providers)
+void cppuhelper::TypeManager::readRdbDirectory(
+    rtl::OUString const & uri, bool optional)
 {
     osl::Directory dir(uri);
     switch (dir.open()) {
@@ -2020,54 +2113,258 @@ void readRdbDirectory(
     default:
         throw css::uno::DeploymentException(
             "Cannot open directory " + uri,
-            css::uno::Reference< css::uno::XInterface >());
+            static_cast< cppu::OWeakObject * >(this));
     }
     for (;;) {
-        rtl::OUString fileUri;
-        if (!cppu::nextDirectoryItem(dir, &fileUri)) {
+        rtl::OUString url;
+        if (!cppu::nextDirectoryItem(dir, &url)) {
             break;
         }
-        readRdbFile(fileUri, optional, serviceManager, context, providers);
+        readRdbFile(url, false);
     }
 }
 
+void cppuhelper::TypeManager::readRdbFile(
+    rtl::OUString const & uri, bool optional)
+{
+    rtl::Reference< unoidl::Provider > prov;
+    try {
+        prov = unoidl::loadProvider(manager_, uri);
+    } catch (unoidl::NoSuchFileException &) {
+        if (!optional) {
+            throw css::uno::DeploymentException(
+                uri + ": no such file",
+                static_cast< cppu::OWeakObject * >(this));
+        }
+        SAL_INFO("cppuhelper", "Ignored optional " << uri);
+    } catch (unoidl::FileFormatException & e) {
+            throw css::uno::DeploymentException(
+                ("unoidl::FileFormatException for <" + e.getUri() + ">: "
+                 + e.getDetail()),
+                static_cast< cppu::OWeakObject * >(this));
+    }
+    manager_->addProvider(prov);
 }
 
-css::uno::Sequence<
-    css::uno::Reference< css::container::XHierarchicalNameAccess > >
-cppuhelper::createTypeDescriptionProviders(
-    rtl::OUString const & uris,
-    css::uno::Reference< css::lang::XMultiComponentFactory > const &
-        serviceManager,
-    css::uno::Reference< css::uno::XComponentContext > const & context)
-{
-    std::vector<
-        css::uno::Reference< css::container::XHierarchicalNameAccess > > provs;
-    for (sal_Int32 i = 0; i != -1;) {
-        rtl::OUString uri(uris.getToken(0, ' ', i));
-        if (uri.isEmpty()) {
-            continue;
+css::uno::Any cppuhelper::TypeManager::getSequenceType(
+    rtl::OUString const & name)
+{
+    assert(name.match("[]"));
+    return css::uno::makeAny<
+        css::uno::Reference< css::reflection::XTypeDescription > >(
+            new SequenceTypeDescription(
+                this, name, name.copy(std::strlen("[]"))));
+}
+
+css::uno::Any cppuhelper::TypeManager::getInstantiatedStruct(
+    rtl::OUString const & name, sal_Int32 separator)
+{
+    assert(name.indexOf('<') == separator && separator != -1);
+    rtl::Reference< unoidl::Entity > ent(findEntity(name.copy(0, separator)));
+    if (!ent.is()
+        || (ent->getSort()
+            != unoidl::Entity::SORT_POLYMORPHIC_STRUCT_TYPE_TEMPLATE))
+    {
+        return css::uno::Any();
+    }
+    rtl::Reference< unoidl::PolymorphicStructTypeTemplateEntity > ent2(
+        static_cast< unoidl::PolymorphicStructTypeTemplateEntity * >(
+            ent.get()));
+    std::vector< rtl::OUString > args;
+    sal_Int32 i = separator;
+    do {
+        ++i; // skip '<' or ','
+        sal_Int32 j = i;
+        for (sal_Int32 level = 0; j != name.getLength(); ++j) {
+            sal_Unicode c = name[j];
+            if (c == ',') {
+                if (level == 0) {
+                    break;
+                }
+            } else if (c == '<') {
+                ++level;
+            } else if (c == '>') {
+                if (level == 0) {
+                    break;
+                }
+                --level;
+            }
         }
-        bool optional;
-        bool directory;
-        cppu::decodeRdbUri(&uri, &optional, &directory);
-        if (directory) {
-            readRdbDirectory(uri, optional, serviceManager, context, &provs);
-        } else {
-            readRdbFile(uri, optional, serviceManager, context, &provs);
+        if (j != name.getLength()) {
+            args.push_back(name.copy(i, j - i));
         }
+        i = j;
+    } while (i != name.getLength() && name[i] != '>');
+    if (i != name.getLength() - 1 || name[i] != '>'
+        || args.size() != ent2->getTypeParameters().size())
+    {
+        return css::uno::Any();
     }
+    return css::uno::makeAny<
+        css::uno::Reference< css::reflection::XTypeDescription > >(
+            new InstantiatedPolymorphicStructTypeDescription(
+                this, name, ent2, args));
+}
+
+css::uno::Any cppuhelper::TypeManager::getInterfaceMember(
+    rtl::OUString const & name, sal_Int32 separator)
+{
+    assert(name.indexOf("::") == separator && separator != -1);
+    css::uno::Reference< css::reflection::XInterfaceTypeDescription2 > ifc(
+        resolveTypedefs(find(name.copy(0, separator))), css::uno::UNO_QUERY);
+    if (!ifc.is()) {
+        return css::uno::Any();
+    }
+    rtl::OUString member(name.copy(separator + std::strlen("::")));
     css::uno::Sequence<
-        css::uno::Reference< css::container::XHierarchicalNameAccess > > provs2(
-            static_cast< sal_Int32 >(provs.size())); //TODO: check overflow
-    std::vector<
         css::uno::Reference<
-            css::container::XHierarchicalNameAccess > >::iterator i(
-                provs.begin());
-    for (sal_Int32 j = 0; j != provs2.getLength(); ++j) {
-        provs2[j] = *i++;
+            css::reflection::XInterfaceMemberTypeDescription > > mems(
+                ifc->getMembers());
+    for (sal_Int32 i = 0; i != mems.getLength(); ++i) {
+        if (mems[i]->getMemberName() == member) {
+            return css::uno::makeAny<
+                css::uno::Reference< css::reflection::XTypeDescription > >(
+                    mems[i].get());
+        }
+    }
+    return css::uno::Any();
+}
+
+css::uno::Any cppuhelper::TypeManager::getNamed(
+    rtl::OUString const & name, rtl::Reference< unoidl::Entity > entity)
+{
+    assert(entity.is());
+    switch (entity->getSort()) {
+    case unoidl::Entity::SORT_MODULE:
+        return css::uno::makeAny<
+            css::uno::Reference< css::reflection::XTypeDescription > >(
+                new ModuleDescription(
+                    this, name,
+                    static_cast< unoidl::ModuleEntity * >(entity.get())));
+    case unoidl::Entity::SORT_ENUM_TYPE:
+        return css::uno::makeAny<
+            css::uno::Reference< css::reflection::XTypeDescription > >(
+                new EnumTypeDescription(
+                    name,
+                    static_cast< unoidl::EnumTypeEntity * >(entity.get())));
+    case unoidl::Entity::SORT_PLAIN_STRUCT_TYPE:
+        return css::uno::makeAny<
+            css::uno::Reference< css::reflection::XTypeDescription > >(
+                new PlainStructTypeDescription(
+                    this, name,
+                    static_cast< unoidl::PlainStructTypeEntity * >(
+                        entity.get())));

... etc. - the rest is truncated
