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 DESTR_HXX
20 : #define DESTR_HXX
21 :
22 : #include "prim.hxx"
23 :
24 :
25 : namespace cppu
26 : {
27 :
28 : //##################################################################################################
29 : //#### destruction #################################################################################
30 : //##################################################################################################
31 :
32 : //--------------------------------------------------------------------------------------------------
33 0 : inline void _destructUnion(
34 : void * pValue,
35 : typelib_TypeDescription * pTypeDescr,
36 : uno_ReleaseFunc release )
37 : SAL_THROW(())
38 : {
39 0 : typelib_TypeDescriptionReference * pType = _unionGetSetType( pValue, pTypeDescr );
40 : ::uno_type_destructData(
41 0 : (char *)pValue + ((typelib_UnionTypeDescription *)pTypeDescr)->nValueOffset,
42 0 : pType, release );
43 0 : ::typelib_typedescriptionreference_release( pType );
44 0 : }
45 : //==================================================================================================
46 : void destructStruct(
47 : void * pValue,
48 : typelib_CompoundTypeDescription * pTypeDescr,
49 : uno_ReleaseFunc release )
50 : SAL_THROW(());
51 : //--------------------------------------------------------------------------------------------------
52 12684263 : inline void _destructStruct(
53 : void * pValue,
54 : typelib_CompoundTypeDescription * pTypeDescr,
55 : uno_ReleaseFunc release )
56 : SAL_THROW(())
57 : {
58 12684263 : if (pTypeDescr->pBaseTypeDescription)
59 : {
60 606903 : destructStruct( pValue, pTypeDescr->pBaseTypeDescription, release );
61 : }
62 :
63 12684263 : typelib_TypeDescriptionReference ** ppTypeRefs = pTypeDescr->ppTypeRefs;
64 12684263 : sal_Int32 * pMemberOffsets = pTypeDescr->pMemberOffsets;
65 12684263 : sal_Int32 nDescr = pTypeDescr->nMembers;
66 77122044 : while (nDescr--)
67 : {
68 : ::uno_type_destructData(
69 103507036 : (char *)pValue + pMemberOffsets[nDescr],
70 155260554 : ppTypeRefs[nDescr], release );
71 : }
72 12684263 : }
73 :
74 : //--------------------------------------------------------------------------------------------------
75 0 : inline void _destructArray(
76 : void * pValue,
77 : typelib_ArrayTypeDescription * pTypeDescr,
78 : uno_ReleaseFunc release )
79 : throw ()
80 : {
81 0 : typelib_TypeDescription * pElementType = NULL;
82 0 : TYPELIB_DANGER_GET( &pElementType, ((typelib_IndirectTypeDescription *)pTypeDescr)->pType );
83 0 : sal_Int32 nElementSize = pElementType->nSize;
84 0 : TYPELIB_DANGER_RELEASE( pElementType );
85 :
86 0 : sal_Int32 nTotalElements = pTypeDescr->nTotalElements;
87 0 : for(sal_Int32 i=0; i < nTotalElements; i++)
88 : {
89 : ::uno_type_destructData(
90 0 : (sal_Char *)pValue + i * nElementSize,
91 0 : ((typelib_IndirectTypeDescription *)pTypeDescr)->pType, release );
92 : }
93 :
94 0 : typelib_typedescriptionreference_release(((typelib_IndirectTypeDescription *)pTypeDescr)->pType);
95 0 : }
96 :
97 : //==============================================================================
98 : void destructSequence(
99 : uno_Sequence * pSequence,
100 : typelib_TypeDescriptionReference * pType,
101 : typelib_TypeDescription * pTypeDescr,
102 : uno_ReleaseFunc release );
103 :
104 : //--------------------------------------------------------------------------------------------------
105 94031438 : inline void _destructAny(
106 : uno_Any * pAny,
107 : uno_ReleaseFunc release )
108 : SAL_THROW(())
109 : {
110 94031438 : typelib_TypeDescriptionReference * pType = pAny->pType;
111 :
112 94031438 : switch (pType->eTypeClass)
113 : {
114 : case typelib_TypeClass_HYPER:
115 : case typelib_TypeClass_UNSIGNED_HYPER:
116 : if (sizeof(void *) < sizeof(sal_Int64))
117 : {
118 108207 : ::rtl_freeMemory( pAny->pData );
119 : }
120 108207 : break;
121 : case typelib_TypeClass_FLOAT:
122 : if (sizeof(void *) < sizeof(float))
123 : {
124 : ::rtl_freeMemory( pAny->pData );
125 : }
126 443189 : break;
127 : case typelib_TypeClass_DOUBLE:
128 : if (sizeof(void *) < sizeof(double))
129 : {
130 272274 : ::rtl_freeMemory( pAny->pData );
131 : }
132 272274 : break;
133 : case typelib_TypeClass_STRING:
134 17022066 : ::rtl_uString_release( (rtl_uString *)pAny->pReserved );
135 17022065 : break;
136 : case typelib_TypeClass_TYPE:
137 : ::typelib_typedescriptionreference_release(
138 69006 : (typelib_TypeDescriptionReference *)pAny->pReserved );
139 69006 : break;
140 : case typelib_TypeClass_ANY:
141 : OSL_FAIL( "### unexpected nested any!" );
142 0 : ::uno_any_destruct( (uno_Any *)pAny->pData, release );
143 0 : ::rtl_freeMemory( pAny->pData );
144 0 : break;
145 : case typelib_TypeClass_TYPEDEF:
146 : OSL_FAIL( "### unexpected typedef!" );
147 0 : break;
148 : case typelib_TypeClass_STRUCT:
149 : case typelib_TypeClass_EXCEPTION:
150 : {
151 2159135 : typelib_TypeDescription * pTypeDescr = 0;
152 2159135 : TYPELIB_DANGER_GET( &pTypeDescr, pType );
153 2159135 : _destructStruct( pAny->pData, (typelib_CompoundTypeDescription *)pTypeDescr, release );
154 2159135 : TYPELIB_DANGER_RELEASE( pTypeDescr );
155 2159135 : ::rtl_freeMemory( pAny->pData );
156 2159135 : break;
157 : }
158 : case typelib_TypeClass_UNION:
159 : {
160 0 : typelib_TypeDescription * pTypeDescr = 0;
161 0 : TYPELIB_DANGER_GET( &pTypeDescr, pType );
162 0 : _destructUnion( pAny->pData, pTypeDescr, release );
163 0 : TYPELIB_DANGER_RELEASE( pTypeDescr );
164 0 : ::rtl_freeMemory( pAny->pData );
165 0 : break;
166 : }
167 : case typelib_TypeClass_SEQUENCE:
168 : {
169 : destructSequence(
170 3448721 : *(uno_Sequence **) &pAny->pReserved, pType, 0, release );
171 3448721 : break;
172 : }
173 : case typelib_TypeClass_INTERFACE:
174 22727024 : _release( pAny->pReserved, release );
175 22727027 : break;
176 : default:
177 47781816 : break;
178 : }
179 : #if OSL_DEBUG_LEVEL > 0
180 : pAny->pData = (void *)0xdeadbeef;
181 : #endif
182 :
183 94031440 : ::typelib_typedescriptionreference_release( pType );
184 94031450 : }
185 : //--------------------------------------------------------------------------------------------------
186 6107088 : inline sal_Int32 idestructElements(
187 : void * pElements, typelib_TypeDescriptionReference * pElementType,
188 : sal_Int32 nStartIndex, sal_Int32 nStopIndex,
189 : uno_ReleaseFunc release )
190 : SAL_THROW(())
191 : {
192 6107088 : switch (pElementType->eTypeClass)
193 : {
194 : case typelib_TypeClass_CHAR:
195 0 : return (sal_Int32)(sizeof(sal_Unicode));
196 : case typelib_TypeClass_BOOLEAN:
197 20665 : return (sal_Int32)(sizeof(sal_Bool));
198 : case typelib_TypeClass_BYTE:
199 1263877 : return (sal_Int32)(sizeof(sal_Int8));
200 : case typelib_TypeClass_SHORT:
201 : case typelib_TypeClass_UNSIGNED_SHORT:
202 1506 : return (sal_Int32)(sizeof(sal_Int16));
203 : case typelib_TypeClass_LONG:
204 : case typelib_TypeClass_UNSIGNED_LONG:
205 28853 : return (sal_Int32)(sizeof(sal_Int32));
206 : case typelib_TypeClass_HYPER:
207 : case typelib_TypeClass_UNSIGNED_HYPER:
208 843 : return (sal_Int32)(sizeof(sal_Int64));
209 : case typelib_TypeClass_FLOAT:
210 6 : return (sal_Int32)(sizeof(float));
211 : case typelib_TypeClass_DOUBLE:
212 172100 : return (sal_Int32)(sizeof(double));
213 :
214 : case typelib_TypeClass_STRING:
215 : {
216 737077 : rtl_uString ** pDest = (rtl_uString **)pElements;
217 3753442 : for ( sal_Int32 nPos = nStartIndex; nPos < nStopIndex; ++nPos )
218 : {
219 3016365 : ::rtl_uString_release( pDest[nPos] );
220 : }
221 737077 : return (sal_Int32)(sizeof(rtl_uString *));
222 : }
223 : case typelib_TypeClass_TYPE:
224 : {
225 8760 : typelib_TypeDescriptionReference ** pDest = (typelib_TypeDescriptionReference **)pElements;
226 152690 : for ( sal_Int32 nPos = nStartIndex; nPos < nStopIndex; ++nPos )
227 : {
228 143930 : ::typelib_typedescriptionreference_release( pDest[nPos] );
229 : }
230 8760 : return (sal_Int32)(sizeof(typelib_TypeDescriptionReference *));
231 : }
232 : case typelib_TypeClass_ANY:
233 : {
234 511307 : uno_Any * pDest = (uno_Any *)pElements;
235 2317862 : for ( sal_Int32 nPos = nStartIndex; nPos < nStopIndex; ++nPos )
236 : {
237 1806555 : _destructAny( &pDest[nPos], release );
238 : }
239 511307 : return (sal_Int32)(sizeof(uno_Any));
240 : }
241 : case typelib_TypeClass_ENUM:
242 5144 : return (sal_Int32)(sizeof(sal_Int32));
243 : case typelib_TypeClass_STRUCT:
244 : case typelib_TypeClass_EXCEPTION:
245 : {
246 1711357 : typelib_TypeDescription * pElementTypeDescr = 0;
247 1711357 : TYPELIB_DANGER_GET( &pElementTypeDescr, pElementType );
248 1711356 : sal_Int32 nElementSize = pElementTypeDescr->nSize;
249 11497507 : for ( sal_Int32 nPos = nStartIndex; nPos < nStopIndex; ++nPos )
250 : {
251 : _destructStruct(
252 19572300 : (char *)pElements + (nElementSize * nPos),
253 : (typelib_CompoundTypeDescription *)pElementTypeDescr,
254 29358450 : release );
255 : }
256 1711357 : sal_Int32 nSize = pElementTypeDescr->nSize;
257 1711357 : TYPELIB_DANGER_RELEASE( pElementTypeDescr );
258 1711357 : return nSize;
259 : }
260 : case typelib_TypeClass_UNION:
261 : {
262 0 : typelib_TypeDescription * pElementTypeDescr = 0;
263 0 : TYPELIB_DANGER_GET( &pElementTypeDescr, pElementType );
264 0 : sal_Int32 nElementSize = pElementTypeDescr->nSize;
265 0 : for ( sal_Int32 nPos = nStartIndex; nPos < nStopIndex; ++nPos )
266 : {
267 : _destructUnion(
268 0 : (char *)pElements + (nElementSize * nPos),
269 : pElementTypeDescr,
270 0 : release );
271 : }
272 0 : sal_Int32 nSize = pElementTypeDescr->nSize;
273 0 : TYPELIB_DANGER_RELEASE( pElementTypeDescr );
274 0 : return nSize;
275 : }
276 : case typelib_TypeClass_SEQUENCE:
277 : {
278 51749 : typelib_TypeDescription * pElementTypeDescr = 0;
279 51749 : TYPELIB_DANGER_GET( &pElementTypeDescr, pElementType );
280 51749 : uno_Sequence ** pDest = (uno_Sequence **)pElements;
281 173561 : for ( sal_Int32 nPos = nStartIndex; nPos < nStopIndex; ++nPos )
282 : {
283 : destructSequence(
284 121812 : pDest[nPos],
285 : pElementTypeDescr->pWeakRef, pElementTypeDescr,
286 243624 : release );
287 : }
288 51749 : TYPELIB_DANGER_RELEASE( pElementTypeDescr );
289 51749 : return (sal_Int32)(sizeof(uno_Sequence *));
290 : }
291 : case typelib_TypeClass_INTERFACE:
292 : {
293 1593844 : if (release)
294 : {
295 7314634 : for ( sal_Int32 nPos = nStartIndex; nPos < nStopIndex; ++nPos )
296 : {
297 5720861 : void * p = ((void **)pElements)[nPos];
298 5720861 : if (p)
299 : {
300 5571534 : (*release)( p );
301 : }
302 : }
303 : }
304 : else
305 : {
306 189 : for ( sal_Int32 nPos = nStartIndex; nPos < nStopIndex; ++nPos )
307 : {
308 120 : uno_Interface * p = ((uno_Interface **)pElements)[nPos];
309 120 : if (p)
310 : {
311 109 : (*p->release)( p );
312 : }
313 : }
314 : }
315 1593842 : return (sal_Int32)(sizeof(void *));
316 : }
317 : default:
318 : OSL_ASSERT(false);
319 0 : return 0;
320 : }
321 : }
322 :
323 : //------------------------------------------------------------------------------
324 18892085 : inline void idestructSequence(
325 : uno_Sequence * pSeq,
326 : typelib_TypeDescriptionReference * pType,
327 : typelib_TypeDescription * pTypeDescr,
328 : uno_ReleaseFunc release )
329 : {
330 18892085 : if (osl_atomic_decrement( &pSeq->nRefCount ) == 0)
331 : {
332 5539108 : if (pSeq->nElements > 0)
333 : {
334 5364745 : if (pTypeDescr)
335 : {
336 : idestructElements(
337 : pSeq->elements,
338 : ((typelib_IndirectTypeDescription *) pTypeDescr)->pType, 0,
339 119040 : pSeq->nElements, release );
340 : }
341 : else
342 : {
343 5245705 : TYPELIB_DANGER_GET( &pTypeDescr, pType );
344 : idestructElements(
345 : pSeq->elements,
346 : ((typelib_IndirectTypeDescription *) pTypeDescr)->pType, 0,
347 5245705 : pSeq->nElements, release );
348 5245704 : TYPELIB_DANGER_RELEASE( pTypeDescr );
349 : }
350 : }
351 5539108 : ::rtl_freeMemory( pSeq );
352 : }
353 18892086 : }
354 :
355 : //--------------------------------------------------------------------------------------------------
356 64610153 : inline void _destructData(
357 : void * pValue,
358 : typelib_TypeDescriptionReference * pType,
359 : typelib_TypeDescription * pTypeDescr,
360 : uno_ReleaseFunc release )
361 : SAL_THROW(())
362 : {
363 64610153 : switch (pType->eTypeClass)
364 : {
365 : case typelib_TypeClass_STRING:
366 16904471 : ::rtl_uString_release( *(rtl_uString **)pValue );
367 16904539 : break;
368 : case typelib_TypeClass_TYPE:
369 669117 : ::typelib_typedescriptionreference_release( *(typelib_TypeDescriptionReference **)pValue );
370 669117 : break;
371 : case typelib_TypeClass_ANY:
372 9259955 : _destructAny( (uno_Any *)pValue, release );
373 9259955 : break;
374 : case typelib_TypeClass_TYPEDEF:
375 : OSL_FAIL( "### unexpected typedef!" );
376 0 : break;
377 : case typelib_TypeClass_STRUCT:
378 : case typelib_TypeClass_EXCEPTION:
379 132074 : if (pTypeDescr)
380 : {
381 18259 : _destructStruct( pValue, (typelib_CompoundTypeDescription *)pTypeDescr, release );
382 : }
383 : else
384 : {
385 113815 : TYPELIB_DANGER_GET( &pTypeDescr, pType );
386 113815 : _destructStruct( pValue, (typelib_CompoundTypeDescription *)pTypeDescr, release );
387 113815 : TYPELIB_DANGER_RELEASE( pTypeDescr );
388 : }
389 132074 : break;
390 : case typelib_TypeClass_ARRAY:
391 0 : if (pTypeDescr)
392 : {
393 0 : _destructArray( pValue, (typelib_ArrayTypeDescription *)pTypeDescr, release );
394 : }
395 : else
396 : {
397 0 : TYPELIB_DANGER_GET( &pTypeDescr, pType );
398 0 : _destructArray( pValue, (typelib_ArrayTypeDescription *)pTypeDescr, release );
399 0 : TYPELIB_DANGER_RELEASE( pTypeDescr );
400 : }
401 0 : break;
402 : case typelib_TypeClass_UNION:
403 0 : if (pTypeDescr)
404 : {
405 0 : _destructUnion( pValue, pTypeDescr, release );
406 : }
407 : else
408 : {
409 0 : TYPELIB_DANGER_GET( &pTypeDescr, pType );
410 0 : _destructUnion( pValue, pTypeDescr, release );
411 0 : TYPELIB_DANGER_RELEASE( pTypeDescr );
412 : }
413 0 : break;
414 : case typelib_TypeClass_SEQUENCE:
415 : {
416 : idestructSequence(
417 12759363 : *(uno_Sequence **)pValue, pType, pTypeDescr, release );
418 12759378 : break;
419 : }
420 : case typelib_TypeClass_INTERFACE:
421 336870 : _release( *(void **)pValue, release );
422 336870 : break;
423 : default:
424 24548303 : break;
425 : }
426 64610236 : }
427 :
428 : }
429 :
430 : #endif
431 :
432 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
