Bug Summary

File:stoc/source/corereflection/criface.cxx
Location:line 840, column 43
Description:Access to field 'pMemberName' results in a dereference of a null pointer (loaded from variable 'pTD')

Annotated 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
20
21#include <sal/config.h>
22#ifdef SAL_UNX
23#include <sal/alloca.h>
24#endif
25#if !(defined(MACOSX) || defined(IOS) || defined(FREEBSD))
26#include <malloc.h>
27#endif
28#include <rtl/alloc.h>
29#include <typelib/typedescription.hxx>
30#include <uno/data.h>
31
32#include "base.hxx"
33
34#include "com/sun/star/lang/WrappedTargetRuntimeException.hpp"
35#include "com/sun/star/uno/RuntimeException.hpp"
36#include "cppuhelper/exc_hlp.hxx"
37
38namespace stoc_corefl
39{
40
41//==================================================================================================
42class IdlAttributeFieldImpl
43 : public IdlMemberImpl
44 , public XIdlField
45 , public XIdlField2
46{
47public:
48 typelib_InterfaceAttributeTypeDescription * getAttributeTypeDescr()
49 { return (typelib_InterfaceAttributeTypeDescription *)getTypeDescr(); }
50
51 IdlAttributeFieldImpl( IdlReflectionServiceImpl * pReflection, const OUString & rName,
52 typelib_TypeDescription * pTypeDescr, typelib_TypeDescription * pDeclTypeDescr )
53 : IdlMemberImpl( pReflection, rName, pTypeDescr, pDeclTypeDescr )
54 {}
55
56 // XInterface
57 virtual Any SAL_CALL queryInterface( const Type & rType ) throw(::com::sun::star::uno::RuntimeException);
58 virtual void SAL_CALL acquire() throw();
59 virtual void SAL_CALL release() throw();
60
61 // XTypeProvider
62 virtual Sequence< Type > SAL_CALL getTypes() throw (::com::sun::star::uno::RuntimeException);
63 virtual Sequence< sal_Int8 > SAL_CALL getImplementationId() throw (::com::sun::star::uno::RuntimeException);
64
65 // XIdlMember
66 virtual Reference< XIdlClass > SAL_CALL getDeclaringClass() throw(::com::sun::star::uno::RuntimeException);
67 virtual OUString SAL_CALL getName() throw(::com::sun::star::uno::RuntimeException);
68 // XIdlField
69 virtual Reference< XIdlClass > SAL_CALL getType() throw(::com::sun::star::uno::RuntimeException);
70 virtual FieldAccessMode SAL_CALL getAccessMode() throw(::com::sun::star::uno::RuntimeException);
71 virtual Any SAL_CALL get( const Any & rObj ) throw(::com::sun::star::lang::IllegalArgumentException, ::com::sun::star::uno::RuntimeException);
72 virtual void SAL_CALL set( const Any & rObj, const Any & rValue ) throw(::com::sun::star::lang::IllegalArgumentException, ::com::sun::star::lang::IllegalAccessException, ::com::sun::star::uno::RuntimeException);
73 // XIdlField2: getType, getAccessMode and get are equal to XIdlField
74 virtual void SAL_CALL set( Any & rObj, const Any & rValue ) throw(::com::sun::star::lang::IllegalArgumentException, ::com::sun::star::lang::IllegalAccessException, ::com::sun::star::uno::RuntimeException);
75
76private:
77 void checkException(
78 uno_Any * exception, Reference< XInterface > const & context);
79};
80
81// XInterface
82//__________________________________________________________________________________________________
83Any IdlAttributeFieldImpl::queryInterface( const Type & rType )
84 throw(::com::sun::star::uno::RuntimeException)
85{
86 Any aRet( ::cppu::queryInterface( rType,
87 static_cast< XIdlField * >( this ),
88 static_cast< XIdlField2 * >( this ) ) );
89 return (aRet.hasValue() ? aRet : IdlMemberImpl::queryInterface( rType ));
90}
91//__________________________________________________________________________________________________
92void IdlAttributeFieldImpl::acquire() throw()
93{
94 IdlMemberImpl::acquire();
95}
96//__________________________________________________________________________________________________
97void IdlAttributeFieldImpl::release() throw()
98{
99 IdlMemberImpl::release();
100}
101
102// XTypeProvider
103//__________________________________________________________________________________________________
104Sequence< Type > IdlAttributeFieldImpl::getTypes()
105 throw (::com::sun::star::uno::RuntimeException)
106{
107 static OTypeCollection * s_pTypes = 0;
108 if (! s_pTypes)
109 {
110 MutexGuard aGuard( getMutexAccess() );
111 if (! s_pTypes)
112 {
113 static OTypeCollection s_aTypes(
114 ::getCppuType( (const Reference< XIdlField2 > *)0 ),
115 ::getCppuType( (const Reference< XIdlField > *)0 ),
116 IdlMemberImpl::getTypes() );
117 s_pTypes = &s_aTypes;
118 }
119 }
120 return s_pTypes->getTypes();
121}
122//__________________________________________________________________________________________________
123Sequence< sal_Int8 > IdlAttributeFieldImpl::getImplementationId()
124 throw (::com::sun::star::uno::RuntimeException)
125{
126 static OImplementationId * s_pId = 0;
127 if (! s_pId)
128 {
129 MutexGuard aGuard( getMutexAccess() );
130 if (! s_pId)
131 {
132 static OImplementationId s_aId;
133 s_pId = &s_aId;
134 }
135 }
136 return s_pId->getImplementationId();
137}
138
139// XIdlMember
140//__________________________________________________________________________________________________
141Reference< XIdlClass > IdlAttributeFieldImpl::getDeclaringClass()
142 throw(::com::sun::star::uno::RuntimeException)
143{
144 if (! _xDeclClass.is())
145 {
146 MutexGuard aGuard( getMutexAccess() );
147 if (! _xDeclClass.is())
148 {
149 rtl::OUString aName(getAttributeTypeDescr()->aBase.aBase.pTypeName);
150 sal_Int32 i = aName.indexOf(':');
151 OSL_ASSERT(i >= 0)do { if (true && (!(i >= 0))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/usr/local/src/libreoffice/stoc/source/corereflection/criface.cxx"
":" "151" ": "), "OSL_ASSERT: %s", "i >= 0"); } } while (
false);
152 _xDeclClass = getReflection()->forName(aName.copy(0, i));
153 }
154 }
155 return _xDeclClass;
156}
157//__________________________________________________________________________________________________
158OUString IdlAttributeFieldImpl::getName()
159 throw(::com::sun::star::uno::RuntimeException)
160{
161 return IdlMemberImpl::getName();
162}
163
164// XIdlField
165//__________________________________________________________________________________________________
166Reference< XIdlClass > IdlAttributeFieldImpl::getType()
167 throw(::com::sun::star::uno::RuntimeException)
168{
169 return getReflection()->forType(
170 getAttributeTypeDescr()->pAttributeTypeRef );
171}
172//__________________________________________________________________________________________________
173FieldAccessMode IdlAttributeFieldImpl::getAccessMode()
174 throw(::com::sun::star::uno::RuntimeException)
175{
176 return (((typelib_InterfaceAttributeTypeDescription *)getAttributeTypeDescr())->bReadOnly
177 ? FieldAccessMode_READONLY : FieldAccessMode_READWRITE);
178}
179//__________________________________________________________________________________________________
180Any IdlAttributeFieldImpl::get( const Any & rObj )
181 throw(::com::sun::star::lang::IllegalArgumentException, ::com::sun::star::uno::RuntimeException)
182{
183 uno_Interface * pUnoI = getReflection()->mapToUno(
184 rObj, (typelib_InterfaceTypeDescription *)getDeclTypeDescr() );
185 OSL_ENSURE( pUnoI, "### illegal destination object given!" )do { if (true && (!(pUnoI))) { sal_detail_logFormat((
SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/usr/local/src/libreoffice/stoc/source/corereflection/criface.cxx"
":" "185" ": "), "%s", "### illegal destination object given!"
); } } while (false);
186 if (pUnoI)
187 {
188 TypeDescription aTD( getAttributeTypeDescr()->pAttributeTypeRef );
189 typelib_TypeDescription * pTD = aTD.get();
190
191 uno_Any aExc;
192 uno_Any * pExc = &aExc;
193 void * pReturn = alloca( pTD->nSize )__builtin_alloca (pTD->nSize);
194
195 (*pUnoI->pDispatcher)( pUnoI, getTypeDescr(), pReturn, 0, &pExc );
196 (*pUnoI->release)( pUnoI );
197
198 checkException(
199 pExc,
200 *static_cast< Reference< XInterface > const * >(rObj.getValue()));
201 Any aRet;
202 uno_any_destruct(
203 &aRet, reinterpret_cast< uno_ReleaseFunc >(cpp_release) );
204 uno_any_constructAndConvert( &aRet, pReturn, pTD, getReflection()->getUno2Cpp().get() );
205 uno_destructData( pReturn, pTD, 0 );
206 return aRet;
207 }
208 throw IllegalArgumentException(
209 OUString( RTL_CONSTASCII_USTRINGPARAM("illegal object given!")(&("illegal object given!")[0]), ((sal_Int32)((sizeof ("illegal object given!"
) / sizeof (("illegal object given!")[0]))-1)), (((rtl_TextEncoding
) 11)) ),
210 (XWeak *)(OWeakObject *)this, 0 );
211}
212//__________________________________________________________________________________________________
213void IdlAttributeFieldImpl::set( Any & rObj, const Any & rValue )
214 throw(::com::sun::star::lang::IllegalArgumentException, ::com::sun::star::lang::IllegalAccessException, ::com::sun::star::uno::RuntimeException)
215{
216 if (getAttributeTypeDescr()->bReadOnly)
217 {
218 throw IllegalAccessException(
219 OUString( RTL_CONSTASCII_USTRINGPARAM("cannot set readonly attribute!")(&("cannot set readonly attribute!")[0]), ((sal_Int32)((sizeof
("cannot set readonly attribute!") / sizeof (("cannot set readonly attribute!"
)[0]))-1)), (((rtl_TextEncoding) 11)) ),
220 (XWeak *)(OWeakObject *)this );
221 }
222
223 uno_Interface * pUnoI = getReflection()->mapToUno(
224 rObj, (typelib_InterfaceTypeDescription *)getDeclTypeDescr() );
225 OSL_ENSURE( pUnoI, "### illegal destination object given!" )do { if (true && (!(pUnoI))) { sal_detail_logFormat((
SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/usr/local/src/libreoffice/stoc/source/corereflection/criface.cxx"
":" "225" ": "), "%s", "### illegal destination object given!"
); } } while (false);
226 if (pUnoI)
227 {
228 TypeDescription aTD( getAttributeTypeDescr()->pAttributeTypeRef );
229 typelib_TypeDescription * pTD = aTD.get();
230
231 // construct uno value to be set
232 void * pArgs[1];
233 void * pArg = pArgs[0] = alloca( pTD->nSize )__builtin_alloca (pTD->nSize);
234
235 sal_Bool bAssign;
236 if (pTD->eTypeClass == typelib_TypeClass_ANY)
237 {
238 uno_copyAndConvertData( pArg, (const_cast< Any * >(&rValue)),
239 pTD, getReflection()->getCpp2Uno().get() );
240 bAssign = sal_True((sal_Bool)1);
241 }
242 else if (typelib_typedescriptionreference_equals( rValue.getValueTypeRef(), pTD->pWeakRef ))
243 {
244 uno_copyAndConvertData( pArg, (const_cast< void * >(rValue.getValue()) ),
245 pTD, getReflection()->getCpp2Uno().get() );
246 bAssign = sal_True((sal_Bool)1);
247 }
248 else if (pTD->eTypeClass == typelib_TypeClass_INTERFACE)
249 {
250 Reference< XInterface > xObj;
251 bAssign = extract(
252 rValue, (typelib_InterfaceTypeDescription *)pTD, xObj,
253 getReflection() );
254 if (bAssign)
255 {
256 *(void **)pArg = getReflection()->getCpp2Uno().mapInterface(
257 xObj.get(), (typelib_InterfaceTypeDescription *)pTD );
258 }
259 }
260 else
261 {
262 typelib_TypeDescription * pValueTD = 0;
263 TYPELIB_DANGER_GET( &pValueTD, rValue.getValueTypeRef() ){ typelib_TypeDescriptionReference * pMacroTypeRef = (rValue.
getValueTypeRef()); typelib_TypeDescription ** ppMacroTypeDescr
= (&pValueTD); 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; } };
264 // construct temp uno val to do proper assignment: todo opt
265 void * pTemp = alloca( pValueTD->nSize )__builtin_alloca (pValueTD->nSize);
266 uno_copyAndConvertData(
267 pTemp, (void *)rValue.getValue(), pValueTD, getReflection()->getCpp2Uno().get() );
268 uno_constructData(
269 pArg, pTD );
270 // assignment does simple conversion
271 bAssign = uno_assignData(
272 pArg, pTD, pTemp, pValueTD, 0, 0, 0 );
273 uno_destructData(
274 pTemp, pValueTD, 0 );
275 TYPELIB_DANGER_RELEASE( pValueTD ){ if ((((pValueTD)->eTypeClass) == typelib_TypeClass_INTERFACE_METHOD
|| ((pValueTD)->eTypeClass) == typelib_TypeClass_INTERFACE_ATTRIBUTE
)) typelib_typedescription_release( pValueTD ); };
276 }
277
278 if (bAssign)
279 {
280 uno_Any aExc;
281 uno_Any * pExc = &aExc;
282 (*pUnoI->pDispatcher)( pUnoI, getTypeDescr(), 0, pArgs, &pExc );
283 (*pUnoI->release)( pUnoI );
284
285 uno_destructData( pArg, pTD, 0 );
286 checkException(
287 pExc,
288 *static_cast< Reference< XInterface > const * >(
289 rObj.getValue()));
290 return;
291 }
292 (*pUnoI->release)( pUnoI );
293
294 throw IllegalArgumentException(
295 OUString( RTL_CONSTASCII_USTRINGPARAM("illegal value given!")(&("illegal value given!")[0]), ((sal_Int32)((sizeof ("illegal value given!"
) / sizeof (("illegal value given!")[0]))-1)), (((rtl_TextEncoding
) 11)) ),
296 *(const Reference< XInterface > *)rObj.getValue(), 1 );
297 }
298 throw IllegalArgumentException(
299 OUString( RTL_CONSTASCII_USTRINGPARAM("illegal destination object given!")(&("illegal destination object given!")[0]), ((sal_Int32)
((sizeof ("illegal destination object given!") / sizeof (("illegal destination object given!"
)[0]))-1)), (((rtl_TextEncoding) 11)) ),
300 (XWeak *)(OWeakObject *)this, 0 );
301}
302//__________________________________________________________________________________________________
303void IdlAttributeFieldImpl::set( const Any & rObj, const Any & rValue )
304 throw(::com::sun::star::lang::IllegalArgumentException, ::com::sun::star::lang::IllegalAccessException, ::com::sun::star::uno::RuntimeException)
305{
306 IdlAttributeFieldImpl::set( const_cast< Any & >( rObj ), rValue );
307}
308
309void IdlAttributeFieldImpl::checkException(
310 uno_Any * exception, Reference< XInterface > const & context)
311{
312 if (exception != 0) {
313 Any e;
314 uno_any_destruct(&e, reinterpret_cast< uno_ReleaseFunc >(cpp_release));
315 uno_type_any_constructAndConvert(
316 &e, exception->pData, exception->pType,
317 getReflection()->getUno2Cpp().get());
318 uno_any_destruct(exception, 0);
319 if (e.isExtractableTo(
320 getCppuType(static_cast< RuntimeException const * >(0))))
321 {
322 cppu::throwException(e);
323 } else {
324 throw WrappedTargetRuntimeException(
325 OUString(
326 RTL_CONSTASCII_USTRINGPARAM((&("non-RuntimeException occurred when accessing an" " interface type attribute"
)[0]), ((sal_Int32)((sizeof ("non-RuntimeException occurred when accessing an"
" interface type attribute") / sizeof (("non-RuntimeException occurred when accessing an"
" interface type attribute")[0]))-1)), (((rtl_TextEncoding) 11
))
327 "non-RuntimeException occurred when accessing an"(&("non-RuntimeException occurred when accessing an" " interface type attribute"
)[0]), ((sal_Int32)((sizeof ("non-RuntimeException occurred when accessing an"
" interface type attribute") / sizeof (("non-RuntimeException occurred when accessing an"
" interface type attribute")[0]))-1)), (((rtl_TextEncoding) 11
))
328 " interface type attribute")(&("non-RuntimeException occurred when accessing an" " interface type attribute"
)[0]), ((sal_Int32)((sizeof ("non-RuntimeException occurred when accessing an"
" interface type attribute") / sizeof (("non-RuntimeException occurred when accessing an"
" interface type attribute")[0]))-1)), (((rtl_TextEncoding) 11
))),
329 context, e);
330 }
331 }
332}
333
334//##################################################################################################
335//##################################################################################################
336//##################################################################################################
337
338
339//==================================================================================================
340class IdlInterfaceMethodImpl
341 : public IdlMemberImpl
342 , public XIdlMethod
343{
344 Sequence< Reference< XIdlClass > > * _pExceptionTypes;
345 Sequence< Reference< XIdlClass > > * _pParamTypes;
346 Sequence< ParamInfo > * _pParamInfos;
347
348public:
349 typelib_InterfaceMethodTypeDescription * getMethodTypeDescr()
350 { return (typelib_InterfaceMethodTypeDescription *)getTypeDescr(); }
351
352 IdlInterfaceMethodImpl( IdlReflectionServiceImpl * pReflection, const OUString & rName,
353 typelib_TypeDescription * pTypeDescr, typelib_TypeDescription * pDeclTypeDescr )
354 : IdlMemberImpl( pReflection, rName, pTypeDescr, pDeclTypeDescr )
355 , _pExceptionTypes( 0 )
356 , _pParamTypes( 0 )
357 , _pParamInfos( 0 )
358 {}
359 virtual ~IdlInterfaceMethodImpl();
360
361 // XInterface
362 virtual Any SAL_CALL queryInterface( const Type & rType ) throw(::com::sun::star::uno::RuntimeException);
363 virtual void SAL_CALL acquire() throw();
364 virtual void SAL_CALL release() throw();
365
366 // XTypeProvider
367 virtual Sequence< Type > SAL_CALL getTypes() throw (::com::sun::star::uno::RuntimeException);
368 virtual Sequence< sal_Int8 > SAL_CALL getImplementationId() throw (::com::sun::star::uno::RuntimeException);
369
370 // XIdlMember
371 virtual Reference< XIdlClass > SAL_CALL getDeclaringClass() throw(::com::sun::star::uno::RuntimeException);
372 virtual OUString SAL_CALL getName() throw(::com::sun::star::uno::RuntimeException);
373 // XIdlMethod
374 virtual Reference< XIdlClass > SAL_CALL getReturnType() throw(::com::sun::star::uno::RuntimeException);
375 virtual Sequence< Reference< XIdlClass > > SAL_CALL getParameterTypes() throw(::com::sun::star::uno::RuntimeException);
376 virtual Sequence< ParamInfo > SAL_CALL getParameterInfos() throw(::com::sun::star::uno::RuntimeException);
377 virtual Sequence< Reference< XIdlClass > > SAL_CALL getExceptionTypes() throw(::com::sun::star::uno::RuntimeException);
378 virtual MethodMode SAL_CALL getMode() throw(::com::sun::star::uno::RuntimeException);
379 virtual Any SAL_CALL invoke( const Any & rObj, Sequence< Any > & rArgs ) throw(::com::sun::star::lang::IllegalArgumentException, ::com::sun::star::reflection::InvocationTargetException, ::com::sun::star::uno::RuntimeException);
380};
381//__________________________________________________________________________________________________
382IdlInterfaceMethodImpl::~IdlInterfaceMethodImpl()
383{
384 delete _pParamInfos;
385 delete _pParamTypes;
386 delete _pExceptionTypes;
387}
388
389// XInterface
390//__________________________________________________________________________________________________
391Any IdlInterfaceMethodImpl::queryInterface( const Type & rType )
392 throw(::com::sun::star::uno::RuntimeException)
393{
394 Any aRet( ::cppu::queryInterface( rType, static_cast< XIdlMethod * >( this ) ) );
395 return (aRet.hasValue() ? aRet : IdlMemberImpl::queryInterface( rType ));
396}
397//__________________________________________________________________________________________________
398void IdlInterfaceMethodImpl::acquire() throw()
399{
400 IdlMemberImpl::acquire();
401}
402//__________________________________________________________________________________________________
403void IdlInterfaceMethodImpl::release() throw()
404{
405 IdlMemberImpl::release();
406}
407
408// XTypeProvider
409//__________________________________________________________________________________________________
410Sequence< Type > IdlInterfaceMethodImpl::getTypes()
411 throw (::com::sun::star::uno::RuntimeException)
412{
413 static OTypeCollection * s_pTypes = 0;
414 if (! s_pTypes)
415 {
416 MutexGuard aGuard( getMutexAccess() );
417 if (! s_pTypes)
418 {
419 static OTypeCollection s_aTypes(
420 ::getCppuType( (const Reference< XIdlMethod > *)0 ),
421 IdlMemberImpl::getTypes() );
422 s_pTypes = &s_aTypes;
423 }
424 }
425 return s_pTypes->getTypes();
426}
427//__________________________________________________________________________________________________
428Sequence< sal_Int8 > IdlInterfaceMethodImpl::getImplementationId()
429 throw (::com::sun::star::uno::RuntimeException)
430{
431 static OImplementationId * s_pId = 0;
432 if (! s_pId)
433 {
434 MutexGuard aGuard( getMutexAccess() );
435 if (! s_pId)
436 {
437 static OImplementationId s_aId;
438 s_pId = &s_aId;
439 }
440 }
441 return s_pId->getImplementationId();
442}
443
444// XIdlMember
445//__________________________________________________________________________________________________
446Reference< XIdlClass > IdlInterfaceMethodImpl::getDeclaringClass()
447 throw(::com::sun::star::uno::RuntimeException)
448{
449 if (! _xDeclClass.is())
450 {
451 MutexGuard aGuard( getMutexAccess() );
452 if (! _xDeclClass.is())
453 {
454 rtl::OUString aName(getMethodTypeDescr()->aBase.aBase.pTypeName);
455 sal_Int32 i = aName.indexOf(':');
456 OSL_ASSERT(i >= 0)do { if (true && (!(i >= 0))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/usr/local/src/libreoffice/stoc/source/corereflection/criface.cxx"
":" "456" ": "), "OSL_ASSERT: %s", "i >= 0"); } } while (
false);
457 _xDeclClass = getReflection()->forName(aName.copy(0, i));
458 }
459 }
460 return _xDeclClass;
461}
462//__________________________________________________________________________________________________
463OUString IdlInterfaceMethodImpl::getName()
464 throw(::com::sun::star::uno::RuntimeException)
465{
466 return IdlMemberImpl::getName();
467}
468
469// XIdlMethod
470//__________________________________________________________________________________________________
471Reference< XIdlClass > SAL_CALL IdlInterfaceMethodImpl::getReturnType()
472 throw(::com::sun::star::uno::RuntimeException)
473{
474 return getReflection()->forType( getMethodTypeDescr()->pReturnTypeRef );
475}
476//__________________________________________________________________________________________________
477Sequence< Reference< XIdlClass > > IdlInterfaceMethodImpl::getExceptionTypes()
478 throw(::com::sun::star::uno::RuntimeException)
479{
480 if (! _pExceptionTypes)
481 {
482 MutexGuard aGuard( getMutexAccess() );
483 if (! _pExceptionTypes)
484 {
485 sal_Int32 nExc = getMethodTypeDescr()->nExceptions;
486 Sequence< Reference< XIdlClass > > * pTempExceptionTypes =
487 new Sequence< Reference< XIdlClass > >( nExc );
488 Reference< XIdlClass > * pExceptionTypes = pTempExceptionTypes->getArray();
489
490 typelib_TypeDescriptionReference ** ppExc =
491 getMethodTypeDescr()->ppExceptions;
492 IdlReflectionServiceImpl * pRefl = getReflection();
493
494 while (nExc--)
495 pExceptionTypes[nExc] = pRefl->forType( ppExc[nExc] );
496
497 _pExceptionTypes = pTempExceptionTypes;
498 }
499 }
500 return *_pExceptionTypes;
501}
502//__________________________________________________________________________________________________
503Sequence< Reference< XIdlClass > > IdlInterfaceMethodImpl::getParameterTypes()
504 throw(::com::sun::star::uno::RuntimeException)
505{
506 if (! _pParamTypes)
507 {
508 MutexGuard aGuard( getMutexAccess() );
509 if (! _pParamTypes)
510 {
511 sal_Int32 nParams = getMethodTypeDescr()->nParams;
512 Sequence< Reference< XIdlClass > > * pTempParamTypes =
513 new Sequence< Reference< XIdlClass > >( nParams );
514 Reference< XIdlClass > * pParamTypes = pTempParamTypes->getArray();
515
516 typelib_MethodParameter * pTypelibParams =
517 getMethodTypeDescr()->pParams;
518 IdlReflectionServiceImpl * pRefl = getReflection();
519
520 while (nParams--)
521 pParamTypes[nParams] = pRefl->forType( pTypelibParams[nParams].pTypeRef );
522
523 _pParamTypes = pTempParamTypes;
524 }
525 }
526 return *_pParamTypes;
527}
528//__________________________________________________________________________________________________
529Sequence< ParamInfo > IdlInterfaceMethodImpl::getParameterInfos()
530 throw(::com::sun::star::uno::RuntimeException)
531{
532 if (! _pParamInfos)
533 {
534 MutexGuard aGuard( getMutexAccess() );
535 if (! _pParamInfos)
536 {
537 sal_Int32 nParams = getMethodTypeDescr()->nParams;
538 Sequence< ParamInfo > * pTempParamInfos = new Sequence< ParamInfo >( nParams );
539 ParamInfo * pParamInfos = pTempParamInfos->getArray();
540
541 typelib_MethodParameter * pTypelibParams =
542 getMethodTypeDescr()->pParams;
543
544 if (_pParamTypes) // use param types
545 {
546 const Reference< XIdlClass > * pParamTypes = _pParamTypes->getConstArray();
547
548 while (nParams--)
549 {
550 const typelib_MethodParameter & rParam = pTypelibParams[nParams];
551 ParamInfo & rInfo = pParamInfos[nParams];
552 rInfo.aName = rParam.pName;
553 if (rParam.bIn)
554 rInfo.aMode = (rParam.bOut ? ParamMode_INOUT : ParamMode_IN);
555 else
556 rInfo.aMode = ParamMode_OUT;
557 rInfo.aType = pParamTypes[nParams];
558 }
559 }
560 else // make also param types sequence if not already initialized
561 {
562 Sequence< Reference< XIdlClass > > * pTempParamTypes =
563 new Sequence< Reference< XIdlClass > >( nParams );
564 Reference< XIdlClass > * pParamTypes = pTempParamTypes->getArray();
565
566 IdlReflectionServiceImpl * pRefl = getReflection();
567
568 while (nParams--)
569 {
570 const typelib_MethodParameter & rParam = pTypelibParams[nParams];
571 ParamInfo & rInfo = pParamInfos[nParams];
572 rInfo.aName = rParam.pName;
573 if (rParam.bIn)
574 rInfo.aMode = (rParam.bOut ? ParamMode_INOUT : ParamMode_IN);
575 else
576 rInfo.aMode = ParamMode_OUT;
577 rInfo.aType = pParamTypes[nParams] = pRefl->forType( rParam.pTypeRef );
578 }
579
580 _pParamTypes = pTempParamTypes;
581 }
582
583 _pParamInfos = pTempParamInfos;
584 }
585 }
586 return *_pParamInfos;
587}
588//__________________________________________________________________________________________________
589MethodMode SAL_CALL IdlInterfaceMethodImpl::getMode()
590 throw(::com::sun::star::uno::RuntimeException)
591{
592 return
593 getMethodTypeDescr()->bOneWay ? MethodMode_ONEWAY : MethodMode_TWOWAY;
594}
595//__________________________________________________________________________________________________
596Any SAL_CALL IdlInterfaceMethodImpl::invoke( const Any & rObj, Sequence< Any > & rArgs )
597 throw(::com::sun::star::lang::IllegalArgumentException,
598 ::com::sun::star::reflection::InvocationTargetException,
599 ::com::sun::star::uno::RuntimeException)
600{
601 if (rObj.getValueTypeClass() == TypeClass_INTERFACE)
602 {
603 // acquire()/ release()
604 if (rtl_ustr_ascii_compare( getTypeDescr()->pTypeName->buffer,
605 "com.sun.star.uno.XInterface::acquire" ) == 0)
606 {
607 (*(const Reference< XInterface > *)rObj.getValue())->acquire();
608 return Any();
609 }
610 else if (rtl_ustr_ascii_compare( getTypeDescr()->pTypeName->buffer,
611 "com.sun.star.uno.XInterface::release" ) == 0)
612 {
613 (*(const Reference< XInterface > *)rObj.getValue())->release();
614 return Any();
615 }
616 }
617
618 uno_Interface * pUnoI = getReflection()->mapToUno(
619 rObj, (typelib_InterfaceTypeDescription *)getDeclTypeDescr() );
620 OSL_ENSURE( pUnoI, "### illegal destination object given!" )do { if (true && (!(pUnoI))) { sal_detail_logFormat((
SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/usr/local/src/libreoffice/stoc/source/corereflection/criface.cxx"
":" "620" ": "), "%s", "### illegal destination object given!"
); } } while (false);
621 if (pUnoI)
622 {
623 sal_Int32 nParams = getMethodTypeDescr()->nParams;
624 if (rArgs.getLength() != nParams)
625 {
626 (*pUnoI->release)( pUnoI );
627 throw IllegalArgumentException(
628 OUString( RTL_CONSTASCII_USTRINGPARAM("arguments len differ!")(&("arguments len differ!")[0]), ((sal_Int32)((sizeof ("arguments len differ!"
) / sizeof (("arguments len differ!")[0]))-1)), (((rtl_TextEncoding
) 11)) ),
629 *(const Reference< XInterface > *)rObj.getValue(), 1 );
630 }
631
632 Any * pCppArgs = rArgs.getArray();
633 typelib_MethodParameter * pParams = getMethodTypeDescr()->pParams;
634 typelib_TypeDescription * pReturnType = 0;
635 TYPELIB_DANGER_GET({ typelib_TypeDescriptionReference * pMacroTypeRef = (getMethodTypeDescr
()->pReturnTypeRef); typelib_TypeDescription ** ppMacroTypeDescr
= (&pReturnType); 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; } }
636 &pReturnType, getMethodTypeDescr()->pReturnTypeRef ){ typelib_TypeDescriptionReference * pMacroTypeRef = (getMethodTypeDescr
()->pReturnTypeRef); typelib_TypeDescription ** ppMacroTypeDescr
= (&pReturnType); 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; } };
637
638 void * pUnoReturn = alloca( pReturnType->nSize )__builtin_alloca (pReturnType->nSize);
639 void ** ppUnoArgs = (void **)alloca( sizeof(void *) * nParams *2 )__builtin_alloca (sizeof(void *) * nParams *2);
640 typelib_TypeDescription ** ppParamTypes = (typelib_TypeDescription **)(ppUnoArgs + nParams);
641
642 // convert arguments
643 for ( sal_Int32 nPos = 0; nPos < nParams; ++nPos )
644 {
645 ppParamTypes[nPos] = 0;
646 TYPELIB_DANGER_GET( ppParamTypes + nPos, pParams[nPos].pTypeRef ){ typelib_TypeDescriptionReference * pMacroTypeRef = (pParams
[nPos].pTypeRef); typelib_TypeDescription ** ppMacroTypeDescr
= (ppParamTypes + nPos); 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; } };
647 typelib_TypeDescription * pTD = ppParamTypes[nPos];
648
649 ppUnoArgs[nPos] = alloca( pTD->nSize )__builtin_alloca (pTD->nSize);
650 if (pParams[nPos].bIn)
651 {
652 sal_Bool bAssign;
653 if (typelib_typedescriptionreference_equals(
654 pCppArgs[nPos].getValueTypeRef(), pTD->pWeakRef ))
655 {
656 uno_type_copyAndConvertData(
657 ppUnoArgs[nPos], (void *)pCppArgs[nPos].getValue(),
658 pCppArgs[nPos].getValueTypeRef(), getReflection()->getCpp2Uno().get() );
659 bAssign = sal_True((sal_Bool)1);
660 }
661 else if (pTD->eTypeClass == typelib_TypeClass_ANY)
662 {
663 uno_type_any_constructAndConvert(
664 (uno_Any *)ppUnoArgs[nPos], (void *)pCppArgs[nPos].getValue(),
665 pCppArgs[nPos].getValueTypeRef(), getReflection()->getCpp2Uno().get() );
666 bAssign = sal_True((sal_Bool)1);
667 }
668 else if (pTD->eTypeClass == typelib_TypeClass_INTERFACE)
669 {
670 Reference< XInterface > xDest;
671 bAssign = extract(
672 pCppArgs[nPos], (typelib_InterfaceTypeDescription *)pTD,
673 xDest, getReflection() );
674 if (bAssign)
675 {
676 *(void **)ppUnoArgs[nPos] = getReflection()->getCpp2Uno().mapInterface(
677 xDest.get(), (typelib_InterfaceTypeDescription *)pTD );
678 }
679 }
680 else
681 {
682 typelib_TypeDescription * pValueTD = 0;
683 TYPELIB_DANGER_GET( &pValueTD, pCppArgs[nPos].getValueTypeRef() ){ typelib_TypeDescriptionReference * pMacroTypeRef = (pCppArgs
[nPos].getValueTypeRef()); typelib_TypeDescription ** ppMacroTypeDescr
= (&pValueTD); 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; } };
684 // construct temp uno val to do proper assignment: todo opt
685 void * pTemp = alloca( pValueTD->nSize )__builtin_alloca (pValueTD->nSize);
686 uno_copyAndConvertData(
687 pTemp, (void *)pCppArgs[nPos].getValue(), pValueTD,
688 getReflection()->getCpp2Uno().get() );
689 uno_constructData(
690 ppUnoArgs[nPos], pTD );
691 // assignment does simple conversion
692 bAssign = uno_assignData(
693 ppUnoArgs[nPos], pTD, pTemp, pValueTD, 0, 0, 0 );
694 uno_destructData(
695 pTemp, pValueTD, 0 );
696 TYPELIB_DANGER_RELEASE( pValueTD ){ if ((((pValueTD)->eTypeClass) == typelib_TypeClass_INTERFACE_METHOD
|| ((pValueTD)->eTypeClass) == typelib_TypeClass_INTERFACE_ATTRIBUTE
)) typelib_typedescription_release( pValueTD ); };
697 }
698
699 if (! bAssign)
700 {
701 IllegalArgumentException aExc(
702 OUString( RTL_CONSTASCII_USTRINGPARAM("cannot coerce argument type during corereflection call!")(&("cannot coerce argument type during corereflection call!"
)[0]), ((sal_Int32)((sizeof ("cannot coerce argument type during corereflection call!"
) / sizeof (("cannot coerce argument type during corereflection call!"
)[0]))-1)), (((rtl_TextEncoding) 11)) ),
703 *(const Reference< XInterface > *)rObj.getValue(), (sal_Int16)nPos );
704
705 // cleanup
706 while (nPos--)
707 {
708 if (pParams[nPos].bIn)
709 uno_destructData( ppUnoArgs[nPos], ppParamTypes[nPos], 0 );
710 TYPELIB_DANGER_RELEASE( ppParamTypes[nPos] ){ if ((((ppParamTypes[nPos])->eTypeClass) == typelib_TypeClass_INTERFACE_METHOD
|| ((ppParamTypes[nPos])->eTypeClass) == typelib_TypeClass_INTERFACE_ATTRIBUTE
)) typelib_typedescription_release( ppParamTypes[nPos] ); };
711 }
712 TYPELIB_DANGER_RELEASE( pReturnType ){ if ((((pReturnType)->eTypeClass) == typelib_TypeClass_INTERFACE_METHOD
|| ((pReturnType)->eTypeClass) == typelib_TypeClass_INTERFACE_ATTRIBUTE
)) typelib_typedescription_release( pReturnType ); };
713 (*pUnoI->release)( pUnoI );
714
715 throw aExc;
716 }
717 }
718 }
719
720 uno_Any aUnoExc;
721 uno_Any * pUnoExc = &aUnoExc;
722
723 (*pUnoI->pDispatcher)(
724 pUnoI, getTypeDescr(), pUnoReturn, ppUnoArgs, &pUnoExc );
725 (*pUnoI->release)( pUnoI );
726
727 Any aRet;
728 if (pUnoExc)
729 {
730 // cleanup
731 while (nParams--)
732 {
733 if (pParams[nParams].bIn)
734 uno_destructData( ppUnoArgs[nParams], ppParamTypes[nParams], 0 );
735 TYPELIB_DANGER_RELEASE( ppParamTypes[nParams] ){ if ((((ppParamTypes[nParams])->eTypeClass) == typelib_TypeClass_INTERFACE_METHOD
|| ((ppParamTypes[nParams])->eTypeClass) == typelib_TypeClass_INTERFACE_ATTRIBUTE
)) typelib_typedescription_release( ppParamTypes[nParams] ); };
736 }
737 TYPELIB_DANGER_RELEASE( pReturnType ){ if ((((pReturnType)->eTypeClass) == typelib_TypeClass_INTERFACE_METHOD
|| ((pReturnType)->eTypeClass) == typelib_TypeClass_INTERFACE_ATTRIBUTE
)) typelib_typedescription_release( pReturnType ); };
738
739 InvocationTargetException aExc;
740 aExc.Context = *(const Reference< XInterface > *)rObj.getValue();
741 aExc.Message = OUString( RTL_CONSTASCII_USTRINGPARAM("exception occurred during invocation!")(&("exception occurred during invocation!")[0]), ((sal_Int32
)((sizeof ("exception occurred during invocation!") / sizeof (
("exception occurred during invocation!")[0]))-1)), (((rtl_TextEncoding
) 11)) );
742 uno_any_destruct(
743 &aExc.TargetException,
744 reinterpret_cast< uno_ReleaseFunc >(cpp_release) );
745 uno_type_copyAndConvertData(
746 &aExc.TargetException, pUnoExc, ::getCppuType( (const Any *)0 ).getTypeLibType(),
747 getReflection()->getUno2Cpp().get() );
748 uno_any_destruct( pUnoExc, 0 );
749 throw aExc;
750 }
751 else
752 {
753 // reconvert arguments and cleanup
754 while (nParams--)
755 {
756 if (pParams[nParams].bOut) // write back
757 {
758 uno_any_destruct(
759 &pCppArgs[nParams],
760 reinterpret_cast< uno_ReleaseFunc >(cpp_release) );
761 uno_any_constructAndConvert(
762 &pCppArgs[nParams], ppUnoArgs[nParams], ppParamTypes[nParams],
763 getReflection()->getUno2Cpp().get() );
764 }
765 uno_destructData( ppUnoArgs[nParams], ppParamTypes[nParams], 0 );
766 TYPELIB_DANGER_RELEASE( ppParamTypes[nParams] ){ if ((((ppParamTypes[nParams])->eTypeClass) == typelib_TypeClass_INTERFACE_METHOD
|| ((ppParamTypes[nParams])->eTypeClass) == typelib_TypeClass_INTERFACE_ATTRIBUTE
)) typelib_typedescription_release( ppParamTypes[nParams] ); };
767 }
768 uno_any_destruct(
769 &aRet, reinterpret_cast< uno_ReleaseFunc >(cpp_release) );
770 uno_any_constructAndConvert(
771 &aRet, pUnoReturn, pReturnType,
772 getReflection()->getUno2Cpp().get() );
773 uno_destructData( pUnoReturn, pReturnType, 0 );
774 TYPELIB_DANGER_RELEASE( pReturnType ){ if ((((pReturnType)->eTypeClass) == typelib_TypeClass_INTERFACE_METHOD
|| ((pReturnType)->eTypeClass) == typelib_TypeClass_INTERFACE_ATTRIBUTE
)) typelib_typedescription_release( pReturnType ); };
775 }
776 return aRet;
777 }
778 throw IllegalArgumentException(
779 OUString( RTL_CONSTASCII_USTRINGPARAM("illegal destination object given!")(&("illegal destination object given!")[0]), ((sal_Int32)
((sizeof ("illegal destination object given!") / sizeof (("illegal destination object given!"
)[0]))-1)), (((rtl_TextEncoding) 11)) ),
780 (XWeak *)(OWeakObject *)this, 0 );
781}
782
783
784//##################################################################################################
785//##################################################################################################
786//##################################################################################################
787
788
789//__________________________________________________________________________________________________
790InterfaceIdlClassImpl::~InterfaceIdlClassImpl()
791{
792 for ( sal_Int32 nPos = _nMethods + _nAttributes; nPos--; )
793 typelib_typedescription_release( _pSortedMemberInit[nPos].second );
794
795 delete [] _pSortedMemberInit;
796}
797
798//__________________________________________________________________________________________________
799Sequence< Reference< XIdlClass > > InterfaceIdlClassImpl::getSuperclasses()
800 throw(::com::sun::star::uno::RuntimeException)
801{
802 MutexGuard aGuard(getMutexAccess());
803 if (_xSuperClasses.getLength() == 0) {
804 typelib_InterfaceTypeDescription * pType = getTypeDescr();
805 _xSuperClasses.realloc(pType->nBaseTypes);
806 for (sal_Int32 i = 0; i < pType->nBaseTypes; ++i) {
807 _xSuperClasses[i] = getReflection()->forType(
808 &pType->ppBaseTypes[i]->aBase);
809 OSL_ASSERT(_xSuperClasses[i].is())do { if (true && (!(_xSuperClasses[i].is()))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/usr/local/src/libreoffice/stoc/source/corereflection/criface.cxx"
":" "809" ": "), "OSL_ASSERT: %s", "_xSuperClasses[i].is()")
; } } while (false);
810 }
811 }
812 return Sequence< Reference< XIdlClass > >(_xSuperClasses);
813}
814//__________________________________________________________________________________________________
815void InterfaceIdlClassImpl::initMembers()
816{
817 sal_Int32 nAll = getTypeDescr()->nAllMembers;
818 MemberInit * pSortedMemberInit = new MemberInit[nAll];
819 typelib_TypeDescriptionReference ** ppAllMembers = getTypeDescr()->ppAllMembers;
820
821 for ( sal_Int32 nPos = 0; nPos < nAll; ++nPos )
3
←
Loop condition is true. Entering loop body
→
5
←
Loop condition is true. Entering loop body
→
7
←
Loop condition is true. Entering loop body
→
822 {
823 sal_Int32 nIndex;
824 if (ppAllMembers[nPos]->eTypeClass == typelib_TypeClass_INTERFACE_METHOD)
4
←
Taking false branch
→
6
←
Taking false branch
→
8
←
Taking false branch
→
825 {
826 // methods to front
827 nIndex = _nMethods;
828 ++_nMethods;
829 }
830 else
831 {
832 ++_nAttributes;
833 nIndex = (nAll - _nAttributes);
834 // attributes at the back
835 }
836
837 typelib_TypeDescription * pTD = 0;
838 typelib_typedescriptionreference_getDescription( &pTD, ppAllMembers[nPos] );
839 OSL_ENSURE( pTD, "### cannot get type description!" )do { if (true && (!(pTD))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN
), ("legacy.osl"), ("/usr/local/src/libreoffice/stoc/source/corereflection/criface.cxx"
":" "839" ": "), "%s", "### cannot get type description!"); }
} while (false);
840 pSortedMemberInit[nIndex].first = ((typelib_InterfaceMemberTypeDescription *)pTD)->pMemberName;
9
←
Access to field 'pMemberName' results in a dereference of a null pointer (loaded from variable 'pTD')
841 pSortedMemberInit[nIndex].second = pTD;
842 }
843
844 _pSortedMemberInit = pSortedMemberInit;
845}
846//__________________________________________________________________________________________________
847sal_Bool InterfaceIdlClassImpl::isAssignableFrom( const Reference< XIdlClass > & xType )
848 throw(::com::sun::star::uno::RuntimeException)
849{
850 if (xType.is() && xType->getTypeClass() == TypeClass_INTERFACE)
851 {
852 if (equals( xType ))
853 return sal_True((sal_Bool)1);
854 else
855 {
856 const Sequence< Reference< XIdlClass > > & rSeq = xType->getSuperclasses();
857 for (sal_Int32 i = 0; i < rSeq.getLength(); ++i) {
858 if (isAssignableFrom(rSeq[i])) {
859 return true;
860 }
861 }
862 }
863 }
864 return sal_False((sal_Bool)0);
865}
866//__________________________________________________________________________________________________
867Uik InterfaceIdlClassImpl::getUik()
868 throw(::com::sun::star::uno::RuntimeException)
869{
870 return Uik(0, 0, 0, 0, 0);
871 // Uiks are deprecated and this function must not be called
872}
873//__________________________________________________________________________________________________
874Sequence< Reference< XIdlMethod > > InterfaceIdlClassImpl::getMethods()
875 throw(::com::sun::star::uno::RuntimeException)
876{
877 MutexGuard aGuard( getMutexAccess() );
878 if (! _pSortedMemberInit)
879 initMembers();
880
881 // create methods sequence
882 Sequence< Reference< XIdlMethod > > aRet( _nMethods );
883 Reference< XIdlMethod > * pRet = aRet.getArray();
884 for ( sal_Int32 nPos = _nMethods; nPos--; )
885 {
886
887 /*_aName2Method[_pSortedMemberInit[nPos].first] = */pRet[nPos] = new IdlInterfaceMethodImpl(
888 getReflection(), _pSortedMemberInit[nPos].first,
889 _pSortedMemberInit[nPos].second, IdlClassImpl::getTypeDescr() );
890 }
891 return aRet;
892}
893//__________________________________________________________________________________________________
894Sequence< Reference< XIdlField > > InterfaceIdlClassImpl::getFields()
895 throw(::com::sun::star::uno::RuntimeException)
896{
897 MutexGuard aGuard( getMutexAccess() );
898 if (! _pSortedMemberInit)
1
Taking true branch
→
899 initMembers();
2
←
Calling 'initMembers'
→
900
901 // create fields sequence
902 Sequence< Reference< XIdlField > > aRet( _nAttributes );
903 Reference< XIdlField > * pRet = aRet.getArray();
904 for ( sal_Int32 nPos = _nAttributes; nPos--; )
905 {
906 /*_aName2Field[_pSortedMemberInit[_nMethods+nPos].first] = */pRet[_nAttributes-nPos-1] =
907 new IdlAttributeFieldImpl(
908 getReflection(), _pSortedMemberInit[_nMethods+nPos].first,
909 _pSortedMemberInit[_nMethods+nPos].second, IdlClassImpl::getTypeDescr() );
910 }
911 return aRet;
912}
913//__________________________________________________________________________________________________
914Reference< XIdlMethod > InterfaceIdlClassImpl::getMethod( const OUString & rName )
915 throw(::com::sun::star::uno::RuntimeException)
916{
917 MutexGuard aGuard( getMutexAccess() );
918 if (! _pSortedMemberInit)
919 initMembers();
920
921 Reference< XIdlMethod > xRet;
922
923 // try weak map
924 const OUString2Method::const_iterator iFind( _aName2Method.find( rName ) );
925 if (iFind != _aName2Method.end())
926 xRet = (*iFind).second; // harden ref
927
928 if (! xRet.is())
929 {
930 for ( sal_Int32 nPos = _nMethods; nPos--; )
931 {
932 if (_pSortedMemberInit[nPos].first == rName)
933 {
934 _aName2Method[rName] = xRet = new IdlInterfaceMethodImpl(
935 getReflection(), rName,
936 _pSortedMemberInit[nPos].second, IdlClassImpl::getTypeDescr() );
937 break;
938 }
939 }
940 }
941 return xRet;
942}
943//__________________________________________________________________________________________________
944Reference< XIdlField > InterfaceIdlClassImpl::getField( const OUString & rName )
945 throw(::com::sun::star::uno::RuntimeException)
946{
947 MutexGuard aGuard( getMutexAccess() );
948 if (! _pSortedMemberInit)
949 initMembers();
950
951 Reference< XIdlField > xRet;
952
953 // try weak map
954 const OUString2Field::const_iterator iFind( _aName2Field.find( rName ) );
955 if (iFind != _aName2Field.end())
956 xRet = (*iFind).second; // harden ref
957
958 if (! xRet.is())
959 {
960 for ( sal_Int32 nPos = _nAttributes; nPos--; )
961 {
962 if (_pSortedMemberInit[_nMethods+nPos].first == rName)
963 {
964 _aName2Field[rName] = xRet = new IdlAttributeFieldImpl(
965 getReflection(), rName,
966 _pSortedMemberInit[_nMethods+nPos].second, IdlClassImpl::getTypeDescr() );
967 break;
968 }
969 }
970 }
971 return xRet;
972}
973//__________________________________________________________________________________________________
974void InterfaceIdlClassImpl::createObject( Any & rObj )
975 throw(::com::sun::star::uno::RuntimeException)
976{
977 // interfaces cannot be constructed
978 rObj.clear();
979}
980
981}
982
983
984/* vim:set shiftwidth=4 softtabstop=4 expandtab: */