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 96317 : inline uno_Sequence * allocSeq(
35 : sal_Int32 nElementSize, sal_Int32 nElements )
36 : {
37 : OSL_ASSERT( nElements >= 0 && nElementSize >= 0 );
38 96317 : uno_Sequence * pSeq = 0;
39 96317 : sal_uInt32 nSize = calcSeqMemSize( nElementSize, nElements );
40 96317 : if (nSize > 0)
41 : {
42 96317 : pSeq = (uno_Sequence *) rtl_allocateMemory( nSize );
43 96317 : if (pSeq != 0)
44 : {
45 : // header init
46 96317 : pSeq->nRefCount = 1;
47 96317 : pSeq->nElements = nElements;
48 : }
49 : }
50 96317 : 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 605697 : inline void _copyConstructStruct(
61 : void * pDest, void * pSource,
62 : typelib_CompoundTypeDescription * pTypeDescr,
63 : uno_AcquireFunc acquire, uno_Mapping * mapping )
64 : SAL_THROW (())
65 : {
66 605697 : if (pTypeDescr->pBaseTypeDescription)
67 : {
68 : // copy base value
69 181441 : copyConstructStruct( pDest, pSource, pTypeDescr->pBaseTypeDescription, acquire, mapping );
70 : }
71 :
72 : // then copy members
73 605697 : typelib_TypeDescriptionReference ** ppTypeRefs = pTypeDescr->ppTypeRefs;
74 605697 : sal_Int32 * pMemberOffsets = pTypeDescr->pMemberOffsets;
75 605697 : sal_Int32 nDescr = pTypeDescr->nMembers;
76 :
77 605697 : if (mapping)
78 : {
79 319042 : while (nDescr--)
80 : {
81 : ::uno_type_copyAndConvertData(
82 332960 : (char *)pDest + pMemberOffsets[nDescr],
83 332960 : (char *)pSource + pMemberOffsets[nDescr],
84 665920 : ppTypeRefs[nDescr], mapping );
85 : }
86 : }
87 : else
88 : {
89 2521575 : while (nDescr--)
90 : {
91 : ::uno_type_copyData(
92 2925486 : (char *)pDest + pMemberOffsets[nDescr],
93 2925486 : (char *)pSource + pMemberOffsets[nDescr],
94 5850972 : ppTypeRefs[nDescr], acquire );
95 : }
96 : }
97 605697 : }
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 21610487 : 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 21610487 : TYPE_ACQUIRE( pType );
172 21610487 : pDestAny->pType = pType;
173 :
174 21610487 : switch (pType->eTypeClass)
175 : {
176 : case typelib_TypeClass_CHAR:
177 30 : pDestAny->pData = &pDestAny->pReserved;
178 30 : *(sal_Unicode *)pDestAny->pData = *(sal_Unicode *)pSource;
179 30 : break;
180 : case typelib_TypeClass_BOOLEAN:
181 3433252 : pDestAny->pData = &pDestAny->pReserved;
182 3433252 : *(sal_Bool *)pDestAny->pData = (*(sal_Bool *)pSource != sal_False);
183 3433252 : break;
184 : case typelib_TypeClass_BYTE:
185 9262 : pDestAny->pData = &pDestAny->pReserved;
186 9262 : *(sal_Int8 *)pDestAny->pData = *(sal_Int8 *)pSource;
187 9262 : break;
188 : case typelib_TypeClass_SHORT:
189 : case typelib_TypeClass_UNSIGNED_SHORT:
190 569154 : pDestAny->pData = &pDestAny->pReserved;
191 569154 : *(sal_Int16 *)pDestAny->pData = *(sal_Int16 *)pSource;
192 569154 : break;
193 : case typelib_TypeClass_LONG:
194 : case typelib_TypeClass_UNSIGNED_LONG:
195 1916373 : pDestAny->pData = &pDestAny->pReserved;
196 1916373 : *(sal_Int32 *)pDestAny->pData = *(sal_Int32 *)pSource;
197 1916373 : 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 51994 : pDestAny->pData = ::rtl_allocateMemory( sizeof(sal_Int64) );
204 51994 : *(sal_Int64 *)pDestAny->pData = *(sal_Int64 *)pSource;
205 51994 : break;
206 : case typelib_TypeClass_FLOAT:
207 : if (sizeof(void *) >= sizeof(float))
208 81735 : pDestAny->pData = &pDestAny->pReserved;
209 : else
210 : pDestAny->pData = ::rtl_allocateMemory( sizeof(float) );
211 81735 : *(float *)pDestAny->pData = *(float *)pSource;
212 81735 : break;
213 : case typelib_TypeClass_DOUBLE:
214 : if (sizeof(void *) >= sizeof(double))
215 : pDestAny->pData = &pDestAny->pReserved;
216 : else
217 103050 : pDestAny->pData = ::rtl_allocateMemory( sizeof(double) );
218 103050 : *(double *)pDestAny->pData = *(double *)pSource;
219 103050 : break;
220 : case typelib_TypeClass_STRING:
221 6494832 : ::rtl_uString_acquire( *(rtl_uString **)pSource );
222 6494832 : pDestAny->pData = &pDestAny->pReserved;
223 6494832 : *(rtl_uString **)pDestAny->pData = *(rtl_uString **)pSource;
224 6494832 : break;
225 : case typelib_TypeClass_TYPE:
226 1869 : TYPE_ACQUIRE( *(typelib_TypeDescriptionReference **)pSource );
227 1869 : pDestAny->pData = &pDestAny->pReserved;
228 1869 : *(typelib_TypeDescriptionReference **)pDestAny->pData = *(typelib_TypeDescriptionReference **)pSource;
229 1869 : break;
230 : case typelib_TypeClass_ANY:
231 : OSL_FAIL( "### unexpected nested any!" );
232 0 : break;
233 : case typelib_TypeClass_ENUM:
234 232285 : pDestAny->pData = &pDestAny->pReserved;
235 : // enum is forced to 32bit long
236 232285 : *(sal_Int32 *)pDestAny->pData = *(sal_Int32 *)pSource;
237 232285 : break;
238 : case typelib_TypeClass_STRUCT:
239 : case typelib_TypeClass_EXCEPTION:
240 377053 : if (pTypeDescr)
241 : {
242 431 : pDestAny->pData = ::rtl_allocateMemory( pTypeDescr->nSize );
243 : _copyConstructStruct(
244 : pDestAny->pData, pSource,
245 : (typelib_CompoundTypeDescription *)pTypeDescr,
246 431 : acquire, mapping );
247 : }
248 : else
249 : {
250 376622 : TYPELIB_DANGER_GET( &pTypeDescr, pType );
251 376622 : pDestAny->pData = ::rtl_allocateMemory( pTypeDescr->nSize );
252 : _copyConstructStruct(
253 : pDestAny->pData, pSource,
254 : (typelib_CompoundTypeDescription *)pTypeDescr,
255 376622 : acquire, mapping );
256 376622 : TYPELIB_DANGER_RELEASE( pTypeDescr );
257 : }
258 377053 : 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 779956 : pDestAny->pData = &pDestAny->pReserved;
295 779956 : if (pTypeDescr)
296 : {
297 : *(uno_Sequence **)pDestAny->pData = copyConstructSequence(
298 : *(uno_Sequence **)pSource,
299 : ((typelib_IndirectTypeDescription *)pTypeDescr)->pType,
300 254 : acquire, mapping );
301 : }
302 : else
303 : {
304 779702 : TYPELIB_DANGER_GET( &pTypeDescr, pType );
305 : *(uno_Sequence **)pDestAny->pData = copyConstructSequence(
306 : *(uno_Sequence **)pSource,
307 : ((typelib_IndirectTypeDescription *)pTypeDescr)->pType,
308 779702 : acquire, mapping );
309 779702 : TYPELIB_DANGER_RELEASE( pTypeDescr );
310 : }
311 779956 : break;
312 : case typelib_TypeClass_INTERFACE:
313 7559642 : pDestAny->pData = &pDestAny->pReserved;
314 7559642 : if (mapping)
315 : {
316 1445 : pDestAny->pReserved = _map( *(void **)pSource, pType, pTypeDescr, mapping );
317 : }
318 : else
319 : {
320 7558197 : _acquire( pDestAny->pReserved = *(void **)pSource, acquire );
321 : }
322 7559642 : break;
323 : default:
324 : OSL_ASSERT(false);
325 0 : break;
326 : }
327 21610487 : }
328 : //--------------------------------------------------------------------------------------------------
329 25579452 : 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 25579452 : if (typelib_TypeClass_VOID == pType->eTypeClass)
336 : {
337 3890518 : CONSTRUCT_EMPTY_ANY( pDestAny );
338 : }
339 : else
340 : {
341 21688934 : if (typelib_TypeClass_ANY == pType->eTypeClass)
342 : {
343 182464 : if (pSource)
344 : {
345 182464 : pType = ((uno_Any *)pSource)->pType;
346 182464 : if (typelib_TypeClass_VOID == pType->eTypeClass)
347 : {
348 103626 : CONSTRUCT_EMPTY_ANY( pDestAny );
349 103626 : return;
350 : }
351 78838 : pTypeDescr = 0;
352 78838 : pSource = ((uno_Any *)pSource)->pData;
353 : }
354 : else
355 : {
356 0 : CONSTRUCT_EMPTY_ANY( pDestAny );
357 0 : return;
358 : }
359 : }
360 21585308 : if (pSource)
361 : {
362 21584981 : _copyConstructAnyFromData( pDestAny, pSource, pType, pTypeDescr, acquire, mapping );
363 : }
364 : else // default construct
365 : {
366 327 : TYPE_ACQUIRE( pType );
367 327 : pDestAny->pType = pType;
368 327 : 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 0 : pDestAny->pData = &pDestAny->pReserved;
376 0 : *(sal_Bool *)pDestAny->pData = sal_False;
377 0 : 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 2 : pDestAny->pData = &pDestAny->pReserved;
385 2 : *(sal_Int16 *)pDestAny->pData = 0;
386 2 : break;
387 : case typelib_TypeClass_LONG:
388 : case typelib_TypeClass_UNSIGNED_LONG:
389 0 : pDestAny->pData = &pDestAny->pReserved;
390 0 : *(sal_Int32 *)pDestAny->pData = 0;
391 0 : 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 0 : pDestAny->pData = &pDestAny->pReserved;
416 0 : *(rtl_uString **)pDestAny->pData = 0;
417 0 : ::rtl_uString_new( (rtl_uString **)pDestAny->pData );
418 0 : 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 0 : pDestAny->pData = &pDestAny->pReserved;
425 0 : if (pTypeDescr)
426 : {
427 0 : *(sal_Int32 *)pDestAny->pData = ((typelib_EnumTypeDescription *)pTypeDescr)->nDefaultEnumValue;
428 : }
429 : else
430 : {
431 0 : TYPELIB_DANGER_GET( &pTypeDescr, pType );
432 0 : *(sal_Int32 *)pDestAny->pData = ((typelib_EnumTypeDescription *)pTypeDescr)->nDefaultEnumValue;
433 0 : TYPELIB_DANGER_RELEASE( pTypeDescr );
434 : }
435 0 : break;
436 : case typelib_TypeClass_STRUCT:
437 : case typelib_TypeClass_EXCEPTION:
438 90 : if (pTypeDescr)
439 : {
440 90 : pDestAny->pData = ::rtl_allocateMemory( pTypeDescr->nSize );
441 : _defaultConstructStruct(
442 90 : 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 90 : 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 232 : pDestAny->pData = &pDestAny->pReserved;
485 232 : *(uno_Sequence **)pDestAny->pData = createEmptySequence();
486 232 : break;
487 : case typelib_TypeClass_INTERFACE:
488 3 : pDestAny->pData = &pDestAny->pReserved;
489 3 : pDestAny->pReserved = 0; // either cpp or c-uno interface
490 3 : break;
491 : default:
492 : OSL_ASSERT(false);
493 0 : break;
494 : }
495 : }
496 : }
497 : }
498 : //------------------------------------------------------------------------------
499 802727 : inline uno_Sequence * icopyConstructSequence(
500 : uno_Sequence * pSource,
501 : typelib_TypeDescriptionReference * pElementType,
502 : uno_AcquireFunc acquire, uno_Mapping * mapping )
503 : {
504 802727 : typelib_TypeClass eTypeClass = pElementType->eTypeClass;
505 802727 : if (!mapping ||
506 : (eTypeClass <= typelib_TypeClass_ENUM &&
507 : eTypeClass != typelib_TypeClass_ANY))
508 : {
509 789761 : osl_atomic_increment( &pSource->nRefCount );
510 789761 : return pSource;
511 : }
512 : else // create new sequence
513 : {
514 : uno_Sequence * pDest;
515 12966 : sal_Int32 nElements = pSource->nElements;
516 12966 : if (nElements)
517 : {
518 12732 : switch (eTypeClass)
519 : {
520 : case typelib_TypeClass_ANY:
521 : {
522 12424 : pDest = allocSeq( sizeof (uno_Any), nElements );
523 12424 : if (pDest != 0)
524 : {
525 12424 : uno_Any * pDestElements = (uno_Any *)pDest->elements;
526 12424 : uno_Any * pSourceElements = (uno_Any *)pSource->elements;
527 50355 : for ( sal_Int32 nPos = nElements; nPos--; )
528 : {
529 : typelib_TypeDescriptionReference * pType =
530 25507 : pSourceElements[nPos].pType;
531 25507 : if (typelib_TypeClass_VOID == pType->eTypeClass)
532 : {
533 2 : CONSTRUCT_EMPTY_ANY( &pDestElements[nPos] );
534 : }
535 : else
536 : {
537 : _copyConstructAnyFromData(
538 : &pDestElements[nPos],
539 25505 : pSourceElements[nPos].pData,
540 : pType, 0,
541 25505 : acquire, mapping );
542 : }
543 : }
544 : }
545 12424 : break;
546 : }
547 : case typelib_TypeClass_STRUCT:
548 : case typelib_TypeClass_EXCEPTION:
549 : {
550 212 : typelib_TypeDescription * pElementTypeDescr = 0;
551 212 : TYPELIB_DANGER_GET( &pElementTypeDescr, pElementType );
552 212 : sal_Int32 nElementSize = pElementTypeDescr->nSize;
553 212 : char * pSourceElements = pSource->elements;
554 212 : pDest = allocSeq( nElementSize, nElements );
555 212 : if (pDest != 0)
556 : {
557 212 : char * pElements = pDest->elements;
558 824 : for ( sal_Int32 nPos = nElements; nPos--; )
559 : {
560 : _copyConstructStruct(
561 400 : pElements + (nPos * nElementSize),
562 400 : pSourceElements + (nPos * nElementSize),
563 : (typelib_CompoundTypeDescription *)
564 : pElementTypeDescr,
565 1200 : acquire, mapping );
566 : }
567 : }
568 212 : 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 60 : pDest = allocSeq( sizeof (uno_Sequence *), nElements );
628 60 : if (pDest != 0)
629 : {
630 60 : typelib_TypeDescription * pElementTypeDescr = 0;
631 60 : TYPELIB_DANGER_GET( &pElementTypeDescr, pElementType );
632 : typelib_TypeDescriptionReference * pSeqElementType =
633 : ((typelib_IndirectTypeDescription *)
634 60 : pElementTypeDescr)->pType;
635 :
636 : uno_Sequence ** pDestElements =
637 60 : (uno_Sequence **) pDest->elements;
638 : uno_Sequence ** pSourceElements =
639 60 : (uno_Sequence **) pSource->elements;
640 220 : for ( sal_Int32 nPos = nElements; nPos--; )
641 : {
642 : uno_Sequence * pNew = copyConstructSequence(
643 100 : pSourceElements[nPos],
644 : pSeqElementType,
645 100 : acquire, mapping );
646 : OSL_ASSERT( pNew != 0 );
647 : // ought never be a memory allocation problem,
648 : // because of reference counted sequence handles
649 100 : pDestElements[ nPos ] = pNew;
650 : }
651 :
652 60 : TYPELIB_DANGER_RELEASE( pElementTypeDescr );
653 : }
654 60 : break;
655 : }
656 : case typelib_TypeClass_INTERFACE:
657 : {
658 36 : pDest = allocSeq( sizeof (void *), nElements );
659 36 : if (pDest != 0)
660 : {
661 36 : char * pElements = pDest->elements;
662 36 : void ** pSourceElements = (void **)pSource->elements;
663 36 : if (mapping)
664 : {
665 36 : typelib_TypeDescription * pElementTypeDescr = 0;
666 36 : TYPELIB_DANGER_GET( &pElementTypeDescr, pElementType );
667 148 : for ( sal_Int32 nPos = nElements; nPos--; )
668 : {
669 76 : ((void **)pElements)[nPos] = 0;
670 76 : if (((void **)pSourceElements)[nPos])
671 : {
672 : (*mapping->mapInterface)(
673 : mapping, (void **)pElements + nPos,
674 68 : pSourceElements[nPos],
675 : (typelib_InterfaceTypeDescription *)
676 136 : pElementTypeDescr );
677 : }
678 : }
679 36 : 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 36 : 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 234 : pDest = allocSeq( 0, 0 );
701 : }
702 :
703 12966 : return pDest;
704 : }
705 : }
706 :
707 : //--------------------------------------------------------------------------------------------------
708 9145988 : 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 9145988 : switch (pType->eTypeClass)
715 : {
716 : case typelib_TypeClass_CHAR:
717 378 : *(sal_Unicode *)pDest = *(sal_Unicode *)pSource;
718 378 : break;
719 : case typelib_TypeClass_BOOLEAN:
720 16921 : *(sal_Bool *)pDest = (*(sal_Bool *)pSource != sal_False);
721 16921 : break;
722 : case typelib_TypeClass_BYTE:
723 256 : *(sal_Int8 *)pDest = *(sal_Int8 *)pSource;
724 256 : break;
725 : case typelib_TypeClass_SHORT:
726 : case typelib_TypeClass_UNSIGNED_SHORT:
727 388820 : *(sal_Int16 *)pDest = *(sal_Int16 *)pSource;
728 388820 : break;
729 : case typelib_TypeClass_LONG:
730 : case typelib_TypeClass_UNSIGNED_LONG:
731 2202535 : *(sal_Int32 *)pDest = *(sal_Int32 *)pSource;
732 2202535 : break;
733 : case typelib_TypeClass_HYPER:
734 : case typelib_TypeClass_UNSIGNED_HYPER:
735 512 : *(sal_Int64 *)pDest = *(sal_Int64 *)pSource;
736 512 : break;
737 : case typelib_TypeClass_FLOAT:
738 2226 : *(float *)pDest = *(float *)pSource;
739 2226 : break;
740 : case typelib_TypeClass_DOUBLE:
741 44246 : *(double *)pDest = *(double *)pSource;
742 44246 : break;
743 : case typelib_TypeClass_STRING:
744 2360861 : ::rtl_uString_acquire( *(rtl_uString **)pSource );
745 2360861 : *(rtl_uString **)pDest = *(rtl_uString **)pSource;
746 2360861 : break;
747 : case typelib_TypeClass_TYPE:
748 143234 : TYPE_ACQUIRE( *(typelib_TypeDescriptionReference **)pSource );
749 143234 : *(typelib_TypeDescriptionReference **)pDest = *(typelib_TypeDescriptionReference **)pSource;
750 143234 : break;
751 : case typelib_TypeClass_ANY:
752 : _copyConstructAny(
753 : (uno_Any *)pDest, ((uno_Any *)pSource)->pData,
754 : ((uno_Any *)pSource)->pType, 0,
755 1876564 : acquire, mapping );
756 1876564 : break;
757 : case typelib_TypeClass_ENUM:
758 1905935 : *(sal_Int32 *)pDest = *(sal_Int32 *)pSource;
759 1905935 : break;
760 : case typelib_TypeClass_STRUCT:
761 : case typelib_TypeClass_EXCEPTION:
762 42557 : if (pTypeDescr)
763 : {
764 : _copyConstructStruct(
765 : pDest, pSource,
766 : (typelib_CompoundTypeDescription *)pTypeDescr,
767 6179 : acquire, mapping );
768 : }
769 : else
770 : {
771 36378 : TYPELIB_DANGER_GET( &pTypeDescr, pType );
772 : _copyConstructStruct(
773 : pDest, pSource,
774 : (typelib_CompoundTypeDescription *)pTypeDescr,
775 36378 : acquire, mapping );
776 36378 : TYPELIB_DANGER_RELEASE( pTypeDescr );
777 : }
778 42557 : 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 84870 : if (mapping)
811 : {
812 12873 : if (pTypeDescr)
813 : {
814 : *(uno_Sequence **)pDest = icopyConstructSequence(
815 : *(uno_Sequence **)pSource,
816 : ((typelib_IndirectTypeDescription *)pTypeDescr)->pType,
817 390 : acquire, mapping );
818 : }
819 : else
820 : {
821 12483 : TYPELIB_DANGER_GET( &pTypeDescr, pType );
822 : *(uno_Sequence **)pDest = icopyConstructSequence(
823 : *(uno_Sequence **)pSource,
824 : ((typelib_IndirectTypeDescription *)pTypeDescr)->pType,
825 12483 : acquire, mapping );
826 12483 : TYPELIB_DANGER_RELEASE( pTypeDescr );
827 : }
828 : }
829 : else
830 : {
831 71997 : osl_atomic_increment( &(*(uno_Sequence **)pSource)->nRefCount );
832 71997 : *(uno_Sequence **)pDest = *(uno_Sequence **)pSource;
833 : }
834 84870 : break;
835 : case typelib_TypeClass_INTERFACE:
836 76073 : if (mapping)
837 13999 : *(void **)pDest = _map( *(void **)pSource, pType, pTypeDescr, mapping );
838 : else
839 62074 : _acquire( *(void **)pDest = *(void **)pSource, acquire );
840 76073 : break;
841 : default:
842 0 : break;
843 : }
844 9145988 : }
845 :
846 : }
847 :
848 : #endif
849 :
850 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
