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