strepsirrhini/office-gobmx
9
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
office-gobmx/registry/tools/regcompare.cxx
Rüdiger Timm ccd83848ab INTEGRATION: CWS changefileheader (1.26.14); FILE MERGED 
2008/04/01 15:23:08 thb 1.26.14.3: #i85898# Stripping all external header guards
2008/04/01 12:32:41 thb 1.26.14.2: #i85898# Stripping all external header guards
2008/03/31 07:25:18 rt 1.26.14.1: #i87441# Change license header to LPGL v3.
2008-04-11 09:58:04 +00:00

2401 lines
84 KiB
C++
Raw Blame History

/*************************************************************************
*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* Copyright 2008 by Sun Microsystems, Inc.
*
* OpenOffice.org - a multi-platform office productivity suite
*
* $RCSfile: regcompare.cxx,v $
* $Revision: 1.27 $
*
* This file is part of OpenOffice.org.
*
* OpenOffice.org is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License version 3
* only, as published by the Free Software Foundation.
*
* OpenOffice.org 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 version 3 for more details
* (a copy is included in the LICENSE file that accompanied this code).
*
* You should have received a copy of the GNU Lesser General Public License
* version 3 along with OpenOffice.org. If not, see
* <http://www.openoffice.org/license.html>
* for a copy of the LGPLv3 License.
*
************************************************************************/
// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_registry.hxx"
#include <stdio.h>
#include <string.h>
#include <set>
#include <vector>
#include "registry/registry.hxx"
#include "registry/reader.hxx"
#include "registry/version.h"
#include <rtl/ustring.hxx>
#include <rtl/alloc.h>
#include <osl/process.h>
#include <osl/diagnose.h>
#include <osl/thread.h>
#include <osl/file.hxx>
#ifdef SAL_UNX
#define SEPARATOR '/'
#else
#define SEPARATOR '\\'
#endif
using namespace ::rtl;
using namespace ::osl;
OUString shortName(const OUString& fullName)
{
return fullName.copy(fullName.lastIndexOf('/') + 1);
}
sal_Bool isFileUrl(const OString& fileName)
{
if (fileName.indexOf("file://") == 0 )
return sal_True;
return sal_False;
}
OUString convertToFileUrl(const OString& fileName)
{
if ( isFileUrl(fileName) )
{
return OStringToOUString(fileName, osl_getThreadTextEncoding());
}
OUString uUrlFileName;
OUString uFileName(fileName.getStr(), fileName.getLength(), osl_getThreadTextEncoding());
if ( fileName.indexOf('.') == 0 || fileName.indexOf(SEPARATOR) < 0 )
{
OUString uWorkingDir;
if (osl_getProcessWorkingDir(&uWorkingDir.pData) != osl_Process_E_None)
{
OSL_ASSERT(false);
}
if (FileBase::getAbsoluteFileURL(uWorkingDir, uFileName, uUrlFileName)
!= FileBase::E_None)
{
OSL_ASSERT(false);
}
} else
{
if (FileBase::getFileURLFromSystemPath(uFileName, uUrlFileName)
!= FileBase::E_None)
{
OSL_ASSERT(false);
}
}
return uUrlFileName;
}
#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)
, m_bUnoTypeCheck(sal_False)
, m_checkUnpublished(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 existsExcludeKeys()
{ return !m_excludeKeys.empty(); };
StringSet& getExcludeKeys()
{ return m_excludeKeys; }
sal_Bool matchedWithExcludeKey( const OUString& keyName);
sal_Bool fullCheck()
{ return m_bFullCheck; }
sal_Bool forceOutput()
{ return m_bForceOutput; }
sal_Bool unoTypeCheck()
{ return m_bUnoTypeCheck; }
bool checkUnpublished() const { return m_checkUnpublished; }
protected:
OString m_program;
OString m_regName1;
OString m_regName2;
OString m_startKey;
StringSet m_excludeKeys;
sal_Bool m_bFullCheck;
sal_Bool m_bForceOutput;
sal_Bool m_bUnoTypeCheck;
bool m_checkUnpublished;
};
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(stdout, "%s", prepareHelp().getStr());
bRet = sal_False;
}
i = 1;
} else
{
i = 0;
}
char *s=NULL;
for (; 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(stdout, "%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(stdout, "%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(stdout, "%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(stdout, "%s: invalid option '%s'\n", m_program.getStr(), av[i]);
bRet = sal_False;
break;
}
} else
{
s = av[i] + 2;
}
m_excludeKeys.insert(S2U(s));
break;
case 'c':
case 'C':
if (av[i][2] != '\0')
{
fprintf(stdout, "%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(stdout, "%s: invalid option '%s'\n", m_program.getStr(), av[i]);
bRet = sal_False;
}
m_bForceOutput = sal_True;
break;
case 't':
case 'T':
if (av[i][2] != '\0')
{
fprintf(stdout, "%s: invalid option '%s'\n", m_program.getStr(), av[i]);
}
m_bUnoTypeCheck = sal_True;
break;
case 'u':
case 'U':
if (av[i][2] != '\0')
{
fprintf(stdout, "%s: invalid option '%s'\n", m_program.getStr(), av[i]);
}
m_checkUnpublished = true;
break;
case 'h':
case '?':
if (av[i][2] != '\0')
{
fprintf(stdout, "%s: invalid option '%s'\n", m_program.getStr(), av[i]);
bRet = sal_False;
} else
{
fprintf(stdout, "%s", prepareHelp().getStr());
exit(0);
}
break;
default:
fprintf(stdout, "%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(stdout, "%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 j=0; j < rargc; j++)
{
free(rargv[j]);
}
}
} else
{
fprintf(stdout, "%s: unknown option '%s'\n", m_program.getStr(), av[i]);
bRet = sal_False;
}
}
}
if ( bRet )
{
if ( m_regName1.getLength() == 0 )
{
fprintf(stdout, "%s: missing option '-r1'\n", m_program.getStr());
bRet = sal_False;
}
if ( m_regName2.getLength() == 0 )
{
fprintf(stdout, "%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 += " |S<name> 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. All\n";
help += " |X<name> subkeys won't be compared also. This option can be used more than once.\n";
help += " -f|F = force the detailed output of any diffenrences. Default\n";
help += " is that only the number of differences is returned.\n";
help += " -c|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 += " -t|T = make an UNO type compatiblity check. This means that registry 2\n";
help += " will be checked against registry 1. If a interface in r2 contains\n";
help += " more methods or the methods are in a different order as in r1, r2 is\n";
help += " incompatible to r1. But if a service in r2 supports more properties as\n";
help += " in r1 and the new properties are 'optonal' it is compatible.\n";
help += " -u|U = additionally check types that are unpublished in registry 1.\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;
}
sal_Bool Options::matchedWithExcludeKey( const OUString& keyName)
{
if ( m_excludeKeys.empty() )
return sal_False;
StringSet::const_iterator iter = m_excludeKeys.begin();
StringSet::const_iterator end = m_excludeKeys.end();
while ( iter != end )
{
if ( keyName.indexOf(*iter) == 0)
return sal_True;
++iter;
}
return sal_False;
}
static Options options;
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 sal_uInt32 checkConstValue(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() )
{
if ( bDump )
{
fprintf(stdout, "%s: %s\n", getTypeClass(typeClass), U2S(keyName));
bDump = sal_False;
}
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() )
{
if ( bDump )
{
fprintf(stdout, "%s: %s\n", getTypeClass(typeClass), U2S(keyName));
bDump = sal_False;
}
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() )
{
if ( bDump )
{
fprintf(stdout, "%s: %s\n", getTypeClass(typeClass), U2S(keyName));
bDump = sal_False;
}
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() )
{
if ( bDump )
{
fprintf(stdout, "%s: %s\n", getTypeClass(typeClass), U2S(keyName));
bDump = sal_False;
}
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() )
{
if ( bDump )
{
fprintf(stdout, "%s: %s\n", getTypeClass(typeClass), U2S(keyName));
bDump = sal_False;
}
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() )
{
if ( bDump )
{
fprintf(stdout, "%s: %s\n", getTypeClass(typeClass), U2S(keyName));
bDump = sal_False;
}
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() )
{
if ( bDump )
{
fprintf(stdout, "%s: %s\n", getTypeClass(typeClass), U2S(keyName));
bDump = sal_False;
}
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() )
{
if ( bDump )
{
fprintf(stdout, "%s: %s\n", getTypeClass(typeClass), U2S(keyName));
bDump = sal_False;
}
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() )
{
if ( bDump )
{
fprintf(stdout, "%s: %s\n", getTypeClass(typeClass), U2S(keyName));
bDump = sal_False;
}
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() )
{
if ( bDump )
{
fprintf(stdout, "%s: %s\n", getTypeClass(typeClass), U2S(keyName));
bDump = sal_False;
}
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(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() )
{
if ( bDump )
{
fprintf(stdout, "%s: %s\n", getTypeClass(typeClass), U2S(keyName));
bDump = sal_False;
}
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() )
{
if ( bDump )
{
fprintf(stdout, "%s: %s\n", getTypeClass(typeClass), U2S(keyName));
bDump = sal_False;
}
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() )
{
if ( bDump )
{
fprintf(stdout, "%s: %s\n", getTypeClass(typeClass), U2S(keyName));
bDump = sal_False;
}
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(keyName, typeClass, bDump, constValue1, constValue2, index1);
}
}
if ( reader1.getFieldFlags(index1) != reader2.getFieldFlags(index2) )
{
if ( options.forceOutput() && !options.unoTypeCheck() )
{
if ( bDump )
{
fprintf(stdout, "%s: %s\n", getTypeClass(typeClass), U2S(keyName));
bDump = sal_False;
}
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() )
{
if ( bDump )
{
fprintf(stdout, "%s: %s\n", getTypeClass(typeClass), U2S(keyName));
bDump = sal_False;
}
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(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() )
{
if ( bDump )
{
fprintf(stdout, "%s: %s\n", getTypeClass(typeClass), U2S(keyName));
bDump = sal_False;
}
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() )
{
if ( bDump )
{
fprintf(stdout, "%s: %s\n", getTypeClass(typeClass), U2S(keyName));
bDump = sal_False;
}
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() )
{
if ( bDump )
{
fprintf(stdout, "%s: %s\n", getTypeClass(typeClass), U2S(keyName));
bDump = sal_False;
}
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() )
{
if ( bDump )
{
fprintf(stdout, "%s: %s\n", getTypeClass(typeClass), U2S(keyName));
bDump = sal_False;
}
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() )
{
if ( bDump )
{
fprintf(stdout, "%s: %s\n", getTypeClass(typeClass), U2S(keyName));
bDump = sal_False;
}
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() )
{
if ( bDump )
{
fprintf(stdout, "%s: %s\n", getTypeClass(typeClass), U2S(keyName));
bDump = sal_False;
}
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() )
{
if ( bDump )
{
fprintf(stdout, "%s: %s\n", getTypeClass(typeClass), U2S(keyName));
bDump = sal_False;
}
fprintf(stdout, " Registry1: Method %d contains %d more parameters\n", index, nParams1 - i);
}
if ( i < nParams2 && options.forceOutput() )
{
if ( bDump )
{
fprintf(stdout, "%s: %s\n", getTypeClass(typeClass), U2S(keyName));
bDump = sal_False;
}
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() )
{
if ( bDump )
{
fprintf(stdout, "%s: %s\n", getTypeClass(typeClass), U2S(keyName));
bDump = sal_False;
}
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() )
{
if ( bDump )
{
fprintf(stdout, "%s: %s\n", getTypeClass(typeClass), U2S(keyName));
bDump = sal_False;
}
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() )
{
if ( bDump )
{
fprintf(stdout, "%s: %s\n", getTypeClass(typeClass), U2S(keyName));
bDump = sal_False;
}
fprintf(stdout, " Registry1: Method %d contains %d more exceptions\n", index, nExcep1 - i);
}
if ( i < nExcep2 && options.forceOutput() )
{
if ( bDump )
{
fprintf(stdout, "%s: %s\n", getTypeClass(typeClass), U2S(keyName));
bDump = sal_False;
}
fprintf(stdout, " Registry2: Method %d contains %d more exceptions\n", index, nExcep2 - i);
}
if ( reader1.getMethodFlags(index) != reader2.getMethodFlags(index) )
{
if ( options.forceOutput() )
{
if ( bDump )
{
fprintf(stdout, "%s: %s\n", getTypeClass(typeClass), U2S(keyName));
bDump = sal_False;
}
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() )
{
if ( bDump )
{
fprintf(stdout, "%s: %s\n", getTypeClass(typeClass), U2S(keyName));
bDump = sal_False;
}
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(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() )
{
if ( bDump )
{
fprintf(stdout, "%s: %s\n", getTypeClass(typeClass), U2S(keyName));
bDump = sal_False;
}
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() )
{
if ( bDump )
{
fprintf(stdout, "%s: %s\n", getTypeClass(typeClass), U2S(keyName));
bDump = sal_False;
}
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() )
{
if ( bDump )
{
fprintf(stdout, "%s: %s\n", getTypeClass(typeClass), U2S(keyName));
bDump = sal_False;
}
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() )
{
if ( bDump )
{
fprintf(stdout, "%s: %s\n", getTypeClass(typeClass), U2S(keyName));
bDump = sal_False;
}
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(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() )
{
if ( bDump )
{
fprintf(stdout, "%s: %s\n", getTypeClass(typeClass), U2S(keyName));
bDump = sal_False;
}
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, ::std::less< sal_uInt16 > > moreProps;
for (i=0; i < nFields1; i++)
{
for (j=0; j < nFields2; j++)
{
if (!checkField(keyName, typeClass, bDump, reader1, reader2, i, j))
{
bFound = sal_True;
moreProps.insert(j);
break;
}
}
if (!bFound)
{
if (options.forceOutput())
{
if ( bDump )
{
fprintf(stdout, "%s: %s\n", getTypeClass(typeClass), U2S(keyName));
bDump = sal_False;
}
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() )
{
if ( bDump )
{
fprintf(stdout, "%s: %s\n", getTypeClass(typeClass), U2S(keyName));
bDump = sal_False;
}
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(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()) {
if (bDump) {
fprintf(stdout, "?: %s\n", U2S(keyName));
bDump = false;
}
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() )
{
if (bDump) {
fprintf(stdout, "?: %s\n", U2S(keyName));
bDump = sal_False;
}
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() )
{
if ( bDump )
{
fprintf(stdout, "%s: %s\n", getTypeClass(typeClass), U2S(keyName));
bDump = sal_False;
}
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()) {
if (bDump) {
fprintf(
stdout, "%s: %s\n", getTypeClass(typeClass), U2S(keyName));
bDump = false;
}
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() )
{
if ( bDump )
{
fprintf(stdout, "%s: %s\n", getTypeClass(typeClass), U2S(keyName));
bDump = sal_False;
}
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() )
{
if ( bDump )
{
fprintf(stdout, "%s: %s\n", getTypeClass(typeClass), U2S(keyName));
bDump = sal_False;
}
fprintf(stdout, " nFields1 = %d != nFields2 = %d\n", nFields1, nFields2);
}
nError++;
}
sal_uInt16 i;
for (i=0; i < nFields1 && i < nFields2; i++)
{
nError += checkField(keyName, typeClass, bDump, reader1, reader2, i, i);
}
if ( i < nFields1 && options.forceOutput() )
{
if ( bDump )
{
fprintf(stdout, "%s: %s\n", getTypeClass(typeClass), U2S(keyName));
bDump = sal_False;
}
fprintf(stdout, " Registry1 contains %d more fields\n", nFields1 - i);
}
if ( i < nFields2 && options.forceOutput() )
{
if ( bDump )
{
fprintf(stdout, "%s: %s\n", getTypeClass(typeClass), U2S(keyName));
bDump = sal_False;
}
fprintf(stdout, " Registry2 contains %d more fields\n", nFields2 - i);
}
} else
{
nError += checkFieldsWithoutOrder(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() )
{
if ( bDump )
{
fprintf(stdout, "%s: %s\n", getTypeClass(typeClass), U2S(keyName));
bDump = sal_False;
}
fprintf(stdout, " nMethods1 = %d != nMethods2 = %d\n", nMethods1, nMethods2);
}
nError++;
}
sal_uInt16 i;
for (i=0; i < nMethods1 && i < nMethods2; i++)
{
nError += checkMethod(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() )
{
if ( bDump )
{
fprintf(stdout, "%s: %s\n", getTypeClass(typeClass), U2S(keyName));
bDump = sal_False;
}
fprintf(stdout, " service1 contains %d more references as service2\n",
nReference1-nReference2);
}
}
sal_Bool bFound = sal_False;
::std::set< sal_uInt16, ::std::less< sal_uInt16 > > moreReferences;
for (i=0; i < nReference1; i++)
{
for (j=0; j < nReference2; j++)
{
if (!checkReference(keyName, typeClass, bDump, reader1, reader2, i, j))
{
bFound = sal_True;
moreReferences.insert(j);
break;
}
}
if (!bFound)
{
if (options.forceOutput())
{
if ( bDump )
{
fprintf(stdout, "%s: %s\n", getTypeClass(typeClass), U2S(keyName));
bDump = sal_False;
}
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() )
{
if ( bDump )
{
fprintf(stdout, "%s: %s\n", getTypeClass(typeClass), U2S(keyName));
bDump = sal_False;
}
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() )
{
if ( bDump )
{
fprintf(stdout, "%s: %s\n", getTypeClass(typeClass), U2S(keyName));
bDump = sal_False;
}
fprintf(stdout, " nReferences1 = %d != nReferences2 = %d\n", nReference1, nReference2);
}
nError++;
}
sal_uInt16 i;
for (i=0; i < nReference1 && i < nReference2; i++)
{
nError += checkReference(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() )
{
if ( bDump )
{
fprintf(stdout, "%s: %s\n", getTypeClass(typeClass), U2S(keyName));
bDump = sal_False;
}
fprintf(stdout, " Doku1 = %s\n Doku2 = %s\n",
U2S(reader1.getDocumentation()), U2S(reader2.getDocumentation()));
}
nError++;
}
/*
if ( nError &&
(!keyName.compareTo(OUString::createFromAscii("/UCR/drafts"), 11) ||
!keyName.compareTo(OUString::createFromAscii("/drafts"), 7)) )
{
if ( options.forceOutput() )
{
if ( bDump )
{
fprintf(stdout, "%s: %s\n", getTypeClass(typeClass), U2S(keyName));
bDump = sal_False;
}
fprintf(stdout, " Note: \"drafts\" type changed incompatible, no effect to the final API\n");
}
return 0;
}
*/
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;
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)
{
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 && valueType2 == RG_VALUETYPE_BINARY )
{
typereg::Reader reader1(
value1, size1, false, TYPEREG_VERSION_1);
typereg::Reader reader2(
value2, size2, false, TYPEREG_VERSION_1);
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(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:
case RG_VALUETYPE_STRING:
case RG_VALUETYPE_UNICODE:
{
RegValue value1 = rtl_allocateMemory(size1);
key1.getValue(tmpName, value1);
switch (valueType1)
{
case RG_VALUETYPE_LONG:
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);
break;
case RG_VALUETYPE_STRING:
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", (sal_Char*)value1);
break;
case RG_VALUETYPE_UNICODE:
{
OUString uStrValue((sal_Unicode*)value1);
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;
default:
OSL_ASSERT(false);
break;
}
rtl_freeMemory(value1);
}
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:
case RG_VALUETYPE_STRING:
case RG_VALUETYPE_UNICODE:
{
RegValue value2 = rtl_allocateMemory(size2);
key2.getValue(tmpName, value2);
switch (valueType2)
{
case RG_VALUETYPE_LONG:
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);
break;
case RG_VALUETYPE_STRING:
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", (sal_Char*)value2);
break;
case RG_VALUETYPE_UNICODE:
{
OUString uStrValue((sal_Unicode*)value2);
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;
default:
OSL_ASSERT(false);
break;
}
rtl_freeMemory(value2);
}
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(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().getStr());
}
}
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().getStr());
}
} else if (type == RG_VALUETYPE_BINARY) {
char * value = new char[size];
bool published = false;
if (subKey.getValue(rtl::OUString(), value) != REG_NO_ERROR)
{
if (options.forceOutput()) {
fprintf(
stdout,
("WARNING: could not read key \"%s\" in"
" registry \"%s\"\n"),
U2S(subKeyNames.getElement(i)),
options.getRegName1().getStr());
}
} else {
published = typereg::Reader(
value, size, false, TYPEREG_VERSION_1).
isPublished();
}
delete[] value;
if (published) {
return true;
}
}
}
}
}
return false;
}
static sal_uInt32 checkDifferences(
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().getStr());
}
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().getStr());
}
++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().getStr());
}
++nError;
} else if (type == RG_VALUETYPE_BINARY) {
char * value = new char[size];
if (subKey.getValue(rtl::OUString(), value)
!= REG_NO_ERROR)
{
if (options.forceOutput()) {
fprintf(
stdout,
("ERROR: could not read key \"%s\" in"
" registry \"%s\"\n"),
U2S(subKeyNames1.getElement(i)),
options.getRegName1().getStr());
}
++nError;
} else {
typereg::Reader reader(
value, size, false, TYPEREG_VERSION_1);
if (reader.getTypeClass() == RT_TYPE_MODULE) {
if (options.checkUnpublished()
|| hasPublishedChildren(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;
}
}
delete[] value;
}
}
}
}
}
}
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().getStr());
}
nError++;
}
}
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(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(key1, 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.matchedWithExcludeKey(keyName) )
{
++iter;
continue;
}
sal_Int32 nPos = keyName.lastIndexOf( '/' );
keyName = keyName.copy( nPos != -1 ? nPos+1 : 0 );
if ( key1.openKey(keyName, subKey1) )
{
if ( options.forceOutput() )
{
fprintf(stdout, "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(stdout, "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) || defined __MINGW32__
int main( int argc, char * argv[] )
#else
int _cdecl main( int argc, char * argv[] )
#endif
{
if ( !options.initOptions(argc, argv) )
{
exit(1);
}
OUString regName1( convertToFileUrl(options.getRegName1()) );
OUString regName2( convertToFileUrl(options.getRegName2()) );
Registry reg1;
Registry reg2;
if ( reg1.open(regName1, REG_READONLY) )
{
fprintf(stdout, "%s: open registry \"%s\" failed\n",
options.getProgramName().getStr(), options.getRegName1().getStr());
exit(2);
}
if ( reg2.open(regName2, REG_READONLY) )
{
fprintf(stdout, "%s: open registry \"%s\" failed\n",
options.getProgramName().getStr(), options.getRegName2().getStr());
exit(3);
}
RegistryKey key1, key2;
if ( reg1.openRootKey(key1) )
{
fprintf(stdout, "%s: open root key of registry \"%s\" failed\n",
options.getProgramName().getStr(), options.getRegName1().getStr());
exit(4);
}
if ( reg2.openRootKey(key2) )
{
fprintf(stdout, "%s: open root key of registry \"%s\" failed\n",
options.getProgramName().getStr(), options.getRegName2().getStr());
exit(5);
}
if ( options.isStartKeyValid() )
{
if ( options.matchedWithExcludeKey( S2U(options.getStartKey()) ) )
{
fprintf(stdout, "%s: start key is equal to one of the exclude keys\n",
options.getProgramName().getStr());
exit(6);
}
RegistryKey sk1, sk2;
if ( key1.openKey(S2U(options.getStartKey()), sk1) )
{
fprintf(stdout, "%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(stdout, "%s: open start key of registry \"%s\" failed\n",
options.getProgramName().getStr(), options.getRegName2().getStr());
exit(8);
}
key1 = sk1;
key2 = sk2;
}
sal_uInt32 nError = compareKeys(key1, key2);
if ( nError )
{
if ( options.unoTypeCheck() )
{
fprintf(stdout, "%s: registries are incompatible: %lu differences!\n",
options.getProgramName().getStr(),
sal::static_int_cast< unsigned long >(nError));
} else
{
fprintf(stdout, "%s: registries contain %lu differences!\n",
options.getProgramName().getStr(),
sal::static_int_cast< unsigned long >(nError));
}
} else
{
if ( options.unoTypeCheck() )
{
fprintf(stdout, "%s: registries are compatible!\n",
options.getProgramName().getStr());
} else
{
fprintf(stdout, "%s: registries are equal!\n",
options.getProgramName().getStr());
}
}
key1.closeKey();
key2.closeKey();
if ( reg1.close() )
{
fprintf(stdout, "%s: closing registry \"%s\" failed\n",
options.getProgramName().getStr(), options.getRegName1().getStr());
exit(9);
}
if ( reg2.close() )
{
fprintf(stdout, "%s: closing registry \"%s\" failed\n",
options.getProgramName().getStr(), options.getRegName2().getStr());
exit(10);
}
return nError > 0 ? 11 : 0;
}
Reference in a new issue View git blame Copy permalink