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 1639579 : inline void _destructStruct(
53 : void * pValue,
54 : typelib_CompoundTypeDescription * pTypeDescr,
55 : uno_ReleaseFunc release )
56 : SAL_THROW(())
57 : {
58 1639579 : if (pTypeDescr->pBaseTypeDescription)
59 : {
60 83274 : destructStruct( pValue, pTypeDescr->pBaseTypeDescription, release );
61 : }
62 :
63 1639579 : typelib_TypeDescriptionReference ** ppTypeRefs = pTypeDescr->ppTypeRefs;
64 1639579 : sal_Int32 * pMemberOffsets = pTypeDescr->pMemberOffsets;
65 1639579 : sal_Int32 nDescr = pTypeDescr->nMembers;
66 10408915 : while (nDescr--)
67 : {
68 : ::uno_type_destructData(
69 14259514 : (char *)pValue + pMemberOffsets[nDescr],
70 21389271 : ppTypeRefs[nDescr], release );
71 : }
72 1639579 : }
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 11693935 : inline void _destructAny(
106 : uno_Any * pAny,
107 : uno_ReleaseFunc release )
108 : SAL_THROW(())
109 : {
110 11693935 : typelib_TypeDescriptionReference * pType = pAny->pType;
111 :
112 11693935 : switch (pType->eTypeClass)
113 : {
114 : case typelib_TypeClass_HYPER:
115 : case typelib_TypeClass_UNSIGNED_HYPER:
116 : if (sizeof(void *) < sizeof(sal_Int64))
117 : {
118 17600 : ::rtl_freeMemory( pAny->pData );
119 : }
120 17600 : break;
121 : case typelib_TypeClass_FLOAT:
122 : if (sizeof(void *) < sizeof(float))
123 : {
124 : ::rtl_freeMemory( pAny->pData );
125 : }
126 38864 : break;
127 : case typelib_TypeClass_DOUBLE:
128 : if (sizeof(void *) < sizeof(double))
129 : {
130 42932 : ::rtl_freeMemory( pAny->pData );
131 : }
132 42932 : break;
133 : case typelib_TypeClass_STRING:
134 1970821 : ::rtl_uString_release( (rtl_uString *)pAny->pReserved );
135 1970821 : break;
136 : case typelib_TypeClass_TYPE:
137 : ::typelib_typedescriptionreference_release(
138 8 : (typelib_TypeDescriptionReference *)pAny->pReserved );
139 8 : 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 135386 : typelib_TypeDescription * pTypeDescr = 0;
152 135386 : TYPELIB_DANGER_GET( &pTypeDescr, pType );
153 135386 : _destructStruct( pAny->pData, (typelib_CompoundTypeDescription *)pTypeDescr, release );
154 135386 : TYPELIB_DANGER_RELEASE( pTypeDescr );
155 135386 : ::rtl_freeMemory( pAny->pData );
156 : 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 : break;
166 : }
167 : case typelib_TypeClass_SEQUENCE:
168 : {
169 : destructSequence(
170 213096 : *(uno_Sequence **) &pAny->pReserved, pType, 0, release );
171 213096 : break;
172 : }
173 : case typelib_TypeClass_INTERFACE:
174 2618311 : _release( pAny->pReserved, release );
175 2618311 : break;
176 : default:
177 6656917 : break;
178 : }
179 : #if OSL_DEBUG_LEVEL > 0
180 : pAny->pData = (void *)0xdeadbeef;
181 : #endif
182 :
183 11693935 : ::typelib_typedescriptionreference_release( pType );
184 11693935 : }
185 : //--------------------------------------------------------------------------------------------------
186 735945 : 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 735945 : switch (pElementType->eTypeClass)
193 : {
194 : case typelib_TypeClass_CHAR:
195 0 : return (sal_Int32)(sizeof(sal_Unicode));
196 : case typelib_TypeClass_BOOLEAN:
197 111 : return (sal_Int32)(sizeof(sal_Bool));
198 : case typelib_TypeClass_BYTE:
199 194462 : return (sal_Int32)(sizeof(sal_Int8));
200 : case typelib_TypeClass_SHORT:
201 : case typelib_TypeClass_UNSIGNED_SHORT:
202 140 : return (sal_Int32)(sizeof(sal_Int16));
203 : case typelib_TypeClass_LONG:
204 : case typelib_TypeClass_UNSIGNED_LONG:
205 3901 : return (sal_Int32)(sizeof(sal_Int32));
206 : case typelib_TypeClass_HYPER:
207 : case typelib_TypeClass_UNSIGNED_HYPER:
208 127 : return (sal_Int32)(sizeof(sal_Int64));
209 : case typelib_TypeClass_FLOAT:
210 6 : return (sal_Int32)(sizeof(float));
211 : case typelib_TypeClass_DOUBLE:
212 12842 : return (sal_Int32)(sizeof(double));
213 :
214 : case typelib_TypeClass_STRING:
215 : {
216 93842 : rtl_uString ** pDest = (rtl_uString **)pElements;
217 457850 : for ( sal_Int32 nPos = nStartIndex; nPos < nStopIndex; ++nPos )
218 : {
219 364008 : ::rtl_uString_release( pDest[nPos] );
220 : }
221 93842 : return (sal_Int32)(sizeof(rtl_uString *));
222 : }
223 : case typelib_TypeClass_TYPE:
224 : {
225 984 : typelib_TypeDescriptionReference ** pDest = (typelib_TypeDescriptionReference **)pElements;
226 27882 : for ( sal_Int32 nPos = nStartIndex; nPos < nStopIndex; ++nPos )
227 : {
228 26898 : ::typelib_typedescriptionreference_release( pDest[nPos] );
229 : }
230 984 : return (sal_Int32)(sizeof(typelib_TypeDescriptionReference *));
231 : }
232 : case typelib_TypeClass_ANY:
233 : {
234 50059 : uno_Any * pDest = (uno_Any *)pElements;
235 179312 : for ( sal_Int32 nPos = nStartIndex; nPos < nStopIndex; ++nPos )
236 : {
237 129253 : _destructAny( &pDest[nPos], release );
238 : }
239 50059 : return (sal_Int32)(sizeof(uno_Any));
240 : }
241 : case typelib_TypeClass_ENUM:
242 289 : return (sal_Int32)(sizeof(sal_Int32));
243 : case typelib_TypeClass_STRUCT:
244 : case typelib_TypeClass_EXCEPTION:
245 : {
246 209128 : typelib_TypeDescription * pElementTypeDescr = 0;
247 209128 : TYPELIB_DANGER_GET( &pElementTypeDescr, pElementType );
248 209128 : sal_Int32 nElementSize = pElementTypeDescr->nSize;
249 1597970 : for ( sal_Int32 nPos = nStartIndex; nPos < nStopIndex; ++nPos )
250 : {
251 : _destructStruct(
252 1388842 : (char *)pElements + (nElementSize * nPos),
253 : (typelib_CompoundTypeDescription *)pElementTypeDescr,
254 2777684 : release );
255 : }
256 209128 : sal_Int32 nSize = pElementTypeDescr->nSize;
257 209128 : TYPELIB_DANGER_RELEASE( pElementTypeDescr );
258 209128 : 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 5411 : typelib_TypeDescription * pElementTypeDescr = 0;
279 5411 : TYPELIB_DANGER_GET( &pElementTypeDescr, pElementType );
280 5411 : uno_Sequence ** pDest = (uno_Sequence **)pElements;
281 19002 : for ( sal_Int32 nPos = nStartIndex; nPos < nStopIndex; ++nPos )
282 : {
283 : destructSequence(
284 13591 : pDest[nPos],
285 : pElementTypeDescr->pWeakRef, pElementTypeDescr,
286 27182 : release );
287 : }
288 5411 : TYPELIB_DANGER_RELEASE( pElementTypeDescr );
289 5411 : return (sal_Int32)(sizeof(uno_Sequence *));
290 : }
291 : case typelib_TypeClass_INTERFACE:
292 : {
293 164643 : if (release)
294 : {
295 639358 : for ( sal_Int32 nPos = nStartIndex; nPos < nStopIndex; ++nPos )
296 : {
297 474724 : void * p = ((void **)pElements)[nPos];
298 474724 : if (p)
299 : {
300 422839 : (*release)( p );
301 : }
302 : }
303 : }
304 : else
305 : {
306 28 : for ( sal_Int32 nPos = nStartIndex; nPos < nStopIndex; ++nPos )
307 : {
308 19 : uno_Interface * p = ((uno_Interface **)pElements)[nPos];
309 19 : if (p)
310 : {
311 17 : (*p->release)( p );
312 : }
313 : }
314 : }
315 164643 : return (sal_Int32)(sizeof(void *));
316 : }
317 : default:
318 : OSL_ASSERT(false);
319 0 : return 0;
320 : }
321 : }
322 :
323 : //------------------------------------------------------------------------------
324 2167520 : inline void idestructSequence(
325 : uno_Sequence * pSeq,
326 : typelib_TypeDescriptionReference * pType,
327 : typelib_TypeDescription * pTypeDescr,
328 : uno_ReleaseFunc release )
329 : {
330 2167520 : if (osl_atomic_decrement( &pSeq->nRefCount ) == 0)
331 : {
332 643798 : if (pSeq->nElements > 0)
333 : {
334 603404 : if (pTypeDescr)
335 : {
336 : idestructElements(
337 : pSeq->elements,
338 : ((typelib_IndirectTypeDescription *) pTypeDescr)->pType, 0,
339 9252 : pSeq->nElements, release );
340 : }
341 : else
342 : {
343 594152 : TYPELIB_DANGER_GET( &pTypeDescr, pType );
344 : idestructElements(
345 : pSeq->elements,
346 : ((typelib_IndirectTypeDescription *) pTypeDescr)->pType, 0,
347 594152 : pSeq->nElements, release );
348 594152 : TYPELIB_DANGER_RELEASE( pTypeDescr );
349 : }
350 : }
351 643798 : ::rtl_freeMemory( pSeq );
352 : }
353 2167520 : }
354 :
355 : //--------------------------------------------------------------------------------------------------
356 8721582 : inline void _destructData(
357 : void * pValue,
358 : typelib_TypeDescriptionReference * pType,
359 : typelib_TypeDescription * pTypeDescr,
360 : uno_ReleaseFunc release )
361 : SAL_THROW(())
362 : {
363 8721582 : switch (pType->eTypeClass)
364 : {
365 : case typelib_TypeClass_STRING:
366 2909902 : ::rtl_uString_release( *(rtl_uString **)pValue );
367 2909902 : break;
368 : case typelib_TypeClass_TYPE:
369 80365 : ::typelib_typedescriptionreference_release( *(typelib_TypeDescriptionReference **)pValue );
370 80365 : break;
371 : case typelib_TypeClass_ANY:
372 944195 : _destructAny( (uno_Any *)pValue, release );
373 944195 : 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 32077 : if (pTypeDescr)
380 : {
381 1700 : _destructStruct( pValue, (typelib_CompoundTypeDescription *)pTypeDescr, release );
382 : }
383 : else
384 : {
385 30377 : TYPELIB_DANGER_GET( &pTypeDescr, pType );
386 30377 : _destructStruct( pValue, (typelib_CompoundTypeDescription *)pTypeDescr, release );
387 30377 : TYPELIB_DANGER_RELEASE( pTypeDescr );
388 : }
389 32077 : 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 1619096 : *(uno_Sequence **)pValue, pType, pTypeDescr, release );
418 1619096 : break;
419 : }
420 : case typelib_TypeClass_INTERFACE:
421 30919 : _release( *(void **)pValue, release );
422 30919 : break;
423 : default:
424 3105028 : break;
425 : }
426 8721582 : }
427 :
428 : }
429 :
430 : #endif
431 :
432 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
