Line data Source code
1 : /* -*- Mode: C++; eval:(c-set-style "bsd"); 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 : #include <config_features.h>
21 : #include <config_folders.h>
22 :
23 : #include "pyuno_impl.hxx"
24 :
25 : #include <unordered_map>
26 : #include <utility>
27 :
28 : #include <osl/module.hxx>
29 : #include <osl/thread.h>
30 : #include <osl/file.hxx>
31 :
32 : #include <typelib/typedescription.hxx>
33 :
34 : #include <rtl/ustring.hxx>
35 : #include <rtl/strbuf.hxx>
36 : #include <rtl/ustrbuf.hxx>
37 : #include <rtl/uuid.h>
38 : #include <rtl/bootstrap.hxx>
39 :
40 : #include <uno/current_context.hxx>
41 : #include <cppuhelper/bootstrap.hxx>
42 :
43 : #include <com/sun/star/lang/XMultiServiceFactory.hpp>
44 : #include <com/sun/star/reflection/XConstantTypeDescription.hpp>
45 : #include <com/sun/star/reflection/XIdlReflection.hpp>
46 : #include <com/sun/star/reflection/XIdlClass.hpp>
47 : #include <com/sun/star/registry/InvalidRegistryException.hpp>
48 :
49 : using osl::Module;
50 :
51 :
52 : using com::sun::star::uno::Sequence;
53 : using com::sun::star::uno::Reference;
54 : using com::sun::star::uno::XInterface;
55 : using com::sun::star::uno::Any;
56 : using com::sun::star::uno::makeAny;
57 : using com::sun::star::uno::UNO_QUERY;
58 : using com::sun::star::uno::RuntimeException;
59 : using com::sun::star::uno::TypeDescription;
60 : using com::sun::star::uno::XComponentContext;
61 : using com::sun::star::container::NoSuchElementException;
62 : using com::sun::star::reflection::XIdlReflection;
63 : using com::sun::star::reflection::XIdlClass;
64 : using com::sun::star::script::XInvocation2;
65 :
66 : using namespace pyuno;
67 :
68 : namespace {
69 :
70 : /**
71 : @ index of the next to be used member in the initializer list !
72 : */
73 : // LEM TODO: export member names as keyword arguments in initialiser?
74 : // Python supports very flexible variadic functions. By marking
75 : // variables with one asterisk (e.g. *var) the given variable is
76 : // defined to be a tuple of all the extra arguments. By marking
77 : // variables with two asterisks (e.g. **var) the given variable is a
78 : // dictionary of all extra keyword arguments; the keys are strings,
79 : // which are the names that were used to identify the arguments. If
80 : // they exist, these arguments must be the last one in the list.
81 :
82 : class fillStructState
83 : {
84 : // Keyword arguments used
85 : PyObject *used;
86 : // Which structure members are initialised
87 : std::unordered_map <OUString, bool, OUStringHash> initialised;
88 : // How many positional arguments are consumed
89 : // This is always the so-many first ones
90 : sal_Int32 nPosConsumed;
91 :
92 : public:
93 31 : fillStructState()
94 31 : : used (PyDict_New())
95 : , initialised ()
96 31 : , nPosConsumed (0)
97 : {
98 31 : if ( ! used )
99 0 : throw RuntimeException("pyuno._createUnoStructHelper failed to create new dictionary");
100 31 : }
101 31 : ~fillStructState()
102 31 : {
103 31 : Py_DECREF(used);
104 31 : }
105 0 : int setUsed(PyObject *key)
106 : {
107 0 : return PyDict_SetItem(used, key, Py_True);
108 : }
109 132 : void setInitialised(const OUString& key, sal_Int32 pos = -1)
110 : {
111 132 : if (initialised[key])
112 : {
113 0 : OUStringBuffer buf;
114 0 : buf.appendAscii( "pyuno._createUnoStructHelper: member '");
115 0 : buf.append(key);
116 0 : buf.appendAscii( "'");
117 0 : if ( pos >= 0 )
118 : {
119 0 : buf.appendAscii( " at position ");
120 0 : buf.append(pos);
121 : }
122 0 : buf.appendAscii( " initialised multiple times.");
123 0 : throw RuntimeException(buf.makeStringAndClear());
124 : }
125 132 : initialised[key] = true;
126 132 : if ( pos >= 0 )
127 132 : ++nPosConsumed;
128 132 : }
129 132 : bool isInitialised(const OUString& key)
130 : {
131 132 : return initialised[key];
132 : }
133 31 : PyObject *getUsed() const
134 : {
135 31 : return used;
136 : }
137 198 : sal_Int32 getCntConsumed() const
138 : {
139 198 : return nPosConsumed;
140 : }
141 : };
142 :
143 35 : static void fillStruct(
144 : const Reference< XInvocation2 > &inv,
145 : typelib_CompoundTypeDescription *pCompType,
146 : PyObject *initializer,
147 : PyObject *kwinitializer,
148 : fillStructState &state,
149 : const Runtime &runtime) throw ( RuntimeException )
150 : {
151 35 : if( pCompType->pBaseTypeDescription )
152 4 : fillStruct( inv, pCompType->pBaseTypeDescription, initializer, kwinitializer, state, runtime );
153 :
154 35 : const sal_Int32 nMembers = pCompType->nMembers;
155 : {
156 167 : for( int i = 0 ; i < nMembers ; i ++ )
157 : {
158 132 : const OUString OUMemberName (pCompType->ppMemberNames[i]);
159 : PyObject *pyMemberName =
160 : PyStr_FromString(OUStringToOString(OUMemberName,
161 132 : RTL_TEXTENCODING_UTF8).getStr());
162 132 : if ( PyObject *element = PyDict_GetItem(kwinitializer, pyMemberName ) )
163 : {
164 0 : state.setInitialised(OUMemberName);
165 0 : state.setUsed(pyMemberName);
166 0 : Any a = runtime.pyObject2Any( element, ACCEPT_UNO_ANY );
167 0 : inv->setValue( OUMemberName, a );
168 : }
169 132 : }
170 : }
171 : {
172 35 : const int remainingPosInitialisers = PyTuple_Size(initializer) - state.getCntConsumed();
173 167 : for( int i = 0 ; i < remainingPosInitialisers && i < nMembers ; i ++ )
174 : {
175 132 : const int tupleIndex = state.getCntConsumed();
176 132 : const OUString pMemberName (pCompType->ppMemberNames[i]);
177 132 : state.setInitialised(pMemberName, tupleIndex);
178 132 : PyObject *element = PyTuple_GetItem( initializer, tupleIndex );
179 264 : Any a = runtime.pyObject2Any( element, ACCEPT_UNO_ANY );
180 132 : inv->setValue( pMemberName, a );
181 132 : }
182 : }
183 167 : for ( int i = 0; i < nMembers ; ++i)
184 : {
185 132 : const OUString memberName (pCompType->ppMemberNames[i]);
186 132 : if ( ! state.isInitialised( memberName ) )
187 : {
188 0 : OUStringBuffer buf;
189 0 : buf.appendAscii( "pyuno._createUnoStructHelper: member '");
190 0 : buf.append(memberName);
191 0 : buf.appendAscii( "' of struct type '");
192 0 : buf.append(pCompType->aBase.pTypeName);
193 0 : buf.appendAscii( "' not given a value.");
194 0 : throw RuntimeException(buf.makeStringAndClear());
195 : }
196 132 : }
197 35 : }
198 :
199 17 : OUString getLibDir()
200 : {
201 : static OUString *pLibDir;
202 17 : if( !pLibDir )
203 : {
204 3 : osl::MutexGuard guard( osl::Mutex::getGlobalMutex() );
205 3 : if( ! pLibDir )
206 : {
207 3 : static OUString libDir;
208 :
209 : // workarounds the $(ORIGIN) until it is available
210 3 : if( Module::getUrlFromAddress(
211 : reinterpret_cast< oslGenericFunction >(getLibDir), libDir ) )
212 : {
213 3 : libDir = OUString( libDir.getStr(), libDir.lastIndexOf('/' ) );
214 3 : OUString name ( "PYUNOLIBDIR" );
215 3 : rtl_bootstrap_set( name.pData, libDir.pData );
216 : }
217 3 : pLibDir = &libDir;
218 3 : }
219 : }
220 17 : return *pLibDir;
221 : }
222 :
223 0 : void raisePySystemException( const char * exceptionType, const OUString & message )
224 : {
225 0 : OStringBuffer buf;
226 0 : buf.append( "Error during bootstrapping uno (");
227 0 : buf.append( exceptionType );
228 0 : buf.append( "):" );
229 0 : buf.append( OUStringToOString( message, osl_getThreadTextEncoding() ) );
230 0 : PyErr_SetString( PyExc_SystemError, buf.makeStringAndClear().getStr() );
231 0 : }
232 :
233 : extern "C" {
234 :
235 17 : static PyObject* getComponentContext(
236 : SAL_UNUSED_PARAMETER PyObject*, SAL_UNUSED_PARAMETER PyObject*)
237 : {
238 17 : PyRef ret;
239 : try
240 : {
241 17 : Reference<XComponentContext> ctx;
242 :
243 : // getLibDir() must be called in order to set bootstrap variables correctly !
244 34 : OUString path( getLibDir());
245 17 : if( Runtime::isInitialized() )
246 : {
247 15 : Runtime runtime;
248 15 : ctx = runtime.getImpl()->cargo->xContext;
249 : }
250 : else
251 : {
252 2 : OUString iniFile;
253 2 : if( path.isEmpty() )
254 : {
255 : PyErr_SetString(
256 : PyExc_RuntimeError, "osl_getUrlFromAddress fails, that's why I cannot find ini "
257 0 : "file for bootstrapping python uno bridge\n" );
258 0 : return NULL;
259 : }
260 :
261 4 : OUStringBuffer iniFileName;
262 2 : iniFileName.append( path );
263 : #ifdef MACOSX
264 : iniFileName.appendAscii( "/../" LIBO_ETC_FOLDER );
265 : #endif
266 2 : iniFileName.appendAscii( "/" );
267 2 : iniFileName.appendAscii( SAL_CONFIGFILE( "pyuno" ) );
268 2 : iniFile = iniFileName.makeStringAndClear();
269 4 : osl::DirectoryItem item;
270 2 : if( osl::DirectoryItem::get( iniFile, item ) == item.E_None )
271 : {
272 : // in case pyuno.ini exists, use this file for bootstrapping
273 0 : PyThreadDetach antiguard;
274 0 : ctx = cppu::defaultBootstrap_InitialComponentContext (iniFile);
275 : }
276 : else
277 : {
278 : // defaulting to the standard bootstrapping
279 2 : PyThreadDetach antiguard;
280 2 : ctx = cppu::defaultBootstrap_InitialComponentContext ();
281 2 : }
282 :
283 : }
284 :
285 17 : if( ! Runtime::isInitialized() )
286 : {
287 2 : Runtime::initialize( ctx );
288 : }
289 34 : Runtime runtime;
290 34 : ret = runtime.any2PyObject( makeAny( ctx ) );
291 : }
292 0 : catch (const com::sun::star::registry::InvalidRegistryException &e)
293 : {
294 : // can't use raisePyExceptionWithAny() here, because the function
295 : // does any conversions, which will not work with a
296 : // wrongly bootstrapped pyuno!
297 0 : raisePySystemException( "InvalidRegistryException", e.Message );
298 : }
299 0 : catch(const com::sun::star::lang::IllegalArgumentException & e)
300 : {
301 0 : raisePySystemException( "IllegalArgumentException", e.Message );
302 : }
303 0 : catch(const com::sun::star::script::CannotConvertException & e)
304 : {
305 0 : raisePySystemException( "CannotConvertException", e.Message );
306 : }
307 0 : catch (const com::sun::star::uno::RuntimeException & e)
308 : {
309 0 : raisePySystemException( "RuntimeException", e.Message );
310 : }
311 0 : catch (const com::sun::star::uno::Exception & e)
312 : {
313 0 : raisePySystemException( "uno::Exception", e.Message );
314 : }
315 17 : return ret.getAcquired();
316 : }
317 :
318 7 : static PyObject* initTestEnvironment(
319 : SAL_UNUSED_PARAMETER PyObject*, SAL_UNUSED_PARAMETER PyObject*)
320 : {
321 : // this tries to bootstrap enough of the soffice from python to run
322 : // unit tests, which is only possible indirectly because pyuno is URE
323 : // so load "test" library and invoke a function there to do the work
324 : try
325 : {
326 7 : PyObject *const ctx(getComponentContext(0, 0));
327 7 : if (!ctx) { abort(); }
328 7 : Runtime const runtime;
329 14 : Any const a(runtime.pyObject2Any(ctx));
330 14 : Reference<XComponentContext> xContext;
331 7 : a >>= xContext;
332 7 : if (!xContext.is()) { abort(); }
333 : using com::sun::star::lang::XMultiServiceFactory;
334 : Reference<XMultiServiceFactory> const xMSF(
335 7 : xContext->getServiceManager(),
336 14 : com::sun::star::uno::UNO_QUERY_THROW);
337 7 : if (!xMSF.is()) { abort(); }
338 7 : char *const testlib = getenv("TEST_LIB");
339 7 : if (!testlib) { abort(); }
340 14 : OString const libname = OString(testlib, strlen(testlib))
341 : #ifdef _WIN32
342 : .replaceAll(OString('/'), OString('\\'))
343 : #endif
344 : ;
345 :
346 7 : osl::Module &mod = runtime.getImpl()->cargo->testModule;
347 7 : mod.load(OStringToOUString(libname, osl_getThreadTextEncoding()),
348 7 : SAL_LOADMODULE_LAZY | SAL_LOADMODULE_GLOBAL);
349 7 : if (!mod.is()) { abort(); }
350 : oslGenericFunction const pFunc(
351 7 : mod.getFunctionSymbol("test_init"));
352 7 : if (!pFunc) { abort(); }
353 14 : reinterpret_cast<void (SAL_CALL *)(XMultiServiceFactory*)>(pFunc)(xMSF.get());
354 : }
355 0 : catch (const com::sun::star::uno::Exception &)
356 : {
357 0 : abort();
358 : }
359 7 : return Py_None;
360 : }
361 :
362 438 : PyObject * extractOneStringArg( PyObject *args, char const *funcName )
363 : {
364 438 : if( !PyTuple_Check( args ) || PyTuple_Size( args) != 1 )
365 : {
366 0 : OStringBuffer buf;
367 0 : buf.append( funcName ).append( ": expecting one string argument" );
368 0 : PyErr_SetString( PyExc_RuntimeError, buf.getStr() );
369 0 : return NULL;
370 : }
371 438 : PyObject *obj = PyTuple_GetItem( args, 0 );
372 438 : if (!PyStr_Check(obj) && !PyUnicode_Check(obj))
373 : {
374 0 : OStringBuffer buf;
375 0 : buf.append( funcName ).append( ": expecting one string argument" );
376 0 : PyErr_SetString( PyExc_TypeError, buf.getStr());
377 0 : return NULL;
378 : }
379 438 : return obj;
380 : }
381 :
382 31 : static PyObject *createUnoStructHelper(
383 : SAL_UNUSED_PARAMETER PyObject *, PyObject* args, PyObject* keywordArgs)
384 : {
385 31 : Any IdlStruct;
386 62 : PyRef ret;
387 : try
388 : {
389 31 : Runtime runtime;
390 31 : if( PyTuple_Size( args ) == 2 )
391 : {
392 31 : PyObject *structName = PyTuple_GetItem(args, 0);
393 31 : PyObject *initializer = PyTuple_GetItem(args, 1);
394 :
395 31 : if (PyStr_Check(structName))
396 : {
397 31 : if( PyTuple_Check( initializer ) && PyDict_Check ( keywordArgs ) )
398 : {
399 31 : OUString typeName( OUString::createFromAscii(PyStr_AsString(structName)));
400 31 : RuntimeCargo *c = runtime.getImpl()->cargo;
401 62 : Reference<XIdlClass> idl_class ( c->xCoreReflection->forName (typeName),UNO_QUERY);
402 31 : if (idl_class.is ())
403 : {
404 31 : idl_class->createObject (IdlStruct);
405 31 : PyUNO *me = reinterpret_cast<PyUNO*>(PyUNO_new_UNCHECKED( IdlStruct, c->xInvocation ));
406 31 : PyRef returnCandidate( reinterpret_cast<PyObject*>(me), SAL_NO_ACQUIRE );
407 62 : TypeDescription desc( typeName );
408 : OSL_ASSERT( desc.is() ); // could already instantiate an XInvocation2 !
409 :
410 : typelib_CompoundTypeDescription *pCompType =
411 31 : reinterpret_cast<typelib_CompoundTypeDescription *>(desc.get());
412 62 : fillStructState state;
413 31 : if ( PyTuple_Size( initializer ) > 0 || PyDict_Size( keywordArgs ) > 0 )
414 31 : fillStruct( me->members->xInvocation, pCompType, initializer, keywordArgs, state, runtime );
415 31 : if( state.getCntConsumed() != PyTuple_Size(initializer) )
416 : {
417 0 : OUStringBuffer buf;
418 0 : buf.appendAscii( "pyuno._createUnoStructHelper: too many ");
419 0 : buf.appendAscii( "elements in the initializer list, expected " );
420 0 : buf.append( state.getCntConsumed() );
421 0 : buf.appendAscii( ", got " );
422 0 : buf.append( (sal_Int32) PyTuple_Size(initializer) );
423 0 : throw RuntimeException( buf.makeStringAndClear());
424 : }
425 62 : ret = PyRef( PyTuple_Pack(2, returnCandidate.get(), state.getUsed()), SAL_NO_ACQUIRE);
426 : }
427 : else
428 : {
429 0 : OStringBuffer buf;
430 0 : buf.append( "UNO struct " );
431 0 : buf.append( PyStr_AsString(structName) );
432 0 : buf.append( " is unknown" );
433 0 : PyErr_SetString (PyExc_RuntimeError, buf.getStr());
434 31 : }
435 : }
436 : else
437 : {
438 : PyErr_SetString(
439 : PyExc_RuntimeError,
440 0 : "pyuno._createUnoStructHelper: 2nd argument (initializer sequence) is no tuple" );
441 : }
442 : }
443 : else
444 : {
445 0 : PyErr_SetString (PyExc_AttributeError, "createUnoStruct: first argument wasn't a string");
446 : }
447 : }
448 : else
449 : {
450 0 : PyErr_SetString (PyExc_AttributeError, "pyuno._createUnoStructHelper: expects exactly two non-keyword arguments:\n\tStructure Name\n\tinitialiser tuple; may be the empty tuple");
451 31 : }
452 : }
453 0 : catch( const com::sun::star::uno::RuntimeException & e )
454 : {
455 0 : raisePyExceptionWithAny( makeAny( e ) );
456 : }
457 0 : catch( const com::sun::star::script::CannotConvertException & e )
458 : {
459 0 : raisePyExceptionWithAny( makeAny( e ) );
460 : }
461 0 : catch( const com::sun::star::uno::Exception & e )
462 : {
463 0 : raisePyExceptionWithAny( makeAny( e ) );
464 : }
465 62 : return ret.getAcquired();
466 : }
467 :
468 23 : static PyObject *getTypeByName(
469 : SAL_UNUSED_PARAMETER PyObject *, PyObject *args )
470 : {
471 23 : PyObject * ret = NULL;
472 :
473 : try
474 : {
475 : char *name;
476 :
477 23 : if (PyArg_ParseTuple (args, "s", &name))
478 : {
479 23 : OUString typeName ( OUString::createFromAscii( name ) );
480 46 : TypeDescription typeDesc( typeName );
481 23 : if( typeDesc.is() )
482 : {
483 23 : Runtime runtime;
484 : ret = PyUNO_Type_new(
485 23 : name, (com::sun::star::uno::TypeClass)typeDesc.get()->eTypeClass, runtime );
486 : }
487 : else
488 : {
489 0 : OStringBuffer buf;
490 0 : buf.append( "Type " ).append(name).append( " is unknown" );
491 0 : PyErr_SetString( PyExc_RuntimeError, buf.getStr() );
492 23 : }
493 : }
494 : }
495 0 : catch ( const RuntimeException & e )
496 : {
497 0 : raisePyExceptionWithAny( makeAny( e ) );
498 : }
499 23 : return ret;
500 : }
501 :
502 114 : static PyObject *getConstantByName(
503 : SAL_UNUSED_PARAMETER PyObject *, PyObject *args )
504 : {
505 114 : PyObject *ret = 0;
506 : try
507 : {
508 : char *name;
509 :
510 114 : if (PyArg_ParseTuple (args, "s", &name))
511 : {
512 114 : OUString typeName ( OUString::createFromAscii( name ) );
513 228 : Runtime runtime;
514 228 : css::uno::Reference< css::reflection::XConstantTypeDescription > td;
515 340 : if (!(runtime.getImpl()->cargo->xTdMgr->getByHierarchicalName(
516 114 : typeName)
517 227 : >>= td))
518 : {
519 0 : OUStringBuffer buf;
520 0 : buf.appendAscii( "pyuno.getConstantByName: " ).append( typeName );
521 0 : buf.appendAscii( "is not a constant" );
522 0 : throw RuntimeException(buf.makeStringAndClear() );
523 : }
524 226 : PyRef constant = runtime.any2PyObject( td->getConstantValue() );
525 227 : ret = constant.getAcquired();
526 : }
527 : }
528 2 : catch( const NoSuchElementException & e )
529 : {
530 : // to the python programmer, this is a runtime exception,
531 : // do not support tweakings with the type system
532 1 : RuntimeException runExc( e.Message );
533 1 : raisePyExceptionWithAny( makeAny( runExc ) );
534 : }
535 0 : catch(const com::sun::star::script::CannotConvertException & e)
536 : {
537 0 : raisePyExceptionWithAny( makeAny( e ) );
538 : }
539 0 : catch(const com::sun::star::lang::IllegalArgumentException & e)
540 : {
541 0 : raisePyExceptionWithAny( makeAny( e ) );
542 : }
543 0 : catch( const RuntimeException & e )
544 : {
545 0 : raisePyExceptionWithAny( makeAny(e) );
546 : }
547 114 : return ret;
548 : }
549 :
550 23 : static PyObject *checkType( SAL_UNUSED_PARAMETER PyObject *, PyObject *args )
551 : {
552 23 : if( !PyTuple_Check( args ) || PyTuple_Size( args) != 1 )
553 : {
554 0 : OStringBuffer buf;
555 0 : buf.append( "pyuno.checkType : expecting one uno.Type argument" );
556 0 : PyErr_SetString( PyExc_RuntimeError, buf.getStr() );
557 0 : return NULL;
558 : }
559 23 : PyObject *obj = PyTuple_GetItem( args, 0 );
560 :
561 : try
562 : {
563 23 : PyType2Type( obj );
564 : }
565 0 : catch(const RuntimeException & e)
566 : {
567 0 : raisePyExceptionWithAny( makeAny( e ) );
568 0 : return NULL;
569 : }
570 23 : Py_INCREF( Py_None );
571 23 : return Py_None;
572 : }
573 :
574 168 : static PyObject *checkEnum( SAL_UNUSED_PARAMETER PyObject *, PyObject *args )
575 : {
576 168 : if( !PyTuple_Check( args ) || PyTuple_Size( args) != 1 )
577 : {
578 0 : OStringBuffer buf;
579 0 : buf.append( "pyuno.checkType : expecting one uno.Type argument" );
580 0 : PyErr_SetString( PyExc_RuntimeError, buf.getStr() );
581 0 : return NULL;
582 : }
583 168 : PyObject *obj = PyTuple_GetItem( args, 0 );
584 :
585 : try
586 : {
587 168 : PyEnum2Enum( obj );
588 : }
589 110 : catch(const RuntimeException & e)
590 : {
591 110 : raisePyExceptionWithAny( makeAny( e) );
592 110 : return NULL;
593 : }
594 58 : Py_INCREF( Py_None );
595 58 : return Py_None;
596 : }
597 :
598 438 : static PyObject *getClass( SAL_UNUSED_PARAMETER PyObject *, PyObject *args )
599 : {
600 438 : PyObject *obj = extractOneStringArg( args, "pyuno.getClass");
601 438 : if( ! obj )
602 0 : return NULL;
603 :
604 : try
605 : {
606 438 : Runtime runtime;
607 876 : PyRef ret = getClass(pyString2ustring(obj), runtime);
608 298 : Py_XINCREF( ret.get() );
609 736 : return ret.get();
610 : }
611 140 : catch(const RuntimeException & e)
612 : {
613 140 : raisePyExceptionWithAny( makeAny(e) );
614 : }
615 140 : return NULL;
616 : }
617 :
618 31 : static PyObject *isInterface( SAL_UNUSED_PARAMETER PyObject *, PyObject *args )
619 : {
620 :
621 31 : if( PyTuple_Check( args ) && PyTuple_Size( args ) == 1 )
622 : {
623 31 : PyObject *obj = PyTuple_GetItem( args, 0 );
624 31 : Runtime r;
625 31 : return PyLong_FromLong( isInterfaceClass( r, obj ) );
626 : }
627 0 : return PyLong_FromLong( 0 );
628 : }
629 :
630 0 : static PyObject * generateUuid(
631 : SAL_UNUSED_PARAMETER PyObject *, SAL_UNUSED_PARAMETER PyObject * )
632 : {
633 0 : Sequence< sal_Int8 > seq( 16 );
634 0 : rtl_createUuid( reinterpret_cast<sal_uInt8*>(seq.getArray()) , 0 , sal_False );
635 0 : PyRef ret;
636 : try
637 : {
638 0 : Runtime runtime;
639 0 : ret = runtime.any2PyObject( makeAny( seq ) );
640 : }
641 0 : catch( const RuntimeException & e )
642 : {
643 0 : raisePyExceptionWithAny( makeAny(e) );
644 : }
645 0 : return ret.getAcquired();
646 : }
647 :
648 0 : static PyObject *systemPathToFileUrl(
649 : SAL_UNUSED_PARAMETER PyObject *, PyObject * args )
650 : {
651 0 : PyObject *obj = extractOneStringArg( args, "pyuno.systemPathToFileUrl" );
652 0 : if( ! obj )
653 0 : return NULL;
654 :
655 0 : OUString sysPath = pyString2ustring( obj );
656 0 : OUString url;
657 0 : osl::FileBase::RC e = osl::FileBase::getFileURLFromSystemPath( sysPath, url );
658 :
659 0 : if( e != osl::FileBase::E_None )
660 : {
661 0 : OUStringBuffer buf;
662 0 : buf.appendAscii( "Couldn't convert " );
663 0 : buf.append( sysPath );
664 0 : buf.appendAscii( " to a file url for reason (" );
665 0 : buf.append( (sal_Int32) e );
666 0 : buf.appendAscii( ")" );
667 : raisePyExceptionWithAny(
668 0 : makeAny( RuntimeException( buf.makeStringAndClear() )));
669 0 : return NULL;
670 : }
671 0 : return ustring2PyUnicode( url ).getAcquired();
672 : }
673 :
674 0 : static PyObject * fileUrlToSystemPath(
675 : SAL_UNUSED_PARAMETER PyObject *, PyObject * args )
676 : {
677 0 : PyObject *obj = extractOneStringArg( args, "pyuno.fileUrlToSystemPath" );
678 0 : if( ! obj )
679 0 : return NULL;
680 :
681 0 : OUString url = pyString2ustring( obj );
682 0 : OUString sysPath;
683 0 : osl::FileBase::RC e = osl::FileBase::getSystemPathFromFileURL( url, sysPath );
684 :
685 0 : if( e != osl::FileBase::E_None )
686 : {
687 0 : OUStringBuffer buf;
688 0 : buf.appendAscii( "Couldn't convert file url " );
689 0 : buf.append( sysPath );
690 0 : buf.appendAscii( " to a system path for reason (" );
691 0 : buf.append( (sal_Int32) e );
692 0 : buf.appendAscii( ")" );
693 : raisePyExceptionWithAny(
694 0 : makeAny( RuntimeException( buf.makeStringAndClear() )));
695 0 : return NULL;
696 : }
697 0 : return ustring2PyUnicode( sysPath ).getAcquired();
698 : }
699 :
700 0 : static PyObject * absolutize( SAL_UNUSED_PARAMETER PyObject *, PyObject * args )
701 : {
702 0 : if( PyTuple_Check( args ) && PyTuple_Size( args ) == 2 )
703 : {
704 0 : OUString ouPath = pyString2ustring( PyTuple_GetItem( args , 0 ) );
705 0 : OUString ouRel = pyString2ustring( PyTuple_GetItem( args, 1 ) );
706 0 : OUString ret;
707 0 : oslFileError e = osl_getAbsoluteFileURL( ouPath.pData, ouRel.pData, &(ret.pData) );
708 0 : if( e != osl_File_E_None )
709 : {
710 0 : OUStringBuffer buf;
711 0 : buf.appendAscii( "Couldn't absolutize " );
712 0 : buf.append( ouRel );
713 0 : buf.appendAscii( " using root " );
714 0 : buf.append( ouPath );
715 0 : buf.appendAscii( " for reason (" );
716 0 : buf.append( (sal_Int32) e );
717 0 : buf.appendAscii( ")" );
718 :
719 : PyErr_SetString(
720 : PyExc_OSError,
721 0 : OUStringToOString(buf.makeStringAndClear(),osl_getThreadTextEncoding()).getStr());
722 0 : return 0;
723 : }
724 0 : return ustring2PyUnicode( ret ).getAcquired();
725 : }
726 0 : return 0;
727 : }
728 :
729 0 : static PyObject * invoke(SAL_UNUSED_PARAMETER PyObject *, PyObject *args)
730 : {
731 0 : PyObject *ret = 0;
732 0 : if(PyTuple_Check(args) && PyTuple_Size(args) == 3)
733 : {
734 0 : PyObject *object = PyTuple_GetItem(args, 0);
735 0 : PyObject *item1 = PyTuple_GetItem(args, 1);
736 0 : if (PyStr_Check(item1))
737 : {
738 0 : const char *name = PyStr_AsString(item1);
739 0 : PyObject *item2 = PyTuple_GetItem(args, 2);
740 0 : if(PyTuple_Check(item2))
741 : {
742 0 : ret = PyUNO_invoke(object, name, item2);
743 : }
744 : else
745 : {
746 0 : OStringBuffer buf;
747 0 : buf.append("uno.invoke expects a tuple as 3rd argument, got ");
748 0 : buf.append(PyStr_AsString(PyObject_Str(item2)));
749 : PyErr_SetString(
750 0 : PyExc_RuntimeError, buf.makeStringAndClear().getStr());
751 : }
752 : }
753 : else
754 : {
755 0 : OStringBuffer buf;
756 0 : buf.append("uno.invoke expected a string as 2nd argument, got ");
757 0 : buf.append(PyStr_AsString(PyObject_Str(item1)));
758 : PyErr_SetString(
759 0 : PyExc_RuntimeError, buf.makeStringAndClear().getStr());
760 : }
761 : }
762 : else
763 : {
764 0 : OStringBuffer buf;
765 0 : buf.append("uno.invoke expects object, name, (arg1, arg2, ... )\n");
766 0 : PyErr_SetString(PyExc_RuntimeError, buf.makeStringAndClear().getStr());
767 : }
768 0 : return ret;
769 : }
770 :
771 0 : static PyObject *getCurrentContext(
772 : SAL_UNUSED_PARAMETER PyObject *, SAL_UNUSED_PARAMETER PyObject * )
773 : {
774 0 : PyRef ret;
775 : try
776 : {
777 0 : Runtime runtime;
778 0 : ret = runtime.any2PyObject(
779 0 : makeAny( com::sun::star::uno::getCurrentContext() ) );
780 : }
781 0 : catch( const com::sun::star::uno::Exception & e )
782 : {
783 0 : raisePyExceptionWithAny( makeAny( e ) );
784 : }
785 0 : return ret.getAcquired();
786 : }
787 :
788 0 : static PyObject *setCurrentContext(
789 : SAL_UNUSED_PARAMETER PyObject *, SAL_UNUSED_PARAMETER PyObject * args )
790 : {
791 0 : PyRef ret;
792 : try
793 : {
794 0 : if( PyTuple_Check( args ) && PyTuple_Size( args ) == 1 )
795 : {
796 :
797 0 : Runtime runtime;
798 0 : Any a = runtime.pyObject2Any( PyTuple_GetItem( args, 0 ) );
799 :
800 0 : Reference< com::sun::star::uno::XCurrentContext > context;
801 :
802 0 : if( (a.hasValue() && (a >>= context)) || ! a.hasValue() )
803 : {
804 0 : ret = com::sun::star::uno::setCurrentContext( context ) ? Py_True : Py_False;
805 : }
806 : else
807 : {
808 0 : OStringBuffer buf;
809 0 : buf.append( "uno.setCurrentContext expects an XComponentContext implementation, got " );
810 : buf.append(
811 0 : PyStr_AsString(PyObject_Str(PyTuple_GetItem(args, 0))));
812 : PyErr_SetString(
813 0 : PyExc_RuntimeError, buf.makeStringAndClear().getStr() );
814 0 : }
815 : }
816 : else
817 : {
818 0 : OStringBuffer buf;
819 0 : buf.append( "uno.setCurrentContext expects exactly one argument (the current Context)\n" );
820 : PyErr_SetString(
821 0 : PyExc_RuntimeError, buf.makeStringAndClear().getStr() );
822 : }
823 : }
824 0 : catch( const com::sun::star::uno::Exception & e )
825 : {
826 0 : raisePyExceptionWithAny( makeAny( e ) );
827 : }
828 0 : return ret.getAcquired();
829 : }
830 :
831 : }
832 :
833 : struct PyMethodDef PyUNOModule_methods [] =
834 : {
835 : {"private_initTestEnvironment", initTestEnvironment, METH_VARARGS, NULL},
836 : {"getComponentContext", getComponentContext, METH_VARARGS, NULL},
837 : {"_createUnoStructHelper", reinterpret_cast<PyCFunction>(createUnoStructHelper), METH_VARARGS | METH_KEYWORDS, NULL},
838 : {"getTypeByName", getTypeByName, METH_VARARGS, NULL},
839 : {"getConstantByName", getConstantByName, METH_VARARGS, NULL},
840 : {"getClass", getClass, METH_VARARGS, NULL},
841 : {"checkEnum", checkEnum, METH_VARARGS, NULL},
842 : {"checkType", checkType, METH_VARARGS, NULL},
843 : {"generateUuid", generateUuid, METH_VARARGS, NULL},
844 : {"systemPathToFileUrl", systemPathToFileUrl, METH_VARARGS, NULL},
845 : {"fileUrlToSystemPath", fileUrlToSystemPath, METH_VARARGS, NULL},
846 : {"absolutize", absolutize, METH_VARARGS | METH_KEYWORDS, NULL},
847 : {"isInterface", isInterface, METH_VARARGS, NULL},
848 : {"invoke", invoke, METH_VARARGS | METH_KEYWORDS, NULL},
849 : {"setCurrentContext", setCurrentContext, METH_VARARGS, NULL},
850 : {"getCurrentContext", getCurrentContext, METH_VARARGS, NULL},
851 : {NULL, NULL, 0, NULL}
852 : };
853 :
854 : }
855 :
856 : extern "C"
857 : #if PY_MAJOR_VERSION >= 3
858 3 : PyObject* PyInit_pyuno()
859 : {
860 3 : PyUNO_initType();
861 : // noop when called already, otherwise needed to allow multiple threads
862 3 : PyEval_InitThreads();
863 : static struct PyModuleDef moduledef =
864 : {
865 : PyModuleDef_HEAD_INIT,
866 : "pyuno", // module name
867 : 0, // module documentation
868 : -1, // module keeps state in global variables,
869 : PyUNOModule_methods, // modules methods
870 : 0, // m_reload (must be 0)
871 : 0, // m_traverse
872 : 0, // m_clear
873 : 0, // m_free
874 : };
875 3 : return PyModule_Create(&moduledef);
876 : }
877 : #else
878 : void initpyuno()
879 : {
880 : PyUNO_initType();
881 : PyEval_InitThreads();
882 : Py_InitModule ("pyuno", PyUNOModule_methods);
883 : }
884 : #endif /* PY_MAJOR_VERSION >= 3 */
885 :
886 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
