| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (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.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| // MARKER(update_precomp.py): autogen include statement, do not remove |
| #include "precompiled_registry.hxx" |
| |
| #include "registry/registry.hxx" |
| #include "registry/reader.hxx" |
| #include "registry/version.h" |
| #include "fileurl.hxx" |
| #include "options.hxx" |
| |
| #include <rtl/ustring.hxx> |
| #include <osl/diagnose.h> |
| |
| #include <stdio.h> |
| #include <string.h> |
| |
| #include <set> |
| #include <vector> |
| #include <string> |
| |
| using namespace rtl; |
| using namespace registry::tools; |
| |
| typedef std::set< rtl::OUString > StringSet; |
| |
| class Options_Impl : public Options |
| { |
| public: |
| explicit Options_Impl(char const * program) |
| : Options(program), |
| m_bFullCheck(false), |
| m_bForceOutput(false), |
| m_bUnoTypeCheck(false), |
| m_checkUnpublished(false) |
| {} |
| |
| std::string const & getRegName1() const { return m_regName1; } |
| std::string const & getRegName2() const { return m_regName2; } |
| |
| bool isStartKeyValid() const { return (m_startKey.getLength() > 0); } |
| OUString const & getStartKey() const { return m_startKey; } |
| bool matchedWithExcludeKey( const OUString& keyName) const; |
| |
| bool fullCheck() const { return m_bFullCheck; } |
| bool forceOutput() const { return m_bForceOutput; } |
| bool unoTypeCheck() const { return m_bUnoTypeCheck; } |
| bool checkUnpublished() const { return m_checkUnpublished; } |
| |
| protected: |
| bool setRegName_Impl(char c, std::string const & param); |
| |
| virtual void printUsage_Impl() const; |
| virtual bool initOptions_Impl (std::vector< std::string > & rArgs); |
| |
| std::string m_regName1; |
| std::string m_regName2; |
| OUString m_startKey; |
| StringSet m_excludeKeys; |
| bool m_bFullCheck; |
| bool m_bForceOutput; |
| bool m_bUnoTypeCheck; |
| bool m_checkUnpublished; |
| }; |
| |
| #define U2S( s ) OUStringToOString(s, RTL_TEXTENCODING_UTF8).getStr() |
| |
| inline rtl::OUString makeOUString (std::string const & s) |
| { |
| return rtl::OUString(s.c_str(), s.size(), RTL_TEXTENCODING_UTF8, OSTRING_TO_OUSTRING_CVTFLAGS); |
| } |
| |
| inline rtl::OUString shortName(rtl::OUString const & fullName) |
| { |
| return fullName.copy(fullName.lastIndexOf('/') + 1); |
| } |
| |
| bool Options_Impl::setRegName_Impl(char c, std::string const & param) |
| { |
| bool one = (c == '1'), two = (c == '2'); |
| if (one) |
| m_regName1 = param; |
| if (two) |
| m_regName2 = param; |
| return (one || two); |
| } |
| |
| //virtual |
| void Options_Impl::printUsage_Impl() const |
| { |
| std::string const & rProgName = getProgramName(); |
| fprintf(stderr, |
| "Usage: %s -r1<filename> -r2<filename> [-options] | @<filename>\n", rProgName.c_str() |
| ); |
| fprintf(stderr, |
| " -r1<filename> = filename specifies the name of the first registry.\n" |
| " -r2<filename> = filename specifies the name of the second registry.\n" |
| " @<filename> = filename specifies a command file.\n" |
| "Options:\n" |
| " -s<name> = name specifies the name of a start key. If no start key\n" |
| " |S<name> is specified the comparison starts with the root key.\n" |
| " -x<name> = name specifies the name of a key which won't be compared. All\n" |
| " |X<name> subkeys won't be compared also. This option can be used more than once.\n" |
| " -f|F = force the detailed output of any diffenrences. Default\n" |
| " is that only the number of differences is returned.\n" |
| " -c|C = make a complete check, that means any differences will be\n" |
| " detected. Default is only a compatibility check that means\n" |
| " only UNO typelibrary entries will be checked.\n" |
| " -t|T = make an UNO type compatiblity check. This means that registry 2\n" |
| " will be checked against registry 1. If a interface in r2 contains\n" |
| " more methods or the methods are in a different order as in r1, r2 is\n" |
| " incompatible to r1. But if a service in r2 supports more properties as\n" |
| " in r1 and the new properties are 'optional' it is compatible.\n" |
| " -u|U = additionally check types that are unpublished in registry 1.\n" |
| " -h|-? = print this help message and exit.\n" |
| ); |
| fprintf(stderr, |
| "\n%s Version 1.0\n\n", rProgName.c_str() |
| ); |
| } |
| |
| // virtual |
| bool Options_Impl::initOptions_Impl (std::vector< std::string > & rArgs) |
| { |
| std::vector< std::string >::const_iterator first = rArgs.begin(), last = rArgs.end(); |
| for (; first != last; ++first) |
| { |
| if ((*first)[0] != '-') |
| { |
| return badOption("invalid", (*first).c_str()); |
| } |
| switch ((*first)[1]) |
| { |
| case 'r': |
| case 'R': |
| { |
| if (!((++first != last) && ((*first)[0] != '-'))) |
| { |
| return badOption("invalid", (*first).c_str()); |
| } |
| |
| std::string option(*first), param; |
| if (option.size() == 1) |
| { |
| // "-r<n><space><param>" |
| if (!((++first != last) && ((*first)[0] != '-'))) |
| { |
| return badOption("invalid", (*first).c_str()); |
| } |
| param = (*first); |
| } |
| else |
| { |
| // "-r<n><param>" |
| param = std::string(&(option[1]), option.size() - 1); |
| } |
| if (!setRegName_Impl(option[0], param)) |
| { |
| return badOption("invalid", option.c_str()); |
| } |
| break; |
| } |
| case 's': |
| case 'S': |
| { |
| if (!((++first != last) && ((*first)[0] != '-'))) |
| { |
| return badOption("invalid", (*first).c_str()); |
| } |
| m_startKey = makeOUString(*first); |
| break; |
| } |
| case 'x': |
| case 'X': |
| { |
| if (!((++first != last) && ((*first)[0] != '-'))) |
| { |
| return badOption("invalid", (*first).c_str()); |
| } |
| m_excludeKeys.insert(makeOUString(*first)); |
| break; |
| } |
| case 'f': |
| case 'F': |
| { |
| if ((*first).size() > 2) |
| { |
| return badOption("invalid", (*first).c_str()); |
| } |
| m_bForceOutput = sal_True; |
| break; |
| } |
| case 'c': |
| case 'C': |
| { |
| if ((*first).size() > 2) |
| { |
| return badOption("invalid", (*first).c_str()); |
| } |
| m_bFullCheck = sal_True; |
| break; |
| } |
| case 't': |
| case 'T': |
| { |
| if ((*first).size() > 2) |
| { |
| return badOption("invalid", (*first).c_str()); |
| } |
| m_bUnoTypeCheck = sal_True; |
| break; |
| } |
| case 'u': |
| case 'U': |
| { |
| if ((*first).size() > 2) |
| { |
| return badOption("invalid", (*first).c_str()); |
| } |
| m_checkUnpublished = true; |
| break; |
| } |
| case 'h': |
| case '?': |
| { |
| if ((*first).size() > 2) |
| { |
| return badOption("invalid", (*first).c_str()); |
| } |
| return printUsage(); |
| // break; // Unreachable |
| } |
| default: |
| { |
| return badOption("unknown", (*first).c_str()); |
| // break; // Unreachable |
| } |
| } |
| } |
| |
| if ( m_regName1.size() == 0 ) |
| { |
| return badOption("missing", "-r1"); |
| } |
| if ( m_regName2.size() == 0 ) |
| { |
| return badOption("missing", "-r2"); |
| } |
| return true; |
| } |
| |
| bool Options_Impl::matchedWithExcludeKey( const OUString& keyName) const |
| { |
| if (!m_excludeKeys.empty()) |
| { |
| StringSet::const_iterator first = m_excludeKeys.begin(), last = m_excludeKeys.end(); |
| for (; first != last; ++first) |
| { |
| if (keyName.indexOf(*first) == 0) |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| static char const * 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"; |
| default: |
| 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 char const * 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*"; |
| default: |
| return "NONE"; |
| } |
| } |
| |
| static void printConstValue(RTConstValue& constValue) |
| { |
| switch (constValue.m_type) |
| { |
| case RT_TYPE_NONE: |
| fprintf(stdout, "none"); |
| break; |
| case RT_TYPE_BOOL: |
| fprintf(stdout, "%s", constValue.m_value.aBool ? "TRUE" : "FALSE"); |
| break; |
| case RT_TYPE_BYTE: |
| fprintf(stdout, "%d", constValue.m_value.aByte); |
| break; |
| case RT_TYPE_INT16: |
| fprintf(stdout, "%d", constValue.m_value.aShort); |
| break; |
| case RT_TYPE_UINT16: |
| fprintf(stdout, "%d", constValue.m_value.aUShort); |
| break; |
| case RT_TYPE_INT32: |
| fprintf( |
| stdout, "%ld", |
| sal::static_int_cast< long >(constValue.m_value.aLong)); |
| break; |
| case RT_TYPE_UINT32: |
| fprintf( |
| stdout, "%lu", |
| sal::static_int_cast< unsigned long >( |
| constValue.m_value.aULong)); |
| break; |
| // case RT_TYPE_INT64: |
| // fprintf(stdout, "%d", constValue.m_value.aHyper); |
| // case RT_TYPE_UINT64: |
| // fprintf(stdout, "%d", constValue.m_value.aUHyper); |
| case RT_TYPE_FLOAT: |
| fprintf(stdout, "%f", constValue.m_value.aFloat); |
| break; |
| case RT_TYPE_DOUBLE: |
| fprintf(stdout, "%f", constValue.m_value.aDouble); |
| break; |
| case RT_TYPE_STRING: |
| fprintf( |
| stdout, "%s", |
| (rtl::OUStringToOString( |
| constValue.m_value.aString, RTL_TEXTENCODING_UTF8). |
| getStr())); |
| break; |
| default: |
| break; |
| } |
| } |
| |
| static void dumpTypeClass(sal_Bool & rbDump, RTTypeClass typeClass, OUString const & keyName) |
| { |
| if (rbDump) |
| fprintf(stdout, "%s: %s\n", getTypeClass(typeClass), U2S(keyName)); |
| rbDump = sal_False; |
| } |
| |
| static sal_uInt32 checkConstValue(Options_Impl const & options, |
| const OUString& keyName, |
| RTTypeClass typeClass, |
| sal_Bool & bDump, |
| RTConstValue& constValue1, |
| RTConstValue& constValue2, |
| sal_uInt16 index1) |
| { |
| switch (constValue1.m_type) |
| { |
| case RT_TYPE_INVALID: |
| break; |
| case RT_TYPE_BOOL: |
| if (constValue1.m_value.aBool != constValue2.m_value.aBool) |
| { |
| if ( options.forceOutput() && !options.unoTypeCheck() ) |
| { |
| dumpTypeClass(bDump, typeClass, keyName); |
| fprintf(stdout, " Field %d: Value1 = %s != Value2 = %s\n", index1, |
| 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() && !options.unoTypeCheck() ) |
| { |
| dumpTypeClass(bDump, typeClass, keyName); |
| fprintf(stdout, " Field %d: Value1 = %d != Value2 = %d\n", index1, |
| 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() && !options.unoTypeCheck() ) |
| { |
| dumpTypeClass(bDump, typeClass, keyName); |
| fprintf(stdout, " Field %d: Value1 = %d != Value2 = %d\n", index1, |
| 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() && !options.unoTypeCheck() ) |
| { |
| dumpTypeClass(bDump, typeClass, keyName); |
| fprintf(stdout, " Field %d: Value1 = %d != Value2 = %d\n", index1, |
| 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() && !options.unoTypeCheck() ) |
| { |
| dumpTypeClass(bDump, typeClass, keyName); |
| fprintf(stdout, " Field %d: Value1 = %ld != Value2 = %ld\n", index1, |
| sal::static_int_cast< long >(constValue1.m_value.aLong), |
| sal::static_int_cast< long >(constValue2.m_value.aLong)); |
| } |
| return 1; |
| } |
| break; |
| case RT_TYPE_UINT32: |
| if (constValue1.m_value.aULong != constValue2.m_value.aULong) |
| { |
| if ( options.forceOutput() && !options.unoTypeCheck() ) |
| { |
| dumpTypeClass(bDump, typeClass, keyName); |
| fprintf(stdout, " Field %d: Value1 = %lu != Value2 = %lu\n", index1, |
| sal::static_int_cast< unsigned long >(constValue1.m_value.aULong), |
| sal::static_int_cast< unsigned long >(constValue2.m_value.aULong)); |
| } |
| return 1; |
| } |
| break; |
| case RT_TYPE_INT64: |
| if (constValue1.m_value.aHyper != constValue2.m_value.aHyper) |
| { |
| if ( options.forceOutput() && !options.unoTypeCheck() ) |
| { |
| dumpTypeClass(bDump, typeClass, keyName); |
| fprintf( |
| stdout, " Field %d: Value1 = %s != Value2 = %s\n", |
| index1, |
| rtl::OUStringToOString( |
| rtl::OUString::valueOf(constValue1.m_value.aHyper), |
| RTL_TEXTENCODING_ASCII_US).getStr(), |
| rtl::OUStringToOString( |
| rtl::OUString::valueOf(constValue2.m_value.aHyper), |
| RTL_TEXTENCODING_ASCII_US).getStr()); |
| } |
| return 1; |
| } |
| break; |
| case RT_TYPE_UINT64: |
| if (constValue1.m_value.aUHyper != constValue2.m_value.aUHyper) |
| { |
| if ( options.forceOutput() && !options.unoTypeCheck() ) |
| { |
| dumpTypeClass(bDump, typeClass, keyName); |
| fprintf( |
| stdout, " Field %d: Value1 = %s != Value2 = %s\n", |
| index1, |
| rtl::OUStringToOString( |
| rtl::OUString::valueOf( |
| static_cast< sal_Int64 >( |
| constValue1.m_value.aUHyper)), |
| RTL_TEXTENCODING_ASCII_US).getStr(), |
| rtl::OUStringToOString( |
| rtl::OUString::valueOf( |
| static_cast< sal_Int64 >( |
| constValue2.m_value.aUHyper)), |
| RTL_TEXTENCODING_ASCII_US).getStr()); |
| // printing the unsigned values as signed should be |
| // acceptable... |
| } |
| return 1; |
| } |
| break; |
| case RT_TYPE_FLOAT: |
| if (constValue1.m_value.aFloat != constValue2.m_value.aFloat) |
| { |
| if ( options.forceOutput() && !options.unoTypeCheck() ) |
| { |
| dumpTypeClass(bDump, typeClass, keyName); |
| fprintf(stdout, " Field %d: Value1 = %f != Value2 = %f\n", index1, |
| 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() && !options.unoTypeCheck() ) |
| { |
| dumpTypeClass(bDump, typeClass, keyName); |
| fprintf(stdout, " Field %d: Value1 = %f != Value2 = %f\n", index1, |
| constValue1.m_value.aDouble, constValue2.m_value.aDouble); |
| } |
| return 1; |
| } |
| break; |
| default: |
| OSL_ASSERT(false); |
| break; |
| } |
| return 0; |
| } |
| |
| static sal_uInt32 checkField(Options_Impl const & options, |
| const OUString& keyName, |
| RTTypeClass typeClass, |
| sal_Bool & bDump, |
| typereg::Reader& reader1, |
| typereg::Reader& reader2, |
| sal_uInt16 index1, |
| sal_uInt16 index2) |
| { |
| sal_uInt32 nError = 0; |
| if ( reader1.getFieldName(index1) != reader2.getFieldName(index2) ) |
| { |
| if ( options.forceOutput() && !options.unoTypeCheck() ) |
| { |
| dumpTypeClass (bDump, typeClass, keyName); |
| fprintf(stdout, " Field %d: Name1 = %s != Name2 = %s\n", index1, |
| U2S(reader1.getFieldName(index1)), U2S(reader2.getFieldName(index2))); |
| } |
| nError++; |
| } |
| if ( reader1.getFieldTypeName(index1) != reader2.getFieldTypeName(index2) ) |
| { |
| if ( options.forceOutput() && !options.unoTypeCheck() ) |
| { |
| dumpTypeClass (bDump, typeClass, keyName); |
| fprintf(stdout, " Field %d: Type1 = %s != Type2 = %s\n", index1, |
| U2S(reader1.getFieldTypeName(index1)), U2S(reader2.getFieldTypeName(index2))); |
| } |
| nError++; |
| } |
| else |
| { |
| RTConstValue constValue1 = reader1.getFieldValue(index1); |
| RTConstValue constValue2 = reader2.getFieldValue(index2); |
| if ( constValue1.m_type != constValue2.m_type ) |
| { |
| if ( options.forceOutput() && !options.unoTypeCheck() ) |
| { |
| dumpTypeClass (bDump, typeClass, keyName); |
| fprintf(stdout, " Field %d: Access1 = %s != Access2 = %s\n", index1, |
| getConstValueType(constValue1), getConstValueType(constValue2)); |
| fprintf(stdout, " Field %d: Value1 = ", index1); |
| printConstValue(constValue1); |
| fprintf(stdout, " != Value2 = "); |
| printConstValue(constValue1); |
| fprintf(stdout, "\n;"); |
| } |
| nError++; |
| } |
| else |
| { |
| nError += checkConstValue(options, keyName, typeClass, bDump, constValue1, constValue2, index1); |
| } |
| } |
| |
| if ( reader1.getFieldFlags(index1) != reader2.getFieldFlags(index2) ) |
| { |
| if ( options.forceOutput() && !options.unoTypeCheck() ) |
| { |
| dumpTypeClass (bDump, typeClass, keyName); |
| fprintf(stdout, " Field %d: FieldAccess1 = %s != FieldAccess2 = %s\n", index1, |
| getFieldAccess(reader1.getFieldFlags(index1)).getStr(), |
| getFieldAccess(reader1.getFieldFlags(index2)).getStr()); |
| } |
| nError++; |
| } |
| |
| if ( options.fullCheck() && (reader1.getFieldDocumentation(index1) != reader2.getFieldDocumentation(index2)) ) |
| { |
| if ( options.forceOutput() && !options.unoTypeCheck() ) |
| { |
| dumpTypeClass (bDump, typeClass, keyName); |
| fprintf(stdout, " Field %d: Doku1 = %s\n Doku2 = %s\n", index1, |
| U2S(reader1.getFieldDocumentation(index1)), U2S(reader2.getFieldDocumentation(index2))); |
| } |
| nError++; |
| } |
| return nError; |
| } |
| |
| static char const * 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"; |
| default: |
| return "INVALID"; |
| } |
| } |
| |
| static char const * getParamMode(RTParamMode paramMode) |
| { |
| switch ( paramMode ) |
| { |
| case RT_PARAM_IN: |
| return "IN"; |
| case RT_PARAM_OUT: |
| return "OUT"; |
| case RT_PARAM_INOUT: |
| return "INOUT"; |
| default: |
| return "INVALID"; |
| } |
| } |
| |
| static sal_uInt32 checkMethod(Options_Impl const & options, |
| const OUString& keyName, |
| RTTypeClass typeClass, |
| sal_Bool & bDump, |
| typereg::Reader& reader1, |
| typereg::Reader& reader2, |
| sal_uInt16 index) |
| { |
| sal_uInt32 nError = 0; |
| if ( reader1.getMethodName(index) != reader2.getMethodName(index) ) |
| { |
| if ( options.forceOutput() ) |
| { |
| dumpTypeClass (bDump, typeClass, keyName); |
| fprintf(stdout, " Method1 %d: Name1 = %s != Name2 = %s\n", index, |
| U2S(reader1.getMethodName(index)), |
| U2S(reader2.getMethodName(index))); |
| } |
| nError++; |
| } |
| |
| if ( reader1.getMethodReturnTypeName(index) != reader2.getMethodReturnTypeName(index) ) |
| { |
| if ( options.forceOutput() ) |
| { |
| dumpTypeClass (bDump, typeClass, keyName); |
| fprintf(stdout, " Method1 %d: ReturnType1 = %s != ReturnType2 = %s\n", index, |
| U2S(reader1.getMethodReturnTypeName(index)), |
| U2S(reader2.getMethodReturnTypeName(index))); |
| } |
| nError++; |
| } |
| |
| sal_uInt16 nParams1 = (sal_uInt16)reader1.getMethodParameterCount(index); |
| sal_uInt16 nParams2 = (sal_uInt16)reader2.getMethodParameterCount(index); |
| if ( nParams1 != nParams2 ) |
| { |
| if ( options.forceOutput() ) |
| { |
| dumpTypeClass (bDump, typeClass, keyName); |
| fprintf(stdout, " 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.getMethodParameterTypeName(index, i) != reader2.getMethodParameterTypeName(index, i) ) |
| { |
| if ( options.forceOutput() ) |
| { |
| dumpTypeClass (bDump, typeClass, keyName); |
| fprintf(stdout, " Method %d, Parameter %d: Type1 = %s != Type2 = %s\n", index, i, |
| U2S(reader1.getMethodParameterTypeName(index, i)), |
| U2S(reader2.getMethodParameterTypeName(index, i))); |
| } |
| nError++; |
| } |
| if ( options.fullCheck() && (reader1.getMethodParameterName(index, i) != reader2.getMethodParameterName(index, i)) ) |
| { |
| if ( options.forceOutput() ) |
| { |
| dumpTypeClass (bDump, typeClass, keyName); |
| fprintf(stdout, " Method %d, Parameter %d: Name1 = %s != Name2 = %s\n", index, i, |
| U2S(reader1.getMethodParameterName(index, i)), |
| U2S(reader2.getMethodParameterName(index, i))); |
| } |
| nError++; |
| } |
| if ( reader1.getMethodParameterFlags(index, i) != reader2.getMethodParameterFlags(index, i) ) |
| { |
| if ( options.forceOutput() ) |
| { |
| dumpTypeClass (bDump, typeClass, keyName); |
| fprintf(stdout, " Method %d, Parameter %d: Mode1 = %s != Mode2 = %s\n", index, i, |
| getParamMode(reader1.getMethodParameterFlags(index, i)), |
| getParamMode(reader2.getMethodParameterFlags(index, i))); |
| } |
| nError++; |
| } |
| } |
| if ( i < nParams1 && options.forceOutput() ) |
| { |
| dumpTypeClass (bDump, typeClass, keyName); |
| fprintf(stdout, " Registry1: Method %d contains %d more parameters\n", index, nParams1 - i); |
| } |
| if ( i < nParams2 && options.forceOutput() ) |
| { |
| dumpTypeClass (bDump, typeClass, keyName); |
| fprintf(stdout, " Registry2: Method %d contains %d more parameters\n", index, nParams2 - i); |
| } |
| |
| sal_uInt16 nExcep1 = (sal_uInt16)reader1.getMethodExceptionCount(index); |
| sal_uInt16 nExcep2 = (sal_uInt16)reader2.getMethodExceptionCount(index); |
| if ( nExcep1 != nExcep2 ) |
| { |
| if ( options.forceOutput() ) |
| { |
| dumpTypeClass (bDump, typeClass, keyName); |
| fprintf(stdout, " nExceptions1 = %d != nExceptions2 = %d\n", nExcep1, nExcep2); |
| } |
| nError++; |
| } |
| for (i=0; i < nExcep1 && i < nExcep2; i++) |
| { |
| if ( reader1.getMethodExceptionTypeName(index, i) != reader2.getMethodExceptionTypeName(index, i) ) |
| { |
| if ( options.forceOutput() ) |
| { |
| dumpTypeClass (bDump, typeClass, keyName); |
| fprintf(stdout, " Method %d, Exception %d: Name1 = %s != Name2 = %s\n", index, i, |
| U2S(reader1.getMethodExceptionTypeName(index, i)), |
| U2S(reader2.getMethodExceptionTypeName(index, i))); |
| } |
| nError++; |
| } |
| } |
| if ( i < nExcep1 && options.forceOutput() ) |
| { |
| dumpTypeClass (bDump, typeClass, keyName); |
| fprintf(stdout, " Registry1: Method %d contains %d more exceptions\n", index, nExcep1 - i); |
| } |
| if ( i < nExcep2 && options.forceOutput() ) |
| { |
| dumpTypeClass (bDump, typeClass, keyName); |
| fprintf(stdout, " Registry2: Method %d contains %d more exceptions\n", index, nExcep2 - i); |
| } |
| |
| if ( reader1.getMethodFlags(index) != reader2.getMethodFlags(index) ) |
| { |
| if ( options.forceOutput() ) |
| { |
| dumpTypeClass (bDump, typeClass, keyName); |
| fprintf(stdout, " Method %d: Mode1 = %s != Mode2 = %s\n", index, |
| getMethodMode(reader1.getMethodFlags(index)), |
| getMethodMode(reader2.getMethodFlags(index))); |
| } |
| nError++; |
| } |
| |
| if ( options.fullCheck() && (reader1.getMethodDocumentation(index) != reader2.getMethodDocumentation(index)) ) |
| { |
| if ( options.forceOutput() ) |
| { |
| dumpTypeClass (bDump, typeClass, keyName); |
| fprintf(stdout, " Method %d: Doku1 = %s\n Doku2 = %s\n", index, |
| U2S(reader1.getMethodDocumentation(index)), |
| U2S(reader2.getMethodDocumentation(index))); |
| } |
| nError++; |
| } |
| return nError; |
| } |
| |
| static char const * 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"; |
| default: |
| return "RT_REF_INVALID"; |
| } |
| } |
| |
| static sal_uInt32 checkReference(Options_Impl const & options, |
| const OUString& keyName, |
| RTTypeClass typeClass, |
| sal_Bool & bDump, |
| typereg::Reader& reader1, |
| typereg::Reader& reader2, |
| sal_uInt16 index1, |
| sal_uInt16 index2) |
| { |
| sal_uInt32 nError = 0; |
| if ( reader1.getReferenceTypeName(index1) != reader2.getReferenceTypeName(index2) ) |
| { |
| if ( options.forceOutput() && !options.unoTypeCheck() ) |
| { |
| dumpTypeClass (bDump, typeClass, keyName); |
| fprintf(stdout, " Reference %d: Name1 = %s != Name2 = %s\n", index1, |
| U2S(reader1.getReferenceTypeName(index1)), |
| U2S(reader2.getReferenceTypeName(index2))); |
| } |
| nError++; |
| } |
| if ( reader1.getReferenceTypeName(index1) != reader2.getReferenceTypeName(index2) ) |
| { |
| if ( options.forceOutput() && !options.unoTypeCheck() ) |
| { |
| dumpTypeClass (bDump, typeClass, keyName); |
| fprintf(stdout, " Reference %d: Type1 = %s != Type2 = %s\n", index1, |
| getReferenceType(reader1.getReferenceSort(index1)), |
| getReferenceType(reader2.getReferenceSort(index2))); |
| } |
| nError++; |
| } |
| if ( options.fullCheck() && (reader1.getReferenceDocumentation(index1) != reader2.getReferenceDocumentation(index2)) ) |
| { |
| if ( options.forceOutput() && !options.unoTypeCheck() ) |
| { |
| dumpTypeClass (bDump, typeClass, keyName); |
| fprintf(stdout, " Reference %d: Doku1 = %s\n Doku2 = %s\n", index1, |
| U2S(reader1.getReferenceDocumentation(index1)), |
| U2S(reader2.getReferenceDocumentation(index2))); |
| } |
| nError++; |
| } |
| if ( reader1.getReferenceFlags(index1) != reader2.getReferenceFlags(index2) ) |
| { |
| if ( options.forceOutput() && !options.unoTypeCheck() ) |
| { |
| dumpTypeClass (bDump, typeClass, keyName); |
| fprintf(stdout, " Reference %d: Access1 = %s != Access2 = %s\n", index1, |
| getFieldAccess(reader1.getReferenceFlags(index1)).getStr(), |
| getFieldAccess(reader1.getReferenceFlags(index2)).getStr()); |
| } |
| nError++; |
| } |
| return nError; |
| } |
| |
| static sal_uInt32 checkFieldsWithoutOrder(Options_Impl const & options, |
| const OUString& keyName, |
| RTTypeClass typeClass, |
| sal_Bool & bDump, |
| typereg::Reader& reader1, |
| typereg::Reader& reader2) |
| { |
| sal_uInt32 nError = 0; |
| |
| sal_uInt16 nFields1 = (sal_uInt16)reader1.getFieldCount(); |
| sal_uInt16 nFields2 = (sal_uInt16)reader2.getFieldCount(); |
| sal_uInt16 i=0, j=0; |
| |
| if ( nFields1 > nFields2 ) |
| { |
| if ( options.forceOutput() ) |
| { |
| dumpTypeClass (bDump, typeClass, keyName); |
| fprintf(stdout, " %s1 contains %d more properties as %s2\n", |
| getTypeClass(typeClass), nFields1-nFields2, getTypeClass(typeClass)); |
| } |
| } |
| |
| sal_Bool bFound = sal_False; |
| ::std::set< sal_uInt16 > moreProps; |
| |
| for (i=0; i < nFields1; i++) |
| { |
| for (j=0; j < nFields2; j++) |
| { |
| if (!checkField(options, keyName, typeClass, bDump, reader1, reader2, i, j)) |
| { |
| bFound = sal_True; |
| moreProps.insert(j); |
| break; |
| } |
| } |
| if (!bFound) |
| { |
| if (options.forceOutput()) |
| { |
| dumpTypeClass (bDump, typeClass, keyName); |
| fprintf(stdout, " incompatible change: Field %d ('%s') of r1 is not longer a property of this %s in r2\n", |
| i, U2S(shortName(reader1.getFieldName(i))), getTypeClass(typeClass)); |
| } |
| nError++; |
| } |
| else |
| { |
| bFound = sal_False; |
| } |
| } |
| |
| if ( typeClass == RT_TYPE_SERVICE && !moreProps.empty() ) |
| { |
| for (j=0; j < nFields2; j++) |
| { |
| if ( moreProps.find(j) == moreProps.end() ) |
| { |
| if ( (reader2.getFieldFlags(j) & RT_ACCESS_OPTIONAL) != RT_ACCESS_OPTIONAL ) |
| { |
| if ( options.forceOutput() ) |
| { |
| dumpTypeClass (bDump, typeClass, keyName); |
| fprintf(stdout, |
| " incompatible change: Field %d ('%s') of r2 is a new property" |
| " compared to this %s in r1 and is not 'optional'\n", |
| j, U2S(shortName(reader2.getFieldName(j))), getTypeClass(typeClass)); |
| } |
| nError++; |
| } |
| } |
| } |
| } |
| |
| return nError; |
| } |
| |
| static sal_uInt32 checkBlob( |
| Options_Impl const & options, |
| const OUString& keyName, |
| typereg::Reader& reader1, sal_uInt32 size1, |
| typereg::Reader& reader2, sal_uInt32 size2) |
| { |
| sal_uInt32 nError = 0; |
| sal_Bool bDump = sal_True; |
| |
| if ( options.fullCheck() && (size1 != size2) ) |
| { |
| if ( options.forceOutput() ) |
| { |
| fprintf( |
| stdout, " Size1 = %lu Size2 = %lu\n", |
| sal::static_int_cast< unsigned long >(size1), |
| sal::static_int_cast< unsigned long >(size2)); |
| } |
| } |
| if (reader1.isPublished()) |
| { |
| if (!reader2.isPublished()) |
| { |
| if (options.forceOutput()) |
| { |
| dumpTypeClass(bDump, /*"?"*/ reader1.getTypeClass(), keyName); |
| fprintf(stdout, " published in 1 but unpublished in 2\n"); |
| } |
| ++nError; |
| } |
| } |
| else if (!options.checkUnpublished()) |
| { |
| return nError; |
| } |
| if ( reader1.getTypeClass() != reader2.getTypeClass() ) |
| { |
| if ( options.forceOutput() ) |
| { |
| dumpTypeClass(bDump, /*"?"*/ reader1.getTypeClass(), keyName); |
| fprintf(stdout, " 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() ) |
| { |
| dumpTypeClass(bDump, typeClass, keyName); |
| fprintf(stdout, " 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) ) |
| { |
| if (reader1.getSuperTypeCount() != reader2.getSuperTypeCount()) |
| { |
| dumpTypeClass(bDump, typeClass, keyName); |
| fprintf( |
| stdout, " SuperTypeCount1 = %d != SuperTypeCount2 = %d\n", |
| static_cast< int >(reader1.getSuperTypeCount()), |
| static_cast< int >(reader2.getSuperTypeCount())); |
| ++nError; |
| } else |
| { |
| for (sal_Int16 i = 0; i < reader1.getSuperTypeCount(); ++i) |
| { |
| if (reader1.getSuperTypeName(i) != reader2.getSuperTypeName(i)) |
| { |
| if ( options.forceOutput() ) |
| { |
| dumpTypeClass(bDump, typeClass, keyName); |
| fprintf(stdout, " SuperTypeName1 = %s != SuperTypeName2 = %s\n", |
| U2S(reader1.getSuperTypeName(i)), U2S(reader2.getSuperTypeName(i))); |
| } |
| nError++; |
| } |
| } |
| } |
| } |
| |
| sal_uInt16 nFields1 = (sal_uInt16)reader1.getFieldCount(); |
| sal_uInt16 nFields2 = (sal_uInt16)reader2.getFieldCount(); |
| sal_Bool bCheckNormal = sal_True; |
| |
| if ( (typeClass == RT_TYPE_SERVICE || |
| typeClass == RT_TYPE_MODULE || |
| typeClass == RT_TYPE_CONSTANTS) && options.unoTypeCheck() ) |
| { |
| bCheckNormal = sal_False; |
| } |
| |
| if ( bCheckNormal ) |
| { |
| if ( nFields1 != nFields2 ) |
| { |
| if ( options.forceOutput() ) |
| { |
| dumpTypeClass(bDump, typeClass, keyName); |
| fprintf(stdout, " nFields1 = %d != nFields2 = %d\n", nFields1, nFields2); |
| } |
| nError++; |
| } |
| |
| sal_uInt16 i; |
| for (i=0; i < nFields1 && i < nFields2; i++) |
| { |
| nError += checkField(options, keyName, typeClass, bDump, reader1, reader2, i, i); |
| } |
| if ( i < nFields1 && options.forceOutput() ) |
| { |
| dumpTypeClass(bDump, typeClass, keyName); |
| fprintf(stdout, " Registry1 contains %d more fields\n", nFields1 - i); |
| } |
| if ( i < nFields2 && options.forceOutput() ) |
| { |
| dumpTypeClass(bDump, typeClass, keyName); |
| fprintf(stdout, " Registry2 contains %d more fields\n", nFields2 - i); |
| } |
| } |
| else |
| { |
| nError += checkFieldsWithoutOrder(options, keyName, typeClass, bDump, reader1, reader2); |
| } |
| |
| 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() ) |
| { |
| dumpTypeClass(bDump, typeClass, keyName); |
| fprintf(stdout, " nMethods1 = %d != nMethods2 = %d\n", nMethods1, nMethods2); |
| } |
| nError++; |
| } |
| |
| sal_uInt16 i; |
| for (i=0; i < nMethods1 && i < nMethods2; i++) |
| { |
| nError += checkMethod(options, keyName, typeClass, bDump, reader1, reader2, i); |
| } |
| if ( i < nMethods1 && options.forceOutput() ) |
| { |
| fprintf(stdout, " Registry1 contains %d more methods\n", nMethods1 - i); |
| } |
| if ( i < nMethods2 && options.forceOutput() ) |
| { |
| fprintf(stdout, " 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 ( !bCheckNormal ) |
| { |
| sal_uInt16 i=0, j=0; |
| |
| if ( nReference1 > nReference2 ) |
| { |
| if ( options.forceOutput() ) |
| { |
| dumpTypeClass(bDump, typeClass, keyName); |
| fprintf(stdout, " service1 contains %d more references as service2\n", |
| nReference1-nReference2); |
| } |
| } |
| |
| sal_Bool bFound = sal_False; |
| ::std::set< sal_uInt16 > moreReferences; |
| |
| for (i=0; i < nReference1; i++) |
| { |
| for (j=0; j < nReference2; j++) |
| { |
| if (!checkReference(options, keyName, typeClass, bDump, reader1, reader2, i, j)) |
| { |
| bFound = sal_True; |
| moreReferences.insert(j); |
| break; |
| } |
| } |
| if (!bFound) |
| { |
| if (options.forceOutput()) |
| { |
| dumpTypeClass(bDump, typeClass, keyName); |
| fprintf(stdout, |
| " incompatible change: Reference %d ('%s') in 'r1' is not longer a reference" |
| " of this service in 'r2'\n", |
| i, U2S(shortName(reader1.getReferenceTypeName(i)))); |
| } |
| nError++; |
| } |
| else |
| { |
| bFound = sal_False; |
| } |
| } |
| |
| if ( !moreReferences.empty() ) |
| { |
| for (j=0; j < nReference2; j++) |
| { |
| if ( moreReferences.find(j) == moreReferences.end() ) |
| { |
| if ( (reader2.getReferenceFlags(j) & RT_ACCESS_OPTIONAL) != RT_ACCESS_OPTIONAL ) |
| { |
| if ( options.forceOutput() ) |
| { |
| dumpTypeClass(bDump, typeClass, keyName); |
| fprintf(stdout, |
| " incompatible change: Reference %d ('%s') of r2 is a new reference" |
| " compared to this service in r1 and is not 'optional'\n", |
| j, U2S(shortName(reader2.getReferenceTypeName(j)))); |
| } |
| nError++; |
| } |
| } |
| } |
| } |
| } |
| else |
| { |
| if ( nReference1 != nReference2 ) |
| { |
| if ( options.forceOutput() ) |
| { |
| dumpTypeClass(bDump, typeClass, keyName); |
| fprintf(stdout, " nReferences1 = %d != nReferences2 = %d\n", nReference1, nReference2); |
| } |
| nError++; |
| } |
| |
| sal_uInt16 i; |
| for (i=0; i < nReference1 && i < nReference2; i++) |
| { |
| nError += checkReference(options, keyName, typeClass, bDump, reader1, reader2, i, i); |
| } |
| if ( i < nReference1 && options.forceOutput() ) |
| { |
| fprintf(stdout, " Registry1 contains %d more references\n", nReference1 - i); |
| } |
| if ( i < nReference2 && options.forceOutput() ) |
| { |
| fprintf(stdout, " Registry2 contains %d more references\n", nReference2 - i); |
| } |
| } |
| } |
| |
| if ( options.fullCheck() && (reader1.getDocumentation() != reader2.getDocumentation()) ) |
| { |
| if ( options.forceOutput() ) |
| { |
| dumpTypeClass(bDump, typeClass, keyName); |
| fprintf(stdout, " Doku1 = %s\n Doku2 = %s\n", |
| U2S(reader1.getDocumentation()), U2S(reader2.getDocumentation())); |
| } |
| nError++; |
| } |
| return nError; |
| } |
| |
| static sal_uInt32 checkValueDifference( |
| Options_Impl const & options, |
| 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; |
| 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; |
| default: |
| break; |
| } |
| |
| if ( bEqual) |
| { |
| std::vector< sal_uInt8 > value1(size1); |
| key1.getValue(tmpName, &value1[0]); |
| |
| std::vector< sal_uInt8 > value2(size2); |
| key2.getValue(tmpName, &value2[0]); |
| |
| bEqual = (rtl_compareMemory(&value1[0], &value2[0], value1.size()) == 0 ); |
| if ( !bEqual && valueType1 == RG_VALUETYPE_BINARY && valueType2 == RG_VALUETYPE_BINARY ) |
| { |
| typereg::Reader reader1(&value1[0], value1.size(), false, TYPEREG_VERSION_1); |
| typereg::Reader reader2(&value2[0], value2.size(), false, TYPEREG_VERSION_1); |
| if ( reader1.isValid() && reader2.isValid() ) |
| { |
| return checkBlob(options, key1.getName(), reader1, size1, reader2, size2); |
| } |
| } |
| if ( bEqual ) |
| { |
| return 0; |
| } |
| else |
| { |
| if ( options.forceOutput() ) |
| { |
| fprintf(stdout, "Difference: key values of key \"%s\" are different\n", U2S(key1.getName())); |
| } |
| nError++; |
| } |
| } |
| } |
| |
| if ( options.forceOutput() ) |
| { |
| switch (valueType1) |
| { |
| case RG_VALUETYPE_NOT_DEFINED: |
| fprintf(stdout, " Registry 1: key has no value\n"); |
| break; |
| case RG_VALUETYPE_LONG: |
| { |
| std::vector< sal_uInt8 > value1(size1); |
| key1.getValue(tmpName, &value1[0]); |
| |
| fprintf(stdout, " Registry 1: Value: Type = RG_VALUETYPE_LONG\n"); |
| fprintf( |
| stdout, " Size = %lu\n", |
| sal::static_int_cast< unsigned long >(size1)); |
| fprintf(stdout, " Data = %p\n", &value1[0]); |
| } |
| break; |
| case RG_VALUETYPE_STRING: |
| { |
| std::vector< sal_uInt8 > value1(size1); |
| key1.getValue(tmpName, &value1[0]); |
| |
| fprintf(stdout, " Registry 1: Value: Type = RG_VALUETYPE_STRING\n"); |
| fprintf( |
| stdout, " Size = %lu\n", |
| sal::static_int_cast< unsigned long >(size1)); |
| fprintf(stdout, " Data = \"%s\"\n", reinterpret_cast<char const*>(&value1[0])); |
| } |
| break; |
| case RG_VALUETYPE_UNICODE: |
| { |
| std::vector< sal_uInt8 > value1(size1); |
| key1.getValue(tmpName, &value1[0]); |
| |
| OUString uStrValue(reinterpret_cast<sal_Unicode const*>(&value1[0])); |
| fprintf(stdout, " Registry 1: Value: Type = RG_VALUETYPE_UNICODE\n"); |
| fprintf( |
| stdout, " Size = %lu\n", |
| sal::static_int_cast< unsigned long >(size1)); |
| fprintf(stdout, " Data = \"%s\"\n", U2S(uStrValue)); |
| } |
| break; |
| case RG_VALUETYPE_BINARY: |
| fprintf(stdout, " Registry 1: Value: Type = RG_VALUETYPE_BINARY\n"); |
| break; |
| case RG_VALUETYPE_LONGLIST: |
| { |
| RegistryValueList<sal_Int32> valueList; |
| key1.getLongListValue(tmpName, valueList); |
| fprintf(stdout, " Registry 1: Value: Type = RG_VALUETYPE_LONGLIST\n"); |
| fprintf( |
| stdout, " Size = %lu\n", |
| sal::static_int_cast< unsigned long >(size1)); |
| sal_uInt32 length = valueList.getLength(); |
| for (sal_uInt32 i=0; i<length; i++) |
| { |
| fprintf( |
| stdout, " Data[%lu] = %ld\n", |
| sal::static_int_cast< unsigned long >(i), |
| sal::static_int_cast< long >(valueList.getElement(i))); |
| } |
| } |
| break; |
| case RG_VALUETYPE_STRINGLIST: |
| { |
| RegistryValueList<sal_Char*> valueList; |
| key1.getStringListValue(tmpName, valueList); |
| fprintf(stdout, " Registry 1: Value: Type = RG_VALUETYPE_STRINGLIST\n"); |
| fprintf( |
| stdout, " Size = %lu\n", |
| sal::static_int_cast< unsigned long >(size1)); |
| sal_uInt32 length = valueList.getLength(); |
| for (sal_uInt32 i=0; i<length; i++) |
| { |
| fprintf( |
| stdout, " Data[%lu] = \"%s\"\n", |
| sal::static_int_cast< unsigned long >(i), |
| valueList.getElement(i)); |
| } |
| } |
| break; |
| case RG_VALUETYPE_UNICODELIST: |
| { |
| RegistryValueList<sal_Unicode*> valueList; |
| key1.getUnicodeListValue(tmpName, valueList); |
| fprintf(stdout, " Registry 1: Value: Type = RG_VALUETYPE_UNICODELIST\n"); |
| fprintf( |
| stdout, " Size = %lu\n", |
| sal::static_int_cast< unsigned long >(size1)); |
| sal_uInt32 length = valueList.getLength(); |
| OUString uStrValue; |
| for (sal_uInt32 i=0; i<length; i++) |
| { |
| uStrValue = OUString(valueList.getElement(i)); |
| fprintf( |
| stdout, " Data[%lu] = \"%s\"\n", |
| sal::static_int_cast< unsigned long >(i), U2S(uStrValue)); |
| } |
| } |
| break; |
| } |
| |
| switch (valueType2) |
| { |
| case RG_VALUETYPE_NOT_DEFINED: |
| fprintf(stdout, " Registry 2: key has no value\n"); |
| break; |
| case RG_VALUETYPE_LONG: |
| { |
| std::vector< sal_uInt8 > value2(size2); |
| key2.getValue(tmpName, &value2[0]); |
| |
| fprintf(stdout, " Registry 2: Value: Type = RG_VALUETYPE_LONG\n"); |
| fprintf( |
| stdout, " Size = %lu\n", |
| sal::static_int_cast< unsigned long >(size2)); |
| fprintf(stdout, " Data = %p\n", &value2[0]); |
| } |
| break; |
| case RG_VALUETYPE_STRING: |
| { |
| std::vector< sal_uInt8 > value2(size2); |
| key2.getValue(tmpName, &value2[0]); |
| |
| fprintf(stdout, " Registry 2: Value: Type = RG_VALUETYPE_STRING\n"); |
| fprintf( |
| stdout, " Size = %lu\n", |
| sal::static_int_cast< unsigned long >(size2)); |
| fprintf(stdout, " Data = \"%s\"\n", reinterpret_cast<char const*>(&value2[0])); |
| } |
| break; |
| case RG_VALUETYPE_UNICODE: |
| { |
| std::vector< sal_uInt8 > value2(size2); |
| key2.getValue(tmpName, &value2[0]); |
| |
| OUString uStrValue(reinterpret_cast<sal_Unicode const*>(&value2[0])); |
| fprintf(stdout, " Registry 2: Value: Type = RG_VALUETYPE_UNICODE\n"); |
| fprintf( |
| stdout, " Size = %lu\n", |
| sal::static_int_cast< unsigned long >(size2)); |
| fprintf(stdout, " Data = \"%s\"\n", U2S(uStrValue)); |
| } |
| break; |
| case RG_VALUETYPE_BINARY: |
| fprintf(stdout, " Registry 2: Value: Type = RG_VALUETYPE_BINARY\n"); |
| break; |
| case RG_VALUETYPE_LONGLIST: |
| { |
| RegistryValueList<sal_Int32> valueList; |
| key2.getLongListValue(tmpName, valueList); |
| fprintf(stdout, " Registry 2: Value: Type = RG_VALUETYPE_LONGLIST\n"); |
| fprintf( |
| stdout, " Size = %lu\n", |
| sal::static_int_cast< unsigned long >(size2)); |
| sal_uInt32 length = valueList.getLength(); |
| for (sal_uInt32 i=0; i<length; i++) |
| { |
| fprintf( |
| stdout, " Data[%lu] = %ld\n", |
| sal::static_int_cast< unsigned long >(i), |
| sal::static_int_cast< long >(valueList.getElement(i))); |
| } |
| } |
| break; |
| case RG_VALUETYPE_STRINGLIST: |
| { |
| RegistryValueList<sal_Char*> valueList; |
| key2.getStringListValue(tmpName, valueList); |
| fprintf(stdout, " Registry 2: Value: Type = RG_VALUETYPE_STRINGLIST\n"); |
| fprintf( |
| stdout, " Size = %lu\n", |
| sal::static_int_cast< unsigned long >(size2)); |
| sal_uInt32 length = valueList.getLength(); |
| for (sal_uInt32 i=0; i<length; i++) |
| { |
| fprintf( |
| stdout, " Data[%lu] = \"%s\"\n", |
| sal::static_int_cast< unsigned long >(i), |
| valueList.getElement(i)); |
| } |
| } |
| break; |
| case RG_VALUETYPE_UNICODELIST: |
| { |
| RegistryValueList<sal_Unicode*> valueList; |
| key2.getUnicodeListValue(tmpName, valueList); |
| fprintf(stdout, " Registry 2: Value: Type = RG_VALUETYPE_UNICODELIST\n"); |
| fprintf( |
| stdout, " Size = %lu\n", |
| sal::static_int_cast< unsigned long >(size2)); |
| sal_uInt32 length = valueList.getLength(); |
| OUString uStrValue; |
| for (sal_uInt32 i=0; i<length; i++) |
| { |
| uStrValue = OUString(valueList.getElement(i)); |
| fprintf( |
| stdout, " Data[%lu] = \"%s\"\n", |
| sal::static_int_cast< unsigned long >(i), U2S(uStrValue)); |
| } |
| } |
| break; |
| } |
| } |
| return nError; |
| } |
| |
| static bool hasPublishedChildren(Options_Impl const & options, RegistryKey & key) |
| { |
| RegistryKeyNames subKeyNames; |
| key.getKeyNames(rtl::OUString(), subKeyNames); |
| for (sal_uInt32 i = 0; i < subKeyNames.getLength(); ++i) |
| { |
| rtl::OUString keyName(subKeyNames.getElement(i)); |
| if (!options.matchedWithExcludeKey(keyName)) |
| { |
| keyName = keyName.copy(keyName.lastIndexOf('/') + 1); |
| RegistryKey subKey; |
| if (!key.openKey(keyName, subKey)) |
| { |
| if (options.forceOutput()) |
| { |
| fprintf( |
| stdout, |
| ("WARNING: could not open key \"%s\" in registry" |
| " \"%s\"\n"), |
| U2S(subKeyNames.getElement(i)), |
| options.getRegName1().c_str()); |
| } |
| } |
| if (subKey.isValid()) |
| { |
| RegValueType type; |
| sal_uInt32 size; |
| if (subKey.getValueInfo(rtl::OUString(), &type, &size) != REG_NO_ERROR) |
| { |
| if (options.forceOutput()) |
| { |
| fprintf( |
| stdout, |
| ("WARNING: could not read key \"%s\" in registry" |
| " \"%s\"\n"), |
| U2S(subKeyNames.getElement(i)), |
| options.getRegName1().c_str()); |
| } |
| } |
| else if (type == RG_VALUETYPE_BINARY) |
| { |
| bool published = false; |
| std::vector< sal_uInt8 > value(size); |
| if (subKey.getValue(rtl::OUString(), &value[0]) != REG_NO_ERROR) |
| { |
| if (options.forceOutput()) |
| { |
| fprintf( |
| stdout, |
| ("WARNING: could not read key \"%s\" in" |
| " registry \"%s\"\n"), |
| U2S(subKeyNames.getElement(i)), |
| options.getRegName1().c_str()); |
| } |
| } |
| else |
| { |
| published = typereg::Reader(&value[0], value.size(), false, TYPEREG_VERSION_1).isPublished(); |
| } |
| if (published) |
| { |
| return true; |
| } |
| } |
| } |
| } |
| } |
| return false; |
| } |
| |
| static sal_uInt32 checkDifferences( |
| Options_Impl const & options, |
| RegistryKey& key, StringSet& keys, |
| RegistryKeyNames& subKeyNames1, |
| RegistryKeyNames& subKeyNames2) |
| { |
| sal_uInt32 nError = 0; |
| sal_uInt32 length1 = subKeyNames1.getLength(); |
| sal_uInt32 length2 = subKeyNames2.getLength(); |
| sal_uInt32 i,j; |
| |
| for (i=0; i<length1; i++) |
| { |
| sal_Bool bFound = sal_False; |
| for (j=0; j<length2; j++) |
| { |
| if ( subKeyNames1.getElement(i) == subKeyNames2.getElement(j) ) |
| { |
| bFound = sal_True; |
| keys.insert(subKeyNames1.getElement(i)); |
| break; |
| } |
| } |
| if ( !bFound ) |
| { |
| if ( options.fullCheck() ) |
| { |
| if ( options.forceOutput() ) |
| { |
| fprintf(stdout, "EXISTENCE: key \"%s\" exists only in registry \"%s\"\n", |
| U2S(subKeyNames1.getElement(i)), options.getRegName1().c_str()); |
| } |
| nError++; |
| } |
| else |
| { |
| rtl::OUString keyName(subKeyNames1.getElement(i)); |
| if (!options.matchedWithExcludeKey(keyName)) |
| { |
| keyName = keyName.copy(keyName.lastIndexOf('/') + 1); |
| RegistryKey subKey; |
| if (key.openKey(keyName, subKey)) |
| { |
| if (options.forceOutput()) |
| { |
| fprintf( |
| stdout, |
| ("ERROR: could not open key \"%s\" in registry" |
| " \"%s\"\n"), |
| U2S(subKeyNames1.getElement(i)), |
| options.getRegName1().c_str()); |
| } |
| ++nError; |
| } |
| if (subKey.isValid()) |
| { |
| RegValueType type; |
| sal_uInt32 size; |
| if (subKey.getValueInfo(rtl::OUString(), &type, &size) != REG_NO_ERROR) |
| { |
| if (options.forceOutput()) |
| { |
| fprintf( |
| stdout, |
| ("ERROR: could not read key \"%s\" in" |
| " registry \"%s\"\n"), |
| U2S(subKeyNames1.getElement(i)), |
| options.getRegName1().c_str()); |
| } |
| ++nError; |
| } |
| else if (type == RG_VALUETYPE_BINARY) |
| { |
| std::vector< sal_uInt8 > value(size); |
| if (subKey.getValue(rtl::OUString(), &value[0]) != REG_NO_ERROR) |
| { |
| if (options.forceOutput()) |
| { |
| fprintf( |
| stdout, |
| ("ERROR: could not read key \"%s\" in" |
| " registry \"%s\"\n"), |
| U2S(subKeyNames1.getElement(i)), |
| options.getRegName1().c_str()); |
| } |
| ++nError; |
| } |
| else |
| { |
| typereg::Reader reader(&value[0], value.size(), false, TYPEREG_VERSION_1); |
| if (reader.getTypeClass() == RT_TYPE_MODULE) |
| { |
| if (options.checkUnpublished() || hasPublishedChildren(options, subKey)) |
| { |
| if (options.forceOutput()) |
| { |
| fprintf( |
| stdout, |
| ("EXISTENCE: module \"%s\"" |
| " %sexists only in registry" |
| " 1\n"), |
| U2S(subKeyNames1.getElement(i)), |
| (options.checkUnpublished() |
| ? "" |
| : "with published children ")); |
| } |
| ++nError; |
| } |
| } |
| else if (options.checkUnpublished() || reader.isPublished()) |
| { |
| if (options.forceOutput()) |
| { |
| fprintf( |
| stdout, |
| ("EXISTENCE: %spublished key \"%s\"" |
| " exists only in registry 1\n"), |
| reader.isPublished() ? "" : "un", |
| U2S(subKeyNames1.getElement(i))); |
| } |
| ++nError; |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| for (i=0; i<length2; i++) |
| { |
| sal_Bool bFound = sal_False; |
| 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(stdout, "EXISTENCE: key \"%s\" exists only in registry \"%s\"\n", |
| U2S(subKeyNames2.getElement(i)), options.getRegName2().c_str()); |
| } |
| nError++; |
| } |
| } |
| return nError; |
| } |
| |
| static sal_uInt32 compareKeys( |
| Options_Impl const & options, |
| 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(options, key1, valueType1, size1, key2, valueType2, size2); |
| } |
| else |
| { |
| if ( (e1 != REG_INVALID_VALUE) || (e2 != REG_INVALID_VALUE) ) |
| { |
| if ( options.forceOutput() ) |
| { |
| fprintf(stdout, "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(options, key1, keys, subKeyNames1, subKeyNames2); |
| |
| StringSet::iterator iter = keys.begin(); |
| StringSet::iterator end = keys.end(); |
| |
| while ( iter != end ) |
| { |
| OUString keyName(*iter); |
| if ( options.matchedWithExcludeKey(keyName) ) |
| { |
| ++iter; |
| continue; |
| } |
| |
| sal_Int32 nPos = keyName.lastIndexOf( '/' ); |
| keyName = keyName.copy( nPos != -1 ? nPos+1 : 0 ); |
| |
| RegistryKey subKey1; |
| if ( key1.openKey(keyName, subKey1) ) |
| { |
| if ( options.forceOutput() ) |
| { |
| fprintf(stdout, "ERROR: could not open key \"%s\" in registry \"%s\"\n", |
| U2S(*iter), options.getRegName1().c_str()); |
| } |
| nError++; |
| } |
| |
| RegistryKey subKey2; |
| if ( key2.openKey(keyName, subKey2) ) |
| { |
| if ( options.forceOutput() ) |
| { |
| fprintf(stdout, "ERROR: could not open key \"%s\" in registry \"%s\"\n", |
| U2S(*iter), options.getRegName2().c_str()); |
| } |
| nError++; |
| } |
| |
| if ( subKey1.isValid() && subKey2.isValid() ) |
| { |
| nError += compareKeys(options, subKey1, subKey2); |
| } |
| ++iter; |
| } |
| |
| return nError; |
| } |
| |
| #if (defined UNX) || (defined OS2) || defined __MINGW32__ |
| int main( int argc, char * argv[] ) |
| #else |
| int _cdecl main( int argc, char * argv[] ) |
| #endif |
| { |
| std::vector< std::string > args; |
| |
| Options_Impl options(argv[0]); |
| for (int i = 1; i < argc; i++) |
| { |
| if (!Options::checkArgument(args, argv[i], strlen(argv[i]))) |
| { |
| // failure. |
| options.printUsage(); |
| return (1); |
| } |
| } |
| if (!options.initOptions(args)) |
| { |
| return (1); |
| } |
| |
| OUString regName1( convertToFileUrl(options.getRegName1().c_str(), options.getRegName1().size()) ); |
| OUString regName2( convertToFileUrl(options.getRegName2().c_str(), options.getRegName2().size()) ); |
| |
| Registry reg1, reg2; |
| if ( reg1.open(regName1, REG_READONLY) ) |
| { |
| fprintf(stdout, "%s: open registry \"%s\" failed\n", |
| options.getProgramName().c_str(), options.getRegName1().c_str()); |
| return (2); |
| } |
| if ( reg2.open(regName2, REG_READONLY) ) |
| { |
| fprintf(stdout, "%s: open registry \"%s\" failed\n", |
| options.getProgramName().c_str(), options.getRegName2().c_str()); |
| return (3); |
| } |
| |
| RegistryKey key1, key2; |
| if ( reg1.openRootKey(key1) ) |
| { |
| fprintf(stdout, "%s: open root key of registry \"%s\" failed\n", |
| options.getProgramName().c_str(), options.getRegName1().c_str()); |
| return (4); |
| } |
| if ( reg2.openRootKey(key2) ) |
| { |
| fprintf(stdout, "%s: open root key of registry \"%s\" failed\n", |
| options.getProgramName().c_str(), options.getRegName2().c_str()); |
| return (5); |
| } |
| |
| if ( options.isStartKeyValid() ) |
| { |
| if ( options.matchedWithExcludeKey( options.getStartKey() ) ) |
| { |
| fprintf(stdout, "%s: start key is equal to one of the exclude keys\n", |
| options.getProgramName().c_str()); |
| return (6); |
| } |
| RegistryKey sk1, sk2; |
| if ( key1.openKey(options.getStartKey(), sk1) ) |
| { |
| fprintf(stdout, "%s: open start key of registry \"%s\" failed\n", |
| options.getProgramName().c_str(), options.getRegName1().c_str()); |
| return (7); |
| } |
| if ( key2.openKey(options.getStartKey(), sk2) ) |
| { |
| fprintf(stdout, "%s: open start key of registry \"%s\" failed\n", |
| options.getProgramName().c_str(), options.getRegName2().c_str()); |
| return (8); |
| } |
| |
| key1 = sk1; |
| key2 = sk2; |
| } |
| |
| sal_uInt32 nError = compareKeys(options, key1, key2); |
| if ( nError ) |
| { |
| if ( options.unoTypeCheck() ) |
| { |
| fprintf(stdout, "%s: registries are incompatible: %lu differences!\n", |
| options.getProgramName().c_str(), |
| sal::static_int_cast< unsigned long >(nError)); |
| } |
| else |
| { |
| fprintf(stdout, "%s: registries contain %lu differences!\n", |
| options.getProgramName().c_str(), |
| sal::static_int_cast< unsigned long >(nError)); |
| } |
| } |
| else |
| { |
| if ( options.unoTypeCheck() ) |
| { |
| fprintf(stdout, "%s: registries are compatible!\n", |
| options.getProgramName().c_str()); |
| } |
| else |
| { |
| fprintf(stdout, "%s: registries are equal!\n", |
| options.getProgramName().c_str()); |
| } |
| } |
| |
| key1.releaseKey(); |
| key2.releaseKey(); |
| if ( reg1.close() ) |
| { |
| fprintf(stdout, "%s: closing registry \"%s\" failed\n", |
| options.getProgramName().c_str(), options.getRegName1().c_str()); |
| return (9); |
| } |
| if ( reg2.close() ) |
| { |
| fprintf(stdout, "%s: closing registry \"%s\" failed\n", |
| options.getProgramName().c_str(), options.getRegName2().c_str()); |
| return (10); |
| } |
| |
| return ((nError > 0) ? 11 : 0); |
| } |
