WIP: Experimental new binary type.rdb format

Move unoidl functionality into a module of its own, as a prerequisite to use it
in codemaker etc.  (This is intended to ultimately remove modules store and
registry, modulo backwards compatibility constraints.)

Change-Id: If5274cbd3a595951e6cf7a9664bc542f01833f38

8 files changed, 333 insertions, 2278 deletions

diff --git a/cppuhelper/Library_cppuhelper.mk b/cppuhelper/Library_cppuhelper.mk
index 2b849a109ac8..577efbcf942d 100644
--- a/cppuhelper/Library_cppuhelper.mk
+++ b/cppuhelper/Library_cppuhelper.mk
@@ -45,6 +45,7 @@ $(eval $(call gb_Library_use_libraries,cppuhelper,\
 	reg \
 	sal \
 	salhelper \
+	unoidl \
 	xmlreader \
 	$(gb_UWINAPI) \
 ))
@@ -76,8 +77,6 @@ $(eval $(call gb_Library_add_exception_objects,cppuhelper,\
 	cppuhelper/source/tdmgr \
 	cppuhelper/source/typedescriptionprovider \
 	cppuhelper/source/typeprovider \
-	cppuhelper/source/unoidl \
-	cppuhelper/source/unoidlprovider \
 	cppuhelper/source/unourl \
 	cppuhelper/source/weak \
 ))
diff --git a/cppuhelper/Package_inc.mk b/cppuhelper/Package_inc.mk
index 420eecf2fc47..af5a823c1d49 100644
--- a/cppuhelper/Package_inc.mk
+++ b/cppuhelper/Package_inc.mk
@@ -77,7 +77,6 @@ $(eval $(call gb_Package_add_file,cppuhelper_inc,inc/cppuhelper/queryinterface.h
 $(eval $(call gb_Package_add_file,cppuhelper_inc,inc/cppuhelper/shlib.hxx,cppuhelper/shlib.hxx))
 $(eval $(call gb_Package_add_file,cppuhelper_inc,inc/cppuhelper/supportsservice.hxx,cppuhelper/supportsservice.hxx))
 $(eval $(call gb_Package_add_file,cppuhelper_inc,inc/cppuhelper/typeprovider.hxx,cppuhelper/typeprovider.hxx))
-$(eval $(call gb_Package_add_file,cppuhelper_inc,inc/cppuhelper/unoidl.hxx,cppuhelper/unoidl.hxx))
 $(eval $(call gb_Package_add_file,cppuhelper_inc,inc/cppuhelper/unourl.hxx,cppuhelper/unourl.hxx))
 $(eval $(call gb_Package_add_file,cppuhelper_inc,inc/cppuhelper/weakagg.hxx,cppuhelper/weakagg.hxx))
 $(eval $(call gb_Package_add_file,cppuhelper_inc,inc/cppuhelper/weak.hxx,cppuhelper/weak.hxx))
diff --git a/cppuhelper/inc/cppuhelper/unoidl.hxx b/cppuhelper/inc/cppuhelper/unoidl.hxx
deleted file mode 100644
index 589f8462063a..000000000000
--- a/cppuhelper/inc/cppuhelper/unoidl.hxx
+++ /dev/null
@@ -1,527 +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_UNOIDL_HXX
-#define INCLUDED_CPPUHELPER_UNOIDL_HXX
-
-#include "sal/config.h"
-
-#include <cassert>
-#include <vector>
-
-#include "com/sun/star/uno/Any.hxx"
-#include "cppuhelper/cppuhelperdllapi.h"
-#include "rtl/ref.hxx"
-#include "rtl/ustring.hxx"
-#include "sal/types.h"
-#include "salhelper/simplereferenceobject.hxx"
-
-namespace cppu { namespace unoidl {
-
-class CPPUHELPER_DLLPUBLIC Entity: public salhelper::SimpleReferenceObject {
-public:
-    enum Sort {
-        SORT_MODULE,
-        SORT_ENUM_TYPE,
-        SORT_PLAIN_STRUCT_TYPE,
-        SORT_POLYMORPHIC_STRUCT_TYPE_TEMPLATE,
-        SORT_EXCEPTION_TYPE,
-        SORT_INTERFACE_TYPE,
-        SORT_TYPEDEF,
-        SORT_CONSTANT_GROUP,
-        SORT_SINGLE_INTERFACE_BASED_SERVICE,
-        SORT_ACCUMULATION_BASED_SERVICE,
-        SORT_INTERFACE_BASED_SINGLETON,
-        SORT_SERVICE_BASED_SINGLETON
-    };
-
-    Sort getSort() const { return sort_; }
-
-protected:
-    explicit SAL_DLLPRIVATE Entity(Sort sort): sort_(sort) {}
-
-    virtual SAL_DLLPRIVATE ~Entity() throw ();
-
-private:
-    Sort sort_;
-};
-
-class CPPUHELPER_DLLPUBLIC MapCursor: public salhelper::SimpleReferenceObject {
-public:
-    virtual rtl::Reference< Entity > getNext(rtl::OUString * name) = 0;
-
-protected:
-    SAL_DLLPRIVATE MapCursor() {}
-
-    virtual SAL_DLLPRIVATE ~MapCursor() throw();
-};
-
-class CPPUHELPER_DLLPUBLIC ModuleEntity: public Entity {
-public:
-    virtual std::vector< rtl::OUString > getMemberNames() const = 0;
-
-    virtual rtl::Reference< MapCursor > createCursor() const = 0;
-
-protected:
-    SAL_DLLPRIVATE ModuleEntity(): Entity(SORT_MODULE) {}
-
-    virtual SAL_DLLPRIVATE ~ModuleEntity() throw ();
-};
-
-class CPPUHELPER_DLLPUBLIC PublishableEntity: public Entity {
-public:
-    bool isPublished() const { return published_; }
-
-protected:
-    SAL_DLLPRIVATE PublishableEntity(Sort sort, bool published):
-        Entity(sort), published_(published)
-    {}
-
-    virtual SAL_DLLPRIVATE ~PublishableEntity() throw ();
-
-private:
-    bool published_;
-};
-
-class CPPUHELPER_DLLPUBLIC EnumTypeEntity: public PublishableEntity {
-public:
-    struct Member {
-        Member(rtl::OUString const & theName, sal_Int32 theValue):
-            name(theName), value(theValue)
-        {}
-
-        rtl::OUString name;
-
-        sal_Int32 value;
-    };
-
-    SAL_DLLPRIVATE EnumTypeEntity(
-        bool published, std::vector< Member > const & members):
-        PublishableEntity(SORT_ENUM_TYPE, published), members_(members)
-    { assert(!members.empty()); }
-
-    std::vector< Member > const & getMembers() const { return members_; }
-
-private:
-    virtual SAL_DLLPRIVATE ~EnumTypeEntity() throw ();
-
-    std::vector< Member > members_;
-};
-
-class CPPUHELPER_DLLPUBLIC PlainStructTypeEntity: public PublishableEntity {
-public:
-    struct Member {
-        Member(rtl::OUString const & theName, rtl::OUString const & theType):
-            name(theName), type(theType)
-        {}
-
-        rtl::OUString name;
-
-        rtl::OUString type;
-    };
-
-    SAL_DLLPRIVATE PlainStructTypeEntity(
-        bool published, rtl::OUString const & directBase,
-        std::vector< Member > const & directMembers):
-        PublishableEntity(SORT_PLAIN_STRUCT_TYPE, published),
-        directBase_(directBase), directMembers_(directMembers)
-    {}
-
-    rtl::OUString getDirectBase() const { return directBase_; }
-
-    std::vector< Member > const & getDirectMembers() const
-    { return directMembers_; }
-
-private:
-    virtual SAL_DLLPRIVATE ~PlainStructTypeEntity() throw ();
-
-    rtl::OUString directBase_;
-    std::vector< Member > directMembers_;
-};
-
-class CPPUHELPER_DLLPUBLIC PolymorphicStructTypeTemplateEntity:
-    public PublishableEntity
-{
-public:
-    struct Member {
-        Member(
-            rtl::OUString const & theName, rtl::OUString const & theType,
-            bool theParameterized):
-            name(theName), type(theType), parameterized(theParameterized)
-        {}
-
-        rtl::OUString name;
-
-        rtl::OUString type;
-
-        bool parameterized;
-    };
-
-    SAL_DLLPRIVATE PolymorphicStructTypeTemplateEntity(
-        bool published, std::vector< rtl::OUString > const & typeParameters,
-        std::vector< Member > const & members):
-        PublishableEntity(SORT_POLYMORPHIC_STRUCT_TYPE_TEMPLATE, published),
-        typeParameters_(typeParameters), members_(members)
-    {}
-
-    std::vector< rtl::OUString > const & getTypeParameters() const
-    { return typeParameters_; }
-
-    std::vector< Member > const & getMembers() const { return members_; }
-
-private:
-    virtual SAL_DLLPRIVATE ~PolymorphicStructTypeTemplateEntity() throw ();
-
-    std::vector< rtl::OUString > typeParameters_;
-    std::vector< Member > members_;
-};
-
-class CPPUHELPER_DLLPUBLIC ExceptionTypeEntity: public PublishableEntity {
-public:
-    struct Member {
-        Member(rtl::OUString const & theName, rtl::OUString const & theType):
-            name(theName), type(theType)
-        {}
-
-        rtl::OUString name;
-
-        rtl::OUString type;
-    };
-
-    SAL_DLLPRIVATE ExceptionTypeEntity(
-        bool published, rtl::OUString const & directBase,
-        std::vector< Member > const & directMembers):
-        PublishableEntity(SORT_EXCEPTION_TYPE, published),
-        directBase_(directBase), directMembers_(directMembers)
-    {}
-
-    rtl::OUString getDirectBase() const { return directBase_; }
-
-    std::vector< Member > const & getDirectMembers() const
-    { return directMembers_; }
-
-private:
-    virtual SAL_DLLPRIVATE ~ExceptionTypeEntity() throw ();
-
-    rtl::OUString directBase_;
-    std::vector< Member > directMembers_;
-};
-
-class CPPUHELPER_DLLPUBLIC InterfaceTypeEntity: public PublishableEntity {
-public:
-    struct Attribute {
-        Attribute(
-            rtl::OUString const & theName, rtl::OUString const & theType,
-            bool theBound, bool theReadOnly,
-            std::vector< rtl::OUString > const & theGetExceptions,
-            std::vector< rtl::OUString > const & theSetExceptions):
-            name(theName), type(theType), bound(theBound),
-            readOnly(theReadOnly), getExceptions(theGetExceptions),
-            setExceptions(theSetExceptions)
-        { assert(!theReadOnly || theSetExceptions.empty()); }
-
-        rtl::OUString name;
-
-        rtl::OUString type;
-
-        bool bound;
-
-        bool readOnly;
-
-        std::vector< rtl::OUString > getExceptions;
-
-        std::vector< rtl::OUString > setExceptions;
-    };
-
-    struct Method {
-        struct Parameter {
-            enum Direction { DIRECTION_IN, DIRECTION_OUT, DIRECTION_IN_OUT };
-
-            Parameter(
-                rtl::OUString const & theName, rtl::OUString const & theType,
-                Direction theDirection):
-                name(theName), type(theType), direction(theDirection)
-            {}
-
-            rtl::OUString name;
-
-            rtl::OUString type;
-
-            Direction direction;
-        };
-
-        Method(
-            rtl::OUString const & theName, rtl::OUString const & theReturnType,
-            std::vector< Parameter > const & theParameters,
-            std::vector< rtl::OUString > const & theExceptions):
-            name(theName), returnType(theReturnType), parameters(theParameters),
-            exceptions(theExceptions)
-        {}
-
-        rtl::OUString name;
-
-        rtl::OUString returnType;
-
-        std::vector< Parameter > parameters;
-
-        std::vector< rtl::OUString > exceptions;
-    };
-
-    SAL_DLLPRIVATE InterfaceTypeEntity(
-        bool published,
-        std::vector< rtl::OUString > const & directMandatoryBases,
-        std::vector< rtl::OUString > const & directOptionalBases,
-        std::vector< Attribute > const & directAttributes,
-        std::vector< Method > const & directMethods):
-        PublishableEntity(SORT_INTERFACE_TYPE, published),
-        directMandatoryBases_(directMandatoryBases),
-        directOptionalBases_(directOptionalBases),
-        directAttributes_(directAttributes), directMethods_(directMethods)
-    {}
-
-    std::vector< rtl::OUString > const & getDirectMandatoryBases() const
-    { return directMandatoryBases_; }
-
-    std::vector< rtl::OUString > const & getDirectOptionalBases() const
-    { return directOptionalBases_; }
-
-    std::vector< Attribute > const & getDirectAttributes() const
-    { return directAttributes_; }
-
-    std::vector< Method > const & getDirectMethods() const
-    { return directMethods_; }
-
-private:
-    virtual SAL_DLLPRIVATE ~InterfaceTypeEntity() throw ();
-
-    std::vector< rtl::OUString > directMandatoryBases_;
-    std::vector< rtl::OUString > directOptionalBases_;
-    std::vector< Attribute > directAttributes_;
-    std::vector< Method > directMethods_;
-};
-
-class CPPUHELPER_DLLPUBLIC TypedefEntity: public PublishableEntity {
-public:
-    SAL_DLLPRIVATE TypedefEntity(bool published, rtl::OUString const & type):
-        PublishableEntity(SORT_TYPEDEF, published), type_(type)
-    {}
-
-    rtl::OUString getType() const { return type_; }
-
-private:
-    virtual SAL_DLLPRIVATE ~TypedefEntity() throw ();
-
-    rtl::OUString type_;
-};
-
-class CPPUHELPER_DLLPUBLIC ConstantGroupEntity: public PublishableEntity {
-public:
-    struct Member {
-        Member(rtl::OUString const & theName, css::uno::Any const & theValue):
-            name(theName), value(theValue)
-        {}
-
-        rtl::OUString name;
-
-        css::uno::Any value;
-    };
-
-    SAL_DLLPRIVATE ConstantGroupEntity(
-        bool published, std::vector< Member > const & members):
-        PublishableEntity(SORT_CONSTANT_GROUP, published), members_(members)
-    {}
-
-    std::vector< Member > const & getMembers() const { return members_; }
-
-private:
-    virtual SAL_DLLPRIVATE ~ConstantGroupEntity() throw ();
-
-    std::vector< Member > members_;
-};
-
-class CPPUHELPER_DLLPUBLIC SingleInterfaceBasedServiceEntity:
-    public PublishableEntity
-{
-public:
-    struct Constructor {
-        struct Parameter {
-            Parameter(
-                rtl::OUString const & theName, rtl::OUString const & theType,
-                bool theRest):
-                name(theName), type(theType), rest(theRest)
-            {}
-
-            rtl::OUString name;
-
-            rtl::OUString type;
-
-            bool rest;
-        };
-
-        Constructor(): defaultConstructor(true) {}
-
-        Constructor(
-            rtl::OUString const & theName,
-            std::vector< Parameter > const & theParameters,
-            std::vector< rtl::OUString > const & theExceptions):
-            name(theName), parameters(theParameters), exceptions(theExceptions),
-            defaultConstructor(false)
-        {}
-
-        rtl::OUString name;
-
-        std::vector< Parameter > parameters;
-
-        std::vector< rtl::OUString > exceptions;
-
-        bool defaultConstructor;
-    };
-
-    SAL_DLLPRIVATE SingleInterfaceBasedServiceEntity(
-        bool published, rtl::OUString const & base,
-        std::vector< Constructor > const & constructors):
-        PublishableEntity(SORT_SINGLE_INTERFACE_BASED_SERVICE, published),
-        base_(base), constructors_(constructors)
-    {}
-
-    rtl::OUString getBase() const { return base_; }
-
-    std::vector< Constructor > const & getConstructors() const
-    { return constructors_; }
-
-private:
-    virtual SAL_DLLPRIVATE ~SingleInterfaceBasedServiceEntity() throw ();
-
-    rtl::OUString base_;
-    std::vector< Constructor > constructors_;
-};
-
-class CPPUHELPER_DLLPUBLIC AccumulationBasedServiceEntity:
-    public PublishableEntity
-{
-public:
-    struct Property {
-        enum Attributes {
-            ATTRIBUTE_MAYBE_VOID = 0x001,
-            ATTRIBUTE_BOUND = 0x002,
-            ATTRIBUTE_CONSTRAINED = 0x004,
-            ATTRIBUTE_TRANSIENT = 0x008,
-            ATTRIBUTE_READ_ONLY = 0x010,
-            ATTRIBUTE_MAYBE_AMBIGUOUS = 0x020,
-            ATTRIBUTE_MAYBE_DEFAULT = 0x040,
-            ATTRIBUTE_REMOVABLE = 0x080,
-            ATTRIBUTE_OPTIONAL = 0x100
-        };
-
-        Property(
-            rtl::OUString const & theName, rtl::OUString const & theType,
-            Attributes theAttributes):
-            name(theName), type(theType), attributes(theAttributes)
-        {}
-
-        rtl::OUString name;
-
-        rtl::OUString type;
-
-        Attributes attributes;
-    };
-
-    SAL_DLLPRIVATE AccumulationBasedServiceEntity(
-        bool published,
-        std::vector< rtl::OUString > const & directMandatoryBaseServices,
-        std::vector< rtl::OUString > const & directOptionalBaseServices,
-        std::vector< rtl::OUString > const & directMandatoryBaseInterfaces,
-        std::vector< rtl::OUString > const & directOptionalBaseInterfaces,
-        std::vector< Property > const & directProperties):
-        PublishableEntity(SORT_ACCUMULATION_BASED_SERVICE, published),
-        directMandatoryBaseServices_(directMandatoryBaseServices),
-        directOptionalBaseServices_(directOptionalBaseServices),
-        directMandatoryBaseInterfaces_(directMandatoryBaseInterfaces),
-        directOptionalBaseInterfaces_(directOptionalBaseInterfaces),
-        directProperties_(directProperties)
-        {}
-
-    std::vector< rtl::OUString > const & getDirectMandatoryBaseServices() const
-    { return directMandatoryBaseServices_; }
-
-    std::vector< rtl::OUString > const & getDirectOptionalBaseServices() const
-    { return directOptionalBaseServices_; }
-
-    std::vector< rtl::OUString > const & getDirectMandatoryBaseInterfaces()
-        const
-    { return directMandatoryBaseInterfaces_; }
-
-    std::vector< rtl::OUString > const & getDirectOptionalBaseInterfaces() const
-    { return directOptionalBaseInterfaces_; }
-
-    std::vector< Property > const & getDirectProperties() const
-    { return directProperties_; }
-
-private:
-    virtual SAL_DLLPRIVATE ~AccumulationBasedServiceEntity() throw ();
-
-    std::vector< rtl::OUString > directMandatoryBaseServices_;
-    std::vector< rtl::OUString > directOptionalBaseServices_;
-    std::vector< rtl::OUString > directMandatoryBaseInterfaces_;
-    std::vector< rtl::OUString > directOptionalBaseInterfaces_;
-    std::vector< Property > directProperties_;
-};
-
-class CPPUHELPER_DLLPUBLIC InterfaceBasedSingletonEntity:
-    public PublishableEntity
-{
-public:
-    SAL_DLLPRIVATE InterfaceBasedSingletonEntity(
-        bool published, rtl::OUString const & base):
-        PublishableEntity(SORT_INTERFACE_BASED_SINGLETON, published),
-        base_(base)
-    {}
-
-    rtl::OUString getBase() const { return base_; }
-
-private:
-    virtual SAL_DLLPRIVATE ~InterfaceBasedSingletonEntity() throw ();
-
-    rtl::OUString base_;
-};
-
-class CPPUHELPER_DLLPUBLIC ServiceBasedSingletonEntity: public PublishableEntity
-{
-public:
-    SAL_DLLPRIVATE ServiceBasedSingletonEntity(
-        bool published, rtl::OUString const & base):
-        PublishableEntity(SORT_SERVICE_BASED_SINGLETON, published), base_(base)
-    {}
-
-    rtl::OUString getBase() const { return base_; }
-
-private:
-    virtual SAL_DLLPRIVATE ~ServiceBasedSingletonEntity() throw ();
-
-    rtl::OUString base_;
-};
-
-class CPPUHELPER_DLLPUBLIC Provider: public salhelper::SimpleReferenceObject {
-public:
-    virtual rtl::Reference< MapCursor > createRootCursor() const = 0;
-
-protected:
-    SAL_DLLPRIVATE Provider() {}
-
-    virtual SAL_DLLPRIVATE ~Provider() throw ();
-};
-
-CPPUHELPER_DLLPUBLIC rtl::Reference< Provider > loadProvider(
-    rtl::OUString const & uri);
-
-} }
-
-#endif
-
-/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/cppuhelper/prj/build.lst b/cppuhelper/prj/build.lst
index f39e1a458b9c..02d54ffdc36c 100644
--- a/cppuhelper/prj/build.lst
+++ b/cppuhelper/prj/build.lst
@@ -1,2 +1,2 @@
-ch	cppuhelper	:	BOOST:boost LIBXSLT:libxslt DESKTOP:codemaker cppu offapi registry salhelper xmlreader NULL
+ch	cppuhelper	:	BOOST:boost LIBXSLT:libxslt DESKTOP:codemaker cppu offapi registry salhelper unoidl xmlreader NULL
 ch	cppuhelper\prj							nmake	-	all	ch_prj NULL
diff --git a/cppuhelper/source/typedescriptionprovider.cxx b/cppuhelper/source/typedescriptionprovider.cxx
index bf77491ea991..7dbe5e590b88 100644
--- a/cppuhelper/source/typedescriptionprovider.cxx
+++ b/cppuhelper/source/typedescriptionprovider.cxx
@@ -49,16 +49,16 @@
 #include "com/sun/star/uno/XInterface.hpp"
 #include "cppuhelper/compbase2.hxx"
 #include "cppuhelper/implbase1.hxx"
-#include "cppuhelper/unoidl.hxx"
 #include "osl/file.hxx"
 #include "osl/mutex.hxx"
 #include "rtl/ref.hxx"
 #include "rtl/ustring.hxx"
 #include "sal/types.h"
+#include "unoidl/unoidl.hxx"
+#include "unoidl/unoidlprovider.hxx"
 
 #include "paths.hxx"
 #include "typedescriptionprovider.hxx"
-#include "unoidlprovider.hxx"
 
 namespace {
 
@@ -108,7 +108,7 @@ public:
     ModuleDescription(
         css::uno::Reference< css::uno::XComponentContext > const & context,
         rtl::OUString const & name,
-        rtl::Reference< cppu::unoidl::ModuleEntity > const & entity):
+        rtl::Reference< unoidl::ModuleEntity > const & entity):
         context_(context), name_(name), entity_(entity)
     { assert(entity.is()); }
 
@@ -129,20 +129,26 @@ private:
 
     css::uno::Reference< css::uno::XComponentContext > context_;
     rtl::OUString name_;
-    rtl::Reference< cppu::unoidl::ModuleEntity > entity_;
+    rtl::Reference< unoidl::ModuleEntity > entity_;
 };
 
 css::uno::Sequence< css::uno::Reference< css::reflection::XTypeDescription > >
 ModuleDescription::getMembers() throw (css::uno::RuntimeException) {
-    std::vector< rtl::OUString > names(entity_->getMemberNames());
-    assert(names.size() <= SAL_MAX_INT32);
-    sal_Int32 n = static_cast< sal_Int32 >(names.size());
-    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]);
+    try {
+        std::vector< rtl::OUString > names(entity_->getMemberNames());
+        assert(names.size() <= SAL_MAX_INT32);
+        sal_Int32 n = static_cast< sal_Int32 >(names.size());
+        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]);
+        }
+        return s;
+    } catch (unoidl::FileFormatException & e) {
+        throw css::uno::DeploymentException(
+            e.getUri() + ": " + e.getDetail(),
+            static_cast< cppu::OWeakObject * >(this));
     }
