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 : #ifndef EQ_HXX
20 : #define EQ_HXX
21 :
22 : #include <math.h>
23 :
24 : #include "prim.hxx"
25 : #include "destr.hxx"
26 :
27 :
28 : namespace cppu
29 : {
30 :
31 : //##################################################################################################
32 : //#### equality ####################################################################################
33 : //##################################################################################################
34 :
35 : //--------------------------------------------------------------------------------------------------
36 208 : inline sal_Bool _equalObject(
37 : void * pI1, void * pI2,
38 : uno_QueryInterfaceFunc queryInterface, uno_ReleaseFunc release )
39 : SAL_THROW(())
40 : {
41 208 : if (pI1 == pI2)
42 206 : return sal_True;
43 2 : if ((0 == pI1) || (0 == pI2))
44 0 : return sal_False;
45 2 : sal_Bool bRet = sal_False;
46 :
47 : typelib_TypeDescriptionReference * type_XInterface =
48 2 : * typelib_static_type_getByTypeClass( typelib_TypeClass_INTERFACE );
49 2 : if (0 == queryInterface)
50 0 : queryInterface = binuno_queryInterface;
51 2 : pI1 = (*queryInterface)( pI1, type_XInterface );
52 2 : if (0 != pI1)
53 : {
54 2 : pI2 = (*queryInterface)( pI2, type_XInterface );
55 2 : if (0 != pI2)
56 : {
57 2 : bRet = (pI1 == pI2);
58 2 : _release( pI2, release );
59 : }
60 2 : _release( pI1, release );
61 : }
62 2 : return bRet;
63 : }
64 :
65 : //==================================================================================================
66 : sal_Bool equalStruct(
67 : void * pDest, void *pSource,
68 : typelib_CompoundTypeDescription * pTypeDescr,
69 : uno_QueryInterfaceFunc queryInterface, uno_ReleaseFunc release )
70 : SAL_THROW(());
71 : //--------------------------------------------------------------------------------------------------
72 80909 : inline sal_Bool _equalStruct(
73 : void * pDest, void *pSource,
74 : typelib_CompoundTypeDescription * pTypeDescr,
75 : uno_QueryInterfaceFunc queryInterface, uno_ReleaseFunc release )
76 : SAL_THROW(())
77 : {
78 80973 : if (pTypeDescr->pBaseTypeDescription &&
79 64 : !equalStruct( pDest, pSource, pTypeDescr->pBaseTypeDescription, queryInterface, release ))
80 : {
81 0 : return sal_False;
82 : }
83 :
84 80909 : typelib_TypeDescriptionReference ** ppTypeRefs = pTypeDescr->ppTypeRefs;
85 80909 : sal_Int32 * pMemberOffsets = pTypeDescr->pMemberOffsets;
86 80909 : sal_Int32 nDescr = pTypeDescr->nMembers;
87 :
88 367855 : while (nDescr--)
89 : {
90 212143 : sal_Int32 nOffset = pMemberOffsets[nDescr];
91 424286 : if (! ::uno_type_equalData( (char *)pDest + nOffset,
92 212143 : ppTypeRefs[nDescr],
93 212143 : (char *)pSource + nOffset,
94 212143 : ppTypeRefs[nDescr],
95 636429 : queryInterface, release ))
96 : {
97 6106 : return sal_False;
98 : }
99 : }
100 74803 : return sal_True;
101 : }
102 : //==================================================================================================
103 : sal_Bool equalSequence(
104 : uno_Sequence * pDest, uno_Sequence * pSource,
105 : typelib_TypeDescriptionReference * pElementType,
106 : uno_QueryInterfaceFunc queryInterface, uno_ReleaseFunc release )
107 : SAL_THROW(());
108 : //--------------------------------------------------------------------------------------------------
109 53532 : inline sal_Bool _equalSequence(
110 : uno_Sequence * pDest, uno_Sequence * pSource,
111 : typelib_TypeDescriptionReference * pElementType,
112 : uno_QueryInterfaceFunc queryInterface, uno_ReleaseFunc release )
113 : SAL_THROW(())
114 : {
115 53532 : if (pDest == pSource)
116 5440 : return sal_True;
117 48092 : sal_Int32 nElements = pDest->nElements;
118 48092 : if (nElements != pSource->nElements)
119 30506 : return sal_False;
120 17586 : if (! nElements)
121 6 : return sal_True;
122 :
123 17580 : void * pDestElements = pDest->elements;
124 17580 : void * pSourceElements = pSource->elements;
125 :
126 17580 : switch (pElementType->eTypeClass)
127 : {
128 : case typelib_TypeClass_CHAR:
129 0 : return (0 == memcmp( pDestElements, pSourceElements, sizeof(sal_Unicode) * nElements ));
130 : case typelib_TypeClass_BOOLEAN:
131 : {
132 20 : for ( sal_Int32 nPos = nElements; nPos--; )
133 : {
134 24 : if ((((sal_Bool *)pDestElements)[nPos] != sal_False) !=
135 12 : (((sal_Bool *)pSourceElements)[nPos] != sal_False))
136 : {
137 0 : return sal_False;
138 : }
139 : }
140 4 : return sal_True;
141 : }
142 : case typelib_TypeClass_BYTE:
143 13 : return (0 == memcmp( pDestElements, pSourceElements, sizeof(sal_Int8) * nElements ));
144 : case typelib_TypeClass_SHORT:
145 : case typelib_TypeClass_UNSIGNED_SHORT:
146 12 : return (0 == memcmp( pDestElements, pSourceElements, sizeof(sal_Int16) * nElements ));
147 : case typelib_TypeClass_LONG:
148 : case typelib_TypeClass_UNSIGNED_LONG:
149 21 : return (0 == memcmp( pDestElements, pSourceElements, sizeof(sal_Int32) * nElements ));
150 : case typelib_TypeClass_HYPER:
151 : case typelib_TypeClass_UNSIGNED_HYPER:
152 8 : return (0 == memcmp( pDestElements, pSourceElements, sizeof(sal_Int64) * nElements ));
153 : case typelib_TypeClass_FLOAT:
154 : {
155 20 : for ( sal_Int32 nPos = nElements; nPos--; )
156 : {
157 12 : if (((float *)pDestElements)[nPos] != ((float *)pSourceElements)[nPos])
158 0 : return sal_False;
159 : }
160 4 : return sal_True;
161 : }
162 : case typelib_TypeClass_DOUBLE:
163 : {
164 20 : for ( sal_Int32 nPos = nElements; nPos--; )
165 : {
166 12 : if (((double *)pDestElements)[nPos] != ((double *)pSourceElements)[nPos])
167 0 : return sal_False;
168 : }
169 4 : return sal_True;
170 : }
171 : case typelib_TypeClass_STRING:
172 : {
173 2446 : for ( sal_Int32 nPos = nElements; nPos--; )
174 : {
175 2222 : if (! ((::rtl::OUString *)pDestElements +nPos)->equals( ((const ::rtl::OUString *)pSourceElements)[nPos] ))
176 0 : return sal_False;
177 : }
178 112 : return sal_True;
179 : }
180 : case typelib_TypeClass_TYPE:
181 : {
182 0 : for ( sal_Int32 nPos = nElements; nPos--; )
183 : {
184 0 : if (! _type_equals( ((typelib_TypeDescriptionReference **)pDestElements)[nPos],
185 0 : ((typelib_TypeDescriptionReference **)pSourceElements)[nPos] ))
186 : {
187 0 : return sal_False;
188 : }
189 : }
190 0 : return sal_True;
191 : }
192 : case typelib_TypeClass_ANY:
193 : {
194 30 : for ( sal_Int32 nPos = nElements; nPos--; )
195 : {
196 18 : uno_Any * pDest2 = (uno_Any *)pDestElements + nPos;
197 18 : uno_Any * pSource2 = (uno_Any *)pSourceElements + nPos;
198 18 : if (! ::uno_type_equalData( pDest2->pData, pDest2->pType,
199 : pSource2->pData, pSource2->pType,
200 18 : queryInterface, release ))
201 : {
202 0 : return sal_False;
203 : }
204 : }
205 6 : return sal_True;
206 : }
207 : case typelib_TypeClass_ENUM:
208 4 : return (0 == memcmp( pDestElements, pSourceElements, sizeof(sal_Int32) * nElements ));
209 : case typelib_TypeClass_STRUCT:
210 : case typelib_TypeClass_EXCEPTION:
211 : {
212 14900 : typelib_TypeDescription * pElementTypeDescr = 0;
213 14900 : TYPELIB_DANGER_GET( &pElementTypeDescr, pElementType );
214 14900 : sal_Int32 nElementSize = pElementTypeDescr->nSize;
215 67350 : for ( sal_Int32 nPos = nElements; nPos--; )
216 : {
217 84492 : if (! _equalStruct( (char *)pDestElements + (nPos * nElementSize),
218 42246 : (char *)pSourceElements + (nPos * nElementSize),
219 : (typelib_CompoundTypeDescription *)pElementTypeDescr,
220 126738 : queryInterface, release ))
221 : {
222 4696 : TYPELIB_DANGER_RELEASE( pElementTypeDescr );
223 4696 : return sal_False;
224 : }
225 : }
226 10204 : TYPELIB_DANGER_RELEASE( pElementTypeDescr );
227 10204 : return sal_True;
228 : }
229 : case typelib_TypeClass_UNION:
230 : {
231 0 : typelib_TypeDescription * pElementTypeDescr = 0;
232 0 : TYPELIB_DANGER_GET( &pElementTypeDescr, pElementType );
233 0 : sal_Int32 nElementSize = pElementTypeDescr->nSize;
234 0 : sal_Int32 nValueOffset = ((typelib_UnionTypeDescription *)pElementTypeDescr)->nValueOffset;
235 0 : for ( sal_Int32 nPos = nElements; nPos--; )
236 : {
237 0 : char * pDest2 = (char *)pDestElements + (nPos * nElementSize);
238 0 : char * pSource2 = (char *)pSourceElements + (nPos * nElementSize);
239 : typelib_TypeDescriptionReference * pSetType = _unionGetSetType(
240 0 : pDest2, pElementTypeDescr );
241 : sal_Bool bRet = ::uno_type_equalData(
242 0 : pDest2 + nValueOffset, pSetType,
243 0 : pSource2 + nValueOffset, pSetType,
244 0 : queryInterface, release );
245 0 : ::typelib_typedescriptionreference_release( pSetType );
246 0 : if (! bRet)
247 : {
248 0 : TYPELIB_DANGER_RELEASE( pElementTypeDescr );
249 0 : return sal_False;
250 : }
251 : }
252 0 : TYPELIB_DANGER_RELEASE( pElementTypeDescr );
253 0 : return sal_True;
254 : }
255 : case typelib_TypeClass_SEQUENCE: // sequence of sequence
256 : {
257 2486 : typelib_TypeDescription * pElementTypeDescr = 0;
258 2486 : TYPELIB_DANGER_GET( &pElementTypeDescr, pElementType );
259 : typelib_TypeDescriptionReference * pSeqElementType =
260 2486 : ((typelib_IndirectTypeDescription *)pElementTypeDescr)->pType;
261 5326 : for ( sal_Int32 nPos = nElements; nPos--; )
262 : {
263 5084 : if (! equalSequence( ((uno_Sequence **)pDestElements)[nPos],
264 2542 : ((uno_Sequence **)pSourceElements)[nPos],
265 5084 : pSeqElementType, queryInterface, release ))
266 : {
267 2188 : TYPELIB_DANGER_RELEASE( pElementTypeDescr );
268 2188 : return sal_False;
269 : }
270 : }
271 298 : TYPELIB_DANGER_RELEASE( pElementTypeDescr );
272 298 : return sal_True;
273 : }
274 : case typelib_TypeClass_INTERFACE:
275 : {
276 30 : for ( sal_Int32 nPos = nElements; nPos--; )
277 : {
278 54 : if (! _equalObject( ((void **)pDestElements)[nPos], ((void **)pSourceElements)[nPos],
279 36 : queryInterface, release ))
280 : {
281 0 : return sal_False;
282 : }
283 : }
284 6 : return sal_True;
285 : }
286 : default:
287 : OSL_ASSERT(false);
288 0 : return sal_False;
289 : }
290 : }
291 : //--------------------------------------------------------------------------------------------------
292 405787 : inline sal_Bool _equalData(
293 : void * pDest,
294 : typelib_TypeDescriptionReference * pDestType, typelib_TypeDescription * pDestTypeDescr,
295 : void * pSource,
296 : typelib_TypeDescriptionReference * pSourceType,
297 : uno_QueryInterfaceFunc queryInterface, uno_ReleaseFunc release )
298 : SAL_THROW(())
299 : {
300 : typelib_TypeClass eSourceTypeClass, eDestTypeClass;
301 870566 : while (typelib_TypeClass_ANY == (eDestTypeClass = pDestType->eTypeClass))
302 : {
303 58992 : pDestTypeDescr = 0;
304 58992 : pDestType = ((uno_Any *)pDest)->pType;
305 58992 : pDest = ((uno_Any *)pDest)->pData;
306 : }
307 870566 : while (typelib_TypeClass_ANY == (eSourceTypeClass = pSourceType->eTypeClass))
308 : {
309 58992 : pSourceType = ((uno_Any *)pSource)->pType;
310 58992 : pSource = ((uno_Any *)pSource)->pData;
311 : }
312 :
313 405787 : switch (eDestTypeClass)
314 : {
315 : case typelib_TypeClass_VOID:
316 2380 : return eSourceTypeClass == typelib_TypeClass_VOID;
317 : case typelib_TypeClass_CHAR:
318 : return eSourceTypeClass == typelib_TypeClass_CHAR
319 60 : && *(sal_Unicode *)pDest == *(sal_Unicode *)pSource;
320 : case typelib_TypeClass_BOOLEAN:
321 : return eSourceTypeClass == typelib_TypeClass_BOOLEAN
322 : && ((*(sal_Bool *)pDest != sal_False)
323 5805 : == (*(sal_Bool *)pSource != sal_False));
324 : case typelib_TypeClass_BYTE:
325 60 : switch (eSourceTypeClass)
326 : {
327 : case typelib_TypeClass_BYTE:
328 60 : return (*(sal_Int8 *)pDest == *(sal_Int8 *)pSource);
329 : case typelib_TypeClass_SHORT:
330 0 : return ((sal_Int16)*(sal_Int8 *)pDest == *(sal_Int16 *)pSource);
331 : case typelib_TypeClass_UNSIGNED_SHORT:
332 0 : return ((sal_Int32)*(sal_Int8 *)pDest == (sal_Int32)*(sal_uInt16 *)pSource);
333 : case typelib_TypeClass_LONG:
334 0 : return ((sal_Int32)*(sal_Int8 *)pDest == *(sal_Int32 *)pSource);
335 : case typelib_TypeClass_UNSIGNED_LONG:
336 0 : return ((sal_Int64)*(sal_Int8 *)pDest == (sal_Int64)*(sal_uInt32 *)pSource);
337 : case typelib_TypeClass_HYPER:
338 0 : return ((sal_Int64)*(sal_Int8 *)pDest == *(sal_Int64 *)pSource);
339 : case typelib_TypeClass_UNSIGNED_HYPER:
340 : return (*(sal_Int8 *)pDest >= 0 &&
341 0 : (sal_Int64)*(sal_Int8 *)pDest == *(sal_Int64 *)pSource); // same size
342 : case typelib_TypeClass_FLOAT:
343 0 : return ((float)*(sal_Int8 *)pDest == *(float *)pSource);
344 : case typelib_TypeClass_DOUBLE:
345 0 : return ((double)*(sal_Int8 *)pDest == *(double *)pSource);
346 : default:
347 0 : return sal_False;
348 : }
349 : case typelib_TypeClass_SHORT:
350 41500 : switch (eSourceTypeClass)
351 : {
352 : case typelib_TypeClass_BYTE:
353 0 : return (*(sal_Int16 *)pDest == (sal_Int16)*(sal_Int8 *)pSource);
354 : case typelib_TypeClass_SHORT:
355 41500 : return (*(sal_Int16 *)pDest == *(sal_Int16 *)pSource);
356 : case typelib_TypeClass_UNSIGNED_SHORT:
357 0 : return ((sal_Int32)*(sal_Int16 *)pDest == (sal_Int32)*(sal_uInt16 *)pSource);
358 : case typelib_TypeClass_LONG:
359 0 : return ((sal_Int32)*(sal_Int16 *)pDest == *(sal_Int32 *)pSource);
360 : case typelib_TypeClass_UNSIGNED_LONG:
361 0 : return ((sal_Int64)*(sal_Int16 *)pDest == (sal_Int64)*(sal_uInt32 *)pSource);
362 : case typelib_TypeClass_HYPER:
363 0 : return ((sal_Int64)*(sal_Int16 *)pDest == *(sal_Int64 *)pSource);
364 : case typelib_TypeClass_UNSIGNED_HYPER:
365 : return (*(sal_Int16 *)pDest >= 0 &&
366 0 : (sal_Int64)*(sal_Int16 *)pDest == *(sal_Int64 *)pSource); // same size
367 : case typelib_TypeClass_FLOAT:
368 0 : return ((float)*(sal_Int16 *)pDest == *(float *)pSource);
369 : case typelib_TypeClass_DOUBLE:
370 0 : return ((double)*(sal_Int16 *)pDest == *(double *)pSource);
371 : default:
372 0 : return sal_False;
373 : }
374 : case typelib_TypeClass_UNSIGNED_SHORT:
375 102 : switch (eSourceTypeClass)
376 : {
377 : case typelib_TypeClass_BYTE:
378 0 : return ((sal_Int32)*(sal_uInt16 *)pDest == (sal_Int32)*(sal_Int8 *)pSource);
379 : case typelib_TypeClass_SHORT:
380 0 : return ((sal_Int32)*(sal_uInt16 *)pDest == (sal_Int32)*(sal_Int16 *)pSource);
381 : case typelib_TypeClass_UNSIGNED_SHORT:
382 102 : return (*(sal_uInt16 *)pDest == *(sal_uInt16 *)pSource);
383 : case typelib_TypeClass_LONG:
384 0 : return ((sal_Int32)*(sal_uInt16 *)pDest == *(sal_Int32 *)pSource);
385 : case typelib_TypeClass_UNSIGNED_LONG:
386 0 : return ((sal_uInt32)*(sal_uInt16 *)pDest == *(sal_uInt32 *)pSource);
387 : case typelib_TypeClass_HYPER:
388 0 : return ((sal_Int64)*(sal_uInt16 *)pDest == *(sal_Int64 *)pSource);
389 : case typelib_TypeClass_UNSIGNED_HYPER:
390 0 : return ((sal_uInt64)*(sal_uInt16 *)pDest == *(sal_uInt64 *)pSource);
391 : case typelib_TypeClass_FLOAT:
392 0 : return ((float)*(sal_uInt16 *)pDest == *(float *)pSource);
393 : case typelib_TypeClass_DOUBLE:
394 0 : return ((double)*(sal_uInt16 *)pDest == *(double *)pSource);
395 : default:
396 0 : return sal_False;
397 : }
398 : case typelib_TypeClass_LONG:
399 195040 : switch (eSourceTypeClass)
400 : {
401 : case typelib_TypeClass_BYTE:
402 0 : return (*(sal_Int32 *)pDest == (sal_Int32)*(sal_Int8 *)pSource);
403 : case typelib_TypeClass_SHORT:
404 0 : return (*(sal_Int32 *)pDest == (sal_Int32)*(sal_Int16 *)pSource);
405 : case typelib_TypeClass_UNSIGNED_SHORT:
406 0 : return (*(sal_Int32 *)pDest == (sal_Int32)*(sal_uInt16 *)pSource);
407 : case typelib_TypeClass_LONG:
408 195040 : return (*(sal_Int32 *)pDest == *(sal_Int32 *)pSource);
409 : case typelib_TypeClass_UNSIGNED_LONG:
410 0 : return ((sal_Int64)*(sal_Int32 *)pDest == (sal_Int64)*(sal_uInt32 *)pSource);
411 : case typelib_TypeClass_HYPER:
412 0 : return ((sal_Int64)*(sal_Int32 *)pDest == *(sal_Int64 *)pSource);
413 : case typelib_TypeClass_UNSIGNED_HYPER:
414 : return (*(sal_Int32 *)pDest >= 0 &&
415 0 : (sal_Int64)*(sal_Int32 *)pDest == *(sal_Int64 *)pSource); // same size
416 : case typelib_TypeClass_FLOAT:
417 0 : return ((float)*(sal_Int32 *)pDest == *(float *)pSource);
418 : case typelib_TypeClass_DOUBLE:
419 0 : return ((double)*(sal_Int32 *)pDest == *(double *)pSource);
420 : default:
421 0 : return sal_False;
422 : }
423 : case typelib_TypeClass_UNSIGNED_LONG:
424 252 : switch (eSourceTypeClass)
425 : {
426 : case typelib_TypeClass_BYTE:
427 0 : return ((sal_Int64)*(sal_uInt32 *)pDest == (sal_Int64)*(sal_Int8 *)pSource);
428 : case typelib_TypeClass_SHORT:
429 0 : return ((sal_Int64)*(sal_uInt32 *)pDest == (sal_Int64)*(sal_Int16 *)pSource);
430 : case typelib_TypeClass_UNSIGNED_SHORT:
431 0 : return (*(sal_uInt32 *)pDest == (sal_uInt32)*(sal_uInt16 *)pSource);
432 : case typelib_TypeClass_LONG:
433 0 : return ((sal_Int64)*(sal_uInt32 *)pDest == (sal_Int64)*(sal_Int32 *)pSource);
434 : case typelib_TypeClass_UNSIGNED_LONG:
435 252 : return (*(sal_uInt32 *)pDest == *(sal_uInt32 *)pSource);
436 : case typelib_TypeClass_HYPER:
437 0 : return ((sal_Int64)*(sal_uInt32 *)pDest == *(sal_Int64 *)pSource);
438 : case typelib_TypeClass_UNSIGNED_HYPER:
439 0 : return ((sal_uInt64)*(sal_uInt32 *)pDest == *(sal_uInt64 *)pSource);
440 : case typelib_TypeClass_FLOAT:
441 0 : return ((float)*(sal_uInt32 *)pDest == *(float *)pSource);
442 : case typelib_TypeClass_DOUBLE:
443 0 : return ((double)*(sal_uInt32 *)pDest == *(double *)pSource);
444 : default:
445 0 : return sal_False;
446 : }
447 : case typelib_TypeClass_HYPER:
448 184 : switch (eSourceTypeClass)
449 : {
450 : case typelib_TypeClass_BYTE:
451 0 : return (*(sal_Int64 *)pDest == (sal_Int64)*(sal_Int8 *)pSource);
452 : case typelib_TypeClass_SHORT:
453 0 : return (*(sal_Int64 *)pDest == (sal_Int64)*(sal_Int16 *)pSource);
454 : case typelib_TypeClass_UNSIGNED_SHORT:
455 0 : return (*(sal_Int64 *)pDest == (sal_Int64)*(sal_uInt16 *)pSource);
456 : case typelib_TypeClass_LONG:
457 0 : return (*(sal_Int64 *)pDest == (sal_Int64)*(sal_Int32 *)pSource);
458 : case typelib_TypeClass_UNSIGNED_LONG:
459 0 : return (*(sal_Int64 *)pDest == (sal_Int64)*(sal_uInt32 *)pSource);
460 : case typelib_TypeClass_HYPER:
461 184 : return (*(sal_Int64 *)pDest == *(sal_Int64 *)pSource);
462 : case typelib_TypeClass_UNSIGNED_HYPER:
463 : return (*(sal_Int64 *)pDest >= 0 &&
464 0 : *(sal_Int64 *)pDest == *(sal_Int64 *)pSource); // same size
465 : case typelib_TypeClass_FLOAT:
466 0 : return ((float)*(sal_Int64 *)pDest == *(float *)pSource);
467 : case typelib_TypeClass_DOUBLE:
468 0 : return ((double)*(sal_Int64 *)pDest == *(double *)pSource);
469 : default:
470 0 : return sal_False;
471 : }
472 : case typelib_TypeClass_UNSIGNED_HYPER:
473 60 : switch (eSourceTypeClass)
474 : {
475 : case typelib_TypeClass_BYTE:
476 : return (*(sal_Int8 *)pSource >= 0 &&
477 0 : *(sal_uInt64 *)pDest == (sal_uInt64)*(sal_Int8 *)pSource);
478 : case typelib_TypeClass_SHORT:
479 : return (*(sal_Int16 *)pSource >= 0 &&
480 0 : *(sal_uInt64 *)pDest == (sal_uInt64)*(sal_Int16 *)pSource);
481 : case typelib_TypeClass_UNSIGNED_SHORT:
482 0 : return (*(sal_uInt64 *)pDest == (sal_uInt64)*(sal_uInt16 *)pSource);
483 : case typelib_TypeClass_LONG:
484 : return (*(sal_Int32 *)pSource >= 0 &&
485 0 : *(sal_uInt64 *)pDest == (sal_uInt64)*(sal_Int32 *)pSource);
486 : case typelib_TypeClass_UNSIGNED_LONG:
487 0 : return (*(sal_uInt64 *)pDest == (sal_uInt64)*(sal_uInt32 *)pSource);
488 : case typelib_TypeClass_HYPER:
489 : return (*(sal_Int64 *)pSource >= 0 &&
490 0 : *(sal_uInt64 *)pDest == (sal_uInt64)*(sal_Int64 *)pSource);
491 : case typelib_TypeClass_UNSIGNED_HYPER:
492 60 : return (*(sal_uInt64 *)pDest == *(sal_uInt64 *)pSource);
493 : case typelib_TypeClass_FLOAT:
494 0 : if (::floor( *(float *)pSource ) != *(float *)pSource || *(float *)pSource < 0)
495 0 : return sal_False;
496 0 : return (*(sal_uInt64 *)pDest == (sal_uInt64)*(float *)pSource);
497 : case typelib_TypeClass_DOUBLE:
498 0 : if (::floor( *(double *)pSource ) != *(double *)pSource || *(double *)pSource < 0)
499 0 : return sal_False;
500 0 : return (*(sal_uInt64 *)pDest == (sal_uInt64)*(double *)pSource);
501 : default:
502 0 : return sal_False;
503 : }
504 : case typelib_TypeClass_FLOAT:
505 4490 : switch (eSourceTypeClass)
506 : {
507 : case typelib_TypeClass_BYTE:
508 0 : return (*(float *)pDest == (float)*(sal_Int8 *)pSource);
509 : case typelib_TypeClass_SHORT:
510 0 : return (*(float *)pDest == (float)*(sal_Int16 *)pSource);
511 : case typelib_TypeClass_UNSIGNED_SHORT:
512 0 : return (*(float *)pDest == (float)*(sal_uInt16 *)pSource);
513 : case typelib_TypeClass_LONG:
514 0 : return (*(float *)pDest == (float)*(sal_Int32 *)pSource);
515 : case typelib_TypeClass_UNSIGNED_LONG:
516 0 : return (*(float *)pDest == (float)*(sal_uInt32 *)pSource);
517 : case typelib_TypeClass_HYPER:
518 0 : return (*(float *)pDest == (float)*(sal_Int64 *)pSource);
519 : case typelib_TypeClass_UNSIGNED_HYPER:
520 0 : if (::floor( *(float *)pDest ) != *(float *)pDest || *(float *)pDest < 0)
521 0 : return sal_False;
522 0 : return ((sal_uInt64)*(float *)pDest == *(sal_uInt64 *)pSource);
523 : case typelib_TypeClass_FLOAT:
524 4490 : return (*(float *)pDest == *(float *)pSource);
525 : case typelib_TypeClass_DOUBLE:
526 0 : return ((double)*(float *)pDest == *(double *)pSource);
527 : default:
528 0 : return sal_False;
529 : }
530 : case typelib_TypeClass_DOUBLE:
531 782 : switch (eSourceTypeClass)
532 : {
533 : case typelib_TypeClass_BYTE:
534 0 : return (*(double *)pDest == (double)*(sal_Int8 *)pSource);
535 : case typelib_TypeClass_SHORT:
536 0 : return (*(double *)pDest == (double)*(sal_Int16 *)pSource);
537 : case typelib_TypeClass_UNSIGNED_SHORT:
538 0 : return (*(double *)pDest == (double)*(sal_uInt16 *)pSource);
539 : case typelib_TypeClass_LONG:
540 0 : return (*(double *)pDest == (double)*(sal_Int32 *)pSource);
541 : case typelib_TypeClass_UNSIGNED_LONG:
542 0 : return (*(double *)pDest == (double)*(sal_uInt32 *)pSource);
543 : case typelib_TypeClass_HYPER:
544 0 : return (*(double *)pDest == (double)*(sal_Int64 *)pSource);
545 : case typelib_TypeClass_UNSIGNED_HYPER:
546 0 : if (::floor( *(double *)pDest ) != *(double *)pDest || *(double *)pDest < 0)
547 0 : return sal_False;
548 0 : return ((sal_uInt64)*(double *)pDest == *(sal_uInt64 *)pSource);
549 : case typelib_TypeClass_FLOAT:
550 0 : return (*(double *)pDest == (double)*(float *)pSource);
551 : case typelib_TypeClass_DOUBLE:
552 782 : return (*(double *)pDest == *(double *)pSource);
553 : default:
554 0 : return sal_False;
555 : }
556 : case typelib_TypeClass_STRING:
557 : return eSourceTypeClass == typelib_TypeClass_STRING
558 : && ((::rtl::OUString *)pDest)->equals(
559 30748 : *(::rtl::OUString const *)pSource );
560 : case typelib_TypeClass_TYPE:
561 : return eSourceTypeClass == typelib_TypeClass_TYPE
562 : && _type_equals(
563 : *(typelib_TypeDescriptionReference **)pDest,
564 2 : *(typelib_TypeDescriptionReference **)pSource );
565 : case typelib_TypeClass_ENUM:
566 32960 : return (_type_equals( pDestType, pSourceType ) &&
567 32960 : *(sal_Int32 *)pDest == *(sal_Int32 *)pSource);
568 : case typelib_TypeClass_STRUCT:
569 : case typelib_TypeClass_EXCEPTION:
570 38599 : if (! _type_equals( pDestType, pSourceType ))
571 0 : return sal_False;
572 38599 : if (pDestTypeDescr)
573 : {
574 : return _equalStruct(
575 : pDest, pSource,
576 : (typelib_CompoundTypeDescription *)pDestTypeDescr,
577 0 : queryInterface, release );
578 : }
579 : else
580 : {
581 38599 : TYPELIB_DANGER_GET( &pDestTypeDescr, pDestType );
582 : sal_Bool bRet = _equalStruct(
583 : pDest, pSource,
584 : (typelib_CompoundTypeDescription *)pDestTypeDescr,
585 38599 : queryInterface, release );
586 38599 : TYPELIB_DANGER_RELEASE( pDestTypeDescr );
587 38599 : return bRet;
588 : }
589 : case typelib_TypeClass_UNION:
590 0 : if (_type_equals( pDestType, pSourceType ) &&
591 : *(sal_Int64 *)pDest == *(sal_Int64 *)pSource) // same discriminant
592 : {
593 : sal_Bool bRet;
594 0 : if (pDestTypeDescr)
595 : {
596 : typelib_TypeDescriptionReference * pSetType = _unionGetSetType(
597 0 : pDest, pDestTypeDescr );
598 : bRet = ::uno_type_equalData(
599 0 : (char *)pDest + ((typelib_UnionTypeDescription *)pDestTypeDescr)->nValueOffset,
600 : pSetType,
601 0 : (char *)pSource + ((typelib_UnionTypeDescription *)pDestTypeDescr)->nValueOffset,
602 : pSetType,
603 0 : queryInterface, release );
604 0 : typelib_typedescriptionreference_release( pSetType );
605 : }
606 : else
607 : {
608 0 : TYPELIB_DANGER_GET( &pDestTypeDescr, pDestType );
609 : typelib_TypeDescriptionReference * pSetType = _unionGetSetType(
610 0 : pDest, pDestTypeDescr );
611 : bRet = ::uno_type_equalData(
612 0 : (char *)pDest + ((typelib_UnionTypeDescription *)pDestTypeDescr)->nValueOffset,
613 : pSetType,
614 0 : (char *)pSource + ((typelib_UnionTypeDescription *)pDestTypeDescr)->nValueOffset,
615 : pSetType,
616 0 : queryInterface, release );
617 0 : typelib_typedescriptionreference_release( pSetType );
618 0 : TYPELIB_DANGER_RELEASE( pDestTypeDescr );
619 : }
620 0 : return bRet;
621 : }
622 0 : return sal_False;
623 : case typelib_TypeClass_SEQUENCE:
624 52570 : if (_type_equals( pDestType, pSourceType ))
625 : {
626 50990 : if (pDestTypeDescr)
627 : {
628 : return _equalSequence(
629 : *(uno_Sequence **)pDest, *(uno_Sequence **)pSource,
630 : ((typelib_IndirectTypeDescription *)pDestTypeDescr)->pType,
631 0 : queryInterface, release );
632 : }
633 : else
634 : {
635 50990 : TYPELIB_DANGER_GET( &pDestTypeDescr, pDestType );
636 : sal_Bool bRet = _equalSequence(
637 : *(uno_Sequence **)pDest, *(uno_Sequence **)pSource,
638 : ((typelib_IndirectTypeDescription *)pDestTypeDescr)->pType,
639 50990 : queryInterface, release );
640 50990 : TYPELIB_DANGER_RELEASE( pDestTypeDescr );
641 50990 : return bRet;
642 : }
643 : }
644 1580 : return sal_False;
645 : case typelib_TypeClass_INTERFACE:
646 193 : if (typelib_TypeClass_INTERFACE == eSourceTypeClass)
647 190 : return _equalObject( *(void **)pDest, *(void **)pSource, queryInterface, release );
648 3 : break;
649 : default:
650 : OSL_ASSERT(false);
651 0 : break;
652 : }
653 3 : return sal_False;
654 : }
655 :
656 : }
657 :
658 : #endif
659 :
660 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
