WIP: Experimental new binary type.rdb format

Make uno-skeletonmaker work on top of unoidl/ instead of registry/.

These changes have only been tested so far rather lightly.  Basic
uno-skeletonmaker still works, but more thorough testing of the various input
flags is needed.

Change-Id: Id7f3aee863a10f8c649325db2d6f34a4057f70ff

codemaker/inc/codemaker/codemaker.hxx

@@ -38,12 +38,6 @@ namespace codemaker {
 
 rtl::OString convertString(rtl::OUString const & string);
 
-codemaker::UnoType::Sort decomposeAndResolve(
-    rtl::Reference< TypeManager > const & manager, rtl::OString const & type,
-    bool resolveTypedefs, bool allowVoid, bool allowExtraEntities,
-    RTTypeClass * typeClass, rtl::OString * name, sal_Int32 * rank,
-    std::vector< rtl::OString > * arguments);
-
 }
 
 #endif // INCLUDED_CODEMAKER_CODEMAKER_HXX

codemaker/inc/codemaker/commoncpp.hxx

@@ -36,8 +36,7 @@ namespace codemaker { namespace cpp {
 rtl::OString scopedCppName(rtl::OString const & type, bool ns_alias=true);
 
 rtl::OString translateUnoToCppType(
-    codemaker::UnoType::Sort sort, RTTypeClass typeClass,
-    rtl::OString const & nucleus, bool shortname);
+    codemaker::UnoType::Sort sort, rtl::OUString const & nucleus);
 
 enum IdentifierTranslationMode {
     ITM_GLOBAL,

codemaker/source/codemaker/codemaker.cxx

@@ -62,93 +62,6 @@ rtl::OString convertString(rtl::OUString const & string) {
     return s;
 }
 
-codemaker::UnoType::Sort decomposeAndResolve(
-    rtl::Reference< TypeManager > const & manager, rtl::OString const & type,
-    bool resolveTypedefs, bool allowVoid, bool allowExtraEntities,
-    RTTypeClass * typeClass, rtl::OString * name, sal_Int32 * rank,
-    std::vector< rtl::OString > * arguments)
-{
-    OSL_ASSERT(typeClass != 0 && name != 0 && rank != 0 && arguments != 0);
-    *rank = 0;
-    for (rtl::OString t(type);;) {
-        sal_Int32 n = 0;
-        *name = codemaker::UnoType::decompose(t, &n, arguments);
-        if (n > SAL_MAX_INT32 - *rank) {
-            throw CannotDumpException("Bad type information: " + b2u(type));
-            //TODO
-        }
-        *rank += n;
-        if (n > 0) {
-            allowVoid = false;
-            allowExtraEntities = false;
-        }
-        codemaker::UnoType::Sort sort = codemaker::UnoType::getSort(*name);
-        switch (sort) {
-        case codemaker::UnoType::SORT_VOID:
-            if (!allowVoid) {
-                throw CannotDumpException("Bad type information: " + b2u(type));
-                //TODO
-            }
-        default:
-            checkNoTypeArguments(*arguments);
-            *typeClass = RT_TYPE_INVALID;
-            return sort;
-
-        case codemaker::UnoType::SORT_COMPLEX:
-            typereg::Reader reader(manager->getTypeReader(*name));
-            *typeClass = reader.getTypeClass();
-            switch (*typeClass) {
-            case RT_TYPE_ENUM:
-            case RT_TYPE_INTERFACE:
-                checkNoTypeArguments(*arguments);
-                return sort;
-
-            case RT_TYPE_STRUCT:
-                if (!(allowExtraEntities && arguments->empty())
-                    && (arguments->size() > SAL_MAX_UINT16
-                        || (static_cast< sal_uInt16 >(arguments->size())
-                            != reader.getReferenceCount())))
-                {
-                    throw CannotDumpException("Bad type information: " + b2u(type));
-                    //TODO
-                }
-                return sort;
-
-            case RT_TYPE_MODULE:
-            case RT_TYPE_EXCEPTION:
-            case RT_TYPE_SERVICE:
-            case RT_TYPE_SINGLETON:
-            case RT_TYPE_CONSTANTS:
-                if (!allowExtraEntities) {
-                    throw CannotDumpException("Bad type information: " + b2u(type));
-                    //TODO
-                }
-                checkNoTypeArguments(*arguments);
-                //TODO: check reader for consistency
-                return sort;
-
-            case RT_TYPE_TYPEDEF:
-                checkNoTypeArguments(*arguments);
-                if (reader.getSuperTypeCount() == 1
-                    && reader.getFieldCount() == 0
-                    && reader.getMethodCount() == 0
-                    && reader.getReferenceCount() == 0)
-                {
-                    if (resolveTypedefs) {
-                        t = convertString(reader.getSuperTypeName(0));
-                        continue;
-                    } else {
-                        return sort;
-                    }
-                }
-            default:
-                throw CannotDumpException("Bad type information: " + b2u(type));
-                //TODO
-            }
-        }
-    }
-}
-
 }
 
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

codemaker/source/commoncpp/commoncpp.cxx

@@ -67,36 +67,26 @@ OString scopedCppName(OString const & type, bool ns_alias)
 
 
 OString translateUnoToCppType(
-    codemaker::UnoType::Sort sort, RTTypeClass typeClass,
-    OString const & nucleus, bool shortname)
+    codemaker::UnoType::Sort sort, OUString const & nucleus)
 {
     OStringBuffer buf;
-    if (sort == codemaker::UnoType::SORT_COMPLEX) {
-        if (typeClass == RT_TYPE_INTERFACE
-            && nucleus == OString("com/sun/star/uno/XInterface"))
-        {
-            buf.append("::com::sun::star::uno::XInterface");
-        } else {
-            //TODO: check that nucleus is a valid (UTF-8) identifier
-            buf.append(nucleus);
-        }
-    } else {
+    if (sort <= codemaker::UnoType::SORT_ANY) {
         static char const * const cppTypes[codemaker::UnoType::SORT_ANY + 1] = {
             "void", "::sal_Bool", "::sal_Int8", "::sal_Int16", "::sal_uInt16",
             "::sal_Int32", "::sal_uInt32", "::sal_Int64", "::sal_uInt64",
             "float", "double", "::sal_Unicode", "rtl::OUString",
             "::com::sun::star::uno::Type", "::com::sun::star::uno::Any" };
         buf.append(cppTypes[sort]);
+    } else {
+        if (sort == codemaker::UnoType::SORT_INTERFACE_TYPE
+            && nucleus == "com.sun.star.uno.XInterface")
+        {
+            buf.append("::com::sun::star::uno::XInterface");
+        } else {
+            //TODO: check that nucleus is a valid (UTF-8) identifier
+            buf.append(u2b(nucleus));
+        }
     }
-
-    if (shortname) {
-        OString s(buf.makeStringAndClear());
-        if (s.indexOf("::com::sun::star") == 0)
-            return s.replaceAt(0, 16, "css");
-        else
-            return s;
-    }
-
     return buf.makeStringAndClear();
 }
 

unodevtools/source/skeletonmaker/skeletoncommon.hxx

@@ -23,22 +23,21 @@
 
 #include "rtl/ref.hxx"
 #include "rtl/string.hxx"
-#include "registry/reader.hxx"
 #include "codemaker/typemanager.hxx"
 #include "codemaker/unotype.hxx"
+#include "unoidl/unoidl.hxx"
 
 #include <fstream>
-#include <boost/unordered_set.hpp>
 #include <map>
+#include <set>
 
 namespace skeletonmaker {
 
 typedef ::std::map< OString, ::std::vector< OString >,
                     ::std::less< OString > > ProtocolCmdMap;
 
-typedef ::std::vector< ::std::pair< OString,
-                     ::std::pair< OString, sal_Int16 > > > AttributeInfo;
-
+typedef ::std::vector< unoidl::AccumulationBasedServiceEntity::Property >
+AttributeInfo;
 
 struct ProgramOptions {
     ProgramOptions(): java5(true), all(false), dump(false), license(false),
@@ -97,42 +96,23 @@ bool getOutputStream(ProgramOptions const & options,
                      OString & targetSourceFileName,
                      OString & tmpSourceFileName);
 
-codemaker::UnoType::Sort decomposeResolveAndCheck(
-    rtl::Reference< TypeManager > const & manager, OString const & type,
-    bool resolveTypedefs, bool allowVoid, bool allowExtraEntities,
-    RTTypeClass * typeClass, OString * name, sal_Int32 * rank,
-    std::vector< OString > * arguments);
-
 void checkType(rtl::Reference< TypeManager > const & manager,
-               OString const & type,
-               boost::unordered_set< OString, OStringHash >& interfaceTypes,
-               boost::unordered_set< OString, OStringHash >& serviceTypes,
+               OUString const & type,
+               std::set< OUString >& interfaceTypes,
+               std::set< OUString >& serviceTypes,
                AttributeInfo& properties);
 
 void checkDefaultInterfaces(
-    boost::unordered_set< OString, OStringHash >& interfaces,
-    const boost::unordered_set< OString, OStringHash >& services,
-    const OString & propertyhelper);
+    std::set< OUString >& interfaces,
+    const std::set< OUString >& services,
+    const OUString & propertyhelper);
 
-OString checkPropertyHelper(
+OUString checkPropertyHelper(
     ProgramOptions const & options, rtl::Reference< TypeManager > const & manager,
-    const boost::unordered_set< OString, OStringHash >& services,
-    const boost::unordered_set< OString, OStringHash >& interfaces,
+    const std::set< OUString >& services,
+    const std::set< OUString >& interfaces,
     AttributeInfo& attributes,
-    boost::unordered_set< OString, OStringHash >& propinterfaces);
-
-/**
-   checks whether the return and parameters types are valid and allowed
-   calc add-in type. The function throws a CannotDumpException with an
-   detailed error description which type is wrong
-
-   @param manager a type manager
-   @param reader a registry type reader of an interface defining
-                 calc add-in functions
-*/
-void checkAddInTypes(rtl::Reference< TypeManager > const & manager,
-                     typereg::Reader const & reader);
-
+    std::set< OUString >& propinterfaces);
 
 /**
    checks if XComponent have to be supported, if yes it removes it from the
@@ -145,17 +125,17 @@ void checkAddInTypes(rtl::Reference< TypeManager > const & manager,
    @return true if XComponent have to be supported
 */
 bool checkXComponentSupport(rtl::Reference< TypeManager > const & manager,
-         boost::unordered_set< OString, OStringHash >& interfaces);
-
+                            std::set< OUString >& interfaces);
 
-sal_uInt16 checkAdditionalPropertyFlags(typereg::Reader const & reader,
-                                        sal_uInt16 field, sal_uInt16 method);
 
+unoidl::AccumulationBasedServiceEntity::Property::Attributes
+checkAdditionalPropertyFlags(
+    unoidl::InterfaceTypeEntity::Attribute const & attribute);
 
 void generateFunctionParameterMap(std::ostream& o,
          ProgramOptions const & options,
          rtl::Reference< TypeManager > const & manager,
-         const boost::unordered_set< OString, OStringHash >& interfaces);
+         const std::set< OUString >& interfaces);
 
 }
 

