pyuno/source/module/pyuno_except.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: pyuno_except.cxx,v $
  10  * $Revision: 1.5 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30 #include "pyuno_impl.hxx"
  31
  32 #include <rtl/ustrbuf.hxx>
  33
  34 #include <typelib/typedescription.hxx>
  35
  36 using rtl::OUString;
  37 using rtl::OUStringBuffer;
  38 using rtl::OUStringToOString;
  39
  40 using com::sun::star::uno::RuntimeException;
  41 using com::sun::star::uno::Sequence;
  42 using com::sun::star::uno::Type;
  43 using com::sun::star::uno::Reference;
  44 using com::sun::star::uno::XInterface;
  45 using com::sun::star::uno::TypeDescription;
  46
  47 namespace pyuno
  48 {
  49
  50 void raisePyExceptionWithAny( const com::sun::star::uno::Any &anyExc )
  51 {
  52     try
  53     {
  54         Runtime runtime;
  55         PyRef exc = runtime.any2PyObject( anyExc );
  56         if( exc.is() )
  57         {
  58             PyRef type( getClass( anyExc.getValueType().getTypeName(),runtime ) );
  59             PyErr_SetObject( type.get(), exc.get());
  60         }
  61         else
  62         {
  63             com::sun::star::uno::Exception e;
  64             anyExc >>= e;
  65
  66             OUStringBuffer buf;
  67             buf.appendAscii( "Couldn't convert uno exception to a python exception (" );
  68             buf.append(anyExc.getValueType().getTypeName());
  69             buf.appendAscii( ": " );
  70             buf.append(e.Message );
  71             buf.appendAscii( ")" );
  72             PyErr_SetString(
  73                 PyExc_SystemError,
  74                 OUStringToOString(buf.makeStringAndClear(),RTL_TEXTENCODING_ASCII_US) );
  75         }
  76     }
  77     catch( com::sun::star::lang::IllegalArgumentException & e)
  78     {
  79         PyErr_SetString( PyExc_SystemError,
  80                          OUStringToOString( e.Message, RTL_TEXTENCODING_ASCII_US) );
  81     }
  82     catch( com::sun::star::script::CannotConvertException & e)
  83     {
  84         PyErr_SetString( PyExc_SystemError,
  85                          OUStringToOString( e.Message, RTL_TEXTENCODING_ASCII_US) );
  86     }
  87     catch( RuntimeException & e)
  88     {
  89         PyErr_SetString( PyExc_SystemError,
  90                          OUStringToOString( e.Message, RTL_TEXTENCODING_ASCII_US) );
  91     }
  92 }
  93
  94
  95 static PyRef createClass( const OUString & name, const Runtime &runtime )
  96     throw ( RuntimeException )
  97 {
  98     // assuming that this is never deleted !
  99     // note I don't have the knowledge how to initialize these type objects correctly !
 100     TypeDescription desc( name );
 101     if( ! desc.is() )
 102     {
 103         OUStringBuffer buf;
 104         buf.appendAscii( "pyuno.getClass: uno exception " );
 105         buf.append(name).appendAscii( " is unknown" );
 106         throw RuntimeException( buf.makeStringAndClear(), Reference< XInterface > () );
 107     }
 108
 109     sal_Bool isStruct = desc.get()->eTypeClass == typelib_TypeClass_STRUCT;
 110     sal_Bool isExc = desc.get()->eTypeClass == typelib_TypeClass_EXCEPTION;
 111     sal_Bool isInterface = desc.get()->eTypeClass == typelib_TypeClass_INTERFACE;
 112     if( !isStruct  && !isExc && ! isInterface )
 113     {
 114         OUStringBuffer buf;
 115         buf.appendAscii( "pyuno.getClass: " ).append(name).appendAscii( "is a " );
 116         buf.appendAscii(
 117             typeClassToString( (com::sun::star::uno::TypeClass) desc.get()->eTypeClass));
 118         buf.appendAscii( ", expected EXCEPTION, STRUCT or INTERFACE" );
 119         throw RuntimeException( buf.makeStringAndClear(), Reference< XInterface>() );
 120     }
 121
 122     // retrieve base class
 123     PyRef base;
 124     if( isInterface )
 125     {
 126         typelib_InterfaceTypeDescription *pDesc = (typelib_InterfaceTypeDescription * )desc.get();
 127         if( pDesc->pBaseTypeDescription )
 128         {
 129             base = getClass( pDesc->pBaseTypeDescription->aBase.pTypeName, runtime );
 130         }
 131         else
 132         {
 133             // must be XInterface !
 134         }
 135     }
 136     else
 137     {
 138         typelib_CompoundTypeDescription *pDesc = (typelib_CompoundTypeDescription*)desc.get();
 139         if( pDesc->pBaseTypeDescription )
 140         {
 141             base = getClass( pDesc->pBaseTypeDescription->aBase.pTypeName, runtime );
 142         }
 143         else
 144         {
 145             if( isExc )
 146                 // we are currently creating the root UNO exception
 147                 base = PyRef(PyExc_Exception);
 148         }
 149     }
 150     PyRef args( PyTuple_New( 3 ), SAL_NO_ACQUIRE );
 151
 152     PyRef pyTypeName = ustring2PyString( name /*.replace( '.', '_' )*/ );
 153
 154     PyRef bases;
 155     if( base.is() )
 156     {
 157         { // for CC, keeping ref-count being 1
 158         bases = PyRef( PyTuple_New( 1 ), SAL_NO_ACQUIRE );
 159         }
 160         PyTuple_SetItem( bases.get(), 0 , base.getAcquired() );
 161     }
 162     else
 163     {
 164         bases = PyRef( PyTuple_New( 0 ), SAL_NO_ACQUIRE );
 165     }
 166
 167     PyTuple_SetItem( args.get(), 0, pyTypeName.getAcquired());
 168     PyTuple_SetItem( args.get(), 1, bases.getAcquired() );
 169     PyTuple_SetItem( args.get(), 2, PyDict_New() );
 170
 171     PyRef ret(
 172         PyObject_CallObject(reinterpret_cast<PyObject *>(&PyClass_Type) , args.get()),
 173         SAL_NO_ACQUIRE );
 174
 175     // now overwrite ctor and attrib functions
 176     if( isInterface )
 177     {
 178         PyObject_SetAttrString(
 179             ret.get(), const_cast< char * >("__pyunointerface__"),
 180             ustring2PyString(name).get() );
 181     }
 182     else
 183     {
 184         PyRef ctor = getObjectFromUnoModule( runtime,"_uno_struct__init__" );
 185         PyRef setter = getObjectFromUnoModule( runtime,"_uno_struct__setattr__" );
 186         PyRef getter = getObjectFromUnoModule( runtime,"_uno_struct__getattr__" );
 187         PyRef repr = getObjectFromUnoModule( runtime,"_uno_struct__repr__" );
 188         PyRef eq = getObjectFromUnoModule( runtime,"_uno_struct__eq__" );
 189
 190         PyObject_SetAttrString(
 191             ret.get(), const_cast< char * >("__pyunostruct__"),
 192             ustring2PyString(name).get() );
 193         PyObject_SetAttrString(
 194             ret.get(), const_cast< char * >("typeName"),
 195             ustring2PyString(name).get() );
 196         PyObject_SetAttrString(
 197             ret.get(), const_cast< char * >("__init__"), ctor.get() );
 198         PyObject_SetAttrString(
 199             ret.get(), const_cast< char * >("__getattr__"), getter.get() );
 200         PyObject_SetAttrString(
 201             ret.get(), const_cast< char * >("__setattr__"), setter.get() );
 202         PyObject_SetAttrString(
 203             ret.get(), const_cast< char * >("__repr__"), repr.get() );
 204         PyObject_SetAttrString(
 205             ret.get(), const_cast< char * >("__str__"), repr.get() );
 206         PyObject_SetAttrString(
 207             ret.get(), const_cast< char * >("__eq__"), eq.get() );
 208     }
 209     return ret;
 210 }
 211
 212 bool isInstanceOfStructOrException( PyObject *obj)
 213 {
 214     PyRef attr(
 215         PyObject_GetAttrString(obj, const_cast< char * >("__class__")),
 216         SAL_NO_ACQUIRE );
 217     return PyObject_HasAttrString(
 218         attr.get(), const_cast< char * >("__pyunostruct__"));
 219 }
 220
 221 sal_Bool isInterfaceClass( const Runtime &runtime, PyObject * obj )
 222 {
 223     const ClassSet & set = runtime.getImpl()->cargo->interfaceSet;
 224     return set.find( obj ) != set.end();
 225 }
 226
 227 PyRef getClass( const OUString & name , const Runtime &runtime)
 228 {
 229     PyRef ret;
 230
 231     RuntimeCargo *cargo =runtime.getImpl()->cargo;
 232     ExceptionClassMap::iterator ii = cargo->exceptionMap.find( name );
 233     if( ii == cargo->exceptionMap.end() )
 234     {
 235         ret = createClass( name, runtime );
 236         cargo->exceptionMap[name] = ret;
 237         if( PyObject_HasAttrString(
 238                 ret.get(), const_cast< char * >("__pyunointerface__") ) )
 239             cargo->interfaceSet.insert( ret );
 240
 241         PyObject_SetAttrString(
 242             ret.get(), const_cast< char * >("__pyunointerface__"),
 243             ustring2PyString(name).get() );
 244     }
 245     else
 246     {
 247         ret = ii->second;
 248     }
 249
 250     return ret;
 251 }
 252
 253
 254 }