new

1 files changed, 1915 insertions, 0 deletions

diff --git a/registry/tools/regcompare.cxx b/registry/tools/regcompare.cxx
new file mode 100644
index 000000000000..a192feb088c9
--- /dev/null
+++ b/registry/tools/regcompare.cxx
@@ -0,0 +1,1915 @@
+/*************************************************************************
+ *
+ *  $RCSfile: regcompare.cxx,v $
+ *
+ *  $Revision: 1.1 $
+ *
+ *  last change: $Author: jsc $ $Date: 2001-02-15 16:01:07 $
+ *
+ *  The Contents of this file are made available subject to the terms of
+ *  either of the following licenses
+ *
+ *         - GNU Lesser General Public License Version 2.1
+ *         - Sun Industry Standards Source License Version 1.1
+ *
+ *  Sun Microsystems Inc., October, 2000
+ *
+ *  GNU Lesser General Public License Version 2.1
+ *  =============================================
+ *  Copyright 2000 by Sun Microsystems, Inc.
+ *  901 San Antonio Road, Palo Alto, CA 94303, USA
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License version 2.1, as published by the Free Software Foundation.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public
+ *  License along with this library; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+ *  MA  02111-1307  USA
+ *
+ *
+ *  Sun Industry Standards Source License Version 1.1
+ *  =================================================
+ *  The contents of this file are subject to the Sun Industry Standards
+ *  Source License Version 1.1 (the "License"); You may not use this file
+ *  except in compliance with the License. You may obtain a copy of the
+ *  License at http://www.openoffice.org/license.html.
+ *
+ *  Software provided under this License is provided on an "AS IS" basis,
+ *  WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
+ *  WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
+ *  MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
+ *  See the License for the specific provisions governing your rights and
+ *  obligations concerning the Software.
+ *
+ *  The Initial Developer of the Original Code is: Sun Microsystems, Inc.
+ *
+ *  Copyright: 2000 by Sun Microsystems, Inc.
+ *
+ *  All Rights Reserved.
+ *
+ *  Contributor(s): _______________________________________
+ *
+ *
+ ************************************************************************/
+#include <stdio.h>
+
+#include <set>
+
+#ifndef _REGISTRY_REGISTRY_HXX_
+#include "registry/registry.hxx"
+#endif
+#ifndef _REGISTRY_REFLREAD_HXX_
+#include "registry/reflread.hxx"
+#endif
+
+#ifndef _RTL_USTRING_HXX_
+#include <rtl/ustring.hxx>
+#endif
+
+#ifndef _RTL_ALLOC_H_
+#include <rtl/alloc.h>
+#endif
+
+using namespace ::rtl;
+
+#define U2S( s ) \
+    OUStringToOString(s, RTL_TEXTENCODING_UTF8).getStr()
+#define S2U( s ) \
+    OStringToOUString(s, RTL_TEXTENCODING_UTF8)
+
+struct LessString
+{
+    sal_Bool operator()(const OUString& str1, const OUString& str2) const
+    {
+        return (str1 < str2);
+    }
+};
+
+typedef ::std::set< OUString, LessString > StringSet;
+
+class Options
+{
+public:
+    Options()
+        : m_bFullCheck(sal_False)
+        , m_bForceOutput(sal_False)
+        {}
+    ~Options()
+        {}
+
+    sal_Bool initOptions(int ac, char* av[], sal_Bool bCmdFile=sal_False);
+
+    OString prepareHelp();
+    OString prepareVersion();
+
+    const OString& getProgramName()
+        { return m_program; }
+    const OString& getRegName1()
+        { return m_regName1; }
+    const OString& getRegName2()
+        { return m_regName2; }
+    sal_Bool isStartKeyValid()
+        { return (m_startKey.getLength() > 0); };
+    const OString& getStartKey()
+        { return m_startKey; }
+    sal_Bool isExcludeKeyValid()
+        { return (m_excludeKey.getLength() > 0); };
+    const OString& getExcludeKey()
+        { return m_excludeKey; }
+    sal_Bool fullCheck()
+        { return m_bFullCheck; }
+    sal_Bool forceOutput()
+        { return m_bForceOutput; }
+protected:
+    OString     m_program;
+    OString     m_regName1;
+    OString     m_regName2;
+    OString     m_startKey;
+    OString     m_excludeKey;
+    sal_Bool    m_bFullCheck;
+    sal_Bool    m_bForceOutput;
+};
+
+sal_Bool Options::initOptions(int ac, char* av[], sal_Bool bCmdFile)
+{
+    sal_Bool bRet = sal_True;
+    sal_uInt16  i=0;
+
+    if (!bCmdFile)
+    {
+        bCmdFile = sal_True;
+
+        m_program = av[0];
+
+        if (ac < 2)
+        {
+            fprintf(stderr, "%s", prepareHelp().getStr());
+            bRet = sal_False;
+        }
+
+        i = 1;
+    } else
+    {
+        i = 0;
+    }
+
+    char    *s=NULL;
+    for (i; i < ac; i++)
+    {
+        if (av[i][0] == '-')
+        {
+            switch (av[i][1])
+            {
+                case 'r':
+                case 'R':
+                {
+                    sal_Bool bFirst = sal_True;
+                    if (av[i][2] == '2')
+                    {
+                        bFirst = sal_False;
+                    } else if (av[i][2] != '1')
+                    {
+                        fprintf(stderr, "%s: invalid option '%s'\n", m_program.getStr(), av[i]);
+                    }
+                    if (av[i][3] == '\0')
+                    {
+                        if (i < ac - 1 && av[i+1][0] != '-')
+                        {
+                            i++;
+                            s = av[i];
+                        } else
+                        {
+                            fprintf(stderr, "%s: invalid option '%s'\n", m_program.getStr(), av[i]);
+                            bRet = sal_False;
+                            break;
+                        }
+                    } else
+                    {
+                        s = av[i] + 2;
+                    }
+
+                    if ( bFirst )
+                    {
+                        m_regName1 = OString(s);
+                    } else
+                    {
+                        m_regName2 = OString(s);
+                    }
+                }
+                    break;
+                case 's':
+                case 'S':
+                    if (av[i][2] == '\0')
+                    {
+                        if (i < ac - 1 && av[i+1][0] != '-')
+                        {
+                            i++;
+                            s = av[i];
+                        } else
+                        {
+                            fprintf(stderr, "%s: invalid option '%s'\n", m_program.getStr(), av[i]);
+                            bRet = sal_False;
+                            break;
+                        }
+                    } else
+                    {
+                        s = av[i] + 2;
+                    }
+                    m_startKey = OString(s);
+                    break;
+                case 'x':
+                case 'X':
+                    if (av[i][2] == '\0')
+                    {
+                        if (i < ac - 1 && av[i+1][0] != '-')
+                        {
+                            i++;
+                            s = av[i];
+                        } else
+                        {
+                            fprintf(stderr, "%s: invalid option '%s'\n", m_program.getStr(), av[i]);
+                            bRet = sal_False;
+                            break;
+                        }
+                    } else
+                    {
+                        s = av[i] + 2;
+                    }
+                    m_excludeKey = OString(s);
+                    break;
+                case 'c':
+                case 'C':
+                    if (av[i][2] != '\0')
+                    {
+                        fprintf(stderr, "%s: invalid option '%s'\n", m_program.getStr(), av[i]);
+                    }
+                    m_bFullCheck = sal_True;
+                    break;
+                case 'f':
+                case 'F':
+                    if (av[i][2] != '\0')
+                    {
+                        fprintf(stderr, "%s: invalid option '%s'\n", m_program.getStr(), av[i]);
+                        bRet = sal_False;
+                    }
+                    m_bForceOutput = sal_True;
+                    break;
+                case 'h':
+                case '?':
+                    if (av[i][2] != '\0')
+                    {
+                        fprintf(stderr, "%s: invalid option '%s'\n", m_program.getStr(), av[i]);
+                        bRet = sal_False;
+                    } else
+                    {
+                        fprintf(stdout, "%s", prepareHelp().getStr());
+                        exit(0);
+                    }
+                    break;
+                default:
+                    fprintf(stderr, "%s: unknown option '%s'\n", m_program.getStr(), av[i]);
+                    bRet = sal_False;
+                    break;
+            }
+        } else
+        {
+            if (av[i][0] == '@')
+            {
+                FILE* cmdFile = fopen(av[i]+1, "r");
+                  if( cmdFile == NULL )
+                  {
+                    fprintf(stderr, "%s", prepareHelp().getStr());
+                    bRet = sal_False;
+                } else
+                {
+                    int rargc=0;
+                    char* rargv[512];
+                    char  buffer[512];
+
+                    while ( fscanf(cmdFile, "%s", buffer) != EOF )
+                    {
+                        rargv[rargc]= strdup(buffer);
+                        rargc++;
+                    }
+                    fclose(cmdFile);
+
+                    bRet = initOptions(rargc, rargv, bCmdFile);
+
+                    for (long i=0; i < rargc; i++)
+                    {
+                        free(rargv[i]);
+                    }
+                }
+            } else
+            {
+                fprintf(stderr, "%s: unknown option '%s'\n", m_program.getStr(), av[i]);
+                bRet = sal_False;
+            }
+        }
+    }
+
+    if ( bRet )
+    {
+        if ( m_regName1.getLength() == 0 )
+        {
+              fprintf(stderr, "%s: missing option '-r1'\n", m_program.getStr());
+            bRet = sal_False;
+        }
+        if ( m_regName2.getLength() == 0 )
+        {
+              fprintf(stderr, "%s: missing option '-r2'\n", m_program.getStr());
+            bRet = sal_False;
+        }
+    }
+
+    return bRet;
+}
+
+OString Options::prepareHelp()
+{
+    OString help("\nusing: ");
+    help += m_program + " -r1<filename> -r2<filename> [-options] | @<filename>\n";
+    help += "    -r1<filename>  = filename specifies the name of the first registry.\n";
+    help += "    -r2<filename>  = filename specifies the name of the second registry.\n";
+    help += "    @<filename>    = filename specifies a command file.\n";
+    help += "Options:\n";
+    help += "    -s<name>  = name specifies the name of a start key. If no start key\n";
+    help += "                is specified the comparison starts with the root key.n";
+    help += "    -x<name>  = name specifies the name of a key which won't be compared.\n";
+    help += "    -f        = force the detailed output of any diffenrences. Default\n";
+    help += "                is that only the the number of differences is returned.\n";
+    help += "    -c        = make a complete check, that means any differences will be\n";
+    help += "                detected. Default is only a compatibility check that means\n";
+    help += "                only UNO typelibrary entries will be checked.\n";
+    help += "    -h|-?     = print this help message and exit.\n";
+    help += prepareVersion();
+
+    return help;
+}
+
+OString Options::prepareVersion()
+{
+    OString version("\nSun Microsystems (R) ");
+    version += m_program + " Version 1.0\n\n";
+    return version;
+}
+
+static Options options;
+
+static const RegistryTypeReaderLoader & getRegistryTypeReaderLoader()
+{
+    static RegistryTypeReaderLoader aLoader;
+    return aLoader;
+}
+
+static sal_Char* getTypeClass(RTTypeClass typeClass)
+{
+    switch (typeClass)
+    {
+        case RT_TYPE_INTERFACE:
+            return "INTERFACE";
+        case RT_TYPE_MODULE:
+            return "MODULE";
+        case RT_TYPE_STRUCT:
+            return "STRUCT";
+        case RT_TYPE_ENUM:
+            return "ENUM";
+        case RT_TYPE_EXCEPTION:
+            return "EXCEPTION";
+        case RT_TYPE_TYPEDEF:
+            return "TYPEDEF";
+        case RT_TYPE_SERVICE:
+            return "SERVICE";
+        case RT_TYPE_OBJECT:
+            return "OBJECT";
+        case RT_TYPE_CONSTANTS:
+            return "CONSTANTS";
+    }
+    return "INVALID";
+}
+
+static OString getFieldAccess(RTFieldAccess fieldAccess)
+{
+    OString ret;
+    if ( (fieldAccess & RT_ACCESS_INVALID) == RT_ACCESS_INVALID )
+    {
+        ret += OString("INVALID");
+    }
+    if ( (fieldAccess & RT_ACCESS_READONLY) == RT_ACCESS_READONLY )
+    {
+        ret += OString(ret.getLength() > 0 ? ",READONLY" : "READONLY");
+    }
+    if ( (fieldAccess & RT_ACCESS_OPTIONAL) == RT_ACCESS_OPTIONAL )
+    {
+        ret += OString(ret.getLength() > 0 ? ",OPTIONAL" : "OPTIONAL");
+    }
+    if ( (fieldAccess & RT_ACCESS_MAYBEVOID) == RT_ACCESS_MAYBEVOID )
+    {
+        ret += OString(ret.getLength() > 0 ? ",MAYBEVOID" : "MAYBEVOID");
+    }
+    if ( (fieldAccess & RT_ACCESS_BOUND) == RT_ACCESS_BOUND )
+    {
+        ret += OString(ret.getLength() > 0 ? ",BOUND" : "BOUND");
+    }
+    if ( (fieldAccess & RT_ACCESS_CONSTRAINED) == RT_ACCESS_CONSTRAINED )
+    {
+        ret += OString(ret.getLength() > 0 ? ",CONSTRAINED" : "CONSTRAINED");
+    }
+    if ( (fieldAccess & RT_ACCESS_TRANSIENT) == RT_ACCESS_TRANSIENT )
+    {
+        ret += OString(ret.getLength() > 0 ? ",TRANSIENT" : "TRANSIENT");
+    }
+    if ( (fieldAccess & RT_ACCESS_MAYBEAMBIGUOUS) == RT_ACCESS_MAYBEAMBIGUOUS )
+    {
+        ret += OString(ret.getLength() > 0 ? ",MAYBEAMBIGUOUS" : "MAYBEAMBIGUOUS");
+    }
+    if ( (fieldAccess & RT_ACCESS_MAYBEDEFAULT) == RT_ACCESS_MAYBEDEFAULT )
+    {
+        ret += OString(ret.getLength() > 0 ? ",MAYBEDEFAULT" : "MAYBEDEFAULT");
+    }
+    if ( (fieldAccess & RT_ACCESS_REMOVEABLE) == RT_ACCESS_REMOVEABLE )
+    {
+        ret += OString(ret.getLength() > 0 ? ",REMOVEABLE" : "REMOVEABLE");
+    }
+    if ( (fieldAccess & RT_ACCESS_ATTRIBUTE) == RT_ACCESS_ATTRIBUTE )
+    {
+        ret += OString(ret.getLength() > 0 ? ",ATTRIBUTE" : "ATTRIBUTE");
+    }
+    if ( (fieldAccess & RT_ACCESS_PROPERTY) == RT_ACCESS_PROPERTY )
+    {
+        ret += OString(ret.getLength() > 0 ? ",PROPERTY" : "PROPERTY");
+    }
+    if ( (fieldAccess & RT_ACCESS_CONST) == RT_ACCESS_CONST )
+    {
+        ret += OString(ret.getLength() > 0 ? ",CONST" : "CONST");
+    }
+    if ( (fieldAccess & RT_ACCESS_READWRITE) == RT_ACCESS_READWRITE )
+    {
+        ret += OString(ret.getLength() > 0 ? ",READWRITE" : "READWRITE");
+    }
+    return ret;
+}
+
+static sal_Char* getConstValueType(RTConstValue& constValue)
+{
+    switch (constValue.m_type)
+    {
+        case RT_TYPE_BOOL:
+            return "sal_Bool";
+        case RT_TYPE_BYTE:
+            return "sal_uInt8";
+        case RT_TYPE_INT16:
+            return "sal_Int16";
+        case RT_TYPE_UINT16:
+            return "sal_uInt16";
+        case RT_TYPE_INT32:
+            return "sal_Int32";
+        case RT_TYPE_UINT32:
+            return "sal_uInt32";
+//      case RT_TYPE_INT64:
+//          return "sal_Int64";
+//      case RT_TYPE_UINT64:
+//          return "sal_uInt64";
+        case RT_TYPE_FLOAT:
+            return "float";
+        case RT_TYPE_DOUBLE:
+            return "double";
+        case RT_TYPE_STRING:
+            return "sal_Unicode*";
+    }
+    return "NONE";
+}
+static void printConstValue(RTConstValue& constValue)
+{
+    switch (constValue.m_type)
+    {
+        case RT_TYPE_NONE:
+            fprintf(stderr, "none");
+        case RT_TYPE_BOOL:
+            fprintf(stderr, "%s", constValue.m_value.aBool ? "TRUE" : "FALSE");
+        case RT_TYPE_BYTE:
+            fprintf(stderr, "%d", constValue.m_value.aByte);
+        case RT_TYPE_INT16:
+            fprintf(stderr, "%d", constValue.m_value.aShort);
+        case RT_TYPE_UINT16:
+            fprintf(stderr, "%d", constValue.m_value.aUShort);
+        case RT_TYPE_INT32:
+            fprintf(stderr, "%d", constValue.m_value.aLong);
+        case RT_TYPE_UINT32:
+            fprintf(stderr, "%d", constValue.m_value.aULong);
+//      case RT_TYPE_INT64:
+//          fprintf(stderr, "%d", constValue.m_value.aHyper);
+//      case RT_TYPE_UINT64:
+//          fprintf(stderr, "%d", constValue.m_value.aUHyper);
+        case RT_TYPE_FLOAT:
+            fprintf(stderr, "%f", constValue.m_value.aFloat);
+        case RT_TYPE_DOUBLE:
+            fprintf(stderr, "%f", constValue.m_value.aDouble);
+        case RT_TYPE_STRING:
+            fprintf(stderr, "%s", constValue.m_value.aString);
+    }
+}
+
+static sal_uInt32 checkConstValue(const OUString& keyName,
+                                  RTTypeClass typeClass,
+                                  sal_Bool& bDump,
+                                  RTConstValue& constValue1,
+                                  RTConstValue& constValue2,
+                                  sal_uInt16 index)
+{
+    switch (constValue1.m_type)
+    {
+        case RT_TYPE_BOOL:
+            if (constValue1.m_value.aBool != constValue2.m_value.aBool)
+            {
+                if ( options.forceOutput() )
+                {
+                    if ( bDump )
+                    {
+                        fprintf(stderr, "%s: %s\n", getTypeClass(typeClass), U2S(keyName));
+                        bDump = sal_False;
+                    }
+                    fprintf(stderr, "    Field %d: Value1 = %s  !=  Value2 = %s\n", index,
+                            constValue1.m_value.aBool ? "TRUE" : "FALSE",
+                            constValue2.m_value.aBool ? "TRUE" : "FALSE");
+                }
+                return 1;
+            }
+            break;
+        case RT_TYPE_BYTE:
+            if (constValue1.m_value.aByte != constValue2.m_value.aByte)
+            {
+                if ( options.forceOutput() )
+                {
+                    if ( bDump )
+                    {
+                        fprintf(stderr, "%s: %s\n", getTypeClass(typeClass), U2S(keyName));
+                        bDump = sal_False;
+                    }
+                    fprintf(stderr, "    Field %d: Value1 = %d  !=  Value2 = %d\n", index,
+                            constValue1.m_value.aByte, constValue2.m_value.aByte);
+                }
+                return 1;
+            }
+            break;
+        case RT_TYPE_INT16:
+            if (constValue1.m_value.aShort != constValue2.m_value.aShort)
+            {
+                if ( options.forceOutput() )
+                {
+                    if ( bDump )
+                    {
+                        fprintf(stderr, "%s: %s\n", getTypeClass(typeClass), U2S(keyName));
+                        bDump = sal_False;
+                    }
+                    fprintf(stderr, "    Field %d: Value1 = %d  !=  Value2 = %d\n", index,
+                            constValue1.m_value.aShort, constValue2.m_value.aShort);
+                }
+                return 1;
+            }
+            break;
+        case RT_TYPE_UINT16:
+            if (constValue1.m_value.aUShort != constValue2.m_value.aUShort)
+            {
+                if ( options.forceOutput() )
+                {
+                    if ( bDump )
+                    {
+                        fprintf(stderr, "%s: %s\n", getTypeClass(typeClass), U2S(keyName));
+                        bDump = sal_False;
+                    }
+                    fprintf(stderr, "    Field %d: Value1 = %d  !=  Value2 = %d\n", index,
+                            constValue1.m_value.aUShort, constValue2.m_value.aUShort);
+                }
+                return 1;
+            }
+            break;
+        case RT_TYPE_INT32:
+            if (constValue1.m_value.aLong != constValue2.m_value.aLong)
+            {
+                if ( options.forceOutput() )
+                {
+                    if ( bDump )
+                    {
+                        fprintf(stderr, "%s: %s\n", getTypeClass(typeClass), U2S(keyName));
+                        bDump = sal_False;
+                    }
+                    fprintf(stderr, "    Field %d: Value1 = %d  !=  Value2 = %d\n", index,
+                            constValue1.m_value.aLong, constValue2.m_value.aLong);
+                }
+                return 1;
+            }
+            break;
+        case RT_TYPE_UINT32:
+            if (constValue1.m_value.aULong != constValue2.m_value.aULong)
+            {
+                if ( options.forceOutput() )
+                {
+                    if ( bDump )
+                    {
+                        fprintf(stderr, "%s: %s\n", getTypeClass(typeClass), U2S(keyName));
+                        bDump = sal_False;
+                    }
+                    fprintf(stderr, "    Field %d: Value1 = %d  !=  Value2 = %d\n", index,
+                            constValue1.m_value.aULong, constValue2.m_value.aULong);
+                }
+                return 1;
+            }
+            break;
+//      case RT_TYPE_INT64:
+//          if (constValue1.m_value.aHyper != constValue2.m_value.aHyper)
+//          {
+//              if ( options.forceOutput() )
+//              {
+//                  if ( bDump )
+//                  {
+//                      fprintf(stderr, "%s: %s\n", getTypeClass(typeClass), U2S(keyName));
+//                      bDump = sal_False;
+//                  }
+//                  fprintf(stderr, "    Field %d: Value1 = %d  !=  Value2 = %d\n", index,
+//                          constValue1.m_value.aHyper, constValue2.m_value.aHyper);
+//              }
+//              return 1;
+//          }
+//          break;
+//      case RT_TYPE_UINT64:
+//          if (constValue1.m_value.aUHyper != constValue2.m_value.aUHyper)
+//          {
+//              if ( options.forceOutput() )
+//              {
+//                  if ( bDump )
+//                  {
+//                      fprintf(stderr, "%s: %s\n", getTypeClass(typeClass), U2S(keyName));
+//                      bDump = sal_False;
+//                  }
+//                  fprintf(stderr, "    Field %d: Value1 = %d  !=  Value2 = %d\n", index,
+//                          constValue1.m_value.aUHyper, constValue2.m_value.aUHyper);
+//              }
+//              return 1;
+//          }
+//          break;
+        case RT_TYPE_FLOAT:
+            if (constValue1.m_value.aFloat != constValue2.m_value.aFloat)
+            {
+                if ( options.forceOutput() )
+                {
+                    if ( bDump )
+                    {
+                        fprintf(stderr, "%s: %s\n", getTypeClass(typeClass), U2S(keyName));
+                        bDump = sal_False;
+                    }
+                    fprintf(stderr, "    Field %d: Value1 = %d  !=  Value2 = %d\n", index,
+                            constValue1.m_value.aFloat, constValue2.m_value.aFloat);
+                }
+                return 1;
+            }
+            break;
+        case RT_TYPE_DOUBLE:
+            if (constValue1.m_value.aDouble != constValue2.m_value.aDouble)
+            {
+                if ( options.forceOutput() )
+                {
+                    if ( bDump )
+                    {
+                        fprintf(stderr, "%s: %s\n", getTypeClass(typeClass), U2S(keyName));
+                        bDump = sal_False;
+                    }
+                    fprintf(stderr, "    Field %d: Value1 = %d  !=  Value2 = %d\n", index,
+                            constValue1.m_value.aDouble, constValue2.m_value.aDouble);
+                }
+                return 1;
+            }
+            break;
+        case RT_TYPE_STRING:
+            if (rtl_ustr_compare(constValue1.m_value.aString, constValue2.m_value.aString) != 0)
+            {
+                if ( options.forceOutput() )
+                {
+                    if ( bDump )
+                    {
+                        fprintf(stderr, "%s\n", U2S(keyName));
+                        fprintf(stderr, "    TypeClass = %s\n", getTypeClass(typeClass));
+                        bDump = sal_False;
+                    }
+                    fprintf(stderr, "    Field %d: Value1 = %d  !=  Value2 = %d\n", index,
+                            constValue1.m_value.aString, constValue2.m_value.aString);
+                }
+                return 1;
+            }
+    }
+    return 0;
+}
+
+static sal_uInt32 checkField(const OUString& keyName,
+                             RTTypeClass typeClass,
+                             sal_Bool& bDump,
+                             RegistryTypeReader& reader1,
+                             RegistryTypeReader& reader2,
+                             sal_uInt16 index)
+{
+    sal_uInt32 nError = 0;
+    if ( reader1.getFieldName(index) !=
+         reader2.getFieldName(index) )
+    {
+        if ( options.forceOutput() )
+        {
+            if ( bDump )
+            {
+                fprintf(stderr, "%s: %s\n", getTypeClass(typeClass), U2S(keyName));
+                bDump = sal_False;
+            }
+            fprintf(stderr, "    Field %d: Name1 = %s  !=  Name2 = %s\n", index,
+                    U2S(reader1.getFieldName(index)), U2S(reader2.getFieldName(index)));
+        }
+        nError++;
+    }
+    if ( reader1.getFieldType(index) !=
+         reader2.getFieldType(index) )
+    {
+        if ( options.forceOutput() )
+        {
+            if ( bDump )
+            {
+                fprintf(stderr, "%s: %s\n", getTypeClass(typeClass), U2S(keyName));
+                bDump = sal_False;
+            }
+            fprintf(stderr, "    Field %d: Type1 = %s  !=  Type2 = %s\n", index,
+                    U2S(reader1.getFieldType(index)), U2S(reader2.getFieldType(index)));
+        }
+        nError++;
+    } else
+    {
+        RTConstValue constValue1 = reader1.getFieldConstValue(index);
+        RTConstValue constValue2 = reader2.getFieldConstValue(index);
+        if ( constValue1.m_type != constValue2.m_type )
+        {
+            if ( options.forceOutput() )
+            {
+                if ( bDump )
+                {
+                    fprintf(stderr, "%s: %s\n", getTypeClass(typeClass), U2S(keyName));
+                    bDump = sal_False;
+                }
+                fprintf(stderr, "    Field %d: Access1 = %s  !=  Access2 = %s\n", index,
+                        getConstValueType(constValue1), getConstValueType(constValue2));
+                fprintf(stderr, "    Field %d: Value1 = ", index);
+                printConstValue(constValue1);
+                fprintf(stderr, "  !=  Value2 = ");
+                printConstValue(constValue1);
+                fprintf(stderr, "\n;");
+            }
+            nError++;
+        } else
+        {
+            nError += checkConstValue(keyName, typeClass, bDump, constValue1, constValue2, index);
+        }
+    }
+
+    if ( reader1.getFieldAccess(index) != reader2.getFieldAccess(index) )
+    {
+        if ( options.forceOutput() )
+        {
+            if ( bDump )
+            {
+                fprintf(stderr, "%s: %s\n", getTypeClass(typeClass), U2S(keyName));
+                bDump = sal_False;
+            }
+            fprintf(stderr, "    Field %d: FieldAccess1 = %s  !=  FieldAccess2 = %s\n", index,
+                    getFieldAccess(reader1.getFieldAccess(index)).getStr(),
+                    getFieldAccess(reader1.getFieldAccess(index)).getStr());
+        }
+        nError++;
+    }
+
+    if ( options.fullCheck() &&
+         (reader1.getFieldDoku(index) != reader2.getFieldDoku(index)) )
+    {
+        if ( options.forceOutput() )
+        {
+            if ( bDump )
+            {
+                fprintf(stderr, "%s: %s\n", getTypeClass(typeClass), U2S(keyName));
+                bDump = sal_False;
+            }
+            fprintf(stderr, "    Field %d: Doku1 = %s  !=  Doku2 = %s\n", index,
+                    U2S(reader1.getFieldDoku(index)), U2S(reader2.getFieldDoku(index)));
+        }
+        nError++;
+    }
+    if ( options.fullCheck() &&
+         (reader1.getFieldFileName(index) != reader2.getFieldFileName(index)) )
+    {
+        if ( options.forceOutput() )
+        {
+            if ( bDump )
+            {
+                fprintf(stderr, "%s: %s\n", getTypeClass(typeClass), U2S(keyName));
+                bDump = sal_False;
+            }
+            fprintf(stderr, "    Field %d: FileName1 = %s  !=  FileName2 = %s\n", index,
+                    U2S(reader1.getFieldFileName(index)), U2S(reader2.getFieldFileName(index)));
+        }
+        nError++;
+    }
+    return nError;
+}
+
+static sal_Char* getMethodMode(RTMethodMode methodMode)
+{
+    switch ( methodMode )
+    {
+        case RT_MODE_ONEWAY:
+            return "ONEWAY";
+        case RT_MODE_ONEWAY_CONST:
+            return "ONEWAY,CONST";
+        case RT_MODE_TWOWAY:
+            return "NONE";
+        case RT_MODE_TWOWAY_CONST:
+            return "CONST";
+    }
+    return "INVALID";
+}
+
+static sal_Char* getParamMode(RTParamMode paramMode)
+{
+    switch ( paramMode )
+    {
+        case RT_PARAM_IN:
+            return "IN";
+        case RT_PARAM_OUT:
+            return "OUT";
+        case RT_PARAM_INOUT:
+            return "INOUT";
+    }
+    return "INVALID";
+}
+
+static sal_uInt32 checkMethod(const OUString& keyName,
+                              RTTypeClass typeClass,
+                              sal_Bool& bDump,
+                              RegistryTypeReader& reader1,
+                              RegistryTypeReader& reader2,
+                              sal_uInt16 index)
+{
+    sal_uInt32 nError = 0;
+    if ( reader1.getMethodName(index) !=
+         reader2.getMethodName(index) )
+    {
+        if ( options.forceOutput() )
+        {
+            if ( bDump )
+            {
+                fprintf(stderr, "%s: %s\n", getTypeClass(typeClass), U2S(keyName));
+                bDump = sal_False;
+            }
+            fprintf(stderr, "    Method1 %d: Name1 = %s  !=  Name2 = %s\n", index,
+                    U2S(reader1.getMethodName(index)),
+                    U2S(reader2.getMethodName(index)));
+        }
+        nError++;
+    }
+
+    if ( reader1.getMethodReturnType(index) !=
+         reader2.getMethodReturnType(index) )
+    {
+        if ( options.forceOutput() )
+        {
+            if ( bDump )
+            {
+                fprintf(stderr, "%s: %s\n", getTypeClass(typeClass), U2S(keyName));
+                bDump = sal_False;
+            }
+            fprintf(stderr, "    Method1 %d: ReturnType1 = %s  !=  ReturnType2 = %s\n", index,
+                    U2S(reader1.getMethodReturnType(index)),
+                    U2S(reader2.getMethodReturnType(index)));
+        }
+        nError++;
+    }
+
+    sal_uInt16 nParams1 = (sal_uInt16)reader1.getMethodParamCount(index);
+    sal_uInt16 nParams2 = (sal_uInt16)reader2.getMethodParamCount(index);
+    if ( nParams1 != nParams2 )
+    {
+        if ( options.forceOutput() )
+        {
+            if ( bDump )
+            {
+                fprintf(stderr, "%s: %s\n", getTypeClass(typeClass), U2S(keyName));
+                bDump = sal_False;
+            }
+            fprintf(stderr, "    Method %d : nParameters1 = %d  !=  nParameters2 = %d\n", index, nParams1, nParams2);
+        }
+        nError++;
+    }
+    sal_uInt16 i=0;
+    for (i=0; i < nParams1 && i < nParams2; i++)
+    {
+        if ( reader1.getMethodParamType(index, i) != reader2.getMethodParamType(index, i) )
+        {
+            if ( options.forceOutput() )
+            {
+                if ( bDump )
+                {
+                    fprintf(stderr, "%s: %s\n", getTypeClass(typeClass), U2S(keyName));
+                    bDump = sal_False;
+                }
+                fprintf(stderr, "    Method %d, Parameter %d: Type1 = %s  !=  Type2 = %s\n", index, i,
+                        U2S(reader1.getMethodParamType(index, i)),
+                        U2S(reader2.getMethodParamType(index, i)));
+            }
+            nError++;
+        }
+        if ( options.fullCheck() &&
+             (reader1.getMethodParamName(index, i) != reader2.getMethodParamName(index, i)) )
+        {
+            if ( options.forceOutput() )
+            {
+                if ( bDump )
+                {
+                    fprintf(stderr, "%s: %s\n", getTypeClass(typeClass), U2S(keyName));
+                    bDump = sal_False;
+                }
+                fprintf(stderr, "    Method %d, Parameter %d: Name1 = %s  !=  Name2 = %s\n", index, i,
+                        U2S(reader1.getMethodParamName(index, i)),
+                        U2S(reader2.getMethodParamName(index, i)));
+            }
+            nError++;
+        }
+        if ( reader1.getMethodParamMode(index, i) != reader2.getMethodParamMode(index, i) )
+        {
+            if ( options.forceOutput() )
+            {
+                if ( bDump )
+                {
+                    fprintf(stderr, "%s: %s\n", getTypeClass(typeClass), U2S(keyName));
+                    bDump = sal_False;
+                }
+                fprintf(stderr, "    Method %d, Parameter %d: Mode1 = %s  !=  Mode2 = %s\n", index, i,
+                        getParamMode(reader1.getMethodParamMode(index, i)),
+                        getParamMode(reader2.getMethodParamMode(index, i)));
+            }
+            nError++;
+        }
+    }
+    if ( i < nParams1 && options.forceOutput() )
+    {
+        if ( bDump )
+        {
+            fprintf(stderr, "%s: %s\n", getTypeClass(typeClass), U2S(keyName));
+            bDump = sal_False;
+        }
+        fprintf(stderr, "    Registry1: Method %d contains %d more parameters\n", nParams1 - i);
+    }
+    if ( i < nParams2 && options.forceOutput() )
+    {
+        if ( bDump )
+        {
+            fprintf(stderr, "%s: %s\n", getTypeClass(typeClass), U2S(keyName));
+            bDump = sal_False;
+        }
+        fprintf(stderr, "    Registry2: Method %d contains %d more parameters\n", nParams2 - i);
+    }
+
+    sal_uInt16 nExcep1 = (sal_uInt16)reader1.getMethodExcCount(index);
+    sal_uInt16 nExcep2 = (sal_uInt16)reader2.getMethodExcCount(index);
+    if ( nExcep1 != nExcep2 )
+    {
+        if ( options.forceOutput() )
+        {
+            if ( bDump )
+            {
+                fprintf(stderr, "%s: %s\n", getTypeClass(typeClass), U2S(keyName));
+                bDump = sal_False;
+            }
+            fprintf(stderr, "    nExceptions1 = %d  !=  nExceptions2 = %d\n", nExcep1, nExcep2);
+        }
+        nError++;
+    }
+    for (i=0; i < nExcep1 && i < nExcep2; i++)
+    {
+        if ( reader1.getMethodExcType(index, i) != reader2.getMethodExcType(index, i) )
+        {
+            if ( options.forceOutput() )
+            {
+                if ( bDump )
+                {
+                    fprintf(stderr, "%s: %s\n", getTypeClass(typeClass), U2S(keyName));
+                    bDump = sal_False;
+                }
+                fprintf(stderr, "    Method %d, Exception %d: Name1 = %s  !=  Name2 = %s\n", index, i,
+                        U2S(reader1.getMethodExcType(index, i)),
+                        U2S(reader2.getMethodExcType(index, i)));
+            }
+            nError++;
+        }
+    }
+    if ( i < nExcep1 && options.forceOutput() )
+    {
+        if ( bDump )
+        {
+            fprintf(stderr, "%s: %s\n", getTypeClass(typeClass), U2S(keyName));
+            bDump = sal_False;
+        }
+        fprintf(stderr, "    Registry1: Method %d contains %d more exceptions\n", nExcep1 - i);
+    }
+    if ( i < nExcep2 && options.forceOutput() )
+    {
+        if ( bDump )
+        {
+            fprintf(stderr, "%s: %s\n", getTypeClass(typeClass), U2S(keyName));
+            bDump = sal_False;
+        }
+        fprintf(stderr, "    Registry2: Method %d contains %d more exceptions\n", nExcep2 - i);
+    }
+
+    if ( reader1.getMethodMode(index) != reader2.getMethodMode(index) )
+    {
+        if ( options.forceOutput() )
+        {
+            if ( bDump )
+            {
+                fprintf(stderr, "%s: %s\n", getTypeClass(typeClass), U2S(keyName));
+                bDump = sal_False;
+            }
+            fprintf(stderr, "    Method %d: Mode1 = %s  !=  Mode2 = %s\n", index,
+                    getMethodMode(reader1.getMethodMode(index)),
+                    getMethodMode(reader2.getMethodMode(index)));
+        }
+        nError++;
+    }
+
+    if ( options.fullCheck() &&
+         (reader1.getMethodDoku(index) != reader2.getMethodDoku(index)) )
+    {
+        if ( options.forceOutput() )
+        {
+            if ( bDump )
+            {
+                fprintf(stderr, "%s: %s\n", getTypeClass(typeClass), U2S(keyName));
+                bDump = sal_False;
+            }
+            fprintf(stderr, "    Method %d: Doku1 = %s  !=  Doku2 = %s\n", index,
+                    U2S(reader1.getMethodDoku(index)),
+                    U2S(reader2.getMethodDoku(index)));
+        }
+        nError++;
+    }
+    return nError;
+}
+
+static sal_Char* getReferenceType(RTReferenceType refType)
+{
+    switch (refType)
+    {
+        case RT_REF_SUPPORTS:
+            return "RT_REF_SUPPORTS";
+        case RT_REF_OBSERVES:
+            return "RT_REF_OBSERVES";
+        case RT_REF_EXPORTS:
+            return "RT_REF_EXPORTS";
+        case RT_REF_NEEDS:
+            return "RT_REF_NEEDS";
+    }
+    return "RT_REF_INVALID";
+}
+
+static sal_uInt32 checkReference(const OUString& keyName,
+                                 RTTypeClass typeClass,
+                                 sal_Bool& bDump,
+                                 RegistryTypeReader& reader1,
+                                    RegistryTypeReader& reader2,
+                                    sal_uInt16 index)
+{
+    sal_uInt32 nError = 0;
+    if ( reader1.getReferenceName(index) !=
+         reader2.getReferenceName(index) )
+    {
+        if ( options.forceOutput() )
+        {
+            if ( bDump )
+            {
+                fprintf(stderr, "%s: %s\n", getTypeClass(typeClass), U2S(keyName));
+                bDump = sal_False;
+            }
+            fprintf(stderr, "    Reference %d: Name1 = %s  !=  Name2 = %s\n", index,
+                    U2S(reader1.getReferenceName(index)),
+                    U2S(reader2.getReferenceName(index)));
+        }
+        nError++;
+    }
+    if ( reader1.getReferenceType(index) !=
+         reader2.getReferenceType(index) )
+    {
+        if ( options.forceOutput() )
+        {
+            if ( bDump )
+            {
+                fprintf(stderr, "%s: %s\n", getTypeClass(typeClass), U2S(keyName));
+                bDump = sal_False;
+            }
+            fprintf(stderr, "    Reference %d: Type1 = %s  !=  Type2 = %s\n", index,
+                    getReferenceType(reader1.getReferenceType(index)),
+                    getReferenceType(reader2.getReferenceType(index)));
+        }
+        nError++;
+    }
+    if ( options.fullCheck() &&
+         (reader1.getReferenceDoku(index) != reader2.getReferenceDoku(index)) )
+    {
+        if ( options.forceOutput() )
+        {
+            if ( bDump )
+            {
+                fprintf(stderr, "%s: %s\n", getTypeClass(typeClass), U2S(keyName));
+                bDump = sal_False;
+            }
+            fprintf(stderr, "    Reference %d: Doku1 = %s  !=  Doku2 = %s\n", index,
+                    U2S(reader1.getReferenceDoku(index)),
+                    U2S(reader2.getReferenceDoku(index)));
+        }
+        nError++;
+    }
+    if ( reader1.getReferenceAccess(index) !=
+         reader2.getReferenceAccess(index) )
+    {
+        if ( options.forceOutput() )
+        {
+            if ( bDump )
+            {
+                fprintf(stderr, "%s: %s\n", getTypeClass(typeClass), U2S(keyName));
+                bDump = sal_False;
+            }
+            fprintf(stderr, "    Reference %d: Access1 = %s  !=  Access2 = %s\n", index,
+                    getFieldAccess(reader1.getReferenceAccess(index)).getStr(),
+                    getFieldAccess(reader1.getReferenceAccess(index)).getStr());
+        }
+        nError++;
+    }
+    return nError;
+}
+
+static sal_uInt32 checkBlob(const OUString& keyName, RegistryTypeReader& reader1, sal_uInt32 size1,
+                            RegistryTypeReader& reader2, sal_uInt32 size2)
+{
+    sal_uInt32 nError = 0;
+    sal_Bool bDump = sal_True;
+
+    if ( options.fullCheck() && (size1 != size2) )
+    {
+        if ( options.forceOutput() )
+        {
+            fprintf(stderr, "    Size1 = %d    Size2 = %d\n", size1, size2);
+        }
+    }
+    if ( reader1.getTypeClass() != reader2.getTypeClass() )
+    {
+        if ( options.forceOutput() )
+        {
+            fprintf(stderr, "?: %s\n", U2S(keyName));
+            bDump = sal_False;
+            fprintf(stderr, "    TypeClass1 = %s  !=  TypeClass2 = %s\n",
+                    getTypeClass(reader1.getTypeClass()),
+                    getTypeClass(reader2.getTypeClass()));
+        }
+        return ++nError;
+    }
+
+    RTTypeClass typeClass = reader1.getTypeClass();
+
+    if ( reader1.getTypeName() != reader2.getTypeName() )
+    {
+        if ( options.forceOutput() )
+        {
+            if ( bDump )
+            {
+                fprintf(stderr, "%s: %s\n", getTypeClass(typeClass), U2S(keyName));
+                bDump = sal_False;
+            }
+            fprintf(stderr, "    TypeName1 = %s  !=  TypeName2 = %s\n",
+                    U2S(reader1.getTypeName()), U2S(reader2.getTypeName()));
+        }
+        nError++;
+    }
+    if ( (typeClass == RT_TYPE_INTERFACE ||
+          typeClass == RT_TYPE_STRUCT ||
+          typeClass == RT_TYPE_EXCEPTION) &&
+         reader1.getSuperTypeName() != reader2.getSuperTypeName() )
+    {
+        if ( options.forceOutput() )
+        {
+            if ( bDump )
+            {
+                fprintf(stderr, "%s: %s\n", getTypeClass(typeClass), U2S(keyName));
+                bDump = sal_False;
+            }
+            fprintf(stderr, "    SuperTypeName1 = %s  !=  SuperTypeName2 = %s\n",
+                    U2S(reader1.getSuperTypeName()), U2S(reader2.getSuperTypeName()));
+        }
+        nError++;
+    }
+    if ( typeClass == RT_TYPE_INTERFACE )
+    {
+        RTUik uik1, uik2;
+        reader1.getUik(uik1);
+        reader2.getUik(uik2);
+        if ( uik1.m_Data1 != uik2.m_Data1 ||
+             uik1.m_Data2 != uik2.m_Data2 ||
+             uik1.m_Data3 != uik2.m_Data3 ||
+             uik1.m_Data4 != uik2.m_Data4 ||
+             uik1.m_Data5 != uik2.m_Data5 )
+        {
+            if ( options.forceOutput() )
+            {
+                if ( bDump )
+                {
+                    fprintf(stderr, "%s: %s\n", getTypeClass(typeClass), U2S(keyName));
+                    bDump = sal_False;
+                }
+                fprintf(stderr, "    uik1.m_data1 = %X    uik2.m_data1 = %X\n", uik1.m_Data1, uik2.m_Data1);
+                fprintf(stderr, "    uik1.m_data2 = %X    uik2.m_data2 = %X\n", uik1.m_Data2, uik2.m_Data2);
+                fprintf(stderr, "    uik1.m_data3 = %X    uik2.m_data3 = %X\n", uik1.m_Data3, uik2.m_Data3);
+                fprintf(stderr, "    uik1.m_data4 = %X    uik2.m_data4 = %X\n", uik1.m_Data4, uik2.m_Data4);
+                fprintf(stderr, "    uik1.m_data5 = %X    uik2.m_data5 = %X\n", uik1.m_Data5, uik2.m_Data5);
+            }
+            nError++;
+        }
+    }
+    sal_uInt16 nFields1 = (sal_uInt16)reader1.getFieldCount();
+    sal_uInt16 nFields2 = (sal_uInt16)reader2.getFieldCount();
+    if ( nFields1 != nFields2 )
+    {
+        if ( options.forceOutput() )
+        {
+            if ( bDump )
+            {
+                fprintf(stderr, "%s: %s\n", getTypeClass(typeClass), U2S(keyName));
+                bDump = sal_False;
+            }
+            fprintf(stderr, "    nFields1 = %d  !=  nFields2 = %d\n", nFields1, nFields2);
+        }
+        nError++;
+    }
+    sal_uInt16 i=0;
+    for (i=0; i < nFields1 && i < nFields2; i++)
+    {
+        nError += checkField(keyName, typeClass, bDump, reader1, reader2, i);
+    }
+    if ( i < nFields1 && options.forceOutput() )
+    {
+        if ( bDump )
+        {
+            fprintf(stderr, "%s: %s\n", getTypeClass(typeClass), U2S(keyName));
+            bDump = sal_False;
+        }
+        fprintf(stderr, "    Registry1 contains %d more fields\n", nFields1 - i);
+    }
+    if ( i < nFields2 && options.forceOutput() )
+    {
+        if ( bDump )
+        {
+            fprintf(stderr, "%s: %s\n", getTypeClass(typeClass), U2S(keyName));
+            bDump = sal_False;
+        }
+        fprintf(stderr, "    Registry2 contains %d more fields\n", nFields2 - i);
+    }
+    if ( typeClass == RT_TYPE_INTERFACE )
+    {
+        sal_uInt16 nMethods1 = (sal_uInt16)reader1.getMethodCount();
+        sal_uInt16 nMethods2 = (sal_uInt16)reader2.getMethodCount();
+        if ( nMethods1 != nMethods2 )
+        {
+            if ( options.forceOutput() )
+            {
+                if ( bDump )
+                {
+                    fprintf(stderr, "%s: %s\n", getTypeClass(typeClass), U2S(keyName));
+                    bDump = sal_False;
+                }
+                fprintf(stderr, "    nMethods1 = %d  !=  nMethods2 = %d\n", nMethods1, nMethods2);
+            }
+            nError++;
+        }
+        for (i=0; i < nMethods1 && i < nMethods2; i++)
+        {
+            nError += checkMethod(keyName, typeClass, bDump, reader1, reader2, i);
+        }
+        if ( i < nMethods1 && options.forceOutput() )
+        {
+            fprintf(stderr, "    Registry1 contains %d more methods\n", nMethods1 - i);
+        }
+        if ( i < nMethods2 && options.forceOutput() )
+        {
+            fprintf(stderr, "    Registry2 contains %d more methods\n", nMethods2 - i);
+        }
+    }
+    if ( typeClass == RT_TYPE_SERVICE )
+    {
+        sal_uInt16 nReference1 = (sal_uInt16)reader1.getReferenceCount();
+        sal_uInt16 nReference2 = (sal_uInt16)reader2.getReferenceCount();
+        if ( nReference1 != nReference2 )
+        {
+            if ( options.forceOutput() )
+            {
+                if ( bDump )
+                {
+                    fprintf(stderr, "%s: %s\n", getTypeClass(typeClass), U2S(keyName));
+                    bDump = sal_False;
+                }
+                fprintf(stderr, "    nReferences1 = %d  !=  nReferences2 = %d\n", nReference1, nReference2);
+            }
+            nError++;
+        }
+        for (i=0; i < nReference1 && i < nReference2; i++)
+        {
+            nError += checkReference(keyName, typeClass, bDump, reader1, reader2, i);
+        }
+        if ( i < nReference1 && options.forceOutput() )
+        {
+            fprintf(stderr, "    Registry1 contains %d more references\n", nReference1 - i);
+        }
+        if ( i < nReference2 && options.forceOutput() )
+        {
+            fprintf(stderr, "    Registry2 contains %d more references\n", nReference2 - i);
+        }
+    }
+
+    if ( options.fullCheck() && (reader1.getDoku() != reader2.getDoku()) )
+    {
+        if ( options.forceOutput() )
+        {
+            if ( bDump )
+            {
+                fprintf(stderr, "%s: %s\n", getTypeClass(typeClass), U2S(keyName));
+                bDump = sal_False;
+            }
+            fprintf(stderr, "    Doku1 = %s  !=  Doku2 = %s\n",
+                    U2S(reader1.getDoku()), U2S(reader2.getDoku()));
+        }
+        nError++;
+    }
+    if ( options.fullCheck() && (reader1.getFileName() != reader2.getFileName()) )
+    {
+        if ( options.forceOutput() )
+        {
+            if ( bDump )
+            {
+                fprintf(stderr, "%s: %s\n", getTypeClass(typeClass), U2S(keyName));
+            }
+            fprintf(stderr, "    FileName1 = %s  !=  FileName2 = %s\n",
+                    U2S(reader1.getFileName()), U2S(reader2.getFileName()));
+        }
+        nError++;
+    }
+    return nError;
+}
+
+static sal_uInt32 checkValueDifference(RegistryKey& key1, RegValueType valueType1, sal_uInt32 size1,
+                                RegistryKey& key2, RegValueType valueType2, sal_uInt32 size2)
+{
+    OUString tmpName;
+    sal_uInt32 nError = 0;
+
+    if ( valueType1 == valueType2 )
+    {
+        sal_Bool bEqual = sal_True;
+        if ( valueType1 == RG_VALUETYPE_LONGLIST ||
+              valueType1 == RG_VALUETYPE_STRINGLIST ||
+              valueType1 == RG_VALUETYPE_UNICODELIST )
+        {
+            switch (valueType1)
+            {
+            case RG_VALUETYPE_LONGLIST:
+                {
+                RegistryValueList<sal_Int32> valueList1;
+                RegistryValueList<sal_Int32> valueList2;
+                key1.getLongListValue(tmpName, valueList1);
+                key2.getLongListValue(tmpName, valueList2);
+                sal_uInt32 length1 = valueList1.getLength();
+                sal_uInt32 length2 = valueList1.getLength();
+                if ( length1 != length2 )
+                {
+                    bEqual = sal_False;
+                    break;
+                }
+                for (sal_uInt32 i=0; i<length1; i++)
+                {
+                    if ( valueList1.getElement(i) != valueList2.getElement(i) )
+                    {
+                        bEqual = sal_False;
+                        break;
+                    }
+                }
+                }
+                break;
+            case RG_VALUETYPE_STRINGLIST:
+                {
+                RegistryValueList<sal_Char*> valueList1;
+                RegistryValueList<sal_Char*> valueList2;
+                key1.getStringListValue(tmpName, valueList1);
+                key2.getStringListValue(tmpName, valueList2);
+                sal_uInt32 length1 = valueList1.getLength();
+                sal_uInt32 length2 = valueList1.getLength();
+                if ( length1 != length2 )
+                {
+                    bEqual = sal_False;
+                    break;
+                }
+                for (sal_uInt32 i=0; i<length1; i++)
+                {
+                    if ( strcmp(valueList1.getElement(i), valueList2.getElement(i)) != 0 )
+                    {
+                        bEqual = sal_False;
+                        break;
+                    }
+                }
+                }
+                break;
+            case RG_VALUETYPE_UNICODELIST:
+                {
+                RegistryValueList<sal_Unicode*> valueList1;
+                RegistryValueList<sal_Unicode*> valueList2;
+                key1.getUnicodeListValue(tmpName, valueList1);
+                key2.getUnicodeListValue(tmpName, valueList2);
+                sal_uInt32 length1 = valueList1.getLength();
+                sal_uInt32 length2 = valueList1.getLength();
+                if ( length1 != length2 )
+                {
+                    bEqual = sal_False;
+                    break;
+                }
+                for (sal_uInt32 i=0; i<length1; i++)
+                {
+                    if ( rtl_ustr_compare(valueList1.getElement(i), valueList2.getElement(i)) != 0 )
+                    {
+                        bEqual = sal_False;
+                        break;
+                    }
+                }
+                }
+                break;
+            }
+        }
+
+        if ( bEqual)
+        {
+            RegValue value1 = rtl_allocateMemory(size1);
+            RegValue value2 = rtl_allocateMemory(size2);
+
+            key1.getValue(tmpName, value1);
+            key2.getValue(tmpName, value2);
+
+            bEqual = (rtl_compareMemory(value1, value2, size1) == 0 );
+
+            if ( !bEqual && valueType1 == RG_VALUETYPE_BINARY && valueType1 == RG_VALUETYPE_BINARY )
+            {
+                RegistryTypeReader reader1(getRegistryTypeReaderLoader(),
+                                           (sal_uInt8*)value1, size1, sal_False);
+                RegistryTypeReader reader2(getRegistryTypeReaderLoader(),
+                                           (sal_uInt8*)value2, size2, sal_False);
+
+                if ( reader1.isValid() && reader2.isValid() )
+                {
+                    return checkBlob(key1.getName(), reader1, size1, reader2, size2);
+                }
+            }
+
+            rtl_freeMemory(value1);
+            rtl_freeMemory(value2);
+
+            if ( bEqual )
+            {
+                return 0;
+            } else
+            {
+                if ( options.forceOutput() )
+                {
+                    fprintf(stderr, "Difference: key values of key \"%s\" are different\n",
+                            U2S(key1.getName()));
+                }
+                nError++;
+            }
+        }
+    }
+
+    if ( options.forceOutput() )
+    {
+        switch (valueType1)
+        {
+        case RG_VALUETYPE_NOT_DEFINED:
+            fprintf(stderr, "    Registry 1: key has no value\n");
+            break;
+        case RG_VALUETYPE_LONG:
+        case RG_VALUETYPE_STRING:
+        case RG_VALUETYPE_UNICODE:
+        {
+            RegValue value1 = rtl_allocateMemory(size1);
+            key1.getValue(tmpName, value1);
+
+            switch (valueType1)
+            {
+            case RG_VALUETYPE_LONG:
+                fprintf(stderr, "    Registry 1: Value: Type = RG_VALUETYPE_LONG\n");
+                fprintf(stderr, "                       Size = %d\n", size1);
+                fprintf(stderr, "                       Data = %d\n", (sal_Int32)value1);
+                break;
+            case RG_VALUETYPE_STRING:
+                fprintf(stderr, "    Registry 1: Value: Type = RG_VALUETYPE_STRING\n");
+                fprintf(stderr, "                       Size = %d\n", size1);
+                fprintf(stderr, "                       Data = \"%s\"\n", (sal_Char*)value1);
+                break;
+            case RG_VALUETYPE_UNICODE:
+                {
+                OUString uStrValue((sal_Unicode*)value1);
+                fprintf(stderr, "    Registry 1: Value: Type = RG_VALUETYPE_UNICODE\n");
+                fprintf(stderr, "                       Size = %d\n", size1);
+                fprintf(stderr, "                       Data = \"%s\"\n", U2S(uStrValue));
+                }
+                break;
+            }
+
+            rtl_freeMemory(value1);
+        }
+            break;
+        case RG_VALUETYPE_BINARY:
+            fprintf(stderr, "    Registry 1: Value: Type = RG_VALUETYPE_BINARY\n");
+            break;
+        case RG_VALUETYPE_LONGLIST:
+            {
+            RegistryValueList<sal_Int32> valueList;
+            key1.getLongListValue(tmpName, valueList);
+            fprintf(stderr, "    Registry 1: Value: Type = RG_VALUETYPE_LONGLIST\n");
+            fprintf(stderr, "                       Size = %d\n", size1);
+            sal_uInt32 length = valueList.getLength();
+            for (sal_uInt32 i=0; i<length; i++)
+            {
+                fprintf(stderr, "                       Data[%d] = %d\n", i, valueList.getElement(i));
+            }
+            }
+            break;
+        case RG_VALUETYPE_STRINGLIST:
+            {
+            RegistryValueList<sal_Char*> valueList;
+            key1.getStringListValue(tmpName, valueList);
+            fprintf(stderr, "    Registry 1: Value: Type = RG_VALUETYPE_STRINGLIST\n");
+            fprintf(stderr, "                       Size = %d\n", size1);
+            sal_uInt32 length = valueList.getLength();
+            for (sal_uInt32 i=0; i<length; i++)
+            {
+                fprintf(stderr, "                       Data[%d] = \"%s\"\n", i, valueList.getElement(i));
+            }
+            }
+            break;
+        case RG_VALUETYPE_UNICODELIST:
+            {
+            RegistryValueList<sal_Unicode*> valueList;
+            key1.getUnicodeListValue(tmpName, valueList);
+            fprintf(stderr, "    Registry 1: Value: Type = RG_VALUETYPE_UNICODELIST\n");
+            fprintf(stderr, "                       Size = %d\n", size1);
+            sal_uInt32 length = valueList.getLength();
+            OUString uStrValue;
+            for (sal_uInt32 i=0; i<length; i++)
+            {
+                uStrValue = OUString(valueList.getElement(i));
+                fprintf(stderr, "                       Data[%d] = \"%s\"\n", i, U2S(uStrValue));
+            }
+            }
+            break;
+        }
+
+        switch (valueType2)
+        {
+        case RG_VALUETYPE_NOT_DEFINED:
+            fprintf(stderr, "    Registry 2: key has no value\n");
+            break;
+        case RG_VALUETYPE_LONG:
+        case RG_VALUETYPE_STRING:
+        case RG_VALUETYPE_UNICODE:
+        {
+            RegValue value2 = rtl_allocateMemory(size2);
+            key2.getValue(tmpName, value2);
+
+            switch (valueType2)
+            {
+            case RG_VALUETYPE_LONG:
+                fprintf(stderr, "    Registry 2: Value: Type = RG_VALUETYPE_LONG\n");
+                fprintf(stderr, "                       Size = %d\n", size2);
+                fprintf(stderr, "                       Data = %d\n", (sal_Int32)value2);
+                break;
+            case RG_VALUETYPE_STRING:
+                fprintf(stderr, "    Registry 2: Value: Type = RG_VALUETYPE_STRING\n");
+                fprintf(stderr, "                       Size = %d\n", size2);
+                fprintf(stderr, "                       Data = \"%s\"\n", (sal_Char*)value2);
+                break;
+            case RG_VALUETYPE_UNICODE:
+                {
+                OUString uStrValue((sal_Unicode*)value2);
+                fprintf(stderr, "    Registry 2: Value: Type = RG_VALUETYPE_UNICODE\n");
+                fprintf(stderr, "                       Size = %d\n", size2);
+                fprintf(stderr, "                       Data = \"%s\"\n", U2S(uStrValue));
+                }
+                break;
+            }
+
+            rtl_freeMemory(value2);
+        }
+            break;
+        case RG_VALUETYPE_BINARY:
+            fprintf(stderr, "    Registry 2: Value: Type = RG_VALUETYPE_BINARY\n");
+            break;
+        case RG_VALUETYPE_LONGLIST:
+            {
+            RegistryValueList<sal_Int32> valueList;
+            key2.getLongListValue(tmpName, valueList);
+            fprintf(stderr, "    Registry 2: Value: Type = RG_VALUETYPE_LONGLIST\n");
+            fprintf(stderr, "                       Size = %d\n", size2);
+            sal_uInt32 length = valueList.getLength();
+            for (sal_uInt32 i=0; i<length; i++)
+            {
+                fprintf(stderr, "                       Data[%d] = %d\n", i, valueList.getElement(i));
+            }
+            }
+            break;
+        case RG_VALUETYPE_STRINGLIST:
+            {
+            RegistryValueList<sal_Char*> valueList;
+            key2.getStringListValue(tmpName, valueList);
+            fprintf(stderr, "    Registry 2: Value: Type = RG_VALUETYPE_STRINGLIST\n");
+            fprintf(stderr, "                       Size = %d\n", size2);
+            sal_uInt32 length = valueList.getLength();
+            for (sal_uInt32 i=0; i<length; i++)
+            {
+                fprintf(stderr, "                       Data[%d] = \"%s\"\n", i, valueList.getElement(i));
+            }
+            }
+            break;
+        case RG_VALUETYPE_UNICODELIST:
+            {
+            RegistryValueList<sal_Unicode*> valueList;
+            key2.getUnicodeListValue(tmpName, valueList);
+            fprintf(stderr, "    Registry 2: Value: Type = RG_VALUETYPE_UNICODELIST\n");
+            fprintf(stderr, "                       Size = %d\n", size2);
+            sal_uInt32 length = valueList.getLength();
+            OUString uStrValue;
+            for (sal_uInt32 i=0; i<length; i++)
+            {
+                uStrValue = OUString(valueList.getElement(i));
+                fprintf(stderr, "                       Data[%d] = \"%s\"\n", i, U2S(uStrValue));
+            }
+            }
+            break;
+        }
+    }
+    return nError;
+}
+
+static sal_uInt32 checkDifferences(StringSet& keys, RegistryKeyNames& subKeyNames1,
+                      RegistryKeyNames& subKeyNames2)
+{
+    sal_uInt32 nError = 0;
+    sal_uInt32 length1 = subKeyNames1.getLength();
+    sal_uInt32 length2 = subKeyNames2.getLength();
+    sal_uInt32 i,j;
+    sal_Bool bFound = sal_False;
+
+    for (i=0; i<length1; i++)
+    {
+        for (j=0; j<length2; j++)
+        {
+            if ( subKeyNames1.getElement(i) == subKeyNames2.getElement(j) )
+            {
+                bFound = sal_True;
+                keys.insert(subKeyNames1.getElement(i));
+                break;
+            }
+        }
+        if ( !bFound && options.fullCheck())
+        {
+            if ( options.forceOutput() )
+            {
+                fprintf(stderr, "EXISTENCE: key \"%s\" exists only in registry \"%s\"\n",
+                        U2S(subKeyNames1.getElement(i)), options.getRegName1().getStr());
+            }
+            nError++;
+        } else
+            bFound = sal_False;
+    }
+
+    for (i=0; i<length2; i++)
+    {
+        for (j=0; j<length1; j++)
+        {
+            if ( subKeyNames2.getElement(i) == subKeyNames1.getElement(j) )
+            {
+                bFound = sal_True;
+                keys.insert(subKeyNames2.getElement(i));
+                break;
+            }
+        }
+        if ( !bFound && options.fullCheck() )
+        {
+            if ( options.forceOutput() )
+            {
+                fprintf(stderr, "EXISTENCE: key \"%s\" exists only in registry \"%s\"\n",
+                        U2S(subKeyNames2.getElement(i)), options.getRegName1().getStr());
+            }
+            nError++;
+        } else
+            bFound = sal_False;
+    }
+    return nError;
+}
+
+static sal_uInt32 compareKeys(RegistryKey& key1, RegistryKey& key2)
+{
+    sal_uInt32 nError = 0;
+
+    RegValueType valueType1 = RG_VALUETYPE_NOT_DEFINED;
+    RegValueType valueType2 = RG_VALUETYPE_NOT_DEFINED;
+    sal_uInt32 size1 = 0;
+    sal_uInt32 size2 = 0;
+    OUString tmpName;
+    RegError e1 = key1.getValueInfo(tmpName, &valueType1, &size1);
+    RegError e2 = key2.getValueInfo(tmpName, &valueType2, &size2);
+
+    if ( e1 == e2 && e1 != REG_VALUE_NOT_EXISTS && e1 != REG_INVALID_VALUE )
+    {
+        nError += checkValueDifference(key1, valueType1, size1, key2, valueType2, size2);
+    } else
+    {
+        if ( e1 != REG_INVALID_VALUE || e2 != REG_INVALID_VALUE )
+        {
+            if ( options.forceOutput() )
+            {
+                fprintf(stderr, "VALUES: key values of key \"%s\" are different\n", U2S(key1.getName()));
+            }
+            nError++;
+        }
+    }
+
+    RegistryKeyNames subKeyNames1;
+    RegistryKeyNames subKeyNames2;
+
+    key1.getKeyNames(tmpName, subKeyNames1);
+    key2.getKeyNames(tmpName, subKeyNames2);
+
+    StringSet keys;
+    nError += checkDifferences(keys, subKeyNames1, subKeyNames2);
+
+    StringSet::iterator iter = keys.begin();
+    StringSet::iterator end = keys.end();
+
+    RegistryKey subKey1, subKey2;
+    OUString keyName;
+    while ( iter !=  end )
+    {
+        keyName = OUString(*iter);
+        if ( options.isExcludeKeyValid() &&
+             (keyName == S2U(options.getExcludeKey())) )
+        {
+            iter++;
+            continue;
+        }
+
+        keyName = keyName.getToken(keyName.getTokenCount('/')-1, '/');
+        if ( key1.openKey(keyName, subKey1) )
+        {
+            if ( options.forceOutput() )
+            {
+                fprintf(stderr, "ERROR: could not open key \"%s\" in registry \"%s\"\n",
+                        U2S(*iter), options.getRegName1().getStr());
+            }
+            nError++;
+        }
+        if ( key2.openKey(keyName, subKey2) )
+        {
+            if ( options.forceOutput() )
+            {
+                fprintf(stderr, "ERROR: could not open key \"%s\" in registry \"%s\"\n",
+                        U2S(*iter), options.getRegName2().getStr());
+            }
+            nError++;
+        }
+        if ( subKey1.isValid() && subKey2.isValid() )
+        {
+            nError += compareKeys(subKey1, subKey2);
+        }
+        subKey1.closeKey();
+        subKey2.closeKey();
+        iter++;
+    }
+
+    return nError;
+}
+
+#if (defined UNX) || (defined OS2)
+void main( int argc, char * argv[] )
+#else
+
+void _cdecl main( int argc, char * argv[] )
+#endif
+{
+    if ( !options.initOptions(argc, argv) )
+    {
+        exit(1);
+    }
+
+    OUString regName1( S2U(options.getRegName1()) );
+    OUString regName2( S2U(options.getRegName2()) );
+
+    RegistryLoader regLoader;
+    Registry reg1(regLoader);
+    Registry reg2(regLoader);
+
+    if ( reg1.open(regName1, REG_READONLY) )
+    {
+        fprintf(stderr, "%s: open registry \"%s\" failed\n",
+                options.getProgramName().getStr(), options.getRegName1().getStr());
+        exit(2);
+    }
+    if ( reg2.open(regName2, REG_READONLY) )
+    {
+        fprintf(stderr, "%s: open registry \"%s\" failed\n",
+                options.getProgramName().getStr(), options.getRegName2().getStr());
+        exit(3);
+    }
+
+    RegistryKey key1, key2;
+    if ( reg1.openRootKey(key1) )
+    {
+        fprintf(stderr, "%s: open root key of registry \"%s\" failed\n",
+                options.getProgramName().getStr(), options.getRegName1().getStr());
+        exit(4);
+    }
+    if ( reg2.openRootKey(key2) )
+    {
+        fprintf(stderr, "%s: open root key of registry \"%s\" failed\n",
+                options.getProgramName().getStr(), options.getRegName2().getStr());
+        exit(5);
+    }
+    if ( options.isStartKeyValid() )
+    {
+        if ( options.isExcludeKeyValid() &&
+             (options.getStartKey() == options.getExcludeKey()) )
+        {
+            fprintf(stderr, "%s: start key is equal to exclude key\n",
+                    options.getProgramName().getStr());
+            exit(6);
+        }
+        RegistryKey sk1, sk2;
+        if ( key1.openKey(S2U(options.getStartKey()), sk1) )
+        {
+            fprintf(stderr, "%s: open start key of registry \"%s\" failed\n",
+                    options.getProgramName().getStr(), options.getRegName1().getStr());
+            exit(7);
+        }
+        if ( key2.openKey(S2U(options.getStartKey()), sk2) )
+        {
+            fprintf(stderr, "%s: open start key of registry \"%s\" failed\n",
+                    options.getProgramName().getStr(), options.getRegName2().getStr());
+            exit(8);
+        }
+
+        key1 = sk1;
+        key2 = sk2;
+    }
+
+    sal_uInt32 nError = 0;
+    if ( nError = compareKeys(key1, key2) )
+    {
+        fprintf(stderr, "%s: registries contain %d differences!\n",
+                options.getProgramName().getStr(), nError);
+    } else
+    {
+        fprintf(stderr, "%s: registries are equal!\n",
+                options.getProgramName().getStr());
+    }
+
+    key1.closeKey();
+    key2.closeKey();
+    if ( reg1.close() )
+    {
+        fprintf(stderr, "%s: closing registry \"%s\" failed\n",
+                options.getProgramName().getStr(), options.getRegName1().getStr());
+        exit(9);
+    }
+    if ( reg2.close() )
+    {
+        fprintf(stderr, "%s: closing registry \"%s\" failed\n",
+                options.getProgramName().getStr(), options.getRegName2().getStr());
+        exit(10);
+    }
+
+    if ( nError > 0 )
+        exit(11);
+    else
+        exit(0);
+}
+
+