Bug Summary

File:bridges/source/cpp_uno/gcc3_linux_intel/uno2cpp.cxx
Location:line 140, column 60
Description:Access to field 'nSize' results in a dereference of a null pointer (loaded from variable 'pParamTypeDescr')

Annotated Source Code

1/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2/*************************************************************************
3 *
4 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
5 *
6 * Copyright 2000, 2010 Oracle and/or its affiliates.
7 *
8 * OpenOffice.org - a multi-platform office productivity suite
9 *
10 * This file is part of OpenOffice.org.
11 *
12 * OpenOffice.org is free software: you can redistribute it and/or modify
13 * it under the terms of the GNU Lesser General Public License version 3
14 * only, as published by the Free Software Foundation.
15 *
16 * OpenOffice.org is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU Lesser General Public License version 3 for more details
20 * (a copy is included in the LICENSE file that accompanied this code).
21 *
22 * You should have received a copy of the GNU Lesser General Public License
23 * version 3 along with OpenOffice.org. If not, see
24 * <http://www.openoffice.org/license.html>
25 * for a copy of the LGPLv3 License.
26 *
27 ************************************************************************/
28
29
30#if defined (FREEBSD) || defined(NETBSD) || defined(OPENBSD) || defined(DRAGONFLY)
31#include <stdlib.h>
32#else
33#include <alloca.h>
34#endif
35
36#include <com/sun/star/uno/genfunc.hxx>
37#include "com/sun/star/uno/RuntimeException.hpp"
38#include <uno/data.h>
39
40#include "bridges/cpp_uno/shared/bridge.hxx"
41#include "bridges/cpp_uno/shared/types.hxx"
42#include "bridges/cpp_uno/shared/unointerfaceproxy.hxx"
43#include "bridges/cpp_uno/shared/vtables.hxx"
44
45#include "callvirtualmethod.hxx"
46#include "share.hxx"
47
48using namespace ::rtl;
49using namespace ::com::sun::star::uno;
50
51namespace
52{
53
54static void cpp_call(
55 bridges::cpp_uno::shared::UnoInterfaceProxy * pThis,
56 bridges::cpp_uno::shared::VtableSlot aVtableSlot,
57 typelib_TypeDescriptionReference * pReturnTypeRef,
58 sal_Int32 nParams, typelib_MethodParameter * pParams,
59 void * pUnoReturn, void * pUnoArgs[], uno_Any ** ppUnoExc )
60{
61 // max space for: [complex ret ptr], values|ptr ...
62 char * pCppStack =
63 (char *)alloca( sizeof(sal_Int32) + ((nParams+2) * sizeof(sal_Int64)) )__builtin_alloca (sizeof(sal_Int32) + ((nParams+2) * sizeof(sal_Int64
)));
64 char * pCppStackStart = pCppStack;
65
66 // return
67 typelib_TypeDescription * pReturnTypeDescr = 0;
68 TYPELIB_DANGER_GET( &pReturnTypeDescr, pReturnTypeRef ){ typelib_TypeDescriptionReference * pMacroTypeRef = (pReturnTypeRef
); typelib_TypeDescription ** ppMacroTypeDescr = (&pReturnTypeDescr
); if (((pMacroTypeRef->eTypeClass) == typelib_TypeClass_INTERFACE_METHOD
|| (pMacroTypeRef->eTypeClass) == typelib_TypeClass_INTERFACE_ATTRIBUTE
)) { typelib_typedescriptionreference_getDescription( ppMacroTypeDescr
, pMacroTypeRef ); } else if (!pMacroTypeRef->pType || !pMacroTypeRef
->pType->pWeakRef) { typelib_typedescriptionreference_getDescription
( ppMacroTypeDescr, pMacroTypeRef ); if (*ppMacroTypeDescr) typelib_typedescription_release
( *ppMacroTypeDescr ); } else { *ppMacroTypeDescr = pMacroTypeRef
->pType; } };
69 OSL_ENSURE( pReturnTypeDescr, "### expected return type description!" )do { if (true && (!(pReturnTypeDescr))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/usr/local/src/libreoffice/bridges/source/cpp_uno/gcc3_linux_intel/uno2cpp.cxx"
":" "69" ": "), "%s", "### expected return type description!"
); } } while (false);
70
71 void * pCppReturn = 0; // if != 0 && != pUnoReturn, needs reconversion
72 bool bSimpleReturn = true;
73
74 if (pReturnTypeDescr)
4
←
Taking true branch
→
75 {
76 bSimpleReturn = x86::isSimpleReturnType(pReturnTypeDescr);
77 if (bSimpleReturn)
5
←
Taking false branch
→
78 {
79 pCppReturn = pUnoReturn; // direct way for simple types
80 }
81 else
82 {
83 // complex return via ptr
84 pCppReturn = *(void **)pCppStack
85 = (bridges::cpp_uno::shared::relatesToInterfaceType(
6
←
'?' condition is false
→
86 pReturnTypeDescr )
87 ? alloca( pReturnTypeDescr->nSize )__builtin_alloca (pReturnTypeDescr->nSize)
88 : pUnoReturn); // direct way
89 pCppStack += sizeof(void *);
90 }
91 }
92 // push this
93 void * pAdjustedThisPtr = reinterpret_cast< void ** >(pThis->getCppI())
94 + aVtableSlot.offset;
95 *(void**)pCppStack = pAdjustedThisPtr;
96 pCppStack += sizeof( void* );
97
98 // stack space
99 OSL_ENSURE( sizeof(void *) == sizeof(sal_Int32), "### unexpected size!" )do { if (true && (!(sizeof(void *) == sizeof(sal_Int32
)))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"
), ("/usr/local/src/libreoffice/bridges/source/cpp_uno/gcc3_linux_intel/uno2cpp.cxx"
":" "99" ": "), "%s", "### unexpected size!"); } } while (false
);
100 // args
101 void ** pCppArgs = (void **)alloca( 3 * sizeof(void *) * nParams )__builtin_alloca (3 * sizeof(void *) * nParams);
102 // indizes of values this have to be converted (interface conversion cpp<=>uno)
103 sal_Int32 * pTempIndizes = (sal_Int32 *)(pCppArgs + nParams);
104 // type descriptions for reconversions
105 typelib_TypeDescription ** ppTempParamTypeDescr = (typelib_TypeDescription **)(pCppArgs + (2 * nParams));
106
107 sal_Int32 nTempIndizes = 0;
108
109 for ( sal_Int32 nPos = 0; nPos < nParams; ++nPos )
7
←
Loop condition is true. Entering loop body
→
10
←
Loop condition is true. Entering loop body
→
13
←
Loop condition is true. Entering loop body
→
110 {
111 const typelib_MethodParameter & rParam = pParams[nPos];
112 typelib_TypeDescription * pParamTypeDescr = 0;
113 TYPELIB_DANGER_GET( &pParamTypeDescr, rParam.pTypeRef ){ typelib_TypeDescriptionReference * pMacroTypeRef = (rParam.
pTypeRef); typelib_TypeDescription ** ppMacroTypeDescr = (&
pParamTypeDescr); if (((pMacroTypeRef->eTypeClass) == typelib_TypeClass_INTERFACE_METHOD
|| (pMacroTypeRef->eTypeClass) == typelib_TypeClass_INTERFACE_ATTRIBUTE
)) { typelib_typedescriptionreference_getDescription( ppMacroTypeDescr
, pMacroTypeRef ); } else if (!pMacroTypeRef->pType || !pMacroTypeRef
->pType->pWeakRef) { typelib_typedescriptionreference_getDescription
( ppMacroTypeDescr, pMacroTypeRef ); if (*ppMacroTypeDescr) typelib_typedescription_release
( *ppMacroTypeDescr ); } else { *ppMacroTypeDescr = pMacroTypeRef
->pType; } };
114
115 if (!rParam.bOut
116 && bridges::cpp_uno::shared::isSimpleType( pParamTypeDescr ))
117 {
118 uno_copyAndConvertData( pCppArgs[nPos] = pCppStack, pUnoArgs[nPos], pParamTypeDescr,
119 pThis->getBridge()->getUno2Cpp() );
120
121 switch (pParamTypeDescr->eTypeClass)
122 {
123 case typelib_TypeClass_HYPER:
124 case typelib_TypeClass_UNSIGNED_HYPER:
125 case typelib_TypeClass_DOUBLE:
126 pCppStack += sizeof(sal_Int32); // extra long
127 break;
128 default:
129 break;
130 }
131 // no longer needed
132 TYPELIB_DANGER_RELEASE( pParamTypeDescr ){ if ((((pParamTypeDescr)->eTypeClass) == typelib_TypeClass_INTERFACE_METHOD
|| ((pParamTypeDescr)->eTypeClass) == typelib_TypeClass_INTERFACE_ATTRIBUTE
)) typelib_typedescription_release( pParamTypeDescr ); };
133 }
134 else // ptr to complex value | ref
135 {
136 if (! rParam.bIn) // is pure out
8
←
Taking false branch
→
11
←
Taking false branch
→
14
←
Taking true branch
→
137 {
138 // cpp out is constructed mem, uno out is not!
139 uno_constructData(
140 *(void **)pCppStack = pCppArgs[nPos] = alloca( pParamTypeDescr->nSize )__builtin_alloca (pParamTypeDescr->nSize),
15
←
Within the expansion of the macro 'alloca':
a
Access to field 'nSize' results in a dereference of a null pointer (loaded from variable 'pParamTypeDescr')
141 pParamTypeDescr );
142 pTempIndizes[nTempIndizes] = nPos; // default constructed for cpp call
143 // will be released at reconversion
144 ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;
145 }
146 // is in/inout
147 else if (bridges::cpp_uno::shared::relatesToInterfaceType(
9
←
Taking false branch
→
12
←
Taking false branch
→
148 pParamTypeDescr ))
149 {
150 uno_copyAndConvertData(
151 *(void **)pCppStack = pCppArgs[nPos] = alloca( pParamTypeDescr->nSize )__builtin_alloca (pParamTypeDescr->nSize),
152 pUnoArgs[nPos], pParamTypeDescr,
153 pThis->getBridge()->getUno2Cpp() );
154
155 pTempIndizes[nTempIndizes] = nPos; // has to be reconverted
156 // will be released at reconversion
157 ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;
158 }
159 else // direct way
160 {
161 *(void **)pCppStack = pCppArgs[nPos] = pUnoArgs[nPos];
162 // no longer needed
163 TYPELIB_DANGER_RELEASE( pParamTypeDescr ){ if ((((pParamTypeDescr)->eTypeClass) == typelib_TypeClass_INTERFACE_METHOD
|| ((pParamTypeDescr)->eTypeClass) == typelib_TypeClass_INTERFACE_ATTRIBUTE
)) typelib_typedescription_release( pParamTypeDescr ); };
164 }
165 }
166 pCppStack += sizeof(sal_Int32); // standard parameter length
167 }
168
169 try
170 {
171 OSL_ENSURE( !( (pCppStack - pCppStackStart ) & 3), "UNALIGNED STACK !!! (Please DO panic)" )do { if (true && (!(!( (pCppStack - pCppStackStart ) &
3)))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"
), ("/usr/local/src/libreoffice/bridges/source/cpp_uno/gcc3_linux_intel/uno2cpp.cxx"
":" "171" ": "), "%s", "UNALIGNED STACK !!! (Please DO panic)"
); } } while (false);
172 CPPU_CURRENT_NAMESPACEgcc3::callVirtualMethod(
173 pAdjustedThisPtr, aVtableSlot.index,
174 pCppReturn, pReturnTypeDescr, bSimpleReturn,
175 (sal_Int32 *)pCppStackStart, (pCppStack - pCppStackStart) / sizeof(sal_Int32) );
176 // NO exception occurred...
177 *ppUnoExc = 0;
178
179 // reconvert temporary params
180 for ( ; nTempIndizes--; )
181 {
182 sal_Int32 nIndex = pTempIndizes[nTempIndizes];
183 typelib_TypeDescription * pParamTypeDescr = ppTempParamTypeDescr[nTempIndizes];
184
185 if (pParams[nIndex].bIn)
186 {
187 if (pParams[nIndex].bOut) // inout
188 {
189 uno_destructData( pUnoArgs[nIndex], pParamTypeDescr, 0 ); // destroy uno value
190 uno_copyAndConvertData( pUnoArgs[nIndex], pCppArgs[nIndex], pParamTypeDescr,
191 pThis->getBridge()->getCpp2Uno() );
192 }
193 }
194 else // pure out
195 {
196 uno_copyAndConvertData( pUnoArgs[nIndex], pCppArgs[nIndex], pParamTypeDescr,
197 pThis->getBridge()->getCpp2Uno() );
198 }
199 // destroy temp cpp param => cpp: every param was constructed
200 uno_destructData( pCppArgs[nIndex], pParamTypeDescr, cpp_release );
201
202 TYPELIB_DANGER_RELEASE( pParamTypeDescr ){ if ((((pParamTypeDescr)->eTypeClass) == typelib_TypeClass_INTERFACE_METHOD
|| ((pParamTypeDescr)->eTypeClass) == typelib_TypeClass_INTERFACE_ATTRIBUTE
)) typelib_typedescription_release( pParamTypeDescr ); };
203 }
204 // return value
205 if (pCppReturn && pUnoReturn != pCppReturn)
206 {
207 uno_copyAndConvertData( pUnoReturn, pCppReturn, pReturnTypeDescr,
208 pThis->getBridge()->getCpp2Uno() );
209 uno_destructData( pCppReturn, pReturnTypeDescr, cpp_release );
210 }
211 }
212 catch (...)
213 {
214 // fill uno exception
215 fillUnoException( __cxa_get_globals()->caughtExceptions, *ppUnoExc, pThis->getBridge()->getCpp2Uno() );
216
217 // temporary params
218 for ( ; nTempIndizes--; )
219 {
220 sal_Int32 nIndex = pTempIndizes[nTempIndizes];
221 // destroy temp cpp param => cpp: every param was constructed
222 uno_destructData( pCppArgs[nIndex], ppTempParamTypeDescr[nTempIndizes], cpp_release );
223 TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndizes] ){ if ((((ppTempParamTypeDescr[nTempIndizes])->eTypeClass) ==
typelib_TypeClass_INTERFACE_METHOD || ((ppTempParamTypeDescr
[nTempIndizes])->eTypeClass) == typelib_TypeClass_INTERFACE_ATTRIBUTE
)) typelib_typedescription_release( ppTempParamTypeDescr[nTempIndizes
] ); };
224 }
225 // return type
226 if (pReturnTypeDescr)
227 TYPELIB_DANGER_RELEASE( pReturnTypeDescr ){ if ((((pReturnTypeDescr)->eTypeClass) == typelib_TypeClass_INTERFACE_METHOD
|| ((pReturnTypeDescr)->eTypeClass) == typelib_TypeClass_INTERFACE_ATTRIBUTE
)) typelib_typedescription_release( pReturnTypeDescr ); };
228 }
229}
230
231}
232
233namespace x86
234{
235 bool isSimpleReturnType(typelib_TypeDescription * pTD, bool recursive)
236 {
237 if (bridges::cpp_uno::shared::isSimpleType( pTD ))
238 return true;
239#if defined(FREEBSD) || defined(NETBSD) || defined(OPENBSD) || \
240 defined(MACOSX) || defined(DRAGONFLY)
241 // Only structs of exactly 1, 2, 4, or 8 bytes are returned through
242 // registers, see <http://developer.apple.com/documentation/DeveloperTools/
243 // Conceptual/LowLevelABI/Articles/IA32.html>:
244 if (pTD->eTypeClass == typelib_TypeClass_STRUCT &&
245 (recursive || pTD->nSize <= 2 || pTD->nSize == 4 || pTD->nSize == 8))
246 {
247 typelib_CompoundTypeDescription *const pCompTD =
248 (typelib_CompoundTypeDescription *) pTD;
249 for ( sal_Int32 pos = pCompTD->nMembers; pos--; ) {
250 typelib_TypeDescription * pMemberTD = 0;
251 TYPELIB_DANGER_GET( &pMemberTD, pCompTD->ppTypeRefs[pos] ){ typelib_TypeDescriptionReference * pMacroTypeRef = (pCompTD
->ppTypeRefs[pos]); typelib_TypeDescription ** ppMacroTypeDescr
= (&pMemberTD); if (((pMacroTypeRef->eTypeClass) == typelib_TypeClass_INTERFACE_METHOD
|| (pMacroTypeRef->eTypeClass) == typelib_TypeClass_INTERFACE_ATTRIBUTE
)) { typelib_typedescriptionreference_getDescription( ppMacroTypeDescr
, pMacroTypeRef ); } else if (!pMacroTypeRef->pType || !pMacroTypeRef
->pType->pWeakRef) { typelib_typedescriptionreference_getDescription
( ppMacroTypeDescr, pMacroTypeRef ); if (*ppMacroTypeDescr) typelib_typedescription_release
( *ppMacroTypeDescr ); } else { *ppMacroTypeDescr = pMacroTypeRef
->pType; } };
252 bool const b = isSimpleReturnType(pMemberTD, true);
253 TYPELIB_DANGER_RELEASE( pMemberTD ){ if ((((pMemberTD)->eTypeClass) == typelib_TypeClass_INTERFACE_METHOD
|| ((pMemberTD)->eTypeClass) == typelib_TypeClass_INTERFACE_ATTRIBUTE
)) typelib_typedescription_release( pMemberTD ); };
254 if (! b)
255 return false;
256 }
257 return true;
258 }
259#else
260 (void)recursive;
261#endif
262 return false;
263 }
264}
265
266namespace bridges { namespace cpp_uno { namespace shared {
267
268void unoInterfaceProxyDispatch(
269 uno_Interface * pUnoI, const typelib_TypeDescription * pMemberDescr,
270 void * pReturn, void * pArgs[], uno_Any ** ppException )
271{
272 // is my surrogate
273 bridges::cpp_uno::shared::UnoInterfaceProxy * pThis
274 = static_cast< bridges::cpp_uno::shared::UnoInterfaceProxy * >(pUnoI);
275
276 switch (pMemberDescr->eTypeClass)
1
Control jumps to 'case typelib_TypeClass_INTERFACE_METHOD:' at line 321
→
277 {
278 case typelib_TypeClass_INTERFACE_ATTRIBUTE:
279 {
280 VtableSlot aVtableSlot(
281 getVtableSlot(
282 reinterpret_cast<
283 typelib_InterfaceAttributeTypeDescription const * >(
284 pMemberDescr)));
285 if (pReturn)
286 {
287 // dependent dispatch
288 cpp_call(
289 pThis, aVtableSlot,
290 ((typelib_InterfaceAttributeTypeDescription *)pMemberDescr)->pAttributeTypeRef,
291 0, 0, // no params
292 pReturn, pArgs, ppException );
293 }
294 else
295 {
296 // is SET
297 typelib_MethodParameter aParam;
298 aParam.pTypeRef =
299 ((typelib_InterfaceAttributeTypeDescription *)pMemberDescr)->pAttributeTypeRef;
300 aParam.bIn = sal_True((sal_Bool)1);
301 aParam.bOut = sal_False((sal_Bool)0);
302
303 typelib_TypeDescriptionReference * pReturnTypeRef = 0;
304 OUString aVoidName( RTL_CONSTASCII_USTRINGPARAM("void")(&("void")[0]), ((sal_Int32)((sizeof ("void") / sizeof ((
"void")[0]))-1)), (((rtl_TextEncoding) 11)) );
305 typelib_typedescriptionreference_new(
306 &pReturnTypeRef, typelib_TypeClass_VOID, aVoidName.pData );
307
308 // dependent dispatch
309 aVtableSlot.index += 1; // get, then set method
310 cpp_call(
311 pThis, aVtableSlot,
312 pReturnTypeRef,
313 1, &aParam,
314 pReturn, pArgs, ppException );
315
316 typelib_typedescriptionreference_release( pReturnTypeRef );
317 }
318
319 break;
320 }
321 case typelib_TypeClass_INTERFACE_METHOD:
322 {
323 VtableSlot aVtableSlot(
324 getVtableSlot(
325 reinterpret_cast<
326 typelib_InterfaceMethodTypeDescription const * >(
327 pMemberDescr)));
328 switch (aVtableSlot.index)
2
←
Control jumps to the 'default' case at line 363
→
329 {
330 // standard calls
331 case 1: // acquire uno interface
332 (*pUnoI->acquire)( pUnoI );
333 *ppException = 0;
334 break;
335 case 2: // release uno interface
336 (*pUnoI->release)( pUnoI );
337 *ppException = 0;
338 break;
339 case 0: // queryInterface() opt
340 {
341 typelib_TypeDescription * pTD = 0;
342 TYPELIB_DANGER_GET( &pTD, reinterpret_cast< Type * >( pArgs[0] )->getTypeLibType() ){ typelib_TypeDescriptionReference * pMacroTypeRef = (reinterpret_cast
< Type * >( pArgs[0] )->getTypeLibType()); typelib_TypeDescription
** ppMacroTypeDescr = (&pTD); if (((pMacroTypeRef->eTypeClass
) == typelib_TypeClass_INTERFACE_METHOD || (pMacroTypeRef->
eTypeClass) == typelib_TypeClass_INTERFACE_ATTRIBUTE)) { typelib_typedescriptionreference_getDescription
( ppMacroTypeDescr, pMacroTypeRef ); } else if (!pMacroTypeRef
->pType || !pMacroTypeRef->pType->pWeakRef) { typelib_typedescriptionreference_getDescription
( ppMacroTypeDescr, pMacroTypeRef ); if (*ppMacroTypeDescr) typelib_typedescription_release
( *ppMacroTypeDescr ); } else { *ppMacroTypeDescr = pMacroTypeRef
->pType; } };
343 if (pTD)
344 {
345 uno_Interface * pInterface = 0;
346 (*pThis->pBridge->getUnoEnv()->getRegisteredInterface)(
347 pThis->pBridge->getUnoEnv(),
348 (void **)&pInterface, pThis->oid.pData, (typelib_InterfaceTypeDescription *)pTD );
349
350 if (pInterface)
351 {
352 ::uno_any_construct(
353 reinterpret_cast< uno_Any * >( pReturn ),
354 &pInterface, pTD, 0 );
355 (*pInterface->release)( pInterface );
356 TYPELIB_DANGER_RELEASE( pTD ){ if ((((pTD)->eTypeClass) == typelib_TypeClass_INTERFACE_METHOD
|| ((pTD)->eTypeClass) == typelib_TypeClass_INTERFACE_ATTRIBUTE
)) typelib_typedescription_release( pTD ); };
357 *ppException = 0;
358 break;
359 }
360 TYPELIB_DANGER_RELEASE( pTD ){ if ((((pTD)->eTypeClass) == typelib_TypeClass_INTERFACE_METHOD
|| ((pTD)->eTypeClass) == typelib_TypeClass_INTERFACE_ATTRIBUTE
)) typelib_typedescription_release( pTD ); };
361 }
362 } // else perform queryInterface()
363 default:
364 // dependent dispatch
365 cpp_call(
3
←
Calling 'cpp_call'
→
366 pThis, aVtableSlot,
367 ((typelib_InterfaceMethodTypeDescription *)pMemberDescr)->pReturnTypeRef,
368 ((typelib_InterfaceMethodTypeDescription *)pMemberDescr)->nParams,
369 ((typelib_InterfaceMethodTypeDescription *)pMemberDescr)->pParams,
370 pReturn, pArgs, ppException );
371 }
372 break;
373 }
374 default:
375 {
376 ::com::sun::star::uno::RuntimeException aExc(
377 OUString( RTL_CONSTASCII_USTRINGPARAM("illegal member type description!")(&("illegal member type description!")[0]), ((sal_Int32)(
(sizeof ("illegal member type description!") / sizeof (("illegal member type description!"
)[0]))-1)), (((rtl_TextEncoding) 11)) ),
378 ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface >() );
379
380 Type const & rExcType = ::getCppuType( &aExc );
381 // binary identical null reference
382 ::uno_type_any_construct( *ppException, &aExc, rExcType.getTypeLibType(), 0 );
383 }
384 }
385}
386
387} } }
388
389/* vim:set shiftwidth=4 softtabstop=4 expandtab: */