-    return s;
 }
 
 typedef cppu::ImplInheritanceHelper1<
@@ -153,7 +159,7 @@ class EnumTypeDescription: public EnumTypeDescription_Base {
 public:
     EnumTypeDescription(
         rtl::OUString const & name,
-        rtl::Reference< cppu::unoidl::EnumTypeEntity > const & entity):
+        rtl::Reference< unoidl::EnumTypeEntity > const & entity):
         EnumTypeDescription_Base(entity->isPublished()), name_(name),
         entity_(entity)
     { assert(entity.is()); }
@@ -179,7 +185,7 @@ private:
         throw (css::uno::RuntimeException);
 
     rtl::OUString name_;
-    rtl::Reference< cppu::unoidl::EnumTypeEntity > entity_;
+    rtl::Reference< unoidl::EnumTypeEntity > entity_;
 };
 
 css::uno::Sequence< rtl::OUString > EnumTypeDescription::getEnumNames()
@@ -215,7 +221,7 @@ public:
     PlainStructTypeDescription(
         css::uno::Reference< css::uno::XComponentContext > const & context,
         rtl::OUString const & name,
-        rtl::Reference< cppu::unoidl::PlainStructTypeEntity > const & entity):
+        rtl::Reference< unoidl::PlainStructTypeEntity > const & entity):
         PlainStructTypeDescription_Base(entity->isPublished()),
         context_(context), name_(name), entity_(entity)
     { assert(entity.is()); }
@@ -259,7 +265,7 @@ private:
 
     css::uno::Reference< css::uno::XComponentContext > context_;
     rtl::OUString name_;
-    rtl::Reference< cppu::unoidl::PlainStructTypeEntity > entity_;
+    rtl::Reference< unoidl::PlainStructTypeEntity > entity_;
 };
 
 css::uno::Sequence< css::uno::Reference< css::reflection::XTypeDescription > >
@@ -321,8 +327,8 @@ public:
     PolymorphicStructTypeTemplateDescription(
         css::uno::Reference< css::uno::XComponentContext > const & context,
         rtl::OUString const & name,
-        rtl::Reference< cppu::unoidl::PolymorphicStructTypeTemplateEntity >
-            const & entity):
+        rtl::Reference< unoidl::PolymorphicStructTypeTemplateEntity > const &
+            entity):
         PolymorphicStructTypeTemplateDescription_Base(entity->isPublished()),
         context_(context), name_(name), entity_(entity)
     { assert(entity.is()); }
@@ -362,7 +368,7 @@ private:
 
     css::uno::Reference< css::uno::XComponentContext > context_;
     rtl::OUString name_;
-    rtl::Reference< cppu::unoidl::PolymorphicStructTypeTemplateEntity > entity_;
+    rtl::Reference< unoidl::PolymorphicStructTypeTemplateEntity > entity_;
 };
 
 css::uno::Sequence< css::uno::Reference< css::reflection::XTypeDescription > >
@@ -417,7 +423,7 @@ public:
     ExceptionTypeDescription(
         css::uno::Reference< css::uno::XComponentContext > const & context,
         rtl::OUString const & name,
-        rtl::Reference< cppu::unoidl::ExceptionTypeEntity > const & entity):
+        rtl::Reference< unoidl::ExceptionTypeEntity > const & entity):
         ExceptionTypeDescription_Base(entity->isPublished()), context_(context),
         name_(name), entity_(entity)
     { assert(entity.is()); }
@@ -449,7 +455,7 @@ private:
 
     css::uno::Reference< css::uno::XComponentContext > context_;
     rtl::OUString name_;
-    rtl::Reference< cppu::unoidl::ExceptionTypeEntity > entity_;
+    rtl::Reference< unoidl::ExceptionTypeEntity > entity_;
 };
 
 css::uno::Sequence< css::uno::Reference< css::reflection::XTypeDescription > >
@@ -551,7 +557,7 @@ public:
     AttributeDescription(
         css::uno::Reference< css::uno::XComponentContext > const & context,
         rtl::OUString const & name,
-        cppu::unoidl::InterfaceTypeEntity::Attribute const & attribute,
+        unoidl::InterfaceTypeEntity::Attribute const & attribute,
         sal_Int32 position):
         context_(context), name_(name), attribute_(attribute),
         position_(position)
@@ -596,7 +602,7 @@ private:
 
     css::uno::Reference< css::uno::XComponentContext > context_;
     rtl::OUString name_;
-    cppu::unoidl::InterfaceTypeEntity::Attribute attribute_;
+    unoidl::InterfaceTypeEntity::Attribute attribute_;
     sal_Int32 position_;
 };
 
