strepsirrhini/office-gobmx
9
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
office-gobmx/pyuno/source/module/pyuno.cxx
Noel Grandin 79f4f724b9 loplugin:ostr in pyuno 
Change-Id: I54555110b5c66ea92f2675edc50dccd252558e28
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/167435
Reviewed-by: Noel Grandin <noel.grandin@collabora.co.uk>
Tested-by: Jenkins
2024-05-10 13:16:45 +02:00

1729 lines
54 KiB
C++
Raw Blame History

/* -*- 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 <rtl/ustrbuf.hxx>
#include <typelib/typedescription.hxx>
#include <com/sun/star/lang/XServiceInfo.hpp>
#include <com/sun/star/lang/XTypeProvider.hpp>
#include <com/sun/star/beans/UnknownPropertyException.hpp>
#include <com/sun/star/container/XEnumerationAccess.hpp>
#include <com/sun/star/container/XIndexAccess.hpp>
#include <com/sun/star/container/XIndexContainer.hpp>
#include <com/sun/star/container/XIndexReplace.hpp>
#include <com/sun/star/container/XNameAccess.hpp>
#include <com/sun/star/container/XNameContainer.hpp>
#include <com/sun/star/container/XNameReplace.hpp>
#include <com/sun/star/script/CannotConvertException.hpp>
#include <com/sun/star/script/XInvocation2.hpp>
#include <com/sun/star/script/XTypeConverter.hpp>
#include <com/sun/star/lang/XSingleServiceFactory.hpp>
#include <comphelper/servicehelper.hxx>
#include "pyuno_impl.hxx"
using com::sun::star::uno::Sequence;
using com::sun::star::uno::Reference;
using com::sun::star::uno::XInterface;
using com::sun::star::uno::Any;
using com::sun::star::uno::UNO_QUERY;
using com::sun::star::uno::Type;
using com::sun::star::uno::TypeClass;
using com::sun::star::uno::TypeDescription;
using com::sun::star::uno::RuntimeException;
using com::sun::star::uno::Exception;
using com::sun::star::lang::XSingleServiceFactory;
using com::sun::star::lang::XServiceInfo;
using com::sun::star::lang::XTypeProvider;
using com::sun::star::lang::XUnoTunnel;
using com::sun::star::script::XInvocation2;
using com::sun::star::container::XEnumeration;
using com::sun::star::container::XEnumerationAccess;
using com::sun::star::container::XIndexAccess;
using com::sun::star::container::XIndexContainer;
using com::sun::star::container::XIndexReplace;
using com::sun::star::container::XNameAccess;
using com::sun::star::container::XNameContainer;
using com::sun::star::container::XNameReplace;
namespace pyuno
{
static PyObject *PyUNO_str( PyObject * self );
static void PyUNO_del (PyObject* self)
{
PyUNO* me = reinterpret_cast< PyUNO* > (self);
{
PyThreadDetach antiguard;
delete me->members;
}
PyObject_Del (self);
}
OUString val2str( const void * pVal, typelib_TypeDescriptionReference * pTypeRef , sal_Int32 mode )
{
assert( pVal );
if (pTypeRef->eTypeClass == typelib_TypeClass_VOID)
return u"void"_ustr;
OUStringBuffer buf( 64 );
buf.append( "(" + OUString::unacquired(&pTypeRef->pTypeName) + ")" );
switch (pTypeRef->eTypeClass)
{
case typelib_TypeClass_INTERFACE:
{
buf.append( "0x" +
OUString::number( reinterpret_cast< sal_IntPtr >(*static_cast<void * const *>(pVal)), 16 ));
if( VAL2STR_MODE_DEEP == mode )
{
buf.append( "{" ); Reference< XInterface > r = *static_cast<Reference< XInterface > const *>(pVal);
Reference< XServiceInfo > serviceInfo( r, UNO_QUERY);
Reference< XTypeProvider > typeProvider(r,UNO_QUERY);
if( serviceInfo.is() )
{
buf.append("implementationName="
+ serviceInfo->getImplementationName()
+ ", supportedServices={" );
Sequence< OUString > seq = serviceInfo->getSupportedServiceNames();
for( int i = 0 ; i < seq.getLength() ; i ++ )
{
buf.append( seq[i] );
if( i +1 != seq.getLength() )
buf.append( "," );
}
buf.append("}");
}
if( typeProvider.is() )
{
buf.append(", supportedInterfaces={" );
Sequence< Type > seq (typeProvider->getTypes());
for( int i = 0 ; i < seq.getLength() ; i ++ )
{
buf.append(seq[i].getTypeName());
if( i +1 != seq.getLength() )
buf.append( "," );
}
buf.append("}");
}
buf.append( "}" );
}
break;
}
case typelib_TypeClass_STRUCT:
case typelib_TypeClass_EXCEPTION:
{
buf.append( "{ " );
typelib_TypeDescription * pTypeDescr = nullptr;
TYPELIB_DANGER_GET( &pTypeDescr, pTypeRef );
assert( pTypeDescr );
typelib_CompoundTypeDescription * pCompType = reinterpret_cast<typelib_CompoundTypeDescription *>(pTypeDescr);
sal_Int32 nDescr = pCompType->nMembers;
if (pCompType->pBaseTypeDescription)
{
buf.append( val2str( pVal, pCompType->pBaseTypeDescription->aBase.pWeakRef, mode ) );
if (nDescr)
buf.append( ", " );
}
typelib_TypeDescriptionReference ** ppTypeRefs = pCompType->ppTypeRefs;
sal_Int32 * pMemberOffsets = pCompType->pMemberOffsets;
rtl_uString ** ppMemberNames = pCompType->ppMemberNames;
for ( sal_Int32 nPos = 0; nPos < nDescr; ++nPos )
{
buf.append( OUString::unacquired(&ppMemberNames[nPos]) + " = " );
typelib_TypeDescription * pMemberType = nullptr;
TYPELIB_DANGER_GET( &pMemberType, ppTypeRefs[nPos] );
buf.append( val2str( static_cast<char const *>(pVal) + pMemberOffsets[nPos], pMemberType->pWeakRef, mode ) );
TYPELIB_DANGER_RELEASE( pMemberType );
if (nPos < (nDescr -1))
buf.append( ", " );
}
TYPELIB_DANGER_RELEASE( pTypeDescr );
buf.append( " }" );
break;
}
case typelib_TypeClass_SEQUENCE:
{
typelib_TypeDescription * pTypeDescr = nullptr;
TYPELIB_DANGER_GET( &pTypeDescr, pTypeRef );
uno_Sequence * pSequence = *static_cast<uno_Sequence * const *>(pVal);
typelib_TypeDescription * pElementTypeDescr = nullptr;
TYPELIB_DANGER_GET( &pElementTypeDescr, reinterpret_cast<typelib_IndirectTypeDescription *>(pTypeDescr)->pType );
sal_Int32 nElementSize = pElementTypeDescr->nSize;
sal_Int32 nElements = pSequence->nElements;
if (nElements)
{
buf.append( "{ " );
char * pElements = pSequence->elements;
for ( sal_Int32 nPos = 0; nPos < nElements; ++nPos )
{
buf.append( val2str( pElements + (nElementSize * nPos), pElementTypeDescr->pWeakRef, mode ) );
if (nPos < (nElements -1))
buf.append( ", " );
}
buf.append( " }" );
}
else
{
buf.append( "{}" );
}
TYPELIB_DANGER_RELEASE( pElementTypeDescr );
TYPELIB_DANGER_RELEASE( pTypeDescr );
break;
}
case typelib_TypeClass_ANY:
buf.append( "{ "
+ val2str( static_cast<uno_Any const *>(pVal)->pData,
static_cast<uno_Any const *>(pVal)->pType ,
mode)
+ " }" );
break;
case typelib_TypeClass_TYPE:
buf.append( (*static_cast<typelib_TypeDescriptionReference * const *>(pVal))->pTypeName );
break;
case typelib_TypeClass_STRING:
buf.append( "\"" +
OUString::unacquired(&*static_cast<rtl_uString * const *>(pVal)) +
"\"" );
break;
case typelib_TypeClass_ENUM:
{
typelib_TypeDescription * pTypeDescr = nullptr;
TYPELIB_DANGER_GET( &pTypeDescr, pTypeRef );
sal_Int32 * pValues = reinterpret_cast<typelib_EnumTypeDescription *>(pTypeDescr)->pEnumValues;
sal_Int32 nPos = reinterpret_cast<typelib_EnumTypeDescription *>(pTypeDescr)->nEnumValues;
while (nPos--)
{
if (pValues[nPos] == *static_cast<int const *>(pVal))
break;
}
if (nPos >= 0)
buf.append( reinterpret_cast<typelib_EnumTypeDescription *>(pTypeDescr)->ppEnumNames[nPos] );
else
buf.append( '?' );
TYPELIB_DANGER_RELEASE( pTypeDescr );
break;
}
case typelib_TypeClass_BOOLEAN:
if (*static_cast<sal_Bool const *>(pVal))
buf.append( "true" );
else
buf.append( "false" );
break;
case typelib_TypeClass_CHAR:
buf.append( "\'"
+ OUStringChar(*static_cast<sal_Unicode const *>(pVal) )
+ "\'" );
break;
case typelib_TypeClass_FLOAT:
buf.append( *static_cast<float const *>(pVal) );
break;
case typelib_TypeClass_DOUBLE:
buf.append( *static_cast<double const *>(pVal) );
break;
case typelib_TypeClass_BYTE:
buf.append( "0x" +
OUString::number( static_cast<sal_Int32>(*static_cast<sal_Int8 const *>(pVal)), 16 ));
break;
case typelib_TypeClass_SHORT:
buf.append( "0x" +
OUString::number( static_cast<sal_Int32>(*static_cast<sal_Int16 const *>(pVal)), 16 ));
break;
case typelib_TypeClass_UNSIGNED_SHORT:
buf.append( "0x" +
OUString::number( static_cast<sal_Int32>(*static_cast<sal_uInt16 const *>(pVal)), 16 ));
break;
case typelib_TypeClass_LONG:
buf.append( "0x" +
OUString::number( *static_cast<sal_Int32 const *>(pVal), 16 ));
break;
case typelib_TypeClass_UNSIGNED_LONG:
buf.append( "0x" +
OUString::number( static_cast<sal_Int64>(*static_cast<sal_uInt32 const *>(pVal)), 16 ));
break;
case typelib_TypeClass_HYPER:
case typelib_TypeClass_UNSIGNED_HYPER:
buf.append( "0x" );
#if defined(__GNUC__) && defined(SPARC)
// I guess this really should check if there are strict alignment
// requirements, not just "GCC on SPARC".
{
sal_Int64 aVal;
*(sal_Int32 *)&aVal = *(sal_Int32 *)pVal;
*((sal_Int32 *)&aVal +1)= *((sal_Int32 *)pVal +1);
buf.append( aVal, 16 );
}
#else
buf.append( *static_cast<sal_Int64 const *>(pVal), 16 );
#endif
break;
case typelib_TypeClass_VOID:
case typelib_TypeClass_UNKNOWN:
case typelib_TypeClass_SERVICE:
case typelib_TypeClass_MODULE:
default:
buf.append( '?' );
}
return buf.makeStringAndClear();
}
static sal_Int32 lcl_PyNumber_AsSal_Int32( PyObject *pObj )
{
// Check object is an index
PyRef rIndex( PyNumber_Index( pObj ), SAL_NO_ACQUIRE );
if ( !rIndex.is() )
return -1;
// Convert Python number to platform long, then check actual value against
// bounds of sal_Int32
int nOverflow;
long nResult = PyLong_AsLongAndOverflow( pObj, &nOverflow );
if ( nOverflow || nResult > SAL_MAX_INT32 || nResult < SAL_MIN_INT32) {
PyErr_SetString( PyExc_IndexError, "Python int too large to convert to UNO long" );
return -1;
}
return nResult;
}
static int lcl_PySlice_GetIndicesEx( PyObject *pObject, sal_Int32 nLen, sal_Int32 *nStart, sal_Int32 *nStop, sal_Int32 *nStep, sal_Int32 *nSliceLength )
{
Py_ssize_t nStart_ssize, nStop_ssize, nStep_ssize, nSliceLength_ssize;
int nResult = PySlice_GetIndicesEx(pObject,
nLen, &nStart_ssize, &nStop_ssize, &nStep_ssize, &nSliceLength_ssize );
if (nResult == -1)
return -1;
if ( nStart_ssize > SAL_MAX_INT32 || nStart_ssize < SAL_MIN_INT32
|| nStop_ssize > SAL_MAX_INT32 || nStop_ssize < SAL_MIN_INT32
|| nStep_ssize > SAL_MAX_INT32 || nStep_ssize < SAL_MIN_INT32
|| nSliceLength_ssize > SAL_MAX_INT32 || nSliceLength_ssize < SAL_MIN_INT32 )
{
PyErr_SetString( PyExc_IndexError, "Python int too large to convert to UNO long" );
return -1;
}
*nStart = static_cast<sal_Int32>(nStart_ssize);
*nStop = static_cast<sal_Int32>(nStop_ssize);
*nStep = static_cast<sal_Int32>(nStep_ssize);
*nSliceLength = static_cast<sal_Int32>(nSliceLength_ssize);
return 0;
}
static bool lcl_hasInterfaceByName( Any const &object, OUString const & interfaceName )
{
Reference< XInterface > xInterface( object, UNO_QUERY );
TypeDescription typeDesc( interfaceName );
Any aInterface = xInterface->queryInterface( typeDesc.get()->pWeakRef );
return aInterface.hasValue();
}
static PyObject *PyUNO_repr( PyObject * self )
{
return PyUNO_str( self );
}
static Py_hash_t PyUNO_hash( PyObject *self )
{
PyUNO *me = reinterpret_cast<PyUNO *>(self);
// Py_hash_t is not necessarily the same size as a pointer, but this is not
// important for hashing - it just has to return the same value each time
return sal::static_int_cast< Py_hash_t >( reinterpret_cast< sal_IntPtr > (
*static_cast<void * const *>(me->members->wrappedObject.getValue()) ) );
}
PyObject *PyUNO_invoke( PyObject *object, const char *name , PyObject *args )
{
PyRef ret;
try
{
Runtime runtime;
PyRef paras,callable;
if( PyObject_IsInstance( object, getPyUnoClass().get() ) )
{
PyUNO* me = reinterpret_cast<PyUNO*>(object);
OUString attrName = OUString::createFromAscii(name);
if (! me->members->xInvocation->hasMethod (attrName))
{
throw RuntimeException( "Attribute " + attrName + " unknown" );
}
callable = PyUNO_callable_new (
me->members->xInvocation,
attrName,
ACCEPT_UNO_ANY);
paras = args;
}
else
{
// clean the tuple from uno.Any !
int size = PyTuple_Size( args );
{ // for CC, keeping ref-count of tuple being 1
paras = PyRef(PyTuple_New( size ), SAL_NO_ACQUIRE);
}
for( int i = 0 ; i < size ;i ++ )
{
PyObject * element = PyTuple_GetItem( args , i );
if( PyObject_IsInstance( element , getAnyClass( runtime ).get() ) )
{
element = PyObject_GetAttrString(
element, "value" );
}
else
{
Py_XINCREF( element );
}
PyTuple_SetItem( paras.get(), i , element );
}
callable = PyRef( PyObject_GetAttrString( object , name ), SAL_NO_ACQUIRE );
if( !callable.is() )
return nullptr;
}
ret = PyRef( PyObject_CallObject( callable.get(), paras.get() ), SAL_NO_ACQUIRE );
}
catch (const css::lang::IllegalArgumentException &e)
{
raisePyExceptionWithAny( css::uno::Any( e ) );
}
catch (const css::script::CannotConvertException &e)
{
raisePyExceptionWithAny( css::uno::Any( e ) );
}
catch (const css::uno::RuntimeException &e)
{
raisePyExceptionWithAny( css::uno::Any( e ) );
}
catch (const css::uno::Exception &e)
{
raisePyExceptionWithAny( css::uno::Any( e ) );
}
return ret.getAcquired();
}
PyObject *PyUNO_str( PyObject * self )
{
PyUNO *me = reinterpret_cast<PyUNO *>(self);
OString buf;
{
PyThreadDetach antiguard;
OUString s = val2str( me->members->wrappedObject.getValue(),
me->members->wrappedObject.getValueType().getTypeLibType() );
buf = "pyuno object " + OUStringToOString(s,RTL_TEXTENCODING_ASCII_US);
}
return PyUnicode_FromString( buf.getStr() );
}
static PyObject* PyUNO_dir (PyObject* self)
{
PyUNO* me = reinterpret_cast<PyUNO*>(self);
PyObject* member_list = nullptr;
Sequence<OUString> oo_member_list;
try
{
oo_member_list = me->members->xInvocation->getMemberNames ();
member_list = PyList_New (oo_member_list.getLength ());
for (int i = 0; i < oo_member_list.getLength (); i++)
{
// setitem steals a reference
PyList_SetItem (member_list, i, ustring2PyString(oo_member_list[i]).getAcquired() );
}
}
catch( const RuntimeException &e )
{
raisePyExceptionWithAny( Any(e) );
}
return member_list;
}
static sal_Int32 lcl_detach_getLength( PyUNO const *me )
{
PyThreadDetach antiguard;
// If both XIndexContainer and XNameContainer are implemented, it is
// assumed that getCount() gives the same result as the number of names
// returned by getElementNames(), or the user may be surprised.
// For XIndexContainer
Reference< XIndexAccess > xIndexAccess( me->members->xInvocation, UNO_QUERY );
if ( xIndexAccess.is() )
{
return xIndexAccess->getCount();
}
// For XNameContainer
// Not terribly efficient - get the count of all the names
Reference< XNameAccess > xNameAccess( me->members->xInvocation, UNO_QUERY );
if ( xNameAccess.is() )
{
return xNameAccess->getElementNames().getLength();
}
return -1;
}
static int PyUNO_bool( PyObject* self )
{
PyUNO* me = reinterpret_cast<PyUNO*>(self);
try
{
int nLen = lcl_detach_getLength( me );
if (nLen >= 0)
return nLen == 0 ? 0 : 1;
// Anything which doesn't have members is a scalar object and therefore true
return 1;
}
catch( const css::uno::RuntimeException &e )
{
raisePyExceptionWithAny( css::uno::Any( e ) );
}
return -1;
}
static Py_ssize_t PyUNO_len( PyObject* self )
{
PyUNO* me = reinterpret_cast<PyUNO*>(self);
try
{
int nLen = lcl_detach_getLength( me );
if (nLen >= 0)
return nLen;
PyErr_SetString( PyExc_TypeError, "object has no len()" );
}
catch( const css::uno::RuntimeException &e )
{
raisePyExceptionWithAny( css::uno::Any( e ) );
}
return -1;
}
static void lcl_getRowsColumns( PyUNO const * me, sal_Int32& nRows, sal_Int32& nColumns )
{
Sequence<short> aOutParamIndex;
Sequence<Any> aOutParam;
Sequence<Any> aParams;
Any aRet = me->members->xInvocation->invoke ( u"getRows"_ustr, aParams, aOutParamIndex, aOutParam );
Reference< XIndexAccess > xIndexAccessRows( aRet, UNO_QUERY );
nRows = xIndexAccessRows->getCount();
aRet = me->members->xInvocation->invoke ( u"getColumns"_ustr, aParams, aOutParamIndex, aOutParam );
Reference< XIndexAccess > xIndexAccessCols( aRet, UNO_QUERY );
nColumns = xIndexAccessCols->getCount();
}
static PyRef lcl_indexToSlice( const PyRef& rIndex )
{
Py_ssize_t nIndex = PyNumber_AsSsize_t( rIndex.get(), PyExc_IndexError );
if (nIndex == -1 && PyErr_Occurred())
return nullptr;
PyRef rStart( PyLong_FromSsize_t( nIndex ), SAL_NO_ACQUIRE );
PyRef rStop( PyLong_FromSsize_t( nIndex+1 ), SAL_NO_ACQUIRE );
PyRef rStep( PyLong_FromLong( 1 ), SAL_NO_ACQUIRE );
PyRef rSlice( PySlice_New( rStart.get(), rStop.get(), rStep.get() ), SAL_NO_ACQUIRE );
return rSlice;
}
static PyObject* lcl_getitem_XCellRange( PyUNO const * me, PyObject* pKey )
{
Runtime runtime;
Sequence<short> aOutParamIndex;
Sequence<Any> aOutParam;
Sequence<Any> aParams;
Any aRet;
// Single string key is sugar for getCellRangeByName()
if ( PyUnicode_Check( pKey ) ) {
aParams = { Any(pyString2ustring( pKey )) };
{
PyThreadDetach antiguard;
aRet = me->members->xInvocation->invoke (
u"getCellRangeByName"_ustr, aParams, aOutParamIndex, aOutParam );
}
PyRef rRet = runtime.any2PyObject ( aRet );
return rRet.getAcquired();
}
PyRef rKey0, rKey1;
if ( PyIndex_Check( pKey ) )
{
// [0] is equivalent to [0,:]
rKey0 = pKey;
rKey1 = PySlice_New( nullptr, nullptr, nullptr );
}
else if ( PyTuple_Check( pKey ) && (PyTuple_Size( pKey ) == 2) )
{
rKey0 = PyTuple_GetItem( pKey, 0 );
rKey1 = PyTuple_GetItem( pKey, 1 );
}
else
{
PyErr_SetString( PyExc_KeyError, "invalid subscript" );
return nullptr;
}
// If both keys are indices, return the corresponding cell
if ( PyIndex_Check( rKey0.get() ) && PyIndex_Check( rKey1.get() ))
{
sal_Int32 nKey0_s = lcl_PyNumber_AsSal_Int32( rKey0.get() );
sal_Int32 nKey1_s = lcl_PyNumber_AsSal_Int32( rKey1.get() );
if ( ((nKey0_s == -1) || (nKey1_s == -1)) && PyErr_Occurred() )
return nullptr;
aParams = { Any(nKey1_s), Any(nKey0_s) };
{
PyThreadDetach antiguard;
aRet = me->members->xInvocation->invoke (
u"getCellByPosition"_ustr, aParams, aOutParamIndex, aOutParam );
}
PyRef rRet = runtime.any2PyObject( aRet );
return rRet.getAcquired();
}
// If either argument is an index, coerce it to a slice
if ( PyIndex_Check( rKey0.get() ) )
rKey0 = lcl_indexToSlice( rKey0 );
if ( PyIndex_Check( rKey1.get() ) )
rKey1 = lcl_indexToSlice( rKey1 );
// If both arguments are slices, return the corresponding cell range
if ( PySlice_Check( rKey0.get() ) && PySlice_Check( rKey1.get() ) )
{
sal_Int32 nLen0 = SAL_MAX_INT32, nLen1 = SAL_MAX_INT32;
sal_Int32 nStart0 = 0, nStop0 = 0, nStep0 = 0, nSliceLength0 = 0;
sal_Int32 nStart1 = 0, nStop1 = 0, nStep1 = 0, nSliceLength1 = 0;
{
PyThreadDetach antiguard;
if ( lcl_hasInterfaceByName( me->members->wrappedObject, u"com.sun.star.table.XColumnRowRange"_ustr ) )
{
lcl_getRowsColumns (me, nLen0, nLen1);
}
}
int nSuccess1 = lcl_PySlice_GetIndicesEx( rKey0.get(), nLen0, &nStart0, &nStop0, &nStep0, &nSliceLength0 );
int nSuccess2 = lcl_PySlice_GetIndicesEx( rKey1.get(), nLen1, &nStart1, &nStop1, &nStep1, &nSliceLength1 );
if ( ((nSuccess1 == -1) || (nSuccess2 == -1)) && PyErr_Occurred() )
return nullptr;
if ( nSliceLength0 <= 0 || nSliceLength1 <= 0 )
{
PyErr_SetString( PyExc_KeyError, "invalid number of rows or columns" );
return nullptr;
}
if ( nStep0 == 1 && nStep1 == 1 )
{
aParams = { Any(nStart1), Any(nStart0), Any(nStop1 - 1), Any(nStop0 - 1) };
{
PyThreadDetach antiguard;
aRet = me->members->xInvocation->invoke (
u"getCellRangeByPosition"_ustr, aParams, aOutParamIndex, aOutParam );
}
PyRef rRet = runtime.any2PyObject( aRet );
return rRet.getAcquired();
}
PyErr_SetString( PyExc_KeyError, "step != 1 not supported" );
return nullptr;
}
PyErr_SetString( PyExc_KeyError, "invalid subscript" );
return nullptr;
}
static PyObject* lcl_getitem_index( PyUNO const *me, PyObject *pKey, Runtime const & runtime )
{
Any aRet;
sal_Int32 nIndex;
nIndex = lcl_PyNumber_AsSal_Int32( pKey );
if (nIndex == -1 && PyErr_Occurred())
return nullptr;
{
PyThreadDetach antiguard;
Reference< XIndexAccess > xIndexAccess( me->members->xInvocation, UNO_QUERY );
if ( xIndexAccess.is() )
{
if (nIndex < 0)
nIndex += xIndexAccess->getCount();
aRet = xIndexAccess->getByIndex( nIndex );
}
}
if ( aRet.hasValue() )
{
PyRef rRet ( runtime.any2PyObject( aRet ) );
return rRet.getAcquired();
}
return nullptr;
}
static PyObject* lcl_getitem_slice( PyUNO const *me, PyObject *pKey )
{
Runtime runtime;
Reference< XIndexAccess > xIndexAccess;
sal_Int32 nLen = 0;
{
PyThreadDetach antiguard;
xIndexAccess.set( me->members->xInvocation, UNO_QUERY );
if ( xIndexAccess.is() )
nLen = xIndexAccess->getCount();
}
if ( !xIndexAccess )
return nullptr;
sal_Int32 nStart = 0, nStop = 0, nStep = 0, nSliceLength = 0;
int nSuccess = lcl_PySlice_GetIndicesEx(pKey, nLen, &nStart, &nStop, &nStep, &nSliceLength);
if ( nSuccess == -1 && PyErr_Occurred() )
return nullptr;
PyRef rTuple( PyTuple_New( nSliceLength ), SAL_NO_ACQUIRE, NOT_NULL );
sal_Int32 nCur, i;
for ( nCur = nStart, i = 0; i < nSliceLength; nCur += nStep, i++ )
{
Any aRet;
{
PyThreadDetach antiguard;
aRet = xIndexAccess->getByIndex( nCur );
}
PyRef rRet = runtime.any2PyObject( aRet );
PyTuple_SetItem( rTuple.get(), i, rRet.getAcquired() );
}
return rTuple.getAcquired();
}
static PyObject* lcl_getitem_string( PyUNO const *me, PyObject *pKey, Runtime const & runtime )
{
OUString sKey = pyString2ustring( pKey );
Any aRet;
{
PyThreadDetach antiguard;
Reference< XNameAccess > xNameAccess( me->members->xInvocation, UNO_QUERY );
if ( xNameAccess.is() )
{
aRet = xNameAccess->getByName( sKey );
}
}
if ( aRet.hasValue() )
{
PyRef rRet = runtime.any2PyObject( aRet );
return rRet.getAcquired();
}
return nullptr;
}
static PyObject* PyUNO_getitem( PyObject *self, PyObject *pKey )
{
PyUNO* me = reinterpret_cast<PyUNO*>(self);
Runtime runtime;
try
{
// XIndexAccess access by index
if ( PyIndex_Check( pKey ) )
{
PyObject* pRet = lcl_getitem_index( me, pKey, runtime );
if ( pRet != nullptr || PyErr_Occurred() )
return pRet;
}
// XIndexAccess access by slice
if ( PySlice_Check( pKey ) )
{
PyObject* pRet = lcl_getitem_slice( me, pKey );
if ( pRet != nullptr || PyErr_Occurred() )
return pRet;
}
// XNameAccess access by key
if ( PyUnicode_Check( pKey ) )
{
PyObject* pRet = lcl_getitem_string( me, pKey, runtime );
if ( pRet != nullptr )
return pRet;
}
// XCellRange/XColumnRowRange specialisation
// Uses reflection as we can't have a hard dependency on XCellRange here
bool hasXCellRange = false;
{
PyThreadDetach antiguard;
hasXCellRange = lcl_hasInterfaceByName( me->members->wrappedObject, u"com.sun.star.table.XCellRange"_ustr );
}
if ( hasXCellRange )
{
return lcl_getitem_XCellRange( me, pKey );
}
// If the object is an XIndexAccess and/or XNameAccess, but the
// key passed wasn't suitable, give a TypeError which specifically
// describes this
Reference< XIndexAccess > xIndexAccess( me->members->xInvocation, UNO_QUERY );
Reference< XNameAccess > xNameAccess( me->members->xInvocation, UNO_QUERY );
if ( xIndexAccess.is() || xNameAccess.is() )
{
PyErr_SetString( PyExc_TypeError, "subscription with invalid type" );
return nullptr;
}
PyErr_SetString( PyExc_TypeError, "object is not subscriptable" );
}
catch( const css::lang::IndexOutOfBoundsException & )
{
PyErr_SetString( PyExc_IndexError, "index out of range" );
}
catch( const css::container::NoSuchElementException & )
{
PyErr_SetString( PyExc_KeyError, "key not found" );
}
catch( const css::script::CannotConvertException &e )
{
raisePyExceptionWithAny( css::uno::Any( e ) );
}
catch( const css::lang::IllegalArgumentException &e )
{
raisePyExceptionWithAny( css::uno::Any( e ) );
}
catch( const css::lang::WrappedTargetException &e )
{
raisePyExceptionWithAny( css::uno::Any( e ) );
}
catch( const css::uno::RuntimeException &e )
{
raisePyExceptionWithAny( css::uno::Any( e ) );
}
return nullptr;
}
static int lcl_setitem_index( PyUNO const *me, PyObject *pKey, PyObject *pValue )
{
Runtime runtime;
Reference< XIndexContainer > xIndexContainer;
Reference< XIndexReplace > xIndexReplace;
sal_Int32 nIndex = lcl_PyNumber_AsSal_Int32( pKey );
if ( nIndex == -1 && PyErr_Occurred() )
return 0;
bool isTuple = false;
Any aValue;
if ( pValue != nullptr )
{
isTuple = PyTuple_Check( pValue );
try
{
aValue = runtime.pyObject2Any( pValue );
}
catch ( const css::uno::RuntimeException & )
{
// TODO pyObject2Any can't convert e.g. dicts but only throws
// RuntimeException on failure. Fixing this will require an audit of
// all the rest of PyUNO
throw css::script::CannotConvertException();
}
}
{
PyThreadDetach antiguard;
xIndexContainer.set( me->members->xInvocation, UNO_QUERY );
if ( xIndexContainer.is() )
xIndexReplace = xIndexContainer;
else
xIndexReplace.set( me->members->xInvocation, UNO_QUERY );
if ( xIndexReplace.is() && nIndex < 0 )
nIndex += xIndexReplace->getCount();
// XIndexReplace replace by index
if ( (pValue != nullptr) && xIndexReplace.is() )
{
if ( isTuple )
{
// Apply type specialisation to ensure the correct kind of sequence is passed
Type aType = xIndexReplace->getElementType();
aValue = runtime.getImpl()->cargo->xTypeConverter->convertTo( aValue, aType );
}
xIndexReplace->replaceByIndex( nIndex, aValue );
return 0;
}
// XIndexContainer remove by index
if ( (pValue == nullptr) && xIndexContainer.is() )
{
xIndexContainer->removeByIndex( nIndex );
return 0;
}
}
PyErr_SetString( PyExc_TypeError, "cannot assign to object" );
return -1;
}
static int lcl_setitem_slice( PyUNO const *me, PyObject *pKey, PyObject *pValue )
{
// XIndexContainer insert/remove/replace by slice
Runtime runtime;
Reference< XIndexReplace > xIndexReplace;
Reference< XIndexContainer > xIndexContainer;
sal_Int32 nLen = 0;
{
PyThreadDetach antiguard;
xIndexContainer.set( me->members->xInvocation, UNO_QUERY );
if ( xIndexContainer.is() )
xIndexReplace = xIndexContainer;
else
xIndexReplace.set( me->members->xInvocation, UNO_QUERY );
if ( xIndexReplace.is() )
nLen = xIndexReplace->getCount();
}
if ( xIndexReplace.is() )
{
sal_Int32 nStart = 0, nStop = 0, nStep = 0, nSliceLength = 0;
int nSuccess = lcl_PySlice_GetIndicesEx( pKey, nLen, &nStart, &nStop, &nStep, &nSliceLength );
if ( (nSuccess == -1) && PyErr_Occurred() )
return 0;
if ( pValue == nullptr )
{
pValue = PyTuple_New( 0 );
}
if ( !PyTuple_Check (pValue) )
{
PyErr_SetString( PyExc_TypeError, "value is not a tuple" );
return -1;
}
Py_ssize_t nTupleLength_ssize = PyTuple_Size( pValue );
if ( nTupleLength_ssize > SAL_MAX_INT32 )
{
PyErr_SetString( PyExc_ValueError, "tuple too large" );
return -1;
}
sal_Int32 nTupleLength = static_cast<sal_Int32>(nTupleLength_ssize);
if ( (nTupleLength != nSliceLength) && (nStep != 1) )
{
PyErr_SetString( PyExc_ValueError, "number of items assigned must be equal" );
return -1;
}
if ( (nTupleLength != nSliceLength) && !xIndexContainer.is() )
{
PyErr_SetString( PyExc_ValueError, "cannot change length" );
return -1;
}
sal_Int32 nCur, i;
sal_Int32 nMax = ::std::max( nSliceLength, nTupleLength );
for ( nCur = nStart, i = 0; i < nMax; nCur += nStep, i++ )
{
if ( i < nTupleLength )
{
PyRef rItem = PyTuple_GetItem( pValue, i );
bool isTuple = PyTuple_Check( rItem.get() );
Any aItem;
try
{
aItem = runtime.pyObject2Any( rItem.get() );
}
catch ( const css::uno::RuntimeException & )
{
// TODO pyObject2Any can't convert e.g. dicts but only throws
// RuntimeException on failure. Fixing this will require an audit of
// all the rest of PyUNO
throw css::script::CannotConvertException();
}
{
PyThreadDetach antiguard;
if ( isTuple )
{
// Apply type specialisation to ensure the correct kind of sequence is passed
Type aType = xIndexReplace->getElementType();
aItem = runtime.getImpl()->cargo->xTypeConverter->convertTo( aItem, aType );
}
if ( i < nSliceLength )
{
xIndexReplace->replaceByIndex( nCur, aItem );
}
else
{
xIndexContainer->insertByIndex( nCur, aItem );
}
}
}
else
{
PyThreadDetach antiguard;
xIndexContainer->removeByIndex( nCur );
nCur--;
}
}
return 0;
}
PyErr_SetString( PyExc_TypeError, "cannot assign to object" );
return -1;
}
static int lcl_setitem_string( PyUNO const *me, PyObject *pKey, PyObject *pValue )
{
Runtime runtime;
OUString sKey = pyString2ustring( pKey );
bool isTuple = false;
Any aValue;
if ( pValue != nullptr)
{
isTuple = PyTuple_Check( pValue );
try
{
aValue = runtime.pyObject2Any( pValue );
}
catch( const css::uno::RuntimeException & )
{
// TODO pyObject2Any can't convert e.g. dicts but only throws
// RuntimeException on failure. Fixing this will require an audit of
// all the rest of PyUNO
throw css::script::CannotConvertException();
}
}
{
PyThreadDetach antiguard;
Reference< XNameContainer > xNameContainer( me->members->xInvocation, UNO_QUERY );
Reference< XNameReplace > xNameReplace;
if ( xNameContainer.is() )
xNameReplace = xNameContainer;
else
xNameReplace.set( me->members->xInvocation, UNO_QUERY );
if ( xNameReplace.is() )
{
if ( isTuple && aValue.hasValue() )
{
// Apply type specialisation to ensure the correct kind of sequence is passed
Type aType = xNameReplace->getElementType();
aValue = runtime.getImpl()->cargo->xTypeConverter->convertTo( aValue, aType );
}
if ( aValue.hasValue() )
{
if ( xNameContainer.is() )
{
try {
xNameContainer->insertByName( sKey, aValue );
return 0;
}
catch( const css::container::ElementExistException & )
{
// Fall through, try replace instead
}
}
xNameReplace->replaceByName( sKey, aValue );
return 0;
}
else if ( xNameContainer.is() )
{
xNameContainer->removeByName( sKey );
return 0;
}
}
}
PyErr_SetString( PyExc_TypeError, "cannot assign to object" );
return -1;
}
static int PyUNO_setitem( PyObject *self, PyObject *pKey, PyObject *pValue )
{
PyUNO* me = reinterpret_cast<PyUNO*>(self);
try
{
if ( PyIndex_Check( pKey ) )
{
return lcl_setitem_index( me, pKey, pValue );
}
else if ( PySlice_Check( pKey ) )
{
return lcl_setitem_slice( me, pKey, pValue );
}
else if ( PyUnicode_Check( pKey ) )
{
return lcl_setitem_string( me, pKey, pValue );
}
PyErr_SetString( PyExc_TypeError, "list index has invalid type" );
}
catch( const css::lang::IndexOutOfBoundsException & )
{
PyErr_SetString( PyExc_IndexError, "list index out of range" );
}
catch( const css::container::NoSuchElementException & )
{
PyErr_SetString( PyExc_KeyError, "key not found" );
}
catch( const css::lang::IllegalArgumentException & )
{
PyErr_SetString( PyExc_TypeError, "value has invalid type" );
}
catch( const css::script::CannotConvertException & )
{
PyErr_SetString( PyExc_TypeError, "value has invalid type" );
}
catch( const css::container::ElementExistException &e )
{
raisePyExceptionWithAny( css::uno::Any( e ) );
}
catch( const css::lang::WrappedTargetException &e )
{
raisePyExceptionWithAny( css::uno::Any( e ) );
}
catch( const css::uno::RuntimeException &e )
{
raisePyExceptionWithAny( css::uno::Any( e ) );
}
return -1;
}
static PyObject* PyUNO_iter( PyObject *self )
{
PyUNO* me = reinterpret_cast<PyUNO*>(self);
try
{
Reference< XEnumerationAccess > xEnumerationAccess;
Reference< XEnumeration > xEnumeration;
Reference< XIndexAccess > xIndexAccess;
Reference< XNameAccess > xNameAccess;
{
PyThreadDetach antiguard;
xEnumerationAccess.set( me->members->xInvocation, UNO_QUERY );
if ( xEnumerationAccess.is() )
xEnumeration = xEnumerationAccess->createEnumeration();
else
xEnumeration.set( me->members->wrappedObject, UNO_QUERY );
if ( !xEnumeration.is() )
xIndexAccess.set( me->members->xInvocation, UNO_QUERY );
if ( !xIndexAccess.is() )
xNameAccess.set( me->members->xInvocation, UNO_QUERY );
}
// XEnumerationAccess iterator
// XEnumeration iterator
if (xEnumeration.is())
{
return PyUNO_iterator_new( xEnumeration );
}
// XIndexAccess iterator
if ( xIndexAccess.is() )
{
// We'd like to be able to use PySeqIter_New() here, but we're not
// allowed to because we also implement the mapping protocol
return PyUNO_list_iterator_new( xIndexAccess );
}
// XNameAccess iterator
if (xNameAccess.is())
{
// There's no generic mapping iterator, but we can cobble our own
// together using PySeqIter_New()
Runtime runtime;
Any aRet;
{
PyThreadDetach antiguard;
aRet <<= xNameAccess->getElementNames();
}
PyRef rNames = runtime.any2PyObject( aRet );
return PySeqIter_New( rNames.getAcquired() );
}
PyErr_SetString ( PyExc_TypeError, "object is not iterable" );
}
catch( css::script::CannotConvertException &e )
{
raisePyExceptionWithAny( css::uno::Any( e ) );
}
catch( css::lang::IllegalArgumentException &e )
{
raisePyExceptionWithAny( css::uno::Any( e ) );
}
catch( const css::uno::RuntimeException &e )
{
raisePyExceptionWithAny( css::uno::Any( e ) );
}
return nullptr;
}
static int PyUNO_contains( PyObject *self, PyObject *pKey )
{
PyUNO* me = reinterpret_cast<PyUNO*>(self);
Runtime runtime;
try
{
Any aValue;
try
{
aValue = runtime.pyObject2Any( pKey );
}
catch( const css::uno::RuntimeException & )
{
// TODO pyObject2Any can't convert e.g. dicts but only throws
// RuntimeException on failure. Fixing this will require an audit of
// all the rest of PyUNO
throw css::script::CannotConvertException();
}
// XNameAccess is tried first, because checking key presence is much more
// useful for objects which implement both XIndexAccess and XNameAccess
// For XNameAccess
if ( PyUnicode_Check( pKey ) )
{
OUString sKey;
aValue >>= sKey;
Reference< XNameAccess > xNameAccess;
{
PyThreadDetach antiguard;
xNameAccess.set( me->members->xInvocation, UNO_QUERY );
if ( xNameAccess.is() )
{
bool hasKey = xNameAccess->hasByName( sKey );
return hasKey ? 1 : 0;
}
}
}
// For any other type of PyUNO iterable: Ugly iterative search by
// content (XIndexAccess, XEnumerationAccess, XEnumeration)
PyRef rIterator( PyUNO_iter( self ), SAL_NO_ACQUIRE );
if ( rIterator.is() )
{
while ( PyObject* pItem = PyIter_Next( rIterator.get() ) )
{
PyRef rItem( pItem, SAL_NO_ACQUIRE );
if ( PyObject_RichCompareBool( pKey, rItem.get(), Py_EQ ) == 1 )
{
return 1;
}
}
return 0;
}
PyErr_SetString( PyExc_TypeError, "argument is not iterable" );
}
catch( const css::script::CannotConvertException& )
{
PyErr_SetString( PyExc_TypeError, "invalid type passed as left argument to 'in'" );
}
catch( const css::container::NoSuchElementException &e )
{
raisePyExceptionWithAny( css::uno::Any( e ) );
}
catch( const css::lang::IndexOutOfBoundsException &e )
{
raisePyExceptionWithAny( css::uno::Any( e ) );
}
catch( const css::lang::IllegalArgumentException &e )
{
raisePyExceptionWithAny( css::uno::Any( e ) );
}
catch( const css::lang::WrappedTargetException &e )
{
raisePyExceptionWithAny( css::uno::Any( e ) );
}
catch( const css::uno::RuntimeException &e )
{
raisePyExceptionWithAny( css::uno::Any( e ) );
}
return -1;
}
static PyObject* PyUNO_getattr (PyObject* self, char* name)
{
try
{
Runtime runtime;
PyUNO* me = reinterpret_cast<PyUNO*>(self);
if (strcmp (name, "__dict__") == 0)
{
Py_INCREF (Py_TYPE(me)->tp_dict);
return Py_TYPE(me)->tp_dict;
}
if (strcmp (name, "__class__") == 0)
{
Py_INCREF (Py_None);
return Py_None;
}
PyObject *pRet = PyObject_GenericGetAttr( self, PyUnicode_FromString( name ) );
if( pRet )
return pRet;
PyErr_Clear();
OUString attrName( OUString::createFromAscii( name ) );
//We need to find out if it's a method...
bool isMethod;
{
PyThreadDetach antiguard;
isMethod = me->members->xInvocation->hasMethod (attrName);
}
if (isMethod)
{
//Create a callable object to invoke this...
PyRef ret = PyUNO_callable_new (
me->members->xInvocation,
attrName);
Py_XINCREF( ret.get() );
return ret.get();
}
//or a property
bool isProperty;
Any anyRet;
{
PyThreadDetach antiguard;
isProperty = me->members->xInvocation->hasProperty ( attrName);
if (isProperty)
{
//Return the value of the property
anyRet = me->members->xInvocation->getValue (attrName);
}
}
if (isProperty)
{
PyRef ret = runtime.any2PyObject(anyRet);
Py_XINCREF( ret.get() );
return ret.get();
}
//or else...
PyErr_SetString (PyExc_AttributeError, name);
}
catch( const css::reflection::InvocationTargetException & e )
{
raisePyExceptionWithAny( e.TargetException );
}
catch( const css::beans::UnknownPropertyException & e )
{
raisePyExceptionWithAny( Any(e) );
}
catch( const css::lang::IllegalArgumentException &e )
{
raisePyExceptionWithAny( Any(e) );
}
catch( const css::script::CannotConvertException &e )
{
raisePyExceptionWithAny( Any(e) );
}
catch( const RuntimeException &e )
{
raisePyExceptionWithAny( Any(e) );
}
return nullptr;
}
static int PyUNO_setattr (PyObject* self, char* name, PyObject* value)
{
PyUNO* me;
me = reinterpret_cast<PyUNO*>(self);
try
{
Runtime runtime;
Any val= runtime.pyObject2Any(value, ACCEPT_UNO_ANY);
OUString attrName( OUString::createFromAscii( name ) );
{
PyThreadDetach antiguard;
if (me->members->xInvocation->hasProperty (attrName))
{
me->members->xInvocation->setValue (attrName, val);
return 0; //Keep with Python's boolean system
}
}
}
catch( const css::reflection::InvocationTargetException & e )
{
raisePyExceptionWithAny( e.TargetException );
return -1;
}
catch( const css::beans::UnknownPropertyException & e )
{
raisePyExceptionWithAny( Any(e) );
return -1;
}
catch( const css::script::CannotConvertException &e )
{
raisePyExceptionWithAny( Any(e) );
return -1;
}
catch( const RuntimeException & e )
{
raisePyExceptionWithAny( Any( e ) );
return -1;
}
PyErr_SetString (PyExc_AttributeError, name);
return -1; //as above.
}
static PyObject* PyUNO_cmp( PyObject *self, PyObject *that, int op )
{
PyObject *result;
if(op != Py_EQ && op != Py_NE)
{
PyErr_SetString(PyExc_TypeError, "only '==' and '!=' comparisons are defined");
return nullptr;
}
if( self == that )
{
result = (op == Py_EQ ? Py_True : Py_False);
Py_INCREF(result);
return result;
}
try
{
Runtime runtime;
if( PyObject_IsInstance( that, getPyUnoClass().get() ) )
{
PyUNO *me = reinterpret_cast< PyUNO*> ( self );
PyUNO *other = reinterpret_cast< PyUNO *> (that );
css::uno::TypeClass tcMe = me->members->wrappedObject.getValueTypeClass();
css::uno::TypeClass tcOther = other->members->wrappedObject.getValueTypeClass();
if( tcMe == tcOther )
{
if( me->members->wrappedObject == other->members->wrappedObject )
{
result = (op == Py_EQ ? Py_True : Py_False);
Py_INCREF(result);
return result;
}
}
}
}
catch( const css::uno::RuntimeException & e)
{
raisePyExceptionWithAny( Any( e ) );
}
result = (op == Py_EQ ? Py_False : Py_True);
Py_INCREF(result);
return result;
}
static PyMethodDef PyUNOMethods[] =
{
#if defined __clang__
#if __has_warning("-Wcast-function-type-mismatch")
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wcast-function-type-mismatch"
#endif
#endif
{"__dir__", reinterpret_cast<PyCFunction>(PyUNO_dir), METH_NOARGS, nullptr},
#if defined __clang__
#if __has_warning("-Wcast-function-type-mismatch")
#pragma clang diagnostic pop
#endif
#endif
{nullptr, nullptr, 0, nullptr}
};
static PyNumberMethods PyUNONumberMethods[] =
{
nullptr, /* nb_add */
nullptr, /* nb_subtract */
nullptr, /* nb_multiply */
nullptr, /* nb_remainder */
nullptr, /* nb_divmod */
nullptr, /* nb_power */
nullptr, /* nb_negative */
nullptr, /* nb_positive */
nullptr, /* nb_absolute */
PyUNO_bool, /* nb_bool */
nullptr, /* nb_invert */
nullptr, /* nb_lshift */
nullptr, /* nb_rshift */
nullptr, /* nb_and */
nullptr, /* nb_xor */
nullptr, /* nb_or */
nullptr, /* nb_int */
nullptr, /* nb_reserved */
nullptr, /* nb_float */
nullptr, /* nb_inplace_add */
nullptr, /* nb_inplace_subtract */
nullptr, /* nb_inplace_multiply */
nullptr, /* nb_inplace_remainder */
nullptr, /* nb_inplace_power */
nullptr, /* nb_inplace_lshift */
nullptr, /* nb_inplace_rshift */
nullptr, /* nb_inplace_and */
nullptr, /* nb_inplace_xor */
nullptr, /* nb_inplace_or */
nullptr, /* nb_floor_divide */
nullptr, /* nb_true_divide */
nullptr, /* nb_inplace_floor_divide */
nullptr, /* nb_inplace_true_divide */
nullptr, /* nb_index */
#if PY_MAJOR_VERSION == 3 && PY_MINOR_VERSION >= 5
nullptr, /* nb_matrix_multiply */
nullptr, /* nb_inplace_matrix_multiply */
#endif
};
static PySequenceMethods PyUNOSequenceMethods[] =
{
nullptr, /* sq_length */
nullptr, /* sq_concat */
nullptr, /* sq_repeat */
nullptr, /* sq_item */
nullptr, /* sq_slice */
nullptr, /* sq_ass_item */
nullptr, /* sq_ass_slice */
PyUNO_contains, /* sq_contains */
nullptr, /* sq_inplace_concat */
nullptr /* sq_inplace_repeat */
};
static PyMappingMethods PyUNOMappingMethods[] =
{
PyUNO_len, /* mp_length */
PyUNO_getitem, /* mp_subscript */
PyUNO_setitem, /* mp_ass_subscript */
};
static PyTypeObject PyUNOType =
{
PyVarObject_HEAD_INIT( &PyType_Type, 0 )
"pyuno",
sizeof (PyUNO),
0,
PyUNO_del,
#if PY_VERSION_HEX >= 0x03080000
0, // Py_ssize_t tp_vectorcall_offset
#else
nullptr, // printfunc tp_print
#endif
PyUNO_getattr,
PyUNO_setattr,
/* this type does not exist in Python 3: (cmpfunc) */ nullptr,
PyUNO_repr,
PyUNONumberMethods,
PyUNOSequenceMethods,
PyUNOMappingMethods,
PyUNO_hash,
nullptr,
PyUNO_str,
nullptr,
nullptr,
nullptr,
Py_TPFLAGS_HAVE_ITER | Py_TPFLAGS_HAVE_RICHCOMPARE | Py_TPFLAGS_HAVE_SEQUENCE_IN,
nullptr,
nullptr,
nullptr,
PyUNO_cmp,
0,
PyUNO_iter,
nullptr,
PyUNOMethods,
nullptr,
nullptr,
nullptr,
nullptr,
nullptr,
nullptr,
0,
nullptr,
nullptr,
nullptr,
nullptr,
nullptr,
nullptr,
nullptr,
nullptr,
nullptr,
nullptr,
nullptr
, 0
#if PY_VERSION_HEX >= 0x03040000
, nullptr
#if PY_VERSION_HEX >= 0x03080000
, nullptr // vectorcallfunc tp_vectorcall
#if PY_VERSION_HEX < 0x03090000
#if defined __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wdeprecated-declarations"
#endif
, nullptr // tp_print
#if defined __clang__
#pragma clang diagnostic pop
#endif
#endif
#if PY_VERSION_HEX >= 0x030C00A1
, 0 // tp_watched
#endif
#endif
#endif
};
int PyUNO_initType()
{
return PyType_Ready(&PyUNOType);
}
PyRef getPyUnoClass()
{
return PyRef( reinterpret_cast< PyObject * > ( &PyUNOType ) );
}
PyRef PyUNO_new (
const Any &targetInterface,
const Reference<XSingleServiceFactory> &ssf )
{
Reference<XInvocation2> xInvocation;
{
PyThreadDetach antiguard;
xInvocation.set(
ssf->createInstanceWithArguments( Sequence<Any>( &targetInterface, 1 ) ), css::uno::UNO_QUERY_THROW );
auto that = comphelper::getFromUnoTunnel<Adapter>(
xInvocation->getIntrospection()->queryAdapter(cppu::UnoType<XUnoTunnel>::get()));
if( that )
return that->getWrappedObject();
}
if( !Py_IsInitialized() )
throw RuntimeException();
PyUNO* self = PyObject_New (PyUNO, &PyUNOType);
if (self == nullptr)
return PyRef(); // == error
self->members = new PyUNOInternals;
self->members->xInvocation = xInvocation;
self->members->wrappedObject = targetInterface;
return PyRef( reinterpret_cast<PyObject*>(self), SAL_NO_ACQUIRE );
}
}
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
Reference in a new issue View git blame Copy permalink