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 COPY_HXX
20 : : #define COPY_HXX
21 : :
22 : : #include "prim.hxx"
23 : : #include "constr.hxx"
24 : :
25 : :
26 : : namespace cppu
27 : : {
28 : :
29 : : //##################################################################################################
30 : : //#### copy construction ###########################################################################
31 : : //##################################################################################################
32 : :
33 : : //------------------------------------------------------------------------------
34 : 326455 : inline uno_Sequence * allocSeq(
35 : : sal_Int32 nElementSize, sal_Int32 nElements )
36 : : {
37 : : OSL_ASSERT( nElements >= 0 && nElementSize >= 0 );
38 : 326455 : uno_Sequence * pSeq = 0;
39 : 326455 : sal_uInt32 nSize = calcSeqMemSize( nElementSize, nElements );
40 [ + - ]: 326455 : if (nSize > 0)
41 : : {
42 : 326455 : pSeq = (uno_Sequence *) rtl_allocateMemory( nSize );
43 [ + - ]: 326455 : if (pSeq != 0)
44 : : {
45 : : // header init
46 : 326455 : pSeq->nRefCount = 1;
47 : 326455 : pSeq->nElements = nElements;
48 : : }
49 : : }
50 : 326455 : return pSeq;
51 : : }
52 : :
53 : : //--------------------------------------------------------------------------------------------------
54 : : void copyConstructStruct(
55 : : void * pDest, void * pSource,
56 : : typelib_CompoundTypeDescription * pTypeDescr,
57 : : uno_AcquireFunc acquire, uno_Mapping * mapping )
58 : : SAL_THROW (());
59 : : //--------------------------------------------------------------------------------------------------
60 : 4385562 : inline void _copyConstructStruct(
61 : : void * pDest, void * pSource,
62 : : typelib_CompoundTypeDescription * pTypeDescr,
63 : : uno_AcquireFunc acquire, uno_Mapping * mapping )
64 : : SAL_THROW (())
65 : : {
66 [ + + ]: 4385562 : if (pTypeDescr->pBaseTypeDescription)
67 : : {
68 : : // copy base value
69 : 512654 : copyConstructStruct( pDest, pSource, pTypeDescr->pBaseTypeDescription, acquire, mapping );
70 : : }
71 : :
72 : : // then copy members
73 : 4385562 : typelib_TypeDescriptionReference ** ppTypeRefs = pTypeDescr->ppTypeRefs;
74 : 4385562 : sal_Int32 * pMemberOffsets = pTypeDescr->pMemberOffsets;
75 : 4385562 : sal_Int32 nDescr = pTypeDescr->nMembers;
76 : :
77 [ + + ]: 4385562 : if (mapping)
78 : : {
79 [ + + ]: 1271223 : while (nDescr--)
80 : : {
81 : : ::uno_type_copyAndConvertData(
82 : 1914132 : (char *)pDest + pMemberOffsets[nDescr],
83 : 1914132 : (char *)pSource + pMemberOffsets[nDescr],
84 : 957066 : ppTypeRefs[nDescr], mapping );
85 : : }
86 : : }
87 : : else
88 : : {
89 [ + + ]: 19012046 : while (nDescr--)
90 : : {
91 : : ::uno_type_copyData(
92 : 29881284 : (char *)pDest + pMemberOffsets[nDescr],
93 : 29881284 : (char *)pSource + pMemberOffsets[nDescr],
94 : 14940642 : ppTypeRefs[nDescr], acquire );
95 : : }
96 : : }
97 : 4385561 : }
98 : : //--------------------------------------------------------------------------------------------------
99 : 0 : inline void _copyConstructArray(
100 : : void * pDest, void * pSource,
101 : : typelib_ArrayTypeDescription * pTypeDescr,
102 : : uno_AcquireFunc acquire, uno_Mapping * mapping )
103 : : {
104 : 0 : typelib_TypeDescriptionReference * pElementTypeRef = ((typelib_IndirectTypeDescription *)pTypeDescr)->pType;
105 : 0 : typelib_TypeDescription * pElementTypeDescr = NULL;
106 [ # # ][ # # ]: 0 : TYPELIB_DANGER_GET( &pElementTypeDescr, pElementTypeRef );
[ # # ][ # # ]
[ # # ]
107 : 0 : sal_Int32 nElementSize = ((typelib_TypeDescription*)pElementTypeDescr)->nSize;
108 [ # # ][ # # ]: 0 : TYPELIB_DANGER_RELEASE( pElementTypeDescr );
109 : 0 : sal_Int32 nTotalElements = pTypeDescr->nTotalElements;
110 : :
111 [ # # ]: 0 : if (mapping)
112 : : {
113 [ # # ]: 0 : for(sal_Int32 i = 0; i < nTotalElements; i++)
114 : : {
115 : : ::uno_type_copyAndConvertData(
116 : 0 : (sal_Char *)pDest + i * nElementSize,
117 : 0 : (sal_Char *)pSource + i * nElementSize,
118 : 0 : pElementTypeRef, mapping );
119 : : }
120 : : }
121 : : else
122 : : {
123 [ # # ]: 0 : for(sal_Int32 i = 0; i < nTotalElements; i++)
124 : : {
125 : : ::uno_type_copyData(
126 : 0 : (sal_Char *)pDest + (i * nElementSize),
127 : 0 : (sal_Char *)pSource + (i * nElementSize),
128 : 0 : pElementTypeRef, acquire );
129 : : }
130 : : }
131 : 0 : }
132 : : //--------------------------------------------------------------------------------------------------
133 : 0 : inline void _copyConstructUnion(
134 : : void * pDest, void * pSource,
135 : : typelib_TypeDescription * pTypeDescr,
136 : : uno_AcquireFunc acquire, uno_Mapping * mapping )
137 : : SAL_THROW (())
138 : : {
139 : 0 : typelib_TypeDescriptionReference * pSetType = _unionGetSetType( pSource, pTypeDescr );
140 [ # # ]: 0 : if (mapping)
141 : : {
142 : : ::uno_type_copyAndConvertData(
143 : 0 : (char *)pDest + ((typelib_UnionTypeDescription *)pTypeDescr)->nValueOffset,
144 : 0 : (char *)pSource + ((typelib_UnionTypeDescription *)pTypeDescr)->nValueOffset,
145 : 0 : pSetType, mapping );
146 : : }
147 : : else
148 : : {
149 : : ::uno_type_copyData(
150 : 0 : (char *)pDest + ((typelib_UnionTypeDescription *)pTypeDescr)->nValueOffset,
151 : 0 : (char *)pSource + ((typelib_UnionTypeDescription *)pTypeDescr)->nValueOffset,
152 : 0 : pSetType, acquire );
153 : : }
154 : 0 : *(sal_Int64 *)pDest = *(sal_Int64 *)pSource;
155 : 0 : typelib_typedescriptionreference_release( pSetType );
156 : 0 : }
157 : :
158 : : //------------------------------------------------------------------------------
159 : : uno_Sequence * copyConstructSequence(
160 : : uno_Sequence * pSource,
161 : : typelib_TypeDescriptionReference * pElementType,
162 : : uno_AcquireFunc acquire, uno_Mapping * mapping );
163 : :
164 : : //--------------------------------------------------------------------------------------------------
165 : 106781428 : inline void _copyConstructAnyFromData(
166 : : uno_Any * pDestAny, void * pSource,
167 : : typelib_TypeDescriptionReference * pType, typelib_TypeDescription * pTypeDescr,
168 : : uno_AcquireFunc acquire, uno_Mapping * mapping )
169 : : SAL_THROW (())
170 : : {
171 : 106781428 : TYPE_ACQUIRE( pType );
172 : 106781605 : pDestAny->pType = pType;
173 : :
174 [ + + + + : 106781605 : switch (pType->eTypeClass)
+ + + + +
+ - + + -
- + + - ]
175 : : {
176 : : case typelib_TypeClass_CHAR:
177 : 365 : pDestAny->pData = &pDestAny->pReserved;
178 : 365 : *(sal_Unicode *)pDestAny->pData = *(sal_Unicode *)pSource;
179 : 365 : break;
180 : : case typelib_TypeClass_BOOLEAN:
181 : 16091123 : pDestAny->pData = &pDestAny->pReserved;
182 : 16091123 : *(sal_Bool *)pDestAny->pData = (*(sal_Bool *)pSource != sal_False);
183 : 16091123 : break;
184 : : case typelib_TypeClass_BYTE:
185 : 34395 : pDestAny->pData = &pDestAny->pReserved;
186 : 34395 : *(sal_Int8 *)pDestAny->pData = *(sal_Int8 *)pSource;
187 : 34395 : break;
188 : : case typelib_TypeClass_SHORT:
189 : : case typelib_TypeClass_UNSIGNED_SHORT:
190 : 5306482 : pDestAny->pData = &pDestAny->pReserved;
191 : 5306482 : *(sal_Int16 *)pDestAny->pData = *(sal_Int16 *)pSource;
192 : 5306482 : break;
193 : : case typelib_TypeClass_LONG:
194 : : case typelib_TypeClass_UNSIGNED_LONG:
195 : 7739805 : pDestAny->pData = &pDestAny->pReserved;
196 : 7739805 : *(sal_Int32 *)pDestAny->pData = *(sal_Int32 *)pSource;
197 : 7739805 : break;
198 : : case typelib_TypeClass_HYPER:
199 : : case typelib_TypeClass_UNSIGNED_HYPER:
200 : : if (sizeof(void *) >= sizeof(sal_Int64))
201 : : pDestAny->pData = &pDestAny->pReserved;
202 : : else
203 : 207951 : pDestAny->pData = ::rtl_allocateMemory( sizeof(sal_Int64) );
204 : 207951 : *(sal_Int64 *)pDestAny->pData = *(sal_Int64 *)pSource;
205 : 207951 : break;
206 : : case typelib_TypeClass_FLOAT:
207 : : if (sizeof(void *) >= sizeof(float))
208 : 806588 : pDestAny->pData = &pDestAny->pReserved;
209 : : else
210 : : pDestAny->pData = ::rtl_allocateMemory( sizeof(float) );
211 : 806588 : *(float *)pDestAny->pData = *(float *)pSource;
212 : 806588 : break;
213 : : case typelib_TypeClass_DOUBLE:
214 : : if (sizeof(void *) >= sizeof(double))
215 : : pDestAny->pData = &pDestAny->pReserved;
216 : : else
217 : 429966 : pDestAny->pData = ::rtl_allocateMemory( sizeof(double) );
218 : 429966 : *(double *)pDestAny->pData = *(double *)pSource;
219 : 429966 : break;
220 : : case typelib_TypeClass_STRING:
221 : 28549120 : ::rtl_uString_acquire( *(rtl_uString **)pSource );
222 : 28549124 : pDestAny->pData = &pDestAny->pReserved;
223 : 28549124 : *(rtl_uString **)pDestAny->pData = *(rtl_uString **)pSource;
224 : 28549124 : break;
225 : : case typelib_TypeClass_TYPE:
226 : 137760 : TYPE_ACQUIRE( *(typelib_TypeDescriptionReference **)pSource );
227 : 137760 : pDestAny->pData = &pDestAny->pReserved;
228 : 137760 : *(typelib_TypeDescriptionReference **)pDestAny->pData = *(typelib_TypeDescriptionReference **)pSource;
229 : 137760 : break;
230 : : case typelib_TypeClass_ANY:
231 : : OSL_FAIL( "### unexpected nested any!" );
232 : 0 : break;
233 : : case typelib_TypeClass_ENUM:
234 : 1562222 : pDestAny->pData = &pDestAny->pReserved;
235 : : // enum is forced to 32bit long
236 : 1562222 : *(sal_Int32 *)pDestAny->pData = *(sal_Int32 *)pSource;
237 : 1562222 : break;
238 : : case typelib_TypeClass_STRUCT:
239 : : case typelib_TypeClass_EXCEPTION:
240 [ + + ]: 3556979 : if (pTypeDescr)
241 : : {
242 : 16992 : pDestAny->pData = ::rtl_allocateMemory( pTypeDescr->nSize );
243 : : _copyConstructStruct(
244 : : pDestAny->pData, pSource,
245 : : (typelib_CompoundTypeDescription *)pTypeDescr,
246 : 16992 : acquire, mapping );
247 : : }
248 : : else
249 : : {
250 [ + - ][ - + ]: 3539987 : TYPELIB_DANGER_GET( &pTypeDescr, pType );
[ + - ][ + + ]
[ + - ]
251 : 3539987 : pDestAny->pData = ::rtl_allocateMemory( pTypeDescr->nSize );
252 : : _copyConstructStruct(
253 : : pDestAny->pData, pSource,
254 : : (typelib_CompoundTypeDescription *)pTypeDescr,
255 : 3539987 : acquire, mapping );
256 [ - + ][ + - ]: 3539987 : TYPELIB_DANGER_RELEASE( pTypeDescr );
257 : : }
258 : 3556979 : break;
259 : : case typelib_TypeClass_ARRAY:
260 [ # # ]: 0 : if (pTypeDescr)
261 : : {
262 : 0 : pDestAny->pData = ::rtl_allocateMemory( pTypeDescr->nSize );
263 : : _copyConstructArray(
264 : : pDestAny->pData, pSource,
265 : : (typelib_ArrayTypeDescription *)pTypeDescr,
266 : 0 : acquire, mapping );
267 : : }
268 : : else
269 : : {
270 [ # # ][ # # ]: 0 : TYPELIB_DANGER_GET( &pTypeDescr, pType );
[ # # ][ # # ]
[ # # ]
271 : 0 : pDestAny->pData = ::rtl_allocateMemory( pTypeDescr->nSize );
272 : : _copyConstructArray(
273 : : pDestAny->pData, pSource,
274 : : (typelib_ArrayTypeDescription *)pTypeDescr,
275 : 0 : acquire, mapping );
276 [ # # ][ # # ]: 0 : TYPELIB_DANGER_RELEASE( pTypeDescr );
277 : : }
278 : 0 : break;
279 : : case typelib_TypeClass_UNION:
280 [ # # ]: 0 : if (pTypeDescr)
281 : : {
282 : 0 : pDestAny->pData = ::rtl_allocateMemory( pTypeDescr->nSize );
283 : 0 : _copyConstructUnion( pDestAny->pData, pSource, pTypeDescr, acquire, mapping );
284 : : }
285 : : else
286 : : {
287 [ # # ][ # # ]: 0 : TYPELIB_DANGER_GET( &pTypeDescr, pType );
[ # # ][ # # ]
[ # # ]
288 : 0 : pDestAny->pData = ::rtl_allocateMemory( pTypeDescr->nSize );
289 : 0 : _copyConstructUnion( pDestAny->pData, pSource, pTypeDescr, acquire, mapping );
290 [ # # ][ # # ]: 0 : TYPELIB_DANGER_RELEASE( pTypeDescr );
291 : : }
292 : 0 : break;
293 : : case typelib_TypeClass_SEQUENCE:
294 : 5659027 : pDestAny->pData = &pDestAny->pReserved;
295 [ + + ]: 5659027 : if (pTypeDescr)
296 : : {
297 : : *(uno_Sequence **)pDestAny->pData = copyConstructSequence(
298 : : *(uno_Sequence **)pSource,
299 : : ((typelib_IndirectTypeDescription *)pTypeDescr)->pType,
300 : 44105 : acquire, mapping );
301 : : }
302 : : else
303 : : {
304 [ + - ][ - + ]: 5614922 : TYPELIB_DANGER_GET( &pTypeDescr, pType );
[ + - ][ - + ]
[ # # ]
305 : : *(uno_Sequence **)pDestAny->pData = copyConstructSequence(
306 : : *(uno_Sequence **)pSource,
307 : : ((typelib_IndirectTypeDescription *)pTypeDescr)->pType,
308 : 5614922 : acquire, mapping );
309 [ - + ][ + - ]: 5614922 : TYPELIB_DANGER_RELEASE( pTypeDescr );
310 : : }
311 : 5659027 : break;
312 : : case typelib_TypeClass_INTERFACE:
313 : 36699822 : pDestAny->pData = &pDestAny->pReserved;
314 [ + + ]: 36699822 : if (mapping)
315 : : {
316 : 52861 : pDestAny->pReserved = _map( *(void **)pSource, pType, pTypeDescr, mapping );
317 : : }
318 : : else
319 : : {
320 : 36646961 : _acquire( pDestAny->pReserved = *(void **)pSource, acquire );
321 : : }
322 : 36699806 : break;
323 : : default:
324 : : OSL_ASSERT(false);
325 : 0 : break;
326 : : }
327 : 106781593 : }
328 : : //--------------------------------------------------------------------------------------------------
329 : 121696467 : inline void _copyConstructAny(
330 : : uno_Any * pDestAny, void * pSource,
331 : : typelib_TypeDescriptionReference * pType, typelib_TypeDescription * pTypeDescr,
332 : : uno_AcquireFunc acquire, uno_Mapping * mapping )
333 : : SAL_THROW (())
334 : : {
335 [ + + ]: 121696467 : if (typelib_TypeClass_VOID == pType->eTypeClass)
336 : : {
337 : 14953276 : CONSTRUCT_EMPTY_ANY( pDestAny );
338 : : }
339 : : else
340 : : {
341 [ + + ]: 106743191 : if (typelib_TypeClass_ANY == pType->eTypeClass)
342 : : {
343 [ + - ]: 476887 : if (pSource)
344 : : {
345 : 476887 : pType = ((uno_Any *)pSource)->pType;
346 [ + + ]: 476887 : if (typelib_TypeClass_VOID == pType->eTypeClass)
347 : : {
348 : 179944 : CONSTRUCT_EMPTY_ANY( pDestAny );
349 : 179944 : return;
350 : : }
351 : 296943 : pTypeDescr = 0;
352 : 296943 : pSource = ((uno_Any *)pSource)->pData;
353 : : }
354 : : else
355 : : {
356 : 0 : CONSTRUCT_EMPTY_ANY( pDestAny );
357 : 0 : return;
358 : : }
359 : : }
360 [ + + ]: 106563247 : if (pSource)
361 : : {
362 : 106454706 : _copyConstructAnyFromData( pDestAny, pSource, pType, pTypeDescr, acquire, mapping );
363 : : }
364 : : else // default construct
365 : : {
366 : 108541 : TYPE_ACQUIRE( pType );
367 : 108541 : pDestAny->pType = pType;
368 [ - + - + : 108541 : switch (pType->eTypeClass)
+ - - - +
- + + - -
+ + - ]
369 : : {
370 : : case typelib_TypeClass_CHAR:
371 : 0 : pDestAny->pData = &pDestAny->pReserved;
372 : 0 : *(sal_Unicode *)pDestAny->pData = '\0';
373 : 0 : break;
374 : : case typelib_TypeClass_BOOLEAN:
375 : 18 : pDestAny->pData = &pDestAny->pReserved;
376 : 18 : *(sal_Bool *)pDestAny->pData = sal_False;
377 : 18 : break;
378 : : case typelib_TypeClass_BYTE:
379 : 0 : pDestAny->pData = &pDestAny->pReserved;
380 : 0 : *(sal_Int8 *)pDestAny->pData = 0;
381 : 0 : break;
382 : : case typelib_TypeClass_SHORT:
383 : : case typelib_TypeClass_UNSIGNED_SHORT:
384 : 15 : pDestAny->pData = &pDestAny->pReserved;
385 : 15 : *(sal_Int16 *)pDestAny->pData = 0;
386 : 15 : break;
387 : : case typelib_TypeClass_LONG:
388 : : case typelib_TypeClass_UNSIGNED_LONG:
389 : 5768 : pDestAny->pData = &pDestAny->pReserved;
390 : 5768 : *(sal_Int32 *)pDestAny->pData = 0;
391 : 5768 : break;
392 : : case typelib_TypeClass_HYPER:
393 : : case typelib_TypeClass_UNSIGNED_HYPER:
394 : : if (sizeof(void *) >= sizeof(sal_Int64))
395 : : pDestAny->pData = &pDestAny->pReserved;
396 : : else
397 : 0 : pDestAny->pData = ::rtl_allocateMemory( sizeof(sal_Int64) );
398 : 0 : *(sal_Int64 *)pDestAny->pData = 0;
399 : 0 : break;
400 : : case typelib_TypeClass_FLOAT:
401 : : if (sizeof(void *) >= sizeof(float))
402 : 0 : pDestAny->pData = &pDestAny->pReserved;
403 : : else
404 : : pDestAny->pData = ::rtl_allocateMemory( sizeof(float) );
405 : 0 : *(float *)pDestAny->pData = 0.0;
406 : 0 : break;
407 : : case typelib_TypeClass_DOUBLE:
408 : : if (sizeof(void *) >= sizeof(double))
409 : : pDestAny->pData = &pDestAny->pReserved;
410 : : else
411 : 0 : pDestAny->pData = ::rtl_allocateMemory( sizeof(double) );
412 : 0 : *(double *)pDestAny->pData = 0.0;
413 : 0 : break;
414 : : case typelib_TypeClass_STRING:
415 : 3330 : pDestAny->pData = &pDestAny->pReserved;
416 : 3330 : *(rtl_uString **)pDestAny->pData = 0;
417 : 3330 : ::rtl_uString_new( (rtl_uString **)pDestAny->pData );
418 : 3330 : break;
419 : : case typelib_TypeClass_TYPE:
420 : 0 : pDestAny->pData = &pDestAny->pReserved;
421 : 0 : *(typelib_TypeDescriptionReference **)pDestAny->pData = _getVoidType();
422 : 0 : break;
423 : : case typelib_TypeClass_ENUM:
424 : 4 : pDestAny->pData = &pDestAny->pReserved;
425 [ - + ]: 4 : if (pTypeDescr)
426 : : {
427 : 0 : *(sal_Int32 *)pDestAny->pData = ((typelib_EnumTypeDescription *)pTypeDescr)->nDefaultEnumValue;
428 : : }
429 : : else
430 : : {
431 [ + - ][ - + ]: 4 : TYPELIB_DANGER_GET( &pTypeDescr, pType );
[ + - ][ - + ]
[ # # ]
432 : 4 : *(sal_Int32 *)pDestAny->pData = ((typelib_EnumTypeDescription *)pTypeDescr)->nDefaultEnumValue;
433 [ + - ][ - + ]: 4 : TYPELIB_DANGER_RELEASE( pTypeDescr );
434 : : }
435 : 4 : break;
436 : : case typelib_TypeClass_STRUCT:
437 : : case typelib_TypeClass_EXCEPTION:
438 [ + - ]: 7855 : if (pTypeDescr)
439 : : {
440 : 7855 : pDestAny->pData = ::rtl_allocateMemory( pTypeDescr->nSize );
441 : : _defaultConstructStruct(
442 : 7855 : pDestAny->pData, (typelib_CompoundTypeDescription *)pTypeDescr );
443 : : }
444 : : else
445 : : {
446 [ # # ][ # # ]: 0 : TYPELIB_DANGER_GET( &pTypeDescr, pType );
[ # # ][ # # ]
[ # # ]
447 : 0 : pDestAny->pData = ::rtl_allocateMemory( pTypeDescr->nSize );
448 : : _defaultConstructStruct(
449 : 0 : pDestAny->pData, (typelib_CompoundTypeDescription *)pTypeDescr );
450 [ # # ][ # # ]: 0 : TYPELIB_DANGER_RELEASE( pTypeDescr );
451 : : }
452 : 7855 : break;
453 : : case typelib_TypeClass_ARRAY:
454 [ # # ]: 0 : if (pTypeDescr)
455 : : {
456 : 0 : pDestAny->pData = ::rtl_allocateMemory( pTypeDescr->nSize );
457 : : _defaultConstructArray(
458 : 0 : pDestAny->pData, (typelib_ArrayTypeDescription *)pTypeDescr );
459 : : }
460 : : else
461 : : {
462 [ # # ][ # # ]: 0 : TYPELIB_DANGER_GET( &pTypeDescr, pType );
[ # # ][ # # ]
[ # # ]
463 : 0 : pDestAny->pData = ::rtl_allocateMemory( pTypeDescr->nSize );
464 : : _defaultConstructArray(
465 : 0 : pDestAny->pData, (typelib_ArrayTypeDescription *)pTypeDescr );
466 [ # # ][ # # ]: 0 : TYPELIB_DANGER_RELEASE( pTypeDescr );
467 : : }
468 : 0 : break;
469 : : case typelib_TypeClass_UNION:
470 [ # # ]: 0 : if (pTypeDescr)
471 : : {
472 : 0 : pDestAny->pData = ::rtl_allocateMemory( pTypeDescr->nSize );
473 : 0 : _defaultConstructUnion( pDestAny->pData, pTypeDescr );
474 : : }
475 : : else
476 : : {
477 [ # # ][ # # ]: 0 : TYPELIB_DANGER_GET( &pTypeDescr, pType );
[ # # ][ # # ]
[ # # ]
478 : 0 : pDestAny->pData = ::rtl_allocateMemory( pTypeDescr->nSize );
479 : 0 : _defaultConstructUnion( pDestAny->pData, pTypeDescr );
480 [ # # ][ # # ]: 0 : TYPELIB_DANGER_RELEASE( pTypeDescr );
481 : : }
482 : 0 : break;
483 : : case typelib_TypeClass_SEQUENCE:
484 : 91246 : pDestAny->pData = &pDestAny->pReserved;
485 : 91246 : *(uno_Sequence **)pDestAny->pData = createEmptySequence();
486 : 91246 : break;
487 : : case typelib_TypeClass_INTERFACE:
488 : 305 : pDestAny->pData = &pDestAny->pReserved;
489 : 305 : pDestAny->pReserved = 0; // either cpp or c-uno interface
490 : 305 : break;
491 : : default:
492 : : OSL_ASSERT(false);
493 : 121696492 : break;
494 : : }
495 : : }
496 : : }
497 : : }
498 : : //------------------------------------------------------------------------------
499 : 5778341 : inline uno_Sequence * icopyConstructSequence(
500 : : uno_Sequence * pSource,
501 : : typelib_TypeDescriptionReference * pElementType,
502 : : uno_AcquireFunc acquire, uno_Mapping * mapping )
503 : : {
504 : 5778341 : typelib_TypeClass eTypeClass = pElementType->eTypeClass;
505 [ + + ][ + + ]: 5778341 : if (!mapping ||
[ + + ]
506 : : (eTypeClass <= typelib_TypeClass_ENUM &&
507 : : eTypeClass != typelib_TypeClass_ANY))
508 : : {
509 : 5682222 : ::osl_incrementInterlockedCount( &pSource->nRefCount );
510 : 5682222 : return pSource;
511 : : }
512 : : else // create new sequence
513 : : {
514 : : uno_Sequence * pDest;
515 : 96119 : sal_Int32 nElements = pSource->nElements;
516 [ + + ]: 96119 : if (nElements)
517 : : {
518 [ + + - - : 60002 : switch (eTypeClass)
+ + - ]
519 : : {
520 : : case typelib_TypeClass_ANY:
521 : : {
522 : 51489 : pDest = allocSeq( sizeof (uno_Any), nElements );
523 [ + - ]: 51489 : if (pDest != 0)
524 : : {
525 : 51489 : uno_Any * pDestElements = (uno_Any *)pDest->elements;
526 : 51489 : uno_Any * pSourceElements = (uno_Any *)pSource->elements;
527 [ + + ]: 379595 : for ( sal_Int32 nPos = nElements; nPos--; )
528 : : {
529 : : typelib_TypeDescriptionReference * pType =
530 : 328106 : pSourceElements[nPos].pType;
531 [ + + ]: 328106 : if (typelib_TypeClass_VOID == pType->eTypeClass)
532 : : {
533 : 1365 : CONSTRUCT_EMPTY_ANY( &pDestElements[nPos] );
534 : : }
535 : : else
536 : : {
537 : : _copyConstructAnyFromData(
538 : : &pDestElements[nPos],
539 : 326741 : pSourceElements[nPos].pData,
540 : : pType, 0,
541 : 326741 : acquire, mapping );
542 : : }
543 : : }
544 : : }
545 : 51489 : break;
546 : : }
547 : : case typelib_TypeClass_STRUCT:
548 : : case typelib_TypeClass_EXCEPTION:
549 : : {
550 : 8009 : typelib_TypeDescription * pElementTypeDescr = 0;
551 [ + - ][ - + ]: 8009 : TYPELIB_DANGER_GET( &pElementTypeDescr, pElementType );
[ + - ][ - + ]
[ # # ]
552 : 8009 : sal_Int32 nElementSize = pElementTypeDescr->nSize;
553 : 8009 : char * pSourceElements = pSource->elements;
554 : 8009 : pDest = allocSeq( nElementSize, nElements );
555 [ + - ]: 8009 : if (pDest != 0)
556 : : {
557 : 8009 : char * pElements = pDest->elements;
558 [ + + ]: 34192 : for ( sal_Int32 nPos = nElements; nPos--; )
559 : : {
560 : : _copyConstructStruct(
561 : 26183 : pElements + (nPos * nElementSize),
562 : 26183 : pSourceElements + (nPos * nElementSize),
563 : : (typelib_CompoundTypeDescription *)
564 : : pElementTypeDescr,
565 [ + - ]: 26183 : acquire, mapping );
566 : : }
567 : : }
568 [ + - ][ - + ]: 8009 : TYPELIB_DANGER_RELEASE( pElementTypeDescr );
569 : : break;
570 : : }
571 : : case typelib_TypeClass_ARRAY:
572 : : {
573 : 0 : typelib_TypeDescription * pElementTypeDescr = 0;
574 [ # # ][ # # ]: 0 : TYPELIB_DANGER_GET( &pElementTypeDescr, pElementType );
[ # # ][ # # ]
[ # # ]
575 : 0 : sal_Int32 nElementSize = pElementTypeDescr->nSize;
576 : 0 : char * pSourceElements = pSource->elements;
577 : 0 : pDest = allocSeq( nElementSize, nElements );
578 [ # # ]: 0 : if (pDest != 0)
579 : : {
580 : 0 : char * pElements = pDest->elements;
581 [ # # ]: 0 : for ( sal_Int32 nPos = nElements; nPos--; )
582 : : {
583 : : _copyConstructArray(
584 : 0 : pElements + (nPos * nElementSize),
585 : 0 : pSourceElements + (nPos * nElementSize),
586 : : (typelib_ArrayTypeDescription *)pElementTypeDescr,
587 : 0 : acquire, mapping );
588 : : }
589 : : }
590 [ # # ][ # # ]: 0 : TYPELIB_DANGER_RELEASE( pElementTypeDescr );
591 : : break;
592 : : }
593 : : case typelib_TypeClass_UNION:
594 : : {
595 : 0 : typelib_TypeDescription * pElementTypeDescr = 0;
596 [ # # ][ # # ]: 0 : TYPELIB_DANGER_GET( &pElementTypeDescr, pElementType );
[ # # ][ # # ]
[ # # ]
597 : 0 : sal_Int32 nElementSize = pElementTypeDescr->nSize;
598 : : sal_Int32 nValueOffset =
599 : : ((typelib_UnionTypeDescription *)
600 : 0 : pElementTypeDescr)->nValueOffset;
601 : 0 : pDest = allocSeq( nElementSize, nElements );
602 [ # # ]: 0 : if (pDest != 0)
603 : : {
604 : 0 : char * pElements = pDest->elements;
605 : 0 : char * pSourceElements = pSource->elements;
606 [ # # ]: 0 : for ( sal_Int32 nPos = nElements; nPos--; )
607 : : {
608 : : char * pDest2 =
609 : 0 : pElements + (nPos * nElementSize);
610 : : char * pSource2 =
611 : 0 : pSourceElements + (nPos * nElementSize);
612 : :
613 : : typelib_TypeDescriptionReference * pSetType =
614 : 0 : _unionGetSetType( pSource2, pElementTypeDescr );
615 : : ::uno_type_copyAndConvertData(
616 : 0 : pDest2 + nValueOffset, pSource2 + nValueOffset,
617 : 0 : pSetType, mapping );
618 : 0 : *(sal_Int64 *)pDest2 = *(sal_Int64 *)pSource2;
619 : 0 : ::typelib_typedescriptionreference_release( pSetType );
620 : : }
621 : : }
622 [ # # ][ # # ]: 0 : TYPELIB_DANGER_RELEASE( pElementTypeDescr );
623 : : break;
624 : : }
625 : : case typelib_TypeClass_SEQUENCE: // sequence of sequence
626 : : {
627 : 306 : pDest = allocSeq( sizeof (uno_Sequence *), nElements );
628 [ + - ]: 306 : if (pDest != 0)
629 : : {
630 : 306 : typelib_TypeDescription * pElementTypeDescr = 0;
631 [ + - ][ - + ]: 306 : TYPELIB_DANGER_GET( &pElementTypeDescr, pElementType );
[ + - ][ - + ]
[ # # ]
632 : : typelib_TypeDescriptionReference * pSeqElementType =
633 : : ((typelib_IndirectTypeDescription *)
634 : 306 : pElementTypeDescr)->pType;
635 : :
636 : : uno_Sequence ** pDestElements =
637 : 306 : (uno_Sequence **) pDest->elements;
638 : : uno_Sequence ** pSourceElements =
639 : 306 : (uno_Sequence **) pSource->elements;
640 [ + + ]: 1426 : for ( sal_Int32 nPos = nElements; nPos--; )
641 : : {
642 : : uno_Sequence * pNew = copyConstructSequence(
643 : 1120 : pSourceElements[nPos],
644 : : pSeqElementType,
645 [ + - ]: 1120 : acquire, mapping );
646 : : OSL_ASSERT( pNew != 0 );
647 : : // ought never be a memory allocation problem,
648 : : // because of reference counted sequence handles
649 : 1120 : pDestElements[ nPos ] = pNew;
650 : : }
651 : :
652 [ + - ][ - + ]: 306 : TYPELIB_DANGER_RELEASE( pElementTypeDescr );
653 : : }
654 : 306 : break;
655 : : }
656 : : case typelib_TypeClass_INTERFACE:
657 : : {
658 : 198 : pDest = allocSeq( sizeof (void *), nElements );
659 [ + - ]: 198 : if (pDest != 0)
660 : : {
661 : 198 : char * pElements = pDest->elements;
662 : 198 : void ** pSourceElements = (void **)pSource->elements;
663 [ + - ]: 198 : if (mapping)
664 : : {
665 : 198 : typelib_TypeDescription * pElementTypeDescr = 0;
666 [ + - ][ - + ]: 198 : TYPELIB_DANGER_GET( &pElementTypeDescr, pElementType );
[ + - ][ + + ]
[ + - ]
667 [ + + ]: 564 : for ( sal_Int32 nPos = nElements; nPos--; )
668 : : {
669 : 366 : ((void **)pElements)[nPos] = 0;
670 [ + + ]: 366 : if (((void **)pSourceElements)[nPos])
671 : : {
672 : : (*mapping->mapInterface)(
673 : : mapping, (void **)pElements + nPos,
674 : 328 : pSourceElements[nPos],
675 : : (typelib_InterfaceTypeDescription *)
676 [ + - ]: 328 : pElementTypeDescr );
677 : : }
678 : : }
679 [ + - ][ - + ]: 198 : TYPELIB_DANGER_RELEASE( pElementTypeDescr );
680 : : }
681 : : else
682 : : {
683 [ # # ]: 0 : for ( sal_Int32 nPos = nElements; nPos--; )
684 : : {
685 : 0 : ((void **)pElements)[nPos] = pSourceElements[nPos];
686 : 0 : _acquire( ((void **)pElements)[nPos], acquire );
687 : : }
688 : : }
689 : : }
690 : 198 : break;
691 : : }
692 : : default:
693 : : OSL_FAIL( "### unexepcted sequence element type!" );
694 : 0 : pDest = 0;
695 : 60002 : break;
696 : : }
697 : : }
698 : : else // empty sequence
699 : : {
700 : 36117 : pDest = allocSeq( 0, 0 );
701 : : }
702 : :
703 : 5778341 : return pDest;
704 : : }
705 : : }
706 : :
707 : : //--------------------------------------------------------------------------------------------------
708 : 56683986 : inline void _copyConstructData(
709 : : void * pDest, void * pSource,
710 : : typelib_TypeDescriptionReference * pType, typelib_TypeDescription * pTypeDescr,
711 : : uno_AcquireFunc acquire, uno_Mapping * mapping )
712 : : SAL_THROW (())
713 : : {
714 [ + + + + : 56683986 : switch (pType->eTypeClass)
+ + + + +
+ + + + -
- + + + ]
715 : : {
716 : : case typelib_TypeClass_CHAR:
717 : 1193 : *(sal_Unicode *)pDest = *(sal_Unicode *)pSource;
718 : 1193 : break;
719 : : case typelib_TypeClass_BOOLEAN:
720 : 331821 : *(sal_Bool *)pDest = (*(sal_Bool *)pSource != sal_False);
721 : 331821 : break;
722 : : case typelib_TypeClass_BYTE:
723 : 672 : *(sal_Int8 *)pDest = *(sal_Int8 *)pSource;
724 : 672 : break;
725 : : case typelib_TypeClass_SHORT:
726 : : case typelib_TypeClass_UNSIGNED_SHORT:
727 : 2424864 : *(sal_Int16 *)pDest = *(sal_Int16 *)pSource;
728 : 2424864 : break;
729 : : case typelib_TypeClass_LONG:
730 : : case typelib_TypeClass_UNSIGNED_LONG:
731 : 13227834 : *(sal_Int32 *)pDest = *(sal_Int32 *)pSource;
732 : 13227834 : break;
733 : : case typelib_TypeClass_HYPER:
734 : : case typelib_TypeClass_UNSIGNED_HYPER:
735 : 1308 : *(sal_Int64 *)pDest = *(sal_Int64 *)pSource;
736 : 1308 : break;
737 : : case typelib_TypeClass_FLOAT:
738 : 278735 : *(float *)pDest = *(float *)pSource;
739 : 278735 : break;
740 : : case typelib_TypeClass_DOUBLE:
741 : 354749 : *(double *)pDest = *(double *)pSource;
742 : 354749 : break;
743 : : case typelib_TypeClass_STRING:
744 : 14675385 : ::rtl_uString_acquire( *(rtl_uString **)pSource );
745 : 14675387 : *(rtl_uString **)pDest = *(rtl_uString **)pSource;
746 : 14675387 : break;
747 : : case typelib_TypeClass_TYPE:
748 : 582301 : TYPE_ACQUIRE( *(typelib_TypeDescriptionReference **)pSource );
749 : 582301 : *(typelib_TypeDescriptionReference **)pDest = *(typelib_TypeDescriptionReference **)pSource;
750 : 582301 : break;
751 : : case typelib_TypeClass_ANY:
752 : : _copyConstructAny(
753 : : (uno_Any *)pDest, ((uno_Any *)pSource)->pData,
754 : : ((uno_Any *)pSource)->pType, 0,
755 : 11861405 : acquire, mapping );
756 : 11861405 : break;
757 : : case typelib_TypeClass_ENUM:
758 : 11738438 : *(sal_Int32 *)pDest = *(sal_Int32 *)pSource;
759 : 11738438 : break;
760 : : case typelib_TypeClass_STRUCT:
761 : : case typelib_TypeClass_EXCEPTION:
762 [ + + ]: 245426 : if (pTypeDescr)
763 : : {
764 : : _copyConstructStruct(
765 : : pDest, pSource,
766 : : (typelib_CompoundTypeDescription *)pTypeDescr,
767 : 28155 : acquire, mapping );
768 : : }
769 : : else
770 : : {
771 [ + - ][ - + ]: 217271 : TYPELIB_DANGER_GET( &pTypeDescr, pType );
[ + - ][ + + ]
[ # # ]
772 : : _copyConstructStruct(
773 : : pDest, pSource,
774 : : (typelib_CompoundTypeDescription *)pTypeDescr,
775 : 217270 : acquire, mapping );
776 [ - + ][ + - ]: 217271 : TYPELIB_DANGER_RELEASE( pTypeDescr );
777 : : }
778 : 245426 : break;
779 : : case typelib_TypeClass_ARRAY:
780 [ # # ]: 0 : if (pTypeDescr)
781 : : {
782 : : _copyConstructArray(
783 : : pDest, pSource,
784 : : (typelib_ArrayTypeDescription *)pTypeDescr,
785 : 0 : acquire, mapping );
786 : : }
787 : : else
788 : : {
789 [ # # ][ # # ]: 0 : TYPELIB_DANGER_GET( &pTypeDescr, pType );
[ # # ][ # # ]
[ # # ]
790 : : _copyConstructArray(
791 : : pDest, pSource,
792 : : (typelib_ArrayTypeDescription *)pTypeDescr,
793 : 0 : acquire, mapping );
794 [ # # ][ # # ]: 0 : TYPELIB_DANGER_RELEASE( pTypeDescr );
795 : : }
796 : 0 : break;
797 : : case typelib_TypeClass_UNION:
798 [ # # ]: 0 : if (pTypeDescr)
799 : : {
800 : 0 : _copyConstructUnion( pDest, pSource, pTypeDescr, acquire, mapping );
801 : : }
802 : : else
803 : : {
804 [ # # ][ # # ]: 0 : TYPELIB_DANGER_GET( &pTypeDescr, pType );
[ # # ][ # # ]
[ # # ]
805 : 0 : _copyConstructUnion( pDest, pSource, pTypeDescr, acquire, mapping );
806 [ # # ][ # # ]: 0 : TYPELIB_DANGER_RELEASE( pTypeDescr );
807 : : }
808 : 0 : break;
809 : : case typelib_TypeClass_SEQUENCE:
810 [ + + ]: 449600 : if (mapping)
811 : : {
812 [ + + ]: 95073 : if (pTypeDescr)
813 : : {
814 : : *(uno_Sequence **)pDest = icopyConstructSequence(
815 : : *(uno_Sequence **)pSource,
816 : : ((typelib_IndirectTypeDescription *)pTypeDescr)->pType,
817 : 37181 : acquire, mapping );
818 : : }
819 : : else
820 : : {
821 [ + - ][ - + ]: 57892 : TYPELIB_DANGER_GET( &pTypeDescr, pType );
[ + - ][ - + ]
[ # # ]
822 : : *(uno_Sequence **)pDest = icopyConstructSequence(
823 : : *(uno_Sequence **)pSource,
824 : : ((typelib_IndirectTypeDescription *)pTypeDescr)->pType,
825 : 57892 : acquire, mapping );
826 [ - + ][ + - ]: 57892 : TYPELIB_DANGER_RELEASE( pTypeDescr );
827 : : }
828 : : }
829 : : else
830 : : {
831 : 354527 : ::osl_incrementInterlockedCount( &(*(uno_Sequence **)pSource)->nRefCount );
832 : 354527 : *(uno_Sequence **)pDest = *(uno_Sequence **)pSource;
833 : : }
834 : 449600 : break;
835 : : case typelib_TypeClass_INTERFACE:
836 [ + + ]: 510217 : if (mapping)
837 : 175157 : *(void **)pDest = _map( *(void **)pSource, pType, pTypeDescr, mapping );
838 : : else
839 : 335060 : _acquire( *(void **)pDest = *(void **)pSource, acquire );
840 : 510217 : break;
841 : : default:
842 : 38 : break;
843 : : }
844 : 56683988 : }
845 : :
846 : : }
847 : :
848 : : #endif
849 : :
850 : : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