@@ -637,7 +643,7 @@ class MethodParameter:
 public:
     MethodParameter(
         css::uno::Reference< css::uno::XComponentContext > const & context,
-        cppu::unoidl::InterfaceTypeEntity::Method::Parameter const & parameter,
+        unoidl::InterfaceTypeEntity::Method::Parameter const & parameter,
         sal_Int32 position):
         context_(context), parameter_(parameter), position_(position)
     {}
@@ -655,20 +661,18 @@ private:
     virtual sal_Bool SAL_CALL isIn() throw (css::uno::RuntimeException) {
         return
             (parameter_.direction
-             == cppu::unoidl::InterfaceTypeEntity::Method::Parameter::
-                 DIRECTION_IN)
+             == unoidl::InterfaceTypeEntity::Method::Parameter::DIRECTION_IN)
             || (parameter_.direction
-                == cppu::unoidl::InterfaceTypeEntity::Method::Parameter::
+                == unoidl::InterfaceTypeEntity::Method::Parameter::
                     DIRECTION_IN_OUT);
     }
 
     virtual sal_Bool SAL_CALL isOut() throw (css::uno::RuntimeException) {
         return
             (parameter_.direction
-             == cppu::unoidl::InterfaceTypeEntity::Method::Parameter::
-                 DIRECTION_OUT)
+             == unoidl::InterfaceTypeEntity::Method::Parameter::DIRECTION_OUT)
             || (parameter_.direction
-                == cppu::unoidl::InterfaceTypeEntity::Method::Parameter::
+                == unoidl::InterfaceTypeEntity::Method::Parameter::
                     DIRECTION_IN_OUT);
     }
 
@@ -676,7 +680,7 @@ private:
     { return position_; }
 
     css::uno::Reference< css::uno::XComponentContext > context_;
-    cppu::unoidl::InterfaceTypeEntity::Method::Parameter parameter_;
+    unoidl::InterfaceTypeEntity::Method::Parameter parameter_;
     sal_Int32 position_;
 };
 
@@ -689,8 +693,7 @@ public:
     MethodDescription(
         css::uno::Reference< css::uno::XComponentContext > const & context,
         rtl::OUString const & name,
-        cppu::unoidl::InterfaceTypeEntity::Method const & method,
-        sal_Int32 position):
+        unoidl::InterfaceTypeEntity::Method const & method, sal_Int32 position):
         context_(context), name_(name), method_(method), position_(position)
     {}
 
@@ -730,7 +733,7 @@ private:
 
     css::uno::Reference< css::uno::XComponentContext > context_;
     rtl::OUString name_;
-    cppu::unoidl::InterfaceTypeEntity::Method method_;
+    unoidl::InterfaceTypeEntity::Method method_;
     sal_Int32 position_;
 };
 
@@ -767,7 +770,7 @@ public:
     InterfaceTypeDescription(
         css::uno::Reference< css::uno::XComponentContext > const & context,
         rtl::OUString const & name,
-        rtl::Reference< cppu::unoidl::InterfaceTypeEntity > const & entity):
+        rtl::Reference< unoidl::InterfaceTypeEntity > const & entity):
         InterfaceTypeDescription_Base(entity->isPublished()), context_(context),
         name_(name), entity_(entity)
     { assert(entity.is()); }
@@ -810,7 +813,7 @@ private:
 
     css::uno::Reference< css::uno::XComponentContext > context_;
     rtl::OUString name_;
-    rtl::Reference< cppu::unoidl::InterfaceTypeEntity > entity_;
+    rtl::Reference< unoidl::InterfaceTypeEntity > entity_;
 };
 
 css::uno::Sequence<
@@ -905,7 +908,7 @@ public:
     ConstantGroupDescription(
         css::uno::Reference< css::uno::XComponentContext > const & context,
         rtl::OUString const & name,
-        rtl::Reference< cppu::unoidl::ConstantGroupEntity > const & entity):
+        rtl::Reference< unoidl::ConstantGroupEntity > const & entity):
         ConstantGroupDescription_Base(entity->isPublished()), context_(context),
         name_(name), entity_(entity)
     { assert(entity.is()); }
@@ -927,7 +930,7 @@ private:
 
     css::uno::Reference< css::uno::XComponentContext > context_;
     rtl::OUString name_;
-    rtl::Reference< cppu::unoidl::ConstantGroupEntity > entity_;
+    rtl::Reference< unoidl::ConstantGroupEntity > entity_;
 };
 
 css::uno::Sequence<
@@ -955,7 +958,7 @@ public:
     TypedefDescription(
         css::uno::Reference< css::uno::XComponentContext > const & context,
         rtl::OUString const & name,
-        rtl::Reference< cppu::unoidl::TypedefEntity > const & entity):
+        rtl::Reference< unoidl::TypedefEntity > const & entity):
         TypedefDescription_Base(entity->isPublished()), context_(context),
         name_(name), entity_(entity)
     { assert(entity.is()); }
@@ -976,7 +979,7 @@ private:
 
     css::uno::Reference< css::uno::XComponentContext > context_;
     rtl::OUString name_;
-    rtl::Reference< cppu::unoidl::TypedefEntity > entity_;
+    rtl::Reference< unoidl::TypedefEntity > entity_;
 };
 
 class ConstructorParameter:
@@ -986,7 +989,7 @@ class ConstructorParameter:
 public:
     ConstructorParameter(
         css::uno::Reference< css::uno::XComponentContext > const & context,
-        cppu::unoidl::SingleInterfaceBasedServiceEntity::Constructor::Parameter
+        unoidl::SingleInterfaceBasedServiceEntity::Constructor::Parameter
             const & parameter,
         sal_Int32 position):
         context_(context), parameter_(parameter), position_(position)
@@ -1016,7 +1019,7 @@ private:
     { return parameter_.rest; }
 
     css::uno::Reference< css::uno::XComponentContext > context_;
-    cppu::unoidl::SingleInterfaceBasedServiceEntity::Constructor::Parameter
+    unoidl::SingleInterfaceBasedServiceEntity::Constructor::Parameter
         parameter_;
     sal_Int32 position_;
 };
@@ -1029,7 +1032,7 @@ class ConstructorDescription:
 public:
     ConstructorDescription(
         css::uno::Reference< css::uno::XComponentContext > const & context,
-        cppu::unoidl::SingleInterfaceBasedServiceEntity::Constructor const &
+        unoidl::SingleInterfaceBasedServiceEntity::Constructor const &
             constructor):
         context_(context), constructor_(constructor)
     {}
@@ -1055,7 +1058,7 @@ private:
     SAL_CALL getExceptions() throw (css::uno::RuntimeException);
 
     css::uno::Reference< css::uno::XComponentContext > context_;
-    cppu::unoidl::SingleInterfaceBasedServiceEntity::Constructor constructor_;
+    unoidl::SingleInterfaceBasedServiceEntity::Constructor constructor_;
 };
 
 css::uno::Sequence< css::uno::Reference< css::reflection::XParameter > >
@@ -1097,8 +1100,8 @@ public:
     SingleInterfaceBasedServiceDescription(
         css::uno::Reference< css::uno::XComponentContext > const & context,
         rtl::OUString const & name,
-        rtl::Reference< cppu::unoidl::SingleInterfaceBasedServiceEntity >
-            const & entity):
+        rtl::Reference< unoidl::SingleInterfaceBasedServiceEntity > const &
+            entity):
         SingleInterfaceBasedServiceDescription_Base(entity->isPublished()),
         context_(context), name_(name), entity_(entity)
     { assert(entity.is()); }
@@ -1176,7 +1179,7 @@ private:
 
     css::uno::Reference< css::uno::XComponentContext > context_;
     rtl::OUString name_;
-    rtl::Reference< cppu::unoidl::SingleInterfaceBasedServiceEntity > entity_;
+    rtl::Reference< unoidl::SingleInterfaceBasedServiceEntity > entity_;
 };
 
 css::uno::Sequence<
@@ -1203,8 +1206,7 @@ class PropertyDescription:
 public:
     PropertyDescription(
         css::uno::Reference< css::uno::XComponentContext > const & context,
-        cppu::unoidl::AccumulationBasedServiceEntity::Property const &
-            property):
+        unoidl::AccumulationBasedServiceEntity::Property const & property):
         context_(context), property_(property)
     {}
 
@@ -1227,7 +1229,7 @@ private:
     { return resolve(context_, property_.type); }
 
     css::uno::Reference< css::uno::XComponentContext > context_;
-    cppu::unoidl::AccumulationBasedServiceEntity::Property property_;
+    unoidl::AccumulationBasedServiceEntity::Property property_;
 };
 
 typedef cppu::ImplInheritanceHelper1<
@@ -1241,7 +1243,7 @@ public:
     AccumulationBasedServiceDescription(
         css::uno::Reference< css::uno::XComponentContext > const & context,
         rtl::OUString const & name,
-        rtl::Reference< cppu::unoidl::AccumulationBasedServiceEntity > const &
+        rtl::Reference< unoidl::AccumulationBasedServiceEntity > const &
             entity):
         AccumulationBasedServiceDescription_Base(entity->isPublished()),
         context_(context), name_(name), entity_(entity)
@@ -1302,7 +1304,7 @@ private:
 
     css::uno::Reference< css::uno::XComponentContext > context_;
     rtl::OUString name_;
-    rtl::Reference< cppu::unoidl::AccumulationBasedServiceEntity > entity_;
+    rtl::Reference< unoidl::AccumulationBasedServiceEntity > entity_;
 };
 
 css::uno::Sequence<
@@ -1411,8 +1413,7 @@ public:
     InterfaceBasedSingletonDescription(
         css::uno::Reference< css::uno::XComponentContext > const & context,
         rtl::OUString const & name,
-        rtl::Reference< cppu::unoidl::InterfaceBasedSingletonEntity > const &
-            entity):
+        rtl::Reference< unoidl::InterfaceBasedSingletonEntity > const & entity):
         InterfaceBasedSingletonDescription_Base(entity->isPublished()),
         context_(context), name_(name), entity_(entity)
     { assert(entity.is()); }
@@ -1444,7 +1445,7 @@ private:
 
     css::uno::Reference< css::uno::XComponentContext > context_;
     rtl::OUString name_;
-    rtl::Reference< cppu::unoidl::InterfaceBasedSingletonEntity > entity_;
+    rtl::Reference< unoidl::InterfaceBasedSingletonEntity > entity_;
 };
 
 typedef cppu::ImplInheritanceHelper1<
@@ -1458,8 +1459,7 @@ public:
     ServiceBasedSingletonDescription(
         css::uno::Reference< css::uno::XComponentContext > const & context,
         rtl::OUString const & name,
-        rtl::Reference< cppu::unoidl::ServiceBasedSingletonEntity > const &
-            entity):
+        rtl::Reference< unoidl::ServiceBasedSingletonEntity > const & entity):
         ServiceBasedSingletonDescription_Base(entity_->isPublished()),
         context_(context), name_(name), entity_(entity)
     { assert(entity.is()); }
@@ -1491,7 +1491,7 @@ private:
 
     css::uno::Reference< css::uno::XComponentContext > context_;
     rtl::OUString name_;
-    rtl::Reference< cppu::unoidl::ServiceBasedSingletonEntity > entity_;
+    rtl::Reference< unoidl::ServiceBasedSingletonEntity > entity_;
 };
 
 class Enumeration:
@@ -1503,7 +1503,7 @@ public:
     Enumeration(
         css::uno::Reference< css::uno::XComponentContext > const & context,
         rtl::OUString const & prefix,
-        rtl::Reference< cppu::unoidl::MapCursor > const & cursor,
+        rtl::Reference< unoidl::MapCursor > const & cursor,
         css::uno::Sequence< css::uno::TypeClass > const & types, bool deep):
         context_(context), types_(types), deep_(deep)
     {
@@ -1536,22 +1536,22 @@ private:
     struct Position {
         Position(
             rtl::OUString const & thePrefix,
-            rtl::Reference< cppu::unoidl::MapCursor > const & theCursor):
+            rtl::Reference< unoidl::MapCursor > const & theCursor):
             prefix(thePrefix), cursor(theCursor)
         { assert(theCursor.is()); }
 
         Position(
             rtl::OUString const & thePrefix,
-            rtl::Reference< cppu::unoidl::ConstantGroupEntity > const &
+            rtl::Reference< unoidl::ConstantGroupEntity > const &
                 theConstantGroup):
             prefix(thePrefix), constantGroup(theConstantGroup),
             constantGroupIndex(constantGroup->getMembers().begin())
         { assert(theConstantGroup.is()); }
 
         rtl::OUString prefix;
-        rtl::Reference< cppu::unoidl::MapCursor > cursor;
-        rtl::Reference< cppu::unoidl::ConstantGroupEntity > constantGroup;
-        std::vector< cppu::unoidl::ConstantGroupEntity::Member >::const_iterator
+        rtl::Reference< unoidl::MapCursor > cursor;
+        rtl::Reference< unoidl::ConstantGroupEntity > constantGroup;
+        std::vector< unoidl::ConstantGroupEntity::Member >::const_iterator
             constantGroupIndex;
     };
 
