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 150439 : inline uno_Sequence * allocSeq(
35 : sal_Int32 nElementSize, sal_Int32 nElements )
36 : {
37 : OSL_ASSERT( nElements >= 0 && nElementSize >= 0 );
38 150439 : uno_Sequence * pSeq = 0;
39 150439 : sal_uInt32 nSize = calcSeqMemSize( nElementSize, nElements );
40 150439 : if (nSize > 0)
41 : {
42 150439 : pSeq = (uno_Sequence *) rtl_allocateMemory( nSize );
43 150439 : if (pSeq != 0)
44 : {
45 : // header init
46 150439 : pSeq->nRefCount = 1;
47 150439 : pSeq->nElements = nElements;
48 : }
49 : }
50 150439 : 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 2635138 : inline void _copyConstructStruct(
61 : void * pDest, void * pSource,
62 : typelib_CompoundTypeDescription * pTypeDescr,
63 : uno_AcquireFunc acquire, uno_Mapping * mapping )
64 : SAL_THROW (())
65 : {
66 2635138 : if (pTypeDescr->pBaseTypeDescription)
67 : {
68 : // copy base value
69 321873 : copyConstructStruct( pDest, pSource, pTypeDescr->pBaseTypeDescription, acquire, mapping );
70 : }
71 :
72 : // then copy members
73 2635139 : typelib_TypeDescriptionReference ** ppTypeRefs = pTypeDescr->ppTypeRefs;
74 2635139 : sal_Int32 * pMemberOffsets = pTypeDescr->pMemberOffsets;
75 2635139 : sal_Int32 nDescr = pTypeDescr->nMembers;
76 :
77 2635139 : if (mapping)
78 : {
79 824971 : while (nDescr--)
80 : {
81 : ::uno_type_copyAndConvertData(
82 944134 : (char *)pDest + pMemberOffsets[nDescr],
83 944134 : (char *)pSource + pMemberOffsets[nDescr],
84 1888268 : ppTypeRefs[nDescr], mapping );
85 : }
86 : }
87 : else
88 : {
89 13781379 : while (nDescr--)
90 : {
91 : ::uno_type_copyData(
92 17728010 : (char *)pDest + pMemberOffsets[nDescr],
93 17728010 : (char *)pSource + pMemberOffsets[nDescr],
94 35456020 : ppTypeRefs[nDescr], acquire );
95 : }
96 : }
97 2635139 : }
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 63753013 : 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 63753013 : TYPE_ACQUIRE( pType );
172 63753013 : pDestAny->pType = pType;
173 :
174 63753013 : switch (pType->eTypeClass)
175 : {
176 : case typelib_TypeClass_CHAR:
177 253 : pDestAny->pData = &pDestAny->pReserved;
178 253 : *(sal_Unicode *)pDestAny->pData = *(sal_Unicode *)pSource;
179 253 : break;
180 : case typelib_TypeClass_BOOLEAN:
181 8512774 : pDestAny->pData = &pDestAny->pReserved;
182 8512774 : *(sal_Bool *)pDestAny->pData = (*(sal_Bool *)pSource != sal_False);
183 8512774 : break;
184 : case typelib_TypeClass_BYTE:
185 14308 : pDestAny->pData = &pDestAny->pReserved;
186 14308 : *(sal_Int8 *)pDestAny->pData = *(sal_Int8 *)pSource;
187 14308 : break;
188 : case typelib_TypeClass_SHORT:
189 : case typelib_TypeClass_UNSIGNED_SHORT:
190 3097395 : pDestAny->pData = &pDestAny->pReserved;
191 3097395 : *(sal_Int16 *)pDestAny->pData = *(sal_Int16 *)pSource;
192 3097395 : break;
193 : case typelib_TypeClass_LONG:
194 : case typelib_TypeClass_UNSIGNED_LONG:
195 5051893 : pDestAny->pData = &pDestAny->pReserved;
196 5051893 : *(sal_Int32 *)pDestAny->pData = *(sal_Int32 *)pSource;
197 5051893 : 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 108589 : pDestAny->pData = ::rtl_allocateMemory( sizeof(sal_Int64) );
204 108589 : *(sal_Int64 *)pDestAny->pData = *(sal_Int64 *)pSource;
205 108589 : break;
206 : case typelib_TypeClass_FLOAT:
207 : if (sizeof(void *) >= sizeof(float))
208 443190 : pDestAny->pData = &pDestAny->pReserved;
209 : else
210 : pDestAny->pData = ::rtl_allocateMemory( sizeof(float) );
211 443190 : *(float *)pDestAny->pData = *(float *)pSource;
212 443190 : break;
213 : case typelib_TypeClass_DOUBLE:
214 : if (sizeof(void *) >= sizeof(double))
215 : pDestAny->pData = &pDestAny->pReserved;
216 : else
217 272665 : pDestAny->pData = ::rtl_allocateMemory( sizeof(double) );
218 272665 : *(double *)pDestAny->pData = *(double *)pSource;
219 272665 : break;
220 : case typelib_TypeClass_STRING:
221 17027021 : ::rtl_uString_acquire( *(rtl_uString **)pSource );
222 17027021 : pDestAny->pData = &pDestAny->pReserved;
223 17027021 : *(rtl_uString **)pDestAny->pData = *(rtl_uString **)pSource;
224 17027021 : break;
225 : case typelib_TypeClass_TYPE:
226 69006 : TYPE_ACQUIRE( *(typelib_TypeDescriptionReference **)pSource );
227 69006 : pDestAny->pData = &pDestAny->pReserved;
228 69006 : *(typelib_TypeDescriptionReference **)pDestAny->pData = *(typelib_TypeDescriptionReference **)pSource;
229 69006 : break;
230 : case typelib_TypeClass_ANY:
231 : OSL_FAIL( "### unexpected nested any!" );
232 0 : break;
233 : case typelib_TypeClass_ENUM:
234 860834 : pDestAny->pData = &pDestAny->pReserved;
235 : // enum is forced to 32bit long
236 860834 : *(sal_Int32 *)pDestAny->pData = *(sal_Int32 *)pSource;
237 860834 : break;
238 : case typelib_TypeClass_STRUCT:
239 : case typelib_TypeClass_EXCEPTION:
240 2142318 : if (pTypeDescr)
241 : {
242 9118 : pDestAny->pData = ::rtl_allocateMemory( pTypeDescr->nSize );
243 : _copyConstructStruct(
244 : pDestAny->pData, pSource,
245 : (typelib_CompoundTypeDescription *)pTypeDescr,
246 9118 : acquire, mapping );
247 : }
248 : else
249 : {
250 2133200 : TYPELIB_DANGER_GET( &pTypeDescr, pType );
251 2133200 : pDestAny->pData = ::rtl_allocateMemory( pTypeDescr->nSize );
252 : _copyConstructStruct(
253 : pDestAny->pData, pSource,
254 : (typelib_CompoundTypeDescription *)pTypeDescr,
255 2133200 : acquire, mapping );
256 2133200 : TYPELIB_DANGER_RELEASE( pTypeDescr );
257 : }
258 2142318 : 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 3400554 : pDestAny->pData = &pDestAny->pReserved;
295 3400554 : if (pTypeDescr)
296 : {
297 : *(uno_Sequence **)pDestAny->pData = copyConstructSequence(
298 : *(uno_Sequence **)pSource,
299 : ((typelib_IndirectTypeDescription *)pTypeDescr)->pType,
300 15136 : acquire, mapping );
301 : }
302 : else
303 : {
304 3385418 : TYPELIB_DANGER_GET( &pTypeDescr, pType );
305 : *(uno_Sequence **)pDestAny->pData = copyConstructSequence(
306 : *(uno_Sequence **)pSource,
307 : ((typelib_IndirectTypeDescription *)pTypeDescr)->pType,
308 3385418 : acquire, mapping );
309 3385418 : TYPELIB_DANGER_RELEASE( pTypeDescr );
310 : }
311 3400554 : break;
312 : case typelib_TypeClass_INTERFACE:
313 22752213 : pDestAny->pData = &pDestAny->pReserved;
314 22752213 : if (mapping)
315 : {
316 32637 : pDestAny->pReserved = _map( *(void **)pSource, pType, pTypeDescr, mapping );
317 : }
318 : else
319 : {
320 22719576 : _acquire( pDestAny->pReserved = *(void **)pSource, acquire );
321 : }
322 22752212 : break;
323 : default:
324 : OSL_ASSERT(false);
325 0 : break;
326 : }
327 63753012 : }
328 : //--------------------------------------------------------------------------------------------------
329 71441616 : 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 71441616 : if (typelib_TypeClass_VOID == pType->eTypeClass)
336 : {
337 7703683 : CONSTRUCT_EMPTY_ANY( pDestAny );
338 : }
339 : else
340 : {
341 63737933 : if (typelib_TypeClass_ANY == pType->eTypeClass)
342 : {
343 288744 : if (pSource)
344 : {
345 288744 : pType = ((uno_Any *)pSource)->pType;
346 288744 : if (typelib_TypeClass_VOID == pType->eTypeClass)
347 : {
348 108283 : CONSTRUCT_EMPTY_ANY( pDestAny );
349 108283 : return;
350 : }
351 180461 : pTypeDescr = 0;
352 180461 : pSource = ((uno_Any *)pSource)->pData;
353 : }
354 : else
355 : {
356 0 : CONSTRUCT_EMPTY_ANY( pDestAny );
357 0 : return;
358 : }
359 : }
360 63629650 : if (pSource)
361 : {
362 63575575 : _copyConstructAnyFromData( pDestAny, pSource, pType, pTypeDescr, acquire, mapping );
363 : }
364 : else // default construct
365 : {
366 54075 : TYPE_ACQUIRE( pType );
367 54075 : pDestAny->pType = pType;
368 54075 : 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 11 : pDestAny->pData = &pDestAny->pReserved;
376 11 : *(sal_Bool *)pDestAny->pData = sal_False;
377 11 : 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 11 : pDestAny->pData = &pDestAny->pReserved;
385 11 : *(sal_Int16 *)pDestAny->pData = 0;
386 11 : break;
387 : case typelib_TypeClass_LONG:
388 : case typelib_TypeClass_UNSIGNED_LONG:
389 3435 : pDestAny->pData = &pDestAny->pReserved;
390 3435 : *(sal_Int32 *)pDestAny->pData = 0;
391 3435 : 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 1915 : pDestAny->pData = &pDestAny->pReserved;
416 1915 : *(rtl_uString **)pDestAny->pData = 0;
417 1915 : ::rtl_uString_new( (rtl_uString **)pDestAny->pData );
418 1915 : 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 2 : pDestAny->pData = &pDestAny->pReserved;
425 2 : if (pTypeDescr)
426 : {
427 0 : *(sal_Int32 *)pDestAny->pData = ((typelib_EnumTypeDescription *)pTypeDescr)->nDefaultEnumValue;
428 : }
429 : else
430 : {
431 2 : TYPELIB_DANGER_GET( &pTypeDescr, pType );
432 2 : *(sal_Int32 *)pDestAny->pData = ((typelib_EnumTypeDescription *)pTypeDescr)->nDefaultEnumValue;
433 2 : TYPELIB_DANGER_RELEASE( pTypeDescr );
434 : }
435 2 : break;
436 : case typelib_TypeClass_STRUCT:
437 : case typelib_TypeClass_EXCEPTION:
438 86 : if (pTypeDescr)
439 : {
440 86 : pDestAny->pData = ::rtl_allocateMemory( pTypeDescr->nSize );
441 : _defaultConstructStruct(
442 86 : 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 86 : 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 48444 : pDestAny->pData = &pDestAny->pReserved;
485 48444 : *(uno_Sequence **)pDestAny->pData = createEmptySequence();
486 48444 : break;
487 : case typelib_TypeClass_INTERFACE:
488 171 : pDestAny->pData = &pDestAny->pReserved;
489 171 : pDestAny->pReserved = 0; // either cpp or c-uno interface
490 171 : break;
491 : default:
492 : OSL_ASSERT(false);
493 0 : break;
494 : }
495 : }
496 : }
497 : }
498 : //------------------------------------------------------------------------------
499 3447604 : inline uno_Sequence * icopyConstructSequence(
500 : uno_Sequence * pSource,
501 : typelib_TypeDescriptionReference * pElementType,
502 : uno_AcquireFunc acquire, uno_Mapping * mapping )
503 : {
504 3447604 : typelib_TypeClass eTypeClass = pElementType->eTypeClass;
505 3482839 : if (!mapping ||
506 65238 : (eTypeClass <= typelib_TypeClass_ENUM &&
507 : eTypeClass != typelib_TypeClass_ANY))
508 : {
509 3413868 : osl_atomic_increment( &pSource->nRefCount );
510 3413868 : return pSource;
511 : }
512 : else // create new sequence
513 : {
514 : uno_Sequence * pDest;
515 33736 : sal_Int32 nElements = pSource->nElements;
516 33736 : if (nElements)
517 : {
518 32801 : switch (eTypeClass)
519 : {
520 : case typelib_TypeClass_ANY:
521 : {
522 28414 : pDest = allocSeq( sizeof (uno_Any), nElements );
523 28414 : if (pDest != 0)
524 : {
525 28414 : uno_Any * pDestElements = (uno_Any *)pDest->elements;
526 28414 : uno_Any * pSourceElements = (uno_Any *)pSource->elements;
527 237483 : for ( sal_Int32 nPos = nElements; nPos--; )
528 : {
529 : typelib_TypeDescriptionReference * pType =
530 180655 : pSourceElements[nPos].pType;
531 180655 : if (typelib_TypeClass_VOID == pType->eTypeClass)
532 : {
533 3266 : CONSTRUCT_EMPTY_ANY( &pDestElements[nPos] );
534 : }
535 : else
536 : {
537 : _copyConstructAnyFromData(
538 : &pDestElements[nPos],
539 177389 : pSourceElements[nPos].pData,
540 : pType, 0,
541 177389 : acquire, mapping );
542 : }
543 : }
544 : }
545 28414 : break;
546 : }
547 : case typelib_TypeClass_STRUCT:
548 : case typelib_TypeClass_EXCEPTION:
549 : {
550 4081 : typelib_TypeDescription * pElementTypeDescr = 0;
551 4081 : TYPELIB_DANGER_GET( &pElementTypeDescr, pElementType );
552 4081 : sal_Int32 nElementSize = pElementTypeDescr->nSize;
553 4081 : char * pSourceElements = pSource->elements;
554 4081 : pDest = allocSeq( nElementSize, nElements );
555 4081 : if (pDest != 0)
556 : {
557 4081 : char * pElements = pDest->elements;
558 22038 : for ( sal_Int32 nPos = nElements; nPos--; )
559 : {
560 : _copyConstructStruct(
561 27752 : pElements + (nPos * nElementSize),
562 27752 : pSourceElements + (nPos * nElementSize),
563 : (typelib_CompoundTypeDescription *)
564 : pElementTypeDescr,
565 55504 : acquire, mapping );
566 : }
567 : }
568 4081 : TYPELIB_DANGER_RELEASE( pElementTypeDescr );
569 4081 : 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 0 : 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 0 : break;
624 : }
625 : case typelib_TypeClass_SEQUENCE: // sequence of sequence
626 : {
627 228 : pDest = allocSeq( sizeof (uno_Sequence *), nElements );
628 228 : if (pDest != 0)
629 : {
630 228 : typelib_TypeDescription * pElementTypeDescr = 0;
631 228 : TYPELIB_DANGER_GET( &pElementTypeDescr, pElementType );
632 : typelib_TypeDescriptionReference * pSeqElementType =
633 : ((typelib_IndirectTypeDescription *)
634 228 : pElementTypeDescr)->pType;
635 :
636 : uno_Sequence ** pDestElements =
637 228 : (uno_Sequence **) pDest->elements;
638 : uno_Sequence ** pSourceElements =
639 228 : (uno_Sequence **) pSource->elements;
640 1483 : for ( sal_Int32 nPos = nElements; nPos--; )
641 : {
642 : uno_Sequence * pNew = copyConstructSequence(
643 1027 : pSourceElements[nPos],
644 : pSeqElementType,
645 1027 : acquire, mapping );
646 : OSL_ASSERT( pNew != 0 );
647 : // ought never be a memory allocation problem,
648 : // because of reference counted sequence handles
649 1027 : pDestElements[ nPos ] = pNew;
650 : }
651 :
652 228 : TYPELIB_DANGER_RELEASE( pElementTypeDescr );
653 : }
654 228 : break;
655 : }
656 : case typelib_TypeClass_INTERFACE:
657 : {
658 78 : pDest = allocSeq( sizeof (void *), nElements );
659 78 : if (pDest != 0)
660 : {
661 78 : char * pElements = pDest->elements;
662 78 : void ** pSourceElements = (void **)pSource->elements;
663 78 : if (mapping)
664 : {
665 78 : typelib_TypeDescription * pElementTypeDescr = 0;
666 78 : TYPELIB_DANGER_GET( &pElementTypeDescr, pElementType );
667 295 : for ( sal_Int32 nPos = nElements; nPos--; )
668 : {
669 139 : ((void **)pElements)[nPos] = 0;
670 139 : if (((void **)pSourceElements)[nPos])
671 : {
672 : (*mapping->mapInterface)(
673 : mapping, (void **)pElements + nPos,
674 126 : pSourceElements[nPos],
675 : (typelib_InterfaceTypeDescription *)
676 252 : pElementTypeDescr );
677 : }
678 : }
679 78 : 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 78 : break;
691 : }
692 : default:
693 : OSL_FAIL( "### unexepcted sequence element type!" );
694 0 : pDest = 0;
695 0 : break;
696 : }
697 : }
698 : else // empty sequence
699 : {
700 935 : pDest = allocSeq( 0, 0 );
701 : }
702 :
703 33736 : return pDest;
704 : }
705 : }
706 :
707 : //--------------------------------------------------------------------------------------------------
708 31886224 : 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 31886224 : switch (pType->eTypeClass)
715 : {
716 : case typelib_TypeClass_CHAR:
717 371 : *(sal_Unicode *)pDest = *(sal_Unicode *)pSource;
718 371 : break;
719 : case typelib_TypeClass_BOOLEAN:
720 168397 : *(sal_Bool *)pDest = (*(sal_Bool *)pSource != sal_False);
721 168397 : break;
722 : case typelib_TypeClass_BYTE:
723 177 : *(sal_Int8 *)pDest = *(sal_Int8 *)pSource;
724 177 : break;
725 : case typelib_TypeClass_SHORT:
726 : case typelib_TypeClass_UNSIGNED_SHORT:
727 1231123 : *(sal_Int16 *)pDest = *(sal_Int16 *)pSource;
728 1231123 : break;
729 : case typelib_TypeClass_LONG:
730 : case typelib_TypeClass_UNSIGNED_LONG:
731 7554720 : *(sal_Int32 *)pDest = *(sal_Int32 *)pSource;
732 7554720 : break;
733 : case typelib_TypeClass_HYPER:
734 : case typelib_TypeClass_UNSIGNED_HYPER:
735 271 : *(sal_Int64 *)pDest = *(sal_Int64 *)pSource;
736 271 : break;
737 : case typelib_TypeClass_FLOAT:
738 147379 : *(float *)pDest = *(float *)pSource;
739 147379 : break;
740 : case typelib_TypeClass_DOUBLE:
741 195368 : *(double *)pDest = *(double *)pSource;
742 195368 : break;
743 : case typelib_TypeClass_STRING:
744 8143034 : ::rtl_uString_acquire( *(rtl_uString **)pSource );
745 8143034 : *(rtl_uString **)pDest = *(rtl_uString **)pSource;
746 8143034 : break;
747 : case typelib_TypeClass_TYPE:
748 346468 : TYPE_ACQUIRE( *(typelib_TypeDescriptionReference **)pSource );
749 346468 : *(typelib_TypeDescriptionReference **)pDest = *(typelib_TypeDescriptionReference **)pSource;
750 346468 : break;
751 : case typelib_TypeClass_ANY:
752 : _copyConstructAny(
753 : (uno_Any *)pDest, ((uno_Any *)pSource)->pData,
754 : ((uno_Any *)pSource)->pType, 0,
755 6829523 : acquire, mapping );
756 6829523 : break;
757 : case typelib_TypeClass_ENUM:
758 6770683 : *(sal_Int32 *)pDest = *(sal_Int32 *)pSource;
759 6770683 : break;
760 : case typelib_TypeClass_STRUCT:
761 : case typelib_TypeClass_EXCEPTION:
762 112929 : if (pTypeDescr)
763 : {
764 : _copyConstructStruct(
765 : pDest, pSource,
766 : (typelib_CompoundTypeDescription *)pTypeDescr,
767 14626 : acquire, mapping );
768 : }
769 : else
770 : {
771 98303 : TYPELIB_DANGER_GET( &pTypeDescr, pType );
772 : _copyConstructStruct(
773 : pDest, pSource,
774 : (typelib_CompoundTypeDescription *)pTypeDescr,
775 98303 : acquire, mapping );
776 98303 : TYPELIB_DANGER_RELEASE( pTypeDescr );
777 : }
778 112929 : 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 168432 : if (mapping)
811 : {
812 31076 : if (pTypeDescr)
813 : {
814 : *(uno_Sequence **)pDest = icopyConstructSequence(
815 : *(uno_Sequence **)pSource,
816 : ((typelib_IndirectTypeDescription *)pTypeDescr)->pType,
817 8505 : acquire, mapping );
818 : }
819 : else
820 : {
821 22571 : TYPELIB_DANGER_GET( &pTypeDescr, pType );
822 : *(uno_Sequence **)pDest = icopyConstructSequence(
823 : *(uno_Sequence **)pSource,
824 : ((typelib_IndirectTypeDescription *)pTypeDescr)->pType,
825 22571 : acquire, mapping );
826 22571 : TYPELIB_DANGER_RELEASE( pTypeDescr );
827 : }
828 : }
829 : else
830 : {
831 137356 : osl_atomic_increment( &(*(uno_Sequence **)pSource)->nRefCount );
832 137356 : *(uno_Sequence **)pDest = *(uno_Sequence **)pSource;
833 : }
834 168432 : break;
835 : case typelib_TypeClass_INTERFACE:
836 217326 : if (mapping)
837 86570 : *(void **)pDest = _map( *(void **)pSource, pType, pTypeDescr, mapping );
838 : else
839 130756 : _acquire( *(void **)pDest = *(void **)pSource, acquire );
840 217326 : break;
841 : default:
842 23 : break;
843 : }
844 31886224 : }
845 :
846 : }
847 :
848 : #endif
849 :
850 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