unodevtools/source/skeletonmaker/skeletoncpp.hxx

@@ -33,84 +33,20 @@ namespace skeletonmaker { namespace cpp {
 // 4 = const reference  (includes css::uno::Reference for interfaces)
 // 8 = default construction for example for return types, means "return <type>();"
 // 16 = default member initialization in a constructor
-void printType(std::ostream & o,
-               ProgramOptions const & options, rtl::Reference< TypeManager > const & manager,
-               codemaker::UnoType::Sort sort, RTTypeClass typeClass,
-               OString const & name, sal_Int32 rank,
-               std::vector< OString > const & arguments,
-               short referenceType, bool defaultvalue=false);
-
-void printType(std::ostream & o,
-               ProgramOptions const & options, rtl::Reference< TypeManager > const & manager,
-               OString const & type, short referenceType,
-               bool defaultvalue=false);
-
-
-bool printConstructorParameters(std::ostream & o,
-                                ProgramOptions const & options,
-                                rtl::Reference< TypeManager > const & manager,
-                                typereg::Reader const & reader,
-                                typereg::Reader const & outerReader,
-                                std::vector< OString > const & arguments);
-
-
-void printConstructor(std::ostream & o,
-                      ProgramOptions const & options,
-                      rtl::Reference< TypeManager > const & manager,
-                      typereg::Reader const & reader,
-                      std::vector< OString > const & arguments);
-
-
-void printMethodParameters(std::ostream & o,
-                           ProgramOptions const & options,
-                           rtl::Reference< TypeManager > const & manager,
-                           typereg::Reader const & reader,
-                           sal_uInt16 method, bool previous,
-                           bool withtype);
-
-
-void printExceptionSpecification(std::ostream & o,
-                                 ProgramOptions const & options,
-                                 rtl::Reference< TypeManager > const & manager,
-                                 typereg::Reader const & reader,
-                                 sal_uInt16 method);
-
+void printType(
+    std::ostream & o, ProgramOptions const & options,
+    rtl::Reference< TypeManager > const & manager, OUString const & name,
+    short referenceType, bool defaultvalue = false);
 
 void printMethods(std::ostream & o,
                   ProgramOptions const & options, rtl::Reference< TypeManager > const & manager,
-                  typereg::Reader const & reader,
+                  OUString const & name,
                   codemaker::GeneratedTypeSet & generated,
                   OString const & delegate,
                   OString const & classname=OString(),
                   OString const & indentation=OString(),
                   bool defaultvalue=false,
-                  OString const & propertyhelper=OString());
-
-
-void printConstructionMethods(std::ostream & o,
-                              ProgramOptions const & options,
-                              rtl::Reference< TypeManager > const & manager,
-                              typereg::Reader const & reader);
-
-
-void printServiceMembers(std::ostream & o,
-                         ProgramOptions const & options,
-                         rtl::Reference< TypeManager > const & manager,
-                         typereg::Reader const & reader,
-                         OString const & type,
-                         OString const & delegate);
-
-
-void printMapsToCppType(std::ostream & o,
-                        ProgramOptions const & options,
-                        rtl::Reference< TypeManager > const & manager,
-                        codemaker::UnoType::Sort sort,
-                        RTTypeClass typeClass,
-                        OString const & name,
-                        sal_Int32 rank,
-                        std::vector< OString > const & arguments,
-                        const char * cppTypeSort);
-
+                  OUString const & propertyhelper=OUString());
 
 void generateDocumentation(std::ostream & o,
                            ProgramOptions const & options,

unodevtools/source/skeletonmaker/skeletonjava.hxx

@@ -26,73 +26,20 @@
 
 namespace skeletonmaker { namespace java {
 
-void printType(std::ostream & o,
-               ProgramOptions const & options, rtl::Reference< TypeManager > const & manager,
-               codemaker::UnoType::Sort sort, RTTypeClass typeClass,
-               OString const & name, sal_Int32 rank,
-               std::vector< OString > const & arguments,
-               bool referenceType, bool defaultvalue=false);
-
-void printType(std::ostream & o,
-               ProgramOptions const & options, rtl::Reference< TypeManager > const & manager,
-               OString const & type, bool referenceType,
-               bool defaultvalue=false);
-
-bool printConstructorParameters(std::ostream & o,
-                                ProgramOptions const & options,
-                                rtl::Reference< TypeManager > const & manager,
-                                typereg::Reader const & reader,
-                                typereg::Reader const & outerReader,
-                                std::vector< OString > const & arguments);
-
-void printConstructor(std::ostream & o,
-                      ProgramOptions const & options, rtl::Reference< TypeManager > const & manager,
-                      typereg::Reader const & reader,
-                      std::vector< OString > const & arguments);
-
-void printMethodParameters(std::ostream & o,
-                           ProgramOptions const & options,
-                           rtl::Reference< TypeManager > const & manager,
-                           typereg::Reader const & reader,
-                           sal_uInt16 method, bool previous,
-                           bool withtype);
-
-void printExceptionSpecification(std::ostream & o,
-                                 ProgramOptions const & options,
-                                 rtl::Reference< TypeManager > const & manager,
-                                 typereg::Reader const & reader,
-                                 sal_uInt16 method);
+void printType(
+    std::ostream & o, ProgramOptions const & options,
+    rtl::Reference< TypeManager > const & manager, OUString const & name,
+    bool referenceType, bool defaultvalue = false);
 
 void printMethods(std::ostream & o,
                   ProgramOptions const & options, rtl::Reference< TypeManager > const & manager,
-                  typereg::Reader const & reader,
+                  OUString const & name,
                   codemaker::GeneratedTypeSet & generated,
                   OString const & delegate,
                   OString const & indentation=OString(),
                   bool defaultvalue=false,
                   bool usepropertymixin=false);
 
-void printConstructionMethods(std::ostream & o,
-                              ProgramOptions const & options,
-                              rtl::Reference< TypeManager > const & manager,
-                              typereg::Reader const & reader);
-
-void printServiceMembers(std::ostream & o,
-                         ProgramOptions const & options,
-                         rtl::Reference< TypeManager > const & manager,
-                         typereg::Reader const & reader,
-                         OString const & type,
-                         OString const & delegate);
-
-void printMapsToJavaType(std::ostream & o,
-                         ProgramOptions const & options,
-                         rtl::Reference< TypeManager > const & manager,
-                         codemaker::UnoType::Sort sort,
-                         RTTypeClass typeClass,
-                         OString const & name, sal_Int32 rank,
-                         std::vector< OString > const & arguments,
-                         const char * javaTypeSort);
-
 void generateDocumentation(std::ostream & o,
                            ProgramOptions const & options,
                            rtl::Reference< TypeManager > const & manager,

unodevtools/source/skeletonmaker/skeletonmaker.cxx

@@ -22,6 +22,8 @@
 #include "sal/main.h"
 #include "rtl/process.h"
 #include "unodevtools/options.hxx"
+#include "unoidl/unoidl.hxx"
+
 #include "skeletonjava.hxx"
 #include "skeletoncpp.hxx"
 
@@ -266,11 +268,10 @@ SAL_IMPLEMENT_MAIN()
     }
 
     rtl::Reference< TypeManager > manager(new TypeManager);
-    if ( !manager->init(registries) ) {
-        std::cerr
-            << ("\nError: Using the binary type libraries failed, check the -L"
-                " options\n");
-        exit(EXIT_FAILURE);
+    for (std::vector< OString >::const_iterator i(registries.begin());
+         i != registries.end(); ++i)
+    {
+        manager->loadProvider(b2u(*i), true);
     }
 
     if ( options.dump ) {
@@ -309,9 +310,17 @@ SAL_IMPLEMENT_MAIN()
         }
     }
 
-    } catch (const CannotDumpException & e) {
-        std::cout.flush();
-        std::cerr << "\nError: " << e.getMessage() << std::endl;
+    } catch (CannotDumpException & e) {
+        std::cerr << "ERROR: " << e.getMessage() << '\n';
+        return EXIT_FAILURE;
+    } catch (unoidl::NoSuchFileException & e) {
+        std::cerr << "ERROR: No such file <" << e.getUri() << ">\n";
+        return EXIT_FAILURE;
+    } catch (unoidl::FileFormatException & e) {
+        std::cerr
+            << "ERROR: Bad format of <" << e.getUri() << ">, \""
+            << e.getDetail() << "\"\n";
+        return EXIT_FAILURE;
     }
 
     return 0;