/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
* This file is part of the LibreOffice project.
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*
* This file incorporates work covered by the following license notice:
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed
* with this work for additional information regarding copyright
* ownership. The ASF licenses this file to you under the Apache
* License, Version 2.0 (the "License"); you may not use this file
* except in compliance with the License. You may obtain a copy of
* the License at http://www.apache.org/licenses/LICENSE-2.0 .
*/
#include <sal/config.h>
#include <algorithm>
#include <cassert>
#include <stdarg.h>
#include <osl/mutex.hxx>
#include <osl/interlck.h>
#include <rtl/ustring.hxx>
#include <rtl/ustrbuf.hxx>
#include <rtl/instance.hxx>
#include <typelib/typedescription.h>
#include "typelib.hxx"
using namespace osl;
using ::rtl::OUString;
using ::rtl::OUStringBuffer;
extern "C"
{
#ifdef _WIN32
#pragma pack(push, 8)
#endif
/**
* The double member determines the alignment.
* Under OS2 and MS-Windows the Alignment is min( 8, sizeof( type ) ).
* The alignment of a structure is min( 8, sizeof( max basic type ) ), the greatest basic type
* determines the alignment.
*/
struct AlignSize_Impl
{
sal_Int16 nInt16;
#ifdef AIX
//double: doubleword aligned if -qalign=natural/-malign=natural
//which isn't the default ABI. Otherwise word aligned, While a long long int
//is always doubleword aligned, so use that instead.
sal_Int64 dDouble;
#else
double dDouble;
#endif
};
#ifdef _WIN32
#pragma pack(pop)
#endif
// the value of the maximal alignment
static sal_Int32 nMaxAlignment = static_cast<sal_Int32>( reinterpret_cast<sal_Size>(&reinterpret_cast<AlignSize_Impl *>(16)->dDouble) - 16);
static inline sal_Int32 adjustAlignment( sal_Int32 nRequestedAlignment )
{
if( nRequestedAlignment > nMaxAlignment )
nRequestedAlignment = nMaxAlignment;
return nRequestedAlignment;
}
/**
* Calculate the new size of the struktur.
*/
static inline sal_Int32 newAlignedSize(
sal_Int32 OldSize, sal_Int32 ElementSize, sal_Int32 NeededAlignment )
{
NeededAlignment = adjustAlignment( NeededAlignment );
return (OldSize + NeededAlignment -1) / NeededAlignment * NeededAlignment + ElementSize;
}
namespace
{
struct typelib_StaticInitMutex : public rtl::Static< Mutex, typelib_StaticInitMutex > {};
}
// !for NOT REALLY WEAK TYPES only!
static inline typelib_TypeDescriptionReference * igetTypeByName( rtl_uString const * pTypeName )
{
typelib_TypeDescriptionReference * pRef = nullptr;
::typelib_typedescriptionreference_getByName( &pRef, pTypeName );
if (pRef && pRef->pType && pRef->pType->pWeakRef) // found initialized td
{
return pRef;
}
return nullptr;
}
extern "C"
{
typelib_TypeDescriptionReference ** SAL_CALL typelib_static_type_getByTypeClass(
typelib_TypeClass eTypeClass )
SAL_THROW_EXTERN_C()
{
static typelib_TypeDescriptionReference * s_aTypes[] = {
nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,
nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,
nullptr, nullptr, nullptr };
if (! s_aTypes[eTypeClass])
{
MutexGuard aGuard( typelib_StaticInitMutex::get() );
if (! s_aTypes[eTypeClass])
{
static const char * s_aTypeNames[] = {
"void", "char", "boolean", "byte",
"short", "unsigned short", "long", "unsigned long",
"hyper", "unsigned hyper", "float", "double",
"string", "type", "any" };
switch (eTypeClass)
{
case typelib_TypeClass_EXCEPTION:
case typelib_TypeClass_INTERFACE:
{
// type
if (! s_aTypes[typelib_TypeClass_TYPE])
{
OUString sTypeName("type");
::typelib_typedescriptionreference_new(
&s_aTypes[typelib_TypeClass_TYPE], typelib_TypeClass_TYPE, sTypeName.pData );
// another static ref:
++s_aTypes[typelib_TypeClass_TYPE]->nStaticRefCount;
}
// any
if (! s_aTypes[typelib_TypeClass_ANY])
{
OUString sTypeName("any");
::typelib_typedescriptionreference_new(
&s_aTypes[typelib_TypeClass_ANY], typelib_TypeClass_ANY, sTypeName.pData );
// another static ref:
++s_aTypes[typelib_TypeClass_ANY]->nStaticRefCount;
}
// string
if (! s_aTypes[typelib_TypeClass_STRING])
{
OUString sTypeName("string");
::typelib_typedescriptionreference_new(
&s_aTypes[typelib_TypeClass_STRING], typelib_TypeClass_STRING, sTypeName.pData );
// another static ref:
++s_aTypes[typelib_TypeClass_STRING]->nStaticRefCount;
}
// XInterface
if (! s_aTypes[typelib_TypeClass_INTERFACE])
{
OUString sTypeName("com.sun.star.uno.XInterface");
typelib_InterfaceTypeDescription * pTD = nullptr;
typelib_TypeDescriptionReference * pMembers[3] = { nullptr,nullptr,nullptr };
OUString sMethodName0("com.sun.star.uno.XInterface::queryInterface");
::typelib_typedescriptionreference_new(
&pMembers[0], typelib_TypeClass_INTERFACE_METHOD, sMethodName0.pData );
OUString sMethodName1("com.sun.star.uno.XInterface::acquire");
::typelib_typedescriptionreference_new(
&pMembers[1], typelib_TypeClass_INTERFACE_METHOD, sMethodName1.pData );
OUString sMethodName2("com.sun.star.uno.XInterface::release");
::typelib_typedescriptionreference_new(
&pMembers[2], typelib_TypeClass_INTERFACE_METHOD, sMethodName2.pData );
::typelib_typedescription_newInterface(
&pTD, sTypeName.pData, 0, 0, 0, 0, 0, nullptr, 3, pMembers );
::typelib_typedescription_register( reinterpret_cast<typelib_TypeDescription **>(&pTD) );
::typelib_typedescriptionreference_acquire(
s_aTypes[typelib_TypeClass_INTERFACE] = pTD->aBase.pWeakRef );
// another static ref:
++s_aTypes[typelib_TypeClass_INTERFACE]->nStaticRefCount;
::typelib_typedescription_release( &pTD->aBase );
::typelib_typedescriptionreference_release( pMembers[0] );
::typelib_typedescriptionreference_release( pMembers[1] );
::typelib_typedescriptionreference_release( pMembers[2] );
// Exception
assert( ! s_aTypes[typelib_TypeClass_EXCEPTION] );
{
typelib_TypeDescription * pTD1 = nullptr;
OUString sTypeName1("com.sun.star.uno.Exception");
typelib_CompoundMember_Init aMembers[2];
OUString sMemberType0("string");
OUString sMemberName0("Message");
aMembers[0].eTypeClass = typelib_TypeClass_STRING;
aMembers[0].pTypeName = sMemberType0.pData;
aMembers[0].pMemberName = sMemberName0.pData;
OUString sMemberType1("com.sun.star.uno.XInterface");
OUString sMemberName1("Context");
aMembers[1].eTypeClass = typelib_TypeClass_INTERFACE;
aMembers[1].pTypeName = sMemberType1.pData;
aMembers[1].pMemberName = sMemberName1.pData;
::typelib_typedescription_new(
&pTD1, typelib_TypeClass_EXCEPTION, sTypeName1.pData, nullptr, 2, aMembers );
typelib_typedescription_register( &pTD1 );
typelib_typedescriptionreference_acquire(
s_aTypes[typelib_TypeClass_EXCEPTION] = pTD1->pWeakRef );
// another static ref:
++s_aTypes[typelib_TypeClass_EXCEPTION]->nStaticRefCount;
// RuntimeException
OUString sTypeName2("com.sun.star.uno.RuntimeException");
::typelib_typedescription_new(
&pTD1, typelib_TypeClass_EXCEPTION, sTypeName2.pData, s_aTypes[typelib_TypeClass_EXCEPTION], 0, nullptr );
::typelib_typedescription_register( &pTD1 );
::typelib_typedescription_release( pTD1 );
}
// XInterface members
typelib_InterfaceMethodTypeDescription * pMethod = nullptr;
typelib_Parameter_Init aParameters[1];
OUString sParamName0("aType");
OUString sParamType0("type");
aParameters[0].pParamName = sParamName0.pData;
aParameters[0].eTypeClass = typelib_TypeClass_TYPE;
aParameters[0].pTypeName = sParamType0.pData;
aParameters[0].bIn = true;
aParameters[0].bOut = false;
rtl_uString * pExceptions[1];
OUString sExceptionName0("com.sun.star.uno.RuntimeException");
pExceptions[0] = sExceptionName0.pData;
OUString sReturnType0("any");
typelib_typedescription_newInterfaceMethod(
&pMethod, 0, false, sMethodName0.pData,
typelib_TypeClass_ANY, sReturnType0.pData,
1, aParameters, 1, pExceptions );
::typelib_typedescription_register( reinterpret_cast<typelib_TypeDescription**>(&pMethod) );
OUString sReturnType1("void");
::typelib_typedescription_newInterfaceMethod(
&pMethod, 1, true, sMethodName1.pData,
typelib_TypeClass_VOID, sReturnType1.pData, 0, nullptr, 0, nullptr );
::typelib_typedescription_register( reinterpret_cast<typelib_TypeDescription**>(&pMethod) );
::typelib_typedescription_newInterfaceMethod(
&pMethod, 2, true, sMethodName2.pData,
typelib_TypeClass_VOID, sReturnType1.pData,
0, nullptr, 0, nullptr );
::typelib_typedescription_register( reinterpret_cast<typelib_TypeDescription**>(&pMethod) );
::typelib_typedescription_release( &pMethod->aBase.aBase );
}
break;
}
default:
{
OUString aTypeName( OUString::createFromAscii( s_aTypeNames[eTypeClass] ) );
::typelib_typedescriptionreference_new( &s_aTypes[eTypeClass], eTypeClass, aTypeName.pData );
// another static ref:
++s_aTypes[eTypeClass]->nStaticRefCount;
}
}
}
}
return &s_aTypes[eTypeClass];
}
void SAL_CALL typelib_static_type_init(
typelib_TypeDescriptionReference ** ppRef,
typelib_TypeClass eTypeClass, const sal_Char * pTypeName )
SAL_THROW_EXTERN_C()
{
if (! *ppRef)
{
MutexGuard aGuard( typelib_StaticInitMutex::get() );
if (! *ppRef)
{
OUString aTypeName( OUString::createFromAscii( pTypeName ) );
::typelib_typedescriptionreference_new( ppRef, eTypeClass, aTypeName.pData );
assert(*ppRef && "coverity[var_deref_op] - shouldn't be possible");
++((*ppRef)->nStaticRefCount);
}
}
}
void SAL_CALL typelib_static_sequence_type_init(
typelib_TypeDescriptionReference ** ppRef,
typelib_TypeDescriptionReference * pElementType )
SAL_THROW_EXTERN_C()
{
if (! *ppRef)
{
MutexGuard aGuard( typelib_StaticInitMutex::get() );
if (! *ppRef)
{
OUStringBuffer aBuf( 32 );
aBuf.append( "[]" );
aBuf.append( pElementType->pTypeName );
OUString aTypeName( aBuf.makeStringAndClear() );
assert( ! TYPELIB_TYPEDESCRIPTIONREFERENCE_ISREALLYWEAK(typelib_TypeClass_SEQUENCE) );
*ppRef = igetTypeByName( aTypeName.pData );
if (!*ppRef)
{
typelib_TypeDescription * pReg = nullptr;
::typelib_typedescription_new(
&pReg, typelib_TypeClass_SEQUENCE,
aTypeName.pData, pElementType, 0, nullptr );
::typelib_typedescription_register( &pReg );
*ppRef = reinterpret_cast<typelib_TypeDescriptionReference *>(pReg);
assert( *ppRef == pReg->pWeakRef );
}
// another static ref:
++((*ppRef)->nStaticRefCount);
}
}
}
namespace {
void init(
typelib_TypeDescriptionReference ** ppRef,
typelib_TypeClass eTypeClass, const sal_Char * pTypeName,
typelib_TypeDescriptionReference * pBaseType,
sal_Int32 nMembers, typelib_TypeDescriptionReference ** ppMembers,
sal_Bool const * pParameterizedTypes)
{
assert( eTypeClass == typelib_TypeClass_STRUCT || eTypeClass == typelib_TypeClass_EXCEPTION );
if (! *ppRef)
{
MutexGuard aGuard( typelib_StaticInitMutex::get() );
if (! *ppRef)
{
assert( ! TYPELIB_TYPEDESCRIPTIONREFERENCE_ISREALLYWEAK(eTypeClass) );
OUString aTypeName( OUString::createFromAscii( pTypeName ) );
*ppRef = igetTypeByName( aTypeName.pData );
if (!*ppRef)
{
typelib_CompoundTypeDescription * pComp = nullptr;
::typelib_typedescription_newEmpty(
reinterpret_cast<typelib_TypeDescription **>(&pComp), eTypeClass, aTypeName.pData );
sal_Int32 nOffset = 0;
if (pBaseType)
{
::typelib_typedescriptionreference_getDescription(
reinterpret_cast<typelib_TypeDescription **>(&pComp->pBaseTypeDescription), pBaseType );
assert( pComp->pBaseTypeDescription );
nOffset = pComp->pBaseTypeDescription->aBase.nSize;
assert( newAlignedSize( 0, pComp->pBaseTypeDescription->aBase.nSize, pComp->pBaseTypeDescription->aBase.nAlignment ) == pComp->pBaseTypeDescription->aBase.nSize ); // unexpected offset
}
if (nMembers)
{
pComp->nMembers = nMembers;
pComp->pMemberOffsets = new sal_Int32[ nMembers ];
pComp->ppTypeRefs = new typelib_TypeDescriptionReference *[ nMembers ];
if (pParameterizedTypes != nullptr) {
reinterpret_cast< typelib_StructTypeDescription * >(
pComp)->pParameterizedTypes
= new sal_Bool[nMembers];
}
for ( sal_Int32 i = 0 ; i < nMembers; ++i )
{
::typelib_typedescriptionreference_acquire(
pComp->ppTypeRefs[i] = ppMembers[i] );
// write offset
typelib_TypeDescription * pTD = nullptr;
TYPELIB_DANGER_GET( &pTD, pComp->ppTypeRefs[i] );
assert( pTD->nSize ); // void member?
nOffset = newAlignedSize( nOffset, pTD->nSize, pTD->nAlignment );
pComp->pMemberOffsets[i] = nOffset - pTD->nSize;
TYPELIB_DANGER_RELEASE( pTD );
if (pParameterizedTypes != nullptr) {
reinterpret_cast< typelib_StructTypeDescription * >(
pComp)->pParameterizedTypes[i]
= pParameterizedTypes[i];
}
}
}
typelib_TypeDescription * pReg = &pComp->aBase;
pReg->pWeakRef = reinterpret_cast<typelib_TypeDescriptionReference *>(pReg);
// sizeof(void) not allowed
pReg->nSize = ::typelib_typedescription_getAlignedUnoSize( pReg, 0, pReg->nAlignment );
pReg->nAlignment = adjustAlignment( pReg->nAlignment );
pReg->bComplete = false;
::typelib_typedescription_register( &pReg );
*ppRef = reinterpret_cast<typelib_TypeDescriptionReference *>(pReg);
assert( *ppRef == pReg->pWeakRef );
}
// another static ref:
++((*ppRef)->nStaticRefCount);
}
}
}
}
void SAL_CALL typelib_static_compound_type_init(
typelib_TypeDescriptionReference ** ppRef,
typelib_TypeClass eTypeClass, const sal_Char * pTypeName,
typelib_TypeDescriptionReference * pBaseType,
sal_Int32 nMembers, typelib_TypeDescriptionReference ** ppMembers )
SAL_THROW_EXTERN_C()
{
init(ppRef, eTypeClass, pTypeName, pBaseType, nMembers, ppMembers, nullptr);
}
void SAL_CALL typelib_static_struct_type_init(
typelib_TypeDescriptionReference ** ppRef, const sal_Char * pTypeName,
typelib_TypeDescriptionReference * pBaseType,
sal_Int32 nMembers, typelib_TypeDescriptionReference ** ppMembers,
sal_Bool const * pParameterizedTypes )
SAL_THROW_EXTERN_C()
{
init(
ppRef, typelib_TypeClass_STRUCT, pTypeName, pBaseType, nMembers,
ppMembers, pParameterizedTypes);
}
void SAL_CALL typelib_static_interface_type_init(
typelib_TypeDescriptionReference ** ppRef,
const sal_Char * pTypeName,
typelib_TypeDescriptionReference * pBaseType )
SAL_THROW_EXTERN_C()
{
// coverity[callee_ptr_arith] - not a bug
typelib_static_mi_interface_type_init(
ppRef, pTypeName, pBaseType == nullptr ? 0 : 1, &pBaseType);
}
void SAL_CALL typelib_static_mi_interface_type_init(
typelib_TypeDescriptionReference ** ppRef,
const sal_Char * pTypeName,
sal_Int32 nBaseTypes,
typelib_TypeDescriptionReference ** ppBaseTypes )
SAL_THROW_EXTERN_C()
{
if (! *ppRef)
{
MutexGuard aGuard( typelib_StaticInitMutex::get() );
if (! *ppRef)
{
assert( ! TYPELIB_TYPEDESCRIPTIONREFERENCE_ISREALLYWEAK(typelib_TypeClass_INTERFACE) );
OUString aTypeName( OUString::createFromAscii( pTypeName ) );
*ppRef = igetTypeByName( aTypeName.pData );
if (!*ppRef)
{
typelib_InterfaceTypeDescription * pIface = nullptr;
::typelib_typedescription_newEmpty(
reinterpret_cast<typelib_TypeDescription **>(&pIface), typelib_TypeClass_INTERFACE, aTypeName.pData );
pIface->nBaseTypes = std::max< sal_Int32 >(nBaseTypes, 1);
pIface->ppBaseTypes = new typelib_InterfaceTypeDescription *[
pIface->nBaseTypes];
if (nBaseTypes > 0)
{
for (sal_Int32 i = 0; i < nBaseTypes; ++i) {
pIface->ppBaseTypes[i] = nullptr;
::typelib_typedescriptionreference_getDescription(
reinterpret_cast<typelib_TypeDescription **>(&pIface->ppBaseTypes[i]), ppBaseTypes[i] );
assert( pIface->ppBaseTypes[i] );
}
}
else
{
pIface->ppBaseTypes[0] = nullptr;
::typelib_typedescriptionreference_getDescription(
reinterpret_cast<typelib_TypeDescription **>(&pIface->ppBaseTypes[0]),
* ::typelib_static_type_getByTypeClass( typelib_TypeClass_INTERFACE ) );
assert( pIface->ppBaseTypes[0] );
}
pIface->pBaseTypeDescription = pIface->ppBaseTypes[0];
typelib_typedescription_acquire(
&pIface->pBaseTypeDescription->aBase);
typelib_TypeDescription * pReg = &pIface->aBase;
pReg->pWeakRef = reinterpret_cast<typelib_TypeDescriptionReference *>(pReg);
// sizeof(void) not allowed
pReg->nSize = ::typelib_typedescription_getAlignedUnoSize( pReg, 0, pReg->nAlignment );
pReg->nAlignment = adjustAlignment( pReg->nAlignment );
pReg->bComplete = false;
::typelib_typedescription_register( &pReg );
*ppRef = reinterpret_cast<typelib_TypeDescriptionReference *>(pReg);
assert( *ppRef == pReg->pWeakRef );
}
// another static ref:
++((*ppRef)->nStaticRefCount);
}
}
}
void SAL_CALL typelib_static_enum_type_init(
typelib_TypeDescriptionReference ** ppRef,
const sal_Char * pTypeName,
sal_Int32 nDefaultValue )
SAL_THROW_EXTERN_C()
{
if (! *ppRef)
{
MutexGuard aGuard( typelib_StaticInitMutex::get() );
if (! *ppRef)
{
assert( ! TYPELIB_TYPEDESCRIPTIONREFERENCE_ISREALLYWEAK(typelib_TypeClass_ENUM) );
OUString aTypeName( OUString::createFromAscii( pTypeName ) );
*ppRef = igetTypeByName( aTypeName.pData );
if (!*ppRef)
{
typelib_TypeDescription * pReg = nullptr;
::typelib_typedescription_newEmpty(
&pReg, typelib_TypeClass_ENUM, aTypeName.pData );
typelib_EnumTypeDescription * pEnum = reinterpret_cast<typelib_EnumTypeDescription *>(pReg);
pEnum->nDefaultEnumValue = nDefaultValue;
pReg->pWeakRef = reinterpret_cast<typelib_TypeDescriptionReference *>(pReg);
// sizeof(void) not allowed
pReg->nSize = ::typelib_typedescription_getAlignedUnoSize( pReg, 0, pReg->nAlignment );
pReg->nAlignment = ::adjustAlignment( pReg->nAlignment );
pReg->bComplete = false;
::typelib_typedescription_register( &pReg );
*ppRef = reinterpret_cast<typelib_TypeDescriptionReference *>(pReg);
assert( *ppRef == pReg->pWeakRef );
}
// another static ref:
++((*ppRef)->nStaticRefCount);
}
}
}
} // extern "C"
}
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
↑ V547 Expression '!s_aTypes[eTypeClass]' is always true.