9540af1ece
Unlikely to work yet, but at least builds for the simulator. We can not use dynamic code generation on iOS, so we use a fixed set of code snippets, genertated by a Perl script. Experimentation seems to indicate that a relatively small set of static code snippets should be enough in simple use cases with no extensions (that we can't really support on iOS anyway) and stuff. Except for the static set of snippets the code mostly is, or will be, an ifdefified combination of the gcc3_linux_arm and gcc3_macosx_intel code. The ABI on iOS ARM devices should be quite close to that on Linux ARM, knock on wood.
544 lines
19 KiB
C++
544 lines
19 KiB
C++
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
|
|
/*************************************************************************
|
|
*
|
|
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
|
*
|
|
* Copyright 2000, 2010 Oracle and/or its affiliates.
|
|
*
|
|
* OpenOffice.org - a multi-platform office productivity suite
|
|
*
|
|
* This file is part of OpenOffice.org.
|
|
*
|
|
* OpenOffice.org is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU Lesser General Public License version 3
|
|
* only, as published by the Free Software Foundation.
|
|
*
|
|
* OpenOffice.org is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU Lesser General Public License version 3 for more details
|
|
* (a copy is included in the LICENSE file that accompanied this code).
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public License
|
|
* version 3 along with OpenOffice.org. If not, see
|
|
* <http://www.openoffice.org/license.html>
|
|
* for a copy of the LGPLv3 License.
|
|
*
|
|
************************************************************************/
|
|
|
|
// MARKER(update_precomp.py): autogen include statement, do not remove
|
|
#include "precompiled_bridges.hxx"
|
|
|
|
#include <com/sun/star/uno/genfunc.hxx>
|
|
#include "com/sun/star/uno/RuntimeException.hpp"
|
|
#include "com/sun/star/uno/Sequence.hxx"
|
|
#include <uno/data.h>
|
|
#include <typelib/typedescription.hxx>
|
|
|
|
#include "bridges/cpp_uno/shared/bridge.hxx"
|
|
#include "bridges/cpp_uno/shared/cppinterfaceproxy.hxx"
|
|
#include "bridges/cpp_uno/shared/types.hxx"
|
|
#include "bridges/cpp_uno/shared/vtablefactory.hxx"
|
|
|
|
#include "share.hxx"
|
|
|
|
#include "boost/static_assert.hpp"
|
|
#include <stdio.h>
|
|
|
|
using namespace ::com::sun::star::uno;
|
|
|
|
namespace
|
|
{
|
|
|
|
//==================================================================================================
|
|
void cpp2uno_call(
|
|
bridges::cpp_uno::shared::CppInterfaceProxy * pThis,
|
|
const typelib_TypeDescription * pMemberTypeDescr,
|
|
typelib_TypeDescriptionReference * pReturnTypeRef, // 0 indicates void return
|
|
sal_Int32 nParams, typelib_MethodParameter * pParams,
|
|
void ** pCallStack,
|
|
void * pReturnValue )
|
|
{
|
|
// pCallStack: ret, [return ptr], this, params
|
|
char * pCppStack = (char *)(pCallStack +1);
|
|
|
|
// return
|
|
typelib_TypeDescription * pReturnTypeDescr = 0;
|
|
if (pReturnTypeRef)
|
|
TYPELIB_DANGER_GET( &pReturnTypeDescr, pReturnTypeRef );
|
|
|
|
void * pUnoReturn = 0;
|
|
void * pCppReturn = 0; // complex return ptr: if != 0 && != pUnoReturn, reconversion need
|
|
|
|
if (pReturnTypeDescr)
|
|
{
|
|
// xxx todo: test PolyStructy<STRUCT<long>> foo()
|
|
if (CPPU_CURRENT_NAMESPACE::isSimpleReturnType( pReturnTypeDescr ))
|
|
{
|
|
pUnoReturn = pReturnValue; // direct way for simple types
|
|
}
|
|
else // complex return via ptr (pCppReturn)
|
|
{
|
|
pCppReturn = *(void **)pCppStack;
|
|
pCppStack += sizeof(void *);
|
|
pUnoReturn = (bridges::cpp_uno::shared::relatesToInterfaceType(
|
|
pReturnTypeDescr )
|
|
? alloca( pReturnTypeDescr->nSize )
|
|
: pCppReturn); // direct way
|
|
}
|
|
}
|
|
// pop this
|
|
pCppStack += sizeof( void* );
|
|
|
|
// stack space
|
|
OSL_ENSURE( sizeof(void *) == sizeof(sal_Int32), "### unexpected size!" );
|
|
// parameters
|
|
void ** pUnoArgs = (void **)alloca( 4 * sizeof(void *) * nParams );
|
|
void ** pCppArgs = pUnoArgs + nParams;
|
|
// indizes of values this have to be converted (interface conversion cpp<=>uno)
|
|
sal_Int32 * pTempIndizes = (sal_Int32 *)(pUnoArgs + (2 * nParams));
|
|
// type descriptions for reconversions
|
|
typelib_TypeDescription ** ppTempParamTypeDescr = (typelib_TypeDescription **)(pUnoArgs + (3 * nParams));
|
|
|
|
sal_Int32 nTempIndizes = 0;
|
|
|
|
for ( sal_Int32 nPos = 0; nPos < nParams; ++nPos )
|
|
{
|
|
const typelib_MethodParameter & rParam = pParams[nPos];
|
|
typelib_TypeDescription * pParamTypeDescr = 0;
|
|
TYPELIB_DANGER_GET( &pParamTypeDescr, rParam.pTypeRef );
|
|
|
|
if (!rParam.bOut
|
|
&& bridges::cpp_uno::shared::isSimpleType( pParamTypeDescr ))
|
|
// value
|
|
{
|
|
pCppArgs[nPos] = pCppStack;
|
|
pUnoArgs[nPos] = pCppStack;
|
|
switch (pParamTypeDescr->eTypeClass)
|
|
{
|
|
case typelib_TypeClass_HYPER:
|
|
case typelib_TypeClass_UNSIGNED_HYPER:
|
|
case typelib_TypeClass_DOUBLE:
|
|
pCppStack += sizeof(sal_Int32); // extra long
|
|
default:
|
|
break;
|
|
}
|
|
// no longer needed
|
|
TYPELIB_DANGER_RELEASE( pParamTypeDescr );
|
|
}
|
|
else // ptr to complex value | ref
|
|
{
|
|
pCppArgs[nPos] = *(void **)pCppStack;
|
|
|
|
if (! rParam.bIn) // is pure out
|
|
{
|
|
// uno out is unconstructed mem!
|
|
pUnoArgs[nPos] = alloca( pParamTypeDescr->nSize );
|
|
pTempIndizes[nTempIndizes] = nPos;
|
|
// will be released at reconversion
|
|
ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;
|
|
}
|
|
// is in/inout
|
|
else if (bridges::cpp_uno::shared::relatesToInterfaceType(
|
|
pParamTypeDescr ))
|
|
{
|
|
uno_copyAndConvertData( pUnoArgs[nPos] = alloca( pParamTypeDescr->nSize ),
|
|
*(void **)pCppStack, pParamTypeDescr,
|
|
pThis->getBridge()->getCpp2Uno() );
|
|
pTempIndizes[nTempIndizes] = nPos; // has to be reconverted
|
|
// will be released at reconversion
|
|
ppTempParamTypeDescr[nTempIndizes++] = pParamTypeDescr;
|
|
}
|
|
else // direct way
|
|
{
|
|
pUnoArgs[nPos] = *(void **)pCppStack;
|
|
// no longer needed
|
|
TYPELIB_DANGER_RELEASE( pParamTypeDescr );
|
|
}
|
|
}
|
|
pCppStack += sizeof(sal_Int32); // standard parameter length
|
|
}
|
|
|
|
// ExceptionHolder
|
|
uno_Any aUnoExc; // Any will be constructed by callee
|
|
uno_Any * pUnoExc = &aUnoExc;
|
|
|
|
// invoke uno dispatch call
|
|
(*pThis->getUnoI()->pDispatcher)(
|
|
pThis->getUnoI(), pMemberTypeDescr, pUnoReturn, pUnoArgs, &pUnoExc );
|
|
|
|
// in case an exception occurred...
|
|
if (pUnoExc)
|
|
{
|
|
// destruct temporary in/inout params
|
|
for ( ; nTempIndizes--; )
|
|
{
|
|
sal_Int32 nIndex = pTempIndizes[nTempIndizes];
|
|
|
|
if (pParams[nIndex].bIn) // is in/inout => was constructed
|
|
uno_destructData( pUnoArgs[nIndex], ppTempParamTypeDescr[nTempIndizes], 0 );
|
|
TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndizes] );
|
|
}
|
|
if (pReturnTypeDescr)
|
|
TYPELIB_DANGER_RELEASE( pReturnTypeDescr );
|
|
|
|
CPPU_CURRENT_NAMESPACE::raiseException(
|
|
&aUnoExc, pThis->getBridge()->getUno2Cpp() );
|
|
// has to destruct the any
|
|
}
|
|
else // else no exception occurred...
|
|
{
|
|
// temporary params
|
|
for ( ; nTempIndizes--; )
|
|
{
|
|
sal_Int32 nIndex = pTempIndizes[nTempIndizes];
|
|
typelib_TypeDescription * pParamTypeDescr = ppTempParamTypeDescr[nTempIndizes];
|
|
|
|
if (pParams[nIndex].bOut) // inout/out
|
|
{
|
|
// convert and assign
|
|
uno_destructData( pCppArgs[nIndex], pParamTypeDescr, cpp_release );
|
|
uno_copyAndConvertData( pCppArgs[nIndex], pUnoArgs[nIndex], pParamTypeDescr,
|
|
pThis->getBridge()->getUno2Cpp() );
|
|
}
|
|
// destroy temp uno param
|
|
uno_destructData( pUnoArgs[nIndex], pParamTypeDescr, 0 );
|
|
|
|
TYPELIB_DANGER_RELEASE( pParamTypeDescr );
|
|
}
|
|
// return
|
|
if (pCppReturn) // has complex return
|
|
{
|
|
if (pUnoReturn != pCppReturn) // needs reconversion
|
|
{
|
|
uno_copyAndConvertData( pCppReturn, pUnoReturn, pReturnTypeDescr,
|
|
pThis->getBridge()->getUno2Cpp() );
|
|
// destroy temp uno return
|
|
uno_destructData( pUnoReturn, pReturnTypeDescr, 0 );
|
|
}
|
|
if (pReturnValue != pCppReturn) {
|
|
// complex return ptr is set to eax if return value
|
|
// is not transferred via eax[/edx]:
|
|
*static_cast< void ** >(pReturnValue) = pCppReturn;
|
|
}
|
|
}
|
|
if (pReturnTypeDescr)
|
|
{
|
|
TYPELIB_DANGER_RELEASE( pReturnTypeDescr );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//==================================================================================================
|
|
extern "C" void cpp_vtable_call(
|
|
int nFunctionIndex, int nVtableOffset, void** pCallStack,
|
|
void * pReturnValue )
|
|
{
|
|
OSL_ENSURE( sizeof(sal_Int32)==sizeof(void *), "### unexpected!" );
|
|
|
|
// pCallStack: ret adr, [ret *], this, params
|
|
void * pThis;
|
|
if( nFunctionIndex & 0x80000000 )
|
|
{
|
|
nFunctionIndex &= 0x7fffffff;
|
|
pThis = pCallStack[2];
|
|
}
|
|
else
|
|
{
|
|
pThis = pCallStack[1];
|
|
}
|
|
pThis = static_cast< char * >(pThis) - nVtableOffset;
|
|
bridges::cpp_uno::shared::CppInterfaceProxy * pCppI
|
|
= bridges::cpp_uno::shared::CppInterfaceProxy::castInterfaceToProxy(
|
|
pThis);
|
|
#if OSL_DEBUG_LEVEL > 1
|
|
fprintf( stderr, "%p %p %p pThis=%p, pCppI=%p, function index=%d, vtable offset=%d\n", pCallStack[0], pCallStack[1], pCallStack[2], pThis, pCppI, nFunctionIndex, nVtableOffset );
|
|
#endif
|
|
typelib_InterfaceTypeDescription * pTypeDescr = pCppI->getTypeDescr();
|
|
#if OSL_DEBUG_LEVEL > 1
|
|
fprintf( stderr, "name=%s\n", rtl::OUStringToOString(pTypeDescr->aBase.pTypeName, RTL_TEXTENCODING_UTF8).getStr() );
|
|
#endif
|
|
OSL_ENSURE( nFunctionIndex < pTypeDescr->nMapFunctionIndexToMemberIndex, "### illegal vtable index!" );
|
|
if (nFunctionIndex >= pTypeDescr->nMapFunctionIndexToMemberIndex)
|
|
{
|
|
throw RuntimeException(
|
|
rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "illegal vtable index!" )),
|
|
(XInterface *)pThis );
|
|
}
|
|
|
|
// determine called method
|
|
sal_Int32 nMemberPos = pTypeDescr->pMapFunctionIndexToMemberIndex[nFunctionIndex];
|
|
OSL_ENSURE( nMemberPos < pTypeDescr->nAllMembers, "### illegal member index!" );
|
|
|
|
TypeDescription aMemberDescr( pTypeDescr->ppAllMembers[nMemberPos] );
|
|
#if OSL_DEBUG_LEVEL > 1
|
|
fprintf(stderr, "calling %s\n", rtl::OUStringToOString(aMemberDescr.get()->pTypeName, RTL_TEXTENCODING_UTF8).getStr());
|
|
#endif
|
|
switch (aMemberDescr.get()->eTypeClass)
|
|
{
|
|
case typelib_TypeClass_INTERFACE_ATTRIBUTE:
|
|
{
|
|
if (pTypeDescr->pMapMemberIndexToFunctionIndex[nMemberPos] == nFunctionIndex)
|
|
{
|
|
// is GET method
|
|
cpp2uno_call(
|
|
pCppI, aMemberDescr.get(),
|
|
((typelib_InterfaceAttributeTypeDescription *)aMemberDescr.get())->pAttributeTypeRef,
|
|
0, 0, // no params
|
|
pCallStack, pReturnValue );
|
|
}
|
|
else
|
|
{
|
|
// is SET method
|
|
typelib_MethodParameter aParam;
|
|
aParam.pTypeRef =
|
|
((typelib_InterfaceAttributeTypeDescription *)aMemberDescr.get())->pAttributeTypeRef;
|
|
aParam.bIn = sal_True;
|
|
aParam.bOut = sal_False;
|
|
|
|
cpp2uno_call(
|
|
pCppI, aMemberDescr.get(),
|
|
0, // indicates void return
|
|
1, &aParam,
|
|
pCallStack, pReturnValue );
|
|
}
|
|
break;
|
|
}
|
|
case typelib_TypeClass_INTERFACE_METHOD:
|
|
{
|
|
// is METHOD
|
|
switch (nFunctionIndex)
|
|
{
|
|
case 1: // acquire()
|
|
pCppI->acquireProxy(); // non virtual call!
|
|
break;
|
|
case 2: // release()
|
|
pCppI->releaseProxy(); // non virtual call!
|
|
break;
|
|
case 0: // queryInterface() opt
|
|
{
|
|
typelib_TypeDescription * pTD = 0;
|
|
TYPELIB_DANGER_GET( &pTD, reinterpret_cast< Type * >( pCallStack[3] )->getTypeLibType() );
|
|
if (pTD)
|
|
{
|
|
XInterface * pInterface = 0;
|
|
(*pCppI->getBridge()->getCppEnv()->getRegisteredInterface)(
|
|
pCppI->getBridge()->getCppEnv(),
|
|
(void **)&pInterface, pCppI->getOid().pData,
|
|
(typelib_InterfaceTypeDescription *)pTD );
|
|
|
|
if (pInterface)
|
|
{
|
|
::uno_any_construct(
|
|
reinterpret_cast< uno_Any * >( pCallStack[1] ),
|
|
&pInterface, pTD, cpp_acquire );
|
|
pInterface->release();
|
|
TYPELIB_DANGER_RELEASE( pTD );
|
|
*static_cast< void ** >(pReturnValue) = pCallStack[1];
|
|
break;
|
|
}
|
|
TYPELIB_DANGER_RELEASE( pTD );
|
|
}
|
|
} // else perform queryInterface()
|
|
default:
|
|
cpp2uno_call(
|
|
pCppI, aMemberDescr.get(),
|
|
((typelib_InterfaceMethodTypeDescription *)aMemberDescr.get())->pReturnTypeRef,
|
|
((typelib_InterfaceMethodTypeDescription *)aMemberDescr.get())->nParams,
|
|
((typelib_InterfaceMethodTypeDescription *)aMemberDescr.get())->pParams,
|
|
pCallStack, pReturnValue );
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
throw RuntimeException(
|
|
rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "no member description found!" )),
|
|
(XInterface *)pThis );
|
|
}
|
|
}
|
|
}
|
|
|
|
//==================================================================================================
|
|
|
|
extern "C" {
|
|
extern int nFunIndexes, nVtableOffsets;
|
|
extern unsigned char **codeSnippets;
|
|
}
|
|
|
|
unsigned char * codeSnippet(
|
|
sal_Int32 functionIndex, sal_Int32 vtableOffset,
|
|
#ifdef __arm
|
|
bool bHasHiddenParam
|
|
#else
|
|
typelib_TypeDescriptionReference * pReturnTypeRef
|
|
#endif
|
|
)
|
|
{
|
|
OSL_ASSERT(functionIndex < nFunIndexes);
|
|
if (!(functionIndex < nFunIndexes))
|
|
return NULL;
|
|
|
|
OSL_ASSERT(vtableOffset < nVtableOffsets);
|
|
if (!(vtableOffset < nVtableOffsets))
|
|
return NULL;
|
|
|
|
#ifdef __arm
|
|
return codeSnippets[functionIndex*nVtableOffsets*2 + vtableOffset*2 + bHasHiddenParam];
|
|
#else
|
|
enum { General, Void, Hyper, Float, Double, Class } exec;
|
|
int flag = 0;
|
|
if (pReturnTypeRef == 0) {
|
|
exec = Void;
|
|
}
|
|
else {
|
|
switch (pReturnTypeRef->eTypeClass) {
|
|
case typelib_TypeClass_VOID:
|
|
exec = Void;
|
|
break;
|
|
case typelib_TypeClass_HYPER:
|
|
case typelib_TypeClass_UNSIGNED_HYPER:
|
|
exec = Hyper;
|
|
break;
|
|
case typelib_TypeClass_FLOAT:
|
|
exec = Float;
|
|
break;
|
|
case typelib_TypeClass_DOUBLE:
|
|
exec = Double;
|
|
break;
|
|
case typelib_TypeClass_STRUCT:
|
|
case typelib_TypeClass_EXCEPTION: {
|
|
typelib_TypeDescription * pReturnTypeDescr = 0;
|
|
TYPELIB_DANGER_GET( &pReturnTypeDescr, pReturnTypeRef );
|
|
bool const bSimpleReturnStruct =
|
|
CPPU_CURRENT_NAMESPACE::isSimpleReturnType(pReturnTypeDescr);
|
|
sal_Int32 const nRetSize = pReturnTypeDescr->nSize;
|
|
TYPELIB_DANGER_RELEASE( pReturnTypeDescr );
|
|
if (bSimpleReturnStruct && nRetSize <= 8) {
|
|
exec = General; // fills eax
|
|
if (nRetSize > 4)
|
|
exec = Hyper; // fills eax/edx
|
|
break;
|
|
}
|
|
}
|
|
case typelib_TypeClass_STRING:
|
|
case typelib_TypeClass_TYPE:
|
|
case typelib_TypeClass_SEQUENCE:
|
|
case typelib_TypeClass_INTERFACE:
|
|
case typelib_TypeClass_ANY:
|
|
flag = 1;
|
|
exec = Class;
|
|
break;
|
|
default:
|
|
exec = General;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return codeSnippets[functionIndex*nVtableOffsets*6*2 + vtableOffset*6*2 + exec*2 + flag];
|
|
#endif
|
|
|
|
}
|
|
|
|
}
|
|
|
|
struct bridges::cpp_uno::shared::VtableFactory::Slot { void * fn; };
|
|
|
|
bridges::cpp_uno::shared::VtableFactory::Slot *
|
|
bridges::cpp_uno::shared::VtableFactory::mapBlockToVtable(void * block)
|
|
{
|
|
return static_cast< Slot * >(block) + 2;
|
|
}
|
|
|
|
sal_Size bridges::cpp_uno::shared::VtableFactory::getBlockSize(
|
|
sal_Int32 slotCount)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
bridges::cpp_uno::shared::VtableFactory::Slot *
|
|
bridges::cpp_uno::shared::VtableFactory::initializeBlock(
|
|
void * block, sal_Int32 slotCount)
|
|
{
|
|
Slot * slots = mapBlockToVtable(block);
|
|
slots[-2].fn = 0;
|
|
slots[-1].fn = 0;
|
|
return slots + slotCount;
|
|
}
|
|
|
|
unsigned char * bridges::cpp_uno::shared::VtableFactory::addLocalFunctions(
|
|
Slot ** slots, unsigned char * code,
|
|
typelib_InterfaceTypeDescription const * type, sal_Int32 functionOffset,
|
|
sal_Int32 functionCount, sal_Int32 vtableOffset)
|
|
{
|
|
(*slots) -= functionCount;
|
|
Slot * s = *slots;
|
|
for (sal_Int32 i = 0; i < type->nMembers; ++i) {
|
|
typelib_TypeDescription * member = 0;
|
|
TYPELIB_DANGER_GET(&member, type->ppMembers[i]);
|
|
OSL_ASSERT(member != 0);
|
|
switch (member->eTypeClass) {
|
|
case typelib_TypeClass_INTERFACE_ATTRIBUTE:
|
|
#ifdef __arm
|
|
typelib_InterfaceAttributeTypeDescription *pAttrTD =
|
|
reinterpret_cast<typelib_InterfaceAttributeTypeDescription *>( member );
|
|
#endif
|
|
// Getter:
|
|
(s++)->fn = codeSnippet(
|
|
functionOffset++, vtableOffset,
|
|
#ifdef __arm
|
|
arm::return_in_hidden_param( pAttrTD->pAttributeTypeRef )
|
|
#else
|
|
reinterpret_cast< typelib_InterfaceAttributeTypeDescription * >(
|
|
member)->pAttributeTypeRef
|
|
#endif
|
|
);
|
|
// Setter:
|
|
if (!reinterpret_cast<
|
|
typelib_InterfaceAttributeTypeDescription * >(
|
|
member)->bReadOnly)
|
|
{
|
|
(s++)->fn = codeSnippet(
|
|
functionOffset++, vtableOffset,
|
|
#ifdef __arm
|
|
false
|
|
#else
|
|
0 /* indicates VOID */
|
|
#endif
|
|
);
|
|
}
|
|
break;
|
|
|
|
case typelib_TypeClass_INTERFACE_METHOD:
|
|
#ifdef __arm
|
|
typelib_InterfaceMethodTypeDescription *pMethodTD =
|
|
reinterpret_cast<
|
|
typelib_InterfaceMethodTypeDescription * >(member);
|
|
#endif
|
|
(s++)->fn = codeSnippet(
|
|
functionOffset++, vtableOffset,
|
|
#ifdef __arm
|
|
arm::return_in_hidden_param(pMethodTD->pReturnTypeRef)
|
|
#else
|
|
reinterpret_cast< typelib_InterfaceMethodTypeDescription * >(
|
|
member)->pReturnTypeRef
|
|
#endif
|
|
);
|
|
break;
|
|
|
|
default:
|
|
OSL_ASSERT(false);
|
|
break;
|
|
}
|
|
TYPELIB_DANGER_RELEASE(member);
|
|
}
|
|
return code;
|
|
}
|
|
|
|
void bridges::cpp_uno::shared::VtableFactory::flushCode(
|
|
unsigned char const *, unsigned char const *)
|
|
{}
|
|
|
|
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|