Line data Source code
1 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : /*
3 : * This file is part of the LibreOffice project.
4 : *
5 : * This Source Code Form is subject to the terms of the Mozilla Public
6 : * License, v. 2.0. If a copy of the MPL was not distributed with this
7 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 : *
9 : * This file incorporates work covered by the following license notice:
10 : *
11 : * Licensed to the Apache Software Foundation (ASF) under one or more
12 : * contributor license agreements. See the NOTICE file distributed
13 : * with this work for additional information regarding copyright
14 : * ownership. The ASF licenses this file to you under the Apache
15 : * License, Version 2.0 (the "License"); you may not use this file
16 : * except in compliance with the License. You may obtain a copy of
17 : * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 : */
19 :
20 :
21 : #include "registry/registry.hxx"
22 : #include "registry/reader.hxx"
23 : #include "registry/version.h"
24 : #include "fileurl.hxx"
25 : #include "options.hxx"
26 :
27 : #include <rtl/ustring.hxx>
28 : #include <osl/diagnose.h>
29 :
30 : #include <stdio.h>
31 : #include <string.h>
32 :
33 : #include <set>
34 : #include <vector>
35 : #include <string>
36 :
37 : using namespace rtl;
38 : using namespace registry::tools;
39 :
40 : typedef std::set< OUString > StringSet;
41 :
42 0 : class Options_Impl : public Options
43 : {
44 : public:
45 0 : explicit Options_Impl(char const * program)
46 : : Options(program),
47 : m_bFullCheck(false),
48 : m_bForceOutput(false),
49 : m_bUnoTypeCheck(false),
50 0 : m_checkUnpublished(false)
51 0 : {}
52 :
53 0 : std::string const & getRegName1() const { return m_regName1; }
54 0 : std::string const & getRegName2() const { return m_regName2; }
55 :
56 0 : bool isStartKeyValid() const { return (!m_startKey.isEmpty()); }
57 0 : OUString const & getStartKey() const { return m_startKey; }
58 : bool matchedWithExcludeKey( const OUString& keyName) const;
59 :
60 0 : bool fullCheck() const { return m_bFullCheck; }
61 0 : bool forceOutput() const { return m_bForceOutput; }
62 0 : bool unoTypeCheck() const { return m_bUnoTypeCheck; }
63 0 : bool checkUnpublished() const { return m_checkUnpublished; }
64 :
65 : protected:
66 : bool setRegName_Impl(char c, std::string const & param);
67 :
68 : virtual void printUsage_Impl() const SAL_OVERRIDE;
69 : virtual bool initOptions_Impl (std::vector< std::string > & rArgs) SAL_OVERRIDE;
70 :
71 : std::string m_regName1;
72 : std::string m_regName2;
73 : OUString m_startKey;
74 : StringSet m_excludeKeys;
75 : bool m_bFullCheck;
76 : bool m_bForceOutput;
77 : bool m_bUnoTypeCheck;
78 : bool m_checkUnpublished;
79 : };
80 :
81 : #define U2S( s ) OUStringToOString(s, RTL_TEXTENCODING_UTF8).getStr()
82 :
83 0 : inline OUString makeOUString (std::string const & s)
84 : {
85 0 : return OUString(s.c_str(), s.size(), RTL_TEXTENCODING_UTF8, OSTRING_TO_OUSTRING_CVTFLAGS);
86 : }
87 :
88 0 : inline OUString shortName(OUString const & fullName)
89 : {
90 0 : return fullName.copy(fullName.lastIndexOf('/') + 1);
91 : }
92 :
93 0 : bool Options_Impl::setRegName_Impl(char c, std::string const & param)
94 : {
95 0 : bool one = (c == '1'), two = (c == '2');
96 0 : if (one)
97 0 : m_regName1 = param;
98 0 : if (two)
99 0 : m_regName2 = param;
100 0 : return (one || two);
101 : }
102 :
103 : //virtual
104 0 : void Options_Impl::printUsage_Impl() const
105 : {
106 0 : std::string const & rProgName = getProgramName();
107 : fprintf(stderr,
108 : "Usage: %s -r1<filename> -r2<filename> [-options] | @<filename>\n", rProgName.c_str()
109 0 : );
110 : fprintf(stderr,
111 : " -r1<filename> = filename specifies the name of the first registry.\n"
112 : " -r2<filename> = filename specifies the name of the second registry.\n"
113 : " @<filename> = filename specifies a command file.\n"
114 : "Options:\n"
115 : " -s<name> = name specifies the name of a start key. If no start key\n"
116 : " |S<name> is specified the comparison starts with the root key.\n"
117 : " -x<name> = name specifies the name of a key which won't be compared. All\n"
118 : " |X<name> subkeys won't be compared also. This option can be used more than once.\n"
119 : " -f|F = force the detailed output of any diffenrences. Default\n"
120 : " is that only the number of differences is returned.\n"
121 : " -c|C = make a complete check, that means any differences will be\n"
122 : " detected. Default is only a compatibility check that means\n"
123 : " only UNO typelibrary entries will be checked.\n"
124 : " -t|T = make an UNO type compatiblity check. This means that registry 2\n"
125 : " will be checked against registry 1. If a interface in r2 contains\n"
126 : " more methods or the methods are in a different order as in r1, r2 is\n"
127 : " incompatible to r1. But if a service in r2 supports more properties as\n"
128 : " in r1 and the new properties are 'optional' it is compatible.\n"
129 : " -u|U = additionally check types that are unpublished in registry 1.\n"
130 : " -h|-? = print this help message and exit.\n"
131 0 : );
132 : fprintf(stderr,
133 : "\n%s Version 1.0\n\n", rProgName.c_str()
134 0 : );
135 0 : }
136 :
137 : // virtual
138 0 : bool Options_Impl::initOptions_Impl (std::vector< std::string > & rArgs)
139 : {
140 0 : std::vector< std::string >::const_iterator first = rArgs.begin(), last = rArgs.end();
141 0 : for (; first != last; ++first)
142 : {
143 0 : if ((*first)[0] != '-')
144 : {
145 0 : return badOption("invalid", (*first).c_str());
146 : }
147 0 : switch ((*first)[1])
148 : {
149 : case 'r':
150 : case 'R':
151 : {
152 0 : if (!((++first != last) && ((*first)[0] != '-')))
153 : {
154 0 : return badOption("invalid", (*first).c_str());
155 : }
156 :
157 0 : std::string option(*first), param;
158 0 : if (option.size() == 1)
159 : {
160 : // "-r<n><space><param>"
161 0 : if (!((++first != last) && ((*first)[0] != '-')))
162 : {
163 0 : return badOption("invalid", (*first).c_str());
164 : }
165 0 : param = (*first);
166 : }
167 : else
168 : {
169 : // "-r<n><param>"
170 0 : param = std::string(&(option[1]), option.size() - 1);
171 : }
172 0 : if (!setRegName_Impl(option[0], param))
173 : {
174 0 : return badOption("invalid", option.c_str());
175 : }
176 0 : break;
177 : }
178 : case 's':
179 : case 'S':
180 : {
181 0 : if (!((++first != last) && ((*first)[0] != '-')))
182 : {
183 0 : return badOption("invalid", (*first).c_str());
184 : }
185 0 : m_startKey = makeOUString(*first);
186 0 : break;
187 : }
188 : case 'x':
189 : case 'X':
190 : {
191 0 : if (!((++first != last) && ((*first)[0] != '-')))
192 : {
193 0 : return badOption("invalid", (*first).c_str());
194 : }
195 0 : m_excludeKeys.insert(makeOUString(*first));
196 0 : break;
197 : }
198 : case 'f':
199 : case 'F':
200 : {
201 0 : if ((*first).size() > 2)
202 : {
203 0 : return badOption("invalid", (*first).c_str());
204 : }
205 0 : m_bForceOutput = true;
206 0 : break;
207 : }
208 : case 'c':
209 : case 'C':
210 : {
211 0 : if ((*first).size() > 2)
212 : {
213 0 : return badOption("invalid", (*first).c_str());
214 : }
215 0 : m_bFullCheck = true;
216 0 : break;
217 : }
218 : case 't':
219 : case 'T':
220 : {
221 0 : if ((*first).size() > 2)
222 : {
223 0 : return badOption("invalid", (*first).c_str());
224 : }
225 0 : m_bUnoTypeCheck = true;
226 0 : break;
227 : }
228 : case 'u':
229 : case 'U':
230 : {
231 0 : if ((*first).size() > 2)
232 : {
233 0 : return badOption("invalid", (*first).c_str());
234 : }
235 0 : m_checkUnpublished = true;
236 0 : break;
237 : }
238 : case 'h':
239 : case '?':
240 : {
241 0 : if ((*first).size() > 2)
242 : {
243 0 : return badOption("invalid", (*first).c_str());
244 : }
245 0 : return printUsage();
246 : // break; // Unreachable
247 : }
248 : default:
249 : {
250 0 : return badOption("unknown", (*first).c_str());
251 : // break; // Unreachable
252 : }
253 : }
254 : }
255 :
256 0 : if ( m_regName1.empty() )
257 : {
258 0 : return badOption("missing", "-r1");
259 : }
260 0 : if ( m_regName2.empty() )
261 : {
262 0 : return badOption("missing", "-r2");
263 : }
264 0 : return true;
265 : }
266 :
267 0 : bool Options_Impl::matchedWithExcludeKey( const OUString& keyName) const
268 : {
269 0 : if (!m_excludeKeys.empty())
270 : {
271 0 : StringSet::const_iterator first = m_excludeKeys.begin(), last = m_excludeKeys.end();
272 0 : for (; first != last; ++first)
273 : {
274 0 : if (keyName.startsWith(*first))
275 0 : return true;
276 : }
277 : }
278 0 : return false;
279 : }
280 :
281 0 : static char const * getTypeClass(RTTypeClass typeClass)
282 : {
283 0 : switch (typeClass)
284 : {
285 : case RT_TYPE_INTERFACE:
286 0 : return "INTERFACE";
287 : case RT_TYPE_MODULE:
288 0 : return "MODULE";
289 : case RT_TYPE_STRUCT:
290 0 : return "STRUCT";
291 : case RT_TYPE_ENUM:
292 0 : return "ENUM";
293 : case RT_TYPE_EXCEPTION:
294 0 : return "EXCEPTION";
295 : case RT_TYPE_TYPEDEF:
296 0 : return "TYPEDEF";
297 : case RT_TYPE_SERVICE:
298 0 : return "SERVICE";
299 : case RT_TYPE_OBJECT:
300 0 : return "OBJECT";
301 : case RT_TYPE_CONSTANTS:
302 0 : return "CONSTANTS";
303 : default:
304 0 : return "INVALID";
305 : }
306 : }
307 :
308 0 : static OString getFieldAccess(RTFieldAccess fieldAccess)
309 : {
310 0 : OString ret;
311 : if ( (fieldAccess & RT_ACCESS_INVALID) == RT_ACCESS_INVALID )
312 : {
313 0 : ret += OString("INVALID");
314 : }
315 0 : if ( (fieldAccess & RT_ACCESS_READONLY) == RT_ACCESS_READONLY )
316 : {
317 0 : ret += OString(ret.isEmpty() ? "READONLY" : ",READONLY");
318 : }
319 0 : if ( (fieldAccess & RT_ACCESS_OPTIONAL) == RT_ACCESS_OPTIONAL )
320 : {
321 0 : ret += OString(ret.isEmpty() ? "OPTIONAL" : ",OPTIONAL");
322 : }
323 0 : if ( (fieldAccess & RT_ACCESS_MAYBEVOID) == RT_ACCESS_MAYBEVOID )
324 : {
325 0 : ret += OString(ret.isEmpty() ? "MAYBEVOID" : ",MAYBEVOID");
326 : }
327 0 : if ( (fieldAccess & RT_ACCESS_BOUND) == RT_ACCESS_BOUND )
328 : {
329 0 : ret += OString(ret.isEmpty() ? "BOUND" : ",BOUND");
330 : }
331 0 : if ( (fieldAccess & RT_ACCESS_CONSTRAINED) == RT_ACCESS_CONSTRAINED )
332 : {
333 0 : ret += OString(ret.isEmpty() ? "CONSTRAINED" : ",CONSTRAINED");
334 : }
335 0 : if ( (fieldAccess & RT_ACCESS_TRANSIENT) == RT_ACCESS_TRANSIENT )
336 : {
337 0 : ret += OString(ret.isEmpty() ? "TRANSIENT" : ",TRANSIENT");
338 : }
339 0 : if ( (fieldAccess & RT_ACCESS_MAYBEAMBIGUOUS) == RT_ACCESS_MAYBEAMBIGUOUS )
340 : {
341 0 : ret += OString(ret.isEmpty() ? "MAYBEAMBIGUOUS" : ",MAYBEAMBIGUOUS");
342 : }
343 0 : if ( (fieldAccess & RT_ACCESS_MAYBEDEFAULT) == RT_ACCESS_MAYBEDEFAULT )
344 : {
345 0 : ret += OString(ret.isEmpty() ? "MAYBEDEFAULT" : ",MAYBEDEFAULT");
346 : }
347 0 : if ( (fieldAccess & RT_ACCESS_REMOVABLE) == RT_ACCESS_REMOVABLE )
348 : {
349 0 : ret += OString(ret.isEmpty() ? "REMOVABLE" : ",REMOVABLE");
350 : }
351 0 : if ( (fieldAccess & RT_ACCESS_ATTRIBUTE) == RT_ACCESS_ATTRIBUTE )
352 : {
353 0 : ret += OString(ret.isEmpty() ? "ATTRIBUTE" : ",ATTRIBUTE");
354 : }
355 0 : if ( (fieldAccess & RT_ACCESS_PROPERTY) == RT_ACCESS_PROPERTY )
356 : {
357 0 : ret += OString(ret.isEmpty() ? "PROPERTY" : ",PROPERTY");
358 : }
359 0 : if ( (fieldAccess & RT_ACCESS_CONST) == RT_ACCESS_CONST )
360 : {
361 0 : ret += OString(ret.isEmpty() ? "CONST" : ",CONST");
362 : }
363 0 : if ( (fieldAccess & RT_ACCESS_READWRITE) == RT_ACCESS_READWRITE )
364 : {
365 0 : ret += OString(ret.isEmpty() ? "READWRITE" : ",READWRITE");
366 : }
367 0 : return ret;
368 : }
369 :
370 0 : static char const * getConstValueType(RTConstValue& constValue)
371 : {
372 0 : switch (constValue.m_type)
373 : {
374 : case RT_TYPE_BOOL:
375 0 : return "sal_Bool";
376 : case RT_TYPE_BYTE:
377 0 : return "sal_uInt8";
378 : case RT_TYPE_INT16:
379 0 : return "sal_Int16";
380 : case RT_TYPE_UINT16:
381 0 : return "sal_uInt16";
382 : case RT_TYPE_INT32:
383 0 : return "sal_Int32";
384 : case RT_TYPE_UINT32:
385 0 : return "sal_uInt32";
386 : // case RT_TYPE_INT64:
387 : // return "sal_Int64";
388 : // case RT_TYPE_UINT64:
389 : // return "sal_uInt64";
390 : case RT_TYPE_FLOAT:
391 0 : return "float";
392 : case RT_TYPE_DOUBLE:
393 0 : return "double";
394 : case RT_TYPE_STRING:
395 0 : return "sal_Unicode*";
396 : default:
397 0 : return "NONE";
398 : }
399 : }
400 :
401 0 : static void printConstValue(RTConstValue& constValue)
402 : {
403 0 : switch (constValue.m_type)
404 : {
405 : case RT_TYPE_NONE:
406 0 : fprintf(stdout, "none");
407 0 : break;
408 : case RT_TYPE_BOOL:
409 0 : fprintf(stdout, "%s", constValue.m_value.aBool ? "TRUE" : "FALSE");
410 0 : break;
411 : case RT_TYPE_BYTE:
412 0 : fprintf(stdout, "%d", constValue.m_value.aByte);
413 0 : break;
414 : case RT_TYPE_INT16:
415 0 : fprintf(stdout, "%d", constValue.m_value.aShort);
416 0 : break;
417 : case RT_TYPE_UINT16:
418 0 : fprintf(stdout, "%d", constValue.m_value.aUShort);
419 0 : break;
420 : case RT_TYPE_INT32:
421 : fprintf(
422 : stdout, "%ld",
423 0 : sal::static_int_cast< long >(constValue.m_value.aLong));
424 0 : break;
425 : case RT_TYPE_UINT32:
426 : fprintf(
427 : stdout, "%lu",
428 : sal::static_int_cast< unsigned long >(
429 0 : constValue.m_value.aULong));
430 0 : break;
431 : // case RT_TYPE_INT64:
432 : // fprintf(stdout, "%d", constValue.m_value.aHyper);
433 : // case RT_TYPE_UINT64:
434 : // fprintf(stdout, "%d", constValue.m_value.aUHyper);
435 : case RT_TYPE_FLOAT:
436 0 : fprintf(stdout, "%f", constValue.m_value.aFloat);
437 0 : break;
438 : case RT_TYPE_DOUBLE:
439 0 : fprintf(stdout, "%f", constValue.m_value.aDouble);
440 0 : break;
441 : case RT_TYPE_STRING:
442 : fprintf(
443 : stdout, "%s",
444 : (OUStringToOString(
445 : constValue.m_value.aString, RTL_TEXTENCODING_UTF8).
446 0 : getStr()));
447 0 : break;
448 : default:
449 0 : break;
450 : }
451 0 : }
452 :
453 0 : static void dumpTypeClass(bool & rbDump, RTTypeClass typeClass, OUString const & keyName)
454 : {
455 0 : if (rbDump)
456 0 : fprintf(stdout, "%s: %s\n", getTypeClass(typeClass), U2S(keyName));
457 0 : rbDump = false;
458 0 : }
459 :
460 0 : static sal_uInt32 checkConstValue(Options_Impl const & options,
461 : const OUString& keyName,
462 : RTTypeClass typeClass,
463 : bool & bDump,
464 : RTConstValue& constValue1,
465 : RTConstValue& constValue2,
466 : sal_uInt16 index1)
467 : {
468 0 : switch (constValue1.m_type)
469 : {
470 : case RT_TYPE_NONE:
471 0 : break;
472 : case RT_TYPE_BOOL:
473 0 : if (constValue1.m_value.aBool != constValue2.m_value.aBool)
474 : {
475 0 : if ( options.forceOutput() && !options.unoTypeCheck() )
476 : {
477 0 : dumpTypeClass(bDump, typeClass, keyName);
478 : fprintf(stdout, " Field %d: Value1 = %s != Value2 = %s\n", index1,
479 : constValue1.m_value.aBool ? "TRUE" : "FALSE",
480 0 : constValue2.m_value.aBool ? "TRUE" : "FALSE");
481 : }
482 0 : return 1;
483 : }
484 0 : break;
485 : case RT_TYPE_BYTE:
486 0 : if (constValue1.m_value.aByte != constValue2.m_value.aByte)
487 : {
488 0 : if ( options.forceOutput() && !options.unoTypeCheck() )
489 : {
490 0 : dumpTypeClass(bDump, typeClass, keyName);
491 : fprintf(stdout, " Field %d: Value1 = %d != Value2 = %d\n", index1,
492 0 : constValue1.m_value.aByte, constValue2.m_value.aByte);
493 : }
494 0 : return 1;
495 : }
496 0 : break;
497 : case RT_TYPE_INT16:
498 0 : if (constValue1.m_value.aShort != constValue2.m_value.aShort)
499 : {
500 0 : if ( options.forceOutput() && !options.unoTypeCheck() )
501 : {
502 0 : dumpTypeClass(bDump, typeClass, keyName);
503 : fprintf(stdout, " Field %d: Value1 = %d != Value2 = %d\n", index1,
504 0 : constValue1.m_value.aShort, constValue2.m_value.aShort);
505 : }
506 0 : return 1;
507 : }
508 0 : break;
509 : case RT_TYPE_UINT16:
510 0 : if (constValue1.m_value.aUShort != constValue2.m_value.aUShort)
511 : {
512 0 : if ( options.forceOutput() && !options.unoTypeCheck() )
513 : {
514 0 : dumpTypeClass(bDump, typeClass, keyName);
515 : fprintf(stdout, " Field %d: Value1 = %d != Value2 = %d\n", index1,
516 0 : constValue1.m_value.aUShort, constValue2.m_value.aUShort);
517 : }
518 0 : return 1;
519 : }
520 0 : break;
521 : case RT_TYPE_INT32:
522 0 : if (constValue1.m_value.aLong != constValue2.m_value.aLong)
523 : {
524 0 : if ( options.forceOutput() && !options.unoTypeCheck() )
525 : {
526 0 : dumpTypeClass(bDump, typeClass, keyName);
527 : fprintf(stdout, " Field %d: Value1 = %ld != Value2 = %ld\n", index1,
528 : sal::static_int_cast< long >(constValue1.m_value.aLong),
529 0 : sal::static_int_cast< long >(constValue2.m_value.aLong));
530 : }
531 0 : return 1;
532 : }
533 0 : break;
534 : case RT_TYPE_UINT32:
535 0 : if (constValue1.m_value.aULong != constValue2.m_value.aULong)
536 : {
537 0 : if ( options.forceOutput() && !options.unoTypeCheck() )
538 : {
539 0 : dumpTypeClass(bDump, typeClass, keyName);
540 : fprintf(stdout, " Field %d: Value1 = %lu != Value2 = %lu\n", index1,
541 : sal::static_int_cast< unsigned long >(constValue1.m_value.aULong),
542 0 : sal::static_int_cast< unsigned long >(constValue2.m_value.aULong));
543 : }
544 0 : return 1;
545 : }
546 0 : break;
547 : case RT_TYPE_INT64:
548 0 : if (constValue1.m_value.aHyper != constValue2.m_value.aHyper)
549 : {
550 0 : if ( options.forceOutput() && !options.unoTypeCheck() )
551 : {
552 0 : dumpTypeClass(bDump, typeClass, keyName);
553 : fprintf(
554 : stdout, " Field %d: Value1 = %s != Value2 = %s\n",
555 : index1,
556 : OUStringToOString(
557 : OUString::number(constValue1.m_value.aHyper),
558 : RTL_TEXTENCODING_ASCII_US).getStr(),
559 : OUStringToOString(
560 : OUString::number(constValue2.m_value.aHyper),
561 0 : RTL_TEXTENCODING_ASCII_US).getStr());
562 : }
563 0 : return 1;
564 : }
565 0 : break;
566 : case RT_TYPE_UINT64:
567 0 : if (constValue1.m_value.aUHyper != constValue2.m_value.aUHyper)
568 : {
569 0 : if ( options.forceOutput() && !options.unoTypeCheck() )
570 : {
571 0 : dumpTypeClass(bDump, typeClass, keyName);
572 : fprintf(
573 : stdout, " Field %d: Value1 = %s != Value2 = %s\n",
574 : index1,
575 : OUStringToOString(
576 : OUString::number(
577 : constValue1.m_value.aUHyper),
578 : RTL_TEXTENCODING_ASCII_US).getStr(),
579 : OUStringToOString(
580 : OUString::number(
581 : constValue2.m_value.aUHyper),
582 0 : RTL_TEXTENCODING_ASCII_US).getStr());
583 : // printing the unsigned values as signed should be
584 : // acceptable...
585 : }
586 0 : return 1;
587 : }
588 0 : break;
589 : case RT_TYPE_FLOAT:
590 0 : if (constValue1.m_value.aFloat != constValue2.m_value.aFloat)
591 : {
592 0 : if ( options.forceOutput() && !options.unoTypeCheck() )
593 : {
594 0 : dumpTypeClass(bDump, typeClass, keyName);
595 : fprintf(stdout, " Field %d: Value1 = %f != Value2 = %f\n", index1,
596 0 : constValue1.m_value.aFloat, constValue2.m_value.aFloat);
597 : }
598 0 : return 1;
599 : }
600 0 : break;
601 : case RT_TYPE_DOUBLE:
602 0 : if (constValue1.m_value.aDouble != constValue2.m_value.aDouble)
603 : {
604 0 : if ( options.forceOutput() && !options.unoTypeCheck() )
605 : {
606 0 : dumpTypeClass(bDump, typeClass, keyName);
607 : fprintf(stdout, " Field %d: Value1 = %f != Value2 = %f\n", index1,
608 0 : constValue1.m_value.aDouble, constValue2.m_value.aDouble);
609 : }
610 0 : return 1;
611 : }
612 0 : break;
613 : default:
614 : OSL_ASSERT(false);
615 0 : break;
616 : }
617 0 : return 0;
618 : }
619 :
620 : enum verbosity_t {SILENT, REPORT};
621 0 : static sal_uInt32 checkField(Options_Impl const & options,
622 : const OUString& keyName,
623 : RTTypeClass typeClass,
624 : bool & bDump,
625 : typereg::Reader& reader1,
626 : typereg::Reader& reader2,
627 : sal_uInt16 index1,
628 : sal_uInt16 index2,
629 : verbosity_t const eVerbosity)
630 : {
631 0 : sal_uInt32 nError = 0;
632 0 : if ( reader1.getFieldName(index1) != reader2.getFieldName(index2) )
633 : {
634 0 : if (options.forceOutput() && (REPORT == eVerbosity))
635 : {
636 0 : dumpTypeClass (bDump, typeClass, keyName);
637 : fprintf(stdout, " Field %d: Name1 = %s != Name2 = %s\n", index1,
638 0 : U2S(reader1.getFieldName(index1)), U2S(reader2.getFieldName(index2)));
639 : }
640 0 : nError++;
641 : }
642 0 : if ( reader1.getFieldTypeName(index1) != reader2.getFieldTypeName(index2) )
643 : {
644 0 : if (options.forceOutput() && (REPORT == eVerbosity))
645 : {
646 0 : dumpTypeClass (bDump, typeClass, keyName);
647 : fprintf(stdout, " Field %d: Type1 = %s != Type2 = %s\n", index1,
648 0 : U2S(reader1.getFieldTypeName(index1)), U2S(reader2.getFieldTypeName(index2)));
649 : }
650 0 : nError++;
651 : }
652 : else
653 : {
654 0 : RTConstValue constValue1 = reader1.getFieldValue(index1);
655 0 : RTConstValue constValue2 = reader2.getFieldValue(index2);
656 0 : if ( constValue1.m_type != constValue2.m_type )
657 : {
658 0 : if (options.forceOutput() && (REPORT == eVerbosity))
659 : {
660 0 : dumpTypeClass (bDump, typeClass, keyName);
661 : fprintf(stdout, " Field %d: Access1 = %s != Access2 = %s\n", index1,
662 0 : getConstValueType(constValue1), getConstValueType(constValue2));
663 0 : fprintf(stdout, " Field %d: Value1 = ", index1);
664 0 : printConstValue(constValue1);
665 0 : fprintf(stdout, " != Value2 = ");
666 0 : printConstValue(constValue1);
667 0 : fprintf(stdout, "\n;");
668 : }
669 0 : nError++;
670 : }
671 : else
672 : {
673 0 : nError += checkConstValue(options, keyName, typeClass, bDump, constValue1, constValue2, index1);
674 0 : }
675 : }
676 :
677 0 : if ( reader1.getFieldFlags(index1) != reader2.getFieldFlags(index2) )
678 : {
679 0 : if (options.forceOutput() && (REPORT == eVerbosity))
680 : {
681 0 : dumpTypeClass (bDump, typeClass, keyName);
682 : fprintf(stdout, " Field %d: FieldAccess1 = %s != FieldAccess2 = %s\n", index1,
683 0 : getFieldAccess(reader1.getFieldFlags(index1)).getStr(),
684 0 : getFieldAccess(reader1.getFieldFlags(index2)).getStr());
685 : }
686 0 : nError++;
687 : }
688 :
689 0 : if ( options.fullCheck() && (reader1.getFieldDocumentation(index1) != reader2.getFieldDocumentation(index2)) )
690 : {
691 0 : if (options.forceOutput() && (REPORT == eVerbosity))
692 : {
693 0 : dumpTypeClass (bDump, typeClass, keyName);
694 : fprintf(stdout, " Field %d: Doku1 = %s\n Doku2 = %s\n", index1,
695 0 : U2S(reader1.getFieldDocumentation(index1)), U2S(reader2.getFieldDocumentation(index2)));
696 : }
697 0 : nError++;
698 : }
699 0 : return nError;
700 : }
701 :
702 0 : static char const * getMethodMode(RTMethodMode methodMode)
703 : {
704 0 : switch ( methodMode )
705 : {
706 : case RT_MODE_ONEWAY:
707 0 : return "ONEWAY";
708 : case RT_MODE_ONEWAY_CONST:
709 0 : return "ONEWAY,CONST";
710 : case RT_MODE_TWOWAY:
711 0 : return "NONE";
712 : case RT_MODE_TWOWAY_CONST:
713 0 : return "CONST";
714 : default:
715 0 : return "INVALID";
716 : }
717 : }
718 :
719 0 : static char const * getParamMode(RTParamMode paramMode)
720 : {
721 0 : switch ( paramMode )
722 : {
723 : case RT_PARAM_IN:
724 0 : return "IN";
725 : case RT_PARAM_OUT:
726 0 : return "OUT";
727 : case RT_PARAM_INOUT:
728 0 : return "INOUT";
729 : default:
730 0 : return "INVALID";
731 : }
732 : }
733 :
734 0 : static sal_uInt32 checkMethod(Options_Impl const & options,
735 : const OUString& keyName,
736 : RTTypeClass typeClass,
737 : bool & bDump,
738 : typereg::Reader& reader1,
739 : typereg::Reader& reader2,
740 : sal_uInt16 index)
741 : {
742 0 : sal_uInt32 nError = 0;
743 0 : if ( reader1.getMethodName(index) != reader2.getMethodName(index) )
744 : {
745 0 : if ( options.forceOutput() )
746 : {
747 0 : dumpTypeClass (bDump, typeClass, keyName);
748 : fprintf(stdout, " Method1 %d: Name1 = %s != Name2 = %s\n", index,
749 : U2S(reader1.getMethodName(index)),
750 0 : U2S(reader2.getMethodName(index)));
751 : }
752 0 : nError++;
753 : }
754 :
755 0 : if ( reader1.getMethodReturnTypeName(index) != reader2.getMethodReturnTypeName(index) )
756 : {
757 0 : if ( options.forceOutput() )
758 : {
759 0 : dumpTypeClass (bDump, typeClass, keyName);
760 : fprintf(stdout, " Method1 %d: ReturnType1 = %s != ReturnType2 = %s\n", index,
761 : U2S(reader1.getMethodReturnTypeName(index)),
762 0 : U2S(reader2.getMethodReturnTypeName(index)));
763 : }
764 0 : nError++;
765 : }
766 :
767 0 : sal_uInt16 nParams1 = (sal_uInt16)reader1.getMethodParameterCount(index);
768 0 : sal_uInt16 nParams2 = (sal_uInt16)reader2.getMethodParameterCount(index);
769 0 : if ( nParams1 != nParams2 )
770 : {
771 0 : if ( options.forceOutput() )
772 : {
773 0 : dumpTypeClass (bDump, typeClass, keyName);
774 0 : fprintf(stdout, " Method %d : nParameters1 = %d != nParameters2 = %d\n", index, nParams1, nParams2);
775 : }
776 0 : nError++;
777 : }
778 0 : sal_uInt16 i=0;
779 0 : for (i=0; i < nParams1 && i < nParams2; i++)
780 : {
781 0 : if ( reader1.getMethodParameterTypeName(index, i) != reader2.getMethodParameterTypeName(index, i) )
782 : {
783 0 : if ( options.forceOutput() )
784 : {
785 0 : dumpTypeClass (bDump, typeClass, keyName);
786 : fprintf(stdout, " Method %d, Parameter %d: Type1 = %s != Type2 = %s\n", index, i,
787 : U2S(reader1.getMethodParameterTypeName(index, i)),
788 0 : U2S(reader2.getMethodParameterTypeName(index, i)));
789 : }
790 0 : nError++;
791 : }
792 0 : if ( options.fullCheck() && (reader1.getMethodParameterName(index, i) != reader2.getMethodParameterName(index, i)) )
793 : {
794 0 : if ( options.forceOutput() )
795 : {
796 0 : dumpTypeClass (bDump, typeClass, keyName);
797 : fprintf(stdout, " Method %d, Parameter %d: Name1 = %s != Name2 = %s\n", index, i,
798 : U2S(reader1.getMethodParameterName(index, i)),
799 0 : U2S(reader2.getMethodParameterName(index, i)));
800 : }
801 0 : nError++;
802 : }
803 0 : if ( reader1.getMethodParameterFlags(index, i) != reader2.getMethodParameterFlags(index, i) )
804 : {
805 0 : if ( options.forceOutput() )
806 : {
807 0 : dumpTypeClass (bDump, typeClass, keyName);
808 : fprintf(stdout, " Method %d, Parameter %d: Mode1 = %s != Mode2 = %s\n", index, i,
809 : getParamMode(reader1.getMethodParameterFlags(index, i)),
810 0 : getParamMode(reader2.getMethodParameterFlags(index, i)));
811 : }
812 0 : nError++;
813 : }
814 : }
815 0 : if ( i < nParams1 && options.forceOutput() )
816 : {
817 0 : dumpTypeClass (bDump, typeClass, keyName);
818 0 : fprintf(stdout, " Registry1: Method %d contains %d more parameters\n", index, nParams1 - i);
819 : }
820 0 : if ( i < nParams2 && options.forceOutput() )
821 : {
822 0 : dumpTypeClass (bDump, typeClass, keyName);
823 0 : fprintf(stdout, " Registry2: Method %d contains %d more parameters\n", index, nParams2 - i);
824 : }
825 :
826 0 : sal_uInt16 nExcep1 = (sal_uInt16)reader1.getMethodExceptionCount(index);
827 0 : sal_uInt16 nExcep2 = (sal_uInt16)reader2.getMethodExceptionCount(index);
828 0 : if ( nExcep1 != nExcep2 )
829 : {
830 0 : if ( options.forceOutput() )
831 : {
832 0 : dumpTypeClass (bDump, typeClass, keyName);
833 0 : fprintf(stdout, " nExceptions1 = %d != nExceptions2 = %d\n", nExcep1, nExcep2);
834 : }
835 0 : nError++;
836 : }
837 0 : for (i=0; i < nExcep1 && i < nExcep2; i++)
838 : {
839 0 : if ( reader1.getMethodExceptionTypeName(index, i) != reader2.getMethodExceptionTypeName(index, i) )
840 : {
841 0 : if ( options.forceOutput() )
842 : {
843 0 : dumpTypeClass (bDump, typeClass, keyName);
844 : fprintf(stdout, " Method %d, Exception %d: Name1 = %s != Name2 = %s\n", index, i,
845 : U2S(reader1.getMethodExceptionTypeName(index, i)),
846 0 : U2S(reader2.getMethodExceptionTypeName(index, i)));
847 : }
848 0 : nError++;
849 : }
850 : }
851 0 : if ( i < nExcep1 && options.forceOutput() )
852 : {
853 0 : dumpTypeClass (bDump, typeClass, keyName);
854 0 : fprintf(stdout, " Registry1: Method %d contains %d more exceptions\n", index, nExcep1 - i);
855 : }
856 0 : if ( i < nExcep2 && options.forceOutput() )
857 : {
858 0 : dumpTypeClass (bDump, typeClass, keyName);
859 0 : fprintf(stdout, " Registry2: Method %d contains %d more exceptions\n", index, nExcep2 - i);
860 : }
861 :
862 0 : if ( reader1.getMethodFlags(index) != reader2.getMethodFlags(index) )
863 : {
864 0 : if ( options.forceOutput() )
865 : {
866 0 : dumpTypeClass (bDump, typeClass, keyName);
867 : fprintf(stdout, " Method %d: Mode1 = %s != Mode2 = %s\n", index,
868 : getMethodMode(reader1.getMethodFlags(index)),
869 0 : getMethodMode(reader2.getMethodFlags(index)));
870 : }
871 0 : nError++;
872 : }
873 :
874 0 : if ( options.fullCheck() && (reader1.getMethodDocumentation(index) != reader2.getMethodDocumentation(index)) )
875 : {
876 0 : if ( options.forceOutput() )
877 : {
878 0 : dumpTypeClass (bDump, typeClass, keyName);
879 : fprintf(stdout, " Method %d: Doku1 = %s\n Doku2 = %s\n", index,
880 : U2S(reader1.getMethodDocumentation(index)),
881 0 : U2S(reader2.getMethodDocumentation(index)));
882 : }
883 0 : nError++;
884 : }
885 0 : return nError;
886 : }
887 :
888 0 : static char const * getReferenceType(RTReferenceType refType)
889 : {
890 0 : switch (refType)
891 : {
892 : case RT_REF_SUPPORTS:
893 0 : return "RT_REF_SUPPORTS";
894 : case RT_REF_OBSERVES:
895 0 : return "RT_REF_OBSERVES";
896 : case RT_REF_EXPORTS:
897 0 : return "RT_REF_EXPORTS";
898 : case RT_REF_NEEDS:
899 0 : return "RT_REF_NEEDS";
900 : default:
901 0 : return "RT_REF_INVALID";
902 : }
903 : }
904 :
905 0 : static sal_uInt32 checkReference(Options_Impl const & options,
906 : const OUString& keyName,
907 : RTTypeClass typeClass,
908 : bool & bDump,
909 : typereg::Reader& reader1,
910 : typereg::Reader& reader2,
911 : sal_uInt16 index1,
912 : sal_uInt16 index2)
913 : {
914 0 : sal_uInt32 nError = 0;
915 0 : if ( reader1.getReferenceTypeName(index1) != reader2.getReferenceTypeName(index2) )
916 : {
917 0 : if ( options.forceOutput() && !options.unoTypeCheck() )
918 : {
919 0 : dumpTypeClass (bDump, typeClass, keyName);
920 : fprintf(stdout, " Reference %d: Name1 = %s != Name2 = %s\n", index1,
921 : U2S(reader1.getReferenceTypeName(index1)),
922 0 : U2S(reader2.getReferenceTypeName(index2)));
923 : }
924 0 : nError++;
925 : }
926 0 : if ( reader1.getReferenceTypeName(index1) != reader2.getReferenceTypeName(index2) )
927 : {
928 0 : if ( options.forceOutput() && !options.unoTypeCheck() )
929 : {
930 0 : dumpTypeClass (bDump, typeClass, keyName);
931 : fprintf(stdout, " Reference %d: Type1 = %s != Type2 = %s\n", index1,
932 : getReferenceType(reader1.getReferenceSort(index1)),
933 0 : getReferenceType(reader2.getReferenceSort(index2)));
934 : }
935 0 : nError++;
936 : }
937 0 : if ( options.fullCheck() && (reader1.getReferenceDocumentation(index1) != reader2.getReferenceDocumentation(index2)) )
938 : {
939 0 : if ( options.forceOutput() && !options.unoTypeCheck() )
940 : {
941 0 : dumpTypeClass (bDump, typeClass, keyName);
942 : fprintf(stdout, " Reference %d: Doku1 = %s\n Doku2 = %s\n", index1,
943 : U2S(reader1.getReferenceDocumentation(index1)),
944 0 : U2S(reader2.getReferenceDocumentation(index2)));
945 : }
946 0 : nError++;
947 : }
948 0 : if ( reader1.getReferenceFlags(index1) != reader2.getReferenceFlags(index2) )
949 : {
950 0 : if ( options.forceOutput() && !options.unoTypeCheck() )
951 : {
952 0 : dumpTypeClass (bDump, typeClass, keyName);
953 : fprintf(stdout, " Reference %d: Access1 = %s != Access2 = %s\n", index1,
954 0 : getFieldAccess(reader1.getReferenceFlags(index1)).getStr(),
955 0 : getFieldAccess(reader1.getReferenceFlags(index2)).getStr());
956 : }
957 0 : nError++;
958 : }
959 0 : return nError;
960 : }
961 :
962 0 : static sal_uInt32 checkFieldsWithoutOrder(Options_Impl const & options,
963 : const OUString& keyName,
964 : RTTypeClass typeClass,
965 : bool & bDump,
966 : typereg::Reader& reader1,
967 : typereg::Reader& reader2)
968 : {
969 0 : sal_uInt32 nError = 0;
970 :
971 0 : sal_uInt16 nFields1 = (sal_uInt16)reader1.getFieldCount();
972 0 : sal_uInt16 nFields2 = (sal_uInt16)reader2.getFieldCount();
973 0 : sal_uInt16 i=0, j=0;
974 :
975 0 : if ( nFields1 > nFields2 )
976 : {
977 0 : if ( options.forceOutput() )
978 : {
979 0 : dumpTypeClass (bDump, typeClass, keyName);
980 : fprintf(stdout, " %s1 contains %d more properties as %s2\n",
981 0 : getTypeClass(typeClass), nFields1-nFields2, getTypeClass(typeClass));
982 : }
983 : }
984 :
985 0 : bool bFound = false;
986 0 : ::std::set< sal_uInt16 > moreProps;
987 :
988 0 : for (i=0; i < nFields1; i++)
989 : {
990 0 : for (j=0; j < nFields2; j++)
991 : {
992 0 : if (!checkField(options, keyName, typeClass, bDump, reader1, reader2, i, j, SILENT))
993 : {
994 0 : bFound = true;
995 0 : moreProps.insert(j);
996 0 : break;
997 : }
998 : }
999 0 : if (!bFound)
1000 : {
1001 0 : if (options.forceOutput())
1002 : {
1003 0 : dumpTypeClass (bDump, typeClass, keyName);
1004 : fprintf(stdout, " incompatible change: Field %d ('%s') of r1 is not longer a property of this %s in r2\n",
1005 0 : i, U2S(shortName(reader1.getFieldName(i))), getTypeClass(typeClass));
1006 : }
1007 0 : nError++;
1008 : }
1009 : else
1010 : {
1011 0 : bFound = false;
1012 : }
1013 : }
1014 :
1015 0 : if ( typeClass == RT_TYPE_SERVICE && !moreProps.empty() )
1016 : {
1017 0 : for (j=0; j < nFields2; j++)
1018 : {
1019 0 : if ( moreProps.find(j) == moreProps.end() )
1020 : {
1021 0 : if ( (reader2.getFieldFlags(j) & RT_ACCESS_OPTIONAL) != RT_ACCESS_OPTIONAL )
1022 : {
1023 0 : if ( options.forceOutput() )
1024 : {
1025 0 : dumpTypeClass (bDump, typeClass, keyName);
1026 : fprintf(stdout,
1027 : " incompatible change: Field %d ('%s') of r2 is a new property"
1028 : " compared to this %s in r1 and is not 'optional'\n",
1029 0 : j, U2S(shortName(reader2.getFieldName(j))), getTypeClass(typeClass));
1030 : }
1031 0 : nError++;
1032 : }
1033 : }
1034 : }
1035 : }
1036 :
1037 0 : return nError;
1038 : }
1039 :
1040 0 : static sal_uInt32 checkBlob(
1041 : Options_Impl const & options,
1042 : const OUString& keyName,
1043 : typereg::Reader& reader1, sal_uInt32 size1,
1044 : typereg::Reader& reader2, sal_uInt32 size2)
1045 : {
1046 0 : sal_uInt32 nError = 0;
1047 0 : bool bDump = true;
1048 :
1049 0 : if ( options.fullCheck() && (size1 != size2) )
1050 : {
1051 0 : if ( options.forceOutput() )
1052 : {
1053 : fprintf(
1054 : stdout, " Size1 = %lu Size2 = %lu\n",
1055 : sal::static_int_cast< unsigned long >(size1),
1056 0 : sal::static_int_cast< unsigned long >(size2));
1057 : }
1058 : }
1059 0 : if (reader1.isPublished())
1060 : {
1061 0 : if (!reader2.isPublished())
1062 : {
1063 0 : if (options.forceOutput())
1064 : {
1065 0 : dumpTypeClass(bDump, /*"?"*/ reader1.getTypeClass(), keyName);
1066 0 : fprintf(stdout, " published in 1 but unpublished in 2\n");
1067 : }
1068 0 : ++nError;
1069 : }
1070 : }
1071 0 : else if (!options.checkUnpublished())
1072 : {
1073 0 : return nError;
1074 : }
1075 0 : if ( reader1.getTypeClass() != reader2.getTypeClass() )
1076 : {
1077 0 : if ( options.forceOutput() )
1078 : {
1079 0 : dumpTypeClass(bDump, /*"?"*/ reader1.getTypeClass(), keyName);
1080 : fprintf(stdout, " TypeClass1 = %s != TypeClass2 = %s\n",
1081 : getTypeClass(reader1.getTypeClass()),
1082 0 : getTypeClass(reader2.getTypeClass()));
1083 : }
1084 0 : return ++nError;
1085 : }
1086 :
1087 0 : RTTypeClass typeClass = reader1.getTypeClass();
1088 0 : if ( reader1.getTypeName() != reader2.getTypeName() )
1089 : {
1090 0 : if ( options.forceOutput() )
1091 : {
1092 0 : dumpTypeClass(bDump, typeClass, keyName);
1093 : fprintf(stdout, " TypeName1 = %s != TypeName2 = %s\n",
1094 0 : U2S(reader1.getTypeName()), U2S(reader2.getTypeName()));
1095 : }
1096 0 : nError++;
1097 : }
1098 0 : if ( (typeClass == RT_TYPE_INTERFACE ||
1099 0 : typeClass == RT_TYPE_STRUCT ||
1100 : typeClass == RT_TYPE_EXCEPTION) )
1101 : {
1102 0 : if (reader1.getSuperTypeCount() != reader2.getSuperTypeCount())
1103 : {
1104 0 : dumpTypeClass(bDump, typeClass, keyName);
1105 : fprintf(
1106 : stdout, " SuperTypeCount1 = %d != SuperTypeCount2 = %d\n",
1107 0 : static_cast< int >(reader1.getSuperTypeCount()),
1108 0 : static_cast< int >(reader2.getSuperTypeCount()));
1109 0 : ++nError;
1110 : } else
1111 : {
1112 0 : for (sal_Int16 i = 0; i < reader1.getSuperTypeCount(); ++i)
1113 : {
1114 0 : if (reader1.getSuperTypeName(i) != reader2.getSuperTypeName(i))
1115 : {
1116 0 : if ( options.forceOutput() )
1117 : {
1118 0 : dumpTypeClass(bDump, typeClass, keyName);
1119 : fprintf(stdout, " SuperTypeName1 = %s != SuperTypeName2 = %s\n",
1120 0 : U2S(reader1.getSuperTypeName(i)), U2S(reader2.getSuperTypeName(i)));
1121 : }
1122 0 : nError++;
1123 : }
1124 : }
1125 : }
1126 : }
1127 :
1128 0 : sal_uInt16 nFields1 = (sal_uInt16)reader1.getFieldCount();
1129 0 : sal_uInt16 nFields2 = (sal_uInt16)reader2.getFieldCount();
1130 0 : bool bCheckNormal = true;
1131 :
1132 0 : if ( (typeClass == RT_TYPE_SERVICE ||
1133 0 : typeClass == RT_TYPE_MODULE ||
1134 0 : typeClass == RT_TYPE_CONSTANTS) && options.unoTypeCheck() )
1135 : {
1136 0 : bCheckNormal = false;
1137 : }
1138 :
1139 0 : if ( bCheckNormal )
1140 : {
1141 0 : if ( nFields1 != nFields2 )
1142 : {
1143 0 : if ( options.forceOutput() )
1144 : {
1145 0 : dumpTypeClass(bDump, typeClass, keyName);
1146 0 : fprintf(stdout, " nFields1 = %d != nFields2 = %d\n", nFields1, nFields2);
1147 : }
1148 0 : nError++;
1149 : }
1150 :
1151 : sal_uInt16 i;
1152 0 : for (i=0; i < nFields1 && i < nFields2; i++)
1153 : {
1154 0 : nError += checkField(options, keyName, typeClass, bDump, reader1, reader2, i, i, REPORT);
1155 : }
1156 0 : if ( i < nFields1 && options.forceOutput() )
1157 : {
1158 0 : dumpTypeClass(bDump, typeClass, keyName);
1159 0 : fprintf(stdout, " Registry1 contains %d more fields\n", nFields1 - i);
1160 : }
1161 0 : if ( i < nFields2 && options.forceOutput() )
1162 : {
1163 0 : dumpTypeClass(bDump, typeClass, keyName);
1164 0 : fprintf(stdout, " Registry2 contains %d more fields\n", nFields2 - i);
1165 : }
1166 : }
1167 : else
1168 : {
1169 0 : nError += checkFieldsWithoutOrder(options, keyName, typeClass, bDump, reader1, reader2);
1170 : }
1171 :
1172 0 : if ( typeClass == RT_TYPE_INTERFACE )
1173 : {
1174 0 : sal_uInt16 nMethods1 = (sal_uInt16)reader1.getMethodCount();
1175 0 : sal_uInt16 nMethods2 = (sal_uInt16)reader2.getMethodCount();
1176 0 : if ( nMethods1 != nMethods2 )
1177 : {
1178 0 : if ( options.forceOutput() )
1179 : {
1180 0 : dumpTypeClass(bDump, typeClass, keyName);
1181 0 : fprintf(stdout, " nMethods1 = %d != nMethods2 = %d\n", nMethods1, nMethods2);
1182 : }
1183 0 : nError++;
1184 : }
1185 :
1186 : sal_uInt16 i;
1187 0 : for (i=0; i < nMethods1 && i < nMethods2; i++)
1188 : {
1189 0 : nError += checkMethod(options, keyName, typeClass, bDump, reader1, reader2, i);
1190 : }
1191 0 : if ( i < nMethods1 && options.forceOutput() )
1192 : {
1193 0 : fprintf(stdout, " Registry1 contains %d more methods\n", nMethods1 - i);
1194 : }
1195 0 : if ( i < nMethods2 && options.forceOutput() )
1196 : {
1197 0 : fprintf(stdout, " Registry2 contains %d more methods\n", nMethods2 - i);
1198 : }
1199 : }
1200 0 : if ( typeClass == RT_TYPE_SERVICE )
1201 : {
1202 0 : sal_uInt16 nReference1 = (sal_uInt16)reader1.getReferenceCount();
1203 0 : sal_uInt16 nReference2 = (sal_uInt16)reader2.getReferenceCount();
1204 :
1205 0 : if ( !bCheckNormal )
1206 : {
1207 0 : sal_uInt16 i=0, j=0;
1208 :
1209 0 : if ( nReference1 > nReference2 )
1210 : {
1211 0 : if ( options.forceOutput() )
1212 : {
1213 0 : dumpTypeClass(bDump, typeClass, keyName);
1214 : fprintf(stdout, " service1 contains %d more references as service2\n",
1215 0 : nReference1-nReference2);
1216 : }
1217 : }
1218 :
1219 0 : bool bFound = false;
1220 0 : ::std::set< sal_uInt16 > moreReferences;
1221 :
1222 0 : for (i=0; i < nReference1; i++)
1223 : {
1224 0 : for (j=0; j < nReference2; j++)
1225 : {
1226 0 : if (!checkReference(options, keyName, typeClass, bDump, reader1, reader2, i, j))
1227 : {
1228 0 : bFound = true;
1229 0 : moreReferences.insert(j);
1230 0 : break;
1231 : }
1232 : }
1233 0 : if (!bFound)
1234 : {
1235 0 : if (options.forceOutput())
1236 : {
1237 0 : dumpTypeClass(bDump, typeClass, keyName);
1238 : fprintf(stdout,
1239 : " incompatible change: Reference %d ('%s') in 'r1' is not longer a reference"
1240 : " of this service in 'r2'\n",
1241 0 : i, U2S(shortName(reader1.getReferenceTypeName(i))));
1242 : }
1243 0 : nError++;
1244 : }
1245 : else
1246 : {
1247 0 : bFound = false;
1248 : }
1249 : }
1250 :
1251 0 : if ( !moreReferences.empty() )
1252 : {
1253 0 : for (j=0; j < nReference2; j++)
1254 : {
1255 0 : if ( moreReferences.find(j) == moreReferences.end() )
1256 : {
1257 0 : if ( (reader2.getReferenceFlags(j) & RT_ACCESS_OPTIONAL) != RT_ACCESS_OPTIONAL )
1258 : {
1259 0 : if ( options.forceOutput() )
1260 : {
1261 0 : dumpTypeClass(bDump, typeClass, keyName);
1262 : fprintf(stdout,
1263 : " incompatible change: Reference %d ('%s') of r2 is a new reference"
1264 : " compared to this service in r1 and is not 'optional'\n",
1265 0 : j, U2S(shortName(reader2.getReferenceTypeName(j))));
1266 : }
1267 0 : nError++;
1268 : }
1269 : }
1270 : }
1271 0 : }
1272 : }
1273 : else
1274 : {
1275 0 : if ( nReference1 != nReference2 )
1276 : {
1277 0 : if ( options.forceOutput() )
1278 : {
1279 0 : dumpTypeClass(bDump, typeClass, keyName);
1280 0 : fprintf(stdout, " nReferences1 = %d != nReferences2 = %d\n", nReference1, nReference2);
1281 : }
1282 0 : nError++;
1283 : }
1284 :
1285 : sal_uInt16 i;
1286 0 : for (i=0; i < nReference1 && i < nReference2; i++)
1287 : {
1288 0 : nError += checkReference(options, keyName, typeClass, bDump, reader1, reader2, i, i);
1289 : }
1290 0 : if ( i < nReference1 && options.forceOutput() )
1291 : {
1292 0 : fprintf(stdout, " Registry1 contains %d more references\n", nReference1 - i);
1293 : }
1294 0 : if ( i < nReference2 && options.forceOutput() )
1295 : {
1296 0 : fprintf(stdout, " Registry2 contains %d more references\n", nReference2 - i);
1297 : }
1298 : }
1299 : }
1300 :
1301 0 : if ( options.fullCheck() && (reader1.getDocumentation() != reader2.getDocumentation()) )
1302 : {
1303 0 : if ( options.forceOutput() )
1304 : {
1305 0 : dumpTypeClass(bDump, typeClass, keyName);
1306 : fprintf(stdout, " Doku1 = %s\n Doku2 = %s\n",
1307 0 : U2S(reader1.getDocumentation()), U2S(reader2.getDocumentation()));
1308 : }
1309 0 : nError++;
1310 : }
1311 0 : return nError;
1312 : }
1313 :
1314 0 : static sal_uInt32 checkValueDifference(
1315 : Options_Impl const & options,
1316 : RegistryKey& key1, RegValueType valueType1, sal_uInt32 size1,
1317 : RegistryKey& key2, RegValueType valueType2, sal_uInt32 size2)
1318 : {
1319 0 : OUString tmpName;
1320 0 : sal_uInt32 nError = 0;
1321 :
1322 0 : if ( valueType1 == valueType2 )
1323 : {
1324 0 : bool bEqual = true;
1325 0 : switch (valueType1)
1326 : {
1327 : case RG_VALUETYPE_LONGLIST:
1328 : {
1329 0 : RegistryValueList<sal_Int32> valueList1;
1330 0 : RegistryValueList<sal_Int32> valueList2;
1331 0 : key1.getLongListValue(tmpName, valueList1);
1332 0 : key2.getLongListValue(tmpName, valueList2);
1333 0 : sal_uInt32 length1 = valueList1.getLength();
1334 0 : sal_uInt32 length2 = valueList1.getLength();
1335 0 : if ( length1 != length2 )
1336 : {
1337 0 : bEqual = false;
1338 0 : break;
1339 : }
1340 0 : for (sal_uInt32 i=0; i<length1; i++)
1341 : {
1342 0 : if ( valueList1.getElement(i) != valueList2.getElement(i) )
1343 : {
1344 0 : bEqual = false;
1345 0 : break;
1346 : }
1347 0 : }
1348 : }
1349 0 : break;
1350 : case RG_VALUETYPE_STRINGLIST:
1351 : {
1352 0 : RegistryValueList<sal_Char*> valueList1;
1353 0 : RegistryValueList<sal_Char*> valueList2;
1354 0 : key1.getStringListValue(tmpName, valueList1);
1355 0 : key2.getStringListValue(tmpName, valueList2);
1356 0 : sal_uInt32 length1 = valueList1.getLength();
1357 0 : sal_uInt32 length2 = valueList1.getLength();
1358 0 : if ( length1 != length2 )
1359 : {
1360 0 : bEqual = false;
1361 0 : break;
1362 : }
1363 0 : for (sal_uInt32 i=0; i<length1; i++)
1364 : {
1365 0 : if ( strcmp(valueList1.getElement(i), valueList2.getElement(i)) != 0 )
1366 : {
1367 0 : bEqual = false;
1368 0 : break;
1369 : }
1370 0 : }
1371 : }
1372 0 : break;
1373 : case RG_VALUETYPE_UNICODELIST:
1374 : {
1375 0 : RegistryValueList<sal_Unicode*> valueList1;
1376 0 : RegistryValueList<sal_Unicode*> valueList2;
1377 0 : key1.getUnicodeListValue(tmpName, valueList1);
1378 0 : key2.getUnicodeListValue(tmpName, valueList2);
1379 0 : sal_uInt32 length1 = valueList1.getLength();
1380 0 : sal_uInt32 length2 = valueList1.getLength();
1381 0 : if ( length1 != length2 )
1382 : {
1383 0 : bEqual = false;
1384 0 : break;
1385 : }
1386 0 : for (sal_uInt32 i=0; i<length1; i++)
1387 : {
1388 0 : if ( rtl_ustr_compare(valueList1.getElement(i), valueList2.getElement(i)) != 0 )
1389 : {
1390 0 : bEqual = false;
1391 0 : break;
1392 : }
1393 0 : }
1394 : }
1395 0 : break;
1396 : default:
1397 0 : break;
1398 : }
1399 :
1400 0 : if ( bEqual)
1401 : {
1402 0 : std::vector< sal_uInt8 > value1(size1);
1403 0 : key1.getValue(tmpName, &value1[0]);
1404 :
1405 0 : std::vector< sal_uInt8 > value2(size2);
1406 0 : key2.getValue(tmpName, &value2[0]);
1407 :
1408 0 : bEqual = (memcmp(&value1[0], &value2[0], value1.size()) == 0 );
1409 0 : if ( !bEqual && valueType1 == RG_VALUETYPE_BINARY && valueType2 == RG_VALUETYPE_BINARY )
1410 : {
1411 0 : typereg::Reader reader1(&value1[0], value1.size(), false, TYPEREG_VERSION_1);
1412 0 : typereg::Reader reader2(&value2[0], value2.size(), false, TYPEREG_VERSION_1);
1413 0 : if ( reader1.isValid() && reader2.isValid() )
1414 : {
1415 0 : return checkBlob(options, key1.getName(), reader1, size1, reader2, size2);
1416 0 : }
1417 : }
1418 0 : if ( bEqual )
1419 : {
1420 0 : return 0;
1421 : }
1422 : else
1423 : {
1424 0 : if ( options.forceOutput() )
1425 : {
1426 0 : fprintf(stdout, "Difference: key values of key \"%s\" are different\n", U2S(key1.getName()));
1427 : }
1428 0 : nError++;
1429 0 : }
1430 : }
1431 : }
1432 :
1433 0 : if ( options.forceOutput() )
1434 : {
1435 0 : switch (valueType1)
1436 : {
1437 : case RG_VALUETYPE_NOT_DEFINED:
1438 0 : fprintf(stdout, " Registry 1: key has no value\n");
1439 0 : break;
1440 : case RG_VALUETYPE_LONG:
1441 : {
1442 0 : std::vector< sal_uInt8 > value1(size1);
1443 0 : key1.getValue(tmpName, &value1[0]);
1444 :
1445 0 : fprintf(stdout, " Registry 1: Value: Type = RG_VALUETYPE_LONG\n");
1446 : fprintf(
1447 : stdout, " Size = %lu\n",
1448 0 : sal::static_int_cast< unsigned long >(size1));
1449 0 : fprintf(stdout, " Data = %p\n", &value1[0]);
1450 : }
1451 0 : break;
1452 : case RG_VALUETYPE_STRING:
1453 : {
1454 0 : std::vector< sal_uInt8 > value1(size1);
1455 0 : key1.getValue(tmpName, &value1[0]);
1456 :
1457 0 : fprintf(stdout, " Registry 1: Value: Type = RG_VALUETYPE_STRING\n");
1458 : fprintf(
1459 : stdout, " Size = %lu\n",
1460 0 : sal::static_int_cast< unsigned long >(size1));
1461 0 : fprintf(stdout, " Data = \"%s\"\n", reinterpret_cast<char const*>(&value1[0]));
1462 : }
1463 0 : break;
1464 : case RG_VALUETYPE_UNICODE:
1465 : {
1466 0 : std::vector< sal_uInt8 > value1(size1);
1467 0 : key1.getValue(tmpName, &value1[0]);
1468 :
1469 0 : OUString uStrValue(reinterpret_cast<sal_Unicode const*>(&value1[0]));
1470 0 : fprintf(stdout, " Registry 1: Value: Type = RG_VALUETYPE_UNICODE\n");
1471 : fprintf(
1472 : stdout, " Size = %lu\n",
1473 0 : sal::static_int_cast< unsigned long >(size1));
1474 0 : fprintf(stdout, " Data = \"%s\"\n", U2S(uStrValue));
1475 : }
1476 0 : break;
1477 : case RG_VALUETYPE_BINARY:
1478 0 : fprintf(stdout, " Registry 1: Value: Type = RG_VALUETYPE_BINARY\n");
1479 0 : break;
1480 : case RG_VALUETYPE_LONGLIST:
1481 : {
1482 0 : RegistryValueList<sal_Int32> valueList;
1483 0 : key1.getLongListValue(tmpName, valueList);
1484 0 : fprintf(stdout, " Registry 1: Value: Type = RG_VALUETYPE_LONGLIST\n");
1485 : fprintf(
1486 : stdout, " Size = %lu\n",
1487 0 : sal::static_int_cast< unsigned long >(size1));
1488 0 : sal_uInt32 length = valueList.getLength();
1489 0 : for (sal_uInt32 i=0; i<length; i++)
1490 : {
1491 : fprintf(
1492 : stdout, " Data[%lu] = %ld\n",
1493 : sal::static_int_cast< unsigned long >(i),
1494 0 : sal::static_int_cast< long >(valueList.getElement(i)));
1495 0 : }
1496 : }
1497 0 : break;
1498 : case RG_VALUETYPE_STRINGLIST:
1499 : {
1500 0 : RegistryValueList<sal_Char*> valueList;
1501 0 : key1.getStringListValue(tmpName, valueList);
1502 0 : fprintf(stdout, " Registry 1: Value: Type = RG_VALUETYPE_STRINGLIST\n");
1503 : fprintf(
1504 : stdout, " Size = %lu\n",
1505 0 : sal::static_int_cast< unsigned long >(size1));
1506 0 : sal_uInt32 length = valueList.getLength();
1507 0 : for (sal_uInt32 i=0; i<length; i++)
1508 : {
1509 : fprintf(
1510 : stdout, " Data[%lu] = \"%s\"\n",
1511 : sal::static_int_cast< unsigned long >(i),
1512 0 : valueList.getElement(i));
1513 0 : }
1514 : }
1515 0 : break;
1516 : case RG_VALUETYPE_UNICODELIST:
1517 : {
1518 0 : RegistryValueList<sal_Unicode*> valueList;
1519 0 : key1.getUnicodeListValue(tmpName, valueList);
1520 0 : fprintf(stdout, " Registry 1: Value: Type = RG_VALUETYPE_UNICODELIST\n");
1521 : fprintf(
1522 : stdout, " Size = %lu\n",
1523 0 : sal::static_int_cast< unsigned long >(size1));
1524 0 : sal_uInt32 length = valueList.getLength();
1525 0 : OUString uStrValue;
1526 0 : for (sal_uInt32 i=0; i<length; i++)
1527 : {
1528 0 : uStrValue = OUString(valueList.getElement(i));
1529 : fprintf(
1530 : stdout, " Data[%lu] = \"%s\"\n",
1531 0 : sal::static_int_cast< unsigned long >(i), U2S(uStrValue));
1532 0 : }
1533 : }
1534 0 : break;
1535 : }
1536 :
1537 0 : switch (valueType2)
1538 : {
1539 : case RG_VALUETYPE_NOT_DEFINED:
1540 0 : fprintf(stdout, " Registry 2: key has no value\n");
1541 0 : break;
1542 : case RG_VALUETYPE_LONG:
1543 : {
1544 0 : std::vector< sal_uInt8 > value2(size2);
1545 0 : key2.getValue(tmpName, &value2[0]);
1546 :
1547 0 : fprintf(stdout, " Registry 2: Value: Type = RG_VALUETYPE_LONG\n");
1548 : fprintf(
1549 : stdout, " Size = %lu\n",
1550 0 : sal::static_int_cast< unsigned long >(size2));
1551 0 : fprintf(stdout, " Data = %p\n", &value2[0]);
1552 : }
1553 0 : break;
1554 : case RG_VALUETYPE_STRING:
1555 : {
1556 0 : std::vector< sal_uInt8 > value2(size2);
1557 0 : key2.getValue(tmpName, &value2[0]);
1558 :
1559 0 : fprintf(stdout, " Registry 2: Value: Type = RG_VALUETYPE_STRING\n");
1560 : fprintf(
1561 : stdout, " Size = %lu\n",
1562 0 : sal::static_int_cast< unsigned long >(size2));
1563 0 : fprintf(stdout, " Data = \"%s\"\n", reinterpret_cast<char const*>(&value2[0]));
1564 : }
1565 0 : break;
1566 : case RG_VALUETYPE_UNICODE:
1567 : {
1568 0 : std::vector< sal_uInt8 > value2(size2);
1569 0 : key2.getValue(tmpName, &value2[0]);
1570 :
1571 0 : OUString uStrValue(reinterpret_cast<sal_Unicode const*>(&value2[0]));
1572 0 : fprintf(stdout, " Registry 2: Value: Type = RG_VALUETYPE_UNICODE\n");
1573 : fprintf(
1574 : stdout, " Size = %lu\n",
1575 0 : sal::static_int_cast< unsigned long >(size2));
1576 0 : fprintf(stdout, " Data = \"%s\"\n", U2S(uStrValue));
1577 : }
1578 0 : break;
1579 : case RG_VALUETYPE_BINARY:
1580 0 : fprintf(stdout, " Registry 2: Value: Type = RG_VALUETYPE_BINARY\n");
1581 0 : break;
1582 : case RG_VALUETYPE_LONGLIST:
1583 : {
1584 0 : RegistryValueList<sal_Int32> valueList;
1585 0 : key2.getLongListValue(tmpName, valueList);
1586 0 : fprintf(stdout, " Registry 2: Value: Type = RG_VALUETYPE_LONGLIST\n");
1587 : fprintf(
1588 : stdout, " Size = %lu\n",
1589 0 : sal::static_int_cast< unsigned long >(size2));
1590 0 : sal_uInt32 length = valueList.getLength();
1591 0 : for (sal_uInt32 i=0; i<length; i++)
1592 : {
1593 : fprintf(
1594 : stdout, " Data[%lu] = %ld\n",
1595 : sal::static_int_cast< unsigned long >(i),
1596 0 : sal::static_int_cast< long >(valueList.getElement(i)));
1597 0 : }
1598 : }
1599 0 : break;
1600 : case RG_VALUETYPE_STRINGLIST:
1601 : {
1602 0 : RegistryValueList<sal_Char*> valueList;
1603 0 : key2.getStringListValue(tmpName, valueList);
1604 0 : fprintf(stdout, " Registry 2: Value: Type = RG_VALUETYPE_STRINGLIST\n");
1605 : fprintf(
1606 : stdout, " Size = %lu\n",
1607 0 : sal::static_int_cast< unsigned long >(size2));
1608 0 : sal_uInt32 length = valueList.getLength();
1609 0 : for (sal_uInt32 i=0; i<length; i++)
1610 : {
1611 : fprintf(
1612 : stdout, " Data[%lu] = \"%s\"\n",
1613 : sal::static_int_cast< unsigned long >(i),
1614 0 : valueList.getElement(i));
1615 0 : }
1616 : }
1617 0 : break;
1618 : case RG_VALUETYPE_UNICODELIST:
1619 : {
1620 0 : RegistryValueList<sal_Unicode*> valueList;
1621 0 : key2.getUnicodeListValue(tmpName, valueList);
1622 0 : fprintf(stdout, " Registry 2: Value: Type = RG_VALUETYPE_UNICODELIST\n");
1623 : fprintf(
1624 : stdout, " Size = %lu\n",
1625 0 : sal::static_int_cast< unsigned long >(size2));
1626 0 : sal_uInt32 length = valueList.getLength();
1627 0 : OUString uStrValue;
1628 0 : for (sal_uInt32 i=0; i<length; i++)
1629 : {
1630 0 : uStrValue = OUString(valueList.getElement(i));
1631 : fprintf(
1632 : stdout, " Data[%lu] = \"%s\"\n",
1633 0 : sal::static_int_cast< unsigned long >(i), U2S(uStrValue));
1634 0 : }
1635 : }
1636 0 : break;
1637 : }
1638 : }
1639 0 : return nError;
1640 : }
1641 :
1642 0 : static bool hasPublishedChildren(Options_Impl const & options, RegistryKey & key)
1643 : {
1644 0 : RegistryKeyNames subKeyNames;
1645 0 : key.getKeyNames(OUString(), subKeyNames);
1646 0 : for (sal_uInt32 i = 0; i < subKeyNames.getLength(); ++i)
1647 : {
1648 0 : OUString keyName(subKeyNames.getElement(i));
1649 0 : if (!options.matchedWithExcludeKey(keyName))
1650 : {
1651 0 : keyName = keyName.copy(keyName.lastIndexOf('/') + 1);
1652 0 : RegistryKey subKey;
1653 0 : if (!key.openKey(keyName, subKey))
1654 : {
1655 0 : if (options.forceOutput())
1656 : {
1657 : fprintf(
1658 : stdout,
1659 : ("WARNING: could not open key \"%s\" in registry"
1660 : " \"%s\"\n"),
1661 : U2S(subKeyNames.getElement(i)),
1662 0 : options.getRegName1().c_str());
1663 : }
1664 : }
1665 0 : if (subKey.isValid())
1666 : {
1667 : RegValueType type;
1668 : sal_uInt32 size;
1669 0 : if (subKey.getValueInfo(OUString(), &type, &size) != REG_NO_ERROR)
1670 : {
1671 0 : if (options.forceOutput())
1672 : {
1673 : fprintf(
1674 : stdout,
1675 : ("WARNING: could not read key \"%s\" in registry"
1676 : " \"%s\"\n"),
1677 : U2S(subKeyNames.getElement(i)),
1678 0 : options.getRegName1().c_str());
1679 : }
1680 : }
1681 0 : else if (type == RG_VALUETYPE_BINARY)
1682 : {
1683 0 : bool published = false;
1684 0 : std::vector< sal_uInt8 > value(size);
1685 0 : if (subKey.getValue(OUString(), &value[0]) != REG_NO_ERROR)
1686 : {
1687 0 : if (options.forceOutput())
1688 : {
1689 : fprintf(
1690 : stdout,
1691 : ("WARNING: could not read key \"%s\" in"
1692 : " registry \"%s\"\n"),
1693 : U2S(subKeyNames.getElement(i)),
1694 0 : options.getRegName1().c_str());
1695 : }
1696 : }
1697 : else
1698 : {
1699 0 : published = typereg::Reader(&value[0], value.size(), false, TYPEREG_VERSION_1).isPublished();
1700 : }
1701 0 : if (published)
1702 : {
1703 0 : return true;
1704 0 : }
1705 : }
1706 0 : }
1707 : }
1708 0 : }
1709 0 : return false;
1710 : }
1711 :
1712 0 : static sal_uInt32 checkDifferences(
1713 : Options_Impl const & options,
1714 : RegistryKey& key, StringSet& keys,
1715 : RegistryKeyNames& subKeyNames1,
1716 : RegistryKeyNames& subKeyNames2)
1717 : {
1718 0 : sal_uInt32 nError = 0;
1719 0 : sal_uInt32 length1 = subKeyNames1.getLength();
1720 0 : sal_uInt32 length2 = subKeyNames2.getLength();
1721 : sal_uInt32 i,j;
1722 :
1723 0 : for (i=0; i<length1; i++)
1724 : {
1725 0 : bool bFound = false;
1726 0 : for (j=0; j<length2; j++)
1727 : {
1728 0 : if ( subKeyNames1.getElement(i) == subKeyNames2.getElement(j) )
1729 : {
1730 0 : bFound = true;
1731 0 : keys.insert(subKeyNames1.getElement(i));
1732 0 : break;
1733 : }
1734 : }
1735 0 : if ( !bFound )
1736 : {
1737 0 : if ( options.fullCheck() )
1738 : {
1739 0 : if ( options.forceOutput() )
1740 : {
1741 : fprintf(stdout, "EXISTENCE: key \"%s\" exists only in registry \"%s\"\n",
1742 0 : U2S(subKeyNames1.getElement(i)), options.getRegName1().c_str());
1743 : }
1744 0 : nError++;
1745 : }
1746 : else
1747 : {
1748 0 : OUString keyName(subKeyNames1.getElement(i));
1749 0 : if (!options.matchedWithExcludeKey(keyName))
1750 : {
1751 0 : keyName = keyName.copy(keyName.lastIndexOf('/') + 1);
1752 0 : RegistryKey subKey;
1753 0 : if (key.openKey(keyName, subKey))
1754 : {
1755 0 : if (options.forceOutput())
1756 : {
1757 : fprintf(
1758 : stdout,
1759 : ("ERROR: could not open key \"%s\" in registry"
1760 : " \"%s\"\n"),
1761 : U2S(subKeyNames1.getElement(i)),
1762 0 : options.getRegName1().c_str());
1763 : }
1764 0 : ++nError;
1765 : }
1766 0 : if (subKey.isValid())
1767 : {
1768 : RegValueType type;
1769 : sal_uInt32 size;
1770 0 : if (subKey.getValueInfo(OUString(), &type, &size) != REG_NO_ERROR)
1771 : {
1772 0 : if (options.forceOutput())
1773 : {
1774 : fprintf(
1775 : stdout,
1776 : ("ERROR: could not read key \"%s\" in"
1777 : " registry \"%s\"\n"),
1778 : U2S(subKeyNames1.getElement(i)),
1779 0 : options.getRegName1().c_str());
1780 : }
1781 0 : ++nError;
1782 : }
1783 0 : else if (type == RG_VALUETYPE_BINARY)
1784 : {
1785 0 : std::vector< sal_uInt8 > value(size);
1786 0 : if (subKey.getValue(OUString(), &value[0]) != REG_NO_ERROR)
1787 : {
1788 0 : if (options.forceOutput())
1789 : {
1790 : fprintf(
1791 : stdout,
1792 : ("ERROR: could not read key \"%s\" in"
1793 : " registry \"%s\"\n"),
1794 : U2S(subKeyNames1.getElement(i)),
1795 0 : options.getRegName1().c_str());
1796 : }
1797 0 : ++nError;
1798 : }
1799 : else
1800 : {
1801 0 : typereg::Reader reader(&value[0], value.size(), false, TYPEREG_VERSION_1);
1802 0 : if (reader.getTypeClass() == RT_TYPE_MODULE)
1803 : {
1804 0 : if (options.checkUnpublished() || hasPublishedChildren(options, subKey))
1805 : {
1806 0 : if (options.forceOutput())
1807 : {
1808 : fprintf(
1809 : stdout,
1810 : ("EXISTENCE: module \"%s\""
1811 : " %sexists only in registry"
1812 : " 1\n"),
1813 : U2S(subKeyNames1.getElement(i)),
1814 0 : (options.checkUnpublished()
1815 : ? ""
1816 0 : : "with published children "));
1817 : }
1818 0 : ++nError;
1819 : }
1820 : }
1821 0 : else if (options.checkUnpublished() || reader.isPublished())
1822 : {
1823 0 : if (options.forceOutput())
1824 : {
1825 : fprintf(
1826 : stdout,
1827 : ("EXISTENCE: %spublished key \"%s\""
1828 : " exists only in registry 1\n"),
1829 0 : reader.isPublished() ? "" : "un",
1830 0 : U2S(subKeyNames1.getElement(i)));
1831 : }
1832 0 : ++nError;
1833 0 : }
1834 0 : }
1835 : }
1836 0 : }
1837 0 : }
1838 : }
1839 : }
1840 : }
1841 :
1842 0 : for (i=0; i<length2; i++)
1843 : {
1844 0 : bool bFound = false;
1845 0 : for (j=0; j<length1; j++)
1846 : {
1847 0 : if ( subKeyNames2.getElement(i) == subKeyNames1.getElement(j) )
1848 : {
1849 0 : bFound = true;
1850 0 : keys.insert(subKeyNames2.getElement(i));
1851 0 : break;
1852 : }
1853 : }
1854 0 : if ( !bFound && options.fullCheck() )
1855 : {
1856 0 : if ( options.forceOutput() )
1857 : {
1858 : fprintf(stdout, "EXISTENCE: key \"%s\" exists only in registry \"%s\"\n",
1859 0 : U2S(subKeyNames2.getElement(i)), options.getRegName2().c_str());
1860 : }
1861 0 : nError++;
1862 : }
1863 : }
1864 0 : return nError;
1865 : }
1866 :
1867 0 : static sal_uInt32 compareKeys(
1868 : Options_Impl const & options,
1869 : RegistryKey& key1,
1870 : RegistryKey& key2)
1871 : {
1872 0 : sal_uInt32 nError = 0;
1873 :
1874 0 : RegValueType valueType1 = RG_VALUETYPE_NOT_DEFINED;
1875 0 : RegValueType valueType2 = RG_VALUETYPE_NOT_DEFINED;
1876 0 : sal_uInt32 size1 = 0;
1877 0 : sal_uInt32 size2 = 0;
1878 :
1879 0 : OUString tmpName;
1880 0 : RegError e1 = key1.getValueInfo(tmpName, &valueType1, &size1);
1881 0 : RegError e2 = key2.getValueInfo(tmpName, &valueType2, &size2);
1882 0 : if ( (e1 == e2) && (e1 != REG_VALUE_NOT_EXISTS) && (e1 != REG_INVALID_VALUE) )
1883 : {
1884 0 : nError += checkValueDifference(options, key1, valueType1, size1, key2, valueType2, size2);
1885 : }
1886 : else
1887 : {
1888 0 : if ( (e1 != REG_INVALID_VALUE) || (e2 != REG_INVALID_VALUE) )
1889 : {
1890 0 : if ( options.forceOutput() )
1891 : {
1892 0 : fprintf(stdout, "VALUES: key values of key \"%s\" are different\n", U2S(key1.getName()));
1893 : }
1894 0 : nError++;
1895 : }
1896 : }
1897 :
1898 0 : RegistryKeyNames subKeyNames1;
1899 0 : RegistryKeyNames subKeyNames2;
1900 :
1901 0 : key1.getKeyNames(tmpName, subKeyNames1);
1902 0 : key2.getKeyNames(tmpName, subKeyNames2);
1903 :
1904 0 : StringSet keys;
1905 0 : nError += checkDifferences(options, key1, keys, subKeyNames1, subKeyNames2);
1906 :
1907 0 : StringSet::iterator iter = keys.begin();
1908 0 : StringSet::iterator end = keys.end();
1909 :
1910 0 : while ( iter != end )
1911 : {
1912 0 : OUString keyName(*iter);
1913 0 : if ( options.matchedWithExcludeKey(keyName) )
1914 : {
1915 0 : ++iter;
1916 0 : continue;
1917 : }
1918 :
1919 0 : sal_Int32 nPos = keyName.lastIndexOf( '/' );
1920 0 : keyName = keyName.copy( nPos != -1 ? nPos+1 : 0 );
1921 :
1922 0 : RegistryKey subKey1;
1923 0 : if ( key1.openKey(keyName, subKey1) )
1924 : {
1925 0 : if ( options.forceOutput() )
1926 : {
1927 : fprintf(stdout, "ERROR: could not open key \"%s\" in registry \"%s\"\n",
1928 0 : U2S(*iter), options.getRegName1().c_str());
1929 : }
1930 0 : nError++;
1931 : }
1932 :
1933 0 : RegistryKey subKey2;
1934 0 : if ( key2.openKey(keyName, subKey2) )
1935 : {
1936 0 : if ( options.forceOutput() )
1937 : {
1938 : fprintf(stdout, "ERROR: could not open key \"%s\" in registry \"%s\"\n",
1939 0 : U2S(*iter), options.getRegName2().c_str());
1940 : }
1941 0 : nError++;
1942 : }
1943 :
1944 0 : if ( subKey1.isValid() && subKey2.isValid() )
1945 : {
1946 0 : nError += compareKeys(options, subKey1, subKey2);
1947 : }
1948 0 : ++iter;
1949 0 : }
1950 :
1951 0 : return nError;
1952 : }
1953 :
1954 : #if (defined UNX) || defined __MINGW32__
1955 0 : int main( int argc, char * argv[] )
1956 : #else
1957 : int _cdecl main( int argc, char * argv[] )
1958 : #endif
1959 : {
1960 0 : std::vector< std::string > args;
1961 :
1962 0 : Options_Impl options(argv[0]);
1963 0 : for (int i = 1; i < argc; i++)
1964 : {
1965 0 : if (!Options::checkArgument(args, argv[i], strlen(argv[i])))
1966 : {
1967 : // failure.
1968 0 : options.printUsage();
1969 0 : return (1);
1970 : }
1971 : }
1972 0 : if (!options.initOptions(args))
1973 : {
1974 0 : return (1);
1975 : }
1976 :
1977 0 : OUString regName1( convertToFileUrl(options.getRegName1().c_str(), options.getRegName1().size()) );
1978 0 : OUString regName2( convertToFileUrl(options.getRegName2().c_str(), options.getRegName2().size()) );
1979 :
1980 0 : Registry reg1, reg2;
1981 0 : if ( reg1.open(regName1, REG_READONLY) )
1982 : {
1983 : fprintf(stdout, "%s: open registry \"%s\" failed\n",
1984 0 : options.getProgramName().c_str(), options.getRegName1().c_str());
1985 0 : return (2);
1986 : }
1987 0 : if ( reg2.open(regName2, REG_READONLY) )
1988 : {
1989 : fprintf(stdout, "%s: open registry \"%s\" failed\n",
1990 0 : options.getProgramName().c_str(), options.getRegName2().c_str());
1991 0 : return (3);
1992 : }
1993 :
1994 0 : RegistryKey key1, key2;
1995 0 : if ( reg1.openRootKey(key1) )
1996 : {
1997 : fprintf(stdout, "%s: open root key of registry \"%s\" failed\n",
1998 0 : options.getProgramName().c_str(), options.getRegName1().c_str());
1999 0 : return (4);
2000 : }
2001 0 : if ( reg2.openRootKey(key2) )
2002 : {
2003 : fprintf(stdout, "%s: open root key of registry \"%s\" failed\n",
2004 0 : options.getProgramName().c_str(), options.getRegName2().c_str());
2005 0 : return (5);
2006 : }
2007 :
2008 0 : if ( options.isStartKeyValid() )
2009 : {
2010 0 : if ( options.matchedWithExcludeKey( options.getStartKey() ) )
2011 : {
2012 : fprintf(stdout, "%s: start key is equal to one of the exclude keys\n",
2013 0 : options.getProgramName().c_str());
2014 0 : return (6);
2015 : }
2016 0 : RegistryKey sk1, sk2;
2017 0 : if ( key1.openKey(options.getStartKey(), sk1) )
2018 : {
2019 : fprintf(stdout, "%s: open start key of registry \"%s\" failed\n",
2020 0 : options.getProgramName().c_str(), options.getRegName1().c_str());
2021 0 : return (7);
2022 : }
2023 0 : if ( key2.openKey(options.getStartKey(), sk2) )
2024 : {
2025 : fprintf(stdout, "%s: open start key of registry \"%s\" failed\n",
2026 0 : options.getProgramName().c_str(), options.getRegName2().c_str());
2027 0 : return (8);
2028 : }
2029 :
2030 0 : key1 = sk1;
2031 0 : key2 = sk2;
2032 : }
2033 :
2034 0 : sal_uInt32 nError = compareKeys(options, key1, key2);
2035 0 : if ( nError )
2036 : {
2037 0 : if ( options.unoTypeCheck() )
2038 : {
2039 : fprintf(stdout, "%s: registries are incompatible: %lu differences!\n",
2040 0 : options.getProgramName().c_str(),
2041 0 : sal::static_int_cast< unsigned long >(nError));
2042 : }
2043 : else
2044 : {
2045 : fprintf(stdout, "%s: registries contain %lu differences!\n",
2046 0 : options.getProgramName().c_str(),
2047 0 : sal::static_int_cast< unsigned long >(nError));
2048 : }
2049 : }
2050 :
2051 0 : key1.releaseKey();
2052 0 : key2.releaseKey();
2053 0 : if ( reg1.close() )
2054 : {
2055 : fprintf(stdout, "%s: closing registry \"%s\" failed\n",
2056 0 : options.getProgramName().c_str(), options.getRegName1().c_str());
2057 0 : return (9);
2058 : }
2059 0 : if ( reg2.close() )
2060 : {
2061 : fprintf(stdout, "%s: closing registry \"%s\" failed\n",
2062 0 : options.getProgramName().c_str(), options.getRegName2().c_str());
2063 0 : return (10);
2064 : }
2065 :
2066 0 : return ((nError > 0) ? 11 : 0);
2067 : }
2068 :
2069 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