@@ -1595,87 +1595,93 @@ bool Enumeration::matches(css::uno::TypeClass tc) const {
 }
 
 void Enumeration::findNextMatch() {
-    for (;;) {
-        assert(!positions_.empty());
-        rtl::OUString name;
-        if (positions_.top().cursor.is()) { // root or module
-            rtl::Reference< cppu::unoidl::Entity > ent(
-                positions_.top().cursor->getNext(&name));
-            if (!ent.is()) {
-                positions_.pop();
-                if (positions_.empty()) {
+    try {
+        for (;;) {
+            assert(!positions_.empty());
+            rtl::OUString name;
+            if (positions_.top().cursor.is()) { // root or module
+                rtl::Reference< unoidl::Entity > ent(
+                    positions_.top().cursor->getNext(&name));
+                if (!ent.is()) {
+                    positions_.pop();
+                    if (positions_.empty()) {
+                        break;
+                    }
+                    continue;
+                }
+                name = positions_.top().prefix + name;
+                css::uno::TypeClass tc;
+                switch (ent->getSort()) {
+                case unoidl::Entity::SORT_MODULE:
+                    tc = css::uno::TypeClass_MODULE;
+                    if (deep_) {
+                        positions_.push(
+                            Position(
+                                name + ".",
+                                static_cast< unoidl::ModuleEntity * >(
+                                    ent.get())->createCursor()));
+                    }
+                    break;
+                case unoidl::Entity::SORT_ENUM_TYPE:
+                    tc = css::uno::TypeClass_ENUM;
+                    break;
+                case unoidl::Entity::SORT_PLAIN_STRUCT_TYPE:
+                case unoidl::Entity::SORT_POLYMORPHIC_STRUCT_TYPE_TEMPLATE:
+                    tc = css::uno::TypeClass_STRUCT;
+                    break;
+                case unoidl::Entity::SORT_EXCEPTION_TYPE:
+                    tc = css::uno::TypeClass_EXCEPTION;
+                    break;
+                case unoidl::Entity::SORT_INTERFACE_TYPE:
+                    tc = css::uno::TypeClass_INTERFACE;
+                    break;
+                case unoidl::Entity::SORT_TYPEDEF:
+                    tc = css::uno::TypeClass_TYPEDEF;
+                    break;
+                case unoidl::Entity::SORT_CONSTANT_GROUP:
+                    tc = css::uno::TypeClass_CONSTANTS;
+                    if (deep_ && matches(css::uno::TypeClass_CONSTANT)) {
+                        positions_.push(
+                            Position(
+                                name + ".",
+                                static_cast< unoidl::ConstantGroupEntity * >(
+                                    ent.get())));
+                    }
                     break;
+                case unoidl::Entity::SORT_SINGLE_INTERFACE_BASED_SERVICE:
+                case unoidl::Entity::SORT_ACCUMULATION_BASED_SERVICE:
+                    tc = css::uno::TypeClass_SERVICE;
+                    break;
+                case unoidl::Entity::SORT_INTERFACE_BASED_SINGLETON:
+                case unoidl::Entity::SORT_SERVICE_BASED_SINGLETON:
+                    tc = css::uno::TypeClass_SINGLETON;
+                    break;
+                default:
+                    for (;;) { std::abort(); } // this cannot happen
                 }
-                continue;
-            }
-            name = positions_.top().prefix + name;
-            css::uno::TypeClass tc;
-            switch (ent->getSort()) {
-            case cppu::unoidl::Entity::SORT_MODULE:
-                tc = css::uno::TypeClass_MODULE;
-                if (deep_) {
-                    positions_.push(
-                        Position(
-                            name + ".",
-                            static_cast< cppu::unoidl::ModuleEntity * >(
-                                ent.get())->createCursor()));
+                if (matches(tc)) {
+                    current_ = name;
+                    break;
                 }
-                break;
-            case cppu::unoidl::Entity::SORT_ENUM_TYPE:
-                tc = css::uno::TypeClass_ENUM;
-                break;
-            case cppu::unoidl::Entity::SORT_PLAIN_STRUCT_TYPE:
-            case cppu::unoidl::Entity::SORT_POLYMORPHIC_STRUCT_TYPE_TEMPLATE:
-                tc = css::uno::TypeClass_STRUCT;
-                break;
-            case cppu::unoidl::Entity::SORT_EXCEPTION_TYPE:
-                tc = css::uno::TypeClass_EXCEPTION;
-                break;
-            case cppu::unoidl::Entity::SORT_INTERFACE_TYPE:
-                tc = css::uno::TypeClass_INTERFACE;
-                break;
-            case cppu::unoidl::Entity::SORT_TYPEDEF:
-                tc = css::uno::TypeClass_TYPEDEF;
-                break;
-            case cppu::unoidl::Entity::SORT_CONSTANT_GROUP:
-                tc = css::uno::TypeClass_CONSTANTS;
-                if (deep_ && matches(css::uno::TypeClass_CONSTANT)) {
-                    positions_.push(
-                        Position(
-                            name + ".",
-                            static_cast< cppu::unoidl::ConstantGroupEntity * >(
-                                ent.get())));
+            } else { // constant group
+                if (positions_.top().constantGroupIndex
+                    == positions_.top().constantGroup->getMembers().end())
+                {
+                    positions_.pop();
+                    if (positions_.empty()) {
+                        break;
+                    }
+                    continue;
                 }
+                current_ = positions_.top().prefix
+                    + positions_.top().constantGroupIndex++->name;
                 break;
-            case cppu::unoidl::Entity::SORT_SINGLE_INTERFACE_BASED_SERVICE:
-            case cppu::unoidl::Entity::SORT_ACCUMULATION_BASED_SERVICE:
-                tc = css::uno::TypeClass_SERVICE;
-                break;
-            case cppu::unoidl::Entity::SORT_INTERFACE_BASED_SINGLETON:
-            case cppu::unoidl::Entity::SORT_SERVICE_BASED_SINGLETON:
-                tc = css::uno::TypeClass_SINGLETON;
-                break;
-            default:
-                for (;;) { std::abort(); } // this cannot happen
-            }
-            if (matches(tc)) {
-                current_ = name;
-                break;
-            }
-        } else { // constant group
-            if (positions_.top().constantGroupIndex
-                == positions_.top().constantGroup->getMembers().end())
-            {
-                positions_.pop();
-                if (positions_.empty()) {
-                    break;
-                }
-                continue;
             }
-            current_ = positions_.top().prefix
-                + positions_.top().constantGroupIndex++->name;
-            break;
         }
+    } catch (unoidl::FileFormatException & e) {
+        throw css::uno::DeploymentException(
+            e.getUri() + ": " + e.getDetail(),
+            static_cast< cppu::OWeakObject * >(this));
     }
 }
 
@@ -1688,11 +1694,12 @@ class Provider:
     private osl::Mutex, public Provider_Base, private boost::noncopyable
 {
 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 cppu::UnoidlProvider(uri))
+        provider_(new unoidl::UnoidlProvider(uri))
     {}
 
     using Provider_Base::acquire;
@@ -1709,8 +1716,7 @@ private:
             css::container::NoSuchElementException, css::uno::RuntimeException);
 
     virtual sal_Bool SAL_CALL hasByHierarchicalName(
-        rtl::OUString const & aName) throw (css::uno::RuntimeException)
-    { return provider_->find(aName) != 0; }
+        rtl::OUString const & aName) throw (css::uno::RuntimeException);
 
     virtual css::uno::Reference< css::reflection::XTypeDescriptionEnumeration >
     SAL_CALL createTypeDescriptionEnumeration(
@@ -1723,117 +1729,169 @@ private:
             css::uno::RuntimeException);
 
     css::uno::Reference< css::uno::XComponentContext > context_;
-    rtl::Reference< cppu::UnoidlProvider > provider_;
+    rtl::Reference< unoidl::UnoidlProvider > provider_;
 };
 
 css::uno::Any Provider::getByHierarchicalName(rtl::OUString const & aName)
     throw (css::container::NoSuchElementException, css::uno::RuntimeException)
 {
-    bool cnst;
-    sal_uInt32 off = provider_->find(aName, &cnst);
-    if (off == 0) {
-        throw css::container::NoSuchElementException(
-            aName, static_cast< cppu::OWeakObject * >(this));
-    }
-    if (cnst) {
-        return css::uno::makeAny<
-            css::uno::Reference< css::reflection::XTypeDescription > >(
-                new ConstantDescription(aName, provider_->getConstant(off)));
-    } else {
-        rtl::Reference< cppu::unoidl::Entity > ent(provider_->getEntity(off));
-        switch (ent->getSort()) {
-        case cppu::unoidl::Entity::SORT_MODULE:
-            return css::uno::makeAny<
-                css::uno::Reference< css::reflection::XTypeDescription > >(
-                    new ModuleDescription(
-                        context_, aName,
-                        static_cast< cppu::unoidl::ModuleEntity * >(
-                            ent.get())));
-        case cppu::unoidl::Entity::SORT_ENUM_TYPE:
-            return css::uno::makeAny<
-                css::uno::Reference< css::reflection::XTypeDescription > >(
-                    new EnumTypeDescription(
-                        aName,
-                        static_cast< cppu::unoidl::EnumTypeEntity * >(
-                            ent.get())));
-        case cppu::unoidl::Entity::SORT_PLAIN_STRUCT_TYPE:
-            return css::uno::makeAny<
-                css::uno::Reference< css::reflection::XTypeDescription > >(
-                    new PlainStructTypeDescription(
-                        context_, aName,
-                        static_cast< cppu::unoidl::PlainStructTypeEntity * >(
-                            ent.get())));
-        case cppu::unoidl::Entity::SORT_POLYMORPHIC_STRUCT_TYPE_TEMPLATE:
-            return css::uno::makeAny<
-                css::uno::Reference< css::reflection::XTypeDescription > >(
-                    new PolymorphicStructTypeTemplateDescription(
-                        context_, aName,
-                        static_cast<
-                            cppu::unoidl::PolymorphicStructTypeTemplateEntity *
-                                >(ent.get())));
-        case cppu::unoidl::Entity::SORT_EXCEPTION_TYPE:
-            return css::uno::makeAny<
-                css::uno::Reference< css::reflection::XTypeDescription > >(
-                    new ExceptionTypeDescription(
-                        context_, aName,
-                        static_cast< cppu::unoidl::ExceptionTypeEntity * >(
-                            ent.get())));
-        case cppu::unoidl::Entity::SORT_INTERFACE_TYPE:
-            return css::uno::makeAny<
-                css::uno::Reference< css::reflection::XTypeDescription > >(
-                    new InterfaceTypeDescription(
-                        context_, aName,
-                        static_cast< cppu::unoidl::InterfaceTypeEntity * >(
-                            ent.get())));
-        case cppu::unoidl::Entity::SORT_TYPEDEF:
-            return css::uno::makeAny<
-                css::uno::Reference< css::reflection::XTypeDescription > >(
-                    new TypedefDescription(
-                        context_, aName,
-                        static_cast< cppu::unoidl::TypedefEntity * >(
-                            ent.get())));
-        case cppu::unoidl::Entity::SORT_CONSTANT_GROUP:
-            return css::uno::makeAny<
-                css::uno::Reference< css::reflection::XTypeDescription > >(
-                    new ConstantGroupDescription(
-                        context_, aName,
-                        static_cast< cppu::unoidl::ConstantGroupEntity * >(
-                            ent.get())));
-        case cppu::unoidl::Entity::SORT_SINGLE_INTERFACE_BASED_SERVICE:
+    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
+            }
             return css::uno::makeAny<
                 css::uno::Reference< css::reflection::XTypeDescription > >(
-                    new SingleInterfaceBasedServiceDescription(
-                        context_, aName,
-                        static_cast<
-                            cppu::unoidl::SingleInterfaceBasedServiceEntity * >(
+                    new ConstantDescription(aName, val2));
+        } else {
+            rtl::Reference< unoidl::Entity > ent(provider_->getEntity(off));
+            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 cppu::unoidl::Entity::SORT_ACCUMULATION_BASED_SERVICE:
-            return css::uno::makeAny<
-                css::uno::Reference< css::reflection::XTypeDescription > >(
-                    new AccumulationBasedServiceDescription(
-                        context_, aName,
-                        static_cast<
-                            cppu::unoidl::AccumulationBasedServiceEntity * >(
+            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 cppu::unoidl::Entity::SORT_INTERFACE_BASED_SINGLETON:
-            return css::uno::makeAny<
-                css::uno::Reference< css::reflection::XTypeDescription > >(
-                    new InterfaceBasedSingletonDescription(
-                        context_, aName,
-                        static_cast<
-                            cppu::unoidl::InterfaceBasedSingletonEntity * >(
+            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 cppu::unoidl::Entity::SORT_SERVICE_BASED_SINGLETON:
-            return css::uno::makeAny<
-                css::uno::Reference< css::reflection::XTypeDescription > >(
-                    new ServiceBasedSingletonDescription(
-                        context_, aName,
-                        static_cast<
-                            cppu::unoidl::ServiceBasedSingletonEntity * >(
+            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())));
-        default:
-            for (;;) { std::abort(); } // this cannot happen
+            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())));
+            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())));
+            default:
+                for (;;) { std::abort(); } // this cannot happen
+            }
         }
+    } catch (unoidl::FileFormatException & e) {
+        throw css::uno::DeploymentException(
+            e.getUri() + ": " + e.getDetail(),
+            static_cast< cppu::OWeakObject * >(this));
+    }
+}
+
+sal_Bool Provider::hasByHierarchicalName(
+    rtl::OUString const & aName) 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));
     }
 }
 
@@ -1846,33 +1904,39 @@ Provider::createTypeDescriptionEnumeration(
         css::reflection::NoSuchTypeNameException,
         css::reflection::InvalidTypeNameException, css::uno::RuntimeException)
 {
-    rtl::OUString prefix;
-    rtl::Reference< cppu::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< cppu::unoidl::Entity > ent(provider_->getEntity(off));
-        if (ent->getSort() != cppu::unoidl::Entity::SORT_MODULE) {
-            throw css::reflection::InvalidTypeNameException(
-                moduleName, static_cast< cppu::OWeakObject * >(this));
+    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();
         }
-        cursor = static_cast< cppu::unoidl::ModuleEntity * >(ent.get())->
-            createCursor();
+        return new Enumeration(
+            context_, prefix, cursor, types,
+            depth == css::reflection::TypeDescriptionSearchDepth_INFINITE);
+    } catch (unoidl::FileFormatException & e) {
+        throw css::uno::DeploymentException(
+            e.getUri() + ": " + e.getDetail(),
+            static_cast< cppu::OWeakObject * >(this));
     }
-    return new Enumeration(
-        context_, prefix, cursor, types,
-        depth == css::reflection::TypeDescriptionSearchDepth_INFINITE);
 }
 
 css::uno::Reference< css::container::XHierarchicalNameAccess >
@@ -1916,7 +1980,7 @@ void readRdbFile(
     css::uno::Reference< css::container::XHierarchicalNameAccess > prov;
     try {
         prov = new Provider(context, uri);
-    } catch (css::container::NoSuchElementException &) {
+    } catch (unoidl::NoSuchFileException &) {
         if (optional) {
             SAL_INFO("cppuhelper", "Ignored optional " << uri);
             return;
@@ -1924,7 +1988,7 @@ void readRdbFile(
         throw css::uno::DeploymentException(
             uri + ": no such file",
             css::uno::Reference< css::uno::XInterface >());
-    } catch (css::registry::InvalidRegistryException &) {
+    } catch (unoidl::FileFormatException &) {
         prov = readLegacyRdbFile(uri, serviceManager, context);
     }
     assert(prov.is());
diff --git a/cppuhelper/source/unoidl.cxx b/cppuhelper/source/unoidl.cxx
deleted file mode 100644
index b9109af0416f..000000000000
--- a/cppuhelper/source/unoidl.cxx
+++ /dev/null
@@ -1,63 +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/.
- */
-
-#include "sal/config.h"
-
-#include <vector>
-
-#include "cppuhelper/unoidl.hxx"
-#include "rtl/ref.hxx"
-#include "rtl/ustring.hxx"
-
-#include "unoidlprovider.hxx"
-
-namespace cppu { namespace unoidl {
-
-Entity::~Entity() throw () {}
-
-MapCursor::~MapCursor() throw () {}
-
-ModuleEntity::~ModuleEntity() throw () {}
-
-PublishableEntity::~PublishableEntity() throw () {}
-
-EnumTypeEntity::~EnumTypeEntity() throw () {}
-
-PlainStructTypeEntity::~PlainStructTypeEntity() throw () {}
-
-PolymorphicStructTypeTemplateEntity::~PolymorphicStructTypeTemplateEntity()
-    throw ()
-{}
-
-ExceptionTypeEntity::~ExceptionTypeEntity() throw () {}
-
-InterfaceTypeEntity::~InterfaceTypeEntity() throw () {}
-
-TypedefEntity::~TypedefEntity() throw () {}
-
-ConstantGroupEntity::~ConstantGroupEntity() throw () {}
-
-SingleInterfaceBasedServiceEntity::~SingleInterfaceBasedServiceEntity() throw ()
-{}
-
-AccumulationBasedServiceEntity::~AccumulationBasedServiceEntity() throw () {}
-
-InterfaceBasedSingletonEntity::~InterfaceBasedSingletonEntity() throw () {}
-
-ServiceBasedSingletonEntity::~ServiceBasedSingletonEntity() throw () {}
-
-Provider::~Provider() throw () {}
-
-rtl::Reference< Provider > loadProvider(rtl::OUString const & uri) {
-    return new UnoidlProvider(uri);
-}
-
-} }
-
-/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/cppuhelper/source/unoidlprovider.cxx b/cppuhelper/source/unoidlprovider.cxx
deleted file mode 100644
index 12b497490c87..000000000000
--- a/cppuhelper/source/unoidlprovider.cxx
+++ /dev/null
@@ -1,1363 +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/.
- */
-
-#include "sal/config.h"
-
-#include <algorithm>
-#include <cassert>
-#include <cstring>
-#include <vector>
-
-#include "com/sun/star/container/NoSuchElementException.hpp"
-#include "com/sun/star/registry/InvalidRegistryException.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/XInterface.hpp"
-#include "cppuhelper/unoidl.hxx"
-#include "osl/endian.h"
-#include "osl/file.h"
-#include "rtl/ref.hxx"
-#include "rtl/ustring.hxx"
-#include "sal/log.hxx"
-#include "sal/types.h"
-#include "salhelper/simplereferenceobject.hxx"
-
-#include "unoidlprovider.hxx"
-
-// New binary format:
-//
-// Uses the following definitions:
-//
-// * UInt16: 2-byte value, LSB first
-// * UInt32: 4-byte value, LSB first
-// * UInt64: 8-byte value, LSB first
-// * Offset: UInt32 value, counting bytes from start of file
-// * NUL-Name: zero or more non-NUL US-ASCII bytes followed by a NUL byte
-// * Len-Name: UInt32 number of characters, with 0x80000000 bit 1, followed by
-//    that many (- 0x80000000) US-ASCII bytes
-// * Idx-Name: either an Offset (with 0x80000000 bit 0) of a Len-Name, or a
-//    Len-Name
-// * Entry: Offset of NUL-Name followed by Offset of payload
-// * Map: zero or more Entries
-//
-// Layout of per-entry payload in the root or a module Map:
-//
-// * kind byte:
-// ** 0: module
-// *** followed by:
-// **** UInt32 number N1 of entries of Map
-// **** N1 * Entry
-// ** otherwise:
-// *** 0x80 bit: 1 if published
-// *** 0x40 bit: 1 if deprecated
-// *** 0x20 bit: flag (may only be 1 for certain kinds, see below)
-// *** remaining bits:
-// **** 1: enum type
-// ***** followed by:
-// ****** UInt32 number N1 of members
-// ****** N1 * tuple of:
-// ******* Offset of Idx-Name
-// ******* UInt32
-// **** 2: plain struct type (with base if flag is 1)
-// ***** followed by:
-// ****** if "with base": Offset of Idx-Name
-// ****** UInt32 number N1 of direct members
-// ****** N1 * tuple of:
-// ******* Offset of Idx-Name name
-// ******* Offset of Idx-Name type
-// **** 3: polymorphic struct type template
-// ***** followed by:
-// ****** UInt32 number N1 of type parameters
-// ****** N1 * Offset of Idx-Name
-// ****** UInt32 number N2 of members
-// ****** N2 * tuple of:
-// ******* kind byte: 0x01 bit is 1 if parameterized type
-// ******* Offset of Idx-Name name
-// ******* Offset of Idx-Name type
-// **** 4: exception type (with base if flag is 1)
-// ***** followed by:
-// ****** if "with base": Offset of Idx-Name
-// ****** UInt32 number N1 of direct members
-// ****** N1 * tuple of:
-// ******* Offset of Idx-Name name
-// ******* Offset of Idx-Name type
-// **** 5: interface type
-// ***** followed by:
-// ****** UInt32 number N1 of direct mandatory bases
-// ****** N1 * Offset of Idx-Name
-// ****** UInt32 number N2 of direct optional bases
-// ****** N2 * Offset of Idx-Name
-// ****** UInt32 number N3 of direct attributes
-// ****** N3 * tuple of:
-// ******* kind byte:
-// ******** 0x02 bit: 1 if read-only
-// ******** 0x01 bit: 1 if bound
-// ******* Offset of Idx-Name name
-// ******* Offset of Idx-Name type
-// ******* UInt32 number N4 of get exceptions
-// ******* N4 * Offset of Idx-Name
-// ******* UInt32 number N5 of set exceptions
-// ******* N5 * Offset of Idx-Name
-// ****** UInt32 number N6 of direct methods
-// ****** N6 * tuple of:
-// ******* Offset of Idx-Name name
-// ******* Offset of Idx-Name return type
-// ******* UInt32 number N7 of parameters
-// ******* N7 * tuple of:
-// ******** direction byte: 0 for in, 1 for out, 2 for in-out
-// ******** Offset of Idx-Name name
-// ******** Offset of Idx-Name type
-// ******* UInt32 number N8 of exceptions
-// ******* N8 * Offset of Idx-Name
-// **** 6: typedef
-// ***** followed by:
-// ****** Offset of Idx-Name
-// **** 7: constant group
-// ***** followed by:
-// ****** UInt32 number N1 of entries of Map
-// ****** N1 * Entry
-// **** 8: single-interface--based service (with default constructor if flag is
-//       1)
-// ***** followed by:
-// ****** Offset of Idx-Name
-// ****** if not "with default constructor":
-// ******* UInt32 number N1 of constructors
-// ******* N1 * tuple of:
-// ******** Offset of Idx-Name
-// ******** UInt32 number N2 of parameters
-// ******** N2 * tuple of
-// ********* kind byte: 0x04 bit is 1 if rest parameter
-// ********* Offset of Idx-Name name
-// ********* Offset of Idx-Name type
-// ******** UInt32 number N3 of exceptions
-// ******** N3 * Offset of Idx-Name
-// **** 9: accumulation-based service
-// ***** followed by:
-// ****** UInt32 number N1 of direct mandatory base services
-// ****** N1 * Offset of Idx-Name
-// ****** UInt32 number N2 of direct optional base services
-// ****** N2 * Offset of Idx-Name
-// ****** UInt32 number N3 of direct mandatory base interfaces
-// ****** N3 * Offset of Idx-Name
-// ****** UInt32 number N4 of direct optional base interfaces
-// ****** N4 * Offset of Idx-Name
-// ****** UInt32 number N5 of direct properties
-// ****** N5 * tuple of:
-// ******* UInt16 kind:
-// ******** 0x0100 bit: 1 if optional
-// ******** 0x0080 bit: 1 if removable
-// ******** 0x0040 bit: 1 if maybedefault
-// ******** 0x0020 bit: 1 if maybeambiguous
-// ******** 0x0010 bit: 1 if readonly
-// ******** 0x0008 bit: 1 if transient
-// ******** 0x0004 bit: 1 if constrained
-// ******** 0x0002 bit: 1 if bound
-// ******** 0x0001 bit: 1 if maybevoid
-// ******* Offset of Idx-Name name
-// ******* Offset of Idx-Name type
-// **** 10: interface-based singleton
-// ***** followed by:
-// ****** Offset of Idx-Name
-// **** 11: service-based singleton
-// ***** followed by:
-// ****** Offset of Idx-Name
-//
-// Layout of per-entry payload in a constant group Map:
-//
-// * kind byte:
-// ** 0x80 bit: 1 if deprecated
-// ** remaining bits:
-// *** 0: BOOLEAN
-// **** followed by value byte, 0 represents false, 1 represents true
-// *** 1: BYTE
-// **** followed by value byte, representing values with two's complement
-// *** 2: SHORT
-// **** followed by UInt16 value, representing values with two's complement
-// *** 3: UNSIGNED SHORT
-// **** followed by UInt16 value
-// *** 4: LONG
-// **** followed by UInt32 value, representing values with two's complement
-// *** 5: UNSIGNED LONG
-// **** followed by UInt32 value
-// *** 6: HYPER
-// **** followed by UInt64 value, representing values with two's complement
-// *** 7: UNSIGNED HYPER
-// **** followed by UInt64 value
-// *** 8: FLOAT
-// **** followed by 4-byte value, representing values in ISO 60599 binary32
-//       format, LSB first
-// *** 9: DOUBLE
-// **** followed by 8-byte value, representing values in ISO 60599 binary64
-//       format, LSB first
-//
-// Memory layout:
-//
-// * 8 byte header "UNOIDL\0\xFF
-// * Offset of root Map
-// * UInt32 number of entries of root Map
-// ...
-
-namespace {
-
-// sizeof (Memory16) == 2
-struct Memory16 {
-    unsigned char byte[2];
-
-    sal_uInt16 getUnsigned16() const {
-        return static_cast< sal_uInt16 >(byte[0])
-            | (static_cast< sal_uInt16 >(byte[1]) << 8);
-    }
-};
-
-// sizeof (Memory32) == 4
-struct Memory32 {
-    unsigned char byte[4];
-
-    sal_uInt32 getUnsigned32() const {
-        return static_cast< sal_uInt32 >(byte[0])
-            | (static_cast< sal_uInt32 >(byte[1]) << 8)
-            | (static_cast< sal_uInt32 >(byte[2]) << 16)
-            | (static_cast< sal_uInt32 >(byte[3]) << 24);
-    }
-
-    float getIso60599Binary32() const {
-        union {
-            unsigned char buf[4];
-            float f; // assuming float is ISO 60599 binary32
-        } sa;
-#if defined OSL_LITENDIAN
-        sa.buf[0] = byte[0];
-        sa.buf[1] = byte[1];
-        sa.buf[2] = byte[2];
-        sa.buf[3] = byte[3];
-#else
-        sa.buf[0] = byte[3];
-        sa.buf[1] = byte[2];
-        sa.buf[2] = byte[1];
-        sa.buf[3] = byte[0];
-#endif
-        return sa.f;
-    }
-};
-
-// sizeof (Memory64) == 8
-struct Memory64 {
-    unsigned char byte[8];
-
-    sal_uInt64 getUnsigned64() const {
-        return static_cast< sal_uInt64 >(byte[0])
-            | (static_cast< sal_uInt64 >(byte[1]) << 8)
-            | (static_cast< sal_uInt64 >(byte[2]) << 16)
-            | (static_cast< sal_uInt64 >(byte[3]) << 24)
-            | (static_cast< sal_uInt64 >(byte[4]) << 32)
-            | (static_cast< sal_uInt64 >(byte[5]) << 40)
-            | (static_cast< sal_uInt64 >(byte[6]) << 48)
-            | (static_cast< sal_uInt64 >(byte[7]) << 56);
-        }
-
-    double getIso60599Binary64() const {
-        union {
-            unsigned char buf[8];
-            double d; // assuming double is ISO 60599 binary64
-        } sa;
-#if defined OSL_LITENDIAN
-        sa.buf[0] = byte[0];
-        sa.buf[1] = byte[1];
-        sa.buf[2] = byte[2];
-        sa.buf[3] = byte[3];
-        sa.buf[4] = byte[4];
-        sa.buf[5] = byte[5];
-        sa.buf[6] = byte[6];
-        sa.buf[7] = byte[7];
-#else
-        sa.buf[0] = byte[7];
-        sa.buf[1] = byte[6];
-        sa.buf[2] = byte[5];
-        sa.buf[3] = byte[4];
-        sa.buf[4] = byte[3];
-        sa.buf[5] = byte[2];
-        sa.buf[6] = byte[1];
-        sa.buf[7] = byte[0];
-#endif
-        return sa.d;
-    }
-};
-
-}
-
-namespace cppu {
-
-class MappedFile: public salhelper::SimpleReferenceObject {
-public:
-    explicit MappedFile(rtl::OUString const & fileUrl);
-
-    sal_uInt8 read8(sal_uInt32 offset) const;
-
-    sal_uInt16 read16(sal_uInt32 offset) const;
-
-    sal_uInt32 read32(sal_uInt32 offset) const;
-
-    sal_uInt64 read64(sal_uInt32 offset) const;
-
-    float readIso60599Binary32(sal_uInt32 offset) const;
-
-    double readIso60599Binary64(sal_uInt32 offset) const;
-
-    rtl::OUString readNameNul(sal_uInt32 offset) const;
-
-    rtl::OUString readNameLen(sal_uInt32 offset, sal_uInt32 * newOffset = 0)
-        const;
-
-    oslFileHandle handle;
-    sal_uInt64 size;
-    void * address;
-
-private:
-    virtual ~MappedFile();
-
-    sal_uInt8 get8(sal_uInt32 offset) const;
-
-    sal_uInt16 get16(sal_uInt32 offset) const;
-
-    sal_uInt32 get32(sal_uInt32 offset) const;
-
-    sal_uInt64 get64(sal_uInt32 offset) const;
-
-    float getIso60599Binary32(sal_uInt32 offset) const;
-
-    double getIso60599Binary64(sal_uInt32 offset) const;
-};
-
-MappedFile::MappedFile(rtl::OUString const & fileUrl) {
-    oslFileError e = osl_openFile(
-        fileUrl.pData, &handle, osl_File_OpenFlag_Read);
-    switch (e) {
-    case osl_File_E_None:
-        break;
-    case osl_File_E_NOENT:
-        throw css::container::NoSuchElementException(
-            fileUrl, css::uno::Reference< css::uno::XInterface >());
-    default:
-        throw css::uno::RuntimeException(
-            "cannot open " + fileUrl + ": " + rtl::OUString::number(e),
-            css::uno::Reference< css::uno::XInterface >());
-    }
-    e = osl_getFileSize(handle, &size);
-    if (e == osl_File_E_None) {
-        e = osl_mapFile(
-            handle, &address, size, 0, osl_File_MapFlag_RandomAccess);
-    }
-    if (e != osl_File_E_None) {
-        oslFileError e2 = osl_closeFile(handle);
-        SAL_WARN_IF(
-            e2 != osl_File_E_None, "cppuhelper",
-            "cannot close " << fileUrl << ": " << +e2);
-        throw css::uno::RuntimeException(
-            "cannot mmap " + fileUrl + ": " + rtl::OUString::number(e),
-            css::uno::Reference< css::uno::XInterface >());
-    }
-}
-
-sal_uInt8 MappedFile::read8(sal_uInt32 offset) const {
-    assert(size >= 8);
-    if (offset > size - 1) {
-        throw css::uno::DeploymentException(
-            "broken UNOIDL file: offset for 8-bit value too large",
-            css::uno::Reference< css::uno::XInterface >());
-    }
-    return get8(offset);
-}
-
-sal_uInt16 MappedFile::read16(sal_uInt32 offset) const {
-    assert(size >= 8);
-    if (offset > size - 2) {
-        throw css::uno::DeploymentException(
-            "broken UNOIDL file: offset for 16-bit value too large",
-            css::uno::Reference< css::uno::XInterface >());
-    }
-    return get16(offset);
-}
-
-sal_uInt32 MappedFile::read32(sal_uInt32 offset) const {
-    assert(size >= 8);
-    if (offset > size - 4) {
-        throw css::uno::DeploymentException(
-            "broken UNOIDL file: offset for 32-bit value too large",
-            css::uno::Reference< css::uno::XInterface >());
-    }
-    return get32(offset);
-}
-
-sal_uInt64 MappedFile::read64(sal_uInt32 offset) const {
-    assert(size >= 8);
-    if (offset > size - 8) {
-        throw css::uno::DeploymentException(
-            "broken UNOIDL file: offset for 64-bit value too large",
-            css::uno::Reference< css::uno::XInterface >());
-    }
-    return get64(offset);
-}
-
-float MappedFile::readIso60599Binary32(sal_uInt32 offset) const {
-    assert(size >= 8);
-    if (offset > size - 4) {
-        throw css::uno::DeploymentException(
-            "broken UNOIDL file: offset for 32-bit value too large",
-            css::uno::Reference< css::uno::XInterface >());
-    }
-    return getIso60599Binary32(offset);
-}
-
-double MappedFile::readIso60599Binary64(sal_uInt32 offset) const {
-    assert(size >= 8);
-    if (offset > size - 8) {
-        throw css::uno::DeploymentException(
-            "broken UNOIDL file: offset for 64-bit value too large",
-            css::uno::Reference< css::uno::XInterface >());
-    }
-    return getIso60599Binary64(offset);
-}
-
-rtl::OUString MappedFile::readNameNul(sal_uInt32 offset) const {
-    if (offset > size) {
-        throw css::uno::DeploymentException(
-            "broken UNOIDL file: offset for string too large",
-            css::uno::Reference< css::uno::XInterface >());
-    }
-    sal_uInt64 end = offset;
-    for (;; ++end) {
-        if (end == size) {
-            throw css::uno::DeploymentException(
-                "broken UNOIDL file: string misses trailing NUL",
-                css::uno::Reference< css::uno::XInterface >());
-        }
-        if (static_cast< char const * >(address)[end] == 0) {
-            break;
-        }
-    }
-    if (end - offset > SAL_MAX_INT32) {
-        throw css::uno::DeploymentException(
-            "broken UNOIDL file: string too long",
-            css::uno::Reference< css::uno::XInterface >());
-    }
-    rtl::OUString name;
-    if (!rtl_convertStringToUString(
-            &name.pData, static_cast< char const * >(address) + offset,
-            end - offset, RTL_TEXTENCODING_ASCII_US,
-            (RTL_TEXTTOUNICODE_FLAGS_UNDEFINED_ERROR
-             | RTL_TEXTTOUNICODE_FLAGS_MBUNDEFINED_ERROR
-             | RTL_TEXTTOUNICODE_FLAGS_INVALID_ERROR)))
-    {
-        throw css::uno::DeploymentException(
-            "broken UNOIDL file: name is not ASCII",
-            css::uno::Reference< css::uno::XInterface >());
-    }
-    return name;
-}
-
-rtl::OUString MappedFile::readNameLen(sal_uInt32 offset, sal_uInt32 * newOffset)
-    const
-{
-    sal_uInt32 len = read32(offset);
-    if ((len & 0x80000000) == 0) {
-        if (newOffset != 0) {
-            *newOffset = offset + 4;
-        }
-        offset = len;
-        len = read32(offset);
-        if ((len & 0x80000000) == 0) {
-            throw css::uno::DeploymentException(
-                "broken UNOIDL file: name length high bit unset",
-                css::uno::Reference< css::uno::XInterface >());
-        }
-        len &= ~0x80000000;
-    } else {
-        len &= ~0x80000000;
-        if (newOffset != 0) {
-            *newOffset = offset + 4 + len;
-        }
-    }
-    if (len > SAL_MAX_INT32 || len > size - offset - 4) {
-        throw css::uno::DeploymentException(
-            "broken UNOIDL file: size of name is too large",
-            css::uno::Reference< css::uno::XInterface >());
-    }
-    rtl::OUString name;
-    if (!rtl_convertStringToUString(
-            &name.pData, static_cast< char const * >(address) + offset + 4, len,
-            RTL_TEXTENCODING_ASCII_US,
-            (RTL_TEXTTOUNICODE_FLAGS_UNDEFINED_ERROR
-             | RTL_TEXTTOUNICODE_FLAGS_MBUNDEFINED_ERROR
-             | RTL_TEXTTOUNICODE_FLAGS_INVALID_ERROR)))
-    {
-        throw css::uno::DeploymentException(
-            "broken UNOIDL file: name is not ASCII",
-            css::uno::Reference< css::uno::XInterface >());
-    }
-    return name;
-}
-
-MappedFile::~MappedFile() {
-    oslFileError e = osl_unmapMappedFile(handle, address, size);
-    SAL_WARN_IF(e != osl_File_E_None, "cppuhelper", "cannot unmap: " << +e);
-    e = osl_closeFile(handle);
-    SAL_WARN_IF(e != osl_File_E_None, "cppuhelper", "cannot close: " << +e);
-}
-
-sal_uInt8 MappedFile::get8(sal_uInt32 offset) const {
-    assert(size >= 8);
-    assert(offset <= size - 1);
-    return static_cast< char const * >(address)[offset];
-}
-
-sal_uInt16 MappedFile::get16(sal_uInt32 offset) const {
-    assert(size >= 8);
-    assert(offset <= size - 2);
-    return reinterpret_cast< Memory16 const * >(
-        static_cast< char const * >(address) + offset)->getUnsigned16();
-}
-
-sal_uInt32 MappedFile::get32(sal_uInt32 offset) const {
-    assert(size >= 8);
-    assert(offset <= size - 4);
-    return reinterpret_cast< Memory32 const * >(
-        static_cast< char const * >(address) + offset)->getUnsigned32();
-}
-
-sal_uInt64 MappedFile::get64(sal_uInt32 offset) const {
-    assert(size >= 8);
-    assert(offset <= size - 8);
-    return reinterpret_cast< Memory64 const * >(
-        static_cast< char const * >(address) + offset)->getUnsigned64();
-}
-
-float MappedFile::getIso60599Binary32(sal_uInt32 offset) const {
-    assert(size >= 8);
-    assert(offset <= size - 4);
-    return reinterpret_cast< Memory32 const * >(
-        static_cast< char const * >(address) + offset)->getIso60599Binary32();
-}
-
-double MappedFile::getIso60599Binary64(sal_uInt32 offset) const {
-    assert(size >= 8);
-    assert(offset <= size - 8);
-    return reinterpret_cast< Memory64 const * >(
-        static_cast< char const * >(address) + offset)->getIso60599Binary64();
-}
-
-// sizeof (MapEntry) == 8
-struct MapEntry {
-    Memory32 name;
-    Memory32 data;
-};
-
-namespace {
-
-enum Compare { COMPARE_LESS, COMPARE_GREATER, COMPARE_EQUAL };
-
-Compare compare(
-    rtl::Reference< MappedFile > const & file, rtl::OUString const & name,
-    sal_Int32 nameOffset, sal_Int32 nameLength, MapEntry const * entry)
-{
-    assert(file.is());
-    assert(entry != 0);
-    sal_uInt32 off = entry->name.getUnsigned32();
-    if (off > file->size - 1) { // at least a trailing NUL
-        throw css::uno::DeploymentException(
-            "broken UNOIDL file: string offset too large",
-            css::uno::Reference< css::uno::XInterface >());
-    }
-    assert(nameLength >= 0);
-    sal_uInt64 min = std::min(
-        static_cast< sal_uInt64 >(nameLength), file->size - off);
-    for (sal_uInt64 i = 0; i != min; ++i) {
-        sal_Unicode c1 = name[nameOffset + i];
-        sal_Unicode c2 = static_cast< unsigned char const * >(file->address)[
-            off + i];
-        if (c1 < c2) {
-            return COMPARE_LESS;
-        } else if (c1 > c2 || c2 == 0) {
-            // ...the "|| c2 == 0" is for the odd case where name erroneously
-            // contains NUL characters
-            return COMPARE_GREATER;
-        }
-    }
-    if (static_cast< sal_uInt64 >(nameLength) == min) {
-        if (file->size - off == min) {
-            throw css::uno::DeploymentException(
-                "broken UNOIDL file: string misses trailing NUL",
-                css::uno::Reference< css::uno::XInterface >());
-        }
-        return
-            static_cast< unsigned char const * >(file->address)[off + min] == 0
-            ? COMPARE_EQUAL : COMPARE_LESS;
-    } else {
-        return COMPARE_GREATER;
-    }
-}
-
-sal_uInt32 findInMap(
-    rtl::Reference< MappedFile > const & file, MapEntry const * mapBegin,
-    sal_uInt32 mapSize, rtl::OUString const & name, sal_Int32 nameOffset,
-    sal_Int32 nameLength)
-{
-    if (mapSize == 0) {
-        return 0;
-    }
-    sal_uInt32 n = mapSize / 2;
-    MapEntry const * p = mapBegin + n;
-    switch (compare(file, name, nameOffset, nameLength, p)) {
-    case COMPARE_LESS:
-        return findInMap(file, mapBegin, n, name, nameOffset, nameLength);
-    case COMPARE_GREATER:
-        return findInMap(
-            file, p + 1, mapSize - n - 1, name, nameOffset, nameLength);
-    default: // COMPARE_EQUAL
-        break;
-    }
-    sal_uInt32 off = mapBegin[n].data.getUnsigned32();
-    if (off == 0) {
-        throw css::uno::DeploymentException(
-            "broken UNOIDL file: map entry data offset is null",
-            css::uno::Reference< css::uno::XInterface >());
-    }
-    return off;
-}
-
-css::uno::Any readConstant(
-    rtl::Reference< MappedFile > const & file, sal_uInt32 offset)
-{
-    assert(file.is());
-    int v = file->read8(offset);
-    int type = v & 0x7F;
-    bool deprecated = (v & 0x80) != 0; (void)deprecated;//TODO
-    switch (type) {
-    case 0: // BOOLEAN
-        v = file->read8(offset + 1);
-        switch (v) {
-        case 0:
-            return css::uno::makeAny(false);
-        case 1:
-            return css::uno::makeAny(true);
-        default:
-            throw css::uno::DeploymentException(
-                ("broken UNOIDL file: bad boolean constant value "
-                 + rtl::OUString::number(v)),
-                css::uno::Reference< css::uno::XInterface >());
-        }
-        break;
-    case 1: // BYTE
-        return css::uno::makeAny< sal_Int8 >(file->read8(offset + 1));
-            //TODO: implementation-defined behavior of conversion from sal_uInt8
-            // to sal_Int8 relies on two's complement representation
-    case 2: // SHORT
-        return css::uno::makeAny< sal_Int16 >(file->read16(offset + 1));
-            //TODO: implementation-defined behavior of conversion from
-            // sal_uInt16 to sal_Int16 relies on two's complement representation
-    case 3: // UNSIGNED SHORT
-        return css::uno::makeAny(file->read16(offset + 1));
-    case 4: // LONG
-        return css::uno::makeAny< sal_Int32 >(file->read32(offset + 1));
-            //TODO: implementation-defined behavior of conversion from
-            // sal_uInt32 to sal_Int32 relies on two's complement representation
-    case 5: // UNSIGNED LONG
-        return css::uno::makeAny(file->read32(offset + 1));
-    case 6: // HYPER
-        return css::uno::makeAny< sal_Int64 >(file->read64(offset + 1));
-            //TODO: implementation-defined behavior of conversion from
-            // sal_uInt64 to sal_Int64 relies on two's complement representation
-    case 7: // UNSIGNED HYPER
-        return css::uno::makeAny(file->read64(offset + 1));
-    case 8: // FLOAT
-        return css::uno::makeAny(file->readIso60599Binary32(offset + 1));
-    case 9: // DOUBLE
-        return css::uno::makeAny(file->readIso60599Binary64(offset + 1));
-    default:
-        throw css::uno::DeploymentException(
-            ("broken UNOIDL file: bad constant type byte "
-             + rtl::OUString::number(v)),
-            css::uno::Reference< css::uno::XInterface >());
-    }
-}
-
-rtl::Reference< unoidl::Entity > readEntity(
-    rtl::Reference< MappedFile > const & file, sal_uInt32 offset);
-
-class UnoidlCursor: public unoidl::MapCursor {
-public:
-    UnoidlCursor(
-        rtl::Reference< MappedFile > file, MapEntry const * mapBegin,
-        sal_uInt32 mapSize):
-        file_(file), mapIndex_(mapBegin), mapEnd_(mapBegin + mapSize)
-    {}
-
-private:
-    virtual ~UnoidlCursor() throw () {}
-
-    virtual rtl::Reference< unoidl::Entity > getNext(rtl::OUString * name);
-
-    rtl::Reference< MappedFile > file_;
-    MapEntry const * mapIndex_;
-    MapEntry const * mapEnd_;
-};
-
-rtl::Reference< unoidl::Entity > UnoidlCursor::getNext(rtl::OUString * name) {
-    assert(name != 0);
-    rtl::Reference< unoidl::Entity > ent;
-    if (mapIndex_ != mapEnd_) {
-        *name = file_->readNameNul(mapIndex_->name.getUnsigned32());
-        ent = readEntity(file_, mapIndex_->data.getUnsigned32());
-        ++mapIndex_;
-    }
-    return ent;
-}
-
-class UnoidlModuleEntity: public unoidl::ModuleEntity {
-public:
-    UnoidlModuleEntity(
-        rtl::Reference< MappedFile > const & file, sal_uInt32 mapOffset,
-        sal_uInt32 mapSize):
-        file_(file),
-        mapBegin_(
-            reinterpret_cast< MapEntry const * >(
-                static_cast< char const * >(file_->address) + mapOffset)),
-        mapSize_(mapSize)
-    { assert(file.is()); }
-
-private:
-    virtual ~UnoidlModuleEntity() throw () {}
-
-    virtual std::vector< rtl::OUString > getMemberNames() const;
-
-    virtual rtl::Reference< unoidl::MapCursor > createCursor() const
-    { return new UnoidlCursor(file_, mapBegin_, mapSize_); }
-
-    rtl::Reference< MappedFile > file_;
-    MapEntry const * mapBegin_;
-    sal_uInt32 mapSize_;
-};
-
-std::vector< rtl::OUString > UnoidlModuleEntity::getMemberNames() const {
-    std::vector< rtl::OUString > names;
-    for (sal_uInt32 i = 0; i != mapSize_; ++i) {
-        names.push_back(file_->readNameNul(mapBegin_[i].name.getUnsigned32()));
-    }
-    return names;
-}
-
-rtl::Reference< unoidl::Entity > readEntity(
-    rtl::Reference< MappedFile > const & file, sal_uInt32 offset)
-{
-    assert(file.is());
-    int v = file->read8(offset);
-    int type = v & 0x3F;
-    bool published = (v & 0x80) != 0;
-    bool deprecated = (v & 0x40) != 0; (void)deprecated;//TODO
-    bool flag = (v & 0x20) != 0;
-    switch (type) {
-    case 0: // module
-        {
-            if (v != 0) {
-                throw css::uno::DeploymentException(
-                    ("broken UNOIDL file: bad module type byte "
-                     + rtl::OUString::number(v)),
-                    css::uno::Reference< css::uno::XInterface >());
-            }
-            sal_uInt32 n = file->read32(offset + 1);
-            if (n > SAL_MAX_INT32) {
-                throw css::uno::DeploymentException(
-                    "broken UNOIDL file: too many items in module",
-                    css::uno::Reference< css::uno::XInterface >());
-            }
-            if (offset + 5 + 8 * n > file->size) { //TODO: overflow
-                throw css::uno::DeploymentException(
-                    "broken UNOIDL file: module map offset + size too large",
-                    css::uno::Reference< css::uno::XInterface >());
-            }
-            return new UnoidlModuleEntity(file, offset + 5, n);
-        }
-    case 1: // enum type
-        {
-            sal_uInt32 n = file->read32(offset + 1);
-            if (n > SAL_MAX_INT32) {
-                throw css::uno::DeploymentException(
-                    "broken UNOIDL file: too many members of enum type",
-                    css::uno::Reference< css::uno::XInterface >());
-            }
-            offset += 5;
-            std::vector< unoidl::EnumTypeEntity::Member > mems;
-            for (sal_uInt32 i = 0; i != n; ++i) {
-                rtl::OUString memName(file->readNameLen(offset, &offset));
-                sal_Int32 memValue = static_cast< sal_Int32 >(
-                    file->read32(offset));
-                    //TODO: implementation-defined behavior of conversion from
-                    // sal_uInt32 to sal_Int32 relies on two's complement
-                    // representation
-                offset += 4;
-                mems.push_back(
-                    unoidl::EnumTypeEntity::Member(memName, memValue));
-            }
-            return new unoidl::EnumTypeEntity(published, mems);
-        }
-    case 2: // plain struct type without base
-    case 2 | 0x20: // plain struct type with base
-        {
-            ++offset;
-            rtl::OUString base;
-            if (flag) {
-                base = file->readNameLen(offset, &offset);
-                if (base.isEmpty()) {
-                    throw css::uno::DeploymentException(
-                        ("broken UNOIDL file: empty base type name of plain"
-                         " struct type"),
-                        css::uno::Reference< css::uno::XInterface >());
-                }
-            }
-            sal_uInt32 n = file->read32(offset);
-            if (n > SAL_MAX_INT32) {
-                throw css::uno::DeploymentException(
-                    ("broken UNOIDL file: too many direct members of plain"
-                     " struct type"),
-                    css::uno::Reference< css::uno::XInterface >());
-            }
-            offset += 4;
-            std::vector< unoidl::PlainStructTypeEntity::Member > mems;
-            for (sal_uInt32 i = 0; i != n; ++i) {
-                rtl::OUString memName(file->readNameLen(offset, &offset));
-                rtl::OUString memType(file->readNameLen(offset, &offset));
-                mems.push_back(
-                    unoidl::PlainStructTypeEntity::Member(memName, memType));
-            }
-            return new unoidl::PlainStructTypeEntity(published, base, mems);
-        }
-    case 3: // polymorphic struct type template
-        {
-            sal_uInt32 n = file->read32(offset + 1);
-            if (n > SAL_MAX_INT32) {
-                throw css::uno::DeploymentException(
-                    ("broken UNOIDL file: too many type parameters of"
-                     " polymorphic struct type template"),
-                    css::uno::Reference< css::uno::XInterface >());
-            }
-            offset += 5;
-            std::vector< rtl::OUString > params;
-            for (sal_uInt32 i = 0; i != n; ++i) {
-                params.push_back(file->readNameLen(offset, &offset));
-            }
-            n = file->read32(offset);
-            if (n > SAL_MAX_INT32) {
-                throw css::uno::DeploymentException(
-                    ("broken UNOIDL file: too many members of polymorphic"
-                     " struct type template"),
-                    css::uno::Reference< css::uno::XInterface >());
-            }
-            offset += 4;
-            std::vector< unoidl::PolymorphicStructTypeTemplateEntity::Member >
-                mems;
-            for (sal_uInt32 i = 0; i != n; ++i) {
-                v = file->read8(offset);
-                ++offset;
-                rtl::OUString memName(file->readNameLen(offset, &offset));
-                rtl::OUString memType(file->readNameLen(offset, &offset));
-                if (v > 1) {
-                    throw css::uno::DeploymentException(
-                        ("broken UNOIDL file: bad flags "
-                         + rtl::OUString::number(v) + " for member " + memName
-                         + " of polymorphic struct type template"),
-                        css::uno::Reference< css::uno::XInterface >());
-                }
-                mems.push_back(
-                    unoidl::PolymorphicStructTypeTemplateEntity::Member(
-                        memName, memType, v == 1));
-            }
-            return new unoidl::PolymorphicStructTypeTemplateEntity(
-                published, params, mems);
-        }
-    case 4: // exception type without base
-    case 4 | 0x20: // exception type with base
-        {
-            ++offset;
-            rtl::OUString base;
-            if (flag) {
-                base = file->readNameLen(offset, &offset);
-                if (base.isEmpty()) {
-                    throw css::uno::DeploymentException(
-                        ("broken UNOIDL file: empty base type name of"
-                         " exception type"),
-                        css::uno::Reference< css::uno::XInterface >());
-                }
-            }
-            sal_uInt32 n = file->read32(offset);
-            if (n > SAL_MAX_INT32) {
-                throw css::uno::DeploymentException(
-                    ("broken UNOIDL file: too many direct members of"
-                     " exception type"),
-                    css::uno::Reference< css::uno::XInterface >());
-            }
-            offset += 4;
-            std::vector< unoidl::ExceptionTypeEntity::Member > mems;
-            for (sal_uInt32 i = 0; i != n; ++i) {
-                rtl::OUString memName(file->readNameLen(offset, &offset));
-                rtl::OUString memType(file->readNameLen(offset, &offset));
-                mems.push_back(
-                    unoidl::ExceptionTypeEntity::Member(memName, memType));
-            }
-            return new unoidl::ExceptionTypeEntity(published, base, mems);
-        }
-    case 5: // interface type
-        {
-            sal_uInt32 n = file->read32(offset + 1);
-            if (n > SAL_MAX_INT32) {
-                throw css::uno::DeploymentException(
-                    ("broken UNOIDL file: too many direct mandatory bases of"
-                     " interface type"),
-                    css::uno::Reference< css::uno::XInterface >());
-            }
-            offset += 5;
-            std::vector< rtl::OUString > mandBases;
-            for (sal_uInt32 i = 0; i != n; ++i) {
-                mandBases.push_back(file->readNameLen(offset, &offset));
-            }
-            n = file->read32(offset);
-            if (n > SAL_MAX_INT32) {
-                throw css::uno::DeploymentException(
-                    ("broken UNOIDL file: too many direct optional bases of"
-                     " interface type"),
-                    css::uno::Reference< css::uno::XInterface >());
-            }
-            offset += 4;
-            std::vector< rtl::OUString > optBases;
-            for (sal_uInt32 i = 0; i != n; ++i) {
-                optBases.push_back(file->readNameLen(offset, &offset));
-            }
-            sal_uInt32 nAttrs = file->read32(offset);
-            if (nAttrs > SAL_MAX_INT32) {
-                throw css::uno::DeploymentException(
-                    ("broken UNOIDL file: too many direct attributes of"
-                     " interface type"),
-                    css::uno::Reference< css::uno::XInterface >());
-            }
-            offset += 4;
-            std::vector< unoidl::InterfaceTypeEntity::Attribute > attrs;
-            for (sal_uInt32 i = 0; i != nAttrs; ++i) {
-                v = file->read8(offset);
-                ++offset;
-                rtl::OUString attrName(file->readNameLen(offset, &offset));
-                rtl::OUString attrType(file->readNameLen(offset, &offset));
-                if (v > 0x03) {
-                    throw css::uno::DeploymentException(
-                        ("broken UNOIDL file: bad flags for direct attribute "
-                         + attrName + " of interface type"),
-                        css::uno::Reference< css::uno::XInterface >());
-                }
-                std::vector< rtl::OUString > getExcs;
-                sal_uInt32 m = file->read32(offset);
-                if (m > SAL_MAX_INT32) {
-                    throw css::uno::DeploymentException(
-                        ("broken UNOIDL file: too many getter exceptions for"
-                         " direct attribute " + attrName
-                         + " of interface type"),
-                        css::uno::Reference< css::uno::XInterface >());
-                }
-                offset += 4;
-                for (sal_uInt32 j = 0; j != m; ++j) {
-                    getExcs.push_back(file->readNameLen(offset, &offset));
-                }
-                std::vector< rtl::OUString > setExcs;
-                if ((v & 0x02) == 0) {
-                    m = file->read32(offset);
-                    if (m > SAL_MAX_INT32) {
-                        throw css::uno::DeploymentException(
-                            ("broken UNOIDL file: too many setter exceptions"
-                             " for direct attribute " + attrName
-                             + " of interface type"),
-                            css::uno::Reference< css::uno::XInterface >());
-                    }
-                    offset += 4;
-                    for (sal_uInt32 j = 0; j != m; ++j) {
-                        setExcs.push_back(file->readNameLen(offset, &offset));
-                    }
-                }
-                attrs.push_back(
-                    unoidl::InterfaceTypeEntity::Attribute(
-                        attrName, attrType, (v & 0x01) != 0, (v & 0x02) != 0,
-                        getExcs, setExcs));
-            }
-            sal_uInt32 nMeths = file->read32(offset);
-            if (nMeths > SAL_MAX_INT32 - nAttrs) {
-                throw css::uno::DeploymentException(
-                    ("broken UNOIDL file: too many direct attributes and"
-                     " methods of interface type"),
-                    css::uno::Reference< css::uno::XInterface >());
-            }
-            offset += 4;
-            std::vector< unoidl::InterfaceTypeEntity::Method > meths;
-            for (sal_uInt32 i = 0; i != nMeths; ++i) {
-                rtl::OUString methName(file->readNameLen(offset, &offset));
-                rtl::OUString methType(file->readNameLen(offset, &offset));
-                sal_uInt32 m = file->read32(offset);
-                if (m > SAL_MAX_INT32) {
-                    throw css::uno::DeploymentException(
-                        ("broken UNOIDL file: too many parameters for method "
-                         + methName + " of interface type"),
-                        css::uno::Reference< css::uno::XInterface >());
-                }
-                offset += 4;
-                std::vector< unoidl::InterfaceTypeEntity::Method::Parameter >
-                    params;
-                for (sal_uInt32 j = 0; j != m; ++j) {
-                    v = file->read8(offset);
-                    ++offset;
-                    rtl::OUString paramName(
-                        file->readNameLen(offset, &offset));
-                    rtl::OUString paramType(
-                        file->readNameLen(offset, &offset));
-                    unoidl::InterfaceTypeEntity::Method::Parameter::Direction
-                        dir;
-                    switch (v) {
-                    case 0:
-                        dir = unoidl::InterfaceTypeEntity::Method::Parameter::
-                            DIRECTION_IN;
-                        break;
-                    case 1:
-                        dir = unoidl::InterfaceTypeEntity::Method::Parameter::
-                            DIRECTION_OUT;
-                        break;
-                    case 2:
-                        dir = unoidl::InterfaceTypeEntity::Method::Parameter::
-                            DIRECTION_IN_OUT;
-                        break;
-                    default:
-                        throw css::uno::DeploymentException(
-                            ("broken UNOIDL file: bad direction "
-                             + rtl::OUString::number(v) + " of parameter "
-                             + paramName + " for method " + methName
-                             + " of interface type"),
-                            css::uno::Reference< css::uno::XInterface >());
-                    }
-                    params.push_back(
-                        unoidl::InterfaceTypeEntity::Method::Parameter(
-                            paramName, paramType, dir));
-                }
-                std::vector< rtl::OUString > excs;
-                m = file->read32(offset);
-                if (m > SAL_MAX_INT32) {
-                    throw css::uno::DeploymentException(
-                        ("broken UNOIDL file: too many exceptions for method "
-                         + methName + " of interface type"),
-                        css::uno::Reference< css::uno::XInterface >());
-                }
-                offset += 4;
-                for (sal_uInt32 j = 0; j != m; ++j) {
-                    excs.push_back(file->readNameLen(offset, &offset));
-                }
-                meths.push_back(
-                    unoidl::InterfaceTypeEntity::Method(
-                        methName, methType, params, excs));
-            }
-            return new unoidl::InterfaceTypeEntity(
-                published, mandBases, optBases, attrs, meths);
-        }
-    case 6: // typedef
-        return new unoidl::TypedefEntity(
-            published, file->readNameLen(offset + 1));
-    case 7: // constant group
-        {
-            sal_uInt32 n = file->read32(offset + 1);
-            if (n > SAL_MAX_INT32) {
-                throw css::uno::DeploymentException(
-                    "broken UNOIDL file: too many constants in constant group",
-                    css::uno::Reference< css::uno::XInterface >());
-            }
-            if (offset + 5 + 8 * n > file->size) { //TODO: overflow
-                throw css::uno::DeploymentException(
-                    ("broken UNOIDL file: constant group map offset + size too"
-                     " large"),
-                    css::uno::Reference< css::uno::XInterface >());
-            }
-            MapEntry const * p = reinterpret_cast< MapEntry const * >(
-                static_cast< char const * >(file->address) + offset + 5);
-            std::vector< unoidl::ConstantGroupEntity::Member > mems;
-            for (sal_uInt32 i = 0; i != n; ++i) {
-                mems.push_back(
-                    unoidl::ConstantGroupEntity::Member(
-                        file->readNameNul(p[i].name.getUnsigned32()),
-                        readConstant(file, p[i].data.getUnsigned32())));
-            }
-            return new unoidl::ConstantGroupEntity(published, mems);
-        }
-    case 8: // single-interface--based service without default constructor
-    case 8 | 0x20: // single-interface--based service with default constructor
-        {
-            rtl::OUString base(file->readNameLen(offset + 1, &offset));
-            std::vector<
-                unoidl::SingleInterfaceBasedServiceEntity::Constructor >
-                ctors;
-            if (flag) {
-                ctors.push_back(
-                    unoidl::SingleInterfaceBasedServiceEntity::Constructor());
-            } else {
-                sal_uInt32 n = file->read32(offset);
-                if (n > SAL_MAX_INT32) {
-                    throw css::uno::DeploymentException(
-                        ("broken UNOIDL file: too many constructors of"
-                         " single-interface--based service"),
-                        css::uno::Reference< css::uno::XInterface >());
-                }
-                offset += 4;
-                for (sal_uInt32 i = 0; i != n; ++i) {
-                    rtl::OUString ctorName(file->readNameLen(offset, &offset));
-                    sal_uInt32 m = file->read32(offset);
-                    if (m > SAL_MAX_INT32) {
-                        throw css::uno::DeploymentException(
-                            ("broken UNOIDL file: too many parameters for"
-                             " constructor " + ctorName
-                             + " of single-interface--based service"),
-                            css::uno::Reference< css::uno::XInterface >());
-                    }
-                    offset += 4;
-                    std::vector<
-                        unoidl::SingleInterfaceBasedServiceEntity::Constructor::
-                        Parameter > params;
-                    for (sal_uInt32 j = 0; j != m; ++j) {
-                        v = file->read8(offset);
-                        ++offset;
-                        rtl::OUString paramName(
-                            file->readNameLen(offset, &offset));
-                        rtl::OUString paramType(
-                            file->readNameLen(offset, &offset));
-                        bool rest;
-                        switch (v) {
-                        case 0:
-                            rest = false;
-                            break;
-                        case 0x04:
-                            rest = true;
-                            break;
-                        default:
-                            throw css::uno::DeploymentException(
-                                ("broken UNOIDL file: bad mode "
-                                 + rtl::OUString::number(v) + " of parameter "
-                                 + paramName + " for constructor " + ctorName
-                                 + " of single-interface--based service"),
-                                css::uno::Reference< css::uno::XInterface >());
-                        }
-                        params.push_back(
-                            unoidl::SingleInterfaceBasedServiceEntity::
-                            Constructor::Parameter(
-                                paramName, paramType, rest));
-                    }
-                    std::vector< rtl::OUString > excs;
-                    m = file->read32(offset);
-                    if (m > SAL_MAX_INT32) {
-                        throw css::uno::DeploymentException(
-                            ("broken UNOIDL file: too many exceptions for"
-                             " constructor " + ctorName
-                             + " of single-interface--based service"),
-                            css::uno::Reference< css::uno::XInterface >());
-                    }
-                    offset += 4;
-                    for (sal_uInt32 j = 0; j != m; ++j) {
-                        excs.push_back(file->readNameLen(offset, &offset));
-                    }
-                    ctors.push_back(
-                        unoidl::SingleInterfaceBasedServiceEntity::Constructor(
-                            ctorName, params, excs));
-                }
-            }
-            return new unoidl::SingleInterfaceBasedServiceEntity(
-                published, base, ctors);
-        }
-    case 9: // accumulation-based service
-        {
-            sal_uInt32 n = file->read32(offset + 1);
-            if (n > SAL_MAX_INT32) {
-                throw css::uno::DeploymentException(
-                    ("broken UNOIDL file: too many direct mandatory service"
-                     " bases of accumulation-based service"),
-                    css::uno::Reference< css::uno::XInterface >());
-            }
-            offset += 5;
-            std::vector< rtl::OUString > mandServs;
-            for (sal_uInt32 i = 0; i != n; ++i) {
-                mandServs.push_back(file->readNameLen(offset, &offset));
-            }
-            n = file->read32(offset);
-            if (n > SAL_MAX_INT32) {
-                throw css::uno::DeploymentException(
-                    ("broken UNOIDL file: too many direct optional service"
-                     " bases of accumulation-based servcie"),
-                    css::uno::Reference< css::uno::XInterface >());
-            }
-            offset += 4;
-            std::vector< rtl::OUString > optServs;
-            for (sal_uInt32 i = 0; i != n; ++i) {
-                optServs.push_back(file->readNameLen(offset, &offset));
-            }
-            n = file->read32(offset);
-            if (n > SAL_MAX_INT32) {
-                throw css::uno::DeploymentException(
-                    ("broken UNOIDL file: too many direct mandatory interface"
-                     " bases of accumulation-based servcie"),
-                    css::uno::Reference< css::uno::XInterface >());
-            }
-            offset += 4;
-            std::vector< rtl::OUString > mandIfcs;
-            for (sal_uInt32 i = 0; i != n; ++i) {
-                mandIfcs.push_back(file->readNameLen(offset, &offset));
-            }
-            n = file->read32(offset);
-            if (n > SAL_MAX_INT32) {
-                throw css::uno::DeploymentException(
-                    ("broken UNOIDL file: too many direct optional interface"
-                     " bases of accumulation-based servcie"),
-                    css::uno::Reference< css::uno::XInterface >());
-            }
-            offset += 4;
-            std::vector< rtl::OUString > optIfcs;
-            for (sal_uInt32 i = 0; i != n; ++i) {
-                optIfcs.push_back(file->readNameLen(offset, &offset));
-            }
-            n = file->read32(offset);
-            if (n > SAL_MAX_INT32) {
-                throw css::uno::DeploymentException(
-                    ("broken UNOIDL file: too many direct properties of"
-                     " accumulation-based servcie"),
-                    css::uno::Reference< css::uno::XInterface >());
-            }
-            offset += 4;
-            std::vector< unoidl::AccumulationBasedServiceEntity::Property >
-                props;
-            for (sal_uInt32 i = 0; i != n; ++i) {
-                sal_uInt16 attrs = file->read16(offset);
-                offset += 2;
-                rtl::OUString propName(file->readNameLen(offset, &offset));
-                rtl::OUString propType(file->readNameLen(offset, &offset));
-                if (attrs > 0x01FF) { // see css.beans.PropertyAttribute
-                    throw css::uno::DeploymentException(
-                        ("broken UNOIDL file: bad mode "
-                         + rtl::OUString::number(v) + " of property " + propName
-                         + " for accumulation-based servcie"),
-                        css::uno::Reference< css::uno::XInterface >());
-                }
-                props.push_back(
-                    unoidl::AccumulationBasedServiceEntity::Property(
-                        propName, propType,
-                        static_cast<
-                            unoidl::AccumulationBasedServiceEntity::Property::
-                            Attributes >(
-                                attrs)));
-            }
-            return new unoidl::AccumulationBasedServiceEntity(
-                published, mandServs, optServs, mandIfcs, optIfcs, props);
-        }
-    case 10: // interface-based singleton
-        return new unoidl::InterfaceBasedSingletonEntity(
-            published, file->readNameLen(offset + 1));
-    case 11: // service-based singleton
-        return new unoidl::ServiceBasedSingletonEntity(
-            published, file->readNameLen(offset + 1));
-    default:
-        throw css::uno::DeploymentException(
-            "broken UNOIDL file: bad type byte " + rtl::OUString::number(v),
-            css::uno::Reference< css::uno::XInterface >());
-    }
-}
-
-}
-
-UnoidlProvider::UnoidlProvider(rtl::OUString const & uri):
-    file_(new MappedFile(uri))
-{
-    if (file_->size < 8 || std::memcmp(file_->address, "UNOIDL\0\xFF", 8) != 0)
-    {
-        throw css::registry::InvalidRegistryException(
-            uri, css::uno::Reference< css::uno::XInterface >());
-    }
-    sal_uInt32 off = file_->read32(8);
-    mapSize_ = file_->read32(12);
-    if (off + 8 * mapSize_ > file_->size) { //TODO: overflow
-        throw css::uno::DeploymentException(
-            "broken UNOIDL file: root map offset + size too large",
-            css::uno::Reference< css::uno::XInterface >());
-    }
-    mapBegin_ = reinterpret_cast< MapEntry const * >(
-        static_cast< char const * >(file_->address) + off);
-}
-
-rtl::Reference< unoidl::MapCursor > UnoidlProvider::createRootCursor() const {
-    return new UnoidlCursor(file_, mapBegin_, mapSize_);
-}
-
-sal_uInt32 UnoidlProvider::find(rtl::OUString const & name, bool * constant)
-    const
-{
-    MapEntry const * mapBegin = mapBegin_;
-    sal_uInt32 mapSize = mapSize_;
-    bool cgroup = false;
-    for (sal_Int32 i = 0;;) {
-        sal_Int32 j = name.indexOf('.', i);
-        if (j == -1) {
-            j = name.getLength();
-        }
-        sal_Int32 off = findInMap(file_, mapBegin, mapSize, name, i, j - i);
-        if (off == 0) {
-            return 0;
-        }
-        if (j == name.getLength()) {
-            if (constant != 0) {
-                *constant = cgroup;
-            }
-            return off;
-        }
-        if (cgroup) {
-            return 0;
-                //TODO: throw an exception instead here, where the segments of a
-                // constant's name are a prefix of the requested name's
-                // segments?
-        }
-        int v = file_->read8(off);
-        if (v != 0) { // module
-            if ((v & 0x3F) == 7) { // constant group
-                cgroup = true;
-            } else {
-                return 0;
-                    //TODO: throw an exception instead here, where the segments
-                    // of a non-module, non-constant-group entity's name are a
-                    // prefix of the requested name's segments?
-            }
-        }
-        mapSize = file_->read32(off + 1);
-        if (8 * mapSize > file_->size - off - 5) { //TODO: overflow
-            throw css::uno::DeploymentException(
-                "broken UNOIDL file: map offset + size too large",
-                css::uno::Reference< css::uno::XInterface >());
-        }
-        mapBegin = reinterpret_cast< MapEntry const * >(
-            static_cast< char const * >(file_->address) + off + 5);
-        i = j + 1;
-    }
-}
-
-rtl::Reference< unoidl::Entity > UnoidlProvider::getEntity(sal_uInt32 offset)
-    const
-{
-    return readEntity(file_, offset);
-}
-
-css::uno::Any UnoidlProvider::getConstant(sal_uInt32 offset) const {
-    return readConstant(file_, offset);
-}
-
-UnoidlProvider::~UnoidlProvider() throw () {}
-
-}
-
-/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/cppuhelper/source/unoidlprovider.hxx b/cppuhelper/source/unoidlprovider.hxx
deleted file mode 100644
index 45089b9d688b..000000000000
--- a/cppuhelper/source/unoidlprovider.hxx
+++ /dev/null
@@ -1,54 +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_UNOIDLPROVIDER_HXX
-#define INCLUDED_CPPUHELPER_SOURCE_UNOIDLPROVIDER_HXX
-
-#include "sal/config.h"
-
-#include "cppuhelper/unoidl.hxx"
-#include "rtl/ref.hxx"
-#include "sal/types.h"
-
-namespace com { namespace sun { namespace star { namespace uno {
-    class Any;
-} } } }
-namespace cppu {
-    class MappedFile;
-    struct MapEntry;
-}
-namespace rtl { class OUString; }
-
-namespace cppu {
-
-class UnoidlProvider: public unoidl::Provider {
-public:
-    explicit UnoidlProvider(rtl::OUString const & uri);
-
-    virtual rtl::Reference< unoidl::MapCursor > createRootCursor() const;
-
-    sal_uInt32 find(rtl::OUString const & name, bool * constant = 0) const;
-
-    rtl::Reference< unoidl::Entity > getEntity(sal_uInt32 offset) const;
-
-    css::uno::Any getConstant(sal_uInt32 offset) const;
-
-private:
-    virtual ~UnoidlProvider() throw ();
-
-    rtl::Reference< MappedFile > file_;
-    MapEntry const * mapBegin_;
-    sal_uInt32 mapSize_;
-};
-
-}
-
-#endif
-
-/* vim:set shiftwidth=4 softtabstop=4 expandtab: